#shadertoy

In this tutorial you will learn how to code a sunburst effect inside a shader, using scanlines and polar coordinates. You will learn how to code the effect using the web based shader editor called Shadertoy.

Recent coding practice:

1 & 2: Messing around in shadertoy

This is one of my personal favorite fractals, the Harter-Heighway Dragon Curve, featured in the original Jurrassic park book shown skipping a few steps at a time, unpredictably evolving into this shape here to highlight the chaotic but organized mess of nature we struggle to predict and understand. This is among the friends I am most deeply and intimately familiar with. I started playing around with these based off an old ViHart video explaining how to make them in terms of squiggles and folding papers

My traditional method has always been to take a sequence, reverse it, and add one, rolling over when you hit 4. Example 0 01 01 21 01 21 23 21 01 21 23 21 23 03 23 21

If you change each number into a direction, 0 being right, 1 being up, and so on, then follow that path along the sequence you will also get a dragon curve. There are so many wonderful ways to construct these

However, here’s my favorite

This is my Dragon Curve *unity shader* that I wrote. It comes with an editor script that you can use to bake it into a texture, since the process is a bit heavy. Why is this so special you ask? Well it comes down to the fact that this is running in real time, in parallel. See algorithms have two main kinds of families, parallel and serial. A serial algorithm goes step by step, like taking a math test alone. A parallel algorithm runs side by side, like everyone doing one problem on the test. Its much faster, but they aren’t allowed to talk to each other so if the same problem shows up twice, or if a second problem relies on the answer to the first, its much more difficult. This is why dragon curves are hard to parallelize. You take the sequence *before* and reverse / increase. You take the segments *from the last step* and fold them again. You fold the paper *back over itself* referencing previous work. This problem is about as serializable as it comes. So how do you parallelize? Will, you change your perspective

See instead of trying to split everyone up to try to *create* a dragon curve, you give every pixel a job to decide *is it on* a dragon curve. By rotating the space itself in alternating grid patterns you can twist a dragon curve down into a single line. If your point in space ends up on the line, then it was on the dragon curve! Furthermore, the direction it turns due to how the grids line up actually encodes how far along the dragon curve it was in binary (left being a 0, right being a 1), so by keeping track of that and converting it to decimal we can give subtle coloration to points on one dragon curve from 0-2^n, and clip out anything that isn’t on it. As far as I know, I’m the only person to have implemented it this way and it might be a straight up novel algorithm, which I’m super proud of!