deeptwins-cesium-engine 0.1.1 → 0.1.3

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\
+";