deeptwins-cesium-engine 0.1.2 → 0.1.4

package/Source/Shaders/GlobeFS.js

@@ -88,25 +88,47 @@ flat in int v_regionIndex;\n\
 uniform float u_minimumBrightness;\n\
 #endif\n\
 \n\
+// Based on colorCorrect\n\
+// The colorCorrect flag can only be true when tileProvider.hue/saturation/brightnessShift \n\
+// are nonzero AND when (applyFog || showGroundAtmosphere) in the tile provider\n\
+// - The tileProvider.hue/saturation/brightnessShift are just passed through\n\
+//   from the Globe hue/saturation/brightness, like atmosphereBrightnessShift\n\
+// - The applyFog depends on enableFog, and some tile distance from the viewer\n\
+// - The showGroundAtmosphere is a flag that is passed through from the Globe,\n\
+//   and is true by default when the ellipsoid is WGS84\n\
 #ifdef COLOR_CORRECT\n\
 uniform vec3 u_hsbShift; // Hue, saturation, brightness\n\
 #endif\n\
 \n\
+// Based on highlightFillTile\n\
+// This is set for terrain tiles when they are \"fill\" tiles, and\n\
+// the terrainProvider.fillHighlightColor was set to a value with\n\
+// nonzero alpha\n\
 #ifdef HIGHLIGHT_FILL_TILE\n\
 uniform vec4 u_fillHighlightColor;\n\
 #endif\n\
 \n\
+// Based on translucent\n\
+// This is set depending on the GlobeTranslucencyState\n\
 #ifdef TRANSLUCENT\n\
 uniform vec4 u_frontFaceAlphaByDistance;\n\
 uniform vec4 u_backFaceAlphaByDistance;\n\
 uniform vec4 u_translucencyRectangle;\n\
 #endif\n\
 \n\
+// Based on showUndergroundColor\n\
+// This is set when GlobeSurfaceTileProvider.isUndergroundVisible \n\
+// returns true, AND the tileProvider.undergroundColor had a value with \n\
+// nonzero alpha, and the tileProvider.undergroundColorAlphaByDistance\n\
+// was in the right range\n\
 #ifdef UNDERGROUND_COLOR\n\
 uniform vec4 u_undergroundColor;\n\
 uniform vec4 u_undergroundColorAlphaByDistance;\n\
 #endif\n\
 \n\
+// Based on enableLighting && hasVertexNormals\n\
+// The enableLighting flag is passed in directly from the Globe.\n\
+// The hasVertexNormals flag is from the tileProvider\n\
 #ifdef ENABLE_VERTEX_LIGHTING\n\
 uniform float u_lambertDiffuseMultiplier;\n\
 uniform float u_vertexShadowDarkness;\n\

package/Source/Shaders/GlobeVS.js

@@ -115,7 +115,8 @@ vec4 getPositionMorphingMode(vec3 position, float height, vec2 textureCoordinate
     float yPositionFraction = get2DYPositionFraction(textureCoordinates);\n\
     vec4 position2DWC = vec4(height, mix(u_tileRectangle.st, u_tileRectangle.pq, vec2(textureCoordinates.x, yPositionFraction)), 1.0);\n\
     vec4 morphPosition = czm_columbusViewMorph(position2DWC, vec4(position3DWC, 1.0), czm_morphTime);\n\
-    return czm_modelViewProjection * morphPosition;\n\
+    vec4 morphPositionEC = czm_modelView * morphPosition;\n\
+    return czm_projection * morphPositionEC;\n\
 }\n\
 \n\
 #ifdef QUANTIZATION_BITS12\n\
@@ -141,7 +142,7 @@ void main()\n\
 #elif defined(INCLUDE_WEB_MERCATOR_Y)\n\
     float webMercatorT = czm_decompressTextureCoordinates(compressed0.w).x;\n\
     float encodedNormal = 0.0;\n\
-#elif defined(ENABLE_VERTEX_LIGHTING) || defined(GENERATE_POSITION_AND_NORMAL)\n\
+#elif defined(ENABLE_VERTEX_LIGHTING) || defined(GENERATE_POSITION_AND_NORMAL) || defined(APPLY_MATERIAL)\n\
     float webMercatorT = textureCoordinates.y;\n\
     float encodedNormal = compressed0.w;\n\
 #else\n\

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\
@@ -444,6 +470,10 @@ void materialStage(inout czm_modelMaterial material, ProcessedAttributes attribu
     #elif defined(HAS_BASE_COLOR_FACTOR)\n\
         baseColorWithAlpha = u_baseColorFactor;\n\
     #endif\n\
+\n\
+    #ifdef HAS_IMAGERY\n\
+    baseColorWithAlpha = blendBaseColorWithImagery(baseColorWithAlpha);\n\
+    #endif // HAS_IMAGERY\n\
 \n\
     #ifdef HAS_POINT_CLOUD_COLOR_STYLE\n\
         baseColorWithAlpha = v_pointCloudColor;\n\
@@ -466,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/MetadataStageFS.js

@@ -1,11 +1,12 @@
 //This file is automatically rebuilt by the Cesium build process.
 export default "void metadataStage(\n\
+  FeatureIds featureIds,\n\
   out Metadata metadata,\n\
   out MetadataClass metadataClass,\n\
   out MetadataStatistics metadataStatistics,\n\
   ProcessedAttributes attributes\n\
   )\n\
 {\n\
-  initializeMetadata(metadata, metadataClass, metadataStatistics, attributes);\n\
+  initializeMetadata(featureIds, metadata, metadataClass, metadataStatistics, attributes);\n\
 }\n\
 ";

package/Source/Shaders/Model/MetadataStageVS.js

@@ -1,12 +1,13 @@
 //This file is automatically rebuilt by the Cesium build process.
 export default "void metadataStage(\n\
+  FeatureIds featureIds,\n\
   out Metadata metadata,\n\
   out MetadataClass metadataClass,\n\
   out MetadataStatistics metadataStatistics,\n\
   ProcessedAttributes attributes\n\
   )\n\
 {\n\
-  initializeMetadata(metadata, metadataClass, metadataStatistics, attributes);\n\
+  initializeMetadata(featureIds, metadata, metadataClass, metadataStatistics, attributes);\n\
   setMetadataVaryings();\n\
 }\n\
 ";

package/Source/Shaders/Model/ModelFS.js

@@ -1,6 +1,7 @@
 //This file is automatically rebuilt by the Cesium build process.
 export default "\n\
 precision highp float;\n\
+\n\
 czm_modelMaterial defaultModelMaterial()\n\
 {\n\
     czm_modelMaterial material;\n\
@@ -25,10 +26,31 @@ 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\
 {\n\
+    #if defined(PRIMITIVE_TYPE_POINTS) && defined(HAS_POINT_DIAMETER)\n\
+    // Render points as circles\n\
+    float distanceToCenter = length(gl_PointCoord - vec2(0.5));\n\
+    if (distanceToCenter > 0.5) {\n\
+        discard;\n\
+    }\n\
+    #endif\n\
+\n\
     #ifdef HAS_POINT_CLOUD_SHOW_STYLE\n\
         if (v_pointCloudShow == 0.0)\n\
         {\n\
@@ -51,7 +73,7 @@ void main()\n\
     Metadata metadata;\n\
     MetadataClass metadataClass;\n\
     MetadataStatistics metadataStatistics;\n\
-    metadataStage(metadata, metadataClass, metadataStatistics, attributes);\n\
+    metadataStage(featureIds, metadata, metadataClass, metadataStatistics, attributes);\n\
 \n\
     //========================================================================\n\
     // When not picking metadata START\n\
@@ -87,7 +109,7 @@ void main()\n\
 \n\
     // When not picking metadata END\n\
     //========================================================================\n\
-    #else \n\
+    #else\n\
     //========================================================================\n\
     // When picking metadata START\n\
 \n\
@@ -98,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\
@@ -118,6 +142,11 @@ void main()\n\
     #ifdef HAS_ATMOSPHERE\n\
     atmosphereStage(color, attributes);\n\
     #endif\n\
+\n\
+    #ifdef HAS_EDGE_VISIBILITY\n\
+    edgeVisibilityStage(color, featureIds);\n\
+    edgeDetectionStage(color, featureIds);\n\
+    #endif\n\
 \n\
     #endif\n\
     // When not picking metadata END\n\
@@ -125,4 +154,5 @@ void main()\n\
 \n\
     out_FragColor = color;\n\
 }\n\
+\n\
 ";

package/Source/Shaders/Model/ModelVS.js

@@ -14,6 +14,10 @@ void main()\n\
     // attributes except quantized ones.\n\
     ProcessedAttributes attributes;\n\
     initializeAttributes(attributes);\n\
+\n\
+    #ifdef HAS_IMAGERY\n\
+    initializeImageryAttributes();\n\
+    #endif\n\
 \n\
     // Dequantize the quantized ones and add them to the\n\
     // attributes struct.\n\
@@ -92,7 +96,7 @@ void main()\n\
     Metadata metadata;\n\
     MetadataClass metadataClass;\n\
     MetadataStatistics metadataStatistics;\n\
-    metadataStage(metadata, metadataClass, metadataStatistics, attributes);\n\
+    metadataStage(featureIds, metadata, metadataClass, metadataStatistics, attributes);\n\
 \n\
     #ifdef HAS_VERTICAL_EXAGGERATION\n\
     verticalExaggerationStage(attributes);\n\
@@ -106,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\
@@ -139,6 +147,8 @@ void main()\n\
         gl_PointSize = vsOutput.pointSize;\n\
         #elif defined(HAS_POINT_CLOUD_POINT_SIZE_STYLE) || defined(HAS_POINT_CLOUD_ATTENUATION)\n\
         gl_PointSize = pointCloudPointSizeStylingStage(attributes, metadata);\n\
+        #elif defined(HAS_POINT_DIAMETER)\n\
+        gl_PointSize = u_pointDiameter;\n\
         #else\n\
         gl_PointSize = 1.0;\n\
         #endif\n\
@@ -151,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/Model/PointCloudStylingStageVS.js

@@ -43,4 +43,5 @@ float pointCloudBackFaceCullingStage() {\n\
   return 1.0;\n\
   #endif\n\
 }\n\
-#endif";
+#endif\n\
+";

package/Source/Shaders/Model/PrimitiveOutlineStageFS.js

@@ -14,5 +14,4 @@ export default "void primitiveOutlineStage(inout czm_modelMaterial material) {\n
 \n\
     material.diffuse = mix(material.diffuse, model_outlineColor.rgb, model_outlineColor.a * outlineness);\n\
 }\n\
-\n\
 ";

package/Source/Shaders/PointPrimitiveCollectionVS.js

@@ -47,45 +47,14 @@ void main()\n\
 \n\
     ///////////////////////////////////////////////////////////////////////////\n\
 \n\
-    vec4 color;\n\
-    vec4 outlineColor;\n\
-    vec4 pickColor;\n\
-\n\
-    // compressedAttribute0.z => pickColor.rgb\n\
-\n\
-    temp = compressedAttribute0.z * SHIFT_RIGHT8;\n\
-    pickColor.b = (temp - floor(temp)) * SHIFT_LEFT8;\n\
-    temp = floor(temp) * SHIFT_RIGHT8;\n\
-    pickColor.g = (temp - floor(temp)) * SHIFT_LEFT8;\n\
-    pickColor.r = floor(temp);\n\
-\n\
-    // compressedAttribute0.x => color.rgb\n\
-\n\
-    temp = compressedAttribute0.x * SHIFT_RIGHT8;\n\
-    color.b = (temp - floor(temp)) * SHIFT_LEFT8;\n\
-    temp = floor(temp) * SHIFT_RIGHT8;\n\
-    color.g = (temp - floor(temp)) * SHIFT_LEFT8;\n\
-    color.r = floor(temp);\n\
-\n\
-    // compressedAttribute0.y => outlineColor.rgb\n\
-\n\
-    temp = compressedAttribute0.y * SHIFT_RIGHT8;\n\
-    outlineColor.b = (temp - floor(temp)) * SHIFT_LEFT8;\n\
-    temp = floor(temp) * SHIFT_RIGHT8;\n\
-    outlineColor.g = (temp - floor(temp)) * SHIFT_LEFT8;\n\
-    outlineColor.r = floor(temp);\n\
-\n\
-    // compressedAttribute0.w => color.a, outlineColor.a, pickColor.a\n\
-\n\
-    temp = compressedAttribute0.w * SHIFT_RIGHT8;\n\
-    pickColor.a = (temp - floor(temp)) * SHIFT_LEFT8;\n\
-    pickColor = pickColor / 255.0;\n\
-\n\
-    temp = floor(temp) * SHIFT_RIGHT8;\n\
-    outlineColor.a = (temp - floor(temp)) * SHIFT_LEFT8;\n\
-    outlineColor /= 255.0;\n\
-    color.a = floor(temp);\n\
-    color /= 255.0;\n\
+    vec4 color = czm_decodeRGB8(compressedAttribute0.x);\n\
+    vec4 outlineColor = czm_decodeRGB8(compressedAttribute0.y);\n\
+    vec4 pickColor = czm_decodeRGB8(compressedAttribute0.z);\n\
+    vec4 alphaPacked = czm_decodeRGB8(compressedAttribute0.w);\n\
+\n\
+    color.a = alphaPacked.x;\n\
+    outlineColor.a = alphaPacked.y;\n\
+    pickColor.a = alphaPacked.z;\n\
 \n\
     ///////////////////////////////////////////////////////////////////////////\n\
 \n\

package/Source/Shaders/PolygonSignedDistanceFS.js

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

package/Source/Shaders/PolylineCommon.js

@@ -161,7 +161,7 @@ vec4 getPolylineWindowCoordinatesEC(vec4 positionEC, vec4 prevEC, vec4 nextEC, f
         vec2 u = -thisSegmentForwardWC;\n\
         vec2 v = leftWC;\n\
         float sinAngle = abs(u.x * v.y - u.y * v.x);\n\
-        expandWidth = clamp(expandWidth / sinAngle, 0.0, width * 0.5);\n\
+        expandWidth = clamp(expandWidth / sinAngle, 0.0, width * 2.0);\n\
     }\n\
 \n\
     vec2 offset = leftWC * expandDirection * expandWidth * czm_pixelRatio;\n\

package/Source/Shaders/ShadowVolumeAppearanceFS.js

@@ -66,21 +66,6 @@ void main(void)\n\
 #endif // SPHERICAL\n\
 #endif // TEXTURE_COORDINATES\n\
 \n\
-#ifdef PICK\n\
-#ifdef CULL_FRAGMENTS\n\
-    // When classifying translucent geometry, logDepthOrDepth == 0.0\n\
-    // indicates a region that should not be classified, possibly due to there\n\
-    // being opaque pixels there in another buffer.\n\
-    // Check for logDepthOrDepth != 0.0 to make sure this should be classified.\n\
-    if (0.0 <= uv.x && uv.x <= 1.0 && 0.0 <= uv.y && uv.y <= 1.0 || logDepthOrDepth != 0.0) {\n\
-        out_FragColor.a = 1.0; // 0.0 alpha leads to discard from ShaderSource.createPickFragmentShaderSource\n\
-        czm_writeDepthClamp();\n\
-    }\n\
-#else // CULL_FRAGMENTS\n\
-        out_FragColor.a = 1.0;\n\
-#endif // CULL_FRAGMENTS\n\
-#else // PICK\n\
-\n\
 #ifdef CULL_FRAGMENTS\n\
     // When classifying translucent geometry, logDepthOrDepth == 0.0\n\
     // indicates a region that should not be classified, possibly due to there\n\
@@ -90,6 +75,13 @@ void main(void)\n\
     }\n\
 #endif\n\
 \n\
+#ifdef PICK\n\
+    out_FragColor.a = 1.0; // Explicitly set the alpha, otherwise this may be discarded by ShaderSource.createPickFragmentShaderSource\n\
+#ifdef CULL_FRAGMENTS\n\
+    czm_writeDepthClamp();\n\
+#endif // CULL_FRAGMENTS\n\
+#else // PICK\n\
+\n\
 #ifdef NORMAL_EC\n\
     // Compute normal by sampling adjacent pixels in 2x2 block in screen space\n\
     vec3 downUp = vectorFromOffset(eyeCoordinate, vec2(0.0, 1.0));\n\

package/Source/Shaders/SkyAtmosphereVS.js

@@ -28,6 +28,7 @@ void main(void)\n\
     #endif\n\
 \n\
     v_outerPositionWC = positionWC.xyz;\n\
-    gl_Position = czm_modelViewProjection * position;\n\
+    vec4 positionEC = czm_modelView * position;\n\
+    gl_Position = czm_projection * positionEC;\n\
 }\n\
 ";