@cesium/engine 8.0.0 → 9.0.0

package/Source/Scene/VoxelPrimitive.js

@@ -22,6 +22,9 @@ import PolylineCollection from "./PolylineCollection.js";
 import VoxelShapeType from "./VoxelShapeType.js";
 import VoxelTraversal from "./VoxelTraversal.js";
 import CustomShader from "./Model/CustomShader.js";
+import Cartographic from "../Core/Cartographic.js";
+import Ellipsoid from "../Core/Ellipsoid.js";
+import VerticalExaggeration from "../Core/VerticalExaggeration.js";
 
 /**
  * A primitive that renders voxel data from a {@link VoxelProvider}.
@@ -231,6 +234,14 @@ function VoxelPrimitive(options) {
     defaultValue(options.modelMatrix, Matrix4.IDENTITY)
   );
 
+  /**
+   * Model matrix with vertical exaggeration applied. Only used for BOX shape type.
+   *
+   * @type {Matrix4}
+   * @private
+   */
+  this._exaggeratedModelMatrix = Matrix4.clone(this._modelMatrix);
+
   /**
    * The primitive's model matrix multiplied by the provider's model matrix.
    * This member is not known until the provider is ready.
@@ -320,18 +331,12 @@ function VoxelPrimitive(options) {
    */
   this._transformNormalLocalToWorld = new Matrix3();
 
-  /**
-   * @type {number}
-   * @private
-   */
-  this._stepSizeUv = 1.0;
-
   // Rendering
   /**
    * @type {boolean}
    * @private
    */
-  this._jitter = true;
+  this._jitter = false;
 
   /**
    * @type {boolean}
@@ -469,12 +474,25 @@ function initialize(primitive, provider) {
   primitive.minClippingBounds = VoxelShapeType.getMinBounds(shapeType);
   primitive.maxClippingBounds = VoxelShapeType.getMaxBounds(shapeType);
 
+  // Initialize the exaggerated versions of bounds and model matrix
+  primitive._exaggeratedMinBounds = Cartesian3.clone(
+    primitive._minBounds,
+    primitive._exaggeratedMinBounds
+  );
+  primitive._exaggeratedMaxBounds = Cartesian3.clone(
+    primitive._maxBounds,
+    primitive._exaggeratedMaxBounds
+  );
+  primitive._exaggeratedModelMatrix = Matrix4.clone(
+    primitive._modelMatrix,
+    primitive._exaggeratedModelMatrix
+  );
+
   checkTransformAndBounds(primitive, provider);
 
   // Create the shape object, and update it so it is valid for VoxelTraversal
   const ShapeConstructor = VoxelShapeType.getShapeConstructor(shapeType);
   primitive._shape = new ShapeConstructor();
-  updateVerticalExaggeration(primitive);
   primitive._shapeVisible = updateShapeAndTransforms(
     primitive,
     primitive._shape,
@@ -1132,7 +1150,7 @@ VoxelPrimitive.prototype.update = function (frameState) {
     cameraPositionWorld,
     uniforms.cameraPositionUv
   );
-  uniforms.stepSize = this._stepSizeUv * this._stepSizeMultiplier;
+  uniforms.stepSize = this._stepSizeMultiplier;
 
   // Render the primitive
   const command = frameState.passes.pick
@@ -1144,11 +1162,16 @@ VoxelPrimitive.prototype.update = function (frameState) {
   frameState.commandList.push(command);
 };
 
+const scratchExaggerationScale = new Cartesian3();
+const scratchExaggerationCenter = new Cartesian3();
+const scratchCartographicCenter = new Cartographic();
+const scratchExaggerationTranslation = new Cartesian3();
+
 /**
  * Update the exaggerated bounds of a primitive to account for vertical exaggeration
  * Currently only applies to Ellipsoid shape type
  * @param {VoxelPrimitive} primitive
- * @param {FrameState} [frameState]
+ * @param {FrameState} frameState
  * @private
  */
 function updateVerticalExaggeration(primitive, frameState) {
@@ -1160,16 +1183,87 @@ function updateVerticalExaggeration(primitive, frameState) {
     primitive._maxBounds,
     primitive._exaggeratedMaxBounds
   );
-  if (defined(frameState) && primitive.shape === VoxelShapeType.ELLIPSOID) {
+
+  if (primitive.shape === VoxelShapeType.ELLIPSOID) {
+    // Apply the exaggeration by stretching the height bounds
     const relativeHeight = frameState.verticalExaggerationRelativeHeight;
     const exaggeration = frameState.verticalExaggeration;
     primitive._exaggeratedMinBounds.z =
       (primitive._minBounds.z - relativeHeight) * exaggeration + relativeHeight;
     primitive._exaggeratedMaxBounds.z =
       (primitive._maxBounds.z - relativeHeight) * exaggeration + relativeHeight;
+  } else if (primitive.shape === VoxelShapeType.BOX) {
+    // Apply the exaggeration via the model matrix
+    const exaggerationScale = Cartesian3.fromElements(
+      1.0,
+      1.0,
+      frameState.verticalExaggeration,
+      scratchExaggerationScale
+    );
+    primitive._exaggeratedModelMatrix = Matrix4.multiplyByScale(
+      primitive._modelMatrix,
+      exaggerationScale,
+      primitive._exaggeratedModelMatrix
+    );
+    primitive._exaggeratedModelMatrix = Matrix4.multiplyByTranslation(
+      primitive._exaggeratedModelMatrix,
+      computeBoxExaggerationTranslation(primitive, frameState),
+      primitive._exaggeratedModelMatrix
+    );
   }
 }
 
+function computeBoxExaggerationTranslation(primitive, frameState) {
+  // Compute translation based on box center, relative height, and exaggeration
+  const {
+    shapeTransform = Matrix4.IDENTITY,
+    globalTransform = Matrix4.IDENTITY,
+  } = primitive._provider;
+
+  // Find the Cartesian position of the center of the OBB
+  const initialCenter = Matrix4.getTranslation(
+    shapeTransform,
+    scratchExaggerationCenter
+  );
+  const intermediateCenter = Matrix4.multiplyByPoint(
+    primitive._modelMatrix,
+    initialCenter,
+    scratchExaggerationCenter
+  );
+  const transformedCenter = Matrix4.multiplyByPoint(
+    globalTransform,
+    intermediateCenter,
+    scratchExaggerationCenter
+  );
+
+  // Find the cartographic height
+  const ellipsoid = Ellipsoid.WGS84;
+  const centerCartographic = ellipsoid.cartesianToCartographic(
+    transformedCenter,
+    scratchCartographicCenter
+  );
+
+  let centerHeight = 0.0;
+  if (defined(centerCartographic)) {
+    centerHeight = centerCartographic.height;
+  }
+
+  // Find the shift that will put the center in the right position relative
+  // to relativeHeight, after it is scaled by verticalExaggeration
+  const exaggeratedHeight = VerticalExaggeration.getHeight(
+    centerHeight,
+    frameState.verticalExaggeration,
+    frameState.verticalExaggerationRelativeHeight
+  );
+
+  return Cartesian3.fromElements(
+    0.0,
+    0.0,
+    (exaggeratedHeight - centerHeight) / frameState.verticalExaggeration,
+    scratchExaggerationTranslation
+  );
+}
+
 /**
  * Initialize primitive properties that are derived from the voxel provider
  * @param {VoxelPrimitive} primitive
@@ -1254,7 +1348,7 @@ function checkTransformAndBounds(primitive, provider) {
   // Compound model matrix = global transform * model matrix * shape transform
   Matrix4.multiplyTransformation(
     globalTransform,
-    primitive._modelMatrix,
+    primitive._exaggeratedModelMatrix,
     primitive._compoundModelMatrix
   );
   Matrix4.multiplyTransformation(
@@ -1345,8 +1439,6 @@ function updateShapeAndTransforms(primitive, shape, provider) {
   );
 
   // Set member variables when the shape is dirty
-  const dimensions = provider.dimensions;
-  primitive._stepSizeUv = shape.computeApproximateStepSize(dimensions);
   primitive._transformPositionWorldToUv = Matrix4.multiplyTransformation(
     transformPositionLocalToUv,
     transformPositionWorldToLocal,

package/Source/Scene/VoxelRenderResources.js

@@ -3,6 +3,7 @@ import combine from "../Core/combine.js";
 import defined from "../Core/defined.js";
 import ShaderBuilder from "../Renderer/ShaderBuilder.js";
 import ShaderDestination from "../Renderer/ShaderDestination.js";
+import VoxelUtils from "../Shaders/Voxels/VoxelUtils.js";
 import VoxelFS from "../Shaders/Voxels/VoxelFS.js";
 import VoxelVS from "../Shaders/Voxels/VoxelVS.js";
 import IntersectionUtils from "../Shaders/Voxels/IntersectionUtils.js";
@@ -89,6 +90,7 @@ function VoxelRenderResources(primitive) {
     customShader.fragmentShaderText,
     "#line 0",
     Octree,
+    VoxelUtils,
     IntersectionUtils,
     Megatexture,
   ]);
@@ -124,7 +126,6 @@ function VoxelRenderResources(primitive) {
 
   const shapeType = primitive._provider.shape;
   if (shapeType === "BOX") {
-    shaderBuilder.addDefine("SHAPE_BOX", undefined, ShaderDestination.FRAGMENT);
     shaderBuilder.addFragmentLines([
       convertUvToBox,
       IntersectBox,
@@ -132,17 +133,22 @@ function VoxelRenderResources(primitive) {
     ]);
   } else if (shapeType === "CYLINDER") {
     shaderBuilder.addFragmentLines([
+      convertUvToCylinder,
       IntersectLongitude,
       IntersectCylinder,
       Intersection,
-      convertUvToCylinder,
     ]);
   } else if (shapeType === "ELLIPSOID") {
+    shaderBuilder.addDefine(
+      "SHAPE_ELLIPSOID",
+      undefined,
+      ShaderDestination.FRAGMENT
+    );
     shaderBuilder.addFragmentLines([
+      convertUvToEllipsoid,
       IntersectLongitude,
       IntersectEllipsoid,
       Intersection,
-      convertUvToEllipsoid,
     ]);
   }
 

package/Source/Scene/VoxelShape.js

@@ -130,16 +130,6 @@ VoxelShape.prototype.computeOrientedBoundingBoxForTile =
 VoxelShape.prototype.computeOrientedBoundingBoxForSample =
   DeveloperError.throwInstantiationError;
 
-/**
- * Computes an approximate step size for raymarching the root tile of a voxel grid.
- * The update function must be called before calling this function.
- *
- * @param {Cartesian3} voxelDimensions The voxel grid dimensions for a tile.
- * @returns {number} The step size.
- */
-VoxelShape.prototype.computeApproximateStepSize =
-  DeveloperError.throwInstantiationError;
-
 /**
  * Defines the minimum bounds of the shape. The meaning can vary per-shape.
  *

package/Source/Scene/processVoxelProperties.js

@@ -153,6 +153,7 @@ function processVoxelProperties(renderResources, primitive) {
   shaderBuilder.addStructField(voxelStructId, "vec3", "viewDirWorld");
   shaderBuilder.addStructField(voxelStructId, "vec3", "surfaceNormal");
   shaderBuilder.addStructField(voxelStructId, "float", "travelDistance");
+  shaderBuilder.addStructField(voxelStructId, "int", "stepCount");
   shaderBuilder.addStructField(voxelStructId, "int", "tileIndex");
   shaderBuilder.addStructField(voxelStructId, "int", "sampleIndex");
 

package/Source/Shaders/Voxels/IntersectBox.glsl

@@ -1,5 +1,5 @@
-// See IntersectionUtils.glsl for the definitions of Ray and NO_HIT
-// See convertUvToBox.glsl for the definition of convertShapeUvToUvSpace
+// See IntersectionUtils.glsl for the definitions of Ray, RayShapeIntersection,
+// NO_HIT, Intersections
 
 /* Box defines (set in Scene/VoxelBoxShape.js)
 #define BOX_INTERSECTION_INDEX ### // always 0
@@ -8,66 +8,40 @@
 uniform vec3 u_renderMinBounds;
 uniform vec3 u_renderMaxBounds;
 
-struct Box {
-    vec3 p0;
-    vec3 p1;
-};
-
-Box constructVoxelBox(in ivec4 octreeCoords, in vec3 tileUv)
-{
-    // Find the min/max cornerpoints of the voxel in tile coordinates
-    vec3 tileOrigin = vec3(octreeCoords.xyz);
-    vec3 numSamples = vec3(u_dimensions);
-    vec3 voxelSize = 1.0 / numSamples;
-    vec3 coordP0 = floor(tileUv * numSamples) * voxelSize + tileOrigin;
-    vec3 coordP1 = coordP0 + voxelSize;
-
-    // Transform to the UV coordinates of the scaled tileset
-    float tileSize = 1.0 / pow(2.0, float(octreeCoords.w));
-    vec3 p0 = convertShapeUvToUvSpace(coordP0 * tileSize);
-    vec3 p1 = convertShapeUvToUvSpace(coordP1 * tileSize);
-
-    return Box(p0, p1);
-}
-
-vec3 getBoxNormal(in Box box, in Ray ray, in float t)
-{
-    vec3 hitPoint = ray.pos + t * ray.dir;
-    vec3 lower = step(hitPoint, box.p0);
-    vec3 upper = step(box.p1, hitPoint);
-    return normalize(upper - lower);
-}
-
-// Find the distances along a ray at which the ray intersects an axis-aligned box
-// See https://tavianator.com/2011/ray_box.html
-RayShapeIntersection intersectBox(in Ray ray, in Box box)
+RayShapeIntersection intersectBox(in Ray ray, in vec3 minBound, in vec3 maxBound)
 {
     // Consider the box as the intersection of the space between 3 pairs of parallel planes
     // Compute the distance along the ray to each plane
-    vec3 t0 = (box.p0 - ray.pos) * ray.dInv;
-    vec3 t1 = (box.p1 - ray.pos) * ray.dInv;
+    vec3 t0 = (minBound - ray.pos) / ray.dir;
+    vec3 t1 = (maxBound - ray.pos) / ray.dir;
 
     // Identify candidate entries/exits based on distance from ray.pos
     vec3 entries = min(t0, t1);
     vec3 exits = max(t0, t1);
 
-    // The actual box intersection points are the furthest entry and the closest exit
-    float entryT = max(max(entries.x, entries.y), entries.z);
-    float exitT = min(min(exits.x, exits.y), exits.z);
+    vec3 directions = sign(ray.dir);
+
+    // The actual intersection points are the furthest entry and the closest exit
+    float lastEntry = maxComponent(entries);
+    bvec3 isLastEntry = equal(entries, vec3(lastEntry));
+    vec3 entryNormal = -1.0 * vec3(isLastEntry) * directions;
+    vec4 entry = vec4(entryNormal, lastEntry);
 
-    vec3 entryNormal = getBoxNormal(box, ray, entryT - RAY_SHIFT);
-    vec3 exitNormal = getBoxNormal(box, ray, exitT + RAY_SHIFT);
+    float firstExit = minComponent(exits);
+    bvec3 isFirstExit = equal(exits, vec3(firstExit));
+    vec3 exitNormal = vec3(isLastEntry) * directions;
+    vec4 exit = vec4(exitNormal, firstExit);
 
-    if (entryT > exitT) {
-        entryT = NO_HIT;
-        exitT = NO_HIT;
+    if (entry.w > exit.w) {
+        entry.w = NO_HIT;
+        exit.w = NO_HIT;
     }
 
-    return RayShapeIntersection(vec4(entryNormal, entryT), vec4(exitNormal, exitT));
+    return RayShapeIntersection(entry, exit);
 }
 
 void intersectShape(in Ray ray, inout Intersections ix)
 {
-    RayShapeIntersection intersection = intersectBox(ray, Box(u_renderMinBounds, u_renderMaxBounds));
+    RayShapeIntersection intersection = intersectBox(ray, u_renderMinBounds, u_renderMaxBounds);
     setShapeIntersection(ix, BOX_INTERSECTION_INDEX, intersection);
 }

package/Source/Shaders/Voxels/IntersectBox.js

@@ -1,6 +1,6 @@
 //This file is automatically rebuilt by the Cesium build process.
-export default "// See IntersectionUtils.glsl for the definitions of Ray and NO_HIT\n\
-// See convertUvToBox.glsl for the definition of convertShapeUvToUvSpace\n\
+export default "// See IntersectionUtils.glsl for the definitions of Ray, RayShapeIntersection,\n\
+// NO_HIT, Intersections\n\
 \n\
 /* Box defines (set in Scene/VoxelBoxShape.js)\n\
 #define BOX_INTERSECTION_INDEX ### // always 0\n\
@@ -9,67 +9,41 @@ export default "// See IntersectionUtils.glsl for the definitions of Ray and NO_
 uniform vec3 u_renderMinBounds;\n\
 uniform vec3 u_renderMaxBounds;\n\
 \n\
-struct Box {\n\
-    vec3 p0;\n\
-    vec3 p1;\n\
-};\n\
-\n\
-Box constructVoxelBox(in ivec4 octreeCoords, in vec3 tileUv)\n\
-{\n\
-    // Find the min/max cornerpoints of the voxel in tile coordinates\n\
-    vec3 tileOrigin = vec3(octreeCoords.xyz);\n\
-    vec3 numSamples = vec3(u_dimensions);\n\
-    vec3 voxelSize = 1.0 / numSamples;\n\
-    vec3 coordP0 = floor(tileUv * numSamples) * voxelSize + tileOrigin;\n\
-    vec3 coordP1 = coordP0 + voxelSize;\n\
-\n\
-    // Transform to the UV coordinates of the scaled tileset\n\
-    float tileSize = 1.0 / pow(2.0, float(octreeCoords.w));\n\
-    vec3 p0 = convertShapeUvToUvSpace(coordP0 * tileSize);\n\
-    vec3 p1 = convertShapeUvToUvSpace(coordP1 * tileSize);\n\
-\n\
-    return Box(p0, p1);\n\
-}\n\
-\n\
-vec3 getBoxNormal(in Box box, in Ray ray, in float t)\n\
-{\n\
-    vec3 hitPoint = ray.pos + t * ray.dir;\n\
-    vec3 lower = step(hitPoint, box.p0);\n\
-    vec3 upper = step(box.p1, hitPoint);\n\
-    return normalize(upper - lower);\n\
-}\n\
-\n\
-// Find the distances along a ray at which the ray intersects an axis-aligned box\n\
-// See https://tavianator.com/2011/ray_box.html\n\
-RayShapeIntersection intersectBox(in Ray ray, in Box box)\n\
+RayShapeIntersection intersectBox(in Ray ray, in vec3 minBound, in vec3 maxBound)\n\
 {\n\
     // Consider the box as the intersection of the space between 3 pairs of parallel planes\n\
     // Compute the distance along the ray to each plane\n\
-    vec3 t0 = (box.p0 - ray.pos) * ray.dInv;\n\
-    vec3 t1 = (box.p1 - ray.pos) * ray.dInv;\n\
+    vec3 t0 = (minBound - ray.pos) / ray.dir;\n\
+    vec3 t1 = (maxBound - ray.pos) / ray.dir;\n\
 \n\
     // Identify candidate entries/exits based on distance from ray.pos\n\
     vec3 entries = min(t0, t1);\n\
     vec3 exits = max(t0, t1);\n\
 \n\
-    // The actual box intersection points are the furthest entry and the closest exit\n\
-    float entryT = max(max(entries.x, entries.y), entries.z);\n\
-    float exitT = min(min(exits.x, exits.y), exits.z);\n\
+    vec3 directions = sign(ray.dir);\n\
+\n\
+    // The actual intersection points are the furthest entry and the closest exit\n\
+    float lastEntry = maxComponent(entries);\n\
+    bvec3 isLastEntry = equal(entries, vec3(lastEntry));\n\
+    vec3 entryNormal = -1.0 * vec3(isLastEntry) * directions;\n\
+    vec4 entry = vec4(entryNormal, lastEntry);\n\
 \n\
-    vec3 entryNormal = getBoxNormal(box, ray, entryT - RAY_SHIFT);\n\
-    vec3 exitNormal = getBoxNormal(box, ray, exitT + RAY_SHIFT);\n\
+    float firstExit = minComponent(exits);\n\
+    bvec3 isFirstExit = equal(exits, vec3(firstExit));\n\
+    vec3 exitNormal = vec3(isLastEntry) * directions;\n\
+    vec4 exit = vec4(exitNormal, firstExit);\n\
 \n\
-    if (entryT > exitT) {\n\
-        entryT = NO_HIT;\n\
-        exitT = NO_HIT;\n\
+    if (entry.w > exit.w) {\n\
+        entry.w = NO_HIT;\n\
+        exit.w = NO_HIT;\n\
     }\n\
 \n\
-    return RayShapeIntersection(vec4(entryNormal, entryT), vec4(exitNormal, exitT));\n\
+    return RayShapeIntersection(entry, exit);\n\
 }\n\
 \n\
 void intersectShape(in Ray ray, inout Intersections ix)\n\
 {\n\
-    RayShapeIntersection intersection = intersectBox(ray, Box(u_renderMinBounds, u_renderMaxBounds));\n\
+    RayShapeIntersection intersection = intersectBox(ray, u_renderMinBounds, u_renderMaxBounds);\n\
     setShapeIntersection(ix, BOX_INTERSECTION_INDEX, intersection);\n\
 }\n\
 ";

package/Source/Shaders/Voxels/IntersectClippingPlanes.glsl

@@ -1,5 +1,5 @@
 // See IntersectionUtils.glsl for the definitions of Ray, Intersections, INF_HIT,
-// NO_HIT, setIntersectionPair
+// NO_HIT, setShapeIntersection
 
 /* Clipping plane defines (set in Scene/VoxelRenderResources.js)
 #define CLIPPING_PLANES_UNION

package/Source/Shaders/Voxels/IntersectClippingPlanes.js

@@ -1,6 +1,6 @@
 //This file is automatically rebuilt by the Cesium build process.
 export default "// See IntersectionUtils.glsl for the definitions of Ray, Intersections, INF_HIT,\n\
-// NO_HIT, setIntersectionPair\n\
+// NO_HIT, setShapeIntersection\n\
 \n\
 /* Clipping plane defines (set in Scene/VoxelRenderResources.js)\n\
 #define CLIPPING_PLANES_UNION\n\