Snippet Zone

Polar Forking Tweak

```
const FOUR_PI = 6 * Math.PI;
```
```
const { cos, sin } = Math;
```
```
 
```

const canvas = document.body.appendChild(

```
  document.createElement('canvas')
```
```
);
```
```
const c = canvas.getContext('2d');
```
```
 
```
```
function resize() {
```
```
  canvas.width = window.innerWidth;
```
```
  canvas.height = window.innerHeight;
```
```
}
```
```
 
```
```
let inc = 0;
```
```
function draw() { 
```
```
  c.fillStyle = 'rgba(0, 0, 0, .3)'
```

  c.fillRect(0, 0, canvas.width, canvas.height)

```
  c.fillStyle = 'white';
```
```
 
```

  const halfWidth = window.innerWidth / 2;

  const halfHeight = window.innerHeight / 2;

```
  let theta = 0,
```

    a = 20 * Math.min(window.innerWidth, window.innerHeight) * 0.005,

```
    x,
```
```
    y;
```
```
 
```
```
  c.save();
```
```
  c.translate(halfWidth, halfHeight)
```
```
 
```
```
  let b = 5 * cos(inc);
```
```
  inc += .02;
```
```
 
```

  for (let i = 0; theta < FOUR_PI; i++) {

    let rad = a * (b + 10 * sin(theta / 3));

    // randomly speed-coded and tweaked... leaving as is :D

    x = rad * cos(theta + b / 10) * cos(b / 10 +theta * 2) * cos(theta * 2);

    y = rad * sin(theta * 2) * cos(theta + b / 3) * cos(theta * 2);

```
    c.fillRect(x,y, 2, 2);
```
```
    theta += 0.04;
```
```
  }
```
```
  c.restore();
```
```
 
```
```
  requestAnimationFrame(draw)
```
```
}
```
```
 
```
```
resize();
```
```
addEventListener('resize', resize);
```
```
 
```
```
draw();
```

Just randomly futzing with sin/cos…

January 12, 2022

// animation // canvas // curves // graphics // hacks // humor // math

Hermit Crab Curves

// six white geometric figures (outlines) superimposed on a black wall.

```
d = document
```
```
b = d.body
```
```
S = 600
```
```
hs = S / 2
```
```
with(Math) {
```
```
with(
```
```
  b.appendChild(Object.assign(
```

  d.createElement`canvas`, { width: S, height: S })

```
  ).getContext`2d`) {
```
```
 
```
```
    fillRect(0, 0, S, S)
```
```
    strokeStyle = '#fff'
```
```
 
```

    canvas.style.transformOrigin = '0 0'

    canvas.style.transform = 'scale(.5)'

```
 
```
```
    lineWidth = 8
```
```
 
```
```
    H = (
```
```
      s = S * .5,
```
```
      yp = hs, xp = hs,
```
```
      a = 1.234,
```
```
      d = 0.1678,
```
```
      o = 3.9
```
```
      ) => {
```
```
        beginPath()
```
```
        for (t = 0; t < 6.28; t+=.2) {
```

          r = sqrt(a ** PI % sin(d * (t ** 2 * a) + o)) * s

```
          x = xp + r * sin(t);
```
```
          y = yp + r * cos(t);
```

          t === 0 ? moveTo(x, y) : lineTo(x, y)

```
        }
```
```
        closePath()
```
```
        stroke()
```
```
        fill()
```
```
    }
```
```
 
```
```
    tick = 0
```
```
    loop = _ => {
```
```
      fillStyle = 'rgba(0, 0, 0, 0.5)'
```
```
      fillRect(0, 0, S, S)
```
```
      save()
```
```
      translate(S/2, S/2)
```
```
      scale(.5, .5)
```
```
      rotate(tick * 20)
```
```
      translate(-S/2, -S/2)
```
```
      tick += .0001
```
```
      globalAlpha = .8;
```
```
      H(S, hs, hs, 1 + tick)
```
```
      H(S, hs, hs, 1.1 + tick)
```
```
      H(S, hs, hs, 1.2 + tick)
```
```
      globalAlpha = 1;
```
```
      H(S * .3, hs-S/4, hs, 1, tick)
```

      H(S * .2, hs+S/4, hs, 1.2, tick, 1.8)

      H(S * .2, hs, hs - S/4, cos(tick), -tick, 5)

```
      restore()
```
```
      requestAnimationFrame(loop)
```
```
    }
```
```
    loop()
```
```
  }
```
```
}
```

Another thing for #genuary2022… Sol LeWitt Wall Drawing

January 7, 2022

// animation // canvas // graphics // hacks // javascript // math

Speed Coded Mouse Toy

```
d = document
```
```
b = d.body
```
```
b.style.margin = 0
```
```
with (b.appendChild(
```

  Object.assign(d.createElement`canvas`, {

```
    width: innerWidth,
```
```
    height: innerHeight,
```
```
  })
```
```
).getContext`2d`) {
```
```
  mx = 0
```
```
  my = 0
```
```
 
```
```
  onresize = _ => {
```
```
    canvas.width = innerWidth
```
```
    canvas.height = innerHeight
```
```
  }
```
```
 
```
```
  onpointermove = e => {
```
```
    mx = e.clientX, 
```
```
    my = e.clientY
```
```
  }
```
```
 
```
```
  r = 0
```
```
  loop = () => {
```
```
    save()
```

    globalCompositeOperation = 'hard-light'

    translate(innerWidth / 2, innerHeight / 2)

```
 
```
```
    rotate(r += .02)
```

    translate(-innerWidth / 2, -innerHeight / 2)

```
 
```
```
    fillStyle = 'rgba(55, 55, 55, .01)'
```

    fillRect(0, 0, innerWidth, innerHeight)

```
 
```

    fillStyle = 'rgba(116, 196, 221, .02)'

```
    fillRect(0, my, innerWidth, 20);
```
```
 
```

    fillStyle = 'rgba(255, 255, 255, .02)'

```
    fillRect(mx, 0, 20, innerHeight);
```
```
 
```
```
    fillStyle = 'rgba(0, 0, 0, .03)'
```

    fillRect(0, innerHeight - my, innerWidth, 20);

```
 
```

    fillStyle = 'rgba(116, 196, 221, .02)'

    fillRect(innerWidth - mx, 0, 20, innerHeight);

```
    restore()
```
```
    requestAnimationFrame(loop)
```
```
  }
```
```
  loop()
```
```
}
```

Speed coded mouse toy…

December 30, 2021

// canvas // codegolf // globals // graphics // hacks // speedcoding

WebGL Tangled Supershape Points

```
(() => {
```
```
  const TWO_PI = Math.PI * 2;
```
```
  const m = new Float32Array([
```
```
    0, 0, 0, 0,
```
```
    0, 0, 0, 0,
```
```
    0, 0, 0, 0,
```
```
    0, 0, 0, 0
```
```
  ])
```
```
 
```
```
 
```
```
  const vert = `
```
```
    attribute vec3 vec;
```
```
    uniform mat4 mat;
```
```
    void main(void) {
```

      gl_Position = mat * vec4(vec, 1.0);

```
      gl_PointSize = 2.0;
```
```
    }
```
```
  `
```
```
 
```
```
  const frag = `
```
```
    void main(void) {
```

      gl_FragColor = vec4(1., 1., 1., .25);

```
    }
```
```
  `
```
```
 
```

  document.body.style.background = '#232323'

```
  const gl = document.body
```

    .appendChild(document.createElement('canvas'))

```
    .getContext('webgl', {
```
```
      preserveDrawingBuffer: true,
```

      powerPreference: 'high-performance'

```
    })
```
```
 
```
```
  Object.assign(gl.canvas.style, {
```
```
    position: 'absolute',
```
```
    left: '50%',
```
```
    top: '50%',
```
```
    transform: 'translate(-50%, -50%)',
```
```
    outline: '1px solid gray'
```
```
  })
```
```
 
```
```
 
```
```
  with(gl) {
```
```
    const NUM = 120
```
```
    const radius = 0.7
```
```
    let verts = []
```
```
 
```
```
    // Superformula (equations from):
```

    // https://bsapubs.onlinelibrary.wiley.com/doi/10.3732/ajb.90.3.333

    // http://en.wikipedia.org/wiki/Superformula

    function superShape(a, b, m, n1, n2, n3, scale, x = 0, y = 0, z = 0) {

      const { random, pow, abs, cos, sin } = Math

      // with(Math) { // destrucuring vs the dreaded `with`

```
        let r = 0
```
```
        let p = 0
```
```
        let xp = 0
```
```
        let yp = 0
```
```
        let zp = 0
```
```
 
```
```
        let rotX = random() * TWO_PI
```
```
        let rotY = random() * TWO_PI
```
```
        let rotZ = random() * TWO_PI
```
```
 
```
```
        let cosX = cos(rotX)
```
```
        let cosY = cos(rotY)
```
```
        let sinX = sin(rotX)
```
```
        let sinY = sin(rotY)
```
```
 
```
```
        while (p <= TWO_PI) {
```
```
          let ang = (m * p) / 4
```
```
 
```

          r = pow(pow(abs(cos(ang) / a), n2) + pow(abs(sin(ang) / b), n3), -1 / n1)

```
          xp = r * cos(p)
```
```
          yp = r * sin(p)
```
```
 
```
```
          p += 0.05
```
```
 
```
```
          zp = zp * cosX - xp * sinX
```
```
          xp = zp * sinX + xp * cosX
```
```
          yp = yp * cosY - zp * sinY
```
```
          zp = yp * sinY + zp * cosY
```
```
 
```
```
          verts[inc] = xp * scale + x
```

          verts[inc + 1] = yp * scale + y

          verts[inc + 2] = zp * scale + z

```
          inc += 3;
```
```
        }
```
```
      // }
```
```
    }
```
```
 
```
```
    let inc = 0; 
```
```
    for (let i = 0; i < NUM; i++) {
```

      superShape(1, 1, 1 + ~~(Math.random() * 20),

```
        ~~(Math.random() * 30),
```
```
        ~~(Math.random() * 30),
```

        ~~(Math.random() * 30), Math.random() * .2,

```
        Math.random() - .5,
```
```
        Math.random() - .5,
```
```
        Math.random() - .5 )
```
```
    }
```
```
 
```
```
 
```
```
    console.log(verts.length)
```
```
    const overts = verts.concat()
```
```
    const leng = verts.length / 3
```
```
 
```

    bindBuffer(ARRAY_BUFFER, createBuffer())

    bufferData(ARRAY_BUFFER, new Float32Array(verts), STATIC_DRAW)

```
 
```

    const vs = createShader(VERTEX_SHADER)

```
    shaderSource(vs, vert)
```
```
    compileShader(vs)
```
```
 
```

    const fs = createShader(FRAGMENT_SHADER)

```
    const sp = createProgram()
```
```
 
```
```
    shaderSource(fs, frag)
```
```
    compileShader(fs)
```
```
    attachShader(sp, vs)
```
```
    attachShader(sp, fs)
```
```
    linkProgram(sp)
```
```
    useProgram(sp)
```
```
 
```

    const vec = getAttribLocation(sp, 'vec')

    vertexAttribPointer(vec, 3, FLOAT, false, 0, 0)

```
    enableVertexAttribArray(vec)
```
```
 
```

    const matLoc = getUniformLocation(sp, 'mat')

```
 
```
```
    function rot(x, y, z) {
```

      // https://wikimedia.org/api/rest_v1/media/math/render/svg/a8e16f4967571b7a572d1a19f3f6468512f9843e

```
 
```
```
      const sinA = Math.sin(x)
```
```
      const cosA = Math.cos(x)
```
```
      const sinB = Math.sin(y)
```
```
      const cosB = Math.cos(y)
```
```
      const sinY = Math.sin(z)
```
```
      const cosY = Math.cos(z)
```
```
 
```
```
      m[0] = cosA * cosB
```

      m[1] = cosA * sinB * sinY - sinA * cosY

      m[2] = cosA * sinB * cosY + sinA * sinY

```
      m[3] = 0
```
```
 
```
```
      m[4] = sinA * cosB
```

      m[5] = sinA * sinB * sinY + cosA * cosY

      m[6] = sinA * sinB * cosY - cosA * sinY

```
      m[7] = 0
```
```
 
```
```
      m[8] = -sinB
```
```
      m[9] = cosB * sinY
```
```
      m[10] = cosB * cosY
```
```
      m[11] = m[12] = m[13] = 0
```
```
      m[15] = 1
```
```
 
```

      uniformMatrix4fv(matLoc, false, m)

```
    }
```
```
 
```
```
    onresize = () => {
```
```
      const {
```
```
        canvas
```
```
      } = gl
```

      const size = Math.min(innerWidth, innerHeight) - 20

      canvas.width = canvas.height = size

```
      viewport(0, 0, size, size)
```
```
    }
```
```
 
```
```
    onresize()
```
```
 
```
```
    let rx = 0, ry = 0, rz = 0
```
```
 
```
```
    function loop() {
```
```
      rx += 0.01
```
```
      ry += 0.01
```
```
      rz += 0.01
```
```
      rot(rx, ry, rz)
```
```
 
```
```
      disable(DEPTH_TEST)
```
```
      enable(BLEND)
```

      blendFunc(SRC_ALPHA, ONE_MINUS_SRC_ALPHA)

```
      clearColor(0, 0, 0, 1)
```
```
      clear(COLOR_BUFFER_BIT)
```
```
      drawArrays(POINTS, 0, leng)
```

      window.requestAnimationFrame(loop)

```
    }
```
```
    loop()
```
```
  }
```
```
})()
```

An interesting accident while playing around with Supershapes and WebgGL points…

December 26, 2021

// animation // graphics // hacks // javascript // math // matrix // webgl

Martin Kleppe’s Golfed Blobs Quine

<pre id=p style=background:#000><svg onload='setInterval(f=n=>

{for(t++,o=i=1;i++<476;o+=i%30?([(f+"")[i%195],"o"][c=0|(h=v=>

(M=Math).hypot(i/30-8+3*M.sin(t/8/v),i%30/2-7+4*M.cos(t/9/v)))

(7)*h(9)*h(6)/52]||".").fontcolor(c?c>2:n):"\n");p.innerHTML=o},t=1)'>

Great golfed snippet from Martin Kleppe – can’t wait to fork it… 😀

This was updated a bit later to be even smaller:

<body onload='setInterval(f=n=>{for(t++,o=i=1;i++<476;o+=i%30?([(f+f)[i],"o"][c=0|(h=v=>(M=Math).hypot(i/30-7+3*M.sin(t/8/v),i%30/2-7+4*M.cos(t/9/v)))(7)*h(9)*h(6)/52]||".").fontcolor(c?c>2:n):"\n");p.innerHTML=o},t=1)'bgcolor=X><pre id=p>

December 22, 2021

// dom // golfed // graphics // hacks // html // humor // javascript // math // strings // tricks

Older Posts

Newer Posts

Polar Forking Tweak

Hermit Crab Curves

Speed Coded Mouse Toy

WebGL Tangled Supershape Points

Martin Kleppe’s Golfed Blobs Quine

Recent

Archive