Use local coordinates instead of UV for voxel transforms

Author: Jeshurun Hembd

packages/engine/Source/Scene/VoxelBoxShape.js

@@ -77,8 +77,8 @@ function VoxelBoxShape() {
   this._renderBoundPlanes = new VoxelBoundCollection({ planes: boundPlanes });
 
   this._shaderUniforms = {
-    boxUvToShapeUvScale: new Cartesian3(),
-    boxUvToShapeUvTranslate: new Cartesian3(),
+    boxLocalToShapeUvScale: new Cartesian3(),
+    boxLocalToShapeUvTranslate: new Cartesian3(),
   };
 
   this._shaderDefines = {
@@ -315,17 +315,19 @@ VoxelBoxShape.prototype.update = function (
   const max = maxBounds;
 
   // Compute scale and translation to transform from UV space to bounded UV space
-  shaderUniforms.boxUvToShapeUvScale = Cartesian3.fromElements(
-    2.0 / (min.x === max.x ? 1.0 : max.x - min.x),
-    2.0 / (min.y === max.y ? 1.0 : max.y - min.y),
-    2.0 / (min.z === max.z ? 1.0 : max.z - min.z),
-    shaderUniforms.boxUvToShapeUvScale,
+  const boxLocalToShapeUvScale = Cartesian3.fromElements(
+    1.0 / (min.x === max.x ? 1.0 : max.x - min.x),
+    1.0 / (min.y === max.y ? 1.0 : max.y - min.y),
+    1.0 / (min.z === max.z ? 1.0 : max.z - min.z),
+    shaderUniforms.boxLocalToShapeUvScale,
   );
-  shaderUniforms.boxUvToShapeUvTranslate = Cartesian3.fromElements(
-    -shaderUniforms.boxUvToShapeUvScale.x * (min.x * 0.5 + 0.5),
-    -shaderUniforms.boxUvToShapeUvScale.y * (min.y * 0.5 + 0.5),
-    -shaderUniforms.boxUvToShapeUvScale.z * (min.z * 0.5 + 0.5),
-    shaderUniforms.boxUvToShapeUvTranslate,
+  shaderUniforms.boxLocalToShapeUvTranslate = Cartesian3.negate(
+    Cartesian3.multiplyComponents(
+      boxLocalToShapeUvScale,
+      min,
+      shaderUniforms.boxLocalToShapeUvTranslate,
+    ),
+    shaderUniforms.boxLocalToShapeUvTranslate,
   );
 
   this._shaderMaximumIntersectionsLength = intersectionCount;
@@ -343,26 +345,26 @@ VoxelBoxShape.prototype.updateViewTransforms = function (frameState) {
 }
 
 /**
- * Convert a UV coordinate to the shape's UV space.
+ * Convert a local coordinate to the shape's UV space.
  * @private
- * @param {Cartesian3} positionUV The UV coordinate to convert.
+ * @param {Cartesian3} positionLocal The local coordinate to convert.
  * @param {Cartesian3} result The Cartesian3 to store the result in.
  * @returns {Cartesian3} The converted UV coordinate.
  */
-VoxelBoxShape.prototype.convertUvToShapeUvSpace = function (
-  positionUV,
+VoxelBoxShape.prototype.convertLocalToShapeUvSpace = function (
+  positionLocal,
   result,
 ) {
   //>>includeStart('debug', pragmas.debug);
-  Check.typeOf.object("positionUV", positionUV);
+  Check.typeOf.object("positionLocal", positionLocal);
   Check.typeOf.object("result", result);
   //>>includeEnd('debug');
 
-  const { boxUvToShapeUvScale, boxUvToShapeUvTranslate } = this._shaderUniforms;
+  const { boxLocalToShapeUvScale, boxLocalToShapeUvTranslate } = this._shaderUniforms;
 
   return Cartesian3.add(
-    Cartesian3.multiplyComponents(positionUV, boxUvToShapeUvScale, result),
-    boxUvToShapeUvTranslate,
+    Cartesian3.multiplyComponents(positionLocal, boxLocalToShapeUvScale, result),
+    boxLocalToShapeUvTranslate,
     result,
   );
 };

packages/engine/Source/Scene/VoxelCylinderShape.js

@@ -58,9 +58,9 @@ function VoxelCylinderShape() {
     cylinderEcToRadialTangentUp: new Matrix3(),
     cylinderRenderRadiusMinMax: new Cartesian2(),
     cylinderRenderAngleMinMax: new Cartesian2(),
-    cylinderUvToShapeUvRadius: new Cartesian2(),
-    cylinderUvToShapeUvAngle: new Cartesian2(),
-    cylinderUvToShapeUvHeight: new Cartesian2(),
+    cylinderLocalToShapeUvRadius: new Cartesian2(),
+    cylinderLocalToShapeUvAngle: new Cartesian2(),
+    cylinderLocalToShapeUvHeight: new Cartesian2(),
     cylinderShapeUvAngleRangeOrigin: 0.0,
   };
 
@@ -360,29 +360,25 @@ VoxelCylinderShape.prototype.update = function (
   let radialOffset = 1.0;
   if (radiusRange !== 0.0) {
     radialScale = 1.0 / radiusRange;
-    radialOffset = -minBounds.x / radiusRange;
+    radialOffset = -minBounds.x * radialScale;
   }
-  shaderUniforms.cylinderUvToShapeUvRadius = Cartesian2.fromElements(
+  shaderUniforms.cylinderLocalToShapeUvRadius = Cartesian2.fromElements(
     radialScale,
     radialOffset,
-    shaderUniforms.cylinderUvToShapeUvRadius,
+    shaderUniforms.cylinderLocalToShapeUvRadius,
   );
 
   const heightRange = maxBounds.z - minBounds.z; // Default 2.0
   let heightScale = 0.0;
   let heightOffset = 1.0;
   if (heightRange !== 0.0) {
     heightScale = 1.0 / heightRange;
-    // TODO: drop all this UV stuff. We are now using physical bounds in meters.
-    // offset = -minHeightUv / (maxHeightUv - minHeightUv)
-    // offset = -(minHeight * 0.5 + 0.5) / ((maxHeight * 0.5 + 0.5) - (minHeight * 0.5 + 0.5))
-    // offset = -(minHeight + 1.0) / (maxHeight - minHeight)
-    heightOffset = -(minBounds.z + 1.0) / heightRange;
+    heightOffset = -minBounds.z * heightScale;
   }
-  shaderUniforms.cylinderUvToShapeUvHeight = Cartesian2.fromElements(
+  shaderUniforms.cylinderLocalToShapeUvHeight = Cartesian2.fromElements(
     heightScale,
     heightOffset,
-    shaderUniforms.cylinderUvToShapeUvHeight,
+    shaderUniforms.cylinderLocalToShapeUvHeight,
   );
 
   if (renderHasAngle) {
@@ -416,19 +412,19 @@ VoxelCylinderShape.prototype.update = function (
   shaderUniforms.cylinderShapeUvAngleRangeOrigin = uvAngleRangeOrigin;
 
   if (shapeAngleRange <= epsilonAngle) {
-    shaderUniforms.cylinderUvToShapeUvAngle = Cartesian2.fromElements(
+    shaderUniforms.cylinderLocalToShapeUvAngle = Cartesian2.fromElements(
       0.0,
       1.0,
-      shaderUniforms.cylinderUvToShapeUvAngle,
+      shaderUniforms.cylinderLocalToShapeUvAngle,
     );
   } else {
     const scale = defaultAngleRange / shapeAngleRange;
     const shiftedMinAngle = uvMinAngle - uvAngleRangeOrigin;
     const offset = -scale * (shiftedMinAngle - Math.floor(shiftedMinAngle));
-    shaderUniforms.cylinderUvToShapeUvAngle = Cartesian2.fromElements(
+    shaderUniforms.cylinderLocalToShapeUvAngle = Cartesian2.fromElements(
       scale,
       offset,
-      shaderUniforms.cylinderUvToShapeUvAngle,
+      shaderUniforms.cylinderLocalToShapeUvAngle,
     );
   }
 
@@ -512,48 +508,40 @@ function updateRtuTransform(shape, frameState) {
 /**
  * Convert a UV coordinate to the shape's UV space.
  * @private
- * @param {Cartesian3} positionUV The UV coordinate to convert.
+ * @param {Cartesian3} positionLocal The local coordinate to convert.
  * @param {Cartesian3} result The Cartesian3 to store the result in.
  * @returns {Cartesian3} The converted UV coordinate.
  */
-VoxelCylinderShape.prototype.convertUvToShapeUvSpace = function (
-  positionUV,
+VoxelCylinderShape.prototype.convertLocalToShapeUvSpace = function (
+  positionLocal,
   result,
 ) {
   //>>includeStart('debug', pragmas.debug);
-  Check.typeOf.object("positionUV", positionUV);
+  Check.typeOf.object("positionLocal", positionLocal);
   Check.typeOf.object("result", result);
   //>>includeEnd('debug');
 
-  // Convert from Cartesian UV space [0, 1] to Cartesian local space [-1, 1]
-  const positionLocal = Cartesian3.fromElements(
-    positionUV.x * 2.0 - 1.0,
-    positionUV.y * 2.0 - 1.0,
-    positionUV.z * 2.0 - 1.0,
-    result,
-  );
-
   let radius = Math.hypot(positionLocal.x, positionLocal.y);
   let angle = Math.atan2(positionLocal.y, positionLocal.x);
   let height = positionLocal.z;
 
   const {
-    cylinderUvToShapeUvRadius,
-    cylinderUvToShapeUvAngle,
+    cylinderLocalToShapeUvRadius,
+    cylinderLocalToShapeUvAngle,
     cylinderShapeUvAngleRangeOrigin,
-    cylinderUvToShapeUvHeight,
+    cylinderLocalToShapeUvHeight,
   } = this._shaderUniforms;
 
-  radius = radius * cylinderUvToShapeUvRadius.x + cylinderUvToShapeUvRadius.y;
+  radius = radius * cylinderLocalToShapeUvRadius.x + cylinderLocalToShapeUvRadius.y;
 
   // Convert angle to a "UV" in [0,1] with 0 defined at the center of the unoccupied space.
   angle = (angle + Math.PI) / (2.0 * Math.PI);
   angle -= cylinderShapeUvAngleRangeOrigin;
   angle = angle - Math.floor(angle);
   // Scale and shift so [0,1] covers the occupied space.
-  angle = angle * cylinderUvToShapeUvAngle.x + cylinderUvToShapeUvAngle.y;
+  angle = angle * cylinderLocalToShapeUvAngle.x + cylinderLocalToShapeUvAngle.y;
 
-  height = height * cylinderUvToShapeUvHeight.x + cylinderUvToShapeUvHeight.y;
+  height = height * cylinderLocalToShapeUvHeight.x + cylinderLocalToShapeUvHeight.y;
 
   return Cartesian3.fromElements(radius, angle, height, result);
 };

packages/engine/Source/Scene/VoxelEllipsoidShape.js

@@ -76,8 +76,8 @@ function VoxelEllipsoidShape() {
     ellipsoidInverseRadiiSquared: new Cartesian3(),
     ellipsoidRenderLongitudeMinMax: new Cartesian2(),
     ellipsoidShapeUvLongitudeMinMaxMid: new Cartesian3(),
-    ellipsoidUvToShapeUvLongitude: new Cartesian2(),
-    ellipsoidUvToShapeUvLatitude: new Cartesian2(),
+    ellipsoidLocalToShapeUvLongitude: new Cartesian2(),
+    ellipsoidLocalToShapeUvLatitude: new Cartesian2(),
     ellipsoidRenderLatitudeSinMinMax: new Cartesian2(),
     ellipsoidInverseHeightDifference: 0.0,
     clipMinMaxHeight: new Cartesian2(),
@@ -558,29 +558,20 @@ VoxelEllipsoidShape.prototype.update = function (
         true;
     }
 
-    // delerp(longitudeUv, minLongitudeUv, maxLongitudeUv)
-    // (longitudeUv - minLongitudeUv) / (maxLongitudeUv - minLongitudeUv)
-    // longitudeUv / (maxLongitudeUv - minLongitudeUv) - minLongitudeUv / (maxLongitudeUv - minLongitudeUv)
-    // scale = 1.0 / (maxLongitudeUv - minLongitudeUv)
-    // scale = 1.0 / (((maxLongitude - pi) / (2.0 * pi)) - ((minLongitude - pi) / (2.0 * pi)))
-    // scale = 2.0 * pi / (maxLongitude - minLongitude)
-    // offset = -minLongitudeUv / (maxLongitudeUv - minLongitudeUv)
-    // offset = -((minLongitude - pi) / (2.0 * pi)) / (((maxLongitude - pi) / (2.0 * pi)) - ((minLongitude - pi) / (2.0 * pi)))
-    // offset = -(minLongitude - pi) / (maxLongitude - minLongitude)
     if (shapeLongitudeRange <= epsilonLongitude) {
-      shaderUniforms.ellipsoidUvToShapeUvLongitude = Cartesian2.fromElements(
+      shaderUniforms.ellipsoidLocalToShapeUvLongitude = Cartesian2.fromElements(
         0.0,
         1.0,
-        shaderUniforms.ellipsoidUvToShapeUvLongitude,
+        shaderUniforms.ellipsoidLocalToShapeUvLongitude,
       );
     } else {
       const scale = defaultLongitudeRange / shapeLongitudeRange;
       const offset =
         -(shapeMinBounds.x - DefaultMinBounds.x) / shapeLongitudeRange;
-      shaderUniforms.ellipsoidUvToShapeUvLongitude = Cartesian2.fromElements(
+      shaderUniforms.ellipsoidLocalToShapeUvLongitude = Cartesian2.fromElements(
         scale,
         offset,
-        shaderUniforms.ellipsoidUvToShapeUvLongitude,
+        shaderUniforms.ellipsoidLocalToShapeUvLongitude,
       );
     }
   }
@@ -680,31 +671,21 @@ VoxelEllipsoidShape.prototype.update = function (
   if (shapeHasLatitude) {
     shaderDefines["ELLIPSOID_HAS_SHAPE_BOUNDS_LATITUDE"] = true;
 
-    // delerp(latitudeUv, minLatitudeUv, maxLatitudeUv)
-    // (latitudeUv - minLatitudeUv) / (maxLatitudeUv - minLatitudeUv)
-    // latitudeUv / (maxLatitudeUv - minLatitudeUv) - minLatitudeUv / (maxLatitudeUv - minLatitudeUv)
-    // scale = 1.0 / (maxLatitudeUv - minLatitudeUv)
-    // scale = 1.0 / (((maxLatitude - pi) / (2.0 * pi)) - ((minLatitude - pi) / (2.0 * pi)))
-    // scale = 2.0 * pi / (maxLatitude - minLatitude)
-    // offset = -minLatitudeUv / (maxLatitudeUv - minLatitudeUv)
-    // offset = -((minLatitude - -pi) / (2.0 * pi)) / (((maxLatitude - pi) / (2.0 * pi)) - ((minLatitude - pi) / (2.0 * pi)))
-    // offset = -(minLatitude - -pi) / (maxLatitude - minLatitude)
-    // offset = (-pi - minLatitude) / (maxLatitude - minLatitude)
     if (shapeLatitudeRange < epsilonLatitude) {
-      shaderUniforms.ellipsoidUvToShapeUvLatitude = Cartesian2.fromElements(
+      shaderUniforms.ellipsoidLocalToShapeUvLatitude = Cartesian2.fromElements(
         0.0,
         1.0,
-        shaderUniforms.ellipsoidUvToShapeUvLatitude,
+        shaderUniforms.ellipsoidLocalToShapeUvLatitude,
       );
     } else {
       const defaultLatitudeRange = DefaultMaxBounds.y - DefaultMinBounds.y;
       const scale = defaultLatitudeRange / shapeLatitudeRange;
       const offset =
         (DefaultMinBounds.y - shapeMinBounds.y) / shapeLatitudeRange;
-      shaderUniforms.ellipsoidUvToShapeUvLatitude = Cartesian2.fromElements(
+      shaderUniforms.ellipsoidLocalToShapeUvLatitude = Cartesian2.fromElements(
         scale,
         offset,
-        shaderUniforms.ellipsoidUvToShapeUvLatitude,
+        shaderUniforms.ellipsoidLocalToShapeUvLatitude,
       );
     }
   }
@@ -922,26 +903,19 @@ const scratchNormal2d = new Cartesian2();
 /**
  * Convert a UV coordinate to the shape's UV space.
  * @private
- * @param {Cartesian3} positionUV The UV coordinate to convert.
+ * @param {Cartesian3} positionLocal The local position to convert.
  * @param {Cartesian3} result The Cartesian3 to store the result in.
  * @returns {Cartesian3} The converted UV coordinate.
  */
-VoxelEllipsoidShape.prototype.convertUvToShapeUvSpace = function (
-  positionUV,
+VoxelEllipsoidShape.prototype.convertLocalToShapeUvSpace = function (
+  positionLocal,
   result,
 ) {
   //>>includeStart('debug', pragmas.debug);
-  Check.typeOf.object("positionUV", positionUV);
+  Check.typeOf.object("positionLocal", positionLocal);
   Check.typeOf.object("result", result);
   //>>includeEnd('debug');
 
-  // Convert from Cartesian UV space [0, 1] to Cartesian local space [-1, 1]
-  const positionLocal = Cartesian3.fromElements(
-    positionUV.x * 2.0 - 1.0,
-    positionUV.y * 2.0 - 1.0,
-    positionUV.z * 2.0 - 1.0,
-    result,
-  );
   let longitude = Math.atan2(positionLocal.y, positionLocal.x);
 
   const {