/src/tinyobjloader/tobj_tess_impl.inc

Source
/*
 * tobj_tess_impl.inc -- per-precision projection + dispatch.
 * Included twice from tobj_tess.c. Do not include directly.
 */

/* Project the 3D ring into w->p2d (double). Returns 1 normally, 0 if the
 * polygon is fully degenerate (collinear/zero-area) and a bbox fallback was
 * used. Never fails. */
static int TOBJ_TESS_T(tobj_tess_project)(const TOBJ_TESS_REAL *pts, uint32_t n,
                                          const TOBJ_TESS_REAL *given_normal,
                                          uint32_t flags, tobj_tess_work *w) {
  double cx = (double)pts[0], cy = (double)pts[1], cz = (double)pts[2];
  double coordmax = 0.0;
  for (uint32_t i = 0; i < 3u * n; i++) {
    double a = tobj_dabs((double)pts[i]);
    if (a > coordmax) coordmax = a;
  }

  double nx = 0, ny = 0, nz = 0;
  if (flags & TOBJ_TESS_FLAG_NORMAL_GIVEN) {
    nx = (double)given_normal[0];
    ny = (double)given_normal[1];
    nz = (double)given_normal[2];
  } else {
    for (uint32_t k = 0; k < n; k++) {
      uint32_t j = (k + 1u) % n;
      double ax = (double)pts[3 * k], ay = (double)pts[3 * k + 1],
             az = (double)pts[3 * k + 2];
      double bx = (double)pts[3 * j], by = (double)pts[3 * j + 1],
             bz = (double)pts[3 * j + 2];
      nx += (ay - by) * (az + bz);
      ny += (az - bz) * (ax + bx);
      nz += (ax - bx) * (ay + by);
    }
  }
  double len2 = nx * nx + ny * ny + nz * nz;
  double cm2 = coordmax * coordmax;
  double thresh = cm2 * cm2 * TOBJ_TESS_REL_N;

  if (tobj_is_finite(len2) && len2 > thresh && len2 > 0.0) {
    /* in-plane basis (unnormalized: only orientation signs matter) */
    double wx = nx, wy = ny, wz = nz;
    double ax = tobj_dabs(wx), ay = tobj_dabs(wy), az = tobj_dabs(wz);
    double sx = 0, sy = 0, sz = 0;
    if (ax <= ay && ax <= az)
      sx = 1;
    else if (ay <= az)
      sy = 1;
    else
      sz = 1;
    /* u = w x s, v = w x u */
    double ux = wy * sz - wz * sy;
    double uy = wz * sx - wx * sz;
    double uz = wx * sy - wy * sx;
    double vx = wy * uz - wz * uy;
    double vy = wz * ux - wx * uz;
    double vz = wx * uy - wy * ux;
    for (uint32_t k = 0; k < n; k++) {
      double dx = (double)pts[3 * k] - cx;
      double dy = (double)pts[3 * k + 1] - cy;
      double dz = (double)pts[3 * k + 2] - cz;
      w->p2d[2 * k] = dx * ux + dy * uy + dz * uz;
      w->p2d[2 * k + 1] = dx * vx + dy * vy + dz * vz;
    }
    return 1;
  }

  /* Fallback: drop the smallest-extent axis, keep the other two raw axes. */
  double mn[3], mx[3];
  mn[0] = mx[0] = (double)pts[0];
  mn[1] = mx[1] = (double)pts[1];
  mn[2] = mx[2] = (double)pts[2];
  for (uint32_t k = 0; k < n; k++) {
    for (int c = 0; c < 3; c++) {
      double v = (double)pts[3 * k + c];
      if (v < mn[c]) mn[c] = v;
      if (v > mx[c]) mx[c] = v;
    }
  }
  double span[3] = {mx[0] - mn[0], mx[1] - mn[1], mx[2] - mn[2]};
  int drop = 0;
  if (span[1] < span[0]) drop = 1;
  if (span[2] < span[drop]) drop = 2;
  int a0 = (drop == 0) ? 1 : 0;
  int a1 = (drop == 2) ? 1 : 2;
  for (uint32_t k = 0; k < n; k++) {
    w->p2d[2 * k] = (double)pts[3 * k + a0] - (drop == 0 ? cy : cx);
    w->p2d[2 * k + 1] =
        (double)pts[3 * k + a1] - ((drop == 2) ? cy : cz);
  }
  return 0;
}

tobj_tess_status TOBJ_TESS_T(tobj_tess_polygon)(
    const TOBJ_TESS_T(tobj_tess_desc) * desc, tobj_tess_result *result) {
  result->indices = NULL;
  result->num_triangles = 0;
  result->indices_allocated = 0;
  result->status = TOBJ_TESS_INVALID;

  if (!desc || !desc->points) return TOBJ_TESS_INVALID;
  uint32_t n = desc->n;
  if (n < 3) return TOBJ_TESS_INVALID;

  /* reject non-finite coordinates */
  for (uint32_t i = 0; i < 3u * n; i++) {
    if (!tobj_is_finite((double)desc->points[i])) return TOBJ_TESS_INVALID;
  }

  uint32_t tri = n - 2u;
  uint32_t need_out = tri * 3u;

  /* resolve output buffer */
  uint32_t *out = NULL;
  int out_alloc = 0;
  if (desc->out_indices && desc->out_cap >= need_out) {
    out = desc->out_indices;
  } else if (desc->alloc && desc->alloc->alloc) {
    out = (uint32_t *)desc->alloc->alloc(desc->alloc->ud,
                                         need_out * sizeof(uint32_t));
    if (!out) {
      result->status = TOBJ_TESS_OOM;
      return TOBJ_TESS_OOM;
    }
    out_alloc = 1;
  } else {
    result->status = TOBJ_TESS_OOM;
    return TOBJ_TESS_OOM;
  }

  /* resolve scratch */
  size_t need_scratch = tobj_tess_scratch_size(n);
  void *scratch = NULL;
  int scratch_alloc = 0;
  unsigned char stackbuf[TOBJ_TESS_STACK_BYTES];
  if (desc->scratch && desc->scratch_size >= need_scratch) {
    scratch = desc->scratch;
  } else if (n <= TOBJ_TESS_STACK_N && need_scratch <= sizeof(stackbuf)) {
    scratch = stackbuf;
  } else if (desc->alloc && desc->alloc->alloc) {
    scratch = desc->alloc->alloc(desc->alloc->ud, need_scratch);
    if (!scratch) {
      if (out_alloc) desc->alloc->free(desc->alloc->ud, out);
      result->status = TOBJ_TESS_OOM;
      return TOBJ_TESS_OOM;
    }
    scratch_alloc = 1;
  } else {
    if (out_alloc && desc->alloc) desc->alloc->free(desc->alloc->ud, out);
    result->status = TOBJ_TESS_OOM;
    return TOBJ_TESS_OOM;
  }

  tobj_tess_work w;
  tobj_tess_work_bind(&w, scratch, need_scratch, n);

  int proj_ok =
      TOBJ_TESS_T(tobj_tess_project)(desc->points, n, desc->normal,
                                     desc->flags, &w);

  tobj_tess_status status;
  uint32_t k = 0;

  if (n == 3) {
    tobj_tess_emit(out, &k, 0, 1, 2);
    double ar = tobj_dabs(tobj_orient2d(&w.p2d[0], &w.p2d[2], &w.p2d[4]));
    double scale = tobj_tess_scale2d(w.p2d, n);
    status = ar <= scale * scale * TOBJ_TESS_REL ? TOBJ_TESS_DEGENERATE_BESTEFFORT
                                                 : TOBJ_TESS_OK;
  } else if (n == 4) {
    double scale = tobj_tess_scale2d(w.p2d, n);
    double eps = scale * scale * TOBJ_TESS_REL;
    const double *p0 = &w.p2d[0], *p1 = &w.p2d[2], *p2 = &w.p2d[4],
                 *p3 = &w.p2d[6];
    double o012 = tobj_orient2d(p0, p1, p2);
    double o023 = tobj_orient2d(p0, p2, p3);
    double o123 = tobj_orient2d(p1, p2, p3);
    double o130 = tobj_orient2d(p1, p3, p0);
    int d02 = (tobj_dabs(o012) > eps && tobj_dabs(o023) > eps &&
               ((o012 > 0) == (o023 > 0)));
    int d13 = (tobj_dabs(o123) > eps && tobj_dabs(o130) > eps &&
               ((o123 > 0) == (o130 > 0)));
    int split02;
    status = TOBJ_TESS_OK;
    if (d02 && !d13) {
      split02 = 1;
    } else if (d13 && !d02) {
      split02 = 0;
    } else {
      /* convex (both internal) or degenerate (neither): shorter 3D diagonal */
      const TOBJ_TESS_REAL *q = desc->points;
      double e02x = (double)q[6] - (double)q[0];
      double e02y = (double)q[7] - (double)q[1];
      double e02z = (double)q[8] - (double)q[2];
      double e13x = (double)q[9] - (double)q[3];
      double e13y = (double)q[10] - (double)q[4];
      double e13z = (double)q[11] - (double)q[5];
      double s02 = e02x * e02x + e02y * e02y + e02z * e02z;
      double s13 = e13x * e13x + e13y * e13y + e13z * e13z;
      split02 = s02 <= s13;
      if (!d02 && !d13) status = TOBJ_TESS_DEGENERATE_BESTEFFORT;
    }
    if (split02) {
      tobj_tess_emit(out, &k, 0, 1, 2);
      tobj_tess_emit(out, &k, 0, 2, 3);
    } else {
      tobj_tess_emit(out, &k, 0, 1, 3);
      tobj_tess_emit(out, &k, 1, 2, 3);
    }
  } else {
    status = tobj_tess_run2d(&w, n, out, desc->flags);
  }

  if (!proj_ok && status == TOBJ_TESS_OK) status = TOBJ_TESS_DEGENERATE_BESTEFFORT;

  if (scratch_alloc) desc->alloc->free(desc->alloc->ud, scratch);

  result->indices = out;
  result->num_triangles = tri;
  result->indices_allocated = out_alloc;
  result->status = status;
  return status;
}

Coverage Report

Created: 2026-09-04 06:42