UNPKG

playcanvas

Version:

Open-source WebGL/WebGPU 3D engine for the web

playcanvas.com

playcanvas/engine

3 lines (2 loc) • 15.2 kB
1
2
3
declare const _default: "\n// Real-Time Polygonal-Light Shading with Linearly Transformed Cosines\n// by Eric Heitz, Jonathan Dupuy, Stephen Hill and David Neubelt\n// code: https://github.com/selfshadow/ltc_code/\n\nfn LTC_Uv(N: vec3f, V: vec3f, roughness: f32) -> vec2f {\n const LUT_SIZE: f32 = 64.0;\n const LUT_SCALE: f32 = (LUT_SIZE - 1.0) / LUT_SIZE;\n const LUT_BIAS: f32 = 0.5 / LUT_SIZE;\n let dotNV: f32 = saturate(dot( N, V ));\n // texture parameterized by sqrt( GGX alpha ) and sqrt( 1 - cos( theta ) )\n let uv: vec2f = vec2f( roughness, sqrt( 1.0 - dotNV ) );\n return uv * LUT_SCALE + LUT_BIAS;\n}\n\nfn LTC_ClippedSphereFormFactor( f: vec3f ) -> f32 {\n // Real-Time Area Lighting: a Journey from Research to Production (p.102)\n // An approximation of the form factor of a horizon-clipped rectangle.\n let l: f32 = length( f );\n return max( ( l * l + f.z ) / ( l + 1.0 ), 0.0 );\n}\n\nfn LTC_EdgeVectorFormFactor( v1: vec3f, v2: vec3f ) -> vec3f {\n let x: f32 = dot( v1, v2 );\n let y: f32 = abs( x );\n // rational polynomial approximation to theta / sin( theta ) / 2PI\n let a: f32 = 0.8543985 + ( 0.4965155 + 0.0145206 * y ) * y;\n let b: f32 = 3.4175940 + ( 4.1616724 + y ) * y;\n let v: f32 = a / b;\n let inv_sqrt_term = inverseSqrt( max( 1.0 - x * x, 1e-7f ) );\n let theta_sintheta: f32 = select( (0.5 * inv_sqrt_term - v), v, x > 0.0 );\n return cross( v1, v2 ) * theta_sintheta;\n}\n\nstruct Coords {\n coord0: vec3f,\n coord1: vec3f,\n coord2: vec3f,\n coord3: vec3f,\n}\n\nfn LTC_EvaluateRect( N: vec3f, V: vec3f, P: vec3f, mInv: mat3x3f, rectCoords: Coords) -> f32 {\n // bail if point is on back side of plane of light\n // assumes ccw winding order of light vertices\n let v1: vec3f = rectCoords.coord1 - rectCoords.coord0;\n let v2: vec3f = rectCoords.coord3 - rectCoords.coord0;\n\n let lightNormal: vec3f = cross( v1, v2 );\n let factor: f32 = sign(-dot( lightNormal, P - rectCoords.coord0 ));\n\n // construct orthonormal basis around N\n let T1: vec3f = normalize( V - N * dot( V, N ) );\n let T2: vec3f = factor * cross( N, T1 ); // negated from paper; possibly due to a different handedness of world coordinate system\n // compute transform\n let mat: mat3x3f = mInv * transpose( mat3x3f( T1, T2, N ) );\n // transform rect\n var coords: array<vec3f, 4>;\n coords[0] = mat * ( rectCoords.coord0 - P );\n coords[1] = mat * ( rectCoords.coord1 - P );\n coords[2] = mat * ( rectCoords.coord2 - P );\n coords[3] = mat * ( rectCoords.coord3 - P );\n // project rect onto sphere\n coords[0] = normalize( coords[0] );\n coords[1] = normalize( coords[1] );\n coords[2] = normalize( coords[2] );\n coords[3] = normalize( coords[3] );\n // calculate vector form factor\n var vectorFormFactor: vec3f = vec3f( 0.0 );\n vectorFormFactor = vectorFormFactor + LTC_EdgeVectorFormFactor( coords[0], coords[1] );\n vectorFormFactor = vectorFormFactor + LTC_EdgeVectorFormFactor( coords[1], coords[2] );\n vectorFormFactor = vectorFormFactor + LTC_EdgeVectorFormFactor( coords[2], coords[3] );\n vectorFormFactor = vectorFormFactor + LTC_EdgeVectorFormFactor( coords[3], coords[0] );\n // adjust for horizon clipping\n let result: f32 = LTC_ClippedSphereFormFactor( vectorFormFactor );\n\n return result;\n}\n\nvar<private> dLTCCoords: Coords;\nfn getLTCLightCoords(lightPos: vec3f, halfWidth: vec3f, halfHeight: vec3f) -> Coords {\n var coords: Coords;\n coords.coord0 = lightPos + halfWidth - halfHeight;\n coords.coord1 = lightPos - halfWidth - halfHeight;\n coords.coord2 = lightPos - halfWidth + halfHeight;\n coords.coord3 = lightPos + halfWidth + halfHeight;\n return coords;\n}\n\nvar<private> dSphereRadius: f32;\nfn getSphereLightCoords(lightPos: vec3f, halfWidth: vec3f, halfHeight: vec3f) -> Coords {\n // used for simple sphere light falloff\n // also, the code only handles a spherical light, it cannot be non-uniformly scaled in world space, and so we enforce it here\n dSphereRadius = max(length(halfWidth), length(halfHeight));\n\n // Billboard the 2d light quad to reflection vector, as it's used for specular. This allows us to use disk math for the sphere.\n let f: vec3f = reflect(normalize(lightPos - uniform.view_position), vNormalW);\n let w: vec3f = normalize(cross(f, halfHeight));\n let h: vec3f = normalize(cross(f, w));\n\n return getLTCLightCoords(lightPos, w * dSphereRadius, h * dSphereRadius);\n}\n\n// used for LTC LUT texture lookup\nvar<private> dLTCUV: vec2f;\n#ifdef LIT_CLEARCOAT\n var<private> ccLTCUV: vec2f;\n#endif\n\nfn getLTCLightUV(gloss: f32, worldNormal: vec3f, viewDir: vec3f) -> vec2f {\n let roughness: f32 = max((1.0 - gloss) * (1.0 - gloss), 0.001);\n return LTC_Uv( worldNormal, viewDir, roughness );\n}\n\n// used for energy conservation and to modulate specular\nvar<private> dLTCSpecFres: vec3f;\n#ifdef LIT_CLEARCOAT\n var<private> ccLTCSpecFres: vec3f;\n#endif\n\nfn getLTCLightSpecFres(uv: vec2f, specularity: vec3f) -> vec3f {\n let t2: vec4f = textureSampleLevel(areaLightsLutTex2, areaLightsLutTex2Sampler, uv, 0.0);\n return specularity * t2.x + ( vec3f( 1.0 ) - specularity) * t2.y;\n}\n\nfn calcLTCLightValues(gloss: f32, worldNormal: vec3f, viewDir: vec3f, specularity: vec3f, clearcoatGloss: f32, clearcoatWorldNormal: vec3f, clearcoatSpecularity: f32) {\n dLTCUV = getLTCLightUV(gloss, worldNormal, viewDir);\n dLTCSpecFres = getLTCLightSpecFres(dLTCUV, specularity);\n\n #ifdef LIT_CLEARCOAT\n ccLTCUV = getLTCLightUV(clearcoatGloss, clearcoatWorldNormal, viewDir);\n ccLTCSpecFres = getLTCLightSpecFres(ccLTCUV, vec3f(clearcoatSpecularity));\n #endif\n}\n\nfn calcRectLightValues(lightPos: vec3f, halfWidth: vec3f, halfHeight: vec3f) {\n dLTCCoords = getLTCLightCoords(lightPos, halfWidth, halfHeight);\n}\nfn calcDiskLightValues(lightPos: vec3f, halfWidth: vec3f, halfHeight: vec3f) {\n calcRectLightValues(lightPos, halfWidth, halfHeight);\n}\nfn calcSphereLightValues(lightPos: vec3f, halfWidth: vec3f, halfHeight: vec3f) {\n dLTCCoords = getSphereLightCoords(lightPos, halfWidth, halfHeight);\n}\n\n// An extended version of the implementation from \"How to solve a cubic equation, revisited\"\n// http://momentsingraphics.de/?p=105\nfn SolveCubic(Coefficient_in: vec4f) -> vec3f {\n let pi: f32 = 3.14159;\n var Coefficient = Coefficient_in;\n\n // Normalize the polynomial\n Coefficient = vec4f(Coefficient.xyz / Coefficient.w, Coefficient.w);\n\n // Divide middle coefficients by three\n let new_yz: vec2f = Coefficient.yz / 3.0;\n Coefficient = vec4f(Coefficient.x, new_yz.x, new_yz.y, Coefficient.w);\n \n let A: f32 = Coefficient.w;\n let B: f32 = Coefficient.z;\n let C: f32 = Coefficient.y;\n let D: f32 = Coefficient.x;\n\n // Compute the Hessian and the discriminant\n let Delta: vec3f = vec3f(\n -Coefficient.z * Coefficient.z + Coefficient.y,\n -Coefficient.y * Coefficient.z + Coefficient.x,\n dot(vec2f(Coefficient.z, -Coefficient.y), Coefficient.xy)\n );\n\n let Discriminant: f32 = dot(vec2f(4.0 * Delta.x, -Delta.y), Delta.zy);\n\n var xlc: vec2f;\n var xsc: vec2f;\n\n // Algorithm A\n {\n let A_a: f32 = 1.0;\n let C_a: f32 = Delta.x;\n let D_a: f32 = -2.0 * B * Delta.x + Delta.y;\n\n // Take the cubic root of a normalized complex number\n let Theta: f32 = atan2(sqrt(Discriminant), -D_a) / 3.0;\n\n let sqrt_neg_Ca = sqrt(-C_a);\n let x_1a: f32 = 2.0 * sqrt_neg_Ca * cos(Theta);\n let x_3a: f32 = 2.0 * sqrt_neg_Ca * cos(Theta + (2.0 / 3.0) * pi);\n\n let xl: f32 = select(x_3a, x_1a, (x_1a + x_3a) > 2.0 * B);\n xlc = vec2f(xl - B, A);\n }\n\n // Algorithm D\n {\n let A_d: f32 = D;\n let C_d: f32 = Delta.z;\n let D_d: f32 = -D * Delta.y + 2.0 * C * Delta.z;\n\n // Take the cubic root of a normalized complex number\n let Theta: f32 = atan2(D * sqrt(Discriminant), -D_d) / 3.0;\n\n let sqrt_neg_Cd = sqrt(-C_d);\n let x_1d: f32 = 2.0 * sqrt_neg_Cd * cos(Theta);\n let x_3d: f32 = 2.0 * sqrt_neg_Cd * cos(Theta + (2.0 / 3.0) * pi);\n\n let xs: f32 = select(x_3d, x_1d, x_1d + x_3d < 2.0 * C);\n xsc = vec2f(-D, xs + C);\n }\n\n let E: f32 = xlc.y * xsc.y;\n let F: f32 = -xlc.x * xsc.y - xlc.y * xsc.x;\n let G: f32 = xlc.x * xsc.x;\n\n let xmc: vec2f = vec2f(C * F - B * G, -B * F + C * E);\n\n var Root: vec3f = vec3f(xsc.x / xsc.y, xmc.x / xmc.y, xlc.x / xlc.y);\n\n if (Root.x < Root.y && Root.x < Root.z) {\n Root = Root.yxz;\n } else if (Root.z < Root.x && Root.z < Root.y) {\n Root = Root.xzy;\n }\n return Root;\n}\n\nfn LTC_EvaluateDisk(N: vec3f, V: vec3f, P: vec3f, Minv: mat3x3f, points: Coords) -> f32 {\n // construct orthonormal basis around N\n let T1: vec3f = normalize(V - N * dot(V, N));\n let T2: vec3f = cross(N, T1);\n\n // rotate area light in (T1, T2, N) basis\n let R: mat3x3f = transpose( mat3x3f( T1, T2, N ) );\n // polygon (allocate 5 vertices for clipping\n var L_: array<vec3f, 3>;\n L_[0] = R * ( points.coord0 - P );\n L_[1] = R * ( points.coord1 - P );\n L_[2] = R * ( points.coord2 - P );\n\n // init ellipse\n let C: vec3f = 0.5 * (L_[0] + L_[2]);\n var V1: vec3f = 0.5 * (L_[1] - L_[2]);\n var V2: vec3f = 0.5 * (L_[1] - L_[0]);\n\n let C_Minv: vec3f = Minv * C;\n let V1_Minv: vec3f = Minv * V1;\n let V2_Minv: vec3f = Minv * V2;\n\n // compute eigenvectors of ellipse\n var a: f32;\n var b: f32;\n let d11: f32 = dot(V1_Minv, V1_Minv);\n let d22: f32 = dot(V2_Minv, V2_Minv);\n let d12: f32 = dot(V1_Minv, V2_Minv);\n if (abs(d12) / sqrt(d11 * d22) > 0.0001) {\n let tr: f32 = d11 + d22;\n let det_inner: f32 = -d12 * d12 + d11 * d22;\n let det: f32 = sqrt(det_inner);\n let u: f32 = 0.5 * sqrt(tr - 2.0 * det);\n let v: f32 = 0.5 * sqrt(tr + 2.0 * det);\n let e_max: f32 = (u + v) * (u + v);\n let e_min: f32 = (u - v) * (u - v);\n\n var V1_: vec3f;\n var V2_: vec3f;\n\n if (d11 > d22) {\n V1_ = d12 * V1_Minv + (e_max - d11) * V2_Minv;\n V2_ = d12 * V1_Minv + (e_min - d11) * V2_Minv;\n } else {\n V1_ = d12*V2_Minv + (e_max - d22)*V1_Minv;\n V2_ = d12*V2_Minv + (e_min - d22)*V1_Minv;\n }\n\n a = 1.0 / e_max;\n b = 1.0 / e_min;\n V1 = normalize(V1_);\n V2 = normalize(V2_);\n } else {\n a = 1.0 / dot(V1_Minv, V1_Minv);\n b = 1.0 / dot(V2_Minv, V2_Minv);\n V1 = V1_Minv * sqrt(a);\n V2 = V2_Minv * sqrt(b);\n }\n\n var V3: vec3f = normalize(cross(V1, V2));\n if (dot(C_Minv, V3) < 0.0) {\n V3 = V3 * -1.0;\n }\n\n let L: f32 = dot(V3, C_Minv);\n let x0: f32 = dot(V1, C_Minv) / L;\n let y0: f32 = dot(V2, C_Minv) / L;\n\n let E1: f32 = inverseSqrt(a);\n let E2: f32 = inverseSqrt(b);\n\n let a_scaled = a * L * L;\n let b_scaled = b * L * L;\n\n let c0: f32 = a_scaled * b_scaled;\n let c1: f32 = a_scaled * b_scaled * (1.0 + x0 * x0 + y0 * y0) - a_scaled - b_scaled;\n let c2: f32 = 1.0 - a_scaled * (1.0 + x0 * x0) - b_scaled * (1.0 + y0 * y0);\n let c3: f32 = 1.0;\n\n let roots: vec3f = SolveCubic(vec4f(c0, c1, c2, c3));\n let e1: f32 = roots.x;\n let e2: f32 = roots.y;\n let e3: f32 = roots.z;\n\n var avgDir: vec3f = vec3f(a_scaled * x0 / (a_scaled - e2), b_scaled * y0 / (b_scaled - e2), 1.0);\n\n let rotate: mat3x3f = mat3x3f(V1, V2, V3);\n\n avgDir = rotate * avgDir;\n avgDir = normalize(avgDir);\n\n let L1: f32 = sqrt(-e2 / e3);\n let L2: f32 = sqrt(-e2 / e1);\n\n let formFactor: f32 = max(0.0, L1 * L2 * inverseSqrt((1.0 + L1 * L1) * (1.0 + L2 * L2)));\n\n const LUT_SIZE_disk: f32 = 64.0;\n const LUT_SCALE_disk: f32 = ( LUT_SIZE_disk - 1.0 ) / LUT_SIZE_disk;\n const LUT_BIAS_disk: f32 = 0.5 / LUT_SIZE_disk;\n\n // use tabulated horizon-clipped sphere\n var uv: vec2f = vec2f(avgDir.z * 0.5 + 0.5, formFactor);\n uv = uv * LUT_SCALE_disk + LUT_BIAS_disk;\n\n let scale: f32 = textureSampleLevel(areaLightsLutTex2, areaLightsLutTex2Sampler, uv, 0.0).w;\n\n return formFactor * scale;\n}\n\n// LTC_EvaluateDisk in some rare cases genereates NaN values in a or b, just before 'float c0 = a * b;'\n// Get rid of those Nan values before they propagate further, as in case of bloom / DOF blurs they\n// propagate to large areas. I didn't find the actual reason where those come from, so that is still TODO.\n// Note that only disk/sphere lights are causing it, so only handle those.\nfn FixNan(value: f32) -> f32 {\n // use value != value check for NaN as isnan() is not available in WGSL\n return select(value, 0.0, value != value);\n}\n\nfn getRectLightDiffuse(worldNormal: vec3f, viewDir: vec3f, lightDir: vec3f, lightDirNorm: vec3f) -> f32 {\n let identityMat = mat3x3f(vec3f(1.0, 0.0, 0.0), vec3f(0.0, 1.0, 0.0), vec3f(0.0, 0.0, 1.0));\n return LTC_EvaluateRect( worldNormal, viewDir, vPositionW, identityMat, dLTCCoords );\n}\n\nfn getDiskLightDiffuse(worldNormal: vec3f, viewDir: vec3f, lightDir: vec3f, lightDirNorm: vec3f) -> f32 {\n let identityMat = mat3x3f(vec3f(1.0, 0.0, 0.0), vec3f(0.0, 1.0, 0.0), vec3f(0.0, 0.0, 1.0));\n return FixNan(LTC_EvaluateDisk( worldNormal, viewDir, vPositionW, identityMat, dLTCCoords ));\n}\n\nfn getSphereLightDiffuse(worldNormal: vec3f, viewDir: vec3f, lightDir: vec3f, lightDirNorm: vec3f) -> f32 {\n // NB: this could be improved further with distance based wrap lighting\n let falloff: f32 = dSphereRadius / (dot(lightDir, lightDir) + dSphereRadius);\n return FixNan(getLightDiffuse(worldNormal, viewDir, lightDirNorm) * falloff);\n}\n\nfn getLTCLightInvMat(uv: vec2f) -> mat3x3f {\n let t1: vec4f = textureSampleLevel(areaLightsLutTex1, areaLightsLutTex1Sampler, uv, 0.0);\n\n return mat3x3f(\n vec3f( t1.x, 0.0, t1.y ),\n vec3f( 0.0, 1.0, 0.0 ),\n vec3f( t1.z, 0.0, t1.w )\n );\n}\n\nfn calcRectLightSpecular(worldNormal: vec3f, viewDir: vec3f, uv: vec2f) -> f32 {\n let mInv: mat3x3f = getLTCLightInvMat(uv);\n return LTC_EvaluateRect( worldNormal, viewDir, vPositionW, mInv, dLTCCoords );\n}\n\nfn getRectLightSpecular(worldNormal: vec3f, viewDir: vec3f) -> f32 {\n return calcRectLightSpecular(worldNormal, viewDir, dLTCUV);\n}\n\nfn calcDiskLightSpecular(worldNormal: vec3f, viewDir: vec3f, uv: vec2f) -> f32 {\n let mInv: mat3x3f = getLTCLightInvMat(uv);\n return LTC_EvaluateDisk( worldNormal, viewDir, vPositionW, mInv, dLTCCoords );\n}\n\nfn getDiskLightSpecular(worldNormal: vec3f, viewDir: vec3f) -> f32 {\n return calcDiskLightSpecular(worldNormal, viewDir, dLTCUV);\n}\n\nfn getSphereLightSpecular(worldNormal: vec3f, viewDir: vec3f) -> f32 {\n return calcDiskLightSpecular(worldNormal, viewDir, dLTCUV);\n}\n"; export default _default;