Bart/bullet3
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

rename to b3 convention, to avoid naming conflicts when using in combination with Bullet 2.x

Browse Source
This commit is contained in:
erwincoumans
2013-04-29 15:19:36 -07:00
parent 7366e262fd
commit 55b69201a9
88 changed files with 1682 additions and 1584 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
src/Bullet3Geometry/b3AabbUtil.h
View File

@@ -23,7 +23,7 @@ subject to the following restrictions:
SIMD_FORCE_INLINE void AabbExpand (b3Vector3& aabbMin,
B3_FORCE_INLINE void b3AabbExpand (b3Vector3& aabbMin,
b3Vector3& aabbMax,
const b3Vector3& expansionMin,
const b3Vector3& expansionMax)
@@ -33,7 +33,7 @@ SIMD_FORCE_INLINE void AabbExpand (b3Vector3& aabbMin,
}
/// conservative test for overlap between two aabbs
SIMD_FORCE_INLINE bool TestPointAgainstAabb2(const b3Vector3 &aabbMin1, const b3Vector3 &aabbMax1,
B3_FORCE_INLINE bool b3TestPointAgainstAabb2(const b3Vector3 &aabbMin1, const b3Vector3 &aabbMax1,
const b3Vector3 &point)
{
bool overlap = true;
@@ -45,7 +45,7 @@ SIMD_FORCE_INLINE bool TestPointAgainstAabb2(const b3Vector3 &aabbMin1, const b3
/// conservative test for overlap between two aabbs
SIMD_FORCE_INLINE bool TestAabbAgainstAabb2(const b3Vector3 &aabbMin1, const b3Vector3 &aabbMax1,
B3_FORCE_INLINE bool b3TestAabbAgainstAabb2(const b3Vector3 &aabbMin1, const b3Vector3 &aabbMax1,
const b3Vector3 &aabbMin2, const b3Vector3 &aabbMax2)
{
bool overlap = true;
@@ -56,7 +56,7 @@ SIMD_FORCE_INLINE bool TestAabbAgainstAabb2(const b3Vector3 &aabbMin1, const b3V
}
/// conservative test for overlap between triangle and aabb
SIMD_FORCE_INLINE bool TestTriangleAgainstAabb2(const b3Vector3 *vertices,
B3_FORCE_INLINE bool b3TestTriangleAgainstAabb2(const b3Vector3 *vertices,
const b3Vector3 &aabbMin, const b3Vector3 &aabbMax)
{
const b3Vector3 &p1 = vertices[0];
@@ -75,7 +75,7 @@ SIMD_FORCE_INLINE bool TestTriangleAgainstAabb2(const b3Vector3 *vertices,
}
SIMD_FORCE_INLINE int b3Outcode(const b3Vector3& p,const b3Vector3& halfExtent)
B3_FORCE_INLINE int b3Outcode(const b3Vector3& p,const b3Vector3& halfExtent)
{
return (p.getX() < -halfExtent.getX() ? 0x01 : 0x0) |
(p.getX() > halfExtent.getX() ? 0x08 : 0x0) |
@@ -87,7 +87,7 @@ SIMD_FORCE_INLINE int b3Outcode(const b3Vector3& p,const b3Vector3& halfExtent)
SIMD_FORCE_INLINE bool b3RayAabb2(const b3Vector3& rayFrom,
B3_FORCE_INLINE bool b3RayAabb2(const b3Vector3& rayFrom,
const b3Vector3& rayInvDirection,
const unsigned int raySign[3],
const b3Vector3 bounds[2],
@@ -122,7 +122,7 @@ SIMD_FORCE_INLINE bool b3RayAabb2(const b3Vector3& rayFrom,
return ( (tmin < lambda_max) && (tmax > lambda_min) );
}
SIMD_FORCE_INLINE bool b3RayAabb(const b3Vector3& rayFrom,
B3_FORCE_INLINE bool b3RayAabb(const b3Vector3& rayFrom,
const b3Vector3& rayTo,
const b3Vector3& aabbMin,
const b3Vector3& aabbMax,
@@ -179,7 +179,7 @@ SIMD_FORCE_INLINE bool b3RayAabb(const b3Vector3& rayFrom,
SIMD_FORCE_INLINE void b3TransformAabb(const b3Vector3& halfExtents, b3Scalar margin,const b3Transform& t,b3Vector3& aabbMinOut,b3Vector3& aabbMaxOut)
B3_FORCE_INLINE void b3TransformAabb(const b3Vector3& halfExtents, b3Scalar margin,const b3Transform& t,b3Vector3& aabbMinOut,b3Vector3& aabbMaxOut)
{
b3Vector3 halfExtentsWithMargin = halfExtents+b3Vector3(margin,margin,margin);
b3Matrix3x3 abs_b = t.getBasis().absolute();
@@ -190,7 +190,7 @@ SIMD_FORCE_INLINE void b3TransformAabb(const b3Vector3& halfExtents, b3Scalar ma
}
SIMD_FORCE_INLINE void b3TransformAabb(const b3Vector3& localAabbMin,const b3Vector3& localAabbMax, b3Scalar margin,const b3Transform& trans,b3Vector3& aabbMinOut,b3Vector3& aabbMaxOut)
B3_FORCE_INLINE void b3TransformAabb(const b3Vector3& localAabbMin,const b3Vector3& localAabbMax, b3Scalar margin,const b3Transform& trans,b3Vector3& aabbMinOut,b3Vector3& aabbMaxOut)
{
b3Assert(localAabbMin.getX() <= localAabbMax.getX());
b3Assert(localAabbMin.getY() <= localAabbMax.getY());
@@ -206,10 +206,10 @@ SIMD_FORCE_INLINE void b3TransformAabb(const b3Vector3& localAabbMin,const b3Vec
aabbMaxOut = center+extent;
}
#define USE_BANCHLESS 1
#ifdef USE_BANCHLESS
#define B3_USE_BANCHLESS 1
#ifdef B3_USE_BANCHLESS
//This block replaces the block below and uses no branches, and replaces the 8 bit return with a 32 bit return for improved performance (~3x on XBox 360)
SIMD_FORCE_INLINE unsigned testQuantizedAabbAgainstQuantizedAabb(const unsigned short int* aabbMin1,const unsigned short int* aabbMax1,const unsigned short int* aabbMin2,const unsigned short int* aabbMax2)
B3_FORCE_INLINE unsigned b3TestQuantizedAabbAgainstQuantizedAabb(const unsigned short int* aabbMin1,const unsigned short int* aabbMax1,const unsigned short int* aabbMin2,const unsigned short int* aabbMax2)
{
return static_cast<unsigned int>(b3Select((unsigned)((aabbMin1[0] <= aabbMax2[0]) & (aabbMax1[0] >= aabbMin2[0])
& (aabbMin1[2] <= aabbMax2[2]) & (aabbMax1[2] >= aabbMin2[2])
@@ -217,7 +217,7 @@ SIMD_FORCE_INLINE void b3TransformAabb(const b3Vector3& localAabbMin,const b3Vec
1, 0));
}
#else
SIMD_FORCE_INLINE bool testQuantizedAabbAgainstQuantizedAabb(const unsigned short int* aabbMin1,const unsigned short int* aabbMax1,const unsigned short int* aabbMin2,const unsigned short int* aabbMax2)
B3_FORCE_INLINE bool b3TestQuantizedAabbAgainstQuantizedAabb(const unsigned short int* aabbMin1,const unsigned short int* aabbMax1,const unsigned short int* aabbMin2,const unsigned short int* aabbMax2)
{
bool overlap = true;
overlap = (aabbMin1[0] > aabbMax2[0] || aabbMax1[0] < aabbMin2[0]) ? false : overlap;
@@ -225,7 +225,7 @@ SIMD_FORCE_INLINE void b3TransformAabb(const b3Vector3& localAabbMin,const b3Vec
overlap = (aabbMin1[1] > aabbMax2[1] || aabbMax1[1] < aabbMin2[1]) ? false : overlap;
return overlap;
}
#endif //USE_BANCHLESS
#endif //B3_USE_BANCHLESS
#endif //B3_AABB_UTIL2

268
src/Bullet3Geometry/b3ConvexHullComputer.cpp
View File

@@ -21,16 +21,20 @@ subject to the following restrictions:
#ifdef __GNUC__
#include <stdint.h>
typedef int32_t btInt32_t;
typedef int64_t btInt64_t;
typedef uint32_t btUint32_t;
typedef uint64_t btUint64_t;
#elif defined(_MSC_VER)
typedef __int32 int32_t;
typedef __int64 int64_t;
typedef unsigned __int32 uint32_t;
typedef unsigned __int64 uint64_t;
typedef __int32 btInt32_t;
typedef __int64 btInt64_t;
typedef unsigned __int32 btUint32_t;
typedef unsigned __int64 btUint64_t;
#else
typedef int int32_t;
typedef long long int int64_t;
typedef unsigned int uint32_t;
typedef unsigned long long int uint64_t;
typedef int btInt32_t;
typedef long long int btInt64_t;
typedef unsigned int btUint32_t;
typedef unsigned long long int btUint64_t;
#endif
@@ -56,11 +60,11 @@ class b3ConvexHullInternal
class Point64
{
public:
int64_t x;
int64_t y;
int64_t z;
btInt64_t x;
btInt64_t y;
btInt64_t z;
Point64(int64_t x, int64_t y, int64_t z): x(x), y(y), z(z)
Point64(btInt64_t x, btInt64_t y, btInt64_t z): x(x), y(y), z(z)
{
}
@@ -69,7 +73,7 @@ class b3ConvexHullInternal
return (x == 0) && (y == 0) && (z == 0);
}
int64_t dot(const Point64& b) const
btInt64_t dot(const Point64& b) const
{
return x * b.x + y * b.y + z * b.z;
}
@@ -78,16 +82,16 @@ class b3ConvexHullInternal
class Point32
{
public:
int32_t x;
int32_t y;
int32_t z;
btInt32_t x;
btInt32_t y;
btInt32_t z;
int index;
Point32()
{
}
Point32(int32_t x, int32_t y, int32_t z): x(x), y(y), z(z), index(-1)
Point32(btInt32_t x, btInt32_t y, btInt32_t z): x(x), y(y), z(z), index(-1)
{
}
@@ -116,12 +120,12 @@ class b3ConvexHullInternal
return Point64(y * b.z - z * b.y, z * b.x - x * b.z, x * b.y - y * b.x);
}
int64_t dot(const Point32& b) const
btInt64_t dot(const Point32& b) const
{
return x * b.x + y * b.y + z * b.z;
}
int64_t dot(const Point64& b) const
btInt64_t dot(const Point64& b) const
{
return x * b.x + y * b.y + z * b.z;
}
@@ -140,32 +144,32 @@ class b3ConvexHullInternal
class Int128
{
public:
uint64_t low;
uint64_t high;
btUint64_t low;
btUint64_t high;
Int128()
{
}
Int128(uint64_t low, uint64_t high): low(low), high(high)
Int128(btUint64_t low, btUint64_t high): low(low), high(high)
{
}
Int128(uint64_t low): low(low), high(0)
Int128(btUint64_t low): low(low), high(0)
{
}
Int128(int64_t value): low(value), high((value >= 0) ? 0 : (uint64_t) -1LL)
Int128(btInt64_t value): low(value), high((value >= 0) ? 0 : (btUint64_t) -1LL)
{
}
static Int128 mul(int64_t a, int64_t b);
static Int128 mul(btInt64_t a, btInt64_t b);
static Int128 mul(uint64_t a, uint64_t b);
static Int128 mul(btUint64_t a, btUint64_t b);
Int128 operator-() const
{
return Int128((uint64_t) -(int64_t)low, ~high + (low == 0));
return Int128((btUint64_t) -(btInt64_t)low, ~high + (low == 0));
}
Int128 operator+(const Int128& b) const
@@ -179,7 +183,7 @@ class b3ConvexHullInternal
: "cc" );
return result;
#else
uint64_t lo = low + b.low;
btUint64_t lo = low + b.low;
return Int128(lo, high + b.high + (lo < low));
#endif
}
@@ -208,7 +212,7 @@ class b3ConvexHullInternal
: "0"(low), "1"(high), [bl] "g"(b.low), [bh] "g"(b.high)
: "cc" );
#else
uint64_t lo = low + b.low;
btUint64_t lo = low + b.low;
if (lo < low)
{
++high;
@@ -228,17 +232,17 @@ class b3ConvexHullInternal
return *this;
}
Int128 operator*(int64_t b) const;
Int128 operator*(btInt64_t b) const;
b3Scalar toScalar() const
{
return ((int64_t) high >= 0) ? b3Scalar(high) * (b3Scalar(0x100000000LL) * b3Scalar(0x100000000LL)) + b3Scalar(low)
return ((btInt64_t) high >= 0) ? b3Scalar(high) * (b3Scalar(0x100000000LL) * b3Scalar(0x100000000LL)) + b3Scalar(low)
: -(-*this).toScalar();
}
int getSign() const
{
return ((int64_t) high < 0) ? -1 : (high || low) ? 1 : 0;
return ((btInt64_t) high < 0) ? -1 : (high || low) ? 1 : 0;
}
bool operator<(const Int128& b) const
@@ -272,22 +276,22 @@ class b3ConvexHullInternal
class Rational64
{
private:
uint64_t m_numerator;
uint64_t m_denominator;
btUint64_t m_numerator;
btUint64_t m_denominator;
int sign;
public:
Rational64(int64_t numerator, int64_t denominator)
Rational64(btInt64_t numerator, btInt64_t denominator)
{
if (numerator > 0)
{
sign = 1;
m_numerator = (uint64_t) numerator;
m_numerator = (btUint64_t) numerator;
}
else if (numerator < 0)
{
sign = -1;
m_numerator = (uint64_t) -numerator;
m_numerator = (btUint64_t) -numerator;
}
else
{
@@ -296,12 +300,12 @@ class b3ConvexHullInternal
}
if (denominator > 0)
{
m_denominator = (uint64_t) denominator;
m_denominator = (btUint64_t) denominator;
}
else if (denominator < 0)
{
sign = -sign;
m_denominator = (uint64_t) -denominator;
m_denominator = (btUint64_t) -denominator;
}
else
{
@@ -323,7 +327,7 @@ class b3ConvexHullInternal
b3Scalar toScalar() const
{
return sign * ((m_denominator == 0) ? SIMD_INFINITY : (b3Scalar) m_numerator / m_denominator);
return sign * ((m_denominator == 0) ? B3_INFINITY : (b3Scalar) m_numerator / m_denominator);
}
};
@@ -337,7 +341,7 @@ class b3ConvexHullInternal
bool isInt64;
public:
Rational128(int64_t value)
Rational128(btInt64_t value)
{
if (value > 0)
{
@@ -352,9 +356,9 @@ class b3ConvexHullInternal
else
{
sign = 0;
this->numerator = (uint64_t) 0;
this->numerator = (btUint64_t) 0;
}
this->denominator = (uint64_t) 1;
this->denominator = (btUint64_t) 1;
isInt64 = true;
}
@@ -384,11 +388,11 @@ class b3ConvexHullInternal
int compare(const Rational128& b) const;
int compare(int64_t b) const;
int compare(btInt64_t b) const;
b3Scalar toScalar() const
{
return sign * ((denominator.getSign() == 0) ? SIMD_INFINITY : numerator.toScalar() / denominator.toScalar());
return sign * ((denominator.getSign() == 0) ? B3_INFINITY : numerator.toScalar() / denominator.toScalar());
}
};
@@ -579,37 +583,37 @@ class b3ConvexHullInternal
template<typename UWord, typename UHWord> class DMul
{
private:
static uint32_t high(uint64_t value)
static btUint32_t high(btUint64_t value)
{
return (uint32_t) (value >> 32);
return (btUint32_t) (value >> 32);
}
static uint32_t low(uint64_t value)
static btUint32_t low(btUint64_t value)
{
return (uint32_t) value;
return (btUint32_t) value;
}
static uint64_t mul(uint32_t a, uint32_t b)
static btUint64_t mul(btUint32_t a, btUint32_t b)
{
return (uint64_t) a * (uint64_t) b;
return (btUint64_t) a * (btUint64_t) b;
}
static void shlHalf(uint64_t& value)
static void shlHalf(btUint64_t& value)
{
value <<= 32;
}
static uint64_t high(Int128 value)
static btUint64_t high(Int128 value)
{
return value.high;
}
static uint64_t low(Int128 value)
static btUint64_t low(Int128 value)
{
return value.low;
}
static Int128 mul(uint64_t a, uint64_t b)
static Int128 mul(btUint64_t a, btUint64_t b)
{
return Int128::mul(a, b);
}
@@ -835,21 +839,21 @@ class b3ConvexHullInternal
};
b3ConvexHullInternal::Int128 b3ConvexHullInternal::Int128::operator*(int64_t b) const
b3ConvexHullInternal::Int128 b3ConvexHullInternal::Int128::operator*(btInt64_t b) const
{
bool negative = (int64_t) high < 0;
bool negative = (btInt64_t) high < 0;
Int128 a = negative ? -*this : *this;
if (b < 0)
{
negative = !negative;
b = -b;
}
Int128 result = mul(a.low, (uint64_t) b);
result.high += a.high * (uint64_t) b;
Int128 result = mul(a.low, (btUint64_t) b);
result.high += a.high * (btUint64_t) b;
return negative ? -result : result;
}
b3ConvexHullInternal::Int128 b3ConvexHullInternal::Int128::mul(int64_t a, int64_t b)
b3ConvexHullInternal::Int128 b3ConvexHullInternal::Int128::mul(btInt64_t a, btInt64_t b)
{
Int128 result;
@@ -871,12 +875,12 @@ b3ConvexHullInternal::Int128 b3ConvexHullInternal::Int128::mul(int64_t a, int64_
negative = !negative;
b = -b;
}
DMul<uint64_t, uint32_t>::mul((uint64_t) a, (uint64_t) b, result.low, result.high);
DMul<btUint64_t, btUint32_t>::mul((btUint64_t) a, (btUint64_t) b, result.low, result.high);
return negative ? -result : result;
#endif
}
b3ConvexHullInternal::Int128 b3ConvexHullInternal::Int128::mul(uint64_t a, uint64_t b)
b3ConvexHullInternal::Int128 b3ConvexHullInternal::Int128::mul(btUint64_t a, btUint64_t b)
{
Int128 result;
@@ -887,7 +891,7 @@ b3ConvexHullInternal::Int128 b3ConvexHullInternal::Int128::mul(uint64_t a, uint6
: "cc" );
#else
DMul<uint64_t, uint32_t>::mul(a, b, result.low, result.high);
DMul<btUint64_t, btUint32_t>::mul(a, b, result.low, result.high);
#endif
return result;
@@ -909,8 +913,8 @@ int b3ConvexHullInternal::Rational64::compare(const Rational64& b) const
#ifdef USE_X86_64_ASM
int result;
int64_t tmp;
int64_t dummy;
btInt64_t tmp;
btInt64_t dummy;
__asm__ ("mulq %[bn]\n\t"
"movq %%rax, %[tmp]\n\t"
"movq %%rdx, %%rbx\n\t"
@@ -949,12 +953,12 @@ int b3ConvexHullInternal::Rational128::compare(const Rational128& b) const
}
if (isInt64)
{
return -b.compare(sign * (int64_t) numerator.low);
return -b.compare(sign * (btInt64_t) numerator.low);
}
Int128 nbdLow, nbdHigh, dbnLow, dbnHigh;
DMul<Int128, uint64_t>::mul(numerator, b.denominator, nbdLow, nbdHigh);
DMul<Int128, uint64_t>::mul(denominator, b.numerator, dbnLow, dbnHigh);
DMul<Int128, btUint64_t>::mul(numerator, b.denominator, nbdLow, nbdHigh);
DMul<Int128, btUint64_t>::mul(denominator, b.numerator, dbnLow, dbnHigh);
int cmp = nbdHigh.ucmp(dbnHigh);
if (cmp)
@@ -964,11 +968,11 @@ int b3ConvexHullInternal::Rational128::compare(const Rational128& b) const
return nbdLow.ucmp(dbnLow) * sign;
}
int b3ConvexHullInternal::Rational128::compare(int64_t b) const
int b3ConvexHullInternal::Rational128::compare(btInt64_t b) const
{
if (isInt64)
{
int64_t a = sign * (int64_t) numerator.low;
btInt64_t a = sign * (btInt64_t) numerator.low;
return (a > b) ? 1 : (a < b) ? -1 : 0;
}
if (b > 0)
@@ -1067,22 +1071,22 @@ bool b3ConvexHullInternal::mergeProjection(IntermediateHull& h0, IntermediateHul
v1 = h1.maxXy;
Vertex* v00 = NULL;
Vertex* v10 = NULL;
int32_t sign = 1;
btInt32_t sign = 1;
for (int side = 0; side <= 1; side++)
{
int32_t dx = (v1->point.x - v0->point.x) * sign;
btInt32_t dx = (v1->point.x - v0->point.x) * sign;
if (dx > 0)
{
while (true)
{
int32_t dy = v1->point.y - v0->point.y;
btInt32_t dy = v1->point.y - v0->point.y;
Vertex* w0 = side ? v0->next : v0->prev;
if (w0 != v0)
{
int32_t dx0 = (w0->point.x - v0->point.x) * sign;
int32_t dy0 = w0->point.y - v0->point.y;
btInt32_t dx0 = (w0->point.x - v0->point.x) * sign;
btInt32_t dy0 = w0->point.y - v0->point.y;
if ((dy0 <= 0) && ((dx0 == 0) || ((dx0 < 0) && (dy0 * dx <= dy * dx0))))
{
v0 = w0;
@@ -1094,9 +1098,9 @@ bool b3ConvexHullInternal::mergeProjection(IntermediateHull& h0, IntermediateHul
Vertex* w1 = side ? v1->next : v1->prev;
if (w1 != v1)
{
int32_t dx1 = (w1->point.x - v1->point.x) * sign;
int32_t dy1 = w1->point.y - v1->point.y;
int32_t dxn = (w1->point.x - v0->point.x) * sign;
btInt32_t dx1 = (w1->point.x - v1->point.x) * sign;
btInt32_t dy1 = w1->point.y - v1->point.y;
btInt32_t dxn = (w1->point.x - v0->point.x) * sign;
if ((dxn > 0) && (dy1 < 0) && ((dx1 == 0) || ((dx1 < 0) && (dy1 * dx < dy * dx1))))
{
v1 = w1;
@@ -1112,13 +1116,13 @@ bool b3ConvexHullInternal::mergeProjection(IntermediateHull& h0, IntermediateHul
{
while (true)
{
int32_t dy = v1->point.y - v0->point.y;
btInt32_t dy = v1->point.y - v0->point.y;
Vertex* w1 = side ? v1->prev : v1->next;
if (w1 != v1)
{
int32_t dx1 = (w1->point.x - v1->point.x) * sign;
int32_t dy1 = w1->point.y - v1->point.y;
btInt32_t dx1 = (w1->point.x - v1->point.x) * sign;
btInt32_t dy1 = w1->point.y - v1->point.y;
if ((dy1 >= 0) && ((dx1 == 0) || ((dx1 < 0) && (dy1 * dx <= dy * dx1))))
{
v1 = w1;
@@ -1130,9 +1134,9 @@ bool b3ConvexHullInternal::mergeProjection(IntermediateHull& h0, IntermediateHul
Vertex* w0 = side ? v0->prev : v0->next;
if (w0 != v0)
{
int32_t dx0 = (w0->point.x - v0->point.x) * sign;
int32_t dy0 = w0->point.y - v0->point.y;
int32_t dxn = (v1->point.x - w0->point.x) * sign;
btInt32_t dx0 = (w0->point.x - v0->point.x) * sign;
btInt32_t dy0 = w0->point.y - v0->point.y;
btInt32_t dxn = (v1->point.x - w0->point.x) * sign;
if ((dxn < 0) && (dy0 > 0) && ((dx0 == 0) || ((dx0 < 0) && (dy0 * dx < dy * dx0))))
{
v0 = w0;
@@ -1146,8 +1150,8 @@ bool b3ConvexHullInternal::mergeProjection(IntermediateHull& h0, IntermediateHul
}
else
{
int32_t x = v0->point.x;
int32_t y0 = v0->point.y;
btInt32_t x = v0->point.x;
btInt32_t y0 = v0->point.y;
Vertex* w0 = v0;
Vertex* t;
while (((t = side ? w0->next : w0->prev) != v0) && (t->point.x == x) && (t->point.y <= y0))
@@ -1157,7 +1161,7 @@ bool b3ConvexHullInternal::mergeProjection(IntermediateHull& h0, IntermediateHul
}
v0 = w0;
int32_t y1 = v1->point.y;
btInt32_t y1 = v1->point.y;
Vertex* w1 = v1;
while (((t = side ? w1->prev : w1->next) != v1) && (t->point.x == x) && (t->point.y >= y1))
{
@@ -1218,8 +1222,8 @@ void b3ConvexHullInternal::computeInternal(int start, int end, IntermediateHull&
Vertex* w = v + 1;
if (v->point != w->point)
{
int32_t dx = v->point.x - w->point.x;
int32_t dy = v->point.y - w->point.y;
btInt32_t dx = v->point.x - w->point.x;
btInt32_t dy = v->point.y - w->point.y;
if ((dx == 0) && (dy == 0))
{
@@ -1392,7 +1396,7 @@ b3ConvexHullInternal::Orientation b3ConvexHullInternal::getOrientation(const Edg
Point64 n = t.cross(s);
Point64 m = (*prev->target - *next->reverse->target).cross(*next->target - *next->reverse->target);
b3Assert(!m.isZero());
int64_t dot = n.dot(m);
btInt64_t dot = n.dot(m);
b3Assert(dot != 0);
return (dot > 0) ? COUNTER_CLOCKWISE : CLOCKWISE;
}
@@ -1468,7 +1472,7 @@ void b3ConvexHullInternal::findEdgeForCoplanarFaces(Vertex* c0, Vertex* c1, Edge
Point32 et1 = start1 ? start1->target->point : c1->point;
Point32 s = c1->point - c0->point;
Point64 normal = ((start0 ? start0 : start1)->target->point - c0->point).cross(s);
int64_t dist = c0->point.dot(normal);
btInt64_t dist = c0->point.dot(normal);
b3Assert(!start1 || (start1->target->point.dot(normal) == dist));
Point64 perp = s.cross(normal);
b3Assert(!perp.isZero());
@@ -1477,7 +1481,7 @@ void b3ConvexHullInternal::findEdgeForCoplanarFaces(Vertex* c0, Vertex* c1, Edge
printf(" Advancing %d %d (%p %p, %d %d)\n", c0->point.index, c1->point.index, start0, start1, start0 ? start0->target->point.index : -1, start1 ? start1->target->point.index : -1);
#endif
int64_t maxDot0 = et0.dot(perp);
btInt64_t maxDot0 = et0.dot(perp);
if (e0)
{
while (e0->target != stop0)
@@ -1492,7 +1496,7 @@ void b3ConvexHullInternal::findEdgeForCoplanarFaces(Vertex* c0, Vertex* c1, Edge
{
break;
}
int64_t dot = e->target->point.dot(perp);
btInt64_t dot = e->target->point.dot(perp);
if (dot <= maxDot0)
{
break;
@@ -1503,7 +1507,7 @@ void b3ConvexHullInternal::findEdgeForCoplanarFaces(Vertex* c0, Vertex* c1, Edge
}
}
int64_t maxDot1 = et1.dot(perp);
btInt64_t maxDot1 = et1.dot(perp);
if (e1)
{
while (e1->target != stop1)
@@ -1518,7 +1522,7 @@ void b3ConvexHullInternal::findEdgeForCoplanarFaces(Vertex* c0, Vertex* c1, Edge
{
break;
}
int64_t dot = e->target->point.dot(perp);
btInt64_t dot = e->target->point.dot(perp);
if (dot <= maxDot1)
{
break;
@@ -1533,20 +1537,20 @@ void b3ConvexHullInternal::findEdgeForCoplanarFaces(Vertex* c0, Vertex* c1, Edge
printf(" Starting at %d %d\n", et0.index, et1.index);
#endif
int64_t dx = maxDot1 - maxDot0;
btInt64_t dx = maxDot1 - maxDot0;
if (dx > 0)
{
while (true)
{
int64_t dy = (et1 - et0).dot(s);
btInt64_t dy = (et1 - et0).dot(s);
if (e0 && (e0->target != stop0))
{
Edge* f0 = e0->next->reverse;
if (f0->copy > mergeStamp)
{
int64_t dx0 = (f0->target->point - et0).dot(perp);
int64_t dy0 = (f0->target->point - et0).dot(s);
btInt64_t dx0 = (f0->target->point - et0).dot(perp);
btInt64_t dy0 = (f0->target->point - et0).dot(s);
if ((dx0 == 0) ? (dy0 < 0) : ((dx0 < 0) && (Rational64(dy0, dx0).compare(Rational64(dy, dx)) >= 0)))
{
et0 = f0->target->point;
@@ -1565,9 +1569,9 @@ void b3ConvexHullInternal::findEdgeForCoplanarFaces(Vertex* c0, Vertex* c1, Edge
Point32 d1 = f1->target->point - et1;
if (d1.dot(normal) == 0)
{
int64_t dx1 = d1.dot(perp);
int64_t dy1 = d1.dot(s);
int64_t dxn = (f1->target->point - et0).dot(perp);
btInt64_t dx1 = d1.dot(perp);
btInt64_t dy1 = d1.dot(s);
btInt64_t dxn = (f1->target->point - et0).dot(perp);
if ((dxn > 0) && ((dx1 == 0) ? (dy1 < 0) : ((dx1 < 0) && (Rational64(dy1, dx1).compare(Rational64(dy, dx)) > 0))))
{
e1 = f1;
@@ -1590,15 +1594,15 @@ void b3ConvexHullInternal::findEdgeForCoplanarFaces(Vertex* c0, Vertex* c1, Edge
{
while (true)
{
int64_t dy = (et1 - et0).dot(s);
btInt64_t dy = (et1 - et0).dot(s);
if (e1 && (e1->target != stop1))
{
Edge* f1 = e1->prev->reverse;
if (f1->copy > mergeStamp)
{
int64_t dx1 = (f1->target->point - et1).dot(perp);
int64_t dy1 = (f1->target->point - et1).dot(s);
btInt64_t dx1 = (f1->target->point - et1).dot(perp);
btInt64_t dy1 = (f1->target->point - et1).dot(s);
if ((dx1 == 0) ? (dy1 > 0) : ((dx1 < 0) && (Rational64(dy1, dx1).compare(Rational64(dy, dx)) <= 0)))
{
et1 = f1->target->point;
@@ -1617,9 +1621,9 @@ void b3ConvexHullInternal::findEdgeForCoplanarFaces(Vertex* c0, Vertex* c1, Edge
Point32 d0 = f0->target->point - et0;
if (d0.dot(normal) == 0)
{
int64_t dx0 = d0.dot(perp);
int64_t dy0 = d0.dot(s);
int64_t dxn = (et1 - f0->target->point).dot(perp);
btInt64_t dx0 = d0.dot(perp);
btInt64_t dy0 = d0.dot(s);
btInt64_t dxn = (et1 - f0->target->point).dot(perp);
if ((dxn < 0) && ((dx0 == 0) ? (dy0 > 0) : ((dx0 < 0) && (Rational64(dy0, dx0).compare(Rational64(dy, dx)) < 0))))
{
e0 = f0;
@@ -1683,7 +1687,7 @@ void b3ConvexHullInternal::merge(IntermediateHull& h0, IntermediateHull& h1)
{
do
{
int64_t dot = (*e->target - *c0).dot(normal);
btInt64_t dot = (*e->target - *c0).dot(normal);
b3Assert(dot <= 0);
if ((dot == 0) && ((*e->target - *c0).dot(t) > 0))
{
@@ -1702,7 +1706,7 @@ void b3ConvexHullInternal::merge(IntermediateHull& h0, IntermediateHull& h1)
{
do
{
int64_t dot = (*e->target - *c1).dot(normal);
btInt64_t dot = (*e->target - *c1).dot(normal);
b3Assert(dot <= 0);
if ((dot == 0) && ((*e->target - *c1).dot(t) > 0))
{
@@ -1932,7 +1936,7 @@ void b3ConvexHullInternal::merge(IntermediateHull& h0, IntermediateHull& h1)
}
static bool pointCmp(const b3ConvexHullInternal::Point32& p, const b3ConvexHullInternal::Point32& q)
static bool b3PointCmp(const b3ConvexHullInternal::Point32& p, const b3ConvexHullInternal::Point32& q)
{
return (p.y < q.y) || ((p.y == q.y) && ((p.x < q.x) || ((p.x == q.x) && (p.z < q.z))));
}
@@ -2006,9 +2010,9 @@ void b3ConvexHullInternal::compute(const void* coords, bool doubleCoords, int st
b3Vector3 p((b3Scalar) v[0], (b3Scalar) v[1], (b3Scalar) v[2]);
ptr += stride;
p = (p - center) * s;
points[i].x = (int32_t) p[medAxis];
points[i].y = (int32_t) p[maxAxis];
points[i].z = (int32_t) p[minAxis];
points[i].x = (btInt32_t) p[medAxis];
points[i].y = (btInt32_t) p[maxAxis];
points[i].z = (btInt32_t) p[minAxis];
points[i].index = i;
}
}
@@ -2020,13 +2024,13 @@ void b3ConvexHullInternal::compute(const void* coords, bool doubleCoords, int st
b3Vector3 p(v[0], v[1], v[2]);
ptr += stride;
p = (p - center) * s;
points[i].x = (int32_t) p[medAxis];
points[i].y = (int32_t) p[maxAxis];
points[i].z = (int32_t) p[minAxis];
points[i].x = (btInt32_t) p[medAxis];
points[i].y = (btInt32_t) p[maxAxis];
points[i].z = (btInt32_t) p[minAxis];
points[i].index = i;
}
}
points.quickSort(pointCmp);
points.quickSort(b3PointCmp);
vertexPool.reset();
vertexPool.setArraySize(count);
@@ -2126,7 +2130,7 @@ b3Scalar b3ConvexHullInternal::shrink(b3Scalar amount, b3Scalar clampAmount)
{
if (a && b)
{
int64_t vol = (v->point - ref).dot((a->point - ref).cross(b->point - ref));
btInt64_t vol = (v->point - ref).dot((a->point - ref).cross(b->point - ref));
b3Assert(vol >= 0);
Point32 c = v->point + a->point + b->point + ref;
hullCenterX += vol * c.x;
@@ -2166,7 +2170,7 @@ b3Scalar b3ConvexHullInternal::shrink(b3Scalar amount, b3Scalar clampAmount)
if (clampAmount > 0)
{
b3Scalar minDist = SIMD_INFINITY;
b3Scalar minDist = B3_INFINITY;
for (int i = 0; i < faceCount; i++)
{
b3Vector3 normal = getBtNormal(faces[i]);
@@ -2217,7 +2221,7 @@ bool b3ConvexHullInternal::shiftFace(Face* face, b3Scalar amount, b3AlignedObjec
{
origShift[2] /= scaling[2];
}
Point32 shift((int32_t) origShift[medAxis], (int32_t) origShift[maxAxis], (int32_t) origShift[minAxis]);
Point32 shift((btInt32_t) origShift[medAxis], (btInt32_t) origShift[maxAxis], (btInt32_t) origShift[minAxis]);
if (shift.isZero())
{
return true;
@@ -2227,9 +2231,9 @@ bool b3ConvexHullInternal::shiftFace(Face* face, b3Scalar amount, b3AlignedObjec
printf("\nShrinking face (%d %d %d) (%d %d %d) (%d %d %d) by (%d %d %d)\n",
face->origin.x, face->origin.y, face->origin.z, face->dir0.x, face->dir0.y, face->dir0.z, face->dir1.x, face->dir1.y, face->dir1.z, shift.x, shift.y, shift.z);
#endif
int64_t origDot = face->origin.dot(normal);
btInt64_t origDot = face->origin.dot(normal);
Point32 shiftedOrigin = face->origin + shift;
int64_t shiftedDot = shiftedOrigin.dot(normal);
btInt64_t shiftedDot = shiftedOrigin.dot(normal);
b3Assert(shiftedDot <= origDot);
if (shiftedDot >= origDot)
{
@@ -2463,12 +2467,12 @@ bool b3ConvexHullInternal::shiftFace(Face* face, b3Scalar amount, b3AlignedObjec
Point64 n0 = intersection->face->getNormal();
Point64 n1 = intersection->reverse->face->getNormal();
int64_t m00 = face->dir0.dot(n0);
int64_t m01 = face->dir1.dot(n0);
int64_t m10 = face->dir0.dot(n1);
int64_t m11 = face->dir1.dot(n1);
int64_t r0 = (intersection->face->origin - shiftedOrigin).dot(n0);
int64_t r1 = (intersection->reverse->face->origin - shiftedOrigin).dot(n1);
btInt64_t m00 = face->dir0.dot(n0);
btInt64_t m01 = face->dir1.dot(n0);
btInt64_t m10 = face->dir0.dot(n1);
btInt64_t m11 = face->dir1.dot(n1);
btInt64_t r0 = (intersection->face->origin - shiftedOrigin).dot(n0);
btInt64_t r1 = (intersection->reverse->face->origin - shiftedOrigin).dot(n1);
Int128 det = Int128::mul(m00, m11) - Int128::mul(m01, m10);
b3Assert(det.getSign() != 0);
Vertex* v = vertexPool.newObject();
@@ -2481,9 +2485,9 @@ bool b3ConvexHullInternal::shiftFace(Face* face, b3Scalar amount, b3AlignedObjec
Int128::mul(face->dir0.z * r0, m11) - Int128::mul(face->dir0.z * r1, m01)
+ Int128::mul(face->dir1.z * r1, m00) - Int128::mul(face->dir1.z * r0, m10) + det * shiftedOrigin.z,
det);
v->point.x = (int32_t) v->point128.xvalue();
v->point.y = (int32_t) v->point128.yvalue();
v->point.z = (int32_t) v->point128.zvalue();
v->point.x = (btInt32_t) v->point128.xvalue();
v->point.y = (btInt32_t) v->point128.yvalue();
v->point.z = (btInt32_t) v->point128.zvalue();
intersection->target = v;
v->edges = e;

14
src/Bullet3Geometry/b3GrahamScan2dConvexHull.h
View File

@@ -14,16 +14,16 @@ subject to the following restrictions:
*/
#ifndef GRAHAM_SCAN_2D_CONVEX_HULL_H
#define GRAHAM_SCAN_2D_CONVEX_HULL_H
#ifndef B3_GRAHAM_SCAN_2D_CONVEX_HULL_H
#define B3_GRAHAM_SCAN_2D_CONVEX_HULL_H
#include "Bullet3Common/b3Vector3.h"
#include "Bullet3Common/b3AlignedObjectArray.h"
struct GrahamVector3 : public b3Vector3
struct b3GrahamVector3 : public b3Vector3
{
GrahamVector3(const b3Vector3& org, int orgIndex)
b3GrahamVector3(const b3Vector3& org, int orgIndex)
:b3Vector3(org),
m_orgIndex(orgIndex)
{
@@ -39,7 +39,7 @@ struct b3AngleCompareFunc {
: m_anchor(anchor)
{
}
bool operator()(const GrahamVector3& a, const GrahamVector3& b) const {
bool operator()(const b3GrahamVector3& a, const b3GrahamVector3& b) const {
if (a.m_angle != b.m_angle)
return a.m_angle < b.m_angle;
else
@@ -56,7 +56,7 @@ struct b3AngleCompareFunc {
}
};
inline void GrahamScanConvexHull2D(b3AlignedObjectArray<GrahamVector3>& originalPoints, b3AlignedObjectArray<GrahamVector3>& hull, const b3Vector3& normalAxis)
inline void b3GrahamScanConvexHull2D(b3AlignedObjectArray<b3GrahamVector3>& originalPoints, b3AlignedObjectArray<b3GrahamVector3>& hull, const b3Vector3& normalAxis)
{
b3Vector3 axis0,axis1;
b3PlaneSpace1(normalAxis,axis0,axis1);
@@ -114,4 +114,4 @@ inline void GrahamScanConvexHull2D(b3AlignedObjectArray<GrahamVector3>& original
}
}
#endif //GRAHAM_SCAN_2D_CONVEX_HULL_H
#endif //B3_GRAHAM_SCAN_2D_CONVEX_HULL_H