237 lines
10 KiB
HLSL
237 lines
10 KiB
HLSL
// _preIntegratedFGD and _CubemapLD are unique for each BRDF
|
|
IndirectLighting EvaluateBSDF_Env(LightLoopContext lightLoopContext,
|
|
float3 V, PositionInputs posInput,
|
|
PreLightData preLightData, EnvLightData lightData, BSDFData bsdfData,
|
|
int influenceShapeType,
|
|
inout float hierarchyWeight)
|
|
{
|
|
IndirectLighting lighting;
|
|
ZERO_INITIALIZE(IndirectLighting, lighting);
|
|
|
|
float3 envLighting;
|
|
float weight = 1.0;
|
|
|
|
float3 R = reflect(-V, bsdfData.normalWS);
|
|
|
|
EvaluateLight_EnvIntersection(posInput.positionWS, bsdfData.normalWS, lightData, influenceShapeType, R, weight);
|
|
|
|
// 31 bit index, 1 bit cache type
|
|
uint cacheType = IsEnvIndexCubemap(lightData.envIndex) ? ENVCACHETYPE_CUBEMAP : ENVCACHETYPE_TEXTURE2D;
|
|
// Index start at 1, because -0 == 0, so we can't known which cache to sample for that index. Thus it is invalid.
|
|
int index = abs(lightData.envIndex) - 1;
|
|
|
|
float lod = PerceptualRoughnessToMipmapLevel(preLightData.iblPerceptualRoughness) * lightData.roughReflections;
|
|
float2 atlasCoords = GetReflectionAtlasCoordsCube(CUBE_SCALE_OFFSET[index], R, lod);
|
|
|
|
// No distance based roughness for simple lit
|
|
float4 preLD = SampleEnv(lightLoopContext, lightData.envIndex, R, PerceptualRoughnessToMipmapLevel(preLightData.iblPerceptualRoughness) * lightData.roughReflections, lightData.rangeCompressionFactorCompensation, posInput.positionNDC);
|
|
weight *= preLD.a; // Used by planar reflection to discard pixel
|
|
|
|
//envLighting = F_Schlick(bsdfData.fresnel0, dot(bsdfData.normalWS, V)) * preLD.rgb;
|
|
envLighting = preLD.rgb;
|
|
|
|
UpdateLightingHierarchyWeights(hierarchyWeight, weight);
|
|
envLighting *= weight * lightData.multiplier;
|
|
|
|
lighting.specularReflected = envLighting;
|
|
|
|
return lighting;
|
|
}
|
|
|
|
float4 ComputeReflection(LightLoopContext context, PositionInputs posInput, PreLightData preLightData, BuiltinData builtinData, float3 V, float lod, BSDFData bsdfData)
|
|
{
|
|
float3 refcolor = 0;
|
|
float reflectionHierarchyWeight = 0.0; // Max: 1.0
|
|
|
|
uint envLightStart, envLightCount;
|
|
|
|
// Fetch first env light to provide the scene proxy for screen space computation
|
|
#ifndef LIGHTLOOP_DISABLE_TILE_AND_CLUSTER
|
|
GetCountAndStart(posInput, LIGHTCATEGORY_ENV, envLightStart, envLightCount);
|
|
#else // LIGHTLOOP_DISABLE_TILE_AND_CLUSTER
|
|
envLightCount = _EnvLightCount;
|
|
envLightStart = 0;
|
|
#endif
|
|
|
|
bool fastPath = false;
|
|
#if SCALARIZE_LIGHT_LOOP
|
|
uint envStartFirstLane;
|
|
fastPath = IsFastPath(envLightStart, envStartFirstLane);
|
|
#endif
|
|
|
|
context.sampleReflection = SINGLE_PASS_CONTEXT_SAMPLE_REFLECTION_PROBES;
|
|
|
|
#if SCALARIZE_LIGHT_LOOP
|
|
if (fastPath)
|
|
{
|
|
envLightStart = envStartFirstLane;
|
|
}
|
|
#endif
|
|
|
|
// Scalarized loop, same rationale of the punctual light version
|
|
uint v_envLightListOffset = 0;
|
|
uint v_envLightIdx = envLightStart;
|
|
#if NEED_TO_CHECK_HELPER_LANE
|
|
// On some platform helper lanes don't behave as we'd expect, therefore we prevent them from entering the loop altogether.
|
|
// IMPORTANT! This has implications if ddx/ddy is used on results derived from lighting, however given Lightloop is called in compute we should be
|
|
// sure it will not happen.
|
|
bool isHelperLane = WaveIsHelperLane();
|
|
while (!isHelperLane && v_envLightListOffset < envLightCount)
|
|
#else
|
|
while (v_envLightListOffset < envLightCount)
|
|
#endif
|
|
{
|
|
v_envLightIdx = FetchIndex(envLightStart, v_envLightListOffset);
|
|
#if SCALARIZE_LIGHT_LOOP
|
|
uint s_envLightIdx = ScalarizeElementIndex(v_envLightIdx, fastPath);
|
|
#else
|
|
uint s_envLightIdx = v_envLightIdx;
|
|
#endif
|
|
if (s_envLightIdx == -1)
|
|
break;
|
|
|
|
EnvLightData s_envLightData = FetchEnvLight(s_envLightIdx); // Scalar load.
|
|
|
|
// If current scalar and vector light index match, we process the light. The v_envLightListOffset for current thread is increased.
|
|
// Note that the following should really be ==, however, since helper lanes are not considered by WaveActiveMin, such helper lanes could
|
|
// end up with a unique v_envLightIdx value that is smaller than s_envLightIdx hence being stuck in a loop. All the active lanes will not have this problem.
|
|
if (s_envLightIdx >= v_envLightIdx)
|
|
{
|
|
v_envLightListOffset++;
|
|
if (reflectionHierarchyWeight < 1.0)
|
|
{
|
|
if (IsMatchingLightLayer(s_envLightData.lightLayers, builtinData.renderingLayers))
|
|
{
|
|
IndirectLighting lighting = EvaluateBSDF_Env(context, V, posInput, preLightData, s_envLightData, bsdfData, s_envLightData.influenceShapeType, reflectionHierarchyWeight);
|
|
#if defined(PROBE_VOLUMES_L1) || defined(PROBE_VOLUMES_L2)
|
|
float3 lightInReflDir = float3(-1, -1, -1);
|
|
if (s_envLightData.normalizeWithAPV > 0 && all(lightInReflDir >= 0))
|
|
{
|
|
float factor = GetReflectionProbeNormalizationFactor(lightInReflDir, bsdfData.normalWS, s_envLightData.L0L1, s_envLightData.L2_1, s_envLightData.L2_2);
|
|
lighting.specularReflected *= factor;
|
|
}
|
|
#endif
|
|
refcolor += lighting.specularReflected;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
return float4(refcolor.r, refcolor.g, refcolor.b, reflectionHierarchyWeight);
|
|
}
|
|
|
|
float3 ComputeFresnelLerp(float3 c0, float3 c1, float cosA)
|
|
{
|
|
float t = pow(1 - cosA, 5);
|
|
return lerp(c0, c1, t);
|
|
}
|
|
|
|
float3 ComputeIndirectDiffuse(PositionInputs posInput, BSDFData bsdfData, float3 V)
|
|
{
|
|
float3 indirectDiffuse = 0.0;
|
|
|
|
if(_ID_Intensity > 0)
|
|
{
|
|
#ifdef _PBR_Mode_ANISO
|
|
GetGGXAnisotropicModifiedNormalAndRoughness(bsdfData.bitangentWS, bsdfData.tangentWS , bsdfData.normalWS, V, bsdfData.anisotropy, bsdfData.perceptualRoughness, bsdfData.normalWS, bsdfData.perceptualRoughness);
|
|
#endif
|
|
|
|
float NdotV = saturate(dot(bsdfData.normalWS, V));
|
|
|
|
#if defined(PROBE_VOLUMES_L1) || defined(PROBE_VOLUMES_L2)
|
|
BuiltinData apvBuiltinData;
|
|
ZERO_INITIALIZE(BuiltinData, apvBuiltinData);
|
|
|
|
#if defined(_PBR_Mode_OFF) || defined(_PBR_Mode_TOON)
|
|
EvaluateAdaptiveProbeVolume(GetAbsolutePositionWS(posInput.positionWS), 0.0, 0.0, V, posInput.positionSS, apvBuiltinData.bakeDiffuseLighting, apvBuiltinData.backBakeDiffuseLighting);
|
|
#else
|
|
EvaluateAdaptiveProbeVolume(GetAbsolutePositionWS(posInput.positionWS), bsdfData.normalWS, -bsdfData.normalWS, V, posInput.positionSS, apvBuiltinData.bakeDiffuseLighting, apvBuiltinData.backBakeDiffuseLighting);
|
|
#endif
|
|
|
|
float3 probeDiffuse = apvBuiltinData.bakeDiffuseLighting * GetCurrentExposureMultiplier();
|
|
|
|
indirectDiffuse = probeDiffuse;
|
|
#else
|
|
#if defined(_PBR_Mode_OFF) || defined(_PBR_Mode_TOON)
|
|
indirectDiffuse = EvaluateAmbientProbe(0.0) * GetCurrentExposureMultiplier();
|
|
#else
|
|
indirectDiffuse = EvaluateAmbientProbe(bsdfData.normalWS) * GetCurrentExposureMultiplier();
|
|
#endif
|
|
#endif
|
|
|
|
//SSGI
|
|
if(_ReceivesSSGI == 1)
|
|
{
|
|
float4 ssgiLighting = LOAD_TEXTURE2D_X(_IndirectDiffuseTexture, posInput.positionSS);
|
|
ssgiLighting *= _GIMultiplier;
|
|
indirectDiffuse = lerp(indirectDiffuse, ssgiLighting.rgb, ssgiLighting.a);
|
|
}
|
|
|
|
//Compelete the indirect lighting
|
|
indirectDiffuse = indirectDiffuse * bsdfData.diffuseColor.rgb * _BaseColor.rgb;
|
|
|
|
//SSAO
|
|
if(_ReceivesSSAO == 1)
|
|
{
|
|
AmbientOcclusionFactor aoFactor;
|
|
GetScreenSpaceAmbientOcclusionMultibounce(posInput.positionSS, NdotV, bsdfData.perceptualRoughness, bsdfData.ambientOcclusion, bsdfData.specularOcclusion, bsdfData.diffuseColor, bsdfData.fresnel0, aoFactor);
|
|
indirectDiffuse *= lerp(_AOMin, 1, aoFactor.indirectAmbientOcclusion);
|
|
}
|
|
indirectDiffuse = indirectDiffuse * bsdfData.ambientOcclusion;
|
|
}
|
|
|
|
return indirectDiffuse;
|
|
}
|
|
|
|
float3 ComputeIndirectSpecular(LightLoopContext lightLoopContext, PositionInputs posInput, PreLightData preLightData, BSDFData bsdfData, SurfaceData surfaceData, BuiltinData builtinData, float3 V)
|
|
{
|
|
#if defined(_PBR_Mode_OFF) || defined(_PBR_Mode_TOON)
|
|
return 0;
|
|
#else
|
|
float3 indirectSpecular = 0;
|
|
|
|
if(_IR_Intensity > 0)
|
|
{
|
|
#ifdef _PBR_Mode_ANISO
|
|
GetGGXAnisotropicModifiedNormalAndRoughness(bsdfData.bitangentWS, bsdfData.tangentWS , bsdfData.normalWS, V, bsdfData.anisotropy, bsdfData.perceptualRoughness, bsdfData.normalWS, bsdfData.perceptualRoughness);
|
|
#endif
|
|
|
|
float3 albedo = _BaseColor.rgb * surfaceData.baseColor;
|
|
float mip = PerceptualRoughnessToMipmapLevel(bsdfData.perceptualRoughness);
|
|
float NdotV = saturate(dot(bsdfData.normalWS, V));
|
|
|
|
indirectSpecular = SampleSkyTexture(reflect(-V, bsdfData.normalWS), mip, 0).rgb;
|
|
float3 specColor = lerp(ColorSpaceDielectricSpec.rgb, albedo, surfaceData.metallic);
|
|
float oneMinusReflectivity = ColorSpaceDielectricSpec.a * (1 - surfaceData.metallic);
|
|
float grazingTerm = saturate((1 - bsdfData.perceptualRoughness) + (1 - oneMinusReflectivity));
|
|
|
|
//Reflection Probe
|
|
float4 refProbe = ComputeReflection(lightLoopContext, posInput, preLightData, builtinData, V, mip, bsdfData);
|
|
indirectSpecular = lerp(indirectSpecular, refProbe.rgb, refProbe.a);
|
|
|
|
//SSR
|
|
if(_ReceivesSSR == 1)
|
|
{
|
|
float4 ssrLighting = LOAD_TEXTURE2D_X(_SsrLightingTexture, posInput.positionSS);
|
|
InversePreExposeSsrLighting(ssrLighting);
|
|
ApplyScreenSpaceReflectionWeight(ssrLighting);
|
|
indirectSpecular = lerp(indirectSpecular, ssrLighting.rgb, ssrLighting.a);
|
|
}
|
|
|
|
//Compelete the indirect lighting
|
|
indirectSpecular = indirectSpecular * ComputeFresnelLerp(specColor, grazingTerm, NdotV) * GetCurrentExposureMultiplier();
|
|
|
|
// Occlusion
|
|
if(_ReceivesSSAO == 1)
|
|
{
|
|
AmbientOcclusionFactor aoFactor;
|
|
GetScreenSpaceAmbientOcclusionMultibounce(posInput.positionSS, NdotV, bsdfData.perceptualRoughness, bsdfData.ambientOcclusion, bsdfData.specularOcclusion, bsdfData.diffuseColor, bsdfData.fresnel0, aoFactor);
|
|
|
|
indirectSpecular *= lerp(_AOMin, 1, aoFactor.indirectSpecularOcclusion);
|
|
}
|
|
indirectSpecular = indirectSpecular * bsdfData.specularOcclusion;
|
|
}
|
|
return indirectSpecular;
|
|
#endif
|
|
} |