​

let colors = [

  'blue',

  'green',

  'yellow',

  'cyan',

  'pink',

  'limegreen'

];

​

function setup() {

  createCanvas(800, 800, WEBGL);

  createGeometry();

}

​

function draw() {

  background(0);

  orbitControl(4, 2, 0.1);

​

  push();

  translate(200 * sin(frameCount / 50), 0, 200 * cos(frameCount / 50));

  emissiveMaterial(255, 255, 0);

  sphere(10);

  pop();

​

  pointLight(

    255,

    255,

    200,

    200 * sin(frameCount / 50),

    0,

    200 * cos(frameCount / 50)

  );

  ambientLight(50);

  // rotateX(rotX);

  // rotateY(-rotY);

  fill(255, 0, 0);

  noStroke();

  model(nut);

  if (keyIsDown(SHIFT)) {

    push();

      strokeWeight(10);

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

      stroke(colors[i % 6]);

      point(nut.vertices[i].x, nut.vertices[i].y, nut.vertices[i].z)

    }

    stroke(0, 255, 0);

    strokeWeight(0.5);

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

      let vert = nut.vertices[i];

      let norm = nut.vertexNormals[i];

      line(

        vert.x, vert.y, vert.z,

        vert.x + norm.x * 10, vert.y + norm.y * 10, vert.z + norm.z * 10

      );

    }

    stroke(0, 0, 255);

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

      let vert = nut.vertices[i];

      for (let norm of nut.faceNormalsByVertex[i]) {

        line(

          vert.x, vert.y, vert.z,

          vert.x + norm.x * 10, vert.y + norm.y * 10, vert.z + norm.z * 10

        );

      }

    }

    pop();

  }

}

​

function createGeometry() {

  nut = new p5.Geometry();

  let a = 0;

  let b = 0;

  let d1 = 150;

  let d2 = 80;

  let ht = 20;

  let angle = TWO_PI / 6;

​

  nut.vertices = [

    //-----front outer

​

    new p5.Vector(d1 * cos(a), d1 * sin(a), ht),

    new p5.Vector(d1 * cos((a += angle)), d1 * sin(a), ht),

    new p5.Vector(d1 * cos((a += angle)), d1 * sin(a), ht),

    new p5.Vector(d1 * cos((a += angle)), d1 * sin(a), ht),

    new p5.Vector(d1 * cos((a += angle)), d1 * sin(a), ht),

    new p5.Vector(d1 * cos((a += angle)), d1 * sin(a), ht),

​

    //-----front inner

​

    new p5.Vector(d2 * cos(b), d2 * sin(b), ht),

    new p5.Vector(d2 * cos((b += angle)), d2 * sin(b), ht),

    new p5.Vector(d2 * cos((b += angle)), d2 * sin(b), ht),

    new p5.Vector(d2 * cos((b += angle)), d2 * sin(b), ht),

    new p5.Vector(d2 * cos((b += angle)), d2 * sin(b), ht),

    new p5.Vector(d2 * cos((b += angle)), d2 * sin(b), ht),

​

    //-----back outer

​

    new p5.Vector(d1 * cos(a), d1 * sin(a), -ht),

    new p5.Vector(d1 * cos((a += angle)), d1 * sin(a), -ht),

    new p5.Vector(d1 * cos((a += angle)), d1 * sin(a), -ht),

    new p5.Vector(d1 * cos((a += angle)), d1 * sin(a), -ht),

    new p5.Vector(d1 * cos((a += angle)), d1 * sin(a), -ht),

    new p5.Vector(d1 * cos((a += angle)), d1 * sin(a), -ht),

​

    //-----back inner

​

    new p5.Vector(d2 * cos(b), d2 * sin(b), -ht),

    new p5.Vector(d2 * cos((b += angle)), d2 * sin(b), -ht),

    new p5.Vector(d2 * cos((b += angle)), d2 * sin(b), -ht),

    new p5.Vector(d2 * cos((b += angle)), d2 * sin(b), -ht),

    new p5.Vector(d2 * cos((b += angle)), d2 * sin(b), -ht),

    new p5.Vector(d2 * cos((b += angle)), d2 * sin(b), -ht),

  ];

​

  nut.faces = [

    // triangle face vector combination.

    // (numbers are the subsequently written p5.vectors above)

​

    //------frontside

​

    [0, 1, 6],

    [6, 1, 7],

    [1, 2, 7],

    [7, 2, 8],

    [2, 3, 8],

    [8, 3, 9],

    [3, 4, 9],

    [9, 4, 10],

    [4, 5, 10],

    [10, 5, 11],

    [5, 0, 11],

    [11, 0, 6],

​

    //------ backside

​

    [12, 18, 13],

    [18, 19, 13],

    [13, 19, 14],

    [19, 20, 14],

    [14, 20, 15],

    [20, 21, 15],

    [15, 21, 16],

    [21, 22, 16],

    [16, 22, 17],

    [22, 23, 17],

    [17, 23, 12],

    [23, 18, 12],

    // [18, 13, 24],

    // [18, 19, 13],

​

    //-----outer

​

    [0, 13, 1],

    [1, 13, 14],

    [1, 14, 2],

    [2, 14, 15],

    [2, 15, 3],

    [3, 15, 16],

    [3, 16, 4],

    [4, 16, 17],

    [4, 17, 5],

    [5, 17, 12],

    [5, 13, 0],

    [5, 12, 13],

​

    //-----inner

​

    [6, 7, 19],

    [7, 20, 19],

    [7, 8, 20],

    [8, 21, 20],

    [8, 22, 21],

    [9, 22, 8],

    [9, 10, 23],

    [10, 18, 23],

    [9, 23, 22],

    [10, 11, 18],

    [11, 6, 19],

    [11, 19, 18],

  ];

  // Technically computeNormals can do this for us, but this is here for debugging and to demonstrate how computeNormals works.

  // Since each vertex is used by multiple faces, the normal of 

  // each vertex needs to be an average of the normals for all 

  // faces that touch that vertex.

  let faceNormalsByVertex = [];

  for (const face of nut.faces) {

    // to find the normal of a plane, take the cross product of

    // two edges of a triange on that plane.

    const v1 = p5.Vector.sub(nut.vertices[face[0]], nut.vertices[face[1]]);

    const v2 = p5.Vector.sub(nut.vertices[face[2]], nut.vertices[face[1]]);

    const norm = v2.cross(v1).normalize();

    for (const vix of face) {

      let normList = faceNormalsByVertex[vix];

      if (!normList) {

        normList = faceNormalsByVertex[vix] = [];

      }

      // Count multiple trianges with the same normal as a single component of the average.

      if (normList.every(n => p5.Vector.sub(n, norm).magSq() > 0.01)) {

        normList.push(norm);

      }

    }

  }

  // for debugging

  nut.faceNormalsByVertex = faceNormalsByVertex;

  /*

  // This is conceptually what computeNormals() does.

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

    let norm = faceNormalsByVertex[i].reduce((v1, v2) => p5.Vector.add(v1, v2)).normalize();

    nut.vertexNormals[i] = norm;

  } */

  nut.computeNormals();

​

  // Needs to be unique for geometry caching

  nut.gid = "nut";

}

​

/*

function mouseDragged() {

  rotY -= (mouseX - pmouseX) * 0.01;

  rotX -= (mouseY - pmouseY) * 0.01;

}*/

​