Merge Map and MapRenderer

src/ol/webgl/arraybuffer.js

@@ -0,0 +1,47 @@
+goog.provide('ol.webgl.ArrayBuffer');
+
+goog.require('goog.webgl');
+goog.require('ol.webgl.StaticGLObject');
+
+
+
+/**
+ * @constructor
+ * @extends {ol.webgl.StaticGLObject}
+ * @param {WebGLRenderingContext} gl GL.
+ * @param {ArrayBuffer|ArrayBufferView|null|number} data Data.
+ * @param {number} usage Usage.
+ */
+ol.webgl.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.webgl.ArrayBuffer, ol.webgl.StaticGLObject);
+
+
+/**
+ */
+ol.webgl.ArrayBuffer.prototype.bind = function() {
+  var gl = this.getGL();
+  gl.bindBuffer(goog.webgl.ARRAY_BUFFER, this.buffer_);
+};
+
+
+/**
+ * @inheritDoc
+ */
+ol.webgl.ArrayBuffer.prototype.disposeInternal = function() {
+  var gl = this.getGL();
+  gl.deleteBuffer(this.buffer_);
+  this.buffer_ = null;
+  goog.base(this, 'disposeInternal');
+};

src/ol/webgl/framebuffer.js

@@ -0,0 +1,118 @@
+goog.provide('ol.webgl.Framebuffer');
+
+goog.require('goog.asserts');
+goog.require('goog.webgl');
+goog.require('ol.webgl.GLObject');
+
+
+
+/**
+ * @constructor
+ * @extends {ol.webgl.GLObject}
+ * @param {number} size Size.
+ */
+ol.webgl.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.webgl.Framebuffer, ol.webgl.GLObject);
+
+
+/**
+ */
+ol.webgl.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.webgl.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.webgl.Framebuffer.prototype.get = function() {
+  goog.asserts.assert(!goog.isNull(this.framebuffer_));
+  return this.framebuffer_;
+};
+
+
+/**
+ * @param {WebGLRenderingContext} gl GL.
+ */
+ol.webgl.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.webgl.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;
+  }
+};

src/ol/webgl/globject.js

@@ -0,0 +1,50 @@
+goog.provide('ol.webgl.GLObject');
+
+goog.require('goog.Disposable');
+goog.require('ol.webgl.IGLObject');
+
+
+
+/**
+ * @constructor
+ * @extends {goog.Disposable}
+ * @implements {ol.webgl.IGLObject}
+ */
+ol.webgl.GLObject = function() {
+
+  goog.base(this);
+
+  /**
+   * @private
+   * @type {WebGLRenderingContext}
+   */
+  this.gl_ = null;
+
+};
+goog.inherits(ol.webgl.GLObject, goog.Disposable);
+
+
+/**
+ * @inheritDoc
+ */
+ol.webgl.GLObject.prototype.disposeInternal = function() {
+  this.setGL(null);
+  goog.base(this, 'disposeInternal');
+};
+
+
+/**
+ * @inheritDoc
+ */
+ol.webgl.GLObject.prototype.getGL = function() {
+  goog.asserts.assert(!goog.isNull(this.gl_));
+  return this.gl_;
+};
+
+
+/**
+ * @inheritDoc
+ */
+ol.webgl.GLObject.prototype.setGL = function(gl) {
+  this.gl_ = gl;
+};

src/ol/webgl/iglobject.js

@@ -0,0 +1,20 @@
+goog.provide('ol.webgl.IGLObject');
+
+
+
+/**
+ * @interface
+ */
+ol.webgl.IGLObject = function() {};
+
+
+/**
+ * @return {WebGLRenderingContext} GL.
+ */
+ol.webgl.IGLObject.prototype.getGL = function() {};
+
+
+/**
+ * @param {WebGLRenderingContext} gl GL.
+ */
+ol.webgl.IGLObject.prototype.setGL = function(gl) {};

src/ol/webgl/map.js

@@ -0,0 +1,175 @@
+goog.provide('ol.webgl.Map');
+
+goog.require('goog.dom');
+goog.require('goog.dom.TagName');
+goog.require('goog.style');
+goog.require('goog.webgl');
+goog.require('ol.Layer');
+goog.require('ol.Map');
+goog.require('ol.TileStore');
+goog.require('ol.webgl.IGLObject');
+goog.require('ol.webgl.TileLayerRenderer');
+
+
+
+/**
+ * @constructor
+ * @extends {ol.Map}
+ * @implements {ol.webgl.IGLObject}
+ * @param {!HTMLDivElement} target Target.
+ * @param {Object.<string, *>=} opt_values Values.
+ */
+ol.webgl.Map = function(target, opt_values) {
+
+  goog.base(this, target);
+
+  /**
+   * @private
+   * @type {Element}
+   */
+  this.canvas_ = goog.dom.createElement(goog.dom.TagName.CANVAS);
+  this.canvas_.height = target.clientHeight;
+  this.canvas_.width = target.clientWidth;
+  this.canvas_.style.overflow = 'hidden';
+  target.appendChild(this.canvas_);
+
+  /**
+   * @private
+   * @type {WebGLRenderingContext}
+   */
+  this.gl_ = null;
+
+  /** @type {WebGLRenderingContext} */
+  var gl = this.canvas_.getContext('experimental-webgl', {
+    alpha: false,
+    antialias: true,
+    depth: false,
+    preserveDrawingBuffer: false,
+    stencil: false
+  });
+  goog.asserts.assert(!goog.isNull(gl));
+  this.setGL(gl);
+
+  if (goog.isDef(opt_values)) {
+    this.setValues(opt_values);
+  }
+
+};
+goog.inherits(ol.webgl.Map, ol.Map);
+
+
+/**
+ * @inheritDoc
+ */
+ol.webgl.Map.prototype.createLayerRenderer = function(layer) {
+  var store = layer.getStore();
+  if (store instanceof ol.TileStore) {
+    return new ol.webgl.TileLayerRenderer(layer, this.getGL());
+  } else {
+    goog.asserts.assert(false);
+    return null;
+  }
+};
+
+
+/**
+ * @inheritDoc
+ */
+ol.webgl.Map.prototype.disposeInternal = function() {
+  this.setGL(null);
+  goog.base(this, 'disposeInternal');
+};
+
+
+/**
+ * @inheritDoc
+ */
+ol.webgl.Map.prototype.getGL = function() {
+  var gl = this.gl_;
+  goog.asserts.assert(!goog.isNull(gl));
+  return gl;
+};
+
+
+/**
+ * @inheritDoc
+ */
+ol.webgl.Map.prototype.handleCameraPropertyChanged = function() {
+  this.redraw_();
+};
+
+
+/**
+ * @inheritDoc
+ */
+ol.webgl.Map.prototype.handleLayerAdd = function(layer) {
+  goog.base(this, 'handleLayerAdd', layer);
+  this.redraw_();
+};
+
+
+/**
+ * @inheritDoc
+ */
+ol.webgl.Map.prototype.handleLayerRemove = function(layer) {
+  goog.base(this, 'handleLayerRemove', layer);
+  this.redraw_();
+};
+
+
+/**
+ * @inheritDoc
+ */
+ol.webgl.Map.prototype.handleTargetResize = function(event) {
+  goog.base(this, 'handleTargetResize', event);
+  this.updateSize_();
+};
+
+
+/**
+ * @private
+ */
+ol.webgl.Map.prototype.redraw_ = function() {
+
+  var gl = this.getGL();
+
+  gl.clear(goog.webgl.COLOR_BUFFER_BIT);
+
+};
+
+
+/**
+ * @inheritDoc
+ */
+ol.webgl.Map.prototype.setGL = function(gl) {
+  if (!goog.isNull(this.gl_)) {
+    this.gl_ = null;
+  }
+  this.gl_ = gl;
+  if (!goog.isNull(gl)) {
+    gl.clearColor(1, 0, 0, 1);
+    gl.disable(goog.webgl.CULL_FACE);
+    gl.disable(goog.webgl.DEPTH_TEST);
+    gl.disable(goog.webgl.SCISSOR_TEST);
+    this.forEachLayerRenderer(function(layerRenderer) {
+      layerRenderer.setGL(gl);
+    });
+    this.updateSize_();
+    this.redraw_();
+  }
+};
+
+
+/**
+ * @private
+ */
+ol.webgl.Map.prototype.updateSize_ = function() {
+  var size = this.getSize();
+  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.redraw_();
+  }
+};

src/ol/webgl/program.js

@@ -0,0 +1,79 @@
+goog.provide('ol.webgl.Program');
+
+goog.require('goog.asserts');
+goog.require('goog.webgl');
+goog.require('ol.webgl.GLObject');
+goog.require('ol.webgl.VertexAttrib');
+goog.require('ol.webgl.shader.Fragment');
+goog.require('ol.webgl.shader.Vertex');
+
+
+
+/**
+ * @constructor
+ * @extends {ol.webgl.GLObject}
+ * @param {ol.webgl.shader.Fragment} fragmentShader Fragment shader.
+ * @param {ol.webgl.shader.Vertex} vertexShader Vertex shader.
+ */
+ol.webgl.Program = function(fragmentShader, vertexShader) {
+
+  goog.base(this);
+
+  /**
+   * @private
+   * @type {ol.webgl.shader.Fragment}
+   */
+  this.fragmentShader_ = fragmentShader;
+
+  /**
+   * @private
+   * @type {ol.webgl.shader.Vertex}
+   */
+  this.vertexShader_ = vertexShader;
+
+  /**
+   * @private
+   * @type {WebGLProgram}
+   */
+  this.program_ = null;
+
+};
+goog.inherits(ol.webgl.Program, ol.webgl.GLObject);
+
+
+/**
+ * @inheritDoc
+ */
+ol.webgl.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.webgl.Program.prototype.use = function() {
+  var gl = this.getGL();
+  gl.useProgram(this.program_);
+};

src/ol/webgl/programcache.js

@@ -0,0 +1,64 @@
+goog.provide('ol.webgl.ProgramCache');
+
+goog.require('goog.dispose');
+goog.require('goog.object');
+goog.require('ol.webgl.GLObject');
+goog.require('ol.webgl.Program');
+goog.require('ol.webgl.shader.Fragment');
+goog.require('ol.webgl.shader.Vertex');
+
+
+
+/**
+ * @constructor
+ * @extends {ol.webgl.GLObject}
+ */
+ol.webgl.ProgramCache = function() {
+
+  goog.base(this);
+
+  /**
+   * @private
+   * @type {Object.<string, Object.<string, ol.webgl.Program>>}
+   */
+  this.programss_ = {};
+
+};
+goog.inherits(ol.webgl.ProgramCache, ol.webgl.GLObject);
+
+
+/**
+ * @param {ol.webgl.shader.Fragment} fragmentShader Fragment shader.
+ * @param {ol.webgl.shader.Vertex} vertexShader Vertex shader.
+ * @return {ol.webgl.Program} Program.
+ */
+ol.webgl.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.webgl.Program(fragmentShader, vertexShader);
+    programs[vertexShaderKey] = program;
+  }
+  return program;
+};
+
+
+/**
+ * @inheritDoc
+ */
+ol.webgl.ProgramCache.prototype.setGL = function(gl) {
+  goog.object.forEach(this.programss_, function(programs) {
+    goog.disposeAll(goog.object.getValues(programs));
+  });
+  goog.base(this, 'setGL', gl);
+};

src/ol/webgl/shader.js

@@ -0,0 +1,117 @@
+goog.provide('ol.webgl.Shader');
+
+goog.require('goog.array');
+goog.require('goog.asserts');
+goog.require('goog.webgl');
+goog.require('ol.webgl.GLObject');
+goog.require('ol.webgl.Uniform');
+
+
+
+/**
+ * @constructor
+ * @extends {ol.webgl.GLObject}
+ * @param {string} source Source.
+ * @param {Array.<ol.webgl.Uniform>=} opt_uniforms Uniforms.
+ */
+ol.webgl.Shader = function(source, opt_uniforms) {
+
+  goog.base(this);
+
+  /**
+   * @private
+   * @type {WebGLShader}
+   */
+  this.shader_ = null;
+
+  /**
+   * @private
+   * @type {string}
+   */
+  this.source_ = source;
+
+  /**
+   * @private
+   * @type {Array.<ol.webgl.Uniform>}
+   */
+  this.uniforms_ = opt_uniforms || [];
+
+};
+goog.inherits(ol.webgl.Shader, ol.webgl.GLObject);
+
+
+/**
+ */
+ol.webgl.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.webgl.Shader.prototype.create = goog.abstractMethod;
+
+
+/**
+ * @return {WebGLShader} Shader.
+ */
+ol.webgl.Shader.prototype.get = function() {
+  return this.shader_;
+};
+
+
+/**
+ * @return {boolean} Is animated?
+ */
+ol.webgl.Shader.prototype.isAnimated = function() {
+  return false;
+};
+
+
+/**
+ * @inheritDoc
+ */
+ol.webgl.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.webgl.Shader.prototype.setProgram = function(program) {
+  goog.array.forEach(this.uniforms_, function(uniform) {
+    uniform.setProgram(program);
+  });
+};
+
+
+/**
+ */
+ol.webgl.Shader.prototype.setUniforms = function() {
+};

src/ol/webgl/shader/fragment.js

@@ -0,0 +1,27 @@
+goog.provide('ol.webgl.shader.Fragment');
+
+goog.require('goog.asserts');
+goog.require('ol.webgl.Shader');
+
+
+
+/**
+ * @constructor
+ * @extends {ol.webgl.Shader}
+ * @param {string} source Source.
+ * @param {Array.<ol.webgl.Uniform>=} opt_uniforms Uniforms.
+ */
+ol.webgl.shader.Fragment = function(source, opt_uniforms) {
+  goog.base(this, source, opt_uniforms);
+};
+goog.inherits(ol.webgl.shader.Fragment, ol.webgl.Shader);
+
+
+/**
+ * @protected
+ * @return {WebGLShader} Shader.
+ */
+ol.webgl.shader.Fragment.prototype.create = function() {
+  var gl = this.getGL();
+  return gl.createShader(gl.FRAGMENT_SHADER);
+};

src/ol/webgl/shader/vertex.js

@@ -0,0 +1,27 @@
+goog.provide('ol.webgl.shader.Vertex');
+
+goog.require('goog.asserts');
+goog.require('ol.webgl.Shader');
+
+
+
+/**
+ * @constructor
+ * @extends {ol.webgl.Shader}
+ * @param {string} source Source.
+ * @param {Array.<ol.webgl.Uniform>=} opt_uniforms Uniforms.
+ */
+ol.webgl.shader.Vertex = function(source, opt_uniforms) {
+  goog.base(this, source, opt_uniforms);
+};
+goog.inherits(ol.webgl.shader.Vertex, ol.webgl.Shader);
+
+
+/**
+ * @protected
+ * @return {WebGLShader} Shader.
+ */
+ol.webgl.shader.Vertex.prototype.create = function() {
+  var gl = this.getGL();
+  return gl.createShader(gl.VERTEX_SHADER);
+};

src/ol/webgl/staticglobject.js

@@ -0,0 +1,49 @@
+goog.provide('ol.webgl.StaticGLObject');
+
+goog.require('goog.Disposable');
+
+
+
+/**
+ * @constructor
+ * @extends {goog.Disposable}
+ * @param {WebGLRenderingContext} gl GL.
+ */
+ol.webgl.StaticGLObject = function(gl) {
+
+  goog.asserts.assert(!goog.isNull(gl));
+
+  /**
+   * @protected
+   * @type {WebGLRenderingContext}
+   */
+  this.gl = gl;
+
+};
+goog.inherits(ol.webgl.StaticGLObject, goog.Disposable);
+
+
+/**
+ * @inheritDoc
+ */
+ol.webgl.StaticGLObject.prototype.disposeInternal = function() {
+  this.gl = null;
+  goog.base(this, 'disposeInternal');
+};
+
+
+/**
+ * @return {!WebGLRenderingContext} GL.
+ */
+ol.webgl.StaticGLObject.prototype.getGL = function() {
+  goog.asserts.assert(!goog.isNull(this.gl));
+  return this.gl;
+};
+
+
+/**
+ * @return {WebGLRenderingContext} GL.
+ */
+ol.webgl.StaticGLObject.prototype.unsafeGetGL = function() {
+  return this.gl;
+};

src/ol/webgl/texture.js

@@ -0,0 +1,64 @@
+goog.provide('ol.webgl.Texture');
+
+goog.require('goog.asserts');
+goog.require('ol.webgl.GLObject');
+
+
+
+/**
+ * @constructor
+ * @extends {ol.webgl.GLObject}
+ * @param {Image} image Image.
+ */
+ol.webgl.Texture = function(image) {
+
+  goog.base(this);
+
+  /**
+   * @private
+   * @type {WebGLTexture}
+   */
+  this.texture_ = null;
+
+  /**
+   * @private
+   * @type {Image}
+   */
+  this.image_ = image;
+
+};
+goog.inherits(ol.webgl.Texture, ol.webgl.GLObject);
+
+
+/**
+ */
+ol.webgl.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.webgl.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);
+};

src/ol/webgl/tilelayerrenderer.js

@@ -0,0 +1,71 @@
+goog.provide('ol.webgl.TileLayerRenderer');
+
+goog.require('goog.events.EventType');
+goog.require('ol.LayerRenderer');
+goog.require('ol.webgl.IGLObject');
+
+
+
+/**
+ * @constructor
+ * @extends {ol.LayerRenderer}
+ * @implements {ol.webgl.IGLObject}
+ * @param {ol.Layer} layer Layer.
+ * @param {WebGLRenderingContext} gl GL.
+ */
+ol.webgl.TileLayerRenderer = function(layer, gl) {
+
+  goog.base(this, layer);
+
+  /**
+   * @type {WebGLRenderingContext}
+   * @private
+   */
+  this.gl_ = null;
+
+  this.setGL(gl);
+
+};
+goog.inherits(ol.webgl.TileLayerRenderer, ol.LayerRenderer);
+
+
+/**
+ * @protected
+ */
+ol.webgl.TileLayerRenderer.prototype.dispatchChangeEvent = function() {
+  this.dispatchEvent(goog.events.EventType.CHANGE);
+};
+
+
+/**
+ * @inheritDoc
+ */
+ol.webgl.TileLayerRenderer.prototype.getGL = function() {
+  return this.gl_;
+};
+
+
+/**
+ * @inheritDoc
+ */
+ol.webgl.TileLayerRenderer.prototype.handleLayerOpacityChange =
+    function() {
+  this.dispatchChangeEvent();
+};
+
+
+/**
+ * @inheritDoc
+ */
+ol.webgl.TileLayerRenderer.prototype.handleLayerVisibleChange =
+    function() {
+  this.dispatchChangeEvent();
+};
+
+
+/**
+ * @inheritDoc
+ */
+ol.webgl.TileLayerRenderer.prototype.setGL = function(gl) {
+  this.gl_ = gl;
+};

src/ol/webgl/uniform.js

@@ -0,0 +1,101 @@
+goog.provide('ol.webgl.Uniform');
+
+goog.require('goog.asserts');
+goog.require('goog.vec.Mat4');
+goog.require('ol.webgl.GLObject');
+
+
+
+/**
+ * @constructor
+ * @extends {ol.webgl.GLObject}
+ * @param {string} name Name.
+ */
+ol.webgl.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.webgl.Uniform, ol.webgl.GLObject);
+
+
+/**
+ * @return {string} Name.
+ */
+ol.webgl.Uniform.prototype.getName = function() {
+  return this.name_;
+};
+
+
+/**
+ * @param {WebGLRenderingContext} gl GL.
+ */
+ol.webgl.Uniform.prototype.setGL = function(gl) {
+  this.location_ = null;
+  goog.base(this, 'setGL', gl);
+};
+
+
+/**
+ * @param {number} value Value.
+ */
+ol.webgl.Uniform.prototype.set1f = function(value) {
+  var gl = this.getGL();
+  if (!goog.isNull(this.location_)) {
+    gl.uniform1f(this.location_, value);
+  }
+};
+
+
+/**
+ * @param {number} value Value.
+ */
+ol.webgl.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.webgl.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.webgl.Uniform.prototype.setProgram = function(program) {
+  if (goog.isNull(program)) {
+    this.location_ = null;
+  } else {
+    var gl = this.getGL();
+    this.location_ = gl.getUniformLocation(program, this.name_);
+  }
+};

src/ol/webgl/vertexattrib.js

@@ -0,0 +1,78 @@
+goog.provide('ol.webgl.VertexAttrib');
+
+goog.require('goog.asserts');
+goog.require('ol.webgl.GLObject');
+
+
+
+/**
+ * @constructor
+ * @extends {ol.webgl.GLObject}
+ * @param {string} name Name.
+ */
+ol.webgl.VertexAttrib = function(name) {
+
+  goog.base(this);
+
+  /**
+   * @private
+   * @type {string}
+   */
+  this.name_ = name;
+
+  /**
+   * @private
+   * @type {number}
+   */
+  this.location_ = -1;
+
+};
+goog.inherits(ol.webgl.VertexAttrib, ol.webgl.GLObject);
+
+
+/**
+ */
+ol.webgl.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.webgl.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.webgl.VertexAttrib.prototype.setGL = function(gl) {
+  this.location_ = -1;
+  goog.base(this, 'setGL', gl);
+};
+
+
+/**
+ * @param {WebGLProgram} program Program.
+ */
+ol.webgl.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_));
+  }
+};

src/ol/webgl/webgl.js

@@ -0,0 +1,9 @@
+goog.provide('ol.webgl');
+
+
+/**
+ * @return {boolean} Is supported.
+ */
+ol.webgl.isSupported = function() {
+  return 'WebGLRenderingContext' in goog.global;
+};