Fog performance optimizations

* Rename albedo cutoff to alpha cutoff
* Add LODs for calculating fog density
* Use 3D noise texture to speed up density calculation
* Eliminate low impact octaves from density calculation
* Add support for multiple emitters

1 files changed, 99 insertions, 51 deletions

diff --git a/fog.cginc b/fog.cginc
index f31a7d3..f02415f 100644
--- a/fog.cginc
+++ b/fog.cginc
@@ -17,43 +17,77 @@ struct Fog00PBR {
   float ao;
 };
 
-float map(float3 p) {
-  float density = 0;
-  float t = _Time[1] * 0.5;
+float perlin_noise_3d_tex(float3 p)
+{
+  float3 sq = floor(p);
+  float3 sqi = frac(p);
+
+  // 1/256 = 0.00390625
+  float r_lo = _Gimmick_Fog_00_Noise.SampleLevel(linear_repeat_s, p.xyz * 0.00390625, 0);
+
+  return r_lo;
+}
+
+float map(float3 p, float lod) {
+  float3 t = _Time[1] * 0.5;
   float radius = saturate(_Gimmick_Fog_00_Radius - length(p));
-  float tmp;
-  tmp = perlin_noise_3d(p * _Gimmick_Fog_00_Noise_Scale * 3.1 + t) * radius * 0.5;
-  density += tmp;
-  tmp = perlin_noise_3d(p * _Gimmick_Fog_00_Noise_Scale * 1.7 + t) * radius * 0.5;
-  density *= 0.5;
-  density += tmp;
-  tmp = perlin_noise_3d(p * _Gimmick_Fog_00_Noise_Scale * 1.0 + t) * radius * 0.5;
-  density *= 0.5;
-  density += tmp;
+
+	float3 pp = p * _Gimmick_Fog_00_Noise_Scale + t;
+  float density = perlin_noise_3d_tex(pp) * radius * 0.7;
 
   density = pow(density, _Gimmick_Fog_00_Noise_Exponent);
 
-  // Note: this term annihilates performance by creating large open areas. Long
-  // avgerage view ray = bad perf!
-  #if 1
-  tmp = perlin_noise_3d(p * _Gimmick_Fog_00_Noise_Scale * 0.167 + t/4) * radius - 0.5;
-  tmp *= 0.2;
-  density += tmp;
-  #endif
+  // This term creates large open areas
+  if (lod < 1) {
+    float tmp = perlin_noise_3d_tex(pp * 0.167 + t/4) * radius - 0.5;
+    // Aggressively dial down this parameter as density increases. We really
+    // need to keep paths short when density is high.
+    float density_performance_fix = rcp(_Gimmick_Fog_00_Density);
+    density_performance_fix *= density_performance_fix;
+    tmp *= 0.5 * density_performance_fix;
+    density += tmp;
+  }
 
   return saturate(density);
 }
 
-float3 get_normal(float3 p, float map_p) {
+float3 get_normal(float3 p, float map_p, float lod) {
   float3 e = float3(0.001, 0, 0);
   float center = map_p;
 
   // Prevent NaN
   float e2 = 1E-9;
   return normalize(float3(
-      map(p + e.xyz) - center,
-      map(p + e.yxz) - center,
-      map(p + e.zyx) - center) + e2);
+      map(p + e.xyz, lod) - center,
+      map(p + e.yxz, lod) - center,
+      map(p + e.zyx, lod) - center) + e2);
+}
+
+void getEmitterData(float3 p, float step_size,
+    float3 em_loc, float3 em_normal, float em_scale_x,
+    float em_scale_y, out float3 em_color, out float em_weight,
+    out float3 p_projected)
+{
+  // Project onto plane
+  const float3 p_to_emitter = p - em_loc;
+  const float2 emitter_scale = float2(em_scale_x, em_scale_y);
+  const float t = dot(p_to_emitter, em_normal);
+  float emitter_lod = floor(abs(t) / (_Gimmick_Fog_00_Emitter_Lod_Half_Life * step_size));
+  p_projected = p - t * em_normal;
+
+  p_projected -= em_loc;
+  bool in_range = (abs(p_projected.x) < emitter_scale.x) * (abs(p_projected.y) < emitter_scale.y) * (t > 0);
+
+  float2 emitter_uv = clamp(p_projected.xy, -emitter_scale, emitter_scale) / emitter_scale;
+  emitter_uv /= 2.0;
+  emitter_uv += 0.5;
+  // Go up one LOD every 5 meters
+  // TODO make this tunable
+  em_color = _Gimmick_Fog_00_Emitter_Texture.SampleLevel(linear_repeat_s, emitter_uv, emitter_lod);
+  em_color *= _Gimmick_Fog_00_Emitter_Brightness;
+  float emitter_dist = in_range ? abs(t) : 1000;
+  float emitter_falloff = min(1, rcp(pow(emitter_dist, 1.4)));
+  em_weight = in_range * emitter_falloff;
 }
 
 Fog00PBR getFog00(v2f i) {
@@ -108,42 +142,56 @@ Fog00PBR getFog00(v2f i) {
         _Gimmick_Fog_00_Max_Ray / step_size,
         world_pos_depth_hit_l / step_size));
   step_count *= (1 - no_intersection);
+#define FOG_MAX_LOOP 128
+  step_count = min(step_count, FOG_MAX_LOOP);
 
   float3 normal = i.normal;
   float ao = 0;
   for (uint ii = 0; ii < step_count; ii++) {
-    float3 p = ro + (rd * step_size) * ii;
+    const float3 p = ro + (rd * step_size) * ii;
+    const float lod = floor((ii * step_size) / _Gimmick_Fog_00_Lod_Half_Life);
 
-    const float col_gray = 0;
-    const float map_p = map(p);
-    float4 c = float4(col_gray, col_gray, col_gray, map_p);
+    const float map_p = map(p, lod);
+    float4 c = float4(0, 0, 0, map_p);
     c.a = saturate(c.a * _Gimmick_Fog_00_Density * step_size);
 
 #if defined(_GIMMICK_FOG_00_EMITTER_TEXTURE)
-    // Project onto plane
-    float3 p_to_emitter = p - _Gimmick_Fog_00_Emitter_Location;
-    float3 emitter_normal = normalize(_Gimmick_Fog_00_Emitter_Normal);
-    float2 emitter_scale = float2(_Gimmick_Fog_00_Emitter_Scale_X, _Gimmick_Fog_00_Emitter_Scale_Y);
-
-    float t = dot(p_to_emitter, emitter_normal);
-    float3 p_projected = p - t * emitter_normal;
-
-    p_projected -= _Gimmick_Fog_00_Emitter_Location;
-    bool in_range = (abs(p_projected.x) < emitter_scale.x) * (abs(p_projected.y) < emitter_scale.y) * (t > 0);
-
-    float2 emitter_uv = clamp(p_projected.xy, -emitter_scale, emitter_scale) / emitter_scale;
-    emitter_uv /= 2.0;
-    emitter_uv += 0.5;
-    float3 emitter_color = _Gimmick_Fog_00_Emitter_Texture.SampleLevel(linear_repeat_s, emitter_uv, 0);
-    emitter_color *= _Gimmick_Fog_00_Emitter_Brightness;
-    float emitter_dist = in_range ? abs(t) : 1000;
-    // Inverse square is physically accurate, but this looks better.
-    float emitter_falloff = min(1, rcp(pow(emitter_dist, 1.0)));
-#if 1
-    c.rgb = lerp(c.rgb, emitter_color, in_range * emitter_falloff);
-#else
-    c.rgb = emitter_color;
+    {
+      const float3 em_loc = _Gimmick_Fog_00_Emitter0_Location;
+      const float3 em_normal = normalize(_Gimmick_Fog_00_Emitter0_Normal);
+      const float em_scale_x = _Gimmick_Fog_00_Emitter0_Scale_X;
+      const float em_scale_y = _Gimmick_Fog_00_Emitter0_Scale_Y;
+
+      float3 em_color;
+      float em_weight;
+      float3 em_p;
+      getEmitterData(p, step_size, em_loc, em_normal, em_scale_x, em_scale_y, em_color, em_weight, em_p);
+#if defined(_GIMMICK_FOG_00_EMITTER_1)
+      const float3 em1_loc = _Gimmick_Fog_00_Emitter1_Location;
+      const float3 em1_normal = normalize(_Gimmick_Fog_00_Emitter1_Normal);
+      const float em1_scale_x = _Gimmick_Fog_00_Emitter1_Scale_X;
+      const float em1_scale_y = _Gimmick_Fog_00_Emitter1_Scale_Y;
+      float3 em1_color;
+      float em1_weight;
+      float3 em1_p;
+      getEmitterData(p, step_size, em1_loc, em1_normal, em1_scale_x, em1_scale_y, em1_color, em1_weight, em1_p);
+      em_color += em1_color;
+      em_weight += em1_weight;
+#endif
+#if defined(_GIMMICK_FOG_00_EMITTER_2)
+      const float3 em2_loc = _Gimmick_Fog_00_Emitter2_Location;
+      const float3 em2_normal = normalize(_Gimmick_Fog_00_Emitter2_Normal);
+      const float em2_scale_x = _Gimmick_Fog_00_Emitter2_Scale_X;
+      const float em2_scale_y = _Gimmick_Fog_00_Emitter2_Scale_Y;
+      float3 em2_color;
+      float em2_weight;
+      float3 em2_p;
+      getEmitterData(p, step_size, em2_loc, em2_normal, em2_scale_x, em2_scale_y, em2_color, em2_weight, em2_p);
+      em_color += em2_color;
+      em_weight += em2_weight;
 #endif
+      c.rgb = lerp(c.rgb, em_color, em_weight);
+    }
 #endif
 
     acc += c * (1.0 - acc.a);
@@ -160,7 +208,7 @@ Fog00PBR getFog00(v2f i) {
       normal = MY_BLEND_NORMALS(normal, n, n_interp);
     }
 #endif
-    if (acc.a > _Gimmick_Fog_00_Albedo_Cutoff) {
+    if (acc.a > _Gimmick_Fog_00_Alpha_Cutoff) {
       acc /= acc.a;
       break;
     }