From a42e07f482afaab063bcc614a7391774d4689d00 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Kurt=20K=C3=BChnert?= <kuehnert.kurt95@gmail.com>
Date: Thu, 7 Oct 2021 19:26:05 +0200
Subject: [PATCH 1/2] renamed the texture module to image moved the texture
 cache renamed many texture variables to image

---
 Cargo.toml                                    |   4 +-
 examples/2d/pipelined_image_atlas.rs          |  98 ++++++++
 examples/2d/pipelined_texture_atlas.rs        |  94 -------
 examples/README.md                            |   2 +-
 examples/shader/custom_shader_pipelined.rs    |   2 +-
 examples/tools/bevymark_pipelined.rs          |  22 +-
 pipelined/bevy_core_pipeline/src/lib.rs       |   2 +-
 pipelined/bevy_gltf2/src/loader.rs            |   4 +-
 pipelined/bevy_pbr2/src/material.rs           |   2 +-
 pipelined/bevy_pbr2/src/render/light.rs       |   1 -
 pipelined/bevy_pbr2/src/render/mod.rs         |   2 +-
 .../hdr_image_loader.rs}                      |  10 +-
 .../src/{texture => image}/image.rs           |  21 +-
 .../image_conversion.rs}                      |   9 +-
 .../image_loader.rs}                          |  15 +-
 .../src/{texture => image}/mod.rs             |  31 +--
 pipelined/bevy_render2/src/lib.rs             |   8 +-
 .../bevy_render2/src/render_resource/mod.rs   |   2 +
 .../texture_cache.rs                          |  13 +
 pipelined/bevy_render2/src/view/window.rs     |   2 +-
 pipelined/bevy_sprite2/src/bundle.rs          |  32 ++-
 ...lder.rs => dynamic_image_atlas_builder.rs} |  67 +++--
 pipelined/bevy_sprite2/src/image_atlas.rs     | 127 ++++++++++
 .../bevy_sprite2/src/image_atlas_builder.rs   | 227 +++++++++++++++++
 pipelined/bevy_sprite2/src/lib.rs             |  15 +-
 pipelined/bevy_sprite2/src/rect.rs            |   2 +-
 pipelined/bevy_sprite2/src/render/mod.rs      |  61 ++---
 pipelined/bevy_sprite2/src/sprite.rs          |  48 +++-
 pipelined/bevy_sprite2/src/texture_atlas.rs   | 145 -----------
 .../bevy_sprite2/src/texture_atlas_builder.rs | 236 ------------------
 30 files changed, 655 insertions(+), 649 deletions(-)
 create mode 100644 examples/2d/pipelined_image_atlas.rs
 delete mode 100644 examples/2d/pipelined_texture_atlas.rs
 rename pipelined/bevy_render2/src/{texture/hdr_texture_loader.rs => image/hdr_image_loader.rs} (87%)
 rename pipelined/bevy_render2/src/{texture => image}/image.rs (95%)
 rename pipelined/bevy_render2/src/{texture/image_texture_conversion.rs => image/image_conversion.rs} (95%)
 rename pipelined/bevy_render2/src/{texture/image_texture_loader.rs => image/image_loader.rs} (86%)
 rename pipelined/bevy_render2/src/{texture => image}/mod.rs (59%)
 rename pipelined/bevy_render2/src/{texture => render_resource}/texture_cache.rs (87%)
 rename pipelined/bevy_sprite2/src/{dynamic_texture_atlas_builder.rs => dynamic_image_atlas_builder.rs} (51%)
 create mode 100644 pipelined/bevy_sprite2/src/image_atlas.rs
 create mode 100644 pipelined/bevy_sprite2/src/image_atlas_builder.rs
 delete mode 100644 pipelined/bevy_sprite2/src/texture_atlas.rs
 delete mode 100644 pipelined/bevy_sprite2/src/texture_atlas_builder.rs

diff --git a/Cargo.toml b/Cargo.toml
index 6bb9d5c9407e6..b8150342bcc10 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -148,8 +148,8 @@ name = "texture_atlas"
 path = "examples/2d/texture_atlas.rs"
 
 [[example]]
-name = "pipelined_texture_atlas"
-path = "examples/2d/pipelined_texture_atlas.rs"
+name = "pipelined_image_atlas"
+path = "examples/2d/pipelined_image_atlas.rs"
 
 # 3D Rendering
 [[example]]
diff --git a/examples/2d/pipelined_image_atlas.rs b/examples/2d/pipelined_image_atlas.rs
new file mode 100644
index 0000000000000..ec658c699c4be
--- /dev/null
+++ b/examples/2d/pipelined_image_atlas.rs
@@ -0,0 +1,98 @@
+use bevy::{
+    asset::LoadState,
+    math::Vec3,
+    prelude::{
+        App, AssetServer, Assets, Commands, HandleUntyped, Res, ResMut, State, SystemSet, Transform,
+    },
+    render2::{camera::OrthographicCameraBundle, image::Image},
+    sprite2::{
+        AtlasSprite, ImageAtlas, ImageAtlasBuilder, PipelinedAtlasSpriteBundle,
+        PipelinedSpriteBundle,
+    },
+    PipelinedDefaultPlugins,
+};
+
+/// In this example we generate a new [`ImageAtlas`] (sprite sheet) from a folder containing
+/// individual images.
+fn main() {
+    App::new()
+        .init_resource::<RpgImageHandles>()
+        .add_plugins(PipelinedDefaultPlugins)
+        .add_state(AppState::Setup)
+        .add_system_set(SystemSet::on_enter(AppState::Setup).with_system(load_images))
+        .add_system_set(SystemSet::on_update(AppState::Setup).with_system(check_images))
+        .add_system_set(SystemSet::on_enter(AppState::Finished).with_system(setup))
+        .run();
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+enum AppState {
+    Setup,
+    Finished,
+}
+
+#[derive(Default)]
+struct RpgImageHandles {
+    handles: Vec<HandleUntyped>,
+}
+
+fn load_images(mut rpg_sprite_handles: ResMut<RpgImageHandles>, asset_server: Res<AssetServer>) {
+    rpg_sprite_handles.handles = asset_server.load_folder("textures/rpg").unwrap();
+}
+
+fn check_images(
+    mut state: ResMut<State<AppState>>,
+    rpg_image_handles: ResMut<RpgImageHandles>,
+    asset_server: Res<AssetServer>,
+) {
+    if let LoadState::Loaded =
+        asset_server.get_group_load_state(rpg_image_handles.handles.iter().map(|handle| handle.id))
+    {
+        state.set(AppState::Finished).unwrap();
+    }
+}
+
+fn setup(
+    mut commands: Commands,
+    rpg_image_handles: Res<RpgImageHandles>,
+    asset_server: Res<AssetServer>,
+    mut image_atlases: ResMut<Assets<ImageAtlas>>,
+    mut images: ResMut<Assets<Image>>,
+) {
+    let mut atlas_builder = ImageAtlasBuilder::default();
+    for handle in rpg_image_handles.handles.iter() {
+        let image = images.get(handle).unwrap();
+        atlas_builder.add_image(handle.clone_weak().typed::<Image>(), image);
+    }
+
+    let image_atlas = atlas_builder.finish(&mut images).unwrap();
+    let image_atlas_source = image_atlas.source_image.clone();
+    let vendor_handle = asset_server.get_handle("textures/rpg/chars/vendor/generic-rpg-vendor.png");
+    let vendor_index = image_atlas.get_region_index(&vendor_handle).unwrap();
+    let atlas_handle = image_atlases.add(image_atlas);
+
+    // set up a scene to display our texture atlas
+    commands.spawn_bundle(OrthographicCameraBundle::new_2d());
+    // draw a sprite from the atlas
+    commands.spawn_bundle(PipelinedAtlasSpriteBundle {
+        transform: Transform {
+            translation: Vec3::new(150.0, 0.0, 0.0),
+            scale: Vec3::splat(4.0),
+            ..Default::default()
+        },
+        sprite: AtlasSprite {
+            region_index: vendor_index as u32,
+            color: Default::default(),
+            flip_x: true,
+            flip_y: true,
+        },
+        image_atlas: atlas_handle,
+        ..Default::default()
+    });
+    // draw the atlas itself
+    commands.spawn_bundle(PipelinedSpriteBundle {
+        image: image_atlas_source,
+        transform: Transform::from_xyz(-300.0, 0.0, 0.0),
+        ..Default::default()
+    });
+}
diff --git a/examples/2d/pipelined_texture_atlas.rs b/examples/2d/pipelined_texture_atlas.rs
deleted file mode 100644
index a11bad5e7e3ee..0000000000000
--- a/examples/2d/pipelined_texture_atlas.rs
+++ /dev/null
@@ -1,94 +0,0 @@
-use bevy::{
-    asset::LoadState,
-    math::Vec3,
-    prelude::{
-        App, AssetServer, Assets, Commands, HandleUntyped, IntoSystem, Res, ResMut, State,
-        SystemSet, Transform,
-    },
-    render2::{camera::OrthographicCameraBundle, texture::Image},
-    sprite2::{
-        PipelinedSpriteBundle, PipelinedSpriteSheetBundle, TextureAtlas, TextureAtlasBuilder,
-        TextureAtlasSprite,
-    },
-    PipelinedDefaultPlugins,
-};
-
-/// In this example we generate a new texture atlas (sprite sheet) from a folder containing
-/// individual sprites
-fn main() {
-    App::new()
-        .init_resource::<RpgSpriteHandles>()
-        .add_plugins(PipelinedDefaultPlugins)
-        .add_state(AppState::Setup)
-        .add_system_set(SystemSet::on_enter(AppState::Setup).with_system(load_textures.system()))
-        .add_system_set(SystemSet::on_update(AppState::Setup).with_system(check_textures.system()))
-        .add_system_set(SystemSet::on_enter(AppState::Finished).with_system(setup.system()))
-        .run();
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-enum AppState {
-    Setup,
-    Finished,
-}
-
-#[derive(Default)]
-struct RpgSpriteHandles {
-    handles: Vec<HandleUntyped>,
-}
-
-fn load_textures(mut rpg_sprite_handles: ResMut<RpgSpriteHandles>, asset_server: Res<AssetServer>) {
-    rpg_sprite_handles.handles = asset_server.load_folder("textures/rpg").unwrap();
-}
-
-fn check_textures(
-    mut state: ResMut<State<AppState>>,
-    rpg_sprite_handles: ResMut<RpgSpriteHandles>,
-    asset_server: Res<AssetServer>,
-) {
-    if let LoadState::Loaded =
-        asset_server.get_group_load_state(rpg_sprite_handles.handles.iter().map(|handle| handle.id))
-    {
-        state.set(AppState::Finished).unwrap();
-    }
-}
-
-fn setup(
-    mut commands: Commands,
-    rpg_sprite_handles: Res<RpgSpriteHandles>,
-    asset_server: Res<AssetServer>,
-    mut texture_atlases: ResMut<Assets<TextureAtlas>>,
-    mut textures: ResMut<Assets<Image>>,
-) {
-    let mut texture_atlas_builder = TextureAtlasBuilder::default();
-    for handle in rpg_sprite_handles.handles.iter() {
-        let texture = textures.get(handle).unwrap();
-        texture_atlas_builder.add_texture(handle.clone_weak().typed::<Image>(), texture);
-    }
-
-    let texture_atlas = texture_atlas_builder.finish(&mut textures).unwrap();
-    let texture_atlas_texture = texture_atlas.texture.clone();
-    let vendor_handle = asset_server.get_handle("textures/rpg/chars/vendor/generic-rpg-vendor.png");
-    let vendor_index = texture_atlas.get_texture_index(&vendor_handle).unwrap();
-    let atlas_handle = texture_atlases.add(texture_atlas);
-
-    // set up a scene to display our texture atlas
-    commands.spawn_bundle(OrthographicCameraBundle::new_2d());
-    // draw a sprite from the atlas
-    commands.spawn_bundle(PipelinedSpriteSheetBundle {
-        transform: Transform {
-            translation: Vec3::new(150.0, 0.0, 0.0),
-            scale: Vec3::splat(4.0),
-            ..Default::default()
-        },
-        sprite: TextureAtlasSprite::new(vendor_index as u32),
-        texture_atlas: atlas_handle,
-        ..Default::default()
-    });
-    // draw the atlas itself
-    commands.spawn_bundle(PipelinedSpriteBundle {
-        texture: texture_atlas_texture,
-        transform: Transform::from_xyz(-300.0, 0.0, 0.0),
-        ..Default::default()
-    });
-}
diff --git a/examples/README.md b/examples/README.md
index fdaf892a3cdf5..c9cbdc479f17b 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -85,7 +85,7 @@ Example | File | Description
 `contributors` | [`2d/contributors.rs`](./2d/contributors.rs) | Displays each contributor as a bouncy bevy-ball!
 `many_sprites` | [`2d/many_sprites.rs`](./2d/many_sprites.rs) | Displays many sprites in a grid arragement! Used for performance testing.
 `mesh` | [`2d/mesh.rs`](./2d/mesh.rs) | Renders a custom mesh
-`pipelined_texture_atlas` | [`2d/pipelined_texture_atlas.rs`](./2d/pipelined_texture_atlas.rs) | Generates a texture atlas (sprite sheet) from individual sprites
+`pipelined_image_atlas` | [`2d/pipelined_image_atlas.rs`](./2d/pipelined_image_atlas) | Generates a image atlas (sprite sheet) from individual images.
 `sprite` | [`2d/sprite.rs`](./2d/sprite.rs) | Renders a sprite
 `sprite_sheet` | [`2d/sprite_sheet.rs`](./2d/sprite_sheet.rs) | Renders an animated sprite
 `text2d` | [`2d/text2d.rs`](./2d/text2d.rs) | Generates text in 2d
diff --git a/examples/shader/custom_shader_pipelined.rs b/examples/shader/custom_shader_pipelined.rs
index 9fb9d118e4034..eecdd2c43cb7d 100644
--- a/examples/shader/custom_shader_pipelined.rs
+++ b/examples/shader/custom_shader_pipelined.rs
@@ -21,7 +21,7 @@ use bevy::{
         render_resource::*,
         renderer::RenderDevice,
         shader::Shader,
-        texture::BevyDefault,
+        image::BevyDefault,
         view::ExtractedView,
         RenderApp, RenderStage,
     },
diff --git a/examples/tools/bevymark_pipelined.rs b/examples/tools/bevymark_pipelined.rs
index f42969bc174d5..b026f2fb0ecca 100644
--- a/examples/tools/bevymark_pipelined.rs
+++ b/examples/tools/bevymark_pipelined.rs
@@ -5,7 +5,7 @@ use bevy::{
     input::Input,
     math::Vec3,
     prelude::{App, AssetServer, Handle, MouseButton, Transform},
-    render2::{camera::OrthographicCameraBundle, color::Color, texture::Image},
+    render2::{camera::OrthographicCameraBundle, color::Color, image::Image},
     sprite2::PipelinedSpriteBundle,
     window::WindowDescriptor,
     PipelinedDefaultPlugins,
@@ -62,7 +62,7 @@ fn main() {
         .run();
 }
 
-struct BirdTexture(Handle<Image>);
+struct BirdImage(Handle<Image>);
 
 fn setup(
     mut commands: Commands,
@@ -70,7 +70,7 @@ fn setup(
     mut counter: ResMut<BevyCounter>,
     asset_server: Res<AssetServer>,
 ) {
-    let texture = asset_server.load("branding/icon.png");
+    let image = asset_server.load("branding/icon.png");
     if let Some(initial_count) = std::env::args()
         .nth(1)
         .and_then(|arg| arg.parse::<u128>().ok())
@@ -80,7 +80,7 @@ fn setup(
             &window,
             &mut counter,
             initial_count,
-            texture.clone_weak(),
+            image.clone_weak(),
         );
     }
     commands.spawn_bundle(OrthographicCameraBundle::new_2d());
@@ -135,7 +135,7 @@ fn setup(
     //     ..Default::default()
     // });
 
-    commands.insert_resource(BirdTexture(texture));
+    commands.insert_resource(BirdImage(image));
 }
 
 #[allow(clippy::too_many_arguments)]
@@ -145,7 +145,7 @@ fn mouse_handler(
     time: Res<Time>,
     mouse_button_input: Res<Input<MouseButton>>,
     window: Res<WindowDescriptor>,
-    bird_texture: Res<BirdTexture>,
+    bird_image: Res<BirdImage>,
     // mut bird_material: ResMut<BirdMaterial>,
     mut counter: ResMut<BevyCounter>,
     // mut materials: ResMut<Assets<ColorMaterial>>,
@@ -154,11 +154,11 @@ fn mouse_handler(
     //     let mut rnd = rand::thread_rng();
     //     let color = gen_color(&mut rnd);
 
-    //     let texture_handle = asset_server.load("branding/icon.png");
+    //     let image = asset_server.load("branding/icon.png");
 
     //     bird_material.0 = materials.add(ColorMaterial {
     //         color: BASE_COLOR * color,
-    //         texture: Some(texture_handle),
+    //         image: Some(image),
     //     });
     // }
 
@@ -169,7 +169,7 @@ fn mouse_handler(
             &window,
             &mut counter,
             spawn_count,
-            bird_texture.0.clone(),
+            bird_image.0.clone(),
         );
     }
 }
@@ -179,7 +179,7 @@ fn spawn_birds(
     window: &WindowDescriptor,
     counter: &mut BevyCounter,
     spawn_count: u128,
-    texture: Handle<Image>,
+    image: Handle<Image>,
 ) {
     let bird_x = (window.width / -2.) + HALF_BIRD_SIZE;
     let bird_y = (window.height / 2.) - HALF_BIRD_SIZE;
@@ -188,7 +188,7 @@ fn spawn_birds(
         commands
             .spawn_bundle(PipelinedSpriteBundle {
                 // material: bird_material.0.clone(),
-                texture: texture.clone(),
+                image: image.clone(),
                 transform: Transform {
                     translation: Vec3::new(bird_x, bird_y, bird_z),
                     scale: Vec3::splat(BIRD_SCALE),
diff --git a/pipelined/bevy_core_pipeline/src/lib.rs b/pipelined/bevy_core_pipeline/src/lib.rs
index cff774108a61c..31a6a51f206aa 100644
--- a/pipelined/bevy_core_pipeline/src/lib.rs
+++ b/pipelined/bevy_core_pipeline/src/lib.rs
@@ -13,11 +13,11 @@ use bevy_ecs::prelude::*;
 use bevy_render2::{
     camera::{ActiveCameras, CameraPlugin},
     color::Color,
+    image::Image,
     render_graph::{EmptyNode, RenderGraph, SlotInfo, SlotType},
     render_phase::{sort_phase_system, DrawFunctionId, DrawFunctions, PhaseItem, RenderPhase},
     render_resource::*,
     renderer::RenderDevice,
-    texture::{Image, TextureCache},
     view::ExtractedView,
     RenderApp, RenderStage, RenderWorld,
 };
diff --git a/pipelined/bevy_gltf2/src/loader.rs b/pipelined/bevy_gltf2/src/loader.rs
index ea75f6c56dd24..c1f7118423a57 100644
--- a/pipelined/bevy_gltf2/src/loader.rs
+++ b/pipelined/bevy_gltf2/src/loader.rs
@@ -13,7 +13,7 @@ use bevy_render2::{
     },
     color::Color,
     mesh::{Indices, Mesh, VertexAttributeValues},
-    texture::{Image, ImageType, TextureError},
+    image::{Image, ImageType, ImageError},
 };
 use bevy_scene::Scene;
 use bevy_transform::{
@@ -50,7 +50,7 @@ pub enum GltfError {
     #[error("invalid image mime type: {0}")]
     InvalidImageMimeType(String),
     #[error("You may need to add the feature for the file format: {0}")]
-    ImageError(#[from] TextureError),
+    ImageError(#[from] ImageError),
     #[error("failed to load an asset path: {0}")]
     AssetIoError(#[from] AssetIoError),
 }
diff --git a/pipelined/bevy_pbr2/src/material.rs b/pipelined/bevy_pbr2/src/material.rs
index 913ac41f6ae06..9a88c6e1b2f09 100644
--- a/pipelined/bevy_pbr2/src/material.rs
+++ b/pipelined/bevy_pbr2/src/material.rs
@@ -5,10 +5,10 @@ use bevy_math::Vec4;
 use bevy_reflect::TypeUuid;
 use bevy_render2::{
     color::Color,
+    image::Image,
     render_asset::{PrepareAssetError, RenderAsset, RenderAssetPlugin, RenderAssets},
     render_resource::{BindGroup, Buffer, BufferInitDescriptor, BufferUsage, Sampler, TextureView},
     renderer::RenderDevice,
-    texture::Image,
 };
 use crevice::std140::{AsStd140, Std140};
 use wgpu::{BindGroupDescriptor, BindGroupEntry, BindingResource};
diff --git a/pipelined/bevy_pbr2/src/render/light.rs b/pipelined/bevy_pbr2/src/render/light.rs
index ad594df2f98c3..5e7113f7ec7cb 100644
--- a/pipelined/bevy_pbr2/src/render/light.rs
+++ b/pipelined/bevy_pbr2/src/render/light.rs
@@ -23,7 +23,6 @@ use bevy_render2::{
     render_resource::*,
     renderer::{RenderContext, RenderDevice, RenderQueue},
     shader::Shader,
-    texture::*,
     view::{ExtractedView, ViewUniformOffset, ViewUniforms},
 };
 use bevy_transform::components::GlobalTransform;
diff --git a/pipelined/bevy_pbr2/src/render/mod.rs b/pipelined/bevy_pbr2/src/render/mod.rs
index e765bc72dbc34..b5dfc07c859be 100644
--- a/pipelined/bevy_pbr2/src/render/mod.rs
+++ b/pipelined/bevy_pbr2/src/render/mod.rs
@@ -18,7 +18,7 @@ use bevy_render2::{
     render_resource::*,
     renderer::{RenderDevice, RenderQueue},
     shader::Shader,
-    texture::{BevyDefault, GpuImage, Image, TextureFormatPixelInfo},
+    image::{BevyDefault, GpuImage, Image, TextureFormatPixelInfo},
     view::{ExtractedView, ViewUniformOffset, ViewUniforms},
 };
 use bevy_transform::components::GlobalTransform;
diff --git a/pipelined/bevy_render2/src/texture/hdr_texture_loader.rs b/pipelined/bevy_render2/src/image/hdr_image_loader.rs
similarity index 87%
rename from pipelined/bevy_render2/src/texture/hdr_texture_loader.rs
rename to pipelined/bevy_render2/src/image/hdr_image_loader.rs
index 09890c0033a2a..81186c69cf50d 100644
--- a/pipelined/bevy_render2/src/texture/hdr_texture_loader.rs
+++ b/pipelined/bevy_render2/src/image/hdr_image_loader.rs
@@ -1,4 +1,4 @@
-use crate::texture::{Image, TextureFormatPixelInfo};
+use crate::image::{Image, TextureFormatPixelInfo};
 use anyhow::Result;
 use bevy_asset::{AssetLoader, LoadContext, LoadedAsset};
 use bevy_utils::BoxedFuture;
@@ -6,9 +6,9 @@ use wgpu::{Extent3d, TextureDimension, TextureFormat};
 
 /// Loads HDR textures as Texture assets
 #[derive(Clone, Default)]
-pub struct HdrTextureLoader;
+pub struct HdrImageLoader;
 
-impl AssetLoader for HdrTextureLoader {
+impl AssetLoader for HdrImageLoader {
     fn load<'a>(
         &'a self,
         bytes: &'a [u8],
@@ -36,7 +36,7 @@ impl AssetLoader for HdrTextureLoader {
                 rgba_data.extend_from_slice(&alpha.to_ne_bytes());
             }
 
-            let texture = Image::new(
+            let image = Image::new(
                 Extent3d {
                     width: info.width,
                     height: info.height,
@@ -47,7 +47,7 @@ impl AssetLoader for HdrTextureLoader {
                 format,
             );
 
-            load_context.set_default_asset(LoadedAsset::new(texture));
+            load_context.set_default_asset(LoadedAsset::new(image));
             Ok(())
         })
     }
diff --git a/pipelined/bevy_render2/src/texture/image.rs b/pipelined/bevy_render2/src/image/image.rs
similarity index 95%
rename from pipelined/bevy_render2/src/texture/image.rs
rename to pipelined/bevy_render2/src/image/image.rs
index 1be9671c92806..9dec05152e11f 100644
--- a/pipelined/bevy_render2/src/texture/image.rs
+++ b/pipelined/bevy_render2/src/image/image.rs
@@ -1,9 +1,9 @@
-use super::image_texture_conversion::image_to_texture;
+use super::image_conversion::from_dynamic_image;
 use crate::{
+    image::BevyDefault,
     render_asset::{PrepareAssetError, RenderAsset},
     render_resource::{Sampler, Texture, TextureView},
     renderer::{RenderDevice, RenderQueue},
-    texture::BevyDefault,
 };
 use bevy_ecs::system::{lifetimeless::SRes, SystemParamItem};
 use bevy_reflect::TypeUuid;
@@ -13,9 +13,6 @@ use wgpu::{
     TextureViewDescriptor,
 };
 
-pub const TEXTURE_ASSET_INDEX: u64 = 0;
-pub const SAMPLER_ASSET_INDEX: u64 = 1;
-
 #[derive(Debug, Clone, TypeUuid)]
 #[uuid = "6ea26da6-6cf8-4ea2-9986-1d7bf6c17d6f"]
 pub struct Image {
@@ -146,7 +143,7 @@ impl Image {
     /// - `TextureFormat::Rgba8UnormSrgb`
     /// - `TextureFormat::Bgra8UnormSrgb`
     pub fn convert(&self, new_format: TextureFormat) -> Option<Self> {
-        super::image_texture_conversion::texture_to_image(self)
+        super::image_conversion::to_dynamic_image(self)
             .and_then(|img| match new_format {
                 TextureFormat::R8Unorm => Some(image::DynamicImage::ImageLuma8(img.into_luma8())),
                 TextureFormat::Rg8Unorm => {
@@ -160,12 +157,12 @@ impl Image {
                 }
                 _ => None,
             })
-            .map(super::image_texture_conversion::image_to_texture)
+            .map(super::image_conversion::from_dynamic_image)
     }
 
     /// Load a bytes buffer in a [`Texture`], according to type `image_type`, using the `image`
     /// crate`
-    pub fn from_buffer(buffer: &[u8], image_type: ImageType) -> Result<Image, TextureError> {
+    pub fn from_buffer(buffer: &[u8], image_type: ImageType) -> Result<Image, ImageError> {
         let format = match image_type {
             ImageType::MimeType(mime_type) => match mime_type {
                 "image/png" => Ok(image::ImageFormat::Png),
@@ -175,10 +172,10 @@ impl Image {
                 "image/jpeg" => Ok(image::ImageFormat::Jpeg),
                 "image/bmp" => Ok(image::ImageFormat::Bmp),
                 "image/x-bmp" => Ok(image::ImageFormat::Bmp),
-                _ => Err(TextureError::InvalidImageMimeType(mime_type.to_string())),
+                _ => Err(ImageError::InvalidImageMimeType(mime_type.to_string())),
             },
             ImageType::Extension(extension) => image::ImageFormat::from_extension(extension)
-                .ok_or_else(|| TextureError::InvalidImageMimeType(extension.to_string())),
+                .ok_or_else(|| ImageError::InvalidImageMimeType(extension.to_string())),
         }?;
 
         // Load the image in the expected format.
@@ -188,13 +185,13 @@ impl Image {
         // cases.
 
         let dyn_img = image::load_from_memory_with_format(buffer, format)?;
-        Ok(image_to_texture(dyn_img))
+        Ok(from_dynamic_image(dyn_img))
     }
 }
 
 /// An error that occurs when loading a texture
 #[derive(Error, Debug)]
-pub enum TextureError {
+pub enum ImageError {
     #[error("invalid image mime type")]
     InvalidImageMimeType(String),
     #[error("invalid image extension")]
diff --git a/pipelined/bevy_render2/src/texture/image_texture_conversion.rs b/pipelined/bevy_render2/src/image/image_conversion.rs
similarity index 95%
rename from pipelined/bevy_render2/src/texture/image_texture_conversion.rs
rename to pipelined/bevy_render2/src/image/image_conversion.rs
index 862ff5ee58447..ead8fe25a0aa6 100644
--- a/pipelined/bevy_render2/src/texture/image_texture_conversion.rs
+++ b/pipelined/bevy_render2/src/image/image_conversion.rs
@@ -1,9 +1,8 @@
-use crate::texture::{Image, TextureFormatPixelInfo};
+use crate::image::{Image, TextureFormatPixelInfo};
 use wgpu::{Extent3d, TextureDimension, TextureFormat};
 
-// TODO: fix name?
 /// Helper method to convert a `DynamicImage` to a `Texture`
-pub(crate) fn image_to_texture(dyn_img: image::DynamicImage) -> Image {
+pub(crate) fn from_dynamic_image(dyn_img: image::DynamicImage) -> Image {
     use bevy_core::cast_slice;
     let width;
     let height;
@@ -91,7 +90,7 @@ pub(crate) fn image_to_texture(dyn_img: image::DynamicImage) -> Image {
                 let r = pixel[0];
                 let g = pixel[1];
                 let b = pixel[2];
-                let a = u16::max_value();
+                let a = u16::MAX;
 
                 local_data.extend_from_slice(&r.to_ne_bytes());
                 local_data.extend_from_slice(&g.to_ne_bytes());
@@ -126,7 +125,7 @@ pub(crate) fn image_to_texture(dyn_img: image::DynamicImage) -> Image {
 
 /// 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: &Image) -> Option<image::DynamicImage> {
+pub(crate) fn to_dynamic_image(texture: &Image) -> Option<image::DynamicImage> {
     match texture.texture_descriptor.format {
         TextureFormat::R8Unorm => image::ImageBuffer::from_raw(
             texture.texture_descriptor.size.width,
diff --git a/pipelined/bevy_render2/src/texture/image_texture_loader.rs b/pipelined/bevy_render2/src/image/image_loader.rs
similarity index 86%
rename from pipelined/bevy_render2/src/texture/image_texture_loader.rs
rename to pipelined/bevy_render2/src/image/image_loader.rs
index c539d0a6b4968..499687c586345 100644
--- a/pipelined/bevy_render2/src/texture/image_texture_loader.rs
+++ b/pipelined/bevy_render2/src/image/image_loader.rs
@@ -3,15 +3,15 @@ use bevy_asset::{AssetLoader, LoadContext, LoadedAsset};
 use bevy_utils::BoxedFuture;
 use thiserror::Error;
 
-use crate::texture::{Image, ImageType, TextureError};
+use crate::image::{Image, ImageType, ImageError};
 
 /// Loader for images that can be read by the `image` crate.
 #[derive(Clone, Default)]
-pub struct ImageTextureLoader;
+pub struct ImageLoader;
 
 const FILE_EXTENSIONS: &[&str] = &["png", "dds", "tga", "jpg", "jpeg", "bmp"];
 
-impl AssetLoader for ImageTextureLoader {
+impl AssetLoader for ImageLoader {
     fn load<'a>(
         &'a self,
         bytes: &'a [u8],
@@ -22,7 +22,7 @@ impl AssetLoader for ImageTextureLoader {
             let ext = load_context.path().extension().unwrap().to_str().unwrap();
 
             let dyn_img = Image::from_buffer(bytes, ImageType::Extension(ext)).map_err(|err| {
-                FileTextureError {
+                ImageFileError {
                     error: err,
                     path: format!("{}", load_context.path().display()),
                 }
@@ -38,13 +38,14 @@ impl AssetLoader for ImageTextureLoader {
     }
 }
 
+
 /// An error that occurs when loading a texture from a file
 #[derive(Error, Debug)]
-pub struct FileTextureError {
-    error: TextureError,
+pub struct ImageFileError {
+    error: ImageError,
     path: String,
 }
-impl std::fmt::Display for FileTextureError {
+impl std::fmt::Display for ImageFileError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
         write!(
             f,
diff --git a/pipelined/bevy_render2/src/texture/mod.rs b/pipelined/bevy_render2/src/image/mod.rs
similarity index 59%
rename from pipelined/bevy_render2/src/texture/mod.rs
rename to pipelined/bevy_render2/src/image/mod.rs
index cd25dd57387ae..6d422b421f44d 100644
--- a/pipelined/bevy_render2/src/texture/mod.rs
+++ b/pipelined/bevy_render2/src/image/mod.rs
@@ -1,38 +1,31 @@
+pub use self::image::*;
+use bevy_app::{App, Plugin};
+use bevy_asset::AddAsset;
 #[cfg(feature = "hdr")]
-mod hdr_texture_loader;
-#[allow(clippy::module_inception)]
-mod image;
-mod image_texture_loader;
-mod texture_cache;
+pub use hdr_image_loader::*;
+pub use image_loader::*;
 
-pub(crate) mod image_texture_conversion;
+use crate::render_asset::RenderAssetPlugin;
 
-pub use self::image::*;
 #[cfg(feature = "hdr")]
-pub use hdr_texture_loader::*;
-pub use image_texture_loader::*;
-pub use texture_cache::*;
+mod hdr_image_loader;
+#[allow(clippy::module_inception)]
+mod image;
+mod image_loader;
 
-use crate::{render_asset::RenderAssetPlugin, RenderApp, RenderStage};
-use bevy_app::{App, Plugin};
-use bevy_asset::AddAsset;
+pub(crate) mod image_conversion;
 
-// TODO: replace Texture names with Image names?
 pub struct ImagePlugin;
 
 impl Plugin for ImagePlugin {
     fn build(&self, app: &mut App) {
         #[cfg(feature = "png")]
         {
-            app.init_asset_loader::<ImageTextureLoader>();
+            app.init_asset_loader::<ImageLoader>();
         }
 
         app.add_plugin(RenderAssetPlugin::<Image>::default())
             .add_asset::<Image>();
-
-        app.sub_app(RenderApp)
-            .init_resource::<TextureCache>()
-            .add_system_to_stage(RenderStage::Cleanup, update_texture_cache_system);
     }
 }
 
diff --git a/pipelined/bevy_render2/src/lib.rs b/pipelined/bevy_render2/src/lib.rs
index df198eee20f87..d30fe7429d7e9 100644
--- a/pipelined/bevy_render2/src/lib.rs
+++ b/pipelined/bevy_render2/src/lib.rs
@@ -1,5 +1,6 @@
 pub mod camera;
 pub mod color;
+pub mod image;
 pub mod mesh;
 pub mod render_asset;
 pub mod render_component;
@@ -8,17 +9,17 @@ pub mod render_phase;
 pub mod render_resource;
 pub mod renderer;
 pub mod shader;
-pub mod texture;
 pub mod view;
 
 pub use once_cell;
 
 use crate::{
     camera::CameraPlugin,
+    image::ImagePlugin,
     mesh::MeshPlugin,
     render_graph::RenderGraph,
+    render_resource::TextureCachePlugin,
     renderer::render_system,
-    texture::ImagePlugin,
     view::{ViewPlugin, WindowRenderPlugin},
 };
 use bevy_app::{App, AppLabel, Plugin};
@@ -232,7 +233,8 @@ impl Plugin for RenderPlugin {
             .add_plugin(CameraPlugin)
             .add_plugin(ViewPlugin)
             .add_plugin(MeshPlugin)
-            .add_plugin(ImagePlugin);
+            .add_plugin(ImagePlugin)
+            .add_plugin(TextureCachePlugin);
     }
 }
 
diff --git a/pipelined/bevy_render2/src/render_resource/mod.rs b/pipelined/bevy_render2/src/render_resource/mod.rs
index 858052e3b9125..f7e0d6d7f894d 100644
--- a/pipelined/bevy_render2/src/render_resource/mod.rs
+++ b/pipelined/bevy_render2/src/render_resource/mod.rs
@@ -3,6 +3,7 @@ mod buffer;
 mod buffer_vec;
 mod pipeline;
 mod texture;
+mod texture_cache;
 mod uniform_vec;
 
 pub use bind_group::*;
@@ -10,6 +11,7 @@ pub use buffer::*;
 pub use buffer_vec::*;
 pub use pipeline::*;
 pub use texture::*;
+pub use texture_cache::*;
 pub use uniform_vec::*;
 
 // TODO: decide where re-exports should go
diff --git a/pipelined/bevy_render2/src/texture/texture_cache.rs b/pipelined/bevy_render2/src/render_resource/texture_cache.rs
similarity index 87%
rename from pipelined/bevy_render2/src/texture/texture_cache.rs
rename to pipelined/bevy_render2/src/render_resource/texture_cache.rs
index 3b9ebe7b1a494..0e10a74fe62f9 100644
--- a/pipelined/bevy_render2/src/texture/texture_cache.rs
+++ b/pipelined/bevy_render2/src/render_resource/texture_cache.rs
@@ -1,11 +1,24 @@
 use crate::{
     render_resource::{Texture, TextureView},
     renderer::RenderDevice,
+    RenderApp, RenderStage,
 };
+use bevy_app::{App, Plugin};
 use bevy_ecs::prelude::ResMut;
 use bevy_utils::HashMap;
 use wgpu::{TextureDescriptor, TextureViewDescriptor};
 
+/// Adds a [`TextureCache`] to the app, which caches textures that are repeatedly created each frame.
+pub struct TextureCachePlugin;
+
+impl Plugin for TextureCachePlugin {
+    fn build(&self, app: &mut App) {
+        app.sub_app(RenderApp)
+            .init_resource::<TextureCache>()
+            .add_system_to_stage(RenderStage::Cleanup, update_texture_cache_system);
+    }
+}
+
 struct CachedTextureMeta {
     texture: Texture,
     default_view: TextureView,
diff --git a/pipelined/bevy_render2/src/view/window.rs b/pipelined/bevy_render2/src/view/window.rs
index 82d5bc6047657..29d4de82d7882 100644
--- a/pipelined/bevy_render2/src/view/window.rs
+++ b/pipelined/bevy_render2/src/view/window.rs
@@ -1,7 +1,7 @@
 use crate::{
     render_resource::TextureView,
     renderer::{RenderDevice, RenderInstance},
-    texture::BevyDefault,
+    image::BevyDefault,
     RenderApp, RenderStage, RenderWorld,
 };
 use bevy_app::{App, Plugin};
diff --git a/pipelined/bevy_sprite2/src/bundle.rs b/pipelined/bevy_sprite2/src/bundle.rs
index 50f5c74432f7b..dfa2191b1b20e 100644
--- a/pipelined/bevy_sprite2/src/bundle.rs
+++ b/pipelined/bevy_sprite2/src/bundle.rs
@@ -1,18 +1,18 @@
-use crate::{
-    texture_atlas::{TextureAtlas, TextureAtlasSprite},
-    Sprite,
-};
+use crate::{image_atlas::ImageAtlas, AtlasSprite, Sprite};
 use bevy_asset::Handle;
 use bevy_ecs::bundle::Bundle;
-use bevy_render2::texture::Image;
+use bevy_render2::image::Image;
 use bevy_transform::components::{GlobalTransform, Transform};
 
+/// A bundle of components for drawing an sprite.
 #[derive(Bundle, Clone)]
 pub struct PipelinedSpriteBundle {
+    /// The sprite information used to render the image.
     pub sprite: Sprite,
+    /// The image of the sprite.
+    pub image: Handle<Image>,
     pub transform: Transform,
     pub global_transform: GlobalTransform,
-    pub texture: Handle<Image>,
 }
 
 impl Default for PipelinedSpriteBundle {
@@ -21,29 +21,27 @@ impl Default for PipelinedSpriteBundle {
             sprite: Default::default(),
             transform: Default::default(),
             global_transform: Default::default(),
-            texture: Default::default(),
+            image: Default::default(),
         }
     }
 }
 
-/// A Bundle of components for drawing a single sprite from a sprite sheet (also referred
-/// to as a `TextureAtlas`)
+/// A bundle of components for drawing a single sprite from a [`ImageAtlas`].
 #[derive(Bundle, Clone)]
-pub struct PipelinedSpriteSheetBundle {
-    /// The specific sprite from the texture atlas to be drawn
-    pub sprite: TextureAtlasSprite,
-    /// A handle to the texture atlas that holds the sprite images
-    pub texture_atlas: Handle<TextureAtlas>,
-    /// Data pertaining to how the sprite is drawn on the screen
+pub struct PipelinedAtlasSpriteBundle {
+    /// The specific sprite from the texture atlas to be drawn.
+    pub sprite: AtlasSprite,
+    /// The image atlas that holds the image of the sprite.
+    pub image_atlas: Handle<ImageAtlas>,
     pub transform: Transform,
     pub global_transform: GlobalTransform,
 }
 
-impl Default for PipelinedSpriteSheetBundle {
+impl Default for PipelinedAtlasSpriteBundle {
     fn default() -> Self {
         Self {
             sprite: Default::default(),
-            texture_atlas: Default::default(),
+            image_atlas: Default::default(),
             transform: Default::default(),
             global_transform: Default::default(),
         }
diff --git a/pipelined/bevy_sprite2/src/dynamic_texture_atlas_builder.rs b/pipelined/bevy_sprite2/src/dynamic_image_atlas_builder.rs
similarity index 51%
rename from pipelined/bevy_sprite2/src/dynamic_texture_atlas_builder.rs
rename to pipelined/bevy_sprite2/src/dynamic_image_atlas_builder.rs
index 9d57adf9e01f3..f689a8d39aa16 100644
--- a/pipelined/bevy_sprite2/src/dynamic_texture_atlas_builder.rs
+++ b/pipelined/bevy_sprite2/src/dynamic_image_atlas_builder.rs
@@ -1,15 +1,15 @@
-use crate::{Rect, TextureAtlas};
+use crate::{ImageAtlas, Rect};
 use bevy_asset::Assets;
 use bevy_math::Vec2;
-use bevy_render2::texture::{Image, TextureFormatPixelInfo};
+use bevy_render2::image::{Image, TextureFormatPixelInfo};
 use guillotiere::{size2, Allocation, AtlasAllocator};
 
-pub struct DynamicTextureAtlasBuilder {
+pub struct DynamicImageAtlasBuilder {
     pub atlas_allocator: AtlasAllocator,
     pub padding: i32,
 }
 
-impl DynamicTextureAtlasBuilder {
+impl DynamicImageAtlasBuilder {
     pub fn new(size: Vec2, padding: i32) -> Self {
         Self {
             atlas_allocator: AtlasAllocator::new(to_size2(size)),
@@ -17,24 +17,24 @@ impl DynamicTextureAtlasBuilder {
         }
     }
 
-    pub fn add_texture(
+    pub fn add_image(
         &mut self,
-        texture_atlas: &mut TextureAtlas,
-        textures: &mut Assets<Image>,
-        texture: &Image,
+        image_atlas: &mut ImageAtlas,
+        images: &mut Assets<Image>,
+        image: &Image,
     ) -> Option<u32> {
         let allocation = self.atlas_allocator.allocate(size2(
-            texture.texture_descriptor.size.width as i32 + self.padding,
-            texture.texture_descriptor.size.height as i32 + self.padding,
+            image.texture_descriptor.size.width as i32 + self.padding,
+            image.texture_descriptor.size.height as i32 + self.padding,
         ));
         if let Some(allocation) = allocation {
-            let atlas_texture = textures.get_mut(&texture_atlas.texture).unwrap();
-            self.place_texture(atlas_texture, allocation, texture);
-            let mut rect: Rect = allocation.rectangle.into();
-            rect.max.x -= self.padding as f32;
-            rect.max.y -= self.padding as f32;
-            texture_atlas.add_texture(rect);
-            Some((texture_atlas.len() - 1) as u32)
+            let atlas_image = images.get_mut(&image_atlas.source_image).unwrap();
+            self.place_image(atlas_image, allocation, image);
+            let mut region: Rect = allocation.rectangle.into();
+            region.max.x -= self.padding as f32;
+            region.max.y -= self.padding as f32;
+            image_atlas.add_region(region);
+            Some((image_atlas.len() - 1) as u32)
         } else {
             None
         }
@@ -63,26 +63,21 @@ impl DynamicTextureAtlasBuilder {
     //     }
     // }
 
-    fn place_texture(
-        &mut self,
-        atlas_texture: &mut Image,
-        allocation: Allocation,
-        texture: &Image,
-    ) {
-        let mut rect = allocation.rectangle;
-        rect.max.x -= self.padding;
-        rect.max.y -= self.padding;
-        let atlas_width = atlas_texture.texture_descriptor.size.width as usize;
-        let rect_width = rect.width() as usize;
-        let format_size = atlas_texture.texture_descriptor.format.pixel_size();
+    // Todo: duplicate of ImageAtlasBuilder::copy_image_to_atlas
+    fn place_image(&mut self, atlas_image: &mut Image, allocation: Allocation, image: &Image) {
+        let mut region = allocation.rectangle;
+        region.max.x -= self.padding;
+        region.max.y -= self.padding;
+        let atlas_width = atlas_image.texture_descriptor.size.width as usize;
+        let region_width = region.width() as usize;
+        let pixel_size = atlas_image.texture_descriptor.format.pixel_size();
 
-        for (texture_y, bound_y) in (rect.min.y..rect.max.y).map(|i| i as usize).enumerate() {
-            let begin = (bound_y * atlas_width + rect.min.x as usize) * format_size;
-            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]);
+        for (texture_y, bound_y) in (region.min.y..region.max.y).map(|i| i as usize).enumerate() {
+            let begin = (bound_y * atlas_width + region.min.x as usize) * pixel_size;
+            let end = begin + region_width * pixel_size;
+            let image_begin = texture_y * region_width * pixel_size;
+            let image_end = image_begin + region_width * pixel_size;
+            atlas_image.data[begin..end].copy_from_slice(&image.data[image_begin..image_end]);
         }
     }
 }
diff --git a/pipelined/bevy_sprite2/src/image_atlas.rs b/pipelined/bevy_sprite2/src/image_atlas.rs
new file mode 100644
index 0000000000000..522030f4f177a
--- /dev/null
+++ b/pipelined/bevy_sprite2/src/image_atlas.rs
@@ -0,0 +1,127 @@
+use crate::Rect;
+use bevy_asset::Handle;
+use bevy_math::Vec2;
+use bevy_reflect::TypeUuid;
+use bevy_render2::image::Image;
+use bevy_utils::HashMap;
+
+/// An atlas containing multiple images stored in regions on the source [`Image`].
+///
+/// Usize ids are used to reference a specific image region of the atlas. They can
+/// be retrieved via the [`ImageAtlas::get_image_index`] methode.
+/// [Example usage animating sprite.](https://github.com/bevyengine/bevy/blob/latest/examples/2d/sprite_sheet.rs)
+/// [Example usage loading sprite sheet.](https://github.com/bevyengine/bevy/blob/latest/examples/2d/image_atlas.rs)
+#[derive(Debug, Clone, TypeUuid)]
+#[uuid = "7233c597-ccfa-411f-bd59-9af349432ada"]
+pub struct ImageAtlas {
+    // Todo: maybe find a better name
+    /// The source image in which all images of the atlas are stored.
+    pub source_image: Handle<Image>,
+    // TODO: add support to Uniforms derive to write dimensions and sprites to the same buffer
+    pub size: Vec2,
+    /// The specific areas of the atlas where each image can be found.
+    pub regions: Vec<Rect>,
+    /// Mapping of image handles to the ids of the regions. This is useful for retrieving the
+    /// region id from the handle to the original image or file path.
+    pub image_handles: Option<HashMap<Handle<Image>, usize>>,
+}
+
+impl ImageAtlas {
+    /// Create a new atlas from the `source_image`, that does not have any individual
+    /// image `regions` specified.
+    pub fn new_empty(source_image: Handle<Image>, size: Vec2) -> Self {
+        Self {
+            source_image,
+            size,
+            regions: Vec::new(),
+            image_handles: None,
+        }
+    }
+
+    /// Generate an atlas by splitting the `source_image` into a grid where each cell of the grid of
+    /// `tile_size` is one of the image `regions` in the atlas.
+    /// The region ids are assigned from left to right and top to bottom in a Z-pattern.
+    pub fn from_grid(
+        source_image: Handle<Image>,
+        tile_size: Vec2,
+        columns: usize,
+        rows: usize,
+    ) -> ImageAtlas {
+        Self::from_grid_with_padding(
+            source_image,
+            tile_size,
+            columns,
+            rows,
+            Vec2::new(0f32, 0f32),
+        )
+    }
+
+    /// Generate an atlas by splitting the `source_image` into a grid where each cell of the grid of
+    /// `tile_size` is one of the image `regions` in the atlas and is separated by some `padding`.
+    /// The region ids are assigned from left to right and top to bottom in a Z-pattern.
+    pub fn from_grid_with_padding(
+        source_image: Handle<Image>,
+        tile_size: Vec2,
+        columns: usize,
+        rows: usize,
+        padding: Vec2,
+    ) -> ImageAtlas {
+        let mut regions = Vec::new();
+        let mut x_padding = 0.0;
+        let mut y_padding = 0.0;
+
+        for y in 0..rows {
+            if y > 0 {
+                y_padding = padding.y;
+            }
+            for x in 0..columns {
+                if x > 0 {
+                    x_padding = padding.x;
+                }
+
+                let rect_min = Vec2::new(
+                    (tile_size.x + x_padding) * x as f32,
+                    (tile_size.y + y_padding) * y as f32,
+                );
+
+                regions.push(Rect {
+                    min: rect_min,
+                    max: Vec2::new(rect_min.x + tile_size.x, rect_min.y + tile_size.y),
+                })
+            }
+        }
+
+        ImageAtlas {
+            source_image,
+            size: Vec2::new(
+                ((tile_size.x + x_padding) * columns as f32) - x_padding,
+                ((tile_size.y + y_padding) * rows as f32) - y_padding,
+            ),
+            regions,
+            image_handles: None,
+        }
+    }
+
+    /// Adds a new image `region` to the atlas. This `region` spans the section of the
+    /// `source_image` from the top-left corner of the image to the bottom-right corner.
+    pub fn add_region(&mut self, region: Rect) {
+        self.regions.push(region);
+    }
+
+    /// The number of image `regions` contained in the atlas.
+    pub fn len(&self) -> usize {
+        self.regions.len()
+    }
+
+    /// Returns `true` if the atlas contains no image `regions`.
+    pub fn is_empty(&self) -> bool {
+        self.regions.is_empty()
+    }
+
+    /// Returns the region index of the `image` inside the atlas.
+    pub fn get_region_index(&self, image: &Handle<Image>) -> Option<usize> {
+        self.image_handles
+            .as_ref()
+            .and_then(|image_handles| image_handles.get(image).cloned())
+    }
+}
diff --git a/pipelined/bevy_sprite2/src/image_atlas_builder.rs b/pipelined/bevy_sprite2/src/image_atlas_builder.rs
new file mode 100644
index 0000000000000..7e08696c4bb15
--- /dev/null
+++ b/pipelined/bevy_sprite2/src/image_atlas_builder.rs
@@ -0,0 +1,227 @@
+use bevy_asset::{Assets, Handle};
+use bevy_log::{debug, error, warn};
+use bevy_math::Vec2;
+use bevy_render2::{
+    image::{Image, TextureFormatPixelInfo},
+    render_resource::{Extent3d, TextureDimension, TextureFormat},
+};
+use bevy_utils::HashMap;
+use rectangle_pack::{
+    contains_smallest_box, pack_rects, volume_heuristic, GroupedRectsToPlace, PackedLocation,
+    RectToInsert, TargetBin,
+};
+use thiserror::Error;
+
+use crate::{image_atlas::ImageAtlas, Rect};
+
+#[derive(Debug, Error)]
+pub enum ImageAtlasBuilderError {
+    #[error("could not pack the images into the atlas within the given bounds")]
+    NotEnoughSpace,
+    #[error("added a image with the wrong format to the atlas")]
+    WrongFormat,
+}
+
+#[derive(Debug)]
+/// A builder which is used to create an [`ImageAtlas`] from many individual images.
+pub struct ImageAtlasBuilder {
+    /// The regions which must be placed with a key value pair of a image handle and index.
+    regions_to_place: GroupedRectsToPlace<Handle<Image>>,
+    /// The initial atlas size in pixels.
+    initial_size: Vec2,
+    /// The absolute maximum size of the atlas in pixels.
+    max_size: Vec2,
+    /// The texture format for the images that will be loaded in the atlas.
+    format: TextureFormat,
+    /// Enable automatic format conversion for images that have a different format than the atlas.
+    auto_format_conversion: bool,
+}
+
+impl Default for ImageAtlasBuilder {
+    fn default() -> Self {
+        Self {
+            regions_to_place: GroupedRectsToPlace::new(),
+            initial_size: Vec2::new(256., 256.),
+            max_size: Vec2::new(2048., 2048.),
+            format: TextureFormat::Rgba8UnormSrgb,
+            auto_format_conversion: true,
+        }
+    }
+}
+
+impl ImageAtlasBuilder {
+    /// Sets the initial size of the atlas in pixels.
+    pub fn initial_size(mut self, size: Vec2) -> Self {
+        self.initial_size = size;
+        self
+    }
+
+    /// Sets the max size of the atlas in pixels.
+    pub fn max_size(mut self, size: Vec2) -> Self {
+        self.max_size = size;
+        self
+    }
+
+    /// Sets the texture format for images of the atlas.
+    pub fn format(mut self, format: TextureFormat) -> Self {
+        self.format = format;
+        self
+    }
+
+    /// Control whether the added images should be converted to the format of the atlas,
+    /// if they are different.
+    pub fn auto_format_conversion(mut self, auto_format_conversion: bool) -> Self {
+        self.auto_format_conversion = auto_format_conversion;
+        self
+    }
+
+    // Todo: change this to only take in the size of the image
+    /// Adds a image to be copied to the atlas.
+    pub fn add_image(&mut self, image_handle: Handle<Image>, image: &Image) {
+        self.regions_to_place.push_rect(
+            image_handle,
+            None,
+            RectToInsert::new(
+                image.texture_descriptor.size.width,
+                image.texture_descriptor.size.height,
+                1,
+            ),
+        )
+    }
+
+    /// Copies the `image` data to the region in the `atlas_image`.
+    fn copy_image_to_atlas(atlas_image: &mut Image, image: &Image, region: &PackedLocation) {
+        let region_x = region.x() as usize;
+        let region_y = region.y() as usize;
+        let region_width = region.width() as usize;
+        let region_height = region.height() as usize;
+        let atlas_width = atlas_image.texture_descriptor.size.width as usize;
+        let pixel_size = atlas_image.texture_descriptor.format.pixel_size();
+
+        // copy row by row
+        for (image_row, bound_y) in (region_y..region_y + region_height).enumerate() {
+            let atlas_begin = (bound_y * atlas_width + region_x) * pixel_size;
+            let atlas_end = atlas_begin + region_width * pixel_size;
+            let image_begin = image_row * region_width * pixel_size;
+            let image_end = image_begin + region_width * pixel_size;
+            atlas_image.data[atlas_begin..atlas_end]
+                .copy_from_slice(&image.data[image_begin..image_end]);
+        }
+    }
+
+    // Todo: check auto_format_conversion here and fail explicitly with result if format can not be converted
+    /// Copies the `image` data to the region in the `atlas_image` and tries to convert the format
+    /// if they are different.
+    fn copy_image_converting(
+        &self,
+        atlas_image: &mut Image,
+        image: &Image,
+        region: &PackedLocation,
+    ) {
+        if self.format == image.texture_descriptor.format {
+            Self::copy_image_to_atlas(atlas_image, image, region);
+        } else if let Some(converted_image) = image.convert(self.format) {
+            debug!(
+                "Converting image from '{:?}' to '{:?}'",
+                image.texture_descriptor.format, self.format
+            );
+            Self::copy_image_to_atlas(atlas_image, &converted_image, region);
+        } else {
+            error!(
+                "Error converting image from '{:?}' to '{:?}', ignoring",
+                image.texture_descriptor.format, self.format
+            );
+        }
+    }
+
+    /// Consumes the builder and returns a result with a new [`ImageAtlas`].
+    ///
+    /// Internally it copies all images into the regions of a new image which the atlas will use.
+    /// It is not useful to hold strong handles to the copied images afterwards else they will
+    /// exist twice in memory.
+    ///
+    /// # Errors
+    ///
+    /// If there is not enough space in the `source_image` of the atlas, an error will
+    /// be returned. It is then recommended to make a larger atlas.
+    pub fn finish(self, images: &mut Assets<Image>) -> Result<ImageAtlas, ImageAtlasBuilderError> {
+        let initial_width = self.initial_size.x as u32;
+        let initial_height = self.initial_size.y as u32;
+        let max_width = self.max_size.x as u32;
+        let max_height = self.max_size.y as u32;
+
+        let mut current_width = initial_width;
+        let mut current_height = initial_height;
+        let mut region_placements = None;
+        let mut atlas_image = Image::default();
+
+        while region_placements.is_none() {
+            if current_width > max_width || current_height > max_height {
+                break;
+            }
+
+            let last_attempt = current_height == max_height && current_width == max_width;
+
+            let mut target_bins = std::collections::BTreeMap::new();
+            target_bins.insert(0, TargetBin::new(current_width, current_height, 1));
+            region_placements = match pack_rects(
+                &self.regions_to_place,
+                &mut target_bins,
+                &volume_heuristic,
+                &contains_smallest_box,
+            ) {
+                Ok(region_placements) => {
+                    atlas_image = Image::new_fill(
+                        Extent3d {
+                            width: current_width,
+                            height: current_height,
+                            depth_or_array_layers: 1,
+                        },
+                        TextureDimension::D2,
+                        &[0, 0, 0, 0],
+                        self.format,
+                    );
+                    Some(region_placements)
+                }
+                Err(rectangle_pack::RectanglePackError::NotEnoughBinSpace) => {
+                    current_height = (current_height * 2).clamp(0, max_height);
+                    current_width = (current_width * 2).clamp(0, max_width);
+                    None
+                }
+            };
+
+            if last_attempt {
+                break;
+            }
+        }
+
+        let region_placements = region_placements.ok_or(ImageAtlasBuilderError::NotEnoughSpace)?;
+
+        let mut regions = Vec::with_capacity(region_placements.packed_locations().len());
+        let mut image_handles = HashMap::default();
+        for (image_handle, (_, region)) in region_placements.packed_locations().iter() {
+            let image = images.get(image_handle).unwrap();
+            let min = Vec2::new(region.x() as f32, region.y() as f32);
+            let max = min + Vec2::new(region.width() as f32, region.height() as f32);
+            image_handles.insert(image_handle.clone_weak(), regions.len());
+            regions.push(Rect { min, max });
+            if image.texture_descriptor.format != self.format && !self.auto_format_conversion {
+                warn!(
+                    "Loading a image of format '{:?}' in an atlas with format '{:?}'",
+                    image.texture_descriptor.format, self.format
+                );
+                return Err(ImageAtlasBuilderError::WrongFormat);
+            }
+            self.copy_image_converting(&mut atlas_image, image, region);
+        }
+        Ok(ImageAtlas {
+            size: Vec2::new(
+                atlas_image.texture_descriptor.size.width as f32,
+                atlas_image.texture_descriptor.size.height as f32,
+            ),
+            source_image: images.add(atlas_image),
+            regions,
+            image_handles: Some(image_handles),
+        })
+    }
+}
diff --git a/pipelined/bevy_sprite2/src/lib.rs b/pipelined/bevy_sprite2/src/lib.rs
index 4d443d2b69912..c9d40ee851b42 100644
--- a/pipelined/bevy_sprite2/src/lib.rs
+++ b/pipelined/bevy_sprite2/src/lib.rs
@@ -1,18 +1,18 @@
 mod bundle;
-mod dynamic_texture_atlas_builder;
+mod dynamic_image_atlas_builder;
+mod image_atlas;
+mod image_atlas_builder;
 mod rect;
 mod render;
 mod sprite;
-mod texture_atlas;
-mod texture_atlas_builder;
 
 pub use bundle::*;
-pub use dynamic_texture_atlas_builder::*;
+pub use dynamic_image_atlas_builder::*;
+pub use image_atlas::*;
+pub use image_atlas_builder::*;
 pub use rect::*;
 pub use render::*;
 pub use sprite::*;
-pub use texture_atlas::*;
-pub use texture_atlas_builder::*;
 
 use bevy_app::prelude::*;
 use bevy_asset::AddAsset;
@@ -26,7 +26,7 @@ pub struct SpritePlugin;
 
 impl Plugin for SpritePlugin {
     fn build(&self, app: &mut App) {
-        app.add_asset::<TextureAtlas>().register_type::<Sprite>();
+        app.add_asset::<ImageAtlas>().register_type::<Sprite>();
         let render_app = app.sub_app(RenderApp);
         render_app
             .init_resource::<ImageBindGroups>()
@@ -45,6 +45,7 @@ impl Plugin for SpritePlugin {
             .write()
             .add(draw_sprite);
         let mut graph = render_app.world.get_resource_mut::<RenderGraph>().unwrap();
+        // Todo: extract the name into const
         graph.add_node("sprite", SpriteNode);
         graph
             .add_node_edge("sprite", bevy_core_pipeline::node::MAIN_PASS_DEPENDENCIES)
diff --git a/pipelined/bevy_sprite2/src/rect.rs b/pipelined/bevy_sprite2/src/rect.rs
index a90a59d71d68b..06743bfcfb723 100644
--- a/pipelined/bevy_sprite2/src/rect.rs
+++ b/pipelined/bevy_sprite2/src/rect.rs
@@ -1,7 +1,7 @@
 use bevy_math::Vec2;
 
 /// A rectangle defined by two points. There is no defined origin, so 0,0 could be anywhere
-/// (top-left, bottom-left, etc)
+/// (top-left, bottom-left, etc).
 #[repr(C)]
 #[derive(Default, Clone, Copy, Debug)]
 pub struct Rect {
diff --git a/pipelined/bevy_sprite2/src/render/mod.rs b/pipelined/bevy_sprite2/src/render/mod.rs
index 6ab413a06167f..5059c864ceb66 100644
--- a/pipelined/bevy_sprite2/src/render/mod.rs
+++ b/pipelined/bevy_sprite2/src/render/mod.rs
@@ -1,7 +1,4 @@
-use crate::{
-    texture_atlas::{TextureAtlas, TextureAtlasSprite},
-    Rect, Sprite,
-};
+use crate::{image_atlas::ImageAtlas, AtlasSprite, Rect, Sprite};
 use bevy_asset::{Assets, Handle};
 use bevy_core_pipeline::Transparent2d;
 use bevy_ecs::{
@@ -10,6 +7,7 @@ use bevy_ecs::{
 };
 use bevy_math::{Mat4, Vec2, Vec3, Vec4Swizzles};
 use bevy_render2::{
+    image::{BevyDefault, Image},
     mesh::{shape::Quad, Indices, Mesh, VertexAttributeValues},
     render_asset::RenderAssets,
     render_graph::{Node, NodeRunError, RenderGraphContext},
@@ -17,7 +15,6 @@ use bevy_render2::{
     render_resource::*,
     renderer::{RenderContext, RenderDevice},
     shader::Shader,
-    texture::{BevyDefault, Image},
     view::{ViewUniformOffset, ViewUniforms},
 };
 use bevy_transform::components::GlobalTransform;
@@ -150,33 +147,28 @@ impl FromWorld for SpriteShaders {
 
 pub struct ExtractedSprite {
     transform: Mat4,
-    rect: Rect,
-    handle: Handle<Image>,
+    region: Rect,
+    image: Handle<Image>,
     atlas_size: Option<Vec2>,
     vertex_index: usize,
 }
 
 pub fn extract_atlases(
     mut commands: Commands,
-    texture_atlases: Res<Assets<TextureAtlas>>,
-    atlas_query: Query<(
-        Entity,
-        &TextureAtlasSprite,
-        &GlobalTransform,
-        &Handle<TextureAtlas>,
-    )>,
+    image_atlases: Res<Assets<ImageAtlas>>,
+    atlas_query: Query<(Entity, &AtlasSprite, &GlobalTransform, &Handle<ImageAtlas>)>,
 ) {
     let mut sprites = Vec::new();
-    for (entity, atlas_sprite, transform, texture_atlas_handle) in atlas_query.iter() {
-        if let Some(texture_atlas) = texture_atlases.get(texture_atlas_handle) {
-            let rect = texture_atlas.textures[atlas_sprite.index as usize];
+    for (entity, atlas_sprite, transform, image_atlas) in atlas_query.iter() {
+        if let Some(image_atlas) = image_atlases.get(image_atlas) {
+            let region = image_atlas.regions[atlas_sprite.region_index as usize];
             sprites.push((
                 entity,
                 (ExtractedSprite {
-                    atlas_size: Some(texture_atlas.size),
+                    atlas_size: Some(image_atlas.size),
                     transform: transform.compute_matrix(),
-                    rect,
-                    handle: texture_atlas.texture.clone_weak(),
+                    region,
+                    image: image_atlas.source_image.clone_weak(),
                     vertex_index: 0,
                 },),
             ));
@@ -200,13 +192,13 @@ pub fn extract_sprites(
                 (ExtractedSprite {
                     atlas_size: None,
                     transform: transform.compute_matrix(),
-                    rect: Rect {
+                    region: Rect {
                         min: Vec2::ZERO,
                         max: sprite
                             .custom_size
                             .unwrap_or_else(|| Vec2::new(size.width as f32, size.height as f32)),
                     },
-                    handle: handle.clone_weak(),
+                    image: handle.clone_weak(),
                     vertex_index: 0,
                 },),
             ));
@@ -282,26 +274,25 @@ pub fn prepare_sprites(
         .reserve_and_clear(extracted_sprite_len * quad_indices.len(), &render_device);
 
     for (i, mut extracted_sprite) in extracted_sprites.iter_mut().enumerate() {
-        let sprite_rect = extracted_sprite.rect;
+        let region = extracted_sprite.region;
 
         // Specify the corners of the sprite
-        let bottom_left = Vec2::new(sprite_rect.min.x, sprite_rect.max.y);
-        let top_left = sprite_rect.min;
-        let top_right = Vec2::new(sprite_rect.max.x, sprite_rect.min.y);
-        let bottom_right = sprite_rect.max;
+        let bottom_left = Vec2::new(region.min.x, region.max.y);
+        let top_left = region.min;
+        let top_right = Vec2::new(region.max.x, region.min.y);
+        let bottom_right = region.max;
 
         let atlas_positions: [Vec2; 4] = [bottom_left, top_left, top_right, bottom_right];
 
         extracted_sprite.vertex_index = i;
         for (index, vertex_position) in quad_vertex_positions.iter().enumerate() {
             let mut final_position =
-                Vec3::from(*vertex_position) * extracted_sprite.rect.size().extend(1.0);
+                Vec3::from(*vertex_position) * extracted_sprite.region.size().extend(1.0);
             final_position = (extracted_sprite.transform * final_position.extend(1.0)).xyz();
             sprite_meta.vertices.push(SpriteVertex {
                 position: final_position.into(),
-                uv: (atlas_positions[index]
-                    / extracted_sprite.atlas_size.unwrap_or(sprite_rect.max))
-                .into(),
+                uv: (atlas_positions[index] / extracted_sprite.atlas_size.unwrap_or(region.max))
+                    .into(),
             });
         }
 
@@ -347,9 +338,9 @@ pub fn queue_sprites(
             for (entity, sprite) in extracted_sprites.iter_mut() {
                 image_bind_groups
                     .values
-                    .entry(sprite.handle.clone_weak())
+                    .entry(sprite.image.clone_weak())
                     .or_insert_with(|| {
-                        let gpu_image = gpu_images.get(&sprite.handle).unwrap();
+                        let gpu_image = gpu_images.get(&sprite.image).unwrap();
                         render_device.create_bind_group(&BindGroupDescriptor {
                             entries: &[
                                 BindGroupEntry {
@@ -368,7 +359,7 @@ pub fn queue_sprites(
                 transparent_phase.add(Transparent2d {
                     draw_function: draw_sprite_function,
                     entity,
-                    sort_key: sprite.handle.clone_weak(),
+                    sort_key: sprite.image.clone_weak(),
                 });
             }
         }
@@ -445,7 +436,7 @@ impl Draw<Transparent2d> for DrawSprite {
             1,
             image_bind_groups
                 .values
-                .get(&extracted_sprite.handle)
+                .get(&extracted_sprite.image)
                 .unwrap(),
             &[],
         );
diff --git a/pipelined/bevy_sprite2/src/sprite.rs b/pipelined/bevy_sprite2/src/sprite.rs
index 06ae90094d7f9..31d1be3d954bb 100644
--- a/pipelined/bevy_sprite2/src/sprite.rs
+++ b/pipelined/bevy_sprite2/src/sprite.rs
@@ -1,15 +1,53 @@
 use bevy_math::Vec2;
 use bevy_reflect::{Reflect, TypeUuid};
+use bevy_render2::color::Color;
 
+/// A sprite stores all the metadata required to draw a 2D [`Image`](bevy_render2::image::Image).
+/// It is used to render it's corresponding image resized or flipped.
 #[derive(Debug, Default, Clone, TypeUuid, Reflect)]
 #[uuid = "7233c597-ccfa-411f-bd59-9af349432ada"]
 #[repr(C)]
 pub struct Sprite {
-    /// Flip the sprite along the X axis
-    pub flip_x: bool,
-    /// Flip the sprite along the Y axis
-    pub flip_y: bool,
+    /// Flip the sprite along the X axis.
+    pub flip_x: bool, // Todo: actually use these
+    /// Flip the sprite along the Y axis.
+    pub flip_y: bool, // Todo: actually use these
     /// An optional custom size for the sprite that will be used when rendering, instead of the size
-    /// of the sprite's image
+    /// of the sprite's image.
     pub custom_size: Option<Vec2>,
 }
+
+// Todo: mirror Sprite API
+/// A sprite that stores all the metadata required to draw a region of an [`ImageAtlas`].
+/// It is used to render it's corresponding region resized or flipped.
+#[derive(Debug, Clone, TypeUuid, Reflect)]
+#[uuid = "7233c597-ccfa-411f-bd59-9af349432ada"]
+pub struct AtlasSprite {
+    pub region_index: u32,
+    pub color: Color, // what is this used for?
+    pub flip_x: bool, // Todo: actually use these
+    pub flip_y: bool, // Todo: actually use these
+                      // /// An optional custom size for the sprite that will be used when rendering, instead of the size
+                      // /// of the sprite's region.
+                      // pub custom_size: Option<Vec2>, // Todo: actually use these
+}
+
+impl Default for AtlasSprite {
+    fn default() -> Self {
+        Self {
+            region_index: 0,
+            color: Color::WHITE,
+            flip_x: false,
+            flip_y: false,
+        }
+    }
+}
+
+impl AtlasSprite {
+    pub fn new(index: u32) -> AtlasSprite {
+        Self {
+            region_index: index,
+            ..Default::default()
+        }
+    }
+}
diff --git a/pipelined/bevy_sprite2/src/texture_atlas.rs b/pipelined/bevy_sprite2/src/texture_atlas.rs
deleted file mode 100644
index 58ded48a3a920..0000000000000
--- a/pipelined/bevy_sprite2/src/texture_atlas.rs
+++ /dev/null
@@ -1,145 +0,0 @@
-use crate::Rect;
-use bevy_asset::Handle;
-use bevy_math::Vec2;
-use bevy_reflect::{Reflect, TypeUuid};
-use bevy_render2::{color::Color, texture::Image};
-use bevy_utils::HashMap;
-
-/// An atlas containing multiple textures (like a spritesheet or a tilemap).
-/// [Example usage animating sprite.](https://github.com/bevyengine/bevy/blob/latest/examples/2d/sprite_sheet.rs)
-/// [Example usage loading sprite sheet.](https://github.com/bevyengine/bevy/blob/latest/examples/2d/texture_atlas.rs)
-#[derive(Debug, Clone, TypeUuid)]
-#[uuid = "7233c597-ccfa-411f-bd59-9af349432ada"]
-pub struct TextureAtlas {
-    /// The handle to the texture in which the sprites are stored
-    pub texture: Handle<Image>,
-    // TODO: add support to Uniforms derive to write dimensions and sprites to the same buffer
-    pub size: Vec2,
-    /// The specific areas of the atlas where each texture can be found
-    pub textures: Vec<Rect>,
-    pub texture_handles: Option<HashMap<Handle<Image>, usize>>,
-}
-
-#[derive(Debug, Clone, TypeUuid, Reflect)]
-#[uuid = "7233c597-ccfa-411f-bd59-9af349432ada"]
-pub struct TextureAtlasSprite {
-    pub color: Color,
-    pub index: u32,
-    pub flip_x: bool,
-    pub flip_y: bool,
-}
-
-impl Default for TextureAtlasSprite {
-    fn default() -> Self {
-        Self {
-            index: 0,
-            color: Color::WHITE,
-            flip_x: false,
-            flip_y: false,
-        }
-    }
-}
-
-impl TextureAtlasSprite {
-    pub fn new(index: u32) -> TextureAtlasSprite {
-        Self {
-            index,
-            ..Default::default()
-        }
-    }
-}
-
-impl TextureAtlas {
-    /// Create a new `TextureAtlas` that has a texture, but does not have
-    /// any individual sprites specified
-    pub fn new_empty(texture: Handle<Image>, dimensions: Vec2) -> Self {
-        Self {
-            texture,
-            size: dimensions,
-            texture_handles: None,
-            textures: Vec::new(),
-        }
-    }
-
-    /// Generate a `TextureAtlas` by splitting a texture into a grid where each
-    /// cell of the grid  of `tile_size` is one of the textures in the atlas
-    pub fn from_grid(
-        texture: Handle<Image>,
-        tile_size: Vec2,
-        columns: usize,
-        rows: usize,
-    ) -> TextureAtlas {
-        Self::from_grid_with_padding(texture, tile_size, columns, rows, Vec2::new(0f32, 0f32))
-    }
-
-    /// Generate a `TextureAtlas` by splitting a texture into a grid where each
-    /// cell of the grid of `tile_size` is one of the textures in the atlas and is separated by
-    /// some `padding` in the texture
-    pub fn from_grid_with_padding(
-        texture: Handle<Image>,
-        tile_size: Vec2,
-        columns: usize,
-        rows: usize,
-        padding: Vec2,
-    ) -> TextureAtlas {
-        let mut sprites = Vec::new();
-        let mut x_padding = 0.0;
-        let mut y_padding = 0.0;
-
-        for y in 0..rows {
-            if y > 0 {
-                y_padding = padding.y;
-            }
-            for x in 0..columns {
-                if x > 0 {
-                    x_padding = padding.x;
-                }
-
-                let rect_min = Vec2::new(
-                    (tile_size.x + x_padding) * x as f32,
-                    (tile_size.y + y_padding) * y as f32,
-                );
-
-                sprites.push(Rect {
-                    min: rect_min,
-                    max: Vec2::new(rect_min.x + tile_size.x, rect_min.y + tile_size.y),
-                })
-            }
-        }
-
-        TextureAtlas {
-            size: Vec2::new(
-                ((tile_size.x + x_padding) * columns as f32) - x_padding,
-                ((tile_size.y + y_padding) * rows as f32) - y_padding,
-            ),
-            textures: sprites,
-            texture,
-            texture_handles: None,
-        }
-    }
-
-    /// Add a sprite to the list of textures in the `TextureAtlas`
-    ///
-    /// # Arguments
-    ///
-    /// * `rect` - The section of the atlas that contains the texture to be added,
-    /// from the top-left corner of the texture to the bottom-right corner
-    pub fn add_texture(&mut self, rect: Rect) {
-        self.textures.push(rect);
-    }
-
-    /// How many textures are in the `TextureAtlas`
-    pub fn len(&self) -> usize {
-        self.textures.len()
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.textures.is_empty()
-    }
-
-    pub fn get_texture_index(&self, texture: &Handle<Image>) -> Option<usize> {
-        self.texture_handles
-            .as_ref()
-            .and_then(|texture_handles| texture_handles.get(texture).cloned())
-    }
-}
diff --git a/pipelined/bevy_sprite2/src/texture_atlas_builder.rs b/pipelined/bevy_sprite2/src/texture_atlas_builder.rs
deleted file mode 100644
index 961fbebf36a55..0000000000000
--- a/pipelined/bevy_sprite2/src/texture_atlas_builder.rs
+++ /dev/null
@@ -1,236 +0,0 @@
-use bevy_asset::{Assets, Handle};
-use bevy_log::{debug, error, warn};
-use bevy_math::Vec2;
-use bevy_render2::{
-    render_resource::{Extent3d, TextureDimension, TextureFormat},
-    texture::{Image, TextureFormatPixelInfo},
-};
-use bevy_utils::HashMap;
-use rectangle_pack::{
-    contains_smallest_box, pack_rects, volume_heuristic, GroupedRectsToPlace, PackedLocation,
-    RectToInsert, TargetBin,
-};
-use thiserror::Error;
-
-use crate::{texture_atlas::TextureAtlas, Rect};
-
-#[derive(Debug, Error)]
-pub enum TextureAtlasBuilderError {
-    #[error("could not pack textures into an atlas within the given bounds")]
-    NotEnoughSpace,
-    #[error("added a texture with the wrong format in an atlas")]
-    WrongFormat,
-}
-
-#[derive(Debug)]
-/// A builder which is used to create a texture atlas from many individual
-/// sprites.
-pub struct TextureAtlasBuilder {
-    /// The grouped rects which must be placed with a key value pair of a
-    /// texture handle to an index.
-    rects_to_place: GroupedRectsToPlace<Handle<Image>>,
-    /// The initial atlas size in pixels.
-    initial_size: Vec2,
-    /// The absolute maximum size of the texture atlas in pixels.
-    max_size: Vec2,
-    /// The texture format for the textures that will be loaded in the atlas.
-    format: TextureFormat,
-    /// Enable automatic format conversion for textures if they are not in the atlas format.
-    auto_format_conversion: bool,
-}
-
-impl Default for TextureAtlasBuilder {
-    fn default() -> Self {
-        Self {
-            rects_to_place: GroupedRectsToPlace::new(),
-            initial_size: Vec2::new(256., 256.),
-            max_size: Vec2::new(2048., 2048.),
-            format: TextureFormat::Rgba8UnormSrgb,
-            auto_format_conversion: true,
-        }
-    }
-}
-
-pub type TextureAtlasBuilderResult<T> = Result<T, TextureAtlasBuilderError>;
-
-impl TextureAtlasBuilder {
-    /// Sets the initial size of the atlas in pixels.
-    pub fn initial_size(mut self, size: Vec2) -> Self {
-        self.initial_size = size;
-        self
-    }
-
-    /// Sets the max size of the atlas in pixels.
-    pub fn max_size(mut self, size: Vec2) -> Self {
-        self.max_size = size;
-        self
-    }
-
-    /// Sets the texture format for textures in the atlas.
-    pub fn format(mut self, format: TextureFormat) -> Self {
-        self.format = format;
-        self
-    }
-
-    /// Control whether the added texture should be converted to the atlas format, if different.
-    pub fn auto_format_conversion(mut self, auto_format_conversion: bool) -> Self {
-        self.auto_format_conversion = auto_format_conversion;
-        self
-    }
-
-    /// Adds a texture to be copied to the texture atlas.
-    pub fn add_texture(&mut self, texture_handle: Handle<Image>, texture: &Image) {
-        self.rects_to_place.push_rect(
-            texture_handle,
-            None,
-            RectToInsert::new(
-                texture.texture_descriptor.size.width,
-                texture.texture_descriptor.size.height,
-                1,
-            ),
-        )
-    }
-
-    fn copy_texture_to_atlas(
-        atlas_texture: &mut Image,
-        texture: &Image,
-        packed_location: &PackedLocation,
-    ) {
-        let rect_width = packed_location.width() as usize;
-        let rect_height = packed_location.height() as usize;
-        let rect_x = packed_location.x() as usize;
-        let rect_y = packed_location.y() as usize;
-        let atlas_width = atlas_texture.texture_descriptor.size.width as usize;
-        let format_size = atlas_texture.texture_descriptor.format.pixel_size();
-
-        for (texture_y, bound_y) in (rect_y..rect_y + rect_height).enumerate() {
-            let begin = (bound_y * atlas_width + rect_x) * format_size;
-            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]);
-        }
-    }
-
-    fn copy_converted_texture(
-        &self,
-        atlas_texture: &mut Image,
-        texture: &Image,
-        packed_location: &PackedLocation,
-    ) {
-        if self.format == texture.texture_descriptor.format {
-            Self::copy_texture_to_atlas(atlas_texture, texture, packed_location);
-        } else if let Some(converted_texture) = texture.convert(self.format) {
-            debug!(
-                "Converting texture from '{:?}' to '{:?}'",
-                texture.texture_descriptor.format, self.format
-            );
-            Self::copy_texture_to_atlas(atlas_texture, &converted_texture, packed_location);
-        } else {
-            error!(
-                "Error converting texture from '{:?}' to '{:?}', ignoring",
-                texture.texture_descriptor.format, self.format
-            );
-        }
-    }
-
-    /// Consumes the builder and returns a result with a new texture atlas.
-    ///
-    /// Internally it copies all rectangles from the textures and copies them
-    /// into a new texture which the texture atlas will use. It is not useful to
-    /// hold a strong handle to the texture afterwards else it will exist twice
-    /// in memory.
-    ///
-    /// # Errors
-    ///
-    /// If there is not enough space in the atlas texture, an error will
-    /// be returned. It is then recommended to make a larger sprite sheet.
-    pub fn finish(
-        self,
-        textures: &mut Assets<Image>,
-    ) -> Result<TextureAtlas, TextureAtlasBuilderError> {
-        let initial_width = self.initial_size.x as u32;
-        let initial_height = self.initial_size.y as u32;
-        let max_width = self.max_size.x as u32;
-        let max_height = self.max_size.y as u32;
-
-        let mut current_width = initial_width;
-        let mut current_height = initial_height;
-        let mut rect_placements = None;
-        let mut atlas_texture = Image::default();
-
-        while rect_placements.is_none() {
-            if current_width > max_width || current_height > max_height {
-                break;
-            }
-
-            let last_attempt = current_height == max_height && current_width == max_width;
-
-            let mut target_bins = std::collections::BTreeMap::new();
-            target_bins.insert(0, TargetBin::new(current_width, current_height, 1));
-            rect_placements = match pack_rects(
-                &self.rects_to_place,
-                &mut target_bins,
-                &volume_heuristic,
-                &contains_smallest_box,
-            ) {
-                Ok(rect_placements) => {
-                    atlas_texture = Image::new_fill(
-                        Extent3d {
-                            width: current_width,
-                            height: current_height,
-                            depth_or_array_layers: 1,
-                        },
-                        TextureDimension::D2,
-                        &[0, 0, 0, 0],
-                        self.format,
-                    );
-                    Some(rect_placements)
-                }
-                Err(rectangle_pack::RectanglePackError::NotEnoughBinSpace) => {
-                    current_height = (current_height * 2).clamp(0, max_height);
-                    current_width = (current_width * 2).clamp(0, max_width);
-                    None
-                }
-            };
-
-            if last_attempt {
-                break;
-            }
-        }
-
-        let rect_placements = rect_placements.ok_or(TextureAtlasBuilderError::NotEnoughSpace)?;
-
-        let mut texture_rects = Vec::with_capacity(rect_placements.packed_locations().len());
-        let mut texture_handles = HashMap::default();
-        for (texture_handle, (_, packed_location)) in rect_placements.packed_locations().iter() {
-            let texture = textures.get(texture_handle).unwrap();
-            let min = Vec2::new(packed_location.x() as f32, packed_location.y() as f32);
-            let max = min
-                + Vec2::new(
-                    packed_location.width() as f32,
-                    packed_location.height() as f32,
-                );
-            texture_handles.insert(texture_handle.clone_weak(), texture_rects.len());
-            texture_rects.push(Rect { min, max });
-            if texture.texture_descriptor.format != self.format && !self.auto_format_conversion {
-                warn!(
-                    "Loading a texture of format '{:?}' in an atlas with format '{:?}'",
-                    texture.texture_descriptor.format, self.format
-                );
-                return Err(TextureAtlasBuilderError::WrongFormat);
-            }
-            self.copy_converted_texture(&mut atlas_texture, texture, packed_location);
-        }
-        Ok(TextureAtlas {
-            size: Vec2::new(
-                atlas_texture.texture_descriptor.size.width as f32,
-                atlas_texture.texture_descriptor.size.height as f32,
-            ),
-            texture: textures.add(atlas_texture),
-            textures: texture_rects,
-            texture_handles: Some(texture_handles),
-        })
-    }
-}

From 01799f9d3e7bfbbc3740314bb3a9e89699080790 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Kurt=20K=C3=BChnert?= <kuehnert.kurt95@gmail.com>
Date: Thu, 7 Oct 2021 20:52:11 +0200
Subject: [PATCH 2/2] fixed ci

---
 examples/README.md                               | 2 +-
 examples/shader/custom_shader_pipelined.rs       | 2 +-
 pipelined/bevy_gltf2/src/loader.rs               | 2 +-
 pipelined/bevy_pbr2/src/render/mod.rs            | 2 +-
 pipelined/bevy_render2/src/image/image_loader.rs | 3 +--
 pipelined/bevy_render2/src/view/window.rs        | 2 +-
 6 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/examples/README.md b/examples/README.md
index c9cbdc479f17b..365622de8ded9 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -85,7 +85,7 @@ Example | File | Description
 `contributors` | [`2d/contributors.rs`](./2d/contributors.rs) | Displays each contributor as a bouncy bevy-ball!
 `many_sprites` | [`2d/many_sprites.rs`](./2d/many_sprites.rs) | Displays many sprites in a grid arragement! Used for performance testing.
 `mesh` | [`2d/mesh.rs`](./2d/mesh.rs) | Renders a custom mesh
-`pipelined_image_atlas` | [`2d/pipelined_image_atlas.rs`](./2d/pipelined_image_atlas) | Generates a image atlas (sprite sheet) from individual images.
+`pipelined_image_atlas` | [`2d/pipelined_image_atlas.rs`](./2d/pipelined_image_atlas.rs) | Generates a image atlas (sprite sheet) from individual images.
 `sprite` | [`2d/sprite.rs`](./2d/sprite.rs) | Renders a sprite
 `sprite_sheet` | [`2d/sprite_sheet.rs`](./2d/sprite_sheet.rs) | Renders an animated sprite
 `text2d` | [`2d/text2d.rs`](./2d/text2d.rs) | Generates text in 2d
diff --git a/examples/shader/custom_shader_pipelined.rs b/examples/shader/custom_shader_pipelined.rs
index eecdd2c43cb7d..4739528eb028a 100644
--- a/examples/shader/custom_shader_pipelined.rs
+++ b/examples/shader/custom_shader_pipelined.rs
@@ -12,6 +12,7 @@ use bevy::{
     render2::{
         camera::PerspectiveCameraBundle,
         color::Color,
+        image::BevyDefault,
         mesh::{shape, Mesh},
         render_asset::{PrepareAssetError, RenderAsset, RenderAssetPlugin, RenderAssets},
         render_component::ExtractComponentPlugin,
@@ -21,7 +22,6 @@ use bevy::{
         render_resource::*,
         renderer::RenderDevice,
         shader::Shader,
-        image::BevyDefault,
         view::ExtractedView,
         RenderApp, RenderStage,
     },
diff --git a/pipelined/bevy_gltf2/src/loader.rs b/pipelined/bevy_gltf2/src/loader.rs
index c1f7118423a57..30246540ce2f4 100644
--- a/pipelined/bevy_gltf2/src/loader.rs
+++ b/pipelined/bevy_gltf2/src/loader.rs
@@ -12,8 +12,8 @@ use bevy_render2::{
         Camera, CameraPlugin, CameraProjection, OrthographicProjection, PerspectiveProjection,
     },
     color::Color,
+    image::{Image, ImageError, ImageType},
     mesh::{Indices, Mesh, VertexAttributeValues},
-    image::{Image, ImageType, ImageError},
 };
 use bevy_scene::Scene;
 use bevy_transform::{
diff --git a/pipelined/bevy_pbr2/src/render/mod.rs b/pipelined/bevy_pbr2/src/render/mod.rs
index b5dfc07c859be..7b920b9c3bb38 100644
--- a/pipelined/bevy_pbr2/src/render/mod.rs
+++ b/pipelined/bevy_pbr2/src/render/mod.rs
@@ -11,6 +11,7 @@ use bevy_ecs::{
 };
 use bevy_math::Mat4;
 use bevy_render2::{
+    image::{BevyDefault, GpuImage, Image, TextureFormatPixelInfo},
     mesh::Mesh,
     render_asset::RenderAssets,
     render_component::{ComponentUniforms, DynamicUniformIndex},
@@ -18,7 +19,6 @@ use bevy_render2::{
     render_resource::*,
     renderer::{RenderDevice, RenderQueue},
     shader::Shader,
-    image::{BevyDefault, GpuImage, Image, TextureFormatPixelInfo},
     view::{ExtractedView, ViewUniformOffset, ViewUniforms},
 };
 use bevy_transform::components::GlobalTransform;
diff --git a/pipelined/bevy_render2/src/image/image_loader.rs b/pipelined/bevy_render2/src/image/image_loader.rs
index 499687c586345..228c7e28f4651 100644
--- a/pipelined/bevy_render2/src/image/image_loader.rs
+++ b/pipelined/bevy_render2/src/image/image_loader.rs
@@ -3,7 +3,7 @@ use bevy_asset::{AssetLoader, LoadContext, LoadedAsset};
 use bevy_utils::BoxedFuture;
 use thiserror::Error;
 
-use crate::image::{Image, ImageType, ImageError};
+use crate::image::{Image, ImageError, ImageType};
 
 /// Loader for images that can be read by the `image` crate.
 #[derive(Clone, Default)]
@@ -38,7 +38,6 @@ impl AssetLoader for ImageLoader {
     }
 }
 
-
 /// An error that occurs when loading a texture from a file
 #[derive(Error, Debug)]
 pub struct ImageFileError {
diff --git a/pipelined/bevy_render2/src/view/window.rs b/pipelined/bevy_render2/src/view/window.rs
index 29d4de82d7882..9844aa8ae82f6 100644
--- a/pipelined/bevy_render2/src/view/window.rs
+++ b/pipelined/bevy_render2/src/view/window.rs
@@ -1,7 +1,7 @@
 use crate::{
+    image::BevyDefault,
     render_resource::TextureView,
     renderer::{RenderDevice, RenderInstance},
-    image::BevyDefault,
     RenderApp, RenderStage, RenderWorld,
 };
 use bevy_app::{App, Plugin};