Project_2026-02-16_11-58-28

GLSL shader by scry · created 2026-02-16 · updated 2026-02-17 · 10s loop · 2 passes

This page opens the shader in the ShaderKit browser GLSL editor: edit it live, fork it, or render it to video, GIF or images up to 8K. Also available as a full-screen view and an embeddable player.

Shader source (GLSL)

Common

#define pi acos(-1.)
#define deg pi/180.  //1 degree
#define time iTime*2.*pi/10. //sin(time) loops 10 seconds
#define R iResolution.xy //shorthand
#define ar R.x/R.y //aspect ratio
#define M iMouse //shorthand
#define xm (M.xy/R) //normalized mouse
#define nm ((xm.xy-0.5)*vec2(ar,1.)+0.5) //aspect ratio correction
vec3 cs = vec3(1.,2.,3.);
mat2 r2d(float a) {
    return mat2(cos(a),sin(a),-sin(a),cos(a));
}

Buffer A (iChannel0)

float hash(vec2 p) {
    return fract(sin(dot(p, vec2(12.9898, 78.233))) * 43758.5453);
}

float valueNoise(vec2 p) {
    vec2 i = floor(p);
    vec2 f = fract(p);
    f = f * f * (3.0 - 2.0 * f);
    
    float a = hash(i);
    float b = hash(i + vec2(1.0, 0.0));
    float c = hash(i + vec2(0.0, 1.0));
    float d = hash(i + vec2(1.0, 1.0));
    
    return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);
}

float fbm(vec2 p) {
    float value = 0.0;
    float amplitude = 0.5;
    for (int i = 0; i < 4; i++) {
        value += amplitude * valueNoise(p);
        p *= 2.0;
        amplitude *= 0.5;
    }
    return value;
}

float sabs(float x, float k) {
    //float a = abs(x);
    return sqrt(x*x+k)-k;
}
vec2 sabs(vec2 x, float k) {
    //float a = abs(x);
    return sqrt(x*x+k)-k;
}

float sdCone(vec3 p, vec2 c, float h) {
    vec2 q = h*vec2(c.x/c.y,-1.0);
    vec2 w = vec2(length(p.xz), p.y);
    vec2 a = w - q*clamp(dot(w,q)/dot(q,q), 0.0, 1.0);
    vec2 b = w - q*vec2(clamp(w.x/q.x, 0.0, 1.0), 1.0);
    float k = sign(q.y);
    float d = min(dot(a, a),dot(b, b));
    float s = max(k*(w.x*q.y-w.y*q.x),k*(w.y-q.y));
    return sqrt(d)*sign(s);
}

float map(vec3 p) {
    p.z -= 3.+2.*sin(time+3.4);
    p.yz *= r2d(deg*-30.+sin(time+4.5));
    p.xz *= r2d(time);
    float a = 0.1;
    p.y += 1.;
    p.xy *= r2d(time);
    //p.y = sabs(p.y,0.01)-0.1;
    p.xz += vec2(sin(time*4.+p.y),cos(time*4.+p.y));
    float d = 1000.;
    vec3 p_ = p;
    p_.y = sabs(p_.y,0.9)-2.;
    
    d = min(d,sdCone(p_, vec2(sin(a), cos(a)), 20.0)*0.5);
    //p.y += 1.;
    for (int i=0;i<8;i++) {
        p.xz = sabs(p.xz,0.01)-0.2;
        p.xy *= r2d(deg*p.y*1.);
        p.yz *= r2d(deg*p.y*-1.);
        p.yx *= r2d(deg*1.);
        p.zy *= r2d(deg*-1.);
        //vec3 p_ = p;
        p_ = p;
        p_.y = sabs(p_.y,0.9)-1.5;
        d = min(d,sdCone(p_, vec2(sin(a), cos(a)), 20.0)*0.5);
        p.y += 0.5;
    }
    //d = min(d,sdCone(p, vec2(sin(a), cos(a)), 20.0)*0.5);
    return d;
}

vec3 calcNormal(vec3 p) {
    vec2 e = vec2(0.001, 0.0);
    return normalize(vec3(
        map(p+e.xyy)-map(p-e.xyy),
        map(p+e.yxy)-map(p-e.yxy),
        map(p+e.yyx)-map(p-e.yyx)
    ));
}

vec2 RM(vec3 ro, vec3 rd) {
    float dO = 0.0;
    float ii = 0.;
    for (int i=0; i<256; i++) {
        vec3 p = ro + rd*dO;
        float dS = map(p);
        dO += dS*0.3;
        ii += 0.08;
        if (dO > 20.0 || dS < 0.001) break;
    }
    return vec2(dO, ii);
}

vec3 getEnvColor(vec2 uv) {
    float n = fbm(uv * 3.0);
    vec3 col = vec3(n);
    //col = mix(vec3(0.1, 0.2, 0.4), vec3(0.8, 0.5, 0.3), n);
    col = sin(cs*1.25+n*20.);
    return col;
}

void mainImage(out vec4 fragColor, in vec2 fragCoord) {
    vec2 uv = fragCoord.xy / iResolution.xy;
    uv -= 0.5;
    uv.x *= ar;
    
    vec3 ro = vec3(0.0, 0.0, 0.0);
    vec3 rd = normalize(vec3(uv, 0.5));
    
    vec3 col = getEnvColor(uv)*0.;
    vec3 accum = vec3(0.0);
    float reflectivity = 1.0;
    
    for (int bounce = 0; bounce < 6; bounce++) {
        vec2 res = RM(ro, rd);
        float t = res.x;
        accum += res.y*res.y*0.002;
        if (bounce == 0 && t>= 20.) {
            accum *= 0.;
            accum += res.y*res.y*0.005;
            //accum += res.y*0.1;
            break;
        }
        if (t >= 20.0) {
            accum += reflectivity * getEnvColor(rd.xy * 0.5);
            break;
        }

        vec3 p = ro + rd * t;
        vec3 n = calcNormal(p);
        
        float fresnel = pow(1.0 - max(dot(-rd, n), 0.0), 3.0);
        float metalness = mix(0.9, 0.95, fresnel);
        
        accum += reflectivity * (1.0 - metalness) * vec3(0.8);
        
        ro = p + n * 0.01;
        rd = reflect(rd, n);
        reflectivity *= metalness;
        
    }
    
    col = accum;
    //col +=
    
    fragColor = vec4(col, 1.0);
}

Image

Not used

More shaders by scry

• Project_2026-08-15_18-22-06
• Project_2026-08-14_16-45-00
• Project_2026-07-24_15-10-23
• Project_2026-07-15_03-18-26
• Glass of Orange Juice (raymarched)
• Project_2026-07-13_00-53-50
• Project_2026-07-10_16-39-54
• Popcorn ceiling
• Project_2026-06-20_15-32-19
• Project_2026-06-25_12-22-43
• Visual Enhancer
• Project_2026-06-24_11-11-39

Browse all public shaders · All shaders by scry · ShaderKit home