@cesium/engine 2.0.0 → 2.1.0

package/Source/Scene/findGroupMetadata.js

@@ -9,7 +9,7 @@ import hasExtension from "./hasExtension.js";
  * @function
  *
  * @param {Cesium3DTileset} tileset The tileset to query for group metadata
- * @param {Object} contentHeader the JSON header for a {@link Cesium3DTileContent}
+ * @param {object} contentHeader the JSON header for a {@link Cesium3DTileContent}
  * @return {GroupMetadata} the group metadata, or <code>undefined</code> if not found
  * @private
  * @experimental This feature is using part of the 3D Tiles spec that is not final and is subject to change without Cesium's standard deprecation policy.

package/Source/Scene/findTileMetadata.js

@@ -14,7 +14,7 @@ import oneTimeWarning from "../Core/oneTimeWarning.js";
  * @function
  *
  * @param {Cesium3DTileset} tileset The tileset to query for tile metadata
- * @param {Object} tileHeader the JSON header for a {@link Cesium3DTile}
+ * @param {object} tileHeader the JSON header for a {@link Cesium3DTile}
  * @return {TileMetadata} the tile metadata, or <code>undefined</code> if not found
  * @private
  * @experimental This feature is using part of the 3D Tiles spec that is not final and is subject to change without Cesium's standard deprecation policy.

package/Source/Scene/getClipAndStyleCode.js

@@ -3,10 +3,10 @@ import Check from "../Core/Check.js";
 /**
  * Gets a GLSL snippet that clips a fragment using the `clip` function from {@link getClippingFunction} and styles it.
  *
- * @param {String} samplerUniformName Name of the uniform for the clipping planes texture sampler.
- * @param {String} matrixUniformName Name of the uniform for the clipping planes matrix.
- * @param {String} styleUniformName Name of the uniform for the clipping planes style, a vec4.
- * @returns {String} A string containing GLSL that clips and styles the current fragment.
+ * @param {string} samplerUniformName Name of the uniform for the clipping planes texture sampler.
+ * @param {string} matrixUniformName Name of the uniform for the clipping planes matrix.
+ * @param {string} styleUniformName Name of the uniform for the clipping planes style, a vec4.
+ * @returns {string} A string containing GLSL that clips and styles the current fragment.
  * @private
  */
 function getClipAndStyleCode(

package/Source/Scene/getClippingFunction.js

@@ -8,7 +8,7 @@ const textureResolutionScratch = new Cartesian2();
  *
  * @param {ClippingPlaneCollection} clippingPlaneCollection ClippingPlaneCollection with a defined texture.
  * @param {Context} context The current rendering context.
- * @returns {String} A string containing GLSL functions for retrieving clipping planes.
+ * @returns {string} A string containing GLSL functions for retrieving clipping planes.
  * @private
  */
 function getClippingFunction(clippingPlaneCollection, context) {

package/Source/Scene/hasExtension.js

@@ -3,9 +3,9 @@ import defined from "../Core/defined.js";
 /**
  * Check if a specific extension is present on a JSON object. This can be used
  * for either 3D Tiles extensions or glTF extensions
- * @param {Object} json The JSON object
- * @param {String} extensionName The name of the extension, e.g. '3DTILES_implicit_tiling'
- * @returns {Boolean} True if the extension is present
+ * @param {object} json The JSON object
+ * @param {string} extensionName The name of the extension, e.g. '3DTILES_implicit_tiling'
+ * @returns {boolean} True if the extension is present
  * @private
  */
 function hasExtension(json, extensionName) {

package/Source/Scene/parseBatchTable.js

@@ -25,11 +25,11 @@ import oneTimeWarning from "../Core/oneTimeWarning.js";
  * See the {@link https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_structural_metadata|EXT_structural_metadata Extension} for glTF.
  * </p>
  *
- * @param {Object} options Object with the following properties:
- * @param {Number} options.count The number of features in the batch table.
- * @param {Object} options.batchTable The batch table JSON
+ * @param {object} options Object with the following properties:
+ * @param {number} options.count The number of features in the batch table.
+ * @param {object} options.batchTable The batch table JSON
  * @param {Uint8Array} [options.binaryBody] The batch table binary body
- * @param {Boolean} [options.parseAsPropertyAttributes=false] If true, binary properties are parsed as property attributes instead of a property table. This is used for .pnts models for GPU styling.
+ * @param {boolean} [options.parseAsPropertyAttributes=false] If true, binary properties are parsed as property attributes instead of a property table. This is used for .pnts models for GPU styling.
  * @param {ModelComponents.Attribute[]} [options.customAttributeOutput] Pass in an empty array here and this method will populate it with a list of custom attributes that will store the values of the property attributes. The attributes will be created with typed arrays, the caller is responsible for uploading them to the GPU. This option is required when options.parseAsPropertyAttributes is true.
  * @return {StructuralMetadata} A transcoded structural metadata object
  *
@@ -149,8 +149,8 @@ function parseBatchTable(options) {
  * Divide the batch table's properties into binary, JSON and hierarchy
  * extension as each is handled separately
  *
- * @param {Object} batchTable The batch table JSON
- * @returns {Object} The batch table divided into binary, JSON and hierarchy portions. Extras and extensions are also divided out for ease of processing.
+ * @param {object} batchTable The batch table JSON
+ * @returns {object} The batch table divided into binary, JSON and hierarchy portions. Extras and extensions are also divided out for ease of processing.
  *
  * @private
  */
@@ -208,11 +208,11 @@ function partitionProperties(batchTable) {
  * Transcode the binary properties of the batch table to be compatible with
  * <code>EXT_structural_metadata</code>
  *
- * @param {Number} featureCount The number of features in the batch table
- * @param {String} className The name of the metadata class to be created.
- * @param {Object.<String, Object>} binaryProperties A dictionary of property ID to property definition
+ * @param {number} featureCount The number of features in the batch table
+ * @param {string} className The name of the metadata class to be created.
+ * @param {Object<string, Object>} binaryProperties A dictionary of property ID to property definition
  * @param {Uint8Array} [binaryBody] The binary body of the batch table
- * @return {Object} Transcoded data needed for constructing a {@link StructuralMetadata} object.
+ * @return {object} Transcoded data needed for constructing a {@link StructuralMetadata} object.
  *
  * @private
  */
@@ -405,8 +405,8 @@ function transcodeBinaryPropertiesAsPropertyAttributes(
  * Given a property definition from the batch table, compute the equivalent
  * <code>EXT_structural_metadata</code> type definition
  *
- * @param {Object} property The batch table property definition
- * @return {Object} The corresponding structural metadata property definition
+ * @param {object} property The batch table property definition
+ * @return {object} The corresponding structural metadata property definition
  * @private
  */
 function transcodePropertyType(property) {
@@ -422,8 +422,8 @@ function transcodePropertyType(property) {
  * Convert the component type of a batch table property to the corresponding
  * type used with structural metadata
  *
- * @property {String} componentType the batch table's component type
- * @return {String} The corresponding structural metadata data type
+ * @property {string} componentType the batch table's component type
+ * @return {string} The corresponding structural metadata data type
  *
  * @private
  */

package/Source/Scene/parseBoundingVolumeSemantics.js

@@ -14,7 +14,7 @@ import defined from "../Core/defined.js";
  * @see {@link https://github.com/CesiumGS/3d-tiles/tree/main/specification/Metadata/Semantics|3D Metadata Semantic Reference} for the various bounding volumes and minimum/maximum heights.
  *
  * @param {TileMetadata} tileMetadata The metadata object for looking up values by semantic. In practice, this will typically be a {@link ImplicitMetadataView}
- * @return {Object} An object containing a <code>tile</code> property and a <code>content</code> property. These contain the bounding volume, and any minimum or maximum height.
+ * @return {object} An object containing a <code>tile</code> property and a <code>content</code> property. These contain the bounding volume, and any minimum or maximum height.
  *
  * @private
  * @experimental This feature is using part of the 3D Tiles spec that is not final and is subject to change without Cesium's standard deprecation policy.
@@ -47,9 +47,9 @@ function parseBoundingVolumeSemantics(tileMetadata) {
  * is the prefix. e.g. <code>TILE_BOUNDING_BOX</code> and
  * <code>CONTENT_BOUNDING_BOX</code> have the same memory layout.
  *
- * @param {String} prefix Either "TILE" or "CONTENT"
+ * @param {string} prefix Either "TILE" or "CONTENT"
  * @param {TileMetadata} tileMetadata The tileMetadata for looking up values
- * @return {Object} An object representing the JSON description of the tile metadata
+ * @return {object} An object representing the JSON description of the tile metadata
  * @private
  */
 function parseBoundingVolume(prefix, tileMetadata) {
@@ -93,9 +93,9 @@ function parseBoundingVolume(prefix, tileMetadata) {
  * quadtree bounds for implicit tiling. This works for both
  * <code>TILE_MINIMUM_HEIGHT</code> and <code>CONTENT_MINIMUM_HEIGHT</code>
  *
- * @param {String} prefix Either "TILE" or "CONTENT"
+ * @param {string} prefix Either "TILE" or "CONTENT"
  * @param {TileMetadata} tileMetadata The tileMetadata for looking up values
- * @return {Number} The minimum height
+ * @return {number} The minimum height
  * @private
  */
 function parseMinimumHeight(prefix, tileMetadata) {
@@ -108,9 +108,9 @@ function parseMinimumHeight(prefix, tileMetadata) {
  * quadtree bounds for implicit tiling. This works for both
  * <code>TILE_MAXIMUM_HEIGHT</code> and <code>CONTENT_MAXIMUM_HEIGHT</code>
  *
- * @param {String} prefix Either "TILE" or "CONTENT"
+ * @param {string} prefix Either "TILE" or "CONTENT"
  * @param {TileMetadata} tileMetadata The tileMetadata for looking up values
- * @return {Number} The maximum height
+ * @return {number} The maximum height
  * @private
  */
 function parseMaximumHeight(prefix, tileMetadata) {

package/Source/Scene/parseFeatureMetadataLegacy.js

@@ -11,11 +11,11 @@ import MetadataTable from "./MetadataTable.js";
  * Parse the <code>EXT_feature_metadata</code> glTF extension to create a
  * structural metadata object.
  *
- * @param {Object} options Object with the following properties:
- * @param {Object} options.extension The extension JSON object.
+ * @param {object} options Object with the following properties:
+ * @param {object} options.extension The extension JSON object.
  * @param {MetadataSchema} options.schema The parsed schema.
- * @param {Object.<String, Uint8Array>} [options.bufferViews] An object mapping bufferView IDs to Uint8Array objects.
- * @param {Object.<String, Texture>} [options.textures] An object mapping texture IDs to {@link Texture} objects.
+ * @param {Object<string, Uint8Array>} [options.bufferViews] An object mapping bufferView IDs to Uint8Array objects.
+ * @param {Object<string, Texture>} [options.textures] An object mapping texture IDs to {@link Texture} objects.
  * @return {StructuralMetadata} A structural metadata object
  * @private
  * @experimental This feature is using part of the 3D Tiles spec that is not final and is subject to change without Cesium's standard deprecation policy.

package/Source/Scene/parseStructuralMetadata.js

@@ -11,11 +11,11 @@ import MetadataTable from "./MetadataTable.js";
  * Parse the <code>EXT_structural_metadata</code> glTF extension to create a
  * structural metadata object.
  *
- * @param {Object} options Object with the following properties:
- * @param {Object} options.extension The extension JSON object.
+ * @param {object} options Object with the following properties:
+ * @param {object} options.extension The extension JSON object.
  * @param {MetadataSchema} options.schema The parsed schema.
- * @param {Object.<String, Uint8Array>} [options.bufferViews] An object mapping bufferView IDs to Uint8Array objects.
- * @param {Object.<String, Texture>} [options.textures] An object mapping texture IDs to {@link Texture} objects.
+ * @param {Object<string, Uint8Array>} [options.bufferViews] An object mapping bufferView IDs to Uint8Array objects.
+ * @param {Object<string, Texture>} [options.textures] An object mapping texture IDs to {@link Texture} objects.
  * @return {StructuralMetadata} A structural metadata object
  * @private
  * @experimental This feature is using part of the 3D Tiles spec that is not final and is subject to change without Cesium's standard deprecation policy.

package/Source/Scene/preprocess3DTileContent.js

@@ -9,10 +9,10 @@ import Cesium3DTileContentType from "./Cesium3DTileContentType.js";
  * {@link Cesium3DTileContentType} and the payload. The payload is either
  * binary or JSON depending on the content type.
  *
- * @typedef {Object} PreprocessedContent
+ * @typedef {object} PreprocessedContent
  * @property {Cesium3DTileContentType} contentType The type of the content
  * @property {Uint8Array} [binaryPayload] For binary files, the payload is returned as a typed array with byteOffset of 0
- * @property {Object} [jsonPayload] For JSON files, the results are returned as a JSON object.
+ * @property {object} [jsonPayload] For JSON files, the results are returned as a JSON object.
  * @private
  */
 

package/Source/Scene/processVoxelProperties.js

@@ -151,6 +151,7 @@ function processVoxelProperties(renderResources, primitive) {
   shaderBuilder.addStructField(voxelStructId, "vec3", "positionUvLocal");
   shaderBuilder.addStructField(voxelStructId, "vec3", "viewDirUv");
   shaderBuilder.addStructField(voxelStructId, "vec3", "viewDirWorld");
+  shaderBuilder.addStructField(voxelStructId, "vec3", "surfaceNormal");
   shaderBuilder.addStructField(voxelStructId, "float", "travelDistance");
 
   // FragmentInput struct
@@ -355,7 +356,7 @@ function processVoxelProperties(renderResources, primitive) {
  * @function
  *
  * @param {MetadataType} type The {@link MetadataType}.
- * @returns {String} The GLSL type.
+ * @returns {string} The GLSL type.
  *
  * @private
  */
@@ -377,7 +378,7 @@ function getGlslType(type) {
  * @function
  *
  * @param {MetadataType} type The {@link MetadataType}.
- * @returns {String} The GLSL swizzle.
+ * @returns {string} The GLSL swizzle.
  *
  * @private
  */
@@ -399,7 +400,7 @@ function getGlslTextureSwizzle(type) {
  * @function
  *
  * @param {MetadataType} type The {@link MetadataType}.
- * @returns {String} The GLSL type.
+ * @returns {string} The GLSL type.
  *
  * @private
  */
@@ -421,8 +422,8 @@ function getGlslPartialDerivativeType(type) {
  *
  * @function
  *
- * @param {Number} number The number to convert.
- * @returns {String} The number as floating point in GLSL.
+ * @param {number} number The number to convert.
+ * @returns {string} The number as floating point in GLSL.
  *
  * @private
  */
@@ -440,8 +441,8 @@ function getGlslNumberAsFloat(number) {
  * @function
  *
  * @param {MetadataType} type
- * @param {Number} index
- * @returns {String}
+ * @param {number} index
+ * @returns {string}
  *
  * @private
  */

package/Source/Shaders/Voxels/IntersectBox.glsl

@@ -1,79 +1,73 @@
 // See IntersectionUtils.glsl for the definitions of Ray and NO_HIT
+// See convertUvToBox.glsl for the definition of convertShapeUvToUvSpace
 
 /* Box defines (set in Scene/VoxelBoxShape.js)
 #define BOX_INTERSECTION_INDEX ### // always 0
-#define BOX_HAS_RENDER_BOUNDS
-#define BOX_IS_2D
 */
 
-#if defined(BOX_HAS_RENDER_BOUNDS)
-    #if defined(BOX_IS_2D)
-        // This matrix bakes in an axis conversion so that the math works for XY plane.
-        uniform mat4 u_boxUvToRenderBoundsTransform;
-    #else
-        // Similar to u_boxTransformUvToBounds but fewer instructions needed.
-        uniform vec3 u_boxUvToRenderBoundsScale;
-        uniform vec3 u_boxUvToRenderBoundsTranslate;
-    #endif
-#endif
+uniform vec3 u_renderMinBounds;
+uniform vec3 u_renderMaxBounds;
 
-vec2 intersectUnitCube(Ray ray) // Unit cube from [-1, +1]
+struct Box {
+    vec3 p0;
+    vec3 p1;
+};
+
+Box constructVoxelBox(in ivec4 octreeCoords, in vec3 tileUv)
 {
-    vec3 o = ray.pos;
-    vec3 d = ray.dir;
+    // 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;
 
-    vec3 dInv = 1.0 / d;
-    vec3 od = -o * dInv;
-    vec3 t0 = od - dInv;
-    vec3 t1 = od + dInv;
-    vec3 m0 = min(t0, t1);
-    vec3 m1 = max(t0, t1);
-    float tMin = max(max(m0.x, m0.y), m0.z);
-    float tMax = min(min(m1.x, m1.y), m1.z);
+    // 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);
 
-    if (tMin >= tMax) {
-        return vec2(NO_HIT);
-    }
+    return Box(p0, p1);
+}
 
-    return vec2(tMin, tMax);
+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);
 }
 
-vec2 intersectUnitSquare(Ray ray) // Unit square from [-1, +1]
+// 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)
 {
-    vec3 o = ray.pos;
-    vec3 d = ray.dir;
+    // 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;
 
-    float t = -o.z / d.z;
-    vec2 planePos = o.xy + d.xy * t;
-    if (any(greaterThan(abs(planePos), vec2(1.0)))) {
-        return vec2(NO_HIT);
+    // 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 entryNormal = getBoxNormal(box, ray, entryT - RAY_SHIFT);
+    vec3 exitNormal = getBoxNormal(box, ray, exitT + RAY_SHIFT);
+
+    if (entryT > exitT) {
+        entryT = NO_HIT;
+        exitT = NO_HIT;
     }
 
-    return vec2(t, t);
+    return RayShapeIntersection(vec4(entryNormal, entryT), vec4(exitNormal, exitT));
 }
 
-void intersectShape(Ray ray, inout Intersections ix)
+void intersectShape(in Ray ray, inout Intersections ix)
 {
-    #if defined(BOX_HAS_RENDER_BOUNDS)
-        #if defined(BOX_IS_2D)
-            // Transform the ray into unit square space on Z plane
-            // This matrix bakes in an axis conversion so that the math works for XY plane.
-            ray.pos = vec3(u_boxUvToRenderBoundsTransform * vec4(ray.pos, 1.0));
-            ray.dir = vec3(u_boxUvToRenderBoundsTransform * vec4(ray.dir, 0.0));
-            vec2 entryExit = intersectUnitSquare(ray);
-        #else
-            // Transform the ray into unit cube space
-            ray.pos = ray.pos * u_boxUvToRenderBoundsScale + u_boxUvToRenderBoundsTranslate;
-            ray.dir *= u_boxUvToRenderBoundsScale;
-            vec2 entryExit = intersectUnitCube(ray);
-        #endif
-    #else
-        // Position is converted from [0,1] to [-1,+1] because shape intersections assume unit space is [-1,+1].
-        // Direction is scaled as well to be in sync with position.
-        ray.pos = ray.pos * 2.0 - 1.0;
-        ray.dir = ray.dir * 2.0;
-        vec2 entryExit = intersectUnitCube(ray);
-    #endif
-
-    setIntersectionPair(ix, BOX_INTERSECTION_INDEX, entryExit);
+    RayShapeIntersection intersection = intersectBox(ray, Box(u_renderMinBounds, u_renderMaxBounds));
+    setShapeIntersection(ix, BOX_INTERSECTION_INDEX, intersection);
 }

package/Source/Shaders/Voxels/IntersectBox.js

@@ -1,81 +1,75 @@
 //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\
 \n\
 /* Box defines (set in Scene/VoxelBoxShape.js)\n\
 #define BOX_INTERSECTION_INDEX ### // always 0\n\
-#define BOX_HAS_RENDER_BOUNDS\n\
-#define BOX_IS_2D\n\
 */\n\
 \n\
-#if defined(BOX_HAS_RENDER_BOUNDS)\n\
-    #if defined(BOX_IS_2D)\n\
-        // This matrix bakes in an axis conversion so that the math works for XY plane.\n\
-        uniform mat4 u_boxUvToRenderBoundsTransform;\n\
-    #else\n\
-        // Similar to u_boxTransformUvToBounds but fewer instructions needed.\n\
-        uniform vec3 u_boxUvToRenderBoundsScale;\n\
-        uniform vec3 u_boxUvToRenderBoundsTranslate;\n\
-    #endif\n\
-#endif\n\
+uniform vec3 u_renderMinBounds;\n\
+uniform vec3 u_renderMaxBounds;\n\
 \n\
-vec2 intersectUnitCube(Ray ray) // Unit cube from [-1, +1]\n\
+struct Box {\n\
+    vec3 p0;\n\
+    vec3 p1;\n\
+};\n\
+\n\
+Box constructVoxelBox(in ivec4 octreeCoords, in vec3 tileUv)\n\
 {\n\
-    vec3 o = ray.pos;\n\
-    vec3 d = ray.dir;\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\
-    vec3 dInv = 1.0 / d;\n\
-    vec3 od = -o * dInv;\n\
-    vec3 t0 = od - dInv;\n\
-    vec3 t1 = od + dInv;\n\
-    vec3 m0 = min(t0, t1);\n\
-    vec3 m1 = max(t0, t1);\n\
-    float tMin = max(max(m0.x, m0.y), m0.z);\n\
-    float tMax = min(min(m1.x, m1.y), m1.z);\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\
-    if (tMin >= tMax) {\n\
-        return vec2(NO_HIT);\n\
-    }\n\
+    return Box(p0, p1);\n\
+}\n\
 \n\
-    return vec2(tMin, tMax);\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\
-vec2 intersectUnitSquare(Ray ray) // Unit square from [-1, +1]\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\
 {\n\
-    vec3 o = ray.pos;\n\
-    vec3 d = ray.dir;\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\
 \n\
-    float t = -o.z / d.z;\n\
-    vec2 planePos = o.xy + d.xy * t;\n\
-    if (any(greaterThan(abs(planePos), vec2(1.0)))) {\n\
-        return vec2(NO_HIT);\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\
+\n\
+    vec3 entryNormal = getBoxNormal(box, ray, entryT - RAY_SHIFT);\n\
+    vec3 exitNormal = getBoxNormal(box, ray, exitT + RAY_SHIFT);\n\
+\n\
+    if (entryT > exitT) {\n\
+        entryT = NO_HIT;\n\
+        exitT = NO_HIT;\n\
     }\n\
 \n\
-    return vec2(t, t);\n\
+    return RayShapeIntersection(vec4(entryNormal, entryT), vec4(exitNormal, exitT));\n\
 }\n\
 \n\
-void intersectShape(Ray ray, inout Intersections ix)\n\
+void intersectShape(in Ray ray, inout Intersections ix)\n\
 {\n\
-    #if defined(BOX_HAS_RENDER_BOUNDS)\n\
-        #if defined(BOX_IS_2D)\n\
-            // Transform the ray into unit square space on Z plane\n\
-            // This matrix bakes in an axis conversion so that the math works for XY plane.\n\
-            ray.pos = vec3(u_boxUvToRenderBoundsTransform * vec4(ray.pos, 1.0));\n\
-            ray.dir = vec3(u_boxUvToRenderBoundsTransform * vec4(ray.dir, 0.0));\n\
-            vec2 entryExit = intersectUnitSquare(ray);\n\
-        #else\n\
-            // Transform the ray into unit cube space\n\
-            ray.pos = ray.pos * u_boxUvToRenderBoundsScale + u_boxUvToRenderBoundsTranslate;\n\
-            ray.dir *= u_boxUvToRenderBoundsScale;\n\
-            vec2 entryExit = intersectUnitCube(ray);\n\
-        #endif\n\
-    #else\n\
-        // Position is converted from [0,1] to [-1,+1] because shape intersections assume unit space is [-1,+1].\n\
-        // Direction is scaled as well to be in sync with position.\n\
-        ray.pos = ray.pos * 2.0 - 1.0;\n\
-        ray.dir = ray.dir * 2.0;\n\
-        vec2 entryExit = intersectUnitCube(ray);\n\
-    #endif\n\
-\n\
-    setIntersectionPair(ix, BOX_INTERSECTION_INDEX, entryExit);\n\
+    RayShapeIntersection intersection = intersectBox(ray, Box(u_renderMinBounds, u_renderMaxBounds));\n\
+    setShapeIntersection(ix, BOX_INTERSECTION_INDEX, intersection);\n\
 }\n\
 ";

package/Source/Shaders/Voxels/IntersectClippingPlanes.glsl

@@ -11,60 +11,68 @@ uniform sampler2D u_clippingPlanesTexture;
 uniform mat4 u_clippingPlanesMatrix;
 
 // Plane is in Hessian Normal Form
-vec2 intersectPlane(Ray ray, vec4 plane) {
-    vec3 o = ray.pos;
-    vec3 d = ray.dir;
+vec4 intersectPlane(in Ray ray, in vec4 plane) {
     vec3 n = plane.xyz; // normal
     float w = plane.w; // -dot(pointOnPlane, normal)
 
-    float a = dot(o, n);
-    float b = dot(d, n);
+    float a = dot(ray.pos, n);
+    float b = dot(ray.dir, n);
     float t = -(w + a) / b;
 
-    if (dot(d, n) > 0.0) {
-        return vec2(t, +INF_HIT);
-    } else {
-        return vec2(-INF_HIT, t);
-    }
+    return vec4(n, t);
 }
 
-void intersectClippingPlanes(Ray ray, inout Intersections ix) {
+void intersectClippingPlanes(in Ray ray, inout Intersections ix) {
+    vec4 backSide = vec4(-ray.dir, -INF_HIT);
+    vec4 farSide = vec4(ray.dir, +INF_HIT);
+    RayShapeIntersection clippingVolume;
+
     #if (CLIPPING_PLANES_COUNT == 1)
         // Union and intersection are the same when there's one clipping plane, and the code
         // is more simplified.
         vec4 planeUv = getClippingPlane(u_clippingPlanesTexture, 0, u_clippingPlanesMatrix);
-        vec2 intersection = intersectPlane(ray, planeUv);
-        setIntersectionPair(ix, CLIPPING_PLANES_INTERSECTION_INDEX, intersection);
+        vec4 intersection = intersectPlane(ray, planeUv);
+        bool reflects = dot(ray.dir, intersection.xyz) < 0.0;
+        clippingVolume.entry = reflects ? backSide : intersection;
+        clippingVolume.exit = reflects ? intersection : farSide;
+        setShapeIntersection(ix, CLIPPING_PLANES_INTERSECTION_INDEX, clippingVolume);
     #elif defined(CLIPPING_PLANES_UNION)
-        float minPositiveT = +INF_HIT;
-        float maxNegativeT = -INF_HIT;
+        vec4 firstTransmission = vec4(ray.dir, +INF_HIT);
+        vec4 lastReflection = vec4(-ray.dir, -INF_HIT);
         for (int i = 0; i < CLIPPING_PLANES_COUNT; i++) {
             vec4 planeUv = getClippingPlane(u_clippingPlanesTexture, i, u_clippingPlanesMatrix);
-            vec2 intersection = intersectPlane(ray, planeUv);
-            if (intersection.y == +INF_HIT) {
-                minPositiveT = min(minPositiveT, intersection.x);
+            vec4 intersection = intersectPlane(ray, planeUv);
+            if (dot(ray.dir, planeUv.xyz) > 0.0) {
+                firstTransmission = intersection.w <= firstTransmission.w ? intersection : firstTransmission;
             } else {
-                maxNegativeT = max(maxNegativeT, intersection.y);
+                lastReflection = intersection.w >= lastReflection.w ? intersection : lastReflection;
             }
         }
-        setIntersectionPair(ix, CLIPPING_PLANES_INTERSECTION_INDEX + 0, vec2(-INF_HIT, maxNegativeT));
-        setIntersectionPair(ix, CLIPPING_PLANES_INTERSECTION_INDEX + 1, vec2(minPositiveT, +INF_HIT));
+        clippingVolume.entry = backSide;
+        clippingVolume.exit = lastReflection;
+        setShapeIntersection(ix, CLIPPING_PLANES_INTERSECTION_INDEX + 0, clippingVolume);
+        clippingVolume.entry = firstTransmission;
+        clippingVolume.exit = farSide;
+        setShapeIntersection(ix, CLIPPING_PLANES_INTERSECTION_INDEX + 1, clippingVolume);
     #else // intersection
-        float maxPositiveT = -INF_HIT;
-        float minNegativeT = +INF_HIT;
+        vec4 lastTransmission = vec4(ray.dir, -INF_HIT);
+        vec4 firstReflection = vec4(-ray.dir, +INF_HIT);
         for (int i = 0; i < CLIPPING_PLANES_COUNT; i++) {
             vec4 planeUv = getClippingPlane(u_clippingPlanesTexture, i, u_clippingPlanesMatrix);
-            vec2 intersection = intersectPlane(ray, planeUv);
-            if (intersection.y == +INF_HIT) {
-                maxPositiveT = max(maxPositiveT, intersection.x);
+            vec4 intersection = intersectPlane(ray, planeUv);
+            if (dot(ray.dir, planeUv.xyz) > 0.0) {
+                lastTransmission = intersection.w > lastTransmission.w ? intersection : lastTransmission;
             } else {
-                minNegativeT = min(minNegativeT, intersection.y);
+                firstReflection = intersection.w < firstReflection.w ? intersection: firstReflection;
             }
         }
-        if (maxPositiveT < minNegativeT) {
-            setIntersectionPair(ix, CLIPPING_PLANES_INTERSECTION_INDEX, vec2(maxPositiveT, minNegativeT));
+        if (lastTransmission.w < firstReflection.w) {
+            clippingVolume.entry = lastTransmission;
+            clippingVolume.exit = firstReflection;
         } else {
-            setIntersectionPair(ix, CLIPPING_PLANES_INTERSECTION_INDEX, vec2(NO_HIT));
+            clippingVolume.entry = vec4(-ray.dir, NO_HIT);
+            clippingVolume.exit = vec4(ray.dir, NO_HIT);
         }
+        setShapeIntersection(ix, CLIPPING_PLANES_INTERSECTION_INDEX, clippingVolume);
     #endif
 }