​

/*

FEUHUIWFH EWUI IUWFUIWEH FIEW FH

I DONT KNOW HOW TO TURN DOWN THE VOLUME

​

*/

​

let pendulums = [];

let VOLUME = 0.0005;

​

let STOPMUSIC = false;

​

const NUM_PENDULUMS = 3;

const GRAVITY = 0.5;

​

const freqs = [300, 200, 100, 400, 600, 500, 700]; // [110, 440, 523.25, 659.25, 880, 1108.73, 1320]; // Harmonious frequencies (C major scale, kinda)

​

const lengths = [1000, 250, 62.5]; // Different lengths for variety

​

const ANNAMODS = [1, -2, 2, -3, 4, -5];

const ATTEMP23424 = [0, 4, 1, -3, 4, 1, -3];

​

/*

>>> sum([0, -5, 5, 5, -5, -5, 5, -3, 5, 5, 5, 2, 5, -3, 5, 5, 5, 5, 5, 2, 5, -5, 5])

48

*/

​

const ATTEMPT_AT_LIEBE_STRAUMUWU = [

  0,

  -5,

  5,

  5,

  -5,

  -5,

  5,

  -3,

  5,

  5,

  5,

  2,

  5,

  -3,

  5,

  -7,

  5,

  5,

  -7,

  2,

  5,

  -5,

  5,

  -24,

];

​

const THE_MODS = ATTEMPT_AT_LIEBE_STRAUMUWU;

​

let angles;

​

let fft;

let noteQueue = [];

​

let current_modulation = 0;

let curr_mod_index = 0;

​

let oscillators = [];

let envelopes = [];

const OSCILLATOR_POOL_SIZE = NUM_PENDULUMS; // Number of oscillators in the pool

​

let continuousOsc;

​

let baseFreq = freqs[1]; // Base frequency for the continuous oscillator

let globalSemitoneShift = 0; // Global semitone shift for modulation

​

const FFT_SMOOTHING = 0.8; // Adjust between 0.0 and 1.0

const FFT_BINS = 16; // Must be a power of two between 16 and 1024

​

let crossingCount = 0;

// WE WILL CALCULATE THIS !!! total_swings()

var MODULATION_THRESHOLD = NUM_PENDULUMS * 2; // Number of crossings to trigger modulation

​

let theShader;

let spectrum = new Array(16).fill(0); // Placeholder for FFT data

​

let startTime;

var randomFontUsed;

​

function preload() {

  theShader = loadShader("vertex.vert", "fragment.frag");

  randomFontUsed = loadFont("randomfont.ttf");

}

​

let angleX = 90;

let angleY = 0;

let distance = 200;

var pause = false;

​

function lcm(a, b) {

  return a * b; // gcd(a, b)

}

​

function total_swings(frequencies) {

  return frequencies.reduce(lcm);

}

​

let cameraX;

let cameraY;

let cameraZ;

var startedAudio = false;

​

function setup() {

  createCanvas(windowWidth, windowHeight, WEBGL);

​

  startTime = millis();

  background(0);

  print(total_swings(freqs));

​

  textAlign(CENTER);

  textFont(randomFontUsed);

  textSize(50);

​

  for (var i = 0; i < lengths.length; i++) {

    lengths[i] = ((lengths[i] / 300) * height) / 1.7;

  }

​

  frameRate(60);

  _renderer.GL.disable(_renderer.GL.DEPTH_TEST);

​

  theShader.setUniform("canasWidth", width);

  theShader.setUniform("height", height);

​

  angles = [PI / 4, PI / 6, PI / 8, PI / 10, PI / 12, PI / 14]; // Different starting angles

​

  const C_FREQUENCIES = [261.63, 329.63, 392.0]; // Frequencies for C4, E4, G4

  const NUM_OCTAVES = 2; // You can change this to add more octaves

  const START_DELAY = 12;

  let arpeggioFreqs = [];

  for (let octave = 0; octave < NUM_OCTAVES; octave++) {

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

      arpeggioFreqs.push(C_FREQUENCIES[i] * Math.pow(2, octave));

    }

  }

//   for (let i = 0; i < NUM_PENDULUMS; i++) {

//     let frequency = arpeggioFreqs[i % arpeggioFreqs.length];

//     let length = lengths[i % lengths.length];

//     let angle = -0.5 + i / NUM_PENDULUMS;

//     let startAfter = i * START_DELAY; // Define START_DELAY as a constant for delay between pendulums

//     pendulums.push(new Pendulum(length, angle, frequency, startAfter));

//   }

​

//   for (let i = 0; i < NUM_PENDULUMS; i++) {

//     let frequency = arpeggioFreqs[i % arpeggioFreqs.length];

//     let length = 700; //lengths[i % lengths.length];

//     let angle = 0.5 + i / NUM_PENDULUMS;

//     let startAfter = i * START_DELAY;

//     pendulums.push(new Pendulum(length, angle, frequency, startAfter));

//   }

  pendulums.push(new Pendulum(1000, 1, 100, 10))

  pendulums.push(new Pendulum(250, 1, 200, 10))

  pendulums.push(new Pendulum(250, 1, 200, 10))

  pendulums.push(new Pendulum(62.5, 1, 300, 10))

  pendulums.push(new Pendulum(15.625, 1, 100, 10))

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

    let osc = new p5.Oscillator("triangle");

    let env = new p5.Envelope();

    env.setADSR(0.1, 0.5, 0.1, 0.4);

    env.setRange(VOLUME, 0);

    osc.start();

    osc.amp(VOLUME * .125);

    oscillators.push(osc);

    envelopes.push(env);

  }

​

  // Adjust the distance to simulate zooming in and out

  // distance = constrain(distance + random(-1, 1), 50, 400);

​

  cameraX = distance * cos(radians(angleX)) * cos(radians(angleY));

  cameraY = distance * cos(radians(angleX)) * sin(radians(angleY));

  cameraZ = distance * 4; // in(radians(angleX));

​

  camera(cameraX, cameraY, cameraZ, 0, 0, 0, 0, 1, 0);

​

  continuousOsc = new p5.Oscillator("triangle");

  continuousOsc.freq(freqs[1]); // Set to a base frequency, like A4 (440 Hz)

  continuousOsc.amp(VOLUME * 0.00125); // Set a moderate amplitude

  continuousOsc.start();

​

  fft = new p5.FFT(FFT_SMOOTHING, FFT_BINS);

}

​

function modulateContinuousOsc(mod_dir) {

  if (!STOPMUSIC){

    globalSemitoneShift += mod_dir;

    let newFreq = baseFreq * Math.pow(2, globalSemitoneShift / 12);

    continuousOsc.freq(newFreq);

  } 

}

function keyPressed(){

  if (key == 'm') {

    STOPMUSIC = !STOPMUSIC

    if (STOPMUSIC){

      print("Muted")

      continuousOsc.stop();

    } else {

      print("Unmuted")

      continuousOsc.start();

    }

  }

}

​

function mouseClicked() {

  if (!startedAudio) {

    userStartAudio();

    startedAudio = true;

    return;

  }

  if (

    mouseX < 20 ||

    mouseX > width - 20 ||

    mouseY < 20 ||

    mouseY > height - 20

  ) {

    return;

  }

  pause = !pause;

  if (!pause) {

    loop();

  } else {

    noLoop();

  }

}

​

function mouseWheel(event) {

  cameraZ += event.delta;

  camera(cameraX, cameraY, cameraZ, 0, 0, 0, 0, 1, 0);

}

​

function draw() {

  background(color("rgba(141,103,248,0.36)"));

​

  // translate(-width / 2, -height / 2); // Adjust for WebGL coordinate system

​

  theShader.setUniform("u_resolution", [width, height]);

  theShader.setUniform("u_time", millis() / 10000.0);

  theShader.setUniform("u_fcking_CamerAZ", float(cameraZ));

  theShader.setUniform("u_repetitions", 1 + noise(millis() / 4235) * 5);

​

  spectrum = fft.analyze();

​

  // Pass normalized FFT data to shader

  // Calculate and pass vec2 for each bin

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

    let binValue = spectrum[i] / 255.0; // Normalize FFT value

​

    let heightValue = map(spectrum[i], 0, 255, 1, 0); // Map to a range, for example, 0 to 1

​

    theShader.setUniform(`bin${i}`, [binValue / 0.999, heightValue / 0.999]);

​

    // print(binValue.toFixed(1), heightValue.toFixed(1))

    // if( spectrum[i]) {

    //   print(`bin${i}`, [binValue, heightValue])

    //   noLoop()

    // }

  }

​

  shader(theShader); // Apply shader

  // rect(-width / 2, -height / 2, width, height); // Draw background with shader

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

​

  // Reset shader for normal drawing

  resetShader();

​

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

​

  //   noStroke();

  //   fill(255, noise(millis()*0.0000005)*250, 100);

​

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

  //     // Map x to half the width

  //     let x = map(i, 0, spectrum.length, 0, width / 2);

  //     let h = -height + map(spectrum[i], 0, 255, height, 0);

​

  //     // Draw rectangle on the right side

  //     rect(width / 2 + x, height, width / spectrum.length / 2, h);

​

  //     // Draw mirrored rectangle on the left side

  //     rect(width / 2 - x, height, -width / spectrum.length / 2, h);

  //   //   }

​

  //   var mod_dir;

  //   mod_dir = .25 // int(random([-5, -3, -1, 1, 3, 5]))

  //         current_modulation = current_modulation + mod_dir

  //         print(current_modulation)

  //         pendulums.forEach((p) => p.modulate(mod_dir)); // Modulate each pendulum individually

  //         modulateContinuousOsc(mod_dir); // Modulate the continuous oscillator

  //         crossingCount = 0; // Reset count

​

  pendulums.forEach((pendulum) => {

    let crossed = pendulum.update();

    if (crossed) {

      crossingCount++;

      if (crossingCount >= MODULATION_THRESHOLD) {

        var mod_dir = THE_MODS[curr_mod_index++ % THE_MODS.length]; // random()-.5 // int(random([-5, -3, -1, 1, 3, 5]))

        current_modulation = current_modulation + mod_dir;

        print(current_modulation);

        pendulums.forEach((p) => p.modulate(mod_dir)); // Modulate each pendulum individually

        modulateContinuousOsc(mod_dir); // Modulate the continuous oscillator

        crossingCount = 0; // Reset count

      }

    }

    pendulum.display();

  });

​

  playQueuedNotes();

}

​

function playFrequency(frequency) {

  if (!STOPMUSIC){

  noteQueue.push(frequency);

  }

}

​

function playQueuedNotes() {

    while (noteQueue.length > 0 && oscillators.length > 0) {

    let frequency = noteQueue.shift(); // Take the next frequency from the queue

    let osc = oscillators.pop(); // Take an oscillator from the pool

    let env = envelopes.pop(); // Take an envelope from the pool

    env.scale(map(frequency, 0, 600, 0.01, 0.005));

    osc.freq(frequency);

    env.play(osc, 0, 0.2);

​

    // Optionally, you can put the oscillator and envelope back into the pool after some time

    setTimeout(() => {

      oscillators.push(osc);

      envelopes.push(env);

    }, 200); // Delay should be at least as long as the envelope duration

  }

​

}

​

const BLINK_LIFETIME = 5; //ticks?/frames?

​

class Pendulum {

  /*

  Pendulum(length, startAngle, frequency(SOUND, NOT SPEED), startAfterAmtUpdates)

  */

  constructor(l, a, f, startAfter) {

    this.position = createVector();

    this.length = l;

    this.init_angle = a;

    this.angle = a;

    this.gravity = GRAVITY; // Acceleration due to gravity (m/s^2)

    this.frequency = f;

​

    this.semitoneShift = 0;

    this.currentFrequency = this.frequency;

    this.angleVelocity = 0;

    this.angleAcceleration = 0;

    this.blinklife = 0;

    this.drag = 1;

    this.blink = false;

    this.startAfter = startAfter;

    this.updateCounter = 0;

    this.ACTUAL_FREQUENCY = this.calculateFrequency();

​

    console.log(

      "Pendulum created at (real) Frequency: " +

        this.ACTUAL_FREQUENCY.toFixed(3) +

        "Hz " +

        "making sound at " +

        this.frequency +

        "Hz"

    );

  }

​

  calculateFrequency() {

    print(this.gravity, this.length);

    return (1 / (2 * PI)) * Math.sqrt(this.gravity / this.length);

  }

​

  update() {

    this.origin = createVector(width / 2, 0);

​

    if (this.updateCounter++ < this.startAfter) {

      return false; // Pendulum hasn't started moving yet

    }

​

    let force = this.gravity * sin(this.angle);

    this.angleAcceleration = (-1 * force) / this.length;

    this.angleVelocity += this.angleAcceleration;

    this.angle += this.angleVelocity;

    this.angleVelocity *= this.drag;

​

    this.prevPosition = createVector();

    this.prevPosition.x = this.position.x;

​

    this.position.x = this.length * sin(this.angle) + this.origin.x;

    this.position.y = this.length * cos(this.angle) + this.origin.y;

    var blinked = false;

​

    if (this.blinklife > 0) {

      this.blinklife--;

    }

    if (

      (this.prevPosition.x < width / 2 && this.position.x >= width / 2) ||

      (this.prevPosition.x > width / 2 && this.position.x <= width / 2)

    ) {

      if (!this.blink) {

        playFrequency(this.currentFrequency);

        this.blinklife = BLINK_LIFETIME;

      }

      if (!this.blink) {

        blinked = true;

      }

​

      this.blink = true;

    } else {

      this.blink = false;

    }

    return blinked;

  }

​

  modulate(mod_dir) {

    this.semitoneShift += mod_dir; // Increment the semitone shift for this pendulum

    this.currentFrequency =

      this.frequency * Math.pow(2, this.semitoneShift / 12);

  }

​

  display() {

    push();

    stroke(this.blinklife ? "rgba(255,255,0,0.29)" : "rgba(255,0,0,0.55)");

    strokeWeight(2);

    fill(this.blinklife ? "#FFC1077C" : "rgba(255,0,0,0.45)");

    line(this.origin.x, this.origin.y, this.position.x, this.position.y);

    circle(this.position.x, this.position.y, 64);

    fill(0);

    text(this.frequency, this.position.x, this.position.y);

    pop();

  }

}

​

function windowResized() {

  print("yea");

  resizeCanvas(windowWidth, windowHeight);

  theShader.setUniform("canasWidth", width);

  theShader.setUniform("height", height);

}

​