Start new eye shader, add UV mirror flipping

Also tune rand3() to behave better on rorschach demo.

8 files changed, 206 insertions, 26 deletions

diff --git a/Editor/tooner.cs b/Editor/tooner.cs
index 17347a7..c1c4331 100644
--- a/Editor/tooner.cs
+++ b/Editor/tooner.cs
@@ -621,7 +621,7 @@ public class ToonerGUI : ShaderGUI {
       SetKeyword($"_RIM_LIGHTING{i}", enabled);
 
       if (!enabled) {
-        return;
+        continue;
       }
 
       bc = FindProperty($"_Rim_Lighting{i}_Color");
@@ -1334,6 +1334,28 @@ public class ToonerGUI : ShaderGUI {
     EditorGUI.indentLevel -= 1;
   }
 
+  void DoGimmickEyes01() {
+    MaterialProperty bc;
+    bc = FindProperty("_Gimmick_Eyes01_Enable_Static");
+    bool enabled = (bc.floatValue != 0.0);
+    EditorGUI.BeginChangeCheck();
+    enabled = EditorGUILayout.Toggle("Eyes 01", enabled);
+    EditorGUI.EndChangeCheck();
+    bc.floatValue = enabled ? 1.0f : 0.0f;
+    SetKeyword("_GIMMICK_EYES_01", enabled);
+
+    if (!enabled) {
+      return;
+    }
+
+    EditorGUI.indentLevel += 1;
+
+    bc = FindProperty("_Gimmick_Eyes01_Radius");
+    editor.FloatProperty(bc, "Radius (meters, object space)");
+
+    EditorGUI.indentLevel -= 1;
+  }
+
   void DoGimmickPixellate() {
     MaterialProperty bc;
     bc = FindProperty("_Gimmick_Pixellate_Enable_Static");
@@ -1481,16 +1503,44 @@ public class ToonerGUI : ShaderGUI {
     EditorGUI.indentLevel -= 1;
   }
 
+  void DoGimmickMirrorUVFlip() {
+    MaterialProperty bc;
+    bc = FindProperty("_Mirror_UV_Flip_Enable_Static");
+    bool enabled = (bc.floatValue != 0.0);
+    EditorGUI.BeginChangeCheck();
+    enabled = EditorGUILayout.Toggle("Flip UVs in mirror", enabled);
+    EditorGUI.EndChangeCheck();
+    bc.floatValue = enabled ? 1.0f : 0.0f;
+    SetKeyword("_MIRROR_UV_FLIP", enabled);
+
+    if (!enabled) {
+      return;
+    }
+
+    EditorGUI.indentLevel += 1;
+
+    bc = FindProperty("_Mirror_UV_Flip_Enable_Dynamic");
+    enabled = (bc.floatValue != 0.0);
+    EditorGUI.BeginChangeCheck();
+    enabled = EditorGUILayout.Toggle("Enable (runtime switch)", enabled);
+    EditorGUI.EndChangeCheck();
+    bc.floatValue = enabled ? 1.0f : 0.0f;
+
+    EditorGUI.indentLevel -= 1;
+  }
+
   void DoGimmicks() {
     DoGimmickFlatColor();
     DoGimmickQuantizeLocation();
     DoGimmickShearLocation();
     DoGimmickSpherizeLocation();
     DoGimmickEyes00();
+    DoGimmickEyes01();
     DoGimmickPixellate();
     DoGimmickTrochoid();
     DoGimmickFaceMeWorldY();
     DoGimmickRorschach();
+    DoGimmickMirrorUVFlip();
   }
 
   void DoMochieParams() {
diff --git a/eyes.cginc b/eyes.cginc
index c5fbc1b..3a913b0 100644
--- a/eyes.cginc
+++ b/eyes.cginc
@@ -1,6 +1,10 @@
 #ifndef __EYES_INC
 #define __EYES_INC
 
+#include "globals.cginc"
+#include "interpolators.cginc"
+#include "iq_sdf.cginc"
+
 #if defined(_GIMMICK_EYES_00)
 
 float eyes00_distance_from_sphere(float3 p, float3 c, float r)
@@ -98,7 +102,88 @@ float4 eyes00_march(float2 uv, inout float3 normal)
     return float4(shaded_color, 1.0);
 }
 
-#endif  // _EYES
+#endif  // _GIMMICK_EYES_00
+
+#if defined(_GIMMICK_EYES_01)
+
+struct Eyes01PBR {
+  float4 albedo;
+  float3 normal;
+};
+
+float eyes01_map(float3 p)
+{
+  return length(p) - .01;
+}
+
+float3 eyes01_calc_normal(in float3 p)
+{
+    const float3 small_step = float3(0.0001, 0.0, 0.0);
+
+    float gradient_x = eyes01_map(p + small_step.xyy) - eyes01_map(p - small_step.xyy);
+    float gradient_y = eyes01_map(p + small_step.yxy) - eyes01_map(p - small_step.yxy);
+    float gradient_z = eyes01_map(p + small_step.yyx) - eyes01_map(p - small_step.yyx);
+
+    float3 normal = float3(gradient_x, gradient_y, gradient_z);
+
+    return normalize(normal);
+}
+
+void __eyes01_march(float3 ro, float3 rd, inout Eyes01PBR result)
+{
+  float total_distance_traveled = 0.0;
+  const float MINIMUM_HIT_DISTANCE = 0.001;
+  const float MAXIMUM_TRACE_DISTANCE = 1000.0;
+
+#define EYES01_MARCH_STEPS 50
+  float distance_to_closest;
+  float3 current_position;
+  for (int i = 0; i < EYES01_MARCH_STEPS; i++)
+  {
+    current_position = ro + total_distance_traveled * rd;
+
+    distance_to_closest = eyes01_map(current_position);
+
+    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) {
+    result.normal = eyes01_calc_normal(current_position);
+    result.albedo = 1;
+  }
+
+  result.normal = float3(0, 0, 1);  // doesn't matter
+  result.albedo = 0;
+}
+
+Eyes01PBR eyes01_march(v2f i)
+{
+  Eyes01PBR result;
+
+  float3 cam_pos = _WorldSpaceCameraPos;
+  float3 ro = cam_pos;
+  float3 rd = normalize(i.worldPos - cam_pos);
+
+  float r_world = _Gimmick_Eyes01_Radius;
+  float3 o = -i.normal * r_world;
+
+  ro -= o;
+
+  __eyes01_march(ro, rd, result);
+
+  return result;
+}
+
+#endif  // _GIMMICK_EYES_01
 
 #endif  // __EYES_INC
 
diff --git a/feature_macros.cginc b/feature_macros.cginc
index ad3af14..cdae09d 100644
--- a/feature_macros.cginc
+++ b/feature_macros.cginc
@@ -139,11 +139,13 @@
 #pragma shader_feature_local _ _GIMMICK_SHEAR_LOCATION
 #pragma shader_feature_local _ _GIMMICK_SPHERIZE_LOCATION
 #pragma shader_feature_local _ _GIMMICK_EYES_00
+#pragma shader_feature_local _ _GIMMICK_EYES_01
 #pragma shader_feature_local _ _PIXELLATE
 #pragma shader_feature_local _ _TROCHOID
 #pragma shader_feature_local _ _FACE_ME_WORLD_Y
 #pragma shader_feature_local _ _RORSCHACH
 #pragma shader_feature_local _ _RORSCHACH_MASK
+#pragma shader_feature_local _ _MIRROR_UV_FLIP
 #pragma shader_feature_local _ _CLEARCOAT
 #pragma shader_feature_local _ _CLEARCOAT_MASK
 #pragma shader_feature_local _ _CLEARCOAT_MASK2
diff --git a/globals.cginc b/globals.cginc
index c13900a..5defb13 100644
--- a/globals.cginc
+++ b/globals.cginc
@@ -574,6 +574,10 @@ float _Gimmick_Eyes00_Enable_Static;
 texture2D _Gimmick_Eyes00_Effect_Mask;
 #endif
 
+#if defined(_GIMMICK_EYES_01)
+float _Gimmick_Eyes01_Radius;
+#endif
+
 #if defined(_PIXELLATE)
 float _Gimmick_Pixellate_Enable_Static;
 float _Gimmick_Pixellate_Resolution_U;
@@ -610,5 +614,9 @@ texture2D _Rorschach_Mask;
 float _Rorschach_Mask_Invert;
 #endif
 
+#if defined(_MIRROR_UV_FLIP)
+float _Mirror_UV_Flip_Enable_Dynamic;
+#endif
+
 #endif
 
diff --git a/math.cginc b/math.cginc
index 59e6fa0..cf753ac 100644
--- a/math.cginc
+++ b/math.cginc
@@ -59,7 +59,7 @@ float rand2(float2 p)
 // Generate a random number on [0, 1].
 float rand3(float3 p)
 {
-  return glsl_mod(sin(dot(p, float3(897.0, 367.0, 197.0))) * 1073.6, 1.0);
+  return glsl_mod(sin(dot(p, float3(151.0, 157.0, 163.0))) * 997.0, 1.0);
 }
 
 float length2(float2 p)
diff --git a/rorschach.cginc b/rorschach.cginc
index d5f8ff1..cc570b8 100644
--- a/rorschach.cginc
+++ b/rorschach.cginc
@@ -21,7 +21,7 @@ float map_sdf(float3 p, float2 e, float3 period)
     (e.x - 0.5) * period.x,
     (e.y - 0.5) * period.y,
     0);
-  //o *= _SinTime[1];
+  //o *= ((_SinTime[1] + 1) / 2) * 1.3;
   o *= _Rorschach_Center_Randomization;
   return distance_from_sphere(p + o, r);
 }
@@ -40,8 +40,8 @@ float map_dr(
 
   float d = 1E9;
   float3 which_tmp = which;
-  for (int xi = -2; xi < 3; xi++)
-  for (int yi = -2; yi < 3; yi++)
+  for (int xi = -1; xi < 3; xi++)
+  for (int yi = -1; yi < 3; yi++)
   {
     float3 rid = which + float3(xi, yi, 0) * o;
     float3 r = p - period * rid;
@@ -87,6 +87,13 @@ RorschachPBR get_rorschach(v2f i)
   d = 1 - d;
   d = saturate(d);
 
+  //d = rand3(which);
+  /*
+  if (_Rorschach_Quantization > 0) {
+    d = round(glsl_mod(d, _Rorschach_Quantization) / _Rorschach_Quantization);
+  }
+  */
+
 #if defined(_RORSCHACH_MASK)
   float mask = _Rorschach_Mask.SampleLevel(linear_repeat_s, i.uv0.xy, /*lod=*/0);
   mask = _Rorschach_Mask_Invert ? 1 - mask : mask;
diff --git a/tooner.shader b/tooner.shader
index 3f20cfb..cbb14b5 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: 9
+  // Build nonce: 18
   Properties
   {
     _Color("Base color", Color) = (0.8, 0.8, 0.8, 1)
@@ -454,6 +454,9 @@ Shader "yum_food/tooner"
     _Gimmick_Eyes00_Enable_Static("Enable eyes 00", Float) = 0.0
     _Gimmick_Eyes00_Effect_Mask("Effect mask", 2D) = "white" {}
 
+    _Gimmick_Eyes01_Enable_Static("Enable eyes 01", Float) = 0.0
+    _Gimmick_Eyes01_Radius("Radius (meters, obj space)", Float) = 1.0
+
     _Gimmick_Pixellate_Enable_Static("Enable pixellation", Float) = 0.0
     _Gimmick_Pixellate_Resolution_U("Resolution (U)", Float) = 64
     _Gimmick_Pixellate_Resolution_V("Resolution (V)", Float) = 64
@@ -484,6 +487,9 @@ Shader "yum_food/tooner"
     _Rorschach_Mask("Mask", 2D) = "white" {}
     _Rorschach_Mask_Invert("Mask invert", Float) = 0
 
+    _Mirror_UV_Flip_Enable_Static("Enable rorschach gimmick", Float) = 0.0
+    _Mirror_UV_Flip_Enable_Dynamic("Enable rorschach gimmick", Float) = 0.0
+
     _Enable_SSR("Enable SSR", Float) = 0
     _SSRStrength("SSR Strength", Float) = 1
     _SSRHeight("SSR Height", Float) = 0.1
@@ -551,7 +557,6 @@ Shader "yum_food/tooner"
       #include "tooner_lighting.cginc"
       ENDCG
     }
-    /*
     Pass {
       Tags {
         "RenderType"="Opaque"
@@ -631,7 +636,6 @@ Shader "yum_food/tooner"
       #include "mochie_shadow_caster.cginc"
 			ENDCG
 		}
-    */
   }
   CustomEditor "ToonerGUI"
 }
diff --git a/tooner_lighting.cginc b/tooner_lighting.cginc
index 8923122..0370d20 100644
--- a/tooner_lighting.cginc
+++ b/tooner_lighting.cginc
@@ -184,6 +184,19 @@ v2f vert(appdata v)
   o.uv5 = v.uv5;
   o.uv6 = v.uv6;
   o.uv7 = v.uv7;
+#if defined(_MIRROR_UV_FLIP)
+  if (_Mirror_UV_Flip_Enable_Dynamic) {
+    bool in_mirror = isInMirror();
+    o.uv0.x = lerp(o.uv0.x, 1 - o.uv0.x, in_mirror);
+    o.uv1.x = lerp(o.uv1.x, 1 - o.uv1.x, in_mirror);
+    o.uv2.x = lerp(o.uv2.x, 1 - o.uv2.x, in_mirror);
+    o.uv3.x = lerp(o.uv3.x, 1 - o.uv3.x, in_mirror);
+    o.uv4.x = lerp(o.uv4.x, 1 - o.uv4.x, in_mirror);
+    o.uv5.x = lerp(o.uv5.x, 1 - o.uv5.x, in_mirror);
+    o.uv6.x = lerp(o.uv6.x, 1 - o.uv6.x, in_mirror);
+    o.uv7.x = lerp(o.uv7.x, 1 - o.uv7.x, in_mirror);
+  }
+#endif
 #if defined(LIGHTMAP_ON)
   o.lmuv = v.uv1 * unity_LightmapST.xy + unity_LightmapST.zw;
 #endif
@@ -866,6 +879,7 @@ void mixOverlayAlbedoRoughnessMetallic(inout float4 albedo,
     a0 *= in_range;
   }
   a0 *= mask;
+  a0 *= ov.ov0_mask;
 #endif
 #if defined(_PBR_OVERLAY1)
   float a1 = saturate(ov.ov1_albedo.a * _PBR_Overlay1_Alpha_Multiplier);
@@ -875,6 +889,7 @@ void mixOverlayAlbedoRoughnessMetallic(inout float4 albedo,
     a1 *= in_range;
   }
   a1 *= mask;
+  a1 *= ov.ov1_mask;
 #endif
 #if defined(_PBR_OVERLAY2)
   float a2 = saturate(ov.ov2_albedo.a * _PBR_Overlay2_Alpha_Multiplier);
@@ -884,6 +899,7 @@ void mixOverlayAlbedoRoughnessMetallic(inout float4 albedo,
     a2 *= in_range;
   }
   a2 *= mask;
+  a2 *= ov.ov2_mask;
 #endif
 #if defined(_PBR_OVERLAY3)
   float a3 = saturate(ov.ov3_albedo.a * _PBR_Overlay3_Alpha_Multiplier);
@@ -893,6 +909,7 @@ void mixOverlayAlbedoRoughnessMetallic(inout float4 albedo,
     a3 *= in_range;
   }
   a3 *= mask;
+  a3 *= ov.ov3_mask;
 #endif
 
 #if defined(_PBR_OVERLAY0)
@@ -906,11 +923,11 @@ void mixOverlayAlbedoRoughnessMetallic(inout float4 albedo,
 #endif
   albedo.a = max(albedo.a, a0);
 #elif defined(_PBR_OVERLAY0_MIX_ADD)
-  albedo.rgb += ov.ov0_albedo;
+  albedo.rgb += ov.ov0_albedo * mask * ov.ov0_mask;
 #elif defined(_PBR_OVERLAY0_MIX_MIN)
-  albedo.rgb = min(albedo.rgb, ov.ov0_albedo);
+  albedo.rgb = lerp(albedo.rgb, min(albedo.rgb, ov.ov0_albedo), mask * ov.ov0_mask);
 #elif defined(_PBR_OVERLAY0_MIX_MAX)
-  albedo.rgb = max(albedo.rgb, ov.ov0_albedo);
+  albedo.rgb = max(albedo.rgb, ov.ov0_albedo * mask * ov.ov0_mask);
 #endif
 #endif
 
@@ -925,11 +942,11 @@ void mixOverlayAlbedoRoughnessMetallic(inout float4 albedo,
 #endif
   albedo.a = max(albedo.a, a1);
 #elif defined(_PBR_OVERLAY1_MIX_ADD)
-  albedo.rgb += ov.ov1_albedo;
+  albedo.rgb += ov.ov1_albedo * mask * ov.ov1_mask;
 #elif defined(_PBR_OVERLAY1_MIX_MIN)
-  albedo.rgb = min(albedo.rgb, ov.ov1_albedo);
+  albedo.rgb = lerp(albedo.rgb, min(albedo.rgb, ov.ov1_albedo), mask * ov.ov1_mask);
 #elif defined(_PBR_OVERLAY1_MIX_MAX)
-  albedo.rgb = max(albedo.rgb, ov.ov1_albedo);
+  albedo.rgb = max(albedo.rgb, ov.ov1_albedo * mask * ov.ov1_mask);
 #endif
 #endif
 
@@ -944,11 +961,11 @@ void mixOverlayAlbedoRoughnessMetallic(inout float4 albedo,
 #endif
   albedo.a = max(albedo.a, a2);
 #elif defined(_PBR_OVERLAY2_MIX_ADD)
-  albedo.rgb += ov.ov2_albedo;
+  albedo.rgb += ov.ov2_albedo * mask * ov.ov2_mask;
 #elif defined(_PBR_OVERLAY2_MIX_MIN)
-  albedo.rgb = min(albedo.rgb, ov.ov2_albedo);
+  albedo.rgb = lerp(albedo.rgb, min(albedo.rgb, ov.ov2_albedo), mask * ov.ov2_mask);
 #elif defined(_PBR_OVERLAY2_MIX_MAX)
-  albedo.rgb = max(albedo.rgb, ov.ov2_albedo);
+  albedo.rgb = max(albedo.rgb, ov.ov2_albedo * mask * ov.ov2_mask);
 #endif
 #endif
 
@@ -963,11 +980,11 @@ void mixOverlayAlbedoRoughnessMetallic(inout float4 albedo,
 #endif
   albedo.a = max(albedo.a, a3);
 #elif defined(_PBR_OVERLAY3_MIX_ADD)
-  albedo.rgb += ov.ov3_albedo;
+  albedo.rgb += ov.ov3_albedo * mask * ov.ov3_mask;
 #elif defined(_PBR_OVERLAY3_MIX_MIN)
-  albedo.rgb = min(albedo.rgb, ov.ov3_albedo);
+  albedo.rgb = lerp(albedo.rgb, min(albedo.rgb, ov.ov3_albedo), mask * ov.ov3_mask);
 #elif defined(_PBR_OVERLAY3_MIX_MAX)
-  albedo.rgb = max(albedo.rgb, ov.ov3_albedo);
+  albedo.rgb = max(albedo.rgb, ov.ov3_albedo * mask * ov.ov3_mask);
 #endif
 #endif
 }
@@ -1227,17 +1244,24 @@ float4 effect(inout v2f i)
 
 #if defined(_GIMMICK_EYES_00)
   {
-    float3 eyes00_normal = 0;
-    float3 eyes00_albedo = eyes00_march(i.uv0, eyes00_normal).rgb;
-    bool is_ray_hit = (eyes00_albedo.r > 0 || eyes00_albedo.g > 0 || eyes00_albedo.b > 0);
+    float3 eyes_normal = 0;
+    float3 eyes_albedo = eyes00_march(i.uv0, eyes_normal).rgb;
+    bool is_ray_hit = (eyes_albedo.r > 0 || eyes_albedo.g > 0 || eyes_albedo.b > 0);
     if (is_ray_hit) {
       float mask = _Gimmick_Eyes00_Effect_Mask.SampleBias(linear_repeat_s, i.uv0, _Global_Sample_Bias);
-      albedo.rgb = lerp(eyes00_albedo * 1.5, albedo.rgb * 20.0, mask);
-      normal = eyes00_normal;
+      albedo.rgb = lerp(eyes_albedo * 1.5, albedo.rgb * 20.0, mask);
+      normal = eyes_normal;
     }
   }
 #endif
 
+#if defined(_GIMMICK_EYES_01)
+  {
+    Eyes01PBR pbr = eyes01_march(i);
+    albedo = pbr.albedo;
+  }
+#endif
+
 #if defined(_MATCAP0) || defined(_MATCAP1) || defined(_RIM_LIGHTING0) || defined(_RIM_LIGHTING1) || defined(_RIM_LIGHTING2) || defined(_RIM_LIGHTING3)
   float3 matcap_emission = 0;
   float2 matcap_uv;