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 frame
96 }
97 wgpu::CurrentSurfaceTexture::Timeout => {
98 return; }
100 wgpu::CurrentSurfaceTexture::Occluded => {
101 return; }
103 wgpu::CurrentSurfaceTexture::Outdated => {
104 self.surface.configure(&self.device, &self.surface_config);
106 return;
107 }
108 wgpu::CurrentSurfaceTexture::Lost => {
109 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 for item in &self.frame.render_tasks {
185 let material = self.asset_manager.materials.get(item.material).unwrap();
186 let pipeline = self.asset_manager.render_pipelines.get(material.pipeline).unwrap();
187 let mesh = self.asset_manager.meshes.get(item.mesh).unwrap();
188
189 render_pass.set_pipeline(&pipeline.pipeline);
190 render_pass.set_bind_group(0, &material.bind_group, &[]);
191 render_pass.set_vertex_buffer(0, mesh.vertex_buffer.slice(..));
192 render_pass.set_index_buffer(mesh.index_buffer.slice(..), wgpu::IndexFormat::Uint16);
193
194 if let Some(instances) = item.instances{
195 let instances = self.asset_manager.buffers.get(instances).unwrap();
196 render_pass.set_vertex_buffer(1, instances.buffer.slice(..));
197 render_pass.draw_indexed(0..mesh.index_count, 0,item.range.clone().unwrap());
198 }
199 else{
200 render_pass.draw_indexed(0..mesh.index_count, 0,0..1);
201 }
202
203
204 }
205 }
206
207 self.queue.submit(Some(encoder.finish()));
208
209 output.present();
210 }
211
212 pub fn resize_surface(&mut self, size: PhysicalSize<u32>) {
213 self.surface_config.width = size.width;
214 self.surface_config.height = size.height;
215 self.surface.configure(&self.device, &self.surface_config);
216 self.create_depth_texture(size.width, size.height);
217 }
218
219 pub fn window_aspect(&self) -> f32 {
220 self.surface_config.width as f32 / self.surface_config.height as f32
221 }
222
223 pub fn width(&self) -> u32{
224 self.surface_config.width
225 }
226 pub fn height(&self) -> u32{
227 self.surface_config.height
228 }
229
230 pub fn begin_frame(&mut self) -> &mut Frame {
231 self.frame.clear();
232 &mut self.frame
233 }
234
235 pub fn current_frame(&mut self) -> &mut Frame {
236 &mut self.frame
237 }
238
239 pub fn create_mesh<T: GpuVertex>(&mut self, vertices: &[T],indices: &[u16]) -> Handle<Mesh>{
240 let mesh = Mesh::new(&self.device,vertices,indices);
241 self.asset_manager.meshes.insert(mesh)
242 }
243
244 pub(crate) fn create_depth_texture(&mut self, width: u32, height: u32){
245 let texture = self.device.create_texture(&wgpu::TextureDescriptor {
246 size: wgpu::Extent3d {
247 width,
248 height,
249 depth_or_array_layers: 1,
250 },
251 mip_level_count: 1,
252 sample_count: 1,
253 dimension: wgpu::TextureDimension::D2,
254 format: wgpu::TextureFormat::Depth24Plus,
255 usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
256 label: Some("depth_texture"),
257 view_formats: &[],
258 });
259
260 let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
261
262 self.depth_view = Some(view);
263 self.depth_texture = Some(texture);
264 }
265
266 pub fn create_buffer(&mut self,buffer_usages: BufferUsages,size:u64) -> Handle<Buffer> {
267 let buffer = Buffer::new(&self.device,size,buffer_usages);
268 self.asset_manager.buffers.insert(buffer)
269 }
270
271 pub fn create_buffer_with_contents(&mut self,buffer_usages: BufferUsages,contents:&[u8]) -> Handle<Buffer> {
272 let buffer = Buffer::from_contents(&self.device,contents,buffer_usages);
273 self.asset_manager.buffers.insert(buffer)
274 }
275
276 pub fn load_shader(&mut self,src: &'static str) -> Handle<ShaderModule>{
277 let shader = self.device.create_shader_module(wgpu::ShaderModuleDescriptor {
278 label: Some("Shader"),
279 source: wgpu::ShaderSource::Wgsl(src.into()),
280 });
281 self.asset_manager.shaders.insert(shader)
282 }
283
284 pub fn write_buffer<T: bytemuck::Pod>(&self,handle: Handle<Buffer>,data: T){
285 let uniform = self.asset_manager.buffers.get(handle).unwrap();
286 self.queue.write_buffer(&uniform.buffer, 0, bytemuck::cast_slice(&[data]));
287 }
288 pub fn load_texture_from_file(&mut self,texture_bytes: Vec<u8>) -> Handle<Texture> {
289 let image = image::load_from_memory(texture_bytes.as_slice()).unwrap();
290 let rgba = image.to_rgba8();
291
292 let dims = image.dimensions();
293
294 let texture_size = wgpu::Extent3d{
295 width: dims.0,
296 height: dims.1,
297 depth_or_array_layers: 1,
298 };
299
300 let texture = self.device.create_texture(&wgpu::TextureDescriptor{
301 label: None,
302 size: texture_size,
303 mip_level_count: 1,
304 sample_count: 1,
305 dimension: TextureDimension::D2,
306 format: TextureFormat::Rgba8UnormSrgb,
307 usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
308 view_formats: &[],
309 });
310
311 self.queue.write_texture(
312 wgpu::TexelCopyTextureInfo{
313 texture: &texture,
314 mip_level: 0,
315 origin: wgpu::Origin3d::ZERO,
316 aspect: wgpu::TextureAspect::All,
317 },
318 &rgba,
319 wgpu::TexelCopyBufferLayout{
320 offset: 0,
321 bytes_per_row: Some(4 * dims.0),
322 rows_per_image: Some(dims.1),
323 },
324 texture_size
325 );
326
327 let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
328
329 self.asset_manager.textures.insert(Texture::new(texture,view))
330 }
331
332 pub fn write_texture(&self,texture: Handle<Texture>,bytes: &[u8],byte_per_pixel: u32, texture_size: Extent3d){
333 let texture = &self.asset_manager.textures.get(texture).unwrap().texture;
334
335 self.queue.write_texture(
336 wgpu::TexelCopyTextureInfo{
337 texture,
338 mip_level: 0,
339 origin: wgpu::Origin3d::ZERO,
340 aspect: wgpu::TextureAspect::All,
341 },
342 bytes,
343 wgpu::TexelCopyBufferLayout{
344 offset: 0,
345 bytes_per_row: Some(byte_per_pixel * texture_size.width),
346 rows_per_image: Some(texture_size.height),
347 },
348 texture_size
349 );
350 }
351}
352