static renderTriangle()

in src/engine/actvolume/volgen.js [25:157]
111 lines of code
47 McCabe index (conditional complexity)

  static renderTriangle(xDim, yDim, zDim, pixels, verts) {
    const xyDim = xDim * yDim;

    // outer loop:
    // [0] -> [1]
    // [0] -> [2]
    const v01 = new THREE.Vector3();
    const v02 = new THREE.Vector3();
    const v12 = new THREE.Vector3();
    v01.x = verts[1].x - verts[0].x;
    v01.y = verts[1].y - verts[0].y;
    v01.z = verts[1].z - verts[0].z;
    v02.x = verts[2].x - verts[0].x;
    v02.y = verts[2].y - verts[0].y;
    v02.z = verts[2].z - verts[0].z;

    v12.x = verts[2].x - verts[1].x;
    v12.y = verts[2].y - verts[1].y;
    v12.z = verts[2].z - verts[1].z;

    const dist01 = Math.sqrt(v01.x * v01.x + v01.y * v01.y + v01.z * v01.z);
    const dist02 = Math.sqrt(v02.x * v02.x + v02.y * v02.y + v02.z * v02.z);
    const dist12 = Math.sqrt(v12.x * v12.x + v12.y * v12.y + v12.z * v12.z);

    let distMax = dist01 > dist02 ? dist01 : dist02;
    distMax = dist12 > distMax ? dist12 : distMax;
    const ITERS_ESTIMATE = 1.2;
    const numIters = Math.floor(distMax * ITERS_ESTIMATE);

    const vLScale = new THREE.Vector3();
    const vRScale = new THREE.Vector3();

    vLScale.x = v01.x / numIters;
    vLScale.y = v01.y / numIters;
    vLScale.z = v01.z / numIters;

    vRScale.x = v02.x / numIters;
    vRScale.y = v02.y / numIters;
    vRScale.z = v02.z / numIters;

    const vL = new THREE.Vector3(verts[0].x, verts[0].y, verts[0].z);
    const vR = new THREE.Vector3(verts[0].x, verts[0].y, verts[0].z);
    const vLR = new THREE.Vector3();
    const vScale = new THREE.Vector3();
    const v = new THREE.Vector3();

    for (let iterSide = 0; iterSide <= numIters; iterSide++) {
      vLR.x = vR.x - vL.x;
      vLR.y = vR.y - vL.y;
      vLR.z = vR.z - vL.z;

      vScale.x = vLR.x / numIters;
      vScale.y = vLR.y / numIters;
      vScale.z = vLR.z / numIters;

      v.x = vL.x;
      v.y = vL.y;
      v.z = vL.z;

      const VIS = 255;
      // interpolate between vL <-> vR
      for (let i = 0; i <= numIters; i++) {
        let x = Math.floor(v.x);
        let y = Math.floor(v.y);
        let z = Math.floor(v.z);

        if (x >= 0 && y >= 0 && z >= 0 && x < xDim && y < yDim && z < zDim) {
          const off = x + y * xDim + z * xyDim;
          pixels[off] = VIS;
        }

        // try to fill neighb
        x = Math.floor(v.x) + 1;
        y = Math.floor(v.y) + 0;
        z = Math.floor(v.z) + 0;
        if (x >= 0 && y >= 0 && z >= 0 && x < xDim && y < yDim && z < zDim) {
          const off = x + y * xDim + z * xyDim;
          pixels[off] = VIS;
        }

        x = Math.floor(v.x) + 0;
        y = Math.floor(v.y) + 1;
        z = Math.floor(v.z) + 0;
        if (x >= 0 && y >= 0 && z >= 0 && x < xDim && y < yDim && z < zDim) {
          const off = x + y * xDim + z * xyDim;
          pixels[off] = VIS;
        }

        x = Math.floor(v.x) + 0;
        y = Math.floor(v.y) + 0;
        z = Math.floor(v.z) + 1;
        if (x >= 0 && y >= 0 && z >= 0 && x < xDim && y < yDim && z < zDim) {
          const off = x + y * xDim + z * xyDim;
          pixels[off] = VIS;
        }

        x = Math.floor(v.x) - 1;
        y = Math.floor(v.y) + 0;
        z = Math.floor(v.z) + 0;
        if (x >= 0 && y >= 0 && z >= 0 && x < xDim && y < yDim && z < zDim) {
          const off = x + y * xDim + z * xyDim;
          pixels[off] = VIS;
        }

        x = Math.floor(v.x) + 0;
        y = Math.floor(v.y) - 1;
        z = Math.floor(v.z) + 0;
        if (x >= 0 && y >= 0 && z >= 0 && x < xDim && y < yDim && z < zDim) {
          const off = x + y * xDim + z * xyDim;
          pixels[off] = VIS;
        }
        x = Math.floor(v.x) + 0;
        y = Math.floor(v.y) + 0;
        z = Math.floor(v.z) - 1;
        if (x >= 0 && y >= 0 && z >= 0 && x < xDim && y < yDim && z < zDim) {
          const off = x + y * xDim + z * xyDim;
          pixels[off] = VIS;
        }
        // next v
        v.x += vScale.x;
        v.y += vScale.y;
        v.z += vScale.z;
      }
      // next L, R
      vL.x += vLScale.x;
      vL.y += vLScale.y;
      vL.z += vLScale.z;

      vR.x += vRScale.x;
      vR.y += vRScale.y;
      vR.z += vRScale.z;
    }
  }