General Instructions

The Game On Launch Party is on the 22nd of November, so submissions should be… submitted, by the 19th of November.
Keep your submissions between 30 seconds to 2 minutes long. The event only goes for a couple of hours, so we can’t really showcase your epic 3 hour VJ mix. Sorry. Slightly longer or shorter is fine. Considerably longer videos will be brutally edited by Jaymis, who is Brutal.
For best results, content should be delivered in 25FPS, PAL format.
Projection Mapping content should be high-contrast, as the project doesn’t have enough budget for more than 5000 lumens worth of projector, which means that fine detail and subtle colours will be lost.
Audio isn’t required. You may deliver video with audio, but it won’t be heard.

Video Delivery

Videos should be delivered at the highest quality your connection can muster. There’s no need for full uncompressed videos, but high bitrate H264 or MJPEG videos would be great.
My favorite method for delivery would be vimeo. Upload your video there, make sure that “Allow other people to download the source video.” is checked, and then email me with a link. If you’d like your video to be private, add me as a contact and you can make it so only I can view and download the video.

If you’re not in to vimeo, give me an email and we’ll work something out.

Resources

The lovely and talented Karl Kwasny has been awesome enough to provide us with some gaming-themed illustrations for our animation and remixing pleasure.

I’ve cropped these to separate layered PSD files (so you can tweak the colours and line art etc. if you’d like), and created transparent PNGs as well. Bargain!

Game On Characters (5.5MB Zip)

These images are released under a Creative Commons Attribution-Noncommercial-Share Alike license. You’re free to use these resources for remixing for this project, and for your own non-commercial use. However, derivatives must also be released under the same license, and must contain attribution to the original source.

Cloud Projections

For those who’d like to be involved, but don’t have the time to go all custom and projection mappy, we’re going to have a series of screens throughout the venue displaying work from international visualists. The screens will be shaped like the “8Bit Cloud” in the image below.

If you’d like to submit any general video content, we will be able to mask it to be displayed in these screens. However, if you’d like to create some content specifically designed for the screens, I’ve made some templates for you:

Game On Cloud Template (25KB Zip)
This zip file contains a transparent PNG file which you can use as a mask over your video, or some layered photoshop documents if you’d like to be a bit more advanced.
Final videos should be delivered in the slightly bizarre size of 760×467 pixels. Use the template as a guide and you can’t go wrong.

Projection Mapping

This is a little more complex. As we couldn’t be guaranteed that the position of the projector on the launch night would match the position on our test run, we’ve had to mostly scrap our plans for a “real” 3D mapping setup. Most of the work will be a “2.5D” mapping, where flat videos are warped in 3D space.

We’re also constrained by our reasonably paltry (for the space and ambient light) 5000 lumen projector. So your content should be reasonably high-contrast, and colours should be bright. Fine detail and subtle colours are likely to get lost, so put the subtlety-brush down and grab your vividity-mallet.

We’re still working on getting the precise dimensions for the flat templates, and they’ll be posted here when completed. However, if you’re going to be super advanced and create something in 3D space which can be later exported as 2D faces, then we have 3D models of the space available for you:
Game On Mapping 3D Models (120KB Zip)

Warning! You’re on your own with these models. The dimensions are correct, but we’re not certain of the camera/projector viewpoint and angle. So your animation will either need to be exported as flat “texture” videos, or you’ll need to change your scene camera to fit the viewpoint of our 2D templates (when they’re finished). So, going all-3D is probably a little risky. Should be fun though! Good luck with that. Give me an email if you have any questions or concerns.

Updated Mapping Models

Apologies 3Ders for the delay. I finally have the mapping templates ready from our test run at the venue.

SLQ Map Release Version (630KB Zip).

This file contains original, editable .AI and .EPS templates with all layers and bricks separated, as well as exported PSD and PNG versions for people who just want to work with the shapes.

There are also 2 jpgs entitled “Stairs-explained” and “Wall-explained”, which provide a legend as to which bits of the template go where on the wall.

Finally, the file “SLQ-Map-2D-Template.png” is an output from our session at the library with VVVV. This file is in the native resolution of the projector we’re using – 1024×768. So you can see that the templates we’ve provided are much higher resolution than our final output. We’ve done this to give you as much precision as possible when creating your videos, but we don’t expect you to deliver videos 3000 pixels wide.

Usage of the Mapping Models

This is where things get a little free-form. We know that everyone has their own workflow and techniques, so we don’t want to confine contributors to a partilcular format. If you’d like to pre-warp and render out your work to fit the dimensions in the “2D Template” file, that should work fine. Otherwise if you’d like to render out flat files based on the “Stairs Section” and “Wall Section” templates, we’ll be able to map these to the wall ourselves, and probably get a slightly higher quality result.

Likewise, don’t feel you need to be producing content for the entire surface. If you’d like to just focus on a couple of sections of the wall, or even create content for a single rectangular surface, feel free. Please get in touch and keep us updated on your progress, so we know where things are going when you come to deliver your files.

Final Delivery

As mentioned above, we’ll try to be as flexible as possible with delivery. Aim for high quality files, but the final output will be warped to fit inside a 1024×768 rectangle, so there’s no need to waste time rendering and uploading at full-HD resolution, unless this particularly turns you on.

I would also suggest rendering and uploading a draft version of your work, so we can check to ensure that it’s going to fit with what we’re doing, and that you haven’t made any glaring geometrical errors.

Collaboration and Progress

If you have any questions or ideas you’d like to discuss publicly, use the comments of this post. Similarly, if you have any materials or resources you’d like to share for others to remix or use, feel free to post them as well.

More information: Game On tag on CDMotion.

smooth(), Processing’s anti-aliasing, doesn’t always do what you expect. It isn’t supported at all if you’re using P3D as the renderer, and it’s only really consistent in the default renderer (aka P2D). But sometimes it should work, and it’s just your fault. See if this sounds familiar: you go to draw something, and mysteriously, your anti-aliasing looks really odd or missing.

The problem is that, if there’s a draw() loop and no background, Processing will progressively overwrite the screen, making any anti-aliasing disappear and look blocky. In the image here, you can see what that looks like on the left, with the corrected version on the right.

The solution: add a background() statement, choose noLoop() if you just want it to draw once, or add a fill to “clear” the screen before drawing. One way to do that: choose a fill color, then enter:

rect(0,0,width,height);

This image comes from one of my students, who was having just this issue. (But like I said, I made the same mistake!)

Of course, it’d be great to hear from others with similar issues.

The following libraries might also be of use:
http://www.texone.org/prosvg/
http://processing.unlekker.net/SimplePostscript/index.html

PDF

Several students had problems with font embedding using the built-in library. Symptoms: strange, blocky letters. The issues seem to occur on Mac OS X (all the students in this case I believe were on Mac exclusively.) The reference documentation for the PDF library offers this clue:

Starting in release 0120, text is no longer treated as shape data by default, meaning that the font will need to be installed to view the PDF that’s created. The upside is that the PDF will render better (particularly in light of the Mac OS X bug noted here). To force text to be treated as shape data, use textMode(SHAPE), immediately after size(). See the developer reference for textMode() inside PGraphicsPDF for more specifics.

But so far, forcing SHAPE hasn’t been very helpful.

Colin Owens has this tip instead:

Placing:

hint(ENABLE_NATIVE_FONTS);

before text();

does the trick.

This needs to happen before all your other font/text code. (I believe setup() is optional.)

I also suggested, for those on the Mac, at least, that people get fonts working on Mac and try re-saving in Preview.app for cross-platform / cross-machine compatibility as needed. (The same would be true with Acrobat or any PDF builder on any platform, just in case the library is misbehaving.)

Oddly, people are still having issues in which the first couple of characters are garbled, so they’ve taken to hiding the first two characters used. Bizarre.

SVG

Mahesh Gudapakkam was having some problems with the SVG graphics format, even following examples from Ben Fry. Nicely enough, he solved it himself.

Basically, the issue was tag information being handled in a way other than he intended, thus triggering an array out of bounds error.

First, the symptoms:

running into a problem here .. i am trying to work with a SVG version of the US map.

i have a version that works well – zooms in and out and scales the way i want to – unfortunately i had no way to control characteristics of individual states (only later did i realize that SVG’s can have markers for individual states stored as attributes to its tags and my svg image didnt have any – i downloaded a free one of the web)

i realized the above while reading through ben fry’s [book Visualizing Data]. in an example of his, he points to an SVG on wikimedia (http://commons.wikimedia.org/wiki/Image:Blank_US_Map.svg)

for some reason when i work with this file i get an exception
java.lang.ArrayIndexOutOfBoundsException: 1

all i am doing at this point is declaring a SVG object and reading this downloaded object into it .. and then trying to display it – any ideas?.. processing version is 0135Beta

The problem? Poorly-formed tags:

quick update. i was able to figure out what was causing the array out of bounds error. comparing the working svg vs the one not working and picking up on some threads from some of the early postings rgd’ing issues with candy’s parsing on the processing forums – i found that the graphic tag had some extra attributes. here’s how it appears in the non-working ones.

<g id="g4" transform="translate(-4,4)">
OR
<g
     id="g4"
     style="fill:#d3d3d3"
     transform="translate(-4,4)">

the candy svg library seems to not like this – once i reduced it down to it happily worked. also a few other things i had to change -
1. it does not work with the tag either – needed to get rid of it
2. some other tags it failed to work with are ones that had these attributes

# sodipodi:type="arc"
# sodipodi:nodetypes="cc"

processing complained that it does not recognize the shape command – once i got rid of these attributes it didnt complain of those errors ..

once i addressed all of these i was able to get the svg to work with candy.

this might be something of interest to others in the group who might end up working with SVG’s .. these tags get produced even when you use a program like illustrator to create a svg (i went that route too and it produced errors as well). hopefully it will save them some time.

If you run into other errors like this, let us know!

For Ignite NYC, I made a five minute presentation demonstrating basic programming concepts, as illustrated in Processing. The point: basic code literacy is as important today as basic arithmetic knowledge, and there’s no reason to be afraid — by working with code visually, you can learn to program, even with “advanced” concepts like object oriented code.

I’ll elaborate on this more for those not there, but if you did make the presentation, these additional code examples should be helpful (in case you missed some of what I was saying in the 15 seconds allotted each slide!)

Referenced Code Examples

Putting something on the screen: Using commands like “line” means everything you do can give you immediate visual response. Line does what it sounds like it does, and takes four simple arguments: x and y coordinates for the start point and end point.

line(0,0,200,200);

An interactive line: Add a draw() loop, and the line you draw becomes interactive, working with the mouse.

void setup() {
  size(400,400);
}
void draw() {
  background(255); //try moving this line to setup and watch what happens!
  line(0,0,mouseX,mouseY);
}

Make values visible: The numbers can also be meaningful values — in this case, from the internal clock.

void setup() {
  size(400,400);
  strokeWeight(50);
  strokeCap(SQUARE);
}

void draw() {
  smooth();
  background(255);
  line(100,0,100,(hour()/24.0)*height);
  line(200,0,200,(minute()/60.0)*height);
  line(300,0,300,(second()/60.0)*height);
}

Variables: Using variables in place of fixed number values allows you to adjust that value — over time for animation, to transform the value aesthetically, and to experiment with how code works.

In fact, the best way to start to figure out code — even before you’re sure how it works — is often to start messing around with values. Sometimes “breaking” code you don’t understand can be a great learning experience. For instance, see what happens when students start to “mess up” the game Breakout to transform it aesthetically and make new art.

Changing values can also help create surprise. You don’t have to hook up variables the way someone would expect. Watch what happens when you move mouseX and mouseY with our interactive line:

void setup() {
  size(400,400);
}

void draw() {
  background(200);
  line(mouseY,height/2,width/2,mouseX);
}

Loops: Seeing a loop happen — even a simple one — illustrates the way the process of iteration can work in more complex problems.

int numOfLines = 10;
int distance = 10;

size(200,200);
background(0);
stroke(255);
strokeWeight(3);

int yPos = 20;
for(int i=0; i<numOfLines; i++) {
  line(20,yPos,width-20,yPos);
  yPos += distance;
}

//bonus!
/*
int yPos = 20;
for(int i=0; i<numOfLines; i++) {
  line(20,yPos,width-20,yPos);
  yPos += distance;
  distance += 2;
}
*/

Loops and arrays: Using arrays (lists) with loops can help to simplify code, even in a simple example — loops and lists are a natural match for one another, since the former lets you iterate through the latter.

int[] circles = {170,113,78,30,13};
size(400,400);
background(150);
noStroke();
smooth();

for (int i=0;i<circles.length;i++){
  fill(random(0,255),random(0,255),random(0,255));
  ellipse(width/2,height/2,circles[i],circles[i]);
}

Loops within loops: You can also place a loop inside a loop. What’s that mean? It helps to see the result.

int[] circles = {170,113,78,30,13};
size(400,400);
background(150);
noStroke();
smooth();

for (int j=0;j<4;j++) {
  for (int i=0;i<circles.length;i++){
    fill(random(0,255),random(0,255),random(0,255));
    ellipse((width/4)*j,(height/4)*j,circles[i],circles[i]);
  }
}

You can extend the loops within loops concept to more involved iteration, such as iterating through columns, then rows — essential to processing the individual pixels in an image.

Java is quick enough for doing this with smaller images and even video, though for better performance, it’s also possible to perform some tasks using shaders on the GPU, thanks to Processing’s support for OpenGL. (Image processing, video processing, and OpenGL are best left to a separate discussion!)

Functions can be understood as recipes. In pseudo-code:

makes cake "Cakemaker" (eggs, flour, ingredients, etc...) {
  step 1
  step 2
  step 3
  return cake, serves 8
}

Objects: Object-oriented programming may seem mystical, but it’s really just a way to better organize code functions. For instance, in the case of the cake, we might consider what the attributes of a cake are, what can be done to it (make a cake, eat a cake, throw a cake at someone’s face), and then organize it relative to smaller categories of related things (cupcakes) and bigger categories of things (dessert).

In visual terms, that allows us to create fast, readable, powerful systems for visual expression, like particle systems. In the included Processing example Topics > Simulate > MultipleParticleSystem, for instance, you’ll see particles and systems of particles defined as objects.

Code for Making the Presentation

For Ignite, I wrote a quick Processing sketch that allowed me to quickly generate the slides I would use. The event needed a PowerPoint file, but I could at least output images to drop into another program for PPT export (hence the saveFrame() function, which saves image files). And for my own purposes, I don’t even need PowerPoint.

Note that in addition to the Processing file, the data folder contains:

• image assets
• fonts (generated in Processing with Tools > Create font…
• a text file with the text for the slides

To create the text file, I simply separated bullets with the “@” character and put a tab between titles and body text. The split() command in Processing then divides up that text into necessary Strings. So, for instance, the first slide looks like this:
visual code literacy Code literacy == math literacy @Technologists, artists (non-specialists)

What this means is that very little code is needed for the presentation — and it’d basically work for any presentation of this template. I saved time versus working in PowerPoint.

You need some Java classes, listed at top, for this to work.

import java.util.*;
import java.text.*;

String[] slides;

PFont font;
int currSlide = 0;

void setup() {
  size(800,600);
  slides = loadStrings("p5_5slides.txt");
  background(0);
  font = loadFont("TimesNewRomanPSMT-14.vlw");
}

void draw() {
  String[] headerString = split(slides[currSlide], TAB);
  String[] bullets = split(headerString[1], '*');
  println("Header: " + headerString[0]);
  for (int i=0;i<bullets.length;i++) {
    println("Bullet: " + bullets[i]);
  }
  saveFrame();
  if(currSlide < slides.length-1) {
  currSlide++;
  }
  else {
    //currSlide = 0;
    stop();
  }
}

Image Credits

In the presentation…

Dinner check by Jim Reynolds:
http://flickr.com/photos/revjim5000/2445394705/

LOGO-generated image graphic created by remi, logo source code created by Arbol01, via Wikimedia:
http://en.wikipedia.org/wiki/Image:Remi_turtlegrafik.png

Apple II image by Florian Eckerstorfer
http://flickr.com/photos/florianeckerstorfer/1870727397/

Breakout art, as featured in Create Digital Motion:
http://createdigitalmotion.com/2007/04/17/breakout-hacked-into-art-in-processing/
See also Game Mod:
http://www.trsp.net/teaching/gamemod/

NOAA climate information from the National Weather Service:
http://www.weather.gov/climate/

Vintage cookbooks by Patrick Q:
http://flickr.com/photos/patrick_q/199986515/

All other images by the author

[SlideShare embed]

PDF download

Examples Download

I’ve been working on creating a set of stupidly simple examples for Processing — even simpler than the ones that come with Processing itself. The idea is to put as little as humanly possible in them, so that you can demonstrate the basics of programming with code examples, even in very short workshops for people who may not have any programming experience (and I mean really short — what if you want to show something in 5 minutes?)

Download the sample files:

Simple Examples 0.01 [ZIP archive for Processing 0135]

Consider this an early preview, and I welcome feedback. Major thanks to Ben Fry for some of the inspiration about how to go about this.

To a beginning Processing user, the libraries section of the Processing site can cause a "kid in the candy store" effect. I actually recommend going a little easy, working with one library at a time. But, at the same time, working with libraries really is essential to working with Processing, because Processing "core" is kept as conservative as possible. This is especially true if you’re working with multimedia. Here are the libraries I recommend for specific multimedia applications, as a starting point:

Sound and MIDI

genPunk uses the Ess library to build an entire music app inside Processing. But you may be best off starting with Minim.

Minim is currently the most reliable sound library available, because it hooks directly into JavaSound, as well as the easiest to use and best-documented. It’s worth looking at the other libraries here, but this should be your first stop as a beginner.

(Note that JavaSound tends to be more reliable on Linux and Windows because of some implementation issues with Apple’s version of Java.)

proMIDI is currently the only library for interfacing with MIDI support. I recommend it with some trepidation, because there are some odd things about implementation — note off events don’t work quite right, for instance. But for basic MIDI data, it works. If you’re planning to get heavy into MIDI, I actually suggest accessing JavaSound’s MIDI tools directly; it’s a little tricky, but there’s superb documentation at jsresources.org, which is maintained by the lead developers of the modern version of JavaSound. Another tool to consider is jm-Etude; by working with the excellent jMusic API, it makes writing MIDI code much more musical.

Video

Shadow Monsters, an audiovisual piece by Phil Worthington, uses blob tracking to create an unusual puppetry effect. It uses JMyron for analysis.

First: start with the internal video library. There’s actually a lot you can do here. If you get weird error messages (assuming you’ve read the documentation for platform-specific caveats), try reinstalling QuickTime — buggy QT installers have a tendency to randomly wipe out Java support, and reinstalling sometimes just fixes the problem.

Then, libraries…

Short version: Get JMyron and go to town. Make sure you have the Intel build if you have an Intel Mac.

Long version: Remember the "Read Me" file you ignore? This is a time when you need to read the documentation. See the documentation of Processing’s own video library for some important caveats and bugs on all three platforms. The Mac should work, though sometimes can have random crashes or problems with capture. Windows requires the often-unpredictable WinVDIG for input; Linux doesn’t work at all. Don’t blame Processing: blame Apple’s now-defunct QuickTime for Java, and the general lack of any Windows/Mac cross-platform library.

But don’t give up. There are some nice things that can be done with computer vision on Processing.

I especially recommend JMyron for basic computer vision techniques. Note that you’ll need to download an Intel build of JMyron’s jnilib file to make it work on Intel Macs; you’ll get some odd error messages otherwise. That Intel recompile is on the jibberia (aka Kevin Cox) projects page. (Look for the following text):

libJMyron.jnilib compiled for intel macs replace the one in /Applications/Processing/libraries/JMyron/library/ with this one. yay

One other note: if code for JMyron contains the getForcedWidth() or getForcedHeight() calls, you actually need to remove that for the code to execute without throwing an error on Mac. On Windows, you may need to call those somewhere to avoid weird video problems. Don’t ask. Video can be a pain.

The BlobDetection library also has some nice CV features, but no special capture features. I do not recommend LibCV for capture; the odds of you getting the ancient Sun JMF media library on Java to work at all are, optimistically, extremely slim. But like BlobDetection, it also has some interesting features.

Also, don’t overlook the built-in capabilities in Processing:

pixels[] is an array of pixels in the display window. (If you’re using JMyron, you can copy pixels from JMyron’s capture and analysis features into that array.) A lot of computer vision simply involves looking at what’s contained in this array.

3D

OBJ Loader … um, loads OBJ files (example pictured at right). With plug-ins, this includes, for instance, files exported from Google’s SketchUp. (I believe you need the paid version of SketchUp, not the free version, for this feature — check out the super-cheap academic pricing if you qualify.) It’s the easiest way to get 3D models into Processing.

surfaceLib is the library that does a lot of the tricks that allow those gorgeous, pulsating 3D objects you see in a lot of the Processing videos. But even if that’s not your style, it provides key capabilities like the ability to figure out the coordinates on a sphere without having to crack open your old Calculus book.

Dan Shiffman’s Vector3D is useful for other math tricks, covered in his class’ examples for lovely 3D animation effects — again, without a lot of wading through math texts or duplicating code over and over again.

Physics

traer.physics is a very elegant, simple physics library that’s great at making springs and particle systems. It does not do everything it’s possible for a physics library to do — but it does work in three dimensions (take that, Flash!), and its simplicity makes it a fantastic starting point. It’s also very fast. (Take that again, Flash!)

As the site there says, you just get coordinates, so once you’ve got that you could, for instance, use image() to draw a particle or create geometry or whatever you want.

Prototyping and live performance

When the team working on the Muon installation wanted to adjust the installed version of their artwork, they used the controlP5 library to get exact feedback on what they were doing.

How much time do you spend re-entering numbers for variables to try different settings? That’s fine when you’re first working on code — less so when you’re trying to play live or do an installation. Here’s the solution:

controlP5 has two key features. First, it makes controls (sliders and such) so you can easily adjust variables. Second, it hides those controls when you want them out of the way. So, for instance, you get to a site for an installation, show your controls, make your adjustments, hide your controls.

Java has more powerful features for UI, but for art projects you probably don’t want that much complexity. controlP5 should have you covered.

This is not a complete list

It’s a field guide to some of my favorites. As you can see, it still winds up being pretty long — which is the reason Processing uses libraries in the first place. Once you start adding features to core, it gets complicated fast. In this way, you stay close to the applications for which the features are actually being used — and you can pick and choose just what you need.

As always, check the libraries page for a wide variety of libraries — and keep your eyes on the Processing Blogs or forums, where things often show up first.

You can also make your own libraries according to instructions in the libraries folder of the Processing install. On the top of my list to put together:

• IMAP support
• Flickr API
• Native capture on Mac, Windows, and Linux for video
• Video playback on Mac, Windows, and Linux
• A new MIDI implementation

So if I finish any of those, I’ll be sure to share on our CDM Labs (and probably brag about them on CDMotion and CDMusic, too).

Unfortunately, the best library for tablets has been Windows-only (works with any Java app and — very nice — with applets in a browser):

JTablet

Now, there’s a Mac alternative, which eventually will wrap JTablet on Windows so you can deploy across platforms:

libTablet 0.1

The wonderful Marcus Wendt put this together — thanks! Let me know how it goes.

Jesse Kriss, who built MaxLink for embedding Processing sketches in Max/MSP/Jitter or communicating between Processing and Max, has a new library called EasyOSC. It uses the OpenSoundControl protocol, which is useful for communicating between apps, computers, and some hardware (like the Monome).

What’s great about it is how easy it is to communicate with other software — ideal if you’re using Processing alongside a sound tool like Reaktor or (in Jesse’s case) ChucK, or with multiple computers running.

http://jklabs.net/easyosc/

You use simple syntax like osc.send("values", values) to transmit data.

Audiovisualists, this should help your mayhem across media. If I come up with some examples, I’ll post them to CDM, perhaps with a basic tutorial for those unfamiliar with how OSC works (and there are some tricks to it in other languages).

What you need

JavaMail API (part of the enterprise Java platform, but available for free to desktop Java users as well)

Get the download, refer to the JavaDocs for reference (note that if you’re not using Java 6, there’s an extra support download for the "JavaBeans Activation Framework" — don’t actually need to know what it does, but you will need it with earlier Java versions)

jGuru: Fundamentals of the JavaMail API: A decent step-by-step tutorial, though you may want to compare it to some of the sample code (installed to the "demo" folder when you install JavaMail) to see how this fits together in a completed example.

Connecting to your favorite email provider

The JavaMail API FAQ specifically addresses Gmail and Yahoo! Mail.

IMAP is more fun, because it allows access to folders other than the inbox. To connect to Gmail IMAP, you need to use the "imaps" protocol for a secure SSL connection, rather than plain "imap".

Accessing folders is a little wonky in Gmail. Aside from the Inbox, labels and folders are accessed like this: store.getFolder("[Gmail]/Spam").

Examples

It takes just a few lines to connect and retrieve some basic information about messages. I’ll post code examples soon.

It’s helpful to know something about the java.util.Date class. Specifically, if you want to compare sent dates or otherwise manipulate time, first use message.getSentDate(), then take that date information and use getTime() to translate into milliseconds.

Week One

What’s Processing?

A little bit of history

Processing is Java

How is Processing different from things that aren’t Processing?

Hello, world, Processing style

Install Processing, Java

Draw "hello"

Say "hello"

Processing syntax

Using the IDE

Using help and documentation

Putting stuff on the screen

Coordinates

Drawing

Color

3D coordinates

Textures

Load an image

Load a video

What next

Where to find inspiration

Where to find libraries

Where to find code

Week Two

Reading pixels

Video capture

Working with 3D

Basic sound playback and analysis

Connect to MIDI

Arduino introduction

Week Three

Video analysis

Advanced hardware

Networking

Data