path: root/fog.cginc

#include "UnityCG.cginc"

#include "audiolink.cginc"
#include "atrix256.cginc"
#include "cnlohr.cginc"
#include "globals.cginc"
#include "interpolators.cginc"
#include "math.cginc"
#include "noise.cginc"
#include "oklab.cginc"
#include "pbr.cginc"
#include "poi.cginc"
#include "tone.cginc"

#ifndef __FOG_INC
#define __FOG_INC

#if defined(_GIMMICK_FOG_00)

struct Fog00PBR {
  float4 albedo;
  float depth;
};

#define FOG_PERLIN_NOISE_SCALE 1

float3 perlin_noise_3d_tex(float3 p)
{
  // 1/256 = 0.00390625
  return _Gimmick_Fog_00_Noise.SampleLevel(trilinear_repeat_s, p.xyz * 0.00390625, 0);
}

#define FBM_OCTAVES 3

float3 perlin_noise_3d_tex_fbm(float3 p)
{
  float3 res = perlin_noise_3d_tex(p);
  float p_scale = 1;
  //float d_scale = .66666;
  float d_scale = .571428571;
  for (uint i = 1; i < FBM_OCTAVES; i++) {
    p_scale *= 2;
    d_scale *= .5;
    res += perlin_noise_3d_tex(p*p_scale)*d_scale;
  }
  return res;
}

// idea from here https://iquilezles.org/articles/warp/
float3 perlin_noise_3d_tex_warp(float3 p)
{
  p = perlin_noise_3d_tex(p);
  p = perlin_noise_3d_tex(p * 255);
  p = perlin_noise_3d_tex(p * 255);
  return p;
}

float3 light_fog00(
    float3 albedo,
    float NoL,
    float3 direct,
    float3 diffuse
    ) {
  half diffuseTerm = NoL;
  float wrappedDiffuse = saturate((diffuseTerm + _WrappingFactor) /
      (1.0f + _WrappingFactor)) * 2 / (2 * (1 + _WrappingFactor));
#if 0
  float3 direct_unlit = .01;
  direct = lerp(direct, direct_unlit, wrappedDiffuse);
#endif
  float3 diffCol = albedo * (diffuse + direct * wrappedDiffuse);
  return diffCol;
}

float map(float3 p, out float3 normal) {
#if 1
  float3 t = float3(0, -_Time[0] * FOG_PERLIN_NOISE_SCALE, 0) * _Gimmick_Fog_00_Motion_Vector;
#else
  float3 t = 0;
#endif
#define RADIUS_TRANS_WIDTH .5
#define RADIUS_TRANS_WIDTH_RCP (1.0 / RADIUS_TRANS_WIDTH)
  // Try to create a smooth transition without doing any length() or other
  // transcendental ops.
  float radius2 = clamp(_Gimmick_Fog_00_Radius * _Gimmick_Fog_00_Radius - dot(p.xz, p.xz), 0, RADIUS_TRANS_WIDTH) * RADIUS_TRANS_WIDTH_RCP;

	float3 pp = p * _Gimmick_Fog_00_Noise_Scale * FOG_PERLIN_NOISE_SCALE;
  normal = normalize(perlin_noise_3d_tex(pp+t) * 2 - 1);
  float density = perlin_noise_3d_tex_warp(pp+t) * radius2;
  //float density = perlin_noise_3d_tex(pp+t) * radius2;
  //float density = 0.5 * radius2;
  //density = pow(density, _Gimmick_Fog_00_Noise_Exponent);
  // EV is 0.5, so apply corrective factor of pow(2, _Gimmick_Fog_00_Noise_Exponent - 1)
  //density *= pow(2, _Gimmick_Fog_00_Noise_Exponent - 1);
  //density *= 8;
  density *= density * 2;

  return density;
}

#if defined(_GIMMICK_FOG_00_EMITTER_TEXTURE)
// Returns weighted color
void getEmitterData(float3 p,
    float dither,
    float step_size,
    float3 em_loc,
    float3 em_normal,
    float3 em_tangent,
    float3 em_normal_x_tangent,
    float2 emitter_scale,
    float2 emitter_scale_rcp,
    out float3 diffuse,
    out float3 direct)
{
  // Using identity a_parallel_to_b = (dot(a, b) / dot(b, b)) * b
  //   float3 along_tangent = dot(p - em_loc, em_tangent) * em_tangent;
  //   float3 along_normal_x_tangent = dot(p - em_loc, em_normal_x_tangent) *
  //       em_normal_x_tangent;
  // Given that em_tangent and em_normal_x_tangent are normalized, and the fact
  // that we really want uvs, we can simplify this:
  float2 uv = float2(dot(p - em_loc, em_normal_x_tangent), dot(p - em_loc, em_tangent));
  uv *= emitter_scale_rcp;
  uv *= 0.5;
  uv += 0.5;

  //uv.x += dither * .01;
  const float frame = ((float) AudioLinkData(ALPASS_GENERALVU + int2(1, 0)).x);
  //uv.x += ign_anim((dither+1000) * 1000, frame, /*speed=*/1.0) * .01;
  //uv.y += ign_anim(dither * 1000, frame, /*speed=*/1.0) * .01;

  bool in_range = uv.x < 1 && uv.y < 1 && uv.x > 0 && uv.y > 0;

#if 0
  uv.y = FOG_PERLIN_NOISE(float3(uv*100, _Time[2]));
  uv.x = FOG_PERLIN_NOISE(p);
  uv.y = FOG_PERLIN_NOISE(float3(uv*100, _Time[2]));
#endif

  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)));
  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));

  direct = in_range * emitter_falloff * em_color;

#if 1
  float e = 0.1;
  float2 uv_inv = 1.0 - uv;
  diffuse = _Gimmick_Fog_00_Emitter_Texture.SampleLevel(point_clamp_s, float2(uv.x, uv.y), 16) +
    _Gimmick_Fog_00_Emitter_Texture.SampleLevel(point_clamp_s, float2(uv.x, uv_inv.y), 16) +
    _Gimmick_Fog_00_Emitter_Texture.SampleLevel(point_clamp_s, float2(uv_inv.x, uv.y), 16);
  diffuse *= 0.3333;
  float3 em_loc_clamp = em_loc + (saturate(uv.x) *2 - 1) * em_tangent + (saturate(uv.y) * 2 - 1) * em_normal_x_tangent;
  em_loc_clamp += em_loc;
  // TODO parameterize shaping constants
  float diffuse_length = dot(p - em_loc_clamp, p - em_loc_clamp);
  diffuse /= diffuse_length;
#else
  diffuse = 0;
#endif
}
#endif  // defined(_GIMMICK_FOG_00_EMITTER_TEXTURE)

#if defined(_GIMMICK_FOG_00_RAY_MARCH_0)
float fog00_map(float3 p, float rid_entropy)
{
  float sin_term = sin(rid_entropy*2*TAU+_Time[0]*2)+1.0;
  sin_term *= sin_term;
  sin_term *= 0.7;
  return length(p)+0.7-rid_entropy*2.3*
    sin_term*.2;
}
float fog00_map_dr(
    float3 p,
    float3 period,
    float3 count,
    float seed,
    out float3 which
    )
{
  p -= float3(0, period.y * floor(count.y/2) + 1, 0);
  p -= unity_ObjectToWorld._m03_m13_m23;

  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;
#if 1
  for (uint xi = 0; xi < 2; xi++)
  for (uint yi = 0; yi < 2; yi++)
  for (uint zi = 0; zi < 2; zi++)
#else
  uint xi = 0;
  uint yi = 0;
  uint zi = 0;
#endif
  {
    float3 rid = which + float3(xi, yi, zi) * o;
    rid = clamp(rid, ceil(-(count)*0.5), floor((count-1)*0.5));
    float3 r = p - period * rid;
    float3 rid_entropy = float3(
        ign(rid.yz+seed),
        ign(rid.xz+seed),
        ign(rid.xy+seed));
    float3 random_dir = normalize(rid_entropy);
    r +=
      (sin(_Time[0] * 2 + (rid_entropy.x + rid_entropy.y + rid_entropy.z) * TAU * .6666) * 2 - 1.0) *
      period * 0.5 *
      random_dir *
      float3(1, 1, 1) * .3;
    float cur_d = fog00_map(r, FOG_PERLIN_NOISE((rid+seed)*100));
    which_tmp = cur_d < d ? rid : which_tmp;
    d = min(d, cur_d);
  }

  which = which_tmp;
  return d;
}
#endif

Fog00PBR getFog00(v2f i, ToonerData tdata) {
  float3 cam_pos = mul(unity_WorldToObject, float4(_WorldSpaceCameraPos, 1.0)).xyz;
  float3 obj_pos = i.objPos;

  float3 obj_pos_depth_hit;
  float2 screen_uv;
  float eye_depth_world;
  {
    float3 full_vec_eye_to_geometry = i.worldPos - _WorldSpaceCameraPos;
    float3 world_dir = normalize(i.worldPos - _WorldSpaceCameraPos);
    float perspective_divide = 1.0 / i.pos.w;
    float perspective_factor = length(full_vec_eye_to_geometry * perspective_divide);
    screen_uv = i.screenPos.xy * perspective_divide;
    eye_depth_world =
      GetLinearZFromZDepth_WorksWithMirrors(
          SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, tdata.screen_uv),
          screen_uv) * perspective_factor;
    float3 world_pos_depth_hit = _WorldSpaceCameraPos + eye_depth_world * world_dir;
    obj_pos_depth_hit = mul(unity_WorldToObject, float4(world_pos_depth_hit, 1.0)).xyz;
  }

  const float3 rd = normalize(obj_pos - cam_pos);
  float3 ro = cam_pos;

  bool no_intersection = false;
  float distance_to_cylinder = 1E6;
  {
    float a = dot(rd.xz, rd.xz);
    float b = 2 * dot(rd.xz, ro.xz);
    float c = dot(ro.xz, ro.xz) - _Gimmick_Fog_00_Radius * _Gimmick_Fog_00_Radius;
    float t0, t1;
    if (solveQuadratic(a, b, c, t0, t1)) {
      no_intersection = (t0 < 0) * (t1 < 0);
      const bool inside_cylinder = (t0 < 0) * (t1 > 0);
      if (!inside_cylinder) {
        distance_to_cylinder = no_intersection ? distance_to_cylinder : min(max(t0, 0), max(t1, 0));
        ro += distance_to_cylinder * rd;
      }
    }
  }
  clip(no_intersection ? -1 : 1);

  float density_ss_term = 1 / _Gimmick_Fog_00_Density;
  //density_ss_term = dclamp(density_ss_term, 0.33, 3.00, 5);
  const float step_size = _Gimmick_Fog_00_Step_Size_Factor * density_ss_term;
  const float step_size_sqrt = sqrt(step_size);
  const float step_size_sqrt_max1 = max(1, step_size_sqrt);
  //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);
#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);
#else
  const float dither_seed = rand2(float2(screen_uv_round.x, screen_uv_round.y)*.001);
#endif
  float dither = dither_seed * step_size * _Gimmick_Fog_00_Ray_Origin_Randomization;
  ro += rd * (0.001 + dither);

  const float depth_hit_l = length(obj_pos_depth_hit - ro);

  // Get common lighting data
  UnityLight direct_light;
  UnityIndirect indirect_light;
  direct_light.dir = getDirectLightDirection(i);
  direct_light.ndotl = 0;  // Not used
  direct_light.color = getDirectLightColor();
  // TODO try per-sample baked lighting
  indirect_light.diffuse = getIndirectDiffuse(i, /*vertex_light_color=*/0);
  // TODO consider doing specular. At time of writing it seems pointless.
  indirect_light.specular = 0;

  float4 acc = 0;
  uint step_count = floor(min(_Gimmick_Fog_00_Max_Ray, depth_hit_l) / step_size);
  //step_count *= (1 - no_intersection);
#define FOG_MAX_LOOP 20
  step_count = min(step_count, FOG_MAX_LOOP);

#if defined(_GIMMICK_FOG_00_EMITTER_TEXTURE)
  const float3 em_loc = mul(unity_WorldToObject, float4(_Gimmick_Fog_00_Emitter0_Location, 1.0)).xyz;
  const float3 em_normal = normalize(mul(unity_WorldToObject, float4(_Gimmick_Fog_00_Emitter0_Normal, 0.0)).xyz);
  const float3 em_tangent = normalize(mul(unity_WorldToObject, float4(_Gimmick_Fog_00_Emitter0_Tangent, 0.0)).xyz);
  const float3 em_normal_x_tangent = normalize(cross(em_normal, em_tangent));
  const float em_scale_t   = _Gimmick_Fog_00_Emitter0_Scale_T * length(mul(unity_WorldToObject, float4(_Gimmick_Fog_00_Emitter0_Normal, 0.0)));
  const float em_scale_nxt = _Gimmick_Fog_00_Emitter0_Scale_NxT * length(mul(unity_WorldToObject, float4(cross(_Gimmick_Fog_00_Emitter0_Normal, _Gimmick_Fog_00_Emitter0_Tangent), 0.0)));
  const float2 em_scale = float2(em_scale_t, em_scale_nxt);
  const float2 em_scale_rcp = rcp(em_scale);
#endif

  const float3 ro_world = mul(unity_ObjectToWorld, float4(ro, 1.0)).xyz;
  const float3 rd_world = mul(unity_ObjectToWorld, float4(rd, 0.0)).xyz;
  const float3 rd_world_normalized = normalize(rd_world);
  const float step_size_world = step_size * length(rd_world);
  const float3 view_dir_world = normalize(_WorldSpaceCameraPos - i.worldPos);

  const float3 noise_scale_rcp = 1.0 / _Gimmick_Fog_00_Noise_Scale;
  uint ii;
  for (ii = 0; ii < step_count; ii++) {
    const float3 p = ro + rd * ii * step_size;

    float4 c;
    float3 c_lit = 0;
#if 1
    float3 map_normal;
    const float map_p_raw = map(p, map_normal);
    const float map_p = map_p_raw * _Gimmick_Fog_00_Density * step_size;
    c = float4(_Color.rgb, map_p);
    float3 diffuse = 0;
    float3 direct = 0;
#if defined(_GIMMICK_FOG_00_EMITTER_TEXTURE) && !defined(_GIMMICK_FOG_00_EMITTER_VARIABLE_DENSITY)
    // We put the emitter color into diffuse instead of doing a directional
    // calculation because it looks better and it's cheaper. Less accurate
    // though!
    if (_Gimmick_Fog_00_Enable_Area_Lighting) {
      // Note that I'm intentionally passing in `direct` and `diffuse`
      // backwards. It looks better if the collimated light is immune to normal
      // dimming, and if the diffuse light is not.
      getEmitterData(p, dither, step_size, em_loc, em_normal, em_tangent, em_normal_x_tangent, em_scale,
          em_scale_rcp, direct, diffuse);
    }
    diffuse *= _Gimmick_Fog_00_Emitter_Brightness_Diffuse;
    direct *= _Gimmick_Fog_00_Emitter_Brightness_Direct;
#else
#endif

    // Scaling brightness by sqrt(step_size) seems to look more consistent as
    // you vary density. No idea why :(
    float NoL = dot(map_normal, direct_light.dir);
    c_lit += light_fog00(
        c.rgb,
        NoL, 
        (direct_light.color + direct) * step_size_sqrt_max1,
        (indirect_light.diffuse + diffuse) * step_size_sqrt_max1);
#else
    c_lit = .05 * step_size;
    c.a = 0.1;
#endif
#if defined(_GIMMICK_FOG_00_EMITTER_TEXTURE) && defined(_GIMMICK_FOG_00_EMITTER_VARIABLE_DENSITY)
    float3 em_c = getEmitterData(p, step_size, em_loc, em_normal, em_scale, em_scale_rcp) * step_size;
    float em_NoL = saturate((map(p + dd_e * em_normal, lod) - map_p_raw) / dd_e);
    c_lit += light_fog00(
        c.rgb,
        em_NoL, 
        em_c,
        0);
#endif
    c.rgb = c_lit;

    // Intuition: add c scaled by the remaining transparent portion of acc.
    acc = acc + (1 - acc.a) * c;

#if 1
    // For performance, stop if we...
    //  1. accumulate enough alpha
    //  2. go outside of the sphere
    if (acc.a > _Gimmick_Fog_00_Alpha_Cutoff ||
        dot(p.xz, p.xz) > _Gimmick_Fog_00_Radius * _Gimmick_Fog_00_Radius) {
      break;
    }
#endif
  }
  if (acc.a > _Gimmick_Fog_00_Alpha_Cutoff || ii == FOG_MAX_LOOP) {
    acc /= acc.a;
  }
  acc.rgb = LRGBtoOKLAB(acc.rgb);
  acc.x = smooth_min(acc.x, _Gimmick_Fog_00_Max_Brightness * .85, _Gimmick_Fog_00_Max_Brightness);
  acc.rgb = OKLABtoLRGB(acc.rgb);

  Fog00PBR pbr;
  pbr.albedo = acc;
  pbr.albedo.a = smooth_min(pbr.albedo.a, .999, 1);

  // Add some dithering to lit color to break up banding
  //const float frame = ((float) AudioLinkData(ALPASS_GENERALVU + int2(1, 0)).x);
  //pbr.albedo.rgb += ign_anim(dither * 1000, frame, /*speed=*/1.0) * .00390625;

  // Remap onto [0, 1]
  pbr.albedo.rgb = aces_filmic(pbr.albedo.rgb);
  // Clamp so max brightness is comfortable. Do it in perceptually uniform
  // space to avoid affecting saturation.
  //pbr.albedo.rgb = LRGBtoOKLAB(pbr.albedo.rgb);
  //pbr.albedo.x = smooth_min(pbr.albedo.x, _Gimmick_Fog_00_Max_Brightness * .9, _Gimmick_Fog_00_Max_Brightness);
  //pbr.albedo.rgb = OKLABtoLRGB(pbr.albedo.rgb);

  float4 clip_pos = mul(UNITY_MATRIX_VP, float4(mul(unity_ObjectToWorld, float4(ro, 1.0))));
  pbr.depth = clip_pos.z / clip_pos.w;

#if 0
  pbr.albedo.rgb = eye_depth_world / 100;
  pbr.albedo.a = 1;
#endif

  return pbr;
}

#endif  // _GIMMICK_FOG_00

#endif  // __FOG_INC