@cesium/engine 1.0.0 → 2.0.0

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} = texture(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/AdjustTranslucentFS.glsl

@@ -1,21 +1,24 @@
 #ifdef MRT
-#extension GL_EXT_draw_buffers : enable
+layout (location = 0) out vec4 out_FragData_0;
+layout (location = 1) out vec4 out_FragData_1;
+#else
+layout (location = 0) out vec4 out_FragColor;
 #endif
 
 uniform vec4 u_bgColor;
 uniform sampler2D u_depthTexture;
 
-varying vec2 v_textureCoordinates;
+in vec2 v_textureCoordinates;
 
 void main()
 {
-    if (texture2D(u_depthTexture, v_textureCoordinates).r < 1.0)
+    if (texture(u_depthTexture, v_textureCoordinates).r < 1.0)
     {
 #ifdef MRT
-        gl_FragData[0] = u_bgColor;
-        gl_FragData[1] = vec4(u_bgColor.a);
+        out_FragData_0 = u_bgColor;
+        out_FragData_1 = vec4(u_bgColor.a);
 #else
-        gl_FragColor = u_bgColor;
+        out_FragColor = u_bgColor;
 #endif
         return;
     }

package/Source/Shaders/AdjustTranslucentFS.js

@@ -1,22 +1,25 @@
 //This file is automatically rebuilt by the Cesium build process.
 export default "#ifdef MRT\n\
-#extension GL_EXT_draw_buffers : enable\n\
+layout (location = 0) out vec4 out_FragData_0;\n\
+layout (location = 1) out vec4 out_FragData_1;\n\
+#else\n\
+layout (location = 0) out vec4 out_FragColor;\n\
 #endif\n\
 \n\
 uniform vec4 u_bgColor;\n\
 uniform sampler2D u_depthTexture;\n\
 \n\
-varying vec2 v_textureCoordinates;\n\
+in vec2 v_textureCoordinates;\n\
 \n\
 void main()\n\
 {\n\
-    if (texture2D(u_depthTexture, v_textureCoordinates).r < 1.0)\n\
+    if (texture(u_depthTexture, v_textureCoordinates).r < 1.0)\n\
     {\n\
 #ifdef MRT\n\
-        gl_FragData[0] = u_bgColor;\n\
-        gl_FragData[1] = vec4(u_bgColor.a);\n\
+        out_FragData_0 = u_bgColor;\n\
+        out_FragData_1 = vec4(u_bgColor.a);\n\
 #else\n\
-        gl_FragColor = u_bgColor;\n\
+        out_FragColor = u_bgColor;\n\
 #endif\n\
         return;\n\
     }\n\

package/Source/Shaders/Appearances/AllMaterialAppearanceFS.glsl

@@ -1,8 +1,8 @@
-varying vec3 v_positionEC;
-varying vec3 v_normalEC;
-varying vec3 v_tangentEC;
-varying vec3 v_bitangentEC;
-varying vec2 v_st;
+in vec3 v_positionEC;
+in vec3 v_normalEC;
+in vec3 v_tangentEC;
+in vec3 v_bitangentEC;
+in vec2 v_st;
 
 void main()
 {
@@ -22,8 +22,8 @@ void main()
     czm_material material = czm_getMaterial(materialInput);
 
 #ifdef FLAT
-    gl_FragColor = vec4(material.diffuse + material.emission, material.alpha);
+    out_FragColor = vec4(material.diffuse + material.emission, material.alpha);
 #else
-    gl_FragColor = czm_phong(normalize(positionToEyeEC), material, czm_lightDirectionEC);
+    out_FragColor = czm_phong(normalize(positionToEyeEC), material, czm_lightDirectionEC);
 #endif
 }

package/Source/Shaders/Appearances/AllMaterialAppearanceFS.js

@@ -1,9 +1,9 @@
 //This file is automatically rebuilt by the Cesium build process.
-export default "varying vec3 v_positionEC;\n\
-varying vec3 v_normalEC;\n\
-varying vec3 v_tangentEC;\n\
-varying vec3 v_bitangentEC;\n\
-varying vec2 v_st;\n\
+export default "in vec3 v_positionEC;\n\
+in vec3 v_normalEC;\n\
+in vec3 v_tangentEC;\n\
+in vec3 v_bitangentEC;\n\
+in vec2 v_st;\n\
 \n\
 void main()\n\
 {\n\
@@ -23,9 +23,9 @@ void main()\n\
     czm_material material = czm_getMaterial(materialInput);\n\
 \n\
 #ifdef FLAT\n\
-    gl_FragColor = vec4(material.diffuse + material.emission, material.alpha);\n\
+    out_FragColor = vec4(material.diffuse + material.emission, material.alpha);\n\
 #else\n\
-    gl_FragColor = czm_phong(normalize(positionToEyeEC), material, czm_lightDirectionEC);\n\
+    out_FragColor = czm_phong(normalize(positionToEyeEC), material, czm_lightDirectionEC);\n\
 #endif\n\
 }\n\
 ";

package/Source/Shaders/Appearances/AllMaterialAppearanceVS.glsl

@@ -1,16 +1,16 @@
-attribute vec3 position3DHigh;
-attribute vec3 position3DLow;
-attribute vec3 normal;
-attribute vec3 tangent;
-attribute vec3 bitangent;
-attribute vec2 st;
-attribute float batchId;
+in vec3 position3DHigh;
+in vec3 position3DLow;
+in vec3 normal;
+in vec3 tangent;
+in vec3 bitangent;
+in vec2 st;
+in float batchId;
 
-varying vec3 v_positionEC;
-varying vec3 v_normalEC;
-varying vec3 v_tangentEC;
-varying vec3 v_bitangentEC;
-varying vec2 v_st;
+out vec3 v_positionEC;
+out vec3 v_normalEC;
+out vec3 v_tangentEC;
+out vec3 v_bitangentEC;
+out vec2 v_st;
 
 void main()
 {

package/Source/Shaders/Appearances/AllMaterialAppearanceVS.js

@@ -1,17 +1,17 @@
 //This file is automatically rebuilt by the Cesium build process.
-export default "attribute vec3 position3DHigh;\n\
-attribute vec3 position3DLow;\n\
-attribute vec3 normal;\n\
-attribute vec3 tangent;\n\
-attribute vec3 bitangent;\n\
-attribute vec2 st;\n\
-attribute float batchId;\n\
+export default "in vec3 position3DHigh;\n\
+in vec3 position3DLow;\n\
+in vec3 normal;\n\
+in vec3 tangent;\n\
+in vec3 bitangent;\n\
+in vec2 st;\n\
+in float batchId;\n\
 \n\
-varying vec3 v_positionEC;\n\
-varying vec3 v_normalEC;\n\
-varying vec3 v_tangentEC;\n\
-varying vec3 v_bitangentEC;\n\
-varying vec2 v_st;\n\
+out vec3 v_positionEC;\n\
+out vec3 v_normalEC;\n\
+out vec3 v_tangentEC;\n\
+out vec3 v_bitangentEC;\n\
+out vec2 v_st;\n\
 \n\
 void main()\n\
 {\n\

package/Source/Shaders/Appearances/BasicMaterialAppearanceFS.glsl

@@ -1,5 +1,5 @@
-varying vec3 v_positionEC;
-varying vec3 v_normalEC;
+in vec3 v_positionEC;
+in vec3 v_normalEC;
 
 void main()
 {
@@ -16,8 +16,8 @@ void main()
     czm_material material = czm_getMaterial(materialInput);
 
 #ifdef FLAT
-    gl_FragColor = vec4(material.diffuse + material.emission, material.alpha);
+    out_FragColor = vec4(material.diffuse + material.emission, material.alpha);
 #else
-    gl_FragColor = czm_phong(normalize(positionToEyeEC), material, czm_lightDirectionEC);
+    out_FragColor = czm_phong(normalize(positionToEyeEC), material, czm_lightDirectionEC);
 #endif
 }

package/Source/Shaders/Appearances/BasicMaterialAppearanceFS.js

@@ -1,6 +1,6 @@
 //This file is automatically rebuilt by the Cesium build process.
-export default "varying vec3 v_positionEC;\n\
-varying vec3 v_normalEC;\n\
+export default "in vec3 v_positionEC;\n\
+in vec3 v_normalEC;\n\
 \n\
 void main()\n\
 {\n\
@@ -17,9 +17,9 @@ void main()\n\
     czm_material material = czm_getMaterial(materialInput);\n\
 \n\
 #ifdef FLAT\n\
-    gl_FragColor = vec4(material.diffuse + material.emission, material.alpha);\n\
+    out_FragColor = vec4(material.diffuse + material.emission, material.alpha);\n\
 #else\n\
-    gl_FragColor = czm_phong(normalize(positionToEyeEC), material, czm_lightDirectionEC);\n\
+    out_FragColor = czm_phong(normalize(positionToEyeEC), material, czm_lightDirectionEC);\n\
 #endif\n\
 }\n\
 ";

package/Source/Shaders/Appearances/BasicMaterialAppearanceVS.glsl

@@ -1,10 +1,10 @@
-attribute vec3 position3DHigh;
-attribute vec3 position3DLow;
-attribute vec3 normal;
-attribute float batchId;
+in vec3 position3DHigh;
+in vec3 position3DLow;
+in vec3 normal;
+in float batchId;
 
-varying vec3 v_positionEC;
-varying vec3 v_normalEC;
+out vec3 v_positionEC;
+out vec3 v_normalEC;
 
 void main()
 {