initial commit

Cargo.lock

@@ -1901,6 +1901,20 @@ version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
+[[package]]
+name = "video-encoder"
+version = "0.1.0"
+dependencies = [
+ "glam",
+ "pollster",
+ "strafesnet_common",
+ "strafesnet_graphics",
+ "strafesnet_roblox_bot_file",
+ "strafesnet_roblox_bot_player",
+ "strafesnet_snf",
+ "wgpu",
+]
+
 [[package]]
 name = "walkdir"
 version = "2.5.0"

Cargo.toml

@@ -2,6 +2,7 @@
 members = [
 	"lib",
 	"native-player",
+	"video-encoder",
 	"wasm-module"
 ]
 resolver = "3"

video-encoder/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "video-encoder"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+glam.workspace = true
+pollster = "0.4.0"
+wgpu = "28.0.0"
+strafesnet_roblox_bot_player.workspace = true
+strafesnet_common.workspace = true
+strafesnet_graphics.workspace = true
+strafesnet_roblox_bot_file.workspace = true
+strafesnet_snf.workspace = true

video-encoder/src/app.rs

@@ -0,0 +1,68 @@
+use crate::window::Instruction;
+use strafesnet_common::integer;
+use strafesnet_common::instruction::TimedInstruction;
+use crate::window::WindowContext;
+
+pub struct App<'a>{
+	root_time:std::time::Instant,
+	window_thread:WindowContext<'a>,
+}
+impl<'a> App<'a>{
+	pub fn new(
+		root_time:std::time::Instant,
+		window_thread:WindowContext<'a>,
+	)->App<'a>{
+		Self{
+			root_time,
+			window_thread,
+		}
+	}
+	fn send_timed_instruction(&mut self,instruction:Instruction){
+		let time=integer::Time::from_nanos(self.root_time.elapsed().as_nanos() as i64);
+		self.window_thread.send(TimedInstruction{time,instruction});
+	}
+}
+impl winit::application::ApplicationHandler for App<'_>{
+	fn resumed(&mut self,_event_loop:&winit::event_loop::ActiveEventLoop){
+		//
+	}
+
+	fn window_event(
+		&mut self,
+		event_loop:&winit::event_loop::ActiveEventLoop,
+		_window_id:winit::window::WindowId,
+		event:winit::event::WindowEvent,
+	){
+		match event{
+			winit::event::WindowEvent::KeyboardInput{
+				event:winit::event::KeyEvent{
+					logical_key:winit::keyboard::Key::Named(winit::keyboard::NamedKey::Escape),
+					state:winit::event::ElementState::Pressed,
+					..
+				},
+				..
+			}
+			|winit::event::WindowEvent::CloseRequested=>{
+				event_loop.exit();
+			},
+			_=>(),
+		}
+		self.send_timed_instruction(Instruction::WindowEvent(event));
+	}
+
+	fn device_event(
+		&mut self,
+		_event_loop:&winit::event_loop::ActiveEventLoop,
+		_device_id:winit::event::DeviceId,
+		event:winit::event::DeviceEvent,
+	){
+		self.send_timed_instruction(Instruction::DeviceEvent(event));
+	}
+
+	fn about_to_wait(
+		&mut self,
+		_event_loop:&winit::event_loop::ActiveEventLoop
+	){
+		self.send_timed_instruction(Instruction::WindowEvent(winit::event::WindowEvent::RedrawRequested));
+	}
+}

video-encoder/src/file.rs

@@ -0,0 +1,68 @@
+use std::io::Read;
+
+#[expect(dead_code)]
+#[derive(Debug)]
+pub enum ReadError{
+	StrafesNET(strafesnet_snf::Error),
+	StrafesNETMap(strafesnet_snf::map::Error),
+	RobloxBot(strafesnet_roblox_bot_file::v0::Error),
+	Io(std::io::Error),
+	UnknownFileFormat,
+}
+impl std::fmt::Display for ReadError{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{self:?}")
+	}
+}
+impl std::error::Error for ReadError{}
+
+pub enum ReadFormat{
+	SNFM(strafesnet_common::map::CompleteMap),
+	QBOT(strafesnet_roblox_bot_file::v0::Block),
+}
+
+pub fn read<R:Read+std::io::Seek>(input:R)->Result<ReadFormat,ReadError>{
+	let mut buf=std::io::BufReader::new(input);
+	let peek=std::io::BufRead::fill_buf(&mut buf).map_err(ReadError::Io)?[0..4].to_owned();
+	// reading the entire file is way faster than round tripping the disk constantly
+	let mut entire_file=Vec::new();
+	buf.read_to_end(&mut entire_file).map_err(ReadError::Io)?;
+	let cursor=std::io::Cursor::new(entire_file);
+	match peek.as_slice(){
+		b"SNFM"=>Ok(ReadFormat::SNFM(
+			strafesnet_snf::read_map(cursor).map_err(ReadError::StrafesNET)?
+			.into_complete_map().map_err(ReadError::StrafesNETMap)?
+		)),
+		b"qbot"=>Ok(ReadFormat::QBOT(
+			strafesnet_roblox_bot_file::v0::read_all_to_block(cursor).map_err(ReadError::RobloxBot)?
+		)),
+		_=>Err(ReadError::UnknownFileFormat),
+	}
+}
+
+#[expect(dead_code)]
+#[derive(Debug)]
+pub enum LoadError{
+	ReadError(ReadError),
+	File(std::io::Error),
+}
+impl std::fmt::Display for LoadError{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{self:?}")
+	}
+}
+impl std::error::Error for LoadError{}
+
+pub enum LoadFormat{
+	Map(strafesnet_common::map::CompleteMap),
+	Bot(strafesnet_roblox_bot_file::v0::Block),
+}
+
+pub fn load<P:AsRef<std::path::Path>>(path:P)->Result<LoadFormat,LoadError>{
+	//blocking because it's simpler...
+	let file=std::fs::File::open(path).map_err(LoadError::File)?;
+	match read(file).map_err(LoadError::ReadError)?{
+		ReadFormat::QBOT(bot)=>Ok(LoadFormat::Bot(bot)),
+		ReadFormat::SNFM(map)=>Ok(LoadFormat::Map(map)),
+	}
+}

video-encoder/src/main.rs

@@ -0,0 +1,12 @@
+mod app;
+mod file;
+mod player;
+mod setup;
+mod window;
+
+
+const TITLE:&'static str=concat!("Roblox Bot Player v",env!("CARGO_PKG_VERSION"));
+
+fn main(){
+	pollster::block_on(setup::setup_and_start(TITLE));
+}

video-encoder/src/player.rs

@@ -0,0 +1,101 @@
+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}};
+
+pub enum SessionControlInstruction{
+	SetPaused(bool),
+	Restart,
+	SkipForward,
+	SkipBack,
+	DecreaseTimescale,
+	IncreaseTimescale,
+}
+
+pub enum Instruction{
+	SessionControl(SessionControlInstruction),
+	Render,
+	Resize(winit::dpi::PhysicalSize<u32>),
+	ChangeMap(strafesnet_common::map::CompleteMap),
+	LoadReplay(strafesnet_roblox_bot_file::v0::Block),
+}
+
+fn speed_ratio(speed:i8)->strafesnet_common::integer::Ratio64{
+	if speed.is_negative(){
+		strafesnet_common::integer::Ratio64::new(4i64.pow(-speed as u32),5u64.pow(-speed as u32)).unwrap()
+	}else{
+		strafesnet_common::integer::Ratio64::new(5i64.pow(speed as u32),4u64.pow(speed as u32)).unwrap()
+	}
+}
+
+struct Playback{
+	bot:CompleteBot,
+	playback_head:PlaybackHead,
+	playback_speed:i8,
+}
+
+pub struct PlayerWorker<'a>{
+	surface:wgpu::Surface<'a>,
+	graphics_thread:Graphics,
+	playback:Option<Playback>,
+}
+impl<'a> PlayerWorker<'a>{
+	pub fn new(
+		surface:wgpu::Surface<'a>,
+		graphics_thread:Graphics,
+	)->Self{
+		Self{
+			surface,
+			graphics_thread,
+			playback:None,
+		}
+	}
+	pub fn send(&mut self,ins:TimedInstruction<Instruction,SessionTime>){
+		match ins.instruction{
+			Instruction::SessionControl(SessionControlInstruction::SetPaused(paused))=>if let Some(playback)=&mut self.playback{
+				playback.playback_head.set_paused(ins.time,paused);
+			},
+			Instruction::SessionControl(SessionControlInstruction::Restart)=>if let Some(playback)=&mut self.playback{
+				playback.playback_head.set_time(&playback.bot,ins.time,PlaybackTime::ZERO);
+			},
+			Instruction::SessionControl(SessionControlInstruction::SkipForward)=>if let Some(playback)=&mut self.playback{
+				let head_time=playback.playback_head.timer().clone().into_state().0.get_time(ins.time+SessionTime::from_secs(2));
+				playback.playback_head.set_time(&playback.bot,ins.time,head_time);
+			},
+			Instruction::SessionControl(SessionControlInstruction::SkipBack)=>if let Some(playback)=&mut self.playback{
+				let head_time=playback.playback_head.timer().clone().into_state().0.get_time(ins.time-SessionTime::from_secs(2));
+				playback.playback_head.set_time(&playback.bot,ins.time,head_time);
+			},
+			Instruction::SessionControl(SessionControlInstruction::DecreaseTimescale)=>if let Some(playback)=&mut self.playback{
+				playback.playback_speed=playback.playback_speed.saturating_sub(1).max(-27);
+				playback.playback_head.set_scale(ins.time,speed_ratio(playback.playback_speed));
+			},
+			Instruction::SessionControl(SessionControlInstruction::IncreaseTimescale)=>if let Some(playback)=&mut self.playback{
+				playback.playback_speed=playback.playback_speed.saturating_add(1).min(27);
+				playback.playback_head.set_scale(ins.time,speed_ratio(playback.playback_speed));
+			},
+			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);
+			},
+			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));
+			},
+			Instruction::ChangeMap(complete_map)=>{
+				self.graphics_thread.change_map(&complete_map);
+			},
+			Instruction::LoadReplay(bot)=>{
+				let bot=CompleteBot::new(bot);
+				let playback_head=PlaybackHead::new(&bot,SessionTime::ZERO);
+				self.playback=Some(Playback{
+					bot,
+					playback_head,
+					playback_speed:0,
+				});
+			},
+		}
+	}
+}

video-encoder/src/setup.rs

@@ -0,0 +1,51 @@
+use strafesnet_graphics::setup;
+
+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);
+	event_loop.create_window(attr)
+}
+
+pub async fn setup_and_start(title:&str){
+	let event_loop=winit::event_loop::EventLoop::new().unwrap();
+
+	let window=create_window(title,&event_loop).unwrap();
+
+	println!("Initializing the surface...");
+
+	let instance=setup::step1::create_instance();
+
+	let surface=setup::step2::create_surface(&instance,&window).unwrap();
+
+	let adapter=setup::step3::pick_adapter(&instance,&surface).await.expect("No suitable GPU adapters found on the system!");
+
+	let (device,queue)=setup::step4::request_device(&adapter).await.unwrap();
+
+	let size=window.inner_size();
+	let config=setup::step5::configure_surface(&adapter,&device,&surface,(size.width,size.height)).unwrap();
+
+	//dedicated thread to ping request redraw back and resize the window doesn't seem logical
+
+	//the thread that spawns the physics thread
+	let mut window_thread=crate::window::WindowContext::new(
+		&window,
+		device,
+		queue,
+		surface,
+		config,
+	);
+
+	for arg in std::env::args().skip(1){
+		window_thread.send(strafesnet_common::instruction::TimedInstruction{
+			time:strafesnet_common::integer::Time::ZERO,
+			instruction:crate::window::Instruction::WindowEvent(winit::event::WindowEvent::DroppedFile(arg.into())),
+		});
+	};
+
+	println!("Entering event loop...");
+	let mut app=crate::app::App::new(
+		std::time::Instant::now(),
+		window_thread
+	);
+	event_loop.run_app(&mut app).unwrap();
+}

video-encoder/src/window.rs

@@ -0,0 +1,137 @@
+use strafesnet_common::instruction::TimedInstruction;
+use strafesnet_common::session::Time as SessionTime;
+use crate::file::LoadFormat;
+use crate::player::{PlayerWorker,Instruction as PhysicsWorkerInstruction,SessionControlInstruction};
+
+pub enum Instruction{
+	WindowEvent(winit::event::WindowEvent),
+	DeviceEvent(winit::event::DeviceEvent),
+}
+
+//holds thread handles to dispatch to
+pub struct WindowContext<'a>{
+	simulation_paused:bool,
+	window:&'a winit::window::Window,
+	physics_thread:PlayerWorker<'a>,
+}
+
+impl WindowContext<'_>{
+	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::Bot(bot))=>self.physics_thread.send(TimedInstruction{time,instruction:PhysicsWorkerInstruction::LoadReplay(bot)}),
+					Err(e)=>println!("Failed to load file: {e}"),
+				}
+			},
+			winit::event::WindowEvent::Focused(state)=>{
+				// don't unpause if manually paused
+				if self.simulation_paused{
+					return;
+				}
+				//pause unpause
+				self.physics_thread.send(TimedInstruction{
+					time,
+					instruction:PhysicsWorkerInstruction::SessionControl(SessionControlInstruction::SetPaused(!state)),
+				});
+				//recalculate pressed keys on focus
+			},
+			winit::event::WindowEvent::KeyboardInput{
+				event:winit::event::KeyEvent{state,logical_key,repeat:false,..},
+				..
+			}=>{
+				match (logical_key,state){
+					(winit::keyboard::Key::Named(winit::keyboard::NamedKey::F11),winit::event::ElementState::Pressed)=>{
+						if self.window.fullscreen().is_some(){
+							self.window.set_fullscreen(None);
+						}else{
+							self.window.set_fullscreen(Some(winit::window::Fullscreen::Borderless(None)));
+						}
+					},
+					(keycode,state)=>{
+						let s=state.is_pressed();
+
+						macro_rules! session_ctrl{
+							($variant:ident,$state:expr)=>{
+								s.then_some(PhysicsWorkerInstruction::SessionControl(SessionControlInstruction::$variant))
+							};
+						}
+
+						if let Some(instruction)=match keycode{
+							winit::keyboard::Key::Named(winit::keyboard::NamedKey::Space)=>if s{
+								let paused=!self.simulation_paused;
+								self.simulation_paused=paused;
+								Some(PhysicsWorkerInstruction::SessionControl(SessionControlInstruction::SetPaused(paused)))
+							}else{None},
+							winit::keyboard::Key::Named(winit::keyboard::NamedKey::ArrowUp)=>session_ctrl!(IncreaseTimescale,s),
+							winit::keyboard::Key::Named(winit::keyboard::NamedKey::ArrowDown)=>session_ctrl!(DecreaseTimescale,s),
+							winit::keyboard::Key::Named(winit::keyboard::NamedKey::ArrowLeft)=>session_ctrl!(SkipBack,s),
+							winit::keyboard::Key::Named(winit::keyboard::NamedKey::ArrowRight)=>session_ctrl!(SkipForward,s),
+							winit::keyboard::Key::Character(key)=>match key.as_str(){
+								"R"|"r"=>session_ctrl!(Restart,s),
+								_=>None,
+							},
+							_=>None,
+						}{
+							self.physics_thread.send(TimedInstruction{
+								time,
+								instruction,
+							});
+						}
+					},
+				}
+			},
+			winit::event::WindowEvent::Resized(size)=>{
+				self.physics_thread.send(
+					TimedInstruction{
+						time,
+						instruction:PhysicsWorkerInstruction::Resize(size)
+					}
+				);
+			},
+			winit::event::WindowEvent::RedrawRequested=>{
+				self.window.request_redraw();
+				self.physics_thread.send(
+					TimedInstruction{
+						time,
+						instruction:PhysicsWorkerInstruction::Render
+					}
+				);
+			},
+			_=>(),
+		}
+	}
+
+	fn device_event(&mut self,_time:SessionTime,_event:winit::event::DeviceEvent){
+	}
+
+	pub fn send(&mut self,ins:TimedInstruction<Instruction,SessionTime>){
+		match ins.instruction{
+			Instruction::WindowEvent(window_event)=>{
+				self.window_event(ins.time,window_event);
+			},
+			Instruction::DeviceEvent(device_event)=>{
+				self.device_event(ins.time,device_event);
+			},
+		}
+	}
+
+	pub fn new<'a>(
+		window:&'a winit::window::Window,
+		device:wgpu::Device,
+		queue:wgpu::Queue,
+		surface:wgpu::Surface<'a>,
+		config:wgpu::SurfaceConfiguration,
+	)->WindowContext<'a>{
+		let graphics=strafesnet_roblox_bot_player::graphics::Graphics::new(device,queue,config);
+		WindowContext{
+			simulation_paused:false,
+			window,
+			physics_thread:crate::player::PlayerWorker::new(
+				surface,
+				graphics,
+			),
+		}
+	}
+}