sporsh/_heightmap.png

## _heightmap.png

      
    Raw
  

              _heightmap.png
            
          
## astigmatism.html
<!DOCTYPE html>
<html>

<head>
    <meta charset="utf-8">
    <title>Astigmatism eye test</title>
    <style>
        canvas {
            position: fixed;
            top: 0;
            left: 0;
            width: 100%;
            height: 100%;
        }
    </style>

    <script>
        var angle = 0;
        var radius = 20;
        var tile, tileCtx, ctx;

        onload = function() {
            tile = document.createElement('canvas');
            tileCtx = tile.getContext('2d');
            ctx = canvas.getContext('2d');
            draw();
        }


        function draw() {
            tile.width = tile.height = radius * 2;
            tileCtx.lineWidth = Math.max(1, radius / 3);
            var cos = Math.cos(angle / 360 * Math.PI);
            var sin = Math.sin(angle / 360 * Math.PI);
            var x1 = (cos * radius) + radius;
            var y1 = (sin * radius) + radius;
            var x2 = tile.width - x1;
            var y2 = tile.height - y1;
            tileCtx.beginPath();
            tileCtx.moveTo(x1, y1);
            tileCtx.lineTo(x2, y2);
            tileCtx.stroke();

            var pattern = ctx.createPattern(tile, 'repeat');
            canvas.width = window.innerWidth;
            canvas.height = window.innerHeight;
            ctx.save();
            var offsetX = canvas.width / 2 + radius;
            var offsetY = canvas.height / 2 + radius;
            ctx.translate(offsetX, offsetY);
            ctx.fillStyle = pattern;
            // ctx.rotate(angle * Math.PI);
            ctx.fillRect(-offsetX, -offsetY, canvas.width, canvas.height);
            ctx.restore();
        }

        // onmousemove = function(event) {
        //     angle = event.offsetX / window.innerWidth * 2 * Math.PI;
        //     draw();
        // }

        onwheel = function(event) {
            console.log(event);
        }

        onkeyup = function(event) {
            switch (event.keyIdentifier) {
                case "Up":
                case "U+004B":
                    radius *= 1.5;
                    break;
                case "Down":
                case "U+004D":
                    radius /= 1.5;
                    break;
                case "Left":
                    angle -= 5;
                    break;
                case "Right":
                    angle += 5;
                    break;
                default:
            }
            draw();
        }
    </script>
</head>

<body>
    <canvas id="canvas" />
</body>

</html>

## astigmatism2.html
<!DOCTYPE html>
<html>

<head>
    <meta charset="utf-8">
    <style>
        canvas {
            position: fixed;
            top: 0;
            left: 0;
            width: 100%;
            height: 100%;
        }
    </style>

    <script>
        var angle = 0;
        var radius = 10;
        var tile, tileCtx, ctx;

        onload = function() {
            tile = document.createElement('canvas');
            tileCtx = tile.getContext('2d');
            ctx = canvas.getContext('2d');
            draw();
        }


        function draw() {
            tile.width = tile.height = radius * 2;
            tileCtx.lineWidth = Math.max(1, radius / 3);
            var cos = Math.cos(angle);
            var sin = Math.sin(angle);
            var x1 = (cos * radius);
            var y1 = (sin * radius);
            // var x1 = (cos * radius) + (tile.width / 2);
            // var y1 = (sin * radius) + (tile.height / 2);
            var x2 = tile.width - x1;
            var y2 = tile.height - y1;
            tileCtx.beginPath();
            tileCtx.moveTo(x1, y1);
            tileCtx.lineTo(x2, y2);
            tileCtx.stroke();
            tileCtx.beginPath();
            tileCtx.moveTo(x1 + tile.width/4, y1 + tile.height/4);
            tileCtx.lineTo(x2 + tile.width/4, y2 + tile.height/4);
            tileCtx.stroke();
            var pattern = ctx.createPattern(tile, 'repeat');

            canvas.width = window.innerWidth;
            canvas.height = window.innerHeight;
            var offsetX = canvas.width / 2 + radius;
            var offsetY = canvas.height / 2 + radius;
            ctx.save();
            ctx.translate(offsetX, offsetY);
            ctx.fillStyle = pattern;
            ctx.fillRect(-offsetX, -offsetY, canvas.width, canvas.height);
            ctx.restore();
        }

        onmousemove = function(event) {
            angle = event.offsetX / window.innerWidth * 2 * Math.PI;
            draw();
        }

        onkeyup = function(event) {
            console.log(event);
            switch (event.keyIdentifier) {
                case "U+004B":
                    radius *= 1.5;
                    break;
                case "U+004D":
                    radius /= 1.5;
                    break;
                default:
            }
            draw();
        }
    </script>
</head>

<body>
    <canvas id="canvas">
</body>

</html>

## cool.html
<style>
    #canvas {
        background: linear-gradient(#a25b5b, #2d1821);
    }
</style>
<canvas id="canvas"></canvas>
<button onclick="toggle()">Start/Stop</button>
<script>
    canvas.width = canvas.height = 0xff;
    canvas.width = canvas.height; //0xff * 2;
    halfWidth = canvas.width / 2;
    halfHeight = canvas.height / 2;

    ctx = canvas.getContext('2d');
    var id = ctx.getImageData(0, 0, canvas.width, canvas.height);
    id32 = new Uint32Array(id.data.buffer);

    a = .25 * Math.PI;
    fov = 180 / 180 * Math.PI;
    // da = fov / canvas.width; a0 = a - camera.fov / 2;
    cosa = Math.cos(a);
    sina = Math.sin(a);
    d = canvas.width / fov;
    // d = 128; d = 0xff / 2;

    frames = 0;

    origin = [0, 0, -1];
    getDirection = function(x, y) {
        return [
            origin[0] + (x - halfWidth) / halfWidth,
            origin[1] + (y - halfHeight) / halfHeight,
            1
        ]
    }

    function length(v) {
        return Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
    }

    function distanceSphere(x, y, z) {
        let radius = .5;
        return length([x, y, z]) - radius;
    }

    function distanceTorus(x, y, z) {
        var t = [.5, .2]
        // var l = [Math.sqrt(x * x + z * z) - t[0], y];
        var l = [Math.sqrt(x * x + y * y) - t[0], z];
        return Math.sqrt(l[0] * l[0] + l[1] * l[1]) - t[1];
    }

    // normal(p, f) {
    //     var epsilon = 0.001;
    //     return [
    //         f(p[0]+epsilon, p[1], p[2])
    //     ]
    // }

    function cast(trace) {
        for (; trace.t < 1; trace.t += .0051) {
            // if (distanceSphere(
            if (distanceTorus(
                    trace.origin[0] + trace.direction[0] * trace.t,
                    trace.origin[1] + trace.direction[1] * trace.t,
                    trace.origin[2] + trace.direction[2] * trace.t) <= 0) {
                return true;
            }
        }
        return false;
    }

    function update(time) {
        canvas.width = canvas.width;
        ox = time / 100

        for (x = 0; x < canvas.width; x++) {
            for (y = 0; y < canvas.height; y++) {
                i = ((y * canvas.width) + x);

                let trace = {
                    origin: origin,
                    direction: getDirection(x, y),
                    t: 0,
                }

                if (cast(trace)) {
                    // id32[i] = getColor(trace);
                    // id32[i] = 0xff00ffff;
                    i *= 4;
                    id.data[i] = id.data[i + 1] = id.data[i + 2] = 0xff - trace.t * 0xff;
                    id.data[i + 3] = 0xff;
                } else {
                    id32[i] = 0x00ffffff;
                }

                // i = ((y * canvas.width) + x) * 4;
            }
        }
        ctx.putImageData(id, 0, 0);

        dt = performance.now() - time;
        ctx.fillStyle = '#fff'
            // ctx.fillText('fps: ' + parseInt(1 / (dt / 1000)) + ' frames: ' + ++frames, 10, 10)
        ctx.fillText('fps: ' + parseInt(1 / (dt / 1000)), 10, 10);
        ctx.fillText('frame: ' + ++frames, 10, 20);
        animationFrameRequestId = requestAnimationFrame(update);
    }

    var animationFrameRequestId;

    toggle = function() {
        if (animationFrameRequestId) {
            cancelAnimationFrame(animationFrameRequestId)
            animationFrameRequestId = null;
        } else {
            animationFrameRequestId = requestAnimationFrame(update);
        }
    }
</script>

## genetic-trace.html
<style>
    #canvas {
        /*background: #000;*/
    }
</style>
<canvas id="canvas"></canvas>
<button onclick="toggle()">Start/Stop</button>
<script src="https://cdnjs.cloudflare.com/ajax/libs/dat-gui/0.5.1/dat.gui.js"></script>
<script>
    canvas.width = canvas.height = 0xff;
    canvas.width = canvas.height; //0xff * 2;
    halfWidth = canvas.width / 2;
    halfHeight = canvas.height / 2;

    ctx = canvas.getContext('2d');
    var id = ctx.getImageData(0, 0, canvas.width, canvas.height);
    id32 = new Uint32Array(id.data.buffer);
    id32.fill(0xff000000);

    let i = (10 + 10 * canvas.width) * 4;
    id.data[i] += 0x30;

    ctx.putImageData(id, 0, 0);

    var cloneFittest = true;
    var maxPopulation = 100;
    var crossoverProbability = .5;
    var mutationProbability = .5;
    var mutationStrength = 20;
    var population = [];

    var selectA = 'randomLinearRank'
    var selectB = 'sequential'

    var gui = new dat.GUI();
    gui.add(window, "cloneFittest");
    gui.add(window, "maxPopulation", 0, 1000);
    gui.add(window, "crossoverProbability", 0, 1);
    gui.add(window, "mutationProbability", 0, 1);
    gui.add(window, "mutationStrength", 0, 100);
    gui.add(window, "selectA", ['fittest', 'random', 'randomLinearRank', 'sequential']);
    gui.add(window, "selectB", ['fittest', 'random', 'randomLinearRank', 'sequential']);


    function seed() {
        return [
            Math.round(Math.random() * canvas.width),
            Math.round(Math.random() * canvas.height)
        ];
    }

    function fitness(p) {
        let i = p[0] + p[1] * canvas.width;
        return id.data[i * 4];
    }

    function init(population, num) {
        for (i = 0; i < num; i++) {
            population.push(seed());
        }
    }

    init(population, maxPopulation);
    console.log(population)
    render(population)

    function render(population) {
        population.forEach(p => {
            let i = (p[0] + p[1] * canvas.width) * 4;
            id.data[i] += 0x30;
        });
        ctx.putImageData(id, 0, 0);
    }

    var select = {
        fittest: (generation) => generation[0].individual,
        random: (generation) => generation[Math.floor(Math.random() * generation.length)].individual,
        randomLinearRank: (generation, n) => generation[Math.floor(Math.random() * Math.min(generation.length, n))].individual,
        sequential: (generation, n) => generation[n % generation.length].individual
    }

    function crossover(a, b) {
        return [a[0], b[1]]
    }

    function mutate(i) {
        return [
            Math.min(canvas.width - 1, Math.max(0, i[0] + Math.round((Math.random() - .5) * mutationStrength))),
            Math.min(canvas.height - 1, Math.max(0, i[1] + Math.round((Math.random() - .5) * mutationStrength)))
        ]
    }

    function evolve() {
        render(population);

        // Mesaure fitness of individuals
        let generation = population
            .map(p => {
                return {
                    fitness: fitness(p),
                    individual: p
                }
            })
            .sort((a, b) => a.fitness - b.fitness);

        var newPopulation = [];

        if (cloneFittest) {
            newPopulation.push(generation[0].individual);
        }

        // Crossover and mutate to build new population
        let n = 0;
        while (newPopulation.length < maxPopulation) {
            let a = select[selectA](generation, ++n);
            if (Math.random() < crossoverProbability) {
                let b = select[selectB](generation, ++n);
                let ab = crossover(a, b);
                let ba = crossover(b, a);
                newPopulation.push(Math.random() < mutationProbability ? mutate(ab) : ab);
                newPopulation.push(Math.random() < mutationProbability ? mutate(ba) : ba);
                newPopulation.push(Math.random() < mutationProbability ? mutate(ba) : ba);
            } else {
                newPopulation.push(Math.random() < mutationProbability ? mutate(a) : a);
            }
        }

        population = newPopulation;
        // console.log(generation)
        animationFrameRequestId = requestAnimationFrame(evolve);
    }

    var animationFrameRequestId;

    toggle = function() {
        if (animationFrameRequestId) {
            cancelAnimationFrame(animationFrameRequestId)
            animationFrameRequestId = null;
        } else {
            animationFrameRequestId = requestAnimationFrame(evolve);
        }
    }
</script>

## genetic.html
<script src="https://cdnjs.cloudflare.com/ajax/libs/dat-gui/0.5.1/dat.gui.js"></script>
<style>
    #canvas {
        background: #000;
    }
</style>
<canvas id="canvas"></canvas>
<button onclick="evolve()">Start/Stop</button>

<script>
    canvas.width = canvas.height = 0xff;
    canvas.width = canvas.height; //0xff * 2;
    halfWidth = canvas.width / 2;
    halfHeight = canvas.height / 2;

    var gui = new dat.GUI();
    gui.add(canvas, "width", 0, 400);
    gui.add(canvas, "height", 0, 400)

    ctx = canvas.getContext('2d');
    var id = ctx.getImageData(0, 0, canvas.width, canvas.height);
    id32 = new Uint32Array(id.data.buffer);


    var population = [];

    function seed() {
        return [
            Math.random() * canvas.width,
            Math.random() * canvas.height
        ];
    }

    function fitness(p) {
        return Math.sqrt(p[0] * p[0] + p[1] * p[1])
    }

    function init(population, num) {
        for (i = 0; i < num; i++) {
            population.push(seed());
        }
    }

    init(population, 10);

    function render(population) {
        ctx.fillStyle = '#000';
        ctx.globalAlpha = 0.1;
        ctx.fillRect(0, 0, canvas.width, canvas.height);
        ctx.globalAlpha = 1;
        ctx.fillStyle = '#fff'
        population.forEach(p => {
            ctx.beginPath();
            ctx.arc(p[0], p[1], 1.5, 0, 2 * Math.PI)
            ctx.fill();
        });
    }

    function cross(p1, p2) {
        return [
            (p1[0] + p2[0]) / 2,
            (p1[1] + p2[1]) / 2
        ];
    }

    var select = {
        fittest: (generation) => generation[0].individual,
        random: (generation) => generation[Math.floor(Math.random() * generation.length)].individual,
        randomLinearRank: (generation, n) => generation[Math.floor(Math.random() * Math.min(generation.length, n))].individual,
        sequential: (generation, n) => generation[n % generation.length].individual
    }

    function crossover(a, b) {
        return [a[0], b[1]]
    }

    function mutate(i) {
        return [
            i[0] + i[0] * (Math.random() - .5),
            i[1] + i[1] * (Math.random() - .5),
        ]
    }

    var cloneFittest = true;
    var maxPopulation = 20;
    var mutationProbability = 0.2;

    function evolve() {
        render(population);

        // Mesaure fitness of individuals
        let generation = population
            .map(p => {
                return {
                    fitness: fitness(p),
                    individual: p
                }
            })
            .sort((a, b) => a.fitness - b.fitness);

        var newPopulation = [];

        if (cloneFittest) {
            newPopulation.push(generation[0].individual);
        }

        // Crossover and mutate to build new population
        let n = 0;
        while (newPopulation.length < maxPopulation) {
            let a = select.randomLinearRank(generation, ++n);
            let b = select.randomLinearRank(generation, ++n);
            let ab = crossover(a, b);
            let ba = crossover(b, a);
            newPopulation.push(Math.random() < mutationProbability ? mutate(ab) : ab);
            newPopulation.push(Math.random() < mutationProbability ? mutate(ba) : ba);
        }

        population = newPopulation;
        console.log(generation[0].individual)
    }
</script>

## heightmap.html
<style>
    #canvas {
        background: linear-gradient(#22a, #aae);
        transform: scaleY(-1);
    }

    img {
        display: none;
    }
</style>
<canvas id="canvas"></canvas>
<canvas id="map"></canvas>
<img id="mapImg" src="data:image/png;base64,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">
<script>
    map.width = map.height = 0xff;
    mapCtx = map.getContext('2d');
    mapCtx.drawImage(mapImg, 0, 0, map.width, map.height);
    heightmap = mapCtx.getImageData(0, 0, map.width, map.height);

    canvas.width = canvas.height = 0xff;
    canvas.width = 0xff * 2;
    ctx = canvas.getContext('2d');

    mapCtx.fillStyle = mapCtx.strokeStyle = '#ff0'

    x0 = map.width / 4;
    y0 = map.height / 4;
    a = .25 * Math.PI;
    fov = 180 / 180 * Math.PI;

    // da = fov / canvas.width; a0 = a - camera.fov / 2;
    cosa = Math.cos(a);
    sina = Math.sin(a);
    d = canvas.width / fov;
    // d = 128; d = 0xff / 2;

    x1 = x0 + d * cosa;
    y1 = y0 + d * sina;

    // Draw camera position
    mapCtx.beginPath();
    mapCtx.arc(x0, y0, 5, 0, 2 * Math.PI);
    mapCtx.stroke();

    // Draw camera direction
    mapCtx.beginPath();
    mapCtx.moveTo(x0, y0);
    mapCtx.lineTo(x1, y1)
        // mapCtx.lineTo(camera.x + Math.cos(camera.a + camera.fov / 2) * 50, camera.y + Math.sin(camera.a + camera.fov / 2) * 50) mapCtx.lineTo(camera.x, camera.y)
    mapCtx.stroke();

    ox = x0;
    oy = y0;
    frames = 0;

    function update(time) {
        canvas.width = canvas.width;
        ox = time / 100
            // oy -=1

        // Loop through each vertical span
        for (x = 0; x < canvas.width; x++) {
            // Start at the camera position
            x0 = ox;
            y0 = oy;

            // Calculate the end position
            var x3d = (x - canvas.width / 2);
            x1 = x0 + (cosa * x3d + sina * d);
            y1 = y0 + (-sina * x3d + cosa * d);

            // x1 = 0 | x1;
            // y1 = 0 | y1;
            // x1 %= map.width;
            // y1 %= map.height;
            // i = ((y1 * map.width + x1) * 4);
            // ctx.fillStyle = 'rgb(' + heightmap.data[i + 0] + ',' + heightmap.data[i + 1] + ',' + heightmap.data[i + 2] + ')'; // if (x == 10)
            // console.log(ctx.fillStyle, i, x1, y1) ctx.fillRect(x, canvas.height / 2, 1, 10);
            // mapCtx.fillRect(x1, y1, 1, 1);
            // a += da;
            // if (x == 0) {


            // Reset the y-buffer
            ymin = 0;

            // Trace the ray in `tmax` steps
            tmax = 128;

            dx = (x1 - x0) / tmax;
            dy = (y1 - y0) / tmax;
            // console.log(d, x1-x0, dx)

            for (t = 1; t < tmax; t++) {
                x0 += dx;
                y0 += dy;
                // mapCtx.fillRect(x0, y0, 1, 1);

                i = (((0 | y0) * map.width + (0 | x0)) * 4);
                h = heightmap.data[i + 3] - 128;
                h = (h / t * 20) + 128;
                h = Math.max(ymin, h) | 0;
                if (h > ymin) {
                    ctx.fillStyle = 'rgb(' + heightmap.data[i + 0] + ',' + heightmap.data[i + 1] + ',' + heightmap.data[i + 2] + ')';
                    ctx.fillRect(x, ymin, 1, h - ymin);
                }
                ymin = Math.max(h, ymin)
            }
            // }
        }

        dt = performance.now() - time;
        ctx.fillStyle = '#000'
        ctx.fillText('fps: ' + (1 / (dt / 1000)) + 'frames: ' + ++frames, 10, 10)
        animationFrameRequestId = requestAnimationFrame(update);
    }

    animationFrameRequestId = requestAnimationFrame(update);

    onclick = function() {
        cancelAnimationFrame(animationFrameRequestId)
    }
</script>

## heightmap.png

      
    Raw
  

              heightmap.png
            
          
## hm2.html
<!DOCTYPE html>
<html>
    <head>
        <meta charset="utf-8">
        <title></title>

        <style>
            #canvas {
                background: linear-gradient(#22a, #aae);
            }

        </style>

        <script>
            var heigtmap,
                heightBuf32;

            var ctx,
                imageData,
                buf32,
                animationFrame,
                prevTime,
                frames = 0;

            u0 = 0;
            v0 = 0;

            function recurse(x0, x1) {
                'use strict';
                let d = x1-x0;
                if (d > 2) {
                let u = x0 + (d / 2)|0;
                let y = 0 | (Math.random() * 10 + canvas.height / 2);
                for (let h = 0; h < 10; h++) {
                    let i = (y + h) * canvas.width + u;
                    // buf32[i] = 0xffff00ff; // ABGR
                    buf32[i] = heightBuf32[i] | 0xff000000;
                }
                recurse(x0, u);
                recurse(u, x1);
                }
            }

            function render(time) {
                // Clear image buffer
                buf32.fill(0x00);

                // Render new image data
                for (x = 0; x < canvas.width; x++) {
                    // u = u0; v = v0; data = heightmap.data[u + v * heightmap.width]; w = data >> 3; // Alpha channel w0 = w / 0xff * 2 - 1; // Convert height map data byte to [-1,1] range c = data | 0xff000000; // Color data + solid alpha

                    y = 0 | (Math.random() * 10 + canvas.height / 2);
                    for (h = 0; h < 10; h++) {
                        i = (y + h) * canvas.width + x;
                        // buf32[i] = 0xffff00ff; // ABGR
                        buf32[i] = heightBuf32[i] | 0xff000000;
                    }
                }

                frames += 1;

                // Display new image data
                ctx.putImageData(imageData, 0, 0);
                if (prevTime) {
                    ctx.fillText('FPS ' + (1000 / (time - prevTime) | 0), 4, 12)
                }

                // Prepare next frame
                prevTime = time;
                animationFrame = window.requestAnimationFrame(render);
            }

            // Load heigtmap data
            heightMapImg = new Image();
            heightMapImg.src = 'heightmap.png';
            heightMapImg.onload = function () {
                ctx = canvas.getContext('2d');

                // Grab heightmap data
                canvas.width = heightMapImg.width;
                canvas.height = heightMapImg.height;
                ctx.drawImage(heightMapImg, 0, 0);
                heightmap = ctx.getImageData(0, 0, canvas.width, canvas.height);
                heightBuf32 = new Uint32Array(heightmap.data.buffer);

                // Initialize canvas and image data buffer
                canvas.width = canvas.height = 0xff;
                ctx.font = '8px monospace'
                imageData = ctx.createImageData(canvas.width, canvas.height);
                buf32 = new Uint32Array(imageData.data.buffer);

                // Enter render loop
                // animationFrame = window.requestAnimationFrame(render);

                // Experiment...
                console.log(0, canvas.width)
                recurse(0, canvas.width)
                // Display new image data
                ctx.putImageData(imageData, 0, 0);
                if (prevTime) {
                    ctx.fillText('FPS ' + (1000 / (time - prevTime) | 0), 4, 12)
                }
            }

            onclick = function () {
                // Stop render loop
                window.cancelAnimationFrame(animationFrame);
            }
        </script>

    </head>
    <body>
        <canvas id="canvas"></canvas>
        <img src="heightmap.png"/>
    </body>
</html>

## index.html
<style>
    #canvas {
        object-fit: contain;
        position: fixed;
        top: 0;
        left: 0;
        width: 100%;
        height: 100%;
        background: linear-gradient(#456, #200);
    }
</style>

<canvas id="canvas" />

<script>
    audioContext = new AudioContext();
    gain = audioContext.createGain();
    gain.gain.value = .1;
    gain.connect(audioContext.destination);

    context = canvas.getContext('2d');


    MIN_F = 50;
    MAX_F = 800;
    MIN_D = 100;
    MAX_D = 1000;
    MIN_A = 5;
    MAX_A = 20;

    minFps = 999;
    maxFps = 0;


    function mutateNote(note) {
        note.frequency.value = Math.random() * (MAX_F - MIN_F) + MIN_F;
        // note.frequency = Math.random() * (MAX_F - MIN_F) + MIN_F;
        note.duration = Math.random() * (MAX_D - MIN_D) + MIN_D;
        // note.amplitude = Math.random() * (MAX_A - MIN_A) + MIN_A;
    }

    function generateNote(type) {
        note = audioContext.createOscillator();
        note.type = type || 'sine';
        mutateNote(note);
        note.start();
        note.connect(gain);
        return note;
    }

    notes = [
        // generateNote('sawtooth'),
        // generateNote('sine'),
        // generateNote('triangle'),
        generateNote('square'),
    ];

    function update(time) {
        if (!window.currentTime) {
            currentTime = time - 1000 / 60;
        }
        previousTime = currentTime;
        currentTime = time;

        deltaTime = currentTime - previousTime;

        fps = 1000 / deltaTime;
        minFps = Math.min(fps, minFps);
        maxFps = Math.max(fps, maxFps);

        // update stuff
        // console.log(time)
        notes.forEach(note => {
            note.duration -= deltaTime;
            if (note.duration <= 0) {
                mutateNote(note);
            }
        });

        // reset canvas
        height = canvas.height = 512;
        width = canvas.width = 512;
        // width = canvas.width = 0 | height * innerWidth / innerHeight;

        // render visuals
        context.shadowColor = '#fff';
        // context.shadowBlur = 24;

        context.shadowBlur = 10;
        context.strokeStyle = '#fff';
        notes.forEach(note => {
            context.beginPath();
            y = height / MAX_F * (MAX_F - note.frequency.value) + Math.sin((currentTime/20000) * note.frequency.value) * 10;
            // y = ((note.frequency.value - MIN_F) / (MAX_F - MIN_F)) * height + Math.sin(currentTime / (note.frequency.value / 4)) * 10;
            context.moveTo(0, y);
            context.lineTo(width, y);
            context.stroke();
        });

        // render stats
        context.shadowBlur = 0;
        context.strokeStyle = '#fff';
        context.strokeText(['FPS: ' + (0 | fps), 0 | minFps, 0 | maxFps], 10, 20);

        requestAnimationFrame(update);
    }

    requestAnimationFrame(update);

    onclick = function() {
        audioContext.suspend();
        update = function() {}
    }
</script>

## index2.html
<style>

#b {
  position: fixed;
  top: 0;
  left: 0;
  width: 100%;
  height: 100%;
  background: radial-gradient(circle, #345, #201);
}

</style><audio id="a"></audio><canvas id="b"></canvas><script>

str='';
notesFreq = [155,195,261,155,233,155,195,207,195,207,195,207,195,207,195,261,155,233,155,233,261,155,233,155,233,155,233,261,155,195,261,195,207,195,261,155,233,155,233,155,195,207,233,155,233,155,195,207,195,207,233,261,155,233,261,233,261,155,195,207,195,207,195,207,195,261,233,155,195,207,233,261,233,155,233,261,155,195,207,195,261,155,233,261,155,233,261,195,261,233,261,155,233,155,195,207,233,261,233,155,195,261,233,155,195,261,195,261,155,233,261,195,207,233,261,195,207,195,261,233,155,195,261,155,195,207,195,261];
notesIndex = 0;

for(time=0;time<60;time+=1/16384) {
  frac= (time&4?time*6:time*4)%1;
  notesIndex += frac==0;
  sample = (time * notesFreq[notesIndex%notesFreq.length] % 1) * (1 - frac) * 16;

  frac = time*2%1;
  sample += (Math.random()) * Math.pow(1-frac, 8) * 16;


  str += String.fromCharCode(sample + 127);
}


a.src = 'data:audio/wav;base64,UklGRiQAAABXQVZFZm10IBAAAAABAAEAA'
        + 'EAAAABA' // 16khz
        + 'AAABAAgAZGF0YQAAAAAA' + btoa(str);
a.play();


c=b.getContext('2d');
ps = [];
COUNT = 2560;
for(i=0;i<COUNT; i++) {
  ps.push({
    x: (Math.random()-.5)*256 * 2,
    y: (Math.random()-.5)*256 * 2,
    z: (Math.random()-.5)*256 * 2,
    u: i / 48 % 1,
    v: i / 48 / 48,
    col: i & 1 ? '#eee' : '#ddd'
    })
};

render = function() {
  requestAnimationFrame(render);
  time = a.currentTime;

  H=b.height=512;
  W=b.width=0|innerWidth/innerHeight*H;
  c.translate(W/2,H/2);

  angle = time;

  c.rotate((angle&13)/32);

  ps.forEach(p => {
    if (p.v < 1) {
      an = p.u*Math.PI*2;

  frac = time*2%1;
  frac = Math.pow(1-frac, 2);

      d = 64 + frac * 32 * Math.cos(an*4)*Math.cos(p.v*6+time*4);
      p.x = d*Math.cos(an);
      p.z = d*Math.sin(an);
      p.y = 384*(p.v-.5);
    p.col =  'rgb('+
        [255-d*4|0,
         255-d*4|0,
         255-d*4|0] +')'
    }

    p.rx = Math.cos(angle) * p.x - Math.sin(angle) * p.z;
    p.rz = Math.sin(angle) * p.x + Math.cos(angle) * p.z;
    p.ry = p.y;


    p.p = (384+p.rz)/256;
    p.sx = p.p*p.rx;
    p.sy = p.p*p.ry;

  });

  ps.sort((a, b) => a.rz - b.rz)

  ps.forEach(p => {

    c.shadowColor = c.fillStyle = p.col;
    s = p.p*8;
    c.shadowBlur = p.v < 1 ? 0 : s;
    c.fillRect(p.sx,p.sy,s,s);
  })

}
render();

</script>

## index3.html
<canvas id="canvas">
	<script>
		var context = canvas.getContext("2d"),
			a, b, position;

		function surface(a, b) {
			var angle = a * Math.PI * 2,
				radius = 100,
				length = 400,
				x = a * 400,
				y = b * 400,
				z = a * b * 200,
				yAxisRotationAngle = -.40, // in radians!
				rotatedX = x * Math.cos(yAxisRotationAngle) + z * Math.sin(yAxisRotationAngle),
				rotatedZ = x * -Math.sin(yAxisRotationAngle) + z * Math.cos(yAxisRotationAngle);

			return {
				x: rotatedX,
				y: y,
				z: rotatedZ,
				r: 0 | a * 255,
				g: 0 | b * 255,
				b: 0
			};
		}
		// function surface(a, b) {
		// 	var angle = a * Math.PI * 2,
		// 		radius = 100,
		// 		length = 400,
		// 		x = Math.cos(angle) * radius,
		// 		y = Math.sin(angle) * radius,
		// 		z = b * length - length / 2,
		// 		yAxisRotationAngle = -.4, // in radians!
		// 		rotatedX = x * Math.cos(yAxisRotationAngle) + z * Math.sin(yAxisRotationAngle),
		// 		rotatedZ = x * -Math.sin(yAxisRotationAngle) + z * Math.cos(yAxisRotationAngle);
		//
		// 	return {
		// 		x: rotatedX,
		// 		y: y,
		// 		z: rotatedZ,
		// 		r: 0,
		// 		g: 0 | b * 255,
		// 		b: 0
		// 	};
		// }

		var pX, pY, // projected on canvas x and y coordinates
			perspective = 350,
			halfHeight = canvas.height / 2,
			halfWidth = canvas.width / 2,
			cameraZ = -700;

		var zBuffer = [],
			zBufferIndex;

		// for (a = 0; a < 1; a += .001) {
		// 	for (b = 0; b < 1; b += .01) {
		// 		if (point = surface(a, b)) {
		// 			pX = Math.floor((point.x * perspective) / (point.z - cameraZ) + halfWidth);
		// 			pY = Math.floor((point.y * perspective) / (point.z - cameraZ) + halfHeight);
		// 			zBufferIndex = pY * canvas.width + pX;
		// 			if ((typeof zBuffer[zBufferIndex] === "undefined") || (point.z < zBuffer[zBufferIndex])) {
		// 				zBuffer[zBufferIndex] = point.z;
		// 				context.fillStyle = "rgb(" + point.r + "," + point.g + "," + point.b + ")";
		// 				context.fillRect(pX, pY, 1, 1);
		// 			}
		// 		}
		// 	}
		// }

		var i;

		// window.setInterval(function() {
		for (i = 0; i < 50000; i++) {
			if (point = surface(Math.random(), Math.random())) {
				pX = Math.floor((point.x * perspective) / (point.z - cameraZ) + halfWidth);
				pY = Math.floor((point.y * perspective) / (point.z - cameraZ) + halfHeight);
				zBufferIndex = pY * canvas.width + pX;
				if ((typeof zBuffer[zBufferIndex] === "undefined") || (point.z < zBuffer[zBufferIndex])) {
					zBuffer[zBufferIndex] = point.z;
					context.fillStyle = "rgb(" + point.r + "," + point.g + "," + point.b + ")";
					context.fillRect(pX, pY, 1, 1);
				}
			}
		}
		// }, 0);
	</script>

## kdtree.html
<script>
    class KDNode {
        constructor(axis, d, children) {
            this.axis = axis;
            this.d = d;
            this.children = children || [];
        }

        intersect(origin, direction) {
            // Determine wich side of the splitting plane the origin lies within
            let originChildIndex = +(origin[this.axis] > this.d);

            if (direction[this.axis] === 0) {
                // Direction parallel to splitting plane, and will never intersect splitting plane
                // Only traverse origin side of splitting plane
                this.children[originChildIndex].intersect(origin, direction);
            } else {
                // Distance from origin to splitting plane
                let t = (this.d - origin[this.axis]) / direction[thid.axis];
                if (t >= 0) {
                    // Direction points towards splitting plane, so both sides must be considered
                    // Traverse origin side of splitting plane first, then the other side
                    this.children[originChildIndex].intersect(origin, direction);
                    this.children[originChildIndex ^ 1].intersect(origin, direction);
                } else {
                    // Direction points away from splitting plane, so will never intersect splitting plane
                    // Only traverse origin side of splitting plane
                    this.children[originChildIndex].intersect(origin, direction);
                }
            }
        }
    }
</script>

<script>
    function createVoxelData(width, height, depth) {
        return {
            width: width,
            height: height,
            depth: depth,
            data: new Uint32Array(width * height * depth)
        }
    }

    voxelData = createVoxelData(3, 3, 3);
    for (let x = 0; x < voxelData.width; x++) {
        for (let y = 0; y < voxelData.height; y++) {
            for (let z = 0; z < voxelData.depth; z++) {
                let i = z * voxelData.width * voxelData.height + y * voxelData.width + x;
                voxelData[i] = 0xff;
            }
        }
    }
</script>

<style>
    #canvas {
        background: linear-gradient(#a25b5b, #2d1821);
        width: 20px;
        height: 200px;
    }

    #circle {
        fill: #f00;
    }
</style>
<svg width="300" height="200" viewBox="-2 -1 3 2" style="background: black">
    <polyline id="view" points="-2,0 -1,1 -1,-1" fill="rgba(255, 255, 255,.25)" />
    <circle id="circle" cx="0" cy="0" r="0.5" fill="#ff0000"/>
    <line id="ray" x1="-2" y1="0"
      x2="-1" y2="1"
      stroke="yellow"
      stroke-width=".01"/>
</svg>
<canvas id="canvas"></canvas>
<button onclick="toggle()">Start/Stop</button>
<script>
    console.log(ray.x2.baseVal.value)

    origin = [view.points[0].x, view.points[0].y];
    console.log(origin)
    top = [view.points[1].x, view.points[1].y];
    bottom = [view.points[2].x, view.points[2].y];

    circle.origin = [circle.cx.baseVal.value, circle.cy.baseVal.value];
    circle.radius = circle.r.baseVal.value;
    circle.color = parseInt(circle.getAttribute('fill').replace('#', '0x'));

    canvas.width = 1;
    canvas.height = 200;
    ctx = canvas.getContext('2d');
    var id = ctx.getImageData(0, 0, canvas.width, canvas.height);
    id32 = new Uint32Array(id.data.buffer);

    function getDirection(y) {
        let d = normalize([-origin[0], y]);
        ray.x2.baseVal.value = d[0];
        ray.y2.baseVal.value = d[1];
        return d;
    }

    function dot(a, b) {
        return a[0] * b[0] + a[1] * b[1];
    }

    function length(v) {
        return Math.sqrt(v[0] * v[0] + v[1] * v[1]);
    }

    function normalize(v) {
        let l = length(v);
        return [v[0] / l, v[1] / l];
    }

    vec = [-1, -1]
    console.log("VEC", vec)
    console.log("LEN", length(vec))
    console.log("NORM", normalize(vec))
    console.log(circle.origin)

    function cast(trace) {
        let m = [
            trace.origin[0] - circle.origin[0],
            trace.origin[1] - circle.origin[1]
        ];

        let b = dot(m, trace.direction);
        let c = dot(m, m) - circle.radius * circle.radius;

        console.log(trace, m, b, c)

        if (c > 0 && b > 0) {
            // Origin outside circle and pointing away
            return false;
        }

        let discr = b * b - c;
        if (discr < 0) {
            // Negative discriminant indicates ray missing sphere
            return false;
        }

        trace.t = -b - Math.sqrt(discr);
        if (trace.t < 0) {
            // Negative t indicates ray origin within circle
            // Clamp to 0
            trace.t = 0;
        }
        return true;
    }

    function update(time) {
        canvas.width = canvas.width;
        ox = time / 100

        for (i = 0; i < canvas.height; i++) {
            let y = ((i / canvas.height) * 2) - 1;

            let trace = {
                origin: origin,
                direction: getDirection(y),
                t: 0,
            }

            if (cast(trace)) {
                // let i = y * 4;
                // id.data[i] = id.data[i + 1] = id.data[i + 2] = 0xff - trace.t * 0xff;
                // id.data[i + 3] = 0xff;
                id32[i] = 0xff0000ff;
            } else {
                id32[i] = 0x00ffffff;
            }

            // i = ((y * canvas.width) + x) * 4;
        }
        ctx.putImageData(id, 0, 0);
        animationFrameRequestId = requestAnimationFrame(update);
    }

    var animationFrameRequestId;

    toggle = function() {
        if (animationFrameRequestId) {
            cancelAnimationFrame(animationFrameRequestId)
            animationFrameRequestId = null;
        } else {
            animationFrameRequestId = requestAnimationFrame(update);
        }
    }
</script>

## octree.html
<style>
    #canvas {
        object-fit: contain;
        position: fixed;
        top: 0;
        left: 0;
        width: 100%;
        height: 100%;
        /*background: radial-gradient(#456, #200);*/
        /*background: linear-gradient(#456, #200);*/
        background-color: black;
    }
</style>

<canvas id="canvas" />

<script>
    context = canvas.getContext('2d');

    minFps = 999;
    maxFps = 0;

    function ClosestPtPointAABB(p, b, q) {
        for (var i = 0; i < 3; i++) {
            var v = p[i];
            if (v < b.min[i]) v = b.max[i];
            if (v > b.max[i]) v = b.min[i];
            q[i] = v;
        }
    }

    // Computes the square distance between a point p and an AABB b
    function sqDistPointAABB(point, aabb) {
        var sqDist = 0.0;
        for (var i = 0; i < 3; i++) {
            // For each axis count any excess distance outside box extents
            var v = point[i];
            if (v < aabb.min[i]) sqDist += (aabb.min[i] - v) * (aabb.min[i] - v);
            if (v > aabb.max[i]) sqDist += (v - aabb.max[i]) * (v - aabb.max[i]);
        }
        return sqDist;
    }

    function testSphereAABB(sphere, aabb) {
        // Compute squared distance between sphere center and AABB
        var sqDist = sqDistPointAABB(sphere.center, aabb);
        // Sphere and AABB intersect if the (squared) distance
        // between them is less than the (squared) sphere radius
        return sqDist <= sphere.radius * sphere.radius;
    }

    function testSceneAABB(aabb) {
        return spheres.some(sphere => {
            return testSphereAABB(sphere, aabb);
        })
    }

    MIN_W = 0.05;
    var spheres = [{
        center: [0.5, 0.5, 0.5],
        radius: 0.1
    }, {
        center: [0.5, 0.5, 0.5],
        radius: 0.25,
    }];

    var pX, pY, perspective = 1,
        halfHeight = canvas.height / 2,
        halfWidth = canvas.width / 2,
        cameraZ = -1;

    function traverseOct(min, w, k) {
        var aabb = {
            min: min.slice(0),
            max: [min[0] + w[0], min[1] + w[1], min[2] + w[2]]
        }
        if (testSceneAABB(aabb)) {
            // if (testSphereAABB(sphere, aabb)) {
            // if (w <= MIN_W) {
            if (k >= 15) {
                // render hit
                pX = 0 | ((min[0] - .5) * perspective / (min[2] - cameraZ) + .5) * canvas.width;
                pY = 0 | ((min[1] - .5) * perspective / (min[2] - cameraZ) + .5) * canvas.height;
                // context.fillStyle = "green";
                // context.fillStyle = 'rgb(' + (0 | ((1 - min[2]) * 255)) + ',' + (0 | (1 - min[2]) * 255) + ',' + (0 | (1 - min[2]) * 255) + ')';
                // context.strokeStyle = 'rgb(' + (0 | ((1 - min[2]) * 255)) + ',' + (0 | (1 - min[2]) * 255) + ',' + (0 | (1 - min[2]) * 255) + ')';
                context.fillStyle = context.strokeStyle = '#fff';
                context.globalAlpha = .05;
                // context.fillRect(pX, pY, 2, 2);
                // context.beginPath();
                // context.arc(pX, pY, 2, 0, 2 * Math.PI);
                // context.fill();
                context.strokeRect(pX, pY, w[0] * canvas.width, w[1] * canvas.height);
                context.fillRect(pX, pY, w[0] * canvas.width, w[1] * canvas.height);
            } else {
                // subdivide
                var i = k%3;
                var w2 = w.slice(0);
                var min2 = min.slice(0);
                w2[i] = w2[i] / 2;
                traverseOct(min2, w2, k+1);
                min2[i] += w2[i];
                traverseOct(min2, w2, k+1);
                // traverseOct(min[i] + w[i], w, k+1);

                // w = w / 2;
                // traverseOct(x + w, y + w, z + w, w)
                // traverseOct(x + w, y, z + w, w)
                // traverseOct(x, y + w, z + w, w)
                // traverseOct(x, y, z + w, w)
                // traverseOct(x + w, y + w, z, w)
                // traverseOct(x, y + w, z, w)
                // traverseOct(x + w, y, z, w)
                // traverseOct(x, y, z, w)
            }
        }
    }

    function update(time) {
        if (!window.currentTime) {
            currentTime = time - 1000 / 60;
        }
        previousTime = currentTime;
        currentTime = time;

        deltaTime = currentTime - previousTime;

        fps = 1000 / deltaTime;
        minFps = Math.min(fps, minFps);
        maxFps = Math.max(fps, maxFps);

        // update stuff
        spheres[0].center[0] = 0.5 + (Math.cos(currentTime / 1000)) / 4;
        spheres[0].center[1] = 0.5 + (Math.sin(currentTime / 2000)) / 4;
        spheres[0].center[2] = 0.5 + (Math.sin(currentTime / 1000)) / 4;

        spheres[1].center[0] = 0.5 + (Math.sin(currentTime / 500)) / 3;
        spheres[1].center[1] = 0.5 + (Math.cos(currentTime / 2000)) / 3;
        spheres[1].center[2] = 0.5 + (Math.cos(currentTime / 1000)) / 2;
        // spheres[1].radius = 0.2 + 0.1 * Math.sin(currentTime / 1000 * 4);

        // reset canvas
        height = canvas.height = 512;
        width = canvas.width = 512;
        // width = canvas.width = 0 | height * innerWidth / innerHeight;

        // render visuals
        // context.shadowColor = '#fff';
        // context.shadowBlur = 24;
        context.shadowBlur = 10;
        context.strokeStyle = '#fff';
        traverseOct([0, 0, 0], [1, 1, 1], 0);

        // render stats
        context.shadowBlur = 0;
        context.strokeStyle = '#fff';
        context.strokeText(['FPS: ' + (0 | fps), 0 | minFps, 0 | maxFps], 10, 20);

        requestAnimationFrame(update);
    }

    requestAnimationFrame(update);

    onclick = function() {
        update = function() {}
    }
</script>

## pathtrace.html
<script>
    class V3 {
        static new() {
            return new Float32Array(3);
        }
        static fromValues(x, y, z) {
            return Float32Array.of(x, y, z);
        }
        static add(a, b, result) {
            result = result || V3.new();
            result[0] = a[0] + b[0];
            result[1] = a[1] + b[1];
            result[2] = a[2] + b[2];
            return result;
        }
        static sub(a, b, result) {
            result = result || V3.new();
            result[0] = a[0] - b[0];
            result[1] = a[1] - b[1];
            result[2] = a[2] - b[2];
            return result;
        }
        static scale(v, s, result) {
            result = result || V3.new();
            result[0] = v[0] * s;
            result[1] = v[1] * s;
            result[2] = v[2] * s;
            return result;
        }
        static dot(a, b) {
            return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
        }
        static length(v) {
            return Math.sqrt(V3.dot(v, v));
        }
        static normalize(v, result) {
            result = result || V3.new();
            let scale = 1 / V3.length(v);
            return V3.scale(v, scale, result);
        }
    }
</script>

<script>
    class Sphere {
        constructor(center, radius) {
            this.center = center;
            this.radius = radius;
            this.radius2 = radius * radius;
        }

        intersect(ray, test, epsilon) {
            let m = V3.sub(ray.origin, this.center);
            let c = V3.dot(m, m) - this.radius2;

            if (test && c < epsilon) {
                return true;
            }

            let b = V3.dot(m, ray.direction);
            if (b > 0) {
                return false
            }

            let discr = b * b - c;
            if (discr < 0) {
                return false;
            }

            if (test) {
                return true;
            }

            let inside = false;
            let sqrtDiscr = Math.sqrt(discr);
            let t = -b - sqrtDiscr;
            if (t < epsilon) {
                inside = true;
                t = -b + sqrtDiscr;
                if (t < epsilon) {
                    return false;
                }
            }

            let point = V3.add(ray.origin, V3.scale(ray.direction, t));
            return {
                point: point,
                t: t,
                inside: inside,
                normal: V3.normalize(V3.sub(point, this.center))
            };
        }
    }
</script>

<script>
    class GeometryGroup {
        constructor(...geometries) {
            this.geometries = geometries;
        }

        intersect(ray, test, epsilon) {
            return this.geometries
                .map(geometry => geometry.intersect(ray, test, epsilon))
                .reduce((previous, current) => {
                    if (!previous) {
                        return current;
                    }
                    if (current) {
                        if (current.t < previous.t) {
                            return current;
                        } else {
                            return previous;
                        }
                    } else {
                        return previous;
                    }
                });
        }
    }
</script>

<script src="https://cdnjs.cloudflare.com/ajax/libs/dat-gui/0.5.1/dat.gui.js"></script>

<script>
    class PathTracer {
        constructor() {
            this.scene = new GeometryGroup(
                new Sphere(V3.fromValues(0, 0, 100), 99),
                new Sphere(V3.fromValues(-100, 0, 0), 99),
                new Sphere(V3.fromValues(100, 0, 0), 99),
                new Sphere(V3.fromValues(0, 100, 0), 99),
                new Sphere(V3.fromValues(0, -100, 0), 99),

                // new Sphere(V3.fromValues(-1, -1, 1), .2),
                // new Sphere(V3.fromValues(1, 1, 1), .2),
                // new Sphere(V3.fromValues(-1, 1, 1), .2),
                // new Sphere(V3.fromValues(1, -1, 1), .2)

                // new Sphere(V3.fromValues(.5, 0, 0), .5),
                new Sphere(V3.fromValues(0, 0, 0), .25)
            );
            this.light = new Sphere(V3.fromValues(-.25, .25, -.5), .2);
            this.epsilon = 0.001;
        }

        sample(ray) {
            let intersection = this.scene.intersect(ray, false, this.epsilon);
            if (intersection) {
                // Intensity color
                let incidence = V3.normalize(V3.sub(this.light.center, intersection.point));
                let lambert = V3.dot(intersection.normal, incidence);
                if (lambert < 0) {
                    return 0xff000000;
                }
                let c = Math.min(0xff, ~~(lambert * this.light.radius * 0xff));
                // return 0xff000000 | c << 16 | c << 8 | c;

                let r = ((intersection.normal[0]) + 1) / 2 * c;
                let g = ((intersection.normal[1]) + 1) / 2 * c;
                let b = ((intersection.normal[2]) + 1) / 2 * c;
                return 0xff000000 | r << 16 | g << 8 | b;

                // Normal color
                // let r = ((intersection.normal[0]) + 1) / 2 * 0xff;
                // let g = ((intersection.normal[1]) + 1) / 2 * 0xff;
                // let b = ((intersection.normal[2]) + 1) / 2 * 0xff;
                // return 0xff000000 | r << 16 | g << 8 | b;
            } else {
                return 0xff000000;
            }
        }
    }

    class ViewPort {
        constructor(canvas) {
            this.ctx = canvas.getContext('2d');
            this.imageData = this.ctx.getImageData(0, 0, canvas.width, canvas.height);
            console.log(this.imageData)
            this.id8 = this.imageData.data.buffer;
            this.id32 = new Uint32Array(this.id8);
            this.halfWidth = canvas.width / 2;
            this.halfHeight = canvas.height / 2;

            this.origin = V3.fromValues(0, 0, -1);
        }

        render(renderer, time) {
            for (let y = 0; y < this.imageData.height; y++) {
                for (let x = 0; x < this.imageData.width; x++) {
                    let direction = this.getRayThrough(x, y);
                    let color = renderer.sample({
                        origin: this.origin,
                        direction: direction
                    })
                    this.setColor(x, y, color);
                }
            }
            this.updateCanvas();
        }

        getRayThrough(x, y) {
            let target = V3.fromValues(
                2 * x / this.imageData.width - 1,
                2 * y / this.imageData.height - 1,
                0
            )
            return V3.normalize(V3.sub(target, this.origin));
        }

        setColor(x, y, color) {
            let i = x + y * this.imageData.width;
            this.id32[i] = color;
        }

        updateCanvas() {
            this.ctx.putImageData(this.imageData, 0, 0);
        }
    }

    function onLoad() {
        let pathTracer = new PathTracer();
        canvas.width = canvas.height = 0xff;
        let viewPort = new ViewPort(canvas);

        canvas.addEventListener('mousemove', ({
            offsetX,
            offsetY
        }) => {
            let x = offsetX / canvas.width * 2 - 1;
            let y = offsetY / canvas.height * 2 - 1;
            pathTracer.light.center[0] = x;
            pathTracer.light.center[1] = y;
        })

        var animationFrameRequestId;
        let ui = {
            run: function() {
                viewPort.render(pathTracer);
                animationFrameRequestId = requestAnimationFrame(ui.run);
            },

            toggle: function() {
                if (animationFrameRequestId) {
                    cancelAnimationFrame(animationFrameRequestId)
                    animationFrameRequestId = null;
                } else {
                    animationFrameRequestId = requestAnimationFrame(ui.run);
                }
            }
        }

        var gui = new dat.GUI();
        gui.add(ui, 'toggle');
        gui.add(pathTracer.light, 'radius', 0, 10);
    }
</script>

<body onload="onLoad()">
    <canvas id="canvas"></canvas>
</body>

## random.js
var seed = function(s) {
    return function() {
        s = Math.sin(s) * 10000;
        return s - Math.floor(s);
    };
};


function Random(seed) {
    this.seed = seed;
}
Random.prototype.next = function() {
    this.seed = Math.sin(this.seed) * 10000;
    return this.seed - Math.floor(this.seed);
};


random = new Random(23);
random.next();

## raymarch.html
<style>
    #canvas {
        /*object-fit: contain;
        position: fixed;*/
        /*top: 0;
        left: 0;*/
        /*width: 256px;
        height: 256px;*/
        /*background: radial-gradient(#456, #200);*/
        /*background: linear-gradient(#456, #200);*/
        background-color: black;
    }
</style>
a
<canvas id="heightmap" height="256" width="256"></canvas>
b
<canvas id="canvas" height="256" width="256"></canvas>
c
<script>
    var ctx = heightmap.getContext('2d');
    var id = ctx.getImageData(0, 0, heightmap.width, heightmap.height);

    function generateHeightMap() {
        id.data.fill(0xff);
        console.log(heightmap.width)
        for (var y = 0; y < heightmap.height; y++) {
            var y_ = y / heightmap.height;
            for (var x = 0; x < heightmap.width; x++) {
                var x_ = x / heightmap.width;
                i = ((y * heightmap.width) + x) * 4;
                var v = 0 | volume(x_, y_) * 0xff;
                id.data[i] = id.data[i + 1] = id.data[i + 2] = v;
            }
        }
        ctx.putImageData(id, 0, 0);
    }

    context = canvas.getContext('2d');
    imageData = context.getImageData(0, 0, canvas.width, canvas.height);
    imageData.data.fill(0xff);

    // function volume(x, y) {
    //     return Math.random()
    // }
    // function volume(x, y) {
    //     x -= .5;
    //     y -= .5;
    //     x *= 3;
    //     y *= 2;
    //     if (x && y) {
    //         return 1 / (x * x + y * y);
    //     } else {
    //         return 1;
    //     }
    // }
    // function volume(x, y) {
    //     return Math.sin(5 * y * Math.PI) / 2 - Math.cos(5 * x * Math.PI) / 2;
    // }
    function volume(x, y) {
        return .7 - y * .5;
    }

    // function draw(time) {
    //     // update stuff
    //
    //     // reset canvas
    //     height = canvas.height = 256;
    //     width = canvas.width = 256;
    //
    //     // render visuals
    //     context.fillStyle = context.strokeStyle = context.shadowColor = '#fff';
    //     // context.shadowBlur = 24;
    //     // march([0, 0, 0], [1, 1, 1], 0);
    //     for (y = 0; y < imageData.height; y++) {
    //         y_ = (y / imageData.height) - .5;
    //         for (x = 0; x < imageData.width; x++) {
    //             x_ = (x / imageData.width) - .5;
    //             i = ((y * imageData.width) + x) * 4;
    //             v = volume(x_, y_) / 100 * 0xff;
    //             imageData.data[i] = v;
    //             imageData.data[i + 1] = v;
    //             imageData.data[i + 2] = v;
    //             // imageData.data[x * 4 + y * canvas.width + 0] = 0 | volume(x_, y_) * 255;
    //             // imageData.data[x * 4 + y * canvas.width + 1] = 0 | volume(x_, y_) * 255;
    //             // imageData.data[x * 4 + y * canvas.width + 2] = 0 | volume(x_, y_) * 255;
    //         }
    //         console.log(x_, y_, volume(x_, y_))
    //     }
    //     context.putImageData(imageData, 0, 0);
    //
    //     // render stats
    //     context.strokeText([((performance.now() - time) / 1000)], 10, 20);
    // }

    var camera = {
        x: 256/2,
        y: 256/2,
        z: 0,
    }

    yBuffer = [];

    function draw(time) {
        for (x = 0; x < imageData.width; x++) {
            x_ = (x / imageData.width);
            ymin = 0;
            dx = x - camera.x;
            for (z = imageData.height; z > 0; z--) {
                // for (z = 0; z < imageData.height; z++) {
                z_ = z / imageData.height;
                y_ = volume(x_, z_);
                // yBuffer[x] = Math.max(yBuffer[x] || 0, y_);
                ymax = y_ * imageData.height;
                dy = ymax - ymin;
                if (ymin < ymax) {
                    // console.log(ymin, ymax, dy)
                    context.fillStyle = context.strokeStyle = context.shadowColor = 'rgb(' + (0 | y_ * 0xff) + ',' + (0 | y_ * 0xff) + ',' + (0 | y_ * 0xff) + ')';
                    context.fillRect(x, imageData.height - ymin, 1, -dy)
                        // context.fillRect(x, y_ * imageData.height, 1, 1)
                    ymin = ymax;
                }
            }
        }
    }

    generateHeightMap();
    draw(performance.now());
</script>

## raymarch2.html
<style>
    body {
        background-color: black;
    }

    #canvas {
        background-color: #333;
        transform: scaleY(-1);
    }
</style>
<canvas id="heightmap" height="256" width="256"></canvas>
<canvas id="canvas" height="256" width="256"></canvas>
<script>
    var ctx = heightmap.getContext('2d');
    var id = ctx.getImageData(0, 0, heightmap.width, heightmap.height);

    function generateHeightMap() {
        id.data.fill(0xff);
        for (var y = 0; y < heightmap.height; y++) {
            var y_ = y / heightmap.height;
            for (var x = 0; x < heightmap.width; x++) {
                var x_ = x / heightmap.width;
                i = ((y * heightmap.width) + x) * 4;
                var v = 0 | volume(x_, y_) * 0xff;
                id.data[i] = id.data[i + 1] = id.data[i + 2] = v;
            }
        }
        ctx.putImageData(id, 0, 0);
        ctx.fillStyle = '#00f';
        ctx.fillRect(0, camera.z * heightmap.height, heightmap.width, 1);
    }


    function volume(x, y) {
        return Math.sin(3 * y * 2 * Math.PI) * Math.cos(3 * x * 2 * Math.PI);
    }

    var camera = {
        x: 256 / 2,
        y: 256 / 2,
        z: 0,
    }

    yBuffer = [];
    context = canvas.getContext('2d');

    function draw(time) {
        // canvas.width = canvas.width;
        for (x = 0; x < canvas.width; x++) {
            x_ = x / canvas.width;
            y_ = volume(x_, camera.z);
            y = (1 + y_) * (canvas.height / 2);
            yBuffer[x] = yBuffer[x] || 0;
            if (y > yBuffer[x]) {
                color = (0 | y_ * 0xff).toString(16);
                color = '00'.substring(0, 2 - color.length) + color;
                context.fillStyle = '#' + color + color + color;
                context.fillRect(x, yBuffer[x], 1, y - yBuffer[x]);
            }
            yBuffer[x] = Math.max(yBuffer[x] || 0, y);
        }
    }

    heightmap.onclick = function(event) {
        camera.z = event.offsetY / this.height;
        generateHeightMap();
        draw(performance.now());
    }

    // for (var z = 0xff; z > 0; z--) {
    //     // for (var z = 0; z > 0xff; z++) {
    //     camera.z = z / 0xff;
    //     draw(performance.now());
    // }
    generateHeightMap();
    console.log("DONE")
</script>

## raymarch3.html
<style>
    body {
        background-color: black;
    }

    #canvas {
        background-color: #abc;
        transform: scaleY(-1);
    }
</style>
<canvas id="heightmap" height="256" width="256"></canvas>
<canvas id="canvas" height="256" width="256"></canvas>
<script>
    var ctx = heightmap.getContext('2d');
    var id = ctx.getImageData(0, 0, heightmap.width, heightmap.height);

    function generateHeightMap() {
        id.data.fill(0xff);
        for (var y = 0; y < heightmap.height; y++) {
            var y_ = y / heightmap.height;
            for (var x = 0; x < heightmap.width; x++) {
                var x_ = x / heightmap.width;
                i = ((y * heightmap.width) + x) * 4;
                var v = 0 | volume(x_, y_) * 0xff;
                id.data[i] = id.data[i + 1] = id.data[i + 2] = v;
            }
        }
        ctx.putImageData(id, 0, 0);
        ctx.fillStyle = '#00f';
        ctx.fillRect(camera.u * heightmap.width, 0, 1, heightmap.height);
        ctx.fillRect(0, camera.v * heightmap.height, heightmap.width, 1);
    }


    function volume(x, y) {
        return Math.sin(3 * y * 2 * Math.PI) * Math.cos(3 * x * 2 * Math.PI) - .5;
        // return (0 | (v * 50)) / 50;
    }

    var camera = {
        u: .5,
        v: 0,
        r: 1.25 * Math.PI,
    }

    yBuffer = [];
    context = canvas.getContext('2d');

    function draw(time) {
        canvas.width = canvas.width;
        for (x = 0; x < canvas.width; x++) {
            r = camera.r + ((x / canvas.width) * Math.PI / 2);
            // console.log(camera.r,x, canvas.width)
            cos = Math.cos(r);
            sin = Math.sin(r);

            u1 = camera.u;
            v1 = camera.v;
            u2 = u1 + cos;
            v2 = v1 + sin;

            tMax = 100;
            du = (u2 - u1) / tMax;
            dv = (v2 - v1) / tMax;

            minY = 0;

            for (t = 0; t < tMax; t++) {
                t_ = t / tMax;
                u1 += du;
                v1 += dv;

                y_ = volume(u1, v1);
                y = (y_ * canvas.height * (1 - t_)) + (canvas.height / 2);

                if (y > minY) {
                    color = (0 | (1 + y_) / 2 * 0xff).toString(16);
                    color = '00'.substring(0, 2 - color.length) + color;
                    context.fillStyle = '#' + color + color + color;
                    context.fillRect(x, minY, 1, y - minY);
                }
                minY = Math.max(minY, y);
            }
        }
    }

    heightmap.onclick = function(event) {
        camera.u = event.offsetX / this.width;
        camera.v = event.offsetY / this.height;
        generateHeightMap();
        draw(performance.now());
    }
</script>

## vector.js
function length2(v) {
    return v[0] * v[0] + v[1] * v[1] + v[2] * v[2];
}

function length(v) {
    return Math.sqrt(length2(v));
}

function dot(v) {}
	<!DOCTYPE html>
	<html>

	<head>
	<meta charset="utf-8">
	<title>Astigmatism eye test</title>
	<style>
	canvas {
	position: fixed;
	top: 0;
	left: 0;
	width: 100%;
	height: 100%;
	}
	</style>

	<script>
	var angle = 0;
	var radius = 20;
	var tile, tileCtx, ctx;

	onload = function() {
	tile = document.createElement('canvas');
	tileCtx = tile.getContext('2d');
	ctx = canvas.getContext('2d');
	draw();
	}


	function draw() {
	tile.width = tile.height = radius * 2;
	tileCtx.lineWidth = Math.max(1, radius / 3);
	var cos = Math.cos(angle / 360 * Math.PI);
	var sin = Math.sin(angle / 360 * Math.PI);
	var x1 = (cos * radius) + radius;
	var y1 = (sin * radius) + radius;
	var x2 = tile.width - x1;
	var y2 = tile.height - y1;
	tileCtx.beginPath();
	tileCtx.moveTo(x1, y1);
	tileCtx.lineTo(x2, y2);
	tileCtx.stroke();

	var pattern = ctx.createPattern(tile, 'repeat');
	canvas.width = window.innerWidth;
	canvas.height = window.innerHeight;
	ctx.save();
	var offsetX = canvas.width / 2 + radius;
	var offsetY = canvas.height / 2 + radius;
	ctx.translate(offsetX, offsetY);
	ctx.fillStyle = pattern;
	// ctx.rotate(angle * Math.PI);
	ctx.fillRect(-offsetX, -offsetY, canvas.width, canvas.height);
	ctx.restore();
	}

	// onmousemove = function(event) {
	// angle = event.offsetX / window.innerWidth * 2 * Math.PI;
	// draw();
	// }

	onwheel = function(event) {
	console.log(event);
	}

	onkeyup = function(event) {
	switch (event.keyIdentifier) {
	case "Up":
	case "U+004B":
	radius *= 1.5;
	break;
	case "Down":
	case "U+004D":
	radius /= 1.5;
	break;
	case "Left":
	angle -= 5;
	break;
	case "Right":
	angle += 5;
	break;
	default:
	}
	draw();
	}
	</script>
	</head>

	<body>
	<canvas id="canvas" />
	</body>

	</html>
	<style>
	#canvas {
	background: linear-gradient(#a25b5b, #2d1821);
	}
	</style>
	<canvas id="canvas"></canvas>
	<button onclick="toggle()">Start/Stop</button>
	<script>
	canvas.width = canvas.height = 0xff;
	canvas.width = canvas.height; //0xff * 2;
	halfWidth = canvas.width / 2;
	halfHeight = canvas.height / 2;

	ctx = canvas.getContext('2d');
	var id = ctx.getImageData(0, 0, canvas.width, canvas.height);
	id32 = new Uint32Array(id.data.buffer);

	a = .25 * Math.PI;
	fov = 180 / 180 * Math.PI;
	// da = fov / canvas.width; a0 = a - camera.fov / 2;
	cosa = Math.cos(a);
	sina = Math.sin(a);
	d = canvas.width / fov;
	// d = 128; d = 0xff / 2;

	frames = 0;

	origin = [0, 0, -1];
	getDirection = function(x, y) {
	return [
	origin[0] + (x - halfWidth) / halfWidth,
	origin[1] + (y - halfHeight) / halfHeight,
	1
	]
	}

	function length(v) {
	return Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
	}

	function distanceSphere(x, y, z) {
	let radius = .5;
	return length([x, y, z]) - radius;
	}

	function distanceTorus(x, y, z) {
	var t = [.5, .2]
	// var l = [Math.sqrt(x * x + z * z) - t[0], y];
	var l = [Math.sqrt(x * x + y * y) - t[0], z];
	return Math.sqrt(l[0] * l[0] + l[1] * l[1]) - t[1];
	}

	// normal(p, f) {
	// var epsilon = 0.001;
	// return [
	// f(p[0]+epsilon, p[1], p[2])
	// ]
	// }

	function cast(trace) {
	for (; trace.t < 1; trace.t += .0051) {
	// if (distanceSphere(
	if (distanceTorus(
	trace.origin[0] + trace.direction[0] * trace.t,
	trace.origin[1] + trace.direction[1] * trace.t,
	trace.origin[2] + trace.direction[2] * trace.t) <= 0) {
	return true;
	}
	}
	return false;
	}

	function update(time) {
	canvas.width = canvas.width;
	ox = time / 100

	for (x = 0; x < canvas.width; x++) {
	for (y = 0; y < canvas.height; y++) {
	i = ((y * canvas.width) + x);

	let trace = {
	origin: origin,
	direction: getDirection(x, y),
	t: 0,
	}

	if (cast(trace)) {
	// id32[i] = getColor(trace);
	// id32[i] = 0xff00ffff;
	i *= 4;
	id.data[i] = id.data[i + 1] = id.data[i + 2] = 0xff - trace.t * 0xff;
	id.data[i + 3] = 0xff;
	} else {
	id32[i] = 0x00ffffff;
	}

	// i = ((y * canvas.width) + x) * 4;
	}
	}
	ctx.putImageData(id, 0, 0);

	dt = performance.now() - time;
	ctx.fillStyle = '#fff'
	// ctx.fillText('fps: ' + parseInt(1 / (dt / 1000)) + ' frames: ' + ++frames, 10, 10)
	ctx.fillText('fps: ' + parseInt(1 / (dt / 1000)), 10, 10);
	ctx.fillText('frame: ' + ++frames, 10, 20);
	animationFrameRequestId = requestAnimationFrame(update);
	}

	var animationFrameRequestId;

	toggle = function() {
	if (animationFrameRequestId) {
	cancelAnimationFrame(animationFrameRequestId)
	animationFrameRequestId = null;
	} else {
	animationFrameRequestId = requestAnimationFrame(update);
	}
	}
	</script>
	<style>
	#canvas {
	/background: #000;/
	}
	</style>
	<canvas id="canvas"></canvas>
	<button onclick="toggle()">Start/Stop</button>
	<script src="https://cdnjs.cloudflare.com/ajax/libs/dat-gui/0.5.1/dat.gui.js"></script>
	<script>
	canvas.width = canvas.height = 0xff;
	canvas.width = canvas.height; //0xff * 2;
	halfWidth = canvas.width / 2;
	halfHeight = canvas.height / 2;

	ctx = canvas.getContext('2d');
	var id = ctx.getImageData(0, 0, canvas.width, canvas.height);
	id32 = new Uint32Array(id.data.buffer);
	id32.fill(0xff000000);

	let i = (10 + 10 * canvas.width) * 4;
	id.data[i] += 0x30;

	ctx.putImageData(id, 0, 0);

	var cloneFittest = true;
	var maxPopulation = 100;
	var crossoverProbability = .5;
	var mutationProbability = .5;
	var mutationStrength = 20;
	var population = [];

	var selectA = 'randomLinearRank'
	var selectB = 'sequential'

	var gui = new dat.GUI();
	gui.add(window, "cloneFittest");
	gui.add(window, "maxPopulation", 0, 1000);
	gui.add(window, "crossoverProbability", 0, 1);
	gui.add(window, "mutationProbability", 0, 1);
	gui.add(window, "mutationStrength", 0, 100);
	gui.add(window, "selectA", ['fittest', 'random', 'randomLinearRank', 'sequential']);
	gui.add(window, "selectB", ['fittest', 'random', 'randomLinearRank', 'sequential']);


	function seed() {
	return [
	Math.round(Math.random() * canvas.width),
	Math.round(Math.random() * canvas.height)
	];
	}

	function fitness(p) {
	let i = p[0] + p[1] * canvas.width;
	return id.data[i * 4];
	}

	function init(population, num) {
	for (i = 0; i < num; i++) {
	population.push(seed());
	}
	}

	init(population, maxPopulation);
	console.log(population)
	render(population)

	function render(population) {
	population.forEach(p => {
	let i = (p[0] + p[1] * canvas.width) * 4;
	id.data[i] += 0x30;
	});
	ctx.putImageData(id, 0, 0);
	}

	var select = {
	fittest: (generation) => generation[0].individual,
	random: (generation) => generation[Math.floor(Math.random() * generation.length)].individual,
	randomLinearRank: (generation, n) => generation[Math.floor(Math.random() * Math.min(generation.length, n))].individual,
	sequential: (generation, n) => generation[n % generation.length].individual
	}

	function crossover(a, b) {
	return [a[0], b[1]]
	}

	function mutate(i) {
	return [
	Math.min(canvas.width - 1, Math.max(0, i[0] + Math.round((Math.random() - .5) * mutationStrength))),
	Math.min(canvas.height - 1, Math.max(0, i[1] + Math.round((Math.random() - .5) * mutationStrength)))
	]
	}

	function evolve() {
	render(population);

	// Mesaure fitness of individuals
	let generation = population
	.map(p => {
	return {
	fitness: fitness(p),
	individual: p
	}
	})
	.sort((a, b) => a.fitness - b.fitness);

	var newPopulation = [];

	if (cloneFittest) {
	newPopulation.push(generation[0].individual);
	}

	// Crossover and mutate to build new population
	let n = 0;
	while (newPopulation.length < maxPopulation) {
	let a = select[selectA](generation, ++n);
	if (Math.random() < crossoverProbability) {
	let b = select[selectB](generation, ++n);
	let ab = crossover(a, b);
	let ba = crossover(b, a);
	newPopulation.push(Math.random() < mutationProbability ? mutate(ab) : ab);
	newPopulation.push(Math.random() < mutationProbability ? mutate(ba) : ba);
	newPopulation.push(Math.random() < mutationProbability ? mutate(ba) : ba);
	} else {
	newPopulation.push(Math.random() < mutationProbability ? mutate(a) : a);
	}
	}

	population = newPopulation;
	// console.log(generation)
	animationFrameRequestId = requestAnimationFrame(evolve);
	}

	var animationFrameRequestId;

	toggle = function() {
	if (animationFrameRequestId) {
	cancelAnimationFrame(animationFrameRequestId)
	animationFrameRequestId = null;
	} else {
	animationFrameRequestId = requestAnimationFrame(evolve);
	}
	}
	</script>
	<style>
	#canvas {
	object-fit: contain;
	position: fixed;
	top: 0;
	left: 0;
	width: 100%;
	height: 100%;
	background: linear-gradient(#456, #200);
	}
	</style>

	<canvas id="canvas" />

	<script>
	audioContext = new AudioContext();
	gain = audioContext.createGain();
	gain.gain.value = .1;
	gain.connect(audioContext.destination);

	context = canvas.getContext('2d');


	MIN_F = 50;
	MAX_F = 800;
	MIN_D = 100;
	MAX_D = 1000;
	MIN_A = 5;
	MAX_A = 20;

	minFps = 999;
	maxFps = 0;


	function mutateNote(note) {
	note.frequency.value = Math.random() * (MAX_F - MIN_F) + MIN_F;
	// note.frequency = Math.random() * (MAX_F - MIN_F) + MIN_F;
	note.duration = Math.random() * (MAX_D - MIN_D) + MIN_D;
	// note.amplitude = Math.random() * (MAX_A - MIN_A) + MIN_A;
	}

	function generateNote(type) {
	note = audioContext.createOscillator();
	note.type = type \|\| 'sine';
	mutateNote(note);
	note.start();
	note.connect(gain);
	return note;
	}

	notes = [
	// generateNote('sawtooth'),
	// generateNote('sine'),
	// generateNote('triangle'),
	generateNote('square'),
	];

	function update(time) {
	if (!window.currentTime) {
	currentTime = time - 1000 / 60;
	}
	previousTime = currentTime;
	currentTime = time;

	deltaTime = currentTime - previousTime;

	fps = 1000 / deltaTime;
	minFps = Math.min(fps, minFps);
	maxFps = Math.max(fps, maxFps);

	// update stuff
	// console.log(time)
	notes.forEach(note => {
	note.duration -= deltaTime;
	if (note.duration <= 0) {
	mutateNote(note);
	}
	});

	// reset canvas
	height = canvas.height = 512;
	width = canvas.width = 512;
	// width = canvas.width = 0 \| height * innerWidth / innerHeight;

	// render visuals
	context.shadowColor = '#fff';
	// context.shadowBlur = 24;

	context.shadowBlur = 10;
	context.strokeStyle = '#fff';
	notes.forEach(note => {
	context.beginPath();
	y = height / MAX_F * (MAX_F - note.frequency.value) + Math.sin((currentTime/20000) * note.frequency.value) * 10;
	// y = ((note.frequency.value - MIN_F) / (MAX_F - MIN_F)) * height + Math.sin(currentTime / (note.frequency.value / 4)) * 10;
	context.moveTo(0, y);
	context.lineTo(width, y);
	context.stroke();
	});

	// render stats
	context.shadowBlur = 0;
	context.strokeStyle = '#fff';
	context.strokeText(['FPS: ' + (0 \| fps), 0 \| minFps, 0 \| maxFps], 10, 20);

	requestAnimationFrame(update);
	}

	requestAnimationFrame(update);

	onclick = function() {
	audioContext.suspend();
	update = function() {}
	}
	</script>
	<style>

	#b {
	position: fixed;
	top: 0;
	left: 0;
	width: 100%;
	height: 100%;
	background: radial-gradient(circle, #345, #201);
	}

	</style><audio id="a"></audio><canvas id="b"></canvas><script>

	str='';
	notesFreq = [155,195,261,155,233,155,195,207,195,207,195,207,195,207,195,261,155,233,155,233,261,155,233,155,233,155,233,261,155,195,261,195,207,195,261,155,233,155,233,155,195,207,233,155,233,155,195,207,195,207,233,261,155,233,261,233,261,155,195,207,195,207,195,207,195,261,233,155,195,207,233,261,233,155,233,261,155,195,207,195,261,155,233,261,155,233,261,195,261,233,261,155,233,155,195,207,233,261,233,155,195,261,233,155,195,261,195,261,155,233,261,195,207,233,261,195,207,195,261,233,155,195,261,155,195,207,195,261];
	notesIndex = 0;

	for(time=0;time<60;time+=1/16384) {
	frac= (time&4?time6:time4)%1;
	notesIndex += frac==0;
	sample = (time * notesFreq[notesIndex%notesFreq.length] % 1) * (1 - frac) * 16;

	frac = time*2%1;
	sample += (Math.random()) * Math.pow(1-frac, 8) * 16;


	str += String.fromCharCode(sample + 127);
	}



	a.src = 'data:audio/wav;base64,UklGRiQAAABXQVZFZm10IBAAAAABAAEAA'
	+ 'EAAAABA' // 16khz
	+ 'AAABAAgAZGF0YQAAAAAA' + btoa(str);
	a.play();




	c=b.getContext('2d');
	ps = [];
	COUNT = 2560;
	for(i=0;i<COUNT; i++) {
	ps.push({
	x: (Math.random()-.5)256 2,
	y: (Math.random()-.5)256 2,
	z: (Math.random()-.5)256 2,
	u: i / 48 % 1,
	v: i / 48 / 48,
	col: i & 1 ? '#eee' : '#ddd'
	})
	};

	render = function() {
	requestAnimationFrame(render);
	time = a.currentTime;

	H=b.height=512;
	W=b.width=0\|innerWidth/innerHeight*H;
	c.translate(W/2,H/2);

	angle = time;

	c.rotate((angle&13)/32);

	ps.forEach(p => {
	if (p.v < 1) {
	an = p.uMath.PI2;

	frac = time*2%1;
	frac = Math.pow(1-frac, 2);

	d = 64 + frac * 32 * Math.cos(an4)Math.cos(p.v6+time4);
	p.x = d*Math.cos(an);
	p.z = d*Math.sin(an);
	p.y = 384*(p.v-.5);
	p.col = 'rgb('+
	[255-d*4\|0,
	255-d*4\|0,
	255-d*4\|0] +')'
	}

	p.rx = Math.cos(angle) * p.x - Math.sin(angle) * p.z;
	p.rz = Math.sin(angle) * p.x + Math.cos(angle) * p.z;
	p.ry = p.y;


	p.p = (384+p.rz)/256;
	p.sx = p.p*p.rx;
	p.sy = p.p*p.ry;

	});

	ps.sort((a, b) => a.rz - b.rz)

	ps.forEach(p => {

	c.shadowColor = c.fillStyle = p.col;
	s = p.p*8;
	c.shadowBlur = p.v < 1 ? 0 : s;
	c.fillRect(p.sx,p.sy,s,s);
	})

	}
	render();

	</script>
	<canvas id="canvas">
	<script>
	var context = canvas.getContext("2d"),
	a, b, position;

	function surface(a, b) {
	var angle = a * Math.PI * 2,
	radius = 100,
	length = 400,
	x = a * 400,
	y = b * 400,
	z = a * b * 200,
	yAxisRotationAngle = -.40, // in radians!
	rotatedX = x * Math.cos(yAxisRotationAngle) + z * Math.sin(yAxisRotationAngle),
	rotatedZ = x * -Math.sin(yAxisRotationAngle) + z * Math.cos(yAxisRotationAngle);

	return {
	x: rotatedX,
	y: y,
	z: rotatedZ,
	r: 0 \| a * 255,
	g: 0 \| b * 255,
	b: 0
	};
	}
	// function surface(a, b) {
	// var angle = a * Math.PI * 2,
	// radius = 100,
	// length = 400,
	// x = Math.cos(angle) * radius,
	// y = Math.sin(angle) * radius,
	// z = b * length - length / 2,
	// yAxisRotationAngle = -.4, // in radians!
	// rotatedX = x * Math.cos(yAxisRotationAngle) + z * Math.sin(yAxisRotationAngle),
	// rotatedZ = x * -Math.sin(yAxisRotationAngle) + z * Math.cos(yAxisRotationAngle);
	//
	// return {
	// x: rotatedX,
	// y: y,
	// z: rotatedZ,
	// r: 0,
	// g: 0 \| b * 255,
	// b: 0
	// };
	// }

	var pX, pY, // projected on canvas x and y coordinates
	perspective = 350,
	halfHeight = canvas.height / 2,
	halfWidth = canvas.width / 2,
	cameraZ = -700;

	var zBuffer = [],
	zBufferIndex;

	// for (a = 0; a < 1; a += .001) {
	// for (b = 0; b < 1; b += .01) {
	// if (point = surface(a, b)) {
	// pX = Math.floor((point.x * perspective) / (point.z - cameraZ) + halfWidth);
	// pY = Math.floor((point.y * perspective) / (point.z - cameraZ) + halfHeight);
	// zBufferIndex = pY * canvas.width + pX;
	// if ((typeof zBuffer[zBufferIndex] === "undefined") \|\| (point.z < zBuffer[zBufferIndex])) {
	// zBuffer[zBufferIndex] = point.z;
	// context.fillStyle = "rgb(" + point.r + "," + point.g + "," + point.b + ")";
	// context.fillRect(pX, pY, 1, 1);
	// }
	// }
	// }
	// }

	var i;

	// window.setInterval(function() {
	for (i = 0; i < 50000; i++) {
	if (point = surface(Math.random(), Math.random())) {
	pX = Math.floor((point.x * perspective) / (point.z - cameraZ) + halfWidth);
	pY = Math.floor((point.y * perspective) / (point.z - cameraZ) + halfHeight);
	zBufferIndex = pY * canvas.width + pX;
	if ((typeof zBuffer[zBufferIndex] === "undefined") \|\| (point.z < zBuffer[zBufferIndex])) {
	zBuffer[zBufferIndex] = point.z;
	context.fillStyle = "rgb(" + point.r + "," + point.g + "," + point.b + ")";
	context.fillRect(pX, pY, 1, 1);
	}
	}
	}
	// }, 0);
	</script>
	<script>
	class KDNode {
	constructor(axis, d, children) {
	this.axis = axis;
	this.d = d;
	this.children = children \|\| [];
	}

	intersect(origin, direction) {
	// Determine wich side of the splitting plane the origin lies within
	let originChildIndex = +(origin[this.axis] > this.d);

	if (direction[this.axis] === 0) {
	// Direction parallel to splitting plane, and will never intersect splitting plane
	// Only traverse origin side of splitting plane
	this.children[originChildIndex].intersect(origin, direction);
	} else {
	// Distance from origin to splitting plane
	let t = (this.d - origin[this.axis]) / direction[thid.axis];
	if (t >= 0) {
	// Direction points towards splitting plane, so both sides must be considered
	// Traverse origin side of splitting plane first, then the other side
	this.children[originChildIndex].intersect(origin, direction);
	this.children[originChildIndex ^ 1].intersect(origin, direction);
	} else {
	// Direction points away from splitting plane, so will never intersect splitting plane
	// Only traverse origin side of splitting plane
	this.children[originChildIndex].intersect(origin, direction);
	}
	}
	}
	}
	</script>

	<script>
	function createVoxelData(width, height, depth) {
	return {
	width: width,
	height: height,
	depth: depth,
	data: new Uint32Array(width * height * depth)
	}
	}

	voxelData = createVoxelData(3, 3, 3);
	for (let x = 0; x < voxelData.width; x++) {
	for (let y = 0; y < voxelData.height; y++) {
	for (let z = 0; z < voxelData.depth; z++) {
	let i = z * voxelData.width * voxelData.height + y * voxelData.width + x;
	voxelData[i] = 0xff;
	}
	}
	}
	</script>

	<style>
	#canvas {
	background: linear-gradient(#a25b5b, #2d1821);
	width: 20px;
	height: 200px;
	}

	#circle {
	fill: #f00;
	}
	</style>
	<svg width="300" height="200" viewBox="-2 -1 3 2" style="background: black">
	<polyline id="view" points="-2,0 -1,1 -1,-1" fill="rgba(255, 255, 255,.25)" />
	<circle id="circle" cx="0" cy="0" r="0.5" fill="#ff0000"/>
	<line id="ray" x1="-2" y1="0"
	x2="-1" y2="1"
	stroke="yellow"
	stroke-width=".01"/>
	</svg>
	<canvas id="canvas"></canvas>
	<button onclick="toggle()">Start/Stop</button>
	<script>
	console.log(ray.x2.baseVal.value)

	origin = [view.points[0].x, view.points[0].y];
	console.log(origin)
	top = [view.points[1].x, view.points[1].y];
	bottom = [view.points[2].x, view.points[2].y];

	circle.origin = [circle.cx.baseVal.value, circle.cy.baseVal.value];
	circle.radius = circle.r.baseVal.value;
	circle.color = parseInt(circle.getAttribute('fill').replace('#', '0x'));

	canvas.width = 1;
	canvas.height = 200;
	ctx = canvas.getContext('2d');
	var id = ctx.getImageData(0, 0, canvas.width, canvas.height);
	id32 = new Uint32Array(id.data.buffer);

	function getDirection(y) {
	let d = normalize([-origin[0], y]);
	ray.x2.baseVal.value = d[0];
	ray.y2.baseVal.value = d[1];
	return d;
	}

	function dot(a, b) {
	return a[0] * b[0] + a[1] * b[1];
	}

	function length(v) {
	return Math.sqrt(v[0] * v[0] + v[1] * v[1]);
	}

	function normalize(v) {
	let l = length(v);
	return [v[0] / l, v[1] / l];
	}

	vec = [-1, -1]
	console.log("VEC", vec)
	console.log("LEN", length(vec))
	console.log("NORM", normalize(vec))
	console.log(circle.origin)

	function cast(trace) {
	let m = [
	trace.origin[0] - circle.origin[0],
	trace.origin[1] - circle.origin[1]
	];

	let b = dot(m, trace.direction);
	let c = dot(m, m) - circle.radius * circle.radius;

	console.log(trace, m, b, c)

	if (c > 0 && b > 0) {
	// Origin outside circle and pointing away
	return false;
	}

	let discr = b * b - c;
	if (discr < 0) {
	// Negative discriminant indicates ray missing sphere
	return false;
	}

	trace.t = -b - Math.sqrt(discr);
	if (trace.t < 0) {
	// Negative t indicates ray origin within circle
	// Clamp to 0
	trace.t = 0;
	}
	return true;
	}

	function update(time) {
	canvas.width = canvas.width;
	ox = time / 100

	for (i = 0; i < canvas.height; i++) {
	let y = ((i / canvas.height) * 2) - 1;

	let trace = {
	origin: origin,
	direction: getDirection(y),
	t: 0,
	}

	if (cast(trace)) {
	// let i = y * 4;
	// id.data[i] = id.data[i + 1] = id.data[i + 2] = 0xff - trace.t * 0xff;
	// id.data[i + 3] = 0xff;
	id32[i] = 0xff0000ff;
	} else {
	id32[i] = 0x00ffffff;
	}

	// i = ((y * canvas.width) + x) * 4;
	}
	ctx.putImageData(id, 0, 0);
	animationFrameRequestId = requestAnimationFrame(update);
	}

	var animationFrameRequestId;

	toggle = function() {
	if (animationFrameRequestId) {
	cancelAnimationFrame(animationFrameRequestId)
	animationFrameRequestId = null;
	} else {
	animationFrameRequestId = requestAnimationFrame(update);
	}
	}
	</script>
	<script>
	class V3 {
	static new() {
	return new Float32Array(3);
	}
	static fromValues(x, y, z) {
	return Float32Array.of(x, y, z);
	}
	static add(a, b, result) {
	result = result \|\| V3.new();
	result[0] = a[0] + b[0];
	result[1] = a[1] + b[1];
	result[2] = a[2] + b[2];
	return result;
	}
	static sub(a, b, result) {
	result = result \|\| V3.new();
	result[0] = a[0] - b[0];
	result[1] = a[1] - b[1];
	result[2] = a[2] - b[2];
	return result;
	}
	static scale(v, s, result) {
	result = result \|\| V3.new();
	result[0] = v[0] * s;
	result[1] = v[1] * s;
	result[2] = v[2] * s;
	return result;
	}
	static dot(a, b) {
	return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
	}
	static length(v) {
	return Math.sqrt(V3.dot(v, v));
	}
	static normalize(v, result) {
	result = result \|\| V3.new();
	let scale = 1 / V3.length(v);
	return V3.scale(v, scale, result);
	}
	}
	</script>

	<script>
	class Sphere {
	constructor(center, radius) {
	this.center = center;
	this.radius = radius;
	this.radius2 = radius * radius;
	}

	intersect(ray, test, epsilon) {
	let m = V3.sub(ray.origin, this.center);
	let c = V3.dot(m, m) - this.radius2;

	if (test && c < epsilon) {
	return true;
	}

	let b = V3.dot(m, ray.direction);
	if (b > 0) {
	return false
	}

	let discr = b * b - c;
	if (discr < 0) {
	return false;
	}

	if (test) {
	return true;
	}

	let inside = false;
	let sqrtDiscr = Math.sqrt(discr);
	let t = -b - sqrtDiscr;
	if (t < epsilon) {
	inside = true;
	t = -b + sqrtDiscr;
	if (t < epsilon) {
	return false;
	}
	}

	let point = V3.add(ray.origin, V3.scale(ray.direction, t));
	return {
	point: point,
	t: t,
	inside: inside,
	normal: V3.normalize(V3.sub(point, this.center))
	};
	}
	}
	</script>

	<script>
	class GeometryGroup {
	constructor(...geometries) {
	this.geometries = geometries;
	}

	intersect(ray, test, epsilon) {
	return this.geometries
	.map(geometry => geometry.intersect(ray, test, epsilon))
	.reduce((previous, current) => {
	if (!previous) {
	return current;
	}
	if (current) {
	if (current.t < previous.t) {
	return current;
	} else {
	return previous;
	}
	} else {
	return previous;
	}
	});
	}
	}
	</script>

	<script src="https://cdnjs.cloudflare.com/ajax/libs/dat-gui/0.5.1/dat.gui.js"></script>

	<script>
	class PathTracer {
	constructor() {
	this.scene = new GeometryGroup(
	new Sphere(V3.fromValues(0, 0, 100), 99),
	new Sphere(V3.fromValues(-100, 0, 0), 99),
	new Sphere(V3.fromValues(100, 0, 0), 99),
	new Sphere(V3.fromValues(0, 100, 0), 99),
	new Sphere(V3.fromValues(0, -100, 0), 99),

	// new Sphere(V3.fromValues(-1, -1, 1), .2),
	// new Sphere(V3.fromValues(1, 1, 1), .2),
	// new Sphere(V3.fromValues(-1, 1, 1), .2),
	// new Sphere(V3.fromValues(1, -1, 1), .2)

	// new Sphere(V3.fromValues(.5, 0, 0), .5),
	new Sphere(V3.fromValues(0, 0, 0), .25)
	);
	this.light = new Sphere(V3.fromValues(-.25, .25, -.5), .2);
	this.epsilon = 0.001;
	}

	sample(ray) {
	let intersection = this.scene.intersect(ray, false, this.epsilon);
	if (intersection) {
	// Intensity color
	let incidence = V3.normalize(V3.sub(this.light.center, intersection.point));
	let lambert = V3.dot(intersection.normal, incidence);
	if (lambert < 0) {
	return 0xff000000;
	}
	let c = Math.min(0xff, ~~(lambert * this.light.radius * 0xff));
	// return 0xff000000 \| c << 16 \| c << 8 \| c;

	let r = ((intersection.normal[0]) + 1) / 2 * c;
	let g = ((intersection.normal[1]) + 1) / 2 * c;
	let b = ((intersection.normal[2]) + 1) / 2 * c;
	return 0xff000000 \| r << 16 \| g << 8 \| b;

	// Normal color
	// let r = ((intersection.normal[0]) + 1) / 2 * 0xff;
	// let g = ((intersection.normal[1]) + 1) / 2 * 0xff;
	// let b = ((intersection.normal[2]) + 1) / 2 * 0xff;
	// return 0xff000000 \| r << 16 \| g << 8 \| b;
	} else {
	return 0xff000000;
	}
	}
	}

	class ViewPort {
	constructor(canvas) {
	this.ctx = canvas.getContext('2d');
	this.imageData = this.ctx.getImageData(0, 0, canvas.width, canvas.height);
	console.log(this.imageData)
	this.id8 = this.imageData.data.buffer;
	this.id32 = new Uint32Array(this.id8);
	this.halfWidth = canvas.width / 2;
	this.halfHeight = canvas.height / 2;

	this.origin = V3.fromValues(0, 0, -1);
	}

	render(renderer, time) {
	for (let y = 0; y < this.imageData.height; y++) {
	for (let x = 0; x < this.imageData.width; x++) {
	let direction = this.getRayThrough(x, y);
	let color = renderer.sample({
	origin: this.origin,
	direction: direction
	})
	this.setColor(x, y, color);
	}
	}
	this.updateCanvas();
	}

	getRayThrough(x, y) {
	let target = V3.fromValues(
	2 * x / this.imageData.width - 1,
	2 * y / this.imageData.height - 1,
	0
	)
	return V3.normalize(V3.sub(target, this.origin));
	}

	setColor(x, y, color) {
	let i = x + y * this.imageData.width;
	this.id32[i] = color;
	}

	updateCanvas() {
	this.ctx.putImageData(this.imageData, 0, 0);
	}
	}

	function onLoad() {
	let pathTracer = new PathTracer();
	canvas.width = canvas.height = 0xff;
	let viewPort = new ViewPort(canvas);

	canvas.addEventListener('mousemove', ({
	offsetX,
	offsetY
	}) => {
	let x = offsetX / canvas.width * 2 - 1;
	let y = offsetY / canvas.height * 2 - 1;
	pathTracer.light.center[0] = x;
	pathTracer.light.center[1] = y;
	})

	var animationFrameRequestId;
	let ui = {
	run: function() {
	viewPort.render(pathTracer);
	animationFrameRequestId = requestAnimationFrame(ui.run);
	},

	toggle: function() {
	if (animationFrameRequestId) {
	cancelAnimationFrame(animationFrameRequestId)
	animationFrameRequestId = null;
	} else {
	animationFrameRequestId = requestAnimationFrame(ui.run);
	}
	}
	}

	var gui = new dat.GUI();
	gui.add(ui, 'toggle');
	gui.add(pathTracer.light, 'radius', 0, 10);
	}
	</script>

	<body onload="onLoad()">
	<canvas id="canvas"></canvas>
	</body>
	var seed = function(s) {
	return function() {
	s = Math.sin(s) * 10000;
	return s - Math.floor(s);
	};
	};


	function Random(seed) {
	this.seed = seed;
	}
	Random.prototype.next = function() {
	this.seed = Math.sin(this.seed) * 10000;
	return this.seed - Math.floor(this.seed);
	};


	random = new Random(23);
	random.next();
	<style>
	#canvas {
	/*object-fit: contain;
	position: fixed;*/
	/*top: 0;
	left: 0;*/
	/*width: 256px;
	height: 256px;*/
	/background: radial-gradient(#456, #200);/
	/background: linear-gradient(#456, #200);/
	background-color: black;
	}
	</style>
	a
	<canvas id="heightmap" height="256" width="256"></canvas>
	b
	<canvas id="canvas" height="256" width="256"></canvas>
	c
	<script>
	var ctx = heightmap.getContext('2d');
	var id = ctx.getImageData(0, 0, heightmap.width, heightmap.height);

	function generateHeightMap() {
	id.data.fill(0xff);
	console.log(heightmap.width)
	for (var y = 0; y < heightmap.height; y++) {
	var y_ = y / heightmap.height;
	for (var x = 0; x < heightmap.width; x++) {
	var x_ = x / heightmap.width;
	i = ((y * heightmap.width) + x) * 4;
	var v = 0 \| volume(x_, y_) * 0xff;
	id.data[i] = id.data[i + 1] = id.data[i + 2] = v;
	}
	}
	ctx.putImageData(id, 0, 0);
	}

	context = canvas.getContext('2d');
	imageData = context.getImageData(0, 0, canvas.width, canvas.height);
	imageData.data.fill(0xff);

	// function volume(x, y) {
	// return Math.random()
	// }
	// function volume(x, y) {
	// x -= .5;
	// y -= .5;
	// x *= 3;
	// y *= 2;
	// if (x && y) {
	// return 1 / (x * x + y * y);
	// } else {
	// return 1;
	// }
	// }
	// function volume(x, y) {
	// return Math.sin(5 * y * Math.PI) / 2 - Math.cos(5 * x * Math.PI) / 2;
	// }
	function volume(x, y) {
	return .7 - y * .5;
	}

	// function draw(time) {
	// // update stuff
	//
	// // reset canvas
	// height = canvas.height = 256;
	// width = canvas.width = 256;
	//
	// // render visuals
	// context.fillStyle = context.strokeStyle = context.shadowColor = '#fff';
	// // context.shadowBlur = 24;
	// // march([0, 0, 0], [1, 1, 1], 0);
	// for (y = 0; y < imageData.height; y++) {
	// y_ = (y / imageData.height) - .5;
	// for (x = 0; x < imageData.width; x++) {
	// x_ = (x / imageData.width) - .5;
	// i = ((y * imageData.width) + x) * 4;
	// v = volume(x_, y_) / 100 * 0xff;
	// imageData.data[i] = v;
	// imageData.data[i + 1] = v;
	// imageData.data[i + 2] = v;
	// // imageData.data[x * 4 + y * canvas.width + 0] = 0 \| volume(x_, y_) * 255;
	// // imageData.data[x * 4 + y * canvas.width + 1] = 0 \| volume(x_, y_) * 255;
	// // imageData.data[x * 4 + y * canvas.width + 2] = 0 \| volume(x_, y_) * 255;
	// }
	// console.log(x_, y_, volume(x_, y_))
	// }
	// context.putImageData(imageData, 0, 0);
	//
	// // render stats
	// context.strokeText([((performance.now() - time) / 1000)], 10, 20);
	// }

	var camera = {
	x: 256/2,
	y: 256/2,
	z: 0,
	}

	yBuffer = [];

	function draw(time) {
	for (x = 0; x < imageData.width; x++) {
	x_ = (x / imageData.width);
	ymin = 0;
	dx = x - camera.x;
	for (z = imageData.height; z > 0; z--) {
	// for (z = 0; z < imageData.height; z++) {
	z_ = z / imageData.height;
	y_ = volume(x_, z_);
	// yBuffer[x] = Math.max(yBuffer[x] \|\| 0, y_);
	ymax = y_ * imageData.height;
	dy = ymax - ymin;
	if (ymin < ymax) {
	// console.log(ymin, ymax, dy)
	context.fillStyle = context.strokeStyle = context.shadowColor = 'rgb(' + (0 \| y_ * 0xff) + ',' + (0 \| y_ * 0xff) + ',' + (0 \| y_ * 0xff) + ')';
	context.fillRect(x, imageData.height - ymin, 1, -dy)
	// context.fillRect(x, y_ * imageData.height, 1, 1)
	ymin = ymax;
	}
	}
	}
	}

	generateHeightMap();
	draw(performance.now());
	</script>