ol 10.6.2-dev.1751730309835 → 10.6.2-dev.1751964281167

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ol",
-  "version": "10.6.2-dev.1751730309835",
+  "version": "10.6.2-dev.1751964281167",
   "description": "OpenLayers mapping library",
   "keywords": [
     "map",

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

@@ -1 +1 @@
-{"version":3,"file":"ShaderBuilder.d.ts","sourceRoot":"","sources":["ShaderBuilder.js"],"names":[],"mappings":"AAQA,oqBAsBE;AAIF;;;;;;;GAOG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH;IAEI;;;;OAIG;IACH,kBAAmB;IAEnB;;;;OAIG;IACH,oBAAqB;IAErB;;;OAGG;IACH,mBAAuB;IAEvB;;;OAGG;IACH,8BAEkE;IAElE;;;OAGG;IACH,kCAAsC;IAEtC;;;OAGG;IACH,gCAA0C;IAE1C;;;OAGG;IACH,+BAEC;IAED;;;OAGG;IACH,4BAAqD;IAErD;;;OAGG;IACH,2BAAiC;IAEjC;;;OAGG;IACH,8BAAkC;IAElC;;;OAGG;IACH,mBAAuB;IAEvB;;;OAGG;IACH,+BAAyE;IAEzE;;;OAGG;IACH,+BAEC;IAED;;OAEG;IACH,gCAAmC;IAEnC;;OAEG;IACH,6BAAiD;IAEjD;;OAEG;IACH,8BAAkD;IAElD;;OAEG;IACH,oCAAwC;IAExC;;OAEG;IACH,uCAA8C;IAE9C;;;OAGG;IACH,iBAAqB;IAErB;;;OAGG;IACH,6BAEC;IAED;;;OAGG;IACH,+BAAgC;IAEhC;;;OAGG;IACH,iCAAkC;IAGpC;;;;;;OAMG;IACH,iBAJW,MAAM,QACN,OAAO,GAAC,MAAM,GAAC,MAAM,GAAC,MAAM,GAAC,WAAW,GACvC,aAAa,CAQxB;IAED;;;;;;;;;;;OAWG;IACH,mBARW,MAAM,QACN,OAAO,GAAC,MAAM,GAAC,MAAM,GAAC,MAAM,sBAC5B,MAAM,gBAEN,OAAO,GAAC,MAAM,GAAC,MAAM,GAAC,MAAM,GAE3B,aAAa,CAWxB;IAED;;;;;;OAMG;IACH,oCAHW,MAAM,GACL,aAAa,CAMxB;IAED;;OAEG;IACH,2BAFY,MAAM,CAIjB;IAED;;;;;;OAMG;IACH,wCAHW,MAAM,GACL,aAAa,CAKxB;IAED;;;;;;OAMG;IACH,sCAHW,MAAM,GACL,aAAa,CAKxB;IAED;;OAEG;IACH,6BAFY,MAAM,CAIjB;IAED;;;;;;OAMG;IACH,qCAHW,MAAM,GACL,aAAa,CAMxB;IAED;;OAEG;IACH,4BAFY,MAAM,CAIjB;IAED;;;;;;OAMG;IACH,2CAHW,MAAM,GACL,aAAa,CAKxB;IAED;;;;;;;;OAQG;IACH,yCAHW,MAAM,GACL,aAAa,CAKxB;IAED;;OAEG;IACH,gCAFY,MAAM,CAIjB;IAED;;;;;OAKG;IACH,wCAHW,OAAO,GACN,aAAa,CAKxB;IAED;;;OAGG;IACH,qCAHW,MAAM,GACL,aAAa,CAMxB;IAED;;;OAGG;IACH,qCAHW,MAAM,GACL,aAAa,CAMxB;IAED;;OAEG;IACH,4BAFY,MAAM,CAIjB;IAED;;;OAGG;IACH,sCAHW,MAAM,GACL,aAAa,CAKxB;IAED;;;OAGG;IACH,mCAHW,MAAM,GACL,aAAa,CAKxB;IAED;;;OAGG;IACH,oCAHW,MAAM,GACL,aAAa,CAKxB;IAED;;;OAGG;IACH,0CAHW,MAAM,GACL,aAAa,CAKxB;IAED;;;;OAIG;IACH,6CAJW,MAAM,GAEL,aAAa,CAKxB;IAED;;;OAGG;IACH,mCAHW,MAAM,GACL,aAAa,CAMxB;IAED;;OAEG;IACH,0BAFY,MAAM,CAIjB;IAED,yCAMC;IACD,2CAMC;IAED;;;OAGG;IACH,yBAFY,MAAM,GAAC,IAAI,CAyEtB;IAED;;;OAGG;IACH,2BAFY,MAAM,GAAC,IAAI,CAwCtB;IAED;;;OAGG;IACH,yBAFY,MAAM,GAAC,IAAI,CAmHtB;IAED;;;;OAIG;IACH,2BAFY,MAAM,GAAC,IAAI,CA+KtB;IAED;;;;OAIG;IACH,uBAFY,MAAM,GAAC,IAAI,CA+BtB;IAED;;;OAGG;IACH,yBAFY,MAAM,GAAC,IAAI,CAyDtB;CACF;;;;;UAj7Ba,MAAM;;;;UACN,MAAM;;;;iBACN,MAAM;;;;iBACN,MAAM;;;;uBACN,MAAM;;;;;;UAKN,MAAM;;;;UACN,MAAM"}
+{"version":3,"file":"ShaderBuilder.d.ts","sourceRoot":"","sources":["ShaderBuilder.js"],"names":[],"mappings":"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"}

package/render/webgl/ShaderBuilder.js

@@ -475,7 +475,7 @@ export class ShaderBuilder {
     return `${COMMON_HEADER}
 ${this.uniforms_.map((uniform) => `uniform ${uniform.type} ${uniform.name};`).join('\n')}
 attribute vec2 a_position;
-attribute float a_index;
+attribute vec2 a_localPosition;
 attribute vec4 a_hitColor;
 
 varying vec2 v_texCoord;
@@ -505,16 +505,7 @@ void main(void) {
   v_quadSizePx = ${this.symbolSizeExpression_};
   vec2 halfSizePx = v_quadSizePx * 0.5;
   vec2 centerOffsetPx = ${this.symbolOffsetExpression_};
-  vec2 offsetPx = centerOffsetPx;
-  if (a_index == 0.0) {
-    offsetPx -= halfSizePx;
-  } else if (a_index == 1.0) {
-    offsetPx += halfSizePx * vec2(1., -1.);
-  } else if (a_index == 2.0) {
-    offsetPx += halfSizePx;
-  } else {
-    offsetPx += halfSizePx * vec2(-1., 1.);
-  }
+  vec2 offsetPx = centerOffsetPx + a_localPosition * halfSizePx * vec2(1., -1.);
   float angle = ${this.symbolRotationExpression_}${this.symbolRotateWithView_ ? ' + u_rotation' : ''};
   float c = cos(-angle);
   float s = sin(-angle);
@@ -522,8 +513,8 @@ void main(void) {
   vec4 center = u_projectionMatrix * vec4(a_position, 0.0, 1.0);
   gl_Position = center + vec4(pxToScreen(offsetPx), u_depth, 0.);
   vec4 texCoord = ${this.texCoordExpression_};
-  float u = a_index == 0.0 || a_index == 3.0 ? texCoord.s : texCoord.p;
-  float v = a_index == 2.0 || a_index == 3.0 ? texCoord.t : texCoord.q;
+  float u = mix(texCoord.s, texCoord.p, a_localPosition.x * 0.5 + 0.5);
+  float v = mix(texCoord.t, texCoord.q, a_localPosition.y * 0.5 + 0.5);
   v_texCoord = vec2(u, v);
   v_hitColor = a_hitColor;
   v_angle = angle;
@@ -597,9 +588,10 @@ ${this.attributes_
 ${this.uniforms_.map((uniform) => `uniform ${uniform.type} ${uniform.name};`).join('\n')}
 attribute vec2 a_segmentStart;
 attribute vec2 a_segmentEnd;
+attribute vec2 a_localPosition;
 attribute float a_measureStart;
 attribute float a_measureEnd;
-attribute float a_parameters;
+attribute float a_angleTangentSum;
 attribute float a_distance;
 attribute vec2 a_joinAngles;
 attribute vec4 a_hitColor;
@@ -656,10 +648,9 @@ vec2 getOffsetPoint(vec2 point, vec2 normal, float joinAngle, float offsetPx) {
 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;
+  float startEndRatio = a_localPosition.x * 0.5 + 0.5;
+  currentLineMetric = mix(a_measureStart, a_measureEnd, startEndRatio);
   // 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);
 
   float lineWidth = ${this.strokeWidthExpression_};
   float lineOffsetPx = ${this.strokeOffsetExpression_};
@@ -673,11 +664,11 @@ void main(void) {
   segmentEndPx = getOffsetPoint(segmentEndPx, normalPx, v_angleEnd, lineOffsetPx);
 
   // compute current vertex position
-  float normalDir = vertexNumber < 0.5 || (vertexNumber > 1.5 && vertexNumber < 2.5) ? 1.0 : -1.0;
-  float tangentDir = vertexNumber < 1.5 ? 1.0 : -1.0;
-  float angle = vertexNumber < 1.5 ? v_angleStart : v_angleEnd;
+  float normalDir = -1. * a_localPosition.y;
+  float tangentDir = -1. * a_localPosition.x;
+  float angle = mix(v_angleStart, v_angleEnd, startEndRatio);
   vec2 joinDirection;
-  vec2 positionPx = vertexNumber < 1.5 ? segmentStartPx : segmentEndPx;
+  vec2 positionPx = mix(segmentStartPx, segmentEndPx, startEndRatio);
   // if angle is too high, do not make a proper join
   if (cos(angle) > ${LINESTRING_ANGLE_COSINE_CUTOFF} || isCap(angle)) {
     joinDirection = normalPx * normalDir - tangentPx * tangentDir;
@@ -691,7 +682,7 @@ void main(void) {
   v_segmentEnd = segmentEndPx;
   v_width = lineWidth;
   v_hitColor = a_hitColor;
-  v_distanceOffsetPx = a_distance / u_resolution - (lineOffsetPx * angleTangentSum);
+  v_distanceOffsetPx = a_distance / u_resolution - (lineOffsetPx * a_angleTangentSum);
   v_measureStart = a_measureStart;
   v_measureEnd = a_measureEnd;
 ${this.attributes_

package/render/webgl/VectorStyleRenderer.d.ts

@@ -12,12 +12,12 @@ export function convertStyleToShaders(style: FlatStyleLike | StyleShaders | Arra
 export type Attributes = string;
 export namespace Attributes {
     let POSITION: string;
-    let INDEX: string;
+    let LOCAL_POSITION: string;
     let SEGMENT_START: string;
     let SEGMENT_END: string;
     let MEASURE_START: string;
     let MEASURE_END: string;
-    let PARAMETERS: string;
+    let ANGLE_TANGENT_SUM: string;
     let JOIN_ANGLES: string;
     let DISTANCE: string;
 }
@@ -44,19 +44,23 @@ export type AttributeDefinitions = {
 export type UniformDefinitions = {
     [x: string]: import("../../webgl/Helper.js").UniformValue;
 };
+/**
+ * Buffers organized like so: [indicesBuffer, vertexAttributesBuffer, instanceAttributesBuffer]
+ */
+export type WebGLArrayBufferSet = Array<WebGLArrayBuffer>;
 export type WebGLBuffers = {
     /**
      * Array containing indices and vertices buffers for polygons
      */
-    polygonBuffers: Array<WebGLArrayBuffer>;
+    polygonBuffers: WebGLArrayBufferSet;
     /**
      * Array containing indices and vertices buffers for line strings
      */
-    lineStringBuffers: Array<WebGLArrayBuffer>;
+    lineStringBuffers: WebGLArrayBufferSet;
     /**
      * Array containing indices and vertices buffers for points
      */
-    pointBuffers: Array<WebGLArrayBuffer>;
+    pointBuffers: WebGLArrayBufferSet;
     /**
      * Inverse of the transform applied when generating buffers
      */
@@ -103,9 +107,17 @@ export type SubRenderPass = {
      */
     fragmentShader: string;
     /**
-     * Attributes description
+     * Attributes description, defined for each primitive vertex
      */
     attributesDesc: Array<import("../../webgl/Helper.js").AttributeDescription>;
+    /**
+     * Attributes description, defined once per primitive
+     */
+    instancedAttributesDesc: Array<import("../../webgl/Helper.js").AttributeDescription>;
+    /**
+     * Number of vertices per instance primitive in this render pass
+     */
+    instancePrimitiveVertexCount: number;
     /**
      * Program; this has to be recreated if the helper is lost/changed
      */
@@ -137,11 +149,14 @@ export type RenderPass = {
  * @typedef {Object<string, AttributeDefinition>} AttributeDefinitions
  * @typedef {Object<string, import("../../webgl/Helper").UniformValue>} UniformDefinitions
  */
+/**
+ * @typedef {Array<WebGLArrayBuffer>} WebGLArrayBufferSet Buffers organized like so: [indicesBuffer, vertexAttributesBuffer, instanceAttributesBuffer]
+ */
 /**
  * @typedef {Object} WebGLBuffers
- * @property {Array<WebGLArrayBuffer>} polygonBuffers Array containing indices and vertices buffers for polygons
- * @property {Array<WebGLArrayBuffer>} lineStringBuffers Array containing indices and vertices buffers for line strings
- * @property {Array<WebGLArrayBuffer>} pointBuffers Array containing indices and vertices buffers for points
+ * @property {WebGLArrayBufferSet} polygonBuffers Array containing indices and vertices buffers for polygons
+ * @property {WebGLArrayBufferSet} lineStringBuffers Array containing indices and vertices buffers for line strings
+ * @property {WebGLArrayBufferSet} pointBuffers Array containing indices and vertices buffers for points
  * @property {import("../../transform.js").Transform} invertVerticesTransform Inverse of the transform applied when generating buffers
  */
 /**
@@ -171,7 +186,9 @@ export type RenderPass = {
  * @typedef {Object} SubRenderPass
  * @property {string} vertexShader Vertex shader
  * @property {string} fragmentShader Fragment shader
- * @property {Array<import('../../webgl/Helper.js').AttributeDescription>} attributesDesc Attributes description
+ * @property {Array<import('../../webgl/Helper.js').AttributeDescription>} attributesDesc Attributes description, defined for each primitive vertex
+ * @property {Array<import('../../webgl/Helper.js').AttributeDescription>} instancedAttributesDesc Attributes description, defined once per primitive
+ * @property {number} instancePrimitiveVertexCount Number of vertices per instance primitive in this render pass
  * @property {WebGLProgram} [program] Program; this has to be recreated if the helper is lost/changed
  */
 /**
@@ -248,7 +265,7 @@ declare class VectorStyleRenderer {
      * @param {Float32Array|null} renderInstructions Render instructions
      * @param {import("../../geom/Geometry.js").Type} geometryType Geometry type
      * @param {import("../../transform.js").Transform} transform Transform to apply to coordinates
-     * @return {Promise<Array<WebGLArrayBuffer>>|null} Indices buffer and vertices buffer; null if nothing to render
+     * @return {Promise<WebGLArrayBufferSet>|null} Indices buffer and vertices buffer; null if nothing to render
      * @private
      */
     private generateBuffersForType_;
@@ -261,9 +278,9 @@ declare class VectorStyleRenderer {
     render(buffers: WebGLBuffers, frameState: import("../../Map.js").FrameState, preRenderCallback: () => void): void;
     /**
      * @param {WebGLArrayBuffer} indicesBuffer Indices buffer
-     * @param {WebGLArrayBuffer} verticesBuffer Vertices buffer
-     * @param {WebGLProgram} program Program
-     * @param {Array<import('../../webgl/Helper.js').AttributeDescription>} attributes Attribute descriptions
+     * @param {WebGLArrayBuffer} vertexAttributesBuffer Vertex attributes buffer
+     * @param {WebGLArrayBuffer} instanceAttributesBuffer Instance attributes buffer
+     * @param {SubRenderPass} subRenderPass Render pass (program, attributes, etc.) specific to one geometry type
      * @param {import("../../Map.js").FrameState} frameState Frame state.
      * @param {function(): void} preRenderCallback This callback will be called right before drawing, and can be used to set uniforms
      * @private

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

@@ -1 +1 @@
-{"version":3,"file":"VectorStyleRenderer.d.ts","sourceRoot":"","sources":["VectorStyleRenderer.js"],"names":[],"mappings":"AAmkBA;;;;;GAKG;AACH,6CAJW,aAAa,GAAC,YAAY,GAAC,KAAK,CAAC,YAAY,CAAC,aAC9C,OAAO,qBAAqB,EAAE,cAAc,GAC3C,KAAK,CAAC,YAAY,CAAC,CAuD9B;;;;;yBA3lBS,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmBF,CAAS,IAAwD,EAAnD,OAAO,yBAAyB,EAAE,iBAAiB,EAAE,IAAmC,EAAnC,OAAO,eAAe,EAAE,WAAW,KAAE,MAAM,GAAC,KAAK,CAAC,MAAM,CAAC;;;;;;;;;;;;oBAW5H,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;;2BAIP,OAAO,YAAY,EAAE,gBAAgB;4BAIrC,OAAO,qBAAqB,EAAE,aAAa;wBAG3C,OAAO,qBAAqB,EAAE,SAAS;4BAGvC,OAAO,qBAAqB,EAAE,IAAI;;;;;kBAKjC,MAAM;;;;oBACN,MAAM;;;;oBACN,KAAK,CAAC,OAAO,uBAAuB,EAAE,oBAAoB,CAAC;;;;;;;;;;;;;;;;;;;;AArDzE;;;;;;;GAOG;AAEH;;;GAGG;AAEH;;;;;;GAMG;AAEH;;;;;GAKG;AAEH;;;;GAIG;AAEH;;GAEG;AAEH;;GAEG;AACH;;GAEG;AACH;;GAEG;AAEH;;;;;;GAMG;AAEH;;;;;GAKG;AAEH;;;;;;;;;;GAUG;AACH;IACE;;;;;OAKG;IACH,oBALW,aAAa,GAAC,YAAY,GAAC,KAAK,CAAC,YAAY,CAAC,aAC9C,OAAO,qBAAqB,EAAE,cAAc,UAC5C,OAAO,uBAAuB,EAAE,OAAO,uBACvC,OAAO,EAwKjB;IArKC;;;OAGG;IACH,gBAAY;IAEZ;;OAEG;IACH,6BAAgD;IAEhD;;;OAGG;IACH,qBAA4D;IAE5D;;;OAGG;IACH,0BAA2B;IAE3B;;;OAGG;IACH,kBAAmB;IAgCnB;;;OAGG;IACH,sBA8FE;IAEF,kBAAsE;IACtE,oBAA0E;IAC1E,oBAA0E;IAM5E;;;;OAIG;IACH,+BAJW,OAAO,yBAAyB,EAAE,OAAO,aACzC,OAAO,oBAAoB,EAAE,SAAS,GACrC,OAAO,CAAC,YAAY,GAAC,IAAI,CAAC,CAwCrC;IAED;;;;;OAKG;IACH,oCA+BC;IAED;;;;;;OAMG;IACH,gCAwEC;IAED;;;;;OAKG;IACH,gBAJW,YAAY,cACZ,OAAO,cAAc,EAAE,UAAU,qBACjC,MAAY,IAAI,QAgC1B;IAED;;;;;;;;OAQG;IACH,wBAkBC;IAED;;;OAGG;IACH,kBAHW,OAAO,uBAAuB,EAAE,OAAO,YACvC,YAAY,QAyCtB;CACF;6BAxjB4B,uBAAuB"}
+{"version":3,"file":"VectorStyleRenderer.d.ts","sourceRoot":"","sources":["VectorStyleRenderer.js"],"names":[],"mappings":"AAunBA;;;;;GAKG;AACH,6CAJW,aAAa,GAAC,YAAY,GAAC,KAAK,CAAC,YAAY,CAAC,aAC9C,OAAO,qBAAqB,EAAE,cAAc,GAC3C,KAAK,CAAC,YAAY,CAAC,CAuD9B;;;;;yBA/oBS,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmBF,CAAS,IAAwD,EAAnD,OAAO,yBAAyB,EAAE,iBAAiB,EAAE,IAAmC,EAAnC,OAAO,eAAe,EAAE,WAAW,KAAE,MAAM,GAAC,KAAK,CAAC,MAAM,CAAC;;;;;;;;;;;kCAU7H,KAAK,CAAC,gBAAgB,CAAC;;;;;oBAKtB,mBAAmB;;;;uBACnB,mBAAmB;;;;kBACnB,mBAAmB;;;;6BACnB,OAAO,oBAAoB,EAAE,SAAS;;;;;;yBAKtC,YAAY,GAAC,IAAI;;;;4BACjB,YAAY,GAAC,IAAI;;;;uBACjB,YAAY,GAAC,IAAI;;;;;;;;;YAKjB,MAAM;;;;cACN,MAAM;;2BAIP,OAAO,YAAY,EAAE,gBAAgB;4BAIrC,OAAO,qBAAqB,EAAE,aAAa;wBAG3C,OAAO,qBAAqB,EAAE,SAAS;4BAGvC,OAAO,qBAAqB,EAAE,IAAI;;;;;kBAKjC,MAAM;;;;oBACN,MAAM;;;;oBACN,KAAK,CAAC,OAAO,uBAAuB,EAAE,oBAAoB,CAAC;;;;6BAC3D,KAAK,CAAC,OAAO,uBAAuB,EAAE,oBAAoB,CAAC;;;;kCAC3D,MAAM;;;;;;;;;;;;;;;;;;;;AA3DpB;;;;;;;GAOG;AAEH;;;GAGG;AAEH;;GAEG;AAEH;;;;;;GAMG;AAEH;;;;;GAKG;AAEH;;;;GAIG;AAEH;;GAEG;AAEH;;GAEG;AACH;;GAEG;AACH;;GAEG;AAEH;;;;;;;;GAQG;AAEH;;;;;GAKG;AAEH;;;;;;;;;;GAUG;AACH;IACE;;;;;OAKG;IACH,oBALW,aAAa,GAAC,YAAY,GAAC,KAAK,CAAC,YAAY,CAAC,aAC9C,OAAO,qBAAqB,EAAE,cAAc,UAC5C,OAAO,uBAAuB,EAAE,OAAO,uBACvC,OAAO,EAqLjB;IAlLC;;;OAGG;IACH,gBAAY;IAEZ;;OAEG;IACH,6BAAgD;IAEhD;;;OAGG;IACH,qBAA4D;IAE5D;;;OAGG;IACH,0BAA2B;IAE3B;;;OAGG;IACH,kBAAmB;IAgCnB;;;OAGG;IACH,sBA2GE;IAEF,kBAAsE;IACtE,oBAA0E;IAC1E,oBAA0E;IAM5E;;;;OAIG;IACH,+BAJW,OAAO,yBAAyB,EAAE,OAAO,aACzC,OAAO,oBAAoB,EAAE,SAAS,GACrC,OAAO,CAAC,YAAY,GAAC,IAAI,CAAC,CAwCrC;IAED;;;;;OAKG;IACH,oCA+BC;IAED;;;;;;OAMG;IACH,gCAiFC;IAED;;;;;OAKG;IACH,gBAJW,YAAY,cACZ,OAAO,cAAc,EAAE,UAAU,qBACjC,MAAY,IAAI,QAgC1B;IAED;;;;;;;;OAQG;IACH,wBAuCC;IAED;;;OAGG;IACH,kBAHW,OAAO,uBAAuB,EAAE,OAAO,YACvC,YAAY,QA4CtB;CACF;6BA5mB4B,uBAAuB"}

package/render/webgl/VectorStyleRenderer.js

@@ -37,12 +37,12 @@ let workerMessageCounter = 0;
  */
 export const Attributes = {
   POSITION: 'a_position',
-  INDEX: 'a_index',
+  LOCAL_POSITION: 'a_localPosition',
   SEGMENT_START: 'a_segmentStart',
   SEGMENT_END: 'a_segmentEnd',
   MEASURE_START: 'a_measureStart',
   MEASURE_END: 'a_measureEnd',
-  PARAMETERS: 'a_parameters',
+  ANGLE_TANGENT_SUM: 'a_angleTangentSum',
   JOIN_ANGLES: 'a_joinAngles',
   DISTANCE: 'a_distance',
 };
@@ -61,11 +61,15 @@ export const Attributes = {
  * @typedef {Object<string, import("../../webgl/Helper").UniformValue>} UniformDefinitions
  */
 
+/**
+ * @typedef {Array<WebGLArrayBuffer>} WebGLArrayBufferSet Buffers organized like so: [indicesBuffer, vertexAttributesBuffer, instanceAttributesBuffer]
+ */
+
 /**
  * @typedef {Object} WebGLBuffers
- * @property {Array<WebGLArrayBuffer>} polygonBuffers Array containing indices and vertices buffers for polygons
- * @property {Array<WebGLArrayBuffer>} lineStringBuffers Array containing indices and vertices buffers for line strings
- * @property {Array<WebGLArrayBuffer>} pointBuffers Array containing indices and vertices buffers for points
+ * @property {WebGLArrayBufferSet} polygonBuffers Array containing indices and vertices buffers for polygons
+ * @property {WebGLArrayBufferSet} lineStringBuffers Array containing indices and vertices buffers for line strings
+ * @property {WebGLArrayBufferSet} pointBuffers Array containing indices and vertices buffers for points
  * @property {import("../../transform.js").Transform} invertVerticesTransform Inverse of the transform applied when generating buffers
  */
 
@@ -100,7 +104,9 @@ export const Attributes = {
  * @typedef {Object} SubRenderPass
  * @property {string} vertexShader Vertex shader
  * @property {string} fragmentShader Fragment shader
- * @property {Array<import('../../webgl/Helper.js').AttributeDescription>} attributesDesc Attributes description
+ * @property {Array<import('../../webgl/Helper.js').AttributeDescription>} attributesDesc Attributes description, defined for each primitive vertex
+ * @property {Array<import('../../webgl/Helper.js').AttributeDescription>} instancedAttributesDesc Attributes description, defined once per primitive
+ * @property {number} instancePrimitiveVertexCount Number of vertices per instance primitive in this render pass
  * @property {WebGLProgram} [program] Program; this has to be recreated if the helper is lost/changed
  */
 
@@ -221,6 +227,8 @@ class VectorStyleRenderer {
             },
             ...customAttributesDesc,
           ],
+          instancedAttributesDesc: [], // no instanced rendering for polygons
+          instancePrimitiveVertexCount: 3,
         };
       }
       if (styleShader.builder.getStrokeVertexShader()) {
@@ -228,6 +236,13 @@ class VectorStyleRenderer {
           vertexShader: styleShader.builder.getStrokeVertexShader(),
           fragmentShader: styleShader.builder.getStrokeFragmentShader(),
           attributesDesc: [
+            {
+              name: Attributes.LOCAL_POSITION,
+              size: 2,
+              type: AttributeType.FLOAT,
+            },
+          ],
+          instancedAttributesDesc: [
             {
               name: Attributes.SEGMENT_START,
               size: 2,
@@ -259,12 +274,13 @@ class VectorStyleRenderer {
               type: AttributeType.FLOAT,
             },
             {
-              name: Attributes.PARAMETERS,
+              name: Attributes.ANGLE_TANGENT_SUM,
               size: 1,
               type: AttributeType.FLOAT,
             },
             ...customAttributesDesc,
           ],
+          instancePrimitiveVertexCount: 6,
         };
       }
       if (styleShader.builder.getSymbolVertexShader()) {
@@ -273,17 +289,20 @@ class VectorStyleRenderer {
           fragmentShader: styleShader.builder.getSymbolFragmentShader(),
           attributesDesc: [
             {
-              name: Attributes.POSITION,
+              name: Attributes.LOCAL_POSITION,
               size: 2,
               type: AttributeType.FLOAT,
             },
+          ],
+          instancedAttributesDesc: [
             {
-              name: Attributes.INDEX,
-              size: 1,
+              name: Attributes.POSITION,
+              size: 2,
               type: AttributeType.FLOAT,
             },
             ...customAttributesDesc,
           ],
+          instancePrimitiveVertexCount: 6,
         };
       }
       return renderPass;
@@ -385,7 +404,7 @@ class VectorStyleRenderer {
    * @param {Float32Array|null} renderInstructions Render instructions
    * @param {import("../../geom/Geometry.js").Type} geometryType Geometry type
    * @param {import("../../transform.js").Transform} transform Transform to apply to coordinates
-   * @return {Promise<Array<WebGLArrayBuffer>>|null} Indices buffer and vertices buffer; null if nothing to render
+   * @return {Promise<WebGLArrayBufferSet>|null} Indices buffer and vertices buffer; null if nothing to render
    * @private
    */
   generateBuffersForType_(renderInstructions, geometryType, transform) {
@@ -425,7 +444,7 @@ class VectorStyleRenderer {
 
     return new Promise((resolve) => {
       /**
-       * @param {*} event Event.
+       * @param {{data: import('./constants.js').WebGLWorkerGenerateBuffersMessage}} event Event.
        */
       const handleMessage = (event) => {
         const received = event.data;
@@ -444,18 +463,27 @@ class VectorStyleRenderer {
         }
 
         // copy & flush received buffers to GPU
-        const verticesBuffer = new WebGLArrayBuffer(
-          ARRAY_BUFFER,
-          DYNAMIC_DRAW,
-        ).fromArrayBuffer(received.vertexBuffer);
         const indicesBuffer = new WebGLArrayBuffer(
           ELEMENT_ARRAY_BUFFER,
           DYNAMIC_DRAW,
-        ).fromArrayBuffer(received.indexBuffer);
-        this.helper_.flushBufferData(verticesBuffer);
+        ).fromArrayBuffer(received.indicesBuffer);
+        const vertexAttributesBuffer = new WebGLArrayBuffer(
+          ARRAY_BUFFER,
+          DYNAMIC_DRAW,
+        ).fromArrayBuffer(received.vertexAttributesBuffer);
+        const instanceAttributesBuffer = new WebGLArrayBuffer(
+          ARRAY_BUFFER,
+          DYNAMIC_DRAW,
+        ).fromArrayBuffer(received.instanceAttributesBuffer);
         this.helper_.flushBufferData(indicesBuffer);
-
-        resolve([indicesBuffer, verticesBuffer]);
+        this.helper_.flushBufferData(vertexAttributesBuffer);
+        this.helper_.flushBufferData(instanceAttributesBuffer);
+
+        resolve([
+          indicesBuffer,
+          vertexAttributesBuffer,
+          instanceAttributesBuffer,
+        ]);
       };
 
       WEBGL_WORKER.addEventListener('message', handleMessage);
@@ -474,8 +502,8 @@ class VectorStyleRenderer {
         this.renderInternal_(
           buffers.polygonBuffers[0],
           buffers.polygonBuffers[1],
-          renderPass.fillRenderPass.program,
-          renderPass.fillRenderPass.attributesDesc,
+          buffers.polygonBuffers[2],
+          renderPass.fillRenderPass,
           frameState,
           preRenderCallback,
         );
@@ -483,8 +511,8 @@ class VectorStyleRenderer {
         this.renderInternal_(
           buffers.lineStringBuffers[0],
           buffers.lineStringBuffers[1],
-          renderPass.strokeRenderPass.program,
-          renderPass.strokeRenderPass.attributesDesc,
+          buffers.lineStringBuffers[2],
+          renderPass.strokeRenderPass,
           frameState,
           preRenderCallback,
         );
@@ -492,8 +520,8 @@ class VectorStyleRenderer {
         this.renderInternal_(
           buffers.pointBuffers[0],
           buffers.pointBuffers[1],
-          renderPass.symbolRenderPass.program,
-          renderPass.symbolRenderPass.attributesDesc,
+          buffers.pointBuffers[2],
+          renderPass.symbolRenderPass,
           frameState,
           preRenderCallback,
         );
@@ -502,18 +530,18 @@ class VectorStyleRenderer {
 
   /**
    * @param {WebGLArrayBuffer} indicesBuffer Indices buffer
-   * @param {WebGLArrayBuffer} verticesBuffer Vertices buffer
-   * @param {WebGLProgram} program Program
-   * @param {Array<import('../../webgl/Helper.js').AttributeDescription>} attributes Attribute descriptions
+   * @param {WebGLArrayBuffer} vertexAttributesBuffer Vertex attributes buffer
+   * @param {WebGLArrayBuffer} instanceAttributesBuffer Instance attributes buffer
+   * @param {SubRenderPass} subRenderPass Render pass (program, attributes, etc.) specific to one geometry type
    * @param {import("../../Map.js").FrameState} frameState Frame state.
    * @param {function(): void} preRenderCallback This callback will be called right before drawing, and can be used to set uniforms
    * @private
    */
   renderInternal_(
     indicesBuffer,
-    verticesBuffer,
-    program,
-    attributes,
+    vertexAttributesBuffer,
+    instanceAttributesBuffer,
+    subRenderPass,
     frameState,
     preRenderCallback,
   ) {
@@ -521,12 +549,33 @@ class VectorStyleRenderer {
     if (renderCount === 0) {
       return;
     }
-    this.helper_.useProgram(program, frameState);
-    this.helper_.bindBuffer(verticesBuffer);
+
+    const usesInstancedRendering = subRenderPass.instancedAttributesDesc.length;
+
+    this.helper_.useProgram(subRenderPass.program, frameState);
+    this.helper_.bindBuffer(vertexAttributesBuffer);
     this.helper_.bindBuffer(indicesBuffer);
-    this.helper_.enableAttributes(attributes);
+    this.helper_.enableAttributes(subRenderPass.attributesDesc);
+    this.helper_.bindBuffer(instanceAttributesBuffer);
+    this.helper_.enableAttributesInstanced(
+      subRenderPass.instancedAttributesDesc,
+    );
+
     preRenderCallback();
-    this.helper_.drawElements(0, renderCount);
+
+    if (usesInstancedRendering) {
+      const instanceAttributesStride =
+        subRenderPass.instancedAttributesDesc.reduce(
+          (prev, curr) => prev + (curr.size || 1),
+          0,
+        );
+      const instanceCount =
+        instanceAttributesBuffer.getSize() / instanceAttributesStride;
+
+      this.helper_.drawElementsInstanced(0, renderCount, instanceCount);
+    } else {
+      this.helper_.drawElements(0, renderCount);
+    }
   }
 
   /**
@@ -562,14 +611,17 @@ class VectorStyleRenderer {
       if (buffers.polygonBuffers) {
         this.helper_.flushBufferData(buffers.polygonBuffers[0]);
         this.helper_.flushBufferData(buffers.polygonBuffers[1]);
+        this.helper_.flushBufferData(buffers.polygonBuffers[2]);
       }
       if (buffers.lineStringBuffers) {
         this.helper_.flushBufferData(buffers.lineStringBuffers[0]);
         this.helper_.flushBufferData(buffers.lineStringBuffers[1]);
+        this.helper_.flushBufferData(buffers.lineStringBuffers[2]);
       }
       if (buffers.pointBuffers) {
         this.helper_.flushBufferData(buffers.pointBuffers[0]);
         this.helper_.flushBufferData(buffers.pointBuffers[1]);
+        this.helper_.flushBufferData(buffers.pointBuffers[2]);
       }
     }
   }

package/render/webgl/bufferUtil.d.ts

@@ -2,16 +2,15 @@
  * Pushes a quad (two triangles) based on a point geometry
  * @param {Float32Array} instructions Array of render instructions for points.
  * @param {number} elementIndex Index from which render instructions will be read.
- * @param {Float32Array} vertexBuffer Buffer in the form of a typed array.
- * @param {Uint32Array} indexBuffer Buffer in the form of a typed array.
+ * @param {Float32Array} instanceAttributesBuffer Buffer in the form of a typed array.
  * @param {number} customAttributesSize Amount of custom attributes for each element.
  * @param {BufferPositions} [bufferPositions] Buffer write positions; if not specified, positions will be set at 0.
  * @return {BufferPositions} New buffer positions where to write next
- * @property {number} vertexPosition New position in the vertex buffer where future writes should start.
- * @property {number} indexPosition New position in the index buffer where future writes should start.
+ * @property {number} vertexAttributesPosition New position in the vertex buffer where future writes should start.
+ * @property {number} indicesPosition New position in the index buffer where future writes should start.
  * @private
  */
-export function writePointFeatureToBuffers(instructions: Float32Array, elementIndex: number, vertexBuffer: Float32Array, indexBuffer: Uint32Array, customAttributesSize: number, bufferPositions?: BufferPositions): BufferPositions;
+export function writePointFeatureToBuffers(instructions: Float32Array, elementIndex: number, instanceAttributesBuffer: Float32Array, customAttributesSize: number, bufferPositions?: BufferPositions): BufferPositions;
 /**
  * Pushes a single quad to form a line segment; also includes a computation for the join angles with previous and next
  * segment, in order to be able to offset the vertices correctly in the shader.
@@ -37,8 +36,7 @@ export function writePointFeatureToBuffers(instructions: Float32Array, elementIn
  * @param {number} segmentEndIndex Index of the segment end point from which render instructions will be read.
  * @param {number|null} beforeSegmentIndex Index of the point right before the segment (null if none, e.g this is a line start)
  * @param {number|null} afterSegmentIndex Index of the point right after the segment (null if none, e.g this is a line end)
- * @param {Array<number>} vertexArray Array containing vertices.
- * @param {Array<number>} indexArray Array containing indices.
+ * @param {Array<number>} instanceAttributesArray Array containing instance attributes.
  * @param {Array<number>} customAttributes Array of custom attributes value
  * @param {import('../../transform.js').Transform} toWorldTransform Transform matrix used to obtain world coordinates from instructions
  * @param {number} currentLength Cumulated length of segments processed so far
@@ -46,7 +44,7 @@ export function writePointFeatureToBuffers(instructions: Float32Array, elementIn
  * @return {{length: number, angle: number}} Cumulated length with the newly processed segment (in world units), new sum of the join angle tangents
  * @private
  */
-export function writeLineSegmentToBuffers(instructions: Float32Array, segmentStartIndex: number, segmentEndIndex: number, beforeSegmentIndex: number | null, afterSegmentIndex: number | null, vertexArray: Array<number>, indexArray: Array<number>, customAttributes: Array<number>, toWorldTransform: import("../../transform.js").Transform, currentLength: number, currentAngleTangentSum: number): {
+export function writeLineSegmentToBuffers(instructions: Float32Array, segmentStartIndex: number, segmentEndIndex: number, beforeSegmentIndex: number | null, afterSegmentIndex: number | null, instanceAttributesArray: Array<number>, customAttributes: Array<number>, toWorldTransform: import("../../transform.js").Transform, currentLength: number, currentAngleTangentSum: number): {
     length: number;
     angle: number;
 };
@@ -69,10 +67,14 @@ export type BufferPositions = {
     /**
      * Position in the vertex buffer
      */
-    vertexPosition: number;
+    vertexAttributesPosition: number;
+    /**
+     * Position in the vertex buffer
+     */
+    instanceAttributesPosition: number;
     /**
      * Position in the index buffer
      */
-    indexPosition: number;
+    indicesPosition: number;
 };
 //# sourceMappingURL=bufferUtil.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"bufferUtil.d.ts","sourceRoot":"","sources":["bufferUtil.js"],"names":[],"mappings":"AAkCA;;;;;;;;;;;;GAYG;AACH,yDAXW,YAAY,gBACZ,MAAM,gBACN,YAAY,eACZ,WAAW,wBACX,MAAM,oBACN,eAAe,GACd,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;AAtXD,6CAA8C,KAAK,CAAC;;;;;;;;oBAQtC,MAAM;;;;mBACN,MAAM"}
+{"version":3,"file":"bufferUtil.d.ts","sourceRoot":"","sources":["bufferUtil.js"],"names":[],"mappings":"AA0BA;;;;;;;;;;;GAWG;AACH,yDAVW,YAAY,gBACZ,MAAM,4BACN,YAAY,wBACZ,MAAM,oBACN,eAAe,GACd,eAAe,CAmC1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wDAbW,YAAY,qBACZ,MAAM,mBACN,MAAM,sBACN,MAAM,GAAC,IAAI,qBACX,MAAM,GAAC,IAAI,2BACX,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,CA0H1C;AAED;;;;;;;;;GASG;AACH,6DARW,YAAY,qBACZ,MAAM,eACN,KAAK,CAAC,MAAM,CAAC,cACb,KAAK,CAAC,MAAM,CAAC,wBACb,MAAM,GACL,MAAM,CA0CjB;AAzQD,6CAA8C,KAAK,CAAC;;;;;;;;8BAQtC,MAAM;;;;gCACN,MAAM;;;;qBACN,MAAM"}