@cesium/engine 9.0.0 → 9.2.0

package/Source/Scene/Model/MaterialPipelineStage.js

@@ -12,15 +12,20 @@ import VertexAttributeSemantic from "../VertexAttributeSemantic.js";
 import LightingModel from "./LightingModel.js";
 import ModelUtility from "./ModelUtility.js";
 
-const Material = ModelComponents.Material;
-const MetallicRoughness = ModelComponents.MetallicRoughness;
-const SpecularGlossiness = ModelComponents.SpecularGlossiness;
+const {
+  Material,
+  MetallicRoughness,
+  SpecularGlossiness,
+  Specular,
+  Clearcoat,
+} = ModelComponents;
 
 /**
  * The material pipeline stage processes textures and other uniforms needed
  * to render a primitive. This handles the following material types:
  * <ul>
  *   <li>Basic glTF materials (PBR metallic roughness model)</li>
+ *   <li>The `KHR_materials_specular` glTF extension</li>
  *   <li>The `KHR_materials_pbrSpecularGlossiness` glTF extension</li>
  *   <li>The `KHR_materials_unlit` glTF extension</li>
  * </ul>
@@ -59,20 +64,19 @@ MaterialPipelineStage.process = function (
   // gltf-pipeline automatically creates a default material so this will always
   // be defined.
   const material = primitive.material;
-  const model = renderResources.model;
+  const { model, uniformMap, shaderBuilder } = renderResources;
 
   // Classification models only use position and feature ID attributes,
   // so textures should be disabled to avoid compile errors.
   const hasClassification = defined(model.classificationType);
   const disableTextures = hasClassification;
 
-  const uniformMap = renderResources.uniformMap;
-  const shaderBuilder = renderResources.shaderBuilder;
-
   // When textures are loaded incrementally, fall back to a default 1x1 texture
-  const defaultTexture = frameState.context.defaultTexture;
-  const defaultNormalTexture = frameState.context.defaultNormalTexture;
-  const defaultEmissiveTexture = frameState.context.defaultEmissiveTexture;
+  const {
+    defaultTexture,
+    defaultNormalTexture,
+    defaultEmissiveTexture,
+  } = frameState.context;
 
   processMaterialUniforms(
     material,
@@ -86,15 +90,51 @@ MaterialPipelineStage.process = function (
 
   if (defined(material.specularGlossiness)) {
     processSpecularGlossinessUniforms(
-      material,
+      material.specularGlossiness,
       uniformMap,
       shaderBuilder,
       defaultTexture,
       disableTextures
     );
   } else {
+    if (
+      defined(material.specular) &&
+      ModelUtility.supportedExtensions.KHR_materials_specular
+    ) {
+      processSpecularUniforms(
+        material.specular,
+        uniformMap,
+        shaderBuilder,
+        defaultTexture,
+        disableTextures
+      );
+    }
+    if (
+      defined(material.anisotropy) &&
+      ModelUtility.supportedExtensions.KHR_materials_anisotropy
+    ) {
+      processAnisotropyUniforms(
+        material.anisotropy,
+        uniformMap,
+        shaderBuilder,
+        defaultTexture,
+        disableTextures
+      );
+    }
+    if (
+      defined(material.clearcoat) &&
+      ModelUtility.supportedExtensions.KHR_materials_clearcoat
+    ) {
+      processClearcoatUniforms(
+        material.clearcoat,
+        uniformMap,
+        shaderBuilder,
+        defaultTexture,
+        disableTextures
+      );
+    }
     processMetallicRoughnessUniforms(
-      material,
+      material.metallicRoughness,
       uniformMap,
       shaderBuilder,
       defaultTexture,
@@ -245,7 +285,13 @@ function processMaterialUniforms(
   defaultEmissiveTexture,
   disableTextures
 ) {
-  const emissiveFactor = material.emissiveFactor;
+  const {
+    emissiveFactor,
+    emissiveTexture,
+    normalTexture,
+    occlusionTexture,
+  } = material;
+
   if (
     defined(emissiveFactor) &&
     !Cartesian3.equals(emissiveFactor, Material.DEFAULT_EMISSIVE_FACTOR)
@@ -264,7 +310,6 @@ function processMaterialUniforms(
       ShaderDestination.FRAGMENT
     );
 
-    const emissiveTexture = material.emissiveTexture;
     if (defined(emissiveTexture) && !disableTextures) {
       processTexture(
         shaderBuilder,
@@ -277,7 +322,6 @@ function processMaterialUniforms(
     }
   }
 
-  const normalTexture = material.normalTexture;
   if (defined(normalTexture) && !disableTextures) {
     processTexture(
       shaderBuilder,
@@ -289,7 +333,6 @@ function processMaterialUniforms(
     );
   }
 
-  const occlusionTexture = material.occlusionTexture;
   if (defined(occlusionTexture) && !disableTextures) {
     processTexture(
       shaderBuilder,
@@ -302,21 +345,37 @@ function processMaterialUniforms(
   }
 }
 
+/**
+ * Add uniforms and defines for the KHR_materials_pbrSpecularGlossiness extension
+ *
+ * @param {ModelComponents.SpecularGlossiness} specularGlossiness
+ * @param {Object<string, Function>} uniformMap The uniform map to modify.
+ * @param {ShaderBuilder} shaderBuilder
+ * @param {Texture} defaultTexture
+ * @param {boolean} disableTextures
+ * @private
+ */
 function processSpecularGlossinessUniforms(
-  material,
+  specularGlossiness,
   uniformMap,
   shaderBuilder,
   defaultTexture,
   disableTextures
 ) {
-  const specularGlossiness = material.specularGlossiness;
+  const {
+    diffuseTexture,
+    diffuseFactor,
+    specularGlossinessTexture,
+    specularFactor,
+    glossinessFactor,
+  } = specularGlossiness;
+
   shaderBuilder.addDefine(
     "USE_SPECULAR_GLOSSINESS",
     undefined,
     ShaderDestination.FRAGMENT
   );
 
-  const diffuseTexture = specularGlossiness.diffuseTexture;
   if (defined(diffuseTexture) && !disableTextures) {
     processTexture(
       shaderBuilder,
@@ -328,7 +387,6 @@ function processSpecularGlossinessUniforms(
     );
   }
 
-  const diffuseFactor = specularGlossiness.diffuseFactor;
   if (
     defined(diffuseFactor) &&
     !Cartesian4.equals(diffuseFactor, SpecularGlossiness.DEFAULT_DIFFUSE_FACTOR)
@@ -348,8 +406,6 @@ function processSpecularGlossinessUniforms(
     );
   }
 
-  const specularGlossinessTexture =
-    specularGlossiness.specularGlossinessTexture;
   if (defined(specularGlossinessTexture) && !disableTextures) {
     processTexture(
       shaderBuilder,
@@ -361,7 +417,6 @@ function processSpecularGlossinessUniforms(
     );
   }
 
-  const specularFactor = specularGlossiness.specularFactor;
   if (
     defined(specularFactor) &&
     !Cartesian3.equals(
@@ -371,20 +426,19 @@ function processSpecularGlossinessUniforms(
   ) {
     shaderBuilder.addUniform(
       "vec3",
-      "u_specularFactor",
+      "u_legacySpecularFactor",
       ShaderDestination.FRAGMENT
     );
-    uniformMap.u_specularFactor = function () {
+    uniformMap.u_legacySpecularFactor = function () {
       return specularGlossiness.specularFactor;
     };
     shaderBuilder.addDefine(
-      "HAS_SPECULAR_FACTOR",
+      "HAS_LEGACY_SPECULAR_FACTOR",
       undefined,
       ShaderDestination.FRAGMENT
     );
   }
 
-  const glossinessFactor = specularGlossiness.glossinessFactor;
   if (
     defined(glossinessFactor) &&
     glossinessFactor !== SpecularGlossiness.DEFAULT_GLOSSINESS_FACTOR
@@ -405,14 +459,277 @@ function processSpecularGlossinessUniforms(
   }
 }
 
+/**
+ * Add uniforms and defines for the KHR_materials_specular extension
+ *
+ * @param {ModelComponents.Specular} specular
+ * @param {Object<string, Function>} uniformMap The uniform map to modify.
+ * @param {ShaderBuilder} shaderBuilder
+ * @param {Texture} defaultTexture
+ * @param {boolean} disableTextures
+ * @private
+ */
+function processSpecularUniforms(
+  specular,
+  uniformMap,
+  shaderBuilder,
+  defaultTexture,
+  disableTextures
+) {
+  const {
+    specularTexture,
+    specularFactor,
+    specularColorTexture,
+    specularColorFactor,
+  } = specular;
+
+  shaderBuilder.addDefine(
+    "USE_SPECULAR",
+    undefined,
+    ShaderDestination.FRAGMENT
+  );
+
+  if (defined(specularTexture) && !disableTextures) {
+    processTexture(
+      shaderBuilder,
+      uniformMap,
+      specularTexture,
+      "u_specularTexture",
+      "SPECULAR",
+      defaultTexture
+    );
+  }
+
+  if (
+    defined(specularFactor) &&
+    specularFactor !== Specular.DEFAULT_SPECULAR_FACTOR
+  ) {
+    shaderBuilder.addUniform(
+      "float",
+      "u_specularFactor",
+      ShaderDestination.FRAGMENT
+    );
+    uniformMap.u_specularFactor = function () {
+      return specular.specularFactor;
+    };
+    shaderBuilder.addDefine(
+      "HAS_SPECULAR_FACTOR",
+      undefined,
+      ShaderDestination.FRAGMENT
+    );
+  }
+
+  if (defined(specularColorTexture) && !disableTextures) {
+    processTexture(
+      shaderBuilder,
+      uniformMap,
+      specularColorTexture,
+      "u_specularColorTexture",
+      "SPECULAR_COLOR",
+      defaultTexture
+    );
+  }
+
+  if (
+    defined(specularColorFactor) &&
+    !Cartesian3.equals(
+      specularColorFactor,
+      Specular.DEFAULT_SPECULAR_COLOR_FACTOR
+    )
+  ) {
+    shaderBuilder.addUniform(
+      "vec3",
+      "u_specularColorFactor",
+      ShaderDestination.FRAGMENT
+    );
+    uniformMap.u_specularColorFactor = function () {
+      return specular.specularColorFactor;
+    };
+    shaderBuilder.addDefine(
+      "HAS_SPECULAR_COLOR_FACTOR",
+      undefined,
+      ShaderDestination.FRAGMENT
+    );
+  }
+}
+
+const scratchAnisotropy = new Cartesian3();
+
+/**
+ * Add uniforms and defines for the KHR_materials_anisotropy extension
+ *
+ * @param {ModelComponents.Anisotropy} anisotropy
+ * @param {Object<string, Function>} uniformMap The uniform map to modify.
+ * @param {ShaderBuilder} shaderBuilder
+ * @param {Texture} defaultTexture
+ * @param {boolean} disableTextures
+ * @private
+ */
+function processAnisotropyUniforms(
+  anisotropy,
+  uniformMap,
+  shaderBuilder,
+  defaultTexture,
+  disableTextures
+) {
+  const {
+    anisotropyStrength,
+    anisotropyRotation,
+    anisotropyTexture,
+  } = anisotropy;
+
+  shaderBuilder.addDefine(
+    "USE_ANISOTROPY",
+    undefined,
+    ShaderDestination.FRAGMENT
+  );
+
+  if (defined(anisotropyTexture) && !disableTextures) {
+    processTexture(
+      shaderBuilder,
+      uniformMap,
+      anisotropyTexture,
+      "u_anisotropyTexture",
+      "ANISOTROPY",
+      defaultTexture
+    );
+  }
+
+  // Pre-compute cos and sin of rotation, since they are the same for all fragments.
+  // Combine with strength as one vec3 uniform.
+  const cosRotation = Math.cos(anisotropyRotation);
+  const sinRotation = Math.sin(anisotropyRotation);
+  shaderBuilder.addUniform("vec3", "u_anisotropy", ShaderDestination.FRAGMENT);
+  uniformMap.u_anisotropy = function () {
+    return Cartesian3.fromElements(
+      cosRotation,
+      sinRotation,
+      anisotropyStrength,
+      scratchAnisotropy
+    );
+  };
+}
+
+/**
+ * Add uniforms and defines for the KHR_materials_clearcoat extension
+ *
+ * @param {ModelComponents.Clearcoat} clearcoat
+ * @param {Object<string, Function>} uniformMap The uniform map to modify.
+ * @param {ShaderBuilder} shaderBuilder
+ * @param {Texture} defaultTexture
+ * @param {boolean} disableTextures
+ * @private
+ */
+function processClearcoatUniforms(
+  clearcoat,
+  uniformMap,
+  shaderBuilder,
+  defaultTexture,
+  disableTextures
+) {
+  const {
+    clearcoatFactor,
+    clearcoatTexture,
+    clearcoatRoughnessFactor,
+    clearcoatRoughnessTexture,
+    clearcoatNormalTexture,
+  } = clearcoat;
+
+  shaderBuilder.addDefine(
+    "USE_CLEARCOAT",
+    undefined,
+    ShaderDestination.FRAGMENT
+  );
+
+  if (
+    defined(clearcoatFactor) &&
+    clearcoatFactor !== Clearcoat.DEFAULT_CLEARCOAT_FACTOR
+  ) {
+    shaderBuilder.addUniform(
+      "float",
+      "u_clearcoatFactor",
+      ShaderDestination.FRAGMENT
+    );
+    uniformMap.u_clearcoatFactor = function () {
+      return clearcoat.clearcoatFactor;
+    };
+    shaderBuilder.addDefine(
+      "HAS_CLEARCOAT_FACTOR",
+      undefined,
+      ShaderDestination.FRAGMENT
+    );
+  }
+
+  if (defined(clearcoatTexture) && !disableTextures) {
+    processTexture(
+      shaderBuilder,
+      uniformMap,
+      clearcoatTexture,
+      "u_clearcoatTexture",
+      "CLEARCOAT",
+      defaultTexture
+    );
+  }
+
+  if (
+    defined(clearcoatRoughnessFactor) &&
+    clearcoatFactor !== Clearcoat.DEFAULT_CLEARCOAT_ROUGHNESS_FACTOR
+  ) {
+    shaderBuilder.addUniform(
+      "float",
+      "u_clearcoatRoughnessFactor",
+      ShaderDestination.FRAGMENT
+    );
+    uniformMap.u_clearcoatRoughnessFactor = function () {
+      return clearcoat.clearcoatRoughnessFactor;
+    };
+    shaderBuilder.addDefine(
+      "HAS_CLEARCOAT_ROUGHNESS_FACTOR",
+      undefined,
+      ShaderDestination.FRAGMENT
+    );
+  }
+
+  if (defined(clearcoatRoughnessTexture) && !disableTextures) {
+    processTexture(
+      shaderBuilder,
+      uniformMap,
+      clearcoatRoughnessTexture,
+      "u_clearcoatRoughnessTexture",
+      "CLEARCOAT_ROUGHNESS",
+      defaultTexture
+    );
+  }
+
+  if (defined(clearcoatNormalTexture) && !disableTextures) {
+    processTexture(
+      shaderBuilder,
+      uniformMap,
+      clearcoatNormalTexture,
+      "u_clearcoatNormalTexture",
+      "CLEARCOAT_NORMAL",
+      defaultTexture
+    );
+  }
+}
+
+/**
+ * Add uniforms and defines for the PBR metallic roughness model
+ *
+ * @param {ModelComponents.MetallicRoughness} metallicRoughness
+ * @param {Object<string, Function>} uniformMap The uniform map to modify.
+ * @param {ShaderBuilder} shaderBuilder
+ * @param {Texture} defaultTexture
+ * @param {boolean} disableTextures
+ * @private
+ */
 function processMetallicRoughnessUniforms(
-  material,
+  metallicRoughness,
   uniformMap,
   shaderBuilder,
   defaultTexture,
   disableTextures
 ) {
-  const metallicRoughness = material.metallicRoughness;
   shaderBuilder.addDefine(
     "USE_METALLIC_ROUGHNESS",
     undefined,

package/Source/Scene/Model/Model.js

@@ -17,6 +17,7 @@ import Resource from "../../Core/Resource.js";
 import RuntimeError from "../../Core/RuntimeError.js";
 import Pass from "../../Renderer/Pass.js";
 import ClippingPlaneCollection from "../ClippingPlaneCollection.js";
+import ClippingPolygonCollection from "../ClippingPolygonCollection.js";
 import ColorBlendMode from "../ColorBlendMode.js";
 import GltfLoader from "../GltfLoader.js";
 import HeightReference, {
@@ -147,6 +148,7 @@ import pickModel from "./pickModel.js";
  * @privateParam {boolean} [options.showOutline=true] Whether to display the outline for models using the {@link https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/CESIUM_primitive_outline|CESIUM_primitive_outline} extension. When true, outlines are displayed. When false, outlines are not displayed.
  * @privateParam {Color} [options.outlineColor=Color.BLACK] The color to use when rendering outlines.
  * @privateParam {ClippingPlaneCollection} [options.clippingPlanes] The {@link ClippingPlaneCollection} used to selectively disable rendering the model.
+ * @privateParam {ClippingPolygonCollection} [options.clippingPolygons] The {@link ClippingPolygonCollection} used to selectively disable rendering the model.
  * @privateParam {Cartesian3} [options.lightColor] The light color when shading the model. When <code>undefined</code> the scene's light color is used instead.
  * @privateParam {ImageBasedLighting} [options.imageBasedLighting] The properties for managing image-based lighting on this model.
  * @privateParam {boolean} [options.backFaceCulling=true] Whether to cull back-facing geometry. When true, back face culling is determined by the material's doubleSided property; when false, back face culling is disabled. Back faces are not culled if the model's color is translucent.
@@ -370,6 +372,20 @@ function Model(options) {
   this._clippingPlanesState = 0; // If this value changes, the shaders need to be regenerated.
   this._clippingPlanesMatrix = Matrix4.clone(Matrix4.IDENTITY); // Derived from reference matrix and the current view matrix
 
+  // If the given clipping polygons don't have an owner, make this model its owner.
+  // Otherwise, the clipping polygons are passed down from a tileset.
+  const clippingPolygons = options.clippingPolygons;
+  if (defined(clippingPolygons) && clippingPolygons.owner === undefined) {
+    ClippingPolygonCollection.setOwner(
+      clippingPolygons,
+      this,
+      "_clippingPolygons"
+    );
+  } else {
+    this._clippingPolygons = clippingPolygons;
+  }
+  this._clippingPolygonsState = 0; // If this value changes, the shaders need to be regenerated.
+
   this._lightColor = Cartesian3.clone(options.lightColor);
 
   this._imageBasedLighting = defined(options.imageBasedLighting)
@@ -1303,6 +1319,26 @@ Object.defineProperties(Model.prototype, {
     },
   },
 
+  /**
+   * The {@link ClippingPolygonCollection} used to selectively disable rendering the model.
+   *
+   * @memberof Model.prototype
+   *
+   * @type {ClippingPolygonCollection}
+   */
+  clippingPolygons: {
+    get: function () {
+      return this._clippingPolygons;
+    },
+    set: function (value) {
+      if (value !== this._clippingPolygons) {
+        // Handle destroying old clipping polygons, new clipping polygons ownership
+        ClippingPolygonCollection.setOwner(value, this, "_clippingPolygons");
+        this.resetDrawCommands();
+      }
+    },
+  },
+
   /**
    * The light color when shading the model. When <code>undefined</code> the scene's light color is used instead.
    * <p>
@@ -1801,6 +1837,7 @@ Model.prototype.update = function (frameState) {
   updateSilhouette(this, frameState);
   updateSkipLevelOfDetail(this, frameState);
   updateClippingPlanes(this, frameState);
+  updateClippingPolygons(this, frameState);
   updateSceneMode(this, frameState);
   updateFog(this, frameState);
   updateVerticalExaggeration(this, frameState);
@@ -1987,6 +2024,24 @@ function updateClippingPlanes(model, frameState) {
   }
 }
 
+function updateClippingPolygons(model, frameState) {
+  // Update the clipping polygon collection / state for this model to detect any changes.
+  let currentClippingPolygonsState = 0;
+  if (model.isClippingPolygonsEnabled()) {
+    if (model._clippingPolygons.owner === model) {
+      model._clippingPolygons.update(frameState);
+      model._clippingPolygons.queueCommands(frameState);
+    }
+    currentClippingPolygonsState =
+      model._clippingPolygons.clippingPolygonsState;
+  }
+
+  if (currentClippingPolygonsState !== model._clippingPolygonsState) {
+    model.resetDrawCommands();
+    model._clippingPolygonsState = currentClippingPolygonsState;
+  }
+}
+
 function updateSceneMode(model, frameState) {
   if (frameState.mode !== model._sceneMode) {
     if (model._projectTo2D) {
@@ -2195,6 +2250,10 @@ function updatePickIds(model) {
   }
 }
 
+// Matrix3 is a row-major constructor.
+// The same constructor in GLSL will produce the transpose of this.
+const yUpToZUp = new Matrix3(-1, 0, 0, 0, 0, 1, 0, -1, 0);
+
 function updateReferenceMatrices(model, frameState) {
   const modelMatrix = defined(model._clampedModelMatrix)
     ? model._clampedModelMatrix
@@ -2212,15 +2271,16 @@ function updateReferenceMatrices(model, frameState) {
       referenceMatrix,
       iblReferenceFrameMatrix4
     );
-    iblReferenceFrameMatrix3 = Matrix4.getMatrix3(
+    iblReferenceFrameMatrix3 = Matrix4.getRotation(
       iblReferenceFrameMatrix4,
       iblReferenceFrameMatrix3
     );
-    iblReferenceFrameMatrix3 = Matrix3.getRotation(
+    iblReferenceFrameMatrix3 = Matrix3.transpose(
       iblReferenceFrameMatrix3,
       iblReferenceFrameMatrix3
     );
-    model._iblReferenceFrameMatrix = Matrix3.transpose(
+    model._iblReferenceFrameMatrix = Matrix3.multiply(
+      yUpToZUp,
       iblReferenceFrameMatrix3,
       model._iblReferenceFrameMatrix
     );
@@ -2537,6 +2597,21 @@ Model.prototype.pick = function (
   );
 };
 
+/**
+ * Gets whether or not clipping polygons are enabled for this model.
+ *
+ * @returns {boolean} <code>true</code> if clipping polygons are enabled for this model, <code>false</code>.
+ * @private
+ */
+Model.prototype.isClippingPolygonsEnabled = function () {
+  const clippingPolygons = this._clippingPolygons;
+  return (
+    defined(clippingPolygons) &&
+    clippingPolygons.enabled &&
+    clippingPolygons.length !== 0
+  );
+};
+
 /**
  * Returns true if this object was destroyed; otherwise, false.
  * <br /><br />
@@ -2606,6 +2681,17 @@ Model.prototype.destroy = function () {
   }
   this._clippingPlanes = undefined;
 
+  // Only destroy the ClippingPolygonCollection if this is the owner.
+  const clippingPolygonCollection = this._clippingPolygons;
+  if (
+    defined(clippingPolygonCollection) &&
+    !clippingPolygonCollection.isDestroyed() &&
+    clippingPolygonCollection.owner === this
+  ) {
+    clippingPolygonCollection.destroy();
+  }
+  this._clippingPolygons = undefined;
+
   // Only destroy the ImageBasedLighting if this is the owner.
   if (
     this._shouldDestroyImageBasedLighting &&
@@ -2689,6 +2775,7 @@ Model.prototype.destroyModelResources = function () {
  * @param {boolean} [options.showOutline=true] Whether to display the outline for models using the {@link https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/CESIUM_primitive_outline|CESIUM_primitive_outline} extension. When true, outlines are displayed. When false, outlines are not displayed.
  * @param {Color} [options.outlineColor=Color.BLACK] The color to use when rendering outlines.
  * @param {ClippingPlaneCollection} [options.clippingPlanes] The {@link ClippingPlaneCollection} used to selectively disable rendering the model.
+ * @param {ClippingPolygonCollection} [options.clippingPolygons] The {@link ClippingPolygonCollection} used to selectively disable rendering the model.
  * @param {Cartesian3} [options.lightColor] The light color when shading the model. When <code>undefined</code> the scene's light color is used instead.
  * @param {ImageBasedLighting} [options.imageBasedLighting] The properties for managing image-based lighting on this model.
  * @param {boolean} [options.backFaceCulling=true] Whether to cull back-facing geometry. When true, back face culling is determined by the material's doubleSided property; when false, back face culling is disabled. Back faces are not culled if the model's color is translucent.
@@ -3051,6 +3138,7 @@ function makeModelOptions(loader, modelType, options) {
     showOutline: options.showOutline,
     outlineColor: options.outlineColor,
     clippingPlanes: options.clippingPlanes,
+    clippingPolygons: options.clippingPolygons,
     lightColor: options.lightColor,
     imageBasedLighting: options.imageBasedLighting,
     backFaceCulling: options.backFaceCulling,