Adaptive Split Screen

About Adaptive Split Screen – Unity Editor Tool & Plugin

Adaptive Split Screen Unity Asset Overview

If you have ever built a local co-op game in Unity, you know the visual frustration of standard side-by-side split screen. When players are standing next to each other, forcing them into narrow, bisected viewports wastes rendered screen space and feels disconnected. In my experience building local multiplayer prototypes, achieving the dynamic split screen look popularized by titles like Lego Star Wars or It Takes Two requires tricky math, custom screen-space post-processing, and endless vector calculations.

The Adaptive Split Screen asset solves this cleanly. At its core, the architecture relies on a centralized camera controller tracking target transforms in world space. When two targets are within a configurable proximity, the system renders a single shared view through a unified Camera frustum. As the targets move apart beyond a specified distance threshold, the script dynamically splits the screen using custom render passes or dual camera viewports, drawing a real-time separating line angled relative to the vector between the two players.

Architecturally, the asset sits neatly between Unity's rendering pipeline and your gameplay framework. It handles target tracking, dynamic frustum calculation, screen-space boundary line generation, and audio listener attenuation so you don't end up with doubled-up spatial audio bugs.

Core Technical Features & Highlights

Looking under the hood, the system is designed to minimize runtime overhead while maintaining clean visuals during dynamic viewport transitions.

• Dynamic Angle Calculation: Calculates the screen-space angle between targets, aligning the visual separator line naturally with player positions.
• Customizable Screen Splitter Shader: Handles screen blending via a dedicated shader pass featuring configurable line color, thickness, anti-aliasing edge softness, and drop-shadow effects.
• SRP & Pipeline Compatibility: Fully configurable for Unity's Universal Render Pipeline (URP) via custom ScriptableRenderPass setup, alongside legacy support for the Built-in Render Pipeline.
• Network Integration Hooks: Includes native sync adapters for network frameworks like Mirror, Photon Fusion, and Unity Netcode for GameObjects to handle camera assignment upon client player spawn events.
• Zero-Allocation Runtime Loop: The main update loop caches vector allocations and transform operations to maintain 60+ FPS on mid-tier hardware.

Here is the key takeaway: instead of rendering two heavy camera pipelines continuously, the manager intelligently disables the secondary camera entirely when players are merged, saving substantial GPU rasterization cycles.

Ideal Use Cases & Game Genres

While any local co-op title can benefit from dynamic camera setups, specific genres maximize the utility of this system:

Couch Co-Op Action Platformers

Games where players explore environments both together and separately benefit immensely. Players can explore opposite sides of a room without pulling the camera off-bounds or feeling constrained by an invisible rubber band boundary.

Top-Down Hack & Slash / Action RPGs

In isometric or top-down perspectives, keeping both players framed on a single screen often means zooming out so far that player models become tiny dots. Dynamic split screen allows tight camera framing on each player while seamlessly joining into a cinematic single view during boss fights.

Dual-Player Puzzle Titles

When two players need to operate switches on opposite sides of a map simultaneously, individual cameras allow precise alignment without obscuring puzzle elements.

Quick-Start Unity Setup & Integration Guide

Integrating this tool into an existing project takes under ten minutes once you understand the basic component flow. Here is how I usually set it up in a standard project:

1. Add the AdaptiveSplitScreenManager component to a main controller GameObject in your scene.
2. Assign your primary Camera component into the Main Camera slot.
3. Define the separation distance threshold in the Inspector (e.g., set Split Distance to 8.0 units).
4. Assign player target Transform references manually or via code during character spawn routines.

If you spawn players dynamically over a local network or via a character selection screen, you can wire up targets programmatically using a straightforward controller script:

using UnityEngine;
using AdaptiveSplitScreenSystem;

public class CoOpPlayerSetup : MonoBehaviour
{
    [SerializeField] private AdaptiveSplitScreenManager cameraManager;

    public void OnPlayersSpawned(GameObject p1, GameObject p2)
    {
        if (cameraManager == null)
        {
            cameraManager = FindFirstObjectByType<AdaptiveSplitScreenManager>();
        }

        // Register player transforms into the dynamic camera controller
        cameraManager.SetTargetOne(p1.transform);
        cameraManager.SetTargetTwo(p2.transform);

        // Enable tracking immediately
        cameraManager.EnableAdaptiveSplit();
    }
}

When running URP, ensure you add the provided SplitScreenRenderFeature to your Forward Renderer asset data file, or the custom border line shader will not blit over the final color buffer correctly.

Pros & Cons Assessment

• Pros:
  • Saves hundreds of hours spent writing custom vector projection and camera frustum math.
  • Smooth transitions with customizable easing curves eliminate visual snapping when views merge or split.
  • In-depth network integration scripts make multiplayer setup straightforward.
  • Clean shader code allows easy modifications for custom visual stylization.
• Cons:
  • Dual-camera rendering active during splits inevitably doubles draw calls and geometry processing costs for world objects.
  • Screen-space UI Canvases set to Screen Space Overlay require custom camera sorting layers to prevent overlay bleeding across the screen split line.

Related Unity Tools Assets