@cesium/engine 1.1.0 → 2.0.0

package/Source/Scene/PostProcessStage.js

@@ -40,7 +40,7 @@ import PostProcessStageSampleMode from "./PostProcessStageSampleMode.js";
  *
  * @exception {DeveloperError} options.textureScale must be greater than 0.0 and less than or equal to 1.0.
  * @exception {DeveloperError} options.pixelFormat must be a color format.
- * @exception {DeveloperError} When options.pixelDatatype is FLOAT, this WebGL implementation must support the OES_texture_float extension.  Check context.floatingPointTexture.
+ * @exception {DeveloperError} When options.pixelDatatype is FLOAT, this WebGL implementation must support floating point textures. Check context.floatingPointTexture.
  *
  * @see PostProcessStageComposite
  *
@@ -48,12 +48,12 @@ import PostProcessStageSampleMode from "./PostProcessStageSampleMode.js";
  * // Simple stage to change the color
  * const fs =`
  *     uniform sampler2D colorTexture;
- *     varying vec2 v_textureCoordinates;
+ *     in vec2 v_textureCoordinates;
  *     uniform float scale;
  *     uniform vec3 offset;
  *     void main() {
- *         vec4 color = texture2D(colorTexture, v_textureCoordinates);
- *         gl_FragColor = vec4(color.rgb * scale + offset, 1.0);
+ *         vec4 color = texture(colorTexture, v_textureCoordinates);
+ *         out_FragColor = vec4(color.rgb * scale + offset, 1.0);
  *     }`;
  * scene.postProcessStages.add(new Cesium.PostProcessStage({
  *     fragmentShader : fs,
@@ -70,15 +70,15 @@ import PostProcessStageSampleMode from "./PostProcessStageSampleMode.js";
  * // If czm_selected returns true, the current fragment belongs to geometry in the selected array.
  * const fs =`
  *     uniform sampler2D colorTexture;
- *     varying vec2 v_textureCoordinates;
+ *     in vec2 v_textureCoordinates;
  *     uniform vec4 highlight;
  *     void main() {
- *         vec4 color = texture2D(colorTexture, v_textureCoordinates);
+ *         vec4 color = texture(colorTexture, v_textureCoordinates);
  *         if (czm_selected()) {
  *             vec3 highlighted = highlight.a * highlight.rgb + (1.0 - highlight.a) * color.rgb;
- *             gl_FragColor = vec4(highlighted, 1.0);
+ *             out_FragColor = vec4(highlighted, 1.0);
  *         } else {
- *             gl_FragColor = color;
+ *             out_FragColor = color;
  *         }
  *     }`;
  * const stage = scene.postProcessStages.add(new Cesium.PostProcessStage({
@@ -364,7 +364,7 @@ Object.defineProperties(PostProcessStage.prototype, {
    * if (czm_selected(v_textureCoordinates)) {
    *     // apply post-process stage
    * } else {
-   *     gl_FragColor = texture2D(colorTexture, v_textureCoordinates);
+   *     out_FragColor = texture(colorTexture, v_textureCoordinates);
    * }
    * </code>
    * </p>
@@ -556,22 +556,22 @@ function createDrawCommand(stage, context) {
   if (defined(stage._selectedIdTexture)) {
     const width = stage._selectedIdTexture.width;
 
-    fs = fs.replace(/varying\s+vec2\s+v_textureCoordinates;/g, "");
+    fs = fs.replace(/in\s+vec2\s+v_textureCoordinates;/g, "");
     fs =
       `${
         "#define CZM_SELECTED_FEATURE \n" +
         "uniform sampler2D czm_idTexture; \n" +
         "uniform sampler2D czm_selectedIdTexture; \n" +
         "uniform float czm_selectedIdTextureStep; \n" +
-        "varying vec2 v_textureCoordinates; \n" +
+        "in vec2 v_textureCoordinates; \n" +
         "bool czm_selected(vec2 offset) \n" +
         "{ \n" +
         "    bool selected = false;\n" +
-        "    vec4 id = texture2D(czm_idTexture, v_textureCoordinates + offset); \n" +
+        "    vec4 id = texture(czm_idTexture, v_textureCoordinates + offset); \n" +
         "    for (int i = 0; i < "
       }${width}; ++i) \n` +
       `    { \n` +
-      `        vec4 selectedId = texture2D(czm_selectedIdTexture, vec2((float(i) + 0.5) * czm_selectedIdTextureStep, 0.5)); \n` +
+      `        vec4 selectedId = texture(czm_selectedIdTexture, vec2((float(i) + 0.5) * czm_selectedIdTextureStep, 0.5)); \n` +
       `        if (all(equal(id, selectedId))) \n` +
       `        { \n` +
       `            return true; \n` +

package/Source/Scene/PostProcessStageLibrary.js

@@ -283,7 +283,7 @@ function getSilhouetteEdgeDetection(edgeDetectionStages) {
   for (let i = 0; i < edgeDetectionStages.length; ++i) {
     fsDecl += `uniform sampler2D edgeTexture${i}; \n`;
     fsLoop +=
-      `        vec4 edge${i} = texture2D(edgeTexture${i}, v_textureCoordinates); \n` +
+      `        vec4 edge${i} = texture(edgeTexture${i}, v_textureCoordinates); \n` +
       `        if (edge${i}.a > 0.0) \n` +
       `        { \n` +
       `            color = edge${i}; \n` +
@@ -293,12 +293,12 @@ function getSilhouetteEdgeDetection(edgeDetectionStages) {
   }
 
   const fs =
-    `${fsDecl}varying vec2 v_textureCoordinates; \n` +
+    `${fsDecl}in vec2 v_textureCoordinates; \n` +
     `void main() { \n` +
     `    vec4 color = vec4(0.0); \n` +
     `    for (int i = 0; i < ${edgeDetectionStages.length}; i++) \n` +
     `    { \n${fsLoop}    } \n` +
-    `    gl_FragColor = color; \n` +
+    `    out_FragColor = color; \n` +
     `} \n`;
 
   const edgeComposite = new PostProcessStage({

package/Source/Scene/Primitive.js

@@ -743,7 +743,7 @@ function cloneInstance(instance, geometry) {
   };
 }
 
-const positionRegex = /attribute\s+vec(?:3|4)\s+(.*)3DHigh;/g;
+const positionRegex = /in\s+vec(?:3|4)\s+(.*)3DHigh;/g;
 
 Primitive._modifyShaderPosition = function (
   primitive,
@@ -771,8 +771,7 @@ Primitive._modifyShaderPosition = function (
     if (!defined(primitive.rtcCenter)) {
       // Use GPU RTE
       if (!scene3DOnly) {
-        attributes +=
-          `attribute vec3 ${name}2DHigh;\n` + `attribute vec3 ${name}2DLow;\n`;
+        attributes += `in vec3 ${name}2DHigh;\nin vec3 ${name}2DLow;\n`;
 
         computeFunctions +=
           `${functionName}\n` +
@@ -805,16 +804,16 @@ Primitive._modifyShaderPosition = function (
     } else {
       // Use RTC
       vertexShaderSource = vertexShaderSource.replace(
-        /attribute\s+vec(?:3|4)\s+position3DHigh;/g,
+        /in\s+vec(?:3|4)\s+position3DHigh;/g,
         ""
       );
       vertexShaderSource = vertexShaderSource.replace(
-        /attribute\s+vec(?:3|4)\s+position3DLow;/g,
+        /in\s+vec(?:3|4)\s+position3DLow;/g,
         ""
       );
 
       forwardDecl += "uniform mat4 u_modifiedModelView;\n";
-      attributes += "attribute vec4 position;\n";
+      attributes += "in vec4 position;\n";
 
       computeFunctions +=
         `${functionName}\n` +
@@ -871,7 +870,7 @@ Primitive._updateColorAttribute = function (
     return vertexShaderSource;
   }
 
-  if (vertexShaderSource.search(/attribute\s+vec4\s+color;/g) === -1) {
+  if (vertexShaderSource.search(/in\s+vec4\s+color;/g) === -1) {
     return vertexShaderSource;
   }
 
@@ -887,7 +886,7 @@ Primitive._updateColorAttribute = function (
   //>>includeEnd('debug');
 
   let modifiedVS = vertexShaderSource;
-  modifiedVS = modifiedVS.replace(/attribute\s+vec4\s+color;/g, "");
+  modifiedVS = modifiedVS.replace(/in\s+vec4\s+color;/g, "");
   if (!isDepthFail) {
     modifiedVS = modifiedVS.replace(
       /(\b)color(\b)/g,
@@ -905,7 +904,7 @@ Primitive._updateColorAttribute = function (
 function appendPickToVertexShader(source) {
   const renamedVS = ShaderSource.replaceMain(source, "czm_non_pick_main");
   const pickMain =
-    "varying vec4 v_pickColor; \n" +
+    "out vec4 v_pickColor; \n" +
     "void main() \n" +
     "{ \n" +
     "    czm_non_pick_main(); \n" +
@@ -916,11 +915,11 @@ function appendPickToVertexShader(source) {
 }
 
 function appendPickToFragmentShader(source) {
-  return `varying vec4 v_pickColor;\n${source}`;
+  return `in vec4 v_pickColor;\n${source}`;
 }
 
 Primitive._updatePickColorAttribute = function (source) {
-  let vsPick = source.replace(/attribute\s+vec4\s+pickColor;/g, "");
+  let vsPick = source.replace(/in\s+vec4\s+pickColor;/g, "");
   vsPick = vsPick.replace(
     /(\b)pickColor(\b)/g,
     "$1czm_batchTable_pickColor(batchId)$2"
@@ -933,10 +932,10 @@ Primitive._appendOffsetToShader = function (primitive, vertexShaderSource) {
     return vertexShaderSource;
   }
 
-  let attr = "attribute float batchId;\n";
-  attr += "attribute float applyOffset;";
+  let attr = "in float batchId;\n";
+  attr += "in float applyOffset;";
   let modifiedShader = vertexShaderSource.replace(
-    /attribute\s+float\s+batchId;/g,
+    /in\s+float\s+batchId;/g,
     attr
   );
 
@@ -1033,17 +1032,16 @@ function modifyForEncodedNormals(primitive, vertexShaderSource) {
   }
 
   const containsNormal =
-    vertexShaderSource.search(/attribute\s+vec3\s+normal;/g) !== -1;
-  const containsSt =
-    vertexShaderSource.search(/attribute\s+vec2\s+st;/g) !== -1;
+    vertexShaderSource.search(/in\s+vec3\s+normal;/g) !== -1;
+  const containsSt = vertexShaderSource.search(/in\s+vec2\s+st;/g) !== -1;
   if (!containsNormal && !containsSt) {
     return vertexShaderSource;
   }
 
   const containsTangent =
-    vertexShaderSource.search(/attribute\s+vec3\s+tangent;/g) !== -1;
+    vertexShaderSource.search(/in\s+vec3\s+tangent;/g) !== -1;
   const containsBitangent =
-    vertexShaderSource.search(/attribute\s+vec3\s+bitangent;/g) !== -1;
+    vertexShaderSource.search(/in\s+vec3\s+bitangent;/g) !== -1;
 
   let numComponents = containsSt && containsNormal ? 2.0 : 1.0;
   numComponents += containsTangent || containsBitangent ? 1 : 0;
@@ -1051,7 +1049,7 @@ function modifyForEncodedNormals(primitive, vertexShaderSource) {
   const type = numComponents > 1 ? `vec${numComponents}` : "float";
 
   const attributeName = "compressedAttributes";
-  const attributeDecl = `attribute ${type} ${attributeName};`;
+  const attributeDecl = `in ${type} ${attributeName};`;
 
   let globalDecl = "";
   let decode = "";
@@ -1092,10 +1090,10 @@ function modifyForEncodedNormals(primitive, vertexShaderSource) {
   }
 
   let modifiedVS = vertexShaderSource;
-  modifiedVS = modifiedVS.replace(/attribute\s+vec3\s+normal;/g, "");
-  modifiedVS = modifiedVS.replace(/attribute\s+vec2\s+st;/g, "");
-  modifiedVS = modifiedVS.replace(/attribute\s+vec3\s+tangent;/g, "");
-  modifiedVS = modifiedVS.replace(/attribute\s+vec3\s+bitangent;/g, "");
+  modifiedVS = modifiedVS.replace(/in\s+vec3\s+normal;/g, "");
+  modifiedVS = modifiedVS.replace(/in\s+vec2\s+st;/g, "");
+  modifiedVS = modifiedVS.replace(/in\s+vec3\s+tangent;/g, "");
+  modifiedVS = modifiedVS.replace(/in\s+vec3\s+bitangent;/g, "");
   modifiedVS = ShaderSource.replaceMain(modifiedVS, "czm_non_compressed_main");
   const compressedMain =
     `${"void main() \n" + "{ \n"}${decode}    czm_non_compressed_main(); \n` +
@@ -1125,19 +1123,12 @@ function depthClampFS(fragmentShaderSource) {
   modifiedFS +=
     "void main() {\n" +
     "    czm_non_depth_clamp_main();\n" +
-    "#if defined(GL_EXT_frag_depth)\n" +
     "    #if defined(LOG_DEPTH)\n" +
     "        czm_writeLogDepth();\n" +
     "    #else\n" +
     "        czm_writeDepthClamp();\n" +
     "    #endif\n" +
-    "#endif\n" +
     "}\n";
-  modifiedFS = `${
-    "#ifdef GL_EXT_frag_depth\n" +
-    "#extension GL_EXT_frag_depth : enable\n" +
-    "#endif\n"
-  }${modifiedFS}`;
   return modifiedFS;
 }
 

package/Source/Scene/ShadowMap.js

@@ -763,7 +763,7 @@ function createDebugShadowViewCommand(shadowMap, context) {
   if (shadowMap._isPointLight) {
     fs =
       "uniform samplerCube shadowMap_textureCube; \n" +
-      "varying vec2 v_textureCoordinates; \n" +
+      "in vec2 v_textureCoordinates; \n" +
       "void main() \n" +
       "{ \n" +
       "    vec2 uv = v_textureCoordinates; \n" +
@@ -812,21 +812,21 @@ function createDebugShadowViewCommand(shadowMap, context) {
       "        } \n" +
       "    } \n" +
       " \n" +
-      "    float shadow = czm_unpackDepth(textureCube(shadowMap_textureCube, dir)); \n" +
-      "    gl_FragColor = vec4(vec3(shadow), 1.0); \n" +
+      "    float shadow = czm_unpackDepth(czm_textureCube(shadowMap_textureCube, dir)); \n" +
+      "    out_FragColor = vec4(vec3(shadow), 1.0); \n" +
       "} \n";
   } else {
     fs =
       `${
         "uniform sampler2D shadowMap_texture; \n" +
-        "varying vec2 v_textureCoordinates; \n" +
+        "in vec2 v_textureCoordinates; \n" +
         "void main() \n" +
         "{ \n"
       }${
         shadowMap._usesDepthTexture
-          ? "    float shadow = texture2D(shadowMap_texture, v_textureCoordinates).r; \n"
-          : "    float shadow = czm_unpackDepth(texture2D(shadowMap_texture, v_textureCoordinates)); \n"
-      }    gl_FragColor = vec4(vec3(shadow), 1.0); \n` + `} \n`;
+          ? "    float shadow = texture(shadowMap_texture, v_textureCoordinates).r; \n"
+          : "    float shadow = czm_unpackDepth(texture(shadowMap_texture, v_textureCoordinates)); \n"
+      }    out_FragColor = vec4(vec3(shadow), 1.0); \n` + `} \n`;
   }
 
   const drawCommand = context.createViewportQuadCommand(fs, {

package/Source/Scene/ShadowMapShader.js

@@ -39,7 +39,7 @@ ShadowMapShader.createShadowCastVertexShader = function (
     }
 
     const shadowVS =
-      "varying vec3 v_positionEC; \n" +
+      "in vec3 v_positionEC; \n" +
       "void main() \n" +
       "{ \n" +
       "    czm_shadow_cast_main(); \n" +
@@ -80,7 +80,7 @@ ShadowMapShader.createShadowCastFragmentShader = function (
 
   if (isPointLight) {
     if (!hasPositionVarying) {
-      fsSource += "varying vec3 v_positionEC; \n";
+      fsSource += "in vec3 v_positionEC; \n";
     }
     fsSource += "uniform vec4 shadowMap_lightPositionEC; \n";
   }
@@ -92,7 +92,7 @@ ShadowMapShader.createShadowCastFragmentShader = function (
       "void main() \n" +
       "{ \n" +
       "    czm_shadow_cast_main(); \n" +
-      "    if (gl_FragColor.a == 0.0) \n" +
+      "    if (out_FragColor.a == 0.0) \n" +
       "    { \n" +
       "       discard; \n" +
       "    } \n";
@@ -106,11 +106,11 @@ ShadowMapShader.createShadowCastFragmentShader = function (
       `        discard; \n` +
       `    } \n` +
       `    distance /= shadowMap_lightPositionEC.w; // radius \n` +
-      `    gl_FragColor = czm_packDepth(distance); \n`;
+      `    out_FragColor = czm_packDepth(distance); \n`;
   } else if (usesDepthTexture) {
-    fsSource += "    gl_FragColor = vec4(1.0); \n";
+    fsSource += "    out_FragColor = vec4(1.0); \n";
   } else {
-    fsSource += "    gl_FragColor = czm_packDepth(gl_FragCoord.z); \n";
+    fsSource += "    out_FragColor = czm_packDepth(gl_FragCoord.z); \n";
   }
 
   fsSource += "} \n";
@@ -257,7 +257,7 @@ ShadowMapShader.createShadowReceiveFragmentShader = function (
       "uniform vec4 shadowMap_normalOffsetScaleDistanceMaxDistanceAndDarkness; \n" +
       "uniform vec4 shadowMap_texelSizeDepthBiasAndNormalShadingSmooth; \n" +
       "#ifdef LOG_DEPTH \n" +
-      "varying vec3 v_logPositionEC; \n" +
+      "in vec3 v_logPositionEC; \n" +
       "#endif \n" +
       "vec4 getPositionEC() \n" +
       "{ \n"
@@ -364,7 +364,7 @@ ShadowMapShader.createShadowReceiveFragmentShader = function (
     }${
       debugCascadeColors
         ? "    // Draw cascade colors for debugging \n" +
-          "    gl_FragColor *= czm_cascadeColor(weights); \n"
+          "    out_FragColor *= czm_cascadeColor(weights); \n"
         : ""
     }`;
   } else {
@@ -383,7 +383,7 @@ ShadowMapShader.createShadowReceiveFragmentShader = function (
       "    float visibility = czm_shadowVisibility(shadowMap_texture, shadowParameters); \n";
   }
 
-  fsSource += "    gl_FragColor.rgb *= visibility; \n" + "} \n";
+  fsSource += "    out_FragColor.rgb *= visibility; \n" + "} \n";
 
   sources.push(fsSource);
 

package/Source/Scene/ShadowVolumeAppearance.js

@@ -168,7 +168,7 @@ ShadowVolumeAppearance.prototype.createPickFragmentShader = function (
   return new ShaderSource({
     defines: defines,
     sources: [ShadowVolumeAppearanceFS],
-    pickColorQualifier: "varying",
+    pickColorQualifier: "in",
   });
 };
 

package/Source/Scene/TextureAtlas.js

@@ -498,17 +498,19 @@ TextureAtlas.prototype.addSubRegion = function (id, subRegion) {
     }
     const atlasWidth = that._texture.width;
     const atlasHeight = that._texture.height;
-    const numImages = that.numberOfImages;
 
     const baseRegion = that._textureCoordinates[index];
     const x = baseRegion.x + subRegion.x / atlasWidth;
     const y = baseRegion.y + subRegion.y / atlasHeight;
     const w = subRegion.width / atlasWidth;
     const h = subRegion.height / atlasHeight;
-    that._textureCoordinates.push(new BoundingRectangle(x, y, w, h));
+    const newIndex =
+      that._textureCoordinates.push(new BoundingRectangle(x, y, w, h)) - 1;
+    that._indexHash[id] = newIndex;
+
     that._guid = createGuid();
 
-    return numImages;
+    return newIndex;
   });
 };
 

package/Source/Scene/Vector3DTilePolylines.js

@@ -421,7 +421,7 @@ const PolylineFS =
   "uniform vec4 u_highlightColor; \n" +
   "void main()\n" +
   "{\n" +
-  "    gl_FragColor = u_highlightColor;\n" +
+  "    out_FragColor = u_highlightColor;\n" +
   "}\n";
 
 function createShaders(primitive, context) {

package/Source/Scene/Vector3DTilePrimitive.js

@@ -283,7 +283,7 @@ function createShaders(primitive, context) {
       `${fragmentShaderSource}void main() \n` +
       `{ \n` +
       `    czm_non_pick_main(); \n` +
-      `    gl_FragColor = ${pickId}; \n` +
+      `    out_FragColor = ${pickId}; \n` +
       `} \n`;
     primitive._spPick = ShaderProgram.fromCache({
       context: context,
@@ -343,7 +343,7 @@ function createShaders(primitive, context) {
     `void main() \n` +
     `{ \n` +
     `    czm_non_pick_main(); \n` +
-    `    gl_FragColor = ${pickId}; \n` +
+    `    out_FragColor = ${pickId}; \n` +
     `} \n`;
 
   const pickVS = new ShaderSource({

package/Source/Scene/VoxelEllipsoidShape.js

@@ -104,6 +104,7 @@ function VoxelEllipsoidShape() {
     ellipsoidInverseHeightDifferenceUv: 0.0,
     ellipseInnerRadiiUv: new Cartesian2(),
     ellipsoidInverseInnerScaleUv: 0.0,
+    ellipsoidInverseOuterScaleUv: 0.0,
   };
 
   /**
@@ -131,7 +132,9 @@ function VoxelEllipsoidShape() {
     ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_RANGE_EQUAL_ZERO: undefined,
     ELLIPSOID_HAS_SHAPE_BOUNDS_LATITUDE: undefined,
     ELLIPSOID_HAS_SHAPE_BOUNDS_LATITUDE_RANGE_EQUAL_ZERO: undefined,
+    ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_MAX: undefined,
     ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_MIN: undefined,
+    ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_FLAT: undefined,
     ELLIPSOID_HAS_SHAPE_BOUNDS_HEIGHT_MIN: undefined,
     ELLIPSOID_HAS_SHAPE_BOUNDS_HEIGHT_FLAT: undefined,
     ELLIPSOID_IS_SPHERE: undefined,
@@ -305,7 +308,6 @@ VoxelEllipsoidShape.prototype.update = function (
     ),
     scratchRenderOuterExtent
   );
-  const renderMaxExtent = Cartesian3.maximumComponent(renderOuterExtent);
 
   // Exit early if the shape is not visible.
   // Note that minLongitude may be greater than maxLongitude when crossing the 180th meridian.
@@ -355,7 +357,7 @@ VoxelEllipsoidShape.prototype.update = function (
   );
 
   this.shapeTransform = Matrix4.fromRotationTranslation(
-    Matrix3.setScale(this._rotation, renderOuterExtent, scratchRotationScale),
+    Matrix3.setScale(this._rotation, shapeOuterExtent, scratchRotationScale),
     this._translation,
     this.shapeTransform
   );
@@ -393,7 +395,7 @@ VoxelEllipsoidShape.prototype.update = function (
     renderIsLongitudeRangeHalf ||
     renderIsLongitudeRangeOverHalf;
 
-  const shapeIsLongitudeReversed = renderMaxLongitude < renderMinLongitude;
+  const shapeIsLongitudeReversed = shapeMaxLongitude < shapeMinLongitude;
   const shapeLongitudeRange =
     shapeMaxLongitude -
     shapeMinLongitude +
@@ -532,12 +534,18 @@ VoxelEllipsoidShape.prototype.update = function (
       ] = intersectionCount;
       intersectionCount += 1;
 
-      // The inverse of the percent of space that is taken up by the inner ellipsoid.
+      // The inverse of the percent of space that is taken up by the inner ellipsoid, relative to the shape bounds
       // 1.0 / (1.0 - thickness) // thickness = percent of space that is between the min and max height.
-      // 1.0 / (1.0 - (renderMaxHeight - renderMinHeight) / renderMaxExtent)
-      // renderMaxExtent / (renderMaxExtent - (renderMaxHeight - renderMinHeight))
+      // 1.0 / (1.0 - (shapeMaxHeight - renderMinHeight) / shapeMaxExtent)
+      // shapeMaxExtent / (shapeMaxExtent - (shapeMaxHeight - renderMinHeight))
       shaderUniforms.ellipsoidInverseInnerScaleUv =
-        renderMaxExtent / (renderMaxExtent - renderHeightRange);
+        shapeMaxExtent / (shapeMaxExtent - (shapeMaxHeight - renderMinHeight));
+    }
+
+    if (renderHasMaxHeight) {
+      shaderDefines["ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_MAX"] = true;
+      shaderUniforms.ellipsoidInverseOuterScaleUv =
+        shapeMaxExtent / (shapeMaxExtent - (shapeMaxHeight - renderMaxHeight));
     }
   }
 

package/Source/Scene/VoxelPrimitive.js

@@ -1137,13 +1137,13 @@ VoxelPrimitive.prototype.update = function (frameState) {
     uniforms.ndcSpaceAxisAlignedBoundingBox
   );
   const transformPositionViewToWorld = context.uniformState.inverseView;
-  uniforms.transformPositionViewToUv = Matrix4.multiply(
+  uniforms.transformPositionViewToUv = Matrix4.multiplyTransformation(
     this._transformPositionWorldToUv,
     transformPositionViewToWorld,
     uniforms.transformPositionViewToUv
   );
   const transformPositionWorldToView = context.uniformState.view;
-  uniforms.transformPositionUvToView = Matrix4.multiply(
+  uniforms.transformPositionUvToView = Matrix4.multiplyTransformation(
     transformPositionWorldToView,
     this._transformPositionUvToWorld,
     uniforms.transformPositionUvToView
@@ -1365,12 +1365,12 @@ function updateShapeAndTransforms(primitive, shape, provider) {
   // Set member variables when the shape is dirty
   const dimensions = provider.dimensions;
   primitive._stepSizeUv = shape.computeApproximateStepSize(dimensions);
-  primitive._transformPositionWorldToUv = Matrix4.multiply(
+  primitive._transformPositionWorldToUv = Matrix4.multiplyTransformation(
     transformPositionLocalToUv,
     transformPositionWorldToLocal,
     primitive._transformPositionWorldToUv
   );
-  primitive._transformPositionUvToWorld = Matrix4.multiply(
+  primitive._transformPositionUvToWorld = Matrix4.multiplyTransformation(
     transformPositionLocalToWorld,
     transformPositionUvToLocal,
     primitive._transformPositionUvToWorld

package/Source/Scene/computeFlyToLocationForRectangle.js

@@ -49,16 +49,25 @@ function computeFlyToLocationForRectangle(rectangle, scene) {
     return computeFlyToLocationForRectangle
       ._sampleTerrainMostDetailed(terrainProvider, cartographics)
       .then(function (positionsOnTerrain) {
+        let heightFound = false;
         const maxHeight = positionsOnTerrain.reduce(function (
           currentMax,
           item
         ) {
+          if (!defined(item.height)) {
+            return currentMax;
+          }
+          heightFound = true;
           return Math.max(item.height, currentMax);
         },
         -Number.MAX_VALUE);
 
         const finalPosition = positionWithoutTerrain;
-        finalPosition.height += maxHeight;
+
+        if (heightFound) {
+          finalPosition.height += maxHeight;
+        }
+
         return finalPosition;
       });
   });

package/Source/Scene/createElevationBandMaterial.js

@@ -462,9 +462,7 @@ function createLayeredEntries(layers) {
  * });
  */
 function createElevationBandMaterial(options) {
-  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
-  const scene = options.scene;
-  const layers = options.layers;
+  const { scene, layers } = defaultValue(options, defaultValue.EMPTY_OBJECT);
 
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("options.scene", scene);
@@ -472,36 +470,34 @@ function createElevationBandMaterial(options) {
   Check.typeOf.number.greaterThan("options.layers.length", layers.length, 0);
   //>>includeEnd('debug');
 
+  const { context } = scene;
   const entries = createLayeredEntries(layers);
   const entriesLength = entries.length;
-  let i;
 
   let heightTexBuffer;
   let heightTexDatatype;
   let heightTexFormat;
 
-  const isPackedHeight = !createElevationBandMaterial._useFloatTexture(
-    scene.context
-  );
+  const isPackedHeight = !createElevationBandMaterial._useFloatTexture(context);
   if (isPackedHeight) {
     heightTexDatatype = PixelDatatype.UNSIGNED_BYTE;
     heightTexFormat = PixelFormat.RGBA;
     heightTexBuffer = new Uint8Array(entriesLength * 4);
-    for (i = 0; i < entriesLength; i++) {
+    for (let i = 0; i < entriesLength; i++) {
       Cartesian4.packFloat(entries[i].height, scratchPackedFloat);
       Cartesian4.pack(scratchPackedFloat, heightTexBuffer, i * 4);
     }
   } else {
     heightTexDatatype = PixelDatatype.FLOAT;
-    heightTexFormat = PixelFormat.LUMINANCE;
+    heightTexFormat = context.webgl2 ? PixelFormat.RED : PixelFormat.LUMINANCE;
     heightTexBuffer = new Float32Array(entriesLength);
-    for (i = 0; i < entriesLength; i++) {
+    for (let i = 0; i < entriesLength; i++) {
       heightTexBuffer[i] = entries[i].height;
     }
   }
 
   const heightsTex = Texture.create({
-    context: scene.context,
+    context: context,
     pixelFormat: heightTexFormat,
     pixelDatatype: heightTexDatatype,
     source: {
@@ -518,7 +514,7 @@ function createElevationBandMaterial(options) {
   });
 
   const colorsArray = new Uint8Array(entriesLength * 4);
-  for (i = 0; i < entriesLength; i++) {
+  for (let i = 0; i < entriesLength; i++) {
     const color = entries[i].color;
     color.toBytes(scratchColorBytes);
     colorsArray[i * 4 + 0] = scratchColorBytes[0];
@@ -528,7 +524,7 @@ function createElevationBandMaterial(options) {
   }
 
   const colorsTex = Texture.create({
-    context: scene.context,
+    context: context,
     pixelFormat: PixelFormat.RGBA,
     pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
     source: {
@@ -544,11 +540,10 @@ function createElevationBandMaterial(options) {
     }),
   });
 
-  const material = Material.fromType("ElevationBand", {
+  return Material.fromType("ElevationBand", {
     heights: heightsTex,
     colors: colorsTex,
   });
-  return material;
 }
 
 /**

package/Source/Scene/getClipAndStyleCode.js

@@ -27,7 +27,7 @@ function getClipAndStyleCode(
     `    float clippingPlanesEdgeWidth = ${styleUniformName}.a; \n` +
     `    if (clipDistance > 0.0 && clipDistance < clippingPlanesEdgeWidth) \n` +
     `    { \n` +
-    `        gl_FragColor = clippingPlanesEdgeColor;\n` +
+    `        out_FragColor = clippingPlanesEdgeColor;\n` +
     `    } \n`;
   return shaderCode;
 }