Colisão dos Cometas

/******************

Code by Vamoss

Original code link:

https://openprocessing.org/sketch/2332433

​

Author links:

http://vamoss.com.br

http://twitter.com/vamoss

http://github.com/vamoss

******************/

​

const shapeSize = Math.hypot(innerWidth, innerHeight) / Math.hypot(1920, 1080) * 50;

const colors = ["#FFC30F", "#581845", "#900C3F", "#C70039", "#FF5733", "#1AC7C4"];

​

var config = {

  acceleration: 3,

  maxAcceleration: 5,

  maxDist: 4 * shapeSize,

};

​

var particles;

var sh;

​

function setup() {

  createCanvas(windowWidth, windowHeight, WEBGL);

  background(255);

  sh = createShader(vert,frag);

  this.shader(sh);

  sh.setUniform("u_resolution", [width*pixelDensity(),height*pixelDensity()]);

  sh.setUniform("u_tex", this._renderer);

  initiate();

}

​

function initiate(){

  particles = [];

​

  for(var j = 0; j < 60; j++){

    const s = random(shapeSize/3, shapeSize);

    const x = random(width - s * 2) + s - width/2;

    const y = random(height - s * 2) + s - height/2;

    let coords1 = [];

    const resolution = 10;

    for(var i = 0; i < resolution; i++){

      coords1.push({

        x: sin(i / resolution * TWO_PI) * s + x,

        y: cos(i / resolution * TWO_PI) * s + y,

      });

    }

    particles.push(new Particle(x, y, coords1));

  }

}

​

function draw() {

  sh.setUniform("u_time", millis());

  resetShader();

  noStroke();

  fill(255, 255, 255, 10);

  rect(-width/2, -height/2, width, height);

  const numParticles = particles.length;

  for(var i = 0; i < numParticles; i++){

    const particle1 = particles[i];

    var accumX = 0;

    var accumY = 0;

    for(var j = 0; j < numParticles; j++){

      if(i == j) continue;

      const particle2 = particles[j];

      var distX = (particle2.pos.x - particle1.pos.x);

      var distY = (particle2.pos.y - particle1.pos.y);

      var d = distX*distX+distY*distY;

      if(d < config.maxDist*config.maxDist){

        accumX += distX;

        accumY += distY;

        if(true){//particle1.area > 100 && particle2.area > 100){

          const intersect = clipper2lib.Clipper.intersect(particle1.shape, particle2.shape, clipper2lib.FillRule.NonZero, -1);

          if(intersect.length > 0){

            for(var k = 0; k < intersect.length; k++){

              var p = getCentroid(intersect[k]);

              var coords = [];

              for(var l = 0; l < intersect[k].length; l++){

                coords.push({

                  x: intersect[k]._path[l*2+0],

                  y: intersect[k]._path[l*2+1],

                });

              }

              const particle3 = new Particle(p.x, p.y, coords);

              //if(particle3.area > 60)

                //particles.push(particle3);

              const difference1 = clipper2lib.Clipper.difference(particle1.shape, particle3.shape, clipper2lib.FillRule.NonZero, -1);

              const difference2 = clipper2lib.Clipper.difference(particle2.shape, particle3.shape, clipper2lib.FillRule.NonZero, -1);

              particle1.updateShape(difference1);

              particle2.updateShape(difference2);

            }

            particle1.acc.x *= -1;

            particle1.acc.y *= -1;

            particle2.acc.x *= -1;

            particle2.acc.y *= -1;

          }

        }

      }

    }

    var d = sqrt(accumX*accumX+accumY*accumY);

    if(d>0){

      particle1.acc.x += accumX/d * 0.52;

      particle1.acc.y += accumY/d * 0.52;

      //particle1.acc.normalize();//make circular movments

      var xAccell = particle1.acc.x * (config.acceleration/2);// * shapeSize/particle1.area;

      var yAccell = particle1.acc.y * (config.acceleration/2);// * shapeSize/particle1.area;

      particle1.v.add(xAccell, yAccell);

      particle1.v.limit(config.maxAcceleration);

    }else{

      particle1.acc.x *= 0.8;

      particle1.acc.y *= 0.8;

      if(particle1.v.mag()>3)

        particle1.v.mult(0.8);

    }

    particle1.draw();

  }

  this.shader(sh);

  rect(-width/2,-height/2,width,height);

}

​

class Particle {

  constructor(x, y, coords) {

    this.pos = {x, y};

    this.lastPos = {x, y};

    this.acc = createVector(0, 0);

    this.v = createVector(random(-2, 2), random(-2, 2));

    this.color = random(colors);

    const shape = new clipper2lib.PathsD();

    shape.push(coords);

    this.shape = shape;

    this.area = getArea(shape);

  }

  updateShape(shape) {

    this.shape = shape;

    if(shape.length > 0){

      var p = getCentroid(shape[0]);

      this.pos.x = p.x;

      this.pos.y = p.y;

      this.lastPos.x = p.x;

      this.lastPos.y = p.y;

​

      this.area = getArea(shape);

    }

  }

  draw() {

    var tempX = this.pos.x + this.v.x;

    var tempY = this.pos.y + this.v.y;

    if(tempX < -width/2 || tempX > width/2)

      this.v.x *= -1;

    if(tempY < -height/2 || tempY > height/2)

      this.v.y *= -1;

    this.lastPos.x = this.pos.x;

    this.lastPos.y = this.pos.y;

    this.pos.x = this.pos.x + this.v.x;

    this.pos.y = this.pos.y + this.v.y;

    movePathsD(this.shape, this.pos.x - this.lastPos.x, this.pos.y - this.lastPos.y);

​

    fill(this.color);

    drawPathsD(this.shape);

  }

}

​

function getCentroid(p) {

  let x = 0, y = 0;

  let area = 0;

  const numPoints = p.length;

  for (let i = 0; i < numPoints; i++) {

      const j = (i + 1) % numPoints;

      const xi = p._path[i * 2 + 0], yi = p._path[i * 2 + 1];

      const xj = p._path[j * 2 + 0], yj = p._path[j * 2 + 1];

      const a = xi * yj - xj * yi;

      area += a;

      x += (xi + xj) * a;

      y += (yi + yj) * a;

  }

  area *= 0.5;

  x /= (6 * area);

  y /= (6 * area);

  return {x, y};

}

​

function getArea(p) {

  let area = 0;

  if (p.length > 0) {

      const numPoints = p[0].length;

      for (let i = 0; i < numPoints; i++) {

          const j = (i + 1) % numPoints;

          const xi = p[0]._path[i * 2 + 0], yi = p[0]._path[i * 2 + 1];

          const xj = p[0]._path[j * 2 + 0], yj = p[0]._path[j * 2 + 1];

          const a = xi * yj - xj * yi;

          area += a;

      }

      area *= 0.5;

  }

  return Math.abs(area);

}

​

function movePathsD(p, x, y){

  for(var j = 0; j < p.length; j++){

    for(var i = 0; i < p[j].length; i++){

      p[j]._path[i*2+0] += x;

      p[j]._path[i*2+1] += y;

    }

  }

}

​

function drawPathsD(p){

  for(var j = 0; j < p.length; j++){

    let vertices = [];

    for(var i = 0; i < p[j].length; i++){

      vertices.push({x: p[j]._path[i*2+0], y: p[j]._path[i*2+1]});

    }

    const hobbyPoints = createHobbyBezier(vertices, { tension: 1, cyclic: true });

    beginShape();

    vertex(vertices[0].x, vertices[0].y);

    hobbyPoints.forEach(({ startControl, endControl, point }) => {

      bezierVertex(startControl.x, startControl.y, endControl.x, endControl.y, point.x, point.y);

    });

    endShape();

  }

  /*

  for(var j = 0; j < p.length; j++){

    beginShape();

    for(var i = 0; i < p[j].length; i++){

      const px = p[j]._path[i*2+0];

      const py = p[j]._path[i*2+1];

      vertex(px, py);

    }

    endShape(CLOSE);

  }

  */

}

​

function keyPressed(){

  if(key == 's'){

    noLoop();

  }else{

    loop();

  }

}