Construct2_3d ›

Construct2

click to generate new pattern

See /f0blog/useless-supercollider-class-no-2/

//
//  construct2.js
//
//  Copyright (c) 2001 Fredrik Olofsson Musikproduktion. All rights reserved.
//
//  2001 original code in java
//  010502 max patch (rev.011004)
//  040920 ported to processing
//  060227 3d version for processing
//  071201 ported to sc (RedConstruct)
//  200326 ported to p5js

// ---------------------------------------------------------------------------------------

let c
let stepX, stepY
let x = 10
let y = 10
let dx = 1
let dy = 1
let v = 1
let m = 1
let col = 4
let row = 3
const movX = 95
const movY = 95
let maxX
let maxY

function setup () {
  const d = new Date().getMilliseconds()
  randomSeed(d)

  const div = select('#sketch')
  const cnv = createCanvas(div.width, div.height)
  cnv.parent('sketch')

  frameRate(60) // frameRate(30)
  maxX = width
  maxY = height
  background(255)
  nytt()
}

function mouseClicked () {
  background(255) // rensa skärmen
  nytt() // nya värden
}

function keyTyped () {
  if (key === ' ') {
    background(255) // rensa skärmen
    nytt() // nya värden
  }
}

function draw () {
  if (int(random(1881)) === 0) { // lite då och då
    background(255) // rensa skärmen
    nytt() // nya värden
  }
  stroke(c, 55, 66)
  drawFO() // rita punkt(er)

  x += (dx * stepX) // flytta position x
  if (x < 1) { // om vänster kant
    dx = int(random(2)) // vänd eller stå still i x-led
  } else if (x > (maxX / col)) { // om höger kant
    dx = 0 - int(random(2)) // vänd eller stå still i x-led
  }

  y += (dy * stepY) // flytta position y
  if (y < 1) { // om övre kanten
    dy = int(random(2)) // vänd eller stå still i y-led
  } else if (y > (maxY / row)) { // om nedre kanten
    dy = 0 - int(random(2)) // vänd eller stå still i y-led
  }

  switch (v) {
    case 1:
      variant1()
      break
    case 2:
      variant2()
      break
    case 3:
      variant3()
      break
    case 4:
      variant4()
      break
    case 5:
      variant5()
      break
    case 6:
      variant6()
      break
  }
}

// ---------------------------------------------------------------------------------------
function variant1 () { // 1. slumpa riktningar individuellt
  if (int(random(100)) >= movX) {
    slumpaRiktningX()
  }
  if (int(random(100)) >= movY) {
    slumpaRiktningY()
  }
}
function variant2 () { // 2. slumpa alltid riktningar tillsammans
  slumpaRiktningXY()
}
function variant3 () { // 3. slumpa riktningar individuellt
  if (int(random(100)) >= movX) {
    if (dx === 0 && x >= 1) { // dra åt vänster
      dx = -1
    } else {
      dx = 0
    }
  }
  if (int(random(100)) >= movY) {
    if (dy === 0 && y >= 1) { // dra uppåt
      dy = -1
    } else {
      dy = 0
    }
  }
}
function variant4 () { // 4. slumpa riktningar individuellt
  if (int(random(100)) >= movX) {
    if (dx === 0 && x >= 1) { // dra åt vänster
      dx = -1
    } else {
      dx = 0
    }
  }
  if (int(random(100)) >= movY) {
    if (dy === 0 && y <= maxY / row) { // dra nedåt
      dy = 1
    } else {
      dy = 0
    }
  }
}
function variant5 () { // 5. slumpa riktningar individuellt
  if (int(random(100)) >= movX) {
    if (dx === 0 && x <= maxX / col) { // dra åt höger
      dx = 1
    } else {
      dx = 0
    }
  }
  if (int(random(100)) >= movY) {
    if (dy === 0 && y >= 1) { // dra uppåt
      dy = -1
    } else {
      dy = 0
    }
  }
}
function variant6 () { // 6. slumpa riktningar individuellt
  if (int(random(100)) >= movX) {
    if (dx === 0 && x <= maxX / col) { // dra åt höger
      dx = 1
    } else {
      dx = 0
    }
  }
  if (int(random(100)) >= movY) {
    if (dy === 0 && y <= maxY / row) { // dra nedåt
      dy = 1
    } else {
      dy = 0
    }
  }
}

// ---------------------------------------------------------------------------------------
function nytt () {
  v = int(random(6)) + 1
  m = int(random(16)) + 1
  col = int(random(12)) + 1
  row = int(random(7)) + 1
  stepX = 1
  // stepX = int(random(2)) + 1
  stepY = 1
  // stepY = int(random(2)) + 1
  slumpaRiktningXY()
  c = int(random(255))
}

function slumpaRiktningXY () {
  while ((dx === 0) && (dy === 0)) { // kolla att inte båda riktningar blir 0
    dx = int(random(2))
    dy = int(random(2))
  }
}
function slumpaRiktningX () {
  dx = int(random(2))
}
function slumpaRiktningY () {
  dy = int(random(2))
}

// ---------------------------------------------------------------------------------------
function drawFO () {
  for (let i = 0; i < col; i++) {
    let iCol = round((maxX / col) * i)
    for (let j = 0; j < row; j++) {
      let jRow = round((maxY / row) * j)
      switch (m) { // kolla mapping
        case 1:
          mapping1(i, j, iCol, jRow)
          break
        case 2:
          mapping2(i, j, iCol, jRow)
          break
        case 3:
          mapping3(i, j, iCol, jRow)
          break
        case 4:
          mapping4(i, j, iCol, jRow)
          break
        case 5:
          mapping5(i, j, iCol, jRow)
          break
        case 6:
          mapping6(i, j, iCol, jRow)
          break
        case 7:
          mapping7(i, j, iCol, jRow)
          break
        case 8:
          mapping8(i, j, iCol, jRow)
          break
        case 9:
          mapping9(i, j, iCol, jRow)
          break
        case 10:
          mapping10(i, j, iCol, jRow)
          break
        case 11:
          mapping11(i, j, iCol, jRow)
          break
        case 12:
          mapping12(i, j, iCol, jRow)
          break
        case 13:
          mapping13(i, j, iCol, jRow)
          break
        case 14:
          mapping14(i, j, iCol, jRow)
          break
        case 15:
          mapping15(i, j, iCol, jRow)
          break
        case 16:
          mapping16(i, j, iCol, jRow)
          break
      }
    }
  }
}

// ---------------------------------------------------------------------------------------
function mapping1 (i, j, iCol, jRow) { // no flip
  point(x + iCol, y + jRow)
}
function mapping2 (i, j, iCol, jRow) { // flip all x
  point(mirrorX(x) + iCol, y + jRow)
}
function mapping3 (i, j, iCol, jRow) { // flip all y
  point(x + iCol, mirrorY(y) + jRow)
}
function mapping4 (i, j, iCol, jRow) { // flip all xy
  point(mirrorX(x) + iCol, mirrorY(y) + jRow)
}
// --
function mapping5 (i, j, iCol, jRow) { // flip odd col x
  if (i % 2 === 1) {
    point(mirrorX(x) + iCol, y + jRow)
  } else {
    point(x + iCol, y + jRow)
  }
}
function mapping6 (i, j, iCol, jRow) { // flip odd col y
  if (i % 2 === 1) {
    point(x + iCol, mirrorY(y) + jRow)
  } else {
    point(x + iCol, y + jRow)
  }
}
function mapping7 (i, j, iCol, jRow) { // flip odd col xy
  if (i % 2 === 1) {
    point(mirrorX(x) + iCol, mirrorY(y) + jRow)
  } else {
    point(x + iCol, y + jRow)
  }
}
// --
function mapping8 (i, j, iCol, jRow) { // flip odd row x
  if (j % 2 === 1) {
    point(mirrorX(x) + iCol, y + jRow)
  } else {
    point(x + iCol, y + jRow)
  }
}
function mapping9 (i, j, iCol, jRow) { // flip odd row y
  if (j % 2 === 1) {
    point(x + iCol, mirrorY(y) + jRow)
  } else {
    point(x + iCol, y + jRow)
  }
}
function mapping10 (i, j, iCol, jRow) { // flip odd row xy
  if (j % 2 === 1) {
    point(mirrorX(x) + iCol, mirrorY(y) + jRow)
  } else {
    point(x + iCol, y + jRow)
  }
}
// --
function mapping11 (i, j, iCol, jRow) { // flip odd col & even row x, flip even col & odd row x
  if (i % 2 === 1 && j % 2 === 0) {
    point(mirrorX(x) + iCol, y + jRow)
  } else if (i % 2 === 0 && j % 2 === 1) {
    point(mirrorX(x) + iCol, y + jRow)
  } else {
    point(x + iCol, y + jRow)
  }
}
function mapping12 (i, j, iCol, jRow) { // flip odd col & even row y, flip even col & odd row y
  if (i % 2 === 1 && j % 2 === 0) {
    point(x + iCol, mirrorY(y) + jRow)
  } else if (i % 2 === 0 && j % 2 === 1) {
    point(x + iCol, mirrorY(y) + jRow)
  } else {
    point(x + iCol, y + jRow)
  }
}
function mapping13 (i, j, iCol, jRow) { // flip odd col & even row xy, flip even col & odd row xy
  if (i % 2 === 1 && j % 2 === 0) {
    point(mirrorX(x) + iCol, mirrorY(y) + jRow)
  } else if (i % 2 === 0 && j % 2 === 1) {
    point(mirrorX(x) + iCol, mirrorY(y) + jRow)
  } else {
    point(x + iCol, y + jRow)
  }
}
// --
function mapping14 (i, j, iCol, jRow) { // flip even col & even row x, flip odd col & odd row x
  if (i % 2 === 0 && j % 2 === 0) {
    point(mirrorX(x) + iCol, y + jRow)
  } else if (i % 2 === 1 && j % 2 === 1) {
    point(mirrorX(x) + iCol, y + jRow)
  } else {
    point(x + iCol, y + jRow)
  }
}
function mapping15 (i, j, iCol, jRow) { // flip even col & even row y, flip odd col & odd row y
  if (i % 2 === 0 && j % 2 === 0) {
    point(x + iCol, mirrorY(y) + jRow)
  } else if (i % 2 === 1 && j % 2 === 1) {
    point(x + iCol, mirrorY(y) + jRow)
  } else {
    point(x + iCol, y + jRow)
  }
}
function mapping16 (i, j, iCol, jRow) { // flip even col & even row xy, flip odd col & odd row xy
  if (i % 2 === 0 && j % 2 === 0) {
    point(mirrorX(x) + iCol, mirrorY(y) + jRow)
  } else if (i % 2 === 1 && j % 2 === 1) {
    point(mirrorX(x) + iCol, mirrorY(y) + jRow)
  } else {
    point(x + iCol, y + jRow)
  }
}

// ---------------------------------------------------------------------------------------
function mirrorX (ox) {
  return round(maxX / col - ox)
}
function mirrorY (oy) {
  return round(maxY / row - oy)
}