diff --git a/Loop edition/config.json b/Loop edition/config.json
new file mode 100644
index 0000000..bfed6e4
--- /dev/null
+++ b/Loop edition/config.json
@@ -0,0 +1,16 @@
+{
+ "PolyTwistColourWidth": [
+ { "type": "range", "min": 3, "max": 10, "defaultValue": 5, "property": "sides" },
+ { "type": "range", "min": 1, "max": 600, "defaultValue": 300, "property": "width" },
+ { "type": "range", "min": 1, "max": 100, "defaultValue": 50, "property": "depth" },
+ { "type": "range", "min": 0, "max": 360, "defaultValue": 180, "property": "rotation" },
+ { "type": "color", "defaultValue": "#4287f5", "property": "colour1" },
+ { "type": "color", "defaultValue": "#42f57b", "property": "colour2" }
+ ],
+ "FloralPhyllo": [
+ { "type": "range", "min": 1, "max": 600, "defaultValue": 300, "property": "width" },
+ { "type": "range", "min": 1, "max": 100, "defaultValue": 50, "property": "depth" },
+ { "type": "color", "defaultValue": "#4287f5", "property": "colour1" },
+ { "type": "color", "defaultValue": "#4287f5", "property": "colour2" }
+ ]
+ }
\ No newline at end of file
diff --git a/Loop edition/css/styles.css b/Loop edition/css/styles.css
new file mode 100644
index 0000000..612d6e4
--- /dev/null
+++ b/Loop edition/css/styles.css
@@ -0,0 +1,111 @@
+body {
+ -webkit-box-sizing: border-box;
+ /* Safari/Chrome, other WebKit */
+ -moz-box-sizing: border-box;
+ /* Firefox, other Gecko */
+ box-sizing: border-box;
+ /* Opera/IE 8+ */
+ height: 100%
+}
+
+p {
+ margin: 0px;
+}
+
+canvas {
+ position: absolute;
+}
+
+#toolbar {
+ display: flex;
+ flex-flow: column;
+ height: 100%;
+
+ position: absolute;
+ padding: 0px 20px 0px 20px;
+ width: 500px;
+ height: 100vh;
+ background-color: rgb(189, 189, 189);
+}
+
+#custom {
+ display: flex;
+ flex-flow: column;
+ height: 100%;
+
+ /* position: absolute; */
+ padding: 0px 20px 0px 20px;
+ /* width: 500px; */
+ /* height: 100vh; */
+ background-color: rgb(189, 189, 189);
+}
+
+.button {
+ display: block;
+ position: absolute;
+ right: 20px;
+ z-index: 100;
+}
+
+
+.controls {
+ display: flex;
+ margin: 8px 0px;
+}
+
+.controlFrameButton {
+ width: 8%;
+}
+.controlPauseButton {
+ width: 80%;
+ margin: auto;
+}
+/*
+ */
+
+/* CSS */
+.button-8 {
+ background-color: #e1ecf4;
+ border-radius: 3px;
+ border: 1px solid #7aa7c7;
+ box-shadow: rgba(255, 255, 255, .7) 0 1px 0 0 inset;
+ box-sizing: border-box;
+ color: #1f3f55;
+ cursor: pointer;
+ display: inline-block;
+ /* font-family: -apple-system,system-ui,"Segoe UI","Liberation Sans",sans-serif; */
+ font-size: 13px;
+ font-weight: 400;
+ line-height: 1.15385;
+ /* margin: 0; */
+ outline: none;
+ padding: 8px .8em;
+ position: relative;
+ text-align: center;
+ text-decoration: none;
+ user-select: none;
+ -webkit-user-select: none;
+ touch-action: manipulation;
+ vertical-align: baseline;
+ white-space: nowrap;
+}
+
+.button-8:hover,
+.button-8:focus {
+ background-color: #b3d3ea;
+ color: #2c5777;
+}
+
+.button-8:focus {
+ box-shadow: 0 0 0 4px rgba(0, 149, 255, .15);
+}
+
+.button-8:active {
+ background-color: #a0c7e4;
+ box-shadow: none;
+ color: #2c5777;
+}
+
+.buttonReset{
+ background-color: #f4e1e1;
+}
\ No newline at end of file
diff --git a/Loop edition/index.html b/Loop edition/index.html
new file mode 100644
index 0000000..7d3c373
--- /dev/null
+++ b/Loop edition/index.html
@@ -0,0 +1,58 @@
+
+
+
+
+
+ Document
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/Loop edition/js/helper.js b/Loop edition/js/helper.js
new file mode 100644
index 0000000..646fbee
--- /dev/null
+++ b/Loop edition/js/helper.js
@@ -0,0 +1,360 @@
+async function fetchConfig(className) {
+ // const config = await $.getJSON("config.json");
+ const config = {
+ PolyTwistColourWidth: [
+ { type: "range", min: 3, max: 10, defaultValue: 5, property: "sides" },
+ { type: "range", min: 400, max: 2000, defaultValue: 400, property: "width" },
+ { type: "range", min: 2, max: 5, defaultValue: 5, property: "line_width" },
+ { type: "range", min: 1, max: 100, defaultValue: 50, property: "depth" },
+ { type: "range", min: -180, max: 180, defaultValue: -90, property: "rotation", },
+ { type: "range", min: 1, max: 500, defaultValue: 100, property: "speedMultiplier", },
+ { type: "color", defaultValue: "#4287f5", property: "colour1" },
+ { type: "color", defaultValue: "#42f57b", property: "colour2" },
+ ],
+ FloralPhyllo: [
+ { type: "range", min: 1, max: 600, defaultValue: 300, property: "width" },
+ { type: "range", min: 1, max: 300, defaultValue: 150, property: "depth" },
+ { type: "range", min: 0, max: 3141, defaultValue: 0, property: "start" },
+ { type: "color", defaultValue: "#4287f5", property: "colour1" },
+ { type: "color", defaultValue: "#FC0362", property: "colour2" },
+ ],
+ Spiral1: [
+ { type: "range", min: 1, max: 50, defaultValue: 20, property: "sides" },
+ { type: "range", min: 1, max: 600, defaultValue: 240, property: "width" },
+ { type: "color", defaultValue: "#4287f5", property: "colour" },
+ ],
+ FloralAccident: [
+ { type: "range", min: 1, max: 50, defaultValue: 20, property: "sides" },
+ { type: "range", min: 1, max: 600, defaultValue: 240, property: "width" },
+ { type: "color", defaultValue: "#4287f5", property: "colour" },
+ ],
+ FloralPhyllo_Accident: [
+ { type: "range", min: 1, max: 50, defaultValue: 20, property: "sides" },
+ { type: "range", min: 1, max: 600, defaultValue: 240, property: "width" },
+ { type: "color", defaultValue: "#2D81FC", property: "colour1" },
+ { type: "color", defaultValue: "#FC0362", property: "colour2" },
+ ],
+ Nodal_expanding: [
+ { type: "range", min: 1, max: 100, defaultValue: 5, property: "expand" },
+ { type: "range", min: 1, max: 1000, defaultValue: 150, property: "points" },
+ { type: "range", min: 1, max: 360, defaultValue: 0, property: "start" },
+ { type: "range", min: 1, max: 10, defaultValue: 6, property: "line_width" },
+ { type: "color", defaultValue: "#2D81FC", property: "colour1" },
+ { type: "color", defaultValue: "#FC0362", property: "colour2" },
+ { type: "range", min: 0, max: 10, defaultValue: 5, property: "colour_change" },
+ ],
+ Phyllotaxis: [
+ { type: "range", min: 1, max: 40, defaultValue: 24, property: "width" },
+ { type: "range", min: 0, max: 3141, defaultValue: 0, property: "start" },
+ { type: "range", min: 1, max: 10000, defaultValue: 300, property: "nMax" },
+ { type: "range", min: 0, max: 2, defaultValue: 0, property: "wave" },
+ { type: "color", defaultValue: "#2D81FC", property: "colour1" },
+ { type: "color", defaultValue: "#FC0362", property: "colour2" },
+ ],
+ SquareTwist_angle: [
+ { type: "range", min: 1, max: 800, defaultValue: 400, property: "width" },
+ { type: "range", min: 1, max: 10, defaultValue: 1, property: "line_width" },
+ { type: "color", defaultValue: "#2D81FC", property: "colour1" },
+ ],
+ EyePrototype: [
+ { type: "range", min: -400, max: 400, defaultValue: 0, property: "x" },
+ { type: "range", min: -400, max: 400, defaultValue: 0, property: "y" },
+ { type: "range", min: -180, max: 180, defaultValue: 0, property: "rotate" },
+ { type: "range", min: 0, max: 1, defaultValue: 1, property: "flip" },
+ { type: "range", min: 1, max: 800, defaultValue: 400, property: "width" },
+ { type: "range", min: 1, max: 100, defaultValue: 5, property: "blink_speed" },
+ { type: "range", min: 0, max: 1, defaultValue: 0, property: "draw_spiral" },
+ { type: "range", min: 0, max: 1, defaultValue: 1, property: "spiral_full" },
+ { type: "range", min: 0, max: 1, defaultValue: 0, property: "draw_pupil" },
+ { type: "range", min: 0, max: 1, defaultValue: 0, property: "draw_expand" },
+ { type: "range", min: 0, max: 1, defaultValue: 1, property: "draw_hypno" },
+ { type: "range", min: 1, max: 10, defaultValue: 1, property: "line_width" },
+ { type: "color", defaultValue: "#00fffb", property: "colourPupil" },
+ { type: "color", defaultValue: "#ff0000", property: "colourSpiral" },
+ { type: "color", defaultValue: "#00fffb", property: "colourExpand" },
+ { type: "range", min: 0, max: 1, defaultValue: 1, property: "draw_eyelid" },
+ ],
+ CircleExpand: [
+ { type: "range", min: 1, max: 70, defaultValue: 21, property: "nCircles" },
+ { type: "range", min: 50, max: 150, defaultValue: 150, property: "gap" },
+ { type: "range", min: 0, max: 1, defaultValue: 1, property: "linear" },
+ { type: "range", min: 0, max: 1, defaultValue: 1, property: "heart" },
+ { type: "color", defaultValue: "#fc03cf", property: "colour1" },
+ { type: "color", defaultValue: "#00fffb", property: "colour2" },
+ ],
+ MaryFace: [
+ { type: "range", min: -400, max: 400, defaultValue: -110, property: "x1" },
+ { type: "range", min: -400, max: 400, defaultValue: -140, property: "y1" },
+ { type: "range", min: -180, max: 180, defaultValue: 18, property: "rotate1" },
+ { type: "range", min: 0, max: 400, defaultValue: 160, property: "width1" },
+ { type: "range", min: -400, max: 400, defaultValue: 195, property: "x2" },
+ { type: "range", min: -400, max: 400, defaultValue: -30, property: "y2" },
+ { type: "range", min: -180, max: 180, defaultValue: 18, property: "rotate2" },
+ { type: "range", min: 0, max: 400, defaultValue: 160, property: "width2" },
+ ],
+ };
+ return config[className];
+}
+
+function addControl(item, instance) {
+ console.log(item);
+ let parentDiv = document.getElementById("custom");
+
+ let title = document.createElement("p");
+ title.innerText = item.property + ": " + item.defaultValue;
+ title.id = "elText" + item.property;
+
+ let control = document.createElement("input");
+ control.type = item.type;
+
+ if (item.type === "range") {
+ control.min = item.min;
+ control.max = item.max;
+ }
+
+ control.value = item.defaultValue;
+ control.className = "control";
+ control.id = "el" + item.property;
+
+ const listener = (event) => {
+ const newValue = event.target.value;
+ instance[item.property] =
+ item.type === "range" ? parseInt(newValue, 10) : newValue;
+
+ title.innerText = item.property + ": " + newValue;
+ };
+
+ control.addEventListener("input", listener);
+
+ parentDiv.appendChild(title);
+ parentDiv.appendChild(control);
+
+ return { element: control, listener };
+}
+
+function drawEyelid(width, x1, y1, colour) {
+ x1 -= centerX;
+ y1 -= centerY;
+
+ const angle = Math.atan2(y1, x1);
+ const cosAngle = Math.cos(angle);
+ const sinAngle = Math.sin(angle);
+
+ const x2 = cosAngle * width;
+ const y2 = sinAngle * width;
+
+ const x3Old = width / 2;
+ const y3Old = width / 2;
+ const x4Old = width / 2;
+ const y4Old = -width / 2;
+
+ const x3 = x3Old * cosAngle - y3Old * sinAngle;
+ const y3 = x3Old * sinAngle + y3Old * cosAngle;
+ const x4 = x4Old * cosAngle - y4Old * sinAngle;
+ const y4 = x4Old * sinAngle + y4Old * cosAngle;
+
+ x1 += centerX;
+ y1 += centerY;
+ const x2Final = x2 + x1;
+ const y2Final = y2 + y1;
+ const x3Final = x3 + x1;
+ const y3Final = y3 + y1;
+ const x4Final = x4 + x1;
+ const y4Final = y4 + y1;
+
+ ctx.beginPath();
+ ctx.moveTo(x1, y1);
+ ctx.quadraticCurveTo(x3Final, y3Final, x2Final, y2Final);
+
+ ctx.moveTo(x1, y1);
+ ctx.quadraticCurveTo(x4Final, y4Final, x2Final, y2Final);
+ ctx.fillStyle = colour;
+ ctx.fill();
+
+ ctx.lineWidth = 2;
+ ctx.strokeStyle = "black";
+ ctx.stroke();
+}
+
+function drawEyelidAccident(x1, y1) {
+ let leafWidth = 120;
+ let leafHeight = 60;
+ x1 -= centerX;
+ y1 -= centerY;
+ let angle = Math.atan(y1 / x1);
+ // if(angle >=Math.PI){
+ // angle -=Math.PI
+ // console.log("greater called")
+ // }
+ angle = Math.abs(angle);
+ let x2Old = 0 + leafWidth;
+ let y2Old = 0;
+
+ let x3Old = 0 + leafWidth / 2;
+ let y3Old = 0 + leafHeight / 2;
+
+ let x4Old = 0 + leafWidth / 2;
+ let y4Old = 0 - leafHeight / 2;
+
+ let x2 = x2Old * Math.cos(angle) - y2Old * Math.sin(angle);
+ let y2 = x2Old * Math.sin(angle) + y2Old * Math.cos(angle);
+
+ let x3 = x3Old * Math.cos(angle) - y3Old * Math.sin(angle);
+ let y3 = x3Old * Math.sin(angle) + y3Old * Math.cos(angle);
+
+ let x4 = x4Old * Math.cos(angle) - y4Old * Math.sin(angle);
+ let y4 = x4Old * Math.sin(angle) + y4Old * Math.cos(angle);
+
+ let oldx1 = x1;
+ let oldy1 = y1;
+
+ x1 += centerX; // +x2/2
+ y1 += centerY; // +x2/2
+ x2 += x1;
+ y2 += y1;
+ x3 += x1;
+ y3 += y1;
+ x4 += x1;
+ y4 += y1;
+ ctx.beginPath();
+ ctx.moveTo(x1, y1);
+ ctx.quadraticCurveTo(x3, y3, x2, y2);
+
+ ctx.moveTo(x1, y1);
+ ctx.quadraticCurveTo(x4, y4, x2, y2);
+ ctx.fillStyle = "black";
+ ctx.fill();
+
+ ctx.lineWidth = 1;
+ ctx.beginPath();
+ ctx.moveTo(x1, y1);
+ ctx.quadraticCurveTo(x3, y3, x2, y2);
+
+ ctx.moveTo(x1, y1);
+ ctx.quadraticCurveTo(x4, y4, x2, y2);
+ ctx.strokeStyle = "orange";
+ ctx.stroke();
+}
+
+function DrawPolygon(sides, width, rotation, colour, line_width) {
+ ctx.beginPath();
+ ctx.moveTo(
+ centerX + width * Math.cos((rotation * Math.PI) / 180),
+ centerY + width * Math.sin((rotation * Math.PI) / 180)
+ );
+
+ for (var i = 1; i <= sides; i += 1) {
+ ctx.lineTo(
+ centerX +
+ width *
+ Math.cos((i * 2 * Math.PI) / sides + (rotation * Math.PI) / 180),
+ centerY +
+ width * Math.sin((i * 2 * Math.PI) / sides + (rotation * Math.PI) / 180)
+ );
+ }
+ ctx.strokeStyle = colour;
+ ctx.lineWidth = line_width;
+ ctx.stroke();
+}
+
+function rad(degrees) {
+ return (degrees * Math.PI) / 180;
+}
+
+function colourToText(colour) {
+ return "rgb(" + colour[0] + "," + colour[1] + "," + colour[2] + ")";
+}
+
+
+function waveNormal(x, max) {
+ let val = Math.sin((x / max) * Math.PI * 2 - max * (Math.PI / (max * 2))) / 2 + 0.5
+ return val
+}
+
+function LerpHex(a, b, amount) {
+ var ah = parseInt(a.replace(/#/g, ""), 16),
+ ar = ah >> 16,
+ ag = (ah >> 8) & 0xff,
+ ab = ah & 0xff,
+ bh = parseInt(b.replace(/#/g, ""), 16),
+ br = bh >> 16,
+ bg = (bh >> 8) & 0xff,
+ bb = bh & 0xff,
+ rr = ar + amount * (br - ar),
+ rg = ag + amount * (bg - ag),
+ rb = ab + amount * (bb - ab);
+
+ return (
+ "#" + (((1 << 24) + (rr << 16) + (rg << 8) + rb) | 0).toString(16).slice(1)
+ );
+}
+
+function LerpRGB(a, b, t) {
+ if (t < 0) {
+ t *= -1;
+ }
+ var newColor = [0, 0, 0];
+ newColor[0] = a[0] + (b[0] - a[0]) * t;
+ newColor[1] = a[1] + (b[1] - a[1]) * t;
+ newColor[2] = a[2] + (b[2] - a[2]) * t;
+ return newColor;
+}
+
+function lerpRGB(a, b, t) {
+ const result = [0, 0, 0];
+ for (let i = 0; i < 3; i++) {
+ result[i] = (1 - t) * a[i] + t * b[i];
+ }
+ return result;
+}
+
+
+function drawCenter(width) {
+ console.log("center?")
+ ctx.strokeStyle = "pink";
+ ctx.lineWidth = 1
+ ctx.beginPath();
+ ctx.moveTo(centerX - width, centerY);
+ ctx.lineTo(centerX + width, centerY);
+ ctx.closePath();
+ ctx.stroke();
+ ctx.beginPath();
+ ctx.moveTo(centerX, centerY - width);
+ ctx.lineTo(centerX, centerY + width);
+ ctx.closePath();
+ ctx.stroke();
+}
+
+function render_clear() {
+ ctx.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height);
+ ctx.fillStyle = "black";
+ ctx.fillRect(0, 0, ctx.canvas.width, ctx.canvas.height);
+}
+
+function rotatePointTmp(x, y, centerXX, centerYY, rotation) {
+ let xFromC = x - centerXX;
+ let yFromC = y - centerYY;
+ let d = (xFromC ** 2 + yFromC ** 2) ** 0.5
+ // let orgAngle = Math.atan2(yFromC/xFromC)
+ let orgAngle = Math.atan2(xFromC, yFromC)
+ let tmp = Math.cos(rad(orgAngle - rotation)) * d
+ // console.log(Math.cos((-90)*(Math.PI/180)))
+ console.log(orgAngle)
+ console.log(rad(rotation))
+ console.log(Math.cos(orgAngle - rad(rotation)) * d)
+ console.log(d)
+ // console.log(d)
+ let newPointX = Math.cos(orgAngle - rad(rotation+90)) * d + centerXX;
+ let newPointY = Math.sin(orgAngle - rad(rotation+90)) * d + centerYY;
+ return [newPointX, newPointY]
+}
+
+function rotatePoint(x,y,rotation){
+ let nCos = Math.cos(rad(rotation))
+ // console.log(nCos*(180/Math.PI))
+ // console.log(rad(rotation))
+ let nSin = Math.sin(rad(rotation))
+ let newX = x*nCos - y*nSin
+ let newY = y*nCos + x*nSin
+ return [newX,newY]
+}
\ No newline at end of file
diff --git a/Loop edition/js/index.js b/Loop edition/js/index.js
new file mode 100644
index 0000000..583b417
--- /dev/null
+++ b/Loop edition/js/index.js
@@ -0,0 +1,144 @@
+//jshint esversion:8
+let c = document.getElementById("myCanvas");
+let ctx = c.getContext("2d");
+ctx.canvas.width = window.innerWidth;
+ctx.canvas.height = window.innerHeight;
+centerX = ctx.canvas.width / 2;
+centerY = ctx.canvas.height / 2;
+
+
+let deg_per_sec = 10;
+let targetFps = 60;
+let frameDuration = 1000 / targetFps;
+
+let rotation = 0; //was = j = angle
+let paused = true;
+render_clear();
+
+let drawObj = null;
+function createInstance(className, args) {
+ const classMap = {
+ PolyTwistColourWidth: PolyTwistColourWidth,
+ FloralPhyllo: FloralPhyllo,
+ Spiral1: Spiral1,
+ FloralAccident: FloralAccident,
+ FloralPhyllo_Accident: FloralPhyllo_Accident,
+ Nodal_expanding: Nodal_expanding,
+ Phyllotaxis:Phyllotaxis,
+ SquareTwist_angle:SquareTwist_angle,
+ EyePrototype:EyePrototype,
+ CircleExpand:CircleExpand,
+ MaryFace:MaryFace,
+ // Add more class constructors here as needed
+ };
+
+ if (classMap.hasOwnProperty(className)) {
+ return new classMap[className](...args);
+ } else {
+ throw new Error(`Unknown class name: ${className}`);
+ }
+}
+
+
+
+async function updateDrawObj() {
+ const shapeSelector = document.getElementById("shape-selector");
+ const selectedShape = shapeSelector.value;
+ const config = await fetchConfig(selectedShape);
+ if (drawObj) {
+ drawObj.remove(); // Remove the previous instance
+ }
+ // Extract default values from the configuration
+ const defaultValues = config
+ // .filter((item) => item.type !== "color") // Exclude color inputs
+ .map((item) => item.defaultValue);
+
+ drawObj = createInstance(selectedShape, defaultValues);
+
+ // drawObj = await createShapeWithRandomProperties(813311281, config1);
+ console.log(drawObj)
+ drawObj.initialise(config);
+}
+
+updateDrawObj();
+
+function render() {
+ setTimeout(() => {
+ requestAnimationFrame(() => {
+ render_clear();
+ if (drawObj) {
+ drawObj.draw(rotation);
+ }
+
+ if (!paused) {
+ rotation += deg_per_sec / targetFps;
+ }
+ // drawCenter(300)
+ });
+ render();
+ }, frameDuration);
+}
+
+document
+ .getElementById("shape-selector")
+ .addEventListener("change", updateDrawObj);
+
+let toolbarShowing = true;
+document.addEventListener("keydown", toggleSettings);
+
+function manualToggleSettings(){
+ console.log("hi")
+ toolbarShowing = !toolbarShowing;
+ let tb = document.getElementById("toolbar");
+ if (toolbarShowing) {
+ tb.style.display = "flex";
+ } else {
+ tb.style.display = "none";
+ }
+}
+
+function toggleSettings(e) {
+ if (e.key == "p") {
+ toolbarShowing = !toolbarShowing;
+ }
+ if (e.code === "Space") {
+ paused = !paused;
+ }
+
+ let tb = document.getElementById("toolbar");
+ if (toolbarShowing) {
+ tb.style.display = "flex";
+ } else {
+ tb.style.display = "none";
+ }
+}
+
+function TogglePause() {
+ let pb = document.getElementById("pauseButton");
+ paused = !paused;
+
+ if (paused) {
+ pb.textContent = "Play";
+ } else {
+ pb.textContent = "Pause";
+ }
+}
+function Reset() {
+ rotation = 0; //was = j = angle
+ currentFrame = 0;
+}
+
+function ForwardFrame() {
+ rotation += deg_per_sec / fps; // was = j = innerRotation, now = rotation
+ currentFrame += 1; // was = i
+}
+function BackwardFrame() {
+ rotation -= deg_per_sec / fps; // was = j = innerRotation, now = rotation
+ currentFrame -= 1; // was = i
+}
+
+function ChangeDegPerSec(newValue) {
+ deg_per_sec = newValue;
+}
+
+window.onload = render;
diff --git a/Loop edition/js/math.js b/Loop edition/js/math.js
new file mode 100644
index 0000000..f9eeea3
--- /dev/null
+++ b/Loop edition/js/math.js
@@ -0,0 +1,77 @@
+function rotateMatrix2d(p, angle) {
+ // cos0 sin0
+ // -sin0 cos0
+ const angleD = rad(angle);
+ const r = [
+ [Math.cos(angleD), Math.sin(angleD)],
+ [-Math.sin(angleD), Math.cos(angleD)],
+ ];
+ const newPoint = [
+ p[0] * r[0][0] + p[1] * r[0][1],
+ p[0] * r[1][0] + p[1] * r[1][1],
+ ];
+ return newPoint;
+}
+
+function rotateMatrix3dX(p, angle) {
+ // cos0 sin0
+ // -sin0 cos0
+ const angleD = rad(angle);
+ const r = [
+ [1, 0, 0],
+ [0, Math.cos(angleD), -Math.sin(angleD)],
+ [0, Math.sin(angleD), Math.cos(angleD)],
+ ];
+ const newPoint = [
+ p[0] * r[0][0] + p[1] * r[0][1] + p[2] * r[0][2],
+ p[0] * r[1][0] + p[1] * r[1][1] + p[2] * r[1][2],
+ p[0] * r[2][0] + p[1] * r[2][1] + p[2] * r[2][2],
+ ];
+ return newPoint;
+}
+
+function rotateMatrix3dY(p, angle) {
+ // cos0 sin0
+ // -sin0 cos0
+ const angleD = rad(angle);
+ const r = [
+ [Math.cos(angleD), 0, Math.sin(angleD)],
+ [0, 1, 0],
+ [-Math.sin(angleD), 0, Math.cos(angleD)],
+ ];
+ const newPoint = [
+ p[0] * r[0][0] + p[1] * r[0][1] + p[2] * r[0][2],
+ p[0] * r[1][0] + p[1] * r[1][1] + p[2] * r[1][2],
+ p[0] * r[2][0] + p[1] * r[2][1] + p[2] * r[2][2],
+ ];
+ return newPoint;
+}
+function rotateMatrix3dZ(p, angle) {
+ // cos0 sin0
+ // -sin0 cos0
+ const angleD = rad(angle);
+ const r = [
+ [Math.cos(angleD), -Math.sin(angleD), 0],
+ [Math.sin(angleD), Math.cos(angleD), 0],
+ [0, 0, 1],
+ ];
+ const newPoint = [
+ p[0] * r[0][0] + p[1] * r[0][1] + p[2] * r[0][2],
+ p[0] * r[1][0] + p[1] * r[1][1] + p[2] * r[1][2],
+ p[0] * r[2][0] + p[1] * r[2][1] + p[2] * r[2][2],
+ ];
+ return newPoint;
+}
+
+function projectionOrth(v) {
+ const p = [
+ [1, 0, 0],
+ [0, 1, 0],
+ ];
+
+ const nPoint = [
+ p[0][0] * v[0] + p[0][1] * v[1] + p[0][2] * v[2],
+ p[1][0] * v[0] + p[1][1] * v[1] + p[1][2] * v[2],
+ ];
+ return nPoint;
+}
diff --git a/Loop edition/js/objects.js b/Loop edition/js/objects.js
new file mode 100644
index 0000000..e73b638
--- /dev/null
+++ b/Loop edition/js/objects.js
@@ -0,0 +1,637 @@
+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, start, colour1, colour2) {
+ super();
+ this.width = width;
+ this.depth = depth;
+ this.start = start;
+ this.colour1 = colour1;
+ this.colour2 = colour2;
+ this.speedMultiplier = 500;
+ }
+
+ draw(rotation) {
+ rotation *= (this.speedMultiplier / 500)
+ rotation += this.start
+ // 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 = this.depth; n > 0; n -= 1) {
+ let colVal = waveNormal(n, this.depth)
+ let ncolour = LerpHex(this.colour1, this.colour2, n / this.depth);
+ 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, start, line_width, colour1, colour2, colour_change) {
+ super();
+ this.expand = expand;
+ this.points = points;
+ this.start = start;
+ this.line_width = line_width;
+ this.colour1 = colour1;
+ this.colour2 = colour2;
+ this.colour_change = colour_change
+ }
+
+ draw(rotation) {
+ rotation *= (this.speedMultiplier / 1000)
+ var angle = (360 / 3000 * rotation) + this.start //2000 controls speed
+
+ var length = this.expand;
+
+ for (let z = 1; z <= this.points; z++) { //why specifically 2500
+ ctx.beginPath();
+ let ncolour = LerpHex(this.colour1, this.colour2, z / this.points);
+
+ 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 Phyllotaxis extends BaseShape {
+ constructor(width, start, nMax, wave, colour1, colour2) {
+ super();
+ this.width = width;
+ this.start = start;
+ this.nMax = nMax;
+ this.wave = wave;
+ this.colour1 = colour1;
+ this.colour2 = colour2;
+ }
+ drawWave(angle) {
+ angle /= 1000
+ const startColor = [45, 129, 252];
+ const endColor = [252, 3, 98];
+ const distanceMultiplier = 3;
+ const maxIterations = 200;
+ // angle=0;
+ for (let n = 0; n < maxIterations; n++) {
+ ctx.beginPath();
+ const nColor = lerpRGB(startColor, endColor, Math.cos(rad(n / 2)));
+
+ // const nAngle = n* angle ;
+ // const nAngle = n*angle+ Math.sin(rad(n*1+angle*4000))/1 ;
+ const nAngle = n * angle + Math.sin(rad(n * 1 + angle * 40000)) / 2;
+ const radius = distanceMultiplier * n;
+ const xCoord = radius * Math.cos(nAngle) + centerX;
+ const yCoord = radius * Math.sin(nAngle) + centerY;
+ ctx.arc(xCoord, yCoord, 8, 0, 2 * Math.PI);
+ ctx.fillStyle = colourToText(nColor);
+ ctx.fill();
+ }
+ }
+ drawSpiral(angle) {
+ angle /= 5000
+ const startColor = [45, 129, 252];
+ const endColor = [252, 3, 98];
+ const distanceMultiplier = 2;
+ const maxIterations = 1000;
+
+
+ for (let n = 0; n < maxIterations; n++) {
+ const nColor = lerpRGB(startColor, endColor, Math.cos(rad(n / 2)));
+
+ const nAngle = n * angle + Math.sin(angle * n * 2);
+ const radius = distanceMultiplier * n;
+ const xCoord = radius * Math.cos(nAngle) + centerX;
+ const yCoord = radius * Math.sin(nAngle) + centerY;
+
+ ctx.beginPath();
+ ctx.arc(xCoord, yCoord, 8, 0, 2 * Math.PI);
+ ctx.fillStyle = colourToText(nColor);
+ ctx.fill();
+ }
+ }
+
+ // Draw_nodal(300, 100, 31, rotation, "blue");
+ draw(rotation) {
+ rotation *= (this.speedMultiplier / 300)
+ rotation += this.start
+ const sizeMultiplier = this.nMax/(5-3)
+ if (this.wave === 1) {
+ this.drawWave(rotation)
+ }
+ else if (this.wave === 2) {
+ this.drawSpiral(rotation)
+ }
+ else {
+ 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, (n/sizeMultiplier)+3, 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 CircleExpand extends BaseShape {
+ constructor(nCircles, gap, linear, heart, colour1, colour2) {
+ super();
+ this.nCircles = nCircles;
+ this.gap = gap;
+ this.linear = linear;
+ this.heart = heart;
+ this.colour1 = colour1;
+ this.colour2 = colour2
+ }
+ lerpColor(a, b, amount) {
+ var ah = +a.replace('#', '0x'),
+ ar = ah >> 16, ag = ah >> 8 & 0xff, ab = ah & 0xff,
+ bh = +b.replace('#', '0x'),
+ br = bh >> 16, bg = bh >> 8 & 0xff, bb = bh & 0xff,
+ rr = ar + amount * (br - ar),
+ rg = ag + amount * (bg - ag),
+ rb = ab + amount * (bb - ab);
+
+ return '#' + ((1 << 24) + (rr << 16) + (rg << 8) + rb | 0).toString(16).slice(1);
+ }
+
+ arraySort(x, y) {
+ if (x.r > y.r) {
+ return 1;
+ }
+ if (x.r < y.r) {
+ return -1;
+ }
+ return 0;
+ }
+ drawHeart(w, colour) {
+ // var w = 200
+ ctx.strokeStyle = "black";
+ ctx.fillStyle = colour;
+ ctx.lineWidth = 1;
+ var x = centerX - w / 2;
+ let y = centerY - w / 2
+ ctx.beginPath();
+ ctx.moveTo(x, y + w / 4);
+ ctx.quadraticCurveTo(x, y, x + w / 4, y);
+ ctx.quadraticCurveTo(x + w / 2, y, x + w / 2, y + w / 5);
+ ctx.quadraticCurveTo(x + w / 2, y, x + w * 3 / 4, y);
+ ctx.quadraticCurveTo(x + w, y, x + w, y + w / 4);
+ ctx.quadraticCurveTo(x + w, y + w / 2, x + w * 3 / 4, y + w * 3 / 4);
+ ctx.lineTo(x + w / 2, y + w);
+ ctx.lineTo(x + w / 4, y + w * 3 / 4);
+ ctx.quadraticCurveTo(x, y + w / 2, x, y + w / 4);
+ ctx.stroke();
+ ctx.fill();
+ }
+
+ draw(rotation) {
+ rotation *= (0.9)
+ ctx.strokeWeight = 1;
+ ctx.lineWidth = 1;
+ let arrOfWidths = []
+ let arrOfco = []
+ let intRot;
+ if (this.linear) {
+ intRot = Math.floor(rotation * 30) / 100
+ }
+ else {
+ intRot = Math.sin(rad(Math.floor(rotation * 30) / 4)) + rotation / 4
+ }
+
+ for (let i = 0; i < this.nCircles; i++) {
+ const width = this.gap * ((intRot + i) % this.nCircles);
+ const colour = (Math.sin(rad(i * (360 / this.nCircles) - 90)) + 1) / 2
+ arrOfWidths.push({ r: width, c: colour });
+ }
+
+ let newArr = arrOfWidths.sort(this.arraySort)
+
+ for (let i = this.nCircles - 1; i >= 0; i--) {
+ let newColour = this.lerpColor(this.colour1, this.colour2, newArr[i].c)
+
+ if (this.heart) {
+ this.drawHeart(newArr[i].r, newColour)
+ }
+ else {
+ ctx.beginPath();
+ ctx.arc(centerX, centerY, newArr[i].r, 0, 2 * Math.PI);
+ ctx.fillStyle = newColour;
+ ctx.fill();
+ ctx.stokeStyle = "black";
+ ctx.stroke();
+
+ }
+ }
+
+ }
+}
+
+
+class EyePrototype extends BaseShape {
+ constructor(x, y, rotate, flip, width, blink_speed, draw_spiral, spiral_full, draw_pupil, draw_expand, draw_hypno, line_width, colourPupil, colourSpiral, colourExpand) {
+ super();
+ this.x = x;
+ this.y = y;
+ this.rotate = rotate;
+ this.flip = flip
+ this.width = width;
+ this.blink_speed = blink_speed;
+ this.line_width = line_width;
+ this.step = 0;
+ this.opening = true;
+ this.counter = 0;
+ this.cooldown = 0;
+ this.draw_spiral = draw_spiral;
+ this.spiral_full = spiral_full;
+ this.draw_pupil = draw_pupil;
+ this.draw_expand = draw_expand;
+ this.draw_hypno = draw_hypno;
+ this.colourPupil = colourPupil;
+ this.colourSpiral = colourSpiral;
+ this.colourExpand = colourExpand;
+ this.centerPulse = new CircleExpand(10, 30, 1, 0, "#2D81FC", "#FC0362")
+ }
+ drawEyelid(rotation) {
+ ctx.strokeStyle = "orange";
+ let relCenterX = centerX + this.x;
+ let relCenterY = centerY + this.y;
+ rotation *= (this.speedMultiplier / 100)
+ ctx.lineWidth = 1;
+ ctx.beginPath();
+ let newPoint = 0
+ let newPoint1 = 0
+ let addedRotate = this.flip ? 90 : 0
+ newPoint = rotatePoint(- this.width / 2, 0, this.rotate + addedRotate)
+ ctx.moveTo(relCenterX + newPoint[0], relCenterY + newPoint[1]);
+ newPoint = rotatePoint(0, - rotation / 400 * this.width, this.rotate + addedRotate)
+ newPoint1 = rotatePoint(this.width / 2, 0, this.rotate + addedRotate)
+ ctx.quadraticCurveTo(relCenterX + newPoint[0], relCenterY + newPoint[1], relCenterX + newPoint1[0], relCenterY + newPoint1[1]);
+
+ newPoint = rotatePoint(- this.width / 2, 0, this.rotate + addedRotate)
+ ctx.moveTo(relCenterX + newPoint[0], relCenterY + newPoint[1]);
+ newPoint = rotatePoint(0, + rotation / 400 * this.width, this.rotate + addedRotate)
+ newPoint1 = rotatePoint(this.width / 2, 0, this.rotate + addedRotate)
+ ctx.quadraticCurveTo(relCenterX + newPoint[0], relCenterY + newPoint[1], relCenterX + newPoint1[0], relCenterY + newPoint1[1]);
+ ctx.stroke();
+ }
+ eyelidCut(rotation) {
+ let relCenterX = centerX + this.x;
+ let relCenterY = centerY + this.y;
+ let newPoint = 0
+ let newPoint1 = 0
+ let addedRotate = this.flip ? 90 : 0
+ // ctx.lineWidth = 1;
+ let squarePath = new Path2D();
+ newPoint = rotatePoint(- this.width / 2, 0, this.rotate + addedRotate)
+ squarePath.moveTo(relCenterX + newPoint[0], relCenterY + newPoint[1]);
+ newPoint = rotatePoint(0, - rotation / 400 * this.width, this.rotate + addedRotate)
+ newPoint1 = rotatePoint(this.width / 2, 0, this.rotate + addedRotate)
+ squarePath.quadraticCurveTo(relCenterX + newPoint[0], relCenterY + newPoint[1], relCenterX + newPoint1[0], relCenterY + newPoint1[1]);
+
+ newPoint = rotatePoint(- this.width / 2, 0, this.rotate + addedRotate)
+ squarePath.moveTo(relCenterX + newPoint[0], relCenterY + newPoint[1]);
+ newPoint = rotatePoint(0, + rotation / 400 * this.width, this.rotate + addedRotate)
+ newPoint1 = rotatePoint(this.width / 2, 0, this.rotate + addedRotate)
+ squarePath.quadraticCurveTo(relCenterX + newPoint[0], relCenterY + newPoint[1], relCenterX + newPoint1[0], relCenterY + newPoint1[1]);
+
+ ctx.clip(squarePath);
+ }
+ drawGrowEye(step) {
+ // console.log(step)
+ ctx.strokeStyle = this.colourExpand
+ ctx.beginPath();
+ ctx.lineWidth = 5;
+ ctx.arc(centerX + this.x, centerY + this.y, step, 0, 2 * Math.PI);
+ ctx.stroke();
+ }
+ drawCircle(step) {
+ ctx.strokeStyle = this.colourPupil
+ ctx.beginPath();
+ ctx.lineWidth = 5;
+ ctx.arc(centerX + this.x, centerY + this.y, step, 0, 2 * Math.PI);
+ ctx.stroke();
+ }
+
+ drawSpiral(step) {
+ ctx.strokeStyle = this.colourSpiral;
+ let a = 1
+ let b = 5
+ ctx.moveTo(centerX, centerY);
+ ctx.beginPath();
+ let max = this.spiral_full ? this.width : this.width / 2
+ for (let i = 0; i < max; 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 + this.x, y + this.y);
+ }
+ ctx.lineWidth = 3;
+ 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.blink_speed;
+ } else {
+ this.step += this.blink_speed;
+ }
+ } else {
+ if (this.step <= 0) {
+ this.opening = true;
+ this.step += this.blink_speed;
+ } else {
+ this.step -= this.blink_speed;
+ }
+ }
+ }
+ }
+
+ draw(rotation) {
+ let speedMult = 50
+ console.log(this.blink_speed)
+ let waitTime = this.blink_speed
+ 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)
+
+ ctx.fillStyle = "black";
+ ctx.save();
+ this.drawEyelid(outputRotation);
+ // squareCut();
+ this.eyelidCut(outputRotation);
+ // console.log(Math.floor(this.counter % this.width / 2))
+ if (Math.floor(this.counter % (this.width / 4)) === 0) {
+ this.counter = 0;
+ }
+ ctx.fillStyle = "black";
+ ctx.fillRect(this.x - this.width / 2 + centerX, 0, this.width, ctx.canvas.height);
+ if (this.draw_expand) {
+ this.drawGrowEye(this.width / 4 + this.counter);
+ }
+
+ if (this.draw_hypno) {
+ this.centerPulse.draw(rotation)
+ }
+ if (this.draw_spiral) {
+ this.drawSpiral(rotation)
+ }
+ if (this.draw_pupil) {
+ this.drawCircle(this.width / 4);
+ }
+
+ ctx.restore();
+
+ this.stepFunc();
+ this.counter++;
+ }
+}
+class MaryFace extends BaseShape {
+ constructor(x1, y1, rotate1, width1, x2, y2, rotate2, width2) {
+ super();
+ this.x1 = x1;
+ this.y1 = y1;
+ this.rotate1 = rotate1;
+ this.width1 = width1;
+ this.x2 = x2;
+ this.y2 = y2;
+ this.rotate2 = rotate2;
+ this.width2 = width2;
+ this.eye1 = new EyePrototype(x1, y1, rotate1, 0, width1, 10, 1, 1, 0, 0, 0, 1, "#00fffb", "#00fffb", "#00fffb")
+ this.eye2 = new EyePrototype(x2, y2, rotate2, 0, width2, 10, 1, 1, 0, 0, 0, 1, "#00fffb", "#00fffb", "#00fffb")
+ // this.eye3 = new EyePrototype(112, -280, rotate2+2,1, width2, 10, 1, 1, 0, 0, 1, "#00fffb", "#00fffb", "#00fffb")
+ this.eye3 = new EyePrototype(110, -280, rotate2 + 2, 1, width2, 10, 1, 1, 0, 0, 0, 1, "#00fffb", "#00fffb", "#00fffb")//maybe
+ }
+
+ draw(rotation) {
+ let img = new Image();
+ img.src = "maryFace.png";
+
+ ctx.drawImage(img, centerX - img.width / 2, centerY - img.height / 2);
+ this.eye1.draw(rotation);
+ this.eye2.draw(rotation);
+ this.eye3.draw(rotation);
+ }
+}
+
diff --git a/Loop edition/maryFace - Copy.png b/Loop edition/maryFace - Copy.png
new file mode 100644
index 0000000..969ade0
Binary files /dev/null and b/Loop edition/maryFace - Copy.png differ
diff --git a/Loop edition/maryFace.png b/Loop edition/maryFace.png
new file mode 100644
index 0000000..a3f6a05
Binary files /dev/null and b/Loop edition/maryFace.png differ