| const GAMMA = 2.200000048; | |
| fn linearTosRGB(linear : vec3<f32>) -> vec3<f32> { | |
| let INV_GAMMA = (1.0 / GAMMA); | |
| return pow(linear, vec3(INV_GAMMA)); | |
| } | |
| fn sRGBToLinear(srgb : vec3<f32>) -> vec3<f32> { | |
| return pow(srgb, vec3(GAMMA)); | |
| } | |
| struct Camera { | |
| projection : mat4x4<f32>, | |
| inverseProjection : mat4x4<f32>, | |
| view : mat4x4<f32>, | |
| position : vec3<f32>, | |
| time : f32, | |
| outputSize : vec2<f32>, | |
| zNear : f32, | |
| zFar : f32, | |
| } | |
| @binding(0) @group(0) var<uniform> camera : Camera; | |
| struct ClusterLights { | |
| offset : u32, | |
| count : u32, | |
| } | |
| struct ClusterLightGroup { | |
| offset : u32, | |
| lights : array<ClusterLights, 27648>, | |
| indices : array<u32, 1769472>, | |
| } | |
| @binding(1) @group(0) var<storage, read> clusterLights : ClusterLightGroup; | |
| struct Light { | |
| position : vec3<f32>, | |
| range : f32, | |
| color : vec3<f32>, | |
| intensity : f32, | |
| } | |
| struct GlobalLights { | |
| ambient : vec3<f32>, | |
| dirColor : vec3<f32>, | |
| dirIntensity : f32, | |
| dirDirection : vec3<f32>, | |
| lightCount : u32, | |
| lights : array<Light>, | |
| } | |
| @binding(2) @group(0) var<storage, read> globalLights : GlobalLights; | |
| const tileCount = vec3(32u, 18u, 48u); | |
| fn linearDepth(depthSample : f32) -> f32 { | |
| return ((camera.zFar * camera.zNear) / fma(depthSample, (camera.zNear - camera.zFar), camera.zFar)); | |
| } | |
| fn getTile(fragCoord : vec4<f32>) -> vec3<u32> { | |
| let sliceScale = (f32(tileCount.z) / log2((camera.zFar / camera.zNear))); | |
| let sliceBias = -(((f32(tileCount.z) * log2(camera.zNear)) / log2((camera.zFar / camera.zNear)))); | |
| let zTile = u32(max(((log2(linearDepth(fragCoord.z)) * sliceScale) + sliceBias), 0.0)); | |
| return vec3(u32((fragCoord.x / (camera.outputSize.x / f32(tileCount.x)))), u32((fragCoord.y / (camera.outputSize.y / f32(tileCount.y)))), zTile); | |
| } | |
| fn getClusterIndex(fragCoord : vec4<f32>) -> u32 { | |
| let tile = getTile(fragCoord); | |
| return ((tile.x + (tile.y * tileCount.x)) + ((tile.z * tileCount.x) * tileCount.y)); | |
| } | |
| @binding(3) @group(0) var defaultSampler : sampler; | |
| @binding(4) @group(0) var shadowTexture : texture_depth_2d; | |
| @binding(5) @group(0) var shadowSampler : sampler_comparison; | |
| struct LightShadowTable { | |
| light : array<i32>, | |
| } | |
| @binding(6) @group(0) var<storage, read> lightShadowTable : LightShadowTable; | |
| var<private> shadowSampleOffsets : array<vec2<f32>, 16> = array<vec2<f32>, 16>(vec2(-1.5, -1.5), vec2(-1.5, -0.5), vec2(-1.5, 0.5), vec2(-1.5, 1.5), vec2(-0.5, -1.5), vec2(-0.5, -0.5), vec2(-0.5, 0.5), vec2(-0.5, 1.5), vec2(0.5, -1.5), vec2(0.5, -0.5), vec2(0.5, 0.5), vec2(0.5, 1.5), vec2(1.5, -1.5), vec2(1.5, -0.5), vec2(1.5, 0.5), vec2(1.5, 1.5)); | |
| const shadowSampleCount = 16u; | |
| struct ShadowProperties { | |
| viewport : vec4<f32>, | |
| viewProj : mat4x4<f32>, | |
| } | |
| struct LightShadows { | |
| properties : array<ShadowProperties>, | |
| } | |
| @binding(7) @group(0) var<storage, read> shadow : LightShadows; | |
| fn dirLightVisibility(worldPos : vec3<f32>) -> f32 { | |
| let shadowIndex = lightShadowTable.light[0u]; | |
| if ((shadowIndex == -1)) { | |
| return 1.0; | |
| } | |
| let viewport = shadow.properties[shadowIndex].viewport; | |
| let lightPos = (shadow.properties[shadowIndex].viewProj * vec4(worldPos, 1.0)); | |
| let shadowPos = vec3((((lightPos.xy / lightPos.w) * vec2(0.5, -0.5)) + vec2(0.5, 0.5)), (lightPos.z / lightPos.w)); | |
| let viewportPos = vec2((viewport.xy + (shadowPos.xy * viewport.zw))); | |
| let texelSize = (1.0 / vec2<f32>(textureDimensions(shadowTexture, 0))); | |
| let clampRect = vec4((viewport.xy - texelSize), ((viewport.xy + viewport.zw) + texelSize)); | |
| var visibility = 0.0; | |
| for(var i = 0u; (i < shadowSampleCount); i = (i + 1u)) { | |
| visibility = (visibility + textureSampleCompareLevel(shadowTexture, shadowSampler, clamp((viewportPos + (shadowSampleOffsets[i] * texelSize)), clampRect.xy, clampRect.zw), (shadowPos.z - 0.003))); | |
| } | |
| return (visibility / f32(shadowSampleCount)); | |
| } | |
| fn getCubeFace(v : vec3<f32>) -> i32 { | |
| let vAbs = abs(v); | |
| if (((vAbs.z >= vAbs.x) && (vAbs.z >= vAbs.y))) { | |
| if ((v.z < 0.0)) { | |
| return 5; | |
| } | |
| return 4; | |
| } | |
| if ((vAbs.y >= vAbs.x)) { | |
| if ((v.y < 0.0)) { | |
| return 3; | |
| } | |
| return 2; | |
| } | |
| if ((v.x < 0.0)) { | |
| return 1; | |
| } | |
| return 0; | |
| } | |
| fn pointLightVisibility(lightIndex : u32, worldPos : vec3<f32>, pointToLight : vec3<f32>) -> f32 { | |
| var shadowIndex = lightShadowTable.light[(lightIndex + 1u)]; | |
| if ((shadowIndex == -1)) { | |
| return 1.0; | |
| } | |
| shadowIndex = (shadowIndex + getCubeFace((pointToLight * -1.0))); | |
| let viewport = shadow.properties[shadowIndex].viewport; | |
| let lightPos = (shadow.properties[shadowIndex].viewProj * vec4(worldPos, 1.0)); | |
| let shadowPos = vec3((((lightPos.xy / lightPos.w) * vec2(0.5, -0.5)) + vec2(0.5, 0.5)), (lightPos.z / lightPos.w)); | |
| let viewportPos = vec2((viewport.xy + (shadowPos.xy * viewport.zw))); | |
| let texelSize = (1.0 / vec2<f32>(textureDimensions(shadowTexture, 0))); | |
| let clampRect = vec4(viewport.xy, (viewport.xy + viewport.zw)); | |
| var visibility = 0.0; | |
| for(var i = 0u; (i < shadowSampleCount); i = (i + 1u)) { | |
| visibility = (visibility + textureSampleCompareLevel(shadowTexture, shadowSampler, clamp((viewportPos + (shadowSampleOffsets[i] * texelSize)), clampRect.xy, clampRect.zw), (shadowPos.z - 0.01))); | |
| } | |
| return (visibility / f32(shadowSampleCount)); | |
| } | |
| struct VertexOutput { | |
| @builtin(position) | |
| position : vec4<f32>, | |
| @location(0) | |
| worldPos : vec3<f32>, | |
| @location(1) | |
| view : vec3<f32>, | |
| @location(2) | |
| texcoord : vec2<f32>, | |
| @location(3) | |
| texcoord2 : vec2<f32>, | |
| @location(4) | |
| color : vec4<f32>, | |
| @location(5) | |
| instanceColor : vec4<f32>, | |
| @location(6) | |
| normal : vec3<f32>, | |
| @location(7) | |
| tangent : vec3<f32>, | |
| @location(8) | |
| bitangent : vec3<f32>, | |
| } | |
| struct Material { | |
| baseColorFactor : vec4<f32>, | |
| emissiveFactor : vec3<f32>, | |
| occlusionStrength : f32, | |
| metallicRoughnessFactor : vec2<f32>, | |
| alphaCutoff : f32, | |
| } | |
| @binding(8) @group(0) var<uniform> material : Material; | |
| @binding(9) @group(0) var baseColorTexture : texture_2d<f32>; | |
| @binding(10) @group(0) var baseColorSampler : sampler; | |
| @binding(11) @group(0) var normalTexture : texture_2d<f32>; | |
| @binding(12) @group(0) var normalSampler : sampler; | |
| @binding(13) @group(0) var metallicRoughnessTexture : texture_2d<f32>; | |
| @binding(14) @group(0) var metallicRoughnessSampler : sampler; | |
| @binding(15) @group(0) var occlusionTexture : texture_2d<f32>; | |
| @binding(16) @group(0) var occlusionSampler : sampler; | |
| @binding(17) @group(0) var emissiveTexture : texture_2d<f32>; | |
| @binding(18) @group(0) var emissiveSampler : sampler; | |
| struct SurfaceInfo { | |
| baseColor : vec4<f32>, | |
| albedo : vec3<f32>, | |
| metallic : f32, | |
| roughness : f32, | |
| normal : vec3<f32>, | |
| f0 : vec3<f32>, | |
| ao : f32, | |
| emissive : vec3<f32>, | |
| v : vec3<f32>, | |
| } | |
| fn GetSurfaceInfo(input : VertexOutput) -> SurfaceInfo { | |
| var surface : SurfaceInfo; | |
| surface.v = normalize(input.view); | |
| let tbn = mat3x3(input.tangent, input.bitangent, input.normal); | |
| let normalMap = textureSample(normalTexture, normalSampler, input.texcoord).rgb; | |
| surface.normal = normalize((tbn * ((2.0 * normalMap) - vec3(1.0)))); | |
| let baseColorMap = textureSample(baseColorTexture, baseColorSampler, input.texcoord); | |
| surface.baseColor = ((input.color * material.baseColorFactor) * baseColorMap); | |
| if ((surface.baseColor.a < material.alphaCutoff)) { | |
| // Violates uniformity analysis: | |
| // discard; | |
| } | |
| surface.albedo = surface.baseColor.rgb; | |
| let metallicRoughnessMap = textureSample(metallicRoughnessTexture, metallicRoughnessSampler, input.texcoord); | |
| surface.metallic = (material.metallicRoughnessFactor.x * metallicRoughnessMap.b); | |
| surface.roughness = (material.metallicRoughnessFactor.y * metallicRoughnessMap.g); | |
| let dielectricSpec = vec3(0.039999999); | |
| surface.f0 = mix(dielectricSpec, surface.albedo, vec3(surface.metallic)); | |
| let occlusionMap = textureSample(occlusionTexture, occlusionSampler, input.texcoord); | |
| surface.ao = (material.occlusionStrength * occlusionMap.r); | |
| let emissiveMap = textureSample(emissiveTexture, emissiveSampler, input.texcoord); | |
| surface.emissive = (material.emissiveFactor * emissiveMap.rgb); | |
| if ((input.instanceColor.a == 0.0)) { | |
| surface.albedo = (surface.albedo + input.instanceColor.rgb); | |
| } else { | |
| surface.albedo = (surface.albedo * input.instanceColor.rgb); | |
| } | |
| return surface; | |
| } | |
| const PI = 3.141592741; | |
| const LightType_Point = 0u; | |
| const LightType_Spot = 1u; | |
| const LightType_Directional = 2u; | |
| struct PuctualLight { | |
| lightType : u32, | |
| pointToLight : vec3<f32>, | |
| range : f32, | |
| color : vec3<f32>, | |
| intensity : f32, | |
| } | |
| fn FresnelSchlick(cosTheta : f32, F0 : vec3<f32>) -> vec3<f32> { | |
| return (F0 + ((vec3(1.0) - F0) * pow((1.0 - cosTheta), 5.0))); | |
| } | |
| fn DistributionGGX(N : vec3<f32>, H : vec3<f32>, roughness : f32) -> f32 { | |
| let a = (roughness * roughness); | |
| let a2 = (a * a); | |
| let NdotH = max(dot(N, H), 0.0); | |
| let NdotH2 = (NdotH * NdotH); | |
| let num = a2; | |
| let denom = ((NdotH2 * (a2 - 1.0)) + 1.0); | |
| return (num / ((PI * denom) * denom)); | |
| } | |
| fn GeometrySchlickGGX(NdotV : f32, roughness : f32) -> f32 { | |
| let r = (roughness + 1.0); | |
| let k = ((r * r) / 8.0); | |
| let num = NdotV; | |
| let denom = ((NdotV * (1.0 - k)) + k); | |
| return (num / denom); | |
| } | |
| fn GeometrySmith(N : vec3<f32>, V : vec3<f32>, L : vec3<f32>, roughness : f32) -> f32 { | |
| let NdotV = max(dot(N, V), 0.0); | |
| let NdotL = max(dot(N, L), 0.0); | |
| let ggx2 = GeometrySchlickGGX(NdotV, roughness); | |
| let ggx1 = GeometrySchlickGGX(NdotL, roughness); | |
| return (ggx1 * ggx2); | |
| } | |
| fn lightAttenuation(light : PuctualLight) -> f32 { | |
| if ((light.lightType == LightType_Directional)) { | |
| return 1.0; | |
| } | |
| let distance = length(light.pointToLight); | |
| if ((light.range <= 0.0)) { | |
| return (1.0 / pow(distance, 2.0)); | |
| } | |
| return (clamp((1.0 - pow((distance / light.range), 4.0)), 0.0, 1.0) / pow(distance, 2.0)); | |
| } | |
| fn lightRadiance(light : PuctualLight, surface : SurfaceInfo) -> vec3<f32> { | |
| let L = normalize(light.pointToLight); | |
| let H = normalize((surface.v + L)); | |
| let NDF = DistributionGGX(surface.normal, H, surface.roughness); | |
| let G = GeometrySmith(surface.normal, surface.v, L, surface.roughness); | |
| let F = FresnelSchlick(max(dot(H, surface.v), 0.0), surface.f0); | |
| let kD = ((vec3(1.0) - F) * (1.0 - surface.metallic)); | |
| let NdotL = max(dot(surface.normal, L), 0.0); | |
| let numerator = ((NDF * G) * F); | |
| let denominator = max(((4.0 * max(dot(surface.normal, surface.v), 0.0)) * NdotL), 0.001); | |
| let specular = (numerator / vec3(denominator)); | |
| let radiance = ((light.color * light.intensity) * lightAttenuation(light)); | |
| return (((((kD * surface.albedo) / vec3(PI)) + specular) * radiance) * NdotL); | |
| } | |
| @binding(19) @group(0) var ssaoTexture : texture_2d<f32>; | |
| struct FragmentOutput { | |
| @location(0) | |
| color : vec4<f32>, | |
| @location(1) | |
| emissive : vec4<f32>, | |
| } | |
| @fragment | |
| fn fragmentMain(input : VertexOutput) -> FragmentOutput { | |
| let surface = GetSurfaceInfo(input); | |
| var Lo = vec3(0.0, 0.0, 0.0); | |
| if ((globalLights.dirIntensity > 0.0)) { | |
| var light : PuctualLight; | |
| light.lightType = LightType_Directional; | |
| light.pointToLight = globalLights.dirDirection; | |
| light.color = globalLights.dirColor; | |
| light.intensity = globalLights.dirIntensity; | |
| let lightVis = dirLightVisibility(input.worldPos); | |
| Lo = (Lo + (lightRadiance(light, surface) * lightVis)); | |
| } | |
| let clusterIndex = getClusterIndex(input.position); | |
| let lightOffset = clusterLights.lights[clusterIndex].offset; | |
| let lightCount = clusterLights.lights[clusterIndex].count; | |
| for(var lightIndex = 0u; (lightIndex < lightCount); lightIndex = (lightIndex + 1u)) { | |
| let i = clusterLights.indices[(lightOffset + lightIndex)]; | |
| var light : PuctualLight; | |
| light.lightType = LightType_Point; | |
| light.pointToLight = (globalLights.lights[i].position.xyz - input.worldPos); | |
| light.range = globalLights.lights[i].range; | |
| light.color = globalLights.lights[i].color; | |
| light.intensity = globalLights.lights[i].intensity; | |
| let lightVis = pointLightVisibility(i, input.worldPos, light.pointToLight); | |
| Lo = (Lo + (lightRadiance(light, surface) * lightVis)); | |
| } | |
| let ssaoCoord = (input.position.xy / vec2<f32>(textureDimensions(ssaoTexture).xy)); | |
| let ssaoFactor = textureSample(ssaoTexture, defaultSampler, ssaoCoord).r; | |
| let ambient = (((globalLights.ambient * surface.albedo) * surface.ao) * ssaoFactor); | |
| let color = linearTosRGB(((Lo + ambient) + surface.emissive)); | |
| var out : FragmentOutput; | |
| out.color = vec4(color, surface.baseColor.a); | |
| out.emissive = vec4(surface.emissive, surface.baseColor.a); | |
| return out; | |
| } |