Revert "WebGL2 support (bevyengine#3039)"

This reverts commit 7d932ac.

crates/bevy_internal/src/default_plugins.rs

@@ -123,9 +123,6 @@ impl PluginGroup for PipelinedDefaultPlugins {
         group.add(bevy_asset::AssetPlugin::default());
         group.add(bevy_scene::ScenePlugin::default());
 
-        #[cfg(feature = "bevy_winit")]
-        group.add(bevy_winit::WinitPlugin::default());
-
         #[cfg(feature = "bevy_render2")]
         {
             group.add(bevy_render2::RenderPlugin::default());
@@ -144,5 +141,8 @@ impl PluginGroup for PipelinedDefaultPlugins {
             #[cfg(feature = "bevy_gltf2")]
             group.add(bevy_gltf2::GltfPlugin::default());
         }
+
+        #[cfg(feature = "bevy_winit")]
+        group.add(bevy_winit::WinitPlugin::default());
     }
 }

crates/bevy_winit/src/lib.rs

@@ -26,6 +26,14 @@ use winit::{
 };
 
 use winit::dpi::LogicalSize;
+#[cfg(any(
+    target_os = "linux",
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "netbsd",
+    target_os = "openbsd"
+))]
+use winit::platform::unix::EventLoopExtUnix;
 
 #[derive(Default)]
 pub struct WinitPlugin;
@@ -35,9 +43,6 @@ impl Plugin for WinitPlugin {
         app.init_resource::<WinitWindows>()
             .set_runner(winit_runner)
             .add_system_to_stage(CoreStage::PostUpdate, change_window.exclusive_system());
-        let event_loop = EventLoop::new();
-        handle_initial_window_events(&mut app.world, &event_loop);
-        app.insert_non_send_resource(event_loop);
     }
 }
 
@@ -202,22 +207,21 @@ where
 }
 
 pub fn winit_runner(app: App) {
-    winit_runner_with(app);
+    winit_runner_with(app, EventLoop::new());
 }
 
-// #[cfg(any(
-//     target_os = "linux",
-//     target_os = "dragonfly",
-//     target_os = "freebsd",
-//     target_os = "netbsd",
-//     target_os = "openbsd"
-// ))]
-// pub fn winit_runner_any_thread(app: App) {
-//     winit_runner_with(app, EventLoop::new_any_thread());
-// }
+#[cfg(any(
+    target_os = "linux",
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "netbsd",
+    target_os = "openbsd"
+))]
+pub fn winit_runner_any_thread(app: App) {
+    winit_runner_with(app, EventLoop::new_any_thread());
+}
 
-pub fn winit_runner_with(mut app: App) {
-    let mut event_loop = app.world.remove_non_send::<EventLoop<()>>().unwrap();
+pub fn winit_runner_with(mut app: App, mut event_loop: EventLoop<()>) {
     let mut create_window_event_reader = ManualEventReader::<CreateWindow>::default();
     let mut app_exit_event_reader = ManualEventReader::<AppExit>::default();
     let mut active = true;
@@ -552,22 +556,3 @@ fn handle_create_window_events(
         });
     }
 }
-
-fn handle_initial_window_events(world: &mut World, event_loop: &EventLoop<()>) {
-    let world = world.cell();
-    let mut winit_windows = world.get_resource_mut::<WinitWindows>().unwrap();
-    let mut windows = world.get_resource_mut::<Windows>().unwrap();
-    let mut create_window_events = world.get_resource_mut::<Events<CreateWindow>>().unwrap();
-    let mut window_created_events = world.get_resource_mut::<Events<WindowCreated>>().unwrap();
-    for create_window_event in create_window_events.drain() {
-        let window = winit_windows.create_window(
-            event_loop,
-            create_window_event.id,
-            &create_window_event.descriptor,
-        );
-        windows.add(window);
-        window_created_events.send(WindowCreated {
-            id: create_window_event.id,
-        });
-    }
-}

pipelined/bevy_render2/Cargo.toml

@@ -45,9 +45,6 @@ parking_lot = "0.11.0"
 regex = "1.5"
 crevice = { path = "../../crates/crevice", version = "0.8.0", features = ["glam"] }
 
-[target.'cfg(target_arch = "wasm32")'.dependencies]
-wgpu = { version = "0.11.0", features = ["spirv", "webgl"] }
-
 [features]
 png = ["image/png"]
 hdr = ["image/hdr"]

pipelined/bevy_render2/src/lib.rs

@@ -90,40 +90,15 @@ struct ScratchRenderWorld(World);
 impl Plugin for RenderPlugin {
     /// Initializes the renderer, sets up the [`RenderStage`](RenderStage) and creates the rendering sub-app.
     fn build(&self, app: &mut App) {
-        let default_backend = if cfg!(not(target_arch = "wasm32")) {
-            Backends::PRIMARY
-        } else {
-            Backends::GL
-        };
-        let backends = wgpu::util::backend_bits_from_env().unwrap_or(default_backend);
-        let instance = wgpu::Instance::new(backends);
-        let surface = {
-            let world = app.world.cell();
-            let windows = world.get_resource_mut::<bevy_window::Windows>().unwrap();
-            let raw_handle = windows.get_primary().map(|window| unsafe {
-                let handle = window.raw_window_handle().get_handle();
-                instance.create_surface(&handle)
-            });
-            raw_handle
-        };
-        let (device, queue) = futures_lite::future::block_on(renderer::initialize_renderer(
-            &instance,
-            &wgpu::RequestAdapterOptions {
-                power_preference: wgpu::PowerPreference::HighPerformance,
-                compatible_surface: surface.as_ref(),
-                ..Default::default()
-            },
-            &wgpu::DeviceDescriptor {
-                features: wgpu::Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES,
-                #[cfg(not(target_arch = "wasm32"))]
-                limits: wgpu::Limits::default(),
-                #[cfg(target_arch = "wasm32")]
-                limits: wgpu::Limits {
-                    ..wgpu::Limits::downlevel_webgl2_defaults()
+        let (instance, device, queue) =
+            futures_lite::future::block_on(renderer::initialize_renderer(
+                wgpu::util::backend_bits_from_env().unwrap_or(Backends::PRIMARY),
+                &wgpu::RequestAdapterOptions {
+                    power_preference: wgpu::PowerPreference::HighPerformance,
+                    ..Default::default()
                 },
-                ..Default::default()
-            },
-        ));
+                &wgpu::DeviceDescriptor::default(),
+            ));
         app.insert_resource(device.clone())
             .insert_resource(queue.clone())
             .add_asset::<Shader>()

pipelined/bevy_render2/src/renderer/mod.rs

@@ -11,7 +11,7 @@ use crate::{
 };
 use bevy_ecs::prelude::*;
 use std::sync::Arc;
-use wgpu::{CommandEncoder, DeviceDescriptor, Instance, Queue, RequestAdapterOptions};
+use wgpu::{Backends, CommandEncoder, DeviceDescriptor, Instance, Queue, RequestAdapterOptions};
 
 /// Updates the [`RenderGraph`] with all of its nodes and then runs it to render the entire frame.
 pub fn render_system(world: &mut World) {
@@ -63,10 +63,12 @@ pub type RenderInstance = Instance;
 /// Initializes the renderer by retrieving and preparing the GPU instance, device and queue
 /// for the specified backend.
 pub async fn initialize_renderer(
-    instance: &Instance,
+    backends: Backends,
     request_adapter_options: &RequestAdapterOptions<'_>,
     device_descriptor: &DeviceDescriptor<'_>,
-) -> (RenderDevice, RenderQueue) {
+) -> (RenderInstance, RenderDevice, RenderQueue) {
+    let instance = wgpu::Instance::new(backends);
+
     let adapter = instance
         .request_adapter(request_adapter_options)
         .await
@@ -91,7 +93,7 @@ pub async fn initialize_renderer(
         .unwrap();
     let device = Arc::new(device);
     let queue = Arc::new(queue);
-    (RenderDevice::from(device), queue)
+    (instance, RenderDevice::from(device), queue)
 }
 
 /// The context with all information required to interact with the GPU.

pipelined/bevy_render2/src/texture/mod.rs

@@ -43,7 +43,7 @@ pub trait BevyDefault {
 
 impl BevyDefault for wgpu::TextureFormat {
     fn bevy_default() -> Self {
-        if cfg!(target_os = "android") || cfg!(target_arch = "wasm32") {
+        if cfg!(target_os = "android") {
             // Bgra8UnormSrgb texture missing on some Android devices
             wgpu::TextureFormat::Rgba8UnormSrgb
         } else {