glContexts = []; // this is where we store the webGL contexts for easy access.
instances = [];
/**
* The WebGLRenderer draws the stage and all its content onto a webGL enabled canvas. This renderer
* should be used for browsers that support webGL. This Render works by automatically managing webGLBatchs.
* So no need for Sprite Batches or Sprite Clouds.
* Don't forget to add the view to your DOM or you will not see anything :)
*
* @class
* @namespace PIXI
* @param [width=0] {number} the width of the canvas view
* @param [height=0] {number} the height of the canvas view
* @param [options] {object} The optional renderer parameters
* @param [options.view] {HTMLCanvasElement} the canvas to use as a view, optional
* @param [options.transparent=false] {boolean} If the render view is transparent, default false
* @param [options.autoResize=false] {boolean} If the render view is automatically resized, default false
* @param [options.antialias=false] {boolean} sets antialias (only applicable in chrome at the moment)
* @param [options.preserveDrawingBuffer=false] {boolean} enables drawing buffer preservation, enable this if you need to call toDataUrl on the webgl context
* @param [options.resolution=1] {number} the resolution of the renderer retina would be 2
*/
function WebGLRenderer(width, height, options) {
if (options) {
for (var i in defaultRenderOptions) {
if (typeof options[i] === 'undefined') options[i] = defaultRenderOptions[i];
}
}
else {
options = defaultRenderOptions;
}
if (!defaultRenderer) {
sayHello('webGL');
defaultRenderer = this;
}
/**
* @member {number}
*/
this.type = WEBGL_RENDERER;
/**
* The resolution of the renderer
*
* @member {number}
* @default 1
*/
this.resolution = options.resolution;
// do a catch.. only 1 webGL renderer..
/**
* Whether the render view is transparent
*
* @member {boolean}
*/
this.transparent = options.transparent;
/**
* Whether the render view should be resized automatically
*
* @member {boolean}
*/
this.autoResize = options.autoResize || false;
/**
* The value of the preserveDrawingBuffer flag affects whether or not the contents of the stencil buffer is retained after rendering.
*
* @member {boolean}
*/
this.preserveDrawingBuffer = options.preserveDrawingBuffer;
/**
* This sets if the WebGLRenderer will clear the context texture or not before the new render pass. If true:
* If the Stage is NOT transparent, Pixi will clear to alpha (0, 0, 0, 0).
* If the Stage is transparent, Pixi will clear to the target Stage's background color.
* Disable this by setting this to false. For example: if your game has a canvas filling background image, you often don't need this set.
*
* @member {boolean}
* @default
*/
this.clearBeforeRender = options.clearBeforeRender;
/**
* The width of the canvas view
*
* @member {number}
* @default 800
*/
this.width = width || 800;
/**
* The height of the canvas view
*
* @member {number}
* @default 600
*/
this.height = height || 600;
/**
* The canvas element that everything is drawn to
*
* @member {HTMLCanvasElement}
*/
this.view = options.view || document.createElement( 'canvas' );
// deal with losing context..
/**
* @member {Function}
*/
this.contextLostBound = this.handleContextLost.bind(this);
/**
* @member {Function}
*/
this.contextRestoredBound = this.handleContextRestored.bind(this);
this.view.addEventListener('webglcontextlost', this.contextLostBound, false);
this.view.addEventListener('webglcontextrestored', this.contextRestoredBound, false);
/**
* @member {object}
* @private
*/
this._contextOptions = {
alpha: this.transparent,
antialias: options.antialias, // SPEED UP??
premultipliedAlpha:this.transparent && this.transparent !== 'notMultiplied',
stencil:true,
preserveDrawingBuffer: options.preserveDrawingBuffer
};
/**
* @member {Point}
*/
this.projection = new Point();
/**
* @member {Point}
*/
this.offset = new Point(0, 0);
// time to create the render managers! each one focuses on managing a state in webGL
/**
* Deals with managing the shader programs and their attribs
* @member {WebGLShaderManager}
*/
this.shaderManager = new WebGLShaderManager();
/**
* Manages the rendering of sprites
* @member {WebGLSpriteBatch}
*/
this.spriteBatch = new WebGLSpriteBatch();
/**
* Manages the masks using the stencil buffer
* @member {WebGLMaskManager}
*/
this.maskManager = new WebGLMaskManager();
/**
* Manages the filters
* @member {WebGLFilterManager}
*/
this.filterManager = new WebGLFilterManager();
/**
* Manages the stencil buffer
* @member {WebGLStencilManager}
*/
this.stencilManager = new WebGLStencilManager();
/**
* Manages the blendModes
* @member {WebGLBlendModeManager}
*/
this.blendModeManager = new WebGLBlendModeManager();
/**
* TODO remove
* @member {object}
*/
this.renderSession = {};
this.renderSession.gl = this.gl;
this.renderSession.drawCount = 0;
this.renderSession.shaderManager = this.shaderManager;
this.renderSession.maskManager = this.maskManager;
this.renderSession.filterManager = this.filterManager;
this.renderSession.blendModeManager = this.blendModeManager;
this.renderSession.spriteBatch = this.spriteBatch;
this.renderSession.stencilManager = this.stencilManager;
this.renderSession.renderer = this;
this.renderSession.resolution = this.resolution;
// time init the context..
this.initContext();
// map some webGL blend modes..
this.mapBlendModes();
};
// constructor
WebGLRenderer.prototype.constructor = WebGLRenderer;
module.exports = WebGLRenderer;
/**
* @method initContext
*/
WebGLRenderer.prototype.initContext = function () {
var gl = this.view.getContext('webgl', this._contextOptions) || this.view.getContext('experimental-webgl', this._contextOptions);
this.gl = gl;
if (!gl) {
// fail, not able to get a context
throw new Error('This browser does not support webGL. Try using the canvas renderer');
}
this.glContextId = gl.id = WebGLRenderer.glContextId ++;
glContexts[this.glContextId] = gl;
instances[this.glContextId] = this;
// set up the default pixi settings..
gl.disable(gl.DEPTH_TEST);
gl.disable(gl.CULL_FACE);
gl.enable(gl.BLEND);
// need to set the context for all the managers...
this.shaderManager.setContext(gl);
this.spriteBatch.setContext(gl);
this.maskManager.setContext(gl);
this.filterManager.setContext(gl);
this.blendModeManager.setContext(gl);
this.stencilManager.setContext(gl);
this.renderSession.gl = this.gl;
// now resize and we are good to go!
this.resize(this.width, this.height);
};
/**
* Renders the stage to its webGL view
*
* @param stage {Stage} the Stage element to be rendered
*/
WebGLRenderer.prototype.render = function (stage) {
// no point rendering if our context has been blown up!
if (this.contextLost)return;
// if rendering a new stage clear the batches..
if (this.__stage !== stage) {
if (stage.interactive)stage.interactionManager.removeEvents();
// TODO make this work
// dont think this is needed any more?
this.__stage = stage;
}
// update the scene graph
stage.updateTransform();
var gl = this.gl;
// interaction
if (stage._interactive) {
//need to add some events!
if (!stage._interactiveEventsAdded) {
stage._interactiveEventsAdded = true;
stage.interactionManager.setTarget(this);
}
}
else {
if (stage._interactiveEventsAdded) {
stage._interactiveEventsAdded = false;
stage.interactionManager.setTarget(this);
}
}
// -- Does this need to be set every frame? -- //
gl.viewport(0, 0, this.width, this.height);
// make sure we are bound to the main frame buffer
gl.bindFramebuffer(gl.FRAMEBUFFER, null);
if (this.clearBeforeRender) {
if (this.transparent) {
gl.clearColor(0, 0, 0, 0);
}
else {
gl.clearColor(stage.backgroundColorSplit[0],stage.backgroundColorSplit[1],stage.backgroundColorSplit[2], 1);
}
gl.clear (gl.COLOR_BUFFER_BIT);
}
this.renderDisplayObject( stage, this.projection );
};
/**
* Renders a Display Object.
*
* @param displayObject {DisplayObject} The DisplayObject to render
* @param projection {Point} The projection
* @param buffer {Array} a standard WebGL buffer
*/
WebGLRenderer.prototype.renderDisplayObject = function (displayObject, projection, buffer) {
this.renderSession.blendModeManager.setBlendMode(blendModes.NORMAL);
// reset the render session data..
this.renderSession.drawCount = 0;
// make sure to flip the Y if using a render texture..
this.renderSession.flipY = buffer ? -1 : 1;
// set the default projection
this.renderSession.projection = projection;
//set the default offset
this.renderSession.offset = this.offset;
// start the sprite batch
this.spriteBatch.begin(this.renderSession);
// start the filter manager
this.filterManager.begin(this.renderSession, buffer);
// render the scene!
displayObject._renderWebGL(this.renderSession);
// finish the sprite batch
this.spriteBatch.end();
};
/**
* Resizes the webGL view to the specified width and height.
*
* @param width {number} the new width of the webGL view
* @param height {number} the new height of the webGL view
*/
WebGLRenderer.prototype.resize = function (width, height) {
this.width = width * this.resolution;
this.height = height * this.resolution;
this.view.width = this.width;
this.view.height = this.height;
if (this.autoResize) {
this.view.style.width = this.width / this.resolution + 'px';
this.view.style.height = this.height / this.resolution + 'px';
}
this.gl.viewport(0, 0, this.width, this.height);
this.projection.x = this.width / 2 / this.resolution;
this.projection.y = -this.height / 2 / this.resolution;
};
/**
* Updates and Creates a WebGL texture for the renderers context.
*
* @param texture {Texture} the texture to update
*/
WebGLRenderer.prototype.updateTexture = function (texture) {
if (!texture.hasLoaded )return;
var gl = this.gl;
if (!texture._glTextures[gl.id])texture._glTextures[gl.id] = gl.createTexture();
gl.bindTexture(gl.TEXTURE_2D, texture._glTextures[gl.id]);
gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, texture.premultipliedAlpha);
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, texture.source);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, texture.scaleMode === scaleModes.LINEAR ? gl.LINEAR : gl.NEAREST);
if (texture.mipmap && isPowerOfTwo(texture.width, texture.height)) {
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, texture.scaleMode === scaleModes.LINEAR ? gl.LINEAR_MIPMAP_LINEAR : gl.NEAREST_MIPMAP_NEAREST);
gl.generateMipmap(gl.TEXTURE_2D);
}
else {
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, texture.scaleMode === scaleModes.LINEAR ? gl.LINEAR : gl.NEAREST);
}
// reguler...
if (!texture._powerOf2) {
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
}
else {
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT);
}
texture._dirty[gl.id] = false;
return texture._glTextures[gl.id];
};
/**
* Handles a lost webgl context
*
* @param event {Event}
* @private
*/
WebGLRenderer.prototype.handleContextLost = function (event) {
event.preventDefault();
this.contextLost = true;
};
/**
* Handles a restored webgl context
*
* @param event {Event}
* @private
*/
WebGLRenderer.prototype.handleContextRestored = function () {
this.initContext();
// empty all the ol gl textures as they are useless now
for (var key in TextureCache) {
var texture = TextureCache[key].baseTexture;
texture._glTextures = [];
}
this.contextLost = false;
};
/**
* Removes everything from the renderer (event listeners, spritebatch, etc...)
*
*/
WebGLRenderer.prototype.destroy = function () {
// remove listeners
this.view.removeEventListener('webglcontextlost', this.contextLostBound);
this.view.removeEventListener('webglcontextrestored', this.contextRestoredBound);
glContexts[this.glContextId] = null;
this.projection = null;
this.offset = null;
// time to create the render managers! each one focuses on managine a state in webGL
this.shaderManager.destroy();
this.spriteBatch.destroy();
this.maskManager.destroy();
this.filterManager.destroy();
this.shaderManager = null;
this.spriteBatch = null;
this.maskManager = null;
this.filterManager = null;
this.gl = null;
this.renderSession = null;
};
/**
* Maps Pixi blend modes to WebGL blend modes.
*
*/
WebGLRenderer.prototype.mapBlendModes = function () {
var gl = this.gl;
if (!blendModesWebGL) {
blendModesWebGL = [];
blendModesWebGL[blendModes.NORMAL] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
blendModesWebGL[blendModes.ADD] = [gl.SRC_ALPHA, gl.DST_ALPHA];
blendModesWebGL[blendModes.MULTIPLY] = [gl.DST_COLOR, gl.ONE_MINUS_SRC_ALPHA];
blendModesWebGL[blendModes.SCREEN] = [gl.SRC_ALPHA, gl.ONE];
blendModesWebGL[blendModes.OVERLAY] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
blendModesWebGL[blendModes.DARKEN] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
blendModesWebGL[blendModes.LIGHTEN] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
blendModesWebGL[blendModes.COLOR_DODGE] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
blendModesWebGL[blendModes.COLOR_BURN] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
blendModesWebGL[blendModes.HARD_LIGHT] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
blendModesWebGL[blendModes.SOFT_LIGHT] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
blendModesWebGL[blendModes.DIFFERENCE] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
blendModesWebGL[blendModes.EXCLUSION] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
blendModesWebGL[blendModes.HUE] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
blendModesWebGL[blendModes.SATURATION] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
blendModesWebGL[blendModes.COLOR] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
blendModesWebGL[blendModes.LUMINOSITY] = [gl.ONE, gl.ONE_MINUS_SRC_ALPHA];
}
};
WebGLRenderer.glContextId = 0;
