30         int3(
int _x, 
int _y, 
int _z)
 
   74         potentialVertex += n3n1;
 
   75         potentialVertex += n1n2;
 
   76         potentialVertex *= quotient;
 
   93         return p0 + (dif * t);
 
  139 #define SPLIT (OVER | UNDER) 
  140 #define PAPERWIDTH (btScalar(0.001)) 
  149         edges.resize(edges_size);
 
  207         for (
int i = 0; i < count; i++)
 
  210                         if (m == -1 || 
btDot(p[i], dir) > 
btDot(p[m], dir))
 
  239                 if (allow[m] == 3) 
return m;
 
  248                         if (ma == m && mb == m)
 
  253                         if (ma != -1 && ma != mb)  
 
  261                                         if (mc == m && md == m)
 
  281         for (
int i = 0; i < 3; i++)
 
  283                 if (a[i] != b[i]) 
return 0;
 
  292         return (
btDot(n, p - vertices[t[0]]) > epsilon);  
 
  297         for (
int i = 0; i < 3; i++)
 
  299                 int i1 = (i + 1) % 3;
 
  300                 if (t[i] == a && t[i1] == b) 
return 1;
 
  307         return (t[0] == v || t[1] == v || t[2] == v);
 
  313         for (i = 0; i < 3; i++)
 
  315                 int i1 = (i + 1) % 3;
 
  316                 if (
hasedge(a, b[i1], b[i])) 
return 1;
 
  338         int &
neib(
int a, 
int b);
 
  345         for (i = 0; i < 3; i++)
 
  347                 int i1 = (i + 1) % 3;
 
  348                 int i2 = (i + 2) % 3;
 
  349                 if ((*
this)[i] == a && (*this)[i1] == b) 
return n[i2];
 
  350                 if ((*
this)[i] == b && (*this)[i1] == a) 
return n[i2];
 
  358         for (i = 0; i < 3; i++)
 
  360                 int i1 = (i + 1) % 3;
 
  361                 int i2 = (i + 2) % 3;
 
  385         for (i = 0; i < 3; i++)
 
  387                 int i1 = (i + 1) % 3;
 
  388                 int i2 = (i + 2) % 3;
 
  426         ta->
n = 
int3(t0->
n[0], n + 1, n + 2);
 
  427         m_tris[t0->
n[0]]->neib(t[1], t[2]) = n + 0;
 
  429         tb->
n = 
int3(t0->
n[1], n + 2, n + 0);
 
  430         m_tris[t0->
n[1]]->neib(t[2], t[0]) = n + 1;
 
  432         tc->
n = 
int3(t0->
n[2], n + 0, n + 1);
 
  433         m_tris[t0->
n[2]]->neib(t[0], t[1]) = n + 2;
 
  454         return (t->
rise > epsilon) ? t : NULL;
 
  461         int p0 = 
maxdirsterid(verts, verts_count, basis[0], allow);
 
  462         int p1 = 
maxdirsterid(verts, verts_count, -basis[0], allow);
 
  463         basis[0] = verts[p0] - verts[p1];
 
  464         if (p0 == p1 || basis[0] == 
btVector3(0, 0, 0))
 
  465                 return int4(-1, -1, -1, -1);
 
  477         int p2 = 
maxdirsterid(verts, verts_count, basis[1], allow);
 
  478         if (p2 == p0 || p2 == p1)
 
  480                 p2 = 
maxdirsterid(verts, verts_count, -basis[1], allow);
 
  482         if (p2 == p0 || p2 == p1)
 
  483                 return int4(-1, -1, -1, -1);
 
  484         basis[1] = verts[p2] - verts[p0];
 
  486         int p3 = 
maxdirsterid(verts, verts_count, basis[2], allow);
 
  487         if (p3 == p0 || p3 == p1 || p3 == p2) p3 = 
maxdirsterid(verts, verts_count, -basis[2], allow);
 
  488         if (p3 == p0 || p3 == p1 || p3 == p2)
 
  489                 return int4(-1, -1, -1, -1);
 
  490         btAssert(!(p0 == p1 || p0 == p2 || p0 == p3 || p1 == p2 || p1 == p3 || p2 == p3));
 
  491         if (
btDot(verts[p3] - verts[p0], 
btCross(verts[p1] - verts[p0], verts[p2] - verts[p0])) < 0)
 
  495         return int4(p0, p1, p2, p3);
 
  500         if (verts_count < 4) 
return 0;
 
  501         if (vlimit == 0) vlimit = 1000000000;
 
  505         isextreme.
reserve(verts_count);
 
  509         for (j = 0; j < verts_count; j++)
 
  513                 bmin.setMin(verts[j]);
 
  520         if (p.
x == -1) 
return 0;  
 
  522         btVector3 center = (verts[p[0]] + verts[p[1]] + verts[p[2]] + verts[p[3]]) / 
btScalar(4.0);  
 
  524         t0->
n = 
int3(2, 3, 1);
 
  526         t1->
n = 
int3(3, 2, 0);
 
  528         t2->
n = 
int3(0, 1, 3);
 
  530         t3->
n = 
int3(1, 0, 2);
 
  531         isextreme[p[0]] = isextreme[p[1]] = isextreme[p[2]] = isextreme[p[3]] = 1;
 
  548         while (vlimit > 0 && ((te = 
extrudable(epsilon)) != 0))
 
  573                         if (
above(verts, nt, center, 
btScalar(0.01) * epsilon) || 
btCross(verts[nt[1]] - verts[nt[0]], verts[nt[2]] - verts[nt[1]]).
length() < epsilon * epsilon * 
btScalar(0.1))
 
  588                         if (t->
vmax >= 0) 
break;
 
  591                         if (isextreme[t->
vmax])
 
  616                         for (
int j = 0; j < 3; j++)
 
  621         tris_count = ts.
size() / 3;
 
  624         for (i = 0; i < ts.
size(); i++)
 
  626                 tris_out[i] = static_cast<unsigned int>(ts[i]);
 
  637         if (!ret) 
return false;
 
  638         result.
mIndexCount = (
unsigned int)(tris_count * 3);
 
  641         result.
mVcount = (
unsigned int)vcount;
 
  677         unsigned int vcount = desc.
mVcount;
 
  678         if (vcount < 8) vcount = 8;
 
  681         vertexSource.
resize(static_cast<int>(vcount));
 
  685         unsigned int ovcount;
 
  693                         for (
unsigned int i = 0; i < ovcount; i++)
 
  695                                 btVector3 &v = vertexSource[static_cast<int>(i)];
 
  728                                         const unsigned int *source = &hr.
m_Indices[0];
 
  729                                         unsigned int *dest = &result.
m_Indices[0];
 
  731                                         for (
unsigned int i = 0; i < hr.
mFaceCount; i++)
 
  757                                         const unsigned int *source = &hr.
m_Indices[0];
 
  758                                         unsigned int *dest = &result.
m_Indices[0];
 
  759                                         for (
unsigned int i = 0; i < hr.
mFaceCount; i++)
 
  819         return dx * dx + dy * dy + dz * dz;
 
  825                                                                   unsigned int &vcount,  
 
  830         if (svcount == 0) 
return false;
 
  834 #define EPSILON btScalar(0.000001)  
  838         btScalar recip[3] = {0.f, 0.f, 0.f};
 
  847         btScalar bmin[3] = {FLT_MAX, FLT_MAX, FLT_MAX};
 
  848         btScalar bmax[3] = {-FLT_MAX, -FLT_MAX, -FLT_MAX};
 
  850         const char *vtx = (
const char *)svertices;
 
  854                 for (
unsigned int i = 0; i < svcount; i++)
 
  860                         for (
int j = 0; j < 3; j++)
 
  862                                 if (p[j] < bmin[j]) bmin[j] = p[j];
 
  863                                 if (p[j] > bmax[j]) bmax[j] = p[j];
 
  874         center[0] = dx * 
btScalar(0.5) + bmin[0];
 
  875         center[1] = dy * 
btScalar(0.5) + bmin[1];
 
  876         center[2] = dz * 
btScalar(0.5) + bmin[2];
 
  882                 if (dx > 
EPSILON && dx < len) len = dx;
 
  883                 if (dy > 
EPSILON && dy < len) len = dy;
 
  884                 if (dz > 
EPSILON && dz < len) len = dz;
 
  906                 addPoint(vcount, vertices, x1, y1, z1);
 
  907                 addPoint(vcount, vertices, x2, y1, z1);
 
  908                 addPoint(vcount, vertices, x2, y2, z1);
 
  909                 addPoint(vcount, vertices, x1, y2, z1);
 
  910                 addPoint(vcount, vertices, x1, y1, z2);
 
  911                 addPoint(vcount, vertices, x2, y1, z2);
 
  912                 addPoint(vcount, vertices, x2, y2, z2);
 
  913                 addPoint(vcount, vertices, x1, y2, z2);
 
  929                         center[0] *= recip[0];
 
  930                         center[1] *= recip[1];
 
  931                         center[2] *= recip[2];
 
  935         vtx = (
const char *)svertices;
 
  937         for (
unsigned int i = 0; i < svcount; i++)
 
  957                         for (j = 0; j < vcount; j++)
 
  970                                 if (dx < normalepsilon && dy < normalepsilon && dz < normalepsilon)
 
 1005                 btScalar bmin[3] = {FLT_MAX, FLT_MAX, FLT_MAX};
 
 1006                 btScalar bmax[3] = {-FLT_MAX, -FLT_MAX, -FLT_MAX};
 
 1008                 for (
unsigned int i = 0; i < vcount; i++)
 
 1011                         for (
int j = 0; j < 3; j++)
 
 1013                                 if (p[j] < bmin[j]) bmin[j] = p[j];
 
 1014                                 if (p[j] > bmax[j]) bmax[j] = p[j];
 
 1030                         if (dx >= 
EPSILON && dx < len) len = dx;
 
 1031                         if (dy >= 
EPSILON && dy < len) len = dy;
 
 1032                         if (dz >= 
EPSILON && dz < len) len = dz;
 
 1056                         addPoint(vcount, vertices, x1, y1, z1);
 
 1057                         addPoint(vcount, vertices, x2, y1, z1);
 
 1058                         addPoint(vcount, vertices, x2, y2, z1);
 
 1059                         addPoint(vcount, vertices, x1, y2, z1);
 
 1060                         addPoint(vcount, vertices, x1, y1, z2);
 
 1061                         addPoint(vcount, vertices, x2, y1, z2);
 
 1062                         addPoint(vcount, vertices, x2, y2, z2);
 
 1063                         addPoint(vcount, vertices, x1, y2, z2);
 
 1084         usedIndices.
resize(static_cast<int>(vcount));
 
 1085         memset(&usedIndices[0], 0, 
sizeof(
unsigned int) * vcount);
 
 1089         for (i = 0; i < int(indexcount); i++)
 
 1091                 unsigned int v = indices[i];  
 
 1095                 if (usedIndices[static_cast<int>(v)])  
 
 1097                         indices[i] = usedIndices[static_cast<int>(v)] - 1;  
 
 1101                         indices[i] = ocount;  
 
 1103                         overts[ocount][0] = verts[v][0];  
 
 1104                         overts[ocount][1] = verts[v][1];
 
 1105                         overts[ocount][2] = verts[v][2];
 
 1109                                 if (tmpIndices[k] == 
int(v))
 
 1115                         btAssert(ocount >= 0 && ocount <= vcount);
 
 1117                         usedIndices[static_cast<int>(v)] = ocount;