nerdcruft/libcruft-util
1
0
Fork 0
Code Issues Releases Activity

geom/aabb: rename AABB to aabb

Browse Source
This commit is contained in:
Danny Robson 2017-08-24 16:43:54 +10:00
parent 359702fb86
commit cd1bb730f2
11 changed files with 61 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
geom/aabb.cpp
View File

@ -21,11 +21,11 @@
#include "../coord/iostream.hpp"
#include "../debug.hpp"
using util::geom::AABB;
using util::geom::aabb;
//-----------------------------------------------------------------------------
template <size_t S, typename T>
AABB<S,T>::AABB (point<S,T> _p0, point<S,T> _p1):
aabb<S,T>::aabb (point<S,T> _p0, point<S,T> _p1):
p0 (_p0),
p1 (_p1)
{
@ -36,7 +36,7 @@ AABB<S,T>::AABB (point<S,T> _p0, point<S,T> _p1):
//-----------------------------------------------------------------------------
template <size_t S, typename T>
T
AABB<S,T>::diameter (void) const
aabb<S,T>::diameter (void) const
{
return magnitude ().diameter ();
}
@ -45,7 +45,7 @@ AABB<S,T>::diameter (void) const
//-----------------------------------------------------------------------------
template <size_t S, typename T>
util::extent<S,T>
AABB<S,T>::magnitude (void) const
aabb<S,T>::magnitude (void) const
{
extent<S,T> out;
for (size_t i = 0; i < S; ++i)
@ -57,7 +57,7 @@ AABB<S,T>::magnitude (void) const
//-----------------------------------------------------------------------------
template <size_t S, typename T>
bool
AABB<S,T>::overlaps (point<S,T> p) const
aabb<S,T>::overlaps (point<S,T> p) const
{
for (size_t i = 0; i < S; ++i)
if (p0[i] > p[i] || p1[i] < p[i])
@ -70,7 +70,7 @@ AABB<S,T>::overlaps (point<S,T> p) const
//-----------------------------------------------------------------------------
template <size_t S, typename T>
util::point<S,T>
AABB<S,T>::closest (point<S,T> q) const
aabb<S,T>::closest (point<S,T> q) const
{
point<S,T> res;
@ -85,8 +85,8 @@ AABB<S,T>::closest (point<S,T> q) const
///////////////////////////////////////////////////////////////////////////////
template <size_t S, typename T>
AABB<S,T>
AABB<S,T>::expanded (vector<S,T> mag) const noexcept
aabb<S,T>
aabb<S,T>::expanded (vector<S,T> mag) const noexcept
{
CHECK (all (mag >= T{0}));
CHECK (all (mag < p1 - p0));
@ -100,8 +100,8 @@ AABB<S,T>::expanded (vector<S,T> mag) const noexcept
//-----------------------------------------------------------------------------
template <size_t S, typename T>
AABB<S,T>
AABB<S,T>::expanded (T t) const noexcept
aabb<S,T>
aabb<S,T>::expanded (T t) const noexcept
{
CHECK_GE (t, T{0});
CHECK (all (t < p1 - p0));
@ -115,8 +115,8 @@ AABB<S,T>::expanded (T t) const noexcept
///////////////////////////////////////////////////////////////////////////////
template <size_t S, typename T>
AABB<S,T>
AABB<S,T>::contracted (util::vector<S,T> mag) const noexcept
aabb<S,T>
aabb<S,T>::contracted (util::vector<S,T> mag) const noexcept
{
CHECK (all (mag > T{0}));
CHECK (all (mag <= p1 - p0));
@ -130,8 +130,8 @@ AABB<S,T>::contracted (util::vector<S,T> mag) const noexcept
//-----------------------------------------------------------------------------
template <size_t S, typename T>
AABB<S,T>
AABB<S,T>::contracted (T mag) const noexcept
aabb<S,T>
aabb<S,T>::contracted (T mag) const noexcept
{
CHECK_GE (mag, T{0});
CHECK (all (mag <= p1 - p0));
@ -146,7 +146,7 @@ AABB<S,T>::contracted (T mag) const noexcept
///////////////////////////////////////////////////////////////////////////////
template <size_t S, typename T>
void
AABB<S,T>::cover (point<S,T> p)
aabb<S,T>::cover (point<S,T> p)
{
p0 = min (p, p0);
p1 = max (p, p1);
@ -155,8 +155,8 @@ AABB<S,T>::cover (point<S,T> p)
///////////////////////////////////////////////////////////////////////////////
template <size_t S, typename T>
AABB<S,T>
AABB<S,T>::operator+ (vector<S,T> v) const
aabb<S,T>
aabb<S,T>::operator+ (vector<S,T> v) const
{
return { p0 + v, p1 + v };
}
@ -164,8 +164,8 @@ AABB<S,T>::operator+ (vector<S,T> v) const
//-----------------------------------------------------------------------------
template <size_t S, typename T>
AABB<S,T>
AABB<S,T>::operator- (vector<S,T> v) const
aabb<S,T>
aabb<S,T>::operator- (vector<S,T> v) const
{
return { p0 - v, p1 - v };
}
@ -174,7 +174,7 @@ AABB<S,T>::operator- (vector<S,T> v) const
///////////////////////////////////////////////////////////////////////////////
template <size_t S, typename T>
bool
AABB<S,T>::operator== (const AABB<S,T> rhs) const
aabb<S,T>::operator== (const aabb<S,T> rhs) const
{
return rhs.p0 == p0 && rhs.p1 == p1;
}
@ -184,8 +184,8 @@ AABB<S,T>::operator== (const AABB<S,T> rhs) const
//-----------------------------------------------------------------------------
namespace util::debug {
template <size_t S, typename T>
struct validator<AABB<S,T>> {
static bool is_valid (const AABB<S,T> &b)
struct validator<aabb<S,T>> {
static bool is_valid (const aabb<S,T> &b)
{
for (size_t i = 0; i < S; ++i)
if (b.p1[i] < b.p0[i])
@ -200,18 +200,18 @@ namespace util::debug {
//-----------------------------------------------------------------------------
template <size_t S, typename T>
std::ostream&
util::geom::operator<< (std::ostream &os, util::geom::AABB<S,T> b)
util::geom::operator<< (std::ostream &os, util::geom::aabb<S,T> b)
{
os << "AABB(" << b.p0 << ", " << b.p1 << ")";
os << "aabb(" << b.p0 << ", " << b.p1 << ")";
return os;
}
//-----------------------------------------------------------------------------
#define INSTANTIATE_S_T(S,T) \
namespace util::geom { template struct AABB<S,T>; } \
template bool util::debug::is_valid (const AABB<S,T>&); \
template std::ostream& util::geom::operator<< (std::ostream&, AABB<S,T>);
namespace util::geom { template struct aabb<S,T>; } \
template bool util::debug::is_valid (const aabb<S,T>&); \
template std::ostream& util::geom::operator<< (std::ostream&, aabb<S,T>);
#define INSTANTIATE(T) \
INSTANTIATE_S_T(2,T) \

32
geom/aabb.hpp
View File

@ -25,9 +25,9 @@
namespace util::geom {
template <size_t S, typename T>
struct AABB {
AABB () = default;
AABB (point<S,T>, point<S,T>);
struct aabb {
aabb () = default;
aabb (point<S,T>, point<S,T>);
T diameter (void) const;
extent<S,T> magnitude (void) const;
@ -36,30 +36,30 @@ namespace util::geom {
point<S,T> closest (point<S,T>) const;
AABB<S,T> expanded (util::vector<S,T>) const noexcept;
AABB<S,T> expanded (T) const noexcept;
aabb<S,T> expanded (util::vector<S,T>) const noexcept;
aabb<S,T> expanded (T) const noexcept;
AABB<S,T> contracted (util::vector<S,T>) const noexcept;
AABB<S,T> contracted (T) const noexcept;
aabb<S,T> contracted (util::vector<S,T>) const noexcept;
aabb<S,T> contracted (T) const noexcept;
void cover (point<S,T>);
AABB<S,T> operator+ (vector<S,T>) const;
AABB<S,T> operator- (vector<S,T>) const;
aabb<S,T> operator+ (vector<S,T>) const;
aabb<S,T> operator- (vector<S,T>) const;
bool operator== (AABB) const;
bool operator== (aabb) const;
point<S,T> p0;
point<S,T> p1;
};
typedef AABB<2,float> AABB2f;
typedef AABB<2,unsigned> AABB2u;
typedef AABB<2,int> AABB2i;
typedef aabb<2,float> aabb2f;
typedef aabb<2,unsigned> aabb2u;
typedef aabb<2,int> aabb2i;
typedef AABB<3,float> AABB3f;
typedef AABB<3,unsigned> AABB3u;
typedef AABB<3,int> AABB3i;
typedef aabb<3,float> aabb3f;
typedef aabb<3,unsigned> aabb3u;
typedef aabb<3,int> aabb3i;
}
#include "aabb.ipp"

4
geom/aabb.ipp
View File

@ -28,9 +28,9 @@
///////////////////////////////////////////////////////////////////////////////
namespace util::geom {
template <size_t S, typename T, typename G>
struct sampler<S,T,AABB,G> {
struct sampler<S,T,aabb,G> {
static point<S,T>
fn (AABB<S,T> b, G &g)
fn (aabb<S,T> b, G &g)
{
std::uniform_real_distribution<T> d;

8
geom/ellipse.cpp
View File

@ -47,7 +47,7 @@ template bool util::geom::intersects (ellipse<3,float>, util::point<3,float>);
///////////////////////////////////////////////////////////////////////////////
template <size_t S, typename T>
static util::geom::AABB<S,T>
static util::geom::aabb<S,T>
bounds (ellipse<S,T> e)
{
return {
@ -59,7 +59,7 @@ bounds (ellipse<S,T> e)
//-----------------------------------------------------------------------------
template <size_t S, typename T, template <size_t,typename> class K>
util::geom::AABB<S,T>
util::geom::aabb<S,T>
util::geom::bounds (K<S,T> k)
{
return ::bounds (k);
@ -67,5 +67,5 @@ util::geom::bounds (K<S,T> k)
//-----------------------------------------------------------------------------
template util::geom::AABB<2,float> util::geom::bounds (ellipse<2,float>);
template util::geom::AABB<3,float> util::geom::bounds (ellipse<3,float>);
template util::geom::aabb<2,float> util::geom::bounds (ellipse<2,float>);
template util::geom::aabb<3,float> util::geom::bounds (ellipse<3,float>);

2
geom/fwd.hpp
View File

@ -22,7 +22,7 @@
namespace util::geom {
template <size_t S, typename T> struct ray;
template <size_t S, typename T> struct plane;
template <size_t S, typename T> struct AABB;
template <size_t S, typename T> struct aabb;
template <size_t S, typename T> struct sphere;
template <size_t S, typename T> struct ellipse;
template <size_t S, typename T> struct rect;

2
geom/iostream.hpp
View File

@ -26,7 +26,7 @@
namespace util::geom {
template <size_t S, typename T>
std::ostream&
operator<< (std::ostream&, AABB<S,T>);
operator<< (std::ostream&, aabb<S,T>);
template <size_t S, typename T>
std::ostream&

2
geom/ops.hpp
View File

@ -55,7 +55,7 @@ namespace util::geom {
typename T,
template <size_t,typename> class K
>
AABB<S,T>
aabb<S,T>
bounds (K<S,T>);
template <

2
geom/ray.cpp
View File

@ -44,7 +44,7 @@ ray<S,T>::intersect (plane<S,T> q) const
/// returns NaN if behind
template <size_t S, typename T>
T
ray<S,T>::intersect (AABB<S,T> r) const
ray<S,T>::intersect (aabb<S,T> r) const
{
auto t1 = (r.p0 - origin) / direction;
auto t2 = (r.p1 - origin) / direction;

2
geom/ray.hpp
View File

@ -47,7 +47,7 @@ namespace util::geom {
//---------------------------------------------------------------------
// intersection tests
T intersect (plane<S,T>) const;
T intersect (AABB<S,T>) const;
T intersect (aabb<S,T>) const;
T intersect (sphere<S,T>) const;
// queries

10
test/geom/aabb.cpp
View File

@ -4,7 +4,7 @@
#include <tuple>
using util::geom::AABB2f;
using util::geom::aabb2f;
int
@ -14,16 +14,16 @@ main (int, char**)
{
// Test contraction
const AABB2f val { { 2, 2 }, { 8, 8 } };
const AABB2f res { { 3, 3 }, { 7, 7 } };
const aabb2f val { { 2, 2 }, { 8, 8 } };
const aabb2f res { { 3, 3 }, { 7, 7 } };
tap.expect_eq (val.contracted (2.f), res, "over contraction");
}
{
// Test expansion
const AABB2f val { { 2, 2 }, { 8, 8 } };
const AABB2f res { { 1, 1 }, { 9, 9 } };
const aabb2f val { { 2, 2 }, { 8, 8 } };
const aabb2f res { { 1, 1 }, { 9, 9 } };
tap.expect_eq (val.expanded (2.f), res, "expansion");
}

4
test/geom/ray.cpp
View File

@ -23,10 +23,10 @@ test_intersect_plane (util::TAP::logger &tap)
void
test_intersect_aabb (util::TAP::logger &tap)
{
using util::geom::AABB2f;
using util::geom::aabb2f;
// trivial case: unit aabb at origin, ray from (0.5,-0.5) upwards
const AABB2f box {
const aabb2f box {
{ 0.f, 0.f },
{ 1.f, 1.f }
};