debug

Splits the MeshQuery trait into MeshQuery and MeshTopology and cleans up much of the physics traits.  A notable optimization is using a closure for iterating variable length topological lists.  Intermediate allocations are avoided in this way.

Reviewed-on: #33
Co-authored-by: Rhys Lloyd <krakow20@gmail.com>
Co-committed-by: Rhys Lloyd <krakow20@gmail.com>

Cargo.lock

@@ -48,9 +48,9 @@ dependencies = [
 
 [[package]]
 name = "aligned"
-version = "0.4.2"
+version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "377e4c0ba83e4431b10df45c1d4666f178ea9c552cac93e60c3a88bf32785923"
+checksum = "ee4508988c62edf04abd8d92897fca0c2995d907ce1dfeaf369dac3716a40685"
 dependencies = [
  "as-slice",
 ]
@@ -64,6 +64,12 @@ dependencies = [
  "equator",
 ]
 
+[[package]]
+name = "allocator-api2"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
+
 [[package]]
 name = "android-activity"
 version = "0.6.0"
@@ -445,9 +451,9 @@ checksum = "f4ad8f11f288f48ca24471bbd51ac257aaeaaa07adae295591266b792902ae64"
 
 [[package]]
 name = "bumpalo"
-version = "3.19.0"
+version = "3.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"
+checksum = "5dd9dc738b7a8311c7ade152424974d8115f2cdad61e8dab8dac9f2362298510"
 
 [[package]]
 name = "bv"
@@ -530,9 +536,9 @@ dependencies = [
 
 [[package]]
 name = "cc"
-version = "1.2.47"
+version = "1.2.49"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd405d82c84ff7f35739f175f67d8b9fb7687a0e84ccdc78bd3568839827cf07"
+checksum = "90583009037521a116abf44494efecd645ba48b6622457080f080b85544e2215"
 dependencies = [
  "find-msvc-tools",
  "jobserver",
@@ -1245,9 +1251,9 @@ dependencies = [
 
 [[package]]
 name = "gif"
-version = "0.14.0"
+version = "0.14.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f954a9e9159ec994f73a30a12b96a702dde78f5547bcb561174597924f7d4162"
+checksum = "f5df2ba84018d80c213569363bdcd0c64e6933c67fe4c1d60ecf822971a3c35e"
 dependencies = [
  "color_quant",
  "weezl",
@@ -1291,34 +1297,17 @@ dependencies = [
  "gl_generator",
 ]
 
-[[package]]
-name = "gpu-alloc"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fbcd2dba93594b227a1f57ee09b8b9da8892c34d55aa332e034a228d0fe6a171"
-dependencies = [
- "bitflags 2.10.0",
- "gpu-alloc-types",
-]
-
-[[package]]
-name = "gpu-alloc-types"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "98ff03b468aa837d70984d55f5d3f846f6ec31fe34bbb97c4f85219caeee1ca4"
-dependencies = [
- "bitflags 2.10.0",
-]
-
 [[package]]
 name = "gpu-allocator"
-version = "0.27.0"
+version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c151a2a5ef800297b4e79efa4f4bec035c5f51d5ae587287c9b952bdf734cacd"
+checksum = "51255ea7cfaadb6c5f1528d43e92a82acb2b96c43365989a28b2d44ee38f8795"
 dependencies = [
+ "ash",
+ "hashbrown 0.16.1",
  "log",
  "presser",
- "thiserror 1.0.69",
+ "thiserror 2.0.17",
  "windows",
 ]
 
@@ -1389,6 +1378,8 @@ version = "0.16.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
 dependencies = [
+ "allocator-api2",
+ "equivalent",
  "foldhash 0.2.0",
 ]
 
@@ -1505,9 +1496,9 @@ dependencies = [
 
 [[package]]
 name = "hyper-util"
-version = "0.1.18"
+version = "0.1.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52e9a2a24dc5c6821e71a7030e1e14b7b632acac55c40e9d2e082c621261bb56"
+checksum = "727805d60e7938b76b826a6ef209eb70eaa1812794f9424d4a4e2d740662df5f"
 dependencies = [
  "base64 0.22.1",
  "bytes",
@@ -1541,7 +1532,7 @@ dependencies = [
  "js-sys",
  "log",
  "wasm-bindgen",
- "windows-core 0.62.2",
+ "windows-core",
 ]
 
 [[package]]
@@ -1601,9 +1592,9 @@ checksum = "7aedcccd01fc5fe81e6b489c15b247b8b0690feb23304303a9e560f37efc560a"
 
 [[package]]
 name = "icu_properties"
-version = "2.1.1"
+version = "2.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e93fcd3157766c0c8da2f8cff6ce651a31f0810eaa1c51ec363ef790bbb5fb99"
+checksum = "020bfc02fe870ec3a66d93e677ccca0562506e5872c650f893269e08615d74ec"
 dependencies = [
  "icu_collections",
  "icu_locale_core",
@@ -1615,9 +1606,9 @@ dependencies = [
 
 [[package]]
 name = "icu_properties_data"
-version = "2.1.1"
+version = "2.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02845b3647bb045f1100ecd6480ff52f34c35f82d9880e029d329c21d1054899"
+checksum = "616c294cf8d725c6afcd8f55abc17c56464ef6211f9ed59cccffe534129c77af"
 
 [[package]]
 name = "icu_provider"
@@ -1687,7 +1678,7 @@ dependencies = [
  "rgb",
  "tiff",
  "zune-core 0.5.0",
- "zune-jpeg 0.5.5",
+ "zune-jpeg 0.5.7",
 ]
 
 [[package]]
@@ -1853,9 +1844,9 @@ dependencies = [
 
 [[package]]
 name = "js-sys"
-version = "0.3.82"
+version = "0.3.83"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b011eec8cc36da2aab2d5cff675ec18454fad408585853910a202391cf9f8e65"
+checksum = "464a3709c7f55f1f721e5389aa6ea4e3bc6aba669353300af094b29ffbdde1d8"
 dependencies = [
  "once_cell",
  "wasm-bindgen",
@@ -1892,9 +1883,9 @@ checksum = "7a79a3332a6609480d7d0c9eab957bca6b455b91bb84e66d19f5ff66294b85b8"
 
 [[package]]
 name = "libc"
-version = "0.2.177"
+version = "0.2.178"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2874a2af47a2325c2001a6e6fad9b16a53b802102b528163885171cf92b15976"
+checksum = "37c93d8daa9d8a012fd8ab92f088405fb202ea0b6ab73ee2482ae66af4f42091"
 
 [[package]]
 name = "libfuzzer-sys"
@@ -1924,13 +1915,13 @@ checksum = "f9fbbcab51052fe104eb5e5d351cf728d30a5be1fe14d9be8a3b097481fb97de"
 
 [[package]]
 name = "libredox"
-version = "0.1.10"
+version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "416f7e718bdb06000964960ffa43b4335ad4012ae8b99060261aa4a8088d5ccb"
+checksum = "df15f6eac291ed1cf25865b1ee60399f57e7c227e7f51bdbd4c5270396a9ed50"
 dependencies = [
  "bitflags 2.10.0",
  "libc",
- "redox_syscall 0.5.18",
+ "redox_syscall 0.6.0",
 ]
 
 [[package]]
@@ -1977,9 +1968,9 @@ dependencies = [
 
 [[package]]
 name = "log"
-version = "0.4.28"
+version = "0.4.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432"
+checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
 
 [[package]]
 name = "logos"
@@ -2025,9 +2016,9 @@ dependencies = [
 
 [[package]]
 name = "luau0-src"
-version = "0.17.0+luau701"
+version = "0.17.1+luau702"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed8f8edd8aba9654a9eeb62b2fe7461589f2faf2d0a1bc04bd64c0123319b3fc"
+checksum = "94e879d82bf7e2e682218f451256f934b7bf8e5703fc2a866eeb4a32e3e79886"
 dependencies = [
  "cc",
 ]
@@ -2126,9 +2117,9 @@ dependencies = [
 
 [[package]]
 name = "metal"
-version = "0.32.0"
+version = "0.33.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "00c15a6f673ff72ddcc22394663290f870fb224c1bfce55734a75c414150e605"
+checksum = "c7047791b5bc903b8cd963014b355f71dc9864a9a0b727057676c1dcae5cbc15"
 dependencies = [
  "bitflags 2.10.0",
  "block",
@@ -2189,9 +2180,9 @@ dependencies = [
 
 [[package]]
 name = "mio"
-version = "1.1.0"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69d83b0086dc8ecf3ce9ae2874b2d1290252e2a30720bea58a5c6639b0092873"
+checksum = "a69bcab0ad47271a0234d9422b131806bf3968021e5dc9328caf2d4cd58557fc"
 dependencies = [
  "libc",
  "wasi",
@@ -2228,9 +2219,9 @@ dependencies = [
 
 [[package]]
 name = "moxcms"
-version = "0.7.10"
+version = "0.7.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "80986bbbcf925ebd3be54c26613d861255284584501595cf418320c078945608"
+checksum = "ac9557c559cd6fc9867e122e20d2cbefc9ca29d80d027a8e39310920ed2f0a97"
 dependencies = [
  "num-traits",
  "pxfm",
@@ -2238,9 +2229,9 @@ dependencies = [
 
 [[package]]
 name = "naga"
-version = "27.0.3"
+version = "28.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "066cf25f0e8b11ee0df221219010f213ad429855f57c494f995590c861a9a7d8"
+checksum = "618f667225063219ddfc61251087db8a9aec3c3f0950c916b614e403486f1135"
 dependencies = [
  "arrayvec",
  "bit-set",
@@ -3009,9 +3000,9 @@ dependencies = [
 
 [[package]]
 name = "pxfm"
-version = "0.1.26"
+version = "0.1.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b3502d6155304a4173a5f2c34b52b7ed0dd085890326cb50fd625fdf39e86b3b"
+checksum = "7186d3822593aa4393561d186d1393b3923e9d6163d3fbfd6e825e3e6cf3e6a8"
 dependencies = [
  "num-traits",
 ]
@@ -3342,6 +3333,15 @@ dependencies = [
  "bitflags 2.10.0",
 ]
 
+[[package]]
+name = "redox_syscall"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec96166dafa0886eb81fe1c0a388bece180fbef2135f97c1e2cf8302e74b43b5"
+dependencies = [
+ "bitflags 2.10.0",
+]
+
 [[package]]
 name = "redox_users"
 version = "0.4.6"
@@ -3407,9 +3407,9 @@ checksum = "51743d3e274e2b18df81c4dc6caf8a5b8e15dbe799e0dca05c7617380094e884"
 
 [[package]]
 name = "reqwest"
-version = "0.12.24"
+version = "0.12.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d0946410b9f7b082a427e4ef5c8ff541a88b357bc6c637c40db3a68ac70a36f"
+checksum = "3b4c14b2d9afca6a60277086b0cc6a6ae0b568f6f7916c943a8cdc79f8be240f"
 dependencies = [
  "base64 0.22.1",
  "bytes",
@@ -3555,9 +3555,9 @@ dependencies = [
 
 [[package]]
 name = "rustls-pki-types"
-version = "1.13.0"
+version = "1.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94182ad936a0c91c324cd46c6511b9510ed16af436d7b5bab34beab0afd55f7a"
+checksum = "21e6f2ab2928ca4291b86736a8bd920a277a399bba1589409d72154ff87c1282"
 dependencies = [
  "zeroize",
 ]
@@ -3725,9 +3725,9 @@ checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
 [[package]]
 name = "simd-adler32"
-version = "0.3.7"
+version = "0.3.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d66dc143e6b11c1eddc06d5c423cfc97062865baf299914ab64caa38182078fe"
+checksum = "e320a6c5ad31d271ad523dcf3ad13e2767ad8b1cb8f047f75a8aeaf8da139da2"
 
 [[package]]
 name = "simd_helpers"
@@ -3752,9 +3752,9 @@ checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589"
 
 [[package]]
 name = "slotmap"
-version = "1.0.7"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dbff4acf519f630b3a3ddcfaea6c06b42174d9a44bc70c620e9ed1649d58b82a"
+checksum = "bdd58c3c93c3d278ca835519292445cb4b0d4dc59ccfdf7ceadaab3f8aeb4038"
 dependencies = [
  "version_check",
 ]
@@ -4264,18 +4264,18 @@ dependencies = [
 
 [[package]]
 name = "toml_datetime"
-version = "0.7.3"
+version = "0.7.5+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2cdb639ebbc97961c51720f858597f7f24c4fc295327923af55b74c3c724533"
+checksum = "92e1cfed4a3038bc5a127e35a2d360f145e1f4b971b551a2ba5fd7aedf7e1347"
 dependencies = [
  "serde_core",
 ]
 
 [[package]]
 name = "toml_edit"
-version = "0.23.7"
+version = "0.23.10+spec-1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6485ef6d0d9b5d0ec17244ff7eb05310113c3f316f2d14200d4de56b3cb98f8d"
+checksum = "84c8b9f757e028cee9fa244aea147aab2a9ec09d5325a9b01e0a49730c2b5269"
 dependencies = [
  "indexmap",
  "toml_datetime",
@@ -4285,9 +4285,9 @@ dependencies = [
 
 [[package]]
 name = "toml_parser"
-version = "1.0.4"
+version = "1.0.6+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0cbe268d35bdb4bb5a56a2de88d0ad0eb70af5384a99d648cd4b3d04039800e"
+checksum = "a3198b4b0a8e11f09dd03e133c0280504d0801269e9afa46362ffde1cbeebf44"
 dependencies = [
  "winnow",
 ]
@@ -4309,9 +4309,9 @@ dependencies = [
 
 [[package]]
 name = "tower-http"
-version = "0.6.7"
+version = "0.6.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9cf146f99d442e8e68e585f5d798ccd3cad9a7835b917e09728880a862706456"
+checksum = "d4e6559d53cc268e5031cd8429d05415bc4cb4aefc4aa5d6cc35fbf5b924a1f8"
 dependencies = [
  "bitflags 2.10.0",
  "bytes",
@@ -4339,9 +4339,9 @@ checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"
 
 [[package]]
 name = "tracing"
-version = "0.1.41"
+version = "0.1.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "784e0ac535deb450455cbfa28a6f0df145ea1bb7ae51b821cf5e7927fdcfbdd0"
+checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
 dependencies = [
  "pin-project-lite",
  "tracing-attributes",
@@ -4361,9 +4361,9 @@ dependencies = [
 
 [[package]]
 name = "tracing-core"
-version = "0.1.35"
+version = "0.1.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a04e24fab5c89c6a36eb8558c9656f30d81de51dfa4d3b45f26b21d61fa0a6c"
+checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
 dependencies = [
  "once_cell",
 ]
@@ -4644,9 +4644,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.105"
+version = "0.2.106"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da95793dfc411fbbd93f5be7715b0578ec61fe87cb1a42b12eb625caa5c5ea60"
+checksum = "0d759f433fa64a2d763d1340820e46e111a7a5ab75f993d1852d70b03dbb80fd"
 dependencies = [
  "cfg-if",
  "once_cell",
@@ -4657,9 +4657,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.55"
+version = "0.4.56"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "551f88106c6d5e7ccc7cd9a16f312dd3b5d36ea8b4954304657d5dfba115d4a0"
+checksum = "836d9622d604feee9e5de25ac10e3ea5f2d65b41eac0d9ce72eb5deae707ce7c"
 dependencies = [
  "cfg-if",
  "js-sys",
@@ -4670,9 +4670,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.105"
+version = "0.2.106"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04264334509e04a7bf8690f2384ef5265f05143a4bff3889ab7a3269adab59c2"
+checksum = "48cb0d2638f8baedbc542ed444afc0644a29166f1595371af4fecf8ce1e7eeb3"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -4680,9 +4680,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.105"
+version = "0.2.106"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "420bc339d9f322e562942d52e115d57e950d12d88983a14c79b86859ee6c7ebc"
+checksum = "cefb59d5cd5f92d9dcf80e4683949f15ca4b511f4ac0a6e14d4e1ac60c6ecd40"
 dependencies = [
  "bumpalo",
  "proc-macro2",
@@ -4693,9 +4693,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.105"
+version = "0.2.106"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76f218a38c84bcb33c25ec7059b07847d465ce0e0a76b995e134a45adcb6af76"
+checksum = "cbc538057e648b67f72a982e708d485b2efa771e1ac05fec311f9f63e5800db4"
 dependencies = [
  "unicode-ident",
 ]
@@ -4811,9 +4811,9 @@ dependencies = [
 
 [[package]]
 name = "web-sys"
-version = "0.3.82"
+version = "0.3.83"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3a1f95c0d03a47f4ae1f7a64643a6bb97465d9b740f0fa8f90ea33915c99a9a1"
+checksum = "9b32828d774c412041098d182a8b38b16ea816958e07cf40eec2bc080ae137ac"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -4837,12 +4837,13 @@ checksum = "a28ac98ddc8b9274cb41bb4d9d4d5c425b6020c50c46f25559911905610b4a88"
 
 [[package]]
 name = "wgpu"
-version = "27.0.1"
+version = "28.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfe68bac7cde125de7a731c3400723cadaaf1703795ad3f4805f187459cd7a77"
+checksum = "f9cb534d5ffd109c7d1135f34cdae29e60eab94855a625dcfe1705f8bc7ad79f"
 dependencies = [
  "arrayvec",
  "bitflags 2.10.0",
+ "bytemuck",
  "cfg-if",
  "cfg_aliases",
  "document-features",
@@ -4866,9 +4867,9 @@ dependencies = [
 
 [[package]]
 name = "wgpu-core"
-version = "27.0.3"
+version = "28.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "27a75de515543b1897b26119f93731b385a19aea165a1ec5f0e3acecc229cae7"
+checksum = "8bb4c8b5db5f00e56f1f08869d870a0dff7c8bc7ebc01091fec140b0cf0211a9"
 dependencies = [
  "arrayvec",
  "bit-set",
@@ -4898,36 +4899,36 @@ dependencies = [
 
 [[package]]
 name = "wgpu-core-deps-apple"
-version = "27.0.0"
+version = "28.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0772ae958e9be0c729561d5e3fd9a19679bcdfb945b8b1a1969d9bfe8056d233"
+checksum = "87b7b696b918f337c486bf93142454080a32a37832ba8a31e4f48221890047da"
 dependencies = [
  "wgpu-hal",
 ]
 
 [[package]]
 name = "wgpu-core-deps-emscripten"
-version = "27.0.0"
+version = "28.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b06ac3444a95b0813ecfd81ddb2774b66220b264b3e2031152a4a29fda4da6b5"
+checksum = "34b251c331f84feac147de3c4aa3aa45112622a95dd7ee1b74384fa0458dbd79"
 dependencies = [
  "wgpu-hal",
 ]
 
 [[package]]
 name = "wgpu-core-deps-windows-linux-android"
-version = "27.0.0"
+version = "28.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "71197027d61a71748e4120f05a9242b2ad142e3c01f8c1b47707945a879a03c3"
+checksum = "68ca976e72b2c9964eb243e281f6ce7f14a514e409920920dcda12ae40febaae"
 dependencies = [
  "wgpu-hal",
 ]
 
 [[package]]
 name = "wgpu-hal"
-version = "27.0.4"
+version = "28.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b21cb61c57ee198bc4aff71aeadff4cbb80b927beb912506af9c780d64313ce"
+checksum = "293080d77fdd14d6b08a67c5487dfddbf874534bb7921526db56a7b75d7e3bef"
 dependencies = [
  "android_system_properties",
  "arrayvec",
@@ -4941,7 +4942,6 @@ dependencies = [
  "core-graphics-types 0.2.0",
  "glow",
  "glutin_wgl_sys",
- "gpu-alloc",
  "gpu-allocator",
  "gpu-descriptor",
  "hashbrown 0.16.1",
@@ -4969,20 +4969,19 @@ dependencies = [
  "web-sys",
  "wgpu-types",
  "windows",
- "windows-core 0.58.0",
+ "windows-core",
 ]
 
 [[package]]
 name = "wgpu-types"
-version = "27.0.1"
+version = "28.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "afdcf84c395990db737f2dd91628706cb31e86d72e53482320d368e52b5da5eb"
+checksum = "e18308757e594ed2cd27dddbb16a139c42a683819d32a2e0b1b0167552f5840c"
 dependencies = [
  "bitflags 2.10.0",
  "bytemuck",
  "js-sys",
  "log",
- "thiserror 2.0.17",
  "web-sys",
 ]
 
@@ -4997,25 +4996,23 @@ dependencies = [
 
 [[package]]
 name = "windows"
-version = "0.58.0"
+version = "0.62.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd04d41d93c4992d421894c18c8b43496aa748dd4c081bac0dc93eb0489272b6"
+checksum = "527fadee13e0c05939a6a05d5bd6eec6cd2e3dbd648b9f8e447c6518133d8580"
 dependencies = [
- "windows-core 0.58.0",
- "windows-targets 0.52.6",
+ "windows-collections",
+ "windows-core",
+ "windows-future",
+ "windows-numerics",
 ]
 
 [[package]]
-name = "windows-core"
-version = "0.58.0"
+name = "windows-collections"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ba6d44ec8c2591c134257ce647b7ea6b20335bf6379a27dac5f1641fcf59f99"
+checksum = "23b2d95af1a8a14a3c7367e1ed4fc9c20e0a26e79551b1454d72583c97cc6610"
 dependencies = [
- "windows-implement 0.58.0",
- "windows-interface 0.58.0",
- "windows-result 0.2.0",
- "windows-strings 0.1.0",
- "windows-targets 0.52.6",
+ "windows-core",
 ]
 
 [[package]]
@@ -5024,22 +5021,22 @@ version = "0.62.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
 dependencies = [
- "windows-implement 0.60.2",
- "windows-interface 0.59.3",
+ "windows-implement",
+ "windows-interface",
  "windows-link",
- "windows-result 0.4.1",
- "windows-strings 0.5.1",
+ "windows-result",
+ "windows-strings",
 ]
 
 [[package]]
-name = "windows-implement"
-version = "0.58.0"
+name = "windows-future"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2bbd5b46c938e506ecbce286b6628a02171d56153ba733b6c741fc627ec9579b"
+checksum = "e1d6f90251fe18a279739e78025bd6ddc52a7e22f921070ccdc67dde84c605cb"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.111",
+ "windows-core",
+ "windows-link",
+ "windows-threading",
 ]
 
 [[package]]
@@ -5053,17 +5050,6 @@ dependencies = [
  "syn 2.0.111",
 ]
 
-[[package]]
-name = "windows-interface"
-version = "0.58.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "053c4c462dc91d3b1504c6fe5a726dd15e216ba718e84a0e46a88fbe5ded3515"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.111",
-]
-
 [[package]]
 name = "windows-interface"
 version = "0.59.3"
@@ -5081,6 +5067,16 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
 
+[[package]]
+name = "windows-numerics"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e2e40844ac143cdb44aead537bbf727de9b044e107a0f1220392177d15b0f26"
+dependencies = [
+ "windows-core",
+ "windows-link",
+]
+
 [[package]]
 name = "windows-registry"
 version = "0.6.1"
@@ -5088,17 +5084,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "02752bf7fbdcce7f2a27a742f798510f3e5ad88dbe84871e5168e2120c3d5720"
 dependencies = [
  "windows-link",
- "windows-result 0.4.1",
- "windows-strings 0.5.1",
-]
-
-[[package]]
-name = "windows-result"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d1043d8214f791817bab27572aaa8af63732e11bf84aa21a45a78d6c317ae0e"
-dependencies = [
- "windows-targets 0.52.6",
+ "windows-result",
+ "windows-strings",
 ]
 
 [[package]]
@@ -5110,16 +5097,6 @@ dependencies = [
  "windows-link",
 ]
 
-[[package]]
-name = "windows-strings"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4cd9b125c486025df0eabcb585e62173c6c9eddcec5d117d3b6e8c30e2ee4d10"
-dependencies = [
- "windows-result 0.2.0",
- "windows-targets 0.52.6",
-]
-
 [[package]]
 name = "windows-strings"
 version = "0.5.1"
@@ -5246,6 +5223,15 @@ dependencies = [
  "windows_x86_64_msvc 0.53.1",
 ]
 
+[[package]]
+name = "windows-threading"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3949bd5b99cafdf1c7ca86b43ca564028dfe27d66958f2470940f73d86d75b37"
+dependencies = [
+ "windows-link",
+]
+
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.42.2"
@@ -5593,18 +5579,18 @@ dependencies = [
 
 [[package]]
 name = "zerocopy"
-version = "0.8.30"
+version = "0.8.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ea879c944afe8a2b25fef16bb4ba234f47c694565e97383b36f3a878219065c"
+checksum = "fd74ec98b9250adb3ca554bdde269adf631549f51d8a8f8f0a10b50f1cb298c3"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.30"
+version = "0.8.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf955aa904d6040f70dc8e9384444cb1030aed272ba3cb09bbc4ab9e7c1f34f5"
+checksum = "d8a8d209fdf45cf5138cbb5a506f6b52522a25afccc534d1475dad8e31105c6a"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -5743,9 +5729,9 @@ dependencies = [
 
 [[package]]
 name = "zune-jpeg"
-version = "0.5.5"
+version = "0.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc6fb7703e32e9a07fb3f757360338b3a567a5054f21b5f52a666752e333d58e"
+checksum = "51d915729b0e7d5fe35c2f294c5dc10b30207cc637920e5b59077bfa3da63f28"
 dependencies = [
  "zune-core 0.5.0",
 ]

engine/graphics/Cargo.toml

@@ -11,7 +11,7 @@ id = { version = "0.1.0", registry = "strafesnet" }
 strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }
 strafesnet_session = { path = "../session", registry = "strafesnet" }
 strafesnet_settings = { path = "../settings", registry = "strafesnet" }
-wgpu = "27.0.0"
+wgpu = "28.0.0"
 
 [lints]
 workspace = true

engine/graphics/src/graphics.rs

@@ -616,7 +616,7 @@ impl GraphicsState{
 			address_mode_w:wgpu::AddressMode::ClampToEdge,
 			mag_filter:wgpu::FilterMode::Linear,
 			min_filter:wgpu::FilterMode::Linear,
-			mipmap_filter:wgpu::FilterMode::Linear,
+			mipmap_filter:wgpu::MipmapFilterMode::Linear,
 			..Default::default()
 		});
 		let repeat_sampler=device.create_sampler(&wgpu::SamplerDescriptor{
@@ -626,7 +626,7 @@ impl GraphicsState{
 			address_mode_w:wgpu::AddressMode::Repeat,
 			mag_filter:wgpu::FilterMode::Linear,
 			min_filter:wgpu::FilterMode::Linear,
-			mipmap_filter:wgpu::FilterMode::Linear,
+			mipmap_filter:wgpu::MipmapFilterMode::Linear,
 			anisotropy_clamp:16,
 			..Default::default()
 		});
@@ -754,7 +754,7 @@ impl GraphicsState{
 				&skybox_texture_bind_group_layout,
 				&model_bind_group_layout,
 			],
-			push_constant_ranges:&[],
+			immediate_size:0,
 		});
 		let sky_pipeline_layout=device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor{
 			label:None,
@@ -762,7 +762,7 @@ impl GraphicsState{
 				&camera_bind_group_layout,
 				&skybox_texture_bind_group_layout,
 			],
-			push_constant_ranges:&[],
+			immediate_size:0,
 		});
 
 		// Create the render pipelines
@@ -793,7 +793,7 @@ impl GraphicsState{
 				bias:wgpu::DepthBiasState::default(),
 			}),
 			multisample:wgpu::MultisampleState::default(),
-			multiview:None,
+			multiview_mask:None,
 			cache:None,
 		});
 		let model_pipeline=device.create_render_pipeline(&wgpu::RenderPipelineDescriptor{
@@ -828,7 +828,7 @@ impl GraphicsState{
 				bias:wgpu::DepthBiasState::default(),
 			}),
 			multisample:wgpu::MultisampleState::default(),
-			multiview:None,
+			multiview_mask:None,
 			cache:None,
 		});
 
@@ -880,7 +880,7 @@ impl GraphicsState{
 			camera_buf,
 			models:Vec::new(),
 			depth_view,
-			staging_belt:wgpu::util::StagingBelt::new(0x100),
+			staging_belt:wgpu::util::StagingBelt::new(device.clone(),0x100),
 			bind_group_layouts:GraphicsBindGroupLayouts{model:model_bind_group_layout},
 			samplers:GraphicsSamplers{repeat:repeat_sampler},
 			temp_squid_texture_view:squid_texture_view,
@@ -909,7 +909,7 @@ impl GraphicsState{
 
 		// update rotation
 		let camera_uniforms=self.camera.to_uniform_data(
-			frame_state.body.extrapolated_position(frame_state.time).map(Into::<f32>::into).to_array().into(),
+			frame_state.trajectory.extrapolated_position(frame_state.time).map(Into::<f32>::into).to_array().into(),
 			frame_state.camera.simulate_move_angles(glam::IVec2::ZERO)
 		);
 		self.staging_belt
@@ -918,7 +918,6 @@ impl GraphicsState{
 				&self.camera_buf,
 				0,
 				wgpu::BufferSize::new((camera_uniforms.len() * 4) as wgpu::BufferAddress).unwrap(),
-				device,
 			)
 			.copy_from_slice(bytemuck::cast_slice(&camera_uniforms));
 		//This code only needs to run when the uniforms change
@@ -965,6 +964,7 @@ impl GraphicsState{
 				}),
 				timestamp_writes:Default::default(),
 				occlusion_query_set:Default::default(),
+				multiview_mask:None,
 			});
 
 			rpass.set_bind_group(0,&self.bind_groups.camera,&[]);

engine/physics/src/body.rs

@@ -2,12 +2,18 @@ use strafesnet_common::aabb;
 use strafesnet_common::integer::{self,vec3,Time,Planar64,Planar64Vec3};
 #[derive(Clone,Copy,Debug,Hash)]
 pub struct Body<T>{
-	pub position:Planar64Vec3,//I64 where 2^32 = 1 u
-	pub velocity:Planar64Vec3,//I64 where 2^32 = 1 u/s
-	pub acceleration:Planar64Vec3,//I64 where 2^32 = 1 u/s/s
-	pub time:Time<T>,//nanoseconds x xxxxD!
+	pub position:Planar64Vec3,
+	pub velocity:Planar64Vec3,
+	pub time:Time<T>,
 }
-impl<T> std::ops::Neg for Body<T>{
+#[derive(Clone,Copy,Debug,Hash)]
+pub struct Trajectory<T>{
+	pub position:Planar64Vec3,
+	pub velocity:Planar64Vec3,
+	pub acceleration:Planar64Vec3,
+	pub time:Time<T>,
+}
+impl<T> std::ops::Neg for Trajectory<T>{
 	type Output=Self;
 	fn neg(self)->Self::Output{
 		Self{
@@ -18,10 +24,10 @@ impl<T> std::ops::Neg for Body<T>{
 		}
 	}
 }
-impl<T:Copy> std::ops::Neg for &Body<T>{
-	type Output=Body<T>;
+impl<T:Copy> std::ops::Neg for &Trajectory<T>{
+	type Output=Trajectory<T>;
 	fn neg(self)->Self::Output{
-		Body{
+		Trajectory{
 			position:self.position,
 			velocity:-self.velocity,
 			acceleration:self.acceleration,
@@ -32,6 +38,32 @@ impl<T:Copy> std::ops::Neg for &Body<T>{
 
 impl<T> Body<T>
 	where Time<T>:Copy,
+{
+	pub const ZERO:Self=Self::new(vec3::zero(),vec3::zero(),Time::ZERO);
+	pub const fn new(position:Planar64Vec3,velocity:Planar64Vec3,time:Time<T>)->Self{
+		Self{
+			position,
+			velocity,
+			time,
+		}
+	}
+	pub const fn with_acceleration(self,acceleration:Planar64Vec3)->Trajectory<T>{
+		let Body{
+			position,
+			velocity,
+			time,
+		}=self;
+		Trajectory{
+			position,
+			velocity,
+			acceleration,
+			time,
+		}
+	}
+}
+
+impl<T> Trajectory<T>
+	where Time<T>:Copy,
 {
 	pub const ZERO:Self=Self::new(vec3::zero(),vec3::zero(),vec3::zero(),Time::ZERO);
 	pub const fn new(position:Planar64Vec3,velocity:Planar64Vec3,acceleration:Planar64Vec3,time:Time<T>)->Self{
@@ -42,13 +74,14 @@ impl<T> Body<T>
 			time,
 		}
 	}
-	pub const fn relative_to<'a>(&'a self,body0:&'a Body<T>)->VirtualBody<'a,T>{
+	pub fn relative_to(&self,trj0:&Self,time:Time<T>)->Self{
 		//(p0,v0,a0,t0)
 		//(p1,v1,a1,t1)
-		VirtualBody{
-			body0,
-			body1:self,
-		}
+		Trajectory::new(
+			self.extrapolated_position(time)-trj0.extrapolated_position(time),
+			self.extrapolated_velocity(time)-trj0.extrapolated_velocity(time),
+			self.acceleration-trj0.acceleration,
+			time)
 	}
 	pub fn extrapolated_position(&self,time:Time<T>)->Planar64Vec3{
 		let dt=time-self.time;
@@ -60,10 +93,12 @@ impl<T> Body<T>
 		let dt=time-self.time;
 		self.velocity+(self.acceleration*dt).map(|elem|elem.divide().clamp_1())
 	}
-	pub fn advance_time(&mut self,time:Time<T>){
-		self.position=self.extrapolated_position(time);
-		self.velocity=self.extrapolated_velocity(time);
-		self.time=time;
+	pub fn extrapolated_body(&self,time:Time<T>)->Body<T>{
+		Body::new(
+			self.extrapolated_position(time),
+			self.extrapolated_velocity(time),
+			time,
+		)
 	}
 	pub fn extrapolated_position_ratio_dt<Num,Den,N1,D1,N2,N3,D2,N4,T1>(&self,dt:integer::Ratio<Num,Den>)->Planar64Vec3
 		where
@@ -101,10 +136,12 @@ impl<T> Body<T>
 		// a*dt + v
 		self.acceleration.map(|elem|(dt*elem).divide().clamp())+self.velocity
 	}
-	pub fn advance_time_ratio_dt(&mut self,dt:crate::model::GigaTime){
-		self.position=self.extrapolated_position_ratio_dt(dt);
-		self.velocity=self.extrapolated_velocity_ratio_dt(dt);
-		self.time+=dt.into();
+	pub fn extrapolated_body_ratio_dt(&self,dt:crate::model::GigaTime)->Body<T>{
+		Body::new(
+			self.extrapolated_position_ratio_dt(dt),
+			self.extrapolated_velocity_ratio_dt(dt),
+			self.time+dt.into(),
+		)
 	}
 	pub fn infinity_dir(&self)->Option<Planar64Vec3>{
 		if self.velocity==vec3::zero(){
@@ -144,28 +181,12 @@ impl<T> Body<T>
 
 }
 impl<T> std::fmt::Display for Body<T>{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"p({}) v({}) t({})",self.position,self.velocity,self.time)
+	}
+}
+impl<T> std::fmt::Display for Trajectory<T>{
 	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
 		write!(f,"p({}) v({}) a({}) t({})",self.position,self.velocity,self.acceleration,self.time)
 	}
 }
-
-pub struct VirtualBody<'a,T>{
-	body0:&'a Body<T>,
-	body1:&'a Body<T>,
-}
-impl<T> VirtualBody<'_,T>
-	where Time<T>:Copy,
-{
-	pub fn extrapolated_position(&self,time:Time<T>)->Planar64Vec3{
-		self.body1.extrapolated_position(time)-self.body0.extrapolated_position(time)
-	}
-	pub fn extrapolated_velocity(&self,time:Time<T>)->Planar64Vec3{
-		self.body1.extrapolated_velocity(time)-self.body0.extrapolated_velocity(time)
-	}
-	pub fn acceleration(&self)->Planar64Vec3{
-		self.body1.acceleration-self.body0.acceleration
-	}
-	pub fn body(&self,time:Time<T>)->Body<T>{
-		Body::new(self.extrapolated_position(time),self.extrapolated_velocity(time),self.acceleration(),time)
-	}
-}

engine/physics/src/face_crawler.rs

@@ -1,32 +1,27 @@
-use crate::model::{into_giga_time,GigaTime,FEV,MeshQuery,DirectedEdge};
-use strafesnet_common::integer::{Fixed,Ratio,vec3::Vector3};
-use crate::physics::{Time,Body};
+use crate::model::{into_giga_time,GigaTime};
+use strafesnet_common::integer::{Fixed,Ratio,vec3::Vector3,Planar64Vec3};
+use crate::physics::{Time,Trajectory};
+use crate::mesh_query::{FEV,DirectedEdge,MeshQuery,MeshTopology};
 
 use core::ops::Bound;
 
-enum Transition<M:MeshQuery>{
+enum Transition<M:MeshTopology>{
 	Miss,
 	Next(FEV<M>,GigaTime),
 	Hit(M::Face,GigaTime),
 }
 
-pub enum CrawlResult<M:MeshQuery>{
+pub enum CrawlResult<M:MeshTopology>{
 	Miss(FEV<M>),
 	Hit(M::Face,GigaTime),
 }
-impl<M:MeshQuery> CrawlResult<M>{
+impl<M:MeshTopology> CrawlResult<M>{
 	pub fn hit(self)->Option<(M::Face,GigaTime)>{
 		match self{
 			CrawlResult::Miss(_)=>None,
 			CrawlResult::Hit(face,time)=>Some((face,time)),
 		}
 	}
-	pub fn miss(self)->Option<FEV<M>>{
-		match self{
-			CrawlResult::Miss(fev)=>Some(fev),
-			CrawlResult::Hit(_,_)=>None,
-		}
-	}
 }
 
 // TODO: move predict_collision_face_out algorithm in here or something
@@ -70,17 +65,18 @@ where
 	}
 }
 
-impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
+impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>,Position=Planar64Vec3,Direction=Planar64Vec3>> FEV<M>
 	where
 		// This is hardcoded for MinkowskiMesh lol
 		M::Face:Copy,
-		M::Edge:Copy+core::fmt::Debug,
-		M::Vert:Copy+core::fmt::Debug,
+		M::Edge:Copy,
+		M::DirectedEdge:Copy,
+		M::Vert:Copy,
 		F:core::ops::Mul<Fixed<1,32>,Output=Fixed<4,128>>,
 		<F as core::ops::Mul<Fixed<1,32>>>::Output:core::iter::Sum,
 		M::Offset:core::ops::Sub<<F as std::ops::Mul<Fixed<1,32>>>::Output>,
 {
-	fn next_transition<const ENABLE_DEBUG:bool>(&self,mesh:&M,body:&Body,lower_bound:Bound<GigaTime>,mut upper_bound:Bound<GigaTime>)->Transition<M>{
+	fn next_transition(&self,mesh:&M,trajectory:&Trajectory,lower_bound:Bound<GigaTime>,mut upper_bound:Bound<GigaTime>)->Transition<M>{
 		//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_transition=Transition::Miss;
@@ -92,29 +88,29 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 				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.
-				for dt in Fixed::<4,128>::zeroes2((n.dot(body.position)-d)*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
-					if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+				for dt in Fixed::<4,128>::zeroes2((n.dot(trajectory.position)-d)*2,n.dot(trajectory.velocity)*2,n.dot(trajectory.acceleration)){
+					if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(trajectory.extrapolated_velocity_ratio_dt(dt)).is_negative(){
 						upper_bound=Bound::Included(dt);
 						best_transition=Transition::Hit(face_id,dt);
 						break;
 					}
 				}
 				//test each edge collision time, ignoring roots with zero or conflicting derivative
-				for &directed_edge_id in mesh.face_edges(face_id).as_ref(){
+				mesh.for_each_face_edge(face_id,|directed_edge_id|{
 					let edge_n=mesh.directed_edge_n(directed_edge_id);
 					let n=n.cross(edge_n);
 					let &[v0,v1]=mesh.edge_verts(directed_edge_id.as_undirected()).as_ref();
 					//WARNING: d is moved out of the *2 block because of adding two vertices!
 					//WARNING: precision is swept under the rug!
 					//wrap for speed
-					for dt in Fixed::<4,128>::zeroes2(n.dot(body.position*2-(mesh.vert(v0)+mesh.vert(v1))).wrap_4(),n.dot(body.velocity).wrap_4()*2,n.dot(body.acceleration).wrap_4()){
-						if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+					for dt in Fixed::<4,128>::zeroes2(n.dot(trajectory.position*2-(mesh.vert(v0)+mesh.vert(v1))).wrap_4(),n.dot(trajectory.velocity).wrap_4()*2,n.dot(trajectory.acceleration).wrap_4()){
+						if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(trajectory.extrapolated_velocity_ratio_dt(dt)).is_negative(){
 							upper_bound=Bound::Included(dt);
 							best_transition=Transition::Next(FEV::Edge(directed_edge_id.as_undirected()),dt);
 							break;
 						}
 					}
-				}
+				});
 				//if none:
 			},
 			&FEV::Edge(edge_id)=>{
@@ -123,18 +119,15 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 				let &[ev0,ev1]=edge_verts.as_ref();
 				let (v0,v1)=(mesh.vert(ev0),mesh.vert(ev1));
 				let edge_n=v1-v0;
-				let delta_pos=body.position*2-(v0+v1);
+				let delta_pos=trajectory.position*2-(v0+v1);
 				for (i,&edge_face_id) in mesh.edge_faces(edge_id).as_ref().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);
 					//WARNING yada yada d *2
 					//wrap for speed
-					for dt in Fixed::<4,128>::zeroes2(n.dot(delta_pos).wrap_4(),n.dot(body.velocity).wrap_4()*2,n.dot(body.acceleration).wrap_4()){
-						if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
-							if ENABLE_DEBUG{
-								println!("Face Crawler FEV::Edge({edge_id:?}) -> FEV::Face");
-							}
+					for dt in Fixed::<4,128>::zeroes2(n.dot(delta_pos).wrap_4(),n.dot(trajectory.velocity).wrap_4()*2,n.dot(trajectory.acceleration).wrap_4()){
+						if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(trajectory.extrapolated_velocity_ratio_dt(dt)).is_negative(){
 							upper_bound=Bound::Included(dt);
 							best_transition=Transition::Next(FEV::Face(edge_face_id),dt);
 							break;
@@ -145,8 +138,8 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 				for (i,&vert_id) in edge_verts.as_ref().iter().enumerate(){
 					//vertex normal gets parity from vert index
 					let n=edge_n*(1-2*(i as i64));
-					for dt in Fixed::<2,64>::zeroes2((n.dot(body.position-mesh.vert(vert_id)))*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
-						if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+					for dt in Fixed::<2,64>::zeroes2((n.dot(trajectory.position-mesh.vert(vert_id)))*2,n.dot(trajectory.velocity)*2,n.dot(trajectory.acceleration)){
+						if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(trajectory.extrapolated_velocity_ratio_dt(dt)).is_negative(){
 							let dt=Ratio::new(dt.num.widen_4(),dt.den.widen_4());
 							upper_bound=Bound::Included(dt);
 							best_transition=Transition::Next(FEV::Vert(vert_id),dt);
@@ -158,31 +151,28 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 			},
 			&FEV::Vert(vert_id)=>{
 				//test each edge collision time, ignoring roots with zero or conflicting derivative
-				for &directed_edge_id in mesh.vert_edges(vert_id).as_ref(){
+				mesh.for_each_vert_edge(vert_id,|directed_edge_id|{
 					//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 dt in Fixed::<2,64>::zeroes2((n.dot(body.position-mesh.vert(vert_id)))*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
-						if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
-							if ENABLE_DEBUG{
-								println!("Face Crawler FEV::Vert({vert_id:?}) -> FEV::Edge");
-							}
+					for dt in Fixed::<2,64>::zeroes2((n.dot(trajectory.position-mesh.vert(vert_id)))*2,n.dot(trajectory.velocity)*2,n.dot(trajectory.acceleration)){
+						if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(trajectory.extrapolated_velocity_ratio_dt(dt)).is_negative(){
 							let dt=Ratio::new(dt.num.widen_4(),dt.den.widen_4());
 							upper_bound=Bound::Included(dt);
 							best_transition=Transition::Next(FEV::Edge(directed_edge_id.as_undirected()),dt);
 							break;
 						}
 					}
-				}
+				});
 				//if none:
 			},
 		}
 		best_transition
 	}
-	pub fn crawl<const ENABLE_DEBUG:bool>(mut self,mesh:&M,relative_body:&Body,lower_bound:Bound<&Time>,upper_bound:Bound<&Time>)->CrawlResult<M>{
-		let mut lower_bound=lower_bound.map(|&t|into_giga_time(t,relative_body.time));
-		let upper_bound=upper_bound.map(|&t|into_giga_time(t,relative_body.time));
+	pub fn crawl(mut self,mesh:&M,trajectory:&Trajectory,lower_bound:Bound<&Time>,upper_bound:Bound<&Time>)->CrawlResult<M>{
+		let mut lower_bound=lower_bound.map(|&t|into_giga_time(t,trajectory.time));
+		let upper_bound=upper_bound.map(|&t|into_giga_time(t,trajectory.time));
 		for _ in 0..20{
-			match self.next_transition::<ENABLE_DEBUG>(mesh,relative_body,lower_bound,upper_bound){
+			match self.next_transition(mesh,trajectory,lower_bound,upper_bound){
 				Transition::Miss=>return CrawlResult::Miss(self),
 				Transition::Next(next_fev,next_time)=>(self,lower_bound)=(next_fev,Bound::Included(next_time)),
 				Transition::Hit(face,time)=>return CrawlResult::Hit(face,time),

engine/physics/src/lib.rs

@@ -1,7 +1,10 @@
 mod body;
-mod push_solve;
 mod face_crawler;
+mod mesh_query;
+mod minkowski;
 mod model;
+mod push_solve;
+mod minimum_difference;
 
 pub mod physics;
 

engine/physics/src/mesh_query.rs

@@ -0,0 +1,56 @@
+pub enum FEV<M:MeshTopology>{
+	Vert(M::Vert),
+	Edge(M::Edge),
+	Face(M::Face),
+}
+
+pub trait UndirectedEdge{
+	type DirectedEdge:DirectedEdge<UndirectedEdge=Self>;
+	fn as_directed(self,parity:bool)->Self::DirectedEdge;
+}
+pub trait DirectedEdge{
+	type UndirectedEdge:UndirectedEdge<DirectedEdge=Self>;
+	fn as_undirected(self)->Self::UndirectedEdge;
+	fn parity(&self)->bool;
+	fn reverse(self)->Self
+		where
+			Self:Sized
+	{
+		let parity=!self.parity();
+		self.as_undirected().as_directed(parity)
+	}
+}
+
+pub trait MeshTopology{
+	type Face;
+	type Edge:UndirectedEdge<DirectedEdge=Self::DirectedEdge>;
+	type DirectedEdge:DirectedEdge<UndirectedEdge=Self::Edge>;
+	type Vert;
+	fn for_each_vert_edge(&self,vert_id:Self::Vert,f:impl FnMut(Self::DirectedEdge));
+	fn for_each_vert_face(&self,vert_id:Self::Vert,f:impl FnMut(Self::Face));
+	fn edge_faces(&self,edge_id:Self::Edge)->impl AsRef<[Self::Face;2]>;
+	fn edge_verts(&self,edge_id:Self::Edge)->impl AsRef<[Self::Vert;2]>;
+	#[expect(unused)]
+	fn for_each_face_vert(&self,face_id:Self::Face,f:impl FnMut(Self::Vert));
+	fn for_each_face_edge(&self,face_id:Self::Face,f:impl FnMut(Self::DirectedEdge));
+}
+
+// Make face_nd d value relative
+// euclidean point?
+// Simplex physics
+// Directed edge necessary?
+// recursive for_each function calls
+// define faces from vertices (Fixed<2> vs Fixed<3>)
+pub trait MeshQuery:MeshTopology{
+	type Position;
+	type Direction;
+	type Normal;
+	type Offset;
+	fn vert(&self,vert_id:Self::Vert)->Self::Position;
+	fn farthest_vert(&self,dir:Self::Direction)->Self::Vert;
+	/// This must return a point inside the mesh.
+	fn hint_point(&self)->Self::Position;
+	fn face_nd(&self,face_id:Self::Face)->(Self::Normal,Self::Offset);
+	fn edge_n(&self,edge_id:Self::Edge)->Self::Direction;
+	fn directed_edge_n(&self,directed_edge_id:Self::DirectedEdge)->Self::Direction;
+}

engine/physics/src/minimum_difference.rs

@@ -0,0 +1,923 @@
+use strafesnet_common::integer::vec3;
+use strafesnet_common::integer::vec3::Vector3;
+use strafesnet_common::integer::{Fixed,Planar64,Planar64Vec3};
+
+use crate::mesh_query::{FEV,DirectedEdge,MeshQuery,MeshTopology};
+// TODO: remove mesh invert
+use crate::minkowski::{MinkowskiMesh,MinkowskiVert};
+
+// This algorithm is based on Lua code
+// written by Trey Reynolds in 2021
+
+type Simplex<const N:usize,Vert>=[Vert;N];
+#[derive(Clone,Copy)]
+enum Simplex1_3<Vert>{
+	Simplex1(Simplex<1,Vert>),
+	Simplex2(Simplex<2,Vert>),
+	Simplex3(Simplex<3,Vert>),
+}
+impl<Vert> Simplex1_3<Vert>{
+	fn push_front(self,v:Vert)->Simplex2_4<Vert>{
+		match self{
+			Simplex1_3::Simplex1([v0])=>Simplex2_4::Simplex2([v,v0]),
+			Simplex1_3::Simplex2([v0,v1])=>Simplex2_4::Simplex3([v,v0,v1]),
+			Simplex1_3::Simplex3([v0,v1,v2])=>Simplex2_4::Simplex4([v,v0,v1,v2]),
+		}
+	}
+}
+#[derive(Clone,Copy)]
+enum Simplex2_4<Vert>{
+	Simplex2(Simplex<2,Vert>),
+	Simplex3(Simplex<3,Vert>),
+	Simplex4(Simplex<4,Vert>),
+}
+
+/*
+local function absDet(r, u, v, w)
+	if w then
+		return math.abs((u - r):Cross(v - r):Dot(w - r))
+	elseif v then
+		return (u - r):Cross(v - r).magnitude
+	elseif u then
+		return (u - r).magnitude
+	else
+		return 1
+	end
+end
+*/
+impl<Vert> Simplex2_4<Vert>{
+	fn det_is_zero<M:MeshQuery<Vert=Vert,Position=Planar64Vec3>>(self,mesh:&M)->bool{
+		match self{
+			Self::Simplex4([p0,p1,p2,p3])=>{
+				let p0=mesh.vert(p0);
+				let p1=mesh.vert(p1);
+				let p2=mesh.vert(p2);
+				let p3=mesh.vert(p3);
+				(p1-p0).cross(p2-p0).dot(p3-p0)==Fixed::ZERO
+			},
+			Self::Simplex3([p0,p1,p2])=>{
+				let p0=mesh.vert(p0);
+				let p1=mesh.vert(p1);
+				let p2=mesh.vert(p2);
+				(p1-p0).cross(p2-p0)==vec3::zero()
+			},
+			Self::Simplex2([p0,p1])=>{
+				let p0=mesh.vert(p0);
+				let p1=mesh.vert(p1);
+				p1-p0==vec3::zero()
+			}
+		}
+	}
+}
+
+/*
+local function choosePerpendicularDirection(d)
+	local x, y, z = d.x, d.y, d.z
+	local best = math.min(x*x, y*y, z*z)
+	if x*x == best then
+		return Vector3.new(y*y + z*z, -x*y, -x*z)
+	elseif y*y == best then
+		return Vector3.new(-x*y, x*x + z*z, -y*z)
+	else
+		return Vector3.new(-x*z, -y*z, x*x + y*y)
+	end
+end
+*/
+fn choose_perpendicular_direction(d:Planar64Vec3)->Planar64Vec3{
+	let x=d.x.abs();
+	let y=d.y.abs();
+	let z=d.z.abs();
+	if x<y&&x<z{
+		Vector3::new([Fixed::ZERO,-d.z,d.y])
+	}else if y<z{
+		Vector3::new([d.z,Fixed::ZERO,-d.x])
+	}else{
+		Vector3::new([-d.y,d.x,Fixed::ZERO])
+	}
+}
+
+const fn choose_any_direction()->Planar64Vec3{
+	vec3::X
+}
+
+fn narrow_dir2(dir:Vector3<Fixed<2,64>>)->Planar64Vec3{
+	if dir==vec3::zero(){
+		return dir.narrow_1().unwrap();
+	}
+	let x=dir.x.as_bits().unsigned_abs().bits();
+	let y=dir.y.as_bits().unsigned_abs().bits();
+	let z=dir.z.as_bits().unsigned_abs().bits();
+	let big=x.max(y).max(z);
+	const MAX_BITS:u32=64+31;
+	if MAX_BITS<big{
+		dir>>(big-MAX_BITS)
+	}else{
+		dir
+	}.narrow_1().unwrap()
+}
+fn narrow_dir3(dir:Vector3<Fixed<3,96>>)->Planar64Vec3{
+	if dir==vec3::zero(){
+		return dir.narrow_1().unwrap();
+	}
+	let x=dir.x.as_bits().unsigned_abs().bits();
+	let y=dir.y.as_bits().unsigned_abs().bits();
+	let z=dir.z.as_bits().unsigned_abs().bits();
+	let big=x.max(y).max(z);
+	const MAX_BITS:u32=96+31;
+	if MAX_BITS<big{
+		dir>>(big-MAX_BITS)
+	}else{
+		dir
+	}.narrow_1().unwrap()
+}
+
+fn reduce1<M:MeshQuery<Position=Planar64Vec3>>(
+	[v0]:Simplex<1,M::Vert>,
+	mesh:&M,
+	point:Planar64Vec3,
+)->Reduced<M::Vert>
+	where M::Vert:Copy,
+{
+	// --debug.profilebegin("reduceSimplex0")
+	// local a = a1 - a0
+	let p0=mesh.vert(v0);
+
+	// local p = -a
+	let p=-(p0+point);
+
+	// local direction = p
+	let mut dir=p;
+
+	// if direction.magnitude == 0 then
+	// 	direction = chooseAnyDirection()
+	if dir==vec3::zero(){
+		dir=choose_any_direction();
+	}
+
+	// return direction, a0, a1
+	Reduced{
+		dir,
+		simplex:Simplex1_3::Simplex1([v0]),
+	}
+}
+
+// local function reduceSimplex1(a0, a1, b0, b1)
+fn reduce2<M:MeshQuery<Position=Planar64Vec3>>(
+	[v0,v1]:Simplex<2,M::Vert>,
+	mesh:&M,
+	point:Planar64Vec3,
+)->Reduced<M::Vert>
+	where
+		M::Vert:Copy
+{
+	// --debug.profilebegin("reduceSimplex1")
+	// local a = a1 - a0
+	// local b = b1 - b0
+	let p0=mesh.vert(v0);
+	let p1=mesh.vert(v1);
+
+	// local p = -a
+	// local u = b - a
+	let p=-(p0+point);
+	let u=p1-p0;
+
+	// -- modify to take into account the radiuses
+	// local p_u = p:Dot(u)
+	let p_u=p.dot(u);
+
+	// if p_u >= 0 then
+	if !p_u.is_negative(){
+		// local direction = u:Cross(p):Cross(u)
+		let direction=u.cross(p).cross(u);
+
+		// if direction.magnitude == 0 then
+		if direction==vec3::zero(){
+			return Reduced{
+				dir:choose_perpendicular_direction(u),
+				simplex:Simplex1_3::Simplex2([v0,v1]),
+			};
+		}
+
+		// -- modify the direction to take into account a0R and b0R
+		// return direction, a0, a1, b0, b1
+		return Reduced{
+			dir:narrow_dir3(direction),
+			simplex:Simplex1_3::Simplex2([v0,v1]),
+		};
+	}
+
+	// local direction = p
+	let mut dir=p;
+
+	// if direction.magnitude == 0 then
+	if dir==vec3::zero(){
+		dir=choose_perpendicular_direction(u);
+	}
+
+	// return direction, a0, a1
+	Reduced{
+		dir,
+		simplex:Simplex1_3::Simplex1([v0]),
+	}
+}
+
+// local function reduceSimplex2(a0, a1, b0, b1, c0, c1)
+fn reduce3<M:MeshQuery<Position=Planar64Vec3>>(
+	[v0,mut v1,v2]:Simplex<3,M::Vert>,
+	mesh:&M,
+	point:Planar64Vec3,
+)->Reduced<M::Vert>
+	where
+		M::Vert:Copy
+{
+	// --debug.profilebegin("reduceSimplex2")
+	// local a = a1 - a0
+	// local b = b1 - b0
+	// local c = c1 - c0
+	let p0=mesh.vert(v0);
+	let p1=mesh.vert(v1);
+	let p2=mesh.vert(v2);
+
+	// local p = -a
+	// local u = b - a
+	// local v = c - a
+	let p=-(p0+point);
+	let mut u=p1-p0;
+	let v=p2-p0;
+
+	// local uv = u:Cross(v)
+	// local up = u:Cross(p)
+	// local pv = p:Cross(v)
+	// local uv_up = uv:Dot(up)
+	// local uv_pv = uv:Dot(pv)
+	let mut uv=u.cross(v);
+	let mut up=u.cross(p);
+	let pv=p.cross(v);
+	let uv_up=uv.dot(up);
+	let uv_pv=uv.dot(pv);
+
+	// if uv_up >= 0 and uv_pv >= 0 then
+	if !uv_up.is_negative()&&!uv_pv.is_negative(){
+		// local uvp = uv:Dot(p)
+		let uvp=uv.dot(p);
+
+		// local direction = uvp < 0 and -uv or uv
+		let direction=if uvp.is_negative(){
+			-uv
+		}else{
+			uv
+		};
+
+		// return direction, a0, a1, b0, b1, c0, c1
+		return Reduced{
+			dir:narrow_dir2(direction),
+			simplex:Simplex1_3::Simplex3([v0,v1,v2]),
+		};
+	}
+
+	// local u_u = u:Dot(u)
+	// local v_v = v:Dot(v)
+	// local uDist = uv_up/(u_u*v.magnitude)
+	// local vDist = uv_pv/(v_v*u.magnitude)
+	// local minDist2 = math.min(uDist, vDist)
+	let u_dist=uv_up*v.length();
+	let v_dist=uv_pv*u.length();
+
+	// if vDist == minDist2 then
+	if v_dist<u_dist{
+		u=v;
+		up=-pv;
+		uv=-uv;
+		// b0 = c0
+		// b1 = c1
+		v1=v2;
+	}
+
+	// local p_u = p:Dot(u)
+	let p_u=p.dot(u);
+
+	// if p_u >= 0 then
+	if !p_u.is_negative(){
+		// local direction = up:Cross(u)
+		let direction=up.cross(u);
+		// if direction.magnitude == 0 then
+		if direction==vec3::zero(){
+			// direction = uv
+			return Reduced{
+				dir:narrow_dir2(uv),
+				simplex:Simplex1_3::Simplex2([v0,v1]),
+			};
+		}
+
+		// return direction, a0, a1, b0, b1
+		return Reduced{
+			dir:narrow_dir3(direction),
+			simplex:Simplex1_3::Simplex2([v0,v1]),
+		};
+	}
+
+	// local direction = p
+	let dir=p;
+	// if direction.magnitude == 0 then
+	if dir==vec3::zero(){
+		// direction = uv
+		return Reduced{
+			dir:narrow_dir2(uv),
+			simplex:Simplex1_3::Simplex1([v0]),
+		};
+	}
+	// return direction, a0, a0
+	Reduced{
+		dir,
+		simplex:Simplex1_3::Simplex1([v0]),
+	}
+}
+
+// local function reduceSimplex3(a0, a1, b0, b1, c0, c1, d0, d1)
+fn reduce4<M:MeshQuery<Position=Planar64Vec3>>(
+	[v0,mut v1,mut v2,v3]:Simplex<4,M::Vert>,
+	mesh:&M,
+	point:Planar64Vec3,
+)->Reduce<M::Vert>
+	where
+		M::Vert:Copy
+{
+	// --debug.profilebegin("reduceSimplex3")
+	// local a = a1 - a0
+	// local b = b1 - b0
+	// local c = c1 - c0
+	// local d = d1 - d0
+	let p0=mesh.vert(v0);
+	let p1=mesh.vert(v1);
+	let p2=mesh.vert(v2);
+	let p3=mesh.vert(v3);
+
+	// local p = -a
+	// local u = b - a
+	// local v = c - a
+	// local w = d - a
+	let p=-(p0+point);
+	let mut u=p1-p0;
+	let mut v=p2-p0;
+	let w=p3-p0;
+
+	// local uv = u:Cross(v)
+	// local vw = v:Cross(w)
+	// local wu = w:Cross(u)
+	// local uvw = uv:Dot(w)
+	// local pvw = vw:Dot(p)
+	// local upw = wu:Dot(p)
+	// local uvp = uv:Dot(p)
+	let mut uv=u.cross(v);
+	let vw=v.cross(w);
+	let wu=w.cross(u);
+	let uv_w=uv.dot(w);
+	let pv_w=vw.dot(p);
+	let up_w=wu.dot(p);
+	let uv_p=uv.dot(p);
+
+	// if pvw/uvw >= 0 and upw/uvw >= 0 and uvp/uvw >= 0 then
+	if !pv_w.div_sign(uv_w).is_negative()
+	 &&!up_w.div_sign(uv_w).is_negative()
+	 &&!uv_p.div_sign(uv_w).is_negative(){
+		// origin is contained, this is a positive detection
+		// local direction = Vector3.new(0, 0, 0)
+		// return direction, a0, a1, b0, b1, c0, c1, d0, d1
+		return Reduce::Escape([v0,v1,v2,v3]);
+	}
+
+	// local uvwSign = uvw < 0 and -1 or uvw > 0 and 1 or 0
+	// local uvDist = uvp*uvwSign/uv.magnitude
+	// local vwDist = pvw*uvwSign/vw.magnitude
+	// local wuDist = upw*uvwSign/wu.magnitude
+	// local minDist3 = math.min(uvDist, vwDist, wuDist)
+	let uv_dist=uv_p.mul_sign(uv_w);
+	let vw_dist=pv_w.mul_sign(uv_w);
+	let wu_dist=up_w.mul_sign(uv_w);
+	let wu_len=wu.length();
+	let uv_len=uv.length();
+	let vw_len=vw.length();
+
+	if vw_dist*wu_len<wu_dist*vw_len{
+		// if vwDist == minDist3 then
+		if vw_dist*uv_len<uv_dist*vw_len{
+			(u,v)=(v,w);
+			uv=vw;
+			// uv_p=pv_w; // unused
+			// b0, c0 = c0, d0
+			// b1, c1 = c1, d1
+			(v1,v2)=(v2,v3);
+		}
+	}else{
+		// elseif wuDist == minDist3 then
+		if wu_dist*uv_len<uv_dist*wu_len{
+			(u,v)=(w,u);
+			uv=wu;
+			// uv_p=up_w; // unused
+			// b0, c0 = d0, b0
+			// b1, c1 = d1, b1
+			// before [a,b,c,d]
+			(v1,v2)=(v3,v1);
+			// after [a,d,b]
+		}
+	}
+
+	// local up = u:Cross(p)
+	// local pv = p:Cross(v)
+	// local uv_up = uv:Dot(up)
+	// local uv_pv = uv:Dot(pv)
+	let mut up=u.cross(p);
+	let pv=p.cross(v);
+	let uv_up=uv.dot(up);
+	let uv_pv=uv.dot(pv);
+
+	// if uv_up >= 0 and uv_pv >= 0 then
+	if !uv_up.is_negative()&&!uv_pv.is_negative(){
+		// local direction = uvw < 0 and uv or -uv
+		// return direction, a0, a1, b0, b1, c0, c1
+		let dir=if uv_w.is_negative(){
+			narrow_dir2(uv)
+		}else{
+			narrow_dir2(-uv)
+		};
+		return Reduce::Reduced(Reduced{
+			dir,
+			simplex:Simplex1_3::Simplex3([v0,v1,v2]),
+		});
+	}
+
+	// local u_u = u:Dot(u)
+	// local v_v = v:Dot(v)
+	// local uDist = uv_up/(u_u*v.magnitude)
+	// local vDist = uv_pv/(v_v*u.magnitude)
+	// local minDist2 = math.min(uDist, vDist)
+	let u_dist=uv_up*v.length();
+	let v_dist=uv_pv*u.length();
+
+	// if vDist == minDist2 then
+	if v_dist<u_dist{
+		u=v;
+		up=-pv;
+		uv=-uv;
+		// b0 = c0
+		// b1 = c1
+		v1=v2;
+	}
+
+	// local p_u = p:Dot(u)
+	let p_u=p.dot(u);
+
+	// if p_u >= 0 then
+	if !p_u.is_negative(){
+		// local direction = up:Cross(u)
+		let direction=up.cross(u);
+		// if direction.magnitude == 0 then
+		if direction==vec3::zero(){
+			// direction = uvw < 0 and uv or -uv
+			// return direction, a0, a1, b0, b1
+			let dir=if uv_w.is_negative(){
+				narrow_dir2(uv)
+			}else{
+				narrow_dir2(-uv)
+			};
+			return Reduce::Reduced(Reduced{
+				dir,
+				simplex:Simplex1_3::Simplex2([v0,v1]),
+			});
+		}
+
+		// return direction, a0, a1, b0, b1
+		return Reduce::Reduced(Reduced{
+			dir:narrow_dir3(direction),
+			simplex:Simplex1_3::Simplex2([v0,v1]),
+		});
+	}
+
+	// local direction = p
+	let dir=p;
+	// if direction.magnitude == 0 then
+	if dir==vec3::zero(){
+		// direction = uvw < 0 and uv or -uv
+		let dir=if uv_w.is_negative(){
+			narrow_dir2(uv)
+		}else{
+			narrow_dir2(-uv)
+		};
+		return Reduce::Reduced(Reduced{
+			dir,
+			simplex:Simplex1_3::Simplex1([v0]),
+		});
+	}
+
+	// return direction, a0, a1
+	Reduce::Reduced(Reduced{
+		dir,
+		simplex:Simplex1_3::Simplex1([v0]),
+	})
+}
+
+struct Reduced<Vert>{
+	dir:Planar64Vec3,
+	simplex:Simplex1_3<Vert>,
+}
+
+enum Reduce<Vert>{
+	Escape(Simplex<4,Vert>),
+	Reduced(Reduced<Vert>),
+}
+
+impl<Vert> Simplex2_4<Vert>{
+	fn reduce<M:MeshQuery<Vert=Vert,Position=Planar64Vec3>>(self,mesh:&M,point:Planar64Vec3)->Reduce<Vert>
+		where
+			M::Vert:Copy
+	{
+		match self{
+			Self::Simplex2(simplex)=>Reduce::Reduced(reduce2(simplex,mesh,point)),
+			Self::Simplex3(simplex)=>Reduce::Reduced(reduce3(simplex,mesh,point)),
+			Self::Simplex4(simplex)=>reduce4(simplex,mesh,point),
+		}
+	}
+}
+
+//infinity fev algorithm state transition
+#[derive(Debug)]
+enum Transition<Vert>{
+	Done,//found closest vert, no edges are better
+	Vert(Vert),//transition to vert
+}
+enum EV<M:MeshTopology>{
+	Vert(M::Vert),
+	Edge(M::Edge),
+}
+impl<M:MeshTopology> From<EV<M>> for FEV<M>{
+	fn from(value:EV<M>)->Self{
+		match value{
+			EV::Vert(minkowski_vert)=>FEV::Vert(minkowski_vert),
+			EV::Edge(minkowski_edge)=>FEV::Edge(minkowski_edge),
+		}
+	}
+}
+
+trait Contains{
+	fn contains(&self,point:Planar64Vec3)->bool;
+}
+
+// convenience type to check if a point is within some threshold of a plane.
+struct ThickPlane{
+	point:Planar64Vec3,
+	normal:Vector3<Fixed<2,64>>,
+	epsilon:Fixed<3,96>,
+}
+impl ThickPlane{
+	fn new<M:MeshQuery<Position=Planar64Vec3>>(mesh:&M,[v0,v1,v2]:Simplex<3,M::Vert>)->Self{
+		let p0=mesh.vert(v0);
+		let p1=mesh.vert(v1);
+		let p2=mesh.vert(v2);
+		let point=p0;
+		let normal=(p1-p0).cross(p2-p0);
+		// Allow ~ 2*sqrt(3) units of thickness on the plane
+		// This is to account for the variance of two voxels across the longest diagonal
+		let epsilon=(normal.length()*(Planar64::EPSILON*3)).wrap_3();
+		Self{point,normal,epsilon}
+	}
+}
+impl Contains for ThickPlane{
+	fn contains(&self,point:Planar64Vec3)->bool{
+		(point-self.point).dot(self.normal).abs()<=self.epsilon
+	}
+}
+
+struct ThickLine{
+	point:Planar64Vec3,
+	dir:Planar64Vec3,
+	epsilon:Fixed<4,128>,
+}
+impl ThickLine{
+	fn new<M:MeshQuery<Position=Planar64Vec3>>(mesh:&M,[v0,v1]:Simplex<2,M::Vert>)->Self{
+		let p0=mesh.vert(v0);
+		let p1=mesh.vert(v1);
+		let point=p0;
+		let dir=p1-p0;
+		// Allow ~ 2*sqrt(3) units of thickness on the plane
+		// This is to account for the variance of two voxels across the longest diagonal
+		let epsilon=(dir.length_squared()*(Planar64::EPSILON*3)).widen_4();
+		Self{point,dir,epsilon}
+	}
+}
+impl Contains for ThickLine{
+	fn contains(&self,point:Planar64Vec3)->bool{
+		(point-self.point).cross(self.dir).length_squared()<=self.epsilon
+	}
+}
+
+struct EVFinder<'a,M,C>{
+	mesh:&'a M,
+	constraint:C,
+	best_distance_squared:Fixed<2,64>,
+}
+
+impl<M:MeshQuery<Position=Planar64Vec3>,C:Contains> EVFinder<'_,M,C>
+	where
+		M::Vert:Copy,
+		M::DirectedEdge:Copy,
+{
+	fn next_transition_vert(&mut self,vert_id:M::Vert,point:Planar64Vec3)->Transition<M::Vert>{
+		let mut best_transition=Transition::Done;
+		self.mesh.for_each_vert_edge(vert_id,|directed_edge_id|{
+			//test if this edge's opposite vertex closer
+			let edge_verts=self.mesh.edge_verts(directed_edge_id.as_undirected());
+			//select opposite vertex
+			let test_vert_id=edge_verts.as_ref()[directed_edge_id.parity() as usize];
+			let test_pos=self.mesh.vert(test_vert_id);
+			let diff=point-test_pos;
+			let distance_squared=diff.dot(diff);
+			// ensure test_vert_id is coplanar to simplex
+			if distance_squared<self.best_distance_squared&&self.constraint.contains(test_pos){
+				best_transition=Transition::Vert(test_vert_id);
+				self.best_distance_squared=distance_squared;
+			}
+		});
+		best_transition
+	}
+	fn final_ev(&mut self,vert_id:M::Vert,point:Planar64Vec3)->EV<M>{
+		let mut best_transition=EV::Vert(vert_id);
+		let vert_pos=self.mesh.vert(vert_id);
+		let diff=point-vert_pos;
+		self.mesh.for_each_vert_edge(vert_id,|directed_edge_id|{
+			//test if this edge is closer
+			let edge_verts=self.mesh.edge_verts(directed_edge_id.as_undirected());
+			let test_vert_id=edge_verts.as_ref()[directed_edge_id.parity() as usize];
+			let test_pos=self.mesh.vert(test_vert_id);
+			let edge_n=test_pos-vert_pos;
+			let d=edge_n.dot(diff);
+			//test the edge
+			let edge_nn=edge_n.dot(edge_n);
+			// ensure edge contains closest point and directed_edge_id is coplanar to simplex
+			if !d.is_negative()&&d<=edge_nn&&self.constraint.contains(test_pos){
+				let distance_squared={
+					let c=diff.cross(edge_n);
+					//wrap for speed
+					(c.dot(c)/edge_nn).divide().wrap_2()
+				};
+				if distance_squared<=self.best_distance_squared{
+					best_transition=EV::Edge(directed_edge_id.as_undirected());
+					self.best_distance_squared=distance_squared;
+				}
+			}
+		});
+		best_transition
+	}
+	fn crawl_boundaries(&mut self,mut vert_id:M::Vert,point:Planar64Vec3)->EV<M>
+		where
+			M::Vert:Copy
+	{
+		loop{
+			match self.next_transition_vert(vert_id,point){
+				Transition::Done=>return self.final_ev(vert_id,point),
+				Transition::Vert(new_vert_id)=>vert_id=new_vert_id,
+			}
+		}
+	}
+}
+/// This function hops along parallel vertices until it finds the EV which contains the closest point to `point`.
+fn crawl_to_closest_ev<M:MeshQuery<Position=Planar64Vec3>>(mesh:&M,simplex:Simplex<2,M::Vert>,point:Planar64Vec3)->EV<M>
+	where
+		M::Vert:Copy,
+		M::DirectedEdge:Copy,
+{
+	// naively start at the closest vertex
+	// the closest vertex is not necessarily the one with the fewest boundary hops
+	// but it doesn't matter, we will get there regardless.
+	let (vert_id,best_distance_squared)=simplex.into_iter().map(|vert_id|{
+		let diff=point-mesh.vert(vert_id);
+		(vert_id,diff.dot(diff))
+	}).min_by_key(|&(_,d)|d).unwrap();
+
+	let constraint=ThickLine::new(mesh,simplex);
+	let mut finder=EVFinder{constraint,mesh,best_distance_squared};
+	//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
+	finder.crawl_boundaries(vert_id,point)
+}
+
+/// This function hops along connected vertices until it finds the FEV which contains the closest point to `point`.
+fn crawl_to_closest_fev<'a>(mesh:&MinkowskiMesh<'a>,simplex:Simplex<3,MinkowskiVert>,point:Planar64Vec3)->FEV::<MinkowskiMesh<'a>>{
+	// naively start at the closest vertex
+	// the closest vertex is not necessarily the one with the fewest boundary hops
+	// but it doesn't matter, we will get there regardless.
+	let (vert_id,best_distance_squared)=simplex.into_iter().map(|vert_id|{
+		let diff=point-mesh.vert(vert_id);
+		(vert_id,diff.dot(diff))
+	}).min_by_key(|&(_,d)|d).unwrap();
+
+	let constraint=ThickPlane::new(mesh,simplex);
+	let mut finder=EVFinder{constraint,mesh,best_distance_squared};
+	//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
+	match finder.crawl_boundaries(vert_id,point){
+		//if a vert is returned, it is the closest point to the infinity point
+		EV::Vert(vert_id)=>FEV::Vert(vert_id),
+		EV::Edge(edge_id)=>{
+			//cross to face if we are on the wrong side
+			let edge_n=mesh.edge_n(edge_id);
+			// point is multiplied by two because vert_sum sums two vertices.
+			let delta_pos=point*2-{
+				let &[v0,v1]=mesh.edge_verts(edge_id).as_ref();
+				mesh.vert(v0)+mesh.vert(v1)
+			};
+			for (i,&face_id) in mesh.edge_faces(edge_id).as_ref().iter().enumerate(){
+				//test if this face is closer
+				let (face_n,d)=mesh.face_nd(face_id);
+				//if test point is behind face, the face is invalid
+				// TODO: find out why I thought of this backwards
+				if !(face_n.dot(point)-d).is_positive(){
+					continue;
+				}
+				//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);
+				//is test point behind edge, i.e. contained in the face
+				if !boundary_d.is_positive(){
+					//both faces cannot pass this condition, return early if one does.
+					return FEV::Face(face_id);
+				}
+			}
+			FEV::Edge(edge_id)
+		},
+	}
+}
+
+pub fn closest_fev_not_inside<'a>(mesh:&MinkowskiMesh<'a>,point:Planar64Vec3)->Option<FEV<MinkowskiMesh<'a>>>{
+	const ENABLE_FAST_FAIL:bool=false;
+	// TODO: remove mesh negation
+	minimum_difference::<ENABLE_FAST_FAIL,_,_>(&-mesh,point,
+		// on_exact
+		|is_intersecting,simplex|{
+			if is_intersecting{
+				return None;
+			}
+			// Convert simplex to FEV
+			// Vertices must be inverted since the mesh is inverted
+			Some(match simplex{
+				Simplex1_3::Simplex1([v0])=>FEV::Vert(-v0),
+				Simplex1_3::Simplex2([v0,v1])=>{
+					// invert
+					let (v0,v1)=(-v0,-v1);
+					crawl_to_closest_ev(mesh,[v0,v1],point).into()
+				},
+				Simplex1_3::Simplex3([v0,v1,v2])=>{
+					// invert
+					let (v0,v1,v2)=(-v0,-v1,-v2);
+					// Shimmy to the side until you find a face that contains the closest point
+					// it's ALWAYS representable as a face, but this algorithm may
+					// return E or V in edge cases but I don't think that will break the face crawler
+					crawl_to_closest_fev(mesh,[v0,v1,v2],point)
+				},
+			})
+		},
+		// on_escape
+		|_simplex|{
+			// intersection is guaranteed at this point
+			// local norm, dist, u0, u1, v0, v1, w0, w1 = expand(queryP, queryQ, a0, a1, b0, b1, c0, c1, d0, d1, 1e-5)
+			// let simplex=refine_to_exact(mesh,simplex);
+			None
+		},
+		// fast_fail value is irrelevant and will never be returned!
+		||unreachable!()
+	)
+}
+
+pub fn contains_point(mesh:&MinkowskiMesh<'_>,point:Planar64Vec3)->bool{
+	const ENABLE_FAST_FAIL:bool=true;
+	// TODO: remove mesh negation
+	minimum_difference::<ENABLE_FAST_FAIL,_,_>(&-mesh,point,
+		// on_exact
+		|is_intersecting,_simplex|{
+			is_intersecting
+		},
+		// on_escape
+		|_simplex|{
+			// intersection is guaranteed at this point
+			true
+		},
+		// fast_fail value
+		||false
+	)
+}
+
+// local function minimumDifference(
+// 	queryP, radiusP,
+// 	queryQ, radiusQ,
+// 	exitRadius, testIntersection
+// )
+fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery<Position=Planar64Vec3,Direction=Planar64Vec3>>(
+	mesh:&M,
+	point:Planar64Vec3,
+	on_exact:impl FnOnce(bool,Simplex1_3<M::Vert>)->T,
+	on_escape:impl FnOnce(Simplex<4,M::Vert>)->T,
+	on_fast_fail:impl FnOnce()->T,
+)->T
+	where
+		M::Vert:Copy
+{
+	// local initialAxis = queryQ() - queryP()
+	// local new_point_p = queryP(initialAxis)
+	// local new_point_q = queryQ(-initialAxis)
+	// local direction, a0, a1, b0, b1, c0, c1, d0, d1
+	let mut initial_axis=mesh.hint_point()+point;
+	// degenerate case
+	if initial_axis==vec3::zero(){
+		initial_axis=choose_any_direction();
+	}
+	let last_point=mesh.farthest_vert(-initial_axis);
+	// this represents the 'a' value in the commented code
+	let mut last_pos=mesh.vert(last_point);
+	let Reduced{dir:mut direction,simplex:mut simplex_small}=reduce1([last_point],mesh,point);
+
+	// exitRadius = testIntersection and 0 or exitRadius or 1/0
+	// for _ = 1, 100 do
+	loop{
+		// new_point_p = queryP(-direction)
+		// new_point_q = queryQ(direction)
+		// local next_point = new_point_q - new_point_p
+		let next_point=mesh.farthest_vert(direction);
+		let next_pos=mesh.vert(next_point);
+
+		// if -direction:Dot(next_point) > (exitRadius + radiusP + radiusQ)*direction.magnitude then
+		if ENABLE_FAST_FAIL&&direction.dot(next_pos+point).is_negative(){
+			return on_fast_fail();
+		}
+
+		let simplex_big=simplex_small.push_front(next_point);
+
+		// if
+		// 	direction:Dot(next_point - a) <= 0 or
+		// 	absDet(next_point, a, b, c) < 1e-6
+		if !direction.dot(next_pos-last_pos).is_positive()
+		||simplex_big.det_is_zero(mesh){
+			// Found enough information to compute the exact closest point.
+			// local norm = direction.unit
+			// local dist = a:Dot(norm)
+			// local hits = -dist < radiusP + radiusQ
+			let is_intersecting=(last_pos+point).dot(direction).is_positive();
+			return on_exact(is_intersecting,simplex_small);
+		}
+
+		// direction, a0, a1, b0, b1, c0, c1, d0, d1 = reduceSimplex(new_point_p, new_point_q, a0, a1, b0, b1, c0, c1)
+		match simplex_big.reduce(mesh,point){
+			// if a and b and c and d then
+			Reduce::Escape(simplex)=>{
+				// Enough information to conclude that the meshes are intersecting.
+				// Topology information is computed if needed.
+				return on_escape(simplex);
+			},
+			Reduce::Reduced(reduced)=>{
+				direction=reduced.dir;
+				simplex_small=reduced.simplex;
+			},
+		}
+
+		// next loop this will be a
+		last_pos=next_pos;
+	}
+}
+
+#[cfg(test)]
+mod test{
+	use super::*;
+    use crate::model::{PhysicsMesh,PhysicsMeshView};
+
+    fn mesh_contains_point(mesh:PhysicsMeshView<'_>,point:Planar64Vec3)->bool{
+		const ENABLE_FAST_FAIL:bool=true;
+		// TODO: remove mesh negation
+		minimum_difference::<ENABLE_FAST_FAIL,_,_>(&mesh,point,
+			// on_exact
+			|is_intersecting,_simplex|{
+				is_intersecting
+			},
+			// on_escape
+			|_simplex|{
+				// intersection is guaranteed at this point
+				true
+			},
+			// fast_fail value
+			||false
+		)
+	}
+
+	#[test]
+	fn test_cube_points(){
+		let mesh=PhysicsMesh::unit_cube();
+		let mesh_view=mesh.complete_mesh_view();
+		for x in -2..=2{
+			for y in -2..=2{
+				for z in -2..=2{
+					let point=vec3::int(x,y,z)>>1;
+					assert!(mesh_contains_point(mesh_view,point),"Mesh did not contain point {point}");
+				}
+			}
+		}
+	}
+}

engine/physics/src/minkowski.rs

@@ -0,0 +1,407 @@
+use core::ops::{Bound,RangeBounds};
+
+use strafesnet_common::integer::{Planar64Vec3,Ratio,Fixed,vec3::Vector3};
+use crate::model::into_giga_time;
+use crate::model::{SubmeshVertId,SubmeshEdgeId,SubmeshDirectedEdgeId,SubmeshFaceId,TransformedMesh,GigaTime};
+use crate::mesh_query::{MeshQuery,MeshTopology,DirectedEdge,UndirectedEdge};
+use crate::physics::{Time,Trajectory};
+
+struct AsRefHelper<T>(T);
+impl<T> AsRef<T> for AsRefHelper<T>{
+	fn as_ref(&self)->&T{
+		&self.0
+	}
+}
+
+//Note that a face on a minkowski mesh refers to a pair of fevs on the meshes it's summed from
+//(face,vertex)
+//(edge,edge)
+//(vertex,face)
+#[derive(Clone,Copy,Debug,Eq,PartialEq)]
+pub enum MinkowskiVert{
+	VertVert(SubmeshVertId,SubmeshVertId),
+}
+// TODO: remove this
+impl core::ops::Neg for MinkowskiVert{
+	type Output=Self;
+	fn neg(self)->Self::Output{
+		match self{
+			MinkowskiVert::VertVert(v0,v1)=>MinkowskiVert::VertVert(v1,v0),
+		}
+	}
+}
+#[derive(Clone,Copy,Debug)]
+pub enum MinkowskiEdge{
+	VertEdge(SubmeshVertId,SubmeshEdgeId),
+	EdgeVert(SubmeshEdgeId,SubmeshVertId),
+	//EdgeEdge when edges are parallel
+}
+impl UndirectedEdge for MinkowskiEdge{
+	type DirectedEdge=MinkowskiDirectedEdge;
+	fn as_directed(self,parity:bool)->Self::DirectedEdge{
+		match self{
+			MinkowskiEdge::VertEdge(v0,e1)=>MinkowskiDirectedEdge::VertEdge(v0,e1.as_directed(parity)),
+			MinkowskiEdge::EdgeVert(e0,v1)=>MinkowskiDirectedEdge::EdgeVert(e0.as_directed(parity),v1),
+		}
+	}
+}
+#[derive(Clone,Copy,Debug)]
+pub enum MinkowskiDirectedEdge{
+	VertEdge(SubmeshVertId,SubmeshDirectedEdgeId),
+	EdgeVert(SubmeshDirectedEdgeId,SubmeshVertId),
+	//EdgeEdge when edges are parallel
+}
+impl DirectedEdge for MinkowskiDirectedEdge{
+	type UndirectedEdge=MinkowskiEdge;
+	fn as_undirected(self)->Self::UndirectedEdge{
+		match self{
+			MinkowskiDirectedEdge::VertEdge(v0,e1)=>MinkowskiEdge::VertEdge(v0,e1.as_undirected()),
+			MinkowskiDirectedEdge::EdgeVert(e0,v1)=>MinkowskiEdge::EdgeVert(e0.as_undirected(),v1),
+		}
+	}
+	fn parity(&self)->bool{
+		match self{
+			MinkowskiDirectedEdge::VertEdge(_,e)
+			|MinkowskiDirectedEdge::EdgeVert(e,_)=>e.parity(),
+		}
+	}
+}
+#[derive(Clone,Copy,Debug,Hash)]
+pub enum MinkowskiFace{
+	VertFace(SubmeshVertId,SubmeshFaceId),
+	EdgeEdge(SubmeshEdgeId,SubmeshEdgeId,bool),
+	FaceVert(SubmeshFaceId,SubmeshVertId),
+	//EdgeFace
+	//FaceEdge
+	//FaceFace
+}
+
+#[derive(Debug)]
+pub struct MinkowskiMesh<'a>{
+	mesh0:TransformedMesh<'a>,
+	mesh1:TransformedMesh<'a>,
+}
+
+// TODO: remove this
+impl<'a> core::ops::Neg for &MinkowskiMesh<'a>{
+	type Output=MinkowskiMesh<'a>;
+	fn neg(self)->Self::Output{
+		MinkowskiMesh::minkowski_sum(self.mesh1,self.mesh0)
+	}
+}
+
+impl MinkowskiMesh<'_>{
+	pub fn minkowski_sum<'a>(mesh0:TransformedMesh<'a>,mesh1:TransformedMesh<'a>)->MinkowskiMesh<'a>{
+		MinkowskiMesh{
+			mesh0,
+			mesh1,
+		}
+	}
+	pub fn predict_collision_in(&self,trajectory:&Trajectory,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
+		let start_position=match range.start_bound(){
+			Bound::Included(time)=>trajectory.extrapolated_position(*time),
+			Bound::Excluded(time)=>trajectory.extrapolated_position(*time),
+			Bound::Unbounded=>trajectory.position,
+		};
+		let fev=crate::minimum_difference::closest_fev_not_inside(self,start_position)?;
+		//continue forwards along the body parabola
+		fev.crawl(self,trajectory,range.start_bound(),range.end_bound()).hit()
+	}
+	pub fn predict_collision_out(&self,trajectory:&Trajectory,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
+		let (lower_bound,upper_bound)=(range.start_bound(),range.end_bound());
+		// TODO: handle unbounded collision using infinity fev
+		let start_position=match upper_bound{
+			Bound::Included(time)=>trajectory.extrapolated_position(*time),
+			Bound::Excluded(time)=>trajectory.extrapolated_position(*time),
+			Bound::Unbounded=>trajectory.position,
+		};
+		let fev=crate::minimum_difference::closest_fev_not_inside(self,start_position)?;
+		// swap and negate bounds to do a time inversion
+		let (lower_bound,upper_bound)=(upper_bound.map(|&t|-t),lower_bound.map(|&t|-t));
+		let time_reversed_trajectory=-trajectory;
+		//continue backwards along the body parabola
+		fev.crawl(self,&time_reversed_trajectory,lower_bound.as_ref(),upper_bound.as_ref()).hit()
+			//no need to test -time<time_limit because of the first step
+			.map(|(face,time)|(face,-time))
+	}
+	pub fn predict_collision_face_out(&self,trajectory:&Trajectory,range:impl RangeBounds<Time>,contact_face_id:MinkowskiFace)->Option<(MinkowskiDirectedEdge,GigaTime)>{
+		// TODO: make better
+		use crate::face_crawler::{low,upp};
+		//no algorithm needed, there is only one state and two cases (Edge,None)
+		//determine when it passes an edge ("sliding off" case)
+		let start_time=range.start_bound().map(|&t|(t-trajectory.time).to_ratio());
+		let mut best_time=range.end_bound().map(|&t|into_giga_time(t,trajectory.time));
+		let mut best_edge=None;
+		let face_n=self.face_nd(contact_face_id).0;
+		self.for_each_face_edge(contact_face_id,|directed_edge_id|{
+			let edge_n=self.directed_edge_n(directed_edge_id);
+			//f x e points in
+			let n=face_n.cross(edge_n);
+			let &[v0,v1]=self.edge_verts(directed_edge_id.as_undirected()).as_ref();
+			let d=n.dot(self.vert(v0)+self.vert(v1));
+			//WARNING! d outside of *2
+			//WARNING: truncated precision
+			//wrap for speed
+			for dt in Fixed::<4,128>::zeroes2(((n.dot(trajectory.position))*2-d).wrap_4(),n.dot(trajectory.velocity).wrap_4()*2,n.dot(trajectory.acceleration).wrap_4()){
+				if low(&start_time,&dt)&&upp(&dt,&best_time)&&n.dot(trajectory.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+					best_time=Bound::Included(dt);
+					best_edge=Some((directed_edge_id,dt));
+					break;
+				}
+			}
+		});
+		best_edge
+	}
+	pub fn contains_point(&self,point:Planar64Vec3)->bool{
+		crate::minimum_difference::contains_point(self,point)
+	}
+}
+impl MeshQuery for MinkowskiMesh<'_>{
+	type Direction=Planar64Vec3;
+	type Position=Planar64Vec3;
+	type Normal=Vector3<Fixed<3,96>>;
+	type Offset=Fixed<4,128>;
+	// TODO: relative d
+	fn face_nd(&self,face_id:MinkowskiFace)->(Self::Normal,Self::Offset){
+		match face_id{
+			MinkowskiFace::VertFace(v0,f1)=>{
+				let (n,d)=self.mesh1.face_nd(f1);
+				(-n,d-n.dot(self.mesh0.vert(v0)))
+			},
+			MinkowskiFace::EdgeEdge(e0,e1,parity)=>{
+				let edge0_n=self.mesh0.edge_n(e0);
+				let edge1_n=self.mesh1.edge_n(e1);
+				let &[e0v0,e0v1]=self.mesh0.edge_verts(e0).as_ref();
+				let &[e1v0,e1v1]=self.mesh1.edge_verts(e1).as_ref();
+				let n=edge0_n.cross(edge1_n);
+				let e0d=n.dot(self.mesh0.vert(e0v0)+self.mesh0.vert(e0v1));
+				let e1d=n.dot(self.mesh1.vert(e1v0)+self.mesh1.vert(e1v1));
+				((n*(parity as i64*4-2)).widen_3(),((e0d-e1d)*(parity as i64*2-1)).widen_4())
+			},
+			MinkowskiFace::FaceVert(f0,v1)=>{
+				let (n,d)=self.mesh0.face_nd(f0);
+				(n,d-n.dot(self.mesh1.vert(v1)))
+			},
+		}
+	}
+	fn vert(&self,vert_id:MinkowskiVert)->Planar64Vec3{
+		match vert_id{
+			MinkowskiVert::VertVert(v0,v1)=>{
+				self.mesh0.vert(v0)-self.mesh1.vert(v1)
+			},
+		}
+	}
+	fn hint_point(&self)->Planar64Vec3{
+		self.mesh0.hint_point()-self.mesh1.hint_point()
+	}
+	fn farthest_vert(&self,dir:Planar64Vec3)->MinkowskiVert{
+		MinkowskiVert::VertVert(self.mesh0.farthest_vert(dir),self.mesh1.farthest_vert(-dir))
+	}
+	fn edge_n(&self,edge_id:Self::Edge)->Self::Direction{
+		let &[v0,v1]=self.edge_verts(edge_id).as_ref();
+		self.vert(v1)-self.vert(v0)
+	}
+	fn directed_edge_n(&self,directed_edge_id:Self::DirectedEdge)->Self::Direction{
+		let &[v0,v1]=self.edge_verts(directed_edge_id.as_undirected()).as_ref();
+		(self.vert(v1)-self.vert(v0))*((directed_edge_id.parity() as i64)*2-1)
+	}
+}
+impl MeshTopology for MinkowskiMesh<'_>{
+	type Face=MinkowskiFace;
+	type Edge=MinkowskiEdge;
+	type DirectedEdge=MinkowskiDirectedEdge;
+	type Vert=MinkowskiVert;
+	fn for_each_vert_edge(&self,vert_id:Self::Vert,mut f:impl FnMut(Self::DirectedEdge)){
+		match vert_id{
+			MinkowskiVert::VertVert(v0,v1)=>{
+				//detect shared volume when the other mesh is mirrored along a test edge dir
+				let v0f={
+					let mut faces=Vec::new();
+					self.mesh0.for_each_vert_face(v0,|face|faces.push(face));
+					faces
+				};
+				let v1f={
+					let mut faces=Vec::new();
+					self.mesh1.for_each_vert_face(v1,|face|faces.push(face));
+					faces
+				};
+				let v0f_n:Vec<_>=v0f.iter().map(|&face_id|self.mesh0.face_nd(face_id).0).collect();
+				let v1f_n:Vec<_>=v1f.iter().map(|&face_id|self.mesh1.face_nd(face_id).0).collect();
+				// scratch vector
+				let mut face_normals=Vec::with_capacity(v0f.len()+v1f.len());
+				face_normals.clone_from(&v0f_n);
+				self.mesh0.for_each_vert_edge(v0,|directed_edge_id|{
+					let n=self.mesh0.directed_edge_n(directed_edge_id);
+					let nn=n.dot(n);
+					// TODO: there's gotta be a better way to do this
+					// drop faces beyond v0f_n
+					face_normals.truncate(v0f.len());
+					// make a set of faces from mesh0's perspective
+					for face_n in &v1f_n{
+						//add reflected mesh1 faces
+						//wrap for speed
+						face_normals.push(*face_n-(n*face_n.dot(n)*2/nn).divide().wrap_3());
+					}
+					if is_empty_volume(&face_normals){
+						f(MinkowskiDirectedEdge::EdgeVert(directed_edge_id,v1));
+					}
+				});
+				face_normals.clone_from(&v1f_n);
+				self.mesh1.for_each_vert_edge(v1,|directed_edge_id|{
+					let n=self.mesh1.directed_edge_n(directed_edge_id);
+					let nn=n.dot(n);
+					// drop faces beyond v1f_n
+					face_normals.truncate(v1f.len());
+					// make a set of faces from mesh1's perspective
+					for face_n in &v0f_n{
+						//wrap for speed
+						face_normals.push(*face_n-(n*face_n.dot(n)*2/nn).divide().wrap_3());
+					}
+					if is_empty_volume(&face_normals){
+						f(MinkowskiDirectedEdge::VertEdge(v0,directed_edge_id));
+					}
+				});
+			},
+		}
+	}
+	fn for_each_vert_face(&self,_vert_id:Self::Vert,_f:impl FnMut(Self::Face)){
+		unimplemented!()
+	}
+	fn edge_faces(&self,edge_id:Self::Edge)->impl AsRef<[Self::Face;2]>{
+		match edge_id{
+			MinkowskiEdge::VertEdge(v0,e1)=>{
+				//faces are listed backwards from the minkowski mesh
+				let v0e={
+					let mut edges=Vec::new();
+					self.mesh0.for_each_vert_edge(v0,|edge|edges.push(edge));
+					edges
+				};
+				let &[e1f0,e1f1]=self.mesh1.edge_faces(e1).as_ref();
+				AsRefHelper([(e1f1,false),(e1f0,true)].map(|(edge_face_id1,face_parity)|{
+					let mut best_edge=None;
+					let mut best_d:Ratio<Fixed<8,256>,Fixed<8,256>>=Ratio::new(Fixed::ZERO,Fixed::ONE);
+					let edge_face1_n=self.mesh1.face_nd(edge_face_id1).0;
+					let edge_face1_nn=edge_face1_n.dot(edge_face1_n);
+					for &directed_edge_id0 in &v0e{
+						let edge0_n=self.mesh0.directed_edge_n(directed_edge_id0);
+						//must be behind other face.
+						let d=edge_face1_n.dot(edge0_n);
+						if d.is_negative(){
+							let edge0_nn=edge0_n.dot(edge0_n);
+							// Assume not every number is huge
+							// TODO: revisit this
+							let dd=(d*d)/(edge_face1_nn*edge0_nn);
+							if best_d<dd{
+								best_d=dd;
+								best_edge=Some(directed_edge_id0);
+							}
+						}
+					}
+					best_edge.map_or(
+						MinkowskiFace::VertFace(v0,edge_face_id1),
+						|directed_edge_id0|MinkowskiFace::EdgeEdge(directed_edge_id0.as_undirected(),e1,directed_edge_id0.parity()^face_parity)
+					)
+				}))
+			},
+			MinkowskiEdge::EdgeVert(e0,v1)=>{
+				//tracking index with an external variable because .enumerate() is not available
+				let v1e={
+					let mut edges=Vec::new();
+					self.mesh1.for_each_vert_edge(v1,|edge|edges.push(edge));
+					edges
+				};
+				let &[e0f0,e0f1]=self.mesh0.edge_faces(e0).as_ref();
+				AsRefHelper([(e0f0,true),(e0f1,false)].map(|(edge_face_id0,face_parity)|{
+					let mut best_edge=None;
+					let mut best_d:Ratio<Fixed<8,256>,Fixed<8,256>>=Ratio::new(Fixed::ZERO,Fixed::ONE);
+					let edge_face0_n=self.mesh0.face_nd(edge_face_id0).0;
+					let edge_face0_nn=edge_face0_n.dot(edge_face0_n);
+					for &directed_edge_id1 in &v1e{
+						let edge1_n=self.mesh1.directed_edge_n(directed_edge_id1);
+						let d=edge_face0_n.dot(edge1_n);
+						if d.is_negative(){
+							let edge1_nn=edge1_n.dot(edge1_n);
+							let dd=(d*d)/(edge_face0_nn*edge1_nn);
+							if best_d<dd{
+								best_d=dd;
+								best_edge=Some(directed_edge_id1);
+							}
+						}
+					}
+					best_edge.map_or(
+						MinkowskiFace::FaceVert(edge_face_id0,v1),
+						|directed_edge_id1|MinkowskiFace::EdgeEdge(e0,directed_edge_id1.as_undirected(),directed_edge_id1.parity()^face_parity)
+					)
+				}))
+			},
+		}
+	}
+	fn edge_verts(&self,edge_id:Self::Edge)->impl AsRef<[Self::Vert;2]>{
+		AsRefHelper(match edge_id{
+			MinkowskiEdge::VertEdge(v0,e1)=>self.mesh1.edge_verts(e1).as_ref().map(|vert_id1|
+				MinkowskiVert::VertVert(v0,vert_id1)
+			),
+			MinkowskiEdge::EdgeVert(e0,v1)=>self.mesh0.edge_verts(e0).as_ref().map(|vert_id0|
+				MinkowskiVert::VertVert(vert_id0,v1)
+			),
+		})
+	}
+	fn for_each_face_vert(&self,_face_id:Self::Face,_f:impl FnMut(Self::Vert)){
+		unimplemented!()
+	}
+	fn for_each_face_edge(&self,face_id:Self::Face,mut f:impl FnMut(Self::DirectedEdge)){
+		match face_id{
+			MinkowskiFace::VertFace(v0,f1)=>{
+				self.mesh1.for_each_face_edge(f1,|edge_id1|
+					f(MinkowskiDirectedEdge::VertEdge(v0,edge_id1.reverse()))
+				)
+			},
+			MinkowskiFace::EdgeEdge(e0,e1,parity)=>{
+				let &[e0v0,e0v1]=self.mesh0.edge_verts(e0).as_ref();
+				let &[e1v0,e1v1]=self.mesh1.edge_verts(e1).as_ref();
+				//could sort this if ordered edges are needed
+				//probably just need to reverse this list according to parity
+				f(MinkowskiDirectedEdge::VertEdge(e0v0,e1.as_directed(parity)));
+				f(MinkowskiDirectedEdge::EdgeVert(e0.as_directed(!parity),e1v0));
+				f(MinkowskiDirectedEdge::VertEdge(e0v1,e1.as_directed(!parity)));
+				f(MinkowskiDirectedEdge::EdgeVert(e0.as_directed(parity),e1v1));
+			},
+			MinkowskiFace::FaceVert(f0,v1)=>{
+				self.mesh0.for_each_face_edge(f0,|edge_id0|
+					f(MinkowskiDirectedEdge::EdgeVert(edge_id0,v1))
+				)
+			},
+		}
+	}
+}
+
+fn is_empty_volume(normals:&[Vector3<Fixed<3,96>>])->bool{
+	let len=normals.len();
+	for i in 0..len-1{
+		for j in i+1..len{
+			let n=normals[i].cross(normals[j]);
+			let mut d_comp=None;
+			for k in 0..len{
+				if k!=i&&k!=j{
+					let d=n.dot(normals[k]).is_negative();
+					if let &Some(comp)=&d_comp{
+						// This is testing if d_comp*d < 0
+						if comp^d{
+							return true;
+						}
+					}else{
+						d_comp=Some(d);
+					}
+				}
+			}
+		}
+	}
+	return false;
+}
+
+#[test]
+fn test_is_empty_volume(){
+	use strafesnet_common::integer::vec3;
+	assert!(!is_empty_volume(&[vec3::X.widen_3(),vec3::Y.widen_3(),vec3::Z.widen_3()]));
+	assert!(is_empty_volume(&[vec3::X.widen_3(),vec3::Y.widen_3(),vec3::Z.widen_3(),vec3::NEG_X.widen_3()]));
+}

engine/physics/src/model.rs

@@ -1,11 +1,9 @@
 use std::collections::{HashSet,HashMap};
-use core::ops::{Bound,RangeBounds};
 use strafesnet_common::integer::vec3::Vector3;
 use strafesnet_common::model::{self,MeshId,PolygonIter};
 use strafesnet_common::integer::{self,vec3,Fixed,Planar64,Planar64Vec3,Ratio};
 use strafesnet_common::physics::Time;
-
-type Body=crate::body::Body<strafesnet_common::physics::TimeInner>;
+use crate::mesh_query::{MeshQuery,MeshTopology,DirectedEdge,UndirectedEdge};
 
 struct AsRefHelper<T>(T);
 impl<T> AsRef<T> for AsRefHelper<T>{
@@ -14,20 +12,6 @@ impl<T> AsRef<T> for AsRefHelper<T>{
 	}
 }
 
-pub trait UndirectedEdge{
-	type DirectedEdge:Copy+DirectedEdge;
-	fn as_directed(&self,parity:bool)->Self::DirectedEdge;
-}
-pub trait DirectedEdge{
-	type UndirectedEdge:Copy+std::fmt::Debug+UndirectedEdge;
-	fn as_undirected(&self)->Self::UndirectedEdge;
-	fn parity(&self)->bool;
-	//this is stupid but may work fine
-	fn reverse(&self)-><<Self as DirectedEdge>::UndirectedEdge as UndirectedEdge>::DirectedEdge{
-		self.as_undirected().as_directed(!self.parity())
-	}
-}
-
 #[derive(Debug,Clone,Copy,Hash,id::Id,Eq,PartialEq)]
 pub struct MeshVertId(u32);
 #[derive(Debug,Clone,Copy,Hash,id::Id,Eq,PartialEq)]
@@ -45,13 +29,13 @@ pub struct SubmeshFaceId(u32);
 
 impl UndirectedEdge for SubmeshEdgeId{
 	type DirectedEdge=SubmeshDirectedEdgeId;
-	fn as_directed(&self,parity:bool)->SubmeshDirectedEdgeId{
+	fn as_directed(self,parity:bool)->SubmeshDirectedEdgeId{
 		SubmeshDirectedEdgeId(self.0|((parity as u32)<<(u32::BITS-1)))
 	}
 }
 impl DirectedEdge for SubmeshDirectedEdgeId{
 	type UndirectedEdge=SubmeshEdgeId;
-	fn as_undirected(&self)->SubmeshEdgeId{
+	fn as_undirected(self)->SubmeshEdgeId{
 		SubmeshEdgeId(self.0&!(1<<(u32::BITS-1)))
 	}
 	fn parity(&self)->bool{
@@ -59,14 +43,6 @@ impl DirectedEdge for SubmeshDirectedEdgeId{
 	}
 }
 
-//Vertex <-> Edge <-> Face -> Collide
-#[derive(Debug)]
-pub enum FEV<M:MeshQuery>{
-	Face(M::Face),
-	Edge(<M::Edge as DirectedEdge>::UndirectedEdge),
-	Vert(M::Vert),
-}
-
 //use Unit32 #[repr(C)] for map files
 #[derive(Clone,Copy,Debug,Hash,Eq,PartialEq)]
 struct Face{
@@ -75,32 +51,6 @@ struct Face{
 }
 #[derive(Debug)]
 struct Vert(Planar64Vec3);
-pub trait MeshQuery{
-	type Face:Copy;
-	type Edge:Copy+DirectedEdge;
-	type Vert:Copy;
-	// Vertex must be Planar64Vec3 because it represents an actual position
-	type Normal;
-	type Offset;
-	fn edge_n(&self,edge_id:<Self::Edge as DirectedEdge>::UndirectedEdge)->Planar64Vec3{
-		let &[v0,v1]=self.edge_verts(edge_id).as_ref();
-		self.vert(v1)-self.vert(v0)
-	}
-	fn directed_edge_n(&self,directed_edge_id:Self::Edge)->Planar64Vec3{
-		let &[v0,v1]=self.edge_verts(directed_edge_id.as_undirected()).as_ref();
-		(self.vert(v1)-self.vert(v0))*((directed_edge_id.parity() as i64)*2-1)
-	}
-	/// This must return a point inside the mesh.
-	#[expect(dead_code)]
-	fn hint_point(&self)->Planar64Vec3;
-	fn vert(&self,vert_id:Self::Vert)->Planar64Vec3;
-	fn face_nd(&self,face_id:Self::Face)->(Self::Normal,Self::Offset);
-	fn face_edges(&self,face_id:Self::Face)->impl AsRef<[Self::Edge]>;
-	fn edge_faces(&self,edge_id:<Self::Edge as DirectedEdge>::UndirectedEdge)->impl AsRef<[Self::Face;2]>;
-	fn edge_verts(&self,edge_id:<Self::Edge as DirectedEdge>::UndirectedEdge)->impl AsRef<[Self::Vert;2]>;
-	fn vert_edges(&self,vert_id:Self::Vert)->impl AsRef<[Self::Edge]>;
-	fn vert_faces(&self,vert_id:Self::Vert)->impl AsRef<[Self::Face]>;
-}
 #[derive(Debug)]
 struct FaceRefs{
 	// I didn't write it down, but I assume the edges are directed
@@ -439,15 +389,14 @@ impl TryFrom<&model::Mesh> for PhysicsMesh{
 	}
 }
 
-#[derive(Debug)]
+#[derive(Debug,Clone,Copy)]
 pub struct PhysicsMeshView<'a>{
 	data:&'a PhysicsMeshData,
 	topology:&'a PhysicsMeshTopology,
 }
 impl MeshQuery for PhysicsMeshView<'_>{
-	type Face=SubmeshFaceId;
-	type Edge=SubmeshDirectedEdgeId;
-	type Vert=SubmeshVertId;
+	type Position=Planar64Vec3;
+	type Direction=Planar64Vec3;
 	type Normal=Planar64Vec3;
 	type Offset=Planar64;
 	fn face_nd(&self,face_id:SubmeshFaceId)->(Planar64Vec3,Planar64){
@@ -458,25 +407,54 @@ impl MeshQuery for PhysicsMeshView<'_>{
 		// invariant: meshes always encompass the origin
 		vec3::zero()
 	}
+	fn farthest_vert(&self,dir:Planar64Vec3)->SubmeshVertId{
+		//this happens to be well-defined.  there are no virtual virtices
+		SubmeshVertId::new(
+			self.topology.verts.iter()
+			.enumerate()
+			.max_by_key(|&(_,&vert_id)|
+				dir.dot(self.data.verts[vert_id.get() as usize].0)
+			)
+			//assume there is more than zero vertices.
+			.unwrap().0 as u32
+		)
+	}
 	//ideally I never calculate the vertex position, but I have to for the graphical meshes...
 	fn vert(&self,vert_id:SubmeshVertId)->Planar64Vec3{
 		let vert_idx=self.topology.verts[vert_id.get() as usize].get() as usize;
 		self.data.verts[vert_idx].0
 	}
-	fn face_edges(&self,face_id:SubmeshFaceId)->impl AsRef<[SubmeshDirectedEdgeId]>{
-		self.topology.face_topology[face_id.get() as usize].edges.as_slice()
+	fn edge_n(&self,edge_id:Self::Edge)->Self::Direction{
+		let &[v0,v1]=self.edge_verts(edge_id).as_ref();
+		self.vert(v1)-self.vert(v0)
 	}
-	fn edge_faces(&self,edge_id:SubmeshEdgeId)->impl AsRef<[SubmeshFaceId;2]>{
+	fn directed_edge_n(&self,directed_edge_id:Self::DirectedEdge)->Self::Direction{
+		let &[v0,v1]=self.edge_verts(directed_edge_id.as_undirected()).as_ref();
+		(self.vert(v1)-self.vert(v0))*((directed_edge_id.parity() as i64)*2-1)
+	}
+}
+impl MeshTopology for PhysicsMeshView<'_>{
+	type Face=SubmeshFaceId;
+	type Edge=SubmeshEdgeId;
+	type DirectedEdge=SubmeshDirectedEdgeId;
+	type Vert=SubmeshVertId;
+	fn for_each_vert_edge(&self,vert_id:Self::Vert,f:impl FnMut(Self::DirectedEdge)){
+		self.topology.vert_topology[vert_id.get() as usize].edges.iter().copied().for_each(f);
+	}
+	fn for_each_vert_face(&self,vert_id:Self::Vert,f:impl FnMut(Self::Face)){
+		self.topology.vert_topology[vert_id.get() as usize].faces.iter().copied().for_each(f);
+	}
+	fn edge_faces(&self,edge_id:Self::Edge)->impl AsRef<[Self::Face;2]>{
 		AsRefHelper(self.topology.edge_topology[edge_id.get() as usize].faces)
 	}
-	fn edge_verts(&self,edge_id:SubmeshEdgeId)->impl AsRef<[SubmeshVertId;2]>{
+	fn edge_verts(&self,edge_id:Self::Edge)->impl AsRef<[Self::Vert;2]>{
 		AsRefHelper(self.topology.edge_topology[edge_id.get() as usize].verts)
 	}
-	fn vert_edges(&self,vert_id:SubmeshVertId)->impl AsRef<[SubmeshDirectedEdgeId]>{
-		self.topology.vert_topology[vert_id.get() as usize].edges.as_slice()
+	fn for_each_face_vert(&self,_face_id:Self::Face,_f:impl FnMut(Self::Vert)){
+		unimplemented!()
 	}
-	fn vert_faces(&self,vert_id:SubmeshVertId)->impl AsRef<[SubmeshFaceId]>{
-		self.topology.vert_topology[vert_id.get() as usize].faces.as_slice()
+	fn for_each_face_edge(&self,face_id:Self::Face,f:impl FnMut(Self::DirectedEdge)){
+		self.topology.face_topology[face_id.get() as usize].edges.iter().copied().for_each(f);
 	}
 }
 
@@ -496,7 +474,7 @@ impl PhysicsMeshTransform{
 	}
 }
 
-#[derive(Debug)]
+#[derive(Debug,Clone,Copy)]
 pub struct TransformedMesh<'a>{
 	view:PhysicsMeshView<'a>,
 	transform:&'a PhysicsMeshTransform,
@@ -514,23 +492,10 @@ impl TransformedMesh<'_>{
 	pub fn verts<'a>(&'a self)->impl Iterator<Item=Vector3<Fixed<2,64>>>+'a{
 		self.view.data.verts.iter().map(|&Vert(pos)|self.transform.vertex.transform_point3(pos))
 	}
-	fn farthest_vert(&self,dir:Planar64Vec3)->SubmeshVertId{
-		//this happens to be well-defined.  there are no virtual virtices
-		SubmeshVertId::new(
-			self.view.topology.verts.iter()
-			.enumerate()
-			.max_by_key(|&(_,&vert_id)|
-				dir.dot(self.transform.vertex.transform_point3(self.view.data.verts[vert_id.get() as usize].0))
-			)
-			//assume there is more than zero vertices.
-			.unwrap().0 as u32
-		)
-	}
 }
 impl MeshQuery for TransformedMesh<'_>{
-	type Face=SubmeshFaceId;
-	type Edge=SubmeshDirectedEdgeId;
-	type Vert=SubmeshVertId;
+	type Direction=Planar64Vec3;
+	type Position=Planar64Vec3;
 	type Normal=Vector3<Fixed<3,96>>;
 	type Offset=Fixed<4,128>;
 	fn face_nd(&self,face_id:SubmeshFaceId)->(Self::Normal,Self::Offset){
@@ -546,510 +511,59 @@ impl MeshQuery for TransformedMesh<'_>{
 	fn hint_point(&self)->Planar64Vec3{
 		self.transform.vertex.translation
 	}
+	fn farthest_vert(&self,dir:Planar64Vec3)->SubmeshVertId{
+		//this happens to be well-defined.  there are no virtual virtices
+		SubmeshVertId::new(
+			self.view.topology.verts.iter()
+			.enumerate()
+			.max_by_key(|&(_,&vert_id)|
+				dir.dot(self.transform.vertex.transform_point3(self.view.data.verts[vert_id.get() as usize].0))
+			)
+			//assume there is more than zero vertices.
+			.unwrap().0 as u32
+		)
+	}
+	fn edge_n(&self,edge_id:Self::Edge)->Self::Direction{
+		let &[v0,v1]=self.edge_verts(edge_id).as_ref();
+		self.vert(v1)-self.vert(v0)
+	}
+	fn directed_edge_n(&self,directed_edge_id:Self::DirectedEdge)->Self::Direction{
+		let &[v0,v1]=self.edge_verts(directed_edge_id.as_undirected()).as_ref();
+		(self.vert(v1)-self.vert(v0))*((directed_edge_id.parity() as i64)*2-1)
+	}
+}
+impl MeshTopology for TransformedMesh<'_>{
+	type Face=SubmeshFaceId;
+	type Edge=SubmeshEdgeId;
+	type DirectedEdge=SubmeshDirectedEdgeId;
+	type Vert=SubmeshVertId;
 	#[inline]
-	fn face_edges(&self,face_id:SubmeshFaceId)->impl AsRef<[SubmeshDirectedEdgeId]>{
-		self.view.face_edges(face_id)
+	fn for_each_vert_edge(&self,vert_id:Self::Vert,f:impl FnMut(Self::DirectedEdge)){
+		self.view.for_each_vert_edge(vert_id,f)
 	}
 	#[inline]
-	fn edge_faces(&self,edge_id:SubmeshEdgeId)->impl AsRef<[SubmeshFaceId;2]>{
+	fn for_each_vert_face(&self,vert_id:Self::Vert,f:impl FnMut(Self::Face)){
+		self.view.for_each_vert_face(vert_id,f)
+	}
+	#[inline]
+	fn edge_faces(&self,edge_id:Self::Edge)->impl AsRef<[Self::Face;2]>{
 		self.view.edge_faces(edge_id)
 	}
 	#[inline]
-	fn edge_verts(&self,edge_id:SubmeshEdgeId)->impl AsRef<[SubmeshVertId;2]>{
+	fn edge_verts(&self,edge_id:Self::Edge)->impl AsRef<[Self::Vert;2]>{
 		self.view.edge_verts(edge_id)
 	}
-	#[inline]
-	fn vert_edges(&self,vert_id:SubmeshVertId)->impl AsRef<[SubmeshDirectedEdgeId]>{
-		self.view.vert_edges(vert_id)
+	fn for_each_face_vert(&self,face_id:Self::Face,f:impl FnMut(Self::Vert)){
+		self.view.for_each_face_vert(face_id,f)
 	}
 	#[inline]
-	fn vert_faces(&self,vert_id:SubmeshVertId)->impl AsRef<[SubmeshFaceId]>{
-		self.view.vert_faces(vert_id)
+	fn for_each_face_edge(&self,face_id:Self::Face,f:impl FnMut(Self::DirectedEdge)){
+		self.view.for_each_face_edge(face_id,f)
 	}
 }
 
-//Note that a face on a minkowski mesh refers to a pair of fevs on the meshes it's summed from
-//(face,vertex)
-//(edge,edge)
-//(vertex,face)
-#[derive(Clone,Copy,Debug)]
-pub enum MinkowskiVert{
-	VertVert(SubmeshVertId,SubmeshVertId),
-}
-#[derive(Clone,Copy,Debug)]
-pub enum MinkowskiEdge{
-	VertEdge(SubmeshVertId,SubmeshEdgeId),
-	EdgeVert(SubmeshEdgeId,SubmeshVertId),
-	//EdgeEdge when edges are parallel
-}
-impl UndirectedEdge for MinkowskiEdge{
-	type DirectedEdge=MinkowskiDirectedEdge;
-	fn as_directed(&self,parity:bool)->Self::DirectedEdge{
-		match self{
-			MinkowskiEdge::VertEdge(v0,e1)=>MinkowskiDirectedEdge::VertEdge(*v0,e1.as_directed(parity)),
-			MinkowskiEdge::EdgeVert(e0,v1)=>MinkowskiDirectedEdge::EdgeVert(e0.as_directed(parity),*v1),
-		}
-	}
-}
-#[derive(Clone,Copy,Debug)]
-pub enum MinkowskiDirectedEdge{
-	VertEdge(SubmeshVertId,SubmeshDirectedEdgeId),
-	EdgeVert(SubmeshDirectedEdgeId,SubmeshVertId),
-	//EdgeEdge when edges are parallel
-}
-impl DirectedEdge for MinkowskiDirectedEdge{
-	type UndirectedEdge=MinkowskiEdge;
-	fn as_undirected(&self)->Self::UndirectedEdge{
-		match self{
-			MinkowskiDirectedEdge::VertEdge(v0,e1)=>MinkowskiEdge::VertEdge(*v0,e1.as_undirected()),
-			MinkowskiDirectedEdge::EdgeVert(e0,v1)=>MinkowskiEdge::EdgeVert(e0.as_undirected(),*v1),
-		}
-	}
-	fn parity(&self)->bool{
-		match self{
-			MinkowskiDirectedEdge::VertEdge(_,e)
-			|MinkowskiDirectedEdge::EdgeVert(e,_)=>e.parity(),
-		}
-	}
-}
-#[derive(Clone,Copy,Debug,Hash,Eq,PartialEq)]
-pub enum MinkowskiFace{
-	VertFace(SubmeshVertId,SubmeshFaceId),
-	EdgeEdge(SubmeshEdgeId,SubmeshEdgeId,bool),
-	FaceVert(SubmeshFaceId,SubmeshVertId),
-	//EdgeFace
-	//FaceEdge
-	//FaceFace
-}
-
-#[derive(Debug)]
-pub struct MinkowskiMesh<'a>{
-	mesh0:TransformedMesh<'a>,
-	mesh1:TransformedMesh<'a>,
-}
-
-//infinity fev algorithm state transition
-#[derive(Debug)]
-enum Transition{
-	Done,//found closest vert, no edges are better
-	Vert(MinkowskiVert),//transition to vert
-}
-enum EV{
-	Vert(MinkowskiVert),
-	Edge(MinkowskiEdge),
-}
-
 pub type GigaTime=Ratio<Fixed<4,128>,Fixed<4,128>>;
 pub fn into_giga_time(time:Time,relative_to:Time)->GigaTime{
 	let r=(time-relative_to).to_ratio();
 	Ratio::new(r.num.widen_4(),r.den.widen_4())
 }
-
-impl MinkowskiMesh<'_>{
-	pub fn minkowski_sum<'a>(mesh0:TransformedMesh<'a>,mesh1:TransformedMesh<'a>)->MinkowskiMesh<'a>{
-		MinkowskiMesh{
-			mesh0,
-			mesh1,
-		}
-	}
-	fn farthest_vert(&self,dir:Planar64Vec3)->MinkowskiVert{
-		MinkowskiVert::VertVert(self.mesh0.farthest_vert(dir),self.mesh1.farthest_vert(-dir))
-	}
-	fn next_transition_vert(&self,vert_id:MinkowskiVert,best_distance_squared:&mut Fixed<2,64>,infinity_dir:Planar64Vec3,point:Planar64Vec3)->Transition{
-		let mut best_transition=Transition::Done;
-		for &directed_edge_id in self.vert_edges(vert_id).as_ref(){
-			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.as_ref()[directed_edge_id.parity() as usize];
-			//test if it's closer
-			let diff=point-self.vert(test_vert_id);
-			if edge_n.dot(infinity_dir).is_zero(){
-				let distance_squared=diff.dot(diff);
-				if distance_squared<*best_distance_squared{
-					best_transition=Transition::Vert(test_vert_id);
-					*best_distance_squared=distance_squared;
-				}
-			}
-		}
-		best_transition
-	}
-	fn final_ev(&self,vert_id:MinkowskiVert,best_distance_squared:&mut Fixed<2,64>,infinity_dir:Planar64Vec3,point:Planar64Vec3)->EV{
-		let mut best_transition=EV::Vert(vert_id);
-		let diff=point-self.vert(vert_id);
-		for &directed_edge_id in self.vert_edges(vert_id).as_ref(){
-			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
-			if edge_n.dot(infinity_dir).is_zero(){
-				let d=edge_n.dot(diff);
-				//test the edge
-				let edge_nn=edge_n.dot(edge_n);
-				if !d.is_negative()&&d<=edge_nn{
-					let distance_squared={
-						let c=diff.cross(edge_n);
-						//wrap for speed
-						(c.dot(c)/edge_nn).divide().wrap_2()
-					};
-					if distance_squared<=*best_distance_squared{
-						best_transition=EV::Edge(directed_edge_id.as_undirected());
-						*best_distance_squared=distance_squared;
-					}
-				}
-			}
-		}
-		best_transition
-	}
-	fn crawl_boundaries(&self,mut vert_id:MinkowskiVert,infinity_dir:Planar64Vec3,point:Planar64Vec3)->EV{
-		let mut best_distance_squared={
-			let diff=point-self.vert(vert_id);
-			diff.dot(diff)
-		};
-		loop{
-			match self.next_transition_vert(vert_id,&mut best_distance_squared,infinity_dir,point){
-				Transition::Done=>return self.final_ev(vert_id,&mut best_distance_squared,infinity_dir,point),
-				Transition::Vert(new_vert_id)=>vert_id=new_vert_id,
-			}
-		}
-	}
-	/// 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::<MinkowskiMesh<'_>>{
-		//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
-		match self.crawl_boundaries(self.farthest_vert(infinity_dir),infinity_dir,point){
-			//if a vert is returned, it is the closest point to the infinity point
-			EV::Vert(vert_id)=>FEV::Vert(vert_id),
-			EV::Edge(edge_id)=>{
-				//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-{
-					let &[v0,v1]=self.edge_verts(edge_id).as_ref();
-					self.vert(v0)+self.vert(v1)
-				};
-				for (i,&face_id) in self.edge_faces(edge_id).as_ref().iter().enumerate(){
-					let face_n=self.face_nd(face_id).0;
-					//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.is_positive()&&boundary_n.dot(infinity_dir).is_zero(){
-						//both faces cannot pass this condition, return early if one does.
-						return FEV::Face(face_id);
-					}
-				}
-				FEV::Edge(edge_id)
-			},
-		}
-	}
-	// TODO: fundamentally improve this algorithm.
-	// All it needs to do is find the closest point on the mesh
-	// and return the FEV which the point resides on.
-	//
-	// What it actually does is use the above functions to trace a ray in from infinity,
-	// crawling the closest point along the mesh surface until the ray reaches
-	// the starting point to discover the final FEV.
-	//
-	// The actual collision prediction probably does a single test
-	// and then immediately returns with 0 FEV transitions on average,
-	// because of the strict time_limit constraint.
-	//
-	// Most of the calculation time is just calculating the starting point
-	// for the "actual" crawling algorithm below (predict_collision_{in|out}).
-	fn closest_fev_not_inside(&self,mut infinity_body:Body,start_time:Bound<&Time>)->Option<FEV<MinkowskiMesh<'_>>>{
-		infinity_body.infinity_dir().and_then(|dir|{
-			let infinity_fev=self.infinity_fev(-dir,infinity_body.position);
-			//a line is simpler to solve than a parabola
-			infinity_body.velocity=dir;
-			infinity_body.acceleration=vec3::zero();
-			//crawl in from negative infinity along a tangent line to get the closest fev
-			infinity_fev.crawl::<false>(self,&infinity_body,Bound::Unbounded,start_time).miss()
-		})
-	}
-	pub fn predict_collision_in(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
-		self.closest_fev_not_inside(*relative_body,range.start_bound()).and_then(|fev|{
-			//continue forwards along the body parabola
-			fev.crawl::<true>(self,relative_body,range.start_bound(),range.end_bound()).hit()
-		})
-	}
-	pub fn predict_collision_out(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
-		let (lower_bound,upper_bound)=(range.start_bound(),range.end_bound());
-		// swap and negate bounds to do a time inversion
-		let (lower_bound,upper_bound)=(upper_bound.map(|&t|-t),lower_bound.map(|&t|-t));
-		let infinity_body=-relative_body;
-		self.closest_fev_not_inside(infinity_body,lower_bound.as_ref()).and_then(|fev|{
-			//continue backwards along the body parabola
-			fev.crawl::<true>(self,&infinity_body,lower_bound.as_ref(),upper_bound.as_ref()).hit()
-				//no need to test -time<time_limit because of the first step
-				.map(|(face,time)|(face,-time))
-		})
-	}
-	pub fn predict_collision_face_out(&self,relative_body:&Body,range:impl RangeBounds<Time>,contact_face_id:MinkowskiFace)->Option<(MinkowskiDirectedEdge,GigaTime)>{
-		// TODO: make better
-		use crate::face_crawler::{low,upp};
-		//no algorithm needed, there is only one state and two cases (Edge,None)
-		//determine when it passes an edge ("sliding off" case)
-		let start_time=range.start_bound().map(|&t|(t-relative_body.time).to_ratio());
-		let mut best_time=range.end_bound().map(|&t|into_giga_time(t,relative_body.time));
-		let mut best_edge=None;
-		let face_n=self.face_nd(contact_face_id).0;
-		for &directed_edge_id in self.face_edges(contact_face_id).as_ref(){
-			let edge_n=self.directed_edge_n(directed_edge_id);
-			//f x e points in
-			let n=face_n.cross(edge_n);
-			let &[v0,v1]=self.edge_verts(directed_edge_id.as_undirected()).as_ref();
-			let d=n.dot(self.vert(v0)+self.vert(v1));
-			//WARNING! d outside of *2
-			//WARNING: truncated precision
-			//wrap for speed
-			for dt in Fixed::<4,128>::zeroes2(((n.dot(relative_body.position))*2-d).wrap_4(),n.dot(relative_body.velocity).wrap_4()*2,n.dot(relative_body.acceleration).wrap_4()){
-				if low(&start_time,&dt)&&upp(&dt,&best_time)&&n.dot(relative_body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
-					best_time=Bound::Included(dt);
-					best_edge=Some((directed_edge_id,dt));
-					break;
-				}
-			}
-		}
-		best_edge
-	}
-	fn infinity_in(&self,infinity_body:Body)->Option<(MinkowskiFace,GigaTime)>{
-		let infinity_fev=self.infinity_fev(-infinity_body.velocity,infinity_body.position);
-		// Bound::Included means that the surface of the mesh is included in the mesh
-		infinity_fev.crawl::<false>(self,&infinity_body,Bound::Unbounded,Bound::Included(&infinity_body.time)).hit()
-	}
-	pub fn is_point_in_mesh(&self,point:Planar64Vec3)->bool{
-		let infinity_body=Body::new(point,vec3::Y,vec3::zero(),Time::ZERO);
-		//movement must escape the mesh forwards and backwards in time,
-		//otherwise the point is not inside the mesh
-		self.infinity_in(infinity_body)
-    	.is_some_and(|_|
-			self.infinity_in(-infinity_body)
-    		.is_some()
-     	)
-	}
-}
-impl MeshQuery for MinkowskiMesh<'_>{
-	type Face=MinkowskiFace;
-	type Edge=MinkowskiDirectedEdge;
-	type Vert=MinkowskiVert;
-	type Normal=Vector3<Fixed<3,96>>;
-	type Offset=Fixed<4,128>;
-	// TODO: relative d
-	fn face_nd(&self,face_id:MinkowskiFace)->(Self::Normal,Self::Offset){
-		match face_id{
-			MinkowskiFace::VertFace(v0,f1)=>{
-				let (n,d)=self.mesh1.face_nd(f1);
-				(-n,d-n.dot(self.mesh0.vert(v0)))
-			},
-			MinkowskiFace::EdgeEdge(e0,e1,parity)=>{
-				let edge0_n=self.mesh0.edge_n(e0);
-				let edge1_n=self.mesh1.edge_n(e1);
-				let &[e0v0,e0v1]=self.mesh0.edge_verts(e0).as_ref();
-				let &[e1v0,e1v1]=self.mesh1.edge_verts(e1).as_ref();
-				let n=edge0_n.cross(edge1_n);
-				let e0d=n.dot(self.mesh0.vert(e0v0)+self.mesh0.vert(e0v1));
-				let e1d=n.dot(self.mesh1.vert(e1v0)+self.mesh1.vert(e1v1));
-				((n*(parity as i64*4-2)).widen_3(),((e0d-e1d)*(parity as i64*2-1)).widen_4())
-			},
-			MinkowskiFace::FaceVert(f0,v1)=>{
-				let (n,d)=self.mesh0.face_nd(f0);
-				(n,d-n.dot(self.mesh1.vert(v1)))
-			},
-		}
-	}
-	fn vert(&self,vert_id:MinkowskiVert)->Planar64Vec3{
-		match vert_id{
-			MinkowskiVert::VertVert(v0,v1)=>{
-				self.mesh0.vert(v0)-self.mesh1.vert(v1)
-			},
-		}
-	}
-	fn hint_point(&self)->Planar64Vec3{
-		self.mesh1.transform.vertex.translation-
-		self.mesh0.transform.vertex.translation
-	}
-	fn face_edges(&self,face_id:MinkowskiFace)->impl AsRef<[MinkowskiDirectedEdge]>{
-		match face_id{
-			MinkowskiFace::VertFace(v0,f1)=>{
-				self.mesh1.face_edges(f1).as_ref().iter().map(|&edge_id1|
-					MinkowskiDirectedEdge::VertEdge(v0,edge_id1.reverse())
-				).collect()
-			},
-			MinkowskiFace::EdgeEdge(e0,e1,parity)=>{
-				let &[e0v0,e0v1]=self.mesh0.edge_verts(e0).as_ref();
-				let &[e1v0,e1v1]=self.mesh1.edge_verts(e1).as_ref();
-				//could sort this if ordered edges are needed
-				//probably just need to reverse this list according to parity
-				vec![
-					MinkowskiDirectedEdge::VertEdge(e0v0,e1.as_directed(parity)),
-					MinkowskiDirectedEdge::EdgeVert(e0.as_directed(!parity),e1v0),
-					MinkowskiDirectedEdge::VertEdge(e0v1,e1.as_directed(!parity)),
-					MinkowskiDirectedEdge::EdgeVert(e0.as_directed(parity),e1v1),
-				]
-			},
-			MinkowskiFace::FaceVert(f0,v1)=>{
-				self.mesh0.face_edges(f0).as_ref().iter().map(|&edge_id0|
-					MinkowskiDirectedEdge::EdgeVert(edge_id0,v1)
-				).collect()
-			},
-		}
-	}
-	fn edge_faces(&self,edge_id:MinkowskiEdge)->impl AsRef<[MinkowskiFace;2]>{
-		match edge_id{
-			MinkowskiEdge::VertEdge(v0,e1)=>{
-				//faces are listed backwards from the minkowski mesh
-				let v0e=self.mesh0.vert_edges(v0);
-				let &[e1f0,e1f1]=self.mesh1.edge_faces(e1).as_ref();
-				AsRefHelper([(e1f1,false),(e1f0,true)].map(|(edge_face_id1,face_parity)|{
-					let mut best_edge=None;
-					let mut best_d:Ratio<Fixed<8,256>,Fixed<8,256>>=Ratio::new(Fixed::ZERO,Fixed::ONE);
-					let edge_face1_n=self.mesh1.face_nd(edge_face_id1).0;
-					let edge_face1_nn=edge_face1_n.dot(edge_face1_n);
-					for &directed_edge_id0 in v0e.as_ref(){
-						let edge0_n=self.mesh0.directed_edge_n(directed_edge_id0);
-						//must be behind other face.
-						let d=edge_face1_n.dot(edge0_n);
-						if d.is_negative(){
-							let edge0_nn=edge0_n.dot(edge0_n);
-							// Assume not every number is huge
-							// TODO: revisit this
-							let dd=(d*d)/(edge_face1_nn*edge0_nn);
-							if best_d<dd{
-								best_d=dd;
-								best_edge=Some(directed_edge_id0);
-							}
-						}
-					}
-					best_edge.map_or(
-						MinkowskiFace::VertFace(v0,edge_face_id1),
-						|directed_edge_id0|MinkowskiFace::EdgeEdge(directed_edge_id0.as_undirected(),e1,directed_edge_id0.parity()^face_parity)
-					)
-				}))
-			},
-			MinkowskiEdge::EdgeVert(e0,v1)=>{
-				//tracking index with an external variable because .enumerate() is not available
-				let v1e=self.mesh1.vert_edges(v1);
-				let &[e0f0,e0f1]=self.mesh0.edge_faces(e0).as_ref();
-				AsRefHelper([(e0f0,true),(e0f1,false)].map(|(edge_face_id0,face_parity)|{
-					let mut best_edge=None;
-					let mut best_d:Ratio<Fixed<8,256>,Fixed<8,256>>=Ratio::new(Fixed::ZERO,Fixed::ONE);
-					let edge_face0_n=self.mesh0.face_nd(edge_face_id0).0;
-					let edge_face0_nn=edge_face0_n.dot(edge_face0_n);
-					for &directed_edge_id1 in v1e.as_ref(){
-						let edge1_n=self.mesh1.directed_edge_n(directed_edge_id1);
-						let d=edge_face0_n.dot(edge1_n);
-						if d.is_negative(){
-							let edge1_nn=edge1_n.dot(edge1_n);
-							let dd=(d*d)/(edge_face0_nn*edge1_nn);
-							if best_d<dd{
-								best_d=dd;
-								best_edge=Some(directed_edge_id1);
-							}
-						}
-					}
-					best_edge.map_or(
-						MinkowskiFace::FaceVert(edge_face_id0,v1),
-						|directed_edge_id1|MinkowskiFace::EdgeEdge(e0,directed_edge_id1.as_undirected(),directed_edge_id1.parity()^face_parity)
-					)
-				}))
-			},
-		}
-	}
-	fn edge_verts(&self,edge_id:MinkowskiEdge)->impl AsRef<[MinkowskiVert;2]>{
-		AsRefHelper(match edge_id{
-			MinkowskiEdge::VertEdge(v0,e1)=>self.mesh1.edge_verts(e1).as_ref().map(|vert_id1|
-				MinkowskiVert::VertVert(v0,vert_id1)
-			),
-			MinkowskiEdge::EdgeVert(e0,v1)=>self.mesh0.edge_verts(e0).as_ref().map(|vert_id0|
-				MinkowskiVert::VertVert(vert_id0,v1)
-			),
-		})
-	}
-	fn vert_edges(&self,vert_id:MinkowskiVert)->impl AsRef<[MinkowskiDirectedEdge]>{
-		match vert_id{
-			MinkowskiVert::VertVert(v0,v1)=>{
-				let mut edges=Vec::new();
-				//detect shared volume when the other mesh is mirrored along a test edge dir
-				let v0f_thing=self.mesh0.vert_faces(v0);
-				let v1f_thing=self.mesh1.vert_faces(v1);
-				let v0f=v0f_thing.as_ref();
-				let v1f=v1f_thing.as_ref();
-				let v0f_n:Vec<_>=v0f.iter().map(|&face_id|self.mesh0.face_nd(face_id).0).collect();
-				let v1f_n:Vec<_>=v1f.iter().map(|&face_id|self.mesh1.face_nd(face_id).0).collect();
-				// scratch vector
-				let mut face_normals=Vec::with_capacity(v0f.len()+v1f.len());
-				face_normals.clone_from(&v0f_n);
-				for &directed_edge_id in self.mesh0.vert_edges(v0).as_ref(){
-					let n=self.mesh0.directed_edge_n(directed_edge_id);
-					let nn=n.dot(n);
-					// TODO: there's gotta be a better way to do this
-					// drop faces beyond v0f_n
-					face_normals.truncate(v0f.len());
-					// make a set of faces from mesh0's perspective
-					for face_n in &v1f_n{
-						//add reflected mesh1 faces
-						//wrap for speed
-						face_normals.push(*face_n-(n*face_n.dot(n)*2/nn).divide().wrap_3());
-					}
-					if is_empty_volume(&face_normals){
-						edges.push(MinkowskiDirectedEdge::EdgeVert(directed_edge_id,v1));
-					}
-				}
-				face_normals.clone_from(&v1f_n);
-				for &directed_edge_id in self.mesh1.vert_edges(v1).as_ref(){
-					let n=self.mesh1.directed_edge_n(directed_edge_id);
-					let nn=n.dot(n);
-					// drop faces beyond v1f_n
-					face_normals.truncate(v1f.len());
-					// make a set of faces from mesh1's perspective
-					for face_n in &v0f_n{
-						//wrap for speed
-						face_normals.push(*face_n-(n*face_n.dot(n)*2/nn).divide().wrap_3());
-					}
-					if is_empty_volume(&face_normals){
-						edges.push(MinkowskiDirectedEdge::VertEdge(v0,directed_edge_id));
-					}
-				}
-				edges
-			},
-		}
-	}
-	fn vert_faces(&self,_vert_id:MinkowskiVert)->impl AsRef<[MinkowskiFace]>{
-		unimplemented!();
-		#[expect(unreachable_code)]
-		Vec::new()
-	}
-}
-
-fn is_empty_volume(normals:&[Vector3<Fixed<3,96>>])->bool{
-	let len=normals.len();
-	for i in 0..len-1{
-		for j in i+1..len{
-			let n=normals[i].cross(normals[j]);
-			let mut d_comp=None;
-			for k in 0..len{
-				if k!=i&&k!=j{
-					let d=n.dot(normals[k]).is_negative();
-					if let &Some(comp)=&d_comp{
-						// This is testing if d_comp*d < 0
-						if comp^d{
-							return true;
-						}
-					}else{
-						d_comp=Some(d);
-					}
-				}
-			}
-		}
-	}
-	return false;
-}
-
-#[test]
-fn test_is_empty_volume(){
-	assert!(!is_empty_volume(&[vec3::X.widen_3(),vec3::Y.widen_3(),vec3::Z.widen_3()]));
-	assert!(is_empty_volume(&[vec3::X.widen_3(),vec3::Y.widen_3(),vec3::Z.widen_3(),vec3::NEG_X.widen_3()]));
-}

engine/physics/src/push_solve.rs

@@ -15,6 +15,7 @@ type Conts<'a>=arrayvec::ArrayVec<&'a Contact,4>;
 const RATIO_ZERO:Ratio<Fixed<1,32>,Fixed<1,32>>=Ratio::new(Fixed::ZERO,Fixed::EPSILON);
 
 /// Information about a contact restriction
+#[derive(Debug,PartialEq)]
 pub struct Contact{
 	pub position:Planar64Vec3,
 	pub velocity:Planar64Vec3,
@@ -281,16 +282,16 @@ fn get_first_touch<'a>(contacts:&'a [Contact],ray:&Ray,conts:&Conts)->Option<(Ra
 		.min_by_key(|&(t,_)|t)
 }
 
-pub fn push_solve(contacts:&[Contact],point:Planar64Vec3)->Planar64Vec3{
+pub fn push_solve(contacts:&[Contact],point:Planar64Vec3)->(Planar64Vec3,Conts<'_>){
 	let (mut ray,mut conts)=get_best_push_ray_and_conts_0(point);
 	loop{
 		let (next_t,next_cont)=match get_first_touch(contacts,&ray,&conts){
 			Some((t,cont))=>(t,cont),
-			None=>return ray.origin,
+			None=>return (ray.origin,conts),
 		};
 
 		if RATIO_ZERO.le_ratio(next_t){
-			return ray.origin;
+			return (ray.origin,conts);
 		}
 
 		//push_front
@@ -306,7 +307,7 @@ pub fn push_solve(contacts:&[Contact],point:Planar64Vec3)->Planar64Vec3{
 		let meet_point=ray.extrapolate(next_t);
 		match get_best_push_ray_and_conts(meet_point,conts.as_slice()){
 			Some((new_ray,new_conts))=>(ray,conts)=(new_ray,new_conts),
-			None=>return meet_point,
+			None=>return (meet_point,conts),
 		}
 	}
 }
@@ -323,9 +324,8 @@ mod tests{
 				normal:vec3::Y,
 			}
 		];
-		assert_eq!(
-			vec3::zero(),
-			push_solve(&contacts,vec3::NEG_Y)
-		);
+		let (point,conts)=push_solve(&contacts,vec3::NEG_Y);
+		assert_eq!(point,vec3::zero());
+		assert_eq!(conts.as_slice(),[&contacts[0]].as_slice());
 	}
 }

engine/session/src/mouse_interpolator.rs

@@ -138,6 +138,7 @@ impl MouseInterpolator{
 		match buffer_state{
 			BufferState::Unbuffered=>(),
 			BufferState::Initializing(_time,mouse_state)=>{
+				println!("{timeout_time} Time out Initializing");
 				// only a single mouse move was sent in 10ms, this is very much an edge case!
 				self.push_mouse_and_flush_buffer(TimedInstruction{
 					time:mouse_state.time,
@@ -148,6 +149,7 @@ impl MouseInterpolator{
 				});
 			}
 			BufferState::Buffered(_time,mouse_state)=>{
+				println!("{timeout_time} Time out Buffered");
 				// duplicate the currently buffered mouse state but at a later (future, from the physics perspective) time
 				self.push_mouse_and_flush_buffer(TimedInstruction{
 					time:mouse_state.time,
@@ -157,6 +159,7 @@ impl MouseInterpolator{
 		}
 	}
 	fn push_unbuffered_input(&mut self,session_time:SessionTime,physics_time:PhysicsTime,ins:UnbufferedInstruction){
+		println!("helo");
 		// new input
 		// if there is zero instruction buffered, it means the mouse is not moving
 		// case 1: unbuffered
@@ -177,9 +180,11 @@ impl MouseInterpolator{
 					let next_mouse_state=MouseState{pos,time:physics_time};
 					match buffer_state{
 						BufferState::Unbuffered=>{
+							println!("{session_time} Unbuffered -> Initializing");
 							((None,None),BufferState::Initializing(session_time,next_mouse_state))
 						},
 						BufferState::Initializing(_time,mouse_state)=>{
+							println!("{session_time} Initializing -> Buffered");
 							let ins_mouse=TimedInstruction{
 								time:mouse_state.time,
 								instruction:MouseInstruction::ReplaceMouse{
@@ -190,6 +195,7 @@ impl MouseInterpolator{
 							((Some(ins_mouse),None),BufferState::Buffered(session_time,next_mouse_state))
 						},
 						BufferState::Buffered(_time,mouse_state)=>{
+							println!("{session_time} Buffered");
 							let ins_mouse=TimedInstruction{
 								time:mouse_state.time,
 								instruction:MouseInstruction::SetNextMouse(next_mouse_state.clone()),

engine/session/src/session.rs

@@ -52,13 +52,12 @@ pub enum SessionControlInstruction{
 pub enum SessionPlaybackInstruction{
 	SkipForward,
 	SkipBack,
-	TogglePaused,
 	DecreaseTimescale,
 	IncreaseTimescale,
 }
 
 pub struct FrameState{
-	pub body:physics::Body,
+	pub trajectory:physics::Trajectory,
 	pub camera:physics::PhysicsCamera,
 	pub time:PhysicsTime,
 }
@@ -77,9 +76,9 @@ impl Simulation{
 			physics,
 		}
 	}
-	pub fn get_frame_state(&self,time:SessionTime)->FrameState{
+	pub fn get_frame_state(&self,time:SessionTime,data:&PhysicsData)->FrameState{
 		FrameState{
-			body:self.physics.camera_body(),
+			trajectory:self.physics.camera_trajectory(data),
 			camera:self.physics.camera(),
 			time:self.timer.time(time),
 		}
@@ -188,9 +187,9 @@ impl Session{
 	}
 	pub fn get_frame_state(&self,time:SessionTime)->Option<FrameState>{
 		match &self.view_state{
-			ViewState::Play=>Some(self.simulation.get_frame_state(time)),
+			ViewState::Play=>Some(self.simulation.get_frame_state(time,&self.geometry_shared)),
 			ViewState::Replay(bot_id)=>self.replays.get(bot_id).map(|replay|
-				replay.simulation.get_frame_state(time)
+				replay.simulation.get_frame_state(time,&self.geometry_shared)
 			),
 		}
 	}
@@ -222,6 +221,7 @@ impl InstructionConsumer<Instruction<'_>> for Session{
 			};
 		}
 
+		println!("=== PRE-PROCESS ===");
 		// process any timeouts that occured since the last instruction
 		self.process_exhaustive(ins.time);
 
@@ -239,12 +239,16 @@ impl InstructionConsumer<Instruction<'_>> for Session{
 				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Mode(ModeInstruction::Reset));
 				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Misc(MiscInstruction::SetSensitivity(self.user_settings().calculate_sensitivity())));
 				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Mode(ModeInstruction::Restart(mode_id)));
+				// TODO: think about this harder.  This works around a bug where you fall infinitely when you reset.
+				self.simulation.timer.set_time(ins.time,PhysicsTime::ZERO);
 			},
 			Instruction::Input(SessionInputInstruction::Mode(ImplicitModeInstruction::ResetAndSpawn(mode_id,spawn_id)))=>{
 				self.clear_recording();
 				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Mode(ModeInstruction::Reset));
 				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Misc(MiscInstruction::SetSensitivity(self.user_settings().calculate_sensitivity())));
 				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Mode(ModeInstruction::Spawn(mode_id,spawn_id)));
+				// TODO: think about this harder.  This works around a bug where you fall infinitely when you reset.
+				self.simulation.timer.set_time(ins.time,PhysicsTime::ZERO);
 			},
 			Instruction::Input(SessionInputInstruction::Misc(misc_instruction))=>{
 				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Misc(misc_instruction));
@@ -253,7 +257,14 @@ impl InstructionConsumer<Instruction<'_>> for Session{
 				// don't flush the buffered instructions in the mouse interpolator
 				// until the mouse is confirmed to be not moving at a later time
 				// what if they pause for 5ms lmao
-				_=self.simulation.timer.set_paused(ins.time,paused);
+				match &self.view_state{
+					ViewState::Play=>{
+						_=self.simulation.timer.set_paused(ins.time,paused);
+					},
+					ViewState::Replay(bot_id)=>if let Some(replay)=self.replays.get_mut(bot_id){
+						_=replay.simulation.timer.set_paused(ins.time,paused);
+					},
+				}
 			},
 			Instruction::Control(SessionControlInstruction::CopyRecordingIntoReplayAndSpectate)=> if let ViewState::Play=self.view_state{
 				// Bind: B
@@ -374,14 +385,6 @@ impl InstructionConsumer<Instruction<'_>> for Session{
 					},
 				}
 			},
-			Instruction::Playback(SessionPlaybackInstruction::TogglePaused)=>{
-				match &self.view_state{
-					ViewState::Play=>(),
-					ViewState::Replay(bot_id)=>if let Some(replay)=self.replays.get_mut(bot_id){
-						_=replay.simulation.timer.set_paused(ins.time,!replay.simulation.timer.is_paused());
-					},
-				}
-			}
 			Instruction::ChangeMap(complete_map)=>{
 				self.clear_recording();
 				self.change_map(complete_map);
@@ -420,6 +423,7 @@ impl InstructionConsumer<Instruction<'_>> for Session{
 			}
 		};
 
+		println!("=== POST-PROCESS ===");
 		// process all emitted output instructions
 		self.process_exhaustive(ins.time);
 	}

integration-testing/src/main.rs

@@ -71,16 +71,16 @@ fn segment_determinism(bot:strafesnet_snf::bot::Segment,physics_data:&PhysicsDat
 	for (i,ins) in bot.instructions.into_iter().enumerate(){
 		let state_deterministic=physics_deterministic.clone();
 		let state_filtered=physics_filtered.clone();
-		PhysicsContext::run_input_instruction(&mut physics_deterministic,&physics_data,ins.clone());
+		PhysicsContext::run_input_instruction(&mut physics_deterministic,physics_data,ins.clone());
 		match ins{
 			strafesnet_common::instruction::TimedInstruction{instruction:strafesnet_common::physics::Instruction::Idle,..}=>(),
 			other=>{
 				non_idle_count+=1;
 				// run
-				PhysicsContext::run_input_instruction(&mut physics_filtered,&physics_data,other.clone());
+				PhysicsContext::run_input_instruction(&mut physics_filtered,physics_data,other.clone());
 				// check if position matches
-				let b0=physics_deterministic.camera_body();
-				let b1=physics_filtered.camera_body();
+				let b0=physics_deterministic.camera_trajectory(physics_data);
+				let b1=physics_filtered.camera_trajectory(physics_data);
 				if b0.position!=b1.position{
 					let nanoseconds=start.elapsed().as_nanos() as u64;
 					println!("desync at instruction #{}",i);

integration-testing/src/test_scenes.rs

@@ -73,7 +73,6 @@ fn simultaneous_collision(){
 	let body=strafesnet_physics::physics::Body::new(
 		(vec3::int(5+2,0,0)>>1)+vec3::int(1,1,0),
 		vec3::int(-1,-1,0),
-		vec3::int(0,0,0),
 		Time::ZERO,
 	);
 	let mut physics=PhysicsState::new_with_body(body);
@@ -88,7 +87,6 @@ fn simultaneous_collision(){
 	let body=physics.body();
 	assert_eq!(body.position,vec3::int(5,0,0));
 	assert_eq!(body.velocity,vec3::int(0,0,0));
-	assert_eq!(body.acceleration,vec3::int(0,0,0));
 	assert_eq!(body.time,Time::from_secs(1));
 }
 #[test]
@@ -97,7 +95,6 @@ fn bug_3(){
 	let body=strafesnet_physics::physics::Body::new(
 		(vec3::int(5+2,0,0)>>1)+vec3::int(1,2,0),
 		vec3::int(-1,-1,0),
-		vec3::int(0,0,0),
 		Time::ZERO,
 	);
 	let mut physics=PhysicsState::new_with_body(body);
@@ -112,6 +109,5 @@ fn bug_3(){
 	let body=physics.body();
 	assert_eq!(body.position,vec3::int(5+2,0,0)>>1);
 	assert_eq!(body.velocity,vec3::int(0,0,0));
-	assert_eq!(body.acceleration,vec3::int(0,0,0));
 	assert_eq!(body.time,Time::from_secs(2));
 }

integration-testing/src/tests.rs

@@ -22,7 +22,6 @@ fn physics_bug_2()->Result<(),ReplayError>{
 	let body=strafesnet_physics::physics::Body::new(
 		vec3::raw_xyz(555690659654,1490485868773,1277783839382),
 		vec3::int(0,0,0),
-		vec3::int(0,-100,0),
 		Time::ZERO,
 	);
 	let mut physics=PhysicsState::new_with_body(body);
@@ -60,9 +59,12 @@ fn physics_bug_3()->Result<(),ReplayError>{
 		// vec3::raw_xyz(0,-96915585363,1265),
 		// vec3::raw_xyz(0,-429496729600,0),
 		// corner setup before wall hits
-		vec3::raw_xyz(-1392580080675,3325402529458,-2444727738679),
-		vec3::raw_xyz(-30259028820,-22950929553,-71141663007),
-		vec3::raw_xyz(0,-429496729600,0),
+		// vec3::raw_xyz(-1392580080675,3325402529458,-2444727738679),
+		// vec3::raw_xyz(-30259028820,-22950929553,-71141663007),
+		// vec3::raw_xyz(0,-429496729600,0),
+		// Actual bug 3 repro
+		vec3::raw_xyz(-2505538624455,3357963283914,557275711118),
+		vec3::raw_xyz(204188283920,-282280474198,166172785440),
 		Time::ZERO,
 	);
 	let mut physics=PhysicsState::new_with_body(body);

lib/common/src/physics.rs

@@ -36,6 +36,7 @@ pub enum SetControlInstruction{
 	SetMoveForward(bool),
 	SetJump(bool),
 	SetZoom(bool),
+	SetSprint(bool),
 }
 #[derive(Clone,Debug)]
 pub enum ModeInstruction{

lib/fixed_wide/src/fixed.rs

@@ -7,7 +7,7 @@ const BNUM_DIGIT_WIDTH:usize=64;
 /// N is the number of u64s to use
 /// F is the number of fractional bits (always N*32 lol)
 pub struct Fixed<const N:usize,const F:usize>{
-	pub(crate)bits:BInt<{N}>,
+	bits:BInt<{N}>,
 }
 
 impl<const N:usize,const F:usize> Fixed<N,F>{
@@ -545,7 +545,7 @@ impl_shift_operator!( Fixed, Shr, shr, Self );
 
 // wide operators.  The result width is the sum of the input widths, i.e. none of the multiplication
 
-#[expect(unused_macros)]
+#[allow(unused_macros)]
 macro_rules! impl_wide_operators{
 	($lhs:expr,$rhs:expr)=>{
 		impl core::ops::Mul<Fixed<$rhs,{$rhs*32}>> for Fixed<$lhs,{$lhs*32}>{

lib/rbx_loader/Cargo.toml

@@ -12,7 +12,7 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 [dependencies]
 bytemuck = "1.14.3"
 glam = "0.30.0"
-regex = { version = "1.11.3", default-features = false }
+regex = { version = "1.11.3", default-features = false, features = ["unicode-perl"] }
 rbx_mesh = "0.5.0"
 rbxassetid = { version = "0.1.0", path = "../rbxassetid", registry = "strafesnet" }
 roblox_emulator = { version = "0.5.1", path = "../roblox_emulator", default-features = false, registry = "strafesnet" }

lib/snf/src/newtypes/physics.rs

@@ -88,6 +88,11 @@ pub enum Instruction{
 	PracticeFly,
 	#[brw(magic=14u8)]
 	SetSensitivity(super::integer::Ratio64Vec2),
+	#[brw(magic=15u8)]
+	SetSprint(
+		#[br(map=bool_from_u8)]
+		#[bw(map=bool_into_u8)]
+		bool),
 	#[brw(magic=255u8)]
 	Idle,
 }
@@ -116,6 +121,7 @@ impl TryInto<strafesnet_common::physics::Instruction> for Instruction{
 			Instruction::SetMoveForward(state)=>strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetMoveForward(state.into())),
 			Instruction::SetJump(state)=>strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetJump(state.into())),
 			Instruction::SetZoom(state)=>strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetZoom(state.into())),
+			Instruction::SetSprint(state)=>strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetSprint(state.into())),
 			Instruction::Reset=>strafesnet_common::physics::Instruction::Mode(strafesnet_common::physics::ModeInstruction::Reset),
 			Instruction::Restart(mode_id)=>strafesnet_common::physics::Instruction::Mode(strafesnet_common::physics::ModeInstruction::Restart(strafesnet_common::gameplay_modes::ModeId::new(mode_id))),
 			Instruction::Spawn(mode_id,stage_id)=>strafesnet_common::physics::Instruction::Mode(strafesnet_common::physics::ModeInstruction::Spawn(
@@ -142,6 +148,7 @@ impl TryFrom<strafesnet_common::physics::Instruction> for Instruction{
 			strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetMoveForward(state))=>Ok(Instruction::SetMoveForward(state.into())),
 			strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetJump(state))=>Ok(Instruction::SetJump(state.into())),
 			strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetZoom(state))=>Ok(Instruction::SetZoom(state.into())),
+			strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetSprint(state))=>Ok(Instruction::SetSprint(state.into())),
 			strafesnet_common::physics::Instruction::Mode(strafesnet_common::physics::ModeInstruction::Reset)=>Ok(Instruction::Reset),
 			strafesnet_common::physics::Instruction::Mode(strafesnet_common::physics::ModeInstruction::Restart(mode_id))=>Ok(Instruction::Restart(mode_id.get())),
 			strafesnet_common::physics::Instruction::Mode(strafesnet_common::physics::ModeInstruction::Spawn(mode_id,stage_id))=>Ok(Instruction::Spawn(

strafe-client/Cargo.toml

@@ -28,7 +28,7 @@ strafesnet_rbx_loader = { path = "../lib/rbx_loader", registry = "strafesnet", o
 strafesnet_session = { path = "../engine/session", registry = "strafesnet" }
 strafesnet_settings = { path = "../engine/settings", registry = "strafesnet" }
 strafesnet_snf = { path = "../lib/snf", registry = "strafesnet", optional = true }
-wgpu = "27.0.0"
+wgpu = "28.0.0"
 winit = "0.30.7"
 
 [profile.dev]

strafe-client/models/teslacyberv3.0.mtl

@@ -1,62 +0,0 @@
-# Blender MTL File: 'teslacyberv3.0.blend'
-# Material Count: 6
-
-newmtl Material
-Ns 65.476285
-Ka 1.000000 1.000000 1.000000
-Kd 0.411568 0.411568 0.411568
-Ks 0.614679 0.614679 0.614679
-Ke 0.000000 0.000000 0.000000
-Ni 36.750000
-d 1.000000
-illum 3
-
-newmtl Материал
-Ns 323.999994
-Ka 1.000000 1.000000 1.000000
-Kd 0.800000 0.800000 0.800000
-Ks 0.500000 0.500000 0.500000
-Ke 0.000000 0.000000 0.000000
-Ni 1.000000
-d 1.000000
-illum 2
-
-newmtl Материал.001
-Ns 900.000000
-Ka 1.000000 1.000000 1.000000
-Kd 0.026240 0.026240 0.026240
-Ks 0.000000 0.000000 0.000000
-Ke 0.000000 0.000000 0.000000
-Ni 1.450000
-d 1.000000
-illum 1
-
-newmtl Материал.002
-Ns 0.000000
-Ka 1.000000 1.000000 1.000000
-Kd 0.031837 0.032429 0.029425
-Ks 0.169725 0.169725 0.169725
-Ke 0.000000 0.000000 0.000000
-Ni 0.000000
-d 1.000000
-illum 2
-
-newmtl Материал.003
-Ns 900.000000
-Ka 1.000000 1.000000 1.000000
-Kd 0.023585 0.083235 0.095923
-Ks 1.000000 1.000000 1.000000
-Ke 0.000000 0.000000 0.000000
-Ni 45.049999
-d 1.000000
-illum 3
-
-newmtl Материал.004
-Ns 323.999994
-Ka 1.000000 1.000000 1.000000
-Kd 0.800000 0.800000 0.800000
-Ks 0.500000 0.500000 0.500000
-Ke 0.000000 0.000000 0.000000
-Ni 1.000000
-d 1.000000
-illum 2

strafe-client/src/setup.rs

@@ -52,7 +52,7 @@ impl<'a> SetupContextPartial2<'a>{
 		let required_features=required_features();
 
 		//no helper function smh gotta write it myself
-		let adapters=self.instance.enumerate_adapters(self.backends);
+		let adapters=pollster::block_on(self.instance.enumerate_adapters(self.backends));
 
 		let mut chosen_adapter=None;
 		let mut chosen_adapter_score=0;

strafe-client/src/window.rs

@@ -15,6 +15,7 @@ pub enum Instruction{
 struct WindowContext<'a>{
 	manual_mouse_lock:bool,
 	mouse_pos:glam::DVec2,
+	simulation_paused:bool,
 	screen_size:glam::UVec2,
 	window:&'a winit::window::Window,
 	physics_thread:crate::compat_worker::QNWorker<'a,TimedInstruction<PhysicsWorkerInstruction,SessionTime>>,
@@ -24,6 +25,35 @@ impl WindowContext<'_>{
 	fn get_middle_of_screen(&self)->winit::dpi::PhysicalPosition<u32>{
 		winit::dpi::PhysicalPosition::new(self.screen_size.x/2,self.screen_size.y/2)
 	}
+	fn free_mouse(&mut self){
+		self.manual_mouse_lock=false;
+		match self.window.set_cursor_position(self.get_middle_of_screen()){
+			Ok(())=>(),
+			Err(e)=>println!("Could not set cursor position: {:?}",e),
+		}
+		match self.window.set_cursor_grab(winit::window::CursorGrabMode::None){
+			Ok(())=>(),
+			Err(e)=>println!("Could not release cursor: {:?}",e),
+		}
+		self.window.set_cursor_visible(true);
+	}
+	fn lock_mouse(&mut self){
+		//if cursor is outside window don't lock but apparently there's no get pos function
+		//let pos=window.get_cursor_pos();
+		match self.window.set_cursor_grab(winit::window::CursorGrabMode::Locked){
+			Ok(())=>(),
+			Err(_)=>{
+				match self.window.set_cursor_grab(winit::window::CursorGrabMode::Confined){
+					Ok(())=>(),
+					Err(e)=>{
+						self.manual_mouse_lock=true;
+						println!("Could not confine cursor: {:?}",e)
+					},
+				}
+			}
+		}
+		self.window.set_cursor_visible(false);
+	}
 	fn window_event(&mut self,time:SessionTime,event:winit::event::WindowEvent){
 		match event{
 			winit::event::WindowEvent::DroppedFile(path)=>{
@@ -34,6 +64,10 @@ impl WindowContext<'_>{
 				}
 			},
 			winit::event::WindowEvent::Focused(state)=>{
+				// don't unpause if manually paused
+				if self.simulation_paused{
+					return;
+				}
 				//pause unpause
 				self.physics_thread.send(TimedInstruction{
 					time,
@@ -46,35 +80,8 @@ impl WindowContext<'_>{
 				..
 			}=>{
 				match (logical_key,state){
-					(winit::keyboard::Key::Named(winit::keyboard::NamedKey::Tab),winit::event::ElementState::Pressed)=>{
-						self.manual_mouse_lock=false;
-						match self.window.set_cursor_position(self.get_middle_of_screen()){
-							Ok(())=>(),
-							Err(e)=>println!("Could not set cursor position: {:?}",e),
-						}
-						match self.window.set_cursor_grab(winit::window::CursorGrabMode::None){
-							Ok(())=>(),
-							Err(e)=>println!("Could not release cursor: {:?}",e),
-						}
-						self.window.set_cursor_visible(state.is_pressed());
-					},
-					(winit::keyboard::Key::Named(winit::keyboard::NamedKey::Tab),winit::event::ElementState::Released)=>{
-						//if cursor is outside window don't lock but apparently there's no get pos function
-						//let pos=window.get_cursor_pos();
-						match self.window.set_cursor_grab(winit::window::CursorGrabMode::Locked){
-							Ok(())=>(),
-							Err(_)=>{
-								match self.window.set_cursor_grab(winit::window::CursorGrabMode::Confined){
-									Ok(())=>(),
-									Err(e)=>{
-										self.manual_mouse_lock=true;
-										println!("Could not confine cursor: {:?}",e)
-									},
-								}
-							}
-						}
-						self.window.set_cursor_visible(state.is_pressed());
-					},
+					(winit::keyboard::Key::Named(winit::keyboard::NamedKey::Tab),winit::event::ElementState::Pressed)=>self.free_mouse(),
+					(winit::keyboard::Key::Named(winit::keyboard::NamedKey::Tab),winit::event::ElementState::Released)=>self.lock_mouse(),
 					(winit::keyboard::Key::Named(winit::keyboard::NamedKey::F11),winit::event::ElementState::Pressed)=>{
 						if self.window.fullscreen().is_some(){
 							self.window.set_fullscreen(None);
@@ -131,8 +138,18 @@ impl WindowContext<'_>{
 
 						if let Some(session_instruction)=match keycode{
 							winit::keyboard::Key::Named(winit::keyboard::NamedKey::Space)=>input_ctrl!(SetJump,s),
+							winit::keyboard::Key::Named(winit::keyboard::NamedKey::Shift)=>input_ctrl!(SetSprint,s),
 							// TODO: bind system so playback pausing can use spacebar
-							winit::keyboard::Key::Named(winit::keyboard::NamedKey::Enter)=>session_playback!(TogglePaused,s),
+							winit::keyboard::Key::Named(winit::keyboard::NamedKey::Enter)=>if s{
+								let paused=!self.simulation_paused;
+								self.simulation_paused=paused;
+								if paused{
+									self.free_mouse();
+								}else{
+									self.lock_mouse();
+								}
+								Some(SessionInstructionSubset::Control(SessionControlInstruction::SetPaused(paused)))
+							}else{None},
 							winit::keyboard::Key::Named(winit::keyboard::NamedKey::ArrowUp)=>session_playback!(IncreaseTimescale,s),
 							winit::keyboard::Key::Named(winit::keyboard::NamedKey::ArrowDown)=>session_playback!(DecreaseTimescale,s),
 							winit::keyboard::Key::Named(winit::keyboard::NamedKey::ArrowLeft)=>session_playback!(SkipBack,s),
@@ -241,6 +258,7 @@ pub fn worker<'a>(
 	let mut window_context=WindowContext{
 		manual_mouse_lock:false,
 		mouse_pos:glam::DVec2::ZERO,
+		simulation_paused:false,
 		//make sure to update this!!!!!
 		screen_size,
 		window,