Import Sprite Sheets into Unreal Engine Paper 2D

Import AutoSprite sprite sheets into Unreal Engine 5 with Paper 2D Sprites, Flipbooks, Blueprint, and C++ playback.

This guide covers importing AutoSprite PNG sprite sheets into Unreal Engine 5, extracting a uniform frame grid, creating Paper 2D Flipbooks, and switching animations from Blueprint or C++.

ℹ️

Need to generate the asset first? Start with the Unreal Engine sprite sheet generator, then return here for Paper 2D import and playback setup.

What You Need

An AutoSprite PNG sprite sheet for each animation you want to use
The exported frame width, frame height, columns, and frame count
Unreal Engine 5 with the Paper 2D plugin enabled

AutoSprite's JSON is useful as a frame-size reference, but Unreal does not automatically turn that JSON into Paper 2D assets. The native workflow starts with the PNG texture.

Quick Start

Enable Paper 2D

In Unreal Editor, open Edit → Plugins, search for Paper 2D, enable it, and restart the editor if prompted.

Import the sprite sheet

Create a folder such as Content/Sprites/Player/Run, click Import in the Content Browser, and select the AutoSprite PNG.

Unreal imports the PNG as a Texture asset.

Apply Paper 2D texture settings

Right-click the imported Texture and choose Sprite Actions → Apply Paper 2D Import Settings.

This applies sprite-friendly defaults, including nearest filtering and no mipmaps, which helps keep pixel art crisp.

Extract the frames

Right-click the Texture and choose Sprite Actions → Extract Sprites. Set Sprite Extract Mode to Grid, then enter the frame dimensions from the AutoSprite export:

Cell Width: exported frame width
Cell Height: exported frame height
Num Cells X: number of columns, or 0 for no limit
Num Cells Y: number of rows, or 0 for no limit
Margin X / Y: 0 for a standard AutoSprite sheet
Spacing X / Y: 0 unless your exported sheet includes spacing

Use a zero-padded naming template such as Player_Run_{0} so alphabetical order matches playback order.

Create a Paper Flipbook

Select the extracted Sprite assets in frame order, right-click the selection, and choose Create Flipbook. Rename it using an Unreal-style asset name such as FB_Player_Run.

Open the Flipbook and set Frames Per Second to the playback speed you want. Enable looping for idle, walk, and run; disable it for one-shot actions such as attack, hit, or death.

Play it on a character

Create a PaperCharacter Blueprint or add a Paper Flipbook Component to an Actor. Assign the Flipbook, then use Set Flipbook when gameplay state changes.

Recommended Asset Layout

Keep one AutoSprite animation per Unreal folder and one Flipbook per gameplay state:

Content/Sprites/Player/
├── Idle/
│   ├── T_Player_Idle
│   ├── SPR_Player_Idle_00 ...
│   └── FB_Player_Idle
├── Run/
│   ├── T_Player_Run
│   ├── SPR_Player_Run_00 ...
│   └── FB_Player_Run
└── Attack/
    ├── T_Player_Attack
    ├── SPR_Player_Attack_00 ...
    └── FB_Player_Attack

AutoSprite output	Unreal asset	Recommended use
PNG sprite sheet	Texture	Source grid for extraction
Extracted cells	Paper Sprite assets	Individual animation frames
Ordered frame sequence	Paper Flipbook	Idle, run, attack, and other clips
JSON metadata	Import reference	Cell size, columns, rows, and frame count

Grid Extraction Details

Use Grid extraction for AutoSprite sheets. Auto extraction finds islands of non-transparent pixels and may create different bounds for each pose, which can make the character shift or change size during playback.

✨

Pro Tip:

If the sheet contains unused cells at the end of the grid, extract the full grid and remove those extra Sprite assets before creating the Flipbook. Do not leave blank frames at the end of the animation.

Unreal reads the grid from the top-left, moving left to right before continuing on the next row. This matches AutoSprite's standard frame order.

Creating Flipbooks Reliably

When you select multiple Sprites and choose Create Flipbook, Unreal adds them in alphabetical order. Zero-pad frame numbers so ..._09 sorts before ..._10:

SPR_Player_Run_00
SPR_Player_Run_01
SPR_Player_Run_02
...
SPR_Player_Run_10

Inside the Flipbook Editor:

Set Frames Per Second to control playback speed
Reorder any frame that was extracted incorrectly
Set repeated frame durations when a pose should hold longer
Preview the complete loop before wiring it into gameplay

Blueprint Playback

For a PaperCharacter Blueprint:

Select the inherited Sprite component.
Assign FB_Player_Idle as the default Flipbook.
Read horizontal velocity in the Event Graph.
If speed is greater than zero, call Set Flipbook with FB_Player_Run.
Otherwise call Set Flipbook with FB_Player_Idle.
For an attack, temporarily switch to FB_Player_Attack, disable looping, and return to idle when it finishes.

⚠️

Do not call Set Flipbook every frame with the same asset if it restarts your animation. Compare the current Flipbook with the desired Flipbook and only switch when the gameplay state changes.

If Set Flipbook does not work at runtime, verify that the Flipbook Component's Mobility is set to Movable.

C++ Playback

For a class derived from APaperCharacter, keep the animation change behind a small helper:

#include "PaperFlipbook.h"
#include "PaperFlipbookComponent.h"

void APlayerPaperCharacter::PlayFlipbook(UPaperFlipbook* NextFlipbook)
{
    UPaperFlipbookComponent* SpriteComponent = GetSprite();

    if (!NextFlipbook || !SpriteComponent) return;
    if (SpriteComponent->GetFlipbook() == NextFlipbook) return;

    SpriteComponent->SetFlipbook(NextFlipbook);
    SpriteComponent->PlayFromStart();
}

Use the helper when velocity, input, combat state, or an animation event changes rather than calling it unconditionally every tick.

Pixel Art and Texture Quality

For pixel art, start with Sprite Actions → Apply Paper 2D Import Settings. That preset removes mipmaps and uses nearest filtering.

Also check:

Setting	Recommended starting point
Filter	Nearest
Mip Gen Settings	NoMipmaps
Texture Group	2D Pixels for retro pixel art; UI for smooth modern 2D art
Compression	Preserve alpha and inspect edge quality
Pixels Per Unreal Unit	Keep consistent across every character and animation
Pivot	Bottom-center for grounded characters, or a shared custom pivot

For illustrated or high-resolution sprites, nearest filtering may look too harsh. Use the filtering mode that matches the art style, but keep every animation in the character set consistent.

Directional Animations

Create a separate Flipbook for each direction and motion, for example:

FB_Player_Idle_Down
FB_Player_Idle_Up
FB_Player_Run_Left
FB_Player_Run_Right

Choose the Flipbook from movement direction in Blueprint or C++. For a symmetrical side view, you can reuse one horizontal Flipbook and flip the Sprite Component instead of storing separate left and right art.

Common Issues

Sprite Actions are missing: Enable the Paper 2D plugin and restart Unreal Editor.

The character shifts between frames: The sheet was extracted with Auto instead of a uniform Grid, or the frame pivots differ. Re-extract with the exact cell size and apply one pivot convention to every frame.

Frames play in the wrong order: Rename extracted Sprites with zero-padded numbers, then recreate or manually reorder the Flipbook.

Pixel art looks blurry: Apply Paper 2D Import Settings and verify nearest filtering, no mipmaps, and integer-friendly scaling.

The animation resets constantly: Only call Set Flipbook when the requested Flipbook differs from the current one.

Set Flipbook does nothing: Make sure the component is Movable and the target Flipbook is valid.

The last pose flashes or holds: Remove unused grid cells and transparent tail frames from the Flipbook.

The character floats or sinks: Give every extracted Sprite the same pivot and keep Pixels Per Unreal Unit consistent.

Official Unreal References

Need Help?

Join Discord

Share your sheet dimensions, extracted Sprite names, and a screenshot of the Flipbook timeline, and we'll help verify the import.

Unreal Engine Integration