modify method

dynamic modify(BufferGeometry geometry)

Implementation

modify(BufferGeometry geometry) {
  if (geometry.index != null) {
    geometry = geometry.toNonIndexed();
  }

  //

  var maxIterations = this.maxIterations;
  var maxEdgeLengthSquared = maxEdgeLength * maxEdgeLength;

  var va = Vector3.init();
  var vb = Vector3.init();
  var vc = Vector3.init();
  var vm = Vector3.init();
  var vs = [va, vb, vc, vm];

  var na = Vector3.init();
  var nb = Vector3.init();
  var nc = Vector3.init();
  var nm = Vector3.init();
  var ns = [na, nb, nc, nm];

  var ca = Color(1, 1, 1);
  var cb = Color(1, 1, 1);
  var cc = Color(1, 1, 1);
  var cm = Color(1, 1, 1);
  var cs = [ca, cb, cc, cm];

  var ua = Vector2(null, null);
  var ub = Vector2(null, null);
  var uc = Vector2(null, null);
  var um = Vector2(null, null);
  var us = [ua, ub, uc, um];

  var u2a = Vector2(null, null);
  var u2b = Vector2(null, null);
  var u2c = Vector2(null, null);
  var u2m = Vector2(null, null);
  var u2s = [u2a, u2b, u2c, u2m];

  var attributes = geometry.attributes;
  var hasNormals = attributes["normal"] != null;
  var hasColors = attributes["color"] != null;
  var hasUVs = attributes["uv"] != null;
  var hasUV2s = attributes["uv2"] != null;

  var positions = attributes["position"].array;
  var normals = hasNormals ? attributes["normal"].array : null;
  var colors = hasColors ? attributes["color"].array : null;
  var uvs = hasUVs ? attributes["uv"].array : null;
  var uv2s = hasUV2s ? attributes["uv2"].array : null;

  var positions2 = positions;
  var normals2 = normals;
  var colors2 = colors;
  var uvs2 = uvs;
  var uv2s2 = uv2s;

  var iteration = 0;
  var tessellating = true;

  void addTriangle(int a, int b, int c) {
    var v1 = vs[a];
    var v2 = vs[b];
    var v3 = vs[c];

    positions2.push(v1.x, v1.y, v1.z);
    positions2.push(v2.x, v2.y, v2.z);
    positions2.push(v3.x, v3.y, v3.z);

    if (hasNormals) {
      var n1 = ns[a];
      var n2 = ns[b];
      var n3 = ns[c];

      normals2.push(n1.x, n1.y, n1.z);
      normals2.push(n2.x, n2.y, n2.z);
      normals2.push(n3.x, n3.y, n3.z);
    }

    if (hasColors) {
      var c1 = cs[a];
      var c2 = cs[b];
      var c3 = cs[c];

      colors2.push(c1.r, c1.g, c1.b);
      colors2.push(c2.r, c2.g, c2.b);
      colors2.push(c3.r, c3.g, c3.b);
    }

    if (hasUVs) {
      var u1 = us[a];
      var u2 = us[b];
      var u3 = us[c];

      uvs2.push(u1.x, u1.y);
      uvs2.push(u2.x, u2.y);
      uvs2.push(u3.x, u3.y);
    }

    if (hasUV2s) {
      var u21 = u2s[a];
      var u22 = u2s[b];
      var u23 = u2s[c];

      uv2s2.push(u21.x, u21.y);
      uv2s2.push(u22.x, u22.y);
      uv2s2.push(u23.x, u23.y);
    }
  }

  while (tessellating && iteration < maxIterations) {
    iteration++;
    tessellating = false;

    positions = positions2;
    positions2 = [];

    if (hasNormals) {
      normals = normals2;
      normals2 = [];
    }

    if (hasColors) {
      colors = colors2;
      colors2 = [];
    }

    if (hasUVs) {
      uvs = uvs2;
      uvs2 = [];
    }

    if (hasUV2s) {
      uv2s = uv2s2;
      uv2s2 = [];
    }

    for (var i = 0, i2 = 0, il = positions.length; i < il; i += 9, i2 += 6) {
      va.fromArray(positions, i + 0);
      vb.fromArray(positions, i + 3);
      vc.fromArray(positions, i + 6);

      if (hasNormals) {
        na.fromArray(normals, i + 0);
        nb.fromArray(normals, i + 3);
        nc.fromArray(normals, i + 6);
      }

      if (hasColors) {
        ca.fromArray(colors, i + 0);
        cb.fromArray(colors, i + 3);
        cc.fromArray(colors, i + 6);
      }

      if (hasUVs) {
        ua.fromArray(uvs, i2 + 0);
        ub.fromArray(uvs, i2 + 2);
        uc.fromArray(uvs, i2 + 4);
      }

      if (hasUV2s) {
        u2a.fromArray(uv2s, i2 + 0);
        u2b.fromArray(uv2s, i2 + 2);
        u2c.fromArray(uv2s, i2 + 4);
      }

      var dab = va.distanceToSquared(vb);
      var dbc = vb.distanceToSquared(vc);
      var dac = va.distanceToSquared(vc);

      if (dab > maxEdgeLengthSquared || dbc > maxEdgeLengthSquared || dac > maxEdgeLengthSquared) {
        tessellating = true;

        if (dab >= dbc && dab >= dac) {
          vm.lerpVectors(va, vb, 0.5);
          if (hasNormals) nm.lerpVectors(na, nb, 0.5);
          if (hasColors) cm.lerpColors(ca, cb, 0.5);
          if (hasUVs) um.lerpVectors(ua, ub, 0.5);
          if (hasUV2s) u2m.lerpVectors(u2a, u2b, 0.5);

          addTriangle(0, 3, 2);
          addTriangle(3, 1, 2);
        } else if (dbc >= dab && dbc >= dac) {
          vm.lerpVectors(vb, vc, 0.5);
          if (hasNormals) nm.lerpVectors(nb, nc, 0.5);
          if (hasColors) cm.lerpColors(cb, cc, 0.5);
          if (hasUVs) um.lerpVectors(ub, uc, 0.5);
          if (hasUV2s) u2m.lerpVectors(u2b, u2c, 0.5);

          addTriangle(0, 1, 3);
          addTriangle(3, 2, 0);
        } else {
          vm.lerpVectors(va, vc, 0.5);
          if (hasNormals) nm.lerpVectors(na, nc, 0.5);
          if (hasColors) cm.lerpColors(ca, cc, 0.5);
          if (hasUVs) um.lerpVectors(ua, uc, 0.5);
          if (hasUV2s) u2m.lerpVectors(u2a, u2c, 0.5);

          addTriangle(0, 1, 3);
          addTriangle(3, 1, 2);
        }
      } else {
        addTriangle(0, 1, 2);
      }
    }
  }

  var geometry2 = BufferGeometry();

  geometry2.setAttribute('position', Float32BufferAttribute(positions2, 3, false));

  if (hasNormals) {
    geometry2.setAttribute('normal', Float32BufferAttribute(normals2, 3, false));
  }

  if (hasColors) {
    geometry2.setAttribute('color', Float32BufferAttribute(colors2, 3, false));
  }

  if (hasUVs) {
    geometry2.setAttribute('uv', Float32BufferAttribute(uvs2, 2, false));
  }

  if (hasUV2s) {
    geometry2.setAttribute('uv2', Float32BufferAttribute(uv2s2, 2, false));
  }

  return geometry2;
}