@cesium/engine 23.0.1 → 25.0.0

package/Source/Shaders/BufferPolylineMaterialVS.glsl

@@ -0,0 +1,49 @@
+in vec3 positionHigh;
+in vec3 positionLow;
+in vec3 prevPositionHigh;
+in vec3 prevPositionLow;
+in vec3 nextPositionHigh;
+in vec3 nextPositionLow;
+in vec4 pickColor;
+in vec4 showColorWidthAndTexCoord;
+
+out vec4 v_pickColor;
+out vec4 v_color;
+out vec2  v_st;
+out float v_width;
+out float v_polylineAngle;
+
+void main()
+{
+    float show = showColorWidthAndTexCoord.x;
+    vec4 color = czm_decodeRGB8(showColorWidthAndTexCoord.y);
+    float width = showColorWidthAndTexCoord.z;
+    float texCoord = showColorWidthAndTexCoord.w;
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    bool usePrevious = texCoord == 1.0;
+    float expandDir = gl_VertexID % 2 == 1 ? 1.0 : -1.0;
+    float polylineAngle;
+
+    vec4 positionEC = czm_translateRelativeToEye(positionHigh, positionLow);
+    vec4 prevPositionEC = czm_translateRelativeToEye(prevPositionHigh, prevPositionLow);
+    vec4 nextPositionEC = czm_translateRelativeToEye(nextPositionHigh, nextPositionLow);
+
+    vec4 positionWC = getPolylineWindowCoordinates(positionEC, prevPositionEC, nextPositionEC, expandDir, width, usePrevious, polylineAngle);
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    gl_Position = czm_viewportOrthographic * positionWC * show;
+
+    v_pickColor = pickColor / 255.0;
+
+    v_color = color;
+    v_color.a *= show;
+
+    v_st.s = texCoord;
+    v_st.t = czm_writeNonPerspective(clamp(expandDir, 0.0, 1.0), gl_Position.w);
+
+    v_width = width;
+    v_polylineAngle = polylineAngle;
+}

package/Source/Shaders/BufferPolylineMaterialVS.js

@@ -0,0 +1,51 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "in vec3 positionHigh;\n\
+in vec3 positionLow;\n\
+in vec3 prevPositionHigh;\n\
+in vec3 prevPositionLow;\n\
+in vec3 nextPositionHigh;\n\
+in vec3 nextPositionLow;\n\
+in vec4 pickColor;\n\
+in vec4 showColorWidthAndTexCoord;\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\
+    vec4 positionEC = czm_translateRelativeToEye(positionHigh, positionLow);\n\
+    vec4 prevPositionEC = czm_translateRelativeToEye(prevPositionHigh, prevPositionLow);\n\
+    vec4 nextPositionEC = czm_translateRelativeToEye(nextPositionHigh, nextPositionLow);\n\
+\n\
+    vec4 positionWC = getPolylineWindowCoordinates(positionEC, prevPositionEC, nextPositionEC, expandDir, width, usePrevious, polylineAngle);\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 *= 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/Builtin/CzmBuiltins.js

@@ -71,6 +71,7 @@ import czm_computeAtmosphereColor from './Functions/computeAtmosphereColor.js'
 import czm_computeGroundAtmosphereScattering from './Functions/computeGroundAtmosphereScattering.js'
 import czm_computePosition from './Functions/computePosition.js'
 import czm_computeScattering from './Functions/computeScattering.js'
+import czm_computeTextureTransform from './Functions/computeTextureTransform.js'
 import czm_cosineAndSine from './Functions/cosineAndSine.js'
 import czm_decodeRGB8 from './Functions/decodeRGB8.js'
 import czm_decompressTextureCoordinates from './Functions/decompressTextureCoordinates.js'
@@ -213,6 +214,7 @@ export default {
     czm_computeGroundAtmosphereScattering : czm_computeGroundAtmosphereScattering,
     czm_computePosition : czm_computePosition,
     czm_computeScattering : czm_computeScattering,
+    czm_computeTextureTransform : czm_computeTextureTransform,
     czm_cosineAndSine : czm_cosineAndSine,
     czm_decodeRGB8 : czm_decodeRGB8,
     czm_decompressTextureCoordinates : czm_decompressTextureCoordinates,

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

@@ -0,0 +1,24 @@
+/**
+ * Applies a 2D texture transformation matrix to texture coordinates.
+ * This function applies translation, rotation, and scaling transformations
+ * as specified by the KHR_texture_transform glTF extension.
+ *
+ * @name czm_computeTextureTransform
+ * @glslFunction
+ *
+ * @param {vec2} texCoord The texture coordinates to transform.
+ * @param {mat3} textureTransform The 3x3 transformation matrix.
+ *
+ * @returns {vec2} The transformed texture coordinates.
+ *
+ * @example
+ * // GLSL declaration
+ * vec2 czm_computeTextureTransform(vec2 texCoord, mat3 textureTransform);
+ *
+ * // Apply texture transform to UV coordinates
+ * vec2 transformedUV = czm_computeTextureTransform(uv, u_textureTransform);
+ */
+vec2 czm_computeTextureTransform(vec2 texCoord, mat3 textureTransform)
+{
+    return vec2(textureTransform * vec3(texCoord, 1.0));
+}

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

@@ -0,0 +1,25 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "/**\n\
+ * Applies a 2D texture transformation matrix to texture coordinates.\n\
+ * This function applies translation, rotation, and scaling transformations\n\
+ * as specified by the KHR_texture_transform glTF extension.\n\
+ *\n\
+ * @name czm_computeTextureTransform\n\
+ * @glslFunction\n\
+ *\n\
+ * @param {vec2} texCoord The texture coordinates to transform.\n\
+ * @param {mat3} textureTransform The 3x3 transformation matrix.\n\
+ *\n\
+ * @returns {vec2} The transformed texture coordinates.\n\
+ *\n\
+ * @example\n\
+ * // GLSL declaration\n\
+ * vec2 czm_computeTextureTransform(vec2 texCoord, mat3 textureTransform);\n\
+ *\n\
+ * // Apply texture transform to UV coordinates\n\
+ * vec2 transformedUV = czm_computeTextureTransform(uv, u_textureTransform);\n\
+ */\n\
+vec2 czm_computeTextureTransform(vec2 texCoord, mat3 textureTransform)\n\
+{\n\
+    return vec2(textureTransform * vec3(texCoord, 1.0));\n\
+}";

package/Source/Shaders/Model/ConstantLodStageFS.glsl

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

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.glsl

@@ -0,0 +1,12 @@
+#ifdef HAS_CONSTANT_LOD
+// Extract model scale to compensate for minimumPixelSize scaling
+float modelScaleX = length(czm_model[0].xyz);
+float modelScaleY = length(czm_model[1].xyz);
+float modelScaleZ = length(czm_model[2].xyz);
+float modelScale = (modelScaleX + modelScaleY + modelScaleZ) / 3.0;
+
+// Transform model position through ENU but as direction only (w=0) to avoid position-dependent rotation
+vec3 enuDir = (u_constantLodWorldToEnu * czm_model * vec4(v_positionMC, 0.0)).xyz;
+v_constantLodUvCustom.xy = (enuDir.yx + u_constantLodOffset) / modelScale;
+v_constantLodUvCustom.z = u_constantLodDistance / modelScale;
+#endif

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/EdgeVisibilityStageFS.glsl

@@ -13,59 +13,45 @@ void edgeVisibilityStage(inout vec4 color, inout FeatureIds featureIds)
     if (!u_isEdgePass) {
         return;
     }
-    
+ 
     float edgeTypeInt = v_edgeType * 255.0;
-    
-    // Color code different edge types
-    vec4 edgeColor = vec4(0.0);
-    
-    if (edgeTypeInt < 0.5) { // HIDDEN (0)
-        edgeColor = vec4(0.0, 0.0, 0.0, 0.0); // Transparent for hidden edges
+
+    if (edgeTypeInt < 0.5) {
+        discard;
     }
-    else if (edgeTypeInt > 0.5 && edgeTypeInt < 1.5) { // SILHOUETTE (1) - Conditional visibility
-        // Proper silhouette detection using face normals
-        vec3 normalA = normalize(v_faceNormalAView);
-        vec3 normalB = normalize(v_faceNormalBView);
-        
-        // Calculate view direction using existing eye-space position varying (v_positionEC)
-        vec3 viewDir = -normalize(v_positionEC);
-        
-        // Calculate dot products to determine triangle facing
-        float dotA = dot(normalA, viewDir);
-        float dotB = dot(normalB, viewDir);
-        
-        const float eps = 1e-3;
-        bool frontA = dotA > eps;
-        bool backA  = dotA < -eps;
-        bool frontB = dotB > eps;
-        bool backB  = dotB < -eps;
-        
-        // True silhouette: one triangle front-facing, other back-facing
-        bool oppositeFacing = (frontA && backB) || (backA && frontB);
-        
-        // Exclude edges where both triangles are nearly grazing (perpendicular to view)
-        // This handles the top-view cylinder case where both normals are ~horizontal
-        bool bothNearGrazing = (abs(dotA) <= eps && abs(dotB) <= eps);
-        
-        if (!(oppositeFacing && !bothNearGrazing)) {
-            discard; // Not a true silhouette edge
-        } else {
-            // True silhouette
-            edgeColor = vec4(1.0, 0.0, 0.0, 1.0);
+
+    if (edgeTypeInt > 0.5 && edgeTypeInt < 1.5) { // silhouette candidate
+        // Silhouette check done in vertex shader
+        // v_shouldDiscard will be > 0.5 if this edge should be discarded
+        if (v_shouldDiscard > 0.5) {
+            discard;
         }
     }
-    else if (edgeTypeInt > 1.5 && edgeTypeInt < 2.5) { // HARD (2) - BRIGHT GREEN
-        edgeColor = vec4(0.0, 1.0, 0.0, 1.0); // Extra bright green
-    }
-    else if (edgeTypeInt > 2.5 && edgeTypeInt < 3.5) { // REPEATED (3)
-        edgeColor = vec4(0.0, 0.0, 1.0, 1.0);
-    } else {
-        edgeColor = vec4(0.0, 0.0, 0.0, 0.0);
+
+    vec4 finalColor = color;
+#ifdef HAS_EDGE_COLOR_ATTRIBUTE
+    if (v_edgeColor.a >= 0.0) {
+        finalColor = v_edgeColor;
     }
+#endif
 
-    // Temporary color: white
-    edgeColor = vec4(1.0, 1.0, 1.0, 1.0);
-    color = edgeColor;
+#ifdef HAS_LINE_PATTERN
+    // Pattern is 16-bit, each bit represents visibility at that position
+    const float maskLength = 16.0;
+    
+    // Get the relative position within the dash from 0 to 1
+    float dashPosition = fract(v_lineCoord / maskLength);
+    // Figure out the mask index
+    float maskIndex = floor(dashPosition * maskLength);
+    // Test the bit mask
+    float maskTest = floor(u_linePattern / pow(2.0, maskIndex));
+    
+    // If bit is 0 (gap), discard the fragment (use < 1.0 for better numerical stability)
+    if (mod(maskTest, 2.0) < 1.0) {
+        discard;
+    }
+#endif
+    color = finalColor;
     
     #if defined(HAS_EDGE_VISIBILITY_MRT) && !defined(CESIUM_REDIRECTED_COLOR_OUTPUT)
         // Write edge metadata
@@ -80,4 +66,4 @@ void edgeVisibilityStage(inout vec4 color, inout FeatureIds featureIds)
         out_edgeDepth = czm_packDepth(gl_FragCoord.z);
     #endif
 #endif
-}
+}

package/Source/Shaders/Model/EdgeVisibilityStageFS.js

@@ -14,59 +14,45 @@ void edgeVisibilityStage(inout vec4 color, inout FeatureIds featureIds)\n\
     if (!u_isEdgePass) {\n\
         return;\n\
     }\n\
-    \n\
+ \n\
     float edgeTypeInt = v_edgeType * 255.0;\n\
-    \n\
-    // Color code different edge types\n\
-    vec4 edgeColor = vec4(0.0);\n\
-    \n\
-    if (edgeTypeInt < 0.5) { // HIDDEN (0)\n\
-        edgeColor = vec4(0.0, 0.0, 0.0, 0.0); // Transparent for hidden edges\n\
+\n\
+    if (edgeTypeInt < 0.5) {\n\
+        discard;\n\
     }\n\
-    else if (edgeTypeInt > 0.5 && edgeTypeInt < 1.5) { // SILHOUETTE (1) - Conditional visibility\n\
-        // Proper silhouette detection using face normals\n\
-        vec3 normalA = normalize(v_faceNormalAView);\n\
-        vec3 normalB = normalize(v_faceNormalBView);\n\
-        \n\
-        // Calculate view direction using existing eye-space position varying (v_positionEC)\n\
-        vec3 viewDir = -normalize(v_positionEC);\n\
-        \n\
-        // Calculate dot products to determine triangle facing\n\
-        float dotA = dot(normalA, viewDir);\n\
-        float dotB = dot(normalB, viewDir);\n\
-        \n\
-        const float eps = 1e-3;\n\
-        bool frontA = dotA > eps;\n\
-        bool backA  = dotA < -eps;\n\
-        bool frontB = dotB > eps;\n\
-        bool backB  = dotB < -eps;\n\
-        \n\
-        // True silhouette: one triangle front-facing, other back-facing\n\
-        bool oppositeFacing = (frontA && backB) || (backA && frontB);\n\
-        \n\
-        // Exclude edges where both triangles are nearly grazing (perpendicular to view)\n\
-        // This handles the top-view cylinder case where both normals are ~horizontal\n\
-        bool bothNearGrazing = (abs(dotA) <= eps && abs(dotB) <= eps);\n\
-        \n\
-        if (!(oppositeFacing && !bothNearGrazing)) {\n\
-            discard; // Not a true silhouette edge\n\
-        } else {\n\
-            // True silhouette\n\
-            edgeColor = vec4(1.0, 0.0, 0.0, 1.0);\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\
-    else if (edgeTypeInt > 1.5 && edgeTypeInt < 2.5) { // HARD (2) - BRIGHT GREEN\n\
-        edgeColor = vec4(0.0, 1.0, 0.0, 1.0); // Extra bright green\n\
-    }\n\
-    else if (edgeTypeInt > 2.5 && edgeTypeInt < 3.5) { // REPEATED (3)\n\
-        edgeColor = vec4(0.0, 0.0, 1.0, 1.0);\n\
-    } else {\n\
-        edgeColor = vec4(0.0, 0.0, 0.0, 0.0);\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\
-    // Temporary color: white\n\
-    edgeColor = vec4(1.0, 1.0, 1.0, 1.0);\n\
-    color = edgeColor;\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\
@@ -81,5 +67,4 @@ void edgeVisibilityStage(inout vec4 color, inout FeatureIds featureIds)\n\
         out_edgeDepth = czm_packDepth(gl_FragCoord.z);\n\
     #endif\n\
 #endif\n\
-}\n\
-";
+}";

package/Source/Shaders/Model/EdgeVisibilityStageVS.glsl

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