Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.tomblack.ca/llms.txt

Use this file to discover all available pages before exploring further.

The PixelateCaptureManager component is the primary interface for driving a capture. Every option listed here appears in its Inspector under the Capture Options section. You set these values before triggering a capture, and some (like Current Frame) can be adjusted in real-time for live preview.

​
Scene references

​
Target
GameObject
default:"None"
The 3D model you want to convert into a sprite sheet. Assign the root GameObject of your character, prop, or effect here. Pixelate will render this object (and all its children) during capture.
​
Capture Camera
Camera
default:"None"
The orthographic camera Pixelate uses to render each frame. This camera should face your model from the desired angle, with its orthographic size tuned to frame the model tightly. Keep this camera separate from your scene’s main camera.

​
Output dimensions

​
Cell Size
Vector2Int
default:"(128, 128)"
The width and height of each individual frame in the output sprite sheet, in pixels. All frames are placed into a square grid atlas, so the final texture dimensions equal cellSize * gridCellCount. See Atlas size limits below.
​
Pivot
Vector2
default:"(0.5, 0.5)"
The pivot point applied to each generated sprite, expressed as a normalized coordinate.
ValuePosition
(0, 0)Bottom-left
(0.5, 0.5)Center
(1, 1)Top-right
Match this to the pivot you intend to use in your Sprite Renderer so the sprite aligns correctly with your collider and attachment points.

​
Texture options

​
Create Normal Map
bool
default:"true"
When enabled, Pixelate renders a second pass and saves a normal map texture alongside the albedo sprite sheet. Normal maps allow your 2D sprites to receive real-time directional lighting. Disable this if you only need an unlit flat sprite.
​
Pixelated
bool
default:"true"
Controls the texture filter mode applied to the output.
  • true — uses FilterMode.Point for sharp, crisp pixel art with no blurring between pixels.
  • false — uses FilterMode.Bilinear for smoother edges, suitable for high-resolution sprite sheets that are not intended to look pixelated.

​
Export

​
Sprite Save Path
string
default:"Assets/"
The project-relative folder where Pixelate writes the output PNG files. The path must start with Assets/ and the folder must already exist. Output files are named using the following convention:
{TargetName}_{ClipName}.png
{TargetName}_{ClipName}_NormalMap.png
For example, capturing a Knight GameObject with a Run clip produces Knight_Run.png and Knight_Run_NormalMap.png.
Pixelate does not create the destination folder automatically. If the path does not exist, the export will fail silently. Create the folder in your Project window before capturing.

​
Animation

​
Frames Per Second
int
default:"20"
The number of frames Pixelate samples per second of animation. Higher values produce smoother playback at the cost of a larger atlas texture and longer capture time. Lower values reduce file size but may introduce visible stepping in fast animations.
​
Current Frame
int
default:"0"
The frame index currently shown in the Scene view for live preview. Drag the slider in the Inspector to scrub through the animation and check framing, clipping, or pivot alignment before committing to a full capture.
​
Source Clips
AnimationClip[]
default:"None"
The animation clips to capture. Each clip in this array becomes a separate sprite sheet. Pixelate captures them in order and exports one PNG (and optionally one normal map PNG) per clip.

​
Particles

​
Random Seed
bool
default:"false"
When capturing particle systems, enable this to use a random seed for each capture run. Disable it to use the fixed value in Seed, which produces identical output on every capture — useful for reproducible builds or version-controlled assets.
​
Seed
uint
default:"1234"
The fixed seed value used for particle captures when Random Seed is disabled. Change this value to get a different but still reproducible particle layout.

​
Palette

​
Auto Palette Color Count
int
default:"16"
The maximum number of colors Pixelate includes in the auto-generated palette for this capture. Lower values produce a more restricted, retro-style palette. Higher values preserve more color detail but reduce the stylized pixel-art appearance.

​
Atlas size limits

Pixelate arranges all frames into a square grid and writes a single atlas PNG. The atlas must not exceed 4096×4096 pixels. The atlas dimensions are calculated as: 
numFrames      = (int)(animClip.length * framesPerSecond)
gridCellCount  = ceil(sqrt(numFrames))
atlasSize      = cellSize * gridCellCount
Example — within limits:
  • cellSize = (128, 128), framesPerSecond = 30, animClip.length = 2s
  • numFrames = 60 → gridCellCount = ceil(√60) = 8 → atlasSize = 1024×1024 ✓
Example — exceeds limit:
  • cellSize = (256, 256), framesPerSecond = 60, animClip.length = 4s
  • numFrames = 240 → gridCellCount = ceil(√240) = 16 → atlasSize = 4096×4096 — right at the boundary.
  • Adding even one more frame would overflow.
If you hit the atlas size limit, reduce framesPerSecond, shorten your clips, or decrease cellSize. For long animations, consider splitting the clip into shorter segments.