improve shader import model

assets/shaders/animate_shader.wgsl

@@ -1,6 +1,6 @@
-#import bevy_pbr::mesh_types
 // The time since startup data is in the globals binding which is part of the mesh_view_bindings import
-#import bevy_pbr::mesh_view_bindings
+#from bevy_pbr::mesh_view_bindings import globals
+#from bevy_pbr::mesh_vertex_output import MeshVertexOutput
 
 fn oklab_to_linear_srgb(c: vec3<f32>) -> vec3<f32> {
     let L = c.x;
@@ -22,17 +22,13 @@ fn oklab_to_linear_srgb(c: vec3<f32>) -> vec3<f32> {
     );
 }
 
-struct FragmentInput {
-    #import bevy_pbr::mesh_vertex_output
-}
-
 @fragment
-fn fragment(in: FragmentInput) -> @location(0) vec4<f32> {
+fn fragment(in: ::MeshVertexOutput) -> @location(0) vec4<f32> {
     let speed = 2.0;
     // The globals binding contains various global values like time
     // which is the time since startup in seconds
-    let t_1 = sin(globals.time * speed) * 0.5 + 0.5;
-    let t_2 = cos(globals.time * speed);
+    let t_1 = sin(::globals.time * speed) * 0.5 + 0.5;
+    let t_2 = cos(::globals.time * speed);
 
     let distance_to_center = distance(in.uv, vec2<f32>(0.5)) * 1.4;
 

assets/shaders/array_texture.wgsl

@@ -1,60 +1,51 @@
-#import bevy_pbr::mesh_view_bindings
-#import bevy_pbr::mesh_bindings
-
-#import bevy_pbr::pbr_types
-#import bevy_pbr::utils
-#import bevy_pbr::clustered_forward
-#import bevy_pbr::lighting
-#import bevy_pbr::shadows
-#import bevy_pbr::fog
-#import bevy_pbr::pbr_functions
-#import bevy_pbr::pbr_ambient
+#from bevy_pbr::mesh_vertex_output  import MeshVertexOutput
+#from bevy_pbr::mesh_view_bindings  import view
+#from bevy_pbr::pbr_types           import STANDARD_MATERIAL_FLAGS_DOUBLE_SIDED_BIT
+#import bevy_pbr::pbr_functions as fns
+#from bevy_core_pipeline::tonemapping import tone_mapping
 
 @group(1) @binding(0)
 var my_array_texture: texture_2d_array<f32>;
 @group(1) @binding(1)
 var my_array_texture_sampler: sampler;
 
-struct FragmentInput {
-    @builtin(front_facing) is_front: bool,
-    @builtin(position) frag_coord: vec4<f32>,
-    #import bevy_pbr::mesh_vertex_output
-};
-
 @fragment
-fn fragment(in: FragmentInput) -> @location(0) vec4<f32> {
-    let layer = i32(in.world_position.x) & 0x3;
+fn fragment(
+    @builtin(front_facing) is_front: bool,
+    mesh: ::MeshVertexOutput,
+) -> @location(0) vec4<f32> {
+    let layer = i32(mesh.world_position.x) & 0x3;
 
     // Prepare a 'processed' StandardMaterial by sampling all textures to resolve
     // the material members
-    var pbr_input: PbrInput = pbr_input_new();
+    var pbr_input: fns::PbrInput = fns::pbr_input_new();
 
-    pbr_input.material.base_color = textureSample(my_array_texture, my_array_texture_sampler, in.uv, layer);
+    pbr_input.material.base_color = textureSample(my_array_texture, my_array_texture_sampler, mesh.uv, layer);
 #ifdef VERTEX_COLORS
-    pbr_input.material.base_color = pbr_input.material.base_color * in.color;
+    pbr_input.material.base_color = pbr_input.material.base_color * mesh.color;
 #endif
 
-    pbr_input.frag_coord = in.frag_coord;
-    pbr_input.world_position = in.world_position;
-    pbr_input.world_normal = prepare_world_normal(
-        in.world_normal,
-        (pbr_input.material.flags & STANDARD_MATERIAL_FLAGS_DOUBLE_SIDED_BIT) != 0u,
-        in.is_front,
+    pbr_input.frag_coord = mesh.clip_position;
+    pbr_input.world_position = mesh.world_position;
+    pbr_input.world_normal = fns::prepare_world_normal(
+        mesh.world_normal,
+        (pbr_input.material.flags & ::STANDARD_MATERIAL_FLAGS_DOUBLE_SIDED_BIT) != 0u,
+        is_front,
     );
 
-    pbr_input.is_orthographic = view.projection[3].w == 1.0;
+    pbr_input.is_orthographic = ::view.projection[3].w == 1.0;
 
-    pbr_input.N = apply_normal_mapping(
+    pbr_input.N = fns::apply_normal_mapping(
         pbr_input.material.flags,
-        pbr_input.world_normal,
+        mesh.world_normal,
 #ifdef VERTEX_TANGENTS
 #ifdef STANDARDMATERIAL_NORMAL_MAP
-        in.world_tangent,
+        mesh.world_tangent,
 #endif
 #endif
-        in.uv,
+        mesh.uv,
     );
-    pbr_input.V = calculate_view(in.world_position, pbr_input.is_orthographic);
+    pbr_input.V = fns::calculate_view(mesh.world_position, pbr_input.is_orthographic);
 
-    return tone_mapping(pbr(pbr_input));
+    return ::tone_mapping(fns::pbr(pbr_input), ::view.color_grading);
 }

assets/shaders/cubemap_unlit.wgsl

@@ -1,4 +1,4 @@
-#import bevy_pbr::mesh_view_bindings
+#from bevy_pbr::mesh_vertex_output import MeshVertexOutput
 
 #ifdef CUBEMAP_ARRAY
 @group(1) @binding(0)
@@ -13,9 +13,9 @@ var base_color_sampler: sampler;
 
 @fragment
 fn fragment(
-    #import bevy_pbr::mesh_vertex_output
+    mesh: ::MeshVertexOutput,
 ) -> @location(0) vec4<f32> {
-    let fragment_position_view_lh = world_position.xyz * vec3<f32>(1.0, 1.0, -1.0);
+    let fragment_position_view_lh = mesh.world_position.xyz * vec3<f32>(1.0, 1.0, -1.0);
     return textureSample(
         base_color_texture,
         base_color_sampler,

assets/shaders/custom_material.frag

@@ -10,7 +10,11 @@ layout(set = 1, binding = 0) uniform CustomMaterial {
 layout(set = 1, binding = 1) uniform texture2D CustomMaterial_texture;
 layout(set = 1, binding = 2) uniform sampler CustomMaterial_sampler;
 
+// wgsl modules can be imported and used in glsl
+// FIXME - this doesn't work any more ...
+// #import bevy_pbr::pbr_functions as PbrFuncs
 
 void main() {
+    // o_Target = PbrFuncs::tone_mapping(Color * texture(sampler2D(CustomMaterial_texture,CustomMaterial_sampler), v_Uv));
     o_Target = Color * texture(sampler2D(CustomMaterial_texture,CustomMaterial_sampler), v_Uv);
 }

assets/shaders/custom_material.wgsl

@@ -1,3 +1,5 @@
+#from bevy_pbr::mesh_vertex_output import MeshVertexOutput
+
 struct CustomMaterial {
     color: vec4<f32>,
 };
@@ -11,7 +13,7 @@ var base_color_sampler: sampler;
 
 @fragment
 fn fragment(
-    #import bevy_pbr::mesh_vertex_output
+    mesh: ::MeshVertexOutput,
 ) -> @location(0) vec4<f32> {
-    return material.color * textureSample(base_color_texture, base_color_sampler, uv);
+    return material.color * textureSample(base_color_texture, base_color_sampler, mesh.uv);
 }

assets/shaders/custom_material_chromatic_aberration.wgsl

@@ -1,5 +1,6 @@
-#import bevy_sprite::mesh2d_view_bindings
-#import bevy_pbr::utils
+#from bevy_pbr::mesh_view_bindings  import view
+#from bevy_pbr::mesh_vertex_output  import MeshVertexOutput
+#from bevy_pbr::utils               import coords_to_viewport_uv
 
 @group(1) @binding(0)
 var texture: texture_2d<f32>;
@@ -9,11 +10,10 @@ var our_sampler: sampler;
 
 @fragment
 fn fragment(
-    @builtin(position) position: vec4<f32>,
-    #import bevy_sprite::mesh2d_vertex_output
+    mesh: ::MeshVertexOutput
 ) -> @location(0) vec4<f32> {
     // Get screen position with coordinates from 0 to 1
-    let uv = coords_to_viewport_uv(position.xy, view.viewport);
+    let uv = ::coords_to_viewport_uv(mesh.clip_position.xy, ::view.viewport);
     let offset_strength = 0.02;
 
     // Sample each color channel with an arbitrary shift

assets/shaders/custom_material_screenspace_texture.wgsl

@@ -1,5 +1,6 @@
-#import bevy_pbr::mesh_view_bindings
-#import bevy_pbr::utils
+#from bevy_pbr::mesh_view_bindings  import view
+#from bevy_pbr::mesh_vertex_output  import MeshVertexOutput
+#from bevy_pbr::utils               import coords_to_viewport_uv
 
 @group(1) @binding(0)
 var texture: texture_2d<f32>;
@@ -8,10 +9,10 @@ var texture_sampler: sampler;
 
 @fragment
 fn fragment(
-    @builtin(position) position: vec4<f32>,
-    #import bevy_pbr::mesh_vertex_output
+    mesh: ::MeshVertexOutput,
 ) -> @location(0) vec4<f32> {
-    let uv = coords_to_viewport_uv(position.xy, view.viewport);
+    let view = ::view;
+    let uv = ::coords_to_viewport_uv(mesh.clip_position.xy, view.viewport);
     let color = textureSample(texture, texture_sampler, uv);
     return color;
 }

assets/shaders/custom_vertex_attribute.wgsl

@@ -1,15 +1,12 @@
-#import bevy_pbr::mesh_view_bindings
-#import bevy_pbr::mesh_bindings
+#from bevy_pbr::mesh_bindings   import mesh
+#from bevy_pbr::mesh_functions  import mesh_position_local_to_clip
 
 struct CustomMaterial {
     color: vec4<f32>,
 };
 @group(1) @binding(0)
 var<uniform> material: CustomMaterial;
 
-// NOTE: Bindings must come before functions that use them!
-#import bevy_pbr::mesh_functions
-
 struct Vertex {
     @location(0) position: vec3<f32>,
     @location(1) blend_color: vec4<f32>,
@@ -23,7 +20,10 @@ struct VertexOutput {
 @vertex
 fn vertex(vertex: Vertex) -> VertexOutput {
     var out: VertexOutput;
-    out.clip_position = mesh_position_local_to_clip(mesh.model, vec4<f32>(vertex.position, 1.0));
+    out.clip_position = ::mesh_position_local_to_clip(
+        ::mesh.model,
+        vec4<f32>(vertex.position, 1.0)
+    );
     out.blend_color = vertex.blend_color;
     return out;
 }

assets/shaders/instancing.wgsl

@@ -1,11 +1,5 @@
-#import bevy_pbr::mesh_types
-#import bevy_pbr::mesh_view_bindings
-
-@group(1) @binding(0)
-var<uniform> mesh: Mesh;
-
-// NOTE: Bindings must come before functions that use them!
-#import bevy_pbr::mesh_functions
+#from bevy_pbr::mesh_functions  import mesh_position_local_to_clip
+#from bevy_pbr::mesh_bindings   import mesh
 
 struct Vertex {
     @location(0) position: vec3<f32>,
@@ -25,7 +19,10 @@ struct VertexOutput {
 fn vertex(vertex: Vertex) -> VertexOutput {
     let position = vertex.position * vertex.i_pos_scale.w + vertex.i_pos_scale.xyz;
     var out: VertexOutput;
-    out.clip_position = mesh_position_local_to_clip(mesh.model, vec4<f32>(position, 1.0));
+    out.clip_position = ::mesh_position_local_to_clip(
+        ::mesh.model, 
+        vec4<f32>(position, 1.0)
+    );
     out.color = vertex.i_color;
     return out;
 }

assets/shaders/line_material.wgsl

@@ -1,3 +1,5 @@
+#from bevy_pbr::mesh_vertex_output import MeshVertexOutput
+
 struct LineMaterial {
     color: vec4<f32>,
 };
@@ -7,7 +9,7 @@ var<uniform> material: LineMaterial;
 
 @fragment
 fn fragment(
-    #import bevy_pbr::mesh_vertex_output
+    mesh: ::MeshVertexOutput,
 ) -> @location(0) vec4<f32> {
     return material.color;
 }

assets/shaders/post_process_pass.wgsl

@@ -20,7 +20,7 @@
 // As you can see, the triangle ends up bigger than the screen.
 //
 // You don't need to worry about this too much since bevy will compute the correct UVs for you.
-#import bevy_core_pipeline::fullscreen_vertex_shader
+#from bevy_core_pipeline::fullscreen_vertex_shader import FullscreenVertexOutput
 
 @group(0) @binding(0)
 var screen_texture: texture_2d<f32>;
@@ -33,7 +33,7 @@ struct PostProcessSettings {
 var<uniform> settings: PostProcessSettings;
 
 @fragment
-fn fragment(in: FullscreenVertexOutput) -> @location(0) vec4<f32> {
+fn fragment(in: ::FullscreenVertexOutput) -> @location(0) vec4<f32> {
     // Chromatic aberration strength
     let offset_strength = settings.intensity;
 

assets/shaders/shader_defs.wgsl

@@ -1,3 +1,5 @@
+#from bevy_pbr::mesh_vertex_output import MeshVertexOutput
+
 struct CustomMaterial {
     color: vec4<f32>,
 };
@@ -7,7 +9,7 @@ var<uniform> material: CustomMaterial;
 
 @fragment
 fn fragment(
-    #import bevy_pbr::mesh_vertex_output
+    mesh: ::MeshVertexOutput,
 ) -> @location(0) vec4<f32> {
 #ifdef IS_RED
     return vec4<f32>(1.0, 0.0, 0.0, 1.0);

assets/shaders/show_prepass.wgsl

@@ -1,6 +1,7 @@
 #import bevy_pbr::mesh_types
-#import bevy_pbr::mesh_view_bindings
+#from bevy_pbr::mesh_view_bindings import globals
 #import bevy_pbr::prepass_utils
+#from bevy_pbr::mesh_vertex_output import MeshVertexOutput
 
 struct ShowPrepassSettings {
     show_depth: u32,
@@ -14,19 +15,18 @@ var<uniform> settings: ShowPrepassSettings;
 
 @fragment
 fn fragment(
-    @builtin(position) frag_coord: vec4<f32>,
     @builtin(sample_index) sample_index: u32,
-    #import bevy_pbr::mesh_vertex_output
+    mesh: ::MeshVertexOutput,
 ) -> @location(0) vec4<f32> {
     if settings.show_depth == 1u {
-        let depth = prepass_depth(frag_coord, sample_index);
+        let depth = bevy_pbr::prepass_utils::prepass_depth(mesh.clip_position, sample_index);
         return vec4(depth, depth, depth, 1.0);
     } else if settings.show_normals == 1u {
-        let normal = prepass_normal(frag_coord, sample_index);
+        let normal = bevy_pbr::prepass_utils::prepass_normal(mesh.clip_position, sample_index);
         return vec4(normal, 1.0);
     } else if settings.show_motion_vectors == 1u {
-        let motion_vector = prepass_motion_vector(frag_coord, sample_index);
-        return vec4(motion_vector / globals.delta_time, 0.0, 1.0);
+        let motion_vector = bevy_pbr::prepass_utils::prepass_motion_vector(mesh.clip_position, sample_index);
+        return vec4(motion_vector / ::globals.delta_time, 0.0, 1.0);
     }
 
     return vec4(0.0);