Merge 29d73555ad into f964ee1e3a

Cargo.toml

@@ -2859,6 +2859,12 @@ name = "extended_material"
 path = "examples/shader/extended_material.rs"
 doc-scrape-examples = true
 
+[[example]]
+name = "extended_vertex_material"
+path = "examples/shader/extended_vertex_material.rs"
+doc-scrape-examples = true
+
+
 [package.metadata.example.extended_material]
 name = "Extended Material"
 description = "A custom shader that builds on the standard material"

assets/shaders/extended_vertex_material.wgsl

@@ -0,0 +1,68 @@
+#import bevy_pbr::{
+    pbr_fragment::pbr_input_from_standard_material,
+    pbr_functions::alpha_discard,
+    mesh_functions::{get_world_from_local, mesh_position_local_to_clip},
+    mesh_view_bindings::globals,
+
+} 
+
+#ifdef PREPASS_PIPELINE
+#import bevy_pbr::{
+    prepass_io::{  FragmentOutput},
+    pbr_deferred_functions::deferred_output,
+}
+#else
+#import bevy_pbr::{
+    forward_io::{  FragmentOutput},
+    pbr_functions::{apply_pbr_lighting, main_pass_post_lighting_processing},
+}
+#endif
+
+struct MyExtendedMaterial {
+    quantize_steps: u32,
+}
+
+@group(2) @binding(100)
+var<uniform> material: MyExtendedMaterial;
+
+
+struct Vertex {
+    @builtin(instance_index) instance_index: u32,
+    @location(0) position: vec3<f32>,
+    @location(1) blend_color: vec4<f32>,
+};
+
+struct VertexOutput {
+    @builtin(position) clip_position: vec4<f32>,
+    @location(0) blend_color: vec4<f32>,
+};
+
+@vertex
+fn vertex(vertex: Vertex) -> VertexOutput {
+    var out: VertexOutput;
+
+    let time_base =  ( globals.time  ) * 1.0  ;
+
+    let sinewave_time = sin(  time_base  );
+
+    var local_psn_output = vertex.position;
+
+    local_psn_output.y = local_psn_output.y + sin(  time_base +  local_psn_output.x) * 0.20; 
+ 
+    out.clip_position = mesh_position_local_to_clip(
+        get_world_from_local(vertex.instance_index),
+        vec4<f32>(local_psn_output, 1.0),
+    );
+    out.blend_color = vertex.blend_color;
+    return out;
+}
+
+struct FragmentInput {
+    @location(0) blend_color: vec4<f32>,
+};
+
+@fragment
+fn fragment(input: FragmentInput) -> @location(0) vec4<f32> {
+    return  input.blend_color;
+}
+

examples/shader/extended_vertex_material.rs

@@ -0,0 +1,125 @@
+//! Demonstrates using a custom extension to the `StandardMaterial` to modify the results of the builtin pbr shader.
+
+use bevy::pbr::MaterialExtensionKey;
+use bevy::pbr::MaterialExtensionPipeline;
+use bevy::{
+    color::palettes::basic::RED,
+    pbr::{ExtendedMaterial, MaterialExtension, OpaqueRendererMethod},
+    prelude::*,
+    render::render_resource::*,
+};
+use bevy_render::mesh::MeshVertexAttribute;
+use bevy_render::mesh::MeshVertexBufferLayoutRef;
+
+/// This example uses a shader source file from the assets subdirectory
+//const SHADER_ASSET_PATH: &str = "shaders/extended_material.wgsl";
+
+const SHADER_ASSET_PATH: &str = "shaders/extended_vertex_material.wgsl";
+
+// A "high" random id should be used for custom attributes to ensure consistent sorting and avoid collisions with other attributes.
+// See the MeshVertexAttribute docs for more info.
+const ATTRIBUTE_BLEND_COLOR: MeshVertexAttribute =
+    MeshVertexAttribute::new("BlendColor", 988540917, VertexFormat::Float32x4);
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_plugins(MaterialPlugin::<
+            ExtendedMaterial<StandardMaterial, MyExtension>,
+        >::default())
+        .add_systems(Startup, setup)
+        .add_systems(Update, rotate_things)
+        .run();
+}
+
+fn setup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<ExtendedMaterial<StandardMaterial, MyExtension>>>,
+) {
+    let mesh = Mesh::from(Cuboid::default())
+        // Sets the custom attribute
+        .with_inserted_attribute(
+            ATTRIBUTE_BLEND_COLOR,
+            // The cube mesh has 24 vertices (6 faces, 4 vertices per face), so we insert one BlendColor for each
+            vec![[1.0, 0.0, 0.0, 1.0]; 24],
+        );
+
+    // sphere
+    commands.spawn((
+        Mesh3d(meshes.add(mesh)),
+        MeshMaterial3d(materials.add(ExtendedMaterial {
+            base: StandardMaterial {
+                base_color: RED.into(),
+                // can be used in forward or deferred mode
+                opaque_render_method: OpaqueRendererMethod::Auto,
+                // in deferred mode, only the PbrInput can be modified (uvs, color and other material properties),
+                // in forward mode, the output can also be modified after lighting is applied.
+                // see the fragment shader `extended_material.wgsl` for more info.
+                // Note: to run in deferred mode, you must also add a `DeferredPrepass` component to the camera and either
+                // change the above to `OpaqueRendererMethod::Deferred` or add the `DefaultOpaqueRendererMethod` resource.
+                ..Default::default()
+            },
+            extension: MyExtension { time_ms_elapsed: 0 },
+        })),
+        Transform::from_xyz(0.0, 0.5, 0.0),
+    ));
+
+    // light
+    commands.spawn((
+        DirectionalLight::default(),
+        Transform::from_xyz(1.0, 1.0, 1.0).looking_at(Vec3::ZERO, Vec3::Y),
+        Rotate,
+    ));
+
+    // camera
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(-2.0, 2.5, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
+}
+
+#[derive(Component)]
+struct Rotate;
+
+fn rotate_things(mut q: Query<&mut Transform, With<Rotate>>, time: Res<Time>) {
+    for mut t in &mut q {
+        t.rotate_y(time.delta_secs());
+    }
+}
+
+#[derive(Asset, AsBindGroup, Reflect, Debug, Clone)]
+struct MyExtension {
+    // We need to ensure that the bindings of the base material and the extension do not conflict,
+    // so we start from binding slot 100, leaving slots 0-99 for the base material.
+    #[uniform(100)]
+    time_ms_elapsed: u32,
+}
+
+impl MaterialExtension for MyExtension {
+    fn fragment_shader() -> ShaderRef {
+        SHADER_ASSET_PATH.into()
+    }
+
+    fn deferred_fragment_shader() -> ShaderRef {
+        SHADER_ASSET_PATH.into()
+    }
+
+    fn vertex_shader() -> ShaderRef {
+        SHADER_ASSET_PATH.into()
+    }
+
+    fn specialize(
+        _pipeline: &MaterialExtensionPipeline,
+        descriptor: &mut RenderPipelineDescriptor,
+        layout: &MeshVertexBufferLayoutRef,
+        _key: MaterialExtensionKey<Self>,
+    ) -> Result<(), SpecializedMeshPipelineError> {
+        let vertex_layout = layout.0.get_layout(&[
+            Mesh::ATTRIBUTE_POSITION.at_shader_location(0),
+            ATTRIBUTE_BLEND_COLOR.at_shader_location(1),
+        ])?;
+        descriptor.vertex.buffers = vec![vertex_layout];
+        Ok(())
+    }
+}