@cesium/engine 1.1.0 → 2.0.0

package/Source/Scene/Cesium3DTileset.js

@@ -167,6 +167,7 @@ function Cesium3DTileset(options) {
   this._asset = undefined; // Metadata for the entire tileset
   this._properties = undefined; // Metadata for per-model/point/etc properties
   this._geometricError = undefined; // Geometric error when the tree is not rendered at all
+  this._scaledGeometricError = undefined; // Geometric error scaled by root tile scale
   this._extensionsUsed = undefined;
   this._extensions = undefined;
   this._modelUpAxis = undefined;
@@ -1007,6 +1008,11 @@ function Cesium3DTileset(options) {
         return;
       }
 
+      // Set these before loading the tileset since _geometricError
+      // and _scaledGeometricError get accessed during tile creation
+      that._geometricError = tilesetJson.geometricError;
+      that._scaledGeometricError = tilesetJson.geometricError;
+
       that._root = that.loadTileset(resource, tilesetJson);
 
       // Handle legacy gltfUpAxis option
@@ -1019,7 +1025,6 @@ function Cesium3DTileset(options) {
       const asset = tilesetJson.asset;
       that._asset = asset;
       that._properties = tilesetJson.properties;
-      that._geometricError = tilesetJson.geometricError;
       that._extensionsUsed = tilesetJson.extensionsUsed;
       that._extensions = tilesetJson.extensions;
       that._modelUpAxis = modelUpAxis;

package/Source/Scene/ClassificationPrimitive.js

@@ -493,22 +493,17 @@ function modifyForEncodedNormals(primitive, vertexShaderSource) {
     return vertexShaderSource;
   }
 
-  if (
-    vertexShaderSource.search(/attribute\s+vec3\s+extrudeDirection;/g) !== -1
-  ) {
+  if (vertexShaderSource.search(/in\s+vec3\s+extrudeDirection;/g) !== -1) {
     const attributeName = "compressedAttributes";
 
     //only shadow volumes use extrudeDirection, and shadow volumes use vertexFormat: POSITION_ONLY so we don't need to check other attributes
-    const attributeDecl = `attribute vec2 ${attributeName};`;
+    const attributeDecl = `in vec2 ${attributeName};`;
 
     const globalDecl = "vec3 extrudeDirection;\n";
     const decode = `    extrudeDirection = czm_octDecode(${attributeName}, 65535.0);\n`;
 
     let modifiedVS = vertexShaderSource;
-    modifiedVS = modifiedVS.replace(
-      /attribute\s+vec3\s+extrudeDirection;/g,
-      ""
-    );
+    modifiedVS = modifiedVS.replace(/in\s+vec3\s+extrudeDirection;/g, "");
     modifiedVS = ShaderSource.replaceMain(
       modifiedVS,
       "czm_non_compressed_main"

package/Source/Scene/DebugAppearance.js

@@ -88,14 +88,12 @@ function DebugAppearance(options) {
 
   const vs =
     `${
-      "attribute vec3 position3DHigh;\n" +
-      "attribute vec3 position3DLow;\n" +
-      "attribute float batchId;\n"
+      "in vec3 position3DHigh;\n" +
+      "in vec3 position3DLow;\n" +
+      "in float batchId;\n"
     }${
-      perInstanceAttribute
-        ? ""
-        : `attribute ${glslDatatype} ${attributeName};\n`
-    }varying ${glslDatatype} ${varyingName};\n` +
+      perInstanceAttribute ? "" : `in ${glslDatatype} ${attributeName};\n`
+    }out ${glslDatatype} ${varyingName};\n` +
     `void main()\n` +
     `{\n` +
     `vec4 p = czm_translateRelativeToEye(position3DHigh, position3DLow);\n${
@@ -105,10 +103,10 @@ function DebugAppearance(options) {
     }gl_Position = czm_modelViewProjectionRelativeToEye * p;\n` +
     `}`;
   const fs =
-    `varying ${glslDatatype} ${varyingName};\n${getColor}\n` +
+    `in ${glslDatatype} ${varyingName};\n${getColor}\n` +
     `void main()\n` +
     `{\n` +
-    `gl_FragColor = getColor();\n` +
+    `out_FragColor = getColor();\n` +
     `}`;
 
   /**

package/Source/Scene/DebugInspector.js

@@ -31,7 +31,7 @@ function createDebugShowFrustumsShaderProgram(scene, shaderProgram) {
   const targets = [];
   fs.sources = fs.sources.map(function (source) {
     source = ShaderSource.replaceMain(source, "czm_Debug_main");
-    const re = /gl_FragData\[(\d+)\]/g;
+    const re = /out_FragData_(\d+)/g;
     let match;
     while ((match = re.exec(source)) !== null) {
       if (targets.indexOf(match[1]) === -1) {
@@ -52,12 +52,12 @@ function createDebugShowFrustumsShaderProgram(scene, shaderProgram) {
   let i;
   if (length > 0) {
     for (i = 0; i < length; ++i) {
-      newMain += `    gl_FragData[${targets[i]}].rgb *= debugShowCommandsColor;\n`;
-      newMain += `    gl_FragData[${targets[i]}].rgb *= debugShowFrustumsColor;\n`;
+      newMain += `    out_FragData_${targets[i]}.rgb *= debugShowCommandsColor;\n`;
+      newMain += `    out_FragData_${targets[i]}.rgb *= debugShowFrustumsColor;\n`;
     }
   } else {
-    newMain += "    gl_FragColor.rgb *= debugShowCommandsColor;\n";
-    newMain += "    gl_FragColor.rgb *= debugShowFrustumsColor;\n";
+    newMain += "    out_FragColor.rgb *= debugShowCommandsColor;\n";
+    newMain += "    out_FragColor.rgb *= debugShowFrustumsColor;\n";
   }
   newMain += "}";
 

package/Source/Scene/DepthPlane.js

@@ -173,12 +173,6 @@ DepthPlane.prototype.update = function (frameState) {
       sources: [DepthPlaneFS],
     });
     if (useLogDepth) {
-      const extension =
-        "#ifdef GL_EXT_frag_depth \n" +
-        "#extension GL_EXT_frag_depth : enable \n" +
-        "#endif \n\n";
-
-      fs.sources.push(extension);
       fs.defines.push("LOG_DEPTH");
       vs.defines.push("LOG_DEPTH");
     }

package/Source/Scene/DerivedCommand.js

@@ -8,7 +8,7 @@ import ShaderSource from "../Renderer/ShaderSource.js";
  */
 function DerivedCommand() {}
 
-const fragDepthRegex = /\bgl_FragDepthEXT\b/;
+const fragDepthRegex = /\bgl_FragDepth\b/;
 const discardRegex = /\bdiscard\b/;
 
 function getDepthOnlyShaderProgram(context, shaderProgram) {
@@ -44,18 +44,18 @@ function getDepthOnlyShaderProgram(context, shaderProgram) {
     let source;
     if (!writesDepthOrDiscards && !usesLogDepth) {
       source =
-        "void main() \n" + "{ \n" + "    gl_FragColor = vec4(1.0); \n" + "} \n";
+        "void main() \n" +
+        "{ \n" +
+        "    out_FragColor = vec4(1.0); \n" +
+        "} \n";
       fs = new ShaderSource({
         sources: [source],
       });
     } else if (!writesDepthOrDiscards && usesLogDepth) {
       source =
-        "#ifdef GL_EXT_frag_depth \n" +
-        "#extension GL_EXT_frag_depth : enable \n" +
-        "#endif \n\n" +
         "void main() \n" +
         "{ \n" +
-        "    gl_FragColor = vec4(1.0); \n" +
+        "    out_FragColor = vec4(1.0); \n" +
         "    czm_writeLogDepth(); \n" +
         "} \n";
       fs = new ShaderSource({
@@ -145,7 +145,6 @@ DerivedCommand.createDepthOnlyDerivedCommand = function (
 
 const writeLogDepthRegex = /\s+czm_writeLogDepth\(/;
 const vertexlogDepthRegex = /\s+czm_vertexLogDepth\(/;
-const extensionRegex = /\s*#extension\s+GL_EXT_frag_depth\s*:\s*enable/;
 
 function getLogDepthShaderProgram(context, shaderProgram) {
   const disableLogDepthWrite =
@@ -210,20 +209,7 @@ function getLogDepthShaderProgram(context, shaderProgram) {
       writesLogDepth = true;
     }
 
-    let addExtension = true;
-    for (i = 0; i < length; ++i) {
-      if (extensionRegex.test(sources[i])) {
-        addExtension = false;
-      }
-    }
-
     let logSource = "";
-    if (addExtension) {
-      logSource +=
-        "#ifdef GL_EXT_frag_depth \n" +
-        "#extension GL_EXT_frag_depth : enable \n" +
-        "#endif \n\n";
-    }
 
     if (!writesLogDepth) {
       for (i = 0; i < length; i++) {
@@ -297,10 +283,10 @@ function getPickShaderProgram(context, shaderProgram, pickId) {
         "void main() \n" +
         "{ \n" +
         "    czm_non_pick_main(); \n" +
-        "    if (gl_FragColor.a == 0.0) { \n" +
+        "    if (out_FragColor.a == 0.0) { \n" +
         "        discard; \n" +
         "    } \n" +
-        "    gl_FragColor = "
+        "    out_FragColor = "
       }${pickId}; \n` + `} \n`;
     const newSources = new Array(length + 1);
     for (let i = 0; i < length; ++i) {

package/Source/Scene/EllipsoidPrimitive.js

@@ -238,11 +238,6 @@ function getVertexArray(context) {
   return vertexArray;
 }
 
-const logDepthExtension =
-  "#ifdef GL_EXT_frag_depth \n" +
-  "#extension GL_EXT_frag_depth : enable \n" +
-  "#endif \n\n";
-
 /**
  * Called when {@link Viewer} or {@link CesiumWidget} render the scene to
  * get the draw commands needed to render this primitive.
@@ -378,7 +373,6 @@ EllipsoidPrimitive.prototype.update = function (frameState) {
     if (this._useLogDepth) {
       vs.defines.push("LOG_DEPTH");
       fs.defines.push("LOG_DEPTH");
-      fs.sources.push(logDepthExtension);
     }
 
     this._sp = ShaderProgram.replaceCache({
@@ -443,7 +437,6 @@ EllipsoidPrimitive.prototype.update = function (frameState) {
       if (this._useLogDepth) {
         vs.defines.push("LOG_DEPTH");
         fs.defines.push("LOG_DEPTH");
-        fs.sources.push(logDepthExtension);
       }
 
       this._pickSP = ShaderProgram.replaceCache({

package/Source/Scene/GlobeTranslucencyState.js

@@ -401,7 +401,7 @@ function getDepthOnlyShaderProgram(vs, fs) {
   }
 
   const depthOnlyShader =
-    "void main() \n" + "{ \n" + "    gl_FragColor = vec4(1.0); \n" + "} \n";
+    "void main() \n" + "{ \n" + "    out_FragColor = vec4(1.0); \n" + "} \n";
 
   fs.sources = [depthOnlyShader];
 }
@@ -423,7 +423,7 @@ function getTranslucentShaderProgram(vs, fs) {
     "{ \n" +
     "    vec2 st = gl_FragCoord.xy / czm_viewport.zw; \n" +
     "#ifdef MANUAL_DEPTH_TEST \n" +
-    "    float logDepthOrDepth = czm_unpackDepth(texture2D(czm_globeDepthTexture, st)); \n" +
+    "    float logDepthOrDepth = czm_unpackDepth(texture(czm_globeDepthTexture, st)); \n" +
     "    if (logDepthOrDepth != 0.0) \n" +
     "    { \n" +
     "        vec4 eyeCoordinate = czm_windowToEyeCoordinates(gl_FragCoord.xy, logDepthOrDepth); \n" +
@@ -435,13 +435,13 @@ function getTranslucentShaderProgram(vs, fs) {
     "    } \n" +
     "#endif \n" +
     "    czm_globe_translucency_main(); \n" +
-    "    vec4 classificationColor = texture2D(u_classificationTexture, st); \n" +
+    "    vec4 classificationColor = texture(u_classificationTexture, st); \n" +
     "    if (classificationColor.a > 0.0) \n" +
     "    { \n" +
     "        // Reverse premultiplication process to get the correct composited result of the classification primitives \n" +
     "        classificationColor.rgb /= classificationColor.a; \n" +
     "    } \n" +
-    "    gl_FragColor = classificationColor * vec4(classificationColor.aaa, 1.0) + gl_FragColor * (1.0 - classificationColor.a); \n" +
+    "    out_FragColor = classificationColor * vec4(classificationColor.aaa, 1.0) + out_FragColor * (1.0 - classificationColor.a); \n" +
     "} \n";
 
   sources.push(globeTranslucencyMain);
@@ -473,12 +473,12 @@ function getPickShaderProgram(vs, fs) {
     "void main() \n" +
     "{ \n" +
     "    vec2 st = gl_FragCoord.xy / czm_viewport.zw; \n" +
-    "    vec4 pickColor = texture2D(u_classificationTexture, st); \n" +
+    "    vec4 pickColor = texture(u_classificationTexture, st); \n" +
     "    if (pickColor == vec4(0.0)) \n" +
     "    { \n" +
     "        discard; \n" +
     "    } \n" +
-    "    gl_FragColor = pickColor; \n" +
+    "    out_FragColor = pickColor; \n" +
     "} \n";
 
   fs.sources = [pickShader];

package/Source/Scene/GroundPolylinePrimitive.js

@@ -405,12 +405,10 @@ function createShaderProgram(groundPolylinePrimitive, frameState, appearance) {
 
     // Check for use of v_width and v_polylineAngle in material shader
     // to determine whether these varyings should be active in the vertex shader.
-    if (
-      materialShaderSource.search(/varying\s+float\s+v_polylineAngle;/g) !== -1
-    ) {
+    if (materialShaderSource.search(/in\s+float\s+v_polylineAngle;/g) !== -1) {
       vsDefines.push("ANGLE_VARYING");
     }
-    if (materialShaderSource.search(/varying\s+float\s+v_width;/g) !== -1) {
+    if (materialShaderSource.search(/in\s+float\s+v_width;/g) !== -1) {
       vsDefines.push("WIDTH_VARYING");
     }
   } else {

package/Source/Scene/InvertClassification.js

@@ -126,19 +126,18 @@ const rsDefault = {
 };
 
 const translucentFS =
-  "#extension GL_EXT_frag_depth : enable\n" +
   "uniform sampler2D colorTexture;\n" +
   "uniform sampler2D depthTexture;\n" +
   "uniform sampler2D classifiedTexture;\n" +
-  "varying vec2 v_textureCoordinates;\n" +
+  "in vec2 v_textureCoordinates;\n" +
   "void main()\n" +
   "{\n" +
-  "    vec4 color = texture2D(colorTexture, v_textureCoordinates);\n" +
+  "    vec4 color = texture(colorTexture, v_textureCoordinates);\n" +
   "    if (color.a == 0.0)\n" +
   "    {\n" +
   "        discard;\n" +
   "    }\n" +
-  "    bool isClassified = all(equal(texture2D(classifiedTexture, v_textureCoordinates), vec4(0.0)));\n" +
+  "    bool isClassified = all(equal(texture(classifiedTexture, v_textureCoordinates), vec4(0.0)));\n" +
   "#ifdef UNCLASSIFIED\n" +
   "    vec4 highlightColor = czm_invertClassificationColor;\n" +
   "    if (isClassified)\n" +
@@ -152,24 +151,24 @@ const translucentFS =
   "        discard;\n" +
   "    }\n" +
   "#endif\n" +
-  "    gl_FragColor = color * highlightColor;\n" +
-  "    gl_FragDepthEXT = texture2D(depthTexture, v_textureCoordinates).r;\n" +
+  "    out_FragColor = color * highlightColor;\n" +
+  "    gl_FragDepth = texture(depthTexture, v_textureCoordinates).r;\n" +
   "}\n";
 
 const opaqueFS =
   "uniform sampler2D colorTexture;\n" +
-  "varying vec2 v_textureCoordinates;\n" +
+  "in vec2 v_textureCoordinates;\n" +
   "void main()\n" +
   "{\n" +
-  "    vec4 color = texture2D(colorTexture, v_textureCoordinates);\n" +
+  "    vec4 color = texture(colorTexture, v_textureCoordinates);\n" +
   "    if (color.a == 0.0)\n" +
   "    {\n" +
   "        discard;\n" +
   "    }\n" +
   "#ifdef UNCLASSIFIED\n" +
-  "    gl_FragColor = color * czm_invertClassificationColor;\n" +
+  "    out_FragColor = color * czm_invertClassificationColor;\n" +
   "#else\n" +
-  "    gl_FragColor = color;\n" +
+  "    out_FragColor = color;\n" +
   "#endif\n" +
   "}\n";
 

package/Source/Scene/Material.js

@@ -1264,8 +1264,8 @@ Material._materialCache.addMaterial(Material.ImageType, {
     },
     components: {
       diffuse:
-        "texture2D(image, fract(repeat * materialInput.st)).rgb * color.rgb",
-      alpha: "texture2D(image, fract(repeat * materialInput.st)).a * color.a",
+        "texture(image, fract(repeat * materialInput.st)).rgb * color.rgb",
+      alpha: "texture(image, fract(repeat * materialInput.st)).a * color.a",
     },
   },
   translucent: function (material) {
@@ -1288,7 +1288,7 @@ Material._materialCache.addMaterial(Material.DiffuseMapType, {
       repeat: new Cartesian2(1.0, 1.0),
     },
     components: {
-      diffuse: "texture2D(image, fract(repeat * materialInput.st)).channels",
+      diffuse: "texture(image, fract(repeat * materialInput.st)).channels",
     },
   },
   translucent: false,
@@ -1309,7 +1309,7 @@ Material._materialCache.addMaterial(Material.AlphaMapType, {
       repeat: new Cartesian2(1.0, 1.0),
     },
     components: {
-      alpha: "texture2D(image, fract(repeat * materialInput.st)).channel",
+      alpha: "texture(image, fract(repeat * materialInput.st)).channel",
     },
   },
   translucent: true,
@@ -1330,7 +1330,7 @@ Material._materialCache.addMaterial(Material.SpecularMapType, {
       repeat: new Cartesian2(1.0, 1.0),
     },
     components: {
-      specular: "texture2D(image, fract(repeat * materialInput.st)).channel",
+      specular: "texture(image, fract(repeat * materialInput.st)).channel",
     },
   },
   translucent: false,
@@ -1351,7 +1351,7 @@ Material._materialCache.addMaterial(Material.EmissionMapType, {
       repeat: new Cartesian2(1.0, 1.0),
     },
     components: {
-      emission: "texture2D(image, fract(repeat * materialInput.st)).channels",
+      emission: "texture(image, fract(repeat * materialInput.st)).channels",
     },
   },
   translucent: false,

package/Source/Scene/Megatexture.js

@@ -63,9 +63,9 @@ function Megatexture(
 
   let pixelFormat;
   if (channelCount === 1) {
-    pixelFormat = PixelFormat.LUMINANCE;
+    pixelFormat = context.webgl2 ? PixelFormat.RED : PixelFormat.LUMINANCE;
   } else if (channelCount === 2) {
-    pixelFormat = PixelFormat.LUMINANCE_ALPHA;
+    pixelFormat = context.webgl2 ? PixelFormat.RG : PixelFormat.LUMINANCE_ALPHA;
   } else if (channelCount === 3) {
     pixelFormat = PixelFormat.RGB;
   } else if (channelCount === 4) {

package/Source/Scene/MetadataSemantic.js

@@ -32,6 +32,14 @@ const MetadataSemantic = {
    * @private
    */
   DESCRIPTION: "DESCRIPTION",
+  /**
+   * The number of tiles in a tileset, stored as a <code>UINT64</code>.
+   *
+   * @type {String}
+   * @constant
+   * @private
+   */
+  TILESET_TILE_COUNT: "TILESET_TILE_COUNT",
   /**
    * A bounding box for a tile, stored as an array of 12 <code>FLOAT32</code> or <code>FLOAT64</code> components. The components are the same format as for <code>boundingVolume.box</code> in 3D Tiles 1.0. This semantic is used to provide a tighter bounding volume than the one implicitly calculated in implicit tiling.
    *

package/Source/Scene/Model/CustomShader.js

@@ -113,7 +113,7 @@ import CustomShaderTranslucencyMode from "./CustomShaderTranslucencyMode.js";
  *   `,
  *   fragmentShaderText: `
  *   void fragmentMain(FragmentInput fsInput, inout czm_modelMaterial material) {
- *     material.normal = texture2D(u_normalMap, fsInput.attributes.texCoord_0);
+ *     material.normal = texture(u_normalMap, fsInput.attributes.texCoord_0);
  *     material.diffuse = v_selectedColor;
  *   }
  *   `

package/Source/Scene/Model/FeatureIdPipelineStage.js

@@ -295,13 +295,13 @@ function processImplicitRange(
   );
 
   // Declare the vertex attribute in the shader
-  // Example: attribute float a_implicit_feature_id_n;
+  // Example: in float a_implicit_feature_id_n;
   const shaderBuilder = renderResources.shaderBuilder;
   const implicitAttributeName = `a_implicit_${variableName}`;
   shaderBuilder.addAttribute("float", implicitAttributeName);
 
   // Also declare the corresponding varyings
-  // Example: varying float v_implicit_feature_id_n;
+  // Example: in float v_implicit_feature_id_n;
   const implicitVaryingName = `v_implicit_${variableName}`;
   shaderBuilder.addVarying("float", implicitVaryingName);
 
@@ -388,9 +388,9 @@ function processTexture(
   );
 
   // Read one or more channels from the texture
-  // example: texture2D(u_featureIdTexture_0, v_texCoord_1).rg
+  // example: texture(u_featureIdTexture_0, v_texCoord_1).rg
   const texCoord = `v_texCoord_${textureReader.texCoord}`;
-  const textureRead = `texture2D(${uniformName}, ${texCoord}).${channels}`;
+  const textureRead = `texture(${uniformName}, ${texCoord}).${channels}`;
 
   // Finally, assign to the struct field. Example:
   // featureIds.featureId_0 = unpacked;

package/Source/Scene/Model/LightingModel.js

@@ -9,7 +9,7 @@ const LightingModel = {
   /**
    * Use unlit shading, i.e. skip lighting calculations. The model's
    * diffuse color (assumed to be linear RGB, not sRGB) is used directly
-   * when computing <code>gl_FragColor</code>. The alpha mode is still
+   * when computing <code>out_FragColor</code>. The alpha mode is still
    * applied.
    *
    * @type {Number}

package/Source/Scene/Model/MetadataPipelineStage.js

@@ -452,7 +452,7 @@ function addPropertyTexturePropertyMetadata(renderResources, propertyInfo) {
 
   // Get a GLSL expression for the value of the property
   const texCoordVariable = `attributes.texCoord_${texCoord}`;
-  const valueExpression = `texture2D(${textureUniformName}, ${texCoordVariable}).${channels}`;
+  const valueExpression = `texture(${textureUniformName}, ${texCoordVariable}).${channels}`;
 
   // Some types need an unpacking step or two. For example, since texture reads
   // are always normalized, UINT8 (not normalized) properties need to be

package/Source/Scene/Model/PickingPipelineStage.js

@@ -157,7 +157,7 @@ function processPickTexture(renderResources, primitive, instances) {
 
   // The feature ID is ignored if it is greater than the number of features.
   renderResources.pickId =
-    "((selectedFeature.id < int(model_featuresLength)) ? texture2D(model_pickTexture, selectedFeature.st) : vec4(0.0))";
+    "((selectedFeature.id < int(model_featuresLength)) ? texture(model_pickTexture, selectedFeature.st) : vec4(0.0))";
 }
 
 function processInstancedPickIds(renderResources, context) {