@rtzh/engine 0.0.1

package/Source/Shaders/Builtin/Functions/modelToWindowCoordinates.js

@@ -0,0 +1,40 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "/**\n\
+ * Transforms a position from model to window coordinates.  The transformation\n\
+ * from model to clip coordinates is done using {@link czm_modelViewProjection}.\n\
+ * The transform from normalized device coordinates to window coordinates is\n\
+ * done using {@link czm_viewportTransformation}, which assumes a depth range\n\
+ * of <code>near = 0</code> and <code>far = 1</code>.\n\
+ * <br /><br />\n\
+ * This transform is useful when there is a need to manipulate window coordinates\n\
+ * in a vertex shader as done by {@link BillboardCollection}.\n\
+ * <br /><br />\n\
+ * This function should not be confused with {@link czm_viewportOrthographic},\n\
+ * which is an orthographic projection matrix that transforms from window \n\
+ * coordinates to clip coordinates.\n\
+ *\n\
+ * @name czm_modelToWindowCoordinates\n\
+ * @glslFunction\n\
+ *\n\
+ * @param {vec4} position The position in model coordinates to transform.\n\
+ *\n\
+ * @returns {vec4} The transformed position in window coordinates.\n\
+ *\n\
+ * @see czm_eyeToWindowCoordinates\n\
+ * @see czm_modelViewProjection\n\
+ * @see czm_viewportTransformation\n\
+ * @see czm_viewportOrthographic\n\
+ * @see BillboardCollection\n\
+ *\n\
+ * @example\n\
+ * vec4 positionWC = czm_modelToWindowCoordinates(positionMC);\n\
+ */\n\
+vec4 czm_modelToWindowCoordinates(vec4 position)\n\
+{\n\
+    vec4 positionEC = czm_modelView * position;\n\
+    vec4 q = czm_projection * positionEC;\n\
+    q.xyz /= q.w;                                                // normalized device coordinates\n\
+    q.xyz = (czm_viewportTransformation * vec4(q.xyz, 1.0)).xyz; // window coordinates\n\
+    return q;\n\
+}\n\
+";

package/Source/Shaders/Builtin/Functions/multiplyWithColorBalance.glsl

@@ -0,0 +1,18 @@
+/**
+ * DOC_TBA
+ *
+ * @name czm_multiplyWithColorBalance
+ * @glslFunction
+ */
+vec3 czm_multiplyWithColorBalance(vec3 left, vec3 right)
+{
+    // Algorithm from Chapter 10 of Graphics Shaders.
+    const vec3 W = vec3(0.2125, 0.7154, 0.0721);
+    
+    vec3 target = left * right;
+    float leftLuminance = dot(left, W);
+    float rightLuminance = dot(right, W);
+    float targetLuminance = dot(target, W);
+    
+    return ((leftLuminance + rightLuminance) / (2.0 * targetLuminance)) * target;
+}

package/Source/Shaders/Builtin/Functions/multiplyWithColorBalance.js

@@ -0,0 +1,20 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "/**\n\
+ * DOC_TBA\n\
+ *\n\
+ * @name czm_multiplyWithColorBalance\n\
+ * @glslFunction\n\
+ */\n\
+vec3 czm_multiplyWithColorBalance(vec3 left, vec3 right)\n\
+{\n\
+    // Algorithm from Chapter 10 of Graphics Shaders.\n\
+    const vec3 W = vec3(0.2125, 0.7154, 0.0721);\n\
+    \n\
+    vec3 target = left * right;\n\
+    float leftLuminance = dot(left, W);\n\
+    float rightLuminance = dot(right, W);\n\
+    float targetLuminance = dot(target, W);\n\
+    \n\
+    return ((leftLuminance + rightLuminance) / (2.0 * targetLuminance)) * target;\n\
+}\n\
+";

package/Source/Shaders/Builtin/Functions/nearFarScalar.glsl

@@ -0,0 +1,26 @@
+/**
+ * Computes a value that scales with distance.  The scaling is clamped at the near and
+ * far distances, and does not extrapolate.  This function works with the
+ * {@link NearFarScalar} JavaScript class.
+ *
+ * @name czm_nearFarScalar
+ * @glslFunction
+ *
+ * @param {vec4} nearFarScalar A vector with 4 components: Near distance (x), Near value (y), Far distance (z), Far value (w).
+ * @param {float} cameraDistSq The square of the current distance from the camera.
+ *
+ * @returns {float} The value at this distance.
+ */
+float czm_nearFarScalar(vec4 nearFarScalar, float cameraDistSq)
+{
+    float valueAtMin = nearFarScalar.y;
+    float valueAtMax = nearFarScalar.w;
+    float nearDistanceSq = nearFarScalar.x * nearFarScalar.x;
+    float farDistanceSq = nearFarScalar.z * nearFarScalar.z;
+
+    float t = (cameraDistSq - nearDistanceSq) / (farDistanceSq - nearDistanceSq);
+
+    t = pow(clamp(t, 0.0, 1.0), 0.2);
+
+    return mix(valueAtMin, valueAtMax, t);
+}

package/Source/Shaders/Builtin/Functions/nearFarScalar.js

@@ -0,0 +1,28 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "/**\n\
+ * Computes a value that scales with distance.  The scaling is clamped at the near and\n\
+ * far distances, and does not extrapolate.  This function works with the\n\
+ * {@link NearFarScalar} JavaScript class.\n\
+ *\n\
+ * @name czm_nearFarScalar\n\
+ * @glslFunction\n\
+ *\n\
+ * @param {vec4} nearFarScalar A vector with 4 components: Near distance (x), Near value (y), Far distance (z), Far value (w).\n\
+ * @param {float} cameraDistSq The square of the current distance from the camera.\n\
+ *\n\
+ * @returns {float} The value at this distance.\n\
+ */\n\
+float czm_nearFarScalar(vec4 nearFarScalar, float cameraDistSq)\n\
+{\n\
+    float valueAtMin = nearFarScalar.y;\n\
+    float valueAtMax = nearFarScalar.w;\n\
+    float nearDistanceSq = nearFarScalar.x * nearFarScalar.x;\n\
+    float farDistanceSq = nearFarScalar.z * nearFarScalar.z;\n\
+\n\
+    float t = (cameraDistSq - nearDistanceSq) / (farDistanceSq - nearDistanceSq);\n\
+\n\
+    t = pow(clamp(t, 0.0, 1.0), 0.2);\n\
+\n\
+    return mix(valueAtMin, valueAtMax, t);\n\
+}\n\
+";

package/Source/Shaders/Builtin/Functions/octDecode.glsl

@@ -0,0 +1,83 @@
+ /**
+  * Decodes a unit-length vector in 'oct' encoding to a normalized 3-component Cartesian vector.
+  * The 'oct' encoding is described in "A Survey of Efficient Representations of Independent Unit Vectors",
+  * Cigolle et al 2014: http://jcgt.org/published/0003/02/01/
+  *
+  * @name czm_octDecode
+  * @param {vec2} encoded The oct-encoded, unit-length vector
+  * @param {float} range The maximum value of the SNORM range. The encoded vector is stored in log2(rangeMax+1) bits.
+  * @returns {vec3} The decoded and normalized vector
+  */
+  vec3 czm_octDecode(vec2 encoded, float range)
+  {
+      if (encoded.x == 0.0 && encoded.y == 0.0) {
+          return vec3(0.0, 0.0, 0.0);
+      }
+
+     encoded = encoded / range * 2.0 - 1.0;
+     vec3 v = vec3(encoded.x, encoded.y, 1.0 - abs(encoded.x) - abs(encoded.y));
+     if (v.z < 0.0)
+     {
+         v.xy = (1.0 - abs(v.yx)) * czm_signNotZero(v.xy);
+     }
+
+     return normalize(v);
+  }
+
+/**
+ * Decodes a unit-length vector in 'oct' encoding to a normalized 3-component Cartesian vector.
+ * The 'oct' encoding is described in "A Survey of Efficient Representations of Independent Unit Vectors",
+ * Cigolle et al 2014: http://jcgt.org/published/0003/02/01/
+ *
+ * @name czm_octDecode
+ * @param {vec2} encoded The oct-encoded, unit-length vector
+ * @returns {vec3} The decoded and normalized vector
+ */
+ vec3 czm_octDecode(vec2 encoded)
+ {
+    return czm_octDecode(encoded, 255.0);
+ }
+
+ /**
+ * Decodes a unit-length vector in 'oct' encoding packed into a floating-point number to a normalized 3-component Cartesian vector.
+ * The 'oct' encoding is described in "A Survey of Efficient Representations of Independent Unit Vectors",
+ * Cigolle et al 2014: http://jcgt.org/published/0003/02/01/
+ *
+ * @name czm_octDecode
+ * @param {float} encoded The oct-encoded, unit-length vector
+ * @returns {vec3} The decoded and normalized vector
+ */
+ vec3 czm_octDecode(float encoded)
+ {
+    float temp = encoded / 256.0;
+    float x = floor(temp);
+    float y = (temp - x) * 256.0;
+    return czm_octDecode(vec2(x, y));
+ }
+
+/**
+ * Decodes three unit-length vectors in 'oct' encoding packed into two floating-point numbers to normalized 3-component Cartesian vectors.
+ * The 'oct' encoding is described in "A Survey of Efficient Representations of Independent Unit Vectors",
+ * Cigolle et al 2014: http://jcgt.org/published/0003/02/01/
+ *
+ * @name czm_octDecode
+ * @param {vec2} encoded The packed oct-encoded, unit-length vectors.
+ * @param {vec3} vector1 One decoded and normalized vector.
+ * @param {vec3} vector2 One decoded and normalized vector.
+ * @param {vec3} vector3 One decoded and normalized vector.
+ */
+  void czm_octDecode(vec2 encoded, out vec3 vector1, out vec3 vector2, out vec3 vector3)
+ {
+    float temp = encoded.x / 65536.0;
+    float x = floor(temp);
+    float encodedFloat1 = (temp - x) * 65536.0;
+
+    temp = encoded.y / 65536.0;
+    float y = floor(temp);
+    float encodedFloat2 = (temp - y) * 65536.0;
+
+    vector1 = czm_octDecode(encodedFloat1);
+    vector2 = czm_octDecode(encodedFloat2);
+    vector3 = czm_octDecode(vec2(x, y));
+ }
+

package/Source/Shaders/Builtin/Functions/octDecode.js

@@ -0,0 +1,85 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default " /**\n\
+  * Decodes a unit-length vector in 'oct' encoding to a normalized 3-component Cartesian vector.\n\
+  * The 'oct' encoding is described in \"A Survey of Efficient Representations of Independent Unit Vectors\",\n\
+  * Cigolle et al 2014: http://jcgt.org/published/0003/02/01/\n\
+  *\n\
+  * @name czm_octDecode\n\
+  * @param {vec2} encoded The oct-encoded, unit-length vector\n\
+  * @param {float} range The maximum value of the SNORM range. The encoded vector is stored in log2(rangeMax+1) bits.\n\
+  * @returns {vec3} The decoded and normalized vector\n\
+  */\n\
+  vec3 czm_octDecode(vec2 encoded, float range)\n\
+  {\n\
+      if (encoded.x == 0.0 && encoded.y == 0.0) {\n\
+          return vec3(0.0, 0.0, 0.0);\n\
+      }\n\
+\n\
+     encoded = encoded / range * 2.0 - 1.0;\n\
+     vec3 v = vec3(encoded.x, encoded.y, 1.0 - abs(encoded.x) - abs(encoded.y));\n\
+     if (v.z < 0.0)\n\
+     {\n\
+         v.xy = (1.0 - abs(v.yx)) * czm_signNotZero(v.xy);\n\
+     }\n\
+\n\
+     return normalize(v);\n\
+  }\n\
+\n\
+/**\n\
+ * Decodes a unit-length vector in 'oct' encoding to a normalized 3-component Cartesian vector.\n\
+ * The 'oct' encoding is described in \"A Survey of Efficient Representations of Independent Unit Vectors\",\n\
+ * Cigolle et al 2014: http://jcgt.org/published/0003/02/01/\n\
+ *\n\
+ * @name czm_octDecode\n\
+ * @param {vec2} encoded The oct-encoded, unit-length vector\n\
+ * @returns {vec3} The decoded and normalized vector\n\
+ */\n\
+ vec3 czm_octDecode(vec2 encoded)\n\
+ {\n\
+    return czm_octDecode(encoded, 255.0);\n\
+ }\n\
+\n\
+ /**\n\
+ * Decodes a unit-length vector in 'oct' encoding packed into a floating-point number to a normalized 3-component Cartesian vector.\n\
+ * The 'oct' encoding is described in \"A Survey of Efficient Representations of Independent Unit Vectors\",\n\
+ * Cigolle et al 2014: http://jcgt.org/published/0003/02/01/\n\
+ *\n\
+ * @name czm_octDecode\n\
+ * @param {float} encoded The oct-encoded, unit-length vector\n\
+ * @returns {vec3} The decoded and normalized vector\n\
+ */\n\
+ vec3 czm_octDecode(float encoded)\n\
+ {\n\
+    float temp = encoded / 256.0;\n\
+    float x = floor(temp);\n\
+    float y = (temp - x) * 256.0;\n\
+    return czm_octDecode(vec2(x, y));\n\
+ }\n\
+\n\
+/**\n\
+ * Decodes three unit-length vectors in 'oct' encoding packed into two floating-point numbers to normalized 3-component Cartesian vectors.\n\
+ * The 'oct' encoding is described in \"A Survey of Efficient Representations of Independent Unit Vectors\",\n\
+ * Cigolle et al 2014: http://jcgt.org/published/0003/02/01/\n\
+ *\n\
+ * @name czm_octDecode\n\
+ * @param {vec2} encoded The packed oct-encoded, unit-length vectors.\n\
+ * @param {vec3} vector1 One decoded and normalized vector.\n\
+ * @param {vec3} vector2 One decoded and normalized vector.\n\
+ * @param {vec3} vector3 One decoded and normalized vector.\n\
+ */\n\
+  void czm_octDecode(vec2 encoded, out vec3 vector1, out vec3 vector2, out vec3 vector3)\n\
+ {\n\
+    float temp = encoded.x / 65536.0;\n\
+    float x = floor(temp);\n\
+    float encodedFloat1 = (temp - x) * 65536.0;\n\
+\n\
+    temp = encoded.y / 65536.0;\n\
+    float y = floor(temp);\n\
+    float encodedFloat2 = (temp - y) * 65536.0;\n\
+\n\
+    vector1 = czm_octDecode(encodedFloat1);\n\
+    vector2 = czm_octDecode(encodedFloat2);\n\
+    vector3 = czm_octDecode(vec2(x, y));\n\
+ }\n\
+\n\
+";

package/Source/Shaders/Builtin/Functions/packDepth.glsl

@@ -0,0 +1,18 @@
+/**
+ * Packs a depth value into a vec4 that can be represented by unsigned bytes.
+ *
+ * @name czm_packDepth
+ * @glslFunction
+ *
+ * @param {float} depth The floating-point depth.
+ * @returns {vec4} The packed depth.
+ */
+vec4 czm_packDepth(float depth)
+{
+    // See Aras Pranckevičius' post Encoding Floats to RGBA
+    // http://aras-p.info/blog/2009/07/30/encoding-floats-to-rgba-the-final/
+    vec4 enc = vec4(1.0, 255.0, 65025.0, 16581375.0) * depth;
+    enc = fract(enc);
+    enc -= enc.yzww * vec4(1.0 / 255.0, 1.0 / 255.0, 1.0 / 255.0, 0.0);
+    return enc;
+}

package/Source/Shaders/Builtin/Functions/packDepth.js

@@ -0,0 +1,20 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "/**\n\
+ * Packs a depth value into a vec4 that can be represented by unsigned bytes.\n\
+ *\n\
+ * @name czm_packDepth\n\
+ * @glslFunction\n\
+ *\n\
+ * @param {float} depth The floating-point depth.\n\
+ * @returns {vec4} The packed depth.\n\
+ */\n\
+vec4 czm_packDepth(float depth)\n\
+{\n\
+    // See Aras Pranckevičius' post Encoding Floats to RGBA\n\
+    // http://aras-p.info/blog/2009/07/30/encoding-floats-to-rgba-the-final/\n\
+    vec4 enc = vec4(1.0, 255.0, 65025.0, 16581375.0) * depth;\n\
+    enc = fract(enc);\n\
+    enc -= enc.yzww * vec4(1.0 / 255.0, 1.0 / 255.0, 1.0 / 255.0, 0.0);\n\
+    return enc;\n\
+}\n\
+";

package/Source/Shaders/Builtin/Functions/pbrLighting.glsl

@@ -0,0 +1,164 @@
+vec3 lambertianDiffuse(vec3 diffuseColor)
+{
+    return diffuseColor / czm_pi;
+}
+
+vec3 fresnelSchlick2(vec3 f0, vec3 f90, float VdotH)
+{
+    float versine = 1.0 - VdotH;
+    // pow(versine, 5.0) is slow. See https://stackoverflow.com/a/68793086/10082269
+    float versineSquared = versine * versine;
+    return f0 + (f90 - f0) * versineSquared * versineSquared * versine;
+}
+
+#ifdef USE_ANISOTROPY
+/**
+ * @param {float} bitangentRoughness Material roughness (along the anisotropy bitangent)
+ * @param {float} tangentialRoughness Anisotropic roughness (along the anisotropy tangent)
+ * @param {vec3} lightDirection The direction from the fragment to the light source, transformed to tangent-bitangent-normal coordinates
+ * @param {vec3} viewDirection The direction from the fragment to the camera, transformed to tangent-bitangent-normal coordinates
+ */
+float smithVisibilityGGX_anisotropic(float bitangentRoughness, float tangentialRoughness, vec3 lightDirection, vec3 viewDirection)
+{
+    vec3 roughnessScale = vec3(tangentialRoughness, bitangentRoughness, 1.0);
+    float GGXV = lightDirection.z * length(roughnessScale * viewDirection);
+    float GGXL = viewDirection.z * length(roughnessScale * lightDirection);
+    float v = 0.5 / (GGXV + GGXL);
+    return clamp(v, 0.0, 1.0);
+}
+
+/**
+ * @param {float} bitangentRoughness Material roughness (along the anisotropy bitangent)
+ * @param {float} tangentialRoughness Anisotropic roughness (along the anisotropy tangent)
+ * @param {vec3} halfwayDirection The unit vector halfway between light and view directions, transformed to tangent-bitangent-normal coordinates
+ */
+float GGX_anisotropic(float bitangentRoughness, float tangentialRoughness, vec3 halfwayDirection)
+{
+    float roughnessSquared = bitangentRoughness * tangentialRoughness;
+    vec3 f = halfwayDirection * vec3(bitangentRoughness, tangentialRoughness, roughnessSquared);
+    float w2 = roughnessSquared / dot(f, f);
+    return roughnessSquared * w2 * w2 / czm_pi;
+}
+#endif
+
+/**
+ * Estimate the geometric self-shadowing of the microfacets in a surface,
+ * using the Smith Joint GGX visibility function.
+ * Note: Vis = G / (4 * NdotL * NdotV)
+ * see Eric Heitz. 2014. Understanding the Masking-Shadowing Function in Microfacet-Based BRDFs. Journal of Computer Graphics Techniques, 3
+ * see Real-Time Rendering. Page 331 to 336.
+ * see https://google.github.io/filament/Filament.md.html#materialsystem/specularbrdf/geometricshadowing(specularg)
+ *
+ * @param {float} alphaRoughness The roughness of the material, expressed as the square of perceptual roughness.
+ * @param {float} NdotL The cosine of the angle between the surface normal and the direction to the light source.
+ * @param {float} NdotV The cosine of the angle between the surface normal and the direction to the camera.
+ */
+float smithVisibilityGGX(float alphaRoughness, float NdotL, float NdotV)
+{
+    float alphaRoughnessSq = alphaRoughness * alphaRoughness;
+
+    float GGXV = NdotL * sqrt(NdotV * NdotV * (1.0 - alphaRoughnessSq) + alphaRoughnessSq);
+    float GGXL = NdotV * sqrt(NdotL * NdotL * (1.0 - alphaRoughnessSq) + alphaRoughnessSq);
+
+    float GGX = GGXV + GGXL;
+    if (GGX > 0.0)
+    {
+        return 0.5 / GGX;
+    }
+    return 0.0;
+}
+
+/**
+ * Estimate the fraction of the microfacets in a surface that are aligned with 
+ * the halfway vector, which is aligned halfway between the directions from
+ * the fragment to the camera and from the fragment to the light source.
+ *
+ * @param {float} alphaRoughness The roughness of the material, expressed as the square of perceptual roughness.
+ * @param {float} NdotH The cosine of the angle between the surface normal and the halfway vector.
+ * @return {float} The fraction of microfacets aligned to the halfway vector.
+ */
+float GGX(float alphaRoughness, float NdotH)
+{
+    float alphaRoughnessSquared = alphaRoughness * alphaRoughness;
+    float f = (NdotH * alphaRoughnessSquared - NdotH) * NdotH + 1.0;
+    return alphaRoughnessSquared / (czm_pi * f * f);
+}
+
+/**
+ * Compute the strength of the specular reflection due to direct lighting.
+ *
+ * @param {vec3} normal The surface normal.
+ * @param {vec3} lightDirection The unit vector pointing from the fragment to the light source.
+ * @param {vec3} viewDirection The unit vector pointing from the fragment to the camera.
+ * @param {vec3} halfwayDirection The unit vector pointing from the fragment to halfway between the light source and the camera.
+ * @param {float} alphaRoughness The roughness of the material, expressed as the square of perceptual roughness.
+ * @return {float} The strength of the specular reflection.
+ */
+float computeDirectSpecularStrength(vec3 normal, vec3 lightDirection, vec3 viewDirection, vec3 halfwayDirection, float alphaRoughness)
+{
+    float NdotL = clamp(dot(normal, lightDirection), 0.0, 1.0);
+    float NdotV = clamp(dot(normal, viewDirection), 0.0, 1.0);
+    float G = smithVisibilityGGX(alphaRoughness, NdotL, NdotV);
+    float NdotH = clamp(dot(normal, halfwayDirection), 0.0, 1.0);
+    float D = GGX(alphaRoughness, NdotH);
+    return G * D;
+}
+
+/**
+ * Compute the diffuse and specular contributions using physically based
+ * rendering. This function only handles direct lighting.
+ * <p>
+ * This function only handles the lighting calculations. Metallic/roughness
+ * and specular/glossy must be handled separately. See {@MaterialStageFS}
+ * </p>
+ *
+ * @name czm_pbrLighting
+ * @glslFunction
+ *
+ * @param {vec3} viewDirectionEC Unit vector pointing from the fragment to the eye position
+ * @param {vec3} normalEC The surface normal in eye coordinates
+ * @param {vec3} lightDirectionEC Unit vector pointing to the light source in eye coordinates.
+ * @param {czm_modelMaterial} The material properties.
+ * @return {vec3} The computed HDR color
+ */
+vec3 czm_pbrLighting(vec3 viewDirectionEC, vec3 normalEC, vec3 lightDirectionEC, czm_modelMaterial material)
+{
+    vec3 halfwayDirectionEC = normalize(viewDirectionEC + lightDirectionEC);
+    float VdotH = clamp(dot(viewDirectionEC, halfwayDirectionEC), 0.0, 1.0);
+    float NdotL = clamp(dot(normalEC, lightDirectionEC), 0.001, 1.0);
+
+    vec3 f0 = material.specular;
+    float reflectance = czm_maximumComponent(f0);
+    // Typical dielectrics will have reflectance 0.04, so f90 will be 1.0.
+    // In this case, at grazing angle, all incident energy is reflected.
+    vec3 f90 = vec3(clamp(reflectance * 25.0, 0.0, 1.0));
+    vec3 F = fresnelSchlick2(f0, f90, VdotH);
+
+    #if defined(USE_SPECULAR)
+        F *= material.specularWeight;
+    #endif
+
+    float alphaRoughness = material.roughness * material.roughness;
+    #ifdef USE_ANISOTROPY
+        mat3 tbn = mat3(material.anisotropicT, material.anisotropicB, normalEC);
+        vec3 lightDirection = lightDirectionEC * tbn;
+        vec3 viewDirection = viewDirectionEC * tbn;
+        vec3 halfwayDirection = halfwayDirectionEC * tbn;
+        float anisotropyStrength = material.anisotropyStrength;
+        float tangentialRoughness = mix(alphaRoughness, 1.0, anisotropyStrength * anisotropyStrength);
+        float bitangentRoughness = clamp(alphaRoughness, 0.001, 1.0);
+        float G = smithVisibilityGGX_anisotropic(bitangentRoughness, tangentialRoughness, lightDirection, viewDirection);
+        float D = GGX_anisotropic(bitangentRoughness, tangentialRoughness, halfwayDirection);
+        vec3 specularContribution = F * G * D;
+    #else
+        float specularStrength = computeDirectSpecularStrength(normalEC, lightDirectionEC, viewDirectionEC, halfwayDirectionEC, alphaRoughness);
+        vec3 specularContribution = F * specularStrength;
+    #endif
+
+    vec3 diffuseColor = material.diffuse;
+    // F here represents the specular contribution
+    vec3 diffuseContribution = (1.0 - F) * lambertianDiffuse(diffuseColor);
+
+    // Lo = (diffuse + specular) * Li * NdotL
+    return (diffuseContribution + specularContribution) * NdotL;
+}

package/Source/Shaders/Builtin/Functions/pbrLighting.js

@@ -0,0 +1,166 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "vec3 lambertianDiffuse(vec3 diffuseColor)\n\
+{\n\
+    return diffuseColor / czm_pi;\n\
+}\n\
+\n\
+vec3 fresnelSchlick2(vec3 f0, vec3 f90, float VdotH)\n\
+{\n\
+    float versine = 1.0 - VdotH;\n\
+    // pow(versine, 5.0) is slow. See https://stackoverflow.com/a/68793086/10082269\n\
+    float versineSquared = versine * versine;\n\
+    return f0 + (f90 - f0) * versineSquared * versineSquared * versine;\n\
+}\n\
+\n\
+#ifdef USE_ANISOTROPY\n\
+/**\n\
+ * @param {float} bitangentRoughness Material roughness (along the anisotropy bitangent)\n\
+ * @param {float} tangentialRoughness Anisotropic roughness (along the anisotropy tangent)\n\
+ * @param {vec3} lightDirection The direction from the fragment to the light source, transformed to tangent-bitangent-normal coordinates\n\
+ * @param {vec3} viewDirection The direction from the fragment to the camera, transformed to tangent-bitangent-normal coordinates\n\
+ */\n\
+float smithVisibilityGGX_anisotropic(float bitangentRoughness, float tangentialRoughness, vec3 lightDirection, vec3 viewDirection)\n\
+{\n\
+    vec3 roughnessScale = vec3(tangentialRoughness, bitangentRoughness, 1.0);\n\
+    float GGXV = lightDirection.z * length(roughnessScale * viewDirection);\n\
+    float GGXL = viewDirection.z * length(roughnessScale * lightDirection);\n\
+    float v = 0.5 / (GGXV + GGXL);\n\
+    return clamp(v, 0.0, 1.0);\n\
+}\n\
+\n\
+/**\n\
+ * @param {float} bitangentRoughness Material roughness (along the anisotropy bitangent)\n\
+ * @param {float} tangentialRoughness Anisotropic roughness (along the anisotropy tangent)\n\
+ * @param {vec3} halfwayDirection The unit vector halfway between light and view directions, transformed to tangent-bitangent-normal coordinates\n\
+ */\n\
+float GGX_anisotropic(float bitangentRoughness, float tangentialRoughness, vec3 halfwayDirection)\n\
+{\n\
+    float roughnessSquared = bitangentRoughness * tangentialRoughness;\n\
+    vec3 f = halfwayDirection * vec3(bitangentRoughness, tangentialRoughness, roughnessSquared);\n\
+    float w2 = roughnessSquared / dot(f, f);\n\
+    return roughnessSquared * w2 * w2 / czm_pi;\n\
+}\n\
+#endif\n\
+\n\
+/**\n\
+ * Estimate the geometric self-shadowing of the microfacets in a surface,\n\
+ * using the Smith Joint GGX visibility function.\n\
+ * Note: Vis = G / (4 * NdotL * NdotV)\n\
+ * see Eric Heitz. 2014. Understanding the Masking-Shadowing Function in Microfacet-Based BRDFs. Journal of Computer Graphics Techniques, 3\n\
+ * see Real-Time Rendering. Page 331 to 336.\n\
+ * see https://google.github.io/filament/Filament.md.html#materialsystem/specularbrdf/geometricshadowing(specularg)\n\
+ *\n\
+ * @param {float} alphaRoughness The roughness of the material, expressed as the square of perceptual roughness.\n\
+ * @param {float} NdotL The cosine of the angle between the surface normal and the direction to the light source.\n\
+ * @param {float} NdotV The cosine of the angle between the surface normal and the direction to the camera.\n\
+ */\n\
+float smithVisibilityGGX(float alphaRoughness, float NdotL, float NdotV)\n\
+{\n\
+    float alphaRoughnessSq = alphaRoughness * alphaRoughness;\n\
+\n\
+    float GGXV = NdotL * sqrt(NdotV * NdotV * (1.0 - alphaRoughnessSq) + alphaRoughnessSq);\n\
+    float GGXL = NdotV * sqrt(NdotL * NdotL * (1.0 - alphaRoughnessSq) + alphaRoughnessSq);\n\
+\n\
+    float GGX = GGXV + GGXL;\n\
+    if (GGX > 0.0)\n\
+    {\n\
+        return 0.5 / GGX;\n\
+    }\n\
+    return 0.0;\n\
+}\n\
+\n\
+/**\n\
+ * Estimate the fraction of the microfacets in a surface that are aligned with \n\
+ * the halfway vector, which is aligned halfway between the directions from\n\
+ * the fragment to the camera and from the fragment to the light source.\n\
+ *\n\
+ * @param {float} alphaRoughness The roughness of the material, expressed as the square of perceptual roughness.\n\
+ * @param {float} NdotH The cosine of the angle between the surface normal and the halfway vector.\n\
+ * @return {float} The fraction of microfacets aligned to the halfway vector.\n\
+ */\n\
+float GGX(float alphaRoughness, float NdotH)\n\
+{\n\
+    float alphaRoughnessSquared = alphaRoughness * alphaRoughness;\n\
+    float f = (NdotH * alphaRoughnessSquared - NdotH) * NdotH + 1.0;\n\
+    return alphaRoughnessSquared / (czm_pi * f * f);\n\
+}\n\
+\n\
+/**\n\
+ * Compute the strength of the specular reflection due to direct lighting.\n\
+ *\n\
+ * @param {vec3} normal The surface normal.\n\
+ * @param {vec3} lightDirection The unit vector pointing from the fragment to the light source.\n\
+ * @param {vec3} viewDirection The unit vector pointing from the fragment to the camera.\n\
+ * @param {vec3} halfwayDirection The unit vector pointing from the fragment to halfway between the light source and the camera.\n\
+ * @param {float} alphaRoughness The roughness of the material, expressed as the square of perceptual roughness.\n\
+ * @return {float} The strength of the specular reflection.\n\
+ */\n\
+float computeDirectSpecularStrength(vec3 normal, vec3 lightDirection, vec3 viewDirection, vec3 halfwayDirection, float alphaRoughness)\n\
+{\n\
+    float NdotL = clamp(dot(normal, lightDirection), 0.0, 1.0);\n\
+    float NdotV = clamp(dot(normal, viewDirection), 0.0, 1.0);\n\
+    float G = smithVisibilityGGX(alphaRoughness, NdotL, NdotV);\n\
+    float NdotH = clamp(dot(normal, halfwayDirection), 0.0, 1.0);\n\
+    float D = GGX(alphaRoughness, NdotH);\n\
+    return G * D;\n\
+}\n\
+\n\
+/**\n\
+ * Compute the diffuse and specular contributions using physically based\n\
+ * rendering. This function only handles direct lighting.\n\
+ * <p>\n\
+ * This function only handles the lighting calculations. Metallic/roughness\n\
+ * and specular/glossy must be handled separately. See {@MaterialStageFS}\n\
+ * </p>\n\
+ *\n\
+ * @name czm_pbrLighting\n\
+ * @glslFunction\n\
+ *\n\
+ * @param {vec3} viewDirectionEC Unit vector pointing from the fragment to the eye position\n\
+ * @param {vec3} normalEC The surface normal in eye coordinates\n\
+ * @param {vec3} lightDirectionEC Unit vector pointing to the light source in eye coordinates.\n\
+ * @param {czm_modelMaterial} The material properties.\n\
+ * @return {vec3} The computed HDR color\n\
+ */\n\
+vec3 czm_pbrLighting(vec3 viewDirectionEC, vec3 normalEC, vec3 lightDirectionEC, czm_modelMaterial material)\n\
+{\n\
+    vec3 halfwayDirectionEC = normalize(viewDirectionEC + lightDirectionEC);\n\
+    float VdotH = clamp(dot(viewDirectionEC, halfwayDirectionEC), 0.0, 1.0);\n\
+    float NdotL = clamp(dot(normalEC, lightDirectionEC), 0.001, 1.0);\n\
+\n\
+    vec3 f0 = material.specular;\n\
+    float reflectance = czm_maximumComponent(f0);\n\
+    // Typical dielectrics will have reflectance 0.04, so f90 will be 1.0.\n\
+    // In this case, at grazing angle, all incident energy is reflected.\n\
+    vec3 f90 = vec3(clamp(reflectance * 25.0, 0.0, 1.0));\n\
+    vec3 F = fresnelSchlick2(f0, f90, VdotH);\n\
+\n\
+    #if defined(USE_SPECULAR)\n\
+        F *= material.specularWeight;\n\
+    #endif\n\
+\n\
+    float alphaRoughness = material.roughness * material.roughness;\n\
+    #ifdef USE_ANISOTROPY\n\
+        mat3 tbn = mat3(material.anisotropicT, material.anisotropicB, normalEC);\n\
+        vec3 lightDirection = lightDirectionEC * tbn;\n\
+        vec3 viewDirection = viewDirectionEC * tbn;\n\
+        vec3 halfwayDirection = halfwayDirectionEC * tbn;\n\
+        float anisotropyStrength = material.anisotropyStrength;\n\
+        float tangentialRoughness = mix(alphaRoughness, 1.0, anisotropyStrength * anisotropyStrength);\n\
+        float bitangentRoughness = clamp(alphaRoughness, 0.001, 1.0);\n\
+        float G = smithVisibilityGGX_anisotropic(bitangentRoughness, tangentialRoughness, lightDirection, viewDirection);\n\
+        float D = GGX_anisotropic(bitangentRoughness, tangentialRoughness, halfwayDirection);\n\
+        vec3 specularContribution = F * G * D;\n\
+    #else\n\
+        float specularStrength = computeDirectSpecularStrength(normalEC, lightDirectionEC, viewDirectionEC, halfwayDirectionEC, alphaRoughness);\n\
+        vec3 specularContribution = F * specularStrength;\n\
+    #endif\n\
+\n\
+    vec3 diffuseColor = material.diffuse;\n\
+    // F here represents the specular contribution\n\
+    vec3 diffuseContribution = (1.0 - F) * lambertianDiffuse(diffuseColor);\n\
+\n\
+    // Lo = (diffuse + specular) * Li * NdotL\n\
+    return (diffuseContribution + specularContribution) * NdotL;\n\
+}\n\
+";