Automated class transform
npx lebab --replace src --transform class
This commit is contained in:
Tim Schaub
+198
-193
@@ -16,18 +16,210 @@ import SourceState from '../source/State.js';
|
||||
* @param {module:ol/layer/Layer} layer Layer.
|
||||
* @struct
|
||||
*/
|
||||
const LayerRenderer = function(layer) {
|
||||
class LayerRenderer {
|
||||
constructor(layer) {
|
||||
|
||||
Observable.call(this);
|
||||
Observable.call(this);
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/layer/Layer}
|
||||
*/
|
||||
this.layer_ = layer;
|
||||
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/layer/Layer}
|
||||
* Create a function that adds loaded tiles to the tile lookup.
|
||||
* @param {module:ol/source/Tile} source Tile source.
|
||||
* @param {module:ol/proj/Projection} projection Projection of the tiles.
|
||||
* @param {Object.<number, Object.<string, module:ol/Tile>>} tiles Lookup of loaded tiles by zoom level.
|
||||
* @return {function(number, module:ol/TileRange):boolean} A function that can be
|
||||
* called with a zoom level and a tile range to add loaded tiles to the lookup.
|
||||
* @protected
|
||||
*/
|
||||
this.layer_ = layer;
|
||||
createLoadedTileFinder(source, projection, tiles) {
|
||||
return (
|
||||
/**
|
||||
* @param {number} zoom Zoom level.
|
||||
* @param {module:ol/TileRange} tileRange Tile range.
|
||||
* @return {boolean} The tile range is fully loaded.
|
||||
*/
|
||||
function(zoom, tileRange) {
|
||||
function callback(tile) {
|
||||
if (!tiles[zoom]) {
|
||||
tiles[zoom] = {};
|
||||
}
|
||||
tiles[zoom][tile.tileCoord.toString()] = tile;
|
||||
}
|
||||
return source.forEachLoadedTile(projection, zoom, tileRange, callback);
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* @return {module:ol/layer/Layer} Layer.
|
||||
*/
|
||||
getLayer() {
|
||||
return this.layer_;
|
||||
}
|
||||
|
||||
};
|
||||
/**
|
||||
* Handle changes in image state.
|
||||
* @param {module:ol/events/Event} event Image change event.
|
||||
* @private
|
||||
*/
|
||||
handleImageChange_(event) {
|
||||
const image = /** @type {module:ol/Image} */ (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 {module:ol/ImageBase} image Image.
|
||||
* @return {boolean} `true` if the image is already loaded, `false` otherwise.
|
||||
* @protected
|
||||
*/
|
||||
loadImage(image) {
|
||||
let imageState = image.getState();
|
||||
if (imageState != ImageState.LOADED && imageState != ImageState.ERROR) {
|
||||
listen(image, EventType.CHANGE, this.handleImageChange_, this);
|
||||
}
|
||||
if (imageState == ImageState.IDLE) {
|
||||
image.load();
|
||||
imageState = image.getState();
|
||||
}
|
||||
return imageState == ImageState.LOADED;
|
||||
}
|
||||
|
||||
/**
|
||||
* @protected
|
||||
*/
|
||||
renderIfReadyAndVisible() {
|
||||
const layer = this.getLayer();
|
||||
if (layer.getVisible() && layer.getSourceState() == SourceState.READY) {
|
||||
this.changed();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @param {module:ol/source/Tile} tileSource Tile source.
|
||||
* @protected
|
||||
*/
|
||||
scheduleExpireCache(frameState, tileSource) {
|
||||
if (tileSource.canExpireCache()) {
|
||||
/**
|
||||
* @param {module:ol/source/Tile} tileSource Tile source.
|
||||
* @param {module:ol/PluggableMap} map Map.
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
*/
|
||||
const postRenderFunction = function(tileSource, map, frameState) {
|
||||
const tileSourceKey = getUid(tileSource).toString();
|
||||
if (tileSourceKey in frameState.usedTiles) {
|
||||
tileSource.expireCache(frameState.viewState.projection,
|
||||
frameState.usedTiles[tileSourceKey]);
|
||||
}
|
||||
}.bind(null, tileSource);
|
||||
|
||||
frameState.postRenderFunctions.push(
|
||||
/** @type {module:ol/PluggableMap~PostRenderFunction} */ (postRenderFunction)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {!Object.<string, !Object.<string, module:ol/TileRange>>} usedTiles Used tiles.
|
||||
* @param {module:ol/source/Tile} tileSource Tile source.
|
||||
* @param {number} z Z.
|
||||
* @param {module:ol/TileRange} tileRange Tile range.
|
||||
* @protected
|
||||
*/
|
||||
updateUsedTiles(usedTiles, tileSource, z, tileRange) {
|
||||
// FIXME should we use tilesToDrawByZ instead?
|
||||
const tileSourceKey = getUid(tileSource).toString();
|
||||
const zKey = z.toString();
|
||||
if (tileSourceKey in usedTiles) {
|
||||
if (zKey in usedTiles[tileSourceKey]) {
|
||||
usedTiles[tileSourceKey][zKey].extend(tileRange);
|
||||
} else {
|
||||
usedTiles[tileSourceKey][zKey] = tileRange;
|
||||
}
|
||||
} else {
|
||||
usedTiles[tileSourceKey] = {};
|
||||
usedTiles[tileSourceKey][zKey] = tileRange;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 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 {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @param {module:ol/source/Tile} tileSource Tile source.
|
||||
* @param {module:ol/tilegrid/TileGrid} tileGrid Tile grid.
|
||||
* @param {number} pixelRatio Pixel ratio.
|
||||
* @param {module:ol/proj/Projection} projection Projection.
|
||||
* @param {module:ol/extent~Extent} extent Extent.
|
||||
* @param {number} currentZ Current Z.
|
||||
* @param {number} preload Load low resolution tiles up to 'preload' levels.
|
||||
* @param {function(this: T, module:ol/Tile)=} opt_tileCallback Tile callback.
|
||||
* @param {T=} opt_this Object to use as `this` in `opt_tileCallback`.
|
||||
* @protected
|
||||
* @template T
|
||||
*/
|
||||
manageTilePyramid(
|
||||
frameState,
|
||||
tileSource,
|
||||
tileGrid,
|
||||
pixelRatio,
|
||||
projection,
|
||||
extent,
|
||||
currentZ,
|
||||
preload,
|
||||
opt_tileCallback,
|
||||
opt_this
|
||||
) {
|
||||
const tileSourceKey = getUid(tileSource).toString();
|
||||
if (!(tileSourceKey in frameState.wantedTiles)) {
|
||||
frameState.wantedTiles[tileSourceKey] = {};
|
||||
}
|
||||
const wantedTiles = frameState.wantedTiles[tileSourceKey];
|
||||
const tileQueue = frameState.tileQueue;
|
||||
const minZoom = tileGrid.getMinZoom();
|
||||
let 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 (currentZ - z <= preload) {
|
||||
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.call(opt_this, tile);
|
||||
}
|
||||
} else {
|
||||
tileSource.useTile(z, x, y, projection);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
inherits(LayerRenderer, Observable);
|
||||
|
||||
@@ -53,191 +245,4 @@ LayerRenderer.prototype.forEachFeatureAtCoordinate = UNDEFINED;
|
||||
LayerRenderer.prototype.hasFeatureAtCoordinate = FALSE;
|
||||
|
||||
|
||||
/**
|
||||
* Create a function that adds loaded tiles to the tile lookup.
|
||||
* @param {module:ol/source/Tile} source Tile source.
|
||||
* @param {module:ol/proj/Projection} projection Projection of the tiles.
|
||||
* @param {Object.<number, Object.<string, module:ol/Tile>>} tiles Lookup of loaded tiles by zoom level.
|
||||
* @return {function(number, module:ol/TileRange):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 {module:ol/TileRange} tileRange Tile range.
|
||||
* @return {boolean} The tile range is fully loaded.
|
||||
*/
|
||||
function(zoom, tileRange) {
|
||||
function callback(tile) {
|
||||
if (!tiles[zoom]) {
|
||||
tiles[zoom] = {};
|
||||
}
|
||||
tiles[zoom][tile.tileCoord.toString()] = tile;
|
||||
}
|
||||
return source.forEachLoadedTile(projection, zoom, tileRange, callback);
|
||||
}
|
||||
);
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @return {module:ol/layer/Layer} Layer.
|
||||
*/
|
||||
LayerRenderer.prototype.getLayer = function() {
|
||||
return this.layer_;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* Handle changes in image state.
|
||||
* @param {module:ol/events/Event} event Image change event.
|
||||
* @private
|
||||
*/
|
||||
LayerRenderer.prototype.handleImageChange_ = function(event) {
|
||||
const image = /** @type {module:ol/Image} */ (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 {module:ol/ImageBase} image Image.
|
||||
* @return {boolean} `true` if the image is already loaded, `false` otherwise.
|
||||
* @protected
|
||||
*/
|
||||
LayerRenderer.prototype.loadImage = function(image) {
|
||||
let imageState = image.getState();
|
||||
if (imageState != ImageState.LOADED && imageState != ImageState.ERROR) {
|
||||
listen(image, EventType.CHANGE, this.handleImageChange_, this);
|
||||
}
|
||||
if (imageState == ImageState.IDLE) {
|
||||
image.load();
|
||||
imageState = image.getState();
|
||||
}
|
||||
return imageState == ImageState.LOADED;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @protected
|
||||
*/
|
||||
LayerRenderer.prototype.renderIfReadyAndVisible = function() {
|
||||
const layer = this.getLayer();
|
||||
if (layer.getVisible() && layer.getSourceState() == SourceState.READY) {
|
||||
this.changed();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @param {module:ol/source/Tile} tileSource Tile source.
|
||||
* @protected
|
||||
*/
|
||||
LayerRenderer.prototype.scheduleExpireCache = function(frameState, tileSource) {
|
||||
if (tileSource.canExpireCache()) {
|
||||
/**
|
||||
* @param {module:ol/source/Tile} tileSource Tile source.
|
||||
* @param {module:ol/PluggableMap} map Map.
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
*/
|
||||
const postRenderFunction = function(tileSource, map, frameState) {
|
||||
const tileSourceKey = getUid(tileSource).toString();
|
||||
if (tileSourceKey in frameState.usedTiles) {
|
||||
tileSource.expireCache(frameState.viewState.projection,
|
||||
frameState.usedTiles[tileSourceKey]);
|
||||
}
|
||||
}.bind(null, tileSource);
|
||||
|
||||
frameState.postRenderFunctions.push(
|
||||
/** @type {module:ol/PluggableMap~PostRenderFunction} */ (postRenderFunction)
|
||||
);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {!Object.<string, !Object.<string, module:ol/TileRange>>} usedTiles Used tiles.
|
||||
* @param {module:ol/source/Tile} tileSource Tile source.
|
||||
* @param {number} z Z.
|
||||
* @param {module:ol/TileRange} tileRange Tile range.
|
||||
* @protected
|
||||
*/
|
||||
LayerRenderer.prototype.updateUsedTiles = function(usedTiles, tileSource, z, tileRange) {
|
||||
// FIXME should we use tilesToDrawByZ instead?
|
||||
const tileSourceKey = getUid(tileSource).toString();
|
||||
const zKey = z.toString();
|
||||
if (tileSourceKey in usedTiles) {
|
||||
if (zKey in usedTiles[tileSourceKey]) {
|
||||
usedTiles[tileSourceKey][zKey].extend(tileRange);
|
||||
} else {
|
||||
usedTiles[tileSourceKey][zKey] = tileRange;
|
||||
}
|
||||
} else {
|
||||
usedTiles[tileSourceKey] = {};
|
||||
usedTiles[tileSourceKey][zKey] = tileRange;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* 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 {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @param {module:ol/source/Tile} tileSource Tile source.
|
||||
* @param {module:ol/tilegrid/TileGrid} tileGrid Tile grid.
|
||||
* @param {number} pixelRatio Pixel ratio.
|
||||
* @param {module:ol/proj/Projection} projection Projection.
|
||||
* @param {module:ol/extent~Extent} extent Extent.
|
||||
* @param {number} currentZ Current Z.
|
||||
* @param {number} preload Load low resolution tiles up to 'preload' levels.
|
||||
* @param {function(this: T, module:ol/Tile)=} opt_tileCallback Tile callback.
|
||||
* @param {T=} opt_this Object to use as `this` in `opt_tileCallback`.
|
||||
* @protected
|
||||
* @template T
|
||||
*/
|
||||
LayerRenderer.prototype.manageTilePyramid = function(
|
||||
frameState, tileSource, tileGrid, pixelRatio, projection, extent,
|
||||
currentZ, preload, opt_tileCallback, opt_this) {
|
||||
const tileSourceKey = getUid(tileSource).toString();
|
||||
if (!(tileSourceKey in frameState.wantedTiles)) {
|
||||
frameState.wantedTiles[tileSourceKey] = {};
|
||||
}
|
||||
const wantedTiles = frameState.wantedTiles[tileSourceKey];
|
||||
const tileQueue = frameState.tileQueue;
|
||||
const minZoom = tileGrid.getMinZoom();
|
||||
let 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 (currentZ - z <= preload) {
|
||||
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.call(opt_this, tile);
|
||||
}
|
||||
} else {
|
||||
tileSource.useTile(z, x, y, projection);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
export default LayerRenderer;
|
||||
|
||||
+285
-293
@@ -19,86 +19,308 @@ import {compose as composeTransform, invert as invertTransform, setFromArray as
|
||||
* @param {module:ol/PluggableMap} map Map.
|
||||
* @struct
|
||||
*/
|
||||
const MapRenderer = function(map) {
|
||||
Disposable.call(this);
|
||||
class MapRenderer {
|
||||
constructor(map) {
|
||||
Disposable.call(this);
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/PluggableMap}
|
||||
*/
|
||||
this.map_ = map;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {!Object.<string, module:ol/renderer/Layer>}
|
||||
*/
|
||||
this.layerRenderers_ = {};
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {Object.<string, module:ol/events~EventsKey>}
|
||||
*/
|
||||
this.layerRendererListeners_ = {};
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {Array.<module:ol/renderer/Layer>}
|
||||
*/
|
||||
this.layerRendererConstructors_ = [];
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/PluggableMap}
|
||||
* Register layer renderer constructors.
|
||||
* @param {Array.<module:ol/renderer/Layer>} constructors Layer renderers.
|
||||
*/
|
||||
this.map_ = map;
|
||||
registerLayerRenderers(constructors) {
|
||||
this.layerRendererConstructors_.push.apply(this.layerRendererConstructors_, constructors);
|
||||
}
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {!Object.<string, module:ol/renderer/Layer>}
|
||||
* Get the registered layer renderer constructors.
|
||||
* @return {Array.<module:ol/renderer/Layer>} Registered layer renderers.
|
||||
*/
|
||||
this.layerRenderers_ = {};
|
||||
getLayerRendererConstructors() {
|
||||
return this.layerRendererConstructors_;
|
||||
}
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {Object.<string, module:ol/events~EventsKey>}
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState FrameState.
|
||||
* @protected
|
||||
*/
|
||||
this.layerRendererListeners_ = {};
|
||||
calculateMatrices2D(frameState) {
|
||||
const viewState = frameState.viewState;
|
||||
const coordinateToPixelTransform = frameState.coordinateToPixelTransform;
|
||||
const 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]);
|
||||
|
||||
invertTransform(
|
||||
transformSetFromArray(pixelToCoordinateTransform, coordinateToPixelTransform));
|
||||
}
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {Array.<module:ol/renderer/Layer>}
|
||||
* Removes all layer renderers.
|
||||
*/
|
||||
this.layerRendererConstructors_ = [];
|
||||
removeLayerRenderers() {
|
||||
for (const key in this.layerRenderers_) {
|
||||
this.removeLayerRendererByKey_(key).dispose();
|
||||
}
|
||||
}
|
||||
|
||||
};
|
||||
/**
|
||||
* @param {module:ol/coordinate~Coordinate} coordinate Coordinate.
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState FrameState.
|
||||
* @param {number} hitTolerance Hit tolerance in pixels.
|
||||
* @param {function(this: S, (module:ol/Feature|module:ol/render/Feature),
|
||||
* module:ol/layer/Layer): T} callback Feature callback.
|
||||
* @param {S} thisArg Value to use as `this` when executing `callback`.
|
||||
* @param {function(this: U, module:ol/layer/Layer): 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(
|
||||
coordinate,
|
||||
frameState,
|
||||
hitTolerance,
|
||||
callback,
|
||||
thisArg,
|
||||
layerFilter,
|
||||
thisArg2
|
||||
) {
|
||||
let result;
|
||||
const viewState = frameState.viewState;
|
||||
const viewResolution = viewState.resolution;
|
||||
|
||||
/**
|
||||
* @param {module:ol/Feature|module:ol/render/Feature} feature Feature.
|
||||
* @param {module:ol/layer/Layer} layer Layer.
|
||||
* @return {?} Callback result.
|
||||
*/
|
||||
function forEachFeatureAtCoordinate(feature, layer) {
|
||||
const key = getUid(feature).toString();
|
||||
const managed = frameState.layerStates[getUid(layer)].managed;
|
||||
if (!(key in frameState.skippedFeatureUids && !managed)) {
|
||||
return callback.call(thisArg, feature, managed ? layer : null);
|
||||
}
|
||||
}
|
||||
|
||||
const projection = viewState.projection;
|
||||
|
||||
let translatedCoordinate = coordinate;
|
||||
if (projection.canWrapX()) {
|
||||
const projectionExtent = projection.getExtent();
|
||||
const worldWidth = getWidth(projectionExtent);
|
||||
const x = coordinate[0];
|
||||
if (x < projectionExtent[0] || x > projectionExtent[2]) {
|
||||
const worldsAway = Math.ceil((projectionExtent[0] - x) / worldWidth);
|
||||
translatedCoordinate = [x + worldWidth * worldsAway, coordinate[1]];
|
||||
}
|
||||
}
|
||||
|
||||
const layerStates = frameState.layerStatesArray;
|
||||
const numLayers = layerStates.length;
|
||||
let i;
|
||||
for (i = numLayers - 1; i >= 0; --i) {
|
||||
const layerState = layerStates[i];
|
||||
const layer = layerState.layer;
|
||||
if (visibleAtResolution(layerState, viewResolution) && layerFilter.call(thisArg2, layer)) {
|
||||
const layerRenderer = this.getLayerRenderer(layer);
|
||||
if (layer.getSource()) {
|
||||
result = layerRenderer.forEachFeatureAtCoordinate(
|
||||
layer.getSource().getWrapX() ? translatedCoordinate : coordinate,
|
||||
frameState, hitTolerance, forEachFeatureAtCoordinate, thisArg);
|
||||
}
|
||||
if (result) {
|
||||
return result;
|
||||
}
|
||||
}
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
|
||||
/**
|
||||
* @abstract
|
||||
* @param {module:ol~Pixel} pixel Pixel.
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState FrameState.
|
||||
* @param {number} hitTolerance Hit tolerance in pixels.
|
||||
* @param {function(this: S, module:ol/layer/Layer, (Uint8ClampedArray|Uint8Array)): T} callback Layer
|
||||
* callback.
|
||||
* @param {S} thisArg Value to use as `this` when executing `callback`.
|
||||
* @param {function(this: U, module:ol/layer/Layer): 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
|
||||
*/
|
||||
forEachLayerAtPixel(pixel, frameState, hitTolerance, callback, thisArg, layerFilter, thisArg2) {}
|
||||
|
||||
/**
|
||||
* @param {module:ol/coordinate~Coordinate} coordinate Coordinate.
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState FrameState.
|
||||
* @param {number} hitTolerance Hit tolerance in pixels.
|
||||
* @param {function(this: U, module:ol/layer/Layer): 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(coordinate, frameState, hitTolerance, layerFilter, thisArg) {
|
||||
const hasFeature = this.forEachFeatureAtCoordinate(
|
||||
coordinate, frameState, hitTolerance, TRUE, this, layerFilter, thisArg);
|
||||
|
||||
return hasFeature !== undefined;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {module:ol/layer/Layer} layer Layer.
|
||||
* @protected
|
||||
* @return {module:ol/renderer/Layer} Layer renderer.
|
||||
*/
|
||||
getLayerRenderer(layer) {
|
||||
const layerKey = getUid(layer).toString();
|
||||
if (layerKey in this.layerRenderers_) {
|
||||
return this.layerRenderers_[layerKey];
|
||||
} else {
|
||||
let renderer;
|
||||
for (let i = 0, ii = this.layerRendererConstructors_.length; i < ii; ++i) {
|
||||
const candidate = this.layerRendererConstructors_[i];
|
||||
if (candidate['handles'](layer)) {
|
||||
renderer = candidate['create'](this, layer);
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (renderer) {
|
||||
this.layerRenderers_[layerKey] = renderer;
|
||||
this.layerRendererListeners_[layerKey] = listen(renderer,
|
||||
EventType.CHANGE, this.handleLayerRendererChange_, this);
|
||||
} else {
|
||||
throw new Error('Unable to create renderer for layer: ' + layer.getType());
|
||||
}
|
||||
return renderer;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {string} layerKey Layer key.
|
||||
* @protected
|
||||
* @return {module:ol/renderer/Layer} Layer renderer.
|
||||
*/
|
||||
getLayerRendererByKey(layerKey) {
|
||||
return this.layerRenderers_[layerKey];
|
||||
}
|
||||
|
||||
/**
|
||||
* @protected
|
||||
* @return {Object.<string, module:ol/renderer/Layer>} Layer renderers.
|
||||
*/
|
||||
getLayerRenderers() {
|
||||
return this.layerRenderers_;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return {module:ol/PluggableMap} Map.
|
||||
*/
|
||||
getMap() {
|
||||
return this.map_;
|
||||
}
|
||||
|
||||
/**
|
||||
* Handle changes in a layer renderer.
|
||||
* @private
|
||||
*/
|
||||
handleLayerRendererChange_() {
|
||||
this.map_.render();
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {string} layerKey Layer key.
|
||||
* @return {module:ol/renderer/Layer} Layer renderer.
|
||||
* @private
|
||||
*/
|
||||
removeLayerRendererByKey_(layerKey) {
|
||||
const layerRenderer = this.layerRenderers_[layerKey];
|
||||
delete this.layerRenderers_[layerKey];
|
||||
|
||||
unlistenByKey(this.layerRendererListeners_[layerKey]);
|
||||
delete this.layerRendererListeners_[layerKey];
|
||||
|
||||
return layerRenderer;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {module:ol/PluggableMap} map Map.
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @private
|
||||
*/
|
||||
removeUnusedLayerRenderers_(map, frameState) {
|
||||
for (const layerKey in this.layerRenderers_) {
|
||||
if (!frameState || !(layerKey in frameState.layerStates)) {
|
||||
this.removeLayerRendererByKey_(layerKey).dispose();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @protected
|
||||
*/
|
||||
scheduleExpireIconCache(frameState) {
|
||||
frameState.postRenderFunctions.push(/** @type {module:ol/PluggableMap~PostRenderFunction} */ (expireIconCache));
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {!module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @protected
|
||||
*/
|
||||
scheduleRemoveUnusedLayerRenderers(frameState) {
|
||||
for (const layerKey in this.layerRenderers_) {
|
||||
if (!(layerKey in frameState.layerStates)) {
|
||||
frameState.postRenderFunctions.push(
|
||||
/** @type {module:ol/PluggableMap~PostRenderFunction} */ (this.removeUnusedLayerRenderers_.bind(this))
|
||||
);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
inherits(MapRenderer, Disposable);
|
||||
|
||||
|
||||
/**
|
||||
* Register layer renderer constructors.
|
||||
* @param {Array.<module:ol/renderer/Layer>} constructors Layer renderers.
|
||||
*/
|
||||
MapRenderer.prototype.registerLayerRenderers = function(constructors) {
|
||||
this.layerRendererConstructors_.push.apply(this.layerRendererConstructors_, constructors);
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* Get the registered layer renderer constructors.
|
||||
* @return {Array.<module:ol/renderer/Layer>} Registered layer renderers.
|
||||
*/
|
||||
MapRenderer.prototype.getLayerRendererConstructors = function() {
|
||||
return this.layerRendererConstructors_;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState FrameState.
|
||||
* @protected
|
||||
*/
|
||||
MapRenderer.prototype.calculateMatrices2D = function(frameState) {
|
||||
const viewState = frameState.viewState;
|
||||
const coordinateToPixelTransform = frameState.coordinateToPixelTransform;
|
||||
const 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]);
|
||||
|
||||
invertTransform(
|
||||
transformSetFromArray(pixelToCoordinateTransform, coordinateToPixelTransform));
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* Removes all layer renderers.
|
||||
*/
|
||||
MapRenderer.prototype.removeLayerRenderers = function() {
|
||||
for (const key in this.layerRenderers_) {
|
||||
this.removeLayerRendererByKey_(key).dispose();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {module:ol/PluggableMap} map Map.
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
@@ -108,197 +330,6 @@ function expireIconCache(map, frameState) {
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @param {module:ol/coordinate~Coordinate} coordinate Coordinate.
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState FrameState.
|
||||
* @param {number} hitTolerance Hit tolerance in pixels.
|
||||
* @param {function(this: S, (module:ol/Feature|module:ol/render/Feature),
|
||||
* module:ol/layer/Layer): T} callback Feature callback.
|
||||
* @param {S} thisArg Value to use as `this` when executing `callback`.
|
||||
* @param {function(this: U, module:ol/layer/Layer): 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, callback, thisArg,
|
||||
layerFilter, thisArg2) {
|
||||
let result;
|
||||
const viewState = frameState.viewState;
|
||||
const viewResolution = viewState.resolution;
|
||||
|
||||
/**
|
||||
* @param {module:ol/Feature|module:ol/render/Feature} feature Feature.
|
||||
* @param {module:ol/layer/Layer} layer Layer.
|
||||
* @return {?} Callback result.
|
||||
*/
|
||||
function forEachFeatureAtCoordinate(feature, layer) {
|
||||
const key = getUid(feature).toString();
|
||||
const managed = frameState.layerStates[getUid(layer)].managed;
|
||||
if (!(key in frameState.skippedFeatureUids && !managed)) {
|
||||
return callback.call(thisArg, feature, managed ? layer : null);
|
||||
}
|
||||
}
|
||||
|
||||
const projection = viewState.projection;
|
||||
|
||||
let translatedCoordinate = coordinate;
|
||||
if (projection.canWrapX()) {
|
||||
const projectionExtent = projection.getExtent();
|
||||
const worldWidth = getWidth(projectionExtent);
|
||||
const x = coordinate[0];
|
||||
if (x < projectionExtent[0] || x > projectionExtent[2]) {
|
||||
const worldsAway = Math.ceil((projectionExtent[0] - x) / worldWidth);
|
||||
translatedCoordinate = [x + worldWidth * worldsAway, coordinate[1]];
|
||||
}
|
||||
}
|
||||
|
||||
const layerStates = frameState.layerStatesArray;
|
||||
const numLayers = layerStates.length;
|
||||
let i;
|
||||
for (i = numLayers - 1; i >= 0; --i) {
|
||||
const layerState = layerStates[i];
|
||||
const layer = layerState.layer;
|
||||
if (visibleAtResolution(layerState, viewResolution) && layerFilter.call(thisArg2, layer)) {
|
||||
const layerRenderer = this.getLayerRenderer(layer);
|
||||
if (layer.getSource()) {
|
||||
result = layerRenderer.forEachFeatureAtCoordinate(
|
||||
layer.getSource().getWrapX() ? translatedCoordinate : coordinate,
|
||||
frameState, hitTolerance, forEachFeatureAtCoordinate, thisArg);
|
||||
}
|
||||
if (result) {
|
||||
return result;
|
||||
}
|
||||
}
|
||||
}
|
||||
return undefined;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @abstract
|
||||
* @param {module:ol~Pixel} pixel Pixel.
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState FrameState.
|
||||
* @param {number} hitTolerance Hit tolerance in pixels.
|
||||
* @param {function(this: S, module:ol/layer/Layer, (Uint8ClampedArray|Uint8Array)): T} callback Layer
|
||||
* callback.
|
||||
* @param {S} thisArg Value to use as `this` when executing `callback`.
|
||||
* @param {function(this: U, module:ol/layer/Layer): 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.forEachLayerAtPixel = function(pixel, frameState, hitTolerance, callback, thisArg,
|
||||
layerFilter, thisArg2) {};
|
||||
|
||||
|
||||
/**
|
||||
* @param {module:ol/coordinate~Coordinate} coordinate Coordinate.
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState FrameState.
|
||||
* @param {number} hitTolerance Hit tolerance in pixels.
|
||||
* @param {function(this: U, module:ol/layer/Layer): 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, layerFilter, thisArg) {
|
||||
const hasFeature = this.forEachFeatureAtCoordinate(
|
||||
coordinate, frameState, hitTolerance, TRUE, this, layerFilter, thisArg);
|
||||
|
||||
return hasFeature !== undefined;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {module:ol/layer/Layer} layer Layer.
|
||||
* @protected
|
||||
* @return {module:ol/renderer/Layer} Layer renderer.
|
||||
*/
|
||||
MapRenderer.prototype.getLayerRenderer = function(layer) {
|
||||
const layerKey = getUid(layer).toString();
|
||||
if (layerKey in this.layerRenderers_) {
|
||||
return this.layerRenderers_[layerKey];
|
||||
} else {
|
||||
let renderer;
|
||||
for (let i = 0, ii = this.layerRendererConstructors_.length; i < ii; ++i) {
|
||||
const candidate = this.layerRendererConstructors_[i];
|
||||
if (candidate['handles'](layer)) {
|
||||
renderer = candidate['create'](this, layer);
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (renderer) {
|
||||
this.layerRenderers_[layerKey] = renderer;
|
||||
this.layerRendererListeners_[layerKey] = listen(renderer,
|
||||
EventType.CHANGE, this.handleLayerRendererChange_, this);
|
||||
} else {
|
||||
throw new Error('Unable to create renderer for layer: ' + layer.getType());
|
||||
}
|
||||
return renderer;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {string} layerKey Layer key.
|
||||
* @protected
|
||||
* @return {module:ol/renderer/Layer} Layer renderer.
|
||||
*/
|
||||
MapRenderer.prototype.getLayerRendererByKey = function(layerKey) {
|
||||
return this.layerRenderers_[layerKey];
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @protected
|
||||
* @return {Object.<string, module:ol/renderer/Layer>} Layer renderers.
|
||||
*/
|
||||
MapRenderer.prototype.getLayerRenderers = function() {
|
||||
return this.layerRenderers_;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @return {module:ol/PluggableMap} Map.
|
||||
*/
|
||||
MapRenderer.prototype.getMap = function() {
|
||||
return this.map_;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* Handle changes in a layer renderer.
|
||||
* @private
|
||||
*/
|
||||
MapRenderer.prototype.handleLayerRendererChange_ = function() {
|
||||
this.map_.render();
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {string} layerKey Layer key.
|
||||
* @return {module:ol/renderer/Layer} Layer renderer.
|
||||
* @private
|
||||
*/
|
||||
MapRenderer.prototype.removeLayerRendererByKey_ = function(layerKey) {
|
||||
const layerRenderer = this.layerRenderers_[layerKey];
|
||||
delete this.layerRenderers_[layerKey];
|
||||
|
||||
unlistenByKey(this.layerRendererListeners_[layerKey]);
|
||||
delete this.layerRendererListeners_[layerKey];
|
||||
|
||||
return layerRenderer;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* Render.
|
||||
* @param {?module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
@@ -306,45 +337,6 @@ MapRenderer.prototype.removeLayerRendererByKey_ = function(layerKey) {
|
||||
MapRenderer.prototype.renderFrame = UNDEFINED;
|
||||
|
||||
|
||||
/**
|
||||
* @param {module:ol/PluggableMap} map Map.
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @private
|
||||
*/
|
||||
MapRenderer.prototype.removeUnusedLayerRenderers_ = function(map, frameState) {
|
||||
for (const layerKey in this.layerRenderers_) {
|
||||
if (!frameState || !(layerKey in frameState.layerStates)) {
|
||||
this.removeLayerRendererByKey_(layerKey).dispose();
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @protected
|
||||
*/
|
||||
MapRenderer.prototype.scheduleExpireIconCache = function(frameState) {
|
||||
frameState.postRenderFunctions.push(/** @type {module:ol/PluggableMap~PostRenderFunction} */ (expireIconCache));
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {!module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @protected
|
||||
*/
|
||||
MapRenderer.prototype.scheduleRemoveUnusedLayerRenderers = function(frameState) {
|
||||
for (const layerKey in this.layerRenderers_) {
|
||||
if (!(layerKey in frameState.layerStates)) {
|
||||
frameState.postRenderFunctions.push(
|
||||
/** @type {module:ol/PluggableMap~PostRenderFunction} */ (this.removeUnusedLayerRenderers_.bind(this))
|
||||
);
|
||||
return;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {module:ol/layer/Layer~State} state1 First layer state.
|
||||
* @param {module:ol/layer/Layer~State} state2 Second layer state.
|
||||
|
||||
@@ -20,44 +20,172 @@ import {create as createTransform, compose as composeTransform} from '../../tran
|
||||
* @param {module:ol/layer/Image|module:ol/layer/Vector} imageLayer Image or vector layer.
|
||||
* @api
|
||||
*/
|
||||
const CanvasImageLayerRenderer = function(imageLayer) {
|
||||
class CanvasImageLayerRenderer {
|
||||
constructor(imageLayer) {
|
||||
|
||||
IntermediateCanvasRenderer.call(this, imageLayer);
|
||||
IntermediateCanvasRenderer.call(this, imageLayer);
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {?module:ol/ImageBase}
|
||||
*/
|
||||
this.image_ = null;
|
||||
/**
|
||||
* @private
|
||||
* @type {?module:ol/ImageBase}
|
||||
*/
|
||||
this.image_ = null;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/transform~Transform}
|
||||
*/
|
||||
this.imageTransform_ = createTransform();
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/transform~Transform}
|
||||
*/
|
||||
this.imageTransform_ = createTransform();
|
||||
|
||||
/**
|
||||
* @type {!Array.<string>}
|
||||
*/
|
||||
this.skippedFeatures_ = [];
|
||||
/**
|
||||
* @type {!Array.<string>}
|
||||
*/
|
||||
this.skippedFeatures_ = [];
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/renderer/canvas/VectorLayer}
|
||||
*/
|
||||
this.vectorRenderer_ = null;
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/renderer/canvas/VectorLayer}
|
||||
*/
|
||||
this.vectorRenderer_ = null;
|
||||
|
||||
if (imageLayer.getType() === LayerType.VECTOR) {
|
||||
for (let i = 0, ii = layerRendererConstructors.length; i < ii; ++i) {
|
||||
const ctor = layerRendererConstructors[i];
|
||||
if (ctor !== CanvasImageLayerRenderer && ctor['handles'](imageLayer)) {
|
||||
this.vectorRenderer_ = new ctor(imageLayer);
|
||||
break;
|
||||
if (imageLayer.getType() === LayerType.VECTOR) {
|
||||
for (let i = 0, ii = layerRendererConstructors.length; i < ii; ++i) {
|
||||
const ctor = layerRendererConstructors[i];
|
||||
if (ctor !== CanvasImageLayerRenderer && ctor['handles'](imageLayer)) {
|
||||
this.vectorRenderer_ = new ctor(imageLayer);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
};
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
disposeInternal() {
|
||||
if (this.vectorRenderer_) {
|
||||
this.vectorRenderer_.dispose();
|
||||
}
|
||||
IntermediateCanvasRenderer.prototype.disposeInternal.call(this);
|
||||
}
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
getImage() {
|
||||
return !this.image_ ? null : this.image_.getImage();
|
||||
}
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
getImageTransform() {
|
||||
return this.imageTransform_;
|
||||
}
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
prepareFrame(frameState, layerState) {
|
||||
|
||||
const pixelRatio = frameState.pixelRatio;
|
||||
const size = frameState.size;
|
||||
const viewState = frameState.viewState;
|
||||
const viewCenter = viewState.center;
|
||||
const viewResolution = viewState.resolution;
|
||||
|
||||
let image;
|
||||
const imageLayer = /** @type {module:ol/layer/Image} */ (this.getLayer());
|
||||
const imageSource = imageLayer.getSource();
|
||||
|
||||
const hints = frameState.viewHints;
|
||||
|
||||
const vectorRenderer = this.vectorRenderer_;
|
||||
let renderedExtent = frameState.extent;
|
||||
if (!vectorRenderer && layerState.extent !== undefined) {
|
||||
renderedExtent = getIntersection(renderedExtent, layerState.extent);
|
||||
}
|
||||
|
||||
if (!hints[ViewHint.ANIMATING] && !hints[ViewHint.INTERACTING] &&
|
||||
!isEmpty(renderedExtent)) {
|
||||
let projection = viewState.projection;
|
||||
if (!ENABLE_RASTER_REPROJECTION) {
|
||||
const sourceProjection = imageSource.getProjection();
|
||||
if (sourceProjection) {
|
||||
projection = sourceProjection;
|
||||
}
|
||||
}
|
||||
let skippedFeatures = this.skippedFeatures_;
|
||||
if (vectorRenderer) {
|
||||
const context = vectorRenderer.context;
|
||||
const imageFrameState = /** @type {module:ol/PluggableMap~FrameState} */ (assign({}, frameState, {
|
||||
size: [
|
||||
getWidth(renderedExtent) / viewResolution,
|
||||
getHeight(renderedExtent) / viewResolution
|
||||
],
|
||||
viewState: /** @type {module:ol/View~State} */ (assign({}, frameState.viewState, {
|
||||
rotation: 0
|
||||
}))
|
||||
}));
|
||||
const newSkippedFeatures = Object.keys(imageFrameState.skippedFeatureUids).sort();
|
||||
image = new ImageCanvas(renderedExtent, viewResolution, pixelRatio, context.canvas, function(callback) {
|
||||
if (vectorRenderer.prepareFrame(imageFrameState, layerState) &&
|
||||
(vectorRenderer.replayGroupChanged ||
|
||||
!equals(skippedFeatures, newSkippedFeatures))) {
|
||||
context.canvas.width = imageFrameState.size[0] * pixelRatio;
|
||||
context.canvas.height = imageFrameState.size[1] * pixelRatio;
|
||||
vectorRenderer.compose(context, imageFrameState, layerState);
|
||||
skippedFeatures = newSkippedFeatures;
|
||||
callback();
|
||||
}
|
||||
});
|
||||
} else {
|
||||
image = imageSource.getImage(
|
||||
renderedExtent, viewResolution, pixelRatio, projection);
|
||||
}
|
||||
if (image && this.loadImage(image)) {
|
||||
this.image_ = image;
|
||||
this.skippedFeatures_ = skippedFeatures;
|
||||
}
|
||||
}
|
||||
|
||||
if (this.image_) {
|
||||
image = this.image_;
|
||||
const imageExtent = image.getExtent();
|
||||
const imageResolution = image.getResolution();
|
||||
const imagePixelRatio = image.getPixelRatio();
|
||||
const scale = pixelRatio * imageResolution /
|
||||
(viewResolution * imagePixelRatio);
|
||||
const transform = composeTransform(this.imageTransform_,
|
||||
pixelRatio * size[0] / 2, pixelRatio * size[1] / 2,
|
||||
scale, scale,
|
||||
0,
|
||||
imagePixelRatio * (imageExtent[0] - viewCenter[0]) / imageResolution,
|
||||
imagePixelRatio * (viewCenter[1] - imageExtent[3]) / imageResolution);
|
||||
composeTransform(this.coordinateToCanvasPixelTransform,
|
||||
pixelRatio * size[0] / 2 - transform[4], pixelRatio * size[1] / 2 - transform[5],
|
||||
pixelRatio / viewResolution, -pixelRatio / viewResolution,
|
||||
0,
|
||||
-viewCenter[0], -viewCenter[1]);
|
||||
|
||||
this.renderedResolution = imageResolution * pixelRatio / imagePixelRatio;
|
||||
}
|
||||
|
||||
return !!this.image_;
|
||||
}
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
forEachFeatureAtCoordinate(coordinate, frameState, hitTolerance, callback, thisArg) {
|
||||
if (this.vectorRenderer_) {
|
||||
return this.vectorRenderer_.forEachFeatureAtCoordinate(coordinate, frameState, hitTolerance, callback, thisArg);
|
||||
} else {
|
||||
return IntermediateCanvasRenderer.prototype.forEachFeatureAtCoordinate.call(this, coordinate, frameState, hitTolerance, callback, thisArg);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
inherits(CanvasImageLayerRenderer, IntermediateCanvasRenderer);
|
||||
|
||||
@@ -85,135 +213,4 @@ CanvasImageLayerRenderer['create'] = function(mapRenderer, layer) {
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
CanvasImageLayerRenderer.prototype.disposeInternal = function() {
|
||||
if (this.vectorRenderer_) {
|
||||
this.vectorRenderer_.dispose();
|
||||
}
|
||||
IntermediateCanvasRenderer.prototype.disposeInternal.call(this);
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
CanvasImageLayerRenderer.prototype.getImage = function() {
|
||||
return !this.image_ ? null : this.image_.getImage();
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
CanvasImageLayerRenderer.prototype.getImageTransform = function() {
|
||||
return this.imageTransform_;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
CanvasImageLayerRenderer.prototype.prepareFrame = function(frameState, layerState) {
|
||||
|
||||
const pixelRatio = frameState.pixelRatio;
|
||||
const size = frameState.size;
|
||||
const viewState = frameState.viewState;
|
||||
const viewCenter = viewState.center;
|
||||
const viewResolution = viewState.resolution;
|
||||
|
||||
let image;
|
||||
const imageLayer = /** @type {module:ol/layer/Image} */ (this.getLayer());
|
||||
const imageSource = imageLayer.getSource();
|
||||
|
||||
const hints = frameState.viewHints;
|
||||
|
||||
const vectorRenderer = this.vectorRenderer_;
|
||||
let renderedExtent = frameState.extent;
|
||||
if (!vectorRenderer && layerState.extent !== undefined) {
|
||||
renderedExtent = getIntersection(renderedExtent, layerState.extent);
|
||||
}
|
||||
|
||||
if (!hints[ViewHint.ANIMATING] && !hints[ViewHint.INTERACTING] &&
|
||||
!isEmpty(renderedExtent)) {
|
||||
let projection = viewState.projection;
|
||||
if (!ENABLE_RASTER_REPROJECTION) {
|
||||
const sourceProjection = imageSource.getProjection();
|
||||
if (sourceProjection) {
|
||||
projection = sourceProjection;
|
||||
}
|
||||
}
|
||||
let skippedFeatures = this.skippedFeatures_;
|
||||
if (vectorRenderer) {
|
||||
const context = vectorRenderer.context;
|
||||
const imageFrameState = /** @type {module:ol/PluggableMap~FrameState} */ (assign({}, frameState, {
|
||||
size: [
|
||||
getWidth(renderedExtent) / viewResolution,
|
||||
getHeight(renderedExtent) / viewResolution
|
||||
],
|
||||
viewState: /** @type {module:ol/View~State} */ (assign({}, frameState.viewState, {
|
||||
rotation: 0
|
||||
}))
|
||||
}));
|
||||
const newSkippedFeatures = Object.keys(imageFrameState.skippedFeatureUids).sort();
|
||||
image = new ImageCanvas(renderedExtent, viewResolution, pixelRatio, context.canvas, function(callback) {
|
||||
if (vectorRenderer.prepareFrame(imageFrameState, layerState) &&
|
||||
(vectorRenderer.replayGroupChanged ||
|
||||
!equals(skippedFeatures, newSkippedFeatures))) {
|
||||
context.canvas.width = imageFrameState.size[0] * pixelRatio;
|
||||
context.canvas.height = imageFrameState.size[1] * pixelRatio;
|
||||
vectorRenderer.compose(context, imageFrameState, layerState);
|
||||
skippedFeatures = newSkippedFeatures;
|
||||
callback();
|
||||
}
|
||||
});
|
||||
} else {
|
||||
image = imageSource.getImage(
|
||||
renderedExtent, viewResolution, pixelRatio, projection);
|
||||
}
|
||||
if (image && this.loadImage(image)) {
|
||||
this.image_ = image;
|
||||
this.skippedFeatures_ = skippedFeatures;
|
||||
}
|
||||
}
|
||||
|
||||
if (this.image_) {
|
||||
image = this.image_;
|
||||
const imageExtent = image.getExtent();
|
||||
const imageResolution = image.getResolution();
|
||||
const imagePixelRatio = image.getPixelRatio();
|
||||
const scale = pixelRatio * imageResolution /
|
||||
(viewResolution * imagePixelRatio);
|
||||
const transform = composeTransform(this.imageTransform_,
|
||||
pixelRatio * size[0] / 2, pixelRatio * size[1] / 2,
|
||||
scale, scale,
|
||||
0,
|
||||
imagePixelRatio * (imageExtent[0] - viewCenter[0]) / imageResolution,
|
||||
imagePixelRatio * (viewCenter[1] - imageExtent[3]) / imageResolution);
|
||||
composeTransform(this.coordinateToCanvasPixelTransform,
|
||||
pixelRatio * size[0] / 2 - transform[4], pixelRatio * size[1] / 2 - transform[5],
|
||||
pixelRatio / viewResolution, -pixelRatio / viewResolution,
|
||||
0,
|
||||
-viewCenter[0], -viewCenter[1]);
|
||||
|
||||
this.renderedResolution = imageResolution * pixelRatio / imagePixelRatio;
|
||||
}
|
||||
|
||||
return !!this.image_;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
CanvasImageLayerRenderer.prototype.forEachFeatureAtCoordinate = function(coordinate, frameState, hitTolerance, callback, thisArg) {
|
||||
if (this.vectorRenderer_) {
|
||||
return this.vectorRenderer_.forEachFeatureAtCoordinate(coordinate, frameState, hitTolerance, callback, thisArg);
|
||||
} else {
|
||||
return IntermediateCanvasRenderer.prototype.forEachFeatureAtCoordinate.call(this, coordinate, frameState, hitTolerance, callback, thisArg);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
export default CanvasImageLayerRenderer;
|
||||
|
||||
@@ -15,137 +15,135 @@ import {create as createTransform, apply as applyTransform} from '../../transfor
|
||||
* @extends {module:ol/renderer/canvas/Layer}
|
||||
* @param {module:ol/layer/Layer} layer Layer.
|
||||
*/
|
||||
const IntermediateCanvasRenderer = function(layer) {
|
||||
class IntermediateCanvasRenderer {
|
||||
constructor(layer) {
|
||||
|
||||
CanvasLayerRenderer.call(this, layer);
|
||||
CanvasLayerRenderer.call(this, layer);
|
||||
|
||||
/**
|
||||
* @protected
|
||||
* @type {module:ol/transform~Transform}
|
||||
*/
|
||||
this.coordinateToCanvasPixelTransform = createTransform();
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {CanvasRenderingContext2D}
|
||||
*/
|
||||
this.hitCanvasContext_ = null;
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* @protected
|
||||
* @type {module:ol/transform~Transform}
|
||||
* @inheritDoc
|
||||
*/
|
||||
this.coordinateToCanvasPixelTransform = createTransform();
|
||||
composeFrame(frameState, layerState, context) {
|
||||
|
||||
this.preCompose(context, frameState);
|
||||
|
||||
const image = this.getImage();
|
||||
if (image) {
|
||||
|
||||
// clipped rendering if layer extent is set
|
||||
const extent = layerState.extent;
|
||||
const clipped = extent !== undefined &&
|
||||
!containsExtent(extent, frameState.extent) &&
|
||||
intersects(extent, frameState.extent);
|
||||
if (clipped) {
|
||||
this.clip(context, frameState, /** @type {module:ol/extent~Extent} */ (extent));
|
||||
}
|
||||
|
||||
const imageTransform = this.getImageTransform();
|
||||
// for performance reasons, context.save / context.restore is not used
|
||||
// to save and restore the transformation matrix and the opacity.
|
||||
// see http://jsperf.com/context-save-restore-versus-variable
|
||||
const alpha = context.globalAlpha;
|
||||
context.globalAlpha = layerState.opacity;
|
||||
|
||||
// for performance reasons, context.setTransform is only used
|
||||
// when the view is rotated. see http://jsperf.com/canvas-transform
|
||||
const dx = imageTransform[4];
|
||||
const dy = imageTransform[5];
|
||||
const dw = image.width * imageTransform[0];
|
||||
const dh = image.height * imageTransform[3];
|
||||
context.drawImage(image, 0, 0, +image.width, +image.height,
|
||||
Math.round(dx), Math.round(dy), Math.round(dw), Math.round(dh));
|
||||
context.globalAlpha = alpha;
|
||||
|
||||
if (clipped) {
|
||||
context.restore();
|
||||
}
|
||||
}
|
||||
|
||||
this.postCompose(context, frameState, layerState);
|
||||
}
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {CanvasRenderingContext2D}
|
||||
* @abstract
|
||||
* @return {HTMLCanvasElement|HTMLVideoElement|HTMLImageElement} Canvas.
|
||||
*/
|
||||
this.hitCanvasContext_ = null;
|
||||
getImage() {}
|
||||
|
||||
};
|
||||
/**
|
||||
* @abstract
|
||||
* @return {!module:ol/transform~Transform} Image transform.
|
||||
*/
|
||||
getImageTransform() {}
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
forEachFeatureAtCoordinate(coordinate, frameState, hitTolerance, callback, thisArg) {
|
||||
const layer = this.getLayer();
|
||||
const source = layer.getSource();
|
||||
const resolution = frameState.viewState.resolution;
|
||||
const rotation = frameState.viewState.rotation;
|
||||
const skippedFeatureUids = frameState.skippedFeatureUids;
|
||||
return source.forEachFeatureAtCoordinate(
|
||||
coordinate, resolution, rotation, hitTolerance, skippedFeatureUids,
|
||||
/**
|
||||
* @param {module:ol/Feature|module:ol/render/Feature} feature Feature.
|
||||
* @return {?} Callback result.
|
||||
*/
|
||||
function(feature) {
|
||||
return callback.call(thisArg, feature, layer);
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
forEachLayerAtCoordinate(coordinate, frameState, hitTolerance, callback, thisArg) {
|
||||
if (!this.getImage()) {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
if (this.getLayer().getSource().forEachFeatureAtCoordinate !== UNDEFINED) {
|
||||
// for ImageCanvas sources use the original hit-detection logic,
|
||||
// so that for example also transparent polygons are detected
|
||||
return CanvasLayerRenderer.prototype.forEachLayerAtCoordinate.apply(this, arguments);
|
||||
} else {
|
||||
const pixel = applyTransform(this.coordinateToCanvasPixelTransform, coordinate.slice());
|
||||
scaleCoordinate(pixel, frameState.viewState.resolution / this.renderedResolution);
|
||||
|
||||
if (!this.hitCanvasContext_) {
|
||||
this.hitCanvasContext_ = createCanvasContext2D(1, 1);
|
||||
}
|
||||
|
||||
this.hitCanvasContext_.clearRect(0, 0, 1, 1);
|
||||
this.hitCanvasContext_.drawImage(this.getImage(), pixel[0], pixel[1], 1, 1, 0, 0, 1, 1);
|
||||
|
||||
const imageData = this.hitCanvasContext_.getImageData(0, 0, 1, 1).data;
|
||||
if (imageData[3] > 0) {
|
||||
return callback.call(thisArg, this.getLayer(), imageData);
|
||||
} else {
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
inherits(IntermediateCanvasRenderer, CanvasLayerRenderer);
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
IntermediateCanvasRenderer.prototype.composeFrame = function(frameState, layerState, context) {
|
||||
|
||||
this.preCompose(context, frameState);
|
||||
|
||||
const image = this.getImage();
|
||||
if (image) {
|
||||
|
||||
// clipped rendering if layer extent is set
|
||||
const extent = layerState.extent;
|
||||
const clipped = extent !== undefined &&
|
||||
!containsExtent(extent, frameState.extent) &&
|
||||
intersects(extent, frameState.extent);
|
||||
if (clipped) {
|
||||
this.clip(context, frameState, /** @type {module:ol/extent~Extent} */ (extent));
|
||||
}
|
||||
|
||||
const imageTransform = this.getImageTransform();
|
||||
// for performance reasons, context.save / context.restore is not used
|
||||
// to save and restore the transformation matrix and the opacity.
|
||||
// see http://jsperf.com/context-save-restore-versus-variable
|
||||
const alpha = context.globalAlpha;
|
||||
context.globalAlpha = layerState.opacity;
|
||||
|
||||
// for performance reasons, context.setTransform is only used
|
||||
// when the view is rotated. see http://jsperf.com/canvas-transform
|
||||
const dx = imageTransform[4];
|
||||
const dy = imageTransform[5];
|
||||
const dw = image.width * imageTransform[0];
|
||||
const dh = image.height * imageTransform[3];
|
||||
context.drawImage(image, 0, 0, +image.width, +image.height,
|
||||
Math.round(dx), Math.round(dy), Math.round(dw), Math.round(dh));
|
||||
context.globalAlpha = alpha;
|
||||
|
||||
if (clipped) {
|
||||
context.restore();
|
||||
}
|
||||
}
|
||||
|
||||
this.postCompose(context, frameState, layerState);
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @abstract
|
||||
* @return {HTMLCanvasElement|HTMLVideoElement|HTMLImageElement} Canvas.
|
||||
*/
|
||||
IntermediateCanvasRenderer.prototype.getImage = function() {};
|
||||
|
||||
|
||||
/**
|
||||
* @abstract
|
||||
* @return {!module:ol/transform~Transform} Image transform.
|
||||
*/
|
||||
IntermediateCanvasRenderer.prototype.getImageTransform = function() {};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
IntermediateCanvasRenderer.prototype.forEachFeatureAtCoordinate = function(coordinate, frameState, hitTolerance, callback, thisArg) {
|
||||
const layer = this.getLayer();
|
||||
const source = layer.getSource();
|
||||
const resolution = frameState.viewState.resolution;
|
||||
const rotation = frameState.viewState.rotation;
|
||||
const skippedFeatureUids = frameState.skippedFeatureUids;
|
||||
return source.forEachFeatureAtCoordinate(
|
||||
coordinate, resolution, rotation, hitTolerance, skippedFeatureUids,
|
||||
/**
|
||||
* @param {module:ol/Feature|module:ol/render/Feature} feature Feature.
|
||||
* @return {?} Callback result.
|
||||
*/
|
||||
function(feature) {
|
||||
return callback.call(thisArg, feature, layer);
|
||||
});
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
IntermediateCanvasRenderer.prototype.forEachLayerAtCoordinate = function(coordinate, frameState, hitTolerance, callback, thisArg) {
|
||||
if (!this.getImage()) {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
if (this.getLayer().getSource().forEachFeatureAtCoordinate !== UNDEFINED) {
|
||||
// for ImageCanvas sources use the original hit-detection logic,
|
||||
// so that for example also transparent polygons are detected
|
||||
return CanvasLayerRenderer.prototype.forEachLayerAtCoordinate.apply(this, arguments);
|
||||
} else {
|
||||
const pixel = applyTransform(this.coordinateToCanvasPixelTransform, coordinate.slice());
|
||||
scaleCoordinate(pixel, frameState.viewState.resolution / this.renderedResolution);
|
||||
|
||||
if (!this.hitCanvasContext_) {
|
||||
this.hitCanvasContext_ = createCanvasContext2D(1, 1);
|
||||
}
|
||||
|
||||
this.hitCanvasContext_.clearRect(0, 0, 1, 1);
|
||||
this.hitCanvasContext_.drawImage(this.getImage(), pixel[0], pixel[1], 1, 1, 0, 0, 1, 1);
|
||||
|
||||
const imageData = this.hitCanvasContext_.getImageData(0, 0, 1, 1).data;
|
||||
if (imageData[3] > 0) {
|
||||
return callback.call(thisArg, this.getLayer(), imageData);
|
||||
} else {
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
export default IntermediateCanvasRenderer;
|
||||
|
||||
+153
-157
@@ -17,175 +17,171 @@ import {create as createTransform, apply as applyTransform, compose as composeTr
|
||||
* @extends {module:ol/renderer/Layer}
|
||||
* @param {module:ol/layer/Layer} layer Layer.
|
||||
*/
|
||||
const CanvasLayerRenderer = function(layer) {
|
||||
class CanvasLayerRenderer {
|
||||
constructor(layer) {
|
||||
|
||||
LayerRenderer.call(this, layer);
|
||||
LayerRenderer.call(this, layer);
|
||||
|
||||
/**
|
||||
* @protected
|
||||
* @type {number}
|
||||
*/
|
||||
this.renderedResolution;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/transform~Transform}
|
||||
*/
|
||||
this.transform_ = createTransform();
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {CanvasRenderingContext2D} context Context.
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @param {module:ol/extent~Extent} extent Clip extent.
|
||||
* @protected
|
||||
* @type {number}
|
||||
*/
|
||||
this.renderedResolution;
|
||||
clip(context, frameState, extent) {
|
||||
const pixelRatio = frameState.pixelRatio;
|
||||
const width = frameState.size[0] * pixelRatio;
|
||||
const height = frameState.size[1] * pixelRatio;
|
||||
const rotation = frameState.viewState.rotation;
|
||||
const topLeft = getTopLeft(/** @type {module:ol/extent~Extent} */ (extent));
|
||||
const topRight = getTopRight(/** @type {module:ol/extent~Extent} */ (extent));
|
||||
const bottomRight = getBottomRight(/** @type {module:ol/extent~Extent} */ (extent));
|
||||
const bottomLeft = getBottomLeft(/** @type {module:ol/extent~Extent} */ (extent));
|
||||
|
||||
applyTransform(frameState.coordinateToPixelTransform, topLeft);
|
||||
applyTransform(frameState.coordinateToPixelTransform, topRight);
|
||||
applyTransform(frameState.coordinateToPixelTransform, bottomRight);
|
||||
applyTransform(frameState.coordinateToPixelTransform, bottomLeft);
|
||||
|
||||
context.save();
|
||||
rotateAtOffset(context, -rotation, width / 2, height / 2);
|
||||
context.beginPath();
|
||||
context.moveTo(topLeft[0] * pixelRatio, topLeft[1] * pixelRatio);
|
||||
context.lineTo(topRight[0] * pixelRatio, topRight[1] * pixelRatio);
|
||||
context.lineTo(bottomRight[0] * pixelRatio, bottomRight[1] * pixelRatio);
|
||||
context.lineTo(bottomLeft[0] * pixelRatio, bottomLeft[1] * pixelRatio);
|
||||
context.clip();
|
||||
rotateAtOffset(context, rotation, width / 2, height / 2);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {module:ol/render/EventType} type Event type.
|
||||
* @param {CanvasRenderingContext2D} context Context.
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @param {module:ol/transform~Transform=} opt_transform Transform.
|
||||
* @private
|
||||
* @type {module:ol/transform~Transform}
|
||||
*/
|
||||
this.transform_ = createTransform();
|
||||
dispatchComposeEvent_(type, context, frameState, opt_transform) {
|
||||
const layer = this.getLayer();
|
||||
if (layer.hasListener(type)) {
|
||||
const width = frameState.size[0] * frameState.pixelRatio;
|
||||
const height = frameState.size[1] * frameState.pixelRatio;
|
||||
const rotation = frameState.viewState.rotation;
|
||||
rotateAtOffset(context, -rotation, width / 2, height / 2);
|
||||
const transform = opt_transform !== undefined ?
|
||||
opt_transform : this.getTransform(frameState, 0);
|
||||
const render = new CanvasImmediateRenderer(
|
||||
context, frameState.pixelRatio, frameState.extent, transform,
|
||||
frameState.viewState.rotation);
|
||||
const composeEvent = new RenderEvent(type, render, frameState,
|
||||
context, null);
|
||||
layer.dispatchEvent(composeEvent);
|
||||
rotateAtOffset(context, rotation, width / 2, height / 2);
|
||||
}
|
||||
}
|
||||
|
||||
};
|
||||
/**
|
||||
* @param {module:ol/coordinate~Coordinate} coordinate Coordinate.
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState FrameState.
|
||||
* @param {number} hitTolerance Hit tolerance in pixels.
|
||||
* @param {function(this: S, module:ol/layer/Layer, (Uint8ClampedArray|Uint8Array)): T} callback Layer
|
||||
* callback.
|
||||
* @param {S} thisArg Value to use as `this` when executing `callback`.
|
||||
* @return {T|undefined} Callback result.
|
||||
* @template S,T,U
|
||||
*/
|
||||
forEachLayerAtCoordinate(coordinate, frameState, hitTolerance, callback, thisArg) {
|
||||
const hasFeature = this.forEachFeatureAtCoordinate(coordinate, frameState, hitTolerance, TRUE, this);
|
||||
|
||||
if (hasFeature) {
|
||||
return callback.call(thisArg, this.getLayer(), null);
|
||||
} else {
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {CanvasRenderingContext2D} context Context.
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @param {module:ol/layer/Layer~State} layerState Layer state.
|
||||
* @param {module:ol/transform~Transform=} opt_transform Transform.
|
||||
* @protected
|
||||
*/
|
||||
postCompose(context, frameState, layerState, opt_transform) {
|
||||
this.dispatchComposeEvent_(RenderEventType.POSTCOMPOSE, context, frameState, opt_transform);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {CanvasRenderingContext2D} context Context.
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @param {module:ol/transform~Transform=} opt_transform Transform.
|
||||
* @protected
|
||||
*/
|
||||
preCompose(context, frameState, opt_transform) {
|
||||
this.dispatchComposeEvent_(RenderEventType.PRECOMPOSE, context, frameState, opt_transform);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {CanvasRenderingContext2D} context Context.
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @param {module:ol/transform~Transform=} opt_transform Transform.
|
||||
* @protected
|
||||
*/
|
||||
dispatchRenderEvent(context, frameState, opt_transform) {
|
||||
this.dispatchComposeEvent_(RenderEventType.RENDER, context, frameState, opt_transform);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @param {number} offsetX Offset on the x-axis in view coordinates.
|
||||
* @protected
|
||||
* @return {!module:ol/transform~Transform} Transform.
|
||||
*/
|
||||
getTransform(frameState, offsetX) {
|
||||
const viewState = frameState.viewState;
|
||||
const pixelRatio = frameState.pixelRatio;
|
||||
const dx1 = pixelRatio * frameState.size[0] / 2;
|
||||
const dy1 = pixelRatio * frameState.size[1] / 2;
|
||||
const sx = pixelRatio / viewState.resolution;
|
||||
const sy = -sx;
|
||||
const angle = -viewState.rotation;
|
||||
const dx2 = -viewState.center[0] + offsetX;
|
||||
const dy2 = -viewState.center[1];
|
||||
return composeTransform(this.transform_, dx1, dy1, sx, sy, angle, dx2, dy2);
|
||||
}
|
||||
|
||||
/**
|
||||
* @abstract
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @param {module:ol/layer/Layer~State} layerState Layer state.
|
||||
* @param {CanvasRenderingContext2D} context Context.
|
||||
*/
|
||||
composeFrame(frameState, layerState, context) {}
|
||||
|
||||
/**
|
||||
* @abstract
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @param {module:ol/layer/Layer~State} layerState Layer state.
|
||||
* @return {boolean} whether composeFrame should be called.
|
||||
*/
|
||||
prepareFrame(frameState, layerState) {}
|
||||
}
|
||||
|
||||
inherits(CanvasLayerRenderer, LayerRenderer);
|
||||
|
||||
|
||||
/**
|
||||
* @param {CanvasRenderingContext2D} context Context.
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @param {module:ol/extent~Extent} extent Clip extent.
|
||||
* @protected
|
||||
*/
|
||||
CanvasLayerRenderer.prototype.clip = function(context, frameState, extent) {
|
||||
const pixelRatio = frameState.pixelRatio;
|
||||
const width = frameState.size[0] * pixelRatio;
|
||||
const height = frameState.size[1] * pixelRatio;
|
||||
const rotation = frameState.viewState.rotation;
|
||||
const topLeft = getTopLeft(/** @type {module:ol/extent~Extent} */ (extent));
|
||||
const topRight = getTopRight(/** @type {module:ol/extent~Extent} */ (extent));
|
||||
const bottomRight = getBottomRight(/** @type {module:ol/extent~Extent} */ (extent));
|
||||
const bottomLeft = getBottomLeft(/** @type {module:ol/extent~Extent} */ (extent));
|
||||
|
||||
applyTransform(frameState.coordinateToPixelTransform, topLeft);
|
||||
applyTransform(frameState.coordinateToPixelTransform, topRight);
|
||||
applyTransform(frameState.coordinateToPixelTransform, bottomRight);
|
||||
applyTransform(frameState.coordinateToPixelTransform, bottomLeft);
|
||||
|
||||
context.save();
|
||||
rotateAtOffset(context, -rotation, width / 2, height / 2);
|
||||
context.beginPath();
|
||||
context.moveTo(topLeft[0] * pixelRatio, topLeft[1] * pixelRatio);
|
||||
context.lineTo(topRight[0] * pixelRatio, topRight[1] * pixelRatio);
|
||||
context.lineTo(bottomRight[0] * pixelRatio, bottomRight[1] * pixelRatio);
|
||||
context.lineTo(bottomLeft[0] * pixelRatio, bottomLeft[1] * pixelRatio);
|
||||
context.clip();
|
||||
rotateAtOffset(context, rotation, width / 2, height / 2);
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {module:ol/render/EventType} type Event type.
|
||||
* @param {CanvasRenderingContext2D} context Context.
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @param {module:ol/transform~Transform=} opt_transform Transform.
|
||||
* @private
|
||||
*/
|
||||
CanvasLayerRenderer.prototype.dispatchComposeEvent_ = function(type, context, frameState, opt_transform) {
|
||||
const layer = this.getLayer();
|
||||
if (layer.hasListener(type)) {
|
||||
const width = frameState.size[0] * frameState.pixelRatio;
|
||||
const height = frameState.size[1] * frameState.pixelRatio;
|
||||
const rotation = frameState.viewState.rotation;
|
||||
rotateAtOffset(context, -rotation, width / 2, height / 2);
|
||||
const transform = opt_transform !== undefined ?
|
||||
opt_transform : this.getTransform(frameState, 0);
|
||||
const render = new CanvasImmediateRenderer(
|
||||
context, frameState.pixelRatio, frameState.extent, transform,
|
||||
frameState.viewState.rotation);
|
||||
const composeEvent = new RenderEvent(type, render, frameState,
|
||||
context, null);
|
||||
layer.dispatchEvent(composeEvent);
|
||||
rotateAtOffset(context, rotation, width / 2, height / 2);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {module:ol/coordinate~Coordinate} coordinate Coordinate.
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState FrameState.
|
||||
* @param {number} hitTolerance Hit tolerance in pixels.
|
||||
* @param {function(this: S, module:ol/layer/Layer, (Uint8ClampedArray|Uint8Array)): T} callback Layer
|
||||
* callback.
|
||||
* @param {S} thisArg Value to use as `this` when executing `callback`.
|
||||
* @return {T|undefined} Callback result.
|
||||
* @template S,T,U
|
||||
*/
|
||||
CanvasLayerRenderer.prototype.forEachLayerAtCoordinate = function(coordinate, frameState, hitTolerance, callback, thisArg) {
|
||||
const hasFeature = this.forEachFeatureAtCoordinate(coordinate, frameState, hitTolerance, TRUE, this);
|
||||
|
||||
if (hasFeature) {
|
||||
return callback.call(thisArg, this.getLayer(), null);
|
||||
} else {
|
||||
return undefined;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {CanvasRenderingContext2D} context Context.
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @param {module:ol/layer/Layer~State} layerState Layer state.
|
||||
* @param {module:ol/transform~Transform=} opt_transform Transform.
|
||||
* @protected
|
||||
*/
|
||||
CanvasLayerRenderer.prototype.postCompose = function(context, frameState, layerState, opt_transform) {
|
||||
this.dispatchComposeEvent_(RenderEventType.POSTCOMPOSE, context, frameState, opt_transform);
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {CanvasRenderingContext2D} context Context.
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @param {module:ol/transform~Transform=} opt_transform Transform.
|
||||
* @protected
|
||||
*/
|
||||
CanvasLayerRenderer.prototype.preCompose = function(context, frameState, opt_transform) {
|
||||
this.dispatchComposeEvent_(RenderEventType.PRECOMPOSE, context, frameState, opt_transform);
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {CanvasRenderingContext2D} context Context.
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @param {module:ol/transform~Transform=} opt_transform Transform.
|
||||
* @protected
|
||||
*/
|
||||
CanvasLayerRenderer.prototype.dispatchRenderEvent = function(context, frameState, opt_transform) {
|
||||
this.dispatchComposeEvent_(RenderEventType.RENDER, context, frameState, opt_transform);
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @param {number} offsetX Offset on the x-axis in view coordinates.
|
||||
* @protected
|
||||
* @return {!module:ol/transform~Transform} Transform.
|
||||
*/
|
||||
CanvasLayerRenderer.prototype.getTransform = function(frameState, offsetX) {
|
||||
const viewState = frameState.viewState;
|
||||
const pixelRatio = frameState.pixelRatio;
|
||||
const dx1 = pixelRatio * frameState.size[0] / 2;
|
||||
const dy1 = pixelRatio * frameState.size[1] / 2;
|
||||
const sx = pixelRatio / viewState.resolution;
|
||||
const sy = -sx;
|
||||
const angle = -viewState.rotation;
|
||||
const dx2 = -viewState.center[0] + offsetX;
|
||||
const dy2 = -viewState.center[1];
|
||||
return composeTransform(this.transform_, dx1, dy1, sx, sy, angle, dx2, dy2);
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @abstract
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @param {module:ol/layer/Layer~State} layerState Layer state.
|
||||
* @param {CanvasRenderingContext2D} context Context.
|
||||
*/
|
||||
CanvasLayerRenderer.prototype.composeFrame = function(frameState, layerState, context) {};
|
||||
|
||||
/**
|
||||
* @abstract
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @param {module:ol/layer/Layer~State} layerState Layer state.
|
||||
* @return {boolean} whether composeFrame should be called.
|
||||
*/
|
||||
CanvasLayerRenderer.prototype.prepareFrame = function(frameState, layerState) {};
|
||||
export default CanvasLayerRenderer;
|
||||
|
||||
+175
-178
@@ -27,201 +27,198 @@ export const layerRendererConstructors = [];
|
||||
* @param {module:ol/PluggableMap} map Map.
|
||||
* @api
|
||||
*/
|
||||
const CanvasMapRenderer = function(map) {
|
||||
MapRenderer.call(this, map);
|
||||
class CanvasMapRenderer {
|
||||
constructor(map) {
|
||||
MapRenderer.call(this, map);
|
||||
|
||||
const container = map.getViewport();
|
||||
const container = map.getViewport();
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {CanvasRenderingContext2D}
|
||||
*/
|
||||
this.context_ = createCanvasContext2D();
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {HTMLCanvasElement}
|
||||
*/
|
||||
this.canvas_ = this.context_.canvas;
|
||||
|
||||
this.canvas_.style.width = '100%';
|
||||
this.canvas_.style.height = '100%';
|
||||
this.canvas_.style.display = 'block';
|
||||
this.canvas_.className = CLASS_UNSELECTABLE;
|
||||
container.insertBefore(this.canvas_, container.childNodes[0] || null);
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {boolean}
|
||||
*/
|
||||
this.renderedVisible_ = true;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/transform~Transform}
|
||||
*/
|
||||
this.transform_ = createTransform();
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {module:ol/render/EventType} type Event type.
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @private
|
||||
* @type {CanvasRenderingContext2D}
|
||||
*/
|
||||
this.context_ = createCanvasContext2D();
|
||||
dispatchComposeEvent_(type, frameState) {
|
||||
const map = this.getMap();
|
||||
const context = this.context_;
|
||||
if (map.hasListener(type)) {
|
||||
const extent = frameState.extent;
|
||||
const pixelRatio = frameState.pixelRatio;
|
||||
const viewState = frameState.viewState;
|
||||
const rotation = viewState.rotation;
|
||||
|
||||
const transform = this.getTransform(frameState);
|
||||
|
||||
const vectorContext = new CanvasImmediateRenderer(context, pixelRatio,
|
||||
extent, transform, rotation);
|
||||
const composeEvent = new RenderEvent(type, vectorContext,
|
||||
frameState, context, null);
|
||||
map.dispatchEvent(composeEvent);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {HTMLCanvasElement}
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @protected
|
||||
* @return {!module:ol/transform~Transform} Transform.
|
||||
*/
|
||||
this.canvas_ = this.context_.canvas;
|
||||
|
||||
this.canvas_.style.width = '100%';
|
||||
this.canvas_.style.height = '100%';
|
||||
this.canvas_.style.display = 'block';
|
||||
this.canvas_.className = CLASS_UNSELECTABLE;
|
||||
container.insertBefore(this.canvas_, container.childNodes[0] || null);
|
||||
getTransform(frameState) {
|
||||
const viewState = frameState.viewState;
|
||||
const dx1 = this.canvas_.width / 2;
|
||||
const dy1 = this.canvas_.height / 2;
|
||||
const sx = frameState.pixelRatio / viewState.resolution;
|
||||
const sy = -sx;
|
||||
const angle = -viewState.rotation;
|
||||
const dx2 = -viewState.center[0];
|
||||
const dy2 = -viewState.center[1];
|
||||
return composeTransform(this.transform_, dx1, dy1, sx, sy, angle, dx2, dy2);
|
||||
}
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {boolean}
|
||||
* @inheritDoc
|
||||
*/
|
||||
this.renderedVisible_ = true;
|
||||
renderFrame(frameState) {
|
||||
|
||||
if (!frameState) {
|
||||
if (this.renderedVisible_) {
|
||||
this.canvas_.style.display = 'none';
|
||||
this.renderedVisible_ = false;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
const context = this.context_;
|
||||
const pixelRatio = frameState.pixelRatio;
|
||||
const width = Math.round(frameState.size[0] * pixelRatio);
|
||||
const height = Math.round(frameState.size[1] * pixelRatio);
|
||||
if (this.canvas_.width != width || this.canvas_.height != height) {
|
||||
this.canvas_.width = width;
|
||||
this.canvas_.height = height;
|
||||
} else {
|
||||
context.clearRect(0, 0, width, height);
|
||||
}
|
||||
|
||||
const rotation = frameState.viewState.rotation;
|
||||
|
||||
this.calculateMatrices2D(frameState);
|
||||
|
||||
this.dispatchComposeEvent_(RenderEventType.PRECOMPOSE, frameState);
|
||||
|
||||
const layerStatesArray = frameState.layerStatesArray;
|
||||
stableSort(layerStatesArray, sortByZIndex);
|
||||
|
||||
if (rotation) {
|
||||
context.save();
|
||||
rotateAtOffset(context, rotation, width / 2, height / 2);
|
||||
}
|
||||
|
||||
const viewResolution = frameState.viewState.resolution;
|
||||
let i, ii, layer, layerRenderer, layerState;
|
||||
for (i = 0, ii = layerStatesArray.length; i < ii; ++i) {
|
||||
layerState = layerStatesArray[i];
|
||||
layer = layerState.layer;
|
||||
layerRenderer = /** @type {module:ol/renderer/canvas/Layer} */ (this.getLayerRenderer(layer));
|
||||
if (!visibleAtResolution(layerState, viewResolution) ||
|
||||
layerState.sourceState != SourceState.READY) {
|
||||
continue;
|
||||
}
|
||||
if (layerRenderer.prepareFrame(frameState, layerState)) {
|
||||
layerRenderer.composeFrame(frameState, layerState, context);
|
||||
}
|
||||
}
|
||||
|
||||
if (rotation) {
|
||||
context.restore();
|
||||
}
|
||||
|
||||
this.dispatchComposeEvent_(RenderEventType.POSTCOMPOSE, frameState);
|
||||
|
||||
if (!this.renderedVisible_) {
|
||||
this.canvas_.style.display = '';
|
||||
this.renderedVisible_ = true;
|
||||
}
|
||||
|
||||
this.scheduleRemoveUnusedLayerRenderers(frameState);
|
||||
this.scheduleExpireIconCache(frameState);
|
||||
}
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/transform~Transform}
|
||||
* @inheritDoc
|
||||
*/
|
||||
this.transform_ = createTransform();
|
||||
forEachLayerAtPixel(pixel, frameState, hitTolerance, callback, thisArg, layerFilter, thisArg2) {
|
||||
let result;
|
||||
const viewState = frameState.viewState;
|
||||
const viewResolution = viewState.resolution;
|
||||
|
||||
};
|
||||
const layerStates = frameState.layerStatesArray;
|
||||
const numLayers = layerStates.length;
|
||||
|
||||
const coordinate = applyTransform(
|
||||
frameState.pixelToCoordinateTransform, pixel.slice());
|
||||
|
||||
let i;
|
||||
for (i = numLayers - 1; i >= 0; --i) {
|
||||
const layerState = layerStates[i];
|
||||
const layer = layerState.layer;
|
||||
if (visibleAtResolution(layerState, viewResolution) && layerFilter.call(thisArg2, layer)) {
|
||||
const layerRenderer = /** @type {module:ol/renderer/canvas/Layer} */ (this.getLayerRenderer(layer));
|
||||
result = layerRenderer.forEachLayerAtCoordinate(
|
||||
coordinate, frameState, hitTolerance, callback, thisArg);
|
||||
if (result) {
|
||||
return result;
|
||||
}
|
||||
}
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
registerLayerRenderers(constructors) {
|
||||
MapRenderer.prototype.registerLayerRenderers.call(this, constructors);
|
||||
for (let i = 0, ii = constructors.length; i < ii; ++i) {
|
||||
const ctor = constructors[i];
|
||||
if (!includes(layerRendererConstructors, ctor)) {
|
||||
layerRendererConstructors.push(ctor);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
inherits(CanvasMapRenderer, MapRenderer);
|
||||
|
||||
|
||||
/**
|
||||
* @param {module:ol/render/EventType} type Event type.
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @private
|
||||
*/
|
||||
CanvasMapRenderer.prototype.dispatchComposeEvent_ = function(type, frameState) {
|
||||
const map = this.getMap();
|
||||
const context = this.context_;
|
||||
if (map.hasListener(type)) {
|
||||
const extent = frameState.extent;
|
||||
const pixelRatio = frameState.pixelRatio;
|
||||
const viewState = frameState.viewState;
|
||||
const rotation = viewState.rotation;
|
||||
|
||||
const transform = this.getTransform(frameState);
|
||||
|
||||
const vectorContext = new CanvasImmediateRenderer(context, pixelRatio,
|
||||
extent, transform, rotation);
|
||||
const composeEvent = new RenderEvent(type, vectorContext,
|
||||
frameState, context, null);
|
||||
map.dispatchEvent(composeEvent);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @protected
|
||||
* @return {!module:ol/transform~Transform} Transform.
|
||||
*/
|
||||
CanvasMapRenderer.prototype.getTransform = function(frameState) {
|
||||
const viewState = frameState.viewState;
|
||||
const dx1 = this.canvas_.width / 2;
|
||||
const dy1 = this.canvas_.height / 2;
|
||||
const sx = frameState.pixelRatio / viewState.resolution;
|
||||
const sy = -sx;
|
||||
const angle = -viewState.rotation;
|
||||
const dx2 = -viewState.center[0];
|
||||
const dy2 = -viewState.center[1];
|
||||
return composeTransform(this.transform_, dx1, dy1, sx, sy, angle, dx2, dy2);
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
CanvasMapRenderer.prototype.renderFrame = function(frameState) {
|
||||
|
||||
if (!frameState) {
|
||||
if (this.renderedVisible_) {
|
||||
this.canvas_.style.display = 'none';
|
||||
this.renderedVisible_ = false;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
const context = this.context_;
|
||||
const pixelRatio = frameState.pixelRatio;
|
||||
const width = Math.round(frameState.size[0] * pixelRatio);
|
||||
const height = Math.round(frameState.size[1] * pixelRatio);
|
||||
if (this.canvas_.width != width || this.canvas_.height != height) {
|
||||
this.canvas_.width = width;
|
||||
this.canvas_.height = height;
|
||||
} else {
|
||||
context.clearRect(0, 0, width, height);
|
||||
}
|
||||
|
||||
const rotation = frameState.viewState.rotation;
|
||||
|
||||
this.calculateMatrices2D(frameState);
|
||||
|
||||
this.dispatchComposeEvent_(RenderEventType.PRECOMPOSE, frameState);
|
||||
|
||||
const layerStatesArray = frameState.layerStatesArray;
|
||||
stableSort(layerStatesArray, sortByZIndex);
|
||||
|
||||
if (rotation) {
|
||||
context.save();
|
||||
rotateAtOffset(context, rotation, width / 2, height / 2);
|
||||
}
|
||||
|
||||
const viewResolution = frameState.viewState.resolution;
|
||||
let i, ii, layer, layerRenderer, layerState;
|
||||
for (i = 0, ii = layerStatesArray.length; i < ii; ++i) {
|
||||
layerState = layerStatesArray[i];
|
||||
layer = layerState.layer;
|
||||
layerRenderer = /** @type {module:ol/renderer/canvas/Layer} */ (this.getLayerRenderer(layer));
|
||||
if (!visibleAtResolution(layerState, viewResolution) ||
|
||||
layerState.sourceState != SourceState.READY) {
|
||||
continue;
|
||||
}
|
||||
if (layerRenderer.prepareFrame(frameState, layerState)) {
|
||||
layerRenderer.composeFrame(frameState, layerState, context);
|
||||
}
|
||||
}
|
||||
|
||||
if (rotation) {
|
||||
context.restore();
|
||||
}
|
||||
|
||||
this.dispatchComposeEvent_(RenderEventType.POSTCOMPOSE, frameState);
|
||||
|
||||
if (!this.renderedVisible_) {
|
||||
this.canvas_.style.display = '';
|
||||
this.renderedVisible_ = true;
|
||||
}
|
||||
|
||||
this.scheduleRemoveUnusedLayerRenderers(frameState);
|
||||
this.scheduleExpireIconCache(frameState);
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
CanvasMapRenderer.prototype.forEachLayerAtPixel = function(pixel, frameState, hitTolerance, callback, thisArg,
|
||||
layerFilter, thisArg2) {
|
||||
let result;
|
||||
const viewState = frameState.viewState;
|
||||
const viewResolution = viewState.resolution;
|
||||
|
||||
const layerStates = frameState.layerStatesArray;
|
||||
const numLayers = layerStates.length;
|
||||
|
||||
const coordinate = applyTransform(
|
||||
frameState.pixelToCoordinateTransform, pixel.slice());
|
||||
|
||||
let i;
|
||||
for (i = numLayers - 1; i >= 0; --i) {
|
||||
const layerState = layerStates[i];
|
||||
const layer = layerState.layer;
|
||||
if (visibleAtResolution(layerState, viewResolution) && layerFilter.call(thisArg2, layer)) {
|
||||
const layerRenderer = /** @type {module:ol/renderer/canvas/Layer} */ (this.getLayerRenderer(layer));
|
||||
result = layerRenderer.forEachLayerAtCoordinate(
|
||||
coordinate, frameState, hitTolerance, callback, thisArg);
|
||||
if (result) {
|
||||
return result;
|
||||
}
|
||||
}
|
||||
}
|
||||
return undefined;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
CanvasMapRenderer.prototype.registerLayerRenderers = function(constructors) {
|
||||
MapRenderer.prototype.registerLayerRenderers.call(this, constructors);
|
||||
for (let i = 0, ii = constructors.length; i < ii; ++i) {
|
||||
const ctor = constructors[i];
|
||||
if (!includes(layerRendererConstructors, ctor)) {
|
||||
layerRendererConstructors.push(ctor);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
export default CanvasMapRenderer;
|
||||
|
||||
+312
-313
@@ -17,71 +17,339 @@ import {create as createTransform, compose as composeTransform} from '../../tran
|
||||
* @param {module:ol/layer/Tile|module:ol/layer/VectorTile} tileLayer Tile layer.
|
||||
* @api
|
||||
*/
|
||||
const CanvasTileLayerRenderer = function(tileLayer) {
|
||||
class CanvasTileLayerRenderer {
|
||||
constructor(tileLayer) {
|
||||
|
||||
IntermediateCanvasRenderer.call(this, tileLayer);
|
||||
IntermediateCanvasRenderer.call(this, tileLayer);
|
||||
|
||||
/**
|
||||
* @protected
|
||||
* @type {CanvasRenderingContext2D}
|
||||
*/
|
||||
this.context = this.context === null ? null : createCanvasContext2D();
|
||||
/**
|
||||
* @protected
|
||||
* @type {CanvasRenderingContext2D}
|
||||
*/
|
||||
this.context = this.context === null ? null : createCanvasContext2D();
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {number}
|
||||
*/
|
||||
this.oversampling_;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/extent~Extent}
|
||||
*/
|
||||
this.renderedExtent_ = null;
|
||||
|
||||
/**
|
||||
* @protected
|
||||
* @type {number}
|
||||
*/
|
||||
this.renderedRevision;
|
||||
|
||||
/**
|
||||
* @protected
|
||||
* @type {!Array.<module:ol/Tile>}
|
||||
*/
|
||||
this.renderedTiles = [];
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {boolean}
|
||||
*/
|
||||
this.newTiles_ = false;
|
||||
|
||||
/**
|
||||
* @protected
|
||||
* @type {module:ol/extent~Extent}
|
||||
*/
|
||||
this.tmpExtent = createEmpty();
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/TileRange}
|
||||
*/
|
||||
this.tmpTileRange_ = new TileRange(0, 0, 0, 0);
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/transform~Transform}
|
||||
*/
|
||||
this.imageTransform_ = createTransform();
|
||||
|
||||
/**
|
||||
* @protected
|
||||
* @type {number}
|
||||
*/
|
||||
this.zDirection = 0;
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {number}
|
||||
* @param {module:ol/Tile} tile Tile.
|
||||
* @return {boolean} Tile is drawable.
|
||||
*/
|
||||
this.oversampling_;
|
||||
isDrawableTile_(tile) {
|
||||
const tileState = tile.getState();
|
||||
const useInterimTilesOnError = this.getLayer().getUseInterimTilesOnError();
|
||||
return tileState == TileState.LOADED ||
|
||||
tileState == TileState.EMPTY ||
|
||||
tileState == TileState.ERROR && !useInterimTilesOnError;
|
||||
}
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/extent~Extent}
|
||||
* @param {number} z Tile coordinate z.
|
||||
* @param {number} x Tile coordinate x.
|
||||
* @param {number} y Tile coordinate y.
|
||||
* @param {number} pixelRatio Pixel ratio.
|
||||
* @param {module:ol/proj/Projection} projection Projection.
|
||||
* @return {!module:ol/Tile} Tile.
|
||||
*/
|
||||
this.renderedExtent_ = null;
|
||||
getTile(z, x, y, pixelRatio, projection) {
|
||||
const layer = this.getLayer();
|
||||
const source = /** @type {module:ol/source/Tile} */ (layer.getSource());
|
||||
let tile = source.getTile(z, x, y, pixelRatio, projection);
|
||||
if (tile.getState() == TileState.ERROR) {
|
||||
if (!layer.getUseInterimTilesOnError()) {
|
||||
// When useInterimTilesOnError is false, we consider the error tile as loaded.
|
||||
tile.setState(TileState.LOADED);
|
||||
} else if (layer.getPreload() > 0) {
|
||||
// Preloaded tiles for lower resolutions might have finished loading.
|
||||
this.newTiles_ = true;
|
||||
}
|
||||
}
|
||||
if (!this.isDrawableTile_(tile)) {
|
||||
tile = tile.getInterimTile();
|
||||
}
|
||||
return tile;
|
||||
}
|
||||
|
||||
/**
|
||||
* @protected
|
||||
* @type {number}
|
||||
* @inheritDoc
|
||||
*/
|
||||
this.renderedRevision;
|
||||
prepareFrame(frameState, layerState) {
|
||||
|
||||
const pixelRatio = frameState.pixelRatio;
|
||||
const size = frameState.size;
|
||||
const viewState = frameState.viewState;
|
||||
const projection = viewState.projection;
|
||||
const viewResolution = viewState.resolution;
|
||||
const viewCenter = viewState.center;
|
||||
|
||||
const tileLayer = this.getLayer();
|
||||
const tileSource = /** @type {module:ol/source/Tile} */ (tileLayer.getSource());
|
||||
const sourceRevision = tileSource.getRevision();
|
||||
const tileGrid = tileSource.getTileGridForProjection(projection);
|
||||
const z = tileGrid.getZForResolution(viewResolution, this.zDirection);
|
||||
const tileResolution = tileGrid.getResolution(z);
|
||||
let oversampling = Math.round(viewResolution / tileResolution) || 1;
|
||||
let extent = frameState.extent;
|
||||
|
||||
if (layerState.extent !== undefined) {
|
||||
extent = getIntersection(extent, layerState.extent);
|
||||
}
|
||||
if (isEmpty(extent)) {
|
||||
// Return false to prevent the rendering of the layer.
|
||||
return false;
|
||||
}
|
||||
|
||||
const tileRange = tileGrid.getTileRangeForExtentAndZ(extent, z);
|
||||
const imageExtent = tileGrid.getTileRangeExtent(z, tileRange);
|
||||
|
||||
const tilePixelRatio = tileSource.getTilePixelRatio(pixelRatio);
|
||||
|
||||
/**
|
||||
* @type {Object.<number, Object.<string, module:ol/Tile>>}
|
||||
*/
|
||||
const tilesToDrawByZ = {};
|
||||
tilesToDrawByZ[z] = {};
|
||||
|
||||
const findLoadedTiles = this.createLoadedTileFinder(
|
||||
tileSource, projection, tilesToDrawByZ);
|
||||
|
||||
const hints = frameState.viewHints;
|
||||
const animatingOrInteracting = hints[ViewHint.ANIMATING] || hints[ViewHint.INTERACTING];
|
||||
|
||||
const tmpExtent = this.tmpExtent;
|
||||
const tmpTileRange = this.tmpTileRange_;
|
||||
this.newTiles_ = false;
|
||||
let tile, x, y;
|
||||
for (x = tileRange.minX; x <= tileRange.maxX; ++x) {
|
||||
for (y = tileRange.minY; y <= tileRange.maxY; ++y) {
|
||||
if (Date.now() - frameState.time > 16 && animatingOrInteracting) {
|
||||
continue;
|
||||
}
|
||||
tile = this.getTile(z, x, y, pixelRatio, projection);
|
||||
if (this.isDrawableTile_(tile)) {
|
||||
const uid = getUid(this);
|
||||
if (tile.getState() == TileState.LOADED) {
|
||||
tilesToDrawByZ[z][tile.tileCoord.toString()] = tile;
|
||||
const inTransition = tile.inTransition(uid);
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
const childTileRange = tileGrid.getTileCoordChildTileRange(
|
||||
tile.tileCoord, tmpTileRange, tmpExtent);
|
||||
let covered = false;
|
||||
if (childTileRange) {
|
||||
covered = findLoadedTiles(z + 1, childTileRange);
|
||||
}
|
||||
if (!covered) {
|
||||
tileGrid.forEachTileCoordParentTileRange(
|
||||
tile.tileCoord, findLoadedTiles, null, tmpTileRange, tmpExtent);
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
const renderedResolution = tileResolution * pixelRatio / tilePixelRatio * oversampling;
|
||||
if (!(this.renderedResolution && Date.now() - frameState.time > 16 && animatingOrInteracting) && (
|
||||
this.newTiles_ ||
|
||||
!(this.renderedExtent_ && containsExtent(this.renderedExtent_, extent)) ||
|
||||
this.renderedRevision != sourceRevision ||
|
||||
oversampling != this.oversampling_ ||
|
||||
!animatingOrInteracting && renderedResolution != this.renderedResolution
|
||||
)) {
|
||||
|
||||
const context = this.context;
|
||||
if (context) {
|
||||
const tilePixelSize = tileSource.getTilePixelSize(z, pixelRatio, projection);
|
||||
const width = Math.round(tileRange.getWidth() * tilePixelSize[0] / oversampling);
|
||||
const height = Math.round(tileRange.getHeight() * tilePixelSize[1] / oversampling);
|
||||
const canvas = context.canvas;
|
||||
if (canvas.width != width || canvas.height != height) {
|
||||
this.oversampling_ = oversampling;
|
||||
canvas.width = width;
|
||||
canvas.height = height;
|
||||
} else {
|
||||
if (this.renderedExtent_ && !equals(imageExtent, this.renderedExtent_)) {
|
||||
context.clearRect(0, 0, width, height);
|
||||
}
|
||||
oversampling = this.oversampling_;
|
||||
}
|
||||
}
|
||||
|
||||
this.renderedTiles.length = 0;
|
||||
/** @type {Array.<number>} */
|
||||
const zs = Object.keys(tilesToDrawByZ).map(Number);
|
||||
zs.sort(function(a, b) {
|
||||
if (a === z) {
|
||||
return 1;
|
||||
} else if (b === z) {
|
||||
return -1;
|
||||
} else {
|
||||
return a > b ? 1 : a < b ? -1 : 0;
|
||||
}
|
||||
});
|
||||
let currentResolution, currentScale, currentTilePixelSize, currentZ, i, ii;
|
||||
let tileExtent, tileGutter, tilesToDraw, w, h;
|
||||
for (i = 0, ii = zs.length; i < ii; ++i) {
|
||||
currentZ = zs[i];
|
||||
currentTilePixelSize = tileSource.getTilePixelSize(currentZ, pixelRatio, projection);
|
||||
currentResolution = tileGrid.getResolution(currentZ);
|
||||
currentScale = currentResolution / tileResolution;
|
||||
tileGutter = tilePixelRatio * tileSource.getGutter(projection);
|
||||
tilesToDraw = tilesToDrawByZ[currentZ];
|
||||
for (const tileCoordKey in tilesToDraw) {
|
||||
tile = tilesToDraw[tileCoordKey];
|
||||
tileExtent = tileGrid.getTileCoordExtent(tile.getTileCoord(), tmpExtent);
|
||||
x = (tileExtent[0] - imageExtent[0]) / tileResolution * tilePixelRatio / oversampling;
|
||||
y = (imageExtent[3] - tileExtent[3]) / tileResolution * tilePixelRatio / oversampling;
|
||||
w = currentTilePixelSize[0] * currentScale / oversampling;
|
||||
h = currentTilePixelSize[1] * currentScale / oversampling;
|
||||
this.drawTileImage(tile, frameState, layerState, x, y, w, h, tileGutter, z === currentZ);
|
||||
this.renderedTiles.push(tile);
|
||||
}
|
||||
}
|
||||
|
||||
this.renderedRevision = sourceRevision;
|
||||
this.renderedResolution = tileResolution * pixelRatio / tilePixelRatio * oversampling;
|
||||
this.renderedExtent_ = imageExtent;
|
||||
}
|
||||
|
||||
const scale = this.renderedResolution / viewResolution;
|
||||
const transform = composeTransform(this.imageTransform_,
|
||||
pixelRatio * size[0] / 2, pixelRatio * size[1] / 2,
|
||||
scale, scale,
|
||||
0,
|
||||
(this.renderedExtent_[0] - viewCenter[0]) / this.renderedResolution * pixelRatio,
|
||||
(viewCenter[1] - this.renderedExtent_[3]) / this.renderedResolution * pixelRatio);
|
||||
composeTransform(this.coordinateToCanvasPixelTransform,
|
||||
pixelRatio * size[0] / 2 - transform[4], pixelRatio * size[1] / 2 - transform[5],
|
||||
pixelRatio / viewResolution, -pixelRatio / viewResolution,
|
||||
0,
|
||||
-viewCenter[0], -viewCenter[1]);
|
||||
|
||||
|
||||
this.updateUsedTiles(frameState.usedTiles, tileSource, z, tileRange);
|
||||
this.manageTilePyramid(frameState, tileSource, tileGrid, pixelRatio,
|
||||
projection, extent, z, tileLayer.getPreload());
|
||||
this.scheduleExpireCache(frameState, tileSource);
|
||||
|
||||
return this.renderedTiles.length > 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* @protected
|
||||
* @type {!Array.<module:ol/Tile>}
|
||||
* @param {module:ol/Tile} tile Tile.
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @param {module:ol/layer/Layer~State} layerState Layer 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.
|
||||
*/
|
||||
this.renderedTiles = [];
|
||||
drawTileImage(tile, frameState, layerState, x, y, w, h, gutter, transition) {
|
||||
const image = tile.getImage(this.getLayer());
|
||||
if (!image) {
|
||||
return;
|
||||
}
|
||||
const uid = getUid(this);
|
||||
const alpha = transition ? tile.getAlpha(uid, frameState.time) : 1;
|
||||
if (alpha === 1 && !this.getLayer().getSource().getOpaque(frameState.viewState.projection)) {
|
||||
this.context.clearRect(x, y, w, h);
|
||||
}
|
||||
const 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 !== 1) {
|
||||
frameState.animate = true;
|
||||
} else if (transition) {
|
||||
tile.endTransition(uid);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {boolean}
|
||||
* @inheritDoc
|
||||
*/
|
||||
this.newTiles_ = false;
|
||||
getImage() {
|
||||
const context = this.context;
|
||||
return context ? context.canvas : null;
|
||||
}
|
||||
|
||||
/**
|
||||
* @protected
|
||||
* @type {module:ol/extent~Extent}
|
||||
* @inheritDoc
|
||||
*/
|
||||
this.tmpExtent = createEmpty();
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/TileRange}
|
||||
*/
|
||||
this.tmpTileRange_ = new TileRange(0, 0, 0, 0);
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/transform~Transform}
|
||||
*/
|
||||
this.imageTransform_ = createTransform();
|
||||
|
||||
/**
|
||||
* @protected
|
||||
* @type {number}
|
||||
*/
|
||||
this.zDirection = 0;
|
||||
|
||||
};
|
||||
getImageTransform() {
|
||||
return this.imageTransform_;
|
||||
}
|
||||
}
|
||||
|
||||
inherits(CanvasTileLayerRenderer, IntermediateCanvasRenderer);
|
||||
|
||||
@@ -107,269 +375,6 @@ CanvasTileLayerRenderer['create'] = function(mapRenderer, layer) {
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @param {module:ol/Tile} tile Tile.
|
||||
* @return {boolean} Tile is drawable.
|
||||
*/
|
||||
CanvasTileLayerRenderer.prototype.isDrawableTile_ = function(tile) {
|
||||
const tileState = tile.getState();
|
||||
const useInterimTilesOnError = this.getLayer().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 {number} pixelRatio Pixel ratio.
|
||||
* @param {module:ol/proj/Projection} projection Projection.
|
||||
* @return {!module:ol/Tile} Tile.
|
||||
*/
|
||||
CanvasTileLayerRenderer.prototype.getTile = function(z, x, y, pixelRatio, projection) {
|
||||
const layer = this.getLayer();
|
||||
const source = /** @type {module:ol/source/Tile} */ (layer.getSource());
|
||||
let tile = source.getTile(z, x, y, pixelRatio, projection);
|
||||
if (tile.getState() == TileState.ERROR) {
|
||||
if (!layer.getUseInterimTilesOnError()) {
|
||||
// When useInterimTilesOnError is false, we consider the error tile as loaded.
|
||||
tile.setState(TileState.LOADED);
|
||||
} else if (layer.getPreload() > 0) {
|
||||
// Preloaded tiles for lower resolutions might have finished loading.
|
||||
this.newTiles_ = true;
|
||||
}
|
||||
}
|
||||
if (!this.isDrawableTile_(tile)) {
|
||||
tile = tile.getInterimTile();
|
||||
}
|
||||
return tile;
|
||||
};
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
CanvasTileLayerRenderer.prototype.prepareFrame = function(frameState, layerState) {
|
||||
|
||||
const pixelRatio = frameState.pixelRatio;
|
||||
const size = frameState.size;
|
||||
const viewState = frameState.viewState;
|
||||
const projection = viewState.projection;
|
||||
const viewResolution = viewState.resolution;
|
||||
const viewCenter = viewState.center;
|
||||
|
||||
const tileLayer = this.getLayer();
|
||||
const tileSource = /** @type {module:ol/source/Tile} */ (tileLayer.getSource());
|
||||
const sourceRevision = tileSource.getRevision();
|
||||
const tileGrid = tileSource.getTileGridForProjection(projection);
|
||||
const z = tileGrid.getZForResolution(viewResolution, this.zDirection);
|
||||
const tileResolution = tileGrid.getResolution(z);
|
||||
let oversampling = Math.round(viewResolution / tileResolution) || 1;
|
||||
let extent = frameState.extent;
|
||||
|
||||
if (layerState.extent !== undefined) {
|
||||
extent = getIntersection(extent, layerState.extent);
|
||||
}
|
||||
if (isEmpty(extent)) {
|
||||
// Return false to prevent the rendering of the layer.
|
||||
return false;
|
||||
}
|
||||
|
||||
const tileRange = tileGrid.getTileRangeForExtentAndZ(extent, z);
|
||||
const imageExtent = tileGrid.getTileRangeExtent(z, tileRange);
|
||||
|
||||
const tilePixelRatio = tileSource.getTilePixelRatio(pixelRatio);
|
||||
|
||||
/**
|
||||
* @type {Object.<number, Object.<string, module:ol/Tile>>}
|
||||
*/
|
||||
const tilesToDrawByZ = {};
|
||||
tilesToDrawByZ[z] = {};
|
||||
|
||||
const findLoadedTiles = this.createLoadedTileFinder(
|
||||
tileSource, projection, tilesToDrawByZ);
|
||||
|
||||
const hints = frameState.viewHints;
|
||||
const animatingOrInteracting = hints[ViewHint.ANIMATING] || hints[ViewHint.INTERACTING];
|
||||
|
||||
const tmpExtent = this.tmpExtent;
|
||||
const tmpTileRange = this.tmpTileRange_;
|
||||
this.newTiles_ = false;
|
||||
let tile, x, y;
|
||||
for (x = tileRange.minX; x <= tileRange.maxX; ++x) {
|
||||
for (y = tileRange.minY; y <= tileRange.maxY; ++y) {
|
||||
if (Date.now() - frameState.time > 16 && animatingOrInteracting) {
|
||||
continue;
|
||||
}
|
||||
tile = this.getTile(z, x, y, pixelRatio, projection);
|
||||
if (this.isDrawableTile_(tile)) {
|
||||
const uid = getUid(this);
|
||||
if (tile.getState() == TileState.LOADED) {
|
||||
tilesToDrawByZ[z][tile.tileCoord.toString()] = tile;
|
||||
const inTransition = tile.inTransition(uid);
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
const childTileRange = tileGrid.getTileCoordChildTileRange(
|
||||
tile.tileCoord, tmpTileRange, tmpExtent);
|
||||
let covered = false;
|
||||
if (childTileRange) {
|
||||
covered = findLoadedTiles(z + 1, childTileRange);
|
||||
}
|
||||
if (!covered) {
|
||||
tileGrid.forEachTileCoordParentTileRange(
|
||||
tile.tileCoord, findLoadedTiles, null, tmpTileRange, tmpExtent);
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
const renderedResolution = tileResolution * pixelRatio / tilePixelRatio * oversampling;
|
||||
if (!(this.renderedResolution && Date.now() - frameState.time > 16 && animatingOrInteracting) && (
|
||||
this.newTiles_ ||
|
||||
!(this.renderedExtent_ && containsExtent(this.renderedExtent_, extent)) ||
|
||||
this.renderedRevision != sourceRevision ||
|
||||
oversampling != this.oversampling_ ||
|
||||
!animatingOrInteracting && renderedResolution != this.renderedResolution
|
||||
)) {
|
||||
|
||||
const context = this.context;
|
||||
if (context) {
|
||||
const tilePixelSize = tileSource.getTilePixelSize(z, pixelRatio, projection);
|
||||
const width = Math.round(tileRange.getWidth() * tilePixelSize[0] / oversampling);
|
||||
const height = Math.round(tileRange.getHeight() * tilePixelSize[1] / oversampling);
|
||||
const canvas = context.canvas;
|
||||
if (canvas.width != width || canvas.height != height) {
|
||||
this.oversampling_ = oversampling;
|
||||
canvas.width = width;
|
||||
canvas.height = height;
|
||||
} else {
|
||||
if (this.renderedExtent_ && !equals(imageExtent, this.renderedExtent_)) {
|
||||
context.clearRect(0, 0, width, height);
|
||||
}
|
||||
oversampling = this.oversampling_;
|
||||
}
|
||||
}
|
||||
|
||||
this.renderedTiles.length = 0;
|
||||
/** @type {Array.<number>} */
|
||||
const zs = Object.keys(tilesToDrawByZ).map(Number);
|
||||
zs.sort(function(a, b) {
|
||||
if (a === z) {
|
||||
return 1;
|
||||
} else if (b === z) {
|
||||
return -1;
|
||||
} else {
|
||||
return a > b ? 1 : a < b ? -1 : 0;
|
||||
}
|
||||
});
|
||||
let currentResolution, currentScale, currentTilePixelSize, currentZ, i, ii;
|
||||
let tileExtent, tileGutter, tilesToDraw, w, h;
|
||||
for (i = 0, ii = zs.length; i < ii; ++i) {
|
||||
currentZ = zs[i];
|
||||
currentTilePixelSize = tileSource.getTilePixelSize(currentZ, pixelRatio, projection);
|
||||
currentResolution = tileGrid.getResolution(currentZ);
|
||||
currentScale = currentResolution / tileResolution;
|
||||
tileGutter = tilePixelRatio * tileSource.getGutter(projection);
|
||||
tilesToDraw = tilesToDrawByZ[currentZ];
|
||||
for (const tileCoordKey in tilesToDraw) {
|
||||
tile = tilesToDraw[tileCoordKey];
|
||||
tileExtent = tileGrid.getTileCoordExtent(tile.getTileCoord(), tmpExtent);
|
||||
x = (tileExtent[0] - imageExtent[0]) / tileResolution * tilePixelRatio / oversampling;
|
||||
y = (imageExtent[3] - tileExtent[3]) / tileResolution * tilePixelRatio / oversampling;
|
||||
w = currentTilePixelSize[0] * currentScale / oversampling;
|
||||
h = currentTilePixelSize[1] * currentScale / oversampling;
|
||||
this.drawTileImage(tile, frameState, layerState, x, y, w, h, tileGutter, z === currentZ);
|
||||
this.renderedTiles.push(tile);
|
||||
}
|
||||
}
|
||||
|
||||
this.renderedRevision = sourceRevision;
|
||||
this.renderedResolution = tileResolution * pixelRatio / tilePixelRatio * oversampling;
|
||||
this.renderedExtent_ = imageExtent;
|
||||
}
|
||||
|
||||
const scale = this.renderedResolution / viewResolution;
|
||||
const transform = composeTransform(this.imageTransform_,
|
||||
pixelRatio * size[0] / 2, pixelRatio * size[1] / 2,
|
||||
scale, scale,
|
||||
0,
|
||||
(this.renderedExtent_[0] - viewCenter[0]) / this.renderedResolution * pixelRatio,
|
||||
(viewCenter[1] - this.renderedExtent_[3]) / this.renderedResolution * pixelRatio);
|
||||
composeTransform(this.coordinateToCanvasPixelTransform,
|
||||
pixelRatio * size[0] / 2 - transform[4], pixelRatio * size[1] / 2 - transform[5],
|
||||
pixelRatio / viewResolution, -pixelRatio / viewResolution,
|
||||
0,
|
||||
-viewCenter[0], -viewCenter[1]);
|
||||
|
||||
|
||||
this.updateUsedTiles(frameState.usedTiles, tileSource, z, tileRange);
|
||||
this.manageTilePyramid(frameState, tileSource, tileGrid, pixelRatio,
|
||||
projection, extent, z, tileLayer.getPreload());
|
||||
this.scheduleExpireCache(frameState, tileSource);
|
||||
|
||||
return this.renderedTiles.length > 0;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {module:ol/Tile} tile Tile.
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @param {module:ol/layer/Layer~State} layerState Layer 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, layerState, x, y, w, h, gutter, transition) {
|
||||
const image = tile.getImage(this.getLayer());
|
||||
if (!image) {
|
||||
return;
|
||||
}
|
||||
const uid = getUid(this);
|
||||
const alpha = transition ? tile.getAlpha(uid, frameState.time) : 1;
|
||||
if (alpha === 1 && !this.getLayer().getSource().getOpaque(frameState.viewState.projection)) {
|
||||
this.context.clearRect(x, y, w, h);
|
||||
}
|
||||
const 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 !== 1) {
|
||||
frameState.animate = true;
|
||||
} else if (transition) {
|
||||
tile.endTransition(uid);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
CanvasTileLayerRenderer.prototype.getImage = function() {
|
||||
const context = this.context;
|
||||
return context ? context.canvas : null;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @function
|
||||
* @return {module:ol/layer/Tile|module:ol/layer/VectorTile}
|
||||
@@ -377,10 +382,4 @@ CanvasTileLayerRenderer.prototype.getImage = function() {
|
||||
CanvasTileLayerRenderer.prototype.getLayer;
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
CanvasTileLayerRenderer.prototype.getImageTransform = function() {
|
||||
return this.imageTransform_;
|
||||
};
|
||||
export default CanvasTileLayerRenderer;
|
||||
|
||||
@@ -21,66 +21,391 @@ import {defaultOrder as defaultRenderOrder, getTolerance as getRenderTolerance,
|
||||
* @param {module:ol/layer/Vector} vectorLayer Vector layer.
|
||||
* @api
|
||||
*/
|
||||
const CanvasVectorLayerRenderer = function(vectorLayer) {
|
||||
class CanvasVectorLayerRenderer {
|
||||
constructor(vectorLayer) {
|
||||
|
||||
CanvasLayerRenderer.call(this, vectorLayer);
|
||||
CanvasLayerRenderer.call(this, vectorLayer);
|
||||
|
||||
/**
|
||||
* Declutter tree.
|
||||
* @private
|
||||
*/
|
||||
this.declutterTree_ = vectorLayer.getDeclutter() ? rbush(9, undefined) : null;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {boolean}
|
||||
*/
|
||||
this.dirty_ = false;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {number}
|
||||
*/
|
||||
this.renderedRevision_ = -1;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {number}
|
||||
*/
|
||||
this.renderedResolution_ = NaN;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/extent~Extent}
|
||||
*/
|
||||
this.renderedExtent_ = createEmpty();
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {function(module:ol/Feature, module:ol/Feature): number|null}
|
||||
*/
|
||||
this.renderedRenderOrder_ = null;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/render/canvas/ReplayGroup}
|
||||
*/
|
||||
this.replayGroup_ = null;
|
||||
|
||||
/**
|
||||
* A new replay group had to be created by `prepareFrame()`
|
||||
* @type {boolean}
|
||||
*/
|
||||
this.replayGroupChanged = true;
|
||||
|
||||
/**
|
||||
* @type {CanvasRenderingContext2D}
|
||||
*/
|
||||
this.context = createCanvasContext2D();
|
||||
|
||||
listen(labelCache, EventType.CLEAR, this.handleFontsChanged_, this);
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Declutter tree.
|
||||
* @inheritDoc
|
||||
*/
|
||||
disposeInternal() {
|
||||
unlisten(labelCache, EventType.CLEAR, this.handleFontsChanged_, this);
|
||||
CanvasLayerRenderer.prototype.disposeInternal.call(this);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {CanvasRenderingContext2D} context Context.
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @param {module:ol/layer/Layer~State} layerState Layer state.
|
||||
*/
|
||||
compose(context, frameState, layerState) {
|
||||
const extent = frameState.extent;
|
||||
const pixelRatio = frameState.pixelRatio;
|
||||
const skippedFeatureUids = layerState.managed ?
|
||||
frameState.skippedFeatureUids : {};
|
||||
const viewState = frameState.viewState;
|
||||
const projection = viewState.projection;
|
||||
const rotation = viewState.rotation;
|
||||
const projectionExtent = projection.getExtent();
|
||||
const vectorSource = /** @type {module:ol/source/Vector} */ (this.getLayer().getSource());
|
||||
|
||||
let transform = this.getTransform(frameState, 0);
|
||||
|
||||
// clipped rendering if layer extent is set
|
||||
const clipExtent = layerState.extent;
|
||||
const clipped = clipExtent !== undefined;
|
||||
if (clipped) {
|
||||
this.clip(context, frameState, /** @type {module:ol/extent~Extent} */ (clipExtent));
|
||||
}
|
||||
const replayGroup = this.replayGroup_;
|
||||
if (replayGroup && !replayGroup.isEmpty()) {
|
||||
if (this.declutterTree_) {
|
||||
this.declutterTree_.clear();
|
||||
}
|
||||
const layer = /** @type {module:ol/layer/Vector} */ (this.getLayer());
|
||||
let drawOffsetX = 0;
|
||||
let drawOffsetY = 0;
|
||||
let replayContext;
|
||||
const transparentLayer = layerState.opacity !== 1;
|
||||
const hasRenderListeners = layer.hasListener(RenderEventType.RENDER);
|
||||
if (transparentLayer || hasRenderListeners) {
|
||||
let drawWidth = context.canvas.width;
|
||||
let drawHeight = context.canvas.height;
|
||||
if (rotation) {
|
||||
const drawSize = Math.round(Math.sqrt(drawWidth * drawWidth + drawHeight * drawHeight));
|
||||
drawOffsetX = (drawSize - drawWidth) / 2;
|
||||
drawOffsetY = (drawSize - drawHeight) / 2;
|
||||
drawWidth = drawHeight = drawSize;
|
||||
}
|
||||
// resize and clear
|
||||
this.context.canvas.width = drawWidth;
|
||||
this.context.canvas.height = drawHeight;
|
||||
replayContext = this.context;
|
||||
} else {
|
||||
replayContext = context;
|
||||
}
|
||||
|
||||
const alpha = replayContext.globalAlpha;
|
||||
if (!transparentLayer) {
|
||||
// for performance reasons, context.save / context.restore is not used
|
||||
// to save and restore the transformation matrix and the opacity.
|
||||
// see http://jsperf.com/context-save-restore-versus-variable
|
||||
replayContext.globalAlpha = layerState.opacity;
|
||||
}
|
||||
|
||||
if (replayContext != context) {
|
||||
replayContext.translate(drawOffsetX, drawOffsetY);
|
||||
}
|
||||
|
||||
const width = frameState.size[0] * pixelRatio;
|
||||
const height = frameState.size[1] * pixelRatio;
|
||||
rotateAtOffset(replayContext, -rotation,
|
||||
width / 2, height / 2);
|
||||
replayGroup.replay(replayContext, transform, rotation, skippedFeatureUids);
|
||||
if (vectorSource.getWrapX() && projection.canWrapX() &&
|
||||
!containsExtent(projectionExtent, extent)) {
|
||||
let startX = extent[0];
|
||||
const worldWidth = getWidth(projectionExtent);
|
||||
let world = 0;
|
||||
let offsetX;
|
||||
while (startX < projectionExtent[0]) {
|
||||
--world;
|
||||
offsetX = worldWidth * world;
|
||||
transform = this.getTransform(frameState, offsetX);
|
||||
replayGroup.replay(replayContext, transform, rotation, skippedFeatureUids);
|
||||
startX += worldWidth;
|
||||
}
|
||||
world = 0;
|
||||
startX = extent[2];
|
||||
while (startX > projectionExtent[2]) {
|
||||
++world;
|
||||
offsetX = worldWidth * world;
|
||||
transform = this.getTransform(frameState, offsetX);
|
||||
replayGroup.replay(replayContext, transform, rotation, skippedFeatureUids);
|
||||
startX -= worldWidth;
|
||||
}
|
||||
}
|
||||
rotateAtOffset(replayContext, rotation,
|
||||
width / 2, height / 2);
|
||||
|
||||
if (hasRenderListeners) {
|
||||
this.dispatchRenderEvent(replayContext, frameState, transform);
|
||||
}
|
||||
if (replayContext != context) {
|
||||
if (transparentLayer) {
|
||||
const mainContextAlpha = context.globalAlpha;
|
||||
context.globalAlpha = layerState.opacity;
|
||||
context.drawImage(replayContext.canvas, -drawOffsetX, -drawOffsetY);
|
||||
context.globalAlpha = mainContextAlpha;
|
||||
} else {
|
||||
context.drawImage(replayContext.canvas, -drawOffsetX, -drawOffsetY);
|
||||
}
|
||||
replayContext.translate(-drawOffsetX, -drawOffsetY);
|
||||
}
|
||||
|
||||
if (!transparentLayer) {
|
||||
replayContext.globalAlpha = alpha;
|
||||
}
|
||||
}
|
||||
|
||||
if (clipped) {
|
||||
context.restore();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
composeFrame(frameState, layerState, context) {
|
||||
const transform = this.getTransform(frameState, 0);
|
||||
this.preCompose(context, frameState, transform);
|
||||
this.compose(context, frameState, layerState);
|
||||
this.postCompose(context, frameState, layerState, transform);
|
||||
}
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
forEachFeatureAtCoordinate(coordinate, frameState, hitTolerance, callback, thisArg) {
|
||||
if (!this.replayGroup_) {
|
||||
return undefined;
|
||||
} else {
|
||||
const resolution = frameState.viewState.resolution;
|
||||
const rotation = frameState.viewState.rotation;
|
||||
const layer = /** @type {module:ol/layer/Vector} */ (this.getLayer());
|
||||
/** @type {!Object.<string, boolean>} */
|
||||
const features = {};
|
||||
const result = this.replayGroup_.forEachFeatureAtCoordinate(coordinate, resolution, rotation, hitTolerance, {},
|
||||
/**
|
||||
* @param {module:ol/Feature|module:ol/render/Feature} feature Feature.
|
||||
* @return {?} Callback result.
|
||||
*/
|
||||
function(feature) {
|
||||
const key = getUid(feature).toString();
|
||||
if (!(key in features)) {
|
||||
features[key] = true;
|
||||
return callback.call(thisArg, feature, layer);
|
||||
}
|
||||
}, null);
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {module:ol/events/Event} event Event.
|
||||
*/
|
||||
handleFontsChanged_(event) {
|
||||
const layer = this.getLayer();
|
||||
if (layer.getVisible() && this.replayGroup_) {
|
||||
layer.changed();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Handle changes in image style state.
|
||||
* @param {module:ol/events/Event} event Image style change event.
|
||||
* @private
|
||||
*/
|
||||
this.declutterTree_ = vectorLayer.getDeclutter() ? rbush(9, undefined) : null;
|
||||
handleStyleImageChange_(event) {
|
||||
this.renderIfReadyAndVisible();
|
||||
}
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {boolean}
|
||||
* @inheritDoc
|
||||
*/
|
||||
this.dirty_ = false;
|
||||
prepareFrame(frameState, layerState) {
|
||||
const vectorLayer = /** @type {module:ol/layer/Vector} */ (this.getLayer());
|
||||
const vectorSource = vectorLayer.getSource();
|
||||
|
||||
const animating = frameState.viewHints[ViewHint.ANIMATING];
|
||||
const interacting = frameState.viewHints[ViewHint.INTERACTING];
|
||||
const updateWhileAnimating = vectorLayer.getUpdateWhileAnimating();
|
||||
const updateWhileInteracting = vectorLayer.getUpdateWhileInteracting();
|
||||
|
||||
if (!this.dirty_ && (!updateWhileAnimating && animating) ||
|
||||
(!updateWhileInteracting && interacting)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
const frameStateExtent = frameState.extent;
|
||||
const viewState = frameState.viewState;
|
||||
const projection = viewState.projection;
|
||||
const resolution = viewState.resolution;
|
||||
const pixelRatio = frameState.pixelRatio;
|
||||
const vectorLayerRevision = vectorLayer.getRevision();
|
||||
const vectorLayerRenderBuffer = vectorLayer.getRenderBuffer();
|
||||
let vectorLayerRenderOrder = vectorLayer.getRenderOrder();
|
||||
|
||||
if (vectorLayerRenderOrder === undefined) {
|
||||
vectorLayerRenderOrder = defaultRenderOrder;
|
||||
}
|
||||
|
||||
const extent = buffer(frameStateExtent,
|
||||
vectorLayerRenderBuffer * resolution);
|
||||
const projectionExtent = viewState.projection.getExtent();
|
||||
|
||||
if (vectorSource.getWrapX() && viewState.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.
|
||||
const worldWidth = getWidth(projectionExtent);
|
||||
const gutter = Math.max(getWidth(extent) / 2, worldWidth);
|
||||
extent[0] = projectionExtent[0] - gutter;
|
||||
extent[2] = projectionExtent[2] + gutter;
|
||||
}
|
||||
|
||||
if (!this.dirty_ &&
|
||||
this.renderedResolution_ == resolution &&
|
||||
this.renderedRevision_ == vectorLayerRevision &&
|
||||
this.renderedRenderOrder_ == vectorLayerRenderOrder &&
|
||||
containsExtent(this.renderedExtent_, extent)) {
|
||||
this.replayGroupChanged = false;
|
||||
return true;
|
||||
}
|
||||
|
||||
this.replayGroup_ = null;
|
||||
|
||||
this.dirty_ = false;
|
||||
|
||||
const replayGroup = new CanvasReplayGroup(
|
||||
getRenderTolerance(resolution, pixelRatio), extent, resolution,
|
||||
pixelRatio, vectorSource.getOverlaps(), this.declutterTree_, vectorLayer.getRenderBuffer());
|
||||
vectorSource.loadFeatures(extent, resolution, projection);
|
||||
/**
|
||||
* @param {module:ol/Feature} feature Feature.
|
||||
* @this {module:ol/renderer/canvas/VectorLayer}
|
||||
*/
|
||||
const render = function(feature) {
|
||||
let styles;
|
||||
const styleFunction = feature.getStyleFunction() || vectorLayer.getStyleFunction();
|
||||
if (styleFunction) {
|
||||
styles = styleFunction(feature, resolution);
|
||||
}
|
||||
if (styles) {
|
||||
const dirty = this.renderFeature(
|
||||
feature, resolution, pixelRatio, styles, replayGroup);
|
||||
this.dirty_ = this.dirty_ || dirty;
|
||||
}
|
||||
}.bind(this);
|
||||
if (vectorLayerRenderOrder) {
|
||||
/** @type {Array.<module:ol/Feature>} */
|
||||
const features = [];
|
||||
vectorSource.forEachFeatureInExtent(extent,
|
||||
/**
|
||||
* @param {module:ol/Feature} feature Feature.
|
||||
*/
|
||||
function(feature) {
|
||||
features.push(feature);
|
||||
}, this);
|
||||
features.sort(vectorLayerRenderOrder);
|
||||
for (let i = 0, ii = features.length; i < ii; ++i) {
|
||||
render(features[i]);
|
||||
}
|
||||
} else {
|
||||
vectorSource.forEachFeatureInExtent(extent, render, this);
|
||||
}
|
||||
replayGroup.finish();
|
||||
|
||||
this.renderedResolution_ = resolution;
|
||||
this.renderedRevision_ = vectorLayerRevision;
|
||||
this.renderedRenderOrder_ = vectorLayerRenderOrder;
|
||||
this.renderedExtent_ = extent;
|
||||
this.replayGroup_ = replayGroup;
|
||||
|
||||
this.replayGroupChanged = true;
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {number}
|
||||
* @param {module:ol/Feature} feature Feature.
|
||||
* @param {number} resolution Resolution.
|
||||
* @param {number} pixelRatio Pixel ratio.
|
||||
* @param {(module:ol/style/Style|Array.<module:ol/style/Style>)} styles The style or array of styles.
|
||||
* @param {module:ol/render/canvas/ReplayGroup} replayGroup Replay group.
|
||||
* @return {boolean} `true` if an image is loading.
|
||||
*/
|
||||
this.renderedRevision_ = -1;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {number}
|
||||
*/
|
||||
this.renderedResolution_ = NaN;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/extent~Extent}
|
||||
*/
|
||||
this.renderedExtent_ = createEmpty();
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {function(module:ol/Feature, module:ol/Feature): number|null}
|
||||
*/
|
||||
this.renderedRenderOrder_ = null;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/render/canvas/ReplayGroup}
|
||||
*/
|
||||
this.replayGroup_ = null;
|
||||
|
||||
/**
|
||||
* A new replay group had to be created by `prepareFrame()`
|
||||
* @type {boolean}
|
||||
*/
|
||||
this.replayGroupChanged = true;
|
||||
|
||||
/**
|
||||
* @type {CanvasRenderingContext2D}
|
||||
*/
|
||||
this.context = createCanvasContext2D();
|
||||
|
||||
listen(labelCache, EventType.CLEAR, this.handleFontsChanged_, this);
|
||||
|
||||
};
|
||||
renderFeature(feature, resolution, pixelRatio, styles, replayGroup) {
|
||||
if (!styles) {
|
||||
return false;
|
||||
}
|
||||
let loading = false;
|
||||
if (Array.isArray(styles)) {
|
||||
for (let i = 0, ii = styles.length; i < ii; ++i) {
|
||||
loading = renderFeature(
|
||||
replayGroup, feature, styles[i],
|
||||
getSquaredRenderTolerance(resolution, pixelRatio),
|
||||
this.handleStyleImageChange_, this) || loading;
|
||||
}
|
||||
} else {
|
||||
loading = renderFeature(
|
||||
replayGroup, feature, styles,
|
||||
getSquaredRenderTolerance(resolution, pixelRatio),
|
||||
this.handleStyleImageChange_, this);
|
||||
}
|
||||
return loading;
|
||||
}
|
||||
}
|
||||
|
||||
inherits(CanvasVectorLayerRenderer, CanvasLayerRenderer);
|
||||
|
||||
@@ -106,333 +431,4 @@ CanvasVectorLayerRenderer['create'] = function(mapRenderer, layer) {
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
CanvasVectorLayerRenderer.prototype.disposeInternal = function() {
|
||||
unlisten(labelCache, EventType.CLEAR, this.handleFontsChanged_, this);
|
||||
CanvasLayerRenderer.prototype.disposeInternal.call(this);
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {CanvasRenderingContext2D} context Context.
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @param {module:ol/layer/Layer~State} layerState Layer state.
|
||||
*/
|
||||
CanvasVectorLayerRenderer.prototype.compose = function(context, frameState, layerState) {
|
||||
const extent = frameState.extent;
|
||||
const pixelRatio = frameState.pixelRatio;
|
||||
const skippedFeatureUids = layerState.managed ?
|
||||
frameState.skippedFeatureUids : {};
|
||||
const viewState = frameState.viewState;
|
||||
const projection = viewState.projection;
|
||||
const rotation = viewState.rotation;
|
||||
const projectionExtent = projection.getExtent();
|
||||
const vectorSource = /** @type {module:ol/source/Vector} */ (this.getLayer().getSource());
|
||||
|
||||
let transform = this.getTransform(frameState, 0);
|
||||
|
||||
// clipped rendering if layer extent is set
|
||||
const clipExtent = layerState.extent;
|
||||
const clipped = clipExtent !== undefined;
|
||||
if (clipped) {
|
||||
this.clip(context, frameState, /** @type {module:ol/extent~Extent} */ (clipExtent));
|
||||
}
|
||||
const replayGroup = this.replayGroup_;
|
||||
if (replayGroup && !replayGroup.isEmpty()) {
|
||||
if (this.declutterTree_) {
|
||||
this.declutterTree_.clear();
|
||||
}
|
||||
const layer = /** @type {module:ol/layer/Vector} */ (this.getLayer());
|
||||
let drawOffsetX = 0;
|
||||
let drawOffsetY = 0;
|
||||
let replayContext;
|
||||
const transparentLayer = layerState.opacity !== 1;
|
||||
const hasRenderListeners = layer.hasListener(RenderEventType.RENDER);
|
||||
if (transparentLayer || hasRenderListeners) {
|
||||
let drawWidth = context.canvas.width;
|
||||
let drawHeight = context.canvas.height;
|
||||
if (rotation) {
|
||||
const drawSize = Math.round(Math.sqrt(drawWidth * drawWidth + drawHeight * drawHeight));
|
||||
drawOffsetX = (drawSize - drawWidth) / 2;
|
||||
drawOffsetY = (drawSize - drawHeight) / 2;
|
||||
drawWidth = drawHeight = drawSize;
|
||||
}
|
||||
// resize and clear
|
||||
this.context.canvas.width = drawWidth;
|
||||
this.context.canvas.height = drawHeight;
|
||||
replayContext = this.context;
|
||||
} else {
|
||||
replayContext = context;
|
||||
}
|
||||
|
||||
const alpha = replayContext.globalAlpha;
|
||||
if (!transparentLayer) {
|
||||
// for performance reasons, context.save / context.restore is not used
|
||||
// to save and restore the transformation matrix and the opacity.
|
||||
// see http://jsperf.com/context-save-restore-versus-variable
|
||||
replayContext.globalAlpha = layerState.opacity;
|
||||
}
|
||||
|
||||
if (replayContext != context) {
|
||||
replayContext.translate(drawOffsetX, drawOffsetY);
|
||||
}
|
||||
|
||||
const width = frameState.size[0] * pixelRatio;
|
||||
const height = frameState.size[1] * pixelRatio;
|
||||
rotateAtOffset(replayContext, -rotation,
|
||||
width / 2, height / 2);
|
||||
replayGroup.replay(replayContext, transform, rotation, skippedFeatureUids);
|
||||
if (vectorSource.getWrapX() && projection.canWrapX() &&
|
||||
!containsExtent(projectionExtent, extent)) {
|
||||
let startX = extent[0];
|
||||
const worldWidth = getWidth(projectionExtent);
|
||||
let world = 0;
|
||||
let offsetX;
|
||||
while (startX < projectionExtent[0]) {
|
||||
--world;
|
||||
offsetX = worldWidth * world;
|
||||
transform = this.getTransform(frameState, offsetX);
|
||||
replayGroup.replay(replayContext, transform, rotation, skippedFeatureUids);
|
||||
startX += worldWidth;
|
||||
}
|
||||
world = 0;
|
||||
startX = extent[2];
|
||||
while (startX > projectionExtent[2]) {
|
||||
++world;
|
||||
offsetX = worldWidth * world;
|
||||
transform = this.getTransform(frameState, offsetX);
|
||||
replayGroup.replay(replayContext, transform, rotation, skippedFeatureUids);
|
||||
startX -= worldWidth;
|
||||
}
|
||||
}
|
||||
rotateAtOffset(replayContext, rotation,
|
||||
width / 2, height / 2);
|
||||
|
||||
if (hasRenderListeners) {
|
||||
this.dispatchRenderEvent(replayContext, frameState, transform);
|
||||
}
|
||||
if (replayContext != context) {
|
||||
if (transparentLayer) {
|
||||
const mainContextAlpha = context.globalAlpha;
|
||||
context.globalAlpha = layerState.opacity;
|
||||
context.drawImage(replayContext.canvas, -drawOffsetX, -drawOffsetY);
|
||||
context.globalAlpha = mainContextAlpha;
|
||||
} else {
|
||||
context.drawImage(replayContext.canvas, -drawOffsetX, -drawOffsetY);
|
||||
}
|
||||
replayContext.translate(-drawOffsetX, -drawOffsetY);
|
||||
}
|
||||
|
||||
if (!transparentLayer) {
|
||||
replayContext.globalAlpha = alpha;
|
||||
}
|
||||
}
|
||||
|
||||
if (clipped) {
|
||||
context.restore();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
CanvasVectorLayerRenderer.prototype.composeFrame = function(frameState, layerState, context) {
|
||||
const transform = this.getTransform(frameState, 0);
|
||||
this.preCompose(context, frameState, transform);
|
||||
this.compose(context, frameState, layerState);
|
||||
this.postCompose(context, frameState, layerState, transform);
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
CanvasVectorLayerRenderer.prototype.forEachFeatureAtCoordinate = function(coordinate, frameState, hitTolerance, callback, thisArg) {
|
||||
if (!this.replayGroup_) {
|
||||
return undefined;
|
||||
} else {
|
||||
const resolution = frameState.viewState.resolution;
|
||||
const rotation = frameState.viewState.rotation;
|
||||
const layer = /** @type {module:ol/layer/Vector} */ (this.getLayer());
|
||||
/** @type {!Object.<string, boolean>} */
|
||||
const features = {};
|
||||
const result = this.replayGroup_.forEachFeatureAtCoordinate(coordinate, resolution, rotation, hitTolerance, {},
|
||||
/**
|
||||
* @param {module:ol/Feature|module:ol/render/Feature} feature Feature.
|
||||
* @return {?} Callback result.
|
||||
*/
|
||||
function(feature) {
|
||||
const key = getUid(feature).toString();
|
||||
if (!(key in features)) {
|
||||
features[key] = true;
|
||||
return callback.call(thisArg, feature, layer);
|
||||
}
|
||||
}, null);
|
||||
return result;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {module:ol/events/Event} event Event.
|
||||
*/
|
||||
CanvasVectorLayerRenderer.prototype.handleFontsChanged_ = function(event) {
|
||||
const layer = this.getLayer();
|
||||
if (layer.getVisible() && this.replayGroup_) {
|
||||
layer.changed();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* Handle changes in image style state.
|
||||
* @param {module:ol/events/Event} event Image style change event.
|
||||
* @private
|
||||
*/
|
||||
CanvasVectorLayerRenderer.prototype.handleStyleImageChange_ = function(event) {
|
||||
this.renderIfReadyAndVisible();
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
CanvasVectorLayerRenderer.prototype.prepareFrame = function(frameState, layerState) {
|
||||
const vectorLayer = /** @type {module:ol/layer/Vector} */ (this.getLayer());
|
||||
const vectorSource = vectorLayer.getSource();
|
||||
|
||||
const animating = frameState.viewHints[ViewHint.ANIMATING];
|
||||
const interacting = frameState.viewHints[ViewHint.INTERACTING];
|
||||
const updateWhileAnimating = vectorLayer.getUpdateWhileAnimating();
|
||||
const updateWhileInteracting = vectorLayer.getUpdateWhileInteracting();
|
||||
|
||||
if (!this.dirty_ && (!updateWhileAnimating && animating) ||
|
||||
(!updateWhileInteracting && interacting)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
const frameStateExtent = frameState.extent;
|
||||
const viewState = frameState.viewState;
|
||||
const projection = viewState.projection;
|
||||
const resolution = viewState.resolution;
|
||||
const pixelRatio = frameState.pixelRatio;
|
||||
const vectorLayerRevision = vectorLayer.getRevision();
|
||||
const vectorLayerRenderBuffer = vectorLayer.getRenderBuffer();
|
||||
let vectorLayerRenderOrder = vectorLayer.getRenderOrder();
|
||||
|
||||
if (vectorLayerRenderOrder === undefined) {
|
||||
vectorLayerRenderOrder = defaultRenderOrder;
|
||||
}
|
||||
|
||||
const extent = buffer(frameStateExtent,
|
||||
vectorLayerRenderBuffer * resolution);
|
||||
const projectionExtent = viewState.projection.getExtent();
|
||||
|
||||
if (vectorSource.getWrapX() && viewState.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.
|
||||
const worldWidth = getWidth(projectionExtent);
|
||||
const gutter = Math.max(getWidth(extent) / 2, worldWidth);
|
||||
extent[0] = projectionExtent[0] - gutter;
|
||||
extent[2] = projectionExtent[2] + gutter;
|
||||
}
|
||||
|
||||
if (!this.dirty_ &&
|
||||
this.renderedResolution_ == resolution &&
|
||||
this.renderedRevision_ == vectorLayerRevision &&
|
||||
this.renderedRenderOrder_ == vectorLayerRenderOrder &&
|
||||
containsExtent(this.renderedExtent_, extent)) {
|
||||
this.replayGroupChanged = false;
|
||||
return true;
|
||||
}
|
||||
|
||||
this.replayGroup_ = null;
|
||||
|
||||
this.dirty_ = false;
|
||||
|
||||
const replayGroup = new CanvasReplayGroup(
|
||||
getRenderTolerance(resolution, pixelRatio), extent, resolution,
|
||||
pixelRatio, vectorSource.getOverlaps(), this.declutterTree_, vectorLayer.getRenderBuffer());
|
||||
vectorSource.loadFeatures(extent, resolution, projection);
|
||||
/**
|
||||
* @param {module:ol/Feature} feature Feature.
|
||||
* @this {module:ol/renderer/canvas/VectorLayer}
|
||||
*/
|
||||
const render = function(feature) {
|
||||
let styles;
|
||||
const styleFunction = feature.getStyleFunction() || vectorLayer.getStyleFunction();
|
||||
if (styleFunction) {
|
||||
styles = styleFunction(feature, resolution);
|
||||
}
|
||||
if (styles) {
|
||||
const dirty = this.renderFeature(
|
||||
feature, resolution, pixelRatio, styles, replayGroup);
|
||||
this.dirty_ = this.dirty_ || dirty;
|
||||
}
|
||||
}.bind(this);
|
||||
if (vectorLayerRenderOrder) {
|
||||
/** @type {Array.<module:ol/Feature>} */
|
||||
const features = [];
|
||||
vectorSource.forEachFeatureInExtent(extent,
|
||||
/**
|
||||
* @param {module:ol/Feature} feature Feature.
|
||||
*/
|
||||
function(feature) {
|
||||
features.push(feature);
|
||||
}, this);
|
||||
features.sort(vectorLayerRenderOrder);
|
||||
for (let i = 0, ii = features.length; i < ii; ++i) {
|
||||
render(features[i]);
|
||||
}
|
||||
} else {
|
||||
vectorSource.forEachFeatureInExtent(extent, render, this);
|
||||
}
|
||||
replayGroup.finish();
|
||||
|
||||
this.renderedResolution_ = resolution;
|
||||
this.renderedRevision_ = vectorLayerRevision;
|
||||
this.renderedRenderOrder_ = vectorLayerRenderOrder;
|
||||
this.renderedExtent_ = extent;
|
||||
this.replayGroup_ = replayGroup;
|
||||
|
||||
this.replayGroupChanged = true;
|
||||
return true;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {module:ol/Feature} feature Feature.
|
||||
* @param {number} resolution Resolution.
|
||||
* @param {number} pixelRatio Pixel ratio.
|
||||
* @param {(module:ol/style/Style|Array.<module:ol/style/Style>)} styles The style or array of styles.
|
||||
* @param {module:ol/render/canvas/ReplayGroup} replayGroup Replay group.
|
||||
* @return {boolean} `true` if an image is loading.
|
||||
*/
|
||||
CanvasVectorLayerRenderer.prototype.renderFeature = function(feature, resolution, pixelRatio, styles, replayGroup) {
|
||||
if (!styles) {
|
||||
return false;
|
||||
}
|
||||
let loading = false;
|
||||
if (Array.isArray(styles)) {
|
||||
for (let i = 0, ii = styles.length; i < ii; ++i) {
|
||||
loading = renderFeature(
|
||||
replayGroup, feature, styles[i],
|
||||
getSquaredRenderTolerance(resolution, pixelRatio),
|
||||
this.handleStyleImageChange_, this) || loading;
|
||||
}
|
||||
} else {
|
||||
loading = renderFeature(
|
||||
replayGroup, feature, styles,
|
||||
getSquaredRenderTolerance(resolution, pixelRatio),
|
||||
this.handleStyleImageChange_, this);
|
||||
}
|
||||
return loading;
|
||||
};
|
||||
export default CanvasVectorLayerRenderer;
|
||||
|
||||
@@ -53,45 +53,426 @@ const VECTOR_REPLAYS = {
|
||||
* @param {module:ol/layer/VectorTile} layer VectorTile layer.
|
||||
* @api
|
||||
*/
|
||||
const CanvasVectorTileLayerRenderer = function(layer) {
|
||||
class CanvasVectorTileLayerRenderer {
|
||||
constructor(layer) {
|
||||
|
||||
/**
|
||||
* @type {CanvasRenderingContext2D}
|
||||
*/
|
||||
this.context = null;
|
||||
|
||||
CanvasTileLayerRenderer.call(this, layer);
|
||||
|
||||
/**
|
||||
* Declutter tree.
|
||||
* @private
|
||||
*/
|
||||
this.declutterTree_ = layer.getDeclutter() ? rbush(9, undefined) : null;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {boolean}
|
||||
*/
|
||||
this.dirty_ = false;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {number}
|
||||
*/
|
||||
this.renderedLayerRevision_;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/transform~Transform}
|
||||
*/
|
||||
this.tmpTransform_ = createTransform();
|
||||
|
||||
// Use lower resolution for pure vector rendering. Closest resolution otherwise.
|
||||
this.zDirection = layer.getRenderMode() == VectorTileRenderType.VECTOR ? 1 : 0;
|
||||
|
||||
listen(labelCache, EventType.CLEAR, this.handleFontsChanged_, this);
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* @type {CanvasRenderingContext2D}
|
||||
* @inheritDoc
|
||||
*/
|
||||
this.context = null;
|
||||
|
||||
CanvasTileLayerRenderer.call(this, layer);
|
||||
disposeInternal() {
|
||||
unlisten(labelCache, EventType.CLEAR, this.handleFontsChanged_, this);
|
||||
CanvasTileLayerRenderer.prototype.disposeInternal.call(this);
|
||||
}
|
||||
|
||||
/**
|
||||
* Declutter tree.
|
||||
* @inheritDoc
|
||||
*/
|
||||
getTile(z, x, y, pixelRatio, projection) {
|
||||
const tile = CanvasTileLayerRenderer.prototype.getTile.call(this, z, x, y, pixelRatio, projection);
|
||||
if (tile.getState() === TileState.LOADED) {
|
||||
this.createReplayGroup_(tile, pixelRatio, projection);
|
||||
if (this.context) {
|
||||
this.renderTileImage_(tile, pixelRatio, projection);
|
||||
}
|
||||
}
|
||||
return tile;
|
||||
}
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
prepareFrame(frameState, layerState) {
|
||||
const layer = this.getLayer();
|
||||
const layerRevision = layer.getRevision();
|
||||
if (this.renderedLayerRevision_ != layerRevision) {
|
||||
this.renderedTiles.length = 0;
|
||||
const renderMode = layer.getRenderMode();
|
||||
if (!this.context && renderMode != VectorTileRenderType.VECTOR) {
|
||||
this.context = createCanvasContext2D();
|
||||
}
|
||||
if (this.context && renderMode == VectorTileRenderType.VECTOR) {
|
||||
this.context = null;
|
||||
}
|
||||
}
|
||||
this.renderedLayerRevision_ = layerRevision;
|
||||
return CanvasTileLayerRenderer.prototype.prepareFrame.apply(this, arguments);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {module:ol/VectorImageTile} tile Tile.
|
||||
* @param {number} pixelRatio Pixel ratio.
|
||||
* @param {module:ol/proj/Projection} projection Projection.
|
||||
* @private
|
||||
*/
|
||||
this.declutterTree_ = layer.getDeclutter() ? rbush(9, undefined) : null;
|
||||
createReplayGroup_(tile, pixelRatio, projection) {
|
||||
const layer = this.getLayer();
|
||||
const revision = layer.getRevision();
|
||||
const renderOrder = /** @type {module:ol/render~OrderFunction} */ (layer.getRenderOrder()) || null;
|
||||
|
||||
const replayState = tile.getReplayState(layer);
|
||||
if (!replayState.dirty && replayState.renderedRevision == revision &&
|
||||
replayState.renderedRenderOrder == renderOrder) {
|
||||
return;
|
||||
}
|
||||
|
||||
const source = /** @type {module:ol/source/VectorTile} */ (layer.getSource());
|
||||
const sourceTileGrid = source.getTileGrid();
|
||||
const tileGrid = source.getTileGridForProjection(projection);
|
||||
const resolution = tileGrid.getResolution(tile.tileCoord[0]);
|
||||
const tileExtent = tile.extent;
|
||||
|
||||
const zIndexKeys = {};
|
||||
for (let t = 0, tt = tile.tileKeys.length; t < tt; ++t) {
|
||||
const sourceTile = tile.getTile(tile.tileKeys[t]);
|
||||
if (sourceTile.getState() != TileState.LOADED) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const sourceTileCoord = sourceTile.tileCoord;
|
||||
const sourceTileExtent = sourceTileGrid.getTileCoordExtent(sourceTileCoord);
|
||||
const sharedExtent = getIntersection(tileExtent, sourceTileExtent);
|
||||
const bufferedExtent = equals(sourceTileExtent, sharedExtent) ? null :
|
||||
buffer(sharedExtent, layer.getRenderBuffer() * resolution, this.tmpExtent);
|
||||
const tileProjection = sourceTile.getProjection();
|
||||
let reproject = false;
|
||||
if (!equivalentProjection(projection, tileProjection)) {
|
||||
reproject = true;
|
||||
sourceTile.setProjection(projection);
|
||||
}
|
||||
replayState.dirty = false;
|
||||
const replayGroup = new CanvasReplayGroup(0, sharedExtent, resolution,
|
||||
pixelRatio, source.getOverlaps(), this.declutterTree_, layer.getRenderBuffer());
|
||||
const squaredTolerance = getSquaredRenderTolerance(resolution, pixelRatio);
|
||||
|
||||
/**
|
||||
* @param {module:ol/Feature|module:ol/render/Feature} feature Feature.
|
||||
* @this {module:ol/renderer/canvas/VectorTileLayer}
|
||||
*/
|
||||
const render = function(feature) {
|
||||
let styles;
|
||||
const styleFunction = feature.getStyleFunction() || layer.getStyleFunction();
|
||||
if (styleFunction) {
|
||||
styles = styleFunction(feature, resolution);
|
||||
}
|
||||
if (styles) {
|
||||
const dirty = this.renderFeature(feature, squaredTolerance, styles, replayGroup);
|
||||
this.dirty_ = this.dirty_ || dirty;
|
||||
replayState.dirty = replayState.dirty || dirty;
|
||||
}
|
||||
};
|
||||
|
||||
const features = sourceTile.getFeatures();
|
||||
if (renderOrder && renderOrder !== replayState.renderedRenderOrder) {
|
||||
features.sort(renderOrder);
|
||||
}
|
||||
for (let i = 0, ii = features.length; i < ii; ++i) {
|
||||
const feature = features[i];
|
||||
if (reproject) {
|
||||
if (tileProjection.getUnits() == Units.TILE_PIXELS) {
|
||||
// projected tile extent
|
||||
tileProjection.setWorldExtent(sourceTileExtent);
|
||||
// tile extent in tile pixel space
|
||||
tileProjection.setExtent(sourceTile.getExtent());
|
||||
}
|
||||
feature.getGeometry().transform(tileProjection, projection);
|
||||
}
|
||||
if (!bufferedExtent || intersects(bufferedExtent, feature.getGeometry().getExtent())) {
|
||||
render.call(this, feature);
|
||||
}
|
||||
}
|
||||
replayGroup.finish();
|
||||
for (const r in replayGroup.getReplays()) {
|
||||
zIndexKeys[r] = true;
|
||||
}
|
||||
sourceTile.setReplayGroup(layer, tile.tileCoord.toString(), replayGroup);
|
||||
}
|
||||
replayState.renderedRevision = revision;
|
||||
replayState.renderedRenderOrder = renderOrder;
|
||||
}
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {boolean}
|
||||
* @inheritDoc
|
||||
*/
|
||||
this.dirty_ = false;
|
||||
forEachFeatureAtCoordinate(coordinate, frameState, hitTolerance, callback, thisArg) {
|
||||
const resolution = frameState.viewState.resolution;
|
||||
const rotation = frameState.viewState.rotation;
|
||||
hitTolerance = hitTolerance == undefined ? 0 : hitTolerance;
|
||||
const layer = this.getLayer();
|
||||
/** @type {!Object.<string, boolean>} */
|
||||
const features = {};
|
||||
|
||||
/** @type {Array.<module:ol/VectorImageTile>} */
|
||||
const renderedTiles = this.renderedTiles;
|
||||
|
||||
let bufferedExtent, found;
|
||||
let i, ii, replayGroup;
|
||||
for (i = 0, ii = renderedTiles.length; i < ii; ++i) {
|
||||
const tile = renderedTiles[i];
|
||||
bufferedExtent = buffer(tile.extent, hitTolerance * resolution, bufferedExtent);
|
||||
if (!containsCoordinate(bufferedExtent, coordinate)) {
|
||||
continue;
|
||||
}
|
||||
for (let t = 0, tt = tile.tileKeys.length; t < tt; ++t) {
|
||||
const sourceTile = tile.getTile(tile.tileKeys[t]);
|
||||
if (sourceTile.getState() != TileState.LOADED) {
|
||||
continue;
|
||||
}
|
||||
replayGroup = sourceTile.getReplayGroup(layer, tile.tileCoord.toString());
|
||||
found = found || replayGroup.forEachFeatureAtCoordinate(coordinate, resolution, rotation, hitTolerance, {},
|
||||
/**
|
||||
* @param {module:ol/Feature|module:ol/render/Feature} feature Feature.
|
||||
* @return {?} Callback result.
|
||||
*/
|
||||
function(feature) {
|
||||
const key = getUid(feature).toString();
|
||||
if (!(key in features)) {
|
||||
features[key] = true;
|
||||
return callback.call(thisArg, feature, layer);
|
||||
}
|
||||
}, null);
|
||||
}
|
||||
}
|
||||
return found;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {module:ol/VectorTile} tile Tile.
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @return {module:ol/transform~Transform} transform Transform.
|
||||
* @private
|
||||
* @type {number}
|
||||
*/
|
||||
this.renderedLayerRevision_;
|
||||
getReplayTransform_(tile, frameState) {
|
||||
const layer = this.getLayer();
|
||||
const source = /** @type {module:ol/source/VectorTile} */ (layer.getSource());
|
||||
const tileGrid = source.getTileGrid();
|
||||
const tileCoord = tile.tileCoord;
|
||||
const tileResolution = tileGrid.getResolution(tileCoord[0]);
|
||||
const viewState = frameState.viewState;
|
||||
const pixelRatio = frameState.pixelRatio;
|
||||
const renderResolution = viewState.resolution / pixelRatio;
|
||||
const tileExtent = tileGrid.getTileCoordExtent(tileCoord, this.tmpExtent);
|
||||
const center = viewState.center;
|
||||
const origin = getTopLeft(tileExtent);
|
||||
const size = frameState.size;
|
||||
const offsetX = Math.round(pixelRatio * size[0] / 2);
|
||||
const offsetY = Math.round(pixelRatio * size[1] / 2);
|
||||
return composeTransform(this.tmpTransform_,
|
||||
offsetX, offsetY,
|
||||
tileResolution / renderResolution, tileResolution / renderResolution,
|
||||
viewState.rotation,
|
||||
(origin[0] - center[0]) / tileResolution,
|
||||
(center[1] - origin[1]) / tileResolution);
|
||||
}
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/transform~Transform}
|
||||
* @param {module:ol/events/Event} event Event.
|
||||
*/
|
||||
this.tmpTransform_ = createTransform();
|
||||
handleFontsChanged_(event) {
|
||||
const layer = this.getLayer();
|
||||
if (layer.getVisible() && this.renderedLayerRevision_ !== undefined) {
|
||||
layer.changed();
|
||||
}
|
||||
}
|
||||
|
||||
// Use lower resolution for pure vector rendering. Closest resolution otherwise.
|
||||
this.zDirection = layer.getRenderMode() == VectorTileRenderType.VECTOR ? 1 : 0;
|
||||
/**
|
||||
* Handle changes in image style state.
|
||||
* @param {module:ol/events/Event} event Image style change event.
|
||||
* @private
|
||||
*/
|
||||
handleStyleImageChange_(event) {
|
||||
this.renderIfReadyAndVisible();
|
||||
}
|
||||
|
||||
listen(labelCache, EventType.CLEAR, this.handleFontsChanged_, this);
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
postCompose(context, frameState, layerState) {
|
||||
const layer = this.getLayer();
|
||||
const renderMode = layer.getRenderMode();
|
||||
if (renderMode != VectorTileRenderType.IMAGE) {
|
||||
const declutterReplays = layer.getDeclutter() ? {} : null;
|
||||
const source = /** @type {module:ol/source/VectorTile} */ (layer.getSource());
|
||||
const replayTypes = VECTOR_REPLAYS[renderMode];
|
||||
const pixelRatio = frameState.pixelRatio;
|
||||
const rotation = frameState.viewState.rotation;
|
||||
const size = frameState.size;
|
||||
let offsetX, offsetY;
|
||||
if (rotation) {
|
||||
offsetX = Math.round(pixelRatio * size[0] / 2);
|
||||
offsetY = Math.round(pixelRatio * size[1] / 2);
|
||||
rotateAtOffset(context, -rotation, offsetX, offsetY);
|
||||
}
|
||||
if (declutterReplays) {
|
||||
this.declutterTree_.clear();
|
||||
}
|
||||
const tiles = this.renderedTiles;
|
||||
const tileGrid = source.getTileGridForProjection(frameState.viewState.projection);
|
||||
const clips = [];
|
||||
const zs = [];
|
||||
for (let i = tiles.length - 1; i >= 0; --i) {
|
||||
const tile = /** @type {module:ol/VectorImageTile} */ (tiles[i]);
|
||||
if (tile.getState() == TileState.ABORT) {
|
||||
continue;
|
||||
}
|
||||
const tileCoord = tile.tileCoord;
|
||||
const worldOffset = tileGrid.getTileCoordExtent(tileCoord, this.tmpExtent)[0] - tile.extent[0];
|
||||
let transform = undefined;
|
||||
for (let t = 0, tt = tile.tileKeys.length; t < tt; ++t) {
|
||||
const sourceTile = tile.getTile(tile.tileKeys[t]);
|
||||
if (sourceTile.getState() != TileState.LOADED) {
|
||||
continue;
|
||||
}
|
||||
const replayGroup = sourceTile.getReplayGroup(layer, tileCoord.toString());
|
||||
if (!replayGroup || !replayGroup.hasReplays(replayTypes)) {
|
||||
// sourceTile was not yet loaded when this.createReplayGroup_() was
|
||||
// called, or it has no replays of the types we want to render
|
||||
continue;
|
||||
}
|
||||
if (!transform) {
|
||||
transform = this.getTransform(frameState, worldOffset);
|
||||
}
|
||||
const currentZ = sourceTile.tileCoord[0];
|
||||
const currentClip = replayGroup.getClipCoords(transform);
|
||||
context.save();
|
||||
context.globalAlpha = layerState.opacity;
|
||||
// Create a clip mask for regions in this low resolution tile that are
|
||||
// already filled by a higher resolution tile
|
||||
for (let j = 0, jj = clips.length; j < jj; ++j) {
|
||||
const clip = clips[j];
|
||||
if (currentZ < zs[j]) {
|
||||
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 resolution 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();
|
||||
}
|
||||
}
|
||||
replayGroup.replay(context, transform, rotation, {}, replayTypes, declutterReplays);
|
||||
context.restore();
|
||||
clips.push(currentClip);
|
||||
zs.push(currentZ);
|
||||
}
|
||||
}
|
||||
if (declutterReplays) {
|
||||
replayDeclutter(declutterReplays, context, rotation);
|
||||
}
|
||||
if (rotation) {
|
||||
rotateAtOffset(context, rotation,
|
||||
/** @type {number} */ (offsetX), /** @type {number} */ (offsetY));
|
||||
}
|
||||
}
|
||||
CanvasTileLayerRenderer.prototype.postCompose.apply(this, arguments);
|
||||
}
|
||||
|
||||
};
|
||||
/**
|
||||
* @param {module:ol/Feature|module:ol/render/Feature} feature Feature.
|
||||
* @param {number} squaredTolerance Squared tolerance.
|
||||
* @param {(module:ol/style/Style|Array.<module:ol/style/Style>)} styles The style or array of styles.
|
||||
* @param {module:ol/render/canvas/ReplayGroup} replayGroup Replay group.
|
||||
* @return {boolean} `true` if an image is loading.
|
||||
*/
|
||||
renderFeature(feature, squaredTolerance, styles, replayGroup) {
|
||||
if (!styles) {
|
||||
return false;
|
||||
}
|
||||
let loading = false;
|
||||
if (Array.isArray(styles)) {
|
||||
for (let i = 0, ii = styles.length; i < ii; ++i) {
|
||||
loading = renderFeature(
|
||||
replayGroup, feature, styles[i], squaredTolerance,
|
||||
this.handleStyleImageChange_, this) || loading;
|
||||
}
|
||||
} else {
|
||||
loading = renderFeature(
|
||||
replayGroup, feature, styles, squaredTolerance,
|
||||
this.handleStyleImageChange_, this);
|
||||
}
|
||||
return loading;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {module:ol/VectorImageTile} tile Tile.
|
||||
* @param {number} pixelRatio Pixel ratio.
|
||||
* @param {module:ol/proj/Projection} projection Projection.
|
||||
* @private
|
||||
*/
|
||||
renderTileImage_(tile, pixelRatio, projection) {
|
||||
const layer = this.getLayer();
|
||||
const replayState = tile.getReplayState(layer);
|
||||
const revision = layer.getRevision();
|
||||
const replays = IMAGE_REPLAYS[layer.getRenderMode()];
|
||||
if (replays && replayState.renderedTileRevision !== revision) {
|
||||
replayState.renderedTileRevision = revision;
|
||||
const tileCoord = tile.wrappedTileCoord;
|
||||
const z = tileCoord[0];
|
||||
const source = /** @type {module:ol/source/VectorTile} */ (layer.getSource());
|
||||
const tileGrid = source.getTileGridForProjection(projection);
|
||||
const resolution = tileGrid.getResolution(z);
|
||||
const context = tile.getContext(layer);
|
||||
const size = source.getTilePixelSize(z, pixelRatio, projection);
|
||||
context.canvas.width = size[0];
|
||||
context.canvas.height = size[1];
|
||||
const tileExtent = tileGrid.getTileCoordExtent(tileCoord, this.tmpExtent);
|
||||
for (let i = 0, ii = tile.tileKeys.length; i < ii; ++i) {
|
||||
const sourceTile = tile.getTile(tile.tileKeys[i]);
|
||||
if (sourceTile.getState() != TileState.LOADED) {
|
||||
continue;
|
||||
}
|
||||
const pixelScale = pixelRatio / resolution;
|
||||
const transform = resetTransform(this.tmpTransform_);
|
||||
scaleTransform(transform, pixelScale, -pixelScale);
|
||||
translateTransform(transform, -tileExtent[0], -tileExtent[3]);
|
||||
const replayGroup = sourceTile.getReplayGroup(layer, tile.tileCoord.toString());
|
||||
replayGroup.replay(context, transform, 0, {}, replays);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
inherits(CanvasVectorTileLayerRenderer, CanvasTileLayerRenderer);
|
||||
|
||||
@@ -117,394 +498,4 @@ CanvasVectorTileLayerRenderer['create'] = function(mapRenderer, layer) {
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
CanvasVectorTileLayerRenderer.prototype.disposeInternal = function() {
|
||||
unlisten(labelCache, EventType.CLEAR, this.handleFontsChanged_, this);
|
||||
CanvasTileLayerRenderer.prototype.disposeInternal.call(this);
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
CanvasVectorTileLayerRenderer.prototype.getTile = function(z, x, y, pixelRatio, projection) {
|
||||
const tile = CanvasTileLayerRenderer.prototype.getTile.call(this, z, x, y, pixelRatio, projection);
|
||||
if (tile.getState() === TileState.LOADED) {
|
||||
this.createReplayGroup_(tile, pixelRatio, projection);
|
||||
if (this.context) {
|
||||
this.renderTileImage_(tile, pixelRatio, projection);
|
||||
}
|
||||
}
|
||||
return tile;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
CanvasVectorTileLayerRenderer.prototype.prepareFrame = function(frameState, layerState) {
|
||||
const layer = this.getLayer();
|
||||
const layerRevision = layer.getRevision();
|
||||
if (this.renderedLayerRevision_ != layerRevision) {
|
||||
this.renderedTiles.length = 0;
|
||||
const renderMode = layer.getRenderMode();
|
||||
if (!this.context && renderMode != VectorTileRenderType.VECTOR) {
|
||||
this.context = createCanvasContext2D();
|
||||
}
|
||||
if (this.context && renderMode == VectorTileRenderType.VECTOR) {
|
||||
this.context = null;
|
||||
}
|
||||
}
|
||||
this.renderedLayerRevision_ = layerRevision;
|
||||
return CanvasTileLayerRenderer.prototype.prepareFrame.apply(this, arguments);
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {module:ol/VectorImageTile} tile Tile.
|
||||
* @param {number} pixelRatio Pixel ratio.
|
||||
* @param {module:ol/proj/Projection} projection Projection.
|
||||
* @private
|
||||
*/
|
||||
CanvasVectorTileLayerRenderer.prototype.createReplayGroup_ = function(tile, pixelRatio, projection) {
|
||||
const layer = this.getLayer();
|
||||
const revision = layer.getRevision();
|
||||
const renderOrder = /** @type {module:ol/render~OrderFunction} */ (layer.getRenderOrder()) || null;
|
||||
|
||||
const replayState = tile.getReplayState(layer);
|
||||
if (!replayState.dirty && replayState.renderedRevision == revision &&
|
||||
replayState.renderedRenderOrder == renderOrder) {
|
||||
return;
|
||||
}
|
||||
|
||||
const source = /** @type {module:ol/source/VectorTile} */ (layer.getSource());
|
||||
const sourceTileGrid = source.getTileGrid();
|
||||
const tileGrid = source.getTileGridForProjection(projection);
|
||||
const resolution = tileGrid.getResolution(tile.tileCoord[0]);
|
||||
const tileExtent = tile.extent;
|
||||
|
||||
const zIndexKeys = {};
|
||||
for (let t = 0, tt = tile.tileKeys.length; t < tt; ++t) {
|
||||
const sourceTile = tile.getTile(tile.tileKeys[t]);
|
||||
if (sourceTile.getState() != TileState.LOADED) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const sourceTileCoord = sourceTile.tileCoord;
|
||||
const sourceTileExtent = sourceTileGrid.getTileCoordExtent(sourceTileCoord);
|
||||
const sharedExtent = getIntersection(tileExtent, sourceTileExtent);
|
||||
const bufferedExtent = equals(sourceTileExtent, sharedExtent) ? null :
|
||||
buffer(sharedExtent, layer.getRenderBuffer() * resolution, this.tmpExtent);
|
||||
const tileProjection = sourceTile.getProjection();
|
||||
let reproject = false;
|
||||
if (!equivalentProjection(projection, tileProjection)) {
|
||||
reproject = true;
|
||||
sourceTile.setProjection(projection);
|
||||
}
|
||||
replayState.dirty = false;
|
||||
const replayGroup = new CanvasReplayGroup(0, sharedExtent, resolution,
|
||||
pixelRatio, source.getOverlaps(), this.declutterTree_, layer.getRenderBuffer());
|
||||
const squaredTolerance = getSquaredRenderTolerance(resolution, pixelRatio);
|
||||
|
||||
/**
|
||||
* @param {module:ol/Feature|module:ol/render/Feature} feature Feature.
|
||||
* @this {module:ol/renderer/canvas/VectorTileLayer}
|
||||
*/
|
||||
const render = function(feature) {
|
||||
let styles;
|
||||
const styleFunction = feature.getStyleFunction() || layer.getStyleFunction();
|
||||
if (styleFunction) {
|
||||
styles = styleFunction(feature, resolution);
|
||||
}
|
||||
if (styles) {
|
||||
const dirty = this.renderFeature(feature, squaredTolerance, styles, replayGroup);
|
||||
this.dirty_ = this.dirty_ || dirty;
|
||||
replayState.dirty = replayState.dirty || dirty;
|
||||
}
|
||||
};
|
||||
|
||||
const features = sourceTile.getFeatures();
|
||||
if (renderOrder && renderOrder !== replayState.renderedRenderOrder) {
|
||||
features.sort(renderOrder);
|
||||
}
|
||||
for (let i = 0, ii = features.length; i < ii; ++i) {
|
||||
const feature = features[i];
|
||||
if (reproject) {
|
||||
if (tileProjection.getUnits() == Units.TILE_PIXELS) {
|
||||
// projected tile extent
|
||||
tileProjection.setWorldExtent(sourceTileExtent);
|
||||
// tile extent in tile pixel space
|
||||
tileProjection.setExtent(sourceTile.getExtent());
|
||||
}
|
||||
feature.getGeometry().transform(tileProjection, projection);
|
||||
}
|
||||
if (!bufferedExtent || intersects(bufferedExtent, feature.getGeometry().getExtent())) {
|
||||
render.call(this, feature);
|
||||
}
|
||||
}
|
||||
replayGroup.finish();
|
||||
for (const r in replayGroup.getReplays()) {
|
||||
zIndexKeys[r] = true;
|
||||
}
|
||||
sourceTile.setReplayGroup(layer, tile.tileCoord.toString(), replayGroup);
|
||||
}
|
||||
replayState.renderedRevision = revision;
|
||||
replayState.renderedRenderOrder = renderOrder;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
CanvasVectorTileLayerRenderer.prototype.forEachFeatureAtCoordinate = function(coordinate, frameState, hitTolerance, callback, thisArg) {
|
||||
const resolution = frameState.viewState.resolution;
|
||||
const rotation = frameState.viewState.rotation;
|
||||
hitTolerance = hitTolerance == undefined ? 0 : hitTolerance;
|
||||
const layer = this.getLayer();
|
||||
/** @type {!Object.<string, boolean>} */
|
||||
const features = {};
|
||||
|
||||
/** @type {Array.<module:ol/VectorImageTile>} */
|
||||
const renderedTiles = this.renderedTiles;
|
||||
|
||||
let bufferedExtent, found;
|
||||
let i, ii, replayGroup;
|
||||
for (i = 0, ii = renderedTiles.length; i < ii; ++i) {
|
||||
const tile = renderedTiles[i];
|
||||
bufferedExtent = buffer(tile.extent, hitTolerance * resolution, bufferedExtent);
|
||||
if (!containsCoordinate(bufferedExtent, coordinate)) {
|
||||
continue;
|
||||
}
|
||||
for (let t = 0, tt = tile.tileKeys.length; t < tt; ++t) {
|
||||
const sourceTile = tile.getTile(tile.tileKeys[t]);
|
||||
if (sourceTile.getState() != TileState.LOADED) {
|
||||
continue;
|
||||
}
|
||||
replayGroup = sourceTile.getReplayGroup(layer, tile.tileCoord.toString());
|
||||
found = found || replayGroup.forEachFeatureAtCoordinate(coordinate, resolution, rotation, hitTolerance, {},
|
||||
/**
|
||||
* @param {module:ol/Feature|module:ol/render/Feature} feature Feature.
|
||||
* @return {?} Callback result.
|
||||
*/
|
||||
function(feature) {
|
||||
const key = getUid(feature).toString();
|
||||
if (!(key in features)) {
|
||||
features[key] = true;
|
||||
return callback.call(thisArg, feature, layer);
|
||||
}
|
||||
}, null);
|
||||
}
|
||||
}
|
||||
return found;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {module:ol/VectorTile} tile Tile.
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @return {module:ol/transform~Transform} transform Transform.
|
||||
* @private
|
||||
*/
|
||||
CanvasVectorTileLayerRenderer.prototype.getReplayTransform_ = function(tile, frameState) {
|
||||
const layer = this.getLayer();
|
||||
const source = /** @type {module:ol/source/VectorTile} */ (layer.getSource());
|
||||
const tileGrid = source.getTileGrid();
|
||||
const tileCoord = tile.tileCoord;
|
||||
const tileResolution = tileGrid.getResolution(tileCoord[0]);
|
||||
const viewState = frameState.viewState;
|
||||
const pixelRatio = frameState.pixelRatio;
|
||||
const renderResolution = viewState.resolution / pixelRatio;
|
||||
const tileExtent = tileGrid.getTileCoordExtent(tileCoord, this.tmpExtent);
|
||||
const center = viewState.center;
|
||||
const origin = getTopLeft(tileExtent);
|
||||
const size = frameState.size;
|
||||
const offsetX = Math.round(pixelRatio * size[0] / 2);
|
||||
const offsetY = Math.round(pixelRatio * size[1] / 2);
|
||||
return composeTransform(this.tmpTransform_,
|
||||
offsetX, offsetY,
|
||||
tileResolution / renderResolution, tileResolution / renderResolution,
|
||||
viewState.rotation,
|
||||
(origin[0] - center[0]) / tileResolution,
|
||||
(center[1] - origin[1]) / tileResolution);
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {module:ol/events/Event} event Event.
|
||||
*/
|
||||
CanvasVectorTileLayerRenderer.prototype.handleFontsChanged_ = function(event) {
|
||||
const layer = this.getLayer();
|
||||
if (layer.getVisible() && this.renderedLayerRevision_ !== undefined) {
|
||||
layer.changed();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* Handle changes in image style state.
|
||||
* @param {module:ol/events/Event} event Image style change event.
|
||||
* @private
|
||||
*/
|
||||
CanvasVectorTileLayerRenderer.prototype.handleStyleImageChange_ = function(event) {
|
||||
this.renderIfReadyAndVisible();
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
CanvasVectorTileLayerRenderer.prototype.postCompose = function(context, frameState, layerState) {
|
||||
const layer = this.getLayer();
|
||||
const renderMode = layer.getRenderMode();
|
||||
if (renderMode != VectorTileRenderType.IMAGE) {
|
||||
const declutterReplays = layer.getDeclutter() ? {} : null;
|
||||
const source = /** @type {module:ol/source/VectorTile} */ (layer.getSource());
|
||||
const replayTypes = VECTOR_REPLAYS[renderMode];
|
||||
const pixelRatio = frameState.pixelRatio;
|
||||
const rotation = frameState.viewState.rotation;
|
||||
const size = frameState.size;
|
||||
let offsetX, offsetY;
|
||||
if (rotation) {
|
||||
offsetX = Math.round(pixelRatio * size[0] / 2);
|
||||
offsetY = Math.round(pixelRatio * size[1] / 2);
|
||||
rotateAtOffset(context, -rotation, offsetX, offsetY);
|
||||
}
|
||||
if (declutterReplays) {
|
||||
this.declutterTree_.clear();
|
||||
}
|
||||
const tiles = this.renderedTiles;
|
||||
const tileGrid = source.getTileGridForProjection(frameState.viewState.projection);
|
||||
const clips = [];
|
||||
const zs = [];
|
||||
for (let i = tiles.length - 1; i >= 0; --i) {
|
||||
const tile = /** @type {module:ol/VectorImageTile} */ (tiles[i]);
|
||||
if (tile.getState() == TileState.ABORT) {
|
||||
continue;
|
||||
}
|
||||
const tileCoord = tile.tileCoord;
|
||||
const worldOffset = tileGrid.getTileCoordExtent(tileCoord, this.tmpExtent)[0] - tile.extent[0];
|
||||
let transform = undefined;
|
||||
for (let t = 0, tt = tile.tileKeys.length; t < tt; ++t) {
|
||||
const sourceTile = tile.getTile(tile.tileKeys[t]);
|
||||
if (sourceTile.getState() != TileState.LOADED) {
|
||||
continue;
|
||||
}
|
||||
const replayGroup = sourceTile.getReplayGroup(layer, tileCoord.toString());
|
||||
if (!replayGroup || !replayGroup.hasReplays(replayTypes)) {
|
||||
// sourceTile was not yet loaded when this.createReplayGroup_() was
|
||||
// called, or it has no replays of the types we want to render
|
||||
continue;
|
||||
}
|
||||
if (!transform) {
|
||||
transform = this.getTransform(frameState, worldOffset);
|
||||
}
|
||||
const currentZ = sourceTile.tileCoord[0];
|
||||
const currentClip = replayGroup.getClipCoords(transform);
|
||||
context.save();
|
||||
context.globalAlpha = layerState.opacity;
|
||||
// Create a clip mask for regions in this low resolution tile that are
|
||||
// already filled by a higher resolution tile
|
||||
for (let j = 0, jj = clips.length; j < jj; ++j) {
|
||||
const clip = clips[j];
|
||||
if (currentZ < zs[j]) {
|
||||
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 resolution 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();
|
||||
}
|
||||
}
|
||||
replayGroup.replay(context, transform, rotation, {}, replayTypes, declutterReplays);
|
||||
context.restore();
|
||||
clips.push(currentClip);
|
||||
zs.push(currentZ);
|
||||
}
|
||||
}
|
||||
if (declutterReplays) {
|
||||
replayDeclutter(declutterReplays, context, rotation);
|
||||
}
|
||||
if (rotation) {
|
||||
rotateAtOffset(context, rotation,
|
||||
/** @type {number} */ (offsetX), /** @type {number} */ (offsetY));
|
||||
}
|
||||
}
|
||||
CanvasTileLayerRenderer.prototype.postCompose.apply(this, arguments);
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {module:ol/Feature|module:ol/render/Feature} feature Feature.
|
||||
* @param {number} squaredTolerance Squared tolerance.
|
||||
* @param {(module:ol/style/Style|Array.<module:ol/style/Style>)} styles The style or array of styles.
|
||||
* @param {module:ol/render/canvas/ReplayGroup} replayGroup Replay group.
|
||||
* @return {boolean} `true` if an image is loading.
|
||||
*/
|
||||
CanvasVectorTileLayerRenderer.prototype.renderFeature = function(feature, squaredTolerance, styles, replayGroup) {
|
||||
if (!styles) {
|
||||
return false;
|
||||
}
|
||||
let loading = false;
|
||||
if (Array.isArray(styles)) {
|
||||
for (let i = 0, ii = styles.length; i < ii; ++i) {
|
||||
loading = renderFeature(
|
||||
replayGroup, feature, styles[i], squaredTolerance,
|
||||
this.handleStyleImageChange_, this) || loading;
|
||||
}
|
||||
} else {
|
||||
loading = renderFeature(
|
||||
replayGroup, feature, styles, squaredTolerance,
|
||||
this.handleStyleImageChange_, this);
|
||||
}
|
||||
return loading;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {module:ol/VectorImageTile} tile Tile.
|
||||
* @param {number} pixelRatio Pixel ratio.
|
||||
* @param {module:ol/proj/Projection} projection Projection.
|
||||
* @private
|
||||
*/
|
||||
CanvasVectorTileLayerRenderer.prototype.renderTileImage_ = function(
|
||||
tile, pixelRatio, projection) {
|
||||
const layer = this.getLayer();
|
||||
const replayState = tile.getReplayState(layer);
|
||||
const revision = layer.getRevision();
|
||||
const replays = IMAGE_REPLAYS[layer.getRenderMode()];
|
||||
if (replays && replayState.renderedTileRevision !== revision) {
|
||||
replayState.renderedTileRevision = revision;
|
||||
const tileCoord = tile.wrappedTileCoord;
|
||||
const z = tileCoord[0];
|
||||
const source = /** @type {module:ol/source/VectorTile} */ (layer.getSource());
|
||||
const tileGrid = source.getTileGridForProjection(projection);
|
||||
const resolution = tileGrid.getResolution(z);
|
||||
const context = tile.getContext(layer);
|
||||
const size = source.getTilePixelSize(z, pixelRatio, projection);
|
||||
context.canvas.width = size[0];
|
||||
context.canvas.height = size[1];
|
||||
const tileExtent = tileGrid.getTileCoordExtent(tileCoord, this.tmpExtent);
|
||||
for (let i = 0, ii = tile.tileKeys.length; i < ii; ++i) {
|
||||
const sourceTile = tile.getTile(tile.tileKeys[i]);
|
||||
if (sourceTile.getState() != TileState.LOADED) {
|
||||
continue;
|
||||
}
|
||||
const pixelScale = pixelRatio / resolution;
|
||||
const transform = resetTransform(this.tmpTransform_);
|
||||
scaleTransform(transform, pixelScale, -pixelScale);
|
||||
translateTransform(transform, -tileExtent[0], -tileExtent[3]);
|
||||
const replayGroup = sourceTile.getReplayGroup(layer, tile.tileCoord.toString());
|
||||
replayGroup.replay(context, transform, 0, {}, replays);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
export default CanvasVectorTileLayerRenderer;
|
||||
|
||||
+268
-264
@@ -29,30 +29,286 @@ import {createTexture} from '../../webgl/Context.js';
|
||||
* @param {module:ol/layer/Image} imageLayer Tile layer.
|
||||
* @api
|
||||
*/
|
||||
const WebGLImageLayerRenderer = function(mapRenderer, imageLayer) {
|
||||
class WebGLImageLayerRenderer {
|
||||
constructor(mapRenderer, imageLayer) {
|
||||
|
||||
WebGLLayerRenderer.call(this, mapRenderer, imageLayer);
|
||||
WebGLLayerRenderer.call(this, mapRenderer, imageLayer);
|
||||
|
||||
/**
|
||||
* The last rendered image.
|
||||
* @private
|
||||
* @type {?module:ol/ImageBase}
|
||||
*/
|
||||
this.image_ = null;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {CanvasRenderingContext2D}
|
||||
*/
|
||||
this.hitCanvasContext_ = null;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {?module:ol/transform~Transform}
|
||||
*/
|
||||
this.hitTransformationMatrix_ = null;
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* The last rendered image.
|
||||
* @param {module:ol/ImageBase} image Image.
|
||||
* @private
|
||||
* @type {?module:ol/ImageBase}
|
||||
* @return {WebGLTexture} Texture.
|
||||
*/
|
||||
this.image_ = null;
|
||||
createTexture_(image) {
|
||||
|
||||
// We meet the conditions to work with non-power of two textures.
|
||||
// http://www.khronos.org/webgl/wiki/WebGL_and_OpenGL_Differences#Non-Power_of_Two_Texture_Support
|
||||
// http://learningwebgl.com/blog/?p=2101
|
||||
|
||||
const imageElement = image.getImage();
|
||||
const gl = this.mapRenderer.getGL();
|
||||
|
||||
return createTexture(
|
||||
gl, imageElement, CLAMP_TO_EDGE, CLAMP_TO_EDGE);
|
||||
}
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {CanvasRenderingContext2D}
|
||||
* @inheritDoc
|
||||
*/
|
||||
this.hitCanvasContext_ = null;
|
||||
forEachFeatureAtCoordinate(coordinate, frameState, hitTolerance, callback, thisArg) {
|
||||
const layer = this.getLayer();
|
||||
const source = layer.getSource();
|
||||
const resolution = frameState.viewState.resolution;
|
||||
const rotation = frameState.viewState.rotation;
|
||||
const skippedFeatureUids = frameState.skippedFeatureUids;
|
||||
return source.forEachFeatureAtCoordinate(
|
||||
coordinate, resolution, rotation, hitTolerance, skippedFeatureUids,
|
||||
|
||||
/**
|
||||
* @param {module:ol/Feature|module:ol/render/Feature} feature Feature.
|
||||
* @return {?} Callback result.
|
||||
*/
|
||||
function(feature) {
|
||||
return callback.call(thisArg, feature, layer);
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {?module:ol/transform~Transform}
|
||||
* @inheritDoc
|
||||
*/
|
||||
this.hitTransformationMatrix_ = null;
|
||||
prepareFrame(frameState, layerState, context) {
|
||||
|
||||
};
|
||||
const gl = this.mapRenderer.getGL();
|
||||
|
||||
const pixelRatio = frameState.pixelRatio;
|
||||
const viewState = frameState.viewState;
|
||||
const viewCenter = viewState.center;
|
||||
const viewResolution = viewState.resolution;
|
||||
const viewRotation = viewState.rotation;
|
||||
|
||||
let image = this.image_;
|
||||
let texture = this.texture;
|
||||
const imageLayer = /** @type {module:ol/layer/Image} */ (this.getLayer());
|
||||
const imageSource = imageLayer.getSource();
|
||||
|
||||
const hints = frameState.viewHints;
|
||||
|
||||
let renderedExtent = frameState.extent;
|
||||
if (layerState.extent !== undefined) {
|
||||
renderedExtent = getIntersection(renderedExtent, layerState.extent);
|
||||
}
|
||||
if (!hints[ViewHint.ANIMATING] && !hints[ViewHint.INTERACTING] &&
|
||||
!isEmpty(renderedExtent)) {
|
||||
let projection = viewState.projection;
|
||||
if (!ENABLE_RASTER_REPROJECTION) {
|
||||
const sourceProjection = imageSource.getProjection();
|
||||
if (sourceProjection) {
|
||||
projection = sourceProjection;
|
||||
}
|
||||
}
|
||||
const image_ = imageSource.getImage(renderedExtent, viewResolution,
|
||||
pixelRatio, projection);
|
||||
if (image_) {
|
||||
const loaded = this.loadImage(image_);
|
||||
if (loaded) {
|
||||
image = image_;
|
||||
texture = this.createTexture_(image_);
|
||||
if (this.texture) {
|
||||
/**
|
||||
* @param {WebGLRenderingContext} gl GL.
|
||||
* @param {WebGLTexture} texture Texture.
|
||||
*/
|
||||
const postRenderFunction = function(gl, texture) {
|
||||
if (!gl.isContextLost()) {
|
||||
gl.deleteTexture(texture);
|
||||
}
|
||||
}.bind(null, gl, this.texture);
|
||||
frameState.postRenderFunctions.push(
|
||||
/** @type {module:ol/PluggableMap~PostRenderFunction} */ (postRenderFunction)
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (image) {
|
||||
const canvas = this.mapRenderer.getContext().getCanvas();
|
||||
|
||||
this.updateProjectionMatrix_(canvas.width, canvas.height,
|
||||
pixelRatio, viewCenter, viewResolution, viewRotation,
|
||||
image.getExtent());
|
||||
this.hitTransformationMatrix_ = null;
|
||||
|
||||
// Translate and scale to flip the Y coord.
|
||||
const texCoordMatrix = this.texCoordMatrix;
|
||||
resetTransform(texCoordMatrix);
|
||||
scaleTransform(texCoordMatrix, 1, -1);
|
||||
translateTransform(texCoordMatrix, 0, -1);
|
||||
|
||||
this.image_ = image;
|
||||
this.texture = texture;
|
||||
}
|
||||
|
||||
return !!image;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {number} canvasWidth Canvas width.
|
||||
* @param {number} canvasHeight Canvas height.
|
||||
* @param {number} pixelRatio Pixel ratio.
|
||||
* @param {module:ol/coordinate~Coordinate} viewCenter View center.
|
||||
* @param {number} viewResolution View resolution.
|
||||
* @param {number} viewRotation View rotation.
|
||||
* @param {module:ol/extent~Extent} imageExtent Image extent.
|
||||
* @private
|
||||
*/
|
||||
updateProjectionMatrix_(
|
||||
canvasWidth,
|
||||
canvasHeight,
|
||||
pixelRatio,
|
||||
viewCenter,
|
||||
viewResolution,
|
||||
viewRotation,
|
||||
imageExtent
|
||||
) {
|
||||
|
||||
const canvasExtentWidth = canvasWidth * viewResolution;
|
||||
const canvasExtentHeight = canvasHeight * viewResolution;
|
||||
|
||||
const projectionMatrix = this.projectionMatrix;
|
||||
resetTransform(projectionMatrix);
|
||||
scaleTransform(projectionMatrix,
|
||||
pixelRatio * 2 / canvasExtentWidth,
|
||||
pixelRatio * 2 / canvasExtentHeight);
|
||||
rotateTransform(projectionMatrix, -viewRotation);
|
||||
translateTransform(projectionMatrix,
|
||||
imageExtent[0] - viewCenter[0],
|
||||
imageExtent[1] - viewCenter[1]);
|
||||
scaleTransform(projectionMatrix,
|
||||
(imageExtent[2] - imageExtent[0]) / 2,
|
||||
(imageExtent[3] - imageExtent[1]) / 2);
|
||||
translateTransform(projectionMatrix, 1, 1);
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
hasFeatureAtCoordinate(coordinate, frameState) {
|
||||
const hasFeature = this.forEachFeatureAtCoordinate(coordinate, frameState, 0, TRUE, this);
|
||||
return hasFeature !== undefined;
|
||||
}
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
forEachLayerAtPixel(pixel, frameState, callback, thisArg) {
|
||||
if (!this.image_ || !this.image_.getImage()) {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
if (this.getLayer().getSource().forEachFeatureAtCoordinate !== UNDEFINED) {
|
||||
// for ImageCanvas sources use the original hit-detection logic,
|
||||
// so that for example also transparent polygons are detected
|
||||
const coordinate = applyTransform(
|
||||
frameState.pixelToCoordinateTransform, pixel.slice());
|
||||
const hasFeature = this.forEachFeatureAtCoordinate(coordinate, frameState, 0, TRUE, this);
|
||||
|
||||
if (hasFeature) {
|
||||
return callback.call(thisArg, this.getLayer(), null);
|
||||
} else {
|
||||
return undefined;
|
||||
}
|
||||
} else {
|
||||
const imageSize =
|
||||
[this.image_.getImage().width, this.image_.getImage().height];
|
||||
|
||||
if (!this.hitTransformationMatrix_) {
|
||||
this.hitTransformationMatrix_ = this.getHitTransformationMatrix_(
|
||||
frameState.size, imageSize);
|
||||
}
|
||||
|
||||
const pixelOnFrameBuffer = applyTransform(
|
||||
this.hitTransformationMatrix_, pixel.slice());
|
||||
|
||||
if (pixelOnFrameBuffer[0] < 0 || pixelOnFrameBuffer[0] > imageSize[0] ||
|
||||
pixelOnFrameBuffer[1] < 0 || pixelOnFrameBuffer[1] > imageSize[1]) {
|
||||
// outside the image, no need to check
|
||||
return undefined;
|
||||
}
|
||||
|
||||
if (!this.hitCanvasContext_) {
|
||||
this.hitCanvasContext_ = createCanvasContext2D(1, 1);
|
||||
}
|
||||
|
||||
this.hitCanvasContext_.clearRect(0, 0, 1, 1);
|
||||
this.hitCanvasContext_.drawImage(this.image_.getImage(),
|
||||
pixelOnFrameBuffer[0], pixelOnFrameBuffer[1], 1, 1, 0, 0, 1, 1);
|
||||
|
||||
const imageData = this.hitCanvasContext_.getImageData(0, 0, 1, 1).data;
|
||||
if (imageData[3] > 0) {
|
||||
return callback.call(thisArg, this.getLayer(), imageData);
|
||||
} else {
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The transformation matrix to get the pixel on the image for a
|
||||
* pixel on the map.
|
||||
* @param {module:ol/size~Size} mapSize The map size.
|
||||
* @param {module:ol/size~Size} imageSize The image size.
|
||||
* @return {module:ol/transform~Transform} The transformation matrix.
|
||||
* @private
|
||||
*/
|
||||
getHitTransformationMatrix_(mapSize, imageSize) {
|
||||
// the first matrix takes a map pixel, flips the y-axis and scales to
|
||||
// a range between -1 ... 1
|
||||
const mapCoordTransform = createTransform();
|
||||
translateTransform(mapCoordTransform, -1, -1);
|
||||
scaleTransform(mapCoordTransform, 2 / mapSize[0], 2 / mapSize[1]);
|
||||
translateTransform(mapCoordTransform, 0, mapSize[1]);
|
||||
scaleTransform(mapCoordTransform, 1, -1);
|
||||
|
||||
// the second matrix is the inverse of the projection matrix used in the
|
||||
// shader for drawing
|
||||
const projectionMatrixInv = invertTransform(this.projectionMatrix.slice());
|
||||
|
||||
// the third matrix scales to the image dimensions and flips the y-axis again
|
||||
const transform = createTransform();
|
||||
translateTransform(transform, 0, imageSize[1]);
|
||||
scaleTransform(transform, 1, -1);
|
||||
scaleTransform(transform, imageSize[0] / 2, imageSize[1] / 2);
|
||||
translateTransform(transform, 1, 1);
|
||||
|
||||
multiplyTransform(transform, projectionMatrixInv);
|
||||
multiplyTransform(transform, mapCoordTransform);
|
||||
|
||||
return transform;
|
||||
}
|
||||
}
|
||||
|
||||
inherits(WebGLImageLayerRenderer, WebGLLayerRenderer);
|
||||
|
||||
@@ -81,256 +337,4 @@ WebGLImageLayerRenderer['create'] = function(mapRenderer, layer) {
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {module:ol/ImageBase} image Image.
|
||||
* @private
|
||||
* @return {WebGLTexture} Texture.
|
||||
*/
|
||||
WebGLImageLayerRenderer.prototype.createTexture_ = function(image) {
|
||||
|
||||
// We meet the conditions to work with non-power of two textures.
|
||||
// http://www.khronos.org/webgl/wiki/WebGL_and_OpenGL_Differences#Non-Power_of_Two_Texture_Support
|
||||
// http://learningwebgl.com/blog/?p=2101
|
||||
|
||||
const imageElement = image.getImage();
|
||||
const gl = this.mapRenderer.getGL();
|
||||
|
||||
return createTexture(
|
||||
gl, imageElement, CLAMP_TO_EDGE, CLAMP_TO_EDGE);
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
WebGLImageLayerRenderer.prototype.forEachFeatureAtCoordinate = function(coordinate, frameState, hitTolerance, callback, thisArg) {
|
||||
const layer = this.getLayer();
|
||||
const source = layer.getSource();
|
||||
const resolution = frameState.viewState.resolution;
|
||||
const rotation = frameState.viewState.rotation;
|
||||
const skippedFeatureUids = frameState.skippedFeatureUids;
|
||||
return source.forEachFeatureAtCoordinate(
|
||||
coordinate, resolution, rotation, hitTolerance, skippedFeatureUids,
|
||||
|
||||
/**
|
||||
* @param {module:ol/Feature|module:ol/render/Feature} feature Feature.
|
||||
* @return {?} Callback result.
|
||||
*/
|
||||
function(feature) {
|
||||
return callback.call(thisArg, feature, layer);
|
||||
});
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
WebGLImageLayerRenderer.prototype.prepareFrame = function(frameState, layerState, context) {
|
||||
|
||||
const gl = this.mapRenderer.getGL();
|
||||
|
||||
const pixelRatio = frameState.pixelRatio;
|
||||
const viewState = frameState.viewState;
|
||||
const viewCenter = viewState.center;
|
||||
const viewResolution = viewState.resolution;
|
||||
const viewRotation = viewState.rotation;
|
||||
|
||||
let image = this.image_;
|
||||
let texture = this.texture;
|
||||
const imageLayer = /** @type {module:ol/layer/Image} */ (this.getLayer());
|
||||
const imageSource = imageLayer.getSource();
|
||||
|
||||
const hints = frameState.viewHints;
|
||||
|
||||
let renderedExtent = frameState.extent;
|
||||
if (layerState.extent !== undefined) {
|
||||
renderedExtent = getIntersection(renderedExtent, layerState.extent);
|
||||
}
|
||||
if (!hints[ViewHint.ANIMATING] && !hints[ViewHint.INTERACTING] &&
|
||||
!isEmpty(renderedExtent)) {
|
||||
let projection = viewState.projection;
|
||||
if (!ENABLE_RASTER_REPROJECTION) {
|
||||
const sourceProjection = imageSource.getProjection();
|
||||
if (sourceProjection) {
|
||||
projection = sourceProjection;
|
||||
}
|
||||
}
|
||||
const image_ = imageSource.getImage(renderedExtent, viewResolution,
|
||||
pixelRatio, projection);
|
||||
if (image_) {
|
||||
const loaded = this.loadImage(image_);
|
||||
if (loaded) {
|
||||
image = image_;
|
||||
texture = this.createTexture_(image_);
|
||||
if (this.texture) {
|
||||
/**
|
||||
* @param {WebGLRenderingContext} gl GL.
|
||||
* @param {WebGLTexture} texture Texture.
|
||||
*/
|
||||
const postRenderFunction = function(gl, texture) {
|
||||
if (!gl.isContextLost()) {
|
||||
gl.deleteTexture(texture);
|
||||
}
|
||||
}.bind(null, gl, this.texture);
|
||||
frameState.postRenderFunctions.push(
|
||||
/** @type {module:ol/PluggableMap~PostRenderFunction} */ (postRenderFunction)
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (image) {
|
||||
const canvas = this.mapRenderer.getContext().getCanvas();
|
||||
|
||||
this.updateProjectionMatrix_(canvas.width, canvas.height,
|
||||
pixelRatio, viewCenter, viewResolution, viewRotation,
|
||||
image.getExtent());
|
||||
this.hitTransformationMatrix_ = null;
|
||||
|
||||
// Translate and scale to flip the Y coord.
|
||||
const texCoordMatrix = this.texCoordMatrix;
|
||||
resetTransform(texCoordMatrix);
|
||||
scaleTransform(texCoordMatrix, 1, -1);
|
||||
translateTransform(texCoordMatrix, 0, -1);
|
||||
|
||||
this.image_ = image;
|
||||
this.texture = texture;
|
||||
}
|
||||
|
||||
return !!image;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {number} canvasWidth Canvas width.
|
||||
* @param {number} canvasHeight Canvas height.
|
||||
* @param {number} pixelRatio Pixel ratio.
|
||||
* @param {module:ol/coordinate~Coordinate} viewCenter View center.
|
||||
* @param {number} viewResolution View resolution.
|
||||
* @param {number} viewRotation View rotation.
|
||||
* @param {module:ol/extent~Extent} imageExtent Image extent.
|
||||
* @private
|
||||
*/
|
||||
WebGLImageLayerRenderer.prototype.updateProjectionMatrix_ = function(canvasWidth, canvasHeight, pixelRatio,
|
||||
viewCenter, viewResolution, viewRotation, imageExtent) {
|
||||
|
||||
const canvasExtentWidth = canvasWidth * viewResolution;
|
||||
const canvasExtentHeight = canvasHeight * viewResolution;
|
||||
|
||||
const projectionMatrix = this.projectionMatrix;
|
||||
resetTransform(projectionMatrix);
|
||||
scaleTransform(projectionMatrix,
|
||||
pixelRatio * 2 / canvasExtentWidth,
|
||||
pixelRatio * 2 / canvasExtentHeight);
|
||||
rotateTransform(projectionMatrix, -viewRotation);
|
||||
translateTransform(projectionMatrix,
|
||||
imageExtent[0] - viewCenter[0],
|
||||
imageExtent[1] - viewCenter[1]);
|
||||
scaleTransform(projectionMatrix,
|
||||
(imageExtent[2] - imageExtent[0]) / 2,
|
||||
(imageExtent[3] - imageExtent[1]) / 2);
|
||||
translateTransform(projectionMatrix, 1, 1);
|
||||
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
WebGLImageLayerRenderer.prototype.hasFeatureAtCoordinate = function(coordinate, frameState) {
|
||||
const hasFeature = this.forEachFeatureAtCoordinate(coordinate, frameState, 0, TRUE, this);
|
||||
return hasFeature !== undefined;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
WebGLImageLayerRenderer.prototype.forEachLayerAtPixel = function(pixel, frameState, callback, thisArg) {
|
||||
if (!this.image_ || !this.image_.getImage()) {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
if (this.getLayer().getSource().forEachFeatureAtCoordinate !== UNDEFINED) {
|
||||
// for ImageCanvas sources use the original hit-detection logic,
|
||||
// so that for example also transparent polygons are detected
|
||||
const coordinate = applyTransform(
|
||||
frameState.pixelToCoordinateTransform, pixel.slice());
|
||||
const hasFeature = this.forEachFeatureAtCoordinate(coordinate, frameState, 0, TRUE, this);
|
||||
|
||||
if (hasFeature) {
|
||||
return callback.call(thisArg, this.getLayer(), null);
|
||||
} else {
|
||||
return undefined;
|
||||
}
|
||||
} else {
|
||||
const imageSize =
|
||||
[this.image_.getImage().width, this.image_.getImage().height];
|
||||
|
||||
if (!this.hitTransformationMatrix_) {
|
||||
this.hitTransformationMatrix_ = this.getHitTransformationMatrix_(
|
||||
frameState.size, imageSize);
|
||||
}
|
||||
|
||||
const pixelOnFrameBuffer = applyTransform(
|
||||
this.hitTransformationMatrix_, pixel.slice());
|
||||
|
||||
if (pixelOnFrameBuffer[0] < 0 || pixelOnFrameBuffer[0] > imageSize[0] ||
|
||||
pixelOnFrameBuffer[1] < 0 || pixelOnFrameBuffer[1] > imageSize[1]) {
|
||||
// outside the image, no need to check
|
||||
return undefined;
|
||||
}
|
||||
|
||||
if (!this.hitCanvasContext_) {
|
||||
this.hitCanvasContext_ = createCanvasContext2D(1, 1);
|
||||
}
|
||||
|
||||
this.hitCanvasContext_.clearRect(0, 0, 1, 1);
|
||||
this.hitCanvasContext_.drawImage(this.image_.getImage(),
|
||||
pixelOnFrameBuffer[0], pixelOnFrameBuffer[1], 1, 1, 0, 0, 1, 1);
|
||||
|
||||
const imageData = this.hitCanvasContext_.getImageData(0, 0, 1, 1).data;
|
||||
if (imageData[3] > 0) {
|
||||
return callback.call(thisArg, this.getLayer(), imageData);
|
||||
} else {
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* The transformation matrix to get the pixel on the image for a
|
||||
* pixel on the map.
|
||||
* @param {module:ol/size~Size} mapSize The map size.
|
||||
* @param {module:ol/size~Size} imageSize The image size.
|
||||
* @return {module:ol/transform~Transform} The transformation matrix.
|
||||
* @private
|
||||
*/
|
||||
WebGLImageLayerRenderer.prototype.getHitTransformationMatrix_ = function(mapSize, imageSize) {
|
||||
// the first matrix takes a map pixel, flips the y-axis and scales to
|
||||
// a range between -1 ... 1
|
||||
const mapCoordTransform = createTransform();
|
||||
translateTransform(mapCoordTransform, -1, -1);
|
||||
scaleTransform(mapCoordTransform, 2 / mapSize[0], 2 / mapSize[1]);
|
||||
translateTransform(mapCoordTransform, 0, mapSize[1]);
|
||||
scaleTransform(mapCoordTransform, 1, -1);
|
||||
|
||||
// the second matrix is the inverse of the projection matrix used in the
|
||||
// shader for drawing
|
||||
const projectionMatrixInv = invertTransform(this.projectionMatrix.slice());
|
||||
|
||||
// the third matrix scales to the image dimensions and flips the y-axis again
|
||||
const transform = createTransform();
|
||||
translateTransform(transform, 0, imageSize[1]);
|
||||
scaleTransform(transform, 1, -1);
|
||||
scaleTransform(transform, imageSize[0] / 2, imageSize[1] / 2);
|
||||
translateTransform(transform, 1, 1);
|
||||
|
||||
multiplyTransform(transform, projectionMatrixInv);
|
||||
multiplyTransform(transform, mapCoordTransform);
|
||||
|
||||
return transform;
|
||||
};
|
||||
export default WebGLImageLayerRenderer;
|
||||
|
||||
+215
-220
@@ -22,244 +22,239 @@ import {createEmptyTexture} from '../../webgl/Context.js';
|
||||
* @param {module:ol/renderer/webgl/Map} mapRenderer Map renderer.
|
||||
* @param {module:ol/layer/Layer} layer Layer.
|
||||
*/
|
||||
const WebGLLayerRenderer = function(mapRenderer, layer) {
|
||||
class WebGLLayerRenderer {
|
||||
constructor(mapRenderer, layer) {
|
||||
|
||||
LayerRenderer.call(this, layer);
|
||||
LayerRenderer.call(this, layer);
|
||||
|
||||
/**
|
||||
* @protected
|
||||
* @type {module:ol/renderer/webgl/Map}
|
||||
*/
|
||||
this.mapRenderer = mapRenderer;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/webgl/Buffer}
|
||||
*/
|
||||
this.arrayBuffer_ = new WebGLBuffer([
|
||||
-1, -1, 0, 0,
|
||||
1, -1, 1, 0,
|
||||
-1, 1, 0, 1,
|
||||
1, 1, 1, 1
|
||||
]);
|
||||
|
||||
/**
|
||||
* @protected
|
||||
* @type {WebGLTexture}
|
||||
*/
|
||||
this.texture = null;
|
||||
|
||||
/**
|
||||
* @protected
|
||||
* @type {WebGLFramebuffer}
|
||||
*/
|
||||
this.framebuffer = null;
|
||||
|
||||
/**
|
||||
* @protected
|
||||
* @type {number|undefined}
|
||||
*/
|
||||
this.framebufferDimension = undefined;
|
||||
|
||||
/**
|
||||
* @protected
|
||||
* @type {module:ol/transform~Transform}
|
||||
*/
|
||||
this.texCoordMatrix = createTransform();
|
||||
|
||||
/**
|
||||
* @protected
|
||||
* @type {module:ol/transform~Transform}
|
||||
*/
|
||||
this.projectionMatrix = createTransform();
|
||||
|
||||
/**
|
||||
* @type {Array.<number>}
|
||||
* @private
|
||||
*/
|
||||
this.tmpMat4_ = create();
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/renderer/webgl/defaultmapshader/Locations}
|
||||
*/
|
||||
this.defaultLocations_ = null;
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @param {number} framebufferDimension Framebuffer dimension.
|
||||
* @protected
|
||||
* @type {module:ol/renderer/webgl/Map}
|
||||
*/
|
||||
this.mapRenderer = mapRenderer;
|
||||
bindFramebuffer(frameState, framebufferDimension) {
|
||||
|
||||
const gl = this.mapRenderer.getGL();
|
||||
|
||||
if (this.framebufferDimension === undefined ||
|
||||
this.framebufferDimension != framebufferDimension) {
|
||||
/**
|
||||
* @param {WebGLRenderingContext} gl GL.
|
||||
* @param {WebGLFramebuffer} framebuffer Framebuffer.
|
||||
* @param {WebGLTexture} texture Texture.
|
||||
*/
|
||||
const postRenderFunction = function(gl, framebuffer, texture) {
|
||||
if (!gl.isContextLost()) {
|
||||
gl.deleteFramebuffer(framebuffer);
|
||||
gl.deleteTexture(texture);
|
||||
}
|
||||
}.bind(null, gl, this.framebuffer, this.texture);
|
||||
|
||||
frameState.postRenderFunctions.push(
|
||||
/** @type {module:ol/PluggableMap~PostRenderFunction} */ (postRenderFunction)
|
||||
);
|
||||
|
||||
const texture = createEmptyTexture(
|
||||
gl, framebufferDimension, framebufferDimension);
|
||||
|
||||
const framebuffer = gl.createFramebuffer();
|
||||
gl.bindFramebuffer(FRAMEBUFFER, framebuffer);
|
||||
gl.framebufferTexture2D(FRAMEBUFFER,
|
||||
COLOR_ATTACHMENT0, TEXTURE_2D, texture, 0);
|
||||
|
||||
this.texture = texture;
|
||||
this.framebuffer = framebuffer;
|
||||
this.framebufferDimension = framebufferDimension;
|
||||
|
||||
} else {
|
||||
gl.bindFramebuffer(FRAMEBUFFER, this.framebuffer);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/webgl/Buffer}
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @param {module:ol/layer/Layer~State} layerState Layer state.
|
||||
* @param {module:ol/webgl/Context} context Context.
|
||||
*/
|
||||
this.arrayBuffer_ = new WebGLBuffer([
|
||||
-1, -1, 0, 0,
|
||||
1, -1, 1, 0,
|
||||
-1, 1, 0, 1,
|
||||
1, 1, 1, 1
|
||||
]);
|
||||
composeFrame(frameState, layerState, context) {
|
||||
|
||||
this.dispatchComposeEvent_(RenderEventType.PRECOMPOSE, context, frameState);
|
||||
|
||||
context.bindBuffer(ARRAY_BUFFER, this.arrayBuffer_);
|
||||
|
||||
const gl = context.getGL();
|
||||
|
||||
const program = context.getProgram(fragment, vertex);
|
||||
|
||||
let locations;
|
||||
if (!this.defaultLocations_) {
|
||||
locations = new Locations(gl, program);
|
||||
this.defaultLocations_ = locations;
|
||||
} else {
|
||||
locations = this.defaultLocations_;
|
||||
}
|
||||
|
||||
if (context.useProgram(program)) {
|
||||
gl.enableVertexAttribArray(locations.a_position);
|
||||
gl.vertexAttribPointer(
|
||||
locations.a_position, 2, FLOAT, false, 16, 0);
|
||||
gl.enableVertexAttribArray(locations.a_texCoord);
|
||||
gl.vertexAttribPointer(
|
||||
locations.a_texCoord, 2, FLOAT, false, 16, 8);
|
||||
gl.uniform1i(locations.u_texture, 0);
|
||||
}
|
||||
|
||||
gl.uniformMatrix4fv(locations.u_texCoordMatrix, false,
|
||||
fromTransform(this.tmpMat4_, this.getTexCoordMatrix()));
|
||||
gl.uniformMatrix4fv(locations.u_projectionMatrix, false,
|
||||
fromTransform(this.tmpMat4_, this.getProjectionMatrix()));
|
||||
gl.uniform1f(locations.u_opacity, layerState.opacity);
|
||||
gl.bindTexture(TEXTURE_2D, this.getTexture());
|
||||
gl.drawArrays(TRIANGLE_STRIP, 0, 4);
|
||||
|
||||
this.dispatchComposeEvent_(RenderEventType.POSTCOMPOSE, context, frameState);
|
||||
}
|
||||
|
||||
/**
|
||||
* @protected
|
||||
* @type {WebGLTexture}
|
||||
*/
|
||||
this.texture = null;
|
||||
|
||||
/**
|
||||
* @protected
|
||||
* @type {WebGLFramebuffer}
|
||||
*/
|
||||
this.framebuffer = null;
|
||||
|
||||
/**
|
||||
* @protected
|
||||
* @type {number|undefined}
|
||||
*/
|
||||
this.framebufferDimension = undefined;
|
||||
|
||||
/**
|
||||
* @protected
|
||||
* @type {module:ol/transform~Transform}
|
||||
*/
|
||||
this.texCoordMatrix = createTransform();
|
||||
|
||||
/**
|
||||
* @protected
|
||||
* @type {module:ol/transform~Transform}
|
||||
*/
|
||||
this.projectionMatrix = createTransform();
|
||||
|
||||
/**
|
||||
* @type {Array.<number>}
|
||||
* @param {module:ol/render/EventType} type Event type.
|
||||
* @param {module:ol/webgl/Context} context WebGL context.
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @private
|
||||
*/
|
||||
this.tmpMat4_ = create();
|
||||
dispatchComposeEvent_(type, context, frameState) {
|
||||
const layer = this.getLayer();
|
||||
if (layer.hasListener(type)) {
|
||||
const viewState = frameState.viewState;
|
||||
const resolution = viewState.resolution;
|
||||
const pixelRatio = frameState.pixelRatio;
|
||||
const extent = frameState.extent;
|
||||
const center = viewState.center;
|
||||
const rotation = viewState.rotation;
|
||||
const size = frameState.size;
|
||||
|
||||
const render = new WebGLImmediateRenderer(
|
||||
context, center, resolution, rotation, size, extent, pixelRatio);
|
||||
const composeEvent = new RenderEvent(
|
||||
type, render, frameState, null, context);
|
||||
layer.dispatchEvent(composeEvent);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/renderer/webgl/defaultmapshader/Locations}
|
||||
* @return {!module:ol/transform~Transform} Matrix.
|
||||
*/
|
||||
this.defaultLocations_ = null;
|
||||
getTexCoordMatrix() {
|
||||
return this.texCoordMatrix;
|
||||
}
|
||||
|
||||
};
|
||||
/**
|
||||
* @return {WebGLTexture} Texture.
|
||||
*/
|
||||
getTexture() {
|
||||
return this.texture;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return {!module:ol/transform~Transform} Matrix.
|
||||
*/
|
||||
getProjectionMatrix() {
|
||||
return this.projectionMatrix;
|
||||
}
|
||||
|
||||
/**
|
||||
* Handle webglcontextlost.
|
||||
*/
|
||||
handleWebGLContextLost() {
|
||||
this.texture = null;
|
||||
this.framebuffer = null;
|
||||
this.framebufferDimension = undefined;
|
||||
}
|
||||
|
||||
/**
|
||||
* @abstract
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @param {module:ol/layer/Layer~State} layerState Layer state.
|
||||
* @param {module:ol/webgl/Context} context Context.
|
||||
* @return {boolean} whether composeFrame should be called.
|
||||
*/
|
||||
prepareFrame(frameState, layerState, context) {}
|
||||
|
||||
/**
|
||||
* @abstract
|
||||
* @param {module:ol~Pixel} pixel Pixel.
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState FrameState.
|
||||
* @param {function(this: S, module:ol/layer/Layer, (Uint8ClampedArray|Uint8Array)): T} callback Layer
|
||||
* callback.
|
||||
* @param {S} thisArg Value to use as `this` when executing `callback`.
|
||||
* @return {T|undefined} Callback result.
|
||||
* @template S,T,U
|
||||
*/
|
||||
forEachLayerAtPixel(pixel, frameState, callback, thisArg) {}
|
||||
}
|
||||
|
||||
inherits(WebGLLayerRenderer, LayerRenderer);
|
||||
|
||||
|
||||
/**
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @param {number} framebufferDimension Framebuffer dimension.
|
||||
* @protected
|
||||
*/
|
||||
WebGLLayerRenderer.prototype.bindFramebuffer = function(frameState, framebufferDimension) {
|
||||
|
||||
const gl = this.mapRenderer.getGL();
|
||||
|
||||
if (this.framebufferDimension === undefined ||
|
||||
this.framebufferDimension != framebufferDimension) {
|
||||
/**
|
||||
* @param {WebGLRenderingContext} gl GL.
|
||||
* @param {WebGLFramebuffer} framebuffer Framebuffer.
|
||||
* @param {WebGLTexture} texture Texture.
|
||||
*/
|
||||
const postRenderFunction = function(gl, framebuffer, texture) {
|
||||
if (!gl.isContextLost()) {
|
||||
gl.deleteFramebuffer(framebuffer);
|
||||
gl.deleteTexture(texture);
|
||||
}
|
||||
}.bind(null, gl, this.framebuffer, this.texture);
|
||||
|
||||
frameState.postRenderFunctions.push(
|
||||
/** @type {module:ol/PluggableMap~PostRenderFunction} */ (postRenderFunction)
|
||||
);
|
||||
|
||||
const texture = createEmptyTexture(
|
||||
gl, framebufferDimension, framebufferDimension);
|
||||
|
||||
const framebuffer = gl.createFramebuffer();
|
||||
gl.bindFramebuffer(FRAMEBUFFER, framebuffer);
|
||||
gl.framebufferTexture2D(FRAMEBUFFER,
|
||||
COLOR_ATTACHMENT0, TEXTURE_2D, texture, 0);
|
||||
|
||||
this.texture = texture;
|
||||
this.framebuffer = framebuffer;
|
||||
this.framebufferDimension = framebufferDimension;
|
||||
|
||||
} else {
|
||||
gl.bindFramebuffer(FRAMEBUFFER, this.framebuffer);
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @param {module:ol/layer/Layer~State} layerState Layer state.
|
||||
* @param {module:ol/webgl/Context} context Context.
|
||||
*/
|
||||
WebGLLayerRenderer.prototype.composeFrame = function(frameState, layerState, context) {
|
||||
|
||||
this.dispatchComposeEvent_(RenderEventType.PRECOMPOSE, context, frameState);
|
||||
|
||||
context.bindBuffer(ARRAY_BUFFER, this.arrayBuffer_);
|
||||
|
||||
const gl = context.getGL();
|
||||
|
||||
const program = context.getProgram(fragment, vertex);
|
||||
|
||||
let locations;
|
||||
if (!this.defaultLocations_) {
|
||||
locations = new Locations(gl, program);
|
||||
this.defaultLocations_ = locations;
|
||||
} else {
|
||||
locations = this.defaultLocations_;
|
||||
}
|
||||
|
||||
if (context.useProgram(program)) {
|
||||
gl.enableVertexAttribArray(locations.a_position);
|
||||
gl.vertexAttribPointer(
|
||||
locations.a_position, 2, FLOAT, false, 16, 0);
|
||||
gl.enableVertexAttribArray(locations.a_texCoord);
|
||||
gl.vertexAttribPointer(
|
||||
locations.a_texCoord, 2, FLOAT, false, 16, 8);
|
||||
gl.uniform1i(locations.u_texture, 0);
|
||||
}
|
||||
|
||||
gl.uniformMatrix4fv(locations.u_texCoordMatrix, false,
|
||||
fromTransform(this.tmpMat4_, this.getTexCoordMatrix()));
|
||||
gl.uniformMatrix4fv(locations.u_projectionMatrix, false,
|
||||
fromTransform(this.tmpMat4_, this.getProjectionMatrix()));
|
||||
gl.uniform1f(locations.u_opacity, layerState.opacity);
|
||||
gl.bindTexture(TEXTURE_2D, this.getTexture());
|
||||
gl.drawArrays(TRIANGLE_STRIP, 0, 4);
|
||||
|
||||
this.dispatchComposeEvent_(RenderEventType.POSTCOMPOSE, context, frameState);
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {module:ol/render/EventType} type Event type.
|
||||
* @param {module:ol/webgl/Context} context WebGL context.
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @private
|
||||
*/
|
||||
WebGLLayerRenderer.prototype.dispatchComposeEvent_ = function(type, context, frameState) {
|
||||
const layer = this.getLayer();
|
||||
if (layer.hasListener(type)) {
|
||||
const viewState = frameState.viewState;
|
||||
const resolution = viewState.resolution;
|
||||
const pixelRatio = frameState.pixelRatio;
|
||||
const extent = frameState.extent;
|
||||
const center = viewState.center;
|
||||
const rotation = viewState.rotation;
|
||||
const size = frameState.size;
|
||||
|
||||
const render = new WebGLImmediateRenderer(
|
||||
context, center, resolution, rotation, size, extent, pixelRatio);
|
||||
const composeEvent = new RenderEvent(
|
||||
type, render, frameState, null, context);
|
||||
layer.dispatchEvent(composeEvent);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @return {!module:ol/transform~Transform} Matrix.
|
||||
*/
|
||||
WebGLLayerRenderer.prototype.getTexCoordMatrix = function() {
|
||||
return this.texCoordMatrix;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @return {WebGLTexture} Texture.
|
||||
*/
|
||||
WebGLLayerRenderer.prototype.getTexture = function() {
|
||||
return this.texture;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @return {!module:ol/transform~Transform} Matrix.
|
||||
*/
|
||||
WebGLLayerRenderer.prototype.getProjectionMatrix = function() {
|
||||
return this.projectionMatrix;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* Handle webglcontextlost.
|
||||
*/
|
||||
WebGLLayerRenderer.prototype.handleWebGLContextLost = function() {
|
||||
this.texture = null;
|
||||
this.framebuffer = null;
|
||||
this.framebufferDimension = undefined;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @abstract
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState Frame state.
|
||||
* @param {module:ol/layer/Layer~State} layerState Layer state.
|
||||
* @param {module:ol/webgl/Context} context Context.
|
||||
* @return {boolean} whether composeFrame should be called.
|
||||
*/
|
||||
WebGLLayerRenderer.prototype.prepareFrame = function(frameState, layerState, context) {};
|
||||
|
||||
|
||||
/**
|
||||
* @abstract
|
||||
* @param {module:ol~Pixel} pixel Pixel.
|
||||
* @param {module:ol/PluggableMap~FrameState} frameState FrameState.
|
||||
* @param {function(this: S, module:ol/layer/Layer, (Uint8ClampedArray|Uint8Array)): T} callback Layer
|
||||
* callback.
|
||||
* @param {S} thisArg Value to use as `this` when executing `callback`.
|
||||
* @return {T|undefined} Callback result.
|
||||
* @template S,T,U
|
||||
*/
|
||||
WebGLLayerRenderer.prototype.forEachLayerAtPixel = function(pixel, frameState, callback, thisArg) {};
|
||||
export default WebGLLayerRenderer;
|
||||
|
||||
+512
-518
File diff suppressed because it is too large
Load Diff
+329
-330
@@ -32,64 +32,355 @@ import WebGLBuffer from '../../webgl/Buffer.js';
|
||||
* @param {module:ol/layer/Tile} tileLayer Tile layer.
|
||||
* @api
|
||||
*/
|
||||
const WebGLTileLayerRenderer = function(mapRenderer, tileLayer) {
|
||||
class WebGLTileLayerRenderer {
|
||||
constructor(mapRenderer, tileLayer) {
|
||||
|
||||
WebGLLayerRenderer.call(this, mapRenderer, tileLayer);
|
||||
WebGLLayerRenderer.call(this, mapRenderer, tileLayer);
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/webgl/Fragment}
|
||||
*/
|
||||
this.fragmentShader_ = fragment;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/webgl/Vertex}
|
||||
*/
|
||||
this.vertexShader_ = vertex;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/renderer/webgl/tilelayershader/Locations}
|
||||
*/
|
||||
this.locations_ = null;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/webgl/Buffer}
|
||||
*/
|
||||
this.renderArrayBuffer_ = new WebGLBuffer([
|
||||
0, 0, 0, 1,
|
||||
1, 0, 1, 1,
|
||||
0, 1, 0, 0,
|
||||
1, 1, 1, 0
|
||||
]);
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/TileRange}
|
||||
*/
|
||||
this.renderedTileRange_ = null;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/extent~Extent}
|
||||
*/
|
||||
this.renderedFramebufferExtent_ = null;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {number}
|
||||
*/
|
||||
this.renderedRevision_ = -1;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/size~Size}
|
||||
*/
|
||||
this.tmpSize_ = [0, 0];
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/webgl/Fragment}
|
||||
* @inheritDoc
|
||||
*/
|
||||
this.fragmentShader_ = fragment;
|
||||
disposeInternal() {
|
||||
const context = this.mapRenderer.getContext();
|
||||
context.deleteBuffer(this.renderArrayBuffer_);
|
||||
WebGLLayerRenderer.prototype.disposeInternal.call(this);
|
||||
}
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/webgl/Vertex}
|
||||
* @inheritDoc
|
||||
*/
|
||||
this.vertexShader_ = vertex;
|
||||
createLoadedTileFinder(source, projection, tiles) {
|
||||
const mapRenderer = this.mapRenderer;
|
||||
|
||||
return (
|
||||
/**
|
||||
* @param {number} zoom Zoom level.
|
||||
* @param {module:ol/TileRange} tileRange Tile range.
|
||||
* @return {boolean} The tile range is fully loaded.
|
||||
*/
|
||||
function(zoom, tileRange) {
|
||||
function callback(tile) {
|
||||
const loaded = mapRenderer.isTileTextureLoaded(tile);
|
||||
if (loaded) {
|
||||
if (!tiles[zoom]) {
|
||||
tiles[zoom] = {};
|
||||
}
|
||||
tiles[zoom][tile.tileCoord.toString()] = tile;
|
||||
}
|
||||
return loaded;
|
||||
}
|
||||
return source.forEachLoadedTile(projection, zoom, tileRange, callback);
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/renderer/webgl/tilelayershader/Locations}
|
||||
* @inheritDoc
|
||||
*/
|
||||
this.locations_ = null;
|
||||
handleWebGLContextLost() {
|
||||
WebGLLayerRenderer.prototype.handleWebGLContextLost.call(this);
|
||||
this.locations_ = null;
|
||||
}
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/webgl/Buffer}
|
||||
* @inheritDoc
|
||||
*/
|
||||
this.renderArrayBuffer_ = new WebGLBuffer([
|
||||
0, 0, 0, 1,
|
||||
1, 0, 1, 1,
|
||||
0, 1, 0, 0,
|
||||
1, 1, 1, 0
|
||||
]);
|
||||
prepareFrame(frameState, layerState, context) {
|
||||
|
||||
const mapRenderer = this.mapRenderer;
|
||||
const gl = context.getGL();
|
||||
|
||||
const viewState = frameState.viewState;
|
||||
const projection = viewState.projection;
|
||||
|
||||
const tileLayer = /** @type {module:ol/layer/Tile} */ (this.getLayer());
|
||||
const tileSource = tileLayer.getSource();
|
||||
const tileGrid = tileSource.getTileGridForProjection(projection);
|
||||
const z = tileGrid.getZForResolution(viewState.resolution);
|
||||
const tileResolution = tileGrid.getResolution(z);
|
||||
|
||||
const tilePixelSize =
|
||||
tileSource.getTilePixelSize(z, frameState.pixelRatio, projection);
|
||||
const pixelRatio = tilePixelSize[0] /
|
||||
toSize(tileGrid.getTileSize(z), this.tmpSize_)[0];
|
||||
const tilePixelResolution = tileResolution / pixelRatio;
|
||||
const tileGutter = tileSource.getTilePixelRatio(pixelRatio) * tileSource.getGutter(projection);
|
||||
|
||||
const center = viewState.center;
|
||||
const extent = frameState.extent;
|
||||
const tileRange = tileGrid.getTileRangeForExtentAndZ(extent, z);
|
||||
|
||||
let framebufferExtent;
|
||||
if (this.renderedTileRange_ &&
|
||||
this.renderedTileRange_.equals(tileRange) &&
|
||||
this.renderedRevision_ == tileSource.getRevision()) {
|
||||
framebufferExtent = this.renderedFramebufferExtent_;
|
||||
} else {
|
||||
|
||||
const tileRangeSize = tileRange.getSize();
|
||||
|
||||
const maxDimension = Math.max(
|
||||
tileRangeSize[0] * tilePixelSize[0],
|
||||
tileRangeSize[1] * tilePixelSize[1]);
|
||||
const framebufferDimension = roundUpToPowerOfTwo(maxDimension);
|
||||
const framebufferExtentDimension = tilePixelResolution * framebufferDimension;
|
||||
const origin = tileGrid.getOrigin(z);
|
||||
const minX = origin[0] +
|
||||
tileRange.minX * tilePixelSize[0] * tilePixelResolution;
|
||||
const minY = origin[1] +
|
||||
tileRange.minY * tilePixelSize[1] * tilePixelResolution;
|
||||
framebufferExtent = [
|
||||
minX, minY,
|
||||
minX + framebufferExtentDimension, minY + framebufferExtentDimension
|
||||
];
|
||||
|
||||
this.bindFramebuffer(frameState, framebufferDimension);
|
||||
gl.viewport(0, 0, framebufferDimension, framebufferDimension);
|
||||
|
||||
gl.clearColor(0, 0, 0, 0);
|
||||
gl.clear(COLOR_BUFFER_BIT);
|
||||
gl.disable(BLEND);
|
||||
|
||||
const program = context.getProgram(this.fragmentShader_, this.vertexShader_);
|
||||
context.useProgram(program);
|
||||
if (!this.locations_) {
|
||||
this.locations_ = new Locations(gl, program);
|
||||
}
|
||||
|
||||
context.bindBuffer(ARRAY_BUFFER, this.renderArrayBuffer_);
|
||||
gl.enableVertexAttribArray(this.locations_.a_position);
|
||||
gl.vertexAttribPointer(
|
||||
this.locations_.a_position, 2, FLOAT, false, 16, 0);
|
||||
gl.enableVertexAttribArray(this.locations_.a_texCoord);
|
||||
gl.vertexAttribPointer(
|
||||
this.locations_.a_texCoord, 2, FLOAT, false, 16, 8);
|
||||
gl.uniform1i(this.locations_.u_texture, 0);
|
||||
|
||||
/**
|
||||
* @type {Object.<number, Object.<string, module:ol/Tile>>}
|
||||
*/
|
||||
const tilesToDrawByZ = {};
|
||||
tilesToDrawByZ[z] = {};
|
||||
|
||||
const findLoadedTiles = this.createLoadedTileFinder(
|
||||
tileSource, projection, tilesToDrawByZ);
|
||||
|
||||
const useInterimTilesOnError = tileLayer.getUseInterimTilesOnError();
|
||||
let allTilesLoaded = true;
|
||||
const tmpExtent = createEmpty();
|
||||
const tmpTileRange = new TileRange(0, 0, 0, 0);
|
||||
let childTileRange, drawable, fullyLoaded, tile, tileState;
|
||||
let x, y, tileExtent;
|
||||
for (x = tileRange.minX; x <= tileRange.maxX; ++x) {
|
||||
for (y = tileRange.minY; y <= tileRange.maxY; ++y) {
|
||||
|
||||
tile = tileSource.getTile(z, x, y, pixelRatio, projection);
|
||||
if (layerState.extent !== undefined) {
|
||||
// ignore tiles outside layer extent
|
||||
tileExtent = tileGrid.getTileCoordExtent(tile.tileCoord, tmpExtent);
|
||||
if (!intersects(tileExtent, layerState.extent)) {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
tileState = tile.getState();
|
||||
drawable = tileState == TileState.LOADED ||
|
||||
tileState == TileState.EMPTY ||
|
||||
tileState == TileState.ERROR && !useInterimTilesOnError;
|
||||
if (!drawable) {
|
||||
tile = tile.getInterimTile();
|
||||
}
|
||||
tileState = tile.getState();
|
||||
if (tileState == TileState.LOADED) {
|
||||
if (mapRenderer.isTileTextureLoaded(tile)) {
|
||||
tilesToDrawByZ[z][tile.tileCoord.toString()] = tile;
|
||||
continue;
|
||||
}
|
||||
} else if (tileState == TileState.EMPTY ||
|
||||
(tileState == TileState.ERROR &&
|
||||
!useInterimTilesOnError)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
allTilesLoaded = false;
|
||||
fullyLoaded = tileGrid.forEachTileCoordParentTileRange(
|
||||
tile.tileCoord, findLoadedTiles, null, tmpTileRange, tmpExtent);
|
||||
if (!fullyLoaded) {
|
||||
childTileRange = tileGrid.getTileCoordChildTileRange(
|
||||
tile.tileCoord, tmpTileRange, tmpExtent);
|
||||
if (childTileRange) {
|
||||
findLoadedTiles(z + 1, childTileRange);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/** @type {Array.<number>} */
|
||||
const zs = Object.keys(tilesToDrawByZ).map(Number);
|
||||
zs.sort(numberSafeCompareFunction);
|
||||
const u_tileOffset = new Float32Array(4);
|
||||
for (let i = 0, ii = zs.length; i < ii; ++i) {
|
||||
const tilesToDraw = tilesToDrawByZ[zs[i]];
|
||||
for (const tileKey in tilesToDraw) {
|
||||
tile = tilesToDraw[tileKey];
|
||||
tileExtent = tileGrid.getTileCoordExtent(tile.tileCoord, tmpExtent);
|
||||
u_tileOffset[0] = 2 * (tileExtent[2] - tileExtent[0]) /
|
||||
framebufferExtentDimension;
|
||||
u_tileOffset[1] = 2 * (tileExtent[3] - tileExtent[1]) /
|
||||
framebufferExtentDimension;
|
||||
u_tileOffset[2] = 2 * (tileExtent[0] - framebufferExtent[0]) /
|
||||
framebufferExtentDimension - 1;
|
||||
u_tileOffset[3] = 2 * (tileExtent[1] - framebufferExtent[1]) /
|
||||
framebufferExtentDimension - 1;
|
||||
gl.uniform4fv(this.locations_.u_tileOffset, u_tileOffset);
|
||||
mapRenderer.bindTileTexture(tile, tilePixelSize,
|
||||
tileGutter * pixelRatio, LINEAR, LINEAR);
|
||||
gl.drawArrays(TRIANGLE_STRIP, 0, 4);
|
||||
}
|
||||
}
|
||||
|
||||
if (allTilesLoaded) {
|
||||
this.renderedTileRange_ = tileRange;
|
||||
this.renderedFramebufferExtent_ = framebufferExtent;
|
||||
this.renderedRevision_ = tileSource.getRevision();
|
||||
} else {
|
||||
this.renderedTileRange_ = null;
|
||||
this.renderedFramebufferExtent_ = null;
|
||||
this.renderedRevision_ = -1;
|
||||
frameState.animate = true;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
this.updateUsedTiles(frameState.usedTiles, tileSource, z, tileRange);
|
||||
const tileTextureQueue = mapRenderer.getTileTextureQueue();
|
||||
this.manageTilePyramid(
|
||||
frameState, tileSource, tileGrid, pixelRatio, projection, extent, z,
|
||||
tileLayer.getPreload(),
|
||||
/**
|
||||
* @param {module:ol/Tile} tile Tile.
|
||||
*/
|
||||
function(tile) {
|
||||
if (tile.getState() == TileState.LOADED &&
|
||||
!mapRenderer.isTileTextureLoaded(tile) &&
|
||||
!tileTextureQueue.isKeyQueued(tile.getKey())) {
|
||||
tileTextureQueue.enqueue([
|
||||
tile,
|
||||
tileGrid.getTileCoordCenter(tile.tileCoord),
|
||||
tileGrid.getResolution(tile.tileCoord[0]),
|
||||
tilePixelSize, tileGutter * pixelRatio
|
||||
]);
|
||||
}
|
||||
}, this);
|
||||
this.scheduleExpireCache(frameState, tileSource);
|
||||
|
||||
const texCoordMatrix = this.texCoordMatrix;
|
||||
resetTransform(texCoordMatrix);
|
||||
translateTransform(texCoordMatrix,
|
||||
(Math.round(center[0] / tileResolution) * tileResolution - framebufferExtent[0]) /
|
||||
(framebufferExtent[2] - framebufferExtent[0]),
|
||||
(Math.round(center[1] / tileResolution) * tileResolution - framebufferExtent[1]) /
|
||||
(framebufferExtent[3] - framebufferExtent[1]));
|
||||
if (viewState.rotation !== 0) {
|
||||
rotateTransform(texCoordMatrix, viewState.rotation);
|
||||
}
|
||||
scaleTransform(texCoordMatrix,
|
||||
frameState.size[0] * viewState.resolution /
|
||||
(framebufferExtent[2] - framebufferExtent[0]),
|
||||
frameState.size[1] * viewState.resolution /
|
||||
(framebufferExtent[3] - framebufferExtent[1]));
|
||||
translateTransform(texCoordMatrix, -0.5, -0.5);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/TileRange}
|
||||
* @inheritDoc
|
||||
*/
|
||||
this.renderedTileRange_ = null;
|
||||
forEachLayerAtPixel(pixel, frameState, callback, thisArg) {
|
||||
if (!this.framebuffer) {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/extent~Extent}
|
||||
*/
|
||||
this.renderedFramebufferExtent_ = null;
|
||||
const pixelOnMapScaled = [
|
||||
pixel[0] / frameState.size[0],
|
||||
(frameState.size[1] - pixel[1]) / frameState.size[1]];
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {number}
|
||||
*/
|
||||
this.renderedRevision_ = -1;
|
||||
const pixelOnFrameBufferScaled = applyTransform(
|
||||
this.texCoordMatrix, pixelOnMapScaled.slice());
|
||||
const pixelOnFrameBuffer = [
|
||||
pixelOnFrameBufferScaled[0] * this.framebufferDimension,
|
||||
pixelOnFrameBufferScaled[1] * this.framebufferDimension];
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/size~Size}
|
||||
*/
|
||||
this.tmpSize_ = [0, 0];
|
||||
const gl = this.mapRenderer.getContext().getGL();
|
||||
gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
|
||||
const imageData = new Uint8Array(4);
|
||||
gl.readPixels(pixelOnFrameBuffer[0], pixelOnFrameBuffer[1], 1, 1,
|
||||
gl.RGBA, gl.UNSIGNED_BYTE, imageData);
|
||||
|
||||
};
|
||||
if (imageData[3] > 0) {
|
||||
return callback.call(thisArg, this.getLayer(), imageData);
|
||||
} else {
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
inherits(WebGLTileLayerRenderer, WebGLLayerRenderer);
|
||||
|
||||
@@ -118,296 +409,4 @@ WebGLTileLayerRenderer['create'] = function(mapRenderer, layer) {
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
WebGLTileLayerRenderer.prototype.disposeInternal = function() {
|
||||
const context = this.mapRenderer.getContext();
|
||||
context.deleteBuffer(this.renderArrayBuffer_);
|
||||
WebGLLayerRenderer.prototype.disposeInternal.call(this);
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
WebGLTileLayerRenderer.prototype.createLoadedTileFinder = function(source, projection, tiles) {
|
||||
const mapRenderer = this.mapRenderer;
|
||||
|
||||
return (
|
||||
/**
|
||||
* @param {number} zoom Zoom level.
|
||||
* @param {module:ol/TileRange} tileRange Tile range.
|
||||
* @return {boolean} The tile range is fully loaded.
|
||||
*/
|
||||
function(zoom, tileRange) {
|
||||
function callback(tile) {
|
||||
const loaded = mapRenderer.isTileTextureLoaded(tile);
|
||||
if (loaded) {
|
||||
if (!tiles[zoom]) {
|
||||
tiles[zoom] = {};
|
||||
}
|
||||
tiles[zoom][tile.tileCoord.toString()] = tile;
|
||||
}
|
||||
return loaded;
|
||||
}
|
||||
return source.forEachLoadedTile(projection, zoom, tileRange, callback);
|
||||
}
|
||||
);
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
WebGLTileLayerRenderer.prototype.handleWebGLContextLost = function() {
|
||||
WebGLLayerRenderer.prototype.handleWebGLContextLost.call(this);
|
||||
this.locations_ = null;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
WebGLTileLayerRenderer.prototype.prepareFrame = function(frameState, layerState, context) {
|
||||
|
||||
const mapRenderer = this.mapRenderer;
|
||||
const gl = context.getGL();
|
||||
|
||||
const viewState = frameState.viewState;
|
||||
const projection = viewState.projection;
|
||||
|
||||
const tileLayer = /** @type {module:ol/layer/Tile} */ (this.getLayer());
|
||||
const tileSource = tileLayer.getSource();
|
||||
const tileGrid = tileSource.getTileGridForProjection(projection);
|
||||
const z = tileGrid.getZForResolution(viewState.resolution);
|
||||
const tileResolution = tileGrid.getResolution(z);
|
||||
|
||||
const tilePixelSize =
|
||||
tileSource.getTilePixelSize(z, frameState.pixelRatio, projection);
|
||||
const pixelRatio = tilePixelSize[0] /
|
||||
toSize(tileGrid.getTileSize(z), this.tmpSize_)[0];
|
||||
const tilePixelResolution = tileResolution / pixelRatio;
|
||||
const tileGutter = tileSource.getTilePixelRatio(pixelRatio) * tileSource.getGutter(projection);
|
||||
|
||||
const center = viewState.center;
|
||||
const extent = frameState.extent;
|
||||
const tileRange = tileGrid.getTileRangeForExtentAndZ(extent, z);
|
||||
|
||||
let framebufferExtent;
|
||||
if (this.renderedTileRange_ &&
|
||||
this.renderedTileRange_.equals(tileRange) &&
|
||||
this.renderedRevision_ == tileSource.getRevision()) {
|
||||
framebufferExtent = this.renderedFramebufferExtent_;
|
||||
} else {
|
||||
|
||||
const tileRangeSize = tileRange.getSize();
|
||||
|
||||
const maxDimension = Math.max(
|
||||
tileRangeSize[0] * tilePixelSize[0],
|
||||
tileRangeSize[1] * tilePixelSize[1]);
|
||||
const framebufferDimension = roundUpToPowerOfTwo(maxDimension);
|
||||
const framebufferExtentDimension = tilePixelResolution * framebufferDimension;
|
||||
const origin = tileGrid.getOrigin(z);
|
||||
const minX = origin[0] +
|
||||
tileRange.minX * tilePixelSize[0] * tilePixelResolution;
|
||||
const minY = origin[1] +
|
||||
tileRange.minY * tilePixelSize[1] * tilePixelResolution;
|
||||
framebufferExtent = [
|
||||
minX, minY,
|
||||
minX + framebufferExtentDimension, minY + framebufferExtentDimension
|
||||
];
|
||||
|
||||
this.bindFramebuffer(frameState, framebufferDimension);
|
||||
gl.viewport(0, 0, framebufferDimension, framebufferDimension);
|
||||
|
||||
gl.clearColor(0, 0, 0, 0);
|
||||
gl.clear(COLOR_BUFFER_BIT);
|
||||
gl.disable(BLEND);
|
||||
|
||||
const program = context.getProgram(this.fragmentShader_, this.vertexShader_);
|
||||
context.useProgram(program);
|
||||
if (!this.locations_) {
|
||||
this.locations_ = new Locations(gl, program);
|
||||
}
|
||||
|
||||
context.bindBuffer(ARRAY_BUFFER, this.renderArrayBuffer_);
|
||||
gl.enableVertexAttribArray(this.locations_.a_position);
|
||||
gl.vertexAttribPointer(
|
||||
this.locations_.a_position, 2, FLOAT, false, 16, 0);
|
||||
gl.enableVertexAttribArray(this.locations_.a_texCoord);
|
||||
gl.vertexAttribPointer(
|
||||
this.locations_.a_texCoord, 2, FLOAT, false, 16, 8);
|
||||
gl.uniform1i(this.locations_.u_texture, 0);
|
||||
|
||||
/**
|
||||
* @type {Object.<number, Object.<string, module:ol/Tile>>}
|
||||
*/
|
||||
const tilesToDrawByZ = {};
|
||||
tilesToDrawByZ[z] = {};
|
||||
|
||||
const findLoadedTiles = this.createLoadedTileFinder(
|
||||
tileSource, projection, tilesToDrawByZ);
|
||||
|
||||
const useInterimTilesOnError = tileLayer.getUseInterimTilesOnError();
|
||||
let allTilesLoaded = true;
|
||||
const tmpExtent = createEmpty();
|
||||
const tmpTileRange = new TileRange(0, 0, 0, 0);
|
||||
let childTileRange, drawable, fullyLoaded, tile, tileState;
|
||||
let x, y, tileExtent;
|
||||
for (x = tileRange.minX; x <= tileRange.maxX; ++x) {
|
||||
for (y = tileRange.minY; y <= tileRange.maxY; ++y) {
|
||||
|
||||
tile = tileSource.getTile(z, x, y, pixelRatio, projection);
|
||||
if (layerState.extent !== undefined) {
|
||||
// ignore tiles outside layer extent
|
||||
tileExtent = tileGrid.getTileCoordExtent(tile.tileCoord, tmpExtent);
|
||||
if (!intersects(tileExtent, layerState.extent)) {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
tileState = tile.getState();
|
||||
drawable = tileState == TileState.LOADED ||
|
||||
tileState == TileState.EMPTY ||
|
||||
tileState == TileState.ERROR && !useInterimTilesOnError;
|
||||
if (!drawable) {
|
||||
tile = tile.getInterimTile();
|
||||
}
|
||||
tileState = tile.getState();
|
||||
if (tileState == TileState.LOADED) {
|
||||
if (mapRenderer.isTileTextureLoaded(tile)) {
|
||||
tilesToDrawByZ[z][tile.tileCoord.toString()] = tile;
|
||||
continue;
|
||||
}
|
||||
} else if (tileState == TileState.EMPTY ||
|
||||
(tileState == TileState.ERROR &&
|
||||
!useInterimTilesOnError)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
allTilesLoaded = false;
|
||||
fullyLoaded = tileGrid.forEachTileCoordParentTileRange(
|
||||
tile.tileCoord, findLoadedTiles, null, tmpTileRange, tmpExtent);
|
||||
if (!fullyLoaded) {
|
||||
childTileRange = tileGrid.getTileCoordChildTileRange(
|
||||
tile.tileCoord, tmpTileRange, tmpExtent);
|
||||
if (childTileRange) {
|
||||
findLoadedTiles(z + 1, childTileRange);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/** @type {Array.<number>} */
|
||||
const zs = Object.keys(tilesToDrawByZ).map(Number);
|
||||
zs.sort(numberSafeCompareFunction);
|
||||
const u_tileOffset = new Float32Array(4);
|
||||
for (let i = 0, ii = zs.length; i < ii; ++i) {
|
||||
const tilesToDraw = tilesToDrawByZ[zs[i]];
|
||||
for (const tileKey in tilesToDraw) {
|
||||
tile = tilesToDraw[tileKey];
|
||||
tileExtent = tileGrid.getTileCoordExtent(tile.tileCoord, tmpExtent);
|
||||
u_tileOffset[0] = 2 * (tileExtent[2] - tileExtent[0]) /
|
||||
framebufferExtentDimension;
|
||||
u_tileOffset[1] = 2 * (tileExtent[3] - tileExtent[1]) /
|
||||
framebufferExtentDimension;
|
||||
u_tileOffset[2] = 2 * (tileExtent[0] - framebufferExtent[0]) /
|
||||
framebufferExtentDimension - 1;
|
||||
u_tileOffset[3] = 2 * (tileExtent[1] - framebufferExtent[1]) /
|
||||
framebufferExtentDimension - 1;
|
||||
gl.uniform4fv(this.locations_.u_tileOffset, u_tileOffset);
|
||||
mapRenderer.bindTileTexture(tile, tilePixelSize,
|
||||
tileGutter * pixelRatio, LINEAR, LINEAR);
|
||||
gl.drawArrays(TRIANGLE_STRIP, 0, 4);
|
||||
}
|
||||
}
|
||||
|
||||
if (allTilesLoaded) {
|
||||
this.renderedTileRange_ = tileRange;
|
||||
this.renderedFramebufferExtent_ = framebufferExtent;
|
||||
this.renderedRevision_ = tileSource.getRevision();
|
||||
} else {
|
||||
this.renderedTileRange_ = null;
|
||||
this.renderedFramebufferExtent_ = null;
|
||||
this.renderedRevision_ = -1;
|
||||
frameState.animate = true;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
this.updateUsedTiles(frameState.usedTiles, tileSource, z, tileRange);
|
||||
const tileTextureQueue = mapRenderer.getTileTextureQueue();
|
||||
this.manageTilePyramid(
|
||||
frameState, tileSource, tileGrid, pixelRatio, projection, extent, z,
|
||||
tileLayer.getPreload(),
|
||||
/**
|
||||
* @param {module:ol/Tile} tile Tile.
|
||||
*/
|
||||
function(tile) {
|
||||
if (tile.getState() == TileState.LOADED &&
|
||||
!mapRenderer.isTileTextureLoaded(tile) &&
|
||||
!tileTextureQueue.isKeyQueued(tile.getKey())) {
|
||||
tileTextureQueue.enqueue([
|
||||
tile,
|
||||
tileGrid.getTileCoordCenter(tile.tileCoord),
|
||||
tileGrid.getResolution(tile.tileCoord[0]),
|
||||
tilePixelSize, tileGutter * pixelRatio
|
||||
]);
|
||||
}
|
||||
}, this);
|
||||
this.scheduleExpireCache(frameState, tileSource);
|
||||
|
||||
const texCoordMatrix = this.texCoordMatrix;
|
||||
resetTransform(texCoordMatrix);
|
||||
translateTransform(texCoordMatrix,
|
||||
(Math.round(center[0] / tileResolution) * tileResolution - framebufferExtent[0]) /
|
||||
(framebufferExtent[2] - framebufferExtent[0]),
|
||||
(Math.round(center[1] / tileResolution) * tileResolution - framebufferExtent[1]) /
|
||||
(framebufferExtent[3] - framebufferExtent[1]));
|
||||
if (viewState.rotation !== 0) {
|
||||
rotateTransform(texCoordMatrix, viewState.rotation);
|
||||
}
|
||||
scaleTransform(texCoordMatrix,
|
||||
frameState.size[0] * viewState.resolution /
|
||||
(framebufferExtent[2] - framebufferExtent[0]),
|
||||
frameState.size[1] * viewState.resolution /
|
||||
(framebufferExtent[3] - framebufferExtent[1]));
|
||||
translateTransform(texCoordMatrix, -0.5, -0.5);
|
||||
|
||||
return true;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
WebGLTileLayerRenderer.prototype.forEachLayerAtPixel = function(pixel, frameState, callback, thisArg) {
|
||||
if (!this.framebuffer) {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
const pixelOnMapScaled = [
|
||||
pixel[0] / frameState.size[0],
|
||||
(frameState.size[1] - pixel[1]) / frameState.size[1]];
|
||||
|
||||
const pixelOnFrameBufferScaled = applyTransform(
|
||||
this.texCoordMatrix, pixelOnMapScaled.slice());
|
||||
const pixelOnFrameBuffer = [
|
||||
pixelOnFrameBufferScaled[0] * this.framebufferDimension,
|
||||
pixelOnFrameBufferScaled[1] * this.framebufferDimension];
|
||||
|
||||
const gl = this.mapRenderer.getContext().getGL();
|
||||
gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
|
||||
const imageData = new Uint8Array(4);
|
||||
gl.readPixels(pixelOnFrameBuffer[0], pixelOnFrameBuffer[1], 1, 1,
|
||||
gl.RGBA, gl.UNSIGNED_BYTE, imageData);
|
||||
|
||||
if (imageData[3] > 0) {
|
||||
return callback.call(thisArg, this.getLayer(), imageData);
|
||||
} else {
|
||||
return undefined;
|
||||
}
|
||||
};
|
||||
export default WebGLTileLayerRenderer;
|
||||
|
||||
@@ -17,54 +17,287 @@ import {apply as applyTransform} from '../../transform.js';
|
||||
* @param {module:ol/layer/Vector} vectorLayer Vector layer.
|
||||
* @api
|
||||
*/
|
||||
const WebGLVectorLayerRenderer = function(mapRenderer, vectorLayer) {
|
||||
class WebGLVectorLayerRenderer {
|
||||
constructor(mapRenderer, vectorLayer) {
|
||||
|
||||
WebGLLayerRenderer.call(this, mapRenderer, vectorLayer);
|
||||
WebGLLayerRenderer.call(this, mapRenderer, vectorLayer);
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {boolean}
|
||||
*/
|
||||
this.dirty_ = false;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {number}
|
||||
*/
|
||||
this.renderedRevision_ = -1;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {number}
|
||||
*/
|
||||
this.renderedResolution_ = NaN;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/extent~Extent}
|
||||
*/
|
||||
this.renderedExtent_ = createEmpty();
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {function(module:ol/Feature, module:ol/Feature): number|null}
|
||||
*/
|
||||
this.renderedRenderOrder_ = null;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/render/webgl/ReplayGroup}
|
||||
*/
|
||||
this.replayGroup_ = null;
|
||||
|
||||
/**
|
||||
* The last layer state.
|
||||
* @private
|
||||
* @type {?module:ol/layer/Layer~State}
|
||||
*/
|
||||
this.layerState_ = null;
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {boolean}
|
||||
* @inheritDoc
|
||||
*/
|
||||
this.dirty_ = false;
|
||||
composeFrame(frameState, layerState, context) {
|
||||
this.layerState_ = layerState;
|
||||
const viewState = frameState.viewState;
|
||||
const replayGroup = this.replayGroup_;
|
||||
const size = frameState.size;
|
||||
const pixelRatio = frameState.pixelRatio;
|
||||
const gl = this.mapRenderer.getGL();
|
||||
if (replayGroup && !replayGroup.isEmpty()) {
|
||||
gl.enable(gl.SCISSOR_TEST);
|
||||
gl.scissor(0, 0, size[0] * pixelRatio, size[1] * pixelRatio);
|
||||
replayGroup.replay(context,
|
||||
viewState.center, viewState.resolution, viewState.rotation,
|
||||
size, pixelRatio, layerState.opacity,
|
||||
layerState.managed ? frameState.skippedFeatureUids : {});
|
||||
gl.disable(gl.SCISSOR_TEST);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {number}
|
||||
* @inheritDoc
|
||||
*/
|
||||
this.renderedRevision_ = -1;
|
||||
disposeInternal() {
|
||||
const replayGroup = this.replayGroup_;
|
||||
if (replayGroup) {
|
||||
const context = this.mapRenderer.getContext();
|
||||
replayGroup.getDeleteResourcesFunction(context)();
|
||||
this.replayGroup_ = null;
|
||||
}
|
||||
WebGLLayerRenderer.prototype.disposeInternal.call(this);
|
||||
}
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {number}
|
||||
* @inheritDoc
|
||||
*/
|
||||
this.renderedResolution_ = NaN;
|
||||
forEachFeatureAtCoordinate(coordinate, frameState, hitTolerance, callback, thisArg) {
|
||||
if (!this.replayGroup_ || !this.layerState_) {
|
||||
return undefined;
|
||||
} else {
|
||||
const context = this.mapRenderer.getContext();
|
||||
const viewState = frameState.viewState;
|
||||
const layer = this.getLayer();
|
||||
const layerState = this.layerState_;
|
||||
/** @type {!Object.<string, boolean>} */
|
||||
const features = {};
|
||||
return this.replayGroup_.forEachFeatureAtCoordinate(coordinate,
|
||||
context, viewState.center, viewState.resolution, viewState.rotation,
|
||||
frameState.size, frameState.pixelRatio, layerState.opacity,
|
||||
{},
|
||||
/**
|
||||
* @param {module:ol/Feature|module:ol/render/Feature} feature Feature.
|
||||
* @return {?} Callback result.
|
||||
*/
|
||||
function(feature) {
|
||||
const key = getUid(feature).toString();
|
||||
if (!(key in features)) {
|
||||
features[key] = true;
|
||||
return callback.call(thisArg, feature, layer);
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {module:ol/extent~Extent}
|
||||
* @inheritDoc
|
||||
*/
|
||||
this.renderedExtent_ = createEmpty();
|
||||
hasFeatureAtCoordinate(coordinate, frameState) {
|
||||
if (!this.replayGroup_ || !this.layerState_) {
|
||||
return false;
|
||||
} else {
|
||||
const context = this.mapRenderer.getContext();
|
||||
const viewState = frameState.viewState;
|
||||
const layerState = this.layerState_;
|
||||
return this.replayGroup_.hasFeatureAtCoordinate(coordinate,
|
||||
context, viewState.center, viewState.resolution, viewState.rotation,
|
||||
frameState.size, frameState.pixelRatio, layerState.opacity,
|
||||
frameState.skippedFeatureUids);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {function(module:ol/Feature, module:ol/Feature): number|null}
|
||||
* @inheritDoc
|
||||
*/
|
||||
this.renderedRenderOrder_ = null;
|
||||
forEachLayerAtPixel(pixel, frameState, callback, thisArg) {
|
||||
const coordinate = applyTransform(
|
||||
frameState.pixelToCoordinateTransform, pixel.slice());
|
||||
const hasFeature = this.hasFeatureAtCoordinate(coordinate, frameState);
|
||||
|
||||
if (hasFeature) {
|
||||
return callback.call(thisArg, this.getLayer(), null);
|
||||
} else {
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Handle changes in image style state.
|
||||
* @param {module:ol/events/Event} event Image style change event.
|
||||
* @private
|
||||
* @type {module:ol/render/webgl/ReplayGroup}
|
||||
*/
|
||||
this.replayGroup_ = null;
|
||||
handleStyleImageChange_(event) {
|
||||
this.renderIfReadyAndVisible();
|
||||
}
|
||||
|
||||
/**
|
||||
* The last layer state.
|
||||
* @private
|
||||
* @type {?module:ol/layer/Layer~State}
|
||||
* @inheritDoc
|
||||
*/
|
||||
this.layerState_ = null;
|
||||
prepareFrame(frameState, layerState, context) {
|
||||
const vectorLayer = /** @type {module:ol/layer/Vector} */ (this.getLayer());
|
||||
const vectorSource = vectorLayer.getSource();
|
||||
|
||||
};
|
||||
const animating = frameState.viewHints[ViewHint.ANIMATING];
|
||||
const interacting = frameState.viewHints[ViewHint.INTERACTING];
|
||||
const updateWhileAnimating = vectorLayer.getUpdateWhileAnimating();
|
||||
const updateWhileInteracting = vectorLayer.getUpdateWhileInteracting();
|
||||
|
||||
if (!this.dirty_ && (!updateWhileAnimating && animating) ||
|
||||
(!updateWhileInteracting && interacting)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
const frameStateExtent = frameState.extent;
|
||||
const viewState = frameState.viewState;
|
||||
const projection = viewState.projection;
|
||||
const resolution = viewState.resolution;
|
||||
const pixelRatio = frameState.pixelRatio;
|
||||
const vectorLayerRevision = vectorLayer.getRevision();
|
||||
const vectorLayerRenderBuffer = vectorLayer.getRenderBuffer();
|
||||
let vectorLayerRenderOrder = vectorLayer.getRenderOrder();
|
||||
|
||||
if (vectorLayerRenderOrder === undefined) {
|
||||
vectorLayerRenderOrder = defaultRenderOrder;
|
||||
}
|
||||
|
||||
const extent = buffer(frameStateExtent,
|
||||
vectorLayerRenderBuffer * resolution);
|
||||
|
||||
if (!this.dirty_ &&
|
||||
this.renderedResolution_ == resolution &&
|
||||
this.renderedRevision_ == vectorLayerRevision &&
|
||||
this.renderedRenderOrder_ == vectorLayerRenderOrder &&
|
||||
containsExtent(this.renderedExtent_, extent)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (this.replayGroup_) {
|
||||
frameState.postRenderFunctions.push(
|
||||
this.replayGroup_.getDeleteResourcesFunction(context));
|
||||
}
|
||||
|
||||
this.dirty_ = false;
|
||||
|
||||
const replayGroup = new WebGLReplayGroup(
|
||||
getRenderTolerance(resolution, pixelRatio),
|
||||
extent, vectorLayer.getRenderBuffer());
|
||||
vectorSource.loadFeatures(extent, resolution, projection);
|
||||
/**
|
||||
* @param {module:ol/Feature} feature Feature.
|
||||
* @this {module:ol/renderer/webgl/VectorLayer}
|
||||
*/
|
||||
const render = function(feature) {
|
||||
let styles;
|
||||
const styleFunction = feature.getStyleFunction() || vectorLayer.getStyleFunction();
|
||||
if (styleFunction) {
|
||||
styles = styleFunction(feature, resolution);
|
||||
}
|
||||
if (styles) {
|
||||
const dirty = this.renderFeature(
|
||||
feature, resolution, pixelRatio, styles, replayGroup);
|
||||
this.dirty_ = this.dirty_ || dirty;
|
||||
}
|
||||
};
|
||||
if (vectorLayerRenderOrder) {
|
||||
/** @type {Array.<module:ol/Feature>} */
|
||||
const features = [];
|
||||
vectorSource.forEachFeatureInExtent(extent,
|
||||
/**
|
||||
* @param {module:ol/Feature} feature Feature.
|
||||
*/
|
||||
function(feature) {
|
||||
features.push(feature);
|
||||
}, this);
|
||||
features.sort(vectorLayerRenderOrder);
|
||||
features.forEach(render.bind(this));
|
||||
} else {
|
||||
vectorSource.forEachFeatureInExtent(extent, render, this);
|
||||
}
|
||||
replayGroup.finish(context);
|
||||
|
||||
this.renderedResolution_ = resolution;
|
||||
this.renderedRevision_ = vectorLayerRevision;
|
||||
this.renderedRenderOrder_ = vectorLayerRenderOrder;
|
||||
this.renderedExtent_ = extent;
|
||||
this.replayGroup_ = replayGroup;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {module:ol/Feature} feature Feature.
|
||||
* @param {number} resolution Resolution.
|
||||
* @param {number} pixelRatio Pixel ratio.
|
||||
* @param {(module:ol/style/Style|Array.<module:ol/style/Style>)} styles The style or array of
|
||||
* styles.
|
||||
* @param {module:ol/render/webgl/ReplayGroup} replayGroup Replay group.
|
||||
* @return {boolean} `true` if an image is loading.
|
||||
*/
|
||||
renderFeature(feature, resolution, pixelRatio, styles, replayGroup) {
|
||||
if (!styles) {
|
||||
return false;
|
||||
}
|
||||
let loading = false;
|
||||
if (Array.isArray(styles)) {
|
||||
for (let i = styles.length - 1, ii = 0; i >= ii; --i) {
|
||||
loading = renderFeature(
|
||||
replayGroup, feature, styles[i],
|
||||
getSquaredRenderTolerance(resolution, pixelRatio),
|
||||
this.handleStyleImageChange_, this) || loading;
|
||||
}
|
||||
} else {
|
||||
loading = renderFeature(
|
||||
replayGroup, feature, styles,
|
||||
getSquaredRenderTolerance(resolution, pixelRatio),
|
||||
this.handleStyleImageChange_, this) || loading;
|
||||
}
|
||||
return loading;
|
||||
}
|
||||
}
|
||||
|
||||
inherits(WebGLVectorLayerRenderer, WebGLLayerRenderer);
|
||||
|
||||
@@ -93,241 +326,4 @@ WebGLVectorLayerRenderer['create'] = function(mapRenderer, layer) {
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
WebGLVectorLayerRenderer.prototype.composeFrame = function(frameState, layerState, context) {
|
||||
this.layerState_ = layerState;
|
||||
const viewState = frameState.viewState;
|
||||
const replayGroup = this.replayGroup_;
|
||||
const size = frameState.size;
|
||||
const pixelRatio = frameState.pixelRatio;
|
||||
const gl = this.mapRenderer.getGL();
|
||||
if (replayGroup && !replayGroup.isEmpty()) {
|
||||
gl.enable(gl.SCISSOR_TEST);
|
||||
gl.scissor(0, 0, size[0] * pixelRatio, size[1] * pixelRatio);
|
||||
replayGroup.replay(context,
|
||||
viewState.center, viewState.resolution, viewState.rotation,
|
||||
size, pixelRatio, layerState.opacity,
|
||||
layerState.managed ? frameState.skippedFeatureUids : {});
|
||||
gl.disable(gl.SCISSOR_TEST);
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
WebGLVectorLayerRenderer.prototype.disposeInternal = function() {
|
||||
const replayGroup = this.replayGroup_;
|
||||
if (replayGroup) {
|
||||
const context = this.mapRenderer.getContext();
|
||||
replayGroup.getDeleteResourcesFunction(context)();
|
||||
this.replayGroup_ = null;
|
||||
}
|
||||
WebGLLayerRenderer.prototype.disposeInternal.call(this);
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
WebGLVectorLayerRenderer.prototype.forEachFeatureAtCoordinate = function(coordinate, frameState, hitTolerance, callback, thisArg) {
|
||||
if (!this.replayGroup_ || !this.layerState_) {
|
||||
return undefined;
|
||||
} else {
|
||||
const context = this.mapRenderer.getContext();
|
||||
const viewState = frameState.viewState;
|
||||
const layer = this.getLayer();
|
||||
const layerState = this.layerState_;
|
||||
/** @type {!Object.<string, boolean>} */
|
||||
const features = {};
|
||||
return this.replayGroup_.forEachFeatureAtCoordinate(coordinate,
|
||||
context, viewState.center, viewState.resolution, viewState.rotation,
|
||||
frameState.size, frameState.pixelRatio, layerState.opacity,
|
||||
{},
|
||||
/**
|
||||
* @param {module:ol/Feature|module:ol/render/Feature} feature Feature.
|
||||
* @return {?} Callback result.
|
||||
*/
|
||||
function(feature) {
|
||||
const key = getUid(feature).toString();
|
||||
if (!(key in features)) {
|
||||
features[key] = true;
|
||||
return callback.call(thisArg, feature, layer);
|
||||
}
|
||||
});
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
WebGLVectorLayerRenderer.prototype.hasFeatureAtCoordinate = function(coordinate, frameState) {
|
||||
if (!this.replayGroup_ || !this.layerState_) {
|
||||
return false;
|
||||
} else {
|
||||
const context = this.mapRenderer.getContext();
|
||||
const viewState = frameState.viewState;
|
||||
const layerState = this.layerState_;
|
||||
return this.replayGroup_.hasFeatureAtCoordinate(coordinate,
|
||||
context, viewState.center, viewState.resolution, viewState.rotation,
|
||||
frameState.size, frameState.pixelRatio, layerState.opacity,
|
||||
frameState.skippedFeatureUids);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
WebGLVectorLayerRenderer.prototype.forEachLayerAtPixel = function(pixel, frameState, callback, thisArg) {
|
||||
const coordinate = applyTransform(
|
||||
frameState.pixelToCoordinateTransform, pixel.slice());
|
||||
const hasFeature = this.hasFeatureAtCoordinate(coordinate, frameState);
|
||||
|
||||
if (hasFeature) {
|
||||
return callback.call(thisArg, this.getLayer(), null);
|
||||
} else {
|
||||
return undefined;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* Handle changes in image style state.
|
||||
* @param {module:ol/events/Event} event Image style change event.
|
||||
* @private
|
||||
*/
|
||||
WebGLVectorLayerRenderer.prototype.handleStyleImageChange_ = function(event) {
|
||||
this.renderIfReadyAndVisible();
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
WebGLVectorLayerRenderer.prototype.prepareFrame = function(frameState, layerState, context) {
|
||||
const vectorLayer = /** @type {module:ol/layer/Vector} */ (this.getLayer());
|
||||
const vectorSource = vectorLayer.getSource();
|
||||
|
||||
const animating = frameState.viewHints[ViewHint.ANIMATING];
|
||||
const interacting = frameState.viewHints[ViewHint.INTERACTING];
|
||||
const updateWhileAnimating = vectorLayer.getUpdateWhileAnimating();
|
||||
const updateWhileInteracting = vectorLayer.getUpdateWhileInteracting();
|
||||
|
||||
if (!this.dirty_ && (!updateWhileAnimating && animating) ||
|
||||
(!updateWhileInteracting && interacting)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
const frameStateExtent = frameState.extent;
|
||||
const viewState = frameState.viewState;
|
||||
const projection = viewState.projection;
|
||||
const resolution = viewState.resolution;
|
||||
const pixelRatio = frameState.pixelRatio;
|
||||
const vectorLayerRevision = vectorLayer.getRevision();
|
||||
const vectorLayerRenderBuffer = vectorLayer.getRenderBuffer();
|
||||
let vectorLayerRenderOrder = vectorLayer.getRenderOrder();
|
||||
|
||||
if (vectorLayerRenderOrder === undefined) {
|
||||
vectorLayerRenderOrder = defaultRenderOrder;
|
||||
}
|
||||
|
||||
const extent = buffer(frameStateExtent,
|
||||
vectorLayerRenderBuffer * resolution);
|
||||
|
||||
if (!this.dirty_ &&
|
||||
this.renderedResolution_ == resolution &&
|
||||
this.renderedRevision_ == vectorLayerRevision &&
|
||||
this.renderedRenderOrder_ == vectorLayerRenderOrder &&
|
||||
containsExtent(this.renderedExtent_, extent)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (this.replayGroup_) {
|
||||
frameState.postRenderFunctions.push(
|
||||
this.replayGroup_.getDeleteResourcesFunction(context));
|
||||
}
|
||||
|
||||
this.dirty_ = false;
|
||||
|
||||
const replayGroup = new WebGLReplayGroup(
|
||||
getRenderTolerance(resolution, pixelRatio),
|
||||
extent, vectorLayer.getRenderBuffer());
|
||||
vectorSource.loadFeatures(extent, resolution, projection);
|
||||
/**
|
||||
* @param {module:ol/Feature} feature Feature.
|
||||
* @this {module:ol/renderer/webgl/VectorLayer}
|
||||
*/
|
||||
const render = function(feature) {
|
||||
let styles;
|
||||
const styleFunction = feature.getStyleFunction() || vectorLayer.getStyleFunction();
|
||||
if (styleFunction) {
|
||||
styles = styleFunction(feature, resolution);
|
||||
}
|
||||
if (styles) {
|
||||
const dirty = this.renderFeature(
|
||||
feature, resolution, pixelRatio, styles, replayGroup);
|
||||
this.dirty_ = this.dirty_ || dirty;
|
||||
}
|
||||
};
|
||||
if (vectorLayerRenderOrder) {
|
||||
/** @type {Array.<module:ol/Feature>} */
|
||||
const features = [];
|
||||
vectorSource.forEachFeatureInExtent(extent,
|
||||
/**
|
||||
* @param {module:ol/Feature} feature Feature.
|
||||
*/
|
||||
function(feature) {
|
||||
features.push(feature);
|
||||
}, this);
|
||||
features.sort(vectorLayerRenderOrder);
|
||||
features.forEach(render.bind(this));
|
||||
} else {
|
||||
vectorSource.forEachFeatureInExtent(extent, render, this);
|
||||
}
|
||||
replayGroup.finish(context);
|
||||
|
||||
this.renderedResolution_ = resolution;
|
||||
this.renderedRevision_ = vectorLayerRevision;
|
||||
this.renderedRenderOrder_ = vectorLayerRenderOrder;
|
||||
this.renderedExtent_ = extent;
|
||||
this.replayGroup_ = replayGroup;
|
||||
|
||||
return true;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {module:ol/Feature} feature Feature.
|
||||
* @param {number} resolution Resolution.
|
||||
* @param {number} pixelRatio Pixel ratio.
|
||||
* @param {(module:ol/style/Style|Array.<module:ol/style/Style>)} styles The style or array of
|
||||
* styles.
|
||||
* @param {module:ol/render/webgl/ReplayGroup} replayGroup Replay group.
|
||||
* @return {boolean} `true` if an image is loading.
|
||||
*/
|
||||
WebGLVectorLayerRenderer.prototype.renderFeature = function(feature, resolution, pixelRatio, styles, replayGroup) {
|
||||
if (!styles) {
|
||||
return false;
|
||||
}
|
||||
let loading = false;
|
||||
if (Array.isArray(styles)) {
|
||||
for (let i = styles.length - 1, ii = 0; i >= ii; --i) {
|
||||
loading = renderFeature(
|
||||
replayGroup, feature, styles[i],
|
||||
getSquaredRenderTolerance(resolution, pixelRatio),
|
||||
this.handleStyleImageChange_, this) || loading;
|
||||
}
|
||||
} else {
|
||||
loading = renderFeature(
|
||||
replayGroup, feature, styles,
|
||||
getSquaredRenderTolerance(resolution, pixelRatio),
|
||||
this.handleStyleImageChange_, this) || loading;
|
||||
}
|
||||
return loading;
|
||||
};
|
||||
export default WebGLVectorLayerRenderer;
|
||||
|
||||
Reference in New Issue
Block a user