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

Wrap ol.webgl code in define condition

Browse Source
This commit is contained in:
Andreas Hocevar
2017-01-02 21:52:31 +01:00
parent fd92982661
commit 9c79564676
5 changed files with 444 additions and 424 deletions
Download Patch File Download Diff File Expand all files Collapse all files

80
src/ol/webgl/buffer.js
View File

@@ -4,52 +4,56 @@ goog.require('ol');
goog.require('ol.webgl'); goog.require('ol.webgl');
/** if (ol.ENABLE_WEBGL) {
* @constructor
* @param {Array.<number>=} opt_arr Array.
* @param {number=} opt_usage Usage.
* @struct
*/
ol.webgl.Buffer = function(opt_arr, opt_usage) {
/** /**
* @private * @constructor
* @type {Array.<number>} * @param {Array.<number>=} opt_arr Array.
* @param {number=} opt_usage Usage.
* @struct
*/ */
this.arr_ = opt_arr !== undefined ? opt_arr : []; ol.webgl.Buffer = function(opt_arr, opt_usage) {
/**
* @private
* @type {Array.<number>}
*/
this.arr_ = opt_arr !== undefined ? opt_arr : [];
/**
* @private
* @type {number}
*/
this.usage_ = opt_usage !== undefined ?
opt_usage : ol.webgl.Buffer.Usage_.STATIC_DRAW;
};
/** /**
* @private * @return {Array.<number>} Array.
* @type {number}
*/ */
this.usage_ = opt_usage !== undefined ? ol.webgl.Buffer.prototype.getArray = function() {
opt_usage : ol.webgl.Buffer.Usage_.STATIC_DRAW; return this.arr_;
};
};
/** /**
* @return {Array.<number>} Array. * @return {number} Usage.
*/ */
ol.webgl.Buffer.prototype.getArray = function() { ol.webgl.Buffer.prototype.getUsage = function() {
return this.arr_; return this.usage_;
}; };
/** /**
* @return {number} Usage. * @enum {number}
*/ * @private
ol.webgl.Buffer.prototype.getUsage = function() { */
return this.usage_; ol.webgl.Buffer.Usage_ = {
}; STATIC_DRAW: ol.webgl.STATIC_DRAW,
STREAM_DRAW: ol.webgl.STREAM_DRAW,
DYNAMIC_DRAW: ol.webgl.DYNAMIC_DRAW
};
}
/**
* @enum {number}
* @private
*/
ol.webgl.Buffer.Usage_ = {
STATIC_DRAW: ol.webgl.STATIC_DRAW,
STREAM_DRAW: ol.webgl.STREAM_DRAW,
DYNAMIC_DRAW: ol.webgl.DYNAMIC_DRAW
};

662
src/ol/webgl/context.js
View File

@@ -9,363 +9,367 @@ goog.require('ol.webgl');
goog.require('ol.webgl.ContextEventType'); goog.require('ol.webgl.ContextEventType');
/** if (ol.ENABLE_WEBGL) {
* @classdesc
* A WebGL context for accessing low-level WebGL capabilities.
*
* @constructor
* @extends {ol.Disposable}
* @param {HTMLCanvasElement} canvas Canvas.
* @param {WebGLRenderingContext} gl GL.
*/
ol.webgl.Context = function(canvas, gl) {
/** /**
* @private * @classdesc
* @type {HTMLCanvasElement} * A WebGL context for accessing low-level WebGL capabilities.
*
* @constructor
* @extends {ol.Disposable}
* @param {HTMLCanvasElement} canvas Canvas.
* @param {WebGLRenderingContext} gl GL.
*/ */
this.canvas_ = canvas; ol.webgl.Context = function(canvas, gl) {
/**
* @private
* @type {HTMLCanvasElement}
*/
this.canvas_ = canvas;
/**
* @private
* @type {WebGLRenderingContext}
*/
this.gl_ = gl;
/**
* @private
* @type {Object.<string, ol.WebglBufferCacheEntry>}
*/
this.bufferCache_ = {};
/**
* @private
* @type {Object.<string, WebGLShader>}
*/
this.shaderCache_ = {};
/**
* @private
* @type {Object.<string, WebGLProgram>}
*/
this.programCache_ = {};
/**
* @private
* @type {WebGLProgram}
*/
this.currentProgram_ = null;
/**
* @private
* @type {WebGLFramebuffer}
*/
this.hitDetectionFramebuffer_ = null;
/**
* @private
* @type {WebGLTexture}
*/
this.hitDetectionTexture_ = null;
/**
* @private
* @type {WebGLRenderbuffer}
*/
this.hitDetectionRenderbuffer_ = null;
/**
* @type {boolean}
*/
this.hasOESElementIndexUint = ol.array.includes(
ol.WEBGL_EXTENSIONS, 'OES_element_index_uint');
// use the OES_element_index_uint extension if available
if (this.hasOESElementIndexUint) {
gl.getExtension('OES_element_index_uint');
}
ol.events.listen(this.canvas_, ol.webgl.ContextEventType.LOST,
this.handleWebGLContextLost, this);
ol.events.listen(this.canvas_, ol.webgl.ContextEventType.RESTORED,
this.handleWebGLContextRestored, this);
};
ol.inherits(ol.webgl.Context, ol.Disposable);
/** /**
* @private * Just bind the buffer if it's in the cache. Otherwise create
* @type {WebGLRenderingContext} * the WebGL buffer, bind it, populate it, and add an entry to
* the cache.
* @param {number} target Target.
* @param {ol.webgl.Buffer} buf Buffer.
*/ */
this.gl_ = gl; ol.webgl.Context.prototype.bindBuffer = function(target, buf) {
var gl = this.getGL();
var arr = buf.getArray();
var bufferKey = String(ol.getUid(buf));
if (bufferKey in this.bufferCache_) {
var bufferCacheEntry = this.bufferCache_[bufferKey];
gl.bindBuffer(target, bufferCacheEntry.buffer);
} else {
var buffer = gl.createBuffer();
gl.bindBuffer(target, buffer);
var /** @type {ArrayBufferView} */ arrayBuffer;
if (target == ol.webgl.ARRAY_BUFFER) {
arrayBuffer = new Float32Array(arr);
} else if (target == ol.webgl.ELEMENT_ARRAY_BUFFER) {
arrayBuffer = this.hasOESElementIndexUint ?
new Uint32Array(arr) : new Uint16Array(arr);
}
gl.bufferData(target, arrayBuffer, buf.getUsage());
this.bufferCache_[bufferKey] = {
buf: buf,
buffer: buffer
};
}
};
/** /**
* @private * @param {ol.webgl.Buffer} buf Buffer.
* @type {Object.<string, ol.WebglBufferCacheEntry>}
*/ */
this.bufferCache_ = {}; ol.webgl.Context.prototype.deleteBuffer = function(buf) {
var gl = this.getGL();
/** var bufferKey = String(ol.getUid(buf));
* @private
* @type {Object.<string, WebGLShader>}
*/
this.shaderCache_ = {};
/**
* @private
* @type {Object.<string, WebGLProgram>}
*/
this.programCache_ = {};
/**
* @private
* @type {WebGLProgram}
*/
this.currentProgram_ = null;
/**
* @private
* @type {WebGLFramebuffer}
*/
this.hitDetectionFramebuffer_ = null;
/**
* @private
* @type {WebGLTexture}
*/
this.hitDetectionTexture_ = null;
/**
* @private
* @type {WebGLRenderbuffer}
*/
this.hitDetectionRenderbuffer_ = null;
/**
* @type {boolean}
*/
this.hasOESElementIndexUint = ol.array.includes(
ol.WEBGL_EXTENSIONS, 'OES_element_index_uint');
// use the OES_element_index_uint extension if available
if (this.hasOESElementIndexUint) {
gl.getExtension('OES_element_index_uint');
}
ol.events.listen(this.canvas_, ol.webgl.ContextEventType.LOST,
this.handleWebGLContextLost, this);
ol.events.listen(this.canvas_, ol.webgl.ContextEventType.RESTORED,
this.handleWebGLContextRestored, this);
};
ol.inherits(ol.webgl.Context, ol.Disposable);
/**
* Just bind the buffer if it's in the cache. Otherwise create
* the WebGL buffer, bind it, populate it, and add an entry to
* the cache.
* @param {number} target Target.
* @param {ol.webgl.Buffer} buf Buffer.
*/
ol.webgl.Context.prototype.bindBuffer = function(target, buf) {
var gl = this.getGL();
var arr = buf.getArray();
var bufferKey = String(ol.getUid(buf));
if (bufferKey in this.bufferCache_) {
var bufferCacheEntry = this.bufferCache_[bufferKey]; var bufferCacheEntry = this.bufferCache_[bufferKey];
gl.bindBuffer(target, bufferCacheEntry.buffer); if (!gl.isContextLost()) {
} else { gl.deleteBuffer(bufferCacheEntry.buffer);
var buffer = gl.createBuffer();
gl.bindBuffer(target, buffer);
var /** @type {ArrayBufferView} */ arrayBuffer;
if (target == ol.webgl.ARRAY_BUFFER) {
arrayBuffer = new Float32Array(arr);
} else if (target == ol.webgl.ELEMENT_ARRAY_BUFFER) {
arrayBuffer = this.hasOESElementIndexUint ?
new Uint32Array(arr) : new Uint16Array(arr);
} }
gl.bufferData(target, arrayBuffer, buf.getUsage()); delete this.bufferCache_[bufferKey];
this.bufferCache_[bufferKey] = { };
buf: buf,
buffer: buffer
};
}
};
/** /**
* @param {ol.webgl.Buffer} buf Buffer. * @inheritDoc
*/ */
ol.webgl.Context.prototype.deleteBuffer = function(buf) { ol.webgl.Context.prototype.disposeInternal = function() {
var gl = this.getGL(); ol.events.unlistenAll(this.canvas_);
var bufferKey = String(ol.getUid(buf));
var bufferCacheEntry = this.bufferCache_[bufferKey];
if (!gl.isContextLost()) {
gl.deleteBuffer(bufferCacheEntry.buffer);
}
delete this.bufferCache_[bufferKey];
};
/**
* @inheritDoc
*/
ol.webgl.Context.prototype.disposeInternal = function() {
ol.events.unlistenAll(this.canvas_);
var gl = this.getGL();
if (!gl.isContextLost()) {
var key;
for (key in this.bufferCache_) {
gl.deleteBuffer(this.bufferCache_[key].buffer);
}
for (key in this.programCache_) {
gl.deleteProgram(this.programCache_[key]);
}
for (key in this.shaderCache_) {
gl.deleteShader(this.shaderCache_[key]);
}
// delete objects for hit-detection
gl.deleteFramebuffer(this.hitDetectionFramebuffer_);
gl.deleteRenderbuffer(this.hitDetectionRenderbuffer_);
gl.deleteTexture(this.hitDetectionTexture_);
}
};
/**
* @return {HTMLCanvasElement} Canvas.
*/
ol.webgl.Context.prototype.getCanvas = function() {
return this.canvas_;
};
/**
* Get the WebGL rendering context
* @return {WebGLRenderingContext} The rendering context.
* @api
*/
ol.webgl.Context.prototype.getGL = function() {
return this.gl_;
};
/**
* Get the frame buffer for hit detection.
* @return {WebGLFramebuffer} The hit detection frame buffer.
*/
ol.webgl.Context.prototype.getHitDetectionFramebuffer = function() {
if (!this.hitDetectionFramebuffer_) {
this.initHitDetectionFramebuffer_();
}
return this.hitDetectionFramebuffer_;
};
/**
* Get shader from the cache if it's in the cache. Otherwise, create
* the WebGL shader, compile it, and add entry to cache.
* @param {ol.webgl.Shader} shaderObject Shader object.
* @return {WebGLShader} Shader.
*/
ol.webgl.Context.prototype.getShader = function(shaderObject) {
var shaderKey = String(ol.getUid(shaderObject));
if (shaderKey in this.shaderCache_) {
return this.shaderCache_[shaderKey];
} else {
var gl = this.getGL(); var gl = this.getGL();
var shader = gl.createShader(shaderObject.getType()); if (!gl.isContextLost()) {
gl.shaderSource(shader, shaderObject.getSource()); var key;
gl.compileShader(shader); for (key in this.bufferCache_) {
this.shaderCache_[shaderKey] = shader; gl.deleteBuffer(this.bufferCache_[key].buffer);
return shader; }
} for (key in this.programCache_) {
}; gl.deleteProgram(this.programCache_[key]);
}
for (key in this.shaderCache_) {
gl.deleteShader(this.shaderCache_[key]);
}
// delete objects for hit-detection
gl.deleteFramebuffer(this.hitDetectionFramebuffer_);
gl.deleteRenderbuffer(this.hitDetectionRenderbuffer_);
gl.deleteTexture(this.hitDetectionTexture_);
}
};
/** /**
* Get the program from the cache if it's in the cache. Otherwise create * @return {HTMLCanvasElement} Canvas.
* the WebGL program, attach the shaders to it, and add an entry to the */
* cache. ol.webgl.Context.prototype.getCanvas = function() {
* @param {ol.webgl.Fragment} fragmentShaderObject Fragment shader. return this.canvas_;
* @param {ol.webgl.Vertex} vertexShaderObject Vertex shader. };
* @return {WebGLProgram} Program.
*/
ol.webgl.Context.prototype.getProgram = function(
fragmentShaderObject, vertexShaderObject) {
var programKey =
ol.getUid(fragmentShaderObject) + '/' + ol.getUid(vertexShaderObject);
if (programKey in this.programCache_) {
return this.programCache_[programKey];
} else {
var gl = this.getGL();
var program = gl.createProgram();
gl.attachShader(program, this.getShader(fragmentShaderObject));
gl.attachShader(program, this.getShader(vertexShaderObject));
gl.linkProgram(program);
this.programCache_[programKey] = program;
return program;
}
};
/** /**
* FIXME empy description for jsdoc * Get the WebGL rendering context
*/ * @return {WebGLRenderingContext} The rendering context.
ol.webgl.Context.prototype.handleWebGLContextLost = function() { * @api
ol.obj.clear(this.bufferCache_); */
ol.obj.clear(this.shaderCache_); ol.webgl.Context.prototype.getGL = function() {
ol.obj.clear(this.programCache_); return this.gl_;
this.currentProgram_ = null; };
this.hitDetectionFramebuffer_ = null;
this.hitDetectionTexture_ = null;
this.hitDetectionRenderbuffer_ = null;
};
/** /**
* FIXME empy description for jsdoc * Get the frame buffer for hit detection.
*/ * @return {WebGLFramebuffer} The hit detection frame buffer.
ol.webgl.Context.prototype.handleWebGLContextRestored = function() { */
}; ol.webgl.Context.prototype.getHitDetectionFramebuffer = function() {
if (!this.hitDetectionFramebuffer_) {
this.initHitDetectionFramebuffer_();
}
return this.hitDetectionFramebuffer_;
};
/** /**
* Creates a 1x1 pixel framebuffer for the hit-detection. * Get shader from the cache if it's in the cache. Otherwise, create
* @private * the WebGL shader, compile it, and add entry to cache.
*/ * @param {ol.webgl.Shader} shaderObject Shader object.
ol.webgl.Context.prototype.initHitDetectionFramebuffer_ = function() { * @return {WebGLShader} Shader.
var gl = this.gl_; */
var framebuffer = gl.createFramebuffer(); ol.webgl.Context.prototype.getShader = function(shaderObject) {
gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer); var shaderKey = String(ol.getUid(shaderObject));
if (shaderKey in this.shaderCache_) {
var texture = ol.webgl.Context.createEmptyTexture(gl, 1, 1); return this.shaderCache_[shaderKey];
var renderbuffer = gl.createRenderbuffer(); } else {
gl.bindRenderbuffer(gl.RENDERBUFFER, renderbuffer); var gl = this.getGL();
gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_COMPONENT16, 1, 1); var shader = gl.createShader(shaderObject.getType());
gl.framebufferTexture2D( gl.shaderSource(shader, shaderObject.getSource());
gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0); gl.compileShader(shader);
gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, this.shaderCache_[shaderKey] = shader;
gl.RENDERBUFFER, renderbuffer); return shader;
}
gl.bindTexture(gl.TEXTURE_2D, null); };
gl.bindRenderbuffer(gl.RENDERBUFFER, null);
gl.bindFramebuffer(gl.FRAMEBUFFER, null);
this.hitDetectionFramebuffer_ = framebuffer;
this.hitDetectionTexture_ = texture;
this.hitDetectionRenderbuffer_ = renderbuffer;
};
/** /**
* Use a program. If the program is already in use, this will return `false`. * Get the program from the cache if it's in the cache. Otherwise create
* @param {WebGLProgram} program Program. * the WebGL program, attach the shaders to it, and add an entry to the
* @return {boolean} Changed. * cache.
* @api * @param {ol.webgl.Fragment} fragmentShaderObject Fragment shader.
*/ * @param {ol.webgl.Vertex} vertexShaderObject Vertex shader.
ol.webgl.Context.prototype.useProgram = function(program) { * @return {WebGLProgram} Program.
if (program == this.currentProgram_) { */
return false; ol.webgl.Context.prototype.getProgram = function(
} else { fragmentShaderObject, vertexShaderObject) {
var gl = this.getGL(); var programKey =
gl.useProgram(program); ol.getUid(fragmentShaderObject) + '/' + ol.getUid(vertexShaderObject);
this.currentProgram_ = program; if (programKey in this.programCache_) {
return true; return this.programCache_[programKey];
} } else {
}; var gl = this.getGL();
var program = gl.createProgram();
gl.attachShader(program, this.getShader(fragmentShaderObject));
gl.attachShader(program, this.getShader(vertexShaderObject));
gl.linkProgram(program);
this.programCache_[programKey] = program;
return program;
}
};
/** /**
* @param {WebGLRenderingContext} gl WebGL rendering context. * FIXME empy description for jsdoc
* @param {number=} opt_wrapS wrapS. */
* @param {number=} opt_wrapT wrapT. ol.webgl.Context.prototype.handleWebGLContextLost = function() {
* @return {WebGLTexture} The texture. ol.obj.clear(this.bufferCache_);
* @private ol.obj.clear(this.shaderCache_);
*/ ol.obj.clear(this.programCache_);
ol.webgl.Context.createTexture_ = function(gl, opt_wrapS, opt_wrapT) { this.currentProgram_ = null;
var texture = gl.createTexture(); this.hitDetectionFramebuffer_ = null;
gl.bindTexture(gl.TEXTURE_2D, texture); this.hitDetectionTexture_ = null;
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR); this.hitDetectionRenderbuffer_ = null;
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR); };
if (opt_wrapS !== undefined) {
gl.texParameteri(
ol.webgl.TEXTURE_2D, ol.webgl.TEXTURE_WRAP_S, opt_wrapS);
}
if (opt_wrapT !== undefined) {
gl.texParameteri(
ol.webgl.TEXTURE_2D, ol.webgl.TEXTURE_WRAP_T, opt_wrapT);
}
return texture;
};
/** /**
* @param {WebGLRenderingContext} gl WebGL rendering context. * FIXME empy description for jsdoc
* @param {number} width Width. */
* @param {number} height Height. ol.webgl.Context.prototype.handleWebGLContextRestored = function() {
* @param {number=} opt_wrapS wrapS. };
* @param {number=} opt_wrapT wrapT.
* @return {WebGLTexture} The texture.
*/
ol.webgl.Context.createEmptyTexture = function(
gl, width, height, opt_wrapS, opt_wrapT) {
var texture = ol.webgl.Context.createTexture_(gl, opt_wrapS, opt_wrapT);
gl.texImage2D(
gl.TEXTURE_2D, 0, gl.RGBA, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE,
null);
return texture;
};
/** /**
* @param {WebGLRenderingContext} gl WebGL rendering context. * Creates a 1x1 pixel framebuffer for the hit-detection.
* @param {HTMLCanvasElement|HTMLImageElement|HTMLVideoElement} image Image. * @private
* @param {number=} opt_wrapS wrapS. */
* @param {number=} opt_wrapT wrapT. ol.webgl.Context.prototype.initHitDetectionFramebuffer_ = function() {
* @return {WebGLTexture} The texture. var gl = this.gl_;
*/ var framebuffer = gl.createFramebuffer();
ol.webgl.Context.createTexture = function(gl, image, opt_wrapS, opt_wrapT) { gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
var texture = ol.webgl.Context.createTexture_(gl, opt_wrapS, opt_wrapT);
gl.texImage2D(
gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, image);
return texture; var texture = ol.webgl.Context.createEmptyTexture(gl, 1, 1);
}; var renderbuffer = gl.createRenderbuffer();
gl.bindRenderbuffer(gl.RENDERBUFFER, renderbuffer);
gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_COMPONENT16, 1, 1);
gl.framebufferTexture2D(
gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);
gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT,
gl.RENDERBUFFER, renderbuffer);
gl.bindTexture(gl.TEXTURE_2D, null);
gl.bindRenderbuffer(gl.RENDERBUFFER, null);
gl.bindFramebuffer(gl.FRAMEBUFFER, null);
this.hitDetectionFramebuffer_ = framebuffer;
this.hitDetectionTexture_ = texture;
this.hitDetectionRenderbuffer_ = renderbuffer;
};
/**
* Use a program. If the program is already in use, this will return `false`.
* @param {WebGLProgram} program Program.
* @return {boolean} Changed.
* @api
*/
ol.webgl.Context.prototype.useProgram = function(program) {
if (program == this.currentProgram_) {
return false;
} else {
var gl = this.getGL();
gl.useProgram(program);
this.currentProgram_ = program;
return true;
}
};
/**
* @param {WebGLRenderingContext} gl WebGL rendering context.
* @param {number=} opt_wrapS wrapS.
* @param {number=} opt_wrapT wrapT.
* @return {WebGLTexture} The texture.
* @private
*/
ol.webgl.Context.createTexture_ = function(gl, opt_wrapS, opt_wrapT) {
var texture = gl.createTexture();
gl.bindTexture(gl.TEXTURE_2D, texture);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
if (opt_wrapS !== undefined) {
gl.texParameteri(
ol.webgl.TEXTURE_2D, ol.webgl.TEXTURE_WRAP_S, opt_wrapS);
}
if (opt_wrapT !== undefined) {
gl.texParameteri(
ol.webgl.TEXTURE_2D, ol.webgl.TEXTURE_WRAP_T, opt_wrapT);
}
return texture;
};
/**
* @param {WebGLRenderingContext} gl WebGL rendering context.
* @param {number} width Width.
* @param {number} height Height.
* @param {number=} opt_wrapS wrapS.
* @param {number=} opt_wrapT wrapT.
* @return {WebGLTexture} The texture.
*/
ol.webgl.Context.createEmptyTexture = function(
gl, width, height, opt_wrapS, opt_wrapT) {
var texture = ol.webgl.Context.createTexture_(gl, opt_wrapS, opt_wrapT);
gl.texImage2D(
gl.TEXTURE_2D, 0, gl.RGBA, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE,
null);
return texture;
};
/**
* @param {WebGLRenderingContext} gl WebGL rendering context.
* @param {HTMLCanvasElement|HTMLImageElement|HTMLVideoElement} image Image.
* @param {number=} opt_wrapS wrapS.
* @param {number=} opt_wrapT wrapT.
* @return {WebGLTexture} The texture.
*/
ol.webgl.Context.createTexture = function(gl, image, opt_wrapS, opt_wrapT) {
var texture = ol.webgl.Context.createTexture_(gl, opt_wrapS, opt_wrapT);
gl.texImage2D(
gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, image);
return texture;
};
}

36
src/ol/webgl/fragment.js
View File

@@ -5,21 +5,25 @@ goog.require('ol.webgl');
goog.require('ol.webgl.Shader'); goog.require('ol.webgl.Shader');
/** if (ol.ENABLE_WEBGL) {
* @constructor
* @extends {ol.webgl.Shader} /**
* @param {string} source Source. * @constructor
* @struct * @extends {ol.webgl.Shader}
*/ * @param {string} source Source.
ol.webgl.Fragment = function(source) { * @struct
ol.webgl.Shader.call(this, source); */
}; ol.webgl.Fragment = function(source) {
ol.inherits(ol.webgl.Fragment, ol.webgl.Shader); ol.webgl.Shader.call(this, source);
};
ol.inherits(ol.webgl.Fragment, ol.webgl.Shader);
/** /**
* @inheritDoc * @inheritDoc
*/ */
ol.webgl.Fragment.prototype.getType = function() { ol.webgl.Fragment.prototype.getType = function() {
return ol.webgl.FRAGMENT_SHADER; return ol.webgl.FRAGMENT_SHADER;
}; };
}

54
src/ol/webgl/shader.js
View File

@@ -4,38 +4,42 @@ goog.require('ol.functions');
goog.require('ol.webgl'); goog.require('ol.webgl');
/** if (ol.ENABLE_WEBGL) {
* @constructor
* @param {string} source Source.
* @struct
*/
ol.webgl.Shader = function(source) {
/** /**
* @private * @constructor
* @type {string} * @param {string} source Source.
* @struct
*/ */
this.source_ = source; ol.webgl.Shader = function(source) {
}; /**
* @private
* @type {string}
*/
this.source_ = source;
};
/** /**
* @abstract * @abstract
* @return {number} Type. * @return {number} Type.
*/ */
ol.webgl.Shader.prototype.getType = function() {}; ol.webgl.Shader.prototype.getType = function() {};
/** /**
* @return {string} Source. * @return {string} Source.
*/ */
ol.webgl.Shader.prototype.getSource = function() { ol.webgl.Shader.prototype.getSource = function() {
return this.source_; return this.source_;
}; };
/** /**
* @return {boolean} Is animated? * @return {boolean} Is animated?
*/ */
ol.webgl.Shader.prototype.isAnimated = ol.functions.FALSE; ol.webgl.Shader.prototype.isAnimated = ol.functions.FALSE;
}

36
src/ol/webgl/vertex.js
View File

@@ -5,21 +5,25 @@ goog.require('ol.webgl');
goog.require('ol.webgl.Shader'); goog.require('ol.webgl.Shader');
/** if (ol.ENABLE_WEBGL) {
* @constructor
* @extends {ol.webgl.Shader} /**
* @param {string} source Source. * @constructor
* @struct * @extends {ol.webgl.Shader}
*/ * @param {string} source Source.
ol.webgl.Vertex = function(source) { * @struct
ol.webgl.Shader.call(this, source); */
}; ol.webgl.Vertex = function(source) {
ol.inherits(ol.webgl.Vertex, ol.webgl.Shader); ol.webgl.Shader.call(this, source);
};
ol.inherits(ol.webgl.Vertex, ol.webgl.Shader);
/** /**
* @inheritDoc * @inheritDoc
*/ */
ol.webgl.Vertex.prototype.getType = function() { ol.webgl.Vertex.prototype.getType = function() {
return ol.webgl.VERTEX_SHADER; return ol.webgl.VERTEX_SHADER;
}; };
}