websites/coopgo
2
0
Fork 0
Code Issues Pull Requests Actions Projects Releases Wiki Activity

planning
All checks were successful
Publish To Prod / deploy_and_publish (push) Successful in 35s
Details

Browse Source
This commit is contained in:
Stéphane Gauthier
2024-10-14 09:15:30 +02:00
parent bcba00a730
commit 6e64e138e2
21059 changed files with 2317811 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
node_modules/ol/renderer/Composite.d.ts generated vendored Normal file
View File

@@ -0,0 +1,29 @@
export default CompositeMapRenderer;
/**
* @classdesc
* Canvas map renderer.
* @api
*/
declare class CompositeMapRenderer extends MapRenderer {
/**
* @type {import("../events.js").EventsKey}
*/
fontChangeListenerKey_: import("../events.js").EventsKey;
/**
* @private
* @type {HTMLDivElement}
*/
private element_;
/**
* @private
* @type {Array<HTMLElement>}
*/
private children_;
/**
* @private
* @type {boolean}
*/
private renderedVisible_;
}
import MapRenderer from "./Map.js";
//# sourceMappingURL=Composite.d.ts.map

1
node_modules/ol/renderer/Composite.d.ts.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"Composite.d.ts","sourceRoot":"","sources":["../src/renderer/Composite.js"],"names":[],"mappings":";AAaA;;;;GAIG;AACH;IAOI;;OAEG;IACH,wBAFU,OAAO,cAAc,EAAE,SAAS,CAMzC;IAED;;;OAGG;IACH,iBAA6C;IAY7C;;;OAGG;IACH,kBAAmB;IAEnB;;;OAGG;IACH,yBAA4B;CAuI/B"}

181
node_modules/ol/renderer/Composite.js generated vendored Normal file
View File

@@ -0,0 +1,181 @@
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
/**
* @module ol/renderer/Composite
*/
import MapRenderer from './Map.js';
import ObjectEventType from '../ObjectEventType.js';
import RenderEvent from '../render/Event.js';
import RenderEventType from '../render/EventType.js';
import { CLASS_UNSELECTABLE } from '../css.js';
import { checkedFonts } from '../render/canvas.js';
import { inView } from '../layer/Layer.js';
import { listen, unlistenByKey } from '../events.js';
import { replaceChildren } from '../dom.js';
/**
* @classdesc
* Canvas map renderer.
* @api
*/
var CompositeMapRenderer = /** @class */ (function (_super) {
__extends(CompositeMapRenderer, _super);
/**
* @param {import("../PluggableMap.js").default} map Map.
*/
function CompositeMapRenderer(map) {
var _this = _super.call(this, map) || this;
/**
* @type {import("../events.js").EventsKey}
*/
_this.fontChangeListenerKey_ = listen(checkedFonts, ObjectEventType.PROPERTYCHANGE, map.redrawText.bind(map));
/**
* @private
* @type {HTMLDivElement}
*/
_this.element_ = document.createElement('div');
var style = _this.element_.style;
style.position = 'absolute';
style.width = '100%';
style.height = '100%';
style.zIndex = '0';
_this.element_.className = CLASS_UNSELECTABLE + ' ol-layers';
var container = map.getViewport();
container.insertBefore(_this.element_, container.firstChild || null);
/**
* @private
* @type {Array<HTMLElement>}
*/
_this.children_ = [];
/**
* @private
* @type {boolean}
*/
_this.renderedVisible_ = true;
return _this;
}
/**
* @param {import("../render/EventType.js").default} type Event type.
* @param {import("../PluggableMap.js").FrameState} frameState Frame state.
*/
CompositeMapRenderer.prototype.dispatchRenderEvent = function (type, frameState) {
var map = this.getMap();
if (map.hasListener(type)) {
var event_1 = new RenderEvent(type, undefined, frameState);
map.dispatchEvent(event_1);
}
};
CompositeMapRenderer.prototype.disposeInternal = function () {
unlistenByKey(this.fontChangeListenerKey_);
this.element_.parentNode.removeChild(this.element_);
_super.prototype.disposeInternal.call(this);
};
/**
* Render.
* @param {?import("../PluggableMap.js").FrameState} frameState Frame state.
*/
CompositeMapRenderer.prototype.renderFrame = function (frameState) {
if (!frameState) {
if (this.renderedVisible_) {
this.element_.style.display = 'none';
this.renderedVisible_ = false;
}
return;
}
this.calculateMatrices2D(frameState);
this.dispatchRenderEvent(RenderEventType.PRECOMPOSE, frameState);
var layerStatesArray = frameState.layerStatesArray.sort(function (a, b) {
return a.zIndex - b.zIndex;
});
var viewState = frameState.viewState;
this.children_.length = 0;
/**
* @type {Array<import("../layer/BaseVector.js").default>}
*/
var declutterLayers = [];
var previousElement = null;
for (var i = 0, ii = layerStatesArray.length; i < ii; ++i) {
var layerState = layerStatesArray[i];
frameState.layerIndex = i;
var layer = layerState.layer;
var sourceState = layer.getSourceState();
if (!inView(layerState, viewState) ||
(sourceState != 'ready' && sourceState != 'undefined')) {
layer.unrender();
continue;
}
var element = layer.render(frameState, previousElement);
if (!element) {
continue;
}
if (element !== previousElement) {
this.children_.push(element);
previousElement = element;
}
if ('getDeclutter' in layer) {
declutterLayers.push(
/** @type {import("../layer/BaseVector.js").default} */ (layer));
}
}
for (var i = declutterLayers.length - 1; i >= 0; --i) {
declutterLayers[i].renderDeclutter(frameState);
}
replaceChildren(this.element_, this.children_);
this.dispatchRenderEvent(RenderEventType.POSTCOMPOSE, frameState);
if (!this.renderedVisible_) {
this.element_.style.display = '';
this.renderedVisible_ = true;
}
this.scheduleExpireIconCache(frameState);
};
/**
* @param {import("../pixel.js").Pixel} pixel Pixel.
* @param {import("../PluggableMap.js").FrameState} frameState FrameState.
* @param {number} hitTolerance Hit tolerance in pixels.
* @param {function(import("../layer/Layer.js").default<import("../source/Source").default>, (Uint8ClampedArray|Uint8Array)): T} callback Layer
* callback.
* @param {function(import("../layer/Layer.js").default<import("../source/Source").default>): boolean} layerFilter Layer filter
* function, only layers which are visible and for which this function
* returns `true` will be tested for features. By default, all visible
* layers will be tested.
* @return {T|undefined} Callback result.
* @template T
*/
CompositeMapRenderer.prototype.forEachLayerAtPixel = function (pixel, frameState, hitTolerance, callback, layerFilter) {
var viewState = frameState.viewState;
var layerStates = frameState.layerStatesArray;
var numLayers = layerStates.length;
for (var i = numLayers - 1; i >= 0; --i) {
var layerState = layerStates[i];
var layer = layerState.layer;
if (layer.hasRenderer() &&
inView(layerState, viewState) &&
layerFilter(layer)) {
var layerRenderer = layer.getRenderer();
var data = layerRenderer.getDataAtPixel(pixel, frameState, hitTolerance);
if (data) {
var result = callback(layer, data);
if (result) {
return result;
}
}
}
}
return undefined;
};
return CompositeMapRenderer;
}(MapRenderer));
export default CompositeMapRenderer;
//# sourceMappingURL=Composite.js.map

1
node_modules/ol/renderer/Composite.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"Composite.js","sourceRoot":"","sources":["../src/renderer/Composite.js"],"names":[],"mappings":"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"}

128
node_modules/ol/renderer/Layer.d.ts generated vendored Normal file
View File

@@ -0,0 +1,128 @@
export default LayerRenderer;
/**
* @template {import("../layer/Layer.js").default} LayerType
*/
declare class LayerRenderer<LayerType extends import("../layer/Layer.js").default<import("../source/Source.js").default, LayerRenderer<any>>> extends Observable {
/**
* @param {LayerType} layer Layer.
*/
constructor(layer: LayerType);
/**
* The renderer is initialized and ready to render.
* @type {boolean}
*/
ready: boolean;
/** @private */
private boundHandleImageChange_;
/**
* @protected
* @type {LayerType}
*/
protected layer_: LayerType;
/**
* @type {import("../render/canvas/ExecutorGroup").default}
*/
declutterExecutorGroup: import("../render/canvas/ExecutorGroup").default;
/**
* Asynchronous layer level hit detection.
* @param {import("../pixel.js").Pixel} pixel Pixel.
* @return {Promise<Array<import("../Feature").default>>} Promise that resolves with
* an array of features.
*/
getFeatures(pixel: import("../pixel.js").Pixel): Promise<Array<import("../Feature").default>>;
/**
* @param {import("../pixel.js").Pixel} pixel Pixel.
* @return {Uint8ClampedArray|Uint8Array|Float32Array|DataView|null} Pixel data.
*/
getData(pixel: import("../pixel.js").Pixel): Uint8ClampedArray | Uint8Array | Float32Array | DataView | null;
/**
* Determine whether render should be called.
* @abstract
* @param {import("../PluggableMap.js").FrameState} frameState Frame state.
* @return {boolean} Layer is ready to be rendered.
*/
prepareFrame(frameState: import("../PluggableMap.js").FrameState): boolean;
/**
* Render the layer.
* @abstract
* @param {import("../PluggableMap.js").FrameState} frameState Frame state.
* @param {HTMLElement} target Target that may be used to render content to.
* @return {HTMLElement} The rendered element.
*/
renderFrame(frameState: import("../PluggableMap.js").FrameState, target: HTMLElement): HTMLElement;
/**
* @param {Object<number, Object<string, import("../Tile.js").default>>} tiles Lookup of loaded tiles by zoom level.
* @param {number} zoom Zoom level.
* @param {import("../Tile.js").default} tile Tile.
* @return {boolean|void} If `false`, the tile will not be considered loaded.
*/
loadedTileCallback(tiles: {
[x: number]: {
[x: string]: import("../Tile.js").default;
};
}, zoom: number, tile: import("../Tile.js").default): boolean | void;
/**
* Create a function that adds loaded tiles to the tile lookup.
* @param {import("../source/Tile.js").default} source Tile source.
* @param {import("../proj/Projection.js").default} projection Projection of the tiles.
* @param {Object<number, Object<string, import("../Tile.js").default>>} tiles Lookup of loaded tiles by zoom level.
* @return {function(number, import("../TileRange.js").default):boolean} A function that can be
* called with a zoom level and a tile range to add loaded tiles to the lookup.
* @protected
*/
protected createLoadedTileFinder(source: import("../source/Tile.js").default, projection: import("../proj/Projection.js").default, tiles: {
[x: number]: {
[x: string]: import("../Tile.js").default;
};
}): (arg0: number, arg1: import("../TileRange.js").default) => boolean;
/**
* @abstract
* @param {import("../coordinate.js").Coordinate} coordinate Coordinate.
* @param {import("../PluggableMap.js").FrameState} frameState Frame state.
* @param {number} hitTolerance Hit tolerance in pixels.
* @param {import("./vector.js").FeatureCallback<T>} callback Feature callback.
* @param {Array<import("./Map.js").HitMatch<T>>} matches The hit detected matches with tolerance.
* @return {T|undefined} Callback result.
* @template T
*/
forEachFeatureAtCoordinate<T>(coordinate: import("../coordinate.js").Coordinate, frameState: import("../PluggableMap.js").FrameState, hitTolerance: number, callback: import("./vector.js").FeatureCallback<T>, matches: import("./Map.js").HitMatch<T>[]): T | undefined;
/**
* @abstract
* @param {import("../pixel.js").Pixel} pixel Pixel.
* @param {import("../PluggableMap.js").FrameState} frameState FrameState.
* @param {number} hitTolerance Hit tolerance in pixels.
* @return {Uint8ClampedArray|Uint8Array} The result. If there is no data at the pixel
* location, null will be returned. If there is data, but pixel values cannot be
* returned, and empty array will be returned.
*/
getDataAtPixel(pixel: import("../pixel.js").Pixel, frameState: import("../PluggableMap.js").FrameState, hitTolerance: number): Uint8ClampedArray | Uint8Array;
/**
* @return {LayerType} Layer.
*/
getLayer(): LayerType;
/**
* Perform action necessary to get the layer rendered after new fonts have loaded
* @abstract
*/
handleFontsChanged(): void;
/**
* Handle changes in image state.
* @param {import("../events/Event.js").default} event Image change event.
* @private
*/
private handleImageChange_;
/**
* Load the image if not already loaded, and register the image change
* listener if needed.
* @param {import("../ImageBase.js").default} image Image.
* @return {boolean} `true` if the image is already loaded, `false` otherwise.
* @protected
*/
protected loadImage(image: import("../ImageBase.js").default): boolean;
/**
* @protected
*/
protected renderIfReadyAndVisible(): void;
}
import Observable from "../Observable.js";
//# sourceMappingURL=Layer.d.ts.map

1
node_modules/ol/renderer/Layer.d.ts.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"Layer.d.ts","sourceRoot":"","sources":["../src/renderer/Layer.js"],"names":[],"mappings":";AAQA;;GAEG;AACH;IACE;;OAEG;IACH,mBAFW,SAAS,EAwBnB;IAnBC;;;OAGG;IACH,OAFU,OAAO,CAEA;IAEjB,eAAe;IACf,gCAAiE;IAEjE;;;OAGG;IACH,kBAFU,SAAS,CAEA;IAEnB;;OAEG;IACH,wBAFU,OAAO,gCAAgC,EAAE,OAAO,CAExB;IAGpC;;;;;OAKG;IACH,mBAJW,OAAO,aAAa,EAAE,KAAK,GAC1B,QAAQ,MAAM,OAAO,YAAY,EAAE,OAAO,CAAC,CAAC,CAKvD;IAED;;;OAGG;IACH,eAHW,OAAO,aAAa,EAAE,KAAK,GAC1B,iBAAiB,GAAC,UAAU,GAAC,YAAY,GAAC,QAAQ,GAAC,IAAI,CAIlE;IAED;;;;;OAKG;IACH,yBAHW,OAAO,oBAAoB,EAAE,UAAU,GACtC,OAAO,CAIlB;IAED;;;;;;OAMG;IACH,wBAJW,OAAO,oBAAoB,EAAE,UAAU,UACvC,WAAW,GACV,WAAW,CAItB;IAED;;;;;OAKG;IACH;YALkB,MAAM;gBAAS,MAAM,GAAE,OAAO,YAAY,EAAE,OAAO;;aAC1D,MAAM,QACN,OAAO,YAAY,EAAE,OAAO,GAC3B,OAAO,GAAC,IAAI,CAQvB;IAED;;;;;;;;OAQG;IACH,yCAPW,OAAO,mBAAmB,EAAE,OAAO,cACnC,OAAO,uBAAuB,EAAE,OAAO;YAChC,MAAM;gBAAS,MAAM,GAAE,OAAO,YAAY,EAAE,OAAO;;eAChD,MAAM,QAAE,OAAO,iBAAiB,EAAE,OAAO,KAAE,OAAO,CAiBtE;IACD;;;;;;;;;OASG;IACH,0CARW,OAAO,kBAAkB,EAAE,UAAU,cACrC,OAAO,oBAAoB,EAAE,UAAU,gBACvC,MAAM,gHAchB;IAED;;;;;;;;OAQG;IACH,sBAPW,OAAO,aAAa,EAAE,KAAK,cAC3B,OAAO,oBAAoB,EAAE,UAAU,gBACvC,MAAM,GACL,iBAAiB,GAAC,UAAU,CAMvC;IAED;;OAEG;IACH,YAFY,SAAS,CAIpB;IAED;;;OAGG;IACH,2BAAuB;IAEvB;;;;OAIG;IACH,2BAKC;IAED;;;;;;OAMG;IACH,2BAJW,OAAO,iBAAiB,EAAE,OAAO,GAChC,OAAO,CAalB;IAED;;OAEG;IACH,0CAKC;CASF"}

205
node_modules/ol/renderer/Layer.js generated vendored Normal file
View File

@@ -0,0 +1,205 @@
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
/**
* @module ol/renderer/Layer
*/
import EventType from '../events/EventType.js';
import ImageState from '../ImageState.js';
import Observable from '../Observable.js';
import { abstract } from '../util.js';
/**
* @template {import("../layer/Layer.js").default} LayerType
*/
var LayerRenderer = /** @class */ (function (_super) {
__extends(LayerRenderer, _super);
/**
* @param {LayerType} layer Layer.
*/
function LayerRenderer(layer) {
var _this = _super.call(this) || this;
/**
* The renderer is initialized and ready to render.
* @type {boolean}
*/
_this.ready = true;
/** @private */
_this.boundHandleImageChange_ = _this.handleImageChange_.bind(_this);
/**
* @protected
* @type {LayerType}
*/
_this.layer_ = layer;
/**
* @type {import("../render/canvas/ExecutorGroup").default}
*/
_this.declutterExecutorGroup = null;
return _this;
}
/**
* Asynchronous layer level hit detection.
* @param {import("../pixel.js").Pixel} pixel Pixel.
* @return {Promise<Array<import("../Feature").default>>} Promise that resolves with
* an array of features.
*/
LayerRenderer.prototype.getFeatures = function (pixel) {
return abstract();
};
/**
* @param {import("../pixel.js").Pixel} pixel Pixel.
* @return {Uint8ClampedArray|Uint8Array|Float32Array|DataView|null} Pixel data.
*/
LayerRenderer.prototype.getData = function (pixel) {
return null;
};
/**
* Determine whether render should be called.
* @abstract
* @param {import("../PluggableMap.js").FrameState} frameState Frame state.
* @return {boolean} Layer is ready to be rendered.
*/
LayerRenderer.prototype.prepareFrame = function (frameState) {
return abstract();
};
/**
* Render the layer.
* @abstract
* @param {import("../PluggableMap.js").FrameState} frameState Frame state.
* @param {HTMLElement} target Target that may be used to render content to.
* @return {HTMLElement} The rendered element.
*/
LayerRenderer.prototype.renderFrame = function (frameState, target) {
return abstract();
};
/**
* @param {Object<number, Object<string, import("../Tile.js").default>>} tiles Lookup of loaded tiles by zoom level.
* @param {number} zoom Zoom level.
* @param {import("../Tile.js").default} tile Tile.
* @return {boolean|void} If `false`, the tile will not be considered loaded.
*/
LayerRenderer.prototype.loadedTileCallback = function (tiles, zoom, tile) {
if (!tiles[zoom]) {
tiles[zoom] = {};
}
tiles[zoom][tile.tileCoord.toString()] = tile;
return undefined;
};
/**
* Create a function that adds loaded tiles to the tile lookup.
* @param {import("../source/Tile.js").default} source Tile source.
* @param {import("../proj/Projection.js").default} projection Projection of the tiles.
* @param {Object<number, Object<string, import("../Tile.js").default>>} tiles Lookup of loaded tiles by zoom level.
* @return {function(number, import("../TileRange.js").default):boolean} A function that can be
* called with a zoom level and a tile range to add loaded tiles to the lookup.
* @protected
*/
LayerRenderer.prototype.createLoadedTileFinder = function (source, projection, tiles) {
return (
/**
* @param {number} zoom Zoom level.
* @param {import("../TileRange.js").default} tileRange Tile range.
* @return {boolean} The tile range is fully loaded.
* @this {LayerRenderer}
*/
function (zoom, tileRange) {
var callback = this.loadedTileCallback.bind(this, tiles, zoom);
return source.forEachLoadedTile(projection, zoom, tileRange, callback);
}.bind(this));
};
/**
* @abstract
* @param {import("../coordinate.js").Coordinate} coordinate Coordinate.
* @param {import("../PluggableMap.js").FrameState} frameState Frame state.
* @param {number} hitTolerance Hit tolerance in pixels.
* @param {import("./vector.js").FeatureCallback<T>} callback Feature callback.
* @param {Array<import("./Map.js").HitMatch<T>>} matches The hit detected matches with tolerance.
* @return {T|undefined} Callback result.
* @template T
*/
LayerRenderer.prototype.forEachFeatureAtCoordinate = function (coordinate, frameState, hitTolerance, callback, matches) {
return undefined;
};
/**
* @abstract
* @param {import("../pixel.js").Pixel} pixel Pixel.
* @param {import("../PluggableMap.js").FrameState} frameState FrameState.
* @param {number} hitTolerance Hit tolerance in pixels.
* @return {Uint8ClampedArray|Uint8Array} The result. If there is no data at the pixel
* location, null will be returned. If there is data, but pixel values cannot be
* returned, and empty array will be returned.
*/
LayerRenderer.prototype.getDataAtPixel = function (pixel, frameState, hitTolerance) {
return null;
};
/**
* @return {LayerType} Layer.
*/
LayerRenderer.prototype.getLayer = function () {
return this.layer_;
};
/**
* Perform action necessary to get the layer rendered after new fonts have loaded
* @abstract
*/
LayerRenderer.prototype.handleFontsChanged = function () { };
/**
* Handle changes in image state.
* @param {import("../events/Event.js").default} event Image change event.
* @private
*/
LayerRenderer.prototype.handleImageChange_ = function (event) {
var image = /** @type {import("../Image.js").default} */ (event.target);
if (image.getState() === ImageState.LOADED) {
this.renderIfReadyAndVisible();
}
};
/**
* Load the image if not already loaded, and register the image change
* listener if needed.
* @param {import("../ImageBase.js").default} image Image.
* @return {boolean} `true` if the image is already loaded, `false` otherwise.
* @protected
*/
LayerRenderer.prototype.loadImage = function (image) {
var imageState = image.getState();
if (imageState != ImageState.LOADED && imageState != ImageState.ERROR) {
image.addEventListener(EventType.CHANGE, this.boundHandleImageChange_);
}
if (imageState == ImageState.IDLE) {
image.load();
imageState = image.getState();
}
return imageState == ImageState.LOADED;
};
/**
* @protected
*/
LayerRenderer.prototype.renderIfReadyAndVisible = function () {
var layer = this.getLayer();
if (layer && layer.getVisible() && layer.getSourceState() === 'ready') {
layer.changed();
}
};
/**
* Clean up.
*/
LayerRenderer.prototype.disposeInternal = function () {
delete this.layer_;
_super.prototype.disposeInternal.call(this);
};
return LayerRenderer;
}(Observable));
export default LayerRenderer;
//# sourceMappingURL=Layer.js.map

1
node_modules/ol/renderer/Layer.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"Layer.js","sourceRoot":"","sources":["../src/renderer/Layer.js"],"names":[],"mappings":"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"}

119
node_modules/ol/renderer/Map.d.ts generated vendored Normal file
View File

@@ -0,0 +1,119 @@
export default MapRenderer;
export type HitMatch<T> = {
/**
* Feature.
*/
feature: import("../Feature.js").FeatureLike;
/**
* Layer.
*/
layer: import("../layer/Layer.js").default;
/**
* Geometry.
*/
geometry: import("../geom/SimpleGeometry.js").default;
/**
* Squared distance.
*/
distanceSq: number;
/**
* Callback.
*/
callback: import("./vector.js").FeatureCallback<T>;
};
/**
* @typedef HitMatch
* @property {import("../Feature.js").FeatureLike} feature Feature.
* @property {import("../layer/Layer.js").default} layer Layer.
* @property {import("../geom/SimpleGeometry.js").default} geometry Geometry.
* @property {number} distanceSq Squared distance.
* @property {import("./vector.js").FeatureCallback<T>} callback Callback.
* @template T
*/
/**
* @abstract
*/
declare class MapRenderer extends Disposable {
/**
* @param {import("../PluggableMap.js").default} map Map.
*/
constructor(map: import("../PluggableMap.js").default);
/**
* @private
* @type {import("../PluggableMap.js").default}
*/
private map_;
/**
* @abstract
* @param {import("../render/EventType.js").default} type Event type.
* @param {import("../PluggableMap.js").FrameState} frameState Frame state.
*/
dispatchRenderEvent(type: any, frameState: import("../PluggableMap.js").FrameState): void;
/**
* @param {import("../PluggableMap.js").FrameState} frameState FrameState.
* @protected
*/
protected calculateMatrices2D(frameState: import("../PluggableMap.js").FrameState): void;
/**
* @param {import("../coordinate.js").Coordinate} coordinate Coordinate.
* @param {import("../PluggableMap.js").FrameState} frameState FrameState.
* @param {number} hitTolerance Hit tolerance in pixels.
* @param {boolean} checkWrapped Check for wrapped geometries.
* @param {import("./vector.js").FeatureCallback<T>} callback Feature callback.
* @param {S} thisArg Value to use as `this` when executing `callback`.
* @param {function(this: U, import("../layer/Layer.js").default): boolean} layerFilter Layer filter
* function, only layers which are visible and for which this function
* returns `true` will be tested for features. By default, all visible
* layers will be tested.
* @param {U} thisArg2 Value to use as `this` when executing `layerFilter`.
* @return {T|undefined} Callback result.
* @template S,T,U
*/
forEachFeatureAtCoordinate<S, T, U>(coordinate: import("../coordinate.js").Coordinate, frameState: import("../PluggableMap.js").FrameState, hitTolerance: number, checkWrapped: boolean, callback: import("./vector.js").FeatureCallback<T>, thisArg: S, layerFilter: (this: U, arg1: import("../layer/Layer.js").default) => boolean, thisArg2: U): T | undefined;
/**
* @abstract
* @param {import("../pixel.js").Pixel} pixel Pixel.
* @param {import("../PluggableMap.js").FrameState} frameState FrameState.
* @param {number} hitTolerance Hit tolerance in pixels.
* @param {function(import("../layer/Layer.js").default<import("../source/Source").default>, (Uint8ClampedArray|Uint8Array)): T} callback Layer
* callback.
* @param {function(import("../layer/Layer.js").default<import("../source/Source").default>): boolean} layerFilter Layer filter
* function, only layers which are visible and for which this function
* returns `true` will be tested for features. By default, all visible
* layers will be tested.
* @return {T|undefined} Callback result.
* @template T
*/
forEachLayerAtPixel<T_1>(pixel: import("../pixel.js").Pixel, frameState: import("../PluggableMap.js").FrameState, hitTolerance: number, callback: (arg0: import("../layer/Layer.js").default<import("../source/Source").default>, arg1: (Uint8ClampedArray | Uint8Array)) => T_1, layerFilter: (arg0: import("../layer/Layer.js").default<import("../source/Source").default>) => boolean): T_1 | undefined;
/**
* @param {import("../coordinate.js").Coordinate} coordinate Coordinate.
* @param {import("../PluggableMap.js").FrameState} frameState FrameState.
* @param {number} hitTolerance Hit tolerance in pixels.
* @param {boolean} checkWrapped Check for wrapped geometries.
* @param {function(this: U, import("../layer/Layer.js").default): boolean} layerFilter Layer filter
* function, only layers which are visible and for which this function
* returns `true` will be tested for features. By default, all visible
* layers will be tested.
* @param {U} thisArg Value to use as `this` when executing `layerFilter`.
* @return {boolean} Is there a feature at the given coordinate?
* @template U
*/
hasFeatureAtCoordinate<U_1>(coordinate: import("../coordinate.js").Coordinate, frameState: import("../PluggableMap.js").FrameState, hitTolerance: number, checkWrapped: boolean, layerFilter: (this: U_1, arg1: import("../layer/Layer.js").default) => boolean, thisArg: U_1): boolean;
/**
* @return {import("../PluggableMap.js").default} Map.
*/
getMap(): import("../PluggableMap.js").default;
/**
* Render.
* @abstract
* @param {?import("../PluggableMap.js").FrameState} frameState Frame state.
*/
renderFrame(frameState: import("../PluggableMap.js").FrameState | null): void;
/**
* @param {import("../PluggableMap.js").FrameState} frameState Frame state.
* @protected
*/
protected scheduleExpireIconCache(frameState: import("../PluggableMap.js").FrameState): void;
}
import Disposable from "../Disposable.js";
//# sourceMappingURL=Map.d.ts.map

1
node_modules/ol/renderer/Map.d.ts.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"Map.d.ts","sourceRoot":"","sources":["../src/renderer/Map.js"],"names":[],"mappings":";;;;;aAcc,OAAO,eAAe,EAAE,WAAW;;;;WACnC,OAAO,mBAAmB,EAAE,OAAO;;;;cACnC,OAAO,2BAA2B,EAAE,OAAO;;;;gBAC3C,MAAM;;;;cACN,OAAO,aAAa,EAAE,eAAe,CAAC,CAAC,CAAC;;AANtD;;;;;;;;GAQG;AAEH;;GAEG;AACH;IACE;;OAEG;IACH,iBAFW,OAAO,oBAAoB,EAAE,OAAO,EAU9C;IALC;;;OAGG;IACH,aAAe;IAGjB;;;;OAIG;IACH,2CAFW,OAAO,oBAAoB,EAAE,UAAU,QAIjD;IAED;;;OAGG;IACH,0CAHW,OAAO,oBAAoB,EAAE,UAAU,QAoBjD;IAED;;;;;;;;;;;;;;OAcG;IACH,gDAdW,OAAO,kBAAkB,EAAE,UAAU,cACrC,OAAO,oBAAoB,EAAE,UAAU,gBACvC,MAAM,gBACN,OAAO,+FAGW,OAAO,mBAAmB,EAAE,OAAO,KAAG,OAAO,8BA4FzE;IAED;;;;;;;;;;;;;OAaG;IACH,gCAZW,OAAO,aAAa,EAAE,KAAK,cAC3B,OAAO,oBAAoB,EAAE,UAAU,gBACvC,MAAM,mBACG,OAAO,mBAAmB,EAAE,OAAO,CAAC,OAAO,kBAAkB,EAAE,OAAO,CAAC,QAAE,CAAC,iBAAiB,GAAC,UAAU,CAAC,8BAEvG,OAAO,mBAAmB,EAAE,OAAO,CAAC,OAAO,kBAAkB,EAAE,OAAO,CAAC,KAAG,OAAO,mBASpG;IAED;;;;;;;;;;;;OAYG;IACH,wCAZW,OAAO,kBAAkB,EAAE,UAAU,cACrC,OAAO,oBAAoB,EAAE,UAAU,gBACvC,MAAM,gBACN,OAAO,iCACW,OAAO,mBAAmB,EAAE,OAAO,KAAG,OAAO,iBAK9D,OAAO,CAuBlB;IAED;;OAEG;IACH,UAFY,OAAO,oBAAoB,EAAE,OAAO,CAI/C;IAED;;;;OAIG;IACH,wBAFY,OAAO,oBAAoB,EAAE,UAAU,eAIlD;IAED;;;OAGG;IACH,8CAHW,OAAO,oBAAoB,EAAE,UAAU,QAOjD;CACF"}

214
node_modules/ol/renderer/Map.js generated vendored Normal file
View File

@@ -0,0 +1,214 @@
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
/**
* @module ol/renderer/Map
*/
import Disposable from '../Disposable.js';
import { TRUE } from '../functions.js';
import { abstract } from '../util.js';
import { compose as composeTransform, makeInverse } from '../transform.js';
import { getWidth } from '../extent.js';
import { shared as iconImageCache } from '../style/IconImageCache.js';
import { inView } from '../layer/Layer.js';
import { wrapX } from '../coordinate.js';
/**
* @typedef HitMatch
* @property {import("../Feature.js").FeatureLike} feature Feature.
* @property {import("../layer/Layer.js").default} layer Layer.
* @property {import("../geom/SimpleGeometry.js").default} geometry Geometry.
* @property {number} distanceSq Squared distance.
* @property {import("./vector.js").FeatureCallback<T>} callback Callback.
* @template T
*/
/**
* @abstract
*/
var MapRenderer = /** @class */ (function (_super) {
__extends(MapRenderer, _super);
/**
* @param {import("../PluggableMap.js").default} map Map.
*/
function MapRenderer(map) {
var _this = _super.call(this) || this;
/**
* @private
* @type {import("../PluggableMap.js").default}
*/
_this.map_ = map;
return _this;
}
/**
* @abstract
* @param {import("../render/EventType.js").default} type Event type.
* @param {import("../PluggableMap.js").FrameState} frameState Frame state.
*/
MapRenderer.prototype.dispatchRenderEvent = function (type, frameState) {
abstract();
};
/**
* @param {import("../PluggableMap.js").FrameState} frameState FrameState.
* @protected
*/
MapRenderer.prototype.calculateMatrices2D = function (frameState) {
var viewState = frameState.viewState;
var coordinateToPixelTransform = frameState.coordinateToPixelTransform;
var pixelToCoordinateTransform = frameState.pixelToCoordinateTransform;
composeTransform(coordinateToPixelTransform, frameState.size[0] / 2, frameState.size[1] / 2, 1 / viewState.resolution, -1 / viewState.resolution, -viewState.rotation, -viewState.center[0], -viewState.center[1]);
makeInverse(pixelToCoordinateTransform, coordinateToPixelTransform);
};
/**
* @param {import("../coordinate.js").Coordinate} coordinate Coordinate.
* @param {import("../PluggableMap.js").FrameState} frameState FrameState.
* @param {number} hitTolerance Hit tolerance in pixels.
* @param {boolean} checkWrapped Check for wrapped geometries.
* @param {import("./vector.js").FeatureCallback<T>} callback Feature callback.
* @param {S} thisArg Value to use as `this` when executing `callback`.
* @param {function(this: U, import("../layer/Layer.js").default): boolean} layerFilter Layer filter
* function, only layers which are visible and for which this function
* returns `true` will be tested for features. By default, all visible
* layers will be tested.
* @param {U} thisArg2 Value to use as `this` when executing `layerFilter`.
* @return {T|undefined} Callback result.
* @template S,T,U
*/
MapRenderer.prototype.forEachFeatureAtCoordinate = function (coordinate, frameState, hitTolerance, checkWrapped, callback, thisArg, layerFilter, thisArg2) {
var result;
var viewState = frameState.viewState;
/**
* @param {boolean} managed Managed layer.
* @param {import("../Feature.js").FeatureLike} feature Feature.
* @param {import("../layer/Layer.js").default} layer Layer.
* @param {import("../geom/Geometry.js").default} geometry Geometry.
* @return {T|undefined} Callback result.
*/
function forEachFeatureAtCoordinate(managed, feature, layer, geometry) {
return callback.call(thisArg, feature, managed ? layer : null, geometry);
}
var projection = viewState.projection;
var translatedCoordinate = wrapX(coordinate.slice(), projection);
var offsets = [[0, 0]];
if (projection.canWrapX() && checkWrapped) {
var projectionExtent = projection.getExtent();
var worldWidth = getWidth(projectionExtent);
offsets.push([-worldWidth, 0], [worldWidth, 0]);
}
var layerStates = frameState.layerStatesArray;
var numLayers = layerStates.length;
var matches = /** @type {Array<HitMatch<T>>} */ ([]);
var tmpCoord = [];
for (var i = 0; i < offsets.length; i++) {
for (var j = numLayers - 1; j >= 0; --j) {
var layerState = layerStates[j];
var layer = layerState.layer;
if (layer.hasRenderer() &&
inView(layerState, viewState) &&
layerFilter.call(thisArg2, layer)) {
var layerRenderer = layer.getRenderer();
var source = layer.getSource();
if (layerRenderer && source) {
var coordinates = source.getWrapX()
? translatedCoordinate
: coordinate;
var callback_1 = forEachFeatureAtCoordinate.bind(null, layerState.managed);
tmpCoord[0] = coordinates[0] + offsets[i][0];
tmpCoord[1] = coordinates[1] + offsets[i][1];
result = layerRenderer.forEachFeatureAtCoordinate(tmpCoord, frameState, hitTolerance, callback_1, matches);
}
if (result) {
return result;
}
}
}
}
if (matches.length === 0) {
return undefined;
}
var order = 1 / matches.length;
matches.forEach(function (m, i) { return (m.distanceSq += i * order); });
matches.sort(function (a, b) { return a.distanceSq - b.distanceSq; });
matches.some(function (m) {
return (result = m.callback(m.feature, m.layer, m.geometry));
});
return result;
};
/**
* @abstract
* @param {import("../pixel.js").Pixel} pixel Pixel.
* @param {import("../PluggableMap.js").FrameState} frameState FrameState.
* @param {number} hitTolerance Hit tolerance in pixels.
* @param {function(import("../layer/Layer.js").default<import("../source/Source").default>, (Uint8ClampedArray|Uint8Array)): T} callback Layer
* callback.
* @param {function(import("../layer/Layer.js").default<import("../source/Source").default>): boolean} layerFilter Layer filter
* function, only layers which are visible and for which this function
* returns `true` will be tested for features. By default, all visible
* layers will be tested.
* @return {T|undefined} Callback result.
* @template T
*/
MapRenderer.prototype.forEachLayerAtPixel = function (pixel, frameState, hitTolerance, callback, layerFilter) {
return abstract();
};
/**
* @param {import("../coordinate.js").Coordinate} coordinate Coordinate.
* @param {import("../PluggableMap.js").FrameState} frameState FrameState.
* @param {number} hitTolerance Hit tolerance in pixels.
* @param {boolean} checkWrapped Check for wrapped geometries.
* @param {function(this: U, import("../layer/Layer.js").default): boolean} layerFilter Layer filter
* function, only layers which are visible and for which this function
* returns `true` will be tested for features. By default, all visible
* layers will be tested.
* @param {U} thisArg Value to use as `this` when executing `layerFilter`.
* @return {boolean} Is there a feature at the given coordinate?
* @template U
*/
MapRenderer.prototype.hasFeatureAtCoordinate = function (coordinate, frameState, hitTolerance, checkWrapped, layerFilter, thisArg) {
var hasFeature = this.forEachFeatureAtCoordinate(coordinate, frameState, hitTolerance, checkWrapped, TRUE, this, layerFilter, thisArg);
return hasFeature !== undefined;
};
/**
* @return {import("../PluggableMap.js").default} Map.
*/
MapRenderer.prototype.getMap = function () {
return this.map_;
};
/**
* Render.
* @abstract
* @param {?import("../PluggableMap.js").FrameState} frameState Frame state.
*/
MapRenderer.prototype.renderFrame = function (frameState) {
abstract();
};
/**
* @param {import("../PluggableMap.js").FrameState} frameState Frame state.
* @protected
*/
MapRenderer.prototype.scheduleExpireIconCache = function (frameState) {
if (iconImageCache.canExpireCache()) {
frameState.postRenderFunctions.push(expireIconCache);
}
};
return MapRenderer;
}(Disposable));
/**
* @param {import("../PluggableMap.js").default} map Map.
* @param {import("../PluggableMap.js").FrameState} frameState Frame state.
*/
function expireIconCache(map, frameState) {
iconImageCache.expire();
}
export default MapRenderer;
//# sourceMappingURL=Map.js.map

1
node_modules/ol/renderer/Map.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"Map.js","sourceRoot":"","sources":["../src/renderer/Map.js"],"names":[],"mappings":"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"}

28
node_modules/ol/renderer/canvas/ImageLayer.d.ts generated vendored Normal file
View File

@@ -0,0 +1,28 @@
export default CanvasImageLayerRenderer;
/**
* @classdesc
* Canvas renderer for image layers.
* @api
*/
declare class CanvasImageLayerRenderer extends CanvasLayerRenderer<any> {
/**
* @param {import("../../layer/Image.js").default} imageLayer Image layer.
*/
constructor(imageLayer: import("../../layer/Image.js").default<any>);
/**
* @protected
* @type {?import("../../ImageBase.js").default}
*/
protected image_: import("../../ImageBase.js").default | null;
/**
* @return {HTMLCanvasElement|HTMLImageElement|HTMLVideoElement} Image.
*/
getImage(): HTMLCanvasElement | HTMLImageElement | HTMLVideoElement;
/**
* @param {import("../../pixel.js").Pixel} pixel Pixel.
* @return {Uint8ClampedArray} Data at the pixel location.
*/
getData(pixel: import("../../pixel.js").Pixel): Uint8ClampedArray;
}
import CanvasLayerRenderer from "./Layer.js";
//# sourceMappingURL=ImageLayer.d.ts.map

1
node_modules/ol/renderer/canvas/ImageLayer.d.ts.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"ImageLayer.d.ts","sourceRoot":"","sources":["../../src/renderer/canvas/ImageLayer.js"],"names":[],"mappings":";AA0BA;;;;GAIG;AACH;IACE;;OAEG;IACH,qEAQC;IALC;;;OAGG;IACH,kBAFW,OAAO,oBAAoB,EAAE,OAAO,QAE7B;IAGpB;;OAEG;IACH,YAFY,iBAAiB,GAAC,gBAAgB,GAAC,gBAAgB,CAI9D;IA2DD;;;OAGG;IACH,eAHW,OAAO,gBAAgB,EAAE,KAAK,GAC7B,iBAAiB,CAyC5B;CAwHF"}

211
node_modules/ol/renderer/canvas/ImageLayer.js generated vendored Normal file
View File

@@ -0,0 +1,211 @@
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
/**
* @module ol/renderer/canvas/ImageLayer
*/
import CanvasLayerRenderer from './Layer.js';
import ImageState from '../../ImageState.js';
import ViewHint from '../../ViewHint.js';
import { ENABLE_RASTER_REPROJECTION } from '../../reproj/common.js';
import { IMAGE_SMOOTHING_DISABLED, IMAGE_SMOOTHING_ENABLED } from './common.js';
import { apply as applyTransform, compose as composeTransform, makeInverse, toString as toTransformString, } from '../../transform.js';
import { assign } from '../../obj.js';
import { containsCoordinate, containsExtent, getHeight, getIntersection, getWidth, intersects as intersectsExtent, isEmpty, } from '../../extent.js';
import { fromUserExtent } from '../../proj.js';
/**
* @classdesc
* Canvas renderer for image layers.
* @api
*/
var CanvasImageLayerRenderer = /** @class */ (function (_super) {
__extends(CanvasImageLayerRenderer, _super);
/**
* @param {import("../../layer/Image.js").default} imageLayer Image layer.
*/
function CanvasImageLayerRenderer(imageLayer) {
var _this = _super.call(this, imageLayer) || this;
/**
* @protected
* @type {?import("../../ImageBase.js").default}
*/
_this.image_ = null;
return _this;
}
/**
* @return {HTMLCanvasElement|HTMLImageElement|HTMLVideoElement} Image.
*/
CanvasImageLayerRenderer.prototype.getImage = function () {
return !this.image_ ? null : this.image_.getImage();
};
/**
* Determine whether render should be called.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @return {boolean} Layer is ready to be rendered.
*/
CanvasImageLayerRenderer.prototype.prepareFrame = function (frameState) {
var layerState = frameState.layerStatesArray[frameState.layerIndex];
var pixelRatio = frameState.pixelRatio;
var viewState = frameState.viewState;
var viewResolution = viewState.resolution;
var imageSource = this.getLayer().getSource();
var hints = frameState.viewHints;
var renderedExtent = frameState.extent;
if (layerState.extent !== undefined) {
renderedExtent = getIntersection(renderedExtent, fromUserExtent(layerState.extent, viewState.projection));
}
if (!hints[ViewHint.ANIMATING] &&
!hints[ViewHint.INTERACTING] &&
!isEmpty(renderedExtent)) {
if (imageSource) {
var projection = viewState.projection;
if (!ENABLE_RASTER_REPROJECTION) {
var sourceProjection = imageSource.getProjection();
if (sourceProjection) {
projection = sourceProjection;
}
}
var image = imageSource.getImage(renderedExtent, viewResolution, pixelRatio, projection);
if (image) {
if (this.loadImage(image)) {
this.image_ = image;
}
else if (image.getState() === ImageState.EMPTY) {
this.image_ = null;
}
}
}
else {
this.image_ = null;
}
}
return !!this.image_;
};
/**
* @param {import("../../pixel.js").Pixel} pixel Pixel.
* @return {Uint8ClampedArray} Data at the pixel location.
*/
CanvasImageLayerRenderer.prototype.getData = function (pixel) {
var frameState = this.frameState;
if (!frameState) {
return null;
}
var layer = this.getLayer();
var coordinate = applyTransform(frameState.pixelToCoordinateTransform, pixel.slice());
var layerExtent = layer.getExtent();
if (layerExtent) {
if (!containsCoordinate(layerExtent, coordinate)) {
return null;
}
}
var imageExtent = this.image_.getExtent();
var img = this.image_.getImage();
var imageMapWidth = getWidth(imageExtent);
var col = Math.floor(img.width * ((coordinate[0] - imageExtent[0]) / imageMapWidth));
if (col < 0 || col >= img.width) {
return null;
}
var imageMapHeight = getHeight(imageExtent);
var row = Math.floor(img.height * ((imageExtent[3] - coordinate[1]) / imageMapHeight));
if (row < 0 || row >= img.height) {
return null;
}
return this.getImageData(img, col, row);
};
/**
* Render the layer.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @param {HTMLElement} target Target that may be used to render content to.
* @return {HTMLElement} The rendered element.
*/
CanvasImageLayerRenderer.prototype.renderFrame = function (frameState, target) {
var image = this.image_;
var imageExtent = image.getExtent();
var imageResolution = image.getResolution();
var imagePixelRatio = image.getPixelRatio();
var layerState = frameState.layerStatesArray[frameState.layerIndex];
var pixelRatio = frameState.pixelRatio;
var viewState = frameState.viewState;
var viewCenter = viewState.center;
var viewResolution = viewState.resolution;
var scale = (pixelRatio * imageResolution) / (viewResolution * imagePixelRatio);
var extent = frameState.extent;
var resolution = viewState.resolution;
var rotation = viewState.rotation;
// desired dimensions of the canvas in pixels
var width = Math.round((getWidth(extent) / resolution) * pixelRatio);
var height = Math.round((getHeight(extent) / resolution) * pixelRatio);
// set forward and inverse pixel transforms
composeTransform(this.pixelTransform, frameState.size[0] / 2, frameState.size[1] / 2, 1 / pixelRatio, 1 / pixelRatio, rotation, -width / 2, -height / 2);
makeInverse(this.inversePixelTransform, this.pixelTransform);
var canvasTransform = toTransformString(this.pixelTransform);
this.useContainer(target, canvasTransform, this.getBackground(frameState));
var context = this.context;
var canvas = context.canvas;
if (canvas.width != width || canvas.height != height) {
canvas.width = width;
canvas.height = height;
}
else if (!this.containerReused) {
context.clearRect(0, 0, width, height);
}
// clipped rendering if layer extent is set
var clipped = false;
var render = true;
if (layerState.extent) {
var layerExtent = fromUserExtent(layerState.extent, viewState.projection);
render = intersectsExtent(layerExtent, frameState.extent);
clipped = render && !containsExtent(layerExtent, frameState.extent);
if (clipped) {
this.clipUnrotated(context, frameState, layerExtent);
}
}
var img = image.getImage();
var transform = composeTransform(this.tempTransform, width / 2, height / 2, scale, scale, 0, (imagePixelRatio * (imageExtent[0] - viewCenter[0])) / imageResolution, (imagePixelRatio * (viewCenter[1] - imageExtent[3])) / imageResolution);
this.renderedResolution = (imageResolution * pixelRatio) / imagePixelRatio;
var dw = img.width * transform[0];
var dh = img.height * transform[3];
if (!this.getLayer().getSource().getInterpolate()) {
assign(context, IMAGE_SMOOTHING_DISABLED);
}
this.preRender(context, frameState);
if (render && dw >= 0.5 && dh >= 0.5) {
var dx = transform[4];
var dy = transform[5];
var opacity = layerState.opacity;
var previousAlpha = void 0;
if (opacity !== 1) {
previousAlpha = context.globalAlpha;
context.globalAlpha = opacity;
}
context.drawImage(img, 0, 0, +img.width, +img.height, dx, dy, dw, dh);
if (opacity !== 1) {
context.globalAlpha = previousAlpha;
}
}
this.postRender(context, frameState);
if (clipped) {
context.restore();
}
assign(context, IMAGE_SMOOTHING_ENABLED);
if (canvasTransform !== canvas.style.transform) {
canvas.style.transform = canvasTransform;
}
return this.container;
};
return CanvasImageLayerRenderer;
}(CanvasLayerRenderer));
export default CanvasImageLayerRenderer;
//# sourceMappingURL=ImageLayer.js.map

1
node_modules/ol/renderer/canvas/ImageLayer.js.map generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

121
node_modules/ol/renderer/canvas/Layer.d.ts generated vendored Normal file
View File

@@ -0,0 +1,121 @@
/**
* @type {Array<HTMLCanvasElement>}
*/
export const canvasPool: Array<HTMLCanvasElement>;
export default CanvasLayerRenderer;
/**
* @abstract
* @template {import("../../layer/Layer.js").default} LayerType
* @extends {LayerRenderer<LayerType>}
*/
declare class CanvasLayerRenderer<LayerType extends import("../../layer/Layer.js").default<import("../../source/Source.js").default, LayerRenderer<any>>> extends LayerRenderer<LayerType> {
/**
* @protected
* @type {HTMLElement}
*/
protected container: HTMLElement;
/**
* @protected
* @type {number}
*/
protected renderedResolution: number;
/**
* A temporary transform. The values in this transform should only be used in a
* function that sets the values.
* @protected
* @type {import("../../transform.js").Transform}
*/
protected tempTransform: import("../../transform.js").Transform;
/**
* The transform for rendered pixels to viewport CSS pixels. This transform must
* be set when rendering a frame and may be used by other functions after rendering.
* @protected
* @type {import("../../transform.js").Transform}
*/
protected pixelTransform: import("../../transform.js").Transform;
/**
* The transform for viewport CSS pixels to rendered pixels. This transform must
* be set when rendering a frame and may be used by other functions after rendering.
* @protected
* @type {import("../../transform.js").Transform}
*/
protected inversePixelTransform: import("../../transform.js").Transform;
/**
* @type {CanvasRenderingContext2D}
*/
context: CanvasRenderingContext2D;
/**
* @type {boolean}
*/
containerReused: boolean;
/**
* @private
* @type {CanvasRenderingContext2D}
*/
private pixelContext_;
/**
* @protected
* @type {import("../../PluggableMap.js").FrameState|null}
*/
protected frameState: import("../../PluggableMap.js").FrameState | null;
/**
* @param {HTMLCanvasElement|HTMLImageElement|HTMLVideoElement} image Image.
* @param {number} col The column index.
* @param {number} row The row index.
* @return {Uint8ClampedArray|null} The image data.
*/
getImageData(image: HTMLCanvasElement | HTMLImageElement | HTMLVideoElement, col: number, row: number): Uint8ClampedArray | null;
/**
* @param {import('../../PluggableMap.js').FrameState} frameState Frame state.
* @return {string} Background color.
*/
getBackground(frameState: import('../../PluggableMap.js').FrameState): string;
/**
* Get a rendering container from an existing target, if compatible.
* @param {HTMLElement} target Potential render target.
* @param {string} transform CSS Transform.
* @param {string} [opt_backgroundColor] Background color.
*/
useContainer(target: HTMLElement, transform: string, opt_backgroundColor?: string | undefined): void;
/**
* @param {CanvasRenderingContext2D} context Context.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @param {import("../../extent.js").Extent} extent Clip extent.
* @protected
*/
protected clipUnrotated(context: CanvasRenderingContext2D, frameState: import("../../PluggableMap.js").FrameState, extent: import("../../extent.js").Extent): void;
/**
* @param {import("../../render/EventType.js").default} type Event type.
* @param {CanvasRenderingContext2D} context Context.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @private
*/
private dispatchRenderEvent_;
/**
* @param {CanvasRenderingContext2D} context Context.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @protected
*/
protected preRender(context: CanvasRenderingContext2D, frameState: import("../../PluggableMap.js").FrameState): void;
/**
* @param {CanvasRenderingContext2D} context Context.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @protected
*/
protected postRender(context: CanvasRenderingContext2D, frameState: import("../../PluggableMap.js").FrameState): void;
/**
* Creates a transform for rendering to an element that will be rotated after rendering.
* @param {import("../../coordinate.js").Coordinate} center Center.
* @param {number} resolution Resolution.
* @param {number} rotation Rotation.
* @param {number} pixelRatio Pixel ratio.
* @param {number} width Width of the rendered element (in pixels).
* @param {number} height Height of the rendered element (in pixels).
* @param {number} offsetX Offset on the x-axis in view coordinates.
* @protected
* @return {!import("../../transform.js").Transform} Transform.
*/
protected getRenderTransform(center: import("../../coordinate.js").Coordinate, resolution: number, rotation: number, pixelRatio: number, width: number, height: number, offsetX: number): import("../../transform.js").Transform;
}
import LayerRenderer from "../Layer.js";
//# sourceMappingURL=Layer.d.ts.map

1
node_modules/ol/renderer/canvas/Layer.d.ts.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"Layer.d.ts","sourceRoot":"","sources":["../../src/renderer/canvas/Layer.js"],"names":[],"mappings":"AAsBA;;GAEG;AACH,yBAFU,MAAM,iBAAiB,CAAC,CAEL;;AAc7B;;;;GAIG;AACH;IAOI;;;OAGG;IACH,qBAFU,WAAW,CAEA;IAErB;;;OAGG;IACH,8BAFU,MAAM,CAEO;IAEvB;;;;;OAKG;IACH,yBAFU,OAAO,oBAAoB,EAAE,SAAS,CAEV;IAEtC;;;;;OAKG;IACH,0BAFU,OAAO,oBAAoB,EAAE,SAAS,CAET;IAEvC;;;;;OAKG;IACH,iCAFU,OAAO,oBAAoB,EAAE,SAAS,CAEF;IAE9C;;OAEG;IACH,SAFU,wBAAwB,CAEf;IAEnB;;OAEG;IACH,iBAFU,OAAO,CAEW;IAE5B;;;OAGG;IACH,sBAAyB;IAEzB;;;OAGG;IACH,sBAFU,OAAO,uBAAuB,EAAE,UAAU,GAAC,IAAI,CAEnC;IAGxB;;;;;OAKG;IACH,oBALW,iBAAiB,GAAC,gBAAgB,GAAC,gBAAgB,OACnD,MAAM,OACN,MAAM,GACL,iBAAiB,GAAC,IAAI,CAiBjC;IAED;;;OAGG;IACH,0BAHW,OAAO,uBAAuB,EAAE,UAAU,GACzC,MAAM,CASjB;IAED;;;;;OAKG;IACH,qBAJW,WAAW,aACX,MAAM,kDAyDhB;IAED;;;;;OAKG;IACH,iCALW,wBAAwB,cACxB,OAAO,uBAAuB,EAAE,UAAU,UAC1C,OAAO,iBAAiB,EAAE,MAAM,QA2B1C;IAED;;;;;OAKG;IACH,6BAWC;IAED;;;;OAIG;IACH,6BAJW,wBAAwB,cACxB,OAAO,uBAAuB,EAAE,UAAU,QAMpD;IAED;;;;OAIG;IACH,8BAJW,wBAAwB,cACxB,OAAO,uBAAuB,EAAE,UAAU,QAKpD;IAED;;;;;;;;;;;OAWG;IACH,qCAVW,OAAO,qBAAqB,EAAE,UAAU,cACxC,MAAM,YACN,MAAM,cACN,MAAM,SACN,MAAM,UACN,MAAM,WACN,MAAM,GAEJ,OAAO,oBAAoB,EAAE,SAAS,CA2BlD;CAoEF"}

331
node_modules/ol/renderer/canvas/Layer.js generated vendored Normal file
View File

@@ -0,0 +1,331 @@
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
/**
* @module ol/renderer/canvas/Layer
*/
import LayerRenderer from '../Layer.js';
import RenderEvent from '../../render/Event.js';
import RenderEventType from '../../render/EventType.js';
import { apply as applyTransform, compose as composeTransform, create as createTransform, } from '../../transform.js';
import { asArray } from '../../color.js';
import { containsCoordinate, getBottomLeft, getBottomRight, getTopLeft, getTopRight, } from '../../extent.js';
import { createCanvasContext2D } from '../../dom.js';
import { equals } from '../../array.js';
/**
* @type {Array<HTMLCanvasElement>}
*/
export var canvasPool = [];
/**
* @type {CanvasRenderingContext2D}
*/
var pixelContext = null;
function createPixelContext() {
var canvas = document.createElement('canvas');
canvas.width = 1;
canvas.height = 1;
pixelContext = canvas.getContext('2d');
}
/**
* @abstract
* @template {import("../../layer/Layer.js").default} LayerType
* @extends {LayerRenderer<LayerType>}
*/
var CanvasLayerRenderer = /** @class */ (function (_super) {
__extends(CanvasLayerRenderer, _super);
/**
* @param {LayerType} layer Layer.
*/
function CanvasLayerRenderer(layer) {
var _this = _super.call(this, layer) || this;
/**
* @protected
* @type {HTMLElement}
*/
_this.container = null;
/**
* @protected
* @type {number}
*/
_this.renderedResolution;
/**
* A temporary transform. The values in this transform should only be used in a
* function that sets the values.
* @protected
* @type {import("../../transform.js").Transform}
*/
_this.tempTransform = createTransform();
/**
* The transform for rendered pixels to viewport CSS pixels. This transform must
* be set when rendering a frame and may be used by other functions after rendering.
* @protected
* @type {import("../../transform.js").Transform}
*/
_this.pixelTransform = createTransform();
/**
* The transform for viewport CSS pixels to rendered pixels. This transform must
* be set when rendering a frame and may be used by other functions after rendering.
* @protected
* @type {import("../../transform.js").Transform}
*/
_this.inversePixelTransform = createTransform();
/**
* @type {CanvasRenderingContext2D}
*/
_this.context = null;
/**
* @type {boolean}
*/
_this.containerReused = false;
/**
* @private
* @type {CanvasRenderingContext2D}
*/
_this.pixelContext_ = null;
/**
* @protected
* @type {import("../../PluggableMap.js").FrameState|null}
*/
_this.frameState = null;
return _this;
}
/**
* @param {HTMLCanvasElement|HTMLImageElement|HTMLVideoElement} image Image.
* @param {number} col The column index.
* @param {number} row The row index.
* @return {Uint8ClampedArray|null} The image data.
*/
CanvasLayerRenderer.prototype.getImageData = function (image, col, row) {
if (!pixelContext) {
createPixelContext();
}
pixelContext.clearRect(0, 0, 1, 1);
var data;
try {
pixelContext.drawImage(image, col, row, 1, 1, 0, 0, 1, 1);
data = pixelContext.getImageData(0, 0, 1, 1).data;
}
catch (err) {
pixelContext = null;
return null;
}
return data;
};
/**
* @param {import('../../PluggableMap.js').FrameState} frameState Frame state.
* @return {string} Background color.
*/
CanvasLayerRenderer.prototype.getBackground = function (frameState) {
var layer = this.getLayer();
var background = layer.getBackground();
if (typeof background === 'function') {
background = background(frameState.viewState.resolution);
}
return background || undefined;
};
/**
* Get a rendering container from an existing target, if compatible.
* @param {HTMLElement} target Potential render target.
* @param {string} transform CSS Transform.
* @param {string} [opt_backgroundColor] Background color.
*/
CanvasLayerRenderer.prototype.useContainer = function (target, transform, opt_backgroundColor) {
var layerClassName = this.getLayer().getClassName();
var container, context;
if (target &&
target.className === layerClassName &&
(!opt_backgroundColor ||
(target &&
target.style.backgroundColor &&
equals(asArray(target.style.backgroundColor), asArray(opt_backgroundColor))))) {
var canvas = target.firstElementChild;
if (canvas instanceof HTMLCanvasElement) {
context = canvas.getContext('2d');
}
}
if (context && context.canvas.style.transform === transform) {
// Container of the previous layer renderer can be used.
this.container = target;
this.context = context;
this.containerReused = true;
}
else if (this.containerReused) {
// Previously reused container cannot be used any more.
this.container = null;
this.context = null;
this.containerReused = false;
}
if (!this.container) {
container = document.createElement('div');
container.className = layerClassName;
var style = container.style;
style.position = 'absolute';
style.width = '100%';
style.height = '100%';
context = createCanvasContext2D();
var canvas = context.canvas;
container.appendChild(canvas);
style = canvas.style;
style.position = 'absolute';
style.left = '0';
style.transformOrigin = 'top left';
this.container = container;
this.context = context;
}
if (!this.containerReused &&
opt_backgroundColor &&
!this.container.style.backgroundColor) {
this.container.style.backgroundColor = opt_backgroundColor;
}
};
/**
* @param {CanvasRenderingContext2D} context Context.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @param {import("../../extent.js").Extent} extent Clip extent.
* @protected
*/
CanvasLayerRenderer.prototype.clipUnrotated = function (context, frameState, extent) {
var topLeft = getTopLeft(extent);
var topRight = getTopRight(extent);
var bottomRight = getBottomRight(extent);
var bottomLeft = getBottomLeft(extent);
applyTransform(frameState.coordinateToPixelTransform, topLeft);
applyTransform(frameState.coordinateToPixelTransform, topRight);
applyTransform(frameState.coordinateToPixelTransform, bottomRight);
applyTransform(frameState.coordinateToPixelTransform, bottomLeft);
var inverted = this.inversePixelTransform;
applyTransform(inverted, topLeft);
applyTransform(inverted, topRight);
applyTransform(inverted, bottomRight);
applyTransform(inverted, bottomLeft);
context.save();
context.beginPath();
context.moveTo(Math.round(topLeft[0]), Math.round(topLeft[1]));
context.lineTo(Math.round(topRight[0]), Math.round(topRight[1]));
context.lineTo(Math.round(bottomRight[0]), Math.round(bottomRight[1]));
context.lineTo(Math.round(bottomLeft[0]), Math.round(bottomLeft[1]));
context.clip();
};
/**
* @param {import("../../render/EventType.js").default} type Event type.
* @param {CanvasRenderingContext2D} context Context.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @private
*/
CanvasLayerRenderer.prototype.dispatchRenderEvent_ = function (type, context, frameState) {
var layer = this.getLayer();
if (layer.hasListener(type)) {
var event_1 = new RenderEvent(type, this.inversePixelTransform, frameState, context);
layer.dispatchEvent(event_1);
}
};
/**
* @param {CanvasRenderingContext2D} context Context.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @protected
*/
CanvasLayerRenderer.prototype.preRender = function (context, frameState) {
this.frameState = frameState;
this.dispatchRenderEvent_(RenderEventType.PRERENDER, context, frameState);
};
/**
* @param {CanvasRenderingContext2D} context Context.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @protected
*/
CanvasLayerRenderer.prototype.postRender = function (context, frameState) {
this.dispatchRenderEvent_(RenderEventType.POSTRENDER, context, frameState);
};
/**
* Creates a transform for rendering to an element that will be rotated after rendering.
* @param {import("../../coordinate.js").Coordinate} center Center.
* @param {number} resolution Resolution.
* @param {number} rotation Rotation.
* @param {number} pixelRatio Pixel ratio.
* @param {number} width Width of the rendered element (in pixels).
* @param {number} height Height of the rendered element (in pixels).
* @param {number} offsetX Offset on the x-axis in view coordinates.
* @protected
* @return {!import("../../transform.js").Transform} Transform.
*/
CanvasLayerRenderer.prototype.getRenderTransform = function (center, resolution, rotation, pixelRatio, width, height, offsetX) {
var dx1 = width / 2;
var dy1 = height / 2;
var sx = pixelRatio / resolution;
var sy = -sx;
var dx2 = -center[0] + offsetX;
var dy2 = -center[1];
return composeTransform(this.tempTransform, dx1, dy1, sx, sy, -rotation, dx2, dy2);
};
/**
* @param {import("../../pixel.js").Pixel} pixel Pixel.
* @param {import("../../PluggableMap.js").FrameState} frameState FrameState.
* @param {number} hitTolerance Hit tolerance in pixels.
* @return {Uint8ClampedArray|Uint8Array} The result. If there is no data at the pixel
* location, null will be returned. If there is data, but pixel values cannot be
* returned, and empty array will be returned.
*/
CanvasLayerRenderer.prototype.getDataAtPixel = function (pixel, frameState, hitTolerance) {
var renderPixel = applyTransform(this.inversePixelTransform, pixel.slice());
var context = this.context;
var layer = this.getLayer();
var layerExtent = layer.getExtent();
if (layerExtent) {
var renderCoordinate = applyTransform(frameState.pixelToCoordinateTransform, pixel.slice());
/** get only data inside of the layer extent */
if (!containsCoordinate(layerExtent, renderCoordinate)) {
return null;
}
}
var x = Math.round(renderPixel[0]);
var y = Math.round(renderPixel[1]);
var pixelContext = this.pixelContext_;
if (!pixelContext) {
var pixelCanvas = document.createElement('canvas');
pixelCanvas.width = 1;
pixelCanvas.height = 1;
pixelContext = pixelCanvas.getContext('2d');
this.pixelContext_ = pixelContext;
}
pixelContext.clearRect(0, 0, 1, 1);
var data;
try {
pixelContext.drawImage(context.canvas, x, y, 1, 1, 0, 0, 1, 1);
data = pixelContext.getImageData(0, 0, 1, 1).data;
}
catch (err) {
if (err.name === 'SecurityError') {
// tainted canvas, we assume there is data at the given pixel (although there might not be)
this.pixelContext_ = null;
return new Uint8Array();
}
return data;
}
if (data[3] === 0) {
return null;
}
return data;
};
/**
* Clean up.
*/
CanvasLayerRenderer.prototype.disposeInternal = function () {
delete this.frameState;
_super.prototype.disposeInternal.call(this);
};
return CanvasLayerRenderer;
}(LayerRenderer));
export default CanvasLayerRenderer;
//# sourceMappingURL=Layer.js.map

1
node_modules/ol/renderer/canvas/Layer.js.map generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

138
node_modules/ol/renderer/canvas/TileLayer.d.ts generated vendored Normal file
View File

@@ -0,0 +1,138 @@
export default CanvasTileLayerRenderer;
/**
* @classdesc
* Canvas renderer for tile layers.
* @api
* @template {import("../../layer/Tile.js").default<import("../../source/Tile.js").default>|import("../../layer/VectorTile.js").default} [LayerType=import("../../layer/Tile.js").default<import("../../source/Tile.js").default>|import("../../layer/VectorTile.js").default]
* @extends {CanvasLayerRenderer<LayerType>}
*/
declare class CanvasTileLayerRenderer<LayerType extends import("../../layer/Tile.js").default<import("../../source/Tile.js").default> | import("../../layer/VectorTile.js").default = import("../../layer/Tile.js").default<import("../../source/Tile.js").default> | import("../../layer/VectorTile.js").default> extends CanvasLayerRenderer<LayerType> {
/**
* @param {LayerType} tileLayer Tile layer.
*/
constructor(tileLayer: LayerType);
/**
* Rendered extent has changed since the previous `renderFrame()` call
* @type {boolean}
*/
extentChanged: boolean;
/**
* @private
* @type {?import("../../extent.js").Extent}
*/
private renderedExtent_;
/**
* @protected
* @type {number}
*/
protected renderedPixelRatio: number;
/**
* @protected
* @type {import("../../proj/Projection.js").default}
*/
protected renderedProjection: import("../../proj/Projection.js").default;
/**
* @protected
* @type {number}
*/
protected renderedRevision: number;
/**
* @protected
* @type {!Array<import("../../Tile.js").default>}
*/
protected renderedTiles: Array<import("../../Tile.js").default>;
/**
* @private
* @type {boolean}
*/
private newTiles_;
/**
* @protected
* @type {import("../../extent.js").Extent}
*/
protected tmpExtent: import("../../extent.js").Extent;
/**
* @private
* @type {import("../../TileRange.js").default}
*/
private tmpTileRange_;
/**
* @protected
* @param {import("../../Tile.js").default} tile Tile.
* @return {boolean} Tile is drawable.
*/
protected isDrawableTile(tile: import("../../Tile.js").default): boolean;
/**
* @param {number} z Tile coordinate z.
* @param {number} x Tile coordinate x.
* @param {number} y Tile coordinate y.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @return {!import("../../Tile.js").default} Tile.
*/
getTile(z: number, x: number, y: number, frameState: import("../../PluggableMap.js").FrameState): import("../../Tile.js").default;
/**
* @param {import("../../pixel.js").Pixel} pixel Pixel.
* @return {Uint8ClampedArray} Data at the pixel location.
*/
getData(pixel: import("../../pixel.js").Pixel): Uint8ClampedArray;
/**
* @param {import("../../ImageTile.js").default} tile Tile.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @param {number} x Left of the tile.
* @param {number} y Top of the tile.
* @param {number} w Width of the tile.
* @param {number} h Height of the tile.
* @param {number} gutter Tile gutter.
* @param {boolean} transition Apply an alpha transition.
*/
drawTileImage(tile: import("../../ImageTile.js").default, frameState: import("../../PluggableMap.js").FrameState, x: number, y: number, w: number, h: number, gutter: number, transition: boolean): void;
/**
* @return {HTMLCanvasElement} Image
*/
getImage(): HTMLCanvasElement;
/**
* Get the image from a tile.
* @param {import("../../ImageTile.js").default} tile Tile.
* @return {HTMLCanvasElement|HTMLImageElement|HTMLVideoElement} Image.
* @protected
*/
protected getTileImage(tile: import("../../ImageTile.js").default): HTMLCanvasElement | HTMLImageElement | HTMLVideoElement;
/**
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @param {import("../../source/Tile.js").default} tileSource Tile source.
* @protected
*/
protected scheduleExpireCache(frameState: import("../../PluggableMap.js").FrameState, tileSource: import("../../source/Tile.js").default): void;
/**
* @param {!Object<string, !Object<string, boolean>>} usedTiles Used tiles.
* @param {import("../../source/Tile.js").default} tileSource Tile source.
* @param {import('../../Tile.js').default} tile Tile.
* @protected
*/
protected updateUsedTiles(usedTiles: {
[x: string]: {
[x: string]: boolean;
};
}, tileSource: import("../../source/Tile.js").default, tile: import('../../Tile.js').default): void;
/**
* Manage tile pyramid.
* This function performs a number of functions related to the tiles at the
* current zoom and lower zoom levels:
* - registers idle tiles in frameState.wantedTiles so that they are not
* discarded by the tile queue
* - enqueues missing tiles
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @param {import("../../source/Tile.js").default} tileSource Tile source.
* @param {import("../../tilegrid/TileGrid.js").default} tileGrid Tile grid.
* @param {number} pixelRatio Pixel ratio.
* @param {import("../../proj/Projection.js").default} projection Projection.
* @param {import("../../extent.js").Extent} extent Extent.
* @param {number} currentZ Current Z.
* @param {number} preload Load low resolution tiles up to `preload` levels.
* @param {function(import("../../Tile.js").default):void} [opt_tileCallback] Tile callback.
* @protected
*/
protected manageTilePyramid(frameState: import("../../PluggableMap.js").FrameState, tileSource: import("../../source/Tile.js").default, tileGrid: import("../../tilegrid/TileGrid.js").default, pixelRatio: number, projection: import("../../proj/Projection.js").default, extent: import("../../extent.js").Extent, currentZ: number, preload: number, opt_tileCallback?: ((arg0: import("../../Tile.js").default) => void) | undefined): void;
}
import CanvasLayerRenderer from "./Layer.js";
//# sourceMappingURL=TileLayer.d.ts.map

1
node_modules/ol/renderer/canvas/TileLayer.d.ts.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"TileLayer.d.ts","sourceRoot":"","sources":["../../src/renderer/canvas/TileLayer.js"],"names":[],"mappings":";AAgCA;;;;;;GAMG;AACH;IACE;;OAEG;IACH,uBAFW,SAAS,EA0DnB;IArDC;;;OAGG;IACH,eAFU,OAAO,CAEQ;IAEzB;;;OAGG;IACH,wBAA2B;IAE3B;;;OAGG;IACH,8BAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,8BAFU,OAAO,0BAA0B,EAAE,OAAO,CAEtB;IAE9B;;;OAGG;IACH,4BAFU,MAAM,CAEK;IAErB;;;OAGG;IACH,yBAFW,MAAM,OAAO,eAAe,EAAE,OAAO,CAAC,CAE1B;IAEvB;;;OAGG;IACH,kBAAsB;IAEtB;;;OAGG;IACH,qBAFU,OAAO,iBAAiB,EAAE,MAAM,CAEZ;IAE9B;;;OAGG;IACH,sBAA8C;IAGhD;;;;OAIG;IACH,+BAHW,OAAO,eAAe,EAAE,OAAO,GAC9B,OAAO,CAWlB;IAED;;;;;;OAMG;IACH,WANW,MAAM,KACN,MAAM,KACN,MAAM,cACN,OAAO,uBAAuB,EAAE,UAAU,GACxC,OAAO,eAAe,EAAE,OAAO,CAqB3C;IAED;;;OAGG;IACH,eAHW,OAAO,gBAAgB,EAAE,KAAK,GAC7B,iBAAiB,CAyE5B;IAoWD;;;;;;;;;OASG;IACH,oBATW,OAAO,oBAAoB,EAAE,OAAO,cACpC,OAAO,uBAAuB,EAAE,UAAU,KAC1C,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,cACN,OAAO,QAqCjB;IAED;;OAEG;IACH,YAFY,iBAAiB,CAK5B;IAED;;;;;OAKG;IACH,6BAJW,OAAO,oBAAoB,EAAE,OAAO,GACnC,iBAAiB,GAAC,gBAAgB,GAAC,gBAAgB,CAK9D;IAED;;;;OAIG;IACH,0CAJW,OAAO,uBAAuB,EAAE,UAAU,cAC1C,OAAO,sBAAsB,EAAE,OAAO,QA0BhD;IAED;;;;;OAKG;IACH;YALmB,MAAM;gBAAU,MAAM,GAAE,OAAO;;mBACvC,OAAO,sBAAsB,EAAE,OAAO,QACtC,OAAO,eAAe,EAAE,OAAO,QAUzC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,wCAXW,OAAO,uBAAuB,EAAE,UAAU,cAC1C,OAAO,sBAAsB,EAAE,OAAO,YACtC,OAAO,4BAA4B,EAAE,OAAO,cAC5C,MAAM,cACN,OAAO,0BAA0B,EAAE,OAAO,UAC1C,OAAO,iBAAiB,EAAE,MAAM,YAChC,MAAM,WACN,MAAM,6BACG,OAAO,eAAe,EAAE,OAAO,KAAE,IAAI,qBAmExD;CACF"}

581
node_modules/ol/renderer/canvas/TileLayer.js generated vendored Normal file
View File

@@ -0,0 +1,581 @@
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
/**
* @module ol/renderer/canvas/TileLayer
*/
import CanvasLayerRenderer from './Layer.js';
import ImageTile from '../../ImageTile.js';
import ReprojTile from '../../reproj/Tile.js';
import TileRange from '../../TileRange.js';
import TileState from '../../TileState.js';
import { IMAGE_SMOOTHING_DISABLED, IMAGE_SMOOTHING_ENABLED } from './common.js';
import { apply as applyTransform, compose as composeTransform, makeInverse, toString as toTransformString, } from '../../transform.js';
import { assign } from '../../obj.js';
import { containsCoordinate, createEmpty, equals, getHeight, getIntersection, getRotatedViewport, getTopLeft, getWidth, intersects, } from '../../extent.js';
import { fromUserExtent } from '../../proj.js';
import { getUid } from '../../util.js';
import { numberSafeCompareFunction } from '../../array.js';
import { toSize } from '../../size.js';
/**
* @classdesc
* Canvas renderer for tile layers.
* @api
* @template {import("../../layer/Tile.js").default<import("../../source/Tile.js").default>|import("../../layer/VectorTile.js").default} [LayerType=import("../../layer/Tile.js").default<import("../../source/Tile.js").default>|import("../../layer/VectorTile.js").default]
* @extends {CanvasLayerRenderer<LayerType>}
*/
var CanvasTileLayerRenderer = /** @class */ (function (_super) {
__extends(CanvasTileLayerRenderer, _super);
/**
* @param {LayerType} tileLayer Tile layer.
*/
function CanvasTileLayerRenderer(tileLayer) {
var _this = _super.call(this, tileLayer) || this;
/**
* Rendered extent has changed since the previous `renderFrame()` call
* @type {boolean}
*/
_this.extentChanged = true;
/**
* @private
* @type {?import("../../extent.js").Extent}
*/
_this.renderedExtent_ = null;
/**
* @protected
* @type {number}
*/
_this.renderedPixelRatio;
/**
* @protected
* @type {import("../../proj/Projection.js").default}
*/
_this.renderedProjection = null;
/**
* @protected
* @type {number}
*/
_this.renderedRevision;
/**
* @protected
* @type {!Array<import("../../Tile.js").default>}
*/
_this.renderedTiles = [];
/**
* @private
* @type {boolean}
*/
_this.newTiles_ = false;
/**
* @protected
* @type {import("../../extent.js").Extent}
*/
_this.tmpExtent = createEmpty();
/**
* @private
* @type {import("../../TileRange.js").default}
*/
_this.tmpTileRange_ = new TileRange(0, 0, 0, 0);
return _this;
}
/**
* @protected
* @param {import("../../Tile.js").default} tile Tile.
* @return {boolean} Tile is drawable.
*/
CanvasTileLayerRenderer.prototype.isDrawableTile = function (tile) {
var tileLayer = this.getLayer();
var tileState = tile.getState();
var useInterimTilesOnError = tileLayer.getUseInterimTilesOnError();
return (tileState == TileState.LOADED ||
tileState == TileState.EMPTY ||
(tileState == TileState.ERROR && !useInterimTilesOnError));
};
/**
* @param {number} z Tile coordinate z.
* @param {number} x Tile coordinate x.
* @param {number} y Tile coordinate y.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @return {!import("../../Tile.js").default} Tile.
*/
CanvasTileLayerRenderer.prototype.getTile = function (z, x, y, frameState) {
var pixelRatio = frameState.pixelRatio;
var projection = frameState.viewState.projection;
var tileLayer = this.getLayer();
var tileSource = tileLayer.getSource();
var tile = tileSource.getTile(z, x, y, pixelRatio, projection);
if (tile.getState() == TileState.ERROR) {
if (!tileLayer.getUseInterimTilesOnError()) {
// When useInterimTilesOnError is false, we consider the error tile as loaded.
tile.setState(TileState.LOADED);
}
else if (tileLayer.getPreload() > 0) {
// Preloaded tiles for lower resolutions might have finished loading.
this.newTiles_ = true;
}
}
if (!this.isDrawableTile(tile)) {
tile = tile.getInterimTile();
}
return tile;
};
/**
* @param {import("../../pixel.js").Pixel} pixel Pixel.
* @return {Uint8ClampedArray} Data at the pixel location.
*/
CanvasTileLayerRenderer.prototype.getData = function (pixel) {
var frameState = this.frameState;
if (!frameState) {
return null;
}
var layer = this.getLayer();
var coordinate = applyTransform(frameState.pixelToCoordinateTransform, pixel.slice());
var layerExtent = layer.getExtent();
if (layerExtent) {
if (!containsCoordinate(layerExtent, coordinate)) {
return null;
}
}
var pixelRatio = frameState.pixelRatio;
var projection = frameState.viewState.projection;
var viewState = frameState.viewState;
var source = layer.getRenderSource();
var tileGrid = source.getTileGridForProjection(viewState.projection);
var tilePixelRatio = source.getTilePixelRatio(frameState.pixelRatio);
for (var z = tileGrid.getZForResolution(viewState.resolution); z >= tileGrid.getMinZoom(); --z) {
var tileCoord = tileGrid.getTileCoordForCoordAndZ(coordinate, z);
var tile = source.getTile(z, tileCoord[1], tileCoord[2], pixelRatio, projection);
if (!(tile instanceof ImageTile || tile instanceof ReprojTile)) {
return null;
}
if (tile.getState() !== TileState.LOADED) {
continue;
}
var tileOrigin = tileGrid.getOrigin(z);
var tileSize = toSize(tileGrid.getTileSize(z));
var tileResolution = tileGrid.getResolution(z);
var col = Math.floor(tilePixelRatio *
((coordinate[0] - tileOrigin[0]) / tileResolution -
tileCoord[1] * tileSize[0]));
var row = Math.floor(tilePixelRatio *
((tileOrigin[1] - coordinate[1]) / tileResolution -
tileCoord[2] * tileSize[1]));
var gutter = Math.round(tilePixelRatio * source.getGutterForProjection(viewState.projection));
return this.getImageData(tile.getImage(), col + gutter, row + gutter);
}
return null;
};
/**
* @param {Object<number, Object<string, import("../../Tile.js").default>>} tiles Lookup of loaded tiles by zoom level.
* @param {number} zoom Zoom level.
* @param {import("../../Tile.js").default} tile Tile.
* @return {boolean|void} If `false`, the tile will not be considered loaded.
*/
CanvasTileLayerRenderer.prototype.loadedTileCallback = function (tiles, zoom, tile) {
if (this.isDrawableTile(tile)) {
return _super.prototype.loadedTileCallback.call(this, tiles, zoom, tile);
}
return false;
};
/**
* Determine whether render should be called.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @return {boolean} Layer is ready to be rendered.
*/
CanvasTileLayerRenderer.prototype.prepareFrame = function (frameState) {
return !!this.getLayer().getSource();
};
/**
* Render the layer.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @param {HTMLElement} target Target that may be used to render content to.
* @return {HTMLElement} The rendered element.
*/
CanvasTileLayerRenderer.prototype.renderFrame = function (frameState, target) {
var layerState = frameState.layerStatesArray[frameState.layerIndex];
var viewState = frameState.viewState;
var projection = viewState.projection;
var viewResolution = viewState.resolution;
var viewCenter = viewState.center;
var rotation = viewState.rotation;
var pixelRatio = frameState.pixelRatio;
var tileLayer = this.getLayer();
var tileSource = tileLayer.getSource();
var sourceRevision = tileSource.getRevision();
var tileGrid = tileSource.getTileGridForProjection(projection);
var z = tileGrid.getZForResolution(viewResolution, tileSource.zDirection);
var tileResolution = tileGrid.getResolution(z);
var extent = frameState.extent;
var resolution = frameState.viewState.resolution;
var tilePixelRatio = tileSource.getTilePixelRatio(pixelRatio);
// desired dimensions of the canvas in pixels
var width = Math.round((getWidth(extent) / resolution) * pixelRatio);
var height = Math.round((getHeight(extent) / resolution) * pixelRatio);
var layerExtent = layerState.extent && fromUserExtent(layerState.extent, projection);
if (layerExtent) {
extent = getIntersection(extent, fromUserExtent(layerState.extent, projection));
}
var dx = (tileResolution * width) / 2 / tilePixelRatio;
var dy = (tileResolution * height) / 2 / tilePixelRatio;
var canvasExtent = [
viewCenter[0] - dx,
viewCenter[1] - dy,
viewCenter[0] + dx,
viewCenter[1] + dy,
];
var tileRange = tileGrid.getTileRangeForExtentAndZ(extent, z);
/**
* @type {Object<number, Object<string, import("../../Tile.js").default>>}
*/
var tilesToDrawByZ = {};
tilesToDrawByZ[z] = {};
var findLoadedTiles = this.createLoadedTileFinder(tileSource, projection, tilesToDrawByZ);
var tmpExtent = this.tmpExtent;
var tmpTileRange = this.tmpTileRange_;
this.newTiles_ = false;
var viewport = rotation
? getRotatedViewport(viewState.center, resolution, rotation, frameState.size)
: undefined;
for (var x = tileRange.minX; x <= tileRange.maxX; ++x) {
for (var y = tileRange.minY; y <= tileRange.maxY; ++y) {
if (rotation &&
!tileGrid.tileCoordIntersectsViewport([z, x, y], viewport)) {
continue;
}
var tile = this.getTile(z, x, y, frameState);
if (this.isDrawableTile(tile)) {
var uid = getUid(this);
if (tile.getState() == TileState.LOADED) {
tilesToDrawByZ[z][tile.tileCoord.toString()] = tile;
var inTransition = tile.inTransition(uid);
if (inTransition && layerState.opacity !== 1) {
// Skipping transition when layer is not fully opaque avoids visual artifacts.
tile.endTransition(uid);
inTransition = false;
}
if (!this.newTiles_ &&
(inTransition || this.renderedTiles.indexOf(tile) === -1)) {
this.newTiles_ = true;
}
}
if (tile.getAlpha(uid, frameState.time) === 1) {
// don't look for alt tiles if alpha is 1
continue;
}
}
var childTileRange = tileGrid.getTileCoordChildTileRange(tile.tileCoord, tmpTileRange, tmpExtent);
var covered = false;
if (childTileRange) {
covered = findLoadedTiles(z + 1, childTileRange);
}
if (!covered) {
tileGrid.forEachTileCoordParentTileRange(tile.tileCoord, findLoadedTiles, tmpTileRange, tmpExtent);
}
}
}
var canvasScale = ((tileResolution / viewResolution) * pixelRatio) / tilePixelRatio;
// set forward and inverse pixel transforms
composeTransform(this.pixelTransform, frameState.size[0] / 2, frameState.size[1] / 2, 1 / pixelRatio, 1 / pixelRatio, rotation, -width / 2, -height / 2);
var canvasTransform = toTransformString(this.pixelTransform);
this.useContainer(target, canvasTransform, this.getBackground(frameState));
var context = this.context;
var canvas = context.canvas;
makeInverse(this.inversePixelTransform, this.pixelTransform);
// set scale transform for calculating tile positions on the canvas
composeTransform(this.tempTransform, width / 2, height / 2, canvasScale, canvasScale, 0, -width / 2, -height / 2);
if (canvas.width != width || canvas.height != height) {
canvas.width = width;
canvas.height = height;
}
else if (!this.containerReused) {
context.clearRect(0, 0, width, height);
}
if (layerExtent) {
this.clipUnrotated(context, frameState, layerExtent);
}
if (!tileSource.getInterpolate()) {
assign(context, IMAGE_SMOOTHING_DISABLED);
}
this.preRender(context, frameState);
this.renderedTiles.length = 0;
/** @type {Array<number>} */
var zs = Object.keys(tilesToDrawByZ).map(Number);
zs.sort(numberSafeCompareFunction);
var clips, clipZs, currentClip;
if (layerState.opacity === 1 &&
(!this.containerReused ||
tileSource.getOpaque(frameState.viewState.projection))) {
zs = zs.reverse();
}
else {
clips = [];
clipZs = [];
}
for (var i = zs.length - 1; i >= 0; --i) {
var currentZ = zs[i];
var currentTilePixelSize = tileSource.getTilePixelSize(currentZ, pixelRatio, projection);
var currentResolution = tileGrid.getResolution(currentZ);
var currentScale = currentResolution / tileResolution;
var dx_1 = currentTilePixelSize[0] * currentScale * canvasScale;
var dy_1 = currentTilePixelSize[1] * currentScale * canvasScale;
var originTileCoord = tileGrid.getTileCoordForCoordAndZ(getTopLeft(canvasExtent), currentZ);
var originTileExtent = tileGrid.getTileCoordExtent(originTileCoord);
var origin_1 = applyTransform(this.tempTransform, [
(tilePixelRatio * (originTileExtent[0] - canvasExtent[0])) /
tileResolution,
(tilePixelRatio * (canvasExtent[3] - originTileExtent[3])) /
tileResolution,
]);
var tileGutter = tilePixelRatio * tileSource.getGutterForProjection(projection);
var tilesToDraw = tilesToDrawByZ[currentZ];
for (var tileCoordKey in tilesToDraw) {
var tile = /** @type {import("../../ImageTile.js").default} */ (tilesToDraw[tileCoordKey]);
var tileCoord = tile.tileCoord;
// Calculate integer positions and sizes so that tiles align
var xIndex = originTileCoord[1] - tileCoord[1];
var nextX = Math.round(origin_1[0] - (xIndex - 1) * dx_1);
var yIndex = originTileCoord[2] - tileCoord[2];
var nextY = Math.round(origin_1[1] - (yIndex - 1) * dy_1);
var x = Math.round(origin_1[0] - xIndex * dx_1);
var y = Math.round(origin_1[1] - yIndex * dy_1);
var w = nextX - x;
var h = nextY - y;
var transition = z === currentZ;
var inTransition = transition && tile.getAlpha(getUid(this), frameState.time) !== 1;
var contextSaved = false;
if (!inTransition) {
if (clips) {
// Clip mask for regions in this tile that already filled by a higher z tile
currentClip = [x, y, x + w, y, x + w, y + h, x, y + h];
for (var i_1 = 0, ii = clips.length; i_1 < ii; ++i_1) {
if (z !== currentZ && currentZ < clipZs[i_1]) {
var clip = clips[i_1];
if (intersects([x, y, x + w, y + h], [clip[0], clip[3], clip[4], clip[7]])) {
if (!contextSaved) {
context.save();
contextSaved = true;
}
context.beginPath();
// counter-clockwise (outer ring) for current tile
context.moveTo(currentClip[0], currentClip[1]);
context.lineTo(currentClip[2], currentClip[3]);
context.lineTo(currentClip[4], currentClip[5]);
context.lineTo(currentClip[6], currentClip[7]);
// clockwise (inner ring) for higher z tile
context.moveTo(clip[6], clip[7]);
context.lineTo(clip[4], clip[5]);
context.lineTo(clip[2], clip[3]);
context.lineTo(clip[0], clip[1]);
context.clip();
}
}
}
clips.push(currentClip);
clipZs.push(currentZ);
}
else {
context.clearRect(x, y, w, h);
}
}
this.drawTileImage(tile, frameState, x, y, w, h, tileGutter, transition);
if (clips && !inTransition) {
if (contextSaved) {
context.restore();
}
this.renderedTiles.unshift(tile);
}
else {
this.renderedTiles.push(tile);
}
this.updateUsedTiles(frameState.usedTiles, tileSource, tile);
}
}
this.renderedRevision = sourceRevision;
this.renderedResolution = tileResolution;
this.extentChanged =
!this.renderedExtent_ || !equals(this.renderedExtent_, canvasExtent);
this.renderedExtent_ = canvasExtent;
this.renderedPixelRatio = pixelRatio;
this.renderedProjection = projection;
this.manageTilePyramid(frameState, tileSource, tileGrid, pixelRatio, projection, extent, z, tileLayer.getPreload());
this.scheduleExpireCache(frameState, tileSource);
this.postRender(context, frameState);
if (layerState.extent) {
context.restore();
}
assign(context, IMAGE_SMOOTHING_ENABLED);
if (canvasTransform !== canvas.style.transform) {
canvas.style.transform = canvasTransform;
}
return this.container;
};
/**
* @param {import("../../ImageTile.js").default} tile Tile.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @param {number} x Left of the tile.
* @param {number} y Top of the tile.
* @param {number} w Width of the tile.
* @param {number} h Height of the tile.
* @param {number} gutter Tile gutter.
* @param {boolean} transition Apply an alpha transition.
*/
CanvasTileLayerRenderer.prototype.drawTileImage = function (tile, frameState, x, y, w, h, gutter, transition) {
var image = this.getTileImage(tile);
if (!image) {
return;
}
var uid = getUid(this);
var layerState = frameState.layerStatesArray[frameState.layerIndex];
var alpha = layerState.opacity *
(transition ? tile.getAlpha(uid, frameState.time) : 1);
var alphaChanged = alpha !== this.context.globalAlpha;
if (alphaChanged) {
this.context.save();
this.context.globalAlpha = alpha;
}
this.context.drawImage(image, gutter, gutter, image.width - 2 * gutter, image.height - 2 * gutter, x, y, w, h);
if (alphaChanged) {
this.context.restore();
}
if (alpha !== layerState.opacity) {
frameState.animate = true;
}
else if (transition) {
tile.endTransition(uid);
}
};
/**
* @return {HTMLCanvasElement} Image
*/
CanvasTileLayerRenderer.prototype.getImage = function () {
var context = this.context;
return context ? context.canvas : null;
};
/**
* Get the image from a tile.
* @param {import("../../ImageTile.js").default} tile Tile.
* @return {HTMLCanvasElement|HTMLImageElement|HTMLVideoElement} Image.
* @protected
*/
CanvasTileLayerRenderer.prototype.getTileImage = function (tile) {
return tile.getImage();
};
/**
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @param {import("../../source/Tile.js").default} tileSource Tile source.
* @protected
*/
CanvasTileLayerRenderer.prototype.scheduleExpireCache = function (frameState, tileSource) {
if (tileSource.canExpireCache()) {
/**
* @param {import("../../source/Tile.js").default} tileSource Tile source.
* @param {import("../../PluggableMap.js").default} map Map.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
*/
var postRenderFunction = function (tileSource, map, frameState) {
var tileSourceKey = getUid(tileSource);
if (tileSourceKey in frameState.usedTiles) {
tileSource.expireCache(frameState.viewState.projection, frameState.usedTiles[tileSourceKey]);
}
}.bind(null, tileSource);
frameState.postRenderFunctions.push(
/** @type {import("../../PluggableMap.js").PostRenderFunction} */ (postRenderFunction));
}
};
/**
* @param {!Object<string, !Object<string, boolean>>} usedTiles Used tiles.
* @param {import("../../source/Tile.js").default} tileSource Tile source.
* @param {import('../../Tile.js').default} tile Tile.
* @protected
*/
CanvasTileLayerRenderer.prototype.updateUsedTiles = function (usedTiles, tileSource, tile) {
// FIXME should we use tilesToDrawByZ instead?
var tileSourceKey = getUid(tileSource);
if (!(tileSourceKey in usedTiles)) {
usedTiles[tileSourceKey] = {};
}
usedTiles[tileSourceKey][tile.getKey()] = true;
};
/**
* Manage tile pyramid.
* This function performs a number of functions related to the tiles at the
* current zoom and lower zoom levels:
* - registers idle tiles in frameState.wantedTiles so that they are not
* discarded by the tile queue
* - enqueues missing tiles
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @param {import("../../source/Tile.js").default} tileSource Tile source.
* @param {import("../../tilegrid/TileGrid.js").default} tileGrid Tile grid.
* @param {number} pixelRatio Pixel ratio.
* @param {import("../../proj/Projection.js").default} projection Projection.
* @param {import("../../extent.js").Extent} extent Extent.
* @param {number} currentZ Current Z.
* @param {number} preload Load low resolution tiles up to `preload` levels.
* @param {function(import("../../Tile.js").default):void} [opt_tileCallback] Tile callback.
* @protected
*/
CanvasTileLayerRenderer.prototype.manageTilePyramid = function (frameState, tileSource, tileGrid, pixelRatio, projection, extent, currentZ, preload, opt_tileCallback) {
var tileSourceKey = getUid(tileSource);
if (!(tileSourceKey in frameState.wantedTiles)) {
frameState.wantedTiles[tileSourceKey] = {};
}
var wantedTiles = frameState.wantedTiles[tileSourceKey];
var tileQueue = frameState.tileQueue;
var minZoom = tileGrid.getMinZoom();
var rotation = frameState.viewState.rotation;
var viewport = rotation
? getRotatedViewport(frameState.viewState.center, frameState.viewState.resolution, rotation, frameState.size)
: undefined;
var tileCount = 0;
var tile, tileRange, tileResolution, x, y, z;
for (z = minZoom; z <= currentZ; ++z) {
tileRange = tileGrid.getTileRangeForExtentAndZ(extent, z, tileRange);
tileResolution = tileGrid.getResolution(z);
for (x = tileRange.minX; x <= tileRange.maxX; ++x) {
for (y = tileRange.minY; y <= tileRange.maxY; ++y) {
if (rotation &&
!tileGrid.tileCoordIntersectsViewport([z, x, y], viewport)) {
continue;
}
if (currentZ - z <= preload) {
++tileCount;
tile = tileSource.getTile(z, x, y, pixelRatio, projection);
if (tile.getState() == TileState.IDLE) {
wantedTiles[tile.getKey()] = true;
if (!tileQueue.isKeyQueued(tile.getKey())) {
tileQueue.enqueue([
tile,
tileSourceKey,
tileGrid.getTileCoordCenter(tile.tileCoord),
tileResolution,
]);
}
}
if (opt_tileCallback !== undefined) {
opt_tileCallback(tile);
}
}
else {
tileSource.useTile(z, x, y, projection);
}
}
}
}
tileSource.updateCacheSize(tileCount, projection);
};
return CanvasTileLayerRenderer;
}(CanvasLayerRenderer));
export default CanvasTileLayerRenderer;
//# sourceMappingURL=TileLayer.js.map

1
node_modules/ol/renderer/canvas/TileLayer.js.map generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

43
node_modules/ol/renderer/canvas/VectorImageLayer.d.ts generated vendored Normal file
View File

@@ -0,0 +1,43 @@
export default CanvasVectorImageLayerRenderer;
/**
* @classdesc
* Canvas renderer for image layers.
* @api
*/
declare class CanvasVectorImageLayerRenderer extends CanvasImageLayerRenderer {
/**
* @param {import("../../layer/VectorImage.js").default} layer Vector image layer.
*/
constructor(layer: import("../../layer/VectorImage.js").default<any>);
/**
* @private
* @type {import("./VectorLayer.js").default}
*/
private vectorRenderer_;
/**
* @private
* @type {number}
*/
private layerImageRatio_;
/**
* @private
* @type {import("../../transform.js").Transform}
*/
private coordinateToVectorPixelTransform_;
/**
* @private
* @type {import("../../transform.js").Transform}
*/
private renderedPixelToCoordinateTransform_;
/**
*/
preRender(): void;
/**
*/
postRender(): void;
/**
*/
renderDeclutter(): void;
}
import CanvasImageLayerRenderer from "./ImageLayer.js";
//# sourceMappingURL=VectorImageLayer.d.ts.map

1
node_modules/ol/renderer/canvas/VectorImageLayer.d.ts.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"VectorImageLayer.d.ts","sourceRoot":"","sources":["../../src/renderer/canvas/VectorImageLayer.js"],"names":[],"mappings":";AAcA;;;;GAIG;AACH;IACE;;OAEG;IACH,sEA0BC;IAvBC;;;OAGG;IACH,wBAA2D;IAE3D;;;OAGG;IACH,yBAA6C;IAE7C;;;OAGG;IACH,0CAAiD;IAEjD;;;OAGG;IACH,4CAA+C;IAuIjD;OACG;IACH,kBAAc;IAEd;OACG;IACH,mBAAe;IAEf;OACG;IACH,wBAAoB;CAoCrB"}

185
node_modules/ol/renderer/canvas/VectorImageLayer.js generated vendored Normal file
View File

@@ -0,0 +1,185 @@
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
/**
* @module ol/renderer/canvas/VectorImageLayer
*/
import CanvasImageLayerRenderer from './ImageLayer.js';
import CanvasVectorLayerRenderer from './VectorLayer.js';
import EventType from '../../events/EventType.js';
import ImageCanvas from '../../ImageCanvas.js';
import ImageState from '../../ImageState.js';
import RBush from 'rbush';
import ViewHint from '../../ViewHint.js';
import { apply, compose, create } from '../../transform.js';
import { assign } from '../../obj.js';
import { getHeight, getWidth, isEmpty, scaleFromCenter } from '../../extent.js';
/**
* @classdesc
* Canvas renderer for image layers.
* @api
*/
var CanvasVectorImageLayerRenderer = /** @class */ (function (_super) {
__extends(CanvasVectorImageLayerRenderer, _super);
/**
* @param {import("../../layer/VectorImage.js").default} layer Vector image layer.
*/
function CanvasVectorImageLayerRenderer(layer) {
var _this = _super.call(this, layer) || this;
/**
* @private
* @type {import("./VectorLayer.js").default}
*/
_this.vectorRenderer_ = new CanvasVectorLayerRenderer(layer);
/**
* @private
* @type {number}
*/
_this.layerImageRatio_ = layer.getImageRatio();
/**
* @private
* @type {import("../../transform.js").Transform}
*/
_this.coordinateToVectorPixelTransform_ = create();
/**
* @private
* @type {import("../../transform.js").Transform}
*/
_this.renderedPixelToCoordinateTransform_ = null;
return _this;
}
/**
* Clean up.
*/
CanvasVectorImageLayerRenderer.prototype.disposeInternal = function () {
this.vectorRenderer_.dispose();
_super.prototype.disposeInternal.call(this);
};
/**
* Asynchronous layer level hit detection.
* @param {import("../../pixel.js").Pixel} pixel Pixel.
* @return {Promise<Array<import("../../Feature").default>>} Promise that resolves with an array of features.
*/
CanvasVectorImageLayerRenderer.prototype.getFeatures = function (pixel) {
if (!this.vectorRenderer_) {
return new Promise(function (resolve) { return resolve([]); });
}
var vectorPixel = apply(this.coordinateToVectorPixelTransform_, apply(this.renderedPixelToCoordinateTransform_, pixel.slice()));
return this.vectorRenderer_.getFeatures(vectorPixel);
};
/**
* Perform action necessary to get the layer rendered after new fonts have loaded
*/
CanvasVectorImageLayerRenderer.prototype.handleFontsChanged = function () {
this.vectorRenderer_.handleFontsChanged();
};
/**
* Determine whether render should be called.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @return {boolean} Layer is ready to be rendered.
*/
CanvasVectorImageLayerRenderer.prototype.prepareFrame = function (frameState) {
var pixelRatio = frameState.pixelRatio;
var viewState = frameState.viewState;
var viewResolution = viewState.resolution;
var hints = frameState.viewHints;
var vectorRenderer = this.vectorRenderer_;
var renderedExtent = frameState.extent;
if (this.layerImageRatio_ !== 1) {
renderedExtent = renderedExtent.slice(0);
scaleFromCenter(renderedExtent, this.layerImageRatio_);
}
var width = getWidth(renderedExtent) / viewResolution;
var height = getHeight(renderedExtent) / viewResolution;
if (!hints[ViewHint.ANIMATING] &&
!hints[ViewHint.INTERACTING] &&
!isEmpty(renderedExtent)) {
vectorRenderer.useContainer(null, null);
var context = vectorRenderer.context;
var layerState = frameState.layerStatesArray[frameState.layerIndex];
context.globalAlpha = layerState.opacity;
var imageLayerState = assign({}, layerState, { opacity: 1 });
var imageFrameState_1 =
/** @type {import("../../PluggableMap.js").FrameState} */ (assign({}, frameState, {
declutterTree: new RBush(9),
extent: renderedExtent,
size: [width, height],
viewState: /** @type {import("../../View.js").State} */ (assign({}, frameState.viewState, {
rotation: 0,
})),
layerStatesArray: [imageLayerState],
layerIndex: 0,
}));
var emptyImage_1 = true;
var image_1 = new ImageCanvas(renderedExtent, viewResolution, pixelRatio, context.canvas, function (callback) {
if (vectorRenderer.prepareFrame(imageFrameState_1) &&
vectorRenderer.replayGroupChanged) {
vectorRenderer.clipping = false;
if (vectorRenderer.renderFrame(imageFrameState_1, null)) {
vectorRenderer.renderDeclutter(imageFrameState_1);
emptyImage_1 = false;
}
callback();
}
});
image_1.addEventListener(EventType.CHANGE, function () {
if (image_1.getState() !== ImageState.LOADED) {
return;
}
this.image_ = emptyImage_1 ? null : image_1;
var imageResolution = image_1.getResolution();
var imagePixelRatio = image_1.getPixelRatio();
var renderedResolution = (imageResolution * pixelRatio) / imagePixelRatio;
this.renderedResolution = renderedResolution;
this.coordinateToVectorPixelTransform_ = compose(this.coordinateToVectorPixelTransform_, width / 2, height / 2, 1 / renderedResolution, -1 / renderedResolution, 0, -viewState.center[0], -viewState.center[1]);
}.bind(this));
image_1.load();
}
if (this.image_) {
this.renderedPixelToCoordinateTransform_ =
frameState.pixelToCoordinateTransform.slice();
}
return !!this.image_;
};
/**
*/
CanvasVectorImageLayerRenderer.prototype.preRender = function () { };
/**
*/
CanvasVectorImageLayerRenderer.prototype.postRender = function () { };
/**
*/
CanvasVectorImageLayerRenderer.prototype.renderDeclutter = function () { };
/**
* @param {import("../../coordinate.js").Coordinate} coordinate Coordinate.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @param {number} hitTolerance Hit tolerance in pixels.
* @param {import("../vector.js").FeatureCallback<T>} callback Feature callback.
* @param {Array<import("../Map.js").HitMatch<T>>} matches The hit detected matches with tolerance.
* @return {T|undefined} Callback result.
* @template T
*/
CanvasVectorImageLayerRenderer.prototype.forEachFeatureAtCoordinate = function (coordinate, frameState, hitTolerance, callback, matches) {
if (this.vectorRenderer_) {
return this.vectorRenderer_.forEachFeatureAtCoordinate(coordinate, frameState, hitTolerance, callback, matches);
}
else {
return _super.prototype.forEachFeatureAtCoordinate.call(this, coordinate, frameState, hitTolerance, callback, matches);
}
};
return CanvasVectorImageLayerRenderer;
}(CanvasImageLayerRenderer));
export default CanvasVectorImageLayerRenderer;
//# sourceMappingURL=VectorImageLayer.js.map

1
node_modules/ol/renderer/canvas/VectorImageLayer.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"VectorImageLayer.js","sourceRoot":"","sources":["../../src/renderer/canvas/VectorImageLayer.js"],"names":[],"mappings":"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"}

124
node_modules/ol/renderer/canvas/VectorLayer.d.ts generated vendored Normal file
View File

@@ -0,0 +1,124 @@
export default CanvasVectorLayerRenderer;
/**
* @classdesc
* Canvas renderer for vector layers.
* @api
*/
declare class CanvasVectorLayerRenderer extends CanvasLayerRenderer<any> {
/**
* @param {import("../../layer/BaseVector.js").default} vectorLayer Vector layer.
*/
constructor(vectorLayer: import("../../layer/BaseVector.js").default<any, any>);
/** @private */
private boundHandleStyleImageChange_;
/**
* @type {boolean}
*/
animatingOrInteracting_: boolean;
/**
* @type {ImageData}
*/
hitDetectionImageData_: ImageData;
/**
* @type {Array<import("../../Feature.js").default>}
*/
renderedFeatures_: Array<import("../../Feature.js").default>;
/**
* @private
* @type {number}
*/
private renderedRevision_;
/**
* @private
* @type {number}
*/
private renderedResolution_;
/**
* @private
* @type {import("../../extent.js").Extent}
*/
private renderedExtent_;
/**
* @private
* @type {import("../../extent.js").Extent}
*/
private wrappedRenderedExtent_;
/**
* @private
* @type {number}
*/
private renderedRotation_;
/**
* @private
* @type {import("../../coordinate").Coordinate}
*/
private renderedCenter_;
/**
* @private
* @type {import("../../proj/Projection").default}
*/
private renderedProjection_;
/**
* @private
* @type {function(import("../../Feature.js").default, import("../../Feature.js").default): number|null}
*/
private renderedRenderOrder_;
/**
* @private
* @type {import("../../render/canvas/ExecutorGroup").default}
*/
private replayGroup_;
/**
* A new replay group had to be created by `prepareFrame()`
* @type {boolean}
*/
replayGroupChanged: boolean;
/**
* Clipping to be performed by `renderFrame()`
* @type {boolean}
*/
clipping: boolean;
/**
* @private
* @type {CanvasRenderingContext2D}
*/
private compositionContext_;
/**
* @private
* @type {number}
*/
private opacity_;
/**
* @param {ExecutorGroup} executorGroup Executor group.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @param {import("rbush").default} [opt_declutterTree] Declutter tree.
*/
renderWorlds(executorGroup: ExecutorGroup, frameState: import("../../PluggableMap.js").FrameState, opt_declutterTree?: any): void;
setupCompositionContext_(): void;
releaseCompositionContext_(): void;
/**
* Render declutter items for this layer
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
*/
renderDeclutter(frameState: import("../../PluggableMap.js").FrameState): void;
/**
* Handle changes in image style state.
* @param {import("../../events/Event.js").default} event Image style change event.
* @private
*/
private handleStyleImageChange_;
/**
* @param {import("../../Feature.js").default} feature Feature.
* @param {number} squaredTolerance Squared render tolerance.
* @param {import("../../style/Style.js").default|Array<import("../../style/Style.js").default>} styles The style or array of styles.
* @param {import("../../render/canvas/BuilderGroup.js").default} builderGroup Builder group.
* @param {import("../../proj.js").TransformFunction} [opt_transform] Transform from user to view projection.
* @param {import("../../render/canvas/BuilderGroup.js").default} [opt_declutterBuilderGroup] Builder for decluttering.
* @return {boolean} `true` if an image is loading.
*/
renderFeature(feature: import("../../Feature.js").default, squaredTolerance: number, styles: import("../../style/Style.js").default | Array<import("../../style/Style.js").default>, builderGroup: import("../../render/canvas/BuilderGroup.js").default, opt_transform?: import("../../proj.js").TransformFunction | undefined, opt_declutterBuilderGroup?: CanvasBuilderGroup | undefined): boolean;
}
import CanvasLayerRenderer from "./Layer.js";
import ExecutorGroup from "../../render/canvas/ExecutorGroup.js";
import CanvasBuilderGroup from "../../render/canvas/BuilderGroup.js";
//# sourceMappingURL=VectorLayer.d.ts.map

1
node_modules/ol/renderer/canvas/VectorLayer.d.ts.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"VectorLayer.d.ts","sourceRoot":"","sources":["../../src/renderer/canvas/VectorLayer.js"],"names":[],"mappings":";AA4CA;;;;GAIG;AACH;IACE;;OAEG;IACH,gFAuGC;IApGC,eAAe;IACf,qCAA2E;IAE3E;;OAEG;IACH,yBAFU,OAAO,CAEW;IAE5B;;OAEG;IACH,wBAFU,SAAS,CAEe;IAElC;;OAEG;IACH,mBAFU,MAAM,OAAO,kBAAkB,EAAE,OAAO,CAAC,CAEtB;IAE7B;;;OAGG;IACH,0BAA2B;IAE3B;;;OAGG;IACH,4BAA8B;IAE9B;;;OAGG;IACH,wBAAoC;IAEpC;;;OAGG;IACH,+BAA2C;IAE3C;;;OAGG;IACH,0BAAsB;IAEtB;;;OAGG;IACH,wBAA2B;IAE3B;;;OAGG;IACH,4BAA+B;IAE/B;;;OAGG;IACH,6BAAgC;IAEhC;;;OAGG;IACH,qBAAwB;IAExB;;;OAGG;IACH,oBAFU,OAAO,CAEa;IAO9B;;;OAGG;IACH,UAFU,OAAO,CAEG;IAEpB;;;OAGG;IACH,4BAA+B;IAE/B;;;OAGG;IACH,iBAAiB;IAGnB;;;;OAIG;IACH,4BAJW,aAAa,cACb,OAAO,uBAAuB,EAAE,UAAU,iCAiDpD;IAED,iCAWC;IAED,mCAUC;IAED;;;OAGG;IACH,4BAFW,OAAO,uBAAuB,EAAE,UAAU,QAYpD;IAmRD;;;;OAIG;IACH,gCAEC;IA0ND;;;;;;;;OAQG;IACH,uBARW,OAAO,kBAAkB,EAAE,OAAO,oBAClC,MAAM,UACN,OAAO,sBAAsB,EAAE,OAAO,GAAC,MAAM,OAAO,sBAAsB,EAAE,OAAO,CAAC,gBACpF,OAAO,qCAAqC,EAAE,OAAO,sIAGpD,OAAO,CAuClB;CACF"}

573
node_modules/ol/renderer/canvas/VectorLayer.js generated vendored Normal file
View File

@@ -0,0 +1,573 @@
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
/**
* @module ol/renderer/canvas/VectorLayer
*/
import CanvasBuilderGroup from '../../render/canvas/BuilderGroup.js';
import CanvasLayerRenderer, { canvasPool } from './Layer.js';
import ExecutorGroup from '../../render/canvas/ExecutorGroup.js';
import ViewHint from '../../ViewHint.js';
import { HIT_DETECT_RESOLUTION, createHitDetectionImageData, hitDetect, } from '../../render/canvas/hitdetect.js';
import { apply, makeInverse, makeScale, toString as transformToString, } from '../../transform.js';
import { buffer, containsExtent, createEmpty, getWidth, intersects as intersectsExtent, wrapX as wrapExtentX, } from '../../extent.js';
import { createCanvasContext2D, releaseCanvas } from '../../dom.js';
import { defaultOrder as defaultRenderOrder, getTolerance as getRenderTolerance, getSquaredTolerance as getSquaredRenderTolerance, renderFeature, } from '../vector.js';
import { equals } from '../../array.js';
import { fromUserExtent, getTransformFromProjections, getUserProjection, toUserExtent, toUserResolution, } from '../../proj.js';
import { getUid } from '../../util.js';
import { wrapX as wrapCoordinateX } from '../../coordinate.js';
/**
* @classdesc
* Canvas renderer for vector layers.
* @api
*/
var CanvasVectorLayerRenderer = /** @class */ (function (_super) {
__extends(CanvasVectorLayerRenderer, _super);
/**
* @param {import("../../layer/BaseVector.js").default} vectorLayer Vector layer.
*/
function CanvasVectorLayerRenderer(vectorLayer) {
var _this = _super.call(this, vectorLayer) || this;
/** @private */
_this.boundHandleStyleImageChange_ = _this.handleStyleImageChange_.bind(_this);
/**
* @type {boolean}
*/
_this.animatingOrInteracting_;
/**
* @type {ImageData}
*/
_this.hitDetectionImageData_ = null;
/**
* @type {Array<import("../../Feature.js").default>}
*/
_this.renderedFeatures_ = null;
/**
* @private
* @type {number}
*/
_this.renderedRevision_ = -1;
/**
* @private
* @type {number}
*/
_this.renderedResolution_ = NaN;
/**
* @private
* @type {import("../../extent.js").Extent}
*/
_this.renderedExtent_ = createEmpty();
/**
* @private
* @type {import("../../extent.js").Extent}
*/
_this.wrappedRenderedExtent_ = createEmpty();
/**
* @private
* @type {number}
*/
_this.renderedRotation_;
/**
* @private
* @type {import("../../coordinate").Coordinate}
*/
_this.renderedCenter_ = null;
/**
* @private
* @type {import("../../proj/Projection").default}
*/
_this.renderedProjection_ = null;
/**
* @private
* @type {function(import("../../Feature.js").default, import("../../Feature.js").default): number|null}
*/
_this.renderedRenderOrder_ = null;
/**
* @private
* @type {import("../../render/canvas/ExecutorGroup").default}
*/
_this.replayGroup_ = null;
/**
* A new replay group had to be created by `prepareFrame()`
* @type {boolean}
*/
_this.replayGroupChanged = true;
/**
* @type {import("../../render/canvas/ExecutorGroup").default}
*/
_this.declutterExecutorGroup = null;
/**
* Clipping to be performed by `renderFrame()`
* @type {boolean}
*/
_this.clipping = true;
/**
* @private
* @type {CanvasRenderingContext2D}
*/
_this.compositionContext_ = null;
/**
* @private
* @type {number}
*/
_this.opacity_ = 1;
return _this;
}
/**
* @param {ExecutorGroup} executorGroup Executor group.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @param {import("rbush").default} [opt_declutterTree] Declutter tree.
*/
CanvasVectorLayerRenderer.prototype.renderWorlds = function (executorGroup, frameState, opt_declutterTree) {
var extent = frameState.extent;
var viewState = frameState.viewState;
var center = viewState.center;
var resolution = viewState.resolution;
var projection = viewState.projection;
var rotation = viewState.rotation;
var projectionExtent = projection.getExtent();
var vectorSource = this.getLayer().getSource();
var pixelRatio = frameState.pixelRatio;
var viewHints = frameState.viewHints;
var snapToPixel = !(viewHints[ViewHint.ANIMATING] || viewHints[ViewHint.INTERACTING]);
var context = this.compositionContext_;
var width = Math.round(frameState.size[0] * pixelRatio);
var height = Math.round(frameState.size[1] * pixelRatio);
var multiWorld = vectorSource.getWrapX() && projection.canWrapX();
var worldWidth = multiWorld ? getWidth(projectionExtent) : null;
var endWorld = multiWorld
? Math.ceil((extent[2] - projectionExtent[2]) / worldWidth) + 1
: 1;
var world = multiWorld
? Math.floor((extent[0] - projectionExtent[0]) / worldWidth)
: 0;
do {
var transform = this.getRenderTransform(center, resolution, rotation, pixelRatio, width, height, world * worldWidth);
executorGroup.execute(context, 1, transform, rotation, snapToPixel, undefined, opt_declutterTree);
} while (++world < endWorld);
};
CanvasVectorLayerRenderer.prototype.setupCompositionContext_ = function () {
if (this.opacity_ !== 1) {
var compositionContext = createCanvasContext2D(this.context.canvas.width, this.context.canvas.height, canvasPool);
this.compositionContext_ = compositionContext;
}
else {
this.compositionContext_ = this.context;
}
};
CanvasVectorLayerRenderer.prototype.releaseCompositionContext_ = function () {
if (this.opacity_ !== 1) {
var alpha = this.context.globalAlpha;
this.context.globalAlpha = this.opacity_;
this.context.drawImage(this.compositionContext_.canvas, 0, 0);
this.context.globalAlpha = alpha;
releaseCanvas(this.compositionContext_);
canvasPool.push(this.compositionContext_.canvas);
this.compositionContext_ = null;
}
};
/**
* Render declutter items for this layer
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
*/
CanvasVectorLayerRenderer.prototype.renderDeclutter = function (frameState) {
if (this.declutterExecutorGroup) {
this.setupCompositionContext_();
this.renderWorlds(this.declutterExecutorGroup, frameState, frameState.declutterTree);
this.releaseCompositionContext_();
}
};
/**
* Render the layer.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @param {HTMLElement} target Target that may be used to render content to.
* @return {HTMLElement} The rendered element.
*/
CanvasVectorLayerRenderer.prototype.renderFrame = function (frameState, target) {
var pixelRatio = frameState.pixelRatio;
var layerState = frameState.layerStatesArray[frameState.layerIndex];
// set forward and inverse pixel transforms
makeScale(this.pixelTransform, 1 / pixelRatio, 1 / pixelRatio);
makeInverse(this.inversePixelTransform, this.pixelTransform);
var canvasTransform = transformToString(this.pixelTransform);
this.useContainer(target, canvasTransform, this.getBackground(frameState));
var context = this.context;
var canvas = context.canvas;
var replayGroup = this.replayGroup_;
var declutterExecutorGroup = this.declutterExecutorGroup;
if ((!replayGroup || replayGroup.isEmpty()) &&
(!declutterExecutorGroup || declutterExecutorGroup.isEmpty())) {
return null;
}
// resize and clear
var width = Math.round(frameState.size[0] * pixelRatio);
var height = Math.round(frameState.size[1] * pixelRatio);
if (canvas.width != width || canvas.height != height) {
canvas.width = width;
canvas.height = height;
if (canvas.style.transform !== canvasTransform) {
canvas.style.transform = canvasTransform;
}
}
else if (!this.containerReused) {
context.clearRect(0, 0, width, height);
}
this.preRender(context, frameState);
var viewState = frameState.viewState;
var projection = viewState.projection;
this.opacity_ = layerState.opacity;
this.setupCompositionContext_();
// clipped rendering if layer extent is set
var clipped = false;
var render = true;
if (layerState.extent && this.clipping) {
var layerExtent = fromUserExtent(layerState.extent, projection);
render = intersectsExtent(layerExtent, frameState.extent);
clipped = render && !containsExtent(layerExtent, frameState.extent);
if (clipped) {
this.clipUnrotated(this.compositionContext_, frameState, layerExtent);
}
}
if (render) {
this.renderWorlds(replayGroup, frameState);
}
if (clipped) {
this.compositionContext_.restore();
}
this.releaseCompositionContext_();
this.postRender(context, frameState);
if (this.renderedRotation_ !== viewState.rotation) {
this.renderedRotation_ = viewState.rotation;
this.hitDetectionImageData_ = null;
}
return this.container;
};
/**
* Asynchronous layer level hit detection.
* @param {import("../../pixel.js").Pixel} pixel Pixel.
* @return {Promise<Array<import("../../Feature").default>>} Promise that resolves with an array of features.
*/
CanvasVectorLayerRenderer.prototype.getFeatures = function (pixel) {
return new Promise(
/**
* @param {function(Array<import("../../Feature").default|import("../../render/Feature").default>): void} resolve Resolver function.
* @this {CanvasVectorLayerRenderer}
*/
function (resolve) {
if (!this.hitDetectionImageData_ && !this.animatingOrInteracting_) {
var size = [this.context.canvas.width, this.context.canvas.height];
apply(this.pixelTransform, size);
var center = this.renderedCenter_;
var resolution = this.renderedResolution_;
var rotation = this.renderedRotation_;
var projection = this.renderedProjection_;
var extent = this.wrappedRenderedExtent_;
var layer = this.getLayer();
var transforms = [];
var width = size[0] * HIT_DETECT_RESOLUTION;
var height = size[1] * HIT_DETECT_RESOLUTION;
transforms.push(this.getRenderTransform(center, resolution, rotation, HIT_DETECT_RESOLUTION, width, height, 0).slice());
var source = layer.getSource();
var projectionExtent = projection.getExtent();
if (source.getWrapX() &&
projection.canWrapX() &&
!containsExtent(projectionExtent, extent)) {
var startX = extent[0];
var worldWidth = getWidth(projectionExtent);
var world = 0;
var offsetX = void 0;
while (startX < projectionExtent[0]) {
--world;
offsetX = worldWidth * world;
transforms.push(this.getRenderTransform(center, resolution, rotation, HIT_DETECT_RESOLUTION, width, height, offsetX).slice());
startX += worldWidth;
}
world = 0;
startX = extent[2];
while (startX > projectionExtent[2]) {
++world;
offsetX = worldWidth * world;
transforms.push(this.getRenderTransform(center, resolution, rotation, HIT_DETECT_RESOLUTION, width, height, offsetX).slice());
startX -= worldWidth;
}
}
this.hitDetectionImageData_ = createHitDetectionImageData(size, transforms, this.renderedFeatures_, layer.getStyleFunction(), extent, resolution, rotation);
}
resolve(hitDetect(pixel, this.renderedFeatures_, this.hitDetectionImageData_));
}.bind(this));
};
/**
* @param {import("../../coordinate.js").Coordinate} coordinate Coordinate.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @param {number} hitTolerance Hit tolerance in pixels.
* @param {import("../vector.js").FeatureCallback<T>} callback Feature callback.
* @param {Array<import("../Map.js").HitMatch<T>>} matches The hit detected matches with tolerance.
* @return {T|undefined} Callback result.
* @template T
*/
CanvasVectorLayerRenderer.prototype.forEachFeatureAtCoordinate = function (coordinate, frameState, hitTolerance, callback, matches) {
var _this = this;
if (!this.replayGroup_) {
return undefined;
}
var resolution = frameState.viewState.resolution;
var rotation = frameState.viewState.rotation;
var layer = this.getLayer();
/** @type {!Object<string, import("../Map.js").HitMatch<T>|true>} */
var features = {};
/**
* @param {import("../../Feature.js").FeatureLike} feature Feature.
* @param {import("../../geom/SimpleGeometry.js").default} geometry Geometry.
* @param {number} distanceSq The squared distance to the click position
* @return {T|undefined} Callback result.
*/
var featureCallback = function (feature, geometry, distanceSq) {
var key = getUid(feature);
var match = features[key];
if (!match) {
if (distanceSq === 0) {
features[key] = true;
return callback(feature, layer, geometry);
}
matches.push((features[key] = {
feature: feature,
layer: layer,
geometry: geometry,
distanceSq: distanceSq,
callback: callback,
}));
}
else if (match !== true && distanceSq < match.distanceSq) {
if (distanceSq === 0) {
features[key] = true;
matches.splice(matches.lastIndexOf(match), 1);
return callback(feature, layer, geometry);
}
match.geometry = geometry;
match.distanceSq = distanceSq;
}
return undefined;
};
var result;
var executorGroups = [this.replayGroup_];
if (this.declutterExecutorGroup) {
executorGroups.push(this.declutterExecutorGroup);
}
executorGroups.some(function (executorGroup) {
return (result = executorGroup.forEachFeatureAtCoordinate(coordinate, resolution, rotation, hitTolerance, featureCallback, executorGroup === _this.declutterExecutorGroup &&
frameState.declutterTree
? frameState.declutterTree.all().map(function (item) { return item.value; })
: null));
});
return result;
};
/**
* Perform action necessary to get the layer rendered after new fonts have loaded
*/
CanvasVectorLayerRenderer.prototype.handleFontsChanged = function () {
var layer = this.getLayer();
if (layer.getVisible() && this.replayGroup_) {
layer.changed();
}
};
/**
* Handle changes in image style state.
* @param {import("../../events/Event.js").default} event Image style change event.
* @private
*/
CanvasVectorLayerRenderer.prototype.handleStyleImageChange_ = function (event) {
this.renderIfReadyAndVisible();
};
/**
* Determine whether render should be called.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @return {boolean} Layer is ready to be rendered.
*/
CanvasVectorLayerRenderer.prototype.prepareFrame = function (frameState) {
var vectorLayer = this.getLayer();
var vectorSource = vectorLayer.getSource();
if (!vectorSource) {
return false;
}
var animating = frameState.viewHints[ViewHint.ANIMATING];
var interacting = frameState.viewHints[ViewHint.INTERACTING];
var updateWhileAnimating = vectorLayer.getUpdateWhileAnimating();
var updateWhileInteracting = vectorLayer.getUpdateWhileInteracting();
if ((this.ready && !updateWhileAnimating && animating) ||
(!updateWhileInteracting && interacting)) {
this.animatingOrInteracting_ = true;
return true;
}
this.animatingOrInteracting_ = false;
var frameStateExtent = frameState.extent;
var viewState = frameState.viewState;
var projection = viewState.projection;
var resolution = viewState.resolution;
var pixelRatio = frameState.pixelRatio;
var vectorLayerRevision = vectorLayer.getRevision();
var vectorLayerRenderBuffer = vectorLayer.getRenderBuffer();
var vectorLayerRenderOrder = vectorLayer.getRenderOrder();
if (vectorLayerRenderOrder === undefined) {
vectorLayerRenderOrder = defaultRenderOrder;
}
var center = viewState.center.slice();
var extent = buffer(frameStateExtent, vectorLayerRenderBuffer * resolution);
var renderedExtent = extent.slice();
var loadExtents = [extent.slice()];
var projectionExtent = projection.getExtent();
if (vectorSource.getWrapX() &&
projection.canWrapX() &&
!containsExtent(projectionExtent, frameState.extent)) {
// For the replay group, we need an extent that intersects the real world
// (-180° to +180°). To support geometries in a coordinate range from -540°
// to +540°, we add at least 1 world width on each side of the projection
// extent. If the viewport is wider than the world, we need to add half of
// the viewport width to make sure we cover the whole viewport.
var worldWidth = getWidth(projectionExtent);
var gutter = Math.max(getWidth(extent) / 2, worldWidth);
extent[0] = projectionExtent[0] - gutter;
extent[2] = projectionExtent[2] + gutter;
wrapCoordinateX(center, projection);
var loadExtent = wrapExtentX(loadExtents[0], projection);
// If the extent crosses the date line, we load data for both edges of the worlds
if (loadExtent[0] < projectionExtent[0] &&
loadExtent[2] < projectionExtent[2]) {
loadExtents.push([
loadExtent[0] + worldWidth,
loadExtent[1],
loadExtent[2] + worldWidth,
loadExtent[3],
]);
}
else if (loadExtent[0] > projectionExtent[0] &&
loadExtent[2] > projectionExtent[2]) {
loadExtents.push([
loadExtent[0] - worldWidth,
loadExtent[1],
loadExtent[2] - worldWidth,
loadExtent[3],
]);
}
}
if (this.ready &&
this.renderedResolution_ == resolution &&
this.renderedRevision_ == vectorLayerRevision &&
this.renderedRenderOrder_ == vectorLayerRenderOrder &&
containsExtent(this.wrappedRenderedExtent_, extent)) {
if (!equals(this.renderedExtent_, renderedExtent)) {
this.hitDetectionImageData_ = null;
this.renderedExtent_ = renderedExtent;
}
this.renderedCenter_ = center;
this.replayGroupChanged = false;
return true;
}
this.replayGroup_ = null;
var replayGroup = new CanvasBuilderGroup(getRenderTolerance(resolution, pixelRatio), extent, resolution, pixelRatio);
var declutterBuilderGroup;
if (this.getLayer().getDeclutter()) {
declutterBuilderGroup = new CanvasBuilderGroup(getRenderTolerance(resolution, pixelRatio), extent, resolution, pixelRatio);
}
var userProjection = getUserProjection();
var userTransform;
if (userProjection) {
for (var i = 0, ii = loadExtents.length; i < ii; ++i) {
var extent_1 = loadExtents[i];
var userExtent_1 = toUserExtent(extent_1, projection);
vectorSource.loadFeatures(userExtent_1, toUserResolution(resolution, projection), userProjection);
}
userTransform = getTransformFromProjections(userProjection, projection);
}
else {
for (var i = 0, ii = loadExtents.length; i < ii; ++i) {
vectorSource.loadFeatures(loadExtents[i], resolution, projection);
}
}
var squaredTolerance = getSquaredRenderTolerance(resolution, pixelRatio);
var ready = true;
var render =
/**
* @param {import("../../Feature.js").default} feature Feature.
* @this {CanvasVectorLayerRenderer}
*/
function (feature) {
var styles;
var styleFunction = feature.getStyleFunction() || vectorLayer.getStyleFunction();
if (styleFunction) {
styles = styleFunction(feature, resolution);
}
if (styles) {
var dirty = this.renderFeature(feature, squaredTolerance, styles, replayGroup, userTransform, declutterBuilderGroup);
ready = ready && !dirty;
}
}.bind(this);
var userExtent = toUserExtent(extent, projection);
/** @type {Array<import("../../Feature.js").default>} */
var features = vectorSource.getFeaturesInExtent(userExtent);
if (vectorLayerRenderOrder) {
features.sort(vectorLayerRenderOrder);
}
for (var i = 0, ii = features.length; i < ii; ++i) {
render(features[i]);
}
this.renderedFeatures_ = features;
this.ready = ready;
var replayGroupInstructions = replayGroup.finish();
var executorGroup = new ExecutorGroup(extent, resolution, pixelRatio, vectorSource.getOverlaps(), replayGroupInstructions, vectorLayer.getRenderBuffer());
if (declutterBuilderGroup) {
this.declutterExecutorGroup = new ExecutorGroup(extent, resolution, pixelRatio, vectorSource.getOverlaps(), declutterBuilderGroup.finish(), vectorLayer.getRenderBuffer());
}
this.renderedResolution_ = resolution;
this.renderedRevision_ = vectorLayerRevision;
this.renderedRenderOrder_ = vectorLayerRenderOrder;
this.renderedExtent_ = renderedExtent;
this.wrappedRenderedExtent_ = extent;
this.renderedCenter_ = center;
this.renderedProjection_ = projection;
this.replayGroup_ = executorGroup;
this.hitDetectionImageData_ = null;
this.replayGroupChanged = true;
return true;
};
/**
* @param {import("../../Feature.js").default} feature Feature.
* @param {number} squaredTolerance Squared render tolerance.
* @param {import("../../style/Style.js").default|Array<import("../../style/Style.js").default>} styles The style or array of styles.
* @param {import("../../render/canvas/BuilderGroup.js").default} builderGroup Builder group.
* @param {import("../../proj.js").TransformFunction} [opt_transform] Transform from user to view projection.
* @param {import("../../render/canvas/BuilderGroup.js").default} [opt_declutterBuilderGroup] Builder for decluttering.
* @return {boolean} `true` if an image is loading.
*/
CanvasVectorLayerRenderer.prototype.renderFeature = function (feature, squaredTolerance, styles, builderGroup, opt_transform, opt_declutterBuilderGroup) {
if (!styles) {
return false;
}
var loading = false;
if (Array.isArray(styles)) {
for (var i = 0, ii = styles.length; i < ii; ++i) {
loading =
renderFeature(builderGroup, feature, styles[i], squaredTolerance, this.boundHandleStyleImageChange_, opt_transform, opt_declutterBuilderGroup) || loading;
}
}
else {
loading = renderFeature(builderGroup, feature, styles, squaredTolerance, this.boundHandleStyleImageChange_, opt_transform, opt_declutterBuilderGroup);
}
return loading;
};
return CanvasVectorLayerRenderer;
}(CanvasLayerRenderer));
export default CanvasVectorLayerRenderer;
//# sourceMappingURL=VectorLayer.js.map

1
node_modules/ol/renderer/canvas/VectorLayer.js.map generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

95
node_modules/ol/renderer/canvas/VectorTileLayer.d.ts generated vendored Normal file
View File

@@ -0,0 +1,95 @@
export default CanvasVectorTileLayerRenderer;
/**
* @classdesc
* Canvas renderer for vector tile layers.
* @api
* @extends {CanvasTileLayerRenderer<import("../../layer/VectorTile.js").default>}
*/
declare class CanvasVectorTileLayerRenderer extends CanvasTileLayerRenderer<import("../../layer/VectorTile.js").default> {
/**
* @param {import("../../layer/VectorTile.js").default} layer VectorTile layer.
*/
constructor(layer: import("../../layer/VectorTile.js").default);
/** @private */
private boundHandleStyleImageChange_;
/**
* @private
* @type {number}
*/
private renderedLayerRevision_;
/**
* @private
* @type {import("../../transform").Transform}
*/
private renderedPixelToCoordinateTransform_;
/**
* @private
* @type {number}
*/
private renderedRotation_;
/**
* @private
* @type {import("../../transform.js").Transform}
*/
private tmpTransform_;
/**
* @param {import("../../VectorRenderTile.js").default} tile Tile.
* @param {number} pixelRatio Pixel ratio.
* @param {import("../../proj/Projection").default} projection Projection.
* @return {boolean|undefined} Tile needs to be rendered.
*/
prepareTile(tile: import("../../VectorRenderTile.js").default, pixelRatio: number, projection: import("../../proj/Projection").default): boolean | undefined;
/**
* @param {import("../../VectorRenderTile.js").default} tile Tile.
* @return {boolean} Tile is drawable.
*/
isDrawableTile(tile: import("../../VectorRenderTile.js").default): boolean;
/**
* @inheritDoc
*/
getTileImage(tile: any): any;
/**
* @param {import("../../VectorRenderTile.js").default} tile Tile.
* @param {number} pixelRatio Pixel ratio.
* @param {import("../../proj/Projection.js").default} projection Projection.
* @private
*/
private updateExecutorGroup_;
/**
* Handle changes in image style state.
* @param {import("../../events/Event.js").default} event Image style change event.
* @private
*/
private handleStyleImageChange_;
/**
* Render declutter items for this layer
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
*/
renderDeclutter(frameState: import("../../PluggableMap.js").FrameState): void;
getTileRenderTransform(tile: any, frameState: any): number[];
ready: any;
/**
* @param {import("../../Feature.js").FeatureLike} feature Feature.
* @param {number} squaredTolerance Squared tolerance.
* @param {import("../../style/Style.js").default|Array<import("../../style/Style.js").default>} styles The style or array of styles.
* @param {import("../../render/canvas/BuilderGroup.js").default} builderGroup Replay group.
* @param {import("../../render/canvas/BuilderGroup.js").default} [opt_declutterBuilderGroup] Builder group for decluttering.
* @return {boolean} `true` if an image is loading.
*/
renderFeature(feature: import("../../Feature.js").FeatureLike, squaredTolerance: number, styles: import("../../style/Style.js").default | Array<import("../../style/Style.js").default>, builderGroup: import("../../render/canvas/BuilderGroup.js").default, opt_declutterBuilderGroup?: CanvasBuilderGroup | undefined): boolean;
/**
* @param {import("../../VectorRenderTile.js").default} tile Tile.
* @return {boolean} A new tile image was rendered.
* @private
*/
private tileImageNeedsRender_;
/**
* @param {import("../../VectorRenderTile.js").default} tile Tile.
* @param {import("../../PluggableMap").FrameState} frameState Frame state.
* @private
*/
private renderTileImage_;
}
import CanvasTileLayerRenderer from "./TileLayer.js";
import CanvasBuilderGroup from "../../render/canvas/BuilderGroup.js";
//# sourceMappingURL=VectorTileLayer.d.ts.map

1
node_modules/ol/renderer/canvas/VectorTileLayer.d.ts.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"VectorTileLayer.d.ts","sourceRoot":"","sources":["../../src/renderer/canvas/VectorTileLayer.js"],"names":[],"mappings":";AAyDA;;;;;GAKG;AACH;IACE;;OAEG;IACH,mBAFW,OAAO,2BAA2B,EAAE,OAAO,EA+BrD;IA1BC,eAAe;IACf,qCAA2E;IAE3E;;;OAGG;IACH,+BAA2B;IAE3B;;;OAGG;IACH,4CAA+C;IAE/C;;;OAGG;IACH,0BAAsB;IAEtB;;;OAGG;IACH,sBAAsC;IAGxC;;;;;OAKG;IACH,kBALW,OAAO,2BAA2B,EAAE,OAAO,cAC3C,MAAM,cACN,OAAO,uBAAuB,EAAE,OAAO,GACtC,OAAO,GAAC,SAAS,CAY5B;IAkCD;;;OAGG;IACH,qBAHW,OAAO,2BAA2B,EAAE,OAAO,GAC1C,OAAO,CAUlB;IAED;;OAEG;IACH,6BAEC;IAgBD;;;;;OAKG;IACH,6BAmIC;IA4ND;;;;OAIG;IACH,gCAEC;IAED;;;OAGG;IACH,4BAFW,OAAO,uBAAuB,EAAE,UAAU,QAiCpD;IAED,6DA+BC;IA6GC,WAAkB;IAKpB;;;;;;;OAOG;IACH,uBAPW,OAAO,kBAAkB,EAAE,WAAW,oBACtC,MAAM,UACN,OAAO,sBAAsB,EAAE,OAAO,GAAC,MAAM,OAAO,sBAAsB,EAAE,OAAO,CAAC,gBACpF,OAAO,qCAAqC,EAAE,OAAO,+DAEpD,OAAO,CAsClB;IAED;;;;OAIG;IACH,8BAcC;IAED;;;;OAIG;IACH,yBAoDC;CACF"}

632
node_modules/ol/renderer/canvas/VectorTileLayer.js generated vendored Normal file
View File

@@ -0,0 +1,632 @@
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
/**
* @module ol/renderer/canvas/VectorTileLayer
*/
import CanvasBuilderGroup from '../../render/canvas/BuilderGroup.js';
import CanvasExecutorGroup from '../../render/canvas/ExecutorGroup.js';
import CanvasTileLayerRenderer from './TileLayer.js';
import TileState from '../../TileState.js';
import VectorTileRenderType from '../../layer/VectorTileRenderType.js';
import ViewHint from '../../ViewHint.js';
import { HIT_DETECT_RESOLUTION, createHitDetectionImageData, hitDetect, } from '../../render/canvas/hitdetect.js';
import { apply as applyTransform, create as createTransform, multiply, reset as resetTransform, scale, scale as scaleTransform, translate as translateTransform, } from '../../transform.js';
import { boundingExtent, buffer, containsExtent, equals, getIntersection, getTopLeft, intersects, } from '../../extent.js';
import { getSquaredTolerance as getSquaredRenderTolerance, renderFeature, } from '../vector.js';
import { getUid } from '../../util.js';
import { toSize } from '../../size.js';
import { wrapX } from '../../coordinate.js';
/**
* @type {!Object<string, Array<import("../../render/canvas.js").BuilderType>>}
*/
var IMAGE_REPLAYS = {
'image': ['Polygon', 'Circle', 'LineString', 'Image', 'Text'],
'hybrid': ['Polygon', 'LineString'],
'vector': [],
};
/**
* @type {!Object<string, Array<import("../../render/canvas.js").BuilderType>>}
*/
var VECTOR_REPLAYS = {
'hybrid': ['Image', 'Text', 'Default'],
'vector': ['Polygon', 'Circle', 'LineString', 'Image', 'Text', 'Default'],
};
/**
* @classdesc
* Canvas renderer for vector tile layers.
* @api
* @extends {CanvasTileLayerRenderer<import("../../layer/VectorTile.js").default>}
*/
var CanvasVectorTileLayerRenderer = /** @class */ (function (_super) {
__extends(CanvasVectorTileLayerRenderer, _super);
/**
* @param {import("../../layer/VectorTile.js").default} layer VectorTile layer.
*/
function CanvasVectorTileLayerRenderer(layer) {
var _this = _super.call(this, layer) || this;
/** @private */
_this.boundHandleStyleImageChange_ = _this.handleStyleImageChange_.bind(_this);
/**
* @private
* @type {number}
*/
_this.renderedLayerRevision_;
/**
* @private
* @type {import("../../transform").Transform}
*/
_this.renderedPixelToCoordinateTransform_ = null;
/**
* @private
* @type {number}
*/
_this.renderedRotation_;
/**
* @private
* @type {import("../../transform.js").Transform}
*/
_this.tmpTransform_ = createTransform();
return _this;
}
/**
* @param {import("../../VectorRenderTile.js").default} tile Tile.
* @param {number} pixelRatio Pixel ratio.
* @param {import("../../proj/Projection").default} projection Projection.
* @return {boolean|undefined} Tile needs to be rendered.
*/
CanvasVectorTileLayerRenderer.prototype.prepareTile = function (tile, pixelRatio, projection) {
var render;
var state = tile.getState();
if (state === TileState.LOADED || state === TileState.ERROR) {
this.updateExecutorGroup_(tile, pixelRatio, projection);
if (this.tileImageNeedsRender_(tile)) {
render = true;
}
}
return render;
};
/**
* @param {number} z Tile coordinate z.
* @param {number} x Tile coordinate x.
* @param {number} y Tile coordinate y.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @return {!import("../../Tile.js").default} Tile.
*/
CanvasVectorTileLayerRenderer.prototype.getTile = function (z, x, y, frameState) {
var pixelRatio = frameState.pixelRatio;
var viewState = frameState.viewState;
var resolution = viewState.resolution;
var projection = viewState.projection;
var layer = this.getLayer();
var tile = layer.getSource().getTile(z, x, y, pixelRatio, projection);
var viewHints = frameState.viewHints;
var hifi = !(viewHints[ViewHint.ANIMATING] || viewHints[ViewHint.INTERACTING]);
if (hifi || !tile.wantedResolution) {
tile.wantedResolution = resolution;
}
var render = this.prepareTile(tile, pixelRatio, projection);
if (render &&
(hifi || Date.now() - frameState.time < 8) &&
layer.getRenderMode() !== VectorTileRenderType.VECTOR) {
this.renderTileImage_(tile, frameState);
}
return _super.prototype.getTile.call(this, z, x, y, frameState);
};
/**
* @param {import("../../VectorRenderTile.js").default} tile Tile.
* @return {boolean} Tile is drawable.
*/
CanvasVectorTileLayerRenderer.prototype.isDrawableTile = function (tile) {
var layer = this.getLayer();
return (_super.prototype.isDrawableTile.call(this, tile) &&
(layer.getRenderMode() === VectorTileRenderType.VECTOR
? getUid(layer) in tile.executorGroups
: tile.hasContext(layer)));
};
/**
* @inheritDoc
*/
CanvasVectorTileLayerRenderer.prototype.getTileImage = function (tile) {
return tile.getImage(this.getLayer());
};
/**
* Determine whether render should be called.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @return {boolean} Layer is ready to be rendered.
*/
CanvasVectorTileLayerRenderer.prototype.prepareFrame = function (frameState) {
var layerRevision = this.getLayer().getRevision();
if (this.renderedLayerRevision_ !== layerRevision) {
this.renderedLayerRevision_ = layerRevision;
this.renderedTiles.length = 0;
}
return _super.prototype.prepareFrame.call(this, frameState);
};
/**
* @param {import("../../VectorRenderTile.js").default} tile Tile.
* @param {number} pixelRatio Pixel ratio.
* @param {import("../../proj/Projection.js").default} projection Projection.
* @private
*/
CanvasVectorTileLayerRenderer.prototype.updateExecutorGroup_ = function (tile, pixelRatio, projection) {
var layer = /** @type {import("../../layer/VectorTile.js").default} */ (this.getLayer());
var revision = layer.getRevision();
var renderOrder = layer.getRenderOrder() || null;
var resolution = tile.wantedResolution;
var builderState = tile.getReplayState(layer);
if (!builderState.dirty &&
builderState.renderedResolution === resolution &&
builderState.renderedRevision == revision &&
builderState.renderedRenderOrder == renderOrder) {
return;
}
var source = layer.getSource();
var declutter = layer.getDeclutter();
var sourceTileGrid = source.getTileGrid();
var tileGrid = source.getTileGridForProjection(projection);
var tileExtent = tileGrid.getTileCoordExtent(tile.wrappedTileCoord);
var sourceTiles = source.getSourceTiles(pixelRatio, projection, tile);
var layerUid = getUid(layer);
delete tile.hitDetectionImageData[layerUid];
tile.executorGroups[layerUid] = [];
if (declutter) {
tile.declutterExecutorGroups[layerUid] = [];
}
builderState.dirty = false;
var _loop_1 = function (t, tt) {
var sourceTile = sourceTiles[t];
if (sourceTile.getState() != TileState.LOADED) {
return "continue";
}
var sourceTileCoord = sourceTile.tileCoord;
var sourceTileExtent = sourceTileGrid.getTileCoordExtent(sourceTileCoord);
var sharedExtent = getIntersection(tileExtent, sourceTileExtent);
var builderExtent = buffer(sharedExtent, layer.getRenderBuffer() * resolution, this_1.tmpExtent);
var bufferedExtent = equals(sourceTileExtent, sharedExtent)
? null
: builderExtent;
var builderGroup = new CanvasBuilderGroup(0, builderExtent, resolution, pixelRatio);
var declutterBuilderGroup = declutter
? new CanvasBuilderGroup(0, sharedExtent, resolution, pixelRatio)
: undefined;
var squaredTolerance = getSquaredRenderTolerance(resolution, pixelRatio);
/**
* @param {import("../../Feature.js").FeatureLike} feature Feature.
* @this {CanvasVectorTileLayerRenderer}
*/
var render = function (feature) {
var styles;
var styleFunction = feature.getStyleFunction() || layer.getStyleFunction();
if (styleFunction) {
styles = styleFunction(feature, resolution);
}
if (styles) {
var dirty = this.renderFeature(feature, squaredTolerance, styles, builderGroup, declutterBuilderGroup);
builderState.dirty = builderState.dirty || dirty;
}
};
var features = sourceTile.getFeatures();
if (renderOrder && renderOrder !== builderState.renderedRenderOrder) {
features.sort(renderOrder);
}
for (var i = 0, ii = features.length; i < ii; ++i) {
var feature = features[i];
if (!bufferedExtent ||
intersects(bufferedExtent, feature.getGeometry().getExtent())) {
render.call(this_1, feature);
}
}
var executorGroupInstructions = builderGroup.finish();
// no need to clip when the render tile is covered by a single source tile
var replayExtent = layer.getRenderMode() !== VectorTileRenderType.VECTOR &&
declutter &&
sourceTiles.length === 1
? null
: sharedExtent;
var renderingReplayGroup = new CanvasExecutorGroup(replayExtent, resolution, pixelRatio, source.getOverlaps(), executorGroupInstructions, layer.getRenderBuffer());
tile.executorGroups[layerUid].push(renderingReplayGroup);
if (declutterBuilderGroup) {
var declutterExecutorGroup = new CanvasExecutorGroup(null, resolution, pixelRatio, source.getOverlaps(), declutterBuilderGroup.finish(), layer.getRenderBuffer());
tile.declutterExecutorGroups[layerUid].push(declutterExecutorGroup);
}
};
var this_1 = this;
for (var t = 0, tt = sourceTiles.length; t < tt; ++t) {
_loop_1(t, tt);
}
builderState.renderedRevision = revision;
builderState.renderedRenderOrder = renderOrder;
builderState.renderedResolution = resolution;
};
/**
* @param {import("../../coordinate.js").Coordinate} coordinate Coordinate.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @param {number} hitTolerance Hit tolerance in pixels.
* @param {import("../vector.js").FeatureCallback<T>} callback Feature callback.
* @param {Array<import("../Map.js").HitMatch<T>>} matches The hit detected matches with tolerance.
* @return {T|undefined} Callback result.
* @template T
*/
CanvasVectorTileLayerRenderer.prototype.forEachFeatureAtCoordinate = function (coordinate, frameState, hitTolerance, callback, matches) {
var resolution = frameState.viewState.resolution;
var rotation = frameState.viewState.rotation;
hitTolerance = hitTolerance == undefined ? 0 : hitTolerance;
var layer = this.getLayer();
var source = layer.getSource();
var tileGrid = source.getTileGridForProjection(frameState.viewState.projection);
var hitExtent = boundingExtent([coordinate]);
buffer(hitExtent, resolution * hitTolerance, hitExtent);
/** @type {!Object<string, import("../Map.js").HitMatch<T>|true>} */
var features = {};
/**
* @param {import("../../Feature.js").FeatureLike} feature Feature.
* @param {import("../../geom/SimpleGeometry.js").default} geometry Geometry.
* @param {number} distanceSq The squared distance to the click position.
* @return {T|undefined} Callback result.
*/
var featureCallback = function (feature, geometry, distanceSq) {
var key = feature.getId();
if (key === undefined) {
key = getUid(feature);
}
var match = features[key];
if (!match) {
if (distanceSq === 0) {
features[key] = true;
return callback(feature, layer, geometry);
}
matches.push((features[key] = {
feature: feature,
layer: layer,
geometry: geometry,
distanceSq: distanceSq,
callback: callback,
}));
}
else if (match !== true && distanceSq < match.distanceSq) {
if (distanceSq === 0) {
features[key] = true;
matches.splice(matches.lastIndexOf(match), 1);
return callback(feature, layer, geometry);
}
match.geometry = geometry;
match.distanceSq = distanceSq;
}
return undefined;
};
var renderedTiles =
/** @type {Array<import("../../VectorRenderTile.js").default>} */ (this.renderedTiles);
var found;
var _loop_2 = function (i, ii) {
var tile = renderedTiles[i];
var tileExtent = tileGrid.getTileCoordExtent(tile.wrappedTileCoord);
if (!intersects(tileExtent, hitExtent)) {
return "continue";
}
var layerUid = getUid(layer);
var executorGroups = [tile.executorGroups[layerUid]];
var declutterExecutorGroups = tile.declutterExecutorGroups[layerUid];
if (declutterExecutorGroups) {
executorGroups.push(declutterExecutorGroups);
}
executorGroups.some(function (executorGroups) {
var declutteredFeatures = executorGroups === declutterExecutorGroups
? frameState.declutterTree.all().map(function (item) { return item.value; })
: null;
for (var t = 0, tt = executorGroups.length; t < tt; ++t) {
var executorGroup = executorGroups[t];
found = executorGroup.forEachFeatureAtCoordinate(coordinate, resolution, rotation, hitTolerance, featureCallback, declutteredFeatures);
if (found) {
return true;
}
}
});
};
for (var i = 0, ii = renderedTiles.length; !found && i < ii; ++i) {
_loop_2(i, ii);
}
return found;
};
/**
* Asynchronous layer level hit detection.
* @param {import("../../pixel.js").Pixel} pixel Pixel.
* @return {Promise<Array<import("../../Feature").default>>} Promise that resolves with an array of features.
*/
CanvasVectorTileLayerRenderer.prototype.getFeatures = function (pixel) {
return new Promise(function (resolve, reject) {
var layer =
/** @type {import("../../layer/VectorTile.js").default} */ (this.getLayer());
var layerUid = getUid(layer);
var source = layer.getSource();
var projection = this.renderedProjection;
var projectionExtent = projection.getExtent();
var resolution = this.renderedResolution;
var tileGrid = source.getTileGridForProjection(projection);
var coordinate = applyTransform(this.renderedPixelToCoordinateTransform_, pixel.slice());
var tileCoord = tileGrid.getTileCoordForCoordAndResolution(coordinate, resolution);
var tile;
for (var i = 0, ii = this.renderedTiles.length; i < ii; ++i) {
if (tileCoord.toString() === this.renderedTiles[i].tileCoord.toString()) {
tile = this.renderedTiles[i];
if (tile.getState() === TileState.LOADED) {
var extent_1 = tileGrid.getTileCoordExtent(tile.tileCoord);
if (source.getWrapX() &&
projection.canWrapX() &&
!containsExtent(projectionExtent, extent_1)) {
wrapX(coordinate, projection);
}
break;
}
tile = undefined;
}
}
if (!tile || tile.loadingSourceTiles > 0) {
resolve([]);
return;
}
var extent = tileGrid.getTileCoordExtent(tile.wrappedTileCoord);
var corner = getTopLeft(extent);
var tilePixel = [
(coordinate[0] - corner[0]) / resolution,
(corner[1] - coordinate[1]) / resolution,
];
var features = tile
.getSourceTiles()
.reduce(function (accumulator, sourceTile) {
return accumulator.concat(sourceTile.getFeatures());
}, []);
var hitDetectionImageData = tile.hitDetectionImageData[layerUid];
if (!hitDetectionImageData && !this.animatingOrInteracting_) {
var tileSize = toSize(tileGrid.getTileSize(tileGrid.getZForResolution(resolution, source.zDirection)));
var rotation = this.renderedRotation_;
var transforms = [
this.getRenderTransform(tileGrid.getTileCoordCenter(tile.wrappedTileCoord), resolution, 0, HIT_DETECT_RESOLUTION, tileSize[0] * HIT_DETECT_RESOLUTION, tileSize[1] * HIT_DETECT_RESOLUTION, 0),
];
hitDetectionImageData = createHitDetectionImageData(tileSize, transforms, features, layer.getStyleFunction(), tileGrid.getTileCoordExtent(tile.wrappedTileCoord), tile.getReplayState(layer).renderedResolution, rotation);
tile.hitDetectionImageData[layerUid] = hitDetectionImageData;
}
resolve(hitDetect(tilePixel, features, hitDetectionImageData));
}.bind(this));
};
/**
* Perform action necessary to get the layer rendered after new fonts have loaded
*/
CanvasVectorTileLayerRenderer.prototype.handleFontsChanged = function () {
var layer = this.getLayer();
if (layer.getVisible() && this.renderedLayerRevision_ !== undefined) {
layer.changed();
}
};
/**
* Handle changes in image style state.
* @param {import("../../events/Event.js").default} event Image style change event.
* @private
*/
CanvasVectorTileLayerRenderer.prototype.handleStyleImageChange_ = function (event) {
this.renderIfReadyAndVisible();
};
/**
* Render declutter items for this layer
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
*/
CanvasVectorTileLayerRenderer.prototype.renderDeclutter = function (frameState) {
var context = this.context;
var alpha = context.globalAlpha;
context.globalAlpha = this.getLayer().getOpacity();
var viewHints = frameState.viewHints;
var hifi = !(viewHints[ViewHint.ANIMATING] || viewHints[ViewHint.INTERACTING]);
var tiles =
/** @type {Array<import("../../VectorRenderTile.js").default>} */ (this.renderedTiles);
for (var i = 0, ii = tiles.length; i < ii; ++i) {
var tile = tiles[i];
var declutterExecutorGroups = tile.declutterExecutorGroups[getUid(this.getLayer())];
if (declutterExecutorGroups) {
for (var j = declutterExecutorGroups.length - 1; j >= 0; --j) {
declutterExecutorGroups[j].execute(this.context, 1, this.getTileRenderTransform(tile, frameState), frameState.viewState.rotation, hifi, undefined, frameState.declutterTree);
}
}
}
context.globalAlpha = alpha;
};
CanvasVectorTileLayerRenderer.prototype.getTileRenderTransform = function (tile, frameState) {
var pixelRatio = frameState.pixelRatio;
var viewState = frameState.viewState;
var center = viewState.center;
var resolution = viewState.resolution;
var rotation = viewState.rotation;
var size = frameState.size;
var width = Math.round(size[0] * pixelRatio);
var height = Math.round(size[1] * pixelRatio);
var source = this.getLayer().getSource();
var tileGrid = source.getTileGridForProjection(frameState.viewState.projection);
var tileCoord = tile.tileCoord;
var tileExtent = tileGrid.getTileCoordExtent(tile.wrappedTileCoord);
var worldOffset = tileGrid.getTileCoordExtent(tileCoord, this.tmpExtent)[0] - tileExtent[0];
var transform = multiply(scale(this.inversePixelTransform.slice(), 1 / pixelRatio, 1 / pixelRatio), this.getRenderTransform(center, resolution, rotation, pixelRatio, width, height, worldOffset));
return transform;
};
/**
* Render the layer.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @param {HTMLElement} target Target that may be used to render content to.
* @return {HTMLElement} The rendered element.
*/
CanvasVectorTileLayerRenderer.prototype.renderFrame = function (frameState, target) {
var viewHints = frameState.viewHints;
var hifi = !(viewHints[ViewHint.ANIMATING] || viewHints[ViewHint.INTERACTING]);
_super.prototype.renderFrame.call(this, frameState, target);
this.renderedPixelToCoordinateTransform_ =
frameState.pixelToCoordinateTransform.slice();
this.renderedRotation_ = frameState.viewState.rotation;
var layer = /** @type {import("../../layer/VectorTile.js").default} */ (this.getLayer());
var renderMode = layer.getRenderMode();
var context = this.context;
var alpha = context.globalAlpha;
context.globalAlpha = layer.getOpacity();
var replayTypes = VECTOR_REPLAYS[renderMode];
var viewState = frameState.viewState;
var rotation = viewState.rotation;
var tileSource = layer.getSource();
var tileGrid = tileSource.getTileGridForProjection(viewState.projection);
var z = tileGrid.getZForResolution(viewState.resolution, tileSource.zDirection);
var tiles = this.renderedTiles;
var clips = [];
var clipZs = [];
var ready = true;
for (var i = tiles.length - 1; i >= 0; --i) {
var tile = /** @type {import("../../VectorRenderTile.js").default} */ (tiles[i]);
ready = ready && !tile.getReplayState(layer).dirty;
var executorGroups = tile.executorGroups[getUid(layer)].filter(function (group) { return group.hasExecutors(replayTypes); });
if (executorGroups.length === 0) {
continue;
}
var transform = this.getTileRenderTransform(tile, frameState);
var currentZ = tile.tileCoord[0];
var contextSaved = false;
// Clip mask for regions in this tile that already filled by a higher z tile
var currentClip = executorGroups[0].getClipCoords(transform);
if (currentClip) {
for (var j = 0, jj = clips.length; j < jj; ++j) {
if (z !== currentZ && currentZ < clipZs[j]) {
var clip = clips[j];
if (intersects([
currentClip[0],
currentClip[3],
currentClip[4],
currentClip[7],
], [clip[0], clip[3], clip[4], clip[7]])) {
if (!contextSaved) {
context.save();
contextSaved = true;
}
context.beginPath();
// counter-clockwise (outer ring) for current tile
context.moveTo(currentClip[0], currentClip[1]);
context.lineTo(currentClip[2], currentClip[3]);
context.lineTo(currentClip[4], currentClip[5]);
context.lineTo(currentClip[6], currentClip[7]);
// clockwise (inner ring) for higher z tile
context.moveTo(clip[6], clip[7]);
context.lineTo(clip[4], clip[5]);
context.lineTo(clip[2], clip[3]);
context.lineTo(clip[0], clip[1]);
context.clip();
}
}
}
clips.push(currentClip);
clipZs.push(currentZ);
}
for (var t = 0, tt = executorGroups.length; t < tt; ++t) {
var executorGroup = executorGroups[t];
executorGroup.execute(context, 1, transform, rotation, hifi, replayTypes);
}
if (contextSaved) {
context.restore();
}
}
context.globalAlpha = alpha;
this.ready = ready;
return this.container;
};
/**
* @param {import("../../Feature.js").FeatureLike} feature Feature.
* @param {number} squaredTolerance Squared tolerance.
* @param {import("../../style/Style.js").default|Array<import("../../style/Style.js").default>} styles The style or array of styles.
* @param {import("../../render/canvas/BuilderGroup.js").default} builderGroup Replay group.
* @param {import("../../render/canvas/BuilderGroup.js").default} [opt_declutterBuilderGroup] Builder group for decluttering.
* @return {boolean} `true` if an image is loading.
*/
CanvasVectorTileLayerRenderer.prototype.renderFeature = function (feature, squaredTolerance, styles, builderGroup, opt_declutterBuilderGroup) {
if (!styles) {
return false;
}
var loading = false;
if (Array.isArray(styles)) {
for (var i = 0, ii = styles.length; i < ii; ++i) {
loading =
renderFeature(builderGroup, feature, styles[i], squaredTolerance, this.boundHandleStyleImageChange_, undefined, opt_declutterBuilderGroup) || loading;
}
}
else {
loading = renderFeature(builderGroup, feature, styles, squaredTolerance, this.boundHandleStyleImageChange_, undefined, opt_declutterBuilderGroup);
}
return loading;
};
/**
* @param {import("../../VectorRenderTile.js").default} tile Tile.
* @return {boolean} A new tile image was rendered.
* @private
*/
CanvasVectorTileLayerRenderer.prototype.tileImageNeedsRender_ = function (tile) {
var layer = /** @type {import("../../layer/VectorTile.js").default} */ (this.getLayer());
if (layer.getRenderMode() === VectorTileRenderType.VECTOR) {
return false;
}
var replayState = tile.getReplayState(layer);
var revision = layer.getRevision();
var resolution = tile.wantedResolution;
return (replayState.renderedTileResolution !== resolution ||
replayState.renderedTileRevision !== revision);
};
/**
* @param {import("../../VectorRenderTile.js").default} tile Tile.
* @param {import("../../PluggableMap").FrameState} frameState Frame state.
* @private
*/
CanvasVectorTileLayerRenderer.prototype.renderTileImage_ = function (tile, frameState) {
var layer = /** @type {import("../../layer/VectorTile.js").default} */ (this.getLayer());
var replayState = tile.getReplayState(layer);
var revision = layer.getRevision();
var executorGroups = tile.executorGroups[getUid(layer)];
replayState.renderedTileRevision = revision;
var tileCoord = tile.wrappedTileCoord;
var z = tileCoord[0];
var source = layer.getSource();
var pixelRatio = frameState.pixelRatio;
var viewState = frameState.viewState;
var projection = viewState.projection;
var tileGrid = source.getTileGridForProjection(projection);
var tileResolution = tileGrid.getResolution(tile.tileCoord[0]);
var renderPixelRatio = (frameState.pixelRatio / tile.wantedResolution) * tileResolution;
var resolution = tileGrid.getResolution(z);
var context = tile.getContext(layer);
// Increase tile size when overzooming for low pixel ratio, to avoid blurry tiles
pixelRatio = Math.round(Math.max(pixelRatio, renderPixelRatio / pixelRatio));
var size = source.getTilePixelSize(z, pixelRatio, projection);
context.canvas.width = size[0];
context.canvas.height = size[1];
var renderScale = pixelRatio / renderPixelRatio;
if (renderScale !== 1) {
var canvasTransform = resetTransform(this.tmpTransform_);
scaleTransform(canvasTransform, renderScale, renderScale);
context.setTransform.apply(context, canvasTransform);
}
var tileExtent = tileGrid.getTileCoordExtent(tileCoord, this.tmpExtent);
var pixelScale = renderPixelRatio / resolution;
var transform = resetTransform(this.tmpTransform_);
scaleTransform(transform, pixelScale, -pixelScale);
translateTransform(transform, -tileExtent[0], -tileExtent[3]);
for (var i = 0, ii = executorGroups.length; i < ii; ++i) {
var executorGroup = executorGroups[i];
executorGroup.execute(context, renderScale, transform, 0, true, IMAGE_REPLAYS[layer.getRenderMode()]);
}
replayState.renderedTileResolution = tile.wantedResolution;
};
return CanvasVectorTileLayerRenderer;
}(CanvasTileLayerRenderer));
export default CanvasVectorTileLayerRenderer;
//# sourceMappingURL=VectorTileLayer.js.map

1
node_modules/ol/renderer/canvas/VectorTileLayer.js.map generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

14
node_modules/ol/renderer/canvas/common.d.ts generated vendored Normal file
View File

@@ -0,0 +1,14 @@
/**
* @module ol/renderer/canvas/common
*/
/**
* Context options to disable image smoothing.
* @type {Object}
*/
export const IMAGE_SMOOTHING_DISABLED: any;
/**
* Context options to enable image smoothing.
* @type {Object}
*/
export const IMAGE_SMOOTHING_ENABLED: any;
//# sourceMappingURL=common.d.ts.map

1
node_modules/ol/renderer/canvas/common.d.ts.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/renderer/canvas/common.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AACH,2CAGE;AAEF;;;GAGG;AACH,0CAGE"}

20
node_modules/ol/renderer/canvas/common.js generated vendored Normal file
View File

@@ -0,0 +1,20 @@
/**
* @module ol/renderer/canvas/common
*/
/**
* Context options to disable image smoothing.
* @type {Object}
*/
export var IMAGE_SMOOTHING_DISABLED = {
imageSmoothingEnabled: false,
msImageSmoothingEnabled: false,
};
/**
* Context options to enable image smoothing.
* @type {Object}
*/
export var IMAGE_SMOOTHING_ENABLED = {
imageSmoothingEnabled: true,
msImageSmoothingEnabled: true,
};
//# sourceMappingURL=common.js.map

1
node_modules/ol/renderer/canvas/common.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"common.js","sourceRoot":"","sources":["../../src/renderer/canvas/common.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AACH,MAAM,CAAC,IAAM,wBAAwB,GAAG;IACtC,qBAAqB,EAAE,KAAK;IAC5B,uBAAuB,EAAE,KAAK;CAC/B,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,IAAM,uBAAuB,GAAG;IACrC,qBAAqB,EAAE,IAAI;IAC3B,uBAAuB,EAAE,IAAI;CAC9B,CAAC"}

38
node_modules/ol/renderer/vector.d.ts generated vendored Normal file
View File

@@ -0,0 +1,38 @@
/**
* @param {import("../Feature.js").FeatureLike} feature1 Feature 1.
* @param {import("../Feature.js").FeatureLike} feature2 Feature 2.
* @return {number} Order.
*/
export function defaultOrder(feature1: import("../Feature.js").FeatureLike, feature2: import("../Feature.js").FeatureLike): number;
/**
* @param {number} resolution Resolution.
* @param {number} pixelRatio Pixel ratio.
* @return {number} Squared pixel tolerance.
*/
export function getSquaredTolerance(resolution: number, pixelRatio: number): number;
/**
* @param {number} resolution Resolution.
* @param {number} pixelRatio Pixel ratio.
* @return {number} Pixel tolerance.
*/
export function getTolerance(resolution: number, pixelRatio: number): number;
/**
* @param {import("../render/canvas/BuilderGroup.js").default} replayGroup Replay group.
* @param {import("../Feature.js").FeatureLike} feature Feature.
* @param {import("../style/Style.js").default} style Style.
* @param {number} squaredTolerance Squared tolerance.
* @param {function(import("../events/Event.js").default): void} listener Listener function.
* @param {import("../proj.js").TransformFunction} [opt_transform] Transform from user to view projection.
* @param {import("../render/canvas/BuilderGroup.js").default} [opt_declutterBuilderGroup] Builder for decluttering.
* @return {boolean} `true` if style is loading.
*/
export function renderFeature(replayGroup: import("../render/canvas/BuilderGroup.js").default, feature: import("../Feature.js").FeatureLike, style: import("../style/Style.js").default, squaredTolerance: number, listener: (arg0: import("../events/Event.js").default) => void, opt_transform?: import("../proj.js").TransformFunction | undefined, opt_declutterBuilderGroup?: import("../render/canvas/BuilderGroup.js").default | undefined): boolean;
/**
* Feature callback. The callback will be called with three arguments. The first
* argument is one {@link module :ol/Feature~Feature feature} or {@link module :ol/render/Feature~RenderFeature render feature}
* at the pixel, the second is the {@link module :ol/layer/Layer~Layer layer} of the feature and will be null for
* unmanaged layers. The third is the {@link module :ol/geom/SimpleGeometry~SimpleGeometry} of the feature. For features
* with a GeometryCollection geometry, it will be the first detected geometry from the collection.
*/
export type FeatureCallback<T> = (arg0: import("../Feature.js").FeatureLike, arg1: import("../layer/Layer.js").default<import("../source/Source").default>, arg2: import("../geom/SimpleGeometry.js").default) => T;
//# sourceMappingURL=vector.d.ts.map

1
node_modules/ol/renderer/vector.d.ts.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"vector.d.ts","sourceRoot":"","sources":["../src/renderer/vector.js"],"names":[],"mappings":"AAuCA;;;;GAIG;AACH,uCAJW,OAAO,eAAe,EAAE,WAAW,YACnC,OAAO,eAAe,EAAE,WAAW,GAClC,MAAM,CAIjB;AAED;;;;GAIG;AACH,gDAJW,MAAM,cACN,MAAM,GACL,MAAM,CAKjB;AAED;;;;GAIG;AACH,yCAJW,MAAM,cACN,MAAM,GACL,MAAM,CAIjB;AAkCD;;;;;;;;;GASG;AACH,2CATW,OAAO,kCAAkC,EAAE,OAAO,WAClD,OAAO,eAAe,EAAE,WAAW,SACnC,OAAO,mBAAmB,EAAE,OAAO,oBACnC,MAAM,mBACG,OAAO,oBAAoB,EAAE,OAAO,KAAG,IAAI,mKAGnD,OAAO,CAmClB;;;;;;;;wCAjIqB,OAAO,eAAe,EAAE,WAAW,QAAE,OAAO,mBAAmB,EAAE,OAAO,CAAC,OAAO,kBAAkB,EAAE,OAAO,CAAC,QAAE,OAAO,2BAA2B,EAAE,OAAO,KAAG,CAAC"}

347
node_modules/ol/renderer/vector.js generated vendored Normal file
View File

@@ -0,0 +1,347 @@
/**
* @module ol/renderer/vector
*/
import ImageState from '../ImageState.js';
import { getUid } from '../util.js';
/**
* Feature callback. The callback will be called with three arguments. The first
* argument is one {@link module:ol/Feature~Feature feature} or {@link module:ol/render/Feature~RenderFeature render feature}
* at the pixel, the second is the {@link module:ol/layer/Layer~Layer layer} of the feature and will be null for
* unmanaged layers. The third is the {@link module:ol/geom/SimpleGeometry~SimpleGeometry} of the feature. For features
* with a GeometryCollection geometry, it will be the first detected geometry from the collection.
* @template T
* @typedef {function(import("../Feature.js").FeatureLike, import("../layer/Layer.js").default<import("../source/Source").default>, import("../geom/SimpleGeometry.js").default): T} FeatureCallback
*/
/**
* Tolerance for geometry simplification in device pixels.
* @type {number}
*/
var SIMPLIFY_TOLERANCE = 0.5;
/**
* @const
* @type {Object<import("../geom/Geometry.js").Type,
* function(import("../render/canvas/BuilderGroup.js").default, import("../geom/Geometry.js").default,
* import("../style/Style.js").default, Object): void>}
*/
var GEOMETRY_RENDERERS = {
'Point': renderPointGeometry,
'LineString': renderLineStringGeometry,
'Polygon': renderPolygonGeometry,
'MultiPoint': renderMultiPointGeometry,
'MultiLineString': renderMultiLineStringGeometry,
'MultiPolygon': renderMultiPolygonGeometry,
'GeometryCollection': renderGeometryCollectionGeometry,
'Circle': renderCircleGeometry,
};
/**
* @param {import("../Feature.js").FeatureLike} feature1 Feature 1.
* @param {import("../Feature.js").FeatureLike} feature2 Feature 2.
* @return {number} Order.
*/
export function defaultOrder(feature1, feature2) {
return parseInt(getUid(feature1), 10) - parseInt(getUid(feature2), 10);
}
/**
* @param {number} resolution Resolution.
* @param {number} pixelRatio Pixel ratio.
* @return {number} Squared pixel tolerance.
*/
export function getSquaredTolerance(resolution, pixelRatio) {
var tolerance = getTolerance(resolution, pixelRatio);
return tolerance * tolerance;
}
/**
* @param {number} resolution Resolution.
* @param {number} pixelRatio Pixel ratio.
* @return {number} Pixel tolerance.
*/
export function getTolerance(resolution, pixelRatio) {
return (SIMPLIFY_TOLERANCE * resolution) / pixelRatio;
}
/**
* @param {import("../render/canvas/BuilderGroup.js").default} builderGroup Builder group.
* @param {import("../geom/Circle.js").default} geometry Geometry.
* @param {import("../style/Style.js").default} style Style.
* @param {import("../Feature.js").default} feature Feature.
* @param {import("../render/canvas/BuilderGroup.js").default} [opt_declutterBuilderGroup] Builder for decluttering.
*/
function renderCircleGeometry(builderGroup, geometry, style, feature, opt_declutterBuilderGroup) {
var fillStyle = style.getFill();
var strokeStyle = style.getStroke();
if (fillStyle || strokeStyle) {
var circleReplay = builderGroup.getBuilder(style.getZIndex(), 'Circle');
circleReplay.setFillStrokeStyle(fillStyle, strokeStyle);
circleReplay.drawCircle(geometry, feature);
}
var textStyle = style.getText();
if (textStyle && textStyle.getText()) {
var textReplay = (opt_declutterBuilderGroup || builderGroup).getBuilder(style.getZIndex(), 'Text');
textReplay.setTextStyle(textStyle);
textReplay.drawText(geometry, feature);
}
}
/**
* @param {import("../render/canvas/BuilderGroup.js").default} replayGroup Replay group.
* @param {import("../Feature.js").FeatureLike} feature Feature.
* @param {import("../style/Style.js").default} style Style.
* @param {number} squaredTolerance Squared tolerance.
* @param {function(import("../events/Event.js").default): void} listener Listener function.
* @param {import("../proj.js").TransformFunction} [opt_transform] Transform from user to view projection.
* @param {import("../render/canvas/BuilderGroup.js").default} [opt_declutterBuilderGroup] Builder for decluttering.
* @return {boolean} `true` if style is loading.
*/
export function renderFeature(replayGroup, feature, style, squaredTolerance, listener, opt_transform, opt_declutterBuilderGroup) {
var loading = false;
var imageStyle = style.getImage();
if (imageStyle) {
var imageState = imageStyle.getImageState();
if (imageState == ImageState.LOADED || imageState == ImageState.ERROR) {
imageStyle.unlistenImageChange(listener);
}
else {
if (imageState == ImageState.IDLE) {
imageStyle.load();
}
imageStyle.listenImageChange(listener);
loading = true;
}
}
renderFeatureInternal(replayGroup, feature, style, squaredTolerance, opt_transform, opt_declutterBuilderGroup);
return loading;
}
/**
* @param {import("../render/canvas/BuilderGroup.js").default} replayGroup Replay group.
* @param {import("../Feature.js").FeatureLike} feature Feature.
* @param {import("../style/Style.js").default} style Style.
* @param {number} squaredTolerance Squared tolerance.
* @param {import("../proj.js").TransformFunction} [opt_transform] Optional transform function.
* @param {import("../render/canvas/BuilderGroup.js").default} [opt_declutterBuilderGroup] Builder for decluttering.
*/
function renderFeatureInternal(replayGroup, feature, style, squaredTolerance, opt_transform, opt_declutterBuilderGroup) {
var geometry = style.getGeometryFunction()(feature);
if (!geometry) {
return;
}
var simplifiedGeometry = geometry.simplifyTransformed(squaredTolerance, opt_transform);
var renderer = style.getRenderer();
if (renderer) {
renderGeometry(replayGroup, simplifiedGeometry, style, feature);
}
else {
var geometryRenderer = GEOMETRY_RENDERERS[simplifiedGeometry.getType()];
geometryRenderer(replayGroup, simplifiedGeometry, style, feature, opt_declutterBuilderGroup);
}
}
/**
* @param {import("../render/canvas/BuilderGroup.js").default} replayGroup Replay group.
* @param {import("../geom/Geometry.js").default|import("../render/Feature.js").default} geometry Geometry.
* @param {import("../style/Style.js").default} style Style.
* @param {import("../Feature.js").FeatureLike} feature Feature.
*/
function renderGeometry(replayGroup, geometry, style, feature) {
if (geometry.getType() == 'GeometryCollection') {
var geometries =
/** @type {import("../geom/GeometryCollection.js").default} */ (geometry).getGeometries();
for (var i = 0, ii = geometries.length; i < ii; ++i) {
renderGeometry(replayGroup, geometries[i], style, feature);
}
return;
}
var replay = replayGroup.getBuilder(style.getZIndex(), 'Default');
replay.drawCustom(
/** @type {import("../geom/SimpleGeometry.js").default} */ (geometry), feature, style.getRenderer(), style.getHitDetectionRenderer());
}
/**
* @param {import("../render/canvas/BuilderGroup.js").default} replayGroup Replay group.
* @param {import("../geom/GeometryCollection.js").default} geometry Geometry.
* @param {import("../style/Style.js").default} style Style.
* @param {import("../Feature.js").default} feature Feature.
* @param {import("../render/canvas/BuilderGroup.js").default} [opt_declutterBuilderGroup] Builder for decluttering.
*/
function renderGeometryCollectionGeometry(replayGroup, geometry, style, feature, opt_declutterBuilderGroup) {
var geometries = geometry.getGeometriesArray();
var i, ii;
for (i = 0, ii = geometries.length; i < ii; ++i) {
var geometryRenderer = GEOMETRY_RENDERERS[geometries[i].getType()];
geometryRenderer(replayGroup, geometries[i], style, feature, opt_declutterBuilderGroup);
}
}
/**
* @param {import("../render/canvas/BuilderGroup.js").default} builderGroup Replay group.
* @param {import("../geom/LineString.js").default|import("../render/Feature.js").default} geometry Geometry.
* @param {import("../style/Style.js").default} style Style.
* @param {import("../Feature.js").FeatureLike} feature Feature.
* @param {import("../render/canvas/BuilderGroup.js").default} [opt_declutterBuilderGroup] Builder for decluttering.
*/
function renderLineStringGeometry(builderGroup, geometry, style, feature, opt_declutterBuilderGroup) {
var strokeStyle = style.getStroke();
if (strokeStyle) {
var lineStringReplay = builderGroup.getBuilder(style.getZIndex(), 'LineString');
lineStringReplay.setFillStrokeStyle(null, strokeStyle);
lineStringReplay.drawLineString(geometry, feature);
}
var textStyle = style.getText();
if (textStyle && textStyle.getText()) {
var textReplay = (opt_declutterBuilderGroup || builderGroup).getBuilder(style.getZIndex(), 'Text');
textReplay.setTextStyle(textStyle);
textReplay.drawText(geometry, feature);
}
}
/**
* @param {import("../render/canvas/BuilderGroup.js").default} builderGroup Replay group.
* @param {import("../geom/MultiLineString.js").default|import("../render/Feature.js").default} geometry Geometry.
* @param {import("../style/Style.js").default} style Style.
* @param {import("../Feature.js").FeatureLike} feature Feature.
* @param {import("../render/canvas/BuilderGroup.js").default} [opt_declutterBuilderGroup] Builder for decluttering.
*/
function renderMultiLineStringGeometry(builderGroup, geometry, style, feature, opt_declutterBuilderGroup) {
var strokeStyle = style.getStroke();
if (strokeStyle) {
var lineStringReplay = builderGroup.getBuilder(style.getZIndex(), 'LineString');
lineStringReplay.setFillStrokeStyle(null, strokeStyle);
lineStringReplay.drawMultiLineString(geometry, feature);
}
var textStyle = style.getText();
if (textStyle && textStyle.getText()) {
var textReplay = (opt_declutterBuilderGroup || builderGroup).getBuilder(style.getZIndex(), 'Text');
textReplay.setTextStyle(textStyle);
textReplay.drawText(geometry, feature);
}
}
/**
* @param {import("../render/canvas/BuilderGroup.js").default} builderGroup Replay group.
* @param {import("../geom/MultiPolygon.js").default} geometry Geometry.
* @param {import("../style/Style.js").default} style Style.
* @param {import("../Feature.js").default} feature Feature.
* @param {import("../render/canvas/BuilderGroup.js").default} [opt_declutterBuilderGroup] Builder for decluttering.
*/
function renderMultiPolygonGeometry(builderGroup, geometry, style, feature, opt_declutterBuilderGroup) {
var fillStyle = style.getFill();
var strokeStyle = style.getStroke();
if (strokeStyle || fillStyle) {
var polygonReplay = builderGroup.getBuilder(style.getZIndex(), 'Polygon');
polygonReplay.setFillStrokeStyle(fillStyle, strokeStyle);
polygonReplay.drawMultiPolygon(geometry, feature);
}
var textStyle = style.getText();
if (textStyle && textStyle.getText()) {
var textReplay = (opt_declutterBuilderGroup || builderGroup).getBuilder(style.getZIndex(), 'Text');
textReplay.setTextStyle(textStyle);
textReplay.drawText(geometry, feature);
}
}
/**
* @param {import("../render/canvas/BuilderGroup.js").default} builderGroup Replay group.
* @param {import("../geom/Point.js").default|import("../render/Feature.js").default} geometry Geometry.
* @param {import("../style/Style.js").default} style Style.
* @param {import("../Feature.js").FeatureLike} feature Feature.
* @param {import("../render/canvas/BuilderGroup.js").default} [opt_declutterBuilderGroup] Builder for decluttering.
*/
function renderPointGeometry(builderGroup, geometry, style, feature, opt_declutterBuilderGroup) {
var imageStyle = style.getImage();
var textStyle = style.getText();
/** @type {import("../render/canvas.js").DeclutterImageWithText} */
var declutterImageWithText;
if (imageStyle) {
if (imageStyle.getImageState() != ImageState.LOADED) {
return;
}
var imageBuilderGroup = builderGroup;
if (opt_declutterBuilderGroup) {
var declutterMode = imageStyle.getDeclutterMode();
if (declutterMode !== 'none') {
imageBuilderGroup = opt_declutterBuilderGroup;
if (declutterMode === 'obstacle') {
// draw in non-declutter group:
var imageReplay_1 = builderGroup.getBuilder(style.getZIndex(), 'Image');
imageReplay_1.setImageStyle(imageStyle, declutterImageWithText);
imageReplay_1.drawPoint(geometry, feature);
}
else if (textStyle && textStyle.getText()) {
declutterImageWithText = {};
}
}
}
var imageReplay = imageBuilderGroup.getBuilder(style.getZIndex(), 'Image');
imageReplay.setImageStyle(imageStyle, declutterImageWithText);
imageReplay.drawPoint(geometry, feature);
}
if (textStyle && textStyle.getText()) {
var textBuilderGroup = builderGroup;
if (opt_declutterBuilderGroup) {
textBuilderGroup = opt_declutterBuilderGroup;
}
var textReplay = textBuilderGroup.getBuilder(style.getZIndex(), 'Text');
textReplay.setTextStyle(textStyle, declutterImageWithText);
textReplay.drawText(geometry, feature);
}
}
/**
* @param {import("../render/canvas/BuilderGroup.js").default} builderGroup Replay group.
* @param {import("../geom/MultiPoint.js").default|import("../render/Feature.js").default} geometry Geometry.
* @param {import("../style/Style.js").default} style Style.
* @param {import("../Feature.js").FeatureLike} feature Feature.
* @param {import("../render/canvas/BuilderGroup.js").default} [opt_declutterBuilderGroup] Builder for decluttering.
*/
function renderMultiPointGeometry(builderGroup, geometry, style, feature, opt_declutterBuilderGroup) {
var imageStyle = style.getImage();
var textStyle = style.getText();
/** @type {import("../render/canvas.js").DeclutterImageWithText} */
var declutterImageWithText;
if (imageStyle) {
if (imageStyle.getImageState() != ImageState.LOADED) {
return;
}
var imageBuilderGroup = builderGroup;
if (opt_declutterBuilderGroup) {
var declutterMode = imageStyle.getDeclutterMode();
if (declutterMode !== 'none') {
imageBuilderGroup = opt_declutterBuilderGroup;
if (declutterMode === 'obstacle') {
// draw in non-declutter group:
var imageReplay_2 = builderGroup.getBuilder(style.getZIndex(), 'Image');
imageReplay_2.setImageStyle(imageStyle, declutterImageWithText);
imageReplay_2.drawMultiPoint(geometry, feature);
}
else if (textStyle && textStyle.getText()) {
declutterImageWithText = {};
}
}
}
var imageReplay = imageBuilderGroup.getBuilder(style.getZIndex(), 'Image');
imageReplay.setImageStyle(imageStyle, declutterImageWithText);
imageReplay.drawMultiPoint(geometry, feature);
}
if (textStyle && textStyle.getText()) {
var textBuilderGroup = builderGroup;
if (opt_declutterBuilderGroup) {
textBuilderGroup = opt_declutterBuilderGroup;
}
var textReplay = textBuilderGroup.getBuilder(style.getZIndex(), 'Text');
textReplay.setTextStyle(textStyle, declutterImageWithText);
textReplay.drawText(geometry, feature);
}
}
/**
* @param {import("../render/canvas/BuilderGroup.js").default} builderGroup Replay group.
* @param {import("../geom/Polygon.js").default|import("../render/Feature.js").default} geometry Geometry.
* @param {import("../style/Style.js").default} style Style.
* @param {import("../Feature.js").FeatureLike} feature Feature.
* @param {import("../render/canvas/BuilderGroup.js").default} [opt_declutterBuilderGroup] Builder for decluttering.
*/
function renderPolygonGeometry(builderGroup, geometry, style, feature, opt_declutterBuilderGroup) {
var fillStyle = style.getFill();
var strokeStyle = style.getStroke();
if (fillStyle || strokeStyle) {
var polygonReplay = builderGroup.getBuilder(style.getZIndex(), 'Polygon');
polygonReplay.setFillStrokeStyle(fillStyle, strokeStyle);
polygonReplay.drawPolygon(geometry, feature);
}
var textStyle = style.getText();
if (textStyle && textStyle.getText()) {
var textReplay = (opt_declutterBuilderGroup || builderGroup).getBuilder(style.getZIndex(), 'Text');
textReplay.setTextStyle(textStyle);
textReplay.drawText(geometry, feature);
}
}
//# sourceMappingURL=vector.js.map

1
node_modules/ol/renderer/vector.js.map generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

238
node_modules/ol/renderer/webgl/Layer.d.ts generated vendored Normal file
View File

@@ -0,0 +1,238 @@
/**
* An object holding positions both in an index and a vertex buffer.
* @typedef {Object} BufferPositions
* @property {number} vertexPosition Position in the vertex buffer
* @property {number} indexPosition Position in the index buffer
*/
/**
* 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 {number} customAttributesCount 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.
* @private
*/
export function writePointFeatureToBuffers(instructions: Float32Array, elementIndex: number, vertexBuffer: Float32Array, indexBuffer: Uint32Array, customAttributesCount: number, bufferPositions?: BufferPositions | undefined): BufferPositions;
/**
* Returns a texture of 1x1 pixel, white
* @private
* @return {ImageData} Image data.
*/
export function getBlankImageData(): ImageData;
/**
* Generates a color array based on a numerical id
* Note: the range for each component is 0 to 1 with 256 steps
* @param {number} id Id
* @param {Array<number>} [opt_array] Reusable array
* @return {Array<number>} Color array containing the encoded id
*/
export function colorEncodeId(id: number, opt_array?: number[] | undefined): Array<number>;
/**
* Reads an id from a color-encoded array
* Note: the expected range for each component is 0 to 1 with 256 steps.
* @param {Array<number>} color Color array containing the encoded id
* @return {number} Decoded id
*/
export function colorDecodeId(color: Array<number>): number;
export type WebGLWorkerMessageType = string;
export namespace WebGLWorkerMessageType {
const GENERATE_BUFFERS: string;
}
export default WebGLLayerRenderer;
/**
* An object holding positions both in an index and a vertex buffer.
*/
export type BufferPositions = {
/**
* Position in the vertex buffer
*/
vertexPosition: number;
/**
* Position in the index buffer
*/
indexPosition: number;
};
/**
* This message will trigger the generation of a vertex and an index buffer based on the given render instructions.
* When the buffers are generated, the worked will send a message of the same type to the main thread, with
* the generated buffers in it.
* Note that any addition properties present in the message *will* be sent back to the main thread.
*/
export type WebGLWorkerGenerateBuffersMessage = {
/**
* Message type
*/
type: WebGLWorkerMessageType;
/**
* Render instructions raw binary buffer.
*/
renderInstructions: ArrayBuffer;
/**
* Vertices array raw binary buffer (sent by the worker).
*/
vertexBuffer?: ArrayBuffer | undefined;
/**
* Indices array raw binary buffer (sent by the worker).
*/
indexBuffer?: ArrayBuffer | undefined;
/**
* Amount of custom attributes count in the render instructions.
*/
customAttributesCount?: number | undefined;
};
export type PostProcessesOptions = {
/**
* Scale ratio; if < 1, the post process will render to a texture smaller than
* the main canvas that will then be sampled up (useful for saving resource on blur steps).
*/
scaleRatio?: number | undefined;
/**
* Vertex shader source
*/
vertexShader?: string | undefined;
/**
* Fragment shader source
*/
fragmentShader?: string | undefined;
/**
* Uniform definitions for the post process step
*/
uniforms?: {
[x: string]: import("../../webgl/Helper.js").UniformValue;
} | undefined;
};
export type Options = {
/**
* Uniform definitions for the post process steps
*/
uniforms?: {
[x: string]: import("../../webgl/Helper.js").UniformValue;
} | undefined;
/**
* Post-processes definitions
*/
postProcesses?: PostProcessesOptions[] | undefined;
};
/**
* @typedef {Object} WebGLWorkerGenerateBuffersMessage
* This message will trigger the generation of a vertex and an index buffer based on the given render instructions.
* When the buffers are generated, the worked will send a message of the same type to the main thread, with
* the generated buffers in it.
* Note that any addition properties present in the message *will* be sent back to the main thread.
* @property {WebGLWorkerMessageType} type Message type
* @property {ArrayBuffer} renderInstructions Render instructions raw binary buffer.
* @property {ArrayBuffer} [vertexBuffer] Vertices array raw binary buffer (sent by the worker).
* @property {ArrayBuffer} [indexBuffer] Indices array raw binary buffer (sent by the worker).
* @property {number} [customAttributesCount] Amount of custom attributes count in the render instructions.
*/
/**
* @typedef {Object} PostProcessesOptions
* @property {number} [scaleRatio] Scale ratio; if < 1, the post process will render to a texture smaller than
* the main canvas that will then be sampled up (useful for saving resource on blur steps).
* @property {string} [vertexShader] Vertex shader source
* @property {string} [fragmentShader] Fragment shader source
* @property {Object<string,import("../../webgl/Helper").UniformValue>} [uniforms] Uniform definitions for the post process step
*/
/**
* @typedef {Object} Options
* @property {Object<string,import("../../webgl/Helper").UniformValue>} [uniforms] Uniform definitions for the post process steps
* @property {Array<PostProcessesOptions>} [postProcesses] Post-processes definitions
*/
/**
* @classdesc
* Base WebGL renderer class.
* Holds all logic related to data manipulation & some common rendering logic
* @template {import("../../layer/Layer.js").default} LayerType
* @extends {LayerRenderer<LayerType>}
*/
declare class WebGLLayerRenderer<LayerType extends import("../../layer/Layer.js").default<import("../../source/Source.js").default, LayerRenderer<any>>> extends LayerRenderer<LayerType> {
/**
* @param {LayerType} layer Layer.
* @param {Options} [opt_options] Options.
*/
constructor(layer: LayerType, opt_options?: Options | undefined);
/**
* The transform for viewport CSS pixels to rendered pixels. This transform is only
* set before dispatching rendering events.
* @private
* @type {import("../../transform.js").Transform}
*/
private inversePixelTransform_;
/**
* @private
* @type {CanvasRenderingContext2D}
*/
private pixelContext_;
/**
* @private
*/
private postProcesses_;
/**
* @private
*/
private uniforms_;
/**
* @type {WebGLHelper}
* @protected
*/
protected helper: WebGLHelper;
/**
* @param {WebGLRenderingContext} context The WebGL rendering context.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @protected
*/
protected dispatchPreComposeEvent(context: WebGLRenderingContext, frameState: import("../../PluggableMap.js").FrameState): void;
/**
* @param {WebGLRenderingContext} context The WebGL rendering context.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @protected
*/
protected dispatchPostComposeEvent(context: WebGLRenderingContext, frameState: import("../../PluggableMap.js").FrameState): void;
/**
* Reset options (only handles uniforms).
* @param {Options} options Options.
*/
reset(options: Options): void;
/**
* @protected
*/
protected removeHelper(): void;
/**
* @protected
*/
protected afterHelperCreated(): void;
/**
* Determine whether renderFrame should be called.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @return {boolean} Layer is ready to be rendered.
* @protected
*/
protected prepareFrameInternal(frameState: import("../../PluggableMap.js").FrameState): boolean;
/**
* @param {import("../../render/EventType.js").default} type Event type.
* @param {WebGLRenderingContext} context The rendering context.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @private
*/
private dispatchRenderEvent_;
/**
* @param {WebGLRenderingContext} context The rendering context.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @protected
*/
protected preRender(context: WebGLRenderingContext, frameState: import("../../PluggableMap.js").FrameState): void;
/**
* @param {WebGLRenderingContext} context The rendering context.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @protected
*/
protected postRender(context: WebGLRenderingContext, frameState: import("../../PluggableMap.js").FrameState): void;
}
import LayerRenderer from "../Layer.js";
import WebGLHelper from "../../webgl/Helper.js";
//# sourceMappingURL=Layer.d.ts.map

1
node_modules/ol/renderer/webgl/Layer.d.ts.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"Layer.d.ts","sourceRoot":"","sources":["../../src/renderer/webgl/Layer.js"],"names":[],"mappings":"AAkWA;;;;;GAKG;AAEH;;;;;;;;;;;;GAYG;AACH,yDAXW,YAAY,gBACZ,MAAM,gBACN,YAAY,eACZ,WAAW,yBACX,MAAM,kDAEL,eAAe,CAgE1B;AAED;;;;GAIG;AACH,qCAFY,SAAS,CAUpB;AAED;;;;;;GAMG;AACH,kCAJW,MAAM,qCAEL,MAAM,MAAM,CAAC,CAWxB;AAED;;;;;GAKG;AACH,qCAHW,MAAM,MAAM,CAAC,GACZ,MAAM,CAWjB;qCAndS,MAAM;;;;;;;;;;;;oBAqVF,MAAM;;;;mBACN,MAAM;;;;;;;;;;;;UA1UN,sBAAsB;;;;wBACtB,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAPzB;;;;;;;;;;;GAWG;AAEH;;;;;;;GAOG;AAEH;;;;GAIG;AAEH;;;;;;GAMG;AACH;IACE;;;OAGG;IACH,mBAHW,SAAS,qCA0CnB;IAlCC;;;;;OAKG;IACH,+BAA+C;IAE/C;;;OAGG;IACH,sBAAyB;IAEzB;;OAEG;IACH,uBAA2C;IAE3C;;OAEG;IACH,kBAAiC;IAEjC;;;OAGG;IACH,kBAHU,WAAW,CAGV;IAQb;;;;OAIG;IACH,2CAJW,qBAAqB,cACrB,OAAO,uBAAuB,EAAE,UAAU,QAcpD;IAED;;;;OAIG;IACH,4CAJW,qBAAqB,cACrB,OAAO,uBAAuB,EAAE,UAAU,QAcpD;IAED;;;OAGG;IACH,eAFW,OAAO,QAOjB;IAED;;OAEG;IACH,+BAKC;IAqDD;;OAEG;IACH,qCAAuB;IAEvB;;;;;OAKG;IACH,2CAJW,OAAO,uBAAuB,EAAE,UAAU,GACzC,OAAO,CAKlB;IAUD;;;;;OAKG;IACH,6BAsBC;IAED;;;;OAIG;IACH,6BAJW,qBAAqB,cACrB,OAAO,uBAAuB,EAAE,UAAU,QAKpD;IAED;;;;OAIG;IACH,8BAJW,qBAAqB,cACrB,OAAO,uBAAuB,EAAE,UAAU,QAKpD;CA+DF"}

410
node_modules/ol/renderer/webgl/Layer.js generated vendored Normal file
View File

@@ -0,0 +1,410 @@
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
/**
* @module ol/renderer/webgl/Layer
*/
import LayerProperty from '../../layer/Property.js';
import LayerRenderer from '../Layer.js';
import RenderEvent from '../../render/Event.js';
import RenderEventType from '../../render/EventType.js';
import WebGLHelper from '../../webgl/Helper.js';
import { apply as applyTransform, compose as composeTransform, create as createTransform, } from '../../transform.js';
import { containsCoordinate } from '../../extent.js';
/**
* @enum {string}
*/
export var WebGLWorkerMessageType = {
GENERATE_BUFFERS: 'GENERATE_BUFFERS',
};
/**
* @typedef {Object} WebGLWorkerGenerateBuffersMessage
* This message will trigger the generation of a vertex and an index buffer based on the given render instructions.
* When the buffers are generated, the worked will send a message of the same type to the main thread, with
* the generated buffers in it.
* Note that any addition properties present in the message *will* be sent back to the main thread.
* @property {WebGLWorkerMessageType} type Message type
* @property {ArrayBuffer} renderInstructions Render instructions raw binary buffer.
* @property {ArrayBuffer} [vertexBuffer] Vertices array raw binary buffer (sent by the worker).
* @property {ArrayBuffer} [indexBuffer] Indices array raw binary buffer (sent by the worker).
* @property {number} [customAttributesCount] Amount of custom attributes count in the render instructions.
*/
/**
* @typedef {Object} PostProcessesOptions
* @property {number} [scaleRatio] Scale ratio; if < 1, the post process will render to a texture smaller than
* the main canvas that will then be sampled up (useful for saving resource on blur steps).
* @property {string} [vertexShader] Vertex shader source
* @property {string} [fragmentShader] Fragment shader source
* @property {Object<string,import("../../webgl/Helper").UniformValue>} [uniforms] Uniform definitions for the post process step
*/
/**
* @typedef {Object} Options
* @property {Object<string,import("../../webgl/Helper").UniformValue>} [uniforms] Uniform definitions for the post process steps
* @property {Array<PostProcessesOptions>} [postProcesses] Post-processes definitions
*/
/**
* @classdesc
* Base WebGL renderer class.
* Holds all logic related to data manipulation & some common rendering logic
* @template {import("../../layer/Layer.js").default} LayerType
* @extends {LayerRenderer<LayerType>}
*/
var WebGLLayerRenderer = /** @class */ (function (_super) {
__extends(WebGLLayerRenderer, _super);
/**
* @param {LayerType} layer Layer.
* @param {Options} [opt_options] Options.
*/
function WebGLLayerRenderer(layer, opt_options) {
var _this = _super.call(this, layer) || this;
var options = opt_options || {};
/**
* The transform for viewport CSS pixels to rendered pixels. This transform is only
* set before dispatching rendering events.
* @private
* @type {import("../../transform.js").Transform}
*/
_this.inversePixelTransform_ = createTransform();
/**
* @private
* @type {CanvasRenderingContext2D}
*/
_this.pixelContext_ = null;
/**
* @private
*/
_this.postProcesses_ = options.postProcesses;
/**
* @private
*/
_this.uniforms_ = options.uniforms;
/**
* @type {WebGLHelper}
* @protected
*/
_this.helper;
layer.addChangeListener(LayerProperty.MAP, _this.removeHelper.bind(_this));
_this.dispatchPreComposeEvent = _this.dispatchPreComposeEvent.bind(_this);
_this.dispatchPostComposeEvent = _this.dispatchPostComposeEvent.bind(_this);
return _this;
}
/**
* @param {WebGLRenderingContext} context The WebGL rendering context.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @protected
*/
WebGLLayerRenderer.prototype.dispatchPreComposeEvent = function (context, frameState) {
var layer = this.getLayer();
if (layer.hasListener(RenderEventType.PRECOMPOSE)) {
var event_1 = new RenderEvent(RenderEventType.PRECOMPOSE, undefined, frameState, context);
layer.dispatchEvent(event_1);
}
};
/**
* @param {WebGLRenderingContext} context The WebGL rendering context.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @protected
*/
WebGLLayerRenderer.prototype.dispatchPostComposeEvent = function (context, frameState) {
var layer = this.getLayer();
if (layer.hasListener(RenderEventType.POSTCOMPOSE)) {
var event_2 = new RenderEvent(RenderEventType.POSTCOMPOSE, undefined, frameState, context);
layer.dispatchEvent(event_2);
}
};
/**
* Reset options (only handles uniforms).
* @param {Options} options Options.
*/
WebGLLayerRenderer.prototype.reset = function (options) {
this.uniforms_ = options.uniforms;
if (this.helper) {
this.helper.setUniforms(this.uniforms_);
}
};
/**
* @protected
*/
WebGLLayerRenderer.prototype.removeHelper = function () {
if (this.helper) {
this.helper.dispose();
delete this.helper;
}
};
/**
* Determine whether renderFrame should be called.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @return {boolean} Layer is ready to be rendered.
*/
WebGLLayerRenderer.prototype.prepareFrame = function (frameState) {
if (this.getLayer().getRenderSource()) {
var incrementGroup = true;
var groupNumber = -1;
var className = void 0;
for (var i = 0, ii = frameState.layerStatesArray.length; i < ii; i++) {
var layer = frameState.layerStatesArray[i].layer;
var renderer = layer.getRenderer();
if (!(renderer instanceof WebGLLayerRenderer)) {
incrementGroup = true;
continue;
}
var layerClassName = layer.getClassName();
if (incrementGroup || layerClassName !== className) {
groupNumber += 1;
incrementGroup = false;
}
className = layerClassName;
if (renderer === this) {
break;
}
}
var canvasCacheKey = 'map/' + frameState.mapId + '/group/' + groupNumber;
if (!this.helper || !this.helper.canvasCacheKeyMatches(canvasCacheKey)) {
this.removeHelper();
this.helper = new WebGLHelper({
postProcesses: this.postProcesses_,
uniforms: this.uniforms_,
canvasCacheKey: canvasCacheKey,
});
if (className) {
this.helper.getCanvas().className = className;
}
this.afterHelperCreated();
}
}
return this.prepareFrameInternal(frameState);
};
/**
* @protected
*/
WebGLLayerRenderer.prototype.afterHelperCreated = function () { };
/**
* Determine whether renderFrame should be called.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @return {boolean} Layer is ready to be rendered.
* @protected
*/
WebGLLayerRenderer.prototype.prepareFrameInternal = function (frameState) {
return true;
};
/**
* Clean up.
*/
WebGLLayerRenderer.prototype.disposeInternal = function () {
this.removeHelper();
_super.prototype.disposeInternal.call(this);
};
/**
* @param {import("../../render/EventType.js").default} type Event type.
* @param {WebGLRenderingContext} context The rendering context.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @private
*/
WebGLLayerRenderer.prototype.dispatchRenderEvent_ = function (type, context, frameState) {
var layer = this.getLayer();
if (layer.hasListener(type)) {
composeTransform(this.inversePixelTransform_, 0, 0, frameState.pixelRatio, -frameState.pixelRatio, 0, 0, -frameState.size[1]);
var event_3 = new RenderEvent(type, this.inversePixelTransform_, frameState, context);
layer.dispatchEvent(event_3);
}
};
/**
* @param {WebGLRenderingContext} context The rendering context.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @protected
*/
WebGLLayerRenderer.prototype.preRender = function (context, frameState) {
this.dispatchRenderEvent_(RenderEventType.PRERENDER, context, frameState);
};
/**
* @param {WebGLRenderingContext} context The rendering context.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @protected
*/
WebGLLayerRenderer.prototype.postRender = function (context, frameState) {
this.dispatchRenderEvent_(RenderEventType.POSTRENDER, context, frameState);
};
/**
* @param {import("../../pixel.js").Pixel} pixel Pixel.
* @param {import("../../PluggableMap.js").FrameState} frameState FrameState.
* @param {number} hitTolerance Hit tolerance in pixels.
* @return {Uint8ClampedArray|Uint8Array} The result. If there is no data at the pixel
* location, null will be returned. If there is data, but pixel values cannot be
* returned, and empty array will be returned.
*/
WebGLLayerRenderer.prototype.getDataAtPixel = function (pixel, frameState, hitTolerance) {
var renderPixel = applyTransform([frameState.pixelRatio, 0, 0, frameState.pixelRatio, 0, 0], pixel.slice());
var gl = this.helper.getGL();
if (!gl) {
return null;
}
var layer = this.getLayer();
var layerExtent = layer.getExtent();
if (layerExtent) {
var renderCoordinate = applyTransform(frameState.pixelToCoordinateTransform, pixel.slice());
/** get only data inside of the layer extent */
if (!containsCoordinate(layerExtent, renderCoordinate)) {
return null;
}
}
var attributes = gl.getContextAttributes();
if (!attributes || !attributes.preserveDrawingBuffer) {
// we assume there is data at the given pixel (although there might not be)
return new Uint8Array();
}
var x = Math.round(renderPixel[0]);
var y = Math.round(renderPixel[1]);
var pixelContext = this.pixelContext_;
if (!pixelContext) {
var pixelCanvas = document.createElement('canvas');
pixelCanvas.width = 1;
pixelCanvas.height = 1;
pixelContext = pixelCanvas.getContext('2d');
this.pixelContext_ = pixelContext;
}
pixelContext.clearRect(0, 0, 1, 1);
var data;
try {
pixelContext.drawImage(gl.canvas, x, y, 1, 1, 0, 0, 1, 1);
data = pixelContext.getImageData(0, 0, 1, 1).data;
}
catch (err) {
return data;
}
if (data[3] === 0) {
return null;
}
return data;
};
return WebGLLayerRenderer;
}(LayerRenderer));
var tmpArray_ = [];
var bufferPositions_ = { vertexPosition: 0, indexPosition: 0 };
function writePointVertex(buffer, pos, x, y, index) {
buffer[pos + 0] = x;
buffer[pos + 1] = y;
buffer[pos + 2] = index;
}
/**
* An object holding positions both in an index and a vertex buffer.
* @typedef {Object} BufferPositions
* @property {number} vertexPosition Position in the vertex buffer
* @property {number} indexPosition Position in the index buffer
*/
/**
* 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 {number} customAttributesCount 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.
* @private
*/
export function writePointFeatureToBuffers(instructions, elementIndex, vertexBuffer, indexBuffer, customAttributesCount, bufferPositions) {
// This is for x, y and index
var baseVertexAttrsCount = 3;
var baseInstructionsCount = 2;
var stride = baseVertexAttrsCount + customAttributesCount;
var x = instructions[elementIndex + 0];
var y = instructions[elementIndex + 1];
// read custom numerical attributes on the feature
var customAttrs = tmpArray_;
customAttrs.length = customAttributesCount;
for (var i = 0; i < customAttrs.length; i++) {
customAttrs[i] = instructions[elementIndex + baseInstructionsCount + i];
}
var vPos = bufferPositions ? bufferPositions.vertexPosition : 0;
var iPos = bufferPositions ? bufferPositions.indexPosition : 0;
var baseIndex = vPos / stride;
// push vertices for each of the four quad corners (first standard then custom attributes)
writePointVertex(vertexBuffer, vPos, x, y, 0);
customAttrs.length &&
vertexBuffer.set(customAttrs, vPos + baseVertexAttrsCount);
vPos += stride;
writePointVertex(vertexBuffer, vPos, x, y, 1);
customAttrs.length &&
vertexBuffer.set(customAttrs, vPos + baseVertexAttrsCount);
vPos += stride;
writePointVertex(vertexBuffer, vPos, x, y, 2);
customAttrs.length &&
vertexBuffer.set(customAttrs, vPos + baseVertexAttrsCount);
vPos += stride;
writePointVertex(vertexBuffer, vPos, x, y, 3);
customAttrs.length &&
vertexBuffer.set(customAttrs, vPos + baseVertexAttrsCount);
vPos += stride;
indexBuffer[iPos++] = baseIndex;
indexBuffer[iPos++] = baseIndex + 1;
indexBuffer[iPos++] = baseIndex + 3;
indexBuffer[iPos++] = baseIndex + 1;
indexBuffer[iPos++] = baseIndex + 2;
indexBuffer[iPos++] = baseIndex + 3;
bufferPositions_.vertexPosition = vPos;
bufferPositions_.indexPosition = iPos;
return bufferPositions_;
}
/**
* Returns a texture of 1x1 pixel, white
* @private
* @return {ImageData} Image data.
*/
export function getBlankImageData() {
var canvas = document.createElement('canvas');
var image = canvas.getContext('2d').createImageData(1, 1);
image.data[0] = 255;
image.data[1] = 255;
image.data[2] = 255;
image.data[3] = 255;
return image;
}
/**
* Generates a color array based on a numerical id
* Note: the range for each component is 0 to 1 with 256 steps
* @param {number} id Id
* @param {Array<number>} [opt_array] Reusable array
* @return {Array<number>} Color array containing the encoded id
*/
export function colorEncodeId(id, opt_array) {
var array = opt_array || [];
var radix = 256;
var divide = radix - 1;
array[0] = Math.floor(id / radix / radix / radix) / divide;
array[1] = (Math.floor(id / radix / radix) % radix) / divide;
array[2] = (Math.floor(id / radix) % radix) / divide;
array[3] = (id % radix) / divide;
return array;
}
/**
* Reads an id from a color-encoded array
* Note: the expected range for each component is 0 to 1 with 256 steps.
* @param {Array<number>} color Color array containing the encoded id
* @return {number} Decoded id
*/
export function colorDecodeId(color) {
var id = 0;
var radix = 256;
var mult = radix - 1;
id += Math.round(color[0] * radix * radix * radix * mult);
id += Math.round(color[1] * radix * radix * mult);
id += Math.round(color[2] * radix * mult);
id += Math.round(color[3] * mult);
return id;
}
export default WebGLLayerRenderer;
//# sourceMappingURL=Layer.js.map

1
node_modules/ol/renderer/webgl/Layer.js.map generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

324
node_modules/ol/renderer/webgl/PointsLayer.d.ts generated vendored Normal file
View File

@@ -0,0 +1,324 @@
export default WebGLPointsLayerRenderer;
/**
* A description of a custom attribute to be passed on to the GPU, with a value different
* for each feature.
*/
export type CustomAttribute = {
/**
* Attribute name.
*/
name: string;
/**
* This callback computes the numerical value of the
* attribute for a given feature (properties are available as 2nd arg for quicker access).
*/
callback: (arg0: import("../../Feature").default, arg1: {
[x: string]: any;
}) => number;
};
/**
* Object that holds a reference to a feature, its geometry and properties. Used to optimize
* rebuildBuffers by accessing these objects quicker.
*/
export type FeatureCacheItem = {
/**
* Feature
*/
feature: import("../../Feature").default;
/**
* Feature properties
*/
properties: {
[x: string]: any;
};
/**
* Feature geometry
*/
geometry: import("../../geom").Geometry;
};
export type Options = {
/**
* A CSS class name to set to the canvas element.
*/
className?: string | undefined;
/**
* These attributes will be read from the features in the source and then
* passed to the GPU. The `name` property of each attribute will serve as its identifier:
* * In the vertex shader as an `attribute` by prefixing it with `a_`
* * In the fragment shader as a `varying` by prefixing it with `v_`
* Please note that these can only be numerical values.
*/
attributes?: CustomAttribute[] | undefined;
/**
* Vertex shader source, mandatory.
*/
vertexShader: string;
/**
* Fragment shader source, mandatory.
*/
fragmentShader: string;
/**
* Vertex shader source for hit detection rendering.
*/
hitVertexShader?: string | undefined;
/**
* Fragment shader source for hit detection rendering.
*/
hitFragmentShader?: string | undefined;
/**
* Uniform definitions for the post process steps
* Please note that `u_texture` is reserved for the main texture slot and `u_opacity` is reserved for the layer opacity.
*/
uniforms?: {
[x: string]: import("../../webgl/Helper.js").UniformValue;
} | undefined;
/**
* Post-processes definitions
*/
postProcesses?: import("./Layer.js").PostProcessesOptions[] | undefined;
};
/**
* @typedef {Object} CustomAttribute A description of a custom attribute to be passed on to the GPU, with a value different
* for each feature.
* @property {string} name Attribute name.
* @property {function(import("../../Feature").default, Object<string, *>):number} callback This callback computes the numerical value of the
* attribute for a given feature (properties are available as 2nd arg for quicker access).
*/
/**
* @typedef {Object} FeatureCacheItem Object that holds a reference to a feature, its geometry and properties. Used to optimize
* rebuildBuffers by accessing these objects quicker.
* @property {import("../../Feature").default} feature Feature
* @property {Object<string, *>} properties Feature properties
* @property {import("../../geom").Geometry} geometry Feature geometry
*/
/**
* @typedef {Object} Options
* @property {string} [className='ol-layer'] A CSS class name to set to the canvas element.
* @property {Array<CustomAttribute>} [attributes] These attributes will be read from the features in the source and then
* passed to the GPU. The `name` property of each attribute will serve as its identifier:
* * In the vertex shader as an `attribute` by prefixing it with `a_`
* * In the fragment shader as a `varying` by prefixing it with `v_`
* Please note that these can only be numerical values.
* @property {string} vertexShader Vertex shader source, mandatory.
* @property {string} fragmentShader Fragment shader source, mandatory.
* @property {string} [hitVertexShader] Vertex shader source for hit detection rendering.
* @property {string} [hitFragmentShader] Fragment shader source for hit detection rendering.
* @property {Object<string,import("../../webgl/Helper").UniformValue>} [uniforms] Uniform definitions for the post process steps
* Please note that `u_texture` is reserved for the main texture slot and `u_opacity` is reserved for the layer opacity.
* @property {Array<import("./Layer").PostProcessesOptions>} [postProcesses] Post-processes definitions
*/
/**
* @classdesc
* WebGL vector renderer optimized for points.
* All features will be rendered as quads (two triangles forming a square). New data will be flushed to the GPU
* every time the vector source changes.
*
* You need to provide vertex and fragment shaders for rendering. This can be done using
* {@link module:ol/webgl/ShaderBuilder~ShaderBuilder} utilities. These shaders shall expect a `a_position` attribute
* containing the screen-space projected center of the quad, as well as a `a_index` attribute
* whose value (0, 1, 2 or 3) indicates which quad vertex is currently getting processed (see structure below).
*
* To include variable attributes in the shaders, you need to declare them using the `attributes` property of
* the options object like so:
* ```js
* new WebGLPointsLayerRenderer(layer, {
* attributes: [
* {
* name: 'size',
* callback: function(feature) {
* // compute something with the feature
* }
* },
* {
* name: 'weight',
* callback: function(feature) {
* // compute something with the feature
* }
* },
* ],
* vertexShader:
* // shader using attribute a_weight and a_size
* fragmentShader:
* // shader using varying v_weight and v_size
* ```
*
* To enable hit detection, you must as well provide dedicated shaders using the `hitVertexShader`
* and `hitFragmentShader` properties. These shall expect the `a_hitColor` attribute to contain
* the final color that will have to be output for hit detection to work.
*
* The following uniform is used for the main texture: `u_texture`.
* The following uniform is used for the layer opacity: `u_opacity`.
*
* Please note that the main shader output should have premultiplied alpha, otherwise visual anomalies may occur.
*
* Points are rendered as quads with the following structure:
*
* ```
* (u0, v1) (u1, v1)
* [3]----------[2]
* |` |
* | ` |
* | ` |
* | ` |
* | ` |
* | ` |
* [0]----------[1]
* (u0, v0) (u1, v0)
* ```
*
* This uses {@link module:ol/webgl/Helper~WebGLHelper} internally.
*
* @api
*/
declare class WebGLPointsLayerRenderer extends WebGLLayerRenderer<any> {
/**
* @param {import("../../layer/Layer.js").default} layer Layer.
* @param {Options} options Options.
*/
constructor(layer: import("../../layer/Layer.js").default, options: Options);
sourceRevision_: number;
verticesBuffer_: WebGLArrayBuffer;
hitVerticesBuffer_: WebGLArrayBuffer;
indicesBuffer_: WebGLArrayBuffer;
/**
* @private
*/
private vertexShader_;
/**
* @private
*/
private fragmentShader_;
/**
* @type {WebGLProgram}
* @private
*/
private program_;
/**
* @type {boolean}
* @private
*/
private hitDetectionEnabled_;
/**
* @private
*/
private hitVertexShader_;
/**
* @private
*/
private hitFragmentShader_;
/**
* @type {WebGLProgram}
* @private
*/
private hitProgram_;
/**
* A list of attributes used by the renderer. By default only the position and
* index of the vertex (0 to 3) are required.
* @type {Array<import('../../webgl/Helper.js').AttributeDescription>}
*/
attributes: Array<import('../../webgl/Helper.js').AttributeDescription>;
/**
* A list of attributes used for hit detection.
* @type {Array<import('../../webgl/Helper.js').AttributeDescription>}
*/
hitDetectionAttributes: Array<import('../../webgl/Helper.js').AttributeDescription>;
customAttributes: CustomAttribute[];
previousExtent_: import("../../extent.js").Extent;
/**
* 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 currentTransform_;
/**
* This transform is updated when buffers are rebuilt and converts world space coordinates to screen space
* @type {import("../../transform.js").Transform}
* @private
*/
private renderTransform_;
/**
* @type {import("../../transform.js").Transform}
* @private
*/
private invertRenderTransform_;
/**
* @type {Float32Array}
* @private
*/
private renderInstructions_;
/**
* These instructions are used for hit detection
* @type {Float32Array}
* @private
*/
private hitRenderInstructions_;
/**
* @type {WebGLRenderTarget}
* @private
*/
private hitRenderTarget_;
/**
* Keep track of latest message sent to worker
* @type {number}
* @private
*/
private generateBuffersRun_;
worker_: Worker;
/**
* This object will be updated when the source changes. Key is uid.
* @type {Object<string, FeatureCacheItem>}
* @private
*/
private featureCache_;
/**
* Amount of features in the cache.
* @type {number}
* @private
*/
private featureCount_;
sourceListenKeys_: import("../../events.js").EventsKey[];
/**
* @param {import("../../source/Vector.js").VectorSourceEvent} event Event.
* @private
*/
private handleSourceFeatureAdded_;
/**
* @param {import("../../source/Vector.js").VectorSourceEvent} event Event.
* @private
*/
private handleSourceFeatureChanged_;
/**
* @param {import("../../source/Vector.js").VectorSourceEvent} event Event.
* @private
*/
private handleSourceFeatureDelete_;
/**
* @private
*/
private handleSourceFeatureClear_;
/**
* Render the layer.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @return {HTMLElement} The rendered element.
*/
renderFrame(frameState: import("../../PluggableMap.js").FrameState): HTMLElement;
/**
* Rebuild internal webgl buffers based on current view extent; costly, should not be called too much
* @param {import("../../PluggableMap").FrameState} frameState Frame state.
* @private
*/
private rebuildBuffers_;
/**
* Render the hit detection data to the corresponding render target
* @param {import("../../PluggableMap.js").FrameState} frameState current frame state
* @param {number} startWorld the world to render in the first iteration
* @param {number} endWorld the last world to render
* @param {number} worldWidth the width of the worlds being rendered
*/
renderHitDetection(frameState: import("../../PluggableMap.js").FrameState, startWorld: number, endWorld: number, worldWidth: number): void;
}
import WebGLLayerRenderer from "./Layer.js";
import WebGLArrayBuffer from "../../webgl/Buffer.js";
//# sourceMappingURL=PointsLayer.d.ts.map

1
node_modules/ol/renderer/webgl/PointsLayer.d.ts.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"PointsLayer.d.ts","sourceRoot":"","sources":["../../src/renderer/webgl/PointsLayer.js"],"names":[],"mappings":";;;;;;;;;UA+Bc,MAAM;;;;;qBACG,OAAO,eAAe,EAAE,OAAO;YAAS,MAAM;UAAM,MAAM;;;;;;;;;;aAOnE,OAAO,eAAe,EAAE,OAAO;;;;;YACxB,MAAM;;;;;cACb,OAAO,YAAY,EAAE,QAAQ;;;;;;;;;;;;;;;;;;kBAW7B,MAAM;;;;oBACN,MAAM;;;;;;;;;;;;;;;;;;;;;AAzBpB;;;;;;GAMG;AAEH;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;GAeG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH;IACE;;;OAGG;IACH,mBAHW,OAAO,sBAAsB,EAAE,OAAO,WACtC,OAAO,EAwQjB;IA1PC,wBAAyB;IAEzB,kCAAuE;IACvE,qCAA0E;IAC1E,iCAGC;IAED;;OAEG;IACH,sBAAyC;IAEzC;;OAEG;IACH,wBAA6C;IAE7C;;;OAGG;IACH,iBAAa;IAEb;;;OAGG;IACH,6BACqE;IAErE;;OAEG;IACH,yBAA+C;IAE/C;;OAEG;IACH,2BAAmD;IAEnD;;;OAGG;IACH,oBAAgB;IAYhB;;;;OAIG;IACH,YAFU,MAAM,OAAO,uBAAuB,EAAE,oBAAoB,CAAC,CAa3C;IAE1B;;;OAGG;IACH,wBAFU,MAAM,OAAO,uBAAuB,EAAE,oBAAoB,CAAC,CAuB3C;IAE1B,oCAAoE;IAEpE,kDAAoC;IAEpC;;;;;;OAMG;IACH,0BAAkD;IAElD;;;;OAIG;IACH,yBAAyC;IAEzC;;;OAGG;IACH,+BAA+C;IAE/C;;;OAGG;IACH,4BAA8C;IAE9C;;;;OAIG;IACH,+BAAiD;IAEjD;;;OAGG;IACH,yBAAqB;IAErB;;;;OAIG;IACH,4BAA4B;IAE5B,gBAAkC;IA4ClC;;;;OAIG;IACH,sBAAuB;IAEvB;;;;OAIG;IACH,sBAAsB;IAGtB,yDAyBC;IA6BH;;;OAGG;IACH,kCAQC;IAED;;;OAGG;IACH,oCAOC;IAED;;;OAGG;IACH,mCAIC;IAED;;OAEG;IACH,kCAGC;IAED;;;;OAIG;IACH,wBAHW,OAAO,uBAAuB,EAAE,UAAU,GACzC,WAAW,CAmDtB;IA6CD;;;;OAIG;IACH,wBA4GC;IA0CD;;;;;;OAMG;IACH,+BALW,OAAO,uBAAuB,EAAE,UAAU,cAC1C,MAAM,YACN,MAAM,cACN,MAAM,QAmChB;CAcF"}

623
node_modules/ol/renderer/webgl/PointsLayer.js generated vendored Normal file
View File

@@ -0,0 +1,623 @@
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
/**
* @module ol/renderer/webgl/PointsLayer
*/
import BaseVector from '../../layer/BaseVector.js';
import VectorEventType from '../../source/VectorEventType.js';
import ViewHint from '../../ViewHint.js';
import WebGLArrayBuffer from '../../webgl/Buffer.js';
import WebGLLayerRenderer, { WebGLWorkerMessageType, colorDecodeId, colorEncodeId, } from './Layer.js';
import WebGLRenderTarget from '../../webgl/RenderTarget.js';
import { ARRAY_BUFFER, DYNAMIC_DRAW, ELEMENT_ARRAY_BUFFER } from '../../webgl.js';
import { AttributeType, DefaultUniform } from '../../webgl/Helper.js';
import { apply as applyTransform, create as createTransform, makeInverse as makeInverseTransform, multiply as multiplyTransform, translate as translateTransform, } from '../../transform.js';
import { assert } from '../../asserts.js';
import { buffer, createEmpty, equals, getWidth } from '../../extent.js';
import { create as createWebGLWorker } from '../../worker/webgl.js';
import { getUid } from '../../util.js';
import { listen, unlistenByKey } from '../../events.js';
/**
* @typedef {Object} CustomAttribute A description of a custom attribute to be passed on to the GPU, with a value different
* for each feature.
* @property {string} name Attribute name.
* @property {function(import("../../Feature").default, Object<string, *>):number} callback This callback computes the numerical value of the
* attribute for a given feature (properties are available as 2nd arg for quicker access).
*/
/**
* @typedef {Object} FeatureCacheItem Object that holds a reference to a feature, its geometry and properties. Used to optimize
* rebuildBuffers by accessing these objects quicker.
* @property {import("../../Feature").default} feature Feature
* @property {Object<string, *>} properties Feature properties
* @property {import("../../geom").Geometry} geometry Feature geometry
*/
/**
* @typedef {Object} Options
* @property {string} [className='ol-layer'] A CSS class name to set to the canvas element.
* @property {Array<CustomAttribute>} [attributes] These attributes will be read from the features in the source and then
* passed to the GPU. The `name` property of each attribute will serve as its identifier:
* * In the vertex shader as an `attribute` by prefixing it with `a_`
* * In the fragment shader as a `varying` by prefixing it with `v_`
* Please note that these can only be numerical values.
* @property {string} vertexShader Vertex shader source, mandatory.
* @property {string} fragmentShader Fragment shader source, mandatory.
* @property {string} [hitVertexShader] Vertex shader source for hit detection rendering.
* @property {string} [hitFragmentShader] Fragment shader source for hit detection rendering.
* @property {Object<string,import("../../webgl/Helper").UniformValue>} [uniforms] Uniform definitions for the post process steps
* Please note that `u_texture` is reserved for the main texture slot and `u_opacity` is reserved for the layer opacity.
* @property {Array<import("./Layer").PostProcessesOptions>} [postProcesses] Post-processes definitions
*/
/**
* @classdesc
* WebGL vector renderer optimized for points.
* All features will be rendered as quads (two triangles forming a square). New data will be flushed to the GPU
* every time the vector source changes.
*
* You need to provide vertex and fragment shaders for rendering. This can be done using
* {@link module:ol/webgl/ShaderBuilder~ShaderBuilder} utilities. These shaders shall expect a `a_position` attribute
* containing the screen-space projected center of the quad, as well as a `a_index` attribute
* whose value (0, 1, 2 or 3) indicates which quad vertex is currently getting processed (see structure below).
*
* To include variable attributes in the shaders, you need to declare them using the `attributes` property of
* the options object like so:
* ```js
* new WebGLPointsLayerRenderer(layer, {
* attributes: [
* {
* name: 'size',
* callback: function(feature) {
* // compute something with the feature
* }
* },
* {
* name: 'weight',
* callback: function(feature) {
* // compute something with the feature
* }
* },
* ],
* vertexShader:
* // shader using attribute a_weight and a_size
* fragmentShader:
* // shader using varying v_weight and v_size
* ```
*
* To enable hit detection, you must as well provide dedicated shaders using the `hitVertexShader`
* and `hitFragmentShader` properties. These shall expect the `a_hitColor` attribute to contain
* the final color that will have to be output for hit detection to work.
*
* The following uniform is used for the main texture: `u_texture`.
* The following uniform is used for the layer opacity: `u_opacity`.
*
* Please note that the main shader output should have premultiplied alpha, otherwise visual anomalies may occur.
*
* Points are rendered as quads with the following structure:
*
* ```
* (u0, v1) (u1, v1)
* [3]----------[2]
* |` |
* | ` |
* | ` |
* | ` |
* | ` |
* | ` |
* [0]----------[1]
* (u0, v0) (u1, v0)
* ```
*
* This uses {@link module:ol/webgl/Helper~WebGLHelper} internally.
*
* @api
*/
var WebGLPointsLayerRenderer = /** @class */ (function (_super) {
__extends(WebGLPointsLayerRenderer, _super);
/**
* @param {import("../../layer/Layer.js").default} layer Layer.
* @param {Options} options Options.
*/
function WebGLPointsLayerRenderer(layer, options) {
var _this = this;
var uniforms = options.uniforms || {};
var projectionMatrixTransform = createTransform();
uniforms[DefaultUniform.PROJECTION_MATRIX] = projectionMatrixTransform;
_this = _super.call(this, layer, {
uniforms: uniforms,
postProcesses: options.postProcesses,
}) || this;
_this.ready = false;
_this.sourceRevision_ = -1;
_this.verticesBuffer_ = new WebGLArrayBuffer(ARRAY_BUFFER, DYNAMIC_DRAW);
_this.hitVerticesBuffer_ = new WebGLArrayBuffer(ARRAY_BUFFER, DYNAMIC_DRAW);
_this.indicesBuffer_ = new WebGLArrayBuffer(ELEMENT_ARRAY_BUFFER, DYNAMIC_DRAW);
/**
* @private
*/
_this.vertexShader_ = options.vertexShader;
/**
* @private
*/
_this.fragmentShader_ = options.fragmentShader;
/**
* @type {WebGLProgram}
* @private
*/
_this.program_;
/**
* @type {boolean}
* @private
*/
_this.hitDetectionEnabled_ =
options.hitFragmentShader && options.hitVertexShader ? true : false;
/**
* @private
*/
_this.hitVertexShader_ = options.hitVertexShader;
/**
* @private
*/
_this.hitFragmentShader_ = options.hitFragmentShader;
/**
* @type {WebGLProgram}
* @private
*/
_this.hitProgram_;
var customAttributes = options.attributes
? options.attributes.map(function (attribute) {
return {
name: 'a_' + attribute.name,
size: 1,
type: AttributeType.FLOAT,
};
})
: [];
/**
* A list of attributes used by the renderer. By default only the position and
* index of the vertex (0 to 3) are required.
* @type {Array<import('../../webgl/Helper.js').AttributeDescription>}
*/
_this.attributes = [
{
name: 'a_position',
size: 2,
type: AttributeType.FLOAT,
},
{
name: 'a_index',
size: 1,
type: AttributeType.FLOAT,
},
].concat(customAttributes);
/**
* A list of attributes used for hit detection.
* @type {Array<import('../../webgl/Helper.js').AttributeDescription>}
*/
_this.hitDetectionAttributes = [
{
name: 'a_position',
size: 2,
type: AttributeType.FLOAT,
},
{
name: 'a_index',
size: 1,
type: AttributeType.FLOAT,
},
{
name: 'a_hitColor',
size: 4,
type: AttributeType.FLOAT,
},
{
name: 'a_featureUid',
size: 1,
type: AttributeType.FLOAT,
},
].concat(customAttributes);
_this.customAttributes = options.attributes ? options.attributes : [];
_this.previousExtent_ = createEmpty();
/**
* 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
*/
_this.currentTransform_ = projectionMatrixTransform;
/**
* This transform is updated when buffers are rebuilt and converts world space coordinates to screen space
* @type {import("../../transform.js").Transform}
* @private
*/
_this.renderTransform_ = createTransform();
/**
* @type {import("../../transform.js").Transform}
* @private
*/
_this.invertRenderTransform_ = createTransform();
/**
* @type {Float32Array}
* @private
*/
_this.renderInstructions_ = new Float32Array(0);
/**
* These instructions are used for hit detection
* @type {Float32Array}
* @private
*/
_this.hitRenderInstructions_ = new Float32Array(0);
/**
* @type {WebGLRenderTarget}
* @private
*/
_this.hitRenderTarget_;
/**
* Keep track of latest message sent to worker
* @type {number}
* @private
*/
_this.generateBuffersRun_ = 0;
_this.worker_ = createWebGLWorker();
_this.worker_.addEventListener('message',
/**
* @param {*} event Event.
* @this {WebGLPointsLayerRenderer}
*/
function (event) {
var received = event.data;
if (received.type === WebGLWorkerMessageType.GENERATE_BUFFERS) {
var projectionTransform = received.projectionTransform;
if (received.hitDetection) {
this.hitVerticesBuffer_.fromArrayBuffer(received.vertexBuffer);
this.helper.flushBufferData(this.hitVerticesBuffer_);
}
else {
this.verticesBuffer_.fromArrayBuffer(received.vertexBuffer);
this.helper.flushBufferData(this.verticesBuffer_);
}
this.indicesBuffer_.fromArrayBuffer(received.indexBuffer);
this.helper.flushBufferData(this.indicesBuffer_);
this.renderTransform_ = projectionTransform;
makeInverseTransform(this.invertRenderTransform_, this.renderTransform_);
if (received.hitDetection) {
this.hitRenderInstructions_ = new Float32Array(event.data.renderInstructions);
}
else {
this.renderInstructions_ = new Float32Array(event.data.renderInstructions);
if (received.generateBuffersRun === this.generateBuffersRun_) {
this.ready = true;
}
}
this.getLayer().changed();
}
}.bind(_this));
/**
* This object will be updated when the source changes. Key is uid.
* @type {Object<string, FeatureCacheItem>}
* @private
*/
_this.featureCache_ = {};
/**
* Amount of features in the cache.
* @type {number}
* @private
*/
_this.featureCount_ = 0;
var source = _this.getLayer().getSource();
_this.sourceListenKeys_ = [
listen(source, VectorEventType.ADDFEATURE, _this.handleSourceFeatureAdded_, _this),
listen(source, VectorEventType.CHANGEFEATURE, _this.handleSourceFeatureChanged_, _this),
listen(source, VectorEventType.REMOVEFEATURE, _this.handleSourceFeatureDelete_, _this),
listen(source, VectorEventType.CLEAR, _this.handleSourceFeatureClear_, _this),
];
source.forEachFeature(function (feature) {
this.featureCache_[getUid(feature)] = {
feature: feature,
properties: feature.getProperties(),
geometry: feature.getGeometry(),
};
this.featureCount_++;
}.bind(_this));
return _this;
}
WebGLPointsLayerRenderer.prototype.afterHelperCreated = function () {
this.program_ = this.helper.getProgram(this.fragmentShader_, this.vertexShader_);
if (this.hitDetectionEnabled_) {
this.hitProgram_ = this.helper.getProgram(this.hitFragmentShader_, this.hitVertexShader_);
this.hitRenderTarget_ = new WebGLRenderTarget(this.helper);
}
};
/**
* @param {import("../../source/Vector.js").VectorSourceEvent} event Event.
* @private
*/
WebGLPointsLayerRenderer.prototype.handleSourceFeatureAdded_ = function (event) {
var feature = event.feature;
this.featureCache_[getUid(feature)] = {
feature: feature,
properties: feature.getProperties(),
geometry: feature.getGeometry(),
};
this.featureCount_++;
};
/**
* @param {import("../../source/Vector.js").VectorSourceEvent} event Event.
* @private
*/
WebGLPointsLayerRenderer.prototype.handleSourceFeatureChanged_ = function (event) {
var feature = event.feature;
this.featureCache_[getUid(feature)] = {
feature: feature,
properties: feature.getProperties(),
geometry: feature.getGeometry(),
};
};
/**
* @param {import("../../source/Vector.js").VectorSourceEvent} event Event.
* @private
*/
WebGLPointsLayerRenderer.prototype.handleSourceFeatureDelete_ = function (event) {
var feature = event.feature;
delete this.featureCache_[getUid(feature)];
this.featureCount_--;
};
/**
* @private
*/
WebGLPointsLayerRenderer.prototype.handleSourceFeatureClear_ = function () {
this.featureCache_ = {};
this.featureCount_ = 0;
};
/**
* Render the layer.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @return {HTMLElement} The rendered element.
*/
WebGLPointsLayerRenderer.prototype.renderFrame = function (frameState) {
var gl = this.helper.getGL();
this.preRender(gl, frameState);
var projection = frameState.viewState.projection;
var layer = this.getLayer();
var vectorSource = layer.getSource();
// FIXME fix hit detection isn't reliable when rendering multiple worlds
var multiWorld = vectorSource.getWrapX() && projection.canWrapX();
var projectionExtent = projection.getExtent();
var extent = frameState.extent;
var worldWidth = multiWorld ? getWidth(projectionExtent) : null;
var endWorld = multiWorld
? Math.ceil((extent[2] - projectionExtent[2]) / worldWidth) + 1
: 1;
var startWorld = multiWorld
? Math.floor((extent[0] - projectionExtent[0]) / worldWidth)
: 0;
var world = startWorld;
var renderCount = this.indicesBuffer_.getSize();
do {
// apply the current projection transform with the invert of the one used to fill buffers
this.helper.makeProjectionTransform(frameState, this.currentTransform_);
translateTransform(this.currentTransform_, world * worldWidth, 0);
multiplyTransform(this.currentTransform_, this.invertRenderTransform_);
this.helper.applyUniforms(frameState);
this.helper.drawElements(0, renderCount);
} while (++world < endWorld);
this.helper.finalizeDraw(frameState, this.dispatchPreComposeEvent, this.dispatchPostComposeEvent);
var canvas = this.helper.getCanvas();
if (this.hitDetectionEnabled_) {
this.renderHitDetection(frameState, startWorld, endWorld, worldWidth);
this.hitRenderTarget_.clearCachedData();
}
this.postRender(gl, frameState);
return canvas;
};
/**
* Determine whether renderFrame should be called.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @return {boolean} Layer is ready to be rendered.
*/
WebGLPointsLayerRenderer.prototype.prepareFrameInternal = function (frameState) {
var layer = this.getLayer();
var vectorSource = layer.getSource();
var viewState = frameState.viewState;
var viewNotMoving = !frameState.viewHints[ViewHint.ANIMATING] &&
!frameState.viewHints[ViewHint.INTERACTING];
var extentChanged = !equals(this.previousExtent_, frameState.extent);
var sourceChanged = this.sourceRevision_ < vectorSource.getRevision();
if (sourceChanged) {
this.sourceRevision_ = vectorSource.getRevision();
}
if (viewNotMoving && (extentChanged || sourceChanged)) {
var projection = viewState.projection;
var resolution = viewState.resolution;
var renderBuffer = layer instanceof BaseVector ? layer.getRenderBuffer() : 0;
var extent = buffer(frameState.extent, renderBuffer * resolution);
vectorSource.loadFeatures(extent, resolution, projection);
this.rebuildBuffers_(frameState);
this.previousExtent_ = frameState.extent.slice();
}
this.helper.useProgram(this.program_);
this.helper.prepareDraw(frameState);
// write new data
this.helper.bindBuffer(this.verticesBuffer_);
this.helper.bindBuffer(this.indicesBuffer_);
this.helper.enableAttributes(this.attributes);
return true;
};
/**
* Rebuild internal webgl buffers based on current view extent; costly, should not be called too much
* @param {import("../../PluggableMap").FrameState} frameState Frame state.
* @private
*/
WebGLPointsLayerRenderer.prototype.rebuildBuffers_ = function (frameState) {
// saves the projection transform for the current frame state
var projectionTransform = createTransform();
this.helper.makeProjectionTransform(frameState, projectionTransform);
// here we anticipate the amount of render instructions that we well generate
// this can be done since we know that for normal render we only have x, y as base instructions,
// and x, y, r, g, b, a and featureUid for hit render instructions
// and we also know the amount of custom attributes to append to these
var totalInstructionsCount = (2 + this.customAttributes.length) * this.featureCount_;
if (!this.renderInstructions_ ||
this.renderInstructions_.length !== totalInstructionsCount) {
this.renderInstructions_ = new Float32Array(totalInstructionsCount);
}
if (this.hitDetectionEnabled_) {
var totalHitInstructionsCount = (7 + this.customAttributes.length) * this.featureCount_;
if (!this.hitRenderInstructions_ ||
this.hitRenderInstructions_.length !== totalHitInstructionsCount) {
this.hitRenderInstructions_ = new Float32Array(totalHitInstructionsCount);
}
}
// loop on features to fill the buffer
var featureCache, geometry;
var tmpCoords = [];
var tmpColor = [];
var renderIndex = 0;
var hitIndex = 0;
var hitColor;
for (var featureUid in this.featureCache_) {
featureCache = this.featureCache_[featureUid];
geometry = /** @type {import("../../geom").Point} */ (featureCache.geometry);
if (!geometry || geometry.getType() !== 'Point') {
continue;
}
tmpCoords[0] = geometry.getFlatCoordinates()[0];
tmpCoords[1] = geometry.getFlatCoordinates()[1];
applyTransform(projectionTransform, tmpCoords);
hitColor = colorEncodeId(hitIndex + 6, tmpColor);
this.renderInstructions_[renderIndex++] = tmpCoords[0];
this.renderInstructions_[renderIndex++] = tmpCoords[1];
// for hit detection, the feature uid is saved in the opacity value
// and the index of the opacity value is encoded in the color values
if (this.hitDetectionEnabled_) {
this.hitRenderInstructions_[hitIndex++] = tmpCoords[0];
this.hitRenderInstructions_[hitIndex++] = tmpCoords[1];
this.hitRenderInstructions_[hitIndex++] = hitColor[0];
this.hitRenderInstructions_[hitIndex++] = hitColor[1];
this.hitRenderInstructions_[hitIndex++] = hitColor[2];
this.hitRenderInstructions_[hitIndex++] = hitColor[3];
this.hitRenderInstructions_[hitIndex++] = Number(featureUid);
}
// pushing custom attributes
var value = void 0;
for (var j = 0; j < this.customAttributes.length; j++) {
value = this.customAttributes[j].callback(featureCache.feature, featureCache.properties);
this.renderInstructions_[renderIndex++] = value;
if (this.hitDetectionEnabled_) {
this.hitRenderInstructions_[hitIndex++] = value;
}
}
}
/** @type {import('./Layer').WebGLWorkerGenerateBuffersMessage} */
var message = {
type: WebGLWorkerMessageType.GENERATE_BUFFERS,
renderInstructions: this.renderInstructions_.buffer,
customAttributesCount: this.customAttributes.length,
};
// additional properties will be sent back as-is by the worker
message['projectionTransform'] = projectionTransform;
message['generateBuffersRun'] = ++this.generateBuffersRun_;
this.ready = false;
this.worker_.postMessage(message, [this.renderInstructions_.buffer]);
this.renderInstructions_ = null;
/** @type {import('./Layer').WebGLWorkerGenerateBuffersMessage} */
if (this.hitDetectionEnabled_) {
var hitMessage = {
type: WebGLWorkerMessageType.GENERATE_BUFFERS,
renderInstructions: this.hitRenderInstructions_.buffer,
customAttributesCount: 5 + this.customAttributes.length,
};
hitMessage['projectionTransform'] = projectionTransform;
hitMessage['hitDetection'] = true;
this.worker_.postMessage(hitMessage, [
this.hitRenderInstructions_.buffer,
]);
this.hitRenderInstructions_ = null;
}
};
/**
* @param {import("../../coordinate.js").Coordinate} coordinate Coordinate.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @param {number} hitTolerance Hit tolerance in pixels.
* @param {import("../vector.js").FeatureCallback<T>} callback Feature callback.
* @param {Array<import("../Map.js").HitMatch<T>>} matches The hit detected matches with tolerance.
* @return {T|undefined} Callback result.
* @template T
*/
WebGLPointsLayerRenderer.prototype.forEachFeatureAtCoordinate = function (coordinate, frameState, hitTolerance, callback, matches) {
assert(this.hitDetectionEnabled_, 66);
if (!this.hitRenderInstructions_) {
return undefined;
}
var pixel = applyTransform(frameState.coordinateToPixelTransform, coordinate.slice());
var data = this.hitRenderTarget_.readPixel(pixel[0] / 2, pixel[1] / 2);
var color = [data[0] / 255, data[1] / 255, data[2] / 255, data[3] / 255];
var index = colorDecodeId(color);
var opacity = this.hitRenderInstructions_[index];
var uid = Math.floor(opacity).toString();
var source = this.getLayer().getSource();
var feature = source.getFeatureByUid(uid);
if (feature) {
return callback(feature, this.getLayer(), null);
}
return undefined;
};
/**
* Render the hit detection data to the corresponding render target
* @param {import("../../PluggableMap.js").FrameState} frameState current frame state
* @param {number} startWorld the world to render in the first iteration
* @param {number} endWorld the last world to render
* @param {number} worldWidth the width of the worlds being rendered
*/
WebGLPointsLayerRenderer.prototype.renderHitDetection = function (frameState, startWorld, endWorld, worldWidth) {
// skip render entirely if vertex buffers not ready/generated yet
if (!this.hitVerticesBuffer_.getSize()) {
return;
}
var world = startWorld;
this.hitRenderTarget_.setSize([
Math.floor(frameState.size[0] / 2),
Math.floor(frameState.size[1] / 2),
]);
this.helper.useProgram(this.hitProgram_);
this.helper.prepareDrawToRenderTarget(frameState, this.hitRenderTarget_, true);
this.helper.bindBuffer(this.hitVerticesBuffer_);
this.helper.bindBuffer(this.indicesBuffer_);
this.helper.enableAttributes(this.hitDetectionAttributes);
do {
this.helper.makeProjectionTransform(frameState, this.currentTransform_);
translateTransform(this.currentTransform_, world * worldWidth, 0);
multiplyTransform(this.currentTransform_, this.invertRenderTransform_);
this.helper.applyUniforms(frameState);
var renderCount = this.indicesBuffer_.getSize();
this.helper.drawElements(0, renderCount);
} while (++world < endWorld);
};
/**
* Clean up.
*/
WebGLPointsLayerRenderer.prototype.disposeInternal = function () {
this.worker_.terminate();
this.layer_ = null;
this.sourceListenKeys_.forEach(function (key) {
unlistenByKey(key);
});
this.sourceListenKeys_ = null;
_super.prototype.disposeInternal.call(this);
};
return WebGLPointsLayerRenderer;
}(WebGLLayerRenderer));
export default WebGLPointsLayerRenderer;
//# sourceMappingURL=PointsLayer.js.map

1
node_modules/ol/renderer/webgl/PointsLayer.js.map generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

191
node_modules/ol/renderer/webgl/TileLayer.d.ts generated vendored Normal file
View File

@@ -0,0 +1,191 @@
export namespace Uniforms {
const TILE_TEXTURE_ARRAY: string;
const TILE_TRANSFORM: string;
const TRANSITION_ALPHA: string;
const DEPTH: string;
const TEXTURE_PIXEL_WIDTH: string;
const TEXTURE_PIXEL_HEIGHT: string;
const TEXTURE_RESOLUTION: string;
const TEXTURE_ORIGIN_X: string;
const TEXTURE_ORIGIN_Y: string;
const RENDER_EXTENT: string;
const RESOLUTION: string;
const ZOOM: string;
}
export namespace Attributes {
const TEXTURE_COORD: string;
}
export default WebGLTileLayerRenderer;
export type Options = {
/**
* Vertex shader source.
*/
vertexShader: string;
/**
* Fragment shader source.
*/
fragmentShader: string;
/**
* Additional uniforms
* made available to shaders.
*/
uniforms?: {
[x: string]: import("../../webgl/Helper.js").UniformValue;
} | undefined;
/**
* Palette textures.
*/
paletteTextures?: import("../../webgl/PaletteTexture.js").default[] | undefined;
/**
* The texture cache size.
*/
cacheSize?: number | undefined;
};
export type LayerType = import("../../layer/WebGLTile.js").default;
/**
* @typedef {Object} Options
* @property {string} vertexShader Vertex shader source.
* @property {string} fragmentShader Fragment shader source.
* @property {Object<string, import("../../webgl/Helper").UniformValue>} [uniforms] Additional uniforms
* made available to shaders.
* @property {Array<import("../../webgl/PaletteTexture.js").default>} [paletteTextures] Palette textures.
* @property {number} [cacheSize=512] The texture cache size.
*/
/**
* @typedef {import("../../layer/WebGLTile.js").default} LayerType
*/
/**
* @classdesc
* WebGL renderer for tile layers.
* @extends {WebGLLayerRenderer<LayerType>}
* @api
*/
declare class WebGLTileLayerRenderer extends WebGLLayerRenderer<import("../../layer/WebGLTile.js").default> {
/**
* @param {LayerType} tileLayer Tile layer.
* @param {Options} options Options.
*/
constructor(tileLayer: LayerType, options: Options);
/**
* The last call to `renderFrame` was completed with all tiles loaded
* @type {boolean}
*/
renderComplete: boolean;
/**
* This transform converts texture coordinates to screen coordinates.
* @type {import("../../transform.js").Transform}
* @private
*/
private tileTransform_;
/**
* @type {Array<number>}
* @private
*/
private tempMat4_;
/**
* @type {import("../../TileRange.js").default}
* @private
*/
private tempTileRange_;
/**
* @type {import("../../tilecoord.js").TileCoord}
* @private
*/
private tempTileCoord_;
/**
* @type {import("../../size.js").Size}
* @private
*/
private tempSize_;
/**
* @type {WebGLProgram}
* @private
*/
private program_;
/**
* @private
*/
private vertexShader_;
/**
* @private
*/
private fragmentShader_;
/**
* Tiles are rendered as a quad with the following structure:
*
* [P3]---------[P2]
* |` |
* | ` B |
* | ` |
* | ` |
* | A ` |
* | ` |
* [P0]---------[P1]
*
* Triangle A: P0, P1, P3
* Triangle B: P1, P2, P3
*
* @private
*/
private indices_;
/**
* @type {import("../../structs/LRUCache.js").default<import("../../webgl/TileTexture.js").default>}
* @private
*/
private tileTextureCache_;
/**
* @type {Array<import("../../webgl/PaletteTexture.js").default>}
* @private
*/
private paletteTextures_;
/**
* @private
* @type {import("../../PluggableMap.js").FrameState|null}
*/
private frameState_;
/**
* @param {Options} options Options.
*/
reset(options: Options): void;
/**
* @param {import("../../webgl/TileTexture").TileType} tile Tile.
* @return {boolean} Tile is drawable.
* @private
*/
private isDrawableTile_;
/**
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @param {import("../../extent.js").Extent} extent The extent to be rendered.
* @param {number} initialZ The zoom level.
* @param {Object<number, Array<TileTexture>>} tileTexturesByZ The zoom level.
*/
enqueueTiles(frameState: import("../../PluggableMap.js").FrameState, extent: import("../../extent.js").Extent, initialZ: number, tileTexturesByZ: {
[x: number]: Array<TileTexture>;
}): void;
/**
* Render the layer.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @return {HTMLElement} The rendered element.
*/
renderFrame(frameState: import("../../PluggableMap.js").FrameState): HTMLElement;
/**
* @param {import("../../pixel.js").Pixel} pixel Pixel.
* @return {Uint8ClampedArray|Uint8Array|Float32Array|DataView} Data at the pixel location.
*/
getData(pixel: import("../../pixel.js").Pixel): Uint8ClampedArray | Uint8Array | Float32Array | DataView;
/**
* Look for tiles covering the provided tile coordinate at an alternate
* zoom level. Loaded tiles will be added to the provided tile texture lookup.
* @param {import("../../tilegrid/TileGrid.js").default} tileGrid The tile grid.
* @param {import("../../tilecoord.js").TileCoord} tileCoord The target tile coordinate.
* @param {number} altZ The alternate zoom level.
* @param {Object<number, Array<import("../../webgl/TileTexture.js").default>>} tileTexturesByZ Lookup of
* tile textures by zoom level.
* @return {boolean} The tile coordinate is covered by loaded tiles at the alternate zoom level.
* @private
*/
private findAltTiles_;
}
import WebGLLayerRenderer from "./Layer.js";
import TileTexture from "../../webgl/TileTexture.js";
//# sourceMappingURL=TileLayer.d.ts.map

1
node_modules/ol/renderer/webgl/TileLayer.d.ts.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"TileLayer.d.ts","sourceRoot":"","sources":["../../src/renderer/webgl/TileLayer.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;kBAiIc,MAAM;;;;oBACN,MAAM;;;;;;;;;;;;;;;;;wBAQP,OAAO,0BAA0B,EAAE,OAAO;AAXvD;;;;;;;;GAQG;AAEH;;GAEG;AAEH;;;;;GAKG;AACH;IACE;;;OAGG;IACH,uBAHW,SAAS,WACT,OAAO,EAmGjB;IA5FC;;;OAGG;IACH,gBAFU,OAAO,CAEU;IAE3B;;;;OAIG;IACH,uBAAuC;IAEvC;;;OAGG;IACH,kBAA6B;IAE7B;;;OAGG;IACH,uBAA+C;IAE/C;;;OAGG;IACH,uBAA8C;IAE9C;;;OAGG;IACH,kBAAuB;IAEvB;;;OAGG;IACH,iBAAa;IAEb;;OAEG;IACH,sBAAyC;IAEzC;;OAEG;IACH,wBAA6C;IAE7C;;;;;;;;;;;;;;;;OAgBG;IACH,iBAAuE;IAKvE;;;OAGG;IACH,0BAAgD;IAEhD;;;OAGG;IACH,yBAAqD;IAErD;;;OAGG;IACH,oBAAuB;IAGzB;;OAEG;IACH,eAFW,OAAO,QAgBjB;IAWD;;;;OAIG;IACH,wBASC;IAoBD;;;;;OAKG;IACH,yBALW,OAAO,uBAAuB,EAAE,UAAU,UAC1C,OAAO,iBAAiB,EAAE,MAAM,YAChC,MAAM;YACC,MAAM,GAAE,MAAM,WAAW,CAAC;aA6F3C;IAED;;;;OAIG;IACH,wBAHW,OAAO,uBAAuB,EAAE,UAAU,GACzC,WAAW,CA4QtB;IAED;;;OAGG;IACH,eAHW,OAAO,gBAAgB,EAAE,KAAK,GAC7B,iBAAiB,GAAC,UAAU,GAAC,YAAY,GAAC,QAAQ,CAqF7D;IAED;;;;;;;;;;OAUG;IACH,sBA+BC;CA+BF"}

641
node_modules/ol/renderer/webgl/TileLayer.js generated vendored Normal file
View File

@@ -0,0 +1,641 @@
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
/**
* @module ol/renderer/webgl/TileLayer
*/
import LRUCache from '../../structs/LRUCache.js';
import TileRange from '../../TileRange.js';
import TileState from '../../TileState.js';
import TileTexture from '../../webgl/TileTexture.js';
import WebGLArrayBuffer from '../../webgl/Buffer.js';
import WebGLLayerRenderer from './Layer.js';
import { AttributeType } from '../../webgl/Helper.js';
import { ELEMENT_ARRAY_BUFFER, STATIC_DRAW } from '../../webgl.js';
import { apply as applyTransform, create as createTransform, reset as resetTransform, rotate as rotateTransform, scale as scaleTransform, translate as translateTransform, } from '../../transform.js';
import { boundingExtent, containsCoordinate, getIntersection, isEmpty, } from '../../extent.js';
import { create as createMat4, fromTransform as mat4FromTransform, } from '../../vec/mat4.js';
import { createOrUpdate as createTileCoord, getKey as getTileCoordKey, } from '../../tilecoord.js';
import { fromUserExtent } from '../../proj.js';
import { getUid } from '../../util.js';
import { numberSafeCompareFunction } from '../../array.js';
import { toSize } from '../../size.js';
export var Uniforms = {
TILE_TEXTURE_ARRAY: 'u_tileTextures',
TILE_TRANSFORM: 'u_tileTransform',
TRANSITION_ALPHA: 'u_transitionAlpha',
DEPTH: 'u_depth',
TEXTURE_PIXEL_WIDTH: 'u_texturePixelWidth',
TEXTURE_PIXEL_HEIGHT: 'u_texturePixelHeight',
TEXTURE_RESOLUTION: 'u_textureResolution',
TEXTURE_ORIGIN_X: 'u_textureOriginX',
TEXTURE_ORIGIN_Y: 'u_textureOriginY',
RENDER_EXTENT: 'u_renderExtent',
RESOLUTION: 'u_resolution',
ZOOM: 'u_zoom',
};
export var Attributes = {
TEXTURE_COORD: 'a_textureCoord',
};
/**
* @type {Array<import('../../webgl/Helper.js').AttributeDescription>}
*/
var attributeDescriptions = [
{
name: Attributes.TEXTURE_COORD,
size: 2,
type: AttributeType.FLOAT,
},
];
/**
* @type {Object<string, boolean>}
*/
var empty = {};
/**
* Transform a zoom level into a depth value ranging from -1 to 1.
* @param {number} z A zoom level.
* @return {number} A depth value.
*/
function depthForZ(z) {
return 2 * (1 - 1 / (z + 1)) - 1;
}
/**
* Add a tile texture to the lookup.
* @param {Object<number, Array<import("../../webgl/TileTexture.js").default>>} tileTexturesByZ Lookup of
* tile textures by zoom level.
* @param {import("../../webgl/TileTexture.js").default} tileTexture A tile texture.
* @param {number} z The zoom level.
*/
function addTileTextureToLookup(tileTexturesByZ, tileTexture, z) {
if (!(z in tileTexturesByZ)) {
tileTexturesByZ[z] = [];
}
tileTexturesByZ[z].push(tileTexture);
}
/**
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @param {import("../../extent.js").Extent} extent The frame extent.
* @return {import("../../extent.js").Extent} Frame extent intersected with layer extents.
*/
function getRenderExtent(frameState, extent) {
var layerState = frameState.layerStatesArray[frameState.layerIndex];
if (layerState.extent) {
extent = getIntersection(extent, fromUserExtent(layerState.extent, frameState.viewState.projection));
}
var source = /** @type {import("../../source/Tile.js").default} */ (layerState.layer.getRenderSource());
if (!source.getWrapX()) {
var gridExtent = source
.getTileGridForProjection(frameState.viewState.projection)
.getExtent();
if (gridExtent) {
extent = getIntersection(extent, gridExtent);
}
}
return extent;
}
function getCacheKey(source, tileCoord) {
return "".concat(source.getKey(), ",").concat(getTileCoordKey(tileCoord));
}
/**
* @typedef {Object} Options
* @property {string} vertexShader Vertex shader source.
* @property {string} fragmentShader Fragment shader source.
* @property {Object<string, import("../../webgl/Helper").UniformValue>} [uniforms] Additional uniforms
* made available to shaders.
* @property {Array<import("../../webgl/PaletteTexture.js").default>} [paletteTextures] Palette textures.
* @property {number} [cacheSize=512] The texture cache size.
*/
/**
* @typedef {import("../../layer/WebGLTile.js").default} LayerType
*/
/**
* @classdesc
* WebGL renderer for tile layers.
* @extends {WebGLLayerRenderer<LayerType>}
* @api
*/
var WebGLTileLayerRenderer = /** @class */ (function (_super) {
__extends(WebGLTileLayerRenderer, _super);
/**
* @param {LayerType} tileLayer Tile layer.
* @param {Options} options Options.
*/
function WebGLTileLayerRenderer(tileLayer, options) {
var _this = _super.call(this, tileLayer, {
uniforms: options.uniforms,
}) || this;
/**
* The last call to `renderFrame` was completed with all tiles loaded
* @type {boolean}
*/
_this.renderComplete = false;
/**
* This transform converts texture coordinates to screen coordinates.
* @type {import("../../transform.js").Transform}
* @private
*/
_this.tileTransform_ = createTransform();
/**
* @type {Array<number>}
* @private
*/
_this.tempMat4_ = createMat4();
/**
* @type {import("../../TileRange.js").default}
* @private
*/
_this.tempTileRange_ = new TileRange(0, 0, 0, 0);
/**
* @type {import("../../tilecoord.js").TileCoord}
* @private
*/
_this.tempTileCoord_ = createTileCoord(0, 0, 0);
/**
* @type {import("../../size.js").Size}
* @private
*/
_this.tempSize_ = [0, 0];
/**
* @type {WebGLProgram}
* @private
*/
_this.program_;
/**
* @private
*/
_this.vertexShader_ = options.vertexShader;
/**
* @private
*/
_this.fragmentShader_ = options.fragmentShader;
/**
* Tiles are rendered as a quad with the following structure:
*
* [P3]---------[P2]
* |` |
* | ` B |
* | ` |
* | ` |
* | A ` |
* | ` |
* [P0]---------[P1]
*
* Triangle A: P0, P1, P3
* Triangle B: P1, P2, P3
*
* @private
*/
_this.indices_ = new WebGLArrayBuffer(ELEMENT_ARRAY_BUFFER, STATIC_DRAW);
_this.indices_.fromArray([0, 1, 3, 1, 2, 3]);
var cacheSize = options.cacheSize !== undefined ? options.cacheSize : 512;
/**
* @type {import("../../structs/LRUCache.js").default<import("../../webgl/TileTexture.js").default>}
* @private
*/
_this.tileTextureCache_ = new LRUCache(cacheSize);
/**
* @type {Array<import("../../webgl/PaletteTexture.js").default>}
* @private
*/
_this.paletteTextures_ = options.paletteTextures || [];
/**
* @private
* @type {import("../../PluggableMap.js").FrameState|null}
*/
_this.frameState_ = null;
return _this;
}
/**
* @param {Options} options Options.
*/
WebGLTileLayerRenderer.prototype.reset = function (options) {
_super.prototype.reset.call(this, {
uniforms: options.uniforms,
});
this.vertexShader_ = options.vertexShader;
this.fragmentShader_ = options.fragmentShader;
this.paletteTextures_ = options.paletteTextures || [];
if (this.helper) {
this.program_ = this.helper.getProgram(this.fragmentShader_, this.vertexShader_);
}
};
WebGLTileLayerRenderer.prototype.afterHelperCreated = function () {
this.program_ = this.helper.getProgram(this.fragmentShader_, this.vertexShader_);
this.helper.flushBufferData(this.indices_);
};
/**
* @param {import("../../webgl/TileTexture").TileType} tile Tile.
* @return {boolean} Tile is drawable.
* @private
*/
WebGLTileLayerRenderer.prototype.isDrawableTile_ = function (tile) {
var tileLayer = this.getLayer();
var tileState = tile.getState();
var useInterimTilesOnError = tileLayer.getUseInterimTilesOnError();
return (tileState == TileState.LOADED ||
tileState == TileState.EMPTY ||
(tileState == TileState.ERROR && !useInterimTilesOnError));
};
/**
* Determine whether renderFrame should be called.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @return {boolean} Layer is ready to be rendered.
*/
WebGLTileLayerRenderer.prototype.prepareFrameInternal = function (frameState) {
var layer = this.getLayer();
var source = layer.getRenderSource();
if (!source) {
return false;
}
if (isEmpty(getRenderExtent(frameState, frameState.extent))) {
return false;
}
return source.getState() === 'ready';
};
/**
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @param {import("../../extent.js").Extent} extent The extent to be rendered.
* @param {number} initialZ The zoom level.
* @param {Object<number, Array<TileTexture>>} tileTexturesByZ The zoom level.
*/
WebGLTileLayerRenderer.prototype.enqueueTiles = function (frameState, extent, initialZ, tileTexturesByZ) {
var viewState = frameState.viewState;
var tileLayer = this.getLayer();
var tileSource = tileLayer.getRenderSource();
var tileGrid = tileSource.getTileGridForProjection(viewState.projection);
var gutter = tileSource.getGutterForProjection(viewState.projection);
var tileSourceKey = getUid(tileSource);
if (!(tileSourceKey in frameState.wantedTiles)) {
frameState.wantedTiles[tileSourceKey] = {};
}
var wantedTiles = frameState.wantedTiles[tileSourceKey];
var tileTextureCache = this.tileTextureCache_;
var minZ = Math.max(initialZ - tileLayer.getPreload(), tileGrid.getMinZoom(), tileLayer.getMinZoom());
for (var z = initialZ; z >= minZ; --z) {
var tileRange = tileGrid.getTileRangeForExtentAndZ(extent, z, this.tempTileRange_);
var tileResolution = tileGrid.getResolution(z);
for (var x = tileRange.minX; x <= tileRange.maxX; ++x) {
for (var y = tileRange.minY; y <= tileRange.maxY; ++y) {
var tileCoord = createTileCoord(z, x, y, this.tempTileCoord_);
var cacheKey = getCacheKey(tileSource, tileCoord);
/** @type {TileTexture} */
var tileTexture = void 0;
/** @type {import("../../webgl/TileTexture").TileType} */
var tile = void 0;
if (tileTextureCache.containsKey(cacheKey)) {
tileTexture = tileTextureCache.get(cacheKey);
tile = tileTexture.tile;
}
if (!tileTexture || tileTexture.tile.key !== tileSource.getKey()) {
tile = tileSource.getTile(z, x, y, frameState.pixelRatio, viewState.projection);
if (!tileTexture) {
tileTexture = new TileTexture({
tile: tile,
grid: tileGrid,
helper: this.helper,
gutter: gutter,
});
tileTextureCache.set(cacheKey, tileTexture);
}
else {
if (this.isDrawableTile_(tile)) {
tileTexture.setTile(tile);
}
else {
var interimTile =
/** @type {import("../../webgl/TileTexture").TileType} */ (tile.getInterimTile());
tileTexture.setTile(interimTile);
}
}
}
addTileTextureToLookup(tileTexturesByZ, tileTexture, z);
var tileQueueKey = tile.getKey();
wantedTiles[tileQueueKey] = true;
if (tile.getState() === TileState.IDLE) {
if (!frameState.tileQueue.isKeyQueued(tileQueueKey)) {
frameState.tileQueue.enqueue([
tile,
tileSourceKey,
tileGrid.getTileCoordCenter(tileCoord),
tileResolution,
]);
}
}
}
}
}
};
/**
* Render the layer.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
* @return {HTMLElement} The rendered element.
*/
WebGLTileLayerRenderer.prototype.renderFrame = function (frameState) {
this.frameState_ = frameState;
this.renderComplete = true;
var gl = this.helper.getGL();
this.preRender(gl, frameState);
var viewState = frameState.viewState;
var tileLayer = this.getLayer();
var tileSource = tileLayer.getRenderSource();
var tileGrid = tileSource.getTileGridForProjection(viewState.projection);
var gutter = tileSource.getGutterForProjection(viewState.projection);
var extent = getRenderExtent(frameState, frameState.extent);
var z = tileGrid.getZForResolution(viewState.resolution, tileSource.zDirection);
/**
* @type {Object<number, Array<import("../../webgl/TileTexture.js").default>>}
*/
var tileTexturesByZ = {};
if (frameState.nextExtent) {
var targetZ = tileGrid.getZForResolution(viewState.nextResolution, tileSource.zDirection);
var nextExtent = getRenderExtent(frameState, frameState.nextExtent);
this.enqueueTiles(frameState, nextExtent, targetZ, tileTexturesByZ);
}
this.enqueueTiles(frameState, extent, z, tileTexturesByZ);
/**
* A lookup of alpha values for tiles at the target rendering resolution
* for tiles that are in transition. If a tile coord key is absent from
* this lookup, the tile should be rendered at alpha 1.
* @type {Object<string, number>}
*/
var alphaLookup = {};
var uid = getUid(this);
var time = frameState.time;
var blend = false;
// look for cached tiles to use if a target tile is not ready
var tileTextures = tileTexturesByZ[z];
for (var i = 0, ii = tileTextures.length; i < ii; ++i) {
var tileTexture = tileTextures[i];
var tile = tileTexture.tile;
var tileCoord = tile.tileCoord;
if (tileTexture.loaded) {
var alpha = tile.getAlpha(uid, time);
if (alpha === 1) {
// no need to look for alt tiles
tile.endTransition(uid);
continue;
}
blend = true;
var tileCoordKey = getTileCoordKey(tileCoord);
alphaLookup[tileCoordKey] = alpha;
}
this.renderComplete = false;
// first look for child tiles (at z + 1)
var coveredByChildren = this.findAltTiles_(tileGrid, tileCoord, z + 1, tileTexturesByZ);
if (coveredByChildren) {
continue;
}
// next look for parent tiles
var minZoom = tileGrid.getMinZoom();
for (var parentZ = z - 1; parentZ >= minZoom; --parentZ) {
var coveredByParent = this.findAltTiles_(tileGrid, tileCoord, parentZ, tileTexturesByZ);
if (coveredByParent) {
break;
}
}
}
this.helper.useProgram(this.program_);
this.helper.prepareDraw(frameState, !blend);
var zs = Object.keys(tileTexturesByZ)
.map(Number)
.sort(numberSafeCompareFunction);
var centerX = viewState.center[0];
var centerY = viewState.center[1];
for (var j = 0, jj = zs.length; j < jj; ++j) {
var tileZ = zs[j];
var tileResolution = tileGrid.getResolution(tileZ);
var tileSize = toSize(tileGrid.getTileSize(tileZ), this.tempSize_);
var tileOrigin = tileGrid.getOrigin(tileZ);
var tileWidthWithGutter = tileSize[0] + 2 * gutter;
var tileHeightWithGutter = tileSize[1] + 2 * gutter;
var aspectRatio = tileWidthWithGutter / tileHeightWithGutter;
var centerI = (centerX - tileOrigin[0]) / (tileSize[0] * tileResolution);
var centerJ = (tileOrigin[1] - centerY) / (tileSize[1] * tileResolution);
var tileScale = viewState.resolution / tileResolution;
var depth = depthForZ(tileZ);
var tileTextures_1 = tileTexturesByZ[tileZ];
for (var i = 0, ii = tileTextures_1.length; i < ii; ++i) {
var tileTexture = tileTextures_1[i];
if (!tileTexture.loaded) {
continue;
}
var tile = tileTexture.tile;
var tileCoord = tile.tileCoord;
var tileCoordKey = getTileCoordKey(tileCoord);
var tileCenterI = tileCoord[1];
var tileCenterJ = tileCoord[2];
resetTransform(this.tileTransform_);
scaleTransform(this.tileTransform_, 2 / ((frameState.size[0] * tileScale) / tileWidthWithGutter), -2 / ((frameState.size[1] * tileScale) / tileWidthWithGutter));
rotateTransform(this.tileTransform_, viewState.rotation);
scaleTransform(this.tileTransform_, 1, 1 / aspectRatio);
translateTransform(this.tileTransform_, (tileSize[0] * (tileCenterI - centerI) - gutter) /
tileWidthWithGutter, (tileSize[1] * (tileCenterJ - centerJ) - gutter) /
tileHeightWithGutter);
this.helper.setUniformMatrixValue(Uniforms.TILE_TRANSFORM, mat4FromTransform(this.tempMat4_, this.tileTransform_));
this.helper.bindBuffer(tileTexture.coords);
this.helper.bindBuffer(this.indices_);
this.helper.enableAttributes(attributeDescriptions);
var textureSlot = 0;
while (textureSlot < tileTexture.textures.length) {
var textureProperty = 'TEXTURE' + textureSlot;
var uniformName = "".concat(Uniforms.TILE_TEXTURE_ARRAY, "[").concat(textureSlot, "]");
gl.activeTexture(gl[textureProperty]);
gl.bindTexture(gl.TEXTURE_2D, tileTexture.textures[textureSlot]);
gl.uniform1i(this.helper.getUniformLocation(uniformName), textureSlot);
++textureSlot;
}
for (var paletteIndex = 0; paletteIndex < this.paletteTextures_.length; ++paletteIndex) {
var paletteTexture = this.paletteTextures_[paletteIndex];
gl.activeTexture(gl['TEXTURE' + textureSlot]);
var texture = paletteTexture.getTexture(gl);
gl.bindTexture(gl.TEXTURE_2D, texture);
gl.uniform1i(this.helper.getUniformLocation(paletteTexture.name), textureSlot);
++textureSlot;
}
var alpha = tileCoordKey in alphaLookup ? alphaLookup[tileCoordKey] : 1;
if (alpha < 1) {
frameState.animate = true;
}
this.helper.setUniformFloatValue(Uniforms.TRANSITION_ALPHA, alpha);
this.helper.setUniformFloatValue(Uniforms.DEPTH, depth);
this.helper.setUniformFloatValue(Uniforms.TEXTURE_PIXEL_WIDTH, tileWidthWithGutter);
this.helper.setUniformFloatValue(Uniforms.TEXTURE_PIXEL_HEIGHT, tileHeightWithGutter);
this.helper.setUniformFloatValue(Uniforms.TEXTURE_RESOLUTION, tileResolution);
this.helper.setUniformFloatValue(Uniforms.TEXTURE_ORIGIN_X, tileOrigin[0] +
tileCenterI * tileSize[0] * tileResolution -
gutter * tileResolution);
this.helper.setUniformFloatValue(Uniforms.TEXTURE_ORIGIN_Y, tileOrigin[1] -
tileCenterJ * tileSize[1] * tileResolution +
gutter * tileResolution);
var gutterExtent = extent;
if (gutter > 0) {
gutterExtent = tileGrid.getTileCoordExtent(tileCoord);
getIntersection(gutterExtent, extent, gutterExtent);
}
this.helper.setUniformFloatVec4(Uniforms.RENDER_EXTENT, gutterExtent);
this.helper.setUniformFloatValue(Uniforms.RESOLUTION, viewState.resolution);
this.helper.setUniformFloatValue(Uniforms.ZOOM, viewState.zoom);
this.helper.drawElements(0, this.indices_.getSize());
}
}
this.helper.finalizeDraw(frameState, this.dispatchPreComposeEvent, this.dispatchPostComposeEvent);
var canvas = this.helper.getCanvas();
var tileTextureCache = this.tileTextureCache_;
while (tileTextureCache.canExpireCache()) {
var tileTexture = tileTextureCache.pop();
tileTexture.dispose();
}
// TODO: let the renderers manage their own cache instead of managing the source cache
/**
* Here we unconditionally expire the source cache since the renderer maintains
* its own cache.
* @param {import("../../PluggableMap.js").default} map Map.
* @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
*/
var postRenderFunction = function (map, frameState) {
tileSource.expireCache(frameState.viewState.projection, empty);
};
frameState.postRenderFunctions.push(postRenderFunction);
this.postRender(gl, frameState);
return canvas;
};
/**
* @param {import("../../pixel.js").Pixel} pixel Pixel.
* @return {Uint8ClampedArray|Uint8Array|Float32Array|DataView} Data at the pixel location.
*/
WebGLTileLayerRenderer.prototype.getData = function (pixel) {
var gl = this.helper.getGL();
if (!gl) {
return null;
}
var frameState = this.frameState_;
if (!frameState) {
return null;
}
var layer = this.getLayer();
var coordinate = applyTransform(frameState.pixelToCoordinateTransform, pixel.slice());
var viewState = frameState.viewState;
var layerExtent = layer.getExtent();
if (layerExtent) {
if (!containsCoordinate(fromUserExtent(layerExtent, viewState.projection), coordinate)) {
return null;
}
}
// determine last source suitable for rendering at coordinate
var sources = layer.getSources(boundingExtent([coordinate]), viewState.resolution);
var i, source, tileGrid;
for (i = sources.length - 1; i >= 0; --i) {
source = sources[i];
if (source.getState() === 'ready') {
tileGrid = source.getTileGridForProjection(viewState.projection);
if (source.getWrapX()) {
break;
}
var gridExtent = tileGrid.getExtent();
if (!gridExtent || containsCoordinate(gridExtent, coordinate)) {
break;
}
}
}
if (i < 0) {
return null;
}
var tileTextureCache = this.tileTextureCache_;
for (var z = tileGrid.getZForResolution(viewState.resolution); z >= tileGrid.getMinZoom(); --z) {
var tileCoord = tileGrid.getTileCoordForCoordAndZ(coordinate, z);
var cacheKey = getCacheKey(source, tileCoord);
if (!tileTextureCache.containsKey(cacheKey)) {
continue;
}
var tileTexture = tileTextureCache.get(cacheKey);
if (!tileTexture.loaded) {
continue;
}
var tileOrigin = tileGrid.getOrigin(z);
var tileSize = toSize(tileGrid.getTileSize(z));
var tileResolution = tileGrid.getResolution(z);
var col = (coordinate[0] - tileOrigin[0]) / tileResolution -
tileCoord[1] * tileSize[0];
var row = (tileOrigin[1] - coordinate[1]) / tileResolution -
tileCoord[2] * tileSize[1];
return tileTexture.getPixelData(col, row);
}
return null;
};
/**
* Look for tiles covering the provided tile coordinate at an alternate
* zoom level. Loaded tiles will be added to the provided tile texture lookup.
* @param {import("../../tilegrid/TileGrid.js").default} tileGrid The tile grid.
* @param {import("../../tilecoord.js").TileCoord} tileCoord The target tile coordinate.
* @param {number} altZ The alternate zoom level.
* @param {Object<number, Array<import("../../webgl/TileTexture.js").default>>} tileTexturesByZ Lookup of
* tile textures by zoom level.
* @return {boolean} The tile coordinate is covered by loaded tiles at the alternate zoom level.
* @private
*/
WebGLTileLayerRenderer.prototype.findAltTiles_ = function (tileGrid, tileCoord, altZ, tileTexturesByZ) {
var tileRange = tileGrid.getTileRangeForTileCoordAndZ(tileCoord, altZ, this.tempTileRange_);
if (!tileRange) {
return false;
}
var covered = true;
var tileTextureCache = this.tileTextureCache_;
var source = this.getLayer().getRenderSource();
for (var x = tileRange.minX; x <= tileRange.maxX; ++x) {
for (var y = tileRange.minY; y <= tileRange.maxY; ++y) {
var cacheKey = getCacheKey(source, [altZ, x, y]);
var loaded = false;
if (tileTextureCache.containsKey(cacheKey)) {
var tileTexture = tileTextureCache.get(cacheKey);
if (tileTexture.loaded) {
addTileTextureToLookup(tileTexturesByZ, tileTexture, altZ);
loaded = true;
}
}
if (!loaded) {
covered = false;
}
}
}
return covered;
};
WebGLTileLayerRenderer.prototype.removeHelper = function () {
if (this.helper) {
var tileTextureCache = this.tileTextureCache_;
tileTextureCache.forEach(function (tileTexture) { return tileTexture.dispose(); });
tileTextureCache.clear();
}
_super.prototype.removeHelper.call(this);
};
/**
* Clean up.
*/
WebGLTileLayerRenderer.prototype.disposeInternal = function () {
var helper = this.helper;
if (helper) {
var gl = helper.getGL();
gl.deleteProgram(this.program_);
delete this.program_;
helper.deleteBuffer(this.indices_);
}
_super.prototype.disposeInternal.call(this);
delete this.indices_;
delete this.tileTextureCache_;
delete this.frameState_;
};
return WebGLTileLayerRenderer;
}(WebGLLayerRenderer));
export default WebGLTileLayerRenderer;
//# sourceMappingURL=TileLayer.js.map

1
node_modules/ol/renderer/webgl/TileLayer.js.map generated vendored Normal file
View File

File diff suppressed because one or more lines are too long