@cesium/engine 22.2.0 → 23.0.0

package/Source/Shaders/Builtin/Functions/unpackTexture.glsl

@@ -0,0 +1,35 @@
+/**
+ * Useful for reinterpreting texture data as higher-precision values.
+ * Only works correctly in WebGL 2, which supports the uint type and bitwise operations.
+ *
+ * @param {float|vec2|vec3|vec4} 1-4 values from a texture lookup (RGBA channels), normalized to [0.0, 1.0].
+ * @return {uint} Raw bits as an unsigned integer.
+*/
+uint czm_unpackTexture(float packedValue) {
+    float rounded = czm_round(packedValue * 255.0);
+    return uint(rounded);
+}
+
+uint czm_unpackTexture(vec2 packedValue) {
+    vec2 rounded = czm_round(packedValue * 255.0);
+    uint byte0 = uint(rounded.x);
+    uint byte1 = uint(rounded.y);
+    return byte0 | (byte1 << 8);
+}
+
+uint czm_unpackTexture(vec3 packedValue) {
+    vec3 rounded = czm_round(packedValue * 255.0);
+    uint byte0 = uint(rounded.x);
+    uint byte1 = uint(rounded.y);
+    uint byte2 = uint(rounded.z);
+    return byte0 | (byte1 << 8) | (byte2 << 16);
+}
+
+uint czm_unpackTexture(vec4 packedValue) {
+    vec4 rounded = czm_round(packedValue * 255.0);
+    uint byte0 = uint(rounded.x);
+    uint byte1 = uint(rounded.y);
+    uint byte2 = uint(rounded.z);
+    uint byte3 = uint(rounded.w);
+    return byte0 | (byte1 << 8) | (byte2 << 16) | (byte3 << 24);
+}

package/Source/Shaders/Builtin/Functions/unpackTexture.js

@@ -0,0 +1,37 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "/**\n\
+ * Useful for reinterpreting texture data as higher-precision values.\n\
+ * Only works correctly in WebGL 2, which supports the uint type and bitwise operations.\n\
+ *\n\
+ * @param {float|vec2|vec3|vec4} 1-4 values from a texture lookup (RGBA channels), normalized to [0.0, 1.0].\n\
+ * @return {uint} Raw bits as an unsigned integer.\n\
+*/\n\
+uint czm_unpackTexture(float packedValue) {\n\
+    float rounded = czm_round(packedValue * 255.0);\n\
+    return uint(rounded);\n\
+}\n\
+\n\
+uint czm_unpackTexture(vec2 packedValue) {\n\
+    vec2 rounded = czm_round(packedValue * 255.0);\n\
+    uint byte0 = uint(rounded.x);\n\
+    uint byte1 = uint(rounded.y);\n\
+    return byte0 | (byte1 << 8);\n\
+}\n\
+\n\
+uint czm_unpackTexture(vec3 packedValue) {\n\
+    vec3 rounded = czm_round(packedValue * 255.0);\n\
+    uint byte0 = uint(rounded.x);\n\
+    uint byte1 = uint(rounded.y);\n\
+    uint byte2 = uint(rounded.z);\n\
+    return byte0 | (byte1 << 8) | (byte2 << 16);\n\
+}\n\
+\n\
+uint czm_unpackTexture(vec4 packedValue) {\n\
+    vec4 rounded = czm_round(packedValue * 255.0);\n\
+    uint byte0 = uint(rounded.x);\n\
+    uint byte1 = uint(rounded.y);\n\
+    uint byte2 = uint(rounded.z);\n\
+    uint byte3 = uint(rounded.w);\n\
+    return byte0 | (byte1 << 8) | (byte2 << 16) | (byte3 << 24);\n\
+}\n\
+";

package/Source/Shaders/CubeMapPanoramaVS.glsl

@@ -0,0 +1,11 @@
+uniform mat3 u_cubeMapPanoramaTransform;
+
+in vec3 position;
+out vec3 v_texCoord;
+
+void main()
+{
+    vec3 p = czm_viewRotation * (u_cubeMapPanoramaTransform * (czm_entireFrustum.y * position));
+    gl_Position = czm_projection * vec4(p, 1.0);
+    v_texCoord = position.xyz;
+}

package/Source/Shaders/CubeMapPanoramaVS.js

@@ -0,0 +1,13 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "uniform mat3 u_cubeMapPanoramaTransform;\n\
+\n\
+in vec3 position;\n\
+out vec3 v_texCoord;\n\
+\n\
+void main()\n\
+{\n\
+    vec3 p = czm_viewRotation * (u_cubeMapPanoramaTransform * (czm_entireFrustum.y * position));\n\
+    gl_Position = czm_projection * vec4(p, 1.0);\n\
+    v_texCoord = position.xyz;\n\
+}\n\
+";

package/Source/Shaders/Model/MetadataStageFS.glsl

@@ -1,9 +1,10 @@
 void metadataStage(
+  FeatureIds featureIds,
   out Metadata metadata,
   out MetadataClass metadataClass,
   out MetadataStatistics metadataStatistics,
   ProcessedAttributes attributes
   )
 {
-  initializeMetadata(metadata, metadataClass, metadataStatistics, attributes);
+  initializeMetadata(featureIds, metadata, metadataClass, metadataStatistics, attributes);
 }

package/Source/Shaders/Model/MetadataStageFS.js

@@ -1,11 +1,12 @@
 //This file is automatically rebuilt by the Cesium build process.
 export default "void metadataStage(\n\
+  FeatureIds featureIds,\n\
   out Metadata metadata,\n\
   out MetadataClass metadataClass,\n\
   out MetadataStatistics metadataStatistics,\n\
   ProcessedAttributes attributes\n\
   )\n\
 {\n\
-  initializeMetadata(metadata, metadataClass, metadataStatistics, attributes);\n\
+  initializeMetadata(featureIds, metadata, metadataClass, metadataStatistics, attributes);\n\
 }\n\
 ";

package/Source/Shaders/Model/MetadataStageVS.glsl

@@ -1,10 +1,11 @@
 void metadataStage(
+  FeatureIds featureIds,
   out Metadata metadata,
   out MetadataClass metadataClass,
   out MetadataStatistics metadataStatistics,
   ProcessedAttributes attributes
   )
 {
-  initializeMetadata(metadata, metadataClass, metadataStatistics, attributes);
+  initializeMetadata(featureIds, metadata, metadataClass, metadataStatistics, attributes);
   setMetadataVaryings();
 }

package/Source/Shaders/Model/MetadataStageVS.js

@@ -1,12 +1,13 @@
 //This file is automatically rebuilt by the Cesium build process.
 export default "void metadataStage(\n\
+  FeatureIds featureIds,\n\
   out Metadata metadata,\n\
   out MetadataClass metadataClass,\n\
   out MetadataStatistics metadataStatistics,\n\
   ProcessedAttributes attributes\n\
   )\n\
 {\n\
-  initializeMetadata(metadata, metadataClass, metadataStatistics, attributes);\n\
+  initializeMetadata(featureIds, metadata, metadataClass, metadataStatistics, attributes);\n\
   setMetadataVaryings();\n\
 }\n\
 ";

package/Source/Shaders/Model/ModelFS.glsl

@@ -29,6 +29,14 @@ SelectedFeature selectedFeature;
 
 void main()
 {
+    #if defined(PRIMITIVE_TYPE_POINTS) && defined(HAS_POINT_DIAMETER)
+    // Render points as circles
+    float distanceToCenter = length(gl_PointCoord - vec2(0.5));
+    if (distanceToCenter > 0.5) {
+        discard;
+    }
+    #endif
+
     #ifdef HAS_POINT_CLOUD_SHOW_STYLE
         if (v_pointCloudShow == 0.0)
         {
@@ -51,7 +59,7 @@ void main()
     Metadata metadata;
     MetadataClass metadataClass;
     MetadataStatistics metadataStatistics;
-    metadataStage(metadata, metadataClass, metadataStatistics, attributes);
+    metadataStage(featureIds, metadata, metadataClass, metadataStatistics, attributes);
 
     //========================================================================
     // When not picking metadata START

package/Source/Shaders/Model/ModelFS.js

@@ -30,6 +30,14 @@ SelectedFeature selectedFeature;\n\
 \n\
 void main()\n\
 {\n\
+    #if defined(PRIMITIVE_TYPE_POINTS) && defined(HAS_POINT_DIAMETER)\n\
+    // Render points as circles\n\
+    float distanceToCenter = length(gl_PointCoord - vec2(0.5));\n\
+    if (distanceToCenter > 0.5) {\n\
+        discard;\n\
+    }\n\
+    #endif\n\
+\n\
     #ifdef HAS_POINT_CLOUD_SHOW_STYLE\n\
         if (v_pointCloudShow == 0.0)\n\
         {\n\
@@ -52,7 +60,7 @@ void main()\n\
     Metadata metadata;\n\
     MetadataClass metadataClass;\n\
     MetadataStatistics metadataStatistics;\n\
-    metadataStage(metadata, metadataClass, metadataStatistics, attributes);\n\
+    metadataStage(featureIds, metadata, metadataClass, metadataStatistics, attributes);\n\
 \n\
     //========================================================================\n\
     // When not picking metadata START\n\

package/Source/Shaders/Model/ModelVS.glsl

@@ -95,7 +95,7 @@ void main()
     Metadata metadata;
     MetadataClass metadataClass;
     MetadataStatistics metadataStatistics;
-    metadataStage(metadata, metadataClass, metadataStatistics, attributes);
+    metadataStage(featureIds, metadata, metadataClass, metadataStatistics, attributes);
 
     #ifdef HAS_VERTICAL_EXAGGERATION
     verticalExaggerationStage(attributes);
@@ -142,10 +142,12 @@ void main()
         gl_PointSize = vsOutput.pointSize;
         #elif defined(HAS_POINT_CLOUD_POINT_SIZE_STYLE) || defined(HAS_POINT_CLOUD_ATTENUATION)
         gl_PointSize = pointCloudPointSizeStylingStage(attributes, metadata);
+        #elif defined(HAS_POINT_DIAMETER)
+        gl_PointSize = u_pointDiameter;
         #else
         gl_PointSize = 1.0;
         #endif
-        
+
         gl_PointSize *= show;
     #endif
 

package/Source/Shaders/Model/ModelVS.js

@@ -96,7 +96,7 @@ void main()\n\
     Metadata metadata;\n\
     MetadataClass metadataClass;\n\
     MetadataStatistics metadataStatistics;\n\
-    metadataStage(metadata, metadataClass, metadataStatistics, attributes);\n\
+    metadataStage(featureIds, metadata, metadataClass, metadataStatistics, attributes);\n\
 \n\
     #ifdef HAS_VERTICAL_EXAGGERATION\n\
     verticalExaggerationStage(attributes);\n\
@@ -143,10 +143,12 @@ void main()\n\
         gl_PointSize = vsOutput.pointSize;\n\
         #elif defined(HAS_POINT_CLOUD_POINT_SIZE_STYLE) || defined(HAS_POINT_CLOUD_ATTENUATION)\n\
         gl_PointSize = pointCloudPointSizeStylingStage(attributes, metadata);\n\
+        #elif defined(HAS_POINT_DIAMETER)\n\
+        gl_PointSize = u_pointDiameter;\n\
         #else\n\
         gl_PointSize = 1.0;\n\
         #endif\n\
-        \n\
+\n\
         gl_PointSize *= show;\n\
     #endif\n\
 \n\

package/Source/Shaders/PointPrimitiveCollectionVS.glsl

@@ -46,45 +46,14 @@ void main()
 
     ///////////////////////////////////////////////////////////////////////////
 
-    vec4 color;
-    vec4 outlineColor;
-    vec4 pickColor;
-
-    // compressedAttribute0.z => pickColor.rgb
-
-    temp = compressedAttribute0.z * SHIFT_RIGHT8;
-    pickColor.b = (temp - floor(temp)) * SHIFT_LEFT8;
-    temp = floor(temp) * SHIFT_RIGHT8;
-    pickColor.g = (temp - floor(temp)) * SHIFT_LEFT8;
-    pickColor.r = floor(temp);
-
-    // compressedAttribute0.x => color.rgb
-
-    temp = compressedAttribute0.x * SHIFT_RIGHT8;
-    color.b = (temp - floor(temp)) * SHIFT_LEFT8;
-    temp = floor(temp) * SHIFT_RIGHT8;
-    color.g = (temp - floor(temp)) * SHIFT_LEFT8;
-    color.r = floor(temp);
-
-    // compressedAttribute0.y => outlineColor.rgb
-
-    temp = compressedAttribute0.y * SHIFT_RIGHT8;
-    outlineColor.b = (temp - floor(temp)) * SHIFT_LEFT8;
-    temp = floor(temp) * SHIFT_RIGHT8;
-    outlineColor.g = (temp - floor(temp)) * SHIFT_LEFT8;
-    outlineColor.r = floor(temp);
-
-    // compressedAttribute0.w => color.a, outlineColor.a, pickColor.a
-
-    temp = compressedAttribute0.w * SHIFT_RIGHT8;
-    pickColor.a = (temp - floor(temp)) * SHIFT_LEFT8;
-    pickColor = pickColor / 255.0;
-
-    temp = floor(temp) * SHIFT_RIGHT8;
-    outlineColor.a = (temp - floor(temp)) * SHIFT_LEFT8;
-    outlineColor /= 255.0;
-    color.a = floor(temp);
-    color /= 255.0;
+    vec4 color = czm_decodeRGB8(compressedAttribute0.x);
+    vec4 outlineColor = czm_decodeRGB8(compressedAttribute0.y);
+    vec4 pickColor = czm_decodeRGB8(compressedAttribute0.z);
+    vec4 alphaPacked = czm_decodeRGB8(compressedAttribute0.w);
+
+    color.a = alphaPacked.x;
+    outlineColor.a = alphaPacked.y;
+    pickColor.a = alphaPacked.z;
 
     ///////////////////////////////////////////////////////////////////////////
 

package/Source/Shaders/PointPrimitiveCollectionVS.js

@@ -47,45 +47,14 @@ void main()\n\
 \n\
     ///////////////////////////////////////////////////////////////////////////\n\
 \n\
-    vec4 color;\n\
-    vec4 outlineColor;\n\
-    vec4 pickColor;\n\
-\n\
-    // compressedAttribute0.z => pickColor.rgb\n\
-\n\
-    temp = compressedAttribute0.z * SHIFT_RIGHT8;\n\
-    pickColor.b = (temp - floor(temp)) * SHIFT_LEFT8;\n\
-    temp = floor(temp) * SHIFT_RIGHT8;\n\
-    pickColor.g = (temp - floor(temp)) * SHIFT_LEFT8;\n\
-    pickColor.r = floor(temp);\n\
-\n\
-    // compressedAttribute0.x => color.rgb\n\
-\n\
-    temp = compressedAttribute0.x * SHIFT_RIGHT8;\n\
-    color.b = (temp - floor(temp)) * SHIFT_LEFT8;\n\
-    temp = floor(temp) * SHIFT_RIGHT8;\n\
-    color.g = (temp - floor(temp)) * SHIFT_LEFT8;\n\
-    color.r = floor(temp);\n\
-\n\
-    // compressedAttribute0.y => outlineColor.rgb\n\
-\n\
-    temp = compressedAttribute0.y * SHIFT_RIGHT8;\n\
-    outlineColor.b = (temp - floor(temp)) * SHIFT_LEFT8;\n\
-    temp = floor(temp) * SHIFT_RIGHT8;\n\
-    outlineColor.g = (temp - floor(temp)) * SHIFT_LEFT8;\n\
-    outlineColor.r = floor(temp);\n\
-\n\
-    // compressedAttribute0.w => color.a, outlineColor.a, pickColor.a\n\
-\n\
-    temp = compressedAttribute0.w * SHIFT_RIGHT8;\n\
-    pickColor.a = (temp - floor(temp)) * SHIFT_LEFT8;\n\
-    pickColor = pickColor / 255.0;\n\
-\n\
-    temp = floor(temp) * SHIFT_RIGHT8;\n\
-    outlineColor.a = (temp - floor(temp)) * SHIFT_LEFT8;\n\
-    outlineColor /= 255.0;\n\
-    color.a = floor(temp);\n\
-    color /= 255.0;\n\
+    vec4 color = czm_decodeRGB8(compressedAttribute0.x);\n\
+    vec4 outlineColor = czm_decodeRGB8(compressedAttribute0.y);\n\
+    vec4 pickColor = czm_decodeRGB8(compressedAttribute0.z);\n\
+    vec4 alphaPacked = czm_decodeRGB8(compressedAttribute0.w);\n\
+\n\
+    color.a = alphaPacked.x;\n\
+    outlineColor.a = alphaPacked.y;\n\
+    pickColor.a = alphaPacked.z;\n\
 \n\
     ///////////////////////////////////////////////////////////////////////////\n\
 \n\

package/Source/Shaders/Voxels/IntersectionUtils.glsl

@@ -135,7 +135,7 @@ RayShapeIntersection nextIntersection(inout Intersections ix) {
         surfaceIntersection = ix.intersections[i];
         int intersectionType = int(length(surfaceIntersection.xyz) - 0.5);
         bool currShapeIsPositive = intersectionType < 2;
-        bool enter = intMod(intersectionType, 2) == 0;
+        bool enter = intersectionType % 2 == 0;
 
         ix.surroundCount += enter ? +1 : -1;
         ix.surroundIsPositive = currShapeIsPositive ? enter : ix.surroundIsPositive;

package/Source/Shaders/Voxels/IntersectionUtils.js

@@ -136,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.glsl

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

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\