const MAX_WEIGHT = 5.0;   // Valor máximo de peso

const POINT_SIZE = 20;    // Tamanho dos pontos de controle

​

let controlPoints = [];   // Array para armazenar os pontos de controle da NURBS

let weights = [];         // Array para armazenar os pesos dos pontos de controle

let splinePoints = [];    // Array para armazenar os pontos da curva NURBS

let currentIndex = 0;     // Índice do ponto de destino atual

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

let squareSize = POINT_SIZE; // Tamanho do quadrado

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

let weightSliders = [];   // Array para armazenar os sliders de peso

​

function setup() {

  createCanvas(800, 900);

​

  let x = 0;

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

    let y = random(height / 2);

    let weight = random(MIN_WEIGHT, MAX_WEIGHT); // Peso aleatório entre o mínimo e o máximo

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

    weights.push(weight);

    x += random(100, 150);

  }

​

  squarePosition = controlPoints[0].copy();

​

  // Criar sliders para cada peso

  createControlPointSliders();

}

​

function draw() {

  background(220);

​

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

    stroke(255, 0, 0);

    fill(255);

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

​

    textSize(12);

    fill(0);

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

  }

​

  splinePoints = calculateNURBSPoints(controlPoints, weights, 20);

​

  stroke(0, 0, 255);

  noFill();

  beginShape();

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

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

  }

  endShape();

​

  fill(0, 255, 0);

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

​

  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) {

      // Gerar novos pontos de controle aleatórios

      generateRandomControlPoints();

      currentIndex = 0;

    }

  }

}

​

function addControlPoint() {

  let newControlPoint = createVector(mouseX, mouseY);

  let newWeight = random(MIN_WEIGHT, MAX_WEIGHT);

​

  controlPoints.push(newControlPoint);

  weights.push(newWeight);

​

  createControlPointSliders();

}

​

function mousePressed() {

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

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

    if (distance < POINT_SIZE / 2) {

      draggedPointIndex = i;

      break;

    }

  }

}

​

function mouseDragged() {

  if (draggedPointIndex >= 0) {

    controlPoints[draggedPointIndex].x = mouseX;

    controlPoints[draggedPointIndex].y = mouseY;

​

    currentIndex = 0;

    squarePosition = controlPoints[0].copy();

  }

}

​

function mouseReleased() {

  draggedPointIndex = -1;

}

​

function calculateNURBSPoints(controlPoints, weights, 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];

​

    let w0 = weights[i];

    let w1 = weights[i + 1];

    let w2 = weights[i + 2];

    let w3 = weights[i + 3];

​

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

      let x = calculateNURBSPoint(p0.x, p1.x, p2.x, p3.x, w0, w1, w2, w3, t);

      let y = calculateNURBSPoint(p0.y, p1.y, p2.y, p3.y, w0, w1, w2, w3, t);

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

    }

  }

​

  return splinePoints;

}

​

function calculateNURBSPoint(p0, p1, p2, p3, w0, w1, w2, w3, 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 * w0 + 3 * uu * t * p1 * w1 + 3 * u * tt * p2 * w2 + ttt * p3 * w3) /

    (uuu * w0 + 3 * uu * t * w1 + 3 * u * tt * w2 + ttt * w3);

​

  return p;

}

​

function updateWeight(index) {

  weights[index] = weightSliders[index].value();

}

​

function generateRandomControlPoints() {

  let x = controlPoints !== [] ? controlPoints[3].x : 0;

  controlPoints = [];

  weights = [];

​

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

    let y = random(height / 2);

    let weight = random(MIN_WEIGHT, MAX_WEIGHT);

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

    weights.push(weight);

    x = random(50, width-50);

  }

​

  squarePosition = controlPoints[0].copy();

​

  // Atualizar sliders de peso

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

    weightSliders[i].value(weights[i]);

  }

}

​

function createControlPointSliders() {

  // Remover sliders existentes

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

    weightSliders[i].remove();

  }

  weightSliders = [];

​

  // Criar sliders para cada peso

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

    let slider = createSlider(MIN_WEIGHT, MAX_WEIGHT, weights[i], 0.01);

    slider.position(10, 40 * i + width-40); // Definir a posição do slider

    // Criar e posicionar o rótulo para o slider

    let label = createElement("label", "Ponto " + (i + 1));

    label.position(160, 40 * i + width-40);

    // Definir o id do slider como seu índice correspondente

    slider.id(i);

    // Definir o evento de input para acionar a função updateWeight com o índice correspondente

    slider.input(function() {

      updateWeight(this.id());

    });

    weightSliders.push(slider); // Adicionar o slider ao array

  }

}

​