mirror of
https://github.com/storytold/wgpu.git
synced 2026-11-19 14:01:08 +01:00
* Expose gpu allocation configuration options This commit adds hints to control memory allocations strategies to the configuration options. These hints allow for automatic profiles such as optimizing for performance (the default, makes sense for a game), optimizing for memory usage (typically more useful for a web browser or UI library) and specifying settings manually. The details of gpu allocation are still in flux. The goal is to switch vulkan and metal to gpu_allocator which is currently used with d3d12. gpu_allocator will also likely receive more configuration options, in particular the ability to start with smaller memory block sizes and progressively grow the block size. So the manual settings already provision for this upcoming option. Another approach could be to wait and add the manual option after the dust settles. The reason for providing presets and defining values in the backends is that I am convinced that optimal fonigurations should take hardware capabilities into consideration. It's a deep rabbithole, though, so that will be an exercise for later. * changelog * Update CHANGELOG.md Co-authored-by: Andreas Reich <r_andreas2@web.de> * Add a comment about not entirely knowing what we are doing --------- Co-authored-by: Andreas Reich <r_andreas2@web.de>
204 lines
7.7 KiB
Rust
204 lines
7.7 KiB
Rust
#![cfg_attr(target_arch = "wasm32", allow(dead_code))]
|
|
|
|
use std::{collections::HashMap, sync::Arc};
|
|
use winit::{
|
|
event::{Event, WindowEvent},
|
|
event_loop::EventLoop,
|
|
window::{Window, WindowId},
|
|
};
|
|
|
|
struct ViewportDesc {
|
|
window: Arc<Window>,
|
|
background: wgpu::Color,
|
|
surface: wgpu::Surface<'static>,
|
|
}
|
|
|
|
struct Viewport {
|
|
desc: ViewportDesc,
|
|
config: wgpu::SurfaceConfiguration,
|
|
}
|
|
|
|
impl ViewportDesc {
|
|
fn new(window: Arc<Window>, background: wgpu::Color, instance: &wgpu::Instance) -> Self {
|
|
let surface = instance.create_surface(window.clone()).unwrap();
|
|
Self {
|
|
window,
|
|
background,
|
|
surface,
|
|
}
|
|
}
|
|
|
|
fn build(self, adapter: &wgpu::Adapter, device: &wgpu::Device) -> Viewport {
|
|
let size = self.window.inner_size();
|
|
let config = self
|
|
.surface
|
|
.get_default_config(adapter, size.width, size.height)
|
|
.unwrap();
|
|
self.surface.configure(device, &config);
|
|
Viewport { desc: self, config }
|
|
}
|
|
}
|
|
|
|
impl Viewport {
|
|
fn resize(&mut self, device: &wgpu::Device, size: winit::dpi::PhysicalSize<u32>) {
|
|
self.config.width = size.width;
|
|
self.config.height = size.height;
|
|
self.desc.surface.configure(device, &self.config);
|
|
}
|
|
fn get_current_texture(&mut self) -> wgpu::SurfaceTexture {
|
|
self.desc
|
|
.surface
|
|
.get_current_texture()
|
|
.expect("Failed to acquire next swap chain texture")
|
|
}
|
|
}
|
|
|
|
async fn run(event_loop: EventLoop<()>, viewports: Vec<(Arc<Window>, wgpu::Color)>) {
|
|
let instance = wgpu::Instance::default();
|
|
let viewports: Vec<_> = viewports
|
|
.into_iter()
|
|
.map(|(window, color)| ViewportDesc::new(window, color, &instance))
|
|
.collect();
|
|
let adapter = instance
|
|
.request_adapter(&wgpu::RequestAdapterOptions {
|
|
// Request an adapter which can render to our surface
|
|
compatible_surface: viewports.first().map(|desc| &desc.surface),
|
|
..Default::default()
|
|
})
|
|
.await
|
|
.expect("Failed to find an appropriate adapter");
|
|
|
|
// Create the logical device and command queue
|
|
let (device, queue) = adapter
|
|
.request_device(
|
|
&wgpu::DeviceDescriptor {
|
|
label: None,
|
|
required_features: wgpu::Features::empty(),
|
|
required_limits: wgpu::Limits::downlevel_defaults(),
|
|
memory_hints: wgpu::MemoryHints::MemoryUsage,
|
|
},
|
|
None,
|
|
)
|
|
.await
|
|
.expect("Failed to create device");
|
|
|
|
let mut viewports: HashMap<WindowId, Viewport> = viewports
|
|
.into_iter()
|
|
.map(|desc| (desc.window.id(), desc.build(&adapter, &device)))
|
|
.collect();
|
|
|
|
event_loop
|
|
.run(move |event, target| {
|
|
// Have the closure take ownership of the resources.
|
|
// `event_loop.run` never returns, therefore we must do this to ensure
|
|
// the resources are properly cleaned up.
|
|
let _ = (&instance, &adapter);
|
|
|
|
if let Event::WindowEvent { window_id, event } = event {
|
|
match event {
|
|
WindowEvent::Resized(new_size) => {
|
|
// Recreate the swap chain with the new size
|
|
if let Some(viewport) = viewports.get_mut(&window_id) {
|
|
viewport.resize(&device, new_size);
|
|
// On macos the window needs to be redrawn manually after resizing
|
|
viewport.desc.window.request_redraw();
|
|
}
|
|
}
|
|
WindowEvent::RedrawRequested => {
|
|
if let Some(viewport) = viewports.get_mut(&window_id) {
|
|
let frame = viewport.get_current_texture();
|
|
let view = frame
|
|
.texture
|
|
.create_view(&wgpu::TextureViewDescriptor::default());
|
|
let mut encoder =
|
|
device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
|
|
label: None,
|
|
});
|
|
{
|
|
let _rpass =
|
|
encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
|
|
label: None,
|
|
color_attachments: &[Some(
|
|
wgpu::RenderPassColorAttachment {
|
|
view: &view,
|
|
resolve_target: None,
|
|
ops: wgpu::Operations {
|
|
load: wgpu::LoadOp::Clear(
|
|
viewport.desc.background,
|
|
),
|
|
store: wgpu::StoreOp::Store,
|
|
},
|
|
},
|
|
)],
|
|
depth_stencil_attachment: None,
|
|
timestamp_writes: None,
|
|
occlusion_query_set: None,
|
|
});
|
|
}
|
|
|
|
queue.submit(Some(encoder.finish()));
|
|
frame.present();
|
|
}
|
|
}
|
|
WindowEvent::CloseRequested => {
|
|
viewports.remove(&window_id);
|
|
if viewports.is_empty() {
|
|
target.exit();
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
})
|
|
.unwrap();
|
|
}
|
|
|
|
pub fn main() {
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
{
|
|
const WINDOW_SIZE: u32 = 128;
|
|
const WINDOW_PADDING: u32 = 16;
|
|
const WINDOW_TITLEBAR: u32 = 32;
|
|
const WINDOW_OFFSET: u32 = WINDOW_SIZE + WINDOW_PADDING;
|
|
const ROWS: u32 = 4;
|
|
const COLUMNS: u32 = 4;
|
|
|
|
let event_loop = EventLoop::new().unwrap();
|
|
let mut viewports = Vec::with_capacity((ROWS * COLUMNS) as usize);
|
|
for row in 0..ROWS {
|
|
for column in 0..COLUMNS {
|
|
let window = winit::window::WindowBuilder::new()
|
|
.with_title(format!("x{column}y{row}"))
|
|
.with_inner_size(winit::dpi::PhysicalSize::new(WINDOW_SIZE, WINDOW_SIZE))
|
|
.build(&event_loop)
|
|
.unwrap();
|
|
let window = Arc::new(window);
|
|
window.set_outer_position(winit::dpi::PhysicalPosition::new(
|
|
WINDOW_PADDING + column * WINDOW_OFFSET,
|
|
WINDOW_PADDING + row * (WINDOW_OFFSET + WINDOW_TITLEBAR),
|
|
));
|
|
fn frac(index: u32, max: u32) -> f64 {
|
|
index as f64 / max as f64
|
|
}
|
|
viewports.push((
|
|
window,
|
|
wgpu::Color {
|
|
r: frac(row, ROWS),
|
|
g: 0.5 - frac(row * column, ROWS * COLUMNS) * 0.5,
|
|
b: frac(column, COLUMNS),
|
|
a: 1.0,
|
|
},
|
|
))
|
|
}
|
|
}
|
|
|
|
env_logger::init();
|
|
pollster::block_on(run(event_loop, viewports));
|
|
}
|
|
#[cfg(target_arch = "wasm32")]
|
|
{
|
|
std::panic::set_hook(Box::new(console_error_panic_hook::hook));
|
|
panic!("wasm32 is not supported")
|
|
}
|
|
}
|