useless machines 210614

let topBeam;

​

function setup() {

  createCanvas(900, 900);

  colorMode(HSB, 360, 100, 100, 1.0);

​

  topBeam = new Beam(0.49, 500, 50,

    200, [0, 0], 0);

  topBeam.offsetX = width / 2;

  topBeam.offsetY = 256;

​

  createBeams(topBeam, 0.8, 500, 100, 30, 5);

}

​

function createBeams(parentBeam, p, l, yo, w, n) {

  if (n === 0) return;

  const lb = new Beam(p, p * l, p * yo, p * w);

  lb.color = color(280, 100, 70, 0.2);

  const rb = new Beam(p, p * l, p * yo, p * w);

  rb.color = color(280 * p, 100, 70, 0.2);

  parentBeam.attach(lb, 0);

  parentBeam.attach(rb, 1);

​

  createBeams(lb, p, l, yo, w, n - 1);

  createBeams(rb, p, l, yo, w, n - 1);

}

​

function draw() {

  background(54, 8, 96);

  topBeam.update();

  topBeam.draw();

  topBeam.drawPoints();

}

​

class Beam {

  constructor(pivot, length, offsetY, mass, weights, initialAngle) {

    weights = weights || [0, 0];

    this.startPoints = [];

    this.endPoints = [];

    this.pointsLimit = 200;

    this.stopAtPointsLimit = true;

    this.on = true;

​

    this.attachments = [null, null];

    this.dt = 0.1;

​

    this.parent = null;

    this.side = -1;

    this.offsetY = offsetY;

​

    this.pivot = pivot;

    this.length = [

      length * this.pivot,

      length * (1 - this.pivot)

    ];

    this.offsetX = -this.length[0];

    this.mass = [

      mass * this.pivot + weights[0],

      mass * (1 - this.pivot) + weights[1]

    ];

    this.calculateMomentOfInertia();

​

    this.angle = initialAngle || 0;

    this.angularVelocity = 0;

    this.angularAccelaration = 0;

    this.color = color(130,100,70,0.5);

  }

​

  calculateMomentOfInertia() {

    this.I = rodMomentOfInertia(this.mass[0], this.length[0]) +

      rodMomentOfInertia(this.mass[1], this.length[1]);

    if (this.attachments[0] !== null) {

      this.I += pointMassMomentOfInertia(this.attachments[0].totalMass(), this.length[0]);

    }

    if (this.attachments[1] !== null) {

      this.I += pointMassMomentOfInertia(this.attachments[1].totalMass(), this.length[1]);

    }

  }

​

  totalMass() {

    return this.mass[0] + this.mass[1];

  }

​

  update() {

    if (!this.on) return;

    const g = 12;

    // not totally sure why it's cosine here but it works

    const lF = cos(this.angle) * force(this.mass[0], g);

    const rF = cos(this.angle) * force(this.mass[1], g);

    // total torque; counterclockwise is negative, clockwise is positive

    const totalTorque = torque(rF, this.length[1]) - torque(lF, this.length[0]);

    // update kinematics; acceleration, velocity, position

    this.angularAcceleration = angularAcceleration(totalTorque, this.I);

    this.angularVelocity = this.angularVelocity + (this.angularAcceleration * this.dt);

    this.angle = this.angle + (this.angularVelocity * this.dt);

​

    if (this.attachments[0] !== null) {

      this.attachments[0].offsetX = this.startPt().x;

      this.attachments[0].update();

    }

    if (this.attachments[1] !== null) {

      this.attachments[1].offsetX = this.endPt().x;

      this.attachments[1].update();

    }

​

    this.startPoints.push(this.startPt());

    if (this.startPoints.length > this.pointsLimit) {

      // stop or trim

      if (this.stopAtPointsLimit) {

        this.on = false;

      } else {

        this.startPoints.splice(0, 1);

      }

    }

    this.endPoints.push(this.endPt());

    if (this.endPoints.length > this.pointsLimit) {

      // stop or trim

      if (this.stopAtPointsLimit) {

        this.on = false;

      } else {

        this.endPoints.splice(0, 1);

      }

    }

  }

​

  attach(obj, side) {

    side = side || 0;

    obj.parent = this;

    obj.side = side;

    if (this.parent) {

      // reattach to recalculate mass

      this.parent.attach(this, this.side);

    }

    this.attachments[side] = obj;

    this.mass[side] = this.mass[side] + obj.totalMass();

  }

​

  pivotXY() {

    let y = this.offsetY;

    if (this.parent) {

      if (this.side === 0) {

        y += this.parent.startPt().y;

      } else {

        y += this.parent.endPt().y;

      }

    }

    return createVector(this.offsetX, y);

  }

​

  startPt() {

    const pivot = this.pivotXY();

    return createVector(

      pivot.x + -this.length[0] * cos(this.angle),

      pivot.y + -this.length[0] * sin(this.angle)

    );

  }

  endPt() {

    const pivot = this.pivotXY();

    return createVector(

      pivot.x + this.length[1] * cos(this.angle),

      pivot.y + this.length[1] * sin(this.angle)

    );

  }

​

  drawPoints() {

    push();

    if (this.parent !== null) {

      noFill();

      stroke(this.color);

      strokeWeight(1);

      const pivot = this.pivotXY();

​

      beginShape();

      for (let p = 0; p < this.startPoints.length; p++) {

        const pt = this.startPoints[p];

        curveVertex(pt.x, pt.y);

      }

      endShape();

      beginShape();

      for (let p = 0; p < this.endPoints.length; p++) {

        const pt = this.endPoints[p];

        curveVertex(pt.x, pt.y);

      }

      endShape();

    }

​

    if (this.attachments[0] !== null) {

      this.attachments[0].drawPoints();

    }

    if (this.attachments[1] !== null) {

      this.attachments[1].drawPoints();

    }

    pop();

  }

​

  draw() {

    if (!this.on) return;

    push();

    stroke(0, 0, 5);

    fill(0, 0, 5);

    // move to pivot xy

    const pivot = this.pivotXY();

    translate(pivot.x, pivot.y);

    // draw pivot

    circle(0, 0, 3);

​

    // beam

    push();

    rotate(this.angle);

    strokeWeight(1);

    line(-this.length[0], 0, this.length[1], 0);

    pop();

​

    pop();

​

    // attachments

    if (this.attachments[0] !== null) {

      push();

      // translate(0, this.startPt().y);

      this.attachments[0].draw();

      stroke(0, 0, 65);

      strokeWeight(0.5);

      line(this.startPt().x, this.startPt().y,

        this.attachments[0].pivotXY().x,

        this.attachments[0].pivotXY().y);

      pop();

    }

    if (this.attachments[1] !== null) {

      push();

      // translate(0, this.endPt().y);

      this.attachments[1].draw();

      stroke(0, 0, 65);

      strokeWeight(0.5);

      line(this.endPt().x, this.endPt().y,

        this.attachments[1].pivotXY().x,

        this.attachments[1].pivotXY().y);

      pop();

    }

​

    // end attachment points

    push();

    noStroke();

    fill(130, 100, 70);

    circle(this.startPt().x, this.startPt().y, 8);

    fill(180, 100, 70);

    circle(this.endPt().x, this.endPt().y, 8);

    pop();

  }

}