Crate smaa

Post-process antialiasing for wgpu-rs, using the SMAA reference implementation.

Example

// Initialize wgpu
let event_loop = EventLoop::new().unwrap();
let window = winit::window::Window::new(&event_loop).unwrap();
let window_size = window.inner_size();
let window_arc = Arc::new(window);
let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::default());
let surface = instance.create_surface(window_arc.clone()).unwrap();
let adapter = instance.request_adapter(&Default::default()).await.unwrap();
let (device, queue) = adapter.request_device(&Default::default(), None).await?;
let swapchain_format = surface.get_capabilities(&adapter).formats[0];
let mut config = wgpu::SurfaceConfiguration {
    usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
    format: swapchain_format,
    width: window_size.width,
    height: window_size.height,
    present_mode: wgpu::PresentMode::AutoVsync,
    alpha_mode: wgpu::CompositeAlphaMode::Opaque,
    view_formats: vec![],
    desired_maximum_frame_latency: 2,
};
surface.configure(&device, &config);

// Create SMAA target
let mut smaa_target = SmaaTarget::new(
    &device,
    &queue,
    window_size.width,
    window_size.height,
    swapchain_format,
    SmaaMode::Smaa1X,
);

// Main loop
event_loop.run(move |event, event_loop| {
    if let Event::WindowEvent { event, .. } = event {
        match event {
            WindowEvent::RedrawRequested => {
                let output_frame = surface.get_current_texture().unwrap();
                let output_view = output_frame.texture.create_view(&Default::default());
                let smaa_frame = smaa_target.start_frame(&device, &queue, &output_view);
 
                // Render the scene into `*smaa_frame`.
                // [...]
 
                smaa_frame.resolve();
                output_frame.present();
            }
            _ => {}
        }
    }
})

Structs

• SmaaFrame
  Frame that the scene should be rendered into; can be created by a SmaaTarget.
• SmaaTarget
  Wraps a color buffer, which it can resolve into an antialiased image using the Subpixel Morphological Antialiasing (SMAA) algorithm.

Enums

• SmaaMode
  Anti-aliasing mode. Higher values produce nicer results but run slower.