Subversion Repository Public Repository

Divide-Framework

This repository has no backups
This repository's network speed is throttled to 100KB/sec

Diff Revisions 640 vs 646 for /trunk/Source Code/Core/Math/BoundingVolumes/Headers/BoundingBox.inl

Diff revisions: vs.
  @@ -36,8 +36,8 @@
36 36
37 37 inline bool BoundingBox::containsPoint(const vec3<F32>& point) const {
38 38 // const ReadLock r_lock(_lock);
39 - return (point.x >= _min.x && point.y >= _min.y && point.z >= _min.z &&
40 - point.x <= _max.x && point.y <= _max.y && point.z <= _max.z);
39 + return (IS_GEQUAL(point.x, _min.x) && IS_GEQUAL(point.y, _min.y) && IS_GEQUAL(point.z, _min.z) &&
40 + IS_LEQUAL(point.x, _max.x) && IS_LEQUAL(point.y, _max.y) && IS_LEQUAL(point.z, _max.z));
41 41 }
42 42
43 43 inline bool BoundingBox::compare(const BoundingBox& bb) const {
  @@ -61,13 +61,24 @@
61 61
62 62 inline void BoundingBox::add(const vec3<F32>& v) {
63 63 // WriteLock w_lock(_lock);
64 - if (v.x > _max.x) _max.x = v.x;
65 - if (v.x < _min.x) _min.x = v.x;
66 - if (v.y > _max.y) _max.y = v.y;
67 - if (v.y < _min.y) _min.y = v.y;
68 - if (v.z > _max.z) _max.z = v.z;
69 - if (v.z < _min.z) _min.z = v.z;
70 - _pointsDirty = true;
64 + if (v.x > _max.x) {
65 + _max.x = v.x;
66 + }
67 + if (v.x < _min.x) {
68 + _min.x = v.x;
69 + }
70 + if (v.y > _max.y) {
71 + _max.y = v.y;
72 + }
73 + if (v.y < _min.y) {
74 + _min.y = v.y;
75 + }
76 + if (v.z > _max.z) {
77 + _max.z = v.z;
78 + }
79 + if (v.z < _min.z) {
80 + _min.z = v.z;
81 + }
71 82 };
72 83
73 84 inline void BoundingBox::add(const BoundingBox& bb) {
  @@ -79,22 +90,18 @@
79 90 _min.set(std::min(bb._min.x, _min.x),
80 91 std::min(bb._min.y, _min.y),
81 92 std::min(bb._min.z, _min.z));
82 -
83 - _pointsDirty = true;
84 93 }
85 94
86 95 inline void BoundingBox::translate(const vec3<F32>& v) {
87 96 // WriteLock w_lock(_lock);
88 97 _min += v;
89 98 _max += v;
90 - _pointsDirty = true;
91 99 }
92 100
93 101 inline void BoundingBox::multiply(F32 factor) {
94 102 // WriteLock w_lock(_lock);
95 103 _min *= factor;
96 104 _max *= factor;
97 - _pointsDirty = true;
98 105 }
99 106
100 107 inline void BoundingBox::multiply(const vec3<F32>& v) {
  @@ -105,7 +112,6 @@
105 112 _max.x *= v.x;
106 113 _max.y *= v.y;
107 114 _max.z *= v.z;
108 - _pointsDirty = true;
109 115 }
110 116
111 117 inline void BoundingBox::multiplyMax(const vec3<F32>& v) {
  @@ -113,7 +119,6 @@
113 119 _max.x *= v.x;
114 120 _max.y *= v.y;
115 121 _max.z *= v.z;
116 - _pointsDirty = true;
117 122 }
118 123
119 124 inline void BoundingBox::multiplyMin(const vec3<F32>& v) {
  @@ -121,7 +126,6 @@
121 126 _min.x *= v.x;
122 127 _min.y *= v.y;
123 128 _min.z *= v.z;
124 - _pointsDirty = true;
125 129 }
126 130
127 131 inline const vec3<F32>& BoundingBox::getMin() const {
  @@ -179,73 +183,69 @@
179 183 inline void BoundingBox::set(F32 min, F32 max) {
180 184 _min.set(min);
181 185 _max.set(max);
182 - _pointsDirty = true;
183 186 }
184 187
185 188 inline void BoundingBox::set(F32 minX, F32 minY, F32 minZ, F32 maxX, F32 maxY, F32 maxZ) {
186 189 _min.set(minX, minY, minZ);
187 190 _max.set(maxX, maxY, maxZ);
188 - _pointsDirty = true;
189 191 }
190 192
191 193 inline void BoundingBox::setMin(F32 min) {
192 194 _min.set(min);
193 - _pointsDirty = true;
194 195 }
195 196
196 197 inline void BoundingBox::setMin(F32 minX, F32 minY, F32 minZ) {
197 198 _min.set(minX, minY, minZ);
198 - _pointsDirty = true;
199 199 }
200 200
201 201 inline void BoundingBox::setMax(F32 max) {
202 202 _max.set(max);
203 - _pointsDirty = true;
204 203 }
205 204
206 205 inline void BoundingBox::setMax(F32 maxX, F32 maxY, F32 maxZ) {
207 206 _max.set(maxX, maxY, maxZ);
208 - _pointsDirty = true;
209 207 }
210 208
211 209 inline void BoundingBox::set(const vec3<F32>& min, const vec3<F32>& max) {
212 210 /*WriteLock w_lock(_lock);*/
213 211 _min = min;
214 212 _max = max;
215 - _pointsDirty = true;
216 213 }
217 214
218 215 inline void BoundingBox::reset() {
219 216 /*WriteLock w_lock(_lock);*/
220 217 _min.set( std::numeric_limits<F32>::max());
221 218 _max.set(-std::numeric_limits<F32>::max());
222 - _pointsDirty = true;
223 219 }
224 220
225 - inline const vec3<F32>* BoundingBox::getPoints() const {
226 - ComputePoints();
227 - return _points;
221 + inline std::array<vec3<F32>, 8> BoundingBox::getPoints() const {
222 + return std::array<vec3<F32>, 8>
223 + {
224 + (_min.x, _min.y, _min.z),
225 + (_min.x, _min.y, _max.z),
226 + (_min.x, _max.y, _min.z),
227 + (_min.x, _max.y, _max.z),
228 + (_max.x, _min.y, _min.z),
229 + (_max.x, _min.y, _max.z),
230 + (_max.x, _max.y, _min.z),
231 + (_max.x, _max.y, _max.z)
232 + };
228 233 }
229 234
230 235 inline F32 BoundingBox::nearestDistanceFromPoint(const vec3<F32>& pos) const {
231 236 return std::sqrt(nearestDistanceFromPointSquared(pos));
232 237 }
233 238
234 - inline void BoundingBox::ComputePoints() const {
235 - if (!_pointsDirty) {
236 - return;
237 - }
239 + inline vec3<F32> BoundingBox::getPVertex(const vec3<F32>& normal) const {
240 + return vec3<F32>(IS_GEQUAL(normal.x, 0.0f) ? _max.x : _min.x,
241 + IS_GEQUAL(normal.y, 0.0f) ? _max.y : _min.y,
242 + IS_GEQUAL(normal.z, 0.0f) ? _max.z : _min.z);
243 + }
238 244
239 - /*WriteLock w_lock(_lock);*/
240 - _points[0].set(_min.x, _min.y, _min.z);
241 - _points[1].set(_min.x, _min.y, _max.z);
242 - _points[2].set(_min.x, _max.y, _min.z);
243 - _points[3].set(_min.x, _max.y, _max.z);
244 - _points[4].set(_max.x, _min.y, _min.z);
245 - _points[5].set(_max.x, _min.y, _max.z);
246 - _points[6].set(_max.x, _max.y, _min.z);
247 - _points[7].set(_max.x, _max.y, _max.z);
248 - _pointsDirty = false;
245 + inline vec3<F32> BoundingBox::getNVertex(const vec3<F32>& normal) const {
246 + return vec3<F32>(IS_GEQUAL(normal.x, 0.0f) ? _min.x : _max.x,
247 + IS_GEQUAL(normal.y, 0.0f) ? _min.y : _max.y,
248 + IS_GEQUAL(normal.z, 0.0f) ? _min.z : _max.z);
249 249 }
250 250
251 251 }; // namespace Divide