/**

* Processing.js object

*/

module.exports = function(options, undef) {

var defaultScope = options.defaultScope,

extend = options.extend,

Browser = options.Browser,

ajax = Browser.ajax,

navigator = Browser.navigator,

window = Browser.window,

XMLHttpRequest = window.XMLHttpRequest,

document = Browser.document,

noop = options.noop,

PConstants = defaultScope.PConstants;

PFont = defaultScope.PFont,

PShapeSVG = defaultScope.PShapeSVG,

PVector = defaultScope.PVector,

Char = Character = defaultScope.Char,

ObjectIterator = defaultScope.ObjectIterator,

XMLElement = defaultScope.XMLElement,

XML = defaultScope.XML;

// fascinating "read only" jshint error if we don't start a new var block here.

var HTMLCanvasElement = window.HTMLCanvasElement,

HTMLImageElement = window.HTMLImageElement;

// window.localStorage cannot be accessed if a user is blocking cookies.

// In that case, we make it a temporary source cache object.

var localStorage;

try { localStorage = window.localStorage; } catch (e) { localStorage = {}; }

var isDOMPresent = ("document" in this) && !("fake" in this.document);

// document.head polyfill for the benefit of Firefox 3.6

if (!document.head) {

document.head = document.getElementsByTagName('head')[0];

}

var Float32Array = setupTypedArray("Float32Array", "WebGLFloatArray"),

Int32Array = setupTypedArray("Int32Array", "WebGLIntArray"),

Uint16Array = setupTypedArray("Uint16Array", "WebGLUnsignedShortArray"),

Uint8Array = setupTypedArray("Uint8Array", "WebGLUnsignedByteArray");

// Typed Arrays: fallback to WebGL arrays or Native JS arrays if unavailable

function setupTypedArray(name, fallback) {

// Check if TypedArray exists, and use if so.

if (name in window) {

return window[name];

}

// Check if WebGLArray exists

if (typeof window[fallback] === "function") {

return window[fallback];

}

// Use Native JS array

return function(obj) {

if (obj instanceof Array) {

return obj;

}

if (typeof obj === "number") {

var arr = [];

arr.length = obj;

return arr;

}

};

}

/* IE9+ quirks mode check - ticket #1606 */

if (document.documentMode >= 9 && !document.doctype) {

throw("The doctype directive is missing. The recommended doctype in Internet Explorer is the HTML5 doctype: <!DOCTYPE html>");

}

// Manage multiple Processing instances

var processingInstances = [];

var processingInstanceIds = {};

/**

* instance tracking - adding new instances

*/

var addInstance = function(processing) {

if (processing.externals.canvas.id === undef || !processing.externals.canvas.id.length) {

processing.externals.canvas.id = "__processing" + processingInstances.length;

}

processingInstanceIds[processing.externals.canvas.id] = processingInstances.length;

processingInstances.push(processing);

};

/**

* instance tracking - removal

*/

var removeInstance = function(id) {

processingInstances.splice(processingInstanceIds[id], 1);

delete processingInstanceIds[id];

};

/**

* The Processing object

*/

var Processing = this.Processing = function(aCanvas, aCode, aFunctions) {

if (!(this instanceof Processing)) {

throw("called Processing constructor as if it were a function: missing 'new'.");

}

var curElement = {},

pgraphicsMode = (aCanvas === undef && aCode === undef);

if (pgraphicsMode) {

curElement = document.createElement("canvas");

} else {

// We'll take a canvas element or a string for a canvas element's id

curElement = typeof aCanvas === "string" ? document.getElementById(aCanvas) : aCanvas;

}

if (!('getContext' in curElement)) {

throw("called Processing constructor without passing canvas element reference or id.");

}

function unimplemented(s) {

Processing.debug('Unimplemented - ' + s);

}

////////////////////////////////////////////////////////////////////////////

// JavaScript event binding and releasing

////////////////////////////////////////////////////////////////////////////

var eventHandlers = [];

function attachEventHandler(elem, type, fn) {

if (elem.addEventListener) {

elem.addEventListener(type, fn, false);

} else {

elem.attachEvent("on" + type, fn);

}

eventHandlers.push({elem: elem, type: type, fn: fn});

}

function detachEventHandler(eventHandler) {

var elem = eventHandler.elem,

type = eventHandler.type,

fn = eventHandler.fn;

if (elem.removeEventListener) {

elem.removeEventListener(type, fn, false);

} else if (elem.detachEvent) {

elem.detachEvent("on" + type, fn);

}

}

function removeFirstArgument(args) {

return Array.prototype.slice.call(args, 1);

}

// When something new is added to "p." it must also be added to the "names" array.

// The names array contains the names of everything that is inside "p."

var p = this;

p.Char = p.Character = Char;

// add in the Processing API functions

extend.withCommonFunctions(p);

extend.withMath(p);

extend.withProxyFunctions(p, removeFirstArgument);

extend.withTouch(p, curElement, attachEventHandler, document, PConstants);

// custom functions and properties are added here

if(aFunctions) {

Object.keys(aFunctions).forEach(function(name) {

p[name] = aFunctions[name];

});

}

// PJS specific (non-p5) methods and properties to externalize

p.externals = {

canvas: curElement,

context: undef,

sketch: undef,

window: window

};

p.name = 'Processing.js Instance'; // Set Processing defaults / environment variables

p.use3DContext = false; // default '2d' canvas context

/**

* Confirms if a Processing program is "focused", meaning that it is

* active and will accept input from mouse or keyboard. This variable

* is "true" if it is focused and "false" if not. This variable is

* often used when you want to warn people they need to click on the

* browser before it will work.

*/

p.focused = false;

p.breakShape = false;

// Glyph path storage for textFonts

p.glyphTable = {};

// Global vars for tracking mouse position

p.pmouseX = 0;

p.pmouseY = 0;

p.mouseX = 0;

p.mouseY = 0;

p.mouseButton = 0;

p.mouseScroll = 0;

// Undefined event handlers to be replaced by user when needed

p.mouseClicked = undef;

p.mouseDragged = undef;

p.mouseMoved = undef;

p.mousePressed = undef;

p.mouseReleased = undef;

p.mouseScrolled = undef;

p.mouseOver = undef;

p.mouseOut = undef;

p.touchStart = undef;

p.touchEnd = undef;

p.touchMove = undef;

p.touchCancel = undef;

p.key = undef;

p.keyCode = undef;

p.keyPressed = noop; // needed to remove function checks

p.keyReleased = noop;

p.keyTyped = noop;

p.draw = undef;

p.setup = undef;

// Remapped vars

p.__mousePressed = false;

p.__keyPressed = false;

p.__frameRate = 60;

// The current animation frame

p.frameCount = 0;

// The height/width of the canvas

p.width = 100;

p.height = 100;

// "Private" variables used to maintain state

var curContext,

curSketch,

drawing, // hold a Drawing2D or Drawing3D object

doFill = true,

fillStyle = [1.0, 1.0, 1.0, 1.0],

currentFillColor = 0xFFFFFFFF,

isFillDirty = true,

doStroke = true,

strokeStyle = [0.0, 0.0, 0.0, 1.0],

currentStrokeColor = 0xFF000000,

isStrokeDirty = true,

lineWidth = 1,

loopStarted = false,

renderSmooth = false,

doLoop = true,

looping = 0,

curRectMode = PConstants.CORNER,

curEllipseMode = PConstants.CENTER,

normalX = 0,

normalY = 0,

normalZ = 0,

normalMode = PConstants.NORMAL_MODE_AUTO,

curFrameRate = 60,

curMsPerFrame = 1000/curFrameRate,

curCursor = PConstants.ARROW,

oldCursor = curElement.style.cursor,

curShape = PConstants.POLYGON,

curShapeCount = 0,

curvePoints = [],

curTightness = 0,

curveDet = 20,

curveInited = false,

backgroundObj = -3355444, // rgb(204, 204, 204) is the default gray background colour

bezDetail = 20,

colorModeA = 255,

colorModeX = 255,

colorModeY = 255,

colorModeZ = 255,

pathOpen = false,

mouseDragging = false,

pmouseXLastFrame = 0,

pmouseYLastFrame = 0,

curColorMode = PConstants.RGB,

curTint = null,

curTint3d = null,

getLoaded = false,

start = Date.now(),

timeSinceLastFPS = start,

framesSinceLastFPS = 0,

textcanvas,

curveBasisMatrix,

curveToBezierMatrix,

curveDrawMatrix,

bezierDrawMatrix,

bezierBasisInverse,

bezierBasisMatrix,

curContextCache = { attributes: {}, locations: {} },

// Shaders

programObject3D,

programObject2D,

programObjectUnlitShape,

boxBuffer,

boxNormBuffer,

boxOutlineBuffer,

rectBuffer,

rectNormBuffer,

sphereBuffer,

lineBuffer,

fillBuffer,

fillColorBuffer,

strokeColorBuffer,

pointBuffer,

shapeTexVBO,

canTex, // texture for createGraphics

textTex, // texture for 3d tex

curTexture = {width:0,height:0},

curTextureMode = PConstants.IMAGE,

usingTexture = false,

textBuffer,

textureBuffer,

indexBuffer,

// Text alignment

horizontalTextAlignment = PConstants.LEFT,

verticalTextAlignment = PConstants.BASELINE,

textMode = PConstants.MODEL,

// Font state

curFontName = "Arial",

curTextSize = 12,

curTextAscent = 9,

curTextDescent = 2,

curTextLeading = 14,

curTextFont = PFont.get(curFontName, curTextSize),

// Pixels cache

originalContext,

proxyContext = null,

isContextReplaced = false,

setPixelsCached,

maxPixelsCached = 1000,

pressedKeysMap = [],

lastPressedKeyCode = null,

codedKeys = [ PConstants.SHIFT, PConstants.CONTROL, PConstants.ALT, PConstants.CAPSLK, PConstants.PGUP, PConstants.PGDN,

PConstants.END, PConstants.HOME, PConstants.LEFT, PConstants.UP, PConstants.RIGHT, PConstants.DOWN, PConstants.NUMLK,

PConstants.INSERT, PConstants.F1, PConstants.F2, PConstants.F3, PConstants.F4, PConstants.F5, PConstants.F6, PConstants.F7,

PConstants.F8, PConstants.F9, PConstants.F10, PConstants.F11, PConstants.F12, PConstants.META ];

// User can only have MAX_LIGHTS lights

var lightCount = 0;

//sphere stuff

var sphereDetailV = 0,

sphereDetailU = 0,

sphereX = [],

sphereY = [],

sphereZ = [],

sinLUT = new Float32Array(PConstants.SINCOS_LENGTH),

cosLUT = new Float32Array(PConstants.SINCOS_LENGTH),

sphereVerts,

sphereNorms;

// Camera defaults and settings

var cam,

cameraInv,

modelView,

modelViewInv,

userMatrixStack,

userReverseMatrixStack,

inverseCopy,

projection,

manipulatingCamera = false,

frustumMode = false,

cameraFOV = 60 * (Math.PI / 180),

cameraX = p.width / 2,

cameraY = p.height / 2,

cameraZ = cameraY / Math.tan(cameraFOV / 2),

cameraNear = cameraZ / 10,

cameraFar = cameraZ * 10,

cameraAspect = p.width / p.height;

var vertArray = [],

curveVertArray = [],

curveVertCount = 0,

isCurve = false,

isBezier = false,

firstVert = true;

//PShape stuff

var curShapeMode = PConstants.CORNER;

// Stores states for pushStyle() and popStyle().

var styleArray = [];

// The vertices for the box cannot be specified using a triangle strip since each

// side of the cube must have its own set of normals.

// Vertices are specified in a counter-clockwise order.

// Triangles are in this order: back, front, right, bottom, left, top.

var boxVerts = new Float32Array([

0.5, 0.5, -0.5, 0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, 0.5, -0.5, 0.5, 0.5, -0.5,

0.5, 0.5, 0.5, -0.5, 0.5, 0.5, -0.5, -0.5, 0.5, -0.5, -0.5, 0.5, 0.5, -0.5, 0.5, 0.5, 0.5, 0.5,

0.5, 0.5, -0.5, 0.5, 0.5, 0.5, 0.5, -0.5, 0.5, 0.5, -0.5, 0.5, 0.5, -0.5, -0.5, 0.5, 0.5, -0.5,

0.5, -0.5, -0.5, 0.5, -0.5, 0.5, -0.5, -0.5, 0.5, -0.5, -0.5, 0.5, -0.5, -0.5, -0.5, 0.5, -0.5, -0.5,

-0.5, -0.5, -0.5, -0.5, -0.5, 0.5, -0.5, 0.5, 0.5, -0.5, 0.5, 0.5, -0.5, 0.5, -0.5, -0.5, -0.5, -0.5,

0.5, 0.5, 0.5, 0.5, 0.5, -0.5, -0.5, 0.5, -0.5, -0.5, 0.5, -0.5, -0.5, 0.5, 0.5, 0.5, 0.5, 0.5]);

var boxOutlineVerts = new Float32Array([

0.5, 0.5, 0.5, 0.5, -0.5, 0.5, 0.5, 0.5, -0.5, 0.5, -0.5, -0.5,

-0.5, 0.5, -0.5, -0.5, -0.5, -0.5, -0.5, 0.5, 0.5, -0.5, -0.5, 0.5,

0.5, 0.5, 0.5, 0.5, 0.5, -0.5, 0.5, 0.5, -0.5, -0.5, 0.5, -0.5,

-0.5, 0.5, -0.5, -0.5, 0.5, 0.5, -0.5, 0.5, 0.5, 0.5, 0.5, 0.5,

0.5, -0.5, 0.5, 0.5, -0.5, -0.5, 0.5, -0.5, -0.5, -0.5, -0.5, -0.5,

-0.5, -0.5, -0.5, -0.5, -0.5, 0.5, -0.5, -0.5, 0.5, 0.5, -0.5, 0.5]);

var boxNorms = new Float32Array([

0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1,

0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1,

1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0,

0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0,

-1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0,

0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0]);

// These verts are used for the fill and stroke using TRIANGLE_FAN and LINE_LOOP.

var rectVerts = new Float32Array([0,0,0, 0,1,0, 1,1,0, 1,0,0]);

var rectNorms = new Float32Array([0,0,1, 0,0,1, 0,0,1, 0,0,1]);

// Shader for points and lines in begin/endShape.

var vertexShaderSrcUnlitShape =

"varying vec4 vFrontColor;" +

"attribute vec3 aVertex;" +

"attribute vec4 aColor;" +

"uniform mat4 uView;" +

"uniform mat4 uProjection;" +

"uniform float uPointSize;" +

"void main(void) {" +

" vFrontColor = aColor;" +

" gl_PointSize = uPointSize;" +

" gl_Position = uProjection * uView * vec4(aVertex, 1.0);" +

"}";

var fragmentShaderSrcUnlitShape =

"#ifdef GL_ES\n" +

"precision highp float;\n" +

"#endif\n" +

"varying vec4 vFrontColor;" +

"uniform bool uSmooth;" +

"void main(void){" +

" if(uSmooth == true){" +

" float dist = distance(gl_PointCoord, vec2(0.5));" +

" if(dist > 0.5){" +

" discard;" +

" }" +

" }" +

" gl_FragColor = vFrontColor;" +

"}";

// Shader for rect, text, box outlines, sphere outlines, point() and line().

var vertexShaderSrc2D =

"varying vec4 vFrontColor;" +

"attribute vec3 aVertex;" +

"attribute vec2 aTextureCoord;" +

"uniform vec4 uColor;" +

"uniform mat4 uModel;" +

"uniform mat4 uView;" +

"uniform mat4 uProjection;" +

"uniform float uPointSize;" +

"varying vec2 vTextureCoord;"+

"void main(void) {" +

" gl_PointSize = uPointSize;" +

" vFrontColor = uColor;" +

" gl_Position = uProjection * uView * uModel * vec4(aVertex, 1.0);" +

" vTextureCoord = aTextureCoord;" +

"}";

var fragmentShaderSrc2D =

"#ifdef GL_ES\n" +

"precision highp float;\n" +

"#endif\n" +

"varying vec4 vFrontColor;" +

"varying vec2 vTextureCoord;"+

"uniform sampler2D uSampler;"+

"uniform int uIsDrawingText;"+

"uniform bool uSmooth;" +

"void main(void){" +

// WebGL does not support POINT_SMOOTH, so we do it ourselves

" if(uSmooth == true){" +

" float dist = distance(gl_PointCoord, vec2(0.5));" +

" if(dist > 0.5){" +

" discard;" +

" }" +

" }" +

" if(uIsDrawingText == 1){" +

" float alpha = texture2D(uSampler, vTextureCoord).a;"+

" gl_FragColor = vec4(vFrontColor.rgb * alpha, alpha);"+

" }" +

" else{" +

" gl_FragColor = vFrontColor;" +

" }" +

"}";

var webglMaxTempsWorkaround = /Windows/.test(navigator.userAgent);

// Vertex shader for boxes and spheres.

var vertexShaderSrc3D =

"varying vec4 vFrontColor;" +

"attribute vec3 aVertex;" +

"attribute vec3 aNormal;" +

"attribute vec4 aColor;" +

"attribute vec2 aTexture;" +

"varying vec2 vTexture;" +

"uniform vec4 uColor;" +

"uniform bool uUsingMat;" +

"uniform vec3 uSpecular;" +

"uniform vec3 uMaterialEmissive;" +

"uniform vec3 uMaterialAmbient;" +

"uniform vec3 uMaterialSpecular;" +

"uniform float uShininess;" +

"uniform mat4 uModel;" +

"uniform mat4 uView;" +

"uniform mat4 uProjection;" +

"uniform mat4 uNormalTransform;" +

"uniform int uLightCount;" +

"uniform vec3 uFalloff;" +

// Careful changing the order of these fields. Some cards

// have issues with memory alignment.

"struct Light {" +

" int type;" +

" vec3 color;" +

" vec3 position;" +

" vec3 direction;" +

" float angle;" +

" vec3 halfVector;" +

" float concentration;" +

"};" +

// nVidia cards have issues with arrays of structures

// so instead we create 8 instances of Light.

"uniform Light uLights0;" +

"uniform Light uLights1;" +

"uniform Light uLights2;" +

"uniform Light uLights3;" +

"uniform Light uLights4;" +

"uniform Light uLights5;" +

"uniform Light uLights6;" +

"uniform Light uLights7;" +

// GLSL does not support switch.

"Light getLight(int index){" +

" if(index == 0) return uLights0;" +

" if(index == 1) return uLights1;" +

" if(index == 2) return uLights2;" +

" if(index == 3) return uLights3;" +

" if(index == 4) return uLights4;" +

" if(index == 5) return uLights5;" +

" if(index == 6) return uLights6;" +

// Do not use a conditional for the last return statement

// because some video cards will fail and complain that

// "not all paths return".

" return uLights7;" +

"}" +

"void AmbientLight( inout vec3 totalAmbient, in vec3 ecPos, in Light light ) {" +

// Get the vector from the light to the vertex and

// get the distance from the current vector to the light position.

" float d = length( light.position - ecPos );" +

" float attenuation = 1.0 / ( uFalloff[0] + ( uFalloff[1] * d ) + ( uFalloff[2] * d * d ));" +

" totalAmbient += light.color * attenuation;" +

"}" +

/*

col - accumulated color

spec - accumulated specular highlight

vertNormal - Normal of the vertex

ecPos - eye coordinate position

light - light structure

*/

"void DirectionalLight( inout vec3 col, inout vec3 spec, in vec3 vertNormal, in vec3 ecPos, in Light light ) {" +

" float powerFactor = 0.0;" +

" float nDotVP = max(0.0, dot( vertNormal, normalize(-light.position) ));" +

" float nDotVH = max(0.0, dot( vertNormal, normalize(-light.position-normalize(ecPos) )));" +

" if( nDotVP != 0.0 ){" +

" powerFactor = pow( nDotVH, uShininess );" +

" }" +

" col += light.color * nDotVP;" +

" spec += uSpecular * powerFactor;" +

"}" +

/*

col - accumulated color

spec - accumulated specular highlight

vertNormal - Normal of the vertex

ecPos - eye coordinate position

light - light structure

*/

"void PointLight( inout vec3 col, inout vec3 spec, in vec3 vertNormal, in vec3 ecPos, in Light light ) {" +

" float powerFactor;" +

// Get the vector from the light to the vertex.

" vec3 VP = light.position - ecPos;" +

// Get the distance from the current vector to the light position.

" float d = length( VP ); " +

// Normalize the light ray so it can be used in the dot product operation.

" VP = normalize( VP );" +

" float attenuation = 1.0 / ( uFalloff[0] + ( uFalloff[1] * d ) + ( uFalloff[2] * d * d ));" +

" float nDotVP = max( 0.0, dot( vertNormal, VP ));" +

" vec3 halfVector = normalize( VP - normalize(ecPos) );" +

" float nDotHV = max( 0.0, dot( vertNormal, halfVector ));" +

" if( nDotVP == 0.0 ) {" +

" powerFactor = 0.0;" +

" }" +

" else {" +

" powerFactor = pow( nDotHV, uShininess );" +

" }" +

" spec += uSpecular * powerFactor * attenuation;" +

" col += light.color * nDotVP * attenuation;" +

"}" +

/*

col - accumulated color

spec - accumulated specular highlight

vertNormal - Normal of the vertex

ecPos - eye coordinate position

light - light structure

*/

"void SpotLight( inout vec3 col, inout vec3 spec, in vec3 vertNormal, in vec3 ecPos, in Light light ) {" +

" float spotAttenuation;" +

" float powerFactor = 0.0;" +

// Calculate the vector from the current vertex to the light.

" vec3 VP = light.position - ecPos;" +

" vec3 ldir = normalize( -light.direction );" +

// Get the distance from the spotlight and the vertex

" float d = length( VP );" +

" VP = normalize( VP );" +

" float attenuation = 1.0 / ( uFalloff[0] + ( uFalloff[1] * d ) + ( uFalloff[2] * d * d ) );" +

// Dot product of the vector from vertex to light and light direction.

" float spotDot = dot( VP, ldir );" +

// If the vertex falls inside the cone

(webglMaxTempsWorkaround ? // Windows reports max temps error if light.angle is used

" spotAttenuation = 1.0; " :

" if( spotDot > cos( light.angle ) ) {" +

" spotAttenuation = pow( spotDot, light.concentration );" +

" }" +

" else{" +

" spotAttenuation = 0.0;" +

" }" +

" attenuation *= spotAttenuation;" +

"") +

" float nDotVP = max( 0.0, dot( vertNormal, VP ) );" +

" vec3 halfVector = normalize( VP - normalize(ecPos) );" +

" float nDotHV = max( 0.0, dot( vertNormal, halfVector ) );" +

" if( nDotVP != 0.0 ) {" +

" powerFactor = pow( nDotHV, uShininess );" +

" }" +

" spec += uSpecular * powerFactor * attenuation;" +

" col += light.color * nDotVP * attenuation;" +

"}" +

"void main(void) {" +

" vec3 finalAmbient = vec3( 0.0 );" +

" vec3 finalDiffuse = vec3( 0.0 );" +

" vec3 finalSpecular = vec3( 0.0 );" +

" vec4 col = uColor;" +

" if ( uColor[0] == -1.0 ){" +

" col = aColor;" +

" }" +

// We use the sphere vertices as the normals when we create the sphere buffer.

// But this only works if the sphere vertices are unit length, so we

// have to normalize the normals here. Since this is only required for spheres

// we could consider placing this in a conditional later on.

" vec3 norm = normalize(vec3( uNormalTransform * vec4( aNormal, 0.0 ) ));" +

" vec4 ecPos4 = uView * uModel * vec4(aVertex, 1.0);" +

" vec3 ecPos = (vec3(ecPos4))/ecPos4.w;" +

// If there were no lights this draw call, just use the

// assigned fill color of the shape and the specular value.

" if( uLightCount == 0 ) {" +

" vFrontColor = col + vec4(uMaterialSpecular, 1.0);" +

" }" +

" else {" +

// WebGL forces us to iterate over a constant value

// so we can't iterate using lightCount.

" for( int i = 0; i < 8; i++ ) {" +

" Light l = getLight(i);" +

// We can stop iterating if we know we have gone past

// the number of lights which are actually on. This gives us a

// significant performance increase with high vertex counts.

" if( i >= uLightCount ){" +

" break;" +

" }" +

" if( l.type == 0 ) {" +

" AmbientLight( finalAmbient, ecPos, l );" +

" }" +

" else if( l.type == 1 ) {" +

" DirectionalLight( finalDiffuse, finalSpecular, norm, ecPos, l );" +

" }" +

" else if( l.type == 2 ) {" +

" PointLight( finalDiffuse, finalSpecular, norm, ecPos, l );" +

" }" +

" else {" +

" SpotLight( finalDiffuse, finalSpecular, norm, ecPos, l );" +

" }" +

" }" +

" if( uUsingMat == false ) {" +

" vFrontColor = vec4(" +

" vec3( col ) * finalAmbient +" +

" vec3( col ) * finalDiffuse +" +

" vec3( col ) * finalSpecular," +

" col[3] );" +

" }" +

" else{" +

" vFrontColor = vec4( " +

" uMaterialEmissive + " +

" (vec3(col) * uMaterialAmbient * finalAmbient ) + " +

" (vec3(col) * finalDiffuse) + " +

" (uMaterialSpecular * finalSpecular), " +

" col[3] );" +

" }" +

" }" +

" vTexture.xy = aTexture.xy;" +

" gl_Position = uProjection * uView * uModel * vec4( aVertex, 1.0 );" +

"}";

var fragmentShaderSrc3D =

"#ifdef GL_ES\n" +

"precision highp float;\n" +

"#endif\n" +

"varying vec4 vFrontColor;" +

"uniform sampler2D uSampler;" +

"uniform bool uUsingTexture;" +

"varying vec2 vTexture;" +

// In Processing, when a texture is used, the fill color is ignored

// vec4(1.0,1.0,1.0,0.5)

"void main(void){" +

" if( uUsingTexture ){" +

" gl_FragColor = vec4(texture2D(uSampler, vTexture.xy)) * vFrontColor;" +

" }"+

" else{" +

" gl_FragColor = vFrontColor;" +

" }" +

"}";

////////////////////////////////////////////////////////////////////////////

// 3D Functions

////////////////////////////////////////////////////////////////////////////

/*

* Sets a uniform variable in a program object to a particular

* value. Before calling this function, ensure the correct

* program object has been installed as part of the current

* rendering state by calling useProgram.

*

* On some systems, if the variable exists in the shader but isn't used,

* the compiler will optimize it out and this function will fail.

*

* @param {String} cacheId

* @param {WebGLProgram} programObj program object returned from

* createProgramObject

* @param {String} varName the name of the variable in the shader

* @param {float | Array} varValue either a scalar value or an Array

*

* @returns none

*

* @see uniformi

* @see uniformMatrix

*/

function uniformf(cacheId, programObj, varName, varValue) {

var varLocation = curContextCache.locations[cacheId];

if(varLocation === undef) {

varLocation = curContext.getUniformLocation(programObj, varName);

curContextCache.locations[cacheId] = varLocation;

}

// the variable won't be found if it was optimized out.

if (varLocation !== null) {

if (varValue.length === 4) {

curContext.uniform4fv(varLocation, varValue);

} else if (varValue.length === 3) {

curContext.uniform3fv(varLocation, varValue);

} else if (varValue.length === 2) {

curContext.uniform2fv(varLocation, varValue);

} else {

curContext.uniform1f(varLocation, varValue);

}

}

}

/**

* Sets a uniform int or int array in a program object to a particular

* value. Before calling this function, ensure the correct

* program object has been installed as part of the current

* rendering state.

*

* On some systems, if the variable exists in the shader but isn't used,

* the compiler will optimize it out and this function will fail.

*

* @param {String} cacheId

* @param {WebGLProgram} programObj program object returned from

* createProgramObject

* @param {String} varName the name of the variable in the shader

* @param {int | Array} varValue either a scalar value or an Array

*

* @returns none

*

* @see uniformf

* @see uniformMatrix

*/

function uniformi(cacheId, programObj, varName, varValue) {

var varLocation = curContextCache.locations[cacheId];

if(varLocation === undef) {

varLocation = curContext.getUniformLocation(programObj, varName);

curContextCache.locations[cacheId] = varLocation;

}

// the variable won't be found if it was optimized out.

if (varLocation !== null) {

if (varValue.length === 4) {

curContext.uniform4iv(varLocation, varValue);

} else if (varValue.length === 3) {

curContext.uniform3iv(varLocation, varValue);

} else if (varValue.length === 2) {

curContext.uniform2iv(varLocation, varValue);

} else {

curContext.uniform1i(varLocation, varValue);

}

}

}

/**

* Sets the value of a uniform matrix variable in a program

* object. Before calling this function, ensure the correct

* program object has been installed as part of the current

* rendering state.

*

* On some systems, if the variable exists in the shader but

* isn't used, the compiler will optimize it out and this

* function will fail.

*

* @param {String} cacheId

* @param {WebGLProgram} programObj program object returned from

* createProgramObject

* @param {String} varName the name of the variable in the shader

* @param {boolean} transpose must be false

* @param {Array} matrix an array of 4, 9 or 16 values

*

* @returns none

*

* @see uniformi

* @see uniformf

*/

function uniformMatrix(cacheId, programObj, varName, transpose, matrix) {

var varLocation = curContextCache.locations[cacheId];

if(varLocation === undef) {

varLocation = curContext.getUniformLocation(programObj, varName);

curContextCache.locations[cacheId] = varLocation;

}

// The variable won't be found if it was optimized out.

if (varLocation !== -1) {

if (matrix.length === 16) {

curContext.uniformMatrix4fv(varLocation, transpose, matrix);

} else if (matrix.length === 9) {

curContext.uniformMatrix3fv(varLocation, transpose, matrix);

} else {

curContext.uniformMatrix2fv(varLocation, transpose, matrix);

}

}

}

/**

* Binds the VBO, sets the vertex attribute data for the program

* object and enables the attribute.

*

* On some systems, if the attribute exists in the shader but

* isn't used, the compiler will optimize it out and this

* function will fail.

*

* @param {String} cacheId

* @param {WebGLProgram} programObj program object returned from

* createProgramObject

* @param {String} varName the name of the variable in the shader

* @param {int} size the number of components per vertex attribute

* @param {WebGLBuffer} VBO Vertex Buffer Object

*

* @returns none

*

* @see disableVertexAttribPointer

*/

function vertexAttribPointer(cacheId, programObj, varName, size, VBO) {

var varLocation = curContextCache.attributes[cacheId];

if(varLocation === undef) {

varLocation = curContext.getAttribLocation(programObj, varName);

curContextCache.attributes[cacheId] = varLocation;

}

if (varLocation !== -1) {

curContext.bindBuffer(curContext.ARRAY_BUFFER, VBO);

curContext.vertexAttribPointer(varLocation, size, curContext.FLOAT, false, 0, 0);

curContext.enableVertexAttribArray(varLocation);

}

}

/**

* Disables a program object attribute from being sent to WebGL.

*

* @param {String} cacheId

* @param {WebGLProgram} programObj program object returned from

* createProgramObject

* @param {String} varName name of the attribute

*

* @returns none

*

* @see vertexAttribPointer

*/

function disableVertexAttribPointer(cacheId, programObj, varName){

var varLocation = curContextCache.attributes[cacheId];

if(varLocation === undef) {

varLocation = curContext.getAttribLocation(programObj, varName);

curContextCache.attributes[cacheId] = varLocation;

}

if (varLocation !== -1) {

curContext.disableVertexAttribArray(varLocation);

}

}

/**

* Creates a WebGL program object.

*

* @param {String} vetexShaderSource

* @param {String} fragmentShaderSource

*

* @returns {WebGLProgram} A program object

*/

var createProgramObject = function(curContext, vetexShaderSource, fragmentShaderSource) {

var vertexShaderObject = curContext.createShader(curContext.VERTEX_SHADER);

curContext.shaderSource(vertexShaderObject, vetexShaderSource);

curContext.compileShader(vertexShaderObject);

if (!curContext.getShaderParameter(vertexShaderObject, curContext.COMPILE_STATUS)) {

throw curContext.getShaderInfoLog(vertexShaderObject);

}

var fragmentShaderObject = curContext.createShader(curContext.FRAGMENT_SHADER);

curContext.shaderSource(fragmentShaderObject, fragmentShaderSource);

curContext.compileShader(fragmentShaderObject);

if (!curContext.getShaderParameter(fragmentShaderObject, curContext.COMPILE_STATUS)) {

throw curContext.getShaderInfoLog(fragmentShaderObject);

}

var programObject = curContext.createProgram();

curContext.attachShader(programObject, vertexShaderObject);

curContext.attachShader(programObject, fragmentShaderObject);

curContext.linkProgram(programObject);

if (!curContext.getProgramParameter(programObject, curContext.LINK_STATUS)) {

throw "Error linking shaders.";

}

return programObject;

};

////////////////////////////////////////////////////////////////////////////

// 2D/3D drawing handling

////////////////////////////////////////////////////////////////////////////