1122 lines
28 KiB
C++
1122 lines
28 KiB
C++
/*
|
|
Stan Melax Convex Hull Computation
|
|
Copyright (c) 2003-2006 Stan Melax http://www.melax.com/
|
|
|
|
This software is provided 'as-is', without any express or implied warranty.
|
|
In no event will the authors be held liable for any damages arising from the use of this software.
|
|
Permission is granted to anyone to use this software for any purpose,
|
|
including commercial applications, and to alter it and redistribute it freely,
|
|
subject to the following restrictions:
|
|
|
|
1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
|
|
2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
|
|
3. This notice may not be removed or altered from any source distribution.
|
|
*/
|
|
|
|
#include <string.h>
|
|
|
|
#include "btConvexHull.h"
|
|
#include "btAlignedObjectArray.h"
|
|
#include "btMinMax.h"
|
|
#include "btVector3.h"
|
|
|
|
//----------------------------------
|
|
|
|
class int3
|
|
{
|
|
public:
|
|
int x, y, z;
|
|
int3(){};
|
|
int3(int _x, int _y, int _z)
|
|
{
|
|
x = _x;
|
|
y = _y;
|
|
z = _z;
|
|
}
|
|
const int &operator[](int i) const { return (&x)[i]; }
|
|
int &operator[](int i) { return (&x)[i]; }
|
|
};
|
|
|
|
//------- btPlane ----------
|
|
|
|
inline btPlane PlaneFlip(const btPlane &plane) { return btPlane(-plane.normal, -plane.dist); }
|
|
inline int operator==(const btPlane &a, const btPlane &b) { return (a.normal == b.normal && a.dist == b.dist); }
|
|
inline int coplanar(const btPlane &a, const btPlane &b) { return (a == b || a == PlaneFlip(b)); }
|
|
|
|
//--------- Utility Functions ------
|
|
|
|
btVector3 PlaneLineIntersection(const btPlane &plane, const btVector3 &p0, const btVector3 &p1);
|
|
btVector3 PlaneProject(const btPlane &plane, const btVector3 &point);
|
|
|
|
btVector3 ThreePlaneIntersection(const btPlane &p0, const btPlane &p1, const btPlane &p2);
|
|
btVector3 ThreePlaneIntersection(const btPlane &p0, const btPlane &p1, const btPlane &p2)
|
|
{
|
|
btVector3 N1 = p0.normal;
|
|
btVector3 N2 = p1.normal;
|
|
btVector3 N3 = p2.normal;
|
|
|
|
btVector3 n2n3;
|
|
n2n3 = N2.cross(N3);
|
|
btVector3 n3n1;
|
|
n3n1 = N3.cross(N1);
|
|
btVector3 n1n2;
|
|
n1n2 = N1.cross(N2);
|
|
|
|
btScalar quotient = (N1.dot(n2n3));
|
|
|
|
btAssert(btFabs(quotient) > btScalar(0.000001));
|
|
|
|
quotient = btScalar(-1.) / quotient;
|
|
n2n3 *= p0.dist;
|
|
n3n1 *= p1.dist;
|
|
n1n2 *= p2.dist;
|
|
btVector3 potentialVertex = n2n3;
|
|
potentialVertex += n3n1;
|
|
potentialVertex += n1n2;
|
|
potentialVertex *= quotient;
|
|
|
|
btVector3 result(potentialVertex.getX(), potentialVertex.getY(), potentialVertex.getZ());
|
|
return result;
|
|
}
|
|
|
|
btScalar DistanceBetweenLines(const btVector3 &ustart, const btVector3 &udir, const btVector3 &vstart, const btVector3 &vdir, btVector3 *upoint = NULL, btVector3 *vpoint = NULL);
|
|
btVector3 TriNormal(const btVector3 &v0, const btVector3 &v1, const btVector3 &v2);
|
|
btVector3 NormalOf(const btVector3 *vert, const int n);
|
|
|
|
btVector3 PlaneLineIntersection(const btPlane &plane, const btVector3 &p0, const btVector3 &p1)
|
|
{
|
|
// returns the point where the line p0-p1 intersects the plane n&d
|
|
btVector3 dif;
|
|
dif = p1 - p0;
|
|
btScalar dn = btDot(plane.normal, dif);
|
|
btScalar t = -(plane.dist + btDot(plane.normal, p0)) / dn;
|
|
return p0 + (dif * t);
|
|
}
|
|
|
|
btVector3 PlaneProject(const btPlane &plane, const btVector3 &point)
|
|
{
|
|
return point - plane.normal * (btDot(point, plane.normal) + plane.dist);
|
|
}
|
|
|
|
btVector3 TriNormal(const btVector3 &v0, const btVector3 &v1, const btVector3 &v2)
|
|
{
|
|
// return the normal of the triangle
|
|
// inscribed by v0, v1, and v2
|
|
btVector3 cp = btCross(v1 - v0, v2 - v1);
|
|
btScalar m = cp.length();
|
|
if (m == 0) return btVector3(1, 0, 0);
|
|
return cp * (btScalar(1.0) / m);
|
|
}
|
|
|
|
btScalar DistanceBetweenLines(const btVector3 &ustart, const btVector3 &udir, const btVector3 &vstart, const btVector3 &vdir, btVector3 *upoint, btVector3 *vpoint)
|
|
{
|
|
btVector3 cp;
|
|
cp = btCross(udir, vdir).normalized();
|
|
|
|
btScalar distu = -btDot(cp, ustart);
|
|
btScalar distv = -btDot(cp, vstart);
|
|
btScalar dist = (btScalar)fabs(distu - distv);
|
|
if (upoint)
|
|
{
|
|
btPlane plane;
|
|
plane.normal = btCross(vdir, cp).normalized();
|
|
plane.dist = -btDot(plane.normal, vstart);
|
|
*upoint = PlaneLineIntersection(plane, ustart, ustart + udir);
|
|
}
|
|
if (vpoint)
|
|
{
|
|
btPlane plane;
|
|
plane.normal = btCross(udir, cp).normalized();
|
|
plane.dist = -btDot(plane.normal, ustart);
|
|
*vpoint = PlaneLineIntersection(plane, vstart, vstart + vdir);
|
|
}
|
|
return dist;
|
|
}
|
|
|
|
#define COPLANAR (0)
|
|
#define UNDER (1)
|
|
#define OVER (2)
|
|
#define SPLIT (OVER | UNDER)
|
|
#define PAPERWIDTH (btScalar(0.001))
|
|
|
|
btScalar planetestepsilon = PAPERWIDTH;
|
|
|
|
typedef ConvexH::HalfEdge HalfEdge;
|
|
|
|
ConvexH::ConvexH(int vertices_size, int edges_size, int facets_size)
|
|
{
|
|
vertices.resize(vertices_size);
|
|
edges.resize(edges_size);
|
|
facets.resize(facets_size);
|
|
}
|
|
|
|
int PlaneTest(const btPlane &p, const btVector3 &v);
|
|
int PlaneTest(const btPlane &p, const btVector3 &v)
|
|
{
|
|
btScalar a = btDot(v, p.normal) + p.dist;
|
|
int flag = (a > planetestepsilon) ? OVER : ((a < -planetestepsilon) ? UNDER : COPLANAR);
|
|
return flag;
|
|
}
|
|
|
|
int SplitTest(ConvexH &convex, const btPlane &plane);
|
|
int SplitTest(ConvexH &convex, const btPlane &plane)
|
|
{
|
|
int flag = 0;
|
|
for (int i = 0; i < convex.vertices.size(); i++)
|
|
{
|
|
flag |= PlaneTest(plane, convex.vertices[i]);
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
class VertFlag
|
|
{
|
|
public:
|
|
unsigned char planetest;
|
|
unsigned char junk;
|
|
unsigned char undermap;
|
|
unsigned char overmap;
|
|
};
|
|
class EdgeFlag
|
|
{
|
|
public:
|
|
unsigned char planetest;
|
|
unsigned char fixes;
|
|
short undermap;
|
|
short overmap;
|
|
};
|
|
class PlaneFlag
|
|
{
|
|
public:
|
|
unsigned char undermap;
|
|
unsigned char overmap;
|
|
};
|
|
class Coplanar
|
|
{
|
|
public:
|
|
unsigned short ea;
|
|
unsigned char v0;
|
|
unsigned char v1;
|
|
};
|
|
|
|
template <class T>
|
|
int maxdirfiltered(const T *p, int count, const T &dir, btAlignedObjectArray<int> &allow)
|
|
{
|
|
btAssert(count);
|
|
int m = -1;
|
|
for (int i = 0; i < count; i++)
|
|
if (allow[i])
|
|
{
|
|
if (m == -1 || btDot(p[i], dir) > btDot(p[m], dir))
|
|
m = i;
|
|
}
|
|
btAssert(m != -1);
|
|
return m;
|
|
}
|
|
|
|
btVector3 orth(const btVector3 &v);
|
|
btVector3 orth(const btVector3 &v)
|
|
{
|
|
btVector3 a = btCross(v, btVector3(0, 0, 1));
|
|
btVector3 b = btCross(v, btVector3(0, 1, 0));
|
|
if (a.length() > b.length())
|
|
{
|
|
return a.normalized();
|
|
}
|
|
else
|
|
{
|
|
return b.normalized();
|
|
}
|
|
}
|
|
|
|
template <class T>
|
|
int maxdirsterid(const T *p, int count, const T &dir, btAlignedObjectArray<int> &allow)
|
|
{
|
|
int m = -1;
|
|
while (m == -1)
|
|
{
|
|
m = maxdirfiltered(p, count, dir, allow);
|
|
if (allow[m] == 3) return m;
|
|
T u = orth(dir);
|
|
T v = btCross(u, dir);
|
|
int ma = -1;
|
|
for (btScalar x = btScalar(0.0); x <= btScalar(360.0); x += btScalar(45.0))
|
|
{
|
|
btScalar s = btSin(SIMD_RADS_PER_DEG * (x));
|
|
btScalar c = btCos(SIMD_RADS_PER_DEG * (x));
|
|
int mb = maxdirfiltered(p, count, dir + (u * s + v * c) * btScalar(0.025), allow);
|
|
if (ma == m && mb == m)
|
|
{
|
|
allow[m] = 3;
|
|
return m;
|
|
}
|
|
if (ma != -1 && ma != mb) // Yuck - this is really ugly
|
|
{
|
|
int mc = ma;
|
|
for (btScalar xx = x - btScalar(40.0); xx <= x; xx += btScalar(5.0))
|
|
{
|
|
btScalar s = btSin(SIMD_RADS_PER_DEG * (xx));
|
|
btScalar c = btCos(SIMD_RADS_PER_DEG * (xx));
|
|
int md = maxdirfiltered(p, count, dir + (u * s + v * c) * btScalar(0.025), allow);
|
|
if (mc == m && md == m)
|
|
{
|
|
allow[m] = 3;
|
|
return m;
|
|
}
|
|
mc = md;
|
|
}
|
|
}
|
|
ma = mb;
|
|
}
|
|
allow[m] = 0;
|
|
m = -1;
|
|
}
|
|
btAssert(0);
|
|
return m;
|
|
}
|
|
|
|
int operator==(const int3 &a, const int3 &b);
|
|
int operator==(const int3 &a, const int3 &b)
|
|
{
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
if (a[i] != b[i]) return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int above(btVector3 *vertices, const int3 &t, const btVector3 &p, btScalar epsilon);
|
|
int above(btVector3 *vertices, const int3 &t, const btVector3 &p, btScalar epsilon)
|
|
{
|
|
btVector3 n = TriNormal(vertices[t[0]], vertices[t[1]], vertices[t[2]]);
|
|
return (btDot(n, p - vertices[t[0]]) > epsilon); // EPSILON???
|
|
}
|
|
int hasedge(const int3 &t, int a, int b);
|
|
int hasedge(const int3 &t, int a, int b)
|
|
{
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
int i1 = (i + 1) % 3;
|
|
if (t[i] == a && t[i1] == b) return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
int hasvert(const int3 &t, int v);
|
|
int hasvert(const int3 &t, int v)
|
|
{
|
|
return (t[0] == v || t[1] == v || t[2] == v);
|
|
}
|
|
int shareedge(const int3 &a, const int3 &b);
|
|
int shareedge(const int3 &a, const int3 &b)
|
|
{
|
|
int i;
|
|
for (i = 0; i < 3; i++)
|
|
{
|
|
int i1 = (i + 1) % 3;
|
|
if (hasedge(a, b[i1], b[i])) return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
class btHullTriangle;
|
|
|
|
class btHullTriangle : public int3
|
|
{
|
|
public:
|
|
int3 n;
|
|
int id;
|
|
int vmax;
|
|
btScalar rise;
|
|
btHullTriangle(int a, int b, int c) : int3(a, b, c), n(-1, -1, -1)
|
|
{
|
|
vmax = -1;
|
|
rise = btScalar(0.0);
|
|
}
|
|
~btHullTriangle()
|
|
{
|
|
}
|
|
int &neib(int a, int b);
|
|
};
|
|
|
|
int &btHullTriangle::neib(int a, int b)
|
|
{
|
|
static int er = -1;
|
|
int i;
|
|
for (i = 0; i < 3; i++)
|
|
{
|
|
int i1 = (i + 1) % 3;
|
|
int i2 = (i + 2) % 3;
|
|
if ((*this)[i] == a && (*this)[i1] == b) return n[i2];
|
|
if ((*this)[i] == b && (*this)[i1] == a) return n[i2];
|
|
}
|
|
btAssert(0);
|
|
return er;
|
|
}
|
|
void HullLibrary::b2bfix(btHullTriangle *s, btHullTriangle *t)
|
|
{
|
|
int i;
|
|
for (i = 0; i < 3; i++)
|
|
{
|
|
int i1 = (i + 1) % 3;
|
|
int i2 = (i + 2) % 3;
|
|
int a = (*s)[i1];
|
|
int b = (*s)[i2];
|
|
btAssert(m_tris[s->neib(a, b)]->neib(b, a) == s->id);
|
|
btAssert(m_tris[t->neib(a, b)]->neib(b, a) == t->id);
|
|
m_tris[s->neib(a, b)]->neib(b, a) = t->neib(b, a);
|
|
m_tris[t->neib(b, a)]->neib(a, b) = s->neib(a, b);
|
|
}
|
|
}
|
|
|
|
void HullLibrary::removeb2b(btHullTriangle *s, btHullTriangle *t)
|
|
{
|
|
b2bfix(s, t);
|
|
deAllocateTriangle(s);
|
|
|
|
deAllocateTriangle(t);
|
|
}
|
|
|
|
void HullLibrary::checkit(btHullTriangle *t)
|
|
{
|
|
(void)t;
|
|
|
|
int i;
|
|
btAssert(m_tris[t->id] == t);
|
|
for (i = 0; i < 3; i++)
|
|
{
|
|
int i1 = (i + 1) % 3;
|
|
int i2 = (i + 2) % 3;
|
|
int a = (*t)[i1];
|
|
int b = (*t)[i2];
|
|
|
|
// release compile fix
|
|
(void)i1;
|
|
(void)i2;
|
|
(void)a;
|
|
(void)b;
|
|
|
|
btAssert(a != b);
|
|
btAssert(m_tris[t->n[i]]->neib(b, a) == t->id);
|
|
}
|
|
}
|
|
|
|
btHullTriangle *HullLibrary::allocateTriangle(int a, int b, int c)
|
|
{
|
|
void *mem = btAlignedAlloc(sizeof(btHullTriangle), 16);
|
|
btHullTriangle *tr = new (mem) btHullTriangle(a, b, c);
|
|
tr->id = m_tris.size();
|
|
m_tris.push_back(tr);
|
|
|
|
return tr;
|
|
}
|
|
|
|
void HullLibrary::deAllocateTriangle(btHullTriangle *tri)
|
|
{
|
|
btAssert(m_tris[tri->id] == tri);
|
|
m_tris[tri->id] = NULL;
|
|
tri->~btHullTriangle();
|
|
btAlignedFree(tri);
|
|
}
|
|
|
|
void HullLibrary::extrude(btHullTriangle *t0, int v)
|
|
{
|
|
int3 t = *t0;
|
|
int n = m_tris.size();
|
|
btHullTriangle *ta = allocateTriangle(v, t[1], t[2]);
|
|
ta->n = int3(t0->n[0], n + 1, n + 2);
|
|
m_tris[t0->n[0]]->neib(t[1], t[2]) = n + 0;
|
|
btHullTriangle *tb = allocateTriangle(v, t[2], t[0]);
|
|
tb->n = int3(t0->n[1], n + 2, n + 0);
|
|
m_tris[t0->n[1]]->neib(t[2], t[0]) = n + 1;
|
|
btHullTriangle *tc = allocateTriangle(v, t[0], t[1]);
|
|
tc->n = int3(t0->n[2], n + 0, n + 1);
|
|
m_tris[t0->n[2]]->neib(t[0], t[1]) = n + 2;
|
|
checkit(ta);
|
|
checkit(tb);
|
|
checkit(tc);
|
|
if (hasvert(*m_tris[ta->n[0]], v)) removeb2b(ta, m_tris[ta->n[0]]);
|
|
if (hasvert(*m_tris[tb->n[0]], v)) removeb2b(tb, m_tris[tb->n[0]]);
|
|
if (hasvert(*m_tris[tc->n[0]], v)) removeb2b(tc, m_tris[tc->n[0]]);
|
|
deAllocateTriangle(t0);
|
|
}
|
|
|
|
btHullTriangle *HullLibrary::extrudable(btScalar epsilon)
|
|
{
|
|
int i;
|
|
btHullTriangle *t = NULL;
|
|
for (i = 0; i < m_tris.size(); i++)
|
|
{
|
|
if (!t || (m_tris[i] && t->rise < m_tris[i]->rise))
|
|
{
|
|
t = m_tris[i];
|
|
}
|
|
}
|
|
return (t->rise > epsilon) ? t : NULL;
|
|
}
|
|
|
|
int4 HullLibrary::FindSimplex(btVector3 *verts, int verts_count, btAlignedObjectArray<int> &allow)
|
|
{
|
|
btVector3 basis[3];
|
|
basis[0] = btVector3(btScalar(0.01), btScalar(0.02), btScalar(1.0));
|
|
int p0 = maxdirsterid(verts, verts_count, basis[0], allow);
|
|
int p1 = maxdirsterid(verts, verts_count, -basis[0], allow);
|
|
basis[0] = verts[p0] - verts[p1];
|
|
if (p0 == p1 || basis[0] == btVector3(0, 0, 0))
|
|
return int4(-1, -1, -1, -1);
|
|
basis[1] = btCross(btVector3(btScalar(1), btScalar(0.02), btScalar(0)), basis[0]);
|
|
basis[2] = btCross(btVector3(btScalar(-0.02), btScalar(1), btScalar(0)), basis[0]);
|
|
if (basis[1].length() > basis[2].length())
|
|
{
|
|
basis[1].normalize();
|
|
}
|
|
else
|
|
{
|
|
basis[1] = basis[2];
|
|
basis[1].normalize();
|
|
}
|
|
int p2 = maxdirsterid(verts, verts_count, basis[1], allow);
|
|
if (p2 == p0 || p2 == p1)
|
|
{
|
|
p2 = maxdirsterid(verts, verts_count, -basis[1], allow);
|
|
}
|
|
if (p2 == p0 || p2 == p1)
|
|
return int4(-1, -1, -1, -1);
|
|
basis[1] = verts[p2] - verts[p0];
|
|
basis[2] = btCross(basis[1], basis[0]).normalized();
|
|
int p3 = maxdirsterid(verts, verts_count, basis[2], allow);
|
|
if (p3 == p0 || p3 == p1 || p3 == p2) p3 = maxdirsterid(verts, verts_count, -basis[2], allow);
|
|
if (p3 == p0 || p3 == p1 || p3 == p2)
|
|
return int4(-1, -1, -1, -1);
|
|
btAssert(!(p0 == p1 || p0 == p2 || p0 == p3 || p1 == p2 || p1 == p3 || p2 == p3));
|
|
if (btDot(verts[p3] - verts[p0], btCross(verts[p1] - verts[p0], verts[p2] - verts[p0])) < 0)
|
|
{
|
|
btSwap(p2, p3);
|
|
}
|
|
return int4(p0, p1, p2, p3);
|
|
}
|
|
|
|
int HullLibrary::calchullgen(btVector3 *verts, int verts_count, int vlimit)
|
|
{
|
|
if (verts_count < 4) return 0;
|
|
if (vlimit == 0) vlimit = 1000000000;
|
|
int j;
|
|
btVector3 bmin(*verts), bmax(*verts);
|
|
btAlignedObjectArray<int> isextreme;
|
|
isextreme.reserve(verts_count);
|
|
btAlignedObjectArray<int> allow;
|
|
allow.reserve(verts_count);
|
|
|
|
for (j = 0; j < verts_count; j++)
|
|
{
|
|
allow.push_back(1);
|
|
isextreme.push_back(0);
|
|
bmin.setMin(verts[j]);
|
|
bmax.setMax(verts[j]);
|
|
}
|
|
btScalar epsilon = (bmax - bmin).length() * btScalar(0.001);
|
|
btAssert(epsilon != 0.0);
|
|
|
|
int4 p = FindSimplex(verts, verts_count, allow);
|
|
if (p.x == -1) return 0; // simplex failed
|
|
|
|
btVector3 center = (verts[p[0]] + verts[p[1]] + verts[p[2]] + verts[p[3]]) / btScalar(4.0); // a valid interior point
|
|
btHullTriangle *t0 = allocateTriangle(p[2], p[3], p[1]);
|
|
t0->n = int3(2, 3, 1);
|
|
btHullTriangle *t1 = allocateTriangle(p[3], p[2], p[0]);
|
|
t1->n = int3(3, 2, 0);
|
|
btHullTriangle *t2 = allocateTriangle(p[0], p[1], p[3]);
|
|
t2->n = int3(0, 1, 3);
|
|
btHullTriangle *t3 = allocateTriangle(p[1], p[0], p[2]);
|
|
t3->n = int3(1, 0, 2);
|
|
isextreme[p[0]] = isextreme[p[1]] = isextreme[p[2]] = isextreme[p[3]] = 1;
|
|
checkit(t0);
|
|
checkit(t1);
|
|
checkit(t2);
|
|
checkit(t3);
|
|
|
|
for (j = 0; j < m_tris.size(); j++)
|
|
{
|
|
btHullTriangle *t = m_tris[j];
|
|
btAssert(t);
|
|
btAssert(t->vmax < 0);
|
|
btVector3 n = TriNormal(verts[(*t)[0]], verts[(*t)[1]], verts[(*t)[2]]);
|
|
t->vmax = maxdirsterid(verts, verts_count, n, allow);
|
|
t->rise = btDot(n, verts[t->vmax] - verts[(*t)[0]]);
|
|
}
|
|
btHullTriangle *te;
|
|
vlimit -= 4;
|
|
while (vlimit > 0 && ((te = extrudable(epsilon)) != 0))
|
|
{
|
|
//int3 ti=*te;
|
|
int v = te->vmax;
|
|
btAssert(v != -1);
|
|
btAssert(!isextreme[v]); // wtf we've already done this vertex
|
|
isextreme[v] = 1;
|
|
//if(v==p0 || v==p1 || v==p2 || v==p3) continue; // done these already
|
|
j = m_tris.size();
|
|
while (j--)
|
|
{
|
|
if (!m_tris[j]) continue;
|
|
int3 t = *m_tris[j];
|
|
if (above(verts, t, verts[v], btScalar(0.01) * epsilon))
|
|
{
|
|
extrude(m_tris[j], v);
|
|
}
|
|
}
|
|
// now check for those degenerate cases where we have a flipped triangle or a really skinny triangle
|
|
j = m_tris.size();
|
|
while (j--)
|
|
{
|
|
if (!m_tris[j]) continue;
|
|
if (!hasvert(*m_tris[j], v)) break;
|
|
int3 nt = *m_tris[j];
|
|
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))
|
|
{
|
|
btHullTriangle *nb = m_tris[m_tris[j]->n[0]];
|
|
btAssert(nb);
|
|
btAssert(!hasvert(*nb, v));
|
|
btAssert(nb->id < j);
|
|
extrude(nb, v);
|
|
j = m_tris.size();
|
|
}
|
|
}
|
|
j = m_tris.size();
|
|
while (j--)
|
|
{
|
|
btHullTriangle *t = m_tris[j];
|
|
if (!t) continue;
|
|
if (t->vmax >= 0) break;
|
|
btVector3 n = TriNormal(verts[(*t)[0]], verts[(*t)[1]], verts[(*t)[2]]);
|
|
t->vmax = maxdirsterid(verts, verts_count, n, allow);
|
|
if (isextreme[t->vmax])
|
|
{
|
|
t->vmax = -1; // already done that vertex - algorithm needs to be able to terminate.
|
|
}
|
|
else
|
|
{
|
|
t->rise = btDot(n, verts[t->vmax] - verts[(*t)[0]]);
|
|
}
|
|
}
|
|
vlimit--;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int HullLibrary::calchull(btVector3 *verts, int verts_count, TUIntArray &tris_out, int &tris_count, int vlimit)
|
|
{
|
|
int rc = calchullgen(verts, verts_count, vlimit);
|
|
if (!rc) return 0;
|
|
btAlignedObjectArray<int> ts;
|
|
int i;
|
|
|
|
for (i = 0; i < m_tris.size(); i++)
|
|
{
|
|
if (m_tris[i])
|
|
{
|
|
for (int j = 0; j < 3; j++)
|
|
ts.push_back((*m_tris[i])[j]);
|
|
deAllocateTriangle(m_tris[i]);
|
|
}
|
|
}
|
|
tris_count = ts.size() / 3;
|
|
tris_out.resize(ts.size());
|
|
|
|
for (i = 0; i < ts.size(); i++)
|
|
{
|
|
tris_out[i] = static_cast<unsigned int>(ts[i]);
|
|
}
|
|
m_tris.resize(0);
|
|
|
|
return 1;
|
|
}
|
|
|
|
bool HullLibrary::ComputeHull(unsigned int vcount, const btVector3 *vertices, PHullResult &result, unsigned int vlimit)
|
|
{
|
|
int tris_count;
|
|
int ret = calchull((btVector3 *)vertices, (int)vcount, result.m_Indices, tris_count, static_cast<int>(vlimit));
|
|
if (!ret) return false;
|
|
result.mIndexCount = (unsigned int)(tris_count * 3);
|
|
result.mFaceCount = (unsigned int)tris_count;
|
|
result.mVertices = (btVector3 *)vertices;
|
|
result.mVcount = (unsigned int)vcount;
|
|
return true;
|
|
}
|
|
|
|
void ReleaseHull(PHullResult &result);
|
|
void ReleaseHull(PHullResult &result)
|
|
{
|
|
if (result.m_Indices.size())
|
|
{
|
|
result.m_Indices.clear();
|
|
}
|
|
|
|
result.mVcount = 0;
|
|
result.mIndexCount = 0;
|
|
result.mVertices = 0;
|
|
}
|
|
|
|
//*********************************************************************
|
|
//*********************************************************************
|
|
//******** HullLib header
|
|
//*********************************************************************
|
|
//*********************************************************************
|
|
|
|
//*********************************************************************
|
|
//*********************************************************************
|
|
//******** HullLib implementation
|
|
//*********************************************************************
|
|
//*********************************************************************
|
|
|
|
HullError HullLibrary::CreateConvexHull(const HullDesc &desc, // describes the input request
|
|
HullResult &result) // contains the resulst
|
|
{
|
|
HullError ret = QE_FAIL;
|
|
|
|
PHullResult hr;
|
|
|
|
unsigned int vcount = desc.mVcount;
|
|
if (vcount < 8) vcount = 8;
|
|
|
|
btAlignedObjectArray<btVector3> vertexSource;
|
|
btVector3 zero;
|
|
zero.setZero();
|
|
vertexSource.resize(static_cast<int>(vcount), zero);
|
|
|
|
btVector3 scale;
|
|
|
|
unsigned int ovcount;
|
|
|
|
bool ok = CleanupVertices(desc.mVcount, desc.mVertices, desc.mVertexStride, ovcount, &vertexSource[0], desc.mNormalEpsilon, scale); // normalize point cloud, remove duplicates!
|
|
|
|
if (ok)
|
|
{
|
|
// if ( 1 ) // scale vertices back to their original size.
|
|
{
|
|
for (unsigned int i = 0; i < ovcount; i++)
|
|
{
|
|
btVector3 &v = vertexSource[static_cast<int>(i)];
|
|
v[0] *= scale[0];
|
|
v[1] *= scale[1];
|
|
v[2] *= scale[2];
|
|
}
|
|
}
|
|
|
|
ok = ComputeHull(ovcount, &vertexSource[0], hr, desc.mMaxVertices);
|
|
|
|
if (ok)
|
|
{
|
|
// re-index triangle mesh so it refers to only used vertices, rebuild a new vertex table.
|
|
btAlignedObjectArray<btVector3> vertexScratch;
|
|
vertexScratch.resize(static_cast<int>(hr.mVcount));
|
|
|
|
BringOutYourDead(hr.mVertices, hr.mVcount, &vertexScratch[0], ovcount, &hr.m_Indices[0], hr.mIndexCount);
|
|
|
|
ret = QE_OK;
|
|
|
|
if (desc.HasHullFlag(QF_TRIANGLES)) // if he wants the results as triangle!
|
|
{
|
|
result.mPolygons = false;
|
|
result.mNumOutputVertices = ovcount;
|
|
result.m_OutputVertices.resize(static_cast<int>(ovcount));
|
|
result.mNumFaces = hr.mFaceCount;
|
|
result.mNumIndices = hr.mIndexCount;
|
|
|
|
result.m_Indices.resize(static_cast<int>(hr.mIndexCount));
|
|
|
|
memcpy(&result.m_OutputVertices[0], &vertexScratch[0], sizeof(btVector3) * ovcount);
|
|
|
|
if (desc.HasHullFlag(QF_REVERSE_ORDER))
|
|
{
|
|
const unsigned int *source = &hr.m_Indices[0];
|
|
unsigned int *dest = &result.m_Indices[0];
|
|
|
|
for (unsigned int i = 0; i < hr.mFaceCount; i++)
|
|
{
|
|
dest[0] = source[2];
|
|
dest[1] = source[1];
|
|
dest[2] = source[0];
|
|
dest += 3;
|
|
source += 3;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
memcpy(&result.m_Indices[0], &hr.m_Indices[0], sizeof(unsigned int) * hr.mIndexCount);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
result.mPolygons = true;
|
|
result.mNumOutputVertices = ovcount;
|
|
result.m_OutputVertices.resize(static_cast<int>(ovcount));
|
|
result.mNumFaces = hr.mFaceCount;
|
|
result.mNumIndices = hr.mIndexCount + hr.mFaceCount;
|
|
result.m_Indices.resize(static_cast<int>(result.mNumIndices));
|
|
memcpy(&result.m_OutputVertices[0], &vertexScratch[0], sizeof(btVector3) * ovcount);
|
|
|
|
// if ( 1 )
|
|
{
|
|
const unsigned int *source = &hr.m_Indices[0];
|
|
unsigned int *dest = &result.m_Indices[0];
|
|
for (unsigned int i = 0; i < hr.mFaceCount; i++)
|
|
{
|
|
dest[0] = 3;
|
|
if (desc.HasHullFlag(QF_REVERSE_ORDER))
|
|
{
|
|
dest[1] = source[2];
|
|
dest[2] = source[1];
|
|
dest[3] = source[0];
|
|
}
|
|
else
|
|
{
|
|
dest[1] = source[0];
|
|
dest[2] = source[1];
|
|
dest[3] = source[2];
|
|
}
|
|
|
|
dest += 4;
|
|
source += 3;
|
|
}
|
|
}
|
|
}
|
|
ReleaseHull(hr);
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
HullError HullLibrary::ReleaseResult(HullResult &result) // release memory allocated for this result, we are done with it.
|
|
{
|
|
if (result.m_OutputVertices.size())
|
|
{
|
|
result.mNumOutputVertices = 0;
|
|
result.m_OutputVertices.clear();
|
|
}
|
|
if (result.m_Indices.size())
|
|
{
|
|
result.mNumIndices = 0;
|
|
result.m_Indices.clear();
|
|
}
|
|
return QE_OK;
|
|
}
|
|
|
|
static void addPoint(unsigned int &vcount, btVector3 *p, btScalar x, btScalar y, btScalar z)
|
|
{
|
|
// XXX, might be broken
|
|
btVector3 &dest = p[vcount];
|
|
dest[0] = x;
|
|
dest[1] = y;
|
|
dest[2] = z;
|
|
vcount++;
|
|
}
|
|
|
|
btScalar GetDist(btScalar px, btScalar py, btScalar pz, const btScalar *p2);
|
|
btScalar GetDist(btScalar px, btScalar py, btScalar pz, const btScalar *p2)
|
|
{
|
|
btScalar dx = px - p2[0];
|
|
btScalar dy = py - p2[1];
|
|
btScalar dz = pz - p2[2];
|
|
|
|
return dx * dx + dy * dy + dz * dz;
|
|
}
|
|
|
|
bool HullLibrary::CleanupVertices(unsigned int svcount,
|
|
const btVector3 *svertices,
|
|
unsigned int stride,
|
|
unsigned int &vcount, // output number of vertices
|
|
btVector3 *vertices, // location to store the results.
|
|
btScalar normalepsilon,
|
|
btVector3 &scale)
|
|
{
|
|
if (svcount == 0) return false;
|
|
|
|
m_vertexIndexMapping.resize(0);
|
|
|
|
#define EPSILON btScalar(0.000001) /* close enough to consider two btScalaring point numbers to be 'the same'. */
|
|
|
|
vcount = 0;
|
|
|
|
btScalar recip[3] = {0.f, 0.f, 0.f};
|
|
|
|
if (scale)
|
|
{
|
|
scale[0] = 1;
|
|
scale[1] = 1;
|
|
scale[2] = 1;
|
|
}
|
|
|
|
btScalar bmin[3] = {FLT_MAX, FLT_MAX, FLT_MAX};
|
|
btScalar bmax[3] = {-FLT_MAX, -FLT_MAX, -FLT_MAX};
|
|
|
|
const char *vtx = (const char *)svertices;
|
|
|
|
// if ( 1 )
|
|
{
|
|
for (unsigned int i = 0; i < svcount; i++)
|
|
{
|
|
const btScalar *p = (const btScalar *)vtx;
|
|
|
|
vtx += stride;
|
|
|
|
for (int j = 0; j < 3; j++)
|
|
{
|
|
if (p[j] < bmin[j]) bmin[j] = p[j];
|
|
if (p[j] > bmax[j]) bmax[j] = p[j];
|
|
}
|
|
}
|
|
}
|
|
|
|
btScalar dx = bmax[0] - bmin[0];
|
|
btScalar dy = bmax[1] - bmin[1];
|
|
btScalar dz = bmax[2] - bmin[2];
|
|
|
|
btVector3 center;
|
|
|
|
center[0] = dx * btScalar(0.5) + bmin[0];
|
|
center[1] = dy * btScalar(0.5) + bmin[1];
|
|
center[2] = dz * btScalar(0.5) + bmin[2];
|
|
|
|
if (dx < EPSILON || dy < EPSILON || dz < EPSILON || svcount < 3)
|
|
{
|
|
btScalar len = FLT_MAX;
|
|
|
|
if (dx > EPSILON && dx < len) len = dx;
|
|
if (dy > EPSILON && dy < len) len = dy;
|
|
if (dz > EPSILON && dz < len) len = dz;
|
|
|
|
if (len == FLT_MAX)
|
|
{
|
|
dx = dy = dz = btScalar(0.01); // one centimeter
|
|
}
|
|
else
|
|
{
|
|
if (dx < EPSILON) dx = len * btScalar(0.05); // 1/5th the shortest non-zero edge.
|
|
if (dy < EPSILON) dy = len * btScalar(0.05);
|
|
if (dz < EPSILON) dz = len * btScalar(0.05);
|
|
}
|
|
|
|
btScalar x1 = center[0] - dx;
|
|
btScalar x2 = center[0] + dx;
|
|
|
|
btScalar y1 = center[1] - dy;
|
|
btScalar y2 = center[1] + dy;
|
|
|
|
btScalar z1 = center[2] - dz;
|
|
btScalar z2 = center[2] + dz;
|
|
|
|
addPoint(vcount, vertices, x1, y1, z1);
|
|
addPoint(vcount, vertices, x2, y1, z1);
|
|
addPoint(vcount, vertices, x2, y2, z1);
|
|
addPoint(vcount, vertices, x1, y2, z1);
|
|
addPoint(vcount, vertices, x1, y1, z2);
|
|
addPoint(vcount, vertices, x2, y1, z2);
|
|
addPoint(vcount, vertices, x2, y2, z2);
|
|
addPoint(vcount, vertices, x1, y2, z2);
|
|
|
|
return true; // return cube
|
|
}
|
|
else
|
|
{
|
|
if (scale)
|
|
{
|
|
scale[0] = dx;
|
|
scale[1] = dy;
|
|
scale[2] = dz;
|
|
|
|
recip[0] = 1 / dx;
|
|
recip[1] = 1 / dy;
|
|
recip[2] = 1 / dz;
|
|
|
|
center[0] *= recip[0];
|
|
center[1] *= recip[1];
|
|
center[2] *= recip[2];
|
|
}
|
|
}
|
|
|
|
vtx = (const char *)svertices;
|
|
|
|
for (unsigned int i = 0; i < svcount; i++)
|
|
{
|
|
const btVector3 *p = (const btVector3 *)vtx;
|
|
vtx += stride;
|
|
|
|
btScalar px = p->getX();
|
|
btScalar py = p->getY();
|
|
btScalar pz = p->getZ();
|
|
|
|
if (scale)
|
|
{
|
|
px = px * recip[0]; // normalize
|
|
py = py * recip[1]; // normalize
|
|
pz = pz * recip[2]; // normalize
|
|
}
|
|
|
|
// if ( 1 )
|
|
{
|
|
unsigned int j;
|
|
|
|
for (j = 0; j < vcount; j++)
|
|
{
|
|
/// XXX might be broken
|
|
btVector3 &v = vertices[j];
|
|
|
|
btScalar x = v[0];
|
|
btScalar y = v[1];
|
|
btScalar z = v[2];
|
|
|
|
btScalar dx = btFabs(x - px);
|
|
btScalar dy = btFabs(y - py);
|
|
btScalar dz = btFabs(z - pz);
|
|
|
|
if (dx < normalepsilon && dy < normalepsilon && dz < normalepsilon)
|
|
{
|
|
// ok, it is close enough to the old one
|
|
// now let us see if it is further from the center of the point cloud than the one we already recorded.
|
|
// in which case we keep this one instead.
|
|
|
|
btScalar dist1 = GetDist(px, py, pz, center);
|
|
btScalar dist2 = GetDist(v[0], v[1], v[2], center);
|
|
|
|
if (dist1 > dist2)
|
|
{
|
|
v[0] = px;
|
|
v[1] = py;
|
|
v[2] = pz;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (j == vcount)
|
|
{
|
|
btVector3 &dest = vertices[vcount];
|
|
dest[0] = px;
|
|
dest[1] = py;
|
|
dest[2] = pz;
|
|
vcount++;
|
|
}
|
|
m_vertexIndexMapping.push_back(j);
|
|
}
|
|
}
|
|
|
|
// ok..now make sure we didn't prune so many vertices it is now invalid.
|
|
// if ( 1 )
|
|
{
|
|
btScalar bmin[3] = {FLT_MAX, FLT_MAX, FLT_MAX};
|
|
btScalar bmax[3] = {-FLT_MAX, -FLT_MAX, -FLT_MAX};
|
|
|
|
for (unsigned int i = 0; i < vcount; i++)
|
|
{
|
|
const btVector3 &p = vertices[i];
|
|
for (int j = 0; j < 3; j++)
|
|
{
|
|
if (p[j] < bmin[j]) bmin[j] = p[j];
|
|
if (p[j] > bmax[j]) bmax[j] = p[j];
|
|
}
|
|
}
|
|
|
|
btScalar dx = bmax[0] - bmin[0];
|
|
btScalar dy = bmax[1] - bmin[1];
|
|
btScalar dz = bmax[2] - bmin[2];
|
|
|
|
if (dx < EPSILON || dy < EPSILON || dz < EPSILON || vcount < 3)
|
|
{
|
|
btScalar cx = dx * btScalar(0.5) + bmin[0];
|
|
btScalar cy = dy * btScalar(0.5) + bmin[1];
|
|
btScalar cz = dz * btScalar(0.5) + bmin[2];
|
|
|
|
btScalar len = FLT_MAX;
|
|
|
|
if (dx >= EPSILON && dx < len) len = dx;
|
|
if (dy >= EPSILON && dy < len) len = dy;
|
|
if (dz >= EPSILON && dz < len) len = dz;
|
|
|
|
if (len == FLT_MAX)
|
|
{
|
|
dx = dy = dz = btScalar(0.01); // one centimeter
|
|
}
|
|
else
|
|
{
|
|
if (dx < EPSILON) dx = len * btScalar(0.05); // 1/5th the shortest non-zero edge.
|
|
if (dy < EPSILON) dy = len * btScalar(0.05);
|
|
if (dz < EPSILON) dz = len * btScalar(0.05);
|
|
}
|
|
|
|
btScalar x1 = cx - dx;
|
|
btScalar x2 = cx + dx;
|
|
|
|
btScalar y1 = cy - dy;
|
|
btScalar y2 = cy + dy;
|
|
|
|
btScalar z1 = cz - dz;
|
|
btScalar z2 = cz + dz;
|
|
|
|
vcount = 0; // add box
|
|
|
|
addPoint(vcount, vertices, x1, y1, z1);
|
|
addPoint(vcount, vertices, x2, y1, z1);
|
|
addPoint(vcount, vertices, x2, y2, z1);
|
|
addPoint(vcount, vertices, x1, y2, z1);
|
|
addPoint(vcount, vertices, x1, y1, z2);
|
|
addPoint(vcount, vertices, x2, y1, z2);
|
|
addPoint(vcount, vertices, x2, y2, z2);
|
|
addPoint(vcount, vertices, x1, y2, z2);
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void HullLibrary::BringOutYourDead(const btVector3 *verts, unsigned int vcount, btVector3 *overts, unsigned int &ocount, unsigned int *indices, unsigned indexcount)
|
|
{
|
|
btAlignedObjectArray<int> tmpIndices;
|
|
tmpIndices.resize(m_vertexIndexMapping.size());
|
|
int i;
|
|
|
|
for (i = 0; i < m_vertexIndexMapping.size(); i++)
|
|
{
|
|
tmpIndices[i] = m_vertexIndexMapping[i];
|
|
}
|
|
|
|
TUIntArray usedIndices;
|
|
usedIndices.resize(static_cast<int>(vcount));
|
|
memset(&usedIndices[0], 0, sizeof(unsigned int) * vcount);
|
|
|
|
ocount = 0;
|
|
|
|
for (i = 0; i < int(indexcount); i++)
|
|
{
|
|
unsigned int v = indices[i]; // original array index
|
|
|
|
btAssert(v >= 0 && v < vcount);
|
|
|
|
if (usedIndices[static_cast<int>(v)]) // if already remapped
|
|
{
|
|
indices[i] = usedIndices[static_cast<int>(v)] - 1; // index to new array
|
|
}
|
|
else
|
|
{
|
|
indices[i] = ocount; // new index mapping
|
|
|
|
overts[ocount][0] = verts[v][0]; // copy old vert to new vert array
|
|
overts[ocount][1] = verts[v][1];
|
|
overts[ocount][2] = verts[v][2];
|
|
|
|
for (int k = 0; k < m_vertexIndexMapping.size(); k++)
|
|
{
|
|
if (tmpIndices[k] == int(v))
|
|
m_vertexIndexMapping[k] = ocount;
|
|
}
|
|
|
|
ocount++; // increment output vert count
|
|
|
|
btAssert(ocount >= 0 && ocount <= vcount);
|
|
|
|
usedIndices[static_cast<int>(v)] = ocount; // assign new index remapping
|
|
}
|
|
}
|
|
}
|