@cesium/engine 1.0.0 → 2.0.0

package/Source/Scene/buildVoxelDrawCommands.js

@@ -0,0 +1,116 @@
+import defined from "../Core/defined.js";
+import PrimitiveType from "../Core/PrimitiveType.js";
+import BlendingState from "./BlendingState.js";
+import CullFace from "./CullFace.js";
+import getClippingFunction from "./getClippingFunction.js";
+import DrawCommand from "../Renderer/DrawCommand.js";
+import Pass from "../Renderer/Pass.js";
+import RenderState from "../Renderer/RenderState.js";
+import ShaderDestination from "../Renderer/ShaderDestination.js";
+import VoxelRenderResources from "./VoxelRenderResources.js";
+import processVoxelProperties from "./processVoxelProperties.js";
+
+/**
+ * @function
+ *
+ * @param {VoxelPrimitive} primitive
+ * @param {Context} context
+ *
+ * @private
+ */
+function buildVoxelDrawCommands(primitive, context) {
+  const renderResources = new VoxelRenderResources(primitive);
+
+  processVoxelProperties(renderResources, primitive);
+
+  const {
+    shaderBuilder,
+    clippingPlanes,
+    clippingPlanesLength,
+  } = renderResources;
+
+  if (clippingPlanesLength > 0) {
+    // Extract the getClippingPlane function from the getClippingFunction string.
+    // This is a bit of a hack.
+    const functionId = "getClippingPlane";
+    const entireFunction = getClippingFunction(clippingPlanes, context);
+    const functionSignatureBegin = 0;
+    const functionSignatureEnd = entireFunction.indexOf(")") + 1;
+    const functionBodyBegin =
+      entireFunction.indexOf("{", functionSignatureEnd) + 1;
+    const functionBodyEnd = entireFunction.indexOf("}", functionBodyBegin);
+    const functionSignature = entireFunction.slice(
+      functionSignatureBegin,
+      functionSignatureEnd
+    );
+    const functionBody = entireFunction.slice(
+      functionBodyBegin,
+      functionBodyEnd
+    );
+    shaderBuilder.addFunction(
+      functionId,
+      functionSignature,
+      ShaderDestination.FRAGMENT
+    );
+    shaderBuilder.addFunctionLines(functionId, [functionBody]);
+  }
+
+  // Compile shaders
+  const shaderBuilderPick = shaderBuilder.clone();
+  shaderBuilderPick.addDefine("PICKING", undefined, ShaderDestination.FRAGMENT);
+  const shaderProgram = shaderBuilder.buildShaderProgram(context);
+  const shaderProgramPick = shaderBuilderPick.buildShaderProgram(context);
+  const renderState = RenderState.fromCache({
+    cull: {
+      enabled: true,
+      face: CullFace.BACK,
+    },
+    depthTest: {
+      enabled: false,
+    },
+    depthMask: false,
+    // internally the shader does premultiplied alpha, so it makes sense to blend that way too
+    blending: BlendingState.PRE_MULTIPLIED_ALPHA_BLEND,
+  });
+
+  // Create the draw commands
+  const viewportQuadVertexArray = context.getViewportQuadVertexArray();
+  const depthTest = primitive._depthTest;
+  const drawCommand = new DrawCommand({
+    vertexArray: viewportQuadVertexArray,
+    primitiveType: PrimitiveType.TRIANGLES,
+    renderState: renderState,
+    shaderProgram: shaderProgram,
+    uniformMap: renderResources.uniformMap,
+    pass: Pass.VOXELS,
+    executeInClosestFrustum: true,
+    owner: this,
+    cull: depthTest, // don't cull or occlude if depth testing is off
+    occlude: depthTest, // don't cull or occlude if depth testing is off
+  });
+
+  // Create the pick draw command
+  const drawCommandPick = DrawCommand.shallowClone(
+    drawCommand,
+    new DrawCommand()
+  );
+  drawCommandPick.shaderProgram = shaderProgramPick;
+  drawCommandPick.pickOnly = true;
+
+  // Delete the old shader programs
+  if (defined(primitive._drawCommand)) {
+    const command = primitive._drawCommand;
+    command.shaderProgram =
+      command.shaderProgram && command.shaderProgram.destroy();
+  }
+  if (defined(primitive._drawCommandPick)) {
+    const command = primitive._drawCommandPick;
+    command.shaderProgram =
+      command.shaderProgram && command.shaderProgram.destroy();
+  }
+
+  primitive._drawCommand = drawCommand;
+  primitive._drawCommandPick = drawCommandPick;
+}
+
+export default buildVoxelDrawCommands;

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;
 }

package/Source/Scene/getClippingFunction.js

@@ -122,7 +122,7 @@ function getClippingPlaneFloat(width, height) {
     `    int pixX = clippingPlaneNumber - (pixY * ${width});\n` +
     `    float u = (float(pixX) + 0.5) * ${pixelWidthString};\n` + // sample from center of pixel
     `    float v = (float(pixY) + 0.5) * ${pixelHeightString};\n` +
-    `    vec4 plane = texture2D(packedClippingPlanes, vec2(u, v));\n` +
+    `    vec4 plane = texture(packedClippingPlanes, vec2(u, v));\n` +
     `    return czm_transformPlane(plane, transform);\n` +
     `}\n`;
   return functionString;
@@ -151,11 +151,11 @@ function getClippingPlaneUint8(width, height) {
     `    int pixX = clippingPlaneStartIndex - (pixY * ${width});\n` +
     `    float u = (float(pixX) + 0.5) * ${pixelWidthString};\n` + // sample from center of pixel
     `    float v = (float(pixY) + 0.5) * ${pixelHeightString};\n` +
-    `    vec4 oct32 = texture2D(packedClippingPlanes, vec2(u, v)) * 255.0;\n` +
+    `    vec4 oct32 = texture(packedClippingPlanes, vec2(u, v)) * 255.0;\n` +
     `    vec2 oct = vec2(oct32.x * 256.0 + oct32.y, oct32.z * 256.0 + oct32.w);\n` +
     `    vec4 plane;\n` +
     `    plane.xyz = czm_octDecode(oct, 65535.0);\n` +
-    `    plane.w = czm_unpackFloat(texture2D(packedClippingPlanes, vec2(u + ${pixelWidthString}, v)));\n` +
+    `    plane.w = czm_unpackFloat(texture(packedClippingPlanes, vec2(u + ${pixelWidthString}, v)));\n` +
     `    return czm_transformPlane(plane, transform);\n` +
     `}\n`;
   return functionString;

package/Source/Scene/parseBatchTable.js

@@ -16,6 +16,7 @@ import MetadataSchema from "./MetadataSchema.js";
 import MetadataTable from "./MetadataTable.js";
 import ModelComponents from "./ModelComponents.js";
 import ModelUtility from "./Model/ModelUtility.js";
+import oneTimeWarning from "../Core/oneTimeWarning.js";
 
 /**
  * An object that parses the the 3D Tiles 1.0 batch table and transcodes it to
@@ -263,7 +264,7 @@ function transcodeBinaryProperties(
     properties: classProperties,
   };
 
-  const transcodedSchema = new MetadataSchema(schemaJson);
+  const transcodedSchema = MetadataSchema.fromJson(schemaJson);
 
   const featureTableJson = {
     class: className,
@@ -353,6 +354,20 @@ function transcodeBinaryPropertiesAsPropertyAttributes(
     attribute.name = customAttributeName;
     attribute.count = featureCount;
     attribute.type = property.type;
+    const componentDatatype = ComponentDatatype.fromTypedArray(
+      attributeTypedArray
+    );
+    if (
+      componentDatatype === ComponentDatatype.INT ||
+      componentDatatype === ComponentDatatype.UNSIGNED_INT ||
+      componentDatatype === ComponentDatatype.DOUBLE
+    ) {
+      parseBatchTable._oneTimeWarning(
+        "Cast pnts property to floats",
+        `Point cloud property "${customAttributeName}" will be cast to a float array because INT, UNSIGNED_INT, and DOUBLE are not valid WebGL vertex attribute types. Some precision may be lost.`
+      );
+      attributeTypedArray = new Float32Array(attributeTypedArray);
+    }
     attribute.componentDatatype = ComponentDatatype.fromTypedArray(
       attributeTypedArray
     );
@@ -372,7 +387,7 @@ function transcodeBinaryPropertiesAsPropertyAttributes(
     properties: classProperties,
   };
 
-  const transcodedSchema = new MetadataSchema(schemaJson);
+  const transcodedSchema = MetadataSchema.fromJson(schemaJson);
 
   const propertyAttributeJson = {
     properties: propertyAttributeProperties,
@@ -435,5 +450,6 @@ function transcodeComponentType(componentType) {
 
 // exposed for testing
 parseBatchTable._deprecationWarning = deprecationWarning;
+parseBatchTable._oneTimeWarning = oneTimeWarning;
 
 export default parseBatchTable;

package/Source/Scene/preprocess3DTileContent.js

@@ -76,6 +76,14 @@ function preprocess3DTileContent(arrayBuffer) {
     };
   }
 
+  if (defined(json.voxelTable)) {
+    // Most likely a voxel JSON
+    return {
+      contentType: Cesium3DTileContentType.VOXEL_JSON,
+      jsonPayload: json,
+    };
+  }
+
   throw new RuntimeError("Invalid tile content.");
 }