ashatora/openlayers
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Redefine ol.Size to be Array.<number>

Browse Source
This commit is contained in:
Frederic Junod
2013-05-31 16:24:47 +02:00
parent 1d7ca27e61
commit a1a7e21f92
33 changed files with 139 additions and 157 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/ol/renderer/canvas/canvasimagelayerrenderer.js
View File

@@ -104,7 +104,7 @@ ol.renderer.canvas.ImageLayer.prototype.renderFrame =
var transform = this.transform_;
goog.vec.Mat4.makeIdentity(transform);
goog.vec.Mat4.translate(transform,
frameState.size.width / 2, frameState.size.height / 2, 0);
frameState.size[0] / 2, frameState.size[1] / 2, 0);
goog.vec.Mat4.rotateZ(transform, viewRotation);
goog.vec.Mat4.scale(
transform,

25
src/ol/renderer/canvas/canvasmaprenderer.js
View File

@@ -16,6 +16,7 @@ goog.require('ol.renderer.Map');
goog.require('ol.renderer.canvas.ImageLayer');
goog.require('ol.renderer.canvas.TileLayer');
goog.require('ol.renderer.canvas.VectorLayer');
goog.require('ol.size');
@@ -29,19 +30,13 @@ ol.renderer.canvas.Map = function(container, map) {
goog.base(this, container, map);
/**
* @private
* @type {ol.Size}
*/
this.canvasSize_ = new ol.Size(container.clientHeight, container.clientWidth);
/**
* @private
* @type {Element}
*/
this.canvas_ = goog.dom.createElement(goog.dom.TagName.CANVAS);
this.canvas_.height = this.canvasSize_.height;
this.canvas_.width = this.canvasSize_.width;
this.canvas_.height = container.clientHeight;
this.canvas_.width = container.clientWidth;
this.canvas_.className = ol.css.CLASS_UNSELECTABLE;
goog.dom.insertChildAt(container, this.canvas_, 0);
@@ -51,6 +46,12 @@ ol.renderer.canvas.Map = function(container, map) {
*/
this.renderedVisible_ = true;
/**
* @private
* @type {ol.Size}
*/
this.canvasSize_ = [container.clientHeight, container.clientWidth];
/**
* @private
* @type {CanvasRenderingContext2D}
@@ -100,15 +101,15 @@ ol.renderer.canvas.Map.prototype.renderFrame = function(frameState) {
}
var size = frameState.size;
if (!this.canvasSize_.equals(size)) {
this.canvas_.width = size.width;
this.canvas_.height = size.height;
if (!ol.size.equals(this.canvasSize_, size)) {
this.canvas_.width = size[0];
this.canvas_.height = size[1];
this.canvasSize_ = size;
}
var context = this.context_;
context.setTransform(1, 0, 0, 1, 0, 0);
context.clearRect(0, 0, size.width, size.height);
context.clearRect(0, 0, size[0], size[1]);
this.calculateMatrices2D(frameState);

39
src/ol/renderer/canvas/canvastilelayerrenderer.js
View File

@@ -195,8 +195,8 @@ ol.renderer.canvas.TileLayer.prototype.renderFrame =
var tileRange = tileGrid.getTileRangeForExtentAndResolution(
extent, tileResolution);
var canvasWidth = tileSize.width * tileRange.getWidth();
var canvasHeight = tileSize.height * tileRange.getHeight();
var canvasWidth = tileSize[0] * tileRange.getWidth();
var canvasHeight = tileSize[1] * tileRange.getHeight();
var canvas, context;
if (goog.isNull(this.canvas_)) {
@@ -209,24 +209,23 @@ ol.renderer.canvas.TileLayer.prototype.renderFrame =
canvas.height = canvasHeight;
context = /** @type {CanvasRenderingContext2D} */ (canvas.getContext('2d'));
this.canvas_ = canvas;
this.canvasSize_ = new ol.Size(canvasWidth, canvasHeight);
this.canvasSize_ = [canvasWidth, canvasHeight];
this.context_ = context;
} else {
goog.asserts.assert(!goog.isNull(this.canvasSize_));
goog.asserts.assert(!goog.isNull(this.context_));
canvas = this.canvas_;
context = this.context_;
if (this.canvasSize_.width < canvasWidth ||
this.canvasSize_.height < canvasHeight) {
if (this.canvasSize_[0] < canvasWidth ||
this.canvasSize_[1] < canvasHeight) {
// Canvas is too small, make it bigger
canvas.width = canvasWidth;
canvas.height = canvasHeight;
this.canvasSize_.width = canvasWidth;
this.canvasSize_.height = canvasHeight;
this.canvasSize_ = [canvasWidth, canvasHeight];
this.renderedCanvasTileRange_ = null;
} else {
canvasWidth = this.canvasSize_.width;
canvasHeight = this.canvasSize_.height;
canvasWidth = this.canvasSize_[0];
canvasHeight = this.canvasSize_[1];
if (z != this.renderedCanvasZ_ ||
!this.renderedCanvasTileRange_.containsTileRange(tileRange)) {
this.renderedCanvasTileRange_ = null;
@@ -236,8 +235,8 @@ ol.renderer.canvas.TileLayer.prototype.renderFrame =
var canvasTileRange, canvasTileRangeWidth, minX, minY;
if (goog.isNull(this.renderedCanvasTileRange_)) {
canvasTileRangeWidth = canvasWidth / tileSize.width;
var canvasTileRangeHeight = canvasHeight / tileSize.height;
canvasTileRangeWidth = canvasWidth / tileSize[0];
var canvasTileRangeHeight = canvasHeight / tileSize[1];
minX = tileRange.minX -
Math.floor((canvasTileRangeWidth - tileRange.getWidth()) / 2);
minY = tileRange.minY -
@@ -304,9 +303,9 @@ ol.renderer.canvas.TileLayer.prototype.renderFrame =
var i, ii;
for (i = 0, ii = tilesToClear.length; i < ii; ++i) {
tile = tilesToClear[i];
x = tileSize.width * (tile.tileCoord.x - canvasTileRange.minX);
y = tileSize.height * (canvasTileRange.maxY - tile.tileCoord.y);
context.clearRect(x, y, tileSize.width, tileSize.height);
x = tileSize[0] * (tile.tileCoord.x - canvasTileRange.minX);
y = tileSize[1] * (canvasTileRange.maxY - tile.tileCoord.y);
context.clearRect(x, y, tileSize[0], tileSize[1]);
}
/** @type {Array.<number>} */
@@ -330,13 +329,13 @@ ol.renderer.canvas.TileLayer.prototype.renderFrame =
(tile.tileCoord.y - canvasTileRange.minY) * canvasTileRangeWidth +
(tile.tileCoord.x - canvasTileRange.minX);
if (this.renderedTiles_[index] != tile) {
x = tileSize.width * (tile.tileCoord.x - canvasTileRange.minX);
y = tileSize.height * (canvasTileRange.maxY - tile.tileCoord.y);
x = tileSize[0] * (tile.tileCoord.x - canvasTileRange.minX);
y = tileSize[1] * (canvasTileRange.maxY - tile.tileCoord.y);
tileState = tile.getState();
if (tileState == ol.TileState.EMPTY ||
tileState == ol.TileState.ERROR ||
!opaque) {
context.clearRect(x, y, tileSize.width, tileSize.height);
context.clearRect(x, y, tileSize[0], tileSize[1]);
}
if (tileState == ol.TileState.LOADED) {
context.drawImage(tile.getImage(), x, y);
@@ -351,8 +350,8 @@ ol.renderer.canvas.TileLayer.prototype.renderFrame =
tileExtent = tileGrid.getTileCoordExtent(tile.tileCoord, tmpExtent);
x = (tileExtent[0] - origin[0]) / tileResolution;
y = (origin[1] - tileExtent[3]) / tileResolution;
width = scale * tileSize.width;
height = scale * tileSize.height;
width = scale * tileSize[0];
height = scale * tileSize[1];
tileState = tile.getState();
if (tileState == ol.TileState.EMPTY || !opaque) {
context.clearRect(x, y, width, height);
@@ -386,7 +385,7 @@ ol.renderer.canvas.TileLayer.prototype.renderFrame =
var transform = this.transform_;
goog.vec.Mat4.makeIdentity(transform);
goog.vec.Mat4.translate(transform,
frameState.size.width / 2, frameState.size.height / 2, 0);
frameState.size[0] / 2, frameState.size[1] / 2, 0);
goog.vec.Mat4.rotateZ(transform, view2DState.rotation);
goog.vec.Mat4.scale(
transform,

36
src/ol/renderer/canvas/canvasvectorlayerrenderer.js
View File

@@ -7,7 +7,6 @@ goog.require('goog.events.EventType');
goog.require('goog.object');
goog.require('goog.vec.Mat4');
goog.require('ol.Pixel');
goog.require('ol.Size');
goog.require('ol.TileCache');
goog.require('ol.TileCoord');
goog.require('ol.ViewHint');
@@ -297,7 +296,7 @@ ol.renderer.canvas.VectorLayer.prototype.renderFrame =
tileGrid = ol.tilegrid.createForProjection(
view2DState.projection,
22, // should be no harm in going big here - ideally, it would be ∞
new ol.Size(512, 512));
[512, 512]);
this.tileGrid_ = tileGrid;
}
@@ -313,8 +312,8 @@ ol.renderer.canvas.VectorLayer.prototype.renderFrame =
goog.vec.Mat4.makeIdentity(transform);
goog.vec.Mat4.translate(transform,
frameState.size.width / 2,
frameState.size.height / 2,
frameState.size[0] / 2,
frameState.size[1] / 2,
0);
goog.vec.Mat4.scale(transform,
tileResolution / resolution, tileResolution / resolution, 1);
@@ -339,8 +338,8 @@ ol.renderer.canvas.VectorLayer.prototype.renderFrame =
if (goog.isNull(this.tileArchetype_)) {
this.tileArchetype_ = /** @type {HTMLCanvasElement} */
(goog.dom.createElement(goog.dom.TagName.CANVAS));
this.tileArchetype_.width = tileSize.width;
this.tileArchetype_.height = tileSize.height;
this.tileArchetype_.width = tileSize[0];
this.tileArchetype_.height = tileSize[1];
}
/**
@@ -348,14 +347,13 @@ ol.renderer.canvas.VectorLayer.prototype.renderFrame =
* and will have rendered all newly visible features.
*/
var sketchCanvas = this.sketchCanvas_;
var sketchSize = new ol.Size(
tileSize.width * tileRange.getWidth(),
tileSize.height * tileRange.getHeight());
var sketchWidth = tileSize[0] * tileRange.getWidth();
var sketchHeight = tileSize[1] * tileRange.getHeight();
// transform for map coords to sketch canvas pixel coords
var sketchTransform = this.sketchTransform_;
var halfWidth = sketchSize.width / 2;
var halfHeight = sketchSize.height / 2;
var halfWidth = sketchWidth / 2;
var halfHeight = sketchHeight / 2;
goog.vec.Mat4.makeIdentity(sketchTransform);
goog.vec.Mat4.translate(sketchTransform,
halfWidth,
@@ -371,16 +369,16 @@ ol.renderer.canvas.VectorLayer.prototype.renderFrame =
0);
// clear/resize sketch canvas
sketchCanvas.width = sketchSize.width;
sketchCanvas.height = sketchSize.height;
sketchCanvas.width = sketchWidth;
sketchCanvas.height = sketchHeight;
var sketchCanvasRenderer = new ol.renderer.canvas.VectorRenderer(
sketchCanvas, sketchTransform, undefined, this.requestMapRenderFrame_);
// clear/resize final canvas
var finalCanvas = this.canvas_;
finalCanvas.width = sketchSize.width;
finalCanvas.height = sketchSize.height;
finalCanvas.width = sketchWidth;
finalCanvas.height = sketchHeight;
var finalContext = this.context_;
var featuresToRender = {};
@@ -456,13 +454,13 @@ ol.renderer.canvas.VectorLayer.prototype.renderFrame =
tile = /** @type {HTMLCanvasElement} */
(this.tileArchetype_.cloneNode(false));
tile.getContext('2d').drawImage(sketchCanvas,
(tileRange.minX - tileCoord.x) * tileSize.width,
(tileCoord.y - tileRange.maxY) * tileSize.height);
(tileRange.minX - tileCoord.x) * tileSize[0],
(tileCoord.y - tileRange.maxY) * tileSize[1]);
this.tileCache_.set(key, [tile, symbolSizes, maxSymbolSize]);
}
finalContext.drawImage(tile,
tileSize.width * (tileCoord.x - tileRange.minX),
tileSize.height * (tileRange.maxY - tileCoord.y));
tileSize[0] * (tileCoord.x - tileRange.minX),
tileSize[1] * (tileRange.maxY - tileCoord.y));
}
this.renderedResolution_ = tileResolution;

2
src/ol/renderer/dom/domimagelayerrenderer.js
View File

@@ -90,7 +90,7 @@ ol.renderer.dom.ImageLayer.prototype.renderFrame =
var transform = goog.vec.Mat4.createNumber();
goog.vec.Mat4.makeIdentity(transform);
goog.vec.Mat4.translate(transform,
frameState.size.width / 2, frameState.size.height / 2, 0);
frameState.size[0] / 2, frameState.size[1] / 2, 0);
goog.vec.Mat4.rotateZ(transform, viewRotation);
goog.vec.Mat4.scale(
transform,

6
src/ol/renderer/dom/domtilelayerrenderer.js
View File

@@ -191,7 +191,7 @@ ol.renderer.dom.TileLayer.prototype.renderFrame =
origin = tileLayerZ.getOrigin();
goog.vec.Mat4.makeIdentity(transform);
goog.vec.Mat4.translate(
transform, frameState.size.width / 2, frameState.size.height / 2, 0);
transform, frameState.size[0] / 2, frameState.size[1] / 2, 0);
goog.vec.Mat4.rotateZ(transform, view2DState.rotation);
goog.vec.Mat4.scale(transform, resolution / view2DState.resolution,
resolution / view2DState.resolution, 1);
@@ -319,9 +319,9 @@ ol.renderer.dom.TileLayerZ_.prototype.addTile = function(tile) {
style.maxWidth = 'none';
style.position = 'absolute';
style.left =
((tileCoord.x - this.tileCoordOrigin_.x) * tileSize.width) + 'px';
((tileCoord.x - this.tileCoordOrigin_.x) * tileSize[0]) + 'px';
style.top =
((this.tileCoordOrigin_.y - tileCoord.y) * tileSize.height) + 'px';
((this.tileCoordOrigin_.y - tileCoord.y) * tileSize[1]) + 'px';
if (goog.isNull(this.documentFragment_)) {
this.documentFragment_ = document.createDocumentFragment();
}

4
src/ol/renderer/layerrenderer.js
View File

@@ -290,8 +290,8 @@ ol.renderer.Layer.prototype.createGetTileIfLoadedFunction =
ol.renderer.Layer.prototype.snapCenterToPixel =
function(center, resolution, size) {
return [
resolution * (Math.round(center[0] / resolution) + (size.width % 2) / 2),
resolution * (Math.round(center[1] / resolution) + (size.height % 2) / 2)
resolution * (Math.round(center[0] / resolution) + (size[0] % 2) / 2),
resolution * (Math.round(center[1] / resolution) + (size[1] % 2) / 2)
];
};

4
src/ol/renderer/maprenderer.js
View File

@@ -49,8 +49,8 @@ ol.renderer.Map.prototype.calculateMatrices2D = function(frameState) {
goog.vec.Mat4.makeIdentity(coordinateToPixelMatrix);
goog.vec.Mat4.translate(coordinateToPixelMatrix,
frameState.size.width / 2,
frameState.size.height / 2,
frameState.size[0] / 2,
frameState.size[1] / 2,
0);
goog.vec.Mat4.scale(coordinateToPixelMatrix,
1 / view2DState.resolution,

11
src/ol/renderer/webgl/webglmaprenderer.js
View File

@@ -23,6 +23,7 @@ goog.require('ol.renderer.webgl.ImageLayer');
goog.require('ol.renderer.webgl.TileLayer');
goog.require('ol.renderer.webgl.map.shader.Color');
goog.require('ol.renderer.webgl.map.shader.Default');
goog.require('ol.size');
goog.require('ol.structs.Buffer');
goog.require('ol.structs.IntegerSet');
goog.require('ol.structs.LRUCache');
@@ -83,7 +84,7 @@ ol.renderer.webgl.Map = function(container, map) {
* @private
* @type {ol.Size}
*/
this.canvasSize_ = new ol.Size(container.clientHeight, container.clientWidth);
this.canvasSize_ = [container.clientHeight, container.clientWidth];
/**
* @private
@@ -556,9 +557,9 @@ ol.renderer.webgl.Map.prototype.renderFrame = function(frameState) {
}
var size = frameState.size;
if (!this.canvasSize_.equals(size)) {
this.canvas_.width = size.width;
this.canvas_.height = size.height;
if (!ol.size.equals(this.canvasSize_, size)) {
this.canvas_.width = size[0];
this.canvas_.height = size[1];
this.canvasSize_ = size;
}
@@ -567,7 +568,7 @@ ol.renderer.webgl.Map.prototype.renderFrame = function(frameState) {
gl.clearColor(0, 0, 0, 0);
gl.clear(goog.webgl.COLOR_BUFFER_BIT);
gl.enable(goog.webgl.BLEND);
gl.viewport(0, 0, size.width, size.height);
gl.viewport(0, 0, size[0], size[1]);
this.bindBuffer(goog.webgl.ARRAY_BUFFER, this.arrayBuffer_);

12
src/ol/renderer/webgl/webgltilelayerrenderer.js
View File

@@ -146,13 +146,13 @@ ol.renderer.webgl.TileLayer.prototype.renderFrame =
var tileSize = tileGrid.getTileSize(z);
var maxDimension = Math.max(
tileRangeSize.width * tileSize.width,
tileRangeSize.height * tileSize.height);
tileRangeSize[0] * tileSize[0],
tileRangeSize[1] * tileSize[1]);
var framebufferDimension = ol.math.roundUpToPowerOfTwo(maxDimension);
var framebufferExtentDimension = tileResolution * framebufferDimension;
var origin = tileGrid.getOrigin(z);
var minX = origin[0] + tileRange.minX * tileSize.width * tileResolution;
var minY = origin[1] + tileRange.minY * tileSize.height * tileResolution;
var minX = origin[0] + tileRange.minX * tileSize[0] * tileResolution;
var minY = origin[1] + tileRange.minY * tileSize[1] * tileResolution;
framebufferExtent = [
minX, minX + framebufferExtentDimension,
minY, minY + framebufferExtentDimension
@@ -292,9 +292,9 @@ ol.renderer.webgl.TileLayer.prototype.renderFrame =
0);
goog.vec.Mat4.rotateZ(texCoordMatrix, view2DState.rotation);
goog.vec.Mat4.scale(texCoordMatrix,
frameState.size.width * view2DState.resolution /
frameState.size[0] * view2DState.resolution /
(framebufferExtent[1] - framebufferExtent[0]),
frameState.size.height * view2DState.resolution /
frameState.size[1] * view2DState.resolution /
(framebufferExtent[3] - framebufferExtent[2]),
1);
goog.vec.Mat4.translate(texCoordMatrix,