// https://editor.p5js.org/micuat/sketches/KDY2VMqN4

​

const gId = `test`;

let _cube = CSG.cube();

let _sphere = CSG.sphere({

    center: [1, 0, 0],

    radius: 1.3

  });

let polygons = _cube.subtract(_sphere).toPolygons();

​

function setup() {

  createCanvas(windowWidth, windowHeight, WEBGL);

  buildShape(gId, polygons)

}

​

function draw() {

  background(0)

  orbitControl(3)

  // why render once, when it can be liiiive!?

  _cube = CSG.cube();

  _sphere = CSG.sphere({

    center: [

      map(mouseX, 0, width, -1, 1), 

      map(mouseY, 0, height, -1, 1), 

      0

    ],

    radius: 1.3

  });

  polygons = _cube.subtract(_sphere).toPolygons();

  // polygons = _cube.union(_sphere).toPolygons(); // opposite test

​

  buildShape(gId, polygons)

​

  normalMaterial()

  // fill(255)

  // lights()

  rotateY(radians(-frameCount / 2))

  drawShape(height/5)

}

​

function drawShape(shapeSize){

  this._renderer.drawBuffersScaled(gId, shapeSize, shapeSize, shapeSize);

}

​

function buildShape(gId, polygons){

  // is it necessary to only do once? works fine w/ constantly rendering..

  // not efficient, best todo if values changed - but seems fine

  // if (!this._renderer.geometryInHash(gId)) {

    const geom = new p5.Geometry();

​

    let vCount = 0;

    const vertice_dict = {};

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

      let p = polygons[i].vertices

      for (let j = 2; j < p.length; j++) {

        let v, n;

        let ia, ib, ic;

        v = p[0].pos;

        n = p[0].normal;

        ia = vertice_dict[`${v.x},${v.y},${v.z},${n.x},${n.y},${n.z}`]

        if (ia === undefined) {

          geom.vertices.push(createVector(v.x, v.y, v.z));

          geom.vertexNormals.push(createVector(n.x, n.y, n.z));

          vertice_dict[`${v.x},${v.y},${v.z},${n.x},${n.y},${n.z}`] = vCount;

          ia = vCount;

          vCount++;

        }

​

        v = p[j-1].pos;

        // n = p[j-1].normal;

        ib = vertice_dict[`${v.x},${v.y},${v.z},${n.x},${n.y},${n.z}`]

        if (ib === undefined) {

          geom.vertices.push(createVector(v.x, v.y, v.z));

          geom.vertexNormals.push(createVector(n.x, n.y, n.z));

          vertice_dict[`${v.x},${v.y},${v.z},${n.x},${n.y},${n.z}`] = vCount;

          ib = vCount;

          vCount++;

        }

​

        v = p[j].pos;

        // n = p[j].normal;

        ic = vertice_dict[`${v.x},${v.y},${v.z},${n.x},${n.y},${n.z}`]

        if (ic === undefined) {

          geom.vertices.push(createVector(v.x, v.y, v.z));

          geom.vertexNormals.push(createVector(n.x, n.y, n.z));

          vertice_dict[`${v.x},${v.y},${v.z},${n.x},${n.y},${n.z}`] = vCount;

          ic = vCount;

          vCount++;

        }

        geom.faces.push([ia, ib, ic]);

      }

    }

    this._renderer.createBuffers(gId, geom);

​

  // }

}