@deck.gl/aggregation-layers 9.4.0-beta.1 → 9.4.0-beta.3

package/dist.webgl-only/index.cjs

@@ -759,7 +759,7 @@ fn project_mercator_(lnglat: vec2<f32>) -> vec2<f32> {
   let y = clamp(lnglat.y, -89.9, 89.9);
   return vec2<f32>(
     radians(x) + PI,
-    PI + log(tan(PI * 0.25 + radians(y) * 0.5))
+    PI + log(tan_fp32(PI * 0.25 + radians(y) * 0.5))
   ) * WORLD_SCALE;
 }
 
@@ -1739,8 +1739,8 @@ var _Viewport = class _Viewport {
     }
     return PROJECTION_MODE.IDENTITY;
   }
-  // Two viewports are equal if width and height are identical, and if
-  // their view and projection matrices are (approximately) equal.
+  // Two viewports are equal if their dimensions, common-space scale, and
+  // view and projection matrices are (approximately) equal.
   equals(viewport) {
     if (!(viewport instanceof _Viewport)) {
       return false;
@@ -1748,7 +1748,7 @@ var _Viewport = class _Viewport {
     if (this === viewport) {
       return true;
     }
-    return viewport.width === this.width && viewport.height === this.height && viewport.scale === this.scale && (0, import_core3.equals)(viewport.projectionMatrix, this.projectionMatrix) && (0, import_core3.equals)(viewport.viewMatrix, this.viewMatrix);
+    return viewport.width === this.width && viewport.height === this.height && viewport.scale === this.scale && viewport.projectionMode === this.projectionMode && viewport.resolution === this.resolution && (0, import_core3.equals)(viewport.distanceScales.unitsPerMeter, this.distanceScales.unitsPerMeter) && (0, import_core3.equals)(viewport.projectionMatrix, this.projectionMatrix) && (0, import_core3.equals)(viewport.viewMatrix, this.viewMatrix);
   }
   /**
    * Projects xyz (possibly latitude and longitude) to pixel coordinates in window
@@ -2085,6 +2085,10 @@ var _WebMercatorViewport = class _WebMercatorViewport extends Viewport {
     }
     return this._subViewports;
   }
+  /** Returns whether two Web Mercator viewports use the same projection settings. */
+  equals(viewport) {
+    return viewport instanceof _WebMercatorViewport && viewport._pseudoMeters === this._pseudoMeters && super.equals(viewport);
+  }
   projectPosition(xyz) {
     if (this._pseudoMeters) {
       return super.projectPosition(xyz);
@@ -3242,6 +3246,7 @@ var DataColumn = class {
       this._buffer = null;
     }
     typed_array_manager_default.release(this.state.allocatedValue);
+    this.state.allocatedValue = null;
   }
   getBuffer() {
     if (this.state.constant && this.device.type !== "webgpu") {
@@ -4191,6 +4196,7 @@ ${getComputeBlock(module2.name, inputEntries, output, elementWise, expression)}
   );
   const computation = new import_engine.Computation(outputBuffer.device, {
     source: source4,
+    modules: module2.dependencies,
     shaderAssembler: GPGPU_SHADER_ASSEMBLER,
     shaderLayout: {
       bindings: [
@@ -10515,6 +10521,25 @@ var PathTesselator = class extends Tesselator {
   get(attributeName) {
     return this.attributes[attributeName];
   }
+  /** Get rendered segment indexes in source traversal order. */
+  getPathSegmentIndices(dataIndex) {
+    const segmentTypes = this.attributes.segmentTypes;
+    const rowStart = this.vertexStarts[dataIndex];
+    const rowEnd = Math.min(
+      this.vertexStarts[dataIndex + 1] ?? this.instanceCount,
+      this.instanceCount
+    );
+    const result = [];
+    for (let segmentIndex = rowStart; segmentIndex < rowEnd - 1; segmentIndex++) {
+      if ((segmentTypes[segmentIndex] & INVALID) === 0) {
+        result.push(segmentIndex);
+      }
+    }
+    if (result.length && (segmentTypes[rowStart] & INVALID) !== 0) {
+      result.unshift(result.pop());
+    }
+    return result;
+  }
   /* Implement base Tesselator interface */
   getGeometryFromBuffer(buffer) {
     if (this.normalize || this.opts.isWebGPU) {
@@ -10710,6 +10735,9 @@ struct Varyings {
   @location(5) vJointType: f32,
   // Location 6 is reserved for TripsLayer's injected vTime varying.
   @location(7) clipCoordinates: vec2<f32>,
+#ifdef DASH_ENABLED
+  @location(8) vPathBounds: vec2<f32>,
+#endif
 };
 
 fn flipIfTrue(flag: bool) -> f32 {
@@ -10724,11 +10752,34 @@ fn clipLine(position: vec4<f32>, refPosition: vec4<f32>) -> vec4<f32> {
   return position;
 }
 
+#ifdef DASH_ENABLED
+// Return the visible interval of the original segment before clipLine moves either endpoint.
+fn getClippedPathRange(startW: f32, endW: f32) -> vec2<f32> {
+  let startClipped = startW < EPSILON;
+  let endClipped = endW < EPSILON;
+  if (startClipped && endClipped) {
+    return vec2<f32>(0.0, 0.0);
+  }
+  if (startClipped || endClipped) {
+    let intersection = clamp((EPSILON - startW) / (endW - startW), 0.0, 1.0);
+    if (startClipped) {
+      return vec2<f32>(intersection, 1.0);
+    }
+    return vec2<f32>(0.0, intersection);
+  }
+  return vec2<f32>(0.0, 1.0);
+}
+#endif
+
 fn getLineJoinOffset(
   prevPoint: vec3<f32>,
   currPoint: vec3<f32>,
   nextPoint: vec3<f32>,
   width: vec2<f32>,
+#ifdef DASH_ENABLED
+  sourcePathLength: f32,
+  sourcePathRange: vec2<f32>,
+#endif
 #ifdef ANTIALIASING
   coverageScale: f32,
 #endif
@@ -10765,7 +10816,43 @@ fn getLineJoinOffset(
   let miterVec = vec2<f32>(-tangent.y, tangent.x);
   let dir = select(dirB, dirA, isEnd);
   let perp = select(perpB, perpA, isEnd);
+#ifdef DASH_ENABLED
+  let segmentLength2D = select(lenB, lenA, isEnd);
+
+  // Extrusion happens in the XY plane, so segmentLength2D is a 2D length and pathPosition.y
+  // below measures 2D distance along the segment. For a path that also moves in Z the true
+  // arc length is longer by this ratio. Scaling pathLength and pathPosition.y by it makes
+  // the coordinate measure real 3D distance while leaving the joint tests unchanged, since
+  // they compare the two against each other and both are scaled alike. Billboard mode
+  // extrudes in clip space, where the perspective divide has already reduced the segment to
+  // its screen projection, so its complete common-space length is supplied by the caller.
+  // Mirrors path-layer-vertex.glsl.ts.
+  let currDelta3 = select(deltaB3, deltaA3, isEnd);
+  let currLength2D = length(currDelta3.xy);
+  // Do not clamp a valid denominator to EPSILON: high-zoom Web Mercator deltas are often
+  // smaller than that in common space, and changing their scale corrupts even flat paths.
+  let safeLength2D = select(1.0, currLength2D, currLength2D > 0.0);
+  var arcLengthRatio = 1.0;
+  var pathPositionOffset = 0.0;
+  var pathLength = segmentLength2D;
+  if (path.billboard != 0.0) {
+    // clipLine may shorten the visible screen-space segment. Preserve the corresponding interval
+    // of the complete common-space arclength instead of compressing the full dash period into the
+    // visible span. Keep pathLength complete so justification is stable as the camera clips it.
+    let visiblePathLength = sourcePathLength * (sourcePathRange.y - sourcePathRange.x);
+    arcLengthRatio = 0.0;
+    if (segmentLength2D > 0.0) {
+      arcLengthRatio = visiblePathLength / segmentLength2D;
+    }
+    pathPositionOffset = sourcePathLength * sourcePathRange.x;
+    pathLength = sourcePathLength;
+  } else if (currLength2D > 0.0) {
+    arcLengthRatio = length(currDelta3) / safeLength2D;
+    pathLength = segmentLength2D * arcLengthRatio;
+  }
+#else
   let pathLength = select(lenB, lenA, isEnd);
+#endif
 
   let sinHalfA = abs(dot(miterVec, perp));
   let cosHalfA = abs(dot(dirA, miterVec));
@@ -10812,7 +10899,11 @@ fn getLineJoinOffset(
 #endif
   let pathPosition = vec2<f32>(
     dot(offsetFromStartOfPath, perp),
+#ifdef DASH_ENABLED
+    pathPositionOffset + dot(offsetFromStartOfPath, dir) * arcLengthRatio
+#else
     dot(offsetFromStartOfPath, dir)
+#endif
   );
   let isValid = step(f32(instanceTypes), 3.5);
 #ifdef ANTIALIASING
@@ -10871,15 +10962,38 @@ fn vertexMain(attributes: Attributes) -> Varyings {
     ) / 2.0;
 
   if (path.billboard != 0.0) {
-    var prevPositionScreen = project_position_to_clipspace(prevPosition, prevPosition64Low, ZERO_OFFSET);
+#ifdef DASH_ENABLED
+    let prevProjection = project_position_to_clipspace_and_commonspace(
+      prevPosition, prevPosition64Low, ZERO_OFFSET
+    );
+    let nextProjection = project_position_to_clipspace_and_commonspace(
+      nextPosition, nextPosition64Low, ZERO_OFFSET
+    );
+    let prevPositionCommon = prevProjection.commonPosition.xyz;
+    let nextPositionCommon = nextProjection.commonPosition.xyz;
+    var prevPositionScreen = prevProjection.clipPosition;
+    var nextPositionScreen = nextProjection.clipPosition;
+#else
+    var prevPositionScreen = project_position_to_clipspace(
+      prevPosition, prevPosition64Low, ZERO_OFFSET
+    );
+    var nextPositionScreen = project_position_to_clipspace(
+      nextPosition, nextPosition64Low, ZERO_OFFSET
+    );
+#endif
     let currProjection = project_position_to_clipspace_and_commonspace(
-      currPosition,
-      currPosition64Low,
-      ZERO_OFFSET
+      currPosition, currPosition64Low, ZERO_OFFSET
     );
     geometry.position = currProjection.commonPosition;
     var currPositionScreen = currProjection.clipPosition;
-    var nextPositionScreen = project_position_to_clipspace(nextPosition, nextPosition64Low, ZERO_OFFSET);
+#ifdef DASH_ENABLED
+    let currPositionCommon = currProjection.commonPosition.xyz;
+    let sourcePathStartScreen = mix(currPositionScreen, prevPositionScreen, isEnd);
+    let sourcePathEndScreen = mix(nextPositionScreen, currPositionScreen, isEnd);
+    let billboardPathRange = getClippedPathRange(
+      sourcePathStartScreen.w, sourcePathEndScreen.w
+    );
+#endif
 
     prevPositionScreen = clipLine(prevPositionScreen, currPositionScreen);
     nextPositionScreen = clipLine(nextPositionScreen, currPositionScreen);
@@ -10891,18 +11005,39 @@ fn vertexMain(attributes: Attributes) -> Varyings {
       (widthPixels + 0.5 / project.devicePixelRatio) / max(widthPixels, 1e-6),
       widthPixels > 0.0
     );
+#endif
+#ifdef DASH_ENABLED
+    let currentDeltaCommon = select(
+      nextPositionCommon - currPositionCommon,
+      currPositionCommon - prevPositionCommon,
+      isEnd > 0.0
+    );
+    let billboardPathLength = select(
+      0.0,
+      length(currentDeltaCommon) * project.scale / (widthPixels * project.focalDistance),
+      widthPixels > 0.0
+    );
 #endif
     let join = getLineJoinOffset(
       prevPositionScreen.xyz / prevPositionScreen.w,
       currPositionScreen.xyz / currPositionScreen.w,
       nextPositionScreen.xyz / nextPositionScreen.w,
       project_pixel_size_to_clipspace(vec2<f32>(widthPixels, widthPixels)),
+#ifdef DASH_ENABLED
+      billboardPathLength,
+      billboardPathRange,
+#endif
 #ifdef ANTIALIASING
       coverageScale,
 #endif
       attributes.positions,
       attributes.instanceTypes
     );
+#ifdef DASH_ENABLED
+    // Phase and justification use the complete source segment, while cap and joint coverage
+    // must still recognize the endpoints moved by clipLine.
+    varyings.vPathBounds = billboardPathLength * billboardPathRange;
+#endif
 
     geometry.uv = join.pathPosition;
     varyings.position = vec4<f32>(
@@ -10935,12 +11070,19 @@ fn vertexMain(attributes: Attributes) -> Varyings {
       currPositionCommon,
       nextPositionCommon,
       width,
+#ifdef DASH_ENABLED
+      1.0,
+      vec2<f32>(0.0, 1.0),
+#endif
 #ifdef ANTIALIASING
       coverageScale,
 #endif
       attributes.positions,
       attributes.instanceTypes
     );
+#ifdef DASH_ENABLED
+    varyings.vPathBounds = vec2<f32>(0.0, join.pathLength);
+#endif
 
     geometry.position = vec4<f32>(currPositionCommon + join.offset, 1.0);
     geometry.uv = join.pathPosition;
@@ -10971,7 +11113,13 @@ fn fragmentMain(varyings: Varyings) -> @location(0) vec4<f32> {
   // bounded by the corner offset, everywhere else by the edge of the stroke. Dividing by the
   // screen-space derivative converts the distance to the boundary into device pixels, which stays
   // correct under perspective foreshortening and under extensions that rescale the stroke.
+#ifdef DASH_ENABLED
+  let isCorner =
+    varyings.vPathPosition.y < varyings.vPathBounds.x ||
+    varyings.vPathPosition.y > varyings.vPathBounds.y;
+#else
   let isCorner = varyings.vPathPosition.y < 0.0 || varyings.vPathPosition.y > varyings.vPathLength;
+#endif
   let isRound = varyings.vJointType > 0.5;
 
   // Distance to the silhouette in device pixels, from the derivative of the coordinate that
@@ -10982,7 +11130,13 @@ fn fragmentMain(varyings: Varyings) -> @location(0) vec4<f32> {
   // Both evaluated so each derivative stays on one field across the corner/body boundary
   let bodyPixels = (1.0 - bodyCoord) / max(fwidth(bodyCoord), 1e-6);
   let cornerPixels = (1.0 - cornerCoord) / max(fwidth(cornerCoord), 1e-6);
+#ifdef PATH_STYLE_OFFSET
+  // Rounded corners still intersect the stroke-width envelope. Extensions may remap
+  // vPathPosition.x independently of vCornerOffset, as PathStyleExtension does for offsets.
+  let edgePixels = select(bodyPixels, min(cornerPixels, bodyPixels), isRound && isCorner);
+#else
   let edgePixels = select(bodyPixels, cornerPixels, isRound && isCorner);
+#endif
 
   // Fragments outside the coverage ramp must not write depth or picking colors.
   if (edgePixels <= -SMOOTH_EDGE_RADIUS) {
@@ -11000,11 +11154,18 @@ fn fragmentMain(varyings: Varyings) -> @location(0) vec4<f32> {
   // Feather one device pixel across the width only, before premultiplication. edgePixels is a
   // signed device-pixel distance and SMOOTH_EDGE_RADIUS is 0.5, so this ramps across one pixel.
   color.a *= smoothedge(0.0, edgePixels);
+#else
+#ifdef DASH_ENABLED
+  if (
+    varyings.vPathPosition.y < varyings.vPathBounds.x ||
+    varyings.vPathPosition.y > varyings.vPathBounds.y
+  ) {
 #else
   if (
     varyings.vPathPosition.y < 0.0 ||
     varyings.vPathPosition.y > varyings.vPathLength
   ) {
+#endif
     if (varyings.vJointType > 0.5 && length(varyings.vCornerOffset) > 1.0) {
       discard;
     }
@@ -11057,6 +11218,9 @@ out float vMiterLength;
 out vec2 vPathPosition;
 out float vPathLength;
 out float vJointType;
+#ifdef DASH_ENABLED
+out vec2 vPathBounds;
+#endif
 
 const float EPSILON = 0.001;
 const vec3 ZERO_OFFSET = vec3(0.0);
@@ -11069,6 +11233,9 @@ float flipIfTrue(bool flag) {
 vec3 getLineJoinOffset(
   vec3 prevPoint, vec3 currPoint, vec3 nextPoint,
   vec2 width
+#ifdef DASH_ENABLED
+  , float sourcePathLength, vec2 sourcePathRange
+#endif
 #ifdef ANTIALIASING
   , float coverageScale
 #endif
@@ -11111,6 +11278,37 @@ vec3 getLineJoinOffset(
   // length of the segment
   float L = isEnd ? lenA : lenB;
 
+#ifdef DASH_ENABLED
+  // Extrusion happens in the XY plane, so L above is a 2D length and vPathPosition.y below
+  // measures 2D distance along the segment. For a path that also moves in Z the true arc
+  // length is longer by this ratio. Scaling vPathLength and vPathPosition.y by it makes the
+  // coordinate measure real 3D distance - which is what CPU-side dash offsets accumulate -
+  // while leaving the joint tests in the fragment shader unchanged, since they compare the
+  // two against each other and both are scaled alike.
+  // Billboard mode extrudes in clip space, where the perspective divide has already reduced
+  // the segment to its screen projection, so its complete common-space length is supplied by
+  // the caller.
+  vec3 currDelta3 = isEnd ? deltaA3 : deltaB3;
+  float currLength2D = length(currDelta3.xy);
+  float arcLengthRatio = 1.0;
+  float pathPositionOffset = 0.0;
+  float pathLength = L;
+  if (path.billboard) {
+    // clipLine may shorten the visible screen-space segment. Preserve the corresponding interval
+    // of the complete common-space arclength instead of compressing the full dash period into the
+    // visible span. Keep pathLength complete so justification is stable as the camera clips it.
+    float visiblePathLength = sourcePathLength * (sourcePathRange.y - sourcePathRange.x);
+    arcLengthRatio = L > 0.0 ? visiblePathLength / L : 0.0;
+    pathPositionOffset = sourcePathLength * sourcePathRange.x;
+    pathLength = sourcePathLength;
+  } else if (currLength2D > 0.0) {
+    // Do not clamp a valid denominator to EPSILON: high-zoom Web Mercator deltas are often
+    // smaller than that in common space, and changing their scale corrupts even flat paths.
+    arcLengthRatio = length(currDelta3) / currLength2D;
+    pathLength = L * arcLengthRatio;
+  }
+#endif
+
   // A = angle of the corner
   float sinHalfA = abs(dot(miterVec, perp));
   float cosHalfA = abs(dot(dirA, miterVec));
@@ -11152,7 +11350,11 @@ vec3 getLineJoinOffset(
   // The physical stroke still ends at offsetVec; the scaled coordinates and vertices only extend
   // its rasterized envelope to include the outer half of the centered coverage ramp.
   vec2 coverageOffsetVec = offsetVec * coverageScale;
+#ifdef DASH_ENABLED
+  vPathLength = pathLength;
+#else
   vPathLength = L;
+#endif
   vCornerOffset = coverageOffsetVec;
   vMiterLength = dot(vCornerOffset, miterVec * turnDirection);
   vMiterLength = isCap ? isJoint : vMiterLength;
@@ -11160,7 +11362,11 @@ vec3 getLineJoinOffset(
   vec2 offsetFromStartOfPath = coverageOffsetVec + deltaA * float(isEnd);
   vPathPosition = vec2(
     dot(offsetFromStartOfPath, perp),
+#ifdef DASH_ENABLED
+    pathPositionOffset + dot(offsetFromStartOfPath, dir) * arcLengthRatio
+#else
     dot(offsetFromStartOfPath, dir)
+#endif
   );
   geometry.uv = vPathPosition;
 
@@ -11168,7 +11374,11 @@ vec3 getLineJoinOffset(
   vec3 offset = vec3(coverageOffsetVec * width * isValid, 0.0);
 #else
   // Generate variables for fragment shader
+#ifdef DASH_ENABLED
+  vPathLength = pathLength;
+#else
   vPathLength = L;
+#endif
   vCornerOffset = offsetVec;
   vMiterLength = dot(vCornerOffset, miterVec * turnDirection);
   vMiterLength = isCap ? isJoint : vMiterLength;
@@ -11176,7 +11386,11 @@ vec3 getLineJoinOffset(
   vec2 offsetFromStartOfPath = vCornerOffset + deltaA * float(isEnd);
   vPathPosition = vec2(
     dot(offsetFromStartOfPath, perp),
+#ifdef DASH_ENABLED
+    pathPositionOffset + dot(offsetFromStartOfPath, dir) * arcLengthRatio
+#else
     dot(offsetFromStartOfPath, dir)
+#endif
   );
   geometry.uv = vPathPosition;
 
@@ -11198,6 +11412,22 @@ void clipLine(inout vec4 position, vec4 refPosition) {
   }
 }
 
+#ifdef DASH_ENABLED
+// Return the visible interval of the original segment before clipLine moves either endpoint.
+vec2 getClippedPathRange(float startW, float endW) {
+  bool startClipped = startW < EPSILON;
+  bool endClipped = endW < EPSILON;
+  if (startClipped && endClipped) {
+    return vec2(0.0);
+  }
+  if (startClipped || endClipped) {
+    float intersection = clamp((EPSILON - startW) / (endW - startW), 0.0, 1.0);
+    return startClipped ? vec2(intersection, 1.0) : vec2(0.0, intersection);
+  }
+  return vec2(0.0, 1.0);
+}
+#endif
+
 void main() {
   geometry.pickingColor = picking_getPickingColorFromIndex(rowIndexes);
 
@@ -11222,9 +11452,35 @@ void main() {
 
   if (path.billboard) {
     // Extrude in clipspace
-    vec4 prevPositionScreen = project_position_to_clipspace(prevPosition, prevPosition64Low, ZERO_OFFSET);
+#ifdef DASH_ENABLED
+    vec4 prevPositionCommon;
+    vec4 nextPositionCommon;
+    vec4 prevPositionScreen = project_position_to_clipspace(
+      prevPosition, prevPosition64Low, ZERO_OFFSET, prevPositionCommon
+    );
+#else
+    vec4 prevPositionScreen = project_position_to_clipspace(
+      prevPosition, prevPosition64Low, ZERO_OFFSET
+    );
+#endif
     vec4 currPositionScreen = project_position_to_clipspace(currPosition, currPosition64Low, ZERO_OFFSET, geometry.position);
-    vec4 nextPositionScreen = project_position_to_clipspace(nextPosition, nextPosition64Low, ZERO_OFFSET);
+#ifdef DASH_ENABLED
+    vec4 nextPositionScreen = project_position_to_clipspace(
+      nextPosition, nextPosition64Low, ZERO_OFFSET, nextPositionCommon
+    );
+#else
+    vec4 nextPositionScreen = project_position_to_clipspace(
+      nextPosition, nextPosition64Low, ZERO_OFFSET
+    );
+#endif
+
+#ifdef DASH_ENABLED
+    vec4 sourcePathStartScreen = mix(currPositionScreen, prevPositionScreen, isEnd);
+    vec4 sourcePathEndScreen = mix(nextPositionScreen, currPositionScreen, isEnd);
+    vec2 billboardPathRange = getClippedPathRange(
+      sourcePathStartScreen.w, sourcePathEndScreen.w
+    );
+#endif
 
     clipLine(prevPositionScreen, currPositionScreen);
     clipLine(nextPositionScreen, currPositionScreen);
@@ -11239,16 +11495,34 @@ void main() {
       : 1.0;
 #endif
 
+#ifdef DASH_ENABLED
+    vec3 currentDeltaCommon = isEnd > 0.0
+      ? geometry.position.xyz - prevPositionCommon.xyz
+      : nextPositionCommon.xyz - geometry.position.xyz;
+    float billboardPathLength = width.x > 0.0
+      ? length(currentDeltaCommon) * project.scale / (width.x * project.focalDistance)
+      : 0.0;
+#endif
+
     vec3 offset = getLineJoinOffset(
       prevPositionScreen.xyz / prevPositionScreen.w,
       currPositionScreen.xyz / currPositionScreen.w,
       nextPositionScreen.xyz / nextPositionScreen.w,
       project_pixel_size_to_clipspace(width.xy)
+#ifdef DASH_ENABLED
+      ,
+      billboardPathLength, billboardPathRange
+#endif
 #ifdef ANTIALIASING
       ,
       coverageScale
 #endif
     );
+#ifdef DASH_ENABLED
+    // Phase and justification use the complete source segment, while cap and joint coverage
+    // must still recognize the endpoints moved by clipLine.
+    vPathBounds = billboardPathLength * billboardPathRange;
+#endif
 
     DECKGL_FILTER_GL_POSITION(currPositionScreen, geometry);
     gl_Position = vec4(currPositionScreen.xyz + offset * currPositionScreen.w, currPositionScreen.w);
@@ -11269,10 +11543,16 @@ void main() {
 
     vec3 offset = getLineJoinOffset(
       prevPosition, currPosition, nextPosition, width.xy
+#ifdef DASH_ENABLED
+      , 1.0, vec2(0.0, 1.0)
+#endif
 #ifdef ANTIALIASING
       , coverageScale
 #endif
     );
+#ifdef DASH_ENABLED
+    vPathBounds = vec2(0.0, vPathLength);
+#endif
     geometry.position = vec4(currPosition + offset, 1.0);
     gl_Position = project_common_position_to_clipspace(geometry.position);
     DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
@@ -11298,6 +11578,9 @@ in float vMiterLength;
 in vec2 vPathPosition;
 in float vPathLength;
 in float vJointType;
+#ifdef DASH_ENABLED
+in vec2 vPathBounds;
+#endif
 
 out vec4 fragColor;
 
@@ -11305,7 +11588,11 @@ void main(void) {
   geometry.uv = vPathPosition;
 
 #ifdef ANTIALIASING
+#ifdef DASH_ENABLED
+  bool isCorner = vPathPosition.y < vPathBounds.x || vPathPosition.y > vPathBounds.y;
+#else
   bool isCorner = vPathPosition.y < 0.0 || vPathPosition.y > vPathLength;
+#endif
   bool isRound = vJointType > 0.5;
 
   // Distance to the silhouette in device pixels, from the derivative of the coordinate that
@@ -11316,7 +11603,13 @@ void main(void) {
   // Both evaluated so each derivative stays on one field across the corner/body boundary
   float bodyPixels = (1.0 - bodyCoord) / max(fwidth(bodyCoord), 1e-6);
   float cornerPixels = (1.0 - cornerCoord) / max(fwidth(cornerCoord), 1e-6);
+#ifdef PATH_STYLE_OFFSET
+  // Rounded corners still intersect the stroke-width envelope. Extensions may remap
+  // vPathPosition.x independently of vCornerOffset, as PathStyleExtension does for offsets.
+  float edgePixels = isRound && isCorner ? min(cornerPixels, bodyPixels) : bodyPixels;
+#else
   float edgePixels = isRound && isCorner ? cornerPixels : bodyPixels;
+#endif
 
   // Fragments outside the coverage ramp must not write depth or picking colors.
   if (edgePixels <= -SMOOTH_EDGE_RADIUS) {
@@ -11335,8 +11628,12 @@ void main(void) {
   // edgePixels is a signed device-pixel distance, and SMOOTH_EDGE_RADIUS is 0.5, so smoothedge
   // ramps across exactly one pixel centered on the edge.
   fragColor.a *= smoothedge(0.0, edgePixels);
+#else
+#ifdef DASH_ENABLED
+  if (vPathPosition.y < vPathBounds.x || vPathPosition.y > vPathBounds.y) {
 #else
   if (vPathPosition.y < 0.0 || vPathPosition.y > vPathLength) {
+#endif
     // if joint is rounded, test distance from the corner
     if (vJointType > 0.5 && length(vCornerOffset) > 1.0) {
       discard;
@@ -11377,6 +11674,18 @@ var ATTRIBUTE_TRANSITION = {
     return chunk.length ? chunk.subarray(chunk.length - value.length) : value;
   }
 };
+function getPathProjectionScale(viewport) {
+  if (viewport.isGeospatial) {
+    return null;
+  }
+  const { unitsPerMeter: unitsPerMeter2 } = viewport.distanceScales;
+  return [unitsPerMeter2[0], unitsPerMeter2[1], unitsPerMeter2[2]];
+}
+function pathProjectionScalesEqual(left, right) {
+  return left === right || Boolean(
+    left && right && left.length === right.length && left.every((value, index) => value === right[index])
+  );
+}
 var PathLayer = class extends Layer {
   getShaders() {
     const { antialiasing } = this.props;
@@ -11404,6 +11713,43 @@ var PathLayer = class extends Layer {
     }
     return (_a = this.getAttributeManager()) == null ? void 0 : _a.getBounds(["vertexPositions"]);
   }
+  getPathProjectionScale(viewport) {
+    var _a;
+    const coordinateSystem = this.props.coordinateSystem;
+    const hasDashMetrics = Boolean((_a = this.getAttributeManager()) == null ? void 0 : _a.getAttributes().instanceDashOffsets);
+    if (!hasDashMetrics) {
+      return null;
+    }
+    const trackViewportScale = viewport instanceof WebMercatorViewport && viewport.zoom >= 12 && // Offset coordinate systems use their fixed coordinateOrigin as the projection origin.
+    // Default/lnglat and preprojected Cartesian paths follow the viewport center instead.
+    (coordinateSystem === "default" || coordinateSystem === "lnglat" || coordinateSystem === "cartesian");
+    if (trackViewportScale) {
+      const projectUniforms = project_default.getUniforms({
+        viewport,
+        coordinateSystem,
+        coordinateOrigin: this.props.coordinateOrigin,
+        autoWrapLongitude: this.wrapLongitude
+      });
+      return [
+        viewport.projectionMode,
+        projectUniforms.coordinateOrigin[1],
+        projectUniforms.commonOrigin[1],
+        ...projectUniforms.commonUnitsPerWorldUnit,
+        ...projectUniforms.commonUnitsPerWorldUnit2,
+        projectUniforms.commonUnitsPerMeter[2]
+      ];
+    }
+    const projectionScale = getPathProjectionScale(viewport);
+    return projectionScale ? [viewport.projectionMode, ...projectionScale] : [viewport.projectionMode];
+  }
+  shouldUpdateState(params) {
+    var _a, _b;
+    const { viewport } = this.context;
+    return super.shouldUpdateState(params) || ((_a = this.state) == null ? void 0 : _a.tessellationResolution) !== viewport.resolution || !pathProjectionScalesEqual(
+      (_b = this.state) == null ? void 0 : _b.pathProjectionScale,
+      this.getPathProjectionScale(viewport)
+    );
+  }
   initializeState() {
     const noAlloc = true;
     const isWebGPU = this.context.device.type === "webgpu";
@@ -11494,7 +11840,9 @@ var PathLayer = class extends Layer {
       pathTesselator: new PathTesselator({
         fp64: this.use64bitPositions(),
         isWebGPU
-      })
+      }),
+      tessellationResolution: this.context.viewport.resolution,
+      pathProjectionScale: this.getPathProjectionScale(this.context.viewport)
     });
   }
   updateState(params) {
@@ -11502,7 +11850,16 @@ var PathLayer = class extends Layer {
     super.updateState(params);
     const { props, oldProps, changeFlags } = params;
     const attributeManager = this.getAttributeManager();
-    const geometryChanged = changeFlags.dataChanged || changeFlags.updateTriggersChanged && (changeFlags.updateTriggersChanged.all || changeFlags.updateTriggersChanged.getPath);
+    const { viewport } = this.context;
+    const tessellationResolutionChanged = this.state.tessellationResolution !== viewport.resolution;
+    const pathProjectionScale = this.getPathProjectionScale(viewport);
+    const pathProjectionScaleChanged = !pathProjectionScalesEqual(
+      this.state.pathProjectionScale,
+      pathProjectionScale
+    );
+    const getPathChanged = changeFlags.updateTriggersChanged && (changeFlags.updateTriggersChanged.all || changeFlags.updateTriggersChanged.getPath);
+    const geometryConfigurationChanged = getPathChanged || props._pathType !== oldProps._pathType || props.positionFormat !== oldProps.positionFormat || props.wrapLongitude !== oldProps.wrapLongitude || tessellationResolutionChanged;
+    const geometryChanged = changeFlags.dataChanged || geometryConfigurationChanged;
     if (geometryChanged) {
       const { pathTesselator } = this.state;
       const buffers = props.data.attributes || {};
@@ -11516,16 +11873,24 @@ var PathLayer = class extends Layer {
         positionFormat: props.positionFormat,
         wrapLongitude: props.wrapLongitude,
         // TODO - move the flag out of the viewport
-        resolution: this.context.viewport.resolution,
-        dataChanged: changeFlags.dataChanged
+        resolution: viewport.resolution,
+        // A partial data diff is only valid while normalization inputs remain unchanged.
+        dataChanged: geometryConfigurationChanged ? void 0 : changeFlags.dataChanged
       });
       this.setState({
         numInstances: pathTesselator.instanceCount,
-        startIndices: pathTesselator.vertexStarts
+        startIndices: pathTesselator.vertexStarts,
+        tessellationResolution: viewport.resolution,
+        pathProjectionScale
       });
-      if (!changeFlags.dataChanged) {
+      if (!changeFlags.dataChanged || geometryConfigurationChanged) {
         attributeManager.invalidateAll();
+      } else if (pathProjectionScaleChanged) {
+        attributeManager.invalidate("instanceDashOffsets");
       }
+    } else if (pathProjectionScaleChanged) {
+      this.setState({ pathProjectionScale });
+      attributeManager.invalidate("instanceDashOffsets");
     }
     if (changeFlags.extensionsChanged || props.antialiasing !== oldProps.antialiasing) {
       (_a = this.state.model) == null ? void 0 : _a.destroy();