@cesium/engine 7.0.0 → 9.0.0

package/Source/Shaders/Voxels/IntersectLongitude.glsl

@@ -0,0 +1,102 @@
+// See IntersectionUtils.glsl for the definitions of Ray, NO_HIT, INF_HIT,
+// RayShapeIntersection
+
+vec4 intersectLongitude(in Ray ray, in float angle, in bool positiveNormal) {
+    float normalSign = positiveNormal ? 1.0 : -1.0;
+    vec2 planeNormal = vec2(-sin(angle), cos(angle)) * normalSign;
+
+    vec2 position = ray.pos.xy;
+    vec2 direction = ray.dir.xy;
+    float approachRate = dot(direction, planeNormal);
+    float distance = -dot(position, planeNormal);
+
+    float t = (approachRate == 0.0)
+        ? NO_HIT
+        : distance / approachRate;
+
+    return vec4(planeNormal, 0.0, t);
+}
+
+RayShapeIntersection intersectHalfSpace(in Ray ray, in float angle, in bool positiveNormal)
+{
+    vec4 intersection = intersectLongitude(ray, angle, positiveNormal);
+    vec4 farSide = vec4(normalize(ray.dir), INF_HIT);
+
+    bool hitFront = (intersection.w > 0.0) == (dot(ray.pos.xy, intersection.xy) > 0.0);
+    if (!hitFront) {
+        return RayShapeIntersection(intersection, farSide);
+    } else {
+        return RayShapeIntersection(-1.0 * farSide, intersection);
+    }
+}
+
+void intersectFlippedWedge(in Ray ray, in vec2 minMaxAngle, out RayShapeIntersection intersections[2])
+{
+    intersections[0] = intersectHalfSpace(ray, minMaxAngle.x, false);
+    intersections[1] = intersectHalfSpace(ray, minMaxAngle.y, true);
+}
+
+bool hitPositiveHalfPlane(in Ray ray, in vec4 intersection, in bool positiveNormal) {
+    float normalSign = positiveNormal ? 1.0 : -1.0;
+    vec2 planeDirection = vec2(intersection.y, -intersection.x) * normalSign;
+    vec2 hit = ray.pos.xy + intersection.w * ray.dir.xy;
+    return dot(hit, planeDirection) > 0.0;
+}
+
+void intersectHalfPlane(in Ray ray, in float angle, out RayShapeIntersection intersections[2]) {
+    vec4 intersection = intersectLongitude(ray, angle, true);
+    vec4 farSide = vec4(normalize(ray.dir), INF_HIT);
+
+    if (hitPositiveHalfPlane(ray, intersection, true)) {
+        intersections[0].entry = -1.0 * farSide;
+        intersections[0].exit = vec4(-1.0 * intersection.xy, 0.0, intersection.w);
+        intersections[1].entry = intersection;
+        intersections[1].exit = farSide;
+    } else {
+        vec4 miss = vec4(normalize(ray.dir), NO_HIT);
+        intersections[0].entry = -1.0 * farSide;
+        intersections[0].exit = farSide;
+        intersections[1].entry = miss;
+        intersections[1].exit = miss;
+    }
+}
+
+RayShapeIntersection intersectRegularWedge(in Ray ray, in vec2 minMaxAngle)
+{
+    // Note: works for maxAngle > minAngle + pi, where the "regular wedge"
+    // is actually a negative volume.
+    // Compute intersections with the two planes.
+    // Normals will point toward the "outside" (negative space)
+    vec4 intersect1 = intersectLongitude(ray, minMaxAngle.x, false);
+    vec4 intersect2 = intersectLongitude(ray, minMaxAngle.y, true);
+
+    // Choose intersection with smallest T as the "first", the other as "last"
+    // Note: first or last could be in the "shadow" wedge, beyond the tip
+    bool inOrder = intersect1.w <= intersect2.w;
+    vec4 first = inOrder ? intersect1 : intersect2;
+    vec4 last = inOrder ? intersect2 : intersect1;
+
+    bool firstIsAhead = first.w >= 0.0;
+    bool startedInsideFirst = dot(ray.pos.xy, first.xy) < 0.0;
+    bool exitFromInside = firstIsAhead == startedInsideFirst;
+    bool lastIsAhead = last.w > 0.0;
+    bool startedOutsideLast = dot(ray.pos.xy, last.xy) >= 0.0;
+    bool enterFromOutside = lastIsAhead == startedOutsideLast;
+
+    vec4 farSide = vec4(normalize(ray.dir), INF_HIT);
+    vec4 miss = vec4(normalize(ray.dir), NO_HIT);
+
+    if (exitFromInside && enterFromOutside) {
+        // Ray crosses both faces of negative wedge, exiting then entering the positive shape
+        return RayShapeIntersection(first, last);
+    } else if (!exitFromInside && enterFromOutside) {
+        // Ray starts inside wedge. last is in shadow wedge, and first is actually the entry
+        return RayShapeIntersection(-1.0 * farSide, first);
+    } else if (exitFromInside && !enterFromOutside) {
+        // First intersection was in the shadow wedge, so last is actually the exit
+        return RayShapeIntersection(last, farSide);
+    } else { // !exitFromInside && !enterFromOutside
+        // Both intersections were in the shadow wedge
+        return RayShapeIntersection(miss, miss);
+    }
+}

package/Source/Shaders/Voxels/IntersectLongitude.js

@@ -0,0 +1,104 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "// See IntersectionUtils.glsl for the definitions of Ray, NO_HIT, INF_HIT,\n\
+// RayShapeIntersection\n\
+\n\
+vec4 intersectLongitude(in Ray ray, in float angle, in bool positiveNormal) {\n\
+    float normalSign = positiveNormal ? 1.0 : -1.0;\n\
+    vec2 planeNormal = vec2(-sin(angle), cos(angle)) * normalSign;\n\
+\n\
+    vec2 position = ray.pos.xy;\n\
+    vec2 direction = ray.dir.xy;\n\
+    float approachRate = dot(direction, planeNormal);\n\
+    float distance = -dot(position, planeNormal);\n\
+\n\
+    float t = (approachRate == 0.0)\n\
+        ? NO_HIT\n\
+        : distance / approachRate;\n\
+\n\
+    return vec4(planeNormal, 0.0, t);\n\
+}\n\
+\n\
+RayShapeIntersection intersectHalfSpace(in Ray ray, in float angle, in bool positiveNormal)\n\
+{\n\
+    vec4 intersection = intersectLongitude(ray, angle, positiveNormal);\n\
+    vec4 farSide = vec4(normalize(ray.dir), INF_HIT);\n\
+\n\
+    bool hitFront = (intersection.w > 0.0) == (dot(ray.pos.xy, intersection.xy) > 0.0);\n\
+    if (!hitFront) {\n\
+        return RayShapeIntersection(intersection, farSide);\n\
+    } else {\n\
+        return RayShapeIntersection(-1.0 * farSide, intersection);\n\
+    }\n\
+}\n\
+\n\
+void intersectFlippedWedge(in Ray ray, in vec2 minMaxAngle, out RayShapeIntersection intersections[2])\n\
+{\n\
+    intersections[0] = intersectHalfSpace(ray, minMaxAngle.x, false);\n\
+    intersections[1] = intersectHalfSpace(ray, minMaxAngle.y, true);\n\
+}\n\
+\n\
+bool hitPositiveHalfPlane(in Ray ray, in vec4 intersection, in bool positiveNormal) {\n\
+    float normalSign = positiveNormal ? 1.0 : -1.0;\n\
+    vec2 planeDirection = vec2(intersection.y, -intersection.x) * normalSign;\n\
+    vec2 hit = ray.pos.xy + intersection.w * ray.dir.xy;\n\
+    return dot(hit, planeDirection) > 0.0;\n\
+}\n\
+\n\
+void intersectHalfPlane(in Ray ray, in float angle, out RayShapeIntersection intersections[2]) {\n\
+    vec4 intersection = intersectLongitude(ray, angle, true);\n\
+    vec4 farSide = vec4(normalize(ray.dir), INF_HIT);\n\
+\n\
+    if (hitPositiveHalfPlane(ray, intersection, true)) {\n\
+        intersections[0].entry = -1.0 * farSide;\n\
+        intersections[0].exit = vec4(-1.0 * intersection.xy, 0.0, intersection.w);\n\
+        intersections[1].entry = intersection;\n\
+        intersections[1].exit = farSide;\n\
+    } else {\n\
+        vec4 miss = vec4(normalize(ray.dir), NO_HIT);\n\
+        intersections[0].entry = -1.0 * farSide;\n\
+        intersections[0].exit = farSide;\n\
+        intersections[1].entry = miss;\n\
+        intersections[1].exit = miss;\n\
+    }\n\
+}\n\
+\n\
+RayShapeIntersection intersectRegularWedge(in Ray ray, in vec2 minMaxAngle)\n\
+{\n\
+    // Note: works for maxAngle > minAngle + pi, where the \"regular wedge\"\n\
+    // is actually a negative volume.\n\
+    // Compute intersections with the two planes.\n\
+    // Normals will point toward the \"outside\" (negative space)\n\
+    vec4 intersect1 = intersectLongitude(ray, minMaxAngle.x, false);\n\
+    vec4 intersect2 = intersectLongitude(ray, minMaxAngle.y, true);\n\
+\n\
+    // Choose intersection with smallest T as the \"first\", the other as \"last\"\n\
+    // Note: first or last could be in the \"shadow\" wedge, beyond the tip\n\
+    bool inOrder = intersect1.w <= intersect2.w;\n\
+    vec4 first = inOrder ? intersect1 : intersect2;\n\
+    vec4 last = inOrder ? intersect2 : intersect1;\n\
+\n\
+    bool firstIsAhead = first.w >= 0.0;\n\
+    bool startedInsideFirst = dot(ray.pos.xy, first.xy) < 0.0;\n\
+    bool exitFromInside = firstIsAhead == startedInsideFirst;\n\
+    bool lastIsAhead = last.w > 0.0;\n\
+    bool startedOutsideLast = dot(ray.pos.xy, last.xy) >= 0.0;\n\
+    bool enterFromOutside = lastIsAhead == startedOutsideLast;\n\
+\n\
+    vec4 farSide = vec4(normalize(ray.dir), INF_HIT);\n\
+    vec4 miss = vec4(normalize(ray.dir), NO_HIT);\n\
+\n\
+    if (exitFromInside && enterFromOutside) {\n\
+        // Ray crosses both faces of negative wedge, exiting then entering the positive shape\n\
+        return RayShapeIntersection(first, last);\n\
+    } else if (!exitFromInside && enterFromOutside) {\n\
+        // Ray starts inside wedge. last is in shadow wedge, and first is actually the entry\n\
+        return RayShapeIntersection(-1.0 * farSide, first);\n\
+    } else if (exitFromInside && !enterFromOutside) {\n\
+        // First intersection was in the shadow wedge, so last is actually the exit\n\
+        return RayShapeIntersection(last, farSide);\n\
+    } else { // !exitFromInside && !enterFromOutside\n\
+        // Both intersections were in the shadow wedge\n\
+        return RayShapeIntersection(miss, miss);\n\
+    }\n\
+}\n\
+";

package/Source/Shaders/Voxels/IntersectionUtils.glsl

@@ -4,22 +4,44 @@
 
 #define NO_HIT (-czm_infinity)
 #define INF_HIT (czm_infinity * 0.5)
-#define RAY_SHIFT (0.000003163)
-#define RAY_SCALE (1.003163)
-
-struct Ray {
-    vec3 pos;
-    vec3 dir;
-#if defined(SHAPE_BOX)
-    vec3 dInv;
-#endif
-};
 
 struct RayShapeIntersection {
     vec4 entry;
     vec4 exit;
 };
 
+vec4 intersectionMin(in vec4 intersect0, in vec4 intersect1)
+{
+    if (intersect0.w == NO_HIT) {
+        return intersect1;
+    } else if (intersect1.w == NO_HIT) {
+        return intersect0;
+    }
+    return (intersect0.w <= intersect1.w) ? intersect0 : intersect1;
+}
+
+vec4 intersectionMax(in vec4 intersect0, in vec4 intersect1)
+{
+    return (intersect0.w >= intersect1.w) ? intersect0 : intersect1;
+}
+
+RayShapeIntersection intersectIntersections(in Ray ray, in RayShapeIntersection intersect0, in RayShapeIntersection intersect1)
+{
+    bool missed = (intersect0.entry.w == NO_HIT) ||
+        (intersect1.entry.w == NO_HIT) ||
+        (intersect0.exit.w < intersect1.entry.w) ||
+        (intersect0.entry.w > intersect1.exit.w);
+    if (missed) {
+        vec4 miss = vec4(normalize(ray.dir), NO_HIT);
+        return RayShapeIntersection(miss, miss);
+    }
+
+    vec4 entry = intersectionMax(intersect0.entry, intersect1.entry);
+    vec4 exit = intersectionMin(intersect0.exit, intersect1.exit);
+
+    return RayShapeIntersection(entry, exit);
+}
+
 struct Intersections {
     // Don't access these member variables directly - call the functions instead.
 
@@ -57,7 +79,7 @@ vec4 encodeIntersectionType(vec4 intersection, int index, bool entry)
 // Use defines instead of real functions because WebGL1 cannot access array with non-constant index.
 #define setIntersection(/*inout Intersections*/ ix, /*int*/ index, /*float*/ t, /*bool*/ positive, /*bool*/ enter) (ix).intersections[(index)] = vec4(0.0, float(!positive) * 2.0 + float(!enter) + 1.0, 0.0, (t))
 #define setIntersectionPair(/*inout Intersections*/ ix, /*int*/ index, /*vec2*/ entryExit) (ix).intersections[(index) * 2 + 0] = vec4(0.0, float((index) > 0) * 2.0 + 1.0, 0.0, (entryExit).x); (ix).intersections[(index) * 2 + 1] = vec4(0.0, float((index) > 0) * 2.0 + 2.0, 0.0, (entryExit).y)
-#define setSurfaceIntersection(/*inout Intersections*/ ix, /*int*/ index, /*vec4*/ intersection) (ix).intersections[(index)] = intersection;
+#define setSurfaceIntersection(/*inout Intersections*/ ix, /*int*/ index, /*vec4*/ intersection, /*bool*/ positive, /*bool*/ enter) (ix).intersections[(index)] = encodeIntersectionType((intersection), int(!positive), (enter))
 #define setShapeIntersection(/*inout Intersections*/ ix, /*int*/ index, /*RayShapeIntersection*/ intersection) (ix).intersections[(index) * 2 + 0] = encodeIntersectionType((intersection).entry, (index), true); (ix).intersections[(index) * 2 + 1] = encodeIntersectionType((intersection).exit, (index), false)
 
 #if (INTERSECTION_COUNT > 1)

package/Source/Shaders/Voxels/IntersectionUtils.js

@@ -5,22 +5,44 @@ export default "/* Intersection defines\n\
 \n\
 #define NO_HIT (-czm_infinity)\n\
 #define INF_HIT (czm_infinity * 0.5)\n\
-#define RAY_SHIFT (0.000003163)\n\
-#define RAY_SCALE (1.003163)\n\
-\n\
-struct Ray {\n\
-    vec3 pos;\n\
-    vec3 dir;\n\
-#if defined(SHAPE_BOX)\n\
-    vec3 dInv;\n\
-#endif\n\
-};\n\
 \n\
 struct RayShapeIntersection {\n\
     vec4 entry;\n\
     vec4 exit;\n\
 };\n\
 \n\
+vec4 intersectionMin(in vec4 intersect0, in vec4 intersect1)\n\
+{\n\
+    if (intersect0.w == NO_HIT) {\n\
+        return intersect1;\n\
+    } else if (intersect1.w == NO_HIT) {\n\
+        return intersect0;\n\
+    }\n\
+    return (intersect0.w <= intersect1.w) ? intersect0 : intersect1;\n\
+}\n\
+\n\
+vec4 intersectionMax(in vec4 intersect0, in vec4 intersect1)\n\
+{\n\
+    return (intersect0.w >= intersect1.w) ? intersect0 : intersect1;\n\
+}\n\
+\n\
+RayShapeIntersection intersectIntersections(in Ray ray, in RayShapeIntersection intersect0, in RayShapeIntersection intersect1)\n\
+{\n\
+    bool missed = (intersect0.entry.w == NO_HIT) ||\n\
+        (intersect1.entry.w == NO_HIT) ||\n\
+        (intersect0.exit.w < intersect1.entry.w) ||\n\
+        (intersect0.entry.w > intersect1.exit.w);\n\
+    if (missed) {\n\
+        vec4 miss = vec4(normalize(ray.dir), NO_HIT);\n\
+        return RayShapeIntersection(miss, miss);\n\
+    }\n\
+\n\
+    vec4 entry = intersectionMax(intersect0.entry, intersect1.entry);\n\
+    vec4 exit = intersectionMin(intersect0.exit, intersect1.exit);\n\
+\n\
+    return RayShapeIntersection(entry, exit);\n\
+}\n\
+\n\
 struct Intersections {\n\
     // Don't access these member variables directly - call the functions instead.\n\
 \n\
@@ -58,7 +80,7 @@ vec4 encodeIntersectionType(vec4 intersection, int index, bool entry)\n\
 // Use defines instead of real functions because WebGL1 cannot access array with non-constant index.\n\
 #define setIntersection(/*inout Intersections*/ ix, /*int*/ index, /*float*/ t, /*bool*/ positive, /*bool*/ enter) (ix).intersections[(index)] = vec4(0.0, float(!positive) * 2.0 + float(!enter) + 1.0, 0.0, (t))\n\
 #define setIntersectionPair(/*inout Intersections*/ ix, /*int*/ index, /*vec2*/ entryExit) (ix).intersections[(index) * 2 + 0] = vec4(0.0, float((index) > 0) * 2.0 + 1.0, 0.0, (entryExit).x); (ix).intersections[(index) * 2 + 1] = vec4(0.0, float((index) > 0) * 2.0 + 2.0, 0.0, (entryExit).y)\n\
-#define setSurfaceIntersection(/*inout Intersections*/ ix, /*int*/ index, /*vec4*/ intersection) (ix).intersections[(index)] = intersection;\n\
+#define setSurfaceIntersection(/*inout Intersections*/ ix, /*int*/ index, /*vec4*/ intersection, /*bool*/ positive, /*bool*/ enter) (ix).intersections[(index)] = encodeIntersectionType((intersection), int(!positive), (enter))\n\
 #define setShapeIntersection(/*inout Intersections*/ ix, /*int*/ index, /*RayShapeIntersection*/ intersection) (ix).intersections[(index) * 2 + 0] = encodeIntersectionType((intersection).entry, (index), true); (ix).intersections[(index) * 2 + 1] = encodeIntersectionType((intersection).exit, (index), false)\n\
 \n\
 #if (INTERSECTION_COUNT > 1)\n\

package/Source/Shaders/Voxels/Megatexture.glsl

@@ -71,9 +71,8 @@ vec2 index1DTo2DTexcoord(int index, ivec2 dimensions, vec2 uvScale)
 */
 
 Properties getPropertiesFromMegatexture(in SampleData sampleData) {
-    vec3 tileUv = clamp(sampleData.tileUv, vec3(0.0), vec3(1.0)); // TODO is the clamp necessary?
     int tileIndex = sampleData.megatextureIndex;
-    vec3 voxelCoord = tileUv * vec3(u_dimensions);
+    vec3 voxelCoord = sampleData.tileUv * vec3(u_dimensions);
     ivec3 voxelDimensions = u_dimensions;
 
     #if defined(PADDING)

package/Source/Shaders/Voxels/Megatexture.js

@@ -72,9 +72,8 @@ vec2 index1DTo2DTexcoord(int index, ivec2 dimensions, vec2 uvScale)\n\
 */\n\
 \n\
 Properties getPropertiesFromMegatexture(in SampleData sampleData) {\n\
-    vec3 tileUv = clamp(sampleData.tileUv, vec3(0.0), vec3(1.0)); // TODO is the clamp necessary?\n\
     int tileIndex = sampleData.megatextureIndex;\n\
-    vec3 voxelCoord = tileUv * vec3(u_dimensions);\n\
+    vec3 voxelCoord = sampleData.tileUv * vec3(u_dimensions);\n\
     ivec3 voxelDimensions = u_dimensions;\n\
 \n\
     #if defined(PADDING)\n\

package/Source/Shaders/Voxels/Octree.glsl

@@ -79,10 +79,15 @@ int getOctreeParentIndex(in int octreeIndex) {
 */
 vec3 getTileUv(in vec3 shapePosition, in ivec4 octreeCoords) {
 	// PERFORMANCE_IDEA: use bit-shifting (only in WebGL2)
-    float dimAtLevel = pow(2.0, float(octreeCoords.w));
+    float dimAtLevel = exp2(float(octreeCoords.w));
     return shapePosition * dimAtLevel - vec3(octreeCoords.xyz);
 }
 
+vec3 getClampedTileUv(in vec3 shapePosition, in ivec4 octreeCoords) {
+    vec3 tileUv = getTileUv(shapePosition, octreeCoords);
+    return clamp(tileUv, vec3(0.0), vec3(1.0));
+}
+
 void getOctreeLeafSampleData(in OctreeNodeData data, in ivec4 octreeCoords, out SampleData sampleData) {
     sampleData.megatextureIndex = data.data;
     sampleData.tileCoords = (data.flag == OCTREE_FLAG_PACKED_LEAF_FROM_PARENT)
@@ -121,7 +126,7 @@ void getOctreeLeafSampleDatas(in OctreeNodeData data, in ivec4 octreeCoords, out
 #endif
 
 OctreeNodeData traverseOctreeDownwards(in vec3 shapePosition, inout TraversalData traversalData) {
-    float sizeAtLevel = 1.0 / pow(2.0, float(traversalData.octreeCoords.w));
+    float sizeAtLevel = exp2(-1.0 * float(traversalData.octreeCoords.w));
     vec3 start = vec3(traversalData.octreeCoords.xyz) * sizeAtLevel;
     vec3 end = start + vec3(sizeAtLevel);
     OctreeNodeData childData;
@@ -167,11 +172,11 @@ void traverseOctreeFromBeginning(in vec3 shapePosition, out TraversalData traver
 
     #if (SAMPLE_COUNT == 1)
         getOctreeLeafSampleData(nodeData, traversalData.octreeCoords, sampleDatas[0]);
-        sampleDatas[0].tileUv = getTileUv(shapePosition, sampleDatas[0].tileCoords);
+        sampleDatas[0].tileUv = getClampedTileUv(shapePosition, sampleDatas[0].tileCoords);
     #else
         getOctreeLeafSampleDatas(nodeData, traversalData.octreeCoords, sampleDatas);
-        sampleDatas[0].tileUv = getTileUv(shapePosition, sampleDatas[0].tileCoords);
-        sampleDatas[1].tileUv = getTileUv(shapePosition, sampleDatas[1].tileCoords);
+        sampleDatas[0].tileUv = getClampedTileUv(shapePosition, sampleDatas[0].tileCoords);
+        sampleDatas[1].tileUv = getClampedTileUv(shapePosition, sampleDatas[1].tileCoords);
     #endif
 }
 
@@ -189,7 +194,7 @@ bool insideTile(in vec3 shapePosition, in ivec4 octreeCoords) {
 void traverseOctreeFromExisting(in vec3 shapePosition, inout TraversalData traversalData, inout SampleData sampleDatas[SAMPLE_COUNT]) {
     if (insideTile(shapePosition, traversalData.octreeCoords)) {
         for (int i = 0; i < SAMPLE_COUNT; i++) {
-            sampleDatas[0].tileUv = getTileUv(shapePosition, sampleDatas[0].tileCoords);
+            sampleDatas[0].tileUv = getClampedTileUv(shapePosition, sampleDatas[0].tileCoords);
         }
         return;
     }
@@ -211,10 +216,10 @@ void traverseOctreeFromExisting(in vec3 shapePosition, inout TraversalData trave
 
     #if (SAMPLE_COUNT == 1)
         getOctreeLeafSampleData(nodeData, traversalData.octreeCoords, sampleDatas[0]);
-        sampleDatas[0].tileUv = getTileUv(shapePosition, sampleDatas[0].tileCoords);
+        sampleDatas[0].tileUv = getClampedTileUv(shapePosition, sampleDatas[0].tileCoords);
     #else
         getOctreeLeafSampleDatas(nodeData, traversalData.octreeCoords, sampleDatas);
-        sampleDatas[0].tileUv = getTileUv(shapePosition, sampleDatas[0].tileCoords);
-        sampleDatas[1].tileUv = getTileUv(shapePosition, sampleDatas[1].tileCoords);
+        sampleDatas[0].tileUv = getClampedTileUv(shapePosition, sampleDatas[0].tileCoords);
+        sampleDatas[1].tileUv = getClampedTileUv(shapePosition, sampleDatas[1].tileCoords);
     #endif
 }

package/Source/Shaders/Voxels/Octree.js

@@ -80,10 +80,15 @@ int getOctreeParentIndex(in int octreeIndex) {\n\
 */\n\
 vec3 getTileUv(in vec3 shapePosition, in ivec4 octreeCoords) {\n\
 	// PERFORMANCE_IDEA: use bit-shifting (only in WebGL2)\n\
-    float dimAtLevel = pow(2.0, float(octreeCoords.w));\n\
+    float dimAtLevel = exp2(float(octreeCoords.w));\n\
     return shapePosition * dimAtLevel - vec3(octreeCoords.xyz);\n\
 }\n\
 \n\
+vec3 getClampedTileUv(in vec3 shapePosition, in ivec4 octreeCoords) {\n\
+    vec3 tileUv = getTileUv(shapePosition, octreeCoords);\n\
+    return clamp(tileUv, vec3(0.0), vec3(1.0));\n\
+}\n\
+\n\
 void getOctreeLeafSampleData(in OctreeNodeData data, in ivec4 octreeCoords, out SampleData sampleData) {\n\
     sampleData.megatextureIndex = data.data;\n\
     sampleData.tileCoords = (data.flag == OCTREE_FLAG_PACKED_LEAF_FROM_PARENT)\n\
@@ -122,7 +127,7 @@ void getOctreeLeafSampleDatas(in OctreeNodeData data, in ivec4 octreeCoords, out
 #endif\n\
 \n\
 OctreeNodeData traverseOctreeDownwards(in vec3 shapePosition, inout TraversalData traversalData) {\n\
-    float sizeAtLevel = 1.0 / pow(2.0, float(traversalData.octreeCoords.w));\n\
+    float sizeAtLevel = exp2(-1.0 * float(traversalData.octreeCoords.w));\n\
     vec3 start = vec3(traversalData.octreeCoords.xyz) * sizeAtLevel;\n\
     vec3 end = start + vec3(sizeAtLevel);\n\
     OctreeNodeData childData;\n\
@@ -168,11 +173,11 @@ void traverseOctreeFromBeginning(in vec3 shapePosition, out TraversalData traver
 \n\
     #if (SAMPLE_COUNT == 1)\n\
         getOctreeLeafSampleData(nodeData, traversalData.octreeCoords, sampleDatas[0]);\n\
-        sampleDatas[0].tileUv = getTileUv(shapePosition, sampleDatas[0].tileCoords);\n\
+        sampleDatas[0].tileUv = getClampedTileUv(shapePosition, sampleDatas[0].tileCoords);\n\
     #else\n\
         getOctreeLeafSampleDatas(nodeData, traversalData.octreeCoords, sampleDatas);\n\
-        sampleDatas[0].tileUv = getTileUv(shapePosition, sampleDatas[0].tileCoords);\n\
-        sampleDatas[1].tileUv = getTileUv(shapePosition, sampleDatas[1].tileCoords);\n\
+        sampleDatas[0].tileUv = getClampedTileUv(shapePosition, sampleDatas[0].tileCoords);\n\
+        sampleDatas[1].tileUv = getClampedTileUv(shapePosition, sampleDatas[1].tileCoords);\n\
     #endif\n\
 }\n\
 \n\
@@ -190,7 +195,7 @@ bool insideTile(in vec3 shapePosition, in ivec4 octreeCoords) {\n\
 void traverseOctreeFromExisting(in vec3 shapePosition, inout TraversalData traversalData, inout SampleData sampleDatas[SAMPLE_COUNT]) {\n\
     if (insideTile(shapePosition, traversalData.octreeCoords)) {\n\
         for (int i = 0; i < SAMPLE_COUNT; i++) {\n\
-            sampleDatas[0].tileUv = getTileUv(shapePosition, sampleDatas[0].tileCoords);\n\
+            sampleDatas[0].tileUv = getClampedTileUv(shapePosition, sampleDatas[0].tileCoords);\n\
         }\n\
         return;\n\
     }\n\
@@ -212,11 +217,11 @@ void traverseOctreeFromExisting(in vec3 shapePosition, inout TraversalData trave
 \n\
     #if (SAMPLE_COUNT == 1)\n\
         getOctreeLeafSampleData(nodeData, traversalData.octreeCoords, sampleDatas[0]);\n\
-        sampleDatas[0].tileUv = getTileUv(shapePosition, sampleDatas[0].tileCoords);\n\
+        sampleDatas[0].tileUv = getClampedTileUv(shapePosition, sampleDatas[0].tileCoords);\n\
     #else\n\
         getOctreeLeafSampleDatas(nodeData, traversalData.octreeCoords, sampleDatas);\n\
-        sampleDatas[0].tileUv = getTileUv(shapePosition, sampleDatas[0].tileCoords);\n\
-        sampleDatas[1].tileUv = getTileUv(shapePosition, sampleDatas[1].tileCoords);\n\
+        sampleDatas[0].tileUv = getClampedTileUv(shapePosition, sampleDatas[0].tileCoords);\n\
+        sampleDatas[1].tileUv = getClampedTileUv(shapePosition, sampleDatas[1].tileCoords);\n\
     #endif\n\
 }\n\
 ";