SF/07 · Seed 6

Gyroid Lantern

A minimal surface cut into a sphere and lit from within.

Sphere tracing inside a bounding ball: a gyroid shell, clipped to a sphere, is lit by an emissive core and a cool key light. The seed sets cell size, wall thickness and metal.

Palette · Night blue / brass / ember
Interaction · Pointer orbits the camera · press to flare the core
Runtime · WebGL2 / fragment shader

Seed 6

Loading…

Time 6.00 s

Fragment shaderGLSL ES 3.00

#version 300 es
precision highp float;

uniform vec2 u_resolution;
uniform float u_time;
uniform vec2 u_pointer;   // 0–1, eased; drifts by itself while nobody is pointing
uniform vec3 u_click;     // xy = last press (0–1), z = seconds since that press
uniform float u_seed;
out vec4 outColor;

// Integer hash: a given seed renders the same work on every GPU.
uint hashu(uint x) {
    x ^= x >> 16; x *= 0x7feb352dU;
    x ^= x >> 15; x *= 0x846ca68bU;
    x ^= x >> 16;
    return x;
}

float seeded(uint k) {
    return float(hashu(uint(u_seed) * 0x9e3779b9U + k)) / 4294967295.0;
}

vec2 toField(vec2 q) {
    return (2.0 * q - 1.0) * u_resolution / min(u_resolution.x, u_resolution.y);
}

float dither(vec2 p) {
    return (fract(52.9829189 * fract(dot(p, vec2(0.06711056, 0.00583715)))) - 0.5) / 255.0;
}

mat2 rot(float a) {
    float s = sin(a), c = cos(a);
    return mat2(c, -s, s, c);
}

float scene(vec3 p) {
    float scale = 5.2 + 2.0 * seeded(1u);
    float wall = 0.03 + 0.02 * seeded(2u);
    vec3 q = p * scale + vec3(0.0, 0.0, u_time * 0.12);
    float gyroid = abs(dot(sin(q), cos(q.zxy))) / scale - wall;
    float shell = max(length(p) - 1.0, gyroid * 0.75);
    return min(shell, length(p) - 0.15);
}

vec3 normalAt(vec3 p) {
    vec2 e = vec2(0.0015, -0.0015);
    return normalize(e.xyy * scene(p + e.xyy) + e.yyx * scene(p + e.yyx) +
                     e.yxy * scene(p + e.yxy) + e.xxx * scene(p + e.xxx));
}

void main() {
    vec2 uv = toField(gl_FragCoord.xy / u_resolution.xy);
    vec2 look = (u_pointer - 0.5) * vec2(1.6, 1.0);
    vec3 ro = vec3(0.0, 0.0, 3.1);
    vec3 rd = normalize(vec3(uv, -2.2));
    mat2 pitch = rot(0.35 + look.y);
    mat2 yaw = rot(u_time * 0.09 + look.x + 6.2831853 * seeded(3u));
    ro.yz *= pitch; rd.yz *= pitch;
    ro.xz *= yaw;   rd.xz *= yaw;

int pick = int(floor(seeded(4u) * 3.0));
    vec3 night = vec3(0.016, 0.02, 0.05), metal = vec3(0.86, 0.72, 0.50), core = vec3(1.0, 0.46, 0.14);
    if (pick == 1) { night = vec3(0.01, 0.035, 0.035); metal = vec3(0.74, 0.80, 0.80); core = vec3(0.20, 0.80, 0.90); }
    if (pick == 2) { night = vec3(0.04, 0.015, 0.04); metal = vec3(0.86, 0.56, 0.46); core = vec3(1.0, 0.32, 0.42); }
    float flare = 1.0 + 2.5 * exp(-2.5 * u_click.z);

vec3 color = night + vec3(0.04, 0.05, 0.11) * (1.0 - 0.5 * length(uv));
    // Only march where the ray crosses the bounding sphere.
    float b = dot(ro, rd);
    float h = b * b - dot(ro, ro) + 1.0;
    if (h > 0.0) {
        float travelled = -b - sqrt(h);
        float exit = -b + sqrt(h);
        float glow = 0.0;
        bool hit = false;
        vec3 p = ro;
        for (int i = 0; i < 96; i++) {
            p = ro + rd * travelled;
            float d = scene(p);
            glow += exp(-3.5 * length(p)) * 0.09;
            if (d < 0.0008) { hit = true; break; }
            travelled += d;
            if (travelled > exit) break;
        }
        if (hit && length(p) < 0.17) {
            color = mix(core, vec3(1.0, 0.95, 0.85), 0.6) * flare;
        } else if (hit) {
            vec3 n = normalAt(p);
            vec3 toCore = -p / max(length(p), 0.001);
            float inner = (0.25 + max(dot(n, toCore), 0.0)) / (1.0 + 5.0 * dot(p, p));
            float key = max(dot(n, normalize(vec3(-0.5, 0.8, 0.6))), 0.0);
            float rim = pow(1.0 - max(dot(n, -rd), 0.0), 3.0);
            float depth = smoothstep(1.05, 0.2, length(p));
            color = metal * (0.06 + 0.42 * key) * (0.3 + 0.7 * (1.0 - depth));
            color += core * inner * 7.0 * flare;
            color += vec3(0.3, 0.36, 0.6) * rim * 0.25;
        }
        color += core * glow * flare;
    }
    color = color / (1.0 + color);
    color = pow(color, vec3(0.85));
    outColor = vec4(color + dither(gl_FragCoord.xy), 1.0);
}

Remix in playground Live compile Animate

Export a loop Format Size Length Seamless

Keys outside the editor: F fullscreen · Space play or pause · R reseed

The source above is the complete fragment shader. Changes remain in this tab unless you take them to the playground. Download the original GLSL.