Introduction:
Having visited NOVA 2024 in person the year before, we originally had the plan to return for the 20th edition this year. Sadly the new UK travel requirements made this option less viable. So we had to support the 20th anniversary of this demoparty remotely instead.
Shrine (256 Bytes, MicroW8):
The original idea of this intro was done about a year ago, when I tried to get a short-cutted apolonian fractal going and see if I was able to get it performant enough. The project was picked up again about a week before the party, where I mostly focused on the audio, camera movement and progression.
Visuals:
This intro consists of a CPU non-scalar raymarcher with a fairly basic/usual setup.
Meaning your typical loops for scanning across the width and height of the screen as well as a loop for travelling along the ray-direction (u,v). I usually use the variable z for indication the total distance travelled (z=z+d*factor).
This intro uses an apolonian fractal at its core, which is then bent and scaled in such a way that, in combination with the sandy-colored palette, was made to look like a shrine/church type building, with the camera moving through the top of the structure..
Here is the pseudo code i've used to generate the visuals:
// tilt UV space 45 degrees counter clockwise
u = ((x-y) / 240.0 - st); // st = camera movement
v = ((x+y) / 240.0 - z * 0.5); // distort the v-space in such a way to create te illusion of pillars
// start position and scale
px = z * u;
py = z * v - t;
pz = z + 1.0;
s = 1.0;
// the fractal loop
for i=1,5 do
k = 3.0 / (px*px + py*py + pz*pz);
s = s * k;
// calculated new point using sin as a shortcut to do cheap non-accurate domain repetition
px = sin(px * k);
py = sin(py * k);
pz = sin(pz * k);
end
// Calculate distance to the final position and divide by scalar s
d = (px*px + py*py + pz*pz) / s - 0.00625;
Given the complexity of the SDF with the 5 iteration steps the rendering is speed up a little by skipping scanlines and only drawing half of the screen.
Audio:
This intro uses a custom softsynth in the 'snd' function callback. The original plans for the audio where to try and generate an organ-like sound, playing a series of notes/frequencies from a table, but sadly I just couldnt get this working within the size budget. After spending a good amount of time on it, I finally had to let go of this idea and settle for 2 octaves of layered oscillated sawtooth strings and a single oscilated organesque sound and present it as a more generic soundscape.
Still, even this minimized plan still took a good bit of the size-budget to pull off:
; given t as sampleoffset
for n=0,numSoundlayers,stepsize do
// calculate a small oscillation between the layers
osc = (fmod(n*n,1.0) / 192 + 1);
// Our 3 octave notes that make up the final soundscape
n1 = t * osc / 880;
n2 = t * osc / 440;
n3 = t * osc / 280;
v = v + fmod(n1,1.0);
v = v + fmod(n2,1.0);
v = v + sin(n3);
end
// Here we control the final volume fade-in / fade-out
v = v * mastervolume / 192.0;
Here the frequencies n1, n2 and n3 are then added as oscillated sawwaves (n1,n2) and sinewave (n3) using additive synthesis in a loop, to be stacked on eachother with slightly offsetted oscilations and finally divided down to a float samplevalue using our mastervolume fade.
Desert Drift (128 Bytes, MicroW8):
This was actually one of my earlier prototypes when I started experimenting a with tiny sized raymarching a few years ago. Because of this it had been sitting on the shelf It was only recently that I picked it up again to try and see if it could be whipped into something more release-worthy.
Being an early experiment, ment the SDF itself for sine-dunes is pretty basic. Again, just as with Shrine the u,v is our ray-direction (-n..n) and z is our accumulated distance
px = cos(z * u + cameratilt);
py = 2.0 - (z * v);
pz = cos(z + time());
d = (px*pz+py);
Because of this, there was a little bit of size-budget left to polish the final visuals. I started by adding sandy dune-waves pattern and adding a bit of noise to that to reduce the color-ramping, as well as helping to sell the sandyness of the visuals.
Here is the code i used for calculating the sanddune color:duneColor = (cos((pz+py)*14.0)-z+randomf()) + 110;
Furthermore, since a single monotone palette is a bit boring, I wanted to bring more color in for the sky, so depending of the total depth travelled we can detect if a dune was hit or not. In case we did not hit anything, we'll draw a gradient for the background based on py in a purple-ish color, giving the total image a more vibrant look.
Conclusion:
I was happy to see that both intros were received well at the party and had a great audience response.
For more information, you can check out the intros at demozoo: Desert Drift (2025) and Shrine (2025)