animate/docs/js/objects.js

class BaseShape {
  constructor() {
    this.controls = []; // Keep track of created elements and event listeners
    this.speedMultiplier = 100;
  }

  initialise(config) {
    for (let item of config) {
      const { element, listener } = addControl(item, this);
      this.controls.push({ element, listener });
    }

    const { element, listener } = addControl(
      {
        type: "range",
        min: 1,
        max: 500,
        defaultValue: 100,
        property: "speedMultiplier",
      },
      this
    );
    this.controls.push({ element, listener });
  }

  remove() {
    this.controls.forEach(({ element, listener }) => {
      if (element && listener) {
        element.removeEventListener("input", listener);
      }
      if (element && element.parentElement) {
        element.parentElement.removeChild(element);
        const titleElement = document.getElementById(
          "elText" + element.id.slice(2)
        );
        titleElement.parentElement.removeChild(titleElement);
      }
    });
    this.controls = [];
  }

  draw() {
    throw new Error("Draw function not implemented");
  }
}

class PolyTwistColourWidth extends BaseShape {
  constructor(
    sides,
    width,
    line_width,
    depth,
    rotation,
    speedMultiplier,
    colour1,
    colour2
  ) {
    super();
    this.sides = sides;
    this.width = width;
    this.line_width = line_width;
    this.depth = depth;
    this.rotation = rotation;
    this.speedMultiplier = speedMultiplier;
    this.colour1 = colour1;
    this.colour2 = colour2;
  }

  draw(rotation) {
    rotation *= this.speedMultiplier / 100;
    let out_angle = 0;
    const innerAngle = 180 - ((this.sides - 2) * 180) / this.sides;
    const scopeAngle =
      rotation - innerAngle * Math.floor(rotation / innerAngle);

    if (scopeAngle < innerAngle / 2) {
      out_angle =
        innerAngle /
          (2 * Math.cos((2 * Math.PI * scopeAngle) / (3 * innerAngle))) -
        innerAngle / 2;
    } else {
      out_angle =
        -innerAngle /
          (2 *
            Math.cos(
              (2 * Math.PI) / 3 - (2 * Math.PI * scopeAngle) / (3 * innerAngle)
            )) +
        (innerAngle * 3) / 2;
    }
    let minWidth =
      Math.sin(rad(innerAngle / 2)) * (0.5 / Math.tan(rad(innerAngle / 2))) * 2;

    let widthMultiplier =
      minWidth /
      Math.sin(
        (Math.PI / 180) *
          (90 +
            innerAngle / 2 -
            out_angle +
            innerAngle * Math.floor(out_angle / innerAngle))
      );

    for (let i = 0; i < this.depth; i++) {
      const fraction = i / this.depth;
      const ncolour = LerpHex(this.colour1, this.colour2, fraction);
      DrawPolygon(
        this.sides,
        this.width * widthMultiplier ** i,
        out_angle * i + this.rotation,
        ncolour,
        this.line_width
      );
    }
  }
}
class FloralPhyllo extends BaseShape {
  constructor(width, depth, colour1, colour2) {
    super();
    this.width = width;
    this.depth = depth;
    this.colour1 = colour1;
    this.colour2 = colour2;
    this.speedMultiplier = 500;
  }

  draw(rotation) {
    rotation *= this.speedMultiplier / 100;
    // var c = 24; //something to do with width. but not width
    var c = 1; //something to do with width. but not width
    //dont make larger than 270 unless altering the number of colours in lerpedColours
    for (let n = 200; n > 0; n -= 1) {
      // let ncolour = LerpHex(this.colour1, this.colour2, n);
      const a = (n * rotation) / 1000; //137.5;
      const r = c * Math.sqrt(n);
      const x = r * Math.cos(a) + centerX;
      const y = r * Math.sin(a) + centerY;

      drawEyelid(n * 2.4 + 40, x, y, ncolour);
    }
  }
}
class Spiral1 extends BaseShape {
  constructor(sides, width, colour) {
    super();
    this.sides = sides;
    this.width = width;
    this.colour = colour;
  }

  draw(rotation) {
    rotation *= this.speedMultiplier / 100;
    var rot = Math.round((((this.sides - 2) * 180) / this.sides) * 2);
    var piv = 360 / this.sides;
    var stt = 0.5 * Math.PI - rad(rot); //+ rad(rotation);
    var end = 0;
    var n = this.width / ((this.width / 10) * (this.width / 10)); //pixel correction for mid leaf

    for (let i = 1; i < this.sides + 1; i++) {
      end = stt + rad(rot);

      ctx.beginPath();
      ctx.arc(
        centerX + Math.cos(rad(90 + piv * i + rotation)) * this.width,
        centerY + Math.sin(rad(90 + piv * i + rotation)) * this.width,
        this.width,
        stt + rad(rotation) - (stt - end) / 2,
        end + rad(rotation) + rad(n),
        0
      );
      ctx.strokeStyle = this.colour;
      ctx.stroke();

      ctx.beginPath();
      ctx.arc(
        centerX + Math.cos(rad(90 + piv * i - rotation)) * this.width,
        centerY + Math.sin(rad(90 + piv * i - rotation)) * this.width,
        this.width,
        stt - rad(rotation),
        end - (end - stt) / 2 + rad(n) - rad(rotation),
        0
      );
      ctx.strokeStyle = this.colour;
      ctx.stroke();

      stt = end + -rad(rot - piv); //+rad(30);
    }
  }
}

class FloralAccident extends BaseShape {
  constructor(sides, width, colour) {
    super();
    this.sides = sides;
    this.width = width;
    this.colour = colour;
  }

  draw(rotation) {
    rotation *= this.speedMultiplier / 100;
    var rot = Math.round((((this.sides - 2) * 180) / this.sides) * 2);
    var piv = 360 / this.sides;
    var stt = 0.5 * Math.PI - rad(rot); //+ rad(rotation);
    var end = 0;
    var n = this.width / ((this.width / 10) * (this.width / 10)); //pixel correction for mid leaf

    for (let i = 1; i < this.sides + 1; i++) {
      end = stt + rad(rot);

      ctx.beginPath();
      ctx.arc(
        centerX + Math.cos(rad(90 + piv * i + rotation)) * this.width,
        centerY + Math.sin(rad(90 + piv * i + rotation)) * this.width,
        this.width,
        stt - (stt - end + rad(rotation)) / 2,
        end + rad(n),
        0
      );
      ctx.strokeStyle = this.colour;
      ctx.stroke();

      ctx.beginPath();
      ctx.arc(
        centerX + Math.cos(rad(90 + piv * i - rotation)) * this.width,
        centerY + Math.sin(rad(90 + piv * i - rotation)) * this.width,
        this.width,
        stt,
        end - (end - stt - rad(rotation)) / 2 + rad(n),
        0
      );
      ctx.strokeStyle = this.colour;
      ctx.stroke();

      stt = end + -rad(rot - piv); //+rad(30);
    }
  }
}
class FloralPhyllo_Accident extends BaseShape {
  constructor(sides, width, colour1, colour2) {
    super();
    this.sides = sides;
    this.width = width;
    this.colour1 = colour1;
    this.colour2 = colour2;
  }

  draw(rotation) {
    rotation *= this.speedMultiplier / 100;
    var c = 24; //something to do with width. but not width

    for (let n = 0; n < 300; n += 1) {
      let ncolour = LerpHex(this.colour1, this.colour2, Math.cos(rad(n / 2)));
      let a = n * (rotation / 1000 + 100); //137.5;
      let r = c * Math.sqrt(n);
      let x = r * Math.cos(a) + centerX;
      let y = r * Math.sin(a) + centerY;

      drawEyelidAccident(x, y);
    }
  }
}
class Nodal_expanding extends BaseShape {
  constructor(expand, points, line_width, colour1, colour2, colour_change) {
    super();
    this.expand = expand;
    this.points = points;
    this.line_width = line_width;
    this.colour1 = colour1;
    this.colour2 = colour2;
    this.colour_change = colour_change;
  }

  draw(rotation) {
    rotation *= this.speedMultiplier / 100;
    let colour_change = this.colour_change / 8;
    var angle = (360 / this.points) * rotation;

    var start_angle = angle;
    var done = false;
    var total_moves = 1;
    var length = this.expand;

    for (let z = 1; z <= 100; z++) {
      //why specifically 2500
      ctx.beginPath();
      let ncolour = LerpHex(
        this.colour1,
        this.colour2,
        Math.cos(rad(z * colour_change))
      );

      ctx.moveTo(
        centerX + Math.cos(rad(angle * (z - 1) + 0)) * (length - this.expand),
        centerY + Math.sin(rad(angle * (z - 1) + 0)) * (length - this.expand)
      );
      ctx.lineTo(
        centerX + Math.cos(rad(angle * z + 0)) * length,
        centerY + Math.sin(rad(angle * z + 0)) * length
      );
      length += this.expand;
      ctx.lineWidth = this.line_width; //try 1
      ctx.strokeStyle = ncolour;
      ctx.lineCap = "round";
      // ctx.strokeStyle = colourToText(ncolour);
      console.log(ncolour);
      ctx.stroke();
    }
  }
}
class Nodal extends BaseShape {
  constructor(width, points, line_width, step, colour) {
    super();
    this.width = width;
    this.points = points;
    this.line_width = line_width;
    this.step = step;
    this.colour = colour;
  }
  // Draw_nodal(300, 100, 31, rotation, "blue");
  draw(rotation) {
    rotation *= this.speedMultiplier / 100;
    // console.log(rotate)
    var angle = (360 / this.points) * this.step;
    ctx.beginPath();
    var start_angle = angle;
    var done = false;
    var total_moves = 1;
    ctx.moveTo(
      centerX + Math.cos(rad(angle + rotation)) * this.width,
      centerY + Math.sin(rad(angle + rotation)) * this.width
    );

    while (done != true) {
      if ((total_moves * this.step) % this.points != 0) {
        total_moves++;
      } else {
        total_moves++;
        done = true;
      }
    }
    for (let z = 1; z <= total_moves; z++) {
      ctx.lineTo(
        centerX + Math.cos(rad(angle * z + rotation)) * this.width,
        centerY + Math.sin(rad(angle * z + rotation)) * this.width
      );
    }
    ctx.lineWidth = this.line_width; //try 1
    ctx.strokeStyle = this.colour;
    ctx.stroke();
  }
}
class Phyllotaxis extends BaseShape {
  constructor(width, nMax, colour1, colour2) {
    super();
    this.width = width;
    this.nMax = nMax;
    this.colour1 = colour1;
    this.colour2 = colour2;
  }
  // Draw_nodal(300, 100, 31, rotation, "blue");
  draw(rotation) {
    rotation *= this.speedMultiplier / 100;
    for (let n = 0; n < this.nMax; n += 1) {
      const ncolour = LerpHex(this.colour1, this.colour2, n / this.nMax);
      // const ncolour = LerpHex(this.colour1, this.colour2, (n/this.nMax)**2);
      const a = n * (rotation / 1000); //137.5;
      const r = this.width * Math.sqrt(n);
      const x = r * Math.cos(a) + centerX;
      const y = r * Math.sin(a) + centerY;

      ctx.beginPath();
      ctx.arc(x, y, 8, 0, 2 * Math.PI);
      ctx.fillStyle = ncolour;
      // ctx.fillStyle = colourToText(ncolour);
      ctx.fill();
      // console.log(this.c)
    }
  }
}
class SquareTwist_angle extends BaseShape {
  constructor(width, line_width, colour1) {
    super();
    this.width = width;
    this.line_width = line_width;
    this.colour1 = colour1;
  }
  drawSquare(angle, size, colour) {
    ctx.save();
    ctx.translate(centerX, centerY); //-(Math.sin(rad(angle)) *centerX));
    ctx.rotate(rad(angle + 180));
    ctx.beginPath();
    ctx.strokeStyle = colour;
    ctx.lineWidth = this.line_width;
    ctx.rect(-size / 2, -size / 2, size, size);
    ctx.stroke();
    ctx.restore();
  }
  // DrawSquareTwist_angle(400,0,rotation,"red")
  draw(rotation) {
    rotation *= this.speedMultiplier / 100;
    let out_angle = rotation;
    let widthMultiplier =
      1 /
        (2 *
          Math.sin(
            (Math.PI / 180) *
              (130 - out_angle + 90 * Math.floor(out_angle / 90))
          )) +
      0.5;

    for (let i = 0; i < 25; i++) {
      this.drawSquare(
        rotation * i,
        this.width * widthMultiplier ** i,
        this.colour1
      );
    }
  }
}
class rectangle_pattern1 extends BaseShape {
  constructor(width, squares, line_width, colour1) {
    super();
    this.width = width;
    this.squares = squares;
    this.line_width = line_width;
    this.colour1 = colour1;
  }
  drawSquare(angle, size, colour) {
    ctx.save();
    ctx.translate(centerX, centerY); //-(Math.sin(rad(angle)) *centerX));
    ctx.rotate(rad(angle + 180));
    ctx.beginPath();
    ctx.strokeStyle = colour;
    ctx.lineWidth = this.line_width;
    ctx.rect(-size / 2, -size / 2, size, size);
    ctx.stroke();
    ctx.restore();
  }
  // Draw_rectangle_pattern1(rotation, squares, 200, "blue");
  draw(rotation) {
    rotation *= this.speedMultiplier / 100;
    for (let z = 0; z < 360; z += 360 / this.squares) {
      this.drawSquare(z + rotation, this.width, this.colour1);
    }
  }
}
class EyePrototype extends BaseShape {
  constructor(
    width,
    blink_speed,
    draw_spiral,
    draw_pupil,
    draw_expand,
    draw_eyelid,
    line_width,
    colourPupil,
    colourSpiral,
    colourExpand
  ) {
    super();
    this.width = width;
    this.line_width = line_width;
    this.colourPupil = colourPupil;
    this.colourSpiral = colourSpiral;
    this.colourExpand = colourExpand;
    this.step = 0;
    this.speed = blink_speed;
    this.opening = true;
    this.counter = 0;
    this.cooldown = 0;
    this.draw_spiral = draw_spiral;
    this.draw_pupil = draw_pupil;
    this.draw_expand = draw_expand;
    this.draw_eyelid = draw_eyelid;
  }
  drawEyelid(rotation) {
    rotation *= this.speedMultiplier / 100;
    ctx.lineWidth = 1;
    ctx.beginPath();
    ctx.moveTo(centerX - this.width / 2, centerY);
    ctx.quadraticCurveTo(
      centerX,
      centerY - (rotation / 400) * this.width,
      centerX + this.width / 2,
      centerY
    );

    ctx.moveTo(centerX - this.width / 2, centerY);
    ctx.quadraticCurveTo(
      centerX,
      centerY + (rotation / 400) * this.width,
      centerX + this.width / 2,
      centerY
    );
    ctx.stroke();
  }
  eyelidCut(step) {
    // ctx.lineWidth = 1;
    let squarePath = new Path2D();
    squarePath.moveTo(centerX - this.width / 2, centerY);
    squarePath.quadraticCurveTo(
      centerX,
      centerY - (step / 400) * this.width,
      centerX + this.width / 2,
      centerY
    );

    squarePath.moveTo(centerX - this.width / 2, centerY);
    squarePath.quadraticCurveTo(
      centerX,
      centerY + (step / 400) * this.width,
      centerX + this.width / 2,
      centerY
    );

    ctx.clip(squarePath);
  }
  drawGrowEye(step) {
    // console.log(step)
    ctx.strokeStyle = this.colourExpand;
    ctx.beginPath();
    ctx.lineWidth = 5;
    ctx.arc(centerX, centerY, step, 0, 2 * Math.PI);
    ctx.stroke();

    // ctx.strokeStyle = "orange";
  }
  drawCircle(step) {
    ctx.strokeStyle = this.colourPupil;
    ctx.beginPath();
    ctx.lineWidth = 5;
    ctx.arc(centerX, centerY, step, 0, 2 * Math.PI);
    ctx.stroke();
  }

  drawSpiral(step) {
    let a = 1;
    let b = 5;
    ctx.moveTo(centerX, centerY);
    ctx.beginPath();
    for (let i = 0; i < 400; i++) {
      let angle = 0.1 * i;
      let x = centerX + (a + b * angle) * Math.cos(angle + step / 2);
      let y = centerY + (a + b * angle) * Math.sin(angle + step / 2);

      ctx.lineTo(x, y);
    }
    ctx.lineWidth = 3;
    ctx.strokeStyle = this.colourSpiral;
    ctx.stroke();
  }
  stepFunc() {
    if (this.cooldown != 0) {
      this.cooldown--;
    } else {
      if (this.opening == true) {
        if (this.step >= 200) {
          this.cooldown = 200;
          this.opening = false;
          this.step -= this.speed;
        } else {
          this.step += this.speed;
        }
      } else {
        if (this.step <= 0) {
          this.opening = true;
          this.step += this.speed;
        } else {
          this.step -= this.speed;
        }
      }
    }
  }

  draw(rotation) {
    let speedMult = 50
    let waitTime = 3
    let cap = 200
    let d = waitTime * speedMult * 10
    let a = cap * 2 + d
    let outputRotation = Math.min(Math.abs((Math.floor(rotation * speedMult) % a) - a / 2 - d / 2), cap)
    // console.log("Rot: "+ rotation + " | " +Math.floor(rotation)%a)
    console.log(outputRotation)
    // console.log(this.counter)
    if (this.draw_eyelid) {
      ctx.strokeStyle = "white";
    }
    else{
      ctx.strokeStyle = "black";
    }
    ctx.fillStyle = "black";
    // ctx.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height);
    // ctx.fillRect(0, 0, 500, 500);

    // let newPath = new Path2D();
    // newPath.arc(150, 75, 75, 0, 2 * Math.PI);

    // ctx.beginPath();
    // ctx.rect(centerX-300/2, centerY-300/2, 300, 300);
    // ctx.stroke();

    // this.drawEyelid(this.step);
    this.drawEyelid(outputRotation);

    ctx.save();
    // squareCut();
    this.eyelidCut(outputRotation);
    if (this.counter % 100 == 0) {
      this.counter = 0;
    }
    // this.drawGrowEye(this.width/4 + this.counter);

    if (this.draw_spiral) {
      this.drawSpiral(rotation)
    }

    this.eyelidCut(outputRotation);
    console.log(this.draw_expand);
    if (this.counter % Math.floor(this.width / 4) == 0) {
      this.counter = 0;
    }
    if (this.draw_expand) {
      this.drawGrowEye(this.width / 4 + this.counter);
    }
    if (this.draw_spiral) {
      this.drawSpiral(rotation);
    }
    if (this.draw_pupil) {
      this.drawCircle(this.width / 4);
    }

    ctx.restore();

    // this.stepFunc();
    // this.counter++;
  }
}