Физика Айвазовского (2 стр)

float getSubsurfaceScattering(float3 normal,float3 view_direction,float3 light_vector,float wave_subsurface_intensity) {
  
  float dotLV = dot(view_direction,light_vector);
  
  // first child
  float visibility = saturate((dotLV + 1.0f) / 2.0f);
  float visibility_gradient = pow(saturate(1.0f - pow(1.0f - visibility,wave_subsurface_intensity)),3.0f);
  
  // second_child
  float dotLW = dot(light_vector,-normal);
  
  float subsurface = pow((dotLW + 1.0f) / 2.0f, 3.0f);
  
  return (subsurface * visibility_gradient);
}

float water_fresnel(float dotNV) {
  float ior = 1.06f;
  float c = abs(dotNV);
  float g = sqrt(ior * ior + c * c - 1);
  float fresnel = 0.5 * pow2(g - c) / pow2(g + c) * (1 + pow2(c * (g + c) - 1) / pow2(c * (g - c) + 1));
  return saturate(0.5f * fresnel + 0.5f * fresnel * dotNV * 2.0f);
}

MAIN_BEGIN(FRAGMENT_OUT,FRAGMENT_IN)

  float2 uv = IN_DATA(0);

  // geodetic
  float3x3 geodetic_tangent_ibasis;
  geodetic_tangent_ibasis[0] = m_tangent_iworld_rotation_x.xyz;
  geodetic_tangent_ibasis[1] = m_tangent_iworld_rotation_y.xyz;
  geodetic_tangent_ibasis[2] = m_tangent_iworld_rotation_z.xyz;

  // discard if non water-surface
  float4 water_buffer = TEXTURE_FETCH(TEX_WATER,uv * s_viewport.xy);
  if(water_buffer.r == 0.0f) {
    OUT_COLOR.a = 0.0f;
    discard;
  }

  water_buffer.r -= BYTE_UNORM_STEP;

  // discard if underwater
  float4 wu_mask = TEXTURE_FETCH(TEX_WR_MASK,uv * s_viewport.xy);
  if(wu_mask.r > 0.0f) {
    OUT_COLOR.a = 0.0f;
    discard;
  }

  uint constant_id = TEXTURE_LOAD(TEX_DEFERRED_CONSTANT,uv).x;

  /* CONSTANT PARAMETERS */
  float refraction_scale = GET_CONSTANT_FLOAT(constant_id,CONST_REFRACTION_SCALE);

  /* INCOMING G-BUFFER DATA */
  float4 diffuse_buffer = TEXTURE_FETCH(TEX_DIFFUSE,uv * s_viewport.xy);
  float4 normal_buffer = TEXTURE_FETCH(TEX_NORMAL,uv * s_viewport.xy);

  float water_fade = normal_buffer.a;

  /* FILL GBUFFER DATA STRUCTURE */
  GBuffer gbuffer = GBufferDefault();
  gbuffer.albedo = float3_one;
  gbuffer.roughness = 0.07f;
  gbuffer.f0 = 0.25f;
  gbuffer.translucent = 1.0f;
  gbuffer.metalness = EPSILON; // fix

  /* FILL COMMON DATA STRUCTURE */
  Data data;
  data.depth = TEXTURE_FETCH(TEX_DEPTH,uv * s_viewport.xy).r;        // native depth (unused)
  data.position = getDepthToPosition(data.depth,uv);      // view position
  data.depth = length(data.position);              // linearize depth

  data.normal  = getDeferredNormal(normal_buffer);

  data.view = -data.position / data.depth;          // normalized view direction
  data.reflection = reflect(-data.view, data.normal);      // reflection vector for fragment

  data.view_w = -mul3(s_imodelview, data.view);        // view world
  data.normal_w = mul3(s_imodelview, data.normal);      // normal world
  data.reflection_w = mul3(s_imodelview, data.reflection);  // reflection world

  data.dotNV = dot(data.normal,data.view);          // dot between NV

  data.dielectric = (1.0f - gbuffer.metalness);        // dielectric
  data.gloss = (1.0f - gbuffer.roughness);          // gloss (inverted roughness)
  data.screen_coord = IN_POSITION.xy;              // screen coord

  gbufferSRGB(gbuffer);

  /* ENVIRONMENT CALCULATION */
  float4 reflection = float4_zero;
  float4 environment = float4_zero;

  // TODO: USE_WATER_ENV_PROBES flag!
  #ifdef DEFERRED_REFLECTION
    reflection = TEXTURE_BIAS_ZERO(TEX_REFLECTION,float3(uv,0.0f));    // environment probes (specular) + planar
  #endif

  #ifdef DEFERRED_ENVIRONMENT
    environment = TEXTURE_BIAS_ZERO(TEX_REFLECTION,float3(uv,1.0f));  // environment probes (diffuse)
  #endif

  #ifdef USE_ENVIRONMENT_AMBIENT || USE_ENVIRONMENT_REFLECTION
    // gloss for reflection
    float reflection_roughness = GET_CONSTANT_FLOAT(constant_id,CONST_REFLECTION_ROUGHNESS);

    float3 ref_sky;
    float3 env_sky;
    loadEnvironmentReflectionHorizont(env_sky, ref_sky, reflection_roughness, data);

    #ifdef DEFERRED_REFLECTION
      reflection.rgb += ref_sky * (1.0f - reflection.a);
    #else
      reflection.rgb = ref_sky;
    #endif

    #ifdef DEFERRED_ENVIRONMENT
      environment.rgb += env_sky * (1.0f - environment.a);
    #else
      environment.rgb = env_sky;
    #endif

  #endif

  reflection.rgb = water_ssr(data.view,data.normal,data.depth,reflection.rgb);

  environment.rgb *= gbuffer.occlusion;
  environment.rgb += gbuffer.lightmap;

  /* LIGHT CALCULATION */
  float3 diffuse_light = float3_zero;
  float3 specular_light = float3_zero;
  float3 sun_color = float3_zero;

  float subsurface_light = 0.0f;

  #ifdef LIGHT_WORLD
    getWorldLight(diffuse_light,specular_light,gbuffer,data,sun_color);
    subsurface_light = getSubsurfaceScattering(data.normal,-data.view,s_light_direction,GET_CONSTANT_FLOAT(constant_id,CONST_SSS_WAVE_INTENSITY));
  #endif

  /* WATER CALCULATION */
  // general dynamic foam
  float water_foam_term = saturate(pow(diffuse_buffer.a,1.0f / water_buffer.r / water_buffer.r) * water_buffer.r);

  // custom water fresnel
  float fresnel = water_fresnel(data.dotNV);

  // reflection fresnel
  reflection.rgb *= fresnel;

  // refraction
  float3 refraction_normal = mul3(data.normal_w,geodetic_tangent_ibasis);

  float refracted_depth_scale = saturate(getLinearizedDepth(TEXTURE_OUT(TEX_DEPTH_PREWATER),uv) - data.depth);

  float2 refracted_uv_coef = refraction_normal.xy * refraction_scale * 0.5f / max(2.0f,data.depth) * refracted_depth_scale;
  float2 refracted_uv = uv + refracted_uv_coef;

  refracted_uv = lerp(refracted_uv,uv,saturate(data.dotNV - data.depth * 0.1f));

  // delta depth
  float prewater_depth = getLinearizedDepth(TEXTURE_OUT(TEX_DEPTH_PREWATER),refracted_uv);
  float delta_depth = abs(prewater_depth - data.depth);

  // shoreline foam
  // TODO: move term calculation to function
  float dotVN2 = saturate(1.0f - dot(data.view,s_modelview[2].xyz));
  float d_term = abs((1.0f - clamp(dotVN2,-1.0f,0.5f)) * delta_depth / (GET_CONSTANT_FLOAT(constant_id,CONST_COAST_FOAM_INTENSITY) * 5.0f));

  float procedural_coarse_foam = saturate(diffuse_buffer.a * (WATER_FOAM_MOD * 10.0f) - d_term + WATER_FOAM_THRESHOLD * 2.0f) * exp2(-saturate(d_term));
  water_foam_term += procedural_coarse_foam;

  // get prewater screen
  // TODO: refactor refraction (implement chromatic abberation, increase performance, make TAA compatible, remove magic constants)
  float3 prewater_screen = get_water_backside_data(refracted_uv);

  float3 bottom_color = float3_zero;

  // calculate fog (linear)
  float4 fog_color = getWaterFog(
    refracted_uv,
    GET_CONSTANT_VEC(constant_id,CONST_FOG_COLOR).xyz,
    environment.rgb,
    sun_color,
    GET_CONSTANT_FLOAT(constant_id,CONST_UNDERWATER_FOG_ENV),
    GET_CONSTANT_FLOAT(constant_id,CONST_UNDERWATER_FOG_SUN),bottom_color);

  // caustics
  water_buffer = TEXTURE_FETCH(TEX_WATER,refracted_uv * s_viewport.xy);
  float4 albedo_buffer = TEXTURE_FETCH(TEX_ALBEDO,refracted_uv * s_viewport.xy);
  prewater_screen += albedo_buffer.rgb * pow((water_buffer.g),1.0f) * bottom_color * 2.0f * sun_color;

  // prewater term (water diffuse)
  prewater_screen = lerp(prewater_screen.rgb,fog_color.rgb,fog_color.a);

  // compose term
  float3 composed_term = prewater_screen * abs(1.0f - max3(specular_light + reflection.rgb)) + specular_light + reflection.rgb;

  // subsurface
  float3 subsurface_color = srgbInv(GET_CONSTANT_VEC(constant_id,CONST_SSS_COLOR).xyz);
  float subsurface_ambient_intensity = srgbInv(GET_CONSTANT_FLOAT(constant_id,CONST_SSS_AMBIENT));
  float subsurface_foam_intensity = srgbInv(GET_CONSTANT_FLOAT(constant_id,CONST_SSS_FOAM_INTENSITY));
  float subsurface_diffuse_intensity = srgbInv(GET_CONSTANT_FLOAT(constant_id,CONST_SSS_DIFFUSE));

  float diffuse_distortion = GET_CONSTANT_FLOAT(constant_id,CONST_DIFFUSE_DISTROTION);

  // diffuse decal
  float2 subsurface_uv = uv + data.normal_w.xy * diffuse_distortion / max(2.0f,data.depth) * 5.0f;
  if(TEXTURE_FETCH(TEX_WATER,subsurface_uv * s_viewport.xy).r == 0.0f)
    subsurface_uv = uv;

  float3 decal_diffuse = TEXTURE_FETCH(TEX_DIFFUSE,subsurface_uv * s_viewport.xy).rgb;
  float max_decal_subsurface = max3(decal_diffuse.rgb);
  max_decal_subsurface = pow(max_decal_subsurface,1.5f);

  // sss
  float3 subsurface_around_foam = subsurface_color * subsurface_foam_intensity * pow(max(EPSILON,saturate(water_buffer.r) - 0.1f),4.0f);

  float3 sss = float3_zero;

  sss += subsurface_color * diffuse_light * subsurface_ambient_intensity * 0.15f;          // ambient

  sss += subsurface_color * subsurface_light * sun_color;                     // main (though waves)
  sss += subsurface_around_foam * max3(environment);                        // environment foam
  sss += subsurface_around_foam * diffuse_light;                          // foam around
  sss += subsurface_color  * max_decal_subsurface * diffuse_light * subsurface_diffuse_intensity;  // diffuse

  // add sss
  composed_term = composed_term * max(0.0f,1.0f - max3(sss)) + sss;

  // result foam term
  float3 foam_lighting = float3_one * diffuse_light + float3_one * max3(environment);

  // foam override
  OUT_COLOR.rgb = lerp(composed_term,foam_lighting,saturate(water_foam_term));

  // diffuse decal lerp
  OUT_COLOR.rgb = lerp(OUT_COLOR.rgb,decal_diffuse.rgb * diffuse_light + decal_diffuse.rgb * max3(environment.rgb),max3(decal_diffuse.rgb));

  #ifdef USE_HAZE
    #ifdef USE_HAZE_SCATTERING
      float4 haze = hazeScattering(data.depth,data.view_w,TEXTURE_OUT(TEX_SKY_LUT));
    #elif USE_HAZE_SOLID
      float4 haze = hazeSolid(data.depth);
    #endif

    OUT_COLOR.rgb = OUT_COLOR.rgb * haze.a + haze.rgb;
  #endif

  // soft intersection with opacity
  OUT_COLOR.a = saturate(delta_depth * GET_CONSTANT_FLOAT(constant_id,CONST_SOFT