Quake map collision: adding bevel planes, sweep trace for bounding boxes

Author: Interrupt

src/examples/quakemap.zig

@@ -22,8 +22,6 @@ var player_pos: math.Vec3 = math.Vec3.zero;
 var player_vel: math.Vec3 = math.Vec3.zero;
 var on_ground = true;
 
-var time: f64 = 0.0;
-
 pub fn main() !void {
     const example = delve.modules.Module{
         .name = "quakemap_example",
@@ -198,50 +196,65 @@ pub fn on_tick(delta: f32) void {
     if (delve.platform.input.isKeyJustPressed(.ESCAPE))
         std.os.exit(0);
 
-    time += delta;
+    do_player_move(delta);
 
+    // update camera position to new player pos
+    camera.position = player_pos;
     camera.runSimpleCamera(0, 60 * delta, true);
 }
 
 pub fn on_draw() void {
     const proj_view_matrix = camera.getProjView();
     var model = math.Mat4.identity;
 
+    for (0..map_meshes.items.len) |idx| {
+        map_meshes.items[idx].draw(proj_view_matrix, model);
+    }
+    for (0..entity_meshes.items.len) |idx| {
+        entity_meshes.items[idx].draw(proj_view_matrix, model);
+    }
+
+    cube_mesh.draw(proj_view_matrix, math.Mat4.translate(camera.position));
+}
+
+pub fn do_player_move(delta: f32) void {
     // gravity!
-    player_vel.y -= 0.01;
+    player_vel.y -= 0.5 * delta;
 
+    // get our forward input direction
+    var move_dir: math.Vec3 = math.Vec3.zero;
     if (delve.platform.input.isKeyPressed(.W)) {
         var dir = camera.direction;
         dir.y = 0.0;
         dir = dir.norm();
-
-        player_vel.x = -0.1 * dir.x;
-        player_vel.z = -0.1 * dir.z;
+        move_dir = move_dir.sub(dir);
     }
     if (delve.platform.input.isKeyPressed(.S)) {
         var dir = camera.direction;
         dir.y = 0.0;
         dir = dir.norm();
-
-        player_vel.x += 0.1 * dir.x;
-        player_vel.z += 0.1 * dir.z;
+        move_dir = move_dir.add(dir);
     }
 
+    // get our sideways input direction
     if (delve.platform.input.isKeyPressed(.D)) {
         const right_dir = camera.getRightDirection();
-        player_vel.x += 0.1 * right_dir.x;
-        player_vel.z += 0.1 * right_dir.z;
+        move_dir = move_dir.add(right_dir);
     }
     if (delve.platform.input.isKeyPressed(.A)) {
         const right_dir = camera.getRightDirection();
-        player_vel.x += -0.1 * right_dir.x;
-        player_vel.z += -0.1 * right_dir.z;
+        move_dir = move_dir.sub(right_dir);
     }
+
+    // jumnp and fly
     if (delve.platform.input.isKeyPressed(.SPACE) and on_ground) player_vel.y = 0.3;
     if (delve.platform.input.isKeyPressed(.F)) player_vel.y = 0.1;
 
-    var check_bounds_x = delve.spatial.BoundingBox.init(player_pos.add(math.Vec3.new(player_vel.x, 0, 0)), bounding_box_size);
+    move_dir = move_dir.norm();
+    player_vel = player_vel.add(move_dir.scale(10.0).scale(delta));
 
+    // horizontal collisions
+    var check_bounds_x = delve.spatial.BoundingBox.init(player_pos.add(math.Vec3.new(player_vel.x, 0, 0)), bounding_box_size);
     var did_collide_x = false;
     for (quake_map.worldspawn.solids.items) |solid| {
         did_collide_x = solid.checkBoundingBoxCollision(check_bounds_x);
@@ -251,8 +264,18 @@ pub fn on_draw() void {
     if (did_collide_x)
         player_vel.x = 0.0;
 
-    var check_bounds_y = delve.spatial.BoundingBox.init(player_pos.add(math.Vec3.new(0, player_vel.y, 0)), bounding_box_size);
+    var check_bounds_z = delve.spatial.BoundingBox.init(player_pos.add(math.Vec3.new(player_vel.x, 0, player_vel.z)), bounding_box_size);
+    var did_collide_z = false;
+    for (quake_map.worldspawn.solids.items) |solid| {
+        did_collide_z = solid.checkBoundingBoxCollision(check_bounds_z);
+        if (did_collide_z)
+            break;
+    }
+    if (did_collide_z)
+        player_vel.z = 0.0;
 
+    // vertical collision
+    var check_bounds_y = delve.spatial.BoundingBox.init(player_pos.add(math.Vec3.new(player_vel.x, player_vel.y, player_vel.z)), bounding_box_size);
     var did_collide_y = false;
     for (quake_map.worldspawn.solids.items) |solid| {
         did_collide_y = solid.checkBoundingBoxCollision(check_bounds_y);
@@ -266,36 +289,9 @@ pub fn on_draw() void {
         on_ground = false;
     }
 
-    var check_bounds_z = delve.spatial.BoundingBox.init(player_pos.add(math.Vec3.new(0, 0, player_vel.z)), bounding_box_size);
-
-    var did_collide_z = false;
-    for (quake_map.worldspawn.solids.items) |solid| {
-        did_collide_z = solid.checkBoundingBoxCollision(check_bounds_z);
-        if (did_collide_z)
-            break;
-    }
-    if (did_collide_z)
-        player_vel.z = 0.0;
-
+    // velocity has been clipped to collisions, can move now
     player_pos = player_pos.add(player_vel);
 
-    for (0..map_meshes.items.len) |idx| {
-        // if(did_collide) {
-        //     map_meshes.items[idx].drawWithMaterial(&fallback_material, proj_view_matrix, model);
-        // }
-        // else {
-
-        map_meshes.items[idx].draw(proj_view_matrix, model);
-    }
-    for (0..entity_meshes.items.len) |idx| {
-        entity_meshes.items[idx].draw(proj_view_matrix, model);
-    }
-
-    cube_mesh.draw(proj_view_matrix, math.Mat4.translate(camera.position));
-
-    // update camera position to new player pos
-    camera.position = player_pos;
-
     // dumb friction!
     player_vel.x = 0.0;
     player_vel.z = 0.0;

src/framework/utils/quakemap.zig

@@ -25,6 +25,11 @@ pub const ErrorInfo = struct {
     line_number: usize,
 };
 
+pub const QuakeMapHit = struct {
+    loc: Vec3,
+    plane: Plane,
+};
+
 pub const Property = struct {
     key: []const u8,
     value: []const u8,
@@ -97,6 +102,7 @@ pub const Entity = struct {
 
 pub const Solid = struct {
     faces: std.ArrayList(Face),
+    bounds: BoundingBox = undefined,
 
     fn init(allocator: Allocator) Solid {
         return .{ .faces = std.ArrayList(Face).init(allocator) };
@@ -110,6 +116,9 @@ pub const Solid = struct {
         defer vertices.deinit(allocator);
         defer clipped.deinit(allocator);
 
+        // build a bounding box along the way too
+        var solid_bounds: BoundingBox = undefined;
+
         for (self.faces.items, 0..) |*face, i| {
             const quad = makeQuadWithRadius(face.plane, 1000000.0);
             vertices.clearRetainingCapacity();
@@ -125,7 +134,20 @@ pub const Solid = struct {
             }
 
             face.vertices = try allocator.dupe(Vec3, vertices.items);
+
+            // create a bounding box out of these vertices
+            const face_bounds: BoundingBox = BoundingBox.initFromPositions(face.vertices);
+            if (i == 0) {
+                solid_bounds = face_bounds;
+                continue;
+            }
+
+            // expand our solid's bounding box by the new face bounds
+            solid_bounds.min = Vec3.min(solid_bounds.min, face_bounds.min);
+            solid_bounds.max = Vec3.max(solid_bounds.max, face_bounds.max);
         }
+
+        self.bounds = solid_bounds;
     }
 
     fn clip(allocator: Allocator, vertices: std.ArrayListUnmanaged(Vec3), clip_plane: Plane, clipped: *std.ArrayListUnmanaged(Vec3)) !void {
@@ -193,44 +215,128 @@ pub const Solid = struct {
         return true;
     }
 
-    pub fn checkBoundingBoxCollision(self: *const Solid, bounds: BoundingBox) bool {
-        const x_size = (bounds.max.x - bounds.min.x) * 0.5;
-        const y_size = (bounds.max.y - bounds.min.y) * 0.5;
-        const z_size = (bounds.max.z - bounds.min.z) * 0.5;
+    // Get our planes expanded by the Minkowski sum of the bounding box
+    pub fn getExpandedPlanes(self: *const Solid, size: math.Vec3) [24]?Plane {
+        var expanded_planes = [_]?Plane{null} ** 24;
+        var plane_count: usize = 0;
+
+        if (self.faces.items.len == 0)
+            return expanded_planes;
 
-        const point = bounds.center;
         for (self.faces.items) |*face| {
             var expand_dist: f32 = 0;
 
             // x_axis
-            const x_d = face.plane.normal.dot(Vec3.x_axis);
-            if (x_d > 0) expand_dist += -x_d * x_size;
+            const x_d = face.plane.normal.dot(math.Vec3.x_axis);
+            if (x_d > 0) expand_dist += -x_d * size.x;
 
-            const x_d_n = face.plane.normal.dot(Vec3.x_axis.scale(-1));
-            if (x_d_n > 0) expand_dist += -x_d_n * x_size;
+            const x_d_n = face.plane.normal.dot(math.Vec3.x_axis.scale(-1));
+            if (x_d_n > 0) expand_dist += -x_d_n * size.x;
 
             // y_axis
-            const y_d = face.plane.normal.dot(Vec3.y_axis);
-            if (y_d > 0) expand_dist += -y_d * y_size;
+            const y_d = face.plane.normal.dot(math.Vec3.y_axis);
+            if (y_d > 0) expand_dist += -y_d * size.y;
 
-            const y_d_n = face.plane.normal.dot(Vec3.y_axis.scale(-1));
-            if (y_d_n > 0) expand_dist += -y_d_n * y_size;
+            const y_d_n = face.plane.normal.dot(math.Vec3.y_axis.scale(-1));
+            if (y_d_n > 0) expand_dist += -y_d_n * size.y;
 
             // z_axis
-            const z_d = face.plane.normal.dot(Vec3.z_axis);
-            if (z_d > 0) expand_dist += -z_d * z_size;
+            const z_d = face.plane.normal.dot(math.Vec3.z_axis);
+            if (z_d > 0) expand_dist += -z_d * size.z;
 
-            const z_d_n = face.plane.normal.dot(Vec3.z_axis.scale(-1));
-            if (z_d_n > 0) expand_dist += -z_d_n * z_size;
+            const z_d_n = face.plane.normal.dot(math.Vec3.z_axis.scale(-1));
+            if (z_d_n > 0) expand_dist += -z_d_n * size.z;
 
             var expandedface = face.plane;
             expandedface.d += expand_dist;
 
-            if (expandedface.testPoint(point) == .FRONT)
-                return false;
+            expanded_planes[plane_count] = expandedface;
+            plane_count += 1;
         }
+
+        // Make the Minkowski sum of both bounding boxes
+        var solid_bounds = self.bounds;
+        solid_bounds.min.x -= size.x;
+        solid_bounds.min.y -= size.y;
+        solid_bounds.min.z -= size.z;
+
+        solid_bounds.max.x += size.x;
+        solid_bounds.max.y += size.y;
+        solid_bounds.max.z += size.z;
+
+        // Can use the sum as our bevel planes
+        const bevel_planes = solid_bounds.getPlanes();
+        for (bevel_planes) |p| {
+            expanded_planes[plane_count] = p;
+            plane_count += 1;
+        }
+
+        return expanded_planes;
+    }
+
+    pub fn checkBoundingBoxCollision(self: *const Solid, bounds: BoundingBox) bool {
+        const x_size = (bounds.max.x - bounds.min.x) * 0.5;
+        const y_size = (bounds.max.y - bounds.min.y) * 0.5;
+        const z_size = (bounds.max.z - bounds.min.z) * 0.5;
+        const point = bounds.center;
+
+        const expanded_planes = self.getExpandedPlanes(Vec3.new(x_size, y_size, z_size));
+        for (expanded_planes) |ep| {
+            if (ep) |p| {
+                if (p.testPoint(point) == .FRONT)
+                    return false;
+            }
+        }
+
         return true;
     }
+
+    pub fn checkBoundingBoxCollisionWithVelocity(self: *const Solid, bounds: BoundingBox, velocity: Vec3) ?QuakeMapHit {
+        var worldhit: ?QuakeMapHit = null;
+
+        const size = bounds.max.sub(bounds.min).scale(0.5);
+        const planes = getExpandedPlanes(self, size);
+
+        const point = bounds.center;
+        const next = point.add(velocity);
+
+        if (planes.len == 0)
+            return null;
+
+        for (0..planes.len) |idx| {
+            const ep = planes[idx];
+            if (ep) |p| {
+                if (p.testPoint(next) == .FRONT)
+                    return null;
+
+                const hit = p.intersectLine(point, next);
+                if (hit) |h| {
+                    var didhit = true;
+                    for (0..planes.len) |h_idx| {
+                        if (idx == h_idx)
+                            continue;
+
+                        // check that this hit point is behind the other clip planes
+                        if (planes[h_idx]) |pp| {
+                            if (pp.testPoint(h) == .FRONT) {
+                                didhit = false;
+                                break;
+                            }
+                        }
+                    }
+
+                    if (didhit) {
+                        worldhit = .{
+                            .loc = h,
+                            .plane = p,
+                        };
+                    }
+                }
+            }
+        }
+
+        return worldhit;
+    }
 };
 
 pub const QuakeMaterial = struct {