Skip to content

Commit 3ad5388

Browse files
TheTermosTheTermos
authoredApr 8, 2020
Collision various fixes (#9343)
·
5.11.05.3.0
1 parent c1742b0 commit 3ad5388

File tree

4 files changed

+141
-149
lines changed

4 files changed

+141
-149
lines changed
 

Diff for: ‎src/client/localplayer.h

+2
Original file line numberDiff line numberDiff line change
@@ -141,6 +141,8 @@ class LocalPlayer : public Player
141141

142142
void setCollisionbox(const aabb3f &box) { m_collisionbox = box; }
143143

144+
const aabb3f& getCollisionbox() const { return m_collisionbox; }
145+
144146
float getZoomFOV() const { return m_zoom_fov; }
145147
void setZoomFOV(float zoom_fov) { m_zoom_fov = zoom_fov; }
146148

Diff for: ‎src/collision.cpp

+106-116
Original file line numberDiff line numberDiff line change
@@ -25,16 +25,13 @@ with this program; if not, write to the Free Software Foundation, Inc.,
2525
#include "gamedef.h"
2626
#ifndef SERVER
2727
#include "client/clientenvironment.h"
28+
#include "client/localplayer.h"
2829
#endif
2930
#include "serverenvironment.h"
3031
#include "serverobject.h"
3132
#include "util/timetaker.h"
3233
#include "profiler.h"
3334

34-
// float error is 10 - 9.96875 = 0.03125
35-
//#define COLL_ZERO 0.032 // broken unit tests
36-
#define COLL_ZERO 0
37-
3835

3936
struct NearbyCollisionInfo {
4037
NearbyCollisionInfo(bool is_ul, bool is_obj, int bouncy,
@@ -61,118 +58,102 @@ struct NearbyCollisionInfo {
6158
// The time after which the collision occurs is stored in dtime.
6259
CollisionAxis axisAlignedCollision(
6360
const aabb3f &staticbox, const aabb3f &movingbox,
64-
const v3f &speed, f32 d, f32 *dtime)
61+
const v3f &speed, f32 *dtime)
6562
{
6663
//TimeTaker tt("axisAlignedCollision");
6764

68-
f32 xsize = (staticbox.MaxEdge.X - staticbox.MinEdge.X) - COLL_ZERO; // reduce box size for solve collision stuck (flying sand)
69-
f32 ysize = (staticbox.MaxEdge.Y - staticbox.MinEdge.Y); // - COLL_ZERO; // Y - no sense for falling, but maybe try later
70-
f32 zsize = (staticbox.MaxEdge.Z - staticbox.MinEdge.Z) - COLL_ZERO;
71-
7265
aabb3f relbox(
73-
movingbox.MinEdge.X - staticbox.MinEdge.X,
74-
movingbox.MinEdge.Y - staticbox.MinEdge.Y,
75-
movingbox.MinEdge.Z - staticbox.MinEdge.Z,
76-
movingbox.MaxEdge.X - staticbox.MinEdge.X,
77-
movingbox.MaxEdge.Y - staticbox.MinEdge.Y,
78-
movingbox.MaxEdge.Z - staticbox.MinEdge.Z
66+
movingbox.MaxEdge.X - movingbox.MinEdge.X + staticbox.MaxEdge.X - staticbox.MinEdge.X, // sum of the widths
67+
movingbox.MaxEdge.Y - movingbox.MinEdge.Y + staticbox.MaxEdge.Y - staticbox.MinEdge.Y,
68+
movingbox.MaxEdge.Z - movingbox.MinEdge.Z + staticbox.MaxEdge.Z - staticbox.MinEdge.Z,
69+
std::max(movingbox.MaxEdge.X, staticbox.MaxEdge.X) - std::min(movingbox.MinEdge.X, staticbox.MinEdge.X), //outer bounding 'box' dimensions
70+
std::max(movingbox.MaxEdge.Y, staticbox.MaxEdge.Y) - std::min(movingbox.MinEdge.Y, staticbox.MinEdge.Y),
71+
std::max(movingbox.MaxEdge.Z, staticbox.MaxEdge.Z) - std::min(movingbox.MinEdge.Z, staticbox.MinEdge.Z)
7972
);
8073

81-
if(speed.X > 0) // Check for collision with X- plane
82-
{
83-
if (relbox.MaxEdge.X <= d) {
84-
*dtime = -relbox.MaxEdge.X / speed.X;
85-
if ((relbox.MinEdge.Y + speed.Y * (*dtime) < ysize) &&
86-
(relbox.MaxEdge.Y + speed.Y * (*dtime) > COLL_ZERO) &&
87-
(relbox.MinEdge.Z + speed.Z * (*dtime) < zsize) &&
88-
(relbox.MaxEdge.Z + speed.Z * (*dtime) > COLL_ZERO))
89-
return COLLISION_AXIS_X;
90-
}
91-
else if(relbox.MinEdge.X > xsize)
92-
{
93-
return COLLISION_AXIS_NONE;
94-
}
95-
}
96-
else if(speed.X < 0) // Check for collision with X+ plane
97-
{
98-
if (relbox.MinEdge.X >= xsize - d) {
99-
*dtime = (xsize - relbox.MinEdge.X) / speed.X;
100-
if ((relbox.MinEdge.Y + speed.Y * (*dtime) < ysize) &&
101-
(relbox.MaxEdge.Y + speed.Y * (*dtime) > COLL_ZERO) &&
102-
(relbox.MinEdge.Z + speed.Z * (*dtime) < zsize) &&
103-
(relbox.MaxEdge.Z + speed.Z * (*dtime) > COLL_ZERO))
104-
return COLLISION_AXIS_X;
105-
}
106-
else if(relbox.MaxEdge.X < 0)
107-
{
108-
return COLLISION_AXIS_NONE;
74+
const f32 dtime_max = *dtime;
75+
const f32 inner_margin = -1.5f;
76+
f32 distance;
77+
f32 time;
78+
79+
if (speed.X) {
80+
distance = relbox.MaxEdge.X - relbox.MinEdge.X;
81+
82+
*dtime = distance >= 0 ? std::abs(distance / speed.X) : -std::abs(distance / speed.X);
83+
time = std::max(*dtime, 0.0f);
84+
85+
if (distance > inner_margin) {
86+
if (*dtime <= dtime_max) {
87+
if ((speed.X > 0 && staticbox.MaxEdge.X > movingbox.MaxEdge.X) ||
88+
(speed.X < 0 && staticbox.MinEdge.X < movingbox.MinEdge.X)) {
89+
if (
90+
(std::max(movingbox.MaxEdge.Y + speed.Y * time, staticbox.MaxEdge.Y)
91+
- std::min(movingbox.MinEdge.Y + speed.Y * time, staticbox.MinEdge.Y)
92+
- relbox.MinEdge.Y < 0) &&
93+
(std::max(movingbox.MaxEdge.Z + speed.Z * time, staticbox.MaxEdge.Z)
94+
- std::min(movingbox.MinEdge.Z + speed.Z * time, staticbox.MinEdge.Z)
95+
- relbox.MinEdge.Z < 0)
96+
)
97+
return COLLISION_AXIS_X;
98+
}
99+
} else {
100+
return COLLISION_AXIS_NONE;
101+
}
109102
}
110103
}
111104

112105
// NO else if here
113106

114-
if(speed.Y > 0) // Check for collision with Y- plane
115-
{
116-
if (relbox.MaxEdge.Y <= d) {
117-
*dtime = -relbox.MaxEdge.Y / speed.Y;
118-
if ((relbox.MinEdge.X + speed.X * (*dtime) < xsize) &&
119-
(relbox.MaxEdge.X + speed.X * (*dtime) > COLL_ZERO) &&
120-
(relbox.MinEdge.Z + speed.Z * (*dtime) < zsize) &&
121-
(relbox.MaxEdge.Z + speed.Z * (*dtime) > COLL_ZERO))
122-
return COLLISION_AXIS_Y;
123-
}
124-
else if(relbox.MinEdge.Y > ysize)
125-
{
126-
return COLLISION_AXIS_NONE;
127-
}
128-
}
129-
else if(speed.Y < 0) // Check for collision with Y+ plane
130-
{
131-
if (relbox.MinEdge.Y >= ysize - d) {
132-
*dtime = (ysize - relbox.MinEdge.Y) / speed.Y;
133-
if ((relbox.MinEdge.X + speed.X * (*dtime) < xsize) &&
134-
(relbox.MaxEdge.X + speed.X * (*dtime) > COLL_ZERO) &&
135-
(relbox.MinEdge.Z + speed.Z * (*dtime) < zsize) &&
136-
(relbox.MaxEdge.Z + speed.Z * (*dtime) > COLL_ZERO))
137-
return COLLISION_AXIS_Y;
138-
}
139-
else if(relbox.MaxEdge.Y < 0)
140-
{
141-
return COLLISION_AXIS_NONE;
107+
if (speed.Y) {
108+
distance = relbox.MaxEdge.Y - relbox.MinEdge.Y;
109+
110+
*dtime = distance >= 0 ? std::abs(distance / speed.Y) : -std::abs(distance / speed.Y);
111+
time = std::max(*dtime, 0.0f);
112+
113+
if (distance > inner_margin) {
114+
if (*dtime <= dtime_max) {
115+
if ((speed.Y > 0 && staticbox.MaxEdge.Y > movingbox.MaxEdge.Y) ||
116+
(speed.Y < 0 && staticbox.MinEdge.Y < movingbox.MinEdge.Y)) {
117+
if (
118+
(std::max(movingbox.MaxEdge.X + speed.X * time, staticbox.MaxEdge.X)
119+
- std::min(movingbox.MinEdge.X + speed.X * time, staticbox.MinEdge.X)
120+
- relbox.MinEdge.X < 0) &&
121+
(std::max(movingbox.MaxEdge.Z + speed.Z * time, staticbox.MaxEdge.Z)
122+
- std::min(movingbox.MinEdge.Z + speed.Z * time, staticbox.MinEdge.Z)
123+
- relbox.MinEdge.Z < 0)
124+
)
125+
return COLLISION_AXIS_Y;
126+
}
127+
} else {
128+
return COLLISION_AXIS_NONE;
129+
}
142130
}
143131
}
144132

145133
// NO else if here
146134

147-
if(speed.Z > 0) // Check for collision with Z- plane
148-
{
149-
if (relbox.MaxEdge.Z <= d) {
150-
*dtime = -relbox.MaxEdge.Z / speed.Z;
151-
if ((relbox.MinEdge.X + speed.X * (*dtime) < xsize) &&
152-
(relbox.MaxEdge.X + speed.X * (*dtime) > COLL_ZERO) &&
153-
(relbox.MinEdge.Y + speed.Y * (*dtime) < ysize) &&
154-
(relbox.MaxEdge.Y + speed.Y * (*dtime) > COLL_ZERO))
155-
return COLLISION_AXIS_Z;
156-
}
157-
//else if(relbox.MinEdge.Z > zsize)
158-
//{
159-
// return COLLISION_AXIS_NONE;
160-
//}
161-
}
162-
else if(speed.Z < 0) // Check for collision with Z+ plane
163-
{
164-
if (relbox.MinEdge.Z >= zsize - d) {
165-
*dtime = (zsize - relbox.MinEdge.Z) / speed.Z;
166-
if ((relbox.MinEdge.X + speed.X * (*dtime) < xsize) &&
167-
(relbox.MaxEdge.X + speed.X * (*dtime) > COLL_ZERO) &&
168-
(relbox.MinEdge.Y + speed.Y * (*dtime) < ysize) &&
169-
(relbox.MaxEdge.Y + speed.Y * (*dtime) > COLL_ZERO))
170-
return COLLISION_AXIS_Z;
135+
if (speed.Z) {
136+
distance = relbox.MaxEdge.Z - relbox.MinEdge.Z;
137+
138+
*dtime = distance >= 0 ? std::abs(distance / speed.Z) : -std::abs(distance / speed.Z);
139+
time = std::max(*dtime, 0.0f);
140+
141+
if (distance > inner_margin) {
142+
if (*dtime <= dtime_max) {
143+
if ((speed.Z > 0 && staticbox.MaxEdge.Z > movingbox.MaxEdge.Z) ||
144+
(speed.Z < 0 && staticbox.MinEdge.Z < movingbox.MinEdge.Z)) {
145+
if (
146+
(std::max(movingbox.MaxEdge.X + speed.X * time, staticbox.MaxEdge.X)
147+
- std::min(movingbox.MinEdge.X + speed.X * time, staticbox.MinEdge.X)
148+
- relbox.MinEdge.X < 0) &&
149+
(std::max(movingbox.MaxEdge.Y + speed.Y * time, staticbox.MaxEdge.Y)
150+
- std::min(movingbox.MinEdge.Y + speed.Y * time, staticbox.MinEdge.Y)
151+
- relbox.MinEdge.Y < 0)
152+
)
153+
return COLLISION_AXIS_Z;
154+
}
155+
}
171156
}
172-
//else if(relbox.MaxEdge.Z < 0)
173-
//{
174-
// return COLLISION_AXIS_NONE;
175-
//}
176157
}
177158

178159
return COLLISION_AXIS_NONE;
@@ -405,22 +386,25 @@ collisionMoveResult collisionMoveSimple(Environment *env, IGameDef *gamedef,
405386
}
406387
}
407388
}
389+
#ifndef SERVER
390+
if (self && c_env) {
391+
LocalPlayer *lplayer = c_env->getLocalPlayer();
392+
if (lplayer->getParent() == nullptr) {
393+
aabb3f lplayer_collisionbox = lplayer->getCollisionbox();
394+
v3f lplayer_pos = lplayer->getPosition();
395+
lplayer_collisionbox.MinEdge += lplayer_pos;
396+
lplayer_collisionbox.MaxEdge += lplayer_pos;
397+
cinfo.emplace_back(false, true, 0, v3s16(), lplayer_collisionbox);
398+
}
399+
}
400+
#endif
408401
} //tt3
409402

410403
/*
411404
Collision detection
412405
*/
413406

414-
/*
415-
Collision uncertainty radius
416-
Make it a bit larger than the maximum distance of movement
417-
*/
418-
f32 d = pos_max_d * 1.1f;
419-
// A fairly large value in here makes moving smoother
420-
//f32 d = 0.15*BS;
421-
422-
// This should always apply, otherwise there are glitches
423-
assert(d > pos_max_d); // invariant
407+
f32 d = 0.0f;
424408

425409
int loopcount = 0;
426410

@@ -450,9 +434,9 @@ collisionMoveResult collisionMoveSimple(Environment *env, IGameDef *gamedef,
450434
continue;
451435

452436
// Find nearest collision of the two boxes (raytracing-like)
453-
f32 dtime_tmp;
437+
f32 dtime_tmp = nearest_dtime;
454438
CollisionAxis collided = axisAlignedCollision(box_info.box,
455-
movingbox, *speed_f, d, &dtime_tmp);
439+
movingbox, *speed_f, &dtime_tmp);
456440

457441
if (collided == -1 || dtime_tmp >= nearest_dtime)
458442
continue;
@@ -470,11 +454,18 @@ collisionMoveResult collisionMoveSimple(Environment *env, IGameDef *gamedef,
470454
// Otherwise, a collision occurred.
471455
NearbyCollisionInfo &nearest_info = cinfo[nearest_boxindex];
472456
const aabb3f& cbox = nearest_info.box;
457+
458+
//movingbox except moved to the horizontal position it would be after step up
459+
aabb3f stepbox = movingbox;
460+
stepbox.MinEdge.X += speed_f->X * dtime;
461+
stepbox.MinEdge.Z += speed_f->Z * dtime;
462+
stepbox.MaxEdge.X += speed_f->X * dtime;
463+
stepbox.MaxEdge.Z += speed_f->Z * dtime;
473464
// Check for stairs.
474465
bool step_up = (nearest_collided != COLLISION_AXIS_Y) && // must not be Y direction
475466
(movingbox.MinEdge.Y < cbox.MaxEdge.Y) &&
476467
(movingbox.MinEdge.Y + stepheight > cbox.MaxEdge.Y) &&
477-
(!wouldCollideWithCeiling(cinfo, movingbox,
468+
(!wouldCollideWithCeiling(cinfo, stepbox,
478469
cbox.MaxEdge.Y - movingbox.MinEdge.Y,
479470
d));
480471

@@ -483,7 +474,7 @@ collisionMoveResult collisionMoveSimple(Environment *env, IGameDef *gamedef,
483474

484475
// Move to the point of collision and reduce dtime by nearest_dtime
485476
if (nearest_dtime < 0) {
486-
// Handle negative nearest_dtime (can be caused by the d allowance)
477+
// Handle negative nearest_dtime
487478
if (!step_up) {
488479
if (nearest_collided == COLLISION_AXIS_X)
489480
pos_f->X += speed_f->X * nearest_dtime;
@@ -562,9 +553,8 @@ collisionMoveResult collisionMoveSimple(Environment *env, IGameDef *gamedef,
562553
Object touches ground if object's minimum Y is near node's
563554
maximum Y and object's X-Z-area overlaps with the node's
564555
X-Z-area.
565-
566-
Use 0.15*BS so that it is easier to get on a node.
567556
*/
557+
568558
if (cbox.MaxEdge.X - d > box.MinEdge.X && cbox.MinEdge.X + d < box.MaxEdge.X &&
569559
cbox.MaxEdge.Z - d > box.MinEdge.Z &&
570560
cbox.MinEdge.Z + d < box.MaxEdge.Z) {
@@ -574,7 +564,7 @@ collisionMoveResult collisionMoveSimple(Environment *env, IGameDef *gamedef,
574564
box.MinEdge += *pos_f;
575565
box.MaxEdge += *pos_f;
576566
}
577-
if (std::fabs(cbox.MaxEdge.Y - box.MinEdge.Y) < 0.15f * BS) {
567+
if (std::fabs(cbox.MaxEdge.Y - box.MinEdge.Y) < 0.05f) {
578568
result.touching_ground = true;
579569

580570
if (box_info.is_object)

Diff for: ‎src/collision.h

+1-1
Original file line numberDiff line numberDiff line change
@@ -77,7 +77,7 @@ collisionMoveResult collisionMoveSimple(Environment *env,IGameDef *gamedef,
7777
// dtime receives time until first collision, invalid if -1 is returned
7878
CollisionAxis axisAlignedCollision(
7979
const aabb3f &staticbox, const aabb3f &movingbox,
80-
const v3f &speed, f32 d, f32 *dtime);
80+
const v3f &speed, f32 *dtime);
8181

8282
// Helper function:
8383
// Checks if moving the movingbox up by the given distance would hit a ceiling.

Diff for: ‎src/unittest/test_collision.cpp

+32-32
Original file line numberDiff line numberDiff line change
@@ -50,38 +50,38 @@ void TestCollision::testAxisAlignedCollision()
5050
aabb3f s(bx, by, bz, bx+1, by+1, bz+1);
5151
aabb3f m(bx-2, by, bz, bx-1, by+1, bz+1);
5252
v3f v(1, 0, 0);
53-
f32 dtime = 0;
54-
UASSERT(axisAlignedCollision(s, m, v, 0, &dtime) == 0);
53+
f32 dtime = 1.0f;
54+
UASSERT(axisAlignedCollision(s, m, v, &dtime) == 0);
5555
UASSERT(fabs(dtime - 1.000) < 0.001);
5656
}
5757
{
5858
aabb3f s(bx, by, bz, bx+1, by+1, bz+1);
5959
aabb3f m(bx-2, by, bz, bx-1, by+1, bz+1);
6060
v3f v(-1, 0, 0);
61-
f32 dtime = 0;
62-
UASSERT(axisAlignedCollision(s, m, v, 0, &dtime) == -1);
61+
f32 dtime = 1.0f;
62+
UASSERT(axisAlignedCollision(s, m, v, &dtime) == -1);
6363
}
6464
{
6565
aabb3f s(bx, by, bz, bx+1, by+1, bz+1);
6666
aabb3f m(bx-2, by+1.5, bz, bx-1, by+2.5, bz-1);
6767
v3f v(1, 0, 0);
68-
f32 dtime;
69-
UASSERT(axisAlignedCollision(s, m, v, 0, &dtime) == -1);
68+
f32 dtime = 1.0f;
69+
UASSERT(axisAlignedCollision(s, m, v, &dtime) == -1);
7070
}
7171
{
7272
aabb3f s(bx, by, bz, bx+1, by+1, bz+1);
7373
aabb3f m(bx-2, by-1.5, bz, bx-1.5, by+0.5, bz+1);
7474
v3f v(0.5, 0.1, 0);
75-
f32 dtime;
76-
UASSERT(axisAlignedCollision(s, m, v, 0, &dtime) == 0);
75+
f32 dtime = 3.0f;
76+
UASSERT(axisAlignedCollision(s, m, v, &dtime) == 0);
7777
UASSERT(fabs(dtime - 3.000) < 0.001);
7878
}
7979
{
8080
aabb3f s(bx, by, bz, bx+1, by+1, bz+1);
8181
aabb3f m(bx-2, by-1.5, bz, bx-1.5, by+0.5, bz+1);
8282
v3f v(0.5, 0.1, 0);
83-
f32 dtime;
84-
UASSERT(axisAlignedCollision(s, m, v, 0, &dtime) == 0);
83+
f32 dtime = 3.0f;
84+
UASSERT(axisAlignedCollision(s, m, v, &dtime) == 0);
8585
UASSERT(fabs(dtime - 3.000) < 0.001);
8686
}
8787

@@ -90,38 +90,38 @@ void TestCollision::testAxisAlignedCollision()
9090
aabb3f s(bx, by, bz, bx+1, by+1, bz+1);
9191
aabb3f m(bx+2, by, bz, bx+3, by+1, bz+1);
9292
v3f v(-1, 0, 0);
93-
f32 dtime;
94-
UASSERT(axisAlignedCollision(s, m, v, 0, &dtime) == 0);
93+
f32 dtime = 1.0f;
94+
UASSERT(axisAlignedCollision(s, m, v, &dtime) == 0);
9595
UASSERT(fabs(dtime - 1.000) < 0.001);
9696
}
9797
{
9898
aabb3f s(bx, by, bz, bx+1, by+1, bz+1);
9999
aabb3f m(bx+2, by, bz, bx+3, by+1, bz+1);
100100
v3f v(1, 0, 0);
101-
f32 dtime;
102-
UASSERT(axisAlignedCollision(s, m, v, 0, &dtime) == -1);
101+
f32 dtime = 1.0f;
102+
UASSERT(axisAlignedCollision(s, m, v, &dtime) == -1);
103103
}
104104
{
105105
aabb3f s(bx, by, bz, bx+1, by+1, bz+1);
106106
aabb3f m(bx+2, by, bz+1.5, bx+3, by+1, bz+3.5);
107107
v3f v(-1, 0, 0);
108-
f32 dtime;
109-
UASSERT(axisAlignedCollision(s, m, v, 0, &dtime) == -1);
108+
f32 dtime = 1.0f;
109+
UASSERT(axisAlignedCollision(s, m, v, &dtime) == -1);
110110
}
111111
{
112112
aabb3f s(bx, by, bz, bx+1, by+1, bz+1);
113113
aabb3f m(bx+2, by-1.5, bz, bx+2.5, by-0.5, bz+1);
114114
v3f v(-0.5, 0.2, 0);
115-
f32 dtime;
116-
UASSERT(axisAlignedCollision(s, m, v, 0, &dtime) == 1); // Y, not X!
115+
f32 dtime = 2.5f;
116+
UASSERT(axisAlignedCollision(s, m, v, &dtime) == 1); // Y, not X!
117117
UASSERT(fabs(dtime - 2.500) < 0.001);
118118
}
119119
{
120120
aabb3f s(bx, by, bz, bx+1, by+1, bz+1);
121121
aabb3f m(bx+2, by-1.5, bz, bx+2.5, by-0.5, bz+1);
122122
v3f v(-0.5, 0.3, 0);
123-
f32 dtime;
124-
UASSERT(axisAlignedCollision(s, m, v, 0, &dtime) == 0);
123+
f32 dtime = 2.0f;
124+
UASSERT(axisAlignedCollision(s, m, v, &dtime) == 0);
125125
UASSERT(fabs(dtime - 2.000) < 0.001);
126126
}
127127

@@ -132,48 +132,48 @@ void TestCollision::testAxisAlignedCollision()
132132
aabb3f s(bx, by, bz, bx+2, by+2, bz+2);
133133
aabb3f m(bx+2.3, by+2.29, bz+2.29, bx+4.2, by+4.2, bz+4.2);
134134
v3f v(-1./3, -1./3, -1./3);
135-
f32 dtime;
136-
UASSERT(axisAlignedCollision(s, m, v, 0, &dtime) == 0);
135+
f32 dtime = 1.0f;
136+
UASSERT(axisAlignedCollision(s, m, v, &dtime) == 0);
137137
UASSERT(fabs(dtime - 0.9) < 0.001);
138138
}
139139
{
140140
aabb3f s(bx, by, bz, bx+2, by+2, bz+2);
141141
aabb3f m(bx+2.29, by+2.3, bz+2.29, bx+4.2, by+4.2, bz+4.2);
142142
v3f v(-1./3, -1./3, -1./3);
143-
f32 dtime;
144-
UASSERT(axisAlignedCollision(s, m, v, 0, &dtime) == 1);
143+
f32 dtime = 1.0f;
144+
UASSERT(axisAlignedCollision(s, m, v, &dtime) == 1);
145145
UASSERT(fabs(dtime - 0.9) < 0.001);
146146
}
147147
{
148148
aabb3f s(bx, by, bz, bx+2, by+2, bz+2);
149149
aabb3f m(bx+2.29, by+2.29, bz+2.3, bx+4.2, by+4.2, bz+4.2);
150150
v3f v(-1./3, -1./3, -1./3);
151-
f32 dtime;
152-
UASSERT(axisAlignedCollision(s, m, v, 0, &dtime) == 2);
151+
f32 dtime = 1.0f;
152+
UASSERT(axisAlignedCollision(s, m, v, &dtime) == 2);
153153
UASSERT(fabs(dtime - 0.9) < 0.001);
154154
}
155155
{
156156
aabb3f s(bx, by, bz, bx+2, by+2, bz+2);
157157
aabb3f m(bx-4.2, by-4.2, bz-4.2, bx-2.3, by-2.29, bz-2.29);
158158
v3f v(1./7, 1./7, 1./7);
159-
f32 dtime;
160-
UASSERT(axisAlignedCollision(s, m, v, 0, &dtime) == 0);
159+
f32 dtime = 17.0f;
160+
UASSERT(axisAlignedCollision(s, m, v, &dtime) == 0);
161161
UASSERT(fabs(dtime - 16.1) < 0.001);
162162
}
163163
{
164164
aabb3f s(bx, by, bz, bx+2, by+2, bz+2);
165165
aabb3f m(bx-4.2, by-4.2, bz-4.2, bx-2.29, by-2.3, bz-2.29);
166166
v3f v(1./7, 1./7, 1./7);
167-
f32 dtime;
168-
UASSERT(axisAlignedCollision(s, m, v, 0, &dtime) == 1);
167+
f32 dtime = 17.0f;
168+
UASSERT(axisAlignedCollision(s, m, v, &dtime) == 1);
169169
UASSERT(fabs(dtime - 16.1) < 0.001);
170170
}
171171
{
172172
aabb3f s(bx, by, bz, bx+2, by+2, bz+2);
173173
aabb3f m(bx-4.2, by-4.2, bz-4.2, bx-2.29, by-2.29, bz-2.3);
174174
v3f v(1./7, 1./7, 1./7);
175-
f32 dtime;
176-
UASSERT(axisAlignedCollision(s, m, v, 0, &dtime) == 2);
175+
f32 dtime = 17.0f;
176+
UASSERT(axisAlignedCollision(s, m, v, &dtime) == 2);
177177
UASSERT(fabs(dtime - 16.1) < 0.001);
178178
}
179179
}

0 commit comments

Comments
 (0)
Please sign in to comment.