Add UV domain warping, box discard gimmicks

Also:

* optimize the ds2 terrain gimmick (ds2_11)
* use golden ratio + blue noise on marched fog
* add second sun to analytic fog
* fix gcd() implementation
* add faster rand2() implementation

12 files changed, 425 insertions, 110 deletions

diff --git a/Editor/tooner.cs b/Editor/tooner.cs
index a100027..f694e53 100644
--- a/Editor/tooner.cs
+++ b/Editor/tooner.cs
@@ -1547,6 +1547,48 @@ public class ToonerGUI : ShaderGUI {
     EditorGUI.indentLevel -= 1;
   }
 
+  void DoGimmickUVDomainWarping() {
+    MaterialProperty bc;
+    bc = FindProperty("_Gimmick_UV_Domain_Warping_Enable_Static");
+    bool enabled = (bc.floatValue != 0.0);
+    EditorGUI.BeginChangeCheck();
+    enabled = Toggle("UV domain warping", enabled);
+    EditorGUI.EndChangeCheck();
+    bc.floatValue = enabled ? 1.0f : 0.0f;
+    SetKeyword("_GIMMICK_UV_DOMAIN_WARPING", enabled);
+
+    if (!enabled) {
+      return;
+    }
+
+    EditorGUI.indentLevel += 1;
+
+    bc = FindProperty("_Gimmick_UV_Domain_Warping_Octaves");
+    FloatProperty(bc, "Octaves");
+    bc = FindProperty("_Gimmick_UV_Domain_Warping_Strength");
+    FloatProperty(bc, "Strength");
+    bc = FindProperty("_Gimmick_UV_Domain_Warping_Scale");
+    FloatProperty(bc, "Scale");
+    bc = FindProperty("_Gimmick_UV_Domain_Warping_Speed");
+    FloatProperty(bc, "Speed");
+    bc = FindProperty("_Gimmick_UV_Domain_Warping_Noise");
+    TexturePropertySingleLine(
+        MakeLabel(bc, "Noise"),
+        bc);
+    bc = FindProperty("_Gimmick_UV_Domain_Warping_Mask");
+    TexturePropertySingleLine(
+        MakeLabel(bc, "Mask"),
+        bc);
+    if (bc.textureValue) {
+      EditorGUI.indentLevel += 1;
+      bc = FindProperty("_Gimmick_UV_Domain_Warping_Mask_Invert");
+      FloatProperty(bc, "Invert");
+      EditorGUI.indentLevel -= 1;
+    }
+
+    EditorGUI.indentLevel -= 1;
+  }
+
   void DoGimmickQuantizeLocation() {
     MaterialProperty bc;
     bc = FindProperty("_Gimmick_Quantize_Location_Enable_Static");
@@ -1930,30 +1972,63 @@ public class ToonerGUI : ShaderGUI {
         ColorProperty(bc, "Fog color");
         bc = FindProperty("_Gimmick_DS2_11_Fog_Sun_Color");
         ColorProperty(bc, "Fog sun color");
+
+        bc = FindProperty("_Gimmick_DS2_11_Fog_Sun_Color_2_Enable");
+        enabled = (bc.floatValue != 0.0);
+        EditorGUI.BeginChangeCheck();
+        enabled = Toggle("Fog sun color 2 enable", enabled);
+        EditorGUI.EndChangeCheck();
+        bc.floatValue = enabled ? 1.0f : 0.0f;
+
+        if (enabled) {
+          bc = FindProperty("_Gimmick_DS2_11_Fog_Sun_Color_2");
+          ColorProperty(bc, "Fog sun color 2");
+          bc = FindProperty("_Gimmick_DS2_11_Fog_Sun_Exponent_2");
+          FloatProperty(bc, "Fog sun exponent 2");
+        }
       }
 
       bc = FindProperty("_Gimmick_DS2_11_Snow_Color");
       ColorProperty(bc, "Snow color");
       bc = FindProperty("_Gimmick_DS2_11_Snowline");
       FloatProperty(bc, "Snowline");
+      bc = FindProperty("_Gimmick_DS2_11_Snowline_Octaves");
+      FloatProperty(bc, "Snowline octaves");
       bc = FindProperty("_Gimmick_DS2_11_Snowline_Width");
       FloatProperty(bc, "Snowline width");
       bc = FindProperty("_Gimmick_DS2_11_Snowline_Noise_Scale");
       FloatProperty(bc, "Snowline noise scale");
+
       bc = FindProperty("_Gimmick_DS2_11_Rock_Color");
       ColorProperty(bc, "Rock color");
       bc = FindProperty("_Gimmick_DS2_11_Rockline");
       FloatProperty(bc, "Rockline");
+      bc = FindProperty("_Gimmick_DS2_11_Rockline_Octaves");
+      FloatProperty(bc, "Rockline octaves");
       bc = FindProperty("_Gimmick_DS2_11_Rockline_Width");
       FloatProperty(bc, "Rockline width");
       bc = FindProperty("_Gimmick_DS2_11_Rockline_Noise_Scale");
       FloatProperty(bc, "Rockline noise scale");
+
       bc = FindProperty("_Gimmick_DS2_11_Grass_Color");
       ColorProperty(bc, "Grass color");
       bc = FindProperty("_Gimmick_DS2_11_Alpha");
       RangeProperty(bc, "Alpha");
+
       bc = FindProperty("_Gimmick_DS2_11_XZ_Offset");
       VectorProperty(bc, "XZ offset");
+      bc = FindProperty("_Gimmick_DS2_11_Octaves");
+      FloatProperty(bc, "Octaves");
+      bc = FindProperty("_Gimmick_DS2_11_March_Initial_Offset");
+      FloatProperty(bc, "March initial offset");
+      bc = FindProperty("_Gimmick_DS2_11_March_Steps");
+      FloatProperty(bc, "March steps");
+      bc = FindProperty("_Gimmick_DS2_11_Simulation_Scale");
+      FloatProperty(bc, "Simulation scale");
+      bc = FindProperty("_Gimmick_DS2_11_Height_Scale");
+      FloatProperty(bc, "Height scale");
+      bc = FindProperty("_Gimmick_DS2_11_Early_Exit_Cutoff_Cos_Theta");
+      FloatProperty(bc, "Early exit cutoff (cos theta)");
 
       bc = FindProperty("_Gimmick_DS2_11_Distance_Culling_Enable");
       enabled = (bc.floatValue != 0.0);
@@ -1965,10 +2040,8 @@ public class ToonerGUI : ShaderGUI {
       if (enabled) {
         EditorGUI.indentLevel += 1;
 
-        bc = FindProperty("_Gimmick_DS2_11_Activation_Center");
-        VectorProperty(bc, "Activation center");
-        bc = FindProperty("_Gimmick_DS2_11_Activation_Radius");
-        FloatProperty(bc, "Activation radius");
+        bc = FindProperty("_Gimmick_DS2_11_Activation_Y");
+        FloatProperty(bc, "Activation Y");
 
         EditorGUI.indentLevel -= 1;
       }
@@ -2602,6 +2675,25 @@ public class ToonerGUI : ShaderGUI {
     ColorProperty(bc, "Sun color");
     bc = FindProperty("_Gimmick_Fog_01_Sun_Exponent");
     FloatProperty(bc, "Sun exponent");
+
+    bc = FindProperty("_Gimmick_Fog_01_Sun_Color_2_Enable");
+    enabled = (bc.floatValue != 0.0);
+    EditorGUI.BeginChangeCheck();
+    enabled = Toggle("Sun color 2", enabled);
+    EditorGUI.EndChangeCheck();
+    bc.floatValue = enabled ? 1.0f : 0.0f;
+
+    if (enabled) {
+      EditorGUI.indentLevel += 1;
+
+      bc = FindProperty("_Gimmick_Fog_01_Sun_Color_2");
+      ColorProperty(bc, "Color");
+      bc = FindProperty("_Gimmick_Fog_01_Sun_Exponent_2");
+      FloatProperty(bc, "Exponent");
+
+      EditorGUI.indentLevel -= 1;
+    }
+
     bc = FindProperty("_Gimmick_Fog_01_Distance_Culling_Enable");
     enabled = (bc.floatValue != 0.0);
     EditorGUI.BeginChangeCheck();
@@ -2620,6 +2712,13 @@ public class ToonerGUI : ShaderGUI {
       EditorGUI.indentLevel -= 1;
     }
 
+    bc = FindProperty("_Gimmick_Fog_01_Overlay_Mode");
+    enabled = (bc.floatValue != 0.0);
+    EditorGUI.BeginChangeCheck();
+    enabled = Toggle("Overlay mode", enabled);
+    EditorGUI.EndChangeCheck();
+    bc.floatValue = enabled ? 1.0f : 0.0f;
+
     EditorGUI.indentLevel -= 1;
   }
 
@@ -2725,12 +2824,46 @@ public class ToonerGUI : ShaderGUI {
 
     EditorGUI.indentLevel -= 1;
   }
+  
+  // Discard unless camera is inside this box.
+  void DoGimmickBoxDiscard() {
+    MaterialProperty bc;
+
+    bc = FindProperty("_Gimmick_Box_Discard_Enable_Static");
+    bool enabled = (bc.floatValue != 0.0);
+    EditorGUI.BeginChangeCheck();
+    enabled = Toggle("Box discard", enabled);
+    EditorGUI.EndChangeCheck();
+    bc.floatValue = enabled ? 1.0f : 0.0f;
+    SetKeyword("_GIMMICK_BOX_DISCARD", enabled);
+
+    if (!enabled) {
+      return;
+    }
+
+    EditorGUI.indentLevel += 1;
+
+    bc = FindProperty("_Gimmick_Box_Discard_Corner_1");
+    VectorProperty(bc, "Corner 1");
+    bc = FindProperty("_Gimmick_Box_Discard_Corner_2");
+    VectorProperty(bc, "Corner 2");
+
+    bc = FindProperty("_Gimmick_Box_Discard_Invert");
+    enabled = (bc.floatValue != 0.0);
+    EditorGUI.BeginChangeCheck();
+    enabled = Toggle("Invert", enabled);
+    EditorGUI.EndChangeCheck();
+    bc.floatValue = enabled ? 1.0f : 0.0f;
+
+    EditorGUI.indentLevel -= 1;
+  }
 
   void DoGimmicks() {
     show_ui.Add(AddCollapsibleMenu("Gimmicks", "_Gimmicks"));
     EditorGUI.indentLevel += 1;
 
     DoGimmickFlatColor();
+    DoGimmickUVDomainWarping();
     DoGimmickQuantizeLocation();
     DoGimmickShearLocation();
     DoGimmickSpherizeLocation();
@@ -2751,6 +2884,7 @@ public class ToonerGUI : ShaderGUI {
     DoGimmickFog1();
     DoGimmickAurora();
     DoGimmickGerstnerWater();
+    DoGimmickBoxDiscard();
     DoClones();
     DoExplosion();
     DoGeoScroll();
diff --git a/Textures/white.png.meta b/Textures/white.png.meta
index 74ac456..9e8caf0 100644
--- a/Textures/white.png.meta
+++ b/Textures/white.png.meta
@@ -5,7 +5,7 @@ TextureImporter:
   externalObjects: {}
   serializedVersion: 12
   mipmaps:
-    mipMapMode: 0
+    mipMapMode: 1
     enableMipMap: 1
     sRGBTexture: 1
     linearTexture: 0
diff --git a/audiolink.cginc b/audiolink.cginc
index 4a3f5f1..802f584 100644
--- a/audiolink.cginc
+++ b/audiolink.cginc
@@ -1,7 +1,7 @@
 #ifndef __AUDIOLINK
 #define __AUDIOLINK
 
-#if defined (_GIMMICK_QUANTIZE_LOCATION_AUDIOLINK) || defined(_GIMMICK_AL_CHROMA_00) || defined(_GIMMICK_FOG_00) || defined(_RENDERING_CUTOUT_IGN) || defined(_GIMMICK_DS2)
+#if defined (_GIMMICK_QUANTIZE_LOCATION_AUDIOLINK) || defined(_GIMMICK_AL_CHROMA_00) || defined(_GIMMICK_FOG_00) || defined(_RENDERING_CUTOUT) || defined(_GIMMICK_DS2)
 
 #include "Packages/com.llealloo.audiolink/Runtime/Shaders/AudioLink.cginc"
 
diff --git a/downstairs_02.cginc b/downstairs_02.cginc
index 53074b5..7896c7b 100644
--- a/downstairs_02.cginc
+++ b/downstairs_02.cginc
@@ -1,5 +1,6 @@
 #include "atrix256.cginc"
 #include "audiolink.cginc"
+#include "cnlohr.cginc"
 #include "globals.cginc"
 #include "fog.cginc"
 #include "interpolators.cginc"
@@ -657,37 +658,52 @@ Gimmick_DS2_Output Gimmick_DS2_03(inout v2f i)
 float ds2_11_height(float2 p)
 {
   float sc = .4;
-  float2 offset = _Time[0] * .00 + _Gimmick_DS2_11_XZ_Offset.xz;
-  //float t = 0;
+  float sc_rcp = 2.5;
+  float2 offset = _Gimmick_DS2_11_XZ_Offset.xz * _Gimmick_DS2_11_Simulation_Scale;
+
+  float2 pp = (p - offset) * sc_rcp;
+  p /= _Gimmick_DS2_11_Simulation_Scale;
+  pp /= _Gimmick_DS2_11_Simulation_Scale;
+#define _GIMMICK_DS2_11_TEXTURE_NOISE
+#if defined(_GIMMICK_DS2_11_TEXTURE_NOISE)
+  pp *= .01;
+#endif
 
   float h = 0;
-  float hsc = 2.0;
-  uint octaves = 11;
-  float corrective_term = 0;
-  float cur_factor = 1;
+  float hsc = _Gimmick_DS2_11_Height_Scale;
+  float sc_hsc = sc * hsc;
+  uint octaves = _Gimmick_DS2_11_Octaves;
   float alpha = _Gimmick_DS2_11_Alpha;
   float alpha_rcp = 1 / alpha;
-  //for (uint i = 0; i < octaves; i += sqrt(i+1)) {
+  float alpha_i = 1;
+  float alpha_rcp_i = 1;
   for (uint i = 0; i < octaves; i++) {
-    corrective_term += cur_factor;
-    h += _Gimmick_DS2_Noise.SampleLevel(linear_repeat_s, (p - offset) * .01 * pow(alpha_rcp, i) / sc, 0) * sc * hsc * cur_factor;
-    cur_factor *= alpha;
+#if defined(_GIMMICK_DS2_11_TEXTURE_NOISE)
+    // Combine components to increase precision.
+    float noise = _Gimmick_DS2_Noise.SampleLevel(linear_repeat_s, pp * alpha_rcp_i, 0);
+#else
+    float noise = perlin_noise(pp * alpha_rcp_i);
+#endif
+    h += noise * sc_hsc * alpha_i;
+    alpha_i *= alpha;
+    alpha_rcp_i *= alpha_rcp;
   }
-  h /= corrective_term;
+  // The sum of the series k^-i is 1 / (1 - k^-1)
+  h /= 1 / (1 - alpha);
+  h *= h;
 
   // `scale_factor` goes from [0, 1] based on radius.
-  float2 center = p + (float2(0, .05));
+  float2 center = p;
   float scale_factor = 1 - exp(-dot(center, center) * 16);
   h *= scale_factor;
-  h -= (1 - scale_factor) * sc * hsc * .15;
-  h += .015;
+  h = ((h - (1 - scale_factor) * sc_hsc * .15) + .015) * _Gimmick_DS2_11_Simulation_Scale;
 
   return h;
 }
 
 float3 ds2_11_calc_normal(float3 p)
 {
-  float epsilon = 4E-4;
+  float epsilon = 6E-4;
   return normalize(float3(
     ds2_11_height(p.xz - float2(epsilon, 0)) - ds2_11_height(p.xz + float2(epsilon, 0)),
     2 * epsilon,
@@ -699,23 +715,27 @@ Gimmick_DS2_Output Gimmick_DS2_11(inout v2f i, ToonerData tdata)
 {
   float3 camera_position = mul(unity_WorldToObject, float4(_WorldSpaceCameraPos, 1));
   float3 rd = normalize(i.objPos - camera_position);
-  float3 ro = camera_position + rd * 1E-2;
+  float3 ro = camera_position + rd * _Gimmick_DS2_11_March_Initial_Offset * _Gimmick_DS2_11_Simulation_Scale;
+
+// 180 degrees is pi radians
+// (d/180)*pi
+  [branch]
+  //if (dot(rd, UnityObjectToWorldNormal(float3(0, 1, 0))) > cos((60/180)*PI)) {
+  if (dot(rd, UnityObjectToWorldNormal(float3(0, 1, 0))) > _Gimmick_DS2_11_Early_Exit_Cutoff_Cos_Theta) {
+    return (Gimmick_DS2_Output)0;
+  }
 
   [branch]
   if (_Gimmick_DS2_11_Distance_Culling_Enable) {
-    float3 activation_center = _Gimmick_DS2_11_Activation_Center;
-    float activation_radius = _Gimmick_DS2_11_Activation_Radius;
-    float cur_radius = length(_WorldSpaceCameraPos - activation_center);
+    float activation_y = _Gimmick_DS2_11_Activation_Y;
     [branch]
-    //if (cur_radius > activation_radius) {
-    if (_WorldSpaceCameraPos.y > activation_center.y + activation_radius) {
+    if (getCenterCamPos().y > activation_y) {
       return (Gimmick_DS2_Output)0;
     }
   }
 
-  #define DS2_11_MARCH_STEPS 20
   float t = 0.0;
-  float dt0 = 0.002;
+  float dt0 = 0.01 * _Gimmick_DS2_11_Simulation_Scale;
   float dt = dt0;
   // last height, last y
   float lh = 0;
@@ -723,46 +743,50 @@ Gimmick_DS2_Output Gimmick_DS2_11(inout v2f i, ToonerData tdata)
 
   // https://iquilezles.org/articles/terrainmarching/
   bool hit = false;
-  for (uint ii = 0; ii < DS2_11_MARCH_STEPS; ii++) {
-    float3 p = ro + rd * t;
-    float h = ds2_11_height(p.xz);
+  float3 p;
+  float h;
+  for (uint ii = 0; ii < _Gimmick_DS2_11_March_Steps; ii++) {
+    p = ro + rd * t;
+    h = ds2_11_height(p.xz);
     if (p.y < h) {
-      t = t - dt + dt * (lh - ly) / (p.y - ly - h + lh);
-      hit = true;
       break;
     }
     t += dt;
-    dt = dt0 * ii;
+    dt = dt0 * (ii+1);
     lh = h;
     ly = p.y;
   }
+  if (p.y < h) {
+    hit = true;
+    t = t - dt + dt * (lh - ly) / (p.y - ly - h + lh);
+  }
 
-  float3 final_pos = ro + t * rd;
+  float3 final_pos = ro + t * rd + (1 - hit) * rd * 1E2;
   float3 final_pos_world = mul(unity_ObjectToWorld, float4(final_pos, 1));
   float4 final_color = 1;
 
   float snowline_noise = 0;
   float alpha = 0.6;
   float alpha_rcp = 1 / alpha;
-  for (uint ii = 0; ii < 8; ii++) {
+  for (uint ii = 0; ii < _Gimmick_DS2_11_Snowline_Octaves; ii++) {
     snowline_noise += _Gimmick_DS2_Noise.SampleLevel(linear_repeat_s, final_pos.xz * _Gimmick_DS2_11_Snowline_Noise_Scale * pow(alpha_rcp, ii), 0) * pow(alpha, ii);
   }
-  float snowline = snowline_noise * _Gimmick_DS2_11_Snowline_Width - _Gimmick_DS2_11_Snowline;
+  float snowline = (snowline_noise - _Gimmick_DS2_11_Snowline) * _Gimmick_DS2_11_Snowline_Width;
   float rockline_noise = 0;
-  for (uint ii = 0; ii < 8; ii++) {
+  for (uint ii = 0; ii < _Gimmick_DS2_11_Rockline_Octaves; ii++) {
     rockline_noise += _Gimmick_DS2_Noise.SampleLevel(linear_repeat_s, final_pos.xz * _Gimmick_DS2_11_Rockline_Noise_Scale * pow(alpha_rcp, ii), 0) * pow(alpha, ii);
   }
-  float rockline = rockline_noise * _Gimmick_DS2_11_Rockline_Width - _Gimmick_DS2_11_Rockline;
+  float rockline = (rockline_noise - _Gimmick_DS2_11_Rockline) * _Gimmick_DS2_11_Rockline_Width;
 
   final_color.rgb = lerp(
+    _Gimmick_DS2_11_Grass_Color,
     _Gimmick_DS2_11_Rock_Color,
-    _Gimmick_DS2_11_Snow_Color,
-    saturate(final_pos_world.y - snowline));
+    saturate(final_pos_world.y - rockline));
 
   final_color.rgb = lerp(
-    _Gimmick_DS2_11_Grass_Color,
     final_color.rgb,
-    saturate(final_pos_world.y - rockline));
+    _Gimmick_DS2_11_Snow_Color,
+    saturate(final_pos_world.y - snowline));
 
   final_color *= hit;
 
@@ -770,20 +794,19 @@ Gimmick_DS2_Output Gimmick_DS2_11(inout v2f i, ToonerData tdata)
   [branch]
   if (_Gimmick_DS2_11_Fog_Enable) {
     fog = apply_fog(
-        length(final_pos_world - _WorldSpaceCameraPos),
+        length(final_pos_world.xyz - _WorldSpaceCameraPos.xyz),
         _Gimmick_DS2_11_Fog_Density,
         UnityObjectToWorldNormal(rd),
         normalize(_Gimmick_DS2_11_Fog_Sun_Direction),
         _Gimmick_DS2_11_Fog_Sun_Color,
         _Gimmick_DS2_11_Fog_Sun_Exponent,
+        _Gimmick_DS2_11_Fog_Sun_Color_2_Enable,
+        _Gimmick_DS2_11_Fog_Sun_Color_2,
+        _Gimmick_DS2_11_Fog_Sun_Exponent_2,
         _Gimmick_DS2_11_Fog_Color) * hit;
   }
 
   float3 normal = UnityObjectToWorldNormal(ds2_11_calc_normal(final_pos));
-  //normal = MY_BLEND_NORMALS(float3(0, 1, 0), normal, hit);
-  //normal = float3(0, 1, 0);
-  //normal = MY_BLEND_NORMALS(normal, float3(0, 1, 0), fog.a);
-
   Gimmick_DS2_Output o;
   o.albedo = final_color;
   o.emission = 0;
diff --git a/feature_macros.cginc b/feature_macros.cginc
index 502491e..a06128d 100644
--- a/feature_macros.cginc
+++ b/feature_macros.cginc
@@ -231,6 +231,7 @@
 #pragma shader_feature_local _ _MATCAP1_DISTORTION0
 #pragma shader_feature_local _ _AMBIENT_OCCLUSION
 #pragma shader_feature_local _ _GIMMICK_FLAT_COLOR
+#pragma shader_feature_local _ _GIMMICK_UV_DOMAIN_WARPING
 #pragma shader_feature_local _ _GIMMICK_QUANTIZE_LOCATION
 #pragma shader_feature_local _ _GIMMICK_QUANTIZE_LOCATION_AUDIOLINK
 #pragma shader_feature_local _ _GIMMICK_SHEAR_LOCATION
@@ -276,6 +277,7 @@
 #pragma shader_feature_local _ _GIMMICK_GERSTNER_WATER
 #pragma shader_feature_local _ _GIMMICK_GERSTNER_WATER_OCTAVE_1
 #pragma shader_feature_local _ _GIMMICK_GERSTNER_WATER_COLOR_RAMP
+#pragma shader_feature_local _ _GIMMICK_BOX_DISCARD
 #pragma shader_feature_local _ _OPTIMIZE_INTERPOLATORS
 #pragma shader_feature_local _ _ACES_FILMIC
 
diff --git a/fog.cginc b/fog.cginc
index 5863d59..5d6137f 100644
--- a/fog.cginc
+++ b/fog.cginc
@@ -138,7 +138,9 @@ void getEmitterData(float3 p,
 
   const float3 p_to_emitter = p - em_loc;
   const float t = dot(p_to_emitter, em_normal);
-  float emitter_lod = floor((abs(t) + dither) / ((_Gimmick_Fog_00_Emitter_Lod_Half_Life*(1+ign_anim(uv*1000, frame, /*speed=*/1.0)*2.5) * step_size)));
+
+  const float raw_noise_sample = _Gimmick_Fog_00_Noise_2D.SampleLevel(point_repeat_s, uv * 1000, 0).x;
+  float emitter_lod = floor((abs(t) + dither) / ((_Gimmick_Fog_00_Emitter_Lod_Half_Life*(1+raw_noise_sample*2.5) * step_size)));
   float3 em_color = _Gimmick_Fog_00_Emitter_Texture.SampleLevel(point_clamp_s, uv, emitter_lod);
   float emitter_dist = in_range ? abs(t) : 1000;
   float emitter_falloff = min(1, rcp(emitter_dist));
@@ -273,14 +275,13 @@ Fog00PBR getFog00(v2f i, ToonerData tdata) {
   //step_size = clamp(step_size, 1E-2, 1E2);
   uint2 screen_uv_round = floor(screen_uv * _ScreenParams.xy);
   const float frame = ((float) AudioLinkData(ALPASS_GENERALVU + int2(1, 0)).x);
-#if false && defined(_GIMMICK_FOG_00_NOISE_2D)
-  const float golden_ratio = 1.61803398875;
-  const float speed = 0.003;
-  const float dither_seed = frac(_Gimmick_Fog_00_Noise_2D.SampleLevel(point_repeat_s, screen_uv_round * _Gimmick_Fog_00_Noise_2D_TexelSize.xy, 0) + 
-    frame * golden_ratio * speed);
+#if defined(_GIMMICK_FOG_00_NOISE_2D)
+  const float raw_noise_sample = _Gimmick_Fog_00_Noise_2D.SampleLevel(point_repeat_s, screen_uv * _ScreenParams.xy * _Gimmick_Fog_00_Noise_2D_TexelSize.xy, 0).x;
+  const float dither_seed = frac(raw_noise_sample + frame * PHI);
 #elif 1
   // float ign_anim(float2 screen_px, float frame, float speed) {
-  const float dither_seed = ign_anim(screen_uv_round, frame, /*speed=*/0.001);
+  //const float dither_seed = ign_anim(screen_uv_round, frame, /*speed=*/0.001);
+  const float dither_seed = frac(ign_anim(screen_uv_round, frame, /*speed=*/0.000) + frame * 1.618033989);
 #else
   const float dither_seed = rand2(float2(screen_uv_round.x, screen_uv_round.y)*.001);
 #endif
@@ -416,7 +417,8 @@ Fog00PBR getFog00(v2f i, ToonerData tdata) {
   pbr.depth = clip_pos.z / clip_pos.w;
 
 #if 0
-  pbr.albedo.rgb = eye_depth_world / 100;
+  //pbr.albedo.rgb = eye_depth_world / 100;
+  pbr.albedo.rgb = dither_seed;
   pbr.albedo.a = 1;
 #endif
 
@@ -439,14 +441,25 @@ float4 apply_fog(
     float3 sun_dir,
     float4 sun_color,
     float sun_exponent,
+    float sun_color_2_enable,
+    float4 sun_color_2,
+    float sun_exponent_2,
     float4 fog_color) {
   float fog_amount = 1 - exp(-t * density);
-  float sun_amount = pow(max(dot(rd, sun_dir), 0), sun_exponent);
-  float4 color =
-    lerp(
-      fog_color,
-      sun_color,
-      sun_amount);
+  float4 color = fog_color;
+  float ndotl = dot(rd, sun_dir);
+  // Wrap ndotl
+  ndotl = (ndotl + 1) / (2);
+  ndotl *= ndotl;
+  ndotl = max(ndotl, 0);
+  [branch]
+  if (sun_color_2_enable) {
+    float sun_amount_2 = saturate(pow(ndotl, sun_exponent_2) * fog_amount);
+    color = lerp(color, sun_color_2, sun_amount_2);
+  }
+  float sun_amount = saturate(pow(ndotl, sun_exponent) * fog_amount);
+  color = lerp(color, sun_color, sun_amount);
+  //return float4(color.rgb, fog_amount * color.a);
   return float4(color.rgb, fog_amount * color.a);
 }
 
@@ -460,7 +473,7 @@ Fog01PBR getFog01(v2f i, ToonerData tdata) {
     float cur_radius = length(_WorldSpaceCameraPos - activation_center);
     [branch]
     //if (cur_radius > activation_radius) {
-    if (_WorldSpaceCameraPos.y > activation_center.y + activation_radius) {
+    if (getCenterCamPos().y > activation_center.y + activation_radius) {
       return (Fog01PBR)0;
     }
   }
@@ -490,6 +503,9 @@ Fog01PBR getFog01(v2f i, ToonerData tdata) {
       normalize(_Gimmick_Fog_01_Sun_Direction),
       _Gimmick_Fog_01_Sun_Color,
       _Gimmick_Fog_01_Sun_Exponent,
+      _Gimmick_Fog_01_Sun_Color_2_Enable,
+      _Gimmick_Fog_01_Sun_Color_2,
+      _Gimmick_Fog_01_Sun_Exponent_2,
       _Gimmick_Fog_01_Color);
   pbr.albedo.rgb = aces_filmic(pbr.albedo.rgb);
 
diff --git a/globals.cginc b/globals.cginc
index e7455e3..2986138 100644
--- a/globals.cginc
+++ b/globals.cginc
@@ -698,6 +698,17 @@ float4 _Gimmick_Flat_Color_Color;
 float3 _Gimmick_Flat_Color_Emission;
 #endif
 
+#if defined(_GIMMICK_UV_DOMAIN_WARPING)
+float _Gimmick_UV_Domain_Warping_Enable_Static;
+float _Gimmick_UV_Domain_Warping_Octaves;
+float _Gimmick_UV_Domain_Warping_Strength;
+float _Gimmick_UV_Domain_Warping_Scale;
+float _Gimmick_UV_Domain_Warping_Speed;
+texture2D _Gimmick_UV_Domain_Warping_Noise;
+texture2D _Gimmick_UV_Domain_Warping_Mask;
+float _Gimmick_UV_Domain_Warping_Mask_Invert;
+#endif
+
 #if defined(_GIMMICK_QUANTIZE_LOCATION)
 float _Gimmick_Quantize_Location_Enable_Static;
 float _Gimmick_Quantize_Location_Enable_Dynamic;
@@ -793,22 +804,32 @@ float _Gimmick_DS2_11_Fog_Enable;
 float _Gimmick_DS2_11_Fog_Density;
 float3 _Gimmick_DS2_11_Fog_Sun_Direction;
 float4 _Gimmick_DS2_11_Fog_Sun_Color;
+float _Gimmick_DS2_11_Fog_Sun_Exponent;
+float _Gimmick_DS2_11_Fog_Sun_Color_2_Enable;
+float4 _Gimmick_DS2_11_Fog_Sun_Color_2;
+float _Gimmick_DS2_11_Fog_Sun_Exponent_2;
 float4 _Gimmick_DS2_11_Fog_Color;
 float _Gimmick_DS2_11_Snowline;
+float _Gimmick_DS2_11_Snowline_Octaves;
 float _Gimmick_DS2_11_Snowline_Width;
 float _Gimmick_DS2_11_Snowline_Noise_Scale;
 float3 _Gimmick_DS2_11_Snow_Color;
 float _Gimmick_DS2_11_Rockline;
+float _Gimmick_DS2_11_Rockline_Octaves;
 float _Gimmick_DS2_11_Rockline_Width;
 float _Gimmick_DS2_11_Rockline_Noise_Scale;
 float3 _Gimmick_DS2_11_Rock_Color;
 float3 _Gimmick_DS2_11_Grass_Color;
 float _Gimmick_DS2_11_Alpha;
+float _Gimmick_DS2_11_Octaves;
+float _Gimmick_DS2_11_March_Initial_Offset;
+float _Gimmick_DS2_11_March_Steps;
+float _Gimmick_DS2_11_Simulation_Scale;
+float _Gimmick_DS2_11_Height_Scale;
 float3 _Gimmick_DS2_11_XZ_Offset;
-float _Gimmick_DS2_11_Fog_Sun_Exponent;
 float _Gimmick_DS2_11_Distance_Culling_Enable;
-float3 _Gimmick_DS2_11_Activation_Center;
-float _Gimmick_DS2_11_Activation_Radius;
+float _Gimmick_DS2_11_Activation_Y;
+float _Gimmick_DS2_11_Early_Exit_Cutoff_Cos_Theta;
 #endif
 
 #if defined(_PIXELLATE)
@@ -966,10 +987,14 @@ float _Gimmick_Fog_00_Emitter2_Scale_Y;
 
 #if defined(_GIMMICK_FOG_01) || defined(_GIMMICK_DS2)
 float _Gimmick_Fog_01_Density;
+float _Gimmick_Fog_01_Overlay_Mode;
 float3 _Gimmick_Fog_01_Sun_Direction;
 float4 _Gimmick_Fog_01_Color;
 float4 _Gimmick_Fog_01_Sun_Color;
+float4 _Gimmick_Fog_01_Sun_Color_2;
 float _Gimmick_Fog_01_Sun_Exponent;
+float _Gimmick_Fog_01_Sun_Exponent_2;
+float _Gimmick_Fog_01_Sun_Color_2_Enable;
 float _Gimmick_Fog_01_Distance_Culling_Enable;
 float3 _Gimmick_Fog_01_Activation_Center;
 float _Gimmick_Fog_01_Activation_Radius;
@@ -1004,6 +1029,13 @@ float4 _Gimmick_Gerstner_Water_Color_Ramp_Mask1;
 #endif
 #endif
 
+#if defined(_GIMMICK_BOX_DISCARD)
+float _Gimmick_Box_Discard_Enable_Static;
+float3 _Gimmick_Box_Discard_Corner_1;
+float3 _Gimmick_Box_Discard_Corner_2;
+float _Gimmick_Box_Discard_Invert;
+#endif
+
 #if defined(_GIMMICK_FOG_00_RAY_MARCH_0)
 float _Gimmick_Fog_00_Ray_March_0_Seed;
 #endif
diff --git a/math.cginc b/math.cginc
index 6b39bdb..41d9987 100644
--- a/math.cginc
+++ b/math.cginc
@@ -149,12 +149,20 @@ float rand(uint seed) {
 }
 
 // Generate a random number on [0, 1].
+/*
 float rand2(float2 p)
 {
   return frac(sin(dot(p,
           float2(12.9898, 78.233)))
       * 43758.5453123);
 }
+*/
+float rand2(float2 p)
+{
+    float3 p3  = frac(float3(p.xyx) * float3(.1031, .1030, .0973));
+    p3 += dot(p3, p3.yzx + 33.33);
+    return frac((p3.x + p3.y) * p3.z);
+}
 
 // Generate a random number on [0, 1].
 float rand3(float3 p)
@@ -275,21 +283,21 @@ float3x3 invert(float3x3 m)
 }
 
 // Return largest number which divides into both 'a' and 'b'.
-// Uses the Euclidean algorithm: repeatedly divide 'b' by 'a'.
+// Uses the Euclidean algorithm: repeatedly divide larger by smaller number.
 uint gcd(uint a, uint b)
 {
-  uint tmp = a * b;
-  #define GCD_MAX_ITER 8
-  for (uint i = 0; i < GCD_MAX_ITER; i++) {
-    tmp = b;
-    b = a % b;
-    a = tmp;
-    if (a == b) {
-      return a;
+    #define GCD_MAX_ITER 24
+    for (uint i = 0; i < GCD_MAX_ITER; i++) {
+        if (b == 0) {
+            return a;
+        }
+        a = a % b;
+        // Swap a and b
+        uint tmp = a;
+        a = b;
+        b = tmp;
     }
-  }
-  return 1;
-  
+    return 1;
 }
 
 #endif  // __MATH_INC
diff --git a/mochie_shadow_caster.cginc b/mochie_shadow_caster.cginc
index c4731d8..375f078 100644
--- a/mochie_shadow_caster.cginc
+++ b/mochie_shadow_caster.cginc
@@ -48,6 +48,20 @@ v2f vert (appdata v){
     return (v2f) (0.0 / 0.0);
   }
 #endif
+#if defined(_GIMMICK_BOX_DISCARD)
+  if (_Gimmick_Box_Discard_Enable_Static) {
+    float3 p = getCenterCamPos();
+    float3 c1 = _Gimmick_Box_Discard_Corner_1;
+    float3 c2 = _Gimmick_Box_Discard_Corner_2;
+    bool inside = (p.x >= c1.x && p.x <= c2.x &&
+        p.y >= c1.y && p.y <= c2.y &&
+        p.z >= c1.z && p.z <= c2.z);
+    if (_Gimmick_Box_Discard_Invert && !inside ||
+        !_Gimmick_Box_Discard_Invert && inside) {
+      return (v2f) (0.0 / 0.0);
+    }
+  }
+#endif
 #if defined(_TROCHOID)
   {
     v.vertex.xyz = cart_to_troch_map(v.vertex.xyz);
@@ -106,22 +120,25 @@ float4 frag (v2f i) : SV_Target {
   mixOverlayAlbedoRoughnessMetallic(albedo, roughness, metallic, ov, one, overlay_glitter_mask);
 
 #if defined(_RENDERING_CUTOUT)
-#if defined(_RENDERING_CUTOUT_STOCHASTIC)
-  float ar = rand2(i.uv0);
-  clip(albedo.a - ar);
-#elif defined(_RENDERING_CUTOUT_IGN)
   float frame = 0;
   if (AudioLinkIsAvailable()) {
     frame = ((float) AudioLinkData(ALPASS_GENERALVU + int2(1, 0)).x);
   } else {
     frame = floor(_Frame_Counter);
   }
+#if defined(_RENDERING_CUTOUT_STOCHASTIC)
+  float ar = rand2(i.uv0);
+  clip(albedo.a - ar);
+#elif defined(_RENDERING_CUTOUT_IGN)
   float ar = ign_anim(
       floor(tdata.screen_uv_round * _Rendering_Cutout_Noise_Scale) + _Rendering_Cutout_Ign_Seed,
       frame, _Rendering_Cutout_Ign_Speed);
   clip(albedo.a - ar);
 #elif defined(_RENDERING_CUTOUT_NOISE_MASK)
-  float ar = _Rendering_Cutout_Noise_Mask.SampleLevel(point_repeat_s, tdata.screen_uv * _ScreenParams.xy * _Rendering_Cutout_Noise_Mask_TexelSize.xy, 0);
+  float ar = frac(
+    _Rendering_Cutout_Noise_Mask.SampleLevel(point_repeat_s, tdata.screen_uv * _ScreenParams.xy * _Rendering_Cutout_Noise_Mask_TexelSize.xy, 0)
+    + frame * PHI);
+  //return float4(ar, ar, ar, 1);
   clip(albedo.a - ar);
 #else
   clip(albedo.a - _Alpha_Cutoff);
diff --git a/tooner.shader b/tooner.shader
index a802100..5adbcc6 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: 36
+  // Build nonce: 38
   Properties
   {
     _Color("Base color", Color) = (0.8, 0.8, 0.8, 1)
@@ -746,6 +746,15 @@ Shader "yum_food/tooner"
     _Gimmick_Flat_Color_Color("Flat color gimmick color", Color) = (0, 0, 0, 1)
     _Gimmick_Flat_Color_Emission("Flat color gimmick emission", Color) = (0, 0, 0, 1)
 
+    _Gimmick_UV_Domain_Warping_Enable_Static("Enable UV domain warping", Float) = 0.0
+    _Gimmick_UV_Domain_Warping_Octaves("UV domain warping octaves", Float) = 3
+    _Gimmick_UV_Domain_Warping_Strength("UV domain warping strength", Float) = 1
+    _Gimmick_UV_Domain_Warping_Scale("UV domain warping scale", Float) = 1
+    _Gimmick_UV_Domain_Warping_Speed("UV domain warping speed", Float) = 1
+    _Gimmick_UV_Domain_Warping_Noise("UV domain warping noise", 2D) = "black" {}
+    _Gimmick_UV_Domain_Warping_Mask("UV domain warping mask", 2D) = "white" {}
+    _Gimmick_UV_Domain_Warping_Mask_Invert("UV domain warping mask invert", Float) = 0.0
+
     _Gimmick_Quantize_Location_Enable_Static("Enable quantize location gimmick", Float) = 0.0
     _Gimmick_Quantize_Location_Enable_Dynamic("quantize location gimmick", Float) = 0.0
     _Gimmick_Quantize_Location_Precision("quantize location precision", Float) = 100.0
@@ -832,23 +841,32 @@ Shader "yum_food/tooner"
     _Gimmick_DS2_11_Fog_Density("Fog density", Float) = 1
     _Gimmick_DS2_11_Fog_Sun_Direction("Fog sun direction", Vector) = (0, 0, 0, 0)
     _Gimmick_DS2_11_Fog_Sun_Exponent("Fog sun exponent", Float) = 1
+    _Gimmick_DS2_11_Fog_Sun_Color_2_Enable("Fog sun color 2 enable", Float) = 0
+    [HDR] _Gimmick_DS2_11_Fog_Sun_Color_2("Fog sun color 2", Color) = (1, 1, 1, 1)
+    _Gimmick_DS2_11_Fog_Sun_Exponent_2("Fog sun exponent 2", Float) = 1
     [HDR] _Gimmick_DS2_11_Fog_Color("Fog color", Color) = (1, 1, 1, 1)
     [HDR] _Gimmick_DS2_11_Fog_Sun_Color("Fog sun color", Color) = (1, 1, 1, 1)
     _Gimmick_DS2_11_Snowline("Snowline", Float) = 1
+    _Gimmick_DS2_11_Snowline_Octaves("Snowline octaves", Float) = 1
     _Gimmick_DS2_11_Snowline_Width("Snowline width", Float) = 0.1
     _Gimmick_DS2_11_Snowline_Noise_Scale("Snowline noise scale", Float) = 1
     [HDR] _Gimmick_DS2_11_Snow_Color("Snow color", Color) = (1, 1, 1, 1)
     _Gimmick_DS2_11_Rockline("Rockline", Float) = 0
+    _Gimmick_DS2_11_Rockline_Octaves("Rockline octaves", Float) = 1
     _Gimmick_DS2_11_Rockline_Width("Rockline width", Float) = 0.1
     _Gimmick_DS2_11_Rockline_Noise_Scale("Rockline noise scale", Float) = 1
     [HDR] _Gimmick_DS2_11_Rock_Color("Rock color", Color) = (1, 1, 1, 1)
     [HDR] _Gimmick_DS2_11_Grass_Color("Grass color", Color) = (1, 1, 1, 1)
     _Gimmick_DS2_11_Alpha("Alpha", Range(0, 1)) = 0.5
+    _Gimmick_DS2_11_Octaves("Octaves", Float) = 12
+    _Gimmick_DS2_11_March_Steps("March steps", Float) = 24
+    _Gimmick_DS2_11_March_Initial_Offset("March initial offset", Float) = 0
+    _Gimmick_DS2_11_Simulation_Scale("Simulation scale", Float) = 1
+    _Gimmick_DS2_11_Height_Scale("Height scale", Float) = 1
     _Gimmick_DS2_11_XZ_Offset("XZ offset", Vector) = (0, 0, 0, 0)
     _Gimmick_DS2_11_Distance_Culling_Enable("Distance culling enable", Float) = 0
-    _Gimmick_DS2_11_Activation_Center("Activation center", Vector) = (0, 0, 0, 0)
-    _Gimmick_DS2_11_Activation_Radius("Activation radius", Float) = 1
-
+    _Gimmick_DS2_11_Activation_Y("Activation Y", Float) = 0
+    _Gimmick_DS2_11_Early_Exit_Cutoff_Cos_Theta("Early exit cutoff (cos theta)", Float) = 0
 
     _Gimmick_Halo00_Enable_Static("Enable halo", Float) = 0.0
 
@@ -1017,11 +1035,15 @@ Shader "yum_food/tooner"
     _Gimmick_Fog_00_Ray_March_0_Seed("seed", Float) = 0
 
     _Gimmick_Fog_01_Enable_Static("Enable fog 01", Float) = 0
+    _Gimmick_Fog_01_Overlay_Mode("Overlay mode", Float) = 0
     _Gimmick_Fog_01_Density("Density", Range(0, 1)) = 1
     _Gimmick_Fog_01_Sun_Direction("Sun direction", Vector) = (0.866, 0.5, 0, 0)
     _Gimmick_Fog_01_Sun_Exponent("Sun exponent", Float) = 1
+    _Gimmick_Fog_01_Sun_Exponent_2("Sun exponent 2", Float) = 1
     [HDR] _Gimmick_Fog_01_Color("Color", Color) = (1, 1, 1, 1)
     [HDR] _Gimmick_Fog_01_Sun_Color("Sun color", Color) = (1, 1, 1, 1)
+    [HDR] _Gimmick_Fog_01_Sun_Color_2("Sun color 2", Color) = (1, 1, 1, 1)
+    _Gimmick_Fog_01_Sun_Color_2_Enable("Sun color 2 enable", Float) = 0
     _Gimmick_Fog_01_Distance_Culling_Enable("Distance culling enable", Float) = 0
     _Gimmick_Fog_01_Activation_Center("Activation center", Vector) = (0, 0, 0, 0)
     _Gimmick_Fog_01_Activation_Radius("Activation radius", Float) = 1
@@ -1047,11 +1069,16 @@ Shader "yum_food/tooner"
 
     _Gimmick_Gerstner_Water_h("Mean water depth", Float) = 10
     _Gimmick_Gerstner_Water_g("Gravity", Float) = 9.8
-    _Gimmick_Gerstner_Water_Scale("Scale", Vector) = (1000, 1000, .1)
+    _Gimmick_Gerstner_Water_Scale("Scale", Vector) = (1000, 1000, .1, 0)
     _Gimmick_Gerstner_Water_Origin_Damping_Direction("Origin damping direction", Float) = 1
-    _Gimmick_Gerstner_Water_Color_Ramp("Color ramp", 2D) = "white"
+    _Gimmick_Gerstner_Water_Color_Ramp("Color ramp", 2D) = "white" {}
     _Gimmick_Gerstner_Water_Color_Ramp_Offset("Color ramp offset", Float) = 0.5
     _Gimmick_Gerstner_Water_Color_Ramp_Scale("Color ramp offset", Float) = 1
+
+    _Gimmick_Box_Discard_Enable_Static("Enable box discard (static)", Float) = 0
+    _Gimmick_Box_Discard_Corner_1("Corner 1", Vector) = (0, 0, 0, 0)
+    _Gimmick_Box_Discard_Corner_2("Corner 2", Vector) = (0, 0, 0, 0)
+    _Gimmick_Box_Discard_Invert("Invert", Float) = 0
   }
   SubShader
   {
@@ -1103,6 +1130,7 @@ Shader "yum_food/tooner"
         "RenderType"="Opaque"
         "Queue"="Geometry"
         "LightMode"="ForwardAdd"
+        "DisableBatching"="True"
       }
       Blend [_SrcBlend] One
       ZWrite Off
@@ -1131,6 +1159,9 @@ Shader "yum_food/tooner"
       ENDCG
     }
 		Pass {
+      Tags {
+        "DisableBatching"="True"
+      }
       Cull [_OutlinesCull]
 
       ZWrite [_ZWrite]
@@ -1159,6 +1190,7 @@ Shader "yum_food/tooner"
 		Pass {
       Tags {
         "LightMode" = "ShadowCaster"
+        "DisableBatching"="True"
       }
       Cull [_Cull]
 
diff --git a/tooner_lighting.cginc b/tooner_lighting.cginc
index a48a14d..821cb0e 100644
--- a/tooner_lighting.cginc
+++ b/tooner_lighting.cginc
@@ -106,6 +106,22 @@ v2f vert(appdata v)
   UNITY_SETUP_INSTANCE_ID(v);
   UNITY_TRANSFER_INSTANCE_ID(v, o);
   UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+  //UNITY_TRANSFER_VERTEX_OUTPUT_STEREO(v, o);
+
+#if defined(_GIMMICK_BOX_DISCARD)
+  if (_Gimmick_Box_Discard_Enable_Static) {
+    float3 p = getCenterCamPos();
+    float3 c1 = _Gimmick_Box_Discard_Corner_1;
+    float3 c2 = _Gimmick_Box_Discard_Corner_2;
+    bool inside = (p.x >= c1.x && p.x <= c2.x &&
+        p.y >= c1.y && p.y <= c2.y &&
+        p.z >= c1.z && p.z <= c2.z);
+    if (_Gimmick_Box_Discard_Invert && !inside ||
+        !_Gimmick_Box_Discard_Invert && inside) {
+      return (v2f) (0.0 / 0.0);
+    }
+  }
+#endif
 
   o.centerCamPos = getCenterCamPos();
 
@@ -949,6 +965,21 @@ float4 effect(inout v2f i, out float depth)
   depth = 0;
 #endif
 
+#if defined(_GIMMICK_UV_DOMAIN_WARPING)
+  {
+    float2 uv = i.uv0;
+    for (uint ii = 0; ii < _Gimmick_UV_Domain_Warping_Octaves; ii++) {
+      uv +=
+        (_Gimmick_UV_Domain_Warping_Noise.SampleLevel(
+          linear_repeat_s,
+          (uv + _Time[0] * _Gimmick_UV_Domain_Warping_Speed) *
+          _Gimmick_UV_Domain_Warping_Scale, 0) - 0.5) *
+        _Gimmick_UV_Domain_Warping_Strength;
+    }
+    i.uv0 = uv;
+  }
+#endif
+
 #if defined(_TROCHOID)
   {
     float3 my_pos;
@@ -1361,22 +1392,24 @@ float4 effect(inout v2f i, out float depth)
 #endif
 
 #if defined(_RENDERING_CUTOUT)
-#if defined(_RENDERING_CUTOUT_STOCHASTIC)
-  float ar = rand2(i.uv0);
-  clip(albedo.a - ar);
-#elif defined(_RENDERING_CUTOUT_IGN)
   float frame = 0;
   if (AudioLinkIsAvailable()) {
     frame = ((float) AudioLinkData(ALPASS_GENERALVU + int2(1, 0)).x);
   } else {
     frame = floor(_Frame_Counter);
   }
+#if defined(_RENDERING_CUTOUT_STOCHASTIC)
+  float ar = rand2(i.uv0);
+  clip(albedo.a - ar);
+#elif defined(_RENDERING_CUTOUT_IGN)
   float ar = ign_anim(
       floor(tdata.screen_uv_round * _Rendering_Cutout_Noise_Scale) + _Rendering_Cutout_Ign_Seed,
       frame, _Rendering_Cutout_Ign_Speed);
   clip(albedo.a - ar);
 #elif defined(_RENDERING_CUTOUT_NOISE_MASK)
-  float ar = _Rendering_Cutout_Noise_Mask.SampleLevel(point_repeat_s, tdata.screen_uv * _ScreenParams.xy * _Rendering_Cutout_Noise_Mask_TexelSize.xy, 0);
+  float ar = frac(
+    _Rendering_Cutout_Noise_Mask.SampleLevel(point_repeat_s, tdata.screen_uv * _ScreenParams.xy * _Rendering_Cutout_Noise_Mask_TexelSize.xy, 0)
+    + frame * PHI);
   //return float4(ar, ar, ar, 1);
   clip(albedo.a - ar);
 #else
@@ -2094,10 +2127,10 @@ float4 effect(inout v2f i, out float depth)
   }
 #endif
 #if defined(_GIMMICK_FOG_01)
-  {
-    Fog01PBR pbr = getFog01(i, tdata);
-    albedo = pbr.albedo;
-    depth = pbr.depth;
+  if (!round(_Gimmick_Fog_01_Overlay_Mode)) {
+    Fog01PBR fog_01_pbr = getFog01(i, tdata);
+    albedo = fog_01_pbr.albedo;
+    depth = fog_01_pbr.depth;
 #if defined(_RENDERING_TRANSPARENT) || defined(_RENDERING_TRANSCLIPPING)
     albedo.rgb *= albedo.a;
 #endif
@@ -2210,6 +2243,24 @@ float4 effect(inout v2f i, out float depth)
   result.rgb += ds2.emission * _Gimmick_DS2_Emission_Factor * ds2_mask;
 #endif
 
+#if defined(_GIMMICK_FOG_01)
+  if (round(_Gimmick_Fog_01_Overlay_Mode)) {
+    float4 fog_color = apply_fog(
+      length(i.worldPos.xyz - getCenterCamPos()),
+      _Gimmick_Fog_01_Density,
+      normalize(i.worldPos.xyz - getCenterCamPos()),
+      _Gimmick_Fog_01_Sun_Direction,
+      _Gimmick_Fog_01_Sun_Color,
+      _Gimmick_Fog_01_Sun_Exponent,
+      _Gimmick_Fog_01_Sun_Color_2_Enable,
+      _Gimmick_Fog_01_Sun_Color_2,
+      _Gimmick_Fog_01_Sun_Exponent_2,
+      _Gimmick_Fog_01_Color
+    );
+    result.xyz = fog_color * fog_color.a + result * (1 - fog_color.a);
+  }
+#endif
+
 #if defined(_ACES_FILMIC)
   result.rgb = aces_filmic(max(result.rgb, 0));
 #endif
diff --git a/trochoid_math.cginc b/trochoid_math.cginc
index bae5e01..881cd6a 100644
--- a/trochoid_math.cginc
+++ b/trochoid_math.cginc
@@ -1,3 +1,4 @@
+#include "cnlohr.cginc"
 #include "globals.cginc"
 #include "math.cginc"
 
@@ -12,15 +13,15 @@
 
 float3 cyl2_to_troch_map(float3 v)
 {
-  const float R = _Trochoid_R;
-  const float r = _Trochoid_r;
+  float R = abs(_Trochoid_R) > abs(_Trochoid_r) ? _Trochoid_R : _Trochoid_r;
+  float r = abs(_Trochoid_R) > abs(_Trochoid_r) ? _Trochoid_r : _Trochoid_R;
   const float d = _Trochoid_d;
   const float rrrr = (R - r) * R / r;
 
 #if 1
   float rr_gcd = gcd(abs(round(R)), abs(round(r)));
   float rr_lcm = (R * r) / rr_gcd;
-  float rr_lcm_factor = rr_lcm / R;
+  float rr_lcm_factor = abs(rr_lcm / R);
 #else
   float rr_lcm_factor = r;
 #endif
@@ -28,15 +29,14 @@ float3 cyl2_to_troch_map(float3 v)
   float toff = _Time[0] * _Trochoid_Speed;
 
   float x =
-      cos(v.x * rr_lcm_factor * R + toff * 2.3 + toff) * v.y * (R - r) * TROCH_POSITION_SCALE +
-      cos(v.x * rr_lcm_factor * rrrr - toff * 2.9 + toff) * v.y * d * TROCH_POSITION_SCALE;
+      cos((v.x / rr_lcm_factor) * R + toff * 2.3 + toff) * v.y * (R - r) * TROCH_POSITION_SCALE +
+      cos((v.x / rr_lcm_factor) * rrrr - toff * 2.9 + toff) * v.y * d * TROCH_POSITION_SCALE;
   float y =
-      sin(v.x * rr_lcm_factor * R - toff * 3.1 + toff) * v.y * (R - r) * TROCH_POSITION_SCALE -
-      sin(v.x * rr_lcm_factor * rrrr + toff * 3.7 + toff) * v.y * d * TROCH_POSITION_SCALE;
+      sin((v.x / rr_lcm_factor) * R - toff * 3.1 + toff) * v.y * (R - r) * TROCH_POSITION_SCALE -
+      sin((v.x / rr_lcm_factor) * rrrr + toff * 3.7 + toff) * v.y * d * TROCH_POSITION_SCALE;
   float z =
-      (v.x * v.y * rr_lcm_factor * R * TROCH_Z_THETA_SCALE +
-      cos(v.x * rr_lcm_factor * R * 5 + toff * 4.1 + toff) * v.y * TROCH_POSITION_SCALE +
-      //v.y * v.z);
+      ((v.x / rr_lcm_factor) * v.y * R * TROCH_Z_THETA_SCALE +
+      cos((v.x / rr_lcm_factor) * R * 5 + toff * 4.1 + toff) * v.y * TROCH_POSITION_SCALE +
       v.z);
 
   return float3(x, y, z);
@@ -62,7 +62,7 @@ float3 cart_to_troch_map(float3 v)
     float cur_radius = length(_WorldSpaceCameraPos - activation_center);
     [branch]
     //if (cur_radius > activation_radius) {
-    if (_WorldSpaceCameraPos.y > activation_center.y + activation_radius) {
+    if (getCenterCamPos().y > activation_center.y + activation_radius) {
       return v;
     }
   }