ScreenshotKit Documentation

Contents

1. Quick Start

2. Workflows

   • Take a single screenshot

   • Capture from multiple cameras (Batch Capture)

   • Render a transparent PNG

   • Record an animated GIF

   • Record an image sequence

   • Render Cryptomatte / AOV passes

   • Customize filenames and output location

3. Runtime API

4. Reference

   • Keyboard shortcuts

   • Cryptomatte / AOV pass list

   • Image formats

   • Resolution presets

   • Menu items

5. Limits & Troubleshooting

6. Support

Quick Start

1. Import the package into your Unity project.

2. Open the window from Tools > ScreenshotKit > Settings Window, or click the ScreenshotKit toolbar overlay in the Scene View.

3. Press Ctrl+Shift+S with the Game View focused — that's your first screenshot, taken from the active camera at the resolution shown in the Capture tab.

4. Files land in Assets/ScreenshotKit/Screenshots by default. Change this under the Settings tab → Save Location.

The window has four tabs:

Workflows

Each workflow follows the same shape: when to use it, the steps, the result, and a few tips.

Take a single screenshot

When to use: You want a high-resolution still from one camera — for marketing, store assets, debugging, or documentation.

Steps:

1. Open the Capture tab.

2. Under Resolution, set width and height (or click a preset like 1080p / 4K / Game View). Optionally raise Size Multiplier (1–8x) for supersampled output.

3. Under Capture Options, toggle Transparent Background if you want an alpha channel, and pick a Capture Layers mask if you want to exclude layers.

4. Click Take Screenshot, or press Ctrl+Shift+S from the Game View, or Ctrl+Shift+Alt+S from the Scene View.

Result: A single image file saved to your Save Location. The filename is built from your filename template (camera name, timestamp, resolution, prefix, suffix — see Customize filenames).

Tips:

• The Game View preset matches your current Game View aspect/resolution.

• Size Multiplier renders at width × multiplier by height × multiplier and writes the supersampled result — useful for crisp 8K stills without changing your scene's display resolution.

• Combined width × height × multiplier² must stay under 64 megapixels (see Limits).

See also: Runtime API — single capture.

Capture from multiple cameras (Batch Capture)

When to use: You have several cameras (turnaround views, vehicle angles, lighting setups, character poses) and you want one shot from each, with consistent naming.

Steps:

1. Open the Capture tab and expand Batch Capture.

2. Click Add All Scene Cameras, or drag specific cameras into the list one at a time. Reorder and remove entries as needed.

3. Optionally tick Override Resolution on individual entries to give a single camera a different size.

4. Adjust Batch Delay under Settings if you need a small pause between captures (0–1 seconds) — useful when post-processing or particle systems need a frame to settle.

5. Click Capture All (N cameras).

Result: One file per camera, each named with that camera's name. If Render mattes with capture is enabled, every enabled matte pass is also rendered for each camera. The summary dialog reports how many shots and matte files were written.

Tips:

• The button label changes to Capture All + Mattes when matte rendering is on, so you can see at a glance whether you're about to write a lot of files.

• Use this for store-asset turnarounds: set up four cameras around your prop, then capture all of them at 4K with one click.

See also: Runtime API — single capture (loop your own Camera[]).

Render a transparent PNG

When to use: You need a screenshot with an alpha channel — for storefront key art, hero shots over an arbitrary background, or compositing into a marketing layout.

Steps:

1. Open the Capture tab.

2. Tick Transparent Background under Capture Options.

3. Pick an Alpha Source — this is where ScreenshotKit gives you three different ways to derive alpha:

4. Choose PNG or TGA under Settings → File Format (JPEG has no alpha).

5. Click Take Screenshot.

Result: A transparent image where the RGB is the lit beauty pass and the alpha is derived from your chosen mode.

Tips:

• Transparent capture disables post-processing in the standard path by default. The Post-Process / Hybrid modes work around this with the dual black-and-white render trick, so you keep your bloom and grading.

• If Cryptomatte alpha isn't available on your render pipeline, Hybrid mode falls back to Post-Process alone and logs a warning.

See also: Runtime API — transparent capture.

Record an animated GIF

When to use: Quick share, social posts, devlog clips, looping previews for store pages.

Steps:

1. Open the Gif tab.

2. Expand Capture Camera and assign the camera to record from (defaults to Camera.main at runtime).

3. Expand GIF Quality and configure:

   • Frame Rate: 5, 10, 15, 30, or 60 fps — or Custom up to 244 fps.

   • Resolution: Full, Half, or Quarter of your base resolution.

   • Max Duration: how long to record, in seconds.

   • Loop: whether the output GIF loops.

   • Color Compression: Low / Medium / High / Ultra — quality vs. file size trade-off.

4. Enter Play Mode. Press Start Recording in the window, play through whatever you want to capture, then press Stop Recording.

5. Alternatively, tick Auto-Record on Play to start recording automatically when you enter Play Mode.

Result: A .gif file saved to your configured GIF output folder. The window shows the estimated file size up front and live recording progress while it captures.

Tips:

• GIF encoding is threaded — capture stays smooth during Play Mode and the encoder finalizes the file after you stop. Larger / longer GIFs take longer to finalize.

• The in-memory frame buffer is capped at 512 MB. If your settings would exceed that, the recorder caps the duration and logs a warning — drop resolution, frame rate, or duration to capture the full take.

• For sharp loops, keep resolution at Half and pick Medium or High compression.

See also: Runtime API — GIF recording.

Record an image sequence

When to use: You want frame-by-frame stills for video editing, frame-perfect compositing, or per-frame mattes.

Steps:

1. Open the Gif tab and expand Sequence Options.

2. Set Frame Rate, Resolution, Max Duration, and a File Prefix.

3. Pick an Image Format: PNG, JPEG, TGA, or EXR. JPEG exposes a quality slider; EXR enables HDR float output.

4. Optionally tick Transparent Background for per-frame alpha, and/or Render Mattes for per-frame Cryptomatte / AOV passes.

5. Enter Play Mode and click Start Recording, then Stop Recording when done.

Result: A folder of frame_000000.ext, frame_000001.ext, … plus one subfolder per enabled matte pass (e.g. ObjectID/, Normals/, MotionVectors/) when Render Mattes is on.

Tips:

• EXR sequences with Output as Float preserve full HDR. Use ZIP or RLE compression under Settings → File Format to control file size.

• The recorder warns before overwriting if the output folder already contains frames.

• Per-frame matte rendering is heavy — if performance matters, capture without mattes and re-render mattes for the frames you actually need.

See also: Runtime API — sequence recording.

Render Cryptomatte / AOV passes

When to use: You're compositing in Nuke, Fusion, After Effects, or Resolve and you want geometry IDs, lighting components, depth, normals, or motion vectors as separate channels.

Steps:

1. Open the Mattes tab.

2. Pick a Cryptomatte Output mode:

3. Pick a Segmentation Mode (Multi-layer EXR mode):

   • By GameObject — every unique GameObject gets its own ID.

   • By Material — every unique material is one ID.

   • By Layer ID — IDs come from Unity's layer bitmask.

4. Enable the passes you want from the three groups:

   • Segmentation: Object ID, Material ID, Layer ID, Alpha

   • Camera & Depth: Depth (Linear), Depth (Raw), Lightmap

   • Lighting Components: Diffuse, Specular, Reflection, Refraction, Emission, Shadow, Ambient Occlusion

   • Data Buffers: Normals, Motion Vectors, World Position, Stencil

5. Either:

   • Click Render Selected Passes to render only the matte passes, or

   • Go back to the Capture tab, tick Render mattes with capture, and take a normal screenshot — every enabled pass is rendered alongside the beauty pass.

Result: One file per enabled pass, named with the pass suffix (e.g. MyCam_ObjectID.exr, MyCam_Normals.png). Multi-layer EXR mode forces .exr for ID passes regardless of the global image format setting.

Tips:

• AOV passes need URP for full fidelity. On the Built-in render pipeline, lighting and data-buffer passes fall back to a standard Diffuse render — you'll get a lit image where you expected normals.

• For compositing, Multi-layer EXR is what you want. Simple RGB24 exists only because the hue-rotated PNGs are readable as thumbnails.

• Depth Linear is normalized 0–1 across the camera's near/far. Depth Raw is the unprocessed Z-buffer.

See also: Runtime API — capture with mattes, Cryptomatte / AOV pass list.

Customize filenames and output location

When to use: You have a naming convention to fit, or your screenshots should land somewhere other than Assets/ScreenshotKit/Screenshots.

Steps:

1. Open the Settings tab.

2. Under Save Location, set Save Path. Toggle Project-Relative Path if the path is inside Assets/. Click Open Folder to verify.

3. Under Filename Format, configure:

   • Prefix / Suffix: literal text prepended / appended to every filename.

   • Include Camera Name — appends the source camera's name.

   • Include Timestamp — appends a timestamp using Timestamp Format (a standard C# DateTime format string; default yyyy-MM-dd_HH-mm-ss).

   • Include Resolution — appends WIDTHxHEIGHT.

4. The Preview shows what a generated filename will look like.

Result: Every capture (screenshots, GIFs, sequences, mattes) uses this template.

Tips:

• All filename parts are sanitized — characters illegal in filenames (:, /, \, etc.) are replaced with underscores, so camera names like Main:Render/Cam are safe.

• Under File Format, the Open Folder After Capture option pops the OS file explorer at the output path after every shot — handy when iterating, distracting in long batches.

Runtime API

For driving captures from your own scripts at runtime — for example, a hotkey in a built game, an in-game photo mode, or an automated capture pass at the end of a scene.

All types live in the DaCruz.ScreenshotKit namespace.

Single capture

using DaCruz.ScreenshotKit;
using UnityEngine;

public class CaptureNow : MonoBehaviour
{
    public Camera sourceCamera;
    public ScreenshotSettings settings;

    public void Capture()
    {
        var result = ScreenshotCapture.Capture(sourceCamera, settings);
        if (result.Success)
            Debug.Log($"Saved to {result.FilePath}");
        else
            Debug.LogError(result.ErrorMessage

using DaCruz.ScreenshotKit;
using UnityEngine;

public class CaptureNow : MonoBehaviour
{
    public Camera sourceCamera;
    public ScreenshotSettings settings;

    public void Capture()
    {
        var result = ScreenshotCapture.Capture(sourceCamera, settings);
        if (result.Success)
            Debug.Log($"Saved to {result.FilePath}");
        else
            Debug.LogError(result.ErrorMessage

using DaCruz.ScreenshotKit;
using UnityEngine;

public class CaptureNow : MonoBehaviour
{
    public Camera sourceCamera;
    public ScreenshotSettings settings;

    public void Capture()
    {
        var result = ScreenshotCapture.Capture(sourceCamera, settings);
        if (result.Success)
            Debug.Log($"Saved to {result.FilePath}");
        else
            Debug.LogError(result.ErrorMessage

ScreenshotCapture.Capture returns a CaptureResult with Success, FilePath, ErrorMessage, and Texture fields. The final resolution is settings.width * settings.sizeMultiplier by settings.height * settings.sizeMultiplier.

Capture with mattes

var result = ScreenshotCapture.CaptureWithMattes(sourceCamera, settings);
if (result.Success)
{
    Debug.Log($"Beauty: {result.FilePath}");
    foreach (var mattePath in result.MatteFilePaths)
        Debug.Log($"Matte: {mattePath}"

var result = ScreenshotCapture.CaptureWithMattes(sourceCamera, settings);
if (result.Success)
{
    Debug.Log($"Beauty: {result.FilePath}");
    foreach (var mattePath in result.MatteFilePaths)
        Debug.Log($"Matte: {mattePath}"

var result = ScreenshotCapture.CaptureWithMattes(sourceCamera, settings);
if (result.Success)
{
    Debug.Log($"Beauty: {result.FilePath}");
    foreach (var mattePath in result.MatteFilePaths)
        Debug.Log($"Matte: {mattePath}"

CaptureWithMattes writes the beauty shot plus every pass enabled on settings (Object ID, Normals, Depth, etc.). MatteFilePaths lists every matte file written.

You can also request individual matte textures directly through CryptomatteCapture:

// Each method returns a Texture2D you can use, save, or upload anywhere
Texture2D normals       = CryptomatteCapture.CaptureNormals(sourceCamera, 1920, 1080);
Texture2D depthLinear   = CryptomatteCapture.CaptureDepthLinear(sourceCamera, 1920, 1080);
Texture2D motionVectors = CryptomatteCapture.CaptureMotionVectors(sourceCamera, 1920, 1080);
Texture2D objectID      = CryptomatteCapture.CaptureObjectID(sourceCamera, 1920, 1080);
// Caller owns the texture — destroy it when done.

// Each method returns a Texture2D you can use, save, or upload anywhere
Texture2D normals       = CryptomatteCapture.CaptureNormals(sourceCamera, 1920, 1080);
Texture2D depthLinear   = CryptomatteCapture.CaptureDepthLinear(sourceCamera, 1920, 1080);
Texture2D motionVectors = CryptomatteCapture.CaptureMotionVectors(sourceCamera, 1920, 1080);
Texture2D objectID      = CryptomatteCapture.CaptureObjectID(sourceCamera, 1920, 1080);
// Caller owns the texture — destroy it when done.

// Each method returns a Texture2D you can use, save, or upload anywhere
Texture2D normals       = CryptomatteCapture.CaptureNormals(sourceCamera, 1920, 1080);
Texture2D depthLinear   = CryptomatteCapture.CaptureDepthLinear(sourceCamera, 1920, 1080);
Texture2D motionVectors = CryptomatteCapture.CaptureMotionVectors(sourceCamera, 1920, 1080);
Texture2D objectID      = CryptomatteCapture.CaptureObjectID(sourceCamera, 1920, 1080);
// Caller owns the texture — destroy it when done.

Transparent capture

var alphaSource = ScreenshotCapture.TransparentAlphaSource.Hybrid;
var result = ScreenshotCapture.CapturePostProcessTransparent(sourceCamera, settings, alphaSource);

// Or with mattes alongside:
var fullResult = ScreenshotCapture.CapturePostProcessTransparentWithMattes(
    sourceCamera, settings, alphaSource

var alphaSource = ScreenshotCapture.TransparentAlphaSource.Hybrid;
var result = ScreenshotCapture.CapturePostProcessTransparent(sourceCamera, settings, alphaSource);

// Or with mattes alongside:
var fullResult = ScreenshotCapture.CapturePostProcessTransparentWithMattes(
    sourceCamera, settings, alphaSource

var alphaSource = ScreenshotCapture.TransparentAlphaSource.Hybrid;
var result = ScreenshotCapture.CapturePostProcessTransparent(sourceCamera, settings, alphaSource);

// Or with mattes alongside:
var fullResult = ScreenshotCapture.CapturePostProcessTransparentWithMattes(
    sourceCamera, settings, alphaSource

TransparentAlphaSource values: CryptomatteOnly, PostProcessOnly, Hybrid. The setting field on ScreenshotSettings is ppAlphaSource if you'd rather pull it from the asset.

Sequence recording

using DaCruz.ScreenshotKit;
using UnityEngine;

public class SequenceController : MonoBehaviour
{
    public Camera cam;

    void StartCapture()
    {
        var seq = new SequenceRecorder.RecordingSettings
        {
            SourceCamera          = cam,
            OutputFolder          = Application.dataPath + "/../Captures/MyShot",
            FilePrefix            = "shot",
            FrameRate             = 30,
            Resolution            = SequenceRecorder.Resolution.Full,
            MaxDuration           = 5f,
            Format                = SequenceRecorder.ImageFormat.PNG,
            TransparentBackground = false,
            RenderMattes          = false,
        };

        SequenceRecorder.Instance.StartRecording(seq);
    }

    void StopCapture()
    {
        SequenceRecorder.Instance.StopRecording();   // finishes pending writes
        // or: SequenceRecorder.Instance.CancelRecording();

using DaCruz.ScreenshotKit;
using UnityEngine;

public class SequenceController : MonoBehaviour
{
    public Camera cam;

    void StartCapture()
    {
        var seq = new SequenceRecorder.RecordingSettings
        {
            SourceCamera          = cam,
            OutputFolder          = Application.dataPath + "/../Captures/MyShot",
            FilePrefix            = "shot",
            FrameRate             = 30,
            Resolution            = SequenceRecorder.Resolution.Full,
            MaxDuration           = 5f,
            Format                = SequenceRecorder.ImageFormat.PNG,
            TransparentBackground = false,
            RenderMattes          = false,
        };

        SequenceRecorder.Instance.StartRecording(seq);
    }

    void StopCapture()
    {
        SequenceRecorder.Instance.StopRecording();   // finishes pending writes
        // or: SequenceRecorder.Instance.CancelRecording();

using DaCruz.ScreenshotKit;
using UnityEngine;

public class SequenceController : MonoBehaviour
{
    public Camera cam;

    void StartCapture()
    {
        var seq = new SequenceRecorder.RecordingSettings
        {
            SourceCamera          = cam,
            OutputFolder          = Application.dataPath + "/../Captures/MyShot",
            FilePrefix            = "shot",
            FrameRate             = 30,
            Resolution            = SequenceRecorder.Resolution.Full,
            MaxDuration           = 5f,
            Format                = SequenceRecorder.ImageFormat.PNG,
            TransparentBackground = false,
            RenderMattes          = false,
        };

        SequenceRecorder.Instance.StartRecording(seq);
    }

    void StopCapture()
    {
        SequenceRecorder.Instance.StopRecording();   // finishes pending writes
        // or: SequenceRecorder.Instance.CancelRecording();

To capture individual frames yourself (no automatic loop), call ScreenshotCapture.CaptureSequenceFrame per frame — it returns a Texture2D you encode and save however you like. CaptureSequenceFrameWithMattes adds matte passes per frame into subfolders.

GIF recording

using DaCruz.ScreenshotKit;
using UnityEngine;

public class GifController : MonoBehaviour
{
    public Camera cam;

    void StartGif()
    {
        var settings = new GifRecorder.RecordingSettings
        {
            SourceCamera     = cam,
            OutputPath       = Application.dataPath + "/../Captures/clip.gif",
            FrameRate        = 15,
            Resolution       = GifRecorder.Resolution.Half,
            MaxDuration      = 8f,
            Loop             = true,
            Quality          = GifEncoder.Quality.Medium,
            UseGlobalPalette = true,
        };

        GifRecorder.Instance.StartRecording(settings);

        GifRecorder.Instance.OnEncodingComplete += path =>
            Debug.Log($"GIF saved to {path}");
        GifRecorder.Instance.OnEncodingFailed += err =>
            Debug.LogError($"GIF failed: {err}");
    }

    void StopGif()
    {
        GifRecorder.Instance.StopRecording();        // starts encoding
        // or: GifRecorder.Instance.CancelRecording();

using DaCruz.ScreenshotKit;
using UnityEngine;

public class GifController : MonoBehaviour
{
    public Camera cam;

    void StartGif()
    {
        var settings = new GifRecorder.RecordingSettings
        {
            SourceCamera     = cam,
            OutputPath       = Application.dataPath + "/../Captures/clip.gif",
            FrameRate        = 15,
            Resolution       = GifRecorder.Resolution.Half,
            MaxDuration      = 8f,
            Loop             = true,
            Quality          = GifEncoder.Quality.Medium,
            UseGlobalPalette = true,
        };

        GifRecorder.Instance.StartRecording(settings);

        GifRecorder.Instance.OnEncodingComplete += path =>
            Debug.Log($"GIF saved to {path}");
        GifRecorder.Instance.OnEncodingFailed += err =>
            Debug.LogError($"GIF failed: {err}");
    }

    void StopGif()
    {
        GifRecorder.Instance.StopRecording();        // starts encoding
        // or: GifRecorder.Instance.CancelRecording();

using DaCruz.ScreenshotKit;
using UnityEngine;

public class GifController : MonoBehaviour
{
    public Camera cam;

    void StartGif()
    {
        var settings = new GifRecorder.RecordingSettings
        {
            SourceCamera     = cam,
            OutputPath       = Application.dataPath + "/../Captures/clip.gif",
            FrameRate        = 15,
            Resolution       = GifRecorder.Resolution.Half,
            MaxDuration      = 8f,
            Loop             = true,
            Quality          = GifEncoder.Quality.Medium,
            UseGlobalPalette = true,
        };

        GifRecorder.Instance.StartRecording(settings);

        GifRecorder.Instance.OnEncodingComplete += path =>
            Debug.Log($"GIF saved to {path}");
        GifRecorder.Instance.OnEncodingFailed += err =>
            Debug.LogError($"GIF failed: {err}");
    }

    void StopGif()
    {
        GifRecorder.Instance.StopRecording();        // starts encoding
        // or: GifRecorder.Instance.CancelRecording();

The recorder runs as a singleton MonoBehaviour that survives scene loads (DontDestroyOnLoad). It exposes State, RecordingTime, FrameCount, EncodingProgress, and LastOutputPath for binding UI; and events OnRecordingStarted, OnRecordingStopped, OnEncodingProgress, OnEncodingComplete, OnEncodingFailed.

GifRecorder and SequenceRecorder both refuse to start outside Play Mode.

Reference

Keyboard shortcuts

Both shortcuts let you toggle Ctrl / Shift / Alt modifiers independently and pick any key.

Cryptomatte / AOV pass list

Image formats

Resolution presets

Built-in presets (editable under Settings → Resolution Presets):

Add your own with + Add, or click Use Current to capture the current width/height as a new preset.

Menu items

Limits & Troubleshooting

64 megapixel cap per capture. Anything beyond this is rejected up front with a clear log message — at 16 bytes per pixel, larger captures will OOM the editor inside the readback. To work around: lower the Size Multiplier, or capture at base resolution and upscale externally. 8K (33 MP) and 4K at ×2 SSAA (33 MP) fit comfortably; 4K at ×4 SSAA (132 MP) does not.

AOV passes on Built-in render pipeline. The lighting and data-buffer shaders are URP-targeted. On Built-in they fall back to a Diffuse render, so a request for Normals or Motion Vectors will produce a lit image instead. Switch to URP for full fidelity. HDRP is detected and reported but not actively supported.

Transparent capture disables post-processing by default. The standard transparent path renders the camera with an alpha-cleared background, which Unity uses as a signal to skip post-processing. The Post-Process Only and Hybrid alpha sources work around this with a dual black-and-white render — pick one of those if you need bloom / grading in a transparent screenshot.

GIF recording memory cap. The in-memory frame buffer is capped at 512 MB. If your duration × resolution × frame rate would exceed that, the recorder caps the duration, logs a warning, and you get a partial GIF instead of a crash. To capture longer / higher-res GIFs, drop the resolution to Half or Quarter.

GIF finalization takes time. Encoding runs on a background thread after Stop Recording. The window stays responsive but the .gif file is written when encoding finishes — wait for OnEncodingComplete or watch EncodingProgress.

Simple RGB24 vs. Multi-layer EXR Cryptomatte. Simple RGB24 produces hue-rotated PNGs that are not loadable as real Cryptomattes in Nuke / Fusion / AE — they're for thumbnail preview only. Use Multi-layer EXR for actual compositing.

Recording requires Play Mode. GifRecorder and SequenceRecorder both refuse to start outside Play Mode and log an error.

Sequence folder collisions. If your sequence output folder already contains frames, the recorder warns but proceeds. Pick a new folder per take if you don't want previous frames overwritten.