penumbra

Last time I've checked (a few years ago) Penumbra was nice clojure-sque OpenGL wrapper. But it seems it's abandoned. Shame, it was really nice, even had clojure DSL to write shaders. https://github.com/ztellman/penumbra

Here's an Asteroids clone I wrote in Clojure a few years back, which has less than 400 lines and some neat stuff like procedurally generated 3D asteroids: https://github.com/ztellman/penumbra/blob/master/test/exampl... Some of the design decisions are discussed in detail at http://ideolalia.com/creating-a-simple-game-in-clojure

Somewhat related: Tetris in Clojure and Penumbra[1] [1]: https://github.com/ztellman/penumbra/blob/master/test/exampl...

I open sourced the code here: https://github.com/jasonjckn/snake3d I don't have a tutorial for Snake3D, but there's quite a bit out there for Clojure + OpenGL: 1) https://github.com/ztellman/penumbra/wiki/Applications 2) https://github.com/swannodette/clj-nehe

If you want straight-up OpenGL bindings for clojure, there's Penumbra: https://github.com/ztellman/penumbra

prospero's work: https://github.com/ztellman/penumbra/tree/master/test/exampl... Pong in 140 < LOC, Tetris in < 260 LOC, Asteroids in < 400 LOC Looks like plenty o' fun to me! :)

With datatypes and protocols it's now possible to get pretty much on par with the speed of Java classes while staying idiomatic. For an example of how idiomatic this can look in action, check out http://github.com/ztellman/penumbra/blob/master/src/penumbra... This vector math datatype will be as fast a Java class + the cost of an object clone. The upside is that you have a value entity that has the exact same concurrency safe semantics as Clojure's built in datatypes. This coupled with Rich Hickey's plans for 1.3 (support for returning primitives from fns) means you'll truly be able to write highly idiomatic Clojure code with host performance without jumping through hoops (much less or no type-hinting, no macro inlining, etc).

I don't have time for a full conversion just now, but an eight-way diffusion on the GPU in Penumbra looks like this: (let [sum 0.0 count 0.0] (convolution 1 (+= sum %1) (+= count 1)) (/ sum count)) "convolution" is a keyword that iterates over the neighbors (with a radius of 1, in this case), and does not overrun the boundaries of the source textures, hence the need to keep a running count. For a more extensive example, see this implementation of Sobel edge detection on the GPU: http://github.com/ztellman/penumbra/blob/master/src/example/...

http://github.com/ztellman/penumbra/ It's very much a work in progress, but there some interesting stuff in there. Especially of note is the GPU-driven Mandelbrot viewer (http://github.com/ztellman/penumbra/blob/master/src/example/...), where the shaders are syntactically and idiomatically indistinguishable from the rest of the code. Every graphics engine I've seen focuses on performance rather than expressiveness. With current trends in graphics cards, that seems more a matter of custom than necessity. It's an exciting time to be working on this stuff; there's huge swaths of unexplored territory out there.

glBegin(GL_QUADS); glVertex3f(1.0f, 1.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 1.0f); glVertex3f(-1.0f, -1.0f, 1.0f); glVertex3f(1.0f, -1.0f, 1.0f); glEnd() Becomes (draw-quads (vertex 1 1 1) (vertex -1 1 1) (vertex -1 -1 1) (vertex 1 -1 1)) Thanks to Zach Tellman's wonderful Penumbra, http://github.com/ztellman/penumbra Please fork and port more Nehe tutorials!