summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/bgfx/examples/common/bounds.cpp
diff options
context:
space:
mode:
Diffstat (limited to '3rdparty/bgfx/examples/common/bounds.cpp')
-rw-r--r--3rdparty/bgfx/examples/common/bounds.cpp1970
1 files changed, 1636 insertions, 334 deletions
diff --git a/3rdparty/bgfx/examples/common/bounds.cpp b/3rdparty/bgfx/examples/common/bounds.cpp
index 2d73dfcb973..ccc291d4c58 100644
--- a/3rdparty/bgfx/examples/common/bounds.cpp
+++ b/3rdparty/bgfx/examples/common/bounds.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright 2011-2018 Branimir Karadzic. All rights reserved.
+ * Copyright 2011-2019 Branimir Karadzic. All rights reserved.
* License: https://github.com/bkaradzic/bgfx#license-bsd-2-clause
*/
@@ -7,217 +7,213 @@
#include <bx/math.h>
#include "bounds.h"
-void aabbToObb(Obb& _obb, const Aabb& _aabb)
+using namespace bx;
+
+Vec3 getCenter(const Aabb& _aabb)
{
- bx::memSet(_obb.m_mtx, 0, sizeof(_obb.m_mtx) );
- _obb.m_mtx[ 0] = (_aabb.m_max.x - _aabb.m_min.x) * 0.5f;
- _obb.m_mtx[ 5] = (_aabb.m_max.y - _aabb.m_min.y) * 0.5f;
- _obb.m_mtx[10] = (_aabb.m_max.z - _aabb.m_min.z) * 0.5f;
- _obb.m_mtx[12] = (_aabb.m_min.x + _aabb.m_max.x) * 0.5f;
- _obb.m_mtx[13] = (_aabb.m_min.y + _aabb.m_max.y) * 0.5f;
- _obb.m_mtx[14] = (_aabb.m_min.z + _aabb.m_max.z) * 0.5f;
- _obb.m_mtx[15] = 1.0f;
+ return mul(add(_aabb.min, _aabb.max), 0.5f);
}
-void toAabb(Aabb& _aabb, const Obb& _obb)
+Vec3 getExtents(const Aabb& _aabb)
{
- bx::Vec3 xyz = { 1.0f, 1.0f, 1.0f };
- bx::Vec3 tmp = bx::mul(xyz, _obb.m_mtx);
-
- _aabb.m_min = tmp;
- _aabb.m_max = tmp;
+ return mul(sub(_aabb.max, _aabb.min), 0.5f);
+}
- for (uint32_t ii = 1; ii < 8; ++ii)
- {
- xyz.x = ii & 1 ? -1.0f : 1.0f;
- xyz.y = ii & 2 ? -1.0f : 1.0f;
- xyz.z = ii & 4 ? -1.0f : 1.0f;
- tmp = bx::mul(xyz, _obb.m_mtx);
+Vec3 getCenter(const Triangle& _triangle)
+{
+ return mul(add(add(_triangle.v0, _triangle.v1), _triangle.v2), 1.0f/3.0f);
+}
- _aabb.m_min = bx::min(_aabb.m_min, tmp);
- _aabb.m_max = bx::max(_aabb.m_max, tmp);
- }
+void toAabb(Aabb& _outAabb, const Vec3& _extents)
+{
+ _outAabb.min = neg(_extents);
+ _outAabb.max = _extents;
}
-void toAabb(Aabb& _aabb, const Sphere& _sphere)
+void toAabb(Aabb& _outAabb, const Vec3& _center, const Vec3& _extents)
{
- const float radius = _sphere.m_radius;
- _aabb.m_min = bx::sub(_sphere.m_center, radius);
- _aabb.m_max = bx::add(_sphere.m_center, radius);
+ _outAabb.min = sub(_center, _extents);
+ _outAabb.max = add(_center, _extents);
}
-void toAabb(Aabb& _aabb, const Disk& _disk)
+void toAabb(Aabb& _outAabb, const Cylinder& _cylinder)
{
// Reference(s):
// - https://web.archive.org/web/20181113055756/http://iquilezles.org/www/articles/diskbbox/diskbbox.htm
//
- const bx::Vec3 nsq = bx::mul(_disk.m_normal, _disk.m_normal);
- const bx::Vec3 one = { 1.0f, 1.0f, 1.0f };
- const bx::Vec3 tmp = bx::sub(one, nsq);
- const float inv = 1.0f / (tmp.x*tmp.y*tmp.z);
+ const Vec3 axis = sub(_cylinder.end, _cylinder.pos);
+ const Vec3 asq = mul(axis, axis);
+ const Vec3 nsq = mul(asq, 1.0f/dot(axis, axis) );
+ const Vec3 tmp = sub(Vec3(1.0f), nsq);
+
+ const float inv = 1.0f/(tmp.x*tmp.y*tmp.z);
- const bx::Vec3 extent =
+ const Vec3 extent =
{
- _disk.m_radius * tmp.x * bx::sqrt((nsq.x + nsq.y * nsq.z) * inv),
- _disk.m_radius * tmp.y * bx::sqrt((nsq.y + nsq.z * nsq.x) * inv),
- _disk.m_radius * tmp.z * bx::sqrt((nsq.z + nsq.x * nsq.y) * inv),
+ _cylinder.radius * tmp.x * sqrt( (nsq.x + nsq.y * nsq.z) * inv),
+ _cylinder.radius * tmp.y * sqrt( (nsq.y + nsq.z * nsq.x) * inv),
+ _cylinder.radius * tmp.z * sqrt( (nsq.z + nsq.x * nsq.y) * inv),
};
- _aabb.m_min = bx::sub(_disk.m_center, extent);
- _aabb.m_max = bx::add(_disk.m_center, extent);
+ const Vec3 minP = sub(_cylinder.pos, extent);
+ const Vec3 minE = sub(_cylinder.end, extent);
+ const Vec3 maxP = add(_cylinder.pos, extent);
+ const Vec3 maxE = add(_cylinder.end, extent);
+
+ _outAabb.min = min(minP, minE);
+ _outAabb.max = max(maxP, maxE);
}
-void toAabb(Aabb& _aabb, const Cylinder& _cylinder)
+void toAabb(Aabb& _outAabb, const Disk& _disk)
{
// Reference(s):
// - https://web.archive.org/web/20181113055756/http://iquilezles.org/www/articles/diskbbox/diskbbox.htm
//
- const bx::Vec3 axis = bx::sub(_cylinder.m_end, _cylinder.m_pos);
- const bx::Vec3 asq = bx::mul(axis, axis);
- const bx::Vec3 nsq = bx::mul(asq, 1.0f/bx::dot(axis, axis) );
- const bx::Vec3 one = { 1.0f, 1.0f, 1.0f };
- const bx::Vec3 tmp = bx::sub(one, nsq);
-
+ const Vec3 nsq = mul(_disk.normal, _disk.normal);
+ const Vec3 one = { 1.0f, 1.0f, 1.0f };
+ const Vec3 tmp = sub(one, nsq);
const float inv = 1.0f / (tmp.x*tmp.y*tmp.z);
- const bx::Vec3 extent =
+ const Vec3 extent =
{
- _cylinder.m_radius * tmp.x * bx::sqrt( (nsq.x + nsq.y * nsq.z) * inv),
- _cylinder.m_radius * tmp.y * bx::sqrt( (nsq.y + nsq.z * nsq.x) * inv),
- _cylinder.m_radius * tmp.z * bx::sqrt( (nsq.z + nsq.x * nsq.y) * inv),
+ _disk.radius * tmp.x * sqrt( (nsq.x + nsq.y * nsq.z) * inv),
+ _disk.radius * tmp.y * sqrt( (nsq.y + nsq.z * nsq.x) * inv),
+ _disk.radius * tmp.z * sqrt( (nsq.z + nsq.x * nsq.y) * inv),
};
- const bx::Vec3 minP = bx::sub(_cylinder.m_pos, extent);
- const bx::Vec3 minE = bx::sub(_cylinder.m_end, extent);
- const bx::Vec3 maxP = bx::add(_cylinder.m_pos, extent);
- const bx::Vec3 maxE = bx::add(_cylinder.m_end, extent);
+ _outAabb.min = sub(_disk.center, extent);
+ _outAabb.max = add(_disk.center, extent);
+}
+
+void toAabb(Aabb& _outAabb, const Obb& _obb)
+{
+ Vec3 xyz = { 1.0f, 1.0f, 1.0f };
+ Vec3 tmp = mul(xyz, _obb.mtx);
+
+ _outAabb.min = tmp;
+ _outAabb.max = tmp;
+
+ for (uint32_t ii = 1; ii < 8; ++ii)
+ {
+ xyz.x = ii & 1 ? -1.0f : 1.0f;
+ xyz.y = ii & 2 ? -1.0f : 1.0f;
+ xyz.z = ii & 4 ? -1.0f : 1.0f;
+ tmp = mul(xyz, _obb.mtx);
+
+ _outAabb.min = min(_outAabb.min, tmp);
+ _outAabb.max = max(_outAabb.max, tmp);
+ }
+}
+
+void toAabb(Aabb& _outAabb, const Sphere& _sphere)
+{
+ const float radius = _sphere.radius;
+ _outAabb.min = sub(_sphere.center, radius);
+ _outAabb.max = add(_sphere.center, radius);
+}
- _aabb.m_min = bx::min(minP, minE);
- _aabb.m_max = bx::max(maxP, maxE);
+void toAabb(Aabb& _outAabb, const Triangle& _triangle)
+{
+ _outAabb.min = min(_triangle.v0, _triangle.v1, _triangle.v2);
+ _outAabb.max = max(_triangle.v0, _triangle.v1, _triangle.v2);
}
void aabbTransformToObb(Obb& _obb, const Aabb& _aabb, const float* _mtx)
{
- aabbToObb(_obb, _aabb);
+ toObb(_obb, _aabb);
float result[16];
- bx::mtxMul(result, _obb.m_mtx, _mtx);
- bx::memCopy(_obb.m_mtx, result, sizeof(result) );
+ mtxMul(result, _obb.mtx, _mtx);
+ memCopy(_obb.mtx, result, sizeof(result) );
}
-void toAabb(Aabb& _aabb, const void* _vertices, uint32_t _numVertices, uint32_t _stride)
+void toAabb(Aabb& _outAabb, const void* _vertices, uint32_t _numVertices, uint32_t _stride)
{
- bx::Vec3 min, max;
+ Vec3 mn, mx;
uint8_t* vertex = (uint8_t*)_vertices;
- float* position = (float*)vertex;
- min.x = max.x = position[0];
- min.y = max.y = position[1];
- min.z = max.z = position[2];
+
+ mn = mx = load<Vec3>(vertex);
vertex += _stride;
for (uint32_t ii = 1; ii < _numVertices; ++ii)
{
- position = (float*)vertex;
+ const Vec3 pos = load<Vec3>(vertex);
vertex += _stride;
- bx::Vec3 pos =
- {
- position[0],
- position[1],
- position[2],
- };
- min = bx::min(pos, min);
- max = bx::max(pos, max);
+ mn = min(pos, mn);
+ mx = max(pos, mx);
}
- _aabb.m_min = min;
- _aabb.m_max = max;
+ _outAabb.min = mn;
+ _outAabb.max = mx;
}
-void toAabb(Aabb& _aabb, const float* _mtx, const void* _vertices, uint32_t _numVertices, uint32_t _stride)
+void toAabb(Aabb& _outAabb, const float* _mtx, const void* _vertices, uint32_t _numVertices, uint32_t _stride)
{
- bx::Vec3 min, max;
+ Vec3 mn, mx;
uint8_t* vertex = (uint8_t*)_vertices;
+ mn = mx = mul(load<Vec3>(vertex), _mtx);
- float position[3];
- bx::vec3MulMtx(position, (float*)vertex, _mtx);
- min.x = max.x = position[0];
- min.y = max.y = position[1];
- min.z = max.z = position[2];
vertex += _stride;
for (uint32_t ii = 1; ii < _numVertices; ++ii)
{
- bx::vec3MulMtx(position, (float*)vertex, _mtx);
+ Vec3 pos = mul(load<Vec3>(vertex), _mtx);
vertex += _stride;
- bx::Vec3 pos =
- {
- position[0],
- position[1],
- position[2],
- };
- min = bx::min(pos, min);
- max = bx::max(pos, max);
+ mn = min(pos, mn);
+ mx = max(pos, mx);
}
- _aabb.m_min = min;
- _aabb.m_max = max;
+ _outAabb.min = mn;
+ _outAabb.max = mx;
}
float calcAreaAabb(const Aabb& _aabb)
{
- const float ww = _aabb.m_max.x - _aabb.m_min.x;
- const float hh = _aabb.m_max.y - _aabb.m_min.y;
- const float dd = _aabb.m_max.z - _aabb.m_min.z;
+ const float ww = _aabb.max.x - _aabb.min.x;
+ const float hh = _aabb.max.y - _aabb.min.y;
+ const float dd = _aabb.max.z - _aabb.min.z;
return 2.0f * (ww*hh + ww*dd + hh*dd);
}
-void aabbExpand(Aabb& _aabb, float _factor)
+void aabbExpand(Aabb& _outAabb, float _factor)
{
- _aabb.m_min.x -= _factor;
- _aabb.m_min.y -= _factor;
- _aabb.m_min.z -= _factor;
- _aabb.m_max.x += _factor;
- _aabb.m_max.y += _factor;
- _aabb.m_max.z += _factor;
+ _outAabb.min.x -= _factor;
+ _outAabb.min.y -= _factor;
+ _outAabb.min.z -= _factor;
+ _outAabb.max.x += _factor;
+ _outAabb.max.y += _factor;
+ _outAabb.max.z += _factor;
}
-void aabbExpand(Aabb& _aabb, const float* _pos)
+void aabbExpand(Aabb& _outAabb, const Vec3& _pos)
{
- const bx::Vec3 pos = { _pos[0], _pos[1], _pos[2] };
- _aabb.m_min = bx::min(_aabb.m_min, pos);
- _aabb.m_max = bx::max(_aabb.m_max, pos);
+ _outAabb.min = min(_outAabb.min, _pos);
+ _outAabb.max = max(_outAabb.max, _pos);
}
-uint32_t aabbOverlapTest(const Aabb& _aabb0, const Aabb& _aabb1)
+void toObb(Obb& _outObb, const Aabb& _aabb)
{
- const uint32_t ltMinX = _aabb0.m_max.x < _aabb1.m_min.x;
- const uint32_t gtMaxX = _aabb0.m_min.x > _aabb1.m_max.x;
- const uint32_t ltMinY = _aabb0.m_max.y < _aabb1.m_min.y;
- const uint32_t gtMaxY = _aabb0.m_min.y > _aabb1.m_max.y;
- const uint32_t ltMinZ = _aabb0.m_max.z < _aabb1.m_min.z;
- const uint32_t gtMaxZ = _aabb0.m_min.z > _aabb1.m_max.z;
-
- return 0
- | (ltMinX<<0)
- | (gtMaxX<<1)
- | (ltMinY<<2)
- | (gtMaxY<<3)
- | (ltMinZ<<4)
- | (gtMaxZ<<5)
- ;
+ memSet(_outObb.mtx, 0, sizeof(_outObb.mtx) );
+ _outObb.mtx[ 0] = (_aabb.max.x - _aabb.min.x) * 0.5f;
+ _outObb.mtx[ 5] = (_aabb.max.y - _aabb.min.y) * 0.5f;
+ _outObb.mtx[10] = (_aabb.max.z - _aabb.min.z) * 0.5f;
+ _outObb.mtx[12] = (_aabb.min.x + _aabb.max.x) * 0.5f;
+ _outObb.mtx[13] = (_aabb.min.y + _aabb.max.y) * 0.5f;
+ _outObb.mtx[14] = (_aabb.min.z + _aabb.max.z) * 0.5f;
+ _outObb.mtx[15] = 1.0f;
}
-void calcObb(Obb& _obb, const void* _vertices, uint32_t _numVertices, uint32_t _stride, uint32_t _steps)
+void calcObb(Obb& _outObb, const void* _vertices, uint32_t _numVertices, uint32_t _stride, uint32_t _steps)
{
Aabb aabb;
toAabb(aabb, _vertices, _numVertices, _stride);
float minArea = calcAreaAabb(aabb);
Obb best;
- aabbToObb(best, aabb);
+ toObb(best, aabb);
- float angleStep = float(bx::kPiHalf/_steps);
+ float angleStep = float(kPiHalf/_steps);
float ax = 0.0f;
float mtx[16];
@@ -231,10 +227,10 @@ void calcObb(Obb& _obb, const void* _vertices, uint32_t _numVertices, uint32_t _
for (uint32_t kk = 0; kk < _steps; ++kk)
{
- bx::mtxRotateXYZ(mtx, ax, ay, az);
+ mtxRotateXYZ(mtx, ax, ay, az);
float mtxT[16];
- bx::mtxTranspose(mtxT, mtx);
+ mtxTranspose(mtxT, mtx);
toAabb(aabb, mtxT, _vertices, _numVertices, _stride);
float area = calcAreaAabb(aabb);
@@ -253,7 +249,7 @@ void calcObb(Obb& _obb, const void* _vertices, uint32_t _numVertices, uint32_t _
ax += angleStep;
}
- bx::memCopy(&_obb, &best, sizeof(Obb) );
+ memCopy(&_outObb, &best, sizeof(Obb) );
}
void calcMaxBoundingSphere(Sphere& _sphere, const void* _vertices, uint32_t _numVertices, uint32_t _stride)
@@ -261,39 +257,32 @@ void calcMaxBoundingSphere(Sphere& _sphere, const void* _vertices, uint32_t _num
Aabb aabb;
toAabb(aabb, _vertices, _numVertices, _stride);
- bx::Vec3 center =
- {
- (aabb.m_min.x + aabb.m_max.x) * 0.5f,
- (aabb.m_min.y + aabb.m_max.y) * 0.5f,
- (aabb.m_min.z + aabb.m_max.z) * 0.5f,
- };
+ Vec3 center = getCenter(aabb);
float maxDistSq = 0.0f;
uint8_t* vertex = (uint8_t*)_vertices;
for (uint32_t ii = 0; ii < _numVertices; ++ii)
{
- float* position = (float*)vertex;
+ const Vec3& pos = load<Vec3>(vertex);
vertex += _stride;
- const float xx = position[0] - center.x;
- const float yy = position[1] - center.y;
- const float zz = position[2] - center.z;
- const float distSq = xx*xx + yy*yy + zz*zz;
- maxDistSq = bx::max(distSq, maxDistSq);
+ const Vec3 tmp = sub(pos, center);
+ const float distSq = dot(tmp, tmp);
+ maxDistSq = max(distSq, maxDistSq);
}
- _sphere.m_center = center;
- _sphere.m_radius = bx::sqrt(maxDistSq);
+ _sphere.center = center;
+ _sphere.radius = sqrt(maxDistSq);
}
void calcMinBoundingSphere(Sphere& _sphere, const void* _vertices, uint32_t _numVertices, uint32_t _stride, float _step)
{
- bx::RngMwc rng;
+ RngMwc rng;
uint8_t* vertex = (uint8_t*)_vertices;
- bx::Vec3 center;
+ Vec3 center;
float* position = (float*)&vertex[0];
center.x = position[0];
center.y = position[1];
@@ -335,7 +324,7 @@ void calcMinBoundingSphere(Sphere& _sphere, const void* _vertices, uint32_t _num
center.x += xx * radiusStep;
center.y += yy * radiusStep;
center.z += zz * radiusStep;
- maxDistSq = bx::lerp(maxDistSq, distSq, _step);
+ maxDistSq = lerp(maxDistSq, distSq, _step);
break;
}
@@ -343,13 +332,8 @@ void calcMinBoundingSphere(Sphere& _sphere, const void* _vertices, uint32_t _num
} while (!done);
- _sphere.m_center = center;
- _sphere.m_radius = bx::sqrt(maxDistSq);
-}
-
-void calcPlaneUv(const Plane& _plane, bx::Vec3& _udir, bx::Vec3& _vdir)
-{
- bx::calcTangentFrame(_udir, _vdir, _plane.m_normal);
+ _sphere.center = center;
+ _sphere.radius = sqrt(maxDistSq);
}
void buildFrustumPlanes(Plane* _result, const float* _viewProj)
@@ -371,110 +355,92 @@ void buildFrustumPlanes(Plane* _result, const float* _viewProj)
Plane& top = _result[4];
Plane& bottom = _result[5];
- near.m_normal.x = xw - xz;
- near.m_normal.y = yw - yz;
- near.m_normal.z = zw - zz;
- near.m_dist = ww - wz;
+ near.normal.x = xw - xz;
+ near.normal.y = yw - yz;
+ near.normal.z = zw - zz;
+ near.dist = ww - wz;
- far.m_normal.x = xw + xz;
- far.m_normal.y = yw + yz;
- far.m_normal.z = zw + zz;
- far.m_dist = ww + wz;
+ far.normal.x = xw + xz;
+ far.normal.y = yw + yz;
+ far.normal.z = zw + zz;
+ far.dist = ww + wz;
const float xx = _viewProj[ 0];
const float yx = _viewProj[ 4];
const float zx = _viewProj[ 8];
const float wx = _viewProj[12];
- left.m_normal.x = xw - xx;
- left.m_normal.y = yw - yx;
- left.m_normal.z = zw - zx;
- left.m_dist = ww - wx;
+ left.normal.x = xw - xx;
+ left.normal.y = yw - yx;
+ left.normal.z = zw - zx;
+ left.dist = ww - wx;
- right.m_normal.x = xw + xx;
- right.m_normal.y = yw + yx;
- right.m_normal.z = zw + zx;
- right.m_dist = ww + wx;
+ right.normal.x = xw + xx;
+ right.normal.y = yw + yx;
+ right.normal.z = zw + zx;
+ right.dist = ww + wx;
const float xy = _viewProj[ 1];
const float yy = _viewProj[ 5];
const float zy = _viewProj[ 9];
const float wy = _viewProj[13];
- top.m_normal.x = xw + xy;
- top.m_normal.y = yw + yy;
- top.m_normal.z = zw + zy;
- top.m_dist = ww + wy;
+ top.normal.x = xw + xy;
+ top.normal.y = yw + yy;
+ top.normal.z = zw + zy;
+ top.dist = ww + wy;
- bottom.m_normal.x = xw - xy;
- bottom.m_normal.y = yw - yy;
- bottom.m_normal.z = zw - zy;
- bottom.m_dist = ww - wy;
+ bottom.normal.x = xw - xy;
+ bottom.normal.y = yw - yy;
+ bottom.normal.z = zw - zy;
+ bottom.dist = ww - wy;
Plane* plane = _result;
for (uint32_t ii = 0; ii < 6; ++ii)
{
- const float len = bx::length(plane->m_normal);
- plane->m_normal = bx::normalize(plane->m_normal);
- float invLen = 1.0f / len;
- plane->m_dist *= invLen;
+ const float invLen = 1.0f/length(plane->normal);
+ plane->normal = normalize(plane->normal);
+ plane->dist *= invLen;
++plane;
}
}
-bx::Vec3 intersectPlanes(const Plane& _pa, const Plane& _pb, const Plane& _pc)
-{
- const bx::Vec3 axb = bx::cross(_pa.m_normal, _pb.m_normal);
- const bx::Vec3 bxc = bx::cross(_pb.m_normal, _pc.m_normal);
- const bx::Vec3 cxa = bx::cross(_pc.m_normal, _pa.m_normal);
- const bx::Vec3 tmp0 = bx::mul(bxc, _pa.m_dist);
- const bx::Vec3 tmp1 = bx::mul(cxa, _pb.m_dist);
- const bx::Vec3 tmp2 = bx::mul(axb, _pc.m_dist);
- const bx::Vec3 tmp3 = bx::add(tmp0, tmp1);
- const bx::Vec3 tmp4 = bx::add(tmp3, tmp2);
-
- const float denom = bx::dot(_pa.m_normal, bxc);
- const bx::Vec3 result = bx::mul(tmp4, -1.0f/denom);
-
- return result;
-}
-
Ray makeRay(float _x, float _y, const float* _invVp)
{
Ray ray;
- const bx::Vec3 near = { _x, _y, 0.0f };
- ray.m_pos = bx::mulH(near, _invVp);
+ const Vec3 near = { _x, _y, 0.0f };
+ ray.pos = mulH(near, _invVp);
- const bx::Vec3 far = { _x, _y, 1.0f };
- bx::Vec3 tmp = bx::mulH(far, _invVp);
+ const Vec3 far = { _x, _y, 1.0f };
+ Vec3 tmp = mulH(far, _invVp);
- const bx::Vec3 dir = bx::sub(tmp, ray.m_pos);
- ray.m_dir = bx::normalize(dir);
+ const Vec3 dir = sub(tmp, ray.pos);
+ ray.dir = normalize(dir);
return ray;
}
-inline bx::Vec3 getPointAt(const Ray& _ray, float _t)
+inline Vec3 getPointAt(const Ray& _ray, float _t)
{
- return bx::add(bx::mul(_ray.m_dir, _t), _ray.m_pos);
+ return mad(_ray.dir, _t, _ray.pos);
}
bool intersect(const Ray& _ray, const Aabb& _aabb, Hit* _hit)
{
- const bx::Vec3 invDir = bx::rcp(_ray.m_dir);
- const bx::Vec3 tmp0 = bx::sub(_aabb.m_min, _ray.m_pos);
- const bx::Vec3 t0 = bx::mul(tmp0, invDir);
- const bx::Vec3 tmp1 = bx::sub(_aabb.m_max, _ray.m_pos);
- const bx::Vec3 t1 = bx::mul(tmp1, invDir);
+ const Vec3 invDir = rcp(_ray.dir);
+ const Vec3 tmp0 = sub(_aabb.min, _ray.pos);
+ const Vec3 t0 = mul(tmp0, invDir);
+ const Vec3 tmp1 = sub(_aabb.max, _ray.pos);
+ const Vec3 t1 = mul(tmp1, invDir);
- const bx::Vec3 min = bx::min(t0, t1);
- const bx::Vec3 max = bx::max(t0, t1);
+ const Vec3 mn = min(t0, t1);
+ const Vec3 mx = max(t0, t1);
- const float tmin = bx::max(min.x, min.y, min.z);
- const float tmax = bx::min(max.x, max.y, max.z);
+ const float tmin = max(mn.x, mn.y, mn.z);
+ const float tmax = min(mx.x, mx.y, mx.z);
- if (tmax < 0.0f
+ if (0.0f > tmax
|| tmin > tmax)
{
return false;
@@ -482,18 +448,18 @@ bool intersect(const Ray& _ray, const Aabb& _aabb, Hit* _hit)
if (NULL != _hit)
{
- _hit->m_normal.x = float( (t1.x == tmin) - (t0.x == tmin) );
- _hit->m_normal.y = float( (t1.y == tmin) - (t0.y == tmin) );
- _hit->m_normal.z = float( (t1.z == tmin) - (t0.z == tmin) );
+ _hit->plane.normal.x = float( (t1.x == tmin) - (t0.x == tmin) );
+ _hit->plane.normal.y = float( (t1.y == tmin) - (t0.y == tmin) );
+ _hit->plane.normal.z = float( (t1.z == tmin) - (t0.z == tmin) );
- _hit->m_dist = tmin;
- _hit->m_pos = getPointAt(_ray, tmin);
+ _hit->plane.dist = tmin;
+ _hit->pos = getPointAt(_ray, tmin);
}
return true;
}
-static const Aabb s_kUnitAabb =
+static constexpr Aabb kUnitAabb =
{
{ -1.0f, -1.0f, -1.0f },
{ 1.0f, 1.0f, 1.0f },
@@ -510,20 +476,20 @@ bool intersect(const Ray& _ray, const Obb& _obb, Hit* _hit)
}
float mtxInv[16];
- bx::mtxInverse(mtxInv, _obb.m_mtx);
+ mtxInverse(mtxInv, _obb.mtx);
Ray obbRay;
- obbRay.m_pos = bx::mul(_ray.m_pos, mtxInv);
- obbRay.m_dir = bx::mulXyz0(_ray.m_dir, mtxInv);
+ obbRay.pos = mul(_ray.pos, mtxInv);
+ obbRay.dir = mulXyz0(_ray.dir, mtxInv);
- if (intersect(obbRay, s_kUnitAabb, _hit) )
+ if (intersect(obbRay, kUnitAabb, _hit) )
{
if (NULL != _hit)
{
- _hit->m_pos = bx::mul(_hit->m_pos, _obb.m_mtx);
+ _hit->pos = mul(_hit->pos, _obb.mtx);
- const bx::Vec3 tmp = bx::mulXyz0(_hit->m_normal, _obb.m_mtx);
- _hit->m_normal = bx::normalize(tmp);
+ const Vec3 tmp = mulXyz0(_hit->plane.normal, _obb.mtx);
+ _hit->plane.normal = normalize(tmp);
}
return true;
@@ -535,16 +501,16 @@ bool intersect(const Ray& _ray, const Obb& _obb, Hit* _hit)
bool intersect(const Ray& _ray, const Disk& _disk, Hit* _hit)
{
Plane plane;
- plane.m_normal = _disk.m_normal;
- plane.m_dist = -bx::dot(_disk.m_center, _disk.m_normal);
+ plane.normal = _disk.normal;
+ plane.dist = -dot(_disk.center, _disk.normal);
Hit tmpHit;
_hit = NULL != _hit ? _hit : &tmpHit;
if (intersect(_ray, plane, _hit) )
{
- const bx::Vec3 tmp = bx::sub(_disk.m_center, _hit->m_pos);
- return bx::dot(tmp, tmp) <= bx::square(_disk.m_radius);
+ const Vec3 tmp = sub(_disk.center, _hit->pos);
+ return dot(tmp, tmp) <= square(_disk.radius);
}
return false;
@@ -552,54 +518,54 @@ bool intersect(const Ray& _ray, const Disk& _disk, Hit* _hit)
static bool intersect(const Ray& _ray, const Cylinder& _cylinder, bool _capsule, Hit* _hit)
{
- bx::Vec3 axis = bx::sub(_cylinder.m_end, _cylinder.m_pos);
- const bx::Vec3 rc = bx::sub(_ray.m_pos, _cylinder.m_pos);
- const bx::Vec3 dxa = bx::cross(_ray.m_dir, axis);
+ Vec3 axis = sub(_cylinder.end, _cylinder.pos);
+ const Vec3 rc = sub(_ray.pos, _cylinder.pos);
+ const Vec3 dxa = cross(_ray.dir, axis);
- const float len = bx::length(dxa);
- const bx::Vec3 normal = bx::normalize(dxa);
- const float dist = bx::abs(bx::dot(rc, normal) );
+ const float len = length(dxa);
+ const Vec3 normal = normalize(dxa);
+ const float dist = bx::abs(dot(rc, normal) );
- if (dist > _cylinder.m_radius)
+ if (dist > _cylinder.radius)
{
return false;
}
- bx::Vec3 vo = bx::cross(rc, axis);
- const float t0 = -bx::dot(vo, normal) / len;
+ Vec3 vo = cross(rc, axis);
+ const float t0 = -dot(vo, normal) / len;
- vo = bx::normalize(bx::cross(normal, axis) );
+ vo = normalize(cross(normal, axis) );
- const float rsq = bx::square(_cylinder.m_radius);
- const float ddoto = bx::dot(_ray.m_dir, vo);
- const float ss = t0 - bx::abs(bx::sqrt(rsq - bx::square(dist) ) / ddoto);
+ const float rsq = square(_cylinder.radius);
+ const float ddoto = dot(_ray.dir, vo);
+ const float ss = t0 - bx::abs(sqrt(rsq - square(dist) ) / ddoto);
if (0.0f > ss)
{
return false;
}
- const bx::Vec3 point = getPointAt(_ray, ss);
+ const Vec3 point = getPointAt(_ray, ss);
- const float axisLen = bx::length(axis);
- axis = bx::normalize(axis);
- const float pdota = bx::dot(_cylinder.m_pos, axis);
- const float height = bx::dot(point, axis) - pdota;
+ const float axisLen = length(axis);
+ axis = normalize(axis);
+ const float pdota = dot(_cylinder.pos, axis);
+ const float height = dot(point, axis) - pdota;
- if (height > 0.0f
- && height < axisLen)
+ if (0.0f < height
+ && axisLen > height)
{
if (NULL != _hit)
{
const float t1 = height / axisLen;
- const bx::Vec3 pointOnAxis = bx::lerp(_cylinder.m_pos, _cylinder.m_end, t1);
+ const Vec3 pointOnAxis = lerp(_cylinder.pos, _cylinder.end, t1);
- _hit->m_pos = point;
+ _hit->pos = point;
- const bx::Vec3 tmp = bx::sub(point, pointOnAxis);
- _hit->m_normal = bx::normalize(tmp);
+ const Vec3 tmp = sub(point, pointOnAxis);
+ _hit->plane.normal = normalize(tmp);
- _hit->m_dist = ss;
+ _hit->plane.dist = ss;
}
return true;
@@ -607,53 +573,53 @@ static bool intersect(const Ray& _ray, const Cylinder& _cylinder, bool _capsule,
if (_capsule)
{
- const float rdota = bx::dot(_ray.m_pos, axis);
+ const float rdota = dot(_ray.pos, axis);
const float pp = rdota - pdota;
const float t1 = pp / axisLen;
- const bx::Vec3 pointOnAxis = bx::lerp(_cylinder.m_pos, _cylinder.m_end, t1);
- const bx::Vec3 axisToRay = bx::sub(_ray.m_pos, pointOnAxis);
+ const Vec3 pointOnAxis = lerp(_cylinder.pos, _cylinder.end, t1);
+ const Vec3 axisToRay = sub(_ray.pos, pointOnAxis);
- if (_cylinder.m_radius < bx::length(axisToRay)
+ if (_cylinder.radius < length(axisToRay)
&& 0.0f > ss)
{
return false;
}
Sphere sphere;
- sphere.m_radius = _cylinder.m_radius;
+ sphere.radius = _cylinder.radius;
- sphere.m_center = 0.0f >= height
- ? _cylinder.m_pos
- : _cylinder.m_end
+ sphere.center = 0.0f >= height
+ ? _cylinder.pos
+ : _cylinder.end
;
return intersect(_ray, sphere, _hit);
}
Plane plane;
- bx::Vec3 pos;
+ Vec3 pos;
if (0.0f >= height)
{
- plane.m_normal = bx::neg(axis);
- pos = _cylinder.m_pos;
+ plane.normal = neg(axis);
+ pos = _cylinder.pos;
}
else
{
- plane.m_normal = axis;
- pos = _cylinder.m_end;
+ plane.normal = axis;
+ pos = _cylinder.end;
}
- plane.m_dist = -bx::dot(pos, plane.m_normal);
+ plane.dist = -dot(pos, plane.normal);
Hit tmpHit;
_hit = NULL != _hit ? _hit : &tmpHit;
if (intersect(_ray, plane, _hit) )
{
- const bx::Vec3 tmp = bx::sub(pos, _hit->m_pos);
- return bx::dot(tmp, tmp) <= rsq;
+ const Vec3 tmp = sub(pos, _hit->pos);
+ return dot(tmp, tmp) <= rsq;
}
return false;
@@ -672,30 +638,30 @@ bool intersect(const Ray& _ray, const Capsule& _capsule, Hit* _hit)
bool intersect(const Ray& _ray, const Cone& _cone, Hit* _hit)
{
- const bx::Vec3 axis = bx::sub(_cone.m_pos, _cone.m_end);
+ const Vec3 axis = sub(_cone.pos, _cone.end);
- const float len = bx::length(axis);
- const bx::Vec3 normal = bx::normalize(axis);
+ const float len = length(axis);
+ const Vec3 normal = normalize(axis);
Disk disk;
- disk.m_center = _cone.m_pos;
- disk.m_normal = normal;
- disk.m_radius = _cone.m_radius;
+ disk.center = _cone.pos;
+ disk.normal = normal;
+ disk.radius = _cone.radius;
Hit tmpInt;
Hit* out = NULL != _hit ? _hit : &tmpInt;
bool hit = intersect(_ray, disk, out);
- const bx::Vec3 ro = bx::sub(_ray.m_pos, _cone.m_end);
+ const Vec3 ro = sub(_ray.pos, _cone.end);
- const float hyp = bx::sqrt(bx::square(_cone.m_radius) + bx::square(len) );
- const float cosaSq = bx::square(len/hyp);
- const float ndoto = bx::dot(normal, ro);
- const float ndotd = bx::dot(normal, _ray.m_dir);
+ const float hyp = sqrt(square(_cone.radius) + square(len) );
+ const float cosaSq = square(len/hyp);
+ const float ndoto = dot(normal, ro);
+ const float ndotd = dot(normal, _ray.dir);
- const float aa = bx::square(ndotd) - cosaSq;
- const float bb = 2.0f * (ndotd*ndoto - bx::dot(_ray.m_dir, ro)*cosaSq);
- const float cc = bx::square(ndoto) - bx::dot(ro, ro)*cosaSq;
+ const float aa = square(ndotd) - cosaSq;
+ const float bb = 2.0f * (ndotd*ndoto - dot(_ray.dir, ro)*cosaSq);
+ const float cc = square(ndoto) - dot(ro, ro)*cosaSq;
float det = bb*bb - 4.0f*aa*cc;
@@ -704,7 +670,7 @@ bool intersect(const Ray& _ray, const Cone& _cone, Hit* _hit)
return hit;
}
- det = bx::sqrt(det);
+ det = sqrt(det);
const float invA2 = 1.0f / (2.0f*aa);
const float t1 = (-bb - det) * invA2;
const float t2 = (-bb + det) * invA2;
@@ -721,10 +687,10 @@ bool intersect(const Ray& _ray, const Cone& _cone, Hit* _hit)
return hit;
}
- const bx::Vec3 hitPos = getPointAt(_ray, tt);
- const bx::Vec3 point = bx::sub(hitPos, _cone.m_end);
+ const Vec3 hitPos = getPointAt(_ray, tt);
+ const Vec3 point = sub(hitPos, _cone.end);
- const float hh = bx::dot(normal, point);
+ const float hh = dot(normal, point);
if (0.0f > hh
|| len < hh)
@@ -735,16 +701,16 @@ bool intersect(const Ray& _ray, const Cone& _cone, Hit* _hit)
if (NULL != _hit)
{
if (!hit
- || tt < _hit->m_dist)
+ || tt < _hit->plane.dist)
{
- _hit->m_dist = tt;
- _hit->m_pos = hitPos;
+ _hit->plane.dist = tt;
+ _hit->pos = hitPos;
- const float scale = hh / bx::dot(point, point);
- const bx::Vec3 pointScaled = bx::mul(point, scale);
+ const float scale = hh / dot(point, point);
+ const Vec3 pointScaled = mul(point, scale);
- const bx::Vec3 tmp = bx::sub(pointScaled, normal);
- _hit->m_normal = bx::normalize(tmp);
+ const Vec3 tmp = sub(pointScaled, normal);
+ _hit->plane.normal = normalize(tmp);
}
}
@@ -753,13 +719,13 @@ bool intersect(const Ray& _ray, const Cone& _cone, Hit* _hit)
bool intersect(const Ray& _ray, const Plane& _plane, Hit* _hit)
{
- float equation = bx::dot(_ray.m_pos, _plane.m_normal) + _plane.m_dist;
- if (0.0f > equation)
+ const float dist = distance(_plane, _ray.pos);
+ if (0.0f > dist)
{
return false;
}
- float ndotd = bx::dot(_ray.m_dir, _plane.m_normal);
+ const float ndotd = dot(_ray.dir, _plane.normal);
if (0.0f < ndotd)
{
return false;
@@ -767,11 +733,11 @@ bool intersect(const Ray& _ray, const Plane& _plane, Hit* _hit)
if (NULL != _hit)
{
- _hit->m_normal = _plane.m_normal;
+ _hit->plane.normal = _plane.normal;
- float tt = -equation/ndotd;
- _hit->m_dist = tt;
- _hit->m_pos = getPointAt(_ray, tt);
+ float tt = -dist/ndotd;
+ _hit->plane.dist = tt;
+ _hit->pos = getPointAt(_ray, tt);
}
return true;
@@ -779,16 +745,16 @@ bool intersect(const Ray& _ray, const Plane& _plane, Hit* _hit)
bool intersect(const Ray& _ray, const Sphere& _sphere, Hit* _hit)
{
- const bx::Vec3 rs = bx::sub(_ray.m_pos, _sphere.m_center);
+ const Vec3 rs = sub(_ray.pos, _sphere.center);
- const float bb = bx::dot(rs, _ray.m_dir);
+ const float bb = dot(rs, _ray.dir);
if (0.0f < bb)
{
return false;
}
- const float aa = bx::dot(_ray.m_dir, _ray.m_dir);
- const float cc = bx::dot(rs, rs) - bx::square(_sphere.m_radius);
+ const float aa = dot(_ray.dir, _ray.dir);
+ const float cc = dot(rs, rs) - square(_sphere.radius);
const float discriminant = bb*bb - aa*cc;
@@ -797,7 +763,7 @@ bool intersect(const Ray& _ray, const Sphere& _sphere, Hit* _hit)
return false;
}
- const float sqrtDiscriminant = bx::sqrt(discriminant);
+ const float sqrtDiscriminant = sqrt(discriminant);
const float invA = 1.0f / aa;
const float tt = -(bb + sqrtDiscriminant)*invA;
@@ -808,50 +774,1386 @@ bool intersect(const Ray& _ray, const Sphere& _sphere, Hit* _hit)
if (NULL != _hit)
{
- _hit->m_dist = tt;
+ _hit->plane.dist = tt;
- const bx::Vec3 point = getPointAt(_ray, tt);
- _hit->m_pos = point;
+ const Vec3 point = getPointAt(_ray, tt);
+ _hit->pos = point;
- const bx::Vec3 tmp = bx::sub(point, _sphere.m_center);
- _hit->m_normal = bx::normalize(tmp);
+ const Vec3 tmp = sub(point, _sphere.center);
+ _hit->plane.normal = normalize(tmp);
}
return true;
}
-bool intersect(const Ray& _ray, const Tris& _triangle, Hit* _hit)
+bool intersect(const Ray& _ray, const Triangle& _triangle, Hit* _hit)
{
- const bx::Vec3 edge10 = bx::sub(_triangle.m_v1, _triangle.m_v0);
- const bx::Vec3 edge02 = bx::sub(_triangle.m_v0, _triangle.m_v2);
- const bx::Vec3 normal = bx::cross(edge02, edge10);
- const bx::Vec3 vo = bx::sub(_triangle.m_v0, _ray.m_pos);
- const bx::Vec3 dxo = bx::cross(_ray.m_dir, vo);
- const float det = bx::dot(normal, _ray.m_dir);
-
- if (det > 0.0f)
+ const Vec3 edge10 = sub(_triangle.v1, _triangle.v0);
+ const Vec3 edge02 = sub(_triangle.v0, _triangle.v2);
+ const Vec3 normal = cross(edge02, edge10);
+ const Vec3 vo = sub(_triangle.v0, _ray.pos);
+ const Vec3 dxo = cross(_ray.dir, vo);
+ const float det = dot(normal, _ray.dir);
+
+ if (0.0f < det)
{
return false;
}
const float invDet = 1.0f/det;
- const float bz = bx::dot(dxo, edge02) * invDet;
- const float by = bx::dot(dxo, edge10) * invDet;
+ const float bz = dot(dxo, edge02) * invDet;
+ const float by = dot(dxo, edge10) * invDet;
const float bx = 1.0f - by - bz;
- if (bx < 0.0f || by < 0.0f || bz < 0.0f)
+ if (0.0f > bx
+ || 0.0f > by
+ || 0.0f > bz)
+ {
+ return false;
+ }
+
+ if (NULL != _hit)
+ {
+ _hit->plane.normal = normalize(normal);
+
+ const float tt = dot(normal, vo) * invDet;
+ _hit->plane.dist = tt;
+ _hit->pos = getPointAt(_ray, tt);
+ }
+
+ return true;
+}
+
+Vec3 barycentric(const Triangle& _triangle, const Vec3& _pos)
+{
+ const Vec3 v0 = sub(_triangle.v1, _triangle.v0);
+ const Vec3 v1 = sub(_triangle.v2, _triangle.v0);
+ const Vec3 v2 = sub(_pos, _triangle.v0);
+
+ const float dot00 = dot(v0, v0);
+ const float dot01 = dot(v0, v1);
+ const float dot02 = dot(v0, v2);
+ const float dot11 = dot(v1, v1);
+ const float dot12 = dot(v1, v2);
+
+ const float invDenom = 1.0f/(dot00*dot11 - square(dot01) );
+
+ const float vv = (dot11*dot02 - dot01*dot12)*invDenom;
+ const float ww = (dot00*dot12 - dot01*dot02)*invDenom;
+ const float uu = 1.0f - vv - ww;
+
+ return { uu, vv, ww };
+}
+
+Vec3 cartesian(const Triangle& _triangle, const Vec3& _uvw)
+{
+ const Vec3 b0 = mul(_triangle.v0, _uvw.x);
+ const Vec3 b1 = mul(_triangle.v1, _uvw.y);
+ const Vec3 b2 = mul(_triangle.v2, _uvw.z);
+
+ return add(add(b0, b1), b2);
+}
+
+void calcPlane(Plane& _outPlane, const Disk& _disk)
+{
+ calcPlane(_outPlane, _disk.normal, _disk.center);
+}
+
+void calcPlane(Plane& _outPlane, const Triangle& _triangle)
+{
+ calcPlane(_outPlane, _triangle.v0, _triangle.v1, _triangle.v2);
+}
+
+struct Interval
+{
+ float start;
+ float end;
+};
+
+bool overlap(const Interval& _a, const Interval& _b)
+{
+ return _a.end > _b.start
+ && _b.end > _a.start
+ ;
+}
+
+float projectToAxis(const Vec3& _axis, const Vec3& _point)
+{
+ return dot(_axis, _point);
+}
+
+Interval projectToAxis(const Vec3& _axis, const Aabb& _aabb)
+{
+ const float extent = bx::abs(dot(abs(_axis), getExtents(_aabb) ) );
+ const float center = dot( _axis , getCenter (_aabb) );
+ return
+ {
+ center - extent,
+ center + extent,
+ };
+}
+
+Interval projectToAxis(const Vec3& _axis, const Triangle& _triangle)
+{
+ const float a0 = dot(_axis, _triangle.v0);
+ const float a1 = dot(_axis, _triangle.v1);
+ const float a2 = dot(_axis, _triangle.v2);
+ return
+ {
+ min(a0, a1, a2),
+ max(a0, a1, a2),
+ };
+}
+
+struct Srt
+{
+ Quaternion rotation;
+ Vec3 translation;
+ Vec3 scale;
+};
+
+Srt toSrt(const void* _mtx)
+{
+ Srt result;
+
+ const float* mtx = (const float*)_mtx;
+
+ result.translation = { mtx[12], mtx[13], mtx[14] };
+
+ float xx = mtx[ 0];
+ float xy = mtx[ 1];
+ float xz = mtx[ 2];
+ float yx = mtx[ 4];
+ float yy = mtx[ 5];
+ float yz = mtx[ 6];
+ float zx = mtx[ 8];
+ float zy = mtx[ 9];
+ float zz = mtx[10];
+
+ result.scale =
+ {
+ sqrt(xx*xx + xy*xy + xz*xz),
+ sqrt(yx*yx + yy*yy + yz*yz),
+ sqrt(zx*zx + zy*zy + zz*zz),
+ };
+
+ const Vec3 invScale = rcp(result.scale);
+
+ xx *= invScale.x;
+ xy *= invScale.x;
+ xz *= invScale.x;
+ yx *= invScale.y;
+ yy *= invScale.y;
+ yz *= invScale.y;
+ zx *= invScale.z;
+ zy *= invScale.z;
+ zz *= invScale.z;
+
+ const float trace = xx + yy + zz;
+
+ if (0.0f < trace)
+ {
+ const float invS = 0.5f * rsqrt(trace + 1.0f);
+ result.rotation =
+ {
+ (yz - zy) * invS,
+ (zx - xz) * invS,
+ (xy - yx) * invS,
+ 0.25f / invS,
+ };
+ }
+ else
+ {
+ if (xx > yy
+ && xx > zz)
+ {
+ const float invS = 0.5f * sqrt(max(1.0f + xx - yy - zz, 1e-8f) );
+ result.rotation =
+ {
+ 0.25f / invS,
+ (xy + yx) * invS,
+ (xz + zx) * invS,
+ (yz - zy) * invS,
+ };
+ }
+ else if (yy > zz)
+ {
+ const float invS = 0.5f * sqrt(max(1.0f + yy - xx - zz, 1e-8f) );
+ result.rotation =
+ {
+ (xy + yx) * invS,
+ 0.25f / invS,
+ (yz + zy) * invS,
+ (zx - xz) * invS,
+ };
+ }
+ else
+ {
+ const float invS = 0.5f * sqrt(max(1.0f + zz - xx - yy, 1e-8f) );
+ result.rotation =
+ {
+ (xz + zx) * invS,
+ (yz + zy) * invS,
+ 0.25f / invS,
+ (xy - yx) * invS,
+ };
+ }
+ }
+
+ return result;
+}
+
+void mtxFromSrt(float* _outMtx, const Srt& _srt)
+{
+ mtxQuat(_outMtx, _srt.rotation);
+
+ store<Vec3>(&_outMtx[0], mul(load<Vec3>(&_outMtx[0]), _srt.scale.x) );
+ store<Vec3>(&_outMtx[4], mul(load<Vec3>(&_outMtx[4]), _srt.scale.y) );
+ store<Vec3>(&_outMtx[8], mul(load<Vec3>(&_outMtx[8]), _srt.scale.z) );
+
+ store<Vec3>(&_outMtx[12], _srt.translation);
+}
+
+bool isNearZero(float _v)
+{
+ return equal(_v, 0.0f, 0.00001f);
+}
+
+bool isNearZero(const Vec3& _v)
+{
+ return isNearZero(dot(_v, _v) );
+}
+
+struct Line
+{
+ Vec3 pos;
+ Vec3 dir;
+};
+
+inline Vec3 getPointAt(const Line& _line, float _t)
+{
+ return mad(_line.dir, _t, _line.pos);
+}
+
+bool intersect(Line& _outLine, const Plane& _planeA, const Plane& _planeB)
+{
+ const Vec3 axb = cross(_planeA.normal, _planeB.normal);
+ const float denom = dot(axb, axb);
+
+ if (isNearZero(denom) )
+ {
+ return false;
+ }
+
+ const Vec3 bxaxb = cross(_planeB.normal, axb);
+ const Vec3 axbxa = cross(axb, _planeA.normal);
+ const Vec3 tmp0 = mul(bxaxb, _planeA.dist);
+ const Vec3 tmp1 = mul(axbxa, _planeB.dist);
+ const Vec3 tmp2 = add(tmp0, tmp1);
+
+ _outLine.pos = mul(tmp2, -1.0f/denom);
+ _outLine.dir = normalize(axb);
+
+ return true;
+}
+
+Vec3 intersectPlanes(const Plane& _pa, const Plane& _pb, const Plane& _pc)
+{
+ const Vec3 axb = cross(_pa.normal, _pb.normal);
+ const Vec3 bxc = cross(_pb.normal, _pc.normal);
+ const Vec3 cxa = cross(_pc.normal, _pa.normal);
+ const Vec3 tmp0 = mul(bxc, _pa.dist);
+ const Vec3 tmp1 = mul(cxa, _pb.dist);
+ const Vec3 tmp2 = mul(axb, _pc.dist);
+ const Vec3 tmp3 = add(tmp0, tmp1);
+ const Vec3 tmp4 = add(tmp3, tmp2);
+
+ const float denom = dot(_pa.normal, bxc);
+ const Vec3 result = mul(tmp4, -1.0f/denom);
+
+ return result;
+}
+
+struct LineSegment
+{
+ Vec3 pos;
+ Vec3 end;
+};
+
+inline Vec3 getPointAt(const LineSegment& _line, float _t)
+{
+ return lerp(_line.pos, _line.end, _t);
+}
+
+bool intersect(float& _outTa, float& _outTb, const LineSegment& _a, const LineSegment& _b)
+{
+ // Reference(s):
+ //
+ // - The shortest line between two lines in 3D
+ // https://web.archive.org/web/20120309093234/http://paulbourke.net/geometry/lineline3d/
+
+ const Vec3 bd = sub(_b.end, _b.pos);
+ if (isNearZero(bd) )
+ {
+ return false;
+ }
+
+ const Vec3 ad = sub(_a.end, _a.pos);
+ if (isNearZero(ad) )
+ {
+ return false;
+ }
+
+ const Vec3 ab = sub(_a.pos, _b.pos);
+
+ const float d0 = projectToAxis(ab, bd);
+ const float d1 = projectToAxis(ad, bd);
+ const float d2 = projectToAxis(ab, ad);
+ const float d3 = projectToAxis(bd, bd);
+ const float d4 = projectToAxis(ad, ad);
+
+ const float denom = d4*d3 - square(d1);
+
+ float ta = 0.0f;
+
+ if (!isNearZero(denom) )
+ {
+ ta = (d0*d1 - d2*d3)/denom;
+ }
+
+ _outTa = ta;
+ _outTb = (d0+d1*ta)/d3;
+
+ return true;
+}
+
+bool intersect(const LineSegment& _a, const LineSegment& _b)
+{
+ float ta, tb;
+ if (!intersect(ta, tb, _a, _b) )
+ {
+ return false;
+ }
+
+ return 0.0f >= ta
+ && 1.0f <= ta
+ && 0.0f >= tb
+ && 1.0f <= tb
+ ;
+}
+
+bool intersect(const LineSegment& _line, const Plane& _plane, Hit* _hit)
+{
+ const float dist = distance(_plane, _line.pos);
+ const float flip = sign(dist);
+ const Vec3 dir = normalize(sub(_line.end, _line.pos) );
+ const float ndotd = dot(dir, _plane.normal);
+ const float tt = -dist/ndotd;
+ const float len = length(sub(_line.end, _line.pos) );
+
+ if (tt < 0.0f || tt > len)
{
return false;
}
if (NULL != _hit)
{
- _hit->m_normal = bx::normalize(normal);
+ _hit->pos = mad(dir, tt, _line.pos);
+
+ _hit->plane.normal = mul(_plane.normal, flip);
+ _hit->plane.dist = -dot(_hit->plane.normal, _hit->pos);
+ }
+
+ return true;
+}
+
+float distance(const Plane& _plane, const LineSegment& _line)
+{
+ const float pd = distance(_plane, _line.pos);
+ const float ed = distance(_plane, _line.end);
+ return min(max(pd*ed, 0.0f), bx::abs(pd), bx::abs(ed) );
+}
+
+Vec3 closestPoint(const Line& _line, const Vec3& _point)
+{
+ const float tt = projectToAxis(_line.dir, sub(_point, _line.pos) );
+ return getPointAt(_line, tt);
+}
+
+Vec3 closestPoint(const LineSegment& _line, const Vec3& _point, float& _outT)
+{
+ const Vec3 axis = sub(_line.end, _line.pos);
+ const float lengthSq = dot(axis, axis);
+ const float tt = clamp(projectToAxis(axis, sub(_point, _line.pos) ) / lengthSq, 0.0f, 1.0f);
+ _outT = tt;
+ return mad(axis, tt, _line.pos);
+}
+
+Vec3 closestPoint(const LineSegment& _line, const Vec3& _point)
+{
+ float ignored;
+ return closestPoint(_line, _point, ignored);
+}
+
+Vec3 closestPoint(const Plane& _plane, const Vec3& _point)
+{
+ const float dist = distance(_plane, _point);
+ return sub(_point, mul(_plane.normal, dist) );
+}
+
+Vec3 closestPoint(const Aabb& _aabb, const Vec3& _point)
+{
+ return clamp(_point, _aabb.min, _aabb.max);
+}
+
+Vec3 closestPoint(const Obb& _obb, const Vec3& _point)
+{
+ Srt srt = toSrt(_obb.mtx);
+
+ Aabb aabb;
+ toAabb(aabb, srt.scale);
+
+ const Quaternion invRotation = invert(srt.rotation);
+ const Vec3 obbSpacePos = mul(sub(_point, srt.translation), srt.rotation);
+ const Vec3 pos = closestPoint(aabb, obbSpacePos);
+
+ return add(mul(pos, invRotation), srt.translation);
+}
+
+Vec3 closestPoint(const Triangle& _triangle, const Vec3& _point)
+{
+ Plane plane;
+ calcPlane(plane, _triangle);
+
+ const Vec3 pos = closestPoint(plane, _point);
+ const Vec3 uvw = barycentric(_triangle, pos);
+
+ return cartesian(_triangle, clamp<Vec3>(uvw, Vec3(0.0f), Vec3(1.0f) ) );
+}
+
+bool overlap(const Aabb& _aabb, const Vec3& _pos)
+{
+ const Vec3 ac = getCenter(_aabb);
+ const Vec3 ae = getExtents(_aabb);
+ const Vec3 abc = bx::abs(sub(ac, _pos) );
+
+ return abc.x <= ae.x
+ && abc.y <= ae.y
+ && abc.z <= ae.z
+ ;
+}
+
+bool overlap(const Aabb& _aabb, const Sphere& _sphere)
+{
+ return overlap(_sphere, _aabb);
+}
+
+bool overlap(const Aabb& _aabbA, const Aabb& _aabbB)
+{
+ return true
+ && _aabbA.max.x > _aabbB.min.x
+ && _aabbB.max.x > _aabbA.min.x
+ && _aabbA.max.y > _aabbB.min.y
+ && _aabbB.max.y > _aabbA.min.y
+ && _aabbA.max.z > _aabbB.min.z
+ && _aabbB.max.z > _aabbA.min.z
+ ;
+}
+
+bool overlap(const Aabb& _aabb, const Plane& _plane)
+{
+ const Vec3 center = getCenter(_aabb);
+ const float dist = distance(_plane, center);
+
+ const Vec3 extents = getExtents(_aabb);
+ const Vec3 normal = bx::abs(_plane.normal);
+ const float radius = dot(extents, normal);
+
+ return bx::abs(dist) <= radius;
+}
+
+static constexpr Vec3 kAxis[] =
+{
+ { 1.0f, 0.0f, 0.0f },
+ { 0.0f, 1.0f, 0.0f },
+ { 0.0f, 0.0f, 1.0f },
+};
+
+bool overlap(const Aabb& _aabb, const Triangle& _triangle)
+{
+ Aabb triAabb;
+ toAabb(triAabb, _triangle);
+
+ if (!overlap(_aabb, triAabb) )
+ {
+ return false;
+ }
+
+ Plane plane;
+ calcPlane(plane, _triangle);
+
+ if (!overlap(_aabb, plane) )
+ {
+ return false;
+ }
+
+ const Vec3 center = getCenter(_aabb);
+ const Vec3 v0 = sub(_triangle.v0, center);
+ const Vec3 v1 = sub(_triangle.v1, center);
+ const Vec3 v2 = sub(_triangle.v2, center);
+
+ const Vec3 edge[] =
+ {
+ sub(v1, v0),
+ sub(v2, v1),
+ sub(v0, v2),
+ };
+
+ for (uint32_t ii = 0; ii < 3; ++ii)
+ {
+ for (uint32_t jj = 0; jj < 3; ++jj)
+ {
+ const Vec3 axis = cross(kAxis[ii], edge[jj]);
+
+ const Interval aabbR = projectToAxis(axis, _aabb);
+ const Interval triR = projectToAxis(axis, _triangle);
- const float tt = bx::dot(normal, vo) * invDet;
- _hit->m_dist = tt;
- _hit->m_pos = getPointAt(_ray, tt);
+ if (!overlap(aabbR, triR) )
+ {
+ return false;
+ }
+ }
}
return true;
}
+
+bool overlap(const Aabb& _aabb, const Cylinder& _cylinder)
+{
+ return overlap(_cylinder, _aabb);
+}
+
+bool overlap(const Aabb& _aabb, const Capsule& _capsule)
+{
+ const Vec3 pos = closestPoint(LineSegment{_capsule.pos, _capsule.end}, getCenter(_aabb) );
+ return overlap(_aabb, Sphere{pos, _capsule.radius});
+}
+
+bool overlap(const Aabb& _aabb, const Cone& _cone)
+{
+ float tt;
+ const Vec3 pos = closestPoint(LineSegment{_cone.pos, _cone.end}, getCenter(_aabb), tt);
+ return overlap(_aabb, Sphere{pos, lerp(_cone.radius, 0.0f, tt)});
+}
+
+bool overlap(const Aabb& _aabb, const Disk& _disk)
+{
+ if (!overlap(_aabb, Sphere{_disk.center, _disk.radius}) )
+ {
+ return false;
+ }
+
+ Plane plane;
+ calcPlane(plane, _disk.normal, _disk.center);
+
+ return overlap(_aabb, plane);
+}
+
+bool overlap(const Aabb& _aabb, const Obb& _obb)
+{
+ BX_UNUSED(_aabb, _obb);
+ return false;
+}
+
+bool overlap(const Capsule& _capsule, const Vec3& _pos)
+{
+ const Vec3 pos = closestPoint(LineSegment{_capsule.pos, _capsule.end}, _pos);
+ return overlap(Sphere{pos, _capsule.radius}, _pos);
+}
+
+bool overlap(const Capsule& _capsule, const Sphere& _sphere)
+{
+ return overlap(_sphere, _capsule);
+}
+
+bool overlap(const Capsule& _capsule, const Aabb& _aabb)
+{
+ return overlap(_aabb, _capsule);
+}
+
+bool overlap(const Capsule& _capsule, const Plane& _plane)
+{
+ return distance(_plane, LineSegment{_capsule.pos, _capsule.end}) <= _capsule.radius;
+}
+
+bool overlap(const Capsule& _capsule, const Triangle& _triangle)
+{
+ return overlap(_triangle, _capsule);
+}
+
+bool overlap(const Capsule& _capsule, const Cylinder& _cylinder)
+{
+ return overlap(_cylinder, _capsule);
+}
+
+bool overlap(const Capsule& _capsuleA, const Capsule& _capsuleB)
+{
+ float ta, tb;
+ if (!intersect(ta, tb, {_capsuleA.pos, _capsuleA.end}, {_capsuleB.pos, _capsuleB.end}) )
+ {
+ return false;
+ }
+
+ if (0.0f <= ta
+ && 1.0f >= ta
+ && 0.0f <= tb
+ && 1.0f >= tb)
+ {
+ const Vec3 ad = sub(_capsuleA.end, _capsuleA.pos);
+ const Vec3 bd = sub(_capsuleB.end, _capsuleB.pos);
+
+ return overlap(
+ Sphere{mad(ad, ta, _capsuleA.pos), _capsuleA.radius}
+ , Sphere{mad(bd, tb, _capsuleB.pos), _capsuleB.radius}
+ );
+ }
+
+ if (0.0f <= ta
+ && 1.0f >= ta)
+ {
+ return overlap(_capsuleA, Sphere{0.0f >= tb ? _capsuleB.pos : _capsuleB.end, _capsuleB.radius});
+ }
+
+ if (0.0f <= tb
+ && 1.0f >= tb)
+ {
+ return overlap(_capsuleB, Sphere{0.0f >= ta ? _capsuleA.pos : _capsuleA.end, _capsuleA.radius});
+ }
+
+ const Vec3 pa = 0.0f > ta ? _capsuleA.pos : _capsuleA.end;
+ const Vec3 pb = 0.0f > tb ? _capsuleB.pos : _capsuleB.end;
+ const Vec3 closestA = closestPoint(LineSegment{_capsuleA.pos, _capsuleA.end}, pb);
+ const Vec3 closestB = closestPoint(LineSegment{_capsuleB.pos, _capsuleB.end}, pa);
+
+ if (dot(closestA, pb) <= dot(closestB, pa) )
+ {
+ return overlap(_capsuleA, Sphere{closestB, _capsuleB.radius});
+ }
+
+ return overlap(_capsuleB, Sphere{closestA, _capsuleA.radius});
+}
+
+bool overlap(const Capsule& _capsule, const Cone& _cone)
+{
+ BX_UNUSED(_capsule, _cone);
+ return false;
+}
+
+bool overlap(const Capsule& _capsule, const Disk& _disk)
+{
+ return overlap(_disk, _capsule);
+}
+
+bool overlap(const Capsule& _capsule, const Obb& _obb)
+{
+ return overlap(_obb, _capsule);
+}
+
+bool overlap(const Cone& _cone, const Vec3& _pos)
+{
+ float tt;
+ const Vec3 pos = closestPoint(LineSegment{_cone.pos, _cone.end}, _pos, tt);
+ return overlap(Disk{pos, normalize(sub(_cone.end, _cone.pos) ), lerp(_cone.radius, 0.0f, tt)}, _pos);
+}
+
+bool overlap(const Cone& _cone, const Sphere& _sphere)
+{
+ return overlap(_sphere, _cone);
+}
+
+bool overlap(const Cone& _cone, const Aabb& _aabb)
+{
+ return overlap(_aabb, _cone);
+}
+
+bool overlap(const Cone& _cone, const Plane& _plane)
+{
+ BX_UNUSED(_cone, _plane);
+ return false;
+}
+
+bool overlap(const Cone& _cone, const Triangle& _triangle)
+{
+ return overlap(_triangle, _cone);
+}
+
+bool overlap(const Cone& _cone, const Cylinder& _cylinder)
+{
+ BX_UNUSED(_cone, _cylinder);
+ return false;
+}
+
+bool overlap(const Cone& _cone, const Capsule& _capsule)
+{
+ BX_UNUSED(_cone, _capsule);
+ return false;
+}
+
+bool overlap(const Cone& _coneA, const Cone& _coneB)
+{
+ BX_UNUSED(_coneA, _coneB);
+ return false;
+}
+
+bool overlap(const Cone& _cone, const Disk& _disk)
+{
+ BX_UNUSED(_cone, _disk);
+ return false;
+}
+
+bool overlap(const Cone& _cone, const Obb& _obb)
+{
+ BX_UNUSED(_cone, _obb);
+ return false;
+}
+
+bool overlap(const Cylinder& _cylinder, const Vec3& _pos)
+{
+ const Vec3 pos = closestPoint(LineSegment{_cylinder.pos, _cylinder.end}, _pos);
+ return overlap(Disk{pos, normalize(sub(_cylinder.end, _cylinder.pos) ), _cylinder.radius}, _pos);
+}
+
+bool overlap(const Cylinder& _cylinder, const Sphere& _sphere)
+{
+ const Vec3 pos = closestPoint(LineSegment{_cylinder.pos, _cylinder.end}, _sphere.center);
+ return overlap(Disk{pos, normalize(sub(_cylinder.end, _cylinder.pos) ), _cylinder.radius}, _sphere);
+}
+
+bool overlap(const Cylinder& _cylinder, const Aabb& _aabb)
+{
+ const Vec3 pos = closestPoint(LineSegment{_cylinder.pos, _cylinder.end}, getCenter(_aabb) );
+ return overlap(Disk{pos, normalize(sub(_cylinder.end, _cylinder.pos) ), _cylinder.radius}, _aabb);
+}
+
+bool overlap(const Cylinder& _cylinder, const Plane& _plane)
+{
+ BX_UNUSED(_cylinder, _plane);
+ return false;
+}
+
+bool overlap(const Cylinder& _cylinder, const Triangle& _triangle)
+{
+ return overlap(_triangle, _cylinder);
+}
+
+bool overlap(const Cylinder& _cylinderA, const Cylinder& _cylinderB)
+{
+ BX_UNUSED(_cylinderA, _cylinderB);
+ return false;
+}
+
+bool overlap(const Cylinder& _cylinder, const Capsule& _capsule)
+{
+ BX_UNUSED(_cylinder, _capsule);
+ return false;
+}
+
+bool overlap(const Cylinder& _cylinder, const Cone& _cone)
+{
+ BX_UNUSED(_cylinder, _cone);
+ return false;
+}
+
+bool overlap(const Cylinder& _cylinder, const Disk& _disk)
+{
+ BX_UNUSED(_cylinder, _disk);
+ return false;
+}
+
+bool overlap(const Cylinder& _cylinder, const Obb& _obb)
+{
+ BX_UNUSED(_cylinder, _obb);
+ return false;
+}
+
+bool overlap(const Disk& _disk, const Vec3& _pos)
+{
+ Plane plane;
+ calcPlane(plane, _disk.normal, _disk.center);
+
+ if (!isNearZero(distance(plane, _pos) ) )
+ {
+ return false;
+ }
+
+ return distanceSq(_disk.center, _pos) <= square(_disk.radius);
+}
+
+bool overlap(const Disk& _disk, const Sphere& _sphere)
+{
+ return overlap(_sphere, _disk);
+}
+
+bool overlap(const Disk& _disk, const Aabb& _aabb)
+{
+ return overlap(_aabb, _disk);
+}
+
+bool overlap(const Disk& _disk, const Plane& _plane)
+{
+ Plane plane;
+ calcPlane(plane, _disk.normal, _disk.center);
+
+ if (!overlap(plane, _plane) )
+ {
+ return false;
+ }
+
+ return overlap(_plane, Sphere{_disk.center, _disk.radius});
+}
+
+bool overlap(const Disk& _disk, const Triangle& _triangle)
+{
+ return overlap(_triangle, _disk);
+}
+
+bool overlap(const Disk& _disk, const Cylinder& _cylinder)
+{
+ return overlap(_cylinder, _disk);
+}
+
+bool overlap(const Disk& _disk, const Capsule& _capsule)
+{
+ if (!overlap(_capsule, Sphere{_disk.center, _disk.radius}) )
+ {
+ return false;
+ }
+
+ Plane plane;
+ calcPlane(plane, _disk.normal, _disk.center);
+
+ return overlap(_capsule, plane);
+}
+
+bool overlap(const Disk& _disk, const Cone& _cone)
+{
+ BX_UNUSED(_disk, _cone);
+ return false;
+}
+
+bool overlap(const Disk& _diskA, const Disk& _diskB)
+{
+ Plane planeA;
+ calcPlane(planeA, _diskA.normal, _diskA.center);
+
+ Plane planeB;
+ calcPlane(planeB, _diskB);
+
+ Line line;
+
+ if (!intersect(line, planeA, planeB) )
+ {
+ return false;
+ }
+
+ const Vec3 pa = closestPoint(line, _diskA.center);
+ const Vec3 pb = closestPoint(line, _diskB.center);
+
+ const float lenA = distance(pa, _diskA.center);
+ const float lenB = distance(pb, _diskB.center);
+
+ return sqrt(square(_diskA.radius) - square(lenA) )
+ + sqrt(square(_diskB.radius) - square(lenB) )
+ >= distance(pa, pb)
+ ;
+}
+
+bool overlap(const Disk& _disk, const Obb& _obb)
+{
+ if (!overlap(_obb, Sphere{_disk.center, _disk.radius}) )
+ {
+ return false;
+ }
+
+ Plane plane;
+ calcPlane(plane, _disk.normal, _disk.center);
+
+ return overlap(_obb, plane);
+}
+
+bool overlap(const Obb& _obb, const Vec3& _pos)
+{
+ Srt srt = toSrt(_obb.mtx);
+
+ Aabb aabb;
+ toAabb(aabb, srt.scale);
+
+ const Quaternion invRotation = invert(srt.rotation);
+ const Vec3 pos = mul(sub(_pos, srt.translation), invRotation);
+
+ return overlap(aabb, pos);
+}
+
+bool overlap(const Obb& _obb, const Sphere& _sphere)
+{
+ return overlap(_sphere, _obb);
+}
+
+bool overlap(const Obb& _obb, const Aabb& _aabb)
+{
+ return overlap(_aabb, _obb);
+}
+
+bool overlap(const Obb& _obb, const Plane& _plane)
+{
+ Srt srt = toSrt(_obb.mtx);
+
+ const Quaternion invRotation = invert(srt.rotation);
+ const Vec3 axis =
+ {
+ projectToAxis(_plane.normal, mul(Vec3{1.0f, 0.0f, 0.0f}, invRotation) ),
+ projectToAxis(_plane.normal, mul(Vec3{0.0f, 1.0f, 0.0f}, invRotation) ),
+ projectToAxis(_plane.normal, mul(Vec3{0.0f, 0.0f, 1.0f}, invRotation) ),
+ };
+
+ const float dist = bx::abs(distance(_plane, srt.translation) );
+ const float radius = dot(srt.scale, bx::abs(axis) );
+
+ return dist <= radius;
+}
+
+bool overlap(const Obb& _obb, const Triangle& _triangle)
+{
+ return overlap(_triangle, _obb);
+}
+
+bool overlap(const Obb& _obb, const Cylinder& _cylinder)
+{
+ BX_UNUSED(_obb, _cylinder);
+ return false;
+}
+
+bool overlap(const Obb& _obb, const Capsule& _capsule)
+{
+ Srt srt = toSrt(_obb.mtx);
+
+ Aabb aabb;
+ toAabb(aabb, srt.scale);
+
+ const Quaternion invRotation = invert(srt.rotation);
+
+ const Capsule capsule =
+ {
+ mul(sub(_capsule.pos, srt.translation), invRotation),
+ mul(sub(_capsule.end, srt.translation), invRotation),
+ _capsule.radius,
+ };
+
+ return overlap(aabb, capsule);
+}
+
+bool overlap(const Obb& _obb, const Cone& _cone)
+{
+ BX_UNUSED(_obb, _cone);
+ return false;
+}
+
+bool overlap(const Obb& _obb, const Disk& _disk)
+{
+ return overlap(_disk, _obb);
+}
+
+bool overlap(const Obb& _obbA, const Obb& _obbB)
+{
+ BX_UNUSED(_obbA, _obbB);
+ return false;
+}
+
+bool overlap(const Plane& _plane, const Vec3& _pos)
+{
+ return isNearZero(distance(_plane, _pos) );
+}
+
+bool overlap(const Plane& _plane, const Sphere& _sphere)
+{
+ return overlap(_sphere, _plane);
+}
+
+bool overlap(const Plane& _plane, const Aabb& _aabb)
+{
+ return overlap(_aabb, _plane);
+}
+
+bool overlap(const Plane& _planeA, const Plane& _planeB)
+{
+ const Vec3 dir = cross(_planeA.normal, _planeB.normal);
+ const float len = length(dir);
+
+ return !isNearZero(len);
+}
+
+bool overlap(const Plane& _plane, const Triangle& _triangle)
+{
+ return overlap(_triangle, _plane);
+}
+
+bool overlap(const Plane& _plane, const Cylinder& _cylinder)
+{
+ return overlap(_cylinder, _plane);
+}
+
+bool overlap(const Plane& _plane, const Capsule& _capsule)
+{
+ return overlap(_capsule, _plane);
+}
+
+bool overlap(const Plane& _plane, const Cone& _cone)
+{
+ BX_UNUSED(_plane, _cone);
+ return false;
+}
+
+bool overlap(const Plane& _plane, const Disk& _disk)
+{
+ return overlap(_disk, _plane);
+}
+
+bool overlap(const Plane& _plane, const Obb& _obb)
+{
+ return overlap(_obb, _plane);
+}
+
+bool overlap(const Sphere& _sphere, const Vec3& _pos)
+{
+ const float distSq = distanceSq(_sphere.center, _pos);
+ const float radiusSq = square(_sphere.radius);
+ return distSq <= radiusSq;
+}
+
+bool overlap(const Sphere& _sphereA, const Sphere& _sphereB)
+{
+ const float distSq = distanceSq(_sphereA.center, _sphereB.center);
+ const float radiusSq = square(_sphereA.radius + _sphereB.radius);
+ return distSq <= radiusSq;
+}
+
+bool overlap(const Sphere& _sphere, const Aabb& _aabb)
+{
+ const Vec3 pos = closestPoint(_aabb, _sphere.center);
+ return overlap(_sphere, pos);
+}
+
+bool overlap(const Sphere& _sphere, const Plane& _plane)
+{
+ return bx::abs(distance(_plane, _sphere.center) ) <= _sphere.radius;
+}
+
+bool overlap(const Sphere& _sphere, const Triangle& _triangle)
+{
+ Plane plane;
+ calcPlane(plane, _triangle);
+
+ if (!overlap(_sphere, plane) )
+ {
+ return false;
+ }
+
+ const Vec3 pos = closestPoint(plane, _sphere.center);
+ const Vec3 uvw = barycentric(_triangle, pos);
+ const float nr = -_sphere.radius;
+
+ return uvw.x >= nr
+ && uvw.y >= nr
+ && uvw.z >= nr
+ ;
+}
+
+bool overlap(const Sphere& _sphere, const Cylinder& _cylinder)
+{
+ return overlap(_cylinder, _sphere);
+}
+
+bool overlap(const Sphere& _sphere, const Capsule& _capsule)
+{
+ const Vec3 pos = closestPoint(LineSegment{_capsule.pos, _capsule.end}, _sphere.center);
+ return overlap(_sphere, Sphere{pos, _capsule.radius});
+}
+
+bool overlap(const Sphere& _sphere, const Cone& _cone)
+{
+ float tt;
+ const Vec3 pos = closestPoint(LineSegment{_cone.pos, _cone.end}, _sphere.center, tt);
+ return overlap(_sphere, Sphere{pos, lerp(_cone.radius, 0.0f, tt)});
+}
+
+bool overlap(const Sphere& _sphere, const Disk& _disk)
+{
+ if (!overlap(_sphere, Sphere{_disk.center, _disk.radius}) )
+ {
+ return false;
+ }
+
+ Plane plane;
+ calcPlane(plane, _disk.normal, _disk.center);
+
+ return overlap(_sphere, plane);
+}
+
+bool overlap(const Sphere& _sphere, const Obb& _obb)
+{
+ const Vec3 pos = closestPoint(_obb, _sphere.center);
+ return overlap(_sphere, pos);
+}
+
+bool overlap(const Triangle& _triangle, const Vec3& _pos)
+{
+ const Vec3 uvw = barycentric(_triangle, _pos);
+
+ return uvw.x >= 0.0f
+ && uvw.y >= 0.0f
+ && uvw.z >= 0.0f
+ ;
+}
+
+bool overlap(const Triangle& _triangle, const Sphere& _sphere)
+{
+ return overlap(_sphere, _triangle);
+}
+
+bool overlap(const Triangle& _triangle, const Aabb& _aabb)
+{
+ return overlap(_aabb, _triangle);
+}
+
+bool overlap(const Triangle& _triangle, const Plane& _plane)
+{
+ const float dist0 = distance(_plane, _triangle.v0);
+ const float dist1 = distance(_plane, _triangle.v1);
+ const float dist2 = distance(_plane, _triangle.v2);
+
+ const float minDist = min(dist0, dist1, dist2);
+ const float maxDist = max(dist0, dist1, dist2);
+
+ return 0.0f > minDist
+ && 0.0f < maxDist
+ ;
+}
+
+inline bool overlap(const Triangle& _triangleA, const Triangle& _triangleB, const Vec3& _axis)
+{
+ const Interval ia = projectToAxis(_axis, _triangleA);
+ const Interval ib = projectToAxis(_axis, _triangleB);
+ return overlap(ia, ib);
+}
+
+bool overlap(const Triangle& _triangleA, const Triangle& _triangleB)
+{
+ const Vec3 baA = sub(_triangleA.v1, _triangleA.v0);
+ const Vec3 cbA = sub(_triangleA.v2, _triangleA.v1);
+ const Vec3 acA = sub(_triangleA.v0, _triangleA.v2);
+
+ const Vec3 baB = sub(_triangleB.v1, _triangleB.v0);
+ const Vec3 cbB = sub(_triangleB.v2, _triangleB.v1);
+ const Vec3 acB = sub(_triangleB.v0, _triangleB.v2);
+
+ return overlap(_triangleA, _triangleB, cross(baA, cbA) )
+ && overlap(_triangleA, _triangleB, cross(baB, cbB) )
+ && overlap(_triangleA, _triangleB, cross(baB, baA) )
+ && overlap(_triangleA, _triangleB, cross(baB, cbA) )
+ && overlap(_triangleA, _triangleB, cross(baB, acA) )
+ && overlap(_triangleA, _triangleB, cross(cbB, baA) )
+ && overlap(_triangleA, _triangleB, cross(cbB, cbA) )
+ && overlap(_triangleA, _triangleB, cross(cbB, acA) )
+ && overlap(_triangleA, _triangleB, cross(acB, baA) )
+ && overlap(_triangleA, _triangleB, cross(acB, cbA) )
+ && overlap(_triangleA, _triangleB, cross(acB, acA) )
+ ;
+}
+
+template<typename Ty>
+bool overlap(const Triangle& _triangle, const Ty& _ty)
+{
+ Plane plane;
+ calcPlane(plane, _triangle);
+
+ plane.normal = neg(plane.normal);
+ plane.dist = -plane.dist;
+
+ const LineSegment line =
+ {
+ _ty.pos,
+ _ty.end,
+ };
+
+ Hit hit;
+ if (intersect(line, plane, &hit) )
+ {
+ return true;
+ }
+
+ const Vec3 pos = closestPoint(plane, hit.pos);
+ const Vec3 uvw = barycentric(_triangle, pos);
+
+ const float nr = -_ty.radius;
+
+ if (uvw.x >= nr
+ && uvw.y >= nr
+ && uvw.z >= nr)
+ {
+ return true;
+ }
+
+ const LineSegment ab = LineSegment{_triangle.v0, _triangle.v1};
+ const LineSegment bc = LineSegment{_triangle.v1, _triangle.v2};
+ const LineSegment ca = LineSegment{_triangle.v2, _triangle.v0};
+
+ float ta0, tb0;
+ const bool i0 = intersect(ta0, tb0, ab, line);
+
+ float ta1, tb1;
+ const bool i1 = intersect(ta1, tb1, bc, line);
+
+ float ta2, tb2;
+ const bool i2 = intersect(ta2, tb2, ca, line);
+
+ if (!i0
+ || !i1
+ || !i2)
+ {
+ return false;
+ }
+
+ ta0 = clamp(ta0, 0.0f, 1.0f);
+ ta1 = clamp(ta1, 0.0f, 1.0f);
+ ta2 = clamp(ta2, 0.0f, 1.0f);
+ tb0 = clamp(tb0, 0.0f, 1.0f);
+ tb1 = clamp(tb1, 0.0f, 1.0f);
+ tb2 = clamp(tb2, 0.0f, 1.0f);
+
+ const Vec3 pa0 = getPointAt(ab, ta0);
+ const Vec3 pa1 = getPointAt(bc, ta1);
+ const Vec3 pa2 = getPointAt(ca, ta2);
+
+ const Vec3 pb0 = getPointAt(line, tb0);
+ const Vec3 pb1 = getPointAt(line, tb1);
+ const Vec3 pb2 = getPointAt(line, tb2);
+
+ const float d0 = distanceSq(pa0, pb0);
+ const float d1 = distanceSq(pa1, pb1);
+ const float d2 = distanceSq(pa2, pb2);
+
+ if (d0 <= d1
+ && d0 <= d2)
+ {
+ return overlap(_ty, pa0);
+ }
+ else if (d1 <= d2)
+ {
+ return overlap(_ty, pa1);
+ }
+
+ return overlap(_ty, pa2);
+}
+
+bool overlap(const Triangle& _triangle, const Cylinder& _cylinder)
+{
+ return overlap<Cylinder>(_triangle, _cylinder);
+}
+
+bool overlap(const Triangle& _triangle, const Capsule& _capsule)
+{
+ return overlap<Capsule>(_triangle, _capsule);
+}
+
+bool overlap(const Triangle& _triangle, const Cone& _cone)
+{
+ const LineSegment ab = LineSegment{_triangle.v0, _triangle.v1};
+ const LineSegment bc = LineSegment{_triangle.v1, _triangle.v2};
+ const LineSegment ca = LineSegment{_triangle.v2, _triangle.v0};
+
+ const LineSegment line =
+ {
+ _cone.pos,
+ _cone.end,
+ };
+
+ float ta0 = 0.0f, tb0 = 0.0f;
+ const bool i0 = intersect(ta0, tb0, ab, line);
+
+ float ta1, tb1;
+ const bool i1 = intersect(ta1, tb1, bc, line);
+
+ float ta2, tb2;
+ const bool i2 = intersect(ta2, tb2, ca, line);
+
+ if (!i0
+ || !i1
+ || !i2)
+ {
+ return false;
+ }
+
+ ta0 = clamp(ta0, 0.0f, 1.0f);
+ ta1 = clamp(ta1, 0.0f, 1.0f);
+ ta2 = clamp(ta2, 0.0f, 1.0f);
+ tb0 = clamp(tb0, 0.0f, 1.0f);
+ tb1 = clamp(tb1, 0.0f, 1.0f);
+ tb2 = clamp(tb2, 0.0f, 1.0f);
+
+ const Vec3 pa0 = getPointAt(ab, ta0);
+ const Vec3 pa1 = getPointAt(bc, ta1);
+ const Vec3 pa2 = getPointAt(ca, ta2);
+
+ const Vec3 pb0 = getPointAt(line, tb0);
+ const Vec3 pb1 = getPointAt(line, tb1);
+ const Vec3 pb2 = getPointAt(line, tb2);
+
+ const float d0 = distanceSq(pa0, pb0);
+ const float d1 = distanceSq(pa1, pb1);
+ const float d2 = distanceSq(pa2, pb2);
+
+ if (d0 <= d1
+ && d0 <= d2)
+ {
+ return overlap(_cone, pa0);
+ }
+ else if (d1 <= d2)
+ {
+ return overlap(_cone, pa1);
+ }
+
+ return overlap(_cone, pa2);
+}
+
+bool overlap(const Triangle& _triangle, const Disk& _disk)
+{
+ if (!overlap(_triangle, Sphere{_disk.center, _disk.radius}) )
+ {
+ return false;
+ }
+
+ Plane plane;
+ calcPlane(plane, _disk.normal, _disk.center);
+
+ return overlap(_triangle, plane);
+}
+
+bool overlap(const Triangle& _triangle, const Obb& _obb)
+{
+ Srt srt = toSrt(_obb.mtx);
+
+ Aabb aabb;
+ toAabb(aabb, srt.scale);
+
+ const Quaternion invRotation = invert(srt.rotation);
+
+ const Triangle triangle =
+ {
+ mul(sub(_triangle.v0, srt.translation), invRotation),
+ mul(sub(_triangle.v1, srt.translation), invRotation),
+ mul(sub(_triangle.v2, srt.translation), invRotation),
+ };
+
+ return overlap(triangle, aabb);
+}
+