📺 Interactive Display System Asset Store ↗
📺 Unity Asset

INTERACTIVE
DISPLAY SYSTEM

Turn any mesh or UI element into a fully functional screen. Five display modes, CRT power effects, static noise transitions, shared broadcast clock, and a full scripting API. No scripting required for basic setups.

Everything You Need

A complete system for TVs, monitors, CCTV screens, digital signage, and UI panels in your Unity project.

🚀

Getting Started Quick Start

Set up a working TV screen in under a minute

Interactive Display System uses a TV/Channel metaphor. The TVScreen component is the physical television set — it handles rendering, power state, and audio. Channels are ScriptableObject assets that define what content to display and how.

TVScreen running in a Unity scene
A TV prop running the Interactive Display System with CRT effects and screen glow

Basic Setup

  1. Add the TVScreen component to any GameObject with a MeshRenderer (for 3D) or assign a UI RawImage (for Canvas).
  2. Create one or more TVChannelData ScriptableObjects via Create > InteractiveDisplaySystem > Channel Data. Choose a display mode and assign your content (textures, sprites, sprite sheet, or camera).
  3. Create a TVScreenSettings ScriptableObject via Create > InteractiveDisplaySystem > Screen Settings. Configure your CRT look — scanlines, curvature, tint, brightness.
  4. Assign the channel(s) and screen settings to your TVScreen component. Press Play.
💡
The TVScreen component has context menu options to auto-detect the correct material slot and screen aspect ratio from your mesh bounds. Right-click the component header to use them.

Namespace

All scripts live under ChrisBurns.InteractiveDisplaySystem. Add this using directive to access the API from your own scripts:

using ChrisBurns.InteractiveDisplaySystem;
🖥

TVScreen Core

The main component — your virtual television set

TVScreen is the central MonoBehaviour that orchestrates everything. It manages the power state, channel playback, rendering, audio, and emission sampling. Drop it onto any GameObject and configure it entirely through the Inspector.

TVScreen component in the Unity Inspector
The TVScreen component — channels, settings, render mode, audio, and events all in one place

Render Modes

TVScreen supports two render targets, selected via the Render Mode dropdown:

MeshRenderer

Renders onto any 3D object — quads, TV prop meshes, monitor models. Uses MaterialPropertyBlock for efficient per-instance rendering with no material clones. The component auto-detects the correct material slot.

UI RawImage

Renders into a Unity UI RawImage on a Canvas. Same features, same shader effects, same API. Uses a managed material instance. Ideal for in-game tablet UIs, HUD camera feeds, or menu backgrounds.

Inspector Properties

PropertyTypeDescription
channelsTVChannelData[]Array of channel ScriptableObjects the TV can display. Order determines channel index.
startChannelIndexintWhich channel index to tune to on power-on. Defaults to 0.
staticProfileTVStaticProfileScriptableObject controlling static noise appearance and transition behaviour.
screenSettingsTVScreenSettingsScriptableObject for the physical TV's visual properties (scanlines, curvature, tint, etc.).
renderModeTVRenderModeMeshRenderer or UIRawImage. Determines which render path is used.
targetMeshRendererMeshRendererThe MeshRenderer to draw on (MeshRenderer mode). Auto-assigned from the GameObject if not set.
targetRawImageRawImageThe UI RawImage to draw on (UIRawImage mode).
screenMaterialMaterialOptional explicit screen material reference. Used to identify the correct material slot on multi-material meshes.
materialIndexintMaterial slot index on the MeshRenderer. Auto-detected or set manually.
screenAspectPresetTVContentAspectAspect ratio of the physical screen face. 27 presets or Custom.
emissionLightLightOptional scene Light whose colour and intensity will be driven by the screen content.
powerOnClipAudioClipSound played on power-on (hardware click).
powerOffClipAudioClipSound played on power-off (hardware click).
idleHumClipAudioClipLooping hum played while powered on (uses a dedicated AudioSource).

UnityEvents

EventDescription
onPowerOnFired when the TV powers on.
onPowerOffFired when the TV powers off.
onChannelChangedFired when the active channel index changes.
onChannelDataChangedFired when the channel's content data updates (texture swap, new frame).
onStaticStartFired when a static transition begins.
onStaticEndFired when a static transition ends and the new channel is visible.
🎞

Display Modes Channel Data

Five ways to put content on screen — TVChannelData ScriptableObject

Each channel is a TVChannelData ScriptableObject (Create > InteractiveDisplaySystem > Channel Data). You pick one of five display modes and assign the matching content. Every mode supports configurable frame rate, random frame order, and random hold times per frame for organic, non-uniform playback.

TVChannelData ScriptableObject in the Inspector
TVChannelData — select a display mode and assign content
Frame Sequence

Cycles through an array of individual Texture2D assets at a configurable frame rate. Ideal for hand-authored image sets, slideshow content, or exported GIF frames. Each frame is a separate texture.

Sprite Sequence

Cycles through Unity Sprite assets. Works with individual sprites or atlas sub-sprites. UV coordinates are read directly from each sprite's rect — no manual grid setup needed. Drag sliced sprite sheet sub-sprites straight into the array.

Texture Grid

All animation frames packed into a single texture in a uniform grid. Set the grid dimensions (columns x rows) and total frame count. More GPU-efficient for larger frame counts since only one texture is loaded. Frames step left-to-right, top-to-bottom.

Render Texture (CCTV)

Live camera feed via RenderTexture. Add the TVCameraChannel component to any scene camera and assign a channel — TVScreen discovers it automatically at startup. Cameras are enabled only when their channel is active, so inactive feeds cost nothing.

Static

Continuous procedural noise for "dead channel" or "no signal" effects. Generated entirely in the shader — no textures needed. The noise never tiles. Choose monochrome (classic broadcast snow) or colour (digital glitch).

Channel Properties

PropertyTypeDescription
channelNamestringDisplay name for UI overlays or on-screen channel banners.
channelNumberintChannel number for UI display purposes.
displayModeTVDisplayModeFrameSequence, SpriteSequence, TextureGrid, RenderTexture, or Static.
framesTexture2D[]Frame Sequence mode: array of textures to cycle.
frameRatefloatFrame Sequence mode: playback speed in frames per second.
spritesSprite[]Sprite Sequence mode: array of Sprite assets to cycle.
spriteFrameRatefloatSprite Sequence mode: playback speed.
spriteSheetTextureTexture2DTexture Grid mode: the packed sprite sheet texture.
gridSizeVector2IntTexture Grid mode: columns x rows of the grid layout.
totalFramesintTexture Grid mode: actual number of frames (may be less than cols * rows).
spriteSheetFrameRatefloatTexture Grid mode: playback speed.
randomizeFramesboolPlay frames in random order instead of sequential.
useRandomHoldTimeboolHold each frame for a random duration instead of fixed frame rate.
randomHoldTimeRangeVector2Min/max seconds to hold each frame when random hold time is enabled.
contentAspectTVContentAspectAspect ratio of the source content. Used for letterbox/pillarbox calculations.
audioClipAudioClipAudio to play when this channel is active.
volumefloatVolume level for this channel's audio.
loopAudioboolWhether the channel audio loops.
audioStartOffsetfloatStart playback at this time offset (seconds).
⚙

Screen Settings ScriptableObject

The physical TV's visual properties — TVScreenSettings

TVScreenSettings is a ScriptableObject (Create > InteractiveDisplaySystem > Screen Settings) that defines the "physical TV set" — how it looks regardless of what channel is playing. Share one settings asset across every TV of the same type. Change one value, every TV using that profile updates.

TVScreenSettings ScriptableObject in the Inspector
TVScreenSettings — scanlines, curvature, tint, brightness, CRT power, and emission controls

Visual Properties

PropertyTypeDescription
tintColorColour tint applied to the screen. Warm amber for vintage, green for surveillance, white for neutral.
brightnessfloat (0-2)Overall brightness multiplier.
contrastfloat (0-2)Contrast adjustment around midpoint.
saturationfloat (0-1)Colour saturation. 0 = greyscale, 1 = full colour.
applyCurvatureboolEnable CRT barrel distortion effect.
curvatureAmountfloatStrength of the barrel distortion. Small values (0.02-0.05) look natural.
applyScanlinesboolEnable horizontal scanline overlay.
scanlineIntensityfloat (0-1)How visible the scanlines are.
scanlineCountfloatNumber of scanlines. 240 for NTSC, 288 for PAL, 480 for later CRTs — or any value.
barsColorColorColour of letterbox/pillarbox bars when aspect ratios don't match.

CRT Power Effect

PropertyTypeDescription
enablePowerEffectboolEnable animated CRT power on/off transitions. Disable for instant on/off (flat panel style).
powerOnDurationfloatDuration of the power-on animation in seconds.
powerOffDurationfloatDuration of the power-off animation in seconds.
powerOnCurveAnimationCurveTiming curve for the power-on animation.
powerOffCurveAnimationCurveTiming curve for the power-off animation.
powerDownStyleCRTPowerDownStyleFullCRTTube or HorizontalLineOnly. See CRT Power Effects section.

Emission

PropertyTypeDescription
emissionIntensityfloatBase emission strength of the screen.
emissionMatchesContentboolWhen enabled, the emission colour is GPU-sampled from the displayed content at 20Hz.
currentEmissionColorColorThe current emission colour (read-only at runtime, driven by the sampling system).
📡

Static Profile ScriptableObject

Configure static noise appearance and channel switch transitions — TVStaticProfile

TVStaticProfile (Create > InteractiveDisplaySystem > Static Profile) controls how static noise looks and how it behaves during channel switches. The noise swells over the old channel, the new channel appears at the midpoint, and the static fades out.

TVStaticProfile ScriptableObject in the Inspector
TVStaticProfile — noise style, transition timing, and static audio clips
PropertyTypeDescription
useProceduralNoiseboolGenerate noise in the shader (no texture needed). Disable to use a custom noise texture.
noiseTextureTexture2DCustom noise texture for hand-authored static patterns. Only used when procedural noise is disabled.
noiseSpeedfloatHow fast the static noise animates.
noiseIntensityfloatStrength of the noise effect.
monochromeboolTrue = classic black-and-white broadcast snow. False = coloured digital glitch.
staticAudioClipsAudioClip[]Array of static/white noise audio clips. A random clip is picked on each channel switch.
staticVolumefloatVolume for static transition audio.
transitionDurationfloatTotal duration of the static transition in seconds. Set to 0 for instant digital-style switching.
transitionCurveAnimationCurveTiming curve for the static transition blend.
💡
Set the transition duration to zero for instant digital-style channel switching with no static burst. Assign multiple audio clips for variety — one is picked at random on each switch.
🎥

TVCameraChannel Component

CCTV camera source for RenderTexture channels

Add TVCameraChannel to any Camera in your scene to make it available as a live CCTV feed. Assign a TVChannelData (set to RenderTexture mode) and the TVScreen will discover this camera automatically at startup. No manual RenderTexture wiring required.

PropertyTypeDescription
channelDataTVChannelDataThe channel ScriptableObject this camera provides content for. Must have displayMode set to RenderTexture.
ℹ
Cameras for inactive RenderTexture channels are disabled automatically by TVScreen. They only render when their channel is actively being displayed, so inactive feeds cost nothing.
📐

Aspect Ratio System Feature

27 presets, three scale modes, independent screen and content ratios

Both the screen (physical TV face) and the content (source material) have independent aspect ratio settings. When they don't match, the Scale Mode determines how to handle it.

Scale Modes

Stretch

Fills the screen exactly. May distort if the content and screen aspect ratios differ.

Fit

Shows the full image centred with letterbox (horizontal bars) or pillarbox (vertical bars) as needed. No cropping, no distortion.

Fill

Crops the content to fill the screen completely. No bars, no distortion, but edges may be cut off.

Aspect Ratio Presets (TVContentAspect)

27 named presets covering everything from smartphone to super ultrawide. Both the screen and each channel's content can use any preset or a custom ratio.

6:13 Smartphone
9:16 Vertical
9:21
2:3
10:16
3:4
1:1 Square
5:4
4:3 Fullscreen
11:8 Academy
1.43:1 IMAX
3:2
14:9
1.618:1 Golden
16:10
5:3
16:9 HD
1.85:1 Flat
17:9
2:1 Univisium
11:5
21:9 Anamorphic
2.39:1 Scope
2.76:1 Ultra
32:10
32:9 Super UW
4:1 Polyvision
Custom
💡
Right-click the TVScreen component header to access the auto-detect context menu. It can read your model's mesh bounds to determine the correct screen aspect ratio automatically.
🔊

Audio System Feature

Three audio layers — channel, static, and hardware

The audio system has three independent layers, all controlled by a master volume and mute toggle.

Channel Audio

Each TVChannelData can have its own AudioClip with independent volume, loop toggle, and start offset. Audio switches with the channel automatically. Configured on the channel ScriptableObject, not on TVScreen.

Static Audio

Assign multiple static/white noise clips to the TVStaticProfile. A random clip plays during each channel switch transition. The audio fades in and out with the static noise.

Hardware Audio

Optional power-on click, power-off click, and continuous idle hum loop. These play on a dedicated AudioSource so they never interrupt channel or static audio. Configured on the TVScreen component directly.

Volume Control

// Master volume (affects all audio) tvScreen.SetVolume(0.8f); // Mute toggle (silences without changing volume level) tvScreen.SetMute(true); // Properties float vol = tvScreen.Volume; bool muted = tvScreen.IsMuted;
💡

Emission & Screen Glow Feature

GPU-sampled emission colour drives scene lighting automatically

The screen emits light with configurable intensity. When emissionMatchesContent is enabled on the TVScreenSettings, the emission colour is GPU-sampled from the currently displayed frame at 20Hz. A red scene glows red, a dark scene barely glows.

The sampling uses an 8x8 RenderTexture blit to extract an average colour from the current frame. It respects sprite sheet UV offsets, so only the current frame cell is sampled — not the entire texture atlas.

Automatic Light Driving

Assign a Point or Spot Light to the emissionLight field on TVScreen. The light's colour and intensity are then driven automatically to match the screen content — simulating the TV illuminating its surroundings. No extra scripting needed.

Screen glow illuminating the environment
The emission system drives a scene light to match the screen content — the room glows with the displayed colours

Emission fades smoothly through CRT power animations and snaps to neutral grey during static transitions, so the room lighting always matches what's actually visible on screen.

ℹ
The emission sampling system uses persistent GPU objects (no per-frame allocation). The 8x8 blit at 20Hz is extremely lightweight — it won't show up in your GPU profiler.
⚡

CRT Power Effects Effect

Animated power on/off with phosphor flare

Animated power transitions that mimic real CRT hardware. Both styles use configurable AnimationCurves for timing, with separate durations for power-on and power-off. The shader adds a phosphor flare as the image collapses — the bright line/dot glow you see on real CRT televisions.

Power Down Styles

Full CRT Tube

The image collapses vertically to a bright horizontal line, then squeezes horizontally to a bright centre dot before fading out. The full retro experience. Reversed on power-on.

Horizontal Line Only

Collapses to a horizontal centre line and fades. A simpler, faster effect for when the full tube collapse is too dramatic.

CRT power off effect showing the horizontal line collapse
CRT power-off in action — the image collapses to a bright phosphor line before fading

Disable the power effect entirely on the TVScreenSettings for instant on/off (flat panel / modern monitor style).

💡
The phosphor flare peaks around 15% of the power-off animation — the bright line or dot just before the screen goes dark. Adjust the AnimationCurves on TVScreenSettings for different timing feels.
🕐

Shared Broadcast Clock Core

Multiple TVs on the same channel are always frame-locked

Multiple TVs tuned to the same TVChannelData ScriptableObject display the same frame at the same time, automatically. The broadcast clock is a static dictionary keyed by channel asset — its state is advanced once per Unity frame regardless of how many TVs reference it.

Switching to a channel mid-playback shows exactly where a "live broadcast" would be, not frame zero. This happens automatically with no setup required — just assign the same channel asset to multiple TVScreen components.

ℹ
Think of it like real broadcast TV. Every television in a store showing the same channel is on the same frame. Your TVs work the same way — a wall of TVs in a shop or a bank of security monitors will all be perfectly synchronised.
⌨

Scripting API Reference

Full public API for controlling TVScreen from code

Methods

MethodReturnsDescription
PowerOn()voidPowers on the TV. Plays the CRT power-on animation if enabled.
PowerOff()voidPowers off the TV. Plays the CRT power-off animation if enabled.
TogglePower()voidToggles between powered on and off.
SetChannel(int)voidSwitches to the channel at the given index. Plays the static transition if configured.
NextChannel()voidSwitches to the next channel (wraps around).
PreviousChannel()voidSwitches to the previous channel (wraps around).
RandomChannel()voidSwitches to a random channel (avoids the current one).
SetVolume(float)voidSets the master volume (0 to 1). Affects all audio layers.
SetMute(bool)voidMutes or unmutes all audio without changing the volume level.

Properties

PropertyTypeDescription
IsPoweredOnboolWhether the TV is currently powered on.
CurrentChannelIndexintIndex of the currently active channel.
CurrentChannelTVChannelDataThe currently active channel ScriptableObject.
ChannelCountintNumber of channels assigned to this TV.
IsMutedboolWhether the TV is currently muted.
VolumefloatCurrent master volume level.

Example Usage

using UnityEngine; using ChrisBurns.InteractiveDisplaySystem; public class TVRemoteControl : MonoBehaviour { [SerializeField] private TVScreen tvScreen; void Update() { if (Input.GetKeyDown(KeyCode.P)) tvScreen.TogglePower(); if (Input.GetKeyDown(KeyCode.RightArrow)) tvScreen.NextChannel(); if (Input.GetKeyDown(KeyCode.LeftArrow)) tvScreen.PreviousChannel(); if (Input.GetKeyDown(KeyCode.M)) tvScreen.SetMute(!tvScreen.IsMuted); } }

UnityEvents

Six events are available for wiring up game logic in the Inspector or subscribing from code:

tvScreen.onPowerOn.AddListener(() => Debug.Log("TV powered on")); tvScreen.onPowerOff.AddListener(() => Debug.Log("TV powered off")); tvScreen.onChannelChanged.AddListener(() => { Debug.Log($"Switched to channel {tvScreen.CurrentChannelIndex}"); }); tvScreen.onStaticStart.AddListener(() => Debug.Log("Static transition started")); tvScreen.onStaticEnd.AddListener(() => Debug.Log("Static transition ended"));
💡
Channel data exposes channelName and channelNumber fields. Use these with onChannelChanged to build in-game UI overlays or on-screen channel banners.
🔮

Shaders & Pipeline Support Rendering

Three custom shaders — auto-detected at runtime

Interactive Display System ships with three custom shaders. The correct shader is detected and applied automatically at runtime based on your project's active render pipeline. No manual shader assignment needed.

TVScreen_URP

Universal Render Pipeline shader. Full HLSL implementation with all TV effects: curvature, scanlines, colour adjustments, CRT power collapse, static noise, aspect ratio correction, and emission.

TVScreen_Builtin

Built-in Render Pipeline shader. Same feature set as URP but written for the legacy pipeline. Used as the automatic fallback.

TVScreen_UI

Canvas/UI shader for RawImage rendering. Pipeline-agnostic — works with both URP and Built-in. Used automatically when Render Mode is set to UIRawImage.

Shader Includes

Shared shader logic lives in two include files:

FileContents
TVCommon.hlslShared functions: TVApplyCurvature, TVCurvatureMask, TVApplyScanlines, TVColorAdjust, TVApplyTint, TVPowerEffectUV, TVPowerEffectColor, sprite sheet UV stepping.
TVNoise.hlslProcedural noise generation: TVStaticNoise, TVStaticTransition. Hash-based noise that never tiles.

Pipeline Auto-Detection

TVShaderUtility checks GraphicsSettings.currentRenderPipeline at runtime. If the pipeline type name contains "Universal", the URP shader is used. Otherwise, the Built-in shader is selected as the default. The UI shader is always pipeline-agnostic.

🔧

Technical Details Reference

Architecture, performance, and compatibility

Architecture

The system follows a clean separation of concerns. TVScreen orchestrates everything but delegates rendering to specialised renderer classes (TVQuadRenderer for MeshRenderer, TVUIRenderer for RawImage), frame playback to TVChannelPlayer, and effects to TVPowerEffect and TVStaticEffect. All data lives in ScriptableObjects that can be shared and reused across any number of TVScreens.

Performance

FeatureDetail
Frame PlaybackZero-allocation at runtime. No GC pressure during normal operation.
MeshRendererUses MaterialPropertyBlock — no per-instance material clones. Multiple TVs share the same material in memory.
Emission SamplingGPU-side 8x8 RenderTexture blit at 20Hz with persistent objects. No per-frame allocation.
Broadcast ClockStatic dictionary advanced once per Unity frame regardless of TV count. O(1) per TV.
CCTV CamerasCameras for inactive RenderTexture channels are disabled. Only the currently displayed camera renders.
UI RenderingManaged material instance per RawImage. Cleaned up on destroy.

Script Architecture

ScriptRole
TVScreenMain orchestrator MonoBehaviour. Power state, channel management, audio, emission.
TVChannelPlayerFrame playback engine with shared broadcast clock.
TVDisplayRendererAbstract base class with cached shader property IDs.
TVQuadRendererMeshRenderer implementation using MaterialPropertyBlock.
TVUIRendererUI RawImage implementation with owned material instance.
TVCameraChannelComponent for marking cameras as CCTV feed sources.
TVPowerEffectCRT power on/off animation state machine.
TVStaticEffectStatic noise transition with midpoint channel swap detection.
TVShaderUtilityRuntime render pipeline detection and shader selection.
TVSpriteSheetHelperUV offset/scale calculations for texture grid stepping.
TVChannelDataScriptableObject: channel content definition.
TVScreenSettingsScriptableObject: physical TV visual properties.
TVStaticProfileScriptableObject: static noise and transition settings.

Compatibility

RequirementDetail
Unity Version2021.3+ (LTS) and later
Render PipelinesBuilt-in and Universal (URP). Auto-detected at runtime.
DependenciesNone. No third-party packages required.
NamespaceChrisBurns.InteractiveDisplaySystem
PlatformsAll platforms supported by Unity's render pipelines.
💬

Support & Contact

Get help, report issues, or request features

If you have questions, run into issues, or want to request a feature, the best way to reach me is through the Unity Asset Store. Leave a review or send a message through the publisher page.

🏪 Asset Store Publisher page & reviews 💬 Discord Community & support 🌐 Email & Website info@chrisburns.com.au · chrisburns.com.au