[Merged by Bors] - Fix wasm examples

crates/bevy_core_pipeline/Cargo.toml

@@ -14,6 +14,7 @@ keywords = ["bevy"]
 
 [features]
 trace = []
+webgl = []
 
 [dependencies]
 # bevy

crates/bevy_core_pipeline/src/core_2d/main_pass_2d_node.rs

@@ -11,6 +11,8 @@ use bevy_render::{
     renderer::RenderContext,
     view::{ExtractedView, ViewTarget},
 };
+#[cfg(feature = "trace")]
+use bevy_utils::tracing::info_span;
 
 pub struct MainPass2dNode {
     query: QueryState<
@@ -57,37 +59,60 @@ impl Node for MainPass2dNode {
                 // no target
                 return Ok(());
             };
+        {
+            #[cfg(feature = "trace")]
+            let _main_pass_2d = info_span!("main_pass_2d").entered();
+            let pass_descriptor = RenderPassDescriptor {
+                label: Some("main_pass_2d"),
+                color_attachments: &[target.get_color_attachment(Operations {
+                    load: match camera_2d.clear_color {
+                        ClearColorConfig::Default => {
+                            LoadOp::Clear(world.resource::<ClearColor>().0.into())
+                        }
+                        ClearColorConfig::Custom(color) => LoadOp::Clear(color.into()),
+                        ClearColorConfig::None => LoadOp::Load,
+                    },
+                    store: true,
+                })],
+                depth_stencil_attachment: None,
+            };
 
-        let pass_descriptor = RenderPassDescriptor {
-            label: Some("main_pass_2d"),
-            color_attachments: &[target.get_color_attachment(Operations {
-                load: match camera_2d.clear_color {
-                    ClearColorConfig::Default => {
-                        LoadOp::Clear(world.resource::<ClearColor>().0.into())
-                    }
-                    ClearColorConfig::Custom(color) => LoadOp::Clear(color.into()),
-                    ClearColorConfig::None => LoadOp::Load,
-                },
-                store: true,
-            })],
-            depth_stencil_attachment: None,
-        };
-
-        let draw_functions = world.resource::<DrawFunctions<Transparent2d>>();
+            let draw_functions = world.resource::<DrawFunctions<Transparent2d>>();
 
-        let render_pass = render_context
-            .command_encoder
-            .begin_render_pass(&pass_descriptor);
+            let render_pass = render_context
+                .command_encoder
+                .begin_render_pass(&pass_descriptor);
 
-        let mut draw_functions = draw_functions.write();
-        let mut tracked_pass = TrackedRenderPass::new(render_pass);
-        if let Some(viewport) = camera.viewport.as_ref() {
-            tracked_pass.set_camera_viewport(viewport);
+            let mut draw_functions = draw_functions.write();
+            let mut tracked_pass = TrackedRenderPass::new(render_pass);
+            if let Some(viewport) = camera.viewport.as_ref() {
+                tracked_pass.set_camera_viewport(viewport);
+            }
+            for item in &transparent_phase.items {
+                let draw_function = draw_functions.get_mut(item.draw_function).unwrap();
+                draw_function.draw(world, &mut tracked_pass, view_entity, item);
+            }
         }
-        for item in &transparent_phase.items {
-            let draw_function = draw_functions.get_mut(item.draw_function).unwrap();
-            draw_function.draw(world, &mut tracked_pass, view_entity, item);
+
+        // If there was a camera with a viewport, finish with a renderpass without a custom viewport in webgl
+        #[cfg(feature = "webgl")]
+        if camera.viewport.is_some() {
+            #[cfg(feature = "trace")]
+            let _reset_viewport_pass_2d = info_span!("reset_viewport_pass_2d").entered();
+            let pass_descriptor = RenderPassDescriptor {
+                label: Some("reset_viewport_pass_2d"),
+                color_attachments: &[target.get_color_attachment(Operations {
+                    load: LoadOp::Load,
+                    store: true,
+                })],
+                depth_stencil_attachment: None,
+            };
+
+            render_context
+                .command_encoder
+                .begin_render_pass(&pass_descriptor);
         }
+
         Ok(())
     }
 }

crates/bevy_core_pipeline/src/core_3d/main_pass_3d_node.rs

@@ -194,6 +194,25 @@ impl Node for MainPass3dNode {
             }
         }
 
+        // If there was a camera with a viewport, finish with a renderpass without a custom viewport in webgl2
+        #[cfg(feature = "webgl")]
+        if camera.viewport.is_some() {
+            #[cfg(feature = "trace")]
+            let _main_transparent_pass_3d_span = info_span!("reset_viewport_pass_3d").entered();
+            let pass_descriptor = RenderPassDescriptor {
+                label: Some("reset_viewport_pass_3d"),
+                color_attachments: &[target.get_color_attachment(Operations {
+                    load: LoadOp::Load,
+                    store: true,
+                })],
+                depth_stencil_attachment: None,
+            };
+
+            render_context
+                .command_encoder
+                .begin_render_pass(&pass_descriptor);
+        }
+
         Ok(())
     }
 }

crates/bevy_internal/Cargo.toml

@@ -55,7 +55,7 @@ x11 = ["bevy_winit/x11"]
 subpixel_glyph_atlas = ["bevy_text/subpixel_glyph_atlas"]
 
 # Optimise for WebGL2
-webgl = ["bevy_pbr/webgl", "bevy_render/webgl"]
+webgl = ["bevy_core_pipeline/webgl", "bevy_pbr/webgl", "bevy_render/webgl"]
 
 # enable systems that allow for automated testing on CI
 bevy_ci_testing = ["bevy_app/bevy_ci_testing", "bevy_render/ci_limits"]

crates/bevy_pbr/src/render/light.rs

@@ -212,7 +212,6 @@ pub struct ShadowPipeline {
     pub skinned_mesh_layout: BindGroupLayout,
     pub point_light_sampler: Sampler,
     pub directional_light_sampler: Sampler,
-    pub clustered_forward_buffer_binding_type: BufferBindingType,
 }
 
 // TODO: this pattern for initializing the shaders / pipeline isn't ideal. this should be handled by the asset system
@@ -221,9 +220,6 @@ impl FromWorld for ShadowPipeline {
         let world = world.cell();
         let render_device = world.resource::<RenderDevice>();
 
-        let clustered_forward_buffer_binding_type = render_device
-            .get_supported_read_only_binding_type(CLUSTERED_FORWARD_STORAGE_BUFFER_COUNT);
-
         let view_layout = render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
             entries: &[
                 // View
@@ -268,7 +264,6 @@ impl FromWorld for ShadowPipeline {
                 compare: Some(CompareFunction::GreaterEqual),
                 ..Default::default()
             }),
-            clustered_forward_buffer_binding_type,
         }
     }
 }
@@ -330,13 +325,6 @@ impl SpecializedMeshPipeline for ShadowPipeline {
             bind_group_layout.push(self.mesh_layout.clone());
         }
 
-        if !matches!(
-            self.clustered_forward_buffer_binding_type,
-            BufferBindingType::Storage { .. }
-        ) {
-            shader_defs.push(String::from("NO_STORAGE_BUFFERS_SUPPORT"));
-        }
-
         let vertex_buffer_layout = layout.get_layout(&vertex_attributes)?;
 
         Ok(RenderPipelineDescriptor {

crates/bevy_pbr/src/render/mesh.rs

@@ -573,18 +573,6 @@ impl SpecializedMeshPipeline for MeshPipeline {
             vertex_attributes.push(Mesh::ATTRIBUTE_COLOR.at_shader_location(4));
         }
 
-        // TODO: consider exposing this in shaders in a more generally useful way, such as:
-        // # if AVAILABLE_STORAGE_BUFFER_BINDINGS == 3
-        // /* use storage buffers here */
-        // # elif
-        // /* use uniforms here */
-        if !matches!(
-            self.clustered_forward_buffer_binding_type,
-            BufferBindingType::Storage { .. }
-        ) {
-            shader_defs.push(String::from("NO_STORAGE_BUFFERS_SUPPORT"));
-        }
-
         let mut bind_group_layout = vec![self.view_layout.clone()];
         if layout.contains(Mesh::ATTRIBUTE_JOINT_INDEX)
             && layout.contains(Mesh::ATTRIBUTE_JOINT_WEIGHT)
@@ -615,9 +603,6 @@ impl SpecializedMeshPipeline for MeshPipeline {
             depth_write_enabled = true;
         }
 
-        #[cfg(feature = "webgl")]
-        shader_defs.push(String::from("NO_ARRAY_TEXTURES_SUPPORT"));
-
         Ok(RenderPipelineDescriptor {
             vertex: VertexState {
                 shader: MESH_SHADER_HANDLE.typed::<Shader>(),

crates/bevy_render/src/render_resource/pipeline_cache.rs

@@ -15,7 +15,10 @@ use bevy_ecs::system::{Res, ResMut};
 use bevy_utils::{default, tracing::error, Entry, HashMap, HashSet};
 use std::{hash::Hash, mem, ops::Deref, sync::Arc};
 use thiserror::Error;
-use wgpu::{PipelineLayoutDescriptor, ShaderModule, VertexBufferLayout as RawVertexBufferLayout};
+use wgpu::{
+    BufferBindingType, PipelineLayoutDescriptor, ShaderModule,
+    VertexBufferLayout as RawVertexBufferLayout,
+};
 
 enum PipelineDescriptor {
     RenderPipelineDescriptor(Box<RenderPipelineDescriptor>),
@@ -117,9 +120,26 @@ impl ShaderCache {
         let module = match data.processed_shaders.entry(shader_defs.to_vec()) {
             Entry::Occupied(entry) => entry.into_mut(),
             Entry::Vacant(entry) => {
+                let mut shader_defs = shader_defs.to_vec();
+                #[cfg(feature = "webgl")]
+                shader_defs.push(String::from("NO_ARRAY_TEXTURES_SUPPORT"));
+
+                // TODO: 3 is the value from CLUSTERED_FORWARD_STORAGE_BUFFER_COUNT declared in bevy_pbr
+                // consider exposing this in shaders in a more generally useful way, such as:
+                // # if AVAILABLE_STORAGE_BUFFER_BINDINGS == 3
+                // /* use storage buffers here */
+                // # elif
+                // /* use uniforms here */
+                if !matches!(
+                    render_device.get_supported_read_only_binding_type(3),
+                    BufferBindingType::Storage { .. }
+                ) {
+                    shader_defs.push(String::from("NO_STORAGE_BUFFERS_SUPPORT"));
+                }
+
                 let processed = self.processor.process(
                     shader,
-                    shader_defs,
+                    &shader_defs,
                     &self.shaders,
                     &self.import_path_shaders,
                 )?;

crates/bevy_sprite/src/mesh2d/mesh.rs

@@ -316,9 +316,6 @@ impl SpecializedMeshPipeline for Mesh2dPipeline {
             vertex_attributes.push(Mesh::ATTRIBUTE_COLOR.at_shader_location(4));
         }
 
-        #[cfg(feature = "webgl")]
-        shader_defs.push(String::from("NO_ARRAY_TEXTURES_SUPPORT"));
-
         let vertex_buffer_layout = layout.get_layout(&vertex_attributes)?;
 
         Ok(RenderPipelineDescriptor {

examples/3d/split_screen.rs

@@ -1,10 +1,8 @@
 //! Renders two cameras to the same window to accomplish "split screen".
 
 use bevy::{
-    core_pipeline::clear_color::ClearColorConfig,
-    prelude::*,
-    render::camera::Viewport,
-    window::{WindowId, WindowResized},
+    core_pipeline::clear_color::ClearColorConfig, prelude::*, render::camera::Viewport,
+    window::WindowResized,
 };
 
 fn main() {
@@ -83,26 +81,25 @@ fn set_camera_viewports(
     mut resize_events: EventReader<WindowResized>,
     mut left_camera: Query<&mut Camera, (With<LeftCamera>, Without<RightCamera>)>,
     mut right_camera: Query<&mut Camera, With<RightCamera>>,
+    mut setup_done: Local<bool>,
 ) {
     // We need to dynamically resize the camera's viewports whenever the window size changes
     // so then each camera always takes up half the screen.
-    // A resize_event is sent when the window is first created, allowing us to reuse this system for initial setup.
-    for resize_event in resize_events.iter() {
-        if resize_event.id == WindowId::primary() {
-            let window = windows.primary();
-            let mut left_camera = left_camera.single_mut();
-            left_camera.viewport = Some(Viewport {
-                physical_position: UVec2::new(0, 0),
-                physical_size: UVec2::new(window.physical_width() / 2, window.physical_height()),
-                ..default()
-            });
+    if resize_events.iter().next().is_some() || !*setup_done {
+        let window = windows.primary();
+        let mut left_camera = left_camera.single_mut();
+        left_camera.viewport = Some(Viewport {
+            physical_position: UVec2::new(0, 0),
+            physical_size: UVec2::new(window.physical_width() / 2, window.physical_height()),
+            ..default()
+        });
 
-            let mut right_camera = right_camera.single_mut();
-            right_camera.viewport = Some(Viewport {
-                physical_position: UVec2::new(window.physical_width() / 2, 0),
-                physical_size: UVec2::new(window.physical_width() / 2, window.physical_height()),
-                ..default()
-            });
-        }
+        let mut right_camera = right_camera.single_mut();
+        right_camera.viewport = Some(Viewport {
+            physical_position: UVec2::new(window.physical_width() / 2, 0),
+            physical_size: UVec2::new(window.physical_width() / 2, window.physical_height()),
+            ..default()
+        });
+        *setup_done = true;
     }
 }