From 49f4f42d3916a8f1f77267cb46493510240f6925 Mon Sep 17 00:00:00 2001
From: Jasen Borisov <jamadazi@protonmail.ch>
Date: Wed, 17 Mar 2021 07:56:43 +0100
Subject: [PATCH 01/15] render: prelude: add FilterMode

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

diff --git a/crates/bevy_render/src/lib.rs b/crates/bevy_render/src/lib.rs
index 33d313eea4c59..f4a3fd7fc0696 100644
--- a/crates/bevy_render/src/lib.rs
+++ b/crates/bevy_render/src/lib.rs
@@ -32,7 +32,7 @@ pub mod prelude {
         pass::ClearColor,
         pipeline::RenderPipelines,
         shader::Shader,
-        texture::Texture,
+        texture::{FilterMode, Texture},
     };
 }
 

From 28748b18a596e53ed7a98f8c1e571d89dfe390d4 Mon Sep 17 00:00:00 2001
From: Jasen Borisov <jamadazi@protonmail.ch>
Date: Wed, 17 Mar 2021 07:57:48 +0100
Subject: [PATCH 02/15] quad mesh primitive: add uv_scale field

---
 crates/bevy_render/src/mesh/shape/mod.rs | 26 ++++++++++++++++--------
 1 file changed, 18 insertions(+), 8 deletions(-)

diff --git a/crates/bevy_render/src/mesh/shape/mod.rs b/crates/bevy_render/src/mesh/shape/mod.rs
index 85c61e9ab92f0..49c7350bfca8a 100644
--- a/crates/bevy_render/src/mesh/shape/mod.rs
+++ b/crates/bevy_render/src/mesh/shape/mod.rs
@@ -126,6 +126,8 @@ pub struct Quad {
     pub size: Vec2,
     /// Flips the texture coords of the resulting vertices.
     pub flip: bool,
+    /// Scale the texture to tile it.
+    pub uv_scale: Vec2,
 }
 
 impl Default for Quad {
@@ -136,11 +138,19 @@ impl Default for Quad {
 
 impl Quad {
     pub fn new(size: Vec2) -> Self {
-        Self { size, flip: false }
+        Self {
+            size,
+            flip: false,
+            uv_scale: Vec2::splat(1.0),
+        }
     }
 
     pub fn flipped(size: Vec2) -> Self {
-        Self { size, flip: true }
+        Self {
+            size,
+            flip: true,
+            uv_scale: Vec2::splat(1.0),
+        }
     }
 }
 
@@ -158,12 +168,12 @@ impl From<Quad> for Mesh {
                 (
                     [south_east.x, south_east.y, 0.0],
                     [0.0, 0.0, 1.0],
-                    [1.0, 1.0],
+                    [quad.uv_scale.x, quad.uv_scale.y],
                 ),
                 (
                     [north_east.x, north_east.y, 0.0],
                     [0.0, 0.0, 1.0],
-                    [1.0, 0.0],
+                    [quad.uv_scale.x, 0.0],
                 ),
                 (
                     [north_west.x, north_west.y, 0.0],
@@ -173,7 +183,7 @@ impl From<Quad> for Mesh {
                 (
                     [south_west.x, south_west.y, 0.0],
                     [0.0, 0.0, 1.0],
-                    [0.0, 1.0],
+                    [0.0, quad.uv_scale.y],
                 ),
             ]
         } else {
@@ -181,7 +191,7 @@ impl From<Quad> for Mesh {
                 (
                     [south_west.x, south_west.y, 0.0],
                     [0.0, 0.0, 1.0],
-                    [0.0, 1.0],
+                    [0.0, quad.uv_scale.y],
                 ),
                 (
                     [north_west.x, north_west.y, 0.0],
@@ -191,12 +201,12 @@ impl From<Quad> for Mesh {
                 (
                     [north_east.x, north_east.y, 0.0],
                     [0.0, 0.0, 1.0],
-                    [1.0, 0.0],
+                    [quad.uv_scale.x, 0.0],
                 ),
                 (
                     [south_east.x, south_east.y, 0.0],
                     [0.0, 0.0, 1.0],
-                    [1.0, 1.0],
+                    [quad.uv_scale.x, quad.uv_scale.y],
                 ),
             ]
         };

From 4afd20f423f19f0f3cfc66a6afd594fa4f95f3cd Mon Sep 17 00:00:00 2001
From: Jasen Borisov <jamadazi@protonmail.ch>
Date: Wed, 17 Mar 2021 15:16:05 +0100
Subject: [PATCH 03/15] Add texture_filtering example (WIP no mipmaps)

---
 Cargo.toml                       |   4 +
 examples/3d/texture_filtering.rs | 267 +++++++++++++++++++++++++++++++
 examples/README.md               |   1 +
 3 files changed, 272 insertions(+)
 create mode 100644 examples/3d/texture_filtering.rs

diff --git a/Cargo.toml b/Cargo.toml
index 217249920a53a..d3a9327cc32e8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -165,6 +165,10 @@ path = "examples/3d/spawner.rs"
 name = "texture"
 path = "examples/3d/texture.rs"
 
+[[example]]
+name = "texture_filtering"
+path = "examples/3d/texture_filtering.rs"
+
 [[example]]
 name = "update_gltf_scene"
 path = "examples/3d/update_gltf_scene.rs"
diff --git a/examples/3d/texture_filtering.rs b/examples/3d/texture_filtering.rs
new file mode 100644
index 0000000000000..8dd62d3f0fd65
--- /dev/null
+++ b/examples/3d/texture_filtering.rs
@@ -0,0 +1,267 @@
+use bevy::prelude::*;
+
+use std::num::NonZeroU8;
+
+fn main() {
+    App::build()
+        .add_plugins(DefaultPlugins)
+        .insert_resource(TextureFiltering::Anisotropic)
+        .add_startup_system(setup_plane.system())
+        .add_startup_system(setup_ui.system())
+        .add_system(swing_camera.system())
+        .add_system(switch_filter_mode.system())
+        .run();
+}
+
+struct MainCamera;
+struct ModeText;
+
+struct MainAssets {
+    texture: Handle<Texture>,
+    material: Handle<StandardMaterial>,
+}
+
+enum TextureFiltering {
+    Nearest,
+    Linear,
+    NearestMipmap,
+    LinearMipmap,
+    Anisotropic,
+}
+
+fn setup_plane(
+    mut commands: Commands,
+    mode: Res<TextureFiltering>,
+    mut textures: ResMut<Assets<Texture>>,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    let tex_size = 256;
+    let mut tex = generate_texture(tex_size, -0.8, 0.156);
+    mode.apply(&mut tex);
+    let tex = textures.add(tex);
+
+    let quad_size = Vec2::new(20.0, 200.0);
+    let quad = meshes.add(Mesh::from(shape::Quad {
+        size: quad_size,
+        flip: false,
+        uv_scale: quad_size,
+    }));
+
+    let material = materials.add(StandardMaterial {
+        albedo_texture: Some(tex.clone()),
+        unlit: true,
+        ..Default::default()
+    });
+
+    commands.insert_resource(MainAssets {
+        texture: tex,
+        material: material.clone(),
+    });
+
+    commands
+        .spawn(PbrBundle {
+            mesh: quad,
+            material,
+            transform: Transform {
+                translation: Vec3::new(0.0, 0.0, -quad_size.y / 4.0),
+                rotation: Quat::from_rotation_x(-std::f32::consts::PI / 2.0),
+                ..Default::default()
+            },
+            visible: Visible {
+                is_transparent: true,
+                ..Default::default()
+            },
+            ..Default::default()
+        })
+        .spawn(PerspectiveCameraBundle::default())
+        .with(MainCamera);
+}
+
+fn setup_ui(mut commands: Commands, asset_server: Res<AssetServer>, mode: Res<TextureFiltering>) {
+    commands
+        .spawn(UiCameraBundle::default())
+        .spawn(TextBundle {
+            style: Style {
+                align_self: AlignSelf::FlexEnd,
+                ..Default::default()
+            },
+            text: Text {
+                sections: vec![
+                    TextSection {
+                        value: "(space to change)".to_string(),
+                        style: TextStyle {
+                            font: asset_server.load("fonts/FiraSans-Bold.ttf"),
+                            font_size: 32.0,
+                            color: Color::ALICE_BLUE,
+                        },
+                    },
+                    TextSection {
+                        value: " Current Mode: ".to_string(),
+                        style: TextStyle {
+                            font: asset_server.load("fonts/FiraSans-Bold.ttf"),
+                            font_size: 32.0,
+                            color: Color::WHITE,
+                        },
+                    },
+                    TextSection {
+                        value: mode.screen_text().to_string(),
+                        style: TextStyle {
+                            font: asset_server.load("fonts/FiraMono-Medium.ttf"),
+                            font_size: 32.0,
+                            color: Color::GOLD,
+                        },
+                    },
+                ],
+                ..Default::default()
+            },
+            ..Default::default()
+        })
+        .with(ModeText);
+}
+
+fn swing_camera(t: Res<Time>, mut q: Query<&mut Transform, With<MainCamera>>) {
+    let secs = t.seconds_since_startup();
+
+    let translation = Vec3::new(secs.sin() as f32, 2.0 + (secs * 0.3).sin() as f32, 5.0);
+
+    for mut transform in q.iter_mut() {
+        *transform = Transform::from_translation(translation).looking_at(Vec3::ZERO, Vec3::Y);
+    }
+}
+
+fn switch_filter_mode(
+    mut mode: ResMut<TextureFiltering>,
+    mut textures: ResMut<Assets<Texture>>,
+    mut mats: ResMut<Assets<StandardMaterial>>,
+    main: Res<MainAssets>,
+    kbd: Res<Input<KeyCode>>,
+    mut q_text: Query<&mut Text, With<ModeText>>,
+) {
+    if kbd.just_pressed(KeyCode::Space) {
+        let next = mode.cycle_next();
+
+        // apply the next filtermode config to the texture
+        let tex = textures.get_mut(&main.texture).unwrap();
+        next.apply(tex);
+
+        // Bevy does not seem to detect the modification,
+        // unless we also mutate the material
+        let mat = mats.get_mut(&main.material).unwrap();
+        mat.albedo_texture = Some(main.texture.clone());
+
+        // update the on-screen text
+        for mut text in q_text.iter_mut() {
+            text.sections[2].value = next.screen_text().to_string();
+        }
+
+        *mode = next;
+    }
+}
+
+/// Procedurally-generate a texture of a julia fractal
+fn generate_texture(size: u32, cx: f32, cy: f32) -> Texture {
+    use std::iter;
+
+    // copied from the wgpu-rs mipmap example:
+    // https://github.com/gfx-rs/wgpu-rs/blob/master/examples/mipmap/main.rs
+    let texels = (0..size * size)
+        .flat_map(|id| {
+            let mut x = 4.0 * (id % size) as f32 / (size - 1) as f32 - 2.0;
+            let mut y = 2.0 * (id / size) as f32 / (size - 1) as f32 - 1.0;
+            let mut count = 0;
+            while count < 0xFF && x * x + y * y < 4.0 {
+                let old_x = x;
+                x = x * x - y * y + cx;
+                y = 2.0 * old_x * y + cy;
+                count += 1;
+            }
+            iter::once(0xFF - (count * 2) as u8)
+                .chain(iter::once(0xFF - (count * 5) as u8))
+                .chain(iter::once(0xFF - (count * 13) as u8))
+                .chain(iter::once(std::u8::MAX))
+        })
+        .collect();
+
+    use bevy::render::texture::{
+        AddressMode, Extent3d, SamplerDescriptor, TextureDimension, TextureFormat,
+    };
+
+    let sampler = SamplerDescriptor {
+        address_mode_u: AddressMode::Repeat,
+        address_mode_v: AddressMode::Repeat,
+        address_mode_w: AddressMode::Repeat,
+        ..Default::default()
+    };
+
+    Texture {
+        data: texels,
+        size: Extent3d::new(size, size, 1),
+        format: TextureFormat::Rgba8UnormSrgb,
+        dimension: TextureDimension::D2,
+        sampler,
+    }
+}
+
+impl TextureFiltering {
+    fn apply(&self, tex: &mut Texture) {
+        match self {
+            TextureFiltering::Nearest => {
+                tex.sampler.mag_filter = FilterMode::Nearest;
+                tex.sampler.min_filter = FilterMode::Nearest;
+                tex.sampler.mipmap_filter = FilterMode::Nearest;
+                tex.sampler.anisotropy_clamp = None;
+            }
+            TextureFiltering::Linear => {
+                tex.sampler.mag_filter = FilterMode::Linear;
+                tex.sampler.min_filter = FilterMode::Linear;
+                tex.sampler.mipmap_filter = FilterMode::Nearest;
+                tex.sampler.anisotropy_clamp = None;
+            }
+            TextureFiltering::NearestMipmap => {
+                tex.sampler.mag_filter = FilterMode::Linear;
+                tex.sampler.min_filter = FilterMode::Linear;
+                tex.sampler.mipmap_filter = FilterMode::Nearest;
+                tex.sampler.anisotropy_clamp = None;
+            }
+            TextureFiltering::LinearMipmap => {
+                tex.sampler.mag_filter = FilterMode::Linear;
+                tex.sampler.min_filter = FilterMode::Linear;
+                tex.sampler.mipmap_filter = FilterMode::Linear;
+                tex.sampler.anisotropy_clamp = None;
+            }
+            TextureFiltering::Anisotropic => {
+                tex.sampler.mag_filter = FilterMode::Linear;
+                tex.sampler.min_filter = FilterMode::Linear;
+                tex.sampler.mipmap_filter = FilterMode::Linear;
+                tex.sampler.anisotropy_clamp = NonZeroU8::new(16);
+            }
+        }
+    }
+
+    fn screen_text(&self) -> &'static str {
+        match self {
+            TextureFiltering::Nearest => "Nearest (no mipmaps)",
+            TextureFiltering::Linear => "Linear (no mipmaps)",
+            TextureFiltering::NearestMipmap => "Linear with nearest mipmap",
+            TextureFiltering::LinearMipmap => "Linear with linear mipmaps",
+            TextureFiltering::Anisotropic => "16x Anisotropic",
+        }
+    }
+
+    fn cycle_next(&self) -> TextureFiltering {
+        match self {
+            TextureFiltering::Nearest => TextureFiltering::Anisotropic,
+            TextureFiltering::Linear => TextureFiltering::Nearest,
+            TextureFiltering::NearestMipmap => TextureFiltering::Linear,
+            TextureFiltering::LinearMipmap => TextureFiltering::NearestMipmap,
+            TextureFiltering::Anisotropic => TextureFiltering::LinearMipmap,
+        }
+    }
+}
+
+impl Default for TextureFiltering {
+    fn default() -> TextureFiltering {
+        TextureFiltering::Anisotropic
+    }
+}
diff --git a/examples/README.md b/examples/README.md
index 7908932a77507..a289fa5a5dce8 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -94,6 +94,7 @@ Example | File | Description
 `render_to_texture` | [`3d/render_to_texture.rs`](./3d/render_to_texture.rs) | Shows how to render to texture
 `spawner` | [`3d/spawner.rs`](./3d/spawner.rs) | Renders a large number of cubes with changing position and material
 `texture` | [`3d/texture.rs`](./3d/texture.rs) | Shows configuration of texture materials
+`texture_filtering` | [`3d/texture_filtering.rs`](./3d/texture_filtering.rs) | Showcases different GPU texture filtering modes (nearest, linear, mipmaps, anisotropic); WARNING: possible epilepsy trigger from extreme aliasing artifacts in Nearest mode. The example uses Anisotropic by default for this reason.
 `update_gltf_scene` | [`3d/update_gltf_scene.rs`](./3d/update_gltf_scene.rs) | Update a scene from a gltf file, either by spawning the scene as a child of another entity, or by accessing the entities of the scene
 `wireframe` | [`3d/wireframe.rs`](./3d/wireframe.rs) | Showcases wireframe rendering
 `z_sort_debug` | [`3d/z_sort_debug.rs`](./3d/z_sort_debug.rs) | Visualizes camera Z-ordering

From 574e7aeb04f82f4e177fc847f5862c6b6b36661b Mon Sep 17 00:00:00 2001
From: Jasen Borisov <jamadazi@protonmail.ch>
Date: Thu, 18 Mar 2021 12:54:31 +0100
Subject: [PATCH 04/15] MIPMAPS: add support for multiple mip levels to
 Textures

---
 .../render_graph/nodes/texture_copy_node.rs   | 88 ++++++++++---------
 .../src/texture/image_texture_conversion.rs   |  8 +-
 crates/bevy_render/src/texture/texture.rs     | 46 ++++++++--
 .../src/texture/texture_descriptor.rs         |  6 +-
 .../src/dynamic_texture_atlas_builder.rs      |  4 +-
 .../bevy_sprite/src/texture_atlas_builder.rs  |  4 +-
 6 files changed, 98 insertions(+), 58 deletions(-)

diff --git a/crates/bevy_render/src/render_graph/nodes/texture_copy_node.rs b/crates/bevy_render/src/render_graph/nodes/texture_copy_node.rs
index ac7c72fe843a9..ace2565f9fca5 100644
--- a/crates/bevy_render/src/render_graph/nodes/texture_copy_node.rs
+++ b/crates/bevy_render/src/render_graph/nodes/texture_copy_node.rs
@@ -33,49 +33,55 @@ impl Node for TextureCopyNode {
                         }
 
                         let texture_descriptor: TextureDescriptor = texture.into();
-                        let width = texture.size.width as usize;
-                        let aligned_width =
-                            render_context.resources().get_aligned_texture_size(width);
-                        let format_size = texture.format.pixel_size();
-                        let mut aligned_data = vec![
-                            0;
-                            format_size
-                                * aligned_width
-                                * texture.size.height as usize
-                                * texture.size.depth as usize
-                        ];
-                        texture
-                            .data
-                            .chunks_exact(format_size * width)
-                            .enumerate()
-                            .for_each(|(index, row)| {
-                                let offset = index * aligned_width * format_size;
-                                aligned_data[offset..(offset + width * format_size)]
-                                    .copy_from_slice(row);
-                            });
-                        let texture_buffer = render_context.resources().create_buffer_with_data(
-                            BufferInfo {
-                                buffer_usage: BufferUsage::COPY_SRC,
-                                ..Default::default()
-                            },
-                            &aligned_data,
-                        );
 
-                        let texture_resource = render_context
-                            .resources()
-                            .get_asset_resource(handle, TEXTURE_ASSET_INDEX)
-                            .unwrap();
+                        debug_assert!(texture_descriptor.mip_level_count > 0);
 
-                        render_context.copy_buffer_to_texture(
-                            texture_buffer,
-                            0,
-                            (format_size * aligned_width) as u32,
-                            texture_resource.get_texture().unwrap(),
-                            [0, 0, 0],
-                            0,
-                            texture_descriptor.size,
-                        );
-                        render_context.resources().remove_buffer(texture_buffer);
+                        for mip_level in 0..texture_descriptor.mip_level_count {
+                            let mip_size = texture.mip_size(mip_level as usize);
+                            let width = mip_size.width as usize;
+                            let aligned_width =
+                                render_context.resources().get_aligned_texture_size(width);
+                            let format_size = texture.format.pixel_size();
+                            let mut aligned_data = vec![
+                                0;
+                                format_size
+                                    * aligned_width
+                                    * mip_size.height as usize
+                                    * mip_size.depth as usize
+                            ];
+                            texture
+                                .data[mip_level as usize]
+                                .chunks_exact(format_size * width)
+                                .enumerate()
+                                .for_each(|(index, row)| {
+                                    let offset = index * aligned_width * format_size;
+                                    aligned_data[offset..(offset + width * format_size)]
+                                        .copy_from_slice(row);
+                                });
+                            let texture_buffer = render_context.resources().create_buffer_with_data(
+                                BufferInfo {
+                                    buffer_usage: BufferUsage::COPY_SRC,
+                                    ..Default::default()
+                                },
+                                &aligned_data,
+                            );
+
+                            let texture_resource = render_context
+                                .resources()
+                                .get_asset_resource(handle, TEXTURE_ASSET_INDEX)
+                                .unwrap();
+
+                            render_context.copy_buffer_to_texture(
+                                texture_buffer,
+                                0,
+                                (format_size * aligned_width) as u32,
+                                texture_resource.get_texture().unwrap(),
+                                [0, 0, 0],
+                                mip_level,
+                                mip_size,
+                            );
+                            render_context.resources().remove_buffer(texture_buffer);
+                        }
 
                         copied_textures.insert(&handle.id);
                     }
diff --git a/crates/bevy_render/src/texture/image_texture_conversion.rs b/crates/bevy_render/src/texture/image_texture_conversion.rs
index 460bce448fbdf..4af473b035d07 100644
--- a/crates/bevy_render/src/texture/image_texture_conversion.rs
+++ b/crates/bevy_render/src/texture/image_texture_conversion.rs
@@ -126,25 +126,25 @@ pub(crate) fn texture_to_image(texture: &Texture) -> Option<image::DynamicImage>
         TextureFormat::R8Unorm => image::ImageBuffer::from_raw(
             texture.size.width,
             texture.size.height,
-            texture.data.clone(),
+            texture.data[0].clone(),
         )
         .map(image::DynamicImage::ImageLuma8),
         TextureFormat::Rg8Unorm => image::ImageBuffer::from_raw(
             texture.size.width,
             texture.size.height,
-            texture.data.clone(),
+            texture.data[0].clone(),
         )
         .map(image::DynamicImage::ImageLumaA8),
         TextureFormat::Rgba8UnormSrgb => image::ImageBuffer::from_raw(
             texture.size.width,
             texture.size.height,
-            texture.data.clone(),
+            texture.data[0].clone(),
         )
         .map(image::DynamicImage::ImageRgba8),
         TextureFormat::Bgra8UnormSrgb => image::ImageBuffer::from_raw(
             texture.size.width,
             texture.size.height,
-            texture.data.clone(),
+            texture.data[0].clone(),
         )
         .map(image::DynamicImage::ImageBgra8),
         _ => None,
diff --git a/crates/bevy_render/src/texture/texture.rs b/crates/bevy_render/src/texture/texture.rs
index 2c493dba11626..8af6247ffe703 100644
--- a/crates/bevy_render/src/texture/texture.rs
+++ b/crates/bevy_render/src/texture/texture.rs
@@ -17,8 +17,16 @@ pub const SAMPLER_ASSET_INDEX: u64 = 1;
 #[derive(Debug, Clone, TypeUuid)]
 #[uuid = "6ea26da6-6cf8-4ea2-9986-1d7bf6c17d6f"]
 pub struct Texture {
-    pub data: Vec<u8>,
+    /// Data for each mipmap level
+    ///
+    /// Must contain at least one (the base texture)
+    pub data: Vec<Vec<u8>>,
     pub size: Extent3d,
+    /// Maximum number of mipmap levels to use
+    ///
+    /// The actual number of mipmaps used is either this, or `data.len()`,
+    /// whichever is less. If 0, all available levels are used.
+    pub mip_levels: u32,
     pub format: TextureFormat,
     pub dimension: TextureDimension,
     pub sampler: SamplerDescriptor,
@@ -27,12 +35,13 @@ pub struct Texture {
 impl Default for Texture {
     fn default() -> Self {
         Texture {
-            data: Default::default(),
+            data: vec![Vec::new()],
             size: Extent3d {
                 width: 1,
                 height: 1,
                 depth: 1,
             },
+            mip_levels: 1,
             format: TextureFormat::Rgba8UnormSrgb,
             dimension: TextureDimension::D2,
             sampler: Default::default(),
@@ -41,6 +50,7 @@ impl Default for Texture {
 }
 
 impl Texture {
+    /// Create a new texture without mipmaps
     pub fn new(
         size: Extent3d,
         dimension: TextureDimension,
@@ -53,10 +63,11 @@ impl Texture {
             "Pixel data, size and format have to match",
         );
         Self {
-            data,
+            data: vec![data],
             size,
-            format,
+            mip_levels: 1,
             dimension,
+            format,
             ..Default::default()
         }
     }
@@ -80,11 +91,11 @@ impl Texture {
             "Must not have incomplete pixel data."
         );
         debug_assert!(
-            pixel.len() <= value.data.len(),
+            pixel.len() <= value.data[0].len(),
             "Fill data must fit within pixel buffer."
         );
 
-        for current_pixel in value.data.chunks_exact_mut(pixel.len()) {
+        for current_pixel in value.data[0].chunks_exact_mut(pixel.len()) {
             current_pixel.copy_from_slice(&pixel);
         }
         value
@@ -94,10 +105,29 @@ impl Texture {
         self.size.height as f32 / self.size.width as f32
     }
 
+    pub fn mip_size(&self, level: usize) -> Extent3d {
+        Extent3d {
+            width: (self.size.width >> level).max(1),
+            height: (self.size.height >> level).max(1),
+            depth: (self.size.depth >> level).max(1),
+        }
+    }
+
     pub fn resize(&mut self, size: Extent3d) {
         self.size = size;
-        self.data
-            .resize(size.volume() * self.format.pixel_size(), 0);
+
+        for level in 0..self.data.len() {
+            let volume = self.mip_size(level).volume();
+
+            self.data[level].resize(volume * self.format.pixel_size(), 0);
+
+            if volume == 1 {
+                // This was the last mip level, remove any extras
+                self.data.truncate(level + 1);
+                self.mip_levels = self.mip_levels.min(level as u32);
+                break;
+            }
+        }
     }
 
     /// Changes the `size`, asserting that the total number of data elements (pixels) remains the
diff --git a/crates/bevy_render/src/texture/texture_descriptor.rs b/crates/bevy_render/src/texture/texture_descriptor.rs
index 5d7d349fe150b..25ab6e321d369 100644
--- a/crates/bevy_render/src/texture/texture_descriptor.rs
+++ b/crates/bevy_render/src/texture/texture_descriptor.rs
@@ -15,7 +15,11 @@ impl From<&Texture> for TextureDescriptor {
     fn from(texture: &Texture) -> Self {
         TextureDescriptor {
             size: texture.size,
-            mip_level_count: 1,
+            mip_level_count: if texture.mip_levels == 0 {
+                texture.data.len() as u32
+            } else {
+                texture.mip_levels.min(texture.data.len() as u32)
+            },
             sample_count: 1,
             dimension: texture.dimension,
             format: texture.format,
diff --git a/crates/bevy_sprite/src/dynamic_texture_atlas_builder.rs b/crates/bevy_sprite/src/dynamic_texture_atlas_builder.rs
index 0353bb1ea9f4d..4e2c8185bf839 100644
--- a/crates/bevy_sprite/src/dynamic_texture_atlas_builder.rs
+++ b/crates/bevy_sprite/src/dynamic_texture_atlas_builder.rs
@@ -81,8 +81,8 @@ impl DynamicTextureAtlasBuilder {
             let end = begin + rect_width * format_size;
             let texture_begin = texture_y * rect_width * format_size;
             let texture_end = texture_begin + rect_width * format_size;
-            atlas_texture.data[begin..end]
-                .copy_from_slice(&texture.data[texture_begin..texture_end]);
+            atlas_texture.data[0][begin..end]
+                .copy_from_slice(&texture.data[0][texture_begin..texture_end]);
         }
     }
 }
diff --git a/crates/bevy_sprite/src/texture_atlas_builder.rs b/crates/bevy_sprite/src/texture_atlas_builder.rs
index 37e3f62a9bf74..23285ec4fe264 100644
--- a/crates/bevy_sprite/src/texture_atlas_builder.rs
+++ b/crates/bevy_sprite/src/texture_atlas_builder.rs
@@ -100,8 +100,8 @@ impl TextureAtlasBuilder {
             let end = begin + rect_width * format_size;
             let texture_begin = texture_y * rect_width * format_size;
             let texture_end = texture_begin + rect_width * format_size;
-            atlas_texture.data[begin..end]
-                .copy_from_slice(&texture.data[texture_begin..texture_end]);
+            atlas_texture.data[0][begin..end]
+                .copy_from_slice(&texture.data[0][texture_begin..texture_end]);
         }
     }
 

From a24d72c8e937e2863a6e65e3eef136fc6bd24fce Mon Sep 17 00:00:00 2001
From: Jasen Borisov <jamadazi@protonmail.ch>
Date: Thu, 18 Mar 2021 12:55:51 +0100
Subject: [PATCH 05/15] PERF: texture->gpu transfer: avoid vec allocation+copy
 if data is aligned

---
 .../render_graph/nodes/texture_copy_node.rs   | 42 ++++++++++++-------
 1 file changed, 26 insertions(+), 16 deletions(-)

diff --git a/crates/bevy_render/src/render_graph/nodes/texture_copy_node.rs b/crates/bevy_render/src/render_graph/nodes/texture_copy_node.rs
index ace2565f9fca5..720998c044478 100644
--- a/crates/bevy_render/src/render_graph/nodes/texture_copy_node.rs
+++ b/crates/bevy_render/src/render_graph/nodes/texture_copy_node.rs
@@ -42,22 +42,32 @@ impl Node for TextureCopyNode {
                             let aligned_width =
                                 render_context.resources().get_aligned_texture_size(width);
                             let format_size = texture.format.pixel_size();
-                            let mut aligned_data = vec![
-                                0;
-                                format_size
-                                    * aligned_width
-                                    * mip_size.height as usize
-                                    * mip_size.depth as usize
-                            ];
-                            texture
-                                .data[mip_level as usize]
-                                .chunks_exact(format_size * width)
-                                .enumerate()
-                                .for_each(|(index, row)| {
-                                    let offset = index * aligned_width * format_size;
-                                    aligned_data[offset..(offset + width * format_size)]
-                                        .copy_from_slice(row);
-                                });
+
+                            let mut temporary_buffer;
+                            let aligned_data = if aligned_width != width {
+                                // must create a temporary buffer with the proper alignment
+                                temporary_buffer = vec![
+                                    0;
+                                    format_size
+                                        * aligned_width
+                                        * mip_size.height as usize
+                                        * mip_size.depth as usize
+                                ];
+                                texture
+                                    .data[mip_level as usize]
+                                    .chunks_exact(format_size * width)
+                                    .enumerate()
+                                    .for_each(|(index, row)| {
+                                        let offset = index * aligned_width * format_size;
+                                        temporary_buffer[offset..(offset + width * format_size)]
+                                            .copy_from_slice(row);
+                                    });
+                                &temporary_buffer
+                            } else {
+                                // source data already has the correct alignment
+                                &texture.data[mip_level as usize]
+                            };
+
                             let texture_buffer = render_context.resources().create_buffer_with_data(
                                 BufferInfo {
                                     buffer_usage: BufferUsage::COPY_SRC,

From 52936f989f6b3c4e7c7ea586417ba9b1ee427016 Mon Sep 17 00:00:00 2001
From: Jasen Borisov <jamadazi@protonmail.ch>
Date: Thu, 18 Mar 2021 15:14:12 +0100
Subject: [PATCH 06/15] formatting fixes

---
 .../render_graph/nodes/texture_copy_node.rs    | 18 +++++++++---------
 crates/bevy_render/src/texture/texture.rs      |  2 +-
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/crates/bevy_render/src/render_graph/nodes/texture_copy_node.rs b/crates/bevy_render/src/render_graph/nodes/texture_copy_node.rs
index 720998c044478..e343229b39cf4 100644
--- a/crates/bevy_render/src/render_graph/nodes/texture_copy_node.rs
+++ b/crates/bevy_render/src/render_graph/nodes/texture_copy_node.rs
@@ -53,8 +53,7 @@ impl Node for TextureCopyNode {
                                         * mip_size.height as usize
                                         * mip_size.depth as usize
                                 ];
-                                texture
-                                    .data[mip_level as usize]
+                                texture.data[mip_level as usize]
                                     .chunks_exact(format_size * width)
                                     .enumerate()
                                     .for_each(|(index, row)| {
@@ -68,13 +67,14 @@ impl Node for TextureCopyNode {
                                 &texture.data[mip_level as usize]
                             };
 
-                            let texture_buffer = render_context.resources().create_buffer_with_data(
-                                BufferInfo {
-                                    buffer_usage: BufferUsage::COPY_SRC,
-                                    ..Default::default()
-                                },
-                                &aligned_data,
-                            );
+                            let texture_buffer =
+                                render_context.resources().create_buffer_with_data(
+                                    BufferInfo {
+                                        buffer_usage: BufferUsage::COPY_SRC,
+                                        ..Default::default()
+                                    },
+                                    &aligned_data,
+                                );
 
                             let texture_resource = render_context
                                 .resources()
diff --git a/crates/bevy_render/src/texture/texture.rs b/crates/bevy_render/src/texture/texture.rs
index 8af6247ffe703..9f30279652e41 100644
--- a/crates/bevy_render/src/texture/texture.rs
+++ b/crates/bevy_render/src/texture/texture.rs
@@ -41,7 +41,7 @@ impl Default for Texture {
                 height: 1,
                 depth: 1,
             },
-            mip_levels: 1,
+            mip_levels: 0,
             format: TextureFormat::Rgba8UnormSrgb,
             dimension: TextureDimension::D2,
             sampler: Default::default(),

From f8c1b7922906d3e8c6a75ee8f49ad8c374410dbf Mon Sep 17 00:00:00 2001
From: Jasen Borisov <jamadazi@protonmail.ch>
Date: Thu, 18 Mar 2021 16:13:00 +0100
Subject: [PATCH 07/15] Add support for mipmap generation (via
 image::DynamicImage::resize)

---
 .../src/texture/image_texture_conversion.rs   | 63 +++++++++----------
 crates/bevy_render/src/texture/texture.rs     | 59 ++++++++++++++++-
 2 files changed, 88 insertions(+), 34 deletions(-)

diff --git a/crates/bevy_render/src/texture/image_texture_conversion.rs b/crates/bevy_render/src/texture/image_texture_conversion.rs
index 4af473b035d07..9e7a91abe2a1b 100644
--- a/crates/bevy_render/src/texture/image_texture_conversion.rs
+++ b/crates/bevy_render/src/texture/image_texture_conversion.rs
@@ -1,7 +1,10 @@
 use super::{Extent3d, Texture, TextureDimension, TextureFormat};
 
-/// Helper method to convert a `DynamicImage` to a `Texture`
-pub(crate) fn image_to_texture(dyn_img: image::DynamicImage) -> Texture {
+/// Helper method to create data for a `Texture` from a `DynamicImage`
+/// Returns (dimensions, format, data).
+pub(crate) fn image_to_texture_data(
+    dyn_img: image::DynamicImage,
+) -> (Extent3d, TextureFormat, Vec<u8>) {
     use bevy_core::AsBytes;
 
     let width;
@@ -111,42 +114,36 @@ pub(crate) fn image_to_texture(dyn_img: image::DynamicImage) -> Texture {
         }
     }
 
-    Texture::new(
-        Extent3d::new(width, height, 1),
-        TextureDimension::D2,
-        data,
-        format,
-    )
+    (Extent3d::new(width, height, 1), format, data)
+}
+
+/// Helper method to convert a `DynamicImage` to a `Texture`
+pub(crate) fn image_to_texture(dyn_img: image::DynamicImage) -> Texture {
+    let (size, format, data) = image_to_texture_data(dyn_img);
+    Texture::new(size, TextureDimension::D2, data, format)
 }
 
 /// Helper method to convert a `Texture` to a `DynamicImage`. Not all `Texture` formats are
 /// covered, it will return `None` if the format is not supported
-pub(crate) fn texture_to_image(texture: &Texture) -> Option<image::DynamicImage> {
+pub(crate) fn texture_to_image(texture: &Texture, mip_level: usize) -> Option<image::DynamicImage> {
+    let size = texture.mip_size(mip_level);
     match texture.format {
-        TextureFormat::R8Unorm => image::ImageBuffer::from_raw(
-            texture.size.width,
-            texture.size.height,
-            texture.data[0].clone(),
-        )
-        .map(image::DynamicImage::ImageLuma8),
-        TextureFormat::Rg8Unorm => image::ImageBuffer::from_raw(
-            texture.size.width,
-            texture.size.height,
-            texture.data[0].clone(),
-        )
-        .map(image::DynamicImage::ImageLumaA8),
-        TextureFormat::Rgba8UnormSrgb => image::ImageBuffer::from_raw(
-            texture.size.width,
-            texture.size.height,
-            texture.data[0].clone(),
-        )
-        .map(image::DynamicImage::ImageRgba8),
-        TextureFormat::Bgra8UnormSrgb => image::ImageBuffer::from_raw(
-            texture.size.width,
-            texture.size.height,
-            texture.data[0].clone(),
-        )
-        .map(image::DynamicImage::ImageBgra8),
+        TextureFormat::R8Unorm => {
+            image::ImageBuffer::from_raw(size.width, size.height, texture.data[mip_level].clone())
+                .map(image::DynamicImage::ImageLuma8)
+        }
+        TextureFormat::Rg8Unorm => {
+            image::ImageBuffer::from_raw(size.width, size.height, texture.data[mip_level].clone())
+                .map(image::DynamicImage::ImageLumaA8)
+        }
+        TextureFormat::Rgba8UnormSrgb => {
+            image::ImageBuffer::from_raw(size.width, size.height, texture.data[mip_level].clone())
+                .map(image::DynamicImage::ImageRgba8)
+        }
+        TextureFormat::Bgra8UnormSrgb => {
+            image::ImageBuffer::from_raw(size.width, size.height, texture.data[mip_level].clone())
+                .map(image::DynamicImage::ImageBgra8)
+        }
         _ => None,
     }
 }
diff --git a/crates/bevy_render/src/texture/texture.rs b/crates/bevy_render/src/texture/texture.rs
index 9f30279652e41..324c61dac3919 100644
--- a/crates/bevy_render/src/texture/texture.rs
+++ b/crates/bevy_render/src/texture/texture.rs
@@ -11,6 +11,10 @@ use bevy_reflect::TypeUuid;
 use bevy_utils::HashSet;
 use thiserror::Error;
 
+/// Reexport to allow users to import it via Bevy and not require depending on `image`
+/// Rename it to avoid confusion with GPU texture sampler filtering modes.
+pub use image::imageops::FilterType as ImageResizeFilter;
+
 pub const TEXTURE_ASSET_INDEX: u64 = 0;
 pub const SAMPLER_ASSET_INDEX: u64 = 1;
 
@@ -159,14 +163,67 @@ impl Texture {
         });
     }
 
+    /// Generate mipmap images by downscaling the texture
+    ///
+    /// Currently this operation is performed on the CPU.
+    ///
+    /// It will generate images up to `max_mip_level` (or all levels, if
+    /// unspecified), by downscaling the previous larger level.
+    ///
+    /// This method uses the `Triangle` image resizing filter. This is the
+    /// fastest algorithm that produces acceptable results.
+    ///
+    /// To override this and use another image resizing filter, see
+    /// `generate_mip_level_with_filter`.
+    ///
+    /// Currently only supports 2D textures in a few pixel formats. Will panic
+    /// if used on an unsupported texture.
+    pub fn generate_mipmaps(&mut self, max_mip_level: Option<usize>) {
+        self.generate_mipmaps_with_filter(max_mip_level, ImageResizeFilter::Triangle)
+    }
+
+    /// Variant of `generate_mipmaps` to allow specifying the filtering algorithm
+    ///
+    /// See that method's documentation for details
+    pub fn generate_mipmaps_with_filter(
+        &mut self,
+        max_mip_level: Option<usize>,
+        filter: ImageResizeFilter,
+    ) {
+        if self.dimension != TextureDimension::D2 {
+            panic!("Generating mipmaps is only supported for 2D textures.");
+        }
+
+        let mut mip_level = self.data.len();
+        debug_assert!(mip_level > 0);
+
+        let mut mip_size = self.mip_size(mip_level);
+
+        // PERF: this is inefficient: `texture_to_image` does a `.clone()` of the source data
+        let base_image = super::image_texture_conversion::texture_to_image(self, 0).unwrap();
+
+        while mip_size.volume() > 1 && mip_level <= max_mip_level.unwrap_or(mip_level + 1) {
+            let resized = base_image.resize_exact(mip_size.width, mip_size.height, filter);
+
+            let (_, _, new_data) = super::image_texture_conversion::image_to_texture_data(resized);
+
+            self.data.push(new_data);
+
+            mip_level += 1;
+            mip_size = self.mip_size(mip_level);
+        }
+    }
+
     /// Convert a texture from a format to another
     /// Only a few formats are supported as input and output:
     /// - `TextureFormat::R8Unorm`
     /// - `TextureFormat::Rg8Unorm`
     /// - `TextureFormat::Rgba8UnormSrgb`
     /// - `TextureFormat::Bgra8UnormSrgb`
+    ///
+    /// (TODO) this method currently discards all mipmap levels except the base image
     pub fn convert(&self, new_format: TextureFormat) -> Option<Self> {
-        super::image_texture_conversion::texture_to_image(self)
+        super::image_texture_conversion::texture_to_image(self, 0)
             .and_then(|img| match new_format {
                 TextureFormat::R8Unorm => Some(image::DynamicImage::ImageLuma8(img.into_luma8())),
                 TextureFormat::Rg8Unorm => {

From 15f8bd14a7f617e252e8f0c8b509945e88d5348d Mon Sep 17 00:00:00 2001
From: Jasen Borisov <jamadazi@protonmail.ch>
Date: Thu, 18 Mar 2021 16:13:26 +0100
Subject: [PATCH 08/15] example: texture_filtering: add the mipmaps

---
 examples/3d/texture_filtering.rs | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/examples/3d/texture_filtering.rs b/examples/3d/texture_filtering.rs
index 8dd62d3f0fd65..d97040e32b0ed 100644
--- a/examples/3d/texture_filtering.rs
+++ b/examples/3d/texture_filtering.rs
@@ -194,43 +194,53 @@ fn generate_texture(size: u32, cx: f32, cy: f32) -> Texture {
         ..Default::default()
     };
 
-    Texture {
-        data: texels,
+    let mut tex = Texture {
+        data: vec![texels],
         size: Extent3d::new(size, size, 1),
+        mip_levels: 0,
         format: TextureFormat::Rgba8UnormSrgb,
         dimension: TextureDimension::D2,
         sampler,
-    }
+    };
+
+    tex.generate_mipmaps(None);
+
+    tex
 }
 
 impl TextureFiltering {
     fn apply(&self, tex: &mut Texture) {
         match self {
             TextureFiltering::Nearest => {
+                tex.mip_levels = 1;
                 tex.sampler.mag_filter = FilterMode::Nearest;
                 tex.sampler.min_filter = FilterMode::Nearest;
                 tex.sampler.mipmap_filter = FilterMode::Nearest;
                 tex.sampler.anisotropy_clamp = None;
             }
             TextureFiltering::Linear => {
+                tex.mip_levels = 1;
                 tex.sampler.mag_filter = FilterMode::Linear;
                 tex.sampler.min_filter = FilterMode::Linear;
                 tex.sampler.mipmap_filter = FilterMode::Nearest;
                 tex.sampler.anisotropy_clamp = None;
             }
             TextureFiltering::NearestMipmap => {
+                tex.mip_levels = 0;
                 tex.sampler.mag_filter = FilterMode::Linear;
                 tex.sampler.min_filter = FilterMode::Linear;
                 tex.sampler.mipmap_filter = FilterMode::Nearest;
                 tex.sampler.anisotropy_clamp = None;
             }
             TextureFiltering::LinearMipmap => {
+                tex.mip_levels = 0;
                 tex.sampler.mag_filter = FilterMode::Linear;
                 tex.sampler.min_filter = FilterMode::Linear;
                 tex.sampler.mipmap_filter = FilterMode::Linear;
                 tex.sampler.anisotropy_clamp = None;
             }
             TextureFiltering::Anisotropic => {
+                tex.mip_levels = 0;
                 tex.sampler.mag_filter = FilterMode::Linear;
                 tex.sampler.min_filter = FilterMode::Linear;
                 tex.sampler.mipmap_filter = FilterMode::Linear;

From 20e698be6dd05124a52c13f96a7baf34f489887b Mon Sep 17 00:00:00 2001
From: Jasen Borisov <jamadazi@protonmail.ch>
Date: Thu, 18 Mar 2021 16:20:13 +0100
Subject: [PATCH 09/15] GLTF loader: generate texture mipmaps if needed

---
 crates/bevy_gltf/src/loader.rs | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/crates/bevy_gltf/src/loader.rs b/crates/bevy_gltf/src/loader.rs
index 3f4947e63772f..e8757fa6817ef 100644
--- a/crates/bevy_gltf/src/loader.rs
+++ b/crates/bevy_gltf/src/loader.rs
@@ -270,6 +270,23 @@ async fn load_gltf<'a, 'b>(
                 )?
             }
         };
+
+        let needs_mipmaps = gltf_texture
+            .sampler()
+            .min_filter()
+            .map(|mf| match mf {
+                MinFilter::NearestMipmapNearest
+                | MinFilter::NearestMipmapLinear
+                | MinFilter::LinearMipmapNearest
+                | MinFilter::LinearMipmapLinear => true,
+                MinFilter::Linear | MinFilter::Nearest => false,
+            })
+            .unwrap_or(false);
+
+        if needs_mipmaps {
+            texture.generate_mipmaps(None);
+        }
+
         let texture_label = texture_label(&gltf_texture);
         texture.sampler = texture_sampler(&gltf_texture);
         if linear_textures.contains(&gltf_texture.index()) {

From eed2f860c7a0638468fb7f5b00552511fb2869e6 Mon Sep 17 00:00:00 2001
From: Jasen Borisov <jamadazi@protonmail.ch>
Date: Thu, 18 Mar 2021 19:03:08 +0100
Subject: [PATCH 10/15] improve texture_filtering example to manually generate
 mipmaps

---
 examples/3d/texture_filtering.rs | 62 ++++++++++++++++++++------------
 1 file changed, 39 insertions(+), 23 deletions(-)

diff --git a/examples/3d/texture_filtering.rs b/examples/3d/texture_filtering.rs
index d97040e32b0ed..5d16ce698b559 100644
--- a/examples/3d/texture_filtering.rs
+++ b/examples/3d/texture_filtering.rs
@@ -123,7 +123,7 @@ fn setup_ui(mut commands: Commands, asset_server: Res<AssetServer>, mode: Res<Te
 fn swing_camera(t: Res<Time>, mut q: Query<&mut Transform, With<MainCamera>>) {
     let secs = t.seconds_since_startup();
 
-    let translation = Vec3::new(secs.sin() as f32, 2.0 + (secs * 0.3).sin() as f32, 5.0);
+    let translation = Vec3::new(secs.sin() as f32, 1.5 + (secs * 0.3).sin() as f32, 5.0);
 
     for mut transform in q.iter_mut() {
         *transform = Transform::from_translation(translation).looking_at(Vec3::ZERO, Vec3::Y);
@@ -163,25 +163,35 @@ fn switch_filter_mode(
 fn generate_texture(size: u32, cx: f32, cy: f32) -> Texture {
     use std::iter;
 
-    // copied from the wgpu-rs mipmap example:
-    // https://github.com/gfx-rs/wgpu-rs/blob/master/examples/mipmap/main.rs
-    let texels = (0..size * size)
-        .flat_map(|id| {
-            let mut x = 4.0 * (id % size) as f32 / (size - 1) as f32 - 2.0;
-            let mut y = 2.0 * (id / size) as f32 / (size - 1) as f32 - 1.0;
-            let mut count = 0;
-            while count < 0xFF && x * x + y * y < 4.0 {
-                let old_x = x;
-                x = x * x - y * y + cx;
-                y = 2.0 * old_x * y + cy;
-                count += 1;
-            }
-            iter::once(0xFF - (count * 2) as u8)
-                .chain(iter::once(0xFF - (count * 5) as u8))
-                .chain(iter::once(0xFF - (count * 13) as u8))
-                .chain(iter::once(std::u8::MAX))
-        })
-        .collect();
+    // This is a procedurally-generated texture, so we can generate the image
+    // directly at any size we want. Generating each mipmap level like this
+    // should produce the prettiest-looking results.
+    let mut data = Vec::new();
+    let mut mip_size = size;
+    while mip_size > 1 {
+        // copied from the wgpu-rs mipmap example:
+        // https://github.com/gfx-rs/wgpu-rs/blob/master/examples/mipmap/main.rs
+        let texels = (0..mip_size * mip_size)
+            .flat_map(|id| {
+                let mut x = 4.0 * (id % mip_size) as f32 / (mip_size - 1) as f32 - 2.0;
+                let mut y = 2.0 * (id / mip_size) as f32 / (mip_size - 1) as f32 - 1.0;
+                let mut count = 0;
+                while count < 0xFF && x * x + y * y < 4.0 {
+                    let old_x = x;
+                    x = x * x - y * y + cx;
+                    y = 2.0 * old_x * y + cy;
+                    count += 1;
+                }
+                iter::once(0xFF - (count * 2) as u8)
+                    .chain(iter::once(0xFF - (count * 5) as u8))
+                    .chain(iter::once(0xFF - (count * 13) as u8))
+                    .chain(iter::once(std::u8::MAX))
+            })
+            .collect();
+
+        data.push(texels);
+        mip_size /= 2;
+    }
 
     use bevy::render::texture::{
         AddressMode, Extent3d, SamplerDescriptor, TextureDimension, TextureFormat,
@@ -194,8 +204,9 @@ fn generate_texture(size: u32, cx: f32, cy: f32) -> Texture {
         ..Default::default()
     };
 
-    let mut tex = Texture {
-        data: vec![texels],
+    let tex = Texture {
+        //data: vec![texels],
+        data,
         size: Extent3d::new(size, size, 1),
         mip_levels: 0,
         format: TextureFormat::Rgba8UnormSrgb,
@@ -203,7 +214,12 @@ fn generate_texture(size: u32, cx: f32, cy: f32) -> Texture {
         sampler,
     };
 
-    tex.generate_mipmaps(None);
+    // Alternatively, if we hadn't generated our own mipmaps above, we could
+    // have asked Bevy to make some for us by downscaling the base image level:
+    //tex.generate_mipmaps(None);
+
+    // You can try to remove the while loop earlier (to only generate one image)
+    // and uncomment the line above, if you want to see how it looks and compare
 
     tex
 }

From eb4ea53363b2e1925c97136d201967e787233779 Mon Sep 17 00:00:00 2001
From: Jasen Borisov <jamadazi@protonmail.ch>
Date: Thu, 18 Mar 2021 19:26:08 +0100
Subject: [PATCH 11/15] fix clippy

---
 examples/3d/texture_filtering.rs | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/examples/3d/texture_filtering.rs b/examples/3d/texture_filtering.rs
index 5d16ce698b559..a953c3c7408ab 100644
--- a/examples/3d/texture_filtering.rs
+++ b/examples/3d/texture_filtering.rs
@@ -168,7 +168,10 @@ fn generate_texture(size: u32, cx: f32, cy: f32) -> Texture {
     // should produce the prettiest-looking results.
     let mut data = Vec::new();
     let mut mip_size = size;
-    while mip_size > 1 {
+
+    // Limiting the smallest mipmap size to 4x4 helps avoid the texture looking
+    // plain white/grey when viewed at very far away distances.
+    while mip_size >= 4 {
         // copied from the wgpu-rs mipmap example:
         // https://github.com/gfx-rs/wgpu-rs/blob/master/examples/mipmap/main.rs
         let texels = (0..mip_size * mip_size)
@@ -204,24 +207,21 @@ fn generate_texture(size: u32, cx: f32, cy: f32) -> Texture {
         ..Default::default()
     };
 
-    let tex = Texture {
-        //data: vec![texels],
+    Texture {
         data,
         size: Extent3d::new(size, size, 1),
         mip_levels: 0,
         format: TextureFormat::Rgba8UnormSrgb,
         dimension: TextureDimension::D2,
         sampler,
-    };
+    }
 
     // Alternatively, if we hadn't generated our own mipmaps above, we could
-    // have asked Bevy to make some for us by downscaling the base image level:
-    //tex.generate_mipmaps(None);
+    // have asked Bevy to make them for us by downscaling the base image level:
+    //texture.generate_mipmaps(None);
 
     // You can try to remove the while loop earlier (to only generate one image)
     // and uncomment the line above, if you want to see how it looks and compare
-
-    tex
 }
 
 impl TextureFiltering {

From 6ddfa38ed595de18ea877bbeeee444338f9002e4 Mon Sep 17 00:00:00 2001
From: Jasen Borisov <jamadazi@protonmail.ch>
Date: Fri, 19 Mar 2021 14:04:31 +0100
Subject: [PATCH 12/15] use safer types for mipmaps in Texture

---
 .../render_graph/nodes/texture_copy_node.rs   | 23 +++++---
 .../src/texture/image_texture_conversion.rs   | 43 ++++++++------
 crates/bevy_render/src/texture/texture.rs     | 57 ++++++++++---------
 .../src/texture/texture_descriptor.rs         |  6 +-
 .../src/dynamic_texture_atlas_builder.rs      |  4 +-
 .../bevy_sprite/src/texture_atlas_builder.rs  |  4 +-
 examples/3d/texture_filtering.rs              | 19 ++++---
 7 files changed, 88 insertions(+), 68 deletions(-)

diff --git a/crates/bevy_render/src/render_graph/nodes/texture_copy_node.rs b/crates/bevy_render/src/render_graph/nodes/texture_copy_node.rs
index e343229b39cf4..215323d499544 100644
--- a/crates/bevy_render/src/render_graph/nodes/texture_copy_node.rs
+++ b/crates/bevy_render/src/render_graph/nodes/texture_copy_node.rs
@@ -36,7 +36,13 @@ impl Node for TextureCopyNode {
 
                         debug_assert!(texture_descriptor.mip_level_count > 0);
 
-                        for mip_level in 0..texture_descriptor.mip_level_count {
+                        for (mip_level, data) in texture.iter_mipmaps().enumerate() {
+                            if let Some(max_level) = texture.max_mip_level {
+                                if mip_level > max_level {
+                                    break;
+                                }
+                            }
+
                             let mip_size = texture.mip_size(mip_level as usize);
                             let width = mip_size.width as usize;
                             let aligned_width =
@@ -53,18 +59,17 @@ impl Node for TextureCopyNode {
                                         * mip_size.height as usize
                                         * mip_size.depth as usize
                                 ];
-                                texture.data[mip_level as usize]
-                                    .chunks_exact(format_size * width)
-                                    .enumerate()
-                                    .for_each(|(index, row)| {
+                                data.chunks_exact(format_size * width).enumerate().for_each(
+                                    |(index, row)| {
                                         let offset = index * aligned_width * format_size;
                                         temporary_buffer[offset..(offset + width * format_size)]
                                             .copy_from_slice(row);
-                                    });
-                                &temporary_buffer
+                                    },
+                                );
+                                temporary_buffer.as_slice()
                             } else {
                                 // source data already has the correct alignment
-                                &texture.data[mip_level as usize]
+                                data
                             };
 
                             let texture_buffer =
@@ -87,7 +92,7 @@ impl Node for TextureCopyNode {
                                 (format_size * aligned_width) as u32,
                                 texture_resource.get_texture().unwrap(),
                                 [0, 0, 0],
-                                mip_level,
+                                mip_level as u32,
                                 mip_size,
                             );
                             render_context.resources().remove_buffer(texture_buffer);
diff --git a/crates/bevy_render/src/texture/image_texture_conversion.rs b/crates/bevy_render/src/texture/image_texture_conversion.rs
index 9e7a91abe2a1b..af7d8550e241b 100644
--- a/crates/bevy_render/src/texture/image_texture_conversion.rs
+++ b/crates/bevy_render/src/texture/image_texture_conversion.rs
@@ -125,25 +125,32 @@ pub(crate) fn image_to_texture(dyn_img: image::DynamicImage) -> Texture {
 
 /// Helper method to convert a `Texture` to a `DynamicImage`. Not all `Texture` formats are
 /// covered, it will return `None` if the format is not supported
-pub(crate) fn texture_to_image(texture: &Texture, mip_level: usize) -> Option<image::DynamicImage> {
-    let size = texture.mip_size(mip_level);
+pub(crate) fn texture_to_image(texture: &Texture) -> Option<image::DynamicImage> {
     match texture.format {
-        TextureFormat::R8Unorm => {
-            image::ImageBuffer::from_raw(size.width, size.height, texture.data[mip_level].clone())
-                .map(image::DynamicImage::ImageLuma8)
-        }
-        TextureFormat::Rg8Unorm => {
-            image::ImageBuffer::from_raw(size.width, size.height, texture.data[mip_level].clone())
-                .map(image::DynamicImage::ImageLumaA8)
-        }
-        TextureFormat::Rgba8UnormSrgb => {
-            image::ImageBuffer::from_raw(size.width, size.height, texture.data[mip_level].clone())
-                .map(image::DynamicImage::ImageRgba8)
-        }
-        TextureFormat::Bgra8UnormSrgb => {
-            image::ImageBuffer::from_raw(size.width, size.height, texture.data[mip_level].clone())
-                .map(image::DynamicImage::ImageBgra8)
-        }
+        TextureFormat::R8Unorm => image::ImageBuffer::from_raw(
+            texture.size.width,
+            texture.size.height,
+            texture.data.clone(),
+        )
+        .map(image::DynamicImage::ImageLuma8),
+        TextureFormat::Rg8Unorm => image::ImageBuffer::from_raw(
+            texture.size.width,
+            texture.size.height,
+            texture.data.clone(),
+        )
+        .map(image::DynamicImage::ImageLumaA8),
+        TextureFormat::Rgba8UnormSrgb => image::ImageBuffer::from_raw(
+            texture.size.width,
+            texture.size.height,
+            texture.data.clone(),
+        )
+        .map(image::DynamicImage::ImageRgba8),
+        TextureFormat::Bgra8UnormSrgb => image::ImageBuffer::from_raw(
+            texture.size.width,
+            texture.size.height,
+            texture.data.clone(),
+        )
+        .map(image::DynamicImage::ImageBgra8),
         _ => None,
     }
 }
diff --git a/crates/bevy_render/src/texture/texture.rs b/crates/bevy_render/src/texture/texture.rs
index 324c61dac3919..0ee53b95bb2a9 100644
--- a/crates/bevy_render/src/texture/texture.rs
+++ b/crates/bevy_render/src/texture/texture.rs
@@ -21,16 +21,13 @@ pub const SAMPLER_ASSET_INDEX: u64 = 1;
 #[derive(Debug, Clone, TypeUuid)]
 #[uuid = "6ea26da6-6cf8-4ea2-9986-1d7bf6c17d6f"]
 pub struct Texture {
-    /// Data for each mipmap level
-    ///
-    /// Must contain at least one (the base texture)
-    pub data: Vec<Vec<u8>>,
+    /// Data of the texture's main image (base mipmap level)
+    pub data: Vec<u8>,
+    /// Data of any additional mipmap levels
+    pub mipmaps: Vec<Vec<u8>>,
     pub size: Extent3d,
-    /// Maximum number of mipmap levels to use
-    ///
-    /// The actual number of mipmaps used is either this, or `data.len()`,
-    /// whichever is less. If 0, all available levels are used.
-    pub mip_levels: u32,
+    /// How many mipmap levels to copy into the GPU
+    pub max_mip_level: Option<usize>,
     pub format: TextureFormat,
     pub dimension: TextureDimension,
     pub sampler: SamplerDescriptor,
@@ -39,13 +36,14 @@ pub struct Texture {
 impl Default for Texture {
     fn default() -> Self {
         Texture {
-            data: vec![Vec::new()],
+            data: Vec::new(),
+            mipmaps: Vec::new(),
             size: Extent3d {
                 width: 1,
                 height: 1,
                 depth: 1,
             },
-            mip_levels: 0,
+            max_mip_level: None,
             format: TextureFormat::Rgba8UnormSrgb,
             dimension: TextureDimension::D2,
             sampler: Default::default(),
@@ -67,9 +65,8 @@ impl Texture {
             "Pixel data, size and format have to match",
         );
         Self {
-            data: vec![data],
+            data,
             size,
-            mip_levels: 1,
             dimension,
             format,
             ..Default::default()
@@ -95,11 +92,11 @@ impl Texture {
             "Must not have incomplete pixel data."
         );
         debug_assert!(
-            pixel.len() <= value.data[0].len(),
+            pixel.len() <= value.data.len(),
             "Fill data must fit within pixel buffer."
         );
 
-        for current_pixel in value.data[0].chunks_exact_mut(pixel.len()) {
+        for current_pixel in value.data.chunks_exact_mut(pixel.len()) {
             current_pixel.copy_from_slice(&pixel);
         }
         value
@@ -120,15 +117,19 @@ impl Texture {
     pub fn resize(&mut self, size: Extent3d) {
         self.size = size;
 
-        for level in 0..self.data.len() {
-            let volume = self.mip_size(level).volume();
+        self.data
+            .resize(size.volume() * self.format.pixel_size(), 0);
+
+        // resize mipmaps
+        for level in 0..self.mipmaps.len() {
+            let mip_volume = self.mip_size(level + 1).volume();
 
-            self.data[level].resize(volume * self.format.pixel_size(), 0);
+            self.mipmaps[level].resize(mip_volume * self.format.pixel_size(), 0);
 
-            if volume == 1 {
+            if mip_volume == 1 {
                 // This was the last mip level, remove any extras
-                self.data.truncate(level + 1);
-                self.mip_levels = self.mip_levels.min(level as u32);
+                self.mipmaps.truncate(level + 1);
+                self.max_mip_level = self.max_mip_level.map(|old| old.min(level + 1));
                 break;
             }
         }
@@ -163,6 +164,11 @@ impl Texture {
         });
     }
 
+    /// Iterator that gives the texel data for each mipmap level to use in rendering
+    pub(crate) fn iter_mipmaps(&self) -> impl Iterator<Item = &[u8]> {
+        std::iter::once(self.data.as_slice()).chain(self.mipmaps.iter().map(|vec| vec.as_slice()))
+    }
+
     /// Generate mipmap images by downscaling the texture
     ///
     /// Currently this operation is performed on the CPU.
@@ -194,20 +200,19 @@ impl Texture {
             panic!("Generating mipmaps is only supported for 2D textures.");
         }
 
-        let mut mip_level = self.data.len();
-        debug_assert!(mip_level > 0);
+        let mut mip_level = self.mipmaps.len() + 1;
 
         let mut mip_size = self.mip_size(mip_level);
 
         // PERF: this is inefficient: `texture_to_image` does a `.clone()` of the source data
-        let base_image = super::image_texture_conversion::texture_to_image(self, 0).unwrap();
+        let base_image = super::image_texture_conversion::texture_to_image(self).unwrap();
 
         while mip_size.volume() > 1 && mip_level <= max_mip_level.unwrap_or(mip_level + 1) {
             let resized = base_image.resize_exact(mip_size.width, mip_size.height, filter);
 
             let (_, _, new_data) = super::image_texture_conversion::image_to_texture_data(resized);
 
-            self.data.push(new_data);
+            self.mipmaps.push(new_data);
 
             mip_level += 1;
             mip_size = self.mip_size(mip_level);
@@ -223,7 +228,7 @@ impl Texture {
     ///
     /// (TODO) this method currently discards all mipmap levels except the base image
     pub fn convert(&self, new_format: TextureFormat) -> Option<Self> {
-        super::image_texture_conversion::texture_to_image(self, 0)
+        super::image_texture_conversion::texture_to_image(self)
             .and_then(|img| match new_format {
                 TextureFormat::R8Unorm => Some(image::DynamicImage::ImageLuma8(img.into_luma8())),
                 TextureFormat::Rg8Unorm => {
diff --git a/crates/bevy_render/src/texture/texture_descriptor.rs b/crates/bevy_render/src/texture/texture_descriptor.rs
index 25ab6e321d369..d3f0871923ea7 100644
--- a/crates/bevy_render/src/texture/texture_descriptor.rs
+++ b/crates/bevy_render/src/texture/texture_descriptor.rs
@@ -15,10 +15,10 @@ impl From<&Texture> for TextureDescriptor {
     fn from(texture: &Texture) -> Self {
         TextureDescriptor {
             size: texture.size,
-            mip_level_count: if texture.mip_levels == 0 {
-                texture.data.len() as u32
+            mip_level_count: if let Some(max_level) = texture.max_mip_level {
+                (max_level as u32 + 1).min(texture.mipmaps.len() as u32 + 1)
             } else {
-                texture.mip_levels.min(texture.data.len() as u32)
+                texture.mipmaps.len() as u32 + 1
             },
             sample_count: 1,
             dimension: texture.dimension,
diff --git a/crates/bevy_sprite/src/dynamic_texture_atlas_builder.rs b/crates/bevy_sprite/src/dynamic_texture_atlas_builder.rs
index 4e2c8185bf839..0353bb1ea9f4d 100644
--- a/crates/bevy_sprite/src/dynamic_texture_atlas_builder.rs
+++ b/crates/bevy_sprite/src/dynamic_texture_atlas_builder.rs
@@ -81,8 +81,8 @@ impl DynamicTextureAtlasBuilder {
             let end = begin + rect_width * format_size;
             let texture_begin = texture_y * rect_width * format_size;
             let texture_end = texture_begin + rect_width * format_size;
-            atlas_texture.data[0][begin..end]
-                .copy_from_slice(&texture.data[0][texture_begin..texture_end]);
+            atlas_texture.data[begin..end]
+                .copy_from_slice(&texture.data[texture_begin..texture_end]);
         }
     }
 }
diff --git a/crates/bevy_sprite/src/texture_atlas_builder.rs b/crates/bevy_sprite/src/texture_atlas_builder.rs
index 23285ec4fe264..37e3f62a9bf74 100644
--- a/crates/bevy_sprite/src/texture_atlas_builder.rs
+++ b/crates/bevy_sprite/src/texture_atlas_builder.rs
@@ -100,8 +100,8 @@ impl TextureAtlasBuilder {
             let end = begin + rect_width * format_size;
             let texture_begin = texture_y * rect_width * format_size;
             let texture_end = texture_begin + rect_width * format_size;
-            atlas_texture.data[0][begin..end]
-                .copy_from_slice(&texture.data[0][texture_begin..texture_end]);
+            atlas_texture.data[begin..end]
+                .copy_from_slice(&texture.data[texture_begin..texture_end]);
         }
     }
 
diff --git a/examples/3d/texture_filtering.rs b/examples/3d/texture_filtering.rs
index a953c3c7408ab..d153bbd618df8 100644
--- a/examples/3d/texture_filtering.rs
+++ b/examples/3d/texture_filtering.rs
@@ -166,7 +166,7 @@ fn generate_texture(size: u32, cx: f32, cy: f32) -> Texture {
     // This is a procedurally-generated texture, so we can generate the image
     // directly at any size we want. Generating each mipmap level like this
     // should produce the prettiest-looking results.
-    let mut data = Vec::new();
+    let mut mipmaps = Vec::new();
     let mut mip_size = size;
 
     // Limiting the smallest mipmap size to 4x4 helps avoid the texture looking
@@ -192,7 +192,7 @@ fn generate_texture(size: u32, cx: f32, cy: f32) -> Texture {
             })
             .collect();
 
-        data.push(texels);
+        mipmaps.push(texels);
         mip_size /= 2;
     }
 
@@ -207,10 +207,13 @@ fn generate_texture(size: u32, cx: f32, cy: f32) -> Texture {
         ..Default::default()
     };
 
+    let data = mipmaps.remove(0);
+
     Texture {
         data,
+        mipmaps,
         size: Extent3d::new(size, size, 1),
-        mip_levels: 0,
+        max_mip_level: None,
         format: TextureFormat::Rgba8UnormSrgb,
         dimension: TextureDimension::D2,
         sampler,
@@ -228,35 +231,35 @@ impl TextureFiltering {
     fn apply(&self, tex: &mut Texture) {
         match self {
             TextureFiltering::Nearest => {
-                tex.mip_levels = 1;
+                tex.max_mip_level = Some(0);
                 tex.sampler.mag_filter = FilterMode::Nearest;
                 tex.sampler.min_filter = FilterMode::Nearest;
                 tex.sampler.mipmap_filter = FilterMode::Nearest;
                 tex.sampler.anisotropy_clamp = None;
             }
             TextureFiltering::Linear => {
-                tex.mip_levels = 1;
+                tex.max_mip_level = Some(0);
                 tex.sampler.mag_filter = FilterMode::Linear;
                 tex.sampler.min_filter = FilterMode::Linear;
                 tex.sampler.mipmap_filter = FilterMode::Nearest;
                 tex.sampler.anisotropy_clamp = None;
             }
             TextureFiltering::NearestMipmap => {
-                tex.mip_levels = 0;
+                tex.max_mip_level = None;
                 tex.sampler.mag_filter = FilterMode::Linear;
                 tex.sampler.min_filter = FilterMode::Linear;
                 tex.sampler.mipmap_filter = FilterMode::Nearest;
                 tex.sampler.anisotropy_clamp = None;
             }
             TextureFiltering::LinearMipmap => {
-                tex.mip_levels = 0;
+                tex.max_mip_level = None;
                 tex.sampler.mag_filter = FilterMode::Linear;
                 tex.sampler.min_filter = FilterMode::Linear;
                 tex.sampler.mipmap_filter = FilterMode::Linear;
                 tex.sampler.anisotropy_clamp = None;
             }
             TextureFiltering::Anisotropic => {
-                tex.mip_levels = 0;
+                tex.max_mip_level = None;
                 tex.sampler.mag_filter = FilterMode::Linear;
                 tex.sampler.min_filter = FilterMode::Linear;
                 tex.sampler.mipmap_filter = FilterMode::Linear;

From e0ead437ba48ad0cb5ac63550111b8e5043639f6 Mon Sep 17 00:00:00 2001
From: Jasen Borisov <jamadazi@protonmail.ch>
Date: Fri, 19 Mar 2021 14:06:04 +0100
Subject: [PATCH 13/15] add minimum size limit to generate_mipmaps

---
 crates/bevy_gltf/src/loader.rs            |  2 +-
 crates/bevy_render/src/texture/texture.rs | 25 ++++++++++++++++++-----
 examples/3d/texture_filtering.rs          |  2 +-
 3 files changed, 22 insertions(+), 7 deletions(-)

diff --git a/crates/bevy_gltf/src/loader.rs b/crates/bevy_gltf/src/loader.rs
index e8757fa6817ef..d4e6e57ba82a9 100644
--- a/crates/bevy_gltf/src/loader.rs
+++ b/crates/bevy_gltf/src/loader.rs
@@ -284,7 +284,7 @@ async fn load_gltf<'a, 'b>(
             .unwrap_or(false);
 
         if needs_mipmaps {
-            texture.generate_mipmaps(None);
+            texture.generate_mipmaps(None, None);
         }
 
         let texture_label = texture_label(&gltf_texture);
diff --git a/crates/bevy_render/src/texture/texture.rs b/crates/bevy_render/src/texture/texture.rs
index 0ee53b95bb2a9..2d658b9d165e1 100644
--- a/crates/bevy_render/src/texture/texture.rs
+++ b/crates/bevy_render/src/texture/texture.rs
@@ -173,8 +173,10 @@ impl Texture {
     ///
     /// Currently this operation is performed on the CPU.
     ///
-    /// It will generate images up to `max_mip_level` (or all levels, if
-    /// unspecified), by downscaling the previous larger level.
+    /// The number of mipmaps to generate is limited to `max_mip_level`, or
+    /// until either width or height reaches `min_size`.
+    ///
+    /// Mipmaps are generated by downscaling the base texture image.
     ///
     /// This method uses the `Triangle` image resizing filter. This is the
     /// fastest algorithm that produces acceptable results.
@@ -184,8 +186,8 @@ impl Texture {
     ///
     /// Currently only supports 2D textures in a few pixel formats. Will panic
     /// if used on an unsupported texture.
-    pub fn generate_mipmaps(&mut self, max_mip_level: Option<usize>) {
-        self.generate_mipmaps_with_filter(max_mip_level, ImageResizeFilter::Triangle)
+    pub fn generate_mipmaps(&mut self, max_mip_level: Option<usize>, min_size: Option<u32>) {
+        self.generate_mipmaps_with_filter(max_mip_level, min_size, ImageResizeFilter::Triangle)
     }
 
     /// Variant of `generate_mipmaps` to allow specifying the filtering algorithm
@@ -194,6 +196,7 @@ impl Texture {
     pub fn generate_mipmaps_with_filter(
         &mut self,
         max_mip_level: Option<usize>,
+        min_size: Option<u32>,
         filter: ImageResizeFilter,
     ) {
         if self.dimension != TextureDimension::D2 {
@@ -207,7 +210,19 @@ impl Texture {
         // PERF: this is inefficient: `texture_to_image` does a `.clone()` of the source data
         let base_image = super::image_texture_conversion::texture_to_image(self).unwrap();
 
-        while mip_size.volume() > 1 && mip_level <= max_mip_level.unwrap_or(mip_level + 1) {
+        while mip_size.volume() > 1 {
+            if let Some(max_level) = max_mip_level {
+                if mip_level > max_level {
+                    break;
+                }
+            }
+
+            if let Some(min_size) = min_size {
+                if mip_size.width < min_size || mip_size.height < min_size {
+                    break;
+                }
+            }
+
             let resized = base_image.resize_exact(mip_size.width, mip_size.height, filter);
 
             let (_, _, new_data) = super::image_texture_conversion::image_to_texture_data(resized);
diff --git a/examples/3d/texture_filtering.rs b/examples/3d/texture_filtering.rs
index d153bbd618df8..53714eff9b887 100644
--- a/examples/3d/texture_filtering.rs
+++ b/examples/3d/texture_filtering.rs
@@ -221,7 +221,7 @@ fn generate_texture(size: u32, cx: f32, cy: f32) -> Texture {
 
     // Alternatively, if we hadn't generated our own mipmaps above, we could
     // have asked Bevy to make them for us by downscaling the base image level:
-    //texture.generate_mipmaps(None);
+    //texture.generate_mipmaps(None, Some(4));
 
     // You can try to remove the while loop earlier (to only generate one image)
     // and uncomment the line above, if you want to see how it looks and compare

From d3bb1a1dd2c05b140164f25a78e186c02f01992b Mon Sep 17 00:00:00 2001
From: Jasen Borisov <jamadazi@protonmail.ch>
Date: Fri, 19 Mar 2021 14:13:42 +0100
Subject: [PATCH 14/15] remove some unneccessary blank lines, add comment

---
 crates/bevy_render/src/texture/texture.rs            | 4 ----
 crates/bevy_render/src/texture/texture_descriptor.rs | 1 +
 2 files changed, 1 insertion(+), 4 deletions(-)

diff --git a/crates/bevy_render/src/texture/texture.rs b/crates/bevy_render/src/texture/texture.rs
index 2d658b9d165e1..72ba5e4ca392d 100644
--- a/crates/bevy_render/src/texture/texture.rs
+++ b/crates/bevy_render/src/texture/texture.rs
@@ -116,7 +116,6 @@ impl Texture {
 
     pub fn resize(&mut self, size: Extent3d) {
         self.size = size;
-
         self.data
             .resize(size.volume() * self.format.pixel_size(), 0);
 
@@ -204,7 +203,6 @@ impl Texture {
         }
 
         let mut mip_level = self.mipmaps.len() + 1;
-
         let mut mip_size = self.mip_size(mip_level);
 
         // PERF: this is inefficient: `texture_to_image` does a `.clone()` of the source data
@@ -224,9 +222,7 @@ impl Texture {
             }
 
             let resized = base_image.resize_exact(mip_size.width, mip_size.height, filter);
-
             let (_, _, new_data) = super::image_texture_conversion::image_to_texture_data(resized);
-
             self.mipmaps.push(new_data);
 
             mip_level += 1;
diff --git a/crates/bevy_render/src/texture/texture_descriptor.rs b/crates/bevy_render/src/texture/texture_descriptor.rs
index d3f0871923ea7..cca25d5142905 100644
--- a/crates/bevy_render/src/texture/texture_descriptor.rs
+++ b/crates/bevy_render/src/texture/texture_descriptor.rs
@@ -16,6 +16,7 @@ impl From<&Texture> for TextureDescriptor {
         TextureDescriptor {
             size: texture.size,
             mip_level_count: if let Some(max_level) = texture.max_mip_level {
+                // note: + 1 is to account for the base texture image
                 (max_level as u32 + 1).min(texture.mipmaps.len() as u32 + 1)
             } else {
                 texture.mipmaps.len() as u32 + 1

From a6c108e0bc70ff1cd17eabf0ee61caab9c8ee68a Mon Sep 17 00:00:00 2001
From: Jasen Borisov <jamadazi@protonmail.ch>
Date: Fri, 19 Mar 2021 14:16:24 +0100
Subject: [PATCH 15/15] add Quad::tiled constructor

---
 crates/bevy_render/src/mesh/shape/mod.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/crates/bevy_render/src/mesh/shape/mod.rs b/crates/bevy_render/src/mesh/shape/mod.rs
index 49c7350bfca8a..9d1dd7f2fad23 100644
--- a/crates/bevy_render/src/mesh/shape/mod.rs
+++ b/crates/bevy_render/src/mesh/shape/mod.rs
@@ -152,6 +152,14 @@ impl Quad {
             uv_scale: Vec2::splat(1.0),
         }
     }
+
+    pub fn tiled(size: Vec2, uv_scale: Vec2) -> Self {
+        Self {
+            size,
+            flip: false,
+            uv_scale,
+        }
+    }
 }
 
 impl From<Quad> for Mesh {