Processing

Processing is "a programming language and environment built for the electronic arts and visual design communities. It was created to teach fundamentals of computer programming within a visual context and to serve as an electronic sketchbook."

Given an introduction like that, I expected it to have a much different feel than it does. I expected a domain-specific direct-manipulation model, and I got a thin procedural wrapper. For example, consider this RGB Cube demo. I'd expect the source code to look something like this:

#pragma 3D_WORLD
Square s;   (implicitly centered in the viewport)
s.all_faces.shading_method = 
        Shading_Method_Interpolate_Vertices;
s.vertices.front_upper_left.color = black;
s.vertices.front_upper_right.color = red;
s.vertices.front_lower_left.color = green;
s.vertices.front_lower_right.color = yellow;
s.vertices.back_upper_left.color = blue;
s.vertices.back_upper_right.color = purple;
s.vertices.back_lower_left.color = cyan;
s.vertices.back_lower_right.color = white;

on mouse_move {
        s.rotate_around_x_axis(mouse.delta_x);
        s.rotate_around_y_axis(mouse.delta_x);
}

But the reality is much easier to implement, and much more disappointing from a user's perspective.

  • Instead of having things like mouse movement deltas readily available, you have to explicitly remember the old mouse position, and subtract it from the new position.
  • The square, instead of being an object, is defined as a series of calls to the vertex() function, preceeded by beginShape(QUADS), and terminated by endShape().
  • The color of the vertices is also completely dependent upon the order of function calls -- you call fill() to set the global color, and that gets inherited by the calls to vertex().
  • There's this completely non-intuitive idea of push() and pop(), to save all the global variables, presumably so that cumulative calls to translate() don't walk you off the screen. At a minimum, I would have expected the loop() function to have implicit calls push() and pop().

In other words, Processing seems to be nothing more than a thin layer over OpenGL, implemented inside a Java applet.

I've got to admit though, some of the applets are really cool.

Posted on January 19, 2004 07:52 PM
More languages articles

Comments

This reminded me of an idea I had a long time ago but lacked the language design skills required to actually implement -- namely a system that generates an interactive graphical rendition of an Origami model from a declarative specification.

All you would have to do is specify an Origami model (or paper airplane or whatever) as a series of paper folds. The system should be capable of deriving the geometry of the resultant model on its own. You could then animate the sequence of folding steps and interact with the model in different ways.

I came across Doodle soon after, but it takes a more procedural approach than I had imagined.

-K

Posted by: Kaushik at January 20, 2004 08:06 PM

this is very opengl-like. They're either basing this on gl or more likely using opengl with a thin layer of translation. Their 2d code is very different, and makes you write your own masking. At least the sprite demo did.

Posted by: Jesse at January 21, 2004 03:46 PM

I was introduced to this several months ago, and also expected something much greater than what it was. The magazine (Wired, maybe?) talked about it like it was this revolutionary idea that makes graphical programming easy and fun. So happens that was precisely what I was looking for, game programming sucking and all.
It had a very C-like syntax, and didn't do much for you. The complexities of graphical programs were as pervasive as ever, and I was turned off within seconds.
Not to say it's bad or anything. OpenGL is one of the best designed libraries ever, in my opinion. It's the only part of game programming that I don't despise.
And, yeah, the demos are pretty cool.

Posted by: Luke Palmer at January 22, 2004 01:14 AM
Post a comment









Remember info?




Prove you're human. Type "human":