qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2024-11-27 14:42:07 +00:00
Code Issues Projects Releases Packages Wiki Activity
quakeforge/libs/models/test/testclip.c

370 lines
12 KiB
C
Raw Normal View History

Make MOD_TraceLine behave "correctly". MOD_TraceLine now behaves the same as id's SV_RecursiveHullCheck (from WinQuake). This means that even if the trace would escape from solid space into non-solid space, the trace is treated as allsolid if it crosses from one solid space to another before hitting the empty space. trace-id.c is used only for establishing the behaviour of id's code.
2010-12-06 06:30:56 +00:00
#include <stdlib.h>
#include "QF/va.h"
#include "getopt.h"
#include "world.h"
Split out the hull data so it can be used in other tests.
2011-12-03 11:20:33 +00:00
#include "hulls.h"
Make MOD_TraceLine behave "correctly". MOD_TraceLine now behaves the same as id's SV_RecursiveHullCheck (from WinQuake). This means that even if the trace would escape from solid space into non-solid space, the trace is treated as allsolid if it crosses from one solid space to another before hitting the empty space. trace-id.c is used only for establishing the behaviour of id's code.
2010-12-06 06:30:56 +00:00
#undef DIST_EPSILON
#define DIST_EPSILON 0
#ifdef TEST_ID
# include "trace-id.c"
Add trace-qf-bad.c to Makefile.am and testclip.c.
2011-09-27 08:09:04 +00:00
#elif defined(TEST_QF_BAD)
# include "trace-qf-bad.c"
Make MOD_TraceLine behave "correctly". MOD_TraceLine now behaves the same as id's SV_RecursiveHullCheck (from WinQuake). This means that even if the trace would escape from solid space into non-solid space, the trace is treated as allsolid if it crosses from one solid space to another before hitting the empty space. trace-id.c is used only for establishing the behaviour of id's code.
2010-12-06 06:30:56 +00:00
#else
Move the testclip program into its own directory. Same as with the audio test program, this is to avoid issues with -prefer-pic.
2011-06-12 07:12:52 +00:00
# include "../trace.c"
Make MOD_TraceLine behave "correctly". MOD_TraceLine now behaves the same as id's SV_RecursiveHullCheck (from WinQuake). This means that even if the trace would escape from solid space into non-solid space, the trace is treated as allsolid if it crosses from one solid space to another before hitting the empty space. trace-id.c is used only for establishing the behaviour of id's code.
2010-12-06 06:30:56 +00:00
#endif
Test the simple wedge.
2011-11-28 08:03:56 +00:00
#define FloatCompare(a, b) (fabs (a - b) < 1e-5)
Be a little more lenient with float comparisons. Unfortunately, Pythagorus and binary don't play well together, so rounding errors are inevetible when testing with a slope. However, 1e-6 seems to be a good epsilon (printf's %g hides it nicely :).
2011-11-27 05:19:05 +00:00
#undef VectorCompare
#define VectorCompare(x, y) \
(FloatCompare (x[0], y[0]) && FloatCompare (x[1], y[1]) \
&& FloatCompare (x[2], y[2]))
Make MOD_TraceLine behave "correctly". MOD_TraceLine now behaves the same as id's SV_RecursiveHullCheck (from WinQuake). This means that even if the trace would escape from solid space into non-solid space, the trace is treated as allsolid if it crosses from one solid space to another before hitting the empty space. trace-id.c is used only for establishing the behaviour of id's code.
2010-12-06 06:30:56 +00:00
typedef struct {
vec3_t extents;
} box_t;
typedef struct {
const char *desc;
box_t *box;
hull_t *hull;
vec3_t start;
vec3_t end;
struct {
float frac;
qboolean allsolid;
qboolean startsolid;
qboolean inopen;
qboolean inwater;
Add code to rebuild the bsp brushes. Names and locations of declarations are still up in the air, but things seem to be working assuming my test code is correct.
2011-11-15 03:57:08 +00:00
int num_portals;
Make MOD_TraceLine behave "correctly". MOD_TraceLine now behaves the same as id's SV_RecursiveHullCheck (from WinQuake). This means that even if the trace would escape from solid space into non-solid space, the trace is treated as allsolid if it crosses from one solid space to another before hitting the empty space. trace-id.c is used only for establishing the behaviour of id's code.
2010-12-06 06:30:56 +00:00
} expect;
} test_t;
box_t point = { {0, 0, 0} };
Make a fresh start on box clipping. I even have a failing test to fix :)
2011-10-02 12:06:56 +00:00
box_t box = { {8, 8, 8} };
Make MOD_TraceLine behave "correctly". MOD_TraceLine now behaves the same as id's SV_RecursiveHullCheck (from WinQuake). This means that even if the trace would escape from solid space into non-solid space, the trace is treated as allsolid if it crosses from one solid space to another before hitting the empty space. trace-id.c is used only for establishing the behaviour of id's code.
2010-12-06 06:30:56 +00:00
box_t player = { {16, 16, 28} };
test_t tests[] = {
Do some renaming to make things a little clearer.
2011-06-12 08:03:51 +00:00
{"Point, Three parallel planes 1", &point, &hull_tpp1,
Add code to rebuild the bsp brushes. Names and locations of declarations are still up in the air, but things seem to be working assuming my test code is correct.
2011-11-15 03:57:08 +00:00
{-64, 0, 0}, { 64, 0, 0}, { 1, 1, 1, 0, 0, 3}},
Do some renaming to make things a little clearer.
2011-06-12 08:03:51 +00:00
{"Point, Three parallel planes 1", &point, &hull_tpp1,
Add code to rebuild the bsp brushes. Names and locations of declarations are still up in the air, but things seem to be working assuming my test code is correct.
2011-11-15 03:57:08 +00:00
{ 0, 0, 0}, { 40, 0, 0}, { 1, 0, 1, 1, 0, 3}},
Do some renaming to make things a little clearer.
2011-06-12 08:03:51 +00:00
{"Point, Three parallel planes 1", &point, &hull_tpp1,
Add code to rebuild the bsp brushes. Names and locations of declarations are still up in the air, but things seem to be working assuming my test code is correct.
2011-11-15 03:57:08 +00:00
{ 40, 0, 0}, {-88, 0, 0}, {0.0625, 0, 0, 1, 0, 3}},
Do some renaming to make things a little clearer.
2011-06-12 08:03:51 +00:00
{"Point, Three parallel planes 1", &point, &hull_tpp1,
Add code to rebuild the bsp brushes. Names and locations of declarations are still up in the air, but things seem to be working assuming my test code is correct.
2011-11-15 03:57:08 +00:00
{ 0, 0, 0}, { 64, 0, 0}, { 0.75, 0, 1, 1, 0, 3}},
Do some renaming to make things a little clearer.
2011-06-12 08:03:51 +00:00
{"Point, Three parallel planes 1", &point, &hull_tpp1,
Add code to rebuild the bsp brushes. Names and locations of declarations are still up in the air, but things seem to be working assuming my test code is correct.
2011-11-15 03:57:08 +00:00
{ 0, 0, 0}, { 0, 8, 0}, { 1, 1, 1, 0, 0, 3}},
Do some renaming to make things a little clearer.
2011-06-12 08:03:51 +00:00
{"Point, Three parallel planes 1", &point, &hull_tpp1,
Add code to rebuild the bsp brushes. Names and locations of declarations are still up in the air, but things seem to be working assuming my test code is correct.
2011-11-15 03:57:08 +00:00
{ 40, 0, 0}, { 40, 8, 0}, { 1, 0, 0, 1, 0, 3}},
Do some renaming to make things a little clearer.
2011-06-12 08:03:51 +00:00
{"Point, Three parallel planes 2", &point, &hull_tpp2,
Add code to rebuild the bsp brushes. Names and locations of declarations are still up in the air, but things seem to be working assuming my test code is correct.
2011-11-15 03:57:08 +00:00
{-64, 0, 0}, { 64, 0, 0}, { 1, 1, 1, 0, 0, 3}},
Do some renaming to make things a little clearer.
2011-06-12 08:03:51 +00:00
{"Point, Three parallel planes 2", &point, &hull_tpp2,
Add code to rebuild the bsp brushes. Names and locations of declarations are still up in the air, but things seem to be working assuming my test code is correct.
2011-11-15 03:57:08 +00:00
{ 0, 0, 0}, { 40, 0, 0}, { 1, 0, 1, 1, 0, 3}},
Do some renaming to make things a little clearer.
2011-06-12 08:03:51 +00:00
{"Point, Three parallel planes 2", &point, &hull_tpp2,
Add code to rebuild the bsp brushes. Names and locations of declarations are still up in the air, but things seem to be working assuming my test code is correct.
2011-11-15 03:57:08 +00:00
{ 40, 0, 0}, {-88, 0, 0}, {0.0625, 0, 0, 1, 0, 3}},
Do some renaming to make things a little clearer.
2011-06-12 08:03:51 +00:00
{"Point, Three parallel planes 2", &point, &hull_tpp2,
Add code to rebuild the bsp brushes. Names and locations of declarations are still up in the air, but things seem to be working assuming my test code is correct.
2011-11-15 03:57:08 +00:00
{ 0, 0, 0}, { 64, 0, 0}, { 0.75, 0, 1, 1, 0, 3}},
Do some renaming to make things a little clearer.
2011-06-12 08:03:51 +00:00
{"Point, Three parallel planes with water", &point, &hull_tppw,
Add code to rebuild the bsp brushes. Names and locations of declarations are still up in the air, but things seem to be working assuming my test code is correct.
2011-11-15 03:57:08 +00:00
{-64, 0, 0}, { 64, 0, 0}, { 0.875, 0, 1, 1, 1, 3}},
Do some renaming to make things a little clearer.
2011-06-12 08:03:51 +00:00
{"Point, Three parallel planes with water", &point, &hull_tppw,
Add code to rebuild the bsp brushes. Names and locations of declarations are still up in the air, but things seem to be working assuming my test code is correct.
2011-11-15 03:57:08 +00:00
{ 0, 0, 0}, { 40, 0, 0}, { 1, 0, 0, 1, 1, 3}},
Do some renaming to make things a little clearer.
2011-06-12 08:03:51 +00:00
{"Point, Three parallel planes with water", &point, &hull_tppw,
Add code to rebuild the bsp brushes. Names and locations of declarations are still up in the air, but things seem to be working assuming my test code is correct.
2011-11-15 03:57:08 +00:00
{ 40, 0, 0}, {-88, 0, 0}, {0.5625, 0, 0, 1, 1, 3}},
Do some renaming to make things a little clearer.
2011-06-12 08:03:51 +00:00
{"Point, Three parallel planes with water", &point, &hull_tppw,
Add code to rebuild the bsp brushes. Names and locations of declarations are still up in the air, but things seem to be working assuming my test code is correct.
2011-11-15 03:57:08 +00:00
{ 0, 0, 0}, { 64, 0, 0}, { 0.75, 0, 0, 1, 1, 3}},
Do some renaming to make things a little clearer.
2011-06-12 08:03:51 +00:00
{"Point, Three parallel planes with water", &point, &hull_tppw,
Add code to rebuild the bsp brushes. Names and locations of declarations are still up in the air, but things seem to be working assuming my test code is correct.
2011-11-15 03:57:08 +00:00
{ 0, 0, 0}, { 0, 8, 0}, { 1, 0, 0, 1, 0, 3}},
Do some renaming to make things a little clearer.
2011-06-12 08:03:51 +00:00
{"Point, Three parallel planes with water", &point, &hull_tppw,
Add code to rebuild the bsp brushes. Names and locations of declarations are still up in the air, but things seem to be working assuming my test code is correct.
2011-11-15 03:57:08 +00:00
{ 40, 0, 0}, { 40, 8, 0}, { 1, 0, 0, 0, 1, 3}},
Do some renaming to make things a little clearer.
2011-06-12 08:03:51 +00:00
{"Point, Three parallel planes with water", &point, &hull_tppw,
Add code to rebuild the bsp brushes. Names and locations of declarations are still up in the air, but things seem to be working assuming my test code is correct.
2011-11-15 03:57:08 +00:00
{ 0, 0, 0}, { 40, 0, 0}, { 1, 0, 0, 1, 1, 3}},
Make a fresh start on box clipping. I even have a failing test to fix :)
2011-10-02 12:06:56 +00:00
{"Point, Step 1", &point, &hull_step1,
Add code to rebuild the bsp brushes. Names and locations of declarations are still up in the air, but things seem to be working assuming my test code is correct.
2011-11-15 03:57:08 +00:00
{ -16, 0, 8}, {16, 0, 24}, { 0.5, 0, 0, 1, 0, 5}},
Make a fresh start on box clipping. I even have a failing test to fix :)
2011-10-02 12:06:56 +00:00
{"Box, Step 1", &box, &hull_step1,
Add code to rebuild the bsp brushes. Names and locations of declarations are still up in the air, but things seem to be working assuming my test code is correct.
2011-11-15 03:57:08 +00:00
{ -16, 0, 8}, {16, 0, 24}, { 0.25, 0, 0, 1, 0, 5}},
Another test, another bug. Fix an incorrect test using offset (forgot to negate).
2011-11-12 09:12:56 +00:00
{"Box, Step 1", &box, &hull_step1,
Add code to rebuild the bsp brushes. Names and locations of declarations are still up in the air, but things seem to be working assuming my test code is correct.
2011-11-15 03:57:08 +00:00
{ -16, 0, 8}, {16, 0, 40}, { 0.25, 0, 0, 1, 0, 5}},
Correct the sign for the shift in frac. However, this is not entirely correct as the new start point when testing the other side of the plane also needs to be calculated.
2011-11-12 09:53:05 +00:00
{"Box, Step 1", &box, &hull_step1,
Add code to rebuild the bsp brushes. Names and locations of declarations are still up in the air, but things seem to be working assuming my test code is correct.
2011-11-15 03:57:08 +00:00
{ -16, 0, 8}, {16, 0, 135}, { 0.25, 0, 0, 1, 0, 5}},
Correct the sign for the shift in frac. However, this is not entirely correct as the new start point when testing the other side of the plane also needs to be calculated.
2011-11-12 09:53:05 +00:00
{"Box, Step 1", &box, &hull_step1,
Box traces can now graze a corner.
2011-11-28 08:06:04 +00:00
{ -16, 0, 8}, {16, 0, 136}, { 1, 0, 0, 1, 0, 5}},
Move the start point to the near side of the crossed plane. I'm not sure the end point needs to be moved at all, but I'll leave it alone for now. I have a couple of failing test cases that seem to be caused by not handling moves where the box is always cut by the plane.
2011-11-12 11:42:44 +00:00
{"Point, Covered Step", &point, &hull_covered_step,
Add a bunch of in-solid tests. Tests where the box is only partially in a solid tend to fail (particularly when the solid is on the back side of the split plane).
2011-11-28 11:28:37 +00:00
{-24, 0, 8}, {-24, 0, 72}, { 0.5, 0, 0, 1, 0, 9}},
Move the start point to the near side of the crossed plane. I'm not sure the end point needs to be moved at all, but I'll leave it alone for now. I have a couple of failing test cases that seem to be caused by not handling moves where the box is always cut by the plane.
2011-11-12 11:42:44 +00:00
{"Box, Covered Step", &box, &hull_covered_step,
Add a bunch of in-solid tests. Tests where the box is only partially in a solid tend to fail (particularly when the solid is on the back side of the split plane).
2011-11-28 11:28:37 +00:00
{-32, 0, 8}, {-32, 0, 72}, { 0.375, 0, 0, 1, 0, 9}},
Move the start point to the near side of the crossed plane. I'm not sure the end point needs to be moved at all, but I'll leave it alone for now. I have a couple of failing test cases that seem to be caused by not handling moves where the box is always cut by the plane.
2011-11-12 11:42:44 +00:00
{"Box, Covered Step", &box, &hull_covered_step,
Add a bunch of in-solid tests. Tests where the box is only partially in a solid tend to fail (particularly when the solid is on the back side of the split plane).
2011-11-28 11:28:37 +00:00
{-24, 0, 8}, {-24, 0, 72}, { 0.375, 0, 0, 1, 0, 9}},
Move the start point to the near side of the crossed plane. I'm not sure the end point needs to be moved at all, but I'll leave it alone for now. I have a couple of failing test cases that seem to be caused by not handling moves where the box is always cut by the plane.
2011-11-12 11:42:44 +00:00
{"Box, Covered Step", &box, &hull_covered_step,
Add a bunch of in-solid tests. Tests where the box is only partially in a solid tend to fail (particularly when the solid is on the back side of the split plane).
2011-11-28 11:28:37 +00:00
{-25, 0, 8}, { 7, 0, 72}, { 0.375, 0, 0, 1, 0, 9}},
Fix the covered step tests. However, there is still a problem with moves where the box is always cut by the plane: both sides need to be tested (done), but when the first side checked allows longer motion than the second, but still collides, only the first side is checked. The shorter motion is required.
2011-11-12 12:30:45 +00:00
{"Box, Covered Step", &box, &hull_covered_step,
Add a bunch of in-solid tests. Tests where the box is only partially in a solid tend to fail (particularly when the solid is on the back side of the split plane).
2011-11-28 11:28:37 +00:00
{ -8, 0, 40}, {-16, 0, 40}, { 0.5, 0, 0, 1, 0, 9}},
Fix the covered step tests. However, there is still a problem with moves where the box is always cut by the plane: both sides need to be tested (done), but when the first side checked allows longer motion than the second, but still collides, only the first side is checked. The shorter motion is required.
2011-11-12 12:30:45 +00:00
{"Box, Covered Step", &box, &hull_covered_step,
Add a bunch of in-solid tests. Tests where the box is only partially in a solid tend to fail (particularly when the solid is on the back side of the split plane).
2011-11-28 11:28:37 +00:00
{-17, 0, 8}, { -1, 0, 72}, { 1, 0, 0, 1, 0, 9}},
Move the start point to the near side of the crossed plane. I'm not sure the end point needs to be moved at all, but I'll leave it alone for now. I have a couple of failing test cases that seem to be caused by not handling moves where the box is always cut by the plane.
2011-11-12 11:42:44 +00:00
{"Box, Covered Step", &box, &hull_covered_step,
Add a bunch of in-solid tests. Tests where the box is only partially in a solid tend to fail (particularly when the solid is on the back side of the split plane).
2011-11-28 11:28:37 +00:00
{ -8, 0, 40}, { 8, 0, 72}, { 1, 0, 0, 1, 0, 9}},
Fix plane touching box backsideness. Because a box has size, even when touching a plane, the side on which the box is can be determined (unlike a point).
2011-11-28 08:12:39 +00:00
{"Box, Covered Step touch backside", &box, &hull_covered_step,
Add a bunch of in-solid tests. Tests where the box is only partially in a solid tend to fail (particularly when the solid is on the back side of the split plane).
2011-11-28 11:28:37 +00:00
{ -8, 0, 8}, {-12, 0, 12}, { 1, 0, 0, 1, 0, 9}},
Fix plane touching box backsideness. Because a box has size, even when touching a plane, the side on which the box is can be determined (unlike a point).
2011-11-28 08:12:39 +00:00
{"Point, Covered Step touch backside", &point, &hull_covered_step,
Add a bunch of in-solid tests. Tests where the box is only partially in a solid tend to fail (particularly when the solid is on the back side of the split plane).
2011-11-28 11:28:37 +00:00
{ 0, 0, 8}, {-12, 0, 12}, { 1, 0, 1, 1, 0, 9}},
{"Box, Covered Step start solid", &box, &hull_covered_step,
{ -4, 0, 4}, {-12, 0, 12}, { 1, 0, 1, 1, 0, 9}},
{"Box, Covered Step start solid", &box, &hull_covered_step,
{ -4, 0, 4}, {-16, 0, 36}, { 0.875, 0, 1, 1, 0, 9}},
{"Box, Covered Step start solid", &box, &hull_covered_step,
{ -4, 0, 4}, {-16, 0, 4}, { 1, 1, 1, 0, 0, 9}},
{"Box, Covered Step start solid", &box, &hull_covered_step,
{-12, 0, 4}, {-16, 0, 4}, { 1, 1, 1, 0, 0, 9}},
{"Box, Covered Step start solid", &box, &hull_covered_step,
{-16, 0, 4}, { -4, 0, 4}, { 1, 1, 1, 0, 0, 9}},
{"Box, Covered Step start solid", &box, &hull_covered_step,
{ 16, 0, -16}, { 16, 0, 64}, { 1, 1, 1, 0, 0, 9}},
{"Box, Covered Step start solid", &box, &hull_covered_step,
{ 16, 0, 16}, { 16, 0, 64}, { 1, 0, 1, 1, 0, 9}},
Fix the covered step tests. However, there is still a problem with moves where the box is always cut by the plane: both sides need to be tested (done), but when the first side checked allows longer motion than the second, but still collides, only the first side is checked. The shorter motion is required.
2011-11-12 12:30:45 +00:00
{"Box, Step 2", &box, &hull_step2,
Add code to rebuild the bsp brushes. Names and locations of declarations are still up in the air, but things seem to be working assuming my test code is correct.
2011-11-15 03:57:08 +00:00
{ 0, 0, 64}, {0, 0, 0}, { 0.375, 0, 0, 1, 0, 5}},
Fix the covered step tests. However, there is still a problem with moves where the box is always cut by the plane: both sides need to be tested (done), but when the first side checked allows longer motion than the second, but still collides, only the first side is checked. The shorter motion is required.
2011-11-12 12:30:45 +00:00
{"Box, Step 3", &box, &hull_step3,
Add code to rebuild the bsp brushes. Names and locations of declarations are still up in the air, but things seem to be working assuming my test code is correct.
2011-11-15 03:57:08 +00:00
{ 0, 0, 64}, {0, 0, 0}, { 0.375, 0, 0, 1, 0, 5}},
Add a new (failing) test case. This one demonstrates the need for more information in the bsp tree (surface polygons). When the box collides with a corner where one side is flat and the other angled, but there's a partition plane cutting the two, the box can instead collide with the angled side before it hits the corner.
2011-11-14 00:26:31 +00:00
{"Box, Ramp", &box, &hull_ramp,
Add code to rebuild the bsp brushes. Names and locations of declarations are still up in the air, but things seem to be working assuming my test code is correct.
2011-11-15 03:57:08 +00:00
{ 0, 0, 16}, {0, 0, 0}, { 0.5, 0, 0, 1, 0, 4}},
Add some more tests for the ramp. These tests pass, but show the basic polygon testing working (just not the collision handling and thus fraction determination).
2011-11-27 05:22:32 +00:00
{"Box, Ramp", &box, &hull_ramp,
{-16, 0, 8}, {16, 0, 8}, { 1, 0, 0, 1, 0, 4}},
{"Box, Ramp", &box, &hull_ramp,
{-16, 0, 5}, {16, 0, 5}, { 0.125, 0, 0, 1, 0, 4}},
Test the simple wedge.
2011-11-28 08:03:56 +00:00
{"Box, Simple Wedge", &box, &hull_simple_wedge,
{ 0, 0, 16}, {0, 0, 0}, { 0.5, 0, 0, 1, 0, 3}},
{"Box, Simple Wedge", &box, &hull_simple_wedge,
{-16, 0, 8}, {16, 0, 8}, { 1, 0, 0, 1, 0, 3}},
{"Box, Simple Wedge", &box, &hull_simple_wedge,
{-16, 0, 5}, {16, 0, 5}, { 0.25, 0, 0, 1, 0, 3}},
{"Box, Simple Wedge", &box, &hull_simple_wedge,
{-16, 0, 12}, {16, 0, 4}, { 0.5, 0, 0, 1, 0, 3}},
Add some snug-fit tests and fix the uncovered bugs. The tests involve the box fitting into a hole with zero slop (this would be impossible with point clipping).
2011-11-28 10:07:00 +00:00
{"Box, Hole. slide in", &box, &hull_hole,
{ 0, -16, 0}, { 0, 16, 0}, { 1, 0, 0, 1, 0, 13}},
{"Box, Hole. slide out", &box, &hull_hole,
{ 0, 16, 0}, { 0, -16, 0}, { 1, 0, 0, 1, 0, 13}},
{"Box, Hole. tight", &box, &hull_hole,
{ 0, 16, 0}, { 0, 16, 16}, { 0, 0, 0, 1, 0, 13}},
{"Box, Hole. tight", &box, &hull_hole,
{ 0, 16, 0}, { 0, 16, -16}, { 0, 0, 0, 1, 0, 13}},
{"Box, Hole. tight", &box, &hull_hole,
{ 0, 16, 0}, { 16, 16, 0}, { 0, 0, 0, 1, 0, 13}},
{"Box, Hole. tight", &box, &hull_hole,
{ 0, 16, 0}, {-16, 16, 0}, { 0, 0, 0, 1, 0, 13}},
{"Box, Hole. edge", &box, &hull_hole,
{ 0, -16, 1}, { 0, 16, 1}, { 0.25, 0, 0, 1, 0, 13}},
{"Box, Hole. edge", &box, &hull_hole,
{ 0, -16, -1}, { 0, 16, -1}, { 0.25, 0, 0, 1, 0, 13}},
{"Box, Hole. edge", &box, &hull_hole,
{ 1, -16, 0}, { 1, 16, 0}, { 0.25, 0, 0, 1, 0, 13}},
{"Box, Hole. edge", &box, &hull_hole,
{-1, -16, 0}, { -1, 16, 0}, { 0.25, 0, 0, 1, 0, 13}},
Test collisions with a ridge smaller than the box. Whee, found a failing test case :)
2011-12-04 00:02:12 +00:00
{"Box, ridge", &box, &hull_ridge,
Fix a silly test case error.
2011-12-04 01:47:52 +00:00
{4, 0, 41}, { 4, 0, 39}, { 0.5, 0, 0, 1, 0, 8}},
Put the mistaken test case back in.
2011-12-04 02:00:38 +00:00
{"Box, ridge, all solid", &box, &hull_ridge,
{4, 41, 0}, { 4, 39, 0}, { 1, 1, 1, 0, 0, 8}},
Make MOD_TraceLine behave "correctly". MOD_TraceLine now behaves the same as id's SV_RecursiveHullCheck (from WinQuake). This means that even if the trace would escape from solid space into non-solid space, the trace is treated as allsolid if it crosses from one solid space to another before hitting the empty space. trace-id.c is used only for establishing the behaviour of id's code.
2010-12-06 06:30:56 +00:00
};
#define num_tests (sizeof (tests) / sizeof (tests[0]))
int verbose = 0;
static trace_t
do_trace (box_t *box, hull_t *hull, vec3_t start, vec3_t end)
{
trace_t trace;
trace.allsolid = true;
trace.startsolid = false;
trace.inopen = false;
trace.inwater = false;
trace.fraction = 1;
VectorCopy (box->extents, trace.extents);
For now, don't use box clipping for point traces. Until I figure out how I want to handle zero sized boxes, don't test them.
2011-11-20 03:02:56 +00:00
// FIXME specify tract type in test spec
trace.type = box == &point ? tr_point : tr_box;
Make MOD_TraceLine behave "correctly". MOD_TraceLine now behaves the same as id's SV_RecursiveHullCheck (from WinQuake). This means that even if the trace would escape from solid space into non-solid space, the trace is treated as allsolid if it crosses from one solid space to another before hitting the empty space. trace-id.c is used only for establishing the behaviour of id's code.
2010-12-06 06:30:56 +00:00
VectorCopy (end, trace.endpos);
MOD_TraceLine (hull, 0, start, end, &trace);
return trace;
}
Add code to rebuild the bsp brushes. Names and locations of declarations are still up in the air, but things seem to be working assuming my test code is correct.
2011-11-15 03:57:08 +00:00
typedef struct portlist_s {
struct portlist_s *next;
clipport_t *portal;
} portlist_t;
static portlist_t *
collect_portals (clipport_t *portal, portlist_t *portal_list)
{
portlist_t *p;
if (!portal)
return portal_list;
for (p = portal_list; p; p = p->next)
if (p->portal == portal)
return portal_list;
p = malloc (sizeof (portlist_t));
p->portal = portal;
p->next = portal_list;
portal_list = p;
portal_list = collect_portals (portal->next[0], portal_list);
portal_list = collect_portals (portal->next[1], portal_list);
return portal_list;
}
Make MOD_TraceLine behave "correctly". MOD_TraceLine now behaves the same as id's SV_RecursiveHullCheck (from WinQuake). This means that even if the trace would escape from solid space into non-solid space, the trace is treated as allsolid if it crosses from one solid space to another before hitting the empty space. trace-id.c is used only for establishing the behaviour of id's code.
2010-12-06 06:30:56 +00:00
static int
run_test (test_t *test)
{
const char *desc;
vec3_t end;
int res = 0;
char *expect;
char *got;
static int output = 0;
Add code to rebuild the bsp brushes. Names and locations of declarations are still up in the air, but things seem to be working assuming my test code is correct.
2011-11-15 03:57:08 +00:00
portlist_t *portal_list = 0;
if (!test->hull->nodeleafs) {
hull_t *hull = test->hull;
int i, j;
portlist_t *p;
clipport_t *portal;
clipleaf_t *leaf;
int side;
hull->nodeleafs = MOD_BuildBrushes (hull);
for (i = hull->firstclipnode; i <= hull->lastclipnode; i++) {
for (j = 0; j < 2; j++) {
if (((hull->clipnodes[i].children[j] >= 0)
!= (!hull->nodeleafs[i].leafs[j]))
|| (hull->nodeleafs[i].leafs[j]
&& (hull->nodeleafs[i].leafs[j]->contents
!= hull->clipnodes[i].children[j]))) {
printf ("bad nodeleaf %d %d\n", i, j);
res = 1;
}
}
if (hull->nodeleafs[i].leafs[0]
&& (hull->nodeleafs[i].leafs[0]
== hull->nodeleafs[i].leafs[1])) {
printf ("bad nodeleaf %d %d\n", i, j);
res = 1;
}
}
if (res)
goto nodeleaf_bail;
for (i = hull->firstclipnode; i <= hull->lastclipnode; i++) {
for (j = 0; j < 2; j++) {
leaf = hull->nodeleafs[i].leafs[j];
if (!leaf)
continue;
portal_list = collect_portals (leaf->portals, portal_list);
}
}
Create edge information for the portals.
2011-11-15 11:21:49 +00:00
for (i = 0, p = portal_list; p; i++, p = p->next) {
if (!p->portal->winding || !p->portal->edges) {
res = 1;
printf ("portal with missing vertex/edge information\n");
}
}
if (res)
goto nodeleaf_bail;
Add code to rebuild the bsp brushes. Names and locations of declarations are still up in the air, but things seem to be working assuming my test code is correct.
2011-11-15 03:57:08 +00:00
if (i != test->expect.num_portals) {
res = 1;
printf ("bad portal count: %d %d\n", test->expect.num_portals, i);
goto nodeleaf_bail;
}
for (p = portal_list; p; p = p->next) {
Clip the portals when running the test cases. When the portals are too big, floats break down and break the tests. This might not be much of an issue in real maps, but my tests use "infinite" planes.
2011-11-27 23:57:42 +00:00
for (j = 0; j < p->portal->winding->numpoints; j++) {
p->portal->winding->points[j][0]
= bound (-8192, p->portal->winding->points[j][0], 8192);
p->portal->winding->points[j][1]
= bound (-8192, p->portal->winding->points[j][1], 8192);
p->portal->winding->points[j][2]
= bound (-8192, p->portal->winding->points[j][2], 8192);
}
Add code to rebuild the bsp brushes. Names and locations of declarations are still up in the air, but things seem to be working assuming my test code is correct.
2011-11-15 03:57:08 +00:00
for (j = 0; j < 2; j++) {
int found = 0;
leaf = p->portal->leafs[j];
for (portal = leaf->portals; portal;
portal = portal->next[side]) {
//printf("%p %d %p %p %p\n", p, j, leaf, portal, p->portal);
side = portal->leafs[1] == leaf;
if (!side && portal->leafs[0] != leaf) {
printf ("mislinked portal\n");
res = 1;
}
if (portal == p->portal)
found = 1;
}
if (!found) {
printf ("portal unreachable from leaf\n");
res = 1;
}
}
}
}
nodeleaf_bail:
while (portal_list) {
portlist_t *t = portal_list;
portal_list = portal_list->next;
free (t);
}
Make MOD_TraceLine behave "correctly". MOD_TraceLine now behaves the same as id's SV_RecursiveHullCheck (from WinQuake). This means that even if the trace would escape from solid space into non-solid space, the trace is treated as allsolid if it crosses from one solid space to another before hitting the empty space. trace-id.c is used only for establishing the behaviour of id's code.
2010-12-06 06:30:56 +00:00
VectorSubtract (test->end, test->start, end);
VectorMultAdd (test->start, test->expect.frac, end, end);
expect = nva ("expect: (%g %g %g) -> (%g %g %g) => (%g %g %g)"
" %3g %d %d %d %d",
test->start[0], test->start[1], test->start[2],
test->end[0], test->end[1], test->end[2],
end[0], end[1], end[2],
test->expect.frac,
test->expect.allsolid, test->expect.startsolid,
test->expect.inopen, test->expect.inwater);
trace_t trace = do_trace (test->box, test->hull, test->start, test->end);
got = nva (" got: (%g %g %g) -> (%g %g %g) => (%g %g %g)"
" %3g %d %d %d %d",
test->start[0], test->start[1], test->start[2],
test->end[0], test->end[1], test->end[2],
trace.endpos[0], trace.endpos[1], trace.endpos[2],
trace.fraction,
trace.allsolid, trace.startsolid,
trace.inopen, trace.inwater);
if (VectorCompare (end, trace.endpos)
Be a little more lenient with float comparisons. Unfortunately, Pythagorus and binary don't play well together, so rounding errors are inevetible when testing with a slope. However, 1e-6 seems to be a good epsilon (printf's %g hides it nicely :).
2011-11-27 05:19:05 +00:00
&& FloatCompare (test->expect.frac, trace.fraction)
Make MOD_TraceLine behave "correctly". MOD_TraceLine now behaves the same as id's SV_RecursiveHullCheck (from WinQuake). This means that even if the trace would escape from solid space into non-solid space, the trace is treated as allsolid if it crosses from one solid space to another before hitting the empty space. trace-id.c is used only for establishing the behaviour of id's code.
2010-12-06 06:30:56 +00:00
&& test->expect.allsolid == trace.allsolid
&& test->expect.startsolid == trace.startsolid
&& test->expect.inopen == trace.inopen
&& test->expect.inwater == trace.inwater)
res = 1;
if (test->desc)
desc = va ("(%d) %s", (int)(long)(test - tests), test->desc);
else
desc = va ("test #%d", (int)(long)(test - tests));
if (verbose >= 0 || !res) {
if (output)
puts("");
output = 1;
puts (expect);
puts (got);
printf ("%s: %s\n", res ? "PASS" : "FAIL", desc);
}
free (expect);
free (got);
return res;
}
More file splitting for code reuse.
2011-12-03 12:13:01 +00:00
#include "main.c"
Reference in a new issue Copy permalink