/ig, '').replace(/<\/p>/ig, ' \nvoid main() {\n vec4 c = vec4(aPosition, 1.);\n vec4 d = modelViewMatrix * c;\n mat4 e = projMatrix;\n e[2].xy += halton.xy / globalTexSize.xy;\n gl_Position = e * d;\n vPosition = gl_Position;\n shadow_computeShadowPars(c);\n}",frag:"#define SHADER_NAME SHADOW_DISPLAY\nprecision mediump float;\nuniform vec3 color;\n#include
');
this._textEditor.innerHTML = html;
var content = this._textEditor.innerText.replace(/[\r\n]+$/gi, '');
this.setContent(content);
off(this._textEditor, 'mousedown dblclick', stopPropagation);
this.getMap().off('mousedown', this.endEditText, this);
this._editUIMarker.remove();
delete this._editUIMarker;
this._textEditor.onkeyup = null;
delete this._textEditor;
this.show();
this._fireEvent('edittextend');
}
return this;
},
isEditingText: function isEditingText() {
if (this._textEditor) {
return true;
}
return false;
},
getTextEditor: function getTextEditor() {
return this._editUIMarker;
},
_prepareEditor: function _prepareEditor() {
var map = this.getMap();
var editContainer = this._createEditor();
this._textEditor = editContainer;
map.on('mousedown', this.endEditText, this);
var offset = this._getEditorOffset();
this._editUIMarker = new UIMarker(this.getCoordinates(), {
'animation': null,
'content': editContainer,
'dx': offset.dx,
'dy': offset.dy
}).addTo(map);
this._setCursorToLast(this._textEditor);
},
_getEditorOffset: function _getEditorOffset() {
var symbol = this._getInternalSymbol() || {};
var dx = 0,
dy = 0;
var textAlign = symbol['textHorizontalAlignment'];
if (textAlign === 'middle' || isNil(textAlign)) {
dx = (symbol['textDx'] || 0) - 2;
dy = (symbol['textDy'] || 0) - 2;
} else {
dx = (symbol['markerDx'] || 0) - 2;
dy = (symbol['markerDy'] || 0) - 2;
}
return {
'dx': dx,
'dy': dy
};
},
_createEditor: function _createEditor() {
var content = this.getContent();
var labelSize = this.getSize(),
symbol = this._getInternalSymbol() || {},
width = labelSize.width,
textColor = symbol['textFill'] || '#000000',
textSize = symbol['textSize'] || 12,
height = labelSize.height,
lineColor = symbol['markerLineColor'] || '#000',
fill = symbol['markerFill'] || '#3398CC',
spacing = symbol['textLineSpacing'] || 0;
var editor = createEl('div');
editor.contentEditable = true;
editor.style.cssText = "background:" + fill + "; border:1px solid " + lineColor + ";\n color:" + textColor + ";font-size:" + textSize + "px;width:" + (width - 2) + "px;height:" + (height - 2) + "px;margin: auto;\n line-height:" + (textSize + spacing) + "px;outline: 0; padding:0; margin:0;word-wrap: break-word;\n overflow: hidden;-webkit-user-modify: read-write-plaintext-only;";
editor.innerText = content;
on(editor, 'mousedown dblclick', stopPropagation);
editor.onkeyup = function (event) {
var h = editor.style.height || 0;
if (event.keyCode === 13) {
editor.style.height = parseInt(h) + textSize / 2 + 'px';
}
};
return editor;
},
_setCursorToLast: function _setCursorToLast(obj) {
var range;
if (window.getSelection) {
obj.focus();
range = window.getSelection();
range.selectAllChildren(obj);
range.collapseToEnd();
} else if (document.selection) {
range = document.selection.createRange();
range.moveToElementText(obj);
range.collapse(false);
range.select();
}
}
};
TextMarker.include(TextEditable);
Geometry.include({
animate: function animate$$1(styles, options, step) {
var _this = this;
if (this._animPlayer) {
this._animPlayer.finish();
}
if (isFunction(options)) {
step = options;
}
if (!options) {
options = {};
}
var map = this.getMap(),
projection = this._getProjection(),
stylesToAnimate = this._prepareAnimationStyles(styles);
var preTranslate;
var isFocusing = options['focus'];
delete this._animationStarted;
if (map) {
var renderer = map._getRenderer();
var framer = function framer(fn) {
renderer.callInNextFrame(fn);
};
options['framer'] = framer;
}
var player = Animation.animate(stylesToAnimate, options, function (frame) {
if (map && map.isRemoved()) {
player.finish();
return;
}
if (map && !_this._animationStarted && isFocusing) {
map.onMoveStart();
}
var styles = frame.styles;
for (var p in styles) {
if (p !== 'symbol' && p !== 'translate' && styles.hasOwnProperty(p)) {
var fnName = 'set' + p[0].toUpperCase() + p.slice(1);
_this[fnName](styles[p]);
}
}
var translate = styles['translate'];
if (translate) {
var toTranslate = translate;
if (preTranslate) {
toTranslate = translate.sub(preTranslate);
}
preTranslate = translate;
_this.translate(toTranslate);
}
var dSymbol = styles['symbol'];
if (dSymbol) {
var symbol = _this.getSymbol() || {};
_this.setSymbol(extendSymbol(symbol, dSymbol));
}
if (map && isFocusing) {
var pcenter = projection.project(_this.getCenter());
map._setPrjCenter(pcenter);
var e = map._parseEventFromCoord(projection.unproject(pcenter));
if (player.playState !== 'running') {
map.onMoveEnd(e);
} else {
map.onMoving(e);
}
}
_this._fireAnimateEvent(player.playState);
if (step) {
step(frame);
}
}, this);
this._animPlayer = player;
return this._animPlayer.play();
},
_prepareAnimationStyles: function _prepareAnimationStyles(styles) {
var symbol = this._getInternalSymbol();
var stylesToAnimate = {};
for (var p in styles) {
if (styles.hasOwnProperty(p)) {
var v = styles[p];
if (p !== 'translate' && p !== 'symbol') {
var fnName = 'get' + p[0].toUpperCase() + p.substring(1);
var current = this[fnName]();
stylesToAnimate[p] = [current, v];
} else if (p === 'symbol') {
var symbolToAnimate = void 0;
if (Array.isArray(styles['symbol'])) {
if (!Array.isArray(symbol)) {
throw new Error('geometry\'symbol isn\'t a composite symbol, while the symbol in styles is.');
}
symbolToAnimate = [];
var symbolInStyles = styles['symbol'];
for (var i = 0; i < symbolInStyles.length; i++) {
if (!symbolInStyles[i]) {
symbolToAnimate.push(null);
continue;
}
var a = {};
for (var sp in symbolInStyles[i]) {
if (symbolInStyles[i].hasOwnProperty(sp)) {
a[sp] = [symbol[i][sp], symbolInStyles[i][sp]];
}
}
symbolToAnimate.push(a);
}
} else {
if (Array.isArray(symbol)) {
throw new Error('geometry\'symbol is a composite symbol, while the symbol in styles isn\'t.');
}
symbolToAnimate = {};
for (var _sp in v) {
if (v.hasOwnProperty(_sp)) {
symbolToAnimate[_sp] = [symbol[_sp], v[_sp]];
}
}
}
stylesToAnimate['symbol'] = symbolToAnimate;
} else if (p === 'translate') {
stylesToAnimate['translate'] = new Coordinate(v);
}
}
}
return stylesToAnimate;
},
_fireAnimateEvent: function _fireAnimateEvent(playState) {
if (playState === 'finished') {
delete this._animationStarted;
this._fireEvent('animateend');
} else if (playState === 'running') {
if (this._animationStarted) {
this._fireEvent('animating');
} else {
this._fireEvent('animatestart');
this._animationStarted = true;
}
}
}
});
var DRAG_STAGE_LAYER_ID = INTERNAL_LAYER_PREFIX + '_drag_stage';
var EVENTS$3 = Browser$1.touch ? 'touchstart mousedown' : 'mousedown';
var GeometryDragHandler = function (_Handler) {
_inheritsLoose(GeometryDragHandler, _Handler);
function GeometryDragHandler(target) {
return _Handler.call(this, target) || this;
}
var _proto = GeometryDragHandler.prototype;
_proto.addHooks = function addHooks() {
this.target.on(EVENTS$3, this._startDrag, this);
};
_proto.removeHooks = function removeHooks() {
this._endDrag();
this.target.off(EVENTS$3, this._startDrag, this);
delete this.container;
};
_proto._prepareDragHandler = function _prepareDragHandler() {
this._dragHandler = new DragHandler(this.container);
this._dragHandler.on('dragging', this._dragging, this).on('mouseup', this._endDrag, this).enable();
};
_proto._prepareShadow = function _prepareShadow() {
var _this = this;
var target = this.target;
var needShadow = target.getLayer().options['renderer'] === 'canvas';
if (!needShadow) {
return;
}
this._prepareDragStageLayer();
if (this._shadow) {
this._shadow.remove();
}
var shadow = this._shadow = target.copy();
if (shadow.getGeometries) {
var shadows = shadow.getGeometries();
var geos = target.getGeometries();
shadows.forEach(function (g, i) {
_this._updateShadowSymbol(g, geos[i]);
});
} else {
this._updateShadowSymbol(shadow, target);
}
shadow.setId(null);
this._prepareShadowConnectors();
};
_proto._updateShadowSymbol = function _updateShadowSymbol(shadow, target) {
shadow.setSymbol(target._getInternalSymbol());
if (target.options['dragShadow']) {
var symbol = lowerSymbolOpacity(shadow._getInternalSymbol(), 0.5);
shadow.setSymbol(symbol);
}
};
_proto._prepareShadowConnectors = function _prepareShadowConnectors() {
var target = this.target;
var shadow = this._shadow;
var resources = this._dragStageLayer._getRenderer().resources;
var shadowConnectors = [];
if (ConnectorLine._hasConnectors(target)) {
var connectors = ConnectorLine._getConnectors(target);
for (var i = 0, l = connectors.length; i < l; i++) {
var targetConn = connectors[i];
var connOptions = targetConn.config(),
connSymbol = targetConn._getInternalSymbol();
connOptions['symbol'] = lowerSymbolOpacity(connSymbol, 0.5);
var conn = void 0;
if (targetConn.getConnectSource() === target) {
conn = new targetConn.constructor(shadow, targetConn.getConnectTarget(), connOptions);
} else {
conn = new targetConn.constructor(targetConn.getConnectSource(), shadow, connOptions);
}
shadowConnectors.push(conn);
if (targetConn.getLayer() && targetConn.getLayer()._getRenderer()) {
resources.merge(targetConn.getLayer()._getRenderer().resources);
}
}
}
this._shadowConnectors = shadowConnectors;
shadowConnectors.push(shadow);
this._dragStageLayer.bringToFront().addGeometry(shadowConnectors);
};
_proto._onTargetUpdated = function _onTargetUpdated() {
if (this._shadow) {
this._shadow.setSymbol(this.target._getSymbol());
}
};
_proto._prepareDragStageLayer = function _prepareDragStageLayer() {
var map = this.target.getMap(),
layer = this.target.getLayer();
this._dragStageLayer = map.getLayer(DRAG_STAGE_LAYER_ID);
if (!this._dragStageLayer) {
this._dragStageLayer = new VectorLayer(DRAG_STAGE_LAYER_ID, {
enableAltitude: layer.options['enableAltitude'],
altitudeProperty: layer.options['altitudeProperty']
});
map.addLayer(this._dragStageLayer);
}
var resources = new ResourceCache();
resources.merge(layer._getRenderer().resources);
this._dragStageLayer._getRenderer().resources = resources;
};
_proto._startDrag = function _startDrag(param) {
var map = this.target.getMap();
if (!map) {
return;
}
var parent = this.target._getParent();
if (parent) {
return;
}
if (this.isDragging()) {
return;
}
var domEvent = param['domEvent'];
if (domEvent.touches && domEvent.touches.length > 1 || domEvent.button === 2) {
return;
}
this.container = map._panels.mapWrapper || map._containerDOM;
this.target.on('click', this._endDrag, this);
this._lastCoord = this._correctCoord(param['coordinate']);
this._lastPoint = param['containerPoint'];
this._prepareDragHandler();
this._dragHandler.onMouseDown(param['domEvent']);
on(this.container, 'mouseleave', this._endDrag, this);
this._startParam = param;
this._moved = false;
return;
};
_proto._dragging = function _dragging(param) {
var target = this.target;
var map = target.getMap();
if (map._isEventOutMap(param['domEvent'])) {
return;
}
var e = map._parseEvent(param['domEvent']);
var domEvent = e['domEvent'];
if (domEvent.touches && domEvent.touches.length > 1) {
return;
}
var visualHeight = map._getVisualHeight(map.options['maxVisualPitch']);
if (e.containerPoint.y < map.height - visualHeight) {
return;
}
if (!this._moved) {
this._moved = true;
target.on('symbolchange', this._onTargetUpdated, this);
this._isDragging = true;
this._prepareShadow();
if (this._shadow) {
if (!target.options['dragShadow']) {
target.hide();
}
this._shadow._fireEvent('dragstart', e);
}
this.target._fireEvent('dragstart', this._startParam || e);
delete this._startParam;
return;
}
var geo = this._shadow || target;
var axis = geo.options['dragOnAxis'],
dragOnScreenAxis = geo.options['dragOnScreenAxis'],
point = e['containerPoint'];
var coord = e['coordinate'];
this._lastPoint = this._lastPoint || point;
this._lastCoord = this._lastCoord || coord;
if (dragOnScreenAxis) {
if (axis === 'x') {
point.y = this._lastPoint.y;
} else if (axis === 'y') {
point.x = this._lastPoint.x;
}
coord = map.containerPointToCoord(point);
} else {
coord = this._correctCoord(coord);
}
var pointOffset = point.sub(this._lastPoint);
var coordOffset = coord.sub(this._lastCoord);
if (!dragOnScreenAxis) {
if (axis === 'x') {
pointOffset.y = coordOffset.y = 0;
} else if (axis === 'y') {
pointOffset.x = coordOffset.x = 0;
}
}
this._lastPoint = point;
this._lastCoord = coord;
geo.translate(coordOffset);
if (geo !== target && !target.options['dragShadow']) {
target.translate(coordOffset);
}
e['coordOffset'] = coordOffset;
e['pointOffset'] = pointOffset;
geo._fireEvent('dragging', e);
if (geo !== target) {
target._fireEvent('dragging', e);
}
};
_proto._endDrag = function _endDrag(param) {
if (this._dragHandler) {
this._dragHandler.disable();
delete this._dragHandler;
}
if (this.container) {
off(this.container, 'mouseleave', this._endDrag, this);
}
if (!this.target) {
return;
}
var target = this.target;
target.off('click', this._endDrag, this);
target.off('symbolchange', this._onTargetUpdated, this);
delete this._lastCoord;
delete this._lastPoint;
this._isDragging = false;
var map = target.getMap();
if (this.enabled() && map) {
var e = map._parseEvent(param ? param['domEvent'] : null);
this._updateTargetAndRemoveShadow(e);
if (this._moved) {
target._fireEvent('dragend', e);
}
}
};
_proto.isDragging = function isDragging() {
if (!this._isDragging) {
return false;
}
return true;
};
_proto._updateTargetAndRemoveShadow = function _updateTargetAndRemoveShadow(eventParam) {
if (!this._shadow) {
return;
}
var target = this.target,
map = target.getMap();
if (!target.options['dragShadow']) {
target.show();
}
var shadow = this._shadow;
if (shadow) {
if (target.options['dragShadow']) {
var shadowFirst = shadow.getFirstCoordinate();
var first = target.getFirstCoordinate();
var offset = shadowFirst.sub(first);
target.translate(offset);
}
shadow._fireEvent('dragend', eventParam);
shadow.remove();
delete this._shadow;
}
if (this._shadowConnectors) {
map.getLayer(DRAG_STAGE_LAYER_ID).removeGeometry(this._shadowConnectors);
delete this._shadowConnectors;
}
if (this._dragStageLayer) {
this._dragStageLayer._getRenderer().resources = new ResourceCache();
this._dragStageLayer.remove();
}
};
_proto._correctCoord = function _correctCoord(coord) {
var map = this.target.getMap();
if (!map.getPitch()) {
return coord;
}
var target = this.target;
if (!target.getMinAltitude()) {
return coord;
}
var alt = (target.getMinAltitude() + target.getMaxAltitude()) / 2;
return map.locateByPoint(coord, 0, -alt);
};
return GeometryDragHandler;
}(Handler$1);
Geometry.mergeOptions({
'draggable': false,
'dragShadow': true,
'dragOnAxis': null,
'dragOnScreenAxis': false
});
Geometry.addInitHook('addHandler', 'draggable', GeometryDragHandler);
Geometry.include({
isDragging: function isDragging() {
if (this._getParent()) {
return this._getParent().isDragging();
}
if (this['draggable']) {
return this['draggable'].isDragging();
}
return false;
}
});
Geometry.include({
startEdit: function startEdit(opts) {
var map = this.getMap();
if (!map || !this.options['editable']) {
return this;
}
if (this._editor) {
this.endEdit();
}
this._editor = new GeometryEditor(this, opts);
this._editor.start();
if (!this._getParent()) {
this.fire('editstart');
}
map.getRenderer().setToRedraw();
return this;
},
endEdit: function endEdit() {
if (this._editor) {
this._editor.stop();
delete this._editor;
if (!this._getParent()) {
this.fire('editend');
}
var map = this.getMap();
if (map) {
map.getRenderer().setToRedraw();
}
}
return this;
},
redoEdit: function redoEdit() {
if (!this.isEditing()) {
return this;
}
this._editor.redo();
if (!this._getParent()) {
this.fire('redoedit');
}
return this;
},
undoEdit: function undoEdit() {
if (!this.isEditing()) {
return this;
}
this._editor.undo();
if (!this._getParent()) {
this.fire('undoedit');
}
return this;
},
cancelEdit: function cancelEdit() {
if (!this.isEditing()) {
return this;
}
if (this._editor) this._editor.cancel();
if (!this._getParent()) {
this.fire('canceledit');
}
return this;
},
isEditing: function isEditing() {
if (this._editor) {
return this._editor.isEditing();
}
return false;
}
});
Geometry.include({
_onEvent: function _onEvent(event, type) {
var map = this.getMap();
if (!map) {
return;
}
var eventType = type || this._getEventTypeToFire(event);
if (eventType === 'contextmenu' && this.listens('contextmenu')) {
stopPropagation(event);
preventDefault(event);
}
var params = map._getEventParams(event);
if (isNumber(this._pickGeometryIndex)) {
params.pickGeometryIndex = this._pickGeometryIndex;
}
this._fireEvent(eventType, params);
},
_getEventTypeToFire: function _getEventTypeToFire(domEvent) {
return domEvent.type;
}
});
Geometry.include({
setInfoWindow: function setInfoWindow(options) {
this.removeInfoWindow();
if (options instanceof InfoWindow) {
this._infoWindow = options;
this._infoWinOptions = extend({}, this._infoWindow.options);
this._infoWindow.addTo(this);
return this;
}
this._infoWinOptions = extend({}, options);
if (this._infoWindow) {
this._infoWindow.setOptions(options);
} else if (this.getMap()) {
this._bindInfoWindow();
}
return this;
},
getInfoWindow: function getInfoWindow() {
if (!this._infoWindow) {
return null;
}
return this._infoWindow;
},
openInfoWindow: function openInfoWindow(coordinate) {
if (!this.getMap()) {
return this;
}
if (!coordinate) {
coordinate = this.getCenter();
}
if (!this._infoWindow) {
if (this._infoWinOptions && this.getMap()) {
this._bindInfoWindow();
this._infoWindow.show(coordinate);
}
} else {
this._infoWindow.show(coordinate);
}
return this;
},
closeInfoWindow: function closeInfoWindow() {
if (this._infoWindow) {
this._infoWindow.hide();
}
this.fire('closeInfoWindow'); // 弹窗关闭时抛出事件 用于geom取消高亮状态
return this;
},
removeInfoWindow: function removeInfoWindow() {
this._unbindInfoWindow();
delete this._infoWinOptions;
delete this._infoWindow;
return this;
},
_bindInfoWindow: function _bindInfoWindow() {
var options = this._infoWinOptions;
if (!options) {
return this;
}
this._infoWindow = new InfoWindow(options);
this._infoWindow.addTo(this);
return this;
},
_unbindInfoWindow: function _unbindInfoWindow() {
if (this._infoWindow) {
this.closeInfoWindow();
this._infoWindow.remove();
delete this._infoWindow;
}
return this;
}
});
var TILE_POINT = new Point(0, 0);
var TEMP_POINT$5 = new Point(0, 0);
var TEMP_POINT1$2 = new Point(0, 0);
var TEMP_POINT2$2 = new Point(0, 0);
var EMPTY_ARRAY$2 = [];
var TileWorkerConnection = function (_Actor) {
_inheritsLoose(TileWorkerConnection, _Actor);
function TileWorkerConnection() {
return _Actor.call(this, imageFetchWorkerKey) || this;
}
var _proto = TileWorkerConnection.prototype;
_proto.checkUrl = function checkUrl(url) {
if (!url || !isString(url)) {
return url;
}
return getAbsoluteURL(url);
};
_proto.fetchImage = function fetchImage(url, workerId, cb, fetchOptions) {
url = this.checkUrl(url);
var data = {
url: url,
fetchOptions: fetchOptions
};
this.send(data, EMPTY_ARRAY$2, cb, workerId);
};
return TileWorkerConnection;
}(Actor);
var BLANK_IMAGE = new Image();
var TileLayerCanvasRenderer = function (_CanvasRenderer) {
_inheritsLoose(TileLayerCanvasRenderer, _CanvasRenderer);
function TileLayerCanvasRenderer(layer) {
var _this;
_this = _CanvasRenderer.call(this, layer) || this;
_this.tilesInView = {};
_this.tilesLoading = {};
_this._parentTiles = [];
_this._childTiles = [];
_this._tileQueue = [];
_this._tileQueueIds = new Set();
var tileSize = layer.getTileSize().width;
_this.tileCache = new LRUCache(layer.options['maxCacheSize'] * tileSize / 512 * tileSize / 512, function (tile) {
_this.deleteTile(tile);
});
if (Browser$1.decodeImageInWorker && _this.layer.options['decodeImageInWorker'] && (layer.options['renderer'] === 'gl' || !Browser$1.safari && !Browser$1.iosWeixin)) {
_this._tileImageWorkerConn = new TileWorkerConnection();
}
_this._compareTiles = compareTiles.bind(_assertThisInitialized(_assertThisInitialized(_this)));
return _this;
}
var _proto2 = TileLayerCanvasRenderer.prototype;
_proto2.getCurrentTileZoom = function getCurrentTileZoom() {
return this._tileZoom;
};
_proto2.draw = function draw(timestamp, context) {
var map = this.getMap();
if (!this.isDrawable()) {
return;
}
var mask2DExtent = this.prepareCanvas();
if (mask2DExtent) {
if (!mask2DExtent.intersects(this.canvasExtent2D)) {
this.completeRender();
return;
}
}
if (this._renderTimestamp !== timestamp) {
this._consumeTileQueue();
this._computeAvgTileAltitude();
this._renderTimestamp = timestamp;
}
var currentTiles;
var hasFreshTiles = false;
var frameTiles = this._frameTiles;
if (frameTiles && timestamp === frameTiles.timestamp) {
if (frameTiles.empty) {
return;
}
currentTiles = frameTiles;
} else {
currentTiles = this._getTilesInCurrentFrame();
if (!currentTiles) {
this._frameTiles = {
empty: true,
timestamp: timestamp
};
this.completeRender();
return;
}
hasFreshTiles = true;
this._frameTiles = currentTiles;
this._frameTiles.timestamp = timestamp;
if (currentTiles.loadingCount) {
this.loadTileQueue(currentTiles.tileQueue);
}
}
var _currentTiles = currentTiles,
tiles = _currentTiles.tiles,
childTiles = _currentTiles.childTiles,
parentTiles = _currentTiles.parentTiles,
placeholders = _currentTiles.placeholders,
loading = _currentTiles.loading,
loadingCount = _currentTiles.loadingCount,
missedTiles = _currentTiles.missedTiles,
incompleteTiles = _currentTiles.incompleteTiles;
this._drawTiles(tiles, parentTiles, childTiles, placeholders, context, missedTiles, incompleteTiles);
if (!loadingCount) {
if (!loading) {
if (!map.isAnimating() && (this._parentTiles.length || this._childTiles.length)) {
this._parentTiles = [];
this._childTiles = [];
this.setToRedraw();
}
this.completeRender();
}
}
if (hasFreshTiles) {
this.retireTiles();
}
};
_proto2.getTileGridsInCurrentFrame = function getTileGridsInCurrentFrame() {
return this._frameTileGrids;
};
_proto2.getCurrentTimestamp = function getCurrentTimestamp() {
return this._renderTimestamp || 0;
};
_proto2._getTilesInCurrentFrame = function _getTilesInCurrentFrame() {
var map = this.getMap();
var layer = this.layer;
var terrainTileMode = layer._isPyramidMode() && layer.options['terrainTileMode'];
var tileGrids = layer.getTiles();
this._frameTileGrids = tileGrids;
tileGrids = tileGrids.tileGrids;
if (!tileGrids || !tileGrids.length) {
return null;
}
var count = tileGrids.reduce(function (acc, curr) {
return acc + (curr && curr.tiles && curr.tiles.length || 0);
}, 0);
if (count >= this.tileCache.max / 2) {
this.tileCache.setMaxSize(count * 2 + 1);
}
var loadingCount = 0;
var loading = false;
var checkedTiles = {};
var tiles = [],
parentTiles = [],
parentKeys = {},
childTiles = [],
childKeys = {},
placeholders = [],
placeholderKeys = {};
var tileQueue = {};
var preLoadingCount = this.markTiles();
var loadingLimit = this._getLoadLimit();
var l = tileGrids.length;
var isFirstRender = this._tileZoom === undefined && !this._terrainHelper;
this._tileZoom = tileGrids[0]['zoom'];
var missingTiles = null;
var incompleteTiles = null;
if (terrainTileMode) {
missingTiles = [];
incompleteTiles = new Map();
}
for (var i = 0; i < l; i++) {
var tileGrid = tileGrids[i];
var gridTiles = tileGrid['tiles'];
var parents = tileGrid['parents'] || EMPTY_ARRAY$2;
var parentCount = parents.length;
var allTiles = isFirstRender ? gridTiles : parents.concat(gridTiles);
var placeholder = void 0;
if (allTiles.length) {
placeholder = this._generatePlaceHolder(allTiles[0].res);
}
for (var j = 0, _l = allTiles.length; j < _l; j++) {
var tile = allTiles[j];
var tileId = tile.id;
var isParentTile = j < parentCount;
var tileLoading = false;
var tilesCount = tiles.length;
if (this._isLoadingTile(tileId)) {
tileLoading = loading = true;
this.markCurrent(this.tilesLoading[tileId], true);
} else {
var cached = this.getCachedTile(tile, isParentTile);
if (cached) {
if (!isParentTile) {
if (cached.image && this.isTileFadingIn(cached.image)) {
tileLoading = loading = true;
this.setToRedraw();
}
if (this.isTileComplete(cached)) {
tiles.push(cached);
} else {
tileLoading = true;
if (terrainTileMode) {
incompleteTiles.set(tileId, cached);
}
}
}
} else {
tileLoading = loading = true;
var hitLimit = loadingLimit && loadingCount + preLoadingCount[0] > loadingLimit;
if (!this._tileQueueIds.has(tile.id) && !hitLimit && (!map.isInteracting() || map.isMoving() || map.isRotating())) {
loadingCount++;
var key = tileId;
tileQueue[key] = tile;
}
}
}
if (terrainTileMode && !isParentTile) {
if (tiles.length === tilesCount) {
missingTiles.push(tile);
} else {
checkedTiles[tile.id] = 1;
}
}
if (terrainTileMode) continue;
if (isParentTile) continue;
if (!tileLoading) continue;
if (checkedTiles[tileId]) continue;
checkedTiles[tileId] = 1;
if (placeholder && !placeholderKeys[tileId]) {
tile.cache = false;
placeholders.push({
image: placeholder,
info: tile
});
placeholderKeys[tileId] = 1;
}
var children = this._findChildTiles(tile);
if (children.length) {
children.forEach(function (c) {
if (!childKeys[c.info.id]) {
childTiles.push(c);
childKeys[c.info.id] = 1;
}
});
}
if (!children.length || children.length !== 4) {
var parentTile = this._findParentTile(tile);
if (parentTile) {
var parentId = parentTile.info.id;
if (parentKeys[parentId] === undefined) {
parentKeys[parentId] = parentTiles.length;
parentTiles.push(parentTile);
}
}
}
}
}
var missedTiles = [];
if (terrainTileMode) {
for (var _i = 0; _i < missingTiles.length; _i++) {
var _tile = missingTiles[_i].info ? missingTiles[_i].info : missingTiles[_i];
if (!_tile.parent || checkedTiles[_tile.id]) {
continue;
}
var _this$_findChildTiles = this._findChildTiles(_tile),
_children = _this$_findChildTiles.tiles,
childMissedTiles = _this$_findChildTiles.missedTiles;
if (_children.length) {
pushIn(tiles, _children);
pushIn(missedTiles, childMissedTiles);
continue;
} else if (incompleteTiles.has(_tile.id)) {
tiles.push(incompleteTiles.get(_tile.id));
incompleteTiles.delete(_tile.id);
continue;
}
checkedTiles[_tile.id] = 1;
missedTiles.push(_tile);
}
}
this.tileCache.shrink();
return {
childTiles: childTiles,
missedTiles: missedTiles,
parentTiles: parentTiles,
tiles: tiles,
incompleteTiles: incompleteTiles && Array.from(incompleteTiles.values()),
placeholders: placeholders,
loading: loading,
loadingCount: loadingCount,
tileQueue: tileQueue
};
};
_proto2.removeTileCache = function removeTileCache(tileId) {
delete this.tilesInView[tileId];
this.tileCache.remove(tileId);
};
_proto2.isTileCachedOrLoading = function isTileCachedOrLoading(tileId) {
return this.tileCache.get(tileId) || this.tilesInView[tileId] || this.tilesLoading[tileId];
};
_proto2.isTileCached = function isTileCached(tileId) {
return !!(this.tileCache.get(tileId) || this.tilesInView[tileId]);
};
_proto2.isTileFadingIn = function isTileFadingIn(tileImage) {
return this._getTileFadingOpacity(tileImage) < 1;
};
_proto2._drawTiles = function _drawTiles(tiles, parentTiles, childTiles, placeholders, parentContext) {
var _this2 = this;
if (parentTiles.length) {
parentTiles.sort(this._compareTiles);
this._parentTiles = parentTiles;
}
if (childTiles.length) {
this._childTiles = childTiles;
this._childTiles.sort(this._compareTiles);
}
var drawBackground = true;
var backgroundTimestamp = this.canvas._parentTileTimestamp;
if (this.layer.constructor === TileLayer || this.layer.constructor === WMSTileLayer) {
if (this._renderTimestamp === backgroundTimestamp) {
drawBackground = false;
} else {
this.canvas._parentTileTimestamp = this._renderTimestamp;
}
}
var renderInGL = this.layer.options.renderer === 'gl' && (!this.isGL || this.isGL());
var context = {
tiles: tiles,
parentTiles: this._parentTiles,
childTiles: this._childTiles,
parentContext: parentContext
};
this.onDrawTileStart(context, parentContext);
if (drawBackground && this.layer.options['opacity'] === 1) {
this.layer._silentConfig = true;
var fadingAnimation = this.layer.options['fadeAnimation'];
this.layer.options['fadeAnimation'] = false;
if (renderInGL) {
this._drawChildTiles(childTiles, parentContext);
this._drawParentTiles(this._parentTiles, parentContext);
} else {
this._drawParentTiles(this._parentTiles, parentContext);
this._drawChildTiles(childTiles, parentContext);
}
this.layer.options['fadeAnimation'] = fadingAnimation;
this.layer._silentConfig = false;
}
this.drawingCurrentTiles = true;
tiles.sort(this._compareTiles);
for (var i = 0, l = tiles.length; i < l; i++) {
this._drawTileAndCache(tiles[i], parentContext);
}
delete this.drawingCurrentTiles;
if (drawBackground && this.layer.options['opacity'] < 1) {
this.layer._silentConfig = true;
var _fadingAnimation = this.layer.options['fadeAnimation'];
this.layer.options['fadeAnimation'] = false;
if (renderInGL) {
this._drawChildTiles(childTiles, parentContext);
this._drawParentTiles(this._parentTiles, parentContext);
} else {
this._drawParentTiles(this._parentTiles, parentContext);
this._drawChildTiles(childTiles, parentContext);
}
this.layer.options['fadeAnimation'] = _fadingAnimation;
this.layer._silentConfig = false;
}
placeholders.forEach(function (t) {
return _this2._drawTile(t.info, t.image, parentContext);
});
this.onDrawTileEnd(context, parentContext);
};
_proto2._drawChildTiles = function _drawChildTiles(childTiles, parentContext) {
var _this3 = this;
this.drawingChildTiles = true;
childTiles.forEach(function (t) {
return _this3._drawTile(t.info, t.image, parentContext);
});
delete this.drawingChildTiles;
};
_proto2._drawParentTiles = function _drawParentTiles(parentTiles, parentContext) {
var _this4 = this;
this.drawingParentTiles = true;
this._parentTiles.forEach(function (t) {
return _this4._drawTile(t.info, t.image, parentContext);
});
delete this.drawingParentTiles;
};
_proto2.onDrawTileStart = function onDrawTileStart() {};
_proto2.onDrawTileEnd = function onDrawTileEnd() {};
_proto2._drawTile = function _drawTile(info, image, parentContext) {
if (image) {
this.drawTile(info, image, parentContext);
}
};
_proto2._drawTileAndCache = function _drawTileAndCache(tile, parentContext) {
if (this.isValidCachedTile(tile)) {
this._addTileToCache(tile.info, tile.image);
}
this._drawTile(tile.info, tile.image, parentContext);
};
_proto2.drawOnInteracting = function drawOnInteracting(event, timestamp, context) {
this.draw(timestamp, context);
};
_proto2.needToRedraw = function needToRedraw() {
var map = this.getMap();
if (this._tileQueue.length) {
return true;
}
if (map.getPitch()) {
return _CanvasRenderer.prototype.needToRedraw.call(this);
}
if (map.isRotating() || map.isZooming()) {
return true;
}
if (map.isMoving()) {
return !!this.layer.options['forceRenderOnMoving'];
}
return _CanvasRenderer.prototype.needToRedraw.call(this);
};
_proto2.hitDetect = function hitDetect() {
return false;
};
_proto2._getLoadLimit = function _getLoadLimit() {
if (this.getMap().isInteracting()) {
return this.layer.options['loadingLimitOnInteracting'];
}
return this.layer.options['loadingLimit'] || 0;
};
_proto2.isDrawable = function isDrawable() {
if (this.getMap().getPitch()) {
if (console) {
console.warn('TileLayer with canvas renderer can\'t be pitched, use gl renderer (\'renderer\' : \'gl\') instead.');
}
this.clear();
return false;
}
return true;
};
_proto2.clear = function clear() {
this.retireTiles(true);
this.tileCache.reset();
this.tilesInView = {};
this.tilesLoading = {};
this._tileQueue = [];
this._tileQueueIds.clear();
this._parentTiles = [];
this._childTiles = [];
_CanvasRenderer.prototype.clear.call(this);
};
_proto2._isLoadingTile = function _isLoadingTile(tileId) {
return !!this.tilesLoading[tileId];
};
_proto2.clipCanvas = function clipCanvas(context) {
return _CanvasRenderer.prototype.clipCanvas.call(this, context);
};
_proto2._clipByPitch = function _clipByPitch(ctx) {
var map = this.getMap();
if (map.getPitch() <= map.options['maxVisualPitch']) {
return false;
}
if (!this.layer.options['clipByPitch']) {
return false;
}
var clipExtent = map.getContainerExtent();
var r = map.getDevicePixelRatio();
ctx.save();
ctx.strokeStyle = 'rgba(0, 0, 0, 0)';
ctx.beginPath();
ctx.rect(0, Math.ceil(clipExtent.ymin) * r, Math.ceil(clipExtent.getWidth()) * r, Math.ceil(clipExtent.getHeight()) * r);
ctx.stroke();
ctx.clip();
return true;
};
_proto2.loadTileQueue = function loadTileQueue(tileQueue) {
for (var p in tileQueue) {
if (tileQueue.hasOwnProperty(p)) {
var tile = tileQueue[p];
var tileImage = this.loadTile(tile);
if (tileImage.loadTime === undefined) {
this.tilesLoading[tile['id']] = {
image: tileImage,
current: true,
info: tile
};
}
}
}
};
_proto2.loadTile = function loadTile(tile) {
var _this5 = this;
var tileImage = {};
if (this.loadTileBitmap) {
var onLoad = function onLoad(bitmap) {
_this5.onTileLoad(bitmap, tile);
};
this.loadTileBitmap(tile['url'], tile, onLoad);
} else if (this._tileImageWorkerConn && this.loadTileImage === this.constructor.prototype.loadTileImage) {
this._fetchImage(tileImage, tile);
} else {
var tileSize = this.layer.getTileSize(tile.layer);
tileImage = new Image();
tileImage.width = tileSize['width'];
tileImage.height = tileSize['height'];
tileImage.onload = this.onTileLoad.bind(this, tileImage, tile);
tileImage.onerror = this.onTileError.bind(this, tileImage, tile);
this.loadTileImage(tileImage, tile['url']);
}
return tileImage;
};
_proto2._fetchImage = function _fetchImage(image, tile) {
var _this6 = this;
if (image instanceof Image) {
image.src = tile.url;
} else {
var x = tile.x,
y = tile.y;
var workerId = Math.abs(x + y) % this._tileImageWorkerConn.workers.length;
this._tileImageWorkerConn.fetchImage(tile.url, workerId, function (err, data) {
if (err) {
_this6.onTileError(image, tile, err);
} else {
getImageBitMap(data, function (bitmap) {
_this6.onTileLoad(bitmap, tile);
});
}
}, this.layer.options['fetchOptions'] || {
referrer: document.location.href,
headers: {
accept: 'image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8'
}
});
}
};
_proto2.loadTileImage = function loadTileImage(tileImage, url) {
var crossOrigin = this.layer.options['crossOrigin'];
if (!isNil(crossOrigin)) {
tileImage.crossOrigin = crossOrigin;
}
return loadImage(tileImage, [url]);
};
_proto2.abortTileLoading = function abortTileLoading(tileImage, tileInfo) {
if (tileInfo && tileInfo.id !== undefined) {
this.removeTileLoading(tileInfo);
}
if (!tileImage) return;
if (tileImage instanceof Image) {
tileImage.onload = falseFn;
tileImage.onerror = falseFn;
tileImage.src = emptyImageUrl;
}
};
_proto2.onTileLoad = function onTileLoad(tileImage, tileInfo) {
this.removeTileLoading(tileInfo);
this._tileQueue.push({
tileInfo: tileInfo,
tileData: tileImage
});
this._tileQueueIds.add(tileInfo.id);
this.setToRedraw();
};
_proto2.removeTileLoading = function removeTileLoading(tileInfo) {
delete this.tilesLoading[tileInfo.id];
this.setToRedraw();
};
_proto2._consumeTileQueue = function _consumeTileQueue() {
var count = 0;
var limit = this.layer.options['tileLimitPerFrame'];
var queue = this._tileQueue;
while (queue.length && (limit <= 0 || count < limit)) {
var _queue$shift = queue.shift(),
tileData = _queue$shift.tileData,
tileInfo = _queue$shift.tileInfo;
if (!this._tileQueueIds.has(tileInfo.id)) {
continue;
}
this._tileQueueIds.delete(tileInfo.id);
if (!this.checkTileInQueue(tileData, tileInfo)) {
continue;
}
this.consumeTile(tileData, tileInfo);
count++;
}
};
_proto2._computeAvgTileAltitude = function _computeAvgTileAltitude() {
var sumMin = 0;
var sumMax = 0;
var count = 0;
for (var p in this.tilesInView) {
var info = this.tilesInView[p] && this.tilesInView[p].info;
if (info) {
sumMin += info.minAltitude || 0;
sumMax += info.maxAltitude || 0;
count++;
}
}
this.avgMinAltitude = sumMin / count;
this.avgMaxAltitude = sumMax / count;
};
_proto2.checkTileInQueue = function checkTileInQueue() {
return true;
};
_proto2.consumeTile = function consumeTile(tileImage, tileInfo) {
if (!this.layer) {
return;
}
if (!this.tilesInView) {
return;
}
var e = {
tile: tileInfo,
tileImage: tileImage
};
tileImage = e.tileImage;
this.resetTileLoadTime(tileImage);
this.removeTileLoading(tileInfo);
this._addTileToCache(tileInfo, tileImage);
this.layer.fire('tileload', e);
this.setToRedraw();
};
_proto2.resetTileLoadTime = function resetTileLoadTime(tileImage) {
tileImage.loadTime = now();
};
_proto2.onTileError = function onTileError(tileImage, tileInfo) {
if (!this.layer) {
return;
}
tileImage.onerrorTick = tileImage.onerrorTick || 0;
var tileRetryCount = this.layer.options['tileRetryCount'];
if (tileRetryCount > tileImage.onerrorTick) {
tileImage.onerrorTick++;
this._fetchImage(tileImage, tileInfo);
this.removeTileLoading(tileInfo);
return;
}
var errorUrl = this.layer.options['errorUrl'];
if (errorUrl) {
if (tileImage instanceof Image && tileImage.src !== errorUrl) {
tileImage.src = errorUrl;
this.removeTileLoading(tileInfo);
return;
} else {
tileImage = new Image();
tileImage.src = errorUrl;
}
}
tileImage = tileImage instanceof Image ? tileImage : BLANK_IMAGE;
this.abortTileLoading(tileImage, tileInfo);
tileImage.loadTime = 0;
this.removeTileLoading(tileInfo);
this._addTileToCache(tileInfo, tileImage);
this.setToRedraw();
this.layer.fire('tileerror', {
tile: tileInfo
});
};
_proto2.drawTile = function drawTile(tileInfo, tileImage) {
if (!tileImage || !this.getMap()) {
return;
}
var extent2d = tileInfo.extent2d,
offset = tileInfo.offset;
var point = TILE_POINT.set(extent2d.xmin - offset[0], extent2d.ymax - offset[1]),
tileZoom = tileInfo.z,
tileId = tileInfo.id;
var map = this.getMap(),
zoom = map.getZoom(),
ctx = this.context,
cp = map._pointAtResToContainerPoint(point, tileInfo.res, 0, TEMP_POINT$5),
bearing = map.getBearing(),
transformed = bearing || zoom !== tileZoom;
var opacity = this.getTileOpacity(tileImage, tileInfo);
var alpha = ctx.globalAlpha;
if (opacity < 1) {
ctx.globalAlpha = opacity;
}
if (!transformed) {
cp._round();
}
var x = cp.x,
y = cp.y;
var w = tileInfo.extent2d.xmax - tileInfo.extent2d.xmin;
var h = tileInfo.extent2d.ymax - tileInfo.extent2d.ymin;
var layer = this.layer;
var bufferPixel = layer ? layer.options.bufferPixel : 0;
if (transformed) {
ctx.save();
ctx.translate(x, y);
if (bearing) {
ctx.rotate(-bearing * Math.PI / 180);
}
w += bufferPixel;
h += bufferPixel;
var res = map._getResolution();
if (res !== tileInfo.res) {
var scale = tileInfo.res / res;
ctx.scale(scale, scale);
}
x = y = 0;
}
Canvas.image(ctx, tileImage, x, y, w, h);
if (this.layer.options['debug']) {
var color = this.layer.options['debugOutline'];
ctx.save();
ctx.strokeStyle = color;
ctx.fillStyle = color;
ctx.strokeWidth = 10;
ctx.font = '20px monospace';
var _point = new Point(x, y);
Canvas.rectangle(ctx, _point, {
width: w,
height: h
}, 1, 0);
Canvas.fillText(ctx, this.getDebugInfo(tileId), _point._add(32, h - 14), color);
Canvas.drawCross(ctx, x + w / 2, y + h / 2, 2, color);
ctx.restore();
}
if (transformed) {
ctx.restore();
}
if (ctx.globalAlpha !== alpha) {
ctx.globalAlpha = alpha;
}
this.setCanvasUpdated();
};
_proto2.getDebugInfo = function getDebugInfo(tileId) {
var xyz = tileId.split('_');
var length = xyz.length;
return xyz[length - 3] + '/' + xyz[length - 2] + '/' + xyz[length - 1];
};
_proto2.findChildTiles = function findChildTiles(info) {
return this._findChildTiles(info);
};
_proto2._findChildTiles = function _findChildTiles(info) {
var layer = this._getLayerOfTile(info.layer);
var terrainTileMode = layer && layer.options['terrainTileMode'] && layer._isPyramidMode();
if (!layer || !layer.options['background'] && !terrainTileMode || info.z > this.layer.getMaxZoom()) {
return EMPTY_ARRAY$2;
}
var map = this.getMap();
var children = [];
if (layer._isPyramidMode()) {
if (!terrainTileMode) {
var _layer = this._getLayerOfTile(info.layer);
var _zoomDiff = 2;
var _cx = info.x * 2;
var _cy = info.y * 2;
var _cz = info.z + 1;
var queue = [];
for (var j = 0; j < 2; j++) {
for (var jj = 0; jj < 2; jj++) {
queue.push(_cx + j, _cy + jj, _cz);
}
}
while (queue.length) {
var z = queue.pop();
var y = queue.pop();
var x = queue.pop();
var id = _layer._getTileId(x, y, z, info.layer);
var canVisit = z + 1 <= info.z + _zoomDiff;
var tile = this.tileCache.getAndRemove(id);
if (tile) {
if (this.isValidCachedTile(tile)) {
children.push(tile);
this.tileCache.add(id, tile);
} else if (canVisit) {
for (var _j = 0; _j < 2; _j++) {
for (var _jj = 0; _jj < 2; _jj++) {
queue.push(x * 2 + _j, y * 2 + _jj, z + 1);
}
}
}
} else if (canVisit) {
for (var _j2 = 0; _j2 < 2; _j2++) {
for (var _jj2 = 0; _jj2 < 2; _jj2++) {
queue.push(x * 2 + _j2, y * 2 + _jj2, z + 1);
}
}
}
}
return children;
}
var missedTiles;
if (terrainTileMode) {
missedTiles = [];
}
var cx = info.x * 2;
var cy = info.y * 2;
var cz = info.z + 1;
var candidates = [];
for (var i = 0; i < 2; i++) {
for (var ii = 0; ii < 2; ii++) {
var _x = cx + i;
var _y = cy + ii;
var _z = cz;
var _id = layer._getTileId(_x, _y, _z, info.layer);
var _tile2 = this.tileCache.getAndRemove(_id);
if (_tile2 && this.isValidCachedTile(_tile2)) {
children.push(_tile2);
this.tileCache.add(_id, _tile2);
candidates.push(null);
} else {
candidates.push(_id);
}
}
}
if (children.length < 4) {
var index = 0;
for (var _i2 = 0; _i2 < 2; _i2++) {
for (var _ii = 0; _ii < 2; _ii++) {
var _id2 = candidates[index++];
if (!_id2) {
continue;
}
var _x2 = cx + _i2;
var _y2 = cy + _ii;
var _z2 = cz;
var childrenCount = children.length;
var childCandidates = [];
for (var _j3 = 0; _j3 < 2; _j3++) {
for (var _jj3 = 0; _jj3 < 2; _jj3++) {
var xx = _x2 * 2 + _j3;
var yy = _y2 * 2 + _jj3;
var zz = _z2 + 1;
var _id3 = layer._getTileId(xx, yy, zz, info.layer);
var childTile = this.tileCache.getAndRemove(_id3);
if (childTile && this.isValidCachedTile(childTile)) {
children.push(childTile);
this.tileCache.add(_id3, childTile);
childCandidates.push(null);
} else {
childCandidates.push(_id3);
}
}
}
if (!terrainTileMode) {
continue;
}
if (children.length - childrenCount < 4) {
var childTileInfo = layer.tileInfoCache.get(_id2) || layer._createChildNode(info, _i2, _ii, [0, 0], _id2);
if (children.length - childrenCount === 0) {
missedTiles.push(childTileInfo);
} else {
var _index = 0;
for (var _j4 = 0; _j4 < 2; _j4++) {
for (var _jj4 = 0; _jj4 < 2; _jj4++) {
var _id4 = childCandidates[_index++];
if (!_id4) {
continue;
}
var grandsonTileInfo = this.layer.tileInfoCache.get(_id4) || layer._createChildNode(childTileInfo, _j4, _jj4, [0, 0], _id4);
missedTiles.push(grandsonTileInfo);
}
}
}
}
}
}
}
return terrainTileMode ? {
tiles: children,
missedTiles: missedTiles
} : children;
}
var zoomDiff = 1;
var res = info.res;
var min = info.extent2d.getMin(),
max = info.extent2d.getMax(),
pmin = layer._project(map._pointToPrjAtRes(min, res, TEMP_POINT1$2), TEMP_POINT1$2),
pmax = layer._project(map._pointToPrjAtRes(max, res, TEMP_POINT2$2), TEMP_POINT2$2);
for (var _i3 = 1; _i3 < zoomDiff; _i3++) {
this._findChildTilesAt(children, pmin, pmax, layer, info.z + _i3);
}
return children;
};
_proto2._findChildTilesAt = function _findChildTilesAt(children, pmin, pmax, layer, childZoom) {
var layerId = layer.getId(),
res = layer.getSpatialReference().getResolution(childZoom);
if (!res) {
return;
}
var dmin = layer._getTileConfig().getTileIndex(pmin, res),
dmax = layer._getTileConfig().getTileIndex(pmax, res);
var sx = Math.min(dmin.idx, dmax.idx),
ex = Math.max(dmin.idx, dmax.idx);
var sy = Math.min(dmin.idy, dmax.idy),
ey = Math.max(dmin.idy, dmax.idy);
var id, tile;
for (var i = sx; i < ex; i++) {
for (var ii = sy; ii < ey; ii++) {
id = layer._getTileId(i, ii, childZoom, layerId);
tile = this.tileCache.getAndRemove(id);
if (tile) {
if (this.isValidCachedTile(tile)) {
children.push(tile);
this.tileCache.add(id, tile);
}
}
}
}
};
_proto2.findParentTile = function findParentTile(info, targetDiff) {
return this._findParentTile(info, targetDiff);
};
_proto2._findParentTile = function _findParentTile(info, targetDiff) {
var map = this.getMap(),
layer = this._getLayerOfTile(info.layer);
if (!layer || !layer.options['background'] && !layer.options['terrainTileMode']) {
return null;
}
var minZoom = layer.getMinZoom();
var zoomDiff = targetDiff || info.z - minZoom;
if (layer._isPyramidMode()) {
var endZoom = info.z - zoomDiff;
for (var z = info.z - 1; z >= endZoom; z--) {
var diff = info.z - z;
var scale = Math.pow(2, diff);
var x = Math.floor(info.x / scale);
var y = Math.floor(info.y / scale);
var id = void 0;
if (z === info.z - 1) {
id = info.parent;
} else {
id = layer._getTileId(x, y, z, info.layer);
}
var tile = this.tileCache.getAndRemove(id);
if (tile) {
if (this.isValidCachedTile(tile)) {
this.tileCache.add(id, tile);
return tile;
}
}
}
return null;
}
var sr = layer.getSpatialReference();
var d = sr.getZoomDirection();
var res = info.res;
var center = info.extent2d.getCenter(),
prj = layer._project(map._pointToPrjAtRes(center, res));
for (var _diff = 1; _diff <= zoomDiff; _diff++) {
var _z3 = info.z - d * _diff;
var _res = sr.getResolution(_z3);
if (!_res) continue;
var tileIndex = layer._getTileConfig().getTileIndex(prj, _res);
var _id5 = layer._getTileId(tileIndex.x, tileIndex.y, _z3, info.layer);
var _tile3 = this.tileCache.getAndRemove(_id5);
if (_tile3) {
this.tileCache.add(_id5, _tile3);
return _tile3;
}
}
return null;
};
_proto2.isValidCachedTile = function isValidCachedTile(tile) {
return !!tile.image;
};
_proto2.isTileComplete = function isTileComplete() {
return true;
};
_proto2._getLayerOfTile = function _getLayerOfTile(layerId) {
return this.layer.getChildLayer ? this.layer.getChildLayer(layerId) : this.layer;
};
_proto2.getCachedTile = function getCachedTile(tile, isParent) {
var tileId = tile.id;
var tilesInView = this.tilesInView;
var cached = this.tileCache.getAndRemove(tileId);
if (cached) {
if (!isParent) {
tilesInView[tileId] = cached;
}
var tilesLoading = this.tilesLoading;
if (tilesLoading && tilesLoading[tileId]) {
this.markCurrent(tilesLoading[tileId], false);
var _tilesLoading$tileId = tilesLoading[tileId],
image = _tilesLoading$tileId.image,
info = _tilesLoading$tileId.info;
this.abortTileLoading(image, info);
delete tilesLoading[tileId];
}
} else {
cached = tilesInView[tileId];
}
if (cached) {
cached.current = true;
if (this.isValidCachedTile(cached)) {
this.tileCache.add(tileId, cached);
}
}
return cached;
};
_proto2._addTileToCache = function _addTileToCache(tileInfo, tileImage) {
if (this.isValidCachedTile({
info: tileInfo,
image: tileImage
})) {
this.tilesInView[tileInfo.id] = {
image: tileImage,
current: true,
info: tileInfo
};
}
};
_proto2.getTileOpacity = function getTileOpacity(tileImage, tileInfo) {
var opacity = this._getTileFadingOpacity(tileImage);
if (this.layer.getChildLayer) {
var childLayer = this.layer.getLayer(tileInfo.layer);
if (childLayer) {
opacity *= childLayer.options['opacity'];
}
}
return opacity;
};
_proto2._getTileFadingOpacity = function _getTileFadingOpacity(tileImage) {
if (!this.layer.options['fadeAnimation'] || !tileImage.loadTime) {
return 1;
}
return Math.min(1, (now() - tileImage.loadTime) / this.layer.options['fadeDuration']);
};
_proto2.onRemove = function onRemove() {
this.clear();
delete this.tileCache;
delete this._tilePlaceHolder;
delete this._tileZoom;
_CanvasRenderer.prototype.onRemove.call(this);
};
_proto2.markCurrent = function markCurrent(tile, isCurrent) {
tile.current = isCurrent;
};
_proto2.markTiles = function markTiles() {
var a = 0,
b = 0;
if (this.tilesLoading) {
for (var p in this.tilesLoading) {
this.markCurrent(this.tilesLoading[p], false);
a++;
}
}
if (this.tilesInView) {
for (var _p in this.tilesInView) {
this.markCurrent(this.tilesInView[_p], false);
b++;
}
}
return [a, b];
};
_proto2.retireTiles = function retireTiles(force) {
for (var i in this.tilesLoading) {
var tile = this.tilesLoading[i];
if (force || !tile.current) {
if (tile.image) {
this.abortTileLoading(tile.image, tile.info);
}
this.deleteTile(tile);
this.removeTileLoading(tile.info);
}
}
for (var _i4 in this.tilesInView) {
var _tile4 = this.tilesInView[_i4];
if (!_tile4.current) {
delete this.tilesInView[_i4];
if (!this.tileCache.has(_i4)) {
this.deleteTile(_tile4);
}
}
}
};
_proto2.deleteTile = function deleteTile(tile) {
if (!tile || !tile.image) {
return;
}
var tileId = tile.info.id;
if (this._tileQueueIds.has(tileId)) {
this._tileQueueIds.delete(tileId);
}
if (tile.image.close) {
tile.image.close();
}
if (tile.image instanceof Image) {
tile.image.onload = null;
tile.image.onerror = null;
}
};
_proto2._generatePlaceHolder = function _generatePlaceHolder(res) {
var map = this.getMap();
var placeholder = this.layer.options['placeholder'];
if (!placeholder || map.getPitch()) {
return null;
}
var tileSize = this.layer.getTileSize(),
scale = res / map._getResolution(),
canvas = this._tilePlaceHolder = this._tilePlaceHolder || Canvas.createCanvas(1, 1, map.CanvasClass);
canvas.width = tileSize.width * scale;
canvas.height = tileSize.height * scale;
if (isFunction(placeholder)) {
placeholder(canvas);
} else {
defaultPlaceholder(canvas);
}
return canvas;
};
_proto2.setTerrainHelper = function setTerrainHelper(helper) {
this._terrainHelper = helper;
};
return TileLayerCanvasRenderer;
}(CanvasRenderer);
TileLayer.registerRenderer('canvas', TileLayerCanvasRenderer);
function falseFn() {
return false;
}
function defaultPlaceholder(canvas) {
var ctx = canvas.getContext('2d'),
cw = canvas.width,
ch = canvas.height,
w = cw / 16,
h = ch / 16;
ctx.beginPath();
for (var i = 0; i < 16; i++) {
ctx.moveTo(0, i * h);
ctx.lineTo(cw, i * h);
ctx.moveTo(i * w, 0);
ctx.lineTo(i * w, ch);
}
ctx.strokeStyle = 'rgba(180, 180, 180, 0.1)';
ctx.lineWidth = 1;
ctx.stroke();
ctx.beginPath();
var path = [[0, 0], [cw, 0], [0, ch], [cw, ch], [0, 0], [0, ch], [cw, 0], [cw, ch], [0, ch / 2], [cw, ch / 2], [cw / 2, 0], [cw / 2, ch]];
for (var _i5 = 1; _i5 < path.length; _i5 += 2) {
ctx.moveTo(path[_i5 - 1][0], path[_i5 - 1][1]);
ctx.lineTo(path[_i5][0], path[_i5][1]);
}
ctx.lineWidth = 1 * 4;
ctx.stroke();
}
function compareTiles(a, b) {
return Math.abs(this._tileZoom - a.info.z) - Math.abs(this._tileZoom - b.info.z);
}
var TILE_POINT$1 = new Point(0, 0);
var MESH_TO_TEST = {
properties: {}
};
var TileLayerGLRenderer = function (_ImageGLRenderable) {
_inheritsLoose(TileLayerGLRenderer, _ImageGLRenderable);
function TileLayerGLRenderer() {
return _ImageGLRenderable.apply(this, arguments) || this;
}
var _proto = TileLayerGLRenderer.prototype;
_proto.isDrawable = function isDrawable() {
return true;
};
_proto.needToRedraw = function needToRedraw() {
var map = this.getMap();
if (this.isGL() && !map.getPitch() && map.isZooming() && !map.isMoving() && !map.isRotating()) {
return true;
}
return _ImageGLRenderable.prototype.needToRedraw.call(this);
};
_proto.onDrawTileStart = function onDrawTileStart(context, parentContext) {
var gl = this.gl;
gl.enable(gl.DEPTH_TEST);
gl.depthFunc(gl.LEQUAL);
gl.enable(gl.POLYGON_OFFSET_FILL);
gl.enable(gl.STENCIL_TEST);
gl.stencilOp(gl.KEEP, gl.KEEP, gl.REPLACE);
var depthMask = !!this.layer.options['depthMask'];
gl.depthMask(depthMask);
if (parentContext && parentContext.renderTarget) {
var fbo = parentContext.renderTarget.fbo;
if (fbo) {
var framebuffer = parentContext.renderTarget.getFramebuffer(fbo);
gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
}
}
};
_proto.onDrawTileEnd = function onDrawTileEnd(context, parentContext) {
var gl = this.gl;
if (parentContext && parentContext.renderTarget) {
var fbo = parentContext.renderTarget.fbo;
if (fbo) {
gl.bindFramebuffer(gl.FRAMEBUFFER, null);
}
}
};
_proto.drawTile = function drawTile(tileInfo, tileImage, parentContext) {
if (parentContext && parentContext.sceneFilter) {
if (!parentContext.sceneFilter(MESH_TO_TEST)) {
return;
}
}
var map = this.getMap();
if (!tileInfo || !map || !tileImage) {
return;
}
var scale = tileInfo._glScale = tileInfo._glScale || tileInfo.res / map.getGLRes();
var w = tileInfo.extent2d.xmax - tileInfo.extent2d.xmin;
var h = tileInfo.extent2d.ymax - tileInfo.extent2d.ymin;
if (tileInfo.cache !== false) {
this._bindGLBuffer(tileImage, w, h);
}
if (!this.isGL()) {
_ImageGLRenderable.prototype.drawTile.call(this, tileInfo, tileImage);
return;
}
var extent2d = tileInfo.extent2d,
offset = tileInfo.offset;
var point = TILE_POINT$1.set(extent2d.xmin - offset[0], tileInfo.extent2d.ymax - offset[1]);
var x = point.x * scale,
y = point.y * scale;
var opacity = this.getTileOpacity(tileImage, tileInfo);
var debugInfo = null;
if (this.layer.options['debug']) {
debugInfo = this.getDebugInfo(tileInfo.id);
}
var gl = this.gl;
gl.stencilFunc(gl.LEQUAL, Math.abs(this.getCurrentTileZoom() - tileInfo.z), 0xFF);
var layerPolygonOffset = this.layer.getPolygonOffset();
var polygonOffset = this.drawingCurrentTiles ? layerPolygonOffset : layerPolygonOffset + 1;
gl.polygonOffset(polygonOffset, polygonOffset);
this.drawGLImage(tileImage, x, y, w, h, scale, opacity, debugInfo);
if (this._getTileFadingOpacity(tileImage) < 1) {
this.setToRedraw();
} else {
this.setCanvasUpdated();
}
};
_proto._bindGLBuffer = function _bindGLBuffer(image, w, h) {
if (!image.glBuffer) {
image.glBuffer = this.bufferTileData(0, 0, w, h);
}
};
_proto.loadTileImage = function loadTileImage(tileImage, url) {
var crossOrigin = this.layer.options['crossOrigin'];
tileImage.crossOrigin = crossOrigin !== null ? crossOrigin : '';
tileImage.src = url;
return;
};
_proto.onCanvasCreate = function onCanvasCreate() {
if (!this.canvas.gl || !this.canvas.gl.wrap) {
this.createCanvas2();
}
};
_proto.createContext = function createContext() {
_ImageGLRenderable.prototype.createContext.call(this);
this.createGLContext();
};
_proto.resizeCanvas = function resizeCanvas(canvasSize) {
if (!this.canvas) {
return;
}
_ImageGLRenderable.prototype.resizeCanvas.call(this, canvasSize);
this.resizeGLCanvas();
};
_proto.clearCanvas = function clearCanvas() {
if (!this.canvas) {
return;
}
_ImageGLRenderable.prototype.clearCanvas.call(this);
this.clearGLCanvas();
};
_proto.getCanvasImage = function getCanvasImage() {
if (!this.isGL() || !this.canvas2) {
return _ImageGLRenderable.prototype.getCanvasImage.call(this);
}
var img = _ImageGLRenderable.prototype.getCanvasImage.call(this);
if (img) {
img.image = this.canvas2;
}
return img;
};
_proto.isGL = function isGL() {
if (this.canvas.gl && this.canvas.gl.wrap) {
return true;
}
var map = this.getMap();
return map && (map.getPitch() || map.getBearing()) || this.layer && !!this.layer.options['fragmentShader'];
};
_proto.deleteTile = function deleteTile(tile) {
_ImageGLRenderable.prototype.deleteTile.call(this, tile);
if (tile && tile.image) {
this.disposeImage(tile.image);
}
delete tile.image;
};
_proto.onRemove = function onRemove() {
_ImageGLRenderable.prototype.onRemove.call(this);
this.removeGLCanvas();
};
return TileLayerGLRenderer;
}(ImageGLRenderable(TileLayerCanvasRenderer));
TileLayer.registerRenderer('gl', TileLayerGLRenderer);
function _loadTile(tile) {
var tileSize = this.layer.getTileSize(),
canvasClass = this.canvas.constructor,
map = this.getMap();
var r = map.getDevicePixelRatio();
var tileCanvas = Canvas.createCanvas(tileSize['width'] * r, tileSize['height'] * r, canvasClass);
tileCanvas['layer'] = this.layer;
var me = this;
var point = new Point(tile['extent2d'].xmin, tile['extent2d'].ymax);
var extent = new Extent(map.pointToCoordinate(point), map.pointToCoordinate(point.add(tileSize.width, tileSize.height)), map.getProjection());
this.layer.drawTile(tileCanvas, {
'url': tile['url'],
'point': point,
'center': map.pointToCoordinate(point.add(tileSize['width'] / 2, tileSize['height'] / 2)),
'extent': extent,
'z': tile['z'],
'x': tile['x'],
'y': tile['y']
}, function (error) {
if (error) {
me.onTileError(tileCanvas, tile);
return;
}
me.onTileLoad(tileCanvas, tile);
});
return tileCanvas;
}
var CanvasRenderer$1 = function (_TileLayerCanvasRende) {
_inheritsLoose(CanvasRenderer, _TileLayerCanvasRende);
function CanvasRenderer() {
return _TileLayerCanvasRende.apply(this, arguments) || this;
}
var _proto = CanvasRenderer.prototype;
_proto.loadTile = function loadTile() {
return _loadTile.apply(this, arguments);
};
return CanvasRenderer;
}(TileLayerCanvasRenderer);
var GLRenderer = function (_TileLayerGLRenderer) {
_inheritsLoose(GLRenderer, _TileLayerGLRenderer);
function GLRenderer() {
return _TileLayerGLRenderer.apply(this, arguments) || this;
}
var _proto2 = GLRenderer.prototype;
_proto2.loadTile = function loadTile() {
return _loadTile.apply(this, arguments);
};
return GLRenderer;
}(TileLayerGLRenderer);
CanvasTileLayer.registerRenderer('canvas', CanvasRenderer$1);
CanvasTileLayer.registerRenderer('gl', GLRenderer);
var quadVertices = typeof Int8Array !== 'undefined' ? new Int8Array([-1, 1, 0, -1, -1, 0, 1, 1, 0, 1, -1, 0]) : [];
var vert = "\n attribute vec3 a_position;\n uniform mat4 transform;\n\n void main()\n {\n gl_Position = transform * vec4(a_position, 1.0);\n }\n";
var frag = "\n precision mediump float;\n uniform vec3 color;\n void main()\n {\n gl_FragColor = vec4(color, 1.0);\n }\n";
var QuadStencil = function () {
function QuadStencil(gl, vertices, debug) {
this.gl = gl;
this.quadVertices = vertices || quadVertices;
this.attributes = ['a_position', 3, getType(vertices)];
this.debug = debug;
}
var _proto = QuadStencil.prototype;
_proto.start = function start() {
var gl = this.gl;
gl.enable(gl.STENCIL_TEST);
gl.stencilMask(0xFF);
gl.stencilOp(gl.KEEP, gl.REPLACE, gl.REPLACE);
gl.depthMask(false);
this._save();
if (!this.buffer) {
this._createBuffer();
this._createProgram();
}
gl.useProgram(this.program);
gl.bindBuffer(gl.ARRAY_BUFFER, this.buffer);
enableVertexAttrib(gl, this.program, this.attributes);
if (!this.transformLoc) {
this.transformLoc = gl.getUniformLocation(this.program, 'transform');
}
if (!this.colorLoc) {
this.colorLoc = gl.getUniformLocation(this.program, 'color');
}
if (this.debug) {
return;
}
gl.colorMask(false, false, false, false);
};
_proto.end = function end() {
var gl = this.gl;
gl.depthMask(true);
this._restore();
if (this.debug) {
return;
}
gl.colorMask(true, true, true, true);
};
_proto.draw = function draw(transform) {
var gl = this.gl;
gl.uniformMatrix4fv(this.transformLoc, false, transform);
gl.uniform3fv(this.colorLoc, [Math.random(), Math.random(), Math.random()]);
gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
};
_proto.remove = function remove() {
var gl = this.gl;
if (this.buffer) {
gl.deleteBuffer(this.buffer);
}
if (this.program) {
gl.deleteShader(this.program.fragmentShader);
gl.deleteShader(this.program.vertexShader);
gl.deleteProgram(this.program);
}
delete this.transformLoc;
delete this.gl;
return this;
};
_proto.stencilMask = function stencilMask(mask) {
this.gl.stencilMask(mask);
return this;
};
_proto.stencilFunc = function stencilFunc(func, ref, mask) {
this.ref = ref;
this.gl.stencilFunc(func, ref, mask);
return this;
};
_proto.stencilOp = function stencilOp(fail, zfail, zpass) {
this.gl.stencilOp(fail, zfail, zpass);
return this;
};
_proto.resetFunc = function resetFunc() {
this.ref = 1;
this.gl.stencilFunc(this.gl.ALWAYS, 1, 0xFF);
return this;
};
_proto._save = function _save() {
var gl = this.gl;
this._savedProgram = gl.program;
};
_proto._restore = function _restore() {
var gl = this.gl;
gl.program = this._savedProgram;
if (gl.program) {
gl.useProgram(gl.program);
}
};
_proto._createBuffer = function _createBuffer() {
var gl = this.gl;
this.buffer = gl.createBuffer();
if (!this.buffer) {
throw new Error('Failed to create the buffer object');
}
gl.bindBuffer(gl.ARRAY_BUFFER, this.buffer);
gl.bufferData(gl.ARRAY_BUFFER, this.quadVertices, gl.STATIC_DRAW);
};
_proto._createProgram = function _createProgram() {
var _createProgram2 = createProgram(this.gl, vert, frag),
program = _createProgram2.program,
vertexShader = _createProgram2.vertexShader,
fragmentShader = _createProgram2.fragmentShader;
program.vertexShader = vertexShader;
program.fragmentShader = fragmentShader;
this.program = program;
};
return QuadStencil;
}();
function getType(arr) {
if (arr instanceof Float32Array) {
return 'FLOAT';
} else if (arr instanceof Int16Array) {
return 'SHORT';
} else if (arr instanceof Uint16Array) {
return 'UNSIGNED_SHORT';
} else if (arr instanceof Int8Array) {
return 'BYTE';
} else if (arr instanceof Uint8Array || arr instanceof Uint8ClampedArray) {
return 'UNSIGNED_BYTE';
}
return 'FLOAT';
}
var OverlayLayerRenderer = function (_CanvasRenderer) {
_inheritsLoose(OverlayLayerRenderer, _CanvasRenderer);
function OverlayLayerRenderer() {
return _CanvasRenderer.apply(this, arguments) || this;
}
var _proto = OverlayLayerRenderer.prototype;
_proto.checkResources = function checkResources() {
var geometries = this._geosToCheck || [];
if (!this._resourceChecked && this.layer._geoList) {
pushIn(geometries, this.layer._geoList);
}
if (!isArrayHasData(geometries)) {
return [];
}
var resources = [];
var cache = {};
for (var i = geometries.length - 1; i >= 0; i--) {
var geo = geometries[i];
var res = geo._getExternalResources();
if (!res.length) {
continue;
}
if (!this.resources) {
resources.push.apply(resources, res);
} else {
for (var _i = 0; _i < res.length; _i++) {
var url = res[_i][0];
if (!this.resources.isResourceLoaded(res[_i]) && !cache[url]) {
resources.push(res[_i]);
cache[url] = 1;
}
}
}
}
this._resourceChecked = true;
delete this._geosToCheck;
return resources;
};
_proto.render = function render() {
this.layer._sortGeometries();
return _CanvasRenderer.prototype.render.apply(this, arguments);
};
_proto._addGeoToCheckRes = function _addGeoToCheckRes(res) {
if (!res) {
return;
}
if (!Array.isArray(res)) {
res = [res];
}
if (!this._geosToCheck) {
this._geosToCheck = [];
}
pushIn(this._geosToCheck, res);
};
_proto.onGeometryAdd = function onGeometryAdd(geometries) {
this._addGeoToCheckRes(geometries);
redraw(this);
};
_proto.onGeometryRemove = function onGeometryRemove() {
redraw(this);
};
_proto.onGeometrySymbolChange = function onGeometrySymbolChange(e) {
this._addGeoToCheckRes(e.target);
redraw(this);
};
_proto.onGeometryShapeChange = function onGeometryShapeChange() {
redraw(this);
};
_proto.onGeometryPositionChange = function onGeometryPositionChange() {
redraw(this);
};
_proto.onGeometryZIndexChange = function onGeometryZIndexChange() {
redraw(this);
};
_proto.onGeometryShow = function onGeometryShow() {
redraw(this);
};
_proto.onGeometryHide = function onGeometryHide() {
redraw(this);
};
_proto.onGeometryPropertiesChange = function onGeometryPropertiesChange() {
redraw(this);
};
return OverlayLayerRenderer;
}(CanvasRenderer);
function redraw(renderer) {
if (renderer.layer.options['drawImmediate']) {
renderer.render();
}
renderer.setToRedraw();
}
var TEMP_EXTENT$9 = new PointExtent();
var TEMP_VEC3 = [];
var TEMP_FIXEDEXTENT = new PointExtent();
var PLACEMENT_CENTER = 'center';
var tempCollisionIndex = new CollisionIndex();
function clearCanvas(canvas) {
if (!canvas) {
return null;
}
var ctx = canvas.getContext('2d');
ctx.clearRect(0, 0, canvas.width, canvas.height);
return ctx;
}
function isDebug(layer) {
return layer && layer.options.progressiveRender && layer.options.progressiveRenderDebug;
}
var VectorLayerRenderer = function (_OverlayLayerCanvasRe) {
_inheritsLoose(VectorLayerRenderer, _OverlayLayerCanvasRe);
function VectorLayerRenderer() {
return _OverlayLayerCanvasRe.apply(this, arguments) || this;
}
var _proto = VectorLayerRenderer.prototype;
_proto.setToRedraw = function setToRedraw() {
_OverlayLayerCanvasRe.prototype.setToRedraw.call(this);
this._resetProgressiveRender();
return this;
};
_proto._geoIsCollision = function _geoIsCollision(geo, collisionIndex) {
if (!geo) {
return false;
}
var collision = geo.options.collision;
if (!collision) {
return false;
}
if (geo.isPoint && geo.getContainerExtent) {
if (!geo.bbox) {
geo.bbox = [0, 0, 0, 0];
}
var bufferSize = this.layer.options['collisionBufferSize'];
var extent = geo.getContainerExtent();
if (!extent) {
return false;
}
geo.bbox[0] = extent.xmin - bufferSize;
geo.bbox[1] = extent.ymin - bufferSize;
geo.bbox[2] = extent.xmax + bufferSize;
geo.bbox[3] = extent.ymax + bufferSize;
if (collisionIndex.collides(geo.bbox)) {
return true;
}
collisionIndex.insertBox(geo.bbox);
}
return false;
};
_proto.getImageData = function getImageData() {
if (!this._lastRenderTime || now() - this._lastRenderTime < 32) {
return null;
}
if (!this.context || !this.context.canvas) {
return null;
}
if (!this._imageData) {
var _this$context$canvas = this.context.canvas,
width = _this$context$canvas.width,
height = _this$context$canvas.height;
try {
this._imageData = this.context.getImageData(0, 0, width, height);
} catch (error) {
console.warn('hit detect failed with tainted canvas, some geometries have external resources in another domain:\n', error);
}
}
return this._imageData;
};
_proto.clearImageData = function clearImageData() {
this._imageData = null;
delete this._imageData;
this._lastRenderTime = now();
};
_proto.checkResources = function checkResources() {
var _this = this;
var resources = _OverlayLayerCanvasRe.prototype.checkResources.apply(this, arguments);
var style = this.layer.getStyle();
if (style) {
if (!Array.isArray(style)) {
style = [style];
}
style.forEach(function (s) {
var res = getExternalResources(s['symbol'], true);
for (var i = 0, l = res.length; i < l; i++) {
if (!_this.resources.isResourceLoaded(res[i])) {
resources.push(res[i]);
}
}
});
}
return resources;
};
_proto.needToRedraw = function needToRedraw() {
if (this.isProgressiveRender() && !this.renderEnd) {
return true;
}
var map = this.getMap();
if (map.isInteracting() && this.layer.options['enableAltitude']) {
return true;
}
if (map.isZooming() && !map.isRotating() && !map.getPitch() && !this._hasPoint && this.layer.constructor === VectorLayer) {
return false;
}
return _OverlayLayerCanvasRe.prototype.needToRedraw.call(this);
};
_proto.draw = function draw() {
if (!this.getMap()) {
return;
}
if (!this.layer.isVisible() || this.layer.isEmpty()) {
this.clearCanvas();
this.completeRender();
return;
}
this.prepareCanvas();
this.drawGeos();
this.completeRender();
};
_proto.isBlank = function isBlank() {
if (!this.context) {
return false;
}
if (this.isProgressiveRender()) {
return false;
}
return !this.context.canvas._drawn;
};
_proto.drawOnInteracting = function drawOnInteracting() {
if (!this._geosToDraw) {
return;
}
this._updateMapStateCache();
this._updateDisplayExtent();
var map = this.getMap();
var count = this.layer.getCount();
var res = this.mapStateCache.resolution;
if (map.isZooming() && map.options['seamlessZoom'] && this._drawnRes !== undefined && res > this._drawnRes * 1.5 && this._geosToDraw.length < count || map.isMoving() || map.isInteracting()) {
this.prepareToDraw();
this._batchConversionMarkers(this.mapStateCache.glRes);
if (!this._onlyHasPoint) {
this._checkGeos();
}
this._drawnRes = res;
}
this._sortByDistanceToCamera(map.cameraPosition);
var _this$layer$options = this.layer.options,
collision = _this$layer$options.collision,
collisionDelay = _this$layer$options.collisionDelay;
if (collision) {
var time = now();
if (!this._lastCollisionTime) {
this._lastCollisionTime = time;
}
if (time - this._lastCollisionTime <= collisionDelay) {
this._geosToDraw = this._lastGeosToDraw || this._geosToDraw;
} else {
this._collidesGeos();
this._lastCollisionTime = time;
}
}
for (var i = 0, l = this._geosToDraw.length; i < l; i++) {
var geo = this._geosToDraw[i];
if (!geo._isCheck) {
if (!geo.isVisible()) {
delete geo._cPoint;
delete geo._inCurrentView;
continue;
}
}
geo._paint(this._displayExtent);
this._geosToDraw[i]._cPoint = undefined;
this._geosToDraw[i]._inCurrentView = undefined;
}
this.clearImageData();
this._lastGeosToDraw = this._geosToDraw;
if (isDebug(this.layer)) {
console.log('progressiveRender on drawOnInteracting page:', this.page);
}
};
_proto.show = function show() {
this.layer.forEach(function (geo) {
geo._repaint();
});
_OverlayLayerCanvasRe.prototype.show.apply(this, arguments);
};
_proto.forEachGeo = function forEachGeo(fn, context) {
this.layer.forEach(fn, context);
};
_proto._checkGeos = function _checkGeos() {
var geos = this._getCurrentNeedRenderGeos();
for (var i = 0, len = geos.length; i < len; i++) {
this.checkGeo(geos[i]);
}
return this;
};
_proto.drawGeos = function drawGeos() {
this._drawSnapshot();
this._updateMapStateCache();
this._drawnRes = this.mapStateCache.resolution;
this._updateDisplayExtent();
this.prepareToDraw();
this._batchConversionMarkers(this.mapStateCache.glRes);
if (!this._onlyHasPoint) {
this._checkGeos();
}
this._sortByDistanceToCamera(this.getMap().cameraPosition);
this._collidesGeos();
for (var i = 0, len = this._geosToDraw.length; i < len; i++) {
this._geosToDraw[i]._paint();
this._geosToDraw[i]._cPoint = undefined;
this._geosToDraw[i]._inCurrentView = undefined;
}
this.clearImageData();
this._lastGeosToDraw = this._geosToDraw;
if (isDebug(this.layer)) {
console.log('progressiveRender drawGeos page:', this.page);
}
this._snapshot();
this._setDrawGeosDrawTime();
};
_proto.prepareToDraw = function prepareToDraw() {
this.layer._drawTime = now();
this._hasPoint = false;
this._geosToDraw = [];
return this;
};
_proto._setDrawGeosDrawTime = function _setDrawGeosDrawTime() {
var time = now();
var drawTime = this.layer._drawTime;
var painterList = this.getGeoPainterList();
for (var i = 0, len = painterList.length; i < len; i++) {
var painter = painterList[i];
if (painter && painter._setDrawTime) {
painter._setDrawTime(drawTime);
}
}
if (isDebug(this.layer)) {
console.log('_setDrawGeosDrawTime time:', now() - time + 'ms');
}
return this;
};
_proto.checkGeo = function checkGeo(geo) {
if (geo.isPoint && this._onlyHasPoint !== undefined) {
if (geo._inCurrentView) {
this._hasPoint = true;
geo._isCheck = true;
this._geosToDraw.push(geo);
}
return;
}
geo._isCheck = false;
if (!geo || !geo.isVisible() || !geo.getMap() || !geo.getLayer() || !geo.getLayer().isCanvasRender()) {
return;
}
var painter = geo._getPainter();
var inCurrentView = true;
if (geo._inCurrentView) {
inCurrentView = true;
} else if (geo._inCurrentView === false) {
inCurrentView = false;
} else {
var extent2D = painter.get2DExtent(this.resources, TEMP_EXTENT$9);
if (!extent2D || !extent2D.intersects(this._displayExtent)) {
inCurrentView = false;
}
}
if (!inCurrentView) {
return;
}
if (painter.hasPoint()) {
this._hasPoint = true;
}
geo._isCheck = true;
this._geosToDraw.push(geo);
};
_proto._collidesGeos = function _collidesGeos() {
var collision = this.layer.options['collision'];
if (!collision) {
return this;
}
var collisionScope = this.layer.options['collisionScope'];
var map = this.layer.getMap();
var collisionIndex = collisionScope === 'map' ? map.getCollisionIndex() : tempCollisionIndex;
if (collisionIndex === tempCollisionIndex) {
collisionIndex.clear();
}
var geos = this._geosToDraw;
this._geosToDraw = [];
for (var i = 0, len = geos.length; i < len; i++) {
if (this._geoIsCollision(geos[i], collisionIndex)) {
continue;
}
this._geosToDraw.push(geos[i]);
}
return this;
};
_proto.onZoomEnd = function onZoomEnd() {
delete this.canvasExtent2D;
_OverlayLayerCanvasRe.prototype.onZoomEnd.apply(this, arguments);
};
_proto.onRemove = function onRemove() {
this.forEachGeo(function (g) {
g.onHide();
});
delete this._geosToDraw;
delete this.snapshotCanvas;
delete this.pageGeos;
delete this.geoPainterList;
};
_proto.onGeometryPropertiesChange = function onGeometryPropertiesChange(param) {
if (param) {
this.layer._styleGeometry(param['target']);
}
_OverlayLayerCanvasRe.prototype.onGeometryPropertiesChange.call(this, param);
};
_proto._updateDisplayExtent = function _updateDisplayExtent() {
var extent2D = this.canvasExtent2D;
if (this._maskExtent) {
if (!this._maskExtent.intersects(extent2D)) {
this.completeRender();
return;
}
extent2D = extent2D.intersection(this._maskExtent);
}
this._displayExtent = extent2D;
};
_proto.identifyAtPoint = function identifyAtPoint(point, options) {
if (options === void 0) {
options = {};
}
var geometries = this.getGeosForIdentify();
if (!geometries) {
return [];
}
return this.layer._hitGeos(geometries, point, options);
};
_proto._updateMapStateCache = function _updateMapStateCache() {
var map = this.getMap();
var offset = map._pointToContainerPoint(this.southWest)._add(0, -map.height);
var resolution = map.getResolution();
var pitch = map.getPitch();
var bearing = map.getBearing();
var glScale = map.getGLScale();
var glRes = map.getGLRes();
var containerExtent = map.getContainerExtent();
var _2DExtent = map._get2DExtent();
var glExtent = map._get2DExtentAtRes(glRes);
this.mapStateCache = {
resolution: resolution,
pitch: pitch,
bearing: bearing,
glScale: glScale,
glRes: glRes,
_2DExtent: _2DExtent,
glExtent: glExtent,
containerExtent: containerExtent,
offset: offset
};
return this;
};
_proto._batchConversionMarkers = function _batchConversionMarkers(glRes) {
this._onlyHasPoint = undefined;
if (!this._constructorIsThis()) {
return [];
}
var cPoints = [];
var markers = [];
var altitudes = [];
var altitudeCache = {};
var layer = this.layer;
var layerOpts = layer.options;
var layerAltitude = layer.getAltitude ? layer.getAltitude() : 0;
var isCanvasRender = layer.isCanvasRender();
this._onlyHasPoint = true;
var idx = 0;
var geos = this._getCurrentNeedRenderGeos();
for (var i = 0, len = geos.length; i < len; i++) {
var geo = geos[i];
if (geo.isPoint) {
var painter = geo._painter;
if (!painter) {
painter = geo._getPainter();
}
var point = painter.getRenderPoints(PLACEMENT_CENTER)[0][0];
var altitude = layerOpts['enableAltitude'] ? geo._getAltitude() : layerAltitude;
if (altitudeCache[altitude] === undefined) {
altitudeCache[altitude] = painter.getAltitude();
}
cPoints[idx] = point;
altitudes[idx] = altitudeCache[altitude];
markers[idx] = geo;
idx++;
} else {
this._onlyHasPoint = false;
}
}
if (idx === 0) {
return [];
}
var map = this.getMap();
var pts = getPointsResultPts(cPoints, '_pt');
pts = map._pointsAtResToContainerPoints(cPoints, glRes, altitudes, pts);
var containerExtent = map.getContainerExtent();
var xmax = containerExtent.xmax,
ymax = containerExtent.ymax,
xmin = containerExtent.xmin,
ymin = containerExtent.ymin;
var extentCache = {};
for (var _i = 0, _len = markers.length; _i < _len; _i++) {
var _geo = markers[_i];
_geo._cPoint = pts[_i];
if (!_geo._cPoint) {
_geo._inCurrentView = false;
continue;
}
var _pts$_i = pts[_i],
x = _pts$_i.x,
y = _pts$_i.y;
_geo._inCurrentView = x >= xmin && y >= ymin && x <= xmax && y <= ymax;
if (!_geo._inCurrentView) {
var symbolkey = _geo.getSymbolHash();
var fixedExtent = void 0;
if (symbolkey) {
fixedExtent = extentCache[symbolkey] = extentCache[symbolkey] || _geo._painter.getFixedExtent();
} else {
fixedExtent = _geo._painter.getFixedExtent();
}
TEMP_FIXEDEXTENT.set(fixedExtent.xmin, fixedExtent.ymin, fixedExtent.xmax, fixedExtent.ymax);
TEMP_FIXEDEXTENT._add(pts[_i]);
_geo._inCurrentView = TEMP_FIXEDEXTENT.intersects(containerExtent);
}
if (_geo._inCurrentView) {
if (!_geo.isVisible() || !isCanvasRender) {
_geo._inCurrentView = false;
}
if (this._onlyHasPoint && _geo._inCurrentView) {
this._hasPoint = true;
_geo._isCheck = true;
this._geosToDraw.push(_geo);
}
}
}
return pts;
};
_proto._sortByDistanceToCamera = function _sortByDistanceToCamera(cameraPosition) {
if (!this.layer.options['sortByDistanceToCamera']) {
return;
}
if (!this._geosToDraw.length) {
return;
}
var map = this.getMap();
var p = map.distanceToPoint(1000, 0, map.getGLScale()).x;
var meterScale = p / 1000;
var placement = 'center';
this._geosToDraw.sort(function (a, b) {
if (!a.isPoint || !b.isPoint) {
return 0;
}
var painter0 = a._painter;
var painter1 = b._painter;
if (!painter0 || !painter1) {
return 0;
}
var point0 = painter0.getRenderPoints(placement)[0][0];
var point1 = painter1.getRenderPoints(placement)[0][0];
var alt0 = painter0.getAltitude() * meterScale;
var alt1 = painter1.getAltitude() * meterScale;
set$2(TEMP_VEC3, point0.x, point0.y, alt0);
var dist0 = distance(TEMP_VEC3, cameraPosition);
set$2(TEMP_VEC3, point1.x, point1.y, alt1);
var dist1 = distance(TEMP_VEC3, cameraPosition);
return dist1 - dist0;
});
};
_proto._constructorIsThis = function _constructorIsThis() {
return this.constructor === VectorLayerRenderer;
};
_proto.isProgressiveRender = function isProgressiveRender() {
var layer = this.layer;
if (!layer) {
return false;
}
var _ref = layer.options || {},
progressiveRender = _ref.progressiveRender,
collision = _ref.collision;
if (collision) {
return false;
}
return progressiveRender;
};
_proto.getGeosForIdentify = function getGeosForIdentify() {
if (!this.isProgressiveRender()) {
return this._geosToDraw || [];
}
return this.pageGeos || [];
};
_proto.getGeoPainterList = function getGeoPainterList() {
if (!this.isProgressiveRender()) {
var list = [];
var geos = this._geosToDraw || [];
for (var i = 0, len = geos.length; i < len; i++) {
list.push(geos[i]._painter);
}
return list;
}
return this.geoPainterList || [];
};
_proto._checkSnapshotCanvas = function _checkSnapshotCanvas() {
if (!this.isProgressiveRender()) {
delete this.snapshotCanvas;
return null;
}
var canvas = this.canvas;
if (!canvas) {
delete this.snapshotCanvas;
return null;
}
if (!this.snapshotCanvas) {
this.snapshotCanvas = Canvas.createCanvas(1, 1);
}
var snapshotCanvas = this.snapshotCanvas;
var width = canvas.width,
height = canvas.height,
style = canvas.style;
if (snapshotCanvas.width !== width || snapshotCanvas.height !== height) {
snapshotCanvas.width = width;
snapshotCanvas.height = height;
}
if (snapshotCanvas.style.width !== style.width || snapshotCanvas.style.height !== style.height) {
snapshotCanvas.style.width = style.width;
snapshotCanvas.style.height = style.height;
}
return snapshotCanvas;
};
_proto._getCurrentNeedRenderGeos = function _getCurrentNeedRenderGeos() {
var geos = this.layer._geoList || [];
if (!this.isProgressiveRender()) {
return geos;
}
if (this.renderEnd) {
return [];
}
var layer = this.layer;
var progressiveRenderCount = layer.options.progressiveRenderCount;
var pageSize = progressiveRenderCount;
var page = this.page;
var start = (page - 1) * pageSize,
end = page * pageSize;
var pageGeos = geos.slice(start, end);
return pageGeos;
};
_proto._resetProgressiveRender = function _resetProgressiveRender() {
if (isDebug(this.layer)) {
console.log('progressiveRender resetProgressiveRender');
}
this.renderEnd = false;
this.page = 1;
this.pageGeos = [];
this.geoPainterList = [];
this.maxTolerance = 0;
this._clearSnapshotCanvas();
};
_proto._clearSnapshotCanvas = function _clearSnapshotCanvas() {
var snapshotCanvas = this._checkSnapshotCanvas();
if (snapshotCanvas) {
clearCanvas(snapshotCanvas);
}
};
_proto._snapshot = function _snapshot() {
var progressiveRender = this.isProgressiveRender();
var geosToDraw = this._geosToDraw || [];
for (var i = 0, len = geosToDraw.length; i < len; i++) {
var geo = geosToDraw[i];
var t = geo._hitTestTolerance() || 0;
this.maxTolerance = Math.max(this.maxTolerance, t);
if (progressiveRender) {
this.pageGeos.push(geo);
var painter = geo._painter;
this.geoPainterList.push(painter);
}
}
if (!progressiveRender) {
return this;
}
var time = now();
var snapshotCanvas = this._checkSnapshotCanvas();
if (snapshotCanvas && this.canvas) {
var ctx = clearCanvas(snapshotCanvas);
ctx.drawImage(this.canvas, 0, 0);
}
var layer = this.layer;
var progressiveRenderCount = layer.options.progressiveRenderCount;
var geos = layer._geoList || [];
var pages = Math.ceil(geos.length / progressiveRenderCount);
this.renderEnd = this.page >= pages;
if (this.renderEnd) {
this._setDrawGeosDrawTime();
}
if (isDebug(this.layer)) {
console.log('snapshot time:', now() - time + 'ms');
}
this.page++;
return this;
};
_proto._drawSnapshot = function _drawSnapshot() {
if (!this.isProgressiveRender()) {
return this;
}
var snapshotCanvas = this.snapshotCanvas,
context = this.context;
if (!snapshotCanvas || !context) {
return this;
}
var map = this.getMap();
if (!map) {
return this;
}
var dpr = map.getDevicePixelRatio() || 1;
var rScale = 1 / dpr;
context.scale(rScale, rScale);
context.drawImage(snapshotCanvas, 0, 0);
context.scale(dpr, dpr);
return this;
};
return VectorLayerRenderer;
}(OverlayLayerRenderer);
VectorLayer.registerRenderer('canvas', VectorLayerRenderer);
var MapRenderer = function (_Class) {
_inheritsLoose(MapRenderer, _Class);
function MapRenderer(map) {
var _this;
_this = _Class.call(this) || this;
_this.map = map;
_this._handlerQueue = [];
_this._thisDocVisibilitychange = _this._onDocVisibilitychange.bind(_assertThisInitialized(_assertThisInitialized(_this)));
_this._thisDocDragStart = _this._onDocDragStart.bind(_assertThisInitialized(_assertThisInitialized(_this)));
_this._thisDocDragEnd = _this._onDocDragEnd.bind(_assertThisInitialized(_assertThisInitialized(_this)));
_this._thisDocDPRChange = _this._onDocDPRChange.bind(_assertThisInitialized(_assertThisInitialized(_this)));
return _this;
}
var _proto = MapRenderer.prototype;
_proto.callInNextFrame = function callInNextFrame(fn) {
this._handlerQueue.push(fn);
};
_proto.executeFrameCallbacks = function executeFrameCallbacks() {
var running = this._handlerQueue;
this._handlerQueue = [];
for (var i = 0, l = running.length; i < l; i++) {
running[i]();
}
};
_proto.offsetPlatform = function offsetPlatform(offset, force) {
if (!this.map._panels.front) {
return this;
}
if (!force && offset.x === 0 && offset.y === 0) {
return this;
}
var panels = this.map._panels;
var hasFront = this._frontCount = panels.back.layerDOM.childElementCount;
var hasBack = this._backCount = panels.front.layerDOM.childElementCount;
var hasUI = this._uiCount = panels.front.uiDOM.childElementCount;
if (hasFront || hasBack || hasUI) {
var pos = this.map.offsetPlatform();
if (offset) {
pos = pos.add(offset)._round();
} else {
pos = pos.round();
}
if (hasBack) {
offsetDom(panels.back, pos);
}
if (hasFront || hasUI) {
offsetDom(panels.front, pos);
}
}
return this;
};
_proto.domChanged = function domChanged() {
var panels = this.map._panels;
if (!panels.front) {
return false;
}
var frontCount = panels.back.layerDOM.childElementCount;
if (this._frontCount === undefined || this._frontCount !== frontCount) {
return true;
}
var backCount = panels.front.layerDOM.childElementCount;
if (this._backCount === undefined || this._backCount !== backCount) {
return true;
}
var uiCount = panels.front.uiDOM.childElementCount;
if (this._uiCount === undefined || this._uiCount !== uiCount) {
return true;
}
return false;
};
_proto.resetContainer = function resetContainer() {
if (!this.map) {
return;
}
this.map._resetMapViewPoint();
if (this.map._panels.front) {
var pos = new Point(0, 0);
offsetDom(this.map._panels.back, pos);
offsetDom(this.map._panels.front, pos);
}
};
_proto.onZoomEnd = function onZoomEnd() {
this.resetContainer();
};
_proto.onLoad = function onLoad() {
this._frameLoop();
};
_proto._onDocVisibilitychange = function _onDocVisibilitychange() {
if (document.visibilityState !== 'visible') {
return;
}
this.setToRedraw();
};
_proto._getWrapPanel = function _getWrapPanel() {
if (!this.map) {
return null;
}
var panels = this.map.getPanels();
return panels && panels.mapWrapper;
};
_proto._onDocDragStart = function _onDocDragStart() {
var wrapPanel = this._getWrapPanel();
if (wrapPanel) {
wrapPanel.style.overflow = 'visible';
}
return;
};
_proto._onDocDragEnd = function _onDocDragEnd() {
var wrapPanel = this._getWrapPanel();
if (wrapPanel) {
wrapPanel.style.overflow = 'hidden';
}
return;
};
_proto._onDocDPRChange = function _onDocDPRChange() {
var map = this.map;
if (!map || !map.options || map.options['devicePixelRatio'] || !map.checkSize || !map.getRenderer) {
return;
}
var renderer = map.getRenderer();
if (renderer) {
map.checkSize(true);
}
};
_proto._containerIsOffscreen = function _containerIsOffscreen() {
var container = this.map.getContainer();
if (!container || !container.style || container.style.display === 'none') {
return true;
}
var minSize = Math.min(container.clientWidth, container.clientHeight);
return minSize <= 0;
};
return MapRenderer;
}(Class);
var MapCanvasRenderer = function (_MapRenderer) {
_inheritsLoose(MapCanvasRenderer, _MapRenderer);
function MapCanvasRenderer(map) {
var _this;
_this = _MapRenderer.call(this, map) || this;
_this._containerIsCanvas = !!map._containerDOM.getContext;
_this._registerEvents();
_this._loopTime = 0;
_this._resizeEventList = [];
_this._resizeTime = -Infinity;
return _this;
}
var _proto = MapCanvasRenderer.prototype;
_proto.load = function load() {
this.initContainer();
};
_proto.renderFrame = function renderFrame(framestamp) {
var map = this.map;
if (!map || !map.options['renderable']) {
return false;
}
this._handleResizeEventList(framestamp);
if (map.options['stopRenderOnOffscreen'] && this._containerIsOffscreen()) {
return true;
}
this._updateDomPosition(framestamp);
delete this._isViewChanged;
map._fireEvent('framestart');
this.updateMapDOM();
map.clearCollisionIndex();
var layers = this._getAllLayerToRender();
this.drawLayers(layers, framestamp);
var updated = this.drawLayerCanvas(layers);
if (updated) {
this.drawTops();
this._drawCenterCross();
if (map.options['debugSky']) {
this._debugSky();
}
}
this._needClear = false;
map._fireEvent('frameend');
this._recordView();
this._mapview = this._getMapView();
delete this._spatialRefChanged;
this._fireLayerLoadEvents();
this.executeFrameCallbacks();
this._canvasUpdated = false;
map.uiCollides();
return true;
};
_proto.updateMapDOM = function updateMapDOM() {
var map = this.map;
if (map.isZooming()) {
return;
}
var offset = map._getViewPointFrameOffset();
if (offset) {
map.offsetPlatform(offset);
} else if (this.domChanged()) {
this.offsetPlatform(null, true);
}
};
_proto.drawLayers = function drawLayers(layers, framestamp) {
var map = this.map,
isInteracting = map.isInteracting(),
canvasIds = [],
updatedIds = [],
fps = map.options['fpsOnInteracting'] || 0,
timeLimit = fps === 0 ? 0 : 1000 / fps,
layerLimit = this.map.options['layerCanvasLimitOnInteracting'],
l = layers.length;
var baseLayer = map.getBaseLayer();
var t = 0;
for (var i = 0; i < l; i++) {
var layer = layers[i];
if (!layer.isVisible()) {
continue;
}
var isCanvas = layer.isCanvasRender();
if (isCanvas) {
canvasIds.push(layer.getId());
}
var renderer = layer._getRenderer();
if (!renderer) {
continue;
}
var needsRedraw = this._checkLayerRedraw(layer);
if (isCanvas && renderer.isCanvasUpdated()) {
if (!needsRedraw) {
updatedIds.push(layer.getId());
}
this.setLayerCanvasUpdated();
}
var transformMatrix = renderer.__zoomTransformMatrix;
delete renderer.__zoomTransformMatrix;
if (!needsRedraw) {
if (isCanvas && isInteracting) {
if (map.isZooming() && !map.getPitch()) {
renderer.prepareRender();
renderer.__zoomTransformMatrix = this._zoomMatrix;
} else if (map.getPitch() || map.isRotating()) {
renderer.clearCanvas();
}
}
continue;
}
if (isInteracting && isCanvas) {
if (layerLimit > 0 && l - 1 - i > layerLimit && layer !== baseLayer) {
layer._getRenderer().clearCanvas();
continue;
}
t += this._drawCanvasLayerOnInteracting(layer, t, timeLimit, framestamp);
} else if (isInteracting && renderer.drawOnInteracting) {
if (renderer.prepareRender) {
renderer.prepareRender();
}
if (renderer.checkAndDraw) {
renderer.checkAndDraw(renderer.drawOnInteracting, this._eventParam, framestamp);
} else {
renderer.drawOnInteracting(this._eventParam, framestamp);
}
} else {
renderer.render(framestamp);
if (isCanvas && transformMatrix && renderer.isLoadingResource()) {
renderer.__zoomTransformMatrix = transformMatrix;
}
}
if (isCanvas) {
updatedIds.push(layer.getId());
this.setLayerCanvasUpdated();
}
}
var preCanvasIds = this._canvasIds || [];
var preUpdatedIds = this._updatedIds || [];
this._canvasIds = canvasIds;
this._updatedIds = updatedIds;
if (!this.isLayerCanvasUpdated()) {
var sep = '---';
if (preCanvasIds.join(sep) !== canvasIds.join(sep) || preUpdatedIds.join(sep) !== updatedIds.join(sep)) {
this.setLayerCanvasUpdated();
}
}
};
_proto._checkLayerRedraw = function _checkLayerRedraw(layer) {
if (this.isSpatialReferenceChanged()) {
return true;
}
var map = this.map;
var renderer = layer._getRenderer();
if (layer.isCanvasRender()) {
return renderer.testIfNeedRedraw();
} else {
if (renderer.needToRedraw && renderer.needToRedraw()) {
return true;
}
return map.isInteracting() || this.isViewChanged();
}
};
_proto._drawCanvasLayerOnInteracting = function _drawCanvasLayerOnInteracting(layer, t, timeLimit, framestamp) {
var map = this.map,
renderer = layer._getRenderer(),
drawTime = renderer.getDrawTime(),
inTime = timeLimit === 0 || timeLimit > 0 && t + drawTime <= timeLimit;
if (renderer.mustRenderOnInteracting && renderer.mustRenderOnInteracting()) {
renderer.render(framestamp);
} else if (renderer.drawOnInteracting && (layer === map.getBaseLayer() || inTime || map.isZooming() && layer.options['forceRenderOnZooming'] || map.isMoving() && layer.options['forceRenderOnMoving'] || map.isRotating() && layer.options['forceRenderOnRotating'])) {
renderer.prepareRender();
renderer.prepareCanvas();
if (renderer.checkAndDraw) {
renderer.checkAndDraw(renderer.drawOnInteracting, this._eventParam, framestamp);
} else {
renderer.drawOnInteracting(this._eventParam, framestamp);
}
return drawTime;
} else if (map.isZooming() && !map.getPitch() && !map.isRotating()) {
renderer.prepareRender();
renderer.__zoomTransformMatrix = this._zoomMatrix;
} else if (map.getPitch() || map.isRotating()) {
renderer.clearCanvas();
}
if (renderer.drawOnInteracting && !inTime) {
renderer.onSkipDrawOnInteracting(this._eventParam, framestamp);
}
return 0;
};
_proto._fireLayerLoadEvents = function _fireLayerLoadEvents() {
if (this._updatedIds && this._updatedIds.length > 0) {
var map = this.map;
this._updatedIds.reverse().forEach(function (id) {
var layer = map.getLayer(id);
if (!layer) {
return;
}
var renderer = layer._getRenderer();
if (!renderer || !renderer.isRenderComplete()) {
return;
}
layer.fire('layerload');
});
}
};
_proto.isLayerCanvasUpdated = function isLayerCanvasUpdated() {
return this._canvasUpdated;
};
_proto.setLayerCanvasUpdated = function setLayerCanvasUpdated() {
this._canvasUpdated = true;
};
_proto.drawLayerCanvas = function drawLayerCanvas(layers) {
var map = this.map;
if (!map) {
return false;
}
if (!this.isLayerCanvasUpdated() && !this.isViewChanged() && this._needClear === false) {
return false;
}
if (!this.canvas) {
this.createCanvas();
}
map._fireEvent('renderstart', {
'context': this.context
});
if (!this._updateCanvasSize()) {
this.clearCanvas();
}
var interacting = map.isInteracting(),
limit = map.options['layerCanvasLimitOnInteracting'];
var len = layers.length;
var baseLayerImage;
var images = [];
for (var i = 0; i < len; i++) {
if (!layers[i].isVisible() || !layers[i].isCanvasRender()) {
continue;
}
var renderer = layers[i]._getRenderer();
if (!renderer) {
continue;
}
var layerImage = this._getLayerImage(layers[i]);
if (layerImage && layerImage['image']) {
if (layers[i] === map.getBaseLayer()) {
baseLayerImage = [layers[i], layerImage];
} else {
images.push([layers[i], layerImage]);
}
}
}
var targetWidth = this.canvas.width;
var targetHeight = this.canvas.height;
if (baseLayerImage) {
this._drawLayerCanvasImage(baseLayerImage[0], baseLayerImage[1], targetWidth, targetHeight);
this._drawFog();
}
len = images.length;
var start = interacting && limit >= 0 && len > limit ? len - limit : 0;
for (var _i = start; _i < len; _i++) {
this._drawLayerCanvasImage(images[_i][0], images[_i][1], targetWidth, targetHeight);
}
map._fireEvent('renderend', {
'context': this.context
});
return true;
};
_proto.setToRedraw = function setToRedraw() {
var layers = this._getAllLayerToRender();
this._needClear = true;
for (var i = 0, l = layers.length; i < l; i++) {
var renderer = layers[i].getRenderer();
if (renderer && renderer.canvas && renderer.setToRedraw) {
renderer.setToRedraw();
}
}
};
_proto.updateMapSize = function updateMapSize(size) {
if (!size || this._containerIsCanvas) {
return;
}
var width = size['width'] + 'px',
height = size['height'] + 'px';
var panels = this.map._panels;
panels.mapWrapper.style.width = width;
panels.mapWrapper.style.height = height;
this._updateCanvasSize();
};
_proto.getMainPanel = function getMainPanel() {
if (!this.map) {
return null;
}
if (this._containerIsCanvas) {
return this.map._containerDOM;
}
if (this.map._panels) {
return this.map._panels.mapWrapper;
}
return null;
};
_proto.toDataURL = function toDataURL(mimeType, quality) {
if (!this.canvas) {
return null;
}
return this.canvas.toDataURL(mimeType, quality);
};
_proto.remove = function remove() {
if (Browser$1.webgl && typeof document !== 'undefined') {
GlobalEvent.off(EVENT_DPR_CHANGE, this._thisDocDPRChange, this);
GlobalEvent.off(EVENT_DOC_VISIBILITY_CHANGE, this._thisDocVisibilitychange, this);
GlobalEvent.off(EVENT_DOC_DRAGSTART, this._thisDocDragStart, this);
GlobalEvent.off(EVENT_DOC_DRAGEND, this._thisDocDragEnd, this);
}
if (this._resizeInterval) {
clearInterval(this._resizeInterval);
}
if (this._resizeObserver) {
this._resizeObserver.disconnect();
}
delete this.context;
delete this.canvas;
delete this.map;
delete this._spatialRefChanged;
this._cancelFrameLoop();
};
_proto.hitDetect = function hitDetect(point) {
var map = this.map;
if (!map || !map.options['hitDetect'] || map.isInteracting()) {
return;
}
var layers = map._getLayers();
var cursor = 'default';
var limit = map.options['hitDetectLimit'] || 0;
var counter = 0;
if (point && point._round) {
point._round();
}
for (var i = layers.length - 1; i >= 0; i--) {
var layer = layers[i];
if (!layer.options['hitDetect'] || layer.isEmpty && layer.isEmpty() || !layer.options['geometryEvents']) {
continue;
}
var renderer = layer._getRenderer();
if (!renderer || !renderer.hitDetect) {
continue;
}
if (renderer.isBlank && renderer.isBlank()) {
continue;
}
if (layer.options['cursor'] !== 'default' && renderer.hitDetect(point)) {
cursor = layer.options['cursor'] || 'pointer';
break;
}
counter++;
if (limit > 0 && counter > limit) {
break;
}
}
map._trySetCursor(cursor);
};
_proto._getLayerImage = function _getLayerImage(layer) {
var renderer = layer._getRenderer();
if (renderer.getCanvasImage) {
return renderer.getCanvasImage();
}
return null;
};
_proto.initContainer = function initContainer() {
var panels = this.map._panels;
function createContainer(name, className, cssText, enableSelect) {
var c = createEl('div', className);
if (cssText) {
c.style.cssText = cssText;
}
panels[name] = c;
if (!enableSelect) {
preventSelection(c);
}
return c;
}
var containerDOM = this.map._containerDOM;
if (this._containerIsCanvas) {
return;
}
containerDOM.innerHTML = '';
var POSITION0 = 'position:absolute;top:0px;left:0px;';
var mapWrapper = createContainer('mapWrapper', 'maptalks-wrapper', 'position:absolute;overflow:hidden;', true),
mapAllLayers = createContainer('allLayers', 'maptalks-all-layers', POSITION0 + 'padding:0px;margin:0px;z-index:0;overflow:visible;', true),
backStatic = createContainer('backStatic', 'maptalks-back-static', POSITION0 + 'z-index:0;', true),
back = createContainer('back', 'maptalks-back', POSITION0 + 'z-index:1;'),
backLayer = createContainer('backLayer', 'maptalks-back-layer', POSITION0),
canvasContainer = createContainer('canvasContainer', 'maptalks-canvas-layer', POSITION0 + 'border:none;z-index:2;'),
frontStatic = createContainer('frontStatic', 'maptalks-front-static', POSITION0 + 'z-index:3;', true),
front = createContainer('front', 'maptalks-front', POSITION0 + 'z-index:4;', true),
frontLayer = createContainer('frontLayer', 'maptalks-front-layer', POSITION0 + 'z-index:0;'),
ui = createContainer('ui', 'maptalks-ui', POSITION0 + 'border:none;z-index:1;', true),
control = createContainer('control', 'maptalks-control', 'z-index:1', true);
containerDOM.appendChild(mapWrapper);
mapAllLayers.appendChild(backStatic);
back.appendChild(backLayer);
back.layerDOM = backLayer;
mapAllLayers.appendChild(back);
mapAllLayers.appendChild(canvasContainer);
front.appendChild(frontLayer);
front.layerDOM = frontLayer;
front.uiDOM = ui;
mapAllLayers.appendChild(frontStatic);
mapAllLayers.appendChild(front);
front.appendChild(ui);
mapWrapper.appendChild(mapAllLayers);
mapWrapper.appendChild(control);
this.createCanvas();
this.resetContainer();
var mapSize = this.map._getContainerDomSize();
this.updateMapSize(mapSize);
};
_proto.isViewChanged = function isViewChanged() {
if (this._isViewChanged !== undefined) {
return this._isViewChanged;
}
var previous = this._mapview;
var view = this._getMapView();
this._isViewChanged = !previous || !equalMapView(previous, view);
return this._isViewChanged;
};
_proto._recordView = function _recordView() {
var map = this.map;
if (!map._onViewChange || map.isInteracting() || map.isAnimating()) {
return;
}
if (!equalMapView(map.getView(), map._getCurrentView())) {
map._onViewChange(map.getView());
}
};
_proto.isSpatialReferenceChanged = function isSpatialReferenceChanged() {
return this._spatialRefChanged;
};
_proto._getMapView = function _getMapView() {
var map = this.map;
var center = map._getPrjCenter();
return {
x: center.x,
y: center.y,
zoom: map.getZoom(),
pitch: map.getPitch(),
bearing: map.getBearing(),
width: map.width,
height: map.height
};
};
_proto._frameLoop = function _frameLoop(framestamp) {
var _this2 = this;
if (!this.map) {
this._cancelFrameLoop();
return;
}
framestamp = framestamp || 0;
this._animationFrame = requestAnimFrame(function (framestamp) {
_this2._frameLoop(framestamp);
});
this._frameTimestamp = framestamp;
this._resizeCount = 0;
this.renderFrame(framestamp);
};
_proto._cancelFrameLoop = function _cancelFrameLoop() {
if (this._animationFrame) {
cancelAnimFrame(this._animationFrame);
}
};
_proto._drawLayerCanvasImage = function _drawLayerCanvasImage(layer, layerImage, targetWidth, targetHeight) {
var ctx = this.context;
var point = layerImage['point'].round();
var dpr = this.map.getDevicePixelRatio();
if (dpr !== 1) {
point._multi(dpr);
}
var canvasImage = layerImage['image'];
var width = canvasImage.width,
height = canvasImage.height;
if (point.x + width <= 0 || point.y + height <= 0) {
return;
}
var op = layer.options['opacity'];
if (!isNumber(op)) {
op = 1;
}
if (op <= 0) {
return;
}
var imgOp = layerImage['opacity'];
if (!isNumber(imgOp)) {
imgOp = 1;
}
if (imgOp <= 0) {
return;
}
var alpha = ctx.globalAlpha;
if (op < 1) {
ctx.globalAlpha *= op;
}
if (imgOp < 1) {
ctx.globalAlpha *= imgOp;
}
if (layer.options['cssFilter']) {
ctx.filter = layer.options['cssFilter'];
}
var renderer = layer.getRenderer();
var matrix = renderer.__zoomTransformMatrix;
var clipped = renderer.clipCanvas(this.context);
if (matrix) {
ctx.save();
ctx.setTransform.apply(ctx, matrix);
}
ctx.drawImage(canvasImage, 0, 0, width, height, point.x, point.y, targetWidth, targetHeight);
if (matrix) {
ctx.restore();
}
if (clipped) {
ctx.restore();
}
if (ctx.filter !== 'none') {
ctx.filter = 'none';
}
ctx.globalAlpha = alpha;
};
_proto._drawCenterCross = function _drawCenterCross() {
var cross = this.map.options['centerCross'];
if (cross) {
var ctx = this.context;
var p = new Point(this.canvas.width / 2, this.canvas.height / 2);
if (isFunction(cross)) {
cross(ctx, p);
} else {
Canvas.drawCross(this.context, p.x, p.y, 2, '#f00');
}
}
};
_proto._drawContainerExtent = function _drawContainerExtent() {
var cascadePitches = this.map.options.cascadePitches;
var h30 = this.map.height - this.map._getVisualHeight(cascadePitches[0]);
var h60 = this.map.height - this.map._getVisualHeight(cascadePitches[1]);
var extent = this.map.getContainerExtent();
var ctx = this.context;
ctx.beginPath();
ctx.moveTo(0, extent.ymin);
ctx.lineTo(extent.xmax, extent.ymin);
ctx.stroke();
ctx.beginPath();
ctx.moveTo(0, h30);
ctx.lineTo(extent.xmax, h30);
ctx.stroke();
ctx.beginPath();
ctx.moveTo(0, h60);
ctx.lineTo(extent.xmax, h60);
ctx.stroke();
};
_proto._drawFog = function _drawFog() {
var map = this.map;
if (map.getPitch() <= map.options['maxVisualPitch'] || !map.options['fog']) {
return;
}
var fogThickness = 30;
var r = map.getDevicePixelRatio();
var ctx = this.context,
clipExtent = map.getContainerExtent();
var top = (map.height - map._getVisualHeight(75)) * r;
if (top < 0) top = 0;
var bottom = clipExtent.ymin * r,
h = Math.ceil(bottom - top),
color = map.options['fogColor'].join();
var gradient = ctx.createLinearGradient(0, top, 0, bottom + fogThickness);
var landscape = 1 - fogThickness / (h + fogThickness);
gradient.addColorStop(0, "rgba(" + color + ", 0)");
gradient.addColorStop(0.3, "rgba(" + color + ", 0.3)");
gradient.addColorStop(landscape, "rgba(" + color + ", 1)");
gradient.addColorStop(1, "rgba(" + color + ", 0)");
ctx.beginPath();
ctx.fillStyle = gradient;
ctx.fillRect(0, top, Math.ceil(clipExtent.getWidth()) * r, Math.ceil(h + fogThickness));
};
_proto._debugSky = function _debugSky() {
var map = this.map;
if (!map) {
return this;
}
var height = map.getContainerExtent().ymin;
if (height <= 0) {
return this;
}
var ctx = this.context;
ctx.strokeStyle = 'red';
ctx.strokeRect(0, 0, map.width, height);
return this;
};
_proto._getAllLayerToRender = function _getAllLayerToRender() {
return this.map._getLayers();
};
_proto.clearCanvas = function clearCanvas() {
if (!this.canvas) {
return;
}
Canvas.clearRect(this.context, 0, 0, this.canvas.width, this.canvas.height);
};
_proto._updateCanvasSize = function _updateCanvasSize() {
if (!this.canvas || this._containerIsCanvas) {
return false;
}
var map = this.map,
mapSize = map.getSize(),
canvas = this.canvas,
r = map.getDevicePixelRatio();
var _calCanvasSize = calCanvasSize(mapSize, r),
width = _calCanvasSize.width,
height = _calCanvasSize.height,
cssWidth = _calCanvasSize.cssWidth,
cssHeight = _calCanvasSize.cssHeight;
if (canvas.style && (canvas.style.width !== cssWidth || canvas.style.height !== cssHeight)) {
canvas.style.width = cssWidth;
canvas.style.height = cssHeight;
}
if (width === canvas.width && height === canvas.height) {
return false;
}
canvas.height = height;
canvas.width = width;
this.topLayer.width = canvas.width;
this.topLayer.height = canvas.height;
return true;
};
_proto.createCanvas = function createCanvas() {
this.topLayer = createEl('canvas');
this.topCtx = this.topLayer.getContext('2d');
if (this._containerIsCanvas) {
this.canvas = this.map._containerDOM;
} else {
this.canvas = createEl('canvas');
this._updateCanvasSize();
this.map._panels.canvasContainer.appendChild(this.canvas);
}
this.context = this.canvas.getContext('2d');
};
_proto._updateDomPosition = function _updateDomPosition(framestamp) {
if (this._checkPositionTime === undefined) {
this._checkPositionTime = -Infinity;
}
var dTime = Math.abs(framestamp - this._checkPositionTime);
if (dTime >= 500) {
computeDomPosition(this.map._containerDOM);
this._checkPositionTime = Math.min(framestamp, this._checkPositionTime);
}
return this;
};
_proto._handleResizeEventList = function _handleResizeEventList(time) {
if (!this._resizeEventList) {
return this;
}
var len = this._resizeEventList.length;
if (len === 0) {
return this;
}
if (this._resizeTime && time - this._resizeTime < 60) {
return this;
}
var contentRect = this._resizeEventList[len - 1].contentRect;
this.map._containerDomContentRect = contentRect;
this._resizeEventList = [];
this._checkSize(contentRect);
this._resizeCount = this._resizeCount || 0;
this.renderFrame((this._frameTimestamp || 0) + ++this._resizeCount / 100);
this._resizeTime = time;
return this;
};
_proto._checkSize = function _checkSize() {
if (!this.map) {
return;
}
this.map.checkSize();
};
_proto._setCheckSizeInterval = function _setCheckSizeInterval(interval) {
var _this3 = this;
if (Browser$1.resizeObserver) {
if (this._resizeObserver) {
this._resizeObserver.disconnect();
}
if (this.map) {
this._resizeObserver = new ResizeObserver(function (entries) {
if (!_this3.map || _this3.map.isRemoved()) {
_this3._resizeObserver.disconnect();
} else if (entries.length) {
_this3._resizeEventList = _this3._resizeEventList || [];
_this3._resizeEventList.push(entries[0]);
}
});
this._resizeObserver.observe(this.map._containerDOM);
}
} else {
clearInterval(this._resizeInterval);
this._checkSizeInterval = interval;
this._resizeInterval = setInterval(function () {
if (!_this3.map || _this3.map.isRemoved()) {
clearInterval(_this3._resizeInterval);
} else {
_this3._checkSize();
}
}, this._checkSizeInterval);
}
};
_proto._registerEvents = function _registerEvents() {
var _this4 = this;
var map = this.map;
if (map.options['checkSize'] && !IS_NODE && typeof window !== 'undefined') {
this._setCheckSizeInterval(map.options['checkSizeInterval']);
}
if (!Browser$1.mobile) {
map.on('_mousemove', this._onMapMouseMove, this);
}
map.on('_dragrotatestart _dragrotating _dragrotateend _movestart _moving _moveend _zoomstart', function (param) {
_this4._eventParam = param;
});
map.on('_zooming', function (param) {
if (!map.getPitch()) {
_this4._zoomMatrix = param['matrix']['container'];
}
_this4._eventParam = param;
});
map.on('_zoomend', function (param) {
_this4._eventParam = param;
delete _this4._zoomMatrix;
});
map.on('_spatialreferencechange', function () {
_this4._spatialRefChanged = true;
});
if (Browser$1.webgl && typeof document !== 'undefined') {
GlobalEvent.on(EVENT_DPR_CHANGE, this._thisDocDPRChange, this);
GlobalEvent.on(EVENT_DOC_VISIBILITY_CHANGE, this._thisDocVisibilitychange, this);
GlobalEvent.on(EVENT_DOC_DRAGSTART, this._thisDocDragStart, this);
GlobalEvent.on(EVENT_DOC_DRAGEND, this._thisDocDragEnd, this);
}
};
_proto._onMapMouseMove = function _onMapMouseMove(param) {
var _this5 = this;
var map = this.map;
if (map.isInteracting() || !map.options['hitDetect']) {
return;
}
if (this._hitDetectFrame) {
cancelAnimFrame(this._hitDetectFrame);
}
this._hitDetectFrame = requestAnimFrame(function () {
_this5.hitDetect(param['containerPoint']);
});
};
_proto._getCanvasLayers = function _getCanvasLayers() {
return this.map._getLayers(function (layer) {
return layer.isCanvasRender();
});
};
_proto.addTopElement = function addTopElement(e) {
if (!this._tops) {
this._tops = [];
}
this._tops.push(e);
};
_proto.removeTopElement = function removeTopElement(e) {
if (!this._tops) {
return;
}
var idx = this._tops.indexOf(e);
if (idx >= 0) {
this._tops.splice(idx, 1);
}
};
_proto.getTopElements = function getTopElements() {
return this._tops || [];
};
_proto.drawTops = function drawTops() {
this.topCtx.clearRect(0, 0, this.topLayer.width, this.topLayer.height);
this.map.fire('drawtopstart');
this.map.fire('drawtops');
var tops = this.getTopElements();
var updated = false;
for (var i = 0; i < tops.length; i++) {
if (tops[i].render(this.topCtx)) {
updated = true;
}
}
if (updated) {
this.context.drawImage(this.topLayer, 0, 0);
}
this.map.fire('drawtopsend');
};
return MapCanvasRenderer;
}(MapRenderer);
Map$1.registerRenderer('canvas', MapCanvasRenderer);
Map$1.mergeOptions({
'fog': false,
'fogColor': [233, 233, 233]
});
var index$6 = /*#__PURE__*/Object.freeze({
ResourceCache: ResourceCache,
CanvasRenderer: CanvasRenderer,
ImageGLRenderable: ImageGLRenderable,
MapRenderer: MapRenderer,
MapCanvasRenderer: MapCanvasRenderer,
Renderable: Renderable,
ImageLayerCanvasRenderer: ImageLayerCanvasRenderer,
ImageLayerGLRenderer: ImageLayerGLRenderer,
TileLayerCanvasRenderer: TileLayerCanvasRenderer,
TileLayerGLRenderer: TileLayerGLRenderer,
CanvasTileLayerCanvasRenderer: CanvasRenderer$1,
CanvasTileLayerGLRenderer: GLRenderer,
QuadStencil: QuadStencil,
OverlayLayerCanvasRenderer: OverlayLayerRenderer,
VectorLayerCanvasRenderer: VectorLayerRenderer,
CanvasLayerRenderer: CanvasLayerRenderer
});
var CenterPointRenderer = {
_getRenderPoints: function _getRenderPoints() {
return [[this._getCenter2DPoint(this.getMap().getGLRes())], null];
}
};
Marker.include(CenterPointRenderer);
Ellipse.include(CenterPointRenderer);
Circle.include(CenterPointRenderer);
Sector.include(CenterPointRenderer);
Rectangle.include({
_getRenderPoints: function _getRenderPoints(placement) {
var map = this.getMap();
var glRes = map.getGLRes();
if (placement === 'vertex') {
var shell = this._trimRing(this.getShell());
var points = [];
for (var i = 0, len = shell.length; i < len; i++) {
points.push(map.coordToPointAtRes(shell[i], glRes));
}
return [points, null];
} else {
var c = map.coordToPointAtRes(this.getCenter(), glRes);
return [[c], null];
}
}
});
var PolyRenderer = {
_getRenderPoints: function _getRenderPoints(placement) {
var map = this.getMap();
var glRes = map.getGLRes();
var points,
rotations = null;
if (placement === 'point') {
points = this._getPath2DPoints(this._getPrjCoordinates(), false, glRes);
if (points && points.length > 0 && Array.isArray(points[0])) {
points = points[0].concat(points[1]);
}
} else if (placement === 'vertex') {
points = this._getPath2DPoints(this._getPrjCoordinates(), false, glRes);
rotations = [];
if (points && points.length > 0 && Array.isArray(points[0])) {
for (var i = 0, l = points.length; i < l; i++) {
for (var ii = 0, ll = points[i].length; ii < ll; ii++) {
if (ii === 0) {
rotations.push([points[i][ii], points[i][ii + 1]]);
} else {
rotations.push([points[i][ii - 1], points[i][ii]]);
}
}
}
points = points[0].concat(points[1]);
} else {
for (var _i = 0, _l = points.length; _i < _l; _i++) {
if (_i === 0) {
rotations.push([points[_i], points[_i + 1]]);
} else {
rotations.push([points[_i - 1], points[_i]]);
}
}
}
} else if (placement === 'line') {
points = [];
rotations = [];
var vertice = this._getPath2DPoints(this._getPrjCoordinates(), false, glRes),
isSplitted = vertice.length > 0 && Array.isArray(vertice[0]);
if (isSplitted) {
var ring;
for (var _i2 = 1, _l2 = vertice.length; _i2 < _l2; _i2++) {
ring = vertice[_i2];
if (this instanceof Polygon && ring.length > 0 && !ring[0].equals(ring[ring.length - 1])) {
ring.push(ring[0]);
}
for (var _ii = 1, _ll = ring.length; _ii < _ll; _ii++) {
points.push(ring[_ii].add(ring[_ii - 1])._multi(0.5));
rotations.push([ring[_ii - 1], ring[_ii]]);
}
}
} else {
if (this instanceof Polygon && vertice.length > 0 && !vertice[0].equals(vertice[vertice.length - 1])) {
vertice.push(vertice[0]);
}
for (var _i3 = 1, _l3 = vertice.length; _i3 < _l3; _i3++) {
points.push(vertice[_i3].add(vertice[_i3 - 1])._multi(0.5));
rotations.push([vertice[_i3 - 1], vertice[_i3]]);
}
}
} else if (placement === 'vertex-first') {
var coords = this._getPrjCoordinates();
var _l4 = coords.length;
var point0 = _l4 ? map._prjToPointAtRes(coords[0], glRes) : null;
points = _l4 ? [point0] : [];
rotations = _l4 ? [[point0, coords[1] ? map._prjToPointAtRes(coords[1], glRes) : point0]] : [];
} else if (placement === 'vertex-last') {
var _coords = this._getPrjCoordinates();
var _l5 = _coords.length;
var curretPoint = _l5 ? map._prjToPointAtRes(_coords[_l5 - 1], glRes) : null;
points = _l5 ? [curretPoint] : [];
var previous = _l5 > 1 ? _l5 - 2 : _l5 - 1;
rotations = _l5 ? [[_coords[previous] ? map._prjToPointAtRes(_coords[previous], glRes) : curretPoint, curretPoint]] : [];
} else {
var center = this.getCenter();
if (!center) {
points = [];
} else {
var pcenter = this._getProjection().project(center);
points = [map._prjToPointAtRes(pcenter, glRes)];
}
}
return [points, rotations];
}
};
LineString.include(PolyRenderer);
Polygon.include(PolyRenderer);
var TEMP_WITHIN = {
within: false,
center: [0, 0]
};
function isWithinPixel(painter) {
if (!painter || !painter._containerBbox) {
TEMP_WITHIN.within = false;
} else {
TEMP_WITHIN.within = false;
var _painter$_containerBb = painter._containerBbox,
minx = _painter$_containerBb.minx,
miny = _painter$_containerBb.miny,
maxx = _painter$_containerBb.maxx,
maxy = _painter$_containerBb.maxy;
var offsetx = Math.abs(maxx - minx);
var offsety = Math.abs(maxy - miny);
if (offsetx <= 1 && offsety <= 1) {
TEMP_WITHIN.within = true;
TEMP_WITHIN.center[0] = (minx + maxx) / 2;
TEMP_WITHIN.center[1] = (miny + maxy) / 2;
}
delete painter._containerBbox;
}
return TEMP_WITHIN;
}
Geometry.include({
_redrawWhenPitch: function _redrawWhenPitch() {
return false;
},
_redrawWhenRotate: function _redrawWhenRotate() {
return false;
},
_getRenderBBOX: function _getRenderBBOX(ctx, points) {
if (!ctx.isHitTesting) {
resetBBOX(BBOX_TEMP);
pointsBBOX(points, BBOX_TEMP);
return BBOX_TEMP;
}
return null;
}
});
function _computeRotatedPrjExtent() {
var coord = this._getPrjShell();
var bbox = getDefaultBBOX();
pointsBBOX(coord, bbox);
var minx = bbox[0],
miny = bbox[1],
maxx = bbox[2],
maxy = bbox[3];
return new Extent(minx, miny, maxx, maxy);
}
function getRotatedShell() {
var prjs = this._getPrjShell();
if (!prjs || !Array.isArray(prjs)) {
return [];
}
var projection = this._getProjection();
var coordinates = this.getCoordinates() || {};
return prjs.map(function (prj) {
var c = projection.unproject(prj);
c.z = coordinates.z || 0;
return c;
});
}
var el = {
_redrawWhenPitch: function _redrawWhenPitch() {
return true;
},
_redrawWhenRotate: function _redrawWhenRotate() {
return this instanceof Ellipse || this instanceof Sector;
},
_computeRotatedPrjExtent: _computeRotatedPrjExtent,
getRotatedShell: getRotatedShell,
_paintAsPath: function _paintAsPath() {
if (this.isRotated()) {
return true;
}
var map = this.getMap();
var altitude = this._getAltitude();
return altitude > 0 || map.getPitch() || this instanceof Ellipse && map.getBearing();
},
_getPaintParams: function _getPaintParams() {
var map = this.getMap();
if (this._paintAsPath()) {
return Polygon.prototype._getPaintParams.call(this, true);
}
var pcenter = this._getPrjCoordinates();
var pt = map._prjToPointAtRes(pcenter, map.getGLRes());
var size = this._getRenderSize(pt);
return [pt].concat(size);
},
_paintOn: function _paintOn() {
if (this._paintAsPath()) {
return Canvas.polygon.apply(Canvas, arguments);
} else {
return Canvas.ellipse.apply(Canvas, arguments);
}
},
_getRenderSize: function _getRenderSize(pt) {
var map = this.getMap(),
glRes = map.getGLRes();
var prjExtent = this._getPrjExtent();
var pmin = map._prjToPointAtRes(prjExtent.getMin(), glRes),
pmax = map._prjToPointAtRes(prjExtent.getMax(), glRes);
return [Math.abs(pmax.x - pmin.x) / 2, Math.abs(pmax.y - pt.y), Math.abs(pt.y - pmin.y)];
}
};
Ellipse.include(el);
Circle.include(el);
Rectangle.include({
_getPaintParams: function _getPaintParams() {
var map = this.getMap();
var shell = this._getPrjShell();
var points = this._getPath2DPoints(shell, false, map.getGLRes());
return [points];
},
_paintOn: Canvas.polygon,
_computeRotatedPrjExtent: _computeRotatedPrjExtent,
getRotatedShell: getRotatedShell
});
Sector.include(el, {
_redrawWhenPitch: function _redrawWhenPitch() {
return true;
},
_getPaintParams: function _getPaintParams() {
if (this._paintAsPath()) {
return Polygon.prototype._getPaintParams.call(this, true);
}
var map = this.getMap();
var pt = map._prjToPointAtRes(this._getPrjCoordinates(), map.getGLRes());
var size = this._getRenderSize(pt);
return [pt, size[0], [this.getStartAngle(), this.getEndAngle()]];
},
_paintOn: function _paintOn() {
if (this._paintAsPath()) {
return Canvas.polygon.apply(Canvas, arguments);
} else {
var r = this.getMap().getBearing();
var args = arguments;
if (r) {
args[3] = args[3].slice(0);
args[3][0] += r;
args[3][1] += r;
}
return Canvas.sector.apply(Canvas, args);
}
}
});
Path.include({
_paintAsPath: function _paintAsPath() {
return true;
}
});
LineString.include({
arrowStyles: {
'classic': [3, 4]
},
_getArrowShape: function _getArrowShape(prePoint, point, lineWidth, arrowStyle, tolerance) {
if (!prePoint || !point || prePoint.equals(point)) {
return null;
}
if (!tolerance) {
tolerance = 0;
}
var width = lineWidth * arrowStyle[0],
height = lineWidth * arrowStyle[1] + tolerance,
hw = width / 2 + tolerance;
var normal;
if (point.nextCtrlPoint || point.prevCtrlPoint) {
if (point.prevCtrlPoint) {
normal = point.sub(new Point(point.prevCtrlPoint));
} else {
normal = point.sub(new Point(point.nextCtrlPoint));
}
} else {
normal = point.sub(prePoint);
}
normal._unit();
var p1 = point.sub(normal.multi(height));
normal._perp();
var p0 = p1.add(normal.multi(hw));
normal._multi(-1);
var p2 = p1.add(normal.multi(hw));
return [p0, point, p2, p0];
},
_getPaintParams: function _getPaintParams() {
var prjVertexes = this._getPrjCoordinates();
var points = this._getPath2DPoints(prjVertexes, false, this.getMap().getGLRes());
return [points];
},
_paintOn: function _paintOn(ctx, points, lineOpacity, fillOpacity, dasharray) {
var r = isWithinPixel(this._painter);
if (r.within) {
Canvas.pixelRect(ctx, r.center, lineOpacity, fillOpacity);
} else if (this.options['smoothness']) {
Canvas.paintSmoothLine(ctx, points, lineOpacity, this.options['smoothness'], false, this._animIdx, this._animTailRatio);
} else {
Canvas.path(ctx, points, lineOpacity, null, dasharray);
}
this._paintArrow(ctx, points, lineOpacity);
return this._getRenderBBOX(ctx, points);
},
_getArrowPlacement: function _getArrowPlacement() {
return this.options['arrowPlacement'];
},
_getArrowStyle: function _getArrowStyle() {
var arrowStyle = this.options['arrowStyle'];
if (arrowStyle) {
return Array.isArray(arrowStyle) ? arrowStyle : this.arrowStyles[arrowStyle];
}
return null;
},
_getArrows: function _getArrows(points, lineWidth, tolerance) {
var arrowStyle = this._getArrowStyle();
if (!arrowStyle || points.length < 2) {
return [];
}
var isSplitted = points.length > 0 && Array.isArray(points[0]);
var segments = isSplitted ? points : [points];
var placement = this._getArrowPlacement();
var arrows = [];
var map = this.getMap(),
first = map.coordToContainerPoint(this.getFirstCoordinate()),
last = map.coordToContainerPoint(this.getLastCoordinate());
for (var i = segments.length - 1; i >= 0; i--) {
if (placement === 'vertex-first' || placement === 'vertex-firstlast' && segments[i][0].closeTo(first, 0.01)) {
var arrow = this._getArrowShape(segments[i][1], segments[i][0], lineWidth, arrowStyle, tolerance);
if (arrow) {
arrows.push(arrow);
}
}
if (placement === 'vertex-last' || placement === 'vertex-firstlast' && segments[i][segments[i].length - 1].closeTo(last, 0.01)) {
var _arrow = this._getArrowShape(segments[i][segments[i].length - 2], segments[i][segments[i].length - 1], lineWidth, arrowStyle, tolerance);
if (_arrow) {
arrows.push(_arrow);
}
} else if (placement === 'point') {
this._getArrowPoints(arrows, segments[i], lineWidth, arrowStyle, tolerance);
}
}
return arrows;
},
_getArrowPoints: function _getArrowPoints(arrows, segments, lineWidth, arrowStyle, tolerance) {
for (var ii = 0, ll = segments.length - 1; ii < ll; ii++) {
var arrow = this._getArrowShape(segments[ii], segments[ii + 1], lineWidth, arrowStyle, tolerance);
if (arrow) {
arrows.push(arrow);
}
}
},
_paintArrow: function _paintArrow(ctx, points, lineOpacity) {
var lineWidth = this._getInternalSymbol()['lineWidth'];
if (!isNumber(lineWidth) || lineWidth < 3) {
lineWidth = 3;
}
var arrows = this._getArrows(points, lineWidth);
if (!arrows.length) {
return;
}
if (ctx.setLineDash) {
ctx.setLineDash([]);
}
for (var i = arrows.length - 1; i >= 0; i--) {
ctx.fillStyle = ctx.strokeStyle;
Canvas.polygon(ctx, arrows[i], lineOpacity, lineOpacity);
}
}
});
Polygon.include({
_getPaintParams: function _getPaintParams(disableSimplify) {
var glRes = this.getMap().getGLRes();
var prjVertexes = this._getPrjShell();
var points = this._getPath2DPoints(prjVertexes, disableSimplify, glRes);
var isSplitted = points.length > 0 && Array.isArray(points[0]);
if (isSplitted) {
points = [[points[0]], [points[1]]];
}
var prjHoles = this._getPrjHoles();
var holePoints = [];
if (prjHoles && prjHoles.length > 0) {
var simplified = this._simplified;
for (var i = 0; i < prjHoles.length; i++) {
var hole = this._getPath2DPoints(prjHoles[i], disableSimplify, glRes);
if (Array.isArray(hole) && isSplitted) {
if (Array.isArray(hole[0])) {
points[0].push(hole[0]);
points[1].push(hole[1]);
} else {
points[0].push(hole);
}
} else {
holePoints.push(hole);
}
}
if (simplified) {
this._simplified = simplified;
}
}
if (!isSplitted) {
points = [points];
pushIn(points, holePoints);
}
return [points];
},
_paintOn: function _paintOn(ctx, points, lineOpacity, fillOpacity, dasharray) {
var r = isWithinPixel(this._painter);
if (r.within) {
Canvas.pixelRect(ctx, r.center, lineOpacity, fillOpacity);
} else {
Canvas.polygon(ctx, points, lineOpacity, fillOpacity, dasharray, this.options['smoothness']);
}
return this._getRenderBBOX(ctx, points);
}
});
Map$1.VERSION = version;
var worker = {
Actor: Actor
};
exports.Util = index$1;
exports.DomUtil = dom;
exports.StringUtil = strings;
exports.MapboxUtil = index;
exports.MicroTask = MicroTask;
exports.Map = Map$1;
exports.ui = index$4;
exports.control = index$5;
exports.renderer = index$6;
exports.symbolizer = index$3;
exports.animation = Animation$1;
exports.worker = worker;
exports.Globalconfig = GlobalConfig;
exports.Browser = Browser$1;
exports.LRUCache = LRUCache;
exports.Ajax = Ajax;
exports.Canvas = Canvas;
exports.Promise = Promise$1;
exports.Class = Class;
exports.Eventable = Eventable;
exports.GlobalEvent = GlobalEvent;
exports.JSONAble = JSONAble;
exports.CollisionIndex = CollisionIndex;
exports.Handlerable = Handlerable;
exports.Handler = Handler$1;
exports.DragHandler = DragHandler;
exports.MapTool = MapTool;
exports.DrawTool = DrawTool;
exports.AreaTool = AreaTool;
exports.DistanceTool = DistanceTool;
exports.SpatialReference = SpatialReference;
exports.animate = animate;
exports.registerWorkerAdapter = registerWorkerAdapter;
exports.INTERNAL_LAYER_PREFIX = INTERNAL_LAYER_PREFIX;
exports.GEOMETRY_COLLECTION_TYPES = GEOMETRY_COLLECTION_TYPES;
exports.GEOJSON_TYPES = GEOJSON_TYPES;
exports.RESOURCE_PROPERTIES = RESOURCE_PROPERTIES;
exports.RESOURCE_SIZE_PROPERTIES = RESOURCE_SIZE_PROPERTIES;
exports.NUMERICAL_PROPERTIES = NUMERICAL_PROPERTIES;
exports.COLOR_PROPERTIES = COLOR_PROPERTIES;
exports.DEFAULT_TEXT_SIZE = DEFAULT_TEXT_SIZE;
exports.projection = projections;
exports.measurer = index$2;
exports.Coordinate = Coordinate;
exports.CRS = CRS;
exports.Extent = Extent;
exports.Point = Point;
exports.PointExtent = PointExtent;
exports.Size = Size;
exports.Transformation = Transformation;
exports.Layer = Layer;
exports.TileLayer = TileLayer;
exports.GroupTileLayer = GroupTileLayer;
exports.WMSTileLayer = WMSTileLayer;
exports.CanvasTileLayer = CanvasTileLayer;
exports.ImageLayer = ImageLayer;
exports.OverlayLayer = OverlayLayer;
exports.VectorLayer = VectorLayer;
exports.CanvasLayer = CanvasLayer;
exports.ParticleLayer = ParticleLayer;
exports.TileSystem = TileSystem;
exports.TileConfig = TileConfig;
exports.ArcCurve = ArcCurve;
exports.Circle = Circle;
exports.ConnectorLine = ConnectorLine;
exports.ArcConnectorLine = ArcConnectorLine;
exports.CubicBezierCurve = CubicBezierCurve;
exports.Curve = Curve;
exports.Ellipse = Ellipse;
exports.GeoJSON = GeoJSON;
exports.Geometry = Geometry;
exports.GeometryCollection = GeometryCollection;
exports.Label = Label;
exports.LineString = LineString;
exports.Marker = Marker;
exports.MultiLineString = MultiLineString;
exports.MultiPoint = MultiPoint;
exports.MultiPolygon = MultiPolygon;
exports.Polygon = Polygon;
exports.QuadBezierCurve = QuadBezierCurve;
exports.Rectangle = Rectangle;
exports.Sector = Sector;
exports.TextBox = TextBox;
exports.TextMarker = TextMarker;
Object.defineProperty(exports, '__esModule', { value: true });
// typeof console !== 'undefined' && console.log && console.log('maptalks v1.0.0-rc.30');
}));
/*!
* @maptalks/gl-layers v0.31.8
* LICENSE : MIT
* (c) 2016-2024 maptalks.com
*/
!function(global,factory){"object"==typeof exports&&"undefined"!=typeof module?factory(exports,require("maptalks")):"function"==typeof define&&define.amd?define(["exports","maptalks"],factory):factory((global="undefined"!=typeof globalThis?globalThis:global||self).maptalks=global.maptalks||{},global.maptalks)}(this,(function(exports,t$1){"use strict";function _interopNamespace(e){if(e&&e.__esModule)return e;var n=Object.create(null);return e&&Object.keys(e).forEach((function(k){if("default"!==k){var d=Object.getOwnPropertyDescriptor(e,k);Object.defineProperty(n,k,d.get?d:{enumerable:!0,get:function(){return e[k]}})}})),n.default=e,Object.freeze(n)}var t__namespace=_interopNamespace(t$1),regl_min=("undefined"!=typeof globalThis?globalThis:"undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self&&self,{exports:{}});!function(module,exports){module.exports=function(){function U(a,b){this.id=Cb++,this.type=a,this.data=b}function W(a){if(0===a.length)return[];var b=a.charAt(0),c=a.charAt(a.length-1);if(1{const s=this._parseResponse(e,t.responseType);return s.message?s:s.then((s=>"arraybuffer"===t.responseType?{data:s,cacheControl:e.headers.get("Cache-Control"),expires:e.headers.get("Expires"),contentType:e.headers.get("Content-Type")}:s)).catch((e=>{if(!e.code||e.code!==DOMException.ABORT_ERR)throw e}))})).catch((e=>{if(!e.code||e.code!==DOMException.ABORT_ERR)throw e}));return i.xhr=s,i},_parseResponse:(e,t)=>200!==e.status?{status:e.status,statusText:e.statusText,message:`incorrect http request with status code(${e.status}): ${e.statusText}`}:"arraybuffer"===t?e.arrayBuffer():"json"===t?e.json():e.text(),getArrayBuffer:(e,t={})=>(t||(t={}),t.responseType="arraybuffer",w$5.get(e,t)),getJSON:function(e,t={}){return t&&t.jsonp?w$5.jsonp(e):((t=t||{}).responseType="json",w$5.get(e,t))},jsonp:function(e){const t="_maptalks_jsonp_"+n$1++;e.match(/\?/)?e+="&callback="+t:e+="?callback="+t;let s=document.createElement("script");return s.type="text/javascript",s.src=e,new Promise((e=>{window[t]=function(r){document.getElementsByTagName("head")[0].removeChild(s),s=null,delete window[t],e(r)},document.getElementsByTagName("head")[0].appendChild(s)}))}};class T$7{constructor(e,t,s,r){this._requestImage=e,this.decoders=t,this._supportedFormats=s,this.images={},this._imgRequests={},this._fetchOptions=r||{}}requestImageFromBufferURI(e,t,s){if(this.buffers[e.id]){const n=this._createDataView(t,this.buffers[e.id]);return this.getImageByBuffer(n,s)}if(this._imgRequests[e.id])return this._imgRequests[e.id].then((()=>{const n=this._createDataView(t,this.buffers[e.id]);return this.getImageByBuffer(n,s)}));if(h$3(e.uri)){const r=this.buffers[e.id]=c$2(e.uri),n=this._createDataView(t,r);return this.getImageByBuffer(n,s)}let r;const n=e.uri.indexOf("blob:")>=0;return r=e.uri.indexOf("://")>0||n?e.uri:this.rootPath+"/"+e.uri,this._imgRequests[e.id]=w$5.getArrayBuffer(r,this._fetchOptions).then((r=>{const n=this.buffers[e.id]=r.data,i=this._createDataView(t,n);return this.getImageByBuffer(i,s)}))}getImageByBuffer(e,t){if(this.images[t.id])return Promise.resolve(this.images[t.id]);const s=this.decoders;return s[t.mimeType]?s[t.mimeType](e,{supportedFormats:this._supportedFormats}):"image/crn"===t.mimeType||"image/ktx2"===t.mimeType||"image/cttf"===t.mimeType?(console.warn("missing transcoder for "+t.mimeType,", visit https://maptalks.com/docs/transcoders for details"),Promise.resolve(null)):this._getImageInfo(t.id,e)}requestExternalImage(e){if(this.images[e.id])return Promise.resolve(this.images[e.id]);const t=0===e.uri.indexOf("data:image/")?e.uri:this.rootPath+"/"+e.uri;return this._imgRequests[e.id]?this._imgRequests[e.id].then((()=>this.images[e.id])):this._imgRequests[e.id]=this._getImageInfo(e.id,t)}_getImageInfo(e,t){return new Promise(((s,r)=>{this._requestImage(t,this._fetchOptions,((n,i)=>{n?r(n):(URL.revokeObjectURL(t),this.images[e]=i,s(this.images[e]))}))}))}}const E$7=["SCALAR",1,"VEC2",2,"VEC3",3,"VEC4",4,"MAT2",4,"MAT3",9,"MAT4",16],O$7=[];class I$6{constructor(e,t,s,r){this.rootPath=e,this.gltf=t,this._enableInterleave=!1,this.glbBuffer=s,this.buffers={},this.requests={},this.accessors={},this._compareAccessor(),this._fetchOptions=r}_requestData(e,t){const s=this.gltf,r=s.accessors[t];if(void 0===r.bufferView)return this.accessors[r.id]=this._toBufferData(e,t,null,0),Promise.resolve(this.accessors[r.id]);if(r&&this.accessors[r.id])return Promise.resolve(this.accessors[r.id]);return this._requestBufferOfBufferView(s.bufferViews[r.bufferView]).then((s=>{const{buffer:n,byteOffset:i}=s;return this.accessors[r.id]=this._toBufferData(e,t,n,i)}))}_requestBufferOfBufferView(e){const t=this.gltf.buffers[e.buffer];if(this.buffers[t.id]){return Promise.resolve({buffer:this.buffers[t.id],byteOffset:0})}if(this.requests[t.id])return this.requests[t.id].then((()=>Promise.resolve({buffer:this.buffers[t.id],byteOffset:0})));if("binary_glTF"!==e.buffer&&"KHR_binary_glTF"!==e.buffer&&t.uri){if(h$3(t.uri)){const e=this.buffers[t.id]=c$2(t.uri);return Promise.resolve({buffer:e,byteOffset:0})}let e;const s=t.uri.indexOf("blob:")>=0;return e=t.uri.indexOf("://")>0||s?t.uri:this.rootPath+"/"+t.uri,this.requests[t.id]=w$5.getArrayBuffer(e,this._fetchOptions).then((r=>(s&&URL.revokeObjectURL(e),{buffer:this.buffers[t.id]=r.data,byteOffset:0})))}return Promise.resolve({buffer:this.glbBuffer.buffer,byteOffset:this.glbBuffer.byteOffset})}_toBufferData(e,t,r,n=0){const i=this.gltf,a=i.accessors[t],o=void 0!==a.bufferView?i.bufferViews[a.bufferView]:{},f=(o.byteOffset||0)+n,h=this._getTypeItemSize(a.type),c=u$4(a.componentType),l=o.byteStride||0,m={array:void 0,name:e,accessorName:t,byteLength:a.count*h*c.BYTES_PER_ELEMENT,componentType:a.componentType,count:a.count,type:a.type,itemSize:h,max:a.max,min:a.min,extensions:a.extensions};if(a.min&&(m.min=a.min),a.max&&(m.max=a.max),r)if(this._enableInterleave)m.byteStride=l,m.byteOffset=f+(a.byteOffset||0),!l||l===h*c.BYTES_PER_ELEMENT||"indices"===e||"input"===e||"output"===e||e.indexOf("morph")>=0?(m.array=this._typedArray(r,a.count,h,f+(a.byteOffset||0),c),m.array.buffer.byteLength===m.byteLength&&(m.byteOffset=0)):m.array=new Uint8Array(r,f,o.byteLength);else if(a.interleaved){m.byteStride=0,m.byteOffset=0;const e=new c(a.count*h);if(m.array=y$5(e,r,a.count,h,l,f+(a.byteOffset||0),a.componentType),m.extensions&&m.extensions.WEB3D_quantized_attributes&&h>2){const e=new Float32Array(m.array.length),{decodeMatrix:t}=m.extensions.WEB3D_quantized_attributes;for(let r=0;r=4&&1!==t[3]&&(i=", "+t[3]),"hwb("+t[0]+", "+t[1]+"%, "+t[2]+"%"+i+")"},I$4.to.keyword=function(t){return A$3[t.slice(0,3)]};var F$5={exports:{}},R$5=x$5,P$4={};for(var D$5 in R$5)R$5.hasOwnProperty(D$5)&&(P$4[R$5[D$5]]=D$5);var H$5=F$5.exports={rgb:{channels:3,labels:"rgb"},hsl:{channels:3,labels:"hsl"},hsv:{channels:3,labels:"hsv"},hwb:{channels:3,labels:"hwb"},cmyk:{channels:4,labels:"cmyk"},xyz:{channels:3,labels:"xyz"},lab:{channels:3,labels:"lab"},lch:{channels:3,labels:"lch"},hex:{channels:1,labels:["hex"]},keyword:{channels:1,labels:["keyword"]},ansi16:{channels:1,labels:["ansi16"]},ansi256:{channels:1,labels:["ansi256"]},hcg:{channels:3,labels:["h","c","g"]},apple:{channels:3,labels:["r16","g16","b16"]},gray:{channels:1,labels:["gray"]}};for(var N$5 in H$5)if(H$5.hasOwnProperty(N$5)){if(!("channels"in H$5[N$5]))throw new Error("missing channels property: "+N$5);if(!("labels"in H$5[N$5]))throw new Error("missing channel labels property: "+N$5);if(H$5[N$5].labels.length!==H$5[N$5].channels)throw new Error("channel and label counts mismatch: "+N$5);var G$5=H$5[N$5].channels,j$5=H$5[N$5].labels;delete H$5[N$5].channels,delete H$5[N$5].labels,Object.defineProperty(H$5[N$5],"channels",{value:G$5}),Object.defineProperty(H$5[N$5],"labels",{value:j$5})}H$5.rgb.hsl=function(t){var i,e,s=t[0]/255,n=t[1]/255,r=t[2]/255,h=Math.min(s,n,r),o=Math.max(s,n,r),a=o-h;return o===h?i=0:s===o?i=(n-r)/a:n===o?i=2+(r-s)/a:r===o&&(i=4+(s-n)/a),(i=Math.min(60*i,360))<0&&(i+=360),e=(h+o)/2,[i,100*(o===h?0:e<=.5?a/(o+h):a/(2-o-h)),100*e]},H$5.rgb.hsv=function(t){var i,e,s,n,r,h=t[0]/255,o=t[1]/255,a=t[2]/255,l=Math.max(h,o,a),c=l-Math.min(h,o,a),u=function(t){return(l-t)/6/c+.5};return 0===c?n=r=0:(r=c/l,i=u(h),e=u(o),s=u(a),h===l?n=s-e:o===l?n=1/3+i-s:a===l&&(n=2/3+e-i),n<0?n+=1:n>1&&(n-=1)),[360*n,100*r,100*l]},H$5.rgb.hwb=function(t){var i=t[0],e=t[1],s=t[2];return[H$5.rgb.hsl(t)[0],1/255*Math.min(i,Math.min(e,s))*100,100*(s=1-1/255*Math.max(i,Math.max(e,s)))]},H$5.rgb.cmyk=function(t){var i,e=t[0]/255,s=t[1]/255,n=t[2]/255;return[100*((1-e-(i=Math.min(1-e,1-s,1-n)))/(1-i)||0),100*((1-s-i)/(1-i)||0),100*((1-n-i)/(1-i)||0),100*i]},H$5.rgb.keyword=function(t){var i=P$4[t];if(i)return i;var e,s,n,r=1/0;for(var h in R$5)if(R$5.hasOwnProperty(h)){var a=(s=t,n=R$5[h],Math.pow(s[0]-n[0],2)+Math.pow(s[1]-n[1],2)+Math.pow(s[2]-n[2],2));a1&&(i=Array.prototype.slice.call(arguments)),t(i))};return"conversion"in t&&(i.conversion=t.conversion),i}(s)}))}));var X$6=w$3.exports,J$6=$$5,Z$6=[].slice,K$6=["keyword","gray","hex"],Q$6={};Object.keys(J$6).forEach((function(t){Q$6[Z$6.call(J$6[t].labels).sort().join("")]=t}));var tt$5={};function it$4(t,i){if(!(this instanceof it$4))return new it$4(t,i);if(i&&i in K$6&&(i=null),i&&!(i in J$6))throw new Error("Unknown model: "+i);var e,s;if(null==t)this.model="rgb",this.color=[0,0,0],this.valpha=1;else if(t instanceof it$4)this.model=t.model,this.color=t.color.slice(),this.valpha=t.valpha;else if("string"==typeof t){var n=X$6.get(t);if(null===n)throw new Error("Unable to parse color from string: "+t);this.model=n.model,this.color=n.value.slice(0,s=J$6[this.model].channels),this.valpha="number"==typeof n.value[s]?n.value[s]:1}else if(t.length){this.model=i||"rgb";var r=Z$6.call(t,0,s=J$6[this.model].channels);this.color=rt$5(r,s),this.valpha="number"==typeof t[s]?t[s]:1}else if("number"==typeof t)t&=16777215,this.model="rgb",this.color=[t>>16&255,t>>8&255,255&t],this.valpha=1;else{this.valpha=1;var h=Object.keys(t);"alpha"in t&&(h.splice(h.indexOf("alpha"),1),this.valpha="number"==typeof t.alpha?t.alpha:0);var o=h.sort().join("");if(!(o in Q$6))throw new Error("Unable to parse color from object: "+JSON.stringify(t));this.model=Q$6[o];var a=J$6[this.model].labels,l=[];for(e=0;e{i.onload=()=>{const e=this.H.texture({mag:"linear",min:"linear mipmap nearest",wrapS:"clamp",wrapT:"clamp",data:i});t(e)},i.onerror=t=>{e(t)}}))}paint(t){if(!this.bt)return;const i=this.St(),e={},s=this.getMap();e.projMatrix=s.projMatrix,e.viewMatrix=s.viewMatrix,e.cameraPosition=s.cameraPosition;const n=i.speed||1,r=this.xt.getElapsedTime()/(2/n)%1;e.time=r,this._t.material.set("diffuse",i.color||Kt$4),this._t.material.set("opacity",i.opacity||1),this.Et(this._t);this.renderer.render(this.vt,e,this.bt,t&&t.renderTarget&&t.renderTarget.fbo),this.s.getRenderer().setCanvasUpdated()}Et(t){const i=this.getMap(),e=i.coordinateToPointAtRes(i.getCenter(),i.getGLRes()),s=i.getGLScale()/i.getGLScale(this.Tt),n=set$4(Jt$4,s,s,s),r=multiply$4(n,Yt$4,n),h=identity$2(Zt$4),o=this.St(),c=i.getBearing();fromRotationTranslationScale(h,fromEuler(Xt$4,o.windDirectionX||0,o.windDirectionY||0,90-c),[e.x,e.y,0],r),multiply$5(h,h,ei$3),t.setLocalTransform(h)}setToRedraw(){const t=this.s.getRenderer();t&&t.setToRedraw()}update(){const t=this.St();if(t){if(this._t||this.Mt(),t.density!==this.At||t.rainWidth!==this.Ot||t.rainHeight!==this.It){const t=this._t.material.get("rainMap");this._t.geometry.dispose(),this._t.dispose(),this.bt.clear(),this._t=this.yt(),this._t.material.set("rainMap",t),this.bt.setMeshes(this._t)}t.rainTexture!==this.Lt&&this.Ct(t.rainTexture).then((t=>{this._t.material.set("rainMap",t)}))}}dispose(){this._t&&(this._t.geometry.dispose(),this._t.material&&this._t.material.dispose(),this._t.dispose(),delete this._t),this.vt&&(this.vt.dispose(),delete this.vt)}isEnable(){const t=this.St();return t&&t.enable}St(){const t=this.s.getWeatherConfig();return t&&t.rain}kt(){const t=16.685648411389433-this.getMap().getZoom();return scale$4(ii$3.min,Qt$4,Math.pow(2,t)),scale$4(ii$3.max,ti$3,Math.pow(2,t)),ii$3}}class ni$3{constructor(t){this.autoStart=void 0===t||t,this.startTime=0,this.oldTime=0,this.elapsedTime=0,this.running=!1}start(){this.startTime=("undefined"==typeof performance?Date:performance).now(),this.oldTime=this.startTime,this.elapsedTime=0,this.running=!0}stop(){this.getElapsedTime(),this.running=!1,this.autoStart=!1}getElapsedTime(){return this.getDelta(),this.elapsedTime}getDelta(){let t=0;if(this.autoStart&&!this.running)return this.start(),0;if(this.running){const i=("undefined"==typeof performance?Date:performance).now();t=(i-this.oldTime)/1e3,this.oldTime=i,this.elapsedTime+=t}return 0}}const ri$3=[],hi$3=[.03,.03,.03],oi$3=[],ai$3=[],li$3=[],ci$3=fromRotationTranslation$1([],fromEuler([],90,0,0),[0,0,0]);class ui$3{constructor(t,i){this.H=t,this.s=i,this.h()}h(){const t=this.s.getRenderer().canvas;this.vt=new vn$4({vert:"#include {const{info:i,image:e}=t;this.hs(i,e)}))),s.resetCurrent(!1);for(let n=0;n0){let e=[];n.forEach(((t,i)=>{m.has(i)||pt$5(e,t)})),i.geometry.properties.hasInvisible=!0,Bs$3(i,e);const s={data:e,primitive:i.geometry.getPrimitive()};i.geometry.elements!==i.geometry.properties.oldElementsBeforeHighlight&&i.geometry.elements.destroy&&i.geometry.deleteElements(),e=t.elements(s),i.geometry.setElements(e),i.geometry.generateBuffers(t)}else i.geometry.properties.hasInvisible&&Us$3(i);i.setDefines(v),i.properties.highlightTimestamp=s;let w=i.properties.hlBloomMesh;if(p&&p.length){if(w){const t=copy$5(w.localTransform,i.localTransform),e=copy$5(w.positionMatrix,i.positionMatrix);w.setLocalTransform(t),w.setPositionMatrix(e),i.properties.hlBloomMesh.geometry.setElements(p)}else{const e=new Q$7(i.geometry.data,p,0,i.geometry.desc);e.generateBuffers(t);w=new Be$5(e,i.material,i.config);const n=i.uniforms;for(const t in n)Object.defineProperty(w.uniforms,t,{enumerable:!0,get:function(){return i.getUniform(t)}});const r=at$5({},i.defines);r.HAS_BLOOM=1;const h=copy$5([],i.localTransform),o=copy$5([],i.positionMatrix);w.setLocalTransform(h),w.setPositionMatrix(o),at$5(w.properties,i.properties),at$5(e.properties,i.geometry.properties),w.setDefines(r),w.bloom=1}i.properties.hlBloomMesh=w}else w&&Vs$3(i)},deleteHighlightBloomMesh:Vs$3});const qs$2=[0,0,0,0];class $s$2{constructor(t,i,e,s,n,r){this.renderer=new B$6(t),this.sceneConfig=i,this.s=e,this.Pn=s,this.Dn=n,this.ln=r||{factor:0,units:0},this.h(),this.Hn=[]}render(t,i,e){this.Nn();const s=this.s.getMap();this.renderer.regl.clear({color:qs$2,depth:1,stencil:255,framebuffer:this.Gn}),this.renderer.render(this.jn,i,t,this.Gn);const n=this.s.getRenderer().canvas;this.Hn[0]=n.width,this.Hn[1]=n.height;const r=at$5({colorRamp:this.Bn,inputTexture:this.Gn,projViewMatrix:s.projViewMatrix,textureOutputSize:this.Hn},i);return this.m(),this.renderer.render(this.Un,r,this.D,e)}dispose(){this.jn&&(this.jn.dispose(),delete this.jn),this.Un&&(this.Un.dispose(),delete this.Un),this.S&&(this.S.geometry.dispose(),this.S.dispose(),delete this.S,delete this.D),this.Gn&&(this.Gn.destroy(),delete this.Gn)}zn(){const t=this.Pn;let i=this.Vn,e=this.Wn;e?e.clearRect(0,0,256,1):(i=this.Vn=document.createElement("canvas"),i.width=256,i.height=1,e=this.Wn=i.getContext("2d"));const s=e.createLinearGradient(0,0,256,1);for(let i=0;i