Merge pull request #20 from openlayers/exp-reorganization

Exp reorganization

src/ol3/createmap.js

@@ -6,8 +6,6 @@ goog.require('ol3.Collection');
 goog.require('ol3.Map');
 goog.require('ol3.MapProperty');
 goog.require('ol3.Projection');
-goog.require('ol3.dom');
-goog.require('ol3.dom.MapRenderer');
 goog.require('ol3.interaction.AltDragRotate');
 goog.require('ol3.interaction.CenterConstraint');
 goog.require('ol3.interaction.Constraints');
@@ -19,8 +17,10 @@ goog.require('ol3.interaction.MouseWheelZoom');
 goog.require('ol3.interaction.ResolutionConstraint');
 goog.require('ol3.interaction.RotationConstraint');
 goog.require('ol3.interaction.ShiftDragZoom');
-goog.require('ol3.webgl');
+goog.require('ol3.renderer.dom');
-goog.require('ol3.webgl.MapRenderer');
+goog.require('ol3.renderer.dom.Map');
+goog.require('ol3.renderer.webgl');
+goog.require('ol3.renderer.webgl.Map');
 
 
 /**
@@ -132,13 +132,13 @@ ol3.createMap = function(target, opt_values, opt_rendererHints) {
   for (i = 0; i < rendererHints.length; ++i) {
     rendererHint = rendererHints[i];
     if (rendererHint == ol3.RendererHint.DOM) {
-      if (ol3.ENABLE_DOM && ol3.dom.isSupported()) {
+      if (ol3.ENABLE_DOM && ol3.renderer.dom.isSupported()) {
-        rendererConstructor = ol3.dom.MapRenderer;
+        rendererConstructor = ol3.renderer.dom.Map;
         break;
       }
     } else if (rendererHint == ol3.RendererHint.WEBGL) {
-      if (ol3.ENABLE_WEBGL && ol3.webgl.isSupported()) {
+      if (ol3.ENABLE_WEBGL && ol3.renderer.webgl.isSupported()) {
-        rendererConstructor = ol3.webgl.MapRenderer;
+        rendererConstructor = ol3.renderer.webgl.Map;
         break;
       }
     }

src/ol3/dom/dom.js

@@ -1,9 +0,0 @@
-goog.provide('ol3.dom');
-
-goog.require('goog.functions');
-
-
-/**
- * @return {boolean} Is supported.
- */
-ol3.dom.isSupported = goog.functions.TRUE;

src/ol3/map.js

@@ -32,13 +32,13 @@ goog.require('ol3.Color');
 goog.require('ol3.Coordinate');
 goog.require('ol3.Extent');
 goog.require('ol3.Interaction');
-goog.require('ol3.LayerRenderer');
 goog.require('ol3.MapBrowserEvent');
 goog.require('ol3.Object');
 goog.require('ol3.Pixel');
 goog.require('ol3.Projection');
 goog.require('ol3.Size');
 goog.require('ol3.TransformFunction');
+goog.require('ol3.renderer.Layer');
 
 
 /**
@@ -79,7 +79,7 @@ ol3.MapPaneZIndex = {
  * @extends {ol3.Object}
  * @implements {goog.fx.anim.Animated}
  * @param {Element} container Container.
- * @param {function(new: ol3.MapRenderer, Element, ol3.Map)} rendererConstructor
+ * @param {function(new: ol3.renderer.Map, Element, ol3.Map)} rendererConstructor
  *     Renderer constructor.
  * @param {Object=} opt_values Values.
  * @param {goog.dom.ViewportSizeMonitor=} opt_viewportSizeMonitor
@@ -179,7 +179,7 @@ ol3.Map = function(
   this.registerDisposable(dragger);
 
   /**
-   * @type {ol3.MapRenderer}
+   * @type {ol3.renderer.Map}
    * @private
    */
   this.renderer_ = new rendererConstructor(this.viewport_, this);

src/ol3/renderer/dom/dom.js

@@ -0,0 +1,9 @@
+goog.provide('ol3.renderer.dom');
+
+goog.require('goog.functions');
+
+
+/**
+ * @return {boolean} Is supported.
+ */
+ol3.renderer.dom.isSupported = goog.functions.TRUE;

src/ol3/renderer/dom/layer.js

@@ -1,18 +1,18 @@
-goog.provide('ol3.dom.LayerRenderer');
+goog.provide('ol3.renderer.dom.Layer');
 
 goog.require('ol3.Coordinate');
-goog.require('ol3.LayerRenderer');
+goog.require('ol3.renderer.Layer');
 
 
 
 /**
  * @constructor
- * @extends {ol3.LayerRenderer}
+ * @extends {ol3.renderer.Layer}
- * @param {ol3.MapRenderer} mapRenderer Map renderer.
+ * @param {ol3.renderer.Map} mapRenderer Map renderer.
  * @param {ol3.Layer} layer Layer.
  * @param {!Element} target Target.
  */
-ol3.dom.LayerRenderer = function(mapRenderer, layer, target) {
+ol3.renderer.dom.Layer = function(mapRenderer, layer, target) {
   goog.base(this, mapRenderer, layer);
 
   /**
@@ -33,22 +33,22 @@ ol3.dom.LayerRenderer = function(mapRenderer, layer, target) {
   this.handleLayerVisibleChange();
 
 };
-goog.inherits(ol3.dom.LayerRenderer, ol3.LayerRenderer);
+goog.inherits(ol3.renderer.dom.Layer, ol3.renderer.Layer);
 
 
 /**
  * @override
- * @return {ol3.MapRenderer} Map renderer.
+ * @return {ol3.renderer.Map} Map renderer.
  */
-ol3.dom.LayerRenderer.prototype.getMapRenderer = function() {
+ol3.renderer.dom.Layer.prototype.getMapRenderer = function() {
-  return /** @type {ol3.dom.MapRenderer} */ goog.base(this, 'getMapRenderer');
+  return /** @type {ol3.renderer.dom.Map} */ goog.base(this, 'getMapRenderer');
 };
 
 
 /**
  * @inheritDoc
  */
-ol3.dom.LayerRenderer.prototype.handleLayerLoad = function() {
+ol3.renderer.dom.Layer.prototype.handleLayerLoad = function() {
   this.getMap().render();
 };
 
@@ -56,7 +56,7 @@ ol3.dom.LayerRenderer.prototype.handleLayerLoad = function() {
 /**
  * @inheritDoc
  */
-ol3.dom.LayerRenderer.prototype.handleLayerOpacityChange = function() {
+ol3.renderer.dom.Layer.prototype.handleLayerOpacityChange = function() {
   goog.style.setOpacity(this.target, this.getLayer().getOpacity());
 };
 
@@ -64,14 +64,14 @@ ol3.dom.LayerRenderer.prototype.handleLayerOpacityChange = function() {
 /**
  * @inheritDoc
  */
-ol3.dom.LayerRenderer.prototype.handleLayerVisibleChange = function() {
+ol3.renderer.dom.Layer.prototype.handleLayerVisibleChange = function() {
   goog.style.showElement(this.target, this.getLayer().getVisible());
 };
 
 
 /**
  */
-ol3.dom.LayerRenderer.prototype.render = goog.abstractMethod;
+ol3.renderer.dom.Layer.prototype.render = goog.abstractMethod;
 
 
 /**
@@ -79,6 +79,6 @@ ol3.dom.LayerRenderer.prototype.render = goog.abstractMethod;
  *
  * @param {ol3.Coordinate} origin Origin.
  */
-ol3.dom.LayerRenderer.prototype.setOrigin = function(origin) {
+ol3.renderer.dom.Layer.prototype.setOrigin = function(origin) {
   this.origin = origin;
 };

src/ol3/renderer/dom/map.js

@@ -1,4 +1,4 @@
-goog.provide('ol3.dom.MapRenderer');
+goog.provide('ol3.renderer.dom.Map');
 
 goog.require('goog.asserts');
 goog.require('goog.dom');
@@ -6,19 +6,19 @@ goog.require('goog.dom.TagName');
 goog.require('goog.style');
 goog.require('ol3.Coordinate');
 goog.require('ol3.Map');
-goog.require('ol3.MapRenderer');
 goog.require('ol3.TileLayer');
-goog.require('ol3.dom.TileLayerRenderer');
+goog.require('ol3.renderer.Map');
+goog.require('ol3.renderer.dom.TileLayer');
 
 
 
 /**
  * @constructor
- * @extends {ol3.MapRenderer}
+ * @extends {ol3.renderer.Map}
  * @param {Element} container Container.
  * @param {ol3.Map} map Map.
  */
-ol3.dom.MapRenderer = function(container, map) {
+ol3.renderer.dom.Map = function(container, map) {
 
   goog.base(this, container, map);
 
@@ -51,13 +51,13 @@ ol3.dom.MapRenderer = function(container, map) {
    */
   this.layersPaneOffset_ = null;
 };
-goog.inherits(ol3.dom.MapRenderer, ol3.MapRenderer);
+goog.inherits(ol3.renderer.dom.Map, ol3.renderer.Map);
 
 
 /**
  * @inheritDoc
  */
-ol3.dom.MapRenderer.prototype.createLayerRenderer = function(layer) {
+ol3.renderer.dom.Map.prototype.createLayerRenderer = function(layer) {
 
   if (layer instanceof ol3.TileLayer) {
 
@@ -66,7 +66,7 @@ ol3.dom.MapRenderer.prototype.createLayerRenderer = function(layer) {
     layerPane.style.position = 'absolute';
     goog.dom.appendChild(this.layersPane_, layerPane);
 
-    var layerRenderer = new ol3.dom.TileLayerRenderer(this, layer, layerPane);
+    var layerRenderer = new ol3.renderer.dom.TileLayer(this, layer, layerPane);
 
     this.layerPanes_[goog.getUid(layerRenderer)] = layerPane;
 
@@ -82,7 +82,7 @@ ol3.dom.MapRenderer.prototype.createLayerRenderer = function(layer) {
 /**
  * @inheritDoc
  */
-ol3.dom.MapRenderer.prototype.handleCenterChanged = function() {
+ol3.renderer.dom.Map.prototype.handleCenterChanged = function() {
   goog.base(this, 'handleCenterChanged');
   var map = this.getMap();
   if (!map.isDef()) {
@@ -102,7 +102,7 @@ ol3.dom.MapRenderer.prototype.handleCenterChanged = function() {
 /**
  * @inheritDoc
  */
-ol3.dom.MapRenderer.prototype.handleResolutionChanged = function() {
+ol3.renderer.dom.Map.prototype.handleResolutionChanged = function() {
   goog.base(this, 'handleResolutionChanged');
   var map = this.getMap();
   if (!map.isDef()) {
@@ -119,7 +119,7 @@ ol3.dom.MapRenderer.prototype.handleResolutionChanged = function() {
  * Reset the layers pane to its initial position.
  * @private
  */
-ol3.dom.MapRenderer.prototype.resetLayersPane_ = function() {
+ol3.renderer.dom.Map.prototype.resetLayersPane_ = function() {
   var offset = new ol3.Coordinate(0, 0);
   goog.style.setPosition(this.layersPane_, offset);
 
@@ -134,7 +134,7 @@ ol3.dom.MapRenderer.prototype.resetLayersPane_ = function() {
  * Set the origin for each layer renderer.
  * @private
  */
-ol3.dom.MapRenderer.prototype.setOrigin_ = function() {
+ol3.renderer.dom.Map.prototype.setOrigin_ = function() {
   var center = this.map.getCenter();
   var resolution = this.map.getResolution();
   var targetSize = this.map.getSize();
@@ -153,7 +153,7 @@ ol3.dom.MapRenderer.prototype.setOrigin_ = function() {
  * Move the layers pane.
  * @private
  */
-ol3.dom.MapRenderer.prototype.shiftLayersPane_ = function() {
+ol3.renderer.dom.Map.prototype.shiftLayersPane_ = function() {
   var center = this.map.getCenter();
   var oldCenter = this.renderedCenter_;
   var resolution = this.map.getResolution();

src/ol3/renderer/dom/tilelayer.js

@@ -1,20 +1,20 @@
-goog.provide('ol3.dom.TileLayerRenderer');
+goog.provide('ol3.renderer.dom.TileLayer');
 
 goog.require('goog.dom');
 goog.require('ol3.Coordinate');
 goog.require('ol3.Extent');
-goog.require('ol3.dom.LayerRenderer');
+goog.require('ol3.renderer.dom.Layer');
 
 
 
 /**
  * @constructor
- * @extends {ol3.dom.LayerRenderer}
+ * @extends {ol3.renderer.dom.Layer}
- * @param {ol3.MapRenderer} mapRenderer Map renderer.
+ * @param {ol3.renderer.Map} mapRenderer Map renderer.
  * @param {ol3.TileLayer} tileLayer Tile layer.
  * @param {!Element} target Target.
  */
-ol3.dom.TileLayerRenderer = function(mapRenderer, tileLayer, target) {
+ol3.renderer.dom.TileLayer = function(mapRenderer, tileLayer, target) {
   goog.base(this, mapRenderer, tileLayer, target);
 
   /**
@@ -29,14 +29,14 @@ ol3.dom.TileLayerRenderer = function(mapRenderer, tileLayer, target) {
    */
   this.renderedMapResolution_ = undefined;
 };
-goog.inherits(ol3.dom.TileLayerRenderer, ol3.dom.LayerRenderer);
+goog.inherits(ol3.renderer.dom.TileLayer, ol3.renderer.dom.Layer);
 
 
 /**
  * @override
  * @return {ol3.TileLayer} Layer.
  */
-ol3.dom.TileLayerRenderer.prototype.getLayer = function() {
+ol3.renderer.dom.TileLayer.prototype.getLayer = function() {
   return /** @type {ol3.TileLayer} */ goog.base(this, 'getLayer');
 };
 
@@ -48,7 +48,7 @@ ol3.dom.TileLayerRenderer.prototype.getLayer = function() {
  * @param {number} resolution Resolution.
  * @return {ol3.Coordinate} Offset.
  */
-ol3.dom.TileLayerRenderer.prototype.getTileOffset_ = function(z, resolution) {
+ol3.renderer.dom.TileLayer.prototype.getTileOffset_ = function(z, resolution) {
   var tileLayer = this.getLayer();
   var tileStore = tileLayer.getStore();
   var tileGrid = tileStore.getTileGrid();
@@ -66,7 +66,7 @@ ol3.dom.TileLayerRenderer.prototype.getTileOffset_ = function(z, resolution) {
  * @param {ol3.TileBounds} tileBounds Tile bounds.
  * @param {number} z Z.
  */
-ol3.dom.TileLayerRenderer.prototype.removeInvisibleTiles_ = function(
+ol3.renderer.dom.TileLayer.prototype.removeInvisibleTiles_ = function(
     tileBounds, z) {
   var key, tileCoord, prune, tile;
   for (key in this.renderedTiles_) {
@@ -88,7 +88,7 @@ ol3.dom.TileLayerRenderer.prototype.removeInvisibleTiles_ = function(
 /**
  * @inheritDoc
  */
-ol3.dom.TileLayerRenderer.prototype.render = function() {
+ol3.renderer.dom.TileLayer.prototype.render = function() {
 
   var map = this.getMap();
   if (!map.isDef()) {

src/ol3/renderer/layer.js

@@ -1,4 +1,4 @@
-goog.provide('ol3.LayerRenderer');
+goog.provide('ol3.renderer.Layer');
 
 goog.require('goog.events');
 goog.require('goog.events.EventType');
@@ -11,16 +11,16 @@ goog.require('ol3.Object');
 /**
  * @constructor
  * @extends {ol3.Object}
- * @param {ol3.MapRenderer} mapRenderer Map renderer.
+ * @param {ol3.renderer.Map} mapRenderer Map renderer.
  * @param {ol3.Layer} layer Layer.
  */
-ol3.LayerRenderer = function(mapRenderer, layer) {
+ol3.renderer.Layer = function(mapRenderer, layer) {
 
   goog.base(this);
 
   /**
    * @private
-   * @type {ol3.MapRenderer}
+   * @type {ol3.renderer.Map}
    */
   this.mapRenderer_ = mapRenderer;
 
@@ -58,13 +58,13 @@ ol3.LayerRenderer = function(mapRenderer, layer) {
       this.handleLayerVisibleChange, false, this);
 
 };
-goog.inherits(ol3.LayerRenderer, ol3.Object);
+goog.inherits(ol3.renderer.Layer, ol3.Object);
 
 
 /**
  * @return {ol3.Layer} Layer.
  */
-ol3.LayerRenderer.prototype.getLayer = function() {
+ol3.renderer.Layer.prototype.getLayer = function() {
   return this.layer_;
 };
 
@@ -72,15 +72,15 @@ ol3.LayerRenderer.prototype.getLayer = function() {
 /**
  * @return {ol3.Map} Map.
  */
-ol3.LayerRenderer.prototype.getMap = function() {
+ol3.renderer.Layer.prototype.getMap = function() {
   return this.mapRenderer_.getMap();
 };
 
 
 /**
- * @return {ol3.MapRenderer} Map renderer.
+ * @return {ol3.renderer.Map} Map renderer.
  */
-ol3.LayerRenderer.prototype.getMapRenderer = function() {
+ol3.renderer.Layer.prototype.getMapRenderer = function() {
   return this.mapRenderer_;
 };
 
@@ -88,40 +88,40 @@ ol3.LayerRenderer.prototype.getMapRenderer = function() {
 /**
  * @protected
  */
-ol3.LayerRenderer.prototype.handleLayerBrightnessChange = goog.nullFunction;
+ol3.renderer.Layer.prototype.handleLayerBrightnessChange = goog.nullFunction;
 
 
 /**
  * @protected
  */
-ol3.LayerRenderer.prototype.handleLayerContrastChange = goog.nullFunction;
+ol3.renderer.Layer.prototype.handleLayerContrastChange = goog.nullFunction;
 
 
 /**
  * @protected
  */
-ol3.LayerRenderer.prototype.handleLayerHueChange = goog.nullFunction;
+ol3.renderer.Layer.prototype.handleLayerHueChange = goog.nullFunction;
 
 
 /**
  * @protected
  */
-ol3.LayerRenderer.prototype.handleLayerLoad = goog.nullFunction;
+ol3.renderer.Layer.prototype.handleLayerLoad = goog.nullFunction;
 
 
 /**
  * @protected
  */
-ol3.LayerRenderer.prototype.handleLayerOpacityChange = goog.nullFunction;
+ol3.renderer.Layer.prototype.handleLayerOpacityChange = goog.nullFunction;
 
 
 /**
  * @protected
  */
-ol3.LayerRenderer.prototype.handleLayerSaturationChange = goog.nullFunction;
+ol3.renderer.Layer.prototype.handleLayerSaturationChange = goog.nullFunction;
 
 
 /**
  * @protected
  */
-ol3.LayerRenderer.prototype.handleLayerVisibleChange = goog.nullFunction;
+ol3.renderer.Layer.prototype.handleLayerVisibleChange = goog.nullFunction;

src/ol3/renderer/map.js

@@ -1,4 +1,4 @@
-goog.provide('ol3.MapRenderer');
+goog.provide('ol3.renderer.Map');
 
 goog.require('goog.Disposable');
 goog.require('goog.events');
@@ -16,7 +16,7 @@ goog.require('ol3.MapProperty');
  * @param {Element} container Container.
  * @param {ol3.Map} map Map.
  */
-ol3.MapRenderer = function(container, map) {
+ol3.renderer.Map = function(container, map) {
 
   goog.base(this);
 
@@ -34,7 +34,7 @@ ol3.MapRenderer = function(container, map) {
 
   /**
    * @protected
-   * @type {Object.<number, ol3.LayerRenderer>}
+   * @type {Object.<number, ol3.renderer.Layer>}
    */
   this.layerRenderers = {};
 
@@ -93,14 +93,14 @@ ol3.MapRenderer = function(container, map) {
   ];
 
 };
-goog.inherits(ol3.MapRenderer, goog.Disposable);
+goog.inherits(ol3.renderer.Map, goog.Disposable);
 
 
 /**
  * @param {ol3.Layer} layer Layer.
  * @protected
  */
-ol3.MapRenderer.prototype.addLayer = function(layer) {
+ol3.renderer.Map.prototype.addLayer = function(layer) {
   var layerRenderer = this.createLayerRenderer(layer);
   this.setLayerRenderer(layer, layerRenderer);
 };
@@ -109,21 +109,21 @@ ol3.MapRenderer.prototype.addLayer = function(layer) {
 /**
  * @return {boolean} Can rotate.
  */
-ol3.MapRenderer.prototype.canRotate = goog.functions.FALSE;
+ol3.renderer.Map.prototype.canRotate = goog.functions.FALSE;
 
 
 /**
  * @param {ol3.Layer} layer Layer.
  * @protected
- * @return {ol3.LayerRenderer} layerRenderer Layer renderer.
+ * @return {ol3.renderer.Layer} layerRenderer Layer renderer.
  */
-ol3.MapRenderer.prototype.createLayerRenderer = goog.abstractMethod;
+ol3.renderer.Map.prototype.createLayerRenderer = goog.abstractMethod;
 
 
 /**
  * @inheritDoc
  */
-ol3.MapRenderer.prototype.disposeInternal = function() {
+ol3.renderer.Map.prototype.disposeInternal = function() {
   goog.object.forEach(this.layerRenderers, function(layerRenderer) {
     goog.dispose(layerRenderer);
   });
@@ -136,11 +136,11 @@ ol3.MapRenderer.prototype.disposeInternal = function() {
 
 
 /**
- * @param {function(this: T, ol3.Layer, ol3.LayerRenderer, number)} f Function.
+ * @param {function(this: T, ol3.Layer, ol3.renderer.Layer, number)} f Function.
  * @param {T=} opt_obj Object.
  * @template T
  */
-ol3.MapRenderer.prototype.forEachReadyVisibleLayer = function(f, opt_obj) {
+ol3.renderer.Map.prototype.forEachReadyVisibleLayer = function(f, opt_obj) {
   var layers = this.map.getLayers();
   layers.forEach(function(layer, index) {
     if (layer.isReady() && layer.getVisible()) {
@@ -155,7 +155,7 @@ ol3.MapRenderer.prototype.forEachReadyVisibleLayer = function(f, opt_obj) {
  * @param {ol3.Pixel} pixel Pixel.
  * @return {ol3.Coordinate} Coordinate.
  */
-ol3.MapRenderer.prototype.getCoordinateFromPixel = function(pixel) {
+ol3.renderer.Map.prototype.getCoordinateFromPixel = function(pixel) {
   this.updateMatrices_();
   var vec3 = [pixel.x, pixel.y, 0];
   goog.vec.Mat4.multVec3(this.pixelToCoordinateMatrix_, vec3, vec3);
@@ -166,9 +166,9 @@ ol3.MapRenderer.prototype.getCoordinateFromPixel = function(pixel) {
 /**
  * @param {ol3.Layer} layer Layer.
  * @protected
- * @return {ol3.LayerRenderer} Layer renderer.
+ * @return {ol3.renderer.Layer} Layer renderer.
  */
-ol3.MapRenderer.prototype.getLayerRenderer = function(layer) {
+ol3.renderer.Map.prototype.getLayerRenderer = function(layer) {
   var key = goog.getUid(layer);
   var layerRenderer = this.layerRenderers[key];
   goog.asserts.assert(goog.isDef(layerRenderer));
@@ -179,7 +179,7 @@ ol3.MapRenderer.prototype.getLayerRenderer = function(layer) {
 /**
  * @return {ol3.Map} Map.
  */
-ol3.MapRenderer.prototype.getMap = function() {
+ol3.renderer.Map.prototype.getMap = function() {
   return this.map;
 };
 
@@ -188,7 +188,7 @@ ol3.MapRenderer.prototype.getMap = function() {
  * @param {ol3.Coordinate} coordinate Coordinate.
  * @return {ol3.Pixel} Pixel.
  */
-ol3.MapRenderer.prototype.getPixelFromCoordinate = function(coordinate) {
+ol3.renderer.Map.prototype.getPixelFromCoordinate = function(coordinate) {
   this.updateMatrices_();
   var vec3 = [coordinate.x, coordinate.y, 0];
   goog.vec.Mat4.multVec3(this.coordinateToPixelMatrix_, vec3, vec3);
@@ -198,13 +198,13 @@ ol3.MapRenderer.prototype.getPixelFromCoordinate = function(coordinate) {
 
 /**
  */
-ol3.MapRenderer.prototype.handleBackgroundColorChanged = goog.nullFunction;
+ol3.renderer.Map.prototype.handleBackgroundColorChanged = goog.nullFunction;
 
 
 /**
  * @protected
  */
-ol3.MapRenderer.prototype.handleCenterChanged = function() {
+ol3.renderer.Map.prototype.handleCenterChanged = function() {
   this.matricesDirty_ = true;
 };
 
@@ -213,7 +213,7 @@ ol3.MapRenderer.prototype.handleCenterChanged = function() {
  * @param {ol3.CollectionEvent} collectionEvent Collection event.
  * @protected
  */
-ol3.MapRenderer.prototype.handleLayersAdd = function(collectionEvent) {
+ol3.renderer.Map.prototype.handleLayersAdd = function(collectionEvent) {
   var layer = /** @type {ol3.Layer} */ collectionEvent.elem;
   this.addLayer(layer);
 };
@@ -222,7 +222,7 @@ ol3.MapRenderer.prototype.handleLayersAdd = function(collectionEvent) {
 /**
  * @protected
  */
-ol3.MapRenderer.prototype.handleLayersChanged = function() {
+ol3.renderer.Map.prototype.handleLayersChanged = function() {
   var layerRenderers = goog.object.getValues(this.layerRenderers);
   goog.array.forEach(layerRenderers, function(layerRenderer) {
     this.removeLayerRenderer(layerRenderer);
@@ -249,7 +249,7 @@ ol3.MapRenderer.prototype.handleLayersChanged = function() {
  * @param {ol3.CollectionEvent} collectionEvent Collection event.
  * @protected
  */
-ol3.MapRenderer.prototype.handleLayersRemove = function(collectionEvent) {
+ol3.renderer.Map.prototype.handleLayersRemove = function(collectionEvent) {
   var layer = /** @type {ol3.Layer} */ collectionEvent.elem;
   this.removeLayer(layer);
 };
@@ -258,7 +258,7 @@ ol3.MapRenderer.prototype.handleLayersRemove = function(collectionEvent) {
 /**
  * @protected
  */
-ol3.MapRenderer.prototype.handleResolutionChanged = function() {
+ol3.renderer.Map.prototype.handleResolutionChanged = function() {
   this.matricesDirty_ = true;
 };
 
@@ -266,7 +266,7 @@ ol3.MapRenderer.prototype.handleResolutionChanged = function() {
 /**
  * @protected
  */
-ol3.MapRenderer.prototype.handleRotationChanged = function() {
+ol3.renderer.Map.prototype.handleRotationChanged = function() {
   this.matricesDirty_ = true;
 };
 
@@ -274,7 +274,7 @@ ol3.MapRenderer.prototype.handleRotationChanged = function() {
 /**
  * @protected
  */
-ol3.MapRenderer.prototype.handleSizeChanged = function() {
+ol3.renderer.Map.prototype.handleSizeChanged = function() {
   this.matricesDirty_ = true;
 };
 
@@ -283,17 +283,17 @@ ol3.MapRenderer.prototype.handleSizeChanged = function() {
  * @param {ol3.Layer} layer Layer.
  * @protected
  */
-ol3.MapRenderer.prototype.removeLayer = function(layer) {
+ol3.renderer.Map.prototype.removeLayer = function(layer) {
   goog.dispose(this.removeLayerRenderer(layer));
 };
 
 
 /**
  * @param {ol3.Layer} layer Layer.
- * @return {ol3.LayerRenderer} Layer renderer.
+ * @return {ol3.renderer.Layer} Layer renderer.
  * @protected
  */
-ol3.MapRenderer.prototype.removeLayerRenderer = function(layer) {
+ol3.renderer.Map.prototype.removeLayerRenderer = function(layer) {
   var key = goog.getUid(layer);
   if (key in this.layerRenderers) {
     var layerRenderer = this.layerRenderers[key];
@@ -308,7 +308,7 @@ ol3.MapRenderer.prototype.removeLayerRenderer = function(layer) {
 /**
  * @return {boolean} Animating.
  */
-ol3.MapRenderer.prototype.render = function() {
+ol3.renderer.Map.prototype.render = function() {
   var animate = false;
   this.forEachReadyVisibleLayer(function(layer, layerRenderer) {
     if (layerRenderer.render()) {
@@ -321,10 +321,10 @@ ol3.MapRenderer.prototype.render = function() {
 
 /**
  * @param {ol3.Layer} layer Layer.
- * @param {ol3.LayerRenderer} layerRenderer Layer renderer.
+ * @param {ol3.renderer.Layer} layerRenderer Layer renderer.
  * @protected
  */
-ol3.MapRenderer.prototype.setLayerRenderer = function(layer, layerRenderer) {
+ol3.renderer.Map.prototype.setLayerRenderer = function(layer, layerRenderer) {
   var key = goog.getUid(layer);
   goog.asserts.assert(!(key in this.layerRenderers));
   this.layerRenderers[key] = layerRenderer;
@@ -334,7 +334,7 @@ ol3.MapRenderer.prototype.setLayerRenderer = function(layer, layerRenderer) {
 /**
  * @private
  */
-ol3.MapRenderer.prototype.updateMatrices_ = function() {
+ol3.renderer.Map.prototype.updateMatrices_ = function() {
 
   if (this.matricesDirty_) {
 

src/ol3/renderer/webgl/layer.js

@@ -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;

src/ol3/renderer/webgl/map.js

@@ -4,8 +4,8 @@
 // FIXME defer cleanup until post-render
 // FIXME check against gl.getParameter(webgl.MAX_TEXTURE_SIZE)
 
-goog.provide('ol3.webgl.MapRenderer');
+goog.provide('ol3.renderer.webgl.Map');
-goog.provide('ol3.webgl.map.shader');
+goog.provide('ol3.renderer.webgl.map.shader');
 
 goog.require('goog.debug.Logger');
 goog.require('goog.dispose');
@@ -20,26 +20,26 @@ goog.require('goog.webgl');
 goog.require('ol3.Layer');
 goog.require('ol3.Map');
 goog.require('ol3.TileLayer');
-goog.require('ol3.webgl.TileLayerRenderer');
+goog.require('ol3.renderer.webgl.FragmentShader');
+goog.require('ol3.renderer.webgl.TileLayer');
+goog.require('ol3.renderer.webgl.VertexShader');
 goog.require('ol3.webgl.WebGLContextEventType');
-goog.require('ol3.webgl.shader.Fragment');
-goog.require('ol3.webgl.shader.Vertex');
 
 
 /**
  * @typedef {{magFilter: number, minFilter: number, texture: WebGLTexture}}
  */
-ol3.webgl.TextureCacheEntry;
+ol3.renderer.webgl.TextureCacheEntry;
 
 
 
 /**
  * @constructor
- * @extends {ol3.webgl.shader.Fragment}
+ * @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.webgl.map.shader.Fragment = function() {
+ol3.renderer.webgl.map.shader.Fragment = function() {
   goog.base(this, [
     'precision mediump float;',
     '',
@@ -97,16 +97,17 @@ ol3.webgl.map.shader.Fragment = function() {
     '}'
   ].join('\n'));
 };
-goog.inherits(ol3.webgl.map.shader.Fragment, ol3.webgl.shader.Fragment);
+goog.inherits(
-goog.addSingletonGetter(ol3.webgl.map.shader.Fragment);
+    ol3.renderer.webgl.map.shader.Fragment, ol3.renderer.webgl.FragmentShader);
+goog.addSingletonGetter(ol3.renderer.webgl.map.shader.Fragment);
 
 
 
 /**
  * @constructor
- * @extends {ol3.webgl.shader.Vertex}
+ * @extends {ol3.renderer.webgl.VertexShader}
  */
-ol3.webgl.map.shader.Vertex = function() {
+ol3.renderer.webgl.map.shader.Vertex = function() {
   goog.base(this, [
     'attribute vec2 aPosition;',
     'attribute vec2 aTexCoord;',
@@ -119,18 +120,19 @@ ol3.webgl.map.shader.Vertex = function() {
     '}'
   ].join('\n'));
 };
-goog.inherits(ol3.webgl.map.shader.Vertex, ol3.webgl.shader.Vertex);
+goog.inherits(
-goog.addSingletonGetter(ol3.webgl.map.shader.Vertex);
+    ol3.renderer.webgl.map.shader.Vertex, ol3.renderer.webgl.VertexShader);
+goog.addSingletonGetter(ol3.renderer.webgl.map.shader.Vertex);
 
 
 
 /**
  * @constructor
- * @extends {ol3.MapRenderer}
+ * @extends {ol3.renderer.Map}
  * @param {Element} container Container.
  * @param {ol3.Map} map Map.
  */
-ol3.webgl.MapRenderer = function(container, map) {
+ol3.renderer.webgl.Map = function(container, map) {
 
   goog.base(this, container, map);
 
@@ -139,7 +141,7 @@ ol3.webgl.MapRenderer = function(container, map) {
      * @inheritDoc
      */
     this.logger = goog.debug.Logger.getLogger(
-        'ol3.webgl.maprenderer.' + goog.getUid(this));
+        'ol3.renderer.webgl.maprenderer.' + goog.getUid(this));
   }
 
   /**
@@ -209,21 +211,21 @@ ol3.webgl.MapRenderer = function(container, map) {
 
   /**
    * @private
-   * @type {Object.<string, ol3.webgl.TextureCacheEntry>}
+   * @type {Object.<string, ol3.renderer.webgl.TextureCacheEntry>}
    */
   this.textureCache_ = {};
 
   /**
    * @private
-   * @type {ol3.webgl.shader.Fragment}
+   * @type {ol3.renderer.webgl.FragmentShader}
    */
-  this.fragmentShader_ = ol3.webgl.map.shader.Fragment.getInstance();
+  this.fragmentShader_ = ol3.renderer.webgl.map.shader.Fragment.getInstance();
 
   /**
    * @private
-   * @type {ol3.webgl.shader.Vertex}
+   * @type {ol3.renderer.webgl.VertexShader}
    */
-  this.vertexShader_ = ol3.webgl.map.shader.Vertex.getInstance();
+  this.vertexShader_ = ol3.renderer.webgl.map.shader.Vertex.getInstance();
 
   /**
    * @private
@@ -234,13 +236,13 @@ ol3.webgl.MapRenderer = function(container, map) {
   this.initializeGL_();
 
 };
-goog.inherits(ol3.webgl.MapRenderer, ol3.MapRenderer);
+goog.inherits(ol3.renderer.webgl.Map, ol3.renderer.Map);
 
 
 /**
  * @inheritDoc
  */
-ol3.webgl.MapRenderer.prototype.addLayer = function(layer) {
+ol3.renderer.webgl.Map.prototype.addLayer = function(layer) {
   goog.base(this, 'addLayer', layer);
   if (layer.getVisible()) {
     this.getMap().render();
@@ -253,7 +255,7 @@ ol3.webgl.MapRenderer.prototype.addLayer = function(layer) {
  * @param {number} magFilter Mag filter.
  * @param {number} minFilter Min filter.
  */
-ol3.webgl.MapRenderer.prototype.bindImageTexture =
+ol3.renderer.webgl.Map.prototype.bindImageTexture =
     function(image, magFilter, minFilter) {
   var gl = this.getGL();
   var imageKey = image.src;
@@ -295,16 +297,16 @@ ol3.webgl.MapRenderer.prototype.bindImageTexture =
 /**
  * @inheritDoc
  */
-ol3.webgl.MapRenderer.prototype.canRotate = goog.functions.TRUE;
+ol3.renderer.webgl.Map.prototype.canRotate = goog.functions.TRUE;
 
 
 /**
  * @inheritDoc
  */
-ol3.webgl.MapRenderer.prototype.createLayerRenderer = function(layer) {
+ol3.renderer.webgl.Map.prototype.createLayerRenderer = function(layer) {
   var gl = this.getGL();
   if (layer instanceof ol3.TileLayer) {
-    return new ol3.webgl.TileLayerRenderer(this, layer);
+    return new ol3.renderer.webgl.TileLayer(this, layer);
   } else {
     goog.asserts.assert(false);
     return null;
@@ -315,7 +317,7 @@ ol3.webgl.MapRenderer.prototype.createLayerRenderer = function(layer) {
 /**
  * @inheritDoc
  */
-ol3.webgl.MapRenderer.prototype.disposeInternal = function() {
+ol3.renderer.webgl.Map.prototype.disposeInternal = function() {
   var gl = this.getGL();
   if (!gl.isContextLost()) {
     goog.object.forEach(this.programCache_, function(program) {
@@ -335,17 +337,18 @@ ol3.webgl.MapRenderer.prototype.disposeInternal = function() {
 /**
  * @return {WebGLRenderingContext} GL.
  */
-ol3.webgl.MapRenderer.prototype.getGL = function() {
+ol3.renderer.webgl.Map.prototype.getGL = function() {
   return this.gl_;
 };
 
 
 /**
- * @param {ol3.webgl.shader.Fragment} fragmentShaderObject Fragment shader.
+ * @param {ol3.renderer.webgl.FragmentShader} fragmentShaderObject
- * @param {ol3.webgl.shader.Vertex} vertexShaderObject Vertex shader.
+ *     Fragment shader.
+ * @param {ol3.renderer.webgl.VertexShader} vertexShaderObject Vertex shader.
  * @return {WebGLProgram} Program.
  */
-ol3.webgl.MapRenderer.prototype.getProgram = function(
+ol3.renderer.webgl.Map.prototype.getProgram = function(
     fragmentShaderObject, vertexShaderObject) {
   var programKey =
       goog.getUid(fragmentShaderObject) + '/' + goog.getUid(vertexShaderObject);
@@ -372,10 +375,10 @@ ol3.webgl.MapRenderer.prototype.getProgram = function(
 
 
 /**
- * @param {ol3.webgl.Shader} shaderObject Shader object.
+ * @param {ol3.renderer.webgl.Shader} shaderObject Shader object.
  * @return {WebGLShader} Shader.
  */
-ol3.webgl.MapRenderer.prototype.getShader = function(shaderObject) {
+ol3.renderer.webgl.Map.prototype.getShader = function(shaderObject) {
   var shaderKey = goog.getUid(shaderObject);
   if (shaderKey in this.shaderCache_) {
     return this.shaderCache_[shaderKey];
@@ -401,7 +404,7 @@ ol3.webgl.MapRenderer.prototype.getShader = function(shaderObject) {
 /**
  * @inheritDoc
  */
-ol3.webgl.MapRenderer.prototype.handleBackgroundColorChanged = function() {
+ol3.renderer.webgl.Map.prototype.handleBackgroundColorChanged = function() {
   var backgroundColor = this.getMap().getBackgroundColor();
   this.clearColor_ = new ol3.Color(
       backgroundColor.r / 255,
@@ -415,7 +418,7 @@ ol3.webgl.MapRenderer.prototype.handleBackgroundColorChanged = function() {
 /**
  * @inheritDoc
  */
-ol3.webgl.MapRenderer.prototype.handleCenterChanged = function() {
+ol3.renderer.webgl.Map.prototype.handleCenterChanged = function() {
   goog.base(this, 'handleCenterChanged');
   this.getMap().render();
 };
@@ -425,7 +428,7 @@ ol3.webgl.MapRenderer.prototype.handleCenterChanged = function() {
  * @param {goog.events.Event} event Event.
  * @protected
  */
-ol3.webgl.MapRenderer.prototype.handleLayerRendererChange = function(event) {
+ol3.renderer.webgl.Map.prototype.handleLayerRendererChange = function(event) {
   this.getMap().render();
 };
 
@@ -433,7 +436,7 @@ ol3.webgl.MapRenderer.prototype.handleLayerRendererChange = function(event) {
 /**
  * @inheritDoc
  */
-ol3.webgl.MapRenderer.prototype.handleResolutionChanged = function() {
+ol3.renderer.webgl.Map.prototype.handleResolutionChanged = function() {
   goog.base(this, 'handleResolutionChanged');
   this.getMap().render();
 };
@@ -442,7 +445,7 @@ ol3.webgl.MapRenderer.prototype.handleResolutionChanged = function() {
 /**
  * @inheritDoc
  */
-ol3.webgl.MapRenderer.prototype.handleRotationChanged = function() {
+ol3.renderer.webgl.Map.prototype.handleRotationChanged = function() {
   goog.base(this, 'handleRotationChanged');
   this.getMap().render();
 };
@@ -451,7 +454,7 @@ ol3.webgl.MapRenderer.prototype.handleRotationChanged = function() {
 /**
  * @inheritDoc
  */
-ol3.webgl.MapRenderer.prototype.handleSizeChanged = function() {
+ol3.renderer.webgl.Map.prototype.handleSizeChanged = function() {
   goog.base(this, 'handleSizeChanged');
   var size = this.getMap().getSize();
   if (!goog.isDef(size)) {
@@ -471,7 +474,7 @@ ol3.webgl.MapRenderer.prototype.handleSizeChanged = function() {
  * @param {goog.events.Event} event Event.
  * @protected
  */
-ol3.webgl.MapRenderer.prototype.handleWebGLContextLost = function(event) {
+ol3.renderer.webgl.Map.prototype.handleWebGLContextLost = function(event) {
   if (goog.DEBUG) {
     this.logger.info('WebGLContextLost');
   }
@@ -490,7 +493,7 @@ ol3.webgl.MapRenderer.prototype.handleWebGLContextLost = function(event) {
 /**
  * @protected
  */
-ol3.webgl.MapRenderer.prototype.handleWebGLContextRestored = function() {
+ol3.renderer.webgl.Map.prototype.handleWebGLContextRestored = function() {
   if (goog.DEBUG) {
     this.logger.info('WebGLContextRestored');
   }
@@ -502,7 +505,7 @@ ol3.webgl.MapRenderer.prototype.handleWebGLContextRestored = function() {
 /**
  * @private
  */
-ol3.webgl.MapRenderer.prototype.initializeGL_ = function() {
+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);
@@ -516,7 +519,7 @@ ol3.webgl.MapRenderer.prototype.initializeGL_ = function() {
  * @param {Image} image Image.
  * @return {boolean} Is image texture loaded.
  */
-ol3.webgl.MapRenderer.prototype.isImageTextureLoaded = function(image) {
+ol3.renderer.webgl.Map.prototype.isImageTextureLoaded = function(image) {
   return image.src in this.textureCache_;
 };
 
@@ -524,7 +527,7 @@ ol3.webgl.MapRenderer.prototype.isImageTextureLoaded = function(image) {
 /**
  * @inheritDoc
  */
-ol3.webgl.MapRenderer.prototype.removeLayer = function(layer) {
+ol3.renderer.webgl.Map.prototype.removeLayer = function(layer) {
   goog.base(this, 'removeLayer', layer);
   if (layer.getVisible()) {
     this.getMap().render();
@@ -535,7 +538,7 @@ ol3.webgl.MapRenderer.prototype.removeLayer = function(layer) {
 /**
  * @inheritDoc
  */
-ol3.webgl.MapRenderer.prototype.removeLayerRenderer = function(layer) {
+ol3.renderer.webgl.Map.prototype.removeLayerRenderer = function(layer) {
   var layerRenderer = goog.base(this, 'removeLayerRenderer', layer);
   if (!goog.isNull(layerRenderer)) {
     var layerKey = goog.getUid(layer);
@@ -549,7 +552,7 @@ ol3.webgl.MapRenderer.prototype.removeLayerRenderer = function(layer) {
 /**
  * @inheritDoc
  */
-ol3.webgl.MapRenderer.prototype.render = function() {
+ol3.renderer.webgl.Map.prototype.render = function() {
 
   if (!this.getMap().isDef()) {
     return false;
@@ -627,7 +630,7 @@ ol3.webgl.MapRenderer.prototype.render = function() {
 /**
  * @inheritDoc
  */
-ol3.webgl.MapRenderer.prototype.setLayerRenderer = function(
+ol3.renderer.webgl.Map.prototype.setLayerRenderer = function(
     layer, layerRenderer) {
   goog.base(this, 'setLayerRenderer', layer, layerRenderer);
   var layerKey = goog.getUid(layer);

src/ol3/renderer/webgl/shader.js

@@ -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;
+};

src/ol3/renderer/webgl/tilelayer.js

@@ -1,10 +1,10 @@
 // FIXME large resolutions lead to too large framebuffers :-(
 // FIXME animated shaders! check in redraw
 
-goog.provide('ol3.webgl.TileLayerRenderer');
+goog.provide('ol3.renderer.webgl.TileLayer');
-goog.provide('ol3.webgl.tilelayerrenderer');
+goog.provide('ol3.renderer.webgl.tilelayerrenderer');
-goog.provide('ol3.webgl.tilelayerrenderer.shader.Fragment');
+goog.provide('ol3.renderer.webgl.tilelayerrenderer.shader.Fragment');
-goog.provide('ol3.webgl.tilelayerrenderer.shader.Vertex');
+goog.provide('ol3.renderer.webgl.tilelayerrenderer.shader.Vertex');
 
 goog.require('goog.array');
 goog.require('goog.asserts');
@@ -19,17 +19,17 @@ goog.require('ol3.MapEventType');
 goog.require('ol3.Size');
 goog.require('ol3.TileLayer');
 goog.require('ol3.TileState');
-goog.require('ol3.webgl.LayerRenderer');
+goog.require('ol3.renderer.webgl.FragmentShader');
-goog.require('ol3.webgl.shader.Fragment');
+goog.require('ol3.renderer.webgl.Layer');
-goog.require('ol3.webgl.shader.Vertex');
+goog.require('ol3.renderer.webgl.VertexShader');
 
 
 
 /**
  * @constructor
- * @extends {ol3.webgl.shader.Fragment}
+ * @extends {ol3.renderer.webgl.FragmentShader}
  */
-ol3.webgl.tilelayerrenderer.shader.Fragment = function() {
+ol3.renderer.webgl.tilelayerrenderer.shader.Fragment = function() {
   goog.base(this, [
     'precision mediump float;',
     '',
@@ -43,16 +43,17 @@ ol3.webgl.tilelayerrenderer.shader.Fragment = function() {
   ].join('\n'));
 };
 goog.inherits(
-    ol3.webgl.tilelayerrenderer.shader.Fragment, ol3.webgl.shader.Fragment);
+    ol3.renderer.webgl.tilelayerrenderer.shader.Fragment,
-goog.addSingletonGetter(ol3.webgl.tilelayerrenderer.shader.Fragment);
+    ol3.renderer.webgl.FragmentShader);
+goog.addSingletonGetter(ol3.renderer.webgl.tilelayerrenderer.shader.Fragment);
 
 
 
 /**
  * @constructor
- * @extends {ol3.webgl.shader.Vertex}
+ * @extends {ol3.renderer.webgl.VertexShader}
  */
-ol3.webgl.tilelayerrenderer.shader.Vertex = function() {
+ol3.renderer.webgl.tilelayerrenderer.shader.Vertex = function() {
   goog.base(this, [
     'attribute vec2 aPosition;',
     'attribute vec2 aTexCoord;',
@@ -70,18 +71,19 @@ ol3.webgl.tilelayerrenderer.shader.Vertex = function() {
   ].join('\n'));
 };
 goog.inherits(
-    ol3.webgl.tilelayerrenderer.shader.Vertex, ol3.webgl.shader.Vertex);
+    ol3.renderer.webgl.tilelayerrenderer.shader.Vertex,
-goog.addSingletonGetter(ol3.webgl.tilelayerrenderer.shader.Vertex);
+    ol3.renderer.webgl.VertexShader);
+goog.addSingletonGetter(ol3.renderer.webgl.tilelayerrenderer.shader.Vertex);
 
 
 
 /**
  * @constructor
- * @extends {ol3.webgl.LayerRenderer}
+ * @extends {ol3.renderer.webgl.Layer}
- * @param {ol3.MapRenderer} mapRenderer Map renderer.
+ * @param {ol3.renderer.Map} mapRenderer Map renderer.
  * @param {ol3.TileLayer} tileLayer Tile layer.
  */
-ol3.webgl.TileLayerRenderer = function(mapRenderer, tileLayer) {
+ol3.renderer.webgl.TileLayer = function(mapRenderer, tileLayer) {
 
   goog.base(this, mapRenderer, tileLayer);
 
@@ -90,21 +92,22 @@ ol3.webgl.TileLayerRenderer = function(mapRenderer, tileLayer) {
      * @inheritDoc
      */
     this.logger = goog.debug.Logger.getLogger(
-        'ol3.webgl.tilelayerrenderer.' + goog.getUid(this));
+        'ol3.renderer.webgl.tilelayerrenderer.' + goog.getUid(this));
   }
 
   /**
    * @private
-   * @type {ol3.webgl.shader.Fragment}
+   * @type {ol3.renderer.webgl.FragmentShader}
    */
   this.fragmentShader_ =
-      ol3.webgl.tilelayerrenderer.shader.Fragment.getInstance();
+      ol3.renderer.webgl.tilelayerrenderer.shader.Fragment.getInstance();
 
   /**
    * @private
-   * @type {ol3.webgl.shader.Vertex}
+   * @type {ol3.renderer.webgl.VertexShader}
    */
-  this.vertexShader_ = ol3.webgl.tilelayerrenderer.shader.Vertex.getInstance();
+  this.vertexShader_ =
+      ol3.renderer.webgl.tilelayerrenderer.shader.Vertex.getInstance();
 
   /**
    * @private
@@ -152,14 +155,14 @@ ol3.webgl.TileLayerRenderer = function(mapRenderer, tileLayer) {
   this.matrix_ = goog.vec.Mat4.createNumber();
 
 };
-goog.inherits(ol3.webgl.TileLayerRenderer, ol3.webgl.LayerRenderer);
+goog.inherits(ol3.renderer.webgl.TileLayer, ol3.renderer.webgl.Layer);
 
 
 /**
  * @param {number} framebufferDimension Framebuffer dimension.
  * @private
  */
-ol3.webgl.TileLayerRenderer.prototype.bindFramebuffer_ =
+ol3.renderer.webgl.TileLayer.prototype.bindFramebuffer_ =
     function(framebufferDimension) {
 
   var mapRenderer = this.getMapRenderer();
@@ -172,7 +175,7 @@ ol3.webgl.TileLayerRenderer.prototype.bindFramebuffer_ =
       this.logger.info('re-sizing framebuffer');
     }
 
-    if (ol3.webgl.FREE_RESOURCES_IMMEDIATELY) {
+    if (ol3.renderer.webgl.FREE_RESOURCES_IMMEDIATELY) {
       if (goog.DEBUG) {
         this.logger.info('freeing WebGL resources');
       }
@@ -225,7 +228,7 @@ ol3.webgl.TileLayerRenderer.prototype.bindFramebuffer_ =
 /**
  * @inheritDoc
  */
-ol3.webgl.TileLayerRenderer.prototype.disposeInternal = function() {
+ol3.renderer.webgl.TileLayer.prototype.disposeInternal = function() {
   var mapRenderer = this.getMapRenderer();
   var gl = mapRenderer.getGL();
   if (!gl.isContextLost()) {
@@ -241,7 +244,7 @@ ol3.webgl.TileLayerRenderer.prototype.disposeInternal = function() {
  * @return {ol3.TileLayer} Layer.
  * @override
  */
-ol3.webgl.TileLayerRenderer.prototype.getLayer = function() {
+ol3.renderer.webgl.TileLayer.prototype.getLayer = function() {
   return /** @type {ol3.TileLayer} */ goog.base(this, 'getLayer');
 };
 
@@ -249,7 +252,7 @@ ol3.webgl.TileLayerRenderer.prototype.getLayer = function() {
 /**
  * @inheritDoc
  */
-ol3.webgl.TileLayerRenderer.prototype.getMatrix = function() {
+ol3.renderer.webgl.TileLayer.prototype.getMatrix = function() {
   return this.matrix_;
 };
 
@@ -257,7 +260,7 @@ ol3.webgl.TileLayerRenderer.prototype.getMatrix = function() {
 /**
  * @inheritDoc
  */
-ol3.webgl.TileLayerRenderer.prototype.getTexture = function() {
+ol3.renderer.webgl.TileLayer.prototype.getTexture = function() {
   return this.texture_;
 };
 
@@ -265,7 +268,7 @@ ol3.webgl.TileLayerRenderer.prototype.getTexture = function() {
 /**
  * @protected
  */
-ol3.webgl.TileLayerRenderer.prototype.handleTileChange = function() {
+ol3.renderer.webgl.TileLayer.prototype.handleTileChange = function() {
   this.dispatchChangeEvent();
 };
 
@@ -273,7 +276,7 @@ ol3.webgl.TileLayerRenderer.prototype.handleTileChange = function() {
 /**
  * @inheritDoc
  */
-ol3.webgl.TileLayerRenderer.prototype.handleWebGLContextLost = function() {
+ol3.renderer.webgl.TileLayer.prototype.handleWebGLContextLost = function() {
   this.locations_ = null;
   this.arrayBuffer_ = null;
   this.texture_ = null;
@@ -285,7 +288,7 @@ ol3.webgl.TileLayerRenderer.prototype.handleWebGLContextLost = function() {
 /**
  * @inheritDoc
  */
-ol3.webgl.TileLayerRenderer.prototype.render = function() {
+ol3.renderer.webgl.TileLayer.prototype.render = function() {
 
   var animate = false;
 

src/ol3/renderer/webgl/webgl.js

@@ -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;
+};

src/ol3/webgl/layerrenderer.js

@@ -1,113 +0,0 @@
-goog.provide('ol3.webgl.LayerRenderer');
-
-goog.require('goog.vec.Mat4');
-goog.require('ol3.Layer');
-goog.require('ol3.LayerRenderer');
-
-
-
-/**
- * @constructor
- * @extends {ol3.LayerRenderer}
- * @param {ol3.MapRenderer} mapRenderer Map renderer.
- * @param {ol3.Layer} layer Layer.
- */
-ol3.webgl.LayerRenderer = function(mapRenderer, layer) {
-  goog.base(this, mapRenderer, layer);
-};
-goog.inherits(ol3.webgl.LayerRenderer, ol3.LayerRenderer);
-
-
-/**
- * @protected
- */
-ol3.webgl.LayerRenderer.prototype.dispatchChangeEvent = function() {
-  this.dispatchEvent(goog.events.EventType.CHANGE);
-};
-
-
-/**
- * @override
- * @return {ol3.MapRenderer} MapRenderer.
- */
-ol3.webgl.LayerRenderer.prototype.getMapRenderer = function() {
-  return /** @type {ol3.webgl.MapRenderer} */ goog.base(this, 'getMapRenderer');
-};
-
-
-/**
- * @return {goog.vec.Mat4.AnyType} Matrix.
- */
-ol3.webgl.LayerRenderer.prototype.getMatrix = goog.abstractMethod;
-
-
-/**
- * @return {WebGLTexture} Texture.
- */
-ol3.webgl.LayerRenderer.prototype.getTexture = goog.abstractMethod;
-
-
-/**
- * @inheritDoc
- */
-ol3.webgl.LayerRenderer.prototype.handleLayerBrightnessChange = function() {
-  this.dispatchChangeEvent();
-};
-
-
-/**
- * @inheritDoc
- */
-ol3.webgl.LayerRenderer.prototype.handleLayerContrastChange = function() {
-  this.dispatchChangeEvent();
-};
-
-
-/**
- * @inheritDoc
- */
-ol3.webgl.LayerRenderer.prototype.handleLayerHueChange = function() {
-  this.dispatchChangeEvent();
-};
-
-
-/**
- * @inheritDoc
- */
-ol3.webgl.LayerRenderer.prototype.handleLayerLoad = function() {
-  this.dispatchChangeEvent();
-};
-
-
-/**
- * @inheritDoc
- */
-ol3.webgl.LayerRenderer.prototype.handleLayerOpacityChange = function() {
-  this.dispatchChangeEvent();
-};
-
-
-/**
- * @inheritDoc
- */
-ol3.webgl.LayerRenderer.prototype.handleLayerSaturationChange = function() {
-  this.dispatchChangeEvent();
-};
-
-
-/**
- * @inheritDoc
- */
-ol3.webgl.LayerRenderer.prototype.handleLayerVisibleChange = function() {
-  this.dispatchChangeEvent();
-};
-
-
-/**
- */
-ol3.webgl.LayerRenderer.prototype.handleWebGLContextLost = goog.nullFunction;
-
-
-/**
- */
-ol3.webgl.LayerRenderer.prototype.render = goog.abstractMethod;

src/ol3/webgl/shader.js

@@ -1,81 +0,0 @@
-goog.provide('ol3.webgl.shader.Fragment');
-goog.provide('ol3.webgl.shader.Vertex');
-
-goog.require('goog.functions');
-goog.require('goog.webgl');
-
-
-
-/**
- * @constructor
- * @param {string} source Source.
- */
-ol3.webgl.Shader = function(source) {
-
-  /**
-   * @private
-   * @type {string}
-   */
-  this.source_ = source;
-
-};
-
-
-/**
- * @return {number} Type.
- */
-ol3.webgl.Shader.prototype.getType = goog.abstractMethod;
-
-
-/**
- * @return {string} Source.
- */
-ol3.webgl.Shader.prototype.getSource = function() {
-  return this.source_;
-};
-
-
-/**
- * @return {boolean} Is animated?
- */
-ol3.webgl.Shader.prototype.isAnimated = goog.functions.FALSE;
-
-
-
-/**
- * @constructor
- * @extends {ol3.webgl.Shader}
- * @param {string} source Source.
- */
-ol3.webgl.shader.Fragment = function(source) {
-  goog.base(this, source);
-};
-goog.inherits(ol3.webgl.shader.Fragment, ol3.webgl.Shader);
-
-
-/**
- * @inheritDoc
- */
-ol3.webgl.shader.Fragment.prototype.getType = function() {
-  return goog.webgl.FRAGMENT_SHADER;
-};
-
-
-
-/**
- * @constructor
- * @extends {ol3.webgl.Shader}
- * @param {string} source Source.
- */
-ol3.webgl.shader.Vertex = function(source) {
-  goog.base(this, source);
-};
-goog.inherits(ol3.webgl.shader.Vertex, ol3.webgl.Shader);
-
-
-/**
- * @inheritDoc
- */
-ol3.webgl.shader.Vertex.prototype.getType = function() {
-  return goog.webgl.VERTEX_SHADER;
-};

src/ol3/webgl/webgl.js

@@ -1,13 +1,6 @@
-goog.provide('ol3.webgl');
 goog.provide('ol3.webgl.WebGLContextEventType');
 
 
-/**
- * @define {boolean} Free resources immediately.
- */
-ol3.webgl.FREE_RESOURCES_IMMEDIATELY = false;
-
-
 /**
  * @enum {string}
  */
@@ -15,11 +8,3 @@ ol3.webgl.WebGLContextEventType = {
   LOST: 'webglcontextlost',
   RESTORED: 'webglcontextrestored'
 };
-
-
-/**
- * @return {boolean} Is supported.
- */
-ol3.webgl.isSupported = function() {
-  return 'WebGLRenderingContext' in goog.global;
-};