polygonize method

int polygonize(dynamic fx, dynamic fy, dynamic fz, int q, dynamic isol,)

Implementation

int polygonize( fx, fy, fz,int q, isol ) {
  // cache indices
  final q1 = q + 1;
  final qy = q + yd;
  final qz = q + zd;
  final q1y = q1 + yd;
  final q1z = q1 + zd;
  final qyz = q + yd + zd;
  final q1yz = q1 + yd + zd;

  int cubeindex = 0;
  final field0 = field[q],
  field1 = field[ q1 ],
  field2 = field[ qy ],
  field3 = field[ q1y ],
  field4 = field[ qz ],
  field5 = field[ q1z ],
  field6 = field[ qyz ],
  field7 = field[ q1yz ];

  if ( field0 < isol ) cubeindex |= 1;
  if ( field1 < isol ) cubeindex |= 2;
  if ( field2 < isol ) cubeindex |= 8;
  if ( field3 < isol ) cubeindex |= 4;
  if ( field4 < isol ) cubeindex |= 16;
  if ( field5 < isol ) cubeindex |= 32;
  if ( field6 < isol ) cubeindex |= 128;
  if ( field7 < isol ) cubeindex |= 64;

  // if cube is entirely in/out of the surface - bail, nothing to draw

  final bits = edgeTable[ cubeindex ];
  if ( bits == 0 ) return 0;

  final d = delta,
    fx2 = fx + d,
    fy2 = fy + d,
    fz2 = fz + d;

  // top of the cube
  if(bits & 1 != 0){
    compNorm( q );
    compNorm( q1 );
    vIntX( q * 3, 0, isol, fx, fy, fz, field0, field1, q, q1 );
  }

  if(bits & 2 != 0){
    compNorm( q1 );
    compNorm( q1y );
    vIntY( q1 * 3, 3, isol, fx2, fy, fz, field1, field3, q1, q1y );
  }

  if(bits & 4 != 0){
    compNorm( qy );
    compNorm( q1y );
    vIntX( qy * 3, 6, isol, fx, fy2, fz, field2, field3, qy, q1y );
  }

  if(bits & 8 != 0){
    compNorm( q );
    compNorm( qy );
    vIntY( q * 3, 9, isol, fx, fy, fz, field0, field2, q, qy );
  }

  // bottom of the cube

  if(bits & 16 != 0){
    compNorm( qz );
    compNorm( q1z );
    vIntX( qz * 3, 12, isol, fx, fy, fz2, field4, field5, qz, q1z );
  }

  if(bits & 32 != 0){
    compNorm( q1z );
    compNorm( q1yz );
    vIntY(
      q1z * 3,
      15,
      isol,
      fx2,
      fy,
      fz2,
      field5,
      field7,
      q1z,
      q1yz
    );
  }

  if(bits & 64 != 0){
    compNorm( qyz );
    compNorm( q1yz );
    vIntX(
      qyz * 3,
      18,
      isol,
      fx,
      fy2,
      fz2,
      field6,
      field7,
      qyz,
      q1yz
    );
  }

  if(bits & 128 != 0){
    compNorm( qz );
    compNorm( qyz );
    vIntY( qz * 3, 21, isol, fx, fy, fz2, field4, field6, qz, qyz );
  }

  // vertical lines of the cube
  if(bits & 256 != 0){
    compNorm( q );
    compNorm( qz );
    vIntZ( q * 3, 24, isol, fx, fy, fz, field0, field4, q, qz );
  }

  if(bits & 512 != 0){
    compNorm( q1 );
    compNorm( q1z );
    vIntZ( q1 * 3, 27, isol, fx2, fy, fz, field1, field5, q1, q1z );
  }

  if(bits & 1024 != 0){
    compNorm( q1y );
    compNorm( q1yz );
    vIntZ(
      q1y * 3,
      30,
      isol,
      fx2,
      fy2,
      fz,
      field3,
      field7,
      q1y,
      q1yz
    );
  }

  if(bits & 2048 != 0){
    compNorm( qy );
    compNorm( qyz );
    vIntZ( qy * 3, 33, isol, fx, fy2, fz, field2, field6, qy, qyz );
  }

  cubeindex <<= 4; // re-purpose cubeindex into an offset into triTable

  int numtris = 0;
  int i = 0;

  // here is where triangles are created

  while ( triTable[ cubeindex + i ] != - 1 ) {
    int o1 = cubeindex + i;
    int o2 = o1 + 1;
    int o3 = o1 + 2;

    posnormtriv(
      vlist,
      nlist,
      clist,
      3 * triTable[ o1 ],
      3 * triTable[ o2 ],
      3 * triTable[ o3 ]
    );

    i += 3;
    numtris ++;
  }

  return numtris;
}