/* P R O C E S S I N G . J S - 0.9.4 a port of the Processing visualization language License : MIT Developer : John Resig: http://ejohn.org Web Site : http://processingjs.org Java Version : http://processing.org Github Repo. : http://github.com/jeresig/processing-js Bug Tracking : http://processing-js.lighthouseapp.com Mozilla POW! : http://wiki.Mozilla.org/Education/Projects/ProcessingForTheWeb Maintained by : Seneca: http://zenit.senecac.on.ca/wiki/index.php/Processing.js Hyper-Metrix: http://hyper-metrix.com/#Processing BuildingSky: http://weare.buildingsky.net/pages/processing-js */ (function() { // IE Unfriendly AJAX Method var ajax = function(url) { var AJAX = new window.XMLHttpRequest(); if (AJAX) { AJAX.open("GET", url + "?t=" + new Date().getTime(), false); AJAX.send(null); return AJAX.responseText; } else { return false; } }; var Processing = this.Processing = function Processing(curElement, aCode) { var p = this; p.pjs = { imageCache: { // by default we have an empty imageCache pending: 0 }, crispLines: false }; p.name = 'Processing.js Instance'; // Set Processing defaults / environment variables p.use3DContext = false; // default '2d' canvas context p.canvas = curElement; // 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 = undefined; p.mouseDragged = undefined; p.mouseMoved = undefined; p.mousePressed = undefined; p.mouseReleased = undefined; p.mouseScrolled = undefined; p.key = undefined; p.keyCode = undefined; p.keyPressed = undefined; p.keyReleased = undefined; p.keyTyped = undefined; p.draw = undefined; p.setup = undefined; // Remapped vars p.__mousePressed = false; p.__keyPressed = false; p.__frameRate = 0; // The current animation frame p.frameCount = 0; // The height/width of the canvas p.width = curElement.width - 0; p.height = curElement.height - 0; // Color modes p.RGB = 1; p.ARGB = 2; p.HSB = 3; p.ALPHA = 4; p.CMYK = 5; // Renderers p.P2D = 1; p.JAVA2D = 1; p.WEBGL = 2; p.P3D = 2; p.OPENGL = 2; p.EPSILON = 0.0001; p.MAX_FLOAT = 3.4028235e+38; p.MIN_FLOAT = -3.4028235e+38; p.MAX_INT = 2147483647; p.MIN_INT = -2147483648; p.PI = Math.PI; p.TWO_PI = 2 * p.PI; p.HALF_PI = p.PI / 2; p.THIRD_PI = p.PI / 3; p.QUARTER_PI = p.PI / 4; p.DEG_TO_RAD = p.PI / 180; p.RAD_TO_DEG = 180 / p.PI; p.WHITESPACE = " \t\n\r\f\u00A0"; // Filter/convert types p.BLUR = 11; p.GRAY = 12; p.INVERT = 13; p.OPAQUE = 14; p.POSTERIZE = 15; p.THRESHOLD = 16; p.ERODE = 17; p.DILATE = 18; // Blend modes p.REPLACE = 0; p.BLEND = 1 << 0; p.ADD = 1 << 1; p.SUBTRACT = 1 << 2; p.LIGHTEST = 1 << 3; p.DARKEST = 1 << 4; p.DIFFERENCE = 1 << 5; p.EXCLUSION = 1 << 6; p.MULTIPLY = 1 << 7; p.SCREEN = 1 << 8; p.OVERLAY = 1 << 9; p.HARD_LIGHT = 1 << 10; p.SOFT_LIGHT = 1 << 11; p.DODGE = 1 << 12; p.BURN = 1 << 13; // Color component bit masks p.ALPHA_MASK = 0xff000000; p.RED_MASK = 0x00ff0000; p.GREEN_MASK = 0x0000ff00; p.BLUE_MASK = 0x000000ff; // Projection matrices p.CUSTOM = 0; p.ORTHOGRAPHIC = 2; p.PERSPECTIVE = 3; // Shapes p.POINT = 2; p.POINTS = 2; p.LINE = 4; p.LINES = 4; p.TRIANGLE = 8; p.TRIANGLES = 9; p.TRIANGLE_STRIP = 10; p.TRIANGLE_FAN = 11; p.QUAD = 16; p.QUADS = 16; p.QUAD_STRIP = 17; p.POLYGON = 20; p.PATH = 21; p.RECT = 30; p.ELLIPSE = 31; p.ARC = 32; p.SPHERE = 40; p.BOX = 41; // Shape closing modes p.OPEN = 1; p.CLOSE = 2; // Shape drawing modes p.CORNER = 0; // Draw mode convention to use (x, y) to (width, height) p.CORNERS = 1; // Draw mode convention to use (x1, y1) to (x2, y2) coordinates p.RADIUS = 2; // Draw mode from the center, and using the radius p.CENTER_RADIUS = 2; // Deprecated! Use RADIUS instead p.CENTER = 3; // Draw from the center, using second pair of values as the diameter p.DIAMETER = 3; // Synonym for the CENTER constant. Draw from the center p.CENTER_DIAMETER = 3; // Deprecated! Use DIAMETER instead // Text vertical alignment modes p.BASELINE = 0; // Default vertical alignment for text placement p.TOP = 101; // Align text to the top p.BOTTOM = 102; // Align text from the bottom, using the baseline // UV Texture coordinate modes p.NORMAL = 1; p.NORMALIZED = 1; p.IMAGE = 2; // Text placement modes p.MODEL = 4; p.SHAPE = 5; // Stroke modes p.SQUARE = 'butt'; p.ROUND = 'round'; p.PROJECT = 'square'; p.MITER = 'miter'; p.BEVEL = 'bevel'; // Lighting modes p.AMBIENT = 0; p.DIRECTIONAL = 1; //POINT = 2; Shared with Shape constant p.SPOT = 3; // Key constants // Both key and keyCode will be equal to these values p.BACKSPACE = 8; p.TAB = 9; p.ENTER = 10; p.RETURN = 13; p.ESC = 27; p.DELETE = 127; p.CODED = 0xffff; // p.key will be CODED and p.keyCode will be this value p.SHIFT = 16; p.CONTROL = 17; p.ALT = 18; p.UP = 38; p.RIGHT = 39; p.DOWN = 40; p.LEFT = 37; var codedKeys = [p.SHIFT, p.CONTROL, p.ALT, p.UP, p.RIGHT, p.DOWN, p.LEFT]; // Cursor types p.ARROW = 'default'; p.CROSS = 'crosshair'; p.HAND = 'pointer'; p.MOVE = 'move'; p.TEXT = 'text'; p.WAIT = 'wait'; p.NOCURSOR = "url('data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw=='), auto"; // Hints p.DISABLE_OPENGL_2X_SMOOTH = 1; p.ENABLE_OPENGL_2X_SMOOTH = -1; p.ENABLE_OPENGL_4X_SMOOTH = 2; p.ENABLE_NATIVE_FONTS = 3; p.DISABLE_DEPTH_TEST = 4; p.ENABLE_DEPTH_TEST = -4; p.ENABLE_DEPTH_SORT = 5; p.DISABLE_DEPTH_SORT = -5; p.DISABLE_OPENGL_ERROR_REPORT = 6; p.ENABLE_OPENGL_ERROR_REPORT = -6; p.ENABLE_ACCURATE_TEXTURES = 7; p.DISABLE_ACCURATE_TEXTURES = -7; p.HINT_COUNT = 10; // PJS defined constants p.SINCOS_LENGTH = parseInt(360 / 0.5, 10); p.PRECISIONB = 15; // fixed point precision is limited to 15 bits!! p.PRECISIONF = 1 << p.PRECISIONB; p.PREC_MAXVAL = p.PRECISIONF - 1; p.PREC_ALPHA_SHIFT = 24 - p.PRECISIONB; p.PREC_RED_SHIFT = 16 - p.PRECISIONB; p.NORMAL_MODE_AUTO = 0; p.NORMAL_MODE_SHAPE = 1; p.NORMAL_MODE_VERTEX = 2; p.MAX_LIGHTS = 8; p.focused = true; // "Private" variables used to maintain state var curContext, online = true, doFill = true, fillStyle = [1.0, 1.0, 1.0, 1.0], currentFillColor = 0xFFFFFFFF, isFillDirty = true, doStroke = true, strokeStyle = [0.8, 0.8, 0.8, 1.0], currentStrokeColor = 0xFFFDFDFD, isStrokeDirty = true, lineWidth = 1, loopStarted = false, refreshBackground = function() {}, doLoop = true, looping = 0, curRectMode = p.CORNER, curEllipseMode = p.CENTER, normalX = 0, normalY = 0, normalZ = 0, normalMode = p.NORMAL_MODE_AUTO, inDraw = false, curFrameRate = 60, curCursor = p.ARROW, oldCursor = curElement.style.cursor, curMsPerFrame = 1, curShape = p.POLYGON, curShapeCount = 0, curvePoints = [], curTightness = 0, curveDet = 20, curveInited = false, bezDetail = 20, colorModeA = 255, colorModeX = 255, colorModeY = 255, colorModeZ = 255, pathOpen = false, mouseDragging = false, curColorMode = p.RGB, curTint = function() {}, curTextSize = 12, curTextFont = "Arial", getLoaded = false, start = new Date().getTime(), timeSinceLastFPS = start, framesSinceLastFPS = 0, textcanvas, curveBasisMatrix, curveToBezierMatrix, curveDrawMatrix, bezierDrawMatrix, bezierBasisInverse, bezierBasisMatrix, // Shaders programObject3D, programObject2D, programObjectUnlitShape, boxBuffer, boxNormBuffer, boxOutlineBuffer, rectBuffer, rectNormBuffer, sphereBuffer, lineBuffer, fillBuffer, fillColorBuffer, strokeColorBuffer, pointBuffer, shapeTexVBO, curTexture = {width:0,height:0}, curTextureMode = p.IMAGE, usingTexture = false, textBuffer, textureBuffer, indexBuffer, // Pixels cache originalContext, proxyContext = null, isContextReplaced = false, setPixelsCached, maxPixelsCached = 1000; // Work-around for Minefield. using ctx.VERTEX_PROGRAM_POINT_SIZE // in Minefield does nothing and does not report any errors. var VERTEX_PROGRAM_POINT_SIZE = 0x8642; var POINT_SMOOTH = 0x0B10; // Get padding and border style widths for mouse offsets var stylePaddingLeft, stylePaddingTop, styleBorderLeft, styleBorderTop; if (document.defaultView && document.defaultView.getComputedStyle) { stylePaddingLeft = parseInt(document.defaultView.getComputedStyle(curElement, null)['paddingLeft'], 10) || 0; stylePaddingTop = parseInt(document.defaultView.getComputedStyle(curElement, null)['paddingTop'], 10) || 0; styleBorderLeft = parseInt(document.defaultView.getComputedStyle(curElement, null)['borderLeftWidth'], 10) || 0; styleBorderTop = parseInt(document.defaultView.getComputedStyle(curElement, null)['borderTopWidth'], 10) || 0; } // User can only have MAX_LIGHTS lights var lightCount = 0; //sphere stuff var sphereDetailV = 0, sphereDetailU = 0, sphereX = [], sphereY = [], sphereZ = [], sinLUT = new Array(p.SINCOS_LENGTH), cosLUT = new Array(p.SINCOS_LENGTH), sphereVerts, sphereNorms; // Camera defaults and settings var cam, cameraInv, forwardTransform, reverseTransform, modelView, modelViewInv, userMatrixStack, inverseCopy, projection, manipulatingCamera = false, frustumMode = false, cameraFOV = 60 * (Math.PI / 180), cameraX = curElement.width / 2, cameraY = curElement.height / 2, cameraZ = cameraY / Math.tan(cameraFOV / 2), cameraNear = cameraZ / 10, cameraFar = cameraZ * 10, cameraAspect = curElement.width / curElement.height; var vertArray = [], curveVertArray = [], curveVertCount = 0, isCurve = false, isBezier = false, firstVert = true; // Stores states for pushStyle() and popStyle(). var styleArray = new Array(0); // Vertices are specified in a counter-clockwise order // triangles are in this order: back, front, right, bottom, left, top var boxVerts = [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 boxNorms = [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]; var boxOutlineVerts = [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]; // These verts are used for the fill and stroke using TRIANGLE_FAN and LINE_LOOP var rectVerts = [0,0,0, 0,1,0, 1,1,0, 1,0,0]; var rectNorms = [0,0,-1, 0,0,-1, 0,0,-1, 0,0,-1]; // Vertex shader for points and lines var vShaderSrcUnlitShape = "attribute vec3 aVertex;" + "attribute vec4 aColor;" + "uniform mat4 uView;" + "uniform mat4 uProjection;" + "void main(void) {" + " gl_FrontColor = aColor;" + " gl_Position = uProjection * uView * vec4(aVertex, 1.0);" + "}"; var fShaderSrcUnlitShape = "void main(void){" + " gl_FragColor = gl_Color;" + "}"; // Vertex shader for points and lines var vertexShaderSource2D = "attribute vec3 Vertex;" + "attribute vec2 aTextureCoord;" + "uniform vec4 color;" + "uniform mat4 model;" + "uniform mat4 view;" + "uniform mat4 projection;" + "uniform float pointSize;" + "varying vec2 vTextureCoord;"+ "void main(void) {" + " gl_PointSize = pointSize;" + " gl_FrontColor = color;" + " gl_Position = projection * view * model * vec4(Vertex, 1.0);" + " vTextureCoord = aTextureCoord;" + "}"; var fragmentShaderSource2D = "varying vec2 vTextureCoord;"+ "uniform vec4 color;"+ "uniform sampler2D uSampler;"+ "uniform int picktype;"+ "void main(void){" + " if(picktype==0){"+ " gl_FragColor = color;" + " }else if(picktype==1){"+ " float alpha = texture2D(uSampler,vTextureCoord).a;"+ " gl_FragColor = vec4(color.rgb*alpha,alpha);\n"+ " }"+ "}"; // Vertex shader for boxes and spheres var vertexShaderSource3D = "attribute vec3 Vertex;" + "attribute vec3 Normal;" + "attribute vec4 aColor;" + "attribute vec2 aTexture;" + "varying vec2 vTexture;" + "uniform vec4 color;" + "uniform bool usingMat;" + "uniform vec3 specular;" + "uniform vec3 mat_emissive;" + "uniform vec3 mat_ambient;" + "uniform vec3 mat_specular;" + "uniform float shininess;" + "uniform mat4 model;" + "uniform mat4 view;" + "uniform mat4 projection;" + "uniform mat4 normalTransform;" + "uniform int lightCount;" + "uniform vec3 falloff;" + "struct Light {" + " bool dummy;" + " int type;" + " vec3 color;" + " vec3 position;" + " vec3 direction;" + " float angle;" + " vec3 halfVector;" + " float concentration;" + "};" + "uniform Light lights[8];" + "void AmbientLight( inout vec3 totalAmbient, in vec3 ecPos, in Light light ) {" + // Get the vector from the light to the vertex // Get the distance from the current vector to the light position " float d = length( light.position - ecPos );" + " float attenuation = 1.0 / ( falloff[0] + ( falloff[1] * d ) + ( falloff[2] * d * d ));" + " totalAmbient += light.color * attenuation;" + "}" + "void DirectionalLight( inout vec3 col, in vec3 ecPos, inout vec3 spec, in vec3 vertNormal, in Light light ) {" + " float powerfactor = 0.0;" + " float nDotVP = max(0.0, dot( vertNormal, light.position ));" + " float nDotVH = max(0.0, dot( vertNormal, normalize( light.position-ecPos )));" + " if( nDotVP != 0.0 ){" + " powerfactor = pow( nDotVH, shininess );" + " }" + " col += light.color * nDotVP;" + " spec += specular * powerfactor;" + "}" + "void PointLight( inout vec3 col, inout vec3 spec, in vec3 vertNormal, in vec3 ecPos, in vec3 eye, 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 / ( falloff[0] + ( falloff[1] * d ) + ( falloff[2] * d * d ));" + " float nDotVP = max( 0.0, dot( vertNormal, VP ));" + " vec3 halfVector = normalize( VP + eye );" + " float nDotHV = max( 0.0, dot( vertNormal, halfVector ));" + " if( nDotVP == 0.0) {" + " powerfactor = 0.0;" + " }" + " else{" + " powerfactor = pow( nDotHV, shininess );" + " }" + " spec += specular * powerfactor * attenuation;" + " col += light.color * nDotVP * attenuation;" + "}" + /* */ "void SpotLight( inout vec3 col, inout vec3 spec, in vec3 vertNormal, in vec3 ecPos, in vec3 eye, in Light light ) {" + " float spotAttenuation;" + " float powerfactor;" + // 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 / ( falloff[0] + ( falloff[1] * d ) + ( falloff[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 " if( spotDot < cos( light.angle ) ) {" + " spotAttenuation = pow( spotDot, light.concentration );" + " }" + " else{" + " spotAttenuation = 1.0;" + " }" + " attenuation *= spotAttenuation;" + " float nDotVP = max( 0.0, dot( vertNormal, VP ));" + " vec3 halfVector = normalize( VP + eye );" + " float nDotHV = max( 0.0, dot( vertNormal, halfVector ));" + " if( nDotVP == 0.0 ) {" + " powerfactor = 0.0;" + " }" + " else {" + " powerfactor = pow( nDotHV, shininess );" + " }" + " spec += specular * powerfactor * attenuation;" + " col += light.color * nDotVP * attenuation;" + "}" + "void main(void) {" + " vec3 finalAmbient = vec3( 0.0, 0.0, 0.0 );" + " vec3 finalDiffuse = vec3( 0.0, 0.0, 0.0 );" + " vec3 finalSpecular = vec3( 0.0, 0.0, 0.0 );" + " vec4 col = color;" + " if(color[0] == -1.0){" + " col = aColor;" + " }" + " vec3 norm = vec3( normalTransform * vec4( Normal, 0.0 ) );" + " vec4 ecPos4 = view * model * vec4(Vertex,1.0);" + " vec3 ecPos = (vec3(ecPos4))/ecPos4.w;" + " vec3 eye = vec3( 0.0, 0.0, 1.0 );" + // If there were no lights this draw call, just use the // assigned fill color of the shape and the specular value " if( lightCount == 0 ) {" + " gl_FrontColor = col + vec4(mat_specular,1.0);" + " }" + " else {" + " for( int i = 0; i < lightCount; i++ ) {" + " if( lights[i].type == 0 ) {" + " AmbientLight( finalAmbient, ecPos, lights[i] );" + " }" + " else if( lights[i].type == 1 ) {" + " DirectionalLight( finalDiffuse,ecPos, finalSpecular, norm, lights[i] );" + " }" + " else if( lights[i].type == 2 ) {" + " PointLight( finalDiffuse, finalSpecular, norm, ecPos, eye, lights[i] );" + " }" + " else if( lights[i].type == 3 ) {" + " SpotLight( finalDiffuse, finalSpecular, norm, ecPos, eye, lights[i] );" + " }" + " }" + " if( usingMat == false ) {" + " gl_FrontColor = vec4( " + " vec3(col) * finalAmbient +" + " vec3(col) * finalDiffuse +" + " vec3(col) * finalSpecular," + " col[3] );" + " }" + " else{" + " gl_FrontColor = vec4( " + " mat_emissive + " + " (vec3(col) * mat_ambient * finalAmbient) + " + " (vec3(col) * finalDiffuse) + " + " (mat_specular * finalSpecular), " + " col[3] );" + " }" + " }" + " vTexture.xy = aTexture.xy;" + " gl_Position = projection * view * model * vec4( Vertex, 1.0 );" + "}"; var fragmentShaderSource3D = "uniform sampler2D sampler;" + "uniform bool usingTexture;" + "varying vec2 vTexture;" + // In Processing, when a texture is used, the fill color is ignored "void main(void){" + " if(usingTexture){" + " gl_FragColor = vec4(texture2D(sampler, vTexture.xy));" + " }"+ " else{" + " gl_FragColor = vec4(gl_Color);" + " }" + "}"; //////////////////////////////////////////////////////////////////////////// // 3D Functions //////////////////////////////////////////////////////////////////////////// /* Sets the uniform variable 'varName' to the value specified by 'value'. Before calling this function, make sure 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. */ function uniformf(programObj, varName, varValue) { var varLocation = curContext.getUniformLocation(programObj, varName); // the variable won't be found if it was optimized out. if (varLocation !== -1) { 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); } } } function uniformi(programObj, varName, varValue) { var varLocation = curContext.getUniformLocation(programObj, varName); // the variable won't be found if it was optimized out. if (varLocation !== -1) { 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); } } } function vertexAttribPointer(programObj, varName, size, VBO) { var varLocation = curContext.getAttribLocation(programObj, varName); if (varLocation !== -1) { curContext.bindBuffer(curContext.ARRAY_BUFFER, VBO); curContext.vertexAttribPointer(varLocation, size, curContext.FLOAT, false, 0, 0); curContext.enableVertexAttribArray(varLocation); } } function disableVertexAttribPointer(programObj, varName){ var varLocation = curContext.getAttribLocation(programObj, varName); if (varLocation !== -1) { curContext.disableVertexAttribArray(varLocation); } } function uniformMatrix(programObj, varName, transpose, matrix) { var varLocation = curContext.getUniformLocation(programObj, varName); // 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); } } } // Wrapper to easily deal with array names changes. TODO: Don't think we need this wrapper anymore consensus has been reached. var newWebGLArray = function(data) { return new WebGLFloatArray(data); }; var imageModeCorner = function imageModeCorner(x, y, w, h, whAreSizes) { return { x: x, y: y, w: w, h: h }; }; var imageModeConvert = imageModeCorner; var imageModeCorners = function imageModeCorners(x, y, w, h, whAreSizes) { return { x: x, y: y, w: whAreSizes ? w : w - x, h: whAreSizes ? h : h - y }; }; var imageModeCenter = function imageModeCenter(x, y, w, h, whAreSizes) { return { x: x - w / 2, y: y - h / 2, w: w, h: h }; }; 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; }; //////////////////////////////////////////////////////////////////////////// // Char handling //////////////////////////////////////////////////////////////////////////// var charMap = {}; var Char = function Char(chr) { if (typeof chr === 'string' && chr.length === 1) { this.code = chr.charCodeAt(0); } else { this.code = NaN; } return (typeof charMap[this.code] === 'undefined') ? charMap[this.code] = this : charMap[this.code]; }; Char.prototype.toString = function() { return String.fromCharCode(this.code); }; Char.prototype.valueOf = function() { return this.code; }; //////////////////////////////////////////////////////////////////////////// // XMLAttribute //////////////////////////////////////////////////////////////////////////// var XMLAttribute = function ( fname, n, nameSpace, v, t){ this.fullName = fname || ""; this.name = n || ""; this.namespace = nameSpace || ""; this.value = v; this.type = t; }; XMLAttribute.prototype = { getName: function(){ return this.name; }, getFullName: function() { return this.fullName; }, getNamespace: function() { return this.namespace; }, getValue: function() { return this.value; }, getType: function() { return this.type; }, setValue: function( newval ){ this.value = newval; } }; //////////////////////////////////////////////////////////////////////////// // XMLElement //////////////////////////////////////////////////////////////////////////// var XMLElement = function( ){ if( arguments.length === 4 ){ this.attributes = []; this.children = []; this.fullName = arguments[0] || ""; if ( arguments[1] ) { this.name = arguments[1]; } else { var index = this.fullName.indexOf(':'); if( index >= 0 ) { this.name = this.fullName.substring(index + 1); } else { this.name = this.fullName; } } this.namespace = arguments[1]; this.content = ""; this.lineNr = arguments[3]; this.systemID = arguments[2]; this.parent = null; } else if( ( arguments.length === 1 && arguments[0].indexOf(".") > -1 ) || arguments.length === 2 ){ // filename or svg xml element if( arguments[arguments.length -1].indexOf(".") > -1 ){ //its a filename this.attributes = []; this.children = []; this.fullName = ""; this.name = ""; this.namespace = ""; this.content = ""; this.systemID = ""; this.lineNr = ""; this.parent = null; this.parse( arguments[arguments.length -1] ); } else { //xml string this.parse( arguments[arguments.length -1] ); } } else{ //empty ctor this.attributes = []; this.children = []; this.fullName = ""; this.name = ""; this.namespace = ""; this.content = ""; this.systemID = ""; this.lineNr = ""; this.parent = null; } return this; }; /*XMLElement methods missing: enumerateAttributeNames(), enumerateChildren(), NOTE: parse does not work when a url is passed in */ XMLElement.prototype = { parse: function( filename ){ var xmlDoc; try { xmlDoc = new DOMParser().parseFromString(ajax(filename), "text/xml"); var elements = xmlDoc.documentElement; if (elements) { this.parseChildrenRecursive( null, elements ); } else { throw("Error loading document"); } return this; } catch(e) { throw(e); } }, createElement: function( ){ if( arguments.length === 2 ){ return new XMLElement( arguments[0], arguments[1], null, null ); } else { return new XMLElement( arguments[0], arguments[1], arguments[2], arguments[3] ); } }, hasAttribute: function ( name ){ return this.getAttribute( name ) !== null; //2 parameter call missing }, createPCDataElement: function (){ return new XMLElement(); }, equals: function( object ){ if( typeof object === "Object"){ return this.equalsXMLElement( object ); } }, equalsXMLElement: function ( object ){ if( object instanceof XMLElement ){ if( this.name !== object.getLocalName ){ return false; } if( this.attributes.length !== object.getAttributeCount() ) { return false; } for( var i = 0; i < this.attributes.length; i++ ){ if (! object.hasAttribute(this.attributes[i].getName(), this.attributes[i].getNamespace())) { return false; } if( this.attributes[i].getValue() !== object.attributes[i].getValue() ) { return false; } if( this.attributes[i].getType() !== object.attributes[i].getType() ) { return false; } } if (this.children.length !== object.getChildCount()) { return false; } var child1, child2; for ( i = 0; i < this.children.length; i++) { child1 = this.getChildAtIndex( i ); child2 = object.getChildAtIndex( i ); if (! child1.equalsXMLElement( child2 )) { return false; } } return true; } }, getContent: function(){ return this.content; }, getAttribute: function (){ var attribute; if( arguments.length === 2 ){ attribute = this.findAttribute( arguments[0] ); if( attribute ){ return attribute.getValue(); } else { return arguments[1]; } }else if( arguments.length === 1 ){ attribute = this.findAttribute( arguments[0] ); if( attribute ){ return attribute.getValue(); } else { return null; } } }, getStringAttribute: function(){ if( arguments.length === 1 ){ return this.getAttribute( arguments[0] ); } else if( arguments.length === 2 ){ return this.getAttribute( arguments[0], arguments[1] ); } else { return this.getAttribute( arguments[0], arguments[1],arguments[2] ); } }, getFloatAttribute: function(){ if( arguments.length === 1 ){ return this.getAttribute( arguments[0], 0 ); } else if( arguments.length === 2 ){ return this.getAttribute( arguments[0], arguments[1] ); } else { return this.getAttribute( arguments[0], arguments[1],arguments[2] ); } }, getIntAttribute: function(){ if( arguments.length === 1 ){ return this.getAttribute( arguments[0], 0 ); } else if( arguments.length === 2 ){ return this.getAttribute( arguments[0], arguments[1] ); } else { return this.getAttribute( arguments[0], arguments[1],arguments[2] ); } }, hasChildren: function(){ return this.children.length > 0 ; }, addChild: function( child ){ if (child !== null) { child.parent = this; this.children.push( child ); } }, insertChild: function( child, index ){ if( child ){ if ((child.getLocalName() === null) && (! this.hasChildren())) { var lastChild = this.children[this.children.length -1]; if ( lastChild.getLocalName() === null ) { lastChild.setContent( lastChild.getContent() + child.getContent() ); return; } } child.parent = this; this.children.splice( index,0,child ); } }, getChild: function( index ){ if( typeof index === "number" ){ return this.children[ index ]; } else if( index.indexOf('/') !== -1) { // path was given this.getChildRecursive( index.split("/"), 0 ); } else { var kid, kidName; for ( var i = 0; i < this.getChildCount(); i++ ) { kid = this.getChild(i); kidName = kid.getName(); if ( kidName !== null && kidName === index ) { return kid; } } return null; } }, getChildren: function(){ if ( arguments.length === 1 ){ if( typeof arguments[0] === "number" ){ return this.getChild( arguments[0] ); } else if( arguments[0].indexOf('/') !== -1) { // path was given return this.getChildrenRecursive( arguments[0].split("/"), 0 ); }else { var matches = []; var kid, kidName; for ( var i = 0; i < this.getChildCount(); i++ ) { kid = this.getChild( i ); kidName = kid.getName(); if ( kidName !== null && kidName === arguments[0] ) { matches.push( kid ); } } return matches; } }else { return this.children; } }, getChildCount: function(){ return this.children.length; }, getChildRecursive: function ( items, offset ){ var kid, kidName; for( var i = 0; i < this.getChildCount(); i++ ) { kid = this.getChild(i); kidName = kid.getName(); if( kidName !== null && kidName === items[offset] ) { if ( offset === items.length-1 ) { return kid; } else { offset += 1; return kid.getChildRecursive( items, offset ); } } } return null; }, getChildrenRecursive: function ( items, offset ){ if ( offset === items.length-1 ) { return this.getChildren( items[offset] ); } var matches = this.getChildren( items[offset] ); var kidMatches; for ( var i = 0; i < matches.length; i++ ) { kidMatches = matches[i].getChildrenRecursive( items, offset+1 ); } return kidMatches; }, parseChildrenRecursive: function ( parent , elementpath ){ var xmlelement, xmlattribute, tmpattrib; if( !parent ) { this.fullName = elementpath.localName; this.name = elementpath.nodeName; this.content = elementpath.textContent || ""; xmlelement = this; } else { // a parent xmlelement = new XMLElement( elementpath.localName, elementpath.nodeName, "", "" ); xmlelement.content = elementpath.textContent || ""; xmlelement.parent = parent; } for( var l = 0; l < elementpath.attributes.length; l++ ) { tmpattrib = elementpath.attributes[l]; xmlattribute = new XMLAttribute( tmpattrib.getname , tmpattrib.nodeName, tmpattrib.namespaceURI , tmpattrib.nodeValue , tmpattrib.nodeType ); xmlelement.attributes.push( xmlattribute ); } for( var m = 0; m < elementpath.childElementCount; m++ ) { xmlelement.children.push( xmlelement.parseChildrenRecursive(xmlelement, elementpath.children[m]) ); } return xmlelement; }, isLeaf: function(){ return this.hasChildren(); }, listChildren: function(){ var arr = []; for( var i = 0; i < this.children.length; i++ ){ arr.push( this.getChild(i).getName() ); } return arr; }, removeAttribute: function ( name , namespace ){ namespace = namespace || ""; for( var i = 0; i < this.attributes.length; i++ ){ if( this.attributes[i].getName() === name && this.attributes[i].getNamespace() === namespace ){ this.attributes.splice( i, 0 ); } } }, removeChild: function( child ){ if( child ){ for( var i = 0; i< this.children.length; i++ ){ if (this.children[i].equalsXMLElement( child )){ this.children.splice( i, 0 ); } } } }, removeChildAtIndex: function( index ){ if( this.children.length > index ) {//make sure its not outofbounds this.children.splice( index, 0 ); } }, findAttribute: function ( name, namespace ){ namespace = namespace || ""; for( var i = 0; i < this.attributes.length; i++ ){ if( this.attributes[i].getName() === name && this.attributes[i].getNamespace() === namespace ){ return this.attributes[i]; } } }, setAttribute: function(){ var attr; if( arguments.length === 3){ var index = arguments[0].indexOf(':'); var name = arguments[0].substring(index + 1); attr = this.findAttribute( name, arguments[1] ); if( attr ){ attr.setValue( arguments[2] ); } else { attr = new XMLAttribute(arguments[0], name, arguments[1], arguments[2], "CDATA"); this.attributes.addElement( attr ); } } else { attr = this.findAttribute( arguments[0] ); if( attr ){ attr.setValue( arguments[1] ); } else { attr = new XMLAttribute( arguments[0], arguments[0], null, arguments[1], "CDATA" ); this.attributes.addElement( attr ); } } }, setContent: function( content ){ this.content = content; }, setName: function(){ if( arguments.length === 1 ){ this.name = arguments[0]; this.fullName = arguments[0]; this.namespace = arguments[0]; } else { var index = arguments[0].indexOf(':'); if (( arguments[1] === null ) || ( index < 0 )) { this.name = arguments[0]; } else { this.name = arguments[0].substring( index + 1 ); } this.fullName = arguments[0]; this.namespace = arguments[1]; } }, getName: function(){ return this.fullName; } }; p.XMLElement = XMLElement; //////////////////////////////////////////////////////////////////////////// // PVector //////////////////////////////////////////////////////////////////////////// var PVector = function(x, y, z) { this.x = x || 0; this.y = y || 0; this.z = z || 0; }, createPVectorMethod = function(method) { return function(v1, v2) { var v = v1.get(); v[method](v2); return v; }; }, createSimplePVectorMethod = function(method) { return function(v1, v2) { return v1[method](v2); }; }, simplePVMethods = "dist dot cross".split(" "), method = simplePVMethods.length; PVector.angleBetween = function(v1, v2) { return Math.acos(v1.dot(v2) / (v1.mag() * v2.mag())); }; // Common vector operations for PVector PVector.prototype = { set: function(v, y, z) { if (arguments.length === 1) { this.set(v.x || v[0], v.y || v[1], v.z || v[2]); } else { this.x = v; this.y = y; this.z = z; } }, get: function() { return new PVector(this.x, this.y, this.z); }, mag: function() { return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z); }, add: function(v, y, z) { if (arguments.length === 3) { this.x += v; this.y += y; this.z += z; } else if (arguments.length === 1) { this.x += v.x; this.y += v.y; this.z += v.z; } }, sub: function(v, y, z) { if (arguments.length === 3) { this.x -= v; this.y -= y; this.z -= z; } else if (arguments.length === 1) { this.x -= v.x; this.y -= v.y; this.z -= v.z; } }, mult: function(v) { if (typeof v === 'number') { this.x *= v; this.y *= v; this.z *= v; } else if (typeof v === 'object') { this.x *= v.x; this.y *= v.y; this.z *= v.z; } }, div: function(v) { if (typeof v === 'number') { this.x /= v; this.y /= v; this.z /= v; } else if (typeof v === 'object') { this.x /= v.x; this.y /= v.y; this.z /= v.z; } }, dist: function(v) { var dx = this.x - v.x, dy = this.y - v.y, dz = this.z - v.z; return Math.sqrt(dx * dx + dy * dy + dz * dz); }, dot: function(v, y, z) { var num; if (arguments.length === 3) { num = this.x * v + this.y * y + this.z * z; } else if (arguments.length === 1) { num = this.x * v.x + this.y * v.y + this.z * v.z; } return num; }, cross: function(v) { var crossX = this.y * v.z - v.y * this.z, crossY = this.z * v.x - v.z * this.x, crossZ = this.x * v.y - v.x * this.y; return new PVector(crossX, crossY, crossZ); }, normalize: function() { var m = this.mag(); if (m > 0) { this.div(m); } }, limit: function(high) { if (this.mag() > high) { this.normalize(); this.mult(high); } }, heading2D: function() { var angle = Math.atan2(-this.y, this.x); return -angle; }, toString: function() { return "[" + this.x + ", " + this.y + ", " + this.z + "]"; }, array: function() { return [this.x, this.y, this.z]; } }; while (method--) { PVector[simplePVMethods[method]] = createSimplePVectorMethod(simplePVMethods[method]); } for (method in PVector.prototype) { if (PVector.prototype.hasOwnProperty(method) && !PVector.hasOwnProperty(method)) { PVector[method] = createPVectorMethod(method); } } p.PVector = PVector; //////////////////////////////////////////////////////////////////////////// // 2D Matrix //////////////////////////////////////////////////////////////////////////// /* Helper function for printMatrix(). Finds the largest scalar in the matrix, then number of digits left of the decimal. Call from PMatrix2D and PMatrix3D's print() function. */ var printMatrixHelper = function printMatrixHelper(elements) { var big = 0; for (var i = 0; i < elements.length; i++) { if (i !== 0) { big = Math.max(big, Math.abs(elements[i])); } else { big = Math.abs(elements[i]); } } var digits = (big + "").indexOf("."); if (digits === 0) { digits = 1; } else if (digits === -1) { digits = (big + "").length; } return digits; }; var PMatrix2D = function() { if (arguments.length === 0) { this.reset(); } else if (arguments.length === 1 && arguments[0] instanceof PMatrix2D) { this.set(arguments[0].array()); } else if (arguments.length === 6) { this.set(arguments[0], arguments[1], arguments[2], arguments[3], arguments[4], arguments[5]); } }; PMatrix2D.prototype = { set: function() { if (arguments.length === 6) { var a = arguments; this.set([a[0], a[1], a[2], a[3], a[4], a[5]]); } else if (arguments.length === 1 && arguments[0] instanceof PMatrix2D) { this.elements = arguments[0].array(); } else if (arguments.length === 1 && arguments[0] instanceof Array) { this.elements = arguments[0].slice(); } }, get: function() { var outgoing = new PMatrix2D(); outgoing.set(this.elements); return outgoing; }, reset: function() { this.set([1, 0, 0, 0, 1, 0]); }, // Returns a copy of the element values. array: function array() { return this.elements.slice(); }, translate: function(tx, ty) { this.elements[2] = tx * this.elements[0] + ty * this.elements[1] + this.elements[2]; this.elements[5] = tx * this.elements[3] + ty * this.elements[4] + this.elements[5]; }, // Does nothing in Processing. transpose: function() { }, mult: function(source, target) { var x, y; if (source instanceof PVector) { x = source.x; y = source.y; if (!target) { target = new PVector(); } } else if (source instanceof Array) { x = source[0]; y = source[1]; if (!target) { target = []; } } if (target instanceof Array) { target[0] = this.elements[0] * x + this.elements[1] * y + this.elements[2]; target[1] = this.elements[3] * x + this.elements[4] * y + this.elements[5]; } else if (target instanceof PVector) { target.x = this.elements[0] * x + this.elements[1] * y + this.elements[2]; target.y = this.elements[3] * x + this.elements[4] * y + this.elements[5]; target.z = 0; } return target; }, multX: function(x, y) { return x * this.elements[0] + y * this.elements[1] + this.elements[2]; }, multY: function(x, y) { return x * this.elements[3] + y * this.elements[4] + this.elements[5]; }, skewX: function(angle) { this.apply(1, 0, 1, angle, 0, 0); }, skewY: function(angle) { this.apply(1, 0, 1, 0, angle, 0); }, determinant: function() { return this.elements[0] * this.elements[4] - this.elements[1] * this.elements[3]; }, invert: function() { var d = this.determinant(); if ( Math.abs( d ) > p.FLOAT_MIN ) { var old00 = this.elements[0]; var old01 = this.elements[1]; var old02 = this.elements[2]; var old10 = this.elements[3]; var old11 = this.elements[4]; var old12 = this.elements[5]; this.elements[0] = old11 / d; this.elements[3] = -old10 / d; this.elements[1] = -old01 / d; this.elements[1] = old00 / d; this.elements[2] = (old01 * old12 - old11 * old02) / d; this.elements[5] = (old10 * old02 - old00 * old12) / d; return true; } return false; }, scale: function(sx, sy) { if (sx && !sy) { sy = sx; } if (sx && sy) { this.elements[0] *= sx; this.elements[1] *= sy; this.elements[3] *= sx; this.elements[4] *= sy; } }, apply: function() { if (arguments.length === 1 && arguments[0] instanceof PMatrix2D) { this.apply(arguments[0].array()); } else if (arguments.length === 6) { var a = arguments; this.apply([a[0], a[1], a[2], a[3], a[4], a[5]]); } else if (arguments.length === 1 && arguments[0] instanceof Array) { var source = arguments[0]; var result = [0, 0, this.elements[2], 0, 0, this.elements[5]]; var e = 0; for (var row = 0; row < 2; row++) { for (var col = 0; col < 3; col++, e++) { result[e] += this.elements[row * 3 + 0] * source[col + 0] + this.elements[row * 3 + 1] * source[col + 3]; } } this.elements = result.slice(); } }, preApply: function() { if (arguments.length === 1 && arguments[0] instanceof PMatrix2D) { this.preApply(arguments[0].array()); } else if (arguments.length === 6) { var a = arguments; this.preApply([a[0], a[1], a[2], a[3], a[4], a[5]]); } else if (arguments.length === 1 && arguments[0] instanceof Array) { var source = arguments[0]; var result = [0, 0, source[2], 0, 0, source[5]]; result[2]= source[2] + this.elements[2] * source[0] + this.elements[5] * source[1]; result[5]= source[5] + this.elements[2] * source[3] + this.elements[5] * source[4]; result[0] = this.elements[0] * source[0] + this.elements[3] * source[1]; result[3] = this.elements[0] * source[3] + this.elements[3] * source[4]; result[1] = this.elements[1] * source[0] + this.elements[4] * source[1]; result[4] = this.elements[1] * source[3] + this.elements[4] * source[4]; this.elements = result.slice(); } }, rotate: function(angle) { var c = Math.cos(angle); var s = Math.sin(angle); var temp1 = this.elements[0]; var temp2 = this.elements[1]; this.elements[0] = c * temp1 + s * temp2; this.elements[1] = -s * temp1 + c * temp2; temp1 = this.elements[3]; temp2 = this.elements[4]; this.elements[3] = c * temp1 + s * temp2; this.elements[4] = -s * temp1 + c * temp2; }, rotateZ: function(angle) { this.rotate(angle); }, print: function() { var digits = printMatrixHelper(this.elements); var output = ""; output += p.nfs(this.elements[0], digits, 4) + " " + p.nfs(this.elements[1], digits, 4) + " " + p.nfs(this.elements[2], digits, 4) + "\n"; output += p.nfs(this.elements[3], digits, 4) + " " + p.nfs(this.elements[4], digits, 4) + " " + p.nfs(this.elements[5], digits, 4) + "\n\n"; p.println(output); } }; //////////////////////////////////////////////////////////////////////////// // PMatrix3D //////////////////////////////////////////////////////////////////////////// var PMatrix3D = function PMatrix3D() { //When a matrix is created, it is set to an identity matrix this.reset(); }; PMatrix3D.prototype = { set: function() { if (arguments.length === 16) { var a = arguments; this.set([a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15]]); } else if (arguments.length === 1 && arguments[0] instanceof PMatrix3D) { this.elements = arguments[0].array(); } else if (arguments.length === 1 && arguments[0] instanceof Array) { this.elements = arguments[0].slice(); } }, get: function() { var outgoing = new PMatrix3D(); outgoing.set(this.elements); return outgoing; }, reset: function() { this.set([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]); }, // Returns a copy of the element values. array: function array() { return this.elements.slice(); }, translate: function(tx, ty, tz) { if (typeof tz === 'undefined') { tz = 0; } this.elements[3] += tx * this.elements[0] + ty * this.elements[1] + tz * this.elements[2]; this.elements[7] += tx * this.elements[4] + ty * this.elements[5] + tz * this.elements[6]; this.elements[11] += tx * this.elements[8] + ty * this.elements[9] + tz * this.elements[10]; this.elements[15] += tx * this.elements[12] + ty * this.elements[13] + tz * this.elements[14]; }, transpose: function() { var temp = this.elements.slice(); this.elements[0] = temp[0]; this.elements[1] = temp[4]; this.elements[2] = temp[8]; this.elements[3] = temp[12]; this.elements[4] = temp[1]; this.elements[5] = temp[5]; this.elements[6] = temp[9]; this.elements[7] = temp[13]; this.elements[8] = temp[2]; this.elements[9] = temp[6]; this.elements[10] = temp[10]; this.elements[11] = temp[14]; this.elements[12] = temp[3]; this.elements[13] = temp[7]; this.elements[14] = temp[11]; this.elements[15] = temp[15]; }, /* You must either pass in two PVectors or two arrays, don't mix between types. You may also omit a second argument and simply read the result from the return. */ mult: function(source, target) { var x, y, z, w; if (source instanceof PVector) { x = source.x; y = source.y; z = source.z; w = 1; if (!target) { target = new PVector(); } } else if (source instanceof Array) { x = source[0]; y = source[1]; z = source[2]; w = source[3] || 1; if (!target || target.length !== 3 && target.length !== 4) { target = [0, 0, 0]; } } if (target instanceof Array) { if (target.length === 3) { target[0] = this.elements[0] * x + this.elements[1] * y + this.elements[2] * z + this.elements[3]; target[1] = this.elements[4] * x + this.elements[5] * y + this.elements[6] * z + this.elements[7]; target[2] = this.elements[8] * x + this.elements[9] * y + this.elements[10] * z + this.elements[11]; } else if (target.length === 4) { target[0] = this.elements[0] * x + this.elements[1] * y + this.elements[2] * z + this.elements[3] * w; target[1] = this.elements[4] * x + this.elements[5] * y + this.elements[6] * z + this.elements[7] * w; target[2] = this.elements[8] * x + this.elements[9] * y + this.elements[10] * z + this.elements[11] * w; target[3] = this.elements[12] * x + this.elements[13] * y + this.elements[14] * z + this.elements[15] * w; } } if (target instanceof PVector) { target.x = this.elements[0] * x + this.elements[1] * y + this.elements[2] * z + this.elements[3]; target.y = this.elements[4] * x + this.elements[5] * y + this.elements[6] * z + this.elements[7]; target.z = this.elements[8] * x + this.elements[9] * y + this.elements[10] * z + this.elements[11]; } return target; }, preApply: function() { if (arguments.length === 1 && arguments[0] instanceof PMatrix3D) { this.preApply(arguments[0].array()); } else if (arguments.length === 16) { var a = arguments; this.preApply([a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15]]); } else if (arguments.length === 1 && arguments[0] instanceof Array) { var source = arguments[0]; var result = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]; var e = 0; for (var row = 0; row < 4; row++) { for (var col = 0; col < 4; col++, e++) { result[e] += this.elements[col + 0] * source[row * 4 + 0] + this.elements[col + 4] * source[row * 4 + 1] + this.elements[col + 8] * source[row * 4 + 2] + this.elements[col + 12] * source[row * 4 + 3]; } } this.elements = result.slice(); } }, apply: function() { if (arguments.length === 1 && arguments[0] instanceof PMatrix3D) { this.apply(arguments[0].array()); } else if (arguments.length === 16) { var a = arguments; this.apply([a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15]]); } else if (arguments.length === 1 && arguments[0] instanceof Array) { var source = arguments[0]; var result = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]; var e = 0; for (var row = 0; row < 4; row++) { for (var col = 0; col < 4; col++, e++) { result[e] += this.elements[row * 4 + 0] * source[col + 0] + this.elements[row * 4 + 1] * source[col + 4] + this.elements[row * 4 + 2] * source[col + 8] + this.elements[row * 4 + 3] * source[col + 12]; } } this.elements = result.slice(); } }, rotate: function(angle, v0, v1, v2) { if (!v1) { this.rotateZ(angle); } else { // TODO should make sure this vector is normalized var c = p.cos(angle); var s = p.sin(angle); var t = 1.0 - c; this.apply((t * v0 * v0) + c, (t * v0 * v1) - (s * v2), (t * v0 * v2) + (s * v1), 0, (t * v0 * v1) + (s * v2), (t * v1 * v1) + c, (t * v1 * v2) - (s * v0), 0, (t * v0 * v2) - (s * v1), (t * v1 * v2) + (s * v0), (t * v2 * v2) + c, 0, 0, 0, 0, 1); } }, invApply: function() { if (typeof inverseCopy === "undefined") { inverseCopy = new PMatrix3D(); } var a = arguments; inverseCopy.set(a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15]); if (!inverseCopy.invert()) { return false; } this.preApply(inverseCopy); return true; }, rotateX: function(angle) { var c = p.cos(angle); var s = p.sin(angle); this.apply([1, 0, 0, 0, 0, c, -s, 0, 0, s, c, 0, 0, 0, 0, 1]); }, rotateY: function(angle) { var c = p.cos(angle); var s = p.sin(angle); this.apply([c, 0, s, 0, 0, 1, 0, 0, -s, 0, c, 0, 0, 0, 0, 1]); }, rotateZ: function(angle) { var c = Math.cos(angle); var s = Math.sin(angle); this.apply([c, -s, 0, 0, s, c, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]); }, // Uniform scaling if only one value passed in scale: function(sx, sy, sz) { if (sx && !sy && !sz) { sy = sz = sx; } else if (sx && sy && !sz) { sz = 1; } if (sx && sy && sz) { this.elements[0] *= sx; this.elements[1] *= sy; this.elements[2] *= sz; this.elements[4] *= sx; this.elements[5] *= sy; this.elements[6] *= sz; this.elements[8] *= sx; this.elements[9] *= sy; this.elements[10] *= sz; this.elements[12] *= sx; this.elements[13] *= sy; this.elements[14] *= sz; } }, skewX: function(angle) { var t = p.tan(angle); this.apply(1, t, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1); }, skewY: function(angle) { var t = Math.tan(angle); this.apply(1, 0, 0, 0, t, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1); }, multX: function(x, y, z, w) { if (!z) { return this.elements[0] * x + this.elements[1] * y + this.elements[3]; } else if (!w) { return this.elements[0] * x + this.elements[1] * y + this.elements[2] * z + this.elements[3]; } else { return this.elements[0] * x + this.elements[1] * y + this.elements[2] * z + this.elements[3] * w; } }, multY: function(x, y, z, w) { if (!z) { return this.elements[4] * x + this.elements[5] * y + this.elements[7]; } else if (!w) { return this.elements[4] * x + this.elements[5] * y + this.elements[6] * z + this.elements[7]; } else { return this.elements[4] * x + this.elements[5] * y + this.elements[6] * z + this.elements[7] * w; } }, multZ: function(x, y, z, w) { if (!w) { return this.elements[8] * x + this.elements[9] * y + this.elements[10] * z + this.elements[11]; } else { return this.elements[8] * x + this.elements[9] * y + this.elements[10] * z + this.elements[11] * w; } }, multW: function(x, y, z, w) { if (!w) { return this.elements[12] * x + this.elements[13] * y + this.elements[14] * z + this.elements[15]; } else { return this.elements[12] * x + this.elements[13] * y + this.elements[14] * z + this.elements[15] * w; } }, invert: function() { var kInv = []; var fA0 = this.elements[0] * this.elements[5] - this.elements[1] * this.elements[4]; var fA1 = this.elements[0] * this.elements[6] - this.elements[2] * this.elements[4]; var fA2 = this.elements[0] * this.elements[7] - this.elements[3] * this.elements[4]; var fA3 = this.elements[1] * this.elements[6] - this.elements[2] * this.elements[5]; var fA4 = this.elements[1] * this.elements[7] - this.elements[3] * this.elements[5]; var fA5 = this.elements[2] * this.elements[7] - this.elements[3] * this.elements[6]; var fB0 = this.elements[8] * this.elements[13] - this.elements[9] * this.elements[12]; var fB1 = this.elements[8] * this.elements[14] - this.elements[10] * this.elements[12]; var fB2 = this.elements[8] * this.elements[15] - this.elements[11] * this.elements[12]; var fB3 = this.elements[9] * this.elements[14] - this.elements[10] * this.elements[13]; var fB4 = this.elements[9] * this.elements[15] - this.elements[11] * this.elements[13]; var fB5 = this.elements[10] * this.elements[15] - this.elements[11] * this.elements[14]; // Determinant var fDet = fA0 * fB5 - fA1 * fB4 + fA2 * fB3 + fA3 * fB2 - fA4 * fB1 + fA5 * fB0; // Account for a very small value // return false if not successful. if (Math.abs(fDet) <= 1e-9) { return false; } kInv[0] = +this.elements[5] * fB5 - this.elements[6] * fB4 + this.elements[7] * fB3; kInv[4] = -this.elements[4] * fB5 + this.elements[6] * fB2 - this.elements[7] * fB1; kInv[8] = +this.elements[4] * fB4 - this.elements[5] * fB2 + this.elements[7] * fB0; kInv[12] = -this.elements[4] * fB3 + this.elements[5] * fB1 - this.elements[6] * fB0; kInv[1] = -this.elements[1] * fB5 + this.elements[2] * fB4 - this.elements[3] * fB3; kInv[5] = +this.elements[0] * fB5 - this.elements[2] * fB2 + this.elements[3] * fB1; kInv[9] = -this.elements[0] * fB4 + this.elements[1] * fB2 - this.elements[3] * fB0; kInv[13] = +this.elements[0] * fB3 - this.elements[1] * fB1 + this.elements[2] * fB0; kInv[2] = +this.elements[13] * fA5 - this.elements[14] * fA4 + this.elements[15] * fA3; kInv[6] = -this.elements[12] * fA5 + this.elements[14] * fA2 - this.elements[15] * fA1; kInv[10] = +this.elements[12] * fA4 - this.elements[13] * fA2 + this.elements[15] * fA0; kInv[14] = -this.elements[12] * fA3 + this.elements[13] * fA1 - this.elements[14] * fA0; kInv[3] = -this.elements[9] * fA5 + this.elements[10] * fA4 - this.elements[11] * fA3; kInv[7] = +this.elements[8] * fA5 - this.elements[10] * fA2 + this.elements[11] * fA1; kInv[11] = -this.elements[8] * fA4 + this.elements[9] * fA2 - this.elements[11] * fA0; kInv[15] = +this.elements[8] * fA3 - this.elements[9] * fA1 + this.elements[10] * fA0; // Inverse using Determinant var fInvDet = 1.0 / fDet; kInv[0] *= fInvDet; kInv[1] *= fInvDet; kInv[2] *= fInvDet; kInv[3] *= fInvDet; kInv[4] *= fInvDet; kInv[5] *= fInvDet; kInv[6] *= fInvDet; kInv[7] *= fInvDet; kInv[8] *= fInvDet; kInv[9] *= fInvDet; kInv[10] *= fInvDet; kInv[11] *= fInvDet; kInv[12] *= fInvDet; kInv[13] *= fInvDet; kInv[14] *= fInvDet; kInv[15] *= fInvDet; this.elements = kInv.slice(); return true; }, toString: function() { var str = ""; for (var i = 0; i < 15; i++) { str += this.elements[i] + ", "; } str += this.elements[15]; return str; }, print: function() { var digits = printMatrixHelper(this.elements); var output = ""; output += p.nfs(this.elements[0], digits, 4) + " " + p.nfs(this.elements[1], digits, 4) + " " + p.nfs(this.elements[2], digits, 4) + " " + p.nfs(this.elements[3], digits, 4) + "\n"; output += p.nfs(this.elements[4], digits, 4) + " " + p.nfs(this.elements[5], digits, 4) + " " + p.nfs(this.elements[6], digits, 4) + " " + p.nfs(this.elements[7], digits, 4) + "\n"; output += p.nfs(this.elements[8], digits, 4) + " " + p.nfs(this.elements[9], digits, 4) + " " + p.nfs(this.elements[10], digits, 4) + " " + p.nfs(this.elements[11], digits, 4) + "\n"; output += p.nfs(this.elements[12], digits, 4) + " " + p.nfs(this.elements[13], digits, 4) + " " + p.nfs(this.elements[14], digits, 4) + " " + p.nfs(this.elements[15], digits, 4) + "\n\n"; p.println(output); }, invTranslate: function(tx, ty, tz) { this.preApply(1, 0, 0, -tx, 0, 1, 0, -ty, 0, 0, 1, -tz, 0, 0, 0, 1); }, invRotateX: function(angle) { var c = p.cos(-angle); var s = p.sin(-angle); this.preApply([1, 0, 0, 0, 0, c, -s, 0, 0, s, c, 0, 0, 0, 0, 1]); }, invRotateY: function(angle) { var c = p.cos(-angle); var s = p.sin(-angle); this.preApply([c, 0, s, 0, 0, 1, 0, 0, -s, 0, c, 0, 0, 0, 0, 1]); }, invRotateZ: function(angle) { var c = p.cos(-angle); var s = p.sin(-angle); this.preApply([c, -s, 0, 0, s, c, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]); }, invScale: function(x, y, z) { this.preApply([1 / x, 0, 0, 0, 0, 1 / y, 0, 0, 0, 0, 1 / z, 0, 0, 0, 0, 1]); } }; //////////////////////////////////////////////////////////////////////////// // Matrix Stack //////////////////////////////////////////////////////////////////////////// var PMatrixStack = function PMatrixStack() { this.matrixStack = []; }; PMatrixStack.prototype.load = function load() { var tmpMatrix; if (p.use3DContext) { tmpMatrix = new PMatrix3D(); } else { tmpMatrix = new PMatrix2D(); } if (arguments.length === 1) { tmpMatrix.set(arguments[0]); } else { tmpMatrix.set(arguments); } this.matrixStack.push(tmpMatrix); }; PMatrixStack.prototype.push = function push() { this.matrixStack.push(this.peek()); }; PMatrixStack.prototype.pop = function pop() { return this.matrixStack.pop(); }; PMatrixStack.prototype.peek = function peek() { var tmpMatrix; if (p.use3DContext) { tmpMatrix = new PMatrix3D(); } else { tmpMatrix = new PMatrix2D(); } tmpMatrix.set(this.matrixStack[this.matrixStack.length - 1]); return tmpMatrix; }; PMatrixStack.prototype.mult = function mult(matrix) { this.matrixStack[this.matrixStack.length - 1].apply(matrix); }; //////////////////////////////////////////////////////////////////////////// // Array handling //////////////////////////////////////////////////////////////////////////// p.split = function(str, delim) { return str.split(delim); }; p.splitTokens = function(str, tokens) { if (arguments.length === 1) { tokens = "\n\t\r\f "; } tokens = "[" + tokens + "]"; var ary = new Array(0); var index = 0; var pos = str.search(tokens); while (pos >= 0) { if (pos === 0) { str = str.substring(1); } else { ary[index] = str.substring(0, pos); index++; str = str.substring(pos); } pos = str.search(tokens); } if (str.length > 0) { ary[index] = str; } if (ary.length === 0) { ary = undefined; } return ary; }; p.append = function(array, element) { array[array.length] = element; return array; }; p.concat = function(array1, array2) { return array1.concat(array2); }; p.sort = function(array, numElem) { var ret = []; // depending on the type used (int, float) or string // we'll need to use a different compare function if (array.length > 0) { // copy since we need to return another array var elemsToCopy = numElem > 0 ? numElem : array.length; for (var i = 0; i < elemsToCopy; i++) { ret.push(array[i]); } if (typeof array[0] === "string") { ret.sort(); } // int or float else { ret.sort(function(a, b) { return a - b; }); } // copy on the rest of the elements that were not sorted in case the user // only wanted a subset of an array to be sorted. if (numElem > 0) { for (var j = ret.length; j < array.length; j++) { ret.push(array[j]); } } } return ret; }; p.splice = function(array, value, index) { if (array.length === 0 && value.length === 0) { return array; } if (value instanceof Array) { for (var i = 0, j = index; i < value.length; j++, i++) { array.splice(j, 0, value[i]); } } else { array.splice(index, 0, value); } return array; }; p.subset = function(array, offset, length) { if (arguments.length === 2) { return p.subset(array, offset, array.length - offset); } else if (arguments.length === 3) { return array.slice(offset, offset + length); } }; p.join = function(array, seperator) { return array.join(seperator); }; p.shorten = function(ary) { var newary = new Array(0); // copy array into new array var len = ary.length; for (var i = 0; i < len; i++) { newary[i] = ary[i]; } newary.pop(); return newary; }; p.expand = function(ary, newSize) { var newary = new Array(0); var len = ary.length; for (var i = 0; i < len; i++) { newary[i] = ary[i]; } if (arguments.length === 1) { // double size of array newary.length *= 2; } else if (arguments.length === 2) { // size is newSize newary.length = newSize; } return newary; }; p.arrayCopy = function(src, srcPos, dest, destPos, length) { if (arguments.length === 2) { // recall itself and copy src to dest from start index 0 to 0 of src.length p.arrayCopy(src, 0, srcPos, 0, src.length); } else if (arguments.length === 3) { // recall itself and copy src to dest from start index 0 to 0 of length p.arrayCopy(src, 0, srcPos, 0, dest); } else if (arguments.length === 5) { // copy src to dest from index srcPos to index destPos of length recursivly on objects for (var i = srcPos, j = destPos; i < length + srcPos; i++, j++) { if (src[i] && typeof src[i] === "object") { // src[i] is not null and is another object or array. go recursive p.arrayCopy(src[i], 0, dest[j], 0, src[i].length); } else { // standard type, just copy dest[j] = src[i]; } } } }; p.ArrayList = function() { var createArrayList = function(args){ var array = []; for (var i = 0; i < args[0]; i++){ array[i] = (args.length > 1 ? createArrayList(args.slice(1)) : 0 ); } array.get = function(i) { return this[i]; }; array.contains = function(item) { return this.indexOf(item) !== -1; }; array.add = function(item) { return this.push(item); }; array.size = function() { return this.length; }; array.clear = function() { this.length = 0; }; array.remove = function(i) { return this.splice(i, 1)[0]; }; array.isEmpty = function() { return !this.length; }; array.clone = function() { return this.slice(0); }; array.toArray = function() { return this.slice(0); }; return array; }; return createArrayList(Array.prototype.slice.call(arguments)); }; p.reverse = function(array) { return array.reverse(); }; //////////////////////////////////////////////////////////////////////////// // HashMap //////////////////////////////////////////////////////////////////////////// var virtHashCode = function virtHashCode(obj) { if (obj.constructor === String) { var hash = 0; for (var i = 0; i < obj.length; ++i) { hash = (hash * 31 + obj.charCodeAt(i)) & 0xFFFFFFFF; } return hash; } else if (typeof(obj) !== "object") { return obj & 0xFFFFFFFF; } else if ("hashCode" in obj) { return obj.hashCode.call(obj); } else { if (obj.$id === undefined) { obj.$id = ((Math.floor(Math.random() * 0x10000) - 0x8000) << 16) | Math.floor(Math.random() * 0x10000); } return obj.$id; } }; var virtEquals = function virtEquals(obj, other) { if (obj === null || other === null) { return (obj === null) && (other === null); } else if (obj.constructor === String) { return obj === other; } else if (typeof(obj) !== "object") { return obj === other; } else if ("equals" in obj) { return obj.equals.call(obj, other); } else { return obj === other; } }; p.HashMap = function HashMap() { if (arguments.length === 1 && arguments[0].constructor === HashMap) { return arguments[0].clone(); } var initialCapacity = arguments.length > 0 ? arguments[0] : 16; var loadFactor = arguments.length > 1 ? arguments[1] : 0.75; var buckets = new Array(initialCapacity); var count = 0; var hashMap = this; function ensureLoad() { if (count <= loadFactor * buckets.length) { return; } var allEntries = []; for (var i = 0; i < buckets.length; ++i) { if (buckets[i] !== undefined) { allEntries = allEntries.concat(buckets[i]); } } buckets = new Array(buckets.length * 2); for (var j = 0; j < allEntries.length; ++j) { var index = virtHashCode(allEntries[j].key) % buckets.length; var bucket = buckets[index]; if (bucket === undefined) { buckets[index] = bucket = []; } bucket.push(allEntries[j]); } } function Iterator(conversion, removeItem) { var bucketIndex = 0; var itemIndex = -1; var endOfBuckets = false; function findNext() { while (!endOfBuckets) { ++itemIndex; if (bucketIndex >= buckets.length) { endOfBuckets = true; } else if (typeof(buckets[bucketIndex]) === 'undefined' || itemIndex >= buckets[bucketIndex].length) { itemIndex = -1; ++bucketIndex; } else { return; } } } this.hasNext = function() { return !endOfBuckets; }; this.next = function() { var result = conversion(buckets[bucketIndex][itemIndex]); findNext(); return result; }; this.remove = function() { removeItem(this.next()); --itemIndex; }; findNext(); } function Set(conversion, isIn, removeItem) { this.clear = function() { hashMap.clear(); }; this.contains = function(o) { return isIn(o); }; this.containsAll = function(o) { var it = o.iterator(); while (it.hasNext()) { if (!this.contains(it.next())) { return false; } } return true; }; this.isEmpty = function() { return hashMap.isEmpty(); }; this.iterator = function() { return new Iterator(conversion, removeItem); }; this.remove = function(o) { if (this.contains(o)) { removeItem(o); return true; } return false; }; this.removeAll = function(c) { var it = c.iterator(); var changed = false; while (it.hasNext()) { var item = it.next(); if (this.contains(item)) { removeItem(item); changed = true; } } return true; }; this.retainAll = function(c) { var it = this.iterator(); var toRemove = []; while (it.hasNext()) { var entry = it.next(); if (!c.contains(entry)) { toRemove.push(entry); } } for (var i = 0; i < toRemove.length; ++i) { removeItem(toRemove[i]); } return toRemove.length > 0; }; this.size = function() { return hashMap.size(); }; this.toArray = function() { var result = new p.ArrayList(0); var it = this.iterator(); while (it.hasNext()) { result.push(it.next()); } return result; }; } function Entry(pair) { this._isIn = function(map) { return map === hashMap && (typeof(pair.removed) === 'undefined'); }; this.equals = function(o) { return virtEquals(pair.key, o.getKey()); }; this.getKey = function() { return pair.key; }; this.getValue = function() { return pair.value; }; this.hashCode = function(o) { return virtHashCode(pair.key); }; this.setValue = function(value) { var old = pair.value; pair.value = value; return old; }; } this.clear = function() { count = 0; buckets = new Array(initialCapacity); }; this.clone = function() { var map = new p.HashMap(); map.putAll(this); return map; }; this.containsKey = function(key) { var index = virtHashCode(key) % buckets.length; var bucket = buckets[index]; if (bucket === undefined) { return false; } for (var i = 0; i < bucket.length; ++i) { if (virtEquals(bucket[i].key, key)) { return true; } } return false; }; this.containsValue = function(value) { for (var i = 0; i < buckets.length; ++i) { var bucket = buckets[i]; if (bucket === undefined) { continue; } for (var j = 0; j < bucket.length; ++j) { if (virtEquals(bucket[j].value, value)) { return true; } } } return false; }; this.entrySet = function() { return new Set( function(pair) { return new Entry(pair); }, function(pair) { return pair.constructor === Entry && pair._isIn(hashMap); }, function(pair) { return hashMap.remove(pair.getKey()); }); }; this.get = function(key) { var index = virtHashCode(key) % buckets.length; var bucket = buckets[index]; if (bucket === undefined) { return null; } for (var i = 0; i < bucket.length; ++i) { if (virtEquals(bucket[i].key, key)) { return bucket[i].value; } } return null; }; this.isEmpty = function() { return count === 0; }; this.keySet = function() { return new Set( function(pair) { return pair.key; }, function(key) { return hashMap.containsKey(key); }, function(key) { return hashMap.remove(key); }); }; this.put = function(key, value) { var index = virtHashCode(key) % buckets.length; var bucket = buckets[index]; if (bucket === undefined) { ++count; buckets[index] = [{ key: key, value: value }]; ensureLoad(); return null; } for (var i = 0; i < bucket.length; ++i) { if (virtEquals(bucket[i].key, key)) { var previous = bucket[i].value; bucket[i].value = value; return previous; } }++count; bucket.push({ key: key, value: value }); ensureLoad(); return null; }; this.putAll = function(m) { var it = m.entrySet().iterator(); while (it.hasNext()) { var entry = it.next(); this.put(entry.getKey(), entry.getValue()); } }; this.remove = function(key) { var index = virtHashCode(key) % buckets.length; var bucket = buckets[index]; if (bucket === undefined) { return null; } for (var i = 0; i < bucket.length; ++i) { if (virtEquals(bucket[i].key, key)) { --count; var previous = bucket[i].value; bucket[i].removed = true; if (bucket.length > 1) { bucket.splice(i, 1); } else { buckets[index] = undefined; } return previous; } } return null; }; this.size = function() { return count; }; this.values = function() { var result = new p.ArrayList(0); var it = this.entrySet().iterator(); while (it.hasNext()) { var entry = it.next(); result.push(entry.getValue()); } return result; }; }; //////////////////////////////////////////////////////////////////////////// // Color functions //////////////////////////////////////////////////////////////////////////// // helper functions for internal blending modes p.mix = function(a, b, f) { return a + (((b - a) * f) >> 8); }; p.peg = function(n) { return (n < 0) ? 0 : ((n > 255) ? 255 : n); }; // blending modes p.modes = { replace: function(c1, c2) { return c2; }, blend: function(c1, c2) { var f = (c2 & p.ALPHA_MASK) >>> 24; return (Math.min(((c1 & p.ALPHA_MASK) >>> 24) + f, 0xff) << 24 | p.mix(c1 & p.RED_MASK, c2 & p.RED_MASK, f) & p.RED_MASK | p.mix(c1 & p.GREEN_MASK, c2 & p.GREEN_MASK, f) & p.GREEN_MASK | p.mix(c1 & p.BLUE_MASK, c2 & p.BLUE_MASK, f)); }, add: function(c1, c2) { var f = (c2 & p.ALPHA_MASK) >>> 24; return (Math.min(((c1 & p.ALPHA_MASK) >>> 24) + f, 0xff) << 24 | Math.min(((c1 & p.RED_MASK) + ((c2 & p.RED_MASK) >> 8) * f), p.RED_MASK) & p.RED_MASK | Math.min(((c1 & p.GREEN_MASK) + ((c2 & p.GREEN_MASK) >> 8) * f), p.GREEN_MASK) & p.GREEN_MASK | Math.min((c1 & p.BLUE_MASK) + (((c2 & p.BLUE_MASK) * f) >> 8), p.BLUE_MASK)); }, subtract: function(c1, c2) { var f = (c2 & p.ALPHA_MASK) >>> 24; return (Math.min(((c1 & p.ALPHA_MASK) >>> 24) + f, 0xff) << 24 | Math.max(((c1 & p.RED_MASK) - ((c2 & p.RED_MASK) >> 8) * f), p.GREEN_MASK) & p.RED_MASK | Math.max(((c1 & p.GREEN_MASK) - ((c2 & p.GREEN_MASK) >> 8) * f), p.BLUE_MASK) & p.GREEN_MASK | Math.max((c1 & p.BLUE_MASK) - (((c2 & p.BLUE_MASK) * f) >> 8), 0)); }, lightest: function(c1, c2) { var f = (c2 & p.ALPHA_MASK) >>> 24; return (Math.min(((c1 & p.ALPHA_MASK) >>> 24) + f, 0xff) << 24 | Math.max(c1 & p.RED_MASK, ((c2 & p.RED_MASK) >> 8) * f) & p.RED_MASK | Math.max(c1 & p.GREEN_MASK, ((c2 & p.GREEN_MASK) >> 8) * f) & p.GREEN_MASK | Math.max(c1 & p.BLUE_MASK, ((c2 & p.BLUE_MASK) * f) >> 8)); }, darkest: function(c1, c2) { var f = (c2 & p.ALPHA_MASK) >>> 24; return (Math.min(((c1 & p.ALPHA_MASK) >>> 24) + f, 0xff) << 24 | p.mix(c1 & p.RED_MASK, Math.min(c1 & p.RED_MASK, ((c2 & p.RED_MASK) >> 8) * f), f) & p.RED_MASK | p.mix(c1 & p.GREEN_MASK, Math.min(c1 & p.GREEN_MASK, ((c2 & p.GREEN_MASK) >> 8) * f), f) & p.GREEN_MASK | p.mix(c1 & p.BLUE_MASK, Math.min(c1 & p.BLUE_MASK, ((c2 & p.BLUE_MASK) * f) >> 8), f)); }, difference: function(c1, c2) { var f = (c2 & p.ALPHA_MASK) >>> 24; var ar = (c1 & p.RED_MASK) >> 16; var ag = (c1 & p.GREEN_MASK) >> 8; var ab = (c1 & p.BLUE_MASK); var br = (c2 & p.RED_MASK) >> 16; var bg = (c2 & p.GREEN_MASK) >> 8; var bb = (c2 & p.BLUE_MASK); // formula: var cr = (ar > br) ? (ar - br) : (br - ar); var cg = (ag > bg) ? (ag - bg) : (bg - ag); var cb = (ab > bb) ? (ab - bb) : (bb - ab); // alpha blend (this portion will always be the same) return (Math.min(((c1 & p.ALPHA_MASK) >>> 24) + f, 0xff) << 24 | (p.peg(ar + (((cr - ar) * f) >> 8)) << 16) | (p.peg(ag + (((cg - ag) * f) >> 8)) << 8) | (p.peg(ab + (((cb - ab) * f) >> 8)))); }, exclusion: function(c1, c2) { var f = (c2 & p.ALPHA_MASK) >>> 24; var ar = (c1 & p.RED_MASK) >> 16; var ag = (c1 & p.GREEN_MASK) >> 8; var ab = (c1 & p.BLUE_MASK); var br = (c2 & p.RED_MASK) >> 16; var bg = (c2 & p.GREEN_MASK) >> 8; var bb = (c2 & p.BLUE_MASK); // formula: var cr = ar + br - ((ar * br) >> 7); var cg = ag + bg - ((ag * bg) >> 7); var cb = ab + bb - ((ab * bb) >> 7); // alpha blend (this portion will always be the same) return (Math.min(((c1 & p.ALPHA_MASK) >>> 24) + f, 0xff) << 24 | (p.peg(ar + (((cr - ar) * f) >> 8)) << 16) | (p.peg(ag + (((cg - ag) * f) >> 8)) << 8) | (p.peg(ab + (((cb - ab) * f) >> 8)))); }, multiply: function(c1, c2) { var f = (c2 & p.ALPHA_MASK) >>> 24; var ar = (c1 & p.RED_MASK) >> 16; var ag = (c1 & p.GREEN_MASK) >> 8; var ab = (c1 & p.BLUE_MASK); var br = (c2 & p.RED_MASK) >> 16; var bg = (c2 & p.GREEN_MASK) >> 8; var bb = (c2 & p.BLUE_MASK); // formula: var cr = (ar * br) >> 8; var cg = (ag * bg) >> 8; var cb = (ab * bb) >> 8; // alpha blend (this portion will always be the same) return (Math.min(((c1 & p.ALPHA_MASK) >>> 24) + f, 0xff) << 24 | (p.peg(ar + (((cr - ar) * f) >> 8)) << 16) | (p.peg(ag + (((cg - ag) * f) >> 8)) << 8) | (p.peg(ab + (((cb - ab) * f) >> 8)))); }, screen: function(c1, c2) { var f = (c2 & p.ALPHA_MASK) >>> 24; var ar = (c1 & p.RED_MASK) >> 16; var ag = (c1 & p.GREEN_MASK) >> 8; var ab = (c1 & p.BLUE_MASK); var br = (c2 & p.RED_MASK) >> 16; var bg = (c2 & p.GREEN_MASK) >> 8; var bb = (c2 & p.BLUE_MASK); // formula: var cr = 255 - (((255 - ar) * (255 - br)) >> 8); var cg = 255 - (((255 - ag) * (255 - bg)) >> 8); var cb = 255 - (((255 - ab) * (255 - bb)) >> 8); // alpha blend (this portion will always be the same) return (Math.min(((c1 & p.ALPHA_MASK) >>> 24) + f, 0xff) << 24 | (p.peg(ar + (((cr - ar) * f) >> 8)) << 16) | (p.peg(ag + (((cg - ag) * f) >> 8)) << 8) | (p.peg(ab + (((cb - ab) * f) >> 8)))); }, hard_light: function(c1, c2) { var f = (c2 & p.ALPHA_MASK) >>> 24; var ar = (c1 & p.RED_MASK) >> 16; var ag = (c1 & p.GREEN_MASK) >> 8; var ab = (c1 & p.BLUE_MASK); var br = (c2 & p.RED_MASK) >> 16; var bg = (c2 & p.GREEN_MASK) >> 8; var bb = (c2 & p.BLUE_MASK); // formula: var cr = (br < 128) ? ((ar * br) >> 7) : (255 - (((255 - ar) * (255 - br)) >> 7)); var cg = (bg < 128) ? ((ag * bg) >> 7) : (255 - (((255 - ag) * (255 - bg)) >> 7)); var cb = (bb < 128) ? ((ab * bb) >> 7) : (255 - (((255 - ab) * (255 - bb)) >> 7)); // alpha blend (this portion will always be the same) return (Math.min(((c1 & p.ALPHA_MASK) >>> 24) + f, 0xff) << 24 | (p.peg(ar + (((cr - ar) * f) >> 8)) << 16) | (p.peg(ag + (((cg - ag) * f) >> 8)) << 8) | (p.peg(ab + (((cb - ab) * f) >> 8)))); }, soft_light: function(c1, c2) { var f = (c2 & p.ALPHA_MASK) >>> 24; var ar = (c1 & p.RED_MASK) >> 16; var ag = (c1 & p.GREEN_MASK) >> 8; var ab = (c1 & p.BLUE_MASK); var br = (c2 & p.RED_MASK) >> 16; var bg = (c2 & p.GREEN_MASK) >> 8; var bb = (c2 & p.BLUE_MASK); // formula: var cr = ((ar * br) >> 7) + ((ar * ar) >> 8) - ((ar * ar * br) >> 15); var cg = ((ag * bg) >> 7) + ((ag * ag) >> 8) - ((ag * ag * bg) >> 15); var cb = ((ab * bb) >> 7) + ((ab * ab) >> 8) - ((ab * ab * bb) >> 15); // alpha blend (this portion will always be the same) return (Math.min(((c1 & p.ALPHA_MASK) >>> 24) + f, 0xff) << 24 | (p.peg(ar + (((cr - ar) * f) >> 8)) << 16) | (p.peg(ag + (((cg - ag) * f) >> 8)) << 8) | (p.peg(ab + (((cb - ab) * f) >> 8)))); }, overlay: function(c1, c2) { var f = (c2 & p.ALPHA_MASK) >>> 24; var ar = (c1 & p.RED_MASK) >> 16; var ag = (c1 & p.GREEN_MASK) >> 8; var ab = (c1 & p.BLUE_MASK); var br = (c2 & p.RED_MASK) >> 16; var bg = (c2 & p.GREEN_MASK) >> 8; var bb = (c2 & p.BLUE_MASK); // formula: var cr = (ar < 128) ? ((ar * br) >> 7) : (255 - (((255 - ar) * (255 - br)) >> 7)); var cg = (ag < 128) ? ((ag * bg) >> 7) : (255 - (((255 - ag) * (255 - bg)) >> 7)); var cb = (ab < 128) ? ((ab * bb) >> 7) : (255 - (((255 - ab) * (255 - bb)) >> 7)); // alpha blend (this portion will always be the same) return (Math.min(((c1 & p.ALPHA_MASK) >>> 24) + f, 0xff) << 24 | (p.peg(ar + (((cr - ar) * f) >> 8)) << 16) | (p.peg(ag + (((cg - ag) * f) >> 8)) << 8) | (p.peg(ab + (((cb - ab) * f) >> 8)))); }, dodge: function(c1, c2) { var f = (c2 & p.ALPHA_MASK) >>> 24; var ar = (c1 & p.RED_MASK) >> 16; var ag = (c1 & p.GREEN_MASK) >> 8; var ab = (c1 & p.BLUE_MASK); var br = (c2 & p.RED_MASK) >> 16; var bg = (c2 & p.GREEN_MASK) >> 8; var bb = (c2 & p.BLUE_MASK); // formula: var cr = (br === 255) ? 255 : p.peg((ar << 8) / (255 - br)); // division requires pre-peg()-ing var cg = (bg === 255) ? 255 : p.peg((ag << 8) / (255 - bg)); // " var cb = (bb === 255) ? 255 : p.peg((ab << 8) / (255 - bb)); // " // alpha blend (this portion will always be the same) return (Math.min(((c1 & p.ALPHA_MASK) >>> 24) + f, 0xff) << 24 | (p.peg(ar + (((cr - ar) * f) >> 8)) << 16) | (p.peg(ag + (((cg - ag) * f) >> 8)) << 8) | (p.peg(ab + (((cb - ab) * f) >> 8)))); }, burn: function(c1, c2) { var f = (c2 & p.ALPHA_MASK) >>> 24; var ar = (c1 & p.RED_MASK) >> 16; var ag = (c1 & p.GREEN_MASK) >> 8; var ab = (c1 & p.BLUE_MASK); var br = (c2 & p.RED_MASK) >> 16; var bg = (c2 & p.GREEN_MASK) >> 8; var bb = (c2 & p.BLUE_MASK); // formula: var cr = (br === 0) ? 0 : 255 - p.peg(((255 - ar) << 8) / br); // division requires pre-peg()-ing var cg = (bg === 0) ? 0 : 255 - p.peg(((255 - ag) << 8) / bg); // " var cb = (bb === 0) ? 0 : 255 - p.peg(((255 - ab) << 8) / bb); // " // alpha blend (this portion will always be the same) return (Math.min(((c1 & p.ALPHA_MASK) >>> 24) + f, 0xff) << 24 | (p.peg(ar + (((cr - ar) * f) >> 8)) << 16) | (p.peg(ag + (((cg - ag) * f) >> 8)) << 8) | (p.peg(ab + (((cb - ab) * f) >> 8)))); } }; function color$4(aValue1, aValue2, aValue3, aValue4) { var r, g, b, a, rgb; if (curColorMode === p.HSB) { rgb = p.color.toRGB(aValue1, aValue2, aValue3); r = rgb[0]; g = rgb[1]; b = rgb[2]; } else { r = Math.round(255 * (aValue1 / colorModeX)); g = Math.round(255 * (aValue2 / colorModeY)); b = Math.round(255 * (aValue3 / colorModeZ)); } a = Math.round(255 * (aValue4 / colorModeA)); // Limit values greater than 255 r = (r > 255) ? 255 : r; g = (g > 255) ? 255 : g; b = (b > 255) ? 255 : b; a = (a > 255) ? 255 : a; // Create color int return (a << 24) & p.ALPHA_MASK | (r << 16) & p.RED_MASK | (g << 8) & p.GREEN_MASK | b & p.BLUE_MASK; } function color$2(aValue1, aValue2) { var a; // Color int and alpha if (aValue1 & p.ALPHA_MASK) { a = Math.round(255 * (aValue2 / colorModeA)); a = (a > 255) ? 255 : a; return aValue1 - (aValue1 & p.ALPHA_MASK) + ((a << 24) & p.ALPHA_MASK); } // Grayscale and alpha else { if (curColorMode === p.RGB) { return color$4(aValue1, aValue1, aValue1, aValue2); } else if (curColorMode === p.HSB) { return color$4(0, 0, (aValue1 / colorModeX) * colorModeZ, aValue2); } } } function color$1(aValue1) { // Grayscale if (aValue1 <= colorModeX && aValue1 >= 0) { if (curColorMode === p.RGB) { return color$4(aValue1, aValue1, aValue1, colorModeA); } else if (curColorMode === p.HSB) { return color$4(0, 0, (aValue1 / colorModeX) * colorModeZ, colorModeA); } } // Color int else if (aValue1) { return aValue1; } } p.color = function color(aValue1, aValue2, aValue3, aValue4) { var undef; // 4 arguments: (R, G, B, A) or (H, S, B, A) if (aValue1 !== undef && aValue2 !== undef && aValue3 !== undef && aValue4 !== undef) { return color$4(aValue1, aValue2, aValue3, aValue4); } // 3 arguments: (R, G, B) or (H, S, B) else if (aValue1 !== undef && aValue2 !== undef && aValue3 !== undef) { return color$4(aValue1, aValue2, aValue3, colorModeA); } // 2 arguments: (Color, A) or (Grayscale, A) else if (aValue1 !== undef && aValue2 !== undef) { return color$2(aValue1, aValue2); } // 1 argument: (Grayscale) or (Color) else if (typeof aValue1 === "number") { return color$1(aValue1); } // Default else { return color$4(colorModeX, colorModeY, colorModeZ, colorModeA); } }; // Ease of use function to extract the colour bits into a string p.color.toString = function(colorInt) { return "rgba(" + ((colorInt & p.RED_MASK) >>> 16) + "," + ((colorInt & p.GREEN_MASK) >>> 8) + "," + ((colorInt & p.BLUE_MASK)) + "," + ((colorInt & p.ALPHA_MASK) >>> 24) / 255 + ")"; }; // Easy of use function to pack rgba values into a single bit-shifted color int. p.color.toInt = function(r, g, b, a) { return (a << 24) & p.ALPHA_MASK | (r << 16) & p.RED_MASK | (g << 8) & p.GREEN_MASK | b & p.BLUE_MASK; }; // Creates a simple array in [R, G, B, A] format, [255, 255, 255, 255] p.color.toArray = function(colorInt) { return [(colorInt & p.RED_MASK) >>> 16, (colorInt & p.GREEN_MASK) >>> 8, colorInt & p.BLUE_MASK, (colorInt & p.ALPHA_MASK) >>> 24]; }; // Creates a WebGL color array in [R, G, B, A] format. WebGL wants the color ranges between 0 and 1, [1, 1, 1, 1] p.color.toGLArray = function(colorInt) { return [((colorInt & p.RED_MASK) >>> 16) / 255, ((colorInt & p.GREEN_MASK) >>> 8) / 255, (colorInt & p.BLUE_MASK) / 255, ((colorInt & p.ALPHA_MASK) >>> 24) / 255]; }; // HSB conversion function from Mootools, MIT Licensed p.color.toRGB = function(h, s, b) { // Limit values greater than range h = (h > colorModeX) ? colorModeX : h; s = (s > colorModeY) ? colorModeY : s; b = (b > colorModeZ) ? colorModeZ : b; h = (h / colorModeX) * 360; s = (s / colorModeY) * 100; b = (b / colorModeZ) * 100; var br = Math.round(b / 100 * 255); if (s === 0) { // Grayscale return [br, br, br]; } else { var hue = h % 360; var f = hue % 60; var p = Math.round((b * (100 - s)) / 10000 * 255); var q = Math.round((b * (6000 - s * f)) / 600000 * 255); var t = Math.round((b * (6000 - s * (60 - f))) / 600000 * 255); switch (Math.floor(hue / 60)) { case 0: return [br, t, p]; case 1: return [q, br, p]; case 2: return [p, br, t]; case 3: return [p, q, br]; case 4: return [t, p, br]; case 5: return [br, p, q]; } } }; p.color.toHSB = function( colorInt ) { var red, green, blue; red = ((colorInt & p.RED_MASK) >>> 16) / 255; green = ((colorInt & p.GREEN_MASK) >>> 8) / 255; blue = (colorInt & p.BLUE_MASK) / 255; var max = p.max(p.max(red,green), blue), min = p.min(p.min(red,green), blue), hue, saturation; if (min === max) { return [0, 0, max]; } else { saturation = (max - min) / max; if (red === max) { hue = (green - blue) / (max - min); } else if (green === max) { hue = 2 + ((blue - red) / (max - min)); } else { hue = 4 + ((red - green) / (max - min)); } hue /= 6; if (hue < 0) { hue += 1; } else if (hue > 1) { hue -= 1; } } return [hue*colorModeX, saturation*colorModeY, max*colorModeZ]; }; p.brightness = function(colInt){ return p.color.toHSB(colInt)[2]; }; p.saturation = function(colInt){ return p.color.toHSB(colInt)[1]; }; p.hue = function(colInt){ return p.color.toHSB(colInt)[0]; }; var verifyChannel = function verifyChannel(aColor) { if (aColor.constructor === Array) { return aColor; } else { return p.color(aColor); } }; p.red = function(aColor) { return ((aColor & p.RED_MASK) >>> 16) / 255 * colorModeX; }; p.green = function(aColor) { return ((aColor & p.GREEN_MASK) >>> 8) / 255 * colorModeY; }; p.blue = function(aColor) { return (aColor & p.BLUE_MASK) / 255 * colorModeZ; }; p.alpha = function(aColor) { return ((aColor & p.ALPHA_MASK) >>> 24) / 255 * colorModeA; }; p.lerpColor = function lerpColor(c1, c2, amt) { // Get RGBA values for Color 1 to floats var colorBits1 = p.color(c1); var r1 = (colorBits1 & p.RED_MASK) >>> 16; var g1 = (colorBits1 & p.GREEN_MASK) >>> 8; var b1 = (colorBits1 & p.BLUE_MASK); var a1 = ((colorBits1 & p.ALPHA_MASK) >>> 24) / colorModeA; // Get RGBA values for Color 2 to floats var colorBits2 = p.color(c2); var r2 = (colorBits2 & p.RED_MASK) >>> 16; var g2 = (colorBits2 & p.GREEN_MASK) >>> 8; var b2 = (colorBits2 & p.BLUE_MASK); var a2 = ((colorBits2 & p.ALPHA_MASK) >>> 24) / colorModeA; // Return lerp value for each channel, INT for color, Float for Alpha-range var r = parseInt(p.lerp(r1, r2, amt), 10); var g = parseInt(p.lerp(g1, g2, amt), 10); var b = parseInt(p.lerp(b1, b2, amt), 10); var a = parseFloat(p.lerp(a1, a2, amt) * colorModeA, 10); return p.color.toInt(r, g, b, a); }; // Forced default color mode for #aaaaaa style p.defaultColor = function(aValue1, aValue2, aValue3) { var tmpColorMode = curColorMode; curColorMode = p.RGB; var c = p.color(aValue1 / 255 * colorModeX, aValue2 / 255 * colorModeY, aValue3 / 255 * colorModeZ); curColorMode = tmpColorMode; return c; }; p.colorMode = function colorMode(mode, range1, range2, range3, range4) { curColorMode = mode; if (arguments.length >= 4) { colorModeX = range1; colorModeY = range2; colorModeZ = range3; } if (arguments.length === 5) { colorModeA = range4; } if (arguments.length === 2) { p.colorMode(mode, range1, range1, range1, range1); } }; p.blendColor = function(c1, c2, mode) { var color = 0; switch (mode) { case p.REPLACE: color = p.modes.replace(c1, c2); break; case p.BLEND: color = p.modes.blend(c1, c2); break; case p.ADD: color = p.modes.add(c1, c2); break; case p.SUBTRACT: color = p.modes.subtract(c1, c2); break; case p.LIGHTEST: color = p.modes.lightest(c1, c2); break; case p.DARKEST: color = p.modes.darkest(c1, c2); break; case p.DIFFERENCE: color = p.modes.difference(c1, c2); break; case p.EXCLUSION: color = p.modes.exclusion(c1, c2); break; case p.MULTIPLY: color = p.modes.multiply(c1, c2); break; case p.SCREEN: color = p.modes.screen(c1, c2); break; case p.HARD_LIGHT: color = p.modes.hard_light(c1, c2); break; case p.SOFT_LIGHT: color = p.modes.soft_light(c1, c2); break; case p.OVERLAY: color = p.modes.overlay(c1, c2); break; case p.DODGE: color = p.modes.dodge(c1, c2); break; case p.BURN: color = p.modes.burn(c1, c2); break; } return color; }; //////////////////////////////////////////////////////////////////////////// // Canvas-Matrix manipulation //////////////////////////////////////////////////////////////////////////// function saveContext() { curContext.save(); } function restoreContext() { curContext.restore(); isStrokeDirty = true; isFillDirty = true; } p.printMatrix = function printMatrix() { modelView.print(); }; p.translate = function translate(x, y, z) { if (p.use3DContext) { forwardTransform.translate(x, y, z); reverseTransform.invTranslate(x, y, z); } else { curContext.translate(x, y); } }; p.scale = function scale(x, y, z) { if (p.use3DContext) { forwardTransform.scale(x, y, z); reverseTransform.invScale(x, y, z); } else { curContext.scale(x, y || x); } }; p.pushMatrix = function pushMatrix() { if (p.use3DContext) { userMatrixStack.load(modelView); } else { saveContext(); } }; p.popMatrix = function popMatrix() { if (p.use3DContext) { modelView.set(userMatrixStack.pop()); } else { restoreContext(); } }; p.resetMatrix = function resetMatrix() { forwardTransform.reset(); reverseTransform.reset(); }; p.applyMatrix = function applyMatrix() { var a = arguments; if (!p.use3DContext) { for (var cnt = a.length; cnt < 16; cnt++) { a[cnt] = 0; } a[10] = a[15] = 1; } forwardTransform.apply(a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15]); reverseTransform.invApply(a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15]); }; p.rotateX = function(angleInRadians) { forwardTransform.rotateX(angleInRadians); reverseTransform.invRotateX(angleInRadians); }; p.rotateZ = function(angleInRadians) { forwardTransform.rotateZ(angleInRadians); reverseTransform.invRotateZ(angleInRadians); }; p.rotateY = function(angleInRadians) { forwardTransform.rotateY(angleInRadians); reverseTransform.invRotateY(angleInRadians); }; p.rotate = function rotate(angleInRadians) { if (p.use3DContext) { forwardTransform.rotateZ(angleInRadians); reverseTransform.invRotateZ(angleInRadians); } else { curContext.rotate(angleInRadians); } }; p.pushStyle = function pushStyle() { // Save the canvas state. saveContext(); p.pushMatrix(); var newState = { 'doFill': doFill, 'currentFillColor': currentFillColor, 'doStroke': doStroke, 'currentStrokeColor': currentStrokeColor, 'curTint': curTint, 'curRectMode': curRectMode, 'curColorMode': curColorMode, 'colorModeX': colorModeX, 'colorModeZ': colorModeZ, 'colorModeY': colorModeY, 'colorModeA': colorModeA, 'curTextFont': curTextFont, 'curTextSize': curTextSize }; styleArray.push(newState); }; p.popStyle = function popStyle() { var oldState = styleArray.pop(); if (oldState) { restoreContext(); p.popMatrix(); doFill = oldState.doFill; currentFillColor = oldState.currentFillColor; doStroke = oldState.doStroke; currentStrokeColor = oldState.currentStrokeColor; curTint = oldState.curTint; curRectMode = oldState.curRectmode; curColorMode = oldState.curColorMode; colorModeX = oldState.colorModeX; colorModeZ = oldState.colorModeZ; colorModeY = oldState.colorModeY; colorModeA = oldState.colorModeA; curTextFont = oldState.curTextFont; curTextSize = oldState.curTextSize; } else { throw "Too many popStyle() without enough pushStyle()"; } }; //////////////////////////////////////////////////////////////////////////// // Time based functions //////////////////////////////////////////////////////////////////////////// p.year = function year() { return new Date().getFullYear(); }; p.month = function month() { return new Date().getMonth() + 1; }; p.day = function day() { return new Date().getDate(); }; p.hour = function hour() { return new Date().getHours(); }; p.minute = function minute() { return new Date().getMinutes(); }; p.second = function second() { return new Date().getSeconds(); }; p.millis = function millis() { return new Date().getTime() - start; }; p.noLoop = function noLoop() { doLoop = false; loopStarted = false; clearInterval(looping); }; p.redraw = function redraw() { var sec = (new Date().getTime() - timeSinceLastFPS) / 1000; framesSinceLastFPS++; var fps = framesSinceLastFPS / sec; // recalculate FPS every half second for better accuracy. if (sec > 0.5) { timeSinceLastFPS = new Date().getTime(); framesSinceLastFPS = 0; p.__frameRate = fps; } p.frameCount++; inDraw = true; if (p.use3DContext) { // Delete all the lighting states and the materials the // user set in the last draw() call. p.noLights(); p.lightFalloff(1, 0, 0); p.shininess(1); p.ambient(255, 255, 255); p.specular(0, 0, 0); p.camera(); p.draw(); } else { saveContext(); p.draw(); restoreContext(); } inDraw = false; }; p.loop = function loop() { if (loopStarted) { return; } looping = window.setInterval(function() { try { try { p.focused = document.hasFocus(); } catch(e) {} p.redraw(); } catch(e_loop) { window.clearInterval(looping); throw e_loop; } }, curMsPerFrame); doLoop = true; loopStarted = true; }; p.frameRate = function frameRate(aRate) { curFrameRate = aRate; curMsPerFrame = 1000 / curFrameRate; }; p.exit = function exit() { window.clearInterval(looping); for (var i=0, ehl=p.pjs.eventHandlers.length; i 1 || (arguments.length === 1 && arguments[0] instanceof p.PImage)) { var image = arguments[0], x, y; if (arguments.length >= 3) { x = arguments[1]; y = arguments[2]; if (x < 0 || y < 0 || y >= image.height || x >= image.width) { throw "x and y must be non-negative and less than the dimensions of the image"; } } else { x = image.width >>> 1; y = image.height >>> 1; } // see https://developer.mozilla.org/en/Using_URL_values_for_the_cursor_property var imageDataURL = image.toDataURL(); var style = "url(\"" + imageDataURL + "\") " + x + " " + y + ", default"; curCursor = curElement.style.cursor = style; } else if (arguments.length === 1) { var mode = arguments[0]; curCursor = curElement.style.cursor = mode; } else { curCursor = curElement.style.cursor = oldCursor; } }; p.noCursor = function noCursor() { curCursor = curElement.style.cursor = p.NOCURSOR; }; p.link = function(href, target) { if (typeof target !== 'undefined') { window.open(href, target); } else { window.location = href; } }; // PGraphics methods // TODO: These functions are suppose to be called before any operations are called on the // PGraphics object. They currently do nothing. p.beginDraw = function beginDraw() {}; p.endDraw = function endDraw() {}; // Imports an external Processing.js library p.Import = function Import(lib) { // Replace evil-eval method with a DOM