LINE1 10 20 30 40 50 60 70 80 90 100 110 120 130 140 150 160 170 1801use std::{2 env,3 error::Error,4 fs::File,5 path::{Path, PathBuf},6 sync::mpsc,7};89use wgpu::util::DeviceExt;1011const DEFAULT_WIDTH: u32 = 800;12const DEFAULT_HEIGHT: u32 = 450;13const BYTES_PER_PIXEL: u32 = 4;14const COPY_ALIGNMENT: u32 = wgpu::COPY_BYTES_PER_ROW_ALIGNMENT;1516struct Options {17 output: PathBuf,18 width: u32,19 height: u32,20 force_fallback_adapter: bool,21}2223fn main() {24 if let Err(error) = run() {25 eprintln!("ray-tracer: {error}");26 std::process::exit(1);27 }28}2930fn run() -> Result<(), Box<dyn Error>> {31 let options = parse_options()?;32 validate_dimensions(options.width, options.height)?;3334 let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::default());35 let adapter = pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {36 power_preference: wgpu::PowerPreference::HighPerformance,37 force_fallback_adapter: options.force_fallback_adapter,38 compatible_surface: None,39 }))40 .ok_or_else(|| {41 if options.force_fallback_adapter {42 "no software/fallback wgpu adapter found; install a Vulkan software driver such as Mesa lavapipe, or retry without --software".to_owned()43 } else {44 "no compatible wgpu adapter found; check that a Vulkan/Metal/DX12-capable graphics driver is installed, or retry with --software if a fallback adapter is available".to_owned()45 }46 })?;47 let adapter_info = adapter.get_info();48 let max_texture_dimension = adapter.limits().max_texture_dimension_2d;49 if options.width > max_texture_dimension || options.height > max_texture_dimension {50 return Err(format!(51 "requested image is {}x{}, but adapter {:?} supports at most {} pixels per texture side",52 options.width, options.height, adapter_info.name, max_texture_dimension53 )54 .into());55 }56 eprintln!(57 "Rendering {}x{} with {} ({:?}, {:?})",58 options.width,59 options.height,60 adapter_info.name,61 adapter_info.device_type,62 adapter_info.backend63 );6465 let (device, queue) = pollster::block_on(adapter.request_device(66 &wgpu::DeviceDescriptor {67 label: Some("ray-tracer device"),68 required_features: wgpu::Features::empty(),69 required_limits: wgpu::Limits::downlevel_defaults().using_resolution(adapter.limits()),70 },71 None,72 ))73 .map_err(|error| {74 format!(75 "could not create a wgpu device from adapter {:?}: {error}; update the graphics driver or try --software",76 adapter_info.name77 )78 })?;7980 let pixels = render(&device, &queue, options.width, options.height)?;81 write_png(&options.output, options.width, options.height, &pixels)?;82 println!("Wrote {}", options.output.display());83 Ok(())84}8586fn parse_options() -> Result<Options, Box<dyn Error>> {87 let mut args = env::args().skip(1);88 let mut output = PathBuf::from("render.png");89 let mut width = DEFAULT_WIDTH;90 let mut height = DEFAULT_HEIGHT;91 let mut force_fallback_adapter = false;9293 while let Some(argument) = args.next() {94 match argument.as_str() {95 "--output" | "-o" => {96 output = args.next().ok_or("--output requires a path")?.into();97 }98 "--size" => {99 let dimensions = args.next().ok_or("--size requires WIDTHxHEIGHT")?;100 let (parsed_width, parsed_height) = dimensions101 .split_once('x')102 .ok_or("--size must use WIDTHxHEIGHT, for example 800x450")?;103 width = parsed_width.parse()?;104 height = parsed_height.parse()?;105 }106 "--software" => force_fallback_adapter = true,107 "--help" | "-h" => {108 print_help();109 std::process::exit(0);110 }111 unknown => return Err(format!("unknown argument: {unknown}; use --help").into()),112 }113 }114115 Ok(Options {116 output,117 width,118 height,119 force_fallback_adapter,120 })121}122123fn print_help() {124 println!(125 "ray-tracer [--output PATH] [--size WIDTHxHEIGHT] [--software]\n\n\126 Render the built-in scene to a PNG. --software requests a fallback adapter."127 );128}129130fn validate_dimensions(width: u32, height: u32) -> Result<(), Box<dyn Error>> {131 if width == 0 || height == 0 {132 return Err("image width and height must both be greater than zero".into());133 }134 if width > 16_384 || height > 16_384 {135 return Err("image dimensions are capped at 16384 pixels per side".into());136 }137 let byte_len = u64::from(width)138 .checked_mul(u64::from(height))139 .and_then(|pixels| pixels.checked_mul(u64::from(BYTES_PER_PIXEL)))140 .ok_or("image dimensions overflow the addressable output size")?;141 let _ = usize::try_from(byte_len).map_err(|_| "image is too large for this platform")?;142 Ok(())143}144145fn render(146 device: &wgpu::Device,147 queue: &wgpu::Queue,148 width: u32,149 height: u32,150) -> Result<Vec<u8>, Box<dyn Error>> {151 let texture = device.create_texture(&wgpu::TextureDescriptor {152 label: Some("ray-traced output"),153 size: wgpu::Extent3d {154 width,155 height,156 depth_or_array_layers: 1,157 },158 mip_level_count: 1,159 sample_count: 1,160 dimension: wgpu::TextureDimension::D2,161 format: wgpu::TextureFormat::Rgba8Unorm,162 usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,163 view_formats: &[],164 });165 let view = texture.create_view(&wgpu::TextureViewDescriptor::default());166 let (pipeline, bind_group) = create_pipeline(device, width, height)?;167 let unpadded_bytes_per_row = width168 .checked_mul(BYTES_PER_PIXEL)169 .ok_or("row size overflows the GPU buffer range")?;170 let padded_bytes_per_row = align_up(unpadded_bytes_per_row, COPY_ALIGNMENT)?;171 let buffer_size = u64::from(padded_bytes_per_row)172 .checked_mul(u64::from(height))173 .ok_or("readback buffer size overflow")?;174 let output_buffer = device.create_buffer(&wgpu::BufferDescriptor {175 label: Some("PNG readback buffer"),176 size: buffer_size,177 usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,178 mapped_at_creation: false,179 });180181 let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor {182 label: Some("ray-tracing command encoder"),183 });184 {185 let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {186 label: Some("ray-tracing pass"),187 color_attachments: &[Some(wgpu::RenderPassColorAttachment {188 view: &view,189 resolve_target: None,190 ops: wgpu::Operations {191 load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),192 store: wgpu::StoreOp::Store,193 },194 })],195 depth_stencil_attachment: None,196 occlusion_query_set: None,197 timestamp_writes: None,198 });199 pass.set_pipeline(&pipeline);200 pass.set_bind_group(0, &bind_group, &[]);201 pass.draw(0..3, 0..1);202 }203 encoder.copy_texture_to_buffer(204 wgpu::ImageCopyTexture {205 texture: &texture,206 mip_level: 0,207 origin: wgpu::Origin3d::ZERO,208 aspect: wgpu::TextureAspect::All,209 },210 wgpu::ImageCopyBuffer {211 buffer: &output_buffer,212 layout: wgpu::ImageDataLayout {213 offset: 0,214 bytes_per_row: Some(padded_bytes_per_row),215 rows_per_image: Some(height),216 },217 },218 wgpu::Extent3d {219 width,220 height,221 depth_or_array_layers: 1,222 },223 );224 queue.submit(Some(encoder.finish()));225226 let slice = output_buffer.slice(..);227 let (sender, receiver) = mpsc::channel();228 slice.map_async(wgpu::MapMode::Read, move |result| {229 let _ = sender.send(result);230 });231 device.poll(wgpu::Maintain::Wait);232 receiver233 .recv()234 .map_err(|error| format!("GPU readback callback failed: {error}"))??;235236 let mapped = slice.get_mapped_range();237 let row_bytes = usize::try_from(unpadded_bytes_per_row)?;238 let padded_row_bytes = usize::try_from(padded_bytes_per_row)?;239 let output_len = usize::try_from(u64::from(width) * u64::from(height) * 4)?;240 let mut pixels = Vec::with_capacity(output_len);241 for row in mapped242 .chunks_exact(padded_row_bytes)243 .take(usize::try_from(height)?)244 {245 pixels.extend_from_slice(&row[..row_bytes]);246 }247 drop(mapped);248 output_buffer.unmap();249 Ok(pixels)250}251252fn create_pipeline(253 device: &wgpu::Device,254 width: u32,255 height: u32,256) -> Result<(wgpu::RenderPipeline, wgpu::BindGroup), Box<dyn Error>> {257 let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {258 label: Some("ray-tracing fragment shader"),259 source: wgpu::ShaderSource::Wgsl(include_str!("raytrace.wgsl").into()),260 });261 let mut dimensions_bytes = Vec::with_capacity(8);262 dimensions_bytes.extend_from_slice(&f32::from(u16::try_from(width)?).to_ne_bytes());263 dimensions_bytes.extend_from_slice(&f32::from(u16::try_from(height)?).to_ne_bytes());264 let dimensions_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {265 label: Some("frame dimensions"),266 contents: &dimensions_bytes,267 usage: wgpu::BufferUsages::UNIFORM,268 });269 let bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {270 label: Some("ray-tracing frame layout"),271 entries: &[wgpu::BindGroupLayoutEntry {272 binding: 0,273 visibility: wgpu::ShaderStages::FRAGMENT,274 ty: wgpu::BindingType::Buffer {275 ty: wgpu::BufferBindingType::Uniform,276 has_dynamic_offset: false,277 min_binding_size: wgpu::BufferSize::new(8),278 },279 count: None,280 }],281 });282 let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {283 label: Some("ray-tracing frame bindings"),284 layout: &bind_group_layout,285 entries: &[wgpu::BindGroupEntry {286 binding: 0,287 resource: dimensions_buffer.as_entire_binding(),288 }],289 });290 let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {291 label: Some("ray-tracing pipeline layout"),292 bind_group_layouts: &[&bind_group_layout],293 push_constant_ranges: &[],294 });295 let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {296 label: Some("ray-tracing pipeline"),297 layout: Some(&pipeline_layout),298 vertex: wgpu::VertexState {299 module: &shader,300 entry_point: "vertex_main",301 buffers: &[],302 },303 fragment: Some(wgpu::FragmentState {304 module: &shader,305 entry_point: "fragment_main",306 targets: &[Some(wgpu::ColorTargetState {307 format: wgpu::TextureFormat::Rgba8Unorm,308 blend: None,309 write_mask: wgpu::ColorWrites::ALL,310 })],311 }),312 primitive: wgpu::PrimitiveState::default(),313 depth_stencil: None,314 multisample: wgpu::MultisampleState::default(),315 multiview: None,316 });317 Ok((pipeline, bind_group))318}319320fn align_up(value: u32, alignment: u32) -> Result<u32, Box<dyn Error>> {321 value322 .checked_add(alignment - 1)323 .map(|aligned| aligned / alignment * alignment)324 .ok_or_else(|| "aligned row size overflow".into())325}326327fn write_png(path: &Path, width: u32, height: u32, pixels: &[u8]) -> Result<(), Box<dyn Error>> {328 let file = File::create(path)?;329 let mut encoder = png::Encoder::new(file, width, height);330 encoder.set_color(png::ColorType::Rgba);331 encoder.set_depth(png::BitDepth::Eight);332 let mut writer = encoder.write_header()?;333 writer.write_image_data(pixels)?;334 writer.finish()?;335 Ok(())336}