263 lines
7.6 KiB
JavaScript
263 lines
7.6 KiB
JavaScript
goog.provide('ol.renderer.canvas.VectorLayer');
|
|
|
|
goog.require('goog.array');
|
|
goog.require('goog.asserts');
|
|
goog.require('goog.events');
|
|
goog.require('ol.ViewHint');
|
|
goog.require('ol.dom');
|
|
goog.require('ol.extent');
|
|
goog.require('ol.feature');
|
|
goog.require('ol.layer.Vector');
|
|
goog.require('ol.render.EventType');
|
|
goog.require('ol.render.canvas.ReplayGroup');
|
|
goog.require('ol.renderer.canvas.Layer');
|
|
goog.require('ol.renderer.vector');
|
|
goog.require('ol.source.Vector');
|
|
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
* @extends {ol.renderer.canvas.Layer}
|
|
* @param {ol.renderer.Map} mapRenderer Map renderer.
|
|
* @param {ol.layer.Vector} vectorLayer Vector layer.
|
|
*/
|
|
ol.renderer.canvas.VectorLayer = function(mapRenderer, vectorLayer) {
|
|
|
|
goog.base(this, mapRenderer, vectorLayer);
|
|
|
|
/**
|
|
* @private
|
|
* @type {boolean}
|
|
*/
|
|
this.dirty_ = false;
|
|
|
|
/**
|
|
* @private
|
|
* @type {number}
|
|
*/
|
|
this.renderedRevision_ = -1;
|
|
|
|
/**
|
|
* @private
|
|
* @type {number}
|
|
*/
|
|
this.renderedResolution_ = NaN;
|
|
|
|
/**
|
|
* @private
|
|
* @type {ol.Extent}
|
|
*/
|
|
this.renderedExtent_ = ol.extent.createEmpty();
|
|
|
|
/**
|
|
* @private
|
|
* @type {function(ol.Feature, ol.Feature): number|null}
|
|
*/
|
|
this.renderedRenderOrder_ = null;
|
|
|
|
/**
|
|
* @private
|
|
* @type {ol.render.canvas.ReplayGroup}
|
|
*/
|
|
this.replayGroup_ = null;
|
|
|
|
/**
|
|
* @private
|
|
* @type {CanvasRenderingContext2D}
|
|
*/
|
|
this.context_ = ol.dom.createCanvasContext2D();
|
|
|
|
};
|
|
goog.inherits(ol.renderer.canvas.VectorLayer, ol.renderer.canvas.Layer);
|
|
|
|
|
|
/**
|
|
* @inheritDoc
|
|
*/
|
|
ol.renderer.canvas.VectorLayer.prototype.composeFrame =
|
|
function(frameState, layerState, context) {
|
|
|
|
var transform = this.getTransform(frameState);
|
|
|
|
this.dispatchPreComposeEvent(context, frameState, transform);
|
|
|
|
var replayGroup = this.replayGroup_;
|
|
if (!goog.isNull(replayGroup) && !replayGroup.isEmpty()) {
|
|
var layer = this.getLayer();
|
|
var replayContext;
|
|
if (layer.hasListener(ol.render.EventType.RENDER)) {
|
|
// resize and clear
|
|
this.context_.canvas.width = context.canvas.width;
|
|
this.context_.canvas.height = context.canvas.height;
|
|
replayContext = this.context_;
|
|
} else {
|
|
replayContext = context;
|
|
}
|
|
replayContext.globalAlpha = layerState.opacity;
|
|
replayGroup.replay(
|
|
replayContext, frameState.extent, frameState.pixelRatio, transform,
|
|
frameState.view2DState.rotation, frameState.skippedFeatureUids_);
|
|
|
|
if (replayContext != context) {
|
|
this.dispatchRenderEvent(replayContext, frameState, transform);
|
|
context.drawImage(replayContext.canvas, 0, 0);
|
|
}
|
|
}
|
|
|
|
this.dispatchPostComposeEvent(context, frameState, transform);
|
|
|
|
};
|
|
|
|
|
|
/**
|
|
* @inheritDoc
|
|
*/
|
|
ol.renderer.canvas.VectorLayer.prototype.forEachFeatureAtPixel =
|
|
function(coordinate, frameState, callback, thisArg) {
|
|
if (goog.isNull(this.replayGroup_)) {
|
|
return undefined;
|
|
} else {
|
|
var extent = frameState.extent;
|
|
var resolution = frameState.view2DState.resolution;
|
|
var rotation = frameState.view2DState.rotation;
|
|
var layer = this.getLayer();
|
|
return this.replayGroup_.forEachGeometryAtPixel(extent, resolution,
|
|
rotation, coordinate, frameState.skippedFeatureUids_,
|
|
/**
|
|
* @param {ol.geom.Geometry} geometry Geometry.
|
|
* @param {Object} data Data.
|
|
* @return {?} Callback result.
|
|
*/
|
|
function(geometry, data) {
|
|
var feature = /** @type {ol.Feature} */ (data);
|
|
goog.asserts.assert(goog.isDef(feature));
|
|
return callback.call(thisArg, feature, layer);
|
|
});
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Handle changes in image style state.
|
|
* @param {goog.events.Event} event Image style change event.
|
|
* @private
|
|
*/
|
|
ol.renderer.canvas.VectorLayer.prototype.handleImageChange_ =
|
|
function(event) {
|
|
this.renderIfReadyAndVisible();
|
|
};
|
|
|
|
|
|
/**
|
|
* @inheritDoc
|
|
*/
|
|
ol.renderer.canvas.VectorLayer.prototype.prepareFrame =
|
|
function(frameState, layerState) {
|
|
|
|
var vectorLayer = this.getLayer();
|
|
goog.asserts.assertInstanceof(vectorLayer, ol.layer.Vector);
|
|
var vectorSource = vectorLayer.getSource();
|
|
goog.asserts.assertInstanceof(vectorSource, ol.source.Vector);
|
|
|
|
this.updateAttributions(
|
|
frameState.attributions, vectorSource.getAttributions());
|
|
this.updateLogos(frameState, vectorSource);
|
|
|
|
if (!this.dirty_ && (frameState.viewHints[ol.ViewHint.ANIMATING] ||
|
|
frameState.viewHints[ol.ViewHint.INTERACTING])) {
|
|
return;
|
|
}
|
|
|
|
var frameStateExtent = frameState.extent;
|
|
var frameStateResolution = frameState.view2DState.resolution;
|
|
var pixelRatio = frameState.pixelRatio;
|
|
var vectorLayerRevision = vectorLayer.getRevision();
|
|
var vectorLayerRenderOrder = vectorLayer.getRenderOrder();
|
|
if (!goog.isDef(vectorLayerRenderOrder)) {
|
|
vectorLayerRenderOrder = ol.renderer.vector.defaultOrder;
|
|
}
|
|
|
|
if (!this.dirty_ &&
|
|
this.renderedResolution_ == frameStateResolution &&
|
|
this.renderedRevision_ == vectorLayerRevision &&
|
|
this.renderedRenderOrder_ == vectorLayerRenderOrder &&
|
|
ol.extent.containsExtent(this.renderedExtent_, frameStateExtent)) {
|
|
return;
|
|
}
|
|
|
|
var extent = this.renderedExtent_;
|
|
var xBuffer = ol.extent.getWidth(frameStateExtent) / 4;
|
|
var yBuffer = ol.extent.getHeight(frameStateExtent) / 4;
|
|
extent[0] = frameStateExtent[0] - xBuffer;
|
|
extent[1] = frameStateExtent[1] - yBuffer;
|
|
extent[2] = frameStateExtent[2] + xBuffer;
|
|
extent[3] = frameStateExtent[3] + yBuffer;
|
|
|
|
// FIXME dispose of old replayGroup in post render
|
|
goog.dispose(this.replayGroup_);
|
|
this.replayGroup_ = null;
|
|
|
|
this.dirty_ = false;
|
|
|
|
var styleFunction = vectorLayer.getStyleFunction();
|
|
if (!goog.isDef(styleFunction)) {
|
|
styleFunction = ol.feature.defaultStyleFunction;
|
|
}
|
|
var tolerance = frameStateResolution / (2 * pixelRatio);
|
|
var replayGroup = new ol.render.canvas.ReplayGroup(tolerance, extent,
|
|
frameStateResolution);
|
|
var renderFeature =
|
|
/**
|
|
* @param {ol.Feature} feature Feature.
|
|
* @this {ol.renderer.canvas.VectorLayer}
|
|
*/
|
|
function(feature) {
|
|
goog.asserts.assert(goog.isDef(styleFunction));
|
|
var dirty = this.renderFeature(
|
|
feature, frameStateResolution, pixelRatio, styleFunction, replayGroup);
|
|
this.dirty_ = this.dirty_ || dirty;
|
|
};
|
|
if (!goog.isNull(vectorLayerRenderOrder)) {
|
|
var features = vectorSource.getFeaturesInExtent(extent);
|
|
goog.array.sort(features, vectorLayerRenderOrder);
|
|
goog.array.forEach(features, renderFeature, this);
|
|
} else {
|
|
vectorSource.forEachFeatureInExtent(extent, renderFeature, this);
|
|
}
|
|
replayGroup.finish();
|
|
|
|
this.renderedResolution_ = frameStateResolution;
|
|
this.renderedRevision_ = vectorLayerRevision;
|
|
this.renderedRenderOrder_ = vectorLayerRenderOrder;
|
|
this.replayGroup_ = replayGroup;
|
|
|
|
};
|
|
|
|
|
|
/**
|
|
* @param {ol.Feature} feature Feature.
|
|
* @param {number} resolution Resolution.
|
|
* @param {number} pixelRatio Pixel ratio.
|
|
* @param {ol.feature.StyleFunction} styleFunction Style function.
|
|
* @param {ol.render.canvas.ReplayGroup} replayGroup Replay group.
|
|
* @return {boolean} `true` if an image is loading.
|
|
*/
|
|
ol.renderer.canvas.VectorLayer.prototype.renderFeature =
|
|
function(feature, resolution, pixelRatio, styleFunction, replayGroup) {
|
|
var styles = styleFunction(feature, resolution);
|
|
if (!goog.isDefAndNotNull(styles)) {
|
|
return false;
|
|
}
|
|
// simplify to a tolerance of half a device pixel
|
|
var squaredTolerance =
|
|
resolution * resolution / (4 * pixelRatio * pixelRatio);
|
|
var i, ii, loading = false;
|
|
for (i = 0, ii = styles.length; i < ii; ++i) {
|
|
loading = ol.renderer.vector.renderFeature(
|
|
replayGroup, feature, styles[i], squaredTolerance, feature,
|
|
this.handleImageChange_, this) || loading;
|
|
}
|
|
return loading;
|
|
};
|