learn_wgpu/

lib.rs

// src/lib.rs
use winit::{
	event::*,
	event_loop::{ ControlFlow, EventLoop },
	window::{ WindowBuilder, Window },
}; 

struct State {
	
	instance: wgpu::Instance,
	adapter: wgpu::Adapter,
	surface: wgpu::Surface,
	device: wgpu::Device,
	queue: wgpu::Queue,
	config: wgpu::SurfaceConfiguration,
	size: winit::dpi::PhysicalSize<u32>,
	clear_color: wgpu::Color,
	render_pipeline: wgpu::RenderPipeline,
	
}

impl State {
	
	async fn new(window: &Window) -> Self {
		
		let size = window.inner_size();
		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 (device, queue) = adapter.request_device(
			
			&wgpu::DeviceDescriptor {
				
				label: None,
				features: wgpu::Features::empty(),
				limits: wgpu::Limits::default(),
				
			},
			None,
		).await.unwrap();
		
		let config = wgpu::SurfaceConfiguration {
			
			usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
			format: surface.get_supported_formats(&adapter)[0],
			width: size.width,
			height: size.height,
			present_mode: wgpu::PresentMode::Fifo,
			
		};		
		surface.configure(&device, &config);
		
		let clear_color = wgpu::Color::BLACK;
		
		let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
			
			label: Some("Shader"),
			source: wgpu::ShaderSource::Wgsl(include_str!("shader.wgsl").into()),
			
		});
		
		let render_pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
			
			label: Some("Render Pipeline Laypout"),
			bind_group_layouts: &[],
			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: &[],
				
			},
			fragment: Some(wgpu::FragmentState {
				
				module: &shader,
				entry_point: "fs_main",
				targets: &[Some(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),
				polygon_mode: wgpu::PolygonMode::Fill,
				unclipped_depth: false,
				conservative: false,
				
			},
			depth_stencil: None,
			multisample: wgpu::MultisampleState {
				
				count: 1,
				mask: !0,
				alpha_to_coverage_enabled: false,
				
			},
			multiview: None,
			
		});
		
		Self {
			
			instance,
			adapter,
			surface,
			device,
			queue,
			config,
			size,
			clear_color,
			render_pipeline,
			
		}
	}
	
	fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
		
		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);
			
		}		
	}	
	
	fn input(&mut self, event: &WindowEvent) -> bool {
		
		match event {
			
			WindowEvent::CursorMoved { position, .. } => {
				
				self.clear_color = wgpu::Color {
					
					r: position.x as f64 / self.size.width as f64,
					g: position.y as f64 / self.size.height as f64,
					b: 1.0,
					a: 1.0,
					
				};
				true
				
			}
			_ => false,
		}		
	}
	
	fn update(&mut self) {
		
		
		
	}
	
	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: &[Some(wgpu::RenderPassColorAttachment {
					
					view: &view,
					resolve_target: None,
					ops: wgpu::Operations {
						
						load: wgpu::LoadOp::Clear(self.clear_color),
						store: true,
												
					},
				})],				
				depth_stencil_attachment: None,
				
			});
			
			render_pass.set_pipeline(&self.render_pipeline);
			render_pass.draw(0..3, 0..1);
		}
		
		self.queue.submit(std::iter::once(encoder.finish()));
		output.present();
		
		Ok(())		
	}
}

pub async fn run() {
	
	env_logger::init();
	let event_loop = EventLoop::new();
	let window = WindowBuilder::new().build(&event_loop).unwrap();
	
	let mut state = State::new(&window).await;	
	
	event_loop.run(move |event, _, control_flow| {
		
		match event {
			
			Event::WindowEvent {
				
				ref event,
				window_id,
				
			} if window_id == window.id() => if !state.input(event) {
				
				match event {
					
					WindowEvent::CloseRequested | WindowEvent::KeyboardInput {
						
						input: KeyboardInput {
							
							state: ElementState::Pressed,
							virtual_keycode: Some(VirtualKeyCode::Escape),
							..
							
						},
					..
						
					} => *control_flow = ControlFlow::Exit,
					WindowEvent::Resized(physical_size) => {
						
						state.resize(*physical_size);
						
					},
					WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
						
						state.resize(**new_inner_size);
						
					},
					_ => {},
					
				}
			}
			Event::RedrawRequested(window_id) if window_id == window.id() => {
				
				state.update();
				match state.render() {
					
					Ok(_) => {}
					Err(wgpu::SurfaceError::Lost) => state.resize(state.size),
					Err(wgpu::SurfaceError::OutOfMemory) => *control_flow = ControlFlow::Exit,
					Err(wgpu::SurfaceError::Timeout) => log::warn!("Surface timeout"),
					Err(e) => eprintln!("{e:?}"),					
					
				}
				
			},
			Event::MainEventsCleared => {
				
				window.request_redraw();
				
			}
			_ => {}			
		}		
	});
}