@cesium/engine 9.0.0 → 9.2.0

package/Source/Scene/ResourceCacheKey.js

@@ -20,8 +20,7 @@ function getExternalResourceCacheKey(resource) {
 }
 
 function getBufferViewCacheKey(bufferView) {
-  let byteOffset = bufferView.byteOffset;
-  let byteLength = bufferView.byteLength;
+  let { byteOffset, byteLength } = bufferView;
 
   if (hasExtension(bufferView, "EXT_meshopt_compression")) {
     const meshopt = bufferView.extensions.EXT_meshopt_compression;
@@ -34,16 +33,10 @@ function getBufferViewCacheKey(bufferView) {
 
 function getAccessorCacheKey(accessor, bufferView) {
   const byteOffset = bufferView.byteOffset + accessor.byteOffset;
-  const componentType = accessor.componentType;
-  const type = accessor.type;
-  const count = accessor.count;
+  const { componentType, type, count } = accessor;
   return `${byteOffset}-${componentType}-${type}-${count}`;
 }
 
-function getExternalBufferCacheKey(resource) {
-  return getExternalResourceCacheKey(resource);
-}
-
 function getEmbeddedBufferCacheKey(parentResource, bufferId) {
   const parentCacheKey = getExternalResourceCacheKey(parentResource);
   return `${parentCacheKey}-buffer-id-${bufferId}`;
@@ -54,7 +47,7 @@ function getBufferCacheKey(buffer, bufferId, gltfResource, baseResource) {
     const resource = baseResource.getDerivedResource({
       url: buffer.uri,
     });
-    return getExternalBufferCacheKey(resource);
+    return getExternalResourceCacheKey(resource);
   }
 
   return getEmbeddedBufferCacheKey(gltfResource, bufferId);
@@ -128,8 +121,7 @@ function getSamplerCacheKey(gltf, textureInfo) {
  * @private
  */
 ResourceCacheKey.getSchemaCacheKey = function (options) {
-  const schema = options.schema;
-  const resource = options.resource;
+  const { schema, resource } = options;
 
   //>>includeStart('debug', pragmas.debug);
   if (defined(schema) === defined(resource)) {
@@ -157,13 +149,13 @@ ResourceCacheKey.getSchemaCacheKey = function (options) {
  */
 ResourceCacheKey.getExternalBufferCacheKey = function (options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
-  const resource = options.resource;
+  const { resource } = options;
 
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("options.resource", resource);
   //>>includeEnd('debug');
 
-  return `external-buffer:${getExternalBufferCacheKey(resource)}`;
+  return `external-buffer:${getExternalResourceCacheKey(resource)}`;
 };
 
 /**
@@ -178,8 +170,7 @@ ResourceCacheKey.getExternalBufferCacheKey = function (options) {
  */
 ResourceCacheKey.getEmbeddedBufferCacheKey = function (options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
-  const parentResource = options.parentResource;
-  const bufferId = options.bufferId;
+  const { parentResource, bufferId } = options;
 
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("options.parentResource", parentResource);
@@ -203,7 +194,7 @@ ResourceCacheKey.getEmbeddedBufferCacheKey = function (options) {
  */
 ResourceCacheKey.getGltfCacheKey = function (options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
-  const gltfResource = options.gltfResource;
+  const { gltfResource } = options;
 
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("options.gltfResource", gltfResource);
@@ -226,10 +217,7 @@ ResourceCacheKey.getGltfCacheKey = function (options) {
  */
 ResourceCacheKey.getBufferViewCacheKey = function (options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
-  const gltf = options.gltf;
-  const bufferViewId = options.bufferViewId;
-  const gltfResource = options.gltfResource;
-  const baseResource = options.baseResource;
+  const { gltf, bufferViewId, gltfResource, baseResource } = options;
 
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("options.gltf", gltf);
@@ -272,10 +260,7 @@ ResourceCacheKey.getBufferViewCacheKey = function (options) {
  */
 ResourceCacheKey.getDracoCacheKey = function (options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
-  const gltf = options.gltf;
-  const draco = options.draco;
-  const gltfResource = options.gltfResource;
-  const baseResource = options.baseResource;
+  const { gltf, draco, gltfResource, baseResource } = options;
 
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("options.gltf", gltf);
@@ -309,16 +294,18 @@ ResourceCacheKey.getDracoCacheKey = function (options) {
  */
 ResourceCacheKey.getVertexBufferCacheKey = function (options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
-  const gltf = options.gltf;
-  const gltfResource = options.gltfResource;
-  const baseResource = options.baseResource;
-  const frameState = options.frameState;
-  const bufferViewId = options.bufferViewId;
-  const draco = options.draco;
-  const attributeSemantic = options.attributeSemantic;
-  const dequantize = defaultValue(options.dequantize, false);
-  const loadBuffer = defaultValue(options.loadBuffer, false);
-  const loadTypedArray = defaultValue(options.loadTypedArray, false);
+  const {
+    gltf,
+    gltfResource,
+    baseResource,
+    frameState,
+    bufferViewId,
+    draco,
+    attributeSemantic,
+    dequantize = false,
+    loadBuffer = false,
+    loadTypedArray = false,
+  } = options;
 
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("options.gltf", gltf);
@@ -420,14 +407,16 @@ function hasDracoCompression(draco, semantic) {
  */
 ResourceCacheKey.getIndexBufferCacheKey = function (options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
-  const gltf = options.gltf;
-  const accessorId = options.accessorId;
-  const gltfResource = options.gltfResource;
-  const baseResource = options.baseResource;
-  const frameState = options.frameState;
-  const draco = options.draco;
-  const loadBuffer = defaultValue(options.loadBuffer, false);
-  const loadTypedArray = defaultValue(options.loadTypedArray, false);
+  const {
+    gltf,
+    accessorId,
+    gltfResource,
+    baseResource,
+    frameState,
+    draco,
+    loadBuffer = false,
+    loadTypedArray = false,
+  } = options;
 
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("options.gltf", gltf);
@@ -495,10 +484,7 @@ ResourceCacheKey.getIndexBufferCacheKey = function (options) {
  */
 ResourceCacheKey.getImageCacheKey = function (options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
-  const gltf = options.gltf;
-  const imageId = options.imageId;
-  const gltfResource = options.gltfResource;
-  const baseResource = options.baseResource;
+  const { gltf, imageId, gltfResource, baseResource } = options;
 
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("options.gltf", gltf);
@@ -533,12 +519,14 @@ ResourceCacheKey.getImageCacheKey = function (options) {
  */
 ResourceCacheKey.getTextureCacheKey = function (options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
-  const gltf = options.gltf;
-  const textureInfo = options.textureInfo;
-  const gltfResource = options.gltfResource;
-  const baseResource = options.baseResource;
-  const supportedImageFormats = options.supportedImageFormats;
-  const frameState = options.frameState;
+  const {
+    gltf,
+    textureInfo,
+    gltfResource,
+    baseResource,
+    supportedImageFormats,
+    frameState,
+  } = options;
 
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("options.gltf", gltf);

package/Source/Scene/Terrain.js

@@ -83,7 +83,7 @@ Object.defineProperties(Terrain.prototype, {
 
   /**
    * Returns true when the terrain provider has been successfully created. Otherwise, returns false.
-   * @memberof Viewer.prototype
+   * @memberof Terrain.prototype
    *
    * @type {boolean}
    * @readonly
@@ -96,7 +96,7 @@ Object.defineProperties(Terrain.prototype, {
 
   /**
    * The terrain provider providing surface geometry to a globe. Do not use until {@link Terrain.readyEvent} is raised.
-   * @memberof Viewer.prototype
+   * @memberof Terrain.prototype
    *
    * @type {TerrainProvider}
    * @readonly

package/Source/Shaders/Builtin/CzmBuiltins.js

@@ -42,7 +42,6 @@ import czm_material from './Structs/material.js'
 import czm_materialInput from './Structs/materialInput.js'
 import czm_modelMaterial from './Structs/modelMaterial.js'
 import czm_modelVertexOutput from './Structs/modelVertexOutput.js'
-import czm_pbrParameters from './Structs/pbrParameters.js'
 import czm_ray from './Structs/ray.js'
 import czm_raySegment from './Structs/raySegment.js'
 import czm_shadowParameters from './Structs/shadowParameters.js'
@@ -64,6 +63,7 @@ import czm_cascadeColor from './Functions/cascadeColor.js'
 import czm_cascadeDistance from './Functions/cascadeDistance.js'
 import czm_cascadeMatrix from './Functions/cascadeMatrix.js'
 import czm_cascadeWeights from './Functions/cascadeWeights.js'
+import czm_clipPolygons from './Functions/clipPolygons.js'
 import czm_columbusViewMorph from './Functions/columbusViewMorph.js'
 import czm_computeAtmosphereColor from './Functions/computeAtmosphereColor.js'
 import czm_computeGroundAtmosphereScattering from './Functions/computeGroundAtmosphereScattering.js'
@@ -71,7 +71,6 @@ import czm_computePosition from './Functions/computePosition.js'
 import czm_computeScattering from './Functions/computeScattering.js'
 import czm_cosineAndSine from './Functions/cosineAndSine.js'
 import czm_decompressTextureCoordinates from './Functions/decompressTextureCoordinates.js'
-import czm_defaultPbrMaterial from './Functions/defaultPbrMaterial.js'
 import czm_depthClamp from './Functions/depthClamp.js'
 import czm_eastNorthUpToEyeCoordinates from './Functions/eastNorthUpToEyeCoordinates.js'
 import czm_ellipsoidContainsPoint from './Functions/ellipsoidContainsPoint.js'
@@ -96,6 +95,7 @@ import czm_latitudeToWebMercatorFraction from './Functions/latitudeToWebMercator
 import czm_lineDistance from './Functions/lineDistance.js'
 import czm_linearToSrgb from './Functions/linearToSrgb.js'
 import czm_luminance from './Functions/luminance.js'
+import czm_maximumComponent from './Functions/maximumComponent.js'
 import czm_metersPerPixel from './Functions/metersPerPixel.js'
 import czm_modelToWindowCoordinates from './Functions/modelToWindowCoordinates.js'
 import czm_multiplyWithColorBalance from './Functions/multiplyWithColorBalance.js'
@@ -103,8 +103,6 @@ import czm_nearFarScalar from './Functions/nearFarScalar.js'
 import czm_octDecode from './Functions/octDecode.js'
 import czm_packDepth from './Functions/packDepth.js'
 import czm_pbrLighting from './Functions/pbrLighting.js'
-import czm_pbrMetallicRoughnessMaterial from './Functions/pbrMetallicRoughnessMaterial.js'
-import czm_pbrSpecularGlossinessMaterial from './Functions/pbrSpecularGlossinessMaterial.js'
 import czm_phong from './Functions/phong.js'
 import czm_planeDistance from './Functions/planeDistance.js'
 import czm_pointAlongRay from './Functions/pointAlongRay.js'
@@ -127,6 +125,7 @@ import czm_transformPlane from './Functions/transformPlane.js'
 import czm_translateRelativeToEye from './Functions/translateRelativeToEye.js'
 import czm_translucentPhong from './Functions/translucentPhong.js'
 import czm_transpose from './Functions/transpose.js'
+import czm_unpackClippingExtents from './Functions/unpackClippingExtents.js'
 import czm_unpackDepth from './Functions/unpackDepth.js'
 import czm_unpackFloat from './Functions/unpackFloat.js'
 import czm_unpackUint from './Functions/unpackUint.js'
@@ -181,7 +180,6 @@ export default {
     czm_materialInput : czm_materialInput,
     czm_modelMaterial : czm_modelMaterial,
     czm_modelVertexOutput : czm_modelVertexOutput,
-    czm_pbrParameters : czm_pbrParameters,
     czm_ray : czm_ray,
     czm_raySegment : czm_raySegment,
     czm_shadowParameters : czm_shadowParameters,
@@ -203,6 +201,7 @@ export default {
     czm_cascadeDistance : czm_cascadeDistance,
     czm_cascadeMatrix : czm_cascadeMatrix,
     czm_cascadeWeights : czm_cascadeWeights,
+    czm_clipPolygons : czm_clipPolygons,
     czm_columbusViewMorph : czm_columbusViewMorph,
     czm_computeAtmosphereColor : czm_computeAtmosphereColor,
     czm_computeGroundAtmosphereScattering : czm_computeGroundAtmosphereScattering,
@@ -210,7 +209,6 @@ export default {
     czm_computeScattering : czm_computeScattering,
     czm_cosineAndSine : czm_cosineAndSine,
     czm_decompressTextureCoordinates : czm_decompressTextureCoordinates,
-    czm_defaultPbrMaterial : czm_defaultPbrMaterial,
     czm_depthClamp : czm_depthClamp,
     czm_eastNorthUpToEyeCoordinates : czm_eastNorthUpToEyeCoordinates,
     czm_ellipsoidContainsPoint : czm_ellipsoidContainsPoint,
@@ -235,6 +233,7 @@ export default {
     czm_lineDistance : czm_lineDistance,
     czm_linearToSrgb : czm_linearToSrgb,
     czm_luminance : czm_luminance,
+    czm_maximumComponent : czm_maximumComponent,
     czm_metersPerPixel : czm_metersPerPixel,
     czm_modelToWindowCoordinates : czm_modelToWindowCoordinates,
     czm_multiplyWithColorBalance : czm_multiplyWithColorBalance,
@@ -242,8 +241,6 @@ export default {
     czm_octDecode : czm_octDecode,
     czm_packDepth : czm_packDepth,
     czm_pbrLighting : czm_pbrLighting,
-    czm_pbrMetallicRoughnessMaterial : czm_pbrMetallicRoughnessMaterial,
-    czm_pbrSpecularGlossinessMaterial : czm_pbrSpecularGlossinessMaterial,
     czm_phong : czm_phong,
     czm_planeDistance : czm_planeDistance,
     czm_pointAlongRay : czm_pointAlongRay,
@@ -266,6 +263,7 @@ export default {
     czm_translateRelativeToEye : czm_translateRelativeToEye,
     czm_translucentPhong : czm_translucentPhong,
     czm_transpose : czm_transpose,
+    czm_unpackClippingExtents : czm_unpackClippingExtents,
     czm_unpackDepth : czm_unpackDepth,
     czm_unpackFloat : czm_unpackFloat,
     czm_unpackUint : czm_unpackUint,

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

@@ -0,0 +1,37 @@
+float getSignedDistance(vec2 uv, highp sampler2D clippingDistance) {
+    float signedDistance = texture(clippingDistance, uv).r;
+    return (signedDistance - 0.5) * 2.0;
+}
+
+void czm_clipPolygons(highp sampler2D clippingDistance, int extentsLength, vec2 clippingPosition, int regionIndex) {
+    // Position is completely outside of polygons bounds
+    vec2 rectUv = clippingPosition;
+    if (regionIndex < 0 || rectUv.x <= 0.0 || rectUv.y <= 0.0 || rectUv.x >= 1.0 || rectUv.y >= 1.0) {
+        #ifdef CLIPPING_INVERSE 
+            discard;
+        #endif
+        return;
+    }
+
+    vec2 clippingDistanceTextureDimensions = vec2(textureSize(clippingDistance, 0));
+    vec2 sampleOffset = max(1.0 / clippingDistanceTextureDimensions, vec2(0.005));
+    float dimension = float(extentsLength);
+    if (extentsLength > 2) {
+       dimension = ceil(log2(float(extentsLength)));
+    }
+
+    vec2 textureOffset = vec2(mod(float(regionIndex), dimension), floor(float(regionIndex) / dimension)) / dimension;
+    vec2 uv = textureOffset + rectUv / dimension;
+
+    float signedDistance = getSignedDistance(uv, clippingDistance);
+
+    #ifdef CLIPPING_INVERSE
+    if (signedDistance > 0.0)  {
+        discard;
+    }
+    #else
+    if (signedDistance < 0.0)  {
+        discard;
+    }
+    #endif
+}

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

@@ -0,0 +1,39 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "float getSignedDistance(vec2 uv, highp sampler2D clippingDistance) {\n\
+    float signedDistance = texture(clippingDistance, uv).r;\n\
+    return (signedDistance - 0.5) * 2.0;\n\
+}\n\
+\n\
+void czm_clipPolygons(highp sampler2D clippingDistance, int extentsLength, vec2 clippingPosition, int regionIndex) {\n\
+    // Position is completely outside of polygons bounds\n\
+    vec2 rectUv = clippingPosition;\n\
+    if (regionIndex < 0 || rectUv.x <= 0.0 || rectUv.y <= 0.0 || rectUv.x >= 1.0 || rectUv.y >= 1.0) {\n\
+        #ifdef CLIPPING_INVERSE \n\
+            discard;\n\
+        #endif\n\
+        return;\n\
+    }\n\
+\n\
+    vec2 clippingDistanceTextureDimensions = vec2(textureSize(clippingDistance, 0));\n\
+    vec2 sampleOffset = max(1.0 / clippingDistanceTextureDimensions, vec2(0.005));\n\
+    float dimension = float(extentsLength);\n\
+    if (extentsLength > 2) {\n\
+       dimension = ceil(log2(float(extentsLength)));\n\
+    }\n\
+\n\
+    vec2 textureOffset = vec2(mod(float(regionIndex), dimension), floor(float(regionIndex) / dimension)) / dimension;\n\
+    vec2 uv = textureOffset + rectUv / dimension;\n\
+\n\
+    float signedDistance = getSignedDistance(uv, clippingDistance);\n\
+\n\
+    #ifdef CLIPPING_INVERSE\n\
+    if (signedDistance > 0.0)  {\n\
+        discard;\n\
+    }\n\
+    #else\n\
+    if (signedDistance < 0.0)  {\n\
+        discard;\n\
+    }\n\
+    #endif\n\
+}\n\
+";

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

@@ -0,0 +1,21 @@
+/**
+ * Find the maximum component of a vector.
+ *
+ * @name czm_maximumComponent
+ * @glslFunction
+ *
+ * @param {vec2|vec3|vec4} v The input vector.
+ * @returns {float} The value of the largest component.
+ */
+float czm_maximumComponent(vec2 v)
+{
+    return max(v.x, v.y);
+}
+float czm_maximumComponent(vec3 v)
+{
+    return max(max(v.x, v.y), v.z);
+}
+float czm_maximumComponent(vec4 v)
+{
+    return max(max(max(v.x, v.y), v.z), v.w);
+}

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

@@ -0,0 +1,23 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "/**\n\
+ * Find the maximum component of a vector.\n\
+ *\n\
+ * @name czm_maximumComponent\n\
+ * @glslFunction\n\
+ *\n\
+ * @param {vec2|vec3|vec4} v The input vector.\n\
+ * @returns {float} The value of the largest component.\n\
+ */\n\
+float czm_maximumComponent(vec2 v)\n\
+{\n\
+    return max(v.x, v.y);\n\
+}\n\
+float czm_maximumComponent(vec3 v)\n\
+{\n\
+    return max(max(v.x, v.y), v.z);\n\
+}\n\
+float czm_maximumComponent(vec4 v)\n\
+{\n\
+    return max(max(max(v.x, v.y), v.z), v.w);\n\
+}\n\
+";

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

@@ -5,9 +5,42 @@ vec3 lambertianDiffuse(vec3 diffuseColor)
 
 vec3 fresnelSchlick2(vec3 f0, vec3 f90, float VdotH)
 {
-    return f0 + (f90 - f0) * pow(clamp(1.0 - VdotH, 0.0, 1.0), 5.0);
+    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} roughness 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 roughness, float tangentialRoughness, vec3 lightDirection, vec3 viewDirection)
+{
+    vec3 roughnessScale = vec3(tangentialRoughness, roughness, 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} roughness 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 roughness, float tangentialRoughness, vec3 halfwayDirection)
+{
+    float roughnessSquared = roughness * tangentialRoughness;
+    vec3 f = halfwayDirection * vec3(roughness, tangentialRoughness, roughnessSquared);
+    float w2 = roughnessSquared / dot(f, f);
+    return roughnessSquared * w2 * w2 / czm_pi;
+}
+#endif
+
 float smithVisibilityG1(float NdotV, float roughness)
 {
     // this is the k value for direct lighting.
@@ -16,14 +49,34 @@ float smithVisibilityG1(float NdotV, float roughness)
     return NdotV / (NdotV * (1.0 - k) + k);
 }
 
+/**
+ * Estimate the geometric self-shadowing of the microfacets in a surface,
+ * using the Schlick GGX approximation of a Smith visibility function.
+ *
+ * @param {float} roughness The roughness of the material.
+ * @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 roughness, float NdotL, float NdotV)
 {
+    // Avoid divide-by-zero errors
+    NdotL = clamp(NdotL, 0.001, 1.0);
+    NdotV += 0.001;
     return (
         smithVisibilityG1(NdotL, roughness) *
         smithVisibilityG1(NdotV, roughness)
-    );
+    ) / (4.0 * NdotL * NdotV);
 }
 
+/**
+ * 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} roughness The roughness of the material.
+ * @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 roughness, float NdotH)
 {
     float roughnessSquared = roughness * roughness;
@@ -31,69 +84,80 @@ float GGX(float roughness, float NdotH)
     return roughnessSquared / (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} roughness The roughness of the material.
+ * @return {float} The strength of the specular reflection.
+ */
+float computeDirectSpecularStrength(vec3 normal, vec3 lightDirection, vec3 viewDirection, vec3 halfwayDirection, float roughness)
+{
+    float NdotL = dot(normal, lightDirection);
+    float NdotV = abs(dot(normal, viewDirection));
+    float G = smithVisibilityGGX(roughness, NdotL, NdotV);
+    float NdotH = clamp(dot(normal, halfwayDirection), 0.0, 1.0);
+    float D = GGX(roughness, 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 {@czm_pbrMetallicRoughnessMaterial}, {@czm_pbrSpecularGlossinessMaterial} and {@czm_defaultPbrMaterial}
+ * and specular/glossy must be handled separately. See {@MaterialStageFS}
  * </p>
  *
- * @name czm_pbrlighting
+ * @name czm_pbrLighting
  * @glslFunction
  *
- * @param {vec3} positionEC The position of the fragment in eye coordinates
+ * @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 {vec3} lightColorHdr radiance of the light source. This is a HDR value.
- * @param {czm_pbrParameters} The computed PBR parameters.
+ * @param {czm_modelMaterial} The material properties.
  * @return {vec3} The computed HDR color
- *
- * @example
- * czm_pbrParameters pbrParameters = czm_pbrMetallicRoughnessMaterial(
- *  baseColor,
- *  metallic,
- *  roughness
- * );
- * vec3 color = czm_pbrlighting(
- *  positionEC,
- *  normalEC,
- *  lightDirectionEC,
- *  lightColorHdr,
- *  pbrParameters);
  */
-vec3 czm_pbrLighting(
-    vec3 positionEC,
-    vec3 normalEC,
-    vec3 lightDirectionEC,
-    vec3 lightColorHdr,
-    czm_pbrParameters pbrParameters
-)
+vec3 czm_pbrLighting(vec3 viewDirectionEC, vec3 normalEC, vec3 lightDirectionEC, czm_modelMaterial material)
 {
-    vec3 v = -normalize(positionEC);
-    vec3 l = normalize(lightDirectionEC);
-    vec3 h = normalize(v + l);
-    vec3 n = normalEC;
-    float NdotL = clamp(dot(n, l), 0.001, 1.0);
-    float NdotV = abs(dot(n, v)) + 0.001;
-    float NdotH = clamp(dot(n, h), 0.0, 1.0);
-    float LdotH = clamp(dot(l, h), 0.0, 1.0);
-    float VdotH = clamp(dot(v, h), 0.0, 1.0);
+    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 = pbrParameters.f0;
-    float reflectance = max(max(f0.r, f0.g), f0.b);
+    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);
 
-    float alpha = pbrParameters.roughness;
-    float G = smithVisibilityGGX(alpha, NdotL, NdotV);
-    float D = GGX(alpha, NdotH);
-    vec3 specularContribution = F * G * D / (4.0 * NdotL * NdotV);
+    #if defined(USE_SPECULAR)
+        F *= material.specularWeight;
+    #endif
+
+    float alpha = 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(alpha, 1.0, anisotropyStrength * anisotropyStrength);
+        float G = smithVisibilityGGX_anisotropic(alpha, tangentialRoughness, lightDirection, viewDirection);
+        float D = GGX_anisotropic(alpha, tangentialRoughness, halfwayDirection);
+        vec3 specularContribution = F * G * D;
+    #else
+        float specularStrength = computeDirectSpecularStrength(normalEC, lightDirectionEC, viewDirectionEC, halfwayDirectionEC, alpha);
+        vec3 specularContribution = F * specularStrength;
+    #endif
 
-    vec3 diffuseColor = pbrParameters.diffuseColor;
+    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 * lightColorHdr;
+    return (diffuseContribution + specularContribution) * NdotL;
 }