Processing.org is a cool little thing; you can't look at two or three of the demos on their site before you realize it's
really neat. Not to mention it's designed as a compliment to
Wiring, the language used to program the
Arduino and a number of other DIY hardware platforms.
So suffice to say, Processing is a compelling alternative to Flash for at least a handful of usage scenarios. So what if you're a Java/ Groovy programmer who wants access to Processing's coolness, without using their cute IDE? We're Java programmers after all; if I can't use Eclipse and integrate it with Hibernate and Spring -- well, that would be overkill. But let's just get to the point: you can use Processing.org straight from your Java environment. In fact,
here's their JavaDoc.
But, the Processing language is actually kinda nice! And if you look at all of those functions that Processing provides, they're all in the PApplet class. Well that's a pain in the ass. Never fear -- that's where Groovy steps in. You can use Groovy's language features to Make Processing's API
at least as easy to use, and you get all of the cool features of the Groovy language as well!
Enough rambling -- here's an example:
import processing.core.*
/**
* A group of dots appear and then shrink in size.
* This sketch uses the Groovy List and uses a second class SpriteEllipse.
* This main extends PApplet so it can create the window.
*/
class CirclesDemo extends PApplet {
// setup vars
def sprites = []
def renderer = JAVA2D // P2D
// state
int nCount = -1
def animating = true
int clickX, clickY = 0
void setup() {
ellipseMode CENTER
size 400, 400, renderer
frameRate 20
smooth()
textFont loadFont("TrebuchetMS-20.vlw"), 14
}
void draw() {
background 120
nCount++
nCount %= 90 // add additional sprites every so often:
if ( ! nCount ) (1..20).each {
sprites << new SpriteEllipse( this )
}
def clicked
sprites.each { s ->
s.update()
if ( s.dead ) s.init()
else if ( clickX && s.isOver( clickX, clickY ) ) clicked = s
s.render()
}
if ( clicked ) sprites.remove clicked
clickX = 0
fill 255 // set text color
text sprites.size(), 5, height-5 // update sprite count display
}
void keyPressed() {
if ( key == ' ' && animating ) { noLoop(); animating = false }
else { loop(); animating = true }
}
void mouseClicked() { // get mouse click pos for next draw() call.
this.clickX = mouseX
this.clickY = mouseY
// println " $clickX $clickY"
}
static void main(args) {
PApplet.main( [ "CirclesDemo" ] as String[] );
}
}
Now the 'SpriteEllipse' class really could just be rolled up into the above
class -- since its functionality all comes from the PApplet anyway. But in Groovy
you can easily separate the functionality into a separate class and use Groovy's
@Delegate to make it appear that SpriteEllipse extends PApplet.
import processing.core.PApplet
class SpriteEllipse {
private Float x = 0
private Float y = 0
private Float rad = 75
private Integer color = 20
private @Delegate PApplet pApplet
SpriteEllipse(PApplet pApplet) {
this.pApplet = pApplet // must be set first since it is delegate
this.init()
}
void init() { /* Initialize fields to random vals */
this.x = random( 0, width )
this.y = random( 0, height )
this.rad = random( (int)( height*0.05 ), (int)( height*0.225 ) )
this.color = random( 0, 255 )
}
void update() { if ( this.rad ) rad-- }
void render() {
fill color
ellipse x, y, rad, rad
}
boolean isOver(int mx, int my) {
(mx-x)*(mx-x) + (my-y)*(my-y) < rad*rad;
}
boolean isDead() { return rad < 1 }
}
The full code is up on GitHub. This is a modified version of
this guy's work, so he deserves most of the credit. Actually now that I look back at his example, about the only thing I did was make use of the @Delegate feature :)
