Changes

=Any further edits should be made in this section or mentioned to Cathy or Daniel. formatting this into ACM now= add changes here or contact cathy or daniel =Processing.js for Web base based Games=

Games delivery requires require fast, highly graphical, interactive, multimedia environmentenvironments. To accomplish this, games delivered on a web page, have traditionally required some sort of browser plug-in. However due to security concerns and general wariness about plug-ins, delivering content/games in this manner is a barrier to access for some users. Furthermore, browser plug-ins are not available on browsers for all platforms. Even Flash, which is one of the most ubiquitous visual interactive environments, is not available for every browser. The HTML5 <canvas> element, standardized in ...(find citation) allows the programmatic delivery of graphics on a web page without plug-ins. With its inclusion in the soon to be released IE 9, the <canvas> element now represents a means to deliver rich graphical content in all the major browsers.

The typical way to draw on the canvas is to use JavaScript. However for artists, educators, and other people less familiar with JavaScript, learning to do this can be a barrier to entry. The Processing language introduced by Ben Fry and Casey Reas is a simple and elegant language for data visualization that is already used by artists, educators as well as , and commercial media to deliver rich graphical content called sketches. There is a large body of work around the world which is being developed using Processing. However, Processing was is developed in Java and thus delivering Processing sketches on a web page required requires that the user install a Java plugin. Furthermore the sketches themselves are self contained items as opposed to being part of a web page. That While it is, that while it was possible to deliver a sketch via a Java applet, the web page served serves as a medium of delivery as opposed to being part of the game.

The Processing.js project was started by John Resig who wanted to utilize the HTML5 canvas element and take advantage of the Java Processing language. It took about seven months to get a working version, consisting of 5000 lines of code but it was not a complete port of the Processing language(source?). The project, similarly to other open source products, was released with the hope that a developer community will would converge around it and contribute to development. In September 2009, we students from Seneca College began the work to complete Processing.js. In order to facilitate an architecture for participation the source code had to be readily available and the inner workings of the project and the missing functionality must be publicized. To this end the source code was made available publicly on GitHub and an issue tracking system was used to manage the large number of issues needed to be resolved in order to complete the port. A review process was setup to ensure that the code submitted was of sufficient quality. Processing.js 1.0 was released in November 2010.

==JavaScriptProcessing.js in detail==

The original Processing Language was is written in Java and the syntax is Java based. Sketches written in Processing are then can be compiled into standalone applications or Java Applets. Processing.js interprets Processing sketches and creates JavaScript code that renders on a web page. When the original Processing Language, also known as P5, was first developed, Java was supposed to become the language of the web while JavaScript was a client-side scripting language for small tasks. As the web matured, JavaScript, however, became the language of the web, although many of the misconceptions about it still persist. /*(cite javascript JavaScript the good parts here*/ ) With recent developments in JavaScript technology, JavaScript is now fast enough to handle the demands of realtime real-time interactive multimedia web graphicsapplications such as games.

From it's inception, Processing.js was designed to be more than just a rewrite of the Java functions provided by Processing to JavaScript. John Resig wrote the original Processing.js parser to scan a Processing sketch for hints of Java code and convert translate that code to JavaScript. However, if the parser encountered JavaScript code, it would leave the code intactas JavaScript. This method allowed allows not only for the interpretation of existing Processing code to JavaScript but also the injection of JavaScript into Processing sketches. By allowing JavaScript to code can exist within inside a Processing Sketch intact, Java and JavaScript code can exist together sketch without any need to declare the language you are using. Old sketches written for Processing will work but new sketches written for Processing.js can not only have Processing code but can easily make use of JavaScript to interact with other elements of the webpagecommon web libraries such as JQuery or pull in resources from web services such as Twitter, Google maps, or Flickr.

ProcessingWhile JavaScript and Java are fairly similar syntactically, there are some fundamental differences that has made this conversion challenging.js The first is more than just that we wanted to do this conversion dynamically when a web page is loaded. The code produced by Processing parser re-written in JavaScript. It is designed in a way js needed to be fully object oriented and we had to provide support to all native Java functions and objects that connects the are supported by Processing language (. We also known as P5) had to take into account the differences between working with web technologies such as JavaScript, the HTML5 canvas element, JQuery, and various web servicesresources vs local resources. /*Awkward*/ Furthermore, Processing.js is built in we had to consider how we would handle some fundamental differences between Java and JavaScript such a way as to allow easy integration of new technologies as they emergetyped vs. It is designed to be fast typeless variables, function overloading and to take advantage of recent JavaScript developments to ensure that the platform is responsivevariable name overloading.

While The original code for Processing.js used regular expressions to convert Java into JavaScript when it was encountered. It did this by scanning for hints of Java code within the entire sketch and then replaced the Java are fairly similar syntacticallycode with its JavaScript equivalent. Due to the difference in how Java and JavaScript accessed object properties from methods inside an object, there are some fundamental differences that has made the with statement was used as a simple solution to avoid having to prepend all function calls with "this conversion challenging." or "Processing.". The first is However, the use of the with statement also meant that the JavaScript generated would fall off Trace (cite trace paper here... do we wanted need to do this conversion dynamically talk about trace in real time. The code produced by the converterback ground section??? ) making the code run slower than it needed to be fully object oriented and we had to provide support to all native Java functions and objects that are supported by in some browsers. In later versions of Processing. We also had to take js this method of scanning the entire sketch was replaced by the creation of an abstract syntax tree that broke up the sketch into account the differences between working with web resources vs local resourcessmaller pieces. Furthermore we had to consider how we would handle some fundamental differences between Java and JavaScript such as typed vsEach piece was then interpreted separately. typeless variables, function overloading and variable name overloading This change made the interpretation of the sketch far cleaner.

==The original code for Processing.js used regular expressions to convert Java into JavaScript when it was encountered. It did this by scanning for hints Blending of Java code within the entire sketch and then replaced Web== One of the Java code with most powerful features of Processsing.js is its JavaScript equivalent. Due ability to the difference in how Java and blend JavaScript accessed object properties from methods inside an object, the with statement was used as a simple solution to avoid having to prepend all function calls code with "this." or "Processing."code. However, the use This results of the with statement also meant this blending means that the JavaScript generated would fall off Trace /*cite trace paper here... do we need to talk about trace Processing sketches are not simply delivered in the back ground section???*/ making the code run slower than it needed to in some browsers. Later this method a self contained container but can make use of scanning the entire sketch was replaced by the creation and interact with other elements of an abstract syntax tree that broke up the code into smaller pieces. Each piece then had the regular expressions applied to change itweb. This made it was easier to apply the regular expressions correctly without accidentally converting code that was already workingsection looks at examples of such blending. It also made it easier to create proper inheritance structures and attach properties  /* insert descriptions and methods to the correct object in the hierarchy chain as smaller pieces screenshots of code was being converted at any one time.applications for demo reel here*/

One important feature provided by Processing.js is that it hides the differences between browsers. Web standards are often loosely defined, and thus variations can exist. These variations not only exist between different browser vendors but can even exist between versions of the same browser on different platforms. Something as simple as key events can vary widely between browsers. Processing.js hides a large number of these differences from the user by When creating a unified method of handling events. Regardless of content as interactive as games in the browser/platformweb, the functions these small differences can create huge problems for handling events within Processing.js are handled the same waycontent creators.

Different browser makers are also at various stages Processing.js hides a large number of implementation for various newer technologies. For example, WebGL provides typed arrays which are much faster than traditional JavaScript arrays. While these typed arrays are implemented for WebGL, they can be used outside differences from the user by creating a unified method of that context also and can provide tremendous speed improvementhandling common interactive events. HoweverRegardless of the browser/platform, not every browser supports WebGL at this time thus a fallback to regular JavaScript arrays is necessary if the feature does not existfunctions behavior of the event handlers are the same in different browsers. By hiding these differences between browser makers from the user, This standardization makes Processing.js provides a means an ideal candidate for game developers to make develop games without worry worrying about how the differences controls will differ between browsers. If a feature exists that can make the rendering smoother and faster, Processing.js will make use of it to increase performance. If it does not exist a fallback mechanism is available to allow it to still run.

The introduction of the <canvas> tag element into the HTML5 specification allowed Processing to be ported to JavaScript, thus enabling . This enables users to run 2D Processing sketches within the browser without additional plug-ins. At the time when porting the Processing.js project began, there was no plug-in free method of delivering 3D content. This limited Processing.js to its 2D functions. WebGL, A a JavaScript API that is based on OpenGL ES 2.0, is now being implemented by Firefox, Chrome and Safari. It is has become a viable candidate for use in Processing.js to render 3D sketches1. Additionally, since 0 makes use of WebGL closely matches OpenGL which is used by Processing, the porting of the to support its 3D Processing functions was relatively straight forward.

===Differences between OpenGL and WebGL===The matter of porting 3D Processing to Processing (which uses OpenGL /*1.x?? if it was opengl 2.0 it would have been even easier right?*/) js was simplified because the WebGL interface is similar that of Processing uses OpenGL, but there are a number of differences between the interfacesfor 3D graphics. The single largest difference between WebGL and the OpenGL 1.x library used in Processing is that like OpenGL ES 2.0in WebGL, the fixed-function pipeline was has been removed. Because of this, user-defined vertex and fragment shaders were are necessary for lighting operations. Since some shapes in Processing aren't lit and others were, multiple shaders were have been written. One shader exists for lit objects such as boxes and spheres, another less complex shader was written for unlit objects such as lines and points.

The following /* shaders are used for rendering unlit shapes specified with beginto go in a figure on final paper*/end function calls.

==Conclusion=Typed Arrays===Performance is always a concern when rendering 3D content, so it was necessary to create a faster version of JavaScript'script's inherently slow arrays types. Because of this, typed arrays were incorporated into pre-release versions of WebGL browsers. Unlike regular arrays which can contain different types such as strings, numbers and objects, typed arrays can only contain one type and cannot by dynamically resized. Some of these types include Float32Intay, Int32Uinty, Uint16ArrUintnd Uint8Array. These types provide a significant performance increase when manipulating arrays. (table removed)<table border="1"><tr><td>Operation</td><td>Array</td><td>Float32Array</td></tr> <tr><td>Write</td><td>8947</td><td>1455</td></tr>

<tr><td>Read</td><td>1948</td><td>1109</td></tr> <tr><td>Loop-copy</td><td>&gt;10, 000</td><td>1969</td></tr> <tr><td>Slice-Copy</td><td>1125</td><td>503</td></tr> </table> Win7 64Bit, 4GB Ram, Dual-Core 1Processing.30Ghz Intel U7300(citation needed) Alistair MacDonald [http://weblog.bocoup.com/javascript-typed-arrays link] Because typed arrays are only available js seamlessly integrates elements of a webpage to create a viable platform for pre-release browsers, they cannot currently be used in 2D sketchesgames on the web. Once they become implemented It handles events in a consistent manner between different browsers, a significant amount of the Processingmaking it easier for game developers to create content with it.js code base can make use of these structures, increasing performance throughout Furthermore the libraryinterpreter was written efficiently. Today's JavaScript engines are highly efficient... /* andor, mike said its This efficiency means that interactive applications such as games can be written inJavaScript. Processing.js makes this process smoother. is it???*/ ==Conclusion==