The texture-atlas skill plans 2D atlas grouping, padding, naming, and manifest generation for game projects. It runs with zero dependencies and targets any engine, making it a portable step in the art import pipeline.
What the texture-atlas Skill Does
Funplay Skills ships 12 skills total. One of those is texture-atlas, which sits between slicing your raw frames and verifying them for UI import. According to the documented art import pipeline, the standard flow is: raw PSD export, then sprite-sheet to slice frames, then texture-atlas to plan the atlas layout, then ui-slicing-checklist to verify nine-slice, pivot, and padding, then finally engine integration via something like unity-prefab-workflow or cocos-component-workflow.
The skill does not pack pixels itself. It plans. That distinction matters. You feed it information about your sprites — dimensions, groupings, naming conventions, padding requirements — and it produces a manifest describing how those sprites should be arranged into one or more atlas textures. A separate packing tool or engine importer reads that manifest and does the actual pixel work.
This approach keeps the skill engine-agnostic. Unity 2022.3 or later, Godot 4.2 or later, and Cocos Creator 3.8 or later can all consume the output, because the output is a plan, not an engine-specific asset file.
Read the full documentation at https://gamebooom.ai/en/blog/.
Why Atlas Planning Matters
Without a plan, you end up with atlases that waste texture memory. Sprites bleed into each other at their edges when sampled. Mipmaps sample neighboring pixels from unrelated sprites. Naming collisions cause silent overwrites in your build pipeline. Groups that should share an atlas end up scattered across multiple textures, increasing draw calls.
The texture-atlas skill forces you to answer these questions before you pack:
- Which sprites belong on the same atlas?
- How much padding does each sprite need?
- What naming convention prevents collisions?
- How should the manifest describe regions for downstream tools?
Answering those questions upfront costs minutes. Fixing them after artists have exported hundreds of frames costs days.
Where texture-atlas Fits in the Pipeline
Here is the full art import pipeline from the knowledge base:
- Raw PSD export from your art tool.
sprite-sheetslices a sprite sheet into single-frame PNGs (requiressharp).texture-atlasplans the atlas grouping, padding, naming, and manifest.ui-slicing-checklistreviews UI sprite exports for nine-slice compliance, pivot points, padding, and import readiness.- An engine-specific skill like
unity-prefab-workfloworcocos-component-workflowhandles integration.
Step three is where texture-atlas lives. It consumes the sliced frames from step two and produces the plan that steps four and five consume.
Walkthrough: Planning a Character Atlas
Say you have a player character with idle, walk, and attack animations. Each animation has been sliced into individual PNGs by sprite-sheet. You now have 30 frames sitting in a directory. Here is how you plan the atlas.
Step 1: Define Your Groups
Decide which sprites share an atlas. A common approach is one atlas per character or one atlas per screen. For this example, all 30 player frames go into a single atlas because they always render together.
Step 2: Specify Padding
Padding prevents texture bleeding. For standard 2D games, 2 pixels of padding on every side is a safe minimum. For games using mipmaps, increase that to 4 or 8 pixels. Document your choice so the skill can include it in the manifest.
Step 3: Define Naming
Choose a naming convention that encodes useful information. A pattern like {character}_{animation}_{frame} gives you player_idle_00, player_idle_01, through player_attack_09.
Step 4: Generate the Manifest
The skill produces a manifest describing every region. Here is an example of what the output looks like:
{
"atlas": "player_atlas",
"textureSize": { "width": 512, "height": 512 },
"padding": 2,
"regions": [
{
"name": "player_idle_00",
"group": "idle",
"frame": 0,
"rect": { "x": 2, "y": 2, "width": 64, "height": 64 }
},
{
"name": "player_idle_01",
"group": "idle",
"frame": 1,
"rect": { "x": 70, "y": 2, "width": 64, "height": 64 }
},
{
"name": "player_walk_00",
"group": "walk",
"frame": 0,
"rect": { "x": 138, "y": 2, "width": 64, "height": 64 }
}
]
}
Each region entry includes the sprite name, its animation group, frame index, and the pixel rectangle inside the atlas. Downstream tools read this manifest to build engine-compatible assets.
Step 5: Validate with ui-slicing-checklist
Before you hand the atlas off to your engine, run the ui-slicing-checklist skill. This skill checks that your nine-slice borders are consistent, pivot points are set, and padding values match what you planned. It catches problems the packing step would otherwise silently ignore.
Step 6: Engine Integration
Pass the manifest and the packed texture to your engine workflow. If you are using Unity with Unity MCP (79 tools available), the unity-prefab-workflow skill guides import settings. For Godot with Godot MCP (105 tools), or Cocos Creator with Cocos MCP (67 tools), use the corresponding component workflow skill. The MCP servers listen on 127.0.0.1 port 8765.
Cross-Skill Workflow Example
The texture-atlas skill also appears in combination with other skills. Here is a common cross-skill workflow for art assets:
# Step 1: Slice sprite sheets into individual frames
# Uses the sprite-sheet skill with sharp dependency
# Step 2: Plan the atlas layout
# Uses the texture-atlas skill with no dependencies
# Step 3: Review UI slicing readiness
# Uses the ui-slicing-checklist skill
# Step 4: Engine integration
# Uses /engine-workflow to choose the right engine-facing skill
The /engine-workflow command automatically selects the correct engine-facing skill based on your project setup, so you do not accidentally run a Unity workflow on a Godot project.
Gotchas and Limitations
The texture-atlas skill plans atlases. It does not pack pixels. If you need actual texture packing, you still need a tool like TexturePacker, a custom script using sharp, or your engine's built-in packer. The skill's output is a manifest, not a PNG.
The skill has no dependencies listed, which is accurate for the planning phase. But the broader pipeline depends on sharp for the sprite-sheet slicing step that runs before it. If you skip slicing and try to plan an atlas from an unsheeted PSD, the skill cannot help you.
The skill is engine-agnostic by design. That means it does not generate .spriteatlas files for Unity or .tres resources for Godot. You or your engine workflow skill must convert the manifest into engine-specific formats.
Do not use this skill for 3D texture atlases, texture channels, or material packing. It targets 2D sprite atlas planning only. For normal map generation, use the normal-map skill instead. For audio conversion, use audio-format-convert.
If your project has fewer than 10 sprites total, an atlas may not be worth the overhead. Direct sprite references are simpler and the performance difference is negligible. Atlases show their value at scale — dozens or hundreds of sprites that share render batches.
The skill also does not handle runtime atlas generation. If your game builds atlases dynamically at startup, you need a different tool. This skill is for the offline content pipeline.
Related Skills in Funplay Skills
The texture-atlas skill is one of 12 skills in the Funplay Skills collection. Sibling skills worth knowing:
sprite-sheet— slices sprite sheets into individual frames, requiressharp.normal-map— generates tangent-space normal maps from diffuse textures.ui-slicing-checklist— validates UI exports for nine-slice, pivot, and padding.game-audio-polish— reviews music and SFX for loudness, loops, and layering.
Browse all skills and workflows at the primary repository: https://github.com/FunplayAI/funplay-skills. For engine-specific integration, see the Unity MCP repository at https://github.com/FunplayAI/unity-mcp, the Godot MCP repository at https://github.com/FunplayAI/godot-mcp, and the Cocos MCP repository at https://github.com/FunplayAI/cocos-mcp.
Run the texture-atlas skill on your next sprite set and catch layout problems before they reach your engine.