D3V-X3N0/roblox-bot-player
1
Fork 0
forked from StrafesNET/roblox-bot-player
Code Pull Requests Activity

move setup into lib

Browse Source
This commit is contained in:
Rhys Lloyd
2026-02-18 09:06:57 -08:00
parent a43f4720a1
commit a39f0fe4db
3 changed files with 47 additions and 47 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
wasm-module/src/lib.rs
View File

@@ -1,9 +1,45 @@
use wasm_bindgen::prelude::wasm_bindgen;
use wasm_bindgen::JsValue;
use strafesnet_roblox_bot_player::{bot,graphics,head};
use strafesnet_roblox_bot_player::{bot,graphics,head,setup};
use strafesnet_common::session::Time as SessionTime;
mod setup;
struct ToSurfaceTarget{
canvas:web_sys::HtmlCanvasElement,
}
impl From<ToSurfaceTarget> for wgpu::SurfaceTarget<'static>{
fn from(ToSurfaceTarget{canvas}:ToSurfaceTarget)->Self{
#[cfg(target_arch = "wasm32")]
let target=wgpu::SurfaceTarget::Canvas(canvas);
#[expect(unused)]
#[cfg(not(target_arch = "wasm32"))]
let target=panic!("{canvas:?}");
#[allow(unused)]
target
}
}
async fn setup_and_start(canvas:web_sys::HtmlCanvasElement)->(wgpu::Device,wgpu::Queue,wgpu::Surface<'static>,wgpu::SurfaceConfiguration){
let size=(canvas.width(),canvas.height());
println!("Initializing the surface...");
let instance=setup::step1::create_instance();
let surface=setup::step2::create_surface(&instance,ToSurfaceTarget{canvas}).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 config=setup::step5::configure_surface(&adapter,&device,&surface,size);
(
device,
queue,
surface,
config,
)
}
#[wasm_bindgen]
pub struct Setup{
@@ -14,7 +50,7 @@ pub struct Setup{
}
#[wasm_bindgen]
pub async fn setup(canvas:web_sys::HtmlCanvasElement)->Setup{
let (device,queue,surface,config)=setup::setup_and_start(canvas).await;
let (device,queue,surface,config)=setup_and_start(canvas).await;
Setup{device,queue,surface,config}
}
#[wasm_bindgen]

149
wasm-module/src/setup.rs
View File

@@ -1,149 +0,0 @@
fn optional_features()->wgpu::Features{
wgpu::Features::TEXTURE_COMPRESSION_ASTC
|wgpu::Features::TEXTURE_COMPRESSION_ETC2
}
fn required_features()->wgpu::Features{
wgpu::Features::TEXTURE_COMPRESSION_BC
}
fn required_downlevel_capabilities()->wgpu::DownlevelCapabilities{
wgpu::DownlevelCapabilities{
flags:wgpu::DownlevelFlags::empty(),
shader_model:wgpu::ShaderModel::Sm5,
..wgpu::DownlevelCapabilities::default()
}
}
mod step1{
pub fn create_instance()->wgpu::Instance{
Default::default()
}
}
mod step2{
pub fn create_surface<'window>(instance:&wgpu::Instance,target:impl Into<wgpu::SurfaceTarget<'window>>)->Result<wgpu::Surface<'window>,wgpu::CreateSurfaceError>{
instance.create_surface(target)
}
}
mod step3{
pub async fn pick_adapter(instance:&wgpu::Instance,surface:&wgpu::Surface<'_>)->Option<wgpu::Adapter>{
let backends=wgpu::Backends::from_env().unwrap_or_default();
//TODO: prefer adapter that implements optional features
//let optional_features=optional_features();
let required_features=super::required_features();
let required_downlevel_capabilities=super::required_downlevel_capabilities();
//no helper function smh gotta write it myself
let adapters=instance.enumerate_adapters(backends).await;
let adapter=adapters.into_iter()
// reverse because we want to select adapters that appear first in ties,
// and max_by_key selects the last equal element in the iterator.
.rev()
.filter(|adapter|
adapter.is_surface_supported(surface)
&&adapter.features().contains(required_features)
&&{
let downlevel_capabilities=adapter.get_downlevel_capabilities();
downlevel_capabilities.shader_model>=required_downlevel_capabilities.shader_model
&&downlevel_capabilities.flags.contains(required_downlevel_capabilities.flags)
}
)
.max_by_key(|adapter|match adapter.get_info().device_type{
wgpu::DeviceType::IntegratedGpu=>3,
wgpu::DeviceType::DiscreteGpu=>4,
wgpu::DeviceType::VirtualGpu=>2,
wgpu::DeviceType::Other|wgpu::DeviceType::Cpu=>1,
})?;
let adapter_info=adapter.get_info();
println!("Using {} ({:?})", adapter_info.name, adapter_info.backend);
Some(adapter)
}
}
mod step4{
pub async fn request_device(adapter:&wgpu::Adapter)->(wgpu::Device,wgpu::Queue){
let optional_features=super::optional_features();
let required_features=super::required_features();
// Make sure we use the texture resolution limits from the adapter, so we can support images the size of the surface.
let needed_limits=strafesnet_graphics::graphics::required_limits().using_resolution(adapter.limits());
let (device, queue)=adapter
.request_device(
&wgpu::DeviceDescriptor{
label:None,
required_features:(optional_features&adapter.features())|required_features,
required_limits:needed_limits,
memory_hints:wgpu::MemoryHints::Performance,
trace:wgpu::Trace::Off,
experimental_features:wgpu::ExperimentalFeatures::disabled(),
},
).await
.expect("Unable to find a suitable GPU adapter!");
(
device,
queue,
)
}
}
mod step5{
pub fn configure_surface(
adapter:&wgpu::Adapter,
device:&wgpu::Device,
surface:&wgpu::Surface<'_>,
(width,height):(u32,u32),
)->wgpu::SurfaceConfiguration{
let mut config=surface
.get_default_config(adapter, width, height)
.expect("Surface isn't supported by the adapter.");
let surface_view_format=config.format.add_srgb_suffix();
config.view_formats.push(surface_view_format);
config.present_mode=wgpu::PresentMode::AutoNoVsync;
surface.configure(device, &config);
config
}
}
struct ToSurfaceTarget{
canvas:web_sys::HtmlCanvasElement,
}
impl From<ToSurfaceTarget> for wgpu::SurfaceTarget<'static>{
fn from(ToSurfaceTarget{canvas}:ToSurfaceTarget)->Self{
#[cfg(target_arch = "wasm32")]
let target=wgpu::SurfaceTarget::Canvas(canvas);
#[expect(unused)]
#[cfg(not(target_arch = "wasm32"))]
let target=panic!("{canvas:?}");
#[allow(unused)]
target
}
}
pub async fn setup_and_start(canvas:web_sys::HtmlCanvasElement)->(wgpu::Device,wgpu::Queue,wgpu::Surface<'static>,wgpu::SurfaceConfiguration){
let size=(canvas.width(),canvas.height());
println!("Initializing the surface...");
let instance=step1::create_instance();
let surface=step2::create_surface(&instance,ToSurfaceTarget{canvas}).unwrap();
let adapter=step3::pick_adapter(&instance,&surface).await.expect("No suitable GPU adapters found on the system!");
let (device,queue)=step4::request_device(&adapter).await;
let config=step5::configure_surface(&adapter,&device,&surface,size);
(
device,
queue,
surface,
config,
)
}