cocos creator sprite sheet maker

Cocos Sprite Sheet Maker

Build Cocos Creator sprite sheets: an aligned PNG atlas and a manifest.json of SpriteFrame regions and fps. Import frames without manual slicing.

live sprite · 8f @ 12 fps
▶ Shroom Patrol · 8F
Pack workbenchFree · alpha kept · SpriteFrame regions

Pack a Cocos-ready atlas

PNG frames into an aligned atlas plus manifest.json for Cocos.

  • Exact SpriteFrame regions from the manifest
  • Per-state fps and loop flags
  • Transparent PNG for any Cocos scene

Drop files here to jump straight into the workbench

Accepts PNG · WebP · JPG · GIF · MP4 · MOV · WebM · no signup required

Instant Demo — Try Without UploadingShroom · 11 frames · 12 FPS
Shroom live animation preview
Packed Alpha Sheet (4312×460 px · 392×460 cell)
Shroom packed sprite sheet
Open the pack workbenchAccepts PNG · WebP · JPG · GIF · MP4 · MOV · WebM

Step by step

How it works..

Step 011
RAWframes/*.png

Add frames

Drop PNG frames; files are ordered by name.

Step 022
SAFE PADDING + RECT

Set the cell

Choose a cell size and padding for a shared baseline.

Step 033
sheet.pngmanifest.json

Export for Cocos

Download the PNG atlas and manifest.json with regions.

Supported Inputs

MP4, MOV, WebM (≤15s 1080p) · Animated GIF · PNG, WebP, JPG (≤240 frames)

Native Engine Exports

PNG Atlas + manifest.json · Godot 4 .tres · Phaser 3 JSON · Unity .meta · Aseprite · FNF XML

Anti-Jitter Alignment

Bottom-Baseline Foot Lock · BBox Center Anchor · Chroma Key & Edge De-Spill

100% Client-Side Privacy

Runs locally in your browser via Canvas 2D — zero server upload, no signup, no watermark.

Cocos Creator 3.x SpriteFrame & AnimationClip Loader

Download free sample PNG + manifest.json →

Build SpriteFrame regions from manifest.json rectangles and attach a looping AnimationClip in Cocos Creator 3.8+:

CocosManifestAnimator.tstypescript
import { _decorator, Component, ImageAsset, Rect, Sprite, SpriteFrame, Texture2D } from "cc";
const { ccclass, property } = _decorator;

@ccclass("CocosManifestAnimator")
export class CocosManifestAnimator extends Component {
  @property(ImageAsset) atlasImage: ImageAsset = null!;
  private frames: SpriteFrame[] = [];
  private elapsed = 0;
  private fps = 12;

   buildFromRects(rects: { x: number; y: number; w: number; h: number }[], fps = 12) {
    const tex = new Texture2D();
    tex.image = this.atlasImage;
    this.fps = fps;
    this.frames = rects.map((r) => {
      const sf = new SpriteFrame();
      sf.texture = tex;
      sf.rect = new Rect(r.x, r.y, r.w, r.h);
      return sf;
    });
  }

  update(dt: number) {
    if (!this.frames.length) return;
    this.elapsed += dt;
    const idx = Math.floor(this.elapsed * this.fps) % this.frames.length;
    this.getComponent(Sprite)!.spriteFrame = this.frames[idx];
  }
}
Works with Cocos Creator 3.x 2D Sprite components without requiring external TexturePacker .plist files.

What a Cocos Sprite Sheet Needs

Cocos Creator draws sprites from a texture plus a SpriteFrame that defines a region. An animation switches those frames over time, so the region data is what actually determines what appears on screen, not the image alone. If the region rectangles are wrong, frames crop or overlap and the art tears at the seams.

The sheet must match the region data exactly, or the animation looks broken in ways that are hard to diagnose late. A manifest lists each frame as an absolute rectangle, and you create a SpriteFrame per rectangle and add them to a SpriteAtlas. Every region then becomes precise and repeatable across a whole team.

The manifest also records fps and a loop flag, which map to an AnimationClip's sample rate and wrap mode. Timing stays with the asset instead of living in a settings panel someone forgets, and the engine plays what you previewed rather than its own default pace.

Because regions are data, an editor script can rebuild the SpriteFrames whenever the sheet changes. That keeps the project reproducible and the art and engine data in step, so a new character set reuses the same import routine and no one hand-slices regions under time pressure.

Importing the Atlas into Cocos

Import the PNG into your assets and let Cocos read it as a texture. You can auto-slice by grid, or create SpriteFrames from the manifest rectangles for exact regions that never drift. Create an AnimationClip that animates the spriteFrame property, and set the sample rate from the manifest fps.

Set wrap mode to loop where the flag says so, so a walk repeats and an attack does not. For pixel art, disable filtering and keep the texture unpackable if you need exact pixels, because smooth filtering blurs small sprites and softens the retro feel the art depends on. Test the clip on the real node scale, not only at 1x.

A sprite that looks fine at 1x can shimmer when scaled by a non-integer factor, so check the resolution the game will actually ship at. Keep the manifest next to the PNG in assets, because treating it as project data makes the import reproducible across machines and teammates and it survives a version control checkout.

If you automate the import, read the JSON once and build the SpriteFrames in an editor plugin. The same script then handles every new sheet without manual steps, which pays off across a whole cast of characters and keeps the pipeline consistent as the project grows.

Why a Manifest Beats a Uniform Grid

A uniform grid assumes every frame shares one size, and a wider attack pose then clips at the cell edge. The detail is simply gone from the packaged asset, and the loss is invisible until that specific move plays in a build. Exact rectangles pack tight and stay correct, so each SpriteFrame uses the true bounding box.

The manifest also documents timing. Sample rate and loop live in data instead of animation settings you must remember to update per clip, which reduces states that feel subtly different. When art changes you re-pack and re-read the rectangles, so the atlas and its descriptor stay in sync and silent cropping regressions are rare.

It also keeps character states consistent. One shared layout means idle, walk, and attack all align to the same baseline automatically, so transitions feel like the same character rather than a set of unrelated sprites. That consistency is worth more than any single frame being perfect.

Because the rectangles are plain data, the same sheet can drive a Cocos SpriteAtlas, a custom loader, or a tool-side previewer. That portability keeps the asset useful beyond one runtime, and it means a pipeline change never forces a re-export of the art from scratch.

Workflow Tips for Cocos Teams

Keep one cell size across a character's states so nodes and anchors stay aligned between idle, walk, and attack, and a state change never shifts the character on screen. Set the AnimationClip sample rate to the manifest fps and compare it to the browser preview before you wire it into gameplay.

Packing and preview are free in the browser, and only AI generation spends credits with failed runs refunded automatically, so trying a new character set is inexpensive. Anchor characters at the feet so they sit on the ground plane, which matters even more in a side-scrolling scene where the floor line never moves.

Re-export from the originals after edits, because hand-editing the atlas desynchronizes it from the manifest and is overwritten on the next pack. Keep the manifest and the PNG together in version control so a fresh checkout rebuilds the same SpriteFrames without guesswork.

Document the cell size and pivot the project expects, and note them beside the manifest. A shared reference stops a new artist from exporting at a slightly different scale, which is the kind of mismatch that only shows up after integration and costs a day to track down.

Before you ship, render one frame at the real in-game scale and zoom in on the edges. A sprite that looks clean at one hundred percent can show a sliver of the neighbouring frame when the camera scales it up. If you see a line, raise the padding and re-pack rather than editing the atlas by hand, because a manual fix is overwritten on the next export. Keep the atlas size a power of two where the engine prefers it, so sampling stays predictable across devices. Because Cocos may pack textures further at build time, confirm that engine-side packing does not reintroduce a seam, or disable it for the sheet. A short check at ship resolution saves a bug report from a player on a phone.

FAQ

Frequently asked questions.

Is this an official Cocos tool?+
No. spritesgen is independent and not affiliated with Cocos or Cocos Creator. It exports a PNG and JSON that you import yourself.
Does Cocos read manifest.json directly?+
Not natively, but you can write a small editor script that creates SpriteFrames from the rectangles. Auto-slice by grid is the manual alternative.
Is packing free?+
Yes. Pack, slice, and export are free in the browser with no account. Only optional AI generation uses credits.
How do I keep pixels sharp in Cocos?+
Disable texture filtering for the sprite and avoid non-integer scaling. Export from spritesgen with a transparent alpha channel.
Do my frames leave my machine?+
No. Packing and export run locally. Frames go to a server only if you explicitly request an AI step.
Can I control loop and speed?+
Yes. The manifest records fps and a loop flag per state. Map those to the AnimationClip sample rate and wrap mode.
Can I use the sheets commercially?+
You keep the rights to your own art. For AI output, confirm your use complies with the applicable license before shipping.