| const vertexShaderWSL1 = ` |
| struct Output { |
| float3 vPositionW : attribute(0); |
| float3 vNormalW : attribute(1); |
| float2 vMainUV1 : attribute(2); |
| float4 position : SV_Position; |
| } |
| |
| struct Scene { |
| float4x4 viewProjection; |
| float4x4 view; |
| } |
| |
| struct Material { |
| float2 vAlbedoInfos; |
| float4 vAmbientInfos; |
| float2 vOpacityInfos; |
| float2 vEmissiveInfos; |
| float2 vLightmapInfos; |
| float3 vReflectivityInfos; |
| float2 vMicroSurfaceSamplerInfos; |
| float2 vReflectionInfos; |
| float3 vReflectionPosition; |
| float3 vReflectionSize; |
| float3 vBumpInfos; |
| float4x4 albedoMatrix; |
| float4x4 ambientMatrix; |
| float4x4 opacityMatrix; |
| float4x4 emissiveMatrix; |
| float4x4 lightmapMatrix; |
| float4x4 reflectivityMatrix; |
| float4x4 microSurfaceSamplerMatrix; |
| float4x4 bumpMatrix; |
| float2 vTangentSpaceParams; |
| float4x4 reflectionMatrix; |
| float3 vReflectionColor; |
| float4 vAlbedoColor; |
| float4 vLightingIntensity; |
| float3 vReflectionMicrosurfaceInfos; |
| float pointSize; |
| float4 vReflectivityColor; |
| float3 vEmissiveColor; |
| float4 vEyePosition; |
| float3 vAmbientColor; |
| float2 vDebugMode; |
| float2 vClearCoatParams; |
| float4 vClearCoatRefractionParams; |
| float2 vClearCoatInfos; |
| float4x4 clearCoatMatrix; |
| float2 vClearCoatBumpInfos; |
| float2 vClearCoatTangentSpaceParams; |
| float4x4 clearCoatBumpMatrix; |
| float4 vClearCoatTintParams; |
| float clearCoatColorAtDistance; |
| float2 vClearCoatTintInfos; |
| float4x4 clearCoatTintMatrix; |
| float3 vAnisotropy; |
| float2 vAnisotropyInfos; |
| float4x4 anisotropyMatrix; |
| float4 vSheenColor; |
| float2 vSheenInfos; |
| float4x4 sheenMatrix; |
| float3 vRefractionMicrosurfaceInfos; |
| float4 vRefractionInfos; |
| float4x4 refractionMatrix; |
| float2 vThicknessInfos; |
| float4x4 thicknessMatrix; |
| float2 vThicknessParam; |
| float3 vDiffusionDistance; |
| float4 vTintColor; |
| float3 vSubSurfaceIntensity; |
| float3 vSphericalL00; |
| float3 vSphericalL1_1; |
| float3 vSphericalL10; |
| float3 vSphericalL11; |
| float3 vSphericalL2_2; |
| float3 vSphericalL2_1; |
| float3 vSphericalL20; |
| float3 vSphericalL21; |
| float3 vSphericalL22; |
| float3 vSphericalX; |
| float3 vSphericalY; |
| float3 vSphericalZ; |
| float3 vSphericalXX_ZZ; |
| float3 vSphericalYY_ZZ; |
| float3 vSphericalZZ; |
| float3 vSphericalXY; |
| float3 vSphericalYZ; |
| float3 vSphericalZX; |
| } |
| |
| struct Mesh { |
| float4x4 world; |
| float visibility; |
| } |
| |
| float3x3 transposeMat3(float3x3 inMatrix) { |
| float3 i0 = inMatrix[0]; |
| float3 i1 = inMatrix[1]; |
| float3 i2 = inMatrix[2]; |
| float3x3 outMatrix = float3x3( |
| float3(i0.x, i1.x, i2.x), |
| float3(i0.y, i1.y, i2.y), |
| float3(i0.z, i1.z, i2.z) |
| ); |
| return outMatrix; |
| } |
| |
| float3x3 inverseMat3(float3x3 inMatrix) { |
| float a00 = inMatrix[0][0], a01 = inMatrix[0][1], a02 = inMatrix[0][2]; |
| float a10 = inMatrix[1][0], a11 = inMatrix[1][1], a12 = inMatrix[1][2]; |
| float a20 = inMatrix[2][0], a21 = inMatrix[2][1], a22 = inMatrix[2][2]; |
| float b01 = a22 * a11 - a12 * a21; |
| float b11 = -a22 * a10 + a12 * a20; |
| float b21 = a21 * a10 - a11 * a20; |
| float det = a00 * b01 + a01 * b11 + a02 * b21; |
| return float3x3(b01, -a22 * a01 + a02 * a21, a12 * a01 - a02 * a11, |
| b11, a22 * a00 - a02 * a20, -a12 * a00 + a02 * a10, |
| b21, -a21 * a00 + a01 * a20, a11 * a00 - a01 * a10) / det; |
| } |
| |
| float3 toLinearSpace(float3 color) { |
| return pow(color, float3(2.2, 2.2, 2.2)); |
| } |
| |
| float3 toGammaSpace(float3 color) { |
| return pow(color, float3(1.0 / 2.2, 1.0 / 2.2, 1.0 / 2.2)); |
| } |
| |
| float square(float value) { |
| return value * value; |
| } |
| |
| float pow5(float value) { |
| float sq = value * value; |
| return sq * sq * value; |
| } |
| |
| float getLuminance(float3 color) { |
| return clamp(dot(color, float3(0.2126, 0.7152, 0.0722)), 0., 1.); |
| } |
| |
| float getRand(float2 seed) { |
| return frac(sin(dot(seed.xy, float2(12.9898, 78.233))) * 43758.5453); |
| } |
| |
| float dither(float2 seed, float varianceAmount) { |
| float rand = getRand(seed); |
| float dither = lerp(-varianceAmount / 255.0, varianceAmount / 255.0, rand); |
| return dither; |
| } |
| |
| float4 toRGBD(float3 color) { |
| float maxRGB = max(max(color.x, max(color.y, color.z)), 0.0000001); |
| float D = max(255.0 / maxRGB, 1.); |
| D = clamp(floor(D) / 255.0, 0., 1.); |
| float3 rgb = color * D; |
| rgb = toGammaSpace(rgb); |
| return float4(rgb, D); |
| } |
| |
| float3 fromRGBD(float4 rgbd) { |
| rgbd.xyz = toLinearSpace(rgbd.xyz); |
| return rgbd.xyz / rgbd.w; |
| } |
| |
| vertex Output main(float3 position : attribute(0), float3 normal : attribute(1), float2 uv : attribute(2), |
| constant Scene[] scene : register(b0, space0), |
| Texture2D<float4> environmentBrdfSamplerTexture : register(t1, space0), |
| sampler environmentBrdfSamplerSampler : register(s2, space0), |
| constant Material[] material : register(b0, space1), |
| constant Mesh[] mesh : register(b1, space1), |
| Texture2D<float4> reflectionSamplerTexture : register(t0, space2), |
| sampler reflectionSamplerSampler : register(s1, space2), |
| Texture2D<float4> albedoSamplerTexture : register(t2, space2), |
| sampler albedoSamplerSampler : register(s3, space2), |
| Texture2D<float4> reflectivitySamplerTexture : register(t4, space2), |
| sampler reflectivitySamplerSampler : register(s5, space2), |
| Texture2D<float4> ambientSamplerTexture : register(t6, space2), |
| sampler ambientSamplerSampler : register(s7, space2), |
| Texture2D<float4> emissiveSamplerTexture : register(t8, space2), |
| sampler emissiveSamplerSampler : register(s9, space2), |
| Texture2D<float4> bumpSamplerTexture : register(t10, space2), |
| sampler bumpSamplerSampler : register(s11, space2)) { |
| Output output; |
| float3 positionUpdated = position; |
| float3 normalUpdated = normal; |
| float2 uvUpdated = uv; |
| float4x4 finalWorld = mesh[0].world; |
| output.position = mul(mul(scene[0].viewProjection, finalWorld), float4(positionUpdated, 1.0)); |
| float4 worldPos = mul(finalWorld, float4(positionUpdated, 1.0)); |
| output.vPositionW = worldPos.xyz; |
| float3x3 normalWorld; |
| normalWorld[0] = finalWorld[0].xyz; |
| normalWorld[1] = finalWorld[1].xyz; |
| normalWorld[2] = finalWorld[2].xyz; |
| output.vNormalW = normalize(mul(normalWorld, normalUpdated)); |
| float2 uv2 = float2(0., 0.); |
| output.vMainUV1 = uvUpdated; |
| return output; |
| } |
| `; |
| |
| const fragmentShaderWSL1 = ` |
| struct Scene { |
| float4x4 viewProjection; |
| float4x4 view; |
| } |
| |
| struct Material { |
| float2 vAlbedoInfos; |
| float4 vAmbientInfos; |
| float2 vOpacityInfos; |
| float2 vEmissiveInfos; |
| float2 vLightmapInfos; |
| float3 vReflectivityInfos; |
| float2 vMicroSurfaceSamplerInfos; |
| float2 vReflectionInfos; |
| float3 vReflectionPosition; |
| float3 vReflectionSize; |
| float3 vBumpInfos; |
| float4x4 albedoMatrix; |
| float4x4 ambientMatrix; |
| float4x4 opacityMatrix; |
| float4x4 emissiveMatrix; |
| float4x4 lightmapMatrix; |
| float4x4 reflectivityMatrix; |
| float4x4 microSurfaceSamplerMatrix; |
| float4x4 bumpMatrix; |
| float2 vTangentSpaceParams; |
| float4x4 reflectionMatrix; |
| float3 vReflectionColor; |
| float4 vAlbedoColor; |
| float4 vLightingIntensity; |
| float3 vReflectionMicrosurfaceInfos; |
| float pointSize; |
| float4 vReflectivityColor; |
| float3 vEmissiveColor; |
| float4 vEyePosition; |
| float3 vAmbientColor; |
| float2 vDebugMode; |
| float2 vClearCoatParams; |
| float4 vClearCoatRefractionParams; |
| float2 vClearCoatInfos; |
| float4x4 clearCoatMatrix; |
| float2 vClearCoatBumpInfos; |
| float2 vClearCoatTangentSpaceParams; |
| float4x4 clearCoatBumpMatrix; |
| float4 vClearCoatTintParams; |
| float clearCoatColorAtDistance; |
| float2 vClearCoatTintInfos; |
| float4x4 clearCoatTintMatrix; |
| float3 vAnisotropy; |
| float2 vAnisotropyInfos; |
| float4x4 anisotropyMatrix; |
| float4 vSheenColor; |
| float2 vSheenInfos; |
| float4x4 sheenMatrix; |
| float3 vRefractionMicrosurfaceInfos; |
| float4 vRefractionInfos; |
| float4x4 refractionMatrix; |
| float2 vThicknessInfos; |
| float4x4 thicknessMatrix; |
| float2 vThicknessParam; |
| float3 vDiffusionDistance; |
| float4 vTintColor; |
| float3 vSubSurfaceIntensity; |
| float3 vSphericalL00; |
| float3 vSphericalL1_1; |
| float3 vSphericalL10; |
| float3 vSphericalL11; |
| float3 vSphericalL2_2; |
| float3 vSphericalL2_1; |
| float3 vSphericalL20; |
| float3 vSphericalL21; |
| float3 vSphericalL22; |
| float3 vSphericalX; |
| float3 vSphericalY; |
| float3 vSphericalZ; |
| float3 vSphericalXX_ZZ; |
| float3 vSphericalYY_ZZ; |
| float3 vSphericalZZ; |
| float3 vSphericalXY; |
| float3 vSphericalYZ; |
| float3 vSphericalZX; |
| } |
| |
| struct Mesh { |
| float4x4 world; |
| float visibility; |
| } |
| |
| float3x3 transposeMat3(float3x3 inMatrix) { |
| float3 i0 = inMatrix[0]; |
| float3 i1 = inMatrix[1]; |
| float3 i2 = inMatrix[2]; |
| float3x3 outMatrix = float3x3( |
| float3(i0.x, i1.x, i2.x), |
| float3(i0.y, i1.y, i2.y), |
| float3(i0.z, i1.z, i2.z) |
| ); |
| return outMatrix; |
| } |
| |
| float3x3 inverseMat3(float3x3 inMatrix) { |
| float a00 = inMatrix[0][0], a01 = inMatrix[0][1], a02 = inMatrix[0][2]; |
| float a10 = inMatrix[1][0], a11 = inMatrix[1][1], a12 = inMatrix[1][2]; |
| float a20 = inMatrix[2][0], a21 = inMatrix[2][1], a22 = inMatrix[2][2]; |
| float b01 = a22 * a11 - a12 * a21; |
| float b11 = -a22 * a10 + a12 * a20; |
| float b21 = a21 * a10 - a11 * a20; |
| float det = a00 * b01 + a01 * b11 + a02 * b21; |
| return float3x3(b01, -a22 * a01 + a02 * a21, a12 * a01 - a02 * a11, |
| b11, a22 * a00 - a02 * a20, -a12 * a00 + a02 * a10, |
| b21, -a21 * a00 + a01 * a20, a11 * a00 - a01 * a10) / det; |
| } |
| |
| float3 toLinearSpace(float3 color) { |
| return pow(color, float3(2.2, 2.2, 2.2)); |
| } |
| |
| float3 toGammaSpace(float3 color) { |
| return pow(color, float3(1.0 / 2.2, 1.0 / 2.2, 1.0 / 2.2)); |
| } |
| |
| float square(float value) { |
| return value * value; |
| } |
| |
| float pow5(float value) { |
| float sq = value * value; |
| return sq * sq * value; |
| } |
| |
| float getLuminance(float3 color) { |
| return clamp(dot(color, float3(0.2126, 0.7152, 0.0722)), 0., 1.); |
| } |
| |
| float getRand(float2 seed) { |
| return frac(sin(dot(seed.xy, float2(12.9898, 78.233))) * 43758.5453); |
| } |
| |
| float dither(float2 seed, float varianceAmount) { |
| float rand = getRand(seed); |
| float dither = lerp(-varianceAmount / 255.0, varianceAmount / 255.0, rand); |
| return dither; |
| } |
| |
| float4 toRGBD(float3 color) { |
| float maxRGB = max(max(color.x, max(color.y, color.z)), 0.0000001); |
| float D = max(255.0 / maxRGB, 1.); |
| D = clamp(floor(D) / 255.0, 0., 1.); |
| float3 rgb = color * D; |
| rgb = toGammaSpace(rgb); |
| return float4(rgb, D); |
| } |
| |
| float3 fromRGBD(float4 rgbd) { |
| rgbd.xyz = toLinearSpace(rgbd.xyz); |
| return rgbd.xyz / rgbd.w; |
| } |
| |
| float convertRoughnessToAverageSlope(float roughness) { |
| return square(roughness) + 0.0005; |
| } |
| |
| float fresnelGrazingReflectance(float reflectance0) { |
| float reflectance90 = clamp(reflectance0 * 25.0, 0.0, 1.0); |
| return reflectance90; |
| } |
| |
| float2 getAARoughnessFactors(float3 normalVector) { |
| return float2(0., 0.); |
| } |
| |
| float4 applyImageProcessing(float4 result) { |
| result.xyz = toGammaSpace(result.xyz); |
| result.xyz = clamp(result.xyz, float3(0.0, 0.0, 0.0), float3(1.0, 1.0, 1.0)); |
| return result; |
| } |
| |
| float3 computeEnvironmentIrradiance(float3 normal, constant Material* material) { |
| return material->vSphericalL00 |
| + material->vSphericalL1_1 * (normal.y) |
| + material->vSphericalL10 * (normal.z) |
| + material->vSphericalL11 * (normal.x) |
| + material->vSphericalL2_2 * (normal.y * normal.x) |
| + material->vSphericalL2_1 * (normal.y * normal.z) |
| + material->vSphericalL20 * ((3.0 * normal.z * normal.z) - 1.0) |
| + material->vSphericalL21 * (normal.z * normal.x) |
| + material->vSphericalL22 * (normal.x * normal.x - (normal.y * normal.y)); |
| } |
| |
| struct PreLightingInfo { |
| float3 lightOffset; |
| float lightDistanceSquared; |
| float lightDistance; |
| float attenuation; |
| float3 L; |
| float3 H; |
| float NdotV; |
| float NdotLUnclamped; |
| float NdotL; |
| float VdotH; |
| float roughness; |
| } |
| |
| PreLightingInfo computePointAndSpotPreLightingInfo(float4 lightData, float3 V, float3 N, float3 vPositionW) { |
| PreLightingInfo result; |
| result.lightOffset = lightData.xyz - vPositionW; |
| result.lightDistanceSquared = dot(result.lightOffset, result.lightOffset); |
| result.lightDistance = sqrt(result.lightDistanceSquared); |
| result.L = normalize(result.lightOffset); |
| result.H = normalize(V + result.L); |
| result.VdotH = clamp(dot(V, result.H), 0.0, 1.0); |
| result.NdotLUnclamped = dot(N, result.L); |
| result.NdotL = clamp(result.NdotLUnclamped, 0.0000001, 1.0); |
| return result; |
| } |
| |
| PreLightingInfo computeDirectionalPreLightingInfo(float4 lightData, float3 V, float3 N) { |
| PreLightingInfo result; |
| result.lightDistance = length(-lightData.xyz); |
| result.L = normalize(-lightData.xyz); |
| result.H = normalize(V + result.L); |
| result.VdotH = clamp(dot(V, result.H), 0.0, 1.0); |
| result.NdotLUnclamped = dot(N, result.L); |
| result.NdotL = clamp(result.NdotLUnclamped, 0.0000001, 1.0); |
| return result; |
| } |
| |
| PreLightingInfo computeHemisphericPreLightingInfo(float4 lightData, float3 V, float3 N) { |
| PreLightingInfo result; |
| result.NdotL = dot(N, lightData.xyz) * 0.5 + 0.5; |
| result.NdotL = clamp(result.NdotL, 0.0000001, 1.0); |
| result.NdotLUnclamped = result.NdotL; |
| return result; |
| } |
| |
| float computeDistanceLightFalloff_Standard(float3 lightOffset, float range) { |
| return max(0., 1.0 - length(lightOffset) / range); |
| } |
| |
| float computeDistanceLightFalloff_Physical(float lightDistanceSquared) { |
| return 1.0 / max(lightDistanceSquared, 0.0000001); |
| } |
| |
| float computeDistanceLightFalloff_GLTF(float lightDistanceSquared, float inverseSquaredRange) { |
| float lightDistanceFalloff = 1.0 / max(lightDistanceSquared, 0.0000001); |
| float factor = lightDistanceSquared * inverseSquaredRange; |
| float attenuation = clamp(1.0 - factor * factor, 0.0, 1.0); |
| attenuation *= attenuation; |
| lightDistanceFalloff *= attenuation; |
| return lightDistanceFalloff; |
| } |
| |
| float computeDistanceLightFalloff(float3 lightOffset, float lightDistanceSquared, float range, float inverseSquaredRange) { |
| return computeDistanceLightFalloff_Physical(lightDistanceSquared); |
| } |
| |
| float computeDirectionalLightFalloff_Standard(float3 lightDirection, float3 directionToLightCenterW, float cosHalfAngle, float exponent) { |
| float falloff = 0.0; |
| float cosAngle = max(dot(-lightDirection, directionToLightCenterW), 0.0000001); |
| if (cosAngle >= cosHalfAngle) { |
| falloff = max(0., pow(cosAngle, exponent)); |
| } |
| return falloff; |
| } |
| |
| float computeDirectionalLightFalloff_Physical(float3 lightDirection, float3 directionToLightCenterW, float cosHalfAngle) { |
| float kMinusLog2ConeAngleIntensityRatio = 6.64385618977; |
| float concentrationKappa = kMinusLog2ConeAngleIntensityRatio / (1.0 - cosHalfAngle); |
| float4 lightDirectionSpreadSG = float4(-lightDirection * concentrationKappa, -concentrationKappa); |
| float falloff = exp2(dot(float4(directionToLightCenterW, 1.0), lightDirectionSpreadSG)); |
| return falloff; |
| } |
| |
| float computeDirectionalLightFalloff_GLTF(float3 lightDirection, float3 directionToLightCenterW, float lightAngleScale, float lightAngleOffset) { |
| float cd = dot(-lightDirection, directionToLightCenterW); |
| float falloff = clamp(cd * lightAngleScale + lightAngleOffset, 0.0, 1.0); |
| falloff *= falloff; |
| return falloff; |
| } |
| |
| float computeDirectionalLightFalloff(float3 lightDirection, float3 directionToLightCenterW, float cosHalfAngle, float exponent, float lightAngleScale, float lightAngleOffset) { |
| return computeDirectionalLightFalloff_Physical(lightDirection, directionToLightCenterW, cosHalfAngle); |
| } |
| |
| float3 getEnergyConservationFactor(float3 specularEnvironmentR0, float3 environmentBrdf) { |
| return float3(1.0, 1.0, 1.0) + specularEnvironmentR0 * (1.0 / environmentBrdf.y - 1.0); |
| } |
| |
| float3 getBRDFLookup(float NdotV, float perceptualRoughness, Texture2D<float4> environmentBrdfSamplerTexture, sampler environmentBrdfSamplerSampler) { |
| float2 UV = float2(NdotV, perceptualRoughness); |
| float4 brdfLookup = Sample(environmentBrdfSamplerTexture, environmentBrdfSamplerSampler, UV); |
| return brdfLookup.xyz; |
| } |
| |
| float3 getReflectanceFromBRDFLookup(float3 specularEnvironmentR0, float3 environmentBrdf) { |
| float3 reflectance = lerp(environmentBrdf.xxx, environmentBrdf.yyy, specularEnvironmentR0); |
| return reflectance; |
| } |
| |
| float3 fresnelSchlickGGX(float VdotH, float3 reflectance0, float3 reflectance90) { |
| return reflectance0 + (reflectance90 - reflectance0) * pow5(1.0 - VdotH); |
| } |
| |
| float fresnelSchlickGGX(float VdotH, float reflectance0, float reflectance90) { |
| return reflectance0 + (reflectance90 - reflectance0) * pow5(1.0 - VdotH); |
| } |
| |
| float normalDistributionFunction_TrowbridgeReitzGGX(float NdotH, float alphaG) { |
| float a2 = square(alphaG); |
| float d = NdotH * NdotH * (a2 - 1.0) + 1.0; |
| return a2 / (3.1415926535897932384626433832795 * d * d); |
| } |
| |
| float smithVisibility_GGXCorrelated(float NdotL, float NdotV, float alphaG) { |
| float a2 = alphaG * alphaG; |
| float GGXV = NdotL * sqrt(NdotV * (NdotV - a2 * NdotV) + a2); |
| float GGXL = NdotV * sqrt(NdotL * (NdotL - a2 * NdotL) + a2); |
| return 0.5 / (GGXV + GGXL); |
| } |
| |
| float diffuseBRDF_Burley(float NdotL, float NdotV, float VdotH, float roughness) { |
| float diffuseFresnelNV = pow5(clamp(1.0 - NdotL, 0.0000001, 1.0)); |
| float diffuseFresnelNL = pow5(clamp(1.0 - NdotV, 0.0000001, 1.0)); |
| float diffuseFresnel90 = 0.5 + 2.0 * VdotH * VdotH * roughness; |
| float fresnel = (1.0 + (diffuseFresnel90 - 1.0) * diffuseFresnelNL) * |
| (1.0 + (diffuseFresnel90 - 1.0) * diffuseFresnelNV); |
| return fresnel / 3.1415926535897932384626433832795; |
| } |
| |
| struct LightingInfo { |
| float3 diffuse; |
| } |
| |
| float adjustRoughnessFromLightProperties(float roughness, float lightRadius, float lightDistance) { |
| float lightRoughness = lightRadius / lightDistance; |
| float totalRoughness = clamp(lightRoughness + roughness, 0.0, 1.0); |
| return totalRoughness; |
| } |
| |
| float3 computeHemisphericDiffuseLighting(PreLightingInfo info, float3 lightColor, float3 groundColor) { |
| return lerp(groundColor, lightColor, float3(info.NdotL, info.NdotL, info.NdotL)); |
| } |
| |
| float3 computeDiffuseLighting(PreLightingInfo info, float3 lightColor) { |
| float diffuseTerm = diffuseBRDF_Burley(info.NdotL, info.NdotV, info.VdotH, info.roughness); |
| return diffuseTerm * info.attenuation * info.NdotL * lightColor; |
| } |
| |
| float2 computeProjectionTextureDiffuseLightingUV(float4x4 textureProjectionMatrix, float3 vPositionW) { |
| float4 strq = mul(textureProjectionMatrix, float4(vPositionW, 1.0)); |
| strq /= strq.w; |
| return strq.xy; |
| } |
| |
| float getLodFromAlphaG(float cubeMapDimensionPixels, float microsurfaceAverageSlope) { |
| float microsurfaceAverageSlopeTexels = cubeMapDimensionPixels * microsurfaceAverageSlope; |
| float lod = log2(microsurfaceAverageSlopeTexels); |
| return lod; |
| } |
| |
| float getLinearLodFromRoughness(float cubeMapDimensionPixels, float roughness) { |
| float lod = log2(cubeMapDimensionPixels) * roughness; |
| return lod; |
| } |
| |
| float environmentRadianceOcclusion(float ambientOcclusion, float NdotVUnclamped) { |
| float temp = NdotVUnclamped + ambientOcclusion; |
| return clamp(square(temp) - 1.0 + ambientOcclusion, 0.0, 1.0); |
| } |
| |
| float environmentHorizonOcclusion(float3 view, float3 normal) { |
| float3 reflection = reflect(view, normal); |
| float temp = clamp(1.0 + 1.1 * dot(reflection, normal), 0.0, 1.0); |
| return square(temp); |
| } |
| |
| float3 perturbNormal(float3x3 cotangentFrame, float3 textureSample, float scale) { |
| textureSample = textureSample * 2.0 - 1.0; |
| textureSample = normalize(textureSample * float3(scale, scale, 1.0)); |
| return normalize(mul(cotangentFrame, textureSample)); |
| } |
| |
| float3x3 cotangent_frame(float3 normal, float3 p, float2 uv, float2 tangentSpaceParams, bool frontFace) { |
| uv = frontFace ? uv : -uv; |
| float3 dp1 = ddx(p); |
| float3 dp2 = ddy(p); |
| float2 duv1 = ddx(uv); |
| float2 duv2 = ddy(uv); |
| float3 dp2perp = cross(dp2, normal); |
| float3 dp1perp = cross(normal, dp1); |
| float3 tangent = dp2perp * duv1.x + dp1perp * duv2.x; |
| float3 bitangent = dp2perp * duv1.y + dp1perp * duv2.y; |
| tangent *= tangentSpaceParams.x; |
| bitangent *= tangentSpaceParams.y; |
| float invmax = rsqrt(max(dot(tangent, tangent), dot(bitangent, bitangent))); |
| return float3x3(tangent * invmax, bitangent * invmax, normal); |
| } |
| |
| float3 perturbNormal(float3x3 cotangentFrame, float2 uv, Texture2D<float4> bumpSamplerTexture, sampler bumpSamplerSampler, float3 vBumpInfos) { |
| return perturbNormal(cotangentFrame, Sample(bumpSamplerTexture, bumpSamplerSampler, uv).xyz, vBumpInfos.y); |
| } |
| |
| float3 perturbNormal(float3x3 cotangentFrame, float3 color, float3 vBumpInfos) { |
| return perturbNormal(cotangentFrame, color, vBumpInfos.y); |
| } |
| |
| float3 parallaxCorrectNormal(float3 vertexPos, float3 origVec, float3 cubeSize, float3 cubePos) { |
| float3 invOrigVec = float3(1.0, 1.0, 1.0) / origVec; |
| float3 halfSize = cubeSize * 0.5; |
| float3 intersecAtMaxPlane = (cubePos + halfSize - vertexPos) * invOrigVec; |
| float3 intersecAtMinPlane = (cubePos - halfSize - vertexPos) * invOrigVec; |
| float3 largestIntersec = max(intersecAtMaxPlane, intersecAtMinPlane); |
| float distance = min(min(largestIntersec.x, largestIntersec.y), largestIntersec.z); |
| float3 intersectPositionWS = vertexPos + origVec * distance; |
| return intersectPositionWS - cubePos; |
| } |
| |
| float3 computeFixedEquirectangularCoords(float4 worldPos, float3 worldNormal, float3 direction) { |
| float lon = atan2(direction.z, direction.x); |
| float lat = acos(direction.y); |
| float2 sphereCoords = float2(lon, lat) * 0.15915494 * 2.0; |
| float s = sphereCoords.x * 0.5 + 0.5; |
| float t = sphereCoords.y; |
| return float3(s, t, 0); |
| } |
| |
| float3 computeMirroredFixedEquirectangularCoords(float4 worldPos, float3 worldNormal, float3 direction) { |
| float lon = atan2(direction.z, direction.x); |
| float lat = acos(direction.y); |
| float2 sphereCoords = float2(lon, lat) * 0.15915494 * 2.0; |
| float s = sphereCoords.x * 0.5 + 0.5; |
| float t = sphereCoords.y; |
| return float3(1.0 - s, t, 0); |
| } |
| |
| float3 computeEquirectangularCoords(float4 worldPos, float3 worldNormal, float3 eyePosition, float4x4 reflectionMatrix) { |
| float3 cameraToVertex = normalize(worldPos.xyz - eyePosition); |
| float3 r = normalize(reflect(cameraToVertex, worldNormal)); |
| r = mul(reflectionMatrix, float4(r, 0)).xyz; |
| float lon = atan2(r.z, r.x); |
| float lat = acos(r.y); |
| float2 sphereCoords = float2(lon, lat) * 0.15915494 * 2.0; |
| float s = sphereCoords.x * 0.5 + 0.5; |
| float t = sphereCoords.y; |
| return float3(s, t, 0); |
| } |
| |
| float3 computeSphericalCoords(float4 worldPos, float3 worldNormal, float4x4 view, float4x4 reflectionMatrix) { |
| float3 viewDir = normalize(mul(view, worldPos).xyz); |
| float3 viewNormal = normalize(mul(view, float4(worldNormal, 0.0)).xyz); |
| float3 r = reflect(viewDir, viewNormal); |
| r = mul(reflectionMatrix, float4(r, 0)).xyz; |
| r.z = r.z - 1.0; |
| float m = 2.0 * length(r); |
| return float3(r.x / m + 0.5, 1.0 - r.y / m - 0.5, 0); |
| } |
| |
| float3 computePlanarCoords(float4 worldPos, float3 worldNormal, float3 eyePosition, float4x4 reflectionMatrix) { |
| float3 viewDir = worldPos.xyz - eyePosition; |
| float3 coords = normalize(reflect(viewDir, worldNormal)); |
| return mul(reflectionMatrix, float4(coords, 1)).xyz; |
| } |
| |
| float3 computeCubicCoords(float4 worldPos, float3 worldNormal, float3 eyePosition, float4x4 reflectionMatrix) { |
| float3 viewDir = normalize(worldPos.xyz - eyePosition); |
| float3 coords = reflect(viewDir, worldNormal); |
| coords = mul(reflectionMatrix, float4(coords, 0)).xyz; |
| return coords; |
| } |
| |
| float3 computeCubicLocalCoords(float4 worldPos, float3 worldNormal, float3 eyePosition, float4x4 reflectionMatrix, float3 reflectionSize, float3 reflectionPosition) { |
| float3 viewDir = normalize(worldPos.xyz - eyePosition); |
| float3 coords = reflect(viewDir, worldNormal); |
| coords = parallaxCorrectNormal(worldPos.xyz, coords, reflectionSize, reflectionPosition); |
| coords = mul(reflectionMatrix, float4(coords, 0)).xyz; |
| return coords; |
| } |
| |
| float3 computeProjectionCoords(float4 worldPos, float4x4 view, float4x4 reflectionMatrix) { |
| return mul(reflectionMatrix, mul(view, worldPos)).xyz; |
| } |
| |
| float3 computeSkyBoxCoords(float3 positionW, float4x4 reflectionMatrix) { |
| return mul(reflectionMatrix, float4(positionW, 0)).xyz; |
| } |
| |
| float3 computeReflectionCoords(float4 worldPos, float3 worldNormal, float4 vEyePosition, float4x4 reflectionMatrix) { |
| return computeCubicCoords(worldPos, worldNormal, vEyePosition.xyz, reflectionMatrix); |
| } |
| |
| fragment float4 main(float3 vPositionW : attribute(0), float3 vNormalW : attribute(1), float2 vMainUV1 : attribute(2), |
| constant Scene[] scene : register(b0, space0), |
| Texture2D<float4> environmentBrdfSamplerTexture : register(t1, space0), |
| sampler environmentBrdfSamplerSampler : register(s2, space0), |
| constant Material[] material : register(b0, space1), |
| constant Mesh[] mesh : register(b1, space1), |
| Texture2D<float4> reflectionSamplerTexture : register(t0, space2), |
| sampler reflectionSamplerSampler : register(s1, space2), |
| Texture2D<float4> albedoSamplerTexture : register(t2, space2), |
| sampler albedoSamplerSampler : register(s3, space2), |
| Texture2D<float4> reflectivitySamplerTexture : register(t4, space2), |
| sampler reflectivitySamplerSampler : register(s5, space2), |
| Texture2D<float4> ambientSamplerTexture : register(t6, space2), |
| sampler ambientSamplerSampler : register(s7, space2), |
| Texture2D<float4> emissiveSamplerTexture : register(t8, space2), |
| sampler emissiveSamplerSampler : register(s9, space2), |
| Texture2D<float4> bumpSamplerTexture : register(t10, space2), |
| sampler bumpSamplerSampler : register(s11, space2), |
| bool frontFace : SV_IsFrontFace) : SV_Target 0 { |
| float3 viewDirectionW = normalize(material[0].vEyePosition.xyz - vPositionW); |
| float3 normalW = normalize(vNormalW); |
| float2 uvOffset = float2(0.0, 0.0); |
| float normalScale = 1.0; |
| float3x3 TBN = cotangent_frame(normalW * normalScale, vPositionW, vMainUV1, material[0].vTangentSpaceParams, frontFace); |
| normalW = perturbNormal(TBN, vMainUV1 + uvOffset, bumpSamplerTexture, bumpSamplerSampler, material[0].vBumpInfos); |
| float3 surfaceAlbedo = material[0].vAlbedoColor.xyz; |
| float alpha = material[0].vAlbedoColor.w; |
| float4 albedoTexture = Sample(albedoSamplerTexture, albedoSamplerSampler, vMainUV1 + uvOffset); |
| surfaceAlbedo *= toLinearSpace(albedoTexture.xyz); |
| surfaceAlbedo *= material[0].vAlbedoInfos.y; |
| float3 ambientOcclusionColor = float3(1., 1., 1.); |
| float3 ambientOcclusionColorMap = Sample(ambientSamplerTexture, ambientSamplerSampler, vMainUV1 + uvOffset).xyz * material[0].vAmbientInfos.y; |
| ambientOcclusionColorMap = float3(ambientOcclusionColorMap.x, ambientOcclusionColorMap.x, ambientOcclusionColorMap.x); |
| ambientOcclusionColor = lerp(ambientOcclusionColor, ambientOcclusionColorMap, float3(material[0].vAmbientInfos.z, material[0].vAmbientInfos.z, material[0].vAmbientInfos.z)); |
| float microSurface = material[0].vReflectivityColor.w; |
| float3 surfaceReflectivityColor = material[0].vReflectivityColor.xyz; |
| float2 metallicRoughness = surfaceReflectivityColor.xy; |
| float4 surfaceMetallicColorMap = Sample(reflectivitySamplerTexture, reflectivitySamplerSampler, vMainUV1 + uvOffset); |
| metallicRoughness.x *= surfaceMetallicColorMap.z; |
| metallicRoughness.y *= surfaceMetallicColorMap.y; |
| microSurface = 1.0 - metallicRoughness.y; |
| float3 baseColor = surfaceAlbedo; |
| float3 DefaultSpecularReflectanceDielectric = float3(0.04, 0.04, 0.04); |
| surfaceAlbedo = lerp(baseColor * (1.0 - DefaultSpecularReflectanceDielectric.x), float3(0., 0., 0.), float3(metallicRoughness.x, metallicRoughness.x, metallicRoughness.x)); |
| surfaceReflectivityColor = lerp(DefaultSpecularReflectanceDielectric, baseColor, float3(metallicRoughness.x, metallicRoughness.x, metallicRoughness.x)); |
| microSurface = clamp(microSurface, 0.0, 1.0); |
| float roughness = 1. - microSurface; |
| float NdotVUnclamped = dot(normalW, viewDirectionW); |
| float NdotV = abs(NdotVUnclamped) + 0.0000001; |
| float alphaG = convertRoughnessToAverageSlope(roughness); |
| float2 AARoughnessFactors = getAARoughnessFactors(normalW.xyz); |
| alphaG += AARoughnessFactors.y; |
| float4 environmentRadiance = float4(0.,0., 0., 0.); |
| float3 environmentIrradiance = float3(0., 0., 0.); |
| float3 reflectionVector = computeReflectionCoords(float4(vPositionW, 1.0), normalW, material[0].vEyePosition, material[0].reflectionMatrix); |
| float3 reflectionCoords = reflectionVector; |
| float reflectionLOD = getLodFromAlphaG(material[0].vReflectionMicrosurfaceInfos.x, alphaG); |
| reflectionLOD = reflectionLOD * material[0].vReflectionMicrosurfaceInfos.y + material[0].vReflectionMicrosurfaceInfos.z; |
| float requestedReflectionLOD = reflectionLOD; |
| environmentRadiance = Sample(reflectionSamplerTexture, reflectionSamplerSampler, reflectionCoords.xy); //SampleLevel(reflectionSamplerTexture, reflectionSamplerSampler, reflectionCoords, requestedReflectionLOD); |
| environmentRadiance.xyz = fromRGBD(environmentRadiance); |
| float3 irradianceVector = mul(material[0].reflectionMatrix, float4(normalW, 0)).xyz; |
| environmentIrradiance = computeEnvironmentIrradiance(irradianceVector, &material[0]); |
| environmentRadiance.xyz *= material[0].vReflectionInfos.x; |
| environmentRadiance.xyz *= material[0].vReflectionColor.xyz; |
| environmentIrradiance *= material[0].vReflectionColor.xyz; |
| float reflectance = max(max(surfaceReflectivityColor.x, surfaceReflectivityColor.y), surfaceReflectivityColor.z); |
| float reflectance90 = fresnelGrazingReflectance(reflectance); |
| float3 specularEnvironmentR0 = surfaceReflectivityColor.xyz; |
| float3 specularEnvironmentR90 = float3(1.0, 1.0, 1.0) * reflectance90; |
| float3 environmentBrdf = getBRDFLookup(NdotV, roughness, environmentBrdfSamplerTexture, environmentBrdfSamplerSampler); |
| float3 energyConservationFactor = getEnergyConservationFactor(specularEnvironmentR0, environmentBrdf); |
| float3 diffuseBase = float3(0., 0., 0.); |
| PreLightingInfo preInfo; |
| LightingInfo info; |
| float shadow = 1.; |
| float3 specularEnvironmentReflectance = getReflectanceFromBRDFLookup(specularEnvironmentR0, environmentBrdf); |
| float ambientMonochrome = ambientOcclusionColor.x; |
| float seo = environmentRadianceOcclusion(ambientMonochrome, NdotVUnclamped); |
| specularEnvironmentReflectance *= seo; |
| float eho = environmentHorizonOcclusion(-viewDirectionW, normalW); |
| specularEnvironmentReflectance *= eho; |
| float3 finalIrradiance = environmentIrradiance; |
| finalIrradiance *= surfaceAlbedo.xyz; |
| float3 finalRadiance = environmentRadiance.xyz; |
| finalRadiance *= specularEnvironmentReflectance; |
| float3 finalRadianceScaled = finalRadiance * material[0].vLightingIntensity.z; |
| finalRadianceScaled *= energyConservationFactor; |
| float3 finalDiffuse = diffuseBase; |
| finalDiffuse *= surfaceAlbedo.xyz; |
| finalDiffuse = max(finalDiffuse, float3(0.0, 0.0, 0.0)); |
| float3 finalAmbient = material[0].vAmbientColor; |
| finalAmbient *= surfaceAlbedo.xyz; |
| float3 finalEmissive = material[0].vEmissiveColor; |
| float3 emissiveColorTex = Sample(emissiveSamplerTexture, emissiveSamplerSampler, vMainUV1 + uvOffset).xyz; |
| finalEmissive *= toLinearSpace(emissiveColorTex); |
| finalEmissive *= material[0].vEmissiveInfos.y; |
| float3 ambientOcclusionForDirectDiffuse = lerp(float3(1., 1., 1.), ambientOcclusionColor, float3(material[0].vAmbientInfos.w, material[0].vAmbientInfos.w, material[0].vAmbientInfos.w)); |
| float4 finalColor = float4( |
| finalAmbient * ambientOcclusionColor + |
| finalDiffuse * ambientOcclusionForDirectDiffuse * material[0].vLightingIntensity.x + |
| finalIrradiance * ambientOcclusionColor * material[0].vLightingIntensity.z + |
| finalRadianceScaled + |
| finalEmissive * material[0].vLightingIntensity.y, |
| alpha); |
| finalColor = max(finalColor, float4(0.0, 0.0, 0.0, 0.0)); |
| finalColor = applyImageProcessing(finalColor); |
| finalColor.w *= mesh[0].visibility; |
| return finalColor; |
| } |
| `; |
| |
| const vertexShaderWSL2 = ` |
| struct Output { |
| float3 vPositionW : attribute(0); |
| float3 vNormalW : attribute(1); |
| float3 vPositionUVW : attribute(2); |
| float4 position : SV_Position; |
| } |
| |
| struct Scene { |
| float4x4 viewProjection; |
| float4x4 view; |
| } |
| |
| struct Material { |
| float2 vAlbedoInfos; |
| float4 vAmbientInfos; |
| float2 vOpacityInfos; |
| float2 vEmissiveInfos; |
| float2 vLightmapInfos; |
| float3 vReflectivityInfos; |
| float2 vMicroSurfaceSamplerInfos; |
| float2 vReflectionInfos; |
| float3 vReflectionPosition; |
| float3 vReflectionSize; |
| float3 vBumpInfos; |
| float4x4 albedoMatrix; |
| float4x4 ambientMatrix; |
| float4x4 opacityMatrix; |
| float4x4 emissiveMatrix; |
| float4x4 lightmapMatrix; |
| float4x4 reflectivityMatrix; |
| float4x4 microSurfaceSamplerMatrix; |
| float4x4 bumpMatrix; |
| float2 vTangentSpaceParams; |
| float4x4 reflectionMatrix; |
| float3 vReflectionColor; |
| float4 vAlbedoColor; |
| float4 vLightingIntensity; |
| float3 vReflectionMicrosurfaceInfos; |
| float pointSize; |
| float4 vReflectivityColor; |
| float3 vEmissiveColor; |
| float4 vEyePosition; |
| float3 vAmbientColor; |
| float2 vDebugMode; |
| float2 vClearCoatParams; |
| float4 vClearCoatRefractionParams; |
| float2 vClearCoatInfos; |
| float4x4 clearCoatMatrix; |
| float2 vClearCoatBumpInfos; |
| float2 vClearCoatTangentSpaceParams; |
| float4x4 clearCoatBumpMatrix; |
| float4 vClearCoatTintParams; |
| float clearCoatColorAtDistance; |
| float2 vClearCoatTintInfos; |
| float4x4 clearCoatTintMatrix; |
| float3 vAnisotropy; |
| float2 vAnisotropyInfos; |
| float4x4 anisotropyMatrix; |
| float4 vSheenColor; |
| float2 vSheenInfos; |
| float4x4 sheenMatrix; |
| float3 vRefractionMicrosurfaceInfos; |
| float4 vRefractionInfos; |
| float4x4 refractionMatrix; |
| float2 vThicknessInfos; |
| float4x4 thicknessMatrix; |
| float2 vThicknessParam; |
| float3 vDiffusionDistance; |
| float4 vTintColor; |
| float3 vSubSurfaceIntensity; |
| float3 vSphericalL00; |
| float3 vSphericalL1_1; |
| float3 vSphericalL10; |
| float3 vSphericalL11; |
| float3 vSphericalL2_2; |
| float3 vSphericalL2_1; |
| float3 vSphericalL20; |
| float3 vSphericalL21; |
| float3 vSphericalL22; |
| float3 vSphericalX; |
| float3 vSphericalY; |
| float3 vSphericalZ; |
| float3 vSphericalXX_ZZ; |
| float3 vSphericalYY_ZZ; |
| float3 vSphericalZZ; |
| float3 vSphericalXY; |
| float3 vSphericalYZ; |
| float3 vSphericalZX; |
| } |
| |
| struct Mesh { |
| float4x4 world; |
| float visibility; |
| } |
| |
| float3x3 transposeMat3(float3x3 inMatrix) { |
| float3 i0 = inMatrix[0]; |
| float3 i1 = inMatrix[1]; |
| float3 i2 = inMatrix[2]; |
| float3x3 outMatrix = float3x3( |
| float3(i0.x, i1.x, i2.x), |
| float3(i0.y, i1.y, i2.y), |
| float3(i0.z, i1.z, i2.z) |
| ); |
| return outMatrix; |
| } |
| |
| float3x3 inverseMat3(float3x3 inMatrix) { |
| float a00 = inMatrix[0][0], a01 = inMatrix[0][1], a02 = inMatrix[0][2]; |
| float a10 = inMatrix[1][0], a11 = inMatrix[1][1], a12 = inMatrix[1][2]; |
| float a20 = inMatrix[2][0], a21 = inMatrix[2][1], a22 = inMatrix[2][2]; |
| float b01 = a22 * a11 - a12 * a21; |
| float b11 = -a22 * a10 + a12 * a20; |
| float b21 = a21 * a10 - a11 * a20; |
| float det = a00 * b01 + a01 * b11 + a02 * b21; |
| return float3x3(b01, -a22 * a01 + a02 * a21, a12 * a01 - a02 * a11, |
| b11, a22 * a00 - a02 * a20, -a12 * a00 + a02 * a10, |
| b21, -a21 * a00 + a01 * a20, a11 * a00 - a01 * a10) / det; |
| } |
| |
| float3 toLinearSpace(float3 color) { |
| return pow(color, float3(2.2, 2.2, 2.2)); |
| } |
| |
| float3 toGammaSpace(float3 color) { |
| return pow(color, float3(1.0 / 2.2, 1.0 / 2.2, 1.0 / 2.2)); |
| } |
| |
| float square(float value) { |
| return value * value; |
| } |
| |
| float pow5(float value) { |
| float sq = value * value; |
| return sq * sq * value; |
| } |
| |
| float getLuminance(float3 color) { |
| return clamp(dot(color, float3(0.2126, 0.7152, 0.0722)), 0., 1.); |
| } |
| |
| float getRand(float2 seed) { |
| return frac(sin(dot(seed.xy, float2(12.9898, 78.233))) * 43758.5453); |
| } |
| |
| float dither(float2 seed, float varianceAmount) { |
| float rand = getRand(seed); |
| float dither = lerp(-varianceAmount / 255.0, varianceAmount / 255.0, rand); |
| return dither; |
| } |
| |
| float4 toRGBD(float3 color) { |
| float maxRGB = max(max(color.x, max(color.y, color.z)), 0.0000001); |
| float D = max(255.0 / maxRGB, 1.); |
| D = clamp(floor(D) / 255.0, 0., 1.); |
| float3 rgb = color * D; |
| rgb = toGammaSpace(rgb); |
| return float4(rgb, D); |
| } |
| |
| float3 fromRGBD(float4 rgbd) { |
| rgbd.xyz = toLinearSpace(rgbd.xyz); |
| return rgbd.xyz / rgbd.w; |
| } |
| |
| vertex Output main(float3 position : attribute(0), float3 normal : attribute(1), |
| constant Scene[] scene : register(b0, space0), |
| Texture2D<float4> environmentBrdfSamplerTexture : register(t1, space0), |
| sampler environmentBrdfSamplerSampler : register(s2, space0), |
| constant Material[] material : register(b0, space1), |
| constant Mesh[] mesh : register(b1, space1), |
| Texture2D<float4> reflectionSamplerTexture : register(t0, space2), |
| sampler reflectionSamplerSampler : register(s1, space2)) { |
| Output output; |
| float3 positionUpdated = position; |
| float3 normalUpdated = normal; |
| output.vPositionUVW = positionUpdated; |
| float4x4 finalWorld = mesh[0].world; |
| output.position = mul(mul(scene[0].viewProjection, finalWorld), float4(positionUpdated, 1.0)); |
| float4 worldPos = mul(finalWorld, float4(positionUpdated, 1.0)); |
| output.vPositionW = worldPos.xyz; |
| float3x3 normalWorld; |
| normalWorld[0] = finalWorld[0].xyz; |
| normalWorld[1] = finalWorld[1].xyz; |
| normalWorld[2] = finalWorld[2].xyz; |
| output.vNormalW = normalize(mul(normalWorld, normalUpdated)); |
| float2 uvUpdated; |
| float2 uv2; |
| return output; |
| } |
| `; |
| |
| const fragmentShaderWSL2 = ` |
| struct Scene { |
| float4x4 viewProjection; |
| float4x4 view; |
| } |
| |
| struct Material { |
| float2 vAlbedoInfos; |
| float4 vAmbientInfos; |
| float2 vOpacityInfos; |
| float2 vEmissiveInfos; |
| float2 vLightmapInfos; |
| float3 vReflectivityInfos; |
| float2 vMicroSurfaceSamplerInfos; |
| float2 vReflectionInfos; |
| float3 vReflectionPosition; |
| float3 vReflectionSize; |
| float3 vBumpInfos; |
| float4x4 albedoMatrix; |
| float4x4 ambientMatrix; |
| float4x4 opacityMatrix; |
| float4x4 emissiveMatrix; |
| float4x4 lightmapMatrix; |
| float4x4 reflectivityMatrix; |
| float4x4 microSurfaceSamplerMatrix; |
| float4x4 bumpMatrix; |
| float2 vTangentSpaceParams; |
| float4x4 reflectionMatrix; |
| float3 vReflectionColor; |
| float4 vAlbedoColor; |
| float4 vLightingIntensity; |
| float3 vReflectionMicrosurfaceInfos; |
| float pointSize; |
| float4 vReflectivityColor; |
| float3 vEmissiveColor; |
| float4 vEyePosition; |
| float3 vAmbientColor; |
| float2 vDebugMode; |
| float2 vClearCoatParams; |
| float4 vClearCoatRefractionParams; |
| float2 vClearCoatInfos; |
| float4x4 clearCoatMatrix; |
| float2 vClearCoatBumpInfos; |
| float2 vClearCoatTangentSpaceParams; |
| float4x4 clearCoatBumpMatrix; |
| float4 vClearCoatTintParams; |
| float clearCoatColorAtDistance; |
| float2 vClearCoatTintInfos; |
| float4x4 clearCoatTintMatrix; |
| float3 vAnisotropy; |
| float2 vAnisotropyInfos; |
| float4x4 anisotropyMatrix; |
| float4 vSheenColor; |
| float2 vSheenInfos; |
| float4x4 sheenMatrix; |
| float3 vRefractionMicrosurfaceInfos; |
| float4 vRefractionInfos; |
| float4x4 refractionMatrix; |
| float2 vThicknessInfos; |
| float4x4 thicknessMatrix; |
| float2 vThicknessParam; |
| float3 vDiffusionDistance; |
| float4 vTintColor; |
| float3 vSubSurfaceIntensity; |
| float3 vSphericalL00; |
| float3 vSphericalL1_1; |
| float3 vSphericalL10; |
| float3 vSphericalL11; |
| float3 vSphericalL2_2; |
| float3 vSphericalL2_1; |
| float3 vSphericalL20; |
| float3 vSphericalL21; |
| float3 vSphericalL22; |
| float3 vSphericalX; |
| float3 vSphericalY; |
| float3 vSphericalZ; |
| float3 vSphericalXX_ZZ; |
| float3 vSphericalYY_ZZ; |
| float3 vSphericalZZ; |
| float3 vSphericalXY; |
| float3 vSphericalYZ; |
| float3 vSphericalZX; |
| } |
| |
| struct Mesh { |
| float4x4 world; |
| float visibility; |
| } |
| |
| float3x3 transposeMat3(float3x3 inMatrix) { |
| float3 i0 = inMatrix[0]; |
| float3 i1 = inMatrix[1]; |
| float3 i2 = inMatrix[2]; |
| float3x3 outMatrix = float3x3( |
| float3(i0.x, i1.x, i2.x), |
| float3(i0.y, i1.y, i2.y), |
| float3(i0.z, i1.z, i2.z) |
| ); |
| return outMatrix; |
| } |
| |
| float3x3 inverseMat3(float3x3 inMatrix) { |
| float a00 = inMatrix[0][0], a01 = inMatrix[0][1], a02 = inMatrix[0][2]; |
| float a10 = inMatrix[1][0], a11 = inMatrix[1][1], a12 = inMatrix[1][2]; |
| float a20 = inMatrix[2][0], a21 = inMatrix[2][1], a22 = inMatrix[2][2]; |
| float b01 = a22 * a11 - a12 * a21; |
| float b11 = -a22 * a10 + a12 * a20; |
| float b21 = a21 * a10 - a11 * a20; |
| float det = a00 * b01 + a01 * b11 + a02 * b21; |
| return float3x3(b01, -a22 * a01 + a02 * a21, a12 * a01 - a02 * a11, |
| b11, a22 * a00 - a02 * a20, -a12 * a00 + a02 * a10, |
| b21, -a21 * a00 + a01 * a20, a11 * a00 - a01 * a10) / det; |
| } |
| |
| float3 toLinearSpace(float3 color) { |
| return pow(color, float3(2.2, 2.2, 2.2)); |
| } |
| |
| float3 toGammaSpace(float3 color) { |
| return pow(color, float3(1.0 / 2.2, 1.0 / 2.2, 1.0 / 2.2)); |
| } |
| |
| float square(float value) { |
| return value * value; |
| } |
| |
| float pow5(float value) { |
| float sq = value * value; |
| return sq * sq * value; |
| } |
| |
| float getLuminance(float3 color) { |
| return clamp(dot(color, float3(0.2126, 0.7152, 0.0722)), 0., 1.); |
| } |
| |
| float getRand(float2 seed) { |
| return frac(sin(dot(seed.xy, float2(12.9898, 78.233))) * 43758.5453); |
| } |
| |
| float dither(float2 seed, float varianceAmount) { |
| float rand = getRand(seed); |
| float dither = lerp(-varianceAmount / 255.0, varianceAmount / 255.0, rand); |
| return dither; |
| } |
| |
| float4 toRGBD(float3 color) { |
| float maxRGB = max(max(color.x, max(color.y, color.z)), 0.0000001); |
| float D = max(255.0 / maxRGB, 1.); |
| D = clamp(floor(D) / 255.0, 0., 1.); |
| float3 rgb = color * D; |
| rgb = toGammaSpace(rgb); |
| return float4(rgb, D); |
| } |
| |
| float3 fromRGBD(float4 rgbd) { |
| rgbd.xyz = toLinearSpace(rgbd.xyz); |
| return rgbd.xyz / rgbd.w; |
| } |
| |
| float convertRoughnessToAverageSlope(float roughness) { |
| return square(roughness) + 0.0005; |
| } |
| |
| float fresnelGrazingReflectance(float reflectance0) { |
| float reflectance90 = clamp(reflectance0 * 25.0, 0.0, 1.0); |
| return reflectance90; |
| } |
| |
| float2 getAARoughnessFactors(float3 normalVector) { |
| return float2(0., 0.); |
| } |
| |
| float4 applyImageProcessing(float4 result) { |
| result.xyz = toGammaSpace(result.xyz); |
| result.xyz = clamp(result.xyz, float3(0.0, 0.0, 0.0), float3(1.0, 1.0, 1.0)); |
| return result; |
| } |
| |
| struct PreLightingInfo { |
| float3 lightOffset; |
| float lightDistanceSquared; |
| float lightDistance; |
| float attenuation; |
| float3 L; |
| float3 H; |
| float NdotV; |
| float NdotLUnclamped; |
| float NdotL; |
| float VdotH; |
| float roughness; |
| } |
| |
| PreLightingInfo computePointAndSpotPreLightingInfo(float4 lightData, float3 V, float3 N, float3 vPositionW) { |
| PreLightingInfo result; |
| result.lightOffset = lightData.xyz - vPositionW; |
| result.lightDistanceSquared = dot(result.lightOffset, result.lightOffset); |
| result.lightDistance = sqrt(result.lightDistanceSquared); |
| result.L = normalize(result.lightOffset); |
| result.H = normalize(V + result.L); |
| result.VdotH = clamp(dot(V, result.H), 0.0, 1.0); |
| result.NdotLUnclamped = dot(N, result.L); |
| result.NdotL = clamp(result.NdotLUnclamped, 0.0000001, 1.0); |
| return result; |
| } |
| |
| PreLightingInfo computeDirectionalPreLightingInfo(float4 lightData, float3 V, float3 N) { |
| PreLightingInfo result; |
| result.lightDistance = length(-lightData.xyz); |
| result.L = normalize(-lightData.xyz); |
| result.H = normalize(V + result.L); |
| result.VdotH = clamp(dot(V, result.H), 0.0, 1.0); |
| result.NdotLUnclamped = dot(N, result.L); |
| result.NdotL = clamp(result.NdotLUnclamped, 0.0000001, 1.0); |
| return result; |
| } |
| |
| PreLightingInfo computeHemisphericPreLightingInfo(float4 lightData, float3 V, float3 N) { |
| PreLightingInfo result; |
| result.NdotL = dot(N, lightData.xyz) * 0.5 + 0.5; |
| result.NdotL = clamp(result.NdotL, 0.0000001, 1.0); |
| result.NdotLUnclamped = result.NdotL; |
| return result; |
| } |
| |
| float computeDistanceLightFalloff_Standard(float3 lightOffset, float range) { |
| return max(0., 1.0 - length(lightOffset) / range); |
| } |
| |
| float computeDistanceLightFalloff_Physical(float lightDistanceSquared) { |
| return 1.0 / max(lightDistanceSquared, 0.0000001); |
| } |
| |
| float computeDistanceLightFalloff_GLTF(float lightDistanceSquared, float inverseSquaredRange) { |
| float lightDistanceFalloff = 1.0 / max(lightDistanceSquared, 0.0000001); |
| float factor = lightDistanceSquared * inverseSquaredRange; |
| float attenuation = clamp(1.0 - factor * factor, 0.0, 1.0); |
| attenuation *= attenuation; |
| lightDistanceFalloff *= attenuation; |
| return lightDistanceFalloff; |
| } |
| |
| float computeDistanceLightFalloff(float3 lightOffset, float lightDistanceSquared, float range, float inverseSquaredRange) { |
| return computeDistanceLightFalloff_Physical(lightDistanceSquared); |
| } |
| |
| float computeDirectionalLightFalloff_Standard(float3 lightDirection, float3 directionToLightCenterW, float cosHalfAngle, float exponent) { |
| float falloff = 0.0; |
| float cosAngle = max(dot(-lightDirection, directionToLightCenterW), 0.0000001); |
| if (cosAngle >= cosHalfAngle) { |
| falloff = max(0., pow(cosAngle, exponent)); |
| } |
| return falloff; |
| } |
| |
| float computeDirectionalLightFalloff_Physical(float3 lightDirection, float3 directionToLightCenterW, float cosHalfAngle) { |
| float kMinusLog2ConeAngleIntensityRatio = 6.64385618977; |
| float concentrationKappa = kMinusLog2ConeAngleIntensityRatio / (1.0 - cosHalfAngle); |
| float4 lightDirectionSpreadSG = float4(-lightDirection * concentrationKappa, -concentrationKappa); |
| float falloff = exp2(dot(float4(directionToLightCenterW, 1.0), lightDirectionSpreadSG)); |
| return falloff; |
| } |
| |
| float computeDirectionalLightFalloff_GLTF(float3 lightDirection, float3 directionToLightCenterW, float lightAngleScale, float lightAngleOffset) { |
| float cd = dot(-lightDirection, directionToLightCenterW); |
| float falloff = clamp(cd * lightAngleScale + lightAngleOffset, 0.0, 1.0); |
| falloff *= falloff; |
| return falloff; |
| } |
| |
| float computeDirectionalLightFalloff(float3 lightDirection, float3 directionToLightCenterW, float cosHalfAngle, float exponent, float lightAngleScale, float lightAngleOffset) { |
| return computeDirectionalLightFalloff_Physical(lightDirection, directionToLightCenterW, cosHalfAngle); |
| } |
| |
| float3 getEnergyConservationFactor(float3 specularEnvironmentR0, float3 environmentBrdf) { |
| return float3(1.0, 1.0, 1.0) + specularEnvironmentR0 * (1.0 / environmentBrdf.y - 1.0); |
| } |
| |
| float3 getBRDFLookup(float NdotV, float perceptualRoughness, Texture2D<float4> environmentBrdfSamplerTexture, sampler environmentBrdfSamplerSampler) { |
| float2 UV = float2(NdotV, perceptualRoughness); |
| float4 brdfLookup = Sample(environmentBrdfSamplerTexture, environmentBrdfSamplerSampler, UV); |
| return brdfLookup.xyz; |
| } |
| |
| float3 getReflectanceFromBRDFLookup(float3 specularEnvironmentR0, float3 environmentBrdf) { |
| float3 reflectance = lerp(environmentBrdf.xxx, environmentBrdf.yyy, specularEnvironmentR0); |
| return reflectance; |
| } |
| |
| float3 getReflectanceFromAnalyticalBRDFLookup_Jones(float VdotN, float3 reflectance0, float3 reflectance90, float smoothness) { |
| float weight = lerp(0.25, 1.0, smoothness); |
| return reflectance0 + weight * (reflectance90 - reflectance0) * pow5(clamp(1.0 - VdotN, 0.0, 1.0)); |
| } |
| |
| float3 fresnelSchlickGGX(float VdotH, float3 reflectance0, float3 reflectance90) { |
| return reflectance0 + (reflectance90 - reflectance0) * pow5(1.0 - VdotH); |
| } |
| |
| float fresnelSchlickGGX(float VdotH, float reflectance0, float reflectance90) { |
| return reflectance0 + (reflectance90 - reflectance0) * pow5(1.0 - VdotH); |
| } |
| |
| float normalDistributionFunction_TrowbridgeReitzGGX(float NdotH, float alphaG) { |
| float a2 = square(alphaG); |
| float d = NdotH * NdotH * (a2 - 1.0) + 1.0; |
| return a2 / (3.1415926535897932384626433832795 * d * d); |
| } |
| |
| float smithVisibility_GGXCorrelated(float NdotL, float NdotV, float alphaG) { |
| float a2 = alphaG * alphaG; |
| float GGXV = NdotL * sqrt(NdotV * (NdotV - a2 * NdotV) + a2); |
| float GGXL = NdotV * sqrt(NdotL * (NdotL - a2 * NdotL) + a2); |
| return 0.5 / (GGXV + GGXL); |
| } |
| |
| float diffuseBRDF_Burley(float NdotL, float NdotV, float VdotH, float roughness) { |
| float diffuseFresnelNV = pow5(clamp(1.0 - NdotL, 0.0000001, 1.0)); |
| float diffuseFresnelNL = pow5(clamp(1.0 - NdotV, 0.0000001, 1.0)); |
| float diffuseFresnel90 = 0.5 + 2.0 * VdotH * VdotH * roughness; |
| float fresnel = (1.0 + (diffuseFresnel90 - 1.0) * diffuseFresnelNL) * |
| (1.0 + (diffuseFresnel90 - 1.0) * diffuseFresnelNV); |
| return fresnel / 3.1415926535897932384626433832795; |
| } |
| |
| struct LightingInfo { |
| float3 diffuse; |
| } |
| |
| float adjustRoughnessFromLightProperties(float roughness, float lightRadius, float lightDistance) { |
| float lightRoughness = lightRadius / lightDistance; |
| float totalRoughness = clamp(lightRoughness + roughness, 0.0, 1.0); |
| return totalRoughness; |
| } |
| |
| float3 computeHemisphericDiffuseLighting(PreLightingInfo info, float3 lightColor, float3 groundColor) { |
| return lerp(groundColor, lightColor, float3(info.NdotL, info.NdotL, info.NdotL)); |
| } |
| |
| float3 computeDiffuseLighting(PreLightingInfo info, float3 lightColor) { |
| float diffuseTerm = diffuseBRDF_Burley(info.NdotL, info.NdotV, info.VdotH, info.roughness); |
| return diffuseTerm * info.attenuation * info.NdotL * lightColor; |
| } |
| |
| float2 computeProjectionTextureDiffuseLightingUV(float4x4 textureProjectionMatrix, float3 vPositionW) { |
| float4 strq = mul(textureProjectionMatrix, float4(vPositionW, 1.0)); |
| strq /= strq.w; |
| return strq.xy; |
| } |
| |
| float getLodFromAlphaG(float cubeMapDimensionPixels, float microsurfaceAverageSlope) { |
| float microsurfaceAverageSlopeTexels = cubeMapDimensionPixels * microsurfaceAverageSlope; |
| float lod = log2(microsurfaceAverageSlopeTexels); |
| return lod; |
| } |
| |
| float getLinearLodFromRoughness(float cubeMapDimensionPixels, float roughness) { |
| float lod = log2(cubeMapDimensionPixels) * roughness; |
| return lod; |
| } |
| |
| float environmentRadianceOcclusion(float ambientOcclusion, float NdotVUnclamped) { |
| float temp = NdotVUnclamped + ambientOcclusion; |
| return clamp(square(temp) - 1.0 + ambientOcclusion, 0.0, 1.0); |
| } |
| |
| float environmentHorizonOcclusion(float3 view, float3 normal) { |
| float3 reflection = reflect(view, normal); |
| float temp = clamp(1.0 + 1.1 * dot(reflection, normal), 0.0, 1.0); |
| return square(temp); |
| } |
| |
| float3 parallaxCorrectNormal(float3 vertexPos, float3 origVec, float3 cubeSize, float3 cubePos) { |
| float3 invOrigVec = float3(1.0, 1.0, 1.0) / origVec; |
| float3 halfSize = cubeSize * 0.5; |
| float3 intersecAtMaxPlane = (cubePos + halfSize - vertexPos) * invOrigVec; |
| float3 intersecAtMinPlane = (cubePos - halfSize - vertexPos) * invOrigVec; |
| float3 largestIntersec = max(intersecAtMaxPlane, intersecAtMinPlane); |
| float distance = min(min(largestIntersec.x, largestIntersec.y), largestIntersec.z); |
| float3 intersectPositionWS = vertexPos + origVec * distance; |
| return intersectPositionWS - cubePos; |
| } |
| |
| float3 computeFixedEquirectangularCoords(float4 worldPos, float3 worldNormal, float3 direction) { |
| float lon = atan2(direction.z, direction.x); |
| float lat = acos(direction.y); |
| float2 sphereCoords = float2(lon, lat) * 0.15915494 * 2.0; |
| float s = sphereCoords.x * 0.5 + 0.5; |
| float t = sphereCoords.y; |
| return float3(s, t, 0); |
| } |
| |
| float3 computeMirroredFixedEquirectangularCoords(float4 worldPos, float3 worldNormal, float3 direction) { |
| float lon = atan2(direction.z, direction.x); |
| float lat = acos(direction.y); |
| float2 sphereCoords = float2(lon, lat) * 0.15915494 * 2.0; |
| float s = sphereCoords.x * 0.5 + 0.5; |
| float t = sphereCoords.y; |
| return float3(1.0 - s, t, 0); |
| } |
| |
| float3 computeEquirectangularCoords(float4 worldPos, float3 worldNormal, float3 eyePosition, float4x4 reflectionMatrix) { |
| float3 cameraToVertex = normalize(worldPos.xyz - eyePosition); |
| float3 r = normalize(reflect(cameraToVertex, worldNormal)); |
| r = mul(reflectionMatrix, float4(r, 0)).xyz; |
| float lon = atan2(r.z, r.x); |
| float lat = acos(r.y); |
| float2 sphereCoords = float2(lon, lat) * 0.15915494 * 2.0; |
| float s = sphereCoords.x * 0.5 + 0.5; |
| float t = sphereCoords.y; |
| return float3(s, t, 0); |
| } |
| |
| float3 computeSphericalCoords(float4 worldPos, float3 worldNormal, float4x4 view, float4x4 reflectionMatrix) { |
| float3 viewDir = normalize(mul(view, worldPos).xyz); |
| float3 viewNormal = normalize(mul(view, float4(worldNormal, 0.0)).xyz); |
| float3 r = reflect(viewDir, viewNormal); |
| r = mul(reflectionMatrix, float4(r, 0)).xyz; |
| r.z = r.z - 1.0; |
| float m = 2.0 * length(r); |
| return float3(r.x / m + 0.5, 1.0 - r.y / m - 0.5, 0); |
| } |
| |
| float3 computePlanarCoords(float4 worldPos, float3 worldNormal, float3 eyePosition, float4x4 reflectionMatrix) { |
| float3 viewDir = worldPos.xyz - eyePosition; |
| float3 coords = normalize(reflect(viewDir, worldNormal)); |
| return mul(reflectionMatrix, float4(coords, 1)).xyz; |
| } |
| |
| float3 computeCubicCoords(float4 worldPos, float3 worldNormal, float3 eyePosition, float4x4 reflectionMatrix) { |
| float3 viewDir = normalize(worldPos.xyz - eyePosition); |
| float3 coords = reflect(viewDir, worldNormal); |
| coords = mul(reflectionMatrix, float4(coords, 0)).xyz; |
| return coords; |
| } |
| |
| float3 computeCubicLocalCoords(float4 worldPos, float3 worldNormal, float3 eyePosition, float4x4 reflectionMatrix, float3 reflectionSize, float3 reflectionPosition) { |
| float3 viewDir = normalize(worldPos.xyz - eyePosition); |
| float3 coords = reflect(viewDir, worldNormal); |
| coords = parallaxCorrectNormal(worldPos.xyz, coords, reflectionSize, reflectionPosition); |
| coords = mul(reflectionMatrix, float4(coords, 0)).xyz; |
| return coords; |
| } |
| |
| float3 computeProjectionCoords(float4 worldPos, float4x4 view, float4x4 reflectionMatrix) { |
| return mul(reflectionMatrix, mul(view, worldPos)).xyz; |
| } |
| |
| float3 computeSkyBoxCoords(float3 positionW, float4x4 reflectionMatrix) { |
| return mul(reflectionMatrix, float4(positionW, 0)).xyz; |
| } |
| |
| float3 computeReflectionCoords(float4 worldPos, float3 worldNormal, float3 vPositionUVW, float4x4 reflectionMatrix) { |
| float r = length(vPositionUVW); |
| float gamma = atan2(vPositionUVW.x, vPositionUVW.z); |
| float theta = acos(vPositionUVW.y / r); |
| return float3(gamma / 3.1415926535897932384626433832795 + 0.5, theta / 3.1415926535897932384626433832795, r); |
| } |
| |
| fragment float4 main(float3 vPositionW : attribute(0), float3 vNormalW : attribute(1), float3 vPositionUVW : attribute(2), |
| constant Scene[] scene : register(b0, space0), |
| Texture2D<float4> environmentBrdfSamplerTexture : register(t1, space0), |
| sampler environmentBrdfSamplerSampler : register(s2, space0), |
| constant Material[] material : register(b0, space1), |
| constant Mesh[] mesh : register(b1, space1), |
| Texture2D<float4> reflectionSamplerTexture : register(t0, space2), |
| sampler reflectionSamplerSampler : register(s1, space2), |
| bool frontFace : SV_IsFrontFace) : SV_Target 0 { |
| float3 viewDirectionW = normalize(material[0].vEyePosition.xyz - vPositionW); |
| float3 normalW = normalize(vNormalW); |
| float2 uvOffset = float2(0.0, 0.0); |
| normalW = frontFace ? normalW : -normalW; |
| float3 surfaceAlbedo = material[0].vAlbedoColor.xyz; |
| float alpha = material[0].vAlbedoColor.w; |
| float3 ambientOcclusionColor = float3(1., 1., 1.); |
| float microSurface = material[0].vReflectivityColor.w; |
| float3 surfaceReflectivityColor = material[0].vReflectivityColor.xyz; |
| microSurface = clamp(microSurface, 0.0, 1.0); |
| float roughness = 1. - microSurface; |
| float NdotVUnclamped = dot(normalW, viewDirectionW); |
| float NdotV = abs(NdotVUnclamped) + 0.0000001; |
| float alphaG = convertRoughnessToAverageSlope(roughness); |
| float2 AARoughnessFactors = getAARoughnessFactors(normalW); |
| float4 environmentRadiance = float4(0., 0., 0., 0.); |
| float3 environmentIrradiance = float3(0., 0., 0.); |
| float3 reflectionVector = computeReflectionCoords(float4(vPositionW, 1.0), normalW, vPositionUVW, material[0].reflectionMatrix); |
| float3 reflectionCoords = reflectionVector; |
| float reflectionLOD = getLodFromAlphaG(material[0].vReflectionMicrosurfaceInfos.x, alphaG); |
| reflectionLOD = reflectionLOD * material[0].vReflectionMicrosurfaceInfos.y + material[0].vReflectionMicrosurfaceInfos.z; |
| float requestedReflectionLOD = reflectionLOD; |
| environmentRadiance = Sample(reflectionSamplerTexture, reflectionSamplerSampler, reflectionCoords.xy); //SampleLevel(reflectionSamplerTexture, reflectionSamplerSampler, reflectionCoords, requestedReflectionLOD); |
| environmentRadiance.xyz = fromRGBD(environmentRadiance); |
| environmentRadiance.xyz *= material[0].vReflectionInfos.x; |
| environmentRadiance.xyz *= material[0].vReflectionColor.xyz; |
| environmentIrradiance *= material[0].vReflectionColor.xyz; |
| float reflectance = max(max(surfaceReflectivityColor.x, surfaceReflectivityColor.y), surfaceReflectivityColor.z); |
| float reflectance90 = fresnelGrazingReflectance(reflectance); |
| float3 specularEnvironmentR0 = surfaceReflectivityColor.xyz; |
| float3 specularEnvironmentR90 = float3(1.0, 1.0, 1.0) * reflectance90; |
| float3 environmentBrdf = getBRDFLookup(NdotV, roughness, environmentBrdfSamplerTexture, environmentBrdfSamplerSampler); |
| float3 energyConservationFactor = getEnergyConservationFactor(specularEnvironmentR0, environmentBrdf); |
| float3 diffuseBase = float3(0., 0., 0.); |
| PreLightingInfo preInfo; |
| LightingInfo info; |
| float shadow = 1.; |
| float3 specularEnvironmentReflectance = getReflectanceFromAnalyticalBRDFLookup_Jones(NdotV, specularEnvironmentR0, specularEnvironmentR90, sqrt(microSurface)); |
| surfaceAlbedo.xyz = (1. - reflectance) * surfaceAlbedo.xyz; |
| float3 finalIrradiance = environmentIrradiance; |
| finalIrradiance *= surfaceAlbedo.xyz; |
| float3 finalRadiance = environmentRadiance.xyz; |
| finalRadiance *= specularEnvironmentReflectance; |
| float3 finalRadianceScaled = finalRadiance * material[0].vLightingIntensity.z; |
| finalRadianceScaled *= energyConservationFactor; |
| float3 finalDiffuse = diffuseBase; |
| finalDiffuse *= surfaceAlbedo.xyz; |
| finalDiffuse = max(finalDiffuse, float3(0.0, 0.0, 0.0)); |
| float3 finalAmbient = material[0].vAmbientColor; |
| finalAmbient *= surfaceAlbedo.xyz; |
| float3 finalEmissive = material[0].vEmissiveColor; |
| float3 ambientOcclusionForDirectDiffuse = ambientOcclusionColor; |
| float4 finalColor = float4( |
| finalAmbient * ambientOcclusionColor + |
| finalDiffuse * ambientOcclusionForDirectDiffuse * material[0].vLightingIntensity.x + |
| finalIrradiance * ambientOcclusionColor * material[0].vLightingIntensity.z + |
| finalRadianceScaled + |
| finalEmissive * material[0].vLightingIntensity.y, |
| alpha); |
| finalColor = max(finalColor, float4(0.0, 0.0, 0.0, 0.0)); |
| finalColor = applyImageProcessing(finalColor); |
| finalColor.w *= mesh[0].visibility; |
| return finalColor; |
| } |
| `; |
