easy_gpu/
renderer.rs

1use std::sync::Arc;
2use image::GenericImageView;
3use wgpu::{BufferUsages, Color, Device, Extent3d, Queue, ShaderModule, StoreOp, Surface, SurfaceConfiguration, TextureDimension};
4use winit::dpi::PhysicalSize;
5use winit::window::Window;
6use crate::{frame::Frame};
7use crate::assets::buffer::Buffer;
8use crate::assets::render::mesh::Mesh;
9use crate::assets::Texture;
10use crate::assets::vertex_layout::GpuVertex;
11use crate::assets_manager::asset_manager::AssetManager;
12use crate::assets_manager::handle::Handle;
13use crate::wgpu::TextureFormat;
14
15pub struct Renderer {
16    pub(crate) device: Device,
17    queue: Queue,
18    surface: Surface<'static>,
19    pub(crate)surface_config: SurfaceConfiguration,
20
21    pub asset_manager: AssetManager,
22
23    pub(crate)depth_texture: Option<wgpu::Texture>,
24    depth_view: Option<wgpu::TextureView>,
25
26    frame: Frame,
27
28    clear_colour: Color,
29}
30
31impl Renderer {
32    pub async fn new(window: Arc<Window>) -> Self {
33        let instance = wgpu::Instance::default();
34
35        let surface = instance.create_surface(window.clone()).unwrap();
36
37        let adapter = instance.request_adapter(
38            &wgpu::RequestAdapterOptions {
39                compatible_surface: Some(&surface),
40                ..Default::default()
41            },
42        ).await.unwrap();
43
44        let (device, queue) = adapter.request_device(
45            &wgpu::DeviceDescriptor::default(),
46        ).await.unwrap();
47
48        let caps = surface.get_capabilities(&adapter);
49
50        let surface_config = SurfaceConfiguration {
51            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
52            format: caps.formats[0],
53            width: window.inner_size().width,
54            height: window.inner_size().height,
55            present_mode: caps.present_modes[0],
56            alpha_mode: caps.alpha_modes[0],
57            view_formats: vec![],
58            desired_maximum_frame_latency: 2,
59        };
60
61        surface.configure(&device, &surface_config);
62
63        let asset_manager = AssetManager::new();
64
65        let frame = Frame::new();
66
67        Self {
68            device,
69            queue,
70            surface,
71            surface_config,
72            asset_manager,
73            depth_texture: None,
74            depth_view: None,
75            frame,
76            clear_colour: wgpu::Color::BLACK,
77        }
78    }
79
80    pub fn clear_colour(mut self,r: f64,g: f64,b: f64,a: f64) -> Self{
81        self.clear_colour = Color{
82            r,
83            g,
84            b,
85            a,
86        };
87        self
88    }
89
90    pub fn render(&mut self) {
91        let output = match self.surface.get_current_texture() {
92            wgpu::CurrentSurfaceTexture::Success(frame) => frame,
93            wgpu::CurrentSurfaceTexture::Suboptimal(frame) => {
94                // still usable, but should reconfigure soon
95                frame
96            }
97            wgpu::CurrentSurfaceTexture::Timeout => {
98                return; // skip frame
99            }
100            wgpu::CurrentSurfaceTexture::Occluded => {
101                return; // window hidden
102            }
103            wgpu::CurrentSurfaceTexture::Outdated => {
104                // reconfigure surface
105                self.surface.configure(&self.device, &self.surface_config);
106                return;
107            }
108            wgpu::CurrentSurfaceTexture::Lost => {
109                // recreate surface ideally, but reconfigure for now
110                self.surface.configure(&self.device, &self.surface_config);
111                return;
112            }
113            wgpu::CurrentSurfaceTexture::Validation => {
114                return;
115            }
116        };
117
118        let view = output
119            .texture
120            .create_view(&wgpu::TextureViewDescriptor::default());
121
122        let mut encoder = self.device.create_command_encoder(
123            &wgpu::CommandEncoderDescriptor {
124                label: Some("Render Encoder"),
125            },
126        );
127
128        for texture in self.frame.textures_to_clear.drain(..){
129            let view = &self.asset_manager.textures.get(texture).unwrap().view;
130
131            let _rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
132                label: Some("Clear Texture Pass"),
133                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
134                    view,
135                    depth_slice: None,
136                    resolve_target: None,
137                    ops: wgpu::Operations {
138                        load: wgpu::LoadOp::Clear(wgpu::Color {
139                            r: 0.0,
140                            g: 0.0,
141                            b: 0.0,
142                            a: 1.0,
143                        }),
144                        store: Default::default(),
145                    },
146                })],
147                depth_stencil_attachment: None,
148                timestamp_writes: None,
149                occlusion_query_set: None,
150                multiview_mask: None,
151            });
152        }
153
154        for compute_task in &self.frame.compute_tasks{
155            compute_task.execute(&mut encoder, &self.asset_manager)
156        }
157
158        {
159            let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
160                label: Some("Render Pass"),
161
162                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
163                    view: &view,
164                    depth_slice: None,
165                    resolve_target: None,
166                    ops: wgpu::Operations {
167                        load: wgpu::LoadOp::Clear(self.clear_colour),
168                        store: StoreOp::Store,
169                    },
170                })],
171                depth_stencil_attachment: self.depth_view.as_ref().map(|view| wgpu::RenderPassDepthStencilAttachment {
172                    view,
173                    depth_ops: Some(wgpu::Operations {
174                        load: wgpu::LoadOp::Clear(1.0),
175                        store: StoreOp::Store,
176                    }),
177                    stencil_ops: None,
178                }) ,
179                occlusion_query_set: None,
180                timestamp_writes: None,
181                multiview_mask: None,
182            });
183
184            let mut current_material = None;
185            let mut current_mesh = None;
186
187            for item in &self.frame.render_tasks {
188                if Some(item.material) != current_material{
189                    current_material = Some(item.material);
190                    let material = self.asset_manager.materials.get(item.material).unwrap();
191                    let pipeline = self.asset_manager.render_pipelines.get(material.pipeline).unwrap();
192
193                    render_pass.set_pipeline(&pipeline.pipeline);
194                    render_pass.set_bind_group(0, &material.bind_group, &[]);
195                }
196
197                let mesh = self.asset_manager.meshes.get(item.mesh).unwrap();
198                if Some(item.mesh) != current_mesh{
199                    current_mesh = Some(item.mesh);
200                    render_pass.set_vertex_buffer(0, mesh.vertex_buffer.slice(..));
201                    render_pass.set_index_buffer(mesh.index_buffer.slice(..), wgpu::IndexFormat::Uint16);
202                }
203
204                if let Some(instances) = item.instances{
205                    let instances = self.asset_manager.buffers.get(instances).unwrap();
206                    render_pass.set_vertex_buffer(1, instances.buffer.slice(..));
207                    render_pass.draw_indexed(0..mesh.index_count, 0,item.range.clone().unwrap());
208                }
209                else{
210                    render_pass.draw_indexed(0..mesh.index_count, 0,0..1);
211                }
212
213
214            }
215        }
216
217        self.queue.submit(Some(encoder.finish()));
218
219        output.present();
220    }
221
222    pub fn resize_surface(&mut self, size: PhysicalSize<u32>) {
223        self.surface_config.width = size.width;
224        self.surface_config.height = size.height;
225        self.surface.configure(&self.device, &self.surface_config);
226        self.create_depth_texture(size.width, size.height);
227    }
228    
229    pub fn window_aspect(&self) -> f32 {
230        self.surface_config.width as f32 / self.surface_config.height as f32
231    }
232
233    pub fn width(&self) -> u32{
234        self.surface_config.width
235    }
236    pub fn height(&self) -> u32{
237        self.surface_config.height
238    }
239
240    pub fn begin_frame(&mut self) -> &mut Frame {
241        self.frame.clear();
242        &mut self.frame
243    }
244
245    pub fn current_frame(&mut self) -> &mut Frame {
246        &mut self.frame
247    }
248
249    pub fn create_mesh<T: GpuVertex>(&mut self, vertices: &[T],indices: &[u16]) -> Handle<Mesh>{
250        let mesh = Mesh::new(&self.device,vertices,indices);
251        self.asset_manager.meshes.insert(mesh)
252    }
253
254    pub(crate) fn create_depth_texture(&mut self, width: u32, height: u32){
255        let texture = self.device.create_texture(&wgpu::TextureDescriptor {
256            size: wgpu::Extent3d {
257                width,
258                height,
259                depth_or_array_layers: 1,
260            },
261            mip_level_count: 1,
262            sample_count: 1,
263            dimension: wgpu::TextureDimension::D2,
264            format: wgpu::TextureFormat::Depth24Plus,
265            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
266            label: Some("depth_texture"),
267            view_formats: &[],
268        });
269
270        let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
271
272        self.depth_view = Some(view);
273        self.depth_texture = Some(texture);
274    }
275
276    pub fn create_buffer(&mut self,buffer_usages: BufferUsages,size:u64) -> Handle<Buffer> {
277        let buffer = Buffer::new(&self.device,size,buffer_usages);
278        self.asset_manager.buffers.insert(buffer)
279    }
280
281    pub fn create_buffer_with_contents(&mut self,buffer_usages: BufferUsages,contents:&[u8]) -> Handle<Buffer> {
282        let buffer = Buffer::from_contents(&self.device,contents,buffer_usages);
283        self.asset_manager.buffers.insert(buffer)
284    }
285
286    pub fn load_shader(&mut self,src: &'static str) -> Handle<ShaderModule>{
287        let shader = self.device.create_shader_module(wgpu::ShaderModuleDescriptor {
288            label: Some("Shader"),
289            source: wgpu::ShaderSource::Wgsl(src.into()),
290        });
291        self.asset_manager.shaders.insert(shader)
292    }
293
294    pub fn write_buffer<T: bytemuck::Pod>(&self,handle: Handle<Buffer>,data: T){
295        let uniform = self.asset_manager.buffers.get(handle).unwrap();
296        self.queue.write_buffer(&uniform.buffer, 0, bytemuck::cast_slice(&[data]));
297    }
298    pub fn load_texture_from_file(&mut self,texture_bytes: Vec<u8>) -> Handle<Texture> {
299        let image = image::load_from_memory(texture_bytes.as_slice()).unwrap();
300        let rgba = image.to_rgba8();
301
302        let dims = image.dimensions();
303
304        let texture_size = wgpu::Extent3d{
305            width: dims.0,
306            height: dims.1,
307            depth_or_array_layers: 1,
308        };
309
310        let texture = self.device.create_texture(&wgpu::TextureDescriptor{
311            label: None,
312            size: texture_size,
313            mip_level_count: 1,
314            sample_count: 1,
315            dimension: TextureDimension::D2,
316            format: TextureFormat::Rgba8UnormSrgb,
317            usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
318            view_formats: &[],
319        });
320
321        self.queue.write_texture(
322            wgpu::TexelCopyTextureInfo{
323                texture: &texture,
324                mip_level: 0,
325                origin: wgpu::Origin3d::ZERO,
326                aspect: wgpu::TextureAspect::All,
327            },
328            &rgba,
329            wgpu::TexelCopyBufferLayout{
330                offset: 0,
331                bytes_per_row: Some(4 * dims.0),
332                rows_per_image: Some(dims.1),
333            },
334            texture_size
335        );
336
337        let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
338
339        self.asset_manager.textures.insert(Texture::new(texture,view))
340    }
341
342    pub fn write_texture(&self,texture: Handle<Texture>,bytes: &[u8],byte_per_pixel: u32, texture_size: Extent3d){
343        let texture = &self.asset_manager.textures.get(texture).unwrap().texture;
344
345        self.queue.write_texture(
346            wgpu::TexelCopyTextureInfo{
347                texture,
348                mip_level: 0,
349                origin: wgpu::Origin3d::ZERO,
350                aspect: wgpu::TextureAspect::All,
351            },
352            bytes,
353            wgpu::TexelCopyBufferLayout{
354                offset: 0,
355                bytes_per_row: Some(byte_per_pixel * texture_size.width),
356                rows_per_image: Some(texture_size.height),
357            },
358            texture_size
359        );
360    }
361}
362
easy_gpu/renderer.rs

easy_gpu/
renderer.rs
