use crate::{ input::Controllable, meshs::DefaultMesh, render::{Renderable, TextureManager}, }; use super::render::{Camera, InstanceRaw, Texture, Vertex}; use winit::{event::WindowEvent, window::Window}; pub struct State { pub surface: wgpu::Surface, pub device: wgpu::Device, pub queue: wgpu::Queue, pub config: wgpu::SurfaceConfiguration, pub size: winit::dpi::PhysicalSize, render_pipeline: wgpu::RenderPipeline, camera: Camera, depth_texture: Texture, mesh: DefaultMesh, #[allow(dead_code)] texture_manager: TextureManager, } impl State { // Creating some of the wgpu types requires async code pub async fn new(window: &Window) -> Self { let size = window.inner_size(); // The instance is a handle to our GPU // Backends::all => Vulkan + Metal + DX12 + Browser WebGPU let instance = wgpu::Instance::new(wgpu::Backends::all()); let surface = unsafe { instance.create_surface(window) }; let adapter = instance .request_adapter(&wgpu::RequestAdapterOptions { power_preference: wgpu::PowerPreference::default(), compatible_surface: Some(&surface), force_fallback_adapter: false, }) .await .unwrap(); // let adapter = instance // .enumerate_adapters(wgpu::Backends::all()) // .filter(|adapter| { // // Check if this adapter supports our surface // surface.get_preferred_format(&adapter).is_some() // }) // .next() // .unwrap(); let (device, queue) = adapter .request_device( &wgpu::DeviceDescriptor { features: wgpu::Features::empty(), // WebGL doesn't support all of wgpu's features, so if // we're building for the web we'll have to disable some. limits: if cfg!(target_arch = "wasm32") { wgpu::Limits::downlevel_webgl2_defaults() } else { wgpu::Limits::default() }, label: None, }, None, // Trace path ) .await .unwrap(); let config = wgpu::SurfaceConfiguration { usage: wgpu::TextureUsages::RENDER_ATTACHMENT, format: surface.get_preferred_format(&adapter).unwrap(), width: size.width, height: size.height, present_mode: wgpu::PresentMode::Fifo, }; surface.configure(&device, &config); let texture_manager = TextureManager::new(&device); let shader = device.create_shader_module(&wgpu::ShaderModuleDescriptor { label: Some("Shader"), source: wgpu::ShaderSource::Wgsl( include_str!(concat!( env!("CARGO_MANIFEST_DIR"), "/res/shaders/main.wgsl" )) .into(), ), }); let mut camera = Camera::new(config.width as f32, config.height as f32, 0.2); camera.initialize(&device); let depth_texture = Texture::create_depth_texture(&device, &config, "depth_texture"); let render_pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { label: Some("Render Pipeline Layout"), bind_group_layouts: &[ &texture_manager.get_texture_bind_group_layout(), camera.get_bind_group_layout(), ], push_constant_ranges: &[], }); let render_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { label: Some("Render Pipeline"), layout: Some(&render_pipeline_layout), vertex: wgpu::VertexState { module: &shader, entry_point: "vs_main", buffers: &[Vertex::desc(), InstanceRaw::desc()], }, fragment: Some(wgpu::FragmentState { module: &shader, entry_point: "fs_main", targets: &[wgpu::ColorTargetState { format: config.format, blend: Some(wgpu::BlendState::REPLACE), write_mask: wgpu::ColorWrites::ALL, }], }), primitive: wgpu::PrimitiveState { topology: wgpu::PrimitiveTopology::TriangleList, strip_index_format: None, front_face: wgpu::FrontFace::Ccw, cull_mode: Some(wgpu::Face::Back), // Setting this to anything other than Fill requires Features::NON_FILL_POLYGON_MODE polygon_mode: wgpu::PolygonMode::Fill, // Requires Features::DEPTH_CLIP_CONTROL unclipped_depth: false, // Requires Features::CONSERVATIVE_RASTERIZATION conservative: false, }, depth_stencil: Some(wgpu::DepthStencilState { format: Texture::DEPTH_FORMAT, depth_write_enabled: true, depth_compare: wgpu::CompareFunction::Less, stencil: wgpu::StencilState::default(), bias: wgpu::DepthBiasState::default(), }), multisample: wgpu::MultisampleState { count: 1, mask: !0, alpha_to_coverage_enabled: false, }, multiview: None, }); let diffuse_bind_group = texture_manager.create_texture_from_bytes( &device, &queue, include_bytes!(concat!( env!("CARGO_MANIFEST_DIR"), "/res/images/happy-tree.png" )), "happy-tree.png", ); let diffuse_bind_group_pikachu = texture_manager.create_texture_from_bytes( &device, &queue, include_bytes!(concat!( env!("CARGO_MANIFEST_DIR"), "/res/images/pikachu.png" )), "pikachu.png", ); let mut mesh = DefaultMesh::new(diffuse_bind_group, diffuse_bind_group_pikachu); mesh.initialize(&device); Self { surface, device, queue, config, size, render_pipeline, camera, depth_texture, mesh, texture_manager, } } pub fn resize(&mut self, new_size: winit::dpi::PhysicalSize) { if new_size.width > 0 && new_size.height > 0 { self.size = new_size; self.config.width = new_size.width; self.config.height = new_size.height; self.surface.configure(&self.device, &self.config); } self.depth_texture = Texture::create_depth_texture(&self.device, &self.config, "depth_texture"); } pub fn input(&mut self, event: &WindowEvent) -> bool { self.mesh.process_events(&event) || self.camera.process_events(&event) } pub fn update(&mut self) { self.camera.update_instances(&self.queue); self.mesh.update_instances(&self.queue); } pub fn render(&mut self) -> Result<(), wgpu::SurfaceError> { let output = self.surface.get_current_texture()?; let view = output .texture .create_view(&wgpu::TextureViewDescriptor::default()); let mut encoder = self .device .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: Some("Render Encoder"), }); { let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { label: Some("Render Pass"), color_attachments: &[ // This is what [[location(0)]] in the fragment shader targets wgpu::RenderPassColorAttachment { view: &view, resolve_target: None, ops: wgpu::Operations { load: wgpu::LoadOp::Clear(wgpu::Color { r: 0.1, g: 0.2, b: 0.3, a: 1.0, }), store: true, }, }, ], depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment { view: &self.depth_texture.view, depth_ops: Some(wgpu::Operations { load: wgpu::LoadOp::Clear(1.0), store: true, }), stencil_ops: None, }), }); render_pass.set_pipeline(&self.render_pipeline); self.camera.prepare(&mut render_pass); self.mesh.prepare(&mut render_pass); self.camera.draw(&mut render_pass); self.mesh.draw(&mut render_pass); } // submit will accept anything that implements IntoIter self.queue.submit(std::iter::once(encoder.finish())); output.present(); Ok(()) } }