Windows as Entities

crates/bevy_ecs/src/system/commands/mod.rs

@@ -62,6 +62,12 @@ impl<'w, 's> Commands<'w, 's> {
         Self { queue, entities }
     }
 
+    // TODO: Can this be solved in any other way?
+    /// Returns true if this commands has the entity present
+    pub fn has_entity(&self, entity: Entity) -> bool {
+        return self.entities.contains(entity);
+    }
+
     /// Creates a new empty [`Entity`] and returns an [`EntityCommands`] builder for it.
     ///
     /// To directly spawn an entity with a [`Bundle`] included, you can use

crates/bevy_render/src/camera/camera.rs

@@ -12,6 +12,7 @@ use bevy_ecs::{
     component::Component,
     entity::Entity,
     event::EventReader,
+    prelude::With,
     query::Added,
     reflect::ReflectComponent,
     system::{Commands, ParamSet, Query, Res},
@@ -20,7 +21,7 @@ use bevy_math::{Mat4, UVec2, Vec2, Vec3};
 use bevy_reflect::prelude::*;
 use bevy_transform::components::GlobalTransform;
 use bevy_utils::HashSet;
-use bevy_window::{WindowCreated, WindowId, WindowResized, Windows};
+use bevy_window::{Window, WindowCreated, WindowResized, WindowResolution};
 use serde::{Deserialize, Serialize};
 use std::{borrow::Cow, ops::Range};
 use wgpu::Extent3d;
@@ -97,7 +98,7 @@ impl Default for Camera {
             priority: 0,
             viewport: None,
             computed: Default::default(),
-            target: Default::default(),
+            target: RenderTarget::PrimaryWindow,
             depth_calculation: Default::default(),
         }
     }
@@ -220,15 +221,17 @@ impl CameraRenderGraph {
 /// swapchain or an [`Image`].
 #[derive(Debug, Clone, Reflect, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub enum RenderTarget {
+    /// Renders the camera's view to the current primary window
+    PrimaryWindow,
     /// Window to which the camera's view is rendered.
-    Window(WindowId),
+    Window(Entity),
     /// Image to which the camera's view is rendered.
     Image(Handle<Image>),
 }
 
 impl Default for RenderTarget {
     fn default() -> Self {
-        Self::Window(Default::default())
+        Self::PrimaryWindow
     }
 }
 
@@ -245,20 +248,28 @@ impl RenderTarget {
             RenderTarget::Image(image_handle) => {
                 images.get(image_handle).map(|image| &image.texture_view)
             }
+            RenderTarget::PrimaryWindow => todo!(),
         }
     }
 
     pub fn get_render_target_info(
         &self,
-        windows: &Windows,
+        windows: &Query<&WindowResolution, With<Window>>, // TODO: Maybe this could just be a Vec?
         images: &Assets<Image>,
     ) -> Option<RenderTargetInfo> {
         Some(match self {
             RenderTarget::Window(window_id) => {
-                let window = windows.get(*window_id)?;
-                RenderTargetInfo {
-                    physical_size: UVec2::new(window.physical_width(), window.physical_height()),
-                    scale_factor: window.scale_factor(),
+                if let Ok(resolution) = windows.get(*window_id) {
+                    RenderTargetInfo {
+                        physical_size: UVec2::new(
+                            resolution.physical_width(),
+                            resolution.physical_height(),
+                        ),
+                        scale_factor: resolution.scale_factor(),
+                    }
+                } else {
+                    // TODO: Helpful panic comment
+                    panic!("Render target does not point to a valid window");
                 }
             }
             RenderTarget::Image(image_handle) => {
@@ -269,17 +280,20 @@ impl RenderTarget {
                     scale_factor: 1.0,
                 }
             }
+            RenderTarget::PrimaryWindow => todo!(),
         })
     }
+
     // Check if this render target is contained in the given changed windows or images.
     fn is_changed(
         &self,
-        changed_window_ids: &[WindowId],
+        changed_window_ids: &[Entity],
         changed_image_handles: &HashSet<&Handle<Image>>,
     ) -> bool {
         match self {
             RenderTarget::Window(window_id) => changed_window_ids.contains(window_id),
             RenderTarget::Image(image_handle) => changed_image_handles.contains(&image_handle),
+            RenderTarget::PrimaryWindow => todo!(),
         }
     }
 }
@@ -303,32 +317,32 @@ pub fn camera_system<T: CameraProjection + Component>(
     mut window_resized_events: EventReader<WindowResized>,
     mut window_created_events: EventReader<WindowCreated>,
     mut image_asset_events: EventReader<AssetEvent<Image>>,
-    windows: Res<Windows>,
+    windows: Query<&WindowResolution, With<Window>>,
     images: Res<Assets<Image>>,
     mut queries: ParamSet<(
         Query<(Entity, &mut Camera, &mut T)>,
         Query<Entity, Added<Camera>>,
     )>,
 ) {
-    let mut changed_window_ids = Vec::new();
+    let mut changed_window_ids: Vec<Entity> = Vec::new();
     // handle resize events. latest events are handled first because we only want to resize each
     // window once
     for event in window_resized_events.iter().rev() {
-        if changed_window_ids.contains(&event.id) {
+        if changed_window_ids.contains(&event.entity) {
             continue;
         }
 
-        changed_window_ids.push(event.id);
+        changed_window_ids.push(event.entity);
     }
 
     // handle resize events. latest events are handled first because we only want to resize each
     // window once
     for event in window_created_events.iter().rev() {
-        if changed_window_ids.contains(&event.id) {
+        if changed_window_ids.contains(&event.entity) {
             continue;
         }
 
-        changed_window_ids.push(event.id);
+        changed_window_ids.push(event.entity);
     }
 
     let changed_image_handles: HashSet<&Handle<Image>> = image_asset_events

crates/bevy_render/src/lib.rs

@@ -27,7 +27,9 @@ pub mod prelude {
     };
 }
 
+use bevy_window::{PrimaryWindow, Window, WindowHandle};
 pub use once_cell;
+use settings::WgpuSettings;
 
 use crate::{
     camera::CameraPlugin,
@@ -42,8 +44,9 @@ use crate::{
 };
 use bevy_app::{App, AppLabel, Plugin};
 use bevy_asset::{AddAsset, AssetServer};
-use bevy_ecs::prelude::*;
+use bevy_ecs::{prelude::*, system::SystemState};
 use bevy_utils::tracing::debug;
+use core::panic;
 use std::ops::{Deref, DerefMut};
 
 /// Contains the default Bevy rendering backend based on wgpu.
@@ -114,27 +117,58 @@ 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) {
+        app.add_asset::<Shader>()
+            .add_debug_asset::<Shader>()
+            .init_asset_loader::<ShaderLoader>()
+            .init_debug_asset_loader::<ShaderLoader>()
+            .register_type::<Color>();
+
         let options = app
             .world
             .get_resource::<settings::WgpuSettings>()
             .cloned()
             .unwrap_or_default();
 
-        app.add_asset::<Shader>()
-            .add_debug_asset::<Shader>()
-            .init_asset_loader::<ShaderLoader>()
-            .init_debug_asset_loader::<ShaderLoader>()
-            .register_type::<Color>();
+        bevy_utils::tracing::info!("Tryin to request primarywindow");
+
+        let mut system_state: SystemState<(
+            Query<&WindowHandle, With<Window>>,
+            Res<PrimaryWindow>,
+            // Res<WgpuSettings>,
+        )> = SystemState::new(&mut app.world);
+        let (
+            window_query,
+            primary_window,
+            // options, // This was .clone().unwrap_or_default(). Will this work the same?
+        ) = system_state.get(&mut app.world);
+
+        bevy_utils::tracing::info!("Should have resource here");
 
         if let Some(backends) = options.backends {
             let instance = wgpu::Instance::new(backends);
             let surface = {
-                let windows = app.world.resource_mut::<bevy_window::Windows>();
-                let raw_handle = windows.get_primary().map(|window| unsafe {
-                    let handle = window.raw_window_handle().get_handle();
-                    instance.create_surface(&handle)
-                });
-                raw_handle
+                // TODO: This can probably be cleaner
+                if let Ok(handle_component) = window_query.get(
+                    primary_window
+                        .window
+                        .expect("There should be a primary window"),
+                ) {
+                    // TODO: Make sure this is ok
+                    unsafe {
+                        let handle = handle_component.raw_window_handle().get_handle();
+                        Some(instance.create_surface(&handle))
+                    }
+                } else {
+                    // TODO: Helpful panic comment
+                    panic!("No WindowHandle component on primary window");
+                }
+                // let handle_component =
+                // // let windows = app.world.resource_mut::<bevy_window::Windows>();
+                // let raw_handle = windows.get_primary().map(|window| unsafe {
+                //     let handle = window.raw_window_handle().get_handle();
+                //     instance.create_surface(&handle)
+                // });
+                // raw_handle
             };
             let request_adapter_options = wgpu::RequestAdapterOptions {
                 power_preference: options.power_preference,

crates/bevy_render/src/view/window.rs

@@ -7,7 +7,10 @@ use crate::{
 use bevy_app::{App, Plugin};
 use bevy_ecs::prelude::*;
 use bevy_utils::{tracing::debug, HashMap, HashSet};
-use bevy_window::{PresentMode, RawWindowHandleWrapper, WindowClosed, WindowId, Windows};
+use bevy_window::{
+    PresentMode, RawWindowHandleWrapper, Window, WindowClosed, WindowHandle, WindowPresentation,
+    WindowResolution,
+};
 use std::ops::{Deref, DerefMut};
 use wgpu::TextureFormat;
 
@@ -39,7 +42,7 @@ impl Plugin for WindowRenderPlugin {
 }
 
 pub struct ExtractedWindow {
-    pub id: WindowId,
+    pub id: Entity,
     pub handle: RawWindowHandleWrapper,
     pub physical_width: u32,
     pub physical_height: u32,
@@ -50,11 +53,11 @@ pub struct ExtractedWindow {
 
 #[derive(Default)]
 pub struct ExtractedWindows {
-    pub windows: HashMap<WindowId, ExtractedWindow>,
+    pub windows: HashMap<Entity, ExtractedWindow>,
 }
 
 impl Deref for ExtractedWindows {
-    type Target = HashMap<WindowId, ExtractedWindow>;
+    type Target = HashMap<Entity, ExtractedWindow>;
 
     fn deref(&self) -> &Self::Target {
         &self.windows
@@ -70,27 +73,32 @@ impl DerefMut for ExtractedWindows {
 fn extract_windows(
     mut render_world: ResMut<RenderWorld>,
     mut closed: EventReader<WindowClosed>,
-    windows: Res<Windows>,
+    windows: Query<
+        (
+            Entity,
+            &WindowResolution,
+            &WindowHandle,
+            &WindowPresentation,
+        ),
+        With<Window>,
+    >,
 ) {
     let mut extracted_windows = render_world.get_resource_mut::<ExtractedWindows>().unwrap();
-    for window in windows.iter() {
+    for (entity, resolution, handle, presentation) in windows.iter() {
         let (new_width, new_height) = (
-            window.physical_width().max(1),
-            window.physical_height().max(1),
+            resolution.physical_width().max(1),
+            resolution.physical_height().max(1),
         );
 
-        let mut extracted_window =
-            extracted_windows
-                .entry(window.id())
-                .or_insert(ExtractedWindow {
-                    id: window.id(),
-                    handle: window.raw_window_handle(),
-                    physical_width: new_width,
-                    physical_height: new_height,
-                    present_mode: window.present_mode(),
-                    swap_chain_texture: None,
-                    size_changed: false,
-                });
+        let mut extracted_window = extracted_windows.entry(entity).or_insert(ExtractedWindow {
+            id: entity,
+            handle: handle.raw_window_handle(),
+            physical_width: new_width,
+            physical_height: new_height,
+            present_mode: presentation.present_mode(),
+            swap_chain_texture: None,
+            size_changed: false,
+        });
 
         // NOTE: Drop the swap chain frame here
         extracted_window.swap_chain_texture = None;
@@ -110,15 +118,15 @@ fn extract_windows(
         }
     }
     for closed_window in closed.iter() {
-        extracted_windows.remove(&closed_window.id);
+        extracted_windows.remove(&closed_window.entity);
     }
 }
 
 #[derive(Default)]
 pub struct WindowSurfaces {
-    surfaces: HashMap<WindowId, wgpu::Surface>,
+    surfaces: HashMap<Entity, wgpu::Surface>,
     /// List of windows that we have already called the initial `configure_surface` for
-    configured_windows: HashSet<WindowId>,
+    configured_windows: HashSet<Entity>,
 }
 
 pub fn prepare_windows(