Skip to content
1        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}