* Based on Unfolding the Dragon (Coding Challenge 185)

 * https://www.youtube.com/watch?v=MazpwQNdJYQ

 */ 

​

let segments = [];

let endSegment;

let zoom = 1;

let targetZoom = 1;

let amt = 0;

let angle1, angle2, goldenRatio, r1, r2;

let generationCount = 0;

let maxGenerations = 12;

​

function setup() {

  createCanvas(500, 500);

  // Calculate constants for the golden ratio dragon curve

  goldenRatio = (1 + Math.sqrt(5)) / 2;

  r1 = Math.pow(1 / goldenRatio, 1 / goldenRatio);

  r2 = r1 ** 2;

  angle1 = Math.acos((1 + r1 ** 2 - r1 ** 4) / (2 * r1));

  angle2 = Math.acos((1 + r1 ** 4 - r1 ** 2) / (2 * r2));

  // Define the start and end points of the initial segment

  let b = createVector(0, 0);

  let a = createVector(0, 250);

  // Create the first segment using points 'a' and 'b'

  endSegment = new Segment(a, b, b);

  endSegment.completed = true;

  // Add the initial segment to the segments array

  segments.push(endSegment);

}

​

let firstTime = true;

​

function nextGeneration() {

  let newSegments = [];

  for (let s of segments) {

    // Duplicate each segment

    let newS = s.duplicate(endSegment.a);

    // If it's the first segment, set the origin to be 'b'

    if (firstTime) {

      newS.origin = endSegment.b;

      firstTime = false;

    }

​

    // Add the new segment to the newSegments array

    newSegments.push(newS);

  }

​

  // Update the endSegment to be the first of the new segments

  endSegment = newSegments[0];

  // Append the new segments to the existing segments array

  segments = segments.concat(newSegments);

}

​

function draw() {

  background(255);

  translate(width / 2, height / 2);

  // Update the zoom only if the number of generations is less than maxGenerations

  if (generationCount < maxGenerations) {

    let newZoom = lerp(zoom, targetZoom, amt);

    scale(newZoom);

    zoom = newZoom; // Update the zoom level

  } else {

    scale(zoom); // Keep the final zoom level

  }

  amt += 0.01;

  for (let s of segments) {

    if (!s.completed) {

      s.update();

    }

    s.show();

  }

​

  if (amt >= 1) {

    for (let s of segments) {

      s.completed = true;

    }

    // Stop after 12 generations

    if (generationCount < maxGenerations) {

      nextGeneration();

      generationCount++; // Increment the generation counter

      targetZoom = zoom / (0.85 * goldenRatio); // Update targetZoom for the next generation

    }

    amt = 0;

    //noLoop();

  } 

  //console.log(amt)

}

​

// Golden ratio Dragon curve

// https://larryriddle.agnesscott.org/ifs/heighway/goldenDragon.htm

​

class Segment {

  constructor(a, b, origin) {

    // Initial positions of the segment

    this.startA = a;

    this.startB = b;

    this.a = a.copy();

    this.b = b.copy();

    this.completed = false;

    this.angle = 0;

    this.origin = origin.copy();

    this.dilatation = 1; // Needed for shrinking segments

  }

​

  show() {

    stroke(0);

    strokeWeight(2 / zoom);

    line(this.a.x, this.a.y, this.b.x, this.b.y);

  }

​

  duplicate(origin) {

    return new Segment(this.a.copy(), this.b.copy(), origin);

  }

​

  update() {

    // Rotation angle based on the golden ratio calculation

    let targetAngle = PI - angle1 - angle2;

    this.angle = lerp(0, targetAngle, amt);

    this.dilatation = lerp(1, r1, amt);

    // Calculate vectors from origin to the start and end points

    let va = p5.Vector.sub(this.startA, this.origin);

    let vb = p5.Vector.sub(this.startB, this.origin);

    // Apply dilation with factor r1 only to the last segment after rotation

    va.mult(this.dilatation);

    vb.mult(this.dilatation);

    // Rotate the vectors by the calculated angle

    va.rotate(-this.angle);

    vb.rotate(-this.angle);

    // Update the segment's current endpoints based on the rotated (and possibly dilated) vectors

    this.a = p5.Vector.add(this.origin, va);

    this.b = p5.Vector.add(this.origin, vb);

  }

}

​