Compare commits
21 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
1a355cbe39
|
|||
|
c7346368c8
|
|||
|
845d837582
|
|||
|
dd930377ed
|
|||
|
d07bbdcc60
|
|||
|
33768bbb1d
|
|||
|
3bfe5fd8d4
|
|||
|
9141d2213e
|
|||
|
8029a15238
|
|||
|
60fa8670ff
|
|||
|
c6b7c01ac9
|
|||
|
8ce327e43f
|
|||
|
63af55d478
|
|||
|
02736d14a9
|
|||
|
90693b8539
|
|||
|
de81fdb2ba
|
|||
|
fcdb6bc93b
|
|||
|
f30f566bac
|
|||
|
9cb5861787
|
|||
|
cb371c66a6
|
|||
|
fdcf2fc8a5
|
206
Cargo.lock
generated
206
Cargo.lock
generated
@@ -73,56 +73,6 @@ dependencies = [
|
||||
"libc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "anstream"
|
||||
version = "0.6.21"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "43d5b281e737544384e969a5ccad3f1cdd24b48086a0fc1b2a5262a26b8f4f4a"
|
||||
dependencies = [
|
||||
"anstyle",
|
||||
"anstyle-parse",
|
||||
"anstyle-query",
|
||||
"anstyle-wincon",
|
||||
"colorchoice",
|
||||
"is_terminal_polyfill",
|
||||
"utf8parse",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "anstyle"
|
||||
version = "1.0.13"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5192cca8006f1fd4f7237516f40fa183bb07f8fbdfedaa0036de5ea9b0b45e78"
|
||||
|
||||
[[package]]
|
||||
name = "anstyle-parse"
|
||||
version = "0.2.7"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "4e7644824f0aa2c7b9384579234ef10eb7efb6a0deb83f9630a49594dd9c15c2"
|
||||
dependencies = [
|
||||
"utf8parse",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "anstyle-query"
|
||||
version = "1.1.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
|
||||
dependencies = [
|
||||
"windows-sys 0.61.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "anstyle-wincon"
|
||||
version = "3.0.11"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
|
||||
dependencies = [
|
||||
"anstyle",
|
||||
"once_cell_polyfill",
|
||||
"windows-sys 0.61.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "array-init"
|
||||
version = "2.1.0"
|
||||
@@ -340,46 +290,6 @@ version = "0.2.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
|
||||
|
||||
[[package]]
|
||||
name = "clap"
|
||||
version = "4.5.60"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "2797f34da339ce31042b27d23607e051786132987f595b02ba4f6a6dffb7030a"
|
||||
dependencies = [
|
||||
"clap_builder",
|
||||
"clap_derive",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "clap_builder"
|
||||
version = "4.5.60"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "24a241312cea5059b13574bb9b3861cabf758b879c15190b37b6d6fd63ab6876"
|
||||
dependencies = [
|
||||
"anstream",
|
||||
"anstyle",
|
||||
"clap_lex",
|
||||
"strsim",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "clap_derive"
|
||||
version = "4.5.55"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a92793da1a46a5f2a02a6f4c46c6496b28c43638adea8306fcb0caa1634f24e5"
|
||||
dependencies = [
|
||||
"heck",
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 2.0.117",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "clap_lex"
|
||||
version = "1.0.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3a822ea5bc7590f9d40f1ba12c0dc3c2760f3482c6984db1573ad11031420831"
|
||||
|
||||
[[package]]
|
||||
name = "codespan-reporting"
|
||||
version = "0.12.0"
|
||||
@@ -391,12 +301,6 @@ dependencies = [
|
||||
"unicode-width",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "colorchoice"
|
||||
version = "1.0.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75"
|
||||
|
||||
[[package]]
|
||||
name = "combine"
|
||||
version = "4.6.7"
|
||||
@@ -813,12 +717,6 @@ dependencies = [
|
||||
"foldhash 0.2.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "heck"
|
||||
version = "0.5.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
|
||||
|
||||
[[package]]
|
||||
name = "hermit-abi"
|
||||
version = "0.5.2"
|
||||
@@ -858,12 +756,6 @@ dependencies = [
|
||||
"hashbrown 0.16.1",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "is_terminal_polyfill"
|
||||
version = "1.70.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
|
||||
|
||||
[[package]]
|
||||
name = "itertools"
|
||||
version = "0.14.0"
|
||||
@@ -873,12 +765,6 @@ dependencies = [
|
||||
"either",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "itoa"
|
||||
version = "1.0.17"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
|
||||
|
||||
[[package]]
|
||||
name = "jni"
|
||||
version = "0.21.1"
|
||||
@@ -1055,20 +941,6 @@ dependencies = [
|
||||
"paste",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "mp4"
|
||||
version = "0.14.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c9ef834d5ed55e494a2ae350220314dc4aacd1c43a9498b00e320e0ea352a5c3"
|
||||
dependencies = [
|
||||
"byteorder",
|
||||
"bytes",
|
||||
"num-rational",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"thiserror 1.0.69",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "mp4ra-rust"
|
||||
version = "0.3.0"
|
||||
@@ -1140,37 +1012,6 @@ dependencies = [
|
||||
"jni-sys",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "num-bigint"
|
||||
version = "0.4.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
|
||||
dependencies = [
|
||||
"num-integer",
|
||||
"num-traits",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "num-integer"
|
||||
version = "0.1.46"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
|
||||
dependencies = [
|
||||
"num-traits",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "num-rational"
|
||||
version = "0.4.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824"
|
||||
dependencies = [
|
||||
"num-bigint",
|
||||
"num-integer",
|
||||
"num-traits",
|
||||
"serde",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "num-traits"
|
||||
version = "0.2.19"
|
||||
@@ -1421,12 +1262,6 @@ version = "1.21.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
|
||||
|
||||
[[package]]
|
||||
name = "once_cell_polyfill"
|
||||
version = "1.70.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
|
||||
|
||||
[[package]]
|
||||
name = "orbclient"
|
||||
version = "0.3.50"
|
||||
@@ -1792,19 +1627,6 @@ dependencies = [
|
||||
"syn 2.0.117",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "serde_json"
|
||||
version = "1.0.149"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
|
||||
dependencies = [
|
||||
"itoa",
|
||||
"memchr",
|
||||
"serde",
|
||||
"serde_core",
|
||||
"zmij",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "shlex"
|
||||
version = "1.3.0"
|
||||
@@ -1883,9 +1705,9 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
|
||||
|
||||
[[package]]
|
||||
name = "strafesnet_common"
|
||||
version = "0.8.7"
|
||||
version = "0.8.6"
|
||||
source = "sparse+https://git.itzana.me/api/packages/strafesnet/cargo/"
|
||||
checksum = "ac4eb613a8d86986b61aa6b52bd74ef605d370c149778fe96cfab16dc4377636"
|
||||
checksum = "fb31424f16d189979d9f5781067ff29169a258c11da6ff46a4196bffd96d61dc"
|
||||
dependencies = [
|
||||
"arrayvec",
|
||||
"bitflags 2.11.0",
|
||||
@@ -1898,9 +1720,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "strafesnet_graphics"
|
||||
version = "0.0.7"
|
||||
version = "0.0.5"
|
||||
source = "sparse+https://git.itzana.me/api/packages/strafesnet/cargo/"
|
||||
checksum = "5b0afe15871f8205f3387dd5816e797c0576429d3013a33a3daed293bcaeedef"
|
||||
checksum = "786feeee41d2a65707eea824ad928f1dad5be3fc82e80d541bb36e45fda1c9d6"
|
||||
dependencies = [
|
||||
"bytemuck",
|
||||
"ddsfile",
|
||||
@@ -1980,12 +1802,6 @@ version = "0.1.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6637bab7722d379c8b41ba849228d680cc12d0a45ba1fa2b48f2a30577a06731"
|
||||
|
||||
[[package]]
|
||||
name = "strsim"
|
||||
version = "0.11.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
|
||||
|
||||
[[package]]
|
||||
name = "syn"
|
||||
version = "1.0.109"
|
||||
@@ -2167,12 +1983,6 @@ version = "0.2.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
|
||||
|
||||
[[package]]
|
||||
name = "utf8parse"
|
||||
version = "0.2.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
|
||||
|
||||
[[package]]
|
||||
name = "version_check"
|
||||
version = "0.9.5"
|
||||
@@ -2183,9 +1993,7 @@ checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
|
||||
name = "video-encoder"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"clap",
|
||||
"glam",
|
||||
"mp4",
|
||||
"strafesnet_common",
|
||||
"strafesnet_graphics",
|
||||
"strafesnet_roblox_bot_file",
|
||||
@@ -3017,9 +2825,3 @@ dependencies = [
|
||||
"quote",
|
||||
"syn 2.0.117",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zmij"
|
||||
version = "1.0.21"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
|
||||
|
||||
@@ -14,16 +14,10 @@ codegen-units = 1
|
||||
|
||||
[workspace.dependencies]
|
||||
glam = "0.32.0"
|
||||
wgpu = "28.0.0"
|
||||
|
||||
strafesnet_common = { version = "0.8.6", registry = "strafesnet" }
|
||||
strafesnet_graphics = { version = "0.0.7", registry = "strafesnet" }
|
||||
strafesnet_graphics = { version = "0.0.5", registry = "strafesnet" }
|
||||
strafesnet_roblox_bot_file = { version = "0.9.3", registry = "strafesnet" }
|
||||
strafesnet_snf = { version = "0.3.2", registry = "strafesnet" }
|
||||
|
||||
strafesnet_roblox_bot_player = { version = "0.2.0", path = "lib" }
|
||||
|
||||
# strafesnet_common = { path = "../strafe-project/lib/common" }
|
||||
# strafesnet_graphics = { path = "../strafe-project/engine/graphics" }
|
||||
# strafesnet_roblox_bot_file = { path = "../roblox_bot_file" }
|
||||
# strafesnet_snf = { path = "../strafe-project/lib/snf" }
|
||||
|
||||
@@ -5,7 +5,7 @@ edition = "2024"
|
||||
|
||||
[dependencies]
|
||||
glam.workspace = true
|
||||
wgpu.workspace = true
|
||||
strafesnet_common.workspace = true
|
||||
strafesnet_graphics.workspace = true
|
||||
strafesnet_roblox_bot_file.workspace = true
|
||||
wgpu = "28.0.0"
|
||||
|
||||
@@ -34,10 +34,6 @@ impl CompleteBot{
|
||||
pub fn time(&self,time:PlaybackTime)->PhysicsTime{
|
||||
self.timer.time(time)
|
||||
}
|
||||
pub fn playback_time(&self,time:PhysicsTime)->PlaybackTime{
|
||||
use strafesnet_common::timer::TimerState;
|
||||
time.coerce()-self.timer.clone().into_state().get_offset().coerce()
|
||||
}
|
||||
pub const fn duration(&self)->PhysicsTime{
|
||||
self.duration
|
||||
}
|
||||
|
||||
101
lib/src/bvh.rs
101
lib/src/bvh.rs
@@ -1,101 +0,0 @@
|
||||
use core::ops::Range;
|
||||
use strafesnet_common::aabb::Aabb;
|
||||
use strafesnet_common::bvh::generate_bvh;
|
||||
use strafesnet_common::integer::vec3;
|
||||
use strafesnet_common::integer::Fixed;
|
||||
use strafesnet_common::physics::Time as PhysicsTime;
|
||||
use crate::bot::CompleteBot;
|
||||
|
||||
const MAX_SLICE_LEN:usize=16;
|
||||
struct EventSlice(Range<usize>);
|
||||
|
||||
pub struct Bvh{
|
||||
bvh:strafesnet_common::bvh::BvhNode<EventSlice>,
|
||||
}
|
||||
|
||||
impl Bvh{
|
||||
pub fn new(bot:&CompleteBot)->Self{
|
||||
let output_events=&bot.timelines().output_events;
|
||||
// iterator over the event timeline and capture slizes of contiguous output events.
|
||||
// create an Aabb for each slice and then generate a BVH.
|
||||
let mut bvh_nodes=Vec::new();
|
||||
let it=output_events
|
||||
.array_windows()
|
||||
.enumerate()
|
||||
// find discontinuities
|
||||
.filter(|&(_,[event0,event1])|
|
||||
event0.time==event1.time&&!(
|
||||
event0.event.position.x==event0.event.position.x
|
||||
&&event0.event.position.y==event0.event.position.y
|
||||
&&event0.event.position.z==event0.event.position.z
|
||||
)
|
||||
);
|
||||
|
||||
let mut last_index=0;
|
||||
let mut push_slices=|index:usize|{
|
||||
let len=index-last_index;
|
||||
let count=len.div_ceil(MAX_SLICE_LEN);
|
||||
let slice_len=len/count;
|
||||
bvh_nodes.reserve(count);
|
||||
// 0123456789
|
||||
// last_index=0
|
||||
// split_index=9
|
||||
// index=10
|
||||
// len=10
|
||||
// count=3
|
||||
// node_len=4
|
||||
// split into groups of 4
|
||||
// [0123][4567][89]
|
||||
let mut push_slice=|slice:Range<usize>|{
|
||||
let mut aabb=Aabb::default();
|
||||
for event in &output_events[slice.start..slice.end]{
|
||||
aabb.grow(vec3::try_from_f32_array([event.event.position.x,event.event.position.y,event.event.position.z]).unwrap());
|
||||
}
|
||||
bvh_nodes.push((EventSlice(slice),aabb));
|
||||
};
|
||||
// push fixed-size groups
|
||||
for i in 0..count-1{
|
||||
push_slice((last_index+i*slice_len)..(last_index+(i+1)*slice_len));
|
||||
}
|
||||
// push last group which may be shorter
|
||||
push_slice((last_index+(count-1)*slice_len)..index);
|
||||
last_index=index;
|
||||
};
|
||||
// find discontinuities (teleports) and avoid forming a nvh node across them
|
||||
for (split_index,_) in it{
|
||||
// we want to use the index of event1
|
||||
push_slices(split_index+1);
|
||||
}
|
||||
// there are no more discontinuities, push the remaining slices
|
||||
push_slices(output_events.len());
|
||||
let bvh=generate_bvh(bvh_nodes);
|
||||
Self{bvh}
|
||||
}
|
||||
/// Find the exact timestamp on the bot timeline that is closest to the given point.
|
||||
pub fn closest_time_to_point(&self,bot:&CompleteBot,point:glam::Vec3)->Option<PhysicsTime>{
|
||||
let start_point=vec3::try_from_f32_array(point.to_array()).unwrap();
|
||||
let output_events=&bot.timelines().output_events;
|
||||
// grow a sphere starting at start_point until we find the closest point on the bot output events
|
||||
let intersect_leaf=|leaf:&EventSlice|{
|
||||
// calculate the distance to the leaf contents
|
||||
output_events[leaf.0.start..leaf.0.end].iter().map(|event|{
|
||||
let p=event.event.position;
|
||||
let p=vec3::try_from_f32_array([p.x,p.y,p.z]).unwrap();
|
||||
(start_point-p).length_squared()
|
||||
}).min()
|
||||
};
|
||||
let intersect_aabb=|aabb:&Aabb|{
|
||||
// calculate the distance to the aabb
|
||||
let clamped_point=start_point.min(aabb.max()).max(aabb.min());
|
||||
Some((start_point-clamped_point).length_squared())
|
||||
};
|
||||
let (_,leaf)=self.bvh.traverse(start_point,Fixed::ZERO,Fixed::MAX,intersect_leaf,intersect_aabb)?;
|
||||
let closest_event=output_events[leaf.0.start..leaf.0.end].iter().min_by_key(|&event|{
|
||||
let p=event.event.position;
|
||||
let p=vec3::try_from_f32_array([p.x,p.y,p.z]).unwrap();
|
||||
(start_point-p).length_squared()
|
||||
})?;
|
||||
// TODO: project start_point onto the edges connected to the closest_event and return the true time
|
||||
crate::time::from_float(closest_event.time).ok()
|
||||
}
|
||||
}
|
||||
@@ -3,28 +3,58 @@ use strafesnet_graphics::graphics::GraphicsState;
|
||||
/// The graphics state, essentially a handle to all the information on the GPU.
|
||||
pub struct Graphics{
|
||||
graphics:GraphicsState,
|
||||
config:wgpu::SurfaceConfiguration,
|
||||
device:wgpu::Device,
|
||||
queue:wgpu::Queue,
|
||||
start_offset:glam::Vec3,
|
||||
}
|
||||
impl Graphics{
|
||||
pub fn new(device:&wgpu::Device,queue:&wgpu::Queue,size:glam::UVec2,view_format:wgpu::TextureFormat)->Self{
|
||||
let graphics=strafesnet_graphics::graphics::GraphicsState::new(device,queue,size,view_format);
|
||||
pub fn new(device:wgpu::Device,queue:wgpu::Queue,config:wgpu::SurfaceConfiguration)->Self{
|
||||
let graphics=strafesnet_graphics::graphics::GraphicsState::new(&device,&queue,glam::uvec2(config.width,config.height),config.view_formats[0]);
|
||||
Self{
|
||||
graphics,
|
||||
device,
|
||||
queue,
|
||||
config,
|
||||
start_offset:glam::Vec3::ZERO,
|
||||
}
|
||||
}
|
||||
pub fn change_map(&mut self,device:&wgpu::Device,queue:&wgpu::Queue,map:&strafesnet_common::map::CompleteMap){
|
||||
pub fn change_map(&mut self,map:&strafesnet_common::map::CompleteMap){
|
||||
self.graphics.clear();
|
||||
self.graphics.generate_models(device,queue,map);
|
||||
self.graphics.generate_models(&self.device,&self.queue,map);
|
||||
let modes=map.modes.clone().denormalize();
|
||||
let mode=modes.get_mode(strafesnet_common::gameplay_modes::ModeId::MAIN).expect("Map does not have a main mode");
|
||||
let start_zone=map.models.get(mode.get_start().get() as usize).expect("Map does not have a start zone");
|
||||
self.start_offset=glam::Vec3::from_array(start_zone.transform.translation.map(|f|f.into()).to_array());
|
||||
}
|
||||
pub fn resize(&mut self,device:&wgpu::Device,size:glam::UVec2,fov:glam::Vec2){
|
||||
self.graphics.resize(device,size,fov);
|
||||
pub fn resize(&mut self,surface:&wgpu::Surface<'_>,size:glam::UVec2,fov:glam::Vec2){
|
||||
self.config.width=size.x.max(1);
|
||||
self.config.height=size.y.max(1);
|
||||
surface.configure(&self.device,&self.config);
|
||||
self.graphics.resize(&self.device,size,fov);
|
||||
}
|
||||
pub fn encode_commands(&mut self,encoder:&mut wgpu::CommandEncoder,view:&wgpu::TextureView,pos:glam::Vec3,angles:glam::Vec2){
|
||||
self.graphics.encode_commands(encoder,view,strafesnet_graphics::graphics::view_inv(pos+self.start_offset,angles));
|
||||
pub fn render(&mut self,surface:&wgpu::Surface<'_>,pos:glam::Vec3,angles:glam::Vec2){
|
||||
//this has to go deeper somehow
|
||||
let frame=match surface.get_current_texture(){
|
||||
Ok(frame)=>frame,
|
||||
Err(_)=>{
|
||||
surface.configure(&self.device,&self.config);
|
||||
surface
|
||||
.get_current_texture()
|
||||
.expect("Failed to acquire next surface texture!")
|
||||
}
|
||||
};
|
||||
let view=frame.texture.create_view(&wgpu::TextureViewDescriptor{
|
||||
format:Some(self.config.view_formats[0]),
|
||||
..wgpu::TextureViewDescriptor::default()
|
||||
});
|
||||
|
||||
let mut encoder=self.device.create_command_encoder(&wgpu::CommandEncoderDescriptor{label:None});
|
||||
|
||||
self.graphics.encode_commands(&mut encoder,&view,strafesnet_graphics::graphics::view_inv(pos+self.start_offset,angles));
|
||||
|
||||
self.queue.submit([encoder.finish()]);
|
||||
|
||||
frame.present();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -119,10 +119,6 @@ impl PlaybackHead{
|
||||
|
||||
(p-bot.world_offset()+CompleteBot::CAMERA_OFFSET,a.yx())
|
||||
}
|
||||
pub fn get_position(&self,bot:&CompleteBot,time:SessionTime)->glam::Vec3{
|
||||
let interp=self.interpolate_output(bot,time);
|
||||
interp.position()
|
||||
}
|
||||
pub fn get_velocity(&self,bot:&CompleteBot,time:SessionTime)->glam::Vec3{
|
||||
let interp=self.interpolate_output(bot,time);
|
||||
interp.velocity()
|
||||
|
||||
@@ -1,6 +1,15 @@
|
||||
pub mod bot;
|
||||
pub mod bvh;
|
||||
pub mod head;
|
||||
pub mod time;
|
||||
pub mod state;
|
||||
// pub mod surface;
|
||||
pub mod graphics;
|
||||
|
||||
// Create Surface
|
||||
// Create Graphics from map file and with surface as sample
|
||||
// Create bot from bot file
|
||||
// Create playback head
|
||||
// loop{
|
||||
// advance head
|
||||
// render frame
|
||||
// }
|
||||
|
||||
2
lib/src/surface.rs
Normal file
2
lib/src/surface.rs
Normal file
@@ -0,0 +1,2 @@
|
||||
/// A render surface configuration, containing information such as resolution and pixel format
|
||||
pub struct Surface{}
|
||||
@@ -4,10 +4,10 @@ version = "0.1.0"
|
||||
edition = "2024"
|
||||
|
||||
[dependencies]
|
||||
pollster = "0.4.0"
|
||||
winit = "0.30.12"
|
||||
glam.workspace = true
|
||||
wgpu.workspace = true
|
||||
pollster = "0.4.0"
|
||||
wgpu = "28.0.0"
|
||||
winit = "0.30.12"
|
||||
strafesnet_roblox_bot_player.workspace = true
|
||||
strafesnet_common.workspace = true
|
||||
strafesnet_graphics.workspace = true
|
||||
|
||||
@@ -2,7 +2,6 @@ use strafesnet_common::instruction::TimedInstruction;
|
||||
use strafesnet_common::session::Time as SessionTime;
|
||||
use strafesnet_common::timer::TimerState;
|
||||
use strafesnet_roblox_bot_player::{bot::CompleteBot,graphics::Graphics,head::{PlaybackHead,Time as PlaybackTime}};
|
||||
use strafesnet_graphics::surface::Surface;
|
||||
|
||||
pub enum SessionControlInstruction{
|
||||
SetPaused(bool),
|
||||
@@ -36,22 +35,22 @@ struct Playback{
|
||||
}
|
||||
|
||||
pub struct PlayerWorker<'a>{
|
||||
surface:wgpu::Surface<'a>,
|
||||
graphics_thread:Graphics,
|
||||
surface:Surface<'a>,
|
||||
playback:Option<Playback>,
|
||||
}
|
||||
impl<'a> PlayerWorker<'a>{
|
||||
pub fn new(
|
||||
surface:wgpu::Surface<'a>,
|
||||
graphics_thread:Graphics,
|
||||
surface:Surface<'a>,
|
||||
)->Self{
|
||||
Self{
|
||||
graphics_thread,
|
||||
surface,
|
||||
graphics_thread,
|
||||
playback:None,
|
||||
}
|
||||
}
|
||||
pub fn send(&mut self,device:&wgpu::Device,queue:&wgpu::Queue,ins:TimedInstruction<Instruction,SessionTime>){
|
||||
pub fn send(&mut self,ins:TimedInstruction<Instruction,SessionTime>){
|
||||
match ins.instruction{
|
||||
Instruction::SessionControl(SessionControlInstruction::SetPaused(paused))=>if let Some(playback)=&mut self.playback{
|
||||
playback.playback_head.set_paused(ins.time,paused);
|
||||
@@ -78,28 +77,15 @@ impl<'a> PlayerWorker<'a>{
|
||||
Instruction::Render=>if let Some(playback)=&mut self.playback{
|
||||
playback.playback_head.advance_time(&playback.bot,ins.time);
|
||||
let (pos,angles)=playback.playback_head.get_position_angles(&playback.bot,ins.time);
|
||||
|
||||
//this has to go deeper somehow
|
||||
let frame=self.surface.new_frame(device);
|
||||
|
||||
let mut encoder=device.create_command_encoder(&wgpu::CommandEncoderDescriptor{label:None});
|
||||
|
||||
self.graphics_thread.encode_commands(&mut encoder,frame.view(),pos,angles);
|
||||
|
||||
queue.submit([encoder.finish()]);
|
||||
|
||||
frame.present();
|
||||
self.graphics_thread.render(&self.surface,pos,angles);
|
||||
},
|
||||
Instruction::Resize(physical_size)=>if let Some(playback)=&self.playback{
|
||||
let fov_y=playback.playback_head.state().get_fov_y();
|
||||
let fov_x=fov_y*physical_size.width as f64/physical_size.height as f64;
|
||||
let fov=glam::vec2(fov_x as f32,fov_y as f32);
|
||||
let size=glam::uvec2(physical_size.width,physical_size.height);
|
||||
self.surface.configure(device,size);
|
||||
self.graphics_thread.resize(device,size,fov);
|
||||
self.graphics_thread.resize(&self.surface,glam::uvec2(physical_size.width,physical_size.height),glam::vec2(fov_x as f32,fov_y as f32));
|
||||
},
|
||||
Instruction::ChangeMap(complete_map)=>{
|
||||
self.graphics_thread.change_map(device,queue,&complete_map);
|
||||
self.graphics_thread.change_map(&complete_map);
|
||||
},
|
||||
Instruction::LoadReplay(bot)=>{
|
||||
let bot=CompleteBot::new(bot);
|
||||
|
||||
@@ -22,7 +22,7 @@ pub async fn setup_and_start(title:&str){
|
||||
let (device,queue)=setup::step4::request_device(&adapter).await.unwrap();
|
||||
|
||||
let size=window.inner_size();
|
||||
let surface=setup::step5::configure_surface(&adapter,&device,surface,(size.width,size.height)).unwrap();
|
||||
let config=setup::step5::configure_surface(&adapter,&device,&surface,(size.width,size.height)).unwrap();
|
||||
|
||||
//dedicated thread to ping request redraw back and resize the window doesn't seem logical
|
||||
|
||||
@@ -32,6 +32,7 @@ pub async fn setup_and_start(title:&str){
|
||||
device,
|
||||
queue,
|
||||
surface,
|
||||
config,
|
||||
);
|
||||
|
||||
for arg in std::env::args().skip(1){
|
||||
|
||||
@@ -13,20 +13,15 @@ pub struct WindowContext<'a>{
|
||||
simulation_paused:bool,
|
||||
window:&'a winit::window::Window,
|
||||
physics_thread:PlayerWorker<'a>,
|
||||
device:wgpu::Device,
|
||||
queue:wgpu::Queue,
|
||||
}
|
||||
|
||||
impl WindowContext<'_>{
|
||||
fn phys(&mut self,ins:TimedInstruction<crate::player::Instruction,strafesnet_common::session::Time>){
|
||||
self.physics_thread.send(&self.device,&self.queue,ins);
|
||||
}
|
||||
fn window_event(&mut self,time:SessionTime,event:winit::event::WindowEvent){
|
||||
match event{
|
||||
winit::event::WindowEvent::DroppedFile(path)=>{
|
||||
match crate::file::load(path.as_path()){
|
||||
Ok(LoadFormat::Map(map))=>self.phys(TimedInstruction{time,instruction:PhysicsWorkerInstruction::ChangeMap(map)}),
|
||||
Ok(LoadFormat::Bot(bot))=>self.phys(TimedInstruction{time,instruction:PhysicsWorkerInstruction::LoadReplay(bot)}),
|
||||
Ok(LoadFormat::Map(map))=>self.physics_thread.send(TimedInstruction{time,instruction:PhysicsWorkerInstruction::ChangeMap(map)}),
|
||||
Ok(LoadFormat::Bot(bot))=>self.physics_thread.send(TimedInstruction{time,instruction:PhysicsWorkerInstruction::LoadReplay(bot)}),
|
||||
Err(e)=>println!("Failed to load file: {e}"),
|
||||
}
|
||||
},
|
||||
@@ -36,7 +31,7 @@ impl WindowContext<'_>{
|
||||
return;
|
||||
}
|
||||
//pause unpause
|
||||
self.phys(TimedInstruction{
|
||||
self.physics_thread.send(TimedInstruction{
|
||||
time,
|
||||
instruction:PhysicsWorkerInstruction::SessionControl(SessionControlInstruction::SetPaused(!state)),
|
||||
});
|
||||
@@ -79,7 +74,7 @@ impl WindowContext<'_>{
|
||||
},
|
||||
_=>None,
|
||||
}{
|
||||
self.phys(TimedInstruction{
|
||||
self.physics_thread.send(TimedInstruction{
|
||||
time,
|
||||
instruction,
|
||||
});
|
||||
@@ -88,7 +83,7 @@ impl WindowContext<'_>{
|
||||
}
|
||||
},
|
||||
winit::event::WindowEvent::Resized(size)=>{
|
||||
self.phys(
|
||||
self.physics_thread.send(
|
||||
TimedInstruction{
|
||||
time,
|
||||
instruction:PhysicsWorkerInstruction::Resize(size)
|
||||
@@ -97,7 +92,7 @@ impl WindowContext<'_>{
|
||||
},
|
||||
winit::event::WindowEvent::RedrawRequested=>{
|
||||
self.window.request_redraw();
|
||||
self.phys(
|
||||
self.physics_thread.send(
|
||||
TimedInstruction{
|
||||
time,
|
||||
instruction:PhysicsWorkerInstruction::Render
|
||||
@@ -126,19 +121,17 @@ impl WindowContext<'_>{
|
||||
window:&'a winit::window::Window,
|
||||
device:wgpu::Device,
|
||||
queue:wgpu::Queue,
|
||||
surface:strafesnet_graphics::surface::Surface<'a>,
|
||||
surface:wgpu::Surface<'a>,
|
||||
config:wgpu::SurfaceConfiguration,
|
||||
)->WindowContext<'a>{
|
||||
let size=surface.size();
|
||||
let graphics=strafesnet_roblox_bot_player::graphics::Graphics::new(&device,&queue,size,surface.view_format());
|
||||
let graphics=strafesnet_roblox_bot_player::graphics::Graphics::new(device,queue,config);
|
||||
WindowContext{
|
||||
simulation_paused:false,
|
||||
window,
|
||||
physics_thread:crate::player::PlayerWorker::new(
|
||||
graphics,
|
||||
surface,
|
||||
graphics,
|
||||
),
|
||||
device,
|
||||
queue,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -5,12 +5,10 @@ edition = "2024"
|
||||
|
||||
[dependencies]
|
||||
glam.workspace = true
|
||||
wgpu.workspace = true
|
||||
wgpu = "28.0.0"
|
||||
strafesnet_roblox_bot_player.workspace = true
|
||||
strafesnet_common.workspace = true
|
||||
strafesnet_graphics.workspace = true
|
||||
strafesnet_roblox_bot_file.workspace = true
|
||||
strafesnet_snf.workspace = true
|
||||
vk-video = "0.2.0"
|
||||
clap = { version = "4.5.60", features = ["derive"] }
|
||||
mp4 = "0.14.0"
|
||||
|
||||
@@ -1,4 +0,0 @@
|
||||
### How it works
|
||||
- Render RGB to graphics_texture
|
||||
- Convert RGB to YUV on video_texture
|
||||
- Encode video frame
|
||||
@@ -1,25 +1,20 @@
|
||||
struct VertexOutput {
|
||||
@builtin(position) position: vec4<f32>,
|
||||
@location(1) uv: vec2<f32>,
|
||||
}
|
||||
|
||||
@vertex
|
||||
fn vs_main(@builtin(vertex_index) vertex_index: u32) -> VertexOutput {
|
||||
// hacky way to draw a large triangle
|
||||
let tmp1 = i32(vertex_index) / 2;
|
||||
let tmp2 = i32(vertex_index) & 1;
|
||||
var result:VertexOutput;
|
||||
result.position=vec4<f32>(
|
||||
f32(tmp1) * 4.0 - 1.0,
|
||||
f32(tmp2) * 4.0 - 1.0,
|
||||
1.0,
|
||||
1.0
|
||||
);
|
||||
result.uv=vec2<f32>(
|
||||
f32(tmp1) * 2.0,
|
||||
1.0 - f32(tmp2) * 2.0
|
||||
);
|
||||
return result;
|
||||
// hacky way to draw a large triangle
|
||||
let tmp1 = i32(vertex_index) / 2;
|
||||
let tmp2 = i32(vertex_index) & 1;
|
||||
var result:VertexOutput;
|
||||
result.position=vec4<f32>(
|
||||
f32(tmp1) * 4.0 - 1.0,
|
||||
f32(tmp2) * 4.0 - 1.0,
|
||||
1.0,
|
||||
1.0
|
||||
);
|
||||
return result;
|
||||
}
|
||||
|
||||
@group(0)
|
||||
@@ -29,27 +24,23 @@ var texture: texture_2d<f32>;
|
||||
@binding(1)
|
||||
var texture_sampler: sampler;
|
||||
|
||||
const RGB_TO_Y:vec3<f32> =
|
||||
vec3(0.2126,0.7152,0.0722);
|
||||
const RGB_TO_UV:mat3x2<f32> = mat3x2<f32>(
|
||||
-0.09991,0.615,
|
||||
-0.33609,-0.55861,
|
||||
0.436,-0.05639
|
||||
);
|
||||
const BIAS:vec2<f32> = vec2<f32>(0.5, 0.5);
|
||||
|
||||
@fragment
|
||||
fn fs_main_y(input: VertexOutput) -> @location(0) f32 {
|
||||
let color = textureSample(texture, texture_sampler, input.uv).rgb;
|
||||
let y = dot(RGB_TO_Y,color);
|
||||
let y_limited = mix(16.0/255.0,240.0/255.0,y);
|
||||
return clamp(y_limited, 0.0, 1.0);
|
||||
let conversion_weights = vec3<f32>(0.2126, 0.7152, 0.0722);
|
||||
let color = textureSample(texture, texture_sampler, input.position.xy).rgb;
|
||||
|
||||
return clamp(dot(color, conversion_weights), 0.0, 1.0);
|
||||
}
|
||||
|
||||
@fragment
|
||||
fn fs_main_uv(input: VertexOutput) -> @location(0) vec2<f32> {
|
||||
let color = textureSample(texture, texture_sampler, input.uv).rgb;
|
||||
let uv = RGB_TO_UV * color + BIAS;
|
||||
let uv_limited = mix(vec2(16.0/255.0),vec2(240.0/255.0),uv);
|
||||
return clamp(uv_limited, vec2(0.0, 0.0), vec2(1.0, 1.0));
|
||||
let conversion_weights = mat3x2<f32>(
|
||||
-0.1146, 0.5,
|
||||
-0.3854, -0.4542,
|
||||
0.5, -0.0458,
|
||||
);
|
||||
let conversion_bias = vec2<f32>(0.5, 0.5);
|
||||
let color = textureSample(texture, texture_sampler, input.position.xy).rgb;
|
||||
|
||||
return clamp(conversion_weights * color + conversion_bias, vec2(0.0, 0.0), vec2(1.0, 1.0));
|
||||
}
|
||||
|
||||
@@ -1,24 +1,5 @@
|
||||
use clap::{Parser,Subcommand};
|
||||
|
||||
mod encode;
|
||||
|
||||
#[derive(Parser)]
|
||||
#[command(author,version,about,long_about=None)]
|
||||
#[command(propagate_version=true)]
|
||||
struct Cli{
|
||||
#[command(subcommand)]
|
||||
command:Commands,
|
||||
}
|
||||
|
||||
#[derive(Subcommand)]
|
||||
enum Commands{
|
||||
#[command(flatten)]
|
||||
Encode(encode::Commands),
|
||||
}
|
||||
mod setup;
|
||||
|
||||
fn main(){
|
||||
let cli=Cli::parse();
|
||||
match cli.command{
|
||||
Commands::Encode(commands)=>commands.run(),
|
||||
}
|
||||
setup::setup_and_start();
|
||||
}
|
||||
|
||||
@@ -1,129 +1,28 @@
|
||||
use std::num::NonZeroU32;
|
||||
use std::path::PathBuf;
|
||||
use std::io::Write;
|
||||
use strafesnet_common::session::Time as SessionTime;
|
||||
|
||||
#[derive(clap::Subcommand)]
|
||||
pub enum Commands{
|
||||
Encode(EncodeSubcommand),
|
||||
}
|
||||
|
||||
impl Commands{
|
||||
pub fn run(self){
|
||||
match self{
|
||||
Commands::Encode(command)=>command.run().unwrap(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(clap::Args)]
|
||||
pub struct EncodeSubcommand{
|
||||
#[arg(long,short)]
|
||||
map:PathBuf,
|
||||
#[arg(long,short)]
|
||||
bot:PathBuf,
|
||||
#[arg(long,short)]
|
||||
output_file:Option<PathBuf>,
|
||||
#[arg(long,short)]
|
||||
width:Option<NonZeroU32>,
|
||||
#[arg(long,short)]
|
||||
height:Option<NonZeroU32>,
|
||||
#[arg(long)]
|
||||
fps:Option<u32>,
|
||||
#[arg(long)]
|
||||
target_bitrate:Option<u64>,
|
||||
#[arg(long)]
|
||||
max_bitrate:Option<u64>,
|
||||
#[arg(long)]
|
||||
device:Option<String>,
|
||||
}
|
||||
impl EncodeSubcommand{
|
||||
fn run(self)->Result<(),EncodeError>{
|
||||
encode(EncodeParams{
|
||||
width:self.width.unwrap_or(NonZeroU32::new(1920).unwrap()),
|
||||
height:self.width.unwrap_or(NonZeroU32::new(1080).unwrap()),
|
||||
target_framerate:self.fps.unwrap_or(60),
|
||||
average_bitrate:self.target_bitrate.unwrap_or(6_000_000),
|
||||
max_bitrate:self.max_bitrate.unwrap_or(6_000_000),
|
||||
device:self.device,
|
||||
output_file:self.output_file.unwrap_or_else(||{
|
||||
let mut output_file:PathBuf=self.bot.file_stem().unwrap().into();
|
||||
output_file.set_extension("mp4");
|
||||
output_file
|
||||
}),
|
||||
map:self.map,
|
||||
bot:self.bot,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[expect(dead_code)]
|
||||
#[derive(Debug)]
|
||||
enum EncodeError{
|
||||
ReadMap(std::io::Error),
|
||||
ReadBot(std::io::Error),
|
||||
DecodeSNF(strafesnet_snf::Error),
|
||||
DecodeMap(strafesnet_snf::map::Error),
|
||||
DecodeBot(strafesnet_roblox_bot_file::v0::Error),
|
||||
CreateInstance(vk_video::VulkanInitError),
|
||||
CreateAdapter(vk_video::VulkanInitError),
|
||||
NoAdapter,
|
||||
CreateDevice(vk_video::VulkanInitError),
|
||||
VideoEncodeParams(vk_video::VulkanEncoderError),
|
||||
VideoCreateTextures(vk_video::VulkanEncoderError),
|
||||
VideoEncodeFrame(vk_video::VulkanEncoderError),
|
||||
OutputCreateFile(std::io::Error),
|
||||
OutputMp4Start(mp4::Error),
|
||||
OutputMp4AddTrack(mp4::Error),
|
||||
OutputMp4WriteSample(mp4::Error),
|
||||
OutputMp4End(mp4::Error),
|
||||
}
|
||||
|
||||
struct EncodeParams{
|
||||
width:NonZeroU32,
|
||||
height:NonZeroU32,
|
||||
target_framerate:u32,
|
||||
average_bitrate:u64,
|
||||
max_bitrate:u64,
|
||||
device:Option<String>,
|
||||
map:PathBuf,
|
||||
bot:PathBuf,
|
||||
output_file:PathBuf,
|
||||
}
|
||||
|
||||
fn encode(params:EncodeParams)->Result<(),EncodeError>{
|
||||
let size = glam::uvec2(params.width.get(),params.height.get());
|
||||
let target_framerate = params.target_framerate;
|
||||
let average_bitrate = params.average_bitrate;
|
||||
let max_bitrate = params.max_bitrate;
|
||||
|
||||
let map_file=std::fs::read(params.map).map_err(EncodeError::ReadMap)?;
|
||||
let bot_file=std::fs::read(params.bot).map_err(EncodeError::ReadBot)?;
|
||||
|
||||
// read files
|
||||
let map=strafesnet_snf::read_map(std::io::Cursor::new(map_file))
|
||||
.map_err(EncodeError::DecodeSNF)?
|
||||
.into_complete_map()
|
||||
.map_err(EncodeError::DecodeMap)?;
|
||||
let timelines=strafesnet_roblox_bot_file::v0::read_all_to_block(std::io::Cursor::new(bot_file))
|
||||
.map_err(EncodeError::DecodeBot)?;
|
||||
|
||||
// vulkan init
|
||||
let vulkan_instance = vk_video::VulkanInstance::new().map_err(EncodeError::CreateInstance)?;
|
||||
let vulkan_adapter = if let Some(filter)=params.device.as_deref(){
|
||||
vulkan_instance.iter_adapters(None)
|
||||
.map_err(EncodeError::CreateAdapter)?
|
||||
.find(|adapter|adapter.info().name.contains(filter))
|
||||
.ok_or(EncodeError::NoAdapter)?
|
||||
}else{
|
||||
vulkan_instance.create_adapter(None).map_err(EncodeError::CreateAdapter)?
|
||||
};
|
||||
pub fn setup_and_start(){
|
||||
let vulkan_instance = vk_video::VulkanInstance::new().unwrap();
|
||||
let vulkan_adapter = vulkan_instance.create_adapter(None).unwrap();
|
||||
let vulkan_device = vulkan_adapter
|
||||
.create_device(
|
||||
wgpu::Features::TEXTURE_COMPRESSION_BC,
|
||||
wgpu::ExperimentalFeatures::disabled(),
|
||||
wgpu::Limits::defaults(),
|
||||
)
|
||||
.map_err(EncodeError::CreateDevice)?;
|
||||
.unwrap();
|
||||
|
||||
let size = glam::uvec2(1920,1080);
|
||||
let target_framerate = 60;
|
||||
let average_bitrate = 10_000_000;
|
||||
let max_bitrate = 20_000_000;
|
||||
|
||||
let bot_file=include_bytes!("../../web-demo/bhop_marble_7cf33a64-7120-4514-b9fa-4fe29d9523d.qbot");
|
||||
let map_file=include_bytes!("../../web-demo/bhop_marble_5692093612.snfm");
|
||||
|
||||
// decode
|
||||
let timelines=strafesnet_roblox_bot_file::v0::read_all_to_block(std::io::Cursor::new(bot_file)).unwrap();
|
||||
let map=strafesnet_snf::read_map(std::io::Cursor::new(map_file)).unwrap().into_complete_map().unwrap();
|
||||
|
||||
// playback
|
||||
let bot=strafesnet_roblox_bot_player::bot::CompleteBot::new(timelines);
|
||||
@@ -142,8 +41,8 @@ fn encode(params:EncodeParams)->Result<(),EncodeError>{
|
||||
vulkan_device
|
||||
.encoder_parameters_high_quality(
|
||||
vk_video::parameters::VideoParameters {
|
||||
width:params.width,
|
||||
height:params.height,
|
||||
width:size.x.try_into().unwrap(),
|
||||
height:size.y.try_into().unwrap(),
|
||||
target_framerate:target_framerate.into(),
|
||||
},
|
||||
vk_video::parameters::RateControl::VariableBitrate {
|
||||
@@ -152,81 +51,41 @@ fn encode(params:EncodeParams)->Result<(),EncodeError>{
|
||||
virtual_buffer_size: std::time::Duration::from_secs(2),
|
||||
},
|
||||
)
|
||||
.map_err(EncodeError::VideoEncodeParams)?,
|
||||
.unwrap(),
|
||||
)
|
||||
.map_err(EncodeError::VideoCreateTextures)?;
|
||||
.unwrap();
|
||||
|
||||
let output_file=std::fs::File::create(params.output_file)
|
||||
.map_err(EncodeError::OutputCreateFile)?;
|
||||
|
||||
let mp4_config=mp4::Mp4Config{
|
||||
major_brand: str::parse("isom").unwrap(),
|
||||
minor_version: 512,
|
||||
compatible_brands: vec![
|
||||
str::parse("isom").unwrap(),
|
||||
str::parse("iso2").unwrap(),
|
||||
str::parse("avc1").unwrap(),
|
||||
str::parse("mp41").unwrap(),
|
||||
],
|
||||
timescale:target_framerate,
|
||||
};
|
||||
let mut mp4=mp4::Mp4Writer::write_start(output_file,&mp4_config)
|
||||
.map_err(EncodeError::OutputMp4Start)?;
|
||||
|
||||
let avc_config=mp4::AvcConfig{
|
||||
width:params.width.get() as u16,
|
||||
height:params.height.get() as u16,
|
||||
// make up some data to prevent this underdeveloped library from crashing
|
||||
seq_param_set:vec![0,0,0,0],
|
||||
pic_param_set:vec![],
|
||||
};
|
||||
let track_config=mp4::TrackConfig{
|
||||
track_type:mp4::TrackType::Video,
|
||||
timescale:target_framerate,
|
||||
language:"eng".to_owned(),
|
||||
media_conf:mp4::MediaConfig::AvcConfig(avc_config),
|
||||
};
|
||||
|
||||
const TRACK_ID:u32=1;
|
||||
mp4.add_track(&track_config)
|
||||
.map_err(EncodeError::OutputMp4AddTrack)?;
|
||||
let mut output_file = std::fs::File::create("output.h264").unwrap();
|
||||
|
||||
let duration = bot.duration();
|
||||
for i in 0..duration.get()*target_framerate as i64/SessionTime::ONE_SECOND.get() {
|
||||
let time=SessionTime::raw(i*SessionTime::ONE_SECOND.get()/target_framerate as i64);
|
||||
playback_head.advance_time(&bot,time);
|
||||
let (pos,angles)=playback_head.get_position_angles(&bot,time);
|
||||
wgpu_state.render(pos,angles);
|
||||
let camera=strafesnet_graphics::graphics::view_inv(pos,angles);
|
||||
wgpu_state.render(camera);
|
||||
|
||||
let frame=vk_video::Frame{
|
||||
data:wgpu_state.video_texture.clone(),
|
||||
pts:None,
|
||||
let res = unsafe {
|
||||
encoder
|
||||
.encode(
|
||||
vk_video::Frame {
|
||||
data: wgpu_state.video_texture.clone(),
|
||||
pts: None,
|
||||
},
|
||||
false,
|
||||
)
|
||||
.unwrap()
|
||||
};
|
||||
let res=unsafe{encoder.encode(frame,false)}
|
||||
.map_err(EncodeError::VideoEncodeFrame)?;
|
||||
|
||||
let mp4_sample=mp4::Mp4Sample{
|
||||
start_time:i as u64,
|
||||
duration:1,
|
||||
rendering_offset:0,
|
||||
is_sync:false,
|
||||
bytes:res.data.into(),
|
||||
};
|
||||
mp4.write_sample(TRACK_ID,&mp4_sample)
|
||||
.map_err(EncodeError::OutputMp4WriteSample)?;
|
||||
output_file.write_all(&res.data).unwrap();
|
||||
}
|
||||
|
||||
mp4.write_end()
|
||||
.map_err(EncodeError::OutputMp4End)?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
struct WgpuState {
|
||||
device: wgpu::Device,
|
||||
queue: wgpu::Queue,
|
||||
// graphics output
|
||||
graphics:strafesnet_roblox_bot_player::graphics::Graphics,
|
||||
graphics: strafesnet_graphics::graphics::GraphicsState,
|
||||
// not sure if this needs to stay bound to keep the TextureView valid
|
||||
#[expect(unused)]
|
||||
graphics_texture: wgpu::Texture,
|
||||
@@ -243,8 +102,8 @@ impl WgpuState {
|
||||
queue: wgpu::Queue,
|
||||
size: glam::UVec2,
|
||||
) -> WgpuState {
|
||||
const FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8UnormSrgb;
|
||||
let graphics = strafesnet_roblox_bot_player::graphics::Graphics::new(&device,&queue,size,FORMAT);
|
||||
const FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Bgra8UnormSrgb;
|
||||
let graphics = strafesnet_graphics::graphics::GraphicsState::new(&device, &queue, size, FORMAT);
|
||||
|
||||
let shader = wgpu::include_wgsl!("../shaders/rgb_to_yuv.wgsl");
|
||||
let shader = device.create_shader_module(shader);
|
||||
@@ -371,17 +230,17 @@ impl WgpuState {
|
||||
}
|
||||
|
||||
fn change_map(&mut self,map:&strafesnet_common::map::CompleteMap){
|
||||
self.graphics.change_map(&self.device,&self.queue,map);
|
||||
self.graphics.generate_models(&self.device,&self.queue,map);
|
||||
}
|
||||
|
||||
fn render(&mut self,pos:glam::Vec3,angles:glam::Vec2) {
|
||||
fn render(&mut self,camera:glam::Mat4) {
|
||||
let mut encoder = self
|
||||
.device
|
||||
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
|
||||
label: Some("wgpu encoder"),
|
||||
});
|
||||
|
||||
self.graphics.encode_commands(&mut encoder,&self.graphics_texture_view,pos,angles);
|
||||
self.graphics.encode_commands(&mut encoder, &self.graphics_texture_view, camera);
|
||||
|
||||
self.y_renderer.render(&mut encoder);
|
||||
self.uv_renderer.render(&mut encoder);
|
||||
@@ -444,7 +303,7 @@ impl PlaneRenderer {
|
||||
topology: wgpu::PrimitiveTopology::TriangleList,
|
||||
cull_mode: Some(wgpu::Face::Back),
|
||||
polygon_mode: wgpu::PolygonMode::Fill,
|
||||
front_face: wgpu::FrontFace::Cw,
|
||||
front_face: wgpu::FrontFace::Ccw,
|
||||
conservative: false,
|
||||
unclipped_depth: false,
|
||||
strip_index_format: None,
|
||||
@@ -12,7 +12,6 @@ webgl = ["wgpu/webgl"]
|
||||
|
||||
[dependencies]
|
||||
glam.workspace = true
|
||||
wgpu.workspace = true
|
||||
strafesnet_roblox_bot_player.workspace = true
|
||||
strafesnet_common.workspace = true
|
||||
strafesnet_graphics.workspace = true
|
||||
@@ -21,6 +20,7 @@ strafesnet_snf.workspace = true
|
||||
wasm-bindgen = "0.2.108"
|
||||
wasm-bindgen-futures = "0.4.58"
|
||||
web-sys = { version = "0.3.85", features = ["HtmlCanvasElement"] }
|
||||
wgpu = { version = "28.0.0" }
|
||||
|
||||
[package.metadata.wasm-pack.profile.release]
|
||||
wasm-opt = ["-Oz", "--enable-bulk-memory","--enable-nontrapping-float-to-int"]
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
use wasm_bindgen::prelude::wasm_bindgen;
|
||||
use wasm_bindgen::JsError;
|
||||
use strafesnet_roblox_bot_file::v0;
|
||||
use strafesnet_roblox_bot_player::{bot,bvh,head,time,graphics};
|
||||
use strafesnet_graphics::{setup,surface};
|
||||
use strafesnet_roblox_bot_player::{bot,head,time,graphics};
|
||||
use strafesnet_graphics::setup;
|
||||
|
||||
// Hack to keep the code compiling,
|
||||
// SurfaceTarget::Canvas is not available in IDE for whatever reason.
|
||||
@@ -22,13 +22,11 @@ impl From<ToSurfaceTarget> for wgpu::SurfaceTarget<'static>{
|
||||
#[wasm_bindgen]
|
||||
pub struct Graphics{
|
||||
graphics:graphics::Graphics,
|
||||
surface:surface::Surface<'static>,
|
||||
device:wgpu::Device,
|
||||
queue:wgpu::Queue,
|
||||
surface:wgpu::Surface<'static>,
|
||||
}
|
||||
#[wasm_bindgen]
|
||||
pub async fn setup_graphics(canvas:web_sys::HtmlCanvasElement)->Result<Graphics,JsError>{
|
||||
let size=glam::uvec2(canvas.width(),canvas.height());
|
||||
let size=(canvas.width(),canvas.height());
|
||||
|
||||
let instance_desc=wgpu::InstanceDescriptor::from_env_or_default();
|
||||
let instance=wgpu::util::new_instance_with_webgpu_detection(&instance_desc).await;
|
||||
@@ -39,12 +37,10 @@ pub async fn setup_graphics(canvas:web_sys::HtmlCanvasElement)->Result<Graphics,
|
||||
compatible_surface:Some(&surface),
|
||||
}).await.map_err(|e|JsError::new(&e.to_string()))?;
|
||||
let (device,queue)=setup::step4::request_device(&adapter).await.map_err(|e|JsError::new(&e.to_string()))?;
|
||||
let surface=setup::step5::configure_surface(&adapter,&device,surface,(size.x,size.y)).map_err(|e|JsError::new(&e.to_string()))?;
|
||||
let config=setup::step5::configure_surface(&adapter,&device,&surface,size).map_err(|e|JsError::new(&e.to_string()))?;
|
||||
Ok(Graphics{
|
||||
graphics:graphics::Graphics::new(&device,&queue,size,surface.view_format()),
|
||||
surface,
|
||||
device,
|
||||
queue,
|
||||
graphics:graphics::Graphics::new(device,queue,config),
|
||||
surface:surface,
|
||||
})
|
||||
}
|
||||
#[wasm_bindgen]
|
||||
@@ -53,21 +49,15 @@ impl Graphics{
|
||||
pub fn render(&mut self,bot:&CompleteBot,head:&PlaybackHead,time:f64){
|
||||
let time=time::from_float(time).unwrap();
|
||||
let (pos,angles)=head.head.get_position_angles(&bot.bot,time);
|
||||
let frame=self.surface.new_frame(&self.device);
|
||||
let mut encoder=self.device.create_command_encoder(&wgpu::CommandEncoderDescriptor{label:None});
|
||||
self.graphics.encode_commands(&mut encoder,frame.view(),pos,angles);
|
||||
self.queue.submit([encoder.finish()]);
|
||||
frame.present();
|
||||
self.graphics.render(&self.surface,pos,angles);
|
||||
}
|
||||
#[wasm_bindgen]
|
||||
pub fn resize(&mut self,width:u32,height:u32,fov_slope_x:f32,fov_slope_y:f32){
|
||||
let size=[width,height].into();
|
||||
self.surface.configure(&self.device,size);
|
||||
self.graphics.resize(&self.device,size,[fov_slope_x as f32,fov_slope_y as f32].into());
|
||||
self.graphics.resize(&self.surface,[width,height].into(),[fov_slope_x as f32,fov_slope_y as f32].into());
|
||||
}
|
||||
#[wasm_bindgen]
|
||||
pub fn change_map(&mut self,map:&CompleteMap){
|
||||
self.graphics.change_map(&self.device,&self.queue,&map.map);
|
||||
self.graphics.change_map(&map.map);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -193,11 +183,12 @@ impl PlaybackHead{
|
||||
pub fn get_game_controls(&self)->u32{
|
||||
self.head.state().get_controls().bits()
|
||||
}
|
||||
/// Returns an array of [pitch, yaw, roll] in radians. Yaw is not restricted to any particular range.
|
||||
#[wasm_bindgen]
|
||||
pub fn get_position(&self,bot:&CompleteBot,time:f64)->Vector3{
|
||||
pub fn get_angles(&self,bot:&CompleteBot,time:f64)->Vec<f32>{
|
||||
let time=time::from_float(time).unwrap();
|
||||
let position=self.head.get_position(&bot.bot,time);
|
||||
Vector3(position)
|
||||
let angles=self.head.get_angles(&bot.bot,time);
|
||||
angles.to_array().to_vec()
|
||||
}
|
||||
/// Returns the camera angles yaw delta between the last game tick and the most recent game tick.
|
||||
#[wasm_bindgen]
|
||||
@@ -205,31 +196,3 @@ impl PlaybackHead{
|
||||
self.head.state().get_angles_delta().y
|
||||
}
|
||||
}
|
||||
|
||||
#[wasm_bindgen]
|
||||
pub struct Vector3(glam::Vec3);
|
||||
#[wasm_bindgen]
|
||||
impl Vector3{
|
||||
#[wasm_bindgen]
|
||||
pub fn to_array(&self)->Vec<f32>{
|
||||
self.0.to_array().to_vec()
|
||||
}
|
||||
}
|
||||
|
||||
#[wasm_bindgen]
|
||||
pub struct Bvh{
|
||||
bvh:bvh::Bvh,
|
||||
}
|
||||
#[wasm_bindgen]
|
||||
impl Bvh{
|
||||
#[wasm_bindgen(constructor)]
|
||||
pub fn new(bot:&CompleteBot)->Self{
|
||||
Self{
|
||||
bvh:bvh::Bvh::new(&bot.bot),
|
||||
}
|
||||
}
|
||||
#[wasm_bindgen]
|
||||
pub fn closest_time_to_point(&self,bot:&CompleteBot,point:&Vector3)->Option<f64>{
|
||||
Some(bot.bot.playback_time(self.bvh.closest_time_to_point(&bot.bot,point.0)?).into())
|
||||
}
|
||||
}
|
||||
|
||||
@@ -58,8 +58,6 @@
|
||||
<div class="hud">
|
||||
<div id="hud_duration" class="timer">00:00:00</div>
|
||||
<div id="hud_timer" class="timer">00:00:00</div>
|
||||
<div id="diff_velocity" class="timer">-0.000 u/s</div>
|
||||
<div id="diff_time" class="timer">-0.000s</div>
|
||||
</div>
|
||||
<div class="controls">
|
||||
<button id="control_reset">↪️</button>
|
||||
|
||||
@@ -3,7 +3,6 @@ import init, {
|
||||
CompleteBot,
|
||||
CompleteMap,
|
||||
PlaybackHead,
|
||||
Bvh,
|
||||
} from "./pkg/strafesnet_roblox_bot_player_wasm_module.js";
|
||||
|
||||
// Loading
|
||||
@@ -18,16 +17,12 @@ const graphics = await setup_graphics(canvas);
|
||||
const bot = new CompleteBot(new Uint8Array(await b.arrayBuffer()));
|
||||
const map = new CompleteMap(new Uint8Array(await m.arrayBuffer()));
|
||||
const playback = new PlaybackHead(bot, 0);
|
||||
const bvh_wr = new Bvh(bot);
|
||||
const playback_wr = new PlaybackHead(bot, 0);
|
||||
|
||||
graphics.change_map(map);
|
||||
|
||||
// HUD
|
||||
const hud_timer = document.getElementById("hud_timer");
|
||||
const hud_duration = document.getElementById("hud_duration");
|
||||
const diff_velocity = document.getElementById("diff_velocity");
|
||||
const diff_time = document.getElementById("diff_time");
|
||||
const MODE_MAIN = 0;
|
||||
|
||||
function timer_text(t) {
|
||||
@@ -111,22 +106,6 @@ function animate(now) {
|
||||
const time = playback.get_run_time(bot, elapsedSec, MODE_MAIN);
|
||||
hud_timer.textContent = timer_text(time);
|
||||
|
||||
// show diff
|
||||
const pos = playback.get_position(bot, elapsedSec);
|
||||
const wr_playback_time = bvh_wr.closest_time_to_point(bot, pos);
|
||||
playback_wr.set_head_time(bot, elapsedSec, wr_playback_time);
|
||||
const wr_time = playback_wr.get_run_time(bot, elapsedSec, MODE_MAIN);
|
||||
const run_speed = playback.get_speed(bot, elapsedSec);
|
||||
const wr_speed = playback_wr.get_speed(bot, elapsedSec);
|
||||
const v_diff = run_speed - wr_speed;
|
||||
const wholespeed = Math.floor(Math.abs(v_diff));
|
||||
const millispeed = Math.floor((Math.abs(v_diff) % 1) * 1000);
|
||||
diff_velocity.textContent = `${v_diff<0?"-":"+"}${String(wholespeed)}.${String(millispeed).padStart(3, "0")} u/s`;
|
||||
const t_diff = time - wr_time;
|
||||
const s = Math.floor(Math.abs(t_diff));
|
||||
const ms = Math.floor((Math.abs(t_diff) % 1) * 1000);
|
||||
diff_time.textContent = `${t_diff<0?"-":"+"}${String(s)}.${String(ms).padStart(3, "0")}s`;
|
||||
|
||||
// Render the frame that the bot is at that time
|
||||
graphics.render(bot, playback, elapsedSec);
|
||||
|
||||
|
||||
Reference in New Issue
Block a user