array texture shader

game/main/assets/shaders/world/chunk.wgsl

@@ -1,56 +1,58 @@
 #import bevy_pbr::{
-    forward_io::VertexOutput,
-    mesh_view_bindings::view,
-    pbr_types::{STANDARD_MATERIAL_FLAGS_DOUBLE_SIDED_BIT, PbrInput, pbr_input_new},
-    pbr_functions as fns,
+    pbr_fragment::pbr_input_from_standard_material,
+    pbr_functions::alpha_discard,
 }
-#import bevy_core_pipeline::tonemapping::tone_mapping
 
-@group(2) @binding(0) var my_array_texture: texture_2d_array<f32>;
-@group(2) @binding(1) var my_array_texture_sampler: sampler;
+#ifdef PREPASS_PIPELINE
+#import bevy_pbr::{
+    prepass_io::{VertexOutput, FragmentOutput},
+    pbr_deferred_functions::deferred_output,
+}
+#else
+#import bevy_pbr::{
+    forward_io::{VertexOutput, FragmentOutput},
+    pbr_functions::{apply_pbr_lighting, main_pass_post_lighting_processing},
+}
+#endif
+
+struct ChunkMaterial {
+    array_texture: texture_2d_array<f32>,
+    array_texture_sampler: sampler,
+}
+
+@group(2) @binding(100)
+var<uniform> chunk_material: ChunkMaterial;
 
 @fragment
 fn fragment(
+    in: VertexOutput,
     @builtin(front_facing) is_front: bool,
-    mesh: VertexOutput,
-) -> @location(0) vec4<f32> {
-    let layer = i32(mesh.world_position.x) & 0x3;
+) -> FragmentOutput {
+    // generate a PbrInput struct from the StandardMaterial bindings
+    var pbr_input = pbr_input_from_standard_material(in, is_front);
 
-    // Prepare a 'processed' StandardMaterial by sampling all textures to resolve
-    // the material members
-    var pbr_input: PbrInput = pbr_input_new();
 
-    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 * mesh.color;
+    // alpha discard
+    pbr_input.material.base_color = alpha_discard(pbr_input.material, pbr_input.material.base_color);
+
+#ifdef PREPASS_PIPELINE
+    // in deferred mode we can't modify anything after that, as lighting is run in a separate fullscreen shader.
+    let out = deferred_output(in, pbr_input);
+#else
+    var out: FragmentOutput;
+    // apply lighting
+    out.color = apply_pbr_lighting(pbr_input);
+
+    let layer = i32(in.world_position.x) & 0x7;
+    out.color = textureSample(chunk_material.array_texture, chunk_material.array_texture_sampler, in.uv, layer);
+
+    // apply in-shader post processing (fog, alpha-premultiply, and also tonemapping, debanding if the camera is non-hdr)
+    // note this does not include fullscreen postprocessing effects like bloom.
+    out.color = main_pass_post_lighting_processing(pbr_input, out.color);
+
+    // we can optionally modify the final result here
+    out.color = out.color * 2.0;
 #endif
 
-    let double_sided = (pbr_input.material.flags & STANDARD_MATERIAL_FLAGS_DOUBLE_SIDED_BIT) != 0u;
-
-    pbr_input.frag_coord = mesh.position;
-    pbr_input.world_position = mesh.world_position;
-    pbr_input.world_normal = fns::prepare_world_normal(
-        mesh.world_normal,
-        double_sided,
-        is_front,
-    );
-
-    pbr_input.is_orthographic = view.projection[3].w == 1.0;
-
-    pbr_input.N = fns::apply_normal_mapping(
-        pbr_input.material.flags,
-        mesh.world_normal,
-        double_sided,
-        is_front,
-#ifdef VERTEX_TANGENTS
-#ifdef STANDARD_MATERIAL_NORMAL_MAP
-        mesh.world_tangent,
-#endif
-#endif
-        mesh.uv,
-        view.mip_bias,
-    );
-    pbr_input.V = fns::calculate_view(mesh.world_position, pbr_input.is_orthographic);
-
-    return tone_mapping(fns::apply_pbr_lighting(pbr_input), view.color_grading);
+    return out;
 }