path helpers

.gitattributes

@@ -1,2 +0,0 @@
-*.qbot filter=lfs diff=lfs merge=lfs -text
-*.snfm filter=lfs diff=lfs merge=lfs -text

Cargo.toml

@@ -1,6 +1,5 @@
 [workspace]
 members = [
-	"integration-tests",
 	"lib",
 	"native-player",
 	"video-encoder",
@@ -15,14 +14,13 @@ codegen-units = 1
 
 [workspace.dependencies]
 glam = "0.32.0"
-wgpu = "29.0.0"
 
-strafesnet_common = { version = "0.9.0", registry = "strafesnet" }
-strafesnet_graphics = { version = "=0.0.11-depth2", registry = "strafesnet" }
-strafesnet_roblox_bot_file = { version = "0.9.4", registry = "strafesnet" }
-strafesnet_snf = { version = "0.4.0", registry = "strafesnet" }
+strafesnet_common = { version = "0.8.6", registry = "strafesnet" }
+strafesnet_graphics = { version = "0.0.7", 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.6.2-depth2", path = "lib", 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" }

integration-tests/Cargo.toml

@@ -1,9 +0,0 @@
-[package]
-name = "integration-tests"
-version = "0.1.0"
-edition = "2024"
-
-[dependencies]
-strafesnet_common.workspace = true
-strafesnet_roblox_bot_file.workspace = true
-strafesnet_roblox_bot_player.workspace = true

integration-tests/bot-cruncher-errors.txt

@@ -1,46 +0,0 @@
-error: Some("03f3eb2c-d33d-44ea-ba60-67b685d1140d") Time conversion failed: Overflow
-error: Some("05997e14-08a7-4aa1-b346-dcd6cf517102") Time conversion failed: Overflow
-error: Some("0a32b95e-1d7d-4fd0-8ad7-d7b796cb4f27") Time conversion failed: Overflow
-error: Some("13f88cbd-f137-445d-9980-c4dff97f2af0") Time conversion failed: Overflow
-error: Some("1a4904fe-a6be-4059-934d-a42de5231a9f") Time conversion failed: Overflow
-error: Some("2340d553-dd29-4646-8317-44bcff565048") Time conversion failed: Overflow
-error: Some("23729b36-4014-4348-b2f0-9a0c3532ef03") Time conversion failed: Overflow
-error: Some("23fb8a0b-38f4-4abc-b3e3-07b2044d3bc2") Time conversion failed: Overflow
-error: Some("2a84d8a7-4655-4d2e-a99f-be70c1599417") Time conversion failed: Overflow
-error: Some("339b4577-4c7f-443b-a407-ad94609d15ed") Time conversion failed: Overflow
-error: Some("3568f1a6-48a5-4378-b46b-2715bd152078") Time conversion failed: Overflow
-error: Some("37b12044-d086-4564-9d5b-2a75b7356714") Time conversion failed: Overflow
-error: Some("3d0eed0d-3f40-4106-b939-bdf6d37288fd") Time conversion failed: Overflow
-error: Some("4242a0cd-bb7d-4e86-89db-3d5007118abd") Time conversion failed: Overflow
-error: Some("46180b28-da3f-43da-ac2a-f814c570920d") Time conversion failed: Overflow
-error: Some("5deda980-247f-4d6d-93a8-61db987d38cd") Time conversion failed: Overflow
-error: Some("6fe42692-dea4-4392-8831-6add36b27b26") Time conversion failed: Overflow
-error: Some("74e88825-409f-46d7-82c5-d20d056cadfc") Time conversion failed: Overflow
-error: Some("7996a8d5-5007-4859-be7c-f48fabfbc26b") Time conversion failed: Overflow
-error: Some("8c23df4f-8174-4d92-bd2d-c5295031233d") Time conversion failed: Overflow
-error: Some("90be213f-e057-418a-9031-a757bcd8da5d") Time conversion failed: Overflow
-error: Some("9ecdfbdc-694b-4e2c-b7be-b90182a24b14") Time conversion failed: Overflow
-error: Some("9fe0ac20-875b-49b4-b309-2144a6e35d5c") Time conversion failed: Overflow
-error: Some("a2581786-6425-4ea1-8def-26e4a2150660") Time conversion failed: Overflow
-error: Some("a343edb6-5038-4b51-b296-c9d806410443") Time conversion failed: Overflow
-error: Some("a83ba7f9-c856-4110-9927-11f9ba052704") Time conversion failed: Overflow
-error: Some("a8ed621f-1829-4c02-90c2-1f667e9b1d6d") Time conversion failed: Overflow
-error: Some("aad6ab3b-7580-4e1b-9981-2409ded7e519") Time conversion failed: Overflow
-error: Some("ab06ed6f-c308-491e-9086-dfb16e2d56b0") Time conversion failed: Overflow
-error: Some("b0ce6510-7d58-461a-b24f-61370b68f700") Time conversion failed: Overflow
-error: Some("b21fbcab-faf1-4f95-9b5c-60195777c814") Time conversion failed: Overflow
-error: Some("b400fa0f-af30-473a-b2f2-359e677e00e7") Time conversion failed: Overflow
-error: Some("bb96ff40-2bcf-4632-b61a-1f4c2c68d3fe") Time conversion failed: Overflow
-error: Some("bba5e324-c17d-486e-aef3-3d4ea93f920a") Time conversion failed: Overflow
-error: Some("bfcc633b-287d-4f0e-bf1d-94944b909614") Time conversion failed: Overflow
-error: Some("cc4454ad-7b5e-4b2b-b547-7e3ffd99103a") Time conversion failed: Overflow
-error: Some("d162d94b-d3f7-47ef-8338-e83cfafdabd8") Time conversion failed: Overflow
-error: Some("d714eba0-6cba-4eb9-b4a8-e71c6d0da8e9") Time conversion failed: Overflow
-error: Some("d9178578-dd59-41cb-bcf7-95d902e783a3") Time conversion failed: Overflow
-error: Some("e7219ca8-e7bd-4b29-8081-91406e4d8764") Time conversion failed: Overflow
-error: Some("e9271e47-db0b-4228-9b3d-dd372e6585ac") Time conversion failed: Overflow
-error: Some("ecb5dfc8-fb3f-4a5d-a864-3a05ea054b7a") Time conversion failed: Overflow
-error: Some("edec8dce-8c27-4a66-8c48-59bfc19e96ca") Time conversion failed: Overflow
-error: Some("f184200c-1bcb-48ca-862d-c43118a0a307") Time conversion failed: Overflow
-error: Some("f76013c7-b4cd-431b-8cc6-ad827cecd923") Time conversion failed: Overflow
-error: Some("f9e4316a-b15d-4417-89c6-8fcba4ee746d") Time conversion failed: Overflow

integration-tests/src/main.rs

@@ -1,50 +0,0 @@
-use strafesnet_roblox_bot_file::v0;
-use strafesnet_roblox_bot_player::{bot,bvh,head};
-use head::Time as PlaybackTime;
-use strafesnet_common::session::Time as SessionTime;
-
-fn main(){
-	let bot=include_bytes!("../../web-demo/bhop_marble_7cf33a64-7120-4514-b9fa-4fe29d9523d.qbot");
-	let timelines=v0::read_all_to_block(std::io::Cursor::new(bot)).unwrap();
-	let bot=bot::CompleteBot::new(timelines).unwrap();
-	let bvh=bvh::Bvh::new(&bot);
-
-	// sample the position at 0.24s
-	let mut playback0=head::PlaybackHead::new(&bot,SessionTime::ZERO);
-	for i in 0..10{
-		let sample_time=PlaybackTime::from_millis(6543+1*i);
-		playback0.set_time(&bot,SessionTime::ZERO,sample_time);
-		let pos=playback0.get_position(&bot,SessionTime::ZERO);
-
-		// get the closest time on the timeline (convert to PlaybackTime which starts at 0)
-		let closest_time=bot.playback_time(bvh.closest_time_to_point(&bot,pos).unwrap());
-		println!("time={sample_time} closest_time={closest_time}");
-	}
-	// let mut playback1=head::PlaybackHead::new(&bot,SessionTime::ZERO);
-	// playback1.set_time(&bot,SessionTime::ZERO,sample_time);
-}
-
-#[test]
-fn get_position_no_panic(){
-	let bot_file=include_bytes!("../../files/000002d3-852a-4e9f-b0c9-c95411683806.qbot");
-	let timelines=v0::read_all_to_block(std::io::Cursor::new(bot_file)).unwrap();
-	let bot=bot::CompleteBot::new(timelines).unwrap();
-	let head=head::PlaybackHead::new(&bot,SessionTime::ZERO);
-	// This can panic if the head is mismanaged!
-	let _pos=head.get_position(&bot,SessionTime::ZERO);
-}
-
-#[test]
-fn get_position_no_panic2(){
-	let bot_file=include_bytes!("../../files/03f3eb2c-d33d-44ea-ba60-67b685d1140d.qbot");
-	let timelines=v0::read_all_to_block(std::io::Cursor::new(bot_file)).unwrap();
-	let bot=bot::CompleteBot::new(timelines).unwrap();
-	println!("duration={}",bot.duration());
-	println!("num_events={}",bot.timelines().output_events.len());
-	for event in &bot.timelines().output_events{
-		println!("time={}",event.time);
-	}
-	let head=head::PlaybackHead::new(&bot,SessionTime::ZERO);
-	// This can panic if the head is mismanaged!
-	let _pos=head.get_position(&bot,SessionTime::ZERO);
-}

lib/Cargo.toml

@@ -1,12 +1,11 @@
 [package]
 name = "strafesnet_roblox_bot_player"
-version = "0.6.2-depth2"
+version = "0.2.0"
 edition = "2024"
 
 [dependencies]
 glam.workspace = true
-wgpu.workspace = true
 strafesnet_common.workspace = true
 strafesnet_graphics.workspace = true
 strafesnet_roblox_bot_file.workspace = true
-thiserror = "2.0.18"
+wgpu = "28.0.0"

lib/src/bot.rs

@@ -4,25 +4,6 @@ use strafesnet_common::physics::{Time as PhysicsTime,TimeInner as PhysicsTimeInn
 use strafesnet_roblox_bot_file::v0;
 
 use crate::head::{Time as PlaybackTime,TimeInner as PlaybackTimeInner};
-use crate::time;
-
-#[derive(Debug,thiserror::Error)]
-pub enum Error{
-	#[error("Bot output timeline has no events")]
-	NoOutputEvents,
-	#[error("Time conversion failed: {0}")]
-	Time(#[from]time::Error),
-}
-
-#[derive(Debug,thiserror::Error)]
-pub enum RunDurationError{
-	#[error("Bot run timeline has no RunStart event")]
-	NoRunStart,
-	#[error("Bot run timeline has no RunFinish event")]
-	NoRunFinish,
-	#[error("Time conversion failed: {0}")]
-	Time(time::Error),
-}
 
 /// A loaded bot file.
 pub struct CompleteBot{
@@ -36,29 +17,23 @@ impl CompleteBot{
 	pub(crate) const CAMERA_OFFSET:glam::Vec3=glam::vec3(0.0,2.0,0.0);
 	pub fn new(
 		timelines:v0::Block,
-	)->Result<Self,Error>{
-		let start_event=timelines.output_events.first().ok_or(Error::NoOutputEvents)?;
-		let end_event=timelines.output_events.last().ok_or(Error::NoOutputEvents)?;
-		let start=time::from_float(start_event.time).map_err(Error::Time)?;
-		let end=time::from_float(end_event.time).map_err(Error::Time)?;
+	)->Self{
+		let start=crate::time::from_float(timelines.output_events.first().unwrap().time).unwrap();
+		let end=crate::time::from_float(timelines.output_events.last().unwrap().time).unwrap();
 		let world_position=timelines.world_events.iter().find_map(|event|match &event.event{
 			v0::WorldEvent::Reset(world_reset_event)=>Some(world_reset_event.position),
 			_=>None,
 		}).expect("Map must contain a WorldReset event");
-		Ok(Self{
+		Self{
 			timer:TimerFixed::new(PlaybackTime::ZERO,start),
 			duration:end-start,
 			timelines,
 			world_offset:glam::vec3(world_position.x,world_position.y,world_position.z),
-		})
+		}
 	}
 	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
 	}
@@ -68,18 +43,18 @@ impl CompleteBot{
 	pub const fn timelines(&self)->&v0::Block{
 		&self.timelines
 	}
-	pub fn run_duration(&self,mode_id:v0::ModeID)->Result<RunTime,RunDurationError>{
+	pub fn run_duration(&self,mode_id:v0::ModeID)->Option<RunTime>{
 		let mut it=self.timelines.run_events.iter().rev();
 		let end=it.find_map(|event|match &event.event{
 			v0::RunEvent::Finish(run_start_event) if run_start_event.mode==mode_id=>Some(event.time),
 			_=>None,
-		}).ok_or(RunDurationError::NoRunFinish)?;
+		})?;
 		let start=it.find_map(|event|match &event.event{
 			v0::RunEvent::Start(run_start_event) if run_start_event.mode==mode_id=>Some(event.time),
 			_=>None,
-		}).ok_or(RunDurationError::NoRunStart)?;
-		let start=time::from_float(start).map_err(RunDurationError::Time)?;
-		let end=time::from_float(end).map_err(RunDurationError::Time)?;
-		Ok(end-start)
+		})?;
+		let start=crate::time::from_float(start).unwrap();
+		let end=crate::time::from_float(end).unwrap();
+		Some(end-start)
 	}
 }

lib/src/bvh.rs

@@ -1,167 +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,Planar64};
-use strafesnet_common::physics::Time as PhysicsTime;
-use crate::bot::CompleteBot;
-use strafesnet_roblox_bot_file::v0;
-
-fn v3(position:v0::Vector3)->strafesnet_common::integer::Planar64Vec3{
-	vec3::try_from_f32_array([position.x,position.y,position.z]).unwrap()
-}
-
-const MAX_SLICE_LEN:usize=16;
-struct EventSlice{
-	slice:Range<usize>,
-	inclusive:bool,
-}
-
-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 slices 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==event1.event.position.x
-					&&event0.event.position.y==event1.event.position.y
-					&&event0.event.position.z==event1.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=MAX_SLICE_LEN;
-			bvh_nodes.reserve(count);
-			// 0123456789
-			// split into groups of MAX_SLICE_LEN=4
-			// [0123][4567][89]
-			let mut push_slice=|slice:Range<usize>,inclusive:bool|{
-				let mut aabb=Aabb::default();
-				for event in &output_events[slice.start..slice.end]{
-					aabb.grow(v3(event.event.position));
-				}
-				if inclusive{
-					let event=&output_events[slice.end];
-					aabb.grow(v3(event.event.position));
-				}
-				bvh_nodes.push((EventSlice{slice,inclusive},aabb));
-			};
-			// push fixed-size groups
-			for i in 0..count-1{
-				push_slice((last_index+i*slice_len)..(last_index+(i+1)*slice_len),true);
-			}
-			// push last group which may be shorter
-			push_slice((last_index+(count-1)*slice_len)..index,false);
-			last_index=index;
-		};
-		// find discontinuities (teleports) and avoid forming a bvh 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<'a>(&self,bot:&'a CompleteBot,point:glam::Vec3)->Option<PhysicsTime>{
-		let point=point+bot.world_offset();
-		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=|event_slice:&EventSlice|{
-			// calculate the distance to the leaf contents
-			let mut best_distance=output_events[event_slice.slice.start..event_slice.slice.end].iter().map(|event|{
-				let p=event.event.position;
-				let p=v3(p);
-				(start_point-p).length_squared()
-			}).min()?;
-			let mut prev_event=&output_events[event_slice.slice.start];
-			let mut f=|event:&'a v0::Timed<v0::OutputEvent>|{
-				let p0=v3(prev_event.event.position);
-				let p1=v3(event.event.position);
-				let d=p1-p0;
-				let d0=p0.dot(d);
-				let d1=p1.dot(d);
-				let sp_d=start_point.dot(d);
-				// must be on the segment
-				if d0<sp_d&&sp_d<d1{
-					let t0=d1-sp_d;
-					let t1=sp_d-d0;
-					let dt=d1-d0;
-					let distance=(((p0*t0+p1*t1)/dt).divide().wrap_64()-start_point).length_squared();
-					if distance<best_distance{
-						best_distance=distance;
-					}
-				}
-				prev_event=event;
-			};
-			for event in &output_events[event_slice.slice.start+1..event_slice.slice.end]{
-				f(event);
-			}
-			if event_slice.inclusive{
-				f(&output_events[event_slice.slice.end]);
-			}
-			Some(best_distance)
-		};
-		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())
-		};
-		// traverse uses strict `start_time < t`, so use NEG_EPSILON to keep exact-zero-distance hits.
-		let (_,event_slice)=self.bvh.traverse(start_point,Fixed::NEG_EPSILON,Fixed::MAX,intersect_leaf,intersect_aabb)?;
-
-		// find time at the closest point
-		let (best_time,mut best_distance)=output_events[event_slice.slice.start..event_slice.slice.end].iter().map(|event|{
-			let p=event.event.position;
-			let p=v3(p);
-			(event.time,(start_point-p).length_squared())
-		}).min_by_key(|&(_,distance)|distance)?;
-		let mut best_time=crate::time::from_float(best_time).unwrap();
-		let mut prev_event=&output_events[event_slice.slice.start];
-		let mut f=|event:&'a v0::Timed<v0::OutputEvent>|{
-			let p0=v3(prev_event.event.position);
-			let p1=v3(event.event.position);
-			let d=p1-p0;
-			let d0=p0.dot(d);
-			let d1=p1.dot(d);
-			let sp_d=start_point.dot(d);
-			// must be on the segment
-			if d0<sp_d&&sp_d<d1{
-				let t0=d1-sp_d;
-				let t1=sp_d-d0;
-				let dt=d1-d0;
-				let distance=(((p0*t0+p1*t1)/dt).divide().wrap_64()-start_point).length_squared();
-				if distance<best_distance{
-					best_distance=distance;
-					let p0:Planar64=prev_event.time.try_into().unwrap();
-					let p1:Planar64=event.time.try_into().unwrap();
-					best_time=((p0*t0+p1*t1)/dt).into();
-				}
-			}
-			prev_event=event;
-		};
-		for event in &output_events[event_slice.slice.start+1..event_slice.slice.end]{
-			f(event);
-		}
-		if event_slice.inclusive{
-			f(&output_events[event_slice.slice.end]);
-		}
-		Some(best_time)
-	}
-}

lib/src/graphics.rs

@@ -1,44 +1,29 @@
 use strafesnet_graphics::graphics::GraphicsState;
 
-#[derive(Debug,thiserror::Error)]
-pub enum ChangeMapError{
-	#[error("Map does not have a main mode")]
-	NoMainMode,
-	#[error("Map does not have a start zone")]
-	NoStartZone,
-}
-
 /// The graphics state, essentially a handle to all the information on the GPU.
 pub struct Graphics{
 	graphics:GraphicsState,
 	start_offset:glam::Vec3,
 }
 impl Graphics{
-	pub fn new(device:&wgpu::Device,queue:&wgpu::Queue,size:glam::UVec2,view_format:wgpu::TextureFormat,limits:wgpu::Limits)->Self{
-		let graphics=strafesnet_graphics::graphics::GraphicsState::new(device,queue,size,view_format,limits);
+	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);
 		Self{
 			graphics,
 			start_offset:glam::Vec3::ZERO,
 		}
 	}
-	pub fn change_map(&mut self,device:&wgpu::Device,queue:&wgpu::Queue,map:&strafesnet_common::map::CompleteMap)->Result<(),ChangeMapError>{
+	pub fn change_map(&mut self,device:&wgpu::Device,queue:&wgpu::Queue,map:&strafesnet_common::map::CompleteMap){
 		self.graphics.clear();
 		self.graphics.generate_models(device,queue,map);
 		let modes=map.modes.clone().denormalize();
-		let mode=modes.get_mode(strafesnet_common::gameplay_modes::ModeId::MAIN).ok_or(ChangeMapError::NoMainMode)?;
-		let start_zone=map.models.get(mode.get_start().get() as usize).ok_or(ChangeMapError::NoStartZone)?;
+		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());
-		Ok(())
 	}
 	pub fn resize(&mut self,device:&wgpu::Device,size:glam::UVec2,fov:glam::Vec2){
 		self.graphics.resize(device,size,fov);
 	}
-	pub const fn depth_texture(&self)->&wgpu::Texture{
-		self.graphics.depth_texture()
-	}
-	pub const fn depth_texture_view(&self)->&wgpu::TextureView{
-		self.graphics.depth_texture_view()
-	}
 	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));
 	}

lib/src/head.rs

@@ -1,8 +1,7 @@
 use glam::Vec3Swizzles;
-use strafesnet_common::physics::Time as PhysicsTime;
 use strafesnet_common::timer::{Scaled,Timer,TimerState};
 use strafesnet_common::session::{Time as SessionTime,TimeInner as SessionTimeInner};
-use strafesnet_roblox_bot_file::v0::{Block,EventType,Head,Timed};
+use strafesnet_roblox_bot_file::v0::{EventType,Head,Timed};
 
 use crate::bot::CompleteBot;
 use crate::state::PlaybackState;
@@ -15,10 +14,6 @@ fn vector3_to_glam(v:&strafesnet_roblox_bot_file::v0::Vector3)->glam::Vec3{
 pub enum TimeInner{}
 pub type Time=strafesnet_common::integer::Time<TimeInner>;
 
-fn head_after_time(block:&Block,time:PhysicsTime)->Head{
-	Head::partition_point(block,|event_time|crate::time::from_float(event_time).unwrap()<=time)
-}
-
 /// A playback context.  Advance time and then generate a camera position to pass to the renderer.
 pub struct PlaybackHead{
 	head:Head,
@@ -28,7 +23,7 @@ pub struct PlaybackHead{
 impl PlaybackHead{
 	pub fn new(bot:&CompleteBot,time:SessionTime)->Self{
 		let timer=Timer::unpaused(time,Time::ZERO);
-		let head=head_after_time(bot.timelines(),bot.time(Time::ZERO));
+		let head=Head::after_time(bot.timelines(),bot.time(Time::ZERO).into());
 		let mut state=PlaybackState::new();
 		state.process_head(bot.timelines(),&head);
 		Self{
@@ -53,7 +48,7 @@ impl PlaybackHead{
 		let new_time=new_time.rem_euclid(bot.duration().coerce());
 		self.timer.set_time(time,new_time);
 		// reset head
-		self.head=head_after_time(bot.timelines(),bot.time(new_time));
+		self.head=Head::after_time(bot.timelines(),bot.time(new_time).into());
 
 		self.state=PlaybackState::new();
 		self.state.process_head(bot.timelines(),&self.head);
@@ -73,10 +68,11 @@ impl PlaybackHead{
 	}
 	pub fn advance_time(&mut self,bot:&CompleteBot,time:SessionTime){
 		let mut simulation_time=bot.time(self.time(time));
+		let mut time_float=simulation_time.into();
 		loop{
 			match self.next_event(bot){
 				Some(next_event)=>{
-					if crate::time::from_float(next_event.time).unwrap()<simulation_time{
+					if next_event.time<time_float{
 						self.process_event(bot,next_event.event);
 					}else{
 						break;
@@ -84,7 +80,7 @@ impl PlaybackHead{
 				},
 				None=>{
 					//reset playback
-					self.head=head_after_time(bot.timelines(),bot.time(Time::ZERO));
+					self.head=Head::after_time(bot.timelines(),bot.time(Time::ZERO).into());
 					self.state=PlaybackState::new();
 					self.state.process_head(bot.timelines(),&self.head);
 
@@ -96,6 +92,7 @@ impl PlaybackHead{
 
 					// update loop variables
 					simulation_time-=bot.duration();
+					time_float=simulation_time.into();
 				},
 			}
 		}
@@ -122,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()-bot.world_offset()
-	}
 	pub fn get_velocity(&self,bot:&CompleteBot,time:SessionTime)->glam::Vec3{
 		let interp=self.interpolate_output(bot,time);
 		interp.velocity()

lib/src/lib.rs

@@ -1,5 +1,4 @@
 pub mod bot;
-pub mod bvh;
 pub mod head;
 pub mod time;
 pub mod state;

lib/src/time.rs

@@ -20,14 +20,13 @@ pub fn from_float<T>(time:f64)->Result<Time<T>,Error>{
 		core::num::FpCategory::Infinite
 		|core::num::FpCategory::Subnormal
 		|core::num::FpCategory::Normal=>{
-			let time_raw=time*Time::<T>::ONE_SECOND.get() as f64;
-			if time_raw<Time::<T>::MIN.get() as f64{
+			if time<Time::<T>::MIN.get() as f64{
 				return Err(Error::Underflow);
 			}
-			if (Time::<T>::MAX.get() as f64)<time_raw{
+			if (Time::<T>::MAX.get() as f64)<time{
 				return Err(Error::Overflow);
 			}
-			Ok(Time::raw(time_raw as i64))
+			Ok(Time::raw((time*Time::<T>::ONE_SECOND.get() as f64) as i64))
 		}
 	}
 }

native-player/Cargo.toml

@@ -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

native-player/src/player.rs

@@ -80,7 +80,7 @@ impl<'a> PlayerWorker<'a>{
 				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).expect("Error creating new frame");
+				let frame=self.surface.new_frame(device);
 
 				let mut encoder=device.create_command_encoder(&wgpu::CommandEncoderDescriptor{label:None});
 
@@ -99,10 +99,10 @@ impl<'a> PlayerWorker<'a>{
 				self.graphics_thread.resize(device,size,fov);
 			},
 			Instruction::ChangeMap(complete_map)=>{
-				self.graphics_thread.change_map(device,queue,&complete_map).unwrap();
+				self.graphics_thread.change_map(device,queue,&complete_map);
 			},
 			Instruction::LoadReplay(bot)=>{
-				let bot=CompleteBot::new(bot).unwrap();
+				let bot=CompleteBot::new(bot);
 				let playback_head=PlaybackHead::new(&bot,SessionTime::ZERO);
 				self.playback=Some(Playback{
 					bot,

native-player/src/setup.rs

@@ -1,7 +1,5 @@
 use strafesnet_graphics::setup;
 
-const LIMITS:wgpu::Limits=wgpu::Limits::defaults();
-
 fn create_window(title:&str,event_loop:&winit::event_loop::EventLoop<()>)->Result<winit::window::Window,winit::error::OsError>{
 	let mut attr=winit::window::WindowAttributes::default();
 	attr=attr.with_title(title);
@@ -15,14 +13,13 @@ pub async fn setup_and_start(title:&str){
 
 	println!("Initializing the surface...");
 
-	let desc=wgpu::InstanceDescriptor::new_with_display_handle_from_env(Box::new(event_loop.owned_display_handle()));
-	let instance=wgpu::Instance::new(desc);
+	let instance=setup::step1::create_instance();
 
 	let surface=setup::step2::create_surface(&instance,&window).unwrap();
 
 	let adapter=setup::step3::pick_adapter(&instance,&surface).await.expect("No suitable GPU adapters found on the system!");
 
-	let (device,queue)=setup::step4::request_device(&adapter,LIMITS).await.unwrap();
+	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();
@@ -35,7 +32,6 @@ pub async fn setup_and_start(title:&str){
 		device,
 		queue,
 		surface,
-		LIMITS,
 	);
 
 	for arg in std::env::args().skip(1){

native-player/src/window.rs

@@ -127,10 +127,9 @@ impl WindowContext<'_>{
 		device:wgpu::Device,
 		queue:wgpu::Queue,
 		surface:strafesnet_graphics::surface::Surface<'a>,
-		limits:wgpu::Limits,
 	)->WindowContext<'a>{
 		let size=surface.size();
-		let graphics=strafesnet_roblox_bot_player::graphics::Graphics::new(&device,&queue,size,surface.view_format(),limits);
+		let graphics=strafesnet_roblox_bot_player::graphics::Graphics::new(&device,&queue,size,surface.view_format());
 		WindowContext{
 			simulation_paused:false,
 			window,

video-encoder/Cargo.toml

@@ -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"

video-encoder/README.md

@@ -1,4 +0,0 @@
-### How it works
-- Render RGB to graphics_texture
-- Convert RGB to YUV on video_texture
-- Encode video frame

video-encoder/shaders/rgb_to_yuv.wgsl

@@ -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));
 }

video-encoder/src/main.rs

@@ -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();
 }

video-encoder/src/setup.rs

@@ -1,134 +1,31 @@
-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,
-}
-
-const LIMITS:wgpu::Limits=wgpu::Limits::defaults();
-
-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).unwrap();
+	let bot=strafesnet_roblox_bot_player::bot::CompleteBot::new(timelines);
 	let mut playback_head=strafesnet_roblox_bot_player::head::PlaybackHead::new(&bot,SessionTime::ZERO);
 
 	let mut wgpu_state = WgpuState::new(
@@ -144,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 {
@@ -154,44 +51,11 @@ 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() {
@@ -200,28 +64,20 @@ fn encode(params:EncodeParams)->Result<(),EncodeError>{
 		let (pos,angles)=playback_head.get_position_angles(&bot,time);
 		wgpu_state.render(pos,angles);
 
-		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 {
@@ -245,8 +101,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,LIMITS);
+		const FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Bgra8UnormSrgb;
+		let graphics = strafesnet_roblox_bot_player::graphics::Graphics::new(&device,&queue,size,FORMAT);
 
 		let shader = wgpu::include_wgsl!("../shaders/rgb_to_yuv.wgsl");
 		let shader = device.create_shader_module(shader);
@@ -321,7 +177,7 @@ impl WgpuState {
 		let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
 			label: Some("wgpu pipeline layout"),
 			bind_group_layouts: &[
-				Some(&graphics_texture_bind_group_layout),
+				&graphics_texture_bind_group_layout
 			],
 			immediate_size: 0,
 		});
@@ -373,7 +229,7 @@ impl WgpuState {
 	}
 
 	fn change_map(&mut self,map:&strafesnet_common::map::CompleteMap){
-		self.graphics.change_map(&self.device,&self.queue,map).unwrap();
+		self.graphics.change_map(&self.device,&self.queue,map);
 	}
 
 	fn render(&mut self,pos:glam::Vec3,angles:glam::Vec2) {
@@ -446,7 +302,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,

wasm-module/Cargo.toml

@@ -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"]

wasm-module/src/lib.rs

@@ -1,7 +1,7 @@
 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_roblox_bot_player::{bot,head,time,graphics};
 use strafesnet_graphics::{setup,surface};
 
 // Hack to keep the code compiling,
@@ -19,12 +19,6 @@ impl From<ToSurfaceTarget> for wgpu::SurfaceTarget<'static>{
 	}
 }
 
-// select limits based on presence of webgl feature
-#[cfg(not(feature="webgl"))]
-const LIMITS:wgpu::Limits=wgpu::Limits::defaults();
-#[cfg(feature="webgl")]
-const LIMITS:wgpu::Limits=wgpu::Limits::downlevel_webgl2_defaults();
-
 #[wasm_bindgen]
 pub struct Graphics{
 	graphics:graphics::Graphics,
@@ -36,18 +30,18 @@ pub struct Graphics{
 pub async fn setup_graphics(canvas:web_sys::HtmlCanvasElement)->Result<Graphics,JsError>{
 	let size=glam::uvec2(canvas.width(),canvas.height());
 
-	let instance_desc=wgpu::InstanceDescriptor::new_without_display_handle_from_env();
-	let instance=wgpu::util::new_instance_with_webgpu_detection(instance_desc).await;
+	let instance_desc=wgpu::InstanceDescriptor::from_env_or_default();
+	let instance=wgpu::util::new_instance_with_webgpu_detection(&instance_desc).await;
 	let surface=setup::step2::create_surface(&instance,ToSurfaceTarget(canvas)).map_err(|e|JsError::new(&e.to_string()))?;
 	let adapter=instance.request_adapter(&wgpu::RequestAdapterOptions{
 		power_preference:wgpu::PowerPreference::HighPerformance,
 		force_fallback_adapter:false,
 		compatible_surface:Some(&surface),
 	}).await.map_err(|e|JsError::new(&e.to_string()))?;
-	let (device,queue)=setup::step4::request_device(&adapter,LIMITS).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()))?;
 	Ok(Graphics{
-		graphics:graphics::Graphics::new(&device,&queue,size,surface.view_format(),LIMITS),
+		graphics:graphics::Graphics::new(&device,&queue,size,surface.view_format()),
 		surface,
 		device,
 		queue,
@@ -59,7 +53,7 @@ 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).expect("Error creating new frame");
+		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()]);
@@ -72,9 +66,8 @@ impl Graphics{
 		self.graphics.resize(&self.device,size,[fov_slope_x as f32,fov_slope_y as f32].into());
 	}
 	#[wasm_bindgen]
-	pub fn change_map(&mut self,map:&CompleteMap)->Result<(),JsError>{
-		self.graphics.change_map(&self.device,&self.queue,&map.map).map_err(|e|JsError::new(&e.to_string()))?;
-		Ok(())
+	pub fn change_map(&mut self,map:&CompleteMap){
+		self.graphics.change_map(&self.device,&self.queue,&map.map);
 	}
 }
 
@@ -88,7 +81,7 @@ impl CompleteBot{
 	pub fn new(data:&[u8])->Result<Self,JsError>{
 		let timelines=v0::read_all_to_block(std::io::Cursor::new(data)).map_err(|e|JsError::new(&e.to_string()))?;
 		Ok(Self{
-			bot:bot::CompleteBot::new(timelines).map_err(|e|JsError::new(&e.to_string()))?,
+			bot:bot::CompleteBot::new(timelines),
 		})
 	}
 	#[wasm_bindgen]
@@ -96,9 +89,9 @@ impl CompleteBot{
 		self.bot.duration().into()
 	}
 	#[wasm_bindgen]
-	pub fn run_duration(&self,mode_id:u32)->Result<f64,JsError>{
+	pub fn run_duration(&self,mode_id:u32)->Option<f64>{
 		let mode=v0::ModeID(mode_id);
-		Ok(self.bot.run_duration(mode).map_err(|e|JsError::new(&e.to_string()))?.into())
+		Some(self.bot.run_duration(mode)?.into())
 	}
 }
 
@@ -200,11 +193,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]
@@ -212,31 +206,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())
-	}
-}

web-demo/.gitattributes

@@ -0,0 +1,2 @@
+bhop_marble_7cf33a64-7120-4514-b9fa-4fe29d9523d.qbot filter=lfs diff=lfs merge=lfs -text
+bhop_marble_5692093612.snfm filter=lfs diff=lfs merge=lfs -text

web-demo/index.html

@@ -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>

web-demo/player.js

@@ -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);