ol 7.3.0 → 7.3.1-dev

package/renderer/webgl/VectorLayer.d.ts

@@ -1,59 +1,40 @@
-export default WebGLVectorLayerRenderer;
-/**
- * A callback computing
- * the value of a custom attribute (different for each feature) to be passed on to the GPU.
- * Properties are available as 2nd arg for quicker access.
- */
-export type CustomAttributeCallback = (arg0: import("../../Feature").default, arg1: {
-    [x: string]: any;
-}) => number;
-/**
- * An object containing both shaders (vertex and fragment) as well as the required attributes
- */
-export type ShaderProgram = {
-    /**
-     * Vertex shader source (using the default one if unspecified).
-     */
-    vertexShader?: string | undefined;
-    /**
-     * Fragment shader source (using the default one if unspecified).
-     */
-    fragmentShader?: string | undefined;
-    /**
-     * Custom attributes made available in the vertex shader.
-     * Keys are the names of the attributes which are then accessible in the vertex shader using the `a_` prefix, e.g.: `a_opacity`.
-     * Default shaders rely on the attributes in {@link module :ol/render/webgl/shaders~DefaultAttributes}.
-     */
-    attributes: any;
+export const Uniforms: {
+    RENDER_EXTENT: string;
+    GLOBAL_ALPHA: string;
+    PROJECTION_MATRIX: string;
+    OFFSET_SCALE_MATRIX: string;
+    OFFSET_ROTATION_MATRIX: string;
+    TIME: string;
+    ZOOM: string;
+    RESOLUTION: string;
+    VIEWPORT_SIZE_PX: string;
+    PIXEL_RATIO: string;
 };
+export default WebGLVectorLayerRenderer;
+export type VectorStyle = import('../../render/webgl/VectorStyleRenderer.js').VectorStyle;
 export type Options = {
     /**
      * A CSS class name to set to the canvas element.
      */
     className?: string | undefined;
     /**
-     * Attributes and shaders for filling polygons.
-     */
-    fill?: ShaderProgram | undefined;
-    /**
-     * Attributes and shaders for line strings and polygon strokes.
-     */
-    stroke?: ShaderProgram | undefined;
-    /**
-     * Attributes and shaders for points.
+     * Vector style as literal style or shaders; can also accept an array of styles
      */
-    point?: ShaderProgram | undefined;
-    /**
-     * Uniform definitions.
-     */
-    uniforms?: {
-        [x: string]: import("../../webgl/Helper.js").UniformValue;
-    } | undefined;
+    style: VectorStyle | Array<VectorStyle>;
     /**
      * Post-processes definitions
      */
     postProcesses?: import("./Layer.js").PostProcessesOptions[] | undefined;
 };
+/**
+ * @typedef {import('../../render/webgl/VectorStyleRenderer.js').VectorStyle} VectorStyle
+ */
+/**
+ * @typedef {Object} Options
+ * @property {string} [className='ol-layer'] A CSS class name to set to the canvas element.
+ * @property {VectorStyle|Array<VectorStyle>} style Vector style as literal style or shaders; can also accept an array of styles
+ * @property {Array<import("./Layer").PostProcessesOptions>} [postProcesses] Post-processes definitions
+ */
 /**
  * @classdesc
  * Experimental WebGL vector renderer. Supports polygons, lines and points:
@@ -88,27 +69,43 @@ declare class WebGLVectorLayerRenderer extends WebGLLayerRenderer<any> {
      * @private
      */
     private currentTransform_;
-    fillVertexShader_: string;
-    fillFragmentShader_: string;
-    fillAttributes_: import("../../render/webgl/BatchRenderer").CustomAttribute[];
-    strokeVertexShader_: string;
-    strokeFragmentShader_: string;
-    strokeAttributes_: import("../../render/webgl/BatchRenderer").CustomAttribute[];
-    pointVertexShader_: string;
-    pointFragmentShader_: string;
-    pointAttributes_: import("../../render/webgl/BatchRenderer").CustomAttribute[];
+    tmpTransform_: number[];
+    tmpMat4_: number[];
+    /**
+     * @type {import("../../transform.js").Transform}
+     * @private
+     */
+    private currentFrameStateTransform_;
+    /**
+     * @type {Array<VectorStyle>}
+     * @private
+     */
+    private styles_;
+    /**
+     * @type {Array<VectorStyleRenderer>}
+     * @private
+     */
+    private styleRenderers_;
     /**
+     * @type {Array<import('../../render/webgl/VectorStyleRenderer.js').WebGLBuffers>}
      * @private
      */
-    private worker_;
+    private buffers_;
     /**
      * @private
      */
     private batch_;
     sourceListenKeys_: import("../../events.js").EventsKey[];
-    polygonRenderer_: PolygonBatchRenderer | undefined;
-    pointRenderer_: PointBatchRenderer | undefined;
-    lineStringRenderer_: LineStringBatchRenderer | undefined;
+    /**
+     * @param {Options} options Options.
+     * @private
+     */
+    private applyOptions_;
+    /**
+     * @private
+     */
+    private createRenderers_;
+    reset(options: any): void;
     /**
      * @param {import("../../source/Vector.js").VectorSourceEvent} event Event.
      * @private
@@ -128,6 +125,11 @@ declare class WebGLVectorLayerRenderer extends WebGLLayerRenderer<any> {
      * @private
      */
     private handleSourceFeatureClear_;
+    /**
+     * @param {import("../../transform.js").Transform} batchInvertTransform Inverse of the transformation in which geometries are expressed
+     * @private
+     */
+    private applyUniforms_;
     /**
      * Render the layer.
      * @param {import("../../Map.js").FrameState} frameState Frame state.
@@ -135,8 +137,5 @@ declare class WebGLVectorLayerRenderer extends WebGLLayerRenderer<any> {
      */
     renderFrame(frameState: import("../../Map.js").FrameState): HTMLElement;
 }
-import WebGLLayerRenderer from "./Layer.js";
-import PolygonBatchRenderer from "../../render/webgl/PolygonBatchRenderer.js";
-import PointBatchRenderer from "../../render/webgl/PointBatchRenderer.js";
-import LineStringBatchRenderer from "../../render/webgl/LineStringBatchRenderer.js";
+import WebGLLayerRenderer from './Layer.js';
 //# sourceMappingURL=VectorLayer.d.ts.map

package/renderer/webgl/VectorLayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VectorLayer.d.ts","sourceRoot":"","sources":["VectorLayer.js"],"names":[],"mappings":";;;;;;6CA2BsB,OAAO,eAAe,EAAE,OAAO;QAAS,MAAM;MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgChF;;;;;;;;;;;;;;;;;GAiBG;AACH;IACE;;;OAGG;IACH,mBAHW,OAAO,sBAAsB,EAAE,OAAO,WACtC,OAAO,EAmHjB;IAvGC,wBAAyB;IAEzB,kDAAoC;IAEpC;;;;;;OAMG;IACH,0BAAkD;IAmClD,0BACmE;IACnE,4BACuE;IACvE,8EAAwD;IAExD,4BACyE;IACzE,8BAEwB;IACxB,gFAA4D;IAE5D,2BACsE;IACtE,6BAC0E;IAC1E,+EAA0D;IAE1D;;OAEG;IACH,gBAAkC;IAElC;;OAEG;IACH,eAAsC;IAItC,yDAyBC;IAID,mDAMC;IACD,+CAMC;IACD,yDAMC;IAGH;;;OAGG;IACH,kCAGC;IAED;;;OAGG;IACH,oCAGC;IAED;;;OAGG;IACH,mCAGC;IAED;;OAEG;IACH,kCAEC;IAED;;;;OAIG;IACH,wBAHW,OAAO,cAAc,EAAE,UAAU,GAChC,WAAW,CAoDtB;CAgGF"}
+{"version":3,"file":"VectorLayer.d.ts","sourceRoot":"","sources":["VectorLayer.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;EAIE;;0BAGW,OAAO,2CAA2C,EAAE,WAAW;;;;;;;;;WAM9D,WAAW,GAAC,MAAM,WAAW,CAAC;;;;;;AAP5C;;GAEG;AAEH;;;;;GAKG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH;IACE;;;OAGG;IACH,mBAHW,OAAO,sBAAsB,EAAE,OAAO,WACtC,OAAO,EAwFjB;IA3EC,wBAAyB;IAEzB,kDAAoC;IAEpC;;;;;;OAMG;IACH,0BAA0C;IAE1C,wBAAsC;IACtC,mBAA4B;IAE5B;;;OAGG;IACH,oCAAoD;IAEpD;;;OAGG;IACH,gBAAiB;IAEjB;;;OAGG;IACH,wBAAyB;IAEzB;;;OAGG;IACH,iBAAkB;IAIlB;;OAEG;IACH,eAAsC;IAItC,yDAyBC;IAGH;;;OAGG;IACH,sBAIC;IAED;;OAEG;IACH,yBAKC;IAED,0BAMC;IAMD;;;OAGG;IACH,kCAGC;IAED;;;OAGG;IACH,oCAGC;IAED;;;OAGG;IACH,mCAGC;IAED;;OAEG;IACH,kCAEC;IAED;;;OAGG;IACH,uBAQC;IAED;;;;OAIG;IACH,wBAHW,OAAO,cAAc,EAAE,UAAU,GAChC,WAAW,CAoDtB;CAkFF;+BAxW8B,YAAY"}

package/renderer/webgl/VectorLayer.js

@@ -2,61 +2,42 @@
  * @module ol/renderer/webgl/VectorLayer
  */
 import BaseVector from '../../layer/BaseVector.js';
-import LineStringBatchRenderer from '../../render/webgl/LineStringBatchRenderer.js';
 import MixedGeometryBatch from '../../render/webgl/MixedGeometryBatch.js';
-import PointBatchRenderer from '../../render/webgl/PointBatchRenderer.js';
-import PolygonBatchRenderer from '../../render/webgl/PolygonBatchRenderer.js';
 import VectorEventType from '../../source/VectorEventType.js';
+import VectorStyleRenderer from '../../render/webgl/VectorStyleRenderer.js';
 import ViewHint from '../../ViewHint.js';
 import WebGLLayerRenderer from './Layer.js';
 import {DefaultUniform} from '../../webgl/Helper.js';
-import {
-  FILL_FRAGMENT_SHADER,
-  FILL_VERTEX_SHADER,
-  POINT_FRAGMENT_SHADER,
-  POINT_VERTEX_SHADER,
-  STROKE_FRAGMENT_SHADER,
-  STROKE_VERTEX_SHADER,
-  packColor,
-} from './shaders.js';
 import {buffer, createEmpty, equals, getWidth} from '../../extent.js';
-import {create as createTransform} from '../../transform.js';
-import {create as createWebGLWorker} from '../../worker/webgl.js';
+import {
+  create as createMat4,
+  fromTransform as mat4FromTransform,
+} from '../../vec/mat4.js';
+import {
+  create as createTransform,
+  multiply as multiplyTransform,
+  setFromArray as setFromTransform,
+  translate as translateTransform,
+} from '../../transform.js';
 import {listen, unlistenByKey} from '../../events.js';
 
-/**
- * @typedef {function(import("../../Feature").default, Object<string, *>):number} CustomAttributeCallback A callback computing
- * the value of a custom attribute (different for each feature) to be passed on to the GPU.
- * Properties are available as 2nd arg for quicker access.
- */
+export const Uniforms = {
+  ...DefaultUniform,
+  RENDER_EXTENT: 'u_renderExtent', // intersection of layer, source, and view extent
+  GLOBAL_ALPHA: 'u_globalAlpha',
+};
 
 /**
- * @typedef {Object} ShaderProgram An object containing both shaders (vertex and fragment) as well as the required attributes
- * @property {string} [vertexShader] Vertex shader source (using the default one if unspecified).
- * @property {string} [fragmentShader] Fragment shader source (using the default one if unspecified).
- * @property {Object<import("./shaders.js").DefaultAttributes,CustomAttributeCallback>} attributes Custom attributes made available in the vertex shader.
- * Keys are the names of the attributes which are then accessible in the vertex shader using the `a_` prefix, e.g.: `a_opacity`.
- * Default shaders rely on the attributes in {@link module:ol/render/webgl/shaders~DefaultAttributes}.
+ * @typedef {import('../../render/webgl/VectorStyleRenderer.js').VectorStyle} VectorStyle
  */
 
 /**
  * @typedef {Object} Options
  * @property {string} [className='ol-layer'] A CSS class name to set to the canvas element.
- * @property {ShaderProgram} [fill] Attributes and shaders for filling polygons.
- * @property {ShaderProgram} [stroke] Attributes and shaders for line strings and polygon strokes.
- * @property {ShaderProgram} [point] Attributes and shaders for points.
- * @property {Object<string,import("../../webgl/Helper").UniformValue>} [uniforms] Uniform definitions.
+ * @property {VectorStyle|Array<VectorStyle>} style Vector style as literal style or shaders; can also accept an array of styles
  * @property {Array<import("./Layer").PostProcessesOptions>} [postProcesses] Post-processes definitions
  */
 
-/**
- * @param {Object<import("./shaders.js").DefaultAttributes,CustomAttributeCallback>} obj Lookup of attribute getters.
- * @return {Array<import("../../render/webgl/BatchRenderer").CustomAttribute>} An array of attribute descriptors.
- */
-function toAttributesArray(obj) {
-  return Object.keys(obj).map((key) => ({name: key, callback: obj[key]}));
-}
-
 /**
  * @classdesc
  * Experimental WebGL vector renderer. Supports polygons, lines and points:
@@ -81,9 +62,10 @@ class WebGLVectorLayerRenderer extends WebGLLayerRenderer {
    * @param {Options} options Options.
    */
   constructor(layer, options) {
-    const uniforms = options.uniforms || {};
-    const projectionMatrixTransform = createTransform();
-    uniforms[DefaultUniform.PROJECTION_MATRIX] = projectionMatrixTransform;
+    const uniforms = {
+      [Uniforms.RENDER_EXTENT]: [0, 0, 0, 0],
+      [Uniforms.GLOBAL_ALPHA]: 1,
+    };
 
     super(layer, {
       uniforms: uniforms,
@@ -101,64 +83,36 @@ class WebGLVectorLayerRenderer extends WebGLLayerRenderer {
      * @type {import("../../transform.js").Transform}
      * @private
      */
-    this.currentTransform_ = projectionMatrixTransform;
-
-    const fillAttributes = {
-      color: function () {
-        return packColor('#ddd');
-      },
-      opacity: function () {
-        return 1;
-      },
-      ...(options.fill && options.fill.attributes),
-    };
+    this.currentTransform_ = createTransform();
 
-    const strokeAttributes = {
-      color: function () {
-        return packColor('#eee');
-      },
-      opacity: function () {
-        return 1;
-      },
-      width: function () {
-        return 1.5;
-      },
-      ...(options.stroke && options.stroke.attributes),
-    };
+    this.tmpTransform_ = createTransform();
+    this.tmpMat4_ = createMat4();
 
-    const pointAttributes = {
-      color: function () {
-        return packColor('#eee');
-      },
-      opacity: function () {
-        return 1;
-      },
-      ...(options.point && options.point.attributes),
-    };
+    /**
+     * @type {import("../../transform.js").Transform}
+     * @private
+     */
+    this.currentFrameStateTransform_ = createTransform();
 
-    this.fillVertexShader_ =
-      (options.fill && options.fill.vertexShader) || FILL_VERTEX_SHADER;
-    this.fillFragmentShader_ =
-      (options.fill && options.fill.fragmentShader) || FILL_FRAGMENT_SHADER;
-    this.fillAttributes_ = toAttributesArray(fillAttributes);
-
-    this.strokeVertexShader_ =
-      (options.stroke && options.stroke.vertexShader) || STROKE_VERTEX_SHADER;
-    this.strokeFragmentShader_ =
-      (options.stroke && options.stroke.fragmentShader) ||
-      STROKE_FRAGMENT_SHADER;
-    this.strokeAttributes_ = toAttributesArray(strokeAttributes);
-
-    this.pointVertexShader_ =
-      (options.point && options.point.vertexShader) || POINT_VERTEX_SHADER;
-    this.pointFragmentShader_ =
-      (options.point && options.point.fragmentShader) || POINT_FRAGMENT_SHADER;
-    this.pointAttributes_ = toAttributesArray(pointAttributes);
+    /**
+     * @type {Array<VectorStyle>}
+     * @private
+     */
+    this.styles_ = [];
 
     /**
+     * @type {Array<VectorStyleRenderer>}
      * @private
      */
-    this.worker_ = createWebGLWorker();
+    this.styleRenderers_ = [];
+
+    /**
+     * @type {Array<import('../../render/webgl/VectorStyleRenderer.js').WebGLBuffers>}
+     * @private
+     */
+    this.buffers_ = [];
+
+    this.applyOptions_(options);
 
     /**
      * @private
@@ -195,30 +149,38 @@ class WebGLVectorLayerRenderer extends WebGLLayerRenderer {
     ];
   }
 
-  afterHelperCreated() {
-    this.polygonRenderer_ = new PolygonBatchRenderer(
-      this.helper,
-      this.worker_,
-      this.fillVertexShader_,
-      this.fillFragmentShader_,
-      this.fillAttributes_
-    );
-    this.pointRenderer_ = new PointBatchRenderer(
-      this.helper,
-      this.worker_,
-      this.pointVertexShader_,
-      this.pointFragmentShader_,
-      this.pointAttributes_
-    );
-    this.lineStringRenderer_ = new LineStringBatchRenderer(
-      this.helper,
-      this.worker_,
-      this.strokeVertexShader_,
-      this.strokeFragmentShader_,
-      this.strokeAttributes_
+  /**
+   * @param {Options} options Options.
+   * @private
+   */
+  applyOptions_(options) {
+    this.styles_ = Array.isArray(options.style)
+      ? options.style
+      : [options.style];
+  }
+
+  /**
+   * @private
+   */
+  createRenderers_() {
+    this.buffers_ = [];
+    this.styleRenderers_ = this.styles_.map(
+      (style) => new VectorStyleRenderer(style, this.helper)
     );
   }
 
+  reset(options) {
+    this.applyOptions_(options);
+    if (this.helper) {
+      this.createRenderers_();
+    }
+    super.reset(options);
+  }
+
+  afterHelperCreated() {
+    this.createRenderers_();
+  }
+
   /**
    * @param {import("../../source/Vector.js").VectorSourceEvent} event Event.
    * @private
@@ -253,6 +215,20 @@ class WebGLVectorLayerRenderer extends WebGLLayerRenderer {
     this.batch_.clear();
   }
 
+  /**
+   * @param {import("../../transform.js").Transform} batchInvertTransform Inverse of the transformation in which geometries are expressed
+   * @private
+   */
+  applyUniforms_(batchInvertTransform) {
+    // world to screen matrix
+    setFromTransform(this.tmpTransform_, this.currentFrameStateTransform_);
+    multiplyTransform(this.tmpTransform_, batchInvertTransform);
+    this.helper.setUniformMatrixValue(
+      Uniforms.PROJECTION_MATRIX,
+      mat4FromTransform(this.tmpMat4_, this.tmpTransform_)
+    );
+  }
+
   /**
    * Render the layer.
    * @param {import("../../Map.js").FrameState} frameState Frame state.
@@ -262,6 +238,12 @@ class WebGLVectorLayerRenderer extends WebGLLayerRenderer {
     const gl = this.helper.getGL();
     this.preRender(gl, frameState);
 
+    this.helper.prepareDraw(frameState);
+    this.currentFrameStateTransform_ = this.helper.makeProjectionTransform(
+      frameState,
+      this.currentFrameStateTransform_
+    );
+
     const layer = this.getLayer();
     const vectorSource = layer.getSource();
     const projection = frameState.viewState.projection;
@@ -276,25 +258,19 @@ class WebGLVectorLayerRenderer extends WebGLLayerRenderer {
       ? Math.floor((extent[0] - projectionExtent[0]) / worldWidth)
       : 0;
 
+    translateTransform(this.currentFrameStateTransform_, world * worldWidth, 0);
     do {
-      this.polygonRenderer_.render(
-        this.batch_.polygonBatch,
-        this.currentTransform_,
-        frameState,
-        world * worldWidth
-      );
-      this.lineStringRenderer_.render(
-        this.batch_.lineStringBatch,
-        this.currentTransform_,
-        frameState,
-        world * worldWidth
-      );
-      this.pointRenderer_.render(
-        this.batch_.pointBatch,
-        this.currentTransform_,
-        frameState,
-        world * worldWidth
-      );
+      for (let i = 0, ii = this.styleRenderers_.length; i < ii; i++) {
+        const renderer = this.styleRenderers_[i];
+        const buffers = this.buffers_[i];
+        if (!buffers) {
+          continue;
+        }
+        renderer.render(buffers, frameState, () => {
+          this.applyUniforms_(buffers.invertVerticesTransform);
+        });
+      }
+      translateTransform(this.currentFrameStateTransform_, worldWidth, 0);
     } while (++world < endWorld);
 
     this.helper.finalizeDraw(frameState);
@@ -339,37 +315,25 @@ class WebGLVectorLayerRenderer extends WebGLLayerRenderer {
       vectorSource.loadFeatures(extent, resolution, projection);
 
       this.ready = false;
-      let remaining = 3;
-      const rebuildCb = () => {
-        remaining--;
-        this.ready = remaining <= 0;
-        this.getLayer().changed();
-      };
 
-      this.polygonRenderer_.rebuild(
-        this.batch_.polygonBatch,
+      const transform = this.helper.makeProjectionTransform(
         frameState,
-        'Polygon',
-        rebuildCb
+        createTransform()
       );
-      this.lineStringRenderer_.rebuild(
-        this.batch_.lineStringBatch,
-        frameState,
-        'LineString',
-        rebuildCb
-      );
-      this.pointRenderer_.rebuild(
-        this.batch_.pointBatch,
-        frameState,
-        'Point',
-        rebuildCb
+
+      const generatePromises = this.styleRenderers_.map((renderer, i) =>
+        renderer.generateBuffers(this.batch_, transform).then((buffers) => {
+          this.buffers_[i] = buffers;
+        })
       );
+      Promise.all(generatePromises).then(() => {
+        this.ready = true;
+        this.getLayer().changed();
+      });
+
       this.previousExtent_ = frameState.extent.slice();
     }
 
-    this.helper.makeProjectionTransform(frameState, this.currentTransform_);
-    this.helper.prepareDraw(frameState);
-
     return true;
   }
 
@@ -396,8 +360,6 @@ class WebGLVectorLayerRenderer extends WebGLLayerRenderer {
    * Clean up.
    */
   disposeInternal() {
-    this.worker_.terminate();
-    this.layer_ = null;
     this.sourceListenKeys_.forEach(function (key) {
       unlistenByKey(key);
     });

package/renderer/webgl/VectorTileLayer.d.ts

@@ -0,0 +1,87 @@
+export default WebGLVectorTileLayerRenderer;
+export type VectorStyle = import('../../render/webgl/VectorStyleRenderer.js').VectorStyle;
+export type Options = {
+    /**
+     * Vector style as literal style or shaders; can also accept an array of styles
+     */
+    style: VectorStyle | Array<VectorStyle>;
+    /**
+     * The vector tile cache size.
+     */
+    cacheSize?: number | undefined;
+};
+export type LayerType = import("../../layer/BaseTile.js").default<any, any>;
+/**
+ * @typedef {import('../../render/webgl/VectorStyleRenderer.js').VectorStyle} VectorStyle
+ */
+/**
+ * @typedef {Object} Options
+ * @property {VectorStyle|Array<VectorStyle>} style Vector style as literal style or shaders; can also accept an array of styles
+ * @property {number} [cacheSize=512] The vector tile cache size.
+ */
+/**
+ * @typedef {import("../../layer/BaseTile.js").default} LayerType
+ */
+/**
+ * @classdesc
+ * WebGL renderer for vector tile layers. Experimental.
+ * @extends {WebGLBaseTileLayerRenderer<LayerType>}
+ */
+declare class WebGLVectorTileLayerRenderer extends WebGLBaseTileLayerRenderer<import("../../layer/BaseTile.js").default<any, any>, any, any> {
+    /**
+     * @param {LayerType} tileLayer Tile layer.
+     * @param {Options} options Options.
+     */
+    constructor(tileLayer: import("../../layer/BaseTile.js").default<any, any>, options: Options);
+    /**
+     * @type {Array<VectorStyle>}
+     * @private
+     */
+    private styles_;
+    /**
+     * @type {Array<VectorStyleRenderer>}
+     * @private
+     */
+    private styleRenderers_;
+    /**
+     * This transform is updated on every frame and is the composition of:
+     * - invert of the world->screen transform that was used when rebuilding buffers (see `this.renderTransform_`)
+     * - current world->screen transform
+     * @type {import("../../transform.js").Transform}
+     * @private
+     */
+    private currentFrameStateTransform_;
+    tmpTransform_: number[];
+    tmpMat4_: number[];
+    /**
+     * @param {Options} options Options.
+     */
+    reset(options: Options): void;
+    /**
+     * @param {Options} options Options.
+     * @private
+     */
+    private applyOptions_;
+    /**
+     * @private
+     */
+    private createRenderers_;
+    createTileRepresentation(options: any): TileGeometry;
+    beforeTilesRender(frameState: any, tilesWithAlpha: any): void;
+    /**
+     * @param {number} alpha Alpha value of the tile
+     * @param {import("../../extent.js").Extent} renderExtent Which extent to restrict drawing to
+     * @param {import("../../transform.js").Transform} batchInvertTransform Inverse of the transformation in which tile geometries are expressed
+     * @private
+     */
+    private applyUniforms_;
+    renderTile(tileRepresentation: any, tileTransform: any, frameState: any, renderExtent: any, tileResolution: any, tileSize: any, tileOrigin: any, tileExtent: any, depth: any, gutter: any, alpha: any): void;
+    /**
+     * Render declutter items for this layer
+     * @param {import("../../Map.js").FrameState} frameState Frame state.
+     */
+    renderDeclutter(frameState: import("../../Map.js").FrameState): void;
+}
+import WebGLBaseTileLayerRenderer from './TileLayerBase.js';
+import TileGeometry from '../../webgl/TileGeometry.js';
+//# sourceMappingURL=VectorTileLayer.d.ts.map

package/renderer/webgl/VectorTileLayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VectorTileLayer.d.ts","sourceRoot":"","sources":["VectorTileLayer.js"],"names":[],"mappings":";0BAoBa,OAAO,2CAA2C,EAAE,WAAW;;;;;WAK9D,WAAW,GAAC,MAAM,WAAW,CAAC;;;;;;;AAN5C;;GAEG;AAEH;;;;GAIG;AAEH;;GAEG;AAEH;;;;GAIG;AACH;IACE;;;OAGG;IACH,qFAFW,OAAO,EA8BjB;IAzBC;;;OAGG;IACH,gBAAiB;IAEjB;;;OAGG;IACH,wBAAyB;IAEzB;;;;;;OAMG;IACH,oCAAoD;IAEpD,wBAAsC;IACtC,mBAA4B;IAK9B;;OAEG;IACH,eAFW,OAAO,QASjB;IAED;;;OAGG;IACH,sBAIC;IAED;;OAEG;IACH,yBAIC;IAMD,qDAWC;IAED,8DAMC;IAED;;;;;OAKG;IACH,uBAkBC;IAED,6MA6BC;IAED;;;OAGG;IACH,4BAFW,OAAO,cAAc,EAAE,UAAU,QAEd;CAQ/B;uCAhMkD,oBAAoB;yBAF9C,6BAA6B"}