Reorganize renderers
This commit is contained in:
Tom Payne
@@ -0,0 +1,114 @@
|
||||
goog.provide('ol3.renderer.webgl.Layer');
|
||||
|
||||
goog.require('goog.vec.Mat4');
|
||||
goog.require('ol3.Layer');
|
||||
goog.require('ol3.renderer.Layer');
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
* @extends {ol3.renderer.Layer}
|
||||
* @param {ol3.renderer.Map} mapRenderer Map renderer.
|
||||
* @param {ol3.Layer} layer Layer.
|
||||
*/
|
||||
ol3.renderer.webgl.Layer = function(mapRenderer, layer) {
|
||||
goog.base(this, mapRenderer, layer);
|
||||
};
|
||||
goog.inherits(ol3.renderer.webgl.Layer, ol3.renderer.Layer);
|
||||
|
||||
|
||||
/**
|
||||
* @protected
|
||||
*/
|
||||
ol3.renderer.webgl.Layer.prototype.dispatchChangeEvent = function() {
|
||||
this.dispatchEvent(goog.events.EventType.CHANGE);
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @override
|
||||
* @return {ol3.renderer.Map} MapRenderer.
|
||||
*/
|
||||
ol3.renderer.webgl.Layer.prototype.getMapRenderer = function() {
|
||||
return /** @type {ol3.renderer.webgl.Map} */ goog.base(
|
||||
this, 'getMapRenderer');
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @return {goog.vec.Mat4.AnyType} Matrix.
|
||||
*/
|
||||
ol3.renderer.webgl.Layer.prototype.getMatrix = goog.abstractMethod;
|
||||
|
||||
|
||||
/**
|
||||
* @return {WebGLTexture} Texture.
|
||||
*/
|
||||
ol3.renderer.webgl.Layer.prototype.getTexture = goog.abstractMethod;
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
ol3.renderer.webgl.Layer.prototype.handleLayerBrightnessChange = function() {
|
||||
this.dispatchChangeEvent();
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
ol3.renderer.webgl.Layer.prototype.handleLayerContrastChange = function() {
|
||||
this.dispatchChangeEvent();
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
ol3.renderer.webgl.Layer.prototype.handleLayerHueChange = function() {
|
||||
this.dispatchChangeEvent();
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
ol3.renderer.webgl.Layer.prototype.handleLayerLoad = function() {
|
||||
this.dispatchChangeEvent();
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
ol3.renderer.webgl.Layer.prototype.handleLayerOpacityChange = function() {
|
||||
this.dispatchChangeEvent();
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
ol3.renderer.webgl.Layer.prototype.handleLayerSaturationChange = function() {
|
||||
this.dispatchChangeEvent();
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
ol3.renderer.webgl.Layer.prototype.handleLayerVisibleChange = function() {
|
||||
this.dispatchChangeEvent();
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
*/
|
||||
ol3.renderer.webgl.Layer.prototype.handleWebGLContextLost = goog.nullFunction;
|
||||
|
||||
|
||||
/**
|
||||
*/
|
||||
ol3.renderer.webgl.Layer.prototype.render = goog.abstractMethod;
|
||||
@@ -0,0 +1,640 @@
|
||||
// FIXME clear textureCache
|
||||
// FIXME defer texture loads until after render when animating
|
||||
// FIXME generational tile texture garbage collector newFrame/get
|
||||
// FIXME defer cleanup until post-render
|
||||
// FIXME check against gl.getParameter(webgl.MAX_TEXTURE_SIZE)
|
||||
|
||||
goog.provide('ol3.renderer.webgl.Map');
|
||||
goog.provide('ol3.renderer.webgl.map.shader');
|
||||
|
||||
goog.require('goog.debug.Logger');
|
||||
goog.require('goog.dispose');
|
||||
goog.require('goog.dom');
|
||||
goog.require('goog.dom.TagName');
|
||||
goog.require('goog.events');
|
||||
goog.require('goog.events.Event');
|
||||
goog.require('goog.events.EventType');
|
||||
goog.require('goog.functions');
|
||||
goog.require('goog.style');
|
||||
goog.require('goog.webgl');
|
||||
goog.require('ol3.Layer');
|
||||
goog.require('ol3.Map');
|
||||
goog.require('ol3.TileLayer');
|
||||
goog.require('ol3.renderer.webgl.FragmentShader');
|
||||
goog.require('ol3.renderer.webgl.TileLayer');
|
||||
goog.require('ol3.renderer.webgl.VertexShader');
|
||||
goog.require('ol3.webgl.WebGLContextEventType');
|
||||
|
||||
|
||||
/**
|
||||
* @typedef {{magFilter: number, minFilter: number, texture: WebGLTexture}}
|
||||
*/
|
||||
ol3.renderer.webgl.TextureCacheEntry;
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
* @extends {ol3.renderer.webgl.FragmentShader}
|
||||
* @see https://github.com/evanw/glfx.js/blob/master/src/filters/adjust/brightnesscontrast.js
|
||||
* @see https://github.com/evanw/glfx.js/blob/master/src/filters/adjust/huesaturation.js
|
||||
*/
|
||||
ol3.renderer.webgl.map.shader.Fragment = function() {
|
||||
goog.base(this, [
|
||||
'precision mediump float;',
|
||||
'',
|
||||
'uniform float uBrightness;',
|
||||
'uniform float uContrast;',
|
||||
'uniform float uHue;',
|
||||
'uniform float uOpacity;',
|
||||
'uniform mat4 uMatrix;',
|
||||
'uniform float uSaturation;',
|
||||
'uniform sampler2D uTexture;',
|
||||
'',
|
||||
'varying vec2 vTexCoord;',
|
||||
'',
|
||||
'void main(void) {',
|
||||
'',
|
||||
' vec4 texCoord = uMatrix * vec4(vTexCoord, 0., 1.);',
|
||||
' vec4 color = texture2D(uTexture, texCoord.st);',
|
||||
'',
|
||||
' if (uHue != 0.) {',
|
||||
' float angle = uHue * 3.14159265;',
|
||||
' float s = sin(angle), c = cos(angle);',
|
||||
' vec3 weights = (vec3(2. * c, -sqrt(3.) * s - c, sqrt(3.) * s - c)',
|
||||
' + 1.) / 3.;',
|
||||
' color.rgb = vec3(',
|
||||
' dot(color.rgb, weights.xyz),',
|
||||
' dot(color.rgb, weights.zxy),',
|
||||
' dot(color.rgb, weights.yzx)',
|
||||
' );',
|
||||
' }',
|
||||
'',
|
||||
' if (uSaturation != 0.) {',
|
||||
' float average = (color.r + color.g + color.b) / 3.;',
|
||||
' if (uSaturation > 0.) {',
|
||||
' color.rgb += (average - color.rgb)',
|
||||
' * (1. - 1. / (1. - uSaturation));',
|
||||
' } else {',
|
||||
' color.rgb += (average - color.rgb) * -uSaturation;',
|
||||
' }',
|
||||
' }',
|
||||
'',
|
||||
' color.rgb += uBrightness;',
|
||||
'',
|
||||
' if (uContrast != 0.) {',
|
||||
' if (uContrast > 0.) {',
|
||||
' color.rgb = (color.rgb - 0.5) / (1. - uContrast) + 0.5;',
|
||||
' } else {',
|
||||
' color.rgb = (color.rgb - 0.5) * (1. + uContrast) + 0.5;',
|
||||
' }',
|
||||
' }',
|
||||
'',
|
||||
' color.a = color.a * uOpacity;',
|
||||
'',
|
||||
' gl_FragColor = color;',
|
||||
'',
|
||||
'}'
|
||||
].join('\n'));
|
||||
};
|
||||
goog.inherits(
|
||||
ol3.renderer.webgl.map.shader.Fragment, ol3.renderer.webgl.FragmentShader);
|
||||
goog.addSingletonGetter(ol3.renderer.webgl.map.shader.Fragment);
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
* @extends {ol3.renderer.webgl.VertexShader}
|
||||
*/
|
||||
ol3.renderer.webgl.map.shader.Vertex = function() {
|
||||
goog.base(this, [
|
||||
'attribute vec2 aPosition;',
|
||||
'attribute vec2 aTexCoord;',
|
||||
'',
|
||||
'varying vec2 vTexCoord;',
|
||||
'',
|
||||
'void main(void) {',
|
||||
' gl_Position = vec4(aPosition, 0., 1.);',
|
||||
' vTexCoord = aTexCoord;',
|
||||
'}'
|
||||
].join('\n'));
|
||||
};
|
||||
goog.inherits(
|
||||
ol3.renderer.webgl.map.shader.Vertex, ol3.renderer.webgl.VertexShader);
|
||||
goog.addSingletonGetter(ol3.renderer.webgl.map.shader.Vertex);
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
* @extends {ol3.renderer.Map}
|
||||
* @param {Element} container Container.
|
||||
* @param {ol3.Map} map Map.
|
||||
*/
|
||||
ol3.renderer.webgl.Map = function(container, map) {
|
||||
|
||||
goog.base(this, container, map);
|
||||
|
||||
if (goog.DEBUG) {
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
this.logger = goog.debug.Logger.getLogger(
|
||||
'ol3.renderer.webgl.maprenderer.' + goog.getUid(this));
|
||||
}
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {Element}
|
||||
*/
|
||||
this.canvas_ = goog.dom.createElement(goog.dom.TagName.CANVAS);
|
||||
this.canvas_.height = container.clientHeight;
|
||||
this.canvas_.width = container.clientWidth;
|
||||
goog.dom.appendChild(container, this.canvas_);
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {WebGLRenderingContext}
|
||||
*/
|
||||
this.gl_ = this.canvas_.getContext('experimental-webgl', {
|
||||
alpha: false,
|
||||
antialias: true,
|
||||
depth: false,
|
||||
preserveDrawingBuffer: false,
|
||||
stencil: false
|
||||
});
|
||||
goog.asserts.assert(!goog.isNull(this.gl_));
|
||||
|
||||
goog.events.listen(this.canvas_, ol3.webgl.WebGLContextEventType.LOST,
|
||||
this.handleWebGLContextLost, false, this);
|
||||
goog.events.listen(this.canvas_, ol3.webgl.WebGLContextEventType.RESTORED,
|
||||
this.handleWebGLContextRestored, false, this);
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {ol3.Color}
|
||||
*/
|
||||
this.clearColor_ = new ol3.Color(1, 1, 1, 1);
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {{aPosition: number,
|
||||
* aTexCoord: number,
|
||||
* uBrightness: WebGLUniformLocation,
|
||||
* uContrast: WebGLUniformLocation,
|
||||
* uHue: WebGLUniformLocation,
|
||||
* uMatrix: WebGLUniformLocation,
|
||||
* uOpacity: WebGLUniformLocation,
|
||||
* uSaturation: WebGLUniformLocation,
|
||||
* uTexture: WebGLUniformLocation}|null}
|
||||
*/
|
||||
this.locations_ = null;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {WebGLBuffer}
|
||||
*/
|
||||
this.arrayBuffer_ = null;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {Object.<number, WebGLShader>}
|
||||
*/
|
||||
this.shaderCache_ = {};
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {Object.<string, WebGLProgram>}
|
||||
*/
|
||||
this.programCache_ = {};
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {Object.<string, ol3.renderer.webgl.TextureCacheEntry>}
|
||||
*/
|
||||
this.textureCache_ = {};
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {ol3.renderer.webgl.FragmentShader}
|
||||
*/
|
||||
this.fragmentShader_ = ol3.renderer.webgl.map.shader.Fragment.getInstance();
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {ol3.renderer.webgl.VertexShader}
|
||||
*/
|
||||
this.vertexShader_ = ol3.renderer.webgl.map.shader.Vertex.getInstance();
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {Object.<number, null|number>}
|
||||
*/
|
||||
this.layerRendererChangeListenKeys_ = {};
|
||||
|
||||
this.initializeGL_();
|
||||
|
||||
};
|
||||
goog.inherits(ol3.renderer.webgl.Map, ol3.renderer.Map);
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
ol3.renderer.webgl.Map.prototype.addLayer = function(layer) {
|
||||
goog.base(this, 'addLayer', layer);
|
||||
if (layer.getVisible()) {
|
||||
this.getMap().render();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {Image} image Image.
|
||||
* @param {number} magFilter Mag filter.
|
||||
* @param {number} minFilter Min filter.
|
||||
*/
|
||||
ol3.renderer.webgl.Map.prototype.bindImageTexture =
|
||||
function(image, magFilter, minFilter) {
|
||||
var gl = this.getGL();
|
||||
var imageKey = image.src;
|
||||
var textureCacheEntry = this.textureCache_[imageKey];
|
||||
if (goog.isDef(textureCacheEntry)) {
|
||||
gl.bindTexture(goog.webgl.TEXTURE_2D, textureCacheEntry.texture);
|
||||
if (textureCacheEntry.magFilter != magFilter) {
|
||||
gl.texParameteri(
|
||||
goog.webgl.TEXTURE_2D, goog.webgl.TEXTURE_MAG_FILTER, magFilter);
|
||||
textureCacheEntry.magFilter = magFilter;
|
||||
}
|
||||
if (textureCacheEntry.minFilter != minFilter) {
|
||||
gl.texParameteri(
|
||||
goog.webgl.TEXTURE_2D, goog.webgl.TEXTURE_MAG_FILTER, minFilter);
|
||||
textureCacheEntry.minFilter = minFilter;
|
||||
}
|
||||
} else {
|
||||
var texture = gl.createTexture();
|
||||
gl.bindTexture(goog.webgl.TEXTURE_2D, texture);
|
||||
gl.texImage2D(goog.webgl.TEXTURE_2D, 0, goog.webgl.RGBA, goog.webgl.RGBA,
|
||||
goog.webgl.UNSIGNED_BYTE, image);
|
||||
gl.texParameteri(
|
||||
goog.webgl.TEXTURE_2D, goog.webgl.TEXTURE_MAG_FILTER, magFilter);
|
||||
gl.texParameteri(
|
||||
goog.webgl.TEXTURE_2D, goog.webgl.TEXTURE_MIN_FILTER, minFilter);
|
||||
gl.texParameteri(goog.webgl.TEXTURE_2D, goog.webgl.TEXTURE_WRAP_S,
|
||||
goog.webgl.CLAMP_TO_EDGE);
|
||||
gl.texParameteri(goog.webgl.TEXTURE_2D, goog.webgl.TEXTURE_WRAP_T,
|
||||
goog.webgl.CLAMP_TO_EDGE);
|
||||
this.textureCache_[imageKey] = {
|
||||
texture: texture,
|
||||
magFilter: magFilter,
|
||||
minFilter: minFilter
|
||||
};
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
ol3.renderer.webgl.Map.prototype.canRotate = goog.functions.TRUE;
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
ol3.renderer.webgl.Map.prototype.createLayerRenderer = function(layer) {
|
||||
var gl = this.getGL();
|
||||
if (layer instanceof ol3.TileLayer) {
|
||||
return new ol3.renderer.webgl.TileLayer(this, layer);
|
||||
} else {
|
||||
goog.asserts.assert(false);
|
||||
return null;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
ol3.renderer.webgl.Map.prototype.disposeInternal = function() {
|
||||
var gl = this.getGL();
|
||||
if (!gl.isContextLost()) {
|
||||
goog.object.forEach(this.programCache_, function(program) {
|
||||
gl.deleteProgram(program);
|
||||
});
|
||||
goog.object.forEach(this.shaderCache_, function(shader) {
|
||||
gl.deleteShader(shader);
|
||||
});
|
||||
goog.object.forEach(this.textureCache_, function(textureCacheEntry) {
|
||||
gl.deleteTexture(textureCacheEntry.texture);
|
||||
});
|
||||
}
|
||||
goog.base(this, 'disposeInternal');
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @return {WebGLRenderingContext} GL.
|
||||
*/
|
||||
ol3.renderer.webgl.Map.prototype.getGL = function() {
|
||||
return this.gl_;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {ol3.renderer.webgl.FragmentShader} fragmentShaderObject
|
||||
* Fragment shader.
|
||||
* @param {ol3.renderer.webgl.VertexShader} vertexShaderObject Vertex shader.
|
||||
* @return {WebGLProgram} Program.
|
||||
*/
|
||||
ol3.renderer.webgl.Map.prototype.getProgram = function(
|
||||
fragmentShaderObject, vertexShaderObject) {
|
||||
var programKey =
|
||||
goog.getUid(fragmentShaderObject) + '/' + goog.getUid(vertexShaderObject);
|
||||
if (programKey in this.programCache_) {
|
||||
return this.programCache_[programKey];
|
||||
} else {
|
||||
var gl = this.getGL();
|
||||
var program = gl.createProgram();
|
||||
gl.attachShader(program, this.getShader(fragmentShaderObject));
|
||||
gl.attachShader(program, this.getShader(vertexShaderObject));
|
||||
gl.linkProgram(program);
|
||||
if (goog.DEBUG) {
|
||||
if (!gl.getProgramParameter(program, goog.webgl.LINK_STATUS) &&
|
||||
!gl.isContextLost()) {
|
||||
this.logger.severe(gl.getProgramInfoLog(program));
|
||||
goog.asserts.assert(
|
||||
gl.getProgramParameter(program, goog.webgl.LINK_STATUS));
|
||||
}
|
||||
}
|
||||
this.programCache_[programKey] = program;
|
||||
return program;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {ol3.renderer.webgl.Shader} shaderObject Shader object.
|
||||
* @return {WebGLShader} Shader.
|
||||
*/
|
||||
ol3.renderer.webgl.Map.prototype.getShader = function(shaderObject) {
|
||||
var shaderKey = goog.getUid(shaderObject);
|
||||
if (shaderKey in this.shaderCache_) {
|
||||
return this.shaderCache_[shaderKey];
|
||||
} else {
|
||||
var gl = this.getGL();
|
||||
var shader = gl.createShader(shaderObject.getType());
|
||||
gl.shaderSource(shader, shaderObject.getSource());
|
||||
gl.compileShader(shader);
|
||||
if (goog.DEBUG) {
|
||||
if (!gl.getShaderParameter(shader, goog.webgl.COMPILE_STATUS) &&
|
||||
!gl.isContextLost()) {
|
||||
this.logger.severe(gl.getShaderInfoLog(shader));
|
||||
goog.asserts.assert(
|
||||
gl.getShaderParameter(shader, goog.webgl.COMPILE_STATUS));
|
||||
}
|
||||
}
|
||||
this.shaderCache_[shaderKey] = shader;
|
||||
return shader;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
ol3.renderer.webgl.Map.prototype.handleBackgroundColorChanged = function() {
|
||||
var backgroundColor = this.getMap().getBackgroundColor();
|
||||
this.clearColor_ = new ol3.Color(
|
||||
backgroundColor.r / 255,
|
||||
backgroundColor.g / 255,
|
||||
backgroundColor.b / 255,
|
||||
backgroundColor.a / 255);
|
||||
this.getMap().render();
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
ol3.renderer.webgl.Map.prototype.handleCenterChanged = function() {
|
||||
goog.base(this, 'handleCenterChanged');
|
||||
this.getMap().render();
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {goog.events.Event} event Event.
|
||||
* @protected
|
||||
*/
|
||||
ol3.renderer.webgl.Map.prototype.handleLayerRendererChange = function(event) {
|
||||
this.getMap().render();
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
ol3.renderer.webgl.Map.prototype.handleResolutionChanged = function() {
|
||||
goog.base(this, 'handleResolutionChanged');
|
||||
this.getMap().render();
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
ol3.renderer.webgl.Map.prototype.handleRotationChanged = function() {
|
||||
goog.base(this, 'handleRotationChanged');
|
||||
this.getMap().render();
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
ol3.renderer.webgl.Map.prototype.handleSizeChanged = function() {
|
||||
goog.base(this, 'handleSizeChanged');
|
||||
var size = this.getMap().getSize();
|
||||
if (!goog.isDef(size)) {
|
||||
return;
|
||||
}
|
||||
this.canvas_.width = size.width;
|
||||
this.canvas_.height = size.height;
|
||||
var gl = this.gl_;
|
||||
if (!goog.isNull(gl)) {
|
||||
gl.viewport(0, 0, size.width, size.height);
|
||||
this.getMap().render();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {goog.events.Event} event Event.
|
||||
* @protected
|
||||
*/
|
||||
ol3.renderer.webgl.Map.prototype.handleWebGLContextLost = function(event) {
|
||||
if (goog.DEBUG) {
|
||||
this.logger.info('WebGLContextLost');
|
||||
}
|
||||
event.preventDefault();
|
||||
this.locations_ = null;
|
||||
this.arrayBuffer_ = null;
|
||||
this.shaderCache_ = {};
|
||||
this.programCache_ = {};
|
||||
this.textureCache_ = {};
|
||||
goog.object.forEach(this.layerRenderers, function(layerRenderer) {
|
||||
layerRenderer.handleWebGLContextLost();
|
||||
});
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @protected
|
||||
*/
|
||||
ol3.renderer.webgl.Map.prototype.handleWebGLContextRestored = function() {
|
||||
if (goog.DEBUG) {
|
||||
this.logger.info('WebGLContextRestored');
|
||||
}
|
||||
this.initializeGL_();
|
||||
this.getMap().render();
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @private
|
||||
*/
|
||||
ol3.renderer.webgl.Map.prototype.initializeGL_ = function() {
|
||||
var gl = this.gl_;
|
||||
gl.activeTexture(goog.webgl.TEXTURE0);
|
||||
gl.blendFunc(goog.webgl.SRC_ALPHA, goog.webgl.ONE_MINUS_SRC_ALPHA);
|
||||
gl.disable(goog.webgl.CULL_FACE);
|
||||
gl.disable(goog.webgl.DEPTH_TEST);
|
||||
gl.disable(goog.webgl.SCISSOR_TEST);
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {Image} image Image.
|
||||
* @return {boolean} Is image texture loaded.
|
||||
*/
|
||||
ol3.renderer.webgl.Map.prototype.isImageTextureLoaded = function(image) {
|
||||
return image.src in this.textureCache_;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
ol3.renderer.webgl.Map.prototype.removeLayer = function(layer) {
|
||||
goog.base(this, 'removeLayer', layer);
|
||||
if (layer.getVisible()) {
|
||||
this.getMap().render();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
ol3.renderer.webgl.Map.prototype.removeLayerRenderer = function(layer) {
|
||||
var layerRenderer = goog.base(this, 'removeLayerRenderer', layer);
|
||||
if (!goog.isNull(layerRenderer)) {
|
||||
var layerKey = goog.getUid(layer);
|
||||
goog.events.unlistenByKey(this.layerRendererChangeListenKeys_[layerKey]);
|
||||
delete this.layerRendererChangeListenKeys_[layerKey];
|
||||
}
|
||||
return layerRenderer;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
ol3.renderer.webgl.Map.prototype.render = function() {
|
||||
|
||||
if (!this.getMap().isDef()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
var size = this.getMap().getSize();
|
||||
|
||||
var animate = goog.base(this, 'render');
|
||||
|
||||
var gl = this.getGL();
|
||||
|
||||
gl.bindFramebuffer(goog.webgl.FRAMEBUFFER, null);
|
||||
|
||||
gl.clearColor(this.clearColor_.r, this.clearColor_.g, this.clearColor_.b,
|
||||
this.clearColor_.a);
|
||||
gl.clear(goog.webgl.COLOR_BUFFER_BIT);
|
||||
gl.enable(goog.webgl.BLEND);
|
||||
gl.viewport(0, 0, size.width, size.height);
|
||||
|
||||
var program = this.getProgram(this.fragmentShader_, this.vertexShader_);
|
||||
gl.useProgram(program);
|
||||
if (goog.isNull(this.locations_)) {
|
||||
this.locations_ = {
|
||||
aPosition: gl.getAttribLocation(program, 'aPosition'),
|
||||
aTexCoord: gl.getAttribLocation(program, 'aTexCoord'),
|
||||
uBrightness: gl.getUniformLocation(program, 'uBrightness'),
|
||||
uContrast: gl.getUniformLocation(program, 'uContrast'),
|
||||
uHue: gl.getUniformLocation(program, 'uHue'),
|
||||
uMatrix: gl.getUniformLocation(program, 'uMatrix'),
|
||||
uOpacity: gl.getUniformLocation(program, 'uOpacity'),
|
||||
uSaturation: gl.getUniformLocation(program, 'uSaturation'),
|
||||
uTexture: gl.getUniformLocation(program, 'uTexture')
|
||||
};
|
||||
}
|
||||
|
||||
if (goog.isNull(this.arrayBuffer_)) {
|
||||
var arrayBuffer = gl.createBuffer();
|
||||
gl.bindBuffer(goog.webgl.ARRAY_BUFFER, arrayBuffer);
|
||||
gl.bufferData(goog.webgl.ARRAY_BUFFER, new Float32Array([
|
||||
-1, -1, 0, 0,
|
||||
1, -1, 1, 0,
|
||||
-1, 1, 0, 1,
|
||||
1, 1, 1, 1
|
||||
]), goog.webgl.STATIC_DRAW);
|
||||
this.arrayBuffer_ = arrayBuffer;
|
||||
} else {
|
||||
gl.bindBuffer(goog.webgl.ARRAY_BUFFER, this.arrayBuffer_);
|
||||
}
|
||||
|
||||
gl.enableVertexAttribArray(this.locations_.aPosition);
|
||||
gl.vertexAttribPointer(
|
||||
this.locations_.aPosition, 2, goog.webgl.FLOAT, false, 16, 0);
|
||||
gl.enableVertexAttribArray(this.locations_.aTexCoord);
|
||||
gl.vertexAttribPointer(
|
||||
this.locations_.aTexCoord, 2, goog.webgl.FLOAT, false, 16, 8);
|
||||
gl.uniform1i(this.locations_.uTexture, 0);
|
||||
|
||||
this.forEachReadyVisibleLayer(function(layer, layerRenderer) {
|
||||
gl.uniformMatrix4fv(
|
||||
this.locations_.uMatrix, false, layerRenderer.getMatrix());
|
||||
gl.uniform1f(this.locations_.uBrightness, layer.getBrightness());
|
||||
gl.uniform1f(this.locations_.uContrast, layer.getContrast());
|
||||
gl.uniform1f(this.locations_.uHue, layer.getHue());
|
||||
gl.uniform1f(this.locations_.uOpacity, layer.getOpacity());
|
||||
gl.uniform1f(this.locations_.uSaturation, layer.getSaturation());
|
||||
gl.bindTexture(goog.webgl.TEXTURE_2D, layerRenderer.getTexture());
|
||||
gl.drawArrays(goog.webgl.TRIANGLE_STRIP, 0, 4);
|
||||
}, this);
|
||||
|
||||
return animate;
|
||||
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
ol3.renderer.webgl.Map.prototype.setLayerRenderer = function(
|
||||
layer, layerRenderer) {
|
||||
goog.base(this, 'setLayerRenderer', layer, layerRenderer);
|
||||
var layerKey = goog.getUid(layer);
|
||||
this.layerRendererChangeListenKeys_[layerKey] = goog.events.listen(
|
||||
layerRenderer, goog.events.EventType.CHANGE,
|
||||
this.handleLayerRendererChange, false, this);
|
||||
};
|
||||
@@ -0,0 +1,81 @@
|
||||
goog.provide('ol3.renderer.webgl.FragmentShader');
|
||||
goog.provide('ol3.renderer.webgl.VertexShader');
|
||||
|
||||
goog.require('goog.functions');
|
||||
goog.require('goog.webgl');
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
* @param {string} source Source.
|
||||
*/
|
||||
ol3.renderer.webgl.Shader = function(source) {
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {string}
|
||||
*/
|
||||
this.source_ = source;
|
||||
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @return {number} Type.
|
||||
*/
|
||||
ol3.renderer.webgl.Shader.prototype.getType = goog.abstractMethod;
|
||||
|
||||
|
||||
/**
|
||||
* @return {string} Source.
|
||||
*/
|
||||
ol3.renderer.webgl.Shader.prototype.getSource = function() {
|
||||
return this.source_;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @return {boolean} Is animated?
|
||||
*/
|
||||
ol3.renderer.webgl.Shader.prototype.isAnimated = goog.functions.FALSE;
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
* @extends {ol3.renderer.webgl.Shader}
|
||||
* @param {string} source Source.
|
||||
*/
|
||||
ol3.renderer.webgl.FragmentShader = function(source) {
|
||||
goog.base(this, source);
|
||||
};
|
||||
goog.inherits(ol3.renderer.webgl.FragmentShader, ol3.renderer.webgl.Shader);
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
ol3.renderer.webgl.FragmentShader.prototype.getType = function() {
|
||||
return goog.webgl.FRAGMENT_SHADER;
|
||||
};
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
* @extends {ol3.renderer.webgl.Shader}
|
||||
* @param {string} source Source.
|
||||
*/
|
||||
ol3.renderer.webgl.VertexShader = function(source) {
|
||||
goog.base(this, source);
|
||||
};
|
||||
goog.inherits(ol3.renderer.webgl.VertexShader, ol3.renderer.webgl.Shader);
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
ol3.renderer.webgl.VertexShader.prototype.getType = function() {
|
||||
return goog.webgl.VERTEX_SHADER;
|
||||
};
|
||||
@@ -0,0 +1,496 @@
|
||||
// FIXME large resolutions lead to too large framebuffers :-(
|
||||
// FIXME animated shaders! check in redraw
|
||||
|
||||
goog.provide('ol3.renderer.webgl.TileLayer');
|
||||
goog.provide('ol3.renderer.webgl.tilelayerrenderer');
|
||||
goog.provide('ol3.renderer.webgl.tilelayerrenderer.shader.Fragment');
|
||||
goog.provide('ol3.renderer.webgl.tilelayerrenderer.shader.Vertex');
|
||||
|
||||
goog.require('goog.array');
|
||||
goog.require('goog.asserts');
|
||||
goog.require('goog.debug.Logger');
|
||||
goog.require('goog.events.EventType');
|
||||
goog.require('goog.object');
|
||||
goog.require('goog.vec.Mat4');
|
||||
goog.require('goog.vec.Vec4');
|
||||
goog.require('goog.webgl');
|
||||
goog.require('ol3.Coordinate');
|
||||
goog.require('ol3.MapEventType');
|
||||
goog.require('ol3.Size');
|
||||
goog.require('ol3.TileLayer');
|
||||
goog.require('ol3.TileState');
|
||||
goog.require('ol3.renderer.webgl.FragmentShader');
|
||||
goog.require('ol3.renderer.webgl.Layer');
|
||||
goog.require('ol3.renderer.webgl.VertexShader');
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
* @extends {ol3.renderer.webgl.FragmentShader}
|
||||
*/
|
||||
ol3.renderer.webgl.tilelayerrenderer.shader.Fragment = function() {
|
||||
goog.base(this, [
|
||||
'precision mediump float;',
|
||||
'',
|
||||
'uniform sampler2D uTexture;',
|
||||
'',
|
||||
'varying vec2 vTexCoord;',
|
||||
'',
|
||||
'void main(void) {',
|
||||
' gl_FragColor = texture2D(uTexture, vTexCoord);',
|
||||
'}'
|
||||
].join('\n'));
|
||||
};
|
||||
goog.inherits(
|
||||
ol3.renderer.webgl.tilelayerrenderer.shader.Fragment,
|
||||
ol3.renderer.webgl.FragmentShader);
|
||||
goog.addSingletonGetter(ol3.renderer.webgl.tilelayerrenderer.shader.Fragment);
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
* @extends {ol3.renderer.webgl.VertexShader}
|
||||
*/
|
||||
ol3.renderer.webgl.tilelayerrenderer.shader.Vertex = function() {
|
||||
goog.base(this, [
|
||||
'attribute vec2 aPosition;',
|
||||
'attribute vec2 aTexCoord;',
|
||||
'',
|
||||
'varying vec2 vTexCoord;',
|
||||
'',
|
||||
'uniform vec4 uTileOffset;',
|
||||
'',
|
||||
'void main(void) {',
|
||||
' gl_Position.xy = aPosition * uTileOffset.xy + uTileOffset.zw;',
|
||||
' gl_Position.z = 0.;',
|
||||
' gl_Position.w = 1.;',
|
||||
' vTexCoord = aTexCoord;',
|
||||
'}'
|
||||
].join('\n'));
|
||||
};
|
||||
goog.inherits(
|
||||
ol3.renderer.webgl.tilelayerrenderer.shader.Vertex,
|
||||
ol3.renderer.webgl.VertexShader);
|
||||
goog.addSingletonGetter(ol3.renderer.webgl.tilelayerrenderer.shader.Vertex);
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
* @extends {ol3.renderer.webgl.Layer}
|
||||
* @param {ol3.renderer.Map} mapRenderer Map renderer.
|
||||
* @param {ol3.TileLayer} tileLayer Tile layer.
|
||||
*/
|
||||
ol3.renderer.webgl.TileLayer = function(mapRenderer, tileLayer) {
|
||||
|
||||
goog.base(this, mapRenderer, tileLayer);
|
||||
|
||||
if (goog.DEBUG) {
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
this.logger = goog.debug.Logger.getLogger(
|
||||
'ol3.renderer.webgl.tilelayerrenderer.' + goog.getUid(this));
|
||||
}
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {ol3.renderer.webgl.FragmentShader}
|
||||
*/
|
||||
this.fragmentShader_ =
|
||||
ol3.renderer.webgl.tilelayerrenderer.shader.Fragment.getInstance();
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {ol3.renderer.webgl.VertexShader}
|
||||
*/
|
||||
this.vertexShader_ =
|
||||
ol3.renderer.webgl.tilelayerrenderer.shader.Vertex.getInstance();
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {{aPosition: number,
|
||||
* aTexCoord: number,
|
||||
* uTileOffset: WebGLUniformLocation,
|
||||
* uTexture: WebGLUniformLocation}|null}
|
||||
*/
|
||||
this.locations_ = null;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {WebGLBuffer}
|
||||
*/
|
||||
this.arrayBuffer_ = null;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {WebGLTexture}
|
||||
*/
|
||||
this.texture_ = null;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {WebGLFramebuffer}
|
||||
*/
|
||||
this.framebuffer_ = null;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {number|undefined}
|
||||
*/
|
||||
this.framebufferDimension_ = undefined;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {Object.<number, number>}
|
||||
*/
|
||||
this.tileChangeListenerKeys_ = {};
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {goog.vec.Mat4.AnyType}
|
||||
*/
|
||||
this.matrix_ = goog.vec.Mat4.createNumber();
|
||||
|
||||
};
|
||||
goog.inherits(ol3.renderer.webgl.TileLayer, ol3.renderer.webgl.Layer);
|
||||
|
||||
|
||||
/**
|
||||
* @param {number} framebufferDimension Framebuffer dimension.
|
||||
* @private
|
||||
*/
|
||||
ol3.renderer.webgl.TileLayer.prototype.bindFramebuffer_ =
|
||||
function(framebufferDimension) {
|
||||
|
||||
var mapRenderer = this.getMapRenderer();
|
||||
var gl = mapRenderer.getGL();
|
||||
|
||||
if (!goog.isDef(this.framebufferDimension_) ||
|
||||
this.framebufferDimension_ != framebufferDimension) {
|
||||
|
||||
if (goog.DEBUG) {
|
||||
this.logger.info('re-sizing framebuffer');
|
||||
}
|
||||
|
||||
if (ol3.renderer.webgl.FREE_RESOURCES_IMMEDIATELY) {
|
||||
if (goog.DEBUG) {
|
||||
this.logger.info('freeing WebGL resources');
|
||||
}
|
||||
if (!gl.isContextLost()) {
|
||||
gl.deleteFramebuffer(this.framebuffer_);
|
||||
gl.deleteTexture(this.texture_);
|
||||
}
|
||||
} else {
|
||||
var map = this.getMap();
|
||||
goog.events.listenOnce(
|
||||
map,
|
||||
ol3.MapEventType.POST_RENDER,
|
||||
goog.partial(function(gl, framebuffer, texture) {
|
||||
if (goog.DEBUG) {
|
||||
this.logger.info('freeing WebGL resources on postrender');
|
||||
}
|
||||
if (!gl.isContextLost()) {
|
||||
gl.deleteFramebuffer(framebuffer);
|
||||
gl.deleteTexture(texture);
|
||||
}
|
||||
}, gl, this.framebuffer_, this.texture_));
|
||||
}
|
||||
|
||||
var texture = gl.createTexture();
|
||||
gl.bindTexture(goog.webgl.TEXTURE_2D, texture);
|
||||
gl.texImage2D(goog.webgl.TEXTURE_2D, 0, goog.webgl.RGBA,
|
||||
framebufferDimension, framebufferDimension, 0, goog.webgl.RGBA,
|
||||
goog.webgl.UNSIGNED_BYTE, null);
|
||||
gl.texParameteri(goog.webgl.TEXTURE_2D, goog.webgl.TEXTURE_MAG_FILTER,
|
||||
goog.webgl.LINEAR);
|
||||
gl.texParameteri(goog.webgl.TEXTURE_2D, goog.webgl.TEXTURE_MIN_FILTER,
|
||||
goog.webgl.LINEAR);
|
||||
|
||||
var framebuffer = gl.createFramebuffer();
|
||||
gl.bindFramebuffer(goog.webgl.FRAMEBUFFER, framebuffer);
|
||||
gl.framebufferTexture2D(goog.webgl.FRAMEBUFFER,
|
||||
goog.webgl.COLOR_ATTACHMENT0, goog.webgl.TEXTURE_2D, texture, 0);
|
||||
|
||||
this.texture_ = texture;
|
||||
this.framebuffer_ = framebuffer;
|
||||
this.framebufferDimension_ = framebufferDimension;
|
||||
|
||||
} else {
|
||||
gl.bindFramebuffer(goog.webgl.FRAMEBUFFER, this.framebuffer_);
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
ol3.renderer.webgl.TileLayer.prototype.disposeInternal = function() {
|
||||
var mapRenderer = this.getMapRenderer();
|
||||
var gl = mapRenderer.getGL();
|
||||
if (!gl.isContextLost()) {
|
||||
gl.deleteBuffer(this.arrayBuffer_);
|
||||
gl.deleteFramebuffer(this.framebuffer_);
|
||||
gl.deleteTexture(this.texture_);
|
||||
}
|
||||
goog.base(this, 'disposeInternal');
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @return {ol3.TileLayer} Layer.
|
||||
* @override
|
||||
*/
|
||||
ol3.renderer.webgl.TileLayer.prototype.getLayer = function() {
|
||||
return /** @type {ol3.TileLayer} */ goog.base(this, 'getLayer');
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
ol3.renderer.webgl.TileLayer.prototype.getMatrix = function() {
|
||||
return this.matrix_;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
ol3.renderer.webgl.TileLayer.prototype.getTexture = function() {
|
||||
return this.texture_;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @protected
|
||||
*/
|
||||
ol3.renderer.webgl.TileLayer.prototype.handleTileChange = function() {
|
||||
this.dispatchChangeEvent();
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
ol3.renderer.webgl.TileLayer.prototype.handleWebGLContextLost = function() {
|
||||
this.locations_ = null;
|
||||
this.arrayBuffer_ = null;
|
||||
this.texture_ = null;
|
||||
this.framebuffer_ = null;
|
||||
this.framebufferDimension_ = undefined;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
ol3.renderer.webgl.TileLayer.prototype.render = function() {
|
||||
|
||||
var animate = false;
|
||||
|
||||
var mapRenderer = this.getMapRenderer();
|
||||
var map = this.getMap();
|
||||
var gl = mapRenderer.getGL();
|
||||
|
||||
goog.asserts.assert(map.isDef());
|
||||
var mapCenter = map.getCenter();
|
||||
var mapExtent = map.getExtent();
|
||||
var mapResolution = /** @type {number} */ map.getResolution();
|
||||
var mapRotatedExtent = map.getRotatedExtent();
|
||||
var mapRotation = map.getRotation();
|
||||
|
||||
var tileLayer = this.getLayer();
|
||||
var tileStore = tileLayer.getStore();
|
||||
var tileGrid = tileStore.getTileGrid();
|
||||
var z = tileGrid.getZForResolution(mapResolution);
|
||||
var tileResolution = tileGrid.getResolution(z);
|
||||
var tileBounds = tileGrid.getTileBoundsForExtentAndResolution(
|
||||
mapRotatedExtent, tileResolution);
|
||||
var tileBoundsSize = tileBounds.getSize();
|
||||
var tileSize = tileGrid.getTileSize();
|
||||
|
||||
var maxDimension = Math.max(
|
||||
tileBoundsSize.width * tileSize.width,
|
||||
tileBoundsSize.height * tileSize.height);
|
||||
var framebufferDimension =
|
||||
Math.pow(2, Math.ceil(Math.log(maxDimension) / Math.log(2)));
|
||||
var framebufferExtentSize = new ol3.Size(
|
||||
tileResolution * framebufferDimension,
|
||||
tileResolution * framebufferDimension);
|
||||
var origin = tileGrid.getOrigin(z);
|
||||
var minX = origin.x + tileBounds.minX * tileSize.width * tileResolution;
|
||||
var minY = origin.y + tileBounds.minY * tileSize.height * tileResolution;
|
||||
var framebufferExtent = new ol3.Extent(
|
||||
minX,
|
||||
minY,
|
||||
minX + framebufferExtentSize.width,
|
||||
minY + framebufferExtentSize.height);
|
||||
|
||||
this.bindFramebuffer_(framebufferDimension);
|
||||
gl.viewport(0, 0, framebufferDimension, framebufferDimension);
|
||||
|
||||
gl.clearColor(0, 0, 0, 0);
|
||||
gl.clear(goog.webgl.COLOR_BUFFER_BIT);
|
||||
gl.disable(goog.webgl.BLEND);
|
||||
|
||||
var program = mapRenderer.getProgram(
|
||||
this.fragmentShader_, this.vertexShader_);
|
||||
gl.useProgram(program);
|
||||
if (goog.isNull(this.locations_)) {
|
||||
this.locations_ = {
|
||||
aPosition: gl.getAttribLocation(program, 'aPosition'),
|
||||
aTexCoord: gl.getAttribLocation(program, 'aTexCoord'),
|
||||
uTileOffset: gl.getUniformLocation(program, 'uTileOffset'),
|
||||
uTexture: gl.getUniformLocation(program, 'uTexture')
|
||||
};
|
||||
}
|
||||
|
||||
if (goog.isNull(this.arrayBuffer_)) {
|
||||
var arrayBuffer = gl.createBuffer();
|
||||
gl.bindBuffer(goog.webgl.ARRAY_BUFFER, arrayBuffer);
|
||||
gl.bufferData(goog.webgl.ARRAY_BUFFER, new Float32Array([
|
||||
0, 0, 0, 1,
|
||||
1, 0, 1, 1,
|
||||
0, 1, 0, 0,
|
||||
1, 1, 1, 0
|
||||
]), goog.webgl.STATIC_DRAW);
|
||||
this.arrayBuffer_ = arrayBuffer;
|
||||
} else {
|
||||
gl.bindBuffer(goog.webgl.ARRAY_BUFFER, this.arrayBuffer_);
|
||||
}
|
||||
|
||||
gl.enableVertexAttribArray(this.locations_.aPosition);
|
||||
gl.vertexAttribPointer(
|
||||
this.locations_.aPosition, 2, goog.webgl.FLOAT, false, 16, 0);
|
||||
gl.enableVertexAttribArray(this.locations_.aTexCoord);
|
||||
gl.vertexAttribPointer(
|
||||
this.locations_.aTexCoord, 2, goog.webgl.FLOAT, false, 16, 8);
|
||||
gl.uniform1i(this.locations_.uTexture, 0);
|
||||
|
||||
/**
|
||||
* @type {Object.<number, Object.<string, ol3.TileCoord>>}
|
||||
*/
|
||||
var tilesToDrawByZ = {};
|
||||
|
||||
/**
|
||||
* @type {Array.<ol3.Tile>}
|
||||
*/
|
||||
var imagesToLoad = [];
|
||||
|
||||
tilesToDrawByZ[z] = {};
|
||||
tileBounds.forEachTileCoord(z, function(tileCoord) {
|
||||
|
||||
var tile = tileStore.getTile(tileCoord);
|
||||
|
||||
if (goog.isNull(tile)) {
|
||||
} else if (tile.getState() == ol3.TileState.LOADED) {
|
||||
if (mapRenderer.isImageTextureLoaded(tile.getImage())) {
|
||||
tilesToDrawByZ[z][tileCoord.toString()] = tile;
|
||||
return;
|
||||
} else {
|
||||
imagesToLoad.push(tile.getImage());
|
||||
}
|
||||
} else {
|
||||
var tileKey = goog.getUid(tile);
|
||||
if (!(tileKey in this.tileChangeListenerKeys_)) {
|
||||
tile.load();
|
||||
// FIXME will need to handle aborts as well
|
||||
this.tileChangeListenerKeys_[tileKey] = goog.events.listen(tile,
|
||||
goog.events.EventType.CHANGE, this.handleTileChange, false, this);
|
||||
}
|
||||
}
|
||||
|
||||
// FIXME this could be more efficient about filling partial holes
|
||||
tileGrid.forEachTileCoordParentTileBounds(
|
||||
tileCoord,
|
||||
function(z, tileBounds) {
|
||||
var fullyCovered = true;
|
||||
tileBounds.forEachTileCoord(z, function(tileCoord) {
|
||||
var tileCoordKey = tileCoord.toString();
|
||||
if (tilesToDrawByZ[z] && tilesToDrawByZ[z][tileCoordKey]) {
|
||||
return;
|
||||
}
|
||||
var tile = tileStore.getTile(tileCoord);
|
||||
if (!goog.isNull(tile) &&
|
||||
tile.getState() == ol3.TileState.LOADED) {
|
||||
if (!tilesToDrawByZ[z]) {
|
||||
tilesToDrawByZ[z] = {};
|
||||
}
|
||||
tilesToDrawByZ[z][tileCoordKey] = tile;
|
||||
} else {
|
||||
fullyCovered = false;
|
||||
}
|
||||
});
|
||||
return fullyCovered;
|
||||
});
|
||||
|
||||
}, this);
|
||||
|
||||
var zs = goog.object.getKeys(tilesToDrawByZ);
|
||||
goog.array.sort(zs);
|
||||
var uTileOffset = goog.vec.Vec4.createFloat32();
|
||||
goog.array.forEach(zs, function(z) {
|
||||
goog.object.forEach(tilesToDrawByZ[z], function(tile) {
|
||||
var tileExtent = tileGrid.getTileCoordExtent(tile.tileCoord);
|
||||
var sx = 2 * tileExtent.getWidth() / framebufferExtentSize.width;
|
||||
var sy = 2 * tileExtent.getHeight() / framebufferExtentSize.height;
|
||||
var tx = 2 * (tileExtent.minX - framebufferExtent.minX) /
|
||||
framebufferExtentSize.width - 1;
|
||||
var ty = 2 * (tileExtent.minY - framebufferExtent.minY) /
|
||||
framebufferExtentSize.height - 1;
|
||||
goog.vec.Vec4.setFromValues(uTileOffset, sx, sy, tx, ty);
|
||||
gl.uniform4fv(this.locations_.uTileOffset, uTileOffset);
|
||||
mapRenderer.bindImageTexture(
|
||||
tile.getImage(), goog.webgl.LINEAR, goog.webgl.LINEAR);
|
||||
gl.drawArrays(goog.webgl.TRIANGLE_STRIP, 0, 4);
|
||||
}, this);
|
||||
}, this);
|
||||
|
||||
goog.vec.Mat4.makeIdentity(this.matrix_);
|
||||
goog.vec.Mat4.translate(this.matrix_,
|
||||
(mapCenter.x - framebufferExtent.minX) /
|
||||
(framebufferExtent.maxX - framebufferExtent.minX),
|
||||
(mapCenter.y - framebufferExtent.minY) /
|
||||
(framebufferExtent.maxY - framebufferExtent.minY),
|
||||
0);
|
||||
goog.vec.Mat4.scale(this.matrix_,
|
||||
(mapExtent.maxX - mapExtent.minX) /
|
||||
(framebufferExtent.maxX - framebufferExtent.minX),
|
||||
(mapExtent.maxY - mapExtent.minY) /
|
||||
(framebufferExtent.maxY - framebufferExtent.minY),
|
||||
1);
|
||||
if (goog.isDef(mapRotation)) {
|
||||
goog.vec.Mat4.rotate(this.matrix_,
|
||||
mapRotation,
|
||||
0,
|
||||
0,
|
||||
1);
|
||||
}
|
||||
goog.vec.Mat4.translate(this.matrix_,
|
||||
-0.5,
|
||||
-0.5,
|
||||
0);
|
||||
|
||||
if (!goog.array.isEmpty(imagesToLoad)) {
|
||||
goog.events.listenOnce(
|
||||
map,
|
||||
ol3.MapEventType.POST_RENDER,
|
||||
goog.partial(function(mapRenderer, imagesToLoad) {
|
||||
if (goog.DEBUG) {
|
||||
this.logger.info('uploading textures');
|
||||
}
|
||||
goog.array.forEach(imagesToLoad, function(image) {
|
||||
mapRenderer.bindImageTexture(
|
||||
image, goog.webgl.LINEAR, goog.webgl.LINEAR);
|
||||
});
|
||||
}, mapRenderer, imagesToLoad));
|
||||
animate = true;
|
||||
}
|
||||
|
||||
return animate;
|
||||
|
||||
};
|
||||
@@ -0,0 +1,15 @@
|
||||
goog.provide('ol3.renderer.webgl');
|
||||
|
||||
|
||||
/**
|
||||
* @define {boolean} Free resources immediately.
|
||||
*/
|
||||
ol3.renderer.webgl.FREE_RESOURCES_IMMEDIATELY = false;
|
||||
|
||||
|
||||
/**
|
||||
* @return {boolean} Is supported.
|
||||
*/
|
||||
ol3.renderer.webgl.isSupported = function() {
|
||||
return 'WebGLRenderingContext' in goog.global;
|
||||
};
|
||||
Reference in New Issue
Block a user