ol 10.0.1-dev.1723498832296 → 10.0.1-dev.1723626173667

package/expr/expression.d.ts

@@ -139,6 +139,9 @@ export type ArgValidator = (arg0: Array<EncodedExpression>, arg1: number, arg2:
  *   * `['time']` The time in seconds since the creation of the layer (WebGL only).
  *   * `['var', 'varName']` fetches a value from the style variables; will throw an error if that variable is undefined
  *   * `['zoom']` The current zoom level (WebGL only).
+ *   * `['line-metric']` returns the M component of the current point on a line (WebGL only); in case where the geometry layout of the line
+ *      does not contain an M component (e.g. XY or XYZ), 0 is returned; 0 is also returned for geometries other than lines.
+ *      Please note that the M component will be linearly interpolated between the two points composing a segment.
  *
  * * Math operators:
  *   * `['*', value1, value2, ...]` multiplies the values (either numbers or colors)

package/expr/expression.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"expression.d.ts","sourceRoot":"","sources":["expression.js"],"names":[],"mappings":"AAiKA;;;;GAIG;AACH,+BAHW,MAAM,GACL,MAAM,CAgBjB;AAED;;;;GAIG;AACH,oCAJW,MAAM,YACN,MAAM,GACL,OAAO,CAIlB;AAED;;;;GAIG;AACH,sCAJW,MAAM,aACN,MAAM,GACL,OAAO,CAIlB;AAED;;;;GAIG;AACH,6BAJW,MAAM,YACN,MAAM,GACL,OAAO,CAIlB;AAmCD;;GAEG;AAEH;;;;;;GAMG;AAEH;;GAEG;AACH,qCAFY,cAAc,CASzB;AAED;;GAEG;AAEH;;;;;GAKG;AACH,+BALW,iBAAiB,gBACjB,MAAM,WACN,cAAc,GACb,UAAU,CA6FrB;AAqoBD;;;;GAIG;AACH,8CAHW,OAAO,qBAAqB,EAAE,OAAO,GAAC,OAAO,sBAAsB,EAAE,OAAO,GAC3E,OAAO,GAAC,YAAY,GAAC,SAAS,GAAC,EAAE,CA2B5C;AA74BD,yBAA0B;AAC1B,iCAA2C;AAC3C,gCAA0C;AAC1C,gCAA0C;AAC1C,+BAAyC;AACzC,qCAA+C;AAC/C,8BAAwC;AACxC,6BAAiD;AAqEjD;;GAEG;AAEH;IACE;;;OAGG;IACH,kBAHW,MAAM,SACN,YAAY,EAUtB;IAFC,aAAgB;IAChB,oBAAkB;CAErB;AAED;IACE;;;;OAIG;IACH,kBAJW,MAAM,YACN,MAAM,WACH,UAAU,EAAA,EAMvB;IAHC,aAAgB;IAChB,iBAAwB;IACxB,mBAAgB;CAEnB;AAiID;;GAEG;AACH,kBAFU;QAAO,MAAM,GAAE,MAAM;CAAC,CAiD9B;yBAhLW,iBAAiB,GAAC,cAAc;;;;;eAK/B,GAAG,CAAC,MAAM,CAAC;;;;gBACX,GAAG,CAAC,MAAM,CAAC;;;;eACX,OAAO;;;;kBACP,OAAO;;gCAgBR,YAAY,QAAM;;;;;2BAuUlB,CAAS,IAAwB,EAAxB,KAAK,CAAC,iBAAiB,CAAC,EAAE,IAAM,EAAN,MAAM,EAAE,IAAc,EAAd,cAAc,KAAE,KAAK,CAAC,UAAU,CAAC,GAAC,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAldjF,KAAK,CAAC,GAAC,CAAC,GAAC,OAAO,aAAa,EAAE,KAAK,GAAC,MAAM,GAAC,MAAM,GAAC,OAAO;2BAkF1D,OAAO,GAAC,MAAM,GAAC,MAAM,GAAC,KAAK,CAAC,MAAM,CAAC;;;;qBAoNnC,CAAS,IAAK,SAAE,IAAM,EAAN,MAAM,EAAE,IAAc,EAAd,cAAc,KAAE,UAAU"}
+{"version":3,"file":"expression.d.ts","sourceRoot":"","sources":["expression.js"],"names":[],"mappings":"AAoKA;;;;GAIG;AACH,+BAHW,MAAM,GACL,MAAM,CAgBjB;AAED;;;;GAIG;AACH,oCAJW,MAAM,YACN,MAAM,GACL,OAAO,CAIlB;AAED;;;;GAIG;AACH,sCAJW,MAAM,aACN,MAAM,GACL,OAAO,CAIlB;AAED;;;;GAIG;AACH,6BAJW,MAAM,YACN,MAAM,GACL,OAAO,CAIlB;AAmCD;;GAEG;AAEH;;;;;;GAMG;AAEH;;GAEG;AACH,qCAFY,cAAc,CASzB;AAED;;GAEG;AAEH;;;;;GAKG;AACH,+BALW,iBAAiB,gBACjB,MAAM,WACN,cAAc,GACb,UAAU,CA6FrB;AAuoBD;;;;GAIG;AACH,8CAHW,OAAO,qBAAqB,EAAE,OAAO,GAAC,OAAO,sBAAsB,EAAE,OAAO,GAC3E,OAAO,GAAC,YAAY,GAAC,SAAS,GAAC,EAAE,CA2B5C;AA/4BD,yBAA0B;AAC1B,iCAA2C;AAC3C,gCAA0C;AAC1C,gCAA0C;AAC1C,+BAAyC;AACzC,qCAA+C;AAC/C,8BAAwC;AACxC,6BAAiD;AAqEjD;;GAEG;AAEH;IACE;;;OAGG;IACH,kBAHW,MAAM,SACN,YAAY,EAUtB;IAFC,aAAgB;IAChB,oBAAkB;CAErB;AAED;IACE;;;;OAIG;IACH,kBAJW,MAAM,YACN,MAAM,WACH,UAAU,EAAA,EAMvB;IAHC,aAAgB;IAChB,iBAAwB;IACxB,mBAAgB;CAEnB;AAiID;;GAEG;AACH,kBAFU;QAAO,MAAM,GAAE,MAAM;CAAC,CAkD9B;yBAjLW,iBAAiB,GAAC,cAAc;;;;;eAK/B,GAAG,CAAC,MAAM,CAAC;;;;gBACX,GAAG,CAAC,MAAM,CAAC;;;;eACX,OAAO;;;;kBACP,OAAO;;gCAgBR,YAAY,QAAM;;;;;2BAyUlB,CAAS,IAAwB,EAAxB,KAAK,CAAC,iBAAiB,CAAC,EAAE,IAAM,EAAN,MAAM,EAAE,IAAc,EAAd,cAAc,KAAE,KAAK,CAAC,UAAU,CAAC,GAAC,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BApdjF,KAAK,CAAC,GAAC,CAAC,GAAC,OAAO,aAAa,EAAE,KAAK,GAAC,MAAM,GAAC,MAAM,GAAC,OAAO;2BAkF1D,OAAO,GAAC,MAAM,GAAC,MAAM,GAAC,KAAK,CAAC,MAAM,CAAC;;;;qBAqNnC,CAAS,IAAK,SAAE,IAAM,EAAN,MAAM,EAAE,IAAc,EAAd,cAAc,KAAE,UAAU"}

package/expr/expression.js

@@ -37,6 +37,9 @@ import {toSize} from '../size.js';
  *   * `['time']` The time in seconds since the creation of the layer (WebGL only).
  *   * `['var', 'varName']` fetches a value from the style variables; will throw an error if that variable is undefined
  *   * `['zoom']` The current zoom level (WebGL only).
+ *   * `['line-metric']` returns the M component of the current point on a line (WebGL only); in case where the geometry layout of the line
+ *      does not contain an M component (e.g. XY or XYZ), 0 is returned; 0 is also returned for geometries other than lines.
+ *      Please note that the M component will be linearly interpolated between the two points composing a segment.
  *
  * * Math operators:
  *   * `['*', value1, value2, ...]` multiplies the values (either numbers or colors)
@@ -375,6 +378,7 @@ export const Ops = {
   Var: 'var',
   Concat: 'concat',
   GeometryType: 'geometry-type',
+  LineMetric: 'line-metric',
   Any: 'any',
   All: 'all',
   Not: '!',
@@ -438,6 +442,7 @@ const parsers = {
     withArgsOfType(StringType),
   ),
   [Ops.GeometryType]: createCallExpressionParser(usesGeometryType, withNoArgs),
+  [Ops.LineMetric]: createCallExpressionParser(withNoArgs),
   [Ops.Resolution]: createCallExpressionParser(withNoArgs),
   [Ops.Zoom]: createCallExpressionParser(withNoArgs),
   [Ops.Time]: createCallExpressionParser(withNoArgs),

package/expr/gpu.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gpu.d.ts","sourceRoot":"","sources":["gpu.js"],"names":[],"mappings":"AA8BA;;;;GAIG;AACH,gCAHW,MAAM,GACL,MAAM,CAKjB;AAED;;;;GAIG;AACH,mCAHW,KAAK,CAAC,MAAM,CAAC,GACZ,MAAM,CASjB;AAED;;;;;;GAMG;AACH,mCALW,MAAM,GAAC,OAAO,aAAa,EAAE,KAAK,GAGjC,MAAM,CAYjB;AAED;;;;GAIG;AACH,iCAHW,MAAM,GAAC,OAAO,YAAY,EAAE,IAAI,GAC/B,MAAM,CAKjB;AAMD;;;;GAIG;AACH,kDAHW,MAAM,GACL,MAAM,CAOjB;AAED;;;;;;GAMG;AACH,qCAHW,MAAM,GACL,MAAM,CAIjB;AAED;;;;GAIG;AACH,qDAHW,MAAM,GACL,MAAM,CAIjB;AAED;;GAEG;AACH;;;GAGG;AACH;;;GAGG;AAEH;;;;;GAKG;AAEH;;;;;GAKG;AAEH;;;;;;;;;GASG;AAEH;;GAEG;AACH,yCAFY,kBAAkB,CAW7B;AAMD;;GAEG;AAEH;;;GAGG;AAEH;;;;;;GAMG;AACH,yCANW,OAAO,iBAAiB,EAAE,iBAAiB,QAC3C,MAAM,kBACN,OAAO,iBAAiB,EAAE,cAAc,sBACxC,kBAAkB,GACjB,kBAAkB,CAU7B;AA1BD,wDAAyD;6BApD5C,OAAO,iBAAiB,EAAE,cAAc;yBAIxC,OAAO,iBAAiB,EAAE,UAAU;gCAIpC,OAAO,iBAAiB,EAAE,iBAAiB;;;;;UAK1C,MAAM;;;;UACN,MAAM;;;;wBACG,OAAO,eAAe,EAAE,WAAW,KAAG,GAAC;;;;;;UAKhD,MAAM;;;;UACN,MAAM;;;;gCACY,GAAC;;;;;;;;;;gBAMnB;YAAO,MAAM,GAAE,0BAA0B;KAAC;;;;eAC1C;YAAO,MAAM,GAAE,0BAA0B;KAAC;;;;eAC1C;YAAO,MAAM,GAAE,MAAM;KAAC;;;;;;;;;;;;WAGtB,OAAO,mBAAmB,EAAE,UAAU;;iCAsBvC,MAAM;;;;uBAIN,CAAS,IAAkB,EAAlB,kBAAkB,EAAE,IAAc,EAAd,cAAc,EAAE,IAAM,EAAN,MAAM,KAAG,MAAM;2BAhL9C,4BAA4B;+BAahD,iBAAiB"}
+{"version":3,"file":"gpu.d.ts","sourceRoot":"","sources":["gpu.js"],"names":[],"mappings":"AA8BA;;;;GAIG;AACH,gCAHW,MAAM,GACL,MAAM,CAKjB;AAED;;;;GAIG;AACH,mCAHW,KAAK,CAAC,MAAM,CAAC,GACZ,MAAM,CASjB;AAED;;;;;;GAMG;AACH,mCALW,MAAM,GAAC,OAAO,aAAa,EAAE,KAAK,GAGjC,MAAM,CAMjB;AAED;;;;GAIG;AACH,iCAHW,MAAM,GAAC,OAAO,YAAY,EAAE,IAAI,GAC/B,MAAM,CAKjB;AAMD;;;;GAIG;AACH,kDAHW,MAAM,GACL,MAAM,CAOjB;AAED;;;;;;GAMG;AACH,qCAHW,MAAM,GACL,MAAM,CAIjB;AAED;;;;GAIG;AACH,qDAHW,MAAM,GACL,MAAM,CAIjB;AAED;;GAEG;AACH;;;GAGG;AACH;;;GAGG;AAEH;;;;;GAKG;AAEH;;;;;GAKG;AAEH;;;;;;;;;GASG;AAEH;;GAEG;AACH,yCAFY,kBAAkB,CAW7B;AAMD;;GAEG;AAEH;;;GAGG;AAEH;;;;;;GAMG;AACH,yCANW,OAAO,iBAAiB,EAAE,iBAAiB,QAC3C,MAAM,kBACN,OAAO,iBAAiB,EAAE,cAAc,sBACxC,kBAAkB,GACjB,kBAAkB,CAU7B;AA1BD,wDAAyD;6BApD5C,OAAO,iBAAiB,EAAE,cAAc;yBAIxC,OAAO,iBAAiB,EAAE,UAAU;gCAIpC,OAAO,iBAAiB,EAAE,iBAAiB;;;;;UAK1C,MAAM;;;;UACN,MAAM;;;;wBACG,OAAO,eAAe,EAAE,WAAW,KAAG,GAAC;;;;;;UAKhD,MAAM;;;;UACN,MAAM;;;;gCACY,GAAC;;;;;;;;;;gBAMnB;YAAO,MAAM,GAAE,0BAA0B;KAAC;;;;eAC1C;YAAO,MAAM,GAAE,0BAA0B;KAAC;;;;eAC1C;YAAO,MAAM,GAAE,MAAM;KAAC;;;;;;;;;;;;WAGtB,OAAO,mBAAmB,EAAE,UAAU;;iCAsBvC,MAAM;;;;uBAIN,CAAS,IAAkB,EAAlB,kBAAkB,EAAE,IAAc,EAAd,cAAc,EAAE,IAAM,EAAN,MAAM,KAAG,MAAM;2BA1K9C,4BAA4B;+BAahD,iBAAiB"}

package/expr/gpu.js

@@ -62,13 +62,7 @@ export function arrayToGlsl(array) {
 export function colorToGlsl(color) {
   const array = asArray(color);
   const alpha = array.length > 3 ? array[3] : 1;
-  // all components are premultiplied with alpha value
-  return arrayToGlsl([
-    (array[0] / 255) * alpha,
-    (array[1] / 255) * alpha,
-    (array[2] / 255) * alpha,
-    alpha,
-  ]);
+  return arrayToGlsl([array[0] / 255, array[1] / 255, array[2] / 255, alpha]);
 }
 
 /**
@@ -245,6 +239,7 @@ const compilers = {
     const prefix = context.inFragmentShader ? 'v_prop_' : 'a_prop_';
     return prefix + propName;
   },
+  [Ops.LineMetric]: () => 'currentLineMetric', // this variable is assumed to always be present in shaders, default is 0.
   [Ops.Var]: (context, expression) => {
     const firstArg = /** @type {LiteralExpression} */ (expression.args[0]);
     const varName = /** @type {string} */ (firstArg.value);
@@ -371,14 +366,14 @@ ${tests.join('\n')}
     }
     if (compiledArgs.length === 2) {
       //grayscale with alpha
-      return `(${compiledArgs[1]} * vec4(vec3(${compiledArgs[0]} / 255.0), 1.0))`;
+      return `vec4(vec3(${compiledArgs[0]} / 255.0), ${compiledArgs[1]})`;
     }
     const rgb = compiledArgs.slice(0, 3).map((color) => `${color} / 255.0`);
     if (compiledArgs.length === 3) {
       return `vec4(${rgb.join(', ')}, 1.0)`;
     }
     const alpha = compiledArgs[3];
-    return `(${alpha} * vec4(${rgb.join(', ')}, 1.0))`;
+    return `vec4(${rgb.join(', ')}, ${alpha})`;
   }),
   [Ops.Band]: createCompiler(([band, xOffset, yOffset], context) => {
     if (!(GET_BAND_VALUE_FUNC in context.functions)) {

package/geom/flat/transform.d.ts

@@ -8,9 +8,10 @@
  * @param {number} stride Stride.
  * @param {import("../../transform.js").Transform} transform Transform.
  * @param {Array<number>} [dest] Destination.
+ * @param {number} [destinationStride] Stride of destination coordinates; if unspecified, assumed to be 2.
  * @return {Array<number>} Transformed coordinates.
  */
-export function transform2D(flatCoordinates: Array<number>, offset: number, end: number, stride: number, transform: import("../../transform.js").Transform, dest?: number[] | undefined): Array<number>;
+export function transform2D(flatCoordinates: Array<number>, offset: number, end: number, stride: number, transform: import("../../transform.js").Transform, dest?: number[] | undefined, destinationStride?: number | undefined): Array<number>;
 /**
  * @param {Array<number>} flatCoordinates Flat coordinates.
  * @param {number} offset Offset.

package/geom/flat/transform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["transform.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;GAQG;AACH,6CARW,KAAK,CAAC,MAAM,CAAC,UACb,MAAM,OACN,MAAM,UACN,MAAM,aACN,OAAO,oBAAoB,EAAE,SAAS,gCAErC,KAAK,CAAC,MAAM,CAAC,CAsBxB;AAED;;;;;;;;;GASG;AACH,wCATW,KAAK,CAAC,MAAM,CAAC,UACb,MAAM,OACN,MAAM,UACN,MAAM,SACN,MAAM,UACN,KAAK,CAAC,MAAM,CAAC,gCAEZ,KAAK,CAAC,MAAM,CAAC,CA8BxB;AAED;;;;;;;;;;;GAWG;AACH,uCAVW,KAAK,CAAC,MAAM,CAAC,UACb,MAAM,OACN,MAAM,UACN,MAAM,MACN,MAAM,MACN,MAAM,UACN,KAAK,CAAC,MAAM,CAAC,gCAEZ,KAAK,CAAC,MAAM,CAAC,CA6BxB;AAED;;;;;;;;;GASG;AACH,2CATW,KAAK,CAAC,MAAM,CAAC,UACb,MAAM,OACN,MAAM,UACN,MAAM,UACN,MAAM,UACN,MAAM,gCAEL,KAAK,CAAC,MAAM,CAAC,CAwBxB"}
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["transform.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;GASG;AACH,6CATW,KAAK,CAAC,MAAM,CAAC,UACb,MAAM,OACN,MAAM,UACN,MAAM,aACN,OAAO,oBAAoB,EAAE,SAAS,wEAGrC,KAAK,CAAC,MAAM,CAAC,CA6BxB;AAED;;;;;;;;;GASG;AACH,wCATW,KAAK,CAAC,MAAM,CAAC,UACb,MAAM,OACN,MAAM,UACN,MAAM,SACN,MAAM,UACN,KAAK,CAAC,MAAM,CAAC,gCAEZ,KAAK,CAAC,MAAM,CAAC,CA8BxB;AAED;;;;;;;;;;;GAWG;AACH,uCAVW,KAAK,CAAC,MAAM,CAAC,UACb,MAAM,OACN,MAAM,UACN,MAAM,MACN,MAAM,MACN,MAAM,UACN,KAAK,CAAC,MAAM,CAAC,gCAEZ,KAAK,CAAC,MAAM,CAAC,CA6BxB;AAED;;;;;;;;;GASG;AACH,2CATW,KAAK,CAAC,MAAM,CAAC,UACb,MAAM,OACN,MAAM,UACN,MAAM,UACN,MAAM,UACN,MAAM,gCAEL,KAAK,CAAC,MAAM,CAAC,CAwBxB"}

package/geom/flat/transform.js

@@ -9,6 +9,7 @@
  * @param {number} stride Stride.
  * @param {import("../../transform.js").Transform} transform Transform.
  * @param {Array<number>} [dest] Destination.
+ * @param {number} [destinationStride] Stride of destination coordinates; if unspecified, assumed to be 2.
  * @return {Array<number>} Transformed coordinates.
  */
 export function transform2D(
@@ -18,15 +19,22 @@ export function transform2D(
   stride,
   transform,
   dest,
+  destinationStride,
 ) {
   dest = dest ? dest : [];
+  destinationStride = destinationStride ? destinationStride : 2;
   let i = 0;
   for (let j = offset; j < end; j += stride) {
     const x = flatCoordinates[j];
     const y = flatCoordinates[j + 1];
     dest[i++] = transform[0] * x + transform[2] * y + transform[4];
     dest[i++] = transform[1] * x + transform[3] * y + transform[5];
+
+    for (let k = 2; k < destinationStride; k++) {
+      dest[i++] = flatCoordinates[j + k];
+    }
   }
+
   if (dest && dest.length != i) {
     dest.length = i;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ol",
-  "version": "10.0.1-dev.1723498832296",
+  "version": "10.0.1-dev.1723626173667",
   "description": "OpenLayers mapping library",
   "keywords": [
     "map",

package/render/webgl/MixedGeometryBatch.d.ts

@@ -226,6 +226,7 @@ declare class MixedGeometryBatch {
      * @param {Feature|RenderFeature} feature Feature
      * @param {string} featureUid Feature uid
      * @param {number} stride Stride
+     * @param {import('../../geom/Geometry.js').GeometryLayout} [layout] Layout
      * @private
      */
     private addCoordinates_;

package/render/webgl/MixedGeometryBatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MixedGeometryBatch.d.ts","sourceRoot":"","sources":["MixedGeometryBatch.js"],"names":[],"mappings":";sBAQa,OAAO,kBAAkB,EAAE,OAAO;2BAGlC,OAAO,wBAAwB,EAAE,IAAI;;;;;;;;aAKpC,OAAO,GAAC,aAAa;;;;iBACrB,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;;;;;;;;;;;;;;;;;;4BAQrB,kBAAkB,GAAC,uBAAuB,GAAC,oBAAoB;;;;;;;;;aAK9D;YAAO,MAAM,GAAE,iBAAiB;KAAC;;;;qBAEjC,MAAM;;;;mBACN,MAAM;;;;gBACN,MAAM;;;;;;;;;;aAKN;YAAO,MAAM,GAAE,iBAAiB;KAAC;;;;qBAEjC,MAAM;;;;mBACN,MAAM;;;;;;;;;;aAKN;YAAO,MAAM,GAAE,iBAAiB;KAAC;;;;qBAEjC,MAAM;;AA1CpB;;GAEG;AACH;;GAEG;AAEH;;;;;;;;GAQG;AAEH;;GAEG;AAEH;;;;;;;GAOG;AAEH;;;;;;GAMG;AAEH;;;;;GAKG;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AACH;IAEI;;OAEG;IACH,uBAAuB;IAEvB;;;;OAIG;IACH,sBAA8B;IAE9B;;;;OAIG;IACH,kBAA0B;IAE1B;;;;;OAKG;IACH,uBAAwB;IAExB;;OAEG;IACH,cAFU,oBAAoB,CAO7B;IAED;;OAEG;IACH,YAFU,kBAAkB,CAK3B;IAED;;OAEG;IACH,iBAFU,uBAAuB,CAMhC;IAGH;;;OAGG;IACH,sBAHW,KAAK,CAAC,OAAO,GAAC,aAAa,CAAC,qFAOtC;IAED;;;OAGG;IACH,oBAHW,OAAO,GAAC,aAAa,qFAa/B;IAED;;;;OAIG;IACH,uCAQC;IAED;;;;OAIG;IACH,4CASC;IAED;;;;OAIG;IACH,yCAUC;IAED;;;;OAIG;IACH,qBAuGC;IAED;;;;;;;;OAQG;IACH,wBAoJC;IAED;;;;;OAKG;IACH,uBAYC;IAED;;;;;OAKG;IACH,mBAOC;IAED;;OAEG;IACH,uBAFW,OAAO,GAAC,aAAa,QAS/B;IAED;;OAEG;IACH,uBAFW,OAAO,GAAC,aAAa,QAU/B;IAED,cAcC;IAED;;;;OAIG;IACH,uBAHW,MAAM,GACL,OAAO,GAAC,aAAa,CAIhC;CACF;0BAxiByB,yBAAyB"}
+{"version":3,"file":"MixedGeometryBatch.d.ts","sourceRoot":"","sources":["MixedGeometryBatch.js"],"names":[],"mappings":";sBAQa,OAAO,kBAAkB,EAAE,OAAO;2BAGlC,OAAO,wBAAwB,EAAE,IAAI;;;;;;;;aAKpC,OAAO,GAAC,aAAa;;;;iBACrB,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;;;;;;;;;;;;;;;;;;4BAQrB,kBAAkB,GAAC,uBAAuB,GAAC,oBAAoB;;;;;;;;;aAK9D;YAAO,MAAM,GAAE,iBAAiB;KAAC;;;;qBAEjC,MAAM;;;;mBACN,MAAM;;;;gBACN,MAAM;;;;;;;;;;aAKN;YAAO,MAAM,GAAE,iBAAiB;KAAC;;;;qBAEjC,MAAM;;;;mBACN,MAAM;;;;;;;;;;aAKN;YAAO,MAAM,GAAE,iBAAiB;KAAC;;;;qBAEjC,MAAM;;AA1CpB;;GAEG;AACH;;GAEG;AAEH;;;;;;;;GAQG;AAEH;;GAEG;AAEH;;;;;;;GAOG;AAEH;;;;;;GAMG;AAEH;;;;;GAKG;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AACH;IAEI;;OAEG;IACH,uBAAuB;IAEvB;;;;OAIG;IACH,sBAA8B;IAE9B;;;;OAIG;IACH,kBAA0B;IAE1B;;;;;OAKG;IACH,uBAAwB;IAExB;;OAEG;IACH,cAFU,oBAAoB,CAO7B;IAED;;OAEG;IACH,YAFU,kBAAkB,CAK3B;IAED;;OAEG;IACH,iBAFU,uBAAuB,CAMhC;IAGH;;;OAGG;IACH,sBAHW,KAAK,CAAC,OAAO,GAAC,aAAa,CAAC,qFAOtC;IAED;;;OAGG;IACH,oBAHW,OAAO,GAAC,aAAa,qFAa/B;IAED;;;;OAIG;IACH,uCAQC;IAED;;;;OAIG;IACH,4CASC;IAED;;;;OAIG;IACH,yCAUC;IAED;;;;OAIG;IACH,qBA2GC;IAED;;;;;;;;;OASG;IACH,wBAyJC;IAED;;;;;OAKG;IACH,uBAYC;IAED;;;;;OAKG;IACH,mBAOC;IAED;;OAEG;IACH,uBAFW,OAAO,GAAC,aAAa,QAS/B;IAED;;OAEG;IACH,uBAFW,OAAO,GAAC,aAAa,QAU/B;IAED,cAcC;IAED;;;;OAIG;IACH,uBAHW,MAAM,GACL,OAAO,GAAC,aAAa,CAIhC;CACF;0BAljByB,yBAAyB"}

package/render/webgl/MixedGeometryBatch.js

@@ -295,13 +295,17 @@ class MixedGeometryBatch {
         const lineGeom = /** @type {import("../../geom.js").LineString} */ (
           geometry
         );
+
+        const stride = lineGeom.getStride();
+
         this.addCoordinates_(
           type,
           lineGeom.getFlatCoordinates(),
           null,
           feature,
           getUid(feature),
-          lineGeom.getStride(),
+          stride,
+          lineGeom.getLayout?.(),
         );
         break;
       }
@@ -317,9 +321,10 @@ class MixedGeometryBatch {
    * @param {Feature|RenderFeature} feature Feature
    * @param {string} featureUid Feature uid
    * @param {number} stride Stride
+   * @param {import('../../geom/Geometry.js').GeometryLayout} [layout] Layout
    * @private
    */
-  addCoordinates_(type, flatCoords, ends, feature, featureUid, stride) {
+  addCoordinates_(type, flatCoords, ends, feature, featureUid, stride, layout) {
     /** @type {number} */
     let verticesCount;
     switch (type) {
@@ -343,6 +348,7 @@ class MixedGeometryBatch {
             feature,
             featureUid,
             stride,
+            layout,
           );
         }
         break;
@@ -358,6 +364,7 @@ class MixedGeometryBatch {
             feature,
             featureUid,
             stride,
+            layout,
           );
         }
         break;
@@ -371,6 +378,7 @@ class MixedGeometryBatch {
             feature,
             featureUid,
             null,
+            null,
           );
         }
         break;
@@ -386,6 +394,7 @@ class MixedGeometryBatch {
               feature,
               featureUid,
               stride,
+              layout,
             );
             return;
           }
@@ -427,6 +436,7 @@ class MixedGeometryBatch {
             feature,
             featureUid,
             stride,
+            layout,
           );
         }
         break;
@@ -460,7 +470,7 @@ class MixedGeometryBatch {
         this.lineStringBatch.verticesCount += verticesCount;
         this.lineStringBatch.geometriesCount++;
         this.lineStringBatch.entries[featureUid].flatCoordss.push(
-          getFlatCoordinatesXY(flatCoords, stride),
+          getFlatCoordinatesXYM(flatCoords, stride, layout),
         );
         this.lineStringBatch.entries[featureUid].verticesCount += verticesCount;
         break;
@@ -567,4 +577,28 @@ function getFlatCoordinatesXY(flatCoords, stride) {
   return flatCoords.filter((v, i) => i % stride < 2);
 }
 
+/**
+ * @param {Array<number>} flatCoords Flat coords
+ * @param {number} stride Stride
+ * @param {string} layout Layout
+ * @return {Array<number>} Flat coords with only XY components
+ */
+function getFlatCoordinatesXYM(flatCoords, stride, layout) {
+  if (stride === 3 && layout === 'XYM') {
+    return flatCoords;
+  }
+  // this is XYZM layout
+  if (stride === 4) {
+    return flatCoords.filter((v, i) => i % stride !== 2);
+  }
+  // this is XYZ layout
+  if (stride === 3) {
+    return flatCoords.map((v, i) => (i % stride !== 2 ? v : 0));
+  }
+  // this is XY layout
+  return new Array(flatCoords.length * 1.5)
+    .fill(0)
+    .map((v, i) => (i % 3 === 2 ? 0 : flatCoords[Math.round(i / 1.5)]));
+}
+
 export default MixedGeometryBatch;

package/render/webgl/VectorStyleRenderer.d.ts

@@ -8,6 +8,8 @@ export namespace Attributes {
     let INDEX: string;
     let SEGMENT_START: string;
     let SEGMENT_END: string;
+    let MEASURE_START: string;
+    let MEASURE_END: string;
     let PARAMETERS: string;
     let JOIN_ANGLES: string;
     let DISTANCE: string;

package/render/webgl/VectorStyleRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VectorStyleRenderer.d.ts","sourceRoot":"","sources":["VectorStyleRenderer.js"],"names":[],"mappings":";;;;yBA4BU,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;cAiBF,CAAS,IAAwD,EAAnD,OAAO,yBAAyB,EAAE,iBAAiB,EAAE,IAAmC,EAAnC,OAAO,eAAe,EAAE,WAAW,KAAE,MAAM,GAAC,KAAK,CAAC,MAAM,CAAC;;mCAK7H;QAAO,MAAM,GAAE,mBAAmB;CAAC;iCACnC;QAAO,MAAM,GAAE,OAAO,oBAAoB,EAAE,YAAY;CAAC;;;;;oBAKxD,KAAK,CAAC,gBAAgB,CAAC;;;;uBACvB,KAAK,CAAC,gBAAgB,CAAC;;;;kBACvB,KAAK,CAAC,gBAAgB,CAAC;;;;6BACvB,OAAO,oBAAoB,EAAE,SAAS;;;;;;yBAKtC,YAAY,GAAC,IAAI;;;;4BACjB,YAAY,GAAC,IAAI;;;;uBACjB,YAAY,GAAC,IAAI;;;;;;;;;YAKjB,MAAM;;;;cACN,MAAM;;;;;;aAKN,OAAO,8BAA8B,EAAE,aAAa;;;;;;;;;;;;;;;0BAOrD,OAAO,sBAAsB,EAAE,UAAU,GAAC,YAAY;AA5CnE;;;;;;;GAOG;AAEH;;;GAGG;AAEH;;;;;;GAMG;AAEH;;;;;GAKG;AAEH;;;;GAIG;AAEH;;;;;;GAMG;AAEH;;GAEG;AAEH;;;;;;;;;;;;;GAaG;AACH;IACE;;;;OAIG;IACH,4BAJW,WAAW,UACX,OAAO,uBAAuB,EAAE,OAAO,sBACvC,OAAO,EAgMjB;IA7LC;;OAEG;IACH,gBAAqB;IAErB;;OAEG;IACH,6BAA8C;IAgB9C;;;OAGG;IACH,iBAAuD;IAErD;;OAEG;IACH,0BAA8D;IAC9D;;OAEG;IACH,4BAAkE;IAClE;;OAEG;IACH,qBAGC;IAGH;;;OAGG;IACH,mBAA2D;IAEzD;;OAEG;IACH,4BAAkE;IAClE;;OAEG;IACH,8BAAsE;IACtE;;OAEG;IACH,uBAGC;IAGH;;;OAGG;IACH,mBAA2D;IAEzD;;OAEG;IACH,4BAAkE;IAClE;;OAEG;IACH,8BAAsE;IACtE;;OAEG;IACH,uBAGC;IAcH;;OAEG;IACH,0BAIC;IACD;;OAEG;IACH,kBAAiC;IASjC;;;OAGG;IACH,+BAOC;IACD;;;OAGG;IACH,kCA2BC;IACD;;;OAGG;IACH,6BAYC;IAOH;;;;OAIG;IACH,+BAJW,OAAO,yBAAyB,EAAE,OAAO,aACzC,OAAO,oBAAoB,EAAE,SAAS,GACrC,OAAO,CAAC,YAAY,CAAC,CAqChC;IAED;;;;;OAKG;IACH,oCA+BC;IAED;;;;;;OAMG;IACH,gCAuEC;IAED;;;;;OAKG;IACH,gBAJW,YAAY,cACZ,OAAO,cAAc,EAAE,UAAU,qBACjC,MAAY,IAAI,QA8B1B;IAED;;;;;;;;OAQG;IACH,wBAkBC;CACF;6BAzgB4B,uBAAuB"}
+{"version":3,"file":"VectorStyleRenderer.d.ts","sourceRoot":"","sources":["VectorStyleRenderer.js"],"names":[],"mappings":";;;;yBA4BU,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmBF,CAAS,IAAwD,EAAnD,OAAO,yBAAyB,EAAE,iBAAiB,EAAE,IAAmC,EAAnC,OAAO,eAAe,EAAE,WAAW,KAAE,MAAM,GAAC,KAAK,CAAC,MAAM,CAAC;;mCAK7H;QAAO,MAAM,GAAE,mBAAmB;CAAC;iCACnC;QAAO,MAAM,GAAE,OAAO,oBAAoB,EAAE,YAAY;CAAC;;;;;oBAKxD,KAAK,CAAC,gBAAgB,CAAC;;;;uBACvB,KAAK,CAAC,gBAAgB,CAAC;;;;kBACvB,KAAK,CAAC,gBAAgB,CAAC;;;;6BACvB,OAAO,oBAAoB,EAAE,SAAS;;;;;;yBAKtC,YAAY,GAAC,IAAI;;;;4BACjB,YAAY,GAAC,IAAI;;;;uBACjB,YAAY,GAAC,IAAI;;;;;;;;;YAKjB,MAAM;;;;cACN,MAAM;;;;;;aAKN,OAAO,8BAA8B,EAAE,aAAa;;;;;;;;;;;;;;;0BAOrD,OAAO,sBAAsB,EAAE,UAAU,GAAC,YAAY;AA5CnE;;;;;;;GAOG;AAEH;;;GAGG;AAEH;;;;;;GAMG;AAEH;;;;;GAKG;AAEH;;;;GAIG;AAEH;;;;;;GAMG;AAEH;;GAEG;AAEH;;;;;;;;;;;;;GAaG;AACH;IACE;;;;OAIG;IACH,4BAJW,WAAW,UACX,OAAO,uBAAuB,EAAE,OAAO,sBACvC,OAAO,EA0MjB;IAvMC;;OAEG;IACH,gBAAqB;IAErB;;OAEG;IACH,6BAA8C;IAgB9C;;;OAGG;IACH,iBAAuD;IAErD;;OAEG;IACH,0BAA8D;IAC9D;;OAEG;IACH,4BAAkE;IAClE;;OAEG;IACH,qBAGC;IAGH;;;OAGG;IACH,mBAA2D;IAEzD;;OAEG;IACH,4BAAkE;IAClE;;OAEG;IACH,8BAAsE;IACtE;;OAEG;IACH,uBAGC;IAGH;;;OAGG;IACH,mBAA2D;IAEzD;;OAEG;IACH,4BAAkE;IAClE;;OAEG;IACH,8BAAsE;IACtE;;OAEG;IACH,uBAGC;IAcH;;OAEG;IACH,0BAIC;IACD;;OAEG;IACH,kBAAiC;IASjC;;;OAGG;IACH,+BAOC;IACD;;;OAGG;IACH,kCAqCC;IACD;;;OAGG;IACH,6BAYC;IAOH;;;;OAIG;IACH,+BAJW,OAAO,yBAAyB,EAAE,OAAO,aACzC,OAAO,oBAAoB,EAAE,SAAS,GACrC,OAAO,CAAC,YAAY,CAAC,CAqChC;IAED;;;;;OAKG;IACH,oCA+BC;IAED;;;;;;OAMG;IACH,gCAuEC;IAED;;;;;OAKG;IACH,gBAJW,YAAY,cACZ,OAAO,cAAc,EAAE,UAAU,qBACjC,MAAY,IAAI,QA8B1B;IAED;;;;;;;;OAQG;IACH,wBAkBC;CACF;6BArhB4B,uBAAuB"}

package/render/webgl/VectorStyleRenderer.js

@@ -33,6 +33,8 @@ export const Attributes = {
   INDEX: 'a_index',
   SEGMENT_START: 'a_segmentStart',
   SEGMENT_END: 'a_segmentEnd',
+  MEASURE_START: 'a_measureStart',
+  MEASURE_END: 'a_measureEnd',
   PARAMETERS: 'a_parameters',
   JOIN_ANGLES: 'a_joinAngles',
   DISTANCE: 'a_distance',
@@ -252,11 +254,21 @@ class VectorStyleRenderer {
         size: 2,
         type: AttributeType.FLOAT,
       },
+      {
+        name: Attributes.MEASURE_START,
+        size: 1,
+        type: AttributeType.FLOAT,
+      },
       {
         name: Attributes.SEGMENT_END,
         size: 2,
         type: AttributeType.FLOAT,
       },
+      {
+        name: Attributes.MEASURE_END,
+        size: 1,
+        type: AttributeType.FLOAT,
+      },
       {
         name: Attributes.JOIN_ANGLES,
         size: 2,

package/render/webgl/renderinstructions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderinstructions.d.ts","sourceRoot":"","sources":["renderinstructions.js"],"names":[],"mappings":"AAwCA;;;GAGG;AACH,0DAHW,OAAO,0BAA0B,EAAE,oBAAoB,GACtD,MAAM,CAOjB;AAED;;;;;;;;GAQG;AACH,uDANW,OAAO,yBAAyB,EAAE,kBAAkB,sBACpD,YAAY,oBACZ,OAAO,0BAA0B,EAAE,oBAAoB,aACvD,OAAO,oBAAoB,EAAE,SAAS,GACrC,YAAY,CAyCvB;AAED;;;;;;;;GAQG;AACH,4DANW,OAAO,yBAAyB,EAAE,uBAAuB,sBACzD,YAAY,oBACZ,OAAO,0BAA0B,EAAE,oBAAoB,aACvD,OAAO,oBAAoB,EAAE,SAAS,GACrC,YAAY,CAuDvB;AAED;;;;;;;;GAQG;AACH,yDANW,OAAO,yBAAyB,EAAE,oBAAoB,sBACtD,YAAY,oBACZ,OAAO,0BAA0B,EAAE,oBAAoB,aACvD,OAAO,oBAAoB,EAAE,SAAS,GACrC,YAAY,CAoEvB"}
+{"version":3,"file":"renderinstructions.d.ts","sourceRoot":"","sources":["renderinstructions.js"],"names":[],"mappings":"AAwCA;;;GAGG;AACH,0DAHW,OAAO,0BAA0B,EAAE,oBAAoB,GACtD,MAAM,CAOjB;AAED;;;;;;;;GAQG;AACH,uDANW,OAAO,yBAAyB,EAAE,kBAAkB,sBACpD,YAAY,oBACZ,OAAO,0BAA0B,EAAE,oBAAoB,aACvD,OAAO,oBAAoB,EAAE,SAAS,GACrC,YAAY,CAyCvB;AAED;;;;;;;;GAQG;AACH,4DANW,OAAO,yBAAyB,EAAE,uBAAuB,sBACzD,YAAY,oBACZ,OAAO,0BAA0B,EAAE,oBAAoB,aACvD,OAAO,oBAAoB,EAAE,SAAS,GACrC,YAAY,CAyDvB;AAED;;;;;;;;GAQG;AACH,yDANW,OAAO,yBAAyB,EAAE,oBAAoB,sBACtD,YAAY,oBACZ,OAAO,0BAA0B,EAAE,oBAAoB,aACvD,OAAO,oBAAoB,EAAE,SAAS,GACrC,YAAY,CAoEvB"}

package/render/webgl/renderinstructions.js

@@ -115,11 +115,11 @@ export function generateLineStringRenderInstructions(
   transform,
 ) {
   // here we anticipate the amount of render instructions for lines:
-  // 2 instructions per vertex for position (x and y)
+  // 3 instructions per vertex for position (x, y and m)
   // + 1 instruction per line per custom attributes
   // + 1 instruction per line (for vertices count)
   const totalInstructionsCount =
-    2 * batch.verticesCount +
+    3 * batch.verticesCount +
     (1 + getCustomAttributesSize(customAttributes)) * batch.geometriesCount;
   if (
     !renderInstructions ||
@@ -139,9 +139,10 @@ export function generateLineStringRenderInstructions(
         batchEntry.flatCoordss[i],
         0,
         flatCoords.length,
-        2,
+        3,
         transform,
         flatCoords,
+        3,
       );
       renderIndex += pushCustomAttributesInRenderInstructions(
         renderInstructions,
@@ -151,12 +152,13 @@ export function generateLineStringRenderInstructions(
       );
 
       // vertices count
-      renderInstructions[renderIndex++] = flatCoords.length / 2;
+      renderInstructions[renderIndex++] = flatCoords.length / 3;
 
       // looping on points for positions
-      for (let j = 0, jj = flatCoords.length; j < jj; j += 2) {
+      for (let j = 0, jj = flatCoords.length; j < jj; j += 3) {
         renderInstructions[renderIndex++] = flatCoords[j];
         renderInstructions[renderIndex++] = flatCoords[j + 1];
+        renderInstructions[renderIndex++] = flatCoords[j + 2];
       }
     }
   }

package/render/webgl/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["utils.js"],"names":[],"mappings":"AAiCA;;;;;;;;;;;;GAYG;AACH,yDAXW,YAAY,gBACZ,MAAM,gBACN,YAAY,eACZ,WAAW,wBACX,MAAM,kDAEL,eAAe,CAgE1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wDAdW,YAAY,qBACZ,MAAM,mBACN,MAAM,sBACN,MAAM,GAAC,IAAI,qBACX,MAAM,GAAC,IAAI,eACX,KAAK,CAAC,MAAM,CAAC,cACb,KAAK,CAAC,MAAM,CAAC,oBACb,KAAK,CAAC,MAAM,CAAC,oBACb,OAAO,oBAAoB,EAAE,SAAS,iBACtC,MAAM,0BACN,MAAM,GACL;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAqL1C;AAED;;;;;;;;;GASG;AACH,6DARW,YAAY,qBACZ,MAAM,eACN,KAAK,CAAC,MAAM,CAAC,cACb,KAAK,CAAC,MAAM,CAAC,wBACb,MAAM,GACL,MAAM,CA0CjB;AAED;;;;GAIG;AACH,qCAFY,SAAS,CAUpB;AAED;;;;;;GAMG;AACH,kCAJW,MAAM,iCAEL,KAAK,CAAC,MAAM,CAAC,CAWxB;AAED;;;;;GAKG;AACH,qCAHW,KAAK,CAAC,MAAM,CAAC,GACZ,MAAM,CAWjB;AA7ZD,mDAAoD;;;;;;;;oBAQtC,MAAM;;;;mBACN,MAAM"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["utils.js"],"names":[],"mappings":"AAiCA;;;;;;;;;;;;GAYG;AACH,yDAXW,YAAY,gBACZ,MAAM,gBACN,YAAY,eACZ,WAAW,wBACX,MAAM,kDAEL,eAAe,CAgE1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wDAdW,YAAY,qBACZ,MAAM,mBACN,MAAM,sBACN,MAAM,GAAC,IAAI,qBACX,MAAM,GAAC,IAAI,eACX,KAAK,CAAC,MAAM,CAAC,cACb,KAAK,CAAC,MAAM,CAAC,oBACb,KAAK,CAAC,MAAM,CAAC,oBACb,OAAO,oBAAoB,EAAE,SAAS,iBACtC,MAAM,0BACN,MAAM,GACL;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAgM1C;AAED;;;;;;;;;GASG;AACH,6DARW,YAAY,qBACZ,MAAM,eACN,KAAK,CAAC,MAAM,CAAC,cACb,KAAK,CAAC,MAAM,CAAC,wBACb,MAAM,GACL,MAAM,CA0CjB;AAED;;;;GAIG;AACH,qCAFY,SAAS,CAUpB;AAED;;;;;;GAMG;AACH,kCAJW,MAAM,iCAEL,KAAK,CAAC,MAAM,CAAC,CAWxB;AAED;;;;;GAKG;AACH,qCAHW,KAAK,CAAC,MAAM,CAAC,GACZ,MAAM,CAWjB;AAxaD,mDAAoD;;;;;;;;oBAQtC,MAAM;;;;mBACN,MAAM"}

package/render/webgl/utils.js

@@ -153,7 +153,7 @@ export function writeLineSegmentToBuffers(
   currentAngleTangentSum,
 ) {
   // compute the stride to determine how many vertices were already pushed
-  const baseVertexAttrsCount = 8; // base attributes: x0, y0, x1, y1, angle0, angle1, distance, params
+  const baseVertexAttrsCount = 10; // base attributes: x0, y0, m0, x1, y1, m1, angle0, angle1, distance, params
   const stride = baseVertexAttrsCount + customAttributes.length;
   const baseIndex = vertexArray.length / stride;
 
@@ -166,6 +166,9 @@ export function writeLineSegmentToBuffers(
   ];
   const p1 = [instructions[segmentEndIndex], instructions[segmentEndIndex + 1]];
 
+  const m0 = instructions[segmentStartIndex + 2];
+  const m1 = instructions[segmentEndIndex + 2];
+
   // to compute join angles we need to reproject coordinates back in world units
   const p0world = applyTransform(toWorldTransform, [...p0]);
   const p1world = applyTransform(toWorldTransform, [...p1]);
@@ -254,8 +257,10 @@ export function writeLineSegmentToBuffers(
   vertexArray.push(
     p0[0],
     p0[1],
+    m0,
     p1[0],
     p1[1],
+    m1,
     angle0,
     angle1,
     currentLength,
@@ -266,8 +271,10 @@ export function writeLineSegmentToBuffers(
   vertexArray.push(
     p0[0],
     p0[1],
+    m0,
     p1[0],
     p1[1],
+    m1,
     angle0,
     angle1,
     currentLength,
@@ -278,8 +285,10 @@ export function writeLineSegmentToBuffers(
   vertexArray.push(
     p0[0],
     p0[1],
+    m0,
     p1[0],
     p1[1],
+    m1,
     angle0,
     angle1,
     currentLength,
@@ -290,8 +299,10 @@ export function writeLineSegmentToBuffers(
   vertexArray.push(
     p0[0],
     p0[1],
+    m0,
     p1[0],
     p1[1],
+    m1,
     angle0,
     angle1,
     currentLength,

package/util.js

@@ -33,4 +33,4 @@ export function getUid(obj) {
  * OpenLayers version.
  * @type {string}
  */
-export const VERSION = '10.0.1-dev.1723498832296';
+export const VERSION = '10.0.1-dev.1723626173667';

package/webgl/ShaderBuilder.d.ts

@@ -1,4 +1,4 @@
-export const COMMON_HEADER: "#ifdef GL_FRAGMENT_PRECISION_HIGH\nprecision highp float;\n#else\nprecision mediump float;\n#endif\nuniform mat4 u_projectionMatrix;\nuniform mat4 u_screenToWorldMatrix;\nuniform vec2 u_viewportSizePx;\nuniform float u_pixelRatio;\nuniform float u_globalAlpha;\nuniform float u_time;\nuniform float u_zoom;\nuniform float u_resolution;\nuniform float u_rotation;\nuniform vec4 u_renderExtent;\nuniform vec2 u_patternOrigin;\nuniform float u_depth;\nuniform mediump int u_hitDetection;\n\nconst float PI = 3.141592653589793238;\nconst float TWO_PI = 2.0 * PI;\n\n// this used to produce an alpha-premultiplied color from a texture\nvec4 samplePremultiplied(sampler2D sampler, vec2 texCoord) {\n  vec4 color = texture2D(sampler, texCoord);\n  return vec4(color.rgb * color.a, color.a);\n}\n";
+export const COMMON_HEADER: "#ifdef GL_FRAGMENT_PRECISION_HIGH\nprecision highp float;\n#else\nprecision mediump float;\n#endif\nuniform mat4 u_projectionMatrix;\nuniform mat4 u_screenToWorldMatrix;\nuniform vec2 u_viewportSizePx;\nuniform float u_pixelRatio;\nuniform float u_globalAlpha;\nuniform float u_time;\nuniform float u_zoom;\nuniform float u_resolution;\nuniform float u_rotation;\nuniform vec4 u_renderExtent;\nuniform vec2 u_patternOrigin;\nuniform float u_depth;\nuniform mediump int u_hitDetection;\n\nconst float PI = 3.141592653589793238;\nconst float TWO_PI = 2.0 * PI;\nfloat currentLineMetric = 0.; // an actual value will be used in the stroke shaders\n";
 /**
  * @typedef {Object} VaryingDescription
  * @property {string} name Varying name, as will be declared in the header.
@@ -19,6 +19,10 @@ export const COMMON_HEADER: "#ifdef GL_FRAGMENT_PRECISION_HIGH\nprecision highp
  *   .setSymbolSizeExpression('...')
  *   .getSymbolFragmentShader();
  * ```
+ *
+ * A note on [alpha premultiplication](https://en.wikipedia.org/wiki/Alpha_compositing#Straight_versus_premultiplied):
+ * The ShaderBuilder class expects all colors to **not having been alpha-premultiplied!** This is because alpha
+ * premultiplication is done at the end of each fragment shader.
  */
 export class ShaderBuilder {
     /**

package/webgl/ShaderBuilder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShaderBuilder.d.ts","sourceRoot":"","sources":["ShaderBuilder.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"ShaderBuilder.d.ts","sourceRoot":"","sources":["ShaderBuilder.js"],"names":[],"mappings":"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"}

package/webgl/ShaderBuilder.js

@@ -27,12 +27,7 @@ uniform mediump int u_hitDetection;
 
 const float PI = 3.141592653589793238;
 const float TWO_PI = 2.0 * PI;
-
-// this used to produce an alpha-premultiplied color from a texture
-vec4 samplePremultiplied(sampler2D sampler, vec2 texCoord) {
-  vec4 color = texture2D(sampler, texCoord);
-  return vec4(color.rgb * color.a, color.a);
-}
+float currentLineMetric = 0.; // an actual value will be used in the stroke shaders
 `;
 
 const DEFAULT_STYLE = createDefaultStyle();
@@ -58,6 +53,10 @@ const DEFAULT_STYLE = createDefaultStyle();
  *   .setSymbolSizeExpression('...')
  *   .getSymbolFragmentShader();
  * ```
+ *
+ * A note on [alpha premultiplication](https://en.wikipedia.org/wiki/Alpha_compositing#Straight_versus_premultiplied):
+ * The ShaderBuilder class expects all colors to **not having been alpha-premultiplied!** This is because alpha
+ * premultiplication is done at the end of each fragment shader.
  */
 export class ShaderBuilder {
   constructor() {
@@ -580,6 +579,7 @@ void main(void) {
   float s = sin(v_angle);
   coordsPx = vec2(c * coordsPx.x - s * coordsPx.y, s * coordsPx.x + c * coordsPx.y);
   gl_FragColor = ${this.symbolColorExpression_};
+  gl_FragColor.rgb *= gl_FragColor.a;
   if (u_hitDetection > 0) {
     if (gl_FragColor.a < 0.05) { discard; };
     gl_FragColor = v_prop_hitColor;
@@ -602,10 +602,10 @@ ${this.uniforms_
     return 'uniform ' + uniform + ';';
   })
   .join('\n')}
-attribute vec2 a_position;
-attribute float a_index;
 attribute vec2 a_segmentStart;
 attribute vec2 a_segmentEnd;
+attribute float a_measureStart;
+attribute float a_measureEnd;
 attribute float a_parameters;
 attribute float a_distance;
 attribute vec2 a_joinAngles;
@@ -622,6 +622,8 @@ varying float v_angleEnd;
 varying float v_width;
 varying vec4 v_prop_hitColor;
 varying float v_distanceOffsetPx;
+varying float v_measureStart;
+varying float v_measureEnd;
 ${this.varyings_
   .map(function (varying) {
     return 'varying ' + varying.type + ' ' + varying.name + ';';
@@ -664,6 +666,7 @@ void main(void) {
   v_angleStart = a_joinAngles.x;
   v_angleEnd = a_joinAngles.y;
   float vertexNumber = floor(abs(a_parameters) / 10000. + 0.5);
+  currentLineMetric = vertexNumber < 1.5 ? a_measureStart : a_measureEnd;
   // we're reading the fractional part while keeping the sign (so -4.12 gives -0.12, 3.45 gives 0.45)
   float angleTangentSum = fract(abs(a_parameters) / 10000.) * 10000. * sign(a_parameters);
 
@@ -698,6 +701,8 @@ void main(void) {
   v_width = lineWidth;
   v_prop_hitColor = a_prop_hitColor;
   v_distanceOffsetPx = a_distance / u_resolution - (lineOffsetPx * angleTangentSum);
+  v_measureStart = a_measureStart;
+  v_measureEnd = a_measureEnd;
 ${this.varyings_
   .map(function (varying) {
     return '  ' + varying.name + ' = ' + varying.expression + ';';
@@ -729,6 +734,8 @@ varying float v_angleEnd;
 varying float v_width;
 varying vec4 v_prop_hitColor;
 varying float v_distanceOffsetPx;
+varying float v_measureStart;
+varying float v_measureEnd;
 ${this.varyings_
   .map(function (varying) {
     return 'varying ' + varying.type + ' ' + varying.name + ';';
@@ -834,16 +841,20 @@ void main(void) {
     discard;
   }
   #endif
-  if (${this.discardExpression_}) { discard; }
 
   float segmentLength = length(v_segmentEnd - v_segmentStart);
   vec2 segmentTangent = (v_segmentEnd - v_segmentStart) / segmentLength;
   vec2 segmentNormal = vec2(-segmentTangent.y, segmentTangent.x);
   vec2 startToPoint = currentPoint - v_segmentStart;
-  float currentLengthPx = max(0., min(dot(segmentTangent, startToPoint), segmentLength)) + v_distanceOffsetPx; 
+  float lengthToPoint = max(0., min(dot(segmentTangent, startToPoint), segmentLength));
+  float currentLengthPx = lengthToPoint + v_distanceOffsetPx; 
   float currentRadiusPx = abs(dot(segmentNormal, startToPoint));
   float currentRadiusRatio = dot(segmentNormal, startToPoint) * 2. / v_width;
-  vec4 color = ${this.strokeColorExpression_} * u_globalAlpha;
+  currentLineMetric = mix(v_measureStart, v_measureEnd, lengthToPoint / segmentLength);
+
+  if (${this.discardExpression_}) { discard; }
+
+  vec4 color = ${this.strokeColorExpression_};
   float capType = ${this.strokeCapExpression_};
   float joinType = ${this.strokeJoinExpression_};
   float segmentStartDistance = computeSegmentPointDistance(currentPoint, v_segmentStart, v_segmentEnd, v_width, v_angleStart, capType, joinType);
@@ -853,7 +864,10 @@ void main(void) {
     max(segmentStartDistance, segmentEndDistance)
   );
   distance = max(distance, ${this.strokeDistanceFieldExpression_});
-  gl_FragColor = color * smoothstep(0.5, -0.5, distance);
+  color.a *= smoothstep(0.5, -0.5, distance);
+  gl_FragColor = color;
+  gl_FragColor.a *= u_globalAlpha;
+  gl_FragColor.rgb *= gl_FragColor.a;
   if (u_hitDetection > 0) {
     if (gl_FragColor.a < 0.1) { discard; };
     gl_FragColor = v_prop_hitColor;
@@ -951,7 +965,9 @@ void main(void) {
   }
   #endif
   if (${this.discardExpression_}) { discard; }
-  gl_FragColor = ${this.fillColorExpression_} * u_globalAlpha;
+  gl_FragColor = ${this.fillColorExpression_};
+  gl_FragColor.a *= u_globalAlpha;
+  gl_FragColor.rgb *= gl_FragColor.a;
   if (u_hitDetection > 0) {
     if (gl_FragColor.a < 0.1) { discard; };
     gl_FragColor = v_prop_hitColor;