1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
//! Flexible and reusable post-processing effects for [`wgpu`](https://wgpu.rs/).
//!
//! This library will provide a collection of post-processing effects that you can easily integrate into your rendering pipeline.
//!
//! ## Effects
//!
//! * A simple [grayscale] effect.
//!
//! ## Usage
//! For example the _grayscale_ effect can be used in principle like so:
//! ```rust
//! # use winit::event::{Event, WindowEvent};
//! # use winit::event_loop::EventLoop;
//! # use winit::window::Window;
//! #
//! use crate::wpp::{Effect, Frame};
//! #
//! # fn main() { pollster::block_on(run()); }
//! # async fn run() -> Result<(), Box<dyn std::error::Error>> {
//!
//! // Initialize winit and wgpu
//! let event_loop = EventLoop::new();
//! let window = winit::window::Window::new(&event_loop).unwrap();
//! let instance = wgpu::Instance::new(wgpu::Backends::PRIMARY);
//! let surface = unsafe { instance.create_surface(&window) };
//! let adapter = instance.request_adapter(&Default::default()).await.unwrap();
//! let (device, queue) = adapter.request_device(&Default::default(), None).await.unwrap();
//! let swapchain_format = surface.get_supported_formats(&adapter)[0];
//! let mut config = wgpu::SurfaceConfiguration {
//! usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
//! format: swapchain_format,
//! width: window.inner_size().width,
//! height: window.inner_size().height,
//! present_mode: wgpu::PresentMode::Fifo,
//! alpha_mode: wgpu::CompositeAlphaMode::Opaque,
//! };
//! surface.configure(&device, &config);
//!
//! let extent = wgpu::Extent3d {
//! width: window.inner_size().width,
//! height: window.inner_size().height,
//! ..Default::default()
//! };
//!
//! // Create the post-processing effect.
//! let mut handler = wpp::grayscale::GrayscaleEffect::new(&device, &extent, swapchain_format);
//!
//! // The event / render loop.
//! event_loop.run(move |event, _, control_flow| {
//! match event {
//! Event::WindowEvent {
//! event: WindowEvent::Resized(size),
//! ..
//! } => {
//! let extent = wgpu::Extent3d {
//! width: size.width,
//! height: size.height,
//! ..Default::default()
//! };
//!
//! // Resize the post-processing effect accordingly.
//! handler.resize(&device, &extent);
//!
//! window.request_redraw();
//! }
//! Event::RedrawRequested(_) => {
//! let frame = surface
//! .get_current_texture()
//! .unwrap();
//! let view = frame
//! .texture
//! .create_view(&wgpu::TextureViewDescriptor::default());
//!
//! // Create a new frame for post-processing.
//! let process_frame = handler.start_frame(&device, &queue, &view);
//!
//! // Render into the `process_frame`.
//! // [...]
//!
//! // Resolve the post-processing on the frame after rendering.
//! process_frame.resolve();
//!
//! // Finally present the post-processed frame.
//! frame.present();
//!
//! # *control_flow = winit::event_loop::ControlFlow::Exit;
//! }
//! _ => {}
//! }
//! });
//! #
//! # }
//! ```
pub use Effect;
pub use Frame;
/// Transforms colorized frames into a simple grayscale version.