From aa8cae7551bb9beae2128362a14022afd3c63d64 Mon Sep 17 00:00:00 2001
From: Bude <kirmesbude@gmail.com>
Date: Fri, 28 May 2021 11:40:40 +0200
Subject: [PATCH 01/17] issue-1031: Add base functionality to change window
 icon at runtime

---
 crates/bevy_window/Cargo.toml      |  1 +
 crates/bevy_window/src/window.rs   | 25 +++++++++++++++++++++++++
 crates/bevy_winit/src/lib.rs       | 14 +++++++++-----
 examples/window/window_settings.rs | 27 +++++++++++++++++++++++++++
 4 files changed, 62 insertions(+), 5 deletions(-)

diff --git a/crates/bevy_window/Cargo.toml b/crates/bevy_window/Cargo.toml
index b7064f986612e..1939fd326a252 100644
--- a/crates/bevy_window/Cargo.toml
+++ b/crates/bevy_window/Cargo.toml
@@ -18,6 +18,7 @@ bevy_app = { path = "../bevy_app", version = "0.5.0" }
 bevy_ecs = { path = "../bevy_ecs", version = "0.5.0" }
 bevy_math = { path = "../bevy_math", version = "0.5.0" }
 bevy_utils = { path = "../bevy_utils", version = "0.5.0" }
+bevy_asset = { path = "../bevy_asset", version = "0.5.0" }
 
 # other
 
diff --git a/crates/bevy_window/src/window.rs b/crates/bevy_window/src/window.rs
index be3a6c0f99230..57dbcfdf0a2a3 100644
--- a/crates/bevy_window/src/window.rs
+++ b/crates/bevy_window/src/window.rs
@@ -1,5 +1,6 @@
 use bevy_math::{IVec2, Vec2};
 use bevy_utils::{tracing::warn, Uuid};
+use bevy_asset::Handle;
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 pub struct WindowId(Uuid);
@@ -127,6 +128,7 @@ pub struct Window {
     mode: WindowMode,
     #[cfg(target_arch = "wasm32")]
     pub canvas: Option<String>,
+    icon: Option<WindowIcon>,
     command_queue: Vec<WindowCommand>,
 }
 
@@ -176,6 +178,9 @@ pub enum WindowCommand {
     SetResizeConstraints {
         resize_constraints: WindowResizeConstraints,
     },
+    SetWindowIcon {
+        icon: Option<WindowIcon>,
+    },
 }
 
 /// Defines the way a window is displayed
@@ -220,6 +225,7 @@ impl Window {
             mode: window_descriptor.mode,
             #[cfg(target_arch = "wasm32")]
             canvas: window_descriptor.canvas.clone(),
+            icon: window_descriptor.icon,
             command_queue: Vec::new(),
         }
     }
@@ -511,6 +517,23 @@ impl Window {
     pub fn is_focused(&self) -> bool {
         self.focused
     }
+
+    #[inline]
+    pub fn icon(&self) -> Option<WindowIcon> {
+        self.icon
+    }
+
+    pub fn set_icon(&mut self, icon: Option<WindowIcon>) {
+        self.icon = icon;
+        self.command_queue.push(WindowCommand::SetWindowIcon {
+            icon,
+        });
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct WindowIcon {
+    /* icon: Handle<Texture>, */
 }
 
 #[derive(Debug, Clone)]
@@ -528,6 +551,7 @@ pub struct WindowDescriptor {
     pub mode: WindowMode,
     #[cfg(target_arch = "wasm32")]
     pub canvas: Option<String>,
+    pub icon: Option<WindowIcon>,
 }
 
 impl Default for WindowDescriptor {
@@ -546,6 +570,7 @@ impl Default for WindowDescriptor {
             mode: WindowMode::Windowed,
             #[cfg(target_arch = "wasm32")]
             canvas: None,
+            icon: None,
         }
     }
 }
diff --git a/crates/bevy_winit/src/lib.rs b/crates/bevy_winit/src/lib.rs
index 3ba197c05c9f2..a5f4ab6e2fc5d 100644
--- a/crates/bevy_winit/src/lib.rs
+++ b/crates/bevy_winit/src/lib.rs
@@ -14,15 +14,12 @@ use bevy_app::{App, AppBuilder, AppExit, CoreStage, Events, ManualEventReader, P
 use bevy_ecs::{system::IntoExclusiveSystem, world::World};
 use bevy_math::{ivec2, Vec2};
 use bevy_utils::tracing::{error, trace, warn};
-use bevy_window::{
-    CreateWindow, CursorEntered, CursorLeft, CursorMoved, FileDragAndDrop, ReceivedCharacter,
-    WindowBackendScaleFactorChanged, WindowCloseRequested, WindowCreated, WindowFocused,
-    WindowMoved, WindowResized, WindowScaleFactorChanged, Windows,
-};
+use bevy_window::{CreateWindow, CursorEntered, CursorLeft, CursorMoved, FileDragAndDrop, ReceivedCharacter, WindowBackendScaleFactorChanged, WindowCloseRequested, WindowCommand, WindowCreated, WindowFocused, WindowMoved, WindowResized, WindowScaleFactorChanged, Windows};
 use winit::{
     dpi::PhysicalPosition,
     event::{self, DeviceEvent, Event, WindowEvent},
     event_loop::{ControlFlow, EventLoop, EventLoopWindowTarget},
+    window::Icon,
 };
 
 use winit::dpi::LogicalSize;
@@ -158,6 +155,13 @@ fn change_window(world: &mut World) {
                         window.set_max_inner_size(Some(max_inner_size));
                     }
                 }
+                bevy_window::WindowCommand::SetWindowIcon { icon } => {
+                    let window = winit_windows.get_window(id).unwrap();
+                    //let winit_icon = Icon::default;
+                    let winit_icon = None;
+
+                    window.set_window_icon(winit_icon);
+                }
             }
         }
     }
diff --git a/examples/window/window_settings.rs b/examples/window/window_settings.rs
index 3c7719916ac2e..a357e2570ba27 100644
--- a/examples/window/window_settings.rs
+++ b/examples/window/window_settings.rs
@@ -10,12 +10,28 @@ fn main() {
             vsync: true,
             ..Default::default()
         })
+        .insert_resource(IconResource::default())
         .add_plugins(DefaultPlugins)
+        .add_startup_system(setup.system())
         .add_system(change_title.system())
         .add_system(toggle_cursor.system())
+        .add_system(toggle_icon.system())
         .run();
 }
 
+#[derive(Debug, Clone, Default)]
+struct IconResource {
+    handle: Handle<Texture>,
+}
+
+fn setup(
+    asset_server: Res<AssetServer>,
+    mut icon_resource: ResMut<IconResource>,
+) {
+    let icon: /* TODO */ Handle<Texture> = asset_server.load("android-res/mipmap-mdpi/ic_launcher.png");
+    (*icon_resource).handle = icon;
+}
+
 /// This system will then change the title during execution
 fn change_title(time: Res<Time>, mut windows: ResMut<Windows>) {
     let window = windows.get_primary_mut().unwrap();
@@ -33,3 +49,14 @@ fn toggle_cursor(input: Res<Input<KeyCode>>, mut windows: ResMut<Windows>) {
         window.set_cursor_visibility(!window.cursor_visible());
     }
 }
+
+fn toggle_icon(input: Res<Input<KeyCode>>, mut windows: ResMut<Windows>, textures: Res<Assets<Texture>>, icon_resource: Res<IconResource>) {
+    let window = windows.get_primary_mut().unwrap();
+    let icon = textures.get(icon_resource.handle.clone());
+    if input.just_pressed(KeyCode::I) {
+        match window.icon() {
+            None => window.set_icon(None /* TODO */),
+            _ => window.set_icon(None),
+        }
+    }
+}
\ No newline at end of file

From 2cd4c3f9d6242febedd1272676aa4acb80cdc587 Mon Sep 17 00:00:00 2001
From: Bude <kirmesbude@gmail.com>
Date: Fri, 28 May 2021 12:00:32 +0200
Subject: [PATCH 02/17] issue-1031: Change window icon at runtime

---
 crates/bevy_window/Cargo.toml      |  1 -
 crates/bevy_window/src/window.rs   | 15 ++++++++-------
 crates/bevy_winit/src/lib.rs       | 21 ++++++++++++---------
 examples/window/window_settings.rs |  9 ++++++---
 4 files changed, 26 insertions(+), 20 deletions(-)

diff --git a/crates/bevy_window/Cargo.toml b/crates/bevy_window/Cargo.toml
index 1939fd326a252..b7064f986612e 100644
--- a/crates/bevy_window/Cargo.toml
+++ b/crates/bevy_window/Cargo.toml
@@ -18,7 +18,6 @@ bevy_app = { path = "../bevy_app", version = "0.5.0" }
 bevy_ecs = { path = "../bevy_ecs", version = "0.5.0" }
 bevy_math = { path = "../bevy_math", version = "0.5.0" }
 bevy_utils = { path = "../bevy_utils", version = "0.5.0" }
-bevy_asset = { path = "../bevy_asset", version = "0.5.0" }
 
 # other
 
diff --git a/crates/bevy_window/src/window.rs b/crates/bevy_window/src/window.rs
index 57dbcfdf0a2a3..cc3ac35818f4d 100644
--- a/crates/bevy_window/src/window.rs
+++ b/crates/bevy_window/src/window.rs
@@ -1,6 +1,5 @@
 use bevy_math::{IVec2, Vec2};
 use bevy_utils::{tracing::warn, Uuid};
-use bevy_asset::Handle;
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 pub struct WindowId(Uuid);
@@ -225,7 +224,7 @@ impl Window {
             mode: window_descriptor.mode,
             #[cfg(target_arch = "wasm32")]
             canvas: window_descriptor.canvas.clone(),
-            icon: window_descriptor.icon,
+            icon: window_descriptor.icon.clone(),
             command_queue: Vec::new(),
         }
     }
@@ -520,20 +519,22 @@ impl Window {
 
     #[inline]
     pub fn icon(&self) -> Option<WindowIcon> {
-        self.icon
+        self.icon.clone()
     }
 
     pub fn set_icon(&mut self, icon: Option<WindowIcon>) {
-        self.icon = icon;
+        self.icon = icon.clone();
         self.command_queue.push(WindowCommand::SetWindowIcon {
-            icon,
+            icon: icon.clone(),
         });
     }
 }
 
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone)]
 pub struct WindowIcon {
-    /* icon: Handle<Texture>, */
+    pub rgba: Vec<u8>,
+    pub width: u32,
+    pub height: u32,
 }
 
 #[derive(Debug, Clone)]
diff --git a/crates/bevy_winit/src/lib.rs b/crates/bevy_winit/src/lib.rs
index a5f4ab6e2fc5d..c67ab8a97e1f4 100644
--- a/crates/bevy_winit/src/lib.rs
+++ b/crates/bevy_winit/src/lib.rs
@@ -14,13 +14,8 @@ use bevy_app::{App, AppBuilder, AppExit, CoreStage, Events, ManualEventReader, P
 use bevy_ecs::{system::IntoExclusiveSystem, world::World};
 use bevy_math::{ivec2, Vec2};
 use bevy_utils::tracing::{error, trace, warn};
-use bevy_window::{CreateWindow, CursorEntered, CursorLeft, CursorMoved, FileDragAndDrop, ReceivedCharacter, WindowBackendScaleFactorChanged, WindowCloseRequested, WindowCommand, WindowCreated, WindowFocused, WindowMoved, WindowResized, WindowScaleFactorChanged, Windows};
-use winit::{
-    dpi::PhysicalPosition,
-    event::{self, DeviceEvent, Event, WindowEvent},
-    event_loop::{ControlFlow, EventLoop, EventLoopWindowTarget},
-    window::Icon,
-};
+use bevy_window::{CreateWindow, CursorEntered, CursorLeft, CursorMoved, FileDragAndDrop, ReceivedCharacter, WindowBackendScaleFactorChanged, WindowCloseRequested, WindowCreated, WindowFocused, WindowMoved, WindowResized, WindowScaleFactorChanged, Windows};
+use winit::{dpi::PhysicalPosition, event::{self, DeviceEvent, Event, WindowEvent}, event_loop::{ControlFlow, EventLoop, EventLoopWindowTarget}, window::Icon};
 
 use winit::dpi::LogicalSize;
 #[cfg(any(
@@ -157,8 +152,16 @@ fn change_window(world: &mut World) {
                 }
                 bevy_window::WindowCommand::SetWindowIcon { icon } => {
                     let window = winit_windows.get_window(id).unwrap();
-                    //let winit_icon = Icon::default;
-                    let winit_icon = None;
+                    
+                    let winit_icon = match icon {
+                        Some(icon) => {
+                            match Icon::from_rgba(icon.rgba, icon.width, icon.height) {
+                                Ok(res) => Some(res),
+                                _ => /* TODO */ None,
+                            }
+                        },
+                        _ => None,
+                    };
 
                     window.set_window_icon(winit_icon);
                 }
diff --git a/examples/window/window_settings.rs b/examples/window/window_settings.rs
index a357e2570ba27..ba9edb4550a5e 100644
--- a/examples/window/window_settings.rs
+++ b/examples/window/window_settings.rs
@@ -54,9 +54,12 @@ fn toggle_icon(input: Res<Input<KeyCode>>, mut windows: ResMut<Windows>, texture
     let window = windows.get_primary_mut().unwrap();
     let icon = textures.get(icon_resource.handle.clone());
     if input.just_pressed(KeyCode::I) {
-        match window.icon() {
-            None => window.set_icon(None /* TODO */),
-            _ => window.set_icon(None),
+        match icon {
+            None => (),
+            Some(texture) =>         match window.icon() {
+                None => window.set_icon(Some( bevy::window::WindowIcon { rgba: texture.data.clone(), width: texture.size.width, height: texture.size.height }) ),
+                _ => window.set_icon(None),
+            },
         }
     }
 }
\ No newline at end of file

From f69eff81a083665c5b0905aecd6b28aabe14a35f Mon Sep 17 00:00:00 2001
From: Bude <kirmesbude@gmail.com>
Date: Fri, 28 May 2021 20:26:30 +0200
Subject: [PATCH 03/17] issue-1031: Texture Handle solution with cyclic
 dependency

---
 crates/bevy_window/Cargo.toml          |  2 ++
 crates/bevy_window/src/window.rs       | 11 +++----
 crates/bevy_winit/Cargo.toml           |  2 ++
 crates/bevy_winit/src/lib.rs           | 45 ++++++++++++++++++++------
 crates/bevy_winit/src/winit_windows.rs | 10 ++++--
 examples/window/window_settings.rs     | 25 +++++++-------
 6 files changed, 64 insertions(+), 31 deletions(-)

diff --git a/crates/bevy_window/Cargo.toml b/crates/bevy_window/Cargo.toml
index b7064f986612e..c0fcd47ef66ee 100644
--- a/crates/bevy_window/Cargo.toml
+++ b/crates/bevy_window/Cargo.toml
@@ -18,6 +18,8 @@ bevy_app = { path = "../bevy_app", version = "0.5.0" }
 bevy_ecs = { path = "../bevy_ecs", version = "0.5.0" }
 bevy_math = { path = "../bevy_math", version = "0.5.0" }
 bevy_utils = { path = "../bevy_utils", version = "0.5.0" }
+bevy_asset = { path = "../bevy_asset", version = "0.5.0" }
+# bevy_render = { path = "../bevy_render", version = "0.5.0" }
 
 # other
 
diff --git a/crates/bevy_window/src/window.rs b/crates/bevy_window/src/window.rs
index cc3ac35818f4d..55ee07164313d 100644
--- a/crates/bevy_window/src/window.rs
+++ b/crates/bevy_window/src/window.rs
@@ -1,4 +1,6 @@
+use bevy_asset::Handle;
 use bevy_math::{IVec2, Vec2};
+use bevy_render::texture::Texture;
 use bevy_utils::{tracing::warn, Uuid};
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
@@ -524,17 +526,14 @@ impl Window {
 
     pub fn set_icon(&mut self, icon: Option<WindowIcon>) {
         self.icon = icon.clone();
-        self.command_queue.push(WindowCommand::SetWindowIcon {
-            icon: icon.clone(),
-        });
+        self.command_queue
+            .push(WindowCommand::SetWindowIcon { icon: icon.clone() });
     }
 }
 
 #[derive(Debug, Clone)]
 pub struct WindowIcon {
-    pub rgba: Vec<u8>,
-    pub width: u32,
-    pub height: u32,
+    pub handle: Handle<Texture>,
 }
 
 #[derive(Debug, Clone)]
diff --git a/crates/bevy_winit/Cargo.toml b/crates/bevy_winit/Cargo.toml
index 48167668fd49d..d6aa6bbddac1d 100644
--- a/crates/bevy_winit/Cargo.toml
+++ b/crates/bevy_winit/Cargo.toml
@@ -25,6 +25,8 @@ bevy_log = { path = "../bevy_log", version = "0.5.0" }
 bevy_math = { path = "../bevy_math", version = "0.5.0" }
 bevy_window = { path = "../bevy_window", version = "0.5.0" }
 bevy_utils = { path = "../bevy_utils", version = "0.5.0" }
+bevy_asset = { path = "../bevy_asset", version = "0.5.0" }
+# bevy_render = { path = "../bevy_render", version = "0.5.0" }
 
 # other
 winit = { version = "0.25.0", default-features = false }
diff --git a/crates/bevy_winit/src/lib.rs b/crates/bevy_winit/src/lib.rs
index c67ab8a97e1f4..95a0042a1086e 100644
--- a/crates/bevy_winit/src/lib.rs
+++ b/crates/bevy_winit/src/lib.rs
@@ -11,11 +11,23 @@ pub use winit_config::*;
 pub use winit_windows::*;
 
 use bevy_app::{App, AppBuilder, AppExit, CoreStage, Events, ManualEventReader, Plugin};
+use bevy_asset::Handle;
 use bevy_ecs::{system::IntoExclusiveSystem, world::World};
 use bevy_math::{ivec2, Vec2};
+use bevy_render::texture::Texture;
 use bevy_utils::tracing::{error, trace, warn};
-use bevy_window::{CreateWindow, CursorEntered, CursorLeft, CursorMoved, FileDragAndDrop, ReceivedCharacter, WindowBackendScaleFactorChanged, WindowCloseRequested, WindowCreated, WindowFocused, WindowMoved, WindowResized, WindowScaleFactorChanged, Windows};
-use winit::{dpi::PhysicalPosition, event::{self, DeviceEvent, Event, WindowEvent}, event_loop::{ControlFlow, EventLoop, EventLoopWindowTarget}, window::Icon};
+use bevy_window::{
+    CreateWindow, CursorEntered, CursorLeft, CursorMoved, FileDragAndDrop, ReceivedCharacter,
+    WindowBackendScaleFactorChanged, WindowCloseRequested, WindowCreated, WindowFocused,
+    WindowMoved, WindowResized, WindowScaleFactorChanged, Windows,
+};
+
+use winit::{
+    dpi::PhysicalPosition,
+    event::{self, DeviceEvent, Event, WindowEvent},
+    event_loop::{ControlFlow, EventLoop, EventLoopWindowTarget},
+    window::Icon,
+};
 
 use winit::dpi::LogicalSize;
 #[cfg(any(
@@ -151,16 +163,31 @@ fn change_window(world: &mut World) {
                     }
                 }
                 bevy_window::WindowCommand::SetWindowIcon { icon } => {
+                    let texture_assets = world.get_resource_mut::<Assets<Texture>>().unwrap();
                     let window = winit_windows.get_window(id).unwrap();
-                    
+
                     let winit_icon = match icon {
-                        Some(icon) => {
-                            match Icon::from_rgba(icon.rgba, icon.width, icon.height) {
-                                Ok(res) => Some(res),
-                                _ => /* TODO */ None,
+                        Some(window_icon) => {
+                            match texture_assets.get(&window_icon.handle) {
+                                None => {
+                                    warn!("Setting window icon with texture that was not yet loaded: {}", window_icon.handle);
+                                    bevy_window.set_icon(icon); // We queue up the command again, so the icon is set as soon as possible
+                                    return;
+                                }
+                                Some(texture) => match Icon::from_rgba(
+                                    texture.data,
+                                    texture.size.width,
+                                    texture.size.height,
+                                ) {
+                                    Ok(icon) => Some(icon),
+                                    Err(e) => {
+                                        error!("Unable to create window icon: {}", e);
+                                        None
+                                    }
+                                },
                             }
-                        },
-                        _ => None,
+                        }
+                        None => None,
                     };
 
                     window.set_window_icon(winit_icon);
diff --git a/crates/bevy_winit/src/winit_windows.rs b/crates/bevy_winit/src/winit_windows.rs
index e3a3c518c0421..86bd2d56ffdf3 100644
--- a/crates/bevy_winit/src/winit_windows.rs
+++ b/crates/bevy_winit/src/winit_windows.rs
@@ -138,14 +138,20 @@ impl WinitWindows {
         let inner_size = winit_window.inner_size();
         let scale_factor = winit_window.scale_factor();
         self.windows.insert(winit_window.id(), winit_window);
-        Window::new(
+
+        let window = Window::new(
             window_id,
             &window_descriptor,
             inner_size.width,
             inner_size.height,
             scale_factor,
             position,
-        )
+        );
+
+        /* TODO: How would we even provide a Handle at this point? */
+        window.set_icon(window_descriptor.icon); /* This will queue up SetWindowIcon until the asset has loaded */
+
+        window
     }
 
     pub fn get_window(&self, id: WindowId) -> Option<&winit::window::Window> {
diff --git a/examples/window/window_settings.rs b/examples/window/window_settings.rs
index ba9edb4550a5e..edd0c2dfbece7 100644
--- a/examples/window/window_settings.rs
+++ b/examples/window/window_settings.rs
@@ -24,11 +24,8 @@ struct IconResource {
     handle: Handle<Texture>,
 }
 
-fn setup(
-    asset_server: Res<AssetServer>,
-    mut icon_resource: ResMut<IconResource>,
-) {
-    let icon: /* TODO */ Handle<Texture> = asset_server.load("android-res/mipmap-mdpi/ic_launcher.png");
+fn setup(asset_server: Res<AssetServer>, mut icon_resource: ResMut<IconResource>) {
+    let icon = asset_server.load("android-res/mipmap-mdpi/ic_launcher.png");
     (*icon_resource).handle = icon;
 }
 
@@ -50,16 +47,16 @@ fn toggle_cursor(input: Res<Input<KeyCode>>, mut windows: ResMut<Windows>) {
     }
 }
 
-fn toggle_icon(input: Res<Input<KeyCode>>, mut windows: ResMut<Windows>, textures: Res<Assets<Texture>>, icon_resource: Res<IconResource>) {
+fn toggle_icon(
+    input: Res<Input<KeyCode>>,
+    mut windows: ResMut<Windows>,
+    icon_resource: Res<IconResource>,
+) {
     let window = windows.get_primary_mut().unwrap();
-    let icon = textures.get(icon_resource.handle.clone());
     if input.just_pressed(KeyCode::I) {
-        match icon {
-            None => (),
-            Some(texture) =>         match window.icon() {
-                None => window.set_icon(Some( bevy::window::WindowIcon { rgba: texture.data.clone(), width: texture.size.width, height: texture.size.height }) ),
-                _ => window.set_icon(None),
-            },
+        match window.icon() {
+            None => window.set_icon(Some(icon_resource.handle.clone())),
+            _ => window.set_icon(None),
         }
     }
-}
\ No newline at end of file
+}

From b6d555e72432f8187d7a28a34f5dc273c802bcd8 Mon Sep 17 00:00:00 2001
From: Bude <kirmesbude@gmail.com>
Date: Sat, 29 May 2021 14:38:08 +0200
Subject: [PATCH 04/17] issue-1031: Fix simple review comments

Remove unnecessary clone calls
Initialize and change resources in the example correctly
Check the load state of the texture handle to determine whether to re-issue the SetWindowIcon command again
Return early if winit icon creation from rgba8 buffer fails
---
 crates/bevy_window/src/window.rs   |  6 ++---
 crates/bevy_winit/src/lib.rs       | 39 +++++++++++++++++++-----------
 examples/window/window_settings.rs |  4 +--
 3 files changed, 30 insertions(+), 19 deletions(-)

diff --git a/crates/bevy_window/src/window.rs b/crates/bevy_window/src/window.rs
index 55ee07164313d..bd9e4baaabe43 100644
--- a/crates/bevy_window/src/window.rs
+++ b/crates/bevy_window/src/window.rs
@@ -520,14 +520,14 @@ impl Window {
     }
 
     #[inline]
-    pub fn icon(&self) -> Option<WindowIcon> {
-        self.icon.clone()
+    pub fn icon(&self) -> Option<&WindowIcon> {
+        self.icon.as_ref()
     }
 
     pub fn set_icon(&mut self, icon: Option<WindowIcon>) {
         self.icon = icon.clone();
         self.command_queue
-            .push(WindowCommand::SetWindowIcon { icon: icon.clone() });
+            .push(WindowCommand::SetWindowIcon { icon });
     }
 }
 
diff --git a/crates/bevy_winit/src/lib.rs b/crates/bevy_winit/src/lib.rs
index 95a0042a1086e..657c1dea73675 100644
--- a/crates/bevy_winit/src/lib.rs
+++ b/crates/bevy_winit/src/lib.rs
@@ -163,28 +163,39 @@ fn change_window(world: &mut World) {
                     }
                 }
                 bevy_window::WindowCommand::SetWindowIcon { icon } => {
-                    let texture_assets = world.get_resource_mut::<Assets<Texture>>().unwrap();
+                    let asset_server = world.get_resource::<AssetServer>().unwrap();
+                    let texture_assets = world.get_resource::<Assets<Texture>>().unwrap();
                     let window = winit_windows.get_window(id).unwrap();
 
                     let winit_icon = match icon {
                         Some(window_icon) => {
-                            match texture_assets.get(&window_icon.handle) {
-                                None => {
+                            match asset_server.get_load_state(&window_icon.handle) {
+                                LoadState::Loading => {
                                     warn!("Setting window icon with texture that was not yet loaded: {}", window_icon.handle);
-                                    bevy_window.set_icon(icon); // We queue up the command again, so the icon is set as soon as possible
+                                    bevy_window.set_icon(icon); // We queue up the command again, so the icon is set as soon as it is loaded
                                     return;
                                 }
-                                Some(texture) => match Icon::from_rgba(
-                                    texture.data,
-                                    texture.size.width,
-                                    texture.size.height,
-                                ) {
-                                    Ok(icon) => Some(icon),
-                                    Err(e) => {
-                                        error!("Unable to create window icon: {}", e);
-                                        None
+                                LoadState::Loaded => {
+                                    let texture = texture_assets.get(&window_icon.handle).unwrap();
+                                    match Icon::from_rgba(
+                                        texture.data,
+                                        texture.size.width,
+                                        texture.size.height,
+                                    ) {
+                                        Ok(icon) => Some(icon),
+                                        Err(e) => {
+                                            error!("Unable to create window icon: {}", e);
+                                            return;
+                                        }
                                     }
-                                },
+                                }
+                                _ => {
+                                    error!(
+                                        "Handle to create window icon points to unloaded asset: {}",
+                                        window_icon.handle
+                                    );
+                                    return;
+                                }
                             }
                         }
                         None => None,
diff --git a/examples/window/window_settings.rs b/examples/window/window_settings.rs
index edd0c2dfbece7..6e39b87e6b006 100644
--- a/examples/window/window_settings.rs
+++ b/examples/window/window_settings.rs
@@ -10,7 +10,7 @@ fn main() {
             vsync: true,
             ..Default::default()
         })
-        .insert_resource(IconResource::default())
+        .insert_resource(IconResource)
         .add_plugins(DefaultPlugins)
         .add_startup_system(setup.system())
         .add_system(change_title.system())
@@ -26,7 +26,7 @@ struct IconResource {
 
 fn setup(asset_server: Res<AssetServer>, mut icon_resource: ResMut<IconResource>) {
     let icon = asset_server.load("android-res/mipmap-mdpi/ic_launcher.png");
-    (*icon_resource).handle = icon;
+    icon_resource.handle = icon;
 }
 
 /// This system will then change the title during execution

From 9fde6377108c0de3b2b7701a69f2b2389041f641 Mon Sep 17 00:00:00 2001
From: Bude <kirmesbude@gmail.com>
Date: Sat, 29 May 2021 14:59:51 +0200
Subject: [PATCH 05/17] issue-1031: Establish dependency on bevy_render in
 bevy_winit

---
 crates/bevy_winit/Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_winit/Cargo.toml b/crates/bevy_winit/Cargo.toml
index d6aa6bbddac1d..863bee3e7ddff 100644
--- a/crates/bevy_winit/Cargo.toml
+++ b/crates/bevy_winit/Cargo.toml
@@ -26,7 +26,7 @@ bevy_math = { path = "../bevy_math", version = "0.5.0" }
 bevy_window = { path = "../bevy_window", version = "0.5.0" }
 bevy_utils = { path = "../bevy_utils", version = "0.5.0" }
 bevy_asset = { path = "../bevy_asset", version = "0.5.0" }
-# bevy_render = { path = "../bevy_render", version = "0.5.0" }
+bevy_render = { path = "../bevy_render", version = "0.5.0" }
 
 # other
 winit = { version = "0.25.0", default-features = false }

From bca3954101b4f4dd9750245a1ed16d0718bf088d Mon Sep 17 00:00:00 2001
From: Bude <kirmesbude@gmail.com>
Date: Sun, 30 May 2021 12:32:13 +0200
Subject: [PATCH 06/17] issue-1031: Add set_icon_path, set_icon and clear_icon

set_icon_path does not yet do anything. The same is true for setting the icon in WindowDescriptor
set_icon works right now by providing a rgba buffer as well as widht and height
clear_icon simply call the winit set icon function with None
---
 crates/bevy_window/Cargo.toml          |  1 -
 crates/bevy_window/src/window.rs       | 60 +++++++++++++++++++-------
 crates/bevy_winit/Cargo.toml           |  2 -
 crates/bevy_winit/src/lib.rs           | 52 ++++++----------------
 crates/bevy_winit/src/winit_windows.rs |  6 ++-
 examples/window/window_settings.rs     | 19 ++++++--
 6 files changed, 78 insertions(+), 62 deletions(-)

diff --git a/crates/bevy_window/Cargo.toml b/crates/bevy_window/Cargo.toml
index c0fcd47ef66ee..1939fd326a252 100644
--- a/crates/bevy_window/Cargo.toml
+++ b/crates/bevy_window/Cargo.toml
@@ -19,7 +19,6 @@ bevy_ecs = { path = "../bevy_ecs", version = "0.5.0" }
 bevy_math = { path = "../bevy_math", version = "0.5.0" }
 bevy_utils = { path = "../bevy_utils", version = "0.5.0" }
 bevy_asset = { path = "../bevy_asset", version = "0.5.0" }
-# bevy_render = { path = "../bevy_render", version = "0.5.0" }
 
 # other
 
diff --git a/crates/bevy_window/src/window.rs b/crates/bevy_window/src/window.rs
index bd9e4baaabe43..503c8ec19d32f 100644
--- a/crates/bevy_window/src/window.rs
+++ b/crates/bevy_window/src/window.rs
@@ -1,6 +1,4 @@
-use bevy_asset::Handle;
 use bevy_math::{IVec2, Vec2};
-use bevy_render::texture::Texture;
 use bevy_utils::{tracing::warn, Uuid};
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
@@ -20,7 +18,10 @@ impl WindowId {
     }
 }
 
-use std::fmt;
+use std::{
+    fmt,
+    path::{Path, PathBuf},
+};
 
 impl fmt::Display for WindowId {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -92,6 +93,13 @@ impl WindowResizeConstraints {
     }
 }
 
+#[derive(Debug, Clone)]
+pub struct WindowIcon {
+    pub bytes: Vec<u8>,
+    pub width: u32,
+    pub height: u32,
+}
+
 /// An operating system window that can present content and receive user input.
 ///
 /// ## Window Sizes
@@ -129,6 +137,7 @@ pub struct Window {
     mode: WindowMode,
     #[cfg(target_arch = "wasm32")]
     pub canvas: Option<String>,
+    icon_path: Option<PathBuf>,
     icon: Option<WindowIcon>,
     command_queue: Vec<WindowCommand>,
 }
@@ -179,9 +188,13 @@ pub enum WindowCommand {
     SetResizeConstraints {
         resize_constraints: WindowResizeConstraints,
     },
-    SetWindowIcon {
-        icon: Option<WindowIcon>,
+    SetIconPath {
+        path: PathBuf,
+    },
+    SetIcon {
+        icon: WindowIcon,
     },
+    ClearIcon,
 }
 
 /// Defines the way a window is displayed
@@ -226,7 +239,8 @@ impl Window {
             mode: window_descriptor.mode,
             #[cfg(target_arch = "wasm32")]
             canvas: window_descriptor.canvas.clone(),
-            icon: window_descriptor.icon.clone(),
+            icon_path: window_descriptor.icon_path.clone(),
+            icon: None,
             command_queue: Vec::new(),
         }
     }
@@ -519,21 +533,37 @@ impl Window {
         self.focused
     }
 
+    #[inline]
+    pub fn icon_path(&self) -> Option<&Path> {
+        self.icon_path.as_deref()
+    }
+
+    pub fn set_icon_path(&mut self, path: &Path) {
+        self.icon_path = Some(path.to_path_buf());
+
+        self.command_queue.push(WindowCommand::SetIconPath {
+            path: path.to_owned(),
+        })
+    }
+
     #[inline]
     pub fn icon(&self) -> Option<&WindowIcon> {
         self.icon.as_ref()
     }
 
-    pub fn set_icon(&mut self, icon: Option<WindowIcon>) {
-        self.icon = icon.clone();
+    pub fn set_icon(&mut self, icon: WindowIcon) {
+        self.icon = Some(icon.clone());
+
         self.command_queue
-            .push(WindowCommand::SetWindowIcon { icon });
+            .push(WindowCommand::SetIcon { icon });
     }
-}
 
-#[derive(Debug, Clone)]
-pub struct WindowIcon {
-    pub handle: Handle<Texture>,
+    pub fn clear_icon(&mut self) {
+        self.icon = None;
+        self.icon_path = None;
+
+        self.command_queue.push(WindowCommand::ClearIcon);
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -551,7 +581,7 @@ pub struct WindowDescriptor {
     pub mode: WindowMode,
     #[cfg(target_arch = "wasm32")]
     pub canvas: Option<String>,
-    pub icon: Option<WindowIcon>,
+    pub icon_path: Option<PathBuf>,
 }
 
 impl Default for WindowDescriptor {
@@ -570,7 +600,7 @@ impl Default for WindowDescriptor {
             mode: WindowMode::Windowed,
             #[cfg(target_arch = "wasm32")]
             canvas: None,
-            icon: None,
+            icon_path: None,
         }
     }
 }
diff --git a/crates/bevy_winit/Cargo.toml b/crates/bevy_winit/Cargo.toml
index 863bee3e7ddff..48167668fd49d 100644
--- a/crates/bevy_winit/Cargo.toml
+++ b/crates/bevy_winit/Cargo.toml
@@ -25,8 +25,6 @@ bevy_log = { path = "../bevy_log", version = "0.5.0" }
 bevy_math = { path = "../bevy_math", version = "0.5.0" }
 bevy_window = { path = "../bevy_window", version = "0.5.0" }
 bevy_utils = { path = "../bevy_utils", version = "0.5.0" }
-bevy_asset = { path = "../bevy_asset", version = "0.5.0" }
-bevy_render = { path = "../bevy_render", version = "0.5.0" }
 
 # other
 winit = { version = "0.25.0", default-features = false }
diff --git a/crates/bevy_winit/src/lib.rs b/crates/bevy_winit/src/lib.rs
index 657c1dea73675..0ad6d82167396 100644
--- a/crates/bevy_winit/src/lib.rs
+++ b/crates/bevy_winit/src/lib.rs
@@ -11,10 +11,8 @@ pub use winit_config::*;
 pub use winit_windows::*;
 
 use bevy_app::{App, AppBuilder, AppExit, CoreStage, Events, ManualEventReader, Plugin};
-use bevy_asset::Handle;
 use bevy_ecs::{system::IntoExclusiveSystem, world::World};
 use bevy_math::{ivec2, Vec2};
-use bevy_render::texture::Texture;
 use bevy_utils::tracing::{error, trace, warn};
 use bevy_window::{
     CreateWindow, CursorEntered, CursorLeft, CursorMoved, FileDragAndDrop, ReceivedCharacter,
@@ -162,46 +160,24 @@ fn change_window(world: &mut World) {
                         window.set_max_inner_size(Some(max_inner_size));
                     }
                 }
-                bevy_window::WindowCommand::SetWindowIcon { icon } => {
-                    let asset_server = world.get_resource::<AssetServer>().unwrap();
-                    let texture_assets = world.get_resource::<Assets<Texture>>().unwrap();
+                bevy_window::WindowCommand::SetIconPath { path } => {
+                    let _ = path;
+                }
+                bevy_window::WindowCommand::SetIcon { icon } => {
                     let window = winit_windows.get_window(id).unwrap();
 
-                    let winit_icon = match icon {
-                        Some(window_icon) => {
-                            match asset_server.get_load_state(&window_icon.handle) {
-                                LoadState::Loading => {
-                                    warn!("Setting window icon with texture that was not yet loaded: {}", window_icon.handle);
-                                    bevy_window.set_icon(icon); // We queue up the command again, so the icon is set as soon as it is loaded
-                                    return;
-                                }
-                                LoadState::Loaded => {
-                                    let texture = texture_assets.get(&window_icon.handle).unwrap();
-                                    match Icon::from_rgba(
-                                        texture.data,
-                                        texture.size.width,
-                                        texture.size.height,
-                                    ) {
-                                        Ok(icon) => Some(icon),
-                                        Err(e) => {
-                                            error!("Unable to create window icon: {}", e);
-                                            return;
-                                        }
-                                    }
-                                }
-                                _ => {
-                                    error!(
-                                        "Handle to create window icon points to unloaded asset: {}",
-                                        window_icon.handle
-                                    );
-                                    return;
-                                }
-                            }
+                    match Icon::from_rgba(icon.bytes, icon.width, icon.height) {
+                        Ok(icon) => window.set_window_icon(Some(icon)),
+                        Err(e) => {
+                            error!("Unable to create window icon: {}", e);
+                            return;
                         }
-                        None => None,
-                    };
+                    }
+                }
+                bevy_window::WindowCommand::ClearIcon => {
+                    let window = winit_windows.get_window(id).unwrap();
 
-                    window.set_window_icon(winit_icon);
+                    window.set_window_icon(None);
                 }
             }
         }
diff --git a/crates/bevy_winit/src/winit_windows.rs b/crates/bevy_winit/src/winit_windows.rs
index 86bd2d56ffdf3..1c61fa92348ab 100644
--- a/crates/bevy_winit/src/winit_windows.rs
+++ b/crates/bevy_winit/src/winit_windows.rs
@@ -139,7 +139,7 @@ impl WinitWindows {
         let scale_factor = winit_window.scale_factor();
         self.windows.insert(winit_window.id(), winit_window);
 
-        let window = Window::new(
+        let mut window = Window::new(
             window_id,
             &window_descriptor,
             inner_size.width,
@@ -149,7 +149,9 @@ impl WinitWindows {
         );
 
         /* TODO: How would we even provide a Handle at this point? */
-        window.set_icon(window_descriptor.icon); /* This will queue up SetWindowIcon until the asset has loaded */
+        if let Some(icon_path) = &window_descriptor.icon_path {
+            window.set_icon_path(icon_path); /* This will queue up SetWindowIcon until the asset has loaded */
+        }
 
         window
     }
diff --git a/examples/window/window_settings.rs b/examples/window/window_settings.rs
index 6e39b87e6b006..95a0a4189adae 100644
--- a/examples/window/window_settings.rs
+++ b/examples/window/window_settings.rs
@@ -1,4 +1,4 @@
-use bevy::prelude::*;
+use bevy::{prelude::*, window::WindowIcon};
 
 /// This example illustrates how to customize the default window settings
 fn main() {
@@ -10,7 +10,7 @@ fn main() {
             vsync: true,
             ..Default::default()
         })
-        .insert_resource(IconResource)
+        .insert_resource(IconResource::default())
         .add_plugins(DefaultPlugins)
         .add_startup_system(setup.system())
         .add_system(change_title.system())
@@ -51,12 +51,23 @@ fn toggle_icon(
     input: Res<Input<KeyCode>>,
     mut windows: ResMut<Windows>,
     icon_resource: Res<IconResource>,
+    textures: Res<Assets<Texture>>,
 ) {
     let window = windows.get_primary_mut().unwrap();
     if input.just_pressed(KeyCode::I) {
         match window.icon() {
-            None => window.set_icon(Some(icon_resource.handle.clone())),
-            _ => window.set_icon(None),
+            None => {
+                if let Some(texture) = textures.get(&icon_resource.handle) {
+                    let window_icon = WindowIcon {
+                        bytes: texture.data.clone(),
+                        width: texture.size.width,
+                        height: texture.size.height,
+                    };
+
+                    window.set_icon(window_icon);
+                }
+            }
+            _ => window.clear_icon(),
         }
     }
 }

From 177b8c9bf19f90a5a9e0730c75446080c521c5b0 Mon Sep 17 00:00:00 2001
From: Bude <kirmesbude@gmail.com>
Date: Tue, 1 Jun 2021 20:36:49 +0200
Subject: [PATCH 07/17] issue-1031: initial icon_path solution

---
 crates/bevy_render/src/lib.rs      | 54 ++++++++++++++++++++++++++++--
 crates/bevy_window/src/window.rs   |  3 +-
 examples/window/window_settings.rs |  3 ++
 3 files changed, 56 insertions(+), 4 deletions(-)

diff --git a/crates/bevy_render/src/lib.rs b/crates/bevy_render/src/lib.rs
index 0bd7c77f586ee..9c3816c0047e4 100644
--- a/crates/bevy_render/src/lib.rs
+++ b/crates/bevy_render/src/lib.rs
@@ -12,12 +12,16 @@ pub mod shader;
 pub mod texture;
 pub mod wireframe;
 
+use std::path::PathBuf;
+
 use bevy_ecs::{
+    prelude::{Local, ResMut},
     schedule::{ParallelSystemDescriptorCoercion, SystemStage},
     system::{IntoExclusiveSystem, IntoSystem, Res},
 };
 use bevy_transform::TransformSystem;
-use bevy_utils::tracing::warn;
+use bevy_utils::{tracing::warn, HashMap};
+use bevy_window::{WindowIcon, WindowId, Windows};
 use draw::{OutsideFrustum, Visible};
 
 pub use once_cell;
@@ -40,7 +44,7 @@ pub mod prelude {
 use crate::prelude::*;
 use base::Msaa;
 use bevy_app::prelude::*;
-use bevy_asset::{AddAsset, AssetStage};
+use bevy_asset::{AddAsset, AssetServer, AssetStage, Assets, Handle, LoadState};
 use bevy_ecs::schedule::{StageLabel, SystemLabel};
 use camera::{
     ActiveCameras, Camera, DepthCalculation, OrthographicProjection, PerspectiveProjection,
@@ -202,6 +206,7 @@ impl Plugin for RenderPlugin {
                 .label(RenderSystem::VisibleEntities)
                 .after(TransformSystem::TransformPropagate),
         )
+        .add_system_to_stage(CoreStage::PostUpdate, window_icon_system.system())
         .add_system_to_stage(
             RenderStage::RenderResource,
             shader::shader_update_system.system(),
@@ -248,3 +253,48 @@ fn check_for_render_resource_context(context: Option<Res<Box<dyn RenderResourceC
         );
     }
 }
+
+pub fn window_icon_system(
+    mut map: Local<HashMap<WindowId, (PathBuf, Handle<Texture>)>>,
+    textures: Res<Assets<Texture>>,
+    mut windows: ResMut<Windows>,
+    asset_server: ResMut<AssetServer>,
+) {
+    for window in windows.iter_mut() {
+        /* Insert new icon changed */
+        if let Some(path) = window.icon_path() {
+            if let Some((map_path, _)) = map.get(&window.id()) {
+                if path != map_path {
+                    let handle = asset_server.load(path);
+
+                    map.insert(window.id(), (path.to_path_buf(), handle));
+                }
+            } else {
+                let handle = asset_server.load(path);
+
+                map.insert(window.id(), (path.to_path_buf(), handle));
+            }
+        }
+
+        /* Poll load state of handle and set the icon */
+        if let Some((_, handle)) = map.get(&window.id()) {
+            match asset_server.get_load_state(handle) {
+                LoadState::Loaded => {
+                    let texture = textures.get(handle).unwrap();
+                    let window_icon = WindowIcon {
+                        bytes: texture.data.clone(),
+                        width: texture.size.width,
+                        height: texture.size.height,
+                    };
+                    window.set_icon(window_icon);
+
+                    map.remove_entry(&window.id());
+                }
+                LoadState::Failed => {
+                    map.remove_entry(&window.id());
+                }
+                _ => { /* Do nothing */ }
+            }
+        }
+    }
+}
diff --git a/crates/bevy_window/src/window.rs b/crates/bevy_window/src/window.rs
index 503c8ec19d32f..f2a4577b34340 100644
--- a/crates/bevy_window/src/window.rs
+++ b/crates/bevy_window/src/window.rs
@@ -554,8 +554,7 @@ impl Window {
     pub fn set_icon(&mut self, icon: WindowIcon) {
         self.icon = Some(icon.clone());
 
-        self.command_queue
-            .push(WindowCommand::SetIcon { icon });
+        self.command_queue.push(WindowCommand::SetIcon { icon });
     }
 
     pub fn clear_icon(&mut self) {
diff --git a/examples/window/window_settings.rs b/examples/window/window_settings.rs
index 95a0a4189adae..a2bd7868a2f7c 100644
--- a/examples/window/window_settings.rs
+++ b/examples/window/window_settings.rs
@@ -1,3 +1,5 @@
+use std::path::PathBuf;
+
 use bevy::{prelude::*, window::WindowIcon};
 
 /// This example illustrates how to customize the default window settings
@@ -8,6 +10,7 @@ fn main() {
             width: 500.,
             height: 300.,
             vsync: true,
+            icon_path: Some(PathBuf::from("android-res/mipmap-mdpi/ic_launcher.png")),
             ..Default::default()
         })
         .insert_resource(IconResource::default())

From 9f041c493b2423de489ab2f18aceac1bd11cdbf8 Mon Sep 17 00:00:00 2001
From: Bude <kirmesbude@gmail.com>
Date: Tue, 1 Jun 2021 21:47:22 +0200
Subject: [PATCH 08/17] issue-1031: implement better (?) system for window icon
 changes

Use enum for WindowIcon to combine path and bytes
---
 crates/bevy_render/src/lib.rs          | 36 ++++++++++-----------
 crates/bevy_window/src/window.rs       | 45 +++++++++++++++-----------
 crates/bevy_winit/src/lib.rs           | 28 +++++++++-------
 crates/bevy_winit/src/winit_windows.rs |  5 ++-
 examples/window/window_settings.rs     |  9 ++++--
 5 files changed, 68 insertions(+), 55 deletions(-)

diff --git a/crates/bevy_render/src/lib.rs b/crates/bevy_render/src/lib.rs
index 9c3816c0047e4..6f55b3d5e8594 100644
--- a/crates/bevy_render/src/lib.rs
+++ b/crates/bevy_render/src/lib.rs
@@ -12,8 +12,6 @@ pub mod shader;
 pub mod texture;
 pub mod wireframe;
 
-use std::path::PathBuf;
-
 use bevy_ecs::{
     prelude::{Local, ResMut},
     schedule::{ParallelSystemDescriptorCoercion, SystemStage},
@@ -21,7 +19,7 @@ use bevy_ecs::{
 };
 use bevy_transform::TransformSystem;
 use bevy_utils::{tracing::warn, HashMap};
-use bevy_window::{WindowIcon, WindowId, Windows};
+use bevy_window::{WindowCommand, WindowIcon, WindowIconBytes, WindowId, Windows};
 use draw::{OutsideFrustum, Visible};
 
 pub use once_cell;
@@ -206,7 +204,10 @@ impl Plugin for RenderPlugin {
                 .label(RenderSystem::VisibleEntities)
                 .after(TransformSystem::TransformPropagate),
         )
-        .add_system_to_stage(CoreStage::PostUpdate, window_icon_system.system())
+        .add_system_to_stage(
+            CoreStage::PreUpdate,
+            window_icon_changed.system(), /* TODO: label? */
+        )
         .add_system_to_stage(
             RenderStage::RenderResource,
             shader::shader_update_system.system(),
@@ -254,38 +255,35 @@ fn check_for_render_resource_context(context: Option<Res<Box<dyn RenderResourceC
     }
 }
 
-pub fn window_icon_system(
-    mut map: Local<HashMap<WindowId, (PathBuf, Handle<Texture>)>>,
+fn window_icon_changed(
+    mut map: Local<HashMap<WindowId, Handle<Texture>>>,
     textures: Res<Assets<Texture>>,
     mut windows: ResMut<Windows>,
     asset_server: ResMut<AssetServer>,
 ) {
     for window in windows.iter_mut() {
         /* Insert new icon changed */
-        if let Some(path) = window.icon_path() {
-            if let Some((map_path, _)) = map.get(&window.id()) {
-                if path != map_path {
-                    let handle = asset_server.load(path);
-
-                    map.insert(window.id(), (path.to_path_buf(), handle));
-                }
-            } else {
-                let handle = asset_server.load(path);
+        for command in window.command_queue() {
+            if let WindowCommand::SetIcon {
+                icon: WindowIcon::Path(path),
+            } = command
+            {
+                let handle = asset_server.load(path.to_owned());
 
-                map.insert(window.id(), (path.to_path_buf(), handle));
+                map.insert(window.id(), handle);
             }
         }
 
         /* Poll load state of handle and set the icon */
-        if let Some((_, handle)) = map.get(&window.id()) {
+        if let Some(handle) = map.get(&window.id()) {
             match asset_server.get_load_state(handle) {
                 LoadState::Loaded => {
                     let texture = textures.get(handle).unwrap();
-                    let window_icon = WindowIcon {
+                    let window_icon = WindowIcon::from(WindowIconBytes {
                         bytes: texture.data.clone(),
                         width: texture.size.width,
                         height: texture.size.height,
-                    };
+                    });
                     window.set_icon(window_icon);
 
                     map.remove_entry(&window.id());
diff --git a/crates/bevy_window/src/window.rs b/crates/bevy_window/src/window.rs
index f2a4577b34340..cf74c5dbb6042 100644
--- a/crates/bevy_window/src/window.rs
+++ b/crates/bevy_window/src/window.rs
@@ -94,12 +94,33 @@ impl WindowResizeConstraints {
 }
 
 #[derive(Debug, Clone)]
-pub struct WindowIcon {
+pub struct WindowIconBytes {
     pub bytes: Vec<u8>,
     pub width: u32,
     pub height: u32,
 }
 
+#[derive(Debug, Clone)]
+pub enum WindowIcon {
+    Path(PathBuf),
+    Bytes(WindowIconBytes),
+}
+
+impl<T> From<T> for WindowIcon
+where
+    T: AsRef<Path>,
+{
+    fn from(path: T) -> Self {
+        WindowIcon::Path(path.as_ref().to_path_buf())
+    }
+}
+
+impl From<WindowIconBytes> for WindowIcon {
+    fn from(window_icon_bytes: WindowIconBytes) -> Self {
+        WindowIcon::Bytes(window_icon_bytes)
+    }
+}
+
 /// An operating system window that can present content and receive user input.
 ///
 /// ## Window Sizes
@@ -137,7 +158,6 @@ pub struct Window {
     mode: WindowMode,
     #[cfg(target_arch = "wasm32")]
     pub canvas: Option<String>,
-    icon_path: Option<PathBuf>,
     icon: Option<WindowIcon>,
     command_queue: Vec<WindowCommand>,
 }
@@ -188,9 +208,6 @@ pub enum WindowCommand {
     SetResizeConstraints {
         resize_constraints: WindowResizeConstraints,
     },
-    SetIconPath {
-        path: PathBuf,
-    },
     SetIcon {
         icon: WindowIcon,
     },
@@ -239,7 +256,6 @@ impl Window {
             mode: window_descriptor.mode,
             #[cfg(target_arch = "wasm32")]
             canvas: window_descriptor.canvas.clone(),
-            icon_path: window_descriptor.icon_path.clone(),
             icon: None,
             command_queue: Vec::new(),
         }
@@ -529,21 +545,13 @@ impl Window {
     }
 
     #[inline]
-    pub fn is_focused(&self) -> bool {
-        self.focused
+    pub fn command_queue(&self) -> &[WindowCommand] {
+        &self.command_queue
     }
 
     #[inline]
-    pub fn icon_path(&self) -> Option<&Path> {
-        self.icon_path.as_deref()
-    }
-
-    pub fn set_icon_path(&mut self, path: &Path) {
-        self.icon_path = Some(path.to_path_buf());
-
-        self.command_queue.push(WindowCommand::SetIconPath {
-            path: path.to_owned(),
-        })
+    pub fn is_focused(&self) -> bool {
+        self.focused
     }
 
     #[inline]
@@ -559,7 +567,6 @@ impl Window {
 
     pub fn clear_icon(&mut self) {
         self.icon = None;
-        self.icon_path = None;
 
         self.command_queue.push(WindowCommand::ClearIcon);
     }
diff --git a/crates/bevy_winit/src/lib.rs b/crates/bevy_winit/src/lib.rs
index 0ad6d82167396..db4b0a15f62d3 100644
--- a/crates/bevy_winit/src/lib.rs
+++ b/crates/bevy_winit/src/lib.rs
@@ -17,7 +17,7 @@ use bevy_utils::tracing::{error, trace, warn};
 use bevy_window::{
     CreateWindow, CursorEntered, CursorLeft, CursorMoved, FileDragAndDrop, ReceivedCharacter,
     WindowBackendScaleFactorChanged, WindowCloseRequested, WindowCreated, WindowFocused,
-    WindowMoved, WindowResized, WindowScaleFactorChanged, Windows,
+    WindowIcon, WindowMoved, WindowResized, WindowScaleFactorChanged, Windows,
 };
 
 use winit::{
@@ -160,18 +160,24 @@ fn change_window(world: &mut World) {
                         window.set_max_inner_size(Some(max_inner_size));
                     }
                 }
-                bevy_window::WindowCommand::SetIconPath { path } => {
-                    let _ = path;
-                }
                 bevy_window::WindowCommand::SetIcon { icon } => {
-                    let window = winit_windows.get_window(id).unwrap();
-
-                    match Icon::from_rgba(icon.bytes, icon.width, icon.height) {
-                        Ok(icon) => window.set_window_icon(Some(icon)),
-                        Err(e) => {
-                            error!("Unable to create window icon: {}", e);
-                            return;
+                    match icon {
+                        WindowIcon::Bytes(window_icon_bytes) => {
+                            let window = winit_windows.get_window(id).unwrap();
+
+                            match Icon::from_rgba(
+                                window_icon_bytes.bytes,
+                                window_icon_bytes.width,
+                                window_icon_bytes.height,
+                            ) {
+                                Ok(winit_icon) => window.set_window_icon(Some(winit_icon)),
+                                Err(e) => {
+                                    error!("Unable to create window icon: {}", e);
+                                    return;
+                                }
+                            }
                         }
+                        WindowIcon::Path(_) => { /* Do Nothing */ }
                     }
                 }
                 bevy_window::WindowCommand::ClearIcon => {
diff --git a/crates/bevy_winit/src/winit_windows.rs b/crates/bevy_winit/src/winit_windows.rs
index 1c61fa92348ab..d59ab020fc0d9 100644
--- a/crates/bevy_winit/src/winit_windows.rs
+++ b/crates/bevy_winit/src/winit_windows.rs
@@ -1,6 +1,6 @@
 use bevy_math::IVec2;
 use bevy_utils::HashMap;
-use bevy_window::{Window, WindowDescriptor, WindowId, WindowMode};
+use bevy_window::{Window, WindowDescriptor, WindowIcon, WindowId, WindowMode};
 use winit::dpi::LogicalSize;
 
 #[derive(Debug, Default)]
@@ -148,9 +148,8 @@ impl WinitWindows {
             position,
         );
 
-        /* TODO: How would we even provide a Handle at this point? */
         if let Some(icon_path) = &window_descriptor.icon_path {
-            window.set_icon_path(icon_path); /* This will queue up SetWindowIcon until the asset has loaded */
+            window.set_icon(WindowIcon::from(icon_path)); /* This will queue up SetWindowIcon until the asset has loaded */
         }
 
         window
diff --git a/examples/window/window_settings.rs b/examples/window/window_settings.rs
index a2bd7868a2f7c..db40673ea24dd 100644
--- a/examples/window/window_settings.rs
+++ b/examples/window/window_settings.rs
@@ -1,6 +1,9 @@
 use std::path::PathBuf;
 
-use bevy::{prelude::*, window::WindowIcon};
+use bevy::{
+    prelude::*,
+    window::{WindowIcon, WindowIconBytes},
+};
 
 /// This example illustrates how to customize the default window settings
 fn main() {
@@ -61,11 +64,11 @@ fn toggle_icon(
         match window.icon() {
             None => {
                 if let Some(texture) = textures.get(&icon_resource.handle) {
-                    let window_icon = WindowIcon {
+                    let window_icon = WindowIcon::from(WindowIconBytes {
                         bytes: texture.data.clone(),
                         width: texture.size.width,
                         height: texture.size.height,
-                    };
+                    });
 
                     window.set_icon(window_icon);
                 }

From 8a6a1e217e5f4f8bc2e7bd9a6cda75fe8f817a1d Mon Sep 17 00:00:00 2001
From: Bude <kirmesbude@gmail.com>
Date: Wed, 2 Jun 2021 20:30:49 +0200
Subject: [PATCH 09/17] issue-1031: Implement some improvements

Implement From for WindowIcon on Into<PathBuf> instead of AsRef<Path>
set_icon accepts everything that implements Into<WindowIcon> and Clone
Remove from and into call in argument for set_icon (in case path is used)
---
 crates/bevy_render/src/lib.rs          |  2 +-
 crates/bevy_window/src/window.rs       | 16 +++++++---------
 crates/bevy_winit/src/winit_windows.rs |  4 ++--
 3 files changed, 10 insertions(+), 12 deletions(-)

diff --git a/crates/bevy_render/src/lib.rs b/crates/bevy_render/src/lib.rs
index 6f55b3d5e8594..dd1a3f951671c 100644
--- a/crates/bevy_render/src/lib.rs
+++ b/crates/bevy_render/src/lib.rs
@@ -259,7 +259,7 @@ fn window_icon_changed(
     mut map: Local<HashMap<WindowId, Handle<Texture>>>,
     textures: Res<Assets<Texture>>,
     mut windows: ResMut<Windows>,
-    asset_server: ResMut<AssetServer>,
+    asset_server: Res<AssetServer>,
 ) {
     for window in windows.iter_mut() {
         /* Insert new icon changed */
diff --git a/crates/bevy_window/src/window.rs b/crates/bevy_window/src/window.rs
index cf74c5dbb6042..75ab695e99018 100644
--- a/crates/bevy_window/src/window.rs
+++ b/crates/bevy_window/src/window.rs
@@ -18,10 +18,7 @@ impl WindowId {
     }
 }
 
-use std::{
-    fmt,
-    path::{Path, PathBuf},
-};
+use std::{fmt, path::PathBuf};
 
 impl fmt::Display for WindowId {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -108,10 +105,10 @@ pub enum WindowIcon {
 
 impl<T> From<T> for WindowIcon
 where
-    T: AsRef<Path>,
+    T: Into<PathBuf>,
 {
     fn from(path: T) -> Self {
-        WindowIcon::Path(path.as_ref().to_path_buf())
+        WindowIcon::Path(path.into())
     }
 }
 
@@ -559,10 +556,11 @@ impl Window {
         self.icon.as_ref()
     }
 
-    pub fn set_icon(&mut self, icon: WindowIcon) {
-        self.icon = Some(icon.clone());
+    pub fn set_icon(&mut self, icon: impl Into<WindowIcon> + Clone) {
+        self.icon = Some(icon.clone().into());
 
-        self.command_queue.push(WindowCommand::SetIcon { icon });
+        self.command_queue
+            .push(WindowCommand::SetIcon { icon: icon.into() });
     }
 
     pub fn clear_icon(&mut self) {
diff --git a/crates/bevy_winit/src/winit_windows.rs b/crates/bevy_winit/src/winit_windows.rs
index d59ab020fc0d9..7d4dc00b180fc 100644
--- a/crates/bevy_winit/src/winit_windows.rs
+++ b/crates/bevy_winit/src/winit_windows.rs
@@ -1,6 +1,6 @@
 use bevy_math::IVec2;
 use bevy_utils::HashMap;
-use bevy_window::{Window, WindowDescriptor, WindowIcon, WindowId, WindowMode};
+use bevy_window::{Window, WindowDescriptor, WindowId, WindowMode};
 use winit::dpi::LogicalSize;
 
 #[derive(Debug, Default)]
@@ -149,7 +149,7 @@ impl WinitWindows {
         );
 
         if let Some(icon_path) = &window_descriptor.icon_path {
-            window.set_icon(WindowIcon::from(icon_path)); /* This will queue up SetWindowIcon until the asset has loaded */
+            window.set_icon(icon_path); /* This will queue up SetWindowIcon until the asset has loaded */
         }
 
         window

From f70a0982f6bbbf9e68b26caffb9f7a78ddeef4c5 Mon Sep 17 00:00:00 2001
From: Bude <kirmesbude@gmail.com>
Date: Thu, 3 Jun 2021 10:41:40 +0200
Subject: [PATCH 10/17] issue-1031: Do not expose command queue

---
 crates/bevy_render/src/lib.rs    | 20 ++++++++++----------
 crates/bevy_window/src/window.rs |  5 -----
 2 files changed, 10 insertions(+), 15 deletions(-)

diff --git a/crates/bevy_render/src/lib.rs b/crates/bevy_render/src/lib.rs
index dd1a3f951671c..7972ac93808f4 100644
--- a/crates/bevy_render/src/lib.rs
+++ b/crates/bevy_render/src/lib.rs
@@ -19,7 +19,7 @@ use bevy_ecs::{
 };
 use bevy_transform::TransformSystem;
 use bevy_utils::{tracing::warn, HashMap};
-use bevy_window::{WindowCommand, WindowIcon, WindowIconBytes, WindowId, Windows};
+use bevy_window::{WindowIcon, WindowIconBytes, WindowId, Windows};
 use draw::{OutsideFrustum, Visible};
 
 pub use once_cell;
@@ -205,7 +205,7 @@ impl Plugin for RenderPlugin {
                 .after(TransformSystem::TransformPropagate),
         )
         .add_system_to_stage(
-            CoreStage::PreUpdate,
+            CoreStage::PostUpdate,
             window_icon_changed.system(), /* TODO: label? */
         )
         .add_system_to_stage(
@@ -263,15 +263,15 @@ fn window_icon_changed(
 ) {
     for window in windows.iter_mut() {
         /* Insert new icon changed */
-        for command in window.command_queue() {
-            if let WindowCommand::SetIcon {
-                icon: WindowIcon::Path(path),
-            } = command
-            {
-                let handle = asset_server.load(path.to_owned());
-
-                map.insert(window.id(), handle);
+        if let Some(WindowIcon::Path(path)) = window.icon() {
+            if let Some(handle) = map.get(&window.id()) {
+                if let Some(handle_path) = asset_server.get_handle_path(handle) {
+                    if handle_path.path() != path {
+                        map.insert(window.id(), asset_server.load(path.clone()));
+                    }
+                }
             }
+            map.insert(window.id(), asset_server.load(path.clone()));
         }
 
         /* Poll load state of handle and set the icon */
diff --git a/crates/bevy_window/src/window.rs b/crates/bevy_window/src/window.rs
index 75ab695e99018..95aac120ae147 100644
--- a/crates/bevy_window/src/window.rs
+++ b/crates/bevy_window/src/window.rs
@@ -541,11 +541,6 @@ impl Window {
         self.command_queue.drain(..)
     }
 
-    #[inline]
-    pub fn command_queue(&self) -> &[WindowCommand] {
-        &self.command_queue
-    }
-
     #[inline]
     pub fn is_focused(&self) -> bool {
         self.focused

From 7dc13a26c98af15f20691484f547774b94c4dfe5 Mon Sep 17 00:00:00 2001
From: Bude <kirmesbude@gmail.com>
Date: Thu, 3 Jun 2021 10:51:40 +0200
Subject: [PATCH 11/17] issue-1031: Quick fix so icon is not loaded every loop

---
 crates/bevy_render/src/lib.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/crates/bevy_render/src/lib.rs b/crates/bevy_render/src/lib.rs
index 7972ac93808f4..4725cb6f1af0f 100644
--- a/crates/bevy_render/src/lib.rs
+++ b/crates/bevy_render/src/lib.rs
@@ -270,8 +270,9 @@ fn window_icon_changed(
                         map.insert(window.id(), asset_server.load(path.clone()));
                     }
                 }
+            } else {
+                map.insert(window.id(), asset_server.load(path.clone()));
             }
-            map.insert(window.id(), asset_server.load(path.clone()));
         }
 
         /* Poll load state of handle and set the icon */

From 796f85417d4228ae7321bdfcf12603b1a1c4711d Mon Sep 17 00:00:00 2001
From: Bude <kirmesbude@gmail.com>
Date: Thu, 3 Jun 2021 17:58:47 +0200
Subject: [PATCH 12/17] issue-1031: Some small fixes

SetIcon Command only takes window_icon_bytes now
Fix panic caused by unwrap
Changed example to always use path instead of window icon bytes
---
 crates/bevy_render/src/lib.rs      | 18 +++++++-------
 crates/bevy_window/src/window.rs   |  8 ++++---
 crates/bevy_winit/src/lib.rs       | 31 ++++++++++--------------
 examples/window/window_settings.rs | 38 ++++--------------------------
 4 files changed, 32 insertions(+), 63 deletions(-)

diff --git a/crates/bevy_render/src/lib.rs b/crates/bevy_render/src/lib.rs
index 4725cb6f1af0f..068fcfc8b6229 100644
--- a/crates/bevy_render/src/lib.rs
+++ b/crates/bevy_render/src/lib.rs
@@ -279,15 +279,17 @@ fn window_icon_changed(
         if let Some(handle) = map.get(&window.id()) {
             match asset_server.get_load_state(handle) {
                 LoadState::Loaded => {
-                    let texture = textures.get(handle).unwrap();
-                    let window_icon = WindowIcon::from(WindowIconBytes {
-                        bytes: texture.data.clone(),
-                        width: texture.size.width,
-                        height: texture.size.height,
-                    });
-                    window.set_icon(window_icon);
+                    if let Some(texture) = textures.get(handle) {
+                        /* TODO: Why can I not just unwrap here? */
+                        let window_icon = WindowIcon::from(WindowIconBytes {
+                            bytes: texture.data.clone(),
+                            width: texture.size.width,
+                            height: texture.size.height,
+                        });
+                        window.set_icon(window_icon);
 
-                    map.remove_entry(&window.id());
+                        map.remove_entry(&window.id());
+                    }
                 }
                 LoadState::Failed => {
                     map.remove_entry(&window.id());
diff --git a/crates/bevy_window/src/window.rs b/crates/bevy_window/src/window.rs
index 95aac120ae147..f715fbf9ea548 100644
--- a/crates/bevy_window/src/window.rs
+++ b/crates/bevy_window/src/window.rs
@@ -206,7 +206,7 @@ pub enum WindowCommand {
         resize_constraints: WindowResizeConstraints,
     },
     SetIcon {
-        icon: WindowIcon,
+        window_icon_bytes: WindowIconBytes,
     },
     ClearIcon,
 }
@@ -554,8 +554,10 @@ impl Window {
     pub fn set_icon(&mut self, icon: impl Into<WindowIcon> + Clone) {
         self.icon = Some(icon.clone().into());
 
-        self.command_queue
-            .push(WindowCommand::SetIcon { icon: icon.into() });
+        if let WindowIcon::Bytes(window_icon_bytes) = icon.into() {
+            self.command_queue
+                .push(WindowCommand::SetIcon { window_icon_bytes });
+        }
     }
 
     pub fn clear_icon(&mut self) {
diff --git a/crates/bevy_winit/src/lib.rs b/crates/bevy_winit/src/lib.rs
index db4b0a15f62d3..a013c6c9c76e6 100644
--- a/crates/bevy_winit/src/lib.rs
+++ b/crates/bevy_winit/src/lib.rs
@@ -17,7 +17,7 @@ use bevy_utils::tracing::{error, trace, warn};
 use bevy_window::{
     CreateWindow, CursorEntered, CursorLeft, CursorMoved, FileDragAndDrop, ReceivedCharacter,
     WindowBackendScaleFactorChanged, WindowCloseRequested, WindowCreated, WindowFocused,
-    WindowIcon, WindowMoved, WindowResized, WindowScaleFactorChanged, Windows,
+    WindowMoved, WindowResized, WindowScaleFactorChanged, Windows,
 };
 
 use winit::{
@@ -160,24 +160,19 @@ fn change_window(world: &mut World) {
                         window.set_max_inner_size(Some(max_inner_size));
                     }
                 }
-                bevy_window::WindowCommand::SetIcon { icon } => {
-                    match icon {
-                        WindowIcon::Bytes(window_icon_bytes) => {
-                            let window = winit_windows.get_window(id).unwrap();
-
-                            match Icon::from_rgba(
-                                window_icon_bytes.bytes,
-                                window_icon_bytes.width,
-                                window_icon_bytes.height,
-                            ) {
-                                Ok(winit_icon) => window.set_window_icon(Some(winit_icon)),
-                                Err(e) => {
-                                    error!("Unable to create window icon: {}", e);
-                                    return;
-                                }
-                            }
+                bevy_window::WindowCommand::SetIcon { window_icon_bytes } => {
+                    let window = winit_windows.get_window(id).unwrap();
+
+                    match Icon::from_rgba(
+                        window_icon_bytes.bytes,
+                        window_icon_bytes.width,
+                        window_icon_bytes.height,
+                    ) {
+                        Ok(winit_icon) => window.set_window_icon(Some(winit_icon)),
+                        Err(e) => {
+                            error!("Unable to create window icon: {}", e);
+                            return;
                         }
-                        WindowIcon::Path(_) => { /* Do Nothing */ }
                     }
                 }
                 bevy_window::WindowCommand::ClearIcon => {
diff --git a/examples/window/window_settings.rs b/examples/window/window_settings.rs
index db40673ea24dd..75a9b2ac69e3d 100644
--- a/examples/window/window_settings.rs
+++ b/examples/window/window_settings.rs
@@ -1,9 +1,4 @@
-use std::path::PathBuf;
-
-use bevy::{
-    prelude::*,
-    window::{WindowIcon, WindowIconBytes},
-};
+use bevy::prelude::*;
 
 /// This example illustrates how to customize the default window settings
 fn main() {
@@ -13,28 +8,16 @@ fn main() {
             width: 500.,
             height: 300.,
             vsync: true,
-            icon_path: Some(PathBuf::from("android-res/mipmap-mdpi/ic_launcher.png")),
+            icon_path: Some("android-res/mipmap-mdpi/ic_launcher.png".into()),
             ..Default::default()
         })
-        .insert_resource(IconResource::default())
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup.system())
         .add_system(change_title.system())
         .add_system(toggle_cursor.system())
         .add_system(toggle_icon.system())
         .run();
 }
 
-#[derive(Debug, Clone, Default)]
-struct IconResource {
-    handle: Handle<Texture>,
-}
-
-fn setup(asset_server: Res<AssetServer>, mut icon_resource: ResMut<IconResource>) {
-    let icon = asset_server.load("android-res/mipmap-mdpi/ic_launcher.png");
-    icon_resource.handle = icon;
-}
-
 /// This system will then change the title during execution
 fn change_title(time: Res<Time>, mut windows: ResMut<Windows>) {
     let window = windows.get_primary_mut().unwrap();
@@ -53,25 +36,12 @@ fn toggle_cursor(input: Res<Input<KeyCode>>, mut windows: ResMut<Windows>) {
     }
 }
 
-fn toggle_icon(
-    input: Res<Input<KeyCode>>,
-    mut windows: ResMut<Windows>,
-    icon_resource: Res<IconResource>,
-    textures: Res<Assets<Texture>>,
-) {
+fn toggle_icon(input: Res<Input<KeyCode>>, mut windows: ResMut<Windows>) {
     let window = windows.get_primary_mut().unwrap();
     if input.just_pressed(KeyCode::I) {
         match window.icon() {
             None => {
-                if let Some(texture) = textures.get(&icon_resource.handle) {
-                    let window_icon = WindowIcon::from(WindowIconBytes {
-                        bytes: texture.data.clone(),
-                        width: texture.size.width,
-                        height: texture.size.height,
-                    });
-
-                    window.set_icon(window_icon);
-                }
+                window.set_icon("android-res/mipmap-mdpi/ic_launcher.png");
             }
             _ => window.clear_icon(),
         }

From 3bfd68c829899566d14f9a4cc37d58a0901afb9a Mon Sep 17 00:00:00 2001
From: Bude <kirmesbude@gmail.com>
Date: Thu, 3 Jun 2021 20:43:26 +0200
Subject: [PATCH 13/17] issue-1031: Use Entry API

Co-authored-by: Nathan Ward <43621845+NathanSWard@users.noreply.github.com>
---
 crates/bevy_render/src/lib.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/crates/bevy_render/src/lib.rs b/crates/bevy_render/src/lib.rs
index 068fcfc8b6229..55c9985e1a8f7 100644
--- a/crates/bevy_render/src/lib.rs
+++ b/crates/bevy_render/src/lib.rs
@@ -264,14 +264,14 @@ fn window_icon_changed(
     for window in windows.iter_mut() {
         /* Insert new icon changed */
         if let Some(WindowIcon::Path(path)) = window.icon() {
-            if let Some(handle) = map.get(&window.id()) {
-                if let Some(handle_path) = asset_server.get_handle_path(handle) {
-                    if handle_path.path() != path {
-                        map.insert(window.id(), asset_server.load(path.clone()));
+            match map.entry(window.id()) {
+                Entry::Occupied(mut o) => {
+                    let handle_path = asset_server.get_handle_path(o.get()).unwrap();
+                    if handle_path != path {
+                        o.insert(asset_server.load(path.clone());
                     }
                 }
-            } else {
-                map.insert(window.id(), asset_server.load(path.clone()));
+                Entry::Vacant(v) => v.insert(asset_server.load(path.clone()),
             }
         }
 

From 984a8e4c37ddaec24e4c37d40c1348cfde1f770c Mon Sep 17 00:00:00 2001
From: Bude <kirmesbude@gmail.com>
Date: Thu, 3 Jun 2021 20:59:01 +0200
Subject: [PATCH 14/17] issue-1031: Further improve the map handling

---
 crates/bevy_render/src/lib.rs | 21 +++++++++++++--------
 1 file changed, 13 insertions(+), 8 deletions(-)

diff --git a/crates/bevy_render/src/lib.rs b/crates/bevy_render/src/lib.rs
index 55c9985e1a8f7..8df86bd1265ec 100644
--- a/crates/bevy_render/src/lib.rs
+++ b/crates/bevy_render/src/lib.rs
@@ -12,6 +12,8 @@ pub mod shader;
 pub mod texture;
 pub mod wireframe;
 
+use std::collections::hash_map::Entry;
+
 use bevy_ecs::{
     prelude::{Local, ResMut},
     schedule::{ParallelSystemDescriptorCoercion, SystemStage},
@@ -266,21 +268,24 @@ fn window_icon_changed(
         if let Some(WindowIcon::Path(path)) = window.icon() {
             match map.entry(window.id()) {
                 Entry::Occupied(mut o) => {
-                    let handle_path = asset_server.get_handle_path(o.get()).unwrap();
-                    if handle_path != path {
-                        o.insert(asset_server.load(path.clone());
+                    if let Some(handle_path) = asset_server.get_handle_path(o.get()) {
+                        if handle_path.path() != path {
+                            o.insert(asset_server.load(path.clone()));
+                        }
                     }
                 }
-                Entry::Vacant(v) => v.insert(asset_server.load(path.clone()),
+                Entry::Vacant(v) => {
+                    v.insert(asset_server.load(path.clone()));
+                }
             }
         }
 
         /* Poll load state of handle and set the icon */
-        if let Some(handle) = map.get(&window.id()) {
+        if let Entry::Occupied(o) = map.entry(window.id()) {
+            let handle = o.get();
             match asset_server.get_load_state(handle) {
                 LoadState::Loaded => {
                     if let Some(texture) = textures.get(handle) {
-                        /* TODO: Why can I not just unwrap here? */
                         let window_icon = WindowIcon::from(WindowIconBytes {
                             bytes: texture.data.clone(),
                             width: texture.size.width,
@@ -288,11 +293,11 @@ fn window_icon_changed(
                         });
                         window.set_icon(window_icon);
 
-                        map.remove_entry(&window.id());
+                        o.remove();
                     }
                 }
                 LoadState::Failed => {
-                    map.remove_entry(&window.id());
+                    o.remove();
                 }
                 _ => { /* Do nothing */ }
             }

From 85e870d76f735c023dd3853f2cecd6391447a37a Mon Sep 17 00:00:00 2001
From: Bude <kirmesbude@gmail.com>
Date: Sun, 6 Jun 2021 14:23:03 +0200
Subject: [PATCH 15/17] issue-1031: reimplement winit BadIcon error

---
 crates/bevy_render/src/lib.rs    | 29 ++++++++++++-----
 crates/bevy_window/Cargo.toml    |  1 +
 crates/bevy_window/src/window.rs | 53 ++++++++++++++++++++++++++++++--
 crates/bevy_winit/src/lib.rs     | 20 ++++++------
 4 files changed, 82 insertions(+), 21 deletions(-)

diff --git a/crates/bevy_render/src/lib.rs b/crates/bevy_render/src/lib.rs
index 8df86bd1265ec..c18a7aab7f39c 100644
--- a/crates/bevy_render/src/lib.rs
+++ b/crates/bevy_render/src/lib.rs
@@ -20,7 +20,10 @@ use bevy_ecs::{
     system::{IntoExclusiveSystem, IntoSystem, Res},
 };
 use bevy_transform::TransformSystem;
-use bevy_utils::{tracing::warn, HashMap};
+use bevy_utils::{
+    tracing::{error, warn},
+    HashMap,
+};
 use bevy_window::{WindowIcon, WindowIconBytes, WindowId, Windows};
 use draw::{OutsideFrustum, Visible};
 
@@ -286,12 +289,24 @@ fn window_icon_changed(
             match asset_server.get_load_state(handle) {
                 LoadState::Loaded => {
                     if let Some(texture) = textures.get(handle) {
-                        let window_icon = WindowIcon::from(WindowIconBytes {
-                            bytes: texture.data.clone(),
-                            width: texture.size.width,
-                            height: texture.size.height,
-                        });
-                        window.set_icon(window_icon);
+                        /* TODO: Not actually sure if we need to check the error here
+                        Whatever Texture gives us might be fine */
+                        let window_icon_bytes = WindowIconBytes::new(
+                            texture.data.clone(),
+                            texture.size.width,
+                            texture.size.height,
+                        );
+
+                        match window_icon_bytes {
+                            Ok(window_icon_bytes) => {
+                                let window_icon = WindowIcon::from(window_icon_bytes);
+                                window.set_icon(window_icon);
+                            }
+                            Err(e) => error!(
+                                "For handle {:?} the following error was produced: {}",
+                                handle, e
+                            ),
+                        }
 
                         o.remove();
                     }
diff --git a/crates/bevy_window/Cargo.toml b/crates/bevy_window/Cargo.toml
index 1939fd326a252..0d0b453bb22d1 100644
--- a/crates/bevy_window/Cargo.toml
+++ b/crates/bevy_window/Cargo.toml
@@ -21,6 +21,7 @@ bevy_utils = { path = "../bevy_utils", version = "0.5.0" }
 bevy_asset = { path = "../bevy_asset", version = "0.5.0" }
 
 # other
+thiserror = "1.0"
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 web-sys = "0.3"
diff --git a/crates/bevy_window/src/window.rs b/crates/bevy_window/src/window.rs
index f715fbf9ea548..4f8e301373bf5 100644
--- a/crates/bevy_window/src/window.rs
+++ b/crates/bevy_window/src/window.rs
@@ -1,5 +1,6 @@
 use bevy_math::{IVec2, Vec2};
 use bevy_utils::{tracing::warn, Uuid};
+use thiserror::Error;
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 pub struct WindowId(Uuid);
@@ -92,9 +93,20 @@ impl WindowResizeConstraints {
 
 #[derive(Debug, Clone)]
 pub struct WindowIconBytes {
-    pub bytes: Vec<u8>,
-    pub width: u32,
-    pub height: u32,
+    bytes: Vec<u8>,
+    width: u32,
+    height: u32,
+}
+
+#[derive(Error, Debug)]
+pub enum WindowIconBytesError {
+    #[error("32bpp RGBA image buffer expected, but {bytes_length} is not divisible by 4")]
+    NotRGBA { bytes_length: usize },
+    #[error("Buffer size {bytes_length} does not match the expected size based on the dimensions {pixel_bytes_length}")]
+    SizeMismatch {
+        pixel_bytes_length: usize,
+        bytes_length: usize,
+    },
 }
 
 #[derive(Debug, Clone)]
@@ -118,6 +130,41 @@ impl From<WindowIconBytes> for WindowIcon {
     }
 }
 
+impl WindowIconBytes {
+    pub fn new(bytes: Vec<u8>, width: u32, height: u32) -> Result<Self, WindowIconBytesError> {
+        let pixel_count = (width * height) as usize;
+        let pixel_bytes_length = pixel_count * 4;
+        let bytes_length = bytes.len();
+
+        if bytes_length % 4 != 0 {
+            Err(WindowIconBytesError::NotRGBA { bytes_length })
+        } else if pixel_bytes_length != bytes_length {
+            Err(WindowIconBytesError::SizeMismatch {
+                pixel_bytes_length,
+                bytes_length,
+            })
+        } else {
+            Ok(Self {
+                bytes,
+                width,
+                height,
+            })
+        }
+    }
+
+    pub fn bytes(&self) -> &[u8] {
+        &self.bytes
+    }
+
+    pub fn width(&self) -> u32 {
+        self.width
+    }
+
+    pub fn height(&self) -> u32 {
+        self.height
+    }
+}
+
 /// An operating system window that can present content and receive user input.
 ///
 /// ## Window Sizes
diff --git a/crates/bevy_winit/src/lib.rs b/crates/bevy_winit/src/lib.rs
index a013c6c9c76e6..8d3ad733b5b3e 100644
--- a/crates/bevy_winit/src/lib.rs
+++ b/crates/bevy_winit/src/lib.rs
@@ -163,17 +163,15 @@ fn change_window(world: &mut World) {
                 bevy_window::WindowCommand::SetIcon { window_icon_bytes } => {
                     let window = winit_windows.get_window(id).unwrap();
 
-                    match Icon::from_rgba(
-                        window_icon_bytes.bytes,
-                        window_icon_bytes.width,
-                        window_icon_bytes.height,
-                    ) {
-                        Ok(winit_icon) => window.set_window_icon(Some(winit_icon)),
-                        Err(e) => {
-                            error!("Unable to create window icon: {}", e);
-                            return;
-                        }
-                    }
+                    /* Failures should already be covered in WindowIconBytes constructor */
+                    window.set_window_icon(
+                        Icon::from_rgba(
+                            window_icon_bytes.bytes().to_vec(),
+                            window_icon_bytes.width(),
+                            window_icon_bytes.height(),
+                        )
+                        .ok(),
+                    );
                 }
                 bevy_window::WindowCommand::ClearIcon => {
                     let window = winit_windows.get_window(id).unwrap();

From d6eb2f5646b6b47e90c34a3d6a3f594ae7bab0b9 Mon Sep 17 00:00:00 2001
From: KirmesBude <kirmesbude@gmail.com>
Date: Sun, 13 Jun 2021 00:40:09 +0200
Subject: [PATCH 16/17] issue-1031: Unwrap texture from handle

---
 crates/bevy_render/src/lib.rs | 38 +++++++++++++++++------------------
 1 file changed, 19 insertions(+), 19 deletions(-)

diff --git a/crates/bevy_render/src/lib.rs b/crates/bevy_render/src/lib.rs
index c18a7aab7f39c..f3da7da898df8 100644
--- a/crates/bevy_render/src/lib.rs
+++ b/crates/bevy_render/src/lib.rs
@@ -288,28 +288,28 @@ fn window_icon_changed(
             let handle = o.get();
             match asset_server.get_load_state(handle) {
                 LoadState::Loaded => {
-                    if let Some(texture) = textures.get(handle) {
-                        /* TODO: Not actually sure if we need to check the error here
-                        Whatever Texture gives us might be fine */
-                        let window_icon_bytes = WindowIconBytes::new(
-                            texture.data.clone(),
-                            texture.size.width,
-                            texture.size.height,
-                        );
+                    let texture = textures.get(handle).unwrap(); /* Safe to unwrap here, because loadstate==loaded is checked */
 
-                        match window_icon_bytes {
-                            Ok(window_icon_bytes) => {
-                                let window_icon = WindowIcon::from(window_icon_bytes);
-                                window.set_icon(window_icon);
-                            }
-                            Err(e) => error!(
-                                "For handle {:?} the following error was produced: {}",
-                                handle, e
-                            ),
-                        }
+                    /* TODO: Not actually sure if we need to check the error here
+                    Whatever Texture gives us might be fine */
+                    let window_icon_bytes = WindowIconBytes::new(
+                        texture.data.clone(),
+                        texture.size.width,
+                        texture.size.height,
+                    );
 
-                        o.remove();
+                    match window_icon_bytes {
+                        Ok(window_icon_bytes) => {
+                            let window_icon = WindowIcon::from(window_icon_bytes);
+                            window.set_icon(window_icon);
+                        }
+                        Err(e) => error!(
+                            "For handle {:?} the following error was produced: {}",
+                            handle, e
+                        ),
                     }
+
+                    o.remove();
                 }
                 LoadState::Failed => {
                     o.remove();

From cba2b2effc5867d34f39e3e6573a3bd1b3513f14 Mon Sep 17 00:00:00 2001
From: KirmesBude <kirmesbude@gmail.com>
Date: Fri, 18 Jun 2021 18:47:32 +0200
Subject: [PATCH 17/17] issue-1031: Small changes, documentation, comments

---
 crates/bevy_render/src/lib.rs          | 13 ++++---------
 crates/bevy_window/src/window.rs       | 23 +++++++++++++++++++++--
 crates/bevy_winit/src/lib.rs           |  2 +-
 crates/bevy_winit/src/winit_windows.rs |  2 +-
 examples/window/window_settings.rs     |  2 ++
 5 files changed, 29 insertions(+), 13 deletions(-)

diff --git a/crates/bevy_render/src/lib.rs b/crates/bevy_render/src/lib.rs
index f3da7da898df8..daff0d6444855 100644
--- a/crates/bevy_render/src/lib.rs
+++ b/crates/bevy_render/src/lib.rs
@@ -209,10 +209,7 @@ impl Plugin for RenderPlugin {
                 .label(RenderSystem::VisibleEntities)
                 .after(TransformSystem::TransformPropagate),
         )
-        .add_system_to_stage(
-            CoreStage::PostUpdate,
-            window_icon_changed.system(), /* TODO: label? */
-        )
+        .add_system_to_stage(CoreStage::PostUpdate, window_icon_changed.system())
         .add_system_to_stage(
             RenderStage::RenderResource,
             shader::shader_update_system.system(),
@@ -274,8 +271,8 @@ fn window_icon_changed(
                     if let Some(handle_path) = asset_server.get_handle_path(o.get()) {
                         if handle_path.path() != path {
                             o.insert(asset_server.load(path.clone()));
-                        }
-                    }
+                        } /* else we are still attempting to load the initial asset */
+                    } /* else the path from the asset is not available yet */
                 }
                 Entry::Vacant(v) => {
                     v.insert(asset_server.load(path.clone()));
@@ -290,9 +287,7 @@ fn window_icon_changed(
                 LoadState::Loaded => {
                     let texture = textures.get(handle).unwrap(); /* Safe to unwrap here, because loadstate==loaded is checked */
 
-                    /* TODO: Not actually sure if we need to check the error here
-                    Whatever Texture gives us might be fine */
-                    let window_icon_bytes = WindowIconBytes::new(
+                    let window_icon_bytes = WindowIconBytes::from_rgba(
                         texture.data.clone(),
                         texture.size.width,
                         texture.size.height,
diff --git a/crates/bevy_window/src/window.rs b/crates/bevy_window/src/window.rs
index 4f8e301373bf5..89e5f1897fda1 100644
--- a/crates/bevy_window/src/window.rs
+++ b/crates/bevy_window/src/window.rs
@@ -91,6 +91,10 @@ impl WindowResizeConstraints {
     }
 }
 
+/// Generic icon buffer for a window.
+/// Replicates the struct from winit.
+///
+/// Only allows rgba images.
 #[derive(Debug, Clone)]
 pub struct WindowIconBytes {
     bytes: Vec<u8>,
@@ -98,6 +102,7 @@ pub struct WindowIconBytes {
     height: u32,
 }
 
+/// Errors that occur while constructing window icons.
 #[derive(Error, Debug)]
 pub enum WindowIconBytesError {
     #[error("32bpp RGBA image buffer expected, but {bytes_length} is not divisible by 4")]
@@ -109,6 +114,10 @@ pub enum WindowIconBytesError {
     },
 }
 
+/// The icon on a window.
+/// The path buffer in the `Path` variant will be passed to the asset server and will be automatically passed to the window backend.
+///
+/// Make sure that the source image is reasonably sized. Refer to winit's `set_window_icon` function.
 #[derive(Debug, Clone)]
 pub enum WindowIcon {
     Path(PathBuf),
@@ -131,7 +140,14 @@ impl From<WindowIconBytes> for WindowIcon {
 }
 
 impl WindowIconBytes {
-    pub fn new(bytes: Vec<u8>, width: u32, height: u32) -> Result<Self, WindowIconBytesError> {
+    /// Create a window icon from a rgba image.
+    ///
+    /// Returns a `WindowIconBytesError` if `bytes` do not add up to a rgba image or the size does not match the specified width and height.
+    pub fn from_rgba(
+        bytes: Vec<u8>,
+        width: u32,
+        height: u32,
+    ) -> Result<Self, WindowIconBytesError> {
         let pixel_count = (width * height) as usize;
         let pixel_bytes_length = pixel_count * 4;
         let bytes_length = bytes.len();
@@ -152,14 +168,17 @@ impl WindowIconBytes {
         }
     }
 
+    /// Bytes of the rgba icon.
     pub fn bytes(&self) -> &[u8] {
         &self.bytes
     }
 
+    /// Width of the icon.
     pub fn width(&self) -> u32 {
         self.width
     }
 
+    /// Height of the icon.
     pub fn height(&self) -> u32 {
         self.height
     }
@@ -200,9 +219,9 @@ pub struct Window {
     cursor_position: Option<Vec2>,
     focused: bool,
     mode: WindowMode,
+    icon: Option<WindowIcon>,
     #[cfg(target_arch = "wasm32")]
     pub canvas: Option<String>,
-    icon: Option<WindowIcon>,
     command_queue: Vec<WindowCommand>,
 }
 
diff --git a/crates/bevy_winit/src/lib.rs b/crates/bevy_winit/src/lib.rs
index 8d3ad733b5b3e..6021546d67084 100644
--- a/crates/bevy_winit/src/lib.rs
+++ b/crates/bevy_winit/src/lib.rs
@@ -163,7 +163,7 @@ fn change_window(world: &mut World) {
                 bevy_window::WindowCommand::SetIcon { window_icon_bytes } => {
                     let window = winit_windows.get_window(id).unwrap();
 
-                    /* Failures should already be covered in WindowIconBytes constructor */
+                    /* Winit errors are replicated in the WindowIconBytes constructor, so it is safe to ignore here */
                     window.set_window_icon(
                         Icon::from_rgba(
                             window_icon_bytes.bytes().to_vec(),
diff --git a/crates/bevy_winit/src/winit_windows.rs b/crates/bevy_winit/src/winit_windows.rs
index 7d4dc00b180fc..d507e4ad4890f 100644
--- a/crates/bevy_winit/src/winit_windows.rs
+++ b/crates/bevy_winit/src/winit_windows.rs
@@ -149,7 +149,7 @@ impl WinitWindows {
         );
 
         if let Some(icon_path) = &window_descriptor.icon_path {
-            window.set_icon(icon_path); /* This will queue up SetWindowIcon until the asset has loaded */
+            window.set_icon(icon_path); /* This will queue up loading the asset and subsequently set the window icon */
         }
 
         window
diff --git a/examples/window/window_settings.rs b/examples/window/window_settings.rs
index 75a9b2ac69e3d..5a5ab4e5c9196 100644
--- a/examples/window/window_settings.rs
+++ b/examples/window/window_settings.rs
@@ -36,11 +36,13 @@ fn toggle_cursor(input: Res<Input<KeyCode>>, mut windows: ResMut<Windows>) {
     }
 }
 
+/// This system toggles the windows' icon (on/off) when I is pressed
 fn toggle_icon(input: Res<Input<KeyCode>>, mut windows: ResMut<Windows>) {
     let window = windows.get_primary_mut().unwrap();
     if input.just_pressed(KeyCode::I) {
         match window.icon() {
             None => {
+                /* Alternatively you can construct a "buffer-based" WindowIcon and bypass the asset server */
                 window.set_icon("android-res/mipmap-mdpi/ic_launcher.png");
             }
             _ => window.clear_icon(),