Amplify Color

About Amplify Color – Unity VFX & Shader Pack

Amplify Color Unity Asset Overview

Amplify Color is built around full-screen image post-processing via Look-Up Tables (LUTs). The core engine architecture processes color transformation vectors by mapping input RGB values from the rendered target buffer directly into a pre-computed 2D or 3D texture space. By transforming color values at the fragment stage rather than performing real-time grading calculations across complex color-math instructions, the runtime achieves a deterministic, fixed-cost color transformation pipeline.

Render Pipeline Integration

The asset natively integrates with Unity's Built-in Render Pipeline by attaching image effect drivers directly to the active Camera stack. For modern render pipelines such as the Universal Render Pipeline (URP) and High Definition Render Pipeline (HDRP), Unity utilizes native volume framework overrides for color grading. When reviewing legacy codebases or pipelines utilizing standalone camera pass architectures, understanding Amplify Color's execution loop remains essential for assets migrating between legacy custom render passes and modern Scriptable Render Pipeline (SRP) Blit operations.

Texture Formats and Math Operations

The core shader samples color tables formatted as either flattened 2D horizontal strips (e.g., 256x16 pixel textures) or converted 3D volumetric textures (Texture3D, typically sized at 32x32x32 precision). Inside the fragment pass, the engine calculates normalized lookup coordinates based on the source pixel's channel intensities:

// Conceptual fragment look-up vector calculation
float3 scale = (lutSize - 1.0) / lutSize;
float3 offset = 0.5 / lutSize;
float3 lutCoords = saturate(sourceColor.rgb) * scale + offset;
float4 gradedColor = tex3D(_LUTTex, lutCoords);

Color Space Alignment: Linear vs. Gamma

When working within Unity's Linear Color Space, color buffers are stored in un-gamma'd floating point representations. Amplify Color normalizes input signals prior to lookup sampling, applying linear-to-gamma mapping when indexing standard sRGB LUT assets and applying inverse transformation back to linear space post-sampling. Maintaining accurate texture import settings—specifically disabling sRGB (Color Texture) flags on 3D textures intended for raw mathematical index evaluation—is critical to prevent double-gamma distortion artifacts.

Visual Effects & Rendering Performance Profile

Because image-space color grading processes every rasterized fragment on screen, performance scales linearly with screen resolution rather than scene geometry complexity. Profiling with tools like Unity Frame Debugger and RenderDoc reveals that color LUT execution costs are dominated by memory bandwidth usage during texture sampling passes rather than arithmetic logic unit (ALU) instruction load.

Performance Evaluation Highlights

• Zero Vertex Overhead: Executes across a full-screen quad or triangle post-processing pass, imposing 0 additional vertex processing load on the GPU.
• Memory Bandwidth Sensitivity: Performance is directly proportional to texture sampling operations. 3D LUT sampling requires Trilinear filtering support, which reads 8 adjacent texels per fragment lookup.
• Mobile GPU Optimization: On Tile-Based Deferred Rendering (TBDR) mobile architectures (e.g., ARM Mali, Apple Silicon), post-processing passes force tile memory flushes to main RAM. Minimizing intermediate render texture allocations during LUT blending keeps bandwidth usage low.
• Depth Buffer Interactivity: Optional depth-masked color grading uses scene depth reads (_CameraDepthTexture), introducing an extra texture lookup pass per fragment to blend between global and localized area LUTs.

Comparative Architectural Breakdown

• 2D Strip Sampling vs. Native 3D Textures: 2D strip textures require dual bilinear samples combined with manually interpolated lerp instructions in the shader. 3D textures execute hardware-accelerated trilinear sampling in a single hardware cycle, providing superior GPU performance on modern hardware.
• Dynamic Cross-Fading: Blending between two LUTs concurrently requires sampling two independent color tables per pixel and interpolating between them via a lerp factor, effectively doubling texture sample instructions for the active camera pass duration.

Inspector Properties & Scripting Guide

The core operational logic is driven by the AmplifyColorEffect script component attached to the primary rendering camera. This component exposes properties for defining active color correction textures, blend triggers, mask shapes, and volume blend depths.

Core Component Configuration

To configure the driver component manually or via dynamic scripting, manipulate key properties exposed by the public component interface:

• LutTexture: Primary active LUT texture applied globally across the rendering frame.
• LutBlendTexture: Secondary target LUT texture utilized during programmatic color transitions or volumetric blending zones.
• BlendAmount: Normalized float value (0.0f to 1.0f) defining the linear interpolation weight between primary and secondary color tables.
• MaskTexture: Grayscale alpha mask allowing screen-space spatial isolation of the color grading pass.
• UseDepthMask: Toggle determining whether world-space depth thresholds isolate color correction application distance.

Runtime Control Scripting

The following production-ready C# utility demonstrates how to trigger programmatic LUT transitions, handle parameter blending, and evaluate current camera post-processing state dynamically:

using UnityEngine;

[DisallowMultipleComponent]
[RequireComponent(typeof(Camera))]
public class DynamicColorGradingController : MonoBehaviour
{
    [Header("LUT Parameters")]
    [SerializeField] private Texture2D baseLUT;
    [SerializeField] private Texture2D combatLUT;
    [SerializeField] private float transitionDuration = 1.25f;

    private AmplifyColorEffect colorEffect;
    private bool isExecutingTransition;

    private void Awake()
    {
        colorEffect = GetComponent<AmplifyColorEffect>();
        if (colorEffect == null)
        {
            Debug.LogError("[ColorGrading] AmplifyColorEffect component missing on camera.", this);
        }
    }

    public void TransitionToCombatLUT()
    {
        if (colorEffect == null || combatLUT == null || isExecutingTransition)
            return;

        // Initiate programmatic cross-fade to new LUT resource
        colorEffect.BlendTo(combatLUT, transitionDuration, OnTransitionComplete);
        isExecutingTransition = true;
    }

    public void ResetToBaseLUT()
    {
        if (colorEffect == null || baseLUT == null || isExecutingTransition)
            return;

        colorEffect.BlendTo(baseLUT, transitionDuration, OnTransitionComplete);
        isExecutingTransition = true;
    }

    private void OnTransitionComplete()
    {
        isExecutingTransition = false;
        Debug.Log("[ColorGrading] Color transition operation completed.", this);
    }
}

Related Unity VFX Assets