project structure cleanup

2021-04-16 10:54:00 +02:00
parent 9cd599743d
commit 3ad54777cd
8 changed files with 107 additions and 97 deletions
@@ -0,0 +1,290 @@
+use winit::{window::Window, dpi::PhysicalSize};
+use wgpu::util::DeviceExt;
+
+mod vertex; use vertex::Vertex;
+mod texture; use texture::Texture;
+pub mod camera; use camera::Camera;
+mod uniforms; use uniforms::Uniforms;
+
+
+const VERTICES: &[Vertex] = &[
+    Vertex { position: [-1.0, 1.0, 0.0], uv: [-1.0, 1.0] }, // top left
+    Vertex { position: [ 1.0, 1.0, 0.0], uv: [1.0, 1.0] }, // top right
+    Vertex { position: [ 1.0,-1.0, 0.0], uv: [1.0, -1.0] }, // bottom right
+    Vertex { position: [-1.0,-1.0, 0.0], uv: [-1.0, -1.0] }, // bottom left
+];
+const INDICES: &[u16] = &[ 0, 1, 3, 3, 1, 2 ];
+
+
+pub struct Renderer {
+    surface: wgpu::Surface,
+    device: wgpu::Device,
+    queue: wgpu::Queue,
+    swapchain_desc: wgpu::SwapChainDescriptor,
+    swapchain: wgpu::SwapChain,
+    pipeline: wgpu::RenderPipeline,
+    // Buffers
+    vertex_buffer: wgpu::Buffer,
+    index_buffer: wgpu::Buffer,
+    uniform_buffer: wgpu::Buffer,
+    // Uniform bind group
+    uniform_bind_group: wgpu::BindGroup,
+    // Texture
+    bind_group: wgpu::BindGroup,
+    // Camera
+    pub camera: Camera,
+    uniforms: Uniforms
+}
+
+impl Renderer {
+
+    fn create_swapchain(adapter: &wgpu::Adapter, device: &wgpu::Device, surface: &wgpu::Surface, size: PhysicalSize<u32>) -> (wgpu::SwapChainDescriptor, wgpu::SwapChain) {
+        let swapchain_desc = wgpu::SwapChainDescriptor {
+            usage: wgpu::TextureUsage::RENDER_ATTACHMENT, // render to screen
+            format: adapter.get_swap_chain_preferred_format(&surface),
+            width: size.width,
+            height: size.height,
+            present_mode: wgpu::PresentMode::Immediate, // Fifo = Vsync
+        };
+        let swapchain = device.create_swap_chain(&surface, &swapchain_desc);
+        (swapchain_desc, swapchain)
+    }
+
+    fn create_pipeline(device: &wgpu::Device, swapchain_desc: &wgpu::SwapChainDescriptor, bind_group_layouts: &[&wgpu::BindGroupLayout]) -> wgpu::RenderPipeline{
+        // Pipeline stuff
+        let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+            label: Some("Render Pipeline Layout"),
+            bind_group_layouts: bind_group_layouts,
+            push_constant_ranges: &[],
+        });
+        let vert_state = wgpu::VertexState { //vert
+            module: &device.create_shader_module(&wgpu::include_spirv!("..\\shaders\\bin\\shader.vert.spv")),
+            entry_point: "main",
+            buffers: &[Vertex::desc()],
+        };
+        let frag_state = wgpu::FragmentState { // frag
+            module: &device.create_shader_module(&wgpu::include_spirv!("..\\shaders\\bin\\shader.frag.spv")),
+            entry_point: "main",
+            targets: &[wgpu::ColorTargetState {
+                format: swapchain_desc.format,
+                alpha_blend: wgpu::BlendState::REPLACE,
+                color_blend: wgpu::BlendState::REPLACE,
+                write_mask: wgpu::ColorWrite::ALL,
+            }],
+        };
+        let prim_state = wgpu::PrimitiveState { // primitive
+            topology: wgpu::PrimitiveTopology::TriangleList,
+            strip_index_format: None,
+            front_face: wgpu::FrontFace::Cw,
+            cull_mode: wgpu::CullMode::Back,
+            polygon_mode: wgpu::PolygonMode::Fill,
+        };
+        let multisample_state = wgpu::MultisampleState { // multisample
+            count: 1,
+            mask: !0,
+            alpha_to_coverage_enabled: false,
+        };
+
+        // Create pipeline
+        device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+            label: Some("Render Pipeline"), 
+            layout: Some(&pipeline_layout),
+            vertex: vert_state, 
+            fragment: Some(frag_state),
+            primitive: prim_state,
+            depth_stencil: None,
+            multisample: multisample_state,
+        })
+    }
+
+    fn create_bind_group(device: &wgpu::Device, tex: &Texture) -> (wgpu::BindGroupLayout, wgpu::BindGroup) {
+        let bind_group_layout = device.create_bind_group_layout(
+            &wgpu::BindGroupLayoutDescriptor {
+                entries: &[
+                    wgpu::BindGroupLayoutEntry {
+                        binding: 0,
+                        visibility: wgpu::ShaderStage::FRAGMENT,
+                        ty: wgpu::BindingType::Texture {
+                            multisampled: false,
+                            view_dimension: wgpu::TextureViewDimension::D2,
+                            sample_type: wgpu::TextureSampleType::Float { filterable: false },
+                        },
+                        count: None,
+                    },
+                    wgpu::BindGroupLayoutEntry {
+                        binding: 1,
+                        visibility: wgpu::ShaderStage::FRAGMENT,
+                        ty: wgpu::BindingType::Sampler {
+                            comparison: false,
+                            filtering: true,
+                        },
+                        count: None,
+                    },
+                ],
+                label: None,
+            }
+        );
+        
+        let bind_group = device.create_bind_group(
+            &wgpu::BindGroupDescriptor {
+                layout: &bind_group_layout,
+                entries: &[
+                    wgpu::BindGroupEntry {
+                        binding: 0,
+                        resource: wgpu::BindingResource::TextureView(&tex.view),
+                    },
+                    wgpu::BindGroupEntry {
+                        binding: 1,
+                        resource: wgpu::BindingResource::Sampler(&tex.sampler),
+                    }
+                ],
+                label: None,
+            }
+        );
+
+        (bind_group_layout, bind_group)
+    }
+
+    fn create_uniform_bind_group(device: &wgpu::Device, buf: &wgpu::Buffer) -> (wgpu::BindGroupLayout, wgpu::BindGroup)  {
+        let uniform_bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+            entries: &[
+                wgpu::BindGroupLayoutEntry {
+                    binding: 0,
+                    visibility: wgpu::ShaderStage::FRAGMENT,
+                    ty: wgpu::BindingType::Buffer {
+                        ty: wgpu::BufferBindingType::Uniform,
+                        has_dynamic_offset: false,
+                        min_binding_size: None,
+                    },
+                    count: None,
+                }
+            ],
+            label: Some("uniform_bind_group_layout"),
+        });
+
+        let uniform_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+            layout: &uniform_bind_group_layout,
+            entries: &[
+                wgpu::BindGroupEntry {
+                    binding: 0,
+                    resource: buf.as_entire_binding(),
+                }
+            ],
+            label: Some("uniform_bind_group"),
+        });
+        
+        (uniform_bind_group_layout, uniform_bind_group)
+    }
+
+    fn create_buffer(device: &wgpu::Device, usage: wgpu::BufferUsage, content: &[u8]) -> wgpu::Buffer {
+        device.create_buffer_init(
+            &wgpu::util::BufferInitDescriptor {
+                label: None,
+                contents: content,
+                usage: usage,
+            }
+        )
+    }
+
+    
+    pub async fn new(window: &Window) -> Self {
+
+        // Create surface and pick device
+        let instance = wgpu::Instance::new(wgpu::BackendBit::PRIMARY);
+        let surface = unsafe { instance.create_surface(window) };
+
+        // Pick adapter (physical gpu)
+        let adapter_options = wgpu::RequestAdapterOptions { power_preference: wgpu::PowerPreference::HighPerformance, compatible_surface: Some(&surface) };
+        let adapter = instance.request_adapter(&adapter_options).await.unwrap();
+        println!("Adapter: {}", adapter.get_info().name);
+
+        // Pick device (logical gpu) from adapter 
+        let device_desc = wgpu::DeviceDescriptor { features: wgpu::Features::empty(), limits: wgpu::Limits::default(), label: None };
+        let (device, queue) = adapter.request_device(&device_desc, None).await.unwrap();
+
+        // Create swapchain
+        let (swapchain_desc, swapchain) = Self::create_swapchain(&adapter, &device, &surface, window.inner_size());
+
+        // Cam
+        let aspect = swapchain_desc.width as f32 / swapchain_desc.height as f32;
+        let camera = Camera::new(aspect, 60.0);
+        let mut uniforms = Uniforms::new();
+        uniforms.update(&camera);
+
+        // Buffers
+        let vertex_buffer = Self::create_buffer(&device, wgpu::BufferUsage::VERTEX, bytemuck::cast_slice(VERTICES));
+        let index_buffer = Self::create_buffer(&device, wgpu::BufferUsage::INDEX, bytemuck::cast_slice(INDICES));
+        let uniform_buffer = Self::create_buffer(&device, wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_DST, bytemuck::cast_slice(&[uniforms]));
+
+        // Load image
+        let tex = Texture::from_file(&device, &queue, "./assets/rick.png");
+        let (bind_group_layout, bind_group) =  Self::create_bind_group(&device, &tex);
+        let (uniform_bind_group_layout, uniform_bind_group) = Self::create_uniform_bind_group(&device, &uniform_buffer);
+
+        // Pipeline
+        let bind_groups = [&bind_group_layout, &uniform_bind_group_layout];
+        let pipeline = Self::create_pipeline(&device, &swapchain_desc, &bind_groups);
+
+        // Save values in app
+        println!("Initialized");
+        Self { surface, device, queue, swapchain_desc, swapchain, pipeline, vertex_buffer, index_buffer, uniform_buffer, bind_group, uniform_bind_group, camera, uniforms }
+    }
+
+    pub fn resize(&mut self, new_size: Option<PhysicalSize<u32>>) {
+        if let Some(size) = new_size {
+            // Minimized or manually resized to 0
+            if size.width == 0 || size.height == 0 { return }
+            // Recreate swapchain
+            self.swapchain_desc.width = size.width;
+            self.swapchain_desc.height = size.height;
+            // Update camera
+            self.camera.set_aspect(size.width as f32 / size.height as f32);
+        }
+        // Recreate swapchain
+        self.swapchain = self.device.create_swap_chain(&self.surface, &self.swapchain_desc);
+    }
+
+    pub fn render(&mut self) -> Result<(), wgpu::SwapChainError> {
+
+        // Update uniform buffer
+        self.uniforms.update(&self.camera);
+        self.queue.write_buffer(&self.uniform_buffer, 0, bytemuck::cast_slice(&[self.uniforms]));
+
+        // Get next frame to render to
+        let frame = self.swapchain.get_current_frame()?.output;
+
+        // Create encoder that will build command buffer for us
+        let mut encoder = self.device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: Some("Render Encoder"),});
+
+        // Create render pass
+        {
+            let ops = wgpu::Operations {
+                // Clear command
+                load: wgpu::LoadOp::Clear(wgpu::Color {r: 0.1, g: 0.2, b: 0.3, a: 1.0,}),
+                // Store command
+                store: true,
+            };
+
+            let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { 
+                label: Some("Render Pass"),
+                color_attachments: &[ wgpu::RenderPassColorAttachmentDescriptor { attachment: &frame.view, resolve_target: None, ops } ],
+                depth_stencil_attachment: None,
+            });
+
+            // Data
+            render_pass.set_pipeline(&self.pipeline);
+            render_pass.set_bind_group(0, &self.bind_group, &[]);
+            render_pass.set_bind_group(1, &self.uniform_bind_group, &[]);
+            // Vertices and indices
+            render_pass.set_vertex_buffer(0, self.vertex_buffer.slice(..));
+            render_pass.set_index_buffer(self.index_buffer.slice(..), wgpu::IndexFormat::Uint16);
+            render_pass.draw_indexed(0..(INDICES.len() as u32), 0, 0..1);
+        }
+
+        // Submit encoder (command buffer)
+        self.queue.submit(std::iter::once(encoder.finish()));
+
+        // Return ok
+        Ok(())
+    }
+}