@cesium/engine 0.1.0 → 1.1.0

package/Source/Shaders/Voxels/Intersection.glsl

@@ -0,0 +1,54 @@
+// Main intersection function for Voxel scenes.
+// See IntersectBox.glsl, IntersectCylinder.glsl, or IntersectEllipsoid.glsl
+// for the definition of intersectShape. The appropriate function is selected
+// based on the VoxelPrimitive shape type, and added to the shader in
+// Scene/VoxelRenderResources.js.
+// See also IntersectClippingPlane.glsl and IntersectDepth.glsl.
+// See IntersectionUtils.glsl for the definitions of Ray, NO_HIT,
+// getIntersectionPair, initializeIntersections, nextIntersection.
+
+/* Intersection defines (set in Scene/VoxelRenderResources.js)
+#define INTERSECTION_COUNT ###
+*/
+
+vec2 intersectScene(vec2 screenCoord, vec3 positionUv, vec3 directionUv, out Intersections ix) {
+    Ray ray = Ray(positionUv, directionUv);
+
+    // Do a ray-shape intersection to find the exact starting and ending points.
+    intersectShape(ray, ix);
+
+    // Exit early if the positive shape was completely missed or behind the ray.
+    vec2 entryExitT = getIntersectionPair(ix, 0);
+    if (entryExitT.x == NO_HIT) {
+        // Positive shape was completely missed - so exit early.
+        return vec2(NO_HIT);
+    }
+
+    // Clipping planes
+    #if defined(CLIPPING_PLANES)
+        intersectClippingPlanes(ray, ix);
+    #endif
+
+    // Depth
+    #if defined(DEPTH_TEST)
+        intersectDepth(screenCoord, ray, ix);
+    #endif
+
+    // Find the first intersection that's in front of the ray
+    #if (INTERSECTION_COUNT > 1)
+        initializeIntersections(ix);
+        for (int i = 0; i < INTERSECTION_COUNT; ++i) {
+            entryExitT = nextIntersection(ix);
+            if (entryExitT.y > 0.0) {
+                // Set start to 0.0 when ray is inside the shape.
+                entryExitT.x = max(entryExitT.x, 0.0);
+                break;
+            }
+        }
+    #else
+        // Set start to 0.0 when ray is inside the shape.
+        entryExitT.x = max(entryExitT.x, 0.0);
+    #endif
+
+    return entryExitT;
+}

package/Source/Shaders/Voxels/Intersection.js

@@ -0,0 +1,56 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "// Main intersection function for Voxel scenes.\n\
+// See IntersectBox.glsl, IntersectCylinder.glsl, or IntersectEllipsoid.glsl\n\
+// for the definition of intersectShape. The appropriate function is selected\n\
+// based on the VoxelPrimitive shape type, and added to the shader in\n\
+// Scene/VoxelRenderResources.js.\n\
+// See also IntersectClippingPlane.glsl and IntersectDepth.glsl.\n\
+// See IntersectionUtils.glsl for the definitions of Ray, NO_HIT,\n\
+// getIntersectionPair, initializeIntersections, nextIntersection.\n\
+\n\
+/* Intersection defines (set in Scene/VoxelRenderResources.js)\n\
+#define INTERSECTION_COUNT ###\n\
+*/\n\
+\n\
+vec2 intersectScene(vec2 screenCoord, vec3 positionUv, vec3 directionUv, out Intersections ix) {\n\
+    Ray ray = Ray(positionUv, directionUv);\n\
+\n\
+    // Do a ray-shape intersection to find the exact starting and ending points.\n\
+    intersectShape(ray, ix);\n\
+\n\
+    // Exit early if the positive shape was completely missed or behind the ray.\n\
+    vec2 entryExitT = getIntersectionPair(ix, 0);\n\
+    if (entryExitT.x == NO_HIT) {\n\
+        // Positive shape was completely missed - so exit early.\n\
+        return vec2(NO_HIT);\n\
+    }\n\
+\n\
+    // Clipping planes\n\
+    #if defined(CLIPPING_PLANES)\n\
+        intersectClippingPlanes(ray, ix);\n\
+    #endif\n\
+\n\
+    // Depth\n\
+    #if defined(DEPTH_TEST)\n\
+        intersectDepth(screenCoord, ray, ix);\n\
+    #endif\n\
+\n\
+    // Find the first intersection that's in front of the ray\n\
+    #if (INTERSECTION_COUNT > 1)\n\
+        initializeIntersections(ix);\n\
+        for (int i = 0; i < INTERSECTION_COUNT; ++i) {\n\
+            entryExitT = nextIntersection(ix);\n\
+            if (entryExitT.y > 0.0) {\n\
+                // Set start to 0.0 when ray is inside the shape.\n\
+                entryExitT.x = max(entryExitT.x, 0.0);\n\
+                break;\n\
+            }\n\
+        }\n\
+    #else\n\
+        // Set start to 0.0 when ray is inside the shape.\n\
+        entryExitT.x = max(entryExitT.x, 0.0);\n\
+    #endif\n\
+\n\
+    return entryExitT;\n\
+}\n\
+";

package/Source/Shaders/Voxels/IntersectionUtils.glsl

@@ -0,0 +1,151 @@
+/* Intersection defines
+#define INTERSECTION_COUNT ###
+*/
+
+#define NO_HIT (-czm_infinity)
+#define INF_HIT (czm_infinity * 0.5)
+
+struct Ray {
+    vec3 pos;
+    vec3 dir;
+};
+
+struct Intersections {
+    // Don't access these member variables directly - call the functions instead.
+
+    #if (INTERSECTION_COUNT > 1)
+        // Store an array of intersections. Each intersection is composed of:
+        //  x for the T value
+        //  y for the shape type - which encodes positive vs negative and entering vs exiting
+        // For example:
+        //  y = 0: positive shape entry
+        //  y = 1: positive shape exit
+        //  y = 2: negative shape entry
+        //  y = 3: negative shape exit
+        vec2 intersections[INTERSECTION_COUNT * 2];
+
+        // Maintain state for future nextIntersection calls
+        int index;
+        int surroundCount;
+        bool surroundIsPositive;
+    #else
+        // When there's only one positive shape intersection none of the extra stuff is needed.
+        float intersections[2];
+    #endif
+};
+
+// Using a define instead of a real function because WebGL1 cannot access array with non-constant index.
+#if (INTERSECTION_COUNT > 1)
+    #define getIntersection(/*inout Intersections*/ ix, /*int*/ index) (ix).intersections[(index)].x
+#else
+    #define getIntersection(/*inout Intersections*/ ix, /*int*/ index) (ix).intersections[(index)]
+#endif
+
+// Using a define instead of a real function because WebGL1 cannot access array with non-constant index.
+#define getIntersectionPair(/*inout Intersections*/ ix, /*int*/ index) vec2(getIntersection((ix), (index) * 2 + 0), getIntersection((ix), (index) * 2 + 1))
+
+// Using a define instead of a real function because WebGL1 cannot access array with non-constant index.
+#if (INTERSECTION_COUNT > 1)
+    #define setIntersection(/*inout Intersections*/ ix, /*int*/ index, /*float*/ t, /*bool*/ positive, /*enter*/ enter) (ix).intersections[(index)] = vec2((t), float(!positive) * 2.0 + float(!enter))
+#else
+    #define setIntersection(/*inout Intersections*/ ix, /*int*/ index, /*float*/ t, /*bool*/ positive, /*enter*/ enter) (ix).intersections[(index)] = (t)
+#endif
+
+// Using a define instead of a real function because WebGL1 cannot access array with non-constant index.
+#if (INTERSECTION_COUNT > 1)
+    #define setIntersectionPair(/*inout Intersections*/ ix, /*int*/ index, /*vec2*/ entryExit) (ix).intersections[(index) * 2 + 0] = vec2((entryExit).x, float((index) > 0) * 2.0 + 0.0); (ix).intersections[(index) * 2 + 1] = vec2((entryExit).y, float((index) > 0) * 2.0 + 1.0)
+#else
+    #define setIntersectionPair(/*inout Intersections*/ ix, /*int*/ index, /*vec2*/ entryExit) (ix).intersections[(index) * 2 + 0] = (entryExit).x; (ix).intersections[(index) * 2 + 1] = (entryExit).y
+#endif
+
+#if (INTERSECTION_COUNT > 1)
+void initializeIntersections(inout Intersections ix) {
+    // Sort the intersections from min T to max T with bubble sort.
+    // Note: If this sorting function changes, some of the intersection test may
+    // need to be updated. Search for "bubble sort" to find those areas.
+    const int sortPasses = INTERSECTION_COUNT * 2 - 1;
+    for (int n = sortPasses; n > 0; --n) {
+        for (int i = 0; i < sortPasses; ++i) {
+            // The loop should be: for (i = 0; i < n; ++i) {...} but WebGL1 cannot
+            // loop with non-constant condition, so it has to break early instead
+            if (i >= n) { break; }
+
+            vec2 intersect0 = ix.intersections[i + 0];
+            vec2 intersect1 = ix.intersections[i + 1];
+
+            float t0 = intersect0.x;
+            float t1 = intersect1.x;
+            float b0 = intersect0.y;
+            float b1 = intersect1.y;
+
+            float tmin = min(t0, t1);
+            float tmax = max(t0, t1);
+            float bmin = tmin == t0 ? b0 : b1;
+            float bmax = tmin == t0 ? b1 : b0;
+
+            ix.intersections[i + 0] = vec2(tmin, bmin);
+            ix.intersections[i + 1] = vec2(tmax, bmax);
+        }
+    }
+
+    // Prepare initial state for nextIntersection
+    ix.index = 0;
+    ix.surroundCount = 0;
+    ix.surroundIsPositive = false;
+}
+#endif
+
+#if (INTERSECTION_COUNT > 1)
+vec2 nextIntersection(inout Intersections ix) {
+    vec2 entryExitT = vec2(NO_HIT);
+
+    const int passCount = INTERSECTION_COUNT * 2;
+
+    if (ix.index == passCount) {
+        return entryExitT;
+    }
+
+    for (int i = 0; i < passCount; ++i) {
+        // The loop should be: for (i = ix.index; i < passCount; ++i) {...} but WebGL1 cannot
+        // loop with non-constant condition, so it has to continue instead.
+        if (i < ix.index) {
+            continue;
+        }
+
+        ix.index = i + 1;
+
+        vec2 intersect = ix.intersections[i];
+        float t = intersect.x;
+        bool currShapeIsPositive = intersect.y < 2.0;
+        bool enter = mod(intersect.y, 2.0) == 0.0;
+
+        ix.surroundCount += enter ? +1 : -1;
+        ix.surroundIsPositive = currShapeIsPositive ? enter : ix.surroundIsPositive;
+
+        // entering positive or exiting negative
+        if (ix.surroundCount == 1 && ix.surroundIsPositive && enter == currShapeIsPositive) {
+            entryExitT.x = t;
+        }
+
+        // exiting positive or entering negative after being inside positive
+        // TODO: Can this be simplified?
+        bool exitPositive = !enter && currShapeIsPositive && ix.surroundCount == 0;
+        bool enterNegativeFromPositive = enter && !currShapeIsPositive && ix.surroundCount == 2 && ix.surroundIsPositive;
+        if (exitPositive || enterNegativeFromPositive) {
+            entryExitT.y = t;
+
+            // entry and exit have been found, so the loop can stop
+            if (exitPositive) {
+                // After exiting positive shape there is nothing left to intersect, so jump to the end index.
+                ix.index = passCount;
+            }
+            break;
+        }
+    }
+
+    return entryExitT;
+}
+#endif
+
+// NOTE: initializeIntersections, nextIntersection aren't even declared unless INTERSECTION_COUNT > 1
+// export { NO_HIT, INF_HIT, Ray, Intersections, getIntersectionPair, setIntersectionPair, initializeIntersections, nextIntersection };

package/Source/Shaders/Voxels/IntersectionUtils.js

@@ -0,0 +1,153 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "/* Intersection defines\n\
+#define INTERSECTION_COUNT ###\n\
+*/\n\
+\n\
+#define NO_HIT (-czm_infinity)\n\
+#define INF_HIT (czm_infinity * 0.5)\n\
+\n\
+struct Ray {\n\
+    vec3 pos;\n\
+    vec3 dir;\n\
+};\n\
+\n\
+struct Intersections {\n\
+    // Don't access these member variables directly - call the functions instead.\n\
+\n\
+    #if (INTERSECTION_COUNT > 1)\n\
+        // Store an array of intersections. Each intersection is composed of:\n\
+        //  x for the T value\n\
+        //  y for the shape type - which encodes positive vs negative and entering vs exiting\n\
+        // For example:\n\
+        //  y = 0: positive shape entry\n\
+        //  y = 1: positive shape exit\n\
+        //  y = 2: negative shape entry\n\
+        //  y = 3: negative shape exit\n\
+        vec2 intersections[INTERSECTION_COUNT * 2];\n\
+\n\
+        // Maintain state for future nextIntersection calls\n\
+        int index;\n\
+        int surroundCount;\n\
+        bool surroundIsPositive;\n\
+    #else\n\
+        // When there's only one positive shape intersection none of the extra stuff is needed.\n\
+        float intersections[2];\n\
+    #endif\n\
+};\n\
+\n\
+// Using a define instead of a real function because WebGL1 cannot access array with non-constant index.\n\
+#if (INTERSECTION_COUNT > 1)\n\
+    #define getIntersection(/*inout Intersections*/ ix, /*int*/ index) (ix).intersections[(index)].x\n\
+#else\n\
+    #define getIntersection(/*inout Intersections*/ ix, /*int*/ index) (ix).intersections[(index)]\n\
+#endif\n\
+\n\
+// Using a define instead of a real function because WebGL1 cannot access array with non-constant index.\n\
+#define getIntersectionPair(/*inout Intersections*/ ix, /*int*/ index) vec2(getIntersection((ix), (index) * 2 + 0), getIntersection((ix), (index) * 2 + 1))\n\
+\n\
+// Using a define instead of a real function because WebGL1 cannot access array with non-constant index.\n\
+#if (INTERSECTION_COUNT > 1)\n\
+    #define setIntersection(/*inout Intersections*/ ix, /*int*/ index, /*float*/ t, /*bool*/ positive, /*enter*/ enter) (ix).intersections[(index)] = vec2((t), float(!positive) * 2.0 + float(!enter))\n\
+#else\n\
+    #define setIntersection(/*inout Intersections*/ ix, /*int*/ index, /*float*/ t, /*bool*/ positive, /*enter*/ enter) (ix).intersections[(index)] = (t)\n\
+#endif\n\
+\n\
+// Using a define instead of a real function because WebGL1 cannot access array with non-constant index.\n\
+#if (INTERSECTION_COUNT > 1)\n\
+    #define setIntersectionPair(/*inout Intersections*/ ix, /*int*/ index, /*vec2*/ entryExit) (ix).intersections[(index) * 2 + 0] = vec2((entryExit).x, float((index) > 0) * 2.0 + 0.0); (ix).intersections[(index) * 2 + 1] = vec2((entryExit).y, float((index) > 0) * 2.0 + 1.0)\n\
+#else\n\
+    #define setIntersectionPair(/*inout Intersections*/ ix, /*int*/ index, /*vec2*/ entryExit) (ix).intersections[(index) * 2 + 0] = (entryExit).x; (ix).intersections[(index) * 2 + 1] = (entryExit).y\n\
+#endif\n\
+\n\
+#if (INTERSECTION_COUNT > 1)\n\
+void initializeIntersections(inout Intersections ix) {\n\
+    // Sort the intersections from min T to max T with bubble sort.\n\
+    // Note: If this sorting function changes, some of the intersection test may\n\
+    // need to be updated. Search for \"bubble sort\" to find those areas.\n\
+    const int sortPasses = INTERSECTION_COUNT * 2 - 1;\n\
+    for (int n = sortPasses; n > 0; --n) {\n\
+        for (int i = 0; i < sortPasses; ++i) {\n\
+            // The loop should be: for (i = 0; i < n; ++i) {...} but WebGL1 cannot\n\
+            // loop with non-constant condition, so it has to break early instead\n\
+            if (i >= n) { break; }\n\
+\n\
+            vec2 intersect0 = ix.intersections[i + 0];\n\
+            vec2 intersect1 = ix.intersections[i + 1];\n\
+\n\
+            float t0 = intersect0.x;\n\
+            float t1 = intersect1.x;\n\
+            float b0 = intersect0.y;\n\
+            float b1 = intersect1.y;\n\
+\n\
+            float tmin = min(t0, t1);\n\
+            float tmax = max(t0, t1);\n\
+            float bmin = tmin == t0 ? b0 : b1;\n\
+            float bmax = tmin == t0 ? b1 : b0;\n\
+\n\
+            ix.intersections[i + 0] = vec2(tmin, bmin);\n\
+            ix.intersections[i + 1] = vec2(tmax, bmax);\n\
+        }\n\
+    }\n\
+\n\
+    // Prepare initial state for nextIntersection\n\
+    ix.index = 0;\n\
+    ix.surroundCount = 0;\n\
+    ix.surroundIsPositive = false;\n\
+}\n\
+#endif\n\
+\n\
+#if (INTERSECTION_COUNT > 1)\n\
+vec2 nextIntersection(inout Intersections ix) {\n\
+    vec2 entryExitT = vec2(NO_HIT);\n\
+\n\
+    const int passCount = INTERSECTION_COUNT * 2;\n\
+\n\
+    if (ix.index == passCount) {\n\
+        return entryExitT;\n\
+    }\n\
+\n\
+    for (int i = 0; i < passCount; ++i) {\n\
+        // The loop should be: for (i = ix.index; i < passCount; ++i) {...} but WebGL1 cannot\n\
+        // loop with non-constant condition, so it has to continue instead.\n\
+        if (i < ix.index) {\n\
+            continue;\n\
+        }\n\
+\n\
+        ix.index = i + 1;\n\
+\n\
+        vec2 intersect = ix.intersections[i];\n\
+        float t = intersect.x;\n\
+        bool currShapeIsPositive = intersect.y < 2.0;\n\
+        bool enter = mod(intersect.y, 2.0) == 0.0;\n\
+\n\
+        ix.surroundCount += enter ? +1 : -1;\n\
+        ix.surroundIsPositive = currShapeIsPositive ? enter : ix.surroundIsPositive;\n\
+\n\
+        // entering positive or exiting negative\n\
+        if (ix.surroundCount == 1 && ix.surroundIsPositive && enter == currShapeIsPositive) {\n\
+            entryExitT.x = t;\n\
+        }\n\
+\n\
+        // exiting positive or entering negative after being inside positive\n\
+        // TODO: Can this be simplified?\n\
+        bool exitPositive = !enter && currShapeIsPositive && ix.surroundCount == 0;\n\
+        bool enterNegativeFromPositive = enter && !currShapeIsPositive && ix.surroundCount == 2 && ix.surroundIsPositive;\n\
+        if (exitPositive || enterNegativeFromPositive) {\n\
+            entryExitT.y = t;\n\
+\n\
+            // entry and exit have been found, so the loop can stop\n\
+            if (exitPositive) {\n\
+                // After exiting positive shape there is nothing left to intersect, so jump to the end index.\n\
+                ix.index = passCount;\n\
+            }\n\
+            break;\n\
+        }\n\
+    }\n\
+\n\
+    return entryExitT;\n\
+}\n\
+#endif\n\
+\n\
+// NOTE: initializeIntersections, nextIntersection aren't even declared unless INTERSECTION_COUNT > 1\n\
+// export { NO_HIT, INF_HIT, Ray, Intersections, getIntersectionPair, setIntersectionPair, initializeIntersections, nextIntersection };\n\
+";

package/Source/Shaders/Voxels/Megatexture.glsl

@@ -0,0 +1,136 @@
+// See Octree.glsl for the definitions of SampleData and intMod
+
+/* 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_dimensions; // does not include padding
+#if defined(PADDING)
+    uniform ivec3 u_paddingBefore;
+    uniform ivec3 u_paddingAfter;
+#endif
+
+// 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)
+{
+    int indexX = intMod(index, dimensions.x);
+    int indexY = index / dimensions.x;
+    return vec2(indexX, indexY) * uvScale;
+}
+
+/*
+    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) {
+    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);
+    ivec3 voxelDimensions = u_dimensions;
+
+    #if defined(PADDING)
+        voxelDimensions += u_paddingBefore + u_paddingAfter;
+        voxelCoord += vec3(u_paddingBefore);
+    #endif
+
+    #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, voxelDimensions.z - 1);
+    vec2 sliceUvOffset0 = index1DTo2DTexcoord(sliceIndex0, u_megatextureSliceDimensions, u_megatextureSliceSizeUv);
+
+    // Voxel location
+    vec2 voxelUvOffset = clamp(voxelCoord.xy, vec2(0.5), vec2(voxelDimensions.xy) - vec2(0.5)) * u_megatextureVoxelSizeUv;
+
+    // Final location in the megatexture
+    vec2 uv0 = tileUvOffset + sliceUvOffset0 + voxelUvOffset;
+
+    #if defined(NEAREST_SAMPLING)
+        return getPropertiesFromMegatextureAtUv(uv0);
+    #else
+        float sliceLerp = fract(slice);
+        int sliceIndex1 = intMin(sliceIndex + 1, voxelDimensions.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
+}
+
+// Convert an array of sample datas to a final weighted properties.
+Properties accumulatePropertiesFromMegatexture(in SampleData sampleDatas[SAMPLE_COUNT]) {
+    #if (SAMPLE_COUNT == 1)
+        return getPropertiesFromMegatexture(sampleDatas[0]);
+    #else
+        // When more than one sample is taken the accumulator needs to start at 0
+        Properties properties = clearProperties();
+        for (int i = 0; i < SAMPLE_COUNT; ++i) {
+            float weight = sampleDatas[i].weight;
+
+            // Avoid reading the megatexture when the weight is 0 as it can be costly.
+            if (weight > 0.0) {
+                Properties tempProperties = getPropertiesFromMegatexture(sampleDatas[i]);
+                tempProperties = scaleProperties(tempProperties, weight);
+                properties = sumProperties(properties, tempProperties);
+            }
+        }
+        return properties;
+    #endif
+}

package/Source/Shaders/Voxels/Megatexture.js

@@ -0,0 +1,138 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "// See Octree.glsl for the definitions of SampleData and intMod\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\
+\n\
+uniform ivec3 u_dimensions; // does not include padding\n\
+#if defined(PADDING)\n\
+    uniform ivec3 u_paddingBefore;\n\
+    uniform ivec3 u_paddingAfter;\n\
+#endif\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\
+{\n\
+    int indexX = intMod(index, dimensions.x);\n\
+    int indexY = index / dimensions.x;\n\
+    return vec2(indexX, indexY) * uvScale;\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\
+    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\
+    ivec3 voxelDimensions = u_dimensions;\n\
+\n\
+    #if defined(PADDING)\n\
+        voxelDimensions += u_paddingBefore + u_paddingAfter;\n\
+        voxelCoord += vec3(u_paddingBefore);\n\
+    #endif\n\
+\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, voxelDimensions.z - 1);\n\
+    vec2 sliceUvOffset0 = index1DTo2DTexcoord(sliceIndex0, u_megatextureSliceDimensions, u_megatextureSliceSizeUv);\n\
+\n\
+    // Voxel location\n\
+    vec2 voxelUvOffset = clamp(voxelCoord.xy, vec2(0.5), vec2(voxelDimensions.xy) - vec2(0.5)) * u_megatextureVoxelSizeUv;\n\
+\n\
+    // Final location in the megatexture\n\
+    vec2 uv0 = tileUvOffset + sliceUvOffset0 + voxelUvOffset;\n\
+\n\
+    #if defined(NEAREST_SAMPLING)\n\
+        return getPropertiesFromMegatextureAtUv(uv0);\n\
+    #else\n\
+        float sliceLerp = fract(slice);\n\
+        int sliceIndex1 = intMin(sliceIndex + 1, voxelDimensions.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\
+}\n\
+\n\
+// Convert an array of sample datas to a final weighted properties.\n\
+Properties accumulatePropertiesFromMegatexture(in SampleData sampleDatas[SAMPLE_COUNT]) {\n\
+    #if (SAMPLE_COUNT == 1)\n\
+        return getPropertiesFromMegatexture(sampleDatas[0]);\n\
+    #else\n\
+        // When more than one sample is taken the accumulator needs to start at 0\n\
+        Properties properties = clearProperties();\n\
+        for (int i = 0; i < SAMPLE_COUNT; ++i) {\n\
+            float weight = sampleDatas[i].weight;\n\
+\n\
+            // Avoid reading the megatexture when the weight is 0 as it can be costly.\n\
+            if (weight > 0.0) {\n\
+                Properties tempProperties = getPropertiesFromMegatexture(sampleDatas[i]);\n\
+                tempProperties = scaleProperties(tempProperties, weight);\n\
+                properties = sumProperties(properties, tempProperties);\n\
+            }\n\
+        }\n\
+        return properties;\n\
+    #endif\n\
+}\n\
+";