@cesium/engine 8.0.0 → 9.1.0

package/Source/Shaders/Model/ModelFS.glsl

@@ -1,3 +1,5 @@
+
+precision highp float;
 czm_modelMaterial defaultModelMaterial()
 {
     czm_modelMaterial material;
@@ -75,6 +77,10 @@ void main()
     modelClippingPlanesStage(color);
     #endif
 
+    #ifdef ENABLE_CLIPPING_POLYGONS
+    modelClippingPolygonsStage();
+    #endif
+
     #if defined(HAS_SILHOUETTE) && defined(HAS_NORMALS)
     silhouetteStage(color);
     #endif

package/Source/Shaders/Model/ModelFS.js

@@ -1,5 +1,7 @@
 //This file is automatically rebuilt by the Cesium build process.
-export default "czm_modelMaterial defaultModelMaterial()\n\
+export default "\n\
+precision highp float;\n\
+czm_modelMaterial defaultModelMaterial()\n\
 {\n\
     czm_modelMaterial material;\n\
     material.diffuse = vec3(0.0);\n\
@@ -75,6 +77,10 @@ void main()\n\
     #ifdef HAS_CLIPPING_PLANES\n\
     modelClippingPlanesStage(color);\n\
     #endif\n\
+\n\
+    #ifdef ENABLE_CLIPPING_POLYGONS\n\
+    modelClippingPolygonsStage();\n\
+    #endif\n\
 \n\
     #if defined(HAS_SILHOUETTE) && defined(HAS_NORMALS)\n\
     silhouetteStage(color);\n\

package/Source/Shaders/Model/ModelVS.glsl

@@ -111,6 +111,10 @@ void main()
     atmosphereStage(attributes);
     #endif
 
+    #ifdef ENABLE_CLIPPING_POLYGONS
+    modelClippingPolygonsStage(attributes);
+    #endif
+
     #ifdef HAS_SILHOUETTE
     silhouetteStage(attributes, positionClip);
     #endif

package/Source/Shaders/Model/ModelVS.js

@@ -111,6 +111,10 @@ void main()\n\
     #ifdef HAS_ATMOSPHERE\n\
     atmosphereStage(attributes);\n\
     #endif\n\
+\n\
+    #ifdef ENABLE_CLIPPING_POLYGONS\n\
+    modelClippingPolygonsStage(attributes);\n\
+    #endif\n\
 \n\
     #ifdef HAS_SILHOUETTE\n\
     silhouetteStage(attributes, positionClip);\n\

package/Source/Shaders/PolygonSignedDistanceFS.glsl

@@ -0,0 +1,100 @@
+in vec2 v_textureCoordinates;
+
+uniform int u_polygonsLength;
+uniform int u_extentsLength;
+uniform highp sampler2D u_polygonTexture;
+uniform highp sampler2D u_extentsTexture;
+
+int getPolygonIndex(float dimension, vec2 coord) {
+   vec2 uv = coord.xy * dimension;
+   return int(floor(uv.y) * dimension + floor(uv.x));
+}
+
+vec2 getLookupUv(ivec2 dimensions, int i) {
+    int pixY = i / dimensions.x;
+    int pixX = i - (pixY * dimensions.x);
+    float pixelWidth = 1.0 / float(dimensions.x);
+    float pixelHeight = 1.0 / float(dimensions.y);
+    float u = (float(pixX) + 0.5) * pixelWidth; // sample from center of pixel
+    float v = (float(pixY) + 0.5) * pixelHeight;
+    return vec2(u, v);
+}
+
+vec4 getExtents(int i) {
+    return texture(u_extentsTexture, getLookupUv(textureSize(u_extentsTexture, 0), i));
+}
+
+ivec2 getPositionsLengthAndExtentsIndex(int i) {
+    vec2 uv = getLookupUv(textureSize(u_polygonTexture, 0), i);
+    vec4 value = texture(u_polygonTexture, uv);
+    return ivec2(int(value.x), int(value.y));
+}
+
+vec2 getPolygonPosition(int i) {
+    vec2 uv = getLookupUv(textureSize(u_polygonTexture, 0), i);
+    return texture(u_polygonTexture, uv).xy;
+}
+
+vec2 getCoordinates(vec2 textureCoordinates, vec4 extents) {
+    float latitude = mix(extents.x, extents.x + 1.0 / extents.z, textureCoordinates.y);
+    float longitude = mix(extents.y, extents.y + 1.0 / extents.w, textureCoordinates.x);
+    return vec2(latitude, longitude);
+}
+
+void main() {
+    int lastPolygonIndex = 0;
+    out_FragColor = vec4(1.0);
+
+    // Get the relevant region of the texture
+    float dimension = float(u_extentsLength);
+    if (u_extentsLength > 2) {
+        dimension = ceil(log2(float(u_extentsLength)));
+    }
+    int regionIndex = getPolygonIndex(dimension, v_textureCoordinates);
+
+    for (int polygonIndex = 0; polygonIndex < u_polygonsLength; polygonIndex++) {
+        ivec2 positionsLengthAndExtents = getPositionsLengthAndExtentsIndex(lastPolygonIndex);
+        int positionsLength = positionsLengthAndExtents.x;
+        int polygonExtentsIndex = positionsLengthAndExtents.y;
+        lastPolygonIndex += 1;
+
+         // Only compute signed distance for the relevant part of the atlas
+         if (polygonExtentsIndex == regionIndex) {
+            float clipAmount = czm_infinity;
+            vec4 extents = getExtents(polygonExtentsIndex);
+            vec2 textureOffset = vec2(mod(float(polygonExtentsIndex), dimension), floor(float(polygonExtentsIndex) / dimension)) / dimension;
+            vec2 p = getCoordinates((v_textureCoordinates - textureOffset) * dimension, extents);
+            float s = 1.0;
+
+            // Check each edge for absolute distance
+            for (int i = 0, j = positionsLength - 1; i < positionsLength; j = i, i++) {
+                vec2 a = getPolygonPosition(lastPolygonIndex + i);
+                vec2 b = getPolygonPosition(lastPolygonIndex + j);
+ 
+                vec2 ab = b - a;
+                vec2 pa = p - a;
+                float t = dot(pa, ab) / dot(ab, ab);
+                t = clamp(t, 0.0, 1.0);
+
+                vec2 pq = pa - t * ab;
+                float d = length(pq);
+
+                // Inside / outside computation to determine sign
+                bvec3 cond = bvec3(p.y >= a.y, 
+                            p.y < b.y, 
+                            ab.x * pa.y > ab.y * pa.x);
+                if (all(cond) || all(not(cond))) s = -s;
+                if (abs(d) < abs(clipAmount)) {
+                    clipAmount = d;
+                }
+            }
+
+            // Normalize the range to [0,1]
+            vec4 result = (s * vec4(clipAmount * length(extents.zw))) / 2.0 + 0.5;
+            // In the case where we've iterated through multiple polygons, take the minimum
+            out_FragColor = min(out_FragColor, result);
+         }
+
+        lastPolygonIndex += positionsLength;
+    }
+}

package/Source/Shaders/PolygonSignedDistanceFS.js

@@ -0,0 +1,101 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "in vec2 v_textureCoordinates;\n\
+\n\
+uniform int u_polygonsLength;\n\
+uniform int u_extentsLength;\n\
+uniform highp sampler2D u_polygonTexture;\n\
+uniform highp sampler2D u_extentsTexture;\n\
+\n\
+int getPolygonIndex(float dimension, vec2 coord) {\n\
+   vec2 uv = coord.xy * dimension;\n\
+   return int(floor(uv.y) * dimension + floor(uv.x));\n\
+}\n\
+\n\
+vec2 getLookupUv(ivec2 dimensions, int i) {\n\
+    int pixY = i / dimensions.x;\n\
+    int pixX = i - (pixY * dimensions.x);\n\
+    float pixelWidth = 1.0 / float(dimensions.x);\n\
+    float pixelHeight = 1.0 / float(dimensions.y);\n\
+    float u = (float(pixX) + 0.5) * pixelWidth; // sample from center of pixel\n\
+    float v = (float(pixY) + 0.5) * pixelHeight;\n\
+    return vec2(u, v);\n\
+}\n\
+\n\
+vec4 getExtents(int i) {\n\
+    return texture(u_extentsTexture, getLookupUv(textureSize(u_extentsTexture, 0), i));\n\
+}\n\
+\n\
+ivec2 getPositionsLengthAndExtentsIndex(int i) {\n\
+    vec2 uv = getLookupUv(textureSize(u_polygonTexture, 0), i);\n\
+    vec4 value = texture(u_polygonTexture, uv);\n\
+    return ivec2(int(value.x), int(value.y));\n\
+}\n\
+\n\
+vec2 getPolygonPosition(int i) {\n\
+    vec2 uv = getLookupUv(textureSize(u_polygonTexture, 0), i);\n\
+    return texture(u_polygonTexture, uv).xy;\n\
+}\n\
+\n\
+vec2 getCoordinates(vec2 textureCoordinates, vec4 extents) {\n\
+    float latitude = mix(extents.x, extents.x + 1.0 / extents.z, textureCoordinates.y);\n\
+    float longitude = mix(extents.y, extents.y + 1.0 / extents.w, textureCoordinates.x);\n\
+    return vec2(latitude, longitude);\n\
+}\n\
+\n\
+void main() {\n\
+    int lastPolygonIndex = 0;\n\
+    out_FragColor = vec4(1.0);\n\
+\n\
+    // Get the relevant region of the texture\n\
+    float dimension = float(u_extentsLength);\n\
+    if (u_extentsLength > 2) {\n\
+        dimension = ceil(log2(float(u_extentsLength)));\n\
+    }\n\
+    int regionIndex = getPolygonIndex(dimension, v_textureCoordinates);\n\
+\n\
+    for (int polygonIndex = 0; polygonIndex < u_polygonsLength; polygonIndex++) {\n\
+        ivec2 positionsLengthAndExtents = getPositionsLengthAndExtentsIndex(lastPolygonIndex);\n\
+        int positionsLength = positionsLengthAndExtents.x;\n\
+        int polygonExtentsIndex = positionsLengthAndExtents.y;\n\
+        lastPolygonIndex += 1;\n\
+\n\
+         // Only compute signed distance for the relevant part of the atlas\n\
+         if (polygonExtentsIndex == regionIndex) {\n\
+            float clipAmount = czm_infinity;\n\
+            vec4 extents = getExtents(polygonExtentsIndex);\n\
+            vec2 textureOffset = vec2(mod(float(polygonExtentsIndex), dimension), floor(float(polygonExtentsIndex) / dimension)) / dimension;\n\
+            vec2 p = getCoordinates((v_textureCoordinates - textureOffset) * dimension, extents);\n\
+            float s = 1.0;\n\
+\n\
+            // Check each edge for absolute distance\n\
+            for (int i = 0, j = positionsLength - 1; i < positionsLength; j = i, i++) {\n\
+                vec2 a = getPolygonPosition(lastPolygonIndex + i);\n\
+                vec2 b = getPolygonPosition(lastPolygonIndex + j);\n\
+ \n\
+                vec2 ab = b - a;\n\
+                vec2 pa = p - a;\n\
+                float t = dot(pa, ab) / dot(ab, ab);\n\
+                t = clamp(t, 0.0, 1.0);\n\
+\n\
+                vec2 pq = pa - t * ab;\n\
+                float d = length(pq);\n\
+\n\
+                // Inside / outside computation to determine sign\n\
+                bvec3 cond = bvec3(p.y >= a.y, \n\
+                            p.y < b.y, \n\
+                            ab.x * pa.y > ab.y * pa.x);\n\
+                if (all(cond) || all(not(cond))) s = -s;\n\
+                if (abs(d) < abs(clipAmount)) {\n\
+                    clipAmount = d;\n\
+                }\n\
+            }\n\
+\n\
+            // Normalize the range to [0,1]\n\
+            vec4 result = (s * vec4(clipAmount * length(extents.zw))) / 2.0 + 0.5;\n\
+            // In the case where we've iterated through multiple polygons, take the minimum\n\
+            out_FragColor = min(out_FragColor, result);\n\
+         }\n\
+\n\
+        lastPolygonIndex += positionsLength;\n\
+    }\n\
+}";

package/Source/Shaders/Voxels/IntersectBox.glsl

@@ -1,5 +1,5 @@
-// See IntersectionUtils.glsl for the definitions of Ray and NO_HIT
-// See convertUvToBox.glsl for the definition of convertShapeUvToUvSpace
+// See IntersectionUtils.glsl for the definitions of Ray, RayShapeIntersection,
+// NO_HIT, Intersections
 
 /* Box defines (set in Scene/VoxelBoxShape.js)
 #define BOX_INTERSECTION_INDEX ### // always 0
@@ -8,66 +8,40 @@
 uniform vec3 u_renderMinBounds;
 uniform vec3 u_renderMaxBounds;
 
-struct Box {
-    vec3 p0;
-    vec3 p1;
-};
-
-Box constructVoxelBox(in ivec4 octreeCoords, in vec3 tileUv)
-{
-    // Find the min/max cornerpoints of the voxel in tile coordinates
-    vec3 tileOrigin = vec3(octreeCoords.xyz);
-    vec3 numSamples = vec3(u_dimensions);
-    vec3 voxelSize = 1.0 / numSamples;
-    vec3 coordP0 = floor(tileUv * numSamples) * voxelSize + tileOrigin;
-    vec3 coordP1 = coordP0 + voxelSize;
-
-    // Transform to the UV coordinates of the scaled tileset
-    float tileSize = 1.0 / pow(2.0, float(octreeCoords.w));
-    vec3 p0 = convertShapeUvToUvSpace(coordP0 * tileSize);
-    vec3 p1 = convertShapeUvToUvSpace(coordP1 * tileSize);
-
-    return Box(p0, p1);
-}
-
-vec3 getBoxNormal(in Box box, in Ray ray, in float t)
-{
-    vec3 hitPoint = ray.pos + t * ray.dir;
-    vec3 lower = step(hitPoint, box.p0);
-    vec3 upper = step(box.p1, hitPoint);
-    return normalize(upper - lower);
-}
-
-// Find the distances along a ray at which the ray intersects an axis-aligned box
-// See https://tavianator.com/2011/ray_box.html
-RayShapeIntersection intersectBox(in Ray ray, in Box box)
+RayShapeIntersection intersectBox(in Ray ray, in vec3 minBound, in vec3 maxBound)
 {
     // Consider the box as the intersection of the space between 3 pairs of parallel planes
     // Compute the distance along the ray to each plane
-    vec3 t0 = (box.p0 - ray.pos) * ray.dInv;
-    vec3 t1 = (box.p1 - ray.pos) * ray.dInv;
+    vec3 t0 = (minBound - ray.pos) / ray.dir;
+    vec3 t1 = (maxBound - ray.pos) / ray.dir;
 
     // Identify candidate entries/exits based on distance from ray.pos
     vec3 entries = min(t0, t1);
     vec3 exits = max(t0, t1);
 
-    // The actual box intersection points are the furthest entry and the closest exit
-    float entryT = max(max(entries.x, entries.y), entries.z);
-    float exitT = min(min(exits.x, exits.y), exits.z);
+    vec3 directions = sign(ray.dir);
+
+    // The actual intersection points are the furthest entry and the closest exit
+    float lastEntry = maxComponent(entries);
+    bvec3 isLastEntry = equal(entries, vec3(lastEntry));
+    vec3 entryNormal = -1.0 * vec3(isLastEntry) * directions;
+    vec4 entry = vec4(entryNormal, lastEntry);
 
-    vec3 entryNormal = getBoxNormal(box, ray, entryT - RAY_SHIFT);
-    vec3 exitNormal = getBoxNormal(box, ray, exitT + RAY_SHIFT);
+    float firstExit = minComponent(exits);
+    bvec3 isFirstExit = equal(exits, vec3(firstExit));
+    vec3 exitNormal = vec3(isLastEntry) * directions;
+    vec4 exit = vec4(exitNormal, firstExit);
 
-    if (entryT > exitT) {
-        entryT = NO_HIT;
-        exitT = NO_HIT;
+    if (entry.w > exit.w) {
+        entry.w = NO_HIT;
+        exit.w = NO_HIT;
     }
 
-    return RayShapeIntersection(vec4(entryNormal, entryT), vec4(exitNormal, exitT));
+    return RayShapeIntersection(entry, exit);
 }
 
 void intersectShape(in Ray ray, inout Intersections ix)
 {
-    RayShapeIntersection intersection = intersectBox(ray, Box(u_renderMinBounds, u_renderMaxBounds));
+    RayShapeIntersection intersection = intersectBox(ray, u_renderMinBounds, u_renderMaxBounds);
     setShapeIntersection(ix, BOX_INTERSECTION_INDEX, intersection);
 }

package/Source/Shaders/Voxels/IntersectBox.js

@@ -1,6 +1,6 @@
 //This file is automatically rebuilt by the Cesium build process.
-export default "// See IntersectionUtils.glsl for the definitions of Ray and NO_HIT\n\
-// See convertUvToBox.glsl for the definition of convertShapeUvToUvSpace\n\
+export default "// See IntersectionUtils.glsl for the definitions of Ray, RayShapeIntersection,\n\
+// NO_HIT, Intersections\n\
 \n\
 /* Box defines (set in Scene/VoxelBoxShape.js)\n\
 #define BOX_INTERSECTION_INDEX ### // always 0\n\
@@ -9,67 +9,41 @@ export default "// See IntersectionUtils.glsl for the definitions of Ray and NO_
 uniform vec3 u_renderMinBounds;\n\
 uniform vec3 u_renderMaxBounds;\n\
 \n\
-struct Box {\n\
-    vec3 p0;\n\
-    vec3 p1;\n\
-};\n\
-\n\
-Box constructVoxelBox(in ivec4 octreeCoords, in vec3 tileUv)\n\
-{\n\
-    // Find the min/max cornerpoints of the voxel in tile coordinates\n\
-    vec3 tileOrigin = vec3(octreeCoords.xyz);\n\
-    vec3 numSamples = vec3(u_dimensions);\n\
-    vec3 voxelSize = 1.0 / numSamples;\n\
-    vec3 coordP0 = floor(tileUv * numSamples) * voxelSize + tileOrigin;\n\
-    vec3 coordP1 = coordP0 + voxelSize;\n\
-\n\
-    // Transform to the UV coordinates of the scaled tileset\n\
-    float tileSize = 1.0 / pow(2.0, float(octreeCoords.w));\n\
-    vec3 p0 = convertShapeUvToUvSpace(coordP0 * tileSize);\n\
-    vec3 p1 = convertShapeUvToUvSpace(coordP1 * tileSize);\n\
-\n\
-    return Box(p0, p1);\n\
-}\n\
-\n\
-vec3 getBoxNormal(in Box box, in Ray ray, in float t)\n\
-{\n\
-    vec3 hitPoint = ray.pos + t * ray.dir;\n\
-    vec3 lower = step(hitPoint, box.p0);\n\
-    vec3 upper = step(box.p1, hitPoint);\n\
-    return normalize(upper - lower);\n\
-}\n\
-\n\
-// Find the distances along a ray at which the ray intersects an axis-aligned box\n\
-// See https://tavianator.com/2011/ray_box.html\n\
-RayShapeIntersection intersectBox(in Ray ray, in Box box)\n\
+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 = (box.p0 - ray.pos) * ray.dInv;\n\
-    vec3 t1 = (box.p1 - ray.pos) * ray.dInv;\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\
-    // The actual box intersection points are the furthest entry and the closest exit\n\
-    float entryT = max(max(entries.x, entries.y), entries.z);\n\
-    float exitT = min(min(exits.x, exits.y), exits.z);\n\
+    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\
-    vec3 entryNormal = getBoxNormal(box, ray, entryT - RAY_SHIFT);\n\
-    vec3 exitNormal = getBoxNormal(box, ray, exitT + RAY_SHIFT);\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 (entryT > exitT) {\n\
-        entryT = NO_HIT;\n\
-        exitT = NO_HIT;\n\
+    if (entry.w > exit.w) {\n\
+        entry.w = NO_HIT;\n\
+        exit.w = NO_HIT;\n\
     }\n\
 \n\
-    return RayShapeIntersection(vec4(entryNormal, entryT), vec4(exitNormal, exitT));\n\
+    return RayShapeIntersection(entry, exit);\n\
 }\n\
 \n\
 void intersectShape(in Ray ray, inout Intersections ix)\n\
 {\n\
-    RayShapeIntersection intersection = intersectBox(ray, Box(u_renderMinBounds, u_renderMaxBounds));\n\
+    RayShapeIntersection intersection = intersectBox(ray, u_renderMinBounds, u_renderMaxBounds);\n\
     setShapeIntersection(ix, BOX_INTERSECTION_INDEX, intersection);\n\
 }\n\
 ";

package/Source/Shaders/Voxels/IntersectClippingPlanes.glsl

@@ -1,5 +1,5 @@
 // See IntersectionUtils.glsl for the definitions of Ray, Intersections, INF_HIT,
-// NO_HIT, setIntersectionPair
+// NO_HIT, setShapeIntersection
 
 /* Clipping plane defines (set in Scene/VoxelRenderResources.js)
 #define CLIPPING_PLANES_UNION

package/Source/Shaders/Voxels/IntersectClippingPlanes.js

@@ -1,6 +1,6 @@
 //This file is automatically rebuilt by the Cesium build process.
 export default "// See IntersectionUtils.glsl for the definitions of Ray, Intersections, INF_HIT,\n\
-// NO_HIT, setIntersectionPair\n\
+// NO_HIT, setShapeIntersection\n\
 \n\
 /* Clipping plane defines (set in Scene/VoxelRenderResources.js)\n\
 #define CLIPPING_PLANES_UNION\n\