lib v0.6.1 depth_texture

.gitattributes

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

Cargo.toml

@@ -15,14 +15,14 @@ codegen-units = 1
 
 [workspace.dependencies]
 glam = "0.32.0"
-wgpu = "28.0.0"
+wgpu = "29.0.0"
 
-strafesnet_common = { version = "0.8.6", registry = "strafesnet" }
+strafesnet_common = { version = "0.9.0", registry = "strafesnet" }
-strafesnet_graphics = { version = "0.0.7", registry = "strafesnet" }
+strafesnet_graphics = { version = "0.0.11", registry = "strafesnet" }
-strafesnet_roblox_bot_file = { version = "0.9.3", registry = "strafesnet" }
+strafesnet_roblox_bot_file = { version = "0.9.4", registry = "strafesnet" }
-strafesnet_snf = { version = "0.3.2", registry = "strafesnet" }
+strafesnet_snf = { version = "0.4.0", registry = "strafesnet" }
 
-strafesnet_roblox_bot_player = { version = "0.2.0", path = "lib" }
+strafesnet_roblox_bot_player = { version = "0.6.2", path = "lib", registry = "strafesnet" }
 
 # strafesnet_common = { path = "../strafe-project/lib/common" }
 # strafesnet_graphics = { path = "../strafe-project/engine/graphics" }

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

@@ -6,7 +6,7 @@ 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);
+	let bot=bot::CompleteBot::new(timelines).unwrap();
 	let bvh=bvh::Bvh::new(&bot);
 
 	// sample the position at 0.24s
@@ -23,3 +23,28 @@ fn main(){
 	// 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,6 +1,6 @@
 [package]
 name = "strafesnet_roblox_bot_player"
-version = "0.2.0"
+version = "0.6.2"
 edition = "2024"
 
 [dependencies]
@@ -9,3 +9,4 @@ wgpu.workspace = true
 strafesnet_common.workspace = true
 strafesnet_graphics.workspace = true
 strafesnet_roblox_bot_file.workspace = true
+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{
@@ -17,19 +36,21 @@ 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)?;
+		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");
-		Self{
+		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)
@@ -47,18 +68,18 @@ impl CompleteBot{
 	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

@@ -2,12 +2,20 @@ use core::ops::Range;
 use strafesnet_common::aabb::Aabb;
 use strafesnet_common::bvh::generate_bvh;
 use strafesnet_common::integer::vec3;
-use strafesnet_common::integer::Fixed;
+use strafesnet_common::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(Range<usize>);
+struct EventSlice{
+	slice:Range<usize>,
+	inclusive:bool,
+}
 
 pub struct Bvh{
 	bvh:strafesnet_common::bvh::BvhNode<EventSlice>,
@@ -40,19 +48,23 @@ impl Bvh{
 			// 0123456789
 			// split into groups of MAX_SLICE_LEN=4
 			// [0123][4567][89]
-			let mut push_slice=|slice:Range<usize>|{
+			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(vec3::try_from_f32_array([event.event.position.x,event.event.position.y,event.event.position.z]).unwrap());
+					aabb.grow(v3(event.event.position));
 				}
-				bvh_nodes.push((EventSlice(slice),aabb));
+				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));
+				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);
+			push_slice((last_index+(count-1)*slice_len)..index,false);
 			last_index=index;
 		};
 		// find discontinuities (teleports) and avoid forming a bvh node across them
@@ -66,31 +78,90 @@ impl Bvh{
 		Self{bvh}
 	}
 	/// Find the exact timestamp on the bot timeline that is closest to the given point.
-	pub fn closest_time_to_point(&self,bot:&CompleteBot,point:glam::Vec3)->Option<PhysicsTime>{
+	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=|EventSlice(slice):&EventSlice|{
+		let intersect_leaf=|event_slice:&EventSlice|{
 			// calculate the distance to the leaf contents
-			output_events[slice.start..slice.end].iter().map(|event|{
+			let mut best_distance=output_events[event_slice.slice.start..event_slice.slice.end].iter().map(|event|{
 				let p=event.event.position;
-				let p=vec3::try_from_f32_array([p.x,p.y,p.z]).unwrap();
+				let p=v3(p);
 				(start_point-p).length_squared()
-			}).min()
+			}).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())
 		};
-		let (_,EventSlice(slice))=self.bvh.traverse(start_point,Fixed::ZERO,Fixed::MAX,intersect_leaf,intersect_aabb)?;
+		// traverse uses strict `start_time < t`, so use NEG_EPSILON to keep exact-zero-distance hits.
-		let closest_event=output_events[slice.start..slice.end].iter().min_by_key(|&event|{
+		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=vec3::try_from_f32_array([p.x,p.y,p.z]).unwrap();
+			let p=v3(p);
-			(start_point-p).length_squared()
+			(event.time,(start_point-p).length_squared())
-		})?;
+		}).min_by_key(|&(_,distance)|distance)?;
-		// TODO: project start_point onto the edges connected to the closest_event and return the true time
+		let mut best_time=crate::time::from_float(best_time).unwrap();
-		crate::time::from_float(closest_event.time).ok()
+		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,29 +1,44 @@
 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)->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,size,view_format);
+		let graphics=strafesnet_graphics::graphics::GraphicsState::new(device,queue,size,view_format,limits);
 		Self{
 			graphics,
 			start_offset:glam::Vec3::ZERO,
 		}
 	}
-	pub fn change_map(&mut self,device:&wgpu::Device,queue:&wgpu::Queue,map:&strafesnet_common::map::CompleteMap){
+	pub fn change_map(&mut self,device:&wgpu::Device,queue:&wgpu::Queue,map:&strafesnet_common::map::CompleteMap)->Result<(),ChangeMapError>{
 		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).expect("Map does not have a main mode");
+		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).expect("Map does not have a start zone");
+		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,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,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,7 +96,6 @@ impl PlaybackHead{
 
 					// update loop variables
 					simulation_time-=bot.duration();
-					time_float=simulation_time.into();
 				},
 			}
 		}

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/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);
+				let frame=self.surface.new_frame(device).expect("Error creating new frame");
 
 				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);
+				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,13 +15,14 @@ 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.unwrap();
+	let (device,queue)=setup::step4::request_device(&adapter,LIMITS).await.unwrap();
 
 	let size=window.inner_size();
 	let surface=setup::step5::configure_surface(&adapter,&device,surface,(size.width,size.height)).unwrap();
@@ -32,6 +35,7 @@ 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,9 +127,10 @@ 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());
+		let graphics=strafesnet_roblox_bot_player::graphics::Graphics::new(&device,&queue,size,surface.view_format(),limits);
 		WindowContext{
 			simulation_paused:false,
 			window,

video-encoder/src/encode.rs

@@ -90,6 +90,8 @@ struct EncodeParams{
 	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;
@@ -126,7 +128,7 @@ fn encode(params:EncodeParams)->Result<(),EncodeError>{
 		.map_err(EncodeError::CreateDevice)?;
 
 	// playback
-	let bot=strafesnet_roblox_bot_player::bot::CompleteBot::new(timelines);
+	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(
@@ -244,7 +246,7 @@ impl WgpuState {
 		size: glam::UVec2,
 	) -> WgpuState {
 		const FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8UnormSrgb;
-		let graphics = strafesnet_roblox_bot_player::graphics::Graphics::new(&device,&queue,size,FORMAT);
+		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);
@@ -319,7 +321,7 @@ impl WgpuState {
 		let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
 			label: Some("wgpu pipeline layout"),
 			bind_group_layouts: &[
-				&graphics_texture_bind_group_layout
+				Some(&graphics_texture_bind_group_layout),
 			],
 			immediate_size: 0,
 		});
@@ -371,7 +373,7 @@ impl WgpuState {
 	}
 
 	fn change_map(&mut self,map:&strafesnet_common::map::CompleteMap){
-		self.graphics.change_map(&self.device,&self.queue,map);
+		self.graphics.change_map(&self.device,&self.queue,map).unwrap();
 	}
 
 	fn render(&mut self,pos:glam::Vec3,angles:glam::Vec2) {

wasm-module/src/lib.rs

@@ -19,6 +19,12 @@ 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,
@@ -30,18 +36,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::from_env_or_default();
+	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=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).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()),
+		graphics:graphics::Graphics::new(&device,&queue,size,surface.view_format(),LIMITS),
 		surface,
 		device,
 		queue,
@@ -53,7 +59,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);
+		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()]);
@@ -66,8 +72,9 @@ 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){
+	pub fn change_map(&mut self,map:&CompleteMap)->Result<(),JsError>{
-		self.graphics.change_map(&self.device,&self.queue,&map.map);
+		self.graphics.change_map(&self.device,&self.queue,&map.map).map_err(|e|JsError::new(&e.to_string()))?;
+		Ok(())
 	}
 }
 
@@ -81,7 +88,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),
+			bot:bot::CompleteBot::new(timelines).map_err(|e|JsError::new(&e.to_string()))?,
 		})
 	}
 	#[wasm_bindgen]
@@ -89,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())
 	}
 }
 

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