wip : Liminal spaces + Tidy up

2026-05-22 11:59:09 +01:00
parent a47cebc99b
commit cb0bcb5df3
76 changed files with 7438 additions and 15195 deletions
@@ -0,0 +1,221 @@
+Shader "Custom/Glitch"
+{
+    Properties
+    {
+        [Header(Fracture)]
+        _FractureAmount ("Fracture Amount", Range(0,1)) = 0.0
+        _CellScale ("Cell Scale", Float) = 8.0
+        _CellDisplace ("Cell Displacement", Range(0,0.1)) = 0.05
+        _CellRotation ("Cell Rotation", Range(0,1)) = 0.3
+
+        [Header(Depth Echoes)]
+        _EchoCount ("Echo Count", Range(0,8)) = 4.0
+        _EchoScale ("Echo Scale", Range(0,0.15)) = 0.06
+        _EchoOpacity ("Echo Opacity", Range(0,1)) = 0.4
+        _EchoSpread ("Echo Spread", Range(0,0.5)) = 0.15
+
+        [Header(Chromatic Aberration)]
+        _ChromaAmount ("Chromatic Aberration", Range(0,0.05)) = 0.01
+
+        [Header(Edge Darkening)]
+        _EdgeDarken ("Edge Darken", Range(0,1)) = 0.5
+        _EdgePower ("Edge Power", Float) = 2.0
+
+        [Header(Glitch Lines)]
+        _GlitchStrength ("Glitch Line Strength", Range(0,1)) = 0.3
+        _GlitchScale ("Glitch Line Scale", Float) = 40.0
+    }
+
+    SubShader
+    {
+        Tags { "RenderType"="Opaque" "RenderPipeline"="UniversalPipeline" }
+        ZWrite Off ZTest Always Cull Off
+
+        Pass
+        {
+            Name "CorridorFracturePass"
+
+            HLSLPROGRAM
+            #pragma vertex Vert
+            #pragma fragment Frag
+            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
+            #include "Packages/com.unity.render-pipelines.core/Runtime/Utilities/Blit.hlsl"
+
+            float _FractureAmount;
+            float _CellScale;
+            float _CellDisplace;
+            float _CellRotation;
+            float _EchoCount;
+            float _EchoScale;
+            float _EchoOpacity;
+            float _EchoSpread;
+            float _ChromaAmount;
+            float _EdgeDarken;
+            float _EdgePower;
+            float _GlitchStrength;
+            float _GlitchScale;
+
+            // ─── NOISE / HASH ─────────────────────────────────────────
+
+            float2 Hash22(float2 p)
+            {
+                p = float2(dot(p, float2(127.1, 311.7)),
+                           dot(p, float2(269.5, 183.3)));
+                return frac(sin(p) * 43758.5453);
+            }
+
+            float Hash11(float p)
+            {
+                return frac(sin(p * 127.1) * 43758.5453);
+            }
+
+            float SmoothNoise(float2 p)
+            {
+                float2 i = floor(p);
+                float2 f = frac(p);
+                f = f * f * (3.0 - 2.0 * f);
+                float a = frac(sin(dot(i,               float2(127.1, 311.7))) * 43758.5453);
+                float b = frac(sin(dot(i + float2(1,0), float2(127.1, 311.7))) * 43758.5453);
+                float c = frac(sin(dot(i + float2(0,1), float2(127.1, 311.7))) * 43758.5453);
+                float d = frac(sin(dot(i + float2(1,1), float2(127.1, 311.7))) * 43758.5453);
+                return lerp(lerp(a, b, f.x), lerp(c, d, f.x), f.y);
+            }
+
+            // ─── VORONOI ──────────────────────────────────────────────
+
+            // Retourne (distance au point le plus proche, id de la cellule)
+            float2 Voronoi(float2 uv, float scale)
+            {
+                float2 scaledUV = uv * scale;
+                float2 i = floor(scaledUV);
+                float2 f = frac(scaledUV);
+
+                float minDist = 8.0;
+                float2 minCell = float2(0, 0);
+
+                for (int y = -1; y <= 1; y++)
+                {
+                    for (int x = -1; x <= 1; x++)
+                    {
+                        float2 neighbor = float2(x, y);
+                        float2 cellId   = i + neighbor;
+                        float2 cellPoint = Hash22(cellId) + neighbor;
+                        float  dist      = length(cellPoint - f);
+
+                        if (dist < minDist)
+                        {
+                            minDist  = dist;
+                            minCell  = cellId;
+                        }
+                    }
+                }
+
+                return float2(minDist, Hash11(minCell.x * 73.1 + minCell.y * 191.7));
+            }
+
+            // ─── ROTATION UV ─────────────────────────────────────────
+
+            float2 RotateUV(float2 uv, float2 center, float angle)
+            {
+                float2 d = uv - center;
+                float  s = sin(angle);
+                float  c = cos(angle);
+                return center + float2(d.x * c - d.y * s, d.x * s + d.y * c);
+            }
+
+            // ─── SAMPLE AVEC CHROMATIC ABERRATION ────────────────────
+
+            half3 SampleChroma(float2 uv, float strength)
+            {
+                float2 dir    = (uv - 0.5) * strength;
+                half   r      = SAMPLE_TEXTURE2D(_BlitTexture, sampler_LinearClamp, uv + dir).r;
+                half   g      = SAMPLE_TEXTURE2D(_BlitTexture, sampler_LinearClamp, uv).g;
+                half   b      = SAMPLE_TEXTURE2D(_BlitTexture, sampler_LinearClamp, uv - dir).b;
+                return half3(r, g, b);
+            }
+
+            // ─── FRAGMENT ────────────────────────────────────────────
+
+            half4 Frag(Varyings input) : SV_Target
+            {
+                float2 uv = input.texcoord;
+
+                // Rien à faire si fracture = 0
+                if (_FractureAmount <= 0.001)
+                    return SAMPLE_TEXTURE2D(_BlitTexture, sampler_LinearClamp, uv);
+
+                float t = _FractureAmount;
+
+                // ── 1. Cellules Voronoi ───────────────────────────────
+                // L'échelle des cellules augmente avec t : plus on avance,
+                // plus les fragments sont nombreux et petits.
+                float dynamicScale = _CellScale * (1.0 + t * 3.0);
+                float2 voronoi     = Voronoi(uv, dynamicScale);
+                float  cellDist    = voronoi.x;
+                float  cellId      = voronoi.y;
+
+                // Déplacement UV par cellule — s'amplifie avec t
+                float2 cellOffset = (Hash22(float2(cellId * 17.3, cellId * 31.7)) - 0.5)
+                                    * _CellDisplace * t * 2.0;
+
+                // Rotation par cellule — s'amplifie avec t
+                float cellAngle = (cellId - 0.5) * _CellRotation * t * 3.14159 * 0.5;
+
+                float2 fracturedUV = RotateUV(uv + cellOffset, uv, cellAngle);
+                fracturedUV        = clamp(fracturedUV, 0.0, 1.0);
+
+                // ── 2. Glitch lines verticales ────────────────────────
+                // Des bandes verticales se décalent aléatoirement.
+                float glitchNoise = SmoothNoise(float2(uv.y * _GlitchScale, floor(_Time.y * 8.0)));
+                float glitchMask  = step(1.0 - t * _GlitchStrength, glitchNoise);
+                float glitchShift = (Hash11(floor(uv.y * _GlitchScale)) - 0.5) * 0.05 * t;
+                fracturedUV.x    += glitchShift * glitchMask;
+
+                // ── 3. Sample de base avec chromatic aberration ───────
+                float chromaStrength = _ChromaAmount * t;
+                half3 col            = SampleChroma(fracturedUV, chromaStrength);
+
+                // ── 4. Échos en profondeur ────────────────────────────
+                // Chaque écho est une copie de l'image contractée vers le centre,
+                // simulant une répétition infinie du couloir.
+                int echoCount = (int)ceil(_EchoCount * t);
+                echoCount     = clamp(echoCount, 0, 8);
+
+                for (int i = 1; i <= echoCount; i++)
+                {
+                    float  fi         = (float)i;
+                    float  echoT      = fi / (float)echoCount;
+
+                    // Contraction vers le centre — chaque écho est plus petit
+                    float  scale      = 1.0 - fi * _EchoScale;
+                    float2 echoUV     = (uv - 0.5) * scale + 0.5;
+
+                    // Décalage latéral alterné pour l'effet de dédoublement
+                    float  side       = (frac(fi * 0.5) > 0.25) ? 1.0 : -1.0;
+                    echoUV.x         += side * _EchoSpread * echoT * t;
+
+                    echoUV            = clamp(echoUV, 0.0, 1.0);
+
+                    // Opacité décroissante pour les échos lointains
+                    float  echoAlpha  = _EchoOpacity * (1.0 - echoT) * t;
+                    half3  echoCol    = SampleChroma(echoUV, chromaStrength * 0.5);
+
+                    col               = lerp(col, echoCol, echoAlpha * 0.4);
+                }
+
+                // ── 5. Assombrissement des bords de cellule ───────────
+                // Les fissures entre cellules sont sombres.
+                float crackMask = 1.0 - smoothstep(0.0, 0.15 * (1.0 - t * 0.5), cellDist);
+                col            *= 1.0 - crackMask * _EdgeDarken * t;
+
+                // ── 6. Vignette de bord d'écran ───────────────────────
+                float2 vigUV   = uv * (1.0 - uv.yx);
+                float  vignette = pow(vigUV.x * vigUV.y * 15.0, _EdgePower * (1.0 + t));
+                col            *= saturate(vignette);
+
+                return half4(col, 1.0);
+            }
+            ENDHLSL
+        }
+    }
+}