Video Streaming & Grid Node System

Overview

VRSL’s video streaming system bridges professional lighting control software with VRChat by encoding DMX data into video pixels. This enables real-time control of hundreds of fixtures from industry-standard tools like MA3, Chamsys, or QLC+.

The Grid Node is a separate paid application that runs locally, converting Art-Net/sACN to video that can be streamed to VRChat.

System Architecture

┌──────────────────┐
│ Lighting Console │  (MA3, Chamsys, QLC+, etc.)
└────────┬─────────┘
         │ Art-Net / sACN
         ▼
┌──────────────────┐
│  VRSL Grid Node  │  (Standalone Application)
│  - Receives DMX  │
│  - Encodes to    │
│    video pixels  │
│  - 1920×1088     │
│    output        │
└────────┬─────────┘
         │ Video Output
         ▼
┌──────────────────┐
│      OBS         │  (or other streaming software)
│  - Captures      │
│    Grid Node     │
│  - Streams to    │
│    Twitch/etc    │
└────────┬─────────┘
         │ RTMP/Stream
         ▼
┌──────────────────┐
│     VRChat       │
│  - Video Player  │
│  - VRSL Shaders  │
│  - Decode DMX    │
│  - Render Lights │
└──────────────────┘

Grid Node Application

Installation & Setup

Purchase the Grid Node from Gumroad
Extract and run the application
Configure network settings:
- Art-Net Universe: 1-9 (or more with RGB mode)
- sACN Universe: Same as Art-Net
- OSC Port: 12000 (for Unity editor sync)
Set orientation:
- Vertical Mode: 13×67 grid (871 channels, 6.7 universes)
- Horizontal Mode: 120×13 grid (1560 channels, 3 universes)

Vertical mode is recommended for most setups as it efficiently maps to DMX universes.

RGB Expanded Mode

Enable RGB mode to triple capacity:

Red Channel: Universes 1, 4, 7
Green Channel: Universes 2, 5, 8
Blue Channel: Universes 3, 6, 9

Total capacity: Up to 9 universes (4,608 channels)

Vertical Grid (RGB Mode):
┌─────────────────────────────────┐
│ 13 cells × 67 cells = 871 cells│
│ × 3 RGB channels                │
│ = 2,613 DMX channels            │
│ ≈ 5.1 universes                 │
└─────────────────────────────────┘

Grid Node Output

The Grid Node outputs a 1920×1088 video texture: Vertical Mode:

Grid area: 208×1072 pixels (13×67 cells, 16px each)
Remaining space: Black/unused

Horizontal Mode:

Grid area: 1920×208 pixels (120×13 cells, 16px each)
Remaining space: Black/unused

Unity Editor Integration

During development, the Grid Node can sync directly with Unity:

GridReader Component

The GridReader.cs script receives OSC data from Grid Node:

// From GridReader.cs:16-38
public class GridReader : MonoBehaviour
{
    [Tooltip("Enable if using the grid node in vertical mode")]
    [SerializeField] bool _IsVertical = true;
    
    [Tooltip("Enable if you are using RGB mode to use additional universes")]
    [SerializeField] bool _ExpandedUniverseSupport = false;
    
    [Tooltip("Change if you set a port other than 12000 in the grid node.")]
    [SerializeField] int _OSCPort = 12000;
    
    [Tooltip("Prefix assigned in the VRSL grid node")]
    [SerializeField] string _OSCPrefix = "/VRSL";
    
    [SerializeField] Texture2D _DataBuffer;
}

OSC Message Parsing

// GridReader.cs:82-106
HandleOscPacket callback = delegate (OscPacket packet)
{
    int[] _pktData = new int[4];
    if (_ExpandedUniverseSupport)
        TekView.TekParse.ParseExpandedMode(packet, ref _pktData, _OSCPrefix);
    else
        TekView.TekParse.ParseStandardMode(packet, ref _pktData, _OSCPrefix);
    
    if (_pktData[0] > _Buf.Length) return;  // Safety check
    
    if (_ExpandedUniverseSupport)
    {
        _Buf[_pktData[0] - 1].r = _pktData[1] / 255f;
        _Buf[_pktData[0] - 1].g = _pktData[2] / 255f;
        _Buf[_pktData[0] - 1].b = _pktData[3] / 255f;
    }
    else
    {
        _Buf[_pktData[0] - 1].r = _pktData[1] / 255f;
        _Buf[_pktData[0] - 1].g = _pktData[1] / 255f;
        _Buf[_pktData[0] - 1].b = _pktData[1] / 255f;
    }
    _NeedsUpdate[_pktData[0] - 1] = true;
};

Texture Buffer Update

Changed cells are written to the texture each frame:

// GridReader.cs:148-184
private void Update()
{
    Color[] data = new Color[256];  // 16×16 pixels
    int index = 0;
    
    if (_IsVertical)
    {
        for (int y = 0; y < _yLim; y++)
        {
            for (int x = 0; x < _xLim; x++)
            {
                if (_NeedsUpdate[index])
                {
                    _NeedsUpdate[index] = false;
                    // Fill 16×16 block with same color
                    for (int datInd = 0; datInd < 256; datInd++) 
                        data[datInd] = _Buf[index];
                    _DataBuffer.SetPixels(16 * x, (16 * y), 16, 16, data, 0);
                }
                index++;
            }
        }
    }
    _DataBuffer.Apply();
}

The GridReader is editor-only (#if UNITY_EDITOR). In VRChat, the video player provides the texture directly.

VRChat Video Player Setup

In your VRChat world:

1. Add Video Player

Use USharp Video Player or similar:

// Example configuration
VideoPlayer videoPlayer;
videoPlayer.url = "https://twitch.tv/your_channel";
videoPlayer.renderMode = VideoRenderMode.RenderTexture;
videoPlayer.targetTexture = dmxGridRenderTexture;

2. Assign Render Texture

Create or assign the DMX grid render texture:

Name: _Udon_DMXGridRenderTexture (or legacy _OSCGridRenderTextureRAW)
Size: 1920×1088 or larger
Format: RGBA32
Filter Mode: Point (no interpolation)
Wrap Mode: Clamp

3. Global Shader Properties

Set the texture globally so all VRSL shaders can access it:

// Set in Udon or custom script
Shader.SetGlobalTexture("_Udon_DMXGridRenderTexture", renderTexture);
Shader.SetGlobalInt("_EnableVerticalMode", verticalMode ? 1 : 0);
Shader.SetGlobalInt("_EnableCompatibilityMode", 0);  // Use Industry mode

The texture MUST be set globally. Per-material assignment will not work due to GPU instancing.

Streaming Setup

OBS Configuration

Add Window Capture or Display Capture source
Point to VRSL Grid Node application
Crop to grid area if desired
Set output resolution:
- 1920×1080 (standard)
- Higher if you need sharper pixels
Critical: Set bitrate high enough to prevent compression:
- Minimum: 6000 kbps
- Recommended: 8000-10000 kbps
- Ideal: Lossless recording/local streaming

Streaming Platform

Options for delivering video to VRChat: Twitch

Pros: Low latency (2-4 seconds), reliable
Cons: Public stream, compression artifacts
Bitrate: Use maximum allowed for your partnership tier

YouTube Live

Pros: High quality, unlisted streams
Cons: Higher latency (5-10 seconds)
Bitrate: Up to 51 Mbps for 4K

Self-Hosted RTMP

Pros: Full control, minimal compression
Cons: Requires server, networking knowledge
Bitrate: Unlimited

For best quality, use a self-hosted RTMP server or record locally and use a file-based video player for testing.

Compression Handling

Video compression is the biggest challenge for DMX streaming:

Problems Caused by Compression

Color Banding - DMX values become imprecise
Temporal Artifacts - Fast changes get blurred
Block Artifacts - Encoding blocks create false data

VRSL’s Mitigation Strategies

Interpolation Render Texture Smooths values over time:

// DMXRTShader-DMXInterpolation.shader
// Reads current and previous frame, outputs lerped result

Movement-Specific Texture Pan/tilt data uses separate, more heavily smoothed texture:

// Different texture for movement channels
float inputValue = getValueAtCoords(DMXChannel, _Udon_DMXGridRenderTextureMovement);

Strobe Timing Generation Converts unreliable strobe values to stable phase:

// DMXRTShader-StrobeTimings.shader
// Accumulates phase based on strobe speed
// DMXRTShader-StrobeOutput.shader
// Generates clean binary output from phase

Latency Optimization

End-to-End Latency Breakdown

Stage	Typical Latency	Optimization
Lighting Console → Art-Net	1-5 ms	Use wired network
Art-Net → Grid Node	1-10 ms	Local processing
Grid Node → OBS	16-33 ms	Monitor refresh rate
OBS Encoding	30-100 ms	Use NVENC, lower preset
Stream Upload	10-50 ms	Use CDN close to server
Platform Processing	500-3000 ms	Choose platform carefully
VRChat Download	100-500 ms	Player’s network
Video Player Buffer	100-1000 ms	Configure buffer size
Total	~750-4500 ms	0.75-4.5 seconds

Reducing Latency

Use Twitch - Lowest platform latency
Enable Low Latency Mode - In Twitch settings
Reduce Buffer - In USharp Video Player settings
Optimize Encoding - Use hardware encoding (NVENC/QuickSync)
Local Network - Test with local RTMP server first

Some latency is unavoidable. Design your lighting cues with a 1-2 second offset to sync with audio.

Texture Modes

VRSL supports multiple texture configurations:

Legacy Textures

#ifdef _VRSL_LEGACY_TEXTURES
    Texture2D _OSCGridRenderTexture;           // Interpolated data
    Texture2D _OSCGridRenderTextureRAW;        // Raw input
    Texture2D _OSCGridStrobeTimer;             // Strobe phase
    Texture2D _OSCGridSpinTimer;               // Spin accumulator
#endif

Modern Textures

#ifndef _VRSL_LEGACY_TEXTURES
    Texture2D _Udon_DMXGridRenderTexture;              // Main data
    Texture2D _Udon_DMXGridRenderTextureMovement;      // Movement (smoothed)
    Texture2D _Udon_DMXGridStrobeOutput;               // Binary strobe
    Texture2D _Udon_DMXGridSpinTimer;                  // Rotation phase
#endif

Modern textures separate movement and strobe data for better quality and performance.

Testing Without Grid Node

For testing without streaming:

1. Use Pre-recorded Video

Record a Grid Node session and play back:

videoPlayer.url = "file:///C:/path/to/recorded_grid.mp4";
videoPlayer.isLooping = true;

2. Use GridReader in Editor

Enable the GridReader component with OSC:

// GridReader automatically creates texture from OSC
// No streaming required

3. Manual Texture Updates

Write a custom script to simulate DMX:

void UpdateDMXChannel(int channel, byte value)
{
    int x = (channel - 1) % 13;
    int y = (channel - 1) / 13;
    
    Color color = new Color(value / 255f, value / 255f, value / 255f, 1f);
    Color[] pixels = new Color[256];
    for (int i = 0; i < 256; i++) pixels[i] = color;
    
    dmxTexture.SetPixels(x * 16, y * 16, 16, 16, pixels);
    dmxTexture.Apply();
}

Advanced Features

OSC Commands

Grid Node supports OSC control:

// Request full DMX refresh
var message = new OscMessage("/VRSL/Command/RefreshDMX", 0);
sender.Send(message);

MIDI Output

Grid Node can output MIDI alongside video:

Convert DMX channels to MIDI CC
Useful for triggering other software
Planned for future VRChat OSC integration

Multiple Outputs

Run multiple Grid Node instances:

Different universe ranges
Different orientations
Multiple worlds simultaneously

Troubleshooting

Grid Appears Black

Check video player is playing
Verify render texture is assigned
Ensure texture is set globally (not per-material)
Check _EnableVerticalMode matches Grid Node

Fixtures Not Responding

Verify DMX channel assignments
Check universe configuration in Grid Node
Ensure fixtures have _EnableDMX enabled
Test with GridReader in editor first

Jittery Movement

Increase streaming bitrate
Use movement-specific smoothing texture
Adjust _ConeSync parameter
Consider slower, smoother movements

Incorrect Colors

Check RGB mode enabled in both Grid Node and fixtures
Verify _NineUniverseMode setting
Ensure color channels are mapped correctly
Test with solid colors first

DMX System

How DMX data is encoded and decoded

Shader Architecture

How shaders read the video texture

Get Started

Core Concepts

Fixtures

Components

Guides

​Overview

​System Architecture

​Grid Node Application

​Installation & Setup

​RGB Expanded Mode

​Grid Node Output

​Unity Editor Integration

​GridReader Component

​OSC Message Parsing

​Texture Buffer Update

​VRChat Video Player Setup

​1. Add Video Player

​2. Assign Render Texture

​3. Global Shader Properties

​Streaming Setup

​OBS Configuration

​Streaming Platform

​Compression Handling

​Problems Caused by Compression

​VRSL’s Mitigation Strategies

​Latency Optimization

​End-to-End Latency Breakdown

​Reducing Latency

​Texture Modes

​Legacy Textures

​Modern Textures

​Testing Without Grid Node

​1. Use Pre-recorded Video

​2. Use GridReader in Editor

​3. Manual Texture Updates

​Advanced Features

​OSC Commands

​MIDI Output

​Multiple Outputs

​Troubleshooting

​Grid Appears Black

​Fixtures Not Responding

​Jittery Movement

​Incorrect Colors

​Related Topics

DMX System

Shader Architecture

Build docs developers (and LLMs) love

Overview

System Architecture

Grid Node Application

Installation & Setup

RGB Expanded Mode

Grid Node Output

Unity Editor Integration

GridReader Component

OSC Message Parsing

Texture Buffer Update

VRChat Video Player Setup

1. Add Video Player

2. Assign Render Texture

3. Global Shader Properties

Streaming Setup

OBS Configuration

Streaming Platform

Compression Handling

Problems Caused by Compression

VRSL’s Mitigation Strategies

Latency Optimization

End-to-End Latency Breakdown

Reducing Latency

Texture Modes

Legacy Textures

Modern Textures

Testing Without Grid Node

1. Use Pre-recorded Video

2. Use GridReader in Editor

3. Manual Texture Updates

Advanced Features

OSC Commands

MIDI Output

Multiple Outputs

Troubleshooting

Grid Appears Black

Fixtures Not Responding

Jittery Movement

Incorrect Colors

Related Topics