@cesium/engine 1.0.0 → 1.1.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/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.");
 }
 

package/Source/Scene/processVoxelProperties.js

@@ -0,0 +1,455 @@
+import defined from "../Core/defined.js";
+import MetadataType from "./MetadataType.js";
+import ShaderDestination from "../Renderer/ShaderDestination.js";
+
+/**
+ * Update the shader with defines, structs, and functions to handle
+ * voxel properties and statistics
+ * @function
+ *
+ * @param {VoxelRenderResources} renderResources
+ * @param {VoxelPrimitive} primitive
+ *
+ * @private
+ */
+function processVoxelProperties(renderResources, primitive) {
+  const { shaderBuilder } = renderResources;
+
+  const {
+    names,
+    types,
+    componentTypes,
+    minimumValues,
+    maximumValues,
+  } = primitive._provider;
+
+  const attributeLength = types.length;
+  const hasStatistics = defined(minimumValues) && defined(maximumValues);
+
+  shaderBuilder.addDefine(
+    "METADATA_COUNT",
+    attributeLength,
+    ShaderDestination.FRAGMENT
+  );
+
+  if (hasStatistics) {
+    shaderBuilder.addDefine(
+      "STATISTICS",
+      undefined,
+      ShaderDestination.FRAGMENT
+    );
+  }
+
+  // PropertyStatistics structs
+  for (let i = 0; i < attributeLength; i++) {
+    const name = names[i];
+    const type = types[i];
+    const propertyStatisticsStructId = `PropertyStatistics_${name}`;
+    const propertyStatisticsStructName = `PropertyStatistics_${name}`;
+    shaderBuilder.addStruct(
+      propertyStatisticsStructId,
+      propertyStatisticsStructName,
+      ShaderDestination.FRAGMENT
+    );
+    const glslType = getGlslType(type);
+    shaderBuilder.addStructField(propertyStatisticsStructId, glslType, "min");
+    shaderBuilder.addStructField(propertyStatisticsStructId, glslType, "max");
+  }
+
+  // Statistics struct
+  const statisticsStructId = "Statistics";
+  const statisticsStructName = "Statistics";
+  const statisticsFieldName = "statistics";
+  shaderBuilder.addStruct(
+    statisticsStructId,
+    statisticsStructName,
+    ShaderDestination.FRAGMENT
+  );
+  for (let i = 0; i < attributeLength; i++) {
+    const name = names[i];
+    const propertyStructName = `PropertyStatistics_${name}`;
+    const propertyFieldName = name;
+    shaderBuilder.addStructField(
+      statisticsStructId,
+      propertyStructName,
+      propertyFieldName
+    );
+  }
+
+  // Metadata struct
+  const metadataStructId = "Metadata";
+  const metadataStructName = "Metadata";
+  const metadataFieldName = "metadata";
+  shaderBuilder.addStruct(
+    metadataStructId,
+    metadataStructName,
+    ShaderDestination.FRAGMENT
+  );
+  shaderBuilder.addStructField(
+    metadataStructId,
+    statisticsStructName,
+    statisticsFieldName
+  );
+  for (let i = 0; i < attributeLength; i++) {
+    const name = names[i];
+    const type = types[i];
+    const glslType = getGlslType(type);
+    shaderBuilder.addStructField(metadataStructId, glslType, name);
+  }
+
+  // VoxelProperty structs
+  for (let i = 0; i < attributeLength; i++) {
+    const name = names[i];
+    const type = types[i];
+    const glslType = getGlslPartialDerivativeType(type);
+    const voxelPropertyStructId = `VoxelProperty_${name}`;
+    const voxelPropertyStructName = `VoxelProperty_${name}`;
+    shaderBuilder.addStruct(
+      voxelPropertyStructId,
+      voxelPropertyStructName,
+      ShaderDestination.FRAGMENT
+    );
+    shaderBuilder.addStructField(
+      voxelPropertyStructId,
+      glslType,
+      "partialDerivativeLocal"
+    );
+    shaderBuilder.addStructField(
+      voxelPropertyStructId,
+      glslType,
+      "partialDerivativeWorld"
+    );
+    shaderBuilder.addStructField(
+      voxelPropertyStructId,
+      glslType,
+      "partialDerivativeView"
+    );
+    shaderBuilder.addStructField(
+      voxelPropertyStructId,
+      glslType,
+      "partialDerivativeValid"
+    );
+  }
+
+  // Voxel struct
+  const voxelStructId = "Voxel";
+  const voxelStructName = "Voxel";
+  const voxelFieldName = "voxel";
+  shaderBuilder.addStruct(
+    voxelStructId,
+    voxelStructName,
+    ShaderDestination.FRAGMENT
+  );
+  for (let i = 0; i < attributeLength; i++) {
+    const name = names[i];
+    const voxelPropertyStructName = `VoxelProperty_${name}`;
+    shaderBuilder.addStructField(voxelStructId, voxelPropertyStructName, name);
+  }
+  shaderBuilder.addStructField(voxelStructId, "vec3", "positionEC");
+  shaderBuilder.addStructField(voxelStructId, "vec3", "positionUv");
+  shaderBuilder.addStructField(voxelStructId, "vec3", "positionShapeUv");
+  shaderBuilder.addStructField(voxelStructId, "vec3", "positionUvLocal");
+  shaderBuilder.addStructField(voxelStructId, "vec3", "viewDirUv");
+  shaderBuilder.addStructField(voxelStructId, "vec3", "viewDirWorld");
+  shaderBuilder.addStructField(voxelStructId, "float", "travelDistance");
+
+  // FragmentInput struct
+  const fragmentInputStructId = "FragmentInput";
+  const fragmentInputStructName = "FragmentInput";
+  shaderBuilder.addStruct(
+    fragmentInputStructId,
+    fragmentInputStructName,
+    ShaderDestination.FRAGMENT
+  );
+  shaderBuilder.addStructField(
+    fragmentInputStructId,
+    metadataStructName,
+    metadataFieldName
+  );
+  shaderBuilder.addStructField(
+    fragmentInputStructId,
+    voxelStructName,
+    voxelFieldName
+  );
+
+  // Properties struct
+  const propertiesStructId = "Properties";
+  const propertiesStructName = "Properties";
+  const propertiesFieldName = "properties";
+  shaderBuilder.addStruct(
+    propertiesStructId,
+    propertiesStructName,
+    ShaderDestination.FRAGMENT
+  );
+  for (let i = 0; i < attributeLength; i++) {
+    const name = names[i];
+    const type = types[i];
+    const glslType = getGlslType(type);
+    shaderBuilder.addStructField(propertiesStructId, glslType, name);
+  }
+
+  // Fragment shader functions
+
+  // clearProperties function
+  {
+    const functionId = "clearProperties";
+    shaderBuilder.addFunction(
+      functionId,
+      `${propertiesStructName} clearProperties()`,
+      ShaderDestination.FRAGMENT
+    );
+    shaderBuilder.addFunctionLines(functionId, [
+      `${propertiesStructName} ${propertiesFieldName};`,
+    ]);
+    for (let i = 0; i < attributeLength; i++) {
+      const name = names[i];
+      const type = types[i];
+      const componentType = componentTypes[i];
+      const glslType = getGlslType(type, componentType);
+      shaderBuilder.addFunctionLines(functionId, [
+        `${propertiesFieldName}.${name} = ${glslType}(0.0);`,
+      ]);
+    }
+    shaderBuilder.addFunctionLines(functionId, [
+      `return ${propertiesFieldName};`,
+    ]);
+  }
+
+  // sumProperties function
+  {
+    const functionId = "sumProperties";
+    shaderBuilder.addFunction(
+      functionId,
+      `${propertiesStructName} sumProperties(${propertiesStructName} propertiesA, ${propertiesStructName} propertiesB)`,
+      ShaderDestination.FRAGMENT
+    );
+    shaderBuilder.addFunctionLines(functionId, [
+      `${propertiesStructName} ${propertiesFieldName};`,
+    ]);
+    for (let i = 0; i < attributeLength; i++) {
+      const name = names[i];
+      shaderBuilder.addFunctionLines(functionId, [
+        `${propertiesFieldName}.${name} = propertiesA.${name} + propertiesB.${name};`,
+      ]);
+    }
+    shaderBuilder.addFunctionLines(functionId, [
+      `return ${propertiesFieldName};`,
+    ]);
+  }
+
+  // scaleProperties function
+  {
+    const functionId = "scaleProperties";
+    shaderBuilder.addFunction(
+      functionId,
+      `${propertiesStructName} scaleProperties(${propertiesStructName} ${propertiesFieldName}, float scale)`,
+      ShaderDestination.FRAGMENT
+    );
+    shaderBuilder.addFunctionLines(functionId, [
+      `${propertiesStructName} scaledProperties = ${propertiesFieldName};`,
+    ]);
+    for (let i = 0; i < attributeLength; i++) {
+      const name = names[i];
+      shaderBuilder.addFunctionLines(functionId, [
+        `scaledProperties.${name} *= scale;`,
+      ]);
+    }
+    shaderBuilder.addFunctionLines(functionId, [`return scaledProperties;`]);
+  }
+
+  // mixProperties
+  {
+    const functionId = "mixProperties";
+    shaderBuilder.addFunction(
+      functionId,
+      `${propertiesStructName} mixProperties(${propertiesStructName} propertiesA, ${propertiesStructName} propertiesB, float mixFactor)`,
+      ShaderDestination.FRAGMENT
+    );
+    shaderBuilder.addFunctionLines(functionId, [
+      `${propertiesStructName} ${propertiesFieldName};`,
+    ]);
+    for (let i = 0; i < attributeLength; i++) {
+      const name = names[i];
+      shaderBuilder.addFunctionLines(functionId, [
+        `${propertiesFieldName}.${name} = mix(propertiesA.${name}, propertiesB.${name}, mixFactor);`,
+      ]);
+    }
+    shaderBuilder.addFunctionLines(functionId, [
+      `return ${propertiesFieldName};`,
+    ]);
+  }
+
+  // copyPropertiesToMetadata
+  {
+    const functionId = "copyPropertiesToMetadata";
+    shaderBuilder.addFunction(
+      functionId,
+      `void copyPropertiesToMetadata(in ${propertiesStructName} ${propertiesFieldName}, inout ${metadataStructName} ${metadataFieldName})`,
+      ShaderDestination.FRAGMENT
+    );
+    for (let i = 0; i < attributeLength; i++) {
+      const name = names[i];
+      shaderBuilder.addFunctionLines(functionId, [
+        `${metadataFieldName}.${name} = ${propertiesFieldName}.${name};`,
+      ]);
+    }
+  }
+
+  // setStatistics function
+  if (hasStatistics) {
+    const functionId = "setStatistics";
+    shaderBuilder.addFunction(
+      functionId,
+      `void setStatistics(inout ${statisticsStructName} ${statisticsFieldName})`,
+      ShaderDestination.FRAGMENT
+    );
+    for (let i = 0; i < attributeLength; i++) {
+      const name = names[i];
+      const type = types[i];
+      const componentCount = MetadataType.getComponentCount(type);
+      for (let j = 0; j < componentCount; j++) {
+        const glslField = getGlslField(type, j);
+        const minimumValue = minimumValues[i][j];
+        const maximumValue = maximumValues[i][j];
+        shaderBuilder.addFunctionLines(functionId, [
+          `${statisticsFieldName}.${name}.min${glslField} = ${getGlslNumberAsFloat(
+            minimumValue
+          )};`,
+          `${statisticsFieldName}.${name}.max${glslField} = ${getGlslNumberAsFloat(
+            maximumValue
+          )};`,
+        ]);
+      }
+    }
+  }
+
+  // getPropertiesFromMegatextureAtUv
+  {
+    const functionId = "getPropertiesFromMegatextureAtUv";
+    shaderBuilder.addFunction(
+      functionId,
+      `${propertiesStructName} getPropertiesFromMegatextureAtUv(vec2 texcoord)`,
+      ShaderDestination.FRAGMENT
+    );
+    shaderBuilder.addFunctionLines(functionId, [
+      `${propertiesStructName} ${propertiesFieldName};`,
+    ]);
+    for (let i = 0; i < attributeLength; i++) {
+      const name = names[i];
+      const type = types[i];
+      const componentType = componentTypes[i];
+      const glslTextureSwizzle = getGlslTextureSwizzle(type, componentType);
+      shaderBuilder.addFunctionLines(functionId, [
+        `properties.${name} = texture2D(u_megatextureTextures[${i}], texcoord)${glslTextureSwizzle};`,
+      ]);
+    }
+    shaderBuilder.addFunctionLines(functionId, [
+      `return ${propertiesFieldName};`,
+    ]);
+  }
+}
+
+/**
+ * Converts a {@link MetadataType} to a GLSL type.
+ *
+ * @function
+ *
+ * @param {MetadataType} type The {@link MetadataType}.
+ * @returns {String} The GLSL type.
+ *
+ * @private
+ */
+function getGlslType(type) {
+  if (type === MetadataType.SCALAR) {
+    return "float";
+  } else if (type === MetadataType.VEC2) {
+    return "vec2";
+  } else if (type === MetadataType.VEC3) {
+    return "vec3";
+  } else if (type === MetadataType.VEC4) {
+    return "vec4";
+  }
+}
+
+/**
+ * Gets the GLSL swizzle when reading data from a texture.
+ *
+ * @function
+ *
+ * @param {MetadataType} type The {@link MetadataType}.
+ * @returns {String} The GLSL swizzle.
+ *
+ * @private
+ */
+function getGlslTextureSwizzle(type) {
+  if (type === MetadataType.SCALAR) {
+    return ".r";
+  } else if (type === MetadataType.VEC2) {
+    return ".ra";
+  } else if (type === MetadataType.VEC3) {
+    return ".rgb";
+  } else if (type === MetadataType.VEC4) {
+    return "";
+  }
+}
+
+/**
+ * Gets the GLSL type of the partial derivative of {@link MetadataType}.
+ *
+ * @function
+ *
+ * @param {MetadataType} type The {@link MetadataType}.
+ * @returns {String} The GLSL type.
+ *
+ * @private
+ */
+function getGlslPartialDerivativeType(type) {
+  if (type === MetadataType.SCALAR) {
+    return "vec3";
+  } else if (type === MetadataType.VEC2) {
+    return "mat2";
+  } else if (type === MetadataType.VEC3) {
+    return "mat3";
+  } else if (type === MetadataType.VEC4) {
+    return "mat4";
+  }
+}
+
+/**
+ * GLSL needs to have `.0` at the end of whole number floats or else it's
+ * treated like an integer.
+ *
+ * @function
+ *
+ * @param {Number} number The number to convert.
+ * @returns {String} The number as floating point in GLSL.
+ *
+ * @private
+ */
+function getGlslNumberAsFloat(number) {
+  let numberString = number.toString();
+  if (numberString.indexOf(".") === -1) {
+    numberString = `${number}.0`;
+  }
+  return numberString;
+}
+
+/**
+ * Gets the GLSL field
+ *
+ * @function
+ *
+ * @param {MetadataType} type
+ * @param {Number} index
+ * @returns {String}
+ *
+ * @private
+ */
+function getGlslField(type, index) {
+  if (type === MetadataType.SCALAR) {
+    return "";
+  }
+  return `[${index}]`;
+}
+
+export default processVoxelProperties;

package/Source/Shaders/BillboardCollectionVS.glsl

@@ -67,7 +67,7 @@ vec4 addScreenSpaceOffset(vec4 positionEC, vec2 imageSize, float scale, vec2 dir
         float angle = rotation;
         if (validAlignedAxis)
         {
-            vec4 projectedAlignedAxis = czm_modelViewProjection * vec4(alignedAxis, 0.0);
+            vec4 projectedAlignedAxis = czm_modelView3D * vec4(alignedAxis, 0.0);
             angle += sign(-projectedAlignedAxis.x) * acos(sign(projectedAlignedAxis.y) * (projectedAlignedAxis.y * projectedAlignedAxis.y) /
                     (projectedAlignedAxis.x * projectedAlignedAxis.x + projectedAlignedAxis.y * projectedAlignedAxis.y));
         }

package/Source/Shaders/BillboardCollectionVS.js

@@ -68,7 +68,7 @@ vec4 addScreenSpaceOffset(vec4 positionEC, vec2 imageSize, float scale, vec2 dir
         float angle = rotation;\n\
         if (validAlignedAxis)\n\
         {\n\
-            vec4 projectedAlignedAxis = czm_modelViewProjection * vec4(alignedAxis, 0.0);\n\
+            vec4 projectedAlignedAxis = czm_modelView3D * vec4(alignedAxis, 0.0);\n\
             angle += sign(-projectedAlignedAxis.x) * acos(sign(projectedAlignedAxis.y) * (projectedAlignedAxis.y * projectedAlignedAxis.y) /\n\
                     (projectedAlignedAxis.x * projectedAlignedAxis.x + projectedAlignedAxis.y * projectedAlignedAxis.y));\n\
         }\n\

package/Source/Shaders/Builtin/Constants/passOverlay.glsl

@@ -6,4 +6,4 @@
  *
  * @see czm_pass
  */
-const float czm_passOverlay = 9.0;
+const float czm_passOverlay = 10.0;

package/Source/Shaders/Builtin/Constants/passOverlay.js

@@ -7,5 +7,5 @@ export default "/**\n\
  *\n\
  * @see czm_pass\n\
  */\n\
-const float czm_passOverlay = 9.0;\n\
+const float czm_passOverlay = 10.0;\n\
 ";

package/Source/Shaders/Builtin/Constants/passVoxels.glsl

@@ -0,0 +1,9 @@
+/**
+ * The automatic GLSL constant for {@link Pass#VOXELS}
+ *
+ * @name czm_passVoxels
+ * @glslConstant
+ *
+ * @see czm_pass
+ */
+const float czm_passVoxels = 9.0;

package/Source/Shaders/Builtin/Constants/passVoxels.js

@@ -0,0 +1,11 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "/**\n\
+ * The automatic GLSL constant for {@link Pass#VOXELS}\n\
+ *\n\
+ * @name czm_passVoxels\n\
+ * @glslConstant\n\
+ *\n\
+ * @see czm_pass\n\
+ */\n\
+const float czm_passVoxels = 9.0;\n\
+";