Norbert's Game Engine v200
Loading...
Searching...
No Matches
eCollision Class Reference

#include <Collision.hpp>

Inheritance diagram for eCollision:
eBase

Static Public Member Functions

static const bool PointInAABB (const eCollider::eAABB &box, const vec3 &point)
 
static const bool AABBInAABB (const eCollider::eAABB &box, const eCollider::eAABB &box2)
 
static const bool PointInAABB2D (const eCollider::eAABB2D &box, const vec2 &point)
 
static const bool AABB2DInAABB2D (const eCollider::eAABB2D &rect, const eCollider::eAABB2D &rect2)
 
static const bool AABB2DInCircle (const eCollider::eAABB2D &rect, const eCollider::eCircle &circle)
 
static const bool CircleInCircle (const eCollider::eCircle &circle, const eCollider::eCircle &circle2)
 
static const bool PointInSphere (const eCollider::eSphere &sphere, const vec3 &point)
 
static const bool SphereInSphere (const eCollider::eSphere &sphere, const eCollider::eSphere &sphere2)
 
static const bool SphereInAABB (const eCollider::eSphere &sphere, const eCollider::eAABB &box)
 
static const bool OBBInOBB (const eCollider::eOBB &obb, const eCollider::eOBB &obb2)
 
static eCollider::eOBB AABBToOBB (const eCollider::eAABB &box)
 
static const bool AABBInOBB (const eCollider::eAABB &box, const eCollider::eOBB &obb)
 
static eCollisionSide GetCollisionSide (const eCollider::eAABB &box, const eCollider::eAABB &box2)
 
static eCollisionSide GetCollisionSide2D (const eCollider::eAABB2D &box, const eCollider::eAABB2D &box2)
 

Additional Inherited Members

- Public Member Functions inherited from eBase
template<typename T >
T * Cast (eBase *obj)
 Cast class to base.
 

Detailed Description

Class for handling collision

Definition at line 25 of file Collision.hpp.

Member Function Documentation

◆ AABB2DInAABB2D()

const bool eCollision::AABB2DInAABB2D ( const eCollider::eAABB2D & rect,
const eCollider::eAABB2D & rect2 )
static

Definition at line 32 of file Collision.cpp.

33{
34 const bool collisionX = rect.mPos.x + rect.mSize.x >= rect2.mPos.x &&
35 rect2.mPos.x + rect2.mSize.x >= rect.mPos.x;
36
37 const bool collisionY = rect.mPos.y + rect.mSize.y >= rect2.mPos.y &&
38 rect2.mPos.y + rect2.mSize.y >= rect.mPos.y;
39
40 return collisionX && collisionY;
41}

◆ AABB2DInCircle()

const bool eCollision::AABB2DInCircle ( const eCollider::eAABB2D & rect,
const eCollider::eCircle & circle )
static

Definition at line 43 of file Collision.cpp.

44{
45 const bool collisionX = rect.mPos.x + rect.mSize.x >= circle.mPos.x &&
46 circle.mPos.x + circle.mRadius >= rect.mPos.x;
47
48 const bool collisionY = rect.mPos.y + rect.mSize.y >= circle.mPos.y &&
49 circle.mPos.y + circle.mRadius >= rect.mPos.y;
50
51 return collisionX && collisionY;
52}

◆ AABBInAABB()

const bool eCollision::AABBInAABB ( const eCollider::eAABB & box,
const eCollider::eAABB & box2 )
static

Definition at line 16 of file Collision.cpp.

17{
18 if (box.mMax.x > box2.mMin.x && box.mMin.x < box2.mMax.x && box.mMax.y > box2.mMin.y && box.mMin.y < box2.mMax.y &&
19 box.mMax.z > box2.mMin.z && box.mMin.z < box2.mMax.z)
20 return true;
21 return false;
22}

◆ AABBInOBB()

const bool eCollision::AABBInOBB ( const eCollider::eAABB & box,
const eCollider::eOBB & obb )
static

Definition at line 179 of file Collision.cpp.

180{
181 eCollider::eOBB obb2 = AABBToOBB(box);
182 return OBBInOBB(obb, obb2);
183}

◆ AABBToOBB()

eCollider::eOBB eCollision::AABBToOBB ( const eCollider::eAABB & box)
static

Definition at line 168 of file Collision.cpp.

169{
170 eCollider::eOBB obb;
171 obb.mCenter = (box.mMin + box.mMax) * 0.5f;
172 obb.mExtents = (box.mMax - box.mMin) * 0.5f;
173 obb.mAxes[0] = vec3(1.0f, 0.0f, 0.0f);
174 obb.mAxes[1] = vec3(0.0f, 1.0f, 0.0f);
175 obb.mAxes[2] = vec3(0.0f, 0.0f, 1.0f);
176 return obb;
177}

◆ CircleInCircle()

const bool eCollision::CircleInCircle ( const eCollider::eCircle & circle,
const eCollider::eCircle & circle2 )
static

Definition at line 54 of file Collision.cpp.

55{
56 const real3 distance = eMath::sqrt(
57 (circle.mPos.x - circle2.mPos.x) * (circle.mPos.x - circle2.mPos.x) +
58 (circle.mPos.y - circle2.mPos.y) * (circle.mPos.y - circle2.mPos.y)
59 );
60
61 return distance < circle.mRadius + circle2.mRadius;
62}

◆ GetCollisionSide()

eCollisionSide eCollision::GetCollisionSide ( const eCollider::eAABB & box,
const eCollider::eAABB & box2 )
static

Definition at line 100 of file Collision.cpp.

101{
102 real3 xOv = eTools::mini(box.mMax.x, box2.mMax.x) - eTools::maxi(box.mMin.x, box2.mMin.x);
103 real3 yOv = eTools::mini(box.mMax.y, box2.mMax.y) - eTools::maxi(box.mMin.y, box2.mMin.y);
104 real3 zOv = eTools::mini(box.mMax.z, box2.mMax.z) - eTools::maxi(box.mMin.z, box2.mMin.z);
105 real3 minOv = eTools::mini(eTools::mini(xOv, yOv), zOv);
106
107 const real3 epsilon = 0.0001f;
108
109 if (fabs(minOv - xOv) < epsilon)
110 return (box.mMin.x < box2.mMin.x) ? eCollisionSide::CsRight : eCollisionSide::CsLeft;
111 else if (fabs(minOv - yOv) < epsilon)
112 return (box.mMin.y < box2.mMin.y) ? eCollisionSide::CsTop : eCollisionSide::CsBottom;
113 else
114 return (box.mMin.z < box2.mMin.z) ? eCollisionSide::CsFront : eCollisionSide::CsBack;
115}

◆ GetCollisionSide2D()

eCollisionSide eCollision::GetCollisionSide2D ( const eCollider::eAABB2D & box,
const eCollider::eAABB2D & box2 )
static

Definition at line 117 of file Collision.cpp.

118{
119 real3 xOv = eTools::mini(box.mPos.x + box.mSize.x, box2.mPos.x + box2.mSize.x) - eTools::maxi(box.mPos.x, box2.mPos.x);
120 real3 yOv = eTools::mini(box.mPos.y + box.mSize.y, box2.mPos.y + box2.mSize.y) - eTools::maxi(box.mPos.y, box2.mPos.y);
121 real3 minOv = eTools::mini(xOv, yOv);
122
123 const real3 epsilon = 0.0001f;
124
125 if (fabs(minOv - xOv) < epsilon)
126 return (box.mPos.x < box2.mPos.x) ? eCollisionSide::CsRight : eCollisionSide::CsLeft;
127 else if (fabs(minOv - yOv) < epsilon)
128 return (box.mPos.y < box2.mPos.y) ? eCollisionSide::CsTop : eCollisionSide::CsBottom;
129
130 return eCollisionSide::CsNone;
131}

◆ OBBInOBB()

const bool eCollision::OBBInOBB ( const eCollider::eOBB & obb,
const eCollider::eOBB & obb2 )
static

Definition at line 133 of file Collision.cpp.

134{
135 mat3 axes1 = mat3(obb.mAxes[0], obb.mAxes[1], obb.mAxes[2]);
136 mat3 axes2 = mat3(obb2.mAxes[0], obb2.mAxes[1], obb2.mAxes[2]);
137 mat3 axes = eMath::transpose(axes1) * axes2;
138
139 vec3 translation = obb2.mCenter - obb.mCenter;
140
141 for (int i = 0; i < 3; i++)
142 {
143 real3 t = eMath::dot(translation, axes[i]);
144
145 real3 obb1Proj = eMath::dot(glm::abs(obb.mAxes[i]), obb.mExtents);
146 real3 obb2Proj = eMath::dot(glm::abs(obb2.mAxes[i]), obb2.mExtents);
147
148 if (eMath::abs(t) > obb1Proj + obb2Proj)
149 return false;
150 }
151
152 axes = eMath::transpose(axes2) * axes1;
153
154 for (int i = 0; i < 3; i++)
155 {
156 real3 t = eMath::dot(translation, axes[i]);
157
158 real3 obb1Proj = eMath::dot(glm::abs(obb.mAxes[i]), obb.mExtents);
159 real3 obb2Proj = eMath::dot(glm::abs(obb2.mAxes[i]), obb2.mExtents);
160
161 if (eMath::abs(t) > obb1Proj + obb2Proj)
162 return false;
163 }
164
165 return true;
166}

◆ PointInAABB()

const bool eCollision::PointInAABB ( const eCollider::eAABB & box,
const vec3 & point )
static

Definition at line 7 of file Collision.cpp.

8{
9 if (point.x > box.mMin.x && point.x < box.mMax.x &&
10 point.y > box.mMin.y && point.y < box.mMax.y &&
11 point.z > box.mMin.z && point.z < box.mMax.z)
12 return true;
13 return false;
14}

◆ PointInAABB2D()

const bool eCollision::PointInAABB2D ( const eCollider::eAABB2D & box,
const vec2 & point )
static

Definition at line 24 of file Collision.cpp.

25{
26 if (point.x > box.mPos.x && point.x < (box.mPos.x + box.mSize.x) &&
27 point.y > box.mPos.y && point.y < (box.mPos.y + box.mSize.y))
28 return true;
29 return false;
30}

◆ PointInSphere()

const bool eCollision::PointInSphere ( const eCollider::eSphere & sphere,
const vec3 & point )
static

Definition at line 64 of file Collision.cpp.

65{
66 const real3 distance = eMath::sqrt(
67 (point.x - sphere.mPos.x) * (point.x - sphere.mPos.x) +
68 (point.y - sphere.mPos.y) * (point.y - sphere.mPos.y) +
69 (point.z - sphere.mPos.z) * (point.z - sphere.mPos.z));
70
71 return distance < sphere.mRadius;
72}

◆ SphereInAABB()

const bool eCollision::SphereInAABB ( const eCollider::eSphere & sphere,
const eCollider::eAABB & box )
static

Definition at line 85 of file Collision.cpp.

86{
87 const real3 x = eTools::maxi(box.mMin.x, eTools::mini(sphere.mPos.x, box.mMax.x));
88 const real3 y = eTools::maxi(box.mMin.y, eTools::mini(sphere.mPos.y, box.mMax.y));
89 const real3 z = eTools::maxi(box.mMin.z, eTools::mini(sphere.mPos.z, box.mMax.z));
90
91 const real3 distance = eMath::sqrt(
92 (x - sphere.mPos.x) * (x - sphere.mPos.x) +
93 (y - sphere.mPos.y) * (y - sphere.mPos.y) +
94 (z - sphere.mPos.z) * (z - sphere.mPos.z)
95 );
96
97 return distance < sphere.mRadius;
98}

◆ SphereInSphere()

const bool eCollision::SphereInSphere ( const eCollider::eSphere & sphere,
const eCollider::eSphere & sphere2 )
static

Definition at line 74 of file Collision.cpp.

75{
76 const real3 distance = eMath::sqrt(
77 (sphere.mPos.x - sphere2.mPos.x) * (sphere.mPos.x - sphere2.mPos.x) +
78 (sphere.mPos.y - sphere2.mPos.y) * (sphere.mPos.y - sphere2.mPos.y) +
79 (sphere.mPos.z - sphere2.mPos.z) * (sphere.mPos.z - sphere2.mPos.z)
80 );
81
82 return distance < sphere.mRadius + sphere2.mRadius;
83}

The documentation for this class was generated from the following files: