sprite-sheet.png (2048×2048)
├─ player_idle_01 (0, 0, 64, 64)
├─ player_run_01  (64, 0, 64, 64)
├─ enemy_walk_01  (128, 0, 32, 32)
└─ ... (metadata in JSON/XML)

use macroquad::prelude::*;

#[derive(Clone, Copy)]
struct SpriteFrame {
    x: f32, y: f32, w: f32, h: f32,
}

impl SpriteFrame {
    fn as_rect(&self) -> Rect {
        Rect::new(self.x, self.y, self.w, self.h)
    }
}

#[macroquad::main("Sprite Demo")]
async fn main() {
    let texture = load_texture("assets/spritesheet.png").await.unwrap();
    texture.set_filter(FilterMode::Nearest); // Pixel art
    
    let frames = vec![
        SpriteFrame { x: 0.0, y: 0.0, w: 64.0, h: 64.0 },
        SpriteFrame { x: 64.0, y: 0.0, w: 64.0, h: 64.0 },
    ];
    
    let mut frame_idx = 0;
    let mut timer = 0.0;
    
    loop {
        clear_background(BLACK);
        
        // Animation logic
        timer += get_frame_time();
        if timer > 0.1 {
            frame_idx = (frame_idx + 1) % frames.len();
            timer = 0.0;
        }
        
        // Draw specific frame
        let frame = frames[frame_idx];
        draw_texture_ex(
            &texture,
            100.0, 100.0, // destination
            WHITE,
            DrawTextureParams {
                source: Some(frame.as_rect()),
                dest_size: Some(vec2(128.0, 128.0)), // scale 2x
                ..Default::default()
            },
        );
        
        next_frame().await
    }
}

use bevy::prelude::*;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins.set(ImagePlugin::default_nearest())) // pixel art
        .add_systems(Startup, setup)
        .add_systems(Update, animate_sprite)
        .run();
}

fn setup(
    mut commands: Commands,
    asset_server: Res<AssetServer>,
    mut texture_atlases: ResMut<Assets<TextureAtlasLayout>>,
) {
    commands.spawn(Camera2dBundle::default());
    
    let texture = asset_server.load("sprites/character.png");
    
    // Define atlas layout (8 columns, 4 rows, each 64×64)
    let layout = TextureAtlasLayout::from_grid(
        UVec2::new(64, 64),
        8, 4,
        Some(UVec2::new(2, 2)), // padding
        Some(UVec2::new(4, 4)), // offset
    );
    let atlas_layout = texture_atlases.add(layout);
    
    // Spawn entity with atlas
    commands.spawn((
        SpriteBundle {
            texture,
            transform: Transform::from_scale(Vec3::splat(2.0)),
            ..default()
        },
        TextureAtlas {
            layout: atlas_layout,
            index: 0,
        },
        AnimationTimer(Timer::from_seconds(0.1, TimerMode::Repeating)),
    ));
}

#[derive(Component)]
struct AnimationTimer(Timer);

fn animate_sprite(
    time: Res<Time>,
    mut query: Query<(&mut AnimationTimer, &mut TextureAtlas)>,
) {
    for (mut timer, mut atlas) in &mut query {
        timer.0.tick(time.delta());
        if timer.0.just_finished() {
            atlas.index = (atlas.index + 1) % 8; // 8 frames loop
        }
    }
}

# res://player.gd
extends AnimatedSprite2D

func _ready():
    # Load sprite frames resource (created in editor)
    sprite_frames = load("res://assets/player_frames.tres")
    animation = "idle"
    play()

# player_frames.tres setup:
# 1. Create SpriteFrames resource
# 2. Add animation "idle"
# 3. Import frames from atlas with "Add Frames from Sprite Sheet"
# 4. Specify H/V frames or custom regions

extends Sprite2D

var atlas_texture: Texture2D
var frames: Array = [
    Rect2(0, 0, 64, 64),
    Rect2(64, 0, 64, 64),
    Rect2(128, 0, 64, 64),
]
var current_frame := 0
var timer := 0.0

func _ready():
    atlas_texture = load("res://assets/spritesheet.png")
    texture = atlas_texture

func _process(delta):
    timer += delta
    if timer > 0.1:
        current_frame = (current_frame + 1) % frames.size()
        region_enabled = true
        region_rect = frames[current_frame]
        timer = 0.0

using UnityEngine;
using UnityEditor;
using System.IO;

public class SpriteSheetExporter : EditorWindow {
    [MenuItem("Tools/Export Sprite Sheet")]
    static void Export() {
        var sprites = Selection.GetFiltered<Sprite>(SelectionMode.Assets);
        if (sprites.Length == 0) return;
        
        var texture = sprites[0].texture;
        var path = EditorUtility.SaveFilePanel("Export", "", "spritesheet.png", "png");
        
        // Copy texture to path
        File.WriteAllBytes(path, texture.EncodeToPNG());
        
        // Export metadata
        var json = "[";
        foreach (var s in sprites) {
            var r = s.textureRect;
            json += $"{{\"name\":\"{s.name}\",\"x\":{r.x},\"y\":{r.y},\"w\":{r.width},\"h\":{r.height}}},";
        }
        json = json.TrimEnd(',') + "]";
        File.WriteAllText(path + ".json", json);
    }
}

1. Create sprites (Aseprite/Photoshop)
2. Export individual PNGs
3. Pack with TexturePacker → atlas.png + atlas.json
4. Load in engine with custom parser or plugin
5. Test on target devices (mobile = critical)