1112 lines
41 KiB
HLSL
1112 lines
41 KiB
HLSL
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#pragma once
|
|
|
|
#include "DeferredShadingCommon.ush"
|
|
#include "BRDF.ush"
|
|
#include "FastMath.ush"
|
|
#include "CapsuleLight.ush"
|
|
#include "RectLight.ush"
|
|
#include "AreaLightCommon.ush"
|
|
#include "TransmissionCommon.ush"
|
|
#include "HairBsdf.ush"
|
|
#include "ShadingEnergyConservation.ush"
|
|
#include "ParticipatingMediaCommon.ush"
|
|
#include "ColorSpace.ush"
|
|
#include "SGGX.ush"
|
|
#include "PathTracing/Utilities/PathTracingRandomSequence.ush"
|
|
|
|
#ifndef HAIR_BSDF_BACKLIT
|
|
#define HAIR_BSDF_BACKLIT 1
|
|
#endif
|
|
|
|
#if SHADING_PATH_MOBILE
|
|
#include "MobileGGX.ush"
|
|
|
|
#ifndef MOBILE_SHADOW_QUALITY
|
|
#define MOBILE_SHADOW_QUALITY 2
|
|
#endif
|
|
|
|
//It's always 0 in mobile deferred lighting shaders
|
|
#ifndef FULLY_ROUGH
|
|
#define FULLY_ROUGH 0
|
|
#endif
|
|
|
|
//It's always 0 in mobile deferred lighting shaders
|
|
#ifndef NONMETAL
|
|
#define NONMETAL 0
|
|
#endif
|
|
|
|
//It's always 0 in mobile deferred lighting shaders
|
|
#ifndef MATERIAL_SHADINGMODEL_SINGLELAYERWATER
|
|
#define MATERIAL_SHADINGMODEL_SINGLELAYERWATER 0
|
|
#endif
|
|
|
|
// Always enabled in mobile deferred lighting shaders
|
|
#ifndef MOBILE_USE_PREINTEGRATED_GF
|
|
#define MOBILE_USE_PREINTEGRATED_GF 1
|
|
#endif
|
|
|
|
//It's always 1 in mobile deferred lighting shaders
|
|
#ifndef MOBILE_DEFERRED_LIGHTING
|
|
#define MOBILE_DEFERRED_LIGHTING 0
|
|
#endif
|
|
|
|
#ifndef DEFERRED_SHADING_PATH
|
|
#define DEFERRED_SHADING_PATH 0
|
|
#endif
|
|
|
|
/*------------------------------------------------------------------------------
|
|
Mobile Shading Model Functions
|
|
------------------------------------------------------------------------------*/
|
|
half4 GetSSProfilePreIntegratedValue(uint SubsurfaceProfileInt, half NoL, half Curvature)
|
|
{
|
|
float3 UV = float3((NoL * .5 + .5), Curvature, SubsurfaceProfileInt);
|
|
|
|
return Texture2DArraySampleLevel(View.SSProfilesPreIntegratedTexture, View.SSProfilesPreIntegratedSampler, UV, 0);
|
|
}
|
|
|
|
half3 GetEnvBRDF(half3 SpecularColor, half Roughness, half NoV)
|
|
{
|
|
#if FULLY_ROUGH
|
|
return 0.0f;
|
|
#elif MOBILE_USE_PREINTEGRATED_GF
|
|
return EnvBRDF(SpecularColor, Roughness, NoV);
|
|
#elif NONMETAL
|
|
// If nothing is hooked up to Metalic and Specular,
|
|
// then defaults are the same as a non-metal,
|
|
// so this define is safe.
|
|
return EnvBRDFApproxNonmetal(Roughness, NoV).xxx;
|
|
#else
|
|
return EnvBRDFApprox(SpecularColor, Roughness, NoV);
|
|
#endif
|
|
}
|
|
#endif // SHADING_PATH_MOBILE
|
|
|
|
struct FDirectLighting
|
|
{
|
|
float3 Diffuse;
|
|
float3 Specular;
|
|
float3 Transmission;
|
|
};
|
|
|
|
struct FShadowTerms
|
|
{
|
|
half SurfaceShadow;
|
|
half TransmissionShadow;
|
|
half TransmissionThickness;
|
|
FHairTransmittanceData HairTransmittance;
|
|
};
|
|
|
|
// UE_DEPRECATED 5.7 - Deprecated by Substrate
|
|
FDirectLighting HairBxDF(FGBufferData GBuffer, half3 N, half3 V, FAreaLight AreaLight, FShadowTerms Shadow)
|
|
{
|
|
const float3 BsdfValue = HairShading(GBuffer, AreaLight.DiffuseL, V, N, Shadow.TransmissionShadow, Shadow.HairTransmittance, HAIR_BSDF_BACKLIT, 0, uint2(0, 0));
|
|
|
|
FDirectLighting Lighting;
|
|
Lighting.Diffuse = 0;
|
|
Lighting.Specular = 0;
|
|
Lighting.Transmission = AreaLight.FalloffColor * AreaLight.Falloff * BsdfValue;
|
|
return Lighting;
|
|
}
|
|
|
|
float New_a2( float a2, float SinAlpha, float VoH )
|
|
{
|
|
return a2 + 0.25 * SinAlpha * (3.0 * sqrtFast(a2) + SinAlpha) / ( VoH + 0.001 );
|
|
//return a2 + 0.25 * SinAlpha * ( saturate(12 * a2 + 0.125) + SinAlpha ) / ( VoH + 0.001 );
|
|
//return a2 + 0.25 * SinAlpha * ( a2 * 2 + 1 + SinAlpha ) / ( VoH + 0.001 );
|
|
}
|
|
|
|
float EnergyNormalization( inout float a2, float VoH, FAreaLight AreaLight )
|
|
{
|
|
if( AreaLight.SphereSinAlphaSoft > 0 )
|
|
{
|
|
// Modify Roughness
|
|
a2 = saturate( a2 + Pow2( AreaLight.SphereSinAlphaSoft ) / ( VoH * 3.6 + 0.4 ) );
|
|
}
|
|
|
|
float Sphere_a2 = a2;
|
|
float Energy = 1;
|
|
if( AreaLight.SphereSinAlpha > 0 )
|
|
{
|
|
Sphere_a2 = New_a2( a2, AreaLight.SphereSinAlpha, VoH );
|
|
Energy = a2 / Sphere_a2;
|
|
}
|
|
|
|
if( AreaLight.LineCosSubtended < 1 )
|
|
{
|
|
#if 1
|
|
float LineCosTwoAlpha = AreaLight.LineCosSubtended;
|
|
float LineTanAlpha = sqrt( ( 1.0001 - LineCosTwoAlpha ) / ( 1 + LineCosTwoAlpha ) );
|
|
float Line_a2 = New_a2( Sphere_a2, LineTanAlpha, VoH );
|
|
Energy *= sqrt( Sphere_a2 / max(Line_a2, 1e-5) );
|
|
#else
|
|
float LineCosTwoAlpha = AreaLight.LineCosSubtended;
|
|
float LineSinAlpha = sqrt( 0.5 - 0.5 * LineCosTwoAlpha );
|
|
float Line_a2 = New_a2( Sphere_a2, LineSinAlpha, VoH );
|
|
Energy *= Sphere_a2 / max(Line_a2, 1e-5);
|
|
#endif
|
|
}
|
|
|
|
return Energy;
|
|
}
|
|
|
|
// UE_DEPRECATED 5.7 - Deprecated by Substrate
|
|
float3 SpecularGGX(float Roughness, float Anisotropy, float3 SpecularColor, BxDFContext Context, FAreaLight AreaLight)
|
|
{
|
|
float Alpha = Roughness * Roughness;
|
|
float ax = 0;
|
|
float ay = 0;
|
|
GetAnisotropicRoughness(Alpha, Anisotropy, ax, ay);
|
|
|
|
// Generalized microfacet specular
|
|
float3 D = D_GGXaniso(ax, ay, Context.NoH, Context.XoH, Context.YoH);
|
|
float3 Vis = Vis_SmithJointAniso(ax, ay, Context.NoV, AreaLight.NoL, Context.XoV, Context.XoL, Context.YoV, Context.YoL);
|
|
float3 F = F_Schlick( SpecularColor, Context.VoH );
|
|
|
|
return (D * Vis) * F;
|
|
}
|
|
|
|
// UE_DEPRECATED 5.7 - Deprecated by Substrate
|
|
float3 SpecularGGX( float Roughness, float3 SpecularColor, BxDFContext Context, FAreaLight AreaLight )
|
|
{
|
|
float a2 = Pow4( Roughness );
|
|
float Energy = EnergyNormalization( a2, Context.VoH, AreaLight );
|
|
|
|
// Generalized microfacet specular
|
|
float D = D_GGX( a2, Context.NoH ) * Energy;
|
|
float Vis = Vis_SmithJointApprox( a2, Context.NoV, AreaLight.NoL );
|
|
float3 F = F_Schlick( SpecularColor, Context.VoH );
|
|
|
|
return (D * Vis) * F;
|
|
}
|
|
|
|
// UE_DEPRECATED 5.7 - Deprecated by Substrate
|
|
half3 DualSpecularGGX(half AverageRoughness, half Lobe0Roughness, half Lobe1Roughness, half LobeMix, half3 SpecularColor, BxDFContext Context, FAreaLight AreaLight)
|
|
{
|
|
float AverageAlpha2 = Pow4(AverageRoughness);
|
|
float Lobe0Alpha2 = Pow4(Lobe0Roughness);
|
|
float Lobe1Alpha2 = Pow4(Lobe1Roughness);
|
|
|
|
float Lobe0Energy = EnergyNormalization(Lobe0Alpha2, Context.VoH, AreaLight);
|
|
float Lobe1Energy = EnergyNormalization(Lobe1Alpha2, Context.VoH, AreaLight);
|
|
|
|
// Generalized microfacet specular
|
|
float D = lerp(D_GGX(Lobe0Alpha2, Context.NoH) * Lobe0Energy, D_GGX(Lobe1Alpha2, Context.NoH) * Lobe1Energy, LobeMix);
|
|
float Vis = Vis_SmithJointApprox(AverageAlpha2, Context.NoV, AreaLight.NoL); // Average visibility well approximates using two separate ones (one per lobe).
|
|
float3 F = F_Schlick(SpecularColor, Context.VoH);
|
|
|
|
return (D * Vis) * F;
|
|
}
|
|
|
|
// UE_DEPRECATED 5.7 - Deprecated by Substrate
|
|
FDirectLighting DefaultLitBxDF( FGBufferData GBuffer, half3 N, half3 V, FAreaLight AreaLight, FShadowTerms Shadow )
|
|
{
|
|
BxDFContext Context;
|
|
FDirectLighting Lighting;
|
|
Lighting.Diffuse = 0;
|
|
Lighting.Specular = 0;
|
|
Lighting.Transmission = 0;
|
|
|
|
BRANCH
|
|
if (AreaLight.NoL > 0.0f)
|
|
{
|
|
#if SUPPORTS_ANISOTROPIC_MATERIALS
|
|
bool bHasAnisotropy = HasAnisotropy(GBuffer.SelectiveOutputMask);
|
|
#else
|
|
bool bHasAnisotropy = false;
|
|
#endif
|
|
|
|
float NoV, VoH, NoH;
|
|
BRANCH
|
|
if (bHasAnisotropy)
|
|
{
|
|
half3 X = GBuffer.WorldTangent;
|
|
half3 Y = normalize(cross(N, X));
|
|
Init(Context, N, X, Y, V, AreaLight.SpecularL);
|
|
|
|
NoV = Context.NoV;
|
|
VoH = Context.VoH;
|
|
NoH = Context.NoH;
|
|
}
|
|
else
|
|
{
|
|
#if SHADING_PATH_MOBILE
|
|
InitMobile(Context, N, V, AreaLight.SpecularL, AreaLight.NoL);
|
|
#else
|
|
Init(Context, N, V, AreaLight.SpecularL);
|
|
#endif
|
|
|
|
NoV = Context.NoV;
|
|
VoH = Context.VoH;
|
|
NoH = Context.NoH;
|
|
|
|
SphereMaxNoH(Context, AreaLight.SphereSinAlpha, true);
|
|
}
|
|
|
|
Context.NoV = saturate(abs( Context.NoV ) + 1e-5);
|
|
|
|
#if MATERIAL_ROUGHDIFFUSE
|
|
// Diffuse model with roughness == specular roughness. This is not necessarily a good model of reality because it assumes microfacets with lambertian response.
|
|
// The limit behavior of SSS as the mean free path gets small behaves differently, but this is a start.
|
|
// Also we cannot use the morphed context maximising NoH as this is causing visual artefact when interpolating rough/smooth diffuse response. (SUBSTRATE_TODO: Check this again with latest rough diffuse model)
|
|
Lighting.Diffuse = Diffuse_GGX_Rough(GBuffer.DiffuseColor, GBuffer.Roughness, NoV, AreaLight.NoL, VoH, NoH, GetAreaLightDiffuseMicroReflWeight(AreaLight));
|
|
#else
|
|
Lighting.Diffuse = Diffuse_Lambert(GBuffer.DiffuseColor);
|
|
#endif
|
|
Lighting.Diffuse *= AreaLight.FalloffColor * (AreaLight.Falloff * AreaLight.NoL);
|
|
|
|
BRANCH
|
|
if (bHasAnisotropy)
|
|
{
|
|
Lighting.Specular = AreaLight.FalloffColor * (AreaLight.Falloff * AreaLight.NoL) * SpecularGGX(GBuffer.Roughness, GBuffer.Anisotropy, GBuffer.SpecularColor, Context, AreaLight);
|
|
}
|
|
else
|
|
{
|
|
if( IsRectLight(AreaLight) )
|
|
{
|
|
Lighting.Specular = RectGGXApproxLTC(GBuffer.Roughness, GBuffer.SpecularColor, N, V, AreaLight.Rect, AreaLight.Texture);
|
|
}
|
|
else
|
|
{
|
|
Lighting.Specular = AreaLight.FalloffColor * (AreaLight.Falloff * AreaLight.NoL) * SpecularGGX(GBuffer.Roughness, GBuffer.SpecularColor, Context, AreaLight);
|
|
}
|
|
}
|
|
|
|
FBxDFEnergyTerms EnergyTerms = ComputeGGXSpecEnergyTerms(GBuffer.Roughness, Context.NoV, GBuffer.SpecularColor);
|
|
|
|
// Add energy presevation (i.e. attenuation of the specular layer onto the diffuse component
|
|
Lighting.Diffuse *= ComputeEnergyPreservation(EnergyTerms);
|
|
|
|
// Add specular microfacet multiple scattering term (energy-conservation)
|
|
Lighting.Specular *= ComputeEnergyConservation(EnergyTerms);
|
|
|
|
Lighting.Transmission = 0;
|
|
}
|
|
|
|
return Lighting;
|
|
}
|
|
|
|
// UE_DEPRECATED 5.7 - Deprecated by Substrate
|
|
// Simple default lit model used by Lumen
|
|
float3 SimpleShading( float3 DiffuseColor, float3 SpecularColor, float Roughness, float3 L, float3 V, half3 N )
|
|
{
|
|
const float NoV = saturate(dot(N, V));
|
|
const FBxDFEnergyTerms EnergyTerms = ComputeGGXSpecEnergyTerms(Roughness, NoV, SpecularColor);
|
|
|
|
float3 H = normalize(V + L);
|
|
float NoH = saturate( dot(N, H) );
|
|
|
|
// Generalized microfacet specular
|
|
float D = D_GGX( Pow4(Roughness), NoH );
|
|
float Vis = Vis_Implicit();
|
|
float3 F = F_None( SpecularColor );
|
|
|
|
return
|
|
Diffuse_Lambert( DiffuseColor ) * ComputeEnergyPreservation(EnergyTerms) +
|
|
(D * Vis) * F * ComputeEnergyConservation(EnergyTerms);
|
|
}
|
|
|
|
float RefractBlend(float VoH, float Eta)
|
|
{
|
|
// Refraction blend factor for normal component of VoH
|
|
float k = 1.0 - Eta * Eta * (1.0 - VoH * VoH);
|
|
return Eta * VoH - sqrt(k);
|
|
}
|
|
|
|
half RefractBlendClearCoatApprox(half VoH)
|
|
{
|
|
// Polynomial approximation of refraction blend factor for normal component of VoH with fixed Eta (1/1.5):
|
|
return (0.63 - 0.22 * VoH) * VoH - 0.745;
|
|
}
|
|
|
|
float3 Refract(float3 V, float3 H, float Eta)
|
|
{
|
|
// Assumes V points away from the point of incidence
|
|
float VoH = dot(V, H);
|
|
return RefractBlend(VoH, Eta) * H - Eta * V;
|
|
}
|
|
|
|
BxDFContext RefractClearCoatContext(BxDFContext Context)
|
|
{
|
|
// Reference: Propagation of refraction through dot-product NoV
|
|
// Note: This version of Refract requires V to point away from the point of incidence
|
|
// NoV2 = -dot(N, Refract(V, H, Eta))
|
|
// NoV2 = -dot(N, RefractBlend(VoH, Eta) * H - Eta * V)
|
|
// NoV2 = -(RefractBlend(VoH, Eta) * NoH - Eta * NoV)
|
|
// NoV2 = Eta * NoV - RefractBlend(VoH, Eta) * NoH
|
|
// NoV2 = 1.0 / 1.5 * NoV - RefractBlendClearCoatApprox(VoH) * NoH
|
|
|
|
BxDFContext RefractedContext = Context;
|
|
half Eta = 1.0 / 1.5;
|
|
half RefractionBlendFactor = RefractBlendClearCoatApprox(Context.VoH);
|
|
half RefractionProjectionTerm = RefractionBlendFactor * Context.NoH;
|
|
RefractedContext.NoV = clamp(Eta * Context.NoV - RefractionProjectionTerm, 0.001, 1.0); // Due to CalcThinTransmission and Vis_SmithJointAniso, we need to make sure
|
|
RefractedContext.NoL = clamp(Eta * Context.NoL - RefractionProjectionTerm, 0.001, 1.0); // those values are not 0s to avoid NaNs.
|
|
RefractedContext.VoH = saturate(Eta * Context.VoH - RefractionBlendFactor);
|
|
RefractedContext.VoL = 2.0 * RefractedContext.VoH * RefractedContext.VoH - 1.0;
|
|
RefractedContext.NoH = Context.NoH;
|
|
return RefractedContext;
|
|
}
|
|
|
|
// UE_DEPRECATED 5.7 - Deprecated by Substrate
|
|
FDirectLighting ClearCoatBxDF( FGBufferData GBuffer, half3 N, half3 V, FAreaLight AreaLight, FShadowTerms Shadow )
|
|
{
|
|
const float ClearCoat = GBuffer.CustomData.x;
|
|
const float ClearCoatRoughness = max(GBuffer.CustomData.y, 0.02f);
|
|
|
|
FDirectLighting Lighting = {
|
|
float3(0.0, 0.0, 0.0),
|
|
float3(0.0, 0.0, 0.0),
|
|
float3(0.0, 0.0, 0.0)
|
|
};
|
|
|
|
BxDFContext Context;
|
|
half3 Nspec = N;
|
|
|
|
if (CLEAR_COAT_BOTTOM_NORMAL)
|
|
{
|
|
Nspec = GBuffer.WorldNormal;
|
|
}
|
|
|
|
#if SUPPORTS_ANISOTROPIC_MATERIALS
|
|
bool bHasAnisotropy = HasAnisotropy(GBuffer.SelectiveOutputMask);
|
|
#else
|
|
bool bHasAnisotropy = false;
|
|
#endif
|
|
|
|
half3 X = 0;
|
|
half3 Y = 0;
|
|
|
|
//////////////////////////////
|
|
/// Top Layer
|
|
//////////////////////////////
|
|
|
|
// No anisotropy for the top layer
|
|
Init(Context, Nspec, V, AreaLight.SpecularL);
|
|
|
|
// Modify SphereSinAlpha, knowing that it was previously manipulated by roughness of the under coat
|
|
// Note: the operation is not invertible for GBuffer.Roughness = 1.0, so roughness is clamped to 254.0/255.0
|
|
float SphereSinAlpha = AreaLight.SphereSinAlpha;
|
|
float RoughnessCompensation = 1 - Pow2(GBuffer.Roughness);
|
|
half Alpha = ClearCoatRoughness * ClearCoatRoughness;
|
|
RoughnessCompensation = RoughnessCompensation > 0.0 ? (1 - Alpha) / RoughnessCompensation : 0.0;
|
|
AreaLight.SphereSinAlpha = saturate(AreaLight.SphereSinAlpha * RoughnessCompensation);
|
|
|
|
SphereMaxNoH(Context, AreaLight.SphereSinAlpha, CLEAR_COAT_BOTTOM_NORMAL == 0);
|
|
Context.NoV = saturate(abs(Context.NoV) + 1e-5);
|
|
const bool bIsRect = IsRectLight(AreaLight);
|
|
Context.VoH = bIsRect ? Context.NoV : Context.VoH;
|
|
|
|
// Hard-coded Fresnel evaluation with IOR = 1.5 (for polyurethane cited by Disney BRDF)
|
|
float F0 = 0.04;
|
|
float Fc = Pow5(1 - Context.VoH);
|
|
float F = Fc + (1 - Fc) * F0;
|
|
|
|
FBxDFEnergyTerms EnergyTermsCoat = ComputeGGXSpecEnergyTerms(ClearCoatRoughness, Context.NoV, F0);
|
|
|
|
if (bIsRect)
|
|
{
|
|
Lighting.Specular = ClearCoat * RectGGXApproxLTC(ClearCoatRoughness, F0, Nspec, V, AreaLight.Rect, AreaLight.Texture);
|
|
}
|
|
else
|
|
{
|
|
// Generalized microfacet specular
|
|
float a2 = Pow2(Alpha);
|
|
float ClearCoatEnergy = EnergyNormalization(a2, Context.VoH, AreaLight);
|
|
half Vis = Vis_SmithJointApprox(a2, Context.NoV, AreaLight.NoL);
|
|
float D = D_GGX(a2, Context.NoH) * ClearCoatEnergy;
|
|
half Fr1 = (D * Vis) * F;
|
|
Lighting.Specular = ClearCoat * AreaLight.FalloffColor * (AreaLight.Falloff * AreaLight.NoL * Fr1);
|
|
}
|
|
Lighting.Specular *= ComputeEnergyConservation(EnergyTermsCoat);
|
|
|
|
// Restore previously changed SphereSinAlpha for the top layer.
|
|
// Alpha needs to also be restored to the bottom layer roughness.
|
|
AreaLight.SphereSinAlpha = SphereSinAlpha;
|
|
Alpha = Pow2(GBuffer.Roughness);
|
|
|
|
// Incoming and exiting Fresnel terms are identical to incoming Fresnel term (VoH == HoL)
|
|
// float FresnelCoeff = (1.0 - F1) * (1.0 - F2);
|
|
#if USE_ENERGY_CONSERVATION
|
|
float3 FresnelCoeff = ComputeEnergyPreservation(EnergyTermsCoat); // 1.0 - F;
|
|
#else
|
|
// Preserve old behavior when energy conservation is disabled
|
|
half FresnelCoeff = 1.0 - F;
|
|
#endif
|
|
FresnelCoeff *= FresnelCoeff;
|
|
|
|
//////////////////////////////
|
|
/// Bottom Layer
|
|
//////////////////////////////
|
|
|
|
if (CLEAR_COAT_BOTTOM_NORMAL)
|
|
{
|
|
BxDFContext TempContext;
|
|
|
|
BRANCH
|
|
if (bHasAnisotropy)
|
|
{
|
|
Init(TempContext, N, X, Y, V, AreaLight.SpecularL);
|
|
}
|
|
else
|
|
{
|
|
Init(TempContext, Nspec, V, AreaLight.SpecularL);
|
|
}
|
|
|
|
// If bottom-normal, update normal-based dot products:
|
|
float3 H = normalize(V + AreaLight.SpecularL);
|
|
Context.NoH = saturate(dot(N, H));
|
|
Context.NoV = saturate(dot(N, V));
|
|
Context.NoL = saturate(dot(N, AreaLight.SpecularL));
|
|
Context.VoL = saturate(dot(V, AreaLight.SpecularL));
|
|
Context.VoH = saturate(dot(V, H));
|
|
|
|
Context.XoV = TempContext.XoV;
|
|
Context.XoL = TempContext.XoL;
|
|
Context.XoH = TempContext.XoH;
|
|
Context.YoV = TempContext.YoV;
|
|
Context.YoL = TempContext.YoL;
|
|
Context.YoH = TempContext.YoH;
|
|
|
|
if (!bHasAnisotropy)
|
|
{
|
|
bool bNewtonIteration = true;
|
|
SphereMaxNoH(Context, AreaLight.SphereSinAlpha, bNewtonIteration);
|
|
}
|
|
|
|
Context.NoV = saturate(abs(Context.NoV) + 1e-5);
|
|
}
|
|
|
|
// Propagate refraction through dot-products rather than the original vectors:
|
|
// Reference:
|
|
// float Eta = 1.0 / 1.5;
|
|
// float3 H = normalize(V + L);
|
|
// float3 V2 = Refract(V, H, Eta);
|
|
// float3 L2 = reflect(V2, H);
|
|
// V2 = -V2;
|
|
// BxDFContext BottomContext;
|
|
// Init(BottomContext, N, X, Y, V2, L2);
|
|
if (bHasAnisotropy)
|
|
{
|
|
// Prepare the anisotropic Context to refract.
|
|
X = GBuffer.WorldTangent;
|
|
Y = normalize(cross(N, X));
|
|
Init(Context, Nspec, X, Y, V, AreaLight.SpecularL);
|
|
}
|
|
BxDFContext BottomContext = RefractClearCoatContext(Context);
|
|
BottomContext.VoH = bIsRect ? BottomContext.NoV : BottomContext.VoH;
|
|
|
|
FBxDFEnergyTerms EnergyTermsBottom = ComputeGGXSpecEnergyTerms(GBuffer.Roughness, BottomContext.NoV, GBuffer.SpecularColor);
|
|
|
|
// Absorption
|
|
float3 Transmission = SimpleClearCoatTransmittance(BottomContext.NoL, BottomContext.NoV, GBuffer.Metallic, GBuffer.BaseColor);
|
|
|
|
// Default Lit
|
|
half3 DefaultDiffuse = (AreaLight.Falloff * AreaLight.NoL) * AreaLight.FalloffColor * Diffuse_Lambert(GBuffer.DiffuseColor) * ComputeEnergyPreservation(EnergyTermsBottom);
|
|
half3 RefractedDiffuse = FresnelCoeff * Transmission * DefaultDiffuse;
|
|
Lighting.Diffuse = lerp(DefaultDiffuse, RefractedDiffuse, ClearCoat);
|
|
|
|
if (!bHasAnisotropy && bIsRect)
|
|
{
|
|
// Note: V is used instead of V2 because LTC integration is not tuned to handle refraction direction
|
|
float3 DefaultSpecular = RectGGXApproxLTC(GBuffer.Roughness, GBuffer.SpecularColor, N, V, AreaLight.Rect, AreaLight.Texture);
|
|
float3 RefractedSpecular = FresnelCoeff * Transmission * DefaultSpecular;
|
|
Lighting.Specular += lerp(DefaultSpecular, RefractedSpecular, ClearCoat);
|
|
}
|
|
else
|
|
{
|
|
float a2 = Pow4(GBuffer.Roughness);
|
|
half D2 = 0;
|
|
half Vis2 = 0;
|
|
|
|
// The energy factor for correcting area light shape needs to be computed "before" the actual D_GGX term,
|
|
// as calling EnergyNormalization() modify the "a2" value.
|
|
float Energy = 1;
|
|
BRANCH
|
|
if (!bHasAnisotropy)
|
|
{
|
|
Energy = EnergyNormalization(a2, Context.VoH, AreaLight);
|
|
}
|
|
|
|
BRANCH
|
|
if (bHasAnisotropy)
|
|
{
|
|
float ax = 0;
|
|
float ay = 0;
|
|
GetAnisotropicRoughness(Alpha, GBuffer.Anisotropy, ax, ay);
|
|
|
|
D2 = D_GGXaniso(ax, ay, Context.NoH, Context.XoH, Context.YoH);
|
|
Vis2 = Vis_SmithJointAniso(ax, ay, BottomContext.NoV, BottomContext.NoL, BottomContext.XoV, BottomContext.XoL, BottomContext.YoV, BottomContext.YoL);
|
|
}
|
|
else
|
|
{
|
|
// NoL is chosen to provide better parity with DefaultLit when ClearCoat=0
|
|
Vis2 = Vis_SmithJointApprox(a2, BottomContext.NoV, AreaLight.NoL);
|
|
D2 = D_GGX(a2, BottomContext.NoH);
|
|
}
|
|
half3 F_Bot = F_Schlick(GBuffer.SpecularColor, BottomContext.VoH);
|
|
half3 F_DefaultLit = F_Schlick(GBuffer.SpecularColor, Context.VoH);
|
|
|
|
|
|
// Note: reusing D and V from refracted context to save computation when ClearCoat < 1
|
|
float3 CommonSpecular = (Energy * AreaLight.Falloff * AreaLight.NoL * D2 * Vis2) * AreaLight.FalloffColor;
|
|
float3 DefaultSpecular = F_DefaultLit;
|
|
float3 RefractedSpecular = FresnelCoeff * Transmission * F_Bot;
|
|
Lighting.Specular += CommonSpecular * lerp(DefaultSpecular, RefractedSpecular, ClearCoat);
|
|
}
|
|
|
|
return Lighting;
|
|
}
|
|
|
|
// HG phase function approximated
|
|
float ApproximateHG(float cosJ, float g)
|
|
{
|
|
float g2 = g * g;
|
|
float gcos2 = 1.0f - (g * cosJ);
|
|
gcos2 *= gcos2;
|
|
|
|
const float ISO_PHASE_FUNC_Normalized = 0.5;
|
|
|
|
return (ISO_PHASE_FUNC_Normalized * (1.0f - g2) / max( 1e-5, gcos2));
|
|
}
|
|
|
|
void GetProfileDualSpecular(uint SubsurfaceProfileInt, half Roughness, half Opacity, out half LobeRoughness0, out half LobeRoughness1, out half LobeMix)
|
|
{
|
|
#if !FORWARD_SHADING
|
|
GetSubsurfaceProfileDualSpecular(SubsurfaceProfileInt, Roughness, Opacity, LobeRoughness0, LobeRoughness1, LobeMix);
|
|
#else
|
|
// Disable dual lobe, as subsurface profile doesn't work with forward.
|
|
LobeRoughness0 = Roughness;
|
|
LobeRoughness1 = Roughness;
|
|
LobeMix = 0.f;
|
|
#endif
|
|
}
|
|
|
|
// UE_DEPRECATED 5.7 - Deprecated by Substrate
|
|
FDirectLighting SubsurfaceProfileBxDF( FGBufferData GBuffer, half3 N, half3 V, FAreaLight AreaLight, FShadowTerms Shadow )
|
|
{
|
|
BxDFContext Context;
|
|
#if SHADING_PATH_MOBILE
|
|
InitMobile(Context, N, V, AreaLight.SpecularL, AreaLight.NoL);
|
|
#else
|
|
Init( Context, N, V, AreaLight.SpecularL );
|
|
#endif
|
|
SphereMaxNoH( Context, AreaLight.SphereSinAlpha, true );
|
|
Context.NoV = saturate( abs( Context.NoV ) + 1e-5 );
|
|
|
|
uint SubsurfaceProfileId = ExtractSubsurfaceProfileInt(GBuffer);
|
|
half Opacity = GBuffer.CustomData.a;
|
|
half Roughness = GBuffer.Roughness;
|
|
|
|
half Lobe0Roughness = 0;
|
|
half Lobe1Roughness = 0;
|
|
half LobeMix = 0;
|
|
|
|
GetProfileDualSpecular(SubsurfaceProfileId, Roughness, Opacity, Lobe0Roughness, Lobe1Roughness, LobeMix);
|
|
half AverageRoughness = lerp(Lobe0Roughness, Lobe1Roughness, LobeMix);
|
|
|
|
// Take the average roughness instead of compute a separate energy term for each roughness
|
|
const FBxDFEnergyTerms EnergyTerms = ComputeGGXSpecEnergyTerms(AverageRoughness, Context.NoV, GBuffer.SpecularColor);
|
|
|
|
FDirectLighting Lighting;
|
|
#if SHADING_PATH_MOBILE
|
|
half Curvature = GBuffer.Curvature;
|
|
half UnClampedNoL = dot(GBuffer.WorldNormal, AreaLight.DiffuseL);
|
|
half ShadowFactor = 1.0f - sqrt(Shadow.SurfaceShadow);
|
|
// Rotate the world normal based on the shadow value, it's just a experimental value
|
|
half UnClampedRotatedNoL = max(UnClampedNoL - max(2.0f * UnClampedNoL, 0.4f) * ShadowFactor, -1.0f);
|
|
half4 BurleyDiffuse = GetSSProfilePreIntegratedValue(SubsurfaceProfileId, UnClampedRotatedNoL, Curvature);
|
|
// asset specific color
|
|
half3 Tint = GetSubsurfaceProfileTexture(SSSS_TINT_SCALE_OFFSET, SubsurfaceProfileId).rgb;
|
|
|
|
// Needs to apply shadow at here, since the preintegrated value has already counted it, and we need to skip applying shadow outside.
|
|
Lighting.Diffuse = lerp(AreaLight.FalloffColor * (AreaLight.Falloff * AreaLight.NoL) * Shadow.SurfaceShadow, BurleyDiffuse.rgb, Tint) * Diffuse_Lambert(GBuffer.DiffuseColor);
|
|
#else
|
|
|
|
#if MATERIAL_ROUGHDIFFUSE
|
|
// Use Chan's diffuse model. It reduces flatness look and has better match, e.g., at the edge of human face skin when compared to GT.
|
|
const float3 DiffuseReflection = Diffuse_GGX_Rough(GBuffer.DiffuseColor, GBuffer.Roughness, Context.NoV, AreaLight.NoL, Context.VoH, Context.NoH, GetAreaLightDiffuseMicroReflWeight(AreaLight));
|
|
#else
|
|
const float3 DiffuseReflection = Diffuse_Burley(GBuffer.DiffuseColor, GBuffer.Roughness, Context.NoV, AreaLight.NoL, Context.VoH);
|
|
#endif
|
|
|
|
Lighting.Diffuse = AreaLight.FalloffColor * (AreaLight.Falloff * AreaLight.NoL) * DiffuseReflection;
|
|
#endif
|
|
|
|
if (IsRectLight(AreaLight))
|
|
{
|
|
float3 Lobe0Specular = RectGGXApproxLTC(Lobe0Roughness, GBuffer.SpecularColor, N, V, AreaLight.Rect, AreaLight.Texture);
|
|
float3 Lobe1Specular = RectGGXApproxLTC(Lobe1Roughness, GBuffer.SpecularColor, N, V, AreaLight.Rect, AreaLight.Texture);
|
|
Lighting.Specular = lerp(Lobe0Specular, Lobe1Specular, LobeMix);
|
|
}
|
|
else
|
|
{
|
|
Lighting.Specular = AreaLight.FalloffColor * (AreaLight.Falloff * AreaLight.NoL) * DualSpecularGGX(AverageRoughness, Lobe0Roughness, Lobe1Roughness, LobeMix, GBuffer.SpecularColor, Context, AreaLight);
|
|
}
|
|
|
|
Lighting.Diffuse *= ComputeEnergyPreservation(EnergyTerms);
|
|
Lighting.Specular *= ComputeEnergyConservation(EnergyTerms);
|
|
|
|
#if USE_TRANSMISSION
|
|
|
|
const uint ProfileId = ExtractSubsurfaceProfileInt(GBuffer);
|
|
FTransmissionProfileParams TransmissionParams = GetTransmissionProfileParams(ProfileId);
|
|
|
|
float Thickness = Shadow.TransmissionThickness;
|
|
Thickness = DecodeThickness(Thickness);
|
|
Thickness *= SSSS_MAX_TRANSMISSION_PROFILE_DISTANCE;
|
|
float3 Profile = GetTransmissionProfile(ProfileId, Thickness).rgb;
|
|
|
|
float3 RefracV = refract(V, -N, TransmissionParams.OneOverIOR);
|
|
float PhaseFunction = ApproximateHG( dot(-AreaLight.DiffuseL, RefracV), TransmissionParams.ScatteringDistribution );
|
|
Lighting.Transmission = AreaLight.FalloffColor * Profile * (AreaLight.Falloff * PhaseFunction); // TODO: This probably should also include cosine term (NoL)
|
|
|
|
#else // USE_TRANSMISSION
|
|
|
|
Lighting.Transmission = 0;
|
|
|
|
#endif // USE_TRANSMISSION
|
|
|
|
return Lighting;
|
|
}
|
|
|
|
// UE_DEPRECATED 5.7 - Deprecated by Substrate
|
|
FDirectLighting ClothBxDF( FGBufferData GBuffer, half3 N, half3 V, FAreaLight AreaLight, FShadowTerms Shadow )
|
|
{
|
|
const float3 FuzzColor = ExtractSubsurfaceColor(GBuffer);
|
|
const float Cloth = saturate(GBuffer.CustomData.a);
|
|
|
|
BxDFContext Context;
|
|
#if SHADING_PATH_MOBILE
|
|
InitMobile(Context, N, V, AreaLight.SpecularL, AreaLight.NoL);
|
|
#else
|
|
Init( Context, N, V, AreaLight.SpecularL );
|
|
#endif
|
|
SphereMaxNoH( Context, AreaLight.SphereSinAlpha, true );
|
|
Context.NoV = saturate( abs( Context.NoV ) + 1e-5 );
|
|
|
|
float3 Spec1;
|
|
if(IsRectLight(AreaLight))
|
|
Spec1 = RectGGXApproxLTC( GBuffer.Roughness, GBuffer.SpecularColor, N, V, AreaLight.Rect, AreaLight.Texture );
|
|
else
|
|
Spec1 = AreaLight.FalloffColor * (AreaLight.Falloff * AreaLight.NoL) * SpecularGGX( GBuffer.Roughness, GBuffer.SpecularColor, Context, AreaLight );
|
|
|
|
const FBxDFEnergyTerms EnergyTerms1 = ComputeGGXSpecEnergyTerms(GBuffer.Roughness, Context.NoV, GBuffer.SpecularColor);
|
|
Spec1 *= ComputeEnergyConservation(EnergyTerms1);
|
|
|
|
// Cloth - Asperity Scattering - Inverse Beckmann Layer
|
|
float D2 = D_InvGGX( Pow4( GBuffer.Roughness ), Context.NoH );
|
|
float Vis2 = Vis_Cloth( Context.NoV, AreaLight.NoL );
|
|
#if SHADING_PATH_MOBILE
|
|
Vis2 = saturate(Vis2);
|
|
#endif
|
|
float3 F2 = F_Schlick( FuzzColor, Context.VoH );
|
|
float3 Spec2 = AreaLight.FalloffColor * (AreaLight.Falloff * AreaLight.NoL) * (D2 * Vis2) * F2;
|
|
|
|
const FBxDFEnergyTermsA EnergyTerms2 = ComputeClothEnergyTermsA(GBuffer.Roughness, Context.NoV);
|
|
Spec2 *= ComputeEnergyConservation(EnergyTerms2);
|
|
|
|
FDirectLighting Lighting;
|
|
Lighting.Diffuse = AreaLight.FalloffColor * (AreaLight.Falloff * AreaLight.NoL) * Diffuse_Lambert( GBuffer.DiffuseColor );
|
|
Lighting.Specular = lerp( Spec1, Spec2, Cloth );
|
|
Lighting.Transmission = 0;
|
|
|
|
Lighting.Diffuse *= lerp(ComputeEnergyPreservation(EnergyTerms1), ComputeEnergyPreservation(EnergyTerms2), Cloth);
|
|
|
|
return Lighting;
|
|
}
|
|
|
|
// UE_DEPRECATED 5.7 - Deprecated by Substrate
|
|
FDirectLighting SubsurfaceBxDF(FGBufferData GBuffer, half3 N, half3 V, FAreaLight AreaLight, FShadowTerms Shadow )
|
|
{
|
|
FDirectLighting Lighting = DefaultLitBxDF( GBuffer, N, V, AreaLight, Shadow);
|
|
|
|
half3 SubsurfaceColor = ExtractSubsurfaceColor(GBuffer);
|
|
half Opacity = GBuffer.CustomData.a;
|
|
|
|
// to get an effect when you see through the material
|
|
// hard coded pow constant
|
|
half InScatter = pow(saturate(dot(AreaLight.DiffuseL, -V)), 12) * lerp(3, .1f, Opacity);
|
|
|
|
// Wrap around lighting,
|
|
// * /(PI*2) to be energy consistent (hack do get some view dependnt and light dependent effect)
|
|
// * Opacity of 0 gives no normal dependent lighting, Opacity of 1 gives strong normal contribution
|
|
// * Simplified version (with w=.5, n=1.5):
|
|
// half WrappedDiffuse = 2 * pow(saturate((dot(N, L) + w) / (1.0f + w)), n) * (n + 1) / (2 * (1 + w));
|
|
// NormalContribution = WrappedDiffuse * Opacity + 1 - Opacity;
|
|
const half WrappedDiffuse = pow(saturate(dot(N, AreaLight.DiffuseL) * (1.f / 1.5f) + (0.5f / 1.5f)), 1.5f) * (2.5f / 1.5f);
|
|
const half NormalContribution = lerp(1.f, WrappedDiffuse, Opacity);
|
|
const half BackScatter = GBuffer.GBufferAO * NormalContribution / (PI * 2);
|
|
|
|
// Transmission
|
|
// * Emulate Beer-Lambert absorption by retrieving extinction coefficient from SubSurfaceColor. Subsurface is interpreted as a 'transmittance color'
|
|
// at a certain 'normalized' distance (SubSurfaceColorAsTransmittanceAtDistanceInMeters). This is a coarse approximation for getting hue-shiting.
|
|
// * TransmittedColor is computed for the 1-normalized distance, and then transformed back-and-forth in HSV space to preserving the luminance value
|
|
// of the original color, but getting hue shifting
|
|
const half3 ExtinctionCoefficients = TransmittanceToExtinction(SubsurfaceColor, View.SubSurfaceColorAsTransmittanceAtDistanceInMeters);
|
|
const half3 RawTransmittedColor = ExtinctionToTransmittance(ExtinctionCoefficients, 1.0f /*At 1 meters, as we use normalized units*/);
|
|
const half3 TransmittedColor = HSV_2_LinearRGB(half3(LinearRGB_2_HSV(RawTransmittedColor).xy, LinearRGB_2_HSV(SubsurfaceColor).z));
|
|
|
|
// lerp to never exceed 1 (energy conserving)
|
|
Lighting.Transmission = AreaLight.FalloffColor * (AreaLight.Falloff * lerp(BackScatter, 1, InScatter)) * lerp(TransmittedColor, SubsurfaceColor, Shadow.TransmissionThickness);
|
|
|
|
return Lighting;
|
|
}
|
|
|
|
#if 0 // SGGX ref
|
|
float PDF_GGX( float a2, half3 N, half3 H )
|
|
{
|
|
half NoH = saturate( dot(N,H) );
|
|
return D_GGX( a2, NoH ) * NoH;
|
|
}
|
|
|
|
float3 SimpleSpec( FGBufferData GBuffer, half3 N, half3 V, half3 L )
|
|
{
|
|
half3 H = normalize( L + V );
|
|
|
|
half NoL = saturate( dot(N,L) );
|
|
half NoV = saturate( dot(N,V) );
|
|
half VoL = saturate( dot(V,L) );
|
|
half NoH = saturate( dot(N,H) );
|
|
half VoH = saturate( dot(V,H) );
|
|
|
|
float a2 = Pow4( GBuffer.Roughness );
|
|
|
|
// Generalized microfacet specular
|
|
float D = D_GGX( a2, NoH );
|
|
float Vis = Vis_SmithJoint( a2, max( NoV, 1e-5 ), NoL );
|
|
float3 F = F_Schlick( GBuffer.SpecularColor, VoH );
|
|
|
|
return (D * Vis) * F;
|
|
}
|
|
|
|
FDirectLighting ShadeSGGX( FGBufferData GBuffer, float Geo_a2, half3 V, half3 L )
|
|
{
|
|
FDirectLighting Lighting = (FDirectLighting)0;
|
|
|
|
half VoL = dot(V, L);
|
|
half3 H = normalize( L + V );
|
|
|
|
float Mat_a2 = Pow4( GBuffer.Roughness );
|
|
|
|
const uint NumSamples = 64;
|
|
|
|
LOOP
|
|
for( uint i = 0; i < NumSamples; i++ )
|
|
{
|
|
RandomSequence RandSequence;
|
|
RandomSequence_Initialize( RandSequence, View.StateFrameIndex, i );
|
|
|
|
float4 Sample_VNDF = SGGX_DvisSample( RandomSequence_GenerateSample2D( RandSequence ), Geo_a2, V );
|
|
float MoL_VNDF = saturate( dot( Sample_VNDF.xyz, L ) );
|
|
|
|
{
|
|
float4 Sample_CosL = CosineSampleHemisphere( RandomSequence_GenerateSample2D( RandSequence ), L );
|
|
float MoL_CosL = saturate( dot( Sample_CosL.xyz, L ) );
|
|
float Dvis_CosL = SGGX_Dvis( Geo_a2, V.z, dot( V, Sample_CosL.xyz ), Sample_CosL.z );
|
|
|
|
Lighting.Diffuse += MoL_VNDF * MISWeightBalanced( Sample_VNDF.w, MoL_VNDF / PI );
|
|
//Lighting.Diffuse += Dvis_CosL * MoL_CosL / Sample_CosL.w * MISWeightBalanced( Sample_CosL.w, Dvis_CosL );
|
|
Lighting.Diffuse += Dvis_CosL * PI * MISWeightBalanced( Sample_CosL.w, Dvis_CosL );
|
|
}
|
|
|
|
{
|
|
float4 Sample_Material = ImportanceSampleGGX( RandomSequence_GenerateSample2D( RandSequence ), Mat_a2 );
|
|
Sample_Material.xyz = mul( Sample_Material.xyz, GetTangentBasis(H) );
|
|
|
|
float Dvis_Material = SGGX_Dvis( Geo_a2, V.z, dot( V, Sample_Material.xyz ), Sample_Material.z );
|
|
float MoL_Material = saturate( dot( Sample_Material.xyz, L ) );
|
|
|
|
Lighting.Specular += SimpleSpec( GBuffer, Sample_VNDF.xyz, V, L ) * MoL_VNDF * MISWeightBalanced( Sample_VNDF.w, PDF_GGX( Mat_a2, Sample_VNDF.xyz, H ) );
|
|
Lighting.Specular += SimpleSpec( GBuffer, Sample_Material.xyz, V, L ) * MoL_Material * Dvis_Material / Sample_Material.w * MISWeightBalanced( Sample_Material.w, Dvis_Material );
|
|
}
|
|
|
|
{
|
|
// http://blog.stevemcauley.com/2011/12/03/energy-conserving-wrapped-diffuse/
|
|
half Wrap = 0.5;
|
|
half WrapNoL = saturate( ( -dot( Sample_VNDF.xyz, L ) + Wrap ) / Square( 1 + Wrap ) );
|
|
|
|
// Scatter distribution
|
|
float Scatter = D_GGX( 0.6*0.6, saturate( -VoL ) );
|
|
|
|
Lighting.Transmission += WrapNoL * Scatter;
|
|
}
|
|
}
|
|
|
|
Lighting.Diffuse /= NumSamples;
|
|
Lighting.Specular /= NumSamples;
|
|
Lighting.Transmission /= NumSamples;
|
|
|
|
Lighting.Diffuse *= GBuffer.DiffuseColor / PI;
|
|
Lighting.Transmission *= ExtractSubsurfaceColor( GBuffer );
|
|
|
|
return Lighting;
|
|
}
|
|
#endif
|
|
|
|
// UE_DEPRECATED 5.7 - Deprecated by Substrate
|
|
FDirectLighting TwoSidedBxDF( FGBufferData GBuffer, half3 N, half3 V, FAreaLight AreaLight, FShadowTerms Shadow )
|
|
{
|
|
half3 SubsurfaceColor = ExtractSubsurfaceColor(GBuffer);
|
|
|
|
#if 0
|
|
half NormalLength2 = length2( GBuffer.NormalDistribution );
|
|
half RcpNormalLength = rsqrt( NormalLength2 );
|
|
half NormalLength = NormalLength2 * RcpNormalLength;
|
|
N = GBuffer.NormalDistribution * RcpNormalLength;
|
|
|
|
half3 L = AreaLight.DiffuseL;
|
|
half NoL = dot(N, L);
|
|
half NoV = dot(N, V);
|
|
half VoL = dot(V, L);
|
|
half InvLenH = rsqrt( 2 + 2 * VoL );
|
|
half NoH = ( NoL + NoV ) * InvLenH;
|
|
half VoH = InvLenH + InvLenH * VoL;
|
|
half3 H = ( L + V ) * InvLenH;
|
|
|
|
float Geo_a = 0.5 - 0.5 * NormalLength;
|
|
if( NoV < 0 )
|
|
Geo_a = 1 - Geo_a;
|
|
|
|
Geo_a = clamp( Geo_a, 0.01, 0.999 );
|
|
|
|
if( Geo_a > 0.5 )
|
|
Geo_a = rcp( 2 - 2 * Geo_a );
|
|
else
|
|
Geo_a = 2 * Geo_a;
|
|
|
|
float Geo_a2 = Pow2( Geo_a );
|
|
float Geo_Area = SGGX_SurfaceArea( Geo_a2 );
|
|
|
|
float3x3 TangentToWorld = GetTangentBasis( N );
|
|
|
|
float3 TangentV = mul( TangentToWorld, V );
|
|
float3 TangentL = mul( TangentToWorld, L );
|
|
|
|
float3 SphereScale = 1;
|
|
SphereScale.xy = Geo_a;
|
|
|
|
float3 SphereV = normalize( TangentV * SphereScale );
|
|
float3 SphereL = normalize( TangentL * SphereScale );
|
|
|
|
float SphereVoL = dot( SphereV, SphereL );
|
|
|
|
#if 0
|
|
float vNoV = SGGX_ProjectedArea( Geo_a2, NoV ) * 2 / Geo_Area;
|
|
float vNoL = SGGX_ProjectedArea( Geo_a2, NoL ) * 2 / Geo_Area;
|
|
#else
|
|
float vNoV = 2 * TangentV.z / ( SphereV.z * Geo_Area );
|
|
float vNoL = 2 * TangentL.z / ( SphereL.z * Geo_Area );
|
|
#endif
|
|
|
|
vNoL *= SGGX_Diffuse( SphereVoL );
|
|
vNoL *= lerp( 0.5 * PI, 2, saturate( Geo_a ) );
|
|
|
|
FDirectLighting Lighting = (FDirectLighting)0;
|
|
|
|
{
|
|
Lighting.Diffuse = AreaLight.FalloffColor * (AreaLight.Falloff * vNoL) * Diffuse_Lambert( GBuffer.DiffuseColor );
|
|
}
|
|
|
|
{
|
|
float Mat_a2 = Pow4( GBuffer.Roughness );
|
|
float Spec_a2 = SGGX_Convolve( Geo_a2, Mat_a2 );
|
|
|
|
float D = D_GGX( Spec_a2, NoH );
|
|
|
|
float Vis_SmithV = vNoL * SGGX_ProjectedArea( Spec_a2, NoV );
|
|
float Vis_SmithL = vNoV * SGGX_ProjectedArea( Spec_a2, NoL );
|
|
|
|
//Vis_SmithV = lerp( vNoL * SGGX_ProjectedArea( Mat_a2, vNoV ), Vis_SmithV, VoH );
|
|
Vis_SmithL = lerp( vNoV * SGGX_ProjectedArea( Mat_a2, vNoL ), Vis_SmithL, VoH );
|
|
|
|
float Vis = 0.5 * rcp( Vis_SmithV + Vis_SmithL );
|
|
|
|
float3 F = F_Schlick( GBuffer.SpecularColor, VoH );
|
|
|
|
Lighting.Specular = AreaLight.FalloffColor * (AreaLight.Falloff * vNoL * D * Vis) * F;
|
|
}
|
|
|
|
{
|
|
float InvNoL = -0.6 * SphereVoL;
|
|
InvNoL *= TangentL.z / SphereL.z;
|
|
InvNoL /= 0.25 * Geo_Area;
|
|
|
|
// http://blog.stevemcauley.com/2011/12/03/energy-conserving-wrapped-diffuse/
|
|
half Wrap = 0.5;
|
|
half WrapNoL = saturate( ( InvNoL + Wrap ) / Square( 1 + Wrap ) );
|
|
|
|
// Scatter distribution
|
|
float Scatter = D_GGX( 0.6*0.6, saturate( -VoL ) );
|
|
|
|
Lighting.Transmission = AreaLight.FalloffColor * (AreaLight.Falloff * WrapNoL * Scatter) * SubsurfaceColor;
|
|
}
|
|
#else
|
|
FDirectLighting Lighting = DefaultLitBxDF( GBuffer, N, V, AreaLight, Shadow );
|
|
|
|
// http://blog.stevemcauley.com/2011/12/03/energy-conserving-wrapped-diffuse/
|
|
half Wrap = 0.5;
|
|
half WrapNoL = saturate( ( -dot(N, AreaLight.DiffuseL) + Wrap ) / Square( 1 + Wrap ) );
|
|
|
|
// Scatter distribution
|
|
half VoL = dot(V, AreaLight.DiffuseL);
|
|
float Scatter = D_GGX( 0.6*0.6, saturate( -VoL ) );
|
|
|
|
Lighting.Transmission = AreaLight.FalloffColor * (AreaLight.Falloff * WrapNoL * Scatter) * SubsurfaceColor;
|
|
#endif
|
|
|
|
return Lighting;
|
|
}
|
|
|
|
// UE_DEPRECATED 5.7 - Deprecated by Substrate
|
|
FDirectLighting EyeBxDF( FGBufferData GBuffer, half3 N, half3 V, FAreaLight AreaLight, FShadowTerms Shadow )
|
|
{
|
|
#if IRIS_NORMAL
|
|
const float2 CausticNormalDelta = float2( GBuffer.StoredMetallic, GBuffer.StoredSpecular ) * 2 - (256.0/255.0);
|
|
const float2 IrisNormalDelta = float2( GBuffer.CustomData.y, GBuffer.CustomData.z ) * 2 - (256.0/255.0);
|
|
const float IrisMask = 1.0f - GBuffer.CustomData.w;
|
|
|
|
const float2 WorldNormalOct = UnitVectorToOctahedron( GBuffer.WorldNormal );
|
|
const float3 CausticNormal = OctahedronToUnitVector( WorldNormalOct + CausticNormalDelta );
|
|
const float3 IrisNormal = OctahedronToUnitVector( WorldNormalOct + IrisNormalDelta );
|
|
#else
|
|
const float3 IrisNormal = OctahedronToUnitVector( GBuffer.CustomData.yz * 2 - 1 );
|
|
const float IrisDistance = GBuffer.StoredMetallic;
|
|
const float IrisMask = 1.0f - GBuffer.CustomData.w;
|
|
|
|
// Blend in the negative intersection normal to create some concavity
|
|
// Not great as it ties the concavity to the convexity of the cornea surface
|
|
// No good justification for that. On the other hand, if we're just looking to
|
|
// introduce some concavity, this does the job.
|
|
const float3 CausticNormal = normalize(lerp(IrisNormal, -N, IrisMask*IrisDistance));
|
|
#endif
|
|
|
|
BxDFContext Context;
|
|
#if SHADING_PATH_MOBILE
|
|
InitMobile(Context, N, V, AreaLight.SpecularL, AreaLight.NoL);
|
|
#else
|
|
Init( Context, N, V, AreaLight.SpecularL );
|
|
#endif
|
|
SphereMaxNoH( Context, AreaLight.SphereSinAlpha, false );
|
|
Context.NoV = saturate( abs( Context.NoV ) + 1e-5 );
|
|
const bool bIsRect = IsRectLight(AreaLight);
|
|
Context.VoH = bIsRect ? Context.NoV : Context.VoH;
|
|
|
|
// F_Schlick
|
|
float F0 = GBuffer.Specular * 0.08;
|
|
float Fc = Pow5( 1 - Context.VoH );
|
|
float F = Fc + (1 - Fc) * F0;
|
|
|
|
const FBxDFEnergyTerms EnergyTerms = ComputeGGXSpecEnergyTerms(GBuffer.Roughness, Context.NoV, F0);
|
|
|
|
FDirectLighting Lighting;
|
|
|
|
if( bIsRect )
|
|
{
|
|
Lighting.Specular = RectGGXApproxLTC( GBuffer.Roughness, F0, N, V, AreaLight.Rect, AreaLight.Texture );
|
|
}
|
|
else
|
|
{
|
|
float a2 = Pow4( GBuffer.Roughness );
|
|
float Energy = EnergyNormalization( a2, Context.VoH, AreaLight );
|
|
// Generalized microfacet specular
|
|
float Vis = Vis_SmithJointApprox(a2, Context.NoV, AreaLight.NoL);
|
|
float D = D_GGX(a2, Context.NoH) * Energy;
|
|
Lighting.Specular = AreaLight.FalloffColor * (AreaLight.Falloff * AreaLight.NoL) * D * Vis * F;
|
|
}
|
|
|
|
float IrisNoL = saturate( dot( IrisNormal, AreaLight.SpecularL ) );
|
|
float Power = lerp( 12, 1, IrisNoL );
|
|
float Caustic = 0.8 + 0.2 * ( Power + 1 ) * pow( saturate( dot( CausticNormal, AreaLight.SpecularL ) ), Power );
|
|
float Iris = IrisNoL * Caustic;
|
|
float Sclera = AreaLight.NoL;
|
|
|
|
Lighting.Specular *= ComputeEnergyConservation(EnergyTerms);
|
|
|
|
#if USE_ENERGY_CONSERVATION
|
|
const float3 EnergyPreservation = ComputeEnergyPreservation(EnergyTerms);
|
|
#else
|
|
// Preserve old behavior when energy conservation is disabled
|
|
const float EnergyPreservation = 1.0f - F;
|
|
#endif
|
|
|
|
Lighting.Diffuse = 0;
|
|
Lighting.Transmission = AreaLight.FalloffColor * ( AreaLight.Falloff * lerp( Sclera, Iris, IrisMask ) * EnergyPreservation ) * Diffuse_Lambert( GBuffer.DiffuseColor );
|
|
#if SHADING_PATH_MOBILE
|
|
uint SubsurfaceProfileId = ExtractSubsurfaceProfileInt(GBuffer);
|
|
half Curvature = GBuffer.Curvature;
|
|
half ShadowFactor = 1.0f - sqrt(Shadow.SurfaceShadow);
|
|
|
|
// Rotate the world normal based on the shadow value, it's just a experimental value
|
|
half UnClampedNoL = dot(GBuffer.WorldNormal, AreaLight.DiffuseL);
|
|
half UnClampedRotatedNoL = max(UnClampedNoL - max(2.0f * UnClampedNoL, 0.4f) * ShadowFactor, -1.0f);
|
|
half4 BurleyDiffuse = GetSSProfilePreIntegratedValue(SubsurfaceProfileId, UnClampedRotatedNoL, Curvature);
|
|
|
|
// Rotate the world normal based on the shadow value, it's just a experimental value
|
|
half UnClampedIrisNoL = dot(IrisNormal, AreaLight.SpecularL);
|
|
half UnClampedRotatedIrisNoL = max(UnClampedIrisNoL - max(2.0f * UnClampedIrisNoL, 0.4f) * ShadowFactor, -1.0f);
|
|
half4 IrisBurleyDiffuse = GetSSProfilePreIntegratedValue(SubsurfaceProfileId, UnClampedRotatedIrisNoL * Caustic, Curvature);
|
|
// asset specific color
|
|
half3 Tint = GetSubsurfaceProfileTexture(SSSS_TINT_SCALE_OFFSET, SubsurfaceProfileId).rgb;
|
|
|
|
// Needs to apply shadow at here, since the preintegrated value has already counted it, and we need to skip applying shadow outside.
|
|
Lighting.Transmission = lerp(Lighting.Transmission * Shadow.SurfaceShadow, AreaLight.Falloff * lerp(BurleyDiffuse.rgb, IrisBurleyDiffuse.rgb, IrisMask) * Diffuse_Lambert(GBuffer.DiffuseColor), Tint);
|
|
#endif
|
|
return Lighting;
|
|
}
|
|
|
|
FDirectLighting PreintegratedSkinBxDF( FGBufferData GBuffer, half3 N, half3 V, FAreaLight AreaLight, FShadowTerms Shadow )
|
|
{
|
|
FDirectLighting Lighting = DefaultLitBxDF( GBuffer, N, V, AreaLight, Shadow );
|
|
|
|
half3 SubsurfaceColor = ExtractSubsurfaceColor(GBuffer);
|
|
half Opacity = GBuffer.CustomData.a;
|
|
|
|
half3 PreintegratedBRDF = Texture2DSampleLevel(View.PreIntegratedBRDF, View.PreIntegratedBRDFSampler, float2(saturate(dot(N, AreaLight.DiffuseL) * .5 + .5), 1 - Opacity), 0).rgb;
|
|
Lighting.Transmission = AreaLight.FalloffColor * AreaLight.Falloff * PreintegratedBRDF * SubsurfaceColor;
|
|
|
|
return Lighting;
|
|
}
|
|
|
|
// UE_DEPRECATED 5.7 - Deprecated by Substrate - Substrate uses SubstrateEvaluateBSDFCommon() instead
|
|
FDirectLighting IntegrateBxDF( FGBufferData GBuffer, half3 N, half3 V, FAreaLight AreaLight, FShadowTerms Shadow )
|
|
{
|
|
switch( GBuffer.ShadingModelID )
|
|
{
|
|
case SHADINGMODELID_DEFAULT_LIT:
|
|
case SHADINGMODELID_SINGLELAYERWATER:
|
|
case SHADINGMODELID_THIN_TRANSLUCENT:
|
|
return DefaultLitBxDF( GBuffer, N, V, AreaLight, Shadow );
|
|
case SHADINGMODELID_SUBSURFACE:
|
|
return SubsurfaceBxDF( GBuffer, N, V, AreaLight, Shadow );
|
|
case SHADINGMODELID_PREINTEGRATED_SKIN:
|
|
return PreintegratedSkinBxDF( GBuffer, N, V, AreaLight, Shadow );
|
|
case SHADINGMODELID_CLEAR_COAT:
|
|
return ClearCoatBxDF( GBuffer, N, V, AreaLight, Shadow );
|
|
case SHADINGMODELID_SUBSURFACE_PROFILE:
|
|
return SubsurfaceProfileBxDF( GBuffer, N, V, AreaLight, Shadow );
|
|
case SHADINGMODELID_TWOSIDED_FOLIAGE:
|
|
return TwoSidedBxDF( GBuffer, N, V, AreaLight, Shadow );
|
|
case SHADINGMODELID_HAIR:
|
|
return HairBxDF( GBuffer, N, V, AreaLight, Shadow );
|
|
case SHADINGMODELID_CLOTH:
|
|
return ClothBxDF( GBuffer, N, V, AreaLight, Shadow );
|
|
case SHADINGMODELID_EYE:
|
|
return EyeBxDF( GBuffer, N, V, AreaLight, Shadow );
|
|
default:
|
|
return (FDirectLighting)0;
|
|
}
|
|
}
|
|
|
|
// UE_DEPRECATED 5.7 - Deprecated by Substrate - Substrate uses SubstrateEvaluateBSDFCommon() instead
|
|
FDirectLighting EvaluateBxDF( FGBufferData GBuffer, half3 N, half3 V, half3 L, float NoL, FShadowTerms Shadow )
|
|
{
|
|
FAreaLight AreaLight = InitAreaLight();
|
|
AreaLight.DiffuseL = L;
|
|
AreaLight.SpecularL = L;
|
|
AreaLight.NoL = NoL;
|
|
|
|
return IntegrateBxDF( GBuffer, N, V, AreaLight, Shadow );
|
|
}
|