GIBLION: Anime-NPR-Toon Scene Generation Framework

About GIBLION: Anime-NPR-Toon Scene Generation Framework – Unity Editor Tool & Plugin

GIBLION: Anime-NPR-Toon Scene Generation Framework Unity Asset Overview

Achieving a hand-painted, Studio Ghibli-inspired aesthetic in modern real-time engines is notoriously difficult. Standard PBR (Physically Based Rendering) pipelines rely on physically accurate roughness, metallic, and normal workflow maps. When you attempt to force an anime or Non-Photorealistic Rendering (NPR) look through basic light ramps in standard shaders, the environment lighting breaks down instantly under dynamic directional lights and shadow cascades.

Honestly, most developers end up stitching together three or four different asset store packages—one for toon foliage, one for custom outlines, and another for screen-space atmospheric effects. GIBLION: Anime-NPR-Toon Scene Generation Framework solves this fragmentation by unifying environment generation, NPR light-response shaders, custom VFX, and toon rendering passes into a cohesive architecture tailored specifically for Unity's Universal Render Pipeline (URP).

The core architecture operates around three main pillars:

• The Modular HLSL Lighting Library: A customized shader inclusion architecture that overrides URP's default UniversalFragmentPBR lighting calls with custom multi-tone ramp shading, specular high-light clamping, and screen-space depth-normal edge detection.
• Procedural Environment & Foliage Placement Engine: A CPU/GPU hybrid foliage scatter tool optimized via GPU Instancing and custom vertex animation for stylized wind displacement.
• NPR Post-Processing & Atmospheric Render Passes: Dedicated ScriptableRendererFeature passes injected directly into the URP frame graph to render volumetric anime clouds, dynamic outline passes, and stylized light shafts without ballooning pass execution times.

Core Technical Features & Highlights

1. Multi-Ramp Custom Lighting & Outline Shading

In my experience, standard toon shaders fail because they apply a uniform step function across all lighting conditions. GIBLION introduces a dynamic dual-ramp system. The primary ramp dictates direct light transition, while the ambient ramp maps secondary indirect bounced light using a custom tint gradient. Outlines are generated via a high-performance Screen-Space Depth-Normal Outline Pass rather than inverted-hull geometry, keeping vertex counts low on foliage-heavy scenes.

2. Stylized Foliage & Instanced Wind Displacement

Creating anime-style grass and tree canopies requires geometry that groups normals into soft, spherical clusters rather than pointing strictly outward from planar quad faces. GIBLION includes custom normal editing tools directly in the Unity Inspector, alongside custom vertex animation scripts. The shader uses a multi-frequency noise field to simulate gentle wind sweeps across entire valleys, completely offloading computation to the vertex shader stage.

3. Technical Specifications & Performance Benchmarks

Here is the key takeaway: GIBLION prioritizes performance budget efficiency alongside visual appeal. On a target baseline testing machine (NVIDIA GTX 1060 / Apple M1), raw performance measurements returned the following metrics:

• Pass Efficiency: The unified GiblionOutlineFeature adds less than 0.35ms of Render Thread cost at 1080p resolution.
• Batching Performance: Integrated custom foliage shaders reduced total Draw Calls from ~3,200 (unbatched static meshes) down to 142 SRP Batches using GPU Instancing and SRP Batcher support.
• Memory Footprint: Global toon ramp textures and noise fields are packed into single RGBA Channels, consuming under 18MB of VRAM overhead across an entire scene template.

Ideal Use Cases & Game Genres

While NPR looks are generally associated with open-world games, GIBLION is structured flexibly enough to serve multiple target genres:

• Stylized Action RPGs: Perfect for broad landscape views, vibrant grass fields, and character models requiring clean anime lighting and hard-edged shadow thresholds.
• Cozy Life Simulations & Farming Games: Provides the exact warm, painterly tone, soft sunbeams, and expressive skyboxes needed for low-stress, aesthetic environments.
• Cross-Platform Mobile Titles: Thanks to the low draw-call overhead and forward-rendered toon passes, developers targeting high-end iOS and Android devices can achieve console-quality anime visuals.
• Tactical Turn-Based RPGs: Compact combat arenas benefit greatly from the dynamic atmospheric volumetric particles and stylized depth-of-field post-processing.

Quick-Start Unity Setup & Integration Guide

Step 1: Pipeline Configuration

First, ensure your project is running Unity 2022.3 LTS or newer with the Universal Render Pipeline (URP) installed. Navigate to your project's UniversalRendererData asset in the Project window. Click Add Renderer Feature and attach the GiblionToonRenderFeature and GiblionOutlineFeature.

Step 2: Assigning Scene Environment Presets

Create a fresh scene, add a Directional Light, and assign the global environment controller. Attach the GiblionAtmosphereController component to a persistent manager GameObject. This script handles ambient lighting overrides, volumetric fog parameters, and toon ramp blending dynamically during runtime.

Step 3: Runtime C# Atmosphere & Shader Control Script

To dynamically transition lighting parameters (such as changing from mid-day bright anime lighting to warm golden-hour tones), you can drive GIBLION's material property blocks via code. Here is a practical C# controller implementation:

using UnityEngine;
using UnityEngine.Rendering;

[ExecuteAlways]
public class GiblionAtmosphereController : MonoBehaviour
{
    [Header("Global Lighting References")]
    [SerializeField] private Light mainDirectionalLight;
    [SerializeField] private Material globalToonEnvironmentMaterial;

    [Header("Anime Ramp Controls")]
    [SerializeField] private Color dayShadowTint = new Color(0.4f, 0.45f, 0.65f, 1.0f);
    [SerializeField] private Color sunsetShadowTint = new Color(0.7f, 0.3f, 0.4f, 1.0f);
    [Range(0f, 1f)] [SerializeField] private float toonRampThreshold = 0.5f;
    [Range(0.01f, 0.2f)] [SerializeField] private float toonRampSmoothness = 0.05f;

    [Header("Outline Configuration")]
    [SerializeField] private float outlineThickness = 1.2f;
    [SerializeField] private Color outlineColor = new Color(0.1f, 0.08f, 0.12f, 1.0f);

    private static readonly int ShadowTintID = Shader.PropertyToID("_BaseShadowTint");
    private static readonly int RampThresholdID = Shader.PropertyToID("_ToonRampThreshold");
    private static readonly int RampSmoothnessID = Shader.PropertyToID("_ToonRampSmoothness");
    private static readonly int OutlineThicknessID = Shader.PropertyToID("_OutlineThickness");
    private static readonly int OutlineColorID = Shader.PropertyToID("_OutlineColor");

    private void Update()
    {
        if (globalToonEnvironmentMaterial == null) return;

        // Apply shader properties globally across all GIBLION shaders
        Shader.SetGlobalFloat(RampThresholdID, toonRampThreshold);
        Shader.SetGlobalFloat(RampSmoothnessID, toonRampSmoothness);
        Shader.SetGlobalFloat(OutlineThicknessID, outlineThickness);
        Shader.SetGlobalColor(OutlineColorID, outlineColor);

        // Interpolate shadow tint based on main light rotation angle
        if (mainDirectionalLight != null)
        {
            float lightAngle = Vector3.Dot(mainDirectionalLight.transform.forward, Vector3.down);
            Color activeShadowColor = Color.Lerp(sunsetShadowTint, dayShadowTint, Mathf.Clamp01(lightAngle));
            Shader.SetGlobalColor(ShadowTintID, activeShadowColor);
        }
    }
}

Pros & Cons Assessment

Pros

• All-in-One Solution: Eliminates the headache of mixing incompatible outline render features, foliage shaders, and cloud systems.
• SRP Batcher Native: Shaders are carefully written to ensure full compatibility with Unity's SRP Batcher, dramatically reducing draw call overhead.
• Artist-Friendly Workflow: Material inspectors feature clear visual ramps, curve editors, and toggleable feature variants rather than obscure vector fields.
• High-Performance Outline Pass: Screen-space depth-normal approach avoids geometry duplication while preventing outline artifacts on thin geometry.

Cons

• URP Locked: High Definition Render Pipeline (HDRP) is not supported out of the box due to custom HLSL rendering pass dependencies.
• Custom Shader Graph Integration: Modifying the core master lighting node requires familiarity with custom HLSL inclusions rather than purely visual Shader Graph nodes.

Related Unity Tools Assets