deeptwins-cesium-engine 0.1.2 → 0.1.4

package/Source/Shaders/Voxels/IntersectBox.js

@@ -6,44 +6,31 @@ export default "// See IntersectionUtils.glsl for the definitions of Ray, RaySha
 #define BOX_INTERSECTION_INDEX ### // always 0\n\
 */\n\
 \n\
-uniform vec3 u_renderMinBounds;\n\
-uniform vec3 u_renderMaxBounds;\n\
-\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 = (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\
-    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\
-    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 (entry.w > exit.w) {\n\
-        entry.w = NO_HIT;\n\
-        exit.w = NO_HIT;\n\
+uniform sampler2D u_renderBoundPlanesTexture;\n\
+\n\
+RayShapeIntersection intersectBoundPlanes(in Ray ray) {\n\
+    vec4 lastEntry = vec4(ray.dir, -INF_HIT);\n\
+    vec4 firstExit = vec4(-ray.dir, +INF_HIT);\n\
+    for (int i = 0; i < 6; i++) {\n\
+        vec4 boundPlane = getBoundPlane(u_renderBoundPlanesTexture, i);\n\
+        vec4 intersection = intersectPlane(ray, boundPlane);\n\
+        if (dot(ray.dir, boundPlane.xyz) < 0.0) {\n\
+            lastEntry = intersection.w > lastEntry.w ? intersection : lastEntry;\n\
+        } else {\n\
+            firstExit = intersection.w < firstExit.w ? intersection: firstExit;\n\
+        }\n\
     }\n\
 \n\
-    return RayShapeIntersection(entry, exit);\n\
+    if (lastEntry.w < firstExit.w) {\n\
+        return RayShapeIntersection(lastEntry, firstExit);\n\
+    } else {\n\
+        return RayShapeIntersection(vec4(-ray.dir, NO_HIT), vec4(ray.dir, NO_HIT));\n\
+    }\n\
 }\n\
 \n\
-void intersectShape(in Ray ray, inout Intersections ix)\n\
+void intersectShape(in Ray rayUV, in  Ray rayEC, inout Intersections ix)\n\
 {\n\
-    RayShapeIntersection intersection = intersectBox(ray, u_renderMinBounds, u_renderMaxBounds);\n\
+    RayShapeIntersection intersection = intersectBoundPlanes(rayEC);\n\
     setShapeIntersection(ix, BOX_INTERSECTION_INDEX, intersection);\n\
 }\n\
 ";

package/Source/Shaders/Voxels/IntersectCylinder.js

@@ -20,32 +20,30 @@ export default "// See IntersectionUtils.glsl for the definitions of Ray, NO_HIT
 \n\
 // Cylinder uniforms\n\
 uniform vec2 u_cylinderRenderRadiusMinMax;\n\
-uniform vec2 u_cylinderRenderHeightMinMax;\n\
 #if defined(CYLINDER_HAS_RENDER_BOUNDS_ANGLE)\n\
     uniform vec2 u_cylinderRenderAngleMinMax;\n\
 #endif\n\
 \n\
-/**\n\
- * Find the intersection of a ray with the volume defined by two planes of constant z\n\
- */\n\
-RayShapeIntersection intersectHeightBounds(in Ray ray, in vec2 minMaxHeight, in bool convex)\n\
-{\n\
-    float zPosition = ray.pos.z;\n\
-    float zDirection = ray.dir.z;\n\
-\n\
-    float tmin = (minMaxHeight.x - zPosition) / zDirection;\n\
-    float tmax = (minMaxHeight.y - zPosition) / zDirection;\n\
-\n\
-    // Normals point outside the volume\n\
-    float signFlip = convex ? 1.0 : -1.0;\n\
-    vec4 intersectMin = vec4(0.0, 0.0, -1.0 * signFlip, tmin);\n\
-    vec4 intersectMax = vec4(0.0, 0.0, 1.0 * signFlip, tmax);\n\
-\n\
-    bool topEntry = zDirection < 0.0;\n\
-    vec4 entry = topEntry ? intersectMax : intersectMin;\n\
-    vec4 exit = topEntry ? intersectMin : intersectMax;\n\
+uniform sampler2D u_renderBoundPlanesTexture;\n\
+\n\
+RayShapeIntersection intersectBoundPlanes(in Ray ray) {\n\
+    vec4 lastEntry = vec4(ray.dir, -INF_HIT);\n\
+    vec4 firstExit = vec4(-ray.dir, +INF_HIT);\n\
+    for (int i = 0; i < 2; i++) {\n\
+        vec4 boundPlane = getBoundPlane(u_renderBoundPlanesTexture, i);\n\
+        vec4 intersection = intersectPlane(ray, boundPlane);\n\
+        if (dot(ray.dir, boundPlane.xyz) < 0.0) {\n\
+            lastEntry = intersection.w > lastEntry.w ? intersection : lastEntry;\n\
+        } else {\n\
+            firstExit = intersection.w < firstExit.w ? intersection: firstExit;\n\
+        }\n\
+    }\n\
 \n\
-    return RayShapeIntersection(entry, exit);\n\
+    if (lastEntry.w < firstExit.w) {\n\
+        return RayShapeIntersection(lastEntry, firstExit);\n\
+    } else {\n\
+        return RayShapeIntersection(vec4(-ray.dir, NO_HIT), vec4(ray.dir, NO_HIT));\n\
+    }\n\
 }\n\
 \n\
 /**\n\
@@ -71,8 +69,11 @@ RayShapeIntersection intersectCylinder(in Ray ray, in float radius, in bool conv
     float t1 = (-b - determinant) / a;\n\
     float t2 = (-b + determinant) / a;\n\
     float signFlip = convex ? 1.0 : -1.0;\n\
-    vec4 intersect1 = vec4(normalize(position + t1 * direction) * signFlip, 0.0, t1);\n\
-    vec4 intersect2 = vec4(normalize(position + t2 * direction) * signFlip, 0.0, t2);\n\
+    vec3 normal1 = vec3((position + t1 * direction) * signFlip, 0.0);\n\
+    vec3 normal2 = vec3((position + t2 * direction) * signFlip, 0.0);\n\
+    // Return normals in eye coordinates\n\
+    vec4 intersect1 = vec4(normalize(czm_normal * normal1), t1);\n\
+    vec4 intersect2 = vec4(normalize(czm_normal * normal2), t2);\n\
 \n\
     return RayShapeIntersection(intersect1, intersect2);\n\
 }\n\
@@ -81,21 +82,16 @@ RayShapeIntersection intersectCylinder(in Ray ray, in float radius, in bool conv
  * Find the intersection of a ray with a right cylindrical solid of given\n\
  * radius and height bounds. NOTE: The shape is assumed to be convex.\n\
  */\n\
-RayShapeIntersection intersectBoundedCylinder(in Ray ray, in float radius, in vec2 minMaxHeight)\n\
+RayShapeIntersection intersectBoundedCylinder(in Ray ray, in Ray rayEC, in float radius)\n\
 {\n\
     RayShapeIntersection cylinderIntersection = intersectCylinder(ray, radius, true);\n\
-    RayShapeIntersection heightBoundsIntersection = intersectHeightBounds(ray, minMaxHeight, true);\n\
+    RayShapeIntersection heightBoundsIntersection = intersectBoundPlanes(rayEC);\n\
     return intersectIntersections(ray, cylinderIntersection, heightBoundsIntersection);\n\
 }\n\
 \n\
-void intersectShape(Ray ray, inout Intersections ix)\n\
+void intersectShape(in Ray ray, in Ray rayEC, inout Intersections ix)\n\
 {\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 *= 2.0;\n\
-\n\
-    RayShapeIntersection outerIntersect = intersectBoundedCylinder(ray, u_cylinderRenderRadiusMinMax.y, u_cylinderRenderHeightMinMax);\n\
+    RayShapeIntersection outerIntersect = intersectBoundedCylinder(ray, rayEC, u_cylinderRenderRadiusMinMax.y);\n\
 \n\
     setShapeIntersection(ix, CYLINDER_INTERSECTION_INDEX_RADIUS_MAX, outerIntersect);\n\
 \n\

package/Source/Shaders/Voxels/IntersectDepth.js

@@ -6,20 +6,24 @@ export default "// See IntersectionUtils.glsl for the definitions of Ray, Inters
 #define DEPTH_INTERSECTION_INDEX ###\n\
 */\n\
 \n\
-uniform mat4 u_transformPositionViewToUv;\n\
-\n\
 void intersectDepth(in vec2 screenCoord, in Ray ray, inout Intersections ix) {\n\
     float logDepthOrDepth = czm_unpackDepth(texture(czm_globeDepthTexture, screenCoord));\n\
+    float entry;\n\
+    float exit;\n\
     if (logDepthOrDepth != 0.0) {\n\
         // Calculate how far the ray must travel before it hits the depth buffer.\n\
         vec4 eyeCoordinateDepth = czm_screenToEyeCoordinates(screenCoord, logDepthOrDepth);\n\
         eyeCoordinateDepth /= eyeCoordinateDepth.w;\n\
-        vec3 depthPositionUv = vec3(u_transformPositionViewToUv * eyeCoordinateDepth);\n\
-        float t = dot(depthPositionUv - ray.pos, ray.dir);\n\
-        setIntersectionPair(ix, DEPTH_INTERSECTION_INDEX, vec2(t, +INF_HIT));\n\
+        entry = dot(eyeCoordinateDepth.xyz - ray.pos, ray.dir);\n\
+        exit = +INF_HIT;\n\
     } else {\n\
         // There's no depth at this location.\n\
-        setIntersectionPair(ix, DEPTH_INTERSECTION_INDEX, vec2(NO_HIT));\n\
+        entry = NO_HIT;\n\
+        exit = NO_HIT;\n\
     }\n\
+    ix.distanceToDepthBuffer = entry;\n\
+#if defined(DEPTH_TEST)\n\
+    setIntersectionPair(ix, DEPTH_INTERSECTION_INDEX, vec2(entry, exit));\n\
+#endif\n\
 }\n\
 ";

package/Source/Shaders/Voxels/IntersectEllipsoid.js

@@ -27,7 +27,7 @@ export default "// See IntersectionUtils.glsl for the definitions of Ray, NO_HIT
 #endif\n\
 uniform float u_eccentricitySquared;\n\
 uniform vec2 u_ellipsoidRenderLatitudeSinMinMax;\n\
-uniform vec2 u_clipMinMaxHeight;\n\
+uniform vec2 u_clipMinMaxHeight; // Values are negative: clipHeight - maxShapeHeight\n\
 \n\
 RayShapeIntersection intersectZPlane(in Ray ray, in float z) {\n\
     float t = -ray.pos.z / ray.dir.z;\n\
@@ -45,11 +45,11 @@ RayShapeIntersection intersectZPlane(in Ray ray, in float z) {\n\
     }\n\
 }\n\
 \n\
-RayShapeIntersection intersectHeight(in Ray ray, in float relativeHeight, in bool convex)\n\
+RayShapeIntersection intersectHeight(in Ray ray, in float height, in bool convex)\n\
 {\n\
     // Scale the ray by the ellipsoid axes to make it a unit sphere\n\
     // Note: approximating ellipsoid + height as an ellipsoid\n\
-    vec3 radiiCorrection = u_ellipsoidRadiiUv / (u_ellipsoidRadiiUv + relativeHeight);\n\
+    vec3 radiiCorrection = vec3(1.0) / (u_ellipsoidRadii + height);\n\
     vec3 position = ray.pos * radiiCorrection;\n\
     vec3 direction = ray.dir * radiiCorrection;\n\
 \n\
@@ -75,10 +75,14 @@ RayShapeIntersection intersectHeight(in Ray ray, in float relativeHeight, in boo
     float tmax = max(t1, t2);\n\
 \n\
     float directionScale = convex ? 1.0 : -1.0;\n\
-    vec3 d1 = directionScale * normalize(position + tmin * direction);\n\
-    vec3 d2 = directionScale * normalize(position + tmax * direction);\n\
+    vec3 d1 = directionScale * (position + tmin * direction);\n\
+    vec3 d2 = directionScale * (position + tmax * direction);\n\
 \n\
-    return RayShapeIntersection(vec4(d1, tmin), vec4(d2, tmax));\n\
+    // Return normals in eye coordinates. Use spherical approximation for the normal.\n\
+    vec3 normal1 = normalize(czm_normal * d1);\n\
+    vec3 normal2 = normalize(czm_normal * d2);\n\
+\n\
+    return RayShapeIntersection(vec4(normal1, tmin), vec4(normal2, tmax));\n\
 }\n\
 \n\
 /**\n\
@@ -152,16 +156,13 @@ float getLatitudeConeShift(in float sinLatitude) {\n\
     // Find prime vertical radius of curvature: \n\
     // the distance along the ellipsoid normal to the intersection with the z-axis\n\
     float x2 = u_eccentricitySquared * sinLatitude * sinLatitude;\n\
-    float primeVerticalRadius = inversesqrt(1.0 - x2);\n\
+    float primeVerticalRadius = u_ellipsoidRadii.x * inversesqrt(1.0 - x2);\n\
 \n\
     // Compute a shift from the origin to the intersection of the cone with the z-axis\n\
     return primeVerticalRadius * u_eccentricitySquared * sinLatitude;\n\
 }\n\
 \n\
 void intersectFlippedCone(in Ray ray, in float cosHalfAngle, out RayShapeIntersection intersections[2]) {\n\
-    // Undo the scaling from ellipsoid to sphere\n\
-    ray.pos = ray.pos * u_ellipsoidRadiiUv;\n\
-    ray.dir = ray.dir * u_ellipsoidRadiiUv;\n\
     // Shift the ray to account for the latitude cone not being centered at the Earth center\n\
     ray.pos.z += getLatitudeConeShift(cosHalfAngle);\n\
 \n\
@@ -207,9 +208,6 @@ void intersectFlippedCone(in Ray ray, in float cosHalfAngle, out RayShapeInterse
 }\n\
 \n\
 RayShapeIntersection intersectRegularCone(in Ray ray, in float cosHalfAngle, in bool convex) {\n\
-    // Undo the scaling from ellipsoid to sphere\n\
-    ray.pos = ray.pos * u_ellipsoidRadiiUv;\n\
-    ray.dir = ray.dir * u_ellipsoidRadiiUv;\n\
     // Shift the ray to account for the latitude cone not being centered at the Earth center\n\
     ray.pos.z += getLatitudeConeShift(cosHalfAngle);\n\
 \n\
@@ -246,13 +244,7 @@ RayShapeIntersection intersectRegularCone(in Ray ray, in float cosHalfAngle, in
     }\n\
 }\n\
 \n\
-void intersectShape(in Ray ray, inout Intersections ix) {\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 *= 2.0;\n\
-\n\
-    // Outer ellipsoid\n\
+void intersectShape(in Ray ray, in Ray rayEC, inout Intersections ix) {    // Outer ellipsoid\n\
     RayShapeIntersection outerIntersect = intersectHeight(ray, u_clipMinMaxHeight.y, true);\n\
     setShapeIntersection(ix, ELLIPSOID_INTERSECTION_INDEX_HEIGHT_MAX, outerIntersect);\n\
 \n\

package/Source/Shaders/Voxels/IntersectLongitude.js

@@ -2,6 +2,14 @@
 export default "// See IntersectionUtils.glsl for the definitions of Ray, NO_HIT, INF_HIT,\n\
 // RayShapeIntersection\n\
 \n\
+vec4 transformNormalToEC(in vec4 intersection) {\n\
+    return vec4(normalize(czm_normal * intersection.xyz), intersection.w);\n\
+}\n\
+\n\
+RayShapeIntersection transformNormalsToEC(in RayShapeIntersection ix) {\n\
+    return RayShapeIntersection(transformNormalToEC(ix.entry), transformNormalToEC(ix.exit));\n\
+}\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\
@@ -33,8 +41,8 @@ RayShapeIntersection intersectHalfSpace(in Ray ray, in float angle, in bool posi
 \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\
+    intersections[0] = transformNormalsToEC(intersectHalfSpace(ray, minMaxAngle.x, false));\n\
+    intersections[1] = transformNormalsToEC(intersectHalfSpace(ray, minMaxAngle.y, true));\n\
 }\n\
 \n\
 bool hitPositiveHalfPlane(in Ray ray, in vec4 intersection, in bool positiveNormal) {\n\
@@ -47,14 +55,18 @@ bool hitPositiveHalfPlane(in Ray ray, in vec4 intersection, in bool positiveNorm
 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\
+    bool hitPositiveSide = hitPositiveHalfPlane(ray, intersection, true);\n\
+\n\
+    farSide = transformNormalToEC(farSide);\n\
 \n\
-    if (hitPositiveHalfPlane(ray, intersection, true)) {\n\
+    if (hitPositiveSide) {\n\
+        intersection = transformNormalToEC(intersection);\n\
         intersections[0].entry = -1.0 * farSide;\n\
-        intersections[0].exit = vec4(-1.0 * intersection.xy, 0.0, intersection.w);\n\
+        intersections[0].exit = vec4(-1.0 * intersection.xyz, intersection.w);\n\
         intersections[1].entry = intersection;\n\
         intersections[1].exit = farSide;\n\
     } else {\n\
-        vec4 miss = vec4(normalize(ray.dir), NO_HIT);\n\
+        vec4 miss = vec4(normalize(czm_normal * ray.dir), NO_HIT);\n\
         intersections[0].entry = -1.0 * farSide;\n\
         intersections[0].exit = farSide;\n\
         intersections[1].entry = miss;\n\
@@ -89,16 +101,16 @@ RayShapeIntersection intersectRegularWedge(in Ray ray, in vec2 minMaxAngle)\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\
+        return transformNormalsToEC(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\
+        return transformNormalsToEC(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\
+        return transformNormalsToEC(RayShapeIntersection(last, farSide));\n\
     } else { // !exitFromInside && !enterFromOutside\n\
         // Both intersections were in the shadow wedge\n\
-        return RayShapeIntersection(miss, miss);\n\
+        return transformNormalsToEC(RayShapeIntersection(miss, miss));\n\
     }\n\
 }\n\
 ";

package/Source/Shaders/Voxels/Intersection.js

@@ -12,9 +12,9 @@ export default "// Main intersection function for Voxel scenes.\n\
 #define INTERSECTION_COUNT ###\n\
 */\n\
 \n\
-RayShapeIntersection intersectScene(in vec2 screenCoord, in Ray ray, out Intersections ix) {\n\
+RayShapeIntersection intersectScene(in vec2 screenCoord, in Ray ray, in Ray rayEC, out Intersections ix) {\n\
     // Do a ray-shape intersection to find the exact starting and ending points.\n\
-    intersectShape(ray, ix);\n\
+    intersectShape(ray, rayEC, ix);\n\
 \n\
     // Exit early if the positive shape was completely missed or behind the ray.\n\
     RayShapeIntersection intersection = getFirstIntersection(ix);\n\
@@ -29,9 +29,7 @@ RayShapeIntersection intersectScene(in vec2 screenCoord, in Ray ray, out Interse
     #endif\n\
 \n\
     // Depth\n\
-    #if defined(DEPTH_TEST)\n\
-        intersectDepth(screenCoord, ray, ix);\n\
-    #endif\n\
+    intersectDepth(screenCoord, rayEC, ix);\n\
 \n\
     // Find the first intersection that's in front of the ray\n\
     #if (INTERSECTION_COUNT > 1)\n\

package/Source/Shaders/Voxels/IntersectionUtils.js

@@ -57,6 +57,7 @@ struct Intersections {\n\
     // INTERSECTION_COUNT is the number of ray-*shape* (volume) intersections,\n\
     // so we need twice as many to track ray-*surface* intersections\n\
     vec4 intersections[INTERSECTION_COUNT * 2];\n\
+    float distanceToDepthBuffer;\n\
 \n\
     #if (INTERSECTION_COUNT > 1)\n\
         // Maintain state for future nextIntersection calls\n\
@@ -135,7 +136,7 @@ RayShapeIntersection nextIntersection(inout Intersections ix) {\n\
         surfaceIntersection = ix.intersections[i];\n\
         int intersectionType = int(length(surfaceIntersection.xyz) - 0.5);\n\
         bool currShapeIsPositive = intersectionType < 2;\n\
-        bool enter = intMod(intersectionType, 2) == 0;\n\
+        bool enter = intersectionType % 2 == 0;\n\
 \n\
         ix.surroundCount += enter ? +1 : -1;\n\
         ix.surroundIsPositive = currShapeIsPositive ? enter : ix.surroundIsPositive;\n\

package/Source/Shaders/Voxels/Megatexture.js

@@ -1,105 +1,37 @@
 //This file is automatically rebuilt by the Cesium build process.
-export default "// See Octree.glsl for the definitions of SampleData and intMod\n\
+export default "// See Octree.glsl for the definitions of SampleData\n\
 \n\
 /* Megatexture defines (set in Scene/VoxelRenderResources.js)\n\
 #define SAMPLE_COUNT ###\n\
-#define NEAREST_SAMPLING\n\
 #define PADDING\n\
 */\n\
 \n\
-uniform ivec2 u_megatextureSliceDimensions; // number of slices per tile, in two dimensions\n\
-uniform ivec2 u_megatextureTileDimensions; // number of tiles per megatexture, in two dimensions\n\
-uniform vec2 u_megatextureVoxelSizeUv;\n\
-uniform vec2 u_megatextureSliceSizeUv;\n\
-uniform vec2 u_megatextureTileSizeUv;\n\
+uniform ivec3 u_megatextureTileCounts; // number of tiles in the megatexture, along each axis\n\
 \n\
-// Integer min, max, clamp: For WebGL1 only\n\
-int intMin(int a, int b) {\n\
-    return a <= b ? a : b;\n\
-}\n\
-int intMax(int a, int b) {\n\
-    return a >= b ? a : b;\n\
-}\n\
-int intClamp(int v, int minVal, int maxVal) {\n\
-    return intMin(intMax(v, minVal), maxVal);\n\
-}\n\
-\n\
-vec2 index1DTo2DTexcoord(int index, ivec2 dimensions, vec2 uvScale)\n\
+vec3 index1DTo3DTexCoord(int index)\n\
 {\n\
-    int indexX = intMod(index, dimensions.x);\n\
-    int indexY = index / dimensions.x;\n\
-    return vec2(indexX, indexY) * uvScale;\n\
+    int tilesPerZ = u_megatextureTileCounts.x * u_megatextureTileCounts.y;\n\
+    int iz = index / tilesPerZ;\n\
+    int remainder = index - iz * tilesPerZ;\n\
+    int iy = remainder / u_megatextureTileCounts.x;\n\
+    int ix = remainder - iy * u_megatextureTileCounts.x;\n\
+    return vec3(ix, iy, iz) / vec3(u_megatextureTileCounts);\n\
 }\n\
 \n\
-/*\n\
-    How is 3D data stored in a 2D megatexture?\n\
-\n\
-    In this example there is only one loaded tile and it has 2x2x2 voxels (8 voxels total).\n\
-    The data is sliced by Z. The data at Z = 0 is placed in texels (0,0), (0,1), (1,0), (1,1) and\n\
-    the data at Z = 1 is placed in texels (2,0), (2,1), (3,0), (3,1).\n\
-    Note that there could be empty space in the megatexture because it's a power of two.\n\
-\n\
-      0   1   2   3\n\
-    +---+---+---+---+\n\
-    |   |   |   |   | 3\n\
-    +---+---+---+---+\n\
-    |   |   |   |   | 2\n\
-    +-------+-------+\n\
-    |010|110|011|111| 1\n\
-    |--- ---|--- ---|\n\
-    |000|100|001|101| 0\n\
-    +-------+-------+\n\
-\n\
-    When doing linear interpolation the megatexture needs to be sampled twice: once for\n\
-    the Z slice above the voxel coordinate and once for the slice below. The two slices\n\
-    are interpolated with fract(coord.z - 0.5). For example, a Z coordinate of 1.0 is\n\
-    halfway between two Z slices so the interpolation factor is 0.5. Below is a side view\n\
-    of the 3D voxel grid with voxel coordinates on the left side.\n\
-\n\
-    2 +---+\n\
-      |001|\n\
-    1 +-z-+\n\
-      |000|\n\
-    0 +---+\n\
-\n\
-    When doing nearest neighbor the megatexture only needs to be sampled once at the closest Z slice.\n\
-*/\n\
-\n\
 Properties getPropertiesFromMegatexture(in SampleData sampleData) {\n\
     int tileIndex = sampleData.megatextureIndex;\n\
 \n\
     vec3 voxelCoord = sampleData.inputCoordinate;\n\
-    #if defined(NEAREST_SAMPLING)\n\
-        // Round to the center of the nearest voxel\n\
-        voxelCoord = floor(voxelCoord) + vec3(0.5);\n\
-    #endif\n\
 \n\
-    // Tile location\n\
-    vec2 tileUvOffset = index1DTo2DTexcoord(tileIndex, u_megatextureTileDimensions, u_megatextureTileSizeUv);\n\
-\n\
-    // Slice location\n\
-    float slice = voxelCoord.z - 0.5;\n\
-    int sliceIndex = int(floor(slice));\n\
-    int sliceIndex0 = intClamp(sliceIndex, 0, u_inputDimensions.z - 1);\n\
-    vec2 sliceUvOffset0 = index1DTo2DTexcoord(sliceIndex0, u_megatextureSliceDimensions, u_megatextureSliceSizeUv);\n\
+    // UV coordinate of the lower corner of the tile in the megatexture\n\
+    vec3 tileUvOffset = index1DTo3DTexCoord(tileIndex);\n\
 \n\
     // Voxel location\n\
-    vec2 voxelUvOffset = clamp(voxelCoord.xy, vec2(0.5), vec2(u_inputDimensions.xy) - vec2(0.5)) * u_megatextureVoxelSizeUv;\n\
-\n\
-    // Final location in the megatexture\n\
-    vec2 uv0 = tileUvOffset + sliceUvOffset0 + voxelUvOffset;\n\
+    vec3 tileDimensions = vec3(u_inputDimensions);\n\
+    vec3 clampedVoxelCoord = clamp(voxelCoord, vec3(0.5), tileDimensions - vec3(0.5));\n\
+    vec3 voxelUv = clampedVoxelCoord / tileDimensions / vec3(u_megatextureTileCounts);\n\
 \n\
-    #if defined(NEAREST_SAMPLING)\n\
-        return getPropertiesFromMegatextureAtUv(uv0);\n\
-    #else\n\
-        float sliceLerp = fract(slice);\n\
-        int sliceIndex1 = intMin(sliceIndex + 1, u_inputDimensions.z - 1);\n\
-        vec2 sliceUvOffset1 = index1DTo2DTexcoord(sliceIndex1, u_megatextureSliceDimensions, u_megatextureSliceSizeUv);\n\
-        vec2 uv1 = tileUvOffset + sliceUvOffset1 + voxelUvOffset;\n\
-        Properties properties0 = getPropertiesFromMegatextureAtUv(uv0);\n\
-        Properties properties1 = getPropertiesFromMegatextureAtUv(uv1);\n\
-        return mixProperties(properties0, properties1, sliceLerp);\n\
-    #endif\n\
+    return getPropertiesFromMegatextureAtUv(tileUvOffset + voxelUv);\n\
 }\n\
 \n\
 // Convert an array of sample datas to a final weighted properties.\n\