rexy712/our_dick
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Change around collision related classes to allow for collision detection between classes without vtables given we know the dynamic type

Browse Source
This commit is contained in:
rexy712 2020-12-03 12:57:42 -08:00
parent aea6fb5320
commit 34f4b22ad8
7 changed files with 147 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

87
include/engine/base_types.hpp
View File

@ -20,86 +20,55 @@
#define OUR_DICK_ENGINE_BASE_TYPES_HPP
#include "math/vec.hpp"
#include "collision.hpp"
namespace egn{
class basic_point : public math::vec3<float>
class point : public math::vec3<float>
{
public:
using math::vec3<float>::vec3;
using math::vec3<float>::operator=;
};
class point : public basic_point, public collidable<point>
class line
{
public:
using basic_point::basic_point;
using basic_point::operator=;
point point1;
point point2;
};
class basic_line
class plane
{
public:
math::vec3<float> point1;
math::vec3<float> point2;
point point1;
point point2;
point point3;
};
class line : public basic_line, public collidable<line>{};
class basic_plane
class aabb
{
public:
math::vec3<float> point1;
math::vec3<float> point2;
math::vec3<float> point3;
point point1 = {};
point point2 = {};
public:
aabb() = default;
aabb(const math::vec3<float>& p1, const math::vec3<float>& p2);
aabb(const aabb&) = default;
aabb(aabb&&) = default;
~aabb() = default;
aabb& operator=(const aabb&) = default;
aabb& operator=(aabb&&) = default;
};
class plane : public basic_plane, public collidable<plane>{};
class basic_aabb
class sphere
{
public:
math::vec3<float> point1 = {};
math::vec3<float> point2 = {};
public:
basic_aabb() = default;
basic_aabb(const math::vec3<float>& p1, const math::vec3<float>& p2);
basic_aabb(const basic_aabb&) = default;
basic_aabb(basic_aabb&&) = default;
~basic_aabb() = default;
basic_aabb& operator=(const basic_aabb&) = default;
basic_aabb& operator=(basic_aabb&&) = default;
};
class aabb : public basic_aabb, public collidable<aabb>
{
public:
using basic_aabb::basic_aabb;
using basic_aabb::operator=;
aabb(const basic_aabb& b);
aabb& operator=(const basic_aabb& b);
};
class basic_sphere
{
public:
math::vec3<float> point = {};
point point1 = {};
float radius = 0.0f;
public:
basic_sphere() = default;
basic_sphere(float r);
basic_sphere(const basic_sphere&) = default;
basic_sphere(basic_sphere&&) = default;
~basic_sphere() = default;
basic_sphere& operator=(const basic_sphere&) = default;
basic_sphere& operator=(basic_sphere&&) = default;
sphere() = default;
sphere(float r);
sphere(const sphere&) = default;
sphere(sphere&&) = default;
~sphere() = default;
sphere& operator=(const sphere&) = default;
sphere& operator=(sphere&&) = default;
};
class aabs : public basic_sphere, public collidable<aabs>
{
public:
using basic_sphere::basic_sphere;
using basic_sphere::operator=;
aabs(const basic_sphere& b);
aabs& operator=(const basic_sphere& b);
};
}

85
include/engine/collision.hpp
View File

@ -19,6 +19,8 @@
#ifndef OUR_DICK_ENGINE_COLLISION_HPP
#define OUR_DICK_ENGINE_COLLISION_HPP
#include "base_types.hpp"
namespace egn{
static constexpr float default_collision_epsilon = 1.0e-10f;
@ -42,20 +44,43 @@ namespace egn{
};
class point;
class aabb;
class aabs;
class line;
class plane;
namespace collision{
class point : public egn::point, public collidable<point>
{
public:
using egn::point::point;
using egn::point::operator=;
};
class line : public egn::line, public collidable<line>{};
class plane : public egn::plane, public collidable<plane>{};
class aabb : public egn::aabb, public collidable<aabb>
{
public:
using egn::aabb::aabb;
using egn::aabb::operator=;
aabb(const egn::aabb& b);
aabb& operator=(const egn::aabb& b);
};
class sphere : public egn::sphere, public collidable<sphere>
{
public:
using egn::sphere::sphere;
using egn::sphere::operator=;
sphere(const egn::sphere& b);
sphere& operator=(const egn::sphere& b);
};
}
class collidable_visitor
{
public:
virtual void visit(const aabb& a) = 0;
virtual void visit(const aabs& a) = 0;
virtual void visit(const line& a) = 0;
virtual void visit(const plane& a) = 0;
virtual void visit(const point& p) = 0;
virtual void visit(const collision::aabb& a) = 0;
virtual void visit(const collision::sphere& a) = 0;
virtual void visit(const collision::line& a) = 0;
virtual void visit(const collision::plane& a) = 0;
virtual void visit(const collision::point& p) = 0;
};
template<typename T>
@ -67,38 +92,38 @@ namespace egn{
bool m_result = false;
public:
constexpr explicit collision_visitor(const T& l, float epsilon);
void visit(const aabb& a)override;
void visit(const aabs& a)override;
void visit(const line& a)override;
void visit(const plane& a)override;
void visit(const point& p)override;
void visit(const collision::aabb& a)override;
void visit(const collision::sphere& a)override;
void visit(const collision::line& a)override;
void visit(const collision::plane& a)override;
void visit(const collision::point& p)override;
constexpr bool result()const;
};
bool check_collision(const collidable_iface& l, const collidable_iface& r, float epsilon = default_collision_epsilon);
//bool check_collision(const collidable_iface& l, const collidable_iface& r, float epsilon = default_collision_epsilon);
bool check_collision(const aabb& l, const aabb& r, float epsilon = default_collision_epsilon);
bool check_collision(const aabb& l, const aabs& r, float epsilon = default_collision_epsilon);
bool check_collision(const aabb& l, const sphere& r, float epsilon = default_collision_epsilon);
bool check_collision(const aabb& l, const line& r, float epsilon = default_collision_epsilon);
bool check_collision(const aabb& l, const plane& r, float epsilon = default_collision_epsilon);
bool check_collision(const aabb& l, const point& r, float epsilon = default_collision_epsilon);
bool check_collision(const aabs& l, const aabs& r, float epsilon = default_collision_epsilon);
bool check_collision(const aabs& l, const aabb& r, float epsilon = default_collision_epsilon);
bool check_collision(const aabs& l, const line& r, float epsilon = default_collision_epsilon);
bool check_collision(const aabs& l, const plane& r, float epsilon = default_collision_epsilon);
bool check_collision(const aabs& l, const point& r, float epsilon = default_collision_epsilon);
bool check_collision(const sphere& l, const sphere& r, float epsilon = default_collision_epsilon);
bool check_collision(const sphere& l, const aabb& r, float epsilon = default_collision_epsilon);
bool check_collision(const sphere& l, const line& r, float epsilon = default_collision_epsilon);
bool check_collision(const sphere& l, const plane& r, float epsilon = default_collision_epsilon);
bool check_collision(const sphere& l, const point& r, float epsilon = default_collision_epsilon);
bool check_collision(const line& l, const line& r, float epsilon = default_collision_epsilon);
bool check_collision(const line& l, const aabb& r, float epsilon = default_collision_epsilon);
bool check_collision(const line& l, const aabs& r, float epsilon = default_collision_epsilon);
bool check_collision(const line& l, const sphere& r, float epsilon = default_collision_epsilon);
bool check_collision(const line& l, const plane& r, float epsilon = default_collision_epsilon);
bool check_collision(const line& l, const point& r, float epsilon = default_collision_epsilon);
bool check_collision(const plane& l, const plane& r, float epsilon = default_collision_epsilon);
bool check_collision(const plane& l, const aabb& r, float epsilon = default_collision_epsilon);
bool check_collision(const plane& l, const aabs& r, float epsilon = default_collision_epsilon);
bool check_collision(const plane& l, const sphere& r, float epsilon = default_collision_epsilon);
bool check_collision(const plane& l, const line& r, float epsilon = default_collision_epsilon);
bool check_collision(const plane& l, const point& r, float epsilon = default_collision_epsilon);
bool check_collision(const point& l, const point& r, float epsilon = default_collision_epsilon);
bool check_collision(const point& l, const aabb& r, float epsilon = default_collision_epsilon);
bool check_collision(const point& l, const aabs& r, float epsilon = default_collision_epsilon);
bool check_collision(const point& l, const sphere& r, float epsilon = default_collision_epsilon);
bool check_collision(const point& l, const line& r, float epsilon = default_collision_epsilon);
bool check_collision(const point& l, const plane& r, float epsilon = default_collision_epsilon);
@ -119,23 +144,23 @@ namespace egn{
m_l(l),
m_epsilon(epsilon){}
template<typename T>
void collision_visitor<T>::visit(const aabb& a){
void collision_visitor<T>::visit(const collision::aabb& a){
m_result = check_collision(m_l, a, m_epsilon);
}
template<typename T>
void collision_visitor<T>::visit(const aabs& a){
void collision_visitor<T>::visit(const collision::sphere& a){
m_result = check_collision(m_l, a, m_epsilon);
}
template<typename T>
void collision_visitor<T>::visit(const line& a){
void collision_visitor<T>::visit(const collision::line& a){
m_result = check_collision(m_l, a, m_epsilon);
}
template<typename T>
void collision_visitor<T>::visit(const plane& a){
void collision_visitor<T>::visit(const collision::plane& a){
m_result = check_collision(m_l, a, m_epsilon);
}
template<typename T>
void collision_visitor<T>::visit(const point& a){
void collision_visitor<T>::visit(const collision::point& a){
m_result = check_collision(m_l, a, m_epsilon);
}
template<typename T>

21
include/math/math_common.hpp
View File

@ -48,6 +48,27 @@ namespace math{
return (t * pi<T>()) / 180.0;
}
template<typename T>
static constexpr T clamp(const T& t, const T& min, const T& max){
if(t < min)
return min;
if(t > max)
return max;
return t;
}
template<typename T>
static constexpr T clamp_min(const T& t, const T& min){
if(t < min)
return min;
return t;
}
template<typename T>
static constexpr T clamp_max(const T& t, const T& max){
if(t > max)
return max;
return t;
}
}
constexpr long double operator"" _rad(long double f){
return f;

4
include/math/vec.hpp
View File

@ -78,6 +78,10 @@ namespace math{
constexpr void assign_(size_type offset, U&& u, Args&&... args);
};
template<typename T>
constexpr auto perp(const vector<T,2>& v);
template<typename T, typename U, size_t R1, size_t R2>
constexpr auto perp(const vector<T,R1>& left, const vector<U,R2>& right);
template<typename T, typename U>
constexpr auto cross(const vector<T,3>& left, const vector<U,3>& right);

8
include/math/vec.tpp
View File

@ -115,6 +115,14 @@ namespace math{
return (*this) / magnitude();
}
template<typename T>
constexpr auto perp(const vector<T,2>& v){
return vec2<T>(-v[1], v[0]);
}
template<typename T, typename U, size_t R1, size_t R2>
constexpr auto perp(const vector<T,R1>& left, const vector<U,R2>& right){
return (left[0] * right[1]) - (left[1] * right[0]);
}
template<typename T, typename U>
constexpr auto cross(const vector<T,3>& left, const vector<U,3>& right){
using res_t = decltype(left[0] * right[0]);

24
src/engine/base_types.cpp
View File

@ -20,26 +20,10 @@
namespace egn{
basic_aabb::basic_aabb(const math::vec3<float>& p1, const math::vec3<float>& p2):
point1(p1),
point2(p2){}
aabb::aabb(const basic_aabb& b):
basic_aabb(b){}
aabb& aabb::operator=(const basic_aabb& b){
basic_aabb::operator=(b);
return *this;
}
basic_sphere::basic_sphere(float r):
aabb::aabb(const math::vec3<float>& p1, const math::vec3<float>& p2):
point1({p1.x(), p1.y(), p1.z()}),
point2({p2.x(), p2.y(), p2.z()}){}
sphere::sphere(float r):
radius(r){}
aabs::aabs(const basic_sphere& b):
basic_sphere(b){}
aabs& aabs::operator=(const basic_sphere& b){
basic_sphere::operator=(b);
return *this;
}
}

38
src/engine/collision.cpp
View File

@ -21,16 +21,32 @@
namespace egn{
bool check_collision(const collidable_iface& l, const collidable_iface& r, float epsilon){
return l.check_collision(r, epsilon);
namespace collision{
aabb::aabb(const egn::aabb& b):
egn::aabb(b){}
aabb& aabb::operator=(const egn::aabb& b){
egn::aabb::operator=(b);
return *this;
}
sphere::sphere(const egn::sphere& b):
egn::sphere(b){}
sphere& sphere::operator=(const egn::sphere& b){
egn::sphere::operator=(b);
return *this;
}
}
/* bool check_collision(const collidable_iface& l, const collidable_iface& r, float epsilon){
return l.check_collision(r, epsilon);
}*/
bool check_collision(const aabb& l, const aabb& r, float epsilon){
(void)l;
(void)r;
(void)epsilon;
return false;
}
bool check_collision(const aabb& l, const aabs& r, float epsilon){
bool check_collision(const aabb& l, const sphere& r, float epsilon){
(void)l;
(void)r;
(void)epsilon;
@ -54,28 +70,28 @@ namespace egn{
(void)epsilon;
return false;
}
bool check_collision(const aabs& l, const aabs& r, float epsilon){
bool check_collision(const sphere& l, const sphere& r, float epsilon){
(void)l;
(void)r;
(void)epsilon;
return false;
}
bool check_collision(const aabs& l, const aabb& r, float epsilon){
bool check_collision(const sphere& l, const aabb& r, float epsilon){
return check_collision(r, l, epsilon);
}
bool check_collision(const aabs& l, const line& r, float epsilon){
bool check_collision(const sphere& l, const line& r, float epsilon){
(void)l;
(void)r;
(void)epsilon;
return false;
}
bool check_collision(const aabs& l, const plane& r, float epsilon){
bool check_collision(const sphere& l, const plane& r, float epsilon){
(void)l;
(void)r;
(void)epsilon;
return false;
}
bool check_collision(const aabs& l, const point& r, float epsilon){
bool check_collision(const sphere& l, const point& r, float epsilon){
(void)l;
(void)r;
(void)epsilon;
@ -87,7 +103,7 @@ namespace egn{
(void)epsilon;
return false;
}
bool check_collision(const line& l, const aabs& r, float epsilon){
bool check_collision(const line& l, const sphere& r, float epsilon){
return check_collision(r, l, epsilon);
}
bool check_collision(const line& l, const aabb& r, float epsilon){
@ -125,7 +141,7 @@ namespace egn{
bool check_collision(const plane& l, const aabb& r, float epsilon){
return check_collision(r, l, epsilon);
}
bool check_collision(const plane& l, const aabs& r, float epsilon){
bool check_collision(const plane& l, const sphere& r, float epsilon){
return check_collision(r, l, epsilon);
}
bool check_collision(const plane& l, const line& r, float epsilon){
@ -143,7 +159,7 @@ namespace egn{
bool check_collision(const point& l, const aabb& r, float epsilon){
return check_collision(r, l, epsilon);
}
bool check_collision(const point& l, const aabs& r, float epsilon){
bool check_collision(const point& l, const sphere& r, float epsilon){
return check_collision(r, l, epsilon);
}
bool check_collision(const point& l, const line& r, float epsilon){