World Scan FX

About World Scan FX – Unity VFX & Shader Pack

World Scan FX Unity Asset Overview

In my 8+ years building Unity games, I have seen dozens of pulse, radar, and sonar scan shaders. Most developers start by trying to render expanded mesh spheres or modifying individual object shaders to support a global wave parameter. That approach quickly becomes a maintenance nightmare when managing hundreds of unique material instances across environments and characters. World Scan FX solves this architectural headache by relying on a post-processing depth-reconstruction approach.

Instead of touching individual materials on your static props or rigged characters, this asset uses a custom pass that reads Unity's _CameraDepthTexture to reconstruct world-space positions on the fly. By calculating the distance between a designated scan origin and the reconstructed world coordinate of every pixel currently on screen, it highlights terrain geometry, low-poly props, and dynamic characters using a single, unified render feature. Honestly, this depth-based approach is the cleanest way to execute radar sweeps, detective-mode visuals, or sci-fi grid highlights without dirtying your material library.

Core Technical Features & Highlights

Under the hood, World Scan FX provides a balance between raw performance and visual fidelity. Here is the technical breakdown of how the shaders and rendering features operate inside Unity's modern pipelines:

World-Space Depth Reconstruction

The core shader pass samples the camera depth buffer and multiplies the screen-space UV coordinates by the inverse view-projection matrix. This yields the exact 3D world position for every visible surface fragment. By comparing this reconstructed vector to an origin position (such as your player's current transform), the shader renders sharp scan lines, glowing grid overlays, and trailing energy falloffs directly over your scene.

URP Scriptable Render Feature Integration

The asset hooks cleanly into the Universal Render Pipeline via a lightweight ScriptableRendererFeature. This allows the effect to inject after opaque rendering finishes, meaning it operates smoothly with both forward and deferred rendering paths without breaking draw call batching or requiring custom depth pre-pass overrides.

• Zero Geometry Overhead: Runs entirely as a post-process effect; no extra vertex geometry or high-poly scan meshes needed.
• Multi-Wave Support: Shader arrays allow up to 4 concurrent scan origins without noticeable frame drops.
• Noise & Grid Modifiers: Includes customizable simplex noise routines and UV triplanar grid projections for sci-fi, holo-tech, or low-poly aesthetics.
• Custom Depth Occlusion: Prevents scan lines from clipping through solid physical geometry unnecessarily.

Ideal Use Cases & Game Genres

Because this package operates on screen-space depth rather than individual mesh setups, it fits into almost any visual style—from highly detailed realistic scenes to low-poly indie titles.

• Sci-Fi First & Third-Person Shooters: Excellent for "tactical visors," sonar ping mechanics, or highlighting interactive props and enemies through low visibility.
• Stealth & Survival Horror: Perfect for echo-location mechanics where players rely on visual audio pulses to map out dark rooms and spot lurking creatures.
• Cyberpunk & Stylized RPGs: Fits seamlessly into cybernetic updates, area-of-effect spell indicators, or futuristic map discovery sequences.
• Low-Poly & Hyper-Casual Games: The triplanar grid options work exceptionally well on unlit, flat-shaded low-poly environments, adding immediate visual contrast without expensive lighting setup.

Quick-Start Unity Setup & Integration Guide

Setting up World Scan FX inside a Universal Render Pipeline project takes less than five minutes. Here is how to configure your render pipeline and trigger a pulse from C#.

Step 1: Configure Your Render Pipeline

Ensure that your active URP Asset has Depth Texture enabled in the inspector. Then, select your Universal Renderer Data asset, click Add Renderer Feature, and select WorldScanRenderFeature.

Step 2: Attach the Runtime Controller

Create a script to pass your player's position and trigger parameters to the renderer feature or shader material. Here is a practical controller script I use in production to drive the sweep over time:

using UnityEngine;

public class WorldScanController : MonoBehaviour
{
    [SerializeField] private Material scanMaterial;
    [SerializeField] private float scanSpeed = 15.0f;
    [SerializeField] private float maxScanDistance = 50.0f;

    private float currentRadius = 0f;
    private bool isScanning = false;

    private static readonly int ScanOriginProperty = Shader.PropertyToID("_ScanOrigin");
    private static readonly int ScanRadiusProperty = Shader.PropertyToID("_ScanRadius");

    public void TriggerScan(Vector3 originPoint)
    {
        scanMaterial.SetVector(ScanOriginProperty, originPoint);
        currentRadius = 0f;
        isScanning = true;
    }

    private void Update()
    {
        if (Input.GetKeyDown(KeyCode.F) && !isScanning)
        {
            TriggerScan(transform.position);
        }

        if (isScanning)
        {
            currentRadius += Time.deltaTime * scanSpeed;
            scanMaterial.SetFloat(ScanRadiusProperty, currentRadius);

            if (currentRadius >= maxScanDistance)
            {
                isScanning = false;
                scanMaterial.SetFloat(ScanRadiusProperty, 0f);
            }
        }
    }
}

Pros & Cons Assessment

In my experience, no visual asset is completely perfect for every scenario. Here is my honest breakdown of where this package excels and where you need to be cautious.

• Pro: Clean Project Architecture. Because it relies on screen-space reconstruction, you do not need to rewrite or swap out shaders on your existing characters or environmental assets.
• Pro: High Scalability. Runs extremely fast on PC and console hardware, maintaining solid frame times even in dense urban levels.
• Pro: Modular Shaders. The HLSL code is modular and clean, making it straightforward to edit if you want to write custom Shader Graph nodes.
• Con: Transparent Object Limitations. Since standard depth buffers do not write depth for semi-transparent surfaces (like glass or water), transparent meshes will not display scan lines unless rendered with explicit depth writes enabled.
• Con: Mobile Fill-Rate Sensitivity. On budget mobile devices running at native 4K or high retina resolutions, heavy screen-space depth sweeps can increase full-screen fill-rate pressure if not downsampled.

Developers Who Downloaded This Also Downloaded

Related Unity VFX Assets