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

easy_gpu/
renderer.rs
