The beat shatters the sphere and ripples the vertices in hues of magenta and cyan. Fragments on screen become audio-reactive and dance to the wonderful music of Rei Harakami.

This new visualizer was developed in my own personal 3d engine. It is coded in C++ and uses OpenGL for the graphics. The fmod sound library provides FFT spectrum data of the song. I enable certain elements of the visualizer to react to the frequencies which causes it all to dance wonderfully.

Above is a short video that I captured during my first week in Kyoto, Japan. The footage was recorded using my Nikon D90 with a 50mm lens. Enjoy!

As I wait patiently for work to begin, I’ve been noodling around with 3D visuals. I have always been intrigued by the beauty of space, so I tried to model a scene based on my conception of a neutron star. The video above shows a pulsating neutron star that glows brighter as it grows.

All the art assets in the simulation are procedurally generated. The light rays are rendered by sampling a 2D Perlin noise function. The function uses the angle and time as the 2D parameters to get the height of the ray. The time parameter causes the light rays to animate naturally. The motion of the torus is generated by rotating the object by its x and y-axis.

The visualization is programmed in C++ using the Cinder library. Music by Newton Faulkner.

[ Download | Screenshot ]

Lately, I’ve been mega-engulfed in simulating flocking behavior using the Boids algorithm. I’ve implemented it before, but this time, I wanted to take it to the next level by adding a trailing ribbon system that caches the previous positions of the boids and renders them out as connected line segments.

The positioning of the boids not only follow traditional flocking rules (separation, alignment, cohesion) but are also influenced by pseudo-random vectors provided by a 3D Perlin noise function. Adding Perlin noise gives the boids real-life “emergent” behavior as they swarm and swirl in random directions. The boids also have a tendency to lean towards the origin so that the boid simulation stays confined within a volume.

The cool blue geometry in the center is simply a triangle fan (GL_TRIANGLE_FAN) that uses the positions of the boids as its vertices. The vertices are offset by the center of the boids so that the object continually stays in the origin of the 3D system.

The camera is implemented using a mass-spring physics system. I wanted the camera to continuously follow the boids and point towards its center. However, I didn’t want the camera to move around erratically and make the viewer nauseous. Adding this mass-spring system allowed for smooth camera movement while following the flocking system nicely.

The simulation was coded in C++ using the awesome Cinder library. Music by Toe.

[ Download (.exe) ]

In an effort to bring the classical Conway’s Game of Life in to the 3D realm, I have coded this sample 3D application in C++. This was also an excuse for me to check out the popular C++ library, Cinder. Great library.

Basically, what’s going on is you apply the traditional cellular automata rules in 3D space. That is, instead of checking the surrounding 8 neighbors like you do in 2D space, you check the 26 neighbors in 3D space. Doing so gives you the results above.

[ Download (.exe) ]

Using OpenFrameworks, I coded this wiggly little particle system that renders organic-looking tentacles in real-time. I was heavily inspired from the movement of underwater anemones and decided to try to imitate its behavior.

With 2D Hermite splines, I was able to render the curves in color-shaded line segments. The tangents and positions are warped slightly every frame using sinusoidal waves to give that life-like wiggly behavior.

Feel free to download it and check it out for yourself. Use left-click to spawn a large entity and right-click to spawn a smaller entity. Press R to reset the app and F to set it to full-screen. Enjoy!

[ Download (.exe) | Screenshot ]

In an effort to mix color theory and music creation, I have concocted this visual music composer application. Each color on the wheel corresponds to one musical note in the C-Maj-7th chord. The color wheel has four octaves of notes that may be used to color the melody of the song. The Major-7th chord was chosen because I find it to be the most pleasant out of all the chords.

This project was coded in C++ using OpenFrameworks.

[ Download (2.1 MB) ]

After hearing all the hype surrounding OpenFrameworks, I decided to check out what it was all about. OpenFrameworks is an open-source C++ toolkit used for “creative coding”. Generally, it’s used for visualizers and interactive applications. The API is clean and effective. So far I like it alot.

Last night, I decided to dive into the framework and try my luck at coding some simple flocking behavior based on Craig Reynolds’ Boids algorithm. “Boids” is an artificial life program which endeavors to simulate the flocking behavior of birds. The movement of each entity is governed by three simple rules: separation, alignment and cohesion. The result is this group behavior that appears natural and “emergent”.

[ Download (.exe) ]

The Game of Life is not a game in the conventional sense. Rather, it is a cellular automaton algorithm devised by John Horton Conway to abstract the biological functionalities of life. This simulation runs on a 2D grid and provides really cool “life-like” results.

The rules to the Game of Life are extremely simple. A grid can be alive or dead. Then for each cell, we count the number of live neighbors surrounding the current grid and use that number to apply the following transitions:

• Any live cell with fewer than two live neighbors dies, as if caused by under-population.
• Any live cell with two or three live neighbours lives on to the next generation.
• Any live cell with more than three live neighbours dies, as if by overcrowding.
• Any dead cell with exactly three live neighbours becomes a live cell, as if by reproduction.

A “neighboring cell” is any of the eight cells adjacent or diagonally adjacent to the given cell. Also, the initial layout of the system acts as the seed of the simulation.

I finally got around to posting a video of the current progress. So far the project is going quite swimmingly, if I do say so myself. One thing I want to say is that I am amazed on the sheer power of the GPU’s geometry shader. I had no idea it was able to generate so many vertices at such interactive speeds. Each of the blades that are rendered is being generated procedurally in the geometry shader given only root positions, which is passed in the vertex buffer. Currently I render about 40,000 blades of grass at a solid FPS of 50FPS.

The swaying of the grass is being modeled by simple oscillators such as sine and cosine. There currently is no interaction that the player can have with the grass. However, my next step is to allow the user to affect the wind conditions of the scene. The wind condition vectors will be modeled using Navier-Stokes equations. Hopefully it comes out as cool as I see it in my mind’s eye. Stay tuned.