use std::sync::Arc;
use grana_gpu::REQUIRED_FEATURES;
use winit::dpi::PhysicalSize;
use winit::window::Window;
pub struct Gpu {
pub surface: wgpu::Surface<'static>,
pub device: wgpu::Device,
pub queue: wgpu::Queue,
pub config: wgpu::SurfaceConfiguration,
pub adapter_description: String,
}
impl Gpu {
pub fn new(window: Arc<Window>) -> Self {
let size = window.inner_size();
let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle());
let surface = instance
.create_surface(window)
.expect("failed to create a window surface");
let options = |fallback: bool| wgpu::RequestAdapterOptions {
power_preference: wgpu::PowerPreference::HighPerformance,
force_fallback_adapter: fallback,
compatible_surface: Some(&surface),
apply_limit_buckets: false,
};
let adapter = pollster::block_on(instance.request_adapter(&options(false)))
.or_else(|_| pollster::block_on(instance.request_adapter(&options(true))))
.expect("no graphics adapter can present to this window");
assert!(
adapter.features().contains(REQUIRED_FEATURES),
"the graphics adapter cannot stream packed volume bricks"
);
let info = adapter.get_info();
let adapter_description = format!("{} ยท {:?}", info.name, info.backend);
println!("grana: using {adapter_description}");
let (device, queue) = pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor {
label: Some("grana"),
required_features: REQUIRED_FEATURES,
required_limits: adapter.limits(),
experimental_features: wgpu::ExperimentalFeatures::disabled(),
memory_hints: wgpu::MemoryHints::Performance,
trace: wgpu::Trace::Off,
}))
.expect("failed to create a graphics device");
let capabilities = surface.get_capabilities(&adapter);
let format = capabilities
.formats
.iter()
.copied()
.find(|format| !format.is_srgb())
.unwrap_or(capabilities.formats[0]);
let config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format,
color_space: wgpu::SurfaceColorSpace::Auto,
width: size.width.max(1),
height: size.height.max(1),
present_mode: wgpu::PresentMode::Fifo,
desired_maximum_frame_latency: 2,
alpha_mode: capabilities.alpha_modes[0],
view_formats: vec![],
};
surface.configure(&device, &config);
Self {
surface,
device,
queue,
config,
adapter_description,
}
}
pub fn format(&self) -> wgpu::TextureFormat {
self.config.format
}
pub fn size(&self) -> [u32; 2] {
[self.config.width, self.config.height]
}
pub fn resize(&mut self, size: PhysicalSize<u32>) {
if size.width == 0 || size.height == 0 {
return;
}
self.config.width = size.width;
self.config.height = size.height;
self.surface.configure(&self.device, &self.config);
}
pub fn acquire(&mut self) -> Option<wgpu::SurfaceTexture> {
match self.surface.get_current_texture() {
wgpu::CurrentSurfaceTexture::Success(frame) => Some(frame),
wgpu::CurrentSurfaceTexture::Suboptimal(frame) => Some(frame),
wgpu::CurrentSurfaceTexture::Outdated | wgpu::CurrentSurfaceTexture::Lost => {
self.surface.configure(&self.device, &self.config);
None
}
wgpu::CurrentSurfaceTexture::Timeout
| wgpu::CurrentSurfaceTexture::Occluded
| wgpu::CurrentSurfaceTexture::Validation => None,
}
}
}