@cesium/engine 11.0.0 → 11.1.0

package/Source/Shaders/Model/ModelFS.glsl

@@ -45,6 +45,10 @@ void main()
     MetadataStatistics metadataStatistics;
     metadataStage(metadata, metadataClass, metadataStatistics, attributes);
 
+    //========================================================================
+    // When not picking metadata START
+    #ifndef METADATA_PICKING_ENABLED
+
     #ifdef HAS_SELECTED_FEATURE_ID
     selectedFeatureIdStage(selectedFeature, featureIds);
     #endif
@@ -73,6 +77,20 @@ void main()
 
     vec4 color = handleAlpha(material.diffuse, material.alpha);
 
+    // When not picking metadata END
+    //========================================================================
+    #else 
+    //========================================================================
+    // When picking metadata START
+
+    vec4 metadataValues = vec4(0.0, 0.0, 0.0, 0.0);
+    metadataPickingStage(metadata, metadataClass, metadataValues);
+    vec4 color = metadataValues;
+
+    #endif
+    // When picking metadata END
+    //========================================================================
+
     #ifdef HAS_CLIPPING_PLANES
     modelClippingPlanesStage(color);
     #endif
@@ -81,6 +99,10 @@ void main()
     modelClippingPolygonsStage();
     #endif
 
+    //========================================================================
+    // When not picking metadata START
+    #ifndef METADATA_PICKING_ENABLED
+
     #if defined(HAS_SILHOUETTE) && defined(HAS_NORMALS)
     silhouetteStage(color);
     #endif
@@ -89,5 +111,9 @@ void main()
     atmosphereStage(color, attributes);
     #endif
 
+    #endif
+    // When not picking metadata END
+    //========================================================================
+
     out_FragColor = color;
 }

package/Source/Shaders/Model/ModelFS.js

@@ -45,6 +45,10 @@ void main()\n\
     MetadataClass metadataClass;\n\
     MetadataStatistics metadataStatistics;\n\
     metadataStage(metadata, metadataClass, metadataStatistics, attributes);\n\
+\n\
+    //========================================================================\n\
+    // When not picking metadata START\n\
+    #ifndef METADATA_PICKING_ENABLED\n\
 \n\
     #ifdef HAS_SELECTED_FEATURE_ID\n\
     selectedFeatureIdStage(selectedFeature, featureIds);\n\
@@ -73,6 +77,20 @@ void main()\n\
     #endif\n\
 \n\
     vec4 color = handleAlpha(material.diffuse, material.alpha);\n\
+\n\
+    // When not picking metadata END\n\
+    //========================================================================\n\
+    #else \n\
+    //========================================================================\n\
+    // When picking metadata START\n\
+\n\
+    vec4 metadataValues = vec4(0.0, 0.0, 0.0, 0.0);\n\
+    metadataPickingStage(metadata, metadataClass, metadataValues);\n\
+    vec4 color = metadataValues;\n\
+\n\
+    #endif\n\
+    // When picking metadata END\n\
+    //========================================================================\n\
 \n\
     #ifdef HAS_CLIPPING_PLANES\n\
     modelClippingPlanesStage(color);\n\
@@ -81,6 +99,10 @@ void main()\n\
     #ifdef ENABLE_CLIPPING_POLYGONS\n\
     modelClippingPolygonsStage();\n\
     #endif\n\
+\n\
+    //========================================================================\n\
+    // When not picking metadata START\n\
+    #ifndef METADATA_PICKING_ENABLED\n\
 \n\
     #if defined(HAS_SILHOUETTE) && defined(HAS_NORMALS)\n\
     silhouetteStage(color);\n\
@@ -89,6 +111,10 @@ void main()\n\
     #ifdef HAS_ATMOSPHERE\n\
     atmosphereStage(color, attributes);\n\
     #endif\n\
+\n\
+    #endif\n\
+    // When not picking metadata END\n\
+    //========================================================================\n\
 \n\
     out_FragColor = color;\n\
 }\n\

package/Source/Shaders/PostProcessStages/AmbientOcclusionGenerate.glsl

@@ -1,3 +1,5 @@
+precision highp float;
+
 uniform sampler2D randomTexture;
 uniform sampler2D depthTexture;
 uniform float intensity;
@@ -6,109 +8,107 @@ uniform float lengthCap;
 uniform float stepSize;
 uniform float frustumLength;
 
-in vec2 v_textureCoordinates;
-
-vec4 clipToEye(vec2 uv, float depth)
+vec3 pixelToEye(vec2 screenCoordinate)
 {
-    vec2 xy = vec2((uv.x * 2.0 - 1.0), ((1.0 - uv.y) * 2.0 - 1.0));
+    vec2 uv = screenCoordinate / czm_viewport.zw;
+    float depth = czm_readDepth(depthTexture, uv);
+    vec2 xy = 2.0 * uv - vec2(1.0);
     vec4 posEC = czm_inverseProjection * vec4(xy, depth, 1.0);
-    posEC = posEC / posEC.w;
-    return posEC;
+    return posEC.xyz / posEC.w;
 }
 
-//Reconstruct Normal Without Edge Removation
-vec3 getNormalXEdge(vec3 posInCamera, float depthU, float depthD, float depthL, float depthR, vec2 pixelSize)
+// Reconstruct surface normal in eye coordinates, avoiding edges
+vec3 getNormalXEdge(vec3 positionEC)
 {
-    vec4 posInCameraUp = clipToEye(v_textureCoordinates - vec2(0.0, pixelSize.y), depthU);
-    vec4 posInCameraDown = clipToEye(v_textureCoordinates + vec2(0.0, pixelSize.y), depthD);
-    vec4 posInCameraLeft = clipToEye(v_textureCoordinates - vec2(pixelSize.x, 0.0), depthL);
-    vec4 posInCameraRight = clipToEye(v_textureCoordinates + vec2(pixelSize.x, 0.0), depthR);
-
-    vec3 up = posInCamera.xyz - posInCameraUp.xyz;
-    vec3 down = posInCameraDown.xyz - posInCamera.xyz;
-    vec3 left = posInCamera.xyz - posInCameraLeft.xyz;
-    vec3 right = posInCameraRight.xyz - posInCamera.xyz;
-
-    vec3 DX = length(left) < length(right) ? left : right;
-    vec3 DY = length(up) < length(down) ? up : down;
-
-    return normalize(cross(DY, DX));
+    // Find the 3D surface positions at adjacent screen pixels
+    vec2 centerCoord = gl_FragCoord.xy;
+    vec3 positionLeft = pixelToEye(centerCoord + vec2(-1.0, 0.0));
+    vec3 positionRight = pixelToEye(centerCoord + vec2(1.0, 0.0));
+    vec3 positionUp = pixelToEye(centerCoord + vec2(0.0, 1.0));
+    vec3 positionDown = pixelToEye(centerCoord + vec2(0.0, -1.0));
+
+    // Compute potential tangent vectors
+    vec3 dx0 = positionEC - positionLeft;
+    vec3 dx1 = positionRight - positionEC;
+    vec3 dy0 = positionEC - positionDown;
+    vec3 dy1 = positionUp - positionEC;
+
+    // The shorter tangent is more likely to be on the same surface
+    vec3 dx = length(dx0) < length(dx1) ? dx0 : dx1;
+    vec3 dy = length(dy0) < length(dy1) ? dy0 : dy1;
+
+    return normalize(cross(dx, dy));
 }
 
 void main(void)
 {
-    float depth = czm_readDepth(depthTexture, v_textureCoordinates);
-    vec4 posInCamera = clipToEye(v_textureCoordinates, depth);
+    vec3 positionEC = pixelToEye(gl_FragCoord.xy);
 
-    if (posInCamera.z > frustumLength)
+    if (positionEC.z > frustumLength)
     {
         out_FragColor = vec4(1.0);
         return;
     }
 
-    vec2 pixelSize = czm_pixelRatio / czm_viewport.zw;
-    float depthU = czm_readDepth(depthTexture, v_textureCoordinates - vec2(0.0, pixelSize.y));
-    float depthD = czm_readDepth(depthTexture, v_textureCoordinates + vec2(0.0, pixelSize.y));
-    float depthL = czm_readDepth(depthTexture, v_textureCoordinates - vec2(pixelSize.x, 0.0));
-    float depthR = czm_readDepth(depthTexture, v_textureCoordinates + vec2(pixelSize.x, 0.0));
-    vec3 normalInCamera = getNormalXEdge(posInCamera.xyz, depthU, depthD, depthL, depthR, pixelSize);
+    vec3 normalEC = getNormalXEdge(positionEC);
 
     float ao = 0.0;
-    vec2 sampleDirection = vec2(1.0, 0.0);
-    float gapAngle = 90.0 * czm_radiansPerDegree;
 
-    // RandomNoise
-    float randomVal = texture(randomTexture, v_textureCoordinates / pixelSize / 255.0).x;
-
-    //Loop for each direction
-    for (int i = 0; i < 4; i++)
+    const int ANGLE_STEPS = 4;
+    float angleStepScale = 1.0 / float(ANGLE_STEPS);
+    float angleStep = angleStepScale * czm_twoPi;
+    float cosStep = cos(angleStep);
+    float sinStep = sin(angleStep);
+    mat2 rotateStep = mat2(cosStep, sinStep, -sinStep, cosStep);
+
+    // Initial sampling direction (different for each pixel)
+    const float randomTextureSize = 255.0;
+    vec2 randomTexCoord = fract(gl_FragCoord.xy / randomTextureSize);
+    float randomVal = texture(randomTexture, randomTexCoord).x;
+    vec2 sampleDirection = vec2(cos(angleStep * randomVal), sin(angleStep * randomVal));
+
+    // Loop over sampling directions
+    for (int i = 0; i < ANGLE_STEPS; i++)
     {
-        float newGapAngle = gapAngle * (float(i) + randomVal);
-        float cosVal = cos(newGapAngle);
-        float sinVal = sin(newGapAngle);
+        sampleDirection = rotateStep * sampleDirection;
 
-        //Rotate Sampling Direction
-        vec2 rotatedSampleDirection = vec2(cosVal * sampleDirection.x - sinVal * sampleDirection.y, sinVal * sampleDirection.x + cosVal * sampleDirection.y);
         float localAO = 0.0;
-        float localStepSize = stepSize;
+        vec2 radialStep = stepSize * sampleDirection;
 
-        //Loop for each step
         for (int j = 0; j < 6; j++)
         {
-            vec2 newCoords = v_textureCoordinates + rotatedSampleDirection * localStepSize * pixelSize;
+            // Step along sampling direction, away from output pixel
+            vec2 newCoords = floor(gl_FragCoord.xy + float(j + 1) * radialStep) + vec2(0.5);
 
-            //Exception Handling
-            if(newCoords.x > 1.0 || newCoords.y > 1.0 || newCoords.x < 0.0 || newCoords.y < 0.0)
+            // Exit if we stepped off the screen
+            if (clamp(newCoords, vec2(0.0), czm_viewport.zw) != newCoords)
             {
                 break;
             }
 
-            float stepDepthInfo = czm_readDepth(depthTexture, newCoords);
-            vec4 stepPosInCamera = clipToEye(newCoords, stepDepthInfo);
-            vec3 diffVec = stepPosInCamera.xyz - posInCamera.xyz;
-            float len = length(diffVec);
+            vec3 stepPositionEC = pixelToEye(newCoords);
+            vec3 stepVector = stepPositionEC - positionEC;
+            float stepLength = length(stepVector);
 
-            if (len > lengthCap)
+            if (stepLength > lengthCap)
             {
                 break;
             }
 
-            float dotVal = clamp(dot(normalInCamera, normalize(diffVec)), 0.0, 1.0 );
-            float weight = len / lengthCap;
-            weight = 1.0 - weight * weight;
-
+            float dotVal = clamp(dot(normalEC, normalize(stepVector)), 0.0, 1.0);
             if (dotVal < bias)
             {
                 dotVal = 0.0;
             }
 
+            float weight = stepLength / lengthCap;
+            weight = 1.0 - weight * weight;
             localAO = max(localAO, dotVal * weight);
-            localStepSize += stepSize;
         }
         ao += localAO;
     }
 
-    ao /= 4.0;
+    ao *= angleStepScale;
     ao = 1.0 - clamp(ao, 0.0, 1.0);
     ao = pow(ao, intensity);
     out_FragColor = vec4(vec3(ao), 1.0);

package/Source/Shaders/PostProcessStages/AmbientOcclusionGenerate.js

@@ -1,5 +1,7 @@
 //This file is automatically rebuilt by the Cesium build process.
-export default "uniform sampler2D randomTexture;\n\
+export default "precision highp float;\n\
+\n\
+uniform sampler2D randomTexture;\n\
 uniform sampler2D depthTexture;\n\
 uniform float intensity;\n\
 uniform float bias;\n\
@@ -7,109 +9,107 @@ uniform float lengthCap;\n\
 uniform float stepSize;\n\
 uniform float frustumLength;\n\
 \n\
-in vec2 v_textureCoordinates;\n\
-\n\
-vec4 clipToEye(vec2 uv, float depth)\n\
+vec3 pixelToEye(vec2 screenCoordinate)\n\
 {\n\
-    vec2 xy = vec2((uv.x * 2.0 - 1.0), ((1.0 - uv.y) * 2.0 - 1.0));\n\
+    vec2 uv = screenCoordinate / czm_viewport.zw;\n\
+    float depth = czm_readDepth(depthTexture, uv);\n\
+    vec2 xy = 2.0 * uv - vec2(1.0);\n\
     vec4 posEC = czm_inverseProjection * vec4(xy, depth, 1.0);\n\
-    posEC = posEC / posEC.w;\n\
-    return posEC;\n\
+    return posEC.xyz / posEC.w;\n\
 }\n\
 \n\
-//Reconstruct Normal Without Edge Removation\n\
-vec3 getNormalXEdge(vec3 posInCamera, float depthU, float depthD, float depthL, float depthR, vec2 pixelSize)\n\
+// Reconstruct surface normal in eye coordinates, avoiding edges\n\
+vec3 getNormalXEdge(vec3 positionEC)\n\
 {\n\
-    vec4 posInCameraUp = clipToEye(v_textureCoordinates - vec2(0.0, pixelSize.y), depthU);\n\
-    vec4 posInCameraDown = clipToEye(v_textureCoordinates + vec2(0.0, pixelSize.y), depthD);\n\
-    vec4 posInCameraLeft = clipToEye(v_textureCoordinates - vec2(pixelSize.x, 0.0), depthL);\n\
-    vec4 posInCameraRight = clipToEye(v_textureCoordinates + vec2(pixelSize.x, 0.0), depthR);\n\
-\n\
-    vec3 up = posInCamera.xyz - posInCameraUp.xyz;\n\
-    vec3 down = posInCameraDown.xyz - posInCamera.xyz;\n\
-    vec3 left = posInCamera.xyz - posInCameraLeft.xyz;\n\
-    vec3 right = posInCameraRight.xyz - posInCamera.xyz;\n\
-\n\
-    vec3 DX = length(left) < length(right) ? left : right;\n\
-    vec3 DY = length(up) < length(down) ? up : down;\n\
-\n\
-    return normalize(cross(DY, DX));\n\
+    // Find the 3D surface positions at adjacent screen pixels\n\
+    vec2 centerCoord = gl_FragCoord.xy;\n\
+    vec3 positionLeft = pixelToEye(centerCoord + vec2(-1.0, 0.0));\n\
+    vec3 positionRight = pixelToEye(centerCoord + vec2(1.0, 0.0));\n\
+    vec3 positionUp = pixelToEye(centerCoord + vec2(0.0, 1.0));\n\
+    vec3 positionDown = pixelToEye(centerCoord + vec2(0.0, -1.0));\n\
+\n\
+    // Compute potential tangent vectors\n\
+    vec3 dx0 = positionEC - positionLeft;\n\
+    vec3 dx1 = positionRight - positionEC;\n\
+    vec3 dy0 = positionEC - positionDown;\n\
+    vec3 dy1 = positionUp - positionEC;\n\
+\n\
+    // The shorter tangent is more likely to be on the same surface\n\
+    vec3 dx = length(dx0) < length(dx1) ? dx0 : dx1;\n\
+    vec3 dy = length(dy0) < length(dy1) ? dy0 : dy1;\n\
+\n\
+    return normalize(cross(dx, dy));\n\
 }\n\
 \n\
 void main(void)\n\
 {\n\
-    float depth = czm_readDepth(depthTexture, v_textureCoordinates);\n\
-    vec4 posInCamera = clipToEye(v_textureCoordinates, depth);\n\
+    vec3 positionEC = pixelToEye(gl_FragCoord.xy);\n\
 \n\
-    if (posInCamera.z > frustumLength)\n\
+    if (positionEC.z > frustumLength)\n\
     {\n\
         out_FragColor = vec4(1.0);\n\
         return;\n\
     }\n\
 \n\
-    vec2 pixelSize = czm_pixelRatio / czm_viewport.zw;\n\
-    float depthU = czm_readDepth(depthTexture, v_textureCoordinates - vec2(0.0, pixelSize.y));\n\
-    float depthD = czm_readDepth(depthTexture, v_textureCoordinates + vec2(0.0, pixelSize.y));\n\
-    float depthL = czm_readDepth(depthTexture, v_textureCoordinates - vec2(pixelSize.x, 0.0));\n\
-    float depthR = czm_readDepth(depthTexture, v_textureCoordinates + vec2(pixelSize.x, 0.0));\n\
-    vec3 normalInCamera = getNormalXEdge(posInCamera.xyz, depthU, depthD, depthL, depthR, pixelSize);\n\
+    vec3 normalEC = getNormalXEdge(positionEC);\n\
 \n\
     float ao = 0.0;\n\
-    vec2 sampleDirection = vec2(1.0, 0.0);\n\
-    float gapAngle = 90.0 * czm_radiansPerDegree;\n\
 \n\
-    // RandomNoise\n\
-    float randomVal = texture(randomTexture, v_textureCoordinates / pixelSize / 255.0).x;\n\
-\n\
-    //Loop for each direction\n\
-    for (int i = 0; i < 4; i++)\n\
+    const int ANGLE_STEPS = 4;\n\
+    float angleStepScale = 1.0 / float(ANGLE_STEPS);\n\
+    float angleStep = angleStepScale * czm_twoPi;\n\
+    float cosStep = cos(angleStep);\n\
+    float sinStep = sin(angleStep);\n\
+    mat2 rotateStep = mat2(cosStep, sinStep, -sinStep, cosStep);\n\
+\n\
+    // Initial sampling direction (different for each pixel)\n\
+    const float randomTextureSize = 255.0;\n\
+    vec2 randomTexCoord = fract(gl_FragCoord.xy / randomTextureSize);\n\
+    float randomVal = texture(randomTexture, randomTexCoord).x;\n\
+    vec2 sampleDirection = vec2(cos(angleStep * randomVal), sin(angleStep * randomVal));\n\
+\n\
+    // Loop over sampling directions\n\
+    for (int i = 0; i < ANGLE_STEPS; i++)\n\
     {\n\
-        float newGapAngle = gapAngle * (float(i) + randomVal);\n\
-        float cosVal = cos(newGapAngle);\n\
-        float sinVal = sin(newGapAngle);\n\
+        sampleDirection = rotateStep * sampleDirection;\n\
 \n\
-        //Rotate Sampling Direction\n\
-        vec2 rotatedSampleDirection = vec2(cosVal * sampleDirection.x - sinVal * sampleDirection.y, sinVal * sampleDirection.x + cosVal * sampleDirection.y);\n\
         float localAO = 0.0;\n\
-        float localStepSize = stepSize;\n\
+        vec2 radialStep = stepSize * sampleDirection;\n\
 \n\
-        //Loop for each step\n\
         for (int j = 0; j < 6; j++)\n\
         {\n\
-            vec2 newCoords = v_textureCoordinates + rotatedSampleDirection * localStepSize * pixelSize;\n\
+            // Step along sampling direction, away from output pixel\n\
+            vec2 newCoords = floor(gl_FragCoord.xy + float(j + 1) * radialStep) + vec2(0.5);\n\
 \n\
-            //Exception Handling\n\
-            if(newCoords.x > 1.0 || newCoords.y > 1.0 || newCoords.x < 0.0 || newCoords.y < 0.0)\n\
+            // Exit if we stepped off the screen\n\
+            if (clamp(newCoords, vec2(0.0), czm_viewport.zw) != newCoords)\n\
             {\n\
                 break;\n\
             }\n\
 \n\
-            float stepDepthInfo = czm_readDepth(depthTexture, newCoords);\n\
-            vec4 stepPosInCamera = clipToEye(newCoords, stepDepthInfo);\n\
-            vec3 diffVec = stepPosInCamera.xyz - posInCamera.xyz;\n\
-            float len = length(diffVec);\n\
+            vec3 stepPositionEC = pixelToEye(newCoords);\n\
+            vec3 stepVector = stepPositionEC - positionEC;\n\
+            float stepLength = length(stepVector);\n\
 \n\
-            if (len > lengthCap)\n\
+            if (stepLength > lengthCap)\n\
             {\n\
                 break;\n\
             }\n\
 \n\
-            float dotVal = clamp(dot(normalInCamera, normalize(diffVec)), 0.0, 1.0 );\n\
-            float weight = len / lengthCap;\n\
-            weight = 1.0 - weight * weight;\n\
-\n\
+            float dotVal = clamp(dot(normalEC, normalize(stepVector)), 0.0, 1.0);\n\
             if (dotVal < bias)\n\
             {\n\
                 dotVal = 0.0;\n\
             }\n\
 \n\
+            float weight = stepLength / lengthCap;\n\
+            weight = 1.0 - weight * weight;\n\
             localAO = max(localAO, dotVal * weight);\n\
-            localStepSize += stepSize;\n\
         }\n\
         ao += localAO;\n\
     }\n\
 \n\
-    ao /= 4.0;\n\
+    ao *= angleStepScale;\n\
     ao = 1.0 - clamp(ao, 0.0, 1.0);\n\
     ao = pow(ao, intensity);\n\
     out_FragColor = vec4(vec3(ao), 1.0);\n\

package/Source/Widget/CesiumWidget.js

@@ -192,7 +192,8 @@ function CesiumWidget(container, options) {
   container.appendChild(element);
 
   const canvas = document.createElement("canvas");
-  const supportsImageRenderingPixelated = FeatureDetection.supportsImageRenderingPixelated();
+  const supportsImageRenderingPixelated =
+    FeatureDetection.supportsImageRenderingPixelated();
   this._supportsImageRenderingPixelated = supportsImageRenderingPixelated;
   if (supportsImageRenderingPixelated) {
     canvas.style.imageRendering = FeatureDetection.imageRenderingValue();
@@ -221,7 +222,7 @@ function CesiumWidget(container, options) {
 
   const blurActiveElementOnCanvasFocus = defaultValue(
     options.blurActiveElementOnCanvasFocus,
-    true
+    true,
   );
 
   if (blurActiveElementOnCanvasFocus) {
@@ -247,7 +248,7 @@ function CesiumWidget(container, options) {
 
   const useBrowserRecommendedResolution = defaultValue(
     options.useBrowserRecommendedResolution,
-    true
+    true,
   );
 
   this._element = element;
@@ -303,7 +304,7 @@ function CesiumWidget(container, options) {
       scene.globe = globe;
       scene.globe.shadows = defaultValue(
         options.terrainShadows,
-        ShadowMode.RECEIVE_ONLY
+        ShadowMode.RECEIVE_ONLY,
       );
     }
 
@@ -348,7 +349,7 @@ function CesiumWidget(container, options) {
       //>>includeStart('debug', pragmas.debug);
       if (defined(options.terrainProvider)) {
         throw new DeveloperError(
-          "Specify either options.terrainProvider or options.terrain."
+          "Specify either options.terrainProvider or options.terrain.",
         );
       }
       //>>includeEnd('debug')
@@ -370,7 +371,7 @@ function CesiumWidget(container, options) {
     this._useDefaultRenderLoop = undefined;
     this.useDefaultRenderLoop = defaultValue(
       options.useDefaultRenderLoop,
-      true
+      true,
     );
 
     this._targetFrameRate = undefined;
@@ -573,7 +574,7 @@ Object.defineProperties(CesiumWidget.prototype, {
       //>>includeStart('debug', pragmas.debug);
       if (value <= 0) {
         throw new DeveloperError(
-          "targetFrameRate must be greater than 0, or undefined."
+          "targetFrameRate must be greater than 0, or undefined.",
         );
       }
       //>>includeEnd('debug');
@@ -693,7 +694,7 @@ CesiumWidget.prototype.showErrorPanel = function (title, message, error) {
   function resizeCallback() {
     errorPanelScroller.style.maxHeight = `${Math.max(
       Math.round(element.clientHeight * 0.9 - 100),
-      30
+      30,
     )}px`;
   }
   resizeCallback();

package/Source/Workers/combineGeometry.js

@@ -2,13 +2,12 @@ import PrimitivePipeline from "../Scene/PrimitivePipeline.js";
 import createTaskProcessorWorker from "./createTaskProcessorWorker.js";
 
 function combineGeometry(packedParameters, transferableObjects) {
-  const parameters = PrimitivePipeline.unpackCombineGeometryParameters(
-    packedParameters
-  );
+  const parameters =
+    PrimitivePipeline.unpackCombineGeometryParameters(packedParameters);
   const results = PrimitivePipeline.combineGeometry(parameters);
   return PrimitivePipeline.packCombineGeometryResults(
     results,
-    transferableObjects
+    transferableObjects,
   );
 }
 export default createTaskProcessorWorker(combineGeometry);

package/Source/Workers/createCircleGeometry.js

@@ -8,10 +8,10 @@ function createCircleGeometry(circleGeometry, offset) {
     circleGeometry = CircleGeometry.unpack(circleGeometry, offset);
   }
   circleGeometry._ellipseGeometry._center = Cartesian3.clone(
-    circleGeometry._ellipseGeometry._center
+    circleGeometry._ellipseGeometry._center,
   );
   circleGeometry._ellipseGeometry._ellipsoid = Ellipsoid.clone(
-    circleGeometry._ellipseGeometry._ellipsoid
+    circleGeometry._ellipseGeometry._ellipsoid,
   );
   return CircleGeometry.createGeometry(circleGeometry);
 }

package/Source/Workers/createCircleOutlineGeometry.js

@@ -8,10 +8,10 @@ function createCircleOutlineGeometry(circleGeometry, offset) {
     circleGeometry = CircleOutlineGeometry.unpack(circleGeometry, offset);
   }
   circleGeometry._ellipseGeometry._center = Cartesian3.clone(
-    circleGeometry._ellipseGeometry._center
+    circleGeometry._ellipseGeometry._center,
   );
   circleGeometry._ellipseGeometry._ellipsoid = Ellipsoid.clone(
-    circleGeometry._ellipseGeometry._ellipsoid
+    circleGeometry._ellipseGeometry._ellipsoid,
   );
   return CircleOutlineGeometry.createGeometry(circleGeometry);
 }

package/Source/Workers/createCoplanarPolygonOutlineGeometry.js

@@ -6,7 +6,7 @@ function createCoplanarPolygonOutlineGeometry(polygonGeometry, offset) {
   if (defined(offset)) {
     polygonGeometry = CoplanarPolygonOutlineGeometry.unpack(
       polygonGeometry,
-      offset
+      offset,
     );
   }
   polygonGeometry._ellipsoid = Ellipsoid.clone(polygonGeometry._ellipsoid);

package/Source/Workers/createCorridorOutlineGeometry.js

@@ -6,11 +6,11 @@ function createCorridorOutlineGeometry(corridorOutlineGeometry, offset) {
   if (defined(offset)) {
     corridorOutlineGeometry = CorridorOutlineGeometry.unpack(
       corridorOutlineGeometry,
-      offset
+      offset,
     );
   }
   corridorOutlineGeometry._ellipsoid = Ellipsoid.clone(
-    corridorOutlineGeometry._ellipsoid
+    corridorOutlineGeometry._ellipsoid,
   );
   return CorridorOutlineGeometry.createGeometry(corridorOutlineGeometry);
 }

package/Source/Workers/createEllipsoidOutlineGeometry.js

@@ -5,7 +5,7 @@ function createEllipsoidOutlineGeometry(ellipsoidGeometry, offset) {
   if (defined(ellipsoidGeometry.buffer, offset)) {
     ellipsoidGeometry = EllipsoidOutlineGeometry.unpack(
       ellipsoidGeometry,
-      offset
+      offset,
     );
   }
   return EllipsoidOutlineGeometry.createGeometry(ellipsoidGeometry);

package/Source/Workers/createGeometry.js

@@ -60,10 +60,9 @@ async function createGeometry(parameters, transferableObjects) {
     }
 
     if (defined(moduleName) || defined(modulePath)) {
-      resultsOrPromises[i] = getModule(
-        moduleName,
-        modulePath
-      ).then((createFunction) => createFunction(geometry, task.offset));
+      resultsOrPromises[i] = getModule(moduleName, modulePath).then(
+        (createFunction) => createFunction(geometry, task.offset),
+      );
     } else {
       // Already created geometry
       resultsOrPromises[i] = geometry;
@@ -73,7 +72,7 @@ async function createGeometry(parameters, transferableObjects) {
   return Promise.all(resultsOrPromises).then(function (results) {
     return PrimitivePipeline.packCreateGeometryResults(
       results,
-      transferableObjects
+      transferableObjects,
     );
   });
 }

package/Source/Workers/createGroundPolylineGeometry.js

@@ -7,7 +7,7 @@ function createGroundPolylineGeometry(groundPolylineGeometry, offset) {
     if (defined(offset)) {
       groundPolylineGeometry = GroundPolylineGeometry.unpack(
         groundPolylineGeometry,
-        offset
+        offset,
       );
     }
     return GroundPolylineGeometry.createGeometry(groundPolylineGeometry);

package/Source/Workers/createPolylineVolumeGeometry.js

@@ -6,11 +6,11 @@ function createPolylineVolumeGeometry(polylineVolumeGeometry, offset) {
   if (defined(offset)) {
     polylineVolumeGeometry = PolylineVolumeGeometry.unpack(
       polylineVolumeGeometry,
-      offset
+      offset,
     );
   }
   polylineVolumeGeometry._ellipsoid = Ellipsoid.clone(
-    polylineVolumeGeometry._ellipsoid
+    polylineVolumeGeometry._ellipsoid,
   );
   return PolylineVolumeGeometry.createGeometry(polylineVolumeGeometry);
 }