sergeypdev/gutter_runner
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Disable edge separation tests for now and make a stress test

Browse Source
This commit is contained in:
sergeypdev 2025-03-01 20:54:26 +04:00
parent 0f60cdda13
commit a1e8d0f231
5 changed files with 103 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
build_hot_reload.sh
View File

@ -35,7 +35,7 @@ esac
# Build the game. # Build the game.
echo "Building game$DLL_EXT" echo "Building game$DLL_EXT"
odin build game -extra-linker-flags:"$EXTRA_LINKER_FLAGS" -define:RAYLIB_SHARED=true -define:TRACY_ENABLE=true -collection:libs=./libs -collection:common=./common -collection:game=./game -build-mode:dll -out:game_tmp$DLL_EXT -strict-style -vet -debug odin build game -extra-linker-flags:"$EXTRA_LINKER_FLAGS" -define:RAYLIB_SHARED=true -define:TRACY_ENABLE=true -collection:libs=./libs -collection:common=./common -collection:game=./game -build-mode:dll -out:game_tmp$DLL_EXT -strict-style -vet -debug -o:speed
# Need to use a temp file on Linux because it first writes an empty `game.so`, which the game will load before it is actually fully written. # Need to use a temp file on Linux because it first writes an empty `game.so`, which the game will load before it is actually fully written.
mv game_tmp$DLL_EXT game$DLL_EXT mv game_tmp$DLL_EXT game$DLL_EXT

15
game/game.odin
View File

@ -260,12 +260,13 @@ update_runtime_world :: proc(runtime_world: ^Runtime_World, dt: f32) {
#hash("car", "fnv32a"), #hash("car", "fnv32a"),
physics.Body_Config { physics.Body_Config {
initial_pos = {0, 4, 0}, initial_pos = {0, 4, 0},
initial_rot = linalg.quaternion_angle_axis( initial_rot = linalg.QUATERNIONF32_IDENTITY,
math.RAD_PER_DEG * 180, // initial_rot = linalg.quaternion_angle_axis(
rl.Vector3{0, 0, 1}, // math.RAD_PER_DEG * 180,
) * // rl.Vector3{0, 0, 1},
linalg.quaternion_angle_axis(math.RAD_PER_DEG * 30, rl.Vector3{1, 0, 0}), // ) *
initial_ang_vel = {0, 0, 20}, // linalg.quaternion_angle_axis(math.RAD_PER_DEG * 30, rl.Vector3{1, 0, 0}),
initial_ang_vel = {0, 0, 0},
shape = physics.Shape_Convex { shape = physics.Shape_Convex {
mesh = car_convex.mesh, mesh = car_convex.mesh,
center_of_mass = car_convex.center_of_mass, center_of_mass = car_convex.center_of_mass,
@ -278,7 +279,7 @@ update_runtime_world :: proc(runtime_world: ^Runtime_World, dt: f32) {
if true { if true {
for x in 0 ..< 10 { for x in 0 ..< 10 {
for y in -3 ..< 10 { for y in -3 ..< 100 {
physics.immediate_body( physics.immediate_body(
&world.physics_scene, &world.physics_scene,
&runtime_world.solver_state, &runtime_world.solver_state,

182
game/physics/collision/convex.odin
View File

@ -180,121 +180,121 @@ query_separation_edges :: proc(
step := 0 step := 0
separating_plane_p: Vec3 if false {
success_step: int
Edge_Pair :: [2]halfedge.Edge_Index separating_plane_p: Vec3
checked_pairs := make_map_cap( success_step: int
map[Edge_Pair]bool,
len(a.edges) * len(b.edges),
context.temp_allocator,
)
for edge_a, edge_a_idx in a.edges { Edge_Pair :: [2]halfedge.Edge_Index
for edge_b, edge_b_idx in b.edges { checked_pairs := make_map_cap(
pair := Edge_Pair{halfedge.Edge_Index(edge_a_idx), halfedge.Edge_Index(edge_b_idx)} map[Edge_Pair]bool,
if checked_pairs[pair] { len(a.edges) * len(b.edges),
continue context.temp_allocator,
} )
tracy.ZoneN("collision.query_separation_edges::check_single_pair") for edge_a, edge_a_idx in a.edges {
for edge_b, edge_b_idx in b.edges {
pair := Edge_Pair{halfedge.Edge_Index(edge_a_idx), halfedge.Edge_Index(edge_b_idx)}
if checked_pairs[pair] {
continue
}
checked_pairs[pair] = true checked_pairs[pair] = true
if edge_a.twin >= 0 { if edge_a.twin >= 0 {
checked_pairs[{edge_a.twin, halfedge.Edge_Index(edge_b_idx)}] = true checked_pairs[{edge_a.twin, halfedge.Edge_Index(edge_b_idx)}] = true
} }
if edge_b.twin >= 0 { if edge_b.twin >= 0 {
checked_pairs[{halfedge.Edge_Index(edge_a_idx), edge_b.twin}] = true checked_pairs[{halfedge.Edge_Index(edge_a_idx), edge_b.twin}] = true
} }
if edge_a.twin >= 0 && edge_b.twin >= 0 { if edge_a.twin >= 0 && edge_b.twin >= 0 {
checked_pairs[{edge_a.twin, edge_b.twin}] = true checked_pairs[{edge_a.twin, edge_b.twin}] = true
} }
edge_a_dir := halfedge.get_edge_direction_normalized(a, edge_a) edge_a_dir := halfedge.get_edge_direction_normalized(a, edge_a)
edge_b_dir := halfedge.get_edge_direction_normalized(b, edge_b) edge_b_dir := halfedge.get_edge_direction_normalized(b, edge_b)
axis := lg.normalize0(lg.cross(edge_a_dir, edge_b_dir)) axis := lg.normalize0(lg.cross(edge_a_dir, edge_b_dir))
if axis == 0 { if axis == 0 {
continue continue
} }
edge_a_origin, _ := halfedge.get_edge_points(a, edge_a) edge_a_origin, _ := halfedge.get_edge_points(a, edge_a)
if lg.dot(axis, edge_a_origin - a.center) < 0 { if lg.dot(axis, edge_a_origin - a.center) < 0 {
axis = -axis axis = -axis
} }
plane_a := plane_from_point_normal(edge_a_origin, axis) plane_a := plane_from_point_normal(edge_a_origin, axis)
vert_a, _, _ := find_support_point(a, plane_a.normal) vert_a, _, _ := find_support_point(a, plane_a.normal)
vert_b, vert_b_idx, _ := find_support_point(b, -plane_a.normal) vert_b, vert_b_idx, _ := find_support_point(b, -plane_a.normal)
// We found the support vert on mesh b, but now we need to find the // We found the support vert on mesh b, but now we need to find the
// best edge that includes that point // best edge that includes that point
vert_b_edge: halfedge.Half_Edge vert_b_edge: halfedge.Half_Edge
vert_b_edge_idx: halfedge.Edge_Index = -1 vert_b_edge_idx: halfedge.Edge_Index = -1
{ {
min_b2_distance := max(f32) min_b2_distance := max(f32)
it := halfedge.iterator_vertex_edges(b, vert_b_idx) it := halfedge.iterator_vertex_edges(b, vert_b_idx)
for edge, edge_idx in halfedge.iterate_next_vertex_edge(&it) { for edge, edge_idx in halfedge.iterate_next_vertex_edge(&it) {
_, vert_b2 := halfedge.get_edge_points(b, edge) _, vert_b2 := halfedge.get_edge_points(b, edge)
distance_b2 := signed_distance_plane(vert_b2, plane_a) distance_b2 := signed_distance_plane(vert_b2, plane_a)
if distance_b2 < min_b2_distance { if distance_b2 < min_b2_distance {
min_b2_distance = distance_b2 min_b2_distance = distance_b2
vert_b_edge = edge vert_b_edge = edge
vert_b_edge_idx = edge_idx vert_b_edge_idx = edge_idx
}
}
if vert_b_edge_idx < 0 {
continue
} }
} }
if vert_b_edge_idx < 0 { distance_a := signed_distance_plane(vert_a.pos, plane_a)
if distance_a > 0 {
continue continue
} }
} distance_b := signed_distance_plane(vert_b.pos, plane_a)
vert_b_projected := vert_b.pos + plane_a.normal * -distance_b
distance_a := signed_distance_plane(vert_a.pos, plane_a) if step == -1 {
if distance_a > 0 { // a1, a2 := halfedge.get_edge_points(a, edge_a)
continue // edge_a_center := (a1 + a2) * 0.5
} a1, a2 := halfedge.get_edge_points(halfedge.Half_Edge_Mesh(a), edge_a)
distance_b := signed_distance_plane(vert_b.pos, plane_a) b1, b2 := halfedge.get_edge_points(halfedge.Half_Edge_Mesh(b), vert_b_edge)
vert_b_projected := vert_b.pos + plane_a.normal * -distance_b
if step == -1 { rl.DrawLine3D(edge_a_origin, edge_a_origin + plane_a.normal, rl.BLUE)
// a1, a2 := halfedge.get_edge_points(a, edge_a) rl.DrawLine3D(a1 + 0.1, a2 + 0.1, rl.ORANGE)
// edge_a_center := (a1 + a2) * 0.5 rl.DrawLine3D(b1 + 0.1, b2 + 0.1, rl.PURPLE)
a1, a2 := halfedge.get_edge_points(halfedge.Half_Edge_Mesh(a), edge_a)
b1, b2 := halfedge.get_edge_points(halfedge.Half_Edge_Mesh(b), vert_b_edge)
rl.DrawLine3D(edge_a_origin, edge_a_origin + plane_a.normal, rl.BLUE) rl.DrawSphereWires(edge_a_origin, 0.1, 4, 4, rl.ORANGE)
rl.DrawLine3D(a1 + 0.1, a2 + 0.1, rl.ORANGE) rl.DrawSphereWires(vert_b.pos, 0.05, 4, 4, rl.BLUE)
rl.DrawLine3D(b1 + 0.1, b2 + 0.1, rl.PURPLE) rl.DrawSphereWires(vert_b_projected, 0.05, 4, 4, rl.BLUE)
rl.DrawLine3D(vert_b.pos, vert_b_projected, rl.VIOLET)
log.debugf("dist: %v", distance_b)
rl.DrawSphereWires(edge_a_origin, 0.1, 4, 4, rl.ORANGE) {
rl.DrawSphereWires(vert_b.pos, 0.05, 4, 4, rl.BLUE) // rl.BeginBlendMode(.ALPHA)
rl.DrawSphereWires(vert_b_projected, 0.05, 4, 4, rl.BLUE) // defer rl.EndBlendMode()
rl.DrawLine3D(vert_b.pos, vert_b_projected, rl.VIOLET) debug_draw_plane(edge_a_origin, plane_a, rl.Color{0, 228, 48, 100})
log.debugf("dist: %v", distance_b) }
{
// rl.BeginBlendMode(.ALPHA)
// defer rl.EndBlendMode()
debug_draw_plane(edge_a_origin, plane_a, rl.Color{0, 228, 48, 100})
} }
}
if distance_b > separation { if distance_b > separation {
separation = distance_b separation = distance_b
a_edge = halfedge.Edge_Index(edge_a_idx) a_edge = halfedge.Edge_Index(edge_a_idx)
b_edge = vert_b_edge_idx b_edge = vert_b_edge_idx
separating_plane = plane_a separating_plane = plane_a
separating_plane_p = edge_a_origin separating_plane_p = edge_a_origin
success_step = step success_step = step
} }
step += 1 step += 1
}
} }
// log.debugf("step: %v", success_step)
// debug_draw_plane(separating_plane_p, separating_plane, rl.Color{228, 0, 48, 100})
} }
// log.debugf("step: %v", success_step)
// debug_draw_plane(separating_plane_p, separating_plane, rl.Color{228, 0, 48, 100})
return return
} }

2
game/physics/scene.odin
View File

@ -3,7 +3,7 @@ package physics
import "collision" import "collision"
import lg "core:math/linalg" import lg "core:math/linalg"
MAX_CONTACTS :: 1024 MAX_CONTACTS :: 1024 * 16
Vec3 :: [3]f32 Vec3 :: [3]f32
Quat :: quaternion128 Quat :: quaternion128

4
game/physics/simulation.odin
View File

@ -170,7 +170,7 @@ simulate :: proc(
} }
} }
bvh.debug_draw_bvh_bounds(&sim_state_bvh, body_aabbs, 0) // bvh.debug_draw_bvh_bounds(&sim_state_bvh, body_aabbs, 0)
switch step_mode { switch step_mode {
case .Accumulated_Time: case .Accumulated_Time:
@ -507,7 +507,7 @@ simulate_step :: proc(
prev_v_normal := lg.dot(prev_v, manifold.normal) prev_v_normal := lg.dot(prev_v, manifold.normal)
v_normal := lg.dot(v, manifold.normal) v_normal := lg.dot(v, manifold.normal)
RESTITUTION :: 0.3 RESTITUTION :: 1
restitution := f32(RESTITUTION) restitution := f32(RESTITUTION)