deeptwins-cesium-engine 0.1.0 → 0.1.2

package/Source/Core/defaultValue.js

@@ -0,0 +1,20 @@
+/**
+ * Returns the first parameter if it is defined, otherwise the second parameter.
+ *
+ * @param {*} a The object.
+ * @param {*} b The default value.
+ * @returns {*} Returns the first parameter if defined, otherwise the second parameter.
+ *
+ * @example
+ * param = Cesium.defaultValue(param, "default");
+ */
+function defaultValue(a, b) {
+  if (a !== undefined && a !== null) {
+    return a;
+  }
+  return b;
+}
+
+defaultValue.EMPTY_OBJECT = Object.freeze({});
+
+export default defaultValue;

package/Source/Shaders/BufferPointMaterialFS.js

@@ -0,0 +1,30 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "in vec4 v_pickColor;\n\
+in vec4 v_color;\n\
+in vec4 v_outlineColor;\n\
+in float v_innerRadiusFrac;\n\
+\n\
+void main()\n\
+{\n\
+    // Distance between fragment and point center, 0 to 0.5.\n\
+    float distanceToCenter = length(gl_PointCoord - vec2(0.5));\n\
+    float delta = fwidth(distanceToCenter);\n\
+\n\
+    float outerLimit = 0.5;\n\
+    float innerLimit = 0.5 * v_innerRadiusFrac;\n\
+\n\
+    float outerAlpha = 1.0 - smoothstep(max(0.0, outerLimit - delta), outerLimit, distanceToCenter);\n\
+    float innerAlpha = 1.0 - smoothstep(innerLimit - delta, innerLimit, distanceToCenter);\n\
+\n\
+    vec4 color = vec4(mix(v_outlineColor.rgb, v_color.rgb, innerAlpha), outerAlpha);\n\
+    color.a *= mix(v_outlineColor.a, v_color.a, innerAlpha);\n\
+\n\
+    if (color.a < 0.005)   // matches 0/255 and 1/255\n\
+    {\n\
+        discard;\n\
+    }\n\
+\n\
+    out_FragColor = czm_gammaCorrect(color);\n\
+    czm_writeLogDepth();\n\
+}\n\
+";

package/Source/Shaders/BufferPointMaterialVS.js

@@ -0,0 +1,60 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "#ifdef USE_FLOAT64\n\
+in vec3 positionHigh;\n\
+in vec3 positionLow;\n\
+#else\n\
+in vec3 position;\n\
+#endif\n\
+in vec4 pickColor;\n\
+in vec4 showPixelSizeColorAlpha;\n\
+in vec3 outlineWidthColorAlpha;\n\
+\n\
+out vec4 v_pickColor;\n\
+out vec4 v_color;\n\
+out vec4 v_outlineColor;\n\
+out float v_innerRadiusFrac;\n\
+\n\
+void main()\n\
+{\n\
+    // Unpack attributes.\n\
+    float show = showPixelSizeColorAlpha.x;\n\
+    float pixelSize = showPixelSizeColorAlpha.y;\n\
+    vec4 color = czm_decodeRGB8(showPixelSizeColorAlpha.z);\n\
+    float alpha = showPixelSizeColorAlpha.w;\n\
+    float outlineWidth = outlineWidthColorAlpha.x;\n\
+    vec4 outlineColor = czm_decodeRGB8(outlineWidthColorAlpha.y);\n\
+    float outlineAlpha = outlineWidthColorAlpha.z;\n\
+\n\
+    ///////////////////////////////////////////////////////////////////////////\n\
+\n\
+    float innerRadius = 0.5 * pixelSize * czm_pixelRatio;\n\
+    float outerRadius = (0.5 * pixelSize + outlineWidth) * czm_pixelRatio;\n\
+\n\
+    ///////////////////////////////////////////////////////////////////////////\n\
+\n\
+#ifdef USE_FLOAT64\n\
+    vec4 p = czm_translateRelativeToEye(positionHigh, positionLow);\n\
+    vec4 positionEC = czm_modelViewRelativeToEye * p;\n\
+#else\n\
+    vec4 positionEC = czm_modelView * vec4(position, 1.0);\n\
+#endif\n\
+\n\
+    ///////////////////////////////////////////////////////////////////////////\n\
+\n\
+    gl_Position = czm_projection * positionEC;\n\
+    czm_vertexLogDepth();\n\
+\n\
+    v_pickColor = pickColor / 255.0;\n\
+\n\
+    v_color = color;\n\
+    v_color.a *= alpha * show;\n\
+\n\
+    v_outlineColor = outlineColor;\n\
+    v_outlineColor.a *= outlineAlpha * show;\n\
+\n\
+    v_innerRadiusFrac = innerRadius / outerRadius;\n\
+\n\
+    gl_PointSize = 2.0 * outerRadius * show;\n\
+    gl_Position *= show;\n\
+}\n\
+";

package/Source/Shaders/BufferPolygonMaterialFS.js

@@ -0,0 +1,15 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "in vec4 v_pickColor;\n\
+in vec4 v_color;\n\
+\n\
+void main()\n\
+{\n\
+    if (v_color.a < 0.005)   // matches 0/255 and 1/255\n\
+    {\n\
+        discard;\n\
+    }\n\
+\n\
+    out_FragColor = czm_gammaCorrect(v_color);\n\
+    czm_writeLogDepth();\n\
+}\n\
+";

package/Source/Shaders/BufferPolygonMaterialVS.js

@@ -0,0 +1,41 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "#ifdef USE_FLOAT64\n\
+in vec3 positionHigh;\n\
+in vec3 positionLow;\n\
+#else\n\
+in vec3 position;\n\
+#endif\n\
+in vec4 pickColor;\n\
+in vec3 showColorAlpha;\n\
+\n\
+out vec4 v_pickColor;\n\
+out vec4 v_color;\n\
+\n\
+void main()\n\
+{\n\
+    float show = showColorAlpha.x;\n\
+    vec4 color = czm_decodeRGB8(showColorAlpha.y);\n\
+    float alpha = showColorAlpha.z;\n\
+\n\
+    ///////////////////////////////////////////////////////////////////////////\n\
+\n\
+#ifdef USE_FLOAT64\n\
+    vec4 p = czm_translateRelativeToEye(positionHigh, positionLow);\n\
+    vec4 positionEC = czm_modelViewRelativeToEye * p;\n\
+#else\n\
+    vec4 positionEC = czm_modelView * vec4(position, 1.0);\n\
+#endif\n\
+\n\
+    ///////////////////////////////////////////////////////////////////////////\n\
+\n\
+    gl_Position = czm_projection * positionEC;\n\
+    czm_vertexLogDepth();\n\
+\n\
+    v_pickColor = pickColor / 255.0;\n\
+\n\
+    v_color = color;\n\
+    v_color.a *= alpha * show;\n\
+\n\
+    gl_Position *= show;\n\
+}\n\
+";

package/Source/Shaders/BufferPolylineMaterialFS.js

@@ -0,0 +1,15 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "in vec4 v_pickColor;\n\
+in vec4 v_color;\n\
+\n\
+void main()\n\
+{\n\
+    if (v_color.a < 0.005)   // matches 0/255 and 1/255\n\
+    {\n\
+        discard;\n\
+    }\n\
+\n\
+    out_FragColor = czm_gammaCorrect(v_color);\n\
+    czm_writeLogDepth();\n\
+}\n\
+";

package/Source/Shaders/BufferPolylineMaterialVS.js

@@ -0,0 +1,65 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "#ifdef USE_FLOAT64\n\
+in vec3 positionHigh;\n\
+in vec3 positionLow;\n\
+in vec3 prevPositionHigh;\n\
+in vec3 prevPositionLow;\n\
+in vec3 nextPositionHigh;\n\
+in vec3 nextPositionLow;\n\
+#else\n\
+in vec3 position;\n\
+in vec3 prevPosition;\n\
+in vec3 nextPosition;\n\
+#endif\n\
+in vec4 pickColor;\n\
+in vec4 showColorWidthAndTexCoord;\n\
+in float alpha;\n\
+\n\
+out vec4 v_pickColor;\n\
+out vec4 v_color;\n\
+out vec2  v_st;\n\
+out float v_width;\n\
+out float v_polylineAngle;\n\
+\n\
+void main()\n\
+{\n\
+    float show = showColorWidthAndTexCoord.x;\n\
+    vec4 color = czm_decodeRGB8(showColorWidthAndTexCoord.y);\n\
+    float width = showColorWidthAndTexCoord.z;\n\
+    float texCoord = showColorWidthAndTexCoord.w;\n\
+\n\
+    ///////////////////////////////////////////////////////////////////////////\n\
+\n\
+    bool usePrevious = texCoord == 1.0;\n\
+    float expandDir = gl_VertexID % 2 == 1 ? 1.0 : -1.0;\n\
+    float polylineAngle;\n\
+\n\
+#ifdef USE_FLOAT64\n\
+    vec4 positionEC = czm_translateRelativeToEye(positionHigh, positionLow);\n\
+    vec4 prevPositionEC = czm_translateRelativeToEye(prevPositionHigh, prevPositionLow);\n\
+    vec4 nextPositionEC = czm_translateRelativeToEye(nextPositionHigh, nextPositionLow);\n\
+    vec4 positionWC = getPolylineWindowCoordinates(positionEC, prevPositionEC, nextPositionEC, expandDir, width, usePrevious, polylineAngle);\n\
+#else\n\
+    vec4 positionEC = czm_modelView * vec4(position, 1.0);\n\
+    vec4 prevPositionEC = czm_modelView * vec4(prevPosition, 1.0);\n\
+    vec4 nextPositionEC = czm_modelView * vec4(nextPosition, 1.0);\n\
+    // Positions are already in eye space; use the EC variant to skip the redundant transform.\n\
+    vec4 positionWC = getPolylineWindowCoordinatesEC(positionEC, prevPositionEC, nextPositionEC, expandDir, width, usePrevious, polylineAngle);\n\
+#endif\n\
+\n\
+    ///////////////////////////////////////////////////////////////////////////\n\
+\n\
+    gl_Position = czm_viewportOrthographic * positionWC * show;\n\
+\n\
+    v_pickColor = pickColor / 255.0;\n\
+\n\
+    v_color = color;\n\
+    v_color.a *= alpha / 255.0 * show;\n\
+\n\
+    v_st.s = texCoord;\n\
+    v_st.t = czm_writeNonPerspective(clamp(expandDir, 0.0, 1.0), gl_Position.w);\n\
+\n\
+    v_width = width;\n\
+    v_polylineAngle = polylineAngle;\n\
+}\n\
+";

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/ConstantLodStageFS.js

@@ -0,0 +1,62 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "#ifdef HAS_CONSTANT_LOD\n\
+\n\
+vec4 constantLodTextureLookup(sampler2D textureSampler, vec3 constantLodParams) {\n\
+    bool atMaxClamp = v_constantLodUvCustom.z >= constantLodParams.y;\n\
+    bool atMinClamp = v_constantLodUvCustom.z <= constantLodParams.x;\n\
+    bool atClampBoundary = atMaxClamp || atMinClamp;\n\
+    \n\
+    float effectiveDistance = atMaxClamp ? constantLodParams.y : \n\
+                              (atMinClamp ? constantLodParams.x : v_constantLodUvCustom.z);\n\
+    \n\
+    float logDepth = log2(effectiveDistance);\n\
+    logDepth = clamp(logDepth, -10.0, 20.0);\n\
+    \n\
+    float f = fract(logDepth);\n\
+    float p = floor(logDepth);\n\
+    \n\
+    if (atClampBoundary) {\n\
+        float clampedP = ceil(logDepth);\n\
+        vec2 tc = v_constantLodUvCustom.xy / pow(2.0, clampedP) * constantLodParams.z;\n\
+        return texture(textureSampler, tc);\n\
+    }\n\
+\n\
+    vec2 tc1 = v_constantLodUvCustom.xy / pow(2.0, p) * constantLodParams.z;\n\
+    vec2 tc2 = v_constantLodUvCustom.xy / pow(2.0, p + 1.0) * constantLodParams.z;\n\
+    return mix(texture(textureSampler, tc1), texture(textureSampler, tc2), f);\n\
+}\n\
+\n\
+vec4 constantLodTextureLookup(sampler2D textureSampler, vec3 constantLodParams, mat3 textureTransform) {\n\
+    bool atMaxClamp = v_constantLodUvCustom.z >= constantLodParams.y;\n\
+    bool atMinClamp = v_constantLodUvCustom.z <= constantLodParams.x;\n\
+    bool atClampBoundary = atMaxClamp || atMinClamp;\n\
+    \n\
+    float effectiveDistance = atMaxClamp ? constantLodParams.y : \n\
+                              (atMinClamp ? constantLodParams.x : v_constantLodUvCustom.z);\n\
+    \n\
+    float logDepth = log2(effectiveDistance);\n\
+    logDepth = clamp(logDepth, -10.0, 20.0);\n\
+    \n\
+    float f = fract(logDepth);\n\
+    float p = floor(logDepth);\n\
+    \n\
+    if (atClampBoundary) {\n\
+        float clampedP = ceil(logDepth);\n\
+        vec2 tc = v_constantLodUvCustom.xy / pow(2.0, clampedP) * constantLodParams.z;\n\
+        // Apply texture transform to the final texture coordinates\n\
+        tc = czm_computeTextureTransform(tc, textureTransform);\n\
+        return texture(textureSampler, tc);\n\
+    }\n\
+\n\
+    vec2 tc1 = v_constantLodUvCustom.xy / pow(2.0, p) * constantLodParams.z;\n\
+    vec2 tc2 = v_constantLodUvCustom.xy / pow(2.0, p + 1.0) * constantLodParams.z;\n\
+    \n\
+    // Apply texture transform to both LOD texture coordinates before mixing\n\
+    tc1 = czm_computeTextureTransform(tc1, textureTransform);\n\
+    tc2 = czm_computeTextureTransform(tc2, textureTransform);\n\
+    \n\
+    return mix(texture(textureSampler, tc1), texture(textureSampler, tc2), f);\n\
+}\n\
+\n\
+#endif\n\
+";

package/Source/Shaders/Model/ConstantLodStageVS.js

@@ -0,0 +1,13 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "#ifdef HAS_CONSTANT_LOD\n\
+// Extract model scale to compensate for minimumPixelSize scaling\n\
+float modelScaleX = length(czm_model[0].xyz);\n\
+float modelScaleY = length(czm_model[1].xyz);\n\
+float modelScaleZ = length(czm_model[2].xyz);\n\
+float modelScale = (modelScaleX + modelScaleY + modelScaleZ) / 3.0;\n\
+\n\
+// Transform model position through ENU but as direction only (w=0) to avoid position-dependent rotation\n\
+vec3 enuDir = (u_constantLodWorldToEnu * czm_model * vec4(v_positionMC, 0.0)).xyz;\n\
+v_constantLodUvCustom.xy = (enuDir.yx + u_constantLodOffset) / modelScale;\n\
+v_constantLodUvCustom.z = u_constantLodDistance / modelScale;\n\
+#endif";

package/Source/Shaders/Model/EdgeDetectionStageFS.js

@@ -0,0 +1,60 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "void edgeDetectionStage(inout vec4 color, inout FeatureIds featureIds) {\n\
+    if (u_isEdgePass) {\n\
+        return;\n\
+    }\n\
+\n\
+    vec2 screenCoord = gl_FragCoord.xy / czm_viewport.zw;\n\
+\n\
+    vec4 edgeColor = texture(czm_edgeColorTexture, screenCoord);\n\
+    vec4 edgeId = texture(czm_edgeIdTexture, screenCoord);\n\
+\n\
+    // Packed window-space depth from edge pass (0..1)\n\
+    float edgeDepthWin = czm_unpackDepth(texture(czm_edgeDepthTexture, screenCoord));\n\
+\n\
+    // Near / far for current frustum\n\
+    float n = czm_currentFrustum.x;\n\
+    float f = czm_currentFrustum.y;\n\
+\n\
+    // geometry depth in eye coordinate\n\
+    vec4 geomEC = czm_windowToEyeCoordinates(gl_FragCoord);\n\
+    float geomDepthLinear = -geomEC.z;\n\
+\n\
+    // Convert edge depth to linear depth\n\
+    float z_ndc_edge = edgeDepthWin * 2.0 - 1.0;\n\
+    float edgeDepthLinear = (2.0 * n * f) / (f + n - z_ndc_edge * (f - n));\n\
+\n\
+    float d = abs(edgeDepthLinear - geomDepthLinear);\n\
+\n\
+    // Adaptive epsilon using linear depth fwidth for robustness\n\
+    float pixelStepLinear = fwidth(geomDepthLinear);\n\
+    float rel = geomDepthLinear * 0.0005;\n\
+    float eps = max(n * 1e-4, max(pixelStepLinear * 1.5, rel));\n\
+\n\
+    // If Edge isn't behind any geometry and the pixel has edge data\n\
+    if (d < eps && edgeId.r > 0.0) {\n\
+#ifdef HAS_EDGE_FEATURE_ID\n\
+        float edgeFeatureId    = edgeId.g;\n\
+        float currentFeatureId = float(featureIds.featureId_0);\n\
+#endif\n\
+        float globeDepth = czm_unpackDepth(texture(czm_globeDepthTexture, screenCoord));\n\
+        // Background / sky / globe: always show edge\n\
+        bool isBackground = geomDepthLinear > globeDepth;\n\
+        bool drawEdge = isBackground;\n\
+\n\
+#ifdef HAS_EDGE_FEATURE_ID\n\
+        bool hasEdgeFeature = edgeFeatureId > 0.0;\n\
+        bool hasCurrentFeature = currentFeatureId > 0.0;\n\
+        bool featuresMatch = edgeFeatureId == currentFeatureId;\n\
+\n\
+        drawEdge = drawEdge || !hasEdgeFeature || !hasCurrentFeature || featuresMatch;\n\
+#else\n\
+        drawEdge = true;\n\
+#endif\n\
+\n\
+        if (drawEdge) {\n\
+            color = edgeColor;\n\
+        }\n\
+    }\n\
+}\n\
+";

package/Source/Shaders/Model/EdgeVisibilityStageFS.js

@@ -0,0 +1,70 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "// CESIUM_REDIRECTED_COLOR_OUTPUT flag is used to avoid color attachment conflicts\n\
+// when shaders are processed by different rendering pipelines (e.g., OIT).\n\
+// Only declare MRT outputs when not in a derived shader context.\n\
+#if defined(HAS_EDGE_VISIBILITY_MRT) && !defined(CESIUM_REDIRECTED_COLOR_OUTPUT)\n\
+layout(location = 1) out vec4 out_id;        // edge id / metadata\n\
+layout(location = 2) out vec4 out_edgeDepth; // packed depth\n\
+#endif\n\
+\n\
+void edgeVisibilityStage(inout vec4 color, inout FeatureIds featureIds)\n\
+{\n\
+#ifdef HAS_EDGE_VISIBILITY\n\
+\n\
+    if (!u_isEdgePass) {\n\
+        return;\n\
+    }\n\
+ \n\
+    float edgeTypeInt = v_edgeType * 255.0;\n\
+\n\
+    if (edgeTypeInt < 0.5) {\n\
+        discard;\n\
+    }\n\
+\n\
+    if (edgeTypeInt > 0.5 && edgeTypeInt < 1.5) { // silhouette candidate\n\
+        // Silhouette check done in vertex shader\n\
+        // v_shouldDiscard will be > 0.5 if this edge should be discarded\n\
+        if (v_shouldDiscard > 0.5) {\n\
+            discard;\n\
+        }\n\
+    }\n\
+\n\
+    vec4 finalColor = color;\n\
+#ifdef HAS_EDGE_COLOR_ATTRIBUTE\n\
+    if (v_edgeColor.a >= 0.0) {\n\
+        finalColor = v_edgeColor;\n\
+    }\n\
+#endif\n\
+\n\
+#ifdef HAS_LINE_PATTERN\n\
+    // Pattern is 16-bit, each bit represents visibility at that position\n\
+    const float maskLength = 16.0;\n\
+    \n\
+    // Get the relative position within the dash from 0 to 1\n\
+    float dashPosition = fract(v_lineCoord / maskLength);\n\
+    // Figure out the mask index\n\
+    float maskIndex = floor(dashPosition * maskLength);\n\
+    // Test the bit mask\n\
+    float maskTest = floor(u_linePattern / pow(2.0, maskIndex));\n\
+    \n\
+    // If bit is 0 (gap), discard the fragment (use < 1.0 for better numerical stability)\n\
+    if (mod(maskTest, 2.0) < 1.0) {\n\
+        discard;\n\
+    }\n\
+#endif\n\
+    color = finalColor;\n\
+    \n\
+    #if defined(HAS_EDGE_VISIBILITY_MRT) && !defined(CESIUM_REDIRECTED_COLOR_OUTPUT)\n\
+        // Write edge metadata\n\
+        out_id = vec4(0.0);\n\
+        out_id.r = edgeTypeInt;                    // Edge type (0-3)\n\
+#ifdef HAS_EDGE_FEATURE_ID\n\
+        out_id.g = float(featureIds.featureId_0); // Feature ID if available\n\
+#else\n\
+        out_id.g = 0.0;\n\
+#endif\n\
+        // Pack depth into separate MRT attachment\n\
+        out_edgeDepth = czm_packDepth(gl_FragCoord.z);\n\
+    #endif\n\
+#endif\n\
+}";

package/Source/Shaders/Model/EdgeVisibilityStageVS.js

@@ -0,0 +1,99 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "#ifdef HAS_EDGE_VISIBILITY\n\
+void edgeVisibilityStageVS() {\n\
+    if (!u_isEdgePass) {\n\
+        return;\n\
+    }\n\
+\n\
+    v_edgeType = a_edgeType;\n\
+    v_faceNormalAView = czm_normal * a_faceNormalA;\n\
+    v_faceNormalBView = czm_normal * a_faceNormalB;\n\
+    v_edgeOffset = a_edgeOffset;\n\
+\n\
+    // Silhouette detection: check both endpoints of the edge\n\
+    v_shouldDiscard = 0.0;\n\
+    float edgeTypeInt = a_edgeType * 255.0;\n\
+    if (edgeTypeInt > 0.5 && edgeTypeInt < 1.5) {\n\
+        vec3 normalA = normalize(v_faceNormalAView);\n\
+        vec3 normalB = normalize(v_faceNormalBView);\n\
+        const float perpTol = 2.5e-4;\n\
+\n\
+        // Check at current vertex (first endpoint)\n\
+        vec4 currentPosEC = czm_modelView * vec4(v_positionMC, 1.0);\n\
+        vec3 toEye1 = normalize(-currentPosEC.xyz);\n\
+        float dotA1 = dot(normalA, toEye1);\n\
+        float dotB1 = dot(normalB, toEye1);\n\
+\n\
+        // Check at other vertex (second endpoint)\n\
+        vec4 otherPosEC = czm_modelView * vec4(a_edgeOtherPos, 1.0);\n\
+        vec3 toEye2 = normalize(-otherPosEC.xyz);\n\
+        float dotA2 = dot(normalA, toEye2);\n\
+        float dotB2 = dot(normalB, toEye2);\n\
+\n\
+        // Discard if EITHER endpoint is non-silhouette\n\
+        if (dotA1 * dotB1 > perpTol || dotA2 * dotB2 > perpTol) {\n\
+            v_shouldDiscard = 1.0;\n\
+        }\n\
+    }\n\
+\n\
+#ifdef HAS_EDGE_FEATURE_ID\n\
+    v_featureId_0 = a_edgeFeatureId;\n\
+#endif\n\
+\n\
+#ifdef HAS_EDGE_COLOR_ATTRIBUTE\n\
+    v_edgeColor = a_edgeColor;\n\
+#endif\n\
+\n\
+#ifdef HAS_LINE_PATTERN\n\
+    #ifdef HAS_EDGE_CUMULATIVE_DISTANCE\n\
+    v_lineCoord = a_edgeCumulativeDistance * u_pixelsPerWorld;\n\
+    #else\n\
+    vec4 currentClip = czm_modelViewProjection * vec4(v_positionMC, 1.0);\n\
+    vec2 currentScreen = ((currentClip.xy / currentClip.w) * 0.5 + 0.5) * czm_viewport.zw;\n\
+\n\
+    vec4 otherClip = czm_modelViewProjection * vec4(a_edgeOtherPos, 1.0);\n\
+    vec2 otherScreen = ((otherClip.xy / otherClip.w) * 0.5 + 0.5) * czm_viewport.zw;\n\
+    vec2 windowDir = otherScreen - currentScreen;\n\
+\n\
+    const float textureCoordinateBase = 8192.0;\n\
+    if (abs(windowDir.x) > abs(windowDir.y)) {\n\
+        v_lineCoord = textureCoordinateBase + currentScreen.x;\n\
+    } else {\n\
+        v_lineCoord = textureCoordinateBase + currentScreen.y;\n\
+    }\n\
+    #endif\n\
+#endif\n\
+\n\
+    // Expand vertex to form quad\n\
+    vec4 posClip = gl_Position;\n\
+\n\
+    if (length(a_edgeOtherPos) > 0.0 && abs(a_edgeOffset) > 0.0) {\n\
+        vec4 currentClip = posClip;\n\
+        vec4 otherClip = czm_modelViewProjection * vec4(a_edgeOtherPos, 1.0);\n\
+\n\
+        vec2 currentNDC = currentClip.xy / currentClip.w;\n\
+        vec2 otherNDC = otherClip.xy / otherClip.w;\n\
+\n\
+        vec2 edgeDirNDC = otherNDC - currentNDC;\n\
+\n\
+        // Ensure consistent edge direction\n\
+        if (edgeDirNDC.x < 0.0 || (abs(edgeDirNDC.x) < 0.001 && edgeDirNDC.y < 0.0)) {\n\
+            edgeDirNDC = -edgeDirNDC;\n\
+        }\n\
+\n\
+        edgeDirNDC = normalize(edgeDirNDC);\n\
+        vec2 perpNDC = vec2(-edgeDirNDC.y, edgeDirNDC.x);\n\
+\n\
+        // Convert line width from pixels to clip space\n\
+        float lineWidthPixels = u_lineWidth;\n\
+        vec2 viewportSize = czm_viewport.zw;\n\
+        vec2 clipPerPixel = (2.0 / viewportSize) * currentClip.w;\n\
+        vec2 offsetClip = perpNDC * lineWidthPixels * clipPerPixel * 0.5 * a_edgeOffset;\n\
+\n\
+        posClip.xy += offsetClip;\n\
+    }\n\
+\n\
+    gl_Position = posClip;\n\
+}\n\
+#endif\n\
+";

package/Source/Shaders/PrimitiveGaussianSplatFS.js

@@ -0,0 +1,20 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "//\n\
+// Fragment shader for Gaussian splats.\n\
+// Renders a Gaussian splat within a quad, discarding fragments outside the unit circle.\n\
+// Applies an approximate Gaussian falloff based on distance from the center and outputs\n\
+// a color modulated by the alpha and Gaussian weight.\n\
+//\n\
+void main() {\n\
+    if (v_splitDirection < 0.0 && gl_FragCoord.x > czm_splitPosition) discard;\n\
+    if (v_splitDirection > 0.0 && gl_FragCoord.x < czm_splitPosition) discard;\n\
+\n\
+    float A = -dot(v_vertPos, v_vertPos);\n\
+    if (A < -4.) {\n\
+        discard;\n\
+    }\n\
+\n\
+    float B = exp(A * 4.) * v_splatColor.a ;\n\
+    out_FragColor = vec4(v_splatColor.rgb * B , B);\n\
+}\n\
+";

package/Source/Shaders/PrimitiveGaussianSplatVS.js

@@ -0,0 +1,197 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "//\n\
+// Vertex shader for Gaussian splats.\n\
+\n\
+// The splats are rendered as quads in view space. Splat attributes are loaded from a texture with precomputed 3D covariance.\n\
+\n\
+// Passes local quad coordinates and color to the fragment shader for Gaussian evaluation. \n\
+//\n\
+// Discards splats outside the view frustum or with negligible screen size.\n\
+//\n\
+#if defined(HAS_SPHERICAL_HARMONICS)\n\
+const uint coefficientCount[3] = uint[3](3u,8u,15u);\n\
+const float SH_C1 = 0.48860251;\n\
+const float SH_C2[5] = float[5](\n\
+         1.092548430,\n\
+        -1.09254843,\n\
+        0.315391565,\n\
+        -1.09254843,\n\
+        0.546274215\n\
+);\n\
+\n\
+const float SH_C3[7] = float[7](\n\
+         -0.59004358,\n\
+        2.890611442,\n\
+        -0.45704579,\n\
+        0.373176332,\n\
+        -0.45704579,\n\
+        1.445305721,\n\
+        -0.59004358\n\
+);\n\
+\n\
+//Retrieve SH coefficient. Currently RG32UI format\n\
+uvec2 loadSHCoeff(uint splatID, int index) {\n\
+    ivec2 shTexSize = textureSize(u_sphericalHarmonicsTexture, 0);\n\
+    uint dims = coefficientCount[uint(u_sphericalHarmonicsDegree)-1u];\n\
+    uint splatsPerRow = uint(shTexSize.x) / dims;\n\
+    uint shIndex = (splatID%splatsPerRow) * dims + uint(index);\n\
+    ivec2 shPosCoord = ivec2(shIndex, splatID / splatsPerRow);\n\
+    return texelFetch(u_sphericalHarmonicsTexture, shPosCoord, 0).rg;\n\
+}\n\
+\n\
+//Unpack RG32UI half float coefficients to vec3\n\
+vec3 halfToVec3(uvec2 packed) {\n\
+    return vec3(unpackHalf2x16(packed.x), unpackHalf2x16(packed.y).x);\n\
+}\n\
+\n\
+vec3 loadAndExpandSHCoeff(uint splatID, int index) {\n\
+    uvec2 coeff = loadSHCoeff(splatID, index);\n\
+    return halfToVec3(coeff);\n\
+}\n\
+\n\
+vec3 evaluateSH(uint splatID, vec3 viewDir) {\n\
+    vec3 result = vec3(0.0);\n\
+    int coeffIndex = 0;\n\
+    float x = viewDir.x, y = viewDir.y, z = viewDir.z;\n\
+\n\
+    if (u_sphericalHarmonicsDegree >= 1.) {\n\
+        vec3 sh1 = loadAndExpandSHCoeff(splatID, coeffIndex++);\n\
+        vec3 sh2 = loadAndExpandSHCoeff(splatID, coeffIndex++);\n\
+        vec3 sh3 = loadAndExpandSHCoeff(splatID, coeffIndex++);\n\
+        result += -SH_C1 * y * sh1 + SH_C1 * z * sh2 - SH_C1 * x * sh3;\n\
+\n\
+        if (u_sphericalHarmonicsDegree >= 2.) {\n\
+            float xx = x * x;\n\
+            float yy = y * y;\n\
+            float zz = z * z;\n\
+            float xy = x * y;\n\
+            float yz = y * z;\n\
+            float xz = x * z;\n\
+\n\
+            vec3 sh4 = loadAndExpandSHCoeff(splatID, coeffIndex++);\n\
+            vec3 sh5 = loadAndExpandSHCoeff(splatID, coeffIndex++);\n\
+            vec3 sh6 = loadAndExpandSHCoeff(splatID, coeffIndex++);\n\
+            vec3 sh7 = loadAndExpandSHCoeff(splatID, coeffIndex++);\n\
+            vec3 sh8 = loadAndExpandSHCoeff(splatID, coeffIndex++);\n\
+            result += SH_C2[0] * xy * sh4 +\n\
+                    SH_C2[1] * yz * sh5 +\n\
+                    SH_C2[2] * (2.0f * zz - xx - yy) * sh6 +\n\
+                    SH_C2[3] * xz * sh7 +\n\
+                    SH_C2[4] * (xx - yy) * sh8;\n\
+\n\
+            if (u_sphericalHarmonicsDegree >= 3.) {\n\
+                vec3 sh9 = loadAndExpandSHCoeff(splatID, coeffIndex++);\n\
+                vec3 sh10 = loadAndExpandSHCoeff(splatID, coeffIndex++);\n\
+                vec3 sh11 = loadAndExpandSHCoeff(splatID, coeffIndex++);\n\
+                vec3 sh12 = loadAndExpandSHCoeff(splatID, coeffIndex++);\n\
+                vec3 sh13 = loadAndExpandSHCoeff(splatID, coeffIndex++);\n\
+                vec3 sh14 = loadAndExpandSHCoeff(splatID, coeffIndex++);\n\
+                vec3 sh15 = loadAndExpandSHCoeff(splatID, coeffIndex++);\n\
+                result += SH_C3[0] * y * (3.0f * xx - yy) * sh9 +\n\
+                        SH_C3[1] * xy * z * sh10 +\n\
+                        SH_C3[2] * y * (4.0f * zz - xx - yy) * sh11 +\n\
+                        SH_C3[3] * z * (2.0f * zz - 3.0f * xx - 3.0f * yy) * sh12 +\n\
+                        SH_C3[4] * x * (4.0f * zz - xx - yy) * sh13 +\n\
+                        SH_C3[5] * z * (xx - yy) * sh14 +\n\
+                        SH_C3[6] * x * (xx - 3.0f * yy) * sh15;\n\
+            }\n\
+        }\n\
+    }\n\
+    return result;\n\
+}\n\
+#endif\n\
+\n\
+// Transforms and projects splat covariance into screen space and extracts the major and minor axes of the Gaussian ellipsoid\n\
+// which is used to calculate the vertex position in clip space.\n\
+vec4 calcCovVectors(vec3 viewPos, mat3 Vrk) {\n\
+    vec4 t = vec4(viewPos, 1.0);\n\
+    vec2 focal = vec2(czm_projection[0][0] * czm_viewport.z, czm_projection[1][1] * czm_viewport.w);\n\
+\n\
+    vec2 J1 = focal / t.z;\n\
+    vec2 J2 = -focal * vec2(t.x, t.y) / (t.z * t.z);\n\
+    mat3 J = mat3(\n\
+        J1.x, 0.0, J2.x,\n\
+        0.0, J1.y, J2.y,\n\
+        0.0, 0.0, 0.0\n\
+    );\n\
+\n\
+    mat3 R = mat3(czm_modelView);\n\
+\n\
+    //transform our covariance into view space\n\
+    //ensures orientation is correct\n\
+    mat3 Vrk_view = R * Vrk * transpose(R);\n\
+    mat3 cov = transpose(J) * Vrk_view * J;\n\
+\n\
+    float diagonal1 = cov[0][0] + .3;\n\
+    float offDiagonal = cov[0][1];\n\
+    float diagonal2 = cov[1][1] + .3;\n\
+\n\
+    float mid = 0.5 * (diagonal1 + diagonal2);\n\
+    float radius = length(vec2((diagonal1 - diagonal2) * 0.5, offDiagonal));\n\
+    float lambda1 = mid + radius;\n\
+    float lambda2 = max(mid - radius, 0.1);\n\
+\n\
+    vec2 diagonalVector = normalize(vec2(offDiagonal, lambda1 - diagonal1));\n\
+\n\
+    return vec4(\n\
+        min(sqrt(2.0 * lambda1), 1024.0) * diagonalVector,\n\
+        min(sqrt(2.0 * lambda2), 1024.0) * vec2(diagonalVector.y, -diagonalVector.x)\n\
+    );\n\
+}\n\
+\n\
+highp vec4 discardVec = vec4(0.0, 0.0, 2.0, 1.0);\n\
+\n\
+void main() {\n\
+    uint texIdx = uint(a_splatIndex);\n\
+    // u_splatRowMask and u_splatRowShift encode the row width of the splat\n\
+    // attribute texture. The texture width is always maximumTextureSize, which\n\
+    // varies by GPU, so these are passed as uniforms rather than constants.\n\
+    //   rowMask  = maximumTextureSize/2 - 1\n\
+    //   rowShift = log2(maximumTextureSize/2)\n\
+    uint rowMask = uint(u_splatRowMask);\n\
+    uint rowShift = uint(u_splatRowShift);\n\
+    ivec2 posCoord = ivec2(int((texIdx & rowMask) << 1), int(texIdx >> rowShift));\n\
+    vec4 splatPosition = vec4( uintBitsToFloat(uvec4(texelFetch(u_splatAttributeTexture, posCoord, 0))) );\n\
+\n\
+    vec4 splatViewPos = czm_modelView * vec4(splatPosition.xyz, 1.0);\n\
+    vec4 clipPosition = czm_projection * splatViewPos;\n\
+\n\
+    float clip = 1.2 * clipPosition.w;\n\
+    if (clipPosition.z < -clip || clipPosition.x < -clip || clipPosition.x > clip ||\n\
+        clipPosition.y < -clip || clipPosition.y > clip) {\n\
+        gl_Position = vec4(0.0, 0.0, 2.0, 1.0);\n\
+        return;\n\
+    }\n\
+\n\
+    ivec2 covCoord = ivec2(int(((texIdx & rowMask) << 1) | 1u), int(texIdx >> rowShift));\n\
+    uvec4 covariance = uvec4(texelFetch(u_splatAttributeTexture, covCoord, 0));\n\
+\n\
+    gl_Position = clipPosition;\n\
+\n\
+    vec2 u1 = unpackHalf2x16(covariance.x) ;\n\
+    vec2 u2 = unpackHalf2x16(covariance.y);\n\
+    vec2 u3 = unpackHalf2x16(covariance.z);\n\
+    mat3 Vrk = mat3(u1.x, u1.y, u2.x, u1.y, u2.y, u3.x, u2.x, u3.x, u3.y);\n\
+\n\
+    vec4 covVectors = calcCovVectors(splatViewPos.xyz, Vrk);\n\
+\n\
+    if (dot(covVectors.xy, covVectors.xy) < 4.0 && dot(covVectors.zw, covVectors.zw) < 4.0) {\n\
+        gl_Position = discardVec;\n\
+        return;\n\
+    }\n\
+\n\
+    vec2 corner = vec2((gl_VertexID << 1) & 2, gl_VertexID & 2) - 1.;\n\
+\n\
+    gl_Position += vec4((corner.x * covVectors.xy + corner.y * covVectors.zw) / czm_viewport.zw * gl_Position.w, 0, 0);\n\
+    gl_Position.z = clamp(gl_Position.z, -abs(gl_Position.w), abs(gl_Position.w));\n\
+\n\
+    v_vertPos = corner ;\n\
+    v_splatColor = vec4(covariance.w & 0xffu, (covariance.w >> 8) & 0xffu, (covariance.w >> 16) & 0xffu, (covariance.w >> 24) & 0xffu) / 255.0;\n\
+#if defined(HAS_SPHERICAL_HARMONICS)\n\
+    vec4 splatWC = czm_inverseView * splatViewPos;\n\
+    vec3 viewDirModel = normalize(u_inverseModelRotation * (splatWC.xyz - u_cameraPositionWC.xyz));\n\
+\n\
+    v_splatColor.rgb += evaluateSH(texIdx, viewDirModel).rgb;\n\
+#endif\n\
+    v_splitDirection = u_splitDirection;\n\
+}";

package/Source/Shaders/Voxels/IntersectPlane.js

@@ -0,0 +1,82 @@
+//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, setShapeIntersection\n\
+\n\
+/* Clipping plane defines (set in Scene/VoxelRenderResources.js)\n\
+#define CLIPPING_PLANES_UNION\n\
+#define CLIPPING_PLANES_COUNT\n\
+#define CLIPPING_PLANES_INTERSECTION_INDEX\n\
+*/\n\
+\n\
+uniform sampler2D u_clippingPlanesTexture;\n\
+uniform mat4 u_clippingPlanesMatrix;\n\
+\n\
+// Plane is in Hessian Normal Form\n\
+vec4 intersectPlane(in Ray ray, in vec4 plane) {\n\
+    vec3 n = plane.xyz; // normal\n\
+    float w = plane.w; // -dot(pointOnPlane, normal)\n\
+\n\
+    float a = dot(ray.pos, n);\n\
+    float b = dot(ray.dir, n);\n\
+    float t = -(w + a) / b;\n\
+\n\
+    return vec4(n, t);\n\
+}\n\
+\n\
+#ifdef CLIPPING_PLANES\n\
+void intersectClippingPlanes(in Ray ray, inout Intersections ix) {\n\
+    vec4 backSide = vec4(-ray.dir, -INF_HIT);\n\
+    vec4 farSide = vec4(ray.dir, +INF_HIT);\n\
+    RayShapeIntersection clippingVolume;\n\
+\n\
+    #if (CLIPPING_PLANES_COUNT == 1)\n\
+        // Union and intersection are the same when there's one clipping plane, and the code\n\
+        // is more simplified.\n\
+        vec4 planeUv = getClippingPlane(u_clippingPlanesTexture, 0);\n\
+        vec4 intersection = intersectPlane(ray, planeUv);\n\
+        bool reflects = dot(ray.dir, intersection.xyz) < 0.0;\n\
+        clippingVolume.entry = reflects ? backSide : intersection;\n\
+        clippingVolume.exit = reflects ? intersection : farSide;\n\
+        setShapeIntersection(ix, CLIPPING_PLANES_INTERSECTION_INDEX, clippingVolume);\n\
+    #elif defined(CLIPPING_PLANES_UNION)\n\
+        vec4 firstTransmission = vec4(ray.dir, +INF_HIT);\n\
+        vec4 lastReflection = vec4(-ray.dir, -INF_HIT);\n\
+        for (int i = 0; i < CLIPPING_PLANES_COUNT; i++) {\n\
+            vec4 planeUv = getClippingPlane(u_clippingPlanesTexture, i);\n\
+            vec4 intersection = intersectPlane(ray, planeUv);\n\
+            if (dot(ray.dir, planeUv.xyz) > 0.0) {\n\
+                firstTransmission = intersection.w <= firstTransmission.w ? intersection : firstTransmission;\n\
+            } else {\n\
+                lastReflection = intersection.w >= lastReflection.w ? intersection : lastReflection;\n\
+            }\n\
+        }\n\
+        clippingVolume.entry = backSide;\n\
+        clippingVolume.exit = lastReflection;\n\
+        setShapeIntersection(ix, CLIPPING_PLANES_INTERSECTION_INDEX + 0, clippingVolume);\n\
+        clippingVolume.entry = firstTransmission;\n\
+        clippingVolume.exit = farSide;\n\
+        setShapeIntersection(ix, CLIPPING_PLANES_INTERSECTION_INDEX + 1, clippingVolume);\n\
+    #else // intersection\n\
+        vec4 lastTransmission = vec4(ray.dir, -INF_HIT);\n\
+        vec4 firstReflection = vec4(-ray.dir, +INF_HIT);\n\
+        for (int i = 0; i < CLIPPING_PLANES_COUNT; i++) {\n\
+            vec4 planeUv = getClippingPlane(u_clippingPlanesTexture, i);\n\
+            vec4 intersection = intersectPlane(ray, planeUv);\n\
+            if (dot(ray.dir, planeUv.xyz) > 0.0) {\n\
+                lastTransmission = intersection.w > lastTransmission.w ? intersection : lastTransmission;\n\
+            } else {\n\
+                firstReflection = intersection.w < firstReflection.w ? intersection: firstReflection;\n\
+            }\n\
+        }\n\
+        if (lastTransmission.w < firstReflection.w) {\n\
+            clippingVolume.entry = lastTransmission;\n\
+            clippingVolume.exit = firstReflection;\n\
+        } else {\n\
+            clippingVolume.entry = vec4(-ray.dir, NO_HIT);\n\
+            clippingVolume.exit = vec4(ray.dir, NO_HIT);\n\
+        }\n\
+        setShapeIntersection(ix, CLIPPING_PLANES_INTERSECTION_INDEX, clippingVolume);\n\
+    #endif\n\
+}\n\
+#endif\n\
+";

package/Source/Shaders/Voxels/convertLocalToBoxUv.js

@@ -0,0 +1,31 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "uniform vec3 u_boxLocalToShapeUvScale;\n\
+\n\
+uniform ivec4 u_cameraTileCoordinates;\n\
+uniform vec3 u_cameraTileUv;\n\
+uniform mat3 u_boxEcToXyz;\n\
+\n\
+mat3 convertLocalToShapeSpaceDerivative(in vec3 positionLocal) {\n\
+    // For BOX, local space = shape space, so the Jacobian is the identity matrix.\n\
+    return mat3(1.0);\n\
+}\n\
+\n\
+vec3 scaleShapeUvToShapeSpace(in vec3 shapeUv) {\n\
+    return shapeUv / u_boxLocalToShapeUvScale;\n\
+}\n\
+\n\
+vec3 convertEcToDeltaTile(in vec3 positionEC) {\n\
+    vec3 dPosition = u_boxEcToXyz * positionEC;\n\
+    return u_boxLocalToShapeUvScale * dPosition * float(1 << u_cameraTileCoordinates.w);\n\
+}\n\
+\n\
+TileAndUvCoordinate getTileAndUvCoordinate(in vec3 positionEC) {\n\
+    vec3 deltaTileCoordinate = convertEcToDeltaTile(positionEC);\n\
+    vec3 tileUvSum = u_cameraTileUv + deltaTileCoordinate;\n\
+    ivec3 tileCoordinate = u_cameraTileCoordinates.xyz + ivec3(floor(tileUvSum));\n\
+    tileCoordinate = min(max(ivec3(0), tileCoordinate), ivec3((1 << u_cameraTileCoordinates.w) - 1));\n\
+    ivec3 tileCoordinateChange = tileCoordinate - u_cameraTileCoordinates.xyz;\n\
+    vec3 tileUv = clamp(tileUvSum - vec3(tileCoordinateChange), 0.0, 1.0);\n\
+    return TileAndUvCoordinate(ivec4(tileCoordinate, u_cameraTileCoordinates.w), tileUv);\n\
+}\n\
+";

package/Source/Shaders/Voxels/convertLocalToCylinderUv.js

@@ -0,0 +1,97 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "uniform vec3 u_cylinderLocalToShapeUvScale; // x = radius scale, y = angle scale, z = height scale\n\
+uniform float u_cylinderShapeUvAngleRangeOrigin;\n\
+uniform mat3 u_cylinderEcToRadialTangentUp;\n\
+uniform ivec4 u_cameraTileCoordinates;\n\
+uniform vec3 u_cameraTileUv;\n\
+uniform vec3 u_cameraShapePosition; // (radial distance, angle, height) of camera in shape space\n\
+\n\
+mat3 convertLocalToShapeSpaceDerivative(in vec3 position) {\n\
+    vec3 radial = normalize(vec3(position.xy, 0.0));\n\
+    vec3 z = vec3(0.0, 0.0, 1.0);\n\
+    vec3 east = normalize(vec3(-position.y, position.x, 0.0));\n\
+    return mat3(radial, east / length(position.xy), z);\n\
+}\n\
+\n\
+vec3 scaleShapeUvToShapeSpace(in vec3 shapeUv) {\n\
+    float radius = shapeUv.x / u_cylinderLocalToShapeUvScale.x;\n\
+    float angle = shapeUv.y * czm_twoPi / u_cylinderLocalToShapeUvScale.y;\n\
+    float height = shapeUv.z / u_cylinderLocalToShapeUvScale.z;\n\
+\n\
+    return vec3(radius, angle, height);\n\
+}\n\
+\n\
+/**\n\
+ * Computes the change in polar coordinates given a change in position.\n\
+ * @param {vec2} dPosition The change in position in Cartesian coordinates.\n\
+ * @param {float} cameraRadialDistance The radial distance of the camera from the origin.\n\
+ * @return {vec2} The change in polar coordinates (radial distance, angle).\n\
+ */\n\
+vec2 computePolarChange(in vec2 dPosition, in float cameraRadialDistance) {\n\
+    float dAngle = atan(dPosition.y, cameraRadialDistance + dPosition.x);\n\
+    // Find the direction of the radial axis at the output angle, in Cartesian coordinates\n\
+    vec2 outputRadialAxis = vec2(cos(dAngle), sin(dAngle));\n\
+    float sinHalfAngle = sin(dAngle / 2.0);\n\
+    float versine = 2.0 * sinHalfAngle * sinHalfAngle;\n\
+    float dRadial = dot(dPosition, outputRadialAxis) - cameraRadialDistance * versine;\n\
+    return vec2(dRadial, dAngle);\n\
+}\n\
+\n\
+vec3 convertEcToDeltaShape(in vec3 positionEC) {\n\
+    // 1. Rotate to radial, tangent, and up coordinates\n\
+    vec3 rtu = u_cylinderEcToRadialTangentUp * positionEC;\n\
+    // 2. Compute change in angular and radial coordinates.\n\
+    vec2 dPolar = computePolarChange(rtu.xy, u_cameraShapePosition.x);\n\
+    return vec3(dPolar.xy, rtu.z);\n\
+}\n\
+\n\
+vec3 convertEcToDeltaTile(in vec3 positionEC) {\n\
+    vec3 deltaShape = convertEcToDeltaShape(positionEC);\n\
+    // Convert to tileset coordinates in [0, 1]\n\
+    float dx = u_cylinderLocalToShapeUvScale.x * deltaShape.x;\n\
+    float dy = deltaShape.y / czm_twoPi;\n\
+#if defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE)\n\
+    // Wrap to ensure dy is not crossing through the unoccupied angle range, where\n\
+    // angle to tile coordinate conversions would be more complicated\n\
+    float cameraUvAngle = (u_cameraShapePosition.y + czm_pi) / czm_twoPi;\n\
+    float cameraUvAngleShift = fract(cameraUvAngle - u_cylinderShapeUvAngleRangeOrigin);\n\
+    float rawOutputUvAngle = cameraUvAngleShift + dy;\n\
+    float rotation = floor(rawOutputUvAngle);\n\
+    dy -= rotation;\n\
+#endif\n\
+    dy *= u_cylinderLocalToShapeUvScale.y;\n\
+    float dz = u_cylinderLocalToShapeUvScale.z * deltaShape.z;\n\
+    // Convert to tile coordinate changes\n\
+    return vec3(dx, dy, dz) * float(1 << u_cameraTileCoordinates.w);\n\
+}\n\
+\n\
+TileAndUvCoordinate getTileAndUvCoordinate(in vec3 positionEC) {\n\
+    vec3 deltaTileCoordinate = convertEcToDeltaTile(positionEC);\n\
+    vec3 tileUvSum = u_cameraTileUv + deltaTileCoordinate;\n\
+    ivec3 tileCoordinate = u_cameraTileCoordinates.xyz + ivec3(floor(tileUvSum));\n\
+    int maxTileCoordinate = (1 << u_cameraTileCoordinates.w) - 1;\n\
+    tileCoordinate.x = min(max(0, tileCoordinate.x), maxTileCoordinate);\n\
+    tileCoordinate.z = min(max(0, tileCoordinate.z), maxTileCoordinate);\n\
+#if (!defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE))\n\
+    ivec3 tileCoordinateChange = tileCoordinate - u_cameraTileCoordinates.xyz;\n\
+    if (tileCoordinate.y < 0) {\n\
+        tileCoordinate.y += (maxTileCoordinate + 1);\n\
+    } else if (tileCoordinate.y > maxTileCoordinate) {\n\
+        tileCoordinate.y -= (maxTileCoordinate + 1);\n\
+    }\n\
+#else\n\
+    tileCoordinate.y = min(max(0, tileCoordinate.y), maxTileCoordinate);\n\
+    ivec3 tileCoordinateChange = tileCoordinate - u_cameraTileCoordinates.xyz;\n\
+#endif\n\
+    vec3 tileUv = tileUvSum - vec3(tileCoordinateChange);\n\
+    tileUv.x = clamp(tileUv.x, 0.0, 1.0);\n\
+#if (!defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE))\n\
+    // If there is only one tile spanning 2*PI angle, the coordinate wraps around\n\
+    tileUv.y = (u_cameraTileCoordinates.w == 0) ? fract(tileUv.y) : clamp(tileUv.y, 0.0, 1.0);\n\
+#else\n\
+    tileUv.y = clamp(tileUv.y, 0.0, 1.0);\n\
+#endif\n\
+    tileUv.z = clamp(tileUv.z, 0.0, 1.0);\n\
+    return TileAndUvCoordinate(ivec4(tileCoordinate, u_cameraTileCoordinates.w), tileUv);\n\
+}\n\
+";

package/Source/Shaders/Voxels/convertLocalToEllipsoidUv.js

@@ -0,0 +1,185 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "/* Ellipsoid defines (set in Scene/VoxelEllipsoidShape.js)\n\
+#define ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE\n\
+#define ELLIPSOID_HAS_SHAPE_BOUNDS_LATITUDE\n\
+*/\n\
+\n\
+uniform vec3 u_cameraPositionCartographic; // (longitude, latitude, height) in radians and meters\n\
+uniform vec2 u_ellipsoidCurvatureAtLatitude;\n\
+uniform mat3 u_ellipsoidEcToEastNorthUp;\n\
+uniform vec3 u_ellipsoidRadii;\n\
+uniform vec2 u_evoluteScale; // (radii.x ^ 2 - radii.z ^ 2) * vec2(1.0, -1.0) / radii;\n\
+uniform vec3 u_ellipsoidInverseRadiiSquared;\n\
+#if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE)\n\
+    uniform float u_ellipsoidShapeUvLongitudeRangeOrigin;\n\
+#endif\n\
+uniform vec3 u_ellipsoidLocalToShapeUvScale; // x = longitude scale, y = latitude scale, z = height scale\n\
+\n\
+uniform ivec4 u_cameraTileCoordinates;\n\
+uniform vec3 u_cameraTileUv;\n\
+\n\
+// robust iterative solution without trig functions\n\
+// https://github.com/0xfaded/ellipse_demo/issues/1\n\
+// https://stackoverflow.com/questions/22959698/distance-from-given-point-to-given-ellipse\n\
+// Extended to return radius of curvature along with the point\n\
+vec3 nearestPointAndRadiusOnEllipse(vec2 pos, vec2 radii) {\n\
+    vec2 p = abs(pos);\n\
+    vec2 inverseRadii = 1.0 / radii;\n\
+\n\
+    // We describe the ellipse parametrically: v = radii * vec2(cos(t), sin(t))\n\
+    // but store the cos and sin of t in a vec2 for efficiency.\n\
+    // Initial guess: t = pi/4\n\
+    vec2 tTrigs = vec2(0.7071067811865476);\n\
+    // Initial guess of point on ellipsoid\n\
+    vec2 v = radii * tTrigs;\n\
+    // Center of curvature of the ellipse at v\n\
+    vec2 evolute = u_evoluteScale * tTrigs * tTrigs * tTrigs;\n\
+\n\
+    const int iterations = 3;\n\
+    for (int i = 0; i < iterations; ++i) {\n\
+        // Find the (approximate) intersection of p - evolute with the ellipsoid.\n\
+        vec2 q = normalize(p - evolute) * length(v - evolute);\n\
+        // Update the estimate of t.\n\
+        tTrigs = (q + evolute) * inverseRadii;\n\
+        tTrigs = normalize(clamp(tTrigs, 0.0, 1.0));\n\
+        v = radii * tTrigs;\n\
+        evolute = u_evoluteScale * tTrigs * tTrigs * tTrigs;\n\
+    }\n\
+\n\
+    return vec3(v * sign(pos), length(v - evolute));\n\
+}\n\
+\n\
+mat3 convertLocalToShapeSpaceDerivative(in vec3 position) {\n\
+    vec3 east = normalize(vec3(-position.y, position.x, 0.0));\n\
+\n\
+    // Convert the 3D position to a 2D position relative to the ellipse (radii.x, radii.z)\n\
+    // (assume radii.y == radii.x) and find the nearest point on the ellipse and its normal\n\
+    float distanceFromZAxis = length(position.xy);\n\
+    vec2 posEllipse = vec2(distanceFromZAxis, position.z);\n\
+    vec3 surfacePointAndRadius = nearestPointAndRadiusOnEllipse(posEllipse, u_ellipsoidRadii.xz);\n\
+    vec2 surfacePoint = surfacePointAndRadius.xy;\n\
+\n\
+    vec2 normal2d = normalize(surfacePoint * u_ellipsoidInverseRadiiSquared.xz);\n\
+    vec3 north = vec3(-normal2d.y * normalize(position.xy), abs(normal2d.x));\n\
+\n\
+    float heightSign = length(posEllipse) < length(surfacePoint) ? -1.0 : 1.0;\n\
+    float height = heightSign * length(posEllipse - surfacePoint);\n\
+    vec3 up = normalize(cross(east, north));\n\
+\n\
+    return mat3(east / distanceFromZAxis, north / (surfacePointAndRadius.z + height), up);\n\
+}\n\
+\n\
+vec3 scaleShapeUvToShapeSpace(in vec3 shapeUv) {\n\
+    // Convert from [0, 1] to radians [-pi, pi]\n\
+    float longitude = shapeUv.x * czm_twoPi;\n\
+    #if defined (ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE)\n\
+        longitude /= u_ellipsoidLocalToShapeUvScale.x;\n\
+    #endif\n\
+\n\
+    // Convert from [0, 1] to radians [-pi/2, pi/2]\n\
+    float latitude = shapeUv.y * czm_pi;\n\
+    #if defined(ELLIPSOID_HAS_SHAPE_BOUNDS_LATITUDE)\n\
+        latitude /= u_ellipsoidLocalToShapeUvScale.y;\n\
+    #endif\n\
+\n\
+    float height = shapeUv.z / u_ellipsoidLocalToShapeUvScale.z;\n\
+\n\
+    return vec3(longitude, latitude, height);\n\
+}\n\
+\n\
+vec3 convertEcToDeltaShape(in vec3 positionEC) {\n\
+    vec3 enu = u_ellipsoidEcToEastNorthUp * positionEC;\n\
+\n\
+    // 1. Compute the change in longitude from the camera to the ENU point\n\
+    // First project the camera and ENU positions to the equatorial XY plane,\n\
+    // positioning the camera on the +x axis, so that enu.x projects along the +y axis\n\
+    float cosLatitude = cos(u_cameraPositionCartographic.y);\n\
+    float sinLatitude = sin(u_cameraPositionCartographic.y);\n\
+    float primeVerticalRadius = 1.0 / u_ellipsoidCurvatureAtLatitude.x;\n\
+    vec2 cameraXY = vec2((primeVerticalRadius + u_cameraPositionCartographic.z) * cosLatitude, 0.0);\n\
+    // Note precision loss in positionXY.x if length(enu) << length(cameraXY)\n\
+    vec2 positionXY = cameraXY + vec2(-enu.y * sinLatitude + enu.z * cosLatitude, enu.x);\n\
+    float dLongitude = atan(positionXY.y, positionXY.x);\n\
+\n\
+    // 2. Find the longitude component of positionXY, by rotating about Z until the y component is zero.\n\
+    // Use the versine  to compute the change in x directly from the change in angle:\n\
+    //   versine(angle) = 2 * sin^2(angle/2)\n\
+    float sinHalfLongitude = sin(dLongitude / 2.0);\n\
+    float dx = length(positionXY) * 2.0 * sinHalfLongitude * sinHalfLongitude;\n\
+    // Rotate longitude component back to ENU North and Up, and remove from enu\n\
+    enu += vec3(-enu.x, -dx * sinLatitude, dx * cosLatitude);\n\
+\n\
+    // 3. Compute the change in latitude from the camera to the ENU point.\n\
+    // First project the camera and ENU positions to the meridional ZX plane,\n\
+    // positioning the camera on the +Z axis, so that enu.y maps to the +X axis.\n\
+    float meridionalRadius = 1.0 / u_ellipsoidCurvatureAtLatitude.y;\n\
+    vec2 cameraZX = vec2(meridionalRadius + u_cameraPositionCartographic.z, 0.0);\n\
+    vec2 positionZX = cameraZX + vec2(enu.z, enu.y);\n\
+    float dLatitude = atan(positionZX.y, positionZX.x);\n\
+\n\
+    // 4. Compute the change in height above the ellipsoid\n\
+    // Find the change in enu.z associated with rotating the point to the latitude of the camera\n\
+    float sinHalfLatitude = sin(dLatitude / 2.0);\n\
+    float dz = length(positionZX) * 2.0 * sinHalfLatitude * sinHalfLatitude;\n\
+    // The remaining change in enu.z is the change in height above the ellipsoid\n\
+    float dHeight = enu.z + dz;\n\
+\n\
+    return vec3(dLongitude, dLatitude, dHeight);\n\
+}\n\
+\n\
+vec3 convertEcToDeltaTile(in vec3 positionEC) {\n\
+    vec3 deltaShape = convertEcToDeltaShape(positionEC);\n\
+    // Convert to tileset coordinates in [0, 1]\n\
+    float dx = deltaShape.x / czm_twoPi;\n\
+\n\
+#if (defined(ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE))\n\
+    // Wrap to ensure dx is not crossing through the unoccupied angle range, where\n\
+    // angle to tile coordinate conversions would be more complicated\n\
+    float cameraUvLongitude = (u_cameraPositionCartographic.x + czm_pi) / czm_twoPi;\n\
+    float cameraUvLongitudeShift = fract(cameraUvLongitude - u_ellipsoidShapeUvLongitudeRangeOrigin);\n\
+    float rawOutputUvLongitude = cameraUvLongitudeShift + dx;\n\
+    float rotation = floor(rawOutputUvLongitude);\n\
+    dx -= rotation;\n\
+    dx *= u_ellipsoidLocalToShapeUvScale.x;\n\
+#endif\n\
+\n\
+    float dy = deltaShape.y / czm_pi;\n\
+#if (defined(ELLIPSOID_HAS_SHAPE_BOUNDS_LATITUDE))\n\
+    dy *= u_ellipsoidLocalToShapeUvScale.y;\n\
+#endif\n\
+\n\
+    float dz = u_ellipsoidLocalToShapeUvScale.z * deltaShape.z;\n\
+    // Convert to tile coordinate changes\n\
+    return vec3(dx, dy, dz) * float(1 << u_cameraTileCoordinates.w);\n\
+}\n\
+\n\
+TileAndUvCoordinate getTileAndUvCoordinate(in vec3 positionEC) {\n\
+    vec3 deltaTileCoordinate = convertEcToDeltaTile(positionEC);\n\
+    vec3 tileUvSum = u_cameraTileUv + deltaTileCoordinate;\n\
+    ivec3 tileCoordinate = u_cameraTileCoordinates.xyz + ivec3(floor(tileUvSum));\n\
+    int maxTileCoordinate = (1 << u_cameraTileCoordinates.w) - 1;\n\
+    tileCoordinate.y = min(max(0, tileCoordinate.y), maxTileCoordinate);\n\
+    tileCoordinate.z = min(max(0, tileCoordinate.z), maxTileCoordinate);\n\
+#if (!defined(ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE))\n\
+    ivec3 tileCoordinateChange = tileCoordinate - u_cameraTileCoordinates.xyz;\n\
+    if (tileCoordinate.x < 0) {\n\
+        tileCoordinate.x += (maxTileCoordinate + 1);\n\
+    } else if (tileCoordinate.x > maxTileCoordinate) {\n\
+        tileCoordinate.x -= (maxTileCoordinate + 1);\n\
+    }\n\
+#else\n\
+    tileCoordinate.x = min(max(0, tileCoordinate.x), maxTileCoordinate);\n\
+    ivec3 tileCoordinateChange = tileCoordinate - u_cameraTileCoordinates.xyz;\n\
+#endif\n\
+    vec3 tileUv = tileUvSum - vec3(tileCoordinateChange);\n\
+#if (!defined(ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE))\n\
+    // If there is only one tile spanning 2*PI angle, the coordinate wraps around\n\
+    tileUv.x = (u_cameraTileCoordinates.w == 0) ? fract(tileUv.x) : clamp(tileUv.x, 0.0, 1.0);\n\
+#else\n\
+    tileUv.x = clamp(tileUv.x, 0.0, 1.0);\n\
+#endif\n\
+    tileUv.y = clamp(tileUv.y, 0.0, 1.0);\n\
+    tileUv.z = clamp(tileUv.z, 0.0, 1.0);\n\
+    return TileAndUvCoordinate(ivec4(tileCoordinate, u_cameraTileCoordinates.w), tileUv);\n\
+}\n\
+";

package/index.js

@@ -1,4 +1,4 @@
-globalThis.CESIUM_VERSION = "0.1.0";
+globalThis.CESIUM_VERSION = "0.1.2";
 export { default as AutomaticUniforms } from './Source/Renderer/AutomaticUniforms.js';
 export { default as Buffer } from './Source/Renderer/Buffer.js';
 export { default as BufferUsage } from './Source/Renderer/BufferUsage.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deeptwins-cesium-engine",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "",
   "keywords": [
     "3D",