small fixes

still dying because of HashMap. Why?

Author: ecoskey

crates/bevy_render/macros/src/specialize.rs

@@ -1,10 +1,8 @@
 use proc_macro::TokenStream;
-use proc_macro2::TokenStream as TokenStream2;
-use quote::{format_ident, quote, ToTokens};
+use quote::{format_ident, quote};
 use syn::{
-    parse::Parse, parse_macro_input, parse_quote, punctuated::Punctuated, spanned::Spanned, Data,
-    DataStruct, DeriveInput, Expr, Index, Member, Meta, MetaList, MetaNameValue, Path, Stmt, Token,
-    Type,
+    parse_macro_input, parse_quote, punctuated::Punctuated, spanned::Spanned, Data, DataStruct,
+    DeriveInput, Expr, Index, Member, Meta, MetaList, MetaNameValue, Path, Stmt, Token, Type,
 };
 
 const KEY_ATTR_IDENT: &str = "key";

crates/bevy_render/src/render_resource/specialize.rs

@@ -63,7 +63,7 @@ impl<T: SpecializeTarget, S: Specialize<T>> Specializer<T, S> {
             specializer,
             user_specializer,
             base_descriptor,
-            pipelines: Default::default(),
+            pipelines: HashMap::new(),
         }
     }
 

examples/shader/custom_phase_item.rs

@@ -32,7 +32,7 @@ use bevy::{
         Render, RenderApp, RenderSet,
     },
 };
-use bevy_render::render_resource::{RenderPipeline, Specialize, Specializer};
+use bevy_render::render_resource::{HasBaseDescriptor, RenderPipeline, Specialize, Specializer};
 use bytemuck::{Pod, Zeroable};
 
 /// A marker component that represents an entity that is to be rendered using
@@ -162,16 +162,10 @@ fn main() {
         .add_plugins(ExtractComponentPlugin::<CustomRenderedEntity>::default())
         .add_systems(Startup, setup);
 
-    let base_pipeline_descriptor = base_pipeline_descriptor(app.world().resource::<AssetServer>());
-
     // We make sure to add these to the render app, not the main app.
     app.get_sub_app_mut(RenderApp)
         .unwrap()
-        .insert_resource(Specializer::new(
-            CustomPhaseSpecializer,
-            None,
-            base_pipeline_descriptor,
-        ))
+        .init_resource::<Specializer<RenderPipeline, CustomPhaseSpecializer>>()
         .add_render_command::<Opaque3d, DrawCustomPhaseItemCommands>()
         .add_systems(
             Render,
@@ -269,7 +263,21 @@ fn queue_custom_phase_item(
     }
 }
 
-struct CustomPhaseSpecializer;
+/// Holds a reference to our shader.
+///
+/// This is loaded at app creation time.
+struct CustomPhaseSpecializer {
+    shader: Handle<Shader>,
+}
+
+impl FromWorld for CustomPhaseSpecializer {
+    fn from_world(world: &mut World) -> Self {
+        let asset_server = world.resource::<AssetServer>();
+        Self {
+            shader: asset_server.load("shaders/custom_phase_item.wgsl"),
+        }
+    }
+}
 
 impl Specialize<RenderPipeline> for CustomPhaseSpecializer {
     type Key = Msaa;
@@ -279,63 +287,64 @@ impl Specialize<RenderPipeline> for CustomPhaseSpecializer {
     }
 }
 
-fn base_pipeline_descriptor(asset_server: &AssetServer) -> RenderPipelineDescriptor {
-    let shader = asset_server.load("shaders/custom_phase_item.wgsl");
-    RenderPipelineDescriptor {
-        label: Some("custom render pipeline".into()),
-        layout: vec![],
-        push_constant_ranges: vec![],
-        vertex: VertexState {
-            shader: shader.clone(),
-            shader_defs: vec![],
-            entry_point: "vertex".into(),
-            buffers: vec![VertexBufferLayout {
-                array_stride: size_of::<Vertex>() as u64,
-                step_mode: VertexStepMode::Vertex,
-                // This needs to match the layout of [`Vertex`].
-                attributes: vec![
-                    VertexAttribute {
-                        format: VertexFormat::Float32x3,
-                        offset: 0,
-                        shader_location: 0,
-                    },
-                    VertexAttribute {
-                        format: VertexFormat::Float32x3,
-                        offset: 16,
-                        shader_location: 1,
-                    },
-                ],
-            }],
-        },
-        fragment: Some(FragmentState {
-            shader,
-            shader_defs: vec![],
-            entry_point: "fragment".into(),
-            targets: vec![Some(ColorTargetState {
-                // Ordinarily, you'd want to check whether the view has the
-                // HDR format and substitute the appropriate texture format
-                // here, but we omit that for simplicity.
-                format: TextureFormat::bevy_default(),
-                blend: None,
-                write_mask: ColorWrites::ALL,
-            })],
-        }),
-        primitive: PrimitiveState::default(),
-        // Note that if your view has no depth buffer this will need to be
-        // changed.
-        depth_stencil: Some(DepthStencilState {
-            format: CORE_3D_DEPTH_FORMAT,
-            depth_write_enabled: false,
-            depth_compare: CompareFunction::Always,
-            stencil: default(),
-            bias: default(),
-        }),
-        multisample: MultisampleState {
-            count: 0,
-            mask: !0,
-            alpha_to_coverage_enabled: false,
-        },
-        zero_initialize_workgroup_memory: false,
+impl HasBaseDescriptor<RenderPipeline> for CustomPhaseSpecializer {
+    fn base_descriptor(&self) -> RenderPipelineDescriptor {
+        RenderPipelineDescriptor {
+            label: Some("custom render pipeline".into()),
+            layout: vec![],
+            push_constant_ranges: vec![],
+            vertex: VertexState {
+                shader: self.shader.clone(),
+                shader_defs: vec![],
+                entry_point: "vertex".into(),
+                buffers: vec![VertexBufferLayout {
+                    array_stride: size_of::<Vertex>() as u64,
+                    step_mode: VertexStepMode::Vertex,
+                    // This needs to match the layout of [`Vertex`].
+                    attributes: vec![
+                        VertexAttribute {
+                            format: VertexFormat::Float32x3,
+                            offset: 0,
+                            shader_location: 0,
+                        },
+                        VertexAttribute {
+                            format: VertexFormat::Float32x3,
+                            offset: 16,
+                            shader_location: 1,
+                        },
+                    ],
+                }],
+            },
+            fragment: Some(FragmentState {
+                shader: self.shader.clone(),
+                shader_defs: vec![],
+                entry_point: "fragment".into(),
+                targets: vec![Some(ColorTargetState {
+                    // Ordinarily, you'd want to check whether the view has the
+                    // HDR format and substitute the appropriate texture format
+                    // here, but we omit that for simplicity.
+                    format: TextureFormat::bevy_default(),
+                    blend: None,
+                    write_mask: ColorWrites::ALL,
+                })],
+            }),
+            primitive: PrimitiveState::default(),
+            // Note that if your view has no depth buffer this will need to be
+            // changed.
+            depth_stencil: Some(DepthStencilState {
+                format: CORE_3D_DEPTH_FORMAT,
+                depth_write_enabled: false,
+                depth_compare: CompareFunction::Always,
+                stencil: default(),
+                bias: default(),
+            }),
+            multisample: MultisampleState {
+                count: 0,
+                mask: !0,
+                alpha_to_coverage_enabled: false,
+            },
+            zero_initialize_workgroup_memory: false,
+        }
     }
 }