* Add support for sheenColor and sheenRoughness This work is necessary to support the glTF extension KHR_materials_sheen. This change effectively adds the specular lobe from the cloth material model to the base material model. The cloth model remains useful for its extra subsurface color feature but also because it's cheaper. * Add support for KHR_materials_sheen to gltfio * Update documentation * Document default shading values
555 lines
21 KiB
GLSL
555 lines
21 KiB
GLSL
//------------------------------------------------------------------------------
|
|
// Image based lighting configuration
|
|
//------------------------------------------------------------------------------
|
|
|
|
// Number of spherical harmonics bands (1, 2 or 3)
|
|
#define SPHERICAL_HARMONICS_BANDS 3
|
|
|
|
// IBL integration algorithm
|
|
#define IBL_INTEGRATION_PREFILTERED_CUBEMAP 0
|
|
#define IBL_INTEGRATION_IMPORTANCE_SAMPLING 1
|
|
|
|
#define IBL_INTEGRATION IBL_INTEGRATION_PREFILTERED_CUBEMAP
|
|
|
|
#define IBL_INTEGRATION_IMPORTANCE_SAMPLING_COUNT 64
|
|
|
|
//------------------------------------------------------------------------------
|
|
// IBL utilities
|
|
//------------------------------------------------------------------------------
|
|
|
|
vec3 decodeDataForIBL(const vec4 data) {
|
|
return data.rgb;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// IBL prefiltered DFG term implementations
|
|
//------------------------------------------------------------------------------
|
|
|
|
vec3 PrefilteredDFG_LUT(float lod, float NoV) {
|
|
// coord = sqrt(linear_roughness), which is the mapping used by cmgen.
|
|
return textureLod(light_iblDFG, vec2(NoV, lod), 0.0).rgb;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// IBL environment BRDF dispatch
|
|
//------------------------------------------------------------------------------
|
|
|
|
vec3 prefilteredDFG(float perceptualRoughness, float NoV) {
|
|
// PrefilteredDFG_LUT() takes a LOD, which is sqrt(roughness) = perceptualRoughness
|
|
return PrefilteredDFG_LUT(perceptualRoughness, NoV);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// IBL irradiance implementations
|
|
//------------------------------------------------------------------------------
|
|
|
|
vec3 Irradiance_SphericalHarmonics(const vec3 n) {
|
|
return max(
|
|
frameUniforms.iblSH[0]
|
|
#if SPHERICAL_HARMONICS_BANDS >= 2
|
|
+ frameUniforms.iblSH[1] * (n.y)
|
|
+ frameUniforms.iblSH[2] * (n.z)
|
|
+ frameUniforms.iblSH[3] * (n.x)
|
|
#endif
|
|
#if SPHERICAL_HARMONICS_BANDS >= 3
|
|
+ frameUniforms.iblSH[4] * (n.y * n.x)
|
|
+ frameUniforms.iblSH[5] * (n.y * n.z)
|
|
+ frameUniforms.iblSH[6] * (3.0 * n.z * n.z - 1.0)
|
|
+ frameUniforms.iblSH[7] * (n.z * n.x)
|
|
+ frameUniforms.iblSH[8] * (n.x * n.x - n.y * n.y)
|
|
#endif
|
|
, 0.0);
|
|
}
|
|
|
|
vec3 Irradiance_RoughnessOne(const vec3 n) {
|
|
// note: lod used is always integer, hopefully the hardware skips tri-linear filtering
|
|
return decodeDataForIBL(textureLod(light_iblSpecular, n, frameUniforms.iblRoughnessOneLevel));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// IBL irradiance dispatch
|
|
//------------------------------------------------------------------------------
|
|
|
|
vec3 diffuseIrradiance(const vec3 n) {
|
|
if (frameUniforms.iblSH[0].x == 65504.0) {
|
|
#if defined(TARGET_MOBILE)
|
|
return Irradiance_RoughnessOne(n);
|
|
#else
|
|
ivec2 s = textureSize(light_iblSpecular, int(frameUniforms.iblRoughnessOneLevel));
|
|
float du = 1.0 / float(s.x);
|
|
float dv = 1.0 / float(s.y);
|
|
vec3 m0 = normalize(cross(n, vec3(0.0, 1.0, 0.0)));
|
|
vec3 m1 = cross(m0, n);
|
|
vec3 m0du = m0 * du;
|
|
vec3 m1dv = m1 * dv;
|
|
vec3 c;
|
|
c = Irradiance_RoughnessOne(n - m0du - m1dv);
|
|
c += Irradiance_RoughnessOne(n + m0du - m1dv);
|
|
c += Irradiance_RoughnessOne(n + m0du + m1dv);
|
|
c += Irradiance_RoughnessOne(n - m0du + m1dv);
|
|
return c * 0.25;
|
|
#endif
|
|
} else {
|
|
return Irradiance_SphericalHarmonics(n);
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// IBL specular
|
|
//------------------------------------------------------------------------------
|
|
|
|
float perceptualRoughnessToLod(float perceptualRoughness) {
|
|
// The mapping below is a quadratic fit for log2(perceptualRoughness)+iblRoughnessOneLevel when
|
|
// iblRoughnessOneLevel is 4. We found empirically that this mapping works very well for
|
|
// a 256 cubemap with 5 levels used. But also scales well for other iblRoughnessOneLevel values.
|
|
return frameUniforms.iblRoughnessOneLevel * perceptualRoughness * (2.0 - perceptualRoughness);
|
|
}
|
|
|
|
vec3 prefilteredRadiance(const vec3 r, float perceptualRoughness) {
|
|
float lod = perceptualRoughnessToLod(perceptualRoughness);
|
|
return decodeDataForIBL(textureLod(light_iblSpecular, r, lod));
|
|
}
|
|
|
|
vec3 prefilteredRadiance(const vec3 r, float roughness, float offset) {
|
|
float lod = frameUniforms.iblRoughnessOneLevel * roughness;
|
|
return decodeDataForIBL(textureLod(light_iblSpecular, r, lod + offset));
|
|
}
|
|
|
|
vec3 getSpecularDominantDirection(const vec3 n, const vec3 r, float roughness) {
|
|
return mix(r, n, roughness * roughness);
|
|
}
|
|
|
|
vec3 specularDFG(const PixelParams pixel) {
|
|
#if defined(SHADING_MODEL_CLOTH)
|
|
return pixel.f0 * pixel.dfg.z;
|
|
#else
|
|
return mix(pixel.dfg.xxx, pixel.dfg.yyy, pixel.f0);
|
|
#endif
|
|
}
|
|
|
|
/**
|
|
* Returns the reflected vector at the current shading point. The reflected vector
|
|
* return by this function might be different from shading_reflected:
|
|
* - For anisotropic material, we bend the reflection vector to simulate
|
|
* anisotropic indirect lighting
|
|
* - The reflected vector may be modified to point towards the dominant specular
|
|
* direction to match reference renderings when the roughness increases
|
|
*/
|
|
|
|
vec3 getReflectedVector(const PixelParams pixel, const vec3 v, const vec3 n) {
|
|
#if defined(MATERIAL_HAS_ANISOTROPY)
|
|
vec3 anisotropyDirection = pixel.anisotropy >= 0.0 ? pixel.anisotropicB : pixel.anisotropicT;
|
|
vec3 anisotropicTangent = cross(anisotropyDirection, v);
|
|
vec3 anisotropicNormal = cross(anisotropicTangent, anisotropyDirection);
|
|
float bendFactor = abs(pixel.anisotropy) * saturate(5.0 * pixel.perceptualRoughness);
|
|
vec3 bentNormal = normalize(mix(n, anisotropicNormal, bendFactor));
|
|
|
|
vec3 r = reflect(-v, bentNormal);
|
|
#else
|
|
vec3 r = reflect(-v, n);
|
|
#endif
|
|
return r;
|
|
}
|
|
|
|
vec3 getReflectedVector(const PixelParams pixel, const vec3 n) {
|
|
#if defined(MATERIAL_HAS_ANISOTROPY)
|
|
vec3 r = getReflectedVector(pixel, shading_view, n);
|
|
#else
|
|
vec3 r = shading_reflected;
|
|
#endif
|
|
return getSpecularDominantDirection(n, r, pixel.roughness);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Prefiltered importance sampling
|
|
//------------------------------------------------------------------------------
|
|
|
|
#if IBL_INTEGRATION == IBL_INTEGRATION_IMPORTANCE_SAMPLING
|
|
vec2 hammersley(uint index) {
|
|
// Compute Hammersley sequence
|
|
// TODO: these should come from uniforms
|
|
// TODO: we should do this with logical bit operations
|
|
const uint numSamples = uint(IBL_INTEGRATION_IMPORTANCE_SAMPLING_COUNT);
|
|
const uint numSampleBits = uint(log2(float(numSamples)));
|
|
const float invNumSamples = 1.0 / float(numSamples);
|
|
uint i = uint(index);
|
|
uint t = i;
|
|
uint bits = 0u;
|
|
for (uint j = 0u; j < numSampleBits; j++) {
|
|
bits = bits * 2u + (t - (2u * (t / 2u)));
|
|
t /= 2u;
|
|
}
|
|
return vec2(float(i), float(bits)) * invNumSamples;
|
|
}
|
|
|
|
vec3 importanceSamplingNdfDggx(vec2 u, float roughness) {
|
|
// Importance sampling D_GGX
|
|
float a2 = roughness * roughness;
|
|
float phi = 2.0 * PI * u.x;
|
|
float cosTheta2 = (1.0 - u.y) / (1.0 + (a2 - 1.0) * u.y);
|
|
float cosTheta = sqrt(cosTheta2);
|
|
float sinTheta = sqrt(1.0 - cosTheta2);
|
|
return vec3(cos(phi) * sinTheta, sin(phi) * sinTheta, cosTheta);
|
|
}
|
|
|
|
vec3 importanceSamplingVNdfDggx(vec2 u, float roughness, vec3 v) {
|
|
// See: "A Simpler and Exact Sampling Routine for the GGX Distribution of Visible Normals", Eric Heitz
|
|
float alpha = roughness;
|
|
|
|
// stretch view
|
|
v = normalize(vec3(alpha * v.x, alpha * v.y, v.z));
|
|
|
|
// orthonormal basis
|
|
vec3 up = abs(v.z) < 0.9999 ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);
|
|
vec3 t = normalize(cross(up, v));
|
|
vec3 b = cross(t, v);
|
|
|
|
// sample point with polar coordinates (r, phi)
|
|
float a = 1.0 / (1.0 + v.z);
|
|
float r = sqrt(u.x);
|
|
float phi = (u.y < a) ? u.y / a * PI : PI + (u.y - a) / (1.0 - a) * PI;
|
|
float p1 = r * cos(phi);
|
|
float p2 = r * sin(phi) * ((u.y < a) ? 1.0 : v.z);
|
|
|
|
// compute normal
|
|
vec3 h = p1 * t + p2 * b + sqrt(max(0.0, 1.0 - p1*p1 - p2*p2)) * v;
|
|
|
|
// unstretch
|
|
h = normalize(vec3(alpha * h.x, alpha * h.y, max(0.0, h.z)));
|
|
return h;
|
|
}
|
|
|
|
float prefilteredImportanceSampling(float ipdf, float iblRoughnessOneLevel) {
|
|
// See: "Real-time Shading with Filtered Importance Sampling", Jaroslav Krivanek
|
|
// Prefiltering doesn't work with anisotropy
|
|
const float numSamples = float(IBL_INTEGRATION_IMPORTANCE_SAMPLING_COUNT);
|
|
const float invNumSamples = 1.0 / float(numSamples);
|
|
const float dim = float(textureSize(light_iblSpecular, 0).x);
|
|
const float omegaP = (4.0 * PI) / (6.0 * dim * dim);
|
|
const float invOmegaP = 1.0 / omegaP;
|
|
const float K = 4.0;
|
|
float omegaS = invNumSamples * ipdf;
|
|
float mipLevel = clamp(log2(K * omegaS * invOmegaP) * 0.5, 0.0, iblRoughnessOneLevel);
|
|
return mipLevel;
|
|
}
|
|
|
|
vec3 isEvaluateIBL(const PixelParams pixel, vec3 n, vec3 v, float NoV) {
|
|
// TODO: for a true anisotropic BRDF, we need a real tangent space
|
|
vec3 up = abs(n.z) < 0.9999 ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);
|
|
|
|
mat3 tangentToWorld;
|
|
tangentToWorld[0] = normalize(cross(up, n));
|
|
tangentToWorld[1] = cross(n, tangentToWorld[0]);
|
|
tangentToWorld[2] = n;
|
|
|
|
float roughness = pixel.roughness;
|
|
float a2 = roughness * roughness;
|
|
|
|
float iblRoughnessOneLevel = frameUniforms.iblRoughnessOneLevel;
|
|
const uint numSamples = uint(IBL_INTEGRATION_IMPORTANCE_SAMPLING_COUNT);
|
|
const float invNumSamples = 1.0 / float(numSamples);
|
|
|
|
vec3 indirectSpecular = vec3(0.0);
|
|
for (uint i = 0u; i < numSamples; i++) {
|
|
vec2 u = hammersley(i);
|
|
vec3 h = tangentToWorld * importanceSamplingNdfDggx(u, roughness);
|
|
|
|
// Since anisotropy doesn't work with prefiltering, we use the same "faux" anisotropy
|
|
// we do when we use the prefiltered cubemap
|
|
vec3 l = getReflectedVector(pixel, v, h);
|
|
|
|
// Compute this sample's contribution to the brdf
|
|
float NoL = dot(n, l);
|
|
if (NoL > 0.0) {
|
|
float NoH = dot(n, h);
|
|
float LoH = max(dot(l, h), 0.0);
|
|
|
|
// PDF inverse (we must use D_GGX() here, which is used to generate samples)
|
|
float ipdf = (4.0 * LoH) / (D_GGX(roughness, NoH, h) * NoH);
|
|
|
|
float mipLevel = prefilteredImportanceSampling(ipdf, iblRoughnessOneLevel);
|
|
|
|
// we use texture() instead of textureLod() to take advantage of mipmapping
|
|
vec3 L = decodeDataForIBL(texture(light_iblSpecular, l, mipLevel));
|
|
|
|
float D = distribution(roughness, NoH, h);
|
|
float V = visibility(roughness, NoV, NoL);
|
|
vec3 F = fresnel(pixel.f0, LoH);
|
|
vec3 Fr = F * (D * V * NoL * ipdf * invNumSamples);
|
|
|
|
indirectSpecular += (Fr * L);
|
|
}
|
|
}
|
|
|
|
return indirectSpecular;
|
|
}
|
|
|
|
void isEvaluateClearCoatIBL(const PixelParams pixel, float specularAO, inout vec3 Fd, inout vec3 Fr) {
|
|
#if defined(MATERIAL_HAS_CLEAR_COAT)
|
|
#if defined(MATERIAL_HAS_NORMAL) || defined(MATERIAL_HAS_CLEAR_COAT_NORMAL)
|
|
// We want to use the geometric normal for the clear coat layer
|
|
float clearCoatNoV = clampNoV(dot(shading_clearCoatNormal, shading_view));
|
|
vec3 clearCoatNormal = shading_clearCoatNormal;
|
|
#else
|
|
float clearCoatNoV = shading_NoV;
|
|
vec3 clearCoatNormal = shading_normal;
|
|
#endif
|
|
// The clear coat layer assumes an IOR of 1.5 (4% reflectance)
|
|
float Fc = F_Schlick(0.04, 1.0, clearCoatNoV) * pixel.clearCoat;
|
|
float attenuation = 1.0 - Fc;
|
|
Fd *= attenuation;
|
|
Fr *= attenuation;
|
|
|
|
PixelParams p;
|
|
p.perceptualRoughness = pixel.clearCoatPerceptualRoughness;
|
|
p.f0 = vec3(0.04);
|
|
p.roughness = perceptualRoughnessToRoughness(p.perceptualRoughness);
|
|
p.anisotropy = 0.0;
|
|
|
|
vec3 clearCoatLobe = isEvaluateIBL(p, clearCoatNormal, shading_view, clearCoatNoV);
|
|
Fr += clearCoatLobe * (specularAO * pixel.clearCoat);
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
//------------------------------------------------------------------------------
|
|
// IBL evaluation
|
|
//------------------------------------------------------------------------------
|
|
|
|
void evaluateClothIndirectDiffuseBRDF(const PixelParams pixel, inout float diffuse) {
|
|
#if defined(SHADING_MODEL_CLOTH)
|
|
#if defined(MATERIAL_HAS_SUBSURFACE_COLOR)
|
|
// Simulate subsurface scattering with a wrap diffuse term
|
|
diffuse *= Fd_Wrap(shading_NoV, 0.5);
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
void evaluateSheenIBL(const PixelParams pixel, float specularAO, inout vec3 Fd, inout vec3 Fr) {
|
|
#if !defined(SHADING_MODEL_CLOTH) && !defined(SHADING_MODEL_SUBSURFACE)
|
|
#if defined(MATERIAL_HAS_SHEEN_COLOR)
|
|
// Albedo scaling of the base layer before we layer sheen on top
|
|
Fd *= pixel.sheenScaling;
|
|
Fr *= pixel.sheenScaling;
|
|
|
|
vec3 reflectance = pixel.sheenDFG * pixel.sheenColor;
|
|
Fr += reflectance * prefilteredRadiance(shading_reflected, pixel.sheenPerceptualRoughness);
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
void evaluateClearCoatIBL(const PixelParams pixel, float specularAO, inout vec3 Fd, inout vec3 Fr) {
|
|
#if IBL_INTEGRATION == IBL_INTEGRATION_IMPORTANCE_SAMPLING
|
|
isEvaluateClearCoatIBL(pixel, specularAO, Fd, Fr);
|
|
return;
|
|
#endif
|
|
|
|
#if defined(MATERIAL_HAS_CLEAR_COAT)
|
|
#if defined(MATERIAL_HAS_NORMAL) || defined(MATERIAL_HAS_CLEAR_COAT_NORMAL)
|
|
// We want to use the geometric normal for the clear coat layer
|
|
float clearCoatNoV = clampNoV(dot(shading_clearCoatNormal, shading_view));
|
|
vec3 clearCoatR = reflect(-shading_view, shading_clearCoatNormal);
|
|
#else
|
|
float clearCoatNoV = shading_NoV;
|
|
vec3 clearCoatR = shading_reflected;
|
|
#endif
|
|
// The clear coat layer assumes an IOR of 1.5 (4% reflectance)
|
|
float Fc = F_Schlick(0.04, 1.0, clearCoatNoV) * pixel.clearCoat;
|
|
float attenuation = 1.0 - Fc;
|
|
Fd *= attenuation;
|
|
Fr *= attenuation;
|
|
Fr += prefilteredRadiance(clearCoatR, pixel.clearCoatPerceptualRoughness) * (specularAO * Fc);
|
|
#endif
|
|
}
|
|
|
|
void evaluateSubsurfaceIBL(const PixelParams pixel, const vec3 diffuseIrradiance,
|
|
inout vec3 Fd, inout vec3 Fr) {
|
|
#if defined(SHADING_MODEL_SUBSURFACE)
|
|
vec3 viewIndependent = diffuseIrradiance;
|
|
vec3 viewDependent = prefilteredRadiance(-shading_view, pixel.roughness, 1.0 + pixel.thickness);
|
|
float attenuation = (1.0 - pixel.thickness) / (2.0 * PI);
|
|
Fd += pixel.subsurfaceColor * (viewIndependent + viewDependent) * attenuation;
|
|
#elif defined(SHADING_MODEL_CLOTH) && defined(MATERIAL_HAS_SUBSURFACE_COLOR)
|
|
Fd *= saturate(pixel.subsurfaceColor + shading_NoV);
|
|
#endif
|
|
}
|
|
|
|
#if defined(HAS_REFRACTION)
|
|
|
|
struct Refraction {
|
|
vec3 position;
|
|
vec3 direction;
|
|
float d;
|
|
};
|
|
|
|
void refractionSolidSphere(const PixelParams pixel,
|
|
const vec3 n, vec3 r, out Refraction ray) {
|
|
r = refract(r, n, pixel.etaIR);
|
|
float NoR = dot(n, r);
|
|
float d = pixel.thickness * -NoR;
|
|
ray.position = vec3(shading_position + r * d);
|
|
ray.d = d;
|
|
vec3 n1 = normalize(NoR * r - n * 0.5);
|
|
ray.direction = refract(r, n1, pixel.etaRI);
|
|
}
|
|
|
|
void refractionSolidBox(const PixelParams pixel,
|
|
const vec3 n, vec3 r, out Refraction ray) {
|
|
vec3 rr = refract(r, n, pixel.etaIR);
|
|
float NoR = dot(n, rr);
|
|
float d = pixel.thickness / max(-NoR, 0.001);
|
|
ray.position = vec3(shading_position + rr * d);
|
|
ray.direction = r;
|
|
ray.d = d;
|
|
#if REFRACTION_MODE == REFRACTION_MODE_CUBEMAP
|
|
// fudge direction vector, so we see the offset due to the thickness of the object
|
|
float envDistance = 10.0; // this should come from a ubo
|
|
ray.direction = normalize((ray.position - shading_position) + ray.direction * envDistance);
|
|
#endif
|
|
}
|
|
|
|
void refractionThinSphere(const PixelParams pixel,
|
|
const vec3 n, vec3 r, out Refraction ray) {
|
|
float d = 0.0;
|
|
#if defined(MATERIAL_HAS_MICRO_THICKNESS)
|
|
// note: we need the refracted ray to calculate the distance traveled
|
|
// we could use shading_NoV, but we would lose the dependency on ior.
|
|
vec3 rr = refract(r, n, pixel.etaIR);
|
|
float NoR = dot(n, rr);
|
|
d = pixel.uThickness / max(-NoR, 0.001);
|
|
ray.position = vec3(shading_position + rr * d);
|
|
#else
|
|
ray.position = vec3(shading_position);
|
|
#endif
|
|
ray.direction = r;
|
|
ray.d = d;
|
|
}
|
|
|
|
void applyRefraction(const PixelParams pixel,
|
|
const vec3 n0, vec3 E, vec3 Fd, vec3 Fr,
|
|
inout vec3 color) {
|
|
|
|
Refraction ray;
|
|
|
|
#if REFRACTION_TYPE == REFRACTION_TYPE_SOLID
|
|
refractionSolidSphere(pixel, n0, -shading_view, ray);
|
|
#elif REFRACTION_TYPE == REFRACTION_TYPE_THIN
|
|
refractionThinSphere(pixel, n0, -shading_view, ray);
|
|
#else
|
|
#error invalid REFRACTION_TYPE
|
|
#endif
|
|
|
|
/* compute transmission T */
|
|
#if defined(MATERIAL_HAS_ABSORPTION)
|
|
#if defined(MATERIAL_HAS_THICKNESS) || defined(MATERIAL_HAS_MICRO_THICKNESS)
|
|
vec3 T = min(vec3(1.0), exp(-pixel.absorption * ray.d));
|
|
#else
|
|
vec3 T = 1.0 - pixel.absorption;
|
|
#endif
|
|
#endif
|
|
|
|
float perceptualRoughness = pixel.perceptualRoughnessUnclamped;
|
|
#if REFRACTION_TYPE == REFRACTION_TYPE_THIN
|
|
// Roughness remaping for thin layers, see Burley 2012, "Physically-Based Shading at Disney"
|
|
perceptualRoughness = saturate((0.65 * pixel.etaRI - 0.35) * perceptualRoughness);
|
|
|
|
// For thin surfaces, the light will bounce off at the second interface in the direction of
|
|
// the reflection, effectively adding to the specular, but this process will repeat itself.
|
|
// Each time the ray exits the surface on the front side after the first bounce,
|
|
// it's multiplied by E^2, and we get: E + E(1-E)^2 + E^3(1-E)^2 + ...
|
|
// This infinite series converges and is easy to simplify.
|
|
// Note: we calculate these bounces only on a single component,
|
|
// since it's a fairly subtle effect.
|
|
E *= 1.0 + pixel.transmission * (1.0 - E.g) / (1.0 + E.g);
|
|
#endif
|
|
|
|
/* sample the cubemap or screen-space */
|
|
#if REFRACTION_MODE == REFRACTION_MODE_CUBEMAP
|
|
// when reading from the cubemap, we are not pre-exposed so we apply iblLuminance
|
|
// which is not the case when we'll read from the screen-space buffer
|
|
vec3 Ft = prefilteredRadiance(ray.direction, perceptualRoughness) * frameUniforms.iblLuminance;
|
|
#else
|
|
// compute the point where the ray exits the medium, if needed
|
|
vec4 p = vec4(frameUniforms.clipFromWorldMatrix * vec4(ray.position, 1.0));
|
|
p.xy = uvToRenderTargetUV(p.xy * (0.5 / p.w) + 0.5);
|
|
|
|
// perceptualRoughness to LOD
|
|
// Empirical factor to compensate for the gaussian approximation of Dggx, chosen so
|
|
// cubemap and screen-space modes match at perceptualRoughness 0.125
|
|
float tweakedPerceptualRoughness = perceptualRoughness * 1.74;
|
|
float lod = max(0.0, 2.0 * log2(tweakedPerceptualRoughness) + frameUniforms.refractionLodOffset);
|
|
|
|
vec3 Ft = textureLod(light_ssr, p.xy, lod).rgb;
|
|
#endif
|
|
|
|
/* fresnel from the first interface */
|
|
Ft *= 1.0 - E;
|
|
|
|
/* apply absorption */
|
|
#if defined(MATERIAL_HAS_ABSORPTION)
|
|
Ft *= T;
|
|
#endif
|
|
|
|
Fr *= frameUniforms.iblLuminance;
|
|
Fd *= frameUniforms.iblLuminance;
|
|
color.rgb += Fr + mix(Fd, Ft, pixel.transmission);
|
|
}
|
|
#endif
|
|
|
|
void combineDiffuseAndSpecular(const PixelParams pixel,
|
|
const vec3 n, const vec3 E, const vec3 Fd, const vec3 Fr,
|
|
inout vec3 color) {
|
|
#if defined(HAS_REFRACTION)
|
|
applyRefraction(pixel, n, E, Fd, Fr, color);
|
|
#else
|
|
color.rgb += (Fd + Fr) * frameUniforms.iblLuminance;
|
|
#endif
|
|
}
|
|
|
|
void evaluateIBL(const MaterialInputs material, const PixelParams pixel, inout vec3 color) {
|
|
float ssao = evaluateSSAO();
|
|
float diffuseAO = min(material.ambientOcclusion, ssao);
|
|
float specularAO = computeSpecularAO(shading_NoV, diffuseAO, pixel.roughness);
|
|
|
|
// specular layer
|
|
vec3 Fr;
|
|
#if IBL_INTEGRATION == IBL_INTEGRATION_PREFILTERED_CUBEMAP
|
|
vec3 E = specularDFG(pixel);
|
|
vec3 r = getReflectedVector(pixel, shading_normal);
|
|
Fr = E * prefilteredRadiance(r, pixel.perceptualRoughness);
|
|
#elif IBL_INTEGRATION == IBL_INTEGRATION_IMPORTANCE_SAMPLING
|
|
vec3 E = vec3(0.0); // TODO: fix for importance sampling
|
|
Fr = isEvaluateIBL(pixel, shading_normal, shading_view, shading_NoV);
|
|
#endif
|
|
Fr *= singleBounceAO(specularAO) * pixel.energyCompensation;
|
|
|
|
// diffuse layer
|
|
float diffuseBRDF = singleBounceAO(diffuseAO); // Fd_Lambert() is baked in the SH below
|
|
evaluateClothIndirectDiffuseBRDF(pixel, diffuseBRDF);
|
|
|
|
#if defined(MATERIAL_HAS_BENT_NORMAL)
|
|
vec3 diffuseNormal = shading_bentNormal;
|
|
#else
|
|
vec3 diffuseNormal = shading_normal;
|
|
#endif
|
|
|
|
vec3 diffuseIrradiance = diffuseIrradiance(diffuseNormal);
|
|
vec3 Fd = pixel.diffuseColor * diffuseIrradiance * (1.0 - E) * diffuseBRDF;
|
|
|
|
// sheen layer
|
|
evaluateSheenIBL(pixel, specularAO, Fd, Fr);
|
|
|
|
// clear coat layer
|
|
evaluateClearCoatIBL(pixel, specularAO, Fd, Fr);
|
|
|
|
// subsurface layer
|
|
evaluateSubsurfaceIBL(pixel, diffuseIrradiance, Fd, Fr);
|
|
|
|
// extra ambient occlusion term
|
|
multiBounceAO(diffuseAO, pixel.diffuseColor, Fd);
|
|
multiBounceSpecularAO(specularAO, pixel.f0, Fr);
|
|
|
|
// Note: iblLuminance is already premultiplied by the exposure
|
|
combineDiffuseAndSpecular(pixel, shading_normal, E, Fd, Fr, color);
|
|
}
|