zenithsiz/zsw
1
0
Fork 0
mirror of https://github.com/Zenithsiz/zsw.git synced 2026-02-03 17:52:15 +00:00
Code Issues Packages Projects Releases Wiki Activity

Renamed WgpuShared to Wgpu.

Browse Source
This commit is contained in:
Filipe Rodrigues 2025-09-08 03:30:59 +01:00
parent f902c6cf98
commit 50b851209e
Signed by: zenithsiz
SSH Key Fingerprint: SHA256:Mb5ppb3Sh7IarBO/sBTXLHbYEOz37hJAlslLQPPAPaU
10 changed files with 135 additions and 146 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
zsw-egui/src/lib.rs
View File

@ -10,7 +10,7 @@ use {
tokio::sync::Mutex,
tracing as _,
winit::window::Window,
zsw_wgpu::{FrameRender, WgpuRenderer, WgpuShared},
zsw_wgpu::{FrameRender, WgpuRenderer, Wgpu},
app_error::Context, zsw_util::AppError,
};
@ -29,10 +29,10 @@ impl fmt::Debug for EguiRenderer {
impl EguiRenderer {
/// Creates a new egui renderer
#[must_use]
pub fn new(wgpu_renderer: &WgpuRenderer, wgpu_shared: &WgpuShared) -> Self {
pub fn new(wgpu_renderer: &WgpuRenderer, wgpu: &Wgpu) -> Self {
// Create the egui render pass
let render_pass =
egui_wgpu_backend::RenderPass::new(&wgpu_shared.device, wgpu_renderer.surface_config().format, 1);
egui_wgpu_backend::RenderPass::new(&wgpu.device, wgpu_renderer.surface_config().format, 1);
Self { render_pass }
}
@ -42,7 +42,7 @@ impl EguiRenderer {
&mut self,
frame: &mut FrameRender,
window: &Window,
wgpu_shared: &WgpuShared,
wgpu: &Wgpu,
paint_jobs: &[egui::ClippedPrimitive],
textures_delta: Option<egui::TexturesDelta>,
) -> Result<(), AppError> {
@ -57,13 +57,13 @@ impl EguiRenderer {
// If we have any textures delta, update them
if let Some(textures_delta) = textures_delta.as_ref() {
self.render_pass
.add_textures(&wgpu_shared.device, &wgpu_shared.queue, textures_delta)
.add_textures(&wgpu.device, &wgpu.queue, textures_delta)
.context("Unable to update textures")?;
}
// Update buffers
self.render_pass
.update_buffers(&wgpu_shared.device, &wgpu_shared.queue, paint_jobs, &screen_descriptor);
.update_buffers(&wgpu.device, &wgpu.queue, paint_jobs, &screen_descriptor);
// Record all render passes.
self.render_pass

45
zsw-wgpu/src/lib.rs
View File

@ -12,9 +12,9 @@ pub use renderer::{FrameRender, WgpuRenderer};
// Imports
use {app_error::Context, tokio::sync::OnceCell, zsw_util::AppError};
/// Wgpu shared
/// Wgpu
#[derive(Debug)]
pub struct WgpuShared {
pub struct Wgpu {
/// Instance
pub instance: wgpu::Instance,
@ -34,34 +34,33 @@ pub struct WgpuShared {
pub empty_texture_view: wgpu::TextureView,
}
/// Shared
/// Wgpu
// TODO: Is it a good idea to make this a global?
// Realistically, we can only have one per process anyway,
// so this models that correctly, but it might be bad API.
static SHARED: OnceCell<WgpuShared> = OnceCell::const_new();
static WGPU: OnceCell<Wgpu> = OnceCell::const_new();
/// Gets or creates the shared state
pub async fn get_or_create_shared() -> Result<&'static WgpuShared, AppError> {
SHARED
.get_or_try_init(async || {
let instance = self::create_instance().context("Unable to create instance")?;
let adapter = self::create_adapter(&instance)
.await
.context("Unable to create adaptor")?;
let (device, queue) = self::create_device(&adapter).await.context("Unable to create device")?;
/// Gets or creates the wgpu
pub async fn get_or_create() -> Result<&'static Wgpu, AppError> {
WGPU.get_or_try_init(async || {
let instance = self::create_instance().context("Unable to create instance")?;
let adapter = self::create_adapter(&instance)
.await
.context("Unable to create adaptor")?;
let (device, queue) = self::create_device(&adapter).await.context("Unable to create device")?;
let (empty_texture, empty_texture_view) = self::create_empty_image_texture(&device);
let (empty_texture, empty_texture_view) = self::create_empty_image_texture(&device);
Ok::<_, AppError>(WgpuShared {
instance,
adapter,
device,
queue,
empty_texture,
empty_texture_view,
})
Ok::<_, AppError>(Wgpu {
instance,
adapter,
device,
queue,
empty_texture,
empty_texture_view,
})
.await
})
.await
}
/// Creates the device

34
zsw-wgpu/src/renderer.rs
View File

@ -2,7 +2,7 @@
// Imports
use {
super::WgpuShared,
super::Wgpu,
app_error::Context,
std::sync::Arc,
winit::{dpi::PhysicalSize, window::Window},
@ -34,15 +34,15 @@ pub struct WgpuRenderer {
}
impl WgpuRenderer {
pub fn new(window: Arc<Window>, shared: &WgpuShared) -> Result<Self, AppError> {
pub fn new(window: Arc<Window>, wgpu: &Wgpu) -> Result<Self, AppError> {
// Create the surface
// SAFETY: We keep an `Arc<Window>` that we only drop
// *after* dropping the surface.
let surface = unsafe { self::create_surface(shared, &window) }?;
let surface = unsafe { self::create_surface(wgpu, &window) }?;
// Configure the surface and get the preferred texture format and surface size
let surface_size = window.inner_size();
let surface_config = self::configure_window_surface(shared, &surface, surface_size)
let surface_config = self::configure_window_surface(wgpu, &surface, surface_size)
.context("Unable to configure window surface")?;
Ok(Self {
@ -69,7 +69,7 @@ impl WgpuRenderer {
///
/// Returns the encoder and surface view to render onto
// TODO: Ensure it's not called more than once?
pub fn start_render(&self, shared: &WgpuShared) -> Result<FrameRender, AppError> {
pub fn start_render(&self, wgpu: &Wgpu) -> Result<FrameRender, AppError> {
// And then get the surface texture
// Note: This can block, so we run it under tokio's block-in-place
// Note: If the application goes to sleep, this can fail spuriously due to a timeout,
@ -96,7 +96,7 @@ impl WgpuRenderer {
let encoder_descriptor = wgpu::CommandEncoderDescriptor {
label: Some("[zsw] Frame render command encoder"),
};
let encoder = shared.device.create_command_encoder(&encoder_descriptor);
let encoder = wgpu.device.create_command_encoder(&encoder_descriptor);
Ok(FrameRender {
encoder,
@ -107,7 +107,7 @@ impl WgpuRenderer {
}
/// Re-configures the surface
pub fn reconfigure(&mut self, shared: &WgpuShared) -> Result<(), AppError> {
pub fn reconfigure(&mut self, wgpu: &Wgpu) -> Result<(), AppError> {
tracing::info!(
"Reconfiguring wgpu surface to {}x{}",
self.surface_size.width,
@ -115,14 +115,14 @@ impl WgpuRenderer {
);
// Update our surface
self.surface_config = self::configure_window_surface(shared, &self.surface, self.surface_size)
self.surface_config = self::configure_window_surface(wgpu, &self.surface, self.surface_size)
.context("Unable to configure window surface")?;
Ok(())
}
/// Performs a resize
pub fn resize(&mut self, shared: &WgpuShared, size: PhysicalSize<u32>) -> Result<(), AppError> {
pub fn resize(&mut self, wgpu: &Wgpu, size: PhysicalSize<u32>) -> Result<(), AppError> {
tracing::info!(
"Resizing wgpu surface to {}x{}",
self.surface_size.width,
@ -132,7 +132,7 @@ impl WgpuRenderer {
// TODO: Don't ignore resizes to the same size?
if size.width > 0 && size.height > 0 && size != self.surface_size {
// Update our surface
self.surface_config = self::configure_window_surface(shared, &self.surface, size)
self.surface_config = self::configure_window_surface(wgpu, &self.surface, size)
.context("Unable to configure window surface")?;
self.surface_size = size;
}
@ -162,11 +162,11 @@ impl FrameRender {
///
/// Returns if a reconfigure is needed
#[must_use]
pub fn finish(self, shared: &WgpuShared) -> bool {
pub fn finish(self, wgpu: &Wgpu) -> bool {
// Submit everything to the queue and present the surface's texture
// Note: Although not supposed to, `submit` calls can block, so we wrap it
// in a tokio block-in-place
let _ = tokio::task::block_in_place(|| shared.queue.submit([self.encoder.finish()]));
let _ = tokio::task::block_in_place(|| wgpu.queue.submit([self.encoder.finish()]));
let reconfigure = self.surface_texture.suboptimal;
self.surface_texture.present();
@ -176,13 +176,13 @@ impl FrameRender {
/// Configures the window surface and returns the configuration
fn configure_window_surface(
shared: &WgpuShared,
wgpu: &Wgpu,
surface: &wgpu::Surface<'static>,
size: PhysicalSize<u32>,
) -> Result<wgpu::SurfaceConfiguration, AppError> {
// Get the format
let mut config = surface
.get_default_config(&shared.adapter, size.width, size.height)
.get_default_config(&wgpu.adapter, size.width, size.height)
.context("Unable to get surface default config")?;
tracing::debug!(?config, "Found surface configuration");
@ -192,7 +192,7 @@ fn configure_window_surface(
tracing::debug!(?config, "Updated surface configuration");
// Then configure it
surface.configure(&shared.device, &config);
surface.configure(&wgpu.device, &config);
Ok(config)
}
@ -201,13 +201,13 @@ fn configure_window_surface(
///
/// # Safety
/// The returned surface *must* be dropped before the window.
unsafe fn create_surface(shared: &WgpuShared, window: &Window) -> Result<wgpu::Surface<'static>, AppError> {
unsafe fn create_surface(wgpu: &Wgpu, window: &Window) -> Result<wgpu::Surface<'static>, AppError> {
// Create the surface
tracing::debug!(?window, "Requesting wgpu surface");
// SAFETY: User ensures that the surface is dropped before the window.
let target = unsafe { wgpu::SurfaceTargetUnsafe::from_window(window) }.context("Unable to get window target")?;
// SAFETY: User ensures that the surface is dropped before the window.
let surface = unsafe { shared.instance.create_surface_unsafe(target) }.context("Unable to request surface")?;
let surface = unsafe { wgpu.instance.create_surface_unsafe(target) }.context("Unable to request surface")?;
tracing::debug!(?surface, "Created wgpu surface");
Ok(surface)

8
zsw/src/main.rs
View File

@ -168,10 +168,8 @@ impl WinitApp {
config_dirs: Arc<ConfigDirs>,
event_loop_proxy: winit::event_loop::EventLoopProxy<AppEvent>,
) -> Result<Self, AppError> {
let wgpu_shared = zsw_wgpu::get_or_create_shared()
.await
.context("Unable to initialize wgpu")?;
let panels_renderer_layouts = PanelsRendererLayouts::new(wgpu_shared);
let wgpu = zsw_wgpu::get_or_create().await.context("Unable to initialize wgpu")?;
let panels_renderer_layouts = PanelsRendererLayouts::new(wgpu);
let playlists = Playlists::new(config_dirs.playlists().to_path_buf());
let panels = Panels::new(config_dirs.panels().to_path_buf());
@ -182,7 +180,7 @@ impl WinitApp {
last_resize: AtomicCell::new(None),
// TODO: Not have a default of (0,0)?
cursor_pos: AtomicCell::new(PhysicalPosition::new(0.0, 0.0)),
wgpu: wgpu_shared,
wgpu,
panels_renderer_layouts,
panels,
playlists: Arc::new(playlists),

34
zsw/src/panel/images.rs
View File

@ -14,7 +14,7 @@ use {
std::{self, mem, path::Path, sync::Arc},
tracing::Instrument,
zsw_util::{AppError, Loadable, loadable::Loader},
zsw_wgpu::WgpuShared,
zsw_wgpu::Wgpu,
zutil_cloned::cloned,
};
@ -76,13 +76,13 @@ impl PanelFadeImages {
/// If successful, starts loading any missing images
///
/// Returns `Err(())` if this would erase the current image.
pub fn step_prev(&mut self, playlist_player: &mut PlaylistPlayer, wgpu_shared: &WgpuShared) -> Result<(), ()> {
pub fn step_prev(&mut self, playlist_player: &mut PlaylistPlayer, wgpu: &Wgpu) -> Result<(), ()> {
playlist_player.step_prev()?;
mem::swap(&mut self.cur, &mut self.next);
mem::swap(&mut self.prev, &mut self.cur);
self.prev = PanelFadeImage::empty();
self.image_bind_group = None;
self.load_missing(playlist_player, wgpu_shared);
self.load_missing(playlist_player, wgpu);
Ok(())
}
@ -92,7 +92,7 @@ impl PanelFadeImages {
/// If successful, starts loading any missing images
///
/// Returns `Err(())` if this would erase the current image.
pub fn step_next(&mut self, playlist_player: &mut PlaylistPlayer, wgpu_shared: &WgpuShared) -> Result<(), ()> {
pub fn step_next(&mut self, playlist_player: &mut PlaylistPlayer, wgpu: &Wgpu) -> Result<(), ()> {
if !self.next.is_loaded() {
return Err(());
}
@ -102,7 +102,7 @@ impl PanelFadeImages {
mem::swap(&mut self.cur, &mut self.next);
self.next = PanelFadeImage::empty();
self.image_bind_group = None;
self.load_missing(playlist_player, wgpu_shared);
self.load_missing(playlist_player, wgpu);
Ok(())
}
@ -110,9 +110,9 @@ impl PanelFadeImages {
/// Loads any missing images, prioritizing the current, then next, then previous.
///
/// Requests images if missing any.
pub fn load_missing(&mut self, playlist_player: &mut PlaylistPlayer, wgpu_shared: &WgpuShared) {
pub fn load_missing(&mut self, playlist_player: &mut PlaylistPlayer, wgpu: &Wgpu) {
// Get the next image, if we can
let Some(res) = self.next_image(playlist_player, wgpu_shared) else {
let Some(res) = self.next_image(playlist_player, wgpu) else {
return;
};
@ -130,7 +130,7 @@ impl PanelFadeImages {
);
playlist_player.remove(&res.path);
_ = self.schedule_load_image(playlist_player, wgpu_shared);
_ = self.schedule_load_image(playlist_player, wgpu);
return;
},
};
@ -154,9 +154,9 @@ impl PanelFadeImages {
if let Some(slot) = slot {
match slot {
Slot::Prev => self.prev = PanelFadeImage::new(wgpu_shared, res.path, image),
Slot::Cur => self.cur = PanelFadeImage::new(wgpu_shared, res.path, image),
Slot::Next => self.next = PanelFadeImage::new(wgpu_shared, res.path, image),
Slot::Prev => self.prev = PanelFadeImage::new(wgpu, res.path, image),
Slot::Cur => self.cur = PanelFadeImage::new(wgpu, res.path, image),
Slot::Next => self.next = PanelFadeImage::new(wgpu, res.path, image),
}
self.image_bind_group = None;
}
@ -166,20 +166,16 @@ impl PanelFadeImages {
///
/// If an image is not scheduled, schedules it, even after
/// successfully returning an image
fn next_image(&mut self, playlist_player: &mut PlaylistPlayer, wgpu_shared: &WgpuShared) -> Option<ImageLoadRes> {
fn next_image(&mut self, playlist_player: &mut PlaylistPlayer, wgpu: &Wgpu) -> Option<ImageLoadRes> {
// Schedule it and try to take any existing image result
_ = self.schedule_load_image(playlist_player, wgpu_shared);
_ = self.schedule_load_image(playlist_player, wgpu);
self.next_image.take()
}
/// Schedules a new image.
///
/// If the image is loaded, returns it
fn schedule_load_image(
&mut self,
playlist_player: &mut PlaylistPlayer,
wgpu_shared: &WgpuShared,
) -> Option<&mut ImageLoadRes> {
fn schedule_load_image(&mut self, playlist_player: &mut PlaylistPlayer, wgpu: &Wgpu) -> Option<&mut ImageLoadRes> {
// If we're loaded, just return it
// Note: We can't use if-let due to a borrow-checker limitation
if self.next_image.get().is_some() {
@ -194,7 +190,7 @@ impl PanelFadeImages {
() => return None,
};
let max_image_size = wgpu_shared.device.limits().max_texture_dimension_2d;
let max_image_size = wgpu.device.limits().max_texture_dimension_2d;
self.next_image.try_load((NextImageArgs {
playlist_pos,

22
zsw/src/panel/images/image.rs
View File

@ -6,7 +6,7 @@ use {
image::DynamicImage,
std::{path::Path, sync::Arc},
wgpu::util::DeviceExt,
zsw_wgpu::WgpuShared,
zsw_wgpu::Wgpu,
};
/// Panel's fade image
@ -45,9 +45,9 @@ impl PanelFadeImage {
/// Creates a new panel image from an image
#[must_use]
pub fn new(wgpu_shared: &WgpuShared, image_path: Arc<Path>, image: DynamicImage) -> Self {
pub fn new(wgpu: &Wgpu, image_path: Arc<Path>, image: DynamicImage) -> Self {
let size = Vector2::new(image.width(), image.height());
let (texture, texture_view) = self::create_image_texture(wgpu_shared, &image_path, image);
let (texture, texture_view) = self::create_image_texture(wgpu, &image_path, image);
Self::Loaded {
_texture: texture,
@ -59,9 +59,9 @@ impl PanelFadeImage {
}
/// Returns the texture view for this image.
pub fn texture_view<'a>(&'a self, wgpu_shared: &'a WgpuShared) -> &'a wgpu::TextureView {
pub fn texture_view<'a>(&'a self, wgpu: &'a Wgpu) -> &'a wgpu::TextureView {
match self {
Self::Empty => &wgpu_shared.empty_texture_view,
Self::Empty => &wgpu.empty_texture_view,
Self::Loaded { texture_view, .. } => texture_view,
}
}
@ -73,11 +73,7 @@ impl PanelFadeImage {
}
/// Creates the image texture and view
fn create_image_texture(
wgpu_shared: &WgpuShared,
image_path: &Path,
image: DynamicImage,
) -> (wgpu::Texture, wgpu::TextureView) {
fn create_image_texture(wgpu: &Wgpu, image_path: &Path, image: DynamicImage) -> (wgpu::Texture, wgpu::TextureView) {
// Get the image's format, converting if necessary.
let (image, format) = match image {
// With `rgba8` we can simply use the image
@ -93,7 +89,7 @@ fn create_image_texture(
};
// Note: The image loader should ensure the image is the right size.
let limits = wgpu_shared.device.limits();
let limits = wgpu.device.limits();
let max_image_size = limits.max_texture_dimension_2d;
let image_width = image.width();
let image_height = image.height();
@ -117,8 +113,8 @@ fn create_image_texture(
// TODO: Pass some view formats?
view_formats: &[],
};
let texture = wgpu_shared.device.create_texture_with_data(
&wgpu_shared.queue,
let texture = wgpu.device.create_texture_with_data(
&wgpu.queue,
&texture_descriptor,
wgpu::util::TextureDataOrder::LayerMajor,
image.as_bytes(),

86
zsw/src/panel/renderer.rs
View File

@ -21,7 +21,7 @@ use {
wgpu::util::DeviceExt,
winit::{dpi::PhysicalSize, window::Window},
zsw_util::{AppError, Rect},
zsw_wgpu::{FrameRender, WgpuRenderer, WgpuShared},
zsw_wgpu::{FrameRender, WgpuRenderer, Wgpu},
};
/// Panels renderer layouts
@ -37,9 +37,9 @@ pub struct PanelsRendererLayouts {
impl PanelsRendererLayouts {
/// Creates new layouts for the panels renderer
pub fn new(wgpu_shared: &WgpuShared) -> Self {
let uniforms_bind_group_layout = self::create_uniforms_bind_group_layout(wgpu_shared);
let fade_image_bind_group_layout = self::create_fade_image_bind_group_layout(wgpu_shared);
pub fn new(wgpu: &Wgpu) -> Self {
let uniforms_bind_group_layout = self::create_uniforms_bind_group_layout(wgpu);
let fade_image_bind_group_layout = self::create_fade_image_bind_group_layout(wgpu);
Self {
uniforms_bind_group_layout,
@ -81,14 +81,14 @@ pub struct PanelsRenderer {
impl PanelsRenderer {
/// Creates a new renderer for the panels
pub fn new(wgpu_renderer: &WgpuRenderer, wgpu_shared: &WgpuShared, msaa_samples: u32) -> Result<Self, AppError> {
pub fn new(wgpu_renderer: &WgpuRenderer, wgpu: &Wgpu, msaa_samples: u32) -> Result<Self, AppError> {
// Create the index / vertex buffer
let indices = self::create_indices(wgpu_shared);
let vertices = self::create_vertices(wgpu_shared);
let indices = self::create_indices(wgpu);
let vertices = self::create_vertices(wgpu);
// Create the framebuffer
let msaa_framebuffer =
self::create_msaa_framebuffer(wgpu_renderer, wgpu_shared, wgpu_renderer.surface_size(), msaa_samples);
self::create_msaa_framebuffer(wgpu_renderer, wgpu, wgpu_renderer.surface_size(), msaa_samples);
Ok(Self {
render_pipelines: HashMap::new(),
@ -100,9 +100,9 @@ impl PanelsRenderer {
}
/// Resizes the buffer
pub fn resize(&mut self, wgpu_renderer: &WgpuRenderer, wgpu_shared: &WgpuShared, size: PhysicalSize<u32>) {
pub fn resize(&mut self, wgpu_renderer: &WgpuRenderer, wgpu: &Wgpu, size: PhysicalSize<u32>) {
tracing::debug!("Resizing msaa framebuffer to {}x{}", size.width, size.height);
self.msaa_framebuffer = self::create_msaa_framebuffer(wgpu_renderer, wgpu_shared, size, self.msaa_samples);
self.msaa_framebuffer = self::create_msaa_framebuffer(wgpu_renderer, wgpu, size, self.msaa_samples);
}
/// Renders a panel
@ -111,7 +111,7 @@ impl PanelsRenderer {
&mut self,
frame: &mut FrameRender,
wgpu_renderer: &WgpuRenderer,
wgpu_shared: &WgpuShared,
wgpu: &Wgpu,
layouts: &PanelsRendererLayouts,
window_geometry: Rect<i32, u32>,
window: &Window,
@ -168,7 +168,7 @@ impl PanelsRenderer {
// Update the panel before drawing it
match &mut panel.state {
PanelState::None(_) => (),
PanelState::Fade(state) => state.update(wgpu_shared),
PanelState::Fade(state) => state.update(wgpu),
}
// If the panel images are empty, there's no sense in rendering it either
@ -193,7 +193,7 @@ impl PanelsRenderer {
let render_pipeline = self::create_render_pipeline(
wgpu_renderer,
wgpu_shared,
wgpu,
bind_group_layouts,
panel.state.shader(),
self.msaa_samples,
@ -214,14 +214,14 @@ impl PanelsRenderer {
let panel_images = panel_state.images_mut();
let image_sampler = panel_images
.image_sampler
.get_or_insert_with(|| self::create_image_sampler(wgpu_shared));
.get_or_insert_with(|| self::create_image_sampler(wgpu));
let image_bind_group = panel_images.image_bind_group.get_or_insert_with(|| {
self::create_image_bind_group(
wgpu_shared,
wgpu,
&layouts.fade_image_bind_group_layout,
panel_images.prev.texture_view(wgpu_shared),
panel_images.cur.texture_view(wgpu_shared),
panel_images.next.texture_view(wgpu_shared),
panel_images.prev.texture_view(wgpu),
panel_images.cur.texture_view(wgpu),
panel_images.next.texture_view(wgpu),
image_sampler,
)
});
@ -237,7 +237,7 @@ impl PanelsRenderer {
// Write and bind the uniforms
Self::write_bind_uniforms(
wgpu_shared,
wgpu,
layouts,
frame.surface_size,
&panel.state,
@ -257,7 +257,7 @@ impl PanelsRenderer {
/// Writes and binds the uniforms
pub fn write_bind_uniforms(
wgpu_shared: &WgpuShared,
wgpu: &Wgpu,
layouts: &PanelsRendererLayouts,
surface_size: PhysicalSize<u32>,
panel_state: &PanelState,
@ -274,9 +274,9 @@ impl PanelsRenderer {
let geometry_uniforms = geometry
.uniforms
.entry(window.id())
.or_insert_with(|| self::create_panel_geometry_uniforms(wgpu_shared, layouts));
.or_insert_with(|| self::create_panel_geometry_uniforms(wgpu, layouts));
let write_uniforms = |uniforms_bytes| {
wgpu_shared
wgpu
.queue
.write_buffer(&geometry_uniforms.buffer, 0, uniforms_bytes);
};
@ -355,7 +355,7 @@ impl PanelsRenderer {
}
/// Creates the panel geometry uniforms
fn create_panel_geometry_uniforms(wgpu_shared: &WgpuShared, layouts: &PanelsRendererLayouts) -> PanelGeometryUniforms {
fn create_panel_geometry_uniforms(wgpu: &Wgpu, layouts: &PanelsRendererLayouts) -> PanelGeometryUniforms {
// Create the uniforms
let buffer_descriptor = wgpu::BufferDescriptor {
label: Some("[zsw::panel] Geometry uniforms buffer"),
@ -363,7 +363,7 @@ fn create_panel_geometry_uniforms(wgpu_shared: &WgpuShared, layouts: &PanelsRend
size: u64::try_from(MAX_UNIFORM_SIZE).expect("Maximum uniform size didn't fit into a `u64`"),
mapped_at_creation: false,
};
let buffer = wgpu_shared.device.create_buffer(&buffer_descriptor);
let buffer = wgpu.device.create_buffer(&buffer_descriptor);
// Create the uniform bind group
let bind_group_descriptor = wgpu::BindGroupDescriptor {
@ -374,24 +374,24 @@ fn create_panel_geometry_uniforms(wgpu_shared: &WgpuShared, layouts: &PanelsRend
}],
label: Some("[zsw::panel] Geometry uniforms bind group"),
};
let bind_group = wgpu_shared.device.create_bind_group(&bind_group_descriptor);
let bind_group = wgpu.device.create_bind_group(&bind_group_descriptor);
PanelGeometryUniforms { buffer, bind_group }
}
/// Creates the vertices
fn create_vertices(wgpu_shared: &WgpuShared) -> wgpu::Buffer {
fn create_vertices(wgpu: &Wgpu) -> wgpu::Buffer {
let descriptor = wgpu::util::BufferInitDescriptor {
label: Some("[zsw::panel] Vertex buffer"),
contents: bytemuck::cast_slice(&PanelVertex::QUAD),
usage: wgpu::BufferUsages::VERTEX,
};
wgpu_shared.device.create_buffer_init(&descriptor)
wgpu.device.create_buffer_init(&descriptor)
}
/// Creates the indices
fn create_indices(wgpu_shared: &WgpuShared) -> wgpu::Buffer {
fn create_indices(wgpu: &Wgpu) -> wgpu::Buffer {
const INDICES: [u32; 6] = [0, 1, 3, 0, 3, 2];
let descriptor = wgpu::util::BufferInitDescriptor {
label: Some("[zsw::panel] Index buffer"),
@ -399,13 +399,13 @@ fn create_indices(wgpu_shared: &WgpuShared) -> wgpu::Buffer {
usage: wgpu::BufferUsages::INDEX,
};
wgpu_shared.device.create_buffer_init(&descriptor)
wgpu.device.create_buffer_init(&descriptor)
}
/// Creates the render pipeline
fn create_render_pipeline(
wgpu_renderer: &WgpuRenderer,
wgpu_shared: &WgpuShared,
wgpu: &Wgpu,
bind_group_layouts: &[&wgpu::BindGroupLayout],
shader: PanelShader,
msaa_samples: u32,
@ -422,7 +422,7 @@ fn create_render_pipeline(
label: Some(&format!("[zsw::panel] Shader {shader_name:?}")),
source: wgpu::ShaderSource::Naga(Cow::Owned(shader_module)),
};
let shader = wgpu_shared.device.create_shader_module(shader_descriptor);
let shader = wgpu.device.create_shader_module(shader_descriptor);
// Create the pipeline layout
let render_pipeline_layout_descriptor = wgpu::PipelineLayoutDescriptor {
@ -430,7 +430,7 @@ fn create_render_pipeline(
bind_group_layouts,
push_constant_ranges: &[],
};
let render_pipeline_layout = wgpu_shared
let render_pipeline_layout = wgpu
.device
.create_pipeline_layout(&render_pipeline_layout_descriptor);
@ -474,13 +474,13 @@ fn create_render_pipeline(
cache: None,
};
Ok(wgpu_shared.device.create_render_pipeline(&render_pipeline_descriptor))
Ok(wgpu.device.create_render_pipeline(&render_pipeline_descriptor))
}
/// Creates the msaa framebuffer
fn create_msaa_framebuffer(
wgpu_renderer: &WgpuRenderer,
wgpu_shared: &WgpuShared,
wgpu: &Wgpu,
size: PhysicalSize<u32>,
msaa_samples: u32,
) -> wgpu::TextureView {
@ -502,14 +502,14 @@ fn create_msaa_framebuffer(
view_formats: &surface_config.view_formats,
};
wgpu_shared
wgpu
.device
.create_texture(&msaa_frame_descriptor)
.create_view(&wgpu::TextureViewDescriptor::default())
}
/// Creates the uniforms bind group layout
fn create_uniforms_bind_group_layout(wgpu_shared: &WgpuShared) -> wgpu::BindGroupLayout {
fn create_uniforms_bind_group_layout(wgpu: &Wgpu) -> wgpu::BindGroupLayout {
let descriptor = wgpu::BindGroupLayoutDescriptor {
label: Some("[zsw::panel] Geometry uniforms bind group layout"),
entries: &[wgpu::BindGroupLayoutEntry {
@ -524,11 +524,11 @@ fn create_uniforms_bind_group_layout(wgpu_shared: &WgpuShared) -> wgpu::BindGrou
}],
};
wgpu_shared.device.create_bind_group_layout(&descriptor)
wgpu.device.create_bind_group_layout(&descriptor)
}
/// Creates the fade image bind group layout
fn create_fade_image_bind_group_layout(wgpu_shared: &WgpuShared) -> wgpu::BindGroupLayout {
fn create_fade_image_bind_group_layout(wgpu: &Wgpu) -> wgpu::BindGroupLayout {
let descriptor = wgpu::BindGroupLayoutDescriptor {
label: Some("[zsw::panel] Fade image bind group layout"),
entries: &[
@ -571,12 +571,12 @@ fn create_fade_image_bind_group_layout(wgpu_shared: &WgpuShared) -> wgpu::BindGr
],
};
wgpu_shared.device.create_bind_group_layout(&descriptor)
wgpu.device.create_bind_group_layout(&descriptor)
}
/// Creates the texture bind group
fn create_image_bind_group(
wgpu_shared: &WgpuShared,
wgpu: &Wgpu,
bind_group_layout: &wgpu::BindGroupLayout,
view_prev: &wgpu::TextureView,
view_cur: &wgpu::TextureView,
@ -605,11 +605,11 @@ fn create_image_bind_group(
],
label: Some("[zsw::panel] Image bind group"),
};
wgpu_shared.device.create_bind_group(&descriptor)
wgpu.device.create_bind_group(&descriptor)
}
/// Creates the image sampler
fn create_image_sampler(wgpu_shared: &WgpuShared) -> wgpu::Sampler {
fn create_image_sampler(wgpu: &Wgpu) -> wgpu::Sampler {
let descriptor = wgpu::SamplerDescriptor {
label: Some("[zsw::panel] Image sampler"),
address_mode_u: wgpu::AddressMode::ClampToEdge,
@ -620,7 +620,7 @@ fn create_image_sampler(wgpu_shared: &WgpuShared) -> wgpu::Sampler {
mipmap_filter: wgpu::FilterMode::Linear,
..wgpu::SamplerDescriptor::default()
};
wgpu_shared.device.create_sampler(&descriptor)
wgpu.device.create_sampler(&descriptor)
}
/// Shader

18
zsw/src/panel/state.rs
View File

@ -9,7 +9,7 @@ use {
core::time::Duration,
std::{sync::Arc, time::Instant},
zsw_util::{AppError, Loadable, loadable::Loader},
zsw_wgpu::WgpuShared,
zsw_wgpu::Wgpu,
zutil_cloned::cloned,
};
@ -250,12 +250,12 @@ impl PanelFadeState {
/// Skips to the next image.
///
/// If the playlist player isn't loaded, does nothing
pub fn skip(&mut self, wgpu_shared: &WgpuShared) {
pub fn skip(&mut self, wgpu: &Wgpu) {
let Some(Ok(playlist_player)) = self.playlist_player.try_load(()) else {
return;
};
self.progress = match self.images.step_next(playlist_player, wgpu_shared) {
self.progress = match self.images.step_next(playlist_player, wgpu) {
Ok(()) => self.fade_duration,
Err(()) => self.max_progress(),
}
@ -264,7 +264,7 @@ impl PanelFadeState {
/// Steps this panel's state by a certain number of frames (potentially negative).
///
/// If the playlist player isn't loaded, does nothing
pub fn step(&mut self, wgpu_shared: &WgpuShared, delta: TimeDelta) {
pub fn step(&mut self, wgpu: &Wgpu, delta: TimeDelta) {
let Some(Ok(playlist_player)) = self.playlist_player.try_load(()) else {
return;
};
@ -281,7 +281,7 @@ impl PanelFadeState {
Some(next_progress) => match next_progress.checked_sub(self.duration) {
// If we did, `next_progress` is our progress at the next image, so try
// to step to it.
Some(next_progress) => match self.images.step_next(playlist_player, wgpu_shared) {
Some(next_progress) => match self.images.step_next(playlist_player, wgpu) {
// If we successfully stepped to the next image, start at the next progress
// Note: If delta was big enough to overflow 2 durations, then cap it at the
// max duration of the next image.
@ -297,7 +297,7 @@ impl PanelFadeState {
},
// Otherwise, we underflowed, so try to step back
None => match self.images.step_prev(playlist_player, wgpu_shared) {
None => match self.images.step_prev(playlist_player, wgpu) {
// If we successfully stepped backwards, start at where we're supposed to:
Ok(()) => {
// Note: This branch is only taken when `delta` is negative, so we can always
@ -321,14 +321,14 @@ impl PanelFadeState {
/// Updates this panel's state using the current time as a delta
///
/// If the playlist player isn't loaded, does nothing
pub fn update(&mut self, wgpu_shared: &WgpuShared) {
pub fn update(&mut self, wgpu: &Wgpu) {
let Some(Ok(playlist_player)) = self.playlist_player.try_load(()) else {
return;
};
// Note: We always load images, even if we're paused, since the user might be
// moving around manually.
self.images.load_missing(playlist_player, wgpu_shared);
self.images.load_missing(playlist_player, wgpu);
// If we're paused, don't update anything
if self.paused {
@ -342,7 +342,7 @@ impl PanelFadeState {
// the other has updated.
let delta = self.update_delta();
let delta = TimeDelta::from_std(delta).expect("Last update duration didn't fit into a delta");
self.step(wgpu_shared, delta);
self.step(wgpu, delta);
}
}

18
zsw/src/settings_menu.rs
View File

@ -15,7 +15,7 @@ use {
std::{path::Path, sync::Arc},
winit::{dpi::LogicalPosition, event_loop::EventLoopProxy},
zsw_util::{AppError, Rect, TokioTaskBlockOn},
zsw_wgpu::WgpuShared,
zsw_wgpu::Wgpu,
};
/// Settings menu
@ -41,7 +41,7 @@ impl SettingsMenu {
pub fn draw(
&mut self,
ctx: &egui::Context,
wgpu_shared: &WgpuShared,
wgpu: &Wgpu,
panels: &Panels,
playlists: &Arc<Playlists>,
event_loop_proxy: &EventLoopProxy<AppEvent>,
@ -68,7 +68,7 @@ impl SettingsMenu {
ui.separator();
match self.cur_tab {
Tab::Panels => self::draw_panels_tab(ui, wgpu_shared, panels, playlists, window_geometry),
Tab::Panels => self::draw_panels_tab(ui, wgpu, panels, playlists, window_geometry),
Tab::Settings => self::draw_settings(ui, event_loop_proxy),
}
});
@ -77,12 +77,12 @@ impl SettingsMenu {
/// Draws the panels tab
fn draw_panels_tab(
ui: &mut egui::Ui,
wgpu_shared: &WgpuShared,
wgpu: &Wgpu,
panels: &Panels,
playlists: &Arc<Playlists>,
window_geometry: Rect<i32, u32>,
) {
self::draw_panels_editor(ui, wgpu_shared, panels, playlists, window_geometry);
self::draw_panels_editor(ui, wgpu, panels, playlists, window_geometry);
ui.separator();
}
@ -90,7 +90,7 @@ fn draw_panels_tab(
// TODO: Not edit the values as-is, as that breaks some invariants of panels (such as duration versus image states)
fn draw_panels_editor(
ui: &mut egui::Ui,
wgpu_shared: &WgpuShared,
wgpu: &Wgpu,
panels: &Panels,
playlists: &Arc<Playlists>,
window_geometry: Rect<i32, u32>,
@ -119,7 +119,7 @@ fn draw_panels_editor(
match &mut panel.state {
PanelState::None(_) => (),
PanelState::Fade(state) =>
self::draw_fade_panel_editor(ui, wgpu_shared, window_geometry, state, &mut panel.geometries),
self::draw_fade_panel_editor(ui, wgpu, window_geometry, state, &mut panel.geometries),
}
ui.collapsing("Shader", |ui| {
@ -132,7 +132,7 @@ fn draw_panels_editor(
/// Draws the fade panel editor
fn draw_fade_panel_editor(
ui: &mut egui::Ui,
wgpu_shared: &WgpuShared,
wgpu: &Wgpu,
window_geometry: Rect<i32, u32>,
panel_state: &mut PanelFadeState,
geometries: &mut [PanelGeometry],
@ -190,7 +190,7 @@ fn draw_fade_panel_editor(
ui.horizontal(|ui| {
ui.label("Skip");
if ui.button("🔄").clicked() {
panel_state.skip(wgpu_shared);
panel_state.skip(wgpu);
}
});

4
zsw/src/shared.rs
View File

@ -11,7 +11,7 @@ use {
crossbeam::atomic::AtomicCell,
std::sync::Arc,
winit::dpi::PhysicalPosition,
zsw_wgpu::WgpuShared,
zsw_wgpu::Wgpu,
};
/// Shared data
@ -22,7 +22,7 @@ pub struct Shared {
pub last_resize: AtomicCell<Option<Resize>>,
pub cursor_pos: AtomicCell<PhysicalPosition<f64>>,
pub wgpu: &'static WgpuShared,
pub wgpu: &'static Wgpu,
pub panels_renderer_layouts: PanelsRendererLayouts,
pub panels: Panels,