Light Simulation

​

zoom = 2

spread = 12

energyLoss = 0.75

energyLossOnMirror = 0

randomDirection = true

snapAmount = 6

snapOn = true

​

tool = 'Lamp'

​

​

typeSelected = 'Wall'

​

function setup() {

  createCanvas(windowWidth, windowHeight);

  background(100);

  angleMode(DEGREES)

  setupSpecs()

  energyKept = 1 - energyLoss

  energyKeptOnMirror = 1 - energyLossOnMirror

}

rays = []

walls = []

function draw() {

  snapAmount = snapSliderS.value()

  zoom = zoomSlider.value()

  scale(zoom,zoom)

  // mouseX/=2

  // mouseY/=2

  fill(255)

  background(0)

  stroke(200, 0, 0)

  newRays = []

  for(let i = 0; i < walls.length; i++){

    walls[i].draw()

  } 

  for(let i = 0; i < rays.length; i++){

    returnedI = rays[i].move()

    if(returnedI !== false){

      if(!rays[i].newRay && walls[returnedI].type == 'Wall'){

        for(let a = 0; a < 360; a+=360/spread){

          if(rays[i].brightness*energyKept > 2){

            let aReset = a

            if(randomDirection){

              a = random(360-2)

            }

            newRays.push(new ray(rays[i].x-rays[i].xVel*1 + sin(a)*4, rays[i].y-rays[i].yVel*1 + cos(a)*4, a, rays[i].brightness*energyKept))

            a = aReset

          }

        }

      }

      if(walls[returnedI].type == 'Wall'){

        for(let w = 0; w < walls.length; w++){

          for(let r = 0; r < newRays.length; r++){

            if(isIntersecting(

            {x: newRays[r].x, y: newRays[r].y}, {x: newRays[r].x-newRays[r].xVel*4, y: newRays[r].y-newRays[r].yVel*4},

            {x: walls[w].x, y: walls[w].y}, {x: walls[w].x2, y: walls[w].y2})){

              newRays.splice(r, 1)

              r--

            }

          }

        }

      }

      if(walls[returnedI].type == 'Mirror'){

        let wallAngle = atan2((walls[returnedI].x-walls[returnedI].x2),(walls[returnedI].y-walls[returnedI].y2))

        let normalLine = wallAngle - 90

        let rayAngle = rays[i].a

        let a = (normalLine - (rayAngle - normalLine)) + 180

        newRays.push(new ray(rays[i].x-rays[i].xVel*1 + sin(a)*1, rays[i].y-rays[i].yVel*1 + cos(a)*1, a, rays[i].brightness*energyKeptOnMirror, false, returnedI))

      }

      rays.splice(i, 1)

      i--

    } else {

        rays[i].draw()

        if(rays[i].brightness < 2){

          rays.splice(i, 1)

          i--

        } 

        else if ((rays[i].x > (width+20)/zoom || rays[i].x < -20) || (rays[i].y > (height+20)/zoom || rays[i].y < -20)){

          rays.splice(i, 1)

          i--

      }

    } 

  } 

  for(let i = 0; i < newRays.length; i++){  

    rays.push(new ray(newRays[i].x, newRays[i].y, newRays[i].a, newRays[i].brightness, true, newRays[i].lastMirrorI))

  }

  strokeWeight(1)

  showSpecs()

  if((keyIsDown(83)) && (frameCount%15==0 || (frameCount%5==0 && tool == 'Lazer'))){  

    shootLight()

  } 

  if(mouseIsPressed){

    push()

    if(typeSelected == 'Mirror'){

      stroke(235, 236, 240, 170)

    } else if(typeSelected == 'Wall'){

      stroke(152, 107, 65, 170)

    }

    let snapX = mouseX/zoom

    let snapY = mouseY/zoom

    let snapAngle = atan2((x-snapX),(y-snapY))

    if(abs(snapAngle%45) < 0+snapAmount){

      snapAngle -= (snapAngle%45)

    }

    if(abs(snapAngle%45) > 45-snapAmount){

      if(snapAngle%45 > 0){

        snapAngle += (45 - abs(snapAngle%45))

      } else {

        snapAngle -= (45 - abs(snapAngle%45))

      }

    }

​

​

    if(abs(snapAngle)%45 == abs(round(0)) && snapOn){

      let snapDist = abs(dist(snapX, snapY, x, y))

      snapY = y - cos(snapAngle)*snapDist

      snapX = x - sin(snapAngle)*snapDist

    }

    if(typeSelected != "Eraser" && typeSelected != "Curved"){

      line(x, y, snapX, snapY)

    } else if(typeSelected == "Eraser"){

      for(let e = 0; e < walls.length; e++){

        //print(distanceSegmentToPoint({x: walls[e].x, y: walls[e].y}, {x: walls[e].x2, y: walls[e].y2}, {x:mouseX/zoom , y:mouseY/zoom}))

        if(distanceSegmentToPoint({x: walls[e].x, y: walls[e].y}, {x: walls[e].x2, y: walls[e].y2+0.01}, {x:mouseX/zoom , y:mouseY/zoom}) < 25/zoom){

          walls.splice(e, 1)

          e--

        }

      }

    }

    pop()

  } 

  if(typeSelected == 'Eraser') {

    push()

    stroke(255)

    noFill()

    ellipse(mouseX/zoom, mouseY/zoom, 50/zoom, 50/zoom)

    pop()

  }

  if(typeSelected == 'Curved'){

    let parabolaPoints = createParabola(3)

    stroke(235, 236, 240, 170)

    for(let p = 1; p < parabolaPoints.length; p++){

      line(parabolaPoints[p-1].x, parabolaPoints[p-1].y, parabolaPoints[p].x, parabolaPoints[p].y)

    }

  }

  if(keyIsDown(39)){

    lazerAngle -= 1

  }

  if(keyIsDown(37)){

    lazerAngle += 1

  }

  if(keyIsDown(40)){

    parabolaSize -= 1

  }

  if(keyIsDown(38)){

    parabolaSize += 1

  }

  if(tool == 'Lazer') {

    push()

    noStroke()

    fill(200)

    rectMode(CENTER)

    translate(mouseX/zoom, mouseY/zoom)

    rotate(-lazerAngle + 90)

    rect(0, 0, 50/zoom, 10/zoom)

    stroke(255,0,0)

    strokeWeight(6/zoom)

    point(20/zoom, 0)

    pop()

  }

}

​

x = 0

y = 0

​

function mousePressed(){

  // if(pointToSquare(mouseX/zoom, mouseY/zoom, 0, 0, 200, 100)){

  //  return

  // }

  x = mouseX/zoom

  y = mouseY/zoom

}

​

function keyPressed(){

  if(key.toLowerCase() == 's'){

    shootLight()

  }

}

​

function mouseReleased(){

  if(pointToSquare(mouseX, mouseY, 0, 0, 270, 80) || pointToSquare(mouseX, mouseY, 0, 0, 130, 250)){

    return

  }

  if(pointToSquare(x*zoom, y*zoom, 0, 0, 270, 80) || pointToSquare(x*zoom, y*zoom, 0, 0, 130, 250)){

    return

  }

  if(typeSelected == 'Curved'){

    let parabolaPoints = createParabola(3)

    for(let p = 1; p < parabolaPoints.length; p++){

      walls.push(new wall(parabolaPoints[p-1].x, parabolaPoints[p-1].y, parabolaPoints[p].x, parabolaPoints[p].y, "Mirror"))

    }

    return

  }

  if(typeSelected == 'Eraser'){

    return

  }

  let snapX = mouseX/zoom

  let snapY = mouseY/zoom

  let snapAngle = atan2((x-snapX),(y-snapY))

  if(abs(snapAngle%45) < 0+snapAmount){

    snapAngle -= (snapAngle%45)

  }

  if(abs(snapAngle%45) > 45-snapAmount){

    if(snapAngle%45 > 0){

      snapAngle += (45 - abs(snapAngle%45))

    } else {

      snapAngle -= (45 - abs(snapAngle%45))

    }

  }

​

​

  if(abs(snapAngle)%45 == abs(round(0)) && snapOn){

    let snapDist = abs(dist(snapX, snapY, x, y))

    snapY = y - cos(snapAngle)*snapDist

    snapX = x - sin(snapAngle)*snapDist

  }

  walls.push(new wall(x, y, snapX, snapY, typeSelected))

}