@deck.gl/extensions 9.4.0-alpha.2 → 9.4.0-beta.3

package/dist/path-style/shaders.glsl.js

@@ -6,26 +6,68 @@ export const dashShaders = {
         'vs:#decl': `
 in vec2 instanceDashArrays;
 #ifdef HIGH_PRECISION_DASH
-in float instanceDashOffsets;
+in vec2 instanceDashOffsets;
 #endif
 out vec2 vDashArray;
 out float vDashOffset;
+out float vDashPathLength;
+layout(std140) uniform pathStyleUniforms {
+float dashAlignMode;
+bool dashGapPickable;
+highp int dashUnits;
+} pathStyle;
 `,
         'vs:#main-end': `
-vDashArray = instanceDashArrays;
+float dashWidthPixels = path.billboard
+? width.x * project.focalDistance
+: width.x * project.scale;
+float strokeHalfWidthPixels = path.billboard ? width.x : width.x * project.scale;
+float dashUnitPixels = strokeHalfWidthPixels;
+if (pathStyle.dashUnits == 1) {
+dashUnitPixels = 1.0;
+} else if (pathStyle.dashUnits == 2) {
+dashUnitPixels = project_size_to_pixel(1.0);
+} else if (pathStyle.dashUnits == 3) {
+dashUnitPixels = project.scale;
+}
+vDashArray = instanceDashArrays * (dashUnitPixels / dashWidthPixels);
 #ifdef HIGH_PRECISION_DASH
-vDashOffset = instanceDashOffsets / width.x;
+vec2 dashOffsetAndLength = (instanceDashOffsets * project.scale) / dashWidthPixels;
+vDashPathLength = dashOffsetAndLength.y;
+float dashUnitLength = vDashArray.x + vDashArray.y;
+float dashPeriod = pathStyle.dashAlignMode == 0.0
+? dashUnitLength
+: vDashPathLength / max(round(vDashPathLength / max(dashUnitLength, 0.0001)), 1.0);
+vDashOffset = dashPeriod > 0.0 ? mod(dashOffsetAndLength.x, dashPeriod) : 0.0;
 #else
 vDashOffset = 0.0;
+vDashPathLength = 0.0;
 #endif
 `,
         'fs:#decl': `
 layout(std140) uniform pathStyleUniforms {
 float dashAlignMode;
 bool dashGapPickable;
+highp int dashUnits;
 } pathStyle;
 in vec2 vDashArray;
 in float vDashOffset;
+in float vDashPathLength;
+float dashPatternIntegral(float position, float solidLength, float unitLength) {
+return floor(position / unitLength) * solidLength +
+min(mod(position, unitLength), solidLength);
+}
+float dashPatternCoverage(
+float position,
+float solidLength,
+float unitLength,
+float filterWidth
+) {
+float halfFilter = 0.5 * filterWidth;
+float reducedPosition = mod(position, unitLength);
+return (dashPatternIntegral(reducedPosition + halfFilter, solidLength, unitLength) -
+dashPatternIntegral(reducedPosition - halfFilter, solidLength, unitLength)) / filterWidth;
+}
 `,
         // if given position is in the gap part of the dashed line
         // dashArray.x: solid stroke length, relative to width
@@ -36,36 +78,90 @@ in float vDashOffset;
         // 1 - stretch to fit, draw half dash at each end for nicer joints
         // o--    ----    ----    ----    --o--      --o--     ----     --o
         'fs:#main-start': `
+float dashCoverage = 1.0;
+bool shouldDiscardDash = false;
+bool inRoundedDashGap = false;
+float roundedDashResolvedCoverage = 1.0;
+float roundedDashSubPixelBlend = 0.0;
+float roundedDashDutyCycle = 1.0;
 float solidLength = vDashArray.x;
 float gapLength = vDashArray.y;
 float unitLength = solidLength + gapLength;
+if (unitLength > 0.0 && gapLength > 0.0) {
 float offset;
-if (unitLength > 0.0) {
 if (pathStyle.dashAlignMode == 0.0) {
 offset = vDashOffset;
 } else {
-unitLength = vPathLength / round(vPathLength / unitLength);
+#ifdef HIGH_PRECISION_DASH
+unitLength = vDashPathLength / max(round(vDashPathLength / unitLength), 1.0);
+#else
+unitLength = vPathLength / max(round(vPathLength / unitLength), 1.0);
+#endif
+solidLength = min(solidLength, unitLength);
 offset = solidLength / 2.0;
+#ifdef HIGH_PRECISION_DASH
+offset += vDashOffset;
+#endif
 }
-float unitOffset = mod(vPathPosition.y + offset, unitLength);
-if (gapLength > 0.0 && unitOffset > solidLength) {
-if (path.capType <= 0.5) {
-if (!(pathStyle.dashGapPickable && bool(picking.isActive))) {
-discard;
-}
-} else {
-float distToEnd = length(vec2(
+float alongPath = vPathPosition.y + offset;
+float unitOffset = mod(alongPath, unitLength);
+float filterWidth = max(fwidth(alongPath), 0.0001);
+if (bool(picking.isActive)) {
+bool inGap = unitOffset > solidLength;
+if (inGap && path.capType > 0.5) {
+inGap = length(vec2(
 min(unitOffset - solidLength, unitLength - unitOffset),
 vPathPosition.x
-));
-if (distToEnd > 1.0) {
-if (!(pathStyle.dashGapPickable && bool(picking.isActive))) {
-discard;
+)) > 1.0;
 }
+if (inGap && !pathStyle.dashGapPickable) {
+shouldDiscardDash = true;
 }
+} else if (path.capType <= 0.5) {
+dashCoverage = dashPatternCoverage(alongPath, solidLength, unitLength, filterWidth);
+} else {
+float distanceAlongGap = min(unitOffset - solidLength, unitLength - unitOffset);
+float distanceToEnd = length(vec2(max(distanceAlongGap, 0.0), vPathPosition.x));
+float capEdgePixels = (1.0 - distanceToEnd) / max(fwidth(distanceToEnd), 1e-6);
+if (distanceAlongGap > 0.0) {
+inRoundedDashGap = true;
+roundedDashResolvedCoverage = smoothedge(0.0, capEdgePixels);
+dashCoverage = roundedDashResolvedCoverage;
 }
+float subPixelBlend = smoothstep(unitLength, 2.0 * unitLength, filterWidth);
+roundedDashSubPixelBlend = subPixelBlend;
+float boundedSolidLength = min(solidLength, unitLength);
+float effectiveGap = max(unitLength - boundedSolidLength, 0.0);
+float capSpan = 2.0 * sqrt(max(1.0 - vPathPosition.x * vPathPosition.x, 0.0));
+float roundedDutyCycle = clamp(
+(boundedSolidLength + min(effectiveGap, capSpan)) / unitLength,
+0.0,
+1.0
+);
+roundedDashDutyCycle = roundedDutyCycle;
+dashCoverage = mix(dashCoverage, roundedDutyCycle, subPixelBlend);
 }
+dashCoverage = clamp(dashCoverage, 0.0, 1.0);
+shouldDiscardDash = shouldDiscardDash || dashCoverage <= 0.0;
+}
+`,
+        'fs:#main-end': `
+#ifdef ANTIALIASING
+if (inRoundedDashGap) {
+float pathCoverage = smoothedge(0.0, edgePixels);
+float resolvedCapMultiplier =
+min(pathCoverage, roundedDashResolvedCoverage) / max(pathCoverage, 1e-6);
+dashCoverage = mix(
+resolvedCapMultiplier,
+roundedDashDutyCycle,
+roundedDashSubPixelBlend
+);
+}
+#endif
+if (shouldDiscardDash) {
+discard;
 }
+fragColor.a *= dashCoverage;
 `
     }
 };
@@ -266,13 +362,32 @@ float offsetDir = sign(instanceOffsets);
 vPathPosition.x = (vPathPosition.x + offsetDir) * offsetWidth - offsetDir;
 vPathPosition.y *= offsetWidth;
 vPathLength *= offsetWidth;
+#ifdef DASH_ENABLED
+if (pathStyle.dashUnits != 0) {
+vDashArray *= offsetWidth;
+}
+vPathBounds *= offsetWidth;
+#ifdef HIGH_PRECISION_DASH
+vDashPathLength *= offsetWidth;
+float restoredDashUnitLength = vDashArray.x + vDashArray.y;
+float restoredDashPeriod = pathStyle.dashAlignMode == 0.0
+? restoredDashUnitLength
+: vDashPathLength /
+max(round(vDashPathLength / max(restoredDashUnitLength, 0.0001)), 1.0);
+vDashOffset = restoredDashPeriod > 0.0
+? mod(dashOffsetAndLength.x * offsetWidth, restoredDashPeriod)
+: 0.0;
+#else
+vDashOffset *= offsetWidth;
+#endif
+#endif
 `,
-        'fs:#main-start': `
-float isInside;
-isInside = step(-1.0, vPathPosition.x) * step(vPathPosition.x, 1.0);
-if (isInside == 0.0) {
+        'fs:#main-end': `
+#ifndef ANTIALIASING
+if (abs(vPathPosition.x) > 1.0) {
 discard;
 }
+#endif
 `
     }
 };

package/dist/path-style/shaders.glsl.js.map

@@ -1 +1 @@
-{"version":3,"file":"shaders.glsl.js","sourceRoot":"","sources":["../../src/path-style/shaders.glsl.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAUpC,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,MAAM,EAAE;QACN,UAAU,EAAE;;;;;;;CAOf;QAEG,cAAc,EAAE;;;;;;;CAOnB;QAEG,UAAU;;;;;;;CAQb;QAEG,0DAA0D;QAC1D,sDAAsD;QACtD,6CAA6C;QAC7C,aAAa;QACb,oBAAoB;QACpB,mEAAmE;QACnE,kEAAkE;QAClE,mEAAmE;QACnE,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCnB;KACE;CACF,CAAC;AAEF,MAAM,CAAC,MAAM,sBAAsB,GAAG;IACpC,MAAM,EAAE;QACN,UAAU,EAAE;;;CAGf;QAEG,cAAc,EAAE;;CAEnB;QAEG,UAAU;;;;;;CAQb;QAEG,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;CAwBnB;QAEG,cAAc;;;;;;;CAOjB;KACE;CACF,CAAC;AAEF,MAAM,CAAC,MAAM,yBAAyB,GAAG;IACvC,MAAM,EAAE;QACN,UAAU,EAAE;;;CAGf;QAEG,cAAc,EAAE;;CAEnB;QAEG,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkGb;QAEG,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BnB;QAEG,cAAc;;;;;;;CAOjB;KACE;CACF,CAAC;AAEF,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,MAAM,EAAE;QACN,UAAU,EAAE;;CAEf;QACG,uBAAuB;;;CAG1B;QACG,cAAc;;;;;;CAMjB;QACG,gBAAgB;;;;;;CAMnB;KACE;CACF,CAAC"}
+{"version":3,"file":"shaders.glsl.js","sourceRoot":"","sources":["../../src/path-style/shaders.glsl.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAsCpC,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,MAAM,EAAE;QACN,UAAU;;;;;;;;;;;;;CAkBb;QAEG,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;CAwDjB;QAEG,UAAU;;;;;;;;;;;;;;;;;;;;;;;;CA0Cb;QAEG,0DAA0D;QAC1D,sDAAsD;QACtD,6CAA6C;QAC7C,aAAa;QACb,oBAAoB;QACpB,mEAAmE;QACnE,kEAAkE;QAClE,mEAAmE;QACnE,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoGnB;QAEG,cAAc;;;;;;;;;;;;;;;;;CAwBjB;KACE;CACF,CAAC;AAEF,MAAM,CAAC,MAAM,sBAAsB,GAAG;IACpC,MAAM,EAAE;QACN,UAAU,EAAE;;;CAGf;QAEG,cAAc,EAAE;;CAEnB;QAEG,UAAU;;;;;;CAQb;QAEG,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;CAwBnB;QAEG,cAAc;;;;;;;CAOjB;KACE;CACF,CAAC;AAEF,MAAM,CAAC,MAAM,yBAAyB,GAAG;IACvC,MAAM,EAAE;QACN,UAAU,EAAE;;;CAGf;QAEG,cAAc,EAAE;;CAEnB;QAEG,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkGb;QAEG,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BnB;QAEG,cAAc;;;;;;;CAOjB;KACE;CACF,CAAC;AAEF,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,MAAM,EAAE;QACN,UAAU,EAAE;;CAEf;QACG,uBAAuB;;;CAG1B;QACG,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;CAgCjB;QACG,cAAc;;;;;;CASjB;KACE;CACF,CAAC"}

package/dist/terrain/shader-module.d.ts

@@ -34,6 +34,7 @@ export declare const terrainModule: {
         readonly name: "project";
         readonly dependencies: [{
             name: string;
+            source: string;
             vs: string;
         }, {
             readonly name: "geometry";
@@ -64,8 +65,22 @@ export declare const terrainModule: {
             readonly pseudoMeters: "f32";
         };
     }];
-    readonly vs: `${string}\nout vec3 commonPos;\n// In globe mode, absolute Mercator position for terrain FBO UV lookups\nout vec2 terrainMercPos;\nout float terrainHeight;\n\nvec2 terrain_globe_to_mercator(vec3 globePosition) {\n  float D = length(globePosition);\n  float sinLat = clamp(globePosition.z / D, -0.999998, 0.999998);\n  float x = atan(globePosition.x, -globePosition.y);\n  float y = atanh(sinLat);\n  return (vec2(x, y) + PI) * WORLD_SCALE;\n}\n`;
-    readonly fs: `${string}in vec2 terrainMercPos;\nin float terrainHeight;`;
+    readonly vs: `${string}
+out vec3 commonPos;
+// In globe mode, absolute Mercator position for terrain FBO UV lookups
+out vec2 terrainMercPos;
+out float terrainHeight;
+
+vec2 terrain_globe_to_mercator(vec3 globePosition) {
+  float D = length(globePosition);
+  float sinLat = clamp(globePosition.z / D, -0.999998, 0.999998);
+  float x = atan(globePosition.x, -globePosition.y);
+  float y = atanh(sinLat);
+  return (vec2(x, y) + PI) * WORLD_SCALE;
+}
+`;
+    readonly fs: `${string}in vec2 terrainMercPos;
+in float terrainHeight;`;
     readonly inject: {
         readonly 'vs:#main-start': "\nif (terrain.mode == TERRAIN_MODE_SKIP) {\n  gl_Position = vec4(0.0);\n  return;\n}\n";
         readonly 'vs:DECKGL_FILTER_GL_POSITION': "\ncommonPos = geometry.position.xyz;\nterrainHeight = commonPos.z + project.commonOrigin.z;\nif (project.projectionMode == PROJECTION_MODE_GLOBE) {\n  terrainMercPos = terrain_globe_to_mercator(commonPos);\n  terrainHeight = length(commonPos) - GLOBE_RADIUS;\n} else {\n  terrainMercPos = commonPos.xy;\n}\nif (terrain.mode == TERRAIN_MODE_WRITE_HEIGHT_MAP) {\n  vec2 texCoords = (terrainMercPos - terrain.bounds.xy) / terrain.bounds.zw;\n  position = vec4(texCoords * 2.0 - 1.0, 0.0, 1.0);\n}\nif (terrain.mode == TERRAIN_MODE_USE_HEIGHT_MAP) {\n  vec3 anchor = geometry.worldPosition;\n  anchor.z = 0.0;\n  vec3 anchorCommon = project_position(anchor);\n  vec2 anchorMercPos = project.projectionMode == PROJECTION_MODE_GLOBE\n    ? terrain_globe_to_mercator(anchorCommon)\n    : anchorCommon.xy;\n  vec2 texCoords = (anchorMercPos - terrain.bounds.xy) / terrain.bounds.zw;\n  if (texCoords.x >= 0.0 && texCoords.y >= 0.0 && texCoords.x <= 1.0 && texCoords.y <= 1.0) {\n    float terrainZ = texture(terrain_map, texCoords).r;\n    if (project.projectionMode == PROJECTION_MODE_GLOBE) {\n      // Height map is written in Mercator common space (units = TILE_SIZE / EARTH_CIRCUMFERENCE / cos(lat))\n      // Convert to globe radial units (units = GLOBE_RADIUS / EARTH_RADIUS)\n      terrainZ *= cos(radians(geometry.worldPosition.y)) * PI;\n      geometry.position.xyz += normalize(geometry.position.xyz) * terrainZ;\n    } else {\n      geometry.position.z += terrainZ;\n    }\n    position = project_common_position_to_clipspace(geometry.position);\n  }\n}\n    ";

package/dist/terrain/shader-module.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader-module.d.ts","sourceRoot":"","sources":["../../src/terrain/shader-module.ts"],"names":[],"mappings":"AAOA,OAAO,EAAU,YAAY,EAAkB,MAAM,eAAe,CAAC;AAErE,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,eAAe,CAAC;AAC3C,OAAO,KAAK,EAAC,MAAM,EAAC,qCAAkC;AACtD,OAAO,KAAK,EAAC,YAAY,EAAC,2BAAwB;AAElD,8DAA8D;AAC9D,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,EAAE,YAAY,CAAC;IACtB,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,EAAE,OAAO,GAAG,IAAI,CAAC;IAC1B,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,cAAc,EAAE,OAAO,CAAC;IACxB,YAAY,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;IACnC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B,CAAC;AAWF,kDAAkD;AAClD,eAAO,MAAM,YAAY;;IAEvB,6EAA6E;;IAE7E,2EAA2E;;IAE3E,6FAA6F;;IAE7F,0EAA0E;;IAE1E,mEAAmE;;CAEpE,CAAC;AAkBF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAiFJ,OAAO,CAAC,kBAAkB,CAAC;;;;;;;;;;;;;CA+EkD,CAAC"}
+{"version":3,"file":"shader-module.d.ts","sourceRoot":"","sources":["../../src/terrain/shader-module.ts"],"names":[],"mappings":"AAOA,OAAO,EAAU,YAAY,EAAkB,MAAM,eAAe,CAAC;AAErE,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,eAAe,CAAC;AAC3C,OAAO,KAAK,EAAC,MAAM,EAAC,qCAAkC;AACtD,OAAO,KAAK,EAAC,YAAY,EAAC,2BAAwB;AAElD,8DAA8D;AAC9D,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,EAAE,YAAY,CAAC;IACtB,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,EAAE,OAAO,GAAG,IAAI,CAAC;IAC1B,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,cAAc,EAAE,OAAO,CAAC;IACxB,YAAY,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;IACnC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B,CAAC;AAWF,kDAAkD;AAClD,eAAO,MAAM,YAAY;;IAEvB,6EAA6E;;IAE7E,2EAA2E;;IAE3E,6FAA6F;;IAE7F,0EAA0E;;IAE1E,mEAAmE;;CAEpE,CAAC;AAkBF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAiFJ,OAAO,CAAC,kBAAkB,CAAC;;;;;;;;;;;;;CA+EkD,CAAC"}

package/dist/utils/debug.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"debug.d.ts","sourceRoot":"","sources":["../../src/utils/debug.ts"],"names":[],"mappings":"AAMA,OAAO,EAAC,WAAW,EAAC,MAAM,eAAe,CAAC;AAE1C,qDAAqD;AAErD,eAAO,MAAM,QAAQ,QACd,WAAW,wBACG;IAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAAC,SAkDzD,CAAC"}
+{"version":3,"file":"debug.d.ts","sourceRoot":"","sources":["../../src/utils/debug.ts"],"names":[],"mappings":"AAMA,OAAO,EAAC,WAAW,EAAC,MAAM,eAAe,CAAC;AAE1C,qDAAqD;AAErD,eAAO,MAAM,QAAQ,GACnB,KAAK,WAAW,EAChB,sBAAmB;IAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAAM,SAkD9D,CAAC"}