410 lines
13 KiB
JavaScript
410 lines
13 KiB
JavaScript
/**
|
|
* @module ol/renderer/webgl/TileLayer
|
|
*/
|
|
// FIXME large resolutions lead to too large framebuffers :-(
|
|
// FIXME animated shaders! check in redraw
|
|
|
|
import {inherits} from '../../index.js';
|
|
import LayerType from '../../LayerType.js';
|
|
import TileRange from '../../TileRange.js';
|
|
import _ol_TileState_ from '../../TileState.js';
|
|
import _ol_array_ from '../../array.js';
|
|
import {createEmpty, intersects} from '../../extent.js';
|
|
import _ol_math_ from '../../math.js';
|
|
import RendererType from '../Type.js';
|
|
import _ol_renderer_webgl_Layer_ from '../webgl/Layer.js';
|
|
import _ol_renderer_webgl_tilelayershader_ from '../webgl/tilelayershader.js';
|
|
import _ol_renderer_webgl_tilelayershader_Locations_ from '../webgl/tilelayershader/Locations.js';
|
|
import _ol_size_ from '../../size.js';
|
|
import _ol_transform_ from '../../transform.js';
|
|
import _ol_webgl_ from '../../webgl.js';
|
|
import _ol_webgl_Buffer_ from '../../webgl/Buffer.js';
|
|
|
|
/**
|
|
* @constructor
|
|
* @extends {ol.renderer.webgl.Layer}
|
|
* @param {ol.renderer.webgl.Map} mapRenderer Map renderer.
|
|
* @param {ol.layer.Tile} tileLayer Tile layer.
|
|
* @api
|
|
*/
|
|
var _ol_renderer_webgl_TileLayer_ = function(mapRenderer, tileLayer) {
|
|
|
|
_ol_renderer_webgl_Layer_.call(this, mapRenderer, tileLayer);
|
|
|
|
/**
|
|
* @private
|
|
* @type {ol.webgl.Fragment}
|
|
*/
|
|
this.fragmentShader_ = _ol_renderer_webgl_tilelayershader_.fragment;
|
|
|
|
/**
|
|
* @private
|
|
* @type {ol.webgl.Vertex}
|
|
*/
|
|
this.vertexShader_ = _ol_renderer_webgl_tilelayershader_.vertex;
|
|
|
|
/**
|
|
* @private
|
|
* @type {ol.renderer.webgl.tilelayershader.Locations}
|
|
*/
|
|
this.locations_ = null;
|
|
|
|
/**
|
|
* @private
|
|
* @type {ol.webgl.Buffer}
|
|
*/
|
|
this.renderArrayBuffer_ = new _ol_webgl_Buffer_([
|
|
0, 0, 0, 1,
|
|
1, 0, 1, 1,
|
|
0, 1, 0, 0,
|
|
1, 1, 1, 0
|
|
]);
|
|
|
|
/**
|
|
* @private
|
|
* @type {ol.TileRange}
|
|
*/
|
|
this.renderedTileRange_ = null;
|
|
|
|
/**
|
|
* @private
|
|
* @type {ol.Extent}
|
|
*/
|
|
this.renderedFramebufferExtent_ = null;
|
|
|
|
/**
|
|
* @private
|
|
* @type {number}
|
|
*/
|
|
this.renderedRevision_ = -1;
|
|
|
|
/**
|
|
* @private
|
|
* @type {ol.Size}
|
|
*/
|
|
this.tmpSize_ = [0, 0];
|
|
|
|
};
|
|
|
|
inherits(_ol_renderer_webgl_TileLayer_, _ol_renderer_webgl_Layer_);
|
|
|
|
|
|
/**
|
|
* Determine if this renderer handles the provided layer.
|
|
* @param {ol.renderer.Type} type The renderer type.
|
|
* @param {ol.layer.Layer} layer The candidate layer.
|
|
* @return {boolean} The renderer can render the layer.
|
|
*/
|
|
_ol_renderer_webgl_TileLayer_['handles'] = function(type, layer) {
|
|
return type === RendererType.WEBGL && layer.getType() === LayerType.TILE;
|
|
};
|
|
|
|
|
|
/**
|
|
* Create a layer renderer.
|
|
* @param {ol.renderer.Map} mapRenderer The map renderer.
|
|
* @param {ol.layer.Layer} layer The layer to be rendererd.
|
|
* @return {ol.renderer.webgl.TileLayer} The layer renderer.
|
|
*/
|
|
_ol_renderer_webgl_TileLayer_['create'] = function(mapRenderer, layer) {
|
|
return new _ol_renderer_webgl_TileLayer_(
|
|
/** @type {ol.renderer.webgl.Map} */ (mapRenderer),
|
|
/** @type {ol.layer.Tile} */ (layer)
|
|
);
|
|
};
|
|
|
|
|
|
/**
|
|
* @inheritDoc
|
|
*/
|
|
_ol_renderer_webgl_TileLayer_.prototype.disposeInternal = function() {
|
|
var context = this.mapRenderer.getContext();
|
|
context.deleteBuffer(this.renderArrayBuffer_);
|
|
_ol_renderer_webgl_Layer_.prototype.disposeInternal.call(this);
|
|
};
|
|
|
|
|
|
/**
|
|
* @inheritDoc
|
|
*/
|
|
_ol_renderer_webgl_TileLayer_.prototype.createLoadedTileFinder = function(source, projection, tiles) {
|
|
var mapRenderer = this.mapRenderer;
|
|
|
|
return (
|
|
/**
|
|
* @param {number} zoom Zoom level.
|
|
* @param {ol.TileRange} tileRange Tile range.
|
|
* @return {boolean} The tile range is fully loaded.
|
|
*/
|
|
function(zoom, tileRange) {
|
|
function callback(tile) {
|
|
var 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
|
|
*/
|
|
_ol_renderer_webgl_TileLayer_.prototype.handleWebGLContextLost = function() {
|
|
_ol_renderer_webgl_Layer_.prototype.handleWebGLContextLost.call(this);
|
|
this.locations_ = null;
|
|
};
|
|
|
|
|
|
/**
|
|
* @inheritDoc
|
|
*/
|
|
_ol_renderer_webgl_TileLayer_.prototype.prepareFrame = function(frameState, layerState, context) {
|
|
|
|
var mapRenderer = this.mapRenderer;
|
|
var gl = context.getGL();
|
|
|
|
var viewState = frameState.viewState;
|
|
var projection = viewState.projection;
|
|
|
|
var tileLayer = /** @type {ol.layer.Tile} */ (this.getLayer());
|
|
var tileSource = tileLayer.getSource();
|
|
var tileGrid = tileSource.getTileGridForProjection(projection);
|
|
var z = tileGrid.getZForResolution(viewState.resolution);
|
|
var tileResolution = tileGrid.getResolution(z);
|
|
|
|
var tilePixelSize =
|
|
tileSource.getTilePixelSize(z, frameState.pixelRatio, projection);
|
|
var pixelRatio = tilePixelSize[0] /
|
|
_ol_size_.toSize(tileGrid.getTileSize(z), this.tmpSize_)[0];
|
|
var tilePixelResolution = tileResolution / pixelRatio;
|
|
var tileGutter = tileSource.getTilePixelRatio(pixelRatio) * tileSource.getGutter(projection);
|
|
|
|
var center = viewState.center;
|
|
var extent = frameState.extent;
|
|
var tileRange = tileGrid.getTileRangeForExtentAndZ(extent, z);
|
|
|
|
var framebufferExtent;
|
|
if (this.renderedTileRange_ &&
|
|
this.renderedTileRange_.equals(tileRange) &&
|
|
this.renderedRevision_ == tileSource.getRevision()) {
|
|
framebufferExtent = this.renderedFramebufferExtent_;
|
|
} else {
|
|
|
|
var tileRangeSize = tileRange.getSize();
|
|
|
|
var maxDimension = Math.max(
|
|
tileRangeSize[0] * tilePixelSize[0],
|
|
tileRangeSize[1] * tilePixelSize[1]);
|
|
var framebufferDimension = _ol_math_.roundUpToPowerOfTwo(maxDimension);
|
|
var framebufferExtentDimension = tilePixelResolution * framebufferDimension;
|
|
var origin = tileGrid.getOrigin(z);
|
|
var minX = origin[0] +
|
|
tileRange.minX * tilePixelSize[0] * tilePixelResolution;
|
|
var 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(_ol_webgl_.COLOR_BUFFER_BIT);
|
|
gl.disable(_ol_webgl_.BLEND);
|
|
|
|
var program = context.getProgram(this.fragmentShader_, this.vertexShader_);
|
|
context.useProgram(program);
|
|
if (!this.locations_) {
|
|
this.locations_ = new _ol_renderer_webgl_tilelayershader_Locations_(gl, program);
|
|
}
|
|
|
|
context.bindBuffer(_ol_webgl_.ARRAY_BUFFER, this.renderArrayBuffer_);
|
|
gl.enableVertexAttribArray(this.locations_.a_position);
|
|
gl.vertexAttribPointer(
|
|
this.locations_.a_position, 2, _ol_webgl_.FLOAT, false, 16, 0);
|
|
gl.enableVertexAttribArray(this.locations_.a_texCoord);
|
|
gl.vertexAttribPointer(
|
|
this.locations_.a_texCoord, 2, _ol_webgl_.FLOAT, false, 16, 8);
|
|
gl.uniform1i(this.locations_.u_texture, 0);
|
|
|
|
/**
|
|
* @type {Object.<number, Object.<string, ol.Tile>>}
|
|
*/
|
|
var tilesToDrawByZ = {};
|
|
tilesToDrawByZ[z] = {};
|
|
|
|
var findLoadedTiles = this.createLoadedTileFinder(
|
|
tileSource, projection, tilesToDrawByZ);
|
|
|
|
var useInterimTilesOnError = tileLayer.getUseInterimTilesOnError();
|
|
var allTilesLoaded = true;
|
|
var tmpExtent = createEmpty();
|
|
var tmpTileRange = new TileRange(0, 0, 0, 0);
|
|
var childTileRange, drawable, fullyLoaded, tile, tileState;
|
|
var 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 == _ol_TileState_.LOADED ||
|
|
tileState == _ol_TileState_.EMPTY ||
|
|
tileState == _ol_TileState_.ERROR && !useInterimTilesOnError;
|
|
if (!drawable) {
|
|
tile = tile.getInterimTile();
|
|
}
|
|
tileState = tile.getState();
|
|
if (tileState == _ol_TileState_.LOADED) {
|
|
if (mapRenderer.isTileTextureLoaded(tile)) {
|
|
tilesToDrawByZ[z][tile.tileCoord.toString()] = tile;
|
|
continue;
|
|
}
|
|
} else if (tileState == _ol_TileState_.EMPTY ||
|
|
(tileState == _ol_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>} */
|
|
var zs = Object.keys(tilesToDrawByZ).map(Number);
|
|
zs.sort(_ol_array_.numberSafeCompareFunction);
|
|
var u_tileOffset = new Float32Array(4);
|
|
var i, ii, tileKey, tilesToDraw;
|
|
for (i = 0, ii = zs.length; i < ii; ++i) {
|
|
tilesToDraw = tilesToDrawByZ[zs[i]];
|
|
for (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, _ol_webgl_.LINEAR, _ol_webgl_.LINEAR);
|
|
gl.drawArrays(_ol_webgl_.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);
|
|
var tileTextureQueue = mapRenderer.getTileTextureQueue();
|
|
this.manageTilePyramid(
|
|
frameState, tileSource, tileGrid, pixelRatio, projection, extent, z,
|
|
tileLayer.getPreload(),
|
|
/**
|
|
* @param {ol.Tile} tile Tile.
|
|
*/
|
|
function(tile) {
|
|
if (tile.getState() == _ol_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);
|
|
|
|
var texCoordMatrix = this.texCoordMatrix;
|
|
_ol_transform_.reset(texCoordMatrix);
|
|
_ol_transform_.translate(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) {
|
|
_ol_transform_.rotate(texCoordMatrix, viewState.rotation);
|
|
}
|
|
_ol_transform_.scale(texCoordMatrix,
|
|
frameState.size[0] * viewState.resolution /
|
|
(framebufferExtent[2] - framebufferExtent[0]),
|
|
frameState.size[1] * viewState.resolution /
|
|
(framebufferExtent[3] - framebufferExtent[1]));
|
|
_ol_transform_.translate(texCoordMatrix, -0.5, -0.5);
|
|
|
|
return true;
|
|
};
|
|
|
|
|
|
/**
|
|
* @inheritDoc
|
|
*/
|
|
_ol_renderer_webgl_TileLayer_.prototype.forEachLayerAtPixel = function(pixel, frameState, callback, thisArg) {
|
|
if (!this.framebuffer) {
|
|
return undefined;
|
|
}
|
|
|
|
var pixelOnMapScaled = [
|
|
pixel[0] / frameState.size[0],
|
|
(frameState.size[1] - pixel[1]) / frameState.size[1]];
|
|
|
|
var pixelOnFrameBufferScaled = _ol_transform_.apply(
|
|
this.texCoordMatrix, pixelOnMapScaled.slice());
|
|
var pixelOnFrameBuffer = [
|
|
pixelOnFrameBufferScaled[0] * this.framebufferDimension,
|
|
pixelOnFrameBufferScaled[1] * this.framebufferDimension];
|
|
|
|
var gl = this.mapRenderer.getContext().getGL();
|
|
gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
|
|
var 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 _ol_renderer_webgl_TileLayer_;
|