@cesium/engine 1.0.0 → 2.0.0

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/KeyframeNode.js

@@ -0,0 +1,47 @@
+const LoadState = Object.freeze({
+  UNLOADED: 0, // Has no data and is in dormant state
+  RECEIVING: 1, // Is waiting on data from the provider
+  RECEIVED: 2, // Received data from the provider
+  LOADED: 3, // Processed data from provider
+  FAILED: 4, // Failed to receive data from the provider
+  UNAVAILABLE: 5, // No data available for this tile
+});
+
+/**
+ * @alias KeyframeNode
+ * @constructor
+ *
+ * @param {SpatialNode} spatialNode
+ * @param {Number} keyframe
+ *
+ * @private
+ */
+function KeyframeNode(spatialNode, keyframe) {
+  this.spatialNode = spatialNode;
+  this.keyframe = keyframe;
+  this.state = LoadState.UNLOADED;
+  this.metadatas = [];
+  this.megatextureIndex = -1;
+  this.priority = -Number.MAX_VALUE;
+  this.highPriorityFrameNumber = -1;
+}
+
+/**
+ * @param {KeyframeNode} a
+ * @param {KeyframeNode} b
+ */
+KeyframeNode.priorityComparator = function (a, b) {
+  return a.priority - b.priority;
+};
+
+/**
+ * @param {KeyframeNode} a
+ * @param {KeyframeNode} b
+ */
+KeyframeNode.searchComparator = function (a, b) {
+  return a.keyframe - b.keyframe;
+};
+
+KeyframeNode.LoadState = LoadState;
+
+export default KeyframeNode;

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

@@ -0,0 +1,490 @@
+import Cartesian2 from "../Core/Cartesian2.js";
+import Cartesian3 from "../Core/Cartesian3.js";
+import ComponentDatatype from "../Core/ComponentDatatype.js";
+import ContextLimits from "../Renderer/ContextLimits.js";
+import defaultValue from "../Core/defaultValue.js";
+import defined from "../Core/defined.js";
+import destroyObject from "../Core/destroyObject.js";
+import DeveloperError from "../Core/DeveloperError.js";
+import CesiumMath from "../Core/Math.js";
+import MetadataComponentType from "./MetadataComponentType.js";
+import PixelDatatype from "../Renderer/PixelDatatype.js";
+import PixelFormat from "../Core/PixelFormat.js";
+import RuntimeError from "../Core/RuntimeError.js";
+import Sampler from "../Renderer/Sampler.js";
+import Texture from "../Renderer/Texture.js";
+import TextureMagnificationFilter from "../Renderer/TextureMagnificationFilter.js";
+import TextureMinificationFilter from "../Renderer/TextureMinificationFilter.js";
+import TextureWrap from "../Renderer/TextureWrap.js";
+
+/**
+ * @alias Megatexture
+ * @constructor
+ *
+ * @param {Context} context
+ * @param {Cartesian3} dimensions
+ * @param {Number} channelCount
+ * @param {MetadataComponentType} componentType
+ * @param {Number} [textureMemoryByteLength]
+ *
+ * @private
+ */
+function Megatexture(
+  context,
+  dimensions,
+  channelCount,
+  componentType,
+  textureMemoryByteLength
+) {
+  // TODO there are a lot of texture packing rules, see https://github.com/CesiumGS/cesium/issues/9572
+  // Unsigned short textures not allowed in webgl 1, so treat as float
+  if (componentType === MetadataComponentType.UNSIGNED_SHORT) {
+    componentType = MetadataComponentType.FLOAT32;
+  }
+
+  const supportsFloatingPointTexture = context.floatingPointTexture;
+  if (
+    componentType === MetadataComponentType.FLOAT32 &&
+    !supportsFloatingPointTexture
+  ) {
+    throw new RuntimeError("Floating point texture not supported");
+  }
+
+  // TODO support more
+  let pixelType;
+  if (
+    componentType === MetadataComponentType.FLOAT32 ||
+    componentType === MetadataComponentType.FLOAT64
+  ) {
+    pixelType = PixelDatatype.FLOAT;
+  } else if (componentType === MetadataComponentType.UINT8) {
+    pixelType = PixelDatatype.UNSIGNED_BYTE;
+  }
+
+  let pixelFormat;
+  if (channelCount === 1) {
+    pixelFormat = context.webgl2 ? PixelFormat.RED : PixelFormat.LUMINANCE;
+  } else if (channelCount === 2) {
+    pixelFormat = context.webgl2 ? PixelFormat.RG : PixelFormat.LUMINANCE_ALPHA;
+  } else if (channelCount === 3) {
+    pixelFormat = PixelFormat.RGB;
+  } else if (channelCount === 4) {
+    pixelFormat = PixelFormat.RGBA;
+  }
+
+  const maximumTextureMemoryByteLength = 512 * 1024 * 1024;
+  const defaultTextureMemoryByteLength = 128 * 1024 * 1024;
+  textureMemoryByteLength = Math.min(
+    defaultValue(textureMemoryByteLength, defaultTextureMemoryByteLength),
+    maximumTextureMemoryByteLength
+  );
+  const maximumTextureDimensionContext = ContextLimits.maximumTextureSize;
+  const componentTypeByteLength = MetadataComponentType.getSizeInBytes(
+    componentType
+  );
+  const texelCount = Math.floor(
+    textureMemoryByteLength / (channelCount * componentTypeByteLength)
+  );
+  const textureDimension = Math.min(
+    maximumTextureDimensionContext,
+    CesiumMath.previousPowerOfTwo(Math.floor(Math.sqrt(texelCount)))
+  );
+
+  const sliceCountPerRegionX = Math.ceil(Math.sqrt(dimensions.x));
+  const sliceCountPerRegionY = Math.ceil(dimensions.z / sliceCountPerRegionX);
+  const voxelCountPerRegionX = sliceCountPerRegionX * dimensions.x;
+  const voxelCountPerRegionY = sliceCountPerRegionY * dimensions.y;
+  const regionCountPerMegatextureX = Math.floor(
+    textureDimension / voxelCountPerRegionX
+  );
+  const regionCountPerMegatextureY = Math.floor(
+    textureDimension / voxelCountPerRegionY
+  );
+
+  if (regionCountPerMegatextureX === 0 || regionCountPerMegatextureY === 0) {
+    throw new RuntimeError("Tileset is too large to fit into megatexture");
+  }
+
+  /**
+   * @type {Number}
+   * @readonly
+   */
+  this.channelCount = channelCount;
+
+  /**
+   * @type {MetadataComponentType}
+   * @readonly
+   */
+  this.componentType = componentType;
+
+  /**
+   * @type {Cartesian3}
+   * @readonly
+   */
+  this.voxelCountPerTile = Cartesian3.clone(dimensions, new Cartesian3());
+
+  /**
+   * @type {Number}
+   * @readonly
+   */
+  this.maximumTileCount =
+    regionCountPerMegatextureX * regionCountPerMegatextureY;
+
+  /**
+   * @type {Cartesian2}
+   * @readonly
+   */
+  this.regionCountPerMegatexture = new Cartesian2(
+    regionCountPerMegatextureX,
+    regionCountPerMegatextureY
+  );
+
+  /**
+   * @type {Cartesian2}
+   * @readonly
+   */
+  this.voxelCountPerRegion = new Cartesian2(
+    voxelCountPerRegionX,
+    voxelCountPerRegionY
+  );
+
+  /**
+   * @type {Cartesian2}
+   * @readonly
+   */
+  this.sliceCountPerRegion = new Cartesian2(
+    sliceCountPerRegionX,
+    sliceCountPerRegionY
+  );
+
+  /**
+   * @type {Cartesian2}
+   * @readonly
+   */
+  this.voxelSizeUv = new Cartesian2(
+    1.0 / textureDimension,
+    1.0 / textureDimension
+  );
+
+  /**
+   * @type {Cartesian2}
+   * @readonly
+   */
+  this.sliceSizeUv = new Cartesian2(
+    dimensions.x / textureDimension,
+    dimensions.y / textureDimension
+  );
+
+  /**
+   * @type {Cartesian2}
+   * @readonly
+   */
+  this.regionSizeUv = new Cartesian2(
+    voxelCountPerRegionX / textureDimension,
+    voxelCountPerRegionY / textureDimension
+  );
+
+  /**
+   * @type {Texture}
+   * @readonly
+   */
+  this.texture = new Texture({
+    context: context,
+    pixelFormat: pixelFormat,
+    pixelDatatype: pixelType,
+    flipY: false,
+    width: textureDimension,
+    height: textureDimension,
+    sampler: new Sampler({
+      wrapS: TextureWrap.CLAMP_TO_EDGE,
+      wrapT: TextureWrap.CLAMP_TO_EDGE,
+      minificationFilter: TextureMinificationFilter.LINEAR,
+      magnificationFilter: TextureMagnificationFilter.LINEAR,
+    }),
+  });
+
+  const componentDatatype = MetadataComponentType.toComponentDatatype(
+    componentType
+  );
+
+  /**
+   * @type {Array}
+   */
+  this.tileVoxelDataTemp = ComponentDatatype.createTypedArray(
+    componentDatatype,
+    voxelCountPerRegionX * voxelCountPerRegionY * channelCount
+  );
+
+  /**
+   * @type {MegatextureNode[]}
+   * @readonly
+   */
+  this.nodes = new Array(this.maximumTileCount);
+  for (let tileIndex = 0; tileIndex < this.maximumTileCount; tileIndex++) {
+    this.nodes[tileIndex] = new MegatextureNode(tileIndex);
+  }
+  for (let tileIndex = 0; tileIndex < this.maximumTileCount; tileIndex++) {
+    const node = this.nodes[tileIndex];
+    node.previousNode = tileIndex > 0 ? this.nodes[tileIndex - 1] : undefined;
+    node.nextNode =
+      tileIndex < this.maximumTileCount - 1
+        ? this.nodes[tileIndex + 1]
+        : undefined;
+  }
+
+  /**
+   * @type {MegatextureNode}
+   * @readonly
+   */
+  this.occupiedList = undefined;
+
+  /**
+   * @type {MegatextureNode}
+   * @readonly
+   */
+  this.emptyList = this.nodes[0];
+
+  /**
+   * @type {Number}
+   * @readonly
+   */
+  this.occupiedCount = 0;
+}
+
+/**
+ * @alias MegatextureNode
+ * @constructor
+ *
+ * @param {Number} index
+ *
+ * @private
+ */
+function MegatextureNode(index) {
+  /**
+   * @type {Number}
+   */
+  this.index = index;
+
+  /**
+   * @type {MegatextureNode}
+   */
+  this.nextNode = undefined;
+
+  /**
+   * @type {MegatextureNode}
+   */
+  this.previousNode = undefined;
+}
+
+/**
+ * @param {Array} data
+ * @returns {Number}
+ */
+Megatexture.prototype.add = function (data) {
+  if (this.isFull()) {
+    throw new DeveloperError("Trying to add when there are no empty spots");
+  }
+
+  // remove head of empty list
+  const node = this.emptyList;
+  this.emptyList = this.emptyList.nextNode;
+  if (defined(this.emptyList)) {
+    this.emptyList.previousNode = undefined;
+  }
+
+  // make head of occupied list
+  node.nextNode = this.occupiedList;
+  if (defined(node.nextNode)) {
+    node.nextNode.previousNode = node;
+  }
+  this.occupiedList = node;
+
+  const index = node.index;
+  this.writeDataToTexture(index, data);
+
+  this.occupiedCount++;
+  return index;
+};
+
+/**
+ * @param {Number} index
+ */
+Megatexture.prototype.remove = function (index) {
+  if (index < 0 || index >= this.maximumTileCount) {
+    throw new DeveloperError("Megatexture index out of bounds");
+  }
+
+  // remove from list
+  const node = this.nodes[index];
+  if (defined(node.previousNode)) {
+    node.previousNode.nextNode = node.nextNode;
+  }
+  if (defined(node.nextNode)) {
+    node.nextNode.previousNode = node.previousNode;
+  }
+
+  // make head of empty list
+  node.nextNode = this.emptyList;
+  if (defined(node.nextNode)) {
+    node.nextNode.previousNode = node;
+  }
+  node.previousNode = undefined;
+  this.emptyList = node;
+  this.occupiedCount--;
+};
+
+/**
+ * @returns {Boolean}
+ */
+Megatexture.prototype.isFull = function () {
+  return this.emptyList === undefined;
+};
+
+/**
+ * @param {Number} tileCount
+ * @param {Cartesian3} dimensions
+ * @param {Number} channelCount number of channels in the metadata. Must be 1 to 4.
+ * @param {MetadataComponentType} componentType
+ * @returns {Number}
+ */
+Megatexture.getApproximateTextureMemoryByteLength = function (
+  tileCount,
+  dimensions,
+  channelCount,
+  componentType
+) {
+  // TODO there's a lot of code duplicate with Megatexture constructor
+
+  // Unsigned short textures not allowed in webgl 1, so treat as float
+  if (componentType === MetadataComponentType.UNSIGNED_SHORT) {
+    componentType = MetadataComponentType.FLOAT32;
+  }
+
+  const datatypeSizeInBytes = MetadataComponentType.getSizeInBytes(
+    componentType
+  );
+  const voxelCountTotal =
+    tileCount * dimensions.x * dimensions.y * dimensions.z;
+
+  const sliceCountPerRegionX = Math.ceil(Math.sqrt(dimensions.z));
+  const sliceCountPerRegionY = Math.ceil(dimensions.z / sliceCountPerRegionX);
+  const voxelCountPerRegionX = sliceCountPerRegionX * dimensions.x;
+  const voxelCountPerRegionY = sliceCountPerRegionY * dimensions.y;
+
+  // Find the power of two that can fit all tile data, accounting for slices.
+  // There's probably a non-iterative solution for this, but this is good enough for now.
+  let textureDimension = CesiumMath.previousPowerOfTwo(
+    Math.floor(Math.sqrt(voxelCountTotal))
+  );
+  for (;;) {
+    const regionCountX = Math.floor(textureDimension / voxelCountPerRegionX);
+    const regionCountY = Math.floor(textureDimension / voxelCountPerRegionY);
+    const regionCount = regionCountX * regionCountY;
+    if (regionCount >= tileCount) {
+      break;
+    } else {
+      textureDimension *= 2;
+    }
+  }
+
+  const textureMemoryByteLength =
+    textureDimension * textureDimension * channelCount * datatypeSizeInBytes;
+  return textureMemoryByteLength;
+};
+
+/**
+ * @param {Number} index
+ * @param {Float32Array|Uint16Array|Uint8Array} data
+ */
+Megatexture.prototype.writeDataToTexture = function (index, data) {
+  // Unsigned short textures not allowed in webgl 1, so treat as float
+  const tileData =
+    data.constructor === Uint16Array ? new Float32Array(data) : data;
+
+  const voxelDimensionsPerTile = this.voxelCountPerTile;
+  const sliceDimensionsPerRegion = this.sliceCountPerRegion;
+  const voxelDimensionsPerRegion = this.voxelCountPerRegion;
+  const channelCount = this.channelCount;
+
+  const tileVoxelData = this.tileVoxelDataTemp;
+  for (let z = 0; z < voxelDimensionsPerTile.z; z++) {
+    const sliceVoxelOffsetX =
+      (z % sliceDimensionsPerRegion.x) * voxelDimensionsPerTile.x;
+    const sliceVoxelOffsetY =
+      Math.floor(z / sliceDimensionsPerRegion.x) * voxelDimensionsPerTile.y;
+    for (let y = 0; y < voxelDimensionsPerTile.y; y++) {
+      for (let x = 0; x < voxelDimensionsPerTile.x; x++) {
+        const readIndex =
+          z * voxelDimensionsPerTile.y * voxelDimensionsPerTile.x +
+          y * voxelDimensionsPerTile.x +
+          x;
+        const writeIndex =
+          (sliceVoxelOffsetY + y) * voxelDimensionsPerRegion.x +
+          (sliceVoxelOffsetX + x);
+        for (let c = 0; c < channelCount; c++) {
+          tileVoxelData[writeIndex * channelCount + c] =
+            tileData[readIndex * channelCount + c];
+        }
+      }
+    }
+  }
+
+  const regionDimensionsPerMegatexture = this.regionCountPerMegatexture;
+  const voxelWidth = voxelDimensionsPerRegion.x;
+  const voxelHeight = voxelDimensionsPerRegion.y;
+  const voxelOffsetX =
+    (index % regionDimensionsPerMegatexture.x) * voxelDimensionsPerRegion.x;
+  const voxelOffsetY =
+    Math.floor(index / regionDimensionsPerMegatexture.x) *
+    voxelDimensionsPerRegion.y;
+
+  const source = {
+    arrayBufferView: tileVoxelData,
+    width: voxelWidth,
+    height: voxelHeight,
+  };
+
+  const copyOptions = {
+    source: source,
+    xOffset: voxelOffsetX,
+    yOffset: voxelOffsetY,
+  };
+
+  this.texture.copyFrom(copyOptions);
+};
+
+/**
+ * Returns true if this object was destroyed; otherwise, false.
+ * <br /><br />
+ * If this object was destroyed, it should not be used; calling any function other than
+ * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
+ *
+ * @returns {Boolean} <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
+ *
+ * @see Megatexture#destroy
+ */
+Megatexture.prototype.isDestroyed = function () {
+  return false;
+};
+
+/**
+ * Destroys the WebGL resources held by this object.  Destroying an object allows for deterministic
+ * release of WebGL resources, instead of relying on the garbage collector to destroy this object.
+ * <br /><br />
+ * Once an object is destroyed, it should not be used; calling any function other than
+ * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
+ * assign the return value (<code>undefined</code>) to the object as done in the example.
+ *
+ * @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
+ *
+ * @see Megatexture#isDestroyed
+ *
+ * @example
+ * megatexture = megatexture && megatexture.destroy();
+ */
+Megatexture.prototype.destroy = function () {
+  this.texture = this.texture && this.texture.destroy();
+  return destroyObject(this);
+};
+
+export default Megatexture;