jakel101_shaders.json

{
  "userName": "jakel101",
  "date": "2025-09-10T23:32:03.814290+00:00",
  "numShaders": 58,
  "shaders": [
    {
      "ver": "0.1",
      "info": {
        "id": "wc2yWh",
        "date": "1756592684",
        "viewed": 90,
        "name": "glass ball bouncing on heightmap",
        "username": "jakel101",
        "description": "I wanted to try 3D physics ontop of my heightmap shader... first goal is a single ball - but maybe we can do a 2nd one. (one glass and one light?)",
        "likes": 5,
        "published": 3,
        "flags": 32,
        "usePreview": 0,
        "tags": [
          "25d",
          "heightmap",
          "physics",
          "pathracing"
        ],
        "hasliked": 0,
        "retrieved": "2025-09-10T23:32:03.814290+00:00"
      },
      "renderpass": [
        {
          "inputs": [
            {
              "id": 257,
              "src": "/media/previz/buffer00.png",
              "ctype": "buffer",
              "channel": 0,
              "sampler": {
                "filter": "linear",
                "wrap": "clamp",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            }
          ],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "// Apache 2.0 no patents \\_%_/\n\n/* Image pass shader to draw a texture/buffer/input as a heightmap\n* with some pathtracing as pillars of pixels.\n* Meant to be used in multiple projects and therefore\n* easily configurable at the top with a few macros\n*\n* selflink: https://www.shadertoy.com/view/M3VBWt\n* other projects using this shader/framework: https://www.shadertoy.com/playlist/mX2cD3\n* \n* work in progress:\n* todo(ideas):\n* - infinite/LOD tiles?\n* - DDA like traversal\n* - cleanup as usual\n* feedback/improvements welcome here.\n*/\n\n\n# define PI 3.141592653\n\n\n# define CELLS ivec2(64)\n//# define CELLS ivec2(3)\n\n// unsure yet where to bring this!\n# define SUN normalize(vec3(sin(iDate.w*0.5), cos(iTime), HEIGHT_SCALE*1.5))\n// normalize(vec3(3.0, -5.0, 2.0))\n\n// horizontal FOV, if you use negative values the camera will be orthographic!\n// examples:\n// FOV -1.0 for orthographic (sensor size)\n// FOV 90.0 for perspective wide\n// FOV 45.0 for perspective narower\n# define FOV 90.0\n\n// how far \"behind\" the camera is behind the arcball\n# define CAMERA_DIST 0.15\n\n\n// TODO one variable to change between sampled and direct light\n// 0 -> directional light\n// 1 -> point light\n// 2 -> MIS? (one light, one sampled?)\n// 3+ -> bounces//samples?\n# define BOUNCES 4\n# define SAMPLES 8\n\nstruct Material{\n    vec3 col; // ground color (or texture?)\n    float emissivity; //emitted light in some unit?\n    float roughness; // invers reflectivity, sorta\n    float translucency; // something like 1.0 for glass and 0.0 for solids? -> rays split/sample/refract??\n    float IOR; // index of refraction\n};\n\n// edit these here to change the look and feel!\nMaterial chalk = Material(vec3(1.0),           0.0,  0.95,  0.0, 1.3);\nMaterial ground = Material(vec3(0.5),          0.0,  0.95,  0.0, 0.0);\nMaterial sky = Material(vec3(0.02, 0.3, 0.85), 0.2,  0.50,  0.0, 0.0);\nMaterial glass = Material(vec3(1.0),           0.0,  0.02,  1.0, 1.33);\n\n\nstruct Ray{\n    vec3 origin;\n    vec3 dir;\n    vec3 inv_dir; // for speedup?\n};\n\n// helper constructor\nRay newRay(vec3 ro, vec3 rd){\n    return Ray(ro, rd, 1.0/rd);\n}\n\n\nstruct IntersectionInfo{\n    bool hit;\n    // rest illdefined for a miss\n    bool inside;\n    vec3 entry;\n    vec3 exit;\n    vec3 entry_norm;\n    vec3 exit_norm;\n    float entry_dist;\n    float exit_dist;\n};\n\n// sorta reference: https://tavianator.com/2022/ray_box_boundary.html\nIntersectionInfo AABB(vec3 center, vec3 size, Ray ray){\n    IntersectionInfo res;\n\n    vec3 pos = center + size;\n    vec3 neg = center - size;\n\n    vec3 pos_dist = (pos-ray.origin) * ray.inv_dir;\n    vec3 neg_dist = (neg-ray.origin) * ray.inv_dir;\n\n    vec3 min_dist = min(pos_dist, neg_dist);\n    vec3 max_dist = max(pos_dist, neg_dist);\n\n    res.entry_dist = max(max(min_dist.x, min_dist.y), min_dist.z);\n    res.exit_dist = min(min(max_dist.x, max_dist.y), max_dist.z);\n\n    // normals point away from the center\n    res.entry_norm = -sign(ray.dir) * vec3(greaterThanEqual(min_dist, vec3(res.entry_dist)));\n    res.exit_norm = sign(ray.dir) * vec3(lessThanEqual(max_dist, vec3(res.exit_dist)));\n\n    // essentially methods?\n    res.entry = ray.origin + ray.dir*res.entry_dist;\n    res.exit = ray.origin + ray.dir*res.exit_dist;\n\n    res.hit = res.entry_dist < res.exit_dist && res.exit_dist > 0.0;\n    res.inside = res.entry_dist < 0.0; // entry behind us\n\n    return res;\n}\n\n// with help from: https://www.scratchapixel.com/lessons/3d-basic-rendering/minimal-ray-tracer-rendering-simple-shapes/ray-sphere-intersection.html\nIntersectionInfo Sphere(vec3 center, float radius, Ray ray){\n    IntersectionInfo res;\n    vec3 local = ray.origin - center;\n        \n    float a = dot(ray.dir, ray.dir);\n    float b = 2.0* dot(ray.dir, local);\n    float c = dot(local, local) - pow(radius,2.0);\n        \n    float discriminant = pow(b,2.0) - 4.0*a*c;\n    \n    res.hit = discriminant >= 0.0;\n    \n    float t0 = (-b + sqrt(discriminant))/ (2.0*a);\n    float t1 = (-b - sqrt(discriminant))/ (2.0*a);\n\n    res.entry_dist = min(t0, t1);\n    res.exit_dist = max(t0, t1);\n    \n    if (res.entry_dist < 0.0 && res.exit_dist < 0.0){\n        res.hit = false;\n    }\n\n    res.entry = ray.origin + ray.dir * res.entry_dist;\n    res.exit = ray.origin + ray.dir * res.exit_dist;\n\n    res.entry_norm = normalize(res.entry - center);\n    res.exit_norm = normalize(res.exit - center);\n    \n    res.inside = res.entry_dist < 0.0 && res.exit_dist > 0.0; // entry behind us\n\n    return res;\n}\n\nvec4 sampleHeight(ivec2 cell){\n    // to allow for more complex math to determine height\n    // .rgb should just return the texture color or some modification of it\n    //cell.x = (cell.x + iFrame) % int(iChannelResolution[0].x); // fun texture scroll\n    vec4 tex = texelFetch(iChannel0, cell, 0);\n    vec4 res;\n    res.a = tex.r + tex.g + tex.b; // we do height by a sum of the color for now\n    res.a *= 0.33;\n    res.rgb = tex.rgb; // simply copy the color as the \"texture\" for now\n    \n    // res.a = tex.a; // debug/use existing height data.\n    res.a *= HEIGHT_SCALE;\n    return res;\n}\n\n\n\nIntersectionInfo pillar_hits(ivec2 cell, float height, Ray ray){\n    // let's move the pillar into world space by having it's center + extends\n\n    vec3 extend = vec3(1.0/vec2(CELLS), abs(height)*0.5);\n    vec3 p = vec3(cell.xy, abs(height)*0.5);\n    p.xy *= extend.xy;\n    p.xy *= 2.0;\n    p.xy -= 1.0 - extend.xy; // not quite the offset?\n    //extend.z = extend.y; // make them cubes?\n\n    // for the case of clouds the box is at the top?\n    if (height < 0.0){\n        p.z = HEIGHT_SCALE*(1.0-abs(height*0.5));\n    }\n\n    // TODO: redo this math when less asleep...\n    IntersectionInfo res = AABB(p, extend, ray);\n    return res;\n}\n\n\n\n// from: https://www.shadertoy.com/view/7l3yRn\nvec2 get_random_numbers(inout uvec2 seed) {\n    // This is PCG2D: https://jcgt.org/published/0009/03/02/\n    seed = 1664525u * seed + 1013904223u;\n    seed.x += 1664525u * seed.y;\n    seed.y += 1664525u * seed.x;\n    seed ^= (seed >> 16u);\n    seed.x += 1664525u * seed.y;\n    seed.y += 1664525u * seed.x;\n    seed ^= (seed >> 16u);\n    // Convert to float. The constant here is 2^-32.\n    return vec2(seed) * 2.32830643654e-10;\n}\n\n// also from above\n// TODO collaplse into one function!\n// Given uniform random numbers u_0, u_1 in [0,1)^2, this function returns a\n// uniformly distributed point on the unit sphere (i.e. a random direction)\n// (omega)\nvec3 sample_sphere(vec2 random_numbers) {\n    float z = 2.0 * random_numbers[1] - 1.0;\n    float phi = 2.0 * PI * random_numbers[0];\n    float x = cos(phi) * sqrt(1.0 - z * z);\n    float y = sin(phi) * sqrt(1.0 - z * z);\n    return vec3(x, y, z);\n}\n\n\n// Like sample_sphere() but only samples the hemisphere where the dot product\n// with the given normal (n) is >= 0\nvec3 sample_hemisphere(vec2 random_numbers, vec3 normal) {\n    vec3 direction = sample_sphere(random_numbers);\n    if (dot(normal, direction) < 0.0)\n        direction -= 2.0 * dot(normal, direction) * normal;\n    return direction;\n}\n\n\nstruct RaycastInfo{\n    bool hit; // if negative, the rest is undefined.\n    float dist; // hit_info.entry_dist redundant?\n    //ivec2 cell; //current_cell?\n    IntersectionInfo hit_info; //has the entry norm etc.\n    vec3 col; // TODO: replace with material\n    //Ray ray; //just as a reference?\n};\n\n\nRaycastInfo raycast(Ray ray){\n    // cast the ray untill there is a hit or we exit the box\n    // \"any hit\" shader?\n    RaycastInfo result;\n    \n    IntersectionInfo box = AABB(vec3(0.0, 0.0, HEIGHT_SCALE*0.5), vec3(1.0, 1.0, HEIGHT_SCALE*0.5), ray);\n\n    vec3 entry = box.entry;\n\n    if (!box.hit){\n        // if we \"MISS\" the whole box (not inside?).\n        result.hit = false;\n        return result;\n        \n    }\n    // everything below here is inside the box\n    if (box.inside){\n        // if we are \"inside\" the entry should just be ro!\n        entry = ray.origin; // maybe problems with distance caluclations at the end?\n    }\n    \n    ivec2 current_cell = worldToCell(entry); // TODO: this one is problematic!\n    int i;\n    ivec2 max_cells = CELLS - min(current_cell, CELLS-current_cell);\n    int max_depth = (max_cells.x + max_cells.y)+2; // could also be min!\n    for (i = 0; i < max_depth; i++){\n        if (current_cell.x < 0 || current_cell.x >= CELLS.x ||\n            current_cell.y < 0 || current_cell.y >= CELLS.y){\n            // we marched far enough are are \"outside the box\" now!\n            result.hit = false;            \n            return result;\n        }\n\n        vec4 tex = sampleHeight(current_cell);\n        IntersectionInfo pillar = pillar_hits(current_cell, tex.a, ray);\n\n        if (pillar.hit) {\n            // \"any hit\" (side/top/bot) -> loop ends here\n            // do a little bit of light sim by doing diffuse \"block of chalk\"\n            vec3 col = tex.rgb;\n            // TODO materail decision here?\n            result.hit = true;\n            result.hit_info = pillar;\n            result.dist = pillar.entry_dist;\n            result.col = col;\n            return result;            \n        }\n\n        // check if our exit distance larger than the box, means we should be at the final pillar...\n        if (pillar.exit_dist >= box.exit_dist){\n            result.hit = false;\n            return result; // do we ever get here?\n        }\n\n        // the step\n        // TODO: DDA style decision\n        ivec2 next_cell = current_cell + ivec2(pillar.exit_norm.xy);\n        if (next_cell == current_cell){\n            // in this case we do another raycast - but without any Z component\n            // so the vector is sideways and points to a new cell!\n            vec3 flat_rd = vec3(ray.dir.xy, 0.0);\n            Ray flat_ray = Ray(ray.origin, flat_rd, 1.0/flat_rd);\n\n            IntersectionInfo grid = pillar_hits(current_cell, 1.0, flat_ray);\n            next_cell += ivec2(grid.exit_norm.xy); // TODO check if this norm is correct!\n        }\n        // for next iteration\n        current_cell = next_cell;\n    }\n    \n    result.hit = false;\n    return result;\n}\n\n// more like a bad shadowmap\n// idea for the future: precompute the horizon per pixel: https://youtu.be/LluCbGdi-RM\nfloat directional_light(Ray sun_ray, vec3 normal){\n    // return the amount of shadowed?\n    // we are now marching upwards from some hit\n    // ro is essentially the point we started from\n    // rd is the sun angle\n    RaycastInfo res = raycast(sun_ray);\n    //return res.a;\n    \n    //TODO: intensity/color?\n    \n    float amt = 1.0;\n    \n    \n    if (!res.hit){// || (ro + rd*res.a).z >= HEIGHT_SCALE){\n        // miss means full sunlight!\n        amt = max(0.0, dot(sun_ray.dir, normal));\n    }\n    else {\n        // TODO: use distance?\n        amt = 0.1; // additional ambient light from here?\n    }\n    return amt;\n}\n\n// struct for lights? colored light?\nfloat point_light(vec3 start, vec3 light_pos, float light_intensity, vec3 normal){\n    float amount;\n    \n    vec3 light_dir = normalize(light_pos - start);\n    float light_dist = distance(start, light_pos);\n    // Ray(hit+0.001*SUN, SUN, 1.0/SUN);\n    Ray light_cast = Ray(start + 0.001*light_dir, light_dir, 1.0/light_dir);\n    RaycastInfo res = raycast(light_cast);\n    \n    if (!res.hit || res.dist > light_dist) {\n        // either we miss geometry or we hit gometry behind the light\n        amount = inversesqrt(light_dist)* light_intensity;\n        amount *= max(0.0, dot(normal, light_dir));\n    }\n    else {\n        // hit an intersection before the light, so don't see the light!\n        amount = 0.0;        \n    }\n    \n    // TODO still needs dot normal!\n    return amount;\n}\n\n\n\n// copied from https://www.shadertoy.com/view/M3jGzh\nfloat checkerboard(vec2 check_uv, float cells){\n    check_uv *= cells/2.0;\n    float rows = float(mod(check_uv.y, 1.0) <= 0.5);\n    float cols = float(mod(check_uv.x, 1.0) <= 0.5);\n    return float(rows == cols);\n}\n\nstruct HitInfo{\n    Material mat;\n    float dist;\n    vec3 norm;\n    vec3 pos;\n    bool inside; // for doing glass rays!\n};\n\n\nHitInfo sampleGround(vec3 ro, vec3 rd){\n    HitInfo res;\n    // TODO: rename to sample skybox maybe? as the ground is sorta part of that...\n    float ground_height = 0.0;\n    float ground_dist = (ground_height-ro.z)/rd.z;\n    // TODO: use the actual sphere for the \"skybox\"\n    if (ground_dist < 0.0 ||ground_dist > 10.0) {\n        // essentially sky hit instead?\n        // just some random skybox right now... could be improved of course!\n        vec3 col = vec3(0.23, 0.59, 0.92)*exp(dot(SUN, rd)-0.8);\n        col = clamp(col, vec3(0.0), vec3(1.0));\n        \n        res.mat = sky;\n        \n        res.mat.col = col; // no longer matches with \"sky\" - so gotta change the above maybe?\n        \n        res.dist = 10.0;\n        res.pos = ro + rd*res.dist;\n        res.mat.emissivity *= clamp(smoothstep(res.dist - 8.1, res.dist- 3.0, res.pos.z), 0.0, 1.0);\n        res.norm = -rd;\n        return res; // some random distance that is positive!\n    }\n\n    vec3 ground_hit = ro + (rd * ground_dist);\n\n    float val = checkerboard(ground_hit.xy, 8.0)* 0.25;\n    val += 0.45;\n    //val *= 2.0 - length(abs(ground_hit));\n\n    // fake sun angle spotlight... TODO actual angle and normal calculation!\n    //val *= 2.5 - min(2.3, length((-SUN-ground_hit)));//,vec3(0.0,0.0,1.0));\n\n    vec3 col = vec3(val);\n    res.mat = ground;\n    res.mat.col = col;\n    res.dist = ground_dist;\n    res.pos = ground_hit;\n    res.norm = vec3(0.0, 0.0, 1.0);\n    return res;\n}\n\n// TODO for montecarlo we need an external loop around this!\nHitInfo scene(Ray camera, vec3 ball_pos, vec3 ball2_pos){\n    HitInfo res;\n    \n    // terrain\n    RaycastInfo terrain = raycast(camera);\n\n    // ball\n    IntersectionInfo ball = Sphere(ball_pos, BALL_SIZE, camera);\n    IntersectionInfo ball2 = Sphere(ball2_pos, BALL_SIZE, camera); // TODO: ballsize in .w data point? so they can some how change dynamically?\n\n    // five cases: just terrain hit, ball hit, both miss, both hit terrain closer, both hit ball closer\n    // idea: get all hits, then calculate closest (sorted?) and then return that. if none return background\n    // TODO: redo logic (dynamic arrays?)\n    \n    // front first?\n    res.dist = 1000.0;\n    \n    if (ball.hit && ball.entry_dist < res.dist) {\n        // ball infront of the terrain\n        res.dist = ball.entry_dist;\n        res.mat = glass; // TODO: glass material?\n        res.norm = ball.entry_norm;\n        res.pos = ball.entry;        \n        res.inside = ball.inside;\n        if (res.inside) {\n            res.dist = ball.exit_dist;\n            res.norm = ball.exit_norm;\n            res.pos = ball.exit;\n       }      \n    } \n    if (ball2.hit && ball2.entry_dist < res.dist) {\n        // ball infront of the terrain\n        res.dist = ball2.entry_dist;\n        res.mat = glass; // TODO: glass material?\n        res.mat.emissivity = 3.5; // 2nd ball is a light source!\n        res.norm = ball2.entry_norm;\n        res.pos = ball2.entry;        \n        res.inside = ball2.inside;\n        if (res.inside) {\n            res.dist = ball2.exit_dist;\n            res.norm = ball2.exit_norm;\n            res.pos = ball2.exit;\n        }\n    }\n    if (terrain.hit && terrain.hit_info.entry_dist < res.dist) {\n        // terrain infront of the ball\n        res.dist = terrain.hit_info.entry_dist;\n        res.mat = chalk;\n        res.mat.col = terrain.col; // TODO: material construction\n        res.norm = terrain.hit_info.entry_norm;\n        res.pos = terrain.hit_info.entry;\n        res.inside = terrain.hit_info.inside;\n        if (res.inside) {\n            res.dist = terrain.hit_info.exit_dist;\n            res.norm = terrain.hit_info.exit_norm;\n            res.pos = terrain.hit_info.exit;\n        }  \n    }\n    if (res.dist > 900.0) {\n        // miss here, but badly scaled \"skybox\"\n        res = sampleGround(camera.origin, camera.dir);\n    }\n    \n\n    return res;\n}\n\n// follow ? https://www.shadertoy.com/view/7l3yRn\nstruct RayRadiance{\n    vec3 radiance;\n    vec3 throughput_weight;\n};\n\n// reading: https://www.pbr-book.org/4ed/Radiometry,_Spectra,_and_Color/Surface_Reflection\n// further: https://www.pbr-book.org/4ed/Reflection_Models\n// watching maybe: https://youtu.be/wA1KVZ1eOuA\nvec3 brsf(in vec3 rd, in HitInfo hit, inout vec3 next_dir, inout uvec2 seed){\n    // returns the outgoing radiance?\n    // as well as the next ray direction. (inout)\n    \n    Material mat = hit.mat;\n    vec3 norm = hit.norm;\n    // naive reflection model\n    vec3 perfect_reflection = reflect(rd, norm);\n    next_dir = mix(perfect_reflection, next_dir, mat.roughness);\n    \n    //native transmission model\n\n    vec2 randoms = get_random_numbers(seed);\n    if (randoms.x < mat.translucency) {\n        float IOR = hit.inside ? mat.IOR : 1.0/mat.IOR;\n        vec3 reflect_norm = hit.inside ? norm : -norm;\n        vec3 perfect_refraction = refract(rd, -reflect_norm, IOR);\n        next_dir = mix(perfect_refraction, -next_dir, mat.roughness);\n        //next_dir = perfect_refraction;\n        norm = reflect_norm;\n    }\n\n    vec3 outgoing = mat.col * 2.0 * max(0.0, dot(norm, next_dir));\n    return outgoing;\n}\n\n\n\n// factored out to function so the seed changes correctly due to inout -.-\nvec3 get_ray_radiance(Ray camera, vec3 ball_pos, vec3 ball2_pos, inout uvec2 seed){\n    //after get_ray_radiance in https://www.shadertoy.com/view/7l3yRn\n\n    vec3 radiance = vec3(0.0);\n    vec3 throughput_weight = vec3(1.0);\n\n    int i;\n    for(i=0; i<=BOUNCES; i++){\n        HitInfo first_hit = scene(camera, ball_pos, ball2_pos);\n        radiance += throughput_weight * first_hit.mat.emissivity;\n        \n        // initialize with random here??\n        vec3 next_dir = sample_hemisphere(get_random_numbers(seed), first_hit.norm);        \n        vec3 outgoing_radiance = brsf(camera.dir, first_hit, next_dir, seed);\n        \n        throughput_weight *= outgoing_radiance;\n        camera = newRay(first_hit.pos+0.0001*next_dir, next_dir);\n    }\n\n    return radiance;\n}\n\n\n\n// TODO: sample hemisphere function\n// TODO: brdf kinda function where it gives you a new direction based on material.\n// TODO: calucalte the light from that brdf too? HitInfo2 -> RayRadiance, next_dir\n// multiple importance sampling? following: https://lisyarus.github.io/blog/posts/multiple-importance-sampling.html\n// idea being we sample the direct light or direction light once, and then do one random sample. weight them 50/50?\n// TODO: call scene below and loop it?\n// 1. cast scene, 2. accumulate light, 3. get next dir, LOOP\n// add a MAX_bounces or SPP var at the top.\n\n\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    // uv normalized to [-1..1] for height with more width\n    vec2 uv = (2.0*fragCoord - iResolution.xy)/iResolution.y;\n    vec2 mo = (2.0*iMouse.xy - iResolution.xy)/iResolution.y;\n    \n    \n    uvec2 seed = uvec2(fragCoord) ^ uvec2(iFrame << 16);\n    vec3 ball_pos = texelFetch(iChannel0, ivec2(0,0), 0).xyz;\n    vec3 ball2_pos = texelFetch(iChannel0, ivec2(8,0), 0).xyz; // janky proof of concept for now!\n    //fragColor = texture(iChannel0, uv);\n    //return;\n\n    // for when it's just idling...\n    float azimuth = -1.9+iTime*0.1 + mo.x; // keeps a bit of residue of the mouse!\n    float altitude = 0.7+cos(1.5+iTime*0.25)*0.35;\n    if (sign(iMouse.z) > 0.0){\n        // orbiting camera setup\n        azimuth = PI*mo.x;\n        altitude = 0.5*PI*clamp(mo.y+1.0, -0.01, 0.99); // maybe just positive?\n    }\n\n    // make sure you don't look \"below\"\n    altitude = clamp(altitude, HEIGHT_SCALE*0.2, PI);\n\n    // a unit length orbit!\n    vec3 camera_pos = vec3(\n        cos(azimuth)*cos(altitude),\n        sin(azimuth)*cos(altitude),\n        sin(altitude));\n    // the camera is always looking \"at\" the origin or half way above it\n        \n    camera_pos = ball_pos + CAMERA_DIST*camera_pos;\n    \n    vec3 nodal = vec3(0.0, 0.0, HEIGHT_SCALE*0.5);\n    vec3 look_at = mix(ball_pos, nodal, 0.05); // so it's not crazy locked on \n    \n    vec3 look_dir = normalize(look_at-camera_pos);\n\n\n    // TODO moving the camera in and out over time??\n    //camera_pos += look_dir * CAMERA_DIST; // moving the camera \"back\" to avoid occlusions?\n    // two vectors orthogonal to this camera direction (tagents?)\n    //vec3 look_u = camera_pos + vec3(-sin(azimuth), cos(azimuth), 0.0);\n    //vec3 look_v = camera_pos + vec3(sin(altitude)*-cos(azimuth), sin(altitude)*-sin(azimuth), cos(altitude));\n\n\n    // turns out analytically these aren't correct. so using cross instead -.-\n    vec3 up_vec = vec3(0.0, 0.0, 1.0);\n    vec3 look_u = normalize(cross(look_dir, up_vec));\n    vec3 look_v = normalize(cross(look_u, look_dir)); // is this faster?\n    // camera plane(origin of each pixel) -> barycentric?\n\n    vec3 camera_plane;\n    vec3 ray_dir;\n    vec3 ray_origin;\n\n    if (FOV > 0.0){\n        // assume a pinhole camera.\n        // FOV is the horizontal fov, the given focal length becomes:\n        // the 1.0 is the sensor height.\n        float focal_length = 1.0/tan(radians(FOV*0.5));\n\n        // the ro\n        camera_plane = camera_pos - (look_dir*focal_length) + ((look_u*uv.x) + (look_v*uv.y))*-1.0; // inverted here to see upright\n        ray_origin = camera_pos;\n\n        // the rd\n        ray_dir = camera_pos-camera_plane;\n        ray_dir = normalize(ray_dir);\n    }\n\n    else {\n        // negative FOV values are interpreted as a sensor size for a orthographic camera!\n        // horizontal sensor size, -1 would be something sensible... everything else is far away\n        float sensor_size = FOV*0.5*-1.0;\n        camera_plane = camera_pos + ((look_u*uv.x)+(look_v*uv.y))*sensor_size; // wider fov = larger \"sensor\"\n        ray_dir = look_dir;\n        ray_origin = camera_plane;\n    }\n\n    // todo extract to a function\n    // Ray in -> material/normal out?\n    // caluclate and aggregate light throughput?\n    // new ray direction based on sampled material/refraction?\n\n    Ray camera = newRay(ray_origin, ray_dir);\n    vec3 out_col = vec3(0.0);\n\n    int j;\n    for(j=0; j<SAMPLES; ++j){\n        vec3 rad = get_ray_radiance(camera, ball_pos, ball2_pos, seed);\n        out_col += rad;\n    }\n    // average color over all samples\n    out_col /= float(SAMPLES);\n    \n    // TODO gamma correction?\n    fragColor = vec4(out_col, 1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        },
        {
          "inputs": [
            {
              "id": 30,
              "src": "/media/a/f735bee5b64ef98879dc618b016ecf7939a5756040c2cde21ccb15e69a6e1cfb.png",
              "ctype": "texture",
              "channel": 1,
              "sampler": {
                "filter": "nearest",
                "wrap": "repeat",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            },
            {
              "id": 257,
              "src": "/media/previz/buffer00.png",
              "ctype": "buffer",
              "channel": 0,
              "sampler": {
                "filter": "linear",
                "wrap": "clamp",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            }
          ],
          "outputs": [
            {
              "id": 257,
              "channel": 0
            }
          ],
          "code": "//buffer pass does the physics simulation!\n// lots of todo to find here!\n\n\n# define SUBSTEPS 16\n# define GRAVITY -9.8\n# define SIM_SPEED 0.3\n\nvec4 init(vec2 uv){\n    //return vec4(uv.x, uv.y, 0.5, 1.0);\n    vec4 tex = texture(iChannel1, uv/vec2(CELLS));    \n    // TODO add dt here\n    return tex;\n}\n\n\n// TODO: can't put in common as the sampler is requied - will break wgpu -.-\nvec4 sampleHeight(vec4 tex, float anim_time, vec2 uv){\n\n    // modulate from above: \n    tex = 0.5+ sin(tex*6.0 + 0.6*(anim_time)+vec4(uv.x,uv.y,1,0)) * 0.5;\n\n    //vec4 tex = texelFetch(iChannel0, cell, 0); // TODO: skip resample\n    vec4 res;\n    res.a = tex.r + tex.g + tex.b; // we do height by a sum of the color for now\n    res.a *= 0.33;\n    res.rgb = tex.rgb; // simply copy the color as the \"texture\" for now\n    \n    // res.a = tex.a; // debug/use existing height data.\n    res.a *= HEIGHT_SCALE;\n    return res;\n}\n\n\n// TODO box - sphere intersection?\n// sph, box -> error/direction/scale\n// sum it all up, recaclucalte velocity? (Position based dynamics?)\n\n\n// TODO: ball box intersection\n// TODO ball, ball intersection? (how to cross write?)\n\n\n\n// TODO: fix the bounces and rewatch https://youtu.be/j84zJ06wnVA\nvoid animate(float dt, int sub_step, in vec2 uv, in vec3 pos, in vec3 vel, out vec3 new_pos, out vec3 new_vel){    \n    new_vel = vel;\n    new_vel.z += GRAVITY *dt;\n    new_pos = pos + new_vel *dt;\n    \n    // basic bouce on the ground:\n    // TODO check the one pillar on the contact point my mapping uv back to texture I guess.\n    float anim_time = iTime + float(sub_step) * dt; \n    vec4 tex = init(new_pos.xy);\n    float height = sampleHeight(tex, dt, uv).a;\n    if ((new_pos.z - RADIUS) < height) {\n        // TODO restitution\n        new_pos.z = pos.z; // TODO don't stop here\n        new_vel.z *= -1.0;\n    }\n    \n    // sides at 1.0 and -1.0 in all directions\n    // TODO bvec here?\n    // probably scale by the overshoot...\n    if ((abs(new_pos.x) + RADIUS) > 1.0) {\n        float error = (abs(new_pos.x) + RADIUS) - 1.0;\n        new_vel.x *= -1.0;\n        \n        new_pos.x += new_vel.x*error;        \n    }\n    if ((abs(new_pos.y) + RADIUS) > 1.0) {\n        new_pos.y = pos.y;\n        new_vel.y *= -1.0;\n    }\n    \n    // TODO check all pillars below the ball!\n    // TODO sidewalls bounce a pillar\n    // how to do a sideways bounce?\n}\n\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    // todo not to the limited 64x64 scale of the world -.-\n    vec2 uv = (2.0*fragCoord - iResolution.xy)/iResolution.y;\n    \n    if (fragCoord.x > 65.0 || fragCoord.y > 65.0){\n        discard;\n    }\n    \n    ivec2 st = ivec2(fragCoord);\n    // since we need to store at least 6 values, we mask them with bools here\n    // TODO maybe macros?\n    \n    // store a ball per row? // TODO -> NUM_BALLS common define?\n    int BALL_ID = int(fragCoord.x);    \n    ivec2 POS_MEM = ivec2(BALL_ID,0);\n    ivec2 VEL_MEM = ivec2(BALL_ID,1);\n    bool STORE_POS = (st == POS_MEM) ? true : false;\n    bool STORE_VEL = (st == VEL_MEM) ? true : false;\n    \n    vec3 pos = texelFetch(iChannel0, POS_MEM, 0).xyz;\n    vec3 vel = texelFetch(iChannel0, VEL_MEM, 0).xyz;    \n    \n    vec4 col = vec4(0.0);\n    vec4 tex; // values at the \"start\" of this timestep?\n    if (iFrame < 2){\n        col = init(vec2(st)/64.0);\n        pos = vec3(0.0, 0.0, 0.75);\n        vel = vec3(uv.x, 2.5, 0.1);\n    }\n    // if (!STORE_POS || !STORE_VEL)\n    else{\n        tex = init(vec2(st));\n        col = sampleHeight(tex, iTime, uv);\n        //discard;        \n    }\n    \n    vec3 new_pos = pos;\n    vec3 new_vel = vel;\n    \n    float dt = (iTimeDelta/float(SUBSTEPS))*SIM_SPEED;\n    // TODO extract to function\n    int i;\n    for (i=0; i < SUBSTEPS; i++){\n        animate(dt, i, uv, pos, vel, new_pos, new_vel);\n        pos = new_pos;\n        vel = new_vel;\n    }        \n    \n    // TODO maybe \n    // write only the relavent part?\n    col.rgb = STORE_POS ? new_pos : col.rgb;\n    col.rgb = STORE_VEL ? new_vel : col.rgb;\n    fragColor = col;\n}",
          "name": "Buffer A",
          "description": "",
          "type": "buffer"
        },
        {
          "inputs": [],
          "outputs": [],
          "code": "// a few shared things\n# define RADIUS 0.035\n# define BALL_SIZE RADIUS\n\n\n# define CELLS ivec2(64)\n# define HEIGHT_SCALE 0.2\n\n\nivec2 worldToCell(vec3 p) {\n    // move world space again\n    p += 1.0;\n    p *= 0.5;\n    ivec2 st = ivec2((p.xy*vec2(CELLS.xy)));\n    // TODO: find an actual solution to the edge cases!\n    st = min(st, CELLS -1);\n    return st;\n}\n",
          "name": "Common",
          "description": "",
          "type": "common"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "wXVSR1",
        "date": "1754338508",
        "viewed": 84,
        "name": "Double Pendulum Datacube",
        "username": "jakel101",
        "description": "this idea came when I watched https://youtu.be/9gQQAO4I1Ck\nthe screenspace essentially picks different initial conditions, keeping track of position and momentum for the inner and outer pendulum. use mouse to inspect a specific pendulum!\n",
        "likes": 4,
        "published": 3,
        "flags": 32,
        "usePreview": 0,
        "tags": [
          "simulation",
          "physics",
          "doublependulum",
          "datacube"
        ],
        "hasliked": 0,
        "retrieved": "2025-09-01T22:40:36.098288+00:00"
      },
      "renderpass": [
        {
          "inputs": [
            {
              "id": 257,
              "src": "/media/previz/buffer00.png",
              "ctype": "buffer",
              "channel": 0,
              "sampler": {
                "filter": "linear",
                "wrap": "repeat",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            },
            {
              "id": 258,
              "src": "/media/previz/buffer01.png",
              "ctype": "buffer",
              "channel": 1,
              "sampler": {
                "filter": "nearest",
                "wrap": "repeat",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            }
          ],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "// Apache 2.0 no patents | ($)~~o~~($) |\n// imporvements and remixes welcome!\n\n// image pass lets you see the datacube and then pick any parallel timeline\n// use the mouse and click to view a specific timeline (whole screen)\n\n// previously derived in https://www.shadertoy.com/view/wc33WX\nfloat sdLineSegment(vec2 p, vec2 a, vec2 b) {\n    float d;    \n    float h = clamp(dot(p-a, b-a)/(length(b-a)*length(b-a)), 0.0, 1.0);\n    vec2 q = mix(a, b, h);    \n    d = length(p-q);\n    return d;\n}\n\nfloat sdBall(vec2 pos, float rad){\n    return length(pos) - rad;\n}\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    // Normalized pixel coordinates (from -1 to 1)\n    vec2 uv = fragCoord/iResolution.xy;\n    vec2 cube_st = uv; // sampling coords we need for the whole screen\n    uv *= 2.0;\n    vec2 cube_uv = uv;\n    uv -= 1.0;\n    vec2 m = iMouse.xy/iResolution.xy;\n    m *= 2.0;\n    m -= 1.0;\n\n    ivec2 st = ivec2(iMouse.xy); //TODO remap to lineup with the front of the cube!\n    vec4 state = texelFetch(iChannel0, st, 0);\n    \n    // sanity checks!\n    // m = Cartesian2Polar(m); // Polar2Cartesian\n    // m = Polar2Cartesian(m.x, m.y); // Polar2Cartesian\n    \n    // sorta the background?\n    vec4 cube = texture(iChannel1, cube_st);\n    vec4 full = texture(iChannel0, cube_st); // this one for fullscreen!    \n    \n    vec3 col = mix(full, cube, clamp(-cos(iTime*0.3)*5.0, 0.0, 1.0)).rgb; // since .a channel also has information it might be worth looking at that too!\n    \n    // TODO these scale is not the same as used for the simulation, but should be proportional\n    vec2 inner_pos = Polar2Cartesian(state.x, 0.45);\n    vec2 outer_pos = inner_pos - Polar2Cartesian(state.z, -0.45); // why minus here?\n        \n    // TODO make pixel width analytically correct!\n    float pixel_width = 0.002;\n    \n    // TODO maybe make a draw func? void( inout bg, in fg, in mask)\n    float selector_dist = sdBall(uv - m, 0.02); // TODO what happens outside the area?\n    col = mix(col, vec3(0.8, 0.8, 0.4), smoothstep(pixel_width, -pixel_width, selector_dist));\n    float innter_rod = sdLineSegment(uv, vec2(0.0, 0.0), inner_pos);\n    col = mix(col, vec3(0.4, 0.4, 0.1), smoothstep(pixel_width, -pixel_width, innter_rod-0.01));\n    float outer_rod = sdLineSegment(uv, inner_pos, outer_pos);\n    col = mix(col, vec3(0.6, 0.6, 0.1), smoothstep(pixel_width, -pixel_width, outer_rod-0.01));\n    float pendulum = sdBall(uv - outer_pos, 0.02);\n    col = mix(col, vec3(1.0, 1.0, 0.1), smoothstep(pixel_width, -pixel_width, pendulum));\n    // Output to screen\n    \n    \n    float angle = atan(uv.x, uv.y);\n    float dist = length(uv)*2.0;\n    //col = vec3((angle/(PI*2.0))+ 0.5, 0.0, 0.0);\n    \n    fragColor = vec4(col, 1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        },
        {
          "inputs": [
            {
              "id": 257,
              "src": "/media/previz/buffer00.png",
              "ctype": "buffer",
              "channel": 0,
              "sampler": {
                "filter": "linear",
                "wrap": "repeat",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            }
          ],
          "outputs": [
            {
              "id": 257,
              "channel": 0
            }
          ],
          "code": "// this buffer does the physics simulation\n// outputs are as follows\n// .x position of the inner pendulum\n// .y rotational speed of the inner pendulum\n// .z position of the outer pendulum (in half rotations from the bottom) left/clockwise is negative\n// .w rotational speed of the outer pendulum clockwise is negative\n\n// substeps still scale the same time, but should be more \"accurate\" but results in why more noise too\n// energy is kept longer, breaks on really high numbers like > 110 or something :/\n#define SUBSTEPS 32\n// this can be changed to make it go \"faster\"\n#define GRAVITY -9.8\n\nvec4 init(vec2 uv) {\n    // this let's you set the initial conditions in relation to screenspace, so play around here and have fun\n    // requiers you to rewind time!\n    vec4 vals;\n    \n    vals.xz = uv; // rotation position\n    vals.yw = vec2(0.0); // start with 0 momentum!\n    //vals.xz = vec2(1.0); // start at the top\n    \n    // vals.x = 0.0; //for testing the outer part is just hanging\n    vals.yw = uv.yx*6.1; // add a lot of momentum!\n    \n    \n    //vals.wy = uv*0.01; // really close initial conditions (start athe the top)\n    \n    vals.y *= -1.0; // little flip so the default mouse position looks more interesting!\n    return vals;\n}\n\n// not used, left over from development!\nvoid simulate_single(inout vec2 pos, inout vec2 vel, float dt){\n    // assume the mass is 1!\n    vel.y += GRAVITY *dt;\n    \n    vec2 new_pos = pos + vel * dt;\n    // constraints\n    \n    // assume length is 1 and fixed to the origin\n    float error = 1.0 - length(new_pos);\n    vec2 corr = new_pos * -1.0 * error;\n\n    new_pos -= corr;\n\n    vec2 next_vel = (new_pos - pos) / dt;\n\n    // outputs\n    pos = new_pos;\n    vel = next_vel;\n}\n\n\nvoid simulate_double(float dt, inout vec2 pos_i, inout vec2 vel_i, inout vec2 pos_o, inout vec2 vel_o){\n    // reference: https://github.com/matthias-research/pages/blob/master/tenMinutePhysics/06-pendulumShort.html MIT licnesed\n    vec2 new_pos_i;\n    vec2 new_vel_i;\n    vec2 new_pos_o;\n    vec2 new_vel_o;\n    \n    // step 1 apply gravity\n    vel_i.y += GRAVITY *dt;\n    vel_o.y += GRAVITY *dt;\n    new_pos_i = pos_i + vel_i * dt;\n    new_pos_o = pos_o + vel_o * dt;\n    \n    // step 2 constraints:\n    // assume masses and lengths is 1\n    // inner is fixed to 0,0 and outer is attached to inner    \n    vec2 delta = new_pos_o - new_pos_i;\n    float error_o = 1.0 - length(delta);\n    vec2 corr_i = error_o * -0.5 * delta; // 0.5 is the inverse mass\n    vec2 corr_o = error_o * -0.5 * delta;    \n    new_pos_i += corr_i; // one adds and one subtracts.. to move them towards their targets\n    new_pos_o -= corr_o;\n    \n    // TODO: is this order correct?\n    float error_i = 1.0 - length(new_pos_i);\n    corr_i = new_pos_i * -1.0 * error_i;\n    new_pos_i -= corr_i;\n    \n    \n    // step3 derive new velocities\n    new_vel_i = (new_pos_i - pos_i) /dt;\n    new_vel_o = (new_pos_o - pos_o) /dt;\n        \n    \n    //return not needed but we use inouts\n    pos_i = new_pos_i;\n    vel_i = new_vel_i;\n    pos_o = new_pos_o;\n    vel_o = new_vel_o;\n}\n\n// lets first try a single pendulumn!\nvec2 single(float a, float v){\n    // reference: https://youtu.be/XPZEeS70zzU\n\n    // returns them as polar again?\n    vec2 new;\n    vec2 pos = Polar2Cartesian(a, 1.0);\n    vec2 orth = Polar2Cartesian(a + 0.5, 1.0); // just an orthogonal vector we then scale\n    vec2 vel = orth*v;\n    \n    int i;\n    float dt = (iTimeDelta/float(SUBSTEPS));\n    for (i=0; i<SUBSTEPS; i++){\n        simulate_single(pos, vel, dt);\n    }    \n    vec2 new_pos = pos;\n    vec2 new_vel = vel;\n    \n    // reproject to polar coordinates:    \n    new.x = Cartesian2Polar(new_pos).x;\n    \n    vec2 next_orth = Polar2Cartesian(new.x + 0.5, 1.0);\n    new.y = length(new_vel)*sign(dot(new_vel,next_orth));\n    new.y = dot(new_vel, next_orth);\n    return new;\n}\n\nvec4 double_pendulum(vec4 state){\n    // decode positions and velocities\n    float lenght_i = 1.0;\n    float length_o = 1.0;\n    //TODO where do we put the lengths?\n    float angle_i = state.x;\n    float momentum_i = state.y;                \n    vec2 pos_i = Polar2Cartesian(angle_i, lenght_i);\n    vec2 vel_i = Polar2Cartesian(angle_i+0.5, 1.0)*momentum_i;\n    \n    float angle_o = state.z;\n    float momentum_o = state.w;\n    vec2 pos_o = Polar2Cartesian(angle_o, length_o);\n    pos_o = pos_i + pos_o; // because the polar coordinates were centered.\n    vec2 vel_o = Polar2Cartesian(angle_o+0.5, 1.0)*momentum_o;\n    vel_o = vel_i + vel_o;\n    \n    int i;\n    float dt = (iTimeDelta/float(SUBSTEPS));\n    for (i=0; i<SUBSTEPS; i++){\n        // sanity check here\n        //simulate_single(pos_i, vel_i, dt);\n        //simulate_single(pos_o, vel_o, dt);\n        simulate_double(dt, pos_i, vel_i, pos_o, vel_o);\n    }\n    \n    // reproject to polar coordinates:\n    vec2 next_i;\n    next_i.x = Cartesian2Polar(pos_i).x;\n    vec2 orth_i = Polar2Cartesian(next_i.x+0.5, 1.0);\n    next_i.y = length(vel_i)*sign(dot(vel_i,orth_i));\n    next_i.y = dot(vel_i, orth_i);\n    \n    vec2 next_o;\n    vec2 pos_o_rel = pos_o - pos_i; // we only store the relative position and motion of the outer pendulum\n    next_o.x = Cartesian2Polar(pos_o_rel).x;\n    vec2 orth_o = Polar2Cartesian(next_o.x+0.5, 1.0);\n    vec2 vel_o_rel = vel_o - vel_i;\n    next_o.y = length(vel_o_rel)*sign(dot(vel_o_rel,orth_o));\n    next_o.y = dot(vel_o_rel, orth_o);\n    \n    // fix the one element for testing\n    //next_i = vec2(0.0, 0.0);\n    //next_o = vec2(0.0, 0.0);\n    vec4 new_state = vec4(next_i, next_o);\n    return new_state;\n}\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    // Normalized pixel coordinates (from -1..1)\n    vec2 uv = fragCoord/iResolution.xy;\n    uv *= 2.0;\n    uv -= 1.0;\n    \n    ivec2 st = ivec2(fragCoord);\n    vec4 prev = texelFetch(iChannel0, st, 0);\n    if (iFrame < 2) { // maybe a fix for resizing here too?\n        prev = init(uv);        \n    }\n    //vec4 next = single(prev.x, prev.y).xyxy;\n    vec4 next = double_pendulum(prev);\n    //next.zw = vec2(0.0,0.0);\n    //next = simulate(prev.xy, prev.zw, iTimeDelta);\n    \n       \n    vec4 col = vec4(next);\n    \n    fragColor = vec4(col);\n}",
          "name": "Buffer A",
          "description": "",
          "type": "buffer"
        },
        {
          "inputs": [
            {
              "id": 257,
              "src": "/media/previz/buffer00.png",
              "ctype": "buffer",
              "channel": 0,
              "sampler": {
                "filter": "linear",
                "wrap": "repeat",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            },
            {
              "id": 258,
              "src": "/media/previz/buffer01.png",
              "ctype": "buffer",
              "channel": 1,
              "sampler": {
                "filter": "nearest",
                "wrap": "repeat",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            }
          ],
          "outputs": [
            {
              "id": 258,
              "channel": 0
            }
          ],
          "code": "// this buffer basically just shows a fake 3D datacube\n// by shifting the previous frame over and then reading the next state!\n\n// TODO: maybe do this in pixels instead?\n#define SHIFT vec2(0.005, 0.002)\n\nvec4 init(vec2 uv){\n\n    return vec4(0.0);\n}\n\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord ){\n    // Normalized pixel coordinates (from 0 to 1)\n    vec2 uv = fragCoord/iResolution.xy;\n    \n    vec2 new_st = (uv*2.0) -1.0;\n    float new_mask = float(new_st.x > 0.0 || new_st.y > 0.0);\n    \n    vec2 prev_st = uv - SHIFT;        \n    vec4 prev = texture(iChannel1, prev_st);    \n        \n    if (prev_st.x < 0.0 || prev.st.y < 0.0) {\n        prev = vec4(0.0); // avoid the wrapping to the left\n    }\n    if (prev_st.x < 0.5 && prev_st.y < 0.5){\n        // sorta a fake shadow?\n        prev *= clamp(length(max(abs(uv.x-0.25), abs(uv.y-0.25)))+0.5, 0.0, 1.0);\n    }\n    prev *= 0.99; // darker everything too\n    vec4 next = texture(iChannel0, new_st);\n    // TODO abs or shift or something to get all values in the visible range!\n    // for display we want to see it\n    // next = abs(next); // too much symmetry\n    // next += 0.5; // no black?\n    next = clamp(next, vec4(0.0), vec4(1.0)); // maybe scale instead with some exp function or similar\n    \n    // TODO: make black transparent here?\n    vec4 col = mix(next, prev, new_mask);\n\n    \n    // Output to screen\n    fragColor = vec4(col);\n}",
          "name": "Buffer B",
          "description": "",
          "type": "buffer"
        },
        {
          "inputs": [],
          "outputs": [],
          "code": "// functions I need for the simulation and the vizualization - they get to be shared here!\n\n# define PI 3.141592\n\n\n// zero seems to be up and 1 is donw -.-\nvec2 Polar2Cartesian(float rot, float dist){\n    rot -= 0.5; // is this even correct anymore?\n    rot *= PI;    \n    vec2 res = vec2(cos(rot)*dist, sin(rot)*dist);    \n    return res;\n}\n\nvec2 Cartesian2Polar(vec2 pos){\n    float rot, dist;\n    dist = length(pos);\n    rot = atan(pos.y, pos.x);\n    rot /= PI;\n    rot += 0.5;\n    return vec2(rot, dist);\n}\n",
          "name": "Common",
          "description": "",
          "type": "common"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "wXKSR1",
        "date": "1754246850",
        "viewed": 62,
        "name": "texture bitplanes",
        "username": "jakel101",
        "description": "https://en.wikipedia.org/wiki/Bit_plane somehow came up on Discord... here we show the reconstructed uin8 bitplanes but split into RGBA channels.\n\nbot left is Red, bot right is Green, top left is Blue and top right is Alpha!",
        "likes": 1,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "bitplane"
        ],
        "hasliked": 0,
        "retrieved": "2025-08-27T15:48:44.247118+00:00"
      },
      "renderpass": [
        {
          "inputs": [
            {
              "id": 5,
              "src": "/media/a/8de3a3924cb95bd0e95a443fff0326c869f9d4979cd1d5b6e94e2a01f5be53e9.jpg",
              "ctype": "texture",
              "channel": 0,
              "sampler": {
                "filter": "mipmap",
                "wrap": "repeat",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            }
          ],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "void mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    // Normalized pixel coordinates (from 0 to 2)\n    vec2 uv = fragCoord/iResolution.xy;\n    uv*= 2.0;\n    int channel = int(uv.x)*2 + int(uv.y);\n    uv = fract(uv);    \n    vec4 tex = texture(iChannel0, uv);\n    // wrange the texture back int uint8 representation\n    int val = int(tex[channel]*255.0);\n    \n    int bit = (iFrame/30)%8; // lower this 30 to make your eyes hurt!\n    val = (val >> bit) & 1;\n    \n    // as val is either 0 or 1 we don't need to scale up again to 255\n    vec4 col = vec4(val);\n    fragColor = vec4(col);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "t3tXz8",
        "date": "1753142287",
        "viewed": 169,
        "name": "Dirt Terrain of Pillars",
        "username": "jakel101",
        "description": "this is meant to be a submission for https://itch.io/jam/acerola-dirt-jam\nnot VOXELS, height is not quantized!\ntracked changes on [url=https://github.com/Vipitis/shader_tracker/tree/main/jakel101/t3tXz8_Dirt_Terrain_of_Pillars]GitHub[/url]",
        "likes": 13,
        "published": 3,
        "flags": 48,
        "usePreview": 0,
        "tags": [
          "terrain",
          "pathtracing",
          "dirtjam"
        ],
        "hasliked": 0,
        "retrieved": "2025-08-13T20:37:17.529453+00:00"
      },
      "renderpass": [
        {
          "inputs": [
            {
              "id": 257,
              "src": "/media/previz/buffer00.png",
              "ctype": "buffer",
              "channel": 0,
              "sampler": {
                "filter": "linear",
                "wrap": "clamp",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            }
          ],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "// Apache 2.0 no patents /^\u00a7^\\\n\n// Image pass implemented as my heightmap pathtracing project: https://www.shadertoy.com/view/M3VBWt\n// with a couple tweaks to make it work for this example :)\n\n// SOME BUGS: (or todos)\n// clouds have a strong moire pattern because traversal abbrpuptly begins at the top plane\n// some water seems to get green side texture?\n\n# define PI 3.141592653\n// tweaked with 0.5 in mind others could look wonky...\n# define HEIGHT_SCALE 0.55\n\n// this is square but still depends on the canvas resolution!\n# define CELLS ivec2(min(512.0,min(iChannelResolution[0].x, iChannelResolution[0].y)))\n\n// unsure yet where to bring this!\n# define SUN normalize(vec3(sin(iDate.w*0.05), cos(iTime*0.2), HEIGHT_SCALE*1.1))\n// normalize(vec3(3.0, -5.0, 2.0))\n\n// playing with this, using my imgui parser - https://github.com/pygfx/shadertoy/pull/46\n# define CLOUD_DENSITY 20.0\n\n\n// horizontal FOV, if you use negative values the camera will be orthographic!\n// examples:\n// FOV -1.0 for orthographic (sensor size)\n// FOV 90.0 for perspective wide\n// FOV 45.0 for perspective narower\n# define FOV 90.0\n\nivec2 worldToCell(vec3 p) {\n    \n    // move world space again\n    p += 1.0;\n    p *= 0.5;\n    ivec2 st = ivec2((p.xy*vec2(CELLS.xy)));\n    // TODO: find an actual solution to the edge cases!\n    st = min(st, CELLS -1);\n    return st;\n}\nstruct Ray{\n    vec3 origin;\n    vec3 dir;\n    vec3 inv_dir; // for speedup?\n};\n\nstruct BoxHit{    \n    bool hit;\n    // rest illdefined for a miss\n    bool inside;\n    vec3 entry;\n    vec3 exit;\n    vec3 entry_norm;\n    vec3 exit_norm;\n    float entry_dist;\n    float exit_dist;\n};\n\n// sorta reference: https://tavianator.com/2022/ray_box_boundary.html\n// TODO should be a HitInfo as the same will work for other intersections down the line.\nBoxHit AABB(vec3 center, vec3 size, Ray ray){\n    BoxHit res;\n        \n    vec3 pos = center + size;\n    vec3 neg = center - size;\n    \n    vec3 pos_dist = (pos-ray.origin) * ray.inv_dir;\n    vec3 neg_dist = (neg-ray.origin) * ray.inv_dir;\n    \n    vec3 min_dist = min(pos_dist, neg_dist);\n    vec3 max_dist = max(pos_dist, neg_dist);\n    \n    res.entry_dist = max(max(min_dist.x, min_dist.y), min_dist.z);\n    res.exit_dist = min(min(max_dist.x, max_dist.y), max_dist.z);\n    \n    // essentially methods?\n    res.hit = res.entry_dist < res.exit_dist && res.exit_dist > 0.0;\n    res.inside = res.entry_dist < 0.0; // entry behind us\n    \n    res.entry = ray.origin + ray.dir*res.entry_dist;\n    res.exit = ray.origin + ray.dir*res.exit_dist;\n    \n    // normals point away from the center\n    res.entry_norm = -sign(ray.dir) * vec3(greaterThanEqual(min_dist, vec3(res.entry_dist)));\n    res.exit_norm = sign(ray.dir) * vec3(lessThanEqual(max_dist, vec3(res.exit_dist)));\n    \n    return res;\n}\n\n\nBoxHit pillar_hits(ivec2 cell, float height, Ray ray){    \n    // let's move the pillar into world space by having it's center + extends\n    \n    vec3 extend = vec3(1.0/vec2(CELLS), abs(height)*0.5);\n    vec3 p = vec3(cell.xy, abs(height)*0.5);    \n    p.xy *= extend.xy; \n    p.xy *= 2.0;\n    p.xy -= 1.0 - extend.xy; // not quite the offset?\n    //extend.z = extend.y; // make them cubes?\n    \n    // for the case of clouds the box is at the top?\n    if (height < 0.0){\n        p.z = HEIGHT_SCALE*(1.0-abs(height*0.5));\n    }    \n    \n    // TODO: redo this math when less asleep...\n    BoxHit res = AABB(p, extend, ray);\n    return res;\n}\n\n\nfloat transmittance(float dist){\n    // ref video https://youtu.be/Qj_tK_mdRcA\n    \n    // bad approximation of \"beers law\"? (macro for absorption)\n    float trans = exp(-dist*CLOUD_DENSITY);\n    \n    trans = clamp(trans, 0.0, 1.0);\n    // this is meant as a transmittance: 1.0 means we see through the cloud and 0.0 means we don't.\n    return trans;\n}\n\n\n\nvec3 terrain_palette(float h){\n    // return a specific color based on height. \n    // I manaually draw the RGB curves in a curve editor tool I have for thermal imaging\n    // then crafted functions in graphtoy to minic their paths and put it here\n    \n    // offsets\n    float h_r = h - 0.52;\n    float h_g = h - 0.4;\n    float h_b = h - 0.15;\n    // cubic polynomials\n    float r = (6.0*pow(h_r,3.0) + 0.1*pow(h_r,2.0) + 0.0*h_r +0.3);\n    float g = (6.0*pow(h_g,3.0) + 0.1*pow(h_g,2.0) + -1.0*h_g +0.3);\n    float b = (4.0*pow(h_b,3.0) + 0.1*pow(h_b,2.0) + -2.0*h_b +0.3);\n    \n    //vec3(0.267, 0.133, 0.001); // ~#442200\n    vec3 col = vec3(r,g,b);\n    col = clamp(col, vec3(0.0), vec3(1.0)); // ensure no negative or overbright colors!\n    return col;\n}\n\nvec4 sampleHeight(ivec2 cell){\n    // to allow for more complex math to determine height\n    // .rgb should just return the texture color or some modification of it\n    //cell.x = (cell.x + iFrame) % int(iChannelResolution[0].x); // fun texture scroll\n    vec4 tex = texelFetch(iChannel0, cell, 0);\n    vec4 res;\n    res.a = tex.r; // our height data is in this channel\n    res.rgb = terrain_palette(res.a*1.5-0.2); // move it a round a bit so the pallete looks okay...\n    \n    // could also just be a constant here!\n    if (tex.b > 0.0){\n        // cheap solid water in amount of water per pillar...\n        // TODO semi transparen/reflective water?\n        // the simulation is in the Buffer pass, we just reconstruct the height for rendering here\n        res.a += tex.b;\n        res.rgb = mix(vec3(0.2, 0.5, 0.8), vec3(0.1, 0.1, 0.9), tex.b*20.0); // little color for water \"depth\"\n    }\n    res.a *= HEIGHT_SCALE;\n    return res;\n}\n// this could be joined into the function above.\nfloat sampleClouds(ivec2 cell){\n    // idea is to read the texture data in a specific channel for cloud height/density?\n    // this needs to be implemented in my function down below as an alternative hit.\n    vec4 tex = texelFetch(iChannel0, cell, 0);        \n    float res = tex.g; // this channel has \"cloud\" terrain\n    // maybe we clamp it or something to have no clouds?\n    res -= 0.55; // negative values become clouds that show up.\n    return res;    \n}\n\nvec4 raycast(Ray ray, inout vec2 clouds){\n    // cast the ray untill there is a hit or we exit the box\n    // \"any hit\" shader?\n    // returns tex + dist, negative dist means a \"miss\"\n    // the inout for clouds sums up it's distance and depth of clouds.\n    BoxHit box = AABB(vec3(0.0, 0.0, HEIGHT_SCALE*0.5), vec3(1.0, 1.0, HEIGHT_SCALE*0.5), ray);\n    clouds = vec2(0.0, 0.0);\n    \n    vec3 entry = box.entry;\n    \n    if (!box.hit){\n        // if we \"MISS\" the whole box (not inside?).\n        \n        return vec4(vec3(0.2, 0.8, 0.0), -abs(box.exit_dist));\n    }\n    // everything below here is inside the box\n    if (box.inside){       \n        // if we are \"inside\" the entry should just be ro!\n        entry = ray.origin; // maybe problems with distance caluclations at the end?\n    }\n    \n    //return vec4(vec3(0.6), 1.0);\n    \n    //return entry.rgbb;\n    \n    ivec2 current_cell = worldToCell(entry); // TODO: this one is problematic!\n    int i;\n    ivec2 max_cells = CELLS - min(current_cell, CELLS-current_cell);\n    int max_depth = (max_cells.x + max_cells.y)+2; // could also be min!\n    for (i = 0; i < max_depth; i++){        \n        if (current_cell.x < 0 || current_cell.x >= CELLS.x ||\n            current_cell.y < 0 || current_cell.y >= CELLS.y){\n            // we marched far enough are are \"outside the box\" now!\n            return vec4(vec3(0.4), -abs(box.exit_dist));\n        }        \n        // so let's look for clouds first!\n        float cloud_depth = sampleClouds(current_cell);        \n        if (cloud_depth < 0.){ // cand adjust how \"many\" clouds here!\n            // only if there is a cloud we even consider this\n            BoxHit cloud = pillar_hits(current_cell, (cloud_depth*0.2), ray);\n            if (cloud.hit){                \n                // for transmittance we accumulate the distance\n                clouds.x += (distance(cloud.entry,cloud.exit)); // +(cloud_depth*0.001)); // add some random variation?\n                \n                // the \"color\" of clouds is based on the depth, scaled by the already accumulated transmittance\n                // sorta the distance to the sun, exit because entry can be at the top\n                // and how much of an angle the sun was at...\n                // the idea is to sum up how much \"light\" this has accumulated.\n                float hit_depth = (HEIGHT_SCALE-cloud.exit.z);\n                float sun_angle = clamp(dot(SUN, vec3(0.0,0.0,1.0)), 0.0, 1.0);\n                clouds.y += abs(cloud_depth*transmittance(clouds.x)*sun_angle*transmittance(hit_depth));\n                \n                // TODO use cloud.inside to increase the scale? (try to remove the moire pattern)\n                //return vec4(vec3((1.0 - cloud_depth)), 0.0*abs(cloud_hit.x));\n            }\n        }\n        \n        vec4 tex = sampleHeight(current_cell);\n        BoxHit pillar = pillar_hits(current_cell, tex.a, ray);\n        \n        if (pillar.hit) {\n            // \"any hit\" (side/top/bot) -> loop ends here            \n            // do a little bit of light sim by doing diffuse \"block of chalk\"\n            vec3 col = tex.rgb;\n            // half the phong diffuse\n            // TODO: assume some base \"emissive\" quality to all pillars (or scaled with some value?)\n            // needs better hit model and shader to accumulate over a few traces.\n            // TODO: should one of them be negative?\n            col *= (2.0*dot(pillar.entry_norm, SUN)) + 0.2; // \"ambient\"/emission term\n            \n            return vec4(col, abs(pillar.entry_dist));\n        }\n        \n        \n        if (pillar.exit_dist >= box.exit_dist){\n            return vec4(vec3(0.8), -abs(pillar.exit_dist));\n        }\n        \n        // the step\n        ivec2 next_cell = current_cell + ivec2(pillar.exit_norm.xy);\n        if (next_cell == current_cell){\n            // in this case we do another raycast - but without any Z component\n            // so the vector is sideways and points to a new cell!\n            vec3 flat_rd = vec3(ray.dir.xy, 0.0);\n            Ray flat_ray = Ray(ray.origin, flat_rd, 1.0/flat_rd);\n            \n            BoxHit grid = pillar_hits(current_cell, 1.0, flat_ray);\n            next_cell += ivec2(grid.exit_norm.xy); // TODO check if this norm is correct!\n        }\n        // for next iteration\n        current_cell = next_cell;\n    }\n    //return vec4(vec2(current_cell)/vec2(CELLS), 0.0, 0.0);\n    // defualt \"miss\"? -> like we exit the box?\n    \n    return vec4(vec3(1,0,0), -abs(box.exit_dist));\n\n}\n\n// more like a bad shadowmap\n// idea for the future: precompute the horizon per pixel: https://youtu.be/LluCbGdi-RM\nfloat shadow(Ray sun_ray){\n    // return the amount of shadowed?\n    // we are now marching upwards from some hit\n    // ro is essentially the point we started from\n    // rd is the sun angle\n    vec2 cloud_values;\n    vec4 res = raycast(sun_ray, cloud_values);\n    //return res.a;\n    if (res.a < 0.0){// || (ro + rd*res.a).z >= HEIGHT_SCALE){\n        // likely means outside the box/ground!\n        // so think like \"skylight\"        \n        float cloud_transmittance = transmittance(cloud_values.x);\n        // full sunlight        \n        return cloud_transmittance;\n    }    \n    else {\n        return 0.0;\n    }\n}\n\nfloat checkerboard(vec2 check_uv, float cells){\n    check_uv *= cells/2.0;\n    float rows = float(mod(check_uv.y, 1.0) <= 0.5);\n    float cols = float(mod(check_uv.x, 1.0) <= 0.5);\n    return float(rows == cols);\n}\n\n\nvec4 sampleGround(vec3 ro, vec3 rd){\n    // for any ray that misses the heightmap\n    // TODO: rename to sample skybox maybe? as the ground is sorta part of that...\n    float ground_height = 0.0;\n    float ground_dist = (ground_height-ro.z)/rd.z;\n    if (ground_dist < 0.0) {\n        // essentially sky hit instead?\n        // just some random skybox right now... could be improved of course!\n        vec3 col = vec3(0.23, 0.59, 0.92)*exp(dot(SUN, rd)-0.8);\n        col = clamp(col, vec3(0.0), vec3(1.0));\n        return vec4(col, 30.0); // some random distance that is positive!\n    }\n    \n    vec3 ground_hit = ro + (rd * ground_dist);\n        \n    float val = checkerboard(ground_hit.xy, 8.0)* 0.1;\n    val += 0.45;\n    //val *= 2.0 - length(abs(ground_hit));\n    \n    // fake sun angle spotlight... TODO actual angle and normal calculation!\n    val *= 2.5 - min(2.3, length((-SUN-ground_hit)));//,vec3(0.0,0.0,1.0));\n    \n    vec3 col = vec3(val);\n    return vec4(col, ground_dist);\n}\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    // uv normalized to [-1..1] for height with more width\n    vec2 uv = (2.0*fragCoord - iResolution.xy)/iResolution.y;\n    vec2 mo = (2.0*iMouse.xy - iResolution.xy)/iResolution.y;\n    \n    //fragColor = texture(iChannel0, uv);\n    //return;\n    \n    // for when it's just idling...   \n    float azimuth = -1.9+iTime*0.1 + mo.x; // keeps a bit of residue of the mouse!\n    float altitude = 0.7+cos(1.5+iTime*0.25)*0.35;      \n    if (sign(iMouse.z) > 0.0){\n        // orbiting camera setup\n        azimuth = PI*mo.x;\n        altitude = 0.5*PI*clamp(mo.y+1.0, -0.01, 0.99); // maybe just positive?\n    }\n    \n    // make sure you don't look \"below\"\n    altitude = clamp(altitude, HEIGHT_SCALE*0.2, PI);\n    \n    // a unit length orbit!\n    vec3 camera_pos = vec3(\n        cos(azimuth)*cos(altitude),\n        sin(azimuth)*cos(altitude),\n        sin(altitude));               \n    // the camera is always looking \"at\" the origin or half way above it\n    vec3 look_dir = normalize(vec3(0.0, 0.0, HEIGHT_SCALE*0.5) - camera_pos);\n    \n    \n    // TODO moving the camera in and out over time??\n    camera_pos += look_dir * -0.1; // moving the camera \"back\" to avoid occlusions?\n    // two vectors orthogonal to this camera direction (tagents?)    \n    //vec3 look_u = camera_pos + vec3(-sin(azimuth), cos(azimuth), 0.0);\n    //vec3 look_v = camera_pos + vec3(sin(altitude)*-cos(azimuth), sin(altitude)*-sin(azimuth), cos(altitude));    \n\n    \n    // turns out analytically these aren't correct. so using cross instead -.-\n    vec3 look_u = normalize(cross(vec3(0.0, 0.0, -1.0), look_dir));\n    vec3 look_v = normalize(cross(camera_pos, look_u)); // is this faster?\n    // camera plane(origin of each pixel) -> barycentric?\n    \n    vec3 camera_plane;\n    vec3 ray_dir;\n    vec3 ray_origin;\n                        \n    if (FOV > 0.0){\n        // assume a pinhole camera.\n        // FOV is the horizontal fov, the given focal length becomes:\n        // the 1.0 is the sensor height.\n        float focal_length = 1.0/tan(radians(FOV*0.5));\n        \n        // the ro\n        camera_plane = camera_pos - (look_dir*focal_length) + ((look_u*uv.x) + (look_v*uv.y))*-1.0; // inverted here to see upright\n        ray_origin = camera_pos;\n        \n        // the rd\n        ray_dir = camera_pos-camera_plane;\n        ray_dir = normalize(ray_dir);        \n    }\n    \n    else {\n        // negative FOV values are interpreted as a sensor size for a orthographic camera!\n        // horizontal sensor size, -1 would be something sensible... everything else is far away\n        float sensor_size = FOV*0.5*-1.0;\n        camera_plane = camera_pos + ((look_u*uv.x)+(look_v*uv.y))*sensor_size; // wider fov = larger \"sensor\"\n        ray_dir = look_dir;\n        ray_origin = camera_plane;\n    }\n    \n    Ray camera = Ray(ray_origin, ray_dir, 1.0/ray_dir);\n    \n    // actual stuff happening:\n    vec2 cloud_val;\n    vec4 res = raycast(camera, cloud_val);\n    // fragColor = vec4(vec3(res.rgb),1.0);\n    //return; // early debug exit\n    if (res.a < 0.0) {\n        // we missed the initial terrain\n        res = sampleGround(ray_origin, ray_dir);\n        \n        // TODO: the skybox hit returns a negative distance, so we need to handle that\n        //res.a = abs(res.a);\n    }\n    vec3 hit = ray_origin + (ray_dir*res.a);\n\n    // TODO: offset the ro a bit?\n    Ray sun_check = Ray(hit+0.001*SUN, SUN, 1.0/SUN);\n    \n    vec2 cloud_foo; // unused?\n    vec4 ref = raycast(sun_check, cloud_foo).rgba; //reflection (the full shadow)    \n    ref.rgb *= 1.0 - step(0.0, ref.a); // this makes misses black?\n    // ref.rgb *= 1.0-exp(-shadow_cloud*15.0); // more \"realistic\" cloud shadow?\n    \n    float shadow_amt = shadow(sun_check);\n    // actually more light amount -.-\n    // so we add and \"ambient\" base like here\n    vec3 col = res.rgb * max(0.3, shadow_amt);\n\n\n    // distance fog? I don't like it so it's commented out\n    // float dist_fog = transmittance(res.a *0.015);\n    // vec3 fog_col = vec3(0.4, 0.5, 0.9);\n    // col = mix(col, fog_col, 1.0-dist_fog);\n    \n\n    float cloud_trans = transmittance(cloud_val.x);\n    vec3 cloud_col = vec3(1.0 - cloud_val.y*0.35); // *(1.0-cloud_trans); // no more alphapremultiplication...\n    col = mix(col, cloud_col, 1.0-cloud_trans);\n    \n    // TODO: better \"shadow\" value via actually colored shadow??\n    // vec3 col2 = res.rgb + ref.rgb*0.3;    \n    // col = vec3(uv.x > 0.0 ? col.rgb : col2.rgb);\n    \n    fragColor = vec4(vec3(col),1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        },
        {
          "inputs": [
            {
              "id": 33,
              "src": "/presets/tex00.jpg",
              "ctype": "keyboard",
              "channel": 1,
              "sampler": {
                "filter": "linear",
                "wrap": "clamp",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            },
            {
              "id": 257,
              "src": "/media/previz/buffer00.png",
              "ctype": "buffer",
              "channel": 0,
              "sampler": {
                "filter": "linear",
                "wrap": "repeat",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            }
          ],
          "outputs": [
            {
              "id": 257,
              "channel": 0
            }
          ],
          "code": "// for the terrain map I combined a bunch of existing and tutorial level snippets\n\n// water simulation controls:\n// SPACE - toggle all simulaion on/off :: default:on\n// E - Erosion simulation toggle on/off :: default:off\n// R - Rain for low clouds toggle on/off :: defualt:on\n\n\n# define OCTAVES 8\n\n// from https://www.shadertoy.com/view/XlGcRh\nuvec2 pcg2d(uvec2 v)\n{\n    v = v * 1664525u + 1013904223u;\n\n    v.x += v.y * 1664525u;\n    v.y += v.x * 1664525u;\n\n    v = v ^ (v>>16u);\n\n    v.x += v.y * 1664525u;\n    v.y += v.x * 1664525u;\n\n    v = v ^ (v>>16u);\n\n    return v;\n}\n\n// wraps the bitconversion and just accessses half the values\nfloat hash21(in vec2 a){\n    uvec2 b = uvec2(floatBitsToUint(a.x), floatBitsToUint(a.y));\n    uvec2 c = pcg2d(b);\n    float r = float(c.x)/float(uint(-1)); // seems to work I guess... but don't we lose a lot of data??\n    // fract(uintBitsToFloat(c.x)) // this one causes issues due to NaN or something, results in black spots in the noise\n    return r;\n}\n\n// TODO to make the clouds more accurate, this should actually be a slice of 3D noise we rotate through\nfloat noise(in vec2 a){\n   // perlin 2D noise\n   vec2 i = floor(a);\n   vec2 f = fract(a);\n   \n   // four corners\n   float bl = hash21(i + vec2(0.0, 0.0));\n   float br = hash21(i + vec2(1.0, 0.0));\n   float tl = hash21(i + vec2(0.0, 1.0));\n   float tr = hash21(i + vec2(1.0, 1.0));\n   \n   vec2 s = smoothstep(0.0, 1.0, f);\n   \n   \n   return mix( mix(bl, br, s.x),\n               mix(tl, tr, s.x), s.y);\n}\n\n\nfloat noise3d(in vec3 a){\n    float i = floor(a.z);\n    float n1 = noise(a.xy+vec2(i));\n    float n2 = noise(a.xy+vec2(i+1.0));\n    \n    float s = smoothstep(0.0, 1.0, fract(a.z));\n    return mix(n1, n2, s);\n}\n\n// via https://thebookofshaders.com/13/\nfloat fbm(in vec2 p){\n    \n    // parameters\n    int octaves = OCTAVES;\n    float l = 2.0;\n    float g = 0.5;\n    \n    // initial values\n    float a = 0.5;\n    float f = 1.0;\n    float res = 0.0;\n    for(int i = 0; i < octaves; i++){\n        res += a * noise(p*f);\n        f *= l;\n        a *= g;\n        \n    }\n    return res;\n}\n\nfloat fbm3(in vec3 p){\n    // parameters\n    int octaves = OCTAVES;\n    float l = 2.0;\n    float g = 0.5;\n    \n    // initial values\n    float a = 0.5;\n    float f = 1.0;\n    float res = 0.0;\n    for(int i = 0; i < octaves; i++){\n        res += a * noise3d(p*f);\n        f *= l;\n        a *= g;\n        \n    }\n    return res;\n}\n\n\nvec4 init_terrain(vec2 uv, float time_seed){\n    // initialize the terrain?\n\n    vec4 start;\n    // we don't do anything interesting here :(\n    float height = fbm(uv*3.0+vec2(time_seed*0.2));\n    \n    // let's have some fun!\n    float clouds = fbm(uv*4.0+vec2(-time_seed*0.1));\n    \n    // water as an amount, not a height.\n    float water = max(0.0, 0.2-height);\n\n    // alpha channel currently not used...\n    start = vec4(vec3(height, clouds, water),1.0);\n    return start;\n}\n\n// idea... look at the the neighbords and then check if water exists in the highest point.\n// step the water down (by full amount) or based on the gradient?\nvec2 simulate_water(ivec2 pos){\n    // do we get the clouds to know where it rains?\n    vec4 old = texelFetch(iChannel0, pos, 0); // these could be passed in?                \n    float old_water = old.z;\n    float old_height = old.x;\n    float old_cloud = old.y; // can we evaporate to collect and rain to lose cloud?\n    float old_wind = old.w; // like radians or amplitude?\n    \n    // maybe only evaporate if there isn't clouds?\n    float evaporation = iTimeDelta*(max(0.0,(3.5*old_height)-0.3));\n    old_water *= (1.0-evaporation); // or last?\n    \n    float water_level = old_height + old_water;    \n    float water_change = 0.0; // the amount \"added\" or removed\n    float height_change = 0.0; //erosion and deposition!\n       \n    \n    \n    // rain, toggle with R\n    float rain_toggle = 1.0 - texelFetch(iChannel1, ivec2(82, 2), 0).x;   \n    if (old_cloud < 0.25) {\n        // could be based on cloud thickness, maybe even drain the clouds?\n        float rain_amount = abs(min(0.0, (old_cloud - 0.25)));\n        water_change += iTimeDelta*rain_amount*rain_toggle;\n    }   \n    \n    // just 4 neighbors is hopefully fine, all 8 would require some sqrt(2) scaling?\n    ivec2 neighbors[4] = ivec2[4] (ivec2(1,0), ivec2(-1,0), ivec2(0,1), ivec2(0,-1));\n    //ivec2 neighbors[8] = ivec2[8] (ivec2(1,0), ivec2(1,1), ivec2(0,1), ivec2(-1,1), ivec2(-1,0), ivec2(-1,-1), ivec2(0,-1), ivec2(1,-1));\n    int i;\n    for (i=0; i<neighbors.length(); i++){        \n        vec4 n = texelFetch(iChannel0, pos+neighbors[i], 0);\n        //float slope = n.x - old_height;\n        float n_level = n.x + n.z; // terrain height + water height\n        float water_diff = n_level - water_level;\n        water_change += clamp(water_diff, -old_water, n.z);\n        //height_change += -water_diff*slope; // this is not it -.-\n    }\n    \n    water_change /= float(neighbors.length()); // does this need to be normalized?\n    height_change /= float(neighbors.length());\n    \n    \n    // motivated by the ideas here: https://www.youtube.com/watch?v=eaXk97ujbPQ\n    // erosion demo: toggle with E\n    float erosion_toggle = texelFetch(iChannel1, ivec2(69, 2), 0).x;   \n    height_change += -(old_water*water_change);\n    height_change *= erosion_toggle;\n    \n    return vec2(old_height + height_change, old_water + water_change);\n}\n\n\n\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    \n    vec2 uv = (fragCoord * 2.0 - iResolution.xy)/iResolution.y;\n    ivec2 st = ivec2(fragCoord);\n    \n    if (fragCoord.x > iResolution.y || fragCoord.x > 512.5 || fragCoord.y > 512.5){\n        // will break on protrait aspect ratio -.-\n        discard; // throw away the threads that are outside the simulation area\n    }\n        \n    //TODO terrain can still move if we offset the sample coords!\n    vec4 prev = texelFetch(iChannel0, st, 0);\n    if (iFrame < 1 || prev.x <= 0.0){ // hack for resizing? -> still messes up uv scaling...\n        prev = init_terrain(uv, 0.0); // TODO: change the value here to something like iDime.w to et different starting terrains.\n    }\n    else {\n        // let's have some fun!\n        float clouds = fbm3(vec3(uv*5.0+vec2(-iTime*0.2),iTime*0.1)); //\n                \n        prev.y = clouds;\n        // press spacebar to toggle water sim (rain, gravity and evaporation) on/off... stars on on.\n        if (texelFetch(iChannel1, ivec2(32, 2), 0).x<0.5){\n            prev.xz = simulate_water(st);\n        }\n    }\n    prev = clamp(prev, vec4(0.0), vec4(1.0)); // maybe that fixes the big black box showing up sometimes?\n    \n    \n    \n    // clouds = uv.y; //ramp for testing\n    // the blue channel might be water... (and we could animate/simulate it here!)\n    //fragColor = vec4(vec3(height, clouds, water),1.0);\n    \n    fragColor = prev;\n}",
          "name": "Buffer A",
          "description": "",
          "type": "buffer"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "tXK3Rd",
        "date": "1752868197",
        "viewed": 127,
        "name": "interactive broken LCD",
        "username": "jakel101",
        "description": "the lowest effort idea on my massive list of shader ideas. Use the mouse start and end positions to break it in another way.\nYou can also put this in the image pass for other existing shaders!",
        "likes": 9,
        "published": 3,
        "flags": 32,
        "usePreview": 0,
        "tags": [
          "postfx",
          "broken",
          "lcd",
          "discord"
        ],
        "hasliked": 0,
        "retrieved": "2025-08-13T20:37:17.529453+00:00"
      },
      "renderpass": [
        {
          "inputs": [
            {
              "id": 257,
              "src": "/media/previz/buffer00.png",
              "ctype": "buffer",
              "channel": 0,
              "sampler": {
                "filter": "linear",
                "wrap": "clamp",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            }
          ],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "// Apache 2.0 no patents [!__!] \n// this is meant as a effects pass (image pass)\n// where it reads some background and make it look sorta broken\n// improvements and remixes welcome!\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    // Normalized pixel coordinates (from 0 to 1)\n    vec2 uv = fragCoord/iResolution.xy;\n    vec2 mouse_start = abs(iMouse.zw)/iResolution.xy;\n    vec2 mouse_end = iMouse.xy/iResolution.xy;\n    \n    // default values for before you touch mouse first time!\n    if (iMouse.x == 0.0 && iMouse.z == 0.0){\n        mouse_start = vec2(0.2);\n        mouse_end = vec2(0.2);\n    }\n    \n    // to capture the background, we distor the uv a bit for extra fun\n    // disorted uv along the vertical axis\n    vec2 distoriton = uv;\n    \n    // this one moves but has glitchy edges\n    float fuzzy = clamp(tan(iTime*iDate.w),-0.3, 0.1);\n    float strength_mask = 1.0 -clamp(abs(uv.y*2.0 - mouse_end.y-0.3)*(fuzzy+3.0), 0.0, 1.0);\n    float offset = exp(sin(distoriton.y*30000.0*iTime))*max(-0.3, cos(iTime*0.33)*4.0);\n    distoriton.y += offset*strength_mask;\n    \n    // this goes negative or positive a few times but stays at 0 most of the time...\n    float sporadic = min(sin(mod(iTime, 3.4)), 0.0) - min(cos(mod(iTime*.3, 1.6)), 0.0)*sign(cos(iTime*3.0));\n    \n    distoriton.x += (0.5-uv.y)*sign(sporadic)*0.1;\n    vec3 good = texture(iChannel0, distoriton).rgb; // TODO: different name\n\n\n    // broken area\n    vec3 bad = vec3(1.0) - good;\n    bad = normalize(bad);\n    bad -= fract(uv.x * 73.8 + sin(iTime*0.04-uv.x*914.0035))* 10.0; // pseudo hash that looks good enough right now\n    //bad = max(vec3(0.0), bad);\n    bad.b *= 64.0;\n    bad.g *= uv.x*mouse_end.x;\n    bad.b += (tan((mouse_start.y - uv.y)*1.0));\n    \n    bad = clamp(bad, vec3(0.0), vec3(1.0));\n\n    \n    //bad = normalize(bad);\n    // todo additional distortions, streaks etc    \n    vec3 bad2 = vec3(1.0 - bad);\n    bad2 = pow(bad2, good*0.2);    \n    bad2 -= fract(uv.y * 73.8 + sin(iTime*0.04-uv.y*914.0035))* 10.0;\n    bad2 *= cross(vec3(mouse_start.xy, sign(cos(iTime*0.8))), normalize(vec3(sin(iTime*0.3),uv.yx)));\n    \n    bad2 = clamp(bad2, vec3(0.0), vec3(1.0));    \n\n\n    // simple polynomals, offset by the mouse positions. Have a root in 0.0... could be more dynamic\n    // TODO: more dynamic?\n    \n    //abs(x)*(x*0.1 -1)*0.2\n    float f1 = abs((uv.x-mouse_start.x))*((uv.x-mouse_start.x)*1.5 -1.0)*0.2+mouse_start.y;\n    f1 += fuzzy*0.03*abs(mouse_end.x);\n    //float f1 = 0.12*((uv.x-mouse_start.x)-2.0)*-(pow(((uv.x-mouse_start.x)-2.0),3.0)+9.0)-0.24+mouse_start.y;\n    float f2 = abs((uv.y-mouse_end.y))*((uv.y-mouse_end.y)*1.2 -1.0)*0.2+mouse_end.x;\n    f2 += fract(sin(40.0 +uv.y*mouse_start.y*523.3))*0.002; // cheap \"cracked edge\"\n    //float f2 = 3.0*((uv.y-mouse_end.y) * -(uv.y-mouse_end.y)) *(0.84*uv.y-mouse_end.y) + mouse_end.x;    \n    \n    float mask1 = float((f1 > uv.y));\n    float mask2 = float((f2 > uv.x));       \n    \n    vec3 col = good;\n    col = mix(col, bad, mask1);\n    col = mix(col, bad2, mask2);\n    col = mix(col, bad+bad2, mask1*mask2); // awful overlap?\n    // Output to screen\n    fragColor = vec4(vec3((col)),1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        },
        {
          "inputs": [],
          "outputs": [
            {
              "id": 257,
              "channel": 0
            }
          ],
          "code": "// forked from https://www.shadertoy.com/view/tXV3Rw\n// changes:\n// parameterized colors\n// expanded style to fit mine...\n// made smaller, changed colors,\n// added little glow animation\n\n// yes, join the Discord!! https://discord.gg/XtmMN6E\n// it's official, see the bottom left corner\n\n\n// goal is to get the apple logo kinda look, ref by \n// https://discord.com/channels/578696555612209173/579528698164805634/1395607001274515508\n\nfloat sdEllipse(vec2 p, vec2 r)\n{\n    float f = length(p / r),\n          g = length(p / r / r);\n    \n    return f * (f - 1.) / g;\n}\n\nfloat sdDiscord(vec2 p)\n{\n    p.x = abs(p.x);\n    \n    float d = length(p + vec2(0, .52)) - .91;\n          d = max(d, length(p - vec2(0, .41)) - .83);\n          d = max(d, length(p - vec2(.82, .09)) - .74);\n          d = max(d, min(.54 - length(p - vec2(0, .21)), \n                         -(.81 * p.x + p.y + .03) / length(vec2(.81, 1))));\n          d = min(d, max(length(p - vec2(0, .3)) - .59,\n                         length(p + vec2(0, .36)) - .7));\n          d = max(d, length(p + vec2(.34, .16)) - .84);\n          d = max(d, -sdEllipse(p - vec2(.165, -.038), vec2(.09, .1)));\n    \n    return d;\n}\n\nvoid mainImage(out vec4 fragColor, vec2 fragCoord)\n{\n    vec2 uv = (fragCoord - .5 * iResolution.xy) / iResolution.y;\n    \n    float d = sdDiscord(uv*2.0);\n    \n    vec3 logo_col = vec3(0.878, 0.89, 1.0);\n    vec3 back_col = vec3(0.345, 0.396, 0.949);\n    vec3 dark_col = vec3(0.07, 0.07, 0.08); //~#121214\n\n    // cheap glow\n    float glow = exp(-d*50.0);\n        \n    vec3 col = mix(logo_col, dark_col, smoothstep(-1., 1., d * iResolution.y));\n    col += glow*((sin(iTime)*0.4)+0.5);\n    \n    fragColor = vec4(col, 1.0);\n}",
          "name": "Buffer A",
          "description": "",
          "type": "buffer"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "tXc3D7",
        "date": "1751330967",
        "viewed": 717,
        "name": "checkerboard with only mix()",
        "username": "jakel101",
        "description": "what if you are only allowed to use one built in function?\n\nwhich other function has potential?",
        "likes": 2,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "justmix",
          "onlymix",
          "onefunction"
        ],
        "hasliked": 0,
        "retrieved": "2025-08-13T20:37:17.529453+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "/*#=#=#=#=#=#=#=#=#=#=#=#=#=#=\n*  The One Function Challenge\n* #=#=#=#=#=#=#=#=#=#=#=#=#=#=\n* \n* only use a single built in function\n*\n* !RULES:\n* + constructors, literals, uniforms are OKAY\n* + array subscript and swizzling are FINE\n* - functions and operators (including unary -, comparison) are NOT ALLOWED\n* ~ control flow (for, while, if, else, ...) is ALRIGHT (but can we do without?)\n* LIMITATIONS:\n* > since there will be no subsitutes for texture sampling or bitcasting,\n* > it will be Image pass only, and no input Channels (open for debate)\n*\n*\n* /\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\\n*   First Edition: only mix\n* \\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\n*\n* https://registry.khronos.org/OpenGL-Refpages/es3.0/html/mix.xhtml\n* >> mix(a,b,x) = a*(1-x) + b*x\n* We have recently been told to not use mix as an optimization:\n* https://iquilezles.org/articles/gpuconditionals/ so hear me out.\n* What if we ONLY use mix? Contributions, Submissions and Improvements welcome!\n* \n* self link: https://www.shadertoy.com/view/tXc3D7\n*/\n\n\n\n\n// the following is my attempt to do at least a checkerboard and see how far I can go.\n// If you don't want to be spoiled and have the fun of discovery yourself, don't scroll down!\n// thanks to @Coderizer for brainstorming the start, @Cottrezz and @diatribes for feedback.\n// please join the discussion below or better yet on the official Discord.\n// yes there is an official Shadertoy discord, scroll down on the website invite link is bottom left corner\n// link to where my idea started (and discussion followed):\n// https://discord.com/channels/578696555612209173/578696556069257231/1389206125584449697\n\n\n// just as a joke, we can even define mix by it's implementation\n# define MIX(a,b,x) (a*(1-x) + b*x)\n\n// arithmetic\n# define MUL(a,b) mix(0.0, a, b)\n# define NEG(a) mix(a, 0.0, 2.0)\n# define ADD(a,b) MUL(mix(a,b, 0.5), 2.0)\n# define SUB(a,b) ADD(a, NEG(b))\n// DIV still missing (without some kind of loop)\n\n// logic\n# define NOT(a) bool(mix(1.0, 0.0, float(bool(a))))\n# define OR(a,b) bool(ADD(float(bool(a)), float(bool(b))))\n# define AND(a,b) NOT(OR(NOT(a), NOT(b)))\n# define XOR(a,b) AND(OR(a,b), NOT(AND(a,b)))\n\n// conditionals\n# define EQ(a,b) bool(NOT(bool(SUB(a,b))))\n\n\n// shader specific\n# define FLOOR(a) float(int(a))\n# define FRACT(a) SUB(a,FLOOR(a))\n# define STEP(a,x) float(bool(uint(ADD(SUB(x,a),1.0))))\n// STEP also works as LEQ (less eqaul than) I think\n// NOTICE: uint(-1.0) is undefined behaviour and therefore not the greatest resource\n\n// exapand formulas to vectors where needed.\n# define MUL2(a,b) vec2(MUL(a.x, b.x), MUL(a.y, b.y))\n# define FRACT2(a) vec2(FRACT(a.x), FRACT(a.y))\n\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    // I wanted to have it be an 8x8 board but game up here\n    float cell_width = MUL(iResolution.x, 0.25);\n    float cell_height = MUL(iResolution.y, 0.25);\n    \n    float cell_x = STEP(MUL(iResolution.x, 0.5), fragCoord.x);\n    float cell_y = STEP(MUL(iResolution.y, 0.5), fragCoord.y);\n    \n    vec3 col;\n    \n    col = vec3(XOR(cell_x, cell_y));    \n    fragColor = vec4(col,1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "wcySRc",
        "date": "1750458246",
        "viewed": 104,
        "name": "3D waterfall audio",
        "username": "jakel101",
        "description": "first idea implementing: https://www.shadertoy.com/view/M3VBWt\nwill behave differently on your resolution and framerate, let me know what works and what doesn't",
        "likes": 8,
        "published": 3,
        "flags": 32,
        "usePreview": 0,
        "tags": [
          "3d",
          "audio"
        ],
        "hasliked": 0,
        "retrieved": "2025-08-13T20:37:17.529453+00:00"
      },
      "renderpass": [
        {
          "inputs": [
            {
              "id": 257,
              "src": "/media/previz/buffer00.png",
              "ctype": "buffer",
              "channel": 0,
              "sampler": {
                "filter": "linear",
                "wrap": "clamp",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            }
          ],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "// Apache 2.0 no patents \\_%_/\n\n/* Image pass presents the texture calculated in Buffer A \n* this is adapted from my heightmap shader:\n* https://www.shadertoy.com/view/M3VBWt\n* pretty much in progress but this is one of the ideas I have had!\n* feedback/improvements welcome here or on the original.\n*/\n\n\n# define PI 3.141592653\n# define HEIGHT_SCALE 0.5\n\n// resolution of the sampled area limit Y to some number smaller than iResolution.y to change the \"speed\"\n# define CELLS ivec2(iChannelResolution[0].x, min(iChannelResolution[0].y,512.0))\n\n// unsure yet where to bring this!\n# define SUN normalize(vec3(sin(iDate.w*0.5), cos(iTime), HEIGHT_SCALE*1.5))\n// normalize(vec3(3.0, -5.0, 2.0))\n\n// horizontal FOV, if you use negative values the camera will be orthographic!\n// examples:\n// FOV -1.0 for orthographic (sensor size)\n// FOV 90.0 for perspective wide\n// FOV 45.0 for perspective narower\n# define FOV 90.0\n\n\nivec2 worldToCell(vec3 p) {\n    // move world space again\n    p += 1.0;\n    p *= 0.5;\n    ivec2 st = ivec2((p.xy*vec2(CELLS.xy)));\n    // TODO: find an actual solution to the edge cases!\n    st = min(st, CELLS -1);\n    return st;\n}\n\nstruct Ray{\n    vec3 origin;\n    vec3 dir;\n    vec3 inv_dir; // for speedup?\n};\n\nstruct HitInfo{\n    bool hit;\n    // rest illdefined for a miss\n    bool inside;\n    vec3 entry;\n    vec3 exit;\n    vec3 entry_norm;\n    vec3 exit_norm;\n    float entry_dist;\n    float exit_dist;\n};\n\n// sorta reference: https://tavianator.com/2022/ray_box_boundary.html\nHitInfo AABB(vec3 center, vec3 size, Ray ray){\n    HitInfo res;\n\n    vec3 pos = center + size;\n    vec3 neg = center - size;\n\n    vec3 pos_dist = (pos-ray.origin) * ray.inv_dir;\n    vec3 neg_dist = (neg-ray.origin) * ray.inv_dir;\n\n    vec3 min_dist = min(pos_dist, neg_dist);\n    vec3 max_dist = max(pos_dist, neg_dist);\n\n    res.entry_dist = max(max(min_dist.x, min_dist.y), min_dist.z);\n    res.exit_dist = min(min(max_dist.x, max_dist.y), max_dist.z);\n\n    // normals point away from the center\n    res.entry_norm = -sign(ray.dir) * vec3(greaterThanEqual(min_dist, vec3(res.entry_dist)));\n    res.exit_norm = sign(ray.dir) * vec3(lessThanEqual(max_dist, vec3(res.exit_dist)));\n\n    // essentially methods?\n    res.entry = ray.origin + ray.dir*res.entry_dist;\n    res.exit = ray.origin + ray.dir*res.exit_dist;\n\n    res.hit = res.entry_dist < res.exit_dist && res.exit_dist > 0.0;\n    res.inside = res.entry_dist < 0.0; // entry behind us\n\n    return res;\n}\n\n\nHitInfo pillar_hits(ivec2 cell, float height, Ray ray){\n    // let's move the pillar into world space by having it's center + extends\n\n    vec3 extend = vec3(1.0/vec2(CELLS), abs(height)*0.5);\n    vec3 p = vec3(cell.xy, abs(height)*0.5);\n    p.xy *= extend.xy;\n    p.xy *= 2.0;\n    p.xy -= 1.0 - extend.xy; // not quite the offset?\n    //extend.z = extend.y; // make them cubes?\n\n    // for the case of clouds the box is at the top?\n    if (height < 0.0){\n        p.z = HEIGHT_SCALE*(1.0-abs(height*0.5));\n    }\n\n    // TODO: redo this math when less asleep...\n    HitInfo res = AABB(p, extend, ray);\n    return res;\n}\n\n\nvec4 sampleHeight(ivec2 cell){\n    // to allow for more complex math to determine height\n    // .rgb should just return the texture color or some modification of it\n    //cell.x = (cell.x + iFrame) % int(iChannelResolution[0].x); // fun texture scroll\n    vec4 tex = texelFetch(iChannel0, cell, 0);\n    vec4 res;\n    res.a = (tex.r + tex.g + tex.b)/3.0;\n    res.rgb = tex.rgb; // * res.a; // to make it more of a \"height\" map?\n    //res.rgb = vec3(0.5);\n    //res.a = tex.a; // use existing height data?\n    res.a *= HEIGHT_SCALE;\n    return res;\n}\n\n\nvec4 raycast(Ray ray){\n    // cast the ray untill there is a hit or we exit the box\n    // \"any hit\" shader?\n    // returns tex + dist, negative dist means a \"miss\"\n    // the inout for clouds sums up it's distance and depth of clouds.\n    HitInfo box = AABB(vec3(0.0, 0.0, HEIGHT_SCALE*0.5), vec3(1.0, 1.0, HEIGHT_SCALE*0.5), ray);\n\n    vec3 entry = box.entry;\n\n    if (!box.hit){\n        // if we \"MISS\" the whole box (not inside?).\n\n        return vec4(vec3(0.2, 0.8, 0.0), -abs(box.exit_dist));\n    }\n    // everything below here is inside the box\n    if (box.inside){\n        // if we are \"inside\" the entry should just be ro!\n        entry = ray.origin; // maybe problems with distance caluclations at the end?\n    }\n\n    //return vec4(vec3(0.6), 1.0);\n\n    //return entry.rgbb;\n\n    ivec2 current_cell = worldToCell(entry); // TODO: this one is problematic!\n    int i;\n    ivec2 max_cells = CELLS - min(current_cell, CELLS-current_cell);\n    int max_depth = (max_cells.x + max_cells.y)+2; // could also be min!\n    for (i = 0; i < max_depth; i++){\n        if (current_cell.x < 0 || current_cell.x >= CELLS.x ||\n            current_cell.y < 0 || current_cell.y >= CELLS.y){\n            // we marched far enough are are \"outside the box\" now!\n            return vec4(vec3(0.4), -abs(box.exit_dist));\n        }\n\n        vec4 tex = sampleHeight(current_cell);\n        HitInfo pillar = pillar_hits(current_cell, tex.a, ray);\n\n        if (pillar.hit) {\n            // \"any hit\" (side/top/bot) -> loop ends here\n            // do a little bit of light sim by doing diffuse \"block of chalk\"\n            vec3 col = tex.rgb;\n            // half the phong diffuse\n            // TODO: assume some base \"emissive\" quality to all pillars (or scaled with some value?)\n            // needs better hit model and shader to accumulate over a few traces.\n            // TODO: should one of them be negative?\n            col *= (2.0*max(0.0, dot(pillar.entry_norm, SUN)))+0.2; // where does the 2.0 factor came from?\n            return vec4(col, abs(pillar.entry_dist));\n        }\n\n        // check if our exit distance larger than the box, means we should be at the final pillar...\n        if (pillar.exit_dist >= box.exit_dist){\n            return vec4(vec3(0.8), -abs(pillar.exit_dist));\n        }\n\n        // the step\n        ivec2 next_cell = current_cell + ivec2(pillar.exit_norm.xy);\n        if (next_cell == current_cell){\n            // in this case we do another raycast - but without any Z component\n            // so the vector is sideways and points to a new cell!\n            vec3 flat_rd = vec3(ray.dir.xy, 0.0);\n            Ray flat_ray = Ray(ray.origin, flat_rd, 1.0/flat_rd);\n\n            HitInfo grid = pillar_hits(current_cell, 1.0, flat_ray);\n            next_cell += ivec2(grid.exit_norm.xy); // TODO check if this norm is correct!\n        }\n        // for next iteration\n        current_cell = next_cell;\n    }\n    //return vec4(vec2(current_cell)/vec2(CELLS), 0.0, 0.0);\n    // defualt \"miss\"? -> like we exit the box?\n\n    return vec4(vec3(1,0,0), -abs(box.exit_dist));\n\n}\n\n// more like a bad shadowmap\n// idea for the future: precompute the horizon per pixel: https://youtu.be/LluCbGdi-RM\nfloat shadow(Ray sun_ray){\n    // return the amount of shadowed?\n    // we are now marching upwards from some hit\n    // ro is essentially the point we started from\n    // rd is the sun angle\n    vec4 res = raycast(sun_ray);\n    //return res.a;\n    if (res.a < 0.0){// || (ro + rd*res.a).z >= HEIGHT_SCALE){\n        return 1.0; // miss means full sunlight!\n    }\n    else {\n        // TODO: use distance?\n        return 0.5; // additional ambient light from here?\n    }\n}\n\n// copied from https://www.shadertoy.com/view/M3jGzh\nfloat checkerboard(vec2 check_uv, float cells){\n    check_uv *= cells/2.0;\n    float rows = float(mod(check_uv.y, 1.0) <= 0.5);\n    float cols = float(mod(check_uv.x, 1.0) <= 0.5);\n    return float(rows == cols);\n}\n\nvec4 sampleGround(vec3 ro, vec3 rd){\n    // for any ray that misses the heightmap\n    // TODO: rename to sample skybox maybe? as the ground is sorta part of that...\n    float ground_height = 0.0;\n    float ground_dist = (ground_height-ro.z)/rd.z;\n    if (ground_dist < 0.0) {\n        // essentially sky hit instead?\n        // just some random skybox right now... could be improved of course!\n        vec3 col = vec3(0.23, 0.59, 0.92)*exp(dot(SUN, rd)-0.8);\n        col = clamp(col, vec3(0.0), vec3(1.0));\n        return vec4(col, 30.0); // some random distance that is positive!\n    }\n\n    vec3 ground_hit = ro + (rd * ground_dist);\n\n    float val = checkerboard(ground_hit.xy, 8.0)* 0.1;\n    val += 0.45;\n    //val *= 2.0 - length(abs(ground_hit));\n\n    // fake sun angle spotlight... TODO actual angle and normal calculation!\n    val *= 2.5 - min(2.3, length((-SUN-ground_hit)));//,vec3(0.0,0.0,1.0));\n\n    vec3 col = vec3(val);\n    return vec4(col, ground_dist);\n}\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    // uv normalized to [-1..1] for height with more width\n    vec2 uv = (2.0*fragCoord - iResolution.xy)/iResolution.y;\n    vec2 mo = (2.0*iMouse.xy - iResolution.xy)/iResolution.y;\n\n    //fragColor = texture(iChannel0, uv);\n    //return;\n\n    // for when it's just idling...\n    float azimuth = -1.9+iTime*0.1 + mo.x; // keeps a bit of residue of the mouse!\n    float altitude = 0.7+cos(1.5+iTime*0.25)*0.35;\n    if (sign(iMouse.z) > 0.0){\n        // orbiting camera setup\n        azimuth = PI*mo.x;\n        altitude = 0.5*PI*clamp(mo.y+1.0, -0.01, 0.99); // maybe just positive?\n    }\n\n    // make sure you don't look \"below\"\n    altitude = clamp(altitude, HEIGHT_SCALE*0.2, PI);\n\n    // a unit length orbit!\n    vec3 camera_pos = vec3(\n        cos(azimuth)*cos(altitude),\n        sin(azimuth)*cos(altitude),\n        sin(altitude));\n    // the camera is always looking \"at\" the origin or half way above it\n    vec3 look_dir = normalize(vec3(0.0, 0.0, HEIGHT_SCALE*0.5) - camera_pos);\n\n\n    // TODO moving the camera in and out over time??\n    camera_pos += look_dir * -0.75; // moving the camera \"back\" to avoid occlusions?\n    // two vectors orthogonal to this camera direction (tagents?)\n    //vec3 look_u = camera_pos + vec3(-sin(azimuth), cos(azimuth), 0.0);\n    //vec3 look_v = camera_pos + vec3(sin(altitude)*-cos(azimuth), sin(altitude)*-sin(azimuth), cos(altitude));\n\n\n    // turns out analytically these aren't correct. so using cross instead -.-\n    vec3 look_u = normalize(cross(vec3(0.0, 0.0, -1.0), look_dir));\n    vec3 look_v = normalize(cross(camera_pos, look_u)); // is this faster?\n    // camera plane(origin of each pixel) -> barycentric?\n\n    vec3 camera_plane;\n    vec3 ray_dir;\n    vec3 ray_origin;\n\n    if (FOV > 0.0){\n        // assume a pinhole camera.\n        // FOV is the horizontal fov, the given focal length becomes:\n        // the 1.0 is the sensor height.\n        float focal_length = 1.0/tan(radians(FOV*0.5));\n\n        // the ro\n        camera_plane = camera_pos - (look_dir*focal_length) + ((look_u*uv.x) + (look_v*uv.y))*-1.0; // inverted here to see upright\n        ray_origin = camera_pos;\n\n        // the rd\n        ray_dir = camera_pos-camera_plane;\n        ray_dir = normalize(ray_dir);\n    }\n\n    else {\n        // negative FOV values are interpreted as a sensor size for a orthographic camera!\n        // horizontal sensor size, -1 would be something sensible... everything else is far away\n        float sensor_size = FOV*0.5*-1.0;\n        camera_plane = camera_pos + ((look_u*uv.x)+(look_v*uv.y))*sensor_size; // wider fov = larger \"sensor\"\n        ray_dir = look_dir;\n        ray_origin = camera_plane;\n    }\n\n    Ray camera = Ray(ray_origin, ray_dir, 1.0/ray_dir);\n\n    // actual stuff happening:\n    vec4 res = raycast(camera);\n    // fragColor = vec4(vec3(res.rgb),1.0);\n    //return; // early debug exit\n    if (res.a < 0.0) {\n        // we missed the initial terrain\n        res = sampleGround(ray_origin, ray_dir);\n\n        // TODO: the skybox hit returns a negative distance, so we need to handle that\n        //res.a = abs(res.a);\n    }\n    vec3 hit = ray_origin + (ray_dir*res.a);\n\n    // ro is a bit offset to reduce start intersections that are noisey ... want a better solution one day.\n    Ray sun_check = Ray(hit+0.001*SUN, SUN, 1.0/SUN);\n\n    vec4 ref = raycast(sun_check).rgba; //reflection (the full shadow)\n    ref.rgb *= 1.0 - step(0.0, ref.a); // this makes misses black?\n    // ref.rgb *= 1.0-exp(-shadow_cloud*15.0); // more \"realistic\" cloud shadow?\n\n    float shadow_amt = shadow(sun_check);\n    // actually more light amount -.-\n    // so we add and \"ambient\" base like here\n    vec3 col = res.rgb * max(0.6, shadow_amt);\n\n\n    // distance fog? I don't like it so it's commented out\n    // float dist_fog = transmittance(res.a *0.015);\n    // vec3 fog_col = vec3(0.4, 0.5, 0.9);\n    // col = mix(col, fog_col, 1.0-dist_fog);\n\n    // TODO: better \"shadow\" value via actually colored shadow??\n    // vec3 col2 = res.rgb + ref.rgb*0.3;\n    // col = vec3(uv.x > 0.0 ? col.rgb : col2.rgb);\n\n    fragColor = vec4(vec3(col),1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        },
        {
          "inputs": [
            {
              "id": 21,
              "src": "/media/a/ec8a6ea755d34600547a5353f21f0a453f9f55ff95514383b2d80b8d71283eda.mp3",
              "ctype": "music",
              "channel": 1,
              "sampler": {
                "filter": "linear",
                "wrap": "clamp",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            },
            {
              "id": 257,
              "src": "/media/previz/buffer00.png",
              "ctype": "buffer",
              "channel": 0,
              "sampler": {
                "filter": "linear",
                "wrap": "clamp",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            }
          ],
          "outputs": [
            {
              "id": 257,
              "channel": 0
            }
          ],
          "code": "// Buffer A read the music and holds a ringbuffer past.\n\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    vec2 uv = fragCoord/iResolution.xy;    \n    ivec2 st = ivec2(fragCoord);\n    // buffer length is essentially iResolution.y\n    \n    vec4 samp = vec4(0.0);    \n    if (st.x > 0) {\n        // previous state, shifted by 1\n        samp = texelFetch(iChannel0, st-ivec2(1,0), 0);\n        \n        \n        // as an alternative, you can use this 2nd line here to get smoothing for free\n        // as the texture is sampled with linear.\n        //samp = texture(iChannel0, uv-vec2(1.0/iResolution.y, 0.0));        \n    }\n    else {\n        // new value in .r and .b\n        samp.x = texelFetch(iChannel1, ivec2(st.y, 0), 0).x;\n        samp.y = 0.2 * texelFetch(iChannel1, ivec2(st.y, 1), 0).x;\n    }\n    \n    // just to have something in the channel since it's also used to calculate height!\n    samp.z = 1.0 - uv.x;    \n    fragColor = vec4(samp);\n}",
          "name": "Buffer A",
          "description": "",
          "type": "buffer"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "wc33WX",
        "date": "1747616947",
        "viewed": 222,
        "name": "Random Beat every min - 87 years",
        "username": "jakel101",
        "description": "Discussed this idea on Discord the other night, decided to sit down and implement it. Needs better instruments still!\ncan get out of sync after ~1 min, so just reload/recompile and you get something new.\n\n(instrument improvements in progress)",
        "likes": 9,
        "published": 3,
        "flags": 8,
        "usePreview": 0,
        "tags": [
          "random",
          "audio",
          "drums"
        ],
        "hasliked": 0,
        "retrieved": "2025-08-13T20:37:17.529453+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "// Apache 2.0 no patents =_=\n// attributions welcome!\n// would love to hear abour your interpretation for this!\n\n\n/*\n* \n* Image pass holds the visualization, it's might get out of sync with the music for now :/\n* Common pass holds the generation logic\n* Sound pass plays the instruments for 3 minutes.\n* recompile to get new patterns!\n* this should only repeat every ~ 87 years so enjoy some unique patterns!\n*/\n\n# define LINE 0.005\n// TODO: better pixel width\n\n// informed by: https://youtu.be/PMltMdi1Wzg\nfloat sdLineSegment(vec2 p, vec2 a, vec2 b) {\n    // pos, start, end;\n    float d;    \n    // how far along we are between the points.    \n    float h = clamp(dot(p-a, b-a)/(length(b-a)*length(b-a)), 0.0, 1.0);\n    // point along the line between the two points\n    vec2 q = mix(a, b, h);    \n    //d = min(length(p-a),length(p-b)); // this actually doesn't matter anymore\n    d = length(p-q); // debug, show point in between...\n    return d;\n}\n\n// axis aligned box with center offset\nfloat dBox(vec2 p, vec2 c, float h, float w){\n    vec2 s = (p-c); // shift the center\n    \n    float d = length(max(abs(s) - vec2(h/2.0,w/2.0), 0.0));\n    \n    return d;\n}\n\n\n// helper functio to draw the blank lines/their mask\nfloat blank(vec2 p) {\n    // from, x:-0.85 to 0.85 (so 16 notes fit in nicely)\n    // lines at y: -0.2, 0.1, 0.0, 0.1, 0.2\n    // big lines at either end\n    float mask = 0.0;    \n    float width = 0.85;\n    float vert_space = 0.1;\n    \n    // five horizontal lines\n    int i;    \n    for (i=-2; i<=2; i++){\n        float height = vert_space*float(i);\n        float l = sdLineSegment(p, vec2(width, height), vec2(-width, height));\n        mask += smoothstep(LINE, 0.0, l);\n    }\n    \n    // maybe use rectanle instead?\n    float left = dBox(p, vec2(-width, 0.0), 0.01, vert_space*4.0);\n    float right = dBox(p, vec2(width, 0.0), 0.01, vert_space*4.0);\n    mask += smoothstep(LINE, 0.0, left);\n    mask += smoothstep(LINE, 0.0, right);\n    \n    return mask; //step(0.5, mask); // step to make it more solid (really whacky)\n}\n\n\n// helper function to the top of the beamed notes\nfloat beams(vec2 p) {\n    // should be double beamed 1/16th?\n    // from like -0.8 to -0.5; -0.4 to 0.0; ...?\n    float mask;\n    float height = 0.4;\n    int i;\n    for (i=0; i<4; i++){\n        float start = -0.71 + float(i)*0.4;\n        float l1 = dBox(p, vec2(start + 0.15, height + 0.05), 0.3, 0.03); \n        float l2 = dBox(p, vec2(start + 0.15, height), 0.3, 0.015); \n        mask += smoothstep(LINE, 0.0, l1);\n        mask += smoothstep(LINE, 0.0, l2);\n    }    \n    \n    return mask;    \n}\n\n// draw notes (masks)\nfloat note(vec2 p, int time, uint type) {\n    // type: 0 - kick, 1 - snare, 2 - hi hat\n    // kick between 1 and 2 (height -0.3)\n    // snare is between 3 and 4 (height 0.1)\n    // hi hat is a ghost note (X) above 5 (height 0.5)\n    // time is 0..16 at 0.1 intervals        \n    float mask;\n    float size = 0.04;\n    float x = -0.75 + float(time)*0.1;\n    float y = -0.15 + float(type)*0.2; // height\n    \n    \n    float dist_note;\n    float stem_bot = y;\n    if (type > 1u){\n        // hh ghostnote!\n        float l1 = sdLineSegment(p, vec2(x+size,y+size), vec2(x-size,y-size));        \n        float l2 = sdLineSegment(p, vec2(x+size,y-size), vec2(x-size,y+size));       \n        dist_note = min(l1, l2);\n        stem_bot += size;\n    } \n    else {\n        // TODO: little twist!\n        dist_note = length(p-vec2(x,y)) - size;\n    }\n    float stem_dist = sdLineSegment(p, vec2(x+size, stem_bot), vec2(x+size, 0.45));\n    \n    mask += smoothstep(LINE, 0.0, min(dist_note, stem_dist));\n    //mask += smoothstep(LINE, 0.0, stem_dist);\n    return mask;\n    \n}\n\n// mask again...\nfloat notes(vec2 p, uint beat){\n    int i;\n    float mask;\n    for (i=0; i<16; i++){\n        uint type = beat & 3u; // select lowest two bits\n        type = min(type, 2u); // this shouldn't exist anyway.\n        beat = beat >> 2; // shift to bits out for next step\n        float note_mask = note(p, i, type);\n        mask += note_mask;\n    }\n    return mask;\n}\n\n\n// vizualize the BPM?\nfloat indicator(vec2 p){\n    float mask;\n    float beat_time = mod(iTime, (60.0*4.0/BPM))/(60.0*4.0/BPM); // for test\n    \n    vec2 pos = vec2(-0.75 + beat_time*(2.0*0.75), -0.5);\n    \n    float d = length(p-pos);\n    mask = smoothstep(0.1, 0.0, d);\n    return mask;\n}\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    uint beat = beat_hash();\n    vec2 uv = fragCoord/iResolution.xy;    \n    uv -= vec2(0.5);\n    uv *= 2.0;\n    \n    float line_dist = sdLineSegment(uv, vec2(0.85, 0.3), vec2(-0.85, 0.3));\n\n    //TODO: more interesting background texture, maybe paper\n    vec3 col = vec3(0.95, 0.98, 0.90);\n    \n    float bg_lines = blank(uv);\n    float tops = beams(uv);\n    float notes_mask = notes(uv, beat);\n    float indicator_mask = indicator(uv);\n    col = mix(col, vec3(0.01), bg_lines);\n    col = mix(col, vec3(0.02), tops);\n    col = mix(col, vec3(0.03), notes_mask);    \n    col = mix(col, vec3(0.85, 0.23, 0.02), indicator_mask);\n    fragColor = vec4(col,1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        },
        {
          "inputs": [],
          "outputs": [],
          "code": "# define LIFE 6\n// linetime of 2^n seconds per beat. Meant to be 6, but 0 or 1 can be used for testing\n\n# define BPM 65.0\n// change, recompile, play and then rewind!\n\n\n// TODO: does this hash every repeat? I am not sure\n// via https://www.shadertoy.com/view/XlGcRh\n// https://www.pcg-random.org/\nuint pcg(uint v)\n{\n\tuint state = v * 747796405u + 2891336453u;\n\tuint word = ((state >> ((state >> 28u) + 4u)) ^ state) * 277803737u;\n\treturn (word >> 22u) ^ word;\n}\n\n//TODO this is not at all accurate, but good enough for the demo\nuint unixTime(){\n    // deconstruct iDate back into a 32 bit unix timestamp:\n    // iDate.x = years\n    // iDate.y = months\n    // iDate.z = days\n    // iDate.w = seconds (including fractionals)\n    // TODO month/day is off by one?\n    uint time;\n    \n    uvec4 date = uvec4(iDate);\n    date.x -= 1970u; // offset since Unix epoch!\n    \n    // lazy addition for now to get a value.\n    // TODO: improve values.\n    time += uint(365.24 * float(date.x )) * 24u * 60u * 60u;\n    time += 30u*date.y * 24u * 60u * 60u;\n    time += date.z * 24u * 60u * 60u;\n    time += date.w;\n    \n    // On the Image pass we subtract the current runtime to get the time during compilation\n    // this is meant to match the Sound pass compilation varaint in the future.\n    //time -= uint(iTime); // can be out of sync -.-\n    return time;\n\n}\n\n// 32 bit value interpreted at trinary by reading 2 bits with max(2)\n// this should hash\nuint beat_hash(){\n    uint beat;\n    \n    // placeholder\n    beat = unixTime();\n    // to cause variations about every ~1 minute, we ignore the lowest 6 bits\n    // our target space is 3^16 which needs less than 26 bits.\n    uint seed = beat >> LIFE; // 6 bits to only change every 64 seconds, reduced for testing\n    uint max_val = 43046720u; //3^16 -1\n    seed = pcg(seed);\n    //seed = seed%max_val; // so it rolls over?\n    \n    \n    \n    // convert to (binary-encoded) trineary representation:        \n    int i;\n    uint val = seed; // this is too imprecise? we lose precision\n    for (i=0; i<16; i++){\n        uint tri = val%3u;\n        val = val/3u; // move to quotient for the next part\n        // fill two bits at a time\n        beat = beat << 2u;\n        beat += uint(tri);//uint(tri);  \n    }    \n    return beat;\n}\n",
          "name": "Common",
          "description": "",
          "type": "common"
        },
        {
          "inputs": [],
          "outputs": [],
          "code": "# define TAU 6.2831\n\n/* \n* I welcome any improvements to the instruments:\n* the envelope is awfully cutoff\n* better drum machines exist on Shadertoy alreay\n* there is a progressively growing undertone, maybe it can be corrected\n*/\n\n// sorta useful as white noise for now\nfloat noise(float t){\n    // really bad idea but will do for now...\n    uint u = floatBitsToUint(t);\n    u = pcg(u);    \n    float n =  uintBitsToFloat(u);\n    n = clamp(n, -1.0, 1.0);\n    return n;\n}\n\n//  TODO easier attach/pluck\nfloat envelope_drum(float t, float target_t) {\n    // this is a bad idea to cutoff the attack!!\n    if (t < target_t + 0.025) return 0.0;\n    \n    // shifts the wave to the target place\n    float t2 = t-target_t+0.05;\n    // avoid the hard cuttoffs!\n    return max(0.0, 5.0*t2*exp(-50.0*(t2-0.095)));\n}\n\n// TODO: better instruments\nfloat kick(float t, float beat_time, float hit_time) {\n    float env = envelope_drum(beat_time, hit_time);\n    env = smoothstep(0.05, 0.95, env);\n    float freq = 1.0-sinh((beat_time-hit_time)*TAU/2.0)*66.0;\n    float tone = sin(TAU*freq);\n    return 1.5*tone*env;\n}\n\nfloat snare(float t, float beat_time, float hit_time) {\n    float env = envelope_drum(beat_time, hit_time);\n    env = smoothstep(0.01, 0.9, env); // cut this off more\n    // TODO: follow the concept: https://youtu.be/hULEn2_4Unw\n    float freq = 1.0-tan((beat_time-hit_time)*TAU/2.0)*221.0;\n    float tone = sin(TAU*freq);\n    float noise = noise(t);\n    return (0.02*noise+tone)*env;\n}\n\nfloat hihat(float t, float beat_time, float hit_time) {\n    // TODO: better hi hat hit \n    float env = envelope_drum(beat_time, hit_time);\n    env = tan(env);\n    // fake gate\n    float gate = smoothstep(0.20,0.80, env);\n    float noise = noise(beat_time+t);\n    noise = clamp(noise, 0.0, 1.0);\n    \n    float tone = sin(TAU * 3420.0 * t);\n    tone *= sin(tone*8.20);\n        \n    \n    float signal = (0.5*tone+noise)*gate*env;\n    \n    return signal;\n}\n\n// returns the instrument[0,1,2] type per measure\nint player(int measure, uint beat){\n    // read exactly the two bits in the 32-bit uint for this measure\n    uint type = (beat >> 2*measure) & 3u;\n    return int(type);\n}\n\n\nvec2 mainSound( int samp, float time )\n{\n    // there probably needs to be an additional time so the cutoff isn't this random!\n    float beat_time = mod(time, (60.0*4.0/BPM))/(60.0*4.0/BPM);    \n    // can we avoid the mod and instead do a gate/trigger?\n    \n    uint beat = beat_hash();\n    \n    float signal;\n    \n    int i;\n    for (i=0; i<16; i++){\n        int type = player(i, beat);\n        float hit_time = float(i)/16.0;        \n        float sound;\n        if (type == 0) {\n            sound = kick(time, beat_time, hit_time);\n        }\n        else if (type == 1) {\n            sound = snare(time, beat_time, hit_time);\n        }\n        else if (type == 2) {\n            sound = hihat(time, beat_time, hit_time);\n        }\n        // TODO: proper mixing\n        signal += sound; \n    }\n    \n    // lots of fun with streo left over here.\n    return vec2(signal);\n}",
          "name": "Sound",
          "description": "",
          "type": "sound"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "3f33zl",
        "date": "1747344200",
        "viewed": 84,
        "name": "casting tests",
        "username": "jakel101",
        "description": "testing how color values get cast into 8unorm",
        "likes": 0,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "test"
        ],
        "hasliked": 0,
        "retrieved": "2025-08-13T20:37:17.529453+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "void mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    vec2 uv = fragCoord/iResolution.xy;\n    \n    if (uv.y > 0.5) (uv.x-=0.5);\n    \n    \n    vec3 col;\n    \n    col.r = uv.x;\n    col.g = (float(int(uv.x*255.0+0.5)))/255.0;   \n    col.b = (float(trunc(uv.x*255.0+0.5)))/255.0;    \n    \n    fragColor = vec4(col,1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "w32XD1",
        "date": "1746067136",
        "viewed": 77,
        "name": "displacing tiling in 2D??",
        "username": "jakel101",
        "description": "WIP where you distort the tile UV (and later ID) so they are no longer squares",
        "likes": 0,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "tiling"
        ],
        "hasliked": 0,
        "retrieved": "2025-08-13T20:37:17.529453+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "#define PI 3.14192\n\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    vec2 uv = fragCoord/iResolution.xy;\n    uv *= 3.0;\n    uv.x += asin(fract(uv.y-0.5)+0.5)*(1.0/PI);\n    \n    // TODO: uv per shape, not per square.\n    // +vec2(0.0, smoothstep(0.0, 1.0, fract(uv.x))))\n    vec2 cellUV = fract(uv);\n    vec2 cellID = floor(uv);\n    \n    // checkerboard trick\n    float check = clamp(0.0, 1.0, \n        (mod(cellID.y, 2.0) + mod(cellID.x, 2.0))) \n     - ((mod(cellID.y, 2.0) * mod(cellID.x, 2.0)));\n    \n    vec3 col = vec3(cellUV, 0.0);//, check);\n    fragColor = vec4(col,1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "tXlGR7",
        "date": "1742863063",
        "viewed": 111,
        "name": "buffer self reference test",
        "username": "jakel101",
        "description": "little illustration on how multiple buffer pass interact with one another and their render order. used for unit testing",
        "likes": 1,
        "published": 3,
        "flags": 32,
        "usePreview": 0,
        "tags": [
          "test",
          "multipass"
        ],
        "hasliked": 0,
        "retrieved": "2025-08-13T20:37:17.529453+00:00"
      },
      "renderpass": [
        {
          "inputs": [
            {
              "id": 257,
              "src": "/media/previz/buffer00.png",
              "ctype": "buffer",
              "channel": 0,
              "sampler": {
                "filter": "linear",
                "wrap": "clamp",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            },
            {
              "id": 258,
              "src": "/media/previz/buffer01.png",
              "ctype": "buffer",
              "channel": 1,
              "sampler": {
                "filter": "linear",
                "wrap": "clamp",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            }
          ],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "// Apache 2.0 not patents [*|*]\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    vec2 uv = fragCoord/iResolution.xy;\n    vec4 c0 = texture(iChannel0, uv);\n    vec4 c1 = texture(iChannel1, uv);\n    fragColor = vec4(mix(c0.rgb, c1.rgb, step(0.5, uv.x)), 1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        },
        {
          "inputs": [
            {
              "id": 257,
              "src": "/media/previz/buffer00.png",
              "ctype": "buffer",
              "channel": 0,
              "sampler": {
                "filter": "linear",
                "wrap": "clamp",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            },
            {
              "id": 258,
              "src": "/media/previz/buffer01.png",
              "ctype": "buffer",
              "channel": 1,
              "sampler": {
                "filter": "linear",
                "wrap": "clamp",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            }
          ],
          "outputs": [
            {
              "id": 257,
              "channel": 0
            }
          ],
          "code": "void mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    vec2 uv = fragCoord/iResolution.xy;\n    vec4 c0 = texture(iChannel0, uv); //self\n    c0 += fract(iTime + uv.y) - 0.5;\n    vec4 c1 = texture(iChannel1, uv);\n    c1 += fract(iTime - uv.y) - 0.5;\n    fragColor = vec4(mix(c0.rgb, c1.rgb, step(0.25, uv.x)), 1.0);\n}",
          "name": "Buffer A",
          "description": "",
          "type": "buffer"
        },
        {
          "inputs": [
            {
              "id": 257,
              "src": "/media/previz/buffer00.png",
              "ctype": "buffer",
              "channel": 0,
              "sampler": {
                "filter": "linear",
                "wrap": "clamp",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            },
            {
              "id": 258,
              "src": "/media/previz/buffer01.png",
              "ctype": "buffer",
              "channel": 1,
              "sampler": {
                "filter": "linear",
                "wrap": "clamp",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            }
          ],
          "outputs": [
            {
              "id": 258,
              "channel": 0
            }
          ],
          "code": "void mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    vec2 uv = fragCoord/iResolution.xy;\n    vec4 c0 = texture(iChannel0, uv); \n    c0 += fract(iTime + uv.y) - 0.5;\n    vec4 c1 = texture(iChannel1, uv); //self\n    c1 += fract(iTime - uv.y) - 0.5;\n    fragColor = vec4(mix(c0.rgb, c1.rgb, step(0.75, uv.x)), 1.0);\n}",
          "name": "Buffer B",
          "description": "",
          "type": "buffer"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "M3VBWt",
        "date": "1738883384",
        "viewed": 253,
        "name": "pathtraced heightmap (WIP)",
        "username": "jakel101",
        "description": "goal is to display some texture as a 3D heighmap. like an array of columns maybe? for development progress see: [url=https://github.com/Vipitis/shader_tracker/blob/main/jakel101/M3VBWt_pathtraced_heightmap__WIP_/Image.frag]GitHub[/url]\n",
        "likes": 5,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "25d",
          "heightmap",
          "pathracing"
        ],
        "hasliked": 0,
        "retrieved": "2025-09-09T21:55:41.107497+00:00"
      },
      "renderpass": [
        {
          "inputs": [
            {
              "id": 16,
              "src": "/media/a/3083c722c0c738cad0f468383167a0d246f91af2bfa373e9c5c094fb8c8413e0.png",
              "ctype": "texture",
              "channel": 0,
              "sampler": {
                "filter": "mipmap",
                "wrap": "repeat",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            }
          ],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "// Apache 2.0 no patents \\_%_/\n\n/* Image pass shader to draw a texture/buffer/input as a heightmap\n* with some pathtracing as pillars of pixels.\n* Meant to be used in multiple projects and therefore\n* easily configurable at the top with a few macros\n*\n* selflink: https://www.shadertoy.com/view/M3VBWt\n* other projects using this shader/framework: https://www.shadertoy.com/playlist/mX2cD3\n* \n* work in progress:\n* todo(ideas):\n* - monte carlo light simulation\n* - pysics simulation\n* - ball/area lights\n* - infinite/LOD tiles?\n* - DDA like traversal\n* - cleanup as usual\n* feedback/improvements welcome here.\n*/\n\n\n# define PI 3.141592653\n# define HEIGHT_SCALE 0.5\n\n# define CELLS ivec2(iChannelResolution[0].x, iChannelResolution[0].y)\n//# define CELLS ivec2(3)\n\n// unsure yet where to bring this!\n# define SUN normalize(vec3(sin(iDate.w*0.5), cos(iTime), HEIGHT_SCALE*1.5))\n// normalize(vec3(3.0, -5.0, 2.0))\n\n// horizontal FOV, if you use negative values the camera will be orthographic!\n// examples:\n// FOV -1.0 for orthographic (sensor size)\n// FOV 90.0 for perspective wide\n// FOV 45.0 for perspective narower\n# define FOV 90.0\n\n// how far \"behind\" the camera is behind the arcball\n# define CAMERA_DIST -0.65\n\n# define BALL_SIZE 0.25\n\n// TODO one variable to change between sampled and direct light\n// 0 -> directional light\n// 1 -> point light\n// 2 -> MIS? (one light, one sampled?)\n// 3+ -> bounces//samples?\n# define BOUNCES 4\n# define SAMPLES 8\n\nstruct Material{\n    vec3 col; // ground color (or texture?)\n    float emissivity; //emitted light in some unit?\n    float roughness; // invers reflectivity, sorta\n    float translucency; // something like 1.0 for glass and 0.0 for solids? -> rays split/sample/refract??\n    float IOR; // index of refraction\n};\n\n// edit these here to change the look and feel!\nMaterial chalk = Material(vec3(1.0),           0.0,  0.65,  0.0, 1.3);\nMaterial ground = Material(vec3(0.5),          0.0,  0.25,  0.0, 0.0);\nMaterial sky = Material(vec3(0.02, 0.3, 0.85), 1.0,  0.90,  0.0, 0.0);\nMaterial glass = Material(vec3(1.0),           0.0,  0.02,  0.9, 1.5);\n\n\nivec2 worldToCell(vec3 p) {\n    // move world space again\n    p += 1.0;\n    p *= 0.5;\n    ivec2 st = ivec2((p.xy*vec2(CELLS.xy)));\n    // TODO: find an actual solution to the edge cases!\n    st = min(st, CELLS -1);\n    return st;\n}\n\nstruct Ray{\n    vec3 origin;\n    vec3 dir;\n    vec3 inv_dir; // for speedup?\n};\n\n// helper constructor\nRay newRay(vec3 ro, vec3 rd){\n    return Ray(ro, rd, 1.0/rd);\n}\n\n\nstruct IntersectionInfo{\n    bool hit;\n    // rest illdefined for a miss\n    bool inside;\n    vec3 entry;\n    vec3 exit;\n    vec3 entry_norm;\n    vec3 exit_norm;\n    float entry_dist;\n    float exit_dist;\n};\n\n// sorta reference: https://tavianator.com/2022/ray_box_boundary.html\nIntersectionInfo AABB(vec3 center, vec3 size, Ray ray){\n    IntersectionInfo res;\n\n    vec3 pos = center + size;\n    vec3 neg = center - size;\n\n    vec3 pos_dist = (pos-ray.origin) * ray.inv_dir;\n    vec3 neg_dist = (neg-ray.origin) * ray.inv_dir;\n\n    vec3 min_dist = min(pos_dist, neg_dist);\n    vec3 max_dist = max(pos_dist, neg_dist);\n\n    res.entry_dist = max(max(min_dist.x, min_dist.y), min_dist.z);\n    res.exit_dist = min(min(max_dist.x, max_dist.y), max_dist.z);\n\n    // normals point away from the center\n    res.entry_norm = -sign(ray.dir) * vec3(greaterThanEqual(min_dist, vec3(res.entry_dist)));\n    res.exit_norm = sign(ray.dir) * vec3(lessThanEqual(max_dist, vec3(res.exit_dist)));\n\n    // essentially methods?\n    res.entry = ray.origin + ray.dir*res.entry_dist;\n    res.exit = ray.origin + ray.dir*res.exit_dist;\n\n    res.hit = res.entry_dist < res.exit_dist && res.exit_dist > 0.0;\n    res.inside = res.entry_dist < 0.0; // entry behind us\n\n    return res;\n}\n\n// with help from: https://www.scratchapixel.com/lessons/3d-basic-rendering/minimal-ray-tracer-rendering-simple-shapes/ray-sphere-intersection.html\nIntersectionInfo Sphere(vec3 center, float radius, Ray ray){\n    IntersectionInfo res;\n    vec3 local = ray.origin - center;\n        \n    float a = dot(ray.dir, ray.dir);\n    float b = 2.0* dot(ray.dir, local);\n    float c = dot(local, local) - pow(radius,2.0);\n        \n    float discriminant = pow(b,2.0) - 4.0*a*c;\n    \n    res.hit = discriminant >= 0.0;\n    \n    float t0 = (-b + sqrt(discriminant))/ (2.0*a);\n    float t1 = (-b - sqrt(discriminant))/ (2.0*a);\n\n    res.entry_dist = min(t0, t1);\n    res.exit_dist = max(t0, t1);\n    \n    if (res.entry_dist < 0.0 && res.exit_dist < 0.0){\n        res.hit = false;\n    }\n\n    res.entry = ray.origin + ray.dir * res.entry_dist;\n    res.exit = ray.origin + ray.dir * res.exit_dist;\n\n    res.entry_norm = normalize(res.entry - center);\n    res.exit_norm = normalize(res.exit - center);\n    \n    res.inside = res.entry_dist < 0.0 && res.exit_dist > 0.0; // entry behind us\n\n    return res;\n}\n\n\nIntersectionInfo pillar_hits(ivec2 cell, float height, Ray ray){\n    // let's move the pillar into world space by having it's center + extends\n\n    vec3 extend = vec3(1.0/vec2(CELLS), abs(height)*0.5);\n    vec3 p = vec3(cell.xy, abs(height)*0.5);\n    p.xy *= extend.xy;\n    p.xy *= 2.0;\n    p.xy -= 1.0 - extend.xy; // not quite the offset?\n    //extend.z = extend.y; // make them cubes?\n\n    // for the case of clouds the box is at the top?\n    if (height < 0.0){\n        p.z = HEIGHT_SCALE*(1.0-abs(height*0.5));\n    }\n\n    // TODO: redo this math when less asleep...\n    IntersectionInfo res = AABB(p, extend, ray);\n    return res;\n}\n\n\nvec4 sampleHeight(ivec2 cell){\n    // to allow for more complex math to determine height\n    // .rgb should just return the texture color or some modification of it\n    //cell.x = (cell.x + iFrame) % int(iChannelResolution[0].x); // fun texture scroll\n    vec4 tex = texelFetch(iChannel0, cell, 0);\n    vec4 res;\n    res.a = tex.r + tex.g + tex.b; // we do height by a sum of the color for now\n    res.a *= 0.33;\n    res.rgb = tex.rgb; // simply copy the color as the \"texture\" for now\n    \n    // res.a = tex.a; // debug/use existing height data.\n    res.a *= HEIGHT_SCALE;\n    return res;\n}\n\n// from: https://www.shadertoy.com/view/7l3yRn\nvec2 get_random_numbers(inout uvec2 seed) {\n    // This is PCG2D: https://jcgt.org/published/0009/03/02/\n    seed = 1664525u * seed + 1013904223u;\n    seed.x += 1664525u * seed.y;\n    seed.y += 1664525u * seed.x;\n    seed ^= (seed >> 16u);\n    seed.x += 1664525u * seed.y;\n    seed.y += 1664525u * seed.x;\n    seed ^= (seed >> 16u);\n    // Convert to float. The constant here is 2^-32.\n    return vec2(seed) * 2.32830643654e-10;\n}\n\n// also from above\n// TODO collaplse into one function!\n// Given uniform random numbers u_0, u_1 in [0,1)^2, this function returns a\n// uniformly distributed point on the unit sphere (i.e. a random direction)\n// (omega)\nvec3 sample_sphere(vec2 random_numbers) {\n    float z = 2.0 * random_numbers[1] - 1.0;\n    float phi = 2.0 * PI * random_numbers[0];\n    float x = cos(phi) * sqrt(1.0 - z * z);\n    float y = sin(phi) * sqrt(1.0 - z * z);\n    return vec3(x, y, z);\n}\n\n\n// Like sample_sphere() but only samples the hemisphere where the dot product\n// with the given normal (n) is >= 0\nvec3 sample_hemisphere(vec2 random_numbers, vec3 normal) {\n    vec3 direction = sample_sphere(random_numbers);\n    if (dot(normal, direction) < 0.0)\n        direction -= 2.0 * dot(normal, direction) * normal;\n    return direction;\n}\n\n\nstruct RaycastInfo{\n    bool hit; // if negative, the rest is undefined.\n    float dist; // hit_info.entry_dist redundant?\n    //ivec2 cell; //current_cell?\n    IntersectionInfo hit_info; //has the entry norm etc.\n    vec3 col; // TODO: replace with material\n    //Ray ray; //just as a reference?\n};\n\n\nRaycastInfo raycast(Ray ray){\n    // cast the ray untill there is a hit or we exit the box\n    // \"any hit\" shader?\n    RaycastInfo result;\n    \n    IntersectionInfo box = AABB(vec3(0.0, 0.0, HEIGHT_SCALE*0.5), vec3(1.0, 1.0, HEIGHT_SCALE*0.5), ray);\n\n    vec3 entry = box.entry;\n\n    if (!box.hit){\n        // if we \"MISS\" the whole box (not inside?).\n        result.hit = false;\n        return result;\n        \n    }\n    // everything below here is inside the box\n    if (box.inside){\n        // if we are \"inside\" the entry should just be ro!\n        entry = ray.origin; // maybe problems with distance caluclations at the end?\n    }\n    \n    ivec2 current_cell = worldToCell(entry); // TODO: this one is problematic!\n    int i;\n    ivec2 max_cells = CELLS - min(current_cell, CELLS-current_cell);\n    int max_depth = (max_cells.x + max_cells.y)+2; // could also be min!\n    for (i = 0; i < max_depth; i++){\n        if (current_cell.x < 0 || current_cell.x >= CELLS.x ||\n            current_cell.y < 0 || current_cell.y >= CELLS.y){\n            // we marched far enough are are \"outside the box\" now!\n            result.hit = false;            \n            return result;\n        }\n\n        vec4 tex = sampleHeight(current_cell);\n        IntersectionInfo pillar = pillar_hits(current_cell, tex.a, ray);\n\n        if (pillar.hit) {\n            // \"any hit\" (side/top/bot) -> loop ends here\n            // do a little bit of light sim by doing diffuse \"block of chalk\"\n            vec3 col = tex.rgb;\n            // TODO materail decision here?\n            result.hit = true;\n            result.hit_info = pillar;\n            result.dist = pillar.entry_dist;\n            result.col = col;\n            return result;            \n        }\n\n        // check if our exit distance larger than the box, means we should be at the final pillar...\n        if (pillar.exit_dist >= box.exit_dist){\n            result.hit = false;\n            return result; // do we ever get here?\n        }\n\n        // the step\n        // TODO: DDA style decision\n        ivec2 next_cell = current_cell + ivec2(pillar.exit_norm.xy);\n        if (next_cell == current_cell){\n            // in this case we do another raycast - but without any Z component\n            // so the vector is sideways and points to a new cell!\n            vec3 flat_rd = vec3(ray.dir.xy, 0.0);\n            Ray flat_ray = Ray(ray.origin, flat_rd, 1.0/flat_rd);\n\n            IntersectionInfo grid = pillar_hits(current_cell, 1.0, flat_ray);\n            next_cell += ivec2(grid.exit_norm.xy); // TODO check if this norm is correct!\n        }\n        // for next iteration\n        current_cell = next_cell;\n    }\n    \n    result.hit = false;\n    return result;\n}\n\n// more like a bad shadowmap\n// idea for the future: precompute the horizon per pixel: https://youtu.be/LluCbGdi-RM\nfloat directional_light(Ray sun_ray, vec3 normal){\n    // return the amount of shadowed?\n    // we are now marching upwards from some hit\n    // ro is essentially the point we started from\n    // rd is the sun angle\n    RaycastInfo res = raycast(sun_ray);\n    //return res.a;\n    \n    //TODO: intensity/color?\n    \n    float amt = 1.0;\n    \n    \n    if (!res.hit){// || (ro + rd*res.a).z >= HEIGHT_SCALE){\n        // miss means full sunlight!\n        amt = max(0.0, dot(sun_ray.dir, normal));\n    }\n    else {\n        // TODO: use distance?\n        amt = 0.1; // additional ambient light from here?\n    }\n    return amt;\n}\n\n// struct for lights? colored light?\nfloat point_light(vec3 start, vec3 light_pos, float light_intensity, vec3 normal){\n    float amount;\n    \n    vec3 light_dir = normalize(light_pos - start);\n    float light_dist = distance(start, light_pos);\n    // Ray(hit+0.001*SUN, SUN, 1.0/SUN);\n    Ray light_cast = Ray(start + 0.001*light_dir, light_dir, 1.0/light_dir);\n    RaycastInfo res = raycast(light_cast);\n    \n    if (!res.hit || res.dist > light_dist) {\n        // either we miss geometry or we hit gometry behind the light\n        amount = inversesqrt(light_dist)* light_intensity;\n        amount *= max(0.0, dot(normal, light_dir));\n    }\n    else {\n        // hit an intersection before the light, so don't see the light!\n        amount = 0.0;        \n    }\n    \n    // TODO still needs dot normal!\n    return amount;\n}\n\n\n\n// copied from https://www.shadertoy.com/view/M3jGzh\nfloat checkerboard(vec2 check_uv, float cells){\n    check_uv *= cells/2.0;\n    float rows = float(mod(check_uv.y, 1.0) <= 0.5);\n    float cols = float(mod(check_uv.x, 1.0) <= 0.5);\n    return float(rows == cols);\n}\n\nstruct HitInfo{\n    Material mat;\n    float dist;\n    vec3 norm;\n    vec3 pos;\n    bool inside; // for doing glass rays!\n};\n\n\nHitInfo sampleGround(vec3 ro, vec3 rd){\n    HitInfo res;\n    // TODO: rename to sample skybox maybe? as the ground is sorta part of that...\n    float ground_height = 0.0;\n    float ground_dist = (ground_height-ro.z)/rd.z;\n    // TODO: use the actual sphere for the \"skybox\"\n    if (ground_dist < 0.0 ||ground_dist > 10.0) {\n        // essentially sky hit instead?\n        // just some random skybox right now... could be improved of course!\n        vec3 col = vec3(0.23, 0.59, 0.92)*exp(dot(SUN, rd)-0.8);\n        col = clamp(col, vec3(0.0), vec3(1.0));\n        \n        res.mat = sky;\n        \n        res.mat.col = col; // no longer matches with \"sky\" - so gotta change the above maybe?\n        \n        res.dist = 10.0;\n        res.pos = ro + rd*res.dist;\n        res.mat.emissivity *= clamp(smoothstep(res.dist - 8.1, res.dist- 3.0, res.pos.z), 0.0, 1.0);\n        res.norm = -rd;\n        return res; // some random distance that is positive!\n    }\n\n    vec3 ground_hit = ro + (rd * ground_dist);\n\n    float val = checkerboard(ground_hit.xy, 8.0)* 0.25;\n    val += 0.45;\n    //val *= 2.0 - length(abs(ground_hit));\n\n    // fake sun angle spotlight... TODO actual angle and normal calculation!\n    //val *= 2.5 - min(2.3, length((-SUN-ground_hit)));//,vec3(0.0,0.0,1.0));\n\n    vec3 col = vec3(val);\n    res.mat = ground;\n    res.mat.col = col;\n    res.dist = ground_dist;\n    res.pos = ground_hit;\n    res.norm = vec3(0.0, 0.0, 1.0);\n    return res;\n}\n\n// TODO for montecarlo we need an external loop around this!\nHitInfo scene(Ray camera){\n    HitInfo res;\n    \n    // terrain\n    RaycastInfo terrain = raycast(camera);\n\n    // ball\n    IntersectionInfo ball = Sphere(SUN, BALL_SIZE, camera);\n\n    // five cases: just terrain hit, ball hit, both miss, both hit terrain closer, both hit ball closer\n    // idea: get all hits, then calculate closest (sorted?) and then return that. if none return background\n    // TODO: redo logic (dynamic arrays?)\n\n    if (terrain.hit && (!ball.hit || terrain.dist < ball.entry_dist)) {\n        // terrain infront of the ball\n        res.mat = chalk;\n        res.mat.col = terrain.col; // TODO: material construction\n        res.norm = terrain.hit_info.entry_norm;\n        res.pos = terrain.hit_info.entry;\n        res.inside = terrain.hit_info.inside;\n        if (res.inside) {\n            res.norm = terrain.hit_info.exit_norm;\n            res.pos = terrain.hit_info.exit;\n        }\n        \n    } else if (ball.hit) {\n        // ball infront of the terrain\n        res.mat = glass; // TODO: glass material?\n        res.norm = ball.entry_norm;\n        res.pos = ball.entry;        \n        res.inside = ball.inside;\n        if (res.inside) {\n            res.norm = ball.exit_norm;\n            res.pos = ball.exit;\n        }\n        \n    } else {\n        res = sampleGround(camera.origin, camera.dir);\n    }\n    \n\n    return res;\n}\n\n// follow ? https://www.shadertoy.com/view/7l3yRn\nstruct RayRadiance{\n    vec3 radiance;\n    vec3 throughput_weight;\n};\n\n// reading: https://www.pbr-book.org/4ed/Radiometry,_Spectra,_and_Color/Surface_Reflection\n// further: https://www.pbr-book.org/4ed/Reflection_Models\n// watching maybe: https://youtu.be/wA1KVZ1eOuA\nvec3 brsf(in vec3 rd, in HitInfo hit, inout vec3 next_dir, inout uvec2 seed){\n    // returns the outgoing radiance?\n    // as well as the next ray direction. (inout)\n    \n    Material mat = hit.mat;\n    vec3 norm = hit.norm;\n    // naive reflection model\n    vec3 perfect_reflection = reflect(rd, norm);\n    next_dir = mix(perfect_reflection, next_dir, mat.roughness);\n    \n    //native transmission model\n\n    vec2 randoms = get_random_numbers(seed);\n    if (randoms.x < mat.translucency) {\n        float IOR = hit.inside ? mat.IOR : 1.0/mat.IOR;\n        vec3 reflect_norm = hit.inside ? norm : -norm;\n        vec3 perfect_refraction = refract(rd, -reflect_norm, IOR);\n        next_dir = mix(perfect_refraction, -next_dir, mat.roughness);\n        //next_dir = perfect_refraction;\n        norm = reflect_norm;\n    }\n\n    vec3 outgoing = mat.col * 2.0 * max(0.0, dot(norm, next_dir));\n    return outgoing;\n}\n\n\n\n// factored out to function so the seed changes correctly due to inout -.-\nvec3 get_ray_radiance(HitInfo first_hit, Ray camera, inout uvec2 seed){\n    //after get_ray_radiance in https://www.shadertoy.com/view/7l3yRn\n\n    // because the first_hit is shared between samples, we can skip the traversal a few times\n    vec3 radiance = vec3(first_hit.mat.emissivity);\n    vec3 next_dir = sample_hemisphere(get_random_numbers(seed), first_hit.norm);\n    vec3 outgoing_radiance = brsf(camera.dir, first_hit, next_dir, seed);\n    vec3 throughput_weight = outgoing_radiance;\n    \n    Ray bounce = newRay(first_hit.pos+0.0001*next_dir, next_dir);\n\n    int i;\n    for(i=0; i<BOUNCES; i++){\n        HitInfo hit = scene(bounce);\n        radiance += throughput_weight * hit.mat.emissivity;\n        // TODO: technically we could exit here early?\n        // random first and then mutated below\n        next_dir = sample_hemisphere(get_random_numbers(seed), hit.norm);        \n        outgoing_radiance = brsf(bounce.dir, hit, next_dir, seed);\n        \n        throughput_weight *= outgoing_radiance;\n        if (lessThanEqual(throughput_weight,vec3(0.0))==bvec3(true)) break; // TODO benchmark if this even works as a speedup\n        //if (length(throughput_weight) <= 0.0) break; // version which I don't belive in...\n        bounce = newRay(hit.pos+0.0001*next_dir, next_dir);\n    }\n\n    return radiance;\n}\n\n\n\n// TODO: calucalte the light from that brdf too? HitInfo2 -> RayRadiance, next_dir\n// multiple importance sampling? following: https://lisyarus.github.io/blog/posts/multiple-importance-sampling.html\n// idea being we sample the direct light or direction light once, and then do one random sample. weight them 50/50?\n// TODO: call scene below and loop it?\n// 1. cast scene, 2. accumulate light, 3. get next dir, LOOP\n// add a MAX_bounces or SPP var at the top.\n\n\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    // uv normalized to [-1..1] for height with more width\n    vec2 uv = (2.0*fragCoord - iResolution.xy)/iResolution.y;\n    vec2 mo = (2.0*iMouse.xy - iResolution.xy)/iResolution.y;\n    \n    \n    uvec2 seed = uvec2(fragCoord) ^ uvec2(iFrame << 16);\n\n    //fragColor = texture(iChannel0, uv);\n    //return;\n\n    // for when it's just idling...\n    float azimuth = -1.9+iTime*0.1 + mo.x; // keeps a bit of residue of the mouse!\n    float altitude = 0.7+cos(1.5+iTime*0.25)*0.35;\n    if (sign(iMouse.z) > 0.0){\n        // orbiting camera setup\n        azimuth = PI*mo.x;\n        altitude = 0.5*PI*clamp(mo.y+1.0, -0.01, 0.99); // maybe just positive?\n    }\n\n    // make sure you don't look \"below\"\n    altitude = clamp(altitude, HEIGHT_SCALE*0.2, PI);\n\n    // a unit length orbit!\n    vec3 camera_pos = vec3(\n        cos(azimuth)*cos(altitude),\n        sin(azimuth)*cos(altitude),\n        sin(altitude));\n    // the camera is always looking \"at\" the origin or half way above it\n    vec3 look_dir = normalize(vec3(0.0, 0.0, HEIGHT_SCALE*0.5) - camera_pos);\n\n\n    // TODO moving the camera in and out over time??\n    camera_pos += look_dir * CAMERA_DIST; // moving the camera \"back\" to avoid occlusions?\n    // two vectors orthogonal to this camera direction (tagents?)\n    //vec3 look_u = camera_pos + vec3(-sin(azimuth), cos(azimuth), 0.0);\n    //vec3 look_v = camera_pos + vec3(sin(altitude)*-cos(azimuth), sin(altitude)*-sin(azimuth), cos(altitude));\n\n\n    // turns out analytically these aren't correct. so using cross instead -.-\n    vec3 look_u = normalize(cross(look_dir, vec3(0.0, 0.0, 1.0)));\n    vec3 look_v = normalize(cross(look_u, look_dir)); // is this faster?\n    // camera plane(origin of each pixel) -> barycentric?\n\n    vec3 camera_plane;\n    vec3 ray_dir;\n    vec3 ray_origin;\n\n    if (FOV > 0.0){\n        // assume a pinhole camera.\n        // FOV is the horizontal fov, the given focal length becomes:\n        // the 1.0 is the sensor height.\n        float focal_length = 1.0/tan(radians(FOV*0.5));\n\n        // the ro\n        camera_plane = camera_pos - (look_dir*focal_length) + ((look_u*uv.x) + (look_v*uv.y))*-1.0; // inverted here to see upright\n        ray_origin = camera_pos;\n\n        // the rd\n        ray_dir = camera_pos-camera_plane;\n        ray_dir = normalize(ray_dir);\n    }\n\n    else {\n        // negative FOV values are interpreted as a sensor size for a orthographic camera!\n        // horizontal sensor size, -1 would be something sensible... everything else is far away\n        float sensor_size = FOV*0.5*-1.0;\n        camera_plane = camera_pos + ((look_u*uv.x)+(look_v*uv.y))*sensor_size; // wider fov = larger \"sensor\"\n        ray_dir = look_dir;\n        ray_origin = camera_plane;\n    }\n\n    // todo extract to a function\n    // Ray in -> material/normal out?\n    // caluclate and aggregate light throughput?\n    // new ray direction based on sampled material/refraction?\n\n    Ray camera = newRay(ray_origin, ray_dir);\n    vec3 out_col = vec3(0.0);\n    \n    // primary rays happen here once per frame!\n    HitInfo first_hit = scene(camera);\n        \n    int j;\n    for(j=0; j<SAMPLES; ++j){\n        vec3 rad = get_ray_radiance(first_hit, camera, seed);\n        out_col += rad;\n    }\n    // average color over all samples\n    out_col /= float(SAMPLES);\n    \n    // TODO gamma correction?\n    fragColor = vec4(out_col, 1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "X3KyRd",
        "date": "1737245413",
        "viewed": 92,
        "name": "bounding box development",
        "username": "jakel101",
        "description": "trying to figure out how this would work (without looking it up)\n\nneeded for this unreleased one: https://www.shadertoy.com/view/lXycDz",
        "likes": 1,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "raytracing",
          "cube"
        ],
        "hasliked": 0,
        "retrieved": "2025-08-20T22:35:16.484822+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "// Apache 2.0 no patent (O)-(O)\n// working out: https://www.desmos.com/3d/dfrawfz5oy\n// improved: https://www.desmos.com/3d/loyr0cvm2c\n// done:? https://www.desmos.com/3d/bewjnaugsh\n# define PI 3.141592654\n# define FOV 90.0\n\nstruct Ray{\n    vec3 origin;\n    vec3 dir;\n    vec3 inv_dir; // for speedup?\n};\n\nstruct BoxHit{\n    bool hit;\n    bool inside;\n    vec3 entry;\n    vec3 exit;\n    vec3 entry_norm;\n    vec3 exit_norm;\n    float entry_dist;\n    float exit_dist;\n};\n\n// sorta reference: https://tavianator.com/2022/ray_box_boundary.html\nBoxHit AABB(vec3 center, vec3 size, Ray ray){\n    BoxHit res;\n        \n    vec3 pos = center + size;\n    vec3 neg = center - size;\n    \n    vec3 pos_dist = (pos-ray.origin) * ray.inv_dir;\n    vec3 neg_dist = (neg-ray.origin) * ray.inv_dir;\n    \n    vec3 min_dist = min(pos_dist, neg_dist);\n    vec3 max_dist = max(pos_dist, neg_dist);\n    \n    res.entry_dist = max(max(min_dist.x, min_dist.y), min_dist.z);\n    res.exit_dist = min(min(max_dist.x, max_dist.y), max_dist.z);\n    \n    // essentially methods?\n    res.hit = res.entry_dist < res.exit_dist && res.exit_dist > 0.0;\n    res.inside = res.entry_dist < 0.0; // entry behind us\n    \n    res.entry = ray.origin + ray.dir*res.entry_dist;\n    res.exit = ray.origin + ray.dir*res.exit_dist;\n    \n    // normals point away from the center\n    res.entry_norm = -sign(ray.dir) * vec3(greaterThanEqual(min_dist, vec3(res.entry_dist)));\n    res.exit_norm = sign(ray.dir) * vec3(lessThanEqual(max_dist, vec3(res.exit_dist)));\n    \n    return res;\n}\n\n// with help from: https://www.scratchapixel.com/lessons/3d-basic-rendering/minimal-ray-tracer-rendering-simple-shapes/ray-sphere-intersection.html\nBoxHit Sphere(vec3 center, float radius, Ray ray){\n    BoxHit res;    \n    vec3 local = ray.origin - center;\n        \n    float a = dot(ray.dir, ray.dir);\n    float b = 2.0* dot(ray.dir, local);\n    float c = dot(local, local) - pow(radius,2.0);\n        \n    float discriminant = pow(b,2.0) - 4.0*a*c;\n    \n    res.hit = discriminant >= 0.0;\n    \n    float t0 = (-b + sqrt(discriminant))/ (2.0*a);\n    float t1 = (-b - sqrt(discriminant))/ (2.0*a);\n\n    res.entry_dist = min(t0, t1);\n    res.exit_dist = max(t0, t1);\n\n    res.entry = ray.origin + ray.dir * res.entry_dist;\n    res.exit = ray.origin + ray.dir * res.exit_dist;\n\n    res.entry_norm = normalize(res.entry - center);\n    res.exit_norm = normalize(res.exit - center);\n    \n    res.inside = res.entry_dist < 0.0; // entry behind us\n\n    return res;\n}\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    // uv normalized to [-1..1] for height with more width\n    vec2 uv = (2.0*fragCoord - iResolution.xy)/iResolution.y;\n    vec2 mo = (2.0*iMouse.xy - iResolution.xy)/iResolution.y;\n    \n    //fragColor = texture(iChannel0, uv);\n    //return;\n    \n    // for when it's just idling...   \n    float azimuth = iTime*0.3 + mo.x; // keeps a bit of residue of the mouse!\n    float altitude = cos(iTime*0.5)*0.35;      \n    if (sign(iMouse.z) > 0.0){\n        // orbiting camera setup\n        azimuth = PI*mo.x;\n        altitude = 0.5*PI*clamp(mo.y, -0.85, 0.99); // maybe just positive?\n    }\n    \n    // make sure you don't look \"below\"\n    altitude = clamp(altitude, -PI, PI);\n    \n    // a unit length orbit!\n    vec3 camera_pos = vec3(\n        cos(azimuth)*cos(altitude),\n        sin(azimuth)*cos(altitude),\n        sin(altitude));               \n    // the camera is always looking \"at\" the origin or half way above it\n    vec3 look_dir = normalize(vec3(0.0, 0.0, 0.0) - camera_pos);\n    \n    \n    // TODO moving the camera in and out over time??\n    camera_pos += look_dir * -0.0; // moving the camera \"back\" to avoid occlusions?\n    // two vectors orthogonal to this camera direction (tagents?)    \n    //vec3 look_u = camera_pos + vec3(-sin(azimuth), cos(azimuth), 0.0);\n    //vec3 look_v = camera_pos + vec3(sin(altitude)*-cos(azimuth), sin(altitude)*-sin(azimuth), cos(altitude));    \n\n    \n    // turns out analytically these aren't correct. so using cross instead -.-\n    vec3 look_u = normalize(cross(vec3(0.0, 0.0, -1.0), look_dir));\n    vec3 look_v = normalize(cross(camera_pos, look_u)); // is this faster?\n    // camera plane(origin of each pixel) -> barycentric?\n    \n    vec3 camera_plane;\n    vec3 ray_dir;\n    vec3 ray_origin;\n                        \n    if (FOV > 0.0){\n        // assume a pinhole camera.\n        // FOV is the horizontal fov, the given focal length becomes:\n        // the 1.0 is the sensor height.\n        float focal_length = 1.0/tan(radians(FOV*0.5));\n        \n        // the ro\n        camera_plane = camera_pos - (look_dir*focal_length) + ((look_u*uv.x) + (look_v*uv.y))*-1.0; // inverted here to see upright\n        ray_origin = camera_pos;\n        \n        // the rd\n        ray_dir = camera_pos-camera_plane;\n        ray_dir = normalize(ray_dir);        \n    }\n    \n    else {\n        // negative FOV values are interpreted as a sensor size for a orthographic camera!\n        // horizontal sensor size, -1 would be something sensible... everything else is far away\n        float sensor_size = FOV*0.5*-1.0;\n        camera_plane = camera_pos + ((look_u*uv.x)+(look_v*uv.y))*sensor_size; // wider fov = larger \"sensor\"\n        ray_dir = look_dir;\n        ray_origin = camera_plane;\n    }\n    \n    \n    Ray camera = Ray(ray_origin, ray_dir, 1.0/ray_dir);\n    BoxHit res = AABB(vec3(0.0, sin(iTime*0.2), 0.0), vec3(0.5), camera);\n    \n    //res = Sphere(vec3(0.0), 0.4, camera);\n    BoxHit res2 = Sphere(vec3(0.0, 0.0, cos(iTime*0.4)), 0.4, camera);\n        \n    vec3 col = vec3(0.05);\n    \n    if (res.hit) {\n        col = res.entry_norm + vec3(0.5);\n        if (res.inside) {\n            //col = vec3(0.5);\n            col = res.exit_norm + vec3(0.5);\n        }\n    }\n    else {\n        //col = res.exit_norm + vec3(0.5);\n    }\n    \n    if (res2.hit && ((res2.entry_dist > res.exit_dist) || !res.hit) ) {\n        col = res2.entry_norm + vec3(0.5);\n            \n    \n    }\n    \n    \n    \n    fragColor = vec4(col, 1.0);\n    \n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "lXyyzR",
        "date": "1735848777",
        "viewed": 140,
        "name": "Persistent Music Visualizer",
        "username": "jakel101",
        "description": "to have some of the element be reactive over time, the persistence is done over time in a Buffer.\nChange the Music in Buffer A Channel1\nChange channel0 to be sampled nearest instead of linear\ndeveloped on 165 Hz, might look worse on 60!",
        "likes": 4,
        "published": 3,
        "flags": 32,
        "usePreview": 0,
        "tags": [
          "music",
          "visualizer",
          "infinity"
        ],
        "hasliked": 0,
        "retrieved": "2025-08-13T20:37:17.529453+00:00"
      },
      "renderpass": [
        {
          "inputs": [
            {
              "id": 257,
              "src": "/media/previz/buffer00.png",
              "ctype": "buffer",
              "channel": 0,
              "sampler": {
                "filter": "linear",
                "wrap": "repeat",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            }
          ],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "// Apache 2.0 no patents `.\u00b4\n\n// Image pass is mainly used for displaying the Buffer A \"background\"\n// Visualizer is purely done in Buffer A!\n// to change the music or try something different, change Channel1 in Buffer A!\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    vec2 uv = fragCoord/iResolution.xy;\n\n    vec4 bg = texture(iChannel0, uv);\n    \n    fragColor = vec4(bg.rgb, 1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        },
        {
          "inputs": [
            {
              "id": 35,
              "src": "/media/a/48e2d9ef22ca6673330b8c38a260c87694d2bbc94c19fec9dfa4a1222c364a99.mp3",
              "ctype": "music",
              "channel": 1,
              "sampler": {
                "filter": "linear",
                "wrap": "clamp",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            },
            {
              "id": 257,
              "src": "/media/previz/buffer00.png",
              "ctype": "buffer",
              "channel": 0,
              "sampler": {
                "filter": "linear",
                "wrap": "clamp",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            }
          ],
          "outputs": [
            {
              "id": 257,
              "channel": 0
            }
          ],
          "code": "// Buffer A does the \"animation\"\n// basic idea is to avoid any kind of integration and just use time to expand\n// and we hide the infinity by creating new \"particles\" as dots in the center\n// we might draw something on top of that in a different pass.\n\n//TODO: fake \"stars\"?\n\n# define TAU 6.283185\nfloat sdCircle(vec2 pos, float radius){\n    return length(pos) - radius;\n}\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    vec2 uv = fragCoord/iResolution.xy;    \n    float beat_wf = texelFetch(iChannel1, ivec2(1,0), 0).r; // the sample point might need to be changed \n    \n    vec4 col = vec4(0.02); // init color\n    col.a = 0.0; // do we need alpha compositing here?\n    \n    float speed = 0.998 - (0.008*beat_wf); // this number is influenced every frame by the sampled music    \n    vec2 st = uv-vec2(0.5);// texture sampling coordinates have to be moved than scaled\n    st *= speed;// -(length(st)*0.02); // positively or negatively warp space on the edges?    \n    //st *= mat2(cos(0.002), -sin(0.002), sin(0.002), cos(0.002)); // rotation?    \n    st += vec2(0.5);  // and finally moved again        \n    vec4 bg_scaled = texture(iChannel0, st);\n    //bg_scaled *= 0.997; // drop off over to highlight layers?\n    \n    vec2 center_uv = uv - vec2(0.5); // +sin(iTime)*0.1); // if you move this it get's really trippy\n    center_uv.x = abs(center_uv.x); // mirror horizontally\n    float phi = mod(atan(center_uv.x, center_uv.y), TAU)/TAU*2.0; // these are pseudo polar coordinates\n    float fft = texelFetch(iChannel1, ivec2(int(phi*512.0),1), 0).x;\n    \n    float shape_dist = sdCircle(center_uv, 0.2*fft);\n    float shape = smoothstep(0.008, 0.0, shape_dist); // the first value has a strong impact\n    \n    vec3 rainbow = vec3(sin(iTime + TAU*vec3(0.0, 0.33, 0.66))); // approximate TAU thirds for RGB rotation\n    \n    col = mix(col, vec4(rainbow,1.0), shape); // basically set the alpha\n    col.rgb = mix(bg_scaled.rgb, col.rgb, col.a);\n    \n    fragColor = vec4(col);\n}",
          "name": "Buffer A",
          "description": "",
          "type": "buffer"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "4XcyR2",
        "date": "1735523996",
        "viewed": 176,
        "name": "particles by density? (wip)",
        "username": "jakel101",
        "description": "I had some ideas for 3D voxels, so I am trying a 2D thing first... not sure where this will go-\n\nidea is end up with something emergent that approximates gravity",
        "likes": 5,
        "published": 3,
        "flags": 32,
        "usePreview": 0,
        "tags": [
          "simulation",
          "particles",
          "cellular"
        ],
        "hasliked": 0,
        "retrieved": "2025-08-13T20:37:17.529453+00:00"
      },
      "renderpass": [
        {
          "inputs": [
            {
              "id": 257,
              "src": "/media/previz/buffer00.png",
              "ctype": "buffer",
              "channel": 0,
              "sampler": {
                "filter": "nearest",
                "wrap": "repeat",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            }
          ],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "// Apache 2.0 no Patents _^-^_\n\n// Image pass just used for displaying right now...\n// maybe I will do stuff like color palettes or something.\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    vec2 uv = fragCoord/iResolution.xy;\n    vec4 values = texture(iChannel0, uv);\n    if (uv.x > 0.5) {\n        values.xy = values.xy*0.5;\n    }    \n    fragColor = vec4(values.yxz,1.0); //swaped rg to look better\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        },
        {
          "inputs": [
            {
              "id": 5,
              "src": "/media/a/8de3a3924cb95bd0e95a443fff0326c869f9d4979cd1d5b6e94e2a01f5be53e9.jpg",
              "ctype": "texture",
              "channel": 1,
              "sampler": {
                "filter": "mipmap",
                "wrap": "repeat",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            },
            {
              "id": 257,
              "src": "/media/previz/buffer00.png",
              "ctype": "buffer",
              "channel": 0,
              "sampler": {
                "filter": "nearest",
                "wrap": "repeat",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            }
          ],
          "outputs": [
            {
              "id": 257,
              "channel": 0
            }
          ],
          "code": "// Buffer A contains the data, the pass makes the calucaltions\n// setting up the iChannel0 input (=Buffer A) with nearest and repeat is important!\n\n\n//extremely fun parameter to experiment with\n//try numbers smaller than 1 as well!\n# define INERTIA 1.12\n\nvec4 init(vec2 uv){\n    // load some shape from texture for the initial distribution?\n    vec4 txt = texture(iChannel1, uv);\n    //return txt;\n    //txt = vec4(length(uv-vec2(0.5))); // simple pattern for a test\n    //return vec4(vec2(0.01), txt.b, 0.0); //very low initial velocity?\n    float init_dens = 0.5;\n    \n    return vec4(txt.rg-vec2(0.5), init_dens, 0.0);\n}\n\n\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    vec2 uv = fragCoord/iResolution.xy;\n    // load something simple?\n    // TODO: draw with the mouse also an option?\n    if (iFrame <= 2) {\n        fragColor = init(uv);\n        return;\n    }\n    \n    // load the data\n    vec4 prev = texelFetch(iChannel0,ivec2(fragCoord), 0);\n    // unpack components\n    vec2 vel = prev.xy;\n    float density = prev.z; //(blue)\n    //prev.w; // currently unused?\n    \n    \n    // idea: density accumulates (gravity?)\n    // but we only look at the near pixel neighbors\n    // density gets removed or added based on density of direct neighbors\n    // only if, and proportional to the direction they are pointing at me\n    \n    float next_d = density;\n    next_d *= 1.0 - clamp(length(vel), 0.0, INERTIA); // this much \"moves away\"\n    vec2 next_vel = vel; // keep track (start with current I guess).\n    float largest_d = 0.0;\n    for(int i = -1; i<2; i++){\n        // i is x neighborhood?\n        // j is y neighborhood!\n        // we start at bottom left!\n        for(int j = -1; j<2; j++){            \n            if (i==0 && j==0){\n                continue;\n            }\n            // ensure it wraps around!\n            ivec2 sample_st = ivec2(fragCoord)+ivec2(i,j);\n            sample_st.x = int(mod(float(sample_st.x),iResolution.x));\n            sample_st.y = int(mod(float(sample_st.y),iResolution.y));\n            vec4 neighbor = texelFetch(iChannel0, sample_st, 0);\n            \n            // n_prefix for neighbor ::\n            float n_d = max(0.0,neighbor.z); //this shouldn't ever be negative anyway!!\n            vec2 n_v = neighbor.xy;\n            \n            // 8 neighbors, with the following normalized vectors\n            // (-0.5, 0.5)  (0.0, 1.0)  (0.5, 0.5)\n            // (-1.0, 0.0)  [ our pov]  (1.0, 0.0) \n            // (-0.5,-0.5)  (0.0,-1.0)  (0.5,-0.5)\n            // normalized might actually be 1/sqrt(2)\n            vec2 n_dir = normalize(vec2(i, j)); //direction towards that neighbor\n            // maybe the corners need to be sqrt(2) length? (it's normalized anyway)\n            //if (i*j > 0) n_d /= sqrt(2.0);\n            \n            next_d += max(0.0, dot(n_dir, normalize(n_v))) * n_d; //accumulating neighboring densities here. inverting n_d should be done?!?! \n            // next vel is weighted sum of neighbors density and direction.\n            next_vel += n_dir * (n_d * 0.125);\n            \n        }        \n    }\n    \n    //next_vel *= 0.99999; //slow down over time to avoid acceleration?        \n    \n    \n    fragColor = vec4(next_vel.xy, clamp(next_d, 0.0, 20.0), 0.0);\n}",
          "name": "Buffer A",
          "description": "",
          "type": "buffer"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "4XdcRr",
        "date": "1734655998",
        "viewed": 119,
        "name": "undefined bitshift visulizer",
        "username": "jakel101",
        "description": "the spec says that bitshifts greater than 31 bits are undefined. and the signed bit gets pushed away to.\nSo what do you see here?",
        "likes": 0,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "visualization",
          "debug"
        ],
        "hasliked": 0,
        "retrieved": "2025-08-13T20:37:17.529453+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "// Apache 2.0 no patents \u00b0!\u00b0\n\n# define LOW -16\n# define HIGH 48\n// shows the range from what happens with\n// 1. negative bitshifts LOW..-1]\n// 2. defined bitshifts 0..31]\n// 3. undefined bitshifts [32..HIGH\n// 4. uint vs int (left vs right)\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    vec2 uv = fragCoord/iResolution.xy;    \n    \n    // the initial value we are shifting (up)\n    int init = floatBitsToInt((iMouse.x/iResolution.x)+iTime); // consider pausing\n    \n    const float range = float(abs(LOW-HIGH));\n    int x_shift = int(mod(uv.x * range*2.0, range))+LOW; // so it goes LOW..HIGH twice\n    int y_bit = int(uv.y*32.0); // sorta the y index\n    \n    vec3 col = vec3(0.06); // background == \"off\" color\n    if (x_shift == 0) col.g = 0.5; // visualize the unshifted col\n    bool bit_mask; // where bits are on or off....\n    \n    // TODO: calulate the bitmask for uint and int everywhere so you can check for differences!\n    // left half int\n    if (uv.x < 0.5){\n        int val = int(init);\n        val <<= x_shift;\n        bit_mask = bool(val&(1<<y_bit)); // get the bit state per cell like this\n        if (y_bit == 31) col.b = 0.5; // visualize the sign bit\n    \n    }\n    // right half uint\n    else {\n        uint val2 = uint(init);\n        val2 <<= x_shift;\n        bit_mask = bool(val2&(1u<<y_bit));\n        col.r = 0.5; // indicate the uint side better\n    }\n    \n    \n    vec3 on_col = vec3(0.95, 0.95, 0.5);\n    col = mix(col, on_col, float(bit_mask)); // actual color happens here!\n    // little \"bulb\" shape for the cells to make it easier to count?\n    col *=vec3(1.4-length(fract(vec2(uv.x * 2.0 * range, uv.y * 32.0))-vec2(0.5))*1.0);\n    //col.b = float(y_bit)/32.0;\n    fragColor = vec4(col,1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "XXdyRn",
        "date": "1734642443",
        "viewed": 91,
        "name": "operator precedence: << and + ",
        "username": "jakel101",
        "description": "so what do you see? and what is correct according to the spec? https://registry.khronos.org/OpenGL/specs/es/3.0/GLSL_ES_Specification_3.00.pdf 5.1 Operator precedence has addition above bitwise shift\ncorrect should be bot left like top left/right?",
        "likes": 0,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "test",
          "bug"
        ],
        "hasliked": 0,
        "retrieved": "2025-08-13T20:37:17.529453+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "void mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    vec2 uv = (2.0 * fragCoord - iResolution.xy)/iResolution.y;\n    int val = 128;\n    \n    // first bitshift then addition\n    if (uv.x > 0.0 && uv.y > 0.0) { //top right\n        val = val << 2;\n        val = val + 254;\n    }    \n    // here addition clearly happens first\n    else if (uv.x > 0.0 && uv.y < 0.0) { // bot right\n        val = val << (2 + 254);\n    }\n    \n    // this is the questionable bit\n    else if (uv.x < 0.0 && uv.y < 0.0) { // bot left\n        val = val << 2 + 254;\n    }\n    \n    // here it's first shift and then addtion\n    else if (uv.x < 0.0 && uv.y > 0.0) { //top left\n        val = (val << 2) + 254;\n    }\n    \n    vec3 col = vec3(float(val)/2048.0);\n    fragColor = vec4(col,1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "4cyBzy",
        "date": "1734198534",
        "viewed": 116,
        "name": "Ray(line) distance functions",
        "username": "jakel101",
        "description": "mostly figuring this out myself, but pen and paper and some references help.\n\nDirected ray has an origin and direction. I use a single float as the direction in radians (but a point or vector would also work), 0 is top.",
        "likes": 1,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "2d",
          "math",
          "distance"
        ],
        "hasliked": 0,
        "retrieved": "2025-08-13T20:37:17.529453+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "# define PI 3.141592\nfloat udRay(vec2 pos, float ang){    \n    ang *= PI*2.0; // from radians to TAU%    \n    vec2 dir = vec2(sin(ang), cos(ang)); // vector along the ray\n    return length(pos - dir*max(dot(pos,dir), 0.0));    \n}\n\n//TODO: signed distance to easily know which side you are on?\nfloat sdRay(vec2 pos, float ang){\n    float dist = udRay(pos, ang);\n    // extract this logic?\n    ang *= PI*2.0;\n    vec2 ortho = vec2(cos(ang), -sin(ang));\n    return dist * sign(dot(pos, ortho));\n}\n\n//TODO: with normals, is this signed?\nvec3 gdRay(vec2 pos, float ang){\n    // extract again\n    float dist = sdRay(pos, ang);\n    ang *= PI*2.0;\n    vec2 ortho = vec2(cos(ang), -sin(ang));\n    float sgn = sign(dot(pos, ortho));\n    \n    vec2 norm = ortho*sgn; // just init, not sure yet\n    \n    // just pointing away from the origin behind the ray?\n    vec2 dir = vec2(sin(ang), cos(ang));\n    if (dot(pos, dir) < 0.0) norm = pos;    \n    return vec3(dist, normalize(norm));\n}\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    vec2 uv = (2.0*fragCoord-iResolution.xy)/iResolution.y;\n    vec2 mou = (2.0*iMouse.xy-iResolution.xy)/iResolution.y;\n\n    float line_size = fwidth(uv.y)*1.5;    \n    vec3 col = vec3(0.02);\n\n    // selection to show just one of them at a time changes every 2 seconds.\n    float sel = floor(mod(iTime*0.5, 3.0));\n\n    float u_ray = udRay(uv, iTime);\n    if (sel != 0.0) u_ray = 1.0; // hide this one easily.\n    vec3 u_col = vec3(0.7, 0.2, 0.4);\n    col = mix(col, u_col, clamp(clamp(-cos(u_ray*100.0), 0.0, 1.0) * (1.0 - (u_ray*2.0)), 0.0, 1.0));\n    col.r = mix(col.r, 1.0, smoothstep(line_size, 0.0, u_ray));\n\n    float s_ray = sdRay(uv, iTime);\n    if (sel != 1.0) s_ray = 1.0; // hide this one easily.\n    vec3 s_col = vec3(0.2, 0.8, float(s_ray < 0.0)*0.4 + 0.2);\n    col = mix(col, s_col, clamp(clamp(-cos(s_ray*100.0), 0.0, 1.0) * (1.0 - (abs(s_ray)*2.0)), 0.0, 1.0));\n    col.g = mix(col.g, 1.0, smoothstep(line_size, 0.0, abs(s_ray)));\n    \n    vec3 g_ray = gdRay(uv, iTime);\n    if (sel != 2.0) g_ray.x = 1.0; //TODO: how to hide this one?    \n    col.gb = mix(col.gb, g_ray.gb, float(sel == 2.0));\n    col.b = mix(col.b, 1.0, smoothstep(line_size, 0.0, abs(g_ray.x)));\n\n    // little crosshair\n    col += smoothstep(line_size, 0.0, abs(uv.x));\n    col += smoothstep(line_size, 0.0, abs(uv.y));\n    fragColor = vec4(col,1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "XctfWS",
        "date": "1733434292",
        "viewed": 115,
        "name": "Angle in revolutions",
        "username": "jakel101",
        "description": "took me a while to figure out that atan exist with two parameters too. the rescaling with mod is a bit odd, taken from here: https://www.shadertoy.com/view/4s3BR8",
        "likes": 1,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "trigonometry"
        ],
        "hasliked": 0,
        "retrieved": "2025-08-13T20:37:17.529453+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "# define PI 3.141592\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    // uv from -1..1\n    vec2 uv = (2.0*fragCoord - iResolution.xy)/iResolution.y;\n    vec3 col;\n    \n    // crosshair\n    col.r = smoothstep(fwidth(uv.y), 0.0, min(abs(uv.x),abs(uv.y)));\n    \n    // angle value in revolutions 0..1\n    float val = mod(atan(uv.x, uv.y), PI*2.0);\n    col.g += val/(PI*2.0);\n    \n    // visualizing section\n    float sec = fract(iTime);\n    col.b = smoothstep(sec, sec-fwidth(uv.y), col.g);\n    \n    fragColor = vec4(col,1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "M3fyR8",
        "date": "1733178754",
        "viewed": 126,
        "name": "Party Lights for Live Coding!",
        "username": "jakel101",
        "description": "hommage to TM Rave!\ncontributions, golfing welcome, use as you please!",
        "likes": 0,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "lights",
          "overlay",
          "party",
          "golf"
        ],
        "hasliked": 0,
        "retrieved": "2025-08-13T20:37:17.529453+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "// Apache 2.0 no patetns\u00b0^\u00b0 remixes welcome!\n/* Fragment shader implementation of the TM Rave plugin for Trackmania\n* link to original plugin: https://openplanet.dev/plugin/tmrave\n* Meant for your live coding sessions where you want a bit more to show for the audience\n* no more pausing time while coding!\n* reference implementation at https://github.com/TheMatrixPill/tmrave/tree/main/source (MIT licensed)\n* default settings are hard coded here: 2 lights, two corners, 0.2 intensity, no randomness\n*/\n#define PI 3.14159\nvec4 rave(vec2 uv){\n    // uv is expected to be screen space from 0.0 to 1.0, aspect ratio irrelevant.\n    float width = 0.15;\n    float edge = 1.5/iResolution.y;\n    \n    // top left\n    float phase1 = abs(fract(iTime)-0.5)*PI;\n    vec2 pos1 = vec2(0.0, 1.0);\n    vec2 n1 = vec2(sin(phase1 - width), cos(phase1 - width));\n    vec2 n2 = vec2(sin(phase1 + width), cos(phase1 + width));\n    float e1 = dot(uv-pos1, n1);\n    float e2 = dot(uv-pos1, n2);\n    float mask1 = clamp(smoothstep(edge, 0.0, max(e1,-e2)), 0.0, 1.0);\n    \n    // TODO: can you not repeat yourself ... will sleep through the idea once.\n    // top left\n    float phase2 = (abs(fract(iTime+0.5)-0.5)+0.5)*PI;\n    vec2 pos2 = vec2(1.0, 1.0);\n    vec2 n3 = vec2(sin(phase2 - width), cos(phase2 - width));\n    vec2 n4 = vec2(sin(phase2 + width), cos(phase2 + width));\n    float e3 = dot(uv-pos2, n3);\n    float e4 = dot(uv-pos2, n4);\n    float mask2 = clamp(smoothstep(edge, 0.0, max(e3,-e4)), 0.0, 1.0);\n    \n    float mask = mask1 + mask2;\n    // RGB rotation like this?\n    vec4 col = vec4(normalize(sin(PI*(iTime+vec3(0.0, 2.0/3.0, 4.0/3.0)))), 1.0);\n    col *= mask;\n    col *= 0.2; // default light intensity\n    return col;\n}\n\n// your normal main funciton\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    vec2 uv = fragCoord/iResolution.xy;\n    vec3 col = vec3(0.05);\n    // your normal output\n    fragColor = vec4(col,1.0);\n    // sneaky addition of party lights, do this early for enjoyment!\n    fragColor += rave(fragCoord/iResolution.xy);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "lfdBz8",
        "date": "1732897530",
        "viewed": 47,
        "name": "ideas for caleb",
        "username": "jakel101",
        "description": "trying to make a reference idea for certain stream\n\nnot done yet. published unfinished - might revisit in a year",
        "likes": 0,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "2d",
          "game",
          "textures"
        ],
        "hasliked": 0,
        "retrieved": "2025-08-13T20:37:17.529453+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "// Apache 2.0 license, no patents :^\n// ideas of what could be done with shadercoding.\n/* desgin brief:: (cont.)\nvim colorschemes, trees, tokyo?  0:22:45 https://x.com/ThePrimeagen/status/1861750821504827569\nfractal trees? 1:08:45 https://x.com/ThePrimeagen/status/1861750821504827569\nHollow Knight style 5:00:11 https://x.com/ThePrimeagen/status/1854155062282531119\n*/\n\n\n// [ utils], partly done myself, partly copied\n\nvec3 hex2col(uint hex){\n    uint r = hex >> 16;\n    uint g = hex >> 8 ^ r<<8;\n    uint b = hex ^ r << 16 ^ g << 8;\n    \n    vec3 col;\n    col.r = float(r)/255.0;\n    col.g = float(g)/255.0;\n    col.b = float(b)/255.0;\n    return col;\n}\n\n// A pseudo-random number generator\n// \\param seed Numbers that are different for each invocation. Gets updated so\n//             that it can be reused.\n// \\return Two independent, uniform, pseudo-random numbers in [0,1) (u_0, u_1)\nvec2 hash22(in uvec2 seed) {\n    // This is PCG2D: https://jcgt.org/published/0009/03/02/\n    seed = 1664525u * seed + 1013904223u;\n    seed.x += 1664525u * seed.y;\n    seed.y += 1664525u * seed.x;\n    seed ^= (seed >> 16u);\n    seed.x += 1664525u * seed.y;\n    seed.y += 1664525u * seed.x;\n    seed ^= (seed >> 16u);\n    // Convert to float. The constant here is 2^-32.\n    return vec2(seed) * 2.32830643654e-10;\n}\n\n//todo: draw function with col inout and object col(already texture fitted), alpha\nvoid draw(inout vec4 col, vec4 obj, float alpha){\n    // col.a and obj.a holds depth\n    float front = float(obj.a > col.a);\n    col = mix(col, obj, clamp(0.0, 1.0, alpha*front));\n}\n\n\n// [ distance functions ]\n\nfloat sdCircle(vec2 pos, float rad){\n    return length(pos) -rad;\n}\n// with help from https://youtu.be/62-pRVZuS5c?si=cGF1eZBKKs1lXPHG\nfloat sdBox(vec2 pos, float width, float height){\n    vec2 dist = abs(pos) - vec2(width, height);\n    \n    return length(max(dist, 0.0)) + min(max(dist.x,dist.y),0.0);\n}\n// Isosceles  triangle(ref: https://www.shadertoy.com/view/MldcD7)\nfloat sdTriangleIsosceles( in vec2 p, in vec2 q )\n{\n    p.x = abs(p.x);\n    vec2 a = p - q*clamp( dot(p,q)/dot(q,q), 0.0, 1.0 );\n    vec2 b = p - q*vec2( clamp( p.x/q.x, 0.0, 1.0 ), 1.0 );\n    float s = -sign( q.y );\n    vec2 d = min( vec2( dot(a,a), s*(p.x*q.y-p.y*q.x) ),\n                  vec2( dot(b,b), s*(p.y-q.y)  ));\n    return -sqrt(d.x)*sign(d.y);\n}\n\n// simple or random trees?\n// maybe fractals?\n// one ref: https://www.youtube.com/watch?v=LLZPnh_LK8c\nfloat sdTree(vec2 pos, float height){\n    // pos is kinda the position of the root\n    pos.y -= height;\n    float trunk = sdTriangleIsosceles(pos, vec2(height/20.0, -height));\n    float dist = trunk;\n    // tbd maybe a small loop or fract?\n    int num_leaves = int(height*(3.0+height))+1;\n    for (int i = 0; i < num_leaves; i++){\n        float width = 0.01+0.05*float(i+1);\n        float height = -0.08*float(i+i+1);\n        float leaf = sdTriangleIsosceles(pos - vec2(0.0, (-cos(abs(pos.x*2.9)-width*1.5))+1.0), vec2(width, height));\n        pos.y += 0.002*float(i+i*num_leaves);\n        dist = min(dist, leaf);\n    }\n    \n    return dist;\n    \n}\n\n\n// [ constructions? ]\n\n// instead of the fake 3D stuff make this an element directly with alpha mask?\nvec4 buildings(vec2 pos, vec3 wall_col, vec3 window_col, vec3 light_col){\n    float num_buildings = 2.5; //scale with uv.x so it's lie 3x or something\n    pos.x += iTime*0.1; // pseudo animation\n    vec2 build_uv = vec2(fract(pos.x*num_buildings)-0.5, pos.y+1.0);\n    // speudo hash\n    float height = hash22(uvec2(floor(pos.x*num_buildings)+100.0, 544)).x*1.6 + 0.5;\n    float building_dist = sdBox(build_uv, .45, height);\n    \n    // real numbers to hash after\n    float floors = (build_uv.y - height)*floor(height+10.0);\n    float rooms = build_uv.x*(1.0/0.45)*floor(height+3.5);\n    vec2 window_uv = fract(vec2(rooms,floors))-vec2(0.5);\n    float window_id = fract(dot(hash22(uvec2(rooms+254.0, floors+987.0)*uint(height*953.702)),vec2(12.34,56.78))); // bad hashes again\n    float window_dist = sdBox(window_uv,0.25, 0.3);\n    float window_mask = smoothstep(0.01, 0.0, window_dist);\n    \n    float lights_mask = float(window_id > 0.9);\n\n    float alpha = clamp(smoothstep(0.01, 0.0,building_dist), 0.0, 1.0);\n    vec3 col = wall_col;\n    col = mix(col, window_col, window_mask);\n    col = mix(col, light_col, lights_mask*window_mask);\n    \n    \n    //col = vec3(window_id);\n    return vec4(col, alpha);\n}\n\n\n// tbd with projection and sampling for craters?\nvec4 moon(vec2 pos, vec3 moon_col, vec3 crater_col){\n    vec3 col = moon_col;\n    float alpha = 0.0;\n    return vec4(col, alpha);\n}\n\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    // uv from -1..1 for wide screen\n    vec2 uv = (2.0 * fragCoord - iResolution.xy)/iResolution.y;\n\n    // scene elements as distance functions\n    // .z component is depth/layer for potential parallax\n    vec3 moon_pos = vec3(-0.6, 0.3, -5.0);\n    float moon_dist = sdCircle(uv-moon_pos.xy, 0.4);\n    vec3 platform_pos = vec3(-0.7, -1.0, 1.0);\n    float platform_dist = sdBox(vec2(fract(uv.x+(iTime+3.0)*0.2)-0.5,uv.y - platform_pos.y), 0.4, 0.1);\n    vec3 caleb_pos = vec3(-1.0, max(-0.8, -(pow(mod(iTime, 5.0)-2.0,2.0))), 1.0);\n    float caleb_dist = sdBox(uv - caleb_pos.xy, 0.05, 0.1);\n    vec3 tree_pos = vec3(-iTime*0.2, -1.0, -2.0);\n    float tree_dist = sdTree(vec2(fract(uv.x+iTime*0.15)-0.5, uv.y - tree_pos.y) , sin((floor(uv.x+iTime*0.15))*444.0)*0.3+1.0);\n\n\n    // colors: https://github.com/folke/tokyonight.nvim/blob/main/lua/tokyonight/colors/night.lua\n    vec3 col_bg = hex2col(0x1A1B26u);\n    vec3 col_bg_dark = hex2col(0X16161Eu);\n    // more colors = https://github.com/folke/tokyonight.nvim/blob/main/lua/tokyonight/colors/storm.lua\n    vec3 col_blue = hex2col(0x7AA2F7u); // platform\n    vec3 col_blue0 = hex2col(0x3D59A1u);\n    vec3 col_blue1 = hex2col(0x2AC3dEu);\n    vec3 col_fg = hex2col(0xC0CAF5u); // cursor?\n    vec3 col_fg_gutter = hex2col(0x3B4261u);\n    vec3 col_orange = hex2col(0xFF9E64u);\n    vec3 col_yellow = hex2col(0xE0AF68u); // moon\n    \n    \n    vec4 bg_buildings = buildings(uv, col_blue0, col_bg, col_orange);\n    // gradient for the background\n    vec3 col = mix(col_fg_gutter, col_bg, uv.y);\n    \n    col = mix(col, col_yellow, smoothstep(0.05, 0.0, moon_dist));\n    col = mix(col, bg_buildings.rgb, bg_buildings.a);\n    col = mix(col, col_bg_dark, smoothstep(0.01, 0.0, tree_dist));\n    col = mix(col, col_fg, smoothstep(0.005, 0.0, caleb_dist));// * max(floor(mod(iTime*(1.0/0.53)-1.0,2.0)),float(caleb_pos.y > -0.8))); // blinking cursor?\n    col = mix(col, col_blue, smoothstep(0.005, 0.0, platform_dist));\n    \n    //col = bg_buildings.rgb;\n    fragColor = vec4(col,1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "MfKcWt",
        "date": "1732834986",
        "viewed": 142,
        "name": "fake 3D pipes",
        "username": "jakel101",
        "description": "trying to figure this out on my own... Motivated by this video https://youtu.be/OV_ZN-8uy4w (segment at 4:45)\n(change SCALE to other values?)\nmouse moves the \"light source\", time animates it's height.",
        "likes": 0,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "2d",
          "texture",
          "light",
          "pattern"
        ],
        "hasliked": 0,
        "retrieved": "2025-08-13T20:37:17.529453+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "#define PI 3.141592\n#define SCALE 4.0\n\n// gradient distance (distance + norm) for a Ray.\n// .x is signed distance\n// .yz is normals\n// ang in radians\nvec3 gdRay(vec2 pos, float ang){\n    ang *= PI*2.0;\n    vec2 dir = vec2(sin(ang), cos(ang));\n    vec2 norm = pos - dir * max(dot(pos, dir), 0.);\n    float dist = length(norm);\n    return vec3(dist * sign(dot(pos, vec2(dir.y, -dir.x))), norm / dist);\n}\n\n\n// pipe tile\n// pos is the local area of this tile from 0..1\n// start is a angle of where the pipe begins 0..1\n// stop is also an angle of where the pipe stops.\n// also outputs an alpha channel either 0 or 1\nvec4 pipe_tile(vec2 pos, float start, float stop, vec3 light_angle){\n    // reshape each tile to be -1..1 again centered\n    vec2 uv = 2.0*pos - vec2(1.0);\n    uv *= 2.0;\n    \n    vec3 g_start = gdRay(uv, start);\n    vec3 g_stop = gdRay(uv, stop);\n    float dist = min(abs(g_start.x), abs(g_stop.x));\n    if (dist > 1.0) return vec4(0.0);\n    // min based on distance, maybe a smoother idea?\n    vec2 normals = (abs(g_start).x < abs(g_stop).x)?g_start.yz:g_stop.yz;\n    // normals = mix(g_start.yz,g_stop.yz,0.5+max(abs(g_start).x,1.0)-max(abs(g_stop).x,1.0));\n    \n    // hemisphere via just distance.\n    float height = sqrt(1.0-dist*dist);    \n    // normals need to be denormalized by distance and the normalized together with height\n    vec3 norm = normalize(vec3(normals*dist, height));\n    \n    \n    float light_intensity = max(0.0,dot(normalize(light_angle), norm));\n    vec3 col = vec3(0.1, 0.2, 0.8); // blue pipe\n    col = mix(col, vec3(0.8, 0.2, 0.4), float(abs(g_start.x)==abs(g_stop.x))); // red part buggy overlap\n    col = mix(col, vec3(0.1, 0.9, 0.3), float(abs(g_start.x)<abs(g_stop.x))); // green part\n    col *= light_intensity;\n    \n    vec3 ambient = vec3(0.05);\n    return vec4(vec3(col + col*ambient), 1.0); // todo alpha based on the expression above?\n}\n\n// simple version to use as a reference?\nvec4 ball_tile(vec2 pos, vec3 light_angle){\n    //shift tile space to be -1..0 again\n    vec2 uv = 2.0*pos - vec2(1.0);\n    uv *= 2.0;\n    float ball_dist = length(uv) -1.0;\n    \n    vec3 height = vec3(sqrt(1.0-pow(uv.x,2.0) - pow(uv.y, 2.0)));\n    vec3 norm = vec3(uv.x, uv.y, height);\n    \n    float light_intensity = max(0.0,dot(normalize(light_angle), norm));\n    vec3 col = vec3(0.15, 0.25, 0.9);\n    vec3 ambient = vec3(0.05);\n    \n    return vec4(vec3(col*light_intensity + col*ambient), 1.0)*step(0.0, -ball_dist);\n}\n\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    // the uv is centered\n    vec2 uv = (2.0 * fragCoord - iResolution.xy)/min(iResolution.x, iResolution.y);\n    vec2 mou = (2.0 * iMouse.xy - iResolution.xy)/min(iResolution.x, iResolution.y);\n    uv *= (SCALE/2.0);\n    mou *= (SCALE/2.0);\n    int tileID = int(floor(uv.x + SCALE/2.0) + floor(uv.y + SCALE/2.0) * SCALE);\n    \n    // per tile\n    vec3 light_angle = vec3(mou-floor(uv)-vec2(0.5), (sin(iTime)+1.0));\n    \n    vec3 col = vec3(0.05);\n    vec4 pipes = vec4(0.0);\n    vec2 tile_angle = vec2(floor(float(tileID)/SCALE)*float(1.0/(SCALE*2.0)),fract(float(tileID)/SCALE)*0.5+0.5);\n    //tile_angle.x += 0.2*iTime;\n    pipes += pipe_tile(fract(uv), tile_angle.x, tile_angle.y, light_angle);\n        \n    col = mix(col, pipes.rgb, pipes.a);\n    if (abs(uv.x) >= SCALE/2.0) col = ball_tile(fract(uv), light_angle).rgb; //col = vec3(0.0);\n    \n    \n    fragColor = vec4(vec3(col),1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "Xfyyzd",
        "date": "1732231413",
        "viewed": 120,
        "name": "fake shadow cone?",
        "username": "jakel101",
        "description": "getting practice in by writing shaders purely from my head of some ideas.",
        "likes": 3,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "2d",
          "shadow"
        ],
        "hasliked": 0,
        "retrieved": "2025-08-13T20:37:17.529453+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "// Apache 2.0 no patents\nfloat sdCircle(vec2 pos, float rad){\n    return (length(pos) - rad);\n}\n\nfloat sdPlane2D(vec2 pos, vec2 norm, float b){\n    // line is orthogonal to the normal vector with offset b\n    // b != length(norm) to allow for lines through the origin of different rotations\n    // distance to that divider, negative for one side, positive for the other\n    vec2 ortho = normalize(norm);\n    return dot(ortho, pos)-b;\n}\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    vec2 uv = (2.0 * fragCoord - iResolution.xy)/min(iResolution.x, iResolution.y);\n    vec2 mou = (2.0 * iMouse.xy - iResolution.xy)/min(iResolution.x, iResolution.y);\n    \n    // positions\n    float ground_height = -0.1 - 0.2*sign(uv.x); // not exact\n    float ball_size = 0.1;\n    vec2 ball_pos = (0.8*vec2(sin(iTime), -cos(iTime)));\n    if (sign(iMouse.z) > 0.0){\n        ball_pos = mou;\n    }\n    float ball_dist = sdCircle(uv - ball_pos, ball_size);\n    float floor_dist = sdPlane2D(uv,vec2(0.0, -1.0), -ground_height);\n\n    // shadow via a 2nd circle, based on globals - not ideal\n    float ball_height = max(0.0, ball_pos.y - ground_height);\n    vec2 shadow_pos = ball_pos;\n    shadow_pos.y = min(shadow_pos.y - ball_size, -1.0 * (shadow_pos.y + ball_size - ground_height) + ground_height);\n    float shadow_dist = sdCircle(uv - shadow_pos, ball_size + sqrt(ball_height+1.0)-1.0);\n\n    // object masks\n    float floor_mask = smoothstep(0.0, 0.01, floor_dist+abs(0.03*sin(uv.x*150.0)));\n    float ball_mask = smoothstep(0.0, 0.01, -ball_dist);\n    float shadow_mask = smoothstep(0.0,  0.01 +ball_height, -shadow_dist);\n    \n    // colors/textures\n    vec3 col = vec3(0.05, 0.3, 0.6*(1.5+uv.y)); // \"sky\" / background\n    vec3 floor_col = vec3(0.3, 0.65+0.2*abs(uv.x), 0.2);\n    vec3 ball_col = vec3(0.9, 0.2, 0.3);\n    \n    // color mixing\n    col = mix(col, floor_col, floor_mask);\n    col += -0.5 * shadow_mask * floor_mask; // adds shadow just to the floor here?\n    col = mix(col, ball_col, ball_mask);\n\n    fragColor = vec4(col,1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "XcVyDW",
        "date": "1731888580",
        "viewed": 140,
        "name": "experiments with squish",
        "username": "jakel101",
        "description": "[mouse control on]\njust trying to come up with some implementation of squishing myself... not quite sure what's possible\nwant to extend this to 3D one day and also use in a physics simulation...",
        "likes": 2,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "2d",
          "physics",
          "amorphous"
        ],
        "hasliked": 0,
        "retrieved": "2025-08-13T20:37:17.529453+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "// Apache 2.0\n// no patents :^\n\n\nfloat sdCircle(vec2 pos, float rad){\n    return (length(pos) - rad);\n}\n\n\nfloat sdFloor(vec2 pos, float height){\n    // normal?\n    // return normalize(vec2(0.0, 1.0));\n    return pos.y - height;\n}\n\n// a more general variant would take a direction vector as input\n// such as the normal of the collision? and then squish in the perpedicular of that\nfloat sdSquish(vec2 pos, float mag, float rad){\n    // squished space transform?\n    mag = 1.0 - mag;\n    vec2 st = vec2(pos.x*mag, pos.y/mag);\n    float ball = sdCircle(st, rad);\n    return ball;\n}\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    // Normalized pixel coordinates (from -1 to 1)\n    vec2 uv = (fragCoord * 2.0 - iResolution.xy)/min(iResolution.x, iResolution.y);\n    vec2 mou = (iMouse.xy * 2.0 - iResolution.xy)/min(iResolution.x, iResolution.y);\n\n    vec2 ball_pos = 0.6*vec2(sin(iTime), cos(iTime));\n    float ball_size = 0.1;\n    if (sign(iMouse.z) > 0.0){\n        ball_pos = mou;\n    }\n    float floor_height = -0.35 + sin(uv.x*30.0)*0.005; //remove the sin to get a difference experience\n    vec2 squish_pos = ball_pos;\n    \n    // this should probably not be constant and contain some part of uv.y to make the\n    // squish less uniform.\n    float squish_depth = max(0.0,floor_height-ball_pos.y+ball_size);\n    if (squish_depth > 0.0) {\n        squish_pos.y = floor_height + (ball_size*(1.0 - squish_depth));\n    }\n    \n    float ball_dist = sdCircle(uv - ball_pos, ball_size);\n    float floor_dist = sdFloor(uv, floor_height);\n    float squish_dist = sdSquish(uv - squish_pos, squish_depth, 0.1);\n    \n    \n    // having some fun with the textures\n    vec3 col = vec3(0.01);\n    col += max(0.0,.1-fract(abs(uv.x*2.5)));\n    col += max(0.0,.1-fract(abs(uv.y*2.5))); //background lines\n    vec3 ball_col = vec3(0.1, 0.1+abs(cos(ball_dist*80.0)), 0.3);\n    vec3 floor_col = normalize(vec3(0.1+0.05*abs(sin(uv.x*2.0)+smoothstep(0.01, 0.4,(cos(uv.y*4.0)))), min(0.3,uv.y-1.5*floor_height), 0.05));\n    vec3 squish_col = vec3(0.05, 0.2, squish_depth);\n    \n    // color mixing with lazy alpha belnding\n    col = mix(col, floor_col, smoothstep(0.01, .0, floor_dist));\n    col = mix(col, ball_col, smoothstep(0.01, 0.0, ball_dist)*0.8);\n    col = mix(col, squish_col, smoothstep(0.01, .0, squish_dist)*0.9);\n\n    fragColor = vec4(col,1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "X3lfW2",
        "date": "1728936073",
        "viewed": 79,
        "name": "a little planet? (WIP)",
        "username": "jakel101",
        "description": "inspired by the render at 11:40 in this video: https://www.youtube.com/watch?v=o879xRxmwmU\nTrying to figure out how to map noise to a sphere and use that in raymarching some shells... but ended up just having noise in the whole volume ....",
        "likes": 0,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "raymarching",
          "noise",
          "spheres"
        ],
        "hasliked": 0,
        "retrieved": "2025-06-05T23:49:51.807010+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "// Apache 2.0 license\n// sorta work in progress\n\n\n// constants/defines?\nconst int MAX_STEPS = 128;\n\n// might be horribly unstable and not fit for this scale.\nfloat hash31(in vec3 a){\n    //return texture(iChannel0, 0.9*a).r; // shortcut by sampling noise instead..\n    vec3 b = a *vec3(54.1122, 123.532, 05.001);\n    b = fract(b + 1.376)-91.12;\n    return fract(dot(a-b,b)+0.43);\n}\n\n// 3d gradient noise??\nfloat noise(in vec3 p){\n    vec3 i = floor(p);\n    vec3 f = fract(p);\n    \n    // 8 corners of a cube\n    float vLLL = hash31(i + vec3(0.0,0.0,0.0));\n    float vLLH = hash31(i + vec3(0.0,0.0,1.0));\n    float vLHL = hash31(i + vec3(0.0,1.0,0.0));\n    float vLHH = hash31(i + vec3(0.0,1.0,1.0));\n    \n    float vHLL = hash31(i + vec3(1.0,0.0,0.0));\n    float vHLH = hash31(i + vec3(1.0,0.0,1.0));\n    float vHHL = hash31(i + vec3(1.0,1.0,0.0));\n    float vHHH = hash31(i + vec3(1.0,1.0,1.0));\n    \n    // interpolated values in the different axis\n    float nLLz = mix(vLLL, vLLH, f.z);\n    float nLHz = mix(vLHL, vLHH, f.z);\n    float nHHz = mix(vHHL, vHHH, f.z);\n    float nHLz = mix(vHLL, vHLH, f.z);\n    \n    float nLyz = mix(nLLz, nLHz, f.y);\n    float nHyz = mix(nHLz, nHHz, f.y);\n    \n    float nxyz = mix(nLyz, nHyz, f.x);\n    \n    return nxyz;\n\n}\n\n// rotate around the one axis left untouched.\nmat2 rot2D( float angle){\n    float s = sin(angle);\n    float c = cos(angle);\n    return mat2(c, -s, s, c);\n}\n\n// is this a simple sphere? all we need?\nfloat sdSphere(vec3 pos, float radius){\n    return length(pos) - radius;\n}\n\n// can we analytically return normals as this is just spheres?\n// TODO: normals for shadows and phong\n\n\n// map might be a vec2 later, where we return distance and material ID or something\nvec2 map(vec3 pos){\n    int material = 0;\n    float dist = 1000.0; // init as far??\n    \n    if (pos.y <= -5.0) {\n        // very simple ground plane?\n        return vec2(0.0, 1.0);\n    }\n    \n    // different shells\n    float ball = sdSphere(pos, 1.0); // blue water\n    material = 2;\n    float ball2 = sdSphere(pos, 1.0 + (0.05)*float(noise(pos*5.0)>0.5)); // green terrain?\n    if (ball2 < ball) material = 3;\n    dist = min(ball, ball2);\n    \n    \n    vec3 cloud_pos = pos;\n    cloud_pos.xz = pos.xz * rot2D(0.1*iTime);\n    float cloud_start = sdSphere(pos, 1.2); // lower edge of clouds, white?\n    float cloud_end = sdSphere(pos, 1.1 + (0.11)*float(noise(cloud_pos*8.0)>0.5)); // upper edge of clouds?\n        \n    float clouds = max(-cloud_start, cloud_end );\n    if (clouds < dist) material = 4;\n    //return vec2(clouds, 0.4);\n    \n    dist = min(dist, clouds);\n    \n    return vec2(dist, material);\n}\n\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    vec2 uv = (fragCoord * 2.0 - iResolution.xy)/iResolution.y;\n    vec2 m = (iMouse.xy * 2.0 - iResolution.xy)/iResolution.y;\n\n    vec3 col = vec3(0.05);\n    \n    \n    // camera setup\n    // ro = ray origin\n    vec3 ro = vec3(0.0, 0.0, -3.0);\n    // rd = ray direction // third element is the fov/focal length? Inverse pyramid!\n    vec3 rd = vec3(normalize(vec3(uv, 1.0)));\n    \n    // mouse control\n    ro.yz *= rot2D(-m.y);\n    rd.yz *= rot2D(-m.y);\n    \n    ro.xz *= rot2D(-m.x);\n    rd.xz *= rot2D(-m.x);\n    \n    \n    float total_dist = 0.0;\n    // p current position, initialized at the ro?\n    vec3 p = ro;\n    int material_ID = 0;\n    for (int i = 0; i < MAX_STEPS; i++){\n        vec2 res = map(p);\n        float d = res.x;\n        material_ID = int(res.y);\n        \n        p += (d*rd);\n        \n        // break near and far?\n        if (d > 100.0){\n            material_ID = 0;\n            break;\n        }\n        if (d < 0.001){\n            break;\n        }\n        // fake ao indicator\n        col.r += 0.02;\n        total_dist += d;\n    }\n    \n    \n    // material coloring.\n    if (material_ID >= 4) {\n        // 4 -> terrain ~ whiteish\n        col += vec3(0.8, 0.9, 0.9);\n    }\n    else if (material_ID >= 3) {\n        // 3 -> terrain ~ green\n        col += vec3(0.03, 0.6, 0.1);\n    }\n    else if (material_ID >= 2) {\n        // 2 -> water ~ blue\n        col += vec3(0.01, 0.02, 0.7);\n    }\n    else if (material_ID >= 1) {\n        // 1 -> floor ~ brown\n        col += vec3(0.3, 0.2, 0.1)*noise(p);\n    }\n    else {\n        // noting as in distance.. fog?\n        col = vec3(10.0/total_dist);\n    }\n    \n    \n    // col = vec3(noise(p));\n    // col = vec3(noise(vec3(uv.x*30.0, iTime, uv.y*20.0)));\n    fragColor = vec4(col,1.0);\n}\n\n\n\n\n\n\n\n\n\n// empty space to move the editor up :)\n\n\n\n\n\n\n",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "4cBBRy",
        "date": "1725655932",
        "viewed": 90,
        "name": "Chippy Case Mod faces [WIP]",
        "username": "jakel101",
        "description": "a rather complex way to visualize the binary face panel for the Chippy Mod PC (from Intel Mod workshop).\n\nThe Image pass essentially doing the mock display\nthe Buffer A is rendering the face, no matter what buffer resolution it should work.",
        "likes": 1,
        "published": 3,
        "flags": 32,
        "usePreview": 0,
        "tags": [
          "display",
          "leds"
        ],
        "hasliked": 0,
        "retrieved": "2025-06-05T23:49:51.807010+00:00"
      },
      "renderpass": [
        {
          "inputs": [
            {
              "id": 257,
              "src": "/media/previz/buffer00.png",
              "ctype": "buffer",
              "channel": 0,
              "sampler": {
                "filter": "nearest",
                "wrap": "clamp",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            }
          ],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "// Apache 2.0 for this shader, but the original images might be copyrighted by Intel.\n\n\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    float short_edge = min(iResolution.x, iResolution.y);\n    vec2 uv = (fragCoord * 2.0 - iResolution.xy)/short_edge;\n    uv *= 1.1; // lazy scale/camera\n    uv += vec2(sin(iTime), cos(iTime))*0.034;\n        \n    \n    // base background (LED is on?)\n    vec3 col = vec3(0.01, 0.8, 0.23);\n    \n    // 1 pixel is 4 LEDs\n    // IDs from\n    vec2 pixelID = floor(uv*float(PIXELS/2));\n    // every single LED from 0 to 1 in x and y\n    vec2 LED_space = fract(uv*float(LEDs/2));\n    \n    // -1.0 outside the area, otherwise from (0 to 1 in 32 steps)\n    vec2 pixel_space = (pixelID + float(PIXELS/2)) / float(PIXELS);\n    \n    // enforce the outer edge, needs a refactor\n    if (pixel_space.x >=1.0) {\n        pixel_space.x = -1.0;\n    }\n    if (pixel_space.y >=1.0) {\n        pixel_space.y = -1.0;\n    }\n    \n     \n    if (pixel_space.x < 0.0 || pixel_space.y < 0.0) {\n        // the outside area is just bluish for now.\n        col = vec3(0.2, 0.4, 0.6);\n        if ((abs(uv.x) > 1.3) && (abs(uv.y) < 0.4)) {\n            // gold parts for the SMDs?\n            col = vec3(0.7, 0.8, 0.1);\n        }\n    }\n    else {\n        \n        // temporal LED visualizer\n        col.rgb *= 1.4 - length(LED_space-vec2(0.5));\n        // sample from the Buffer A (in iChannel0). With half a pixel offset to sample the center of those pixels.\n        float half_pixel = (1.0/float(PIXELS*2));\n        vec4 c0 = texture(iChannel0, (pixel_space + half_pixel));\n        float on_pixels = step(0.5, c0.r); // quickly ensure binary output using threshold\n        \n        // always on outer border (2 LEDs, 1 pixel)\n        float border_width = (1.0/(float(PIXELS)-1.0));\n        if ((pixel_space.x > (1.0 - border_width)) ||\n            (pixel_space.y > (1.0 - border_width)) ||\n            (pixel_space.x < 0.5 * (border_width)) ||\n            (pixel_space.y < 0.5 * (border_width)) ){\n            on_pixels = 1.0;\n        }\n        \n        // simulate on/off LEDs\n        col = mix(col, 0.1*col, 1.0-on_pixels);\n        \n\n    }\n    \n    fragColor = vec4(vec3(col),1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        },
        {
          "inputs": [],
          "outputs": [
            {
              "id": 257,
              "channel": 0
            }
          ],
          "code": "void mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    vec2 uv = fragCoord/iResolution.xy;\n    uv -= .5;\n    uv *= 2.0;\n    vec2 m = iMouse.xy/iResolution.xy;\n    m -= .5;\n    m *= 2.0;\n    \n    // eyes follow the mouse a bit \n    float eyes = length(vec2(abs(uv.x - 0.1*m.x) -0.4, (uv.y - 0.1*m.y) -0.2)) - 0.15; // last part is size\n    // TODO pupil\n    eyes = smoothstep(0.0, 0.02, eyes);\n    \n    \n    // todo wavy or something\n    float edges = 1.0 - smoothstep(0.0, 0.02, length(uv) - 1.);\n    \n    //todo freckles\n    \n    float mouth = 0.0;\n    \n    //TODO: webcam?\n    vec4 c0 = texture(iChannel0, fragCoord/iResolution.xy);\n    \n    float face = 1.0;\n    face *= eyes;\n    face *= edges;\n    fragColor = vec4(vec3(face),1.0);\n}",
          "name": "Buffer A",
          "description": "",
          "type": "buffer"
        },
        {
          "inputs": [],
          "outputs": [],
          "code": "// global constants (might not actually change. so redundant)\n\n// the original has 64x64 LEDs but 32x32 effective pixels. The outer border being unused.\n\nint LEDs = 64;\nint PIXELS = 32;\n\n",
          "name": "Common",
          "description": "",
          "type": "common"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "Mcjfzd",
        "date": "1725403601",
        "viewed": 101,
        "name": "for-loop mistranslation ref",
        "username": "jakel101",
        "description": "This issue serves as a reference for WebGL behaviour. It is public+API so testing via other clients is possible.\nit should be a solid brownish color. If you see different halfs something might be wrong with your implementation.",
        "likes": 0,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "reference",
          "error"
        ],
        "hasliked": 0,
        "retrieved": "2025-06-05T23:49:51.807010+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "// Apache 2.0 free for all!\n\n\n// third expression in a for loop \"loop-expression\" can contain multiple statements.\n// it's evaluated after the loop body. And the variables stay available outside the namespace.\n// OpenGL spec: https://registry.khronos.org/OpenGL/specs/gl/GLSLangSpec.4.60.pdf Chapter 6.3\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    vec2 uv = fragCoord/iResolution.xy;\n\n    float a = 1.0;\n    float b = 0.0;\n    \n    // right side\n    if (uv.x >= 0.5) {\n        // this variant has the iterator increment first and the external statements second\n        for (int i = 0; i < 50; i+=1, b+=0.01) {\n            a -= 0.01;\n        }\n    }\n    //left side\n    else {\n        // here the parts are flipped, it should be equivalent.\n        for (int i = 0; i < 50; b+=0.01, i+=1) {\n            a -= 0.01;\n        }\n    }\n\n    fragColor = vec4(a, b, 0.0, 1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "4cXyDf",
        "date": "1721662949",
        "viewed": 109,
        "name": "brick wall pattern",
        "username": "jakel101",
        "description": "essentially just the lines themselves. not giving IDs for the bricks or anything which would be interesting to putting different bricks etc.",
        "likes": 0,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "pattern",
          "tiling"
        ],
        "hasliked": 0,
        "retrieved": "2025-06-05T23:49:51.807010+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "#define PI 3.14159265\n\n\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    // Normalized pixel coordinates (from 0 to 1)\n    vec2 uv = fragCoord/iResolution.xy;\n    \n    // scale or zoom\n    uv *= 8.5;\n    \n    vec3 bg_col = vec3(0.85,0.2,0.05); //orange brick color?\n    \n    float thickness = 0.05;\n    float vert_lines = smoothstep(0.0, thickness, sin((uv.x*2.0*PI+sign(sin(uv.y*PI))*PI/2.0))-1.0+thickness);\n    float horizontal_lines = smoothstep(0.0, thickness, cos(uv.y*2.0*PI)-1.0+thickness);\n    \n    vec3 fill_col = vec3(0.41, 0.56, 0.65); // grey color\n    \n    vec3 col = mix(bg_col, fill_col, max(vert_lines, horizontal_lines));\n    \n    // Output to screen\n    fragColor = vec4(col,1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "MflcRj",
        "date": "1721334367",
        "viewed": 146,
        "name": "Brushed aluminium texture",
        "username": "jakel101",
        "description": "my attempt and doing a noise based brushed aluminium texture. The basic idea being you simply start with noise and then use directional blur.\nwould likely do better with added fractal noise to look sharper?\nlength and scale are fun to play with... (mouse)",
        "likes": 1,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "procedural",
          "noise",
          "texture"
        ],
        "hasliked": 0,
        "retrieved": "2025-06-05T23:49:51.807010+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "#define PHI 1.6180339887\n\n// pseudo random? not great one....\nfloat hash21(in vec2 ab){\n    float a = ab.x - 0.006;\n    float b = ab.y + 0.1;\n    float h = mod(PHI, -45.4/a) * mod(PHI, -b*0.03);\n    h *= 9123.512;\n    return fract(dot(vec2(a,b),fract(vec2(h,a+b))*586.512));\n}\n\n\n// value noise ~ sorta\nfloat noise2(in vec2 ab){\n    \n    vec2 i = floor(ab);\n    vec2 f = fract(ab);\n    \n    vec2 f2 = smoothstep(0.0, 1.0, f); //\n    \n    // corners in 2D\n    // c3 - c2\n    //  |    |\n    // c0 - c1\n    float c0 = hash21(i);\n    float c1 = hash21(i+vec2(1.0,0.0));\n    float c2 = hash21(i+vec2(1.0,1.0));\n    float c3 = hash21(i+vec2(0.0,1.0));\n    \n    // reconstruct with interpolation\n    float r = mix( mix(c0, c1, f2.x),\n                   mix(c3, c2, f2.x), f2.y);\n    return r;\n}\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    // Normalized pixel coordinates (from 0 to 1)\n    vec2 uv = fragCoord/iResolution.xy;\n\n    // really naive directional blur\n    vec2 m = iMouse.xy;\n    if ((iMouse.x<=0.0)||(iMouse.y<=0.0)){m.x=400.0,m.y=420.0;};\n    float dist = m.y/10.0;\n    float scale = m.x;\n    \n    float steps = max(10.0,dist*3.0);\n    vec3 col = vec3(0);\n    for (float i = 0.0; i <= steps; i++){\n        vec2 offset = vec2((i/steps)*dist); \n        offset *= vec2(sin(iTime*0.1), cos(iTime*0.1)); // animate direction by time?\n        col += noise2((uv*scale)-offset+10.4)/steps;\n    }\n    \n    // Output to screen\n    fragColor = vec4(vec3(col),1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "lXK3WV",
        "date": "1718307576",
        "viewed": 168,
        "name": "particle gravity simulation test",
        "username": "jakel101",
        "description": "shader to implement a very basic physics simulation using buffers. Use mouse+click as a still in progress gravity attractor\nalt+downarrow to reload\nconstants to edit in Common",
        "likes": 2,
        "published": 3,
        "flags": 32,
        "usePreview": 0,
        "tags": [
          "simulation",
          "particles",
          "physics"
        ],
        "hasliked": 0,
        "retrieved": "2025-06-05T23:49:51.807010+00:00"
      },
      "renderpass": [
        {
          "inputs": [
            {
              "id": 257,
              "src": "/media/previz/buffer00.png",
              "ctype": "buffer",
              "channel": 0,
              "sampler": {
                "filter": "nearest",
                "wrap": "clamp",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            }
          ],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "// Apache 2.0 license for this Shader :)\n\n// the main Image pass loads information from the Buffers\n// then draws particles to the canvas\n\nfloat sdCircle(vec2 pos, float r){\n    return length(pos) - r;\n}\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    // uv is set to the center\n    vec2 uv = (2.0*fragCoord - iResolution.xy)/iResolution.y;\n    // scale it a little so we can see the bounds\n    uv *= SCALE;\n    \n    vec4 data = texture(iChannel0, uv);\n    \n    vec2 p = data.xy;\n    vec2 vel = data.zw;\n    float ball = sdCircle(uv - p, RADIUS);\n    \n    vec3 col = vec3(ball < 0.0, vec2(0.2));\n    \n    // ouside area, with indicator bars\n    if (abs(uv.x) > WIDTH ) {\n        col.rgb = vec3(0.0);\n        col.g = float(uv.y > 0.0 && uv.y < vel.y*(SCALE+1.0));\n        col.r = float(uv.y < 0.0 && uv.y > vel.y*(SCALE+1.0));\n        \n    }   \n    if (abs(uv.y) > HEIGHT) {\n        col.rgb = vec3(0.0);\n        col.g = float(uv.x > 0.0 && uv.x < vel.x*(SCALE+1.0));\n        col.r = float(uv.x < 0.0 && uv.x > vel.x*(SCALE+1.0));\n    }\n    \n    \n    fragColor = vec4(col,1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        },
        {
          "inputs": [],
          "outputs": [],
          "code": "// the common pass holds various constants that change the simulation\n\n# define SIM_SPEED 20.0\n# define GRAVITY 0.01\n# define ATTRACT 0.0005\n# define RADIUS 0.1\n# define WIDTH 1.6\n# define HEIGHT 1.0\n# define SCALE 1.1\n# define BOUNCE 0.9\n\n// not yet implemented\n# define NUM_PARTICLES 1",
          "name": "Common",
          "description": "",
          "type": "common"
        },
        {
          "inputs": [
            {
              "id": 257,
              "src": "/media/previz/buffer00.png",
              "ctype": "buffer",
              "channel": 0,
              "sampler": {
                "filter": "nearest",
                "wrap": "clamp",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            }
          ],
          "outputs": [
            {
              "id": 257,
              "channel": 0
            }
          ],
          "code": "// the Buffer A pass holds information about each particle\n// the Red and Green channels are X and Y coordinates\n// the Blue and Alpha channels are X and Y velocity\n// you first load the previous buffer and then do a simulation step.\n// Buffer A gets rendered before Image.\n\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    // uv is set to the center\n    vec2 uv = (2.0*fragCoord - iResolution.xy)/iResolution.y;\n    vec2 m = (2.0*iMouse.xy - iResolution.xy)/iResolution.y;\n        \n    // load previous state\n    vec4 data = texture(iChannel0, uv);    \n    vec2 pos = data.xy;\n    vec2 vel = data.zw;\n    \n    // on initialization, add a bit of sideways motion and start top left\n    if (iFrame == 0) {\n        vel.x += 0.5;\n        pos.x += -WIDTH + RADIUS * 2.0;\n        pos.y += HEIGHT - RADIUS * 2.0;\n    }\n    \n    //mouse attractor, with a factor, only active when mouse is held down\n    // F = G((m1*m2)/(r^2)) // ATTRACT is out G constant, masses are just 1\n    vel += (m-pos)* (1.0)/pow(length(m-pos),2.0) * ATTRACT * max(0.0,sign(iMouse.z));\n        \n    // add gravity\n    vel.y -= GRAVITY * (pos.y+1.0);\n    \n    // trying to \"hold\" the ball\n    //if (length(m-pos) <= RADIUS && iMouse.z > 0.0) {\n        //vel=vec2(0.0);\n        //pos=m;//TODO: this loses the ball on release    \n    //}\n        \n    // move to next position\n    vec2 new_pos = pos + vel * iTimeDelta * SIM_SPEED;\n\n    \n    // simple collision and reflection\n    if (abs(new_pos.x) + RADIUS >= WIDTH) {\n        vel.x *= -BOUNCE;\n        new_pos.x = pos.x;// + (abs(new_pos).x-WIDTH)*vel.x;\n        \n    }\n    if (abs(new_pos.y) + RADIUS >= HEIGHT) {\n        vel.y *= -BOUNCE;\n        new_pos.y = pos.y;// + (abs(new_pos).y-WIDTH)*vel.y;\n        vel.x *= 0.99; //friction\n    }\n    \n    \n\n    fragColor = vec4(new_pos, vel);\n}",
          "name": "Buffer A",
          "description": "",
          "type": "buffer"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "XcVSzK",
        "date": "1715461690",
        "viewed": 98,
        "name": "Wug by Copilot-Chat",
        "username": "jakel101",
        "description": "Fork of https://www.shadertoy.com/view/McVXWW where I used the Copilot-Chat model to replace the sdWug function. conversation not available. I made a few changes to paste it correctly\n\nColor changed for a presentation",
        "likes": 0,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "raymarching",
          "generated",
          "wug"
        ],
        "hasliked": 0,
        "retrieved": "2025-06-05T23:49:51.807010+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "// Apache 2.0 licnese for this shader :)\n\n#define EPS 0.001\n\n\nmat2 rot2D( float angle){\n    float s = sin(angle);\n    float c = cos(angle);\n    return mat2(c, -s, s, c);\n}\n\n// root smooth minimum from @iq MIT license: https://www.shadertoy.com/view/DlVcW1\nfloat smin( float a, float b, float k )\n{\n    k *= 2.0;\n    float x = b-a;\n    return 0.5*( a+b-sqrt(x*x+k*k) );\n}\n\n// rounded cone by @iq MIT license: https://www.shadertoy.com/view/Xds3zN\nfloat sdRoundCone( in vec3 p, in float r1, float r2, float h )\n{\n    vec2 q = vec2( length(p.xz), p.y );\n    \n    float b = (r1-r2)/h;\n    float a = sqrt(1.0-b*b);\n    float k = dot(q,vec2(-b,a));\n    \n    if( k < 0.0 ) return length(q) - r1;\n    if( k > a*h ) return length(q-vec2(0.0,h)) - r2;\n        \n    return dot(q, vec2(a,b) ) - r1;\n}\n\n// capsule/stick/linesegment by @iq MIT license: https://www.shadertoy.com/view/Xds3zN\nfloat sdCapsule( vec3 p, vec3 a, vec3 b, float r )\n{\n\tvec3 pa = p-a, ba = b-a;\n\tfloat h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n\treturn length( pa - ba*h ) - r;\n}\n\n// sphere from @iq MIT license: https://www.shadertoy.com/view/Xds3zN\nfloat sdSphere( vec3 p, float s )\n{\n    return length(p)-s;\n}\n\n// solid angle from @iq MIT license: https://www.shadertoy.com/view/Xds3zN\nfloat sdSolidAngle(vec3 pos, vec2 c, float ra)\n{\n    vec2 p = vec2( length(pos.xz), pos.y );\n    float l = length(p) - ra;\n\tfloat m = length(p - c*clamp(dot(p,c),0.0,ra) );\n    return max(l,m*sign(c.y*p.x-c.x*p.y));\n}\n\n// pyramid from @iq MIT license: https://www.shadertoy.com/view/Xds3zN\nfloat sdPyramid( in vec3 p, in float h )\n{\n    float m2 = h*h + 0.25;\n    \n    // symmetry\n    p.xz = abs(p.xz);\n    p.xz = (p.z>p.x) ? p.zx : p.xz;\n    p.xz -= 0.5;\n\t\n    // project into face plane (2D)\n    vec3 q = vec3( p.z, h*p.y - 0.5*p.x, h*p.x + 0.5*p.y);\n   \n    float s = max(-q.x,0.0);\n    float t = clamp( (q.y-0.5*p.z)/(m2+0.25), 0.0, 1.0 );\n    \n    float a = m2*(q.x+s)*(q.x+s) + q.y*q.y;\n\tfloat b = m2*(q.x+0.5*t)*(q.x+0.5*t) + (q.y-m2*t)*(q.y-m2*t);\n    \n    float d2 = min(q.y,-q.x*m2-q.y*0.5) > 0.0 ? 0.0 : min(a,b);\n    \n    // recover 3D and scale, and add sign\n    return sqrt( (d2+q.z*q.z)/m2 ) * sign(max(q.z,-p.y));;\n}\n\n#define SDF_BODY 1.0\n#define SDF_EYES_LEGS 2.0\n// Sphere SDF by Copilot-chat\nfloat sphereSDF(vec3 position, float radius) {\n    return length(position) - radius;\n}\n\n// Box SDF by Copilot-chat\nfloat boxSDF(vec3 position, vec3 boxSize) {\n    vec3 d = abs(position) - boxSize;\n    return min(max(d.x, max(d.y, d.z)), 0.0) + length(max(d, 0.0));\n}\n\n//this function is generated by a language model\nvec2 sdWug(vec3 position) {\n    // Define the body as a box\n    float body = boxSDF(position, vec3(0.5, 0.7, 0.5));\n\n    // Define the eyes/legs as spheres\n    float eyesLegs = min(\n        sphereSDF(position - vec3(0.6, 0.6, 0.0), 0.2),\n        sphereSDF(position + vec3(0.6, 0.6, 0.0), 0.2)\n    );\n\n    // Return the minimum distance and the corresponding material ID\n    if (body < eyesLegs) {\n        return vec2(body, SDF_BODY);\n    } else {\n        return vec2(eyesLegs, SDF_EYES_LEGS);\n    }\n}\n\n\nvec2 map( vec3 p ){\n    float dist = float(0.0);\n    float mat = 0.0;\n    \n    // ground is a plane just now\n    float groundHeight = 2.0;\n    float ground = p.y + groundHeight; \n    \n    vec3 wugPos = vec3(p);\n    // wugPos.z = 1.5 - mod(wugPos.z, 3.0); // <--- uncomment this line to get more of them!\n    vec2 wug = sdWug(wugPos);\n    dist = min(ground, wug.x);\n    \n    if (wug.x < ground) mat = wug.y; // if ground is closer than wug return wug material, else 0.0?\n    \n    return vec2(dist, mat);\n}\n\nvec3 calcNormal( in vec3 pos){\n    vec2 e = vec2(EPS, 0.0);\n    return normalize(vec3(  map(pos+ e.xyy).x - map(pos-e.xyy).x,\n                            map(pos+ e.yxy).x - map(pos-e.yxy).x,\n                            map(pos+ e.yyx).x - map(pos-e.yyx).x ) );\n}\n\n\nvec2 rayCast( in vec3 ro, in vec3 rd){\n    float t = 0.0;                          //total distance travelled\n    float m = -1.0; // base material ID -1.0 will be sky/miss\n    // Raymarching loop\n    int i;\n    for (i=0; i<=100; i++){\n        vec3 pos = ro + rd*t;                 // position along the ray\n        vec2 h = map(pos);             // \"hit\"? currennt distance to next object in the scene\n        m = h.y;\n        if (h.x < EPS) break;               // early stop near\n        t += h.x;                             // marching step\n        \n        if (t > 20.0) break;        // early stop far\n    }\n    if (t>20.0) m=-1.0;\n    \n    return vec2(t,m);\n}\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    vec2 uv = (fragCoord * 2.0 - iResolution.xy)/iResolution.y;\n    vec2 m = (iMouse.xy * vec2(4.0,2.0) - iResolution.xy)/iResolution.y;\n    m.y -= 0.5;\n    // Initialize\n    vec3 ro = vec3(0.0, 0.0, 4.0);         // rayOrigin\n    vec3 rd = normalize(vec3(uv, -0.8));       // rayDirection, value changes fov\n    vec3 col = vec3(0.55,0.65,0.9) - 0.6*rd.y;           // sky color with gradient\n\n    // mouse control\n    if ((iMouse.x<=0.0)||(iMouse.y<=0.0)){m.x=-.5,m.y=-.4;};//quick hack to detect no mouse input for thumbnail\n    m.x += iTime*0.25;\n    ro.yz *= rot2D(m.y);\n    rd.yz *= rot2D(m.y);\n    \n    ro.xz *= rot2D(m.x);\n    rd.xz *= rot2D(m.x);\n    \n    \n    vec2 res = rayCast(ro, rd);\n    float dist = res.x;\n    float mat = res.y;\n    \n    if (mat > -0.5){\n        vec3 pos = ro + rd*dist;\n        vec3 nor = calcNormal(pos);\n        vec3 material = vec3(0.03,0.18,0.03); // + 0.03*sin(rd.x); // base baterial, albedo low for floor\n        \n        if (mat > 0.5) // ID 1.0 = wug\n        {\n            material = vec3(0.9, 0.4, 0.1); \n        }\n        // should be else if, but I need to have the order correct\n        if (mat > 1.5) // ID 2.0 = eyes, legs\n        {\n            material = vec3(0.03); // near black\n        }\n        \n        \n        vec3 sun_dir = normalize(vec3(1.6, 1.2, 0.7));                   // sun direction\n        float sun_dif = clamp( dot(nor, sun_dir), 0.0, 1.0);             //diffused keylight?\n        float sun_sha = step(rayCast( pos+nor*EPS, sun_dir ).y, 0.0); \n        float sky_dif = clamp( 0.5 + 0.5*dot(nor, vec3(0.0, 1.0, 0.0)), 0.0, 1.0); //diffused sky light, biased?\n        \n        col = material*vec3(1.0, 0.7, 0.5) * sun_dif * sun_sha;   // yellow sunlight\n        col += material*vec3(0.0, 0.2, 0.4) * sky_dif;  // blue skylight\n        \n    }\n    \n    col = pow ( col, vec3(0.4545)); // gamma space - which one?\n    \n    fragColor = vec4(col,1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "4fVXRK",
        "date": "1715459888",
        "viewed": 98,
        "name": "Wug by Mixtral8x7B-Instruct-v0.1",
        "username": "jakel101",
        "description": "Fork of https://www.shadertoy.com/view/McVXWW where I used Mixtral-8x7B-Instruct-v0.1 to replace the sdWug function. conversation: https://hf.co/chat/r/5UWQ7Ca  I made some minor edits to paste it correctly.\n\nColor changed for a presentation",
        "likes": 0,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "raymarching",
          "generated",
          "wug"
        ],
        "hasliked": 0,
        "retrieved": "2025-06-05T23:49:51.807010+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "// Apache 2.0 licnese for this shader :)\n\n#define EPS 0.001\n#define PI 3.14159\n\nmat2 rot2D( float angle){\n    float s = sin(angle);\n    float c = cos(angle);\n    return mat2(c, -s, s, c);\n}\n\n// root smooth minimum from @iq MIT license: https://www.shadertoy.com/view/DlVcW1\nfloat smin( float a, float b, float k )\n{\n    k *= 2.0;\n    float x = b-a;\n    return 0.5*( a+b-sqrt(x*x+k*k) );\n}\n\n// rounded cone by @iq MIT license: https://www.shadertoy.com/view/Xds3zN\nfloat sdRoundCone( in vec3 p, in float r1, float r2, float h )\n{\n    vec2 q = vec2( length(p.xz), p.y );\n    \n    float b = (r1-r2)/h;\n    float a = sqrt(1.0-b*b);\n    float k = dot(q,vec2(-b,a));\n    \n    if( k < 0.0 ) return length(q) - r1;\n    if( k > a*h ) return length(q-vec2(0.0,h)) - r2;\n        \n    return dot(q, vec2(a,b) ) - r1;\n}\n\n// capsule/stick/linesegment by @iq MIT license: https://www.shadertoy.com/view/Xds3zN\nfloat sdCapsule( vec3 p, vec3 a, vec3 b, float r )\n{\n\tvec3 pa = p-a, ba = b-a;\n\tfloat h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n\treturn length( pa - ba*h ) - r;\n}\n\n// sphere from @iq MIT license: https://www.shadertoy.com/view/Xds3zN\nfloat sdSphere( vec3 p, float s )\n{\n    return length(p)-s;\n}\n\n// solid angle from @iq MIT license: https://www.shadertoy.com/view/Xds3zN\nfloat sdSolidAngle(vec3 pos, vec2 c, float ra)\n{\n    vec2 p = vec2( length(pos.xz), pos.y );\n    float l = length(p) - ra;\n\tfloat m = length(p - c*clamp(dot(p,c),0.0,ra) );\n    return max(l,m*sign(c.y*p.x-c.x*p.y));\n}\n\n// pyramid from @iq MIT license: https://www.shadertoy.com/view/Xds3zN\nfloat sdPyramid( in vec3 p, in float h )\n{\n    float m2 = h*h + 0.25;\n    \n    // symmetry\n    p.xz = abs(p.xz);\n    p.xz = (p.z>p.x) ? p.zx : p.xz;\n    p.xz -= 0.5;\n\t\n    // project into face plane (2D)\n    vec3 q = vec3( p.z, h*p.y - 0.5*p.x, h*p.x + 0.5*p.y);\n   \n    float s = max(-q.x,0.0);\n    float t = clamp( (q.y-0.5*p.z)/(m2+0.25), 0.0, 1.0 );\n    \n    float a = m2*(q.x+s)*(q.x+s) + q.y*q.y;\n\tfloat b = m2*(q.x+0.5*t)*(q.x+0.5*t) + (q.y-m2*t)*(q.y-m2*t);\n    \n    float d2 = min(q.y,-q.x*m2-q.y*0.5) > 0.0 ? 0.0 : min(a,b);\n    \n    // recover 3D and scale, and add sign\n    return sqrt( (d2+q.z*q.z)/m2 ) * sign(max(q.z,-p.y));;\n}\n\n\n// this funciton is generated by a language model!\n// WUG SDF parameters\nconst float bodyRadius = 0.5; // Radius of the body\nconst float legLength = 0.4; // Length of each leg\nconst float legWidth = 0.1; // Width of each leg\nconst float eyeRadius = 0.1; // Radius of the eyes\nconst float eyeDistance = 0.6; // Distance between the eyes and the center of the body\nconst int numLegs = 4; // Number of legs\n// Calculate the WUG SDF given a position\nfloat calculateWugSDF(in vec3 position) {\n    // Start by calculating the squared distance from the origin\n    float distSquared = dot(position, position);\n    \n    // Check if we're inside the body sphere\n    if (distSquared < bodyRadius * bodyRadius) {\n        return length(position) - bodyRadius;\n    }\n    \n    // Check if we're near one of the legs\n    for (int i = 0; i < numLegs; ++i) {\n        // Rotate the leg position around the y-axis\n        float angle = 2.0 * PI * float(i) / float(numLegs);\n        mat2 rotMat = mat2(cos(angle), -sin(angle), sin(angle), cos(angle));\n        vec2 legPos = vec2(bodyRadius + legLength, 0.0) * rotMat;\n        \n        // Translate the leg position to world space\n        vec3 legWorldPos = vec3(legPos, 0.0);\n        legWorldPos += position.xyz;\n        legWorldPos *= vec3(-1.0, 1.0, 1.0); // Flip the z axis\n        \n        // Calculate the squared distance from the leg cylinder\n        distSquared = min(distSquared, max(dot(legWorldPos, legWorldPos) - legWidth * legWidth / 4.0, 0.0));\n    }\n    \n    // Check if we're close to either eye\n    for (int i = 0; i < 2; ++i) {\n        // Position the eyes along the x-axis\n        float eyeX = (-1.0 + 2.0 * float(i)) * eyeDistance;\n        vec3 eyePos = vec3(eyeX, 0.0, 0.0);\n        eyePos += position.xyz;\n        eyePos *= vec3(-1.0, 1.0, 1.0); // Flip the z axis\n        \n        // Calculate the squared distance from the eye sphere\n        distSquared = min(distSquared, dot(eyePos, eyePos) - eyeRadius * eyeRadius);\n    }\n    \n    return sqrt(distSquared);\n}\n\n// Generate the final output vector based on the calculated SDF\nvec2 sdWug(in vec3 position) {\n    float distance = calculateWugSDF(position);\n    float materialID = step(distance, 0.0) * 1.0 + step(distance - eyeDistance, 0.0) * 2.0;\n    return vec2(distance, materialID);\n}\n\n\nvec2 map( vec3 p ){\n    float dist = float(0.0);\n    float mat = 0.0;\n    \n    // ground is a plane just now\n    float groundHeight = 2.0;\n    float ground = p.y + groundHeight; \n    \n    vec3 wugPos = vec3(p);\n    // wugPos.z = 1.5 - mod(wugPos.z, 3.0); // <--- uncomment this line to get more of them!\n    vec2 wug = sdWug(wugPos);\n    dist = min(ground, wug.x);\n    \n    if (wug.x < ground) mat = wug.y; // if ground is closer than wug return wug material, else 0.0?\n    \n    return vec2(dist, mat);\n}\n\nvec3 calcNormal( in vec3 pos){\n    vec2 e = vec2(EPS, 0.0);\n    return normalize(vec3(  map(pos+ e.xyy).x - map(pos-e.xyy).x,\n                            map(pos+ e.yxy).x - map(pos-e.yxy).x,\n                            map(pos+ e.yyx).x - map(pos-e.yyx).x ) );\n}\n\n\nvec2 rayCast( in vec3 ro, in vec3 rd){\n    float t = 0.0;                          //total distance travelled\n    float m = -1.0; // base material ID -1.0 will be sky/miss\n    // Raymarching loop\n    int i;\n    for (i=0; i<=100; i++){\n        vec3 pos = ro + rd*t;                 // position along the ray\n        vec2 h = map(pos);             // \"hit\"? currennt distance to next object in the scene\n        m = h.y;\n        if (h.x < EPS) break;               // early stop near\n        t += h.x;                             // marching step\n        \n        if (t > 20.0) break;        // early stop far\n    }\n    if (t>20.0) m=-1.0;\n    \n    return vec2(t,m);\n}\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    vec2 uv = (fragCoord * 2.0 - iResolution.xy)/iResolution.y;\n    vec2 m = (iMouse.xy * vec2(4.0,2.0) - iResolution.xy)/iResolution.y;\n    m.y -= 0.5;\n    // Initialize\n    vec3 ro = vec3(0.0, 0.0, 4.0);         // rayOrigin\n    vec3 rd = normalize(vec3(uv, -0.8));       // rayDirection, value changes fov\n    vec3 col = vec3(0.55,0.65,0.9) - 0.6*rd.y;           // sky color with gradient\n\n    // mouse control\n    if ((iMouse.x<=0.0)||(iMouse.y<=0.0)){m.x=-.5,m.y=-.4;};//quick hack to detect no mouse input for thumbnail\n    m.x += iTime*0.25;\n    ro.yz *= rot2D(m.y);\n    rd.yz *= rot2D(m.y);\n    \n    ro.xz *= rot2D(m.x);\n    rd.xz *= rot2D(m.x);\n    \n    \n    vec2 res = rayCast(ro, rd);\n    float dist = res.x;\n    float mat = res.y;\n    \n    if (mat > -0.5){\n        vec3 pos = ro + rd*dist;\n        vec3 nor = calcNormal(pos);\n        vec3 material = vec3(0.03,0.18,0.03); // + 0.03*sin(rd.x); // base baterial, albedo low for floor\n        \n        if (mat > 0.5) // ID 1.0 = wug\n        {\n            material = vec3(0.9, 0.9, 0.1); \n        }\n        // should be else if, but I need to have the order correct\n        if (mat > 1.5) // ID 2.0 = eyes, legs\n        {\n            material = vec3(0.03); // near black\n        }\n        \n        \n        vec3 sun_dir = normalize(vec3(1.6, 1.2, 0.7));                   // sun direction\n        float sun_dif = clamp( dot(nor, sun_dir), 0.0, 1.0);             //diffused keylight?\n        float sun_sha = step(rayCast( pos+nor*EPS, sun_dir ).y, 0.0); \n        float sky_dif = clamp( 0.5 + 0.5*dot(nor, vec3(0.0, 1.0, 0.0)), 0.0, 1.0); //diffused sky light, biased?\n        \n        col = material*vec3(1.0, 0.7, 0.5) * sun_dif * sun_sha;   // yellow sunlight\n        col += material*vec3(0.0, 0.2, 0.4) * sky_dif;  // blue skylight\n        \n    }\n    \n    col = pow ( col, vec3(0.4545)); // gamma space - which one?\n    \n    fragColor = vec4(col,1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "4cKXRK",
        "date": "1715459313",
        "viewed": 76,
        "name": "Wug by Llama3-70B-instruct",
        "username": "jakel101",
        "description": "Fork of https://www.shadertoy.com/view/McVXWW where I used the llama3-70B-instruct to replace the sdWug function. conversation: https://hf.co/chat/r/gJgP-q0 I made some minor edits to paste it correctly.\n\nColor changed for a presentation",
        "likes": 0,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "raymarching",
          "generated",
          "wug"
        ],
        "hasliked": 0,
        "retrieved": "2025-06-05T23:49:51.807010+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "// Apache 2.0 licnese for this shader :)\n\n#define EPS 0.001\n\n\nmat2 rot2D( float angle){\n    float s = sin(angle);\n    float c = cos(angle);\n    return mat2(c, -s, s, c);\n}\n\n// root smooth minimum from @iq MIT license: https://www.shadertoy.com/view/DlVcW1\nfloat smin( float a, float b, float k )\n{\n    k *= 2.0;\n    float x = b-a;\n    return 0.5*( a+b-sqrt(x*x+k*k) );\n}\n\n// rounded cone by @iq MIT license: https://www.shadertoy.com/view/Xds3zN\nfloat sdRoundCone( in vec3 p, in float r1, float r2, float h )\n{\n    vec2 q = vec2( length(p.xz), p.y );\n    \n    float b = (r1-r2)/h;\n    float a = sqrt(1.0-b*b);\n    float k = dot(q,vec2(-b,a));\n    \n    if( k < 0.0 ) return length(q) - r1;\n    if( k > a*h ) return length(q-vec2(0.0,h)) - r2;\n        \n    return dot(q, vec2(a,b) ) - r1;\n}\n\n// capsule/stick/linesegment by @iq MIT license: https://www.shadertoy.com/view/Xds3zN\nfloat sdCapsule( vec3 p, vec3 a, vec3 b, float r )\n{\n\tvec3 pa = p-a, ba = b-a;\n\tfloat h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n\treturn length( pa - ba*h ) - r;\n}\n\n// sphere from @iq MIT license: https://www.shadertoy.com/view/Xds3zN\nfloat sdSphere( vec3 p, float s )\n{\n    return length(p)-s;\n}\n\n\n// arbitrary orientation sdCylinder by @iq MIT license: https://www.shadertoy.com/view/Xds3zN\nfloat sdCylinder(vec3 p, vec3 a, vec3 b, float r)\n{\n    vec3 pa = p - a;\n    vec3 ba = b - a;\n    float baba = dot(ba,ba);\n    float paba = dot(pa,ba);\n\n    float x = length(pa*baba-ba*paba) - r*baba;\n    float y = abs(paba-baba*0.5)-baba*0.5;\n    float x2 = x*x;\n    float y2 = y*y*baba;\n    float d = (max(x,y)<0.0)?-min(x2,y2):(((x>0.0)?x2:0.0)+((y>0.0)?y2:0.0));\n    return sign(d)*sqrt(abs(d))/baba;\n}\n\n// pyramid from @iq MIT license: https://www.shadertoy.com/view/Xds3zN\nfloat sdPyramid( in vec3 p, in float h )\n{\n    float m2 = h*h + 0.25;\n    \n    // symmetry\n    p.xz = abs(p.xz);\n    p.xz = (p.z>p.x) ? p.zx : p.xz;\n    p.xz -= 0.5;\n\t\n    // project into face plane (2D)\n    vec3 q = vec3( p.z, h*p.y - 0.5*p.x, h*p.x + 0.5*p.y);\n   \n    float s = max(-q.x,0.0);\n    float t = clamp( (q.y-0.5*p.z)/(m2+0.25), 0.0, 1.0 );\n    \n    float a = m2*(q.x+s)*(q.x+s) + q.y*q.y;\n\tfloat b = m2*(q.x+0.5*t)*(q.x+0.5*t) + (q.y-m2*t)*(q.y-m2*t);\n    \n    float d2 = min(q.y,-q.x*m2-q.y*0.5) > 0.0 ? 0.0 : min(a,b);\n    \n    // recover 3D and scale, and add sign\n    return sqrt( (d2+q.z*q.z)/m2 ) * sign(max(q.z,-p.y));;\n}\n\n// this function is generated by a language model\nvec2 sdWug(vec3 p) {\n    // Body\n    float bodyRadius = 0.5;\n    float bodyHeight = 1.0;\n    float bodyDistance = sdCapsule(p, vec3(0.0, -bodyHeight/2.0, 0.0), vec3(0.0, bodyHeight/2.0, 0.0), bodyRadius);\n    \n    // Head\n    float headRadius = 0.3;\n    float headHeight = 0.4;\n    float headDistance = sdCapsule(p, vec3(0.0, bodyHeight/2.0 - headHeight/2.0, 0.0), vec3(0.0, bodyHeight/2.0 + headHeight/2.0, 0.0), headRadius);\n    \n    // Eyes\n    float eyeRadius = 0.1;\n    float eyeDistance = sdSphere(p - vec3(0.0, bodyHeight/2.0 + headHeight/2.0 - eyeRadius, 0.0), eyeRadius);\n    eyeDistance = min(eyeDistance, sdSphere(p - vec3(0.0, bodyHeight/2.0 + headHeight/2.0 - eyeRadius, 0.0), eyeRadius));\n    \n    // Legs\n    float legRadius = 0.05;\n    float legHeight = 0.3;\n    float legDistance = sdCylinder(p - vec3(0.2, -bodyHeight/2.0 - legHeight/2.0, 0.0), vec3(0.2, -bodyHeight/2.0 + legHeight/2.0, 0.0), vec3(0.0), legRadius);\n    legDistance = min(legDistance, sdCylinder(p - vec3(-0.2, -bodyHeight/2.0 - legHeight/2.0, 0.0), vec3(-0.2, -bodyHeight/2.0 + legHeight/2.0, 0.0), vec3(0.0), legRadius));\n    \n    // Combine distances\n    float distance = bodyDistance;\n    distance = min(distance, headDistance);\n    distance = min(distance, eyeDistance);\n    distance = min(distance, legDistance);\n    \n    // Material ID\n    float materialID = 1.0; // Body\n    if (headDistance < distance) materialID = 1.0; // Head\n    if (eyeDistance < distance) materialID = 2.0; // Eyes\n    if (legDistance < distance) materialID = 2.0; // Legs\n    \n    return vec2(distance, materialID);\n}\n\nvec2 map( vec3 p ){\n    float dist = float(0.0);\n    float mat = 0.0;\n    \n    // ground is a plane just now\n    float groundHeight = 2.0;\n    float ground = p.y + groundHeight; \n    \n    vec3 wugPos = vec3(p);\n    // wugPos.z = 1.5 - mod(wugPos.z, 3.0); // <--- uncomment this line to get more of them!\n    vec2 wug = sdWug(wugPos);\n    dist = min(ground, wug.x);\n    \n    if (wug.x < ground) mat = wug.y; // if ground is closer than wug return wug material, else 0.0?\n    \n    return vec2(dist, mat);\n}\n\nvec3 calcNormal( in vec3 pos){\n    vec2 e = vec2(EPS, 0.0);\n    return normalize(vec3(  map(pos+ e.xyy).x - map(pos-e.xyy).x,\n                            map(pos+ e.yxy).x - map(pos-e.yxy).x,\n                            map(pos+ e.yyx).x - map(pos-e.yyx).x ) );\n}\n\n\nvec2 rayCast( in vec3 ro, in vec3 rd){\n    float t = 0.0;                          //total distance travelled\n    float m = -1.0; // base material ID -1.0 will be sky/miss\n    // Raymarching loop\n    int i;\n    for (i=0; i<=100; i++){\n        vec3 pos = ro + rd*t;                 // position along the ray\n        vec2 h = map(pos);             // \"hit\"? currennt distance to next object in the scene\n        m = h.y;\n        if (h.x < EPS) break;               // early stop near\n        t += h.x;                             // marching step\n        \n        if (t > 20.0) break;        // early stop far\n    }\n    if (t>20.0) m=-1.0;\n    \n    return vec2(t,m);\n}\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    vec2 uv = (fragCoord * 2.0 - iResolution.xy)/iResolution.y;\n    vec2 m = (iMouse.xy * vec2(4.0,2.0) - iResolution.xy)/iResolution.y;\n    m.y -= 0.5;\n    // Initialize\n    vec3 ro = vec3(0.0, 0.0, 4.0);         // rayOrigin\n    vec3 rd = normalize(vec3(uv, -0.8));       // rayDirection, value changes fov\n    vec3 col = vec3(0.55,0.65,0.9) - 0.6*rd.y;           // sky color with gradient\n\n    // mouse control\n    if ((iMouse.x<=0.0)||(iMouse.y<=0.0)){m.x=-.5,m.y=-.4;};//quick hack to detect no mouse input for thumbnail\n    m.x += iTime*0.25;\n    ro.yz *= rot2D(m.y);\n    rd.yz *= rot2D(m.y);\n    \n    ro.xz *= rot2D(m.x);\n    rd.xz *= rot2D(m.x);\n    \n    \n    vec2 res = rayCast(ro, rd);\n    float dist = res.x;\n    float mat = res.y;\n    \n    if (mat > -0.5){\n        vec3 pos = ro + rd*dist;\n        vec3 nor = calcNormal(pos);\n        vec3 material = vec3(0.03,0.18,0.03); // + 0.03*sin(rd.x); // base baterial, albedo low for floor\n        \n        if (mat > 0.5) // ID 1.0 = wug\n        {\n            material = vec3(0.9, 0.1, 0.1); \n        }\n        // should be else if, but I need to have the order correct\n        if (mat > 1.5) // ID 2.0 = eyes, legs\n        {\n            material = vec3(0.03); // near black\n        }\n        \n        \n        vec3 sun_dir = normalize(vec3(1.6, 1.2, 0.7));                   // sun direction\n        float sun_dif = clamp( dot(nor, sun_dir), 0.0, 1.0);             //diffused keylight?\n        float sun_sha = step(rayCast( pos+nor*EPS, sun_dir ).y, 0.0); \n        float sky_dif = clamp( 0.5 + 0.5*dot(nor, vec3(0.0, 1.0, 0.0)), 0.0, 1.0); //diffused sky light, biased?\n        \n        col = material*vec3(1.0, 0.7, 0.5) * sun_dif * sun_sha;   // yellow sunlight\n        col += material*vec3(0.0, 0.2, 0.4) * sky_dif;  // blue skylight\n        \n    }\n    \n    col = pow ( col, vec3(0.4545)); // gamma space - which one?\n    \n    fragColor = vec4(col,1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "MfKSDW",
        "date": "1715214362",
        "viewed": 91,
        "name": "some Buffer tests",
        "username": "jakel101",
        "description": "experimenting with the Buffers to understand how multi pass shaders are implemented.",
        "likes": 1,
        "published": 3,
        "flags": 32,
        "usePreview": 0,
        "tags": [
          "test"
        ],
        "hasliked": 0,
        "retrieved": "2025-06-05T23:49:51.807010+00:00"
      },
      "renderpass": [
        {
          "inputs": [
            {
              "id": 257,
              "src": "/media/previz/buffer00.png",
              "ctype": "buffer",
              "channel": 0,
              "sampler": {
                "filter": "linear",
                "wrap": "repeat",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            }
          ],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "void mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    // Normalized pixel coordinates (from 0 to 1)\n    vec2 uv = fragCoord/iResolution.xy;\n\n    vec2 uv_f = uv * 2.;\n    vec4 col = texture(iChannel0, uv_f);\n\n    // Output to screen\n    fragColor = col;\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        },
        {
          "inputs": [
            {
              "id": 8,
              "src": "/media/a/52d2a8f514c4fd2d9866587f4d7b2a5bfa1a11a0e772077d7682deb8b3b517e5.jpg",
              "ctype": "texture",
              "channel": 1,
              "sampler": {
                "filter": "mipmap",
                "wrap": "repeat",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            },
            {
              "id": 258,
              "src": "/media/previz/buffer01.png",
              "ctype": "buffer",
              "channel": 0,
              "sampler": {
                "filter": "linear",
                "wrap": "clamp",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            }
          ],
          "outputs": [
            {
              "id": 257,
              "channel": 0
            }
          ],
          "code": "void mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    vec2 uv = fragCoord/iResolution.xy;\n    vec4 col0 = texture(iChannel0,uv);\n    vec4 col1 = texture(iChannel1,uv);\n    fragColor = mix(col0,col1,0.5) * vec4(uv.y,uv.x,1.0,1.0);\n}",
          "name": "Buffer A",
          "description": "",
          "type": "buffer"
        },
        {
          "inputs": [
            {
              "id": 9,
              "src": "/media/a/bd6464771e47eed832c5eb2cd85cdc0bfc697786b903bfd30f890f9d4fc36657.jpg",
              "ctype": "texture",
              "channel": 0,
              "sampler": {
                "filter": "mipmap",
                "wrap": "repeat",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            },
            {
              "id": 259,
              "src": "/media/previz/buffer02.png",
              "ctype": "buffer",
              "channel": 1,
              "sampler": {
                "filter": "linear",
                "wrap": "clamp",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            }
          ],
          "outputs": [
            {
              "id": 258,
              "channel": 0
            }
          ],
          "code": "void mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    vec2 uv = fragCoord/iResolution.xy;\n    vec4 col0 = texture(iChannel0,uv);\n    vec4 col1 = texture(iChannel1,uv);\n    fragColor = mix(col0, col1, sin(iTime));\n}",
          "name": "Buffer B",
          "description": "",
          "type": "buffer"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "McVXWW",
        "date": "1715206575",
        "viewed": 147,
        "name": "Wug at TaCoS 2024",
        "username": "jakel101",
        "description": "This is the sequel to Wug at TaCoS from 2023: https://www.shadertoy.com/view/DdlcRf, motivated by: https://www.shadertoy.com/view/3lsSzf\nThere will be different variants of composite wugs to compare language models for an illustration. Maybe also details:",
        "likes": 1,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "raymarching",
          "wug"
        ],
        "hasliked": 0,
        "retrieved": "2025-06-05T23:49:51.807010+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "// Apache 2.0 licnese for this shader :)\n\n#define EPS 0.001\n\n\nmat2 rot2D( float angle){\n    float s = sin(angle);\n    float c = cos(angle);\n    return mat2(c, -s, s, c);\n}\n\n// root smooth minimum from @iq MIT license: https://www.shadertoy.com/view/DlVcW1\nfloat smin( float a, float b, float k )\n{\n    k *= 2.0;\n    float x = b-a;\n    return 0.5*( a+b-sqrt(x*x+k*k) );\n}\n\n// rounded cone by @iq MIT license: https://www.shadertoy.com/view/Xds3zN\nfloat sdRoundCone( in vec3 p, in float r1, float r2, float h )\n{\n    vec2 q = vec2( length(p.xz), p.y );\n    \n    float b = (r1-r2)/h;\n    float a = sqrt(1.0-b*b);\n    float k = dot(q,vec2(-b,a));\n    \n    if( k < 0.0 ) return length(q) - r1;\n    if( k > a*h ) return length(q-vec2(0.0,h)) - r2;\n        \n    return dot(q, vec2(a,b) ) - r1;\n}\n\n// capsule/stick/linesegment by @iq MIT license: https://www.shadertoy.com/view/Xds3zN\nfloat sdCapsule( vec3 p, vec3 a, vec3 b, float r )\n{\n\tvec3 pa = p-a, ba = b-a;\n\tfloat h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n\treturn length( pa - ba*h ) - r;\n}\n\n// sphere from @iq MIT license: https://www.shadertoy.com/view/Xds3zN\nfloat sdSphere( vec3 p, float s )\n{\n    return length(p)-s;\n}\n\n// solid angle from @iq MIT license: https://www.shadertoy.com/view/Xds3zN\nfloat sdSolidAngle(vec3 pos, vec2 c, float ra)\n{\n    vec2 p = vec2( length(pos.xz), pos.y );\n    float l = length(p) - ra;\n\tfloat m = length(p - c*clamp(dot(p,c),0.0,ra) );\n    return max(l,m*sign(c.y*p.x-c.x*p.y));\n}\n\n// pyramid from @iq MIT license: https://www.shadertoy.com/view/Xds3zN\nfloat sdPyramid( in vec3 p, in float h )\n{\n    float m2 = h*h + 0.25;\n    \n    // symmetry\n    p.xz = abs(p.xz);\n    p.xz = (p.z>p.x) ? p.zx : p.xz;\n    p.xz -= 0.5;\n\t\n    // project into face plane (2D)\n    vec3 q = vec3( p.z, h*p.y - 0.5*p.x, h*p.x + 0.5*p.y);\n   \n    float s = max(-q.x,0.0);\n    float t = clamp( (q.y-0.5*p.z)/(m2+0.25), 0.0, 1.0 );\n    \n    float a = m2*(q.x+s)*(q.x+s) + q.y*q.y;\n\tfloat b = m2*(q.x+0.5*t)*(q.x+0.5*t) + (q.y-m2*t)*(q.y-m2*t);\n    \n    float d2 = min(q.y,-q.x*m2-q.y*0.5) > 0.0 ? 0.0 : min(a,b);\n    \n    // recover 3D and scale, and add sign\n    return sqrt( (d2+q.z*q.z)/m2 ) * sign(max(q.z,-p.y));;\n}\n\n\n// combine some primative shapes to get a 3D approximation of a Wug, including eyes and legs!\n// res.x is the distance, res.y is the material ID, eyes and legs is ID 1.0; body is 2.0;\nvec2 sdWug( vec3 p ) {\n    float dist = float(0.0);\n    float mat = 1.0;\n    \n    float height = 1.5;\n    float scale = 1.1;\n    \n    //body\n    float body = sdRoundCone(p, 0.7*height, 0.3*height, height);\n    vec3 pyramidPos1 = p;\n    pyramidPos1.xy *= rot2D(1.4);\n    pyramidPos1.x -= -height;\n    float pyramid1 = sdPyramid(pyramidPos1, scale*1.5);\n    \n    vec3 pyramidPos2 = p - vec3(-0.2,-.4,0.0);\n    \n    pyramidPos2.xy *= rot2D(-1.6);\n    \n    float pyramid2 = sdPyramid(pyramidPos2, scale*1.5);\n    float pyramids = smin(pyramid1, pyramid2, 0.1);\n    \n    body = smin(body, pyramids, 0.4);\n    \n    // eyes\n    vec3 eyePos = vec3(p.xy,abs(p.z)) - vec3(0.7, height-0.0, 0.4);\n    float eye = sdSphere(eyePos, .25*scale);\n    if (eye < body) mat = 2.0;\n    dist = min(body, eye);\n    \n    // legs\n    vec3 legPos = vec3(p.xy, abs(p.z)) - vec3(-0.3, -height-0.4, 0.5);\n    float leg = sdCapsule( legPos, vec3(0.0), vec3(0.0,0.6,-0.1), 0.1);\n    \n    float foot = sdCapsule( legPos, vec3(0.0), vec3(0.6, 0.0, 0.1), 0.1);\n    leg = smin(leg, foot, 0.05);\n    if (leg < dist) mat = 2.0;\n    dist = min(leg, dist);\n    \n    return vec2(dist, mat);\n}\n\n\nvec2 map( vec3 p ){\n    float dist = float(0.0);\n    float mat = 0.0;\n    \n    // ground is a plane just now\n    float groundHeight = 2.0;\n    float ground = p.y + groundHeight; \n    \n    vec3 wugPos = vec3(p);\n    // wugPos.z = 1.5 - mod(wugPos.z, 3.0); // <--- uncomment this line to get more of them!\n    vec2 wug = sdWug(wugPos);\n    dist = min(ground, wug.x);\n    \n    if (wug.x < ground) mat = wug.y; // if ground is closer than wug return wug material, else 0.0?\n    \n    return vec2(dist, mat);\n}\n\nvec3 calcNormal( in vec3 pos){\n    vec2 e = vec2(EPS, 0.0);\n    return normalize(vec3(  map(pos+ e.xyy).x - map(pos-e.xyy).x,\n                            map(pos+ e.yxy).x - map(pos-e.yxy).x,\n                            map(pos+ e.yyx).x - map(pos-e.yyx).x ) );\n}\n\n\nvec2 rayCast( in vec3 ro, in vec3 rd){\n    float t = 0.0;                          //total distance travelled\n    float m = -1.0; // base material ID -1.0 will be sky/miss\n    // Raymarching loop\n    int i;\n    for (i=0; i<=100; i++){\n        vec3 pos = ro + rd*t;                 // position along the ray\n        vec2 h = map(pos);             // \"hit\"? currennt distance to next object in the scene\n        m = h.y;\n        if (h.x < EPS) break;               // early stop near\n        t += h.x;                             // marching step\n        \n        if (t > 20.0) break;        // early stop far\n    }\n    if (t>20.0) m=-1.0;\n    \n    return vec2(t,m);\n}\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    vec2 uv = (fragCoord * 2.0 - iResolution.xy)/iResolution.y;\n    vec2 m = (iMouse.xy * vec2(4.0,2.0) - iResolution.xy)/iResolution.y;\n    m.y -= 0.5;\n    // Initialize\n    vec3 ro = vec3(0.0, 0.0, 4.0);         // rayOrigin\n    vec3 rd = normalize(vec3(uv, -0.8));       // rayDirection, value changes fov\n    vec3 col = vec3(0.55,0.65,0.9) - 0.6*rd.y;           // sky color with gradient\n\n    // mouse control\n    if ((iMouse.x<=0.0)||(iMouse.y<=0.0)){m.x=-.5,m.y=-.4;};//quick hack to detect no mouse input for thumbnail\n    m.x += iTime*0.25;\n    ro.yz *= rot2D(m.y);\n    rd.yz *= rot2D(m.y);\n    \n    ro.xz *= rot2D(m.x);\n    rd.xz *= rot2D(m.x);\n    \n    \n    vec2 res = rayCast(ro, rd);\n    float dist = res.x;\n    float mat = res.y;\n    \n    if (mat > -0.5){\n        vec3 pos = ro + rd*dist;\n        vec3 nor = calcNormal(pos);\n        vec3 material = vec3(0.03,0.18,0.03); // + 0.03*sin(rd.x); // base baterial, albedo low for floor\n        \n        if (mat > 0.5) // ID 1.0 = wug\n        {\n            material = vec3(0.1, 0.1, 0.9); \n        }\n        // should be else if, but I need to have the order correct\n        if (mat > 1.5) // ID 2.0 = eyes, legs\n        {\n            material = vec3(0.03); // near black\n        }\n        \n        \n        vec3 sun_dir = normalize(vec3(1.6, 1.2, 0.7));                   // sun direction\n        float sun_dif = clamp( dot(nor, sun_dir), 0.0, 1.0);             //diffused keylight?\n        float sun_sha = step(rayCast( pos+nor*EPS, sun_dir ).y, 0.0); \n        float sky_dif = clamp( 0.5 + 0.5*dot(nor, vec3(0.0, 1.0, 0.0)), 0.0, 1.0); //diffused sky light, biased?\n        \n        col = material*vec3(1.0, 0.7, 0.5) * sun_dif * sun_sha;   // yellow sunlight\n        col += material*vec3(0.0, 0.2, 0.4) * sky_dif;  // blue skylight\n        \n    }\n    \n    col = pow ( col, vec3(0.4545)); // gamma space - which one?\n    \n    fragColor = vec4(col,1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "l3fXWN",
        "date": "1709519899",
        "viewed": 239,
        "name": "API test for CI",
        "username": "jakel101",
        "description": "this is a shader used for testing API functionality in CI. Not yet finalized, so it might change a bit.",
        "likes": 2,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "test",
          "apitesting"
        ],
        "hasliked": 0,
        "retrieved": "2025-06-05T23:49:51.807010+00:00"
      },
      "renderpass": [
        {
          "inputs": [
            {
              "id": 14,
              "src": "/media/a/cbcbb5a6cfb55c36f8f021fbb0e3f69ac96339a39fa85cd96f2017a2192821b5.png",
              "ctype": "texture",
              "channel": 0,
              "sampler": {
                "filter": "nearest",
                "wrap": "clamp",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            }
          ],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "//Confirm API working!\n\nfloat sdCheckmark(vec2 p, float s, float t)\n{\n    vec2 b = vec2(0.1*s, -.5*s);\n    float s1 = udSegment(p, vec2(-.4*s, -0.1*s), b);\n    float s2 = udSegment(p, b, vec2(.7*s, 0.5*s));\n    return min(s1, s2)-t;\n}\n\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    vec2 uv = (2.0*fragCoord - iResolution.xy)/iResolution.x;\n    vec2 m = (2.0*iMouse.xy - iResolution.xy)/iResolution.x;\n    \n    float sep = clamp(2.4*sin(iTime),-0.5, 0.5);\n    float scale = 0.6;\n    float thick = smoothstep(0.1, 1.1, (1.0 - length(uv-m))) * 0.06;\n    vec2 checkpos = uv - vec2(-sep,0.0);\n    vec2 crospos = uv - vec2(sep,0.0);\n    \n    float checkmark = sdCheckmark(checkpos, scale, thick);\n    float cros = sdCross(crospos, scale, thick);\n    \n    vec2 ncatuv = fragCoord/iChannelResolution[0].xy;\n    vec4 ncat = texture(iChannel0, ncatuv);\n    \n    vec3 col = vec3(0.0);\n    col.r += 1.0 - smoothstep(0.0, 0.02, cros);\n    col.g += 1.0 - smoothstep(0.0, 0.02, checkmark);\n    col += ncat.rgb * ncat.a;\n    \n    fragColor = vec4(col, 1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        },
        {
          "inputs": [],
          "outputs": [],
          "code": "//Common pass loaded!\n\n// from iq: https://www.shadertoy.com/view/3dKSDc\nfloat sdCross( in vec2 p, in float w, in float r )\n{\n    p = abs(p);\n    return length(p-min(p.x+p.y,w)*0.5) - r;\n}\n\n// from iq: https://www.shadertoy.com/view/3tdSDj\nfloat udSegment( in vec2 p, in vec2 a, in vec2 b )\n{\n    vec2 ba = b-a;\n    vec2 pa = p-a;\n    float h =clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );\n    return length(pa-h*ba);\n}",
          "name": "Common",
          "description": "",
          "type": "common"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "M3jGzh",
        "date": "1708209659",
        "viewed": 133,
        "name": "WGPUtest: nested loop [FIXED]",
        "username": "jakel101",
        "description": "wgpu seems to have trouble with nested loops. this shadertoy serves as a minimal example.\n\nIf moving the mouse (while clicked) doesn't change anything ... it is working!",
        "likes": 0,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "test"
        ],
        "hasliked": 0,
        "retrieved": "2025-06-05T23:49:51.807010+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "float checkerboard(vec2 uv, float cells){\n    uv *= cells/2.0;\n    float rows = float(mod(uv.y, 1.0) <= 0.5);\n    float cols = float(mod(uv.x, 1.0) <= 0.5);\n    return float(rows == cols);\n}\n\nvec2 working(vec2 uv, float steps){\n    float red = 0.0;\n    float green = 0.0;\n    int x;\n    int y;\n    for (x = 1; x <= 3; x++){\n        // 1 + 2 + 3 = 6\n        green += float(x);\n        for (y = 1; y <= 3; y++){\n            // 1+1+1 + 2+2+2 + 3+3+3 = 18?\n            red += float(x);\n        }\n    }\n    red = red / steps;\n    green = green / steps;\n    \n    return vec2(red<uv.x, green<uv.y);\n}\n\nvec2 broken(vec2 uv, float steps){\n    float red = 0.0;\n    float green = 0.0;\n    for (int x = 1; x <= 3; x++){\n        // 1 + 2 + 3 = 6\n        green += float(x);\n        for (int y = 1; y <= 3; y++){\n            // 1+1+1 + 2+2+2 + 3+3+3 = 18?\n            red += float(x);\n        }\n    }\n    red = red / steps;\n    green = green / steps;\n    \n    return vec2(red<uv.x, green<uv.y);\n}\n\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    float steps = 25.0;\n    vec2 uv = fragCoord/iResolution.xy;\n    vec3 col = vec3(checkerboard(uv,steps)) * 0.7;\n\n    vec2 nested_result = mix(working(uv, steps), broken(uv, steps), iMouse.x/iResolution.x);\n    col.rg += nested_result.rg;\n    \n    fragColor = vec4(col,1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "lXBGRz",
        "date": "1708102775",
        "viewed": 106,
        "name": "sqrt() behavior with negat",
        "username": "jakel101",
        "description": "investigating shadertoy behaviour, similar to https://www.shadertoy.com/view/lXl3Dj",
        "likes": 0,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "test"
        ],
        "hasliked": 0,
        "retrieved": "2025-06-05T23:49:51.807010+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "void mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    \n    vec2 uv = (2.0*fragCoord - iResolution.xy)/iResolution.y;\n\n    vec3 col = vec3(0.0);\n    \n    col += float(sqrt(uv.x) > uv.y);\n    \n    fragColor = vec4(col,1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "lXf3Ws",
        "date": "1708037702",
        "viewed": 204,
        "name": "sampler as function paramter",
        "username": "jakel101",
        "description": "GLSL allows you to use a sampler as function parameter. This seems to currently lead to and issue with wgpu.",
        "likes": 0,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "test"
        ],
        "hasliked": 0,
        "retrieved": "2025-06-05T23:49:51.807010+00:00"
      },
      "renderpass": [
        {
          "inputs": [
            {
              "id": 14,
              "src": "/media/a/cbcbb5a6cfb55c36f8f021fbb0e3f69ac96339a39fa85cd96f2017a2192821b5.png",
              "ctype": "texture",
              "channel": 0,
              "sampler": {
                "filter": "nearest",
                "wrap": "repeat",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            }
          ],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "void Function(in sampler2D myTexture);\nvoid Function2(sampler2D myTexture);\n\nvec4 invertedSampler(in sampler2D s, in vec2 uv) {\n    uv *= vec2(1.0, -1.0);\n    return texture(s, uv);\n}\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    vec2 uv = fragCoord/iResolution.xy;\n    vec4 c0 = invertedSampler(iChannel0,uv);\n    fragColor = c0;\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "lXl3Dj",
        "date": "1707948239",
        "viewed": 139,
        "name": "Pow() behavior with negatives",
        "username": "jakel101",
        "description": "Test shader to see how the pow() function behaves with negative numbers. According the the help (bottom right corner): \n> pow/sqrt: please don't feed sqrt() and pow() with negative numbers. Add an abs() or max(0.0,) to the argument",
        "likes": 1,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "test"
        ],
        "hasliked": 0,
        "retrieved": "2025-06-05T23:49:51.807010+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "void mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    vec2 uv = (2.0*fragCoord - iResolution.xy)/iResolution.y;\n\n\n    float y = 4.0 * uv.y;\n    vec3 col = vec3(0.0);\n    col.r += pow(uv.x, y);\n    col.g += pow(abs(uv.x), y);\n    col.b += pow(max(0.0, uv.x), y);\n    \n    fragColor = vec4(col,1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "X3XGRN",
        "date": "1707179459",
        "viewed": 118,
        "name": "Unsized array syntax",
        "username": "jakel101",
        "description": "Testing out what goes on shadertoy...\nOpenGL Spec https://registry.khronos.org/OpenGL/specs/gl/GLSLangSpec.4.60.pdf Chapter 4.1.9\ntracking: https://github.com/gfx-rs/wgpu/issues/5206",
        "likes": 0,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "test"
        ],
        "hasliked": 0,
        "retrieved": "2024-12-21T00:08:28.822842+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "\n// constant\nconst float[] a = float[](0.0, 1.0, 2.0, 3.0);\nconst float[] b = float[4](0.1, 1.1, 2.1, 3.1);\nconst float[4] c = float[](0.2, 1.2, 2.2, 3.2);\nconst float[4] d = float[4](0.3, 1.3, 2.3, 3.3);\n\n// not declared constant\nfloat[] e = float[](0.4, 1.4, 2.4, 3.4);\nfloat[] f = float[4](0.5, 1.5, 2.5, 3.5);\nfloat[4] g = float[](0.6, 1.6, 2.6, 3.6);\nfloat[4] h = float[4](0.7, 1.7, 2.7, 3.7);\n\n\nfloat avg4( float arr[4]){\n    float sum;\n    sum = arr[0];\n    sum += arr[1];\n    sum += arr[2];\n    sum += arr[3];\n    return sum /float(arr.length());\n}\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    vec2 uv = (2.0*fragCoord - iResolution.xy)/iResolution.y;\n\n    // vec3 col = vec3(0.25 * avg4(a));\n    // vec3 col = vec3(0.25 * avg4(b));\n    // vec3 col = vec3(0.25 * avg4(c));\n    vec3 col = vec3(0.25 * avg4(d));\n    // vec3 col = vec3(0.25 * avg4(e));\n    // vec3 col = vec3(0.25 * avg4(f));\n    // vec3 col = vec3(0.25 * avg4(g));\n    // vec3 col = vec3(0.25 * avg4(h));\n    // vec3 col = vec3(0.123);\n    \n    fragColor = vec4(col,1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "4cjSRc",
        "date": "1706631985",
        "viewed": 141,
        "name": "Example of a 5-Star and a circle",
        "username": "jakel101",
        "description": "Little test shader to explain different levels of model generation are classified in https://huggingface.co/spaces/Vipitis/shadermatch",
        "likes": 4,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "2d",
          "test"
        ],
        "hasliked": 0,
        "retrieved": "2024-12-21T00:08:28.822842+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "#define PI 3.141593\n\n// signed distance to a 5-star, modifed from iq: https://www.shadertoy.com/view/3tSGDy\nfloat sdStar(in vec2 p, in float r) // m=[2,n]\n{\n    // these 4 lines can be precomputed for a given shape\n    float n = 5.0;\n    float an = PI/n;\n    float en = PI/(2.0*n/(n-2.0)); // should be 3.333333 so it's regular (jump over 2!)\n    vec2  acs = vec2(cos(an),sin(an));\n    vec2  ecs = vec2(cos(en),sin(en)); // ecs=vec2(0,1) and simplify, for regular polygon,\n\n    // symmetry (optional)\n    p.x = abs(p.x);\n    \n    // reduce to first sector\n    float bn = mod(atan(p.x,p.y),2.0*an) - an;\n    p = length(p)*vec2(cos(bn),abs(sin(bn)));\n\n    // line sdf\n    p -= r*acs;\n    p += ecs*clamp( -dot(p,ecs), 0.0, r*acs.y/ecs.y);\n    return length(p)*sign(p.x);\n}\n\n// signed distance function of a circle, simple base case\nfloat sdCircle(in vec2 p, in float r) {\n    return length(p) -r;\n}\n\n// (orig: text_match) sigmoid smooth min via iq: https://iquilezles.org/articles/smin/\nfloat smin( float a, float b, float k )\n{\n    float x = b-a;\n    return a + x/(1.0-exp2(x/k));\n}\n\n// (image_match) changed variable names, should work\nfloat smin1( float a, float b, float k )\n{\n    float diff = b-a;\n    float bias = 1.0-exp2(diff/k);\n    return a + diff/bias;\n}\n\n// (altered: variation) root smooth min via iq: https://iquilezles.org/articles/smin/\nfloat smin2( float a, float b, float k )\n{\n    float x = b-a;\n    return 0.5*( a+b-sqrt(x*x+k) );\n}\n\n// (single_color) this one compiles but gives an single color image\nfloat smin3( float a, float b, float k )\n{\n    float g = 2.0*a/k-b;\n    return 0.187;\n}\n\n\n// (code_error) the model generated a full function, but the shadercode does not compile\n// float smin4( float a, float b, float k )\n// {\n//    float z = a*b;\n//     return vec2(min(z, b), k*b);\n// }\n// (incomplete_generation) the model gets stuck and does not generate a full function\n// float smin5( float a, float b, float k )\n// {\n//    float f = 2.0*a/k-b;\n//    float g = 3.0*a/k-b;\n//    float h = 4.0*a/k-b;\n//    float i = 5.0*a/k-b;\n//    float j = 6.0*a/k-b;//incomplete generation!\n\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    vec2 uv = (2.0*fragCoord - iResolution.xy)/iResolution.y;\n\n\n    vec3 col = vec3(0.0);\n    \n    float s = sin(iTime - 0.6) + 1.0;\n    \n    float d;\n    \n    float star = sdStar(uv - vec2(0.5,0.0), s);\n    float circle = sdCircle(uv -vec2(-0.5,0.0) , 0.4);\n    \n    d = smin(star, circle, 0.05);\n    \n    \n    col.r += pow(-d, .1);\n    col.g += abs(d);\n    col.b += pow(abs(d), 0.4);\n    \n    fragColor = vec4(col,1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "XcSXWD",
        "date": "1706307624",
        "viewed": 125,
        "name": "Common renderpass example",
        "username": "jakel101",
        "description": "Figuring out how Common actually works to implement it in wgpu-shadertoy.\nInfo/reference: https://shadertoyunofficial.wordpress.com/2016/07/20/special-shadertoy-features/",
        "likes": 0,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "test"
        ],
        "hasliked": 0,
        "retrieved": "2024-12-21T00:08:28.822842+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "void mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    vec2 uv = (fragCoord - .5/iResolution.xy)/iResolution.y;\n\n    vec3 col = getRed(fract(iTime));\n    col += green;\n    // Output to screen\n    fragColor = vec4(col,1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        },
        {
          "inputs": [],
          "outputs": [],
          "code": "// degree of red from 0.0 to 1.0 as a function\nvec3 getRed(float r){\n    return vec3(r, 0.0, 0.0);\n}\n\n// solid green as a variable\nvec3 green = vec3(0.0, 1.0, 0.0);",
          "name": "Common",
          "description": "",
          "type": "common"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "Xf2SzW",
        "date": "1706104704",
        "viewed": 142,
        "name": "[wip] learning lines",
        "username": "jakel101",
        "description": "learning to draw some lines",
        "likes": 2,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "lines"
        ],
        "hasliked": 0,
        "retrieved": "2024-12-21T00:08:28.822842+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "#define PHI 1.618033988749\n#define TAU 6.283185307179586476925286766559\n\nfloat hash1( float seed){\n    return fract(11.5*seed*fract(PHI * 0.123));\n}\n\n// Basic noise via iq\nfloat bnoise( in float x )\n{    \n    float i = floor(x);\n    float f = fract(x);\n    float s = sign(fract(x/2.0)-0.5);\n    float k = fract(i*PHI);\n\n    return s*f*(f-1.0)*((16.0*k-4.0)*f*(f-1.0)-1.0);\n}\n\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    vec2 uv = fragCoord/iResolution.xy * 2.0 -1.0;\n    \n    // hack cordinate space into polar?\n    float r = length(uv);\n    float a = atan(uv.y,uv.x);\n    vec2 pc = vec2(r,a/TAU*8.0 - 0.175);\n    uv = pc.yx - .4;\n    \n    float line;\n    line = bnoise(uv.x * 5.0 + iTime) * 0.4;\n    line *= 0.7; // scale vertical\n    \n    vec3 col = vec3(0.0);\n    col += vec3(uv.y - line);\n    col = abs(col); // does this count as an SDF?\n    col *= 10.0; // thin the lines?\n    col = 1.0 - clamp(col, 0.0, 1.0); //invert\n    col *= 3.5;\n    col = pow(col, vec3(1.4));\n    \n    // add some \"color\"\n    col *= vec3(0.5, 0.2, 1.0);    \n    fragColor = vec4(col,1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "4f2SzR",
        "date": "1705963517",
        "viewed": 199,
        "name": "iChannelResolution test",
        "username": "jakel101",
        "description": "testing on iChannelResolution behaves.",
        "likes": 0,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "test"
        ],
        "hasliked": 0,
        "retrieved": "2024-12-21T00:08:28.822842+00:00"
      },
      "renderpass": [
        {
          "inputs": [
            {
              "id": 5,
              "src": "/media/a/8de3a3924cb95bd0e95a443fff0326c869f9d4979cd1d5b6e94e2a01f5be53e9.jpg",
              "ctype": "texture",
              "channel": 1,
              "sampler": {
                "filter": "mipmap",
                "wrap": "repeat",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            },
            {
              "id": 8,
              "src": "/media/a/52d2a8f514c4fd2d9866587f4d7b2a5bfa1a11a0e772077d7682deb8b3b517e5.jpg",
              "ctype": "texture",
              "channel": 0,
              "sampler": {
                "filter": "nearest",
                "wrap": "clamp",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            },
            {
              "id": 14,
              "src": "/media/a/cbcbb5a6cfb55c36f8f021fbb0e3f69ac96339a39fa85cd96f2017a2192821b5.png",
              "ctype": "texture",
              "channel": 2,
              "sampler": {
                "filter": "mipmap",
                "wrap": "repeat",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            },
            {
              "id": 15,
              "src": "/media/a/0a40562379b63dfb89227e6d172f39fdce9022cba76623f1054a2c83d6c0ba5d.png",
              "ctype": "texture",
              "channel": 3,
              "sampler": {
                "filter": "mipmap",
                "wrap": "clamp",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            }
          ],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "void mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    vec2 uv = fragCoord/iResolution.xy;\n    vec4 c0 = texture(iChannel0, fragCoord/iChannelResolution[0].xy);\n    vec4 c1 = texture(iChannel1, fragCoord/iChannelResolution[1].xy);\n    vec4 c2 = texture(iChannel2, fragCoord/iChannelResolution[2].xy);\n    vec4 c3 = texture(iChannel3, fragCoord/iChannelResolution[3].xy);\n    \n    vec4 t = vec4(mod(iTime,8.0));\n    \n    // 0 c0, 1 c01, 2 c1, 3 c12, 4 c2, 5 c23, 6 c3, 7 c30, repeat!\n    vec4 c01 = mix(c0, c1, clamp(t-1.0, vec4(0.0), vec4(1.0)));\n    vec4 c23 = mix(c2, c3, clamp(t-5.0, vec4(0.0), vec4(1.0)));\n    vec4 c0123 = mix(c01, c23, clamp(t-3.0, vec4(0.0), vec4(1.0)));\n    \n    \n    fragColor = c0123;\n}\n",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "XfSGRt",
        "date": "1704493098",
        "viewed": 150,
        "name": "First march: a flag pole",
        "username": "jakel101",
        "description": "inspired by: https://youtu.be/khblXafu7iA. Happy for now. more work to do to make it interesting...",
        "likes": 1,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "raymarching"
        ],
        "hasliked": 0,
        "retrieved": "2024-12-21T00:08:28.822842+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "// Apache 2.0 licnese for this shader :)\n\nmat2 rot2D( float angle){\n    float s = sin(angle);\n    float c = cos(angle);\n    return mat2(c, -s, s, c);\n}\n\n// vertical cylinder from @iq MIT license: https://www.shadertoy.com/view/wdXGDr\nfloat sdCylinder( vec3 p, float h, float r )\n{\n  vec2 d = abs(vec2(length(p.xz),p.y)) - vec2(r,h);\n  return min(max(d.x,d.y),0.0) + length(max(d,0.0));\n}\n\n// from @iq: https://iquilezles.org/articles/distfunctions/\nfloat sdBox( vec3 p, vec3 b )\n{\n  vec3 q = abs(p) - b;\n  return length(max(q,0.0)) + min(max(q.x,max(q.y,q.z)),0.0);\n}\n\n// distance to the nearest object\nfloat map( vec3 p ) {\n    // ground is a plane just now\n    float groundHeight = 1.0;    // ground at y = -1.0\n    float ground = p.y + groundHeight; \n    \n    // the \"pole\" is a Cylinder for now\n    float poleHeight = 2.1;   \n    vec3 polePos = vec3(0., -groundHeight + 0.5 * poleHeight, 0.);\n    float poleRadius = 0.05;\n    float pole = sdCylinder(p- polePos, poleHeight, poleRadius);\n    \n    // the \"flag\" is just a thin box right now\n    vec3 flagShape = vec3(.8, 0.45, 0.025);\n    vec3 flagPos = p - vec3(polePos.x, // flag starts in the center\n                        polePos.y + poleHeight - flagShape.y, // flag height is linked to pol height and flag shape\n                        polePos.z);\n    // Flag moving down occasionally, always to half?\n    flagPos.y += smoothstep(0.2, 0.8, sin(iTime* 0.73)) * poleHeight* 0.5;\n                        \n    float windDir = sin(iTime * 0.4); // * p.x; \n    // multiply by flagPos.x or something to make the sway stronger further out??? -tbd\n    flagPos.xz *= rot2D(windDir); // first rotate\n    flagPos.x -= flagShape.x;               // then offset to the side\n    float flag = sdBox(flagPos, flagShape);\n    \n    \n    return min(ground,min(pole,flag));\n}\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    vec2 uv = (fragCoord * 2.0 - iResolution.xy)/iResolution.y;\n    vec2 m = (iMouse.xy * 2.0 - iResolution.xy)/iResolution.y;\n    \n    // Initialize\n    vec3 ro = vec3(0.0, 0.0, -4.0);         // rayOrigin\n    vec3 rd = normalize(vec3(uv, 1));     // rayDirection\n    vec3 col = vec3(0);                   // pixel color\n\n    float t = 0.0;                          //total distance travelled\n    \n    // mouse control\n    ro.yz *= rot2D(-m.y);\n    rd.yz *= rot2D(-m.y);\n    \n    ro.xz *= rot2D(-m.x);\n    rd.xz *= rot2D(-m.x);\n\n    // Raymarching loop\n    int i;\n    vec3 p = vec3(0.0);\n    for (i=0; i<=80; i++){\n        p = ro + rd*t;                 // position along the ray\n        float d = map(p);                   // current distance to next object in the scene\n        \n        t += d;                             // marching step\n        \n        if (d < 0.0005) break;               // early stop near\n        if (d > 50.0) break;        // early stop far\n    }\n    \n    // coloring, make sure to scale down to less than 1.0!!\n    col.g = t * 0.05;\n\n    col.r = float(i) * 0.05;\n    col.b = p.z * 0.23;\n    \n\n    fragColor = vec4(col,1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "4cl3Wn",
        "date": "1702942180",
        "viewed": 187,
        "name": "GLSL Matrix construction",
        "username": "jakel101",
        "description": "Definition: https://www.khronos.org/opengl/wiki/Data_Type_(GLSL)#Matrix_constructors\nHowever it is possible (and often done on shadertoy) to construct a mat2 form a vec4.\nIt's not possible to construct a mat2 from a single vec2 on shadertoy?",
        "likes": 0,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "test",
          "error"
        ],
        "hasliked": 0,
        "retrieved": "2024-12-21T00:08:28.822842+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "void mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    // \"identity\" matrix\n    mat2 a = mat2(0.1);\n    \n    // from vec2: 1 does not work, 2 works\n    // mat2 b1 = mat2(vec2(0.2));\n    mat2 b2 = mat2(vec2(0.2), vec2(0.2));\n    \n    // with two floats\n    mat2 c = mat2(0.3, 0.3, 0.3, 0.3);\n    \n    // with a vec4\n    mat2 d = mat2(vec4(0.4));\n    \n    // some mixture of vec2 and float: e1 and e2 aren't enough components, e3-e5 work\n    // mat2 e1 = mat2(vec2(0.5), 0.5);\n    // mat2 e2 = mat2(0.5, vec2(0.5));\n    mat2 e3 = mat2(vec2(0.5), 0.5, 0.5);\n    mat2 e4 = mat2(0.5, vec2(0.5), 0.5);\n    mat2 e5 = mat2(0.5, 0.5, vec2(0.5));\n    mat2 e6 = mat2(0.5, 0.5, 0.5, vec2(0.5));\n    \n    vec4 col = vec4(a+b2+c+e3+e4+e5+e6);\n    // Output to screen\n    fragColor = vec4(col);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "4cf3Wn",
        "date": "1702928031",
        "viewed": 154,
        "name": "iFrameRate test",
        "username": "jakel101",
        "description": "really simple shader to test iFrameRate functionality for matching it's behaviour. seems to be updated like ~2 times per second? definitely not every frame.",
        "likes": 0,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "test"
        ],
        "hasliked": 0,
        "retrieved": "2024-12-21T00:08:28.822842+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "// see https://www.shadertoy.com/view/lsKGWV for a possible explanation\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    // Normalized pixel coordinates (from 0 to 1)\n    vec2 uv = fragCoord/iResolution.xy;\n    \n    vec3 col = vec3(0.0);\n    // 1.0/iTimeDelta at the top\n    col += (float((1.0/iTimeDelta) / 255.0 >= uv.x) * float(uv.y>=0.5));\n    // iFrameRate at the bottom\n    col += float(iFrameRate/ 255.0 >= uv.x) * float(uv.y<=0.5);\n    \n    // Output to screen\n    fragColor = vec4(col,1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "ctyBDy",
        "date": "1702415786",
        "viewed": 211,
        "name": "Audio Shader: drum machine [WIP]",
        "username": "jakel101",
        "description": "I am learning to write audio shaders, inspiration from: https://youtu.be/3mteFftC7fE and https://youtu.be/zbBY7JL9nnQ",
        "likes": 1,
        "published": 3,
        "flags": 8,
        "usePreview": 0,
        "tags": [
          "audio",
          "learning"
        ],
        "hasliked": 0,
        "retrieved": "2024-12-21T00:08:28.822842+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "void mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    vec2 uv = fragCoord/iResolution.xy * 2.0 -1.0;\n\n    \n    vec2 field = 3.0* vec2(uv.x*fract(-iTime*.5), uv.y -abs(sin(iTime*4.0))+1.0);\n    // fold it?\n    field *= 3.5* mod(abs(field), .5);\n    field.x /= 2.0*uv.x;\n    \n    vec3 col = vec3(0.0);\n    col.r += abs(field.y*field.x)*abs(sin(iTime/.2)+0.5);\n    col.g += abs(field.y*field.x)*abs(sin(iTime/.25)+0.3);\n    col.b += abs(field.y*field.x)*sin(iTime+1.25/.5)-0.1;\n    \n\n    // Output to screen\n    fragColor = vec4(col,1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        },
        {
          "inputs": [],
          "outputs": [],
          "code": "#define TAU 6.2831\n\n// helpers\nfloat hash21(float a, float b){\n    return fract((a*5.421)*(b+2.876)*b);\n}\n\nfloat noise1(float s, float t){\n    return mix(hash21(s, s*s), hash21(2.0*s, -1.0), abs(sin(t)));\n}\n\n//instruments\nfloat bell(float f, float a, float t){\n    return a*sin(TAU*f*t)*exp(-5.0*t);\n}\n\nfloat snare(float f, float a, float t, float d){\n    return a*sin(exp(-TAU*t*f))*exp(-d*t)*noise1(f,t);\n}\n\nfloat triangle(float f, float a, float t){\n    return (a*abs(4.0*f*mod(t,1.0/f)-2.0)-1.0)*exp(-7.0*t);\n}\n\n\n\nvec2 mainSound( int samp, float time )\n{\n    \n    // add on to this for a lazy mix\n    vec2 sig = vec2(0.0);\n    \n    sig += vec2(bell(660.0, 0.5, mod(time + 1.25, 2.0)));    \n    sig += vec2(bell(440.0, 0.3, mod(time + 1.00, 2.0)));\n    \n    \n    sig += vec2(triangle(22.0, .6, mod(time, 0.5)));\n    \n    sig += vec2(triangle(33.0, .8, mod(time, 2.0)));\n    \n    sig += vec2(snare(4.0, 0.3, mod(time + 1.75, 2.0), 1.0));\n    \n    \n    return sig;\n}",
          "name": "Sound",
          "description": "",
          "type": "sound"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "cl3Bzl",
        "date": "1701454047",
        "viewed": 151,
        "name": "shadertoy iChannel test",
        "username": "jakel101",
        "description": "testing iChannel/sampler behaviour for implementing it in wgpu-py",
        "likes": 0,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "test",
          "development"
        ],
        "hasliked": 0,
        "retrieved": "2024-12-21T00:08:28.822842+00:00"
      },
      "renderpass": [
        {
          "inputs": [
            {
              "id": 7,
              "src": "/media/a/fb918796edc3d2221218db0811e240e72e340350008338b0c07a52bd353666a6.jpg",
              "ctype": "texture",
              "channel": 1,
              "sampler": {
                "filter": "mipmap",
                "wrap": "repeat",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            },
            {
              "id": 8,
              "src": "/media/a/52d2a8f514c4fd2d9866587f4d7b2a5bfa1a11a0e772077d7682deb8b3b517e5.jpg",
              "ctype": "texture",
              "channel": 0,
              "sampler": {
                "filter": "mipmap",
                "wrap": "clamp",
                "vflip": "true",
                "srgb": "false",
                "internal": "byte"
              },
              "published": 1
            }
          ],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "void mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    vec2 uv = fragCoord/iResolution.xy;\n    \n    vec4 c0 = texture(iChannel0, uv/(1.0+sin(iTime)));\n    vec4 c1 = texture(iChannel1, uv/(1.0+sin(-iTime)));\n    \n    fragColor = mix(c0,c1,0.5);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "cltfRn",
        "date": "1700872767",
        "viewed": 137,
        "name": "naga panic:index out of bounds",
        "username": "jakel101",
        "description": "investigating a naga panic during validation. In combination with macros, constants and maybe Swizzles and end up with an index out of bounds error",
        "likes": 0,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "test",
          "error"
        ],
        "hasliked": 0,
        "retrieved": "2024-12-21T00:08:28.822842+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "#define MIX2(c) mix(c, c, 0.5)\n\nconst vec2 blank = MIX2(vec2(0.0,1.0));\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    vec2 uv = fragCoord/iResolution.xy;\n    \n    vec2 col = MIX2(uv);\n    \n    fragColor = vec4(col,0.5,1.0);\n}\n",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "Dtyyzt",
        "date": "1700520904",
        "viewed": 93,
        "name": "iDate example",
        "username": "jakel101",
        "description": "inspired by https://www.shadertoy.com/view/ldKGRR; small shader to test if iDate implementation works in wgpu-py shadertoy util ( currently months show seconds, so there is some offset)",
        "likes": 0,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "test",
          "idate"
        ],
        "hasliked": 0,
        "retrieved": "2024-12-21T00:08:28.822842+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "float D(vec2 p, float n) {  // display digit\n    int i=int(p.y), b=int(exp2(floor(30.-p.x-n*3.)));\n    i = ( p.x<0.||p.x>3.? 0:\n    i==5? 972980223: i==4? 690407533: i==3? 704642687: i==2? 696556137:i==1? 972881535: 0 )/b;\n \treturn float(i-i/2*2);\n}\nfloat N(vec2 p, float v) {  // display number\n    for (float n=3.; n>=0.; n--)  // print digit 3 to 0 ( negative = fractionals )\n        if ((p.x-=4.)<3.) return D(p,floor(mod(v/pow(10.,n),10.))); \n    return 0.;\n}    \n\n\nvoid mainImage( out vec4 O, vec2 U )\n{\n    U /= iResolution.xy;\n    \n    float years = iDate.x; // s = 2050\n    float months = iDate.y; // s = 12\n    float days = iDate.z; // s = 31\n    float hours = floor(iDate.w/3600.0); // s = 60\n    float mins = floor(mod(iDate.w/60.0, 60.0)); // s = 60\n    float seconds = floor(mod(iDate.w,60.0)); // s = 60\n    float milisecs = fract(iDate.w)*1000.0; // s = 1000\n    \n    \n   \n    \n    O = vec4(U.x < milisecs/1000.0); // bars\n    \n    O += N(vec2(U.x,mod(U.y,1./7.))*iResolution.xy/6., months) *vec4(1,-1,-1,1); //digits\n\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "DtccWr",
        "date": "1699038672",
        "viewed": 207,
        "name": "WGPU Semantic Error:case not int",
        "username": "jakel101",
        "description": "This is a minimal reproduction of a switch case on Shadertoy using constant ints. It doesn't get translated correctly and throws a Semantic error in naga.",
        "likes": 1,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "error"
        ],
        "hasliked": 0,
        "retrieved": "2024-12-21T00:08:28.822842+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "// 1. declare constant integers\n\nconst int ID_left = 0;\nconst int ID_right = 1;\n\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    vec2 uv = 2.0 * fragCoord/iResolution.xy;\n    \n    int side = int(uv.x);\n \n    vec3 col = vec3(0.2);\n    \n    // 2. switch case on an int\n    switch(side)\n    {\n    // 3. use those constants \n    case ID_left:\n    {\n        col *= 4.0;\n    }\n    case ID_right:\n    {\n        col *= 2.0;\n    }\n    }\n\n    fragColor = vec4(col,1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "dsGBWR",
        "date": "1698104571",
        "viewed": 155,
        "name": "unreachable code for naga panic",
        "username": "jakel101",
        "description": "This shader serves as a minimal example where naga panics during wgsl to spv translation. \nOriginal shader where this was found: https://www.shadertoy.com/view/NsffD2",
        "likes": 1,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "bug",
          "error",
          "reproduction"
        ],
        "hasliked": 0,
        "retrieved": "2024-12-21T00:08:28.822842+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "// step 1: a funciton with an inout input and some other return value\nfloat fn(inout float a) {\n    a += 0.1;\n    return 0.2;\n}\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    // step 2: first variable that is vec2/vec3 (float works)\n    vec2 cd = vec2(0.3, 0.4);\n    \n    // step 3: second variable is assigned to the return value, using first variable as args.\n    float e = fn(cd.x);\n    \n    // Output to screen\n    fragColor = vec4(e);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "DdlcRf",
        "date": "1687052642",
        "viewed": 141,
        "name": "(WIP) a Wug at TaCoS",
        "username": "jakel101",
        "description": "learning some more shader programming by recreating some graphics\nmouse controls the shape of them.",
        "likes": 0,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "2d",
          "logo"
        ],
        "hasliked": 0,
        "retrieved": "2024-12-21T00:08:28.822842+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "// no additional license restrictions, would love to learn about your projects!\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    // Normalized pixel coordinates (from -1 to 1 in the center square)\n    vec2 uv = (fragCoord * 2.0 - iResolution.xy) / iResolution.y;\n    \n    \n    // set all pixels to grey\n    vec3 col = vec3(0.23);\n    \n    // slanted blue box on the left\n    float thickness = 0.02;\n    float slant = -0.25;\n    \n    float width = iMouse.x/iResolution.x;\n    if (iMouse.x<=0.0) {width = 0.3;};\n    float height = iMouse.y/iResolution.y;\n    if (iMouse.y<=0.0) {height = 0.5;};\n    vec2 wug_pos = vec2(-0.4, 0.0);\n    \n    \n    float b = smoothstep(width+thickness,width,abs(uv.x-wug_pos.x+(uv.y*slant)));\n    b *= smoothstep(height+thickness,height,abs(uv.y-wug_pos.y));\n    \n    col.b += b;\n    \n    //joke: eye\n    vec2 eye_pos = vec2(wug_pos.x + 0.6*width, wug_pos.y + 0.7*height);\n    float w = 1.0-smoothstep(0.0, thickness, length(uv-eye_pos)- thickness);\n    col += vec3(w);\n    \n    //legs\n    float leg_length = height*0.4;\n    float leg_slant = sin(iTime) * 0.6;\n    //y component first\n    float wug_bottom = wug_pos.y-(height);\n    float l = smoothstep(wug_bottom+thickness, wug_bottom, uv.y-wug_pos.y);\n    l *= smoothstep(wug_bottom-leg_length, wug_bottom-leg_length+thickness, uv.y-wug_pos.y);\n    // x components\n    float l_1 = smoothstep(thickness,0.0,abs(uv.x-wug_pos.x+(uv.y*(slant+leg_slant))));\n    float l_2 = smoothstep(thickness,0.0,abs(uv.x-wug_pos.x+(uv.y*(slant-leg_slant))));\n    l *= (l_1 + l_2); // combine to legs\n    col -= l;\n    \n    //feet\n    float feet_length = leg_length * width;\n    float leg_end = wug_bottom-leg_length;\n    float f = smoothstep(leg_end+thickness, leg_end, uv.y-wug_pos.y);\n    f *= smoothstep(leg_end-thickness, leg_end, uv.y-wug_pos.y);\n    vec2 f_1_pos = vec2(uv.x-wug_pos.x+(uv.y*(slant+leg_slant)), leg_end);\n    vec2 f_2_pos = vec2(uv.x-wug_pos.x+(uv.y*(slant-leg_slant)), leg_end);\n    float f_1 = smoothstep(leg_length+thickness,leg_length,abs(f_1_pos.x-0.15)+feet_length);\n    float f_2 = smoothstep(leg_length+thickness,leg_length,abs(f_2_pos.x-0.15)+feet_length);\n    f *= (f_1 + f_2);\n    col -= f;\n    \n    \n    \n    //add red circle on top\n    float d = length(uv-eye_pos);\n    d -= sin(iTime*2.5)*0.03;\n    d = smoothstep(4.0*thickness, 0.0, d);\n    col.r += d;\n\n    // Output to screen (add alpha)\n    fragColor = vec4(col,1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "DlGXzh",
        "date": "1685912946",
        "viewed": 173,
        "name": "(WIP) green cubes spinning",
        "username": "jakel101",
        "description": "starting with https://www.shadertoy.com/view/MsX3zr with ideas of https://www.youtube.com/watch?v=O8kAFhSqFdM to recreate the winner of this https://www.instagram.com/p/CrtGz89OUSb/",
        "likes": 1,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "3d",
          "raymarching",
          "distancefield",
          "mouse"
        ],
        "hasliked": 0,
        "retrieved": "2024-12-21T00:08:28.822842+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [],
          "code": "// forked from \"Cubes and Spheres\" by @paulofalcao https://www.shadertoy.com/view/MsX3zr\n\n//Scene Start\n\nvec2 sim2d( in vec2 p, in float s)\n{\n   vec2 ret=p;\n   ret=p+s/2.0;\n   ret=fract(ret/s)*s-s/2.0;\n   return ret;\n}\n\nvec3 stepspace( in vec3 p, in float s)\n{\n  vec3 grid = p-mod(p-s/2.0,s);\n  return grid;\n}\n\n//Object\nfloat obj(in vec3 p)\n{ \n  vec3 fp=stepspace(p,2.0);;\n  float d=2.0+sin(iTime); //y (height) location of the cubes\n  d = d * 1.0/length(.1*p.xz) + 2.0; // this block hole kinda thing in the center. Perhaps I can modify the 2D grid stuff to get an empty center.\n  if (p.x>1.0) d= -5.0; // this moves one half of the cubes higher.\n  p.y=p.y+d;\n  p.xz=sim2d(p.xz,2.0);\n  //c1 is IQ RoundBox from https://iquilezles.org/articles/distfunctions\n  float c1=length(max(abs(p)-vec3(0.7,0.7,0.7),0.0))-0.15;\n  //c2 is a taller cuboid\n  float c2=length(max(abs(p)-vec3(0.3,0.9,0.4),0.0))-0.15;\n  float cf=sin(iTime)*0.5+0.5;\n  return mix(c1,c2,cf);\n}\n\n//Object Color\nvec3 obj_c(vec3 p)\n{\n  vec2 fp=sim2d(p.xz-15.0,16.0);\n  if (fp.y>4.0) fp.x=-fp.x;\n  if (fp.x>0.0) return vec3(0.0,1.0,0.0);\n    else return vec3(0.0,0.1,0.0);\n}\n\n//Scene End\n\n\n//Raymarching Framework Start\n\nfloat PI=3.14159265;\n\nvec3 phong(\n  in vec3 pt,\n  in vec3 prp,\n  in vec3 normal,\n  in vec3 light,\n  in vec3 color,\n  in float spec,\n  in vec3 ambLight)\n{\n   vec3 lightv=normalize(light-pt);\n   float diffuse=dot(normal,lightv);\n   vec3 refl=-reflect(lightv,normal);\n   vec3 viewv=normalize(prp-pt);\n   float specular=pow(max(dot(refl,viewv),0.0),spec);\n   return (max(diffuse,0.0)+ambLight)*color+specular;\n}\n\nfloat raymarching(\n  in vec3 prp,\n  in vec3 scp,\n  in int maxite,\n  in float precis,\n  in float startf,\n  in float maxd,\n  out int objfound)\n{ \n  const vec3 e=vec3(0.1,0,0.0);\n  float s=startf;\n  vec3 c,p,n;\n  float f=startf;\n  objfound=1;\n  for(int i=0;i<256;i++){\n    if (abs(s)<precis||f>maxd||i>maxite) break;\n    f+=s;\n    p=prp+scp*f;\n    s=obj(p);\n  }\n  if (f>maxd) objfound=-1;\n  return f;\n}\n\nvec3 camera(\n  in vec3 prp,\n  in vec3 vrp,\n  in vec3 vuv,\n  in float vpd,\n  in vec2 fragCoord)\n{\n  vec2 vPos=-1.0+2.0*fragCoord.xy/iResolution.xy;\n  vec3 vpn=normalize(vrp-prp);\n  vec3 u=normalize(cross(vuv,vpn));\n  vec3 v=cross(vpn,u);\n  vec3 scrCoord=prp+vpn*vpd+vPos.x*u*iResolution.x/iResolution.y+vPos.y*v;\n  return normalize(scrCoord-prp);\n}\n\nvec3 normal(in vec3 p)\n{\n  //tetrahedron normal\n  const float n_er=0.01;\n  float v1=obj(vec3(p.x+n_er,p.y-n_er,p.z-n_er));\n  float v2=obj(vec3(p.x-n_er,p.y-n_er,p.z+n_er));\n  float v3=obj(vec3(p.x-n_er,p.y+n_er,p.z-n_er));\n  float v4=obj(vec3(p.x+n_er,p.y+n_er,p.z+n_er));\n  return normalize(vec3(v4+v1-v3-v2,v3+v4-v1-v2,v2+v4-v3-v1));\n}\n\nvec3 render(\n  in vec3 prp,\n  in vec3 scp,\n  in int maxite,\n  in float precis,\n  in float startf,\n  in float maxd,\n  in vec3 background,\n  in vec3 light,\n  in float spec,\n  in vec3 ambLight,\n  out vec3 n,\n  out vec3 p,\n  out float f,\n  out int objfound)\n{ \n  objfound=-1;\n  f=raymarching(prp,scp,maxite,precis,startf,maxd,objfound);\n  if (objfound>0){\n    p=prp+scp*f;\n    vec3 c=obj_c(p);\n    n=normal(p);\n    vec3 cf=phong(p,prp,n,light,c,spec,ambLight);\n    return vec3(cf);\n  }\n  f=maxd;\n  return vec3(background); //background color\n}\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord ){\n \n  //Camera animation\n  vec3 vuv=vec3(0,1,0);\n  vec3 vrp=vec3(0.0,0.0,0.0);\n  float mx=iMouse.x/iResolution.x*PI*2.0+(iTime*0.3);\n  float my=iMouse.y/iResolution.y*PI/2.01;\n  // my = 0.05; // stuck view angle by inputting a mouse?\n  if ((iMouse.x<=0.0)||(iMouse.y<=0.0)){mx=1.0,my=0.05;};//quick hack to detect no mouse input for thumbnail\n  // mx =+ iTime * 0.3; // rotation by time\n  vec3 prp=vrp+vec3(cos(my)*cos(mx),sin(my),cos(my)*sin(mx))*12.0; //Trackball style camera pos\n  float vpd=1.5;\n  vec3 light=prp+vec3(5.0,0,5.0);\n  \n  vec3 scp=camera(prp,vrp,vuv,vpd,fragCoord);\n  vec3 n,p;\n  float f;\n  int o;\n  const float maxe=0.01;\n  const float startf=0.1;\n  const vec3 backc=vec3(0.0,0.0,0.0);\n  const float spec=8.0;\n  const vec3 ambi=vec3(0.1,0.1,0.1);\n  \n  vec3 c1=render(prp,scp,256,maxe,startf,60.0,backc,light,spec,ambi,n,p,f,o);\n  c1=c1*max(1.0-f*.015,0.0);\n  vec3 c2=backc;\n  if (o>0){\n    scp=reflect(scp,n);\n    c2=render(p+scp*0.05,scp,32,maxe,startf,10.0,backc,light,spec,ambi,n,p,f,o);\n  }\n  c2=c2*max(1.0-f*.1,0.0);\n  fragColor=vec4(c1.xyz*0.75+c2.xyz*0.25,1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "Dty3Ww",
        "date": "1684075553",
        "viewed": 176,
        "name": "vastness of Image space (WIP)",
        "username": "jakel101",
        "description": "with help of Copilot chat\nIt is meant to show the concept of how vast image space is. Based on a fact noted by Steve Brunton in this video https://www.youtube.com/watch?v=Dt2WYkqZfbs a 20x20 image with just black or white pixels has more information than ",
        "likes": 2,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "random",
          "educational"
        ],
        "hasliked": 0,
        "retrieved": "2024-12-21T00:08:28.822842+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "float modSecs(float modulo)\n{\n    return mod(floor(iTime), modulo);\n}\n\n// an array of 13 int32 numbers can hold the 400bit number for us?\nint[13] number;\n\nbool get_bit(int idx)\n{   \n    // register of which idx of the array we are in\n    int reg = idx >> 5;\n    // remainder of which index in the specific int32 we are in\n    int rem = idx & 0x1F;\n    \n    return ((number[reg] >> int(rem)) & 1) == 0;\n}\n\nbool get_bit_from_float(float inp, int idx)\n{   \n    return ((int(inp) >> idx) & 1) == 1;\n}\n\nvoid set_bit(bool val, int idx)\n{\n    // register of which idx of the array we are in\n    int reg = idx >> 5;\n    // remainder of which index in the specific int32 we are in\n    int rem = idx & 0x1F;\n\n    number[reg] |= (int(val) << rem);\n}\n\n\nvoid mainImage(out vec4 fragColor, in vec2 fragCoord)\n{\n    // Define the resolution of the screen\n    vec2 uv = fragCoord/iResolution.xy;\n\n    vec2 fields = floor(uv * 20.0);\n    \n    float field_idx = fields.x + (fields.y * 20.0);\n\n    // fill number with something \"random\"\n    for (int i = 0; i < 13; i++)\n    {\n        // number[i] = 0xFA0AFA0A; // some funny pattern\n        number[i] = int(fract(sin(floor(iTime)))*165191048.7*float(i+1)); // some \"random\" number constructor for now\n    }\n\n    // set_bit(true, (int(iTime)*2)); // not persistent?\n\n    // Determine the color of the pixel based on its position\n    // color.r (red) is one field at a time, walks around the whole screen in 400 seconds\n    // color.g (green) does nothing right now (working on LSFR to run through all 400 bit of possible numbers randomly)\n    // color.b (blue) is a binary counter of iDate.w (the seconds), counts up to 3600, but runs over at 32 bit.\n    vec3 color = vec3(mod(field_idx - modSecs(400.0),400.0), get_bit(int(field_idx)), get_bit_from_float(iDate.w, int(field_idx)));\n\n    // just look at red channel\n    // color = vec3(color.r);\n    \n    // just look at green channel\n    color = vec3(color.g);\n\n    // just look at blue channel\n    // color = vec3(color.b);\n\n    // Set the color of the pixel\n    fragColor = vec4(color, 1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    },
    {
      "ver": "0.1",
      "info": {
        "id": "7tXyRl",
        "date": "1648509925",
        "viewed": 215,
        "name": "WIP checkerboard",
        "username": "jakel101",
        "description": "trying to understand shaders a bit at a time",
        "likes": 2,
        "published": 3,
        "flags": 0,
        "usePreview": 0,
        "tags": [
          "2d",
          "pattern"
        ],
        "hasliked": 0,
        "retrieved": "2024-12-21T00:08:28.822842+00:00"
      },
      "renderpass": [
        {
          "inputs": [],
          "outputs": [
            {
              "id": 37,
              "channel": 0
            }
          ],
          "code": "#define PI 3.14\n\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord )\n{\n    // Normalized pixel coordinates (from 0 to 1)\n    vec2 uv = fragCoord/iResolution.xy;\n\n    // Time varying pixel color\n    vec3 white = vec3(1.,1.,1.);\n    \n    vec3 col = .5 * white;\n    \n    float x = floor(sin(8.0 * PI * uv.x));\n    float y = floor(sin(8.0 * PI * uv.y));\n    \n    col += (x);\n    col -= y;\n    \n    // Output to screen\n    fragColor = vec4(col,1.0);\n}",
          "name": "Image",
          "description": "",
          "type": "image"
        }
      ]
    }
  ]
}