dunes _db

// A simple beginner #try2recode based from "Cables and Clouds" orignal art from DisruptedStar

// https://www.fxhash.xyz/generative/15377

// #RecodeRethink

​

//noprotect

let birds = [];

let birdCount = 80;

let count = 0;

let poles = [];

let duneHeight = 80;

let duneCount = 7;

let dunes = [];

let phase = 0;

let cloudCount = 3;

let clouds = [];

let stormCloud;

let gS = 55;

​

function setup() {

  createCanvas(1000, 1000);

  colorMode(HSB, 360, 100, 100, 100);

  noLoop();

  p5grain.setup({

    ignoreErrors: true,

    ignoreWarnings: true,

  });

​

  // Créer des poteaux

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

    let x = random(width / 4, 3 * width / 4); 

    let y = height - random(50, 200);

    let length = random(50, 100);

    let angle = random(-PI/4, PI/4);

    let pole = {x: x, y: y, length: length, angle: angle};

    poles.push(pole);

  }

  // Créer des nuages

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

    let y = map(i, 0, cloudCount, 0, height / 2);

    let cloud = createCloud(y);

    clouds.push(cloud);

  }

  // Créer le nuage faché

  stormCloud = createStormCloud(height / 5);

  // Créer des dunes

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

    let y = map(i, 0, duneCount, height / 2, height);

    let dune = createDune(y);

    dunes.push(dune);

  }

  // Créer des oiseaux car c'est joli les oiseaux...

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

    let bird = createBird();

    birds.push(bird);

  }

}

​

function draw() {

  background(220);

  // Dessiner les points de chaque nuage

  for (let cloud of clouds) {

    for (let pt of cloud) {

      stroke(0, 0, 50, 75);

      strokeWeight(random(0.25, 3));

      point(pt.x, pt.y);

    }

  }

  // Dessiner les points du nuage faché

  for (let pt of stormCloud) {

    stroke(0, 0, 20, 80);

    strokeWeight(random(2, 5));

    point(pt.x, pt.y);

  }

  // Dessiner les points de chaque dune

  for (let dune of dunes) {

    for (let pt of dune) {

      push();

      let h = map(pt.y, pt.duneY, pt.duneY + duneHeight, 100, 30);

      stroke(20, 0, h, 100);

      strokeWeight(random(0.25, 1.5));

      point(pt.x, pt.y);

      pop();

    }

  }

  // Dessiner les lignes reliant le nuage aux poteaux

  for (let pole of poles) {

      push();

      translate(pole.x, pole.y);

      rotate(pole.angle);

      stroke(0);

      strokeWeight(10);

      line(0, 0, pole.length, 0);

      pop();

​

      let numCables = floor(random(1, 5)); 

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

          let cableAttachPointX = pole.x + cos(pole.angle) * pole.length / numCables * i;

          let cableAttachPointY = pole.y + sin(pole.angle) * pole.length / numCables * i;

          let lowestCloudPoint = getLowestCloudPoint(cableAttachPointX - 100, cableAttachPointX + 100);

          if (lowestCloudPoint) {

              let cp1 = createVector(cableAttachPointX, cableAttachPointY - 50 + i * 10); 

              let cp2 = createVector(lowestCloudPoint.x, lowestCloudPoint.y + 50);

              stroke(0);

              drawingContext.setLineDash([0, 2, 1]);

              strokeWeight(floor(random(1.5, 3.5)));

              noFill();

              bezier(cableAttachPointX, cableAttachPointY, cp1.x - 15, cp1.y + 15, cp2.x + 10, cp2.y, lowestCloudPoint.x, lowestCloudPoint.y - random(0, 80));

          }

      }

  }

  // Dessiner les oiseaux, plein d'oiseaux

  for (let bird of birds) {

    push();

    //stroke(0, 100, 100, 70);

    stroke(40);

    strokeWeight(random(0.25, 1.5));

    birdWings = bird.size / 2;

    if (count % 2 == 0) {

      line(bird.x - birdWings, bird.y, bird.x, bird.y + birdWings);

    } else {

      stroke(0, 100, 100, 70);

      line(bird.x, bird.y + birdWings, bird.x + birdWings, bird.y);

    }

    line(bird.x - bird.size / 2, bird.y, bird.x + bird.size / 2, bird.y);

    point(bird.x, bird.y);

    pop();

    count++;

  }

  applyMonochromaticGrain(gS);

  noFill();

  bd = 20;

  stroke(255);

  strokeWeight(bd);

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

}

​

function createBird() {

  let x = random(width / 1.5);

  let y = random(height / 3);

  let size = random(8, 12);

  return { x, y, size }; 

}

​

function createDune(y) {

  let points = [];

  let waveAmp = duneHeight * 0.25;

  let waveFreq = TWO_PI / width;

​

  for (let x = 0; x < width; x += 1) {

    for (let yOff = 0; yOff < duneHeight; yOff += 1) {

      let yNoise = noise(x * 0.003, (y + yOff) * 0.004) * duneHeight;

      let yWave = waveAmp * sin(waveFreq * x); 

      yWave = waveAmp * sin(waveFreq * x - phase);

      let pt = createVector(x, y + yOff + yNoise + yWave);

      pt.duneY = y; 

      points.push(pt);

    }

  }

  phase += 0.15;

  return points;

}

​

function createCloud(y) {

  let points = [];

  let cloudHeight = 150; // Hauteur du nuage

  for (let x = 0; x < width; x += 5) {

    for (let yOff = 0; yOff < cloudHeight; yOff += 5) {

      let yNoise = noise(x * 0.01, (y + yOff) * 0.01) * cloudHeight;

      let pt = createVector(x, y + yOff + yNoise);

      points.push(pt);

      points.push(pt);

    }

  }

​

  return points;

}

​

function createStormCloudFirst(y) {

  let points = [];

  let cloudHeight = 200; 

  let cloudWidth = width / random(1.5, 2.5); 

  let offsetX = width / 8; 

  let amplitude = cloudWidth / 8; 

​

  for (let x = offsetX; x < offsetX + cloudWidth; x += 5) {

    let widthVariation = amplitude * (noise(x * 0.01) * 2 - 1);

    for (let yOff = 0; yOff < cloudHeight; yOff += 5) {

      let yNoise = (noise(x * 0.01, (y + yOff) * 0.01) * 2 - 1) * cloudHeight;

      let pt = createVector(x + widthVariation, y + yOff + yNoise);

      points.push(pt);

      points.push(pt);

    }

  }

​

  return points;

}

​

function createStormCloud(y) {

  let points = [];

  let cloudHeight = 200;

  let cloudWidth = width / 2;

  let offsetX = width / random(4,8);

  let amplitude = cloudWidth / 8;

​

  for (let x = offsetX; x < offsetX + cloudWidth; x += 5) {

    let normalizedX = (x - offsetX) / cloudWidth; 

    let edgeFactor = Math.cos(normalizedX * PI);

    let numPoints = max(1, map(edgeFactor, 0, 1, 1, 5));

    let widthVariation = amplitude * (noise(x * 0.01) * 2 - 1);

    for (let yOff = 0; yOff < cloudHeight; yOff += numPoints) {

      let yNoise = (noise(x * 0.01, (y + yOff) * 0.01) * 2 - 1) * cloudHeight;

      let pt = createVector(x + widthVariation, y + yOff + yNoise);

      points.push(pt);

    }

  }

​

  return points;

}

​

function getClosestCloudPoint(pole) {

  let closestDist = Infinity;

  let closestPoint = null;

  for (let pt of stormCloud) {

    let d = p5.Vector.dist(pt, pole);

    if (d < closestDist) {

      closestDist = d;

      closestPoint = pt;

    }

  }

  return closestPoint;

}

​

function getLowestCloudPoint(startX, endX) {

  let lowestY = -Infinity;

  let lowestPoint = null;

  for (let pt of stormCloud) {

    if (pt.x >= startX && pt.x <= endX && pt.y > lowestY) {

      lowestY = pt.y;

      lowestPoint = pt;

    }

  }

  return lowestPoint;

}

​

  function keyPressed() {

    if (keyCode === 83) {

      saveCanvas('dunes_da_' + floor(random(100)), 'png');

    }

  }