@cesium/engine 11.0.0 → 12.0.0

package/Source/Scene/GlobeTranslucency.js

@@ -123,13 +123,13 @@ Object.defineProperties(GlobeTranslucency.prototype, {
       //>>includeStart('debug', pragmas.debug);
       if (defined(value) && value.far < value.near) {
         throw new DeveloperError(
-          "far distance must be greater than near distance."
+          "far distance must be greater than near distance.",
         );
       }
       //>>includeEnd('debug');
       this._frontFaceAlphaByDistance = NearFarScalar.clone(
         value,
-        this._frontFaceAlphaByDistance
+        this._frontFaceAlphaByDistance,
       );
     },
   },
@@ -203,13 +203,13 @@ Object.defineProperties(GlobeTranslucency.prototype, {
       //>>includeStart('debug', pragmas.debug);
       if (defined(value) && value.far < value.near) {
         throw new DeveloperError(
-          "far distance must be greater than near distance."
+          "far distance must be greater than near distance.",
         );
       }
       //>>includeEnd('debug');
       this._backFaceAlphaByDistance = NearFarScalar.clone(
         value,
-        this._backFaceAlphaByDistance
+        this._backFaceAlphaByDistance,
       );
     },
   },

package/Source/Scene/GlobeTranslucencyFramebuffer.js

@@ -81,7 +81,7 @@ function updateResources(globeTranslucency, context, width, height, hdr) {
     width,
     height,
     1,
-    pixelDatatype
+    pixelDatatype,
   );
   globeTranslucency._packedDepthFramebuffer.update(context, width, height);
 }
@@ -92,7 +92,7 @@ function updateCommands(globeTranslucency, context, width, height, passState) {
 
   const useScissorTest = !BoundingRectangle.equals(
     globeTranslucency._viewport,
-    passState.viewport
+    passState.viewport,
   );
   let updateScissor = useScissorTest !== globeTranslucency._useScissorTest;
   globeTranslucency._useScissorTest = useScissorTest;
@@ -100,12 +100,12 @@ function updateCommands(globeTranslucency, context, width, height, passState) {
   if (
     !BoundingRectangle.equals(
       globeTranslucency._scissorRectangle,
-      passState.viewport
+      passState.viewport,
     )
   ) {
     globeTranslucency._scissorRectangle = BoundingRectangle.clone(
       passState.viewport,
-      globeTranslucency._scissorRectangle
+      globeTranslucency._scissorRectangle,
     );
     updateScissor = true;
   }
@@ -114,7 +114,7 @@ function updateCommands(globeTranslucency, context, width, height, passState) {
     !defined(globeTranslucency._renderState) ||
     !BoundingRectangle.equals(
       globeTranslucency._viewport,
-      globeTranslucency._renderState.viewport
+      globeTranslucency._renderState.viewport,
     ) ||
     updateScissor
   ) {
@@ -137,7 +137,7 @@ function updateCommands(globeTranslucency, context, width, height, passState) {
           },
         },
         owner: globeTranslucency,
-      }
+      },
     );
   }
 
@@ -163,7 +163,7 @@ GlobeTranslucencyFramebuffer.prototype.updateAndClear = function (
   hdr,
   viewport,
   context,
-  passState
+  passState,
 ) {
   const width = viewport.width;
   const height = viewport.height;
@@ -176,14 +176,14 @@ GlobeTranslucencyFramebuffer.prototype.updateAndClear = function (
 
 GlobeTranslucencyFramebuffer.prototype.clearClassification = function (
   context,
-  passState
+  passState,
 ) {
   this._clearCommand.execute(context, passState);
 };
 
 GlobeTranslucencyFramebuffer.prototype.packDepth = function (
   context,
-  passState
+  passState,
 ) {
   this._packedDepthCommand.execute(context, passState);
   return this.packedDepthTexture;

package/Source/Scene/GlobeTranslucencyState.js

@@ -133,24 +133,24 @@ GlobeTranslucencyState.prototype.update = function (scene) {
     globe.translucency.enabled,
     globe.translucency.frontFaceAlpha,
     globe.translucency.frontFaceAlphaByDistance,
-    this._frontFaceAlphaByDistance
+    this._frontFaceAlphaByDistance,
   );
   this._backFaceAlphaByDistance = updateAlphaByDistance(
     globe.translucency.enabled,
     globe.translucency.backFaceAlpha,
     globe.translucency.backFaceAlphaByDistance,
-    this._backFaceAlphaByDistance
+    this._backFaceAlphaByDistance,
   );
 
   this._frontFaceTranslucent = isFaceTranslucent(
     globe.translucency.enabled,
     this._frontFaceAlphaByDistance,
-    globe
+    globe,
   );
   this._backFaceTranslucent = isFaceTranslucent(
     globe.translucency.enabled,
     this._backFaceAlphaByDistance,
-    globe
+    globe,
   );
 
   this._requiresManualDepthTest = requiresManualDepthTest(this, scene, globe);
@@ -162,7 +162,7 @@ GlobeTranslucencyState.prototype.update = function (scene) {
 
   this._rectangle = Rectangle.clone(
     globe.translucency.rectangle,
-    this._rectangle
+    this._rectangle,
   );
 
   gatherDerivedCommandRequirements(this, scene);
@@ -244,7 +244,7 @@ function gatherDerivedCommandRequirements(state, scene) {
     scene,
     false,
     false,
-    state._derivedCommandTypes
+    state._derivedCommandTypes,
   );
 
   state._derivedBlendCommandsLength = getDerivedCommandTypes(
@@ -252,7 +252,7 @@ function gatherDerivedCommandRequirements(state, scene) {
     scene,
     true,
     false,
-    state._derivedBlendCommandTypes
+    state._derivedBlendCommandTypes,
   );
 
   state._derivedPickCommandsLength = getDerivedCommandTypes(
@@ -260,7 +260,7 @@ function gatherDerivedCommandRequirements(state, scene) {
     scene,
     false,
     true,
-    state._derivedPickCommandTypes
+    state._derivedPickCommandTypes,
   );
 
   let i;
@@ -298,7 +298,7 @@ function getDerivedCommandTypes(
   scene,
   isBlendCommand,
   isPickCommand,
-  types
+  types,
 ) {
   let length = 0;
 
@@ -316,14 +316,14 @@ function getDerivedCommandTypes(
   const translucentFrontFaceCommandType = isPickCommand
     ? DerivedCommandType.PICK_FRONT_FACE
     : requiresManualDepthTest
-    ? DerivedCommandType.TRANSLUCENT_FRONT_FACE_MANUAL_DEPTH_TEST
-    : DerivedCommandType.TRANSLUCENT_FRONT_FACE;
+      ? DerivedCommandType.TRANSLUCENT_FRONT_FACE_MANUAL_DEPTH_TEST
+      : DerivedCommandType.TRANSLUCENT_FRONT_FACE;
 
   const translucentBackFaceCommandType = isPickCommand
     ? DerivedCommandType.PICK_BACK_FACE
     : requiresManualDepthTest
-    ? DerivedCommandType.TRANSLUCENT_BACK_FACE_MANUAL_DEPTH_TEST
-    : DerivedCommandType.TRANSLUCENT_BACK_FACE;
+      ? DerivedCommandType.TRANSLUCENT_BACK_FACE_MANUAL_DEPTH_TEST
+      : DerivedCommandType.TRANSLUCENT_BACK_FACE;
 
   if (scene.mode === SceneMode.SCENE2D) {
     types[length++] = DerivedCommandType.DEPTH_ONLY_FRONT_FACE;
@@ -412,7 +412,7 @@ function getTranslucentShaderProgram(vs, fs) {
   for (let i = 0; i < length; ++i) {
     sources[i] = ShaderSource.replaceMain(
       sources[i],
-      "czm_globe_translucency_main"
+      "czm_globe_translucency_main",
     );
   }
 
@@ -490,7 +490,7 @@ function getDerivedShaderProgram(
   derivedShaderProgram,
   shaderProgramDirty,
   getShaderProgramFunction,
-  cacheName
+  cacheName,
 ) {
   if (!defined(getShaderProgramFunction)) {
     return shaderProgram;
@@ -502,7 +502,7 @@ function getDerivedShaderProgram(
 
   let shader = context.shaderCache.getDerivedShaderProgram(
     shaderProgram,
-    cacheName
+    cacheName,
   );
   if (!defined(shader)) {
     const attributeLocations = shaderProgram._attributeLocations;
@@ -520,7 +520,7 @@ function getDerivedShaderProgram(
         vertexShaderSource: vs,
         fragmentShaderSource: fs,
         attributeLocations: attributeLocations,
-      }
+      },
     );
   }
 
@@ -600,7 +600,7 @@ function getDerivedRenderState(
   derivedRenderState,
   renderStateDirty,
   getRenderStateFunction,
-  cache
+  cache,
 ) {
   if (!defined(getRenderStateFunction)) {
     return renderState;
@@ -634,7 +634,7 @@ function getDerivedUniformMap(
   uniformMap,
   derivedUniformMap,
   uniformMapDirty,
-  getDerivedUniformMapFunction
+  getDerivedUniformMapFunction,
 ) {
   if (!defined(getDerivedUniformMapFunction)) {
     return uniformMap;
@@ -718,7 +718,8 @@ function createDerivedCommandPacks() {
     new DerivedCommandPack({
       pass: Pass.TRANSLUCENT,
       pickOnly: false,
-      getShaderProgramFunction: getTranslucentFrontFaceManualDepthTestShaderProgram,
+      getShaderProgramFunction:
+        getTranslucentFrontFaceManualDepthTestShaderProgram,
       getRenderStateFunction: getTranslucentFrontFaceRenderState,
       getUniformMapFunction: getTranslucencyUniformMap,
     }),
@@ -726,7 +727,8 @@ function createDerivedCommandPacks() {
     new DerivedCommandPack({
       pass: Pass.TRANSLUCENT,
       pickOnly: false,
-      getShaderProgramFunction: getTranslucentBackFaceManualDepthTestShaderProgram,
+      getShaderProgramFunction:
+        getTranslucentBackFaceManualDepthTestShaderProgram,
       getRenderStateFunction: getTranslucentBackFaceRenderState,
       getUniformMapFunction: getTranslucencyUniformMap,
     }),
@@ -754,7 +756,7 @@ const derivedCommandPacks = new Array(derivedCommandsMaximumLength);
 
 GlobeTranslucencyState.prototype.updateDerivedCommands = function (
   command,
-  frameState
+  frameState,
 ) {
   const derivedCommandTypes = this._derivedCommandTypesToUpdate;
   const derivedCommandsLength = this._derivedCommandsToUpdateLength;
@@ -775,7 +777,7 @@ GlobeTranslucencyState.prototype.updateDerivedCommands = function (
     derivedCommandTypes,
     derivedCommandNames,
     derivedCommandPacks,
-    frameState
+    frameState,
   );
 };
 
@@ -786,7 +788,7 @@ function updateDerivedCommands(
   derivedCommandTypes,
   derivedCommandNames,
   derivedCommandPacks,
-  frameState
+  frameState,
 ) {
   let derivedCommandsObject = command.derivedCommands.globeTranslucency;
   const derivedCommandsDirty = state._derivedCommandsDirty;
@@ -807,15 +809,15 @@ function updateDerivedCommands(
 
     const uniformMapDirtyFrame = defaultValue(
       derivedCommandsObject.uniformMapDirtyFrame,
-      0
+      0,
     );
     const shaderProgramDirtyFrame = defaultValue(
       derivedCommandsObject.shaderProgramDirtyFrame,
-      0
+      0,
     );
     const renderStateDirtyFrame = defaultValue(
       derivedCommandsObject.renderStateDirtyFrame,
-      0
+      0,
     );
 
     const uniformMapDirty =
@@ -866,15 +868,15 @@ function updateDerivedCommands(
 
       const derivedUniformMapDirtyFrame = defaultValue(
         derivedCommand.derivedCommands.uniformMapDirtyFrame,
-        0
+        0,
       );
       const derivedShaderProgramDirtyFrame = defaultValue(
         derivedCommand.derivedCommands.shaderProgramDirtyFrame,
-        0
+        0,
       );
       const derivedRenderStateDirtyFrame = defaultValue(
         derivedCommand.derivedCommands.renderStateDirtyFrame,
-        0
+        0,
       );
 
       const derivedUniformMapDirty =
@@ -904,7 +906,7 @@ function updateDerivedCommands(
         command.uniformMap,
         derivedUniformMap,
         derivedUniformMapDirty,
-        derivedCommandPack.getUniformMapFunction
+        derivedCommandPack.getUniformMapFunction,
       );
       derivedCommand.shaderProgram = getDerivedShaderProgram(
         frameState.context,
@@ -912,14 +914,14 @@ function updateDerivedCommands(
         derivedShaderProgram,
         derivedShaderProgramDirty,
         derivedCommandPack.getShaderProgramFunction,
-        derivedCommandName
+        derivedCommandName,
       );
       derivedCommand.renderState = getDerivedRenderState(
         command.renderState,
         derivedRenderState,
         derivedRenderStateDirty,
         derivedCommandPack.getRenderStateFunction,
-        derivedCommandPack.renderStateCache
+        derivedCommandPack.renderStateCache,
       );
     }
   }
@@ -928,7 +930,7 @@ function updateDerivedCommands(
 GlobeTranslucencyState.prototype.pushDerivedCommands = function (
   command,
   isBlendCommand,
-  frameState
+  frameState,
 ) {
   const picking = frameState.passes.pick || frameState.passes.pickVoxel;
   if (picking && isBlendCommand) {
@@ -966,15 +968,14 @@ function executeCommandsMatchingType(
   commandsLength,
   executeCommandFunction,
   scene,
-  context,
   passState,
-  types
+  types,
 ) {
   for (let i = 0; i < commandsLength; ++i) {
     const command = commands[i];
     const type = command.derivedCommands.type;
     if (!defined(types) || types.indexOf(type) > -1) {
-      executeCommandFunction(command, scene, context, passState);
+      executeCommandFunction(command, scene, passState);
     }
   }
 }
@@ -984,11 +985,10 @@ function executeCommands(
   commandsLength,
   executeCommandFunction,
   scene,
-  context,
-  passState
+  passState,
 ) {
   for (let i = 0; i < commandsLength; ++i) {
-    executeCommandFunction(commands[i], scene, context, passState);
+    executeCommandFunction(commands[i], scene, passState);
   }
 }
 
@@ -1007,7 +1007,7 @@ GlobeTranslucencyState.prototype.executeGlobeCommands = function (
   executeCommandFunction,
   globeTranslucencyFramebuffer,
   scene,
-  passState
+  passState,
 ) {
   const context = scene.context;
   const globeCommands = frustumCommands.commands[Pass.GLOBE];
@@ -1026,9 +1026,8 @@ GlobeTranslucencyState.prototype.executeGlobeCommands = function (
     globeCommandsLength,
     executeCommandFunction,
     scene,
-    context,
     passState,
-    opaqueTypes
+    opaqueTypes,
   );
 };
 
@@ -1037,9 +1036,11 @@ GlobeTranslucencyState.prototype.executeGlobeClassificationCommands = function (
   executeCommandFunction,
   globeTranslucencyFramebuffer,
   scene,
-  passState
+  passState,
 ) {
-  const context = scene.context;
+  const { context } = scene;
+  const { uniformState } = context;
+
   const globeCommands = frustumCommands.commands[Pass.GLOBE];
   const globeCommandsLength = frustumCommands.indices[Pass.GLOBE];
   const classificationCommands =
@@ -1061,8 +1062,7 @@ GlobeTranslucencyState.prototype.executeGlobeClassificationCommands = function (
       classificationCommandsLength,
       executeCommandFunction,
       scene,
-      context,
-      passState
+      passState,
     );
   }
 
@@ -1073,7 +1073,7 @@ GlobeTranslucencyState.prototype.executeGlobeClassificationCommands = function (
 
   this._globeTranslucencyFramebuffer = globeTranslucencyFramebuffer;
 
-  const originalGlobeDepthTexture = context.uniformState.globeDepthTexture;
+  const originalGlobeDepthTexture = uniformState.globeDepthTexture;
   const originalFramebuffer = passState.framebuffer;
 
   // Render to internal framebuffer and get the first depth peel
@@ -1085,18 +1085,17 @@ GlobeTranslucencyState.prototype.executeGlobeClassificationCommands = function (
     globeCommandsLength,
     executeCommandFunction,
     scene,
-    context,
     passState,
-    depthOnlyTypes
+    depthOnlyTypes,
   );
 
   if (context.depthTexture) {
     // Pack depth into separate texture for ground polylines and textured ground primitives
     const packedDepthTexture = globeTranslucencyFramebuffer.packDepth(
       context,
-      passState
+      passState,
     );
-    context.uniformState.globeDepthTexture = packedDepthTexture;
+    uniformState.globeDepthTexture = packedDepthTexture;
   }
 
   // Render classification on translucent faces
@@ -1105,12 +1104,11 @@ GlobeTranslucencyState.prototype.executeGlobeClassificationCommands = function (
     classificationCommandsLength,
     executeCommandFunction,
     scene,
-    context,
-    passState
+    passState,
   );
 
   // Unset temporary state
-  context.uniformState.globeDepthTexture = originalGlobeDepthTexture;
+  uniformState.globeDepthTexture = originalGlobeDepthTexture;
   passState.framebuffer = originalFramebuffer;
 };
 

package/Source/Scene/GltfBufferViewLoader.js

@@ -139,7 +139,7 @@ async function loadResources(loader) {
     const bufferViewTypedArray = new Uint8Array(
       bufferTypedArray.buffer,
       bufferTypedArray.byteOffset + loader._byteOffset,
-      loader._byteLength
+      loader._byteLength,
     );
 
     // Unload the buffer
@@ -156,7 +156,7 @@ async function loadResources(loader) {
         byteStride,
         loader._typedArray,
         loader._meshoptMode,
-        loader._meshoptFilter
+        loader._meshoptFilter,
       );
       loader._typedArray = result;
     }

package/Source/Scene/GltfIndexBufferLoader.js

@@ -55,7 +55,7 @@ function GltfIndexBufferLoader(options) {
   Check.typeOf.object("options.baseResource", baseResource);
   if (!loadBuffer && !loadTypedArray) {
     throw new DeveloperError(
-      "At least one of loadBuffer and loadTypedArray must be true."
+      "At least one of loadBuffer and loadTypedArray must be true.",
     );
   }
   //>>includeEnd('debug');
@@ -222,7 +222,7 @@ async function loadFromBufferView(indexBufferLoader) {
     const bufferViewTypedArray = bufferViewLoader.typedArray;
     indexBufferLoader._typedArray = createIndicesTypedArray(
       indexBufferLoader,
-      bufferViewTypedArray
+      bufferViewTypedArray,
     );
     indexBufferLoader._state = ResourceLoaderState.PROCESSING;
     return indexBufferLoader;
@@ -254,7 +254,7 @@ function createIndicesTypedArray(indexBufferLoader, bufferViewTypedArray) {
     byteOffset = 0;
     deprecationWarning(
       "index-buffer-unaligned",
-      `The index array is not aligned to a ${indexSize}-byte boundary.`
+      `The index array is not aligned to a ${indexSize}-byte boundary.`,
     );
   }
 
@@ -287,7 +287,7 @@ function CreateIndexBufferJob() {
 CreateIndexBufferJob.prototype.set = function (
   typedArray,
   indexDatatype,
-  context
+  context,
 ) {
   this.typedArray = typedArray;
   this.indexDatatype = indexDatatype;
@@ -298,7 +298,7 @@ CreateIndexBufferJob.prototype.execute = function () {
   this.buffer = createIndexBuffer(
     this.typedArray,
     this.indexDatatype,
-    this.context
+    this.context,
   );
 };
 

package/Source/Scene/GltfJsonLoader.js

@@ -187,7 +187,7 @@ async function upgradeVersion(gltfJsonLoader, gltf) {
           }
 
           buffer.extras._pipeline.source = bufferLoader.typedArray;
-        })
+        }),
       );
     }
   });
@@ -209,7 +209,7 @@ function decodeDataUris(gltf) {
       promises.push(
         Resource.fetchArrayBuffer(bufferUri).then(function (arrayBuffer) {
           buffer.extras._pipeline.source = new Uint8Array(arrayBuffer);
-        })
+        }),
       );
     }
   });