🎓 3주차: 반복과 패턴 (Iteration & Pattern)

선 그리기

function setup() {
  createCanvas(800, 400);
  background(23);
}

function draw() {
  for (let i = 20; i < width; i += 20) {
    stroke(255);
    line(i, 0, i, height); // (x1, y1, x2, y2) : 위에서 아래로 수직선
  }
}

• 이 예제에서는 draw 함수 대신 setup에 그리는 것이 더 효율적입니다.
• draw는 매 프레임마다 실행되므로, 라인을 계속 그리게 됩니다.
• x 좌표를 20부터 시작해서 20씩 증가시키며 반복
  • i < 800 이면 x가 780까지 그려지고, i <= 800 이면 x가 800까지 그려집니다.
  • 여기서는 800을 넘어가지 않도록 < 800으로 설정했습니다.
• line()는 (x1, y1, x2, y2)를 인자로 받아서 선을 그리는 함수입니다.

격자 패턴 (Grid Pattern)

function setup() {
  createCanvas(800, 400);
  background(25);
  noFill(); 
  stroke(100, 200, 255); 
  strokeWeight(1);
}

function draw() {
  // 가로선을 그리는 반복문
  for (let y = 20; y < height; y += 40) {
    // 세로선을 그리는 반복문 (가로선 안에 있음)
    for (let x = 20; x < width; x += 40) {
      rect(x, y, 30, 30); // (x, y) 위치에 30x30 크기의 사각형 그리기
    }
  }
}

점 패턴 (Dot Pattern)

function setup() {
  createCanvas(800, 400);
  noLoop();
  noStroke();
}

function draw() {
  background(25);
  let step = 20;
  // x += 1 : 1 픽셀씩 이동하면서 그림
  // x += step : step으로 설정된 수만큼 이동하면서 그림
  for (let x = 0; x < width; x += step) {
    for (let y = 0; y < height; y += step) {
      let r = int(random(0, 20));
      let g = int(random(130, 180));
      let b = int(random(120, 150));

      fill(r, g, b);
      ellipse(x + step / 2, y + step / 2, step - 2);
    }
  }
}

방사형 패턴 (Radial Symmetry)

function setup() {
  createCanvas(800, 400);
  colorMode(HSB, 360, 100, 100, 100);
}

function draw() {
  background(0, 0, 10);
  translate(width / 2, height / 2);

  let layers = 8;
  let petals = 16;

  for (let j = 0; j < layers; j++) {
    let radius = map(j, 0, layers, 40, 200);
    for (let i = 0; i < petals; i++) {
      push();
      rotate((TWO_PI * i) / petals);
      let hue = map(j, 0, layers, 150, 200);
      fill(hue, 80, 100, 80);
      noStroke();
      ellipse(radius, 0, 12, 12);
      pop();
    }
  }
}

• colorMode(HSB)를 사용해서 hue값만 150~200 사이로 변하도록 했습니다. 각 인수에 들어가는 값의 범위는 아래와 같습니다.
  • Hue: 0~360 (색상)
  • Saturation: 0~100 (채도)
  • Brightness: 0~100 (명도)
  • Alpha: 0~100 (투명도)

나선형 (Spriral)

function setup() {
  createCanvas(800, 400);
  angleMode(DEGREES);
  noLoop();
}

function draw() {
  background(25);
  translate(width / 2, height / 2);

  let n = 200;
  let baseRadius = 2;
  let angleStep = 10;

  for (let i = 0; i < n; i++) {
    let angle = i * angleStep;
    let radius = baseRadius + i * 1.8;
    let x = radius * cos(angle);
    let y = radius * sin(angle);

    // 색상: i 값에 따라 변화
    let brightness = map(i, 0, n, 50, 255);
    fill(brightness, 120, 200, 180);

    noStroke();
    ellipse(x, y, 15, 15);
  }
}

위아래 진동하는 공

function setup() {
  createCanvas(800, 400);
  background(23, 23, 23);
  noStroke();
}

function draw() {
  // 매 프레마다 배경을 다시 칠하여 이전 프레임의 원을 지웁니다.
  background(23, 23, 23);

  // draw() 함수는 매 프레임(기본 1초에 60번)마다 실행됩니다.
  // frameCount라는 p5.js 내장 변수를 사용하여 시간을 기준으로 움직임을 만듭니다.

  for (let x = 0; x < width; x += 20) {
    // x 좌표와 현재 프레임 수를 이용하여 y 좌표를 계산합니다.
    // sin() 함수는 -1에서 1 사이의 값을 반환합니다.
    // map() 함수를 사용하여 -1~1의 값을 캔버스 높이(0~400) 범위로 변환합니다.
    let y = map(
      sin(x * 0.05 + frameCount * 0.05),
      -1,
      1,
      height * 0.2,
      height * 0.8
    );

    // y 좌표에 따라 원의 크기를 변화시킵니다.
    let circleSize = map(y, height * 0.2, height * 0.8, 20, 5);

    fill(100, 200, 255);
    circle(x, y, circleSize);
  }
}

• frameCount: p5.js가 시작된 이후의 총 프레임 수를 저장하는 변수입니다. 시간의 흐름을 나타내는 척도로 사용됩니다.
• sin(x * 0.05 + frameCount * 0.05): x 위치와 frameCount를 조합하여 각 절의 파도 높이를 계산합니다. frameCount가 계속 증가하므로 파도가 계속 움직이는 것처럼 보입니다.
• map(): sin() 함수가 반환하는 -1~1의 값을 캔버스의 상단 20% 지점에서 하단 80% 지점으로, 그리고 원의 크기는 20에서 5로 매핑하여 깊이감을 줍니다.

회전하는 사각형 (rotating square)

function setup() {
  createCanvas(800, 400);
}

function draw() {
  background(23, 23, 23); // 마지막 인자의 알파값에 숫자를 쓰면 trail 효과

  push(); // 현재의 캔버스 상태(좌표 등)를 저장합니다.
  translate(width / 2, height / 2); // 캔버스의 중심으로 좌표 이동

  // 회전 각도를 매 프레임마다 조금씩 변경
  rotate(frameCount * 0.01);

  // 12개의 사각형을 원형으로 배치
  for (let i = 0; i < 12; i++) {
    push(); // 현재 회전된 상태를 저장

    // 각 사각형을 배치할 각도를 계산
    let angle = (TWO_PI / 12) * i;
    rotate(angle);

    // 중심에서 150px 떨어진 곳에 사각형을 그립니다.
    translate(150, 0);

    fill(255, 200, 0); // 노란색
    noStroke();
    rectMode(CENTER); // 사각형의 중심을 기준으로 그리도록 설정
    rect(0, 0, 30, 30); // 30x30 크기의 사각형

    pop(); // 회전된 상태를 복원하여 다음 사각형 그리기
  }

  pop(); // 캔버스의 원래 상태(중심 이동 전)를 복원
}

• push() / pop(): push()는 현재의 좌표계, 색상 등 상태를 저장하고, pop()은 마지막으로 저장된 상태를 복원합니다. 이를 사용하면 좌표 변화가 서로 영향을 주지 않아 복잡한 그래픽을 그리기 편해집니다.
• translate(): 좌표의 원점(0,0)을 지정한 위치로 이동시킵니다.
• rotate(): 현재 좌표계를 지정한 각도만큼 회전시킵니다. frameCount를 사용하면 시간에 따라 자연스럽게 회전합니다.
• TWO_PI: 360도를 라디안 값으로 나타낸 것입니다(약 6.28). 12개의 도형을 원형으로 배치하기 위해 각 도형마다 TWO_PI / 12만큼 회전시킵니다.

2차원 파동 그리드 (2D Wave Grid)

// No Animation
function setup() {
  createCanvas(800, 400);
  noLoop();
  background(25);
  noStroke();

  let cols = 20;
  let rows = 15;
  let spacingX = width / cols;
  let spacingY = height / rows;

  for (let i = 0; i < cols; i++) {
    for (let j = 0; j < rows; j++) {
      let cx = i * spacingX + spacingX / 2;
      let cy = j * spacingY + spacingY / 2;
      let angle = i * 0.6 + j * 0.3;
      let r = 20 + 8 * sin(angle);
      fill(150, 80, 220, 250);
      ellipse(cx, cy, r, r);
    }
  }
}

// Animation using sin 
function setup() {
  createCanvas(800, 400);
  // noLoop()를 제거하여 draw() 함수가 매 프레임마다 계속 호출되도록 합니다.
  // 이것이 애니메이션을 만드는 핵심입니다.
  background(25); // 배경색을 한 번만 설정하면 이전 프레임의 그림이 남아있을 수 있습니다.
  noStroke(); // 도형의 외곽선을 그리지 않습니다.
}

function draw() {
  // 매 프레임이 시작될 때마다 배경을 다시 칠해줍니다.
  // 이렇게 해야 이전 프레임에서 그렸던 원들이 지워지고 새로운 프레임이 그려집니다.
  background(25);

  // 그리드 설정
  let cols = 20; // 가로 방향 원의 개수
  let rows = 15; // 세로 방향 원의 개수
  let spacingX = width / cols; // 가로 방향 원 사이의 간격
  let spacingY = height / rows; // 세로 방향 원 사이의 간격

  // 이중 반복문을 사용하여 2차원 그리드 상의 모든 점에 대해 원을 그립니다.
  for (let i = 0; i < cols; i++) {
    for (let j = 0; j < rows; j++) {
      // 그리드 상의 각 점(i, j)에 대한 중심 좌표(cx, cy)를 계산합니다.
      let cx = i * spacingX + spacingX / 2;
      let cy = j * spacingY + spacingY / 2;

      // --- 핵심: 애니메이션을 위한 각도 계산 ---
      // 각 프레임마다 변하는 값인 frameCount를 사용하여 각도를 계산합니다.
      // i와 j에 각각 다른 가중치(0.6, 0.3)를 곱해 대각선 방향으로 파도가 치는 효과를 냅니다.
      let angle = i * 0.6 + j * 0.3 + frameCount * 0.05;

      // sin() 함수는 -1에서 1 사이의 값을 주기적으로 반환합니다.
      // 이 값을 이용하여 원의 반지름(r)을 주기적으로 변화시킵니다.
      // 8 * sin(angle)의 결과는 -8에서 8 사이가 되고,
      // 여기에 기본 반지름 20을 더하면 최종 반지름은 12에서 28 사이로 변합니다.
      let r = 20 + 8 * sin(angle);

      // 원의 색상을 설정합니다. (보라색)
      fill(150, 80, 220, 250);

      // 계산된 중심 좌표(cx, cy)와 변하는 반지름(r)을 이용하여 원을 그립니다.
      ellipse(cx, cy, r, r);
    }
  }
}

• 규칙적인 격자 안에서도 sin()로 수학적 변형을 주어 유기적인 패턴을 생성할 수 있습니다.