diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1a6af20..d3e2498 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.3.0 - 2024-08-26
+
+### Added
+
+- Add support for 3D sprites
+
 ## 0.2.0 - 2024-07-06
 
 ### Added
diff --git a/Cargo.toml b/Cargo.toml
index c0fe4d5..2ef330a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_spritesheet_animation"
-version = "0.2.0"
+version = "0.3.0"
 description = "A Bevy plugin for animating sprites"
 repository = "https://github.com/merwaaan/bevy_spritesheet_animation"
 readme="README.md"
@@ -14,7 +14,7 @@ exclude = [
 ]
 
 [dependencies]
-bevy = { version = "0.14.0", default-features = false, features = ["bevy_sprite"] }
+bevy = { version = "0.14.0", default-features = false, features = ["bevy_pbr", "bevy_sprite"] }
 itertools = "0.12.1"
 visibility = "0.1.0"
 
@@ -24,6 +24,9 @@ bevy = { version = "0.14.0", default-features = true }
 criterion = "0.5.1"
 rand = "0.8.5"
 
+[profile.test]
+inherits = "release"
+
 [features]
 # Enable this feature so that the tests/doctests get access to some private constructors.
 #
diff --git a/README.md b/README.md
index 8fc0ad3..74fe92c 100644
--- a/README.md
+++ b/README.md
@@ -9,6 +9,7 @@ bevy_spritesheet_animation is a [Bevy](https://bevyengine.org/) plugin for anima
 
 # Features
 
+- Animate 2D and [3D sprites](#3d-sprites)! 🎉
 - A single Bevy [component](https://docs.rs/bevy_spritesheet_animation/latest/bevy_spritesheet_animation/component/struct.SpritesheetAnimation.html) to add to your entities to play animations.
 - Tunable parameters: [duration](https://docs.rs/bevy_spritesheet_animation/latest/bevy_spritesheet_animation/animation/enum.AnimationDuration.html), [repetitions](https://docs.rs/bevy_spritesheet_animation/latest/bevy_spritesheet_animation/animation/enum.AnimationRepeat.html), [direction](https://docs.rs/bevy_spritesheet_animation/latest/bevy_spritesheet_animation/animation/enum.AnimationDirection.html), [easing](https://docs.rs/bevy_spritesheet_animation/latest/bevy_spritesheet_animation/easing/enum.Easing.html).
 - [Composable animations](https://docs.rs/bevy_spritesheet_animation/latest/bevy_spritesheet_animation/animation/struct.Animation.html) from multiple clips.
@@ -58,7 +59,7 @@ fn setup(
         // See the `composition` example for more details.
     });
 
-    // Spawn a sprite using Bevy's built-in SpriteSheetBundle
+    // Spawn a sprite using Bevy's built-in SpriteBundle
 
     let texture = assets.load("character.png");
 
@@ -71,12 +72,12 @@ fn setup(
     ));
 
     commands.spawn((
-        SpriteSheetBundle {
+        SpriteBundle {
             texture,
-            atlas: TextureAtlas {
-                layout,
-                ..default()
-            },
+            ..default()
+        },
+        TextureAtlas {
+            layout,
             ..default()
         },
         // Add a SpritesheetAnimation component that references our newly created animation
@@ -178,7 +179,7 @@ fn spawn_enemies(mut commands: Commands, mut library: ResMut<SpritesheetLibrary>
         let animation_id = library.new_animation(|animation| { /* ... */ });
 
         commands.spawn((
-            SpriteSheetBundle { /* .... */ },
+            SpriteBundle { /* .... */ },
             SpritesheetAnimation::from_id(animation_id),
         ));
     }
@@ -206,8 +207,8 @@ fn create_animation(mut library: ResMut<SpritesheetLibrary>) {
     //
     // #[derive(Resource)]
     // struct GameAnimations {
-    //     enemy_running: Option<AnimationId>,
-    //     enemy_firing: Option<AnimationId>,
+    //     enemy_running: AnimationId,
+    //     enemy_firing: AnimationId,
     //     ... and so on ...
     // }
 
@@ -221,7 +222,7 @@ fn spawn_enemies(mut commands: Commands, library: Res<SpritesheetLibrary>) {
     if let Some(animation_id) = libray.animation_with_name("enemy running") {
         for _ in 0..100 {
             commands.spawn((
-                SpriteSheetBundle { /* .... */ },
+                SpriteBundle { /* .... */ },
                 SpritesheetAnimation::from_id(animation_id),
             ));
         }
@@ -229,18 +230,44 @@ fn spawn_enemies(mut commands: Commands, library: Res<SpritesheetLibrary>) {
 }
 ```
 
+## 3D sprites
+
+![A dozen of 3D sprites moving in 3D space](https://github.com/merwaaan/bevy_spritesheet_animation/raw/main/example3d.gif)
+
+This crate also makes it easy to integrate 3D sprites into your games, which is not supported by Bevy out of the box.
+
+[Sprite3DBundle](https://docs.rs/bevy_spritesheet_animation/latest/bevy_spritesheet_animation/components/sprite3d/struct.Sprite3DBundle.html) contains all the necesary components to enable 3D sprites. Use [Sprite3DBuilder](https://docs.rs/bevy_spritesheet_animation/latest/bevy_spritesheet_animation/components/sprite3d/struct.Sprite3DBuilder.html) to easily create one of those.
+
+Animating a 3D sprite is the same as animating 2D sprites: simply attach a [SpritesheetAnimation](https://docs.rs/bevy_spritesheet_animation/latest/bevy_spritesheet_animation/component/struct.SpritesheetAnimation.html) component to your entity.
+
+```rust
+fn spawn_character(mut commands: Commands, mut library: ResMut<SpritesheetLibrary>) {
+
+    let animation_id = library.new_animation(|animation| { /* ... */ });
+
+    commands.spawn((
+        Sprite3DBuilder::from_image(texture.clone())
+            .with_atlas(atlas_layout_handle)
+            .with_anchor(Anchor::BottomRight)
+            .build(),
+        SpritesheetAnimation::from_id(animation_id)
+    ));
+}
+```
+
 # More examples
 
 For more examples, browse the [examples/](examples) directory.
 
 | Example                                | Description                                                              |
 | -------------------------------------- | ------------------------------------------------------------------------ |
-| [basic](examples/basic.rs)             | Minimal example showing how to create an animated sprite                 |
-| [composition](examples/composition.rs) | Advanced example showing how to create an animation with multiple stages |
-| [parameters](examples/parameters.rs)   | Shows the effect of each parameter                                       |
+| [basic](examples/basic.rs)             | Shows how to create an animated sprite                                   |
+| [3d](examples/3d.rs)                   | Shows how to create 3D sprites                                           |
+| [composition](examples/composition.rs) | Shows how to create an animation with multiple stages                    |
+| [parameters](examples/parameters.rs)   | Shows the effect of each animation parameter                             |
 | [character](examples/character.rs)     | Shows how to create a controllable character with multiple animations    |
 | [events](examples/events.rs)           | Shows how to react to animations reaching points of interest with events |
-| [stress](examples/stress.rs)           | A stress test with thousands of animated sprites                         |
+| [stress](examples/stress.rs)           | Stress test with thousands of animated sprites                           |
 
 # Compatibility
 
diff --git a/example3d.gif b/example3d.gif
new file mode 100644
index 0000000..4a9a1a7
Binary files /dev/null and b/example3d.gif differ
diff --git a/examples/3d.rs b/examples/3d.rs
new file mode 100644
index 0000000..b5c1d77
--- /dev/null
+++ b/examples/3d.rs
@@ -0,0 +1,181 @@
+// This example illustrates how to create 3D sprites.
+
+#[path = "./common/mod.rs"]
+pub mod common;
+
+use bevy::{prelude::*, sprite::Anchor};
+use bevy_spritesheet_animation::prelude::*;
+use rand::{seq::SliceRandom, Rng};
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins.set(ImagePlugin::default_nearest()))
+        .add_plugins(SpritesheetAnimationPlugin)
+        .add_systems(Startup, setup)
+        .add_systems(Update, (update_on_keypress, orbit, draw_gizmos))
+        .run();
+}
+
+fn setup(
+    mut commands: Commands,
+    mut library: ResMut<SpritesheetLibrary>,
+    mut atlas_layouts: ResMut<Assets<TextureAtlasLayout>>,
+    assets: Res<AssetServer>,
+) {
+    commands.spawn(Camera3dBundle {
+        transform: Transform::from_xyz(0.0, 0.0, 4000.0),
+        ..default()
+    });
+
+    // Create an animation
+
+    let clip_id = library.new_clip(|clip| {
+        clip.push_frame_indices(Spritesheet::new(8, 8).row(3));
+    });
+
+    let animation_id = library.new_animation(|animation| {
+        animation.add_stage(clip_id.into());
+    });
+
+    // Create an image and an atlas layout like you would for any Bevy sprite
+
+    let texture = assets.load("character.png");
+
+    let atlas_layout_handle = atlas_layouts.add(TextureAtlasLayout::from_grid(
+        UVec2::new(96, 96),
+        8,
+        8,
+        None,
+        None,
+    ));
+
+    // Spawn 3D sprites
+
+    // Orbiting sprites with various parameters
+
+    let sprite_builders = [
+        Sprite3DBuilder::from_image(texture.clone()),
+        Sprite3DBuilder::from_image(texture.clone()).with_flip(true, false),
+        Sprite3DBuilder::from_image(texture.clone()).with_flip(false, true),
+        Sprite3DBuilder::from_image(texture.clone()).with_flip(true, true),
+        Sprite3DBuilder::from_image(texture.clone()).with_anchor(Anchor::BottomLeft),
+        Sprite3DBuilder::from_image(texture.clone()).with_anchor(Anchor::BottomCenter),
+        Sprite3DBuilder::from_image(texture.clone()).with_anchor(Anchor::BottomRight),
+        Sprite3DBuilder::from_image(texture.clone()).with_anchor(Anchor::CenterLeft),
+        Sprite3DBuilder::from_image(texture.clone()).with_anchor(Anchor::Center),
+        Sprite3DBuilder::from_image(texture.clone()).with_anchor(Anchor::CenterRight),
+        Sprite3DBuilder::from_image(texture.clone()).with_anchor(Anchor::TopLeft),
+        Sprite3DBuilder::from_image(texture.clone()).with_anchor(Anchor::TopCenter),
+        Sprite3DBuilder::from_image(texture.clone()).with_anchor(Anchor::TopRight),
+        Sprite3DBuilder::from_image(texture.clone()).with_custom_size(Vec2::new(100.0, 400.0)),
+    ];
+
+    for (i, builder) in sprite_builders.iter().enumerate() {
+        commands.spawn((
+            builder
+                .clone()
+                .with_atlas(atlas_layout_handle.clone())
+                .build(),
+            SpritesheetAnimation::from_id(animation_id),
+            Orbit {
+                start_angle: i as f32 * std::f32::consts::TAU / sprite_builders.len() as f32,
+            },
+        ));
+    }
+
+    // Non-animated sprite in the center
+
+    commands.spawn(
+        Sprite3DBuilder::from_image(texture.clone())
+            .with_atlas(atlas_layout_handle.clone())
+            .with_color(Color::linear_rgb(1.0, 0.0, 0.0))
+            .build(),
+    );
+
+    // Text
+
+    commands.spawn(TextBundle::from_section(
+        "C: random colors\nX: flip on X\nY: flip on Y\nA: random anchors\nS: random sizes\nR: reset",
+        TextStyle {
+            font_size: 30.0,
+            ..default()
+        },
+    ));
+}
+
+fn update_on_keypress(keyboard: Res<ButtonInput<KeyCode>>, mut sprites: Query<&mut Sprite3D>) {
+    let mut rng = rand::thread_rng();
+
+    for mut sprite in &mut sprites {
+        // Random color
+
+        if keyboard.just_pressed(KeyCode::KeyC) {
+            sprite.color = Color::linear_rgb(rng.gen(), rng.gen(), rng.gen());
+        }
+
+        // Flip
+
+        if keyboard.just_pressed(KeyCode::KeyX) {
+            sprite.flip_x = !sprite.flip_x;
+        }
+
+        if keyboard.just_pressed(KeyCode::KeyY) {
+            sprite.flip_y = !sprite.flip_y;
+        }
+
+        // Random anchors
+
+        if keyboard.just_pressed(KeyCode::KeyA) {
+            static ANCHORS: [Anchor; 9] = [
+                Anchor::BottomLeft,
+                Anchor::BottomCenter,
+                Anchor::BottomRight,
+                Anchor::CenterLeft,
+                Anchor::Center,
+                Anchor::CenterRight,
+                Anchor::TopLeft,
+                Anchor::TopCenter,
+                Anchor::TopRight,
+            ];
+
+            sprite.anchor = ANCHORS.choose(&mut rng).unwrap().clone();
+        }
+
+        // Random size
+
+        if keyboard.just_pressed(KeyCode::KeyS) {
+            sprite.custom_size = Some(Vec2::new(
+                rng.gen_range(100.0..1000.0),
+                rng.gen_range(100.0..1000.0),
+            ));
+        }
+
+        // Reset
+
+        if keyboard.just_pressed(KeyCode::KeyR) {
+            sprite.color = Color::WHITE;
+            sprite.flip_x = false;
+            sprite.flip_y = false;
+            sprite.custom_size = None;
+            sprite.anchor = Anchor::default();
+        }
+    }
+}
+
+#[derive(Component)]
+struct Orbit {
+    start_angle: f32,
+}
+
+fn orbit(time: Res<Time>, mut query: Query<(&Orbit, &mut Transform)>) {
+    for (orbit, mut transform) in &mut query {
+        transform.translation.x = (orbit.start_angle + time.elapsed_seconds()).cos() * 1500.0;
+        transform.translation.z = (orbit.start_angle + time.elapsed_seconds()).sin() * 1500.0;
+    }
+}
+
+fn draw_gizmos(mut gizmos: Gizmos, sprites: Query<&Transform, With<Sprite3D>>) {
+    for &transform in &sprites {
+        gizmos.axes(transform, 100.0);
+    }
+}
diff --git a/examples/basic.rs b/examples/basic.rs
index 3dc100b..1a45fee 100644
--- a/examples/basic.rs
+++ b/examples/basic.rs
@@ -73,7 +73,7 @@ fn spawn_sprite(
     let animation_id = library.animation_with_name("walk");
 
     if let Some(id) = animation_id {
-        // Spawn a sprite with Bevy's built-in SpriteSheetBundle
+        // Spawn a sprite with Bevy's built-in SpriteBundle
 
         commands.spawn((
             SpriteBundle {
diff --git a/examples/common/mod.rs b/examples/common/mod.rs
index 7dc99a4..7aa8599 100644
--- a/examples/common/mod.rs
+++ b/examples/common/mod.rs
@@ -4,8 +4,8 @@ use rand::Rng;
 const DEFAULT_WINDOW_WIDTH: f32 = 1280.0;
 const DEFAULT_WINDOW_HEIGHT: f32 = 720.0;
 
-/// Returns the position of the nth item in a grid
-pub fn grid_position(columns: u32, rows: u32, n: u32) -> Vec3 {
+/// Returns the screen-space position of the nth item in a grid
+pub fn grid_position(columns: u32, rows: u32, n: usize) -> Vec3 {
     const MARGIN: f32 = 100.0;
 
     let width = DEFAULT_WINDOW_WIDTH - MARGIN * 2.0;
@@ -14,8 +14,8 @@ pub fn grid_position(columns: u32, rows: u32, n: u32) -> Vec3 {
     let xgap = width / columns.saturating_sub(1) as f32;
     let ygap = height / rows.saturating_sub(1) as f32;
 
-    let x = (n % columns) as f32;
-    let y = (n / columns) as f32;
+    let x = (n as u32 % columns) as f32;
+    let y = (n as u32 / columns) as f32;
 
     Vec3::new(
         x * xgap - width / 2.0,
diff --git a/examples/composition.rs b/examples/composition.rs
index 5950b55..be99d5e 100644
--- a/examples/composition.rs
+++ b/examples/composition.rs
@@ -61,7 +61,7 @@ fn setup(
             .set_default_repeat(1);
     });
 
-    let anim_id = library.new_animation(|anim| {
+    let animation_id = library.new_animation(|anim| {
         anim.add_stage(idle_clip_id.into())
             .add_stage(run_clip_id.into())
             .add_stage(shoot_clip_id.into())
@@ -80,7 +80,7 @@ fn setup(
             layout,
             ..default()
         },
-        SpritesheetAnimation::from_id(anim_id),
+        SpritesheetAnimation::from_id(animation_id),
     ));
 }
 
diff --git a/examples/parameters.rs b/examples/parameters.rs
index 5112c0d..2954297 100644
--- a/examples/parameters.rs
+++ b/examples/parameters.rs
@@ -104,7 +104,7 @@ fn setup(
             .spawn((
                 SpriteBundle {
                     texture: texture.clone(),
-                    transform: Transform::from_translation(grid_position(6, 6, index as u32)),
+                    transform: Transform::from_translation(grid_position(6, 6, index)),
                     ..default()
                 },
                 TextureAtlas {
diff --git a/src/animator.rs b/src/animator.rs
index 1e7b806..cee1d3e 100644
--- a/src/animator.rs
+++ b/src/animator.rs
@@ -12,8 +12,9 @@ use bevy::{
 use std::{collections::HashMap, sync::Arc};
 
 use crate::{
-    animation::AnimationId, component::SpritesheetAnimation, events::AnimationEvent,
-    library::SpritesheetLibrary, systems::ActualTime,
+    animation::AnimationId, components::spritesheet_animation::SpritesheetAnimation,
+    events::AnimationEvent, library::SpritesheetLibrary,
+    systems::spritesheet_animation::ActualTime,
 };
 
 use self::{
diff --git a/src/animator/cache.rs b/src/animator/cache.rs
index 5f22665..59c1358 100644
--- a/src/animator/cache.rs
+++ b/src/animator/cache.rs
@@ -366,7 +366,6 @@ impl AnimationCache {
 
                     if let Some(stage_index) = previous_cycle_stage_index {
                         // At this point, we can safely access [0] as empty cycles have been filtered out
-                        // TODO ???
 
                         cycle[0].events.push(AnimationFrameEvent::ClipCycleEnd {
                             stage_index,
diff --git a/src/components.rs b/src/components.rs
new file mode 100644
index 0000000..2a00f89
--- /dev/null
+++ b/src/components.rs
@@ -0,0 +1,2 @@
+pub mod sprite3d;
+pub mod spritesheet_animation;
diff --git a/src/components/sprite3d.rs b/src/components/sprite3d.rs
new file mode 100644
index 0000000..c2082a9
--- /dev/null
+++ b/src/components/sprite3d.rs
@@ -0,0 +1,170 @@
+use bevy::{
+    asset::Handle,
+    color::Color,
+    ecs::{bundle::Bundle, component::Component},
+    math::{Rect, Vec2},
+    render::{
+        texture::Image,
+        view::{InheritedVisibility, ViewVisibility, Visibility},
+    },
+    sprite::{Anchor, TextureAtlas, TextureAtlasLayout},
+    transform::components::{GlobalTransform, Transform},
+};
+
+/// Specifies the rendering properties of a 3D sprite.
+///
+/// This contains similar fields as Bevy's [Sprite](bevy::sprite::Sprite).
+///
+/// This is commonly used as a component within [Sprite3DBundle].
+#[derive(Component)]
+pub struct Sprite3D {
+    /// A color to tint the sprite with.
+    ///
+    /// The default color is white, which does not tint the sprite.
+    pub color: Color,
+
+    /// Flips the sprite horizontally.
+    pub flip_x: bool,
+
+    /// Flips the sprite vertically.
+    pub flip_y: bool,
+
+    /// The size of the sprite.
+    ///
+    /// If undefined, the dimensions of the sprite's image will be used.
+    pub custom_size: Option<Vec2>,
+
+    /// The position of the sprite's origin
+    pub anchor: Anchor,
+}
+
+impl Default for Sprite3D {
+    fn default() -> Self {
+        Sprite3D {
+            color: Color::WHITE,
+            flip_x: false,
+            flip_y: false,
+            custom_size: None,
+            anchor: Anchor::Center,
+        }
+    }
+}
+
+/// A Bundle of components for drawing a 3D sprite.
+///
+/// This contains similar fields as Bevy's [Sprite](bevy::sprite::SpriteBundle).
+#[derive(Bundle, Default)]
+pub struct Sprite3DBundle {
+    pub sprite: Sprite3D,
+    pub transform: Transform,
+    pub global_transform: GlobalTransform,
+    pub texture: Handle<Image>,
+    pub atlas: TextureAtlas,
+    pub visibility: Visibility,
+    pub inherited_visibility: InheritedVisibility,
+    pub view_visibility: ViewVisibility,
+}
+
+/// A builder to easily instantiate [Sprite3DBundle]s
+///
+/// # Example
+///
+/// ```
+/// # use bevy::{prelude::*, sprite::Anchor};
+/// # use bevy_spritesheet_animation::prelude::*;
+/// # fn f(mut commands: Commands, texture: Handle<Image>, atlas_layout: Handle<TextureAtlasLayout>) {
+/// commands.spawn(
+///     Sprite3DBuilder::from_image(texture.clone())
+///         .with_atlas(atlas_layout)
+///         .with_anchor(Anchor::BottomRight)
+///         .build()
+/// );
+/// # }
+/// ```
+#[derive(Clone)]
+pub struct Sprite3DBuilder {
+    sprite_color: Color,
+    sprite_flip_x: bool,
+    sprite_flip_y: bool,
+    sprite_custom_size: Option<Vec2>,
+    sprite_rect: Option<Rect>,
+    sprite_anchor: Anchor,
+
+    texture: Handle<Image>,
+    atlas: Option<TextureAtlas>,
+    transform: Option<Transform>,
+}
+
+impl Sprite3DBuilder {
+    pub fn from_image(texture: Handle<Image>) -> Self {
+        Self {
+            texture,
+            sprite_color: Color::WHITE,
+            sprite_flip_x: false,
+            sprite_flip_y: false,
+            sprite_custom_size: None,
+            sprite_rect: None,
+            sprite_anchor: Anchor::default(),
+            atlas: None,
+            transform: None,
+        }
+    }
+
+    pub fn with_color(mut self, color: impl Into<Color>) -> Self {
+        self.sprite_color = color.into();
+        self
+    }
+
+    pub fn with_flip(mut self, x: bool, y: bool) -> Self {
+        self.sprite_flip_x = x;
+        self.sprite_flip_y = y;
+        self
+    }
+
+    pub fn with_custom_size(mut self, size: impl Into<Vec2>) -> Self {
+        self.sprite_custom_size = Some(size.into());
+        self
+    }
+
+    pub fn with_rect(mut self, rect: impl Into<Rect>) -> Self {
+        self.sprite_rect = Some(rect.into());
+        self
+    }
+
+    pub fn with_anchor(mut self, anchor: impl Into<Anchor>) -> Self {
+        self.sprite_anchor = anchor.into();
+        self
+    }
+
+    pub fn with_atlas(mut self, handle: Handle<TextureAtlasLayout>) -> Self {
+        self.atlas = Some(TextureAtlas {
+            layout: handle,
+            index: 0,
+        });
+        self
+    }
+
+    pub fn with_transform(mut self, transform: Transform) -> Self {
+        self.transform = Some(transform);
+        self
+    }
+
+    pub fn build(self) -> Sprite3DBundle {
+        Sprite3DBundle {
+            sprite: Sprite3D {
+                color: self.sprite_color,
+                flip_x: self.sprite_flip_x,
+                flip_y: self.sprite_flip_y,
+                custom_size: self.sprite_custom_size,
+                anchor: self.sprite_anchor,
+            },
+            texture: self.texture,
+            atlas: self.atlas.unwrap_or_default(),
+            transform: self.transform.unwrap_or_default(),
+            global_transform: GlobalTransform::default(),
+            visibility: Visibility::default(),
+            inherited_visibility: InheritedVisibility::default(),
+            view_visibility: ViewVisibility::default(),
+        }
+    }
+}
diff --git a/src/component.rs b/src/components/spritesheet_animation.rs
similarity index 94%
rename from src/component.rs
rename to src/components/spritesheet_animation.rs
index 8ec00be..55cf294 100644
--- a/src/component.rs
+++ b/src/components/spritesheet_animation.rs
@@ -34,12 +34,12 @@ use crate::animation::AnimationId;
 ///     # let layout = layouts.add(TextureAtlasLayout::new_empty(UVec2::ONE));
 ///
 ///     commands.spawn((
-///         SpriteSheetBundle {
+///         SpriteBundle {
 ///             texture: texture.clone(),
-///             atlas: TextureAtlas {
-///                 layout: layout.clone(),
-///                 ..default()
-///             },
+///             ..default()
+///         },
+///         TextureAtlas {
+///             layout: layout.clone(),
 ///             ..default()
 ///         },
 ///         SpritesheetAnimation::from_id(animation_id),
diff --git a/src/lib.rs b/src/lib.rs
index 01c4d11..e78b012 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -2,6 +2,7 @@
 //!
 //!# Features
 //!
+//! - Animate 2D and [3D sprites](crate::prelude::Sprite3DBundle)! 🎉
 //! - A single Bevy [component](crate::prelude::SpritesheetAnimation) to add to your entities to play animations.
 //! - Tunable parameters: [duration](crate::prelude::AnimationDuration), [repetitions](crate::prelude::AnimationRepeat), [direction](crate::prelude::AnimationDirection), [easing](crate::prelude::Easing).
 //! - [Composable animations](crate::prelude::Animation) from multiple clips.
@@ -55,7 +56,7 @@
 //!         // See the `composition` example for more details.
 //!     });
 //!
-//!     // Spawn a sprite using Bevy's built-in SpriteSheetBundle
+//!     // Spawn a sprite using Bevy's built-in SpriteBundle
 //!
 //!     let texture = assets.load("character.png");
 //!
@@ -68,12 +69,12 @@
 //!     ));
 //!
 //!     commands.spawn((
-//!         SpriteSheetBundle {
+//!         SpriteBundle {
 //!             texture,
-//!             atlas: TextureAtlas {
-//!                 layout,
-//!                 ..default()
-//!             },
+//!             ..default()
+//!         },
+//!         TextureAtlas {
+//!             layout,
 //!             ..default()
 //!         },
 //!         // Add a SpritesheetAnimation component that references our newly created animation
@@ -86,7 +87,7 @@
 
 pub mod animation;
 pub mod clip;
-pub mod component;
+pub mod components;
 pub mod easing;
 pub mod events;
 pub mod library;
@@ -103,7 +104,10 @@ pub mod prelude {
             Animation, AnimationDirection, AnimationDuration, AnimationId, AnimationRepeat,
         },
         clip::{AnimationClip, AnimationClipId},
-        component::SpritesheetAnimation,
+        components::{
+            sprite3d::{Sprite3D, Sprite3DBuilder, Sprite3DBundle},
+            spritesheet_animation::SpritesheetAnimation,
+        },
         easing::{Easing, EasingVariety},
         events::{AnimationEvent, AnimationMarkerId},
         library::SpritesheetLibrary,
diff --git a/src/library.rs b/src/library.rs
index 8d7f808..21d2984 100644
--- a/src/library.rs
+++ b/src/library.rs
@@ -219,14 +219,14 @@ impl SpritesheetLibrary {
     ///     // ... Load a texture and create an atlas layout for the sprite ...
     ///
     ///     commands.spawn((
-    ///         SpriteSheetBundle {
+    ///         SpriteBundle {
     ///             texture: texture.clone(),
-    ///             atlas: TextureAtlas {
-    ///                 layout: layout.clone(),
-    ///                 ..default()
-    ///             },
     ///             ..default()
     ///         },
+    ///         TextureAtlas {
+    ///             layout: layout.clone(),
+    ///            ..default()
+    ///         },
     ///         SpritesheetAnimation::from_id(animation_id)
     ///     ));
     /// }
diff --git a/src/plugin.rs b/src/plugin.rs
index f9896a9..ce4ae47 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -1,8 +1,10 @@
 use bevy::app::{App, Plugin, PostUpdate};
 
 use crate::{
-    animator::SpritesheetAnimator, events::AnimationEvent, library::SpritesheetLibrary,
-    systems::play_animations,
+    animator::SpritesheetAnimator,
+    events::AnimationEvent,
+    library::SpritesheetLibrary,
+    systems::{sprite3d, spritesheet_animation},
 };
 
 /// The spritesheet animation plugin to add to Bevy apps.
@@ -43,9 +45,26 @@ pub struct SpritesheetAnimationPlugin;
 
 impl Plugin for SpritesheetAnimationPlugin {
     fn build(&self, app: &mut App) {
-        app.insert_resource(SpritesheetLibrary::new())
+        app
+            // The spritesheet library, for creating clips, animations and markers
+            .insert_resource(SpritesheetLibrary::new())
+            // The animator responsible for running animations
             .insert_resource(SpritesheetAnimator::new())
+            // Atlas UVs for 3D sprites
+            .insert_resource(sprite3d::TextureAtlasLayoutUvs::default())
+            // Animations events
             .add_event::<AnimationEvent>()
-            .add_systems(PostUpdate, play_animations);
+            // Systems
+            .add_systems(
+                PostUpdate,
+                (
+                    // Main animation system
+                    spritesheet_animation::play_animations,
+                    // 3D sprite systems
+                    sprite3d::setup_rendering,
+                    sprite3d::sync_sprites_with_component,
+                    sprite3d::sync_sprites_with_atlas,
+                ),
+            );
     }
 }
diff --git a/src/systems.rs b/src/systems.rs
index f22a2d0..2a00f89 100644
--- a/src/systems.rs
+++ b/src/systems.rs
@@ -1,38 +1,2 @@
-use bevy::{
-    ecs::{
-        entity::Entity,
-        event::EventWriter,
-        system::{Query, Res, ResMut},
-    },
-    sprite::TextureAtlas,
-    time::Time,
-};
-
-#[cfg(feature = "integration-tests")]
-use bevy::time::Real;
-
-// In unit tests, we use a TimeUpdateStrategy to control how time advances.
-//
-// However, it currently doesn't seem to work with Time, only with Time<Real>.
-// So we use different time types in release and test builds for now.
-//
-// https://github.com/bevyengine/bevy/issues/11127
-#[cfg(feature = "integration-tests")]
-pub(crate) type ActualTime = Time<Real>;
-#[cfg(not(feature = "integration-tests"))]
-pub(crate) type ActualTime = Time;
-
-use crate::{
-    animator::SpritesheetAnimator, component::SpritesheetAnimation, events::AnimationEvent,
-    library::SpritesheetLibrary,
-};
-
-pub(crate) fn play_animations(
-    time: Res<ActualTime>,
-    library: Res<SpritesheetLibrary>,
-    mut animator: ResMut<SpritesheetAnimator>,
-    mut events: EventWriter<AnimationEvent>,
-    mut query: Query<(Entity, &mut SpritesheetAnimation, &mut TextureAtlas)>,
-) {
-    animator.update(&time, &library, &mut events, &mut query);
-}
+pub mod sprite3d;
+pub mod spritesheet_animation;
diff --git a/src/systems/sprite3d.rs b/src/systems/sprite3d.rs
new file mode 100644
index 0000000..2e5beee
--- /dev/null
+++ b/src/systems/sprite3d.rs
@@ -0,0 +1,230 @@
+use std::collections::HashMap;
+
+use bevy::{
+    asset::{Assets, Handle},
+    ecs::{
+        entity::Entity,
+        query::Changed,
+        system::{Commands, Query, Res, ResMut, Resource},
+    },
+    math::UVec2,
+    pbr::StandardMaterial,
+    prelude::*,
+    render::{
+        alpha::AlphaMode,
+        mesh::{Mesh, PrimitiveTopology},
+        render_asset::RenderAssetUsages,
+        texture::Image,
+    },
+    sprite::{TextureAtlas, TextureAtlasLayout},
+};
+
+use crate::components::sprite3d::Sprite3D;
+
+pub(crate) type QuadUvs = Vec<[f32; 2]>;
+
+/// A resource that stores the UV coordinates for all the atlas layouts used by 3D sprites.
+#[derive(Resource, Default)]
+pub(crate) struct TextureAtlasLayoutUvs {
+    data: HashMap<Handle<TextureAtlasLayout>, Vec<QuadUvs>>,
+}
+
+/// Setups 3D sprites for rendering by creating the 3D geometry and materials to display them.
+pub(crate) fn setup_rendering(
+    mut commands: Commands,
+    atlases: Res<Assets<TextureAtlasLayout>>,
+    mut atlases_uvs: ResMut<TextureAtlasLayoutUvs>,
+    images: Res<Assets<Image>>,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+    sprites: Query<
+        (
+            Entity,
+            &Sprite3D,
+            &TextureAtlas,
+            &Handle<Image>,
+            Option<&Handle<Mesh>>,
+            Option<&Handle<StandardMaterial>>,
+        ),
+        Or<(Without<Handle<Mesh>>, Without<Handle<StandardMaterial>>)>,
+    >,
+) {
+    for (entity, sprite, atlas, image_handle, maybe_mesh_handle, maybe_material_handle) in &sprites
+    {
+        // We have to wait for the image to be loaded to access its dimensions
+
+        if let Some(texture) = images.get(image_handle) {
+            // Generate UVs for this sprite's layout if needed
+
+            let uvs = atlases.get(&atlas.layout).and_then(|layout| {
+                let atlas_uvs = atlases_uvs
+                    .data
+                    .entry(atlas.layout.clone_weak())
+                    .or_insert_with(|| create_uvs_from_atlas_layout(layout));
+
+                atlas_uvs.get(atlas.index)
+            });
+
+            // Add a mesh to the entity if it does not have one yet
+
+            if maybe_mesh_handle.is_none() {
+                let mut mesh = Mesh::new(
+                    PrimitiveTopology::TriangleStrip,
+                    RenderAssetUsages::default(),
+                );
+
+                update_mesh_vertices(&mut mesh, sprite, texture);
+                update_mesh_uvs(&mut mesh, sprite, uvs);
+
+                commands.entity(entity).insert(meshes.add(mesh));
+            }
+
+            // Add a material to the entity if it does not have one yet
+
+            if maybe_material_handle.is_none() {
+                let material = StandardMaterial {
+                    base_color_texture: Some(image_handle.clone()),
+                    base_color: sprite.color,
+                    unlit: true,
+                    alpha_mode: AlphaMode::Blend,
+                    ..default()
+                };
+
+                commands.entity(entity).insert(materials.add(material));
+            }
+        }
+    }
+}
+
+/// Synchronizes 3D sprites with the data from their Sprite3D component.
+pub(crate) fn sync_sprites_with_component(
+    atlases_uvs: Res<TextureAtlasLayoutUvs>,
+    images: Res<Assets<Image>>,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+    sprites: Query<
+        (
+            &Sprite3D,
+            &TextureAtlas,
+            &Handle<Image>,
+            &Handle<Mesh>,
+            &Handle<StandardMaterial>,
+        ),
+        Changed<Sprite3D>,
+    >,
+) {
+    for (sprite, atlas, image_handle, mesh_handle, material_handle) in &sprites {
+        // Update the mesh
+
+        if let Some(mesh) = meshes.get_mut(mesh_handle) {
+            // We need to wait for the image to be loaded to get its size
+
+            if let Some(texture) = images.get(image_handle) {
+                update_mesh_vertices(mesh, sprite, texture);
+
+                if let Some(layout) = atlases_uvs.data.get(&atlas.layout) {
+                    update_mesh_uvs(mesh, sprite, layout.get(atlas.index));
+                }
+            }
+        }
+
+        // Update the material
+
+        if let Some(material) = materials.get_mut(material_handle) {
+            material.base_color = sprite.color;
+        }
+    }
+}
+
+/// Synchronizes the UV coordinates of the sprites' meshes when the index of their texture atlas changes.
+pub(crate) fn sync_sprites_with_atlas(
+    atlases_uvs: Res<TextureAtlasLayoutUvs>,
+    mut meshes: ResMut<Assets<Mesh>>,
+    sprites: Query<(&Sprite3D, &TextureAtlas, &mut Handle<Mesh>), Changed<TextureAtlas>>,
+) {
+    for (sprite, atlas, mesh_handle) in &sprites {
+        if let Some(mesh) = meshes.get_mut(mesh_handle.id()) {
+            if let Some(layout) = atlases_uvs.data.get(&atlas.layout) {
+                update_mesh_uvs(mesh, sprite, layout.get(atlas.index));
+            }
+        }
+    }
+}
+
+/// Generates UV coordinates from a texture atlas layout.
+fn create_uvs_from_atlas_layout(atlas: &TextureAtlasLayout) -> Vec<QuadUvs> {
+    let atlas_layout_size = atlas.size.as_vec2();
+
+    atlas
+        .textures
+        .iter()
+        .map(|texture| {
+            vec![
+                (UVec2::new(texture.min.x, texture.max.y).as_vec2() / atlas_layout_size).to_array(),
+                (UVec2::new(texture.max.x, texture.max.y).as_vec2() / atlas_layout_size).to_array(),
+                (UVec2::new(texture.min.x, texture.min.y).as_vec2() / atlas_layout_size).to_array(),
+                (UVec2::new(texture.max.x, texture.min.y).as_vec2() / atlas_layout_size).to_array(),
+            ]
+        })
+        .collect()
+}
+
+fn update_mesh_vertices(mesh: &mut Mesh, sprite: &Sprite3D, texture: &Image) {
+    let size = match sprite.custom_size {
+        Some(size) => size,
+        None => texture.size_f32(),
+    };
+
+    let half_size = size / 2.0;
+
+    let anchor_offset = sprite.anchor.as_vec() * size;
+
+    mesh.insert_attribute(
+        Mesh::ATTRIBUTE_POSITION,
+        vec![
+            [
+                -half_size.x - anchor_offset.x,
+                -half_size.y - anchor_offset.y,
+                0.0,
+            ],
+            [
+                half_size.x - anchor_offset.x,
+                -half_size.y - anchor_offset.y,
+                0.0,
+            ],
+            [
+                -half_size.x - anchor_offset.x,
+                half_size.y - anchor_offset.y,
+                0.0,
+            ],
+            [
+                half_size.x - anchor_offset.x,
+                half_size.y - anchor_offset.y,
+                0.0,
+            ],
+        ],
+    );
+}
+
+fn update_mesh_uvs(mesh: &mut Mesh, sprite: &Sprite3D, maybe_uvs: Option<&QuadUvs>) {
+    static DEFAULT_UVS: [[f32; 2]; 4] = [[0.0, 1.0], [1.0, 1.0], [0.0, 0.0], [1.0, 0.0]];
+
+    let mut uvs = match maybe_uvs {
+        Some(uvs) => uvs.clone(),
+        None => DEFAULT_UVS.to_vec(),
+    };
+
+    // Flipping
+
+    if sprite.flip_x {
+        uvs.swap(0, 1);
+        uvs.swap(2, 3);
+    }
+
+    if sprite.flip_y {
+        uvs.swap(0, 2);
+        uvs.swap(1, 3);
+    }
+
+    mesh.insert_attribute(Mesh::ATTRIBUTE_UV_0, uvs);
+}
diff --git a/src/systems/spritesheet_animation.rs b/src/systems/spritesheet_animation.rs
new file mode 100644
index 0000000..2ceafc0
--- /dev/null
+++ b/src/systems/spritesheet_animation.rs
@@ -0,0 +1,38 @@
+use bevy::{
+    ecs::{
+        entity::Entity,
+        event::EventWriter,
+        system::{Query, Res, ResMut},
+    },
+    sprite::TextureAtlas,
+    time::Time,
+};
+
+#[cfg(feature = "integration-tests")]
+use bevy::time::Real;
+
+// In unit tests, we use a TimeUpdateStrategy to control how time advances.
+//
+// However, it currently doesn't seem to work with Time, only with Time<Real>.
+// So we use different time types in release and test builds for now.
+//
+// https://github.com/bevyengine/bevy/issues/11127
+#[cfg(feature = "integration-tests")]
+pub(crate) type ActualTime = Time<Real>;
+#[cfg(not(feature = "integration-tests"))]
+pub(crate) type ActualTime = Time;
+
+use crate::{
+    animator::SpritesheetAnimator, components::spritesheet_animation::SpritesheetAnimation,
+    events::AnimationEvent, library::SpritesheetLibrary,
+};
+
+pub(crate) fn play_animations(
+    time: Res<ActualTime>,
+    library: Res<SpritesheetLibrary>,
+    mut animator: ResMut<SpritesheetAnimator>,
+    mut events: EventWriter<AnimationEvent>,
+    mut query: Query<(Entity, &mut SpritesheetAnimation, &mut TextureAtlas)>,
+) {
+    animator.update(&time, &library, &mut events, &mut query);
+}