My projection mapping project explores some basic possibilities offered by GLSL shaders. I used them to map animations on pyramid shapes arranged in a more or less regular fashion, in order to create simulacrum kaleidoscopes.
produced by: Julien Mercier
Kaleidoscopes have existed since the 16th century. They are playful little optical instruments that create regular symmetrical patterns when viewed from. Because they share many structural similarities with the shape I decided to work on, and because projection mapping often feels like a ‘visual orgy’ to me, these colorful little toys seemed like an appropriate visual reference for my piece.
Concept and background research
A few years ago, I was working for a director named Sami Benhadj. He was extremely interested by kaleidoscopes and Werner Herzog (no connection), and he directed this experimental music video, and later this cool ad for TedX using similar concepts. His work still has influence over my tastes and intentions, and I thought of these two videos when I first decided to try and simulate kaleidoscopes.
Kaleidoscopic fragmentation have a unique visual appeal, and have an interesting ‘trippy’ effect, whatever source image it is fed with. In one of my sketches, I loaded a simple test image I found online (entering the keyword “test image” led me to https://testimages.org/). The image is then remapped and fragmented by a simple GLSL shader that handles the variables of the kaleidoscope (angle, speed, amount of facets…). Then, I experimented with “ofImage”, “ofPixels” and “ofTexture” objects to manipulate pixels directly.
Besides the simple desire to experiment with kaleidoscopic tessellations, there is not one singular underlying concept behind this proposition. I took this assignment as an opportunity to practice the OpenFrameworks/C++ coding skills I’ve gained during term 1. My strategy was to come up with quick, iterative ideas for new sketches every other day in order to explore various technical topics and visual intentions. I would start programming them and gradually, they would merge into one another or simply vanish and give space to the better ideas. Eventually, I kept the three sketches that proved more interesting, either visually or technically.
I coded the animations using OpenFrameworks/C++ in the Xcode IDE and used the ofxPiMapper addon to map those on physical shape, using a projector. The first animation of the three is a simple vector of triangles (non Object Oriented, though it would have been a big help at the time) that seem to fall into void, towards the back of the shapes. Each new triangle picks a new color in a vector, and each of its three coordinates also has a noisy behaviour, to simulate an actual object trembling then falling. The second animation explores the possible variations of the shader I used, by playing with the movement speed (the moving portion of the source image that shows), but also changing the amount of facets of my kaleidoscopes as well as the dimension of the image (erratically zooming in and out or stretching the image on its X and Y axis). The third animation explores those options further by generating random arrays of pixels, with some color constraints. The code is set to randomly choose from a few algorithms that draws lines, curves and various shapes, while being fragmented, rotated, scaled and stretched by the shader a little further down the road. For both these animations, I created two shaders based on one created by abigpotostew in 2014 (retrieved from https://github.com/abigpotostew/kaleidoscope). To better understand shaders, I also looked at mokacode’s example (found on https://code.google.com/archive/p/mokacode/downloads) and read the chapters on Shaders from the ofBook (https://openframeworks.cc/ofBook/chapters/shaders.html).
While projection mapping is not a route I see myself taking in the future, it is a great tool to have at hand. I would like to investigate further the GLSL language, which allows to executed programs on the GPU directly. This seems like a great way to perform complex visual effect that could run on a browser, even with a modest internet connection. With the recent topics covered in class, I could also see how it’d be interesting to update those sketches by adding some control on them using computer vision or machine learning and an infrared webcam. To truly understand kaleidoscope tessellation, I would also like to build a physical one.
I do not consider this project to be a creative achievement, but neither is it what I intended it to be. I am aware that my code shows some redundancies, and many of my outputs could have been done in a more efficient way. Even without the newly discovered OOP paradigm, a good part of my animations could have been cleaned and done more elegantly, but time ran short and the visual output seemed like the most important aspect.
I am still very pleased with the technical bits it made me practice, for I now feel like I gain a decent control over them. I am also happy to have brought a little bit of challenge by trying to demystify shaders. It was rewarding to figure out the problems they posed by myself, and it definitely made me become more confident with my coding. The holidays allowed me to spend enought time looking at a single program, which proved to be the only way to get better at coding. I still had to work on the Processing/Java assignement and this one one after the other, because switching from one language to the other was confusing and distracting. All together, the opportunity to work on a project for a little bit longer than usual felt very productive, and a good motivation for the final project, which gradually seems less and less scary as it gets closer.
For the first animation (‘falling triangles’) I looked back at the ‘triangle vectors’ program we worked on in Week 4’s lab exercise (https://learn.gold.ac.uk/mod/page/view.php?id=600199). It helped me remember how to properly set up vectors and vertexes. I also looked back at Week 5’s homework ‘noisy sun’ (https://learn.gold.ac.uk/mod/page/view.php?id=600211), to help me remember how to best use Perlin noise on 2D coordinates for a groovy effect. For the two following animations, I modified a shader created by abigpotostew in 2014 (retrieved from https://github.com/abigpotostew/kaleidoscope).
— ofSimpleShaderExample example by mokacode (https://code.google.com/archive/p/mokacode/downloads)
— Introducing Shaders, ofBook (https://openframeworks.cc/ofBook/chapters/shaders.html)
As visual references, I mentionned these two videos by Körner Union/Sami Benhadj:
— Souvenir de Chine, Sami Benhadj/Körner Union, 2018
— The Power of X, Sami Benhadj/Körner Union, 2012
— Various illustrations by M. C. Escher