Algorithmic Bloom

function setup() {
  createCanvas(windowWidth, windowHeight);
  angleMode(RADIANS); // Ensure angles are in radians (default, but good to be explicit)
  strokeCap(ROUND); // Rounded ends for branches, for a softer look

  // Load the initial color palette
  loadPalette(currentPaletteIndex);

  // Initialize noise offsets with random values for varied starting animations
  angleNoiseOffset = random(1000);
  reductionFactorNoiseOffset = random(1000);
  skyNoiseOffset1 = random(1000);
  skyNoiseOffset2 = random(1000);
  groundNoiseOffset = random(1000); // NEW: Initialize ground noise offset

  // Initialize the initial branch length based on the canvas height
  branchLength = height * 0.25;
}

function draw() {
  drawSkyGradient(); // Draw the gradient sky background with dynamic colors
  drawGroundGradient(); // Draw the ground at the bottom

  // Draw the artist's handle BEFORE the main translation for the tree
  drawArtistHandle();

  translate(width / 2, height - (height * 0.1)); // Move origin to bottom center, slightly above ground
  branch(branchLength, 0); // Start drawing the tree from the main trunk (depth 0)

  // Update noise offsets for continuous, subtle animation over time
  angleNoiseOffset += 0.005;
  reductionFactorNoiseOffset += 0.005;
  skyNoiseOffset1 += 0.002;
  skyNoiseOffset2 += 0.003;
  groundNoiseOffset += 0.001; // NEW: Animate ground noise offset
}

function branch(len, depth) {
  // Determine branch color based on its depth in the tree
  let branchColor = lerpColor(branchBaseColor, branchTipColor, depth / maxDepth);
  stroke(branchColor); // Set the branch color

  // Branch thickness tapers with length
  strokeWeight(len * 0.05);
  line(0, 0, 0, -len); // Draw the branch line

  translate(0, -len); // Move the origin to the end of the current branch

  // If this branch is an endpoint (small enough OR reached max depth), draw leaves and stop recursion
  if ((len <= minBranchLength && depth > 3) || depth >= maxDepth) {
    drawLeaves(len); // Draw a cluster of leaves
    return; // Stop further recursion for this branch
  }

  // If the branch is still long enough and within max depth, continue branching recursively
  if (len > minBranchLength && depth < maxDepth) {
    // Determine dynamic angle for branching based on mouseX and noise
    let dynamicAngle = map(mouseX, 0, width, PI / 8, PI / 2);
    // Rely solely on noise for continuous, organic variation in angle
    dynamicAngle += map(noise(angleNoiseOffset + depth * 0.1), 0, 1, -PI / 16, PI / 16);
    dynamicAngle = constrain(dynamicAngle, PI / 8, PI / 2); // Keep angle within reasonable bounds

    // Determine dynamic reduction factor based on mouseY and noise
    let dynamicReductionFactor = map(mouseY, 0, height, 0.5, 0.8);
    // Rely solely on noise for continuous, organic variation in reduction factor
    dynamicReductionFactor += map(noise(reductionFactorNoiseOffset + depth * 0.1), 0, 1, -0.05, 0.05);
    dynamicReductionFactor = constrain(dynamicReductionFactor, 0.5, 0.8); // Keep reduction factor within bounds

    // Recursive call for the right branch
    push();
    rotate(dynamicAngle);
    branch(len * dynamicReductionFactor, depth + 1);
    pop();

    // Recursive call for the left branch
    push();
    rotate(-dynamicAngle);
    branch(len * dynamicReductionFactor, depth + 1);
    pop();
  }
}

function drawLeaves(len) {
  fill(leafColor); // Set leaf color with transparency
  noStroke(); // No outline for leaves

  // Draw multiple small ellipses to create a fuller leaf cluster
  let leafSize = len * 0.6;
  for (let i = 0; i < 3; i++) {
    push(); // Save current transformation for each leaf ellipse
    // NEW: Random x and y offsets are now applied relative to the current branch tip
    ellipse(random(-leafSize / 8, leafSize / 8), random(-leafSize / 8, leafSize / 8), leafSize * random(0.7, 1.2), leafSize * random(0.4, 0.8));
    pop(); // Restore transformation for the next leaf or branch
  }
}

function drawSkyGradient() {
  noStroke(); // No outline for the gradient lines
  for (let y = 0; y < height * 0.9; y++) { // Draw sky up to 90% of the canvas height
    // Interpolate color from skyColor1 (top) to skyColor2 (bottom)
    // Add noise to each color component for subtle, dynamic shifts
    let c1R = red(skyColor1) + map(noise(skyNoiseOffset1 + y * 0.001), 0, 1, -20, 20);
    let c1G = green(skyColor1) + map(noise(skyNoiseOffset1 + y * 0.001 + 100), 0, 1, -20, 20);
    let c1B = blue(skyColor1) + map(noise(skyNoiseOffset1 + y * 0.001 + 200), 0, 1, -20, 20);
    let dynamicSkyColor1 = color(c1R, c1G, c1B);

    let c2R = red(skyColor2) + map(noise(skyNoiseOffset2 + y * 0.001), 0, 1, -20, 20);
    let c2G = green(skyColor2) + map(noise(skyNoiseOffset2 + y * 0.001 + 100), 0, 1, -20, 20);
    let c2B = blue(skyColor2) + map(noise(skyNoiseOffset2 + y * 0.001 + 200), 0, 1, -20, 20);
    let dynamicSkyColor2 = color(c2R, c2G, c2B);

    let c = lerpColor(dynamicSkyColor1, dynamicSkyColor2, y / (height * 0.9));
    stroke(c); // Set the stroke color to the interpolated color
    line(0, y, width, y); // Draw a horizontal line to create the gradient
  }
}

function drawGroundGradient() {
  noStroke();
  for (let y = height * 0.9; y < height; y++) { // Draw ground from 90% height to bottom
    let c = lerpColor(groundColor1, groundColor2, (y - height * 0.9) / (height * 0.1));
    // NEW: Add noise to each color component for subtle ground texture
    let cR = red(c) + map(noise(groundNoiseOffset + y * 0.01), 0, 1, -10, 10);
    let cG = green(c) + map(noise(groundNoiseOffset + y * 0.01 + 100), 0, 1, -10, 10);
    let cB = blue(c) + map(noise(groundNoiseOffset + y * 0.01 + 200), 0, 1, -10, 10);
    stroke(color(cR, cG, cB));
    line(0, y, width, y);
  }
}

function drawArtistHandle() {
  push(); // Save current drawing state (which is the canvas's default origin)
  textAlign(RIGHT, BOTTOM); // Align text to the bottom right
  textSize(12); // Small text size

  // Dynamically choose text color based on the current sky brightness
  let currentSkyBrightness = brightness(lerpColor(skyColor1, skyColor2, 0.5));
  let textColor = currentSkyBrightness > 127 ? color(50) : color(220); // Dark text on light sky, light text on dark sky

  fill(textColor); // Set text color
  noStroke(); // No stroke for the text
  // Position it with a small margin from the bottom and right edges
  text(artistHandle, width - 10, height - 10);
  pop(); // Restore previous drawing state (not strictly necessary here as no transformations were applied)
}

function loadPalette(index) {
  const palette = palettes[index];
  skyColor1 = color(palette.sky1);
  skyColor2 = color(palette.sky2);
  groundColor1 = color(palette.ground1);
  groundColor2 = color(palette.ground2);
  branchBaseColor = color(palette.branchBase);
  branchTipColor = color(palette.branchTip);
  leafColor = color(palette.leaf);
}

function keyPressed() {
  if (key === 'p' || key === 'P') { // Cycle through palettes when 'P' is pressed
    currentPaletteIndex = (currentPaletteIndex + 1) % palettes.length;
    loadPalette(currentPaletteIndex);
    // Re-initialize noise offsets for a new tree appearance with the new palette
    angleNoiseOffset = random(1000);
    reductionFactorNoiseOffset = random(1000);
    skyNoiseOffset1 = random(1000);
    skyNoiseOffset2 = random(1000);
    groundNoiseOffset = random(1000); // NEW: Re-initialize ground noise offset
  } else if (key === 'n' || key === 'N') { // Generate a new tree (random palette, new noise) when 'N' is pressed
    // Pick a random palette index
    currentPaletteIndex = floor(random(palettes.length));
    loadPalette(currentPaletteIndex); // Load the new random palette
    // Re-initialize all noise offsets for a completely new tree appearance
    angleNoiseOffset = random(1000);
    reductionFactorNoiseOffset = random(1000);
    skyNoiseOffset1 = random(1000);
    skyNoiseOffset2 = random(1000);
    groundNoiseOffset = random(1000); // NEW: Re-initialize ground noise offset
  }
}

function windowResized() {
  resizeCanvas(windowWidth, windowHeight); // Resize the canvas to fit the new window size
  branchLength = height * 0.25; // Recalculate the initial branch length for responsiveness
}