If you want fullscreen on a single window, I recommend using Processing’s built-in “present” mode. Present mode is very stable, and is the most recommended and documented method. If you use present mode, be aware that if your application crashes, you may have difficulty being able to get out of the window. You will also want the application’s size() to be set to your desired screen’s dimensions using screenWidth and screenHeight. Using the Processing IDE for sketching you can easily enter present mode by selecting “Sketch->Present” from the menu. This does not require any code. If you are using Eclipse or you would like to export your application to run in present mode you will need to override the first function called in every java application:

public static void main(String args[])
{
        //launch in "present" mode, your class is "Sketch021210" (prefix with package if used)
	PApplet.main(new String[] {"--present", "Sketch021210"});
}

If you need extra functionality, such as being able to toggle between fullscreen and windowed mode, you can use the Fullscreen API, which offers more features but can be buggy.

The Fullscreen API has caused problems for me several times, and is known to not play well with OpenGL. It has also been the best solution I have found for several projects and am very thankful for the developer that has put a lot of effort into it. The Fullscreen API previously would not render graphics on a secondary display, but a new class SoftFullScreen has made this possible. This is a great API, but should be used with caution.

If you are using multiple dedicated computers for your displays Most Pixels Ever by Daniel Shiffman and some students at ITP is a library for Processing (and also available for openFrameworks) that is simple to set up and can span across many screens. ITP students use Most Pixels Ever for their Big Screens annual show. This is a great and stable solution and will work fine whether or not you are using OpenGL. It also can have resource advantages since the computation is split between machines. Each machine communicates with the others over a server, so there is a little bit of extra set up. You also need to watch your random number generators, if your sketches use random() the computers will return different values and not remain in sync.

If you are using a single computer for multiple displays, even if you want to use OpenGL, then this is when you will need to bring your project into Eclipse and override a few pre-determined things in Processing. If you are unfamiliar with Eclipse, you may want to look at this posting I wrote: Advanced Processing in Eclipse. In my opinion, this technique is the most valuable for Processing users to know. This solution is flexible, will allow you to keep using OpenGL and it will save you the work of splitting your project onto multiple computers. This solution involves a combination of accessing Processing’s JFrame and setting it to be undecorated (which removes the system chrome), positioning the window, and then if you are on a Mac, you will use the applications info.plist file to tell OS X to hide the menu bar. Here is an explanation of the process:

1. Before the setup() method of your sketch is called, PApplet (the core applet class for Processing) calls init(). During the init() method Processing displays the application’s JFrame, we must override this method and alter the JFrame before it is displayed (this can also be found in the processing:hacks).
2. That will hide your system chrome by accessing the “frame” property before it is ever displayed, doing this inside setup() will not work. Your next step is to position the window. In the above link it is recommended to call frame.setLocation(x,y) immediately following size(), I have found this to not work, so I recommend doing it on your first draw().

   
   
   public void init() {
   	  /// to make a frame not displayable, you can
   	  // use frame.removeNotify()
   	  frame.removeNotify(); 
   
   	  frame.setUndecorated(true);
   
   	  // addNotify, here i am not sure if you have
   	  // to add notify again.
   	  frame.addNotify();
   	  super.init();
   }
   
   void setup()
   {
     size(2048,768); //2 1024x768 monitors horizontally
   }
   
   void draw()
   {
     if(frameCount == 1)
     {
        frame.setLocation(0,0);
      }
   }
   
   

3. This step is only necessary if you are on a Mac: go to your jar, right-click on it and select ‘Show Package Contents’ inside the ‘Contents/’ folder is the file ‘info.plist’ open that file in XCode. On the left column you will see “Application UI Presentation Mode” that needs to be set to “All Hidden”. To change this, right-click and select “Show Raw Keys/Values” then select 3 on the right column. Save and quit.

There are currently 18 examples on the site, most of which have focused on being direct ports of the examples from Toxiclibs. Of these examples 14 use Processing.js, 1 uses Three.js, 1 uses Raphael.js, 1 uses Canvas’ 2D API and the other Canvas’ WebGL API. There also is an example using Gee committed by jonobr1. In the future I will be expanding on examples that help clarify the libraries JavaScript nature and independence.

The last 4 examples on the site demonstrate the newest package for Toxiclibs.js, VerletPhysics2D. This package is a light-weight physics engine that is simple to work with and runs well, the Attraction 2D example performs smoothly with 250 particles. VerletPhysics2D includes a base particle class, behaviors, constraints and springs. Behaviors (such as Gravity or Attraction/Repulsion), constraints, and springs are easily applied to the physics world as a whole or to individual particles. You can compare its use with the java documentation for physics2d. I am very excited to have completed this portion of the library, I feel that it fits a void that isn’t currently filled by other physics engines in JavaScript, so please download it and give it a try! And check the site for the new examples.

A great deal of my work involves using HTML5′s canvas tag for generative design; much of the time with the help of Processing.js. Repeatedly, I have spent the time of stripping out references to toxiclibs to make my code work with PJS. I worked-around porting the library for some time because it felt like too large of a project to do by myself. Last week as I was working on a WebGL visualization, I decided it was worth it to port the Vec3D class, and couldn’t stop there. I decided that this has to be done, I badly want these libraries and there have got to be many others thinking the same thing. I encourage anyone interested to contribute to the project.

I am hosting my source at gitHub, http://github.com/hapticdata/toxiclibsjs, and I have prepared an intial round of examples that you can view at http://haptic-data.com/toxiclibsjs. The code already includes several classes for both 2D and 3D use, there are currently examples on several topics, such as using the TColor class for blending, converting and modifying colors, using Line2D, Vec2D and many others. If you aren’t a PJS user, one of the great things about this library is that it has no dependency on Processing.js. This is all JavaScript, with no dependencies, it can be used with other libraries, such as Raphael.js, or it can be used by itself.

To provide a basic understanding of who I am and the work I am creating you may visit my work portfolio, workofkylephillips.com, and my personal site haptic-data.com.