lib v0.6.2-depth2

.gitattributes

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

Cargo.toml

@@ -1,7 +1,9 @@
 [workspace]
 members = [
+	"integration-tests",
 	"lib",
 	"native-player",
+	"video-encoder",
 	"wasm-module"
 ]
 resolver = "3"
@@ -12,7 +14,17 @@ strip = true
 codegen-units = 1
 
 [workspace.dependencies]
-strafesnet_common = { version = "0.8.5", registry = "strafesnet" }
+glam = "0.32.0"
-strafesnet_graphics = { version = "0.0.2", registry = "strafesnet" }
+wgpu = "29.0.0"
-strafesnet_roblox_bot_file = { version = "0.9.3", registry = "strafesnet" }
+
-strafesnet_snf = { version = "0.3.2", registry = "strafesnet" }
+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_roblox_bot_player = { version = "0.6.2-depth2", path = "lib", registry = "strafesnet" }
+
+# 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" }

integration-tests/Cargo.toml

@@ -0,0 +1,9 @@
+[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

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,50 @@
+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,11 +1,12 @@
 [package]
 name = "strafesnet_roblox_bot_player"
-version = "0.1.0"
+version = "0.6.2-depth2"
 edition = "2024"
 
 [dependencies]
-glam = "0.31.0"
+glam.workspace = true
+wgpu.workspace = true
 strafesnet_common.workspace = true
 strafesnet_graphics.workspace = true
 strafesnet_roblox_bot_file.workspace = true
-wgpu = "28.0.0"
+thiserror = "2.0.18"

lib/src/bot.rs

@@ -4,6 +4,25 @@ 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{
@@ -11,41 +30,56 @@ pub struct CompleteBot{
 	timelines:v0::Block,
 	timer:TimerFixed<Realtime<PlaybackTimeInner,PhysicsTimeInner>,Unpaused>,
 	duration:PhysicsTime,
+	world_offset:glam::Vec3,
 }
 impl CompleteBot{
 	pub(crate) const CAMERA_OFFSET:glam::Vec3=glam::vec3(0.0,2.0,0.0);
 	pub fn new(
 		timelines:v0::Block,
-	)->Self{
+	)->Result<Self,Error>{
-		let start=crate::time::from_float(timelines.output_events.first().unwrap().time).unwrap();
+		let start_event=timelines.output_events.first().ok_or(Error::NoOutputEvents)?;
-		let end=crate::time::from_float(timelines.output_events.last().unwrap().time).unwrap();
+		let end_event=timelines.output_events.last().ok_or(Error::NoOutputEvents)?;
-		Self{
+		let start=time::from_float(start_event.time).map_err(Error::Time)?;
+		let end=time::from_float(end_event.time).map_err(Error::Time)?;
+		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{
 			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
 	}
+	pub const fn world_offset(&self)->glam::Vec3{
+		self.world_offset
+	}
 	pub const fn timelines(&self)->&v0::Block{
 		&self.timelines
 	}
-	pub fn run_duration(&self,mode_id:v0::ModeID)->Option<RunTime>{
+	pub fn run_duration(&self,mode_id:v0::ModeID)->Result<RunTime,RunDurationError>{
 		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=crate::time::from_float(start).unwrap();
+		let start=time::from_float(start).map_err(RunDurationError::Time)?;
-		let end=crate::time::from_float(end).unwrap();
+		let end=time::from_float(end).map_err(RunDurationError::Time)?;
-		Some(end-start)
+		Ok(end-start)
 	}
 }

lib/src/bvh.rs

@@ -0,0 +1,167 @@
+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,50 +1,45 @@
 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,
-	config:wgpu::SurfaceConfiguration,
+	start_offset:glam::Vec3,
-	device:wgpu::Device,
-	queue:wgpu::Queue,
 }
 impl Graphics{
-	pub fn new(device:wgpu::Device,queue:wgpu::Queue,config:wgpu::SurfaceConfiguration)->Self{
+	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,&config);
+		let graphics=strafesnet_graphics::graphics::GraphicsState::new(device,queue,size,view_format,limits);
 		Self{
 			graphics,
-			device,
+			start_offset:glam::Vec3::ZERO,
-			queue,
-			config,
 		}
 	}
-	pub fn change_map(&mut self,map:&strafesnet_common::map::CompleteMap){
+	pub fn change_map(&mut self,device:&wgpu::Device,queue:&wgpu::Queue,map:&strafesnet_common::map::CompleteMap)->Result<(),ChangeMapError>{
 		self.graphics.clear();
-		self.graphics.generate_models(&self.device,&self.queue,map);
+		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)?;
+		self.start_offset=glam::Vec3::from_array(start_zone.transform.translation.map(|f|f.into()).to_array());
+		Ok(())
 	}
-	pub fn resize(&mut self,surface:&wgpu::Surface<'_>,size:glam::UVec2,fov:glam::Vec2){
+	pub fn resize(&mut self,device:&wgpu::Device,size:glam::UVec2,fov:glam::Vec2){
-		self.config.width=size.x.max(1);
+		self.graphics.resize(device,size,fov);
-		self.config.height=size.y.max(1);
-		surface.configure(&self.device,&self.config);
-		self.graphics.resize(&self.device,&self.config,fov);
 	}
-	pub fn render(&mut self,surface:&wgpu::Surface<'_>,pos:glam::Vec3,angles:glam::Vec2){
+	pub const fn depth_texture(&self)->&wgpu::Texture{
-		//this has to go deeper somehow
+		self.graphics.depth_texture()
-		let frame=match surface.get_current_texture(){
+	}
-			Ok(frame)=>frame,
+	pub const fn depth_texture_view(&self)->&wgpu::TextureView{
-			Err(_)=>{
+		self.graphics.depth_texture_view()
-				surface.configure(&self.device,&self.config);
+	}
-				surface
+	pub fn encode_commands(&mut self,encoder:&mut wgpu::CommandEncoder,view:&wgpu::TextureView,pos:glam::Vec3,angles:glam::Vec2){
-					.get_current_texture()
+		self.graphics.encode_commands(encoder,view,strafesnet_graphics::graphics::view_inv(pos+self.start_offset,angles));
-					.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()
-		});
-
-		self.graphics.render(&view,&self.device,&self.queue,strafesnet_graphics::graphics::view_inv(pos,angles));
-
-		frame.present();
 	}
 }

lib/src/head.rs

@@ -1,7 +1,8 @@
 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::{EventType,Head,Timed};
+use strafesnet_roblox_bot_file::v0::{Block,EventType,Head,Timed};
 
 use crate::bot::CompleteBot;
 use crate::state::PlaybackState;
@@ -14,6 +15,10 @@ 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,
@@ -23,7 +28,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).into());
+		let head=head_after_time(bot.timelines(),bot.time(Time::ZERO));
 		let mut state=PlaybackState::new();
 		state.process_head(bot.timelines(),&head);
 		Self{
@@ -48,7 +53,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).into());
+		self.head=head_after_time(bot.timelines(),bot.time(new_time));
 
 		self.state=PlaybackState::new();
 		self.state.process_head(bot.timelines(),&self.head);
@@ -68,11 +73,10 @@ 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 next_event.time<time_float{
+					if crate::time::from_float(next_event.time).unwrap()<simulation_time{
 						self.process_event(bot,next_event.event);
 					}else{
 						break;
@@ -80,7 +84,7 @@ impl PlaybackHead{
 				},
 				None=>{
 					//reset playback
-					self.head=Head::after_time(bot.timelines(),bot.time(Time::ZERO).into());
+					self.head=head_after_time(bot.timelines(),bot.time(Time::ZERO));
 					self.state=PlaybackState::new();
 					self.state.process_head(bot.timelines(),&self.head);
 
@@ -92,35 +96,65 @@ impl PlaybackHead{
 
 					// update loop variables
 					simulation_time-=bot.duration();
-					time_float=simulation_time.into();
 				},
 			}
 		}
 	}
-	pub fn get_position_angles(&self,bot:&CompleteBot,time:SessionTime)->(glam::Vec3,glam::Vec2){
+	fn interpolate_output<'a>(&self,bot:&'a CompleteBot,time:SessionTime)->InterpolateOutput<'a>{
 		let time=bot.time(self.time(time));
 		let event0=&bot.timelines().output_events[self.head.get_event_index(EventType::Output)-1];
 		let event1=&bot.timelines().output_events[self.head.get_event_index(EventType::Output)];
-		let p0=vector3_to_glam(&event0.event.position);
-		let p1=vector3_to_glam(&event1.event.position);
-		// let v0=vector3_to_glam(&event0.event.velocity);
-		// let v1=vector3_to_glam(&event1.event.velocity);
-		// let a0=vector3_to_glam(&event0.event.acceleration);
-		// let a1=vector3_to_glam(&event1.event.acceleration);
 		let t0=event0.time;
 		let t1=event1.time;
 		let time_float:f64=time.into();
 		let t=((time_float-t0)/(t1-t0)) as f32;
-		let p=p0.lerp(p1,t);
+		InterpolateOutput{
-		// let v=v0.lerp(v1,t);
+			event0:&event0.event,
-		// let a=a0.lerp(a1,t);
+			event1:&event1.event,
+			t:t,
+		}
+	}
+	pub fn get_position_angles(&self,bot:&CompleteBot,time:SessionTime)->(glam::Vec3,glam::Vec2){
+		let interp=self.interpolate_output(bot,time);
 
-		//println!("position={:?}",p);
+		let p=interp.position();
+		let a=interp.angles();
 
-		let angles0=vector3_to_glam(&event0.event.angles);
+		(p-bot.world_offset()+CompleteBot::CAMERA_OFFSET,a.yx())
-		let angles1=vector3_to_glam(&event1.event.angles);
+	}
-		let angles=angles0.lerp(angles1,t);
+	pub fn get_position(&self,bot:&CompleteBot,time:SessionTime)->glam::Vec3{
-
+		let interp=self.interpolate_output(bot,time);
-		(p+CompleteBot::CAMERA_OFFSET,angles.yx())
+		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()
+	}
+	pub fn get_angles(&self,bot:&CompleteBot,time:SessionTime)->glam::Vec3{
+		let interp=self.interpolate_output(bot,time);
+		interp.angles()
+	}
+}
+
+struct InterpolateOutput<'a>{
+	event0:&'a strafesnet_roblox_bot_file::v0::OutputEvent,
+	event1:&'a strafesnet_roblox_bot_file::v0::OutputEvent,
+	t:f32,
+}
+impl InterpolateOutput<'_>{
+	fn position(&self)->glam::Vec3{
+		let p0=vector3_to_glam(&self.event0.position);
+		let p1=vector3_to_glam(&self.event1.position);
+		p0.lerp(p1,self.t)
+	}
+	fn velocity(&self)->glam::Vec3{
+		let v0=vector3_to_glam(&self.event0.velocity);
+		let v1=vector3_to_glam(&self.event1.velocity);
+		v0.lerp(v1,self.t)
+	}
+	fn angles(&self)->glam::Vec3{
+		let a0=vector3_to_glam(&self.event0.angles);
+		let a1=vector3_to_glam(&self.event1.angles);
+		a0.lerp(a1,self.t)
 	}
 }

lib/src/lib.rs

@@ -1,15 +1,6 @@
 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
-// }

lib/src/state.rs

@@ -55,6 +55,8 @@ pub struct PlaybackState{
 	mouse_pos:v0::Vector2,
 	// EventType::Output
 	jump_count:u32,
+	angles:v0::Vector3,
+	angles_delta:glam::Vec3,
 	// EventType::Sound
 	// EventType::World
 	// EventType::Gravity
@@ -77,6 +79,8 @@ impl PlaybackState{
 			game_controls:v0::GameControls::empty(),
 			mouse_pos:v0::Vector2{x:0.0,y:0.0},
 			jump_count:0,
+			angles:v0::Vector3{x:0.0,y:0.0,z:0.0},
+			angles_delta:glam::Vec3::ZERO,
 			gravity:v0::Vector3{x:0.0,y:0.0,z:0.0},
 			runs:HashMap::new(),
 			style:v0::Style::Autohop,
@@ -91,9 +95,15 @@ impl PlaybackState{
 		self.runs.get(&mode)
 	}
 	fn push_output(&mut self,event:&v0::OutputEvent){
+		// Jumps may occur during a substep
 		if event.tick_info.contains(v0::TickInfo::Jump){
 			self.jump_count+=1;
 		}
+		// Game tick "end", i.e. not a sub-step
+		if event.tick_info.contains(v0::TickInfo::TickEnd){
+			self.angles_delta=glam::vec3(event.angles.x,event.angles.y,event.angles.z)-glam::vec3(self.angles.x,self.angles.y,self.angles.z);
+			self.angles=event.angles;
+		}
 	}
 	fn push_input(&mut self,event:&v0::InputEvent){
 		self.game_controls=event.game_controls;
@@ -194,22 +204,43 @@ impl PlaybackState{
 		}
 	}
 	pub(crate) fn process_head(&mut self,block:&v0::Block,head:&v0::Head){
-		// The whole point of this is to avoid running the realtime events!
+		// Avoid running the realtime events from the beginning.
-		/*
+		// Run the preceding input event to initialize the state.
-		for event in &block.input_events[0..head.get_event_index(v0::EventType::Input)]{
+		if let Some(index)=head.get_event_index(v0::EventType::Input).checked_sub(1)
+			&&let Some(event)=block.input_events.get(index)
+		{
 			self.push_input(&event.event);
 		}
-		for event in &block.output_events[0..head.get_event_index(v0::EventType::Output)]{
+
+		// Helper function
+		fn is_output_tick_end(&(_,event):&(usize,&v0::Timed<v0::OutputEvent>))->bool{
+			event.event.tick_info.contains(v0::TickInfo::TickEnd)
+		}
+		// Run two preceding output events to flush out the default state.
+		let output_end_index=head.get_event_index(v0::EventType::Output);
+		let mut it=block.output_events[..output_end_index].iter().enumerate().rev();
+		// Find two TickEnd events before output_end_index
+		let _first=it.find(is_output_tick_end);
+		let second=it.find(is_output_tick_end);
+		// Get the index at the second event, if two TickEnd events don't exist then start at 0
+		let output_start_index=second.map_or(0,|(i,_)|i);
+		for event in &block.output_events[output_start_index..output_end_index]{
 			self.push_output(&event.event);
 		}
-		for event in &bot.sound_events[0..head.get_event_index(v0::EventType::Sound)]{
+
-			self.push_sound(&event.event);
+		// for event in &bot.sound_events[0..head.get_event_index(v0::EventType::Sound)]{
-		}
+		// 	self.push_sound(&event.event);
-		*/
+		// }
+
+		// Offline events have to be run from the beginning because they contain cumulative state.
 		// for event in &bot.world_events[0..head.get_event_index(v0::EventType::World)]{
 		// 	self.push_world(&event.event);
 		// }
-		for event in &block.gravity_events[0..head.get_event_index(v0::EventType::Gravity)]{
+
+		// Except for gravity, only the most recent event is relevant.
+		if let Some(index)=head.get_event_index(v0::EventType::Gravity).checked_sub(1)
+			&&let Some(event)=block.gravity_events.get(index)
+		{
 			self.push_gravity(&event.event);
 		}
 		for event in &block.run_events[0..head.get_event_index(v0::EventType::Run)]{
@@ -234,16 +265,28 @@ impl PlaybackState{
 			v0::EventType::Setting=>self.push_setting(&block.setting_events[event_index].event),
 		}
 	}
-	pub fn get_fov_y(&self)->f64{
+	pub const fn get_fov_y(&self)->f64{
 		let zoom_enabled=self.game_controls.contains(v0::GameControls::Zoom);
 		if zoom_enabled{self.fov_y*0.2}else{self.fov_y}
 	}
-	pub fn get_sensitivity(&self)->(f64,f64){
+	pub const fn get_sensitivity(&self)->glam::DVec2{
 		if self.absolute_sensitivity_enabled{
-			(self.sens_x,self.sens_x*self.vertical_sensitivity_multipler)
+			glam::dvec2(self.sens_x,self.sens_x*self.vertical_sensitivity_multipler)
 		}else{
 			let sens_x=self.sens_x*self.get_fov_y()/128.0;
-			(sens_x,sens_x*self.vertical_sensitivity_multipler)
+			glam::dvec2(sens_x,sens_x*self.vertical_sensitivity_multipler)
 		}
 	}
+	pub const fn get_controls(&self)->v0::GameControls{
+		self.game_controls
+	}
+	pub const fn get_jump_count(&self)->u32{
+		self.jump_count
+	}
+	pub const fn get_gravity(&self)->v0::Vector3{
+		self.gravity
+	}
+	pub const fn get_angles_delta(&self)->glam::Vec3{
+		self.angles_delta
+	}
 }

lib/src/surface.rs

@@ -1,2 +0,0 @@
-/// A render surface configuration, containing information such as resolution and pixel format
-pub struct Surface{}

lib/src/time.rs

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

native-player/Cargo.toml

@@ -4,11 +4,11 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-glam = "0.31.0"
 pollster = "0.4.0"
-wgpu = "28.0.0"
 winit = "0.30.12"
-strafesnet_roblox_bot_player = { version = "0.1.0", path = "../lib" }
+glam.workspace = true
+wgpu.workspace = true
+strafesnet_roblox_bot_player.workspace = true
 strafesnet_common.workspace = true
 strafesnet_graphics.workspace = true
 strafesnet_roblox_bot_file.workspace = true

native-player/src/player.rs

@@ -2,6 +2,7 @@ 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),
@@ -35,22 +36,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{
-			surface,
 			graphics_thread,
+			surface,
 			playback:None,
 		}
 	}
-	pub fn send(&mut self,ins:TimedInstruction<Instruction,SessionTime>){
+	pub fn send(&mut self,device:&wgpu::Device,queue:&wgpu::Queue,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);
@@ -77,18 +78,31 @@ 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);
-				self.graphics_thread.render(&self.surface,pos,angles);
+
+				//this has to go deeper somehow
+				let frame=self.surface.new_frame(device).expect("Error creating new frame");
+
+				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();
 			},
 			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;
-				self.graphics_thread.resize(&self.surface,glam::uvec2(physical_size.width,physical_size.height),glam::vec2(fov_x as f32,fov_y as f32));
+				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);
 			},
 			Instruction::ChangeMap(complete_map)=>{
-				self.graphics_thread.change_map(&complete_map);
+				self.graphics_thread.change_map(device,queue,&complete_map).unwrap();
 			},
 			Instruction::LoadReplay(bot)=>{
-				let bot=CompleteBot::new(bot);
+				let bot=CompleteBot::new(bot).unwrap();
 				let playback_head=PlaybackHead::new(&bot,SessionTime::ZERO);
 				self.playback=Some(Playback{
 					bot,

native-player/src/setup.rs

@@ -1,5 +1,7 @@
 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);
@@ -13,16 +15,17 @@ pub async fn setup_and_start(title:&str){
 
 	println!("Initializing the surface...");
 
-	let instance=setup::step1::create_instance();
+	let desc=wgpu::InstanceDescriptor::new_with_display_handle_from_env(Box::new(event_loop.owned_display_handle()));
+	let instance=wgpu::Instance::new(desc);
 
 	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).await;
+	let (device,queue)=setup::step4::request_device(&adapter,LIMITS).await.unwrap();
 
 	let size=window.inner_size();
-	let config=setup::step5::configure_surface(&adapter,&device,&surface,(size.width,size.height));
+	let surface=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,7 +35,7 @@ pub async fn setup_and_start(title:&str){
 		device,
 		queue,
 		surface,
-		config,
+		LIMITS,
 	);
 
 	for arg in std::env::args().skip(1){

native-player/src/window.rs

@@ -13,15 +13,20 @@ 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.physics_thread.send(TimedInstruction{time,instruction:PhysicsWorkerInstruction::ChangeMap(map)}),
+					Ok(LoadFormat::Map(map))=>self.phys(TimedInstruction{time,instruction:PhysicsWorkerInstruction::ChangeMap(map)}),
-					Ok(LoadFormat::Bot(bot))=>self.physics_thread.send(TimedInstruction{time,instruction:PhysicsWorkerInstruction::LoadReplay(bot)}),
+					Ok(LoadFormat::Bot(bot))=>self.phys(TimedInstruction{time,instruction:PhysicsWorkerInstruction::LoadReplay(bot)}),
 					Err(e)=>println!("Failed to load file: {e}"),
 				}
 			},
@@ -31,7 +36,7 @@ impl WindowContext<'_>{
 					return;
 				}
 				//pause unpause
-				self.physics_thread.send(TimedInstruction{
+				self.phys(TimedInstruction{
 					time,
 					instruction:PhysicsWorkerInstruction::SessionControl(SessionControlInstruction::SetPaused(!state)),
 				});
@@ -74,7 +79,7 @@ impl WindowContext<'_>{
 							},
 							_=>None,
 						}{
-							self.physics_thread.send(TimedInstruction{
+							self.phys(TimedInstruction{
 								time,
 								instruction,
 							});
@@ -83,7 +88,7 @@ impl WindowContext<'_>{
 				}
 			},
 			winit::event::WindowEvent::Resized(size)=>{
-				self.physics_thread.send(
+				self.phys(
 					TimedInstruction{
 						time,
 						instruction:PhysicsWorkerInstruction::Resize(size)
@@ -92,7 +97,7 @@ impl WindowContext<'_>{
 			},
 			winit::event::WindowEvent::RedrawRequested=>{
 				self.window.request_redraw();
-				self.physics_thread.send(
+				self.phys(
 					TimedInstruction{
 						time,
 						instruction:PhysicsWorkerInstruction::Render
@@ -121,17 +126,20 @@ impl WindowContext<'_>{
 		window:&'a winit::window::Window,
 		device:wgpu::Device,
 		queue:wgpu::Queue,
-		surface:wgpu::Surface<'a>,
+		surface:strafesnet_graphics::surface::Surface<'a>,
-		config:wgpu::SurfaceConfiguration,
+		limits:wgpu::Limits,
 	)->WindowContext<'a>{
-		let graphics=strafesnet_roblox_bot_player::graphics::Graphics::new(device,queue,config);
+		let size=surface.size();
+		let graphics=strafesnet_roblox_bot_player::graphics::Graphics::new(&device,&queue,size,surface.view_format(),limits);
 		WindowContext{
 			simulation_paused:false,
 			window,
 			physics_thread:crate::player::PlayerWorker::new(
-				surface,
 				graphics,
+				surface,
 			),
+			device,
+			queue,
 		}
 	}
 }

video-encoder/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "video-encoder"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+glam.workspace = true
+wgpu.workspace = true
+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

@@ -0,0 +1,4 @@
+### 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

@@ -0,0 +1,55 @@
+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;
+}
+
+@group(0)
+@binding(0)
+var texture: texture_2d<f32>;
+@group(0)
+@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);
+}
+
+@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));
+}

video-encoder/src/encode.rs

@@ -0,0 +1,511 @@
+use std::num::NonZeroU32;
+use std::path::PathBuf;
+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)?
+	};
+	let vulkan_device = vulkan_adapter
+		.create_device(
+			wgpu::Features::TEXTURE_COMPRESSION_BC,
+			wgpu::ExperimentalFeatures::disabled(),
+			wgpu::Limits::defaults(),
+		)
+		.map_err(EncodeError::CreateDevice)?;
+
+	// playback
+	let bot=strafesnet_roblox_bot_player::bot::CompleteBot::new(timelines).unwrap();
+	let mut playback_head=strafesnet_roblox_bot_player::head::PlaybackHead::new(&bot,SessionTime::ZERO);
+
+	let mut wgpu_state = WgpuState::new(
+		vulkan_device.wgpu_device(),
+		vulkan_device.wgpu_queue(),
+		size,
+	);
+
+	wgpu_state.change_map(&map);
+
+	let mut encoder = vulkan_device
+		.create_wgpu_textures_encoder(
+			vulkan_device
+				.encoder_parameters_high_quality(
+					vk_video::parameters::VideoParameters {
+						width:params.width,
+						height:params.height,
+						target_framerate:target_framerate.into(),
+					},
+					vk_video::parameters::RateControl::VariableBitrate {
+						average_bitrate,
+						max_bitrate,
+						virtual_buffer_size: std::time::Duration::from_secs(2),
+					},
+				)
+				.map_err(EncodeError::VideoEncodeParams)?,
+		)
+		.map_err(EncodeError::VideoCreateTextures)?;
+
+	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 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 frame=vk_video::Frame{
+			data:wgpu_state.video_texture.clone(),
+			pts:None,
+		};
+		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)?;
+	}
+
+	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,
+	// not sure if this needs to stay bound to keep the TextureView valid
+	#[expect(unused)]
+	graphics_texture: wgpu::Texture,
+	graphics_texture_view: wgpu::TextureView,
+	// video output
+	video_texture: wgpu::Texture,
+	y_renderer: PlaneRenderer,
+	uv_renderer: PlaneRenderer,
+}
+
+impl WgpuState {
+	fn new(
+		device: wgpu::Device,
+		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);
+
+		let shader = wgpu::include_wgsl!("../shaders/rgb_to_yuv.wgsl");
+		let shader = device.create_shader_module(shader);
+
+		let graphics_texture_bind_group_layout=device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor{
+			label:Some("RGB Bind Group Layout"),
+			entries:&[
+				wgpu::BindGroupLayoutEntry{
+					binding:0,
+					visibility:wgpu::ShaderStages::FRAGMENT,
+					ty:wgpu::BindingType::Texture{
+						sample_type:wgpu::TextureSampleType::Float{filterable:true},
+						multisampled:false,
+						view_dimension:wgpu::TextureViewDimension::D2,
+					},
+					count:None,
+				},
+				wgpu::BindGroupLayoutEntry{
+					binding:1,
+					visibility:wgpu::ShaderStages::FRAGMENT,
+					ty:wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
+					count:None,
+				},
+			],
+		});
+
+		let graphics_texture=device.create_texture(&wgpu::TextureDescriptor{
+			label:Some("RGB texture"),
+			format:FORMAT,
+			size:wgpu::Extent3d{
+				width:size.x,
+				height:size.y,
+				depth_or_array_layers:1,
+			},
+			mip_level_count:1,
+			sample_count:1,
+			dimension:wgpu::TextureDimension::D2,
+			usage:wgpu::TextureUsages::RENDER_ATTACHMENT|wgpu::TextureUsages::TEXTURE_BINDING,
+			view_formats:&[],
+		});
+		let graphics_texture_view = graphics_texture.create_view(&wgpu::TextureViewDescriptor {
+			label: Some("RGB texture view"),
+			aspect: wgpu::TextureAspect::All,
+			usage: Some(wgpu::TextureUsages::RENDER_ATTACHMENT|wgpu::TextureUsages::TEXTURE_BINDING),
+			..Default::default()
+		});
+		let clamp_sampler=device.create_sampler(&wgpu::SamplerDescriptor{
+			label:Some("Clamp Sampler"),
+			address_mode_u:wgpu::AddressMode::ClampToEdge,
+			address_mode_v:wgpu::AddressMode::ClampToEdge,
+			address_mode_w:wgpu::AddressMode::ClampToEdge,
+			mag_filter:wgpu::FilterMode::Linear,
+			min_filter:wgpu::FilterMode::Linear,
+			mipmap_filter:wgpu::MipmapFilterMode::Linear,
+			..Default::default()
+		});
+		let graphics_texture_bind_group=device.create_bind_group(&wgpu::BindGroupDescriptor{
+			layout:&graphics_texture_bind_group_layout,
+			entries:&[
+				wgpu::BindGroupEntry{
+					binding:0,
+					resource:wgpu::BindingResource::TextureView(&graphics_texture_view),
+				},
+				wgpu::BindGroupEntry{
+					binding:1,
+					resource:wgpu::BindingResource::Sampler(&clamp_sampler),
+				},
+			],
+			label:Some("Graphics Texture"),
+		});
+
+		let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+			label: Some("wgpu pipeline layout"),
+			bind_group_layouts: &[
+				Some(&graphics_texture_bind_group_layout),
+			],
+			immediate_size: 0,
+		});
+
+		let video_texture = device.create_texture(&wgpu::TextureDescriptor {
+			label: Some("wgpu render target"),
+			format: wgpu::TextureFormat::NV12,
+			usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
+			dimension: wgpu::TextureDimension::D2,
+			sample_count: 1,
+			view_formats: &[],
+			mip_level_count: 1,
+			size: wgpu::Extent3d {
+				width: size.x,
+				height: size.y,
+				depth_or_array_layers: 1,
+			},
+		});
+
+		let y_renderer = PlaneRenderer::new(
+			&device,
+			&pipeline_layout,
+			&shader,
+			"fs_main_y",
+			&video_texture,
+			wgpu::TextureAspect::Plane0,
+			graphics_texture_bind_group.clone(),
+		);
+		let uv_renderer = PlaneRenderer::new(
+			&device,
+			&pipeline_layout,
+			&shader,
+			"fs_main_uv",
+			&video_texture,
+			wgpu::TextureAspect::Plane1,
+			graphics_texture_bind_group,
+		);
+
+		WgpuState {
+			device,
+			queue,
+			graphics,
+			graphics_texture,
+			graphics_texture_view,
+			video_texture,
+			y_renderer,
+			uv_renderer,
+		}
+	}
+
+	fn change_map(&mut self,map:&strafesnet_common::map::CompleteMap){
+		self.graphics.change_map(&self.device,&self.queue,map).unwrap();
+	}
+
+	fn render(&mut self,pos:glam::Vec3,angles:glam::Vec2) {
+		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.y_renderer.render(&mut encoder);
+		self.uv_renderer.render(&mut encoder);
+
+		encoder.transition_resources(
+			[].into_iter(),
+			[wgpu::TextureTransition {
+				texture: &self.video_texture,
+				state: wgpu::TextureUses::COPY_SRC,
+				selector: None,
+			}]
+			.into_iter(),
+		);
+
+		let buffer = encoder.finish();
+
+		self.queue.submit([buffer]);
+	}
+}
+
+struct PlaneRenderer {
+	graphics_texture_bind_group: wgpu::BindGroup,
+	pipeline: wgpu::RenderPipeline,
+	plane: wgpu::TextureAspect,
+	plane_view: wgpu::TextureView,
+}
+
+impl PlaneRenderer {
+	fn new(
+		device: &wgpu::Device,
+		pipeline_layout: &wgpu::PipelineLayout,
+		shader: &wgpu::ShaderModule,
+		fragment_entry_point: &str,
+		texture: &wgpu::Texture,
+		plane: wgpu::TextureAspect,
+		graphics_texture_bind_group: wgpu::BindGroup,
+	) -> Self {
+		let format = texture.format().aspect_specific_format(plane).unwrap();
+		let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+			label: Some("wgpu pipeline"),
+			layout: Some(pipeline_layout),
+			cache: None,
+			vertex: wgpu::VertexState {
+				module: shader,
+				buffers: &[],
+				entry_point: None,
+				compilation_options: Default::default(),
+			},
+			fragment: Some(wgpu::FragmentState {
+				module: shader,
+				entry_point: Some(fragment_entry_point),
+				compilation_options: Default::default(),
+				targets: &[Some(wgpu::ColorTargetState {
+					blend: None,
+					format,
+					write_mask: wgpu::ColorWrites::ALL,
+				})],
+			}),
+			primitive: wgpu::PrimitiveState {
+				topology: wgpu::PrimitiveTopology::TriangleList,
+				cull_mode: Some(wgpu::Face::Back),
+				polygon_mode: wgpu::PolygonMode::Fill,
+				front_face: wgpu::FrontFace::Cw,
+				conservative: false,
+				unclipped_depth: false,
+				strip_index_format: None,
+			},
+			multiview_mask: None,
+			multisample: wgpu::MultisampleState {
+				count: 1,
+				mask: !0,
+				alpha_to_coverage_enabled: false,
+			},
+			depth_stencil: None,
+		});
+
+		let plane_view = texture.create_view(&wgpu::TextureViewDescriptor {
+			label: Some("wgpu render target plane view"),
+			aspect: plane,
+			usage: Some(wgpu::TextureUsages::RENDER_ATTACHMENT),
+			..Default::default()
+		});
+
+		Self {
+			graphics_texture_bind_group,
+			pipeline,
+			plane,
+			plane_view,
+		}
+	}
+
+	fn render(&self, encoder: &mut wgpu::CommandEncoder) {
+		let clear_color = match self.plane {
+			wgpu::TextureAspect::Plane0 => wgpu::Color::BLACK,
+			wgpu::TextureAspect::Plane1 => wgpu::Color {
+				r: 0.5,
+				g: 0.5,
+				b: 0.0,
+				a: 1.0,
+			},
+			_ => unreachable!(),
+		};
+
+		let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+			label: Some("wgpu render pass"),
+			timestamp_writes: None,
+			occlusion_query_set: None,
+			depth_stencil_attachment: None,
+			color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+				view: &self.plane_view,
+				ops: wgpu::Operations {
+					load: wgpu::LoadOp::Clear(clear_color),
+					store: wgpu::StoreOp::Store,
+				},
+				resolve_target: None,
+				depth_slice: None,
+			})],
+			multiview_mask: None,
+		});
+
+		render_pass.set_bind_group(0,&self.graphics_texture_bind_group,&[]);
+		render_pass.set_pipeline(&self.pipeline);
+		render_pass.draw(0..3, 0..1);
+	}
+}

video-encoder/src/main.rs

@@ -0,0 +1,24 @@
+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),
+}
+
+fn main(){
+	let cli=Cli::parse();
+	match cli.command{
+		Commands::Encode(commands)=>commands.run(),
+	}
+}

wasm-module/Cargo.toml

@@ -6,8 +6,14 @@ edition = "2024"
 [lib]
 crate-type = ["cdylib"]
 
+[features]
+default = []
+webgl = ["wgpu/webgl"]
+
 [dependencies]
-strafesnet_roblox_bot_player = { version = "0.1.0", path = "../lib" }
+glam.workspace = true
+wgpu.workspace = true
+strafesnet_roblox_bot_player.workspace = true
 strafesnet_common.workspace = true
 strafesnet_graphics.workspace = true
 strafesnet_roblox_bot_file.workspace = true
@@ -15,7 +21,6 @@ strafesnet_snf.workspace = true
 wasm-bindgen = "0.2.108"
 wasm-bindgen-futures = "0.4.58"
 web-sys = { version = "0.3.85", features = ["HtmlCanvasElement"] }
-wgpu = "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,8 +1,8 @@
 use wasm_bindgen::prelude::wasm_bindgen;
-use wasm_bindgen::JsValue;
+use wasm_bindgen::JsError;
 use strafesnet_roblox_bot_file::v0;
-use strafesnet_roblox_bot_player::{bot,head,time,graphics};
+use strafesnet_roblox_bot_player::{bot,bvh,head,time,graphics};
-use strafesnet_graphics::setup;
+use strafesnet_graphics::{setup,surface};
 
 // Hack to keep the code compiling,
 // SurfaceTarget::Canvas is not available in IDE for whatever reason.
@@ -19,24 +19,39 @@ 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,
-	surface:wgpu::Surface<'static>,
+	surface:surface::Surface<'static>,
+	device:wgpu::Device,
+	queue:wgpu::Queue,
 }
 #[wasm_bindgen]
-pub async fn setup_graphics(canvas:web_sys::HtmlCanvasElement)->Graphics{
+pub async fn setup_graphics(canvas:web_sys::HtmlCanvasElement)->Result<Graphics,JsError>{
-	let size=(canvas.width(),canvas.height());
+	let size=glam::uvec2(canvas.width(),canvas.height());
 
-	let instance=setup::step1::create_instance();
+	let instance_desc=wgpu::InstanceDescriptor::new_without_display_handle_from_env();
-	let surface=setup::step2::create_surface(&instance,ToSurfaceTarget(canvas)).unwrap();
+	let instance=wgpu::util::new_instance_with_webgpu_detection(instance_desc).await;
-	let adapter=setup::step3::pick_adapter(&instance,&surface).await.expect("No suitable GPU adapters found on the system!");
+	let surface=setup::step2::create_surface(&instance,ToSurfaceTarget(canvas)).map_err(|e|JsError::new(&e.to_string()))?;
-	let (device,queue)=setup::step4::request_device(&adapter).await;
+	let adapter=instance.request_adapter(&wgpu::RequestAdapterOptions{
-	let config=setup::step5::configure_surface(&adapter,&device,&surface,size);
+		power_preference:wgpu::PowerPreference::HighPerformance,
-	Graphics{
+		force_fallback_adapter:false,
-		graphics:graphics::Graphics::new(device,queue,config),
+		compatible_surface:Some(&surface),
-		surface: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 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),
+		surface,
+		device,
+		queue,
+	})
 }
 #[wasm_bindgen]
 impl Graphics{
@@ -44,15 +59,22 @@ 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);
-		self.graphics.render(&self.surface,pos,angles);
+		let frame=self.surface.new_frame(&self.device).expect("Error creating new frame");
+		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();
 	}
 	#[wasm_bindgen]
 	pub fn resize(&mut self,width:u32,height:u32,fov_slope_x:f32,fov_slope_y:f32){
-		self.graphics.resize(&self.surface,[width,height].into(),[fov_slope_x as f32,fov_slope_y as f32].into());
+		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());
 	}
 	#[wasm_bindgen]
-	pub fn change_map(&mut self,map:&CompleteMap){
+	pub fn change_map(&mut self,map:&CompleteMap)->Result<(),JsError>{
-		self.graphics.change_map(&map.map);
+		self.graphics.change_map(&self.device,&self.queue,&map.map).map_err(|e|JsError::new(&e.to_string()))?;
+		Ok(())
 	}
 }
 
@@ -63,10 +85,10 @@ pub struct CompleteBot{
 #[wasm_bindgen]
 impl CompleteBot{
 	#[wasm_bindgen(constructor)]
-	pub fn new(data:&[u8])->Result<Self,JsValue>{
+	pub fn new(data:&[u8])->Result<Self,JsError>{
-		let timelines=v0::read_all_to_block(std::io::Cursor::new(data)).map_err(|e|JsValue::from_str(&e.to_string()))?;
+		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),
+			bot:bot::CompleteBot::new(timelines).map_err(|e|JsError::new(&e.to_string()))?,
 		})
 	}
 	#[wasm_bindgen]
@@ -74,9 +96,9 @@ impl CompleteBot{
 		self.bot.duration().into()
 	}
 	#[wasm_bindgen]
-	pub fn run_duration(&self,mode_id:u32)->Option<f64>{
+	pub fn run_duration(&self,mode_id:u32)->Result<f64,JsError>{
 		let mode=v0::ModeID(mode_id);
-		Some(self.bot.run_duration(mode)?.into())
+		Ok(self.bot.run_duration(mode).map_err(|e|JsError::new(&e.to_string()))?.into())
 	}
 }
 
@@ -87,11 +109,11 @@ pub struct CompleteMap{
 #[wasm_bindgen]
 impl CompleteMap{
 	#[wasm_bindgen(constructor)]
-	pub fn new(data:&[u8])->Result<Self,JsValue>{
+	pub fn new(data:&[u8])->Result<Self,JsError>{
 		let map=strafesnet_snf::read_map(std::io::Cursor::new(data))
-			.map_err(|e|JsValue::from_str(&e.to_string()))?
+			.map_err(|e|JsError::new(&e.to_string()))?
 			.into_complete_map()
-			.map_err(|e|JsValue::from_str(&e.to_string()))?;
+			.map_err(|e|JsError::new(&e.to_string()))?;
 		Ok(Self{
 			map,
 		})
@@ -105,11 +127,11 @@ pub struct PlaybackHead{
 #[wasm_bindgen]
 impl PlaybackHead{
 	#[wasm_bindgen(constructor)]
-	pub fn new(bot:&CompleteBot,time:f64)->Result<Self,JsValue>{
+	pub fn new(bot:&CompleteBot,time:f64)->Self{
 		let time=time::from_float(time).unwrap();
-		Ok(Self{
+		Self{
 			head:head::PlaybackHead::new(&bot.bot,time),
-		})
+		}
 	}
 	#[wasm_bindgen]
 	pub fn advance_time(&mut self,bot:&CompleteBot,time:f64){
@@ -166,4 +188,55 @@ impl PlaybackHead{
 	pub fn get_fov_slope_y(&self)->f64{
 		self.head.state().get_fov_y()
 	}
+	#[wasm_bindgen]
+	pub fn get_speed(&self,bot:&CompleteBot,time:f64)->f32{
+		let time=time::from_float(time).unwrap();
+		let velocity=self.head.get_velocity(&bot.bot,time);
+
+		use glam::Vec3Swizzles;
+		velocity.xz().length()
+	}
+	#[wasm_bindgen]
+	pub fn get_game_controls(&self)->u32{
+		self.head.state().get_controls().bits()
+	}
+	#[wasm_bindgen]
+	pub fn get_position(&self,bot:&CompleteBot,time:f64)->Vector3{
+		let time=time::from_float(time).unwrap();
+		let position=self.head.get_position(&bot.bot,time);
+		Vector3(position)
+	}
+	/// Returns the camera angles yaw delta between the last game tick and the most recent game tick.
+	#[wasm_bindgen]
+	pub fn get_angles_yaw_delta(&self)->f32{
+		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

@@ -1,2 +0,0 @@
-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,6 +58,8 @@
 		<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,6 +3,7 @@ import init, {
 	CompleteBot,
 	CompleteMap,
 	PlaybackHead,
+	Bvh,
 } from "./pkg/strafesnet_roblox_bot_player_wasm_module.js";
 
 // Loading
@@ -17,12 +18,16 @@ 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) {
@@ -106,6 +111,22 @@ 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);