From 19ea6a0cba6404475124430c3918974222c227d3 Mon Sep 17 00:00:00 2001 From: Tom Payne Date: Fri, 13 Jul 2012 19:27:48 +0200 Subject: [PATCH] Import WebGL code from WebGL Maps --- src/ol/webglrenderer/arraybuffer.js | 47 +++++++++ src/ol/webglrenderer/framebuffer.js | 118 ++++++++++++++++++++++ src/ol/webglrenderer/globject.js | 50 +++++++++ src/ol/webglrenderer/program.js | 79 +++++++++++++++ src/ol/webglrenderer/programcache.js | 64 ++++++++++++ src/ol/webglrenderer/shader.js | 117 +++++++++++++++++++++ src/ol/webglrenderer/shader/fragment.js | 27 +++++ src/ol/webglrenderer/shader/vertex.js | 27 +++++ src/ol/webglrenderer/staticglobject.js | 49 +++++++++ src/ol/webglrenderer/texture.js | 64 ++++++++++++ src/ol/webglrenderer/tilelayerrenderer.js | 71 +++++++++++++ src/ol/webglrenderer/uniform.js | 101 ++++++++++++++++++ src/ol/webglrenderer/vertexattrib.js | 78 ++++++++++++++ 13 files changed, 892 insertions(+) create mode 100644 src/ol/webglrenderer/arraybuffer.js create mode 100644 src/ol/webglrenderer/framebuffer.js create mode 100644 src/ol/webglrenderer/globject.js create mode 100644 src/ol/webglrenderer/program.js create mode 100644 src/ol/webglrenderer/programcache.js create mode 100644 src/ol/webglrenderer/shader.js create mode 100644 src/ol/webglrenderer/shader/fragment.js create mode 100644 src/ol/webglrenderer/shader/vertex.js create mode 100644 src/ol/webglrenderer/staticglobject.js create mode 100644 src/ol/webglrenderer/texture.js create mode 100644 src/ol/webglrenderer/tilelayerrenderer.js create mode 100644 src/ol/webglrenderer/uniform.js create mode 100644 src/ol/webglrenderer/vertexattrib.js diff --git a/src/ol/webglrenderer/arraybuffer.js b/src/ol/webglrenderer/arraybuffer.js new file mode 100644 index 0000000000..9e18c5b5ca --- /dev/null +++ b/src/ol/webglrenderer/arraybuffer.js @@ -0,0 +1,47 @@ +goog.provide('ol.webglrenderer.ArrayBuffer'); + +goog.require('goog.webgl'); +goog.require('ol.webglrenderer.StaticGLObject'); + + + +/** + * @constructor + * @extends {ol.webglrenderer.StaticGLObject} + * @param {WebGLRenderingContext} gl GL. + * @param {ArrayBuffer|ArrayBufferView|null|number} data Data. + * @param {number} usage Usage. + */ +ol.webglrenderer.ArrayBuffer = function(gl, data, usage) { + + goog.base(this, gl); + + /** + * @private + * @type {WebGLBuffer} + */ + this.buffer_ = gl.createBuffer(); + gl.bindBuffer(goog.webgl.ARRAY_BUFFER, this.buffer_); + gl.bufferData(goog.webgl.ARRAY_BUFFER, data, usage); + +}; +goog.inherits(ol.webglrenderer.ArrayBuffer, ol.webglrenderer.StaticGLObject); + + +/** + */ +ol.webglrenderer.ArrayBuffer.prototype.bind = function() { + var gl = this.getGL(); + gl.bindBuffer(goog.webgl.ARRAY_BUFFER, this.buffer_); +}; + + +/** + * @inheritDoc + */ +ol.webglrenderer.ArrayBuffer.prototype.disposeInternal = function() { + var gl = this.getGL(); + gl.deleteBuffer(this.buffer_); + this.buffer_ = null; + goog.base(this, 'disposeInternal'); +}; diff --git a/src/ol/webglrenderer/framebuffer.js b/src/ol/webglrenderer/framebuffer.js new file mode 100644 index 0000000000..c8ace09462 --- /dev/null +++ b/src/ol/webglrenderer/framebuffer.js @@ -0,0 +1,118 @@ +goog.provide('ol.webglrenderer.Framebuffer'); + +goog.require('goog.asserts'); +goog.require('goog.webgl'); +goog.require('ol.webglrenderer.GLObject'); + + + +/** + * @constructor + * @extends {ol.webglrenderer.GLObject} + * @param {number} size Size. + */ +ol.webglrenderer.Framebuffer = function(size) { + + goog.base(this); + + /** + * @private + * @type {WebGLFramebuffer} + */ + this.framebuffer_ = null; + + /** + * @private + * @type {WebGLTexture} + */ + this.texture_ = null; + + /** + * @private + * @type {number} + */ + this.size_ = size; + +}; +goog.inherits(ol.webglrenderer.Framebuffer, ol.webglrenderer.GLObject); + + +/** + */ +ol.webglrenderer.Framebuffer.prototype.bind = function() { + var gl = this.getGL(); + var framebuffer = this.get(); + gl.bindFramebuffer(goog.webgl.FRAMEBUFFER, framebuffer); +}; + + +/** + * @param {number} size Size. + * @private + * @return {WebGLTexture} Texture. + */ +ol.webglrenderer.Framebuffer.prototype.createTexture_ = function(size) { + var gl = this.getGL(); + var texture = gl.createTexture(); + gl.bindTexture(goog.webgl.TEXTURE_2D, this.texture_); + gl.texImage2D(goog.webgl.TEXTURE_2D, 0, goog.webgl.RGBA, size, size, 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); + return texture; +}; + + +/** + * @return {WebGLFramebuffer} Framebuffer. + */ +ol.webglrenderer.Framebuffer.prototype.get = function() { + goog.asserts.assert(!goog.isNull(this.framebuffer_)); + return this.framebuffer_; +}; + + +/** + * @param {WebGLRenderingContext} gl GL. + */ +ol.webglrenderer.Framebuffer.prototype.setGL = function(gl) { + if (!goog.isNull(this.gl)) { + if (!goog.isNull(this.framebuffer_)) { + this.gl.deleteFramebuffer(this.framebuffer_); + this.framebuffer_ = null; + } + if (!goog.isNull(this.texture_)) { + this.gl.deleteTexture(this.texture_); + this.texture_ = null; + } + } + goog.base(this, 'setGL', gl); + if (!goog.isNull(gl)) { + this.texture_ = this.createTexture_(this.size_); + this.framebuffer_ = gl.createFramebuffer(); + gl.bindFramebuffer(goog.webgl.FRAMEBUFFER, this.framebuffer_); + gl.framebufferTexture2D(goog.webgl.FRAMEBUFFER, + goog.webgl.COLOR_ATTACHMENT0, goog.webgl.TEXTURE_2D, this.texture_, 0); + } +}; + + +/** + * @param {number} size Size. + */ +ol.webglrenderer.Framebuffer.prototype.setSize = function(size) { + var gl = this.getGL(); + goog.asserts.assert(!(size & (size - 1))); + if (this.size_ != size && !goog.isNull(gl)) { + var texture = this.createTexture_(size); + goog.asserts.assert(!goog.isNull(this.framebuffer_)); + gl.bindFramebuffer(goog.webgl.FRAMEBUFFER, this.framebuffer_); + gl.framebufferTexture2D(goog.webgl.FRAMEBUFFER, + goog.webgl.COLOR_ATTACHMENT0, goog.webgl.TEXTURE_2D, texture, 0); + goog.asserts.assert(!goog.isNull(this.texture_)); + gl.deleteTexture(this.texture_); + this.texture = texture; + } +}; diff --git a/src/ol/webglrenderer/globject.js b/src/ol/webglrenderer/globject.js new file mode 100644 index 0000000000..785a64d93a --- /dev/null +++ b/src/ol/webglrenderer/globject.js @@ -0,0 +1,50 @@ +goog.provide('ol.webglrenderer.GLObject'); + +goog.require('goog.Disposable'); +goog.require('ol.webglrenderer.IGLObject'); + + + +/** + * @constructor + * @extends {goog.Disposable} + * @implements {ol.webglrenderer.IGLObject} + */ +ol.webglrenderer.GLObject = function() { + + goog.base(this); + + /** + * @private + * @type {WebGLRenderingContext} + */ + this.gl_ = null; + +}; +goog.inherits(ol.webglrenderer.GLObject, goog.Disposable); + + +/** + * @inheritDoc + */ +ol.webglrenderer.GLObject.prototype.disposeInternal = function() { + this.setGL(null); + goog.base(this, 'disposeInternal'); +}; + + +/** + * @inheritDoc + */ +ol.webglrenderer.GLObject.prototype.getGL = function() { + goog.asserts.assert(!goog.isNull(this.gl_)); + return this.gl_; +}; + + +/** + * @inheritDoc + */ +ol.webglrenderer.GLObject.prototype.setGL = function(gl) { + this.gl_ = gl; +}; diff --git a/src/ol/webglrenderer/program.js b/src/ol/webglrenderer/program.js new file mode 100644 index 0000000000..4b625dcae2 --- /dev/null +++ b/src/ol/webglrenderer/program.js @@ -0,0 +1,79 @@ +goog.provide('ol.webglrenderer.Program'); + +goog.require('goog.asserts'); +goog.require('goog.webgl'); +goog.require('ol.webglrenderer.GLObject'); +goog.require('ol.webglrenderer.VertexAttrib'); +goog.require('ol.webglrenderer.shader.Fragment'); +goog.require('ol.webglrenderer.shader.Vertex'); + + + +/** + * @constructor + * @extends {ol.webglrenderer.GLObject} + * @param {ol.webglrenderer.shader.Fragment} fragmentShader Fragment shader. + * @param {ol.webglrenderer.shader.Vertex} vertexShader Vertex shader. + */ +ol.webglrenderer.Program = function(fragmentShader, vertexShader) { + + goog.base(this); + + /** + * @private + * @type {ol.webglrenderer.shader.Fragment} + */ + this.fragmentShader_ = fragmentShader; + + /** + * @private + * @type {ol.webglrenderer.shader.Vertex} + */ + this.vertexShader_ = vertexShader; + + /** + * @private + * @type {WebGLProgram} + */ + this.program_ = null; + +}; +goog.inherits(ol.webglrenderer.Program, ol.webglrenderer.GLObject); + + +/** + * @inheritDoc + */ +ol.webglrenderer.Program.prototype.setGL = function(gl) { + if (!goog.isNull(this.gl)) { + if (!goog.isNull(this.program_)) { + this.gl.deleteProgram(this.program_); + this.program_ = null; + } + this.fragmentShader_.setGL(null); + this.vertexShader_.setGL(null); + } + goog.base(this, 'setGL', gl); + if (!goog.isNull(gl)) { + this.fragmentShader_.setGL(gl); + this.vertexShader_.setGL(gl); + var program = gl.createProgram(); + gl.attachShader(program, this.fragmentShader_.get()); + gl.attachShader(program, this.vertexShader_.get()); + gl.linkProgram(program); + if (!gl.getProgramParameter(program, goog.webgl.LINK_STATUS)) { + window.console.log(gl.getProgramInfoLog(program)); + goog.asserts.assert( + gl.getProgramParameter(program, goog.webgl.LINK_STATUS)); + } + this.program_ = program; + } +}; + + +/** + */ +ol.webglrenderer.Program.prototype.use = function() { + var gl = this.getGL(); + gl.useProgram(this.program_); +}; diff --git a/src/ol/webglrenderer/programcache.js b/src/ol/webglrenderer/programcache.js new file mode 100644 index 0000000000..0cd9ef9ded --- /dev/null +++ b/src/ol/webglrenderer/programcache.js @@ -0,0 +1,64 @@ +goog.provide('ol.webglrenderer.ProgramCache'); + +goog.require('goog.dispose'); +goog.require('goog.object'); +goog.require('ol.webglrenderer.GLObject'); +goog.require('ol.webglrenderer.Program'); +goog.require('ol.webglrenderer.shader.Fragment'); +goog.require('ol.webglrenderer.shader.Vertex'); + + + +/** + * @constructor + * @extends {ol.webglrenderer.GLObject} + */ +ol.webglrenderer.ProgramCache = function() { + + goog.base(this); + + /** + * @private + * @type {Object.>} + */ + this.programss_ = {}; + +}; +goog.inherits(ol.webglrenderer.ProgramCache, ol.webglrenderer.GLObject); + + +/** + * @param {ol.webglrenderer.shader.Fragment} fragmentShader Fragment shader. + * @param {ol.webglrenderer.shader.Vertex} vertexShader Vertex shader. + * @return {ol.webglrenderer.Program} Program. + */ +ol.webglrenderer.ProgramCache.prototype.get = + function(fragmentShader, vertexShader) { + var program, programs; + var fragmentShaderKey = goog.getUid(fragmentShader); + if (fragmentShaderKey in this.programss_) { + programs = this.programss_[fragmentShaderKey]; + } else { + programs = {}; + this.programss_[fragmentShaderKey] = programs; + } + var vertexShaderKey = goog.getUid(vertexShader); + if (vertexShaderKey in programs) { + program = programs[vertexShaderKey]; + } else { + program = new ol.webglrenderer.Program(fragmentShader, vertexShader); + programs[vertexShaderKey] = program; + } + return program; +}; + + +/** + * @inheritDoc + */ +ol.webglrenderer.ProgramCache.prototype.setGL = function(gl) { + goog.object.forEach(this.programss_, function(programs) { + goog.disposeAll(goog.object.getValues(programs)); + }); + goog.base(this, 'setGL', gl); +}; diff --git a/src/ol/webglrenderer/shader.js b/src/ol/webglrenderer/shader.js new file mode 100644 index 0000000000..d41c739339 --- /dev/null +++ b/src/ol/webglrenderer/shader.js @@ -0,0 +1,117 @@ +goog.provide('ol.webglrenderer.Shader'); + +goog.require('goog.array'); +goog.require('goog.asserts'); +goog.require('goog.webgl'); +goog.require('ol.webglrenderer.GLObject'); +goog.require('ol.webglrenderer.Uniform'); + + + +/** + * @constructor + * @extends {ol.webglrenderer.GLObject} + * @param {string} source Source. + * @param {Array.=} opt_uniforms Uniforms. + */ +ol.webglrenderer.Shader = function(source, opt_uniforms) { + + goog.base(this); + + /** + * @private + * @type {WebGLShader} + */ + this.shader_ = null; + + /** + * @private + * @type {string} + */ + this.source_ = source; + + /** + * @private + * @type {Array.} + */ + this.uniforms_ = opt_uniforms || []; + +}; +goog.inherits(ol.webglrenderer.Shader, ol.webglrenderer.GLObject); + + +/** + */ +ol.webglrenderer.Shader.prototype.compile = function() { + var gl = this.getGL(); + this.shader_ = this.create(); + gl.shaderSource(this.shader_, this.source_); + gl.compileShader(this.shader_); + if (!gl.getShaderParameter(this.shader_, goog.webgl.COMPILE_STATUS)) { + window.console.log(gl.getShaderInfoLog(this.shader_)); + goog.asserts.assert( + gl.getShaderParameter(this.shader_, goog.webgl.COMPILE_STATUS)); + } +}; + + +/** + * @protected + * @return {WebGLShader} Shader. + */ +ol.webglrenderer.Shader.prototype.create = goog.abstractMethod; + + +/** + * @return {WebGLShader} Shader. + */ +ol.webglrenderer.Shader.prototype.get = function() { + return this.shader_; +}; + + +/** + * @return {boolean} Is animated? + */ +ol.webglrenderer.Shader.prototype.isAnimated = function() { + return false; +}; + + +/** + * @inheritDoc + */ +ol.webglrenderer.Shader.prototype.setGL = function(gl) { + if (!goog.isNull(this.gl)) { + goog.array.forEach(this.uniforms_, function(uniform) { + uniform.setGL(null); + }); + if (!goog.isNull(this.shader_)) { + this.gl.deleteShader(this.shader_); + this.shader_ = null; + } + } + goog.base(this, 'setGL', gl); + if (!goog.isNull(gl)) { + this.compile(); + goog.array.forEach(this.uniforms_, function(uniform) { + uniform.setGL(gl); + }); + } +}; + + +/** + * @param {WebGLProgram} program Program. + */ +ol.webglrenderer.Shader.prototype.setProgram = function(program) { + goog.array.forEach(this.uniforms_, function(uniform) { + uniform.setProgram(program); + }); +}; + + +/** + */ +ol.webglrenderer.Shader.prototype.setUniforms = function() { +}; diff --git a/src/ol/webglrenderer/shader/fragment.js b/src/ol/webglrenderer/shader/fragment.js new file mode 100644 index 0000000000..d68e671578 --- /dev/null +++ b/src/ol/webglrenderer/shader/fragment.js @@ -0,0 +1,27 @@ +goog.provide('ol.webglrenderer.shader.Fragment'); + +goog.require('goog.asserts'); +goog.require('ol.webglrenderer.Shader'); + + + +/** + * @constructor + * @extends {ol.webglrenderer.Shader} + * @param {string} source Source. + * @param {Array.=} opt_uniforms Uniforms. + */ +ol.webglrenderer.shader.Fragment = function(source, opt_uniforms) { + goog.base(this, source, opt_uniforms); +}; +goog.inherits(ol.webglrenderer.shader.Fragment, ol.webglrenderer.Shader); + + +/** + * @protected + * @return {WebGLShader} Shader. + */ +ol.webglrenderer.shader.Fragment.prototype.create = function() { + var gl = this.getGL(); + return gl.createShader(gl.FRAGMENT_SHADER); +}; diff --git a/src/ol/webglrenderer/shader/vertex.js b/src/ol/webglrenderer/shader/vertex.js new file mode 100644 index 0000000000..f234778882 --- /dev/null +++ b/src/ol/webglrenderer/shader/vertex.js @@ -0,0 +1,27 @@ +goog.provide('ol.webglrenderer.shader.Vertex'); + +goog.require('goog.asserts'); +goog.require('ol.webglrenderer.Shader'); + + + +/** + * @constructor + * @extends {ol.webglrenderer.Shader} + * @param {string} source Source. + * @param {Array.=} opt_uniforms Uniforms. + */ +ol.webglrenderer.shader.Vertex = function(source, opt_uniforms) { + goog.base(this, source, opt_uniforms); +}; +goog.inherits(ol.webglrenderer.shader.Vertex, ol.webglrenderer.Shader); + + +/** + * @protected + * @return {WebGLShader} Shader. + */ +ol.webglrenderer.shader.Vertex.prototype.create = function() { + var gl = this.getGL(); + return gl.createShader(gl.VERTEX_SHADER); +}; diff --git a/src/ol/webglrenderer/staticglobject.js b/src/ol/webglrenderer/staticglobject.js new file mode 100644 index 0000000000..b94b6daf33 --- /dev/null +++ b/src/ol/webglrenderer/staticglobject.js @@ -0,0 +1,49 @@ +goog.provide('ol.webglrenderer.StaticGLObject'); + +goog.require('goog.Disposable'); + + + +/** + * @constructor + * @extends {goog.Disposable} + * @param {WebGLRenderingContext} gl GL. + */ +ol.webglrenderer.StaticGLObject = function(gl) { + + goog.asserts.assert(!goog.isNull(gl)); + + /** + * @protected + * @type {WebGLRenderingContext} + */ + this.gl = gl; + +}; +goog.inherits(ol.webglrenderer.StaticGLObject, goog.Disposable); + + +/** + * @inheritDoc + */ +ol.webglrenderer.StaticGLObject.prototype.disposeInternal = function() { + this.gl = null; + goog.base(this, 'disposeInternal'); +}; + + +/** + * @return {!WebGLRenderingContext} GL. + */ +ol.webglrenderer.StaticGLObject.prototype.getGL = function() { + goog.asserts.assert(!goog.isNull(this.gl)); + return this.gl; +}; + + +/** + * @return {WebGLRenderingContext} GL. + */ +ol.webglrenderer.StaticGLObject.prototype.unsafeGetGL = function() { + return this.gl; +}; diff --git a/src/ol/webglrenderer/texture.js b/src/ol/webglrenderer/texture.js new file mode 100644 index 0000000000..6531189ae5 --- /dev/null +++ b/src/ol/webglrenderer/texture.js @@ -0,0 +1,64 @@ +goog.provide('ol.webglrenderer.Texture'); + +goog.require('goog.asserts'); +goog.require('ol.webglrenderer.GLObject'); + + + +/** + * @constructor + * @extends {ol.webglrenderer.GLObject} + * @param {Image} image Image. + */ +ol.webglrenderer.Texture = function(image) { + + goog.base(this); + + /** + * @private + * @type {WebGLTexture} + */ + this.texture_ = null; + + /** + * @private + * @type {Image} + */ + this.image_ = image; + +}; +goog.inherits(ol.webglrenderer.Texture, ol.webglrenderer.GLObject); + + +/** + */ +ol.webglrenderer.Texture.prototype.bind = function() { + var gl = this.getGL(); + if (goog.isNull(this.texture_)) { + 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, this.image_); + gl.texParameteri(goog.webgl.TEXTURE_2D, goog.webgl.TEXTURE_MAG_FILTER, + goog.webgl.NEAREST); + gl.texParameteri(goog.webgl.TEXTURE_2D, goog.webgl.TEXTURE_MIN_FILTER, + goog.webgl.NEAREST); + this.texture_ = texture; + } else { + gl.bindTexture(goog.webgl.TEXTURE_2D, this.texture_); + } +}; + + +/** + * @inheritDoc + */ +ol.webglrenderer.Texture.prototype.setGL = function(gl) { + if (!goog.isNull(this.gl)) { + if (!goog.isNull(this.texture_)) { + this.gl.deleteTexture(this.texture_); + this.texture_ = null; + } + } + goog.base(this, 'setGL', gl); +}; diff --git a/src/ol/webglrenderer/tilelayerrenderer.js b/src/ol/webglrenderer/tilelayerrenderer.js new file mode 100644 index 0000000000..b91b8cefb3 --- /dev/null +++ b/src/ol/webglrenderer/tilelayerrenderer.js @@ -0,0 +1,71 @@ +goog.provide('ol.webglrenderer.TileLayerRenderer'); + +goog.require('goog.events.EventType'); +goog.require('ol.LayerRenderer'); +goog.require('ol.webglrenderer.IGLObject'); + + + +/** + * @constructor + * @extends {ol.LayerRenderer} + * @implements {ol.webglrenderer.IGLObject} + * @param {ol.Layer} layer Layer. + * @param {WebGLRenderingContext} gl GL. + */ +ol.webglrenderer.TileLayerRenderer = function(layer, gl) { + + goog.base(this, layer); + + /** + * @type {WebGLRenderingContext} + * @private + */ + this.gl_ = null; + + this.setGL(gl); + +}; +goog.inherits(ol.webglrenderer.TileLayerRenderer, ol.LayerRenderer); + + +/** + * @protected + */ +ol.webglrenderer.TileLayerRenderer.prototype.dispatchChangeEvent = function() { + this.dispatchEvent(goog.events.EventType.CHANGE); +}; + + +/** + * @inheritDoc + */ +ol.webglrenderer.TileLayerRenderer.prototype.getGL = function() { + return this.gl_; +}; + + +/** + * @inheritDoc + */ +ol.webglrenderer.TileLayerRenderer.prototype.handleLayerOpacityChange = + function() { + this.dispatchChangeEvent(); +}; + + +/** + * @inheritDoc + */ +ol.webglrenderer.TileLayerRenderer.prototype.handleLayerVisibleChange = + function() { + this.dispatchChangeEvent(); +}; + + +/** + * @inheritDoc + */ +ol.webglrenderer.TileLayerRenderer.prototype.setGL = function(gl) { + this.gl_ = gl; +}; diff --git a/src/ol/webglrenderer/uniform.js b/src/ol/webglrenderer/uniform.js new file mode 100644 index 0000000000..ca33224478 --- /dev/null +++ b/src/ol/webglrenderer/uniform.js @@ -0,0 +1,101 @@ +goog.provide('ol.webglrenderer.Uniform'); + +goog.require('goog.asserts'); +goog.require('goog.vec.Mat4'); +goog.require('ol.webglrenderer.GLObject'); + + + +/** + * @constructor + * @extends {ol.webglrenderer.GLObject} + * @param {string} name Name. + */ +ol.webglrenderer.Uniform = function(name) { + + goog.base(this); + + /** + * @private + * @type {WebGLProgram} + */ + this.program_ = null; + + /** + * @private + * @type {string} + */ + this.name_ = name; + + /** + * @private + * @type {WebGLUniformLocation} + */ + this.location_ = null; + +}; +goog.inherits(ol.webglrenderer.Uniform, ol.webglrenderer.GLObject); + + +/** + * @return {string} Name. + */ +ol.webglrenderer.Uniform.prototype.getName = function() { + return this.name_; +}; + + +/** + * @param {WebGLRenderingContext} gl GL. + */ +ol.webglrenderer.Uniform.prototype.setGL = function(gl) { + this.location_ = null; + goog.base(this, 'setGL', gl); +}; + + +/** + * @param {number} value Value. + */ +ol.webglrenderer.Uniform.prototype.set1f = function(value) { + var gl = this.getGL(); + if (!goog.isNull(this.location_)) { + gl.uniform1f(this.location_, value); + } +}; + + +/** + * @param {number} value Value. + */ +ol.webglrenderer.Uniform.prototype.set1i = function(value) { + var gl = this.getGL(); + if (!goog.isNull(this.location_)) { + gl.uniform1i(this.location_, value); + } +}; + + +/** + * @param {boolean} transpose Transpose. + * @param {goog.vec.Mat4.Mat4Like} value Value. + */ +ol.webglrenderer.Uniform.prototype.setMatrix4fv = function(transpose, value) { + var gl = this.getGL(); + if (!goog.isNull(this.location_)) { + gl.uniformMatrix4fv(this.location_, transpose, value); + } +}; + + +/** + * @param {WebGLProgram} program Program. + */ +ol.webglrenderer.Uniform.prototype.setProgram = function(program) { + if (goog.isNull(program)) { + this.location_ = null; + } else { + var gl = this.getGL(); + this.location_ = gl.getUniformLocation(program, this.name_); + } +}; diff --git a/src/ol/webglrenderer/vertexattrib.js b/src/ol/webglrenderer/vertexattrib.js new file mode 100644 index 0000000000..9aabef8700 --- /dev/null +++ b/src/ol/webglrenderer/vertexattrib.js @@ -0,0 +1,78 @@ +goog.provide('ol.webglrenderer.VertexAttrib'); + +goog.require('goog.asserts'); +goog.require('ol.webglrenderer.GLObject'); + + + +/** + * @constructor + * @extends {ol.webglrenderer.GLObject} + * @param {string} name Name. + */ +ol.webglrenderer.VertexAttrib = function(name) { + + goog.base(this); + + /** + * @private + * @type {string} + */ + this.name_ = name; + + /** + * @private + * @type {number} + */ + this.location_ = -1; + +}; +goog.inherits(ol.webglrenderer.VertexAttrib, ol.webglrenderer.GLObject); + + +/** + */ +ol.webglrenderer.VertexAttrib.prototype.enableArray = function() { + var gl = this.getGL(); + goog.asserts.assert(this.location_ != -1); + gl.enableVertexAttribArray(this.location_); +}; + + +/** + * @param {number} size Size. + * @param {number} type Type. + * @param {boolean} normalize Normalized. + * @param {number} stride Stride. + * @param {number} offset Offset. + */ +ol.webglrenderer.VertexAttrib.prototype.pointer = + function(size, type, normalize, stride, offset) { + var gl = this.getGL(); + goog.asserts.assert(this.location_ != -1); + gl.vertexAttribPointer( + this.location_, size, type, normalize, stride, offset); +}; + + +/** + * @param {WebGLRenderingContext} gl GL. + */ +ol.webglrenderer.VertexAttrib.prototype.setGL = function(gl) { + this.location_ = -1; + goog.base(this, 'setGL', gl); +}; + + +/** + * @param {WebGLProgram} program Program. + */ +ol.webglrenderer.VertexAttrib.prototype.setProgram = function(program) { + if (goog.isNull(program)) { + this.location_ = -1; + } else { + var gl = this.getGL(); + this.location_ = gl.getAttribLocation(program, this.name_); + goog.asserts.assert(!goog.isNull(this.location_)); + } +};