Compare commits

..

229 Commits

Author SHA1 Message Date
686bf5d712 print moooore 2023-11-30 18:56:21 -08:00
b2f781ac14 pip 2023-11-30 18:56:21 -08:00
1f636116c0 jkwenfjnwef 2023-11-30 18:56:21 -08:00
086b47c406 prin 2023-11-30 18:56:21 -08:00
aa0e03bc0c a 2023-11-30 18:56:21 -08:00
481a37e0f4 debug 2023-11-30 18:56:21 -08:00
cdfa4db1c9 crazy debug generic restrictions 2023-11-30 18:56:21 -08:00
136c77c65c debug 2023-11-30 18:56:21 -08:00
a7299c423f debug crap 2023-11-30 18:56:21 -08:00
abaf0b2939 debug 2023-11-30 18:56:21 -08:00
8e27c404a3 big platforms fail 2023-11-30 18:56:15 -08:00
62216c3c47 x11 mode has different sens 2023-11-30 18:56:15 -08:00
78b436741c more test 2023-11-30 18:56:15 -08:00
d8f57eb9fa use inverse_times_det 2023-11-30 17:19:56 -08:00
36a61b50a8 inverse_times_det 2023-11-30 17:17:03 -08:00
5793f9f975 swap parity (again) 2023-11-29 20:00:05 -08:00
9de6fe85fa test more things 2023-11-29 19:11:43 -08:00
ed6696be3e Aabb::size() + proper private fields for aabb 2023-11-29 19:11:23 -08:00
680cddc9a2 move collision loop avoidance to outside algorithm 2023-11-29 01:03:50 -08:00
6a7e05bb49 new tests to find failure cases 2023-11-28 22:54:56 -08:00
2558eac7fa TODO: don't do this! 2023-11-28 22:33:08 -08:00
ddb91031b0 getting ahead of myself trying to save a vert_edges call 2023-11-28 21:41:46 -08:00
6e8719136d move code around 2023-11-28 21:25:31 -08:00
7e7915293e ??? 2023-11-28 20:19:39 -08:00
78b94d7259 idk anymore 2023-11-28 20:16:24 -08:00
2152ae3c7b comment about winding 2023-11-28 19:52:46 -08:00
9d266e7be1 fix unit test expected times 2023-11-28 19:25:02 -08:00
49d799eb60 rename and swap faces 2023-11-28 19:19:42 -08:00
9af374ee14 finally fix face_edges MinkowskiFace::EdgeEdge case 2023-11-28 19:19:21 -08:00
26e4d8cab1 absurdly swap everything everywhere 2023-11-28 18:43:40 -08:00
38731c4a10 absurd test: swap left and right faces + parities 2023-11-28 18:35:41 -08:00
47560bb25f rename stupid things 2023-11-28 18:35:09 -08:00
1d50eac5e4 would you look at that, my old code was right! 2023-11-28 17:35:49 -08:00
660ea42576 fix vert_edges 2023-11-27 21:00:34 -08:00
a31c3bc848 update deps 2023-11-27 17:14:54 -08:00
2a3ca06376 comment 2023-11-26 18:59:18 -08:00
4932401553 v0.9.0 minkowski 2023-11-23 19:09:31 -08:00
f53327d87b wrong 2023-11-23 19:00:52 -08:00
b8a0ae6606 opti 2023-11-23 18:59:52 -08:00
3cc006d3fb normalize your normals broh 2023-11-23 18:46:09 -08:00
2cef4cba66 opti 2023-11-23 18:02:05 -08:00
14e168942d more tests 2023-11-23 18:01:48 -08:00
1a05449315 tweak unit tests 2023-11-23 17:23:12 -08:00
3d426c0859 TEMP: fail after 10 iterations 2023-11-23 17:12:49 -08:00
53adc651e5 change parity for funsies 2023-11-23 15:52:48 -08:00
d631747030 sneaky double doubling bug 2023-11-23 15:52:48 -08:00
d7042f9cba must switch to face if equal 2023-11-23 15:52:48 -08:00
66d799b3c3 infinity_fev edge case handling algorithm 2023-11-23 15:07:24 -08:00
dded820fc5 fewer multiplications 2023-11-23 00:13:38 -08:00
c971ab24e2 TEMP: disallow 0 time collisions 2023-11-22 19:27:23 -08:00
096284ea60 wrong 2023-11-22 19:26:52 -08:00
6766ad832d wrong 2023-11-22 17:52:12 -08:00
b23b815132 already_inside_hit_nothing test 2023-11-21 20:44:50 -08:00
7ba94c0837 zoom_hit_nothing test 2023-11-21 20:44:50 -08:00
6d3ff8490d expect a particular time of collision 2023-11-21 20:44:50 -08:00
e4eaecee2c parity depends on face only 2023-11-21 20:44:50 -08:00
de4a2dc652 reuse existing variables 2023-11-21 19:53:15 -08:00
e6c1b87b34 test degenerate case 2023-11-21 19:53:15 -08:00
7bae33ad06 handle_degenerate_cases 2023-11-21 19:53:15 -08:00
05adec5499 pull constant out of loop 2023-11-21 18:17:46 -08:00
5d85b39058 not planned 2023-11-21 17:35:00 -08:00
b964873785 pull constant out of loop 2023-11-21 17:33:24 -08:00
c1ae19b098 rename DirectedEdge::neg to reverse 2023-11-21 16:02:33 -08:00
0ad99958a0 wrong 2023-11-20 19:57:27 -08:00
d2f209869d a-b != b-a 2023-11-20 19:53:59 -08:00
f04e6ee4b7 test transform 2023-11-20 19:47:28 -08:00
9a2b033241 include edges with zero dot to support crawling flush minkowksi faces 2023-11-20 19:29:16 -08:00
e2777852d1 probably wrong 2023-11-20 19:28:44 -08:00
2eadb541cc DirectedEdge.neg() 2023-11-20 19:28:00 -08:00
c9f2ea0308 UndirectedEdge trait 2023-11-20 19:28:00 -08:00
f4db20c206 swap edge faces in VertEdge case 2023-11-20 19:28:00 -08:00
72d8186ba4 MinkowskiMesh::edge_faces sorting against incorrect value 2023-11-20 19:28:00 -08:00
da6b800d4e include apexes 2023-11-20 18:55:42 -08:00
4154a8c437 are vert edges backwards? 2023-11-20 18:55:42 -08:00
13dd90d5f6 opti 2023-11-20 18:55:42 -08:00
a5437c87df wrong 2023-11-20 18:55:42 -08:00
a4ea566c02 unused impl for private type 2023-11-17 18:41:30 -08:00
a6f9f144f4 preopti 2023-11-17 18:41:30 -08:00
e33adeadc8 thinking 2023-11-17 18:41:30 -08:00
563ade11f7 rewrite infinity crawl to use a straight line
for predict_collision_out use an extrapolated body that will exist outside of the mesh in the hit case we care about
2023-11-17 18:41:30 -08:00
1a250fe8d6 style 2023-11-17 16:23:54 -08:00
4be218defb wrong 2023-11-17 16:23:54 -08:00
dc5649f2b5 wrong 2023-11-17 16:23:54 -08:00
ef817389f3 hit_the_ground unit test 2023-11-17 16:23:54 -08:00
399c9505bf reduce test spam 2023-11-17 14:12:11 -08:00
e6c955a958 combine crawl into one loop 2023-11-17 13:48:29 -08:00
8839b8fbb3 fix not moving 2023-11-16 19:57:50 -08:00
d191538aa8 fix time inversion 2023-11-16 19:18:07 -08:00
46c6271286 compiler nits 2023-11-16 18:46:10 -08:00
bb2a5e2d35 workaround stupid monolith 2023-11-16 18:46:10 -08:00
4998f3803a fix lifetimes 2023-11-16 18:46:10 -08:00
fa0be33bf5 initialize variable + guarantees 2023-11-16 18:46:10 -08:00
0da6da24ac implement final algorithm with infinity tech 2023-11-16 18:27:05 -08:00
6a926608b7 fix normal dir 2023-11-16 18:26:56 -08:00
71d221581f DirectedEdge trait (huge) 2023-11-16 17:03:15 -08:00
6fcc6b2303 water goes here 2023-11-15 22:56:16 -08:00
312b0223b6 inline them bad boys 2023-11-15 22:56:16 -08:00
5a3013365e use style mesh + remove double reference in set_velocity & set_acceleration 2023-11-15 22:52:52 -08:00
5c2aad268f style.hitbox 2023-11-15 22:52:51 -08:00
ea9c2efc7f implement Planar64Mat3::from_diagonal 2023-11-15 22:45:49 -08:00
a41cbb79de move mat mul to above mat div 2023-11-15 22:24:56 -08:00
2370fbea54 todo 2023-11-15 21:21:00 -08:00
33972b0c2c physics work 2023-11-15 21:10:50 -08:00
f50670db57 use function that doesn't exist for MinkowskiMesh::closest_fev 2023-11-15 21:10:50 -08:00
559a38b607 implement MinkowskiMesh::farthest_vert 2023-11-15 21:10:50 -08:00
751ccf57ca comment 2023-11-15 21:10:50 -08:00
5bfd340d87 implement MinkowskiMesh::predict_collision{_end} 2023-11-15 21:10:50 -08:00
2d3efdc2e1 comments about potential parallel cases 2023-11-15 21:10:50 -08:00
d217966f77 unused use 2023-11-15 21:10:50 -08:00
328c38ca38 change the MeshQuery trait and delete the code I just wrote 2023-11-15 21:10:50 -08:00
4c05c01b6e fix big wrong 2023-11-15 19:48:13 -08:00
b20f573f1d missing semicolons 2023-11-15 19:45:38 -08:00
21e29aa63e implement MinkowskiMesh::face_edges MinkowskiFace::EdgeEdge case 2023-11-15 18:00:14 -08:00
48870b8a76 implement MinkowskiMesh::edge_faces 2023-11-15 17:59:47 -08:00
020c704968 fix edge faces ordering 2023-11-15 17:59:24 -08:00
8f63699d45 consistent ordering 2023-11-15 16:05:42 -08:00
6071e23be1 style 2023-11-11 21:32:59 -08:00
46d6c31957 avoid double rocket boost 2023-11-11 21:27:20 -08:00
5b26304e95 project walk 2023-11-10 19:13:41 -08:00
d3cf75e0d5 fix ladder crashes 2023-11-10 19:13:41 -08:00
2acf740898 MinkowskiMesh::edge_faces is wrong 2023-11-10 19:13:41 -08:00
816f786763 implement MinkowskiMesh::face_nd for MinkowskiFace::EdgeEdge case 2023-11-10 19:13:41 -08:00
f7c613dfa6 correct MinkowskiMesh::face_edges FaceVert + VertFace cases 2023-11-10 19:13:41 -08:00
4fc09806f6 minkowski vert_edges 2023-11-10 19:13:41 -08:00
3cbefbab03 introduce DirectedEdge 2023-11-10 19:13:41 -08:00
717cf2290d vert_faces 2023-11-10 19:13:41 -08:00
756648c2fb probably need a better fix for this 2023-11-10 19:13:41 -08:00
44540853dd use alternate quadratic equation in poor accuracy cases 2023-11-10 19:13:41 -08:00
43e62e8f1d implement dot128 for face_nd 2023-11-10 19:13:41 -08:00
4af4dc669b update move state if acceleration culls surface 2023-11-10 19:13:41 -08:00
24f6472e9f acceleration was not being refreshed in air move (the bug) 2023-11-10 19:13:41 -08:00
cff920ddcd tweak elasticity calc 2023-11-10 19:13:41 -08:00
053514fa4a exit strafe tick early if zero control dir 2023-11-10 19:13:41 -08:00
27a46093ae introduce dot128 2023-11-10 19:13:41 -08:00
6049aba716 do not overshadow variable 2023-11-10 19:13:41 -08:00
b7998c7bd4 break walking 2023-11-10 19:13:41 -08:00
63cfbbfa9c fix ladders 2023-11-10 19:13:41 -08:00
f7072be5b4 separate culling type setters 2023-11-10 19:13:41 -08:00
4456ee29ec surf test was wrong 2023-11-10 19:13:41 -08:00
2d14e8ac8e cross product was wrong 💀x7 2023-11-10 19:13:41 -08:00
176aaa069c fix walk friction 2023-11-10 19:13:41 -08:00
a6dfa1d72b elasticity calc 2023-11-10 19:13:41 -08:00
516510faa8 add set body functions + jump query functions 2023-11-10 19:13:41 -08:00
1d2de93b9e normalize normal 2023-11-10 19:13:41 -08:00
2988175436 important 2023-11-10 19:13:41 -08:00
03b21aa27f work 2023-11-10 19:13:41 -08:00
910d520c2b wip TouchingState::get_move_state 2023-11-10 19:13:41 -08:00
c321814b9b normal_determinant is not real 2023-11-10 19:13:41 -08:00
ce1e9df334 TouchingState::base_acceleration 2023-11-10 19:13:41 -08:00
e6e7366e66 fix idiot 2023-11-10 19:13:41 -08:00
535ae1a5f0 fix constrain 2023-11-10 19:13:41 -08:00
432a38718c fix slope divide by zero 2023-11-10 19:13:41 -08:00
9aa7656278 mesh gen test 2023-11-10 19:13:41 -08:00
823a16e08d fix determinant 2023-11-10 19:13:41 -08:00
82d84ee07c fix mesh gen algorithm 2023-11-10 19:13:41 -08:00
ffc19020b9 unused var 2023-11-10 19:13:41 -08:00
e0581390bd fix transformed face_nd 2023-11-10 19:13:41 -08:00
4b4ac0de19 test stop taking so long 2023-11-10 19:13:41 -08:00
d94ad475eb debug message 2023-11-10 19:13:41 -08:00
60eadd3156 ref faster no copy 2023-11-10 19:13:41 -08:00
ebca761dbc whoops 2023-11-10 19:13:41 -08:00
ab60fb2cf7 idiot 2023-11-10 19:13:41 -08:00
ec9b720138 make build 2023-11-10 19:13:41 -08:00
7ad0270d2f TransformedMesh::new to avoid pub 2023-11-10 19:13:41 -08:00
d8e605d203 fix compiler nits 2023-11-10 19:13:41 -08:00
dc46cb3d45 delete unused aabb face code 2023-11-10 19:13:41 -08:00
a53d90f74b tape up last stragglers 2023-11-10 19:13:41 -08:00
d9be4b8105 checkpoints don't actually exist 2023-11-10 19:13:41 -08:00
58c35ce364 water 2023-11-10 19:13:41 -08:00
2a033b87e0 rethink ordered checkpoints - do not support non-teleporting (backtracking) 2023-11-10 19:13:41 -08:00
d374a3d4c6 SpawnAt comment 2023-11-10 19:13:41 -08:00
c37b990389 tweak water 2023-11-10 19:13:41 -08:00
7311b1ae88 checkpoints are stage elements 2023-11-10 19:13:41 -08:00
af7fcdd5cb add GameMechanicAttributes::is_wrcp() function 2023-11-10 19:13:41 -08:00
bf51afcf1d fix normal code 2023-11-10 19:13:41 -08:00
fd9ca6cd3f Planar64Vec3::{inverse,transpose,determinant} 2023-11-10 19:13:41 -08:00
d71f143d68 point hitbox work 2023-11-10 19:13:41 -08:00
769f88eb9f real functions 2023-11-10 19:13:41 -08:00
cf9063bffc PhysicsModels idea 2023-11-10 19:13:41 -08:00
fc3d72393f rename enum 2023-11-10 19:13:41 -08:00
a5ef0195e2 tweak minkowski code + fix edge_verts 2023-11-10 19:13:41 -08:00
6fec6b9f59 cling thing 2023-11-10 19:13:41 -08:00
895f9b82f8 tabs 2023-11-10 19:13:41 -08:00
6aa0e790d8 brute force t for plain mesh 2023-11-10 19:13:41 -08:00
b897d4a662 I need to rethink Collision vs Attributes 2023-11-10 19:13:41 -08:00
49931a40fc make aabb_list with silly iterator to avoid pub-ing Vert 2023-11-10 19:13:41 -08:00
e92eaed2d3 work on indexing meshes and attributes 2023-11-10 19:13:41 -08:00
1ec9412b49 closest_fev for TransformedMesh 2023-11-10 19:13:41 -08:00
d9966a4eb0 write mesh closest_fev 2023-11-10 19:13:41 -08:00
cee6835af6 decide 2023-11-10 19:13:41 -08:00
f1e0514ecb cross product!!!! 2023-11-10 19:13:41 -08:00
86d45252c7 use edge_n instead of ambiguous face 2023-11-10 19:13:41 -08:00
9f948744d4 add edge_n to MeshQuery 2023-11-10 19:13:41 -08:00
5e28c02640 TODOs 2023-11-10 19:13:41 -08:00
5f1b93d9c4 next_instruction face crawler implementation 2023-11-10 19:13:41 -08:00
d63a76269f ignore face 2023-11-10 19:13:41 -08:00
354b96d98f collector.time() 2023-11-10 19:13:41 -08:00
d155517587 delete aabb physics 2023-11-10 19:13:41 -08:00
3c443b6b6a mesh generation 2023-11-10 19:13:41 -08:00
f73b4a0c52 Planar64Vec3::new 2023-11-10 19:13:41 -08:00
c37194daf6 AddAssign for Planar64 2023-11-10 19:13:41 -08:00
5317a0fafe rename VirtualMesh to TransformedMesh 2023-11-10 19:13:41 -08:00
941faf199d vert and edge does not have an unambiguous face 2023-11-10 19:13:41 -08:00
053bab9e24 wip: physics work 2023-11-10 19:13:41 -08:00
89f7a2b9b9 wip: start brute force closest_fev 2023-11-10 19:13:41 -08:00
dff2648cd3 add Planar64::MAX 2023-11-10 19:13:41 -08:00
d2d5a62458 implement vert 2023-11-10 19:13:41 -08:00
89ea7f45f9 wip 2023-11-10 19:13:41 -08:00
01d74102e3 MinkowskiMesh::edge_verts 2023-11-10 19:13:41 -08:00
ee4e6dbbaf MinkowskiMesh::edge_faces 2023-11-10 19:13:41 -08:00
19d4fed2a2 MinkowskiMesh::face_edges 2023-11-10 19:13:41 -08:00
a9f6cc7c29 rename functions 2023-11-10 19:13:41 -08:00
64657e718d cow: utter brilliance 2023-11-10 19:13:41 -08:00
3d5ac0cd61 Minkowski face_nd 2023-11-10 19:13:41 -08:00
72ebe5c9c8 generic generic generic 2023-11-10 19:13:41 -08:00
e1fde9b507 there is another 2023-11-10 19:13:41 -08:00
0cb6236035 todo 2023-11-10 19:13:41 -08:00
a8b1ced5cd implement face crawler algorithm using functions that don't exist 2023-11-10 19:13:41 -08:00
bb46801610 functions 2023-11-10 19:13:41 -08:00
06eeac6043 data structures 2023-11-10 19:13:41 -08:00
558febabc3 face_normal 2023-11-10 19:13:41 -08:00
1b51e21ecd implement PhysicsMesh 2023-11-10 19:13:41 -08:00
7ce08b0bbe move stuff to model_physics 2023-11-10 19:13:41 -08:00
19c7a8924e face crawler work 2023-11-10 19:13:41 -08:00
b215578c8d virtual body 2023-11-10 19:13:41 -08:00
2bea7e210e pub body 2023-11-10 19:13:41 -08:00
f8a8cbf12a replace Body::with_pva with Body::new 2023-11-10 19:13:41 -08:00
9f76611c18 algorithm 2023-11-10 19:13:41 -08:00
4da3d78057 Face Crawler™ 2023-11-10 19:13:41 -08:00
14 changed files with 351 additions and 729 deletions

519
Cargo.lock generated

File diff suppressed because it is too large Load Diff

@ -18,8 +18,6 @@ rbx_binary = "0.7.1"
rbx_dom_weak = "2.5.0"
rbx_reflection_database = "0.2.7"
rbx_xml = "0.13.1"
vbsp = "0.5.0"
vmdl = "0.1.1"
wgpu = "0.18.0"
winit = { version = "0.29.2", features = ["rwh_05"] }

@ -72,9 +72,9 @@ fn generate_bvh_node(boxen:Vec<(usize,Aabb)>)->BvhNode{
sort_y.push((*i,center.y()));
sort_z.push((*i,center.z()));
}
sort_x.sort_by(|tup0,tup1|tup0.1.cmp(&tup1.1));
sort_y.sort_by(|tup0,tup1|tup0.1.cmp(&tup1.1));
sort_z.sort_by(|tup0,tup1|tup0.1.cmp(&tup1.1));
sort_x.sort_by(|tup0,tup1|tup0.1.partial_cmp(&tup1.1).unwrap());
sort_y.sort_by(|tup0,tup1|tup0.1.partial_cmp(&tup1.1).unwrap());
sort_z.sort_by(|tup0,tup1|tup0.1.partial_cmp(&tup1.1).unwrap());
let h=n/2;
let median_x=sort_x[h].1;
let median_y=sort_y[h].1;

@ -3,13 +3,16 @@ use crate::model_physics::{FEV,MeshQuery,DirectedEdge};
use crate::integer::{Time,Planar64};
use crate::zeroes::zeroes2;
enum Transition<F,E:DirectedEdge,V>{
#[derive(Debug)]
enum Transition<F,E:DirectedEdge,V>
where <E as DirectedEdge>::UndirectedEdge:std::fmt::Debug{
Miss,
Next(FEV<F,E,V>,Time),
Hit(F,Time),
}
fn next_transition<F:Copy,E:Copy+DirectedEdge,V:Copy>(fev:&FEV<F,E,V>,time:Time,mesh:&impl MeshQuery<F,E,V>,body:&Body,time_limit:Time)->Transition<F,E,V>{
fn next_transition<F:Copy+std::fmt::Debug,E:Copy+DirectedEdge+std::fmt::Debug,V:Copy+std::fmt::Debug>(fev:&FEV<F,E,V>,time:Time,mesh:&impl MeshQuery<F,E,V>,body:&Body,time_limit:Time)->Transition<F,E,V>
where <E as DirectedEdge>::UndirectedEdge:std::fmt::Debug{
//conflicting derivative means it crosses in the wrong direction.
//if the transition time is equal to an already tested transition, do not replace the current best.
let mut best_time=time_limit;
@ -20,10 +23,10 @@ enum Transition<F,E:DirectedEdge,V>{
//n=face.normal d=face.dot
//n.a t^2+n.v t+n.p-d==0
let (n,d)=mesh.face_nd(face_id);
//TODO: use higher precision d value?
//use the mesh transform translation instead of baking it into the d value.
println!("Face n={} d={}",n,d);
for t in zeroes2((n.dot(body.position)-d)*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
let t=body.time+Time::from(t);
println!("dt={} low={} upp={} into={}",t-body.time,time<=t,t<best_time,n.dot(body.extrapolated_velocity(t))<Planar64::ZERO);
if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
best_time=t;
best_transtition=Transition::Hit(face_id,t);
@ -35,9 +38,12 @@ enum Transition<F,E:DirectedEdge,V>{
let edge_n=mesh.directed_edge_n(directed_edge_id);
let n=n.cross(edge_n);
let verts=mesh.edge_verts(directed_edge_id.as_undirected());
let d=n.dot(mesh.vert(verts[0])+mesh.vert(verts[1]));
println!("Face Edge boundary_n={} boundary_d={}",n,d/2);
//WARNING: d is moved out of the *2 block because of adding two vertices!
for t in zeroes2(n.dot(body.position*2-(mesh.vert(verts[0])+mesh.vert(verts[1]))),n.dot(body.velocity)*2,n.dot(body.acceleration)){
for t in zeroes2(n.dot(body.position)*2-d,n.dot(body.velocity)*2,n.dot(body.acceleration)){
let t=body.time+Time::from(t);
println!("dt={} low={} upp={} into={}",t-body.time,time<=t,t<best_time,n.dot(body.extrapolated_velocity(t))<Planar64::ZERO);
if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
best_time=t;
best_transtition=Transition::Next(FEV::<F,E,V>::Edge(directed_edge_id.as_undirected()),t);
@ -51,14 +57,17 @@ enum Transition<F,E:DirectedEdge,V>{
//test each face collision time, ignoring roots with zero or conflicting derivative
let edge_n=mesh.edge_n(edge_id);
let edge_verts=mesh.edge_verts(edge_id);
let delta_pos=body.position*2-(mesh.vert(edge_verts[0])+mesh.vert(edge_verts[1]));
let vert_sum=mesh.vert(edge_verts[0])+mesh.vert(edge_verts[1]);
for (i,&edge_face_id) in mesh.edge_faces(edge_id).iter().enumerate(){
let face_n=mesh.face_nd(edge_face_id).0;
//edge_n gets parity from the order of edge_faces
let n=face_n.cross(edge_n)*((i as i64)*2-1);
let d=n.dot(vert_sum);
println!("Edge Face={:?} boundary_n={} boundary_d={}",edge_face_id,n,d/2);
//WARNING yada yada d *2
for t in zeroes2(n.dot(delta_pos),n.dot(body.velocity)*2,n.dot(body.acceleration)){
for t in zeroes2((n.dot(body.position))*2-d,n.dot(body.velocity)*2,n.dot(body.acceleration)){
let t=body.time+Time::from(t);
println!("dt={} low={} upp={} into={}",t-body.time,time<=t,t<best_time,n.dot(body.extrapolated_velocity(t))<Planar64::ZERO);
if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
best_time=t;
best_transtition=Transition::Next(FEV::<F,E,V>::Face(edge_face_id),t);
@ -70,8 +79,11 @@ enum Transition<F,E:DirectedEdge,V>{
for (i,&vert_id) in edge_verts.iter().enumerate(){
//vertex normal gets parity from vert index
let n=edge_n*(1-2*(i as i64));
for t in zeroes2((n.dot(body.position-mesh.vert(vert_id)))*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
let d=n.dot(mesh.vert(vert_id));
println!("Edge Vert boundary_n={} boundary_d={}",n,d);
for t in zeroes2((n.dot(body.position)-d)*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
let t=body.time+Time::from(t);
println!("dt={} low={} upp={} into={}",t-body.time,time<=t,t<best_time,n.dot(body.extrapolated_velocity(t))<Planar64::ZERO);
if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
best_time=t;
best_transtition=Transition::Next(FEV::<F,E,V>::Vert(vert_id),t);
@ -86,8 +98,11 @@ enum Transition<F,E:DirectedEdge,V>{
for &directed_edge_id in mesh.vert_edges(vert_id).iter(){
//edge is directed away from vertex, but we want the dot product to turn out negative
let n=-mesh.directed_edge_n(directed_edge_id);
for t in zeroes2((n.dot(body.position-mesh.vert(vert_id)))*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
let d=n.dot(mesh.vert(vert_id));
println!("Vert Edge={:?} boundary_n={} boundary_d={}",directed_edge_id,n,d);
for t in zeroes2((n.dot(body.position)-d)*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
let t=body.time+Time::from(t);
println!("dt={} low={} upp={} into={}",t-body.time,time<=t,t<best_time,n.dot(body.extrapolated_velocity(t))<Planar64::ZERO);
if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
best_time=t;
best_transtition=Transition::Next(FEV::<F,E,V>::Edge(directed_edge_id.as_undirected()),t);
@ -104,9 +119,19 @@ pub enum CrawlResult<F,E:DirectedEdge,V>{
Miss(FEV<F,E,V>),
Hit(F,Time),
}
pub fn crawl_fev<F:Copy,E:Copy+DirectedEdge,V:Copy>(mut fev:FEV<F,E,V>,mesh:&impl MeshQuery<F,E,V>,relative_body:&Body,start_time:Time,time_limit:Time)->CrawlResult<F,E,V>{
pub fn crawl_fev<F:Copy+std::fmt::Debug,E:Copy+std::fmt::Debug+DirectedEdge,V:Copy+std::fmt::Debug>(mut fev:FEV<F,E,V>,mesh:&impl MeshQuery<F,E,V>,relative_body:&Body,start_time:Time,time_limit:Time)->CrawlResult<F,E,V>
where <E as DirectedEdge>::UndirectedEdge:std::fmt::Debug{
let mut time=start_time;
for _ in 0..20{
println!("@ fev={:?} time={}",fev,time);
match &fev{
&FEV::Face(face_id)=>{
let a=mesh.face_nd(face_id);
println!("face_n={}",a.0);
},
&FEV::Edge(edge_id)=>println!("edge_n={} verts={:?}",mesh.edge_n(edge_id),mesh.edge_verts(edge_id)),
&FEV::Vert(vert_id)=>println!("vert={}",mesh.vert(vert_id)),
}
match next_transition(&fev,time,mesh,relative_body,time_limit){
Transition::Miss=>return CrawlResult::Miss(fev),
Transition::Next(next_fev,next_time)=>(fev,time)=(next_fev,next_time),

@ -152,14 +152,11 @@ impl GraphicsState{
let mut texture_loading_threads=Vec::new();
let num_textures=indexed_models.textures.len();
for (i,texture_id) in indexed_models.textures.into_iter().enumerate(){
let path=std::path::PathBuf::from(format!("textures/{}.dds",texture_id));
if let Ok(mut file) = std::fs::File::open(path.clone()){
if let Ok(mut file) = std::fs::File::open(std::path::Path::new(&format!("textures/{}.dds",texture_id))){
double_map.insert(i as u32, texture_loading_threads.len() as u32);
texture_loading_threads.push((texture_id,std::thread::spawn(move ||{
ddsfile::Dds::read(&mut file).unwrap()
})));
}else{
//println!("missing texture path={:?}",path);
}
}

@ -105,23 +105,23 @@ impl Ratio64{
None
}else{
let d=gcd(num.unsigned_abs(),den);
Some(Self{num:num/(d as i64),den:den/d})
Some(Self{num:num/d as i64,den:den/d})
}
}
#[inline]
pub fn mul_int(&self,rhs:i64)->i64{
rhs*self.num/(self.den as i64)
rhs*self.num/self.den as i64
}
#[inline]
pub fn rhs_div_int(&self,rhs:i64)->i64{
rhs*(self.den as i64)/self.num
rhs*self.den as i64/self.num
}
#[inline]
pub fn mul_ref(&self,rhs:&Ratio64)->Ratio64{
let (num,den)=(self.num*rhs.num,self.den*rhs.den);
let d=gcd(num.unsigned_abs(),den);
Self{
num:num/(d as i64),
num:num/d as i64,
den:den/d,
}
}
@ -209,8 +209,8 @@ impl TryFrom<f32> for Ratio64{
std::num::FpCategory::Nan=>Err(Self::Error::Nan),
std::num::FpCategory::Infinite=>Err(Self::Error::Infinite),
std::num::FpCategory::Zero=>Ok(Self::ZERO),
std::num::FpCategory::Subnormal
|std::num::FpCategory::Normal=>ratio64_from_mes(integer_decode_f32(value)),
std::num::FpCategory::Subnormal=>Err(Self::Error::Subnormal),
std::num::FpCategory::Normal=>ratio64_from_mes(integer_decode_f32(value)),
}
}
}
@ -222,8 +222,8 @@ impl TryFrom<f64> for Ratio64{
std::num::FpCategory::Nan=>Err(Self::Error::Nan),
std::num::FpCategory::Infinite=>Err(Self::Error::Infinite),
std::num::FpCategory::Zero=>Ok(Self::ZERO),
std::num::FpCategory::Subnormal
|std::num::FpCategory::Normal=>ratio64_from_mes(integer_decode_f64(value)),
std::num::FpCategory::Subnormal=>Err(Self::Error::Subnormal),
std::num::FpCategory::Normal=>ratio64_from_mes(integer_decode_f64(value)),
}
}
}
@ -234,7 +234,7 @@ impl std::ops::Mul<Ratio64> for Ratio64{
let (num,den)=(self.num*rhs.num,self.den*rhs.den);
let d=gcd(num.unsigned_abs(),den);
Self{
num:num/(d as i64),
num:num/d as i64,
den:den/d,
}
}
@ -411,7 +411,7 @@ impl TryFrom<[f32;3]> for Unit32Vec3{
*/
///[-1.0,1.0] = [-2^32,2^32]
#[derive(Clone,Copy,Hash,Eq,Ord,PartialEq,PartialOrd)]
#[derive(Clone,Copy,Debug,Hash,Eq,Ord,PartialEq,PartialOrd)]
pub struct Planar64(i64);
impl Planar64{
pub const ZERO:Self=Self(0);
@ -451,7 +451,7 @@ impl Into<f32> for Planar64{
impl From<Ratio64> for Planar64{
#[inline]
fn from(ratio:Ratio64)->Self{
Self((((ratio.num as i128)<<32)/(ratio.den as i128)) as i64)
Self((((ratio.num as i128)<<32)/ratio.den as i128) as i64)
}
}
#[derive(Debug)]
@ -459,8 +459,26 @@ pub enum Planar64TryFromFloatError{
Nan,
Infinite,
Subnormal,
HighlyNegativeExponent,
HighlyPositiveExponent,
HighlyNegativeExponent(i16),
HighlyPositiveExponent(i16),
}
#[inline]
fn planar64_from_mes((m,e,s):(u64,i16,i8))->Result<Planar64,Planar64TryFromFloatError>{
let e32=e+32;
if e32<0&&(m>>-e32)==0{//shifting m will underflow to 0
Ok(Planar64::ZERO)
// println!("m{} e{} s{}",m,e,s);
// println!("f={}",(m as f64)*(2.0f64.powf(e as f64))*(s as f64));
// Err(Planar64TryFromFloatError::HighlyNegativeExponent(e))
}else if (64-m.leading_zeros() as i16)+e32<64{//shifting m will not overflow
if e32<0{
Ok(Planar64((m as i64)*(s as i64)>>-e32))
}else{
Ok(Planar64((m as i64)*(s as i64)<<e32))
}
}else{//if shifting m will overflow (prev check failed)
Err(Planar64TryFromFloatError::HighlyPositiveExponent(e))
}
}
impl TryFrom<f32> for Planar64{
type Error=Planar64TryFromFloatError;
@ -470,15 +488,8 @@ impl TryFrom<f32> for Planar64{
std::num::FpCategory::Nan=>Err(Self::Error::Nan),
std::num::FpCategory::Infinite=>Err(Self::Error::Infinite),
std::num::FpCategory::Zero=>Ok(Self::ZERO),
std::num::FpCategory::Subnormal
|std::num::FpCategory::Normal=>{
let planar=value*PLANAR64_ONE_FLOAT32;
if planar<(i64::MIN as f32)||(i64::MAX as f32)<planar{
Err(Self::Error::HighlyPositiveExponent)
}else{
Ok(Planar64(unsafe{planar.to_int_unchecked()}))
}
}
std::num::FpCategory::Subnormal=>Err(Self::Error::Subnormal),
std::num::FpCategory::Normal=>planar64_from_mes(integer_decode_f32(value)),
}
}
}
@ -490,15 +501,8 @@ impl TryFrom<f64> for Planar64{
std::num::FpCategory::Nan=>Err(Self::Error::Nan),
std::num::FpCategory::Infinite=>Err(Self::Error::Infinite),
std::num::FpCategory::Zero=>Ok(Self::ZERO),
std::num::FpCategory::Subnormal
|std::num::FpCategory::Normal=>{
let planar=value*PLANAR64_ONE_FLOAT64;
if planar<(i64::MIN as f64)||(i64::MAX as f64)<planar{
Err(Self::Error::HighlyPositiveExponent)
}else{
Ok(Planar64(unsafe{planar.to_int_unchecked()}))
}
}
std::num::FpCategory::Subnormal=>Err(Self::Error::Subnormal),
std::num::FpCategory::Normal=>planar64_from_mes(integer_decode_f64(value)),
}
}
}
@ -568,7 +572,7 @@ impl std::ops::Div<Planar64> for Planar64{
type Output=Planar64;
#[inline]
fn div(self, rhs: Planar64) -> Self::Output {
Planar64((((self.0 as i128)<<32)/(rhs.0 as i128)) as i64)
Planar64((((self.0 as i128)<<32)/rhs.0 as i128) as i64)
}
}
// impl PartialOrd<i64> for Planar64{
@ -579,7 +583,7 @@ impl std::ops::Div<Planar64> for Planar64{
///[-1.0,1.0] = [-2^32,2^32]
#[derive(Clone,Copy,Default,Hash,Eq,PartialEq)]
#[derive(Clone,Copy,Debug,Default,Hash,Eq,PartialEq)]
pub struct Planar64Vec3(glam::I64Vec3);
impl Planar64Vec3{
pub const ZERO:Self=Planar64Vec3(glam::I64Vec3::ZERO);
@ -803,17 +807,6 @@ impl std::ops::Mul<Time> for Planar64Vec3{
))
}
}
impl std::ops::Div<Planar64> for Planar64Vec3{
type Output=Planar64Vec3;
#[inline]
fn div(self,rhs:Planar64)->Self::Output{
Planar64Vec3(glam::i64vec3(
(((self.0.x as i128)<<32)/(rhs.0 as i128)) as i64,
(((self.0.y as i128)<<32)/(rhs.0 as i128)) as i64,
(((self.0.z as i128)<<32)/(rhs.0 as i128)) as i64,
))
}
}
impl std::ops::Div<i64> for Planar64Vec3{
type Output=Planar64Vec3;
#[inline]

@ -1,235 +0,0 @@
const VALVE_SCALE:f32=1.0/16.0;
fn valve_transform(v:[f32;3])->crate::integer::Planar64Vec3{
crate::integer::Planar64Vec3::try_from([v[0]*VALVE_SCALE,v[2]*VALVE_SCALE,-v[1]*VALVE_SCALE]).unwrap()
}
pub fn generate_indexed_models<R:std::io::Read+std::io::Seek>(input:&mut R)->Result<crate::model::IndexedModelInstances,vbsp::BspError>{
let mut s=Vec::new();
match input.read_to_end(&mut s){
Ok(_)=>(),
Err(e)=>println!("load_bsp::generate_indexed_models read_to_end failed: {:?}",e),
}
match vbsp::Bsp::read(s.as_slice()){
Ok(bsp)=>{
let mut spawn_point=crate::integer::Planar64Vec3::ZERO;
let vertices: Vec<_> = bsp
.vertices
.iter()
.map(|vertex|<[f32;3]>::from(vertex.position))
.collect();
let mut name_from_texture_id=Vec::new();
let mut texture_id_from_name=std::collections::HashMap::new();
let mut models=bsp.models().map(|world_model|{
//non-deduplicated
let mut spam_pos=Vec::new();
let mut spam_tex=Vec::new();
let mut spam_normal=Vec::new();
let mut spam_vertices=Vec::new();
let groups=world_model.faces()
.filter(|face| face.is_visible())//TODO: look at this
.map(|face|{
let face_texture=face.texture();
let face_texture_data=face_texture.texture_data();
let (texture_u,texture_v)=(glam::Vec3A::from_slice(&face_texture.texture_transforms_u[0..3]),glam::Vec3A::from_slice(&face_texture.texture_transforms_v[0..3]));
let texture_offset=glam::vec2(face_texture.texture_transforms_u[3],face_texture.texture_transforms_v[3]);
let texture_size=glam::vec2(face_texture_data.width as f32,face_texture_data.height as f32);
//texture
let texture_id=if let Some(&texture_id)=texture_id_from_name.get(face_texture_data.name()){
texture_id
}else{
let texture_id=name_from_texture_id.len() as u32;
texture_id_from_name.insert(face_texture_data.name().to_string(),texture_id);
name_from_texture_id.push(face_texture_data.name().to_string());
texture_id
};
//normal
let normal=face.normal();
let normal_idx=spam_normal.len() as u32;
spam_normal.push(valve_transform(<[f32;3]>::from(normal)));
let mut vertices:Vec<u32>=face.vertex_indexes().map(|vertex_index|{
let pos=glam::Vec3A::from_array(vertices[vertex_index as usize]);
let pos_idx=spam_pos.len();
spam_pos.push(valve_transform(vertices[vertex_index as usize]));
//calculate texture coordinates
let tex=(glam::vec2(pos.dot(texture_u),pos.dot(texture_v))+texture_offset)/texture_size;
let tex_idx=spam_tex.len() as u32;
spam_tex.push(tex);
let i=spam_vertices.len() as u32;
spam_vertices.push(crate::model::IndexedVertex{
pos: pos_idx as u32,
tex: tex_idx as u32,
normal: normal_idx,
color: 0,
});
i
}).collect();
vertices.reverse();
crate::model::IndexedGroup{
texture:Some(texture_id),
polys:vec![crate::model::IndexedPolygon{vertices}],
}
}).collect();
crate::model::IndexedModel{
unique_pos:spam_pos,
unique_tex:spam_tex,
unique_normal:spam_normal,
unique_color:vec![glam::Vec4::ONE],
unique_vertices:spam_vertices,
groups,
instances:vec![crate::model::ModelInstance{
attributes:crate::model::CollisionAttributes::Decoration,
transform:crate::integer::Planar64Affine3::new(
crate::integer::Planar64Mat3::default(),
valve_transform(<[f32;3]>::from(world_model.origin))
),
..Default::default()
}],
}
}).collect();
//dedupe prop models
let mut model_dedupe=std::collections::HashSet::new();
for prop in bsp.static_props(){
model_dedupe.insert(prop.model());
}
//generate unique meshes
let mut model_map=std::collections::HashMap::with_capacity(model_dedupe.len());
let mut prop_models=Vec::new();
for model_name in model_dedupe{
let model_name_lower=model_name.to_lowercase();
//.mdl, .vvd, .dx90.vtx
let mut path=std::path::PathBuf::from(model_name_lower.as_str());
let file_name=std::path::PathBuf::from(path.file_stem().unwrap());
path.pop();
path.push(file_name);
let mut vvd_path=path.clone();
let mut vtx_path=path.clone();
vvd_path.set_extension("vvd");
vtx_path.set_extension("dx90.vtx");
match (bsp.pack.get(model_name_lower.as_str()),bsp.pack.get(vvd_path.as_os_str().to_str().unwrap()),bsp.pack.get(vtx_path.as_os_str().to_str().unwrap())){
(Ok(Some(mdl_file)),Ok(Some(vvd_file)),Ok(Some(vtx_file)))=>{
match (vmdl::mdl::Mdl::read(mdl_file.as_ref()),vmdl::vvd::Vvd::read(vvd_file.as_ref()),vmdl::vtx::Vtx::read(vtx_file.as_ref())){
(Ok(mdl),Ok(vvd),Ok(vtx))=>{
let model=vmdl::Model::from_parts(mdl,vtx,vvd);
let texture_paths=model.texture_directories();
if texture_paths.len()!=1{
println!("WARNING: multiple texture paths");
}
let skin=model.skin_tables().nth(0).unwrap();
let mut spam_pos=Vec::with_capacity(model.vertices().len());
let mut spam_normal=Vec::with_capacity(model.vertices().len());
let mut spam_tex=Vec::with_capacity(model.vertices().len());
let mut spam_vertices=Vec::with_capacity(model.vertices().len());
for (i,vertex) in model.vertices().iter().enumerate(){
spam_pos.push(valve_transform(<[f32;3]>::from(vertex.position)));
spam_normal.push(valve_transform(<[f32;3]>::from(vertex.normal)));
spam_tex.push(glam::Vec2::from_array(vertex.texture_coordinates));
spam_vertices.push(crate::model::IndexedVertex{
pos:i as u32,
tex:i as u32,
normal:i as u32,
color:0,
});
}
let model_id=prop_models.len();
model_map.insert(model_name,model_id);
prop_models.push(crate::model::IndexedModel{
unique_pos:spam_pos,
unique_normal:spam_normal,
unique_tex:spam_tex,
unique_color:vec![glam::Vec4::ONE],
unique_vertices:spam_vertices,
groups:model.meshes().map(|mesh|{
let texture=if let (Some(texture_path),Some(texture_name))=(texture_paths.get(0),skin.texture(mesh.material_index())){
let mut path=std::path::PathBuf::from(texture_path.as_str());
path.push(texture_name);
let texture_location=path.as_os_str().to_str().unwrap();
let texture_id=if let Some(&texture_id)=texture_id_from_name.get(texture_location){
texture_id
}else{
println!("texture! {}",texture_location);
let texture_id=name_from_texture_id.len() as u32;
texture_id_from_name.insert(texture_location.to_string(),texture_id);
name_from_texture_id.push(texture_location.to_string());
texture_id
};
Some(texture_id)
}else{
None
};
crate::model::IndexedGroup{
texture,
polys:{
//looking at the code, it would seem that the strips are pre-deindexed into triangle lists when calling this function
mesh.vertex_strip_indices().map(|strip|{
strip.collect::<Vec<usize>>().chunks(3).map(|tri|{
crate::model::IndexedPolygon{vertices:vec![tri[0] as u32,tri[1] as u32,tri[2] as u32]}
}).collect::<Vec<crate::model::IndexedPolygon>>()
}).flatten().collect()
},
}
}).collect(),
instances:Vec::new(),
});
},
_=>println!("model_name={} error",model_name),
}
},
_=>println!("no model name={}",model_name),
}
}
//generate model instances
for prop in bsp.static_props(){
let placement=prop.as_prop_placement();
if let Some(&model_index)=model_map.get(placement.model){
prop_models[model_index].instances.push(crate::model::ModelInstance{
transform:crate::integer::Planar64Affine3::new(
crate::integer::Planar64Mat3::try_from(
glam::Mat3A::from_diagonal(glam::Vec3::splat(placement.scale))
//TODO: figure this out
*glam::Mat3A::from_quat(glam::Quat::from_xyzw(
placement.rotation.v.x,//b
placement.rotation.v.y,//c
placement.rotation.v.z,//d
placement.rotation.s,//a
))
).unwrap(),
valve_transform(<[f32;3]>::from(placement.origin)),
),
attributes:crate::model::CollisionAttributes::Decoration,
..Default::default()
});
}else{
//println!("model not found {}",placement.model);
}
}
//actually add the prop models
prop_models.append(&mut models);
Ok(crate::model::IndexedModelInstances{
textures:name_from_texture_id,
models:prop_models,
spawn_point,
modes:Vec::new(),
})
},
Err(e)=>{
println!("rotten {:?}",e);
Err(e)
},
}
}

@ -14,15 +14,12 @@ fn class_is_a(class: &str, superclass: &str) -> bool {
return false
}
fn recursive_collect_superclass(objects: &mut std::vec::Vec<rbx_dom_weak::types::Ref>,dom: &rbx_dom_weak::WeakDom, instance: &rbx_dom_weak::Instance, superclass: &str){
let mut stack=vec![instance];
while let Some(item)=stack.pop(){
for &referent in item.children(){
if let Some(c)=dom.get_by_ref(referent){
if class_is_a(c.class.as_str(),superclass){
objects.push(c.referent());//copy ref
}
stack.push(c);
for &referent in instance.children() {
if let Some(c) = dom.get_by_ref(referent) {
if class_is_a(c.class.as_str(), superclass) {
objects.push(c.referent());//copy ref
}
recursive_collect_superclass(objects,dom,c,superclass);
}
}
}
@ -265,18 +262,6 @@ pub fn generate_indexed_models(dom:rbx_dom_weak::WeakDom) -> crate::model::Index
{
let model_transform=planar64_affine3_from_roblox(cf,size);
if model_transform.matrix3.determinant()==Planar64::ZERO{
let mut parent_ref=object.parent();
let mut full_path=object.name.clone();
while let Some(parent)=dom.get_by_ref(parent_ref){
full_path=format!("{}.{}",parent.name,full_path);
parent_ref=parent.parent();
}
println!("Zero determinant CFrame at location {}",full_path);
println!("matrix3:{}",model_transform.matrix3);
continue;
}
//push TempIndexedAttributes
let mut force_intersecting=false;
let mut temp_indexing_attributes=Vec::new();

@ -11,7 +11,6 @@ mod graphics;
mod settings;
mod primitives;
mod instruction;
mod load_bsp;
mod load_roblox;
mod face_crawler;
mod compat_worker;
@ -47,7 +46,7 @@ fn load_file(path: std::path::PathBuf)->Option<model::IndexedModelInstances>{
},
}
},
b"VBSP"=>load_bsp::generate_indexed_models(&mut input).ok(),
//b"VBSP"=>Some(load_bsp::generate_indexed_models(input)),
//b"SNFM"=>Some(sniffer::generate_indexed_models(input)),
//b"SNFB"=>Some(sniffer::load_bot(input)),
other=>{

@ -259,6 +259,7 @@ impl IntersectingAttributes{
}
}
//Spawn(u32) NO! spawns are indexed in the map header instead of marked with attibutes
//TODO: deduplicate attributes
pub enum CollisionAttributes{
Decoration,//visual only
Contact{//track whether you are contacting the object

@ -40,6 +40,7 @@ impl DirectedEdge for DirectedEdgeId{
pub struct FaceId(usize);
//Vertex <-> Edge <-> Face -> Collide
#[derive(Debug)]
pub enum FEV<F,E:DirectedEdge,V>{
Face(F),
Edge(E::UndirectedEdge),
@ -47,10 +48,12 @@ pub enum FEV<F,E:DirectedEdge,V>{
}
//use Unit32 #[repr(C)] for map files
#[derive(Debug)]
struct Face{
normal:Planar64Vec3,
dot:Planar64,
}
#[derive(Debug)]
struct Vert(Planar64Vec3);
pub trait MeshQuery<FACE:Clone,EDGE:Clone+DirectedEdge,VERT:Clone>{
fn edge_n(&self,edge_id:EDGE::UndirectedEdge)->Planar64Vec3{
@ -69,18 +72,22 @@ pub trait MeshQuery<FACE:Clone,EDGE:Clone+DirectedEdge,VERT:Clone>{
fn vert_edges(&self,vert_id:VERT)->Cow<Vec<EDGE>>;
fn vert_faces(&self,vert_id:VERT)->Cow<Vec<FACE>>;
}
#[derive(Debug)]
struct FaceRefs{
edges:Vec<DirectedEdgeId>,
//verts:Vec<VertId>,
}
#[derive(Debug)]
struct EdgeRefs{
faces:[FaceId;2],//left, right
verts:[VertId;2],//bottom, top
}
#[derive(Debug)]
struct VertRefs{
faces:Vec<FaceId>,
edges:Vec<DirectedEdgeId>,
}
#[derive(Debug)]
pub struct PhysicsMesh{
faces:Vec<Face>,
verts:Vec<Vert>,
@ -238,20 +245,17 @@ pub struct TransformedMesh<'a>{
mesh:&'a PhysicsMesh,
transform:&'a crate::integer::Planar64Affine3,
normal_transform:&'a crate::integer::Planar64Mat3,
transform_det:Planar64,
}
impl TransformedMesh<'_>{
pub fn new<'a>(
mesh:&'a PhysicsMesh,
transform:&'a crate::integer::Planar64Affine3,
normal_transform:&'a crate::integer::Planar64Mat3,
transform_det:Planar64,
)->TransformedMesh<'a>{
TransformedMesh{
mesh,
transform,
normal_transform,
transform_det,
}
}
fn farthest_vert(&self,dir:Planar64Vec3)->VertId{
@ -272,8 +276,8 @@ impl MeshQuery<FaceId,DirectedEdgeId,VertId> for TransformedMesh<'_>{
fn face_nd(&self,face_id:FaceId)->(Planar64Vec3,Planar64){
let (n,d)=self.mesh.face_nd(face_id);
let transformed_n=*self.normal_transform*n;
let transformed_d=d+transformed_n.dot(self.transform.translation)/self.transform_det;
(transformed_n/self.transform_det,transformed_d)
let transformed_d=Planar64::raw(((transformed_n.dot128(self.transform.matrix3*(n*d))<<32)/n.dot128(n)) as i64)+transformed_n.dot(self.transform.translation);
(transformed_n,transformed_d)
}
fn vert(&self,vert_id:VertId)->Planar64Vec3{
self.transform.transform_point3(self.mesh.vert(vert_id))
@ -304,11 +308,11 @@ impl MeshQuery<FaceId,DirectedEdgeId,VertId> for TransformedMesh<'_>{
//(face,vertex)
//(edge,edge)
//(vertex,face)
#[derive(Clone,Copy)]
#[derive(Clone,Copy,Debug)]
pub enum MinkowskiVert{
VertVert(VertId,VertId),
}
#[derive(Clone,Copy)]
#[derive(Clone,Copy,Debug)]
pub enum MinkowskiEdge{
VertEdge(VertId,EdgeId),
EdgeVert(EdgeId,VertId),
@ -323,7 +327,7 @@ impl UndirectedEdge for MinkowskiEdge{
}
}
}
#[derive(Clone,Copy)]
#[derive(Clone,Copy,Debug)]
pub enum MinkowskiDirectedEdge{
VertEdge(VertId,DirectedEdgeId),
EdgeVert(DirectedEdgeId,VertId),
@ -344,7 +348,7 @@ impl DirectedEdge for MinkowskiDirectedEdge{
}
}
}
#[derive(Debug,Clone,Copy,Hash,Eq,PartialEq)]
#[derive(Clone,Copy,Debug,Hash,Eq,PartialEq)]
pub enum MinkowskiFace{
VertFace(VertId,FaceId),
EdgeEdge(EdgeId,EdgeId,bool),
@ -384,12 +388,12 @@ impl MinkowskiMesh<'_>{
for &directed_edge_id in self.vert_edges(vert_id).iter(){
let edge_n=self.directed_edge_n(directed_edge_id);
//is boundary uncrossable by a crawl from infinity
let edge_verts=self.edge_verts(directed_edge_id.as_undirected());
//select opposite vertex
let test_vert_id=edge_verts[directed_edge_id.parity() as usize];
//test if it's closer
let diff=point-self.vert(test_vert_id);
if crate::zeroes::zeroes1(edge_n.dot(diff),edge_n.dot(infinity_dir)).len()==0{
if infinity_dir.dot(edge_n)==Planar64::ZERO{
let edge_verts=self.edge_verts(directed_edge_id.as_undirected());
//select opposite vertex
let test_vert_id=edge_verts[directed_edge_id.parity() as usize];
//test if it's closer
let diff=point-self.vert(test_vert_id);
let distance_squared=diff.dot(diff);
if distance_squared<*best_distance_squared{
best_transition=Transition::Vert(test_vert_id);
@ -405,10 +409,9 @@ impl MinkowskiMesh<'_>{
for &directed_edge_id in self.vert_edges(vert_id).iter(){
let edge_n=self.directed_edge_n(directed_edge_id);
//is boundary uncrossable by a crawl from infinity
//check if time of collision is outside Time::MIN..Time::MAX
let d=edge_n.dot(diff);
if crate::zeroes::zeroes1(d,edge_n.dot(infinity_dir)).len()==0{
if infinity_dir.dot(edge_n)==Planar64::ZERO{
//test the edge
let d=diff.dot(edge_n);
let edge_nn=edge_n.dot(edge_n);
if Planar64::ZERO<=d&&d<=edge_nn{
let distance_squared={
@ -438,6 +441,7 @@ impl MinkowskiMesh<'_>{
}
/// This function drops a vertex down to an edge or a face if the path from infinity did not cross any vertex-edge boundaries but the point is supposed to have already crossed a boundary down from a vertex
fn infinity_fev(&self,infinity_dir:Planar64Vec3,point:Planar64Vec3)->FEV::<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>{
println!("infinity_fev dir={} point={}",infinity_dir,point);
//start on any vertex
//cross uncrossable vertex-edge boundaries until you find the closest vertex or edge
//cross edge-face boundary if it's uncrossable
@ -445,21 +449,37 @@ impl MinkowskiMesh<'_>{
//if a vert is returned, it is the closest point to the infinity point
EV::Vert(vert_id)=>FEV::<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>::Vert(vert_id),
EV::Edge(edge_id)=>{
println!("fix edge edge_id={:?}",edge_id);
match edge_id{
MinkowskiEdge::VertEdge(v0,e1)=>{
println!("v0={}",self.mesh0.vert(v0));
for face_id1 in self.mesh1.edge_faces(e1).iter(){
println!("e1 face_n={}",self.mesh1.face_nd(*face_id1).0);
}
},
MinkowskiEdge::EdgeVert(e0,v1)=>{
println!("v1={}",self.mesh1.vert(v1));
for face_id0 in self.mesh0.edge_faces(e0).iter(){
println!("e0 face_n={}",self.mesh0.face_nd(*face_id0).0);
}
},
}
//cross to face if the boundary is not crossable and we are on the wrong side
let edge_n=self.edge_n(edge_id);
// point is multiplied by two because vert_sum sums two vertices.
let delta_pos=point*2-{
println!("edge_n={}",edge_n);
let vert_sum={
let &[v0,v1]=self.edge_verts(edge_id).borrow();
self.vert(v0)+self.vert(v1)
};
for (i,&face_id) in self.edge_faces(edge_id).iter().enumerate(){
let face_n=self.face_nd(face_id).0;
println!("face_id={:?} face_n={}",face_id,face_n);
//edge-face boundary nd, n facing out of the face towards the edge
let boundary_n=face_n.cross(edge_n)*(i as i64*2-1);
let boundary_d=boundary_n.dot(delta_pos);
//check if time of collision is outside Time::MIN..Time::MAX
//infinity_dir can always be treated as a velocity
if (boundary_d)<=Planar64::ZERO&&crate::zeroes::zeroes1(boundary_d,boundary_n.dot(infinity_dir)*2).len()==0{
let boundary_d=boundary_n.dot(vert_sum);
println!("dot={} boundary_n={} boundary_d={} point_d={}",infinity_dir.dot(boundary_n),boundary_n,boundary_d,point.dot(boundary_n)*2);
// point.dot(boundary_n) is multiplied by two because vert_sum sums two vertices.
if infinity_dir.dot(boundary_n)==Planar64::ZERO&&point.dot(boundary_n)*2<=boundary_d{
//both faces cannot pass this condition, return early if one does.
return FEV::<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>::Face(face_id);
}
@ -483,6 +503,7 @@ impl MinkowskiMesh<'_>{
}
pub fn predict_collision_in(&self,relative_body:&crate::physics::Body,time_limit:crate::integer::Time)->Option<(MinkowskiFace,crate::integer::Time)>{
self.closest_fev_not_inside(relative_body.clone()).map_or(None,|fev|{
println!("@@@BEGIN REAL CRAWL@@@");
//continue forwards along the body parabola
match crate::face_crawler::crawl_fev(fev,self,relative_body,relative_body.time,time_limit){
crate::face_crawler::CrawlResult::Miss(_)=>None,
@ -604,7 +625,6 @@ impl MeshQuery<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert> for MinkowskiM
let d=edge_face1_n.dot(edge0_n);
if d<Planar64::ZERO{
let edge0_nn=edge0_n.dot(edge0_n);
//divide by zero???
let dd=d*d/(edge_face1_nn*edge0_nn);
if best_d<dd{
best_d=dd;
@ -741,4 +761,4 @@ fn build_me_a_cube(){
let unit_cube=crate::primitives::unit_cube();
let mesh=PhysicsMesh::from(&unit_cube);
//println!("mesh={:?}",mesh);
}
}

@ -202,7 +202,6 @@ impl PhysicsModels{
&self.meshes[self.models[model_id].mesh_id],
&self.models[model_id].transform,
&self.models[model_id].normal_transform,
self.models[model_id].transform_det,
)
}
fn model(&self,model_id:usize)->&PhysicsModel{
@ -344,11 +343,11 @@ struct Hitbox{
mesh:PhysicsMesh,
transform:crate::integer::Planar64Affine3,
normal_transform:Planar64Mat3,
transform_det:Planar64,
}
impl Hitbox{
fn new(mesh:PhysicsMesh,transform:crate::integer::Planar64Affine3)->Self{
//calculate extents
let normal_transform=transform.matrix3.inverse_times_det().transpose();
let mut aabb=crate::aabb::Aabb::default();
for vert in mesh.verts(){
aabb.grow(transform.transform_point3(vert));
@ -357,28 +356,23 @@ impl Hitbox{
halfsize:aabb.size()/2,
mesh,
transform,
normal_transform:transform.matrix3.inverse_times_det().transpose(),
transform_det:transform.matrix3.determinant(),
normal_transform,
}
}
fn from_mesh_scale(mesh:PhysicsMesh,scale:Planar64Vec3)->Self{
let matrix3=Planar64Mat3::from_diagonal(scale);
Self{
halfsize:scale,
mesh,
normal_transform:matrix3.inverse_times_det().transpose(),
transform:crate::integer::Planar64Affine3::new(matrix3,Planar64Vec3::ZERO),
transform_det:matrix3.determinant(),//scale.x*scale.y*scale.z but whatever
transform:crate::integer::Planar64Affine3::new(Planar64Mat3::from_diagonal(scale),Planar64Vec3::ZERO),
normal_transform:Planar64Mat3::from_diagonal(scale).inverse_times_det().transpose(),
}
}
fn from_mesh_scale_offset(mesh:PhysicsMesh,scale:Planar64Vec3,offset:Planar64Vec3)->Self{
let matrix3=Planar64Mat3::from_diagonal(scale);
Self{
halfsize:scale,
mesh,
normal_transform:matrix3.inverse_times_det().transpose(),
transform:crate::integer::Planar64Affine3::new(matrix3,offset),
transform_det:matrix3.determinant(),
transform:crate::integer::Planar64Affine3::new(Planar64Mat3::from_diagonal(scale),offset),
normal_transform:Planar64Mat3::from_diagonal(scale).inverse_times_det().transpose(),
}
}
fn roblox()->Self{
@ -389,7 +383,7 @@ impl Hitbox{
}
#[inline]
fn transformed_mesh(&self)->TransformedMesh{
TransformedMesh::new(&self.mesh,&self.transform,&self.normal_transform,self.transform_det)
TransformedMesh::new(&self.mesh,&self.transform,&self.normal_transform)
}
}
@ -526,7 +520,7 @@ impl StyleModifiers{
controls_mask:!0,//&!(Self::CONTROL_MOVEUP|Self::CONTROL_MOVEDOWN),
strafe:Some(StrafeSettings{
enable:EnableStrafe::Always,
air_accel_limit:Some(Planar64::raw(150<<28)*100),
air_accel_limit:Some(Planar64::raw(150<<28)*66),
tick_rate:Ratio64::new(100,Time::ONE_SECOND.nanos() as u64).unwrap(),
}),
jump_impulse:JumpImpulse::FromHeight(Planar64::raw(52<<28)),
@ -785,17 +779,16 @@ pub struct PhysicsModel{
attr_id:usize,
transform:crate::integer::Planar64Affine3,
normal_transform:crate::integer::Planar64Mat3,
transform_det:Planar64,
}
impl PhysicsModel{
pub fn new(mesh_id:usize,attr_id:usize,transform:crate::integer::Planar64Affine3)->Self{
let normal_transform=transform.matrix3.inverse_times_det().transpose();
Self{
mesh_id,
attr_id,
transform,
normal_transform:transform.matrix3.inverse_times_det().transpose(),
transform_det:transform.matrix3.determinant(),
normal_transform,
}
}
}
@ -963,6 +956,7 @@ impl TouchingState{
//detect model collision in reverse
let model_mesh=models.mesh(intersect.model_id);
let minkowski=crate::model_physics::MinkowskiMesh::minkowski_sum(&model_mesh,&style_mesh);
println!("### predict_collision_out id={} body={} time_limit={}",intersect.model_id,relative_body,collector.time());
collector.collect(minkowski.predict_collision_out(&relative_body,collector.time()).map(|(face,time)|{
TimedInstruction{
time,
@ -1302,6 +1296,7 @@ impl crate::instruction::InstructionEmitter<PhysicsInstruction> for PhysicsState
//no checks are needed because of the time limits.
let model_mesh=self.models.mesh(id);
let minkowski=crate::model_physics::MinkowskiMesh::minkowski_sum(&model_mesh,&style_mesh);
println!("### predict_collision_in id={} body={} time_limit={}",id,relative_body,collector.time());
collector.collect(minkowski.predict_collision_in(&relative_body,collector.time())
//temp (?) code to avoid collision loops
.map_or(None,|(face,time)|if time==self.time{None}else{Some((face,time))})
@ -1676,7 +1671,7 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
#[allow(dead_code)]
fn test_collision_axis_aligned(relative_body:Body,expected_collision_time:Option<Time>){
let h0=Hitbox::from_mesh_scale(PhysicsMesh::from(&crate::primitives::unit_cube()),Planar64Vec3::int(5,1,5)/2);
let h0=Hitbox::from_mesh_scale(PhysicsMesh::from(&crate::primitives::unit_cube()),Planar64Vec3::int(256,1,256)/2);
let h1=Hitbox::roblox();
let hitbox_mesh=h1.transformed_mesh();
let platform_mesh=h0.transformed_mesh();
@ -1689,9 +1684,9 @@ fn test_collision_rotated(relative_body:Body,expected_collision_time:Option<Time
let h0=Hitbox::new(PhysicsMesh::from(&crate::primitives::unit_cube()),
crate::integer::Planar64Affine3::new(
crate::integer::Planar64Mat3::from_cols(
Planar64Vec3::int(5,0,1)/2,
Planar64Vec3::int(256,0,1)/2,
Planar64Vec3::int(0,1,0)/2,
Planar64Vec3::int(-1,0,5)/2,
Planar64Vec3::int(-1,0,256)/2,
),
Planar64Vec3::ZERO,
)
@ -1871,6 +1866,42 @@ fn test_collision_oblique(){
),Some(Time::from_secs(2)));
}
#[test]
fn test_collision_oblique_north(){
test_collision(Body::new(
Planar64Vec3::int(0,4,0),
Planar64Vec3::int(0,-1,-1),
Planar64Vec3::int(0,-1,0),
Time::ZERO
),Some(Time::from_nanos(732050807)));
}
#[test]
fn test_collision_oblique_east(){
test_collision(Body::new(
Planar64Vec3::int(0,4,0),
Planar64Vec3::int(1,-1,0),
Planar64Vec3::int(0,-1,0),
Time::ZERO
),Some(Time::from_nanos(732050807)));
}
#[test]
fn test_collision_oblique_south(){
test_collision(Body::new(
Planar64Vec3::int(0,4,0),
Planar64Vec3::int(0,-1,1),
Planar64Vec3::int(0,-1,0),
Time::ZERO
),Some(Time::from_nanos(732050807)));
}
#[test]
fn test_collision_oblique_west(){
test_collision(Body::new(
Planar64Vec3::int(0,4,0),
Planar64Vec3::int(-1,-1,0),
Planar64Vec3::int(0,-1,0),
Time::ZERO
),Some(Time::from_nanos(732050807)));
}
#[test]
fn zoom_hit_nothing(){
test_collision(Body::new(
Planar64Vec3::int(0,10,0),
@ -1887,4 +1918,4 @@ fn already_inside_hit_nothing(){
Planar64Vec3::int(0,1,0),
Time::ZERO
),None);
}
}

@ -9,7 +9,6 @@ pub fn zeroes2(a0:Planar64,a1:Planar64,a2:Planar64) -> Vec<Planar64>{
let radicand=a1.get() as i128*a1.get() as i128-a2.get() as i128*a0.get() as i128*4;
if 0<radicand {
//start with f64 sqrt
//failure case: 2^63 < sqrt(2^127)
let planar_radicand=Planar64::raw(unsafe{(radicand as f64).sqrt().to_int_unchecked()});
//TODO: one or two newtons
//sort roots ascending and avoid taking the difference of large numbers
@ -29,12 +28,7 @@ pub fn zeroes2(a0:Planar64,a1:Planar64,a2:Planar64) -> Vec<Planar64>{
pub fn zeroes1(a0:Planar64,a1:Planar64) -> Vec<Planar64> {
if a1==Planar64::ZERO{
return vec![];
}else{
let q=((-a0.get() as i128)<<32)/(a1.get() as i128);
if i64::MIN as i128<=q&&q<=i64::MAX as i128{
return vec![Planar64::raw(q as i64)];
}else{
return vec![];
}
} else {
return vec![-a0/a1];
}
}

@ -1,4 +1,5 @@
[camera]
sensitivity_x=98384
sensitivity_x=49192
#sensitivity_x=98384
fov_y=1.0
#fov_x_from_y_ratio=1.33333333333333333333333333333333