@cesium/engine 23.0.1 → 25.0.0

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

@@ -11,17 +11,12 @@ vec3 blend(vec3 sourceColor, vec3 styleColor, float styleColorBlend)
     return color;
 }
 
-vec2 computeTextureTransform(vec2 texCoord, mat3 textureTransform)
-{
-    return vec2(textureTransform * vec3(texCoord, 1.0));
-}
-
 #ifdef HAS_NORMAL_TEXTURE
 vec2 getNormalTexCoords()
 {
     vec2 texCoord = TEXCOORD_NORMAL;
     #ifdef HAS_NORMAL_TEXTURE_TRANSFORM
-        texCoord = vec2(u_normalTextureTransform * vec3(texCoord, 1.0));
+        texCoord = czm_computeTextureTransform(texCoord, u_normalTextureTransform);
     #endif
     return texCoord;
 }
@@ -64,7 +59,18 @@ NormalInfo getNormalInfo(ProcessedAttributes attributes)
 
     #ifdef HAS_NORMAL_TEXTURE
         mat3 tbn = mat3(tangent, bitangent, geometryNormal);
-        vec3 normalSample = texture(u_normalTexture, normalTexCoords).rgb;
+        
+        vec3 normalSample;
+        #if defined(HAS_NORMAL_CONSTANT_LOD) && defined(HAS_CONSTANT_LOD)
+            #ifdef HAS_NORMAL_TEXTURE_TRANSFORM
+                normalSample = constantLodTextureLookup(u_normalTexture, u_normalTextureConstantLodParams, u_normalTextureTransform).rgb;
+            #else
+                normalSample = constantLodTextureLookup(u_normalTexture, u_normalTextureConstantLodParams).rgb;
+            #endif
+        #else
+            normalSample = texture(u_normalTexture, normalTexCoords).rgb;
+        #endif
+        
         normalSample = 2.0 * normalSample - 1.0;
         #ifdef HAS_NORMAL_TEXTURE_SCALE
             normalSample.xy *= u_normalTextureScale;
@@ -109,7 +115,18 @@ vec3 getNormalFromTexture(ProcessedAttributes attributes, vec3 geometryNormal)
     #endif
 
     mat3 tbn = mat3(t, b, geometryNormal);
-    vec3 normalSample = texture(u_normalTexture, normalTexCoords).rgb;
+    
+    vec3 normalSample;
+    #if defined(HAS_NORMAL_CONSTANT_LOD) && defined(HAS_CONSTANT_LOD)
+        #ifdef HAS_NORMAL_TEXTURE_TRANSFORM
+            normalSample = constantLodTextureLookup(u_normalTexture, u_normalTextureConstantLodParams, u_normalTextureTransform).rgb;
+        #else
+            normalSample = constantLodTextureLookup(u_normalTexture, u_normalTextureConstantLodParams).rgb;
+        #endif
+    #else
+        normalSample = texture(u_normalTexture, normalTexCoords).rgb;
+    #endif
+    
     normalSample = 2.0 * normalSample - 1.0;
     #ifdef HAS_NORMAL_TEXTURE_SCALE
         normalSample.xy *= u_normalTextureScale;
@@ -171,10 +188,19 @@ vec4 getBaseColorFromTexture()
 {
     vec2 baseColorTexCoords = TEXCOORD_BASE_COLOR;
     #ifdef HAS_BASE_COLOR_TEXTURE_TRANSFORM
-        baseColorTexCoords = computeTextureTransform(baseColorTexCoords, u_baseColorTextureTransform);
+        baseColorTexCoords = czm_computeTextureTransform(baseColorTexCoords, u_baseColorTextureTransform);
     #endif
 
-    vec4 baseColorWithAlpha = czm_srgbToLinear(texture(u_baseColorTexture, baseColorTexCoords));
+    vec4 baseColorWithAlpha;
+    #if defined(HAS_BASE_COLOR_CONSTANT_LOD) && defined(HAS_CONSTANT_LOD)
+        #ifdef HAS_BASE_COLOR_TEXTURE_TRANSFORM
+            baseColorWithAlpha = czm_srgbToLinear(constantLodTextureLookup(u_baseColorTexture, u_baseColorTextureConstantLodParams, u_baseColorTextureTransform));
+        #else
+            baseColorWithAlpha = czm_srgbToLinear(constantLodTextureLookup(u_baseColorTexture, u_baseColorTextureConstantLodParams));
+        #endif
+    #else
+        baseColorWithAlpha = czm_srgbToLinear(texture(u_baseColorTexture, baseColorTexCoords));
+    #endif
 
     #ifdef HAS_BASE_COLOR_FACTOR
         baseColorWithAlpha *= u_baseColorFactor;
@@ -189,7 +215,7 @@ vec3 getEmissiveFromTexture()
 {
     vec2 emissiveTexCoords = TEXCOORD_EMISSIVE;
     #ifdef HAS_EMISSIVE_TEXTURE_TRANSFORM
-        emissiveTexCoords = computeTextureTransform(emissiveTexCoords, u_emissiveTextureTransform);
+        emissiveTexCoords = czm_computeTextureTransform(emissiveTexCoords, u_emissiveTextureTransform);
     #endif
 
     vec3 emissive = czm_srgbToLinear(texture(u_emissiveTexture, emissiveTexCoords).rgb);
@@ -207,7 +233,7 @@ void setSpecularGlossiness(inout czm_modelMaterial material)
     #ifdef HAS_SPECULAR_GLOSSINESS_TEXTURE
         vec2 specularGlossinessTexCoords = TEXCOORD_SPECULAR_GLOSSINESS;
         #ifdef HAS_SPECULAR_GLOSSINESS_TEXTURE_TRANSFORM
-            specularGlossinessTexCoords = computeTextureTransform(specularGlossinessTexCoords, u_specularGlossinessTextureTransform);
+            specularGlossinessTexCoords = czm_computeTextureTransform(specularGlossinessTexCoords, u_specularGlossinessTextureTransform);
         #endif
 
         vec4 specularGlossiness = czm_srgbToLinear(texture(u_specularGlossinessTexture, specularGlossinessTexCoords));
@@ -237,7 +263,7 @@ void setSpecularGlossiness(inout czm_modelMaterial material)
     #ifdef HAS_DIFFUSE_TEXTURE
         vec2 diffuseTexCoords = TEXCOORD_DIFFUSE;
         #ifdef HAS_DIFFUSE_TEXTURE_TRANSFORM
-            diffuseTexCoords = computeTextureTransform(diffuseTexCoords, u_diffuseTextureTransform);
+            diffuseTexCoords = czm_computeTextureTransform(diffuseTexCoords, u_diffuseTextureTransform);
         #endif
 
         vec4 diffuse = czm_srgbToLinear(texture(u_diffuseTexture, diffuseTexCoords));
@@ -266,7 +292,7 @@ float setMetallicRoughness(inout czm_modelMaterial material)
     #ifdef HAS_METALLIC_ROUGHNESS_TEXTURE
         vec2 metallicRoughnessTexCoords = TEXCOORD_METALLIC_ROUGHNESS;
         #ifdef HAS_METALLIC_ROUGHNESS_TEXTURE_TRANSFORM
-            metallicRoughnessTexCoords = computeTextureTransform(metallicRoughnessTexCoords, u_metallicRoughnessTextureTransform);
+            metallicRoughnessTexCoords = czm_computeTextureTransform(metallicRoughnessTexCoords, u_metallicRoughnessTextureTransform);
         #endif
 
         vec3 metallicRoughness = texture(u_metallicRoughnessTexture, metallicRoughnessTexCoords).rgb;
@@ -313,7 +339,7 @@ void setSpecular(inout czm_modelMaterial material, in float metalness)
     #ifdef HAS_SPECULAR_TEXTURE
         vec2 specularTexCoords = TEXCOORD_SPECULAR;
         #ifdef HAS_SPECULAR_TEXTURE_TRANSFORM
-            specularTexCoords = computeTextureTransform(specularTexCoords, u_specularTextureTransform);
+            specularTexCoords = czm_computeTextureTransform(specularTexCoords, u_specularTextureTransform);
         #endif
         float specularWeight = texture(u_specularTexture, specularTexCoords).a;
         #ifdef HAS_SPECULAR_FACTOR
@@ -330,7 +356,7 @@ void setSpecular(inout czm_modelMaterial material, in float metalness)
     #ifdef HAS_SPECULAR_COLOR_TEXTURE
         vec2 specularColorTexCoords = TEXCOORD_SPECULAR_COLOR;
         #ifdef HAS_SPECULAR_COLOR_TEXTURE_TRANSFORM
-            specularColorTexCoords = computeTextureTransform(specularColorTexCoords, u_specularColorTextureTransform);
+            specularColorTexCoords = czm_computeTextureTransform(specularColorTexCoords, u_specularColorTextureTransform);
         #endif
         vec3 specularColorSample = texture(u_specularColorTexture, specularColorTexCoords).rgb;
         vec3 specularColorFactor = czm_srgbToLinear(specularColorSample);
@@ -360,7 +386,7 @@ void setAnisotropy(inout czm_modelMaterial material, in NormalInfo normalInfo)
     #ifdef HAS_ANISOTROPY_TEXTURE
         vec2 anisotropyTexCoords = TEXCOORD_ANISOTROPY;
         #ifdef HAS_ANISOTROPY_TEXTURE_TRANSFORM
-            anisotropyTexCoords = computeTextureTransform(anisotropyTexCoords, u_anisotropyTextureTransform);
+            anisotropyTexCoords = czm_computeTextureTransform(anisotropyTexCoords, u_anisotropyTextureTransform);
         #endif
         vec3 anisotropySample = texture(u_anisotropyTexture, anisotropyTexCoords).rgb;
         direction = anisotropySample.rg * 2.0 - vec2(1.0);
@@ -383,7 +409,7 @@ void setClearcoat(inout czm_modelMaterial material, in ProcessedAttributes attri
     #ifdef HAS_CLEARCOAT_TEXTURE
         vec2 clearcoatTexCoords = TEXCOORD_CLEARCOAT;
         #ifdef HAS_CLEARCOAT_TEXTURE_TRANSFORM
-            clearcoatTexCoords = computeTextureTransform(clearcoatTexCoords, u_clearcoatTextureTransform);
+            clearcoatTexCoords = czm_computeTextureTransform(clearcoatTexCoords, u_clearcoatTextureTransform);
         #endif
         float clearcoatFactor = texture(u_clearcoatTexture, clearcoatTexCoords).r;
         #ifdef HAS_CLEARCOAT_FACTOR
@@ -401,7 +427,7 @@ void setClearcoat(inout czm_modelMaterial material, in ProcessedAttributes attri
     #ifdef HAS_CLEARCOAT_ROUGHNESS_TEXTURE
         vec2 clearcoatRoughnessTexCoords = TEXCOORD_CLEARCOAT_ROUGHNESS;
         #ifdef HAS_CLEARCOAT_ROUGHNESS_TEXTURE_TRANSFORM
-            clearcoatRoughnessTexCoords = computeTextureTransform(clearcoatRoughnessTexCoords, u_clearcoatRoughnessTextureTransform);
+            clearcoatRoughnessTexCoords = czm_computeTextureTransform(clearcoatRoughnessTexCoords, u_clearcoatRoughnessTextureTransform);
         #endif
         float clearcoatRoughness = texture(u_clearcoatRoughnessTexture, clearcoatRoughnessTexCoords).g;
         #ifdef HAS_CLEARCOAT_ROUGHNESS_FACTOR
@@ -469,7 +495,7 @@ void materialStage(inout czm_modelMaterial material, ProcessedAttributes attribu
     #ifdef HAS_OCCLUSION_TEXTURE
         vec2 occlusionTexCoords = TEXCOORD_OCCLUSION;
         #ifdef HAS_OCCLUSION_TEXTURE_TRANSFORM
-            occlusionTexCoords = computeTextureTransform(occlusionTexCoords, u_occlusionTextureTransform);
+            occlusionTexCoords = czm_computeTextureTransform(occlusionTexCoords, u_occlusionTextureTransform);
         #endif
         material.occlusion = texture(u_occlusionTexture, occlusionTexCoords).r;
     #endif

package/Source/Shaders/Model/MaterialStageFS.js

@@ -12,17 +12,12 @@ vec3 blend(vec3 sourceColor, vec3 styleColor, float styleColorBlend)\n\
     return color;\n\
 }\n\
 \n\
-vec2 computeTextureTransform(vec2 texCoord, mat3 textureTransform)\n\
-{\n\
-    return vec2(textureTransform * vec3(texCoord, 1.0));\n\
-}\n\
-\n\
 #ifdef HAS_NORMAL_TEXTURE\n\
 vec2 getNormalTexCoords()\n\
 {\n\
     vec2 texCoord = TEXCOORD_NORMAL;\n\
     #ifdef HAS_NORMAL_TEXTURE_TRANSFORM\n\
-        texCoord = vec2(u_normalTextureTransform * vec3(texCoord, 1.0));\n\
+        texCoord = czm_computeTextureTransform(texCoord, u_normalTextureTransform);\n\
     #endif\n\
     return texCoord;\n\
 }\n\
@@ -65,7 +60,18 @@ NormalInfo getNormalInfo(ProcessedAttributes attributes)\n\
 \n\
     #ifdef HAS_NORMAL_TEXTURE\n\
         mat3 tbn = mat3(tangent, bitangent, geometryNormal);\n\
-        vec3 normalSample = texture(u_normalTexture, normalTexCoords).rgb;\n\
+        \n\
+        vec3 normalSample;\n\
+        #if defined(HAS_NORMAL_CONSTANT_LOD) && defined(HAS_CONSTANT_LOD)\n\
+            #ifdef HAS_NORMAL_TEXTURE_TRANSFORM\n\
+                normalSample = constantLodTextureLookup(u_normalTexture, u_normalTextureConstantLodParams, u_normalTextureTransform).rgb;\n\
+            #else\n\
+                normalSample = constantLodTextureLookup(u_normalTexture, u_normalTextureConstantLodParams).rgb;\n\
+            #endif\n\
+        #else\n\
+            normalSample = texture(u_normalTexture, normalTexCoords).rgb;\n\
+        #endif\n\
+        \n\
         normalSample = 2.0 * normalSample - 1.0;\n\
         #ifdef HAS_NORMAL_TEXTURE_SCALE\n\
             normalSample.xy *= u_normalTextureScale;\n\
@@ -110,7 +116,18 @@ vec3 getNormalFromTexture(ProcessedAttributes attributes, vec3 geometryNormal)\n
     #endif\n\
 \n\
     mat3 tbn = mat3(t, b, geometryNormal);\n\
-    vec3 normalSample = texture(u_normalTexture, normalTexCoords).rgb;\n\
+    \n\
+    vec3 normalSample;\n\
+    #if defined(HAS_NORMAL_CONSTANT_LOD) && defined(HAS_CONSTANT_LOD)\n\
+        #ifdef HAS_NORMAL_TEXTURE_TRANSFORM\n\
+            normalSample = constantLodTextureLookup(u_normalTexture, u_normalTextureConstantLodParams, u_normalTextureTransform).rgb;\n\
+        #else\n\
+            normalSample = constantLodTextureLookup(u_normalTexture, u_normalTextureConstantLodParams).rgb;\n\
+        #endif\n\
+    #else\n\
+        normalSample = texture(u_normalTexture, normalTexCoords).rgb;\n\
+    #endif\n\
+    \n\
     normalSample = 2.0 * normalSample - 1.0;\n\
     #ifdef HAS_NORMAL_TEXTURE_SCALE\n\
         normalSample.xy *= u_normalTextureScale;\n\
@@ -172,10 +189,19 @@ vec4 getBaseColorFromTexture()\n\
 {\n\
     vec2 baseColorTexCoords = TEXCOORD_BASE_COLOR;\n\
     #ifdef HAS_BASE_COLOR_TEXTURE_TRANSFORM\n\
-        baseColorTexCoords = computeTextureTransform(baseColorTexCoords, u_baseColorTextureTransform);\n\
+        baseColorTexCoords = czm_computeTextureTransform(baseColorTexCoords, u_baseColorTextureTransform);\n\
     #endif\n\
 \n\
-    vec4 baseColorWithAlpha = czm_srgbToLinear(texture(u_baseColorTexture, baseColorTexCoords));\n\
+    vec4 baseColorWithAlpha;\n\
+    #if defined(HAS_BASE_COLOR_CONSTANT_LOD) && defined(HAS_CONSTANT_LOD)\n\
+        #ifdef HAS_BASE_COLOR_TEXTURE_TRANSFORM\n\
+            baseColorWithAlpha = czm_srgbToLinear(constantLodTextureLookup(u_baseColorTexture, u_baseColorTextureConstantLodParams, u_baseColorTextureTransform));\n\
+        #else\n\
+            baseColorWithAlpha = czm_srgbToLinear(constantLodTextureLookup(u_baseColorTexture, u_baseColorTextureConstantLodParams));\n\
+        #endif\n\
+    #else\n\
+        baseColorWithAlpha = czm_srgbToLinear(texture(u_baseColorTexture, baseColorTexCoords));\n\
+    #endif\n\
 \n\
     #ifdef HAS_BASE_COLOR_FACTOR\n\
         baseColorWithAlpha *= u_baseColorFactor;\n\
@@ -190,7 +216,7 @@ vec3 getEmissiveFromTexture()\n\
 {\n\
     vec2 emissiveTexCoords = TEXCOORD_EMISSIVE;\n\
     #ifdef HAS_EMISSIVE_TEXTURE_TRANSFORM\n\
-        emissiveTexCoords = computeTextureTransform(emissiveTexCoords, u_emissiveTextureTransform);\n\
+        emissiveTexCoords = czm_computeTextureTransform(emissiveTexCoords, u_emissiveTextureTransform);\n\
     #endif\n\
 \n\
     vec3 emissive = czm_srgbToLinear(texture(u_emissiveTexture, emissiveTexCoords).rgb);\n\
@@ -208,7 +234,7 @@ void setSpecularGlossiness(inout czm_modelMaterial material)\n\
     #ifdef HAS_SPECULAR_GLOSSINESS_TEXTURE\n\
         vec2 specularGlossinessTexCoords = TEXCOORD_SPECULAR_GLOSSINESS;\n\
         #ifdef HAS_SPECULAR_GLOSSINESS_TEXTURE_TRANSFORM\n\
-            specularGlossinessTexCoords = computeTextureTransform(specularGlossinessTexCoords, u_specularGlossinessTextureTransform);\n\
+            specularGlossinessTexCoords = czm_computeTextureTransform(specularGlossinessTexCoords, u_specularGlossinessTextureTransform);\n\
         #endif\n\
 \n\
         vec4 specularGlossiness = czm_srgbToLinear(texture(u_specularGlossinessTexture, specularGlossinessTexCoords));\n\
@@ -238,7 +264,7 @@ void setSpecularGlossiness(inout czm_modelMaterial material)\n\
     #ifdef HAS_DIFFUSE_TEXTURE\n\
         vec2 diffuseTexCoords = TEXCOORD_DIFFUSE;\n\
         #ifdef HAS_DIFFUSE_TEXTURE_TRANSFORM\n\
-            diffuseTexCoords = computeTextureTransform(diffuseTexCoords, u_diffuseTextureTransform);\n\
+            diffuseTexCoords = czm_computeTextureTransform(diffuseTexCoords, u_diffuseTextureTransform);\n\
         #endif\n\
 \n\
         vec4 diffuse = czm_srgbToLinear(texture(u_diffuseTexture, diffuseTexCoords));\n\
@@ -267,7 +293,7 @@ float setMetallicRoughness(inout czm_modelMaterial material)\n\
     #ifdef HAS_METALLIC_ROUGHNESS_TEXTURE\n\
         vec2 metallicRoughnessTexCoords = TEXCOORD_METALLIC_ROUGHNESS;\n\
         #ifdef HAS_METALLIC_ROUGHNESS_TEXTURE_TRANSFORM\n\
-            metallicRoughnessTexCoords = computeTextureTransform(metallicRoughnessTexCoords, u_metallicRoughnessTextureTransform);\n\
+            metallicRoughnessTexCoords = czm_computeTextureTransform(metallicRoughnessTexCoords, u_metallicRoughnessTextureTransform);\n\
         #endif\n\
 \n\
         vec3 metallicRoughness = texture(u_metallicRoughnessTexture, metallicRoughnessTexCoords).rgb;\n\
@@ -314,7 +340,7 @@ void setSpecular(inout czm_modelMaterial material, in float metalness)\n\
     #ifdef HAS_SPECULAR_TEXTURE\n\
         vec2 specularTexCoords = TEXCOORD_SPECULAR;\n\
         #ifdef HAS_SPECULAR_TEXTURE_TRANSFORM\n\
-            specularTexCoords = computeTextureTransform(specularTexCoords, u_specularTextureTransform);\n\
+            specularTexCoords = czm_computeTextureTransform(specularTexCoords, u_specularTextureTransform);\n\
         #endif\n\
         float specularWeight = texture(u_specularTexture, specularTexCoords).a;\n\
         #ifdef HAS_SPECULAR_FACTOR\n\
@@ -331,7 +357,7 @@ void setSpecular(inout czm_modelMaterial material, in float metalness)\n\
     #ifdef HAS_SPECULAR_COLOR_TEXTURE\n\
         vec2 specularColorTexCoords = TEXCOORD_SPECULAR_COLOR;\n\
         #ifdef HAS_SPECULAR_COLOR_TEXTURE_TRANSFORM\n\
-            specularColorTexCoords = computeTextureTransform(specularColorTexCoords, u_specularColorTextureTransform);\n\
+            specularColorTexCoords = czm_computeTextureTransform(specularColorTexCoords, u_specularColorTextureTransform);\n\
         #endif\n\
         vec3 specularColorSample = texture(u_specularColorTexture, specularColorTexCoords).rgb;\n\
         vec3 specularColorFactor = czm_srgbToLinear(specularColorSample);\n\
@@ -361,7 +387,7 @@ void setAnisotropy(inout czm_modelMaterial material, in NormalInfo normalInfo)\n
     #ifdef HAS_ANISOTROPY_TEXTURE\n\
         vec2 anisotropyTexCoords = TEXCOORD_ANISOTROPY;\n\
         #ifdef HAS_ANISOTROPY_TEXTURE_TRANSFORM\n\
-            anisotropyTexCoords = computeTextureTransform(anisotropyTexCoords, u_anisotropyTextureTransform);\n\
+            anisotropyTexCoords = czm_computeTextureTransform(anisotropyTexCoords, u_anisotropyTextureTransform);\n\
         #endif\n\
         vec3 anisotropySample = texture(u_anisotropyTexture, anisotropyTexCoords).rgb;\n\
         direction = anisotropySample.rg * 2.0 - vec2(1.0);\n\
@@ -384,7 +410,7 @@ void setClearcoat(inout czm_modelMaterial material, in ProcessedAttributes attri
     #ifdef HAS_CLEARCOAT_TEXTURE\n\
         vec2 clearcoatTexCoords = TEXCOORD_CLEARCOAT;\n\
         #ifdef HAS_CLEARCOAT_TEXTURE_TRANSFORM\n\
-            clearcoatTexCoords = computeTextureTransform(clearcoatTexCoords, u_clearcoatTextureTransform);\n\
+            clearcoatTexCoords = czm_computeTextureTransform(clearcoatTexCoords, u_clearcoatTextureTransform);\n\
         #endif\n\
         float clearcoatFactor = texture(u_clearcoatTexture, clearcoatTexCoords).r;\n\
         #ifdef HAS_CLEARCOAT_FACTOR\n\
@@ -402,7 +428,7 @@ void setClearcoat(inout czm_modelMaterial material, in ProcessedAttributes attri
     #ifdef HAS_CLEARCOAT_ROUGHNESS_TEXTURE\n\
         vec2 clearcoatRoughnessTexCoords = TEXCOORD_CLEARCOAT_ROUGHNESS;\n\
         #ifdef HAS_CLEARCOAT_ROUGHNESS_TEXTURE_TRANSFORM\n\
-            clearcoatRoughnessTexCoords = computeTextureTransform(clearcoatRoughnessTexCoords, u_clearcoatRoughnessTextureTransform);\n\
+            clearcoatRoughnessTexCoords = czm_computeTextureTransform(clearcoatRoughnessTexCoords, u_clearcoatRoughnessTextureTransform);\n\
         #endif\n\
         float clearcoatRoughness = texture(u_clearcoatRoughnessTexture, clearcoatRoughnessTexCoords).g;\n\
         #ifdef HAS_CLEARCOAT_ROUGHNESS_FACTOR\n\
@@ -470,7 +496,7 @@ void materialStage(inout czm_modelMaterial material, ProcessedAttributes attribu
     #ifdef HAS_OCCLUSION_TEXTURE\n\
         vec2 occlusionTexCoords = TEXCOORD_OCCLUSION;\n\
         #ifdef HAS_OCCLUSION_TEXTURE_TRANSFORM\n\
-            occlusionTexCoords = computeTextureTransform(occlusionTexCoords, u_occlusionTextureTransform);\n\
+            occlusionTexCoords = czm_computeTextureTransform(occlusionTexCoords, u_occlusionTextureTransform);\n\
         #endif\n\
         material.occlusion = texture(u_occlusionTexture, occlusionTexCoords).r;\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\

package/Source/Shaders/PolygonSignedDistanceFS.glsl

@@ -52,48 +52,79 @@ void main() {
     }
     int regionIndex = getPolygonIndex(dimension, v_textureCoordinates);
 
+    if (regionIndex >= u_extentsLength) {
+        return; // done (no polygons in this region)
+    }
+
     for (int polygonIndex = 0; polygonIndex < u_polygonsLength; polygonIndex++) {
         ivec2 positionsLengthAndExtents = getPositionsLengthAndExtentsIndex(lastPolygonIndex);
         int positionsLength = positionsLengthAndExtents.x;
         int polygonExtentsIndex = positionsLengthAndExtents.y;
         lastPolygonIndex += 1;
 
+        // Read the individual polygon extent (2 pixels: south/west, latRange/lonRange)
+        vec2 extentsSouthWest = getPolygonPosition(lastPolygonIndex);
+        vec2 extentsRange = getPolygonPosition(lastPolygonIndex + 1);
+        vec4 polygonExtent = vec4(extentsSouthWest, extentsRange);
+        lastPolygonIndex += 2;
+
+        if (polygonExtentsIndex < regionIndex) {
+            lastPolygonIndex += positionsLength;
+            continue; // skip to next (TODO: could optimize further if we knew how many polygons to skip)
+        } else if (polygonExtentsIndex > regionIndex) {
+            break; // done (we know polygons are sorted by regionIndex)
+        }
+
          // Only compute signed distance for the relevant part of the atlas
-         if (polygonExtentsIndex == regionIndex) {
-            float clipAmount = czm_infinity;
-            vec4 extents = getExtents(polygonExtentsIndex);
-            vec2 textureOffset = vec2(mod(float(polygonExtentsIndex), dimension), floor(float(polygonExtentsIndex) / dimension)) / dimension;
-            vec2 p = getCoordinates((v_textureCoordinates - textureOffset) * dimension, extents);
-            float s = 1.0;
-
-            // Check each edge for absolute distance
-            for (int i = 0, j = positionsLength - 1; i < positionsLength; j = i, i++) {
-                vec2 a = getPolygonPosition(lastPolygonIndex + i);
-                vec2 b = getPolygonPosition(lastPolygonIndex + j);
- 
-                vec2 ab = b - a;
-                vec2 pa = p - a;
-                float t = dot(pa, ab) / dot(ab, ab);
-                t = clamp(t, 0.0, 1.0);
-
-                vec2 pq = pa - t * ab;
-                float d = length(pq);
-
-                // Inside / outside computation to determine sign
-                bvec3 cond = bvec3(p.y >= a.y, 
-                            p.y < b.y, 
-                            ab.x * pa.y > ab.y * pa.x);
-                if (all(cond) || all(not(cond))) s = -s;
-                if (abs(d) < abs(clipAmount)) {
-                    clipAmount = d;
-                }
+        float clipAmount = czm_infinity;
+        vec4 extents = getExtents(polygonExtentsIndex);
+        vec2 textureOffset = vec2(mod(float(polygonExtentsIndex), dimension), floor(float(polygonExtentsIndex) / dimension)) / dimension;
+        vec2 p = getCoordinates((v_textureCoordinates - textureOffset) * dimension, extents);   // current pixel position
+
+        // Only consider polygons whos boundingbox includes current pixel (with a slight padding)
+        float padding = 0.05;   // 5% of polygon extents
+        float polygonNorth = polygonExtent.x + polygonExtent.z;
+        float polygonEast = polygonExtent.y + polygonExtent.w;
+        float latPadding = padding * polygonExtent.z; // padding as fraction of latitude range
+        float lonPadding = padding * polygonExtent.w; // padding as fraction of longitude range
+        if (p.x < polygonExtent.x - latPadding || p.x > polygonNorth + latPadding ||
+            p.y < polygonExtent.y - lonPadding || p.y > polygonEast + lonPadding) {
+            lastPolygonIndex += positionsLength;
+            continue;   // skip to next
+        }
+
+        float s = 1.0;
+
+        // Check each edge for absolute distance.
+        // Cache the previous vertex to halve the texture reads per iteration.
+        vec2 prev = getPolygonPosition(lastPolygonIndex + positionsLength - 1);
+        for (int i = 0; i < positionsLength; i++) {
+            vec2 a = getPolygonPosition(lastPolygonIndex + i);
+            vec2 b = prev;
+            prev = a;
+
+            vec2 ab = b - a;
+            vec2 pa = p - a;
+            float t = dot(pa, ab) / dot(ab, ab);
+            t = clamp(t, 0.0, 1.0);
+
+            vec2 pq = pa - t * ab;
+            float d = length(pq);
+
+            // Inside / outside computation to determine sign
+            bvec3 cond = bvec3(p.y >= a.y, 
+                        p.y < b.y, 
+                        ab.x * pa.y > ab.y * pa.x);
+            if (all(cond) || all(not(cond))) s = -s;
+            if (abs(d) < abs(clipAmount)) {
+                clipAmount = d;
             }
+        }
 
-            // Normalize the range to [0,1]
-            vec4 result = (s * vec4(clipAmount * length(extents.zw))) / 2.0 + 0.5;
-            // In the case where we've iterated through multiple polygons, take the minimum
-            out_FragColor = min(out_FragColor, result);
-         }
+        // Normalize the range to [0,1]
+        vec4 result = (s * vec4(clipAmount * length(extents.zw))) / 2.0 + 0.5;
+        // In the case where we've iterated through multiple polygons, take the minimum
+        out_FragColor = min(out_FragColor, result);
 
         lastPolygonIndex += positionsLength;
     }