Added shader packs

tools/packsrc/Blueprint/pack.json

@@ -0,0 +1,32 @@
+{
+    "author": "s23b",
+    "name": "Blueprint of the Arkiteckt",
+    "version": "1.0.0",
+    "description": "",
+    "license": "CC BY-NC-SA 3.0",
+    "engine": "shadertoys",
+    "id": "4tySDW",
+    "tags": [
+        "reactive",
+        "raymarching",
+        "fractal",
+        "edge detect",
+        "mouse"
+    ],
+
+    "source": "./shaders/Image.frag.qsb",
+    "speed": 1,
+
+    "channel0":
+    {
+        "type": 2,
+        "source": "./shaders/Buffer A.frag.qsb",
+        "frame_buffer_channel": 1,
+
+        "channel0":
+        {
+            "type": 4,
+            "invert": true
+        }
+    }
+}

tools/packsrc/Blueprint/shaders/Buffer A.frag

@@ -0,0 +1,8 @@
+// the purpose of this buffer is too smooth out the sudden changes in the fft
+void mainImage( out vec4 fragColor, in vec2 fragCoord )
+{
+    vec2 uv = fragCoord.xy / iResolution.xy;
+    float old = texture(iChannel1, uv).x;
+    float new = texture(iChannel0, uv).x;
+    fragColor = vec4(mix(old, new, new > old ? .4 : .04));
+}

tools/packsrc/Blueprint/shaders/Image.frag

@@ -0,0 +1,356 @@
+#define SPEED .1
+#define FOV 3.
+
+#define MAX_STEPS 80
+#define EPS .001
+#define RENDER_DIST 5.
+#define AO_SAMPLES 4.
+#define AO_RANGE 100.
+
+#define PI 3.14159265359
+#define saturate(x) clamp(x, 0., 1.)
+
+// precomputed globals
+float _house = 0.;
+float _boat = 0.;
+float _spaceship = 0.;
+float _atmosphere = 0.;
+mat3 _kifsRot = mat3(1, 0, 0, 0, 1, 0, 0, 0, 1);
+float _kifsOffset = 0.;
+
+// rotate 2d space with given angle
+void tRotate(inout vec2 p, float angel) {
+    float s = sin(angel), c = cos(angel);
+	p *= mat2(c, -s, s, c);
+}
+
+// divide 2d space into s chunks around the center
+void tFan(inout vec2 p, float s) {
+    float k = s / PI / 2.;
+    tRotate(p, -floor((atan(p.y, p.x)) * k + .5) / k);
+}
+
+// rectangle distance
+float sdRect(vec2 p, vec2 r) {
+    p = abs(p) - r;
+	return min(max(p.x, p.y), 0.) + length(max(p, 0.));
+}
+
+// box distance
+float sdBox(vec3 p, vec3 r) {
+    p = abs(p) - r;
+	return min(max(p.x, max(p.y, p.z)), 0.) + length(max(p, 0.));
+}
+
+// sphere distance
+float sdSphere(vec3 p, float r) {
+	return length(p) - r;
+}
+
+// 3d cross distance
+float sdCross(vec3 p, vec3 r) {
+    p =abs(p) - r;
+    p.xy = p.x < p.y ? p.xy : p.yx;
+    p.yz = p.y < p.z ? p.yz : p.zy;
+    p.xy = p.x < p.y ? p.xy : p.yx;
+    return length(min(p.yz, 0.)) - max(p.y, 0.);
+}
+
+// union
+float opU(float a, float b) {
+    return min(a, b);
+}
+
+// intersection
+float opI(float a, float b) {
+    return max(a, b);
+}
+
+// substraction
+float opS(float a, float b) {
+    return max(a, -b);
+}
+
+// smooth union
+float opSU(float a, float b, float k)
+{
+    float h = clamp(.5 + .5 * (b - a) / k, 0., 1.);
+    return mix(b, a, h) - k * h * (1. - h);
+}
+
+// house distance
+float sdHouse(vec3 p) {
+    p.y += .075;
+    vec3 boxDim = vec3(.2, .15, .2);
+    
+    // add the walls
+    float d = sdBox(p, boxDim);
+    
+    // add the windows
+    vec3 q = abs(p);
+    vec3 windSize = vec3(.04, .04, .06);
+    q -= windSize + vec3(.005);
+    d = opI(d, opU(sdCross(q, windSize), .11 - abs(p.y)));
+    
+    // add the roof
+    q = p;
+    q.y -= .38;
+    tFan(q.xz, 4.);
+    tRotate(q.xy, PI/4.);
+    d = opU(d, sdBox(q, vec3(.35, .01, .35)));
+    
+    // make it hollow
+    d = opS(d, sdBox(p, boxDim - vec3(.02)));
+    return d;
+}
+
+// boat distance
+float sdBoat(vec3 p) {
+    
+    // add the mast (a word I learned today :P)
+    float d = sdBox(p + vec3(0, .05, 0), vec3(.01, .2, .01));
+    
+    // add the sail
+    vec3 q = p + vec3(0, -.05, .12);
+    float a = sdSphere(q, .2);
+	a = opS(a, sdSphere(q, .195));
+    q.x = abs(q.x);
+    tRotate(q.yx, .1);
+    a = opI(a, sdBox(q - vec3(0, 0, .1), vec3(.1)));
+    d = opU(d, a);
+    
+    // add the body of the boat
+    p.x = abs(p.x);
+    p.x += .1;
+    a = sdSphere(p, .3);
+    a = opS(a, sdSphere(p, .29));
+    a = opI(a, p.y + .15);
+    d = opU(d,a);
+    return d;
+}
+
+// spaceship distance
+float sdSpaceship(vec3 p) {
+    tFan(p.xz, 6.);
+    p.x += .3;
+    
+    // add the cap
+    float d = sdSphere(p, .4);
+    d = opS(d, p.y - .12);
+    
+    // add the body
+    d = opU(d, sdSphere(p, .39));
+    
+    // add the fins (another word I learned, thanks google :P)
+    d = opU(d, opI(sdSphere(p + vec3(0, .24, 0), .41), sdRect(p.zx, vec2(.005, .5))));
+    d = opS(d, sdSphere(p + vec3(0, .3, 0), .37));
+    d = opS(d, p.y + .25);
+    return d;
+}
+
+// atmosphere distance
+float sdAtmosphere(vec3 p) {
+    float time = iTime;
+    tRotate(p.yz, time);
+    vec3 q = p;
+    tFan(q.xz, 12.);
+    float d = sdBox(q - vec3(.3, 0, 0), vec3(.01));
+    tRotate(p.yx, time);
+    q = p;
+    tFan(q.yz, 12.);
+    d = opU(d, sdBox(q - vec3(0, .23, 0), vec3(.01)));
+    tRotate(p.xz, time);
+    q = p;
+    tFan(q.yx, 12.);
+    d = opU(d, sdBox(q - vec3(0, .16, 0), vec3(.01)));
+    
+    return d;
+}
+
+// distance estimation of everything together
+float map(vec3 p) {
+    float d = _house <= 0. ? 5. : sdHouse(p) + .1  - _house * .1;
+    if (_boat > 0.) d = opU(d, sdBoat(p) + .1  - _boat * .1);
+    if (_spaceship > 0.) d = opU(d, sdSpaceship(p) + .1  - _spaceship * .1);
+    if (_atmosphere > 0.) d = opU(d, sdAtmosphere(p) + .1 - _atmosphere * .1);
+    
+    //return d;
+    float s = 1.;
+    for (int i = 0; i < 4; ++i) {
+        tFan(p.xz, 10.);
+        p = abs(p);
+        p -= _kifsOffset;
+        
+        p *= _kifsRot;
+        s *= 2.;
+    }
+    
+    return opSU(d, sdBox(p * s, vec3(s / 17.)) / s, .1);
+}
+
+// trace the scene from ro (origin) to rd (direction, normalized)
+// until hit or reached maxDist, outputs distance traveled, the number of steps
+// and the closest distance achieved during marching (used of cheap edge detection)
+float trace(vec3 ro, vec3 rd, float maxDist, out float steps, out float nt) {
+    float total = 0.;
+    steps = 0.;
+    nt = 100.;
+    
+    for (int i = 0; i < MAX_STEPS; ++i) {
+        ++steps;
+        float d = map(ro + rd * total);
+        nt = min(d, nt);
+        total += d;
+        if (d < EPS || maxDist < total) break;
+    }
+    
+    return total;
+}
+
+// calculate the normal vector
+vec3 getNormal(vec3 p) {
+    vec2 e = vec2(.0001, 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)
+	));
+}
+
+// ambient occlusion
+float calculateAO(vec3 p, vec3 n) {
+    
+    float r = 0., w = 1., d;
+    
+    for (float i = 1.; i <= AO_SAMPLES; i++){
+        d = i / AO_SAMPLES / AO_RANGE;
+        r += w * (d - map(p + n * d));
+        w *= .5;
+    }
+    
+    return 1.-saturate(r * AO_RANGE);
+}
+
+// a lovely function that goes up and down periodically between 0 and 1, pausing at the extremes
+float pausingWave(float x, float a, float b) {
+    x = abs(fract(x) - .5) * 1. - .5 + a;       
+    return smoothstep(0., a - b, x);           
+}											   
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord) {
+    // transform screen coordinates
+	vec2 uv = fragCoord.xy / iResolution.xy;
+    uv = uv * 2. - 1.;
+    uv.x *= iResolution.x / iResolution.y;
+    
+    // transform mouse coordinates
+	vec2 mouse = iMouse.xy / iResolution.xy * 2. - 1.;
+    mouse.x *= iResolution.x / iResolution.y;
+    mouse *= 2.;
+    
+    // set time dependent constants
+    float speed = .25 / 10.5;
+    float time = mod(iTime, 290.);
+    time -= 10.5;
+    if (time > 167.) time -= 167.; else
+    if (time > 63.) time -= 63.;
+    time -= 5.25;
+	time *= speed;
+    
+    // these determine which object to show
+    _house = pausingWave(time, .15, .125);
+    _boat = pausingWave(time - .125 / .1, .15, .125);
+    _spaceship = pausingWave(time - .25 / .1, .15, .125);
+    _atmosphere = pausingWave(time - .375 / .1, .15, .125) * step(10., iTime);
+    
+    // set up kifs rotation matrix
+    float a = -texture(iChannel0, vec2(.5, .25)).x + sin(iTime) * .2 + .9;
+    float s = sin(a), c = cos(a);
+    _kifsRot *= mat3(c, -s, 0, s, c, 0, 0, 0, 1);
+    _kifsRot *= mat3(1, 0, 0, 0, c, -s, 0, s, c);
+    _kifsRot *= mat3(c, 0, s, 0, 1, 0, -s, 0, c);
+    
+    // set up kifs offset
+    _kifsOffset = .07 + texture(iChannel0, vec2(.1, .25)).x * .06;
+    
+    // set up camera position
+    vec3 rd =  normalize(vec3(uv, FOV));
+    vec3 ro = vec3(0, 0, -2);
+    
+    // light is relative to the camera
+    vec3 light = vec3(-1., .5, 0);
+    
+    vec2 rot = vec2(0);
+    if (iMouse.z > 0. && iMouse.x > 0. && iMouse.y > 0.) {
+    	// rotate the scene using the mouse
+        rot = -mouse;
+    } else {
+        // otherwise rotate constantly as time passes
+        rot = vec2(
+            iTime * SPEED * PI,//had to slightly modify \/ this value due to an issue reported by Fabrice
+            mix(sin(iTime * SPEED) * PI / 8., PI / 2. - 1e-5, saturate(exp(-iTime + 10.5))));
+    }
+    
+    tRotate(rd.yz, rot.y);
+    tRotate(rd.xz, rot.x);
+    tRotate(light.xz, rot.x);
+    tRotate(ro.yz, rot.y);
+    tRotate(ro.xz, rot.x);
+    
+    // march
+    float steps, outline, dist = trace(ro, rd, RENDER_DIST, steps, outline); 
+    
+    // calculate hit point coordinates
+    vec3 p = ro + rd * dist;
+    
+    // calculate normal
+    vec3 normal = getNormal(p);
+    
+    // light direction
+    vec3 l = normalize(light - p);
+    
+    // ambient light
+    float ambient = .1;
+    
+    // diffuse light
+    float diffuse = max(0., dot(l, normal));
+    
+    // specular light
+    float specular = pow(max(0., dot(reflect(-l, normal), -rd)), 4.);
+    
+    // "ambient occlusion"
+    float ao = calculateAO(p, normal);
+    
+    // create the background grid
+    vec2 gridUv = fragCoord.xy - iResolution.xy / 2.;
+    float grid = dot(step(mod(gridUv.xyxy, vec4(20, 20, 100, 100)), vec4(1)), vec4(.1, .1, .2, .2));
+    
+    // create blue background
+    vec3 bg = vec3(0, .1, .3) * saturate(1.5 - length(uv) * .5);
+    
+    // find the edges in the geometry
+    float edgeWidth = .0015;
+    float edge = smoothstep(1., .0, dot(normal, getNormal(p - normal * edgeWidth))) * step(length(p), 1.);
+    
+    // get the outline of the shapes
+    outline = smoothstep(.005, .0, outline) * step(1., length(p));
+    
+    // diagonal strokes used for shading
+    vec2 strokes = sin(vec2(uv.x + uv.y, uv.x - uv.y) * iResolution.y * PI / 4.) * .5 - .5;
+    
+    // first part of the shading: ao + marching steps
+    float highlights = (steps / float(MAX_STEPS) + sqrt(1. - ao)) * step(length(p), 1.) * .5;
+    highlights = floor(highlights * 5.) / 10.;
+    
+    // second part of the shading: ambient + diffuse + specular light
+    float fog = saturate(length(ro) - dist * dist * .25);
+    float lightValue = (ambient + diffuse + specular) * fog;
+    lightValue = floor(lightValue * 5.) / 10.;
+    
+    fragColor.rgb = mix(bg, vec3(1., .9, .7),
+                        max(max(max(saturate(highlights + strokes.x), saturate(lightValue + strokes.y)) * fog,
+                                (edge + outline) * 2. + strokes.y), grid));
+    
+    // gamma correction
+    fragColor = pow(saturate(fragColor), vec4(1. / 2.2)) * step(abs(uv.y), 1.);
+}