let splinePoints = []; // Array para armazenar os pontos da B-spline

let currentIndex = 0; // Índice do ponto objetivo atual

let squarePosition; // Posição atual do quadrado

let squareSize = 20; // Tamanho do quadrado

let draggedPointIndex = -1; // Índice do ponto de controle sendo arrastado

​

function setup() {

  createCanvas(800, 900);

  // Gerar 5 pontos aleatórios progressivos dentro da tela

  let x = 0;

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

    let y = random(height);

    controlPoints.push(createVector(x, y));

    x += random(100, 150); // Incremento aleatório para X

  }

  // Inicializar a posição do quadrado no primeiro ponto da curva

  squarePosition = controlPoints[0].copy();

}

​

function draw() {

  background(220);

  // Desenhar os pontos de controle

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

    stroke(255, 0, 0);

    fill(255);

    ellipse(controlPoints[i].x, controlPoints[i].y, 10, 10);

​

    // Escrever o nome do ponto atual

    textSize(12);

    fill(0);

    text("Ponto " + (i+1), controlPoints[i].x + 15, controlPoints[i].y);

  }

​

  // Calcular a curva B-spline com 20 pontos

  splinePoints = calculateBSplinePoints(controlPoints, 20);

  // Desenhar a curva B-spline

  stroke(0, 0, 255);

  noFill();

  beginShape();

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

    vertex(splinePoints[i].x, splinePoints[i].y);

  }

  endShape();

  // Desenhar o quadrado

  fill(0, 255, 0);

  rect(squarePosition.x, squarePosition.y, squareSize, squareSize);

  // Atualizar a posição do quadrado em direção ao próximo ponto da curva

  let target = splinePoints[currentIndex];

  let distance = dist(squarePosition.x, squarePosition.y, target.x, target.y);

  if (distance >= 20) {

    let angle = atan2(target.y - squarePosition.y, target.x - squarePosition.x);

    let stepSize = createVector(cos(angle), sin(angle)).mult(2);

    squarePosition.add(stepSize);

  } else {

    currentIndex++;

    if (currentIndex >= splinePoints.length) {

      currentIndex = 0;

    }

  }

}

​

function mousePressed() {

  // Verificar se algum ponto de controle foi clicado

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

    let distance = dist(mouseX, mouseY, controlPoints[i].x, controlPoints[i].y);

    if (distance < 5) {

      draggedPointIndex = i;

      break;

    }

  }

}

​

function mouseDragged() {

  // Arrastar o ponto de controle selecionado pelo mouse

  if (draggedPointIndex >= 0) {

    controlPoints[draggedPointIndex].x = mouseX;

    controlPoints[draggedPointIndex].y = mouseY;

    // Reiniciar a posição do quadrado no primeiro ponto da curva

    currentIndex = 0;

    squarePosition = controlPoints[0].copy();

  }

}

​

function mouseReleased() {

  // Parar de arrastar o ponto de controle

  draggedPointIndex = -1;

}

​

// Função para calcular os pontos da curva B-spline

function calculateBSplinePoints(controlPoints, numPoints) {

  let splinePoints = [];

  let tStep = 1 / (numPoints - 1);

  for (let i = 0; i < controlPoints.length - 3; i++) {

    let p0 = controlPoints[i];

    let p1 = controlPoints[i + 1];

    let p2 = controlPoints[i + 2];

    let p3 = controlPoints[i + 3];

    for (let t = 0; t <= 1; t += tStep) {

      let x = calculateBSplinePoint(p0.x, p1.x, p2.x, p3.x, t);

      let y = calculateBSplinePoint(p0.y, p1.y, p2.y, p3.y, t);

      splinePoints.push(createVector(x, y));

    }

  }

  return splinePoints;

}

​

// Função para calcular um ponto na curva B-spline

function calculateBSplinePoint(p0, p1, p2, p3, t) {

  let u = 1 - t;

  let tt = t * t;

  let uu = u * u;

  let uuu = uu * u;

  let ttt = tt * t;

  let p = uuu * p0;

  p += 3 * uu * t * p1;

  p += 3 * u * tt * p2;

  p += ttt * p3;

  return p;

}

​