@cesium/engine 23.0.0 → 24.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/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

package/Source/Shaders/Model/EdgeVisibilityStageVS.js

@@ -0,0 +1,100 @@
+//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_silhouetteNormalView = czm_normal * a_silhouetteNormal;\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/Model/ModelFS.glsl

@@ -25,6 +25,19 @@ vec4 handleAlpha(vec3 color, float alpha)
     return vec4(color, alpha);
 }
 
+void lineStyleStage()
+{
+    #if defined(HAS_LINE_PATTERN) && !defined(HAS_EDGE_VISIBILITY)
+    const float maskLength = 16.0;
+    float dashPosition = fract(v_lineCoord / maskLength);
+    float maskIndex = floor(dashPosition * maskLength);
+    float maskTest = floor(u_linePattern / pow(2.0, maskIndex));
+    if (mod(maskTest, 2.0) < 1.0) {
+        discard;
+    }
+    #endif
+}
+
 SelectedFeature selectedFeature;
 
 void main()
@@ -107,6 +120,8 @@ void main()
     // When picking metadata END
     //========================================================================
 
+    lineStyleStage();
+
     #ifdef HAS_CLIPPING_PLANES
     modelClippingPlanesStage(color);
     #endif

package/Source/Shaders/Model/ModelFS.js

@@ -26,6 +26,19 @@ vec4 handleAlpha(vec3 color, float alpha)\n\
     return vec4(color, alpha);\n\
 }\n\
 \n\
+void lineStyleStage()\n\
+{\n\
+    #if defined(HAS_LINE_PATTERN) && !defined(HAS_EDGE_VISIBILITY)\n\
+    const float maskLength = 16.0;\n\
+    float dashPosition = fract(v_lineCoord / maskLength);\n\
+    float maskIndex = floor(dashPosition * maskLength);\n\
+    float maskTest = floor(u_linePattern / pow(2.0, maskIndex));\n\
+    if (mod(maskTest, 2.0) < 1.0) {\n\
+        discard;\n\
+    }\n\
+    #endif\n\
+}\n\
+\n\
 SelectedFeature selectedFeature;\n\
 \n\
 void main()\n\
@@ -107,6 +120,8 @@ void main()\n\
     #endif\n\
     // When picking metadata END\n\
     //========================================================================\n\
+\n\
+    lineStyleStage();\n\
 \n\
     #ifdef HAS_CLIPPING_PLANES\n\
     modelClippingPlanesStage(color);\n\

package/Source/Shaders/Model/ModelVS.glsl

@@ -110,6 +110,10 @@ void main()
     // This returns the value that will be assigned to gl_Position.
     vec4 positionClip = geometryStage(attributes, modelView, normal);
 
+    #if defined(HAS_LINE_CUMULATIVE_DISTANCE) || defined(HAS_LINE_PATTERN)
+    lineStyleStageVS(attributes);
+    #endif
+
     // This must go after the geometry stage as it needs v_positionWC
     #ifdef HAS_ATMOSPHERE
     atmosphereStage(attributes);
@@ -157,6 +161,10 @@ void main()
     // We will discard points with v_pointCloudShow == 0 in the fragment shader.
     gl_Position = positionClip;
 
+    #ifdef HAS_EDGE_VISIBILITY
+    edgeVisibilityStageVS();
+    #endif
+
     #ifdef HAS_POINT_CLOUD_SHOW_STYLE
     v_pointCloudShow = show;
     #endif

package/Source/Shaders/Model/ModelVS.js

@@ -110,6 +110,10 @@ void main()\n\
     // Compute the final position in each coordinate system needed.\n\
     // This returns the value that will be assigned to gl_Position.\n\
     vec4 positionClip = geometryStage(attributes, modelView, normal);\n\
+\n\
+    #if defined(HAS_LINE_CUMULATIVE_DISTANCE) || defined(HAS_LINE_PATTERN)\n\
+    lineStyleStageVS(attributes);\n\
+    #endif\n\
 \n\
     // This must go after the geometry stage as it needs v_positionWC\n\
     #ifdef HAS_ATMOSPHERE\n\
@@ -157,6 +161,10 @@ void main()\n\
     //\n\
     // We will discard points with v_pointCloudShow == 0 in the fragment shader.\n\
     gl_Position = positionClip;\n\
+\n\
+    #ifdef HAS_EDGE_VISIBILITY\n\
+    edgeVisibilityStageVS();\n\
+    #endif\n\
 \n\
     #ifdef HAS_POINT_CLOUD_SHOW_STYLE\n\
     v_pointCloudShow = show;\n\