Begin adding gimmicks for downstairs map

Included changes:

* Update LTCGI includes
* Add toggle to force world lighting
  * Unity fucking sucks dick and balls and doesn't set LIGHTMAP_ON
    consistently
* Add some more sdfs for raymarching
* Add separate LTCGI lighting mode for avatar vs. world

14 files changed, 762 insertions, 29 deletions

diff --git a/Editor/tooner.cs b/Editor/tooner.cs
index 60a5c2d..118c0fa 100644
--- a/Editor/tooner.cs
+++ b/Editor/tooner.cs
@@ -1802,6 +1802,118 @@ public class ToonerGUI : ShaderGUI {
     EditorGUI.indentLevel -= 1;
   }
 
+  void DoGimmickDownstairs2() {
+    MaterialProperty bc;
+    bc = FindProperty("_Gimmick_DS2_Enable_Static");
+    bool enabled = (bc.floatValue != 0.0);
+    EditorGUI.BeginChangeCheck();
+    enabled = Toggle("Downstairs 2", enabled);
+    EditorGUI.EndChangeCheck();
+    bc.floatValue = enabled ? 1.0f : 0.0f;
+    SetKeyword("_GIMMICK_DS2", enabled);
+
+    if (!enabled) {
+      return;
+    }
+
+    EditorGUI.indentLevel += 1;
+
+    bc = FindProperty("_Gimmick_DS2_Mask");
+    TexturePropertySingleLine(MakeLabel(bc, "Mask"), bc);
+    bc = FindProperty("_Gimmick_DS2_Noise");
+    TexturePropertySingleLine(MakeLabel(bc, "Noise"), bc);
+    bc = FindProperty("_Gimmick_DS2_Albedo_Factor");
+    FloatProperty(bc, "Albedo factor");
+    bc = FindProperty("_Gimmick_DS2_Emission_Factor");
+    FloatProperty(bc, "Emission factor");
+
+    bc = FindProperty("_Gimmick_DS2_00_Enable_Dynamic");
+    enabled = (bc.floatValue != 0.0);
+    EditorGUI.BeginChangeCheck();
+    enabled = Toggle("Enable effect 00", enabled);
+    EditorGUI.EndChangeCheck();
+    bc.floatValue = enabled ? 1.0f : 0.0f;
+
+    if (enabled) {
+      EditorGUI.indentLevel += 1;
+
+      bc = FindProperty("_Gimmick_DS2_00_Domain_Warping_Octaves");
+      FloatProperty(bc, "Domain warping octaves");
+      bc = FindProperty("_Gimmick_DS2_00_Domain_Warping_Strength");
+      FloatProperty(bc, "Domain warping strength");
+      bc = FindProperty("_Gimmick_DS2_00_Domain_Warping_Scale");
+      FloatProperty(bc, "Domain warping scale");
+      bc = FindProperty("_Gimmick_DS2_00_Domain_Warping_Speed");
+      FloatProperty(bc, "Domain warping speed");
+
+      EditorGUI.indentLevel -= 1;
+    }
+
+    bc = FindProperty("_Gimmick_DS2_01_Enable_Dynamic");
+    enabled = (bc.floatValue != 0.0);
+    EditorGUI.BeginChangeCheck();
+    enabled = Toggle("Enable effect 01", enabled);
+    EditorGUI.EndChangeCheck();
+    bc.floatValue = enabled ? 1.0f : 0.0f;
+
+    if (enabled) {
+      EditorGUI.indentLevel += 1;
+
+      bc = FindProperty("_Gimmick_DS2_01_Period");
+      VectorProperty(bc, "Period");
+      bc = FindProperty("_Gimmick_DS2_01_Count");
+      VectorProperty(bc, "Count");
+      bc = FindProperty("_Gimmick_DS2_01_Radius");
+      FloatProperty(bc, "Radius");
+
+      bc = FindProperty("_Gimmick_DS2_01_Domain_Warping_Octaves");
+      FloatProperty(bc, "Domain warping octaves");
+      bc = FindProperty("_Gimmick_DS2_01_Domain_Warping_Strength");
+      FloatProperty(bc, "Domain warping strength");
+      bc = FindProperty("_Gimmick_DS2_01_Domain_Warping_Scale");
+      FloatProperty(bc, "Domain warping scale");
+      bc = FindProperty("_Gimmick_DS2_01_Domain_Warping_Speed");
+      FloatProperty(bc, "Domain warping speed");
+
+      EditorGUI.indentLevel -= 1;
+    }
+
+    bc = FindProperty("_Gimmick_DS2_02_Enable_Dynamic");
+    enabled = (bc.floatValue != 0.0);
+    EditorGUI.BeginChangeCheck();
+    enabled = Toggle("Enable effect 02", enabled);
+    EditorGUI.EndChangeCheck();
+    bc.floatValue = enabled ? 1.0f : 0.0f;
+
+    if (enabled) {
+      EditorGUI.indentLevel += 1;
+
+      EditorGUI.indentLevel -= 1;
+    }
+
+    bc = FindProperty("_Gimmick_DS2_03_Enable_Dynamic");
+    enabled = (bc.floatValue != 0.0);
+    EditorGUI.BeginChangeCheck();
+    enabled = Toggle("Enable effect 03", enabled);
+    EditorGUI.EndChangeCheck();
+    bc.floatValue = enabled ? 1.0f : 0.0f;
+
+    if (enabled) {
+      EditorGUI.indentLevel += 1;
+
+      bc = FindProperty("_Gimmick_DS2_03_Period");
+      VectorProperty(bc, "Period");
+      bc = FindProperty("_Gimmick_DS2_03_Count");
+      VectorProperty(bc, "Count");
+      bc = FindProperty("_Gimmick_DS2_03_Edge_Length");
+      FloatProperty(bc, "Edge length");
+
+      EditorGUI.indentLevel -= 1;
+    }
+
+    EditorGUI.indentLevel -= 1;
+  }
+
   void DoGimmickHalo00() {
     MaterialProperty bc;
     bc = FindProperty("_Gimmick_Halo00_Enable_Static");
@@ -2473,6 +2585,7 @@ public class ToonerGUI : ShaderGUI {
     DoGimmickEyes00();
     DoGimmickEyes01();
     DoGimmickEyes02();
+    DoGimmickDownstairs2();
     DoGimmickHalo00();
     DoGimmickPixellate();
     DoGimmickTrochoid();
@@ -2963,6 +3076,14 @@ public class ToonerGUI : ShaderGUI {
       EditorGUI.indentLevel -= 1;
     }
 
+    bc = FindProperty("_Force_World_Lighting");
+    enabled = bc.floatValue > 1E-6;
+    EditorGUI.BeginChangeCheck();
+    enabled = Toggle("Force world lighting", enabled);
+    EditorGUI.EndChangeCheck();
+    bc.floatValue = enabled ? 1.0f : 0.0f;
+    SetKeyword("_FORCE_WORLD_LIGHTING", enabled);
+
     bc = FindProperty("_Aces_Filmic_Enable_Static");
     enabled = bc.floatValue > 1E-6;
     EditorGUI.BeginChangeCheck();
diff --git a/Third_Party/at.pimaker.ltcgi/Shaders/LTCGI.cginc b/Third_Party/at.pimaker.ltcgi/Shaders/LTCGI.cginc
index c6ad0b7..b976972 100644
--- a/Third_Party/at.pimaker.ltcgi/Shaders/LTCGI.cginc
+++ b/Third_Party/at.pimaker.ltcgi/Shaders/LTCGI.cginc
@@ -41,9 +41,8 @@ void LTCGI_Evaluate(ltcgi_input input, float3 worldNorm, float3 viewDir, float3x
         {
             if (!input.flags.lmdOnly) {
                 // very approximate lol
-                float3 ctr = (input.Lw[0] + input.Lw[1])/2;
-                float dist = length(ctr);
-                if (dist > LTCGI_DISTANCE_FADE_APPROX_MULT)
+                float3 ctr = (input.Lw[0] + input.Lw[1]) * 0.5f;
+                if (dot(ctr, ctr) > LTCGI_DISTANCE_FADE_APPROX_MULT * LTCGI_DISTANCE_FADE_APPROX_MULT)
                 {
                     return;
                 }
@@ -53,6 +52,7 @@ void LTCGI_Evaluate(ltcgi_input input, float3 worldNorm, float3 viewDir, float3x
 
     #define RET1_IF_LMDIFF [branch] if (/*const*/ diffuse && input.flags.diffFromLm) { output.intensity = 1.0f; return; }
 
+    [branch]
     if (input.flags.colormode == LTCGI_COLORMODE_SINGLEUV) {
         float2 uv = input.uvStart;
         if (uv.x < 0) uv.xy = uv.yx;
@@ -69,6 +69,7 @@ void LTCGI_Evaluate(ltcgi_input input, float3 worldNorm, float3 viewDir, float3x
     }
 
     #ifdef LTCGI_AUDIOLINK
+        [branch]
         if (input.flags.colormode == LTCGI_COLORMODE_AUDIOLINK) {
             float al = AudioLinkData(ALPASS_AUDIOLINK + uint2(0, input.flags.alBand)).r;
             output.color *= al;
@@ -133,6 +134,7 @@ void LTCGI_Evaluate(ltcgi_input input, float3 worldNorm, float3 viewDir, float3x
     LTCGI_ClipQuadToHorizon(L, n);
 
     // early out if everything was clipped below horizon
+    [branch]
     if (n == 0)
         return;
 
@@ -140,15 +142,20 @@ void LTCGI_Evaluate(ltcgi_input input, float3 worldNorm, float3 viewDir, float3x
     L[1] = normalize(L[1]);
     L[2] = normalize(L[2]);
     L[3] = normalize(L[3]);
-    L[4] = normalize(L[4]);
 
-    // integrate (and pray that constant folding works well)
+    // integrate
     float sum = 0;
-    [unroll(5)]
-    for (uint v = 0; v < max(3, (uint)n); v++) {
-        float3 a = L[v];
-        float3 b = L[(v + 1) % 5];
-        sum += LTCGI_IntegrateEdge(a, b).z;
+    sum += LTCGI_IntegrateEdge(L[0], L[1]).z;
+    sum += LTCGI_IntegrateEdge(L[1], L[2]).z;
+    sum += LTCGI_IntegrateEdge(L[2], L[3]).z;
+    [branch]
+    if (n >= 4)
+    {
+        L[4] = normalize(L[4]);
+        sum += LTCGI_IntegrateEdge(L[3], L[4]).z;
+        [branch]
+        if (n == 5)
+            sum += LTCGI_IntegrateEdge(L[4], L[0]).z;
     }
 
     // doublesided is accounted for with optimization at the start, so return abs
@@ -172,6 +179,15 @@ void LTCGI_Contribution(
         totalSpecularIntensity = 0;
         totalDiffuseIntensity = 0;
     #endif
+
+    #ifdef LTCGI_SPECULAR_OFF
+        specular = 0;
+    #endif
+    #ifdef LTCGI_DIFFUSE_OFF
+        diffuse = 0;
+    #endif
+
+    [branch]
     if (_Udon_LTCGI_GlobalEnable == 0.0f) {
         return;
     }
@@ -181,10 +197,6 @@ void LTCGI_Contribution(
     float2 uv = float2(roughness, theta/(0.5*UNITY_PI));
     uv = uv*LUT_SCALE + LUT_BIAS;
 
-    #ifndef UNITY_UV_STARTS_AT_TOP
-        uv.y = 1 - uv.y;
-    #endif
-
     // calculate LTCGI custom lightmap UV and sample
     float3 lms = LTCGI_SampleShadowmap(lmuv);
 
@@ -210,9 +222,12 @@ void LTCGI_Contribution(
     Minv = mul(Minv, identityBrdf);
 
     // specular brightness
+    float spec_amp = 1.0f;
     #ifndef LTCGI_SPECULAR_OFF
+    #ifndef LTCGI_DISABLE_LUT2
     #ifndef SHADER_TARGET_SURFACE_ANALYSIS_MOJOSHADER
-        float spec_amp = _Udon_LTCGI_lut2.SampleLevel(LTCGI_SAMPLER, uv, 0).x;
+        spec_amp = _Udon_LTCGI_lut2.SampleLevel(LTCGI_SAMPLER, uv, 0).x;
+    #endif
     #endif
     #endif
 
@@ -231,8 +246,14 @@ void LTCGI_Contribution(
     #endif
 
     // loop through all lights and add them to the output
+#if MAX_SOURCES != 1
     uint count = min(_Udon_LTCGI_ScreenCount, MAX_SOURCES);
     [loop]
+#else
+    // mobile config
+    const uint count = 1;
+    [unroll(1)]
+#endif
     for (uint i = 0; i < count; i++) {
         // skip masked and black lights
         if (_Udon_LTCGI_Mask[i]) continue;
@@ -298,6 +319,7 @@ void LTCGI_Contribution(
                         lmd = smoothstep(0.0, LTCGI_SPECULAR_LIGHTMAP_STEP, saturate(lm - LTCGI_LIGHTMAP_CUTOFF));
                 }
                 ltcgi_output diff;
+                diff.color = 0;
                 LTCGI_Evaluate(input, worldNorm, viewDir, identityBrdf, roughness, true, diff);
                 diff.intensity *= lmd;
 
@@ -317,6 +339,7 @@ void LTCGI_Contribution(
             if (flags.specular)
             {
                 ltcgi_output spec;
+                spec.color = 0;
                 LTCGI_Evaluate(input, worldNorm, viewDir, Minv, roughness, false, spec);
                 spec.intensity *= spec_amp * smoothstep(0.0, LTCGI_SPECULAR_LIGHTMAP_STEP, saturate(lm - LTCGI_LIGHTMAP_CUTOFF));
 
@@ -336,14 +359,16 @@ void LTCGI_Contribution(
 
 #ifndef LTCGI_API_V2
 
+// missing totalSpecularIntensity, totalDiffuseIntensity, specular
 void LTCGI_Contribution(
     float3 worldPos, float3 worldNorm, float3 viewDir, float roughness, float2 lmuv, inout half3 diffuse
 ) {
-    half3 _u1;
+    half3 _u1 = (half3)0;
     float _u2, _u3;
     LTCGI_Contribution(worldPos, worldNorm, viewDir, roughness, lmuv, diffuse, _u1, _u2, _u3);
 }
 
+// missing totalSpecularIntensity, totalDiffuseIntensity
 void LTCGI_Contribution(
     float3 worldPos, float3 worldNorm, float3 viewDir, float roughness, float2 lmuv, inout half3 diffuse, inout half3 specular
 ) {
@@ -351,6 +376,7 @@ void LTCGI_Contribution(
     LTCGI_Contribution(worldPos, worldNorm, viewDir, roughness, lmuv, diffuse, specular, _u1, _u2);
 }
 
+// missing totalDiffuseIntensity
 void LTCGI_Contribution(
     float3 worldPos, float3 worldNorm, float3 viewDir, float roughness, float2 lmuv, inout half3 diffuse, inout half3 specular, out float totalSpecularIntensity
 ) {
diff --git a/Third_Party/at.pimaker.ltcgi/Shaders/LTCGI_config.cginc b/Third_Party/at.pimaker.ltcgi/Shaders/LTCGI_config.cginc
index 1ddb38a..e64f5a3 100644
--- a/Third_Party/at.pimaker.ltcgi/Shaders/LTCGI_config.cginc
+++ b/Third_Party/at.pimaker.ltcgi/Shaders/LTCGI_config.cginc
@@ -73,7 +73,7 @@ const float LUT_BIAS = 0.5/LUT_SIZE;
 #define LTCGI_STATIC_UNIFORMS
 
 // Allow statically textured lights.
-//#define LTCGI_STATIC_TEXTURES
+#define LTCGI_STATIC_TEXTURES
 
 // Enable support for cylindrical screens.
 //#define LTCGI_CYLINDER
diff --git a/Third_Party/at.pimaker.ltcgi/Shaders/LTCGI_functions.cginc b/Third_Party/at.pimaker.ltcgi/Shaders/LTCGI_functions.cginc
index ff33c87..08df1c7 100644
--- a/Third_Party/at.pimaker.ltcgi/Shaders/LTCGI_functions.cginc
+++ b/Third_Party/at.pimaker.ltcgi/Shaders/LTCGI_functions.cginc
@@ -138,16 +138,28 @@ half3 premul_alpha(half4 i)
     return i.rgb * i.a;
 }
 
+half max2(half2 v)
+{
+    return max(v.x, v.y);
+}
+
 void LTCGI_sample(float2 uv, uint lod, uint idx, float blend, out float3 result)
 {
+#ifndef LTCGI_STATIC_TEXTURES
+    idx = 0; // optimize away the branches below
+#endif
+
 #ifdef LTCGI_FAST_SAMPLING
     #ifndef SHADER_TARGET_SURFACE_ANALYSIS
-        blend *= 2.5f;
+        float outside = max2(abs(uv - 0.5f) - 0.5f);
+        float outmod = smoothstep(-0.1f, 0.1f, outside) * 2.5f;
+        blend = blend * 2.5f + outmod;
         [branch]
         if (idx == 0)
         {
             result = premul_alpha(_Udon_LTCGI_Texture_LOD0.SampleLevel(LTCGI_SAMPLER, uv, blend));
         }
+        #ifdef LTCGI_STATIC_TEXTURES
         else
         {
             result = UNITY_SAMPLE_TEX2DARRAY_SAMPLER_LOD(
@@ -157,14 +169,12 @@ void LTCGI_sample(float2 uv, uint lod, uint idx, float blend, out float3 result)
                     blend
                 ).rgb;
         }
+        #endif
     #else
         result = 0;
     #endif
 #else
     result = 0;
-    #ifndef LTCGI_STATIC_TEXTURES
-    idx = 0; // optimize away the branches below
-    #endif
 
     [branch]
     if (lod == 0)
@@ -191,6 +201,7 @@ void LTCGI_sample(float2 uv, uint lod, uint idx, float blend, out float3 result)
                 return;
                 #endif
             }
+            #ifdef LTCGI_STATIC_TEXTURES
             else
             {
                 result = premul_alpha(UNITY_SAMPLE_TEX2DARRAY_SAMPLER_LOD(
@@ -201,6 +212,7 @@ void LTCGI_sample(float2 uv, uint lod, uint idx, float blend, out float3 result)
                 ));
                 return;
             }
+            #endif
         }
     }
 
@@ -227,6 +239,7 @@ void LTCGI_sample(float2 uv, uint lod, uint idx, float blend, out float3 result)
         return;
         #endif
     }
+    #ifdef LTCGI_STATIC_TEXTURES
     else
     {
         [forcecase]
@@ -258,6 +271,7 @@ void LTCGI_sample(float2 uv, uint lod, uint idx, float blend, out float3 result)
                 return;
         }
     }
+    #endif
 #endif
 }
 
diff --git a/Third_Party/at.pimaker.ltcgi/Shaders/LTCGI_shadowmap.cginc b/Third_Party/at.pimaker.ltcgi/Shaders/LTCGI_shadowmap.cginc
index 922c567..2c4a598 100644
--- a/Third_Party/at.pimaker.ltcgi/Shaders/LTCGI_shadowmap.cginc
+++ b/Third_Party/at.pimaker.ltcgi/Shaders/LTCGI_shadowmap.cginc
@@ -25,7 +25,7 @@ float4 LTCGI_cubic(float v)
 // Unity's SampleTexture2DBicubic doesn't exist in 2018, which is our target here.
 // So this is a similar function with tweaks to have similar semantics. 
 
-float4 LTCGI_SampleTexture2DBicubicFilter(Texture2D tex, SamplerState smp, float2 coord, float4 texSize)
+float4 LTCGI_SampleTexture2DBicubicFilter(Texture2D tex, SamplerState smp, float2 coord, float4 texSize, bool lightmap = false)
 {
     coord = coord * texSize.xy - 0.5;
     float fx = frac(coord.x);
@@ -45,6 +45,13 @@ float4 LTCGI_SampleTexture2DBicubicFilter(Texture2D tex, SamplerState smp, float
     float4 sample2 = tex.Sample(smp, float2(offset.x, offset.w) * texSize.zw);
     float4 sample3 = tex.Sample(smp, float2(offset.y, offset.w) * texSize.zw);
 
+    if (lightmap) {
+        sample0 = float4(DecodeLightmap(sample0), 1.0);
+        sample1 = float4(DecodeLightmap(sample1), 1.0);
+        sample2 = float4(DecodeLightmap(sample2), 1.0);
+        sample3 = float4(DecodeLightmap(sample3), 1.0);
+    }
+
     float sx = s.x / (s.x + s.y);
     float sy = s.z / (s.z + s.w);
 
@@ -68,10 +75,12 @@ float4 LTCGI_SampleShadowmap(float2 lmuv)
 
             return LTCGI_SampleTexture2DBicubicFilter(
                 _Udon_LTCGI_Lightmap, LTCGI_SAMPLER,
-                lmuv, _Udon_LTCGI_Lightmap_TexelSize
+                lmuv, _Udon_LTCGI_Lightmap_TexelSize,
+                true
             );
         #else
-            return _Udon_LTCGI_Lightmap.Sample(LTCGI_SAMPLER, lmuv);
+            fixed4 sample = _Udon_LTCGI_Lightmap.Sample(LTCGI_SAMPLER, lmuv);
+            return float4(DecodeLightmap(sample), 1.0);
         #endif
     #endif
 }
diff --git a/Third_Party/at.pimaker.ltcgi/Shaders/LTCGI_uniform.cginc b/Third_Party/at.pimaker.ltcgi/Shaders/LTCGI_uniform.cginc
index 116cedd..2bf4673 100644
--- a/Third_Party/at.pimaker.ltcgi/Shaders/LTCGI_uniform.cginc
+++ b/Third_Party/at.pimaker.ltcgi/Shaders/LTCGI_uniform.cginc
@@ -10,7 +10,9 @@ SamplerState sampler_LTCGI_trilinear_clamp_sampler;
 
 // LUTs
 #ifndef SHADER_TARGET_SURFACE_ANALYSIS_MOJOSHADER
+#ifndef LTCGI_DISABLE_LUT2
 uniform Texture2D<float4> _Udon_LTCGI_lut2;
+#endif
 uniform Texture2D<float4> _Udon_LTCGI_lut1;
 #endif
 
@@ -120,12 +122,14 @@ uniform Texture2D<float4> _Udon_LTCGI_Texture_LOD3;
 #endif
 
 // static textures
+#ifdef LTCGI_STATIC_TEXTURES
 UNITY_DECLARE_TEX2DARRAY_NOSAMPLER(_Udon_LTCGI_Texture_LOD0_arr);
 #ifndef LTCGI_FAST_SAMPLING
 UNITY_DECLARE_TEX2DARRAY_NOSAMPLER(_Udon_LTCGI_Texture_LOD1_arr);
 UNITY_DECLARE_TEX2DARRAY_NOSAMPLER(_Udon_LTCGI_Texture_LOD2_arr);
 UNITY_DECLARE_TEX2DARRAY_NOSAMPLER(_Udon_LTCGI_Texture_LOD3_arr);
 #endif
+#endif
 
 // lightmap
 #ifndef SHADER_TARGET_SURFACE_ANALYSIS_MOJOSHADER
diff --git a/downstairs_02.cginc b/downstairs_02.cginc
new file mode 100644
index 0000000..844731c
--- /dev/null
+++ b/downstairs_02.cginc
@@ -0,0 +1,439 @@
+#include "atrix256.cginc"
+#include "globals.cginc"
+#include "interpolators.cginc"
+#include "iq_sdf.cginc"
+#include "math.cginc"
+#include "oklab.cginc"
+
+#ifndef __DOWNSTAIRS_02_INC
+#define __DOWNSTAIRS_02_INC
+
+#if defined(_GIMMICK_DS2)
+
+// All gimmicks here return this structure.
+struct Gimmick_DS2_Output {
+  float4 albedo;
+  float3 emission;
+  float3 normal;
+  float3 worldPos;
+  float metallic;
+  float roughness;
+};
+
+
+float ds2_00_distance_from_sphere(float3 p, float3 c, float r)
+{
+  return length(p - c) - r;
+}
+
+float ds2_00_map(float3 p, out float which)
+{
+  float t = _Time.y;
+  float theta = sin(_Time[0]) / 2;
+  float2x2 rot = float2x2(
+    cos(theta), -sin(theta),
+    sin(theta), cos(theta));
+
+  which = 0;
+  float dist = 1000 * 1000 * 1000;
+  #define Y_STEPS 5
+  for (int y = 0; y < Y_STEPS; y++)
+  {
+    const int yy = y - Y_STEPS/2;
+    #define X_STEPS 5
+    for (int x = 0; x < X_STEPS; x++)
+    {
+      const int xx = x - X_STEPS/2;
+      float2 pp = float2(xx * 2, yy * 2);
+      pp = mul(rot, pp);
+      float radius = cos((x + y + _Time[0]) * 3.14159) * 0.5 + 1;
+      float sphere = ds2_00_distance_from_sphere(p, float3(pp.x, pp.y, 0.0), radius);
+      which = lerp(which, y * Y_STEPS + x, sphere < dist);
+      dist = min(dist, sphere);
+      dist += sin(5.0 * pp.x) * sin(5.0 * pp.y) * 0.5;
+    }
+  }
+
+  return dist;
+}
+
+float3 ds2_00_calc_normal(in float3 p)
+{
+  const float3 small_step = float3(1E-4, 0.0, 0.0);
+
+  float which;
+  float center = ds2_00_map(p, which);
+  float gradient_x = ds2_00_map(p + small_step.xyy, which) - center;
+  float gradient_y = ds2_00_map(p + small_step.yxy, which) - center;
+  float gradient_z = ds2_00_map(p + small_step.yyx, which) - center;
+
+  float3 normal = float3(gradient_x, gradient_y, gradient_z);
+
+  return normalize(normal);
+}
+
+bool __ds2_00_march(float3 ro, float3 rd, inout float3 normal, out float which)
+{
+  float total_distance_traveled = 0.0;
+  const float MINIMUM_HIT_DISTANCE = 0.001;
+  const float MAXIMUM_TRACE_DISTANCE = 1000.0;
+
+  #define DS2_00_MARCH_STEPS 10
+  float distance_to_closest;
+  float3 current_position;
+  for (int i = 0; i < DS2_00_MARCH_STEPS; i++)
+  {
+      current_position = ro + total_distance_traveled * rd;
+
+      distance_to_closest = ds2_00_map(current_position, which);
+
+      if (distance_to_closest < MINIMUM_HIT_DISTANCE) 
+      {
+        break;
+      }
+
+      if (total_distance_traveled > MAXIMUM_TRACE_DISTANCE)
+      {
+          break;
+      }
+      total_distance_traveled += distance_to_closest;
+  }
+
+  if (distance_to_closest < MINIMUM_HIT_DISTANCE) {
+    normal = ds2_00_calc_normal(current_position);
+    return true;
+  }
+
+  return false;
+}
+
+Gimmick_DS2_Output Gimmick_DS2_00(v2f i)
+{
+  float2 uv = i.uv0;
+  uv *= 2;
+  uv -= 1;
+  float2 warping_speed_vector = normalize(float2(97, 101));
+  for (uint ii = 0; ii < _Gimmick_DS2_00_Domain_Warping_Octaves; ii++)
+  {
+      float2 noise = _Gimmick_DS2_Noise.SampleLevel(linear_repeat_s, uv * _Gimmick_DS2_00_Domain_Warping_Scale + _Time[0] * _Gimmick_DS2_00_Domain_Warping_Speed * warping_speed_vector, 0);
+      uv += noise * _Gimmick_DS2_00_Domain_Warping_Strength;
+  }
+
+  float3 camera_position = float3(0.0, 0.0, -5.0);
+  float3 ro = camera_position;
+  float3 rd = float3(uv.x, uv.y, 1.0);
+
+  float3 normal;
+  float which;
+  bool hit = __ds2_00_march(ro, rd, normal, which);
+
+  float3 shaded_color = LRGBtoOKLCH(float3(0.7, 0, 0));
+  shaded_color[2] = which * TAU * 1.1 + _Time[1];
+  shaded_color = OKLCHtoLRGB(shaded_color);
+  
+  shaded_color *= hit;
+
+  Gimmick_DS2_Output o;
+  o.albedo = float4(shaded_color * 5, 1.0);
+  o.emission = shaded_color;
+  o.normal = normal;
+  o.metallic = 0;
+  o.roughness = 1;
+  o.worldPos = i.worldPos;
+  return o;
+}
+
+float ds2_01_map(float3 p)
+{
+  p.z -= _Gimmick_DS2_01_Radius;
+  return distance_from_sphere(p, _Gimmick_DS2_01_Radius);
+}
+
+float3 ds2_01_nudge_p(float3 p, float3 e)
+{
+  return p + sin(e*TAU+_Time[0]*4) * _Gimmick_DS2_01_Radius * .5;
+}
+
+float ds2_01_map_dr(
+    float3 p,
+    float3 period,
+    float3 count,
+    out float3 which
+    )
+{
+  which = round(p / period);
+  // Direction to nearest neighboring cell.
+  float3 min_d = p - period * which;
+  float3 o = sign(min_d);
+
+  float d = 1E9;
+  float3 which_tmp = which;
+  for (uint xi = 0; xi < 2; xi++)
+  for (uint yi = 0; yi < 2; yi++)
+  {
+    float3 rid = which + float3(xi, yi, 0) * o;
+    rid = clamp(rid, ceil(-(count)*0.5), floor((count-1)*0.5));
+    float3 r = p - period * rid;
+    float3 e = float3(
+        rand3(rid / 100.0),
+        rand3(rid / 100.0 + 1),
+        rand3(rid / 100.0 + 2));
+    r = ds2_01_nudge_p(r, e);
+    float cur_d = ds2_01_map(r);
+    which_tmp = cur_d < d ? rid : which_tmp;
+    d = min(d, cur_d);
+  }
+
+  which = which_tmp;
+  return d;
+}
+
+
+float3 ds2_01_calc_normal(float3 p, float3 period, float3 count)
+{
+  const float3 small_step = float3(1E-5, 0.0, 0.0);
+  float3 which;
+  float center = ds2_01_map_dr(p, period, count, which);
+  return normalize(float3(
+    ds2_01_map_dr(p + small_step.xyz, period, count, which) - center,
+    ds2_01_map_dr(p + small_step.zxy, period, count, which) - center,
+    ds2_01_map_dr(p + small_step.yzx, period, count, which) - center
+  ));
+}
+
+Gimmick_DS2_Output Gimmick_DS2_01(inout v2f i)
+{
+  float3 camera_position = mul(unity_WorldToObject, float4(_WorldSpaceCameraPos, 1));
+  float3 ro = i.objPos;
+  float3 rd = normalize(i.objPos - camera_position);
+
+  float2 warping_speed_vector = normalize(float2(97, 101));
+  for (uint ii = 0; ii < _Gimmick_DS2_01_Domain_Warping_Octaves; ii++)
+  {
+      float2 noise = _Gimmick_DS2_Noise.SampleLevel(linear_repeat_s, ro.xy * _Gimmick_DS2_01_Domain_Warping_Scale + _Time[0] * _Gimmick_DS2_01_Domain_Warping_Speed * warping_speed_vector, 0);
+      ro.xy += noise * _Gimmick_DS2_01_Domain_Warping_Strength;
+  }
+
+#define DS2_01_MARCH_STEPS 8
+  float total_distance_traveled = 0.0;
+  const float MINIMUM_HIT_DISTANCE = 1E-4;
+  const float MAXIMUM_TRACE_DISTANCE = 30.0;
+  float distance_to_closest;
+  float3 which;
+  for (uint ii = 0; ii < DS2_01_MARCH_STEPS; ii++)
+  {
+    float3 current_position = ro + total_distance_traveled * rd;
+    distance_to_closest = ds2_01_map_dr(current_position, 
+      _Gimmick_DS2_01_Period.xyz, _Gimmick_DS2_01_Count.xyz, which);
+    total_distance_traveled += distance_to_closest;
+    if (distance_to_closest < MINIMUM_HIT_DISTANCE || 
+        total_distance_traveled > MAXIMUM_TRACE_DISTANCE) {
+      break;
+    }
+  }
+
+  float3 normal = i.normal;
+  bool hit = distance_to_closest < MINIMUM_HIT_DISTANCE;
+  float3 color = LRGBtoOKLCH(float3(0.7, 0, 0));
+  color[0] += _Gimmick_DS2_Noise.SampleLevel(linear_repeat_s, ((which.xy / _Gimmick_DS2_01_Count.xy) + _Time[0]) / 10, 0);
+  color[2] = ign(which.xy + _Gimmick_DS2_01_Count.xy) * TAU * .1;
+  color[2] += _Gimmick_DS2_Noise.SampleLevel(linear_repeat_s, ((which.xy / _Gimmick_DS2_01_Count.xy) + _Time[0]) / 100, 0) * 5;
+  color = OKLCHtoLRGB(color);
+  if (hit) {
+    normal = ds2_01_calc_normal(ro + total_distance_traveled * rd, 
+      _Gimmick_DS2_01_Period.xyz, _Gimmick_DS2_01_Count.xyz);
+    normal = UnityObjectToWorldNormal(normal);
+  }
+
+  Gimmick_DS2_Output o;
+  o.albedo = hit ? float4(color, 1) : 0;
+  o.emission = o.albedo;
+  o.normal = normal;
+  o.metallic = 0;
+  o.roughness = 0;
+  o.worldPos = i.worldPos;
+  return o;
+}
+
+float ds2_02_map(float3 p, out float which)
+{
+  float depth = .2;
+  which = 0;
+
+  // Create frame for lights.
+  float d0 = distance_from_box(p - float3(0, 0, depth), float3(.50, .50, depth));
+  float d1 = distance_from_box(p - float3(0, 0, 0), float3(.45, .45, depth));
+  float d2 = op_sub(d1, d0);
+
+  // Create lights.
+  float light_spacing = .12;
+  float d3 = d2;
+  which = -1;
+  for (uint i = 0; i < 3; i++) {
+    float d4 = distance_from_capped_cylinder(abs(p) - float3(i * light_spacing + light_spacing * .5, .45, depth * .5), .05, .03);
+    d3 = min(d3, d4);
+  }
+  for (uint i = 0; i < 3; i++) {
+    float d4 = distance_from_cylinder(abs(p) - float3(i * light_spacing + light_spacing * .5, 0, depth * .5), float3(0, 0, .025));
+    which = d4 < d3 ? ((int) i + 1) * 2 + (sign(p.x) > 0 ? 1 : 0) : which;
+    d3 = min(d3, d4);
+  }
+
+  return d3;
+}
+
+float3 ds2_02_calc_normal(float3 p)
+{
+  float3 small_step = float3(1E-5, 0.0, 0.0);
+  float which;
+  float center = ds2_02_map(p, which);
+  return normalize(float3(
+    ds2_02_map(p + small_step.xyz, which) - center,
+    ds2_02_map(p + small_step.zxy, which) - center,
+    ds2_02_map(p + small_step.yzx, which) - center
+  ));
+}
+
+Gimmick_DS2_Output Gimmick_DS2_02(inout v2f i)
+{
+  float3 camera_position = mul(unity_WorldToObject, float4(_WorldSpaceCameraPos, 1));
+  float3 ro = i.objPos;
+  float3 rd = normalize(i.objPos - camera_position);
+
+  #define DS2_02_MARCH_STEPS 30
+  float total_distance_traveled = 0.0;
+  const float MINIMUM_HIT_DISTANCE = 1E-3;
+  const float MAXIMUM_TRACE_DISTANCE = 30.0;
+  float distance_to_closest;
+  float which;
+  for (uint ii = 0; ii < DS2_02_MARCH_STEPS; ii++)
+  {
+    float3 current_position = ro + total_distance_traveled * rd;
+    distance_to_closest = ds2_02_map(current_position, which);
+    total_distance_traveled += distance_to_closest;
+    if (distance_to_closest < MINIMUM_HIT_DISTANCE || 
+        total_distance_traveled > MAXIMUM_TRACE_DISTANCE) {
+      break;
+    }
+  }
+
+  float3 normal = i.normal;
+  bool hit = distance_to_closest < MINIMUM_HIT_DISTANCE;
+  float3 color = (which == -1 ? 0.01 : 1.5);
+  if (hit) {
+    normal = ds2_02_calc_normal(ro + total_distance_traveled * rd);
+    normal = UnityObjectToWorldNormal(normal);
+  }
+
+  Gimmick_DS2_Output o;
+  o.albedo = hit ? float4(color, 1) : 0;
+  o.emission = color;
+  o.normal = normal;
+  o.metallic = 0;
+  o.roughness = 0.3;
+  o.worldPos = mul(unity_ObjectToWorld, float4(ro + total_distance_traveled * rd, 1));
+  return o;
+}
+
+float ds2_03_map(float3 p)
+{
+  float edge = _Gimmick_DS2_03_Edge_Length;
+  float thickness = edge*10;
+  return distance_from_round_box(p - float3(0, 0, thickness*.99), float3(edge, edge, thickness), edge * .1);
+}
+
+float3 ds2_03_nudge_p(float3 p, float3 which)
+{
+  float noise = _Gimmick_DS2_Noise.SampleLevel(linear_repeat_s, which.xy * _Gimmick_DS2_03_Period.xy * .2 + _Time[0] * .1, 0);
+  return p - float3(0, 0, noise * .01);
+  //return p + sin(e*TAU+_Time[0]*4) * _Gimmick_DS2_03_Edge_Length * .2 - noise;
+  //return p;
+}
+
+float ds2_03_map_dr(
+    float3 p,
+    float3 period,
+    float3 count,
+    out float3 which
+    )
+{
+  which = round(p / period);
+  // Direction to nearest neighboring cell.
+  float3 min_d = p - period * which;
+  float3 o = sign(min_d);
+
+  float d = 1E9;
+  float3 which_tmp = which;
+  for (uint xi = 0; xi < 2; xi++)
+  for (uint yi = 0; yi < 2; yi++)
+  {
+    float3 rid = which + float3(xi, yi, 0) * o;
+    rid = clamp(rid, ceil(-(count)*0.5), floor((count-1)*0.5));
+    float3 r = p - period * rid;
+    r = ds2_03_nudge_p(r, rid);
+    float cur_d = ds2_03_map(r);
+    which_tmp = cur_d < d ? rid : which_tmp;
+    d = min(d, cur_d);
+  }
+
+  which = which_tmp;
+  return d;
+}
+
+float3 ds2_03_calc_normal(float3 p)
+{
+  float3 small_step = float3(1E-5, 0.0, 0.0);
+  float3 which;
+  float center = ds2_03_map_dr(p, _Gimmick_DS2_03_Period.xyz, _Gimmick_DS2_03_Count.xyz, which);
+  return normalize(float3(
+    ds2_03_map_dr(p + small_step.xyz, _Gimmick_DS2_03_Period.xyz, _Gimmick_DS2_03_Count.xyz, which) - center,
+    ds2_03_map_dr(p + small_step.zxy, _Gimmick_DS2_03_Period.xyz, _Gimmick_DS2_03_Count.xyz, which) - center,
+    ds2_03_map_dr(p + small_step.yzx, _Gimmick_DS2_03_Period.xyz, _Gimmick_DS2_03_Count.xyz, which) - center
+  ));
+}
+
+Gimmick_DS2_Output Gimmick_DS2_03(inout v2f i)
+{
+  float3 camera_position = mul(unity_WorldToObject, float4(_WorldSpaceCameraPos, 1));
+  float3 ro = i.objPos;
+  float3 rd = normalize(i.objPos - camera_position);
+
+  #define DS2_03_MARCH_STEPS 30
+  float total_distance_traveled = 0.0;
+  const float MINIMUM_HIT_DISTANCE = 1E-3;
+  const float MAXIMUM_TRACE_DISTANCE = 30.0;
+  float distance_to_closest;
+  float3 which;
+  for (uint ii = 0; ii < DS2_03_MARCH_STEPS; ii++)
+  {
+    float3 current_position = ro + total_distance_traveled * rd;
+    distance_to_closest = ds2_03_map_dr(current_position, _Gimmick_DS2_03_Period.xyz, _Gimmick_DS2_03_Count.xyz, which);
+    total_distance_traveled += distance_to_closest;
+    if (distance_to_closest < MINIMUM_HIT_DISTANCE || 
+        total_distance_traveled > MAXIMUM_TRACE_DISTANCE) {
+      break;
+    }
+  }
+
+  bool hit = distance_to_closest < MINIMUM_HIT_DISTANCE;
+  float3 normal = hit ? UnityObjectToWorldNormal(ds2_03_calc_normal(ro + total_distance_traveled * rd)) : i.normal;
+
+  float3 light_dir = normalize(float3(0.5, -0.5, -0.5));
+  float3 light_color = float3(1, 1, 1);
+  float ndotl = saturate(dot(normal, light_dir));
+  float wrap_factor = 0.5;
+  float4 wrapped = pow(max(1E-4, (ndotl + wrap_factor) / (1 + wrap_factor)), 1 + wrap_factor);
+  float3 light_intensity = light_color * wrapped;
+
+  Gimmick_DS2_Output o;
+  o.albedo = hit ? float4(light_intensity, 1) : 0;
+  o.emission = o.albedo;
+  o.normal = normal;
+  o.metallic = 0;
+  o.roughness = 0;
+  o.worldPos = mul(unity_ObjectToWorld, float4(ro + total_distance_traveled * rd, 1));
+  return o;
+}
+
+#endif  // _GIMMICK_DS2
+#endif  // __DOWNSTAIRS_02_INC
diff --git a/feature_macros.cginc b/feature_macros.cginc
index 3c358fb..2502ebd 100644
--- a/feature_macros.cginc
+++ b/feature_macros.cginc
@@ -225,6 +225,7 @@
 #pragma shader_feature_local _ _DECAL9_MASK
 #pragma shader_feature_local _ _DECAL9_DOMAIN_WARPING
 #pragma shader_feature_local _ _LTCGI
+#pragma shader_feature_local _ _FORCE_WORLD_LIGHTING
 #pragma shader_feature_local _ _TESSELLATION
 #pragma shader_feature_local _ _MATCAP0_DISTORTION0
 #pragma shader_feature_local _ _MATCAP1_DISTORTION0
@@ -237,6 +238,7 @@
 #pragma shader_feature_local _ _GIMMICK_EYES_00
 #pragma shader_feature_local _ _GIMMICK_EYES_01
 #pragma shader_feature_local _ _GIMMICK_EYES_02
+#pragma shader_feature_local _ _GIMMICK_DS2
 #pragma shader_feature_local _ _GIMMICK_HALO_00
 #pragma shader_feature_local _ _PIXELLATE
 #pragma shader_feature_local _ _TROCHOID
diff --git a/globals.cginc b/globals.cginc
index f63453b..40e216d 100644
--- a/globals.cginc
+++ b/globals.cginc
@@ -756,6 +756,36 @@ float _Gimmick_Eyes02_Roughness;
 float3 _Gimmick_Eyes02_Emission;
 #endif
 
+#if defined(_GIMMICK_DS2)
+float _Gimmick_DS2_Enable_Static;
+texture2D _Gimmick_DS2_Mask;
+texture2D _Gimmick_DS2_Noise;
+// 00
+float _Gimmick_DS2_00_Enable_Dynamic;
+float _Gimmick_DS2_Albedo_Factor;
+float _Gimmick_DS2_Emission_Factor;
+float _Gimmick_DS2_00_Domain_Warping_Octaves;
+float _Gimmick_DS2_00_Domain_Warping_Strength;
+float _Gimmick_DS2_00_Domain_Warping_Scale;
+float _Gimmick_DS2_00_Domain_Warping_Speed;
+// 01
+float _Gimmick_DS2_01_Enable_Dynamic;
+float4 _Gimmick_DS2_01_Period;
+float4 _Gimmick_DS2_01_Count;
+float _Gimmick_DS2_01_Radius;
+float _Gimmick_DS2_01_Domain_Warping_Octaves;
+float _Gimmick_DS2_01_Domain_Warping_Strength;
+float _Gimmick_DS2_01_Domain_Warping_Scale;
+float _Gimmick_DS2_01_Domain_Warping_Speed;
+// 02
+float _Gimmick_DS2_02_Enable_Dynamic;
+// 03
+float _Gimmick_DS2_03_Enable_Dynamic;
+float4 _Gimmick_DS2_03_Period;
+float4 _Gimmick_DS2_03_Count;
+float _Gimmick_DS2_03_Edge_Length;
+#endif
+
 #if defined(_PIXELLATE)
 float _Gimmick_Pixellate_Enable_Static;
 float _Gimmick_Pixellate_Resolution_U;
diff --git a/iq_sdf.cginc b/iq_sdf.cginc
index 6320e57..fa5f2c5 100644
--- a/iq_sdf.cginc
+++ b/iq_sdf.cginc
@@ -56,6 +56,12 @@ float distance_from_box(float3 p, float3 b)
   return length(max(q,0.0)) + min(max(q.x,max(q.y,q.z)),0.0);
 }
 
+float distance_from_round_box(float3 p, float3 b, float r)
+{
+  float3 q = abs(p) - b + r;
+  return length(max(q,0.0)) + min(max(q.x,max(q.y,q.z)),0.0) - r;
+}
+
 float distance_from_box_frame(float3 p, float3 b, float e)
 {
   p = abs(p)-b;
@@ -97,11 +103,27 @@ float distance_from_plane(float3 p, float3 n, float h)
   return dot(p,n) + h;
 }
 
+float distance_from_cylinder(float3 p, float3 c)
+{
+  return length(p.xz-c.xy)-c.z;
+}
+
+float distance_from_capped_cylinder(float3 p, float h, float r)
+{
+  float2 d = abs(float2(length(p.xz),p.y)) - float2(r,h);
+  return min(max(d.x,d.y),0.0) + length(max(d,0.0));
+}
+
 float3 op_rep(in float3 p, in float3 c)
 {
   return glsl_mod(p+0.5*c,c)-0.5*c;
 }
 
+float op_sub(float d1, float d2)
+{
+  return max(-d1,d2);
+}
+
 // End licensed section
 
 #endif  // __IQ_SDF_INC
diff --git a/oklab.cginc b/oklab.cginc
index 004dbc4..0a354f3 100644
--- a/oklab.cginc
+++ b/oklab.cginc
@@ -29,7 +29,7 @@
 #ifndef __OKLAB_INC
 #define __OKLAB_INC
 
-#if defined(_OKLAB) || defined(_GIMMICK_LETTER_GRID_COLOR_WAVE) || defined(_GIMMICK_AL_CHROMA_00_HUE_SHIFT) || defined(_GIMMICK_FOG_00)
+#if defined(_OKLAB) || defined(_GIMMICK_LETTER_GRID_COLOR_WAVE) || defined(_GIMMICK_AL_CHROMA_00_HUE_SHIFT) || defined(_GIMMICK_FOG_00) || defined(_GIMMICK_DS2)
 
 // Utilities relating to the OKLAB color space, as defined here:
 //   https://bottosson.github.io/posts/oklab/
diff --git a/pbr.cginc b/pbr.cginc
index 8dda05d..c839dcc 100644
--- a/pbr.cginc
+++ b/pbr.cginc
@@ -245,7 +245,8 @@ float4 getLitColor(
     direct_light.color *= (1 - e);
   }
 
-#if 0 && defined(_LTCGI)
+#if defined(_LTCGI)
+#if !defined(LIGHTMAP_ON) && !defined(_FORCE_WORLD_LIGHTING)
   ltcgi_acc acc = (ltcgi_acc) 0;
   if (_LTCGI_Enabled_Dynamic) {
     LTCGI_Contribution(
@@ -259,6 +260,7 @@ float4 getLitColor(
     indirect_light.specular += acc.specular;
   }
 #endif
+#endif
 
 #if defined(_BRIGHTNESS_CLAMP) || defined(_PROXIMITY_DIMMING)
   direct_light.color = RGBtoHSV(direct_light.color);
@@ -382,7 +384,8 @@ float4 getLitColor(
 #endif
 
 
-#if 1 && defined(_LTCGI)
+#if defined(_LTCGI)
+#if defined(LIGHTMAP_ON) || defined(_FORCE_WORLD_LIGHTING)
   ltcgi_acc acc = (ltcgi_acc) 0;
   if (_LTCGI_Enabled_Dynamic) {
     LTCGI_Contribution(
@@ -392,9 +395,10 @@ float4 getLitColor(
         view_dir,
         1.0 - smoothness,
         i.uv2);
-    pbr.rgb += acc.diffuse * pbr.rgb + acc.specular;
+    pbr.rgb += (acc.diffuse * pbr.rgb + acc.specular) * albedo.a;
   }
 #endif
+#endif
 
   // TODO formalize with parameters
   // Break up color banding by adding some dithering to shaded color.
diff --git a/tooner.shader b/tooner.shader
index 025e7b1..fe6627c 100644
--- a/tooner.shader
+++ b/tooner.shader
@@ -3,7 +3,7 @@ Shader "yum_food/tooner"
   // Unity fucking sucks ass and sometimes incorrectly uses an old cached
   // version of the shader. Bump the nonce below to encourage it to use the
   // current version.
-  // Build nonce: 34
+  // Build nonce: 35
   Properties
   {
     _Color("Base color", Color) = (0.8, 0.8, 0.8, 1)
@@ -733,6 +733,8 @@ Shader "yum_food/tooner"
     _LTCGI_SpecularColor("LTCGI specular color", Color) = (1, 1, 1, 1)
     _LTCGI_DiffuseColor("LTCGI diffuse color", Color) = (1, 1, 1, 1)
 
+    _Force_World_Lighting("Force world lighting", Float) = 0.0
+
     _Cutout_Mode("Cutout rendering mode", Float) = 0.0
     _Render_Queue_Offset("Render queue offset", Integer) = 0
 
@@ -794,6 +796,35 @@ Shader "yum_food/tooner"
     _Gimmick_Eyes02_Roughness ("Roughness", Range(0, 1)) = 0.5
     _Gimmick_Eyes02_Emission ("Emission", Color) = (0, 0, 0, 1)
 
+    _Gimmick_DS2_Enable_Static  ("Enable (static)", Float) = 0
+    _Gimmick_DS2_Noise  ("Noise", 2D) = "black" {}
+    _Gimmick_DS2_Mask("Mask", 2D) = "white" {}
+    _Gimmick_DS2_Albedo_Factor("Albedo factor", Float) = 1
+    _Gimmick_DS2_Emission_Factor("Emission factor", Float) = 1
+    // Effect 00
+    _Gimmick_DS2_00_Enable_Dynamic("Enable effect 00 (dynamic)", Float) = 0
+    _Gimmick_DS2_00_Domain_Warping_Octaves("Domain warping octaves", Float) = 3
+    _Gimmick_DS2_00_Domain_Warping_Strength("Domain warping strength", Float) = 1
+    _Gimmick_DS2_00_Domain_Warping_Scale("Domain warping scale", Float) = 1
+    _Gimmick_DS2_00_Domain_Warping_Speed("Domain warping speed", Float) = 1
+    // Effect 01
+    _Gimmick_DS2_01_Enable_Dynamic("Enable effect 01 (dynamic)", Float) = 0
+    _Gimmick_DS2_01_Period("Period", Vector) = (1, 1, 1, 1)
+    _Gimmick_DS2_01_Count("Count", Vector) = (1, 1, 1, 1)
+    _Gimmick_DS2_01_Radius("Radius", Float) = 1
+    _Gimmick_DS2_01_Domain_Warping_Octaves("Domain warping octaves", Float) = 3
+    _Gimmick_DS2_01_Domain_Warping_Strength("Domain warping strength", Float) = 1
+    _Gimmick_DS2_01_Domain_Warping_Scale("Domain warping scale", Float) = 1
+    _Gimmick_DS2_01_Domain_Warping_Speed("Domain warping speed", Float) = 1
+    // Effect 02
+    _Gimmick_DS2_02_Enable_Dynamic("Enable effect 02 (dynamic)", Float) = 0
+    // Effect 03
+    _Gimmick_DS2_03_Enable_Dynamic("Enable effect 03 (dynamic)", Float) = 0
+    _Gimmick_DS2_03_Period("Period", Vector) = (1, 1, 1, 1)
+    _Gimmick_DS2_03_Count("Count", Vector) = (1, 1, 1, 1)
+    _Gimmick_DS2_03_Edge_Length("Edge length", Float) = 0.1
+
+
     _Gimmick_Halo00_Enable_Static("Enable halo", Float) = 0.0
 
     _Gimmick_Pixellate_Enable_Static("Enable pixellation", Float) = 0.0
@@ -986,6 +1017,7 @@ Shader "yum_food/tooner"
         "RenderType"="Opaque"
         "Queue"="Geometry"
         "LightMode"="ForwardBase"
+        "LTCGI"="ALWAYS"
       }
       Blend [_SrcBlend] [_DstBlend]
       ZWrite [_ZWrite]
@@ -1018,6 +1050,7 @@ Shader "yum_food/tooner"
       #include "tooner_lighting.cginc"
       ENDCG
     }
+    /*
     Pass {
       Tags {
         "RenderType"="Opaque"
@@ -1099,6 +1132,7 @@ Shader "yum_food/tooner"
       #include "mochie_shadow_caster.cginc"
 			ENDCG
 		}
+    */
   }
   CustomEditor "ToonerGUI"
 }
diff --git a/tooner_lighting.cginc b/tooner_lighting.cginc
index 7224152..21d97b0 100644
--- a/tooner_lighting.cginc
+++ b/tooner_lighting.cginc
@@ -7,6 +7,7 @@
 #include "clones.cginc"
 #include "cnlohr.cginc"
 #include "disinfo.cginc"
+#include "downstairs_02.cginc"
 #include "eyes.cginc"
 #include "fog.cginc"
 #include "gerstner.cginc"
@@ -2747,6 +2748,30 @@ float4 effect(inout v2f i, out float depth)
   albedo.rgb += glitter_color_unlit * _Glitter_Brightness_Lit;
 #endif
 
+#if defined(_GIMMICK_DS2)
+  Gimmick_DS2_Output ds2 = (Gimmick_DS2_Output)0;
+  // TODO if these remain mutually exclusive, we should use an enum + switch
+  if (_Gimmick_DS2_00_Enable_Dynamic) {
+    ds2 = Gimmick_DS2_00(i);
+  } else if (_Gimmick_DS2_01_Enable_Dynamic) {
+    ds2 = Gimmick_DS2_01(i);
+  } else if (_Gimmick_DS2_02_Enable_Dynamic) {
+    ds2 = Gimmick_DS2_02(i);
+  } else if (_Gimmick_DS2_03_Enable_Dynamic) {
+    ds2 = Gimmick_DS2_03(i);
+  }
+  float ds2_mask = _Gimmick_DS2_Mask.SampleLevel(linear_clamp_s, i.uv0, 0);
+  albedo = ds2.albedo * _Gimmick_DS2_Albedo_Factor * ds2_mask;
+  normal = ds2.normal;
+  metallic = ds2.metallic;
+  roughness = ds2.roughness;
+  i.worldPos = ds2.worldPos;
+  {
+    float4 clip_pos = mul(UNITY_MATRIX_VP, float4(ds2.worldPos, 1.0));
+    depth = clip_pos.z / clip_pos.w;
+  }
+#endif
+
   float4 lit = getLitColor(vertex_light_color, albedo, i.worldPos, normal,
       metallic, 1.0 - roughness, i.uv0, ao, /*enable_direct=*/true,
       diffuse_contrib, i, tdata);
@@ -2778,6 +2803,9 @@ float4 effect(inout v2f i, out float depth)
 #if defined(_GLITTER)
   result.rgb += glitter_color_unlit * _Glitter_Brightness;
 #endif
+#if defined(_GIMMICK_DS2)
+  result.rgb += ds2.emission * _Gimmick_DS2_Emission_Factor * ds2_mask;
+#endif
 
 #if defined(_ACES_FILMIC)
   result.rgb = aces_filmic(max(result.rgb, 0));