#version 300 es #define COLOR_ATTACHMENT_0 #define COLOR_ATTACHMENT_1 #define COLOR_ATTACHMENT_2 #define COLOR_ATTACHMENT_3 layout(location = 0) out highp vec4 pc_fragColor; #define gl_FragColor pc_fragColor #define pcFragColor0 pc_fragColor #define pcFragColor1 pc_fragColor1 #define pcFragColor2 pc_fragColor2 #define pcFragColor3 pc_fragColor3 #define pcFragColor4 pc_fragColor4 #define pcFragColor5 pc_fragColor5 #define pcFragColor6 pc_fragColor6 #define pcFragColor7 pc_fragColor7 #define varying in #define texture2D texture #define texture2DBias texture #define textureCube texture #define texture2DProj textureProj #define texture2DLodEXT textureLod #define texture2DProjLodEXT textureProjLod #define textureCubeLodEXT textureLod #define texture2DGradEXT textureGrad #define texture2DProjGradEXT textureProjGrad #define textureCubeGradEXT textureGrad #define textureShadow(res, uv) textureGrad(res, uv, vec2(1, 1), vec2(1, 1)) #define SHADOWMAP_PASS(name) name #define SHADOWMAP_ACCEPT(name) sampler2DShadow name #define TEXTURE_PASS(name) name #define TEXTURE_ACCEPT(name) sampler2D name #define GL2 #define SUPPORTS_TEXLOD #define SUPPORTS_MRT precision highp float; precision highp sampler2DShadow; vec2 getGrabScreenPos(vec4 clipPos) { vec2 uv = (clipPos.xy / clipPos.w) * 0.5 + 0.5; return uv; } vec2 getImageEffectUV(vec2 uv) { return uv; } #define SHADER_NAME LitShader #define FORWARD_PASS #define FORWARD_PASS #define LIT_SPECULAR #define LIT_REFLECTIONS #define LIT_SPECULAR_FRESNEL #define LIT_CONSERVE_ENERGY varying vec3 vPositionW; varying vec3 vNormalW; varying vec2 vUv0; #define VARYING_VPOSITIONW #define VARYING_VNORMALW #define VARYING_VUV0 uniform vec3 view_position; uniform vec3 light_globalAmbient; float square(float x) { return x*x; } float saturate(float x) { return clamp(x, 0.0, 1.0); } vec3 saturate(vec3 x) { return clamp(x, vec3(0.0), vec3(1.0)); } mat3 dTBN; vec3 dVertexNormalW; vec3 dViewDirW; vec3 dReflDirW; vec3 ccReflDirW; vec3 dLightDirNormW; vec3 dLightDirW; vec3 dLightPosW; vec3 dShadowCoord; vec4 dReflection; vec3 dDiffuseLight; vec3 dSpecularLight; float dAtten; float dAttenD; vec3 dAtten3; float ccFresnel; vec3 ccReflection; vec3 ccSpecularLight; vec3 sSpecularLight; vec3 sReflection; uniform float textureBias; float dAlpha; vec3 dNormalW; vec3 dAlbedo; float dTransmission; float dThickness; vec3 dSpecularity; float dGlossiness; float dMetalness; float dIor; vec3 dEmission; vec3 litArgs_albedo; float litArgs_opacity; vec3 litArgs_emission; vec3 litArgs_worldNormal; float litArgs_ao; vec3 litArgs_lightmap; vec3 litArgs_lightmapDir; float litArgs_metalness; vec3 litArgs_specularity; float litArgs_specularityFactor; float litArgs_gloss; float litArgs_sheen_gloss; vec3 litArgs_sheen_specularity; float litArgs_transmission; float litArgs_thickness; float litArgs_ior; float litArgs_iridescence_intensity; float litArgs_iridescence_thickness; vec3 litArgs_clearcoat_worldNormal; float litArgs_clearcoat_specularity; float litArgs_clearcoat_gloss; uniform sampler2D texture_diffuseMap; #define AREA_R8_G8_B8_A8_LUTS #define AREA_LIGHTS uniform lowp sampler2D areaLightsLutTex1; uniform lowp sampler2D areaLightsLutTex2; #define CLUSTER_MESH_DYNAMIC_LIGHTS #define CLUSTER_SHADOWS #define CLUSTER_SHADOW_TYPE_PCF3 #define CLUSTER_TEXTURE_FLOAT #define CLUSTER_TEXTURE_8_FLAGS 0 #define CLUSTER_TEXTURE_8_COLOR_A 1 #define CLUSTER_TEXTURE_8_COLOR_B 2 #define CLUSTER_TEXTURE_8_SPOT_ANGLES 3 #define CLUSTER_TEXTURE_8_SHADOW_BIAS 4 #define CLUSTER_TEXTURE_8_COOKIE_A 5 #define CLUSTER_TEXTURE_8_COOKIE_B 6 #define CLUSTER_TEXTURE_8_COUNT_ALWAYS 7 #define CLUSTER_TEXTURE_8_POSITION_X 7 #define CLUSTER_TEXTURE_8_POSITION_Y 8 #define CLUSTER_TEXTURE_8_POSITION_Z 9 #define CLUSTER_TEXTURE_8_RANGE 10 #define CLUSTER_TEXTURE_8_SPOT_DIRECTION_X 11 #define CLUSTER_TEXTURE_8_SPOT_DIRECTION_Y 12 #define CLUSTER_TEXTURE_8_SPOT_DIRECTION_Z 13 #define CLUSTER_TEXTURE_8_PROJ_MAT_00 14 #define CLUSTER_TEXTURE_8_ATLAS_VIEWPORT_A 14 #define CLUSTER_TEXTURE_8_PROJ_MAT_01 15 #define CLUSTER_TEXTURE_8_ATLAS_VIEWPORT_B 15 #define CLUSTER_TEXTURE_8_PROJ_MAT_02 16 #define CLUSTER_TEXTURE_8_PROJ_MAT_03 17 #define CLUSTER_TEXTURE_8_PROJ_MAT_10 18 #define CLUSTER_TEXTURE_8_PROJ_MAT_11 19 #define CLUSTER_TEXTURE_8_PROJ_MAT_12 20 #define CLUSTER_TEXTURE_8_PROJ_MAT_13 21 #define CLUSTER_TEXTURE_8_PROJ_MAT_20 22 #define CLUSTER_TEXTURE_8_PROJ_MAT_21 23 #define CLUSTER_TEXTURE_8_PROJ_MAT_22 24 #define CLUSTER_TEXTURE_8_PROJ_MAT_23 25 #define CLUSTER_TEXTURE_8_PROJ_MAT_30 26 #define CLUSTER_TEXTURE_8_PROJ_MAT_31 27 #define CLUSTER_TEXTURE_8_PROJ_MAT_32 28 #define CLUSTER_TEXTURE_8_PROJ_MAT_33 29 #define CLUSTER_TEXTURE_8_AREA_DATA_WIDTH_X 30 #define CLUSTER_TEXTURE_8_AREA_DATA_WIDTH_Y 31 #define CLUSTER_TEXTURE_8_AREA_DATA_WIDTH_Z 32 #define CLUSTER_TEXTURE_8_AREA_DATA_HEIGHT_X 33 #define CLUSTER_TEXTURE_8_AREA_DATA_HEIGHT_Y 34 #define CLUSTER_TEXTURE_8_AREA_DATA_HEIGHT_Z 35 #define CLUSTER_TEXTURE_8_COUNT 36 #define CLUSTER_TEXTURE_F_POSITION_RANGE 0 #define CLUSTER_TEXTURE_F_SPOT_DIRECTION 1 #define CLUSTER_TEXTURE_F_PROJ_MAT_0 2 #define CLUSTER_TEXTURE_F_ATLAS_VIEWPORT 2 #define CLUSTER_TEXTURE_F_PROJ_MAT_1 3 #define CLUSTER_TEXTURE_F_PROJ_MAT_2 4 #define CLUSTER_TEXTURE_F_PROJ_MAT_3 5 #define CLUSTER_TEXTURE_F_AREA_DATA_WIDTH 6 #define CLUSTER_TEXTURE_F_AREA_DATA_HEIGHT 7 #define CLUSTER_TEXTURE_F_COUNT 8 float getSpotEffect(vec3 lightSpotDir, float lightInnerConeAngle, float lightOuterConeAngle, vec3 lightDirNorm) { float cosAngle = dot(lightDirNorm, lightSpotDir); return smoothstep(lightOuterConeAngle, lightInnerConeAngle, cosAngle); } float getFalloffWindow(float lightRadius, vec3 lightDir) { float sqrDist = dot(lightDir, lightDir); float invRadius = 1.0 / lightRadius; return square( saturate( 1.0 - square( sqrDist * square(invRadius) ) ) ); } float getFalloffInvSquared(float lightRadius, vec3 lightDir) { float sqrDist = dot(lightDir, lightDir); float falloff = 1.0 / (sqrDist + 1.0); float invRadius = 1.0 / lightRadius; falloff *= 16.0; falloff *= square( saturate( 1.0 - square( sqrDist * square(invRadius) ) ) ); return falloff; } float getFalloffLinear(float lightRadius, vec3 lightDir) { float d = length(lightDir); return max(((lightRadius - d) / lightRadius), 0.0); } void getLightDirPoint(vec3 lightPosW) { dLightDirW = vPositionW - lightPosW; dLightDirNormW = normalize(dLightDirW); dLightPosW = lightPosW; } const float PI = 3.141592653589793; vec2 toSpherical(vec3 dir) { return vec2(dir.xz == vec2(0.0) ? 0.0 : atan(dir.x, dir.z), asin(dir.y)); } vec2 toSphericalUv(vec3 dir) { vec2 uv = toSpherical(dir) / vec2(PI * 2.0, PI) + 0.5; return vec2(uv.x, 1.0 - uv.y); } vec3 decodeLinear(vec4 raw) { return raw.rgb; } float decodeGamma(float raw) { return pow(raw, 2.2); } vec3 decodeGamma(vec3 raw) { return pow(raw, vec3(2.2)); } vec3 decodeGamma(vec4 raw) { return pow(raw.xyz, vec3(2.2)); } vec3 decodeRGBM(vec4 raw) { vec3 color = (8.0 * raw.a) * raw.rgb; return color * color; } vec3 decodeRGBP(vec4 raw) { vec3 color = raw.rgb * (-raw.a * 7.0 + 8.0); return color * color; } vec3 decodeRGBE(vec4 raw) { if (raw.a == 0.0) { return vec3(0.0, 0.0, 0.0); } else { return raw.xyz * pow(2.0, raw.w * 255.0 - 128.0); } } vec4 passThrough(vec4 raw) { return raw; } float gammaCorrectInput(float color) { return decodeGamma(color); } vec3 gammaCorrectInput(vec3 color) { return decodeGamma(color); } vec4 gammaCorrectInput(vec4 color) { return vec4(decodeGamma(color.xyz), color.w); } vec3 gammaCorrectOutput(vec3 color) { return pow(color + 0.0000001, vec3(1.0 / 2.2)); } uniform float exposure; vec3 toneMap(vec3 color) { return color * exposure; } float dBlendModeFogFactor = 1.0; vec3 addFog(vec3 color) { return color; } #define MAPFLOAT #undef MAPCOLOR #undef MAPVERTEX #undef MAPTEXTURE #undef MAPINVERT uniform float material_opacity; void getOpacity() { dAlpha = 1.0; dAlpha *= material_opacity; } #undef MAPFLOAT #undef MAPCOLOR #undef MAPVERTEX #undef MAPTEXTURE #undef MAPINVERT vec3 addNormalDetail(vec3 normalMap) { return normalMap; } #undef MAPFLOAT #undef MAPCOLOR #undef MAPVERTEX #undef MAPTEXTURE #undef MAPINVERT void getNormal() { dNormalW = dVertexNormalW; } vec3 detailMode_mul(vec3 c1, vec3 c2) { return c1 * c2; } vec3 detailMode_add(vec3 c1, vec3 c2) { return c1 + c2; } vec3 detailMode_screen(vec3 c1, vec3 c2) { return 1.0 - (1.0 - c1)*(1.0 - c2); } vec3 detailMode_overlay(vec3 c1, vec3 c2) { return mix(1.0 - 2.0*(1.0 - c1)*(1.0 - c2), 2.0*c1*c2, step(c1, vec3(0.5))); } vec3 detailMode_min(vec3 c1, vec3 c2) { return min(c1, c2); } vec3 detailMode_max(vec3 c1, vec3 c2) { return max(c1, c2); } #undef MAPFLOAT #undef MAPCOLOR #undef MAPVERTEX #undef MAPTEXTURE #undef MAPINVERT vec3 addAlbedoDetail(vec3 albedo) { return albedo; } #undef MAPFLOAT #undef MAPCOLOR #undef MAPVERTEX #define MAPTEXTURE #undef MAPINVERT void getAlbedo() { dAlbedo = vec3(1.0); vec3 albedoBase = decodeGamma(texture2DBias(texture_diffuseMap, vUv0, textureBias)).rgb; dAlbedo *= addAlbedoDetail(albedoBase); } #define MAPFLOAT #undef MAPCOLOR #undef MAPVERTEX #undef MAPTEXTURE #undef MAPINVERT uniform float material_refraction; void getRefraction() { float refraction = 1.0; refraction = material_refraction; dTransmission = refraction; } #undef MAPFLOAT #undef MAPCOLOR #undef MAPVERTEX #undef MAPTEXTURE #undef MAPINVERT void getThickness() { dThickness = 1.0; } #define MAPFLOAT #undef MAPCOLOR #undef MAPVERTEX #undef MAPTEXTURE #undef MAPINVERT uniform float material_metalness; void getMetalness() { float metalness = 1.0; metalness *= material_metalness; dMetalness = metalness; } #define MAPFLOAT #undef MAPCOLOR #undef MAPVERTEX #undef MAPTEXTURE #undef MAPINVERT uniform float material_refractionIndex; void getIor() { dIor = material_refractionIndex; } void getSpecularity() { dSpecularity = vec3(1); } #define MAPFLOAT #undef MAPCOLOR #undef MAPVERTEX #undef MAPTEXTURE #undef MAPINVERT uniform float material_gloss; void getGlossiness() { dGlossiness = 1.0; dGlossiness *= material_gloss; dGlossiness += 0.0000001; } #undef MAPFLOAT #define MAPCOLOR #undef MAPVERTEX #undef MAPTEXTURE #undef MAPINVERT uniform vec3 material_emissive; void getEmission() { dEmission = vec3(1.0); dEmission *= material_emissive; } void evaluateFrontend() { getOpacity(); getNormal(); getAlbedo(); getRefraction(); getThickness(); getMetalness(); getIor(); getGlossiness(); getSpecularity(); getEmission(); litArgs_opacity = dAlpha; litArgs_worldNormal = dNormalW; litArgs_albedo = dAlbedo; litArgs_transmission = dTransmission; litArgs_thickness = dThickness; litArgs_metalness = dMetalness; litArgs_ior = dIor; litArgs_specularity = dSpecularity; litArgs_gloss = dGlossiness; litArgs_emission = dEmission; } vec3 cubeMapRotate(vec3 refDir) { return refDir; } vec3 cubeMapProject(vec3 dir) { return cubeMapRotate(dir); } vec3 processEnvironment(vec3 color) { return color; } vec3 getSpecularModulate(in vec3 specularity, in vec3 albedo, in float metalness, in float f0) { vec3 dielectricF0 = f0 * specularity; return mix(dielectricF0, albedo, metalness); } vec3 getAlbedoModulate(in vec3 albedo, in float metalness) { return albedo * (1.0 - metalness); } vec3 getFresnel( float cosTheta, float gloss, vec3 specularity ) { float fresnel = pow(1.0 - max(cosTheta, 0.0), 5.0); float glossSq = gloss * gloss; vec3 ret = specularity + (max(vec3(glossSq), specularity) - specularity) * fresnel; return ret; } float getFresnelCC(float cosTheta) { float fresnel = pow(1.0 - max(cosTheta, 0.0), 5.0); return 0.04 + (1.0 - 0.04) * fresnel; } const float atlasSize = 512.0; const float seamSize = 1.0 / atlasSize; vec2 mapUv(vec2 uv, vec4 rect) { return vec2(mix(rect.x + seamSize, rect.x + rect.z - seamSize, uv.x), mix(rect.y + seamSize, rect.y + rect.w - seamSize, uv.y)); } vec2 mapRoughnessUv(vec2 uv, float level) { float t = 1.0 / exp2(level); return mapUv(uv, vec4(0, 1.0 - t, t, t * 0.5)); } vec2 mapShinyUv(vec2 uv, float level) { float t = 1.0 / exp2(level); return mapUv(uv, vec4(1.0 - t, 1.0 - t, t, t * 0.5)); } #define ENV_ATLAS uniform sampler2D texture_envAtlas; uniform float material_reflectivity; float shinyMipLevel(vec2 uv) { vec2 dx = dFdx(uv); vec2 dy = dFdy(uv); vec2 uv2 = vec2(fract(uv.x + 0.5), uv.y); vec2 dx2 = dFdx(uv2); vec2 dy2 = dFdy(uv2); float maxd = min(max(dot(dx, dx), dot(dy, dy)), max(dot(dx2, dx2), dot(dy2, dy2))); return clamp(0.5 * log2(maxd) - 1.0 + textureBias, 0.0, 5.0); } vec3 calcReflection(vec3 reflDir, float gloss) { vec3 dir = cubeMapProject(reflDir) * vec3(-1.0, 1.0, 1.0); vec2 uv = toSphericalUv(dir); float level = saturate(1.0 - gloss) * 5.0; float ilevel = floor(level); float level2 = shinyMipLevel(uv * atlasSize); float ilevel2 = floor(level2); vec2 uv0, uv1; float weight; if (ilevel == 0.0) { uv0 = mapShinyUv(uv, ilevel2); uv1 = mapShinyUv(uv, ilevel2 + 1.0); weight = level2 - ilevel2; } else { uv0 = uv1 = mapRoughnessUv(uv, ilevel); weight = 0.0; } vec3 linearA = decodeLinear(texture2D(texture_envAtlas, uv0)); vec3 linearB = decodeLinear(texture2D(texture_envAtlas, uv1)); vec3 linear0 = mix(linearA, linearB, weight); vec3 linear1 = decodeLinear(texture2D(texture_envAtlas, mapRoughnessUv(uv, ilevel + 1.0))); return processEnvironment(mix(linear0, linear1, level - ilevel)); } void addReflection(vec3 reflDir, float gloss) { dReflection += vec4(calcReflection(reflDir, gloss), material_reflectivity); } vec3 refract2(vec3 viewVec, vec3 normal, float IOR) { float vn = dot(viewVec, normal); float k = 1.0 - IOR * IOR * (1.0 - vn * vn); vec3 refrVec = IOR * viewVec - (IOR * vn + sqrt(k)) * normal; return refrVec; } void addRefraction( vec3 worldNormal, vec3 viewDir, float thickness, float gloss, vec3 specularity, vec3 albedo, float transmission, float refractionIndex ) { vec4 tmpRefl = dReflection; vec3 reflectionDir = refract2(-viewDir, worldNormal, refractionIndex); dReflection = vec4(0); addReflection(reflectionDir, gloss); dDiffuseLight = mix(dDiffuseLight, dReflection.rgb * albedo, transmission); dReflection = tmpRefl; } vec2 getCubemapFaceCoordinates(const vec3 dir, out float faceIndex, out vec2 tileOffset) { vec3 vAbs = abs(dir); float ma; vec2 uv; if (vAbs.z >= vAbs.x && vAbs.z >= vAbs.y) { faceIndex = dir.z < 0.0 ? 5.0 : 4.0; ma = 0.5 / vAbs.z; uv = vec2(dir.z < 0.0 ? -dir.x : dir.x, -dir.y); tileOffset.x = 2.0; tileOffset.y = dir.z < 0.0 ? 1.0 : 0.0; } else if(vAbs.y >= vAbs.x) { faceIndex = dir.y < 0.0 ? 3.0 : 2.0; ma = 0.5 / vAbs.y; uv = vec2(dir.x, dir.y < 0.0 ? -dir.z : dir.z); tileOffset.x = 1.0; tileOffset.y = dir.y < 0.0 ? 1.0 : 0.0; } else { faceIndex = dir.x < 0.0 ? 1.0 : 0.0; ma = 0.5 / vAbs.x; uv = vec2(dir.x < 0.0 ? dir.z : -dir.z, -dir.y); tileOffset.x = 0.0; tileOffset.y = dir.x < 0.0 ? 1.0 : 0.0; } return uv * ma + 0.5; } vec2 getCubemapAtlasCoordinates(const vec3 omniAtlasViewport, float shadowEdgePixels, float shadowTextureResolution, const vec3 dir) { float faceIndex; vec2 tileOffset; vec2 uv = getCubemapFaceCoordinates(dir, faceIndex, tileOffset); float atlasFaceSize = omniAtlasViewport.z; float tileSize = shadowTextureResolution * atlasFaceSize; float offset = shadowEdgePixels / tileSize; uv = uv * vec2(1.0 - offset * 2.0) + vec2(offset * 1.0); uv *= atlasFaceSize; uv += tileOffset * atlasFaceSize; uv += omniAtlasViewport.xy; return uv; } vec3 lessThan2(vec3 a, vec3 b) { return clamp((b - a)*1000.0, 0.0, 1.0); } #define UNPACKFLOAT float unpackFloat(vec4 rgbaDepth) { const vec4 bitShift = vec4(1.0 / (256.0 * 256.0 * 256.0), 1.0 / (256.0 * 256.0), 1.0 / 256.0, 1.0); return dot(rgbaDepth, bitShift); } float _getShadowPCF3x3(SHADOWMAP_ACCEPT(shadowMap), vec3 shadowCoord, vec3 shadowParams) { float z = shadowCoord.z; vec2 uv = shadowCoord.xy * shadowParams.x; float shadowMapSizeInv = 1.0 / shadowParams.x; vec2 base_uv = floor(uv + 0.5); float s = (uv.x + 0.5 - base_uv.x); float t = (uv.y + 0.5 - base_uv.y); base_uv -= vec2(0.5); base_uv *= shadowMapSizeInv; float sum = 0.0; float uw0 = (3.0 - 2.0 * s); float uw1 = (1.0 + 2.0 * s); float u0 = (2.0 - s) / uw0 - 1.0; float u1 = s / uw1 + 1.0; float vw0 = (3.0 - 2.0 * t); float vw1 = (1.0 + 2.0 * t); float v0 = (2.0 - t) / vw0 - 1.0; float v1 = t / vw1 + 1.0; u0 = u0 * shadowMapSizeInv + base_uv.x; v0 = v0 * shadowMapSizeInv + base_uv.y; u1 = u1 * shadowMapSizeInv + base_uv.x; v1 = v1 * shadowMapSizeInv + base_uv.y; sum += uw0 * vw0 * textureShadow(shadowMap, vec3(u0, v0, z)); sum += uw1 * vw0 * textureShadow(shadowMap, vec3(u1, v0, z)); sum += uw0 * vw1 * textureShadow(shadowMap, vec3(u0, v1, z)); sum += uw1 * vw1 * textureShadow(shadowMap, vec3(u1, v1, z)); sum *= 1.0f / 16.0; return sum; } float getShadowPCF3x3(SHADOWMAP_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams) { return _getShadowPCF3x3(SHADOWMAP_PASS(shadowMap), shadowCoord, shadowParams.xyz); } float getShadowSpotPCF3x3(SHADOWMAP_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams) { return _getShadowPCF3x3(SHADOWMAP_PASS(shadowMap), shadowCoord, shadowParams.xyz); } float getShadowPCF1x1(SHADOWMAP_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams) { return textureShadow(shadowMap, shadowCoord); } float getShadowSpotPCF1x1(SHADOWMAP_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams) { return textureShadow(shadowMap, shadowCoord); } float _getShadowPoint(samplerCube shadowMap, vec4 shadowParams, vec3 dir) { vec3 tc = normalize(dir); vec3 tcAbs = abs(tc); vec4 dirX = vec4(1,0,0, tc.x); vec4 dirY = vec4(0,1,0, tc.y); float majorAxisLength = tc.z; if ((tcAbs.x > tcAbs.y) && (tcAbs.x > tcAbs.z)) { dirX = vec4(0,0,1, tc.z); dirY = vec4(0,1,0, tc.y); majorAxisLength = tc.x; } else if ((tcAbs.y > tcAbs.x) && (tcAbs.y > tcAbs.z)) { dirX = vec4(1,0,0, tc.x); dirY = vec4(0,0,1, tc.z); majorAxisLength = tc.y; } float shadowParamsInFaceSpace = ((1.0/shadowParams.x) * 2.0) * abs(majorAxisLength); vec3 xoffset = (dirX.xyz * shadowParamsInFaceSpace); vec3 yoffset = (dirY.xyz * shadowParamsInFaceSpace); vec3 dx0 = -xoffset; vec3 dy0 = -yoffset; vec3 dx1 = xoffset; vec3 dy1 = yoffset; mat3 shadowKernel; mat3 depthKernel; depthKernel[0][0] = unpackFloat(textureCube(shadowMap, tc + dx0 + dy0)); depthKernel[0][1] = unpackFloat(textureCube(shadowMap, tc + dx0)); depthKernel[0][2] = unpackFloat(textureCube(shadowMap, tc + dx0 + dy1)); depthKernel[1][0] = unpackFloat(textureCube(shadowMap, tc + dy0)); depthKernel[1][1] = unpackFloat(textureCube(shadowMap, tc)); depthKernel[1][2] = unpackFloat(textureCube(shadowMap, tc + dy1)); depthKernel[2][0] = unpackFloat(textureCube(shadowMap, tc + dx1 + dy0)); depthKernel[2][1] = unpackFloat(textureCube(shadowMap, tc + dx1)); depthKernel[2][2] = unpackFloat(textureCube(shadowMap, tc + dx1 + dy1)); vec3 shadowZ = vec3(length(dir) * shadowParams.w + shadowParams.z); shadowKernel[0] = vec3(lessThan2(depthKernel[0], shadowZ)); shadowKernel[1] = vec3(lessThan2(depthKernel[1], shadowZ)); shadowKernel[2] = vec3(lessThan2(depthKernel[2], shadowZ)); vec2 uv = (vec2(dirX.w, dirY.w) / abs(majorAxisLength)) * 0.5; vec2 fractionalCoord = fract( uv * shadowParams.x ); shadowKernel[0] = mix(shadowKernel[0], shadowKernel[1], fractionalCoord.x); shadowKernel[1] = mix(shadowKernel[1], shadowKernel[2], fractionalCoord.x); vec4 shadowValues; shadowValues.x = mix(shadowKernel[0][0], shadowKernel[0][1], fractionalCoord.y); shadowValues.y = mix(shadowKernel[0][1], shadowKernel[0][2], fractionalCoord.y); shadowValues.z = mix(shadowKernel[1][0], shadowKernel[1][1], fractionalCoord.y); shadowValues.w = mix(shadowKernel[1][1], shadowKernel[1][2], fractionalCoord.y); return 1.0 - dot( shadowValues, vec4( 1.0 ) ) * 0.25; } float getShadowPointPCF3x3(samplerCube shadowMap, vec3 shadowCoord, vec4 shadowParams, vec3 lightDir) { return _getShadowPoint(shadowMap, shadowParams, lightDir); } float _getShadowPCF5x5(SHADOWMAP_ACCEPT(shadowMap), vec3 shadowCoord, vec3 shadowParams) { float z = shadowCoord.z; vec2 uv = shadowCoord.xy * shadowParams.x; float shadowMapSizeInv = 1.0 / shadowParams.x; vec2 base_uv = floor(uv + 0.5); float s = (uv.x + 0.5 - base_uv.x); float t = (uv.y + 0.5 - base_uv.y); base_uv -= vec2(0.5); base_uv *= shadowMapSizeInv; float uw0 = (4.0 - 3.0 * s); float uw1 = 7.0; float uw2 = (1.0 + 3.0 * s); float u0 = (3.0 - 2.0 * s) / uw0 - 2.0; float u1 = (3.0 + s) / uw1; float u2 = s / uw2 + 2.0; float vw0 = (4.0 - 3.0 * t); float vw1 = 7.0; float vw2 = (1.0 + 3.0 * t); float v0 = (3.0 - 2.0 * t) / vw0 - 2.0; float v1 = (3.0 + t) / vw1; float v2 = t / vw2 + 2.0; float sum = 0.0; u0 = u0 * shadowMapSizeInv + base_uv.x; v0 = v0 * shadowMapSizeInv + base_uv.y; u1 = u1 * shadowMapSizeInv + base_uv.x; v1 = v1 * shadowMapSizeInv + base_uv.y; u2 = u2 * shadowMapSizeInv + base_uv.x; v2 = v2 * shadowMapSizeInv + base_uv.y; sum += uw0 * vw0 * textureShadow(shadowMap, vec3(u0, v0, z)); sum += uw1 * vw0 * textureShadow(shadowMap, vec3(u1, v0, z)); sum += uw2 * vw0 * textureShadow(shadowMap, vec3(u2, v0, z)); sum += uw0 * vw1 * textureShadow(shadowMap, vec3(u0, v1, z)); sum += uw1 * vw1 * textureShadow(shadowMap, vec3(u1, v1, z)); sum += uw2 * vw1 * textureShadow(shadowMap, vec3(u2, v1, z)); sum += uw0 * vw2 * textureShadow(shadowMap, vec3(u0, v2, z)); sum += uw1 * vw2 * textureShadow(shadowMap, vec3(u1, v2, z)); sum += uw2 * vw2 * textureShadow(shadowMap, vec3(u2, v2, z)); sum *= 1.0f / 144.0; sum = saturate(sum); return sum; } float getShadowPCF5x5(SHADOWMAP_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams) { return _getShadowPCF5x5(SHADOWMAP_PASS(shadowMap), shadowCoord, shadowParams.xyz); } float getShadowSpotPCF5x5(SHADOWMAP_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams) { return _getShadowPCF5x5(SHADOWMAP_PASS(shadowMap), shadowCoord, shadowParams.xyz); } float getLightDiffuse(vec3 worldNormal, vec3 viewDir, vec3 lightDir, vec3 lightDirNorm) { return max(dot(worldNormal, -lightDirNorm), 0.0); } float calcLightSpecular(float gloss, vec3 worldNormal, vec3 h) { float nh = max( dot( h, worldNormal ), 0.0 ); float specPow = exp2(gloss * 11.0); specPow = max(specPow, 0.0001); return pow(nh, specPow) * (specPow + 2.0) / 8.0; } float getLightSpecular(vec3 h, vec3 reflDir, vec3 worldNormal, vec3 viewDir, vec3 lightDirNorm, float gloss, mat3 tbn) { return calcLightSpecular(gloss, worldNormal, h); } vec3 combineColor(vec3 albedo, vec3 sheenSpecularity, float clearcoatSpecularity) { vec3 ret = vec3(0); ret += albedo * dDiffuseLight; ret += dSpecularLight; ret += dReflection.rgb * dReflection.a; return ret; } void addAmbient(vec3 worldNormal) { vec3 dir = normalize(cubeMapRotate(worldNormal) * vec3(-1.0, 1.0, 1.0)); vec2 uv = mapUv(toSphericalUv(dir), vec4(128.0, 256.0 + 128.0, 64.0, 32.0) / atlasSize); vec4 raw = texture2D(texture_envAtlas, uv); vec3 linear = decodeLinear(raw); dDiffuseLight += processEnvironment(linear); } void getViewDir() { dViewDirW = normalize(view_position - vPositionW); } void getReflDir(vec3 worldNormal, vec3 viewDir, float gloss, mat3 tbn) { dReflDirW = normalize(-reflect(viewDir, worldNormal)); } float bytes2float2(vec2 data) { return dot(data, vec2(1.0, 1.0 / 255.0)); } float bytes2float3(vec3 data) { return dot(data, vec3(1.0, 1.0 / 255.0, 1.0 / 65025.0)); } float bytes2float4(vec4 data) { return dot(data, vec4(1.0, 1.0 / 255.0, 1.0 / 65025.0, 1.0 / 16581375.0)); } float bytes2floatRange2(vec2 data, float min, float max) { return mix(min, max, bytes2float2(data)); } float bytes2floatRange3(vec3 data, float min, float max) { return mix(min, max, bytes2float3(data)); } float bytes2floatRange4(vec4 data, float min, float max) { return mix(min, max, bytes2float4(data)); } float mantissaExponent2Float(vec4 pack) { float value = bytes2floatRange3(pack.xyz, -1.0, 1.0); float exponent = floor(pack.w * 255.0 - 127.0); return value * exp2(exponent); } void _getShadowCoordPerspZbuffer(mat4 shadowMatrix, vec4 shadowParams, vec3 wPos) { vec4 projPos = shadowMatrix * vec4(wPos, 1.0); projPos.xyz /= projPos.w; dShadowCoord = projPos.xyz; } void getShadowCoordPerspZbufferNormalOffset(mat4 shadowMatrix, vec4 shadowParams, vec3 normal) { vec3 wPos = vPositionW + normal * shadowParams.y; _getShadowCoordPerspZbuffer(shadowMatrix, shadowParams, wPos); } vec3 normalOffsetPointShadow(vec4 shadowParams, vec3 lightPos, inout vec3 lightDir, vec3 lightDirNorm, vec3 normal) { float distScale = length(lightDir); vec3 wPos = vPositionW + normal * shadowParams.y * clamp(1.0 - dot(normal, -lightDirNorm), 0.0, 1.0) * distScale; vec3 dir = wPos - lightPos; return dir; } float getShadowOmniClusteredPCF3(SHADOWMAP_ACCEPT(shadowMap), vec4 shadowParams, vec3 omniAtlasViewport, float shadowEdgePixels, vec3 lightDir) { float shadowTextureResolution = shadowParams.x; vec2 uv = getCubemapAtlasCoordinates(omniAtlasViewport, shadowEdgePixels, shadowTextureResolution, lightDir); float shadowZ = length(lightDir) * shadowParams.w + shadowParams.z; vec3 shadowCoord = vec3(uv, shadowZ); return getShadowPCF3x3(SHADOWMAP_PASS(shadowMap), shadowCoord, shadowParams); } float getShadowSpotClusteredPCF3(SHADOWMAP_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams) { return getShadowSpotPCF3x3(SHADOWMAP_PASS(shadowMap), shadowCoord, shadowParams); } uniform highp sampler2D clusterWorldTexture; uniform highp sampler2D lightsTexture8; uniform highp sampler2D lightsTextureFloat; #define CLUSTER_COOKIES_OR_SHADOWS uniform sampler2DShadow shadowAtlasTexture; uniform int clusterMaxCells; uniform float clusterSkip; uniform vec3 clusterCellsCountByBoundsSize; uniform vec3 clusterTextureSize; uniform vec3 clusterBoundsMin; uniform vec3 clusterBoundsDelta; uniform vec3 clusterCellsDot; uniform vec3 clusterCellsMax; uniform vec2 clusterCompressionLimit0; uniform vec2 shadowAtlasParams; struct ClusterLightData { vec3 halfWidth; float lightType; vec3 halfHeight; int lightIndex; vec3 position; float shape; vec3 direction; float falloffMode; vec3 color; float shadowIntensity; vec3 omniAtlasViewport; float range; vec4 cookieChannelMask; float shadowBias; float shadowNormalBias; float innerConeAngleCos; float outerConeAngleCos; float cookie; float cookieRgb; float cookieIntensity; float mask; }; mat4 lightProjectionMatrix; #define isClusteredLightCastShadow(light) ( light.shadowIntensity > 0.0 ) #define isClusteredLightCookie(light) (light.cookie > 0.5 ) #define isClusteredLightCookieRgb(light) (light.cookieRgb > 0.5 ) #define isClusteredLightSpot(light) ( light.lightType > 0.5 ) #define isClusteredLightFalloffLinear(light) ( light.falloffMode < 0.5 ) #define isClusteredLightArea(light) ( light.shape > 0.1 ) #define isClusteredLightRect(light) ( light.shape < 0.3 ) #define isClusteredLightDisk(light) ( light.shape < 0.6 ) #define acceptLightMask(light) ( light.mask < 0.75) vec4 decodeClusterLowRange4Vec4(vec4 d0, vec4 d1, vec4 d2, vec4 d3) { return vec4( bytes2floatRange4(d0, -2.0, 2.0), bytes2floatRange4(d1, -2.0, 2.0), bytes2floatRange4(d2, -2.0, 2.0), bytes2floatRange4(d3, -2.0, 2.0) ); } vec4 sampleLightsTexture8(const ClusterLightData clusterLightData, int index) { return texelFetch(lightsTexture8, ivec2(index, clusterLightData.lightIndex), 0); } vec4 sampleLightTextureF(const ClusterLightData clusterLightData, int index) { return texelFetch(lightsTextureFloat, ivec2(index, clusterLightData.lightIndex), 0); } void decodeClusterLightCore(inout ClusterLightData clusterLightData, float lightIndex) { clusterLightData.lightIndex = int(lightIndex); vec4 lightInfo = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_FLAGS); clusterLightData.lightType = lightInfo.x; clusterLightData.shape = lightInfo.y; clusterLightData.falloffMode = lightInfo.z; clusterLightData.shadowIntensity = lightInfo.w; vec4 colorA = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_COLOR_A); vec4 colorB = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_COLOR_B); clusterLightData.color = vec3(bytes2float2(colorA.xy), bytes2float2(colorA.zw), bytes2float2(colorB.xy)) * clusterCompressionLimit0.y; clusterLightData.cookie = colorB.z; clusterLightData.mask = colorB.w; vec4 lightPosRange = sampleLightTextureF(clusterLightData, CLUSTER_TEXTURE_F_POSITION_RANGE); clusterLightData.position = lightPosRange.xyz; clusterLightData.range = lightPosRange.w; vec4 lightDir_Unused = sampleLightTextureF(clusterLightData, CLUSTER_TEXTURE_F_SPOT_DIRECTION); clusterLightData.direction = lightDir_Unused.xyz; } void decodeClusterLightSpot(inout ClusterLightData clusterLightData) { vec4 coneAngle = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_SPOT_ANGLES); clusterLightData.innerConeAngleCos = bytes2float2(coneAngle.xy) * 2.0 - 1.0; clusterLightData.outerConeAngleCos = bytes2float2(coneAngle.zw) * 2.0 - 1.0; } void decodeClusterLightOmniAtlasViewport(inout ClusterLightData clusterLightData) { clusterLightData.omniAtlasViewport = sampleLightTextureF(clusterLightData, CLUSTER_TEXTURE_F_PROJ_MAT_0).xyz; } void decodeClusterLightAreaData(inout ClusterLightData clusterLightData) { clusterLightData.halfWidth = sampleLightTextureF(clusterLightData, CLUSTER_TEXTURE_F_AREA_DATA_WIDTH).xyz; clusterLightData.halfHeight = sampleLightTextureF(clusterLightData, CLUSTER_TEXTURE_F_AREA_DATA_HEIGHT).xyz; } void decodeClusterLightProjectionMatrixData(inout ClusterLightData clusterLightData) { vec4 m0 = sampleLightTextureF(clusterLightData, CLUSTER_TEXTURE_F_PROJ_MAT_0); vec4 m1 = sampleLightTextureF(clusterLightData, CLUSTER_TEXTURE_F_PROJ_MAT_1); vec4 m2 = sampleLightTextureF(clusterLightData, CLUSTER_TEXTURE_F_PROJ_MAT_2); vec4 m3 = sampleLightTextureF(clusterLightData, CLUSTER_TEXTURE_F_PROJ_MAT_3); lightProjectionMatrix = mat4(m0, m1, m2, m3); } void decodeClusterLightShadowData(inout ClusterLightData clusterLightData) { vec4 biases = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_SHADOW_BIAS); clusterLightData.shadowBias = bytes2floatRange2(biases.xy, -1.0, 20.0), clusterLightData.shadowNormalBias = bytes2float2(biases.zw); } void decodeClusterLightCookieData(inout ClusterLightData clusterLightData) { vec4 cookieA = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_COOKIE_A); clusterLightData.cookieIntensity = cookieA.x; clusterLightData.cookieRgb = cookieA.y; clusterLightData.cookieChannelMask = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_COOKIE_B); } void evaluateLight( ClusterLightData light, vec3 worldNormal, vec3 viewDir, vec3 reflectionDir, float gloss, vec3 specularity, vec3 geometricNormal, mat3 tbn, vec3 clearcoat_worldNormal, float clearcoat_gloss, float sheen_gloss, float iridescence_intensity ) { vec3 cookieAttenuation = vec3(1.0); float diffuseAttenuation = 1.0; float falloffAttenuation = 1.0; getLightDirPoint(light.position); { if (isClusteredLightFalloffLinear(light)) falloffAttenuation = getFalloffLinear(light.range, dLightDirW); else falloffAttenuation = getFalloffInvSquared(light.range, dLightDirW); } if (falloffAttenuation > 0.00001) { { falloffAttenuation *= getLightDiffuse(worldNormal, viewDir, dLightDirW, dLightDirNormW); } if (isClusteredLightSpot(light)) { decodeClusterLightSpot(light); falloffAttenuation *= getSpotEffect(light.direction, light.innerConeAngleCos, light.outerConeAngleCos, dLightDirNormW); } if (falloffAttenuation > 0.00001) { if (isClusteredLightCastShadow(light) || isClusteredLightCookie(light)) { if (isClusteredLightSpot(light)) { decodeClusterLightProjectionMatrixData(light); } else { decodeClusterLightOmniAtlasViewport(light); } float shadowTextureResolution = shadowAtlasParams.x; float shadowEdgePixels = shadowAtlasParams.y; if (isClusteredLightCastShadow(light)) { decodeClusterLightShadowData(light); vec4 shadowParams = vec4(shadowTextureResolution, light.shadowNormalBias, light.shadowBias, 1.0 / light.range); if (isClusteredLightSpot(light)) { getShadowCoordPerspZbufferNormalOffset(lightProjectionMatrix, shadowParams, geometricNormal); float shadow = getShadowSpotClusteredPCF3(SHADOWMAP_PASS(shadowAtlasTexture), dShadowCoord, shadowParams); falloffAttenuation *= mix(1.0, shadow, light.shadowIntensity); } else { vec3 dir = normalOffsetPointShadow(shadowParams, dLightPosW, dLightDirW, dLightDirNormW, geometricNormal); float shadow = getShadowOmniClusteredPCF3(SHADOWMAP_PASS(shadowAtlasTexture), shadowParams, light.omniAtlasViewport, shadowEdgePixels, dir); falloffAttenuation *= mix(1.0, shadow, light.shadowIntensity); } } } } { { vec3 punctualDiffuse = falloffAttenuation * light.color * cookieAttenuation; dDiffuseLight += punctualDiffuse; } vec3 halfDir = normalize(-dLightDirNormW + viewDir); dSpecularLight += getLightSpecular(halfDir, reflectionDir, worldNormal, viewDir, dLightDirNormW, gloss, tbn) * falloffAttenuation * light.color * cookieAttenuation * getFresnel( dot(viewDir, halfDir), gloss, specularity ); } } dAtten = falloffAttenuation; dAttenD = diffuseAttenuation; dAtten3 = cookieAttenuation; } void evaluateClusterLight( float lightIndex, vec3 worldNormal, vec3 viewDir, vec3 reflectionDir, float gloss, vec3 specularity, vec3 geometricNormal, mat3 tbn, vec3 clearcoat_worldNormal, float clearcoat_gloss, float sheen_gloss, float iridescence_intensity ) { ClusterLightData clusterLightData; decodeClusterLightCore(clusterLightData, lightIndex); if (acceptLightMask(clusterLightData)) evaluateLight( clusterLightData, worldNormal, viewDir, reflectionDir, gloss, specularity, geometricNormal, tbn, clearcoat_worldNormal, clearcoat_gloss, sheen_gloss, iridescence_intensity ); } void addClusteredLights( vec3 worldNormal, vec3 viewDir, vec3 reflectionDir, float gloss, vec3 specularity, vec3 geometricNormal, mat3 tbn, vec3 clearcoat_worldNormal, float clearcoat_gloss, float sheen_gloss, float iridescence_intensity ) { if (clusterSkip > 0.5) return; vec3 cellCoords = floor((vPositionW - clusterBoundsMin) * clusterCellsCountByBoundsSize); if (!(any(lessThan(cellCoords, vec3(0.0))) || any(greaterThanEqual(cellCoords, clusterCellsMax)))) { float cellIndex = dot(clusterCellsDot, cellCoords); float clusterV = floor(cellIndex * clusterTextureSize.y); float clusterU = cellIndex - (clusterV * clusterTextureSize.x); for (int lightCellIndex = 0; lightCellIndex < clusterMaxCells; lightCellIndex++) { float lightIndex = texelFetch(clusterWorldTexture, ivec2(int(clusterU) + lightCellIndex, clusterV), 0).x; if (lightIndex <= 0.0) return; evaluateClusterLight( lightIndex * 255.0, worldNormal, viewDir, reflectionDir, gloss, specularity, geometricNormal, tbn, clearcoat_worldNormal, clearcoat_gloss, sheen_gloss, iridescence_intensity ); } } } void evaluateBackend() { getReflDir(litArgs_worldNormal, dViewDirW, litArgs_gloss, dTBN); float f0 = 1.0 / litArgs_ior; f0 = (f0 - 1.0) / (f0 + 1.0); f0 *= f0; litArgs_specularity = getSpecularModulate(litArgs_specularity, litArgs_albedo, litArgs_metalness, f0); litArgs_albedo = getAlbedoModulate(litArgs_albedo, litArgs_metalness); addAmbient(litArgs_worldNormal); dDiffuseLight = dDiffuseLight * (1.0 - litArgs_specularity); addReflection(dReflDirW, litArgs_gloss); dReflection.rgb *= getFresnel( dot(dViewDirW, litArgs_worldNormal), litArgs_gloss, litArgs_specularity ); addClusteredLights( litArgs_worldNormal, dViewDirW, dReflDirW, litArgs_gloss, litArgs_specularity, dVertexNormalW, dTBN, litArgs_clearcoat_worldNormal, litArgs_clearcoat_gloss, litArgs_sheen_gloss, litArgs_iridescence_intensity ); addRefraction( litArgs_worldNormal, dViewDirW, litArgs_thickness, litArgs_gloss, litArgs_specularity, litArgs_albedo, litArgs_transmission, litArgs_ior ); gl_FragColor.rgb = combineColor(litArgs_albedo, litArgs_sheen_specularity, litArgs_clearcoat_specularity); gl_FragColor.rgb += litArgs_emission; gl_FragColor.rgb = addFog(gl_FragColor.rgb); gl_FragColor.rgb = toneMap(gl_FragColor.rgb); gl_FragColor.rgb = gammaCorrectOutput(gl_FragColor.rgb); gl_FragColor.a = litArgs_opacity; } void main(void) { dReflection = vec4(0); dVertexNormalW = normalize(vNormalW); getViewDir(); evaluateFrontend(); evaluateBackend(); }

Literally_Kirby's Shaders (1)