Session 003 - Dotted Planet

In this exploration, I took it to space. Points in WebGL are quite fun to work with. It’s very easy to create a large amount of points, and adjust how they are drawn on the screen. Up until now I had not attempted any lighting. Using a framework that handles lighting with a normal scene graph abstraction feels natural, while defining light in terms of math function is a bit more intimidating.

Session 001 - Windy Terrain

This is the first “Session” in the series, and my first time really working in regl. It’s quite hard moving from a model where you think in terms of a scene graph, to one in which you think in terms of a draw call. In order to get some kind of quick output, this is one of the easier example implementations. It is a sine wave going through some plane geometry, with a secondary plane defined as the floor. All of the “lighting” for the floor is a distance from center function. It was a good exercise because it made...

Session 002 - Beam Network

The second session was a jam on the first one. I love being free to copy and paste code without repercussions. There is a lot of cost in time for properly versioning and supporting shared code. This project is about output. For this first time in this project I explored a full screen background with an algorithm, using a combination of simple noise patterns. I also explored the proper use of multiple regl draw calls from the same draw function in order to draw the beams moving across the screen. The grid on the floor is pretty close to the...

River - Paths over Time

This is a coding exploration inspired by flying over rivers while flying. I was inspired by the paths that they traveled and left over time. Video of Visualization...

Wandering Lines - Move Until a Collision

Having been inspired by the work of Anders Hoff, I decided to try my hand at doing some algorithmic line growth. With this piece lines wander through a 3d noise field until they collide with an existing line. The lines regenerate in a diamond space. Video of Visualization About the CodeDrawing lines is interesting because the moment you draw more than one, and care about how they interact, you have a fairly intense algorithm to solve. In Big O notation this would be O(n^2). Luckily I remembered a pretty nice write up by Mikola Lysenko on this...

Growth - Fungal State

Growing geometry as I’ve come to find out is a fairly difficult programming problem to solve. Rather than regenerate geometry and figuring out the algorithms for connecting the topology of additional vertices and faces, I’m playing around with the manipulation of existing geometry. This particular algorithm is similar to other fungus-like growth patterns I’ve seen online. While mine didn’t get the same ordered feel as my references, I did quite enjoy the blobby growing effect. Video of Interaction The creation process About the codeThis example is built ontop of three.js. There aren’t any custom shaders with this one.

Growth - Incremental Additions

Growth in life is mesmerizing with the intricacies of the structures that are created. This programming poem series is an exploration of what happens with small incremental additions. The first installment features the dynamic growth of a 3d tree structure. Video of interaction The creation process The coding processI knew I wanted to start a growth series, but the topic seemed pretty difficult to even begin, so I started with what was comfortable, trees. I explored the idea of recursive tree functions with my previous Recursivity series. With this new code I took a much more functional approach,...

Polar Space - A Retro Space Game

I’m straying a little bit from my programming poem metaphor, and dipping a toe into online gaming. I’m taking a similar approach to my poems and iteratively developing levels for a space shoot ‘em up. It works on mobile and desktop.   Interaction video...

Gravity #4 - Self Attraction with Friction

This poem doesn’t follow as strictly to the rules of Gravity. There is some friction that was tuned to make the arrows behave in an interesting manner, otherwise they didn’t stick together enough to be visually appealing.

Gravity #3 - Directed Gravitational Paths

NASA calculated orbital paths using slide rulers, this programming poems uses the mouse to direct arrows at “planetary” bodies. I enjoy trying to see how many loops I can make with it.

Recursivity #4 - Repeating Circles

This poem is built on a simple rule, take a circle, divide it in half, and then create two more circles. Every time you click, it goes down another level. I also paired it with some WebAudio generators. The circles are slightly offset in their rotation making the circles appear to have been drinking (go home circles, you’re drunk!)...

Gravity #2 - Multiple Black Holes

After creating the initial setup, the best thing to do is add even more to it. The first simulation used only one “black hole,” but this one uses 5 randomly spinning holes. I ended up changing the behaviors of the arrows a little bit as well.

Recursivity #3 - Draw a beautiful fractal tree

I’m quite happy with the way this particular poem turned out. It’s very satisfying taking an idea and iterating on it enough to where the result becomes an entirely new experience. What’s funny about this particular piece is that I spent more time creating a specialized line simplifying algorithm that could draw cool bezier curves. I ended up throwing away most of that (beautiful) code and going for a much simpler solution.

Gravity #1 - Black Hole

After reading Neal Stephenson’s Anathema a second time, watching Cosmos, and of course that one movie with Sandra Bullock, I’ve spent some time thinking about gravity. This is my first in a series on exploring the math and physics behind it. I’m finding it pretty mesmerizing so far.

Recursivity #2 - Branching Fractal Trees

The second poem in my fractal series explores the idea of branching structures. These really are starting to feel like organic vascular structures. The rules are still pretty simple. The biggest tweaking here are some of the ways that the rules change as the depth of the recursion is increased. The default branching rules were not quite as interesting without a little bit of adjustment.

Recursivity #1 - Koch Fractal

Launch the poem. Fork it on GitHub. I’m starting out a new series of programming poems using the idea of recursion. Recursion is done by taking the output of the previous operation as the input for the new operation. Lots of really crazy and interesting complexity can happen because of it. This is how fractals are generated.

Stochasticity #8 - Webcam

This stochastic poem takes the idea of random drawing, but with a sampled color. It take the webcam, and each time one of the “walkers” walks, it draws the color that it finds on the webcam.

Stochasticity #7 - Audio

This stochastic piece dives into some audio. The poem uses the new Web Audio specification for browsers. It’s still a fairly experimental feature in browsers, but it seems like it will be really powerful. This piece sounds best with some headphones. I’d love to continue to explore this intersection between programmatic visuals and audio. There are some issues in Firefox with crackling that I wasn’t able to sort out.

Stochasticity #6 - Weather Vectors

Another vector field poem, this simulation is starting to feel a lot like weather. The rules are similar to last time, but with more of the “walkers”. I find it fascinating how the lines of color converge together as time progresses, and then can randomly split apart. Theoretically if two “walkers” ended up on the exact same point, then they would be merged together forever. However, the location is stored in a double precision float. What that means for the non-programmers is that it’s a very precise means of storing a number with lots of decimal places. The chance that...