#genuary2 #genuary2025 #genuary

let layers = [];

let offsets = []; // Offset per gestire la velocità dei layer

let speeds = [];

let scales = []; // Scale differenti per ogni layer

let cols;

let colors = [];

let n_layers;

let noiseIntensity;

let colorPaletteSize;

let h1;

let h1P;

​

function setup() {

  createCanvas(400, 600);

  colorMode(HSL, 360, 100, 100);

​

  // Impostazioni procedurali

  n_layers = floor(random(4, 10)); // Numero casuale di layer

  noiseIntensity = random(20, 60); // Intensità casuale del rumore

  colorPaletteSize = floor(random(10, 50)); // Numero casuale di colori

  h1=int(random(360)); // colore random

  h1P=int(random(10,100)); // offS colore

​

  // Genera una palette di colori casuale

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

    let h = random(h1-h1P,h1+h1P);

    let s = random(50, 100);

    let l = random(20, 80);

    colors.push(color(h, s, l));

  }

​

  // Inizializza i layer, gli offset, le velocità e le scale

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

    scales.push(random(5, 30)); // Dimensione casuale della scala per ogni layer

    layers.push(createLayer(scales[i]));

    offsets.push(0); // Offset iniziale per il movimento

    speeds.push(random(0.5, 2) * (n_layers - i) * 0.5); // Velocità casuale per layer

  }

}

​

function draw() {

  background(20);

​

  // Disegna e aggiorna ogni layer

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

    drawLayer(layers[i], i, offsets[i], scales[i]);

    updateLayer(i, scales[i]);

  }

}

​

function createLayer(scale) {

  let cols = ceil(width / scale) + 2;

  let rows = ceil(height / 4 / scale);

  let layer = [];

  for (let y = 0; y < rows; y++) {

    let row = [];

    for (let x = 0; x < cols; x++) {

      row.push(noise(x * 0.01, y * 0.01)); // Valori Perlin noise

    }

    layer.push(row);

  }

  return layer;

}

​

function drawLayer(layer, index, offset, scale) {

  push();

  translate(-offset, index * height / n_layers); // Posiziona e applica l'offset

  for (let y = 0; y < layer.length; y++) {

    beginShape(TRIANGLE_STRIP);

    for (let x = 0; x < layer[y].length; x++) {

      let value = layer[y][x];

      let n=noise(x*0.5,y*0.5)

      let xPos = x * scale;

      let yPos = y * scale - value * noiseIntensity; // Altezza influenzata dal noise

      let cV = constrain(floor(map(value, 0, 1, 0, colors.length - 1)), 0, colors.length - 1); // Colore per layer

      let colorValue = colors[cV];

      fill(colorValue); // Colori

      stroke(colorValue);

      vertex(xPos, yPos);

      vertex(xPos, yPos + scale);

    }

    endShape();

  }

  pop();

}

​

function updateLayer(index, scale) {

  offsets[index] += speeds[index]; // Aggiorna l'offset in base alla velocità del layer

  if (offsets[index] > scale) {

    // Sposta i valori a sinistra quando l'offset supera una cella

    let cols = ceil(width / scale) + 2;

    for (let y = 0; y < layers[index].length; y++) {

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

        layers[index][y][x] = layers[index][y][x + 1];

      }

      layers[index][y][cols - 1] = noise(

        frameCount * 0.01,

        y * 0.01 + index * 0.1

      ); // Genera nuovi valori

    }

    offsets[index] = 0; // Resetta l'offset

  }

}

​