add depth buffer

src/lib.rs

@@ -8,7 +8,10 @@ use rand_distr::Distribution as _;
 use crate::{
 	camera::OrbitalCamera,
 	ray::Ray,
-	render::lines::{LookParams, Mesh, Pipeline, Vertex},
+	render::{
+		DEPTH_FORMAT, OUTPUT_FORMAT,
+		lines::{LookParams, Mesh, Pipeline, Vertex},
+	},
 	trace::{Hit, Lambertian, Reflector, Scene, Source, Sphere},
 };
 
@@ -18,8 +21,6 @@ mod render;
 mod shape;
 mod trace;
 
-const OUTPUT_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Bgra8UnormSrgb;
-
 #[derive(Debug, Clone, Copy, PartialEq)]
 #[repr(C)]
 pub struct SphericalPosition {
@@ -66,6 +67,8 @@ pub struct Core {
 	queue: wgpu::Queue,
 	surface: wgpu::Surface<'static>,
 
+	depth: wgpu::Texture,
+
 	pipeline: Pipeline,
 	mesh_pipe: render::faces::Pipeline,
 	tripod: Mesh,
@@ -123,22 +126,26 @@ impl OrbitalCamera {
 }
 
 impl Core {
-	pub fn new(gpu: Gpu) -> Self {
+	pub fn new(gpu: Gpu, pixel_size: UVec2) -> Self {
 		let Gpu {
 			device,
 			queue,
 			surface,
 		} = gpu;
 
-		let pipeline = Pipeline::new(&device, OUTPUT_FORMAT);
+		let pipeline = Pipeline::new(&device);
-		let mesh_pipe = render::faces::Pipeline::new(&device, OUTPUT_FORMAT);
+		let mesh_pipe = render::faces::Pipeline::new(&device);
 		let tripod = new_tripod(&device);
+		let depth = Self::create_depth_buffer(&device, pixel_size);
 		queue.submit([]); // flush buffer updates
 
+		Self::configure_surface(&surface, &device, pixel_size);
+
 		Self {
 			device,
 			queue,
 			surface,
+			depth,
 			pipeline,
 			tripod,
 			mesh_pipe,
@@ -173,6 +180,9 @@ impl Core {
 		self.queue.submit([]); // flush buffer updates
 
 		let view = output.create_view(&wgpu::TextureViewDescriptor::default());
+		let depth_view = self
+			.depth
+			.create_view(&wgpu::TextureViewDescriptor::default());
 		let mut encoder = self
 			.device
 			.create_command_encoder(&wgpu::CommandEncoderDescriptor::default());
@@ -186,7 +196,14 @@ impl Core {
 					store: wgpu::StoreOp::Store,
 				},
 			})],
-			depth_stencil_attachment: None,
+			depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
+				view: &depth_view,
+				depth_ops: Some(wgpu::Operations {
+					load: wgpu::LoadOp::Clear(1.),
+					store: wgpu::StoreOp::Discard,
+				}),
+				stencil_ops: None,
+			}),
 			..Default::default()
 		});
 		if args.show_axes {
@@ -386,10 +403,26 @@ impl Core {
 		self.queue.submit(std::iter::once(encoder.finish()));
 	}
 
-	/// Configures the renderer for a given target size.
+	fn create_depth_buffer(device: &wgpu::Device, pixel_size: UVec2) -> wgpu::Texture {
-	pub fn configure(&mut self, pixel_size: UVec2) {
+		device.create_texture(&wgpu::TextureDescriptor {
-		self.surface.configure(
+			label: Some("depth buffer"),
-			&self.device,
+			size: wgpu::Extent3d {
+				width: pixel_size.x,
+				height: pixel_size.y,
+				depth_or_array_layers: 1,
+			},
+			mip_level_count: 1,
+			sample_count: 1,
+			dimension: wgpu::TextureDimension::D2,
+			format: DEPTH_FORMAT,
+			usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
+			view_formats: &[],
+		})
+	}
+
+	fn configure_surface(surface: &wgpu::Surface, device: &wgpu::Device, pixel_size: UVec2) {
+		surface.configure(
+			device,
 			&wgpu::SurfaceConfiguration {
 				usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_DST,
 				format: OUTPUT_FORMAT,
@@ -403,6 +436,12 @@ impl Core {
 		);
 	}
 
+	/// Configures the renderer for a given target size.
+	pub fn configure(&mut self, pixel_size: UVec2) {
+		Self::configure_surface(&self.surface, &self.device, pixel_size);
+		self.depth = Self::create_depth_buffer(&self.device, pixel_size);
+	}
+
 	/// Redraws the entire surface.
 	///
 	/// [`Self::configure`] must be called at least once before this.

src/main.rs

@@ -26,8 +26,7 @@ impl MainWindow {
 			instance.create_surface(Arc::clone(&window))
 		}))
 		.unwrap();
-		let mut core = Core::new(gpu);
+		let core = Core::new(gpu, uvec2(1, 1));
-		core.configure(uvec2(1, 1));
 		Self { window, core }
 	}
 

src/render/faces.rs

@@ -4,6 +4,8 @@ use bytemuck::{Pod, Zeroable, bytes_of, cast_slice};
 use glam::{Mat4, Vec3};
 use wgpu::util::DeviceExt as _;
 
+use crate::render::{DEPTH_FORMAT, OUTPUT_FORMAT};
+
 #[derive(Debug, Clone, Copy, Pod, Zeroable)]
 #[repr(C)]
 pub struct LookParams {
@@ -67,7 +69,7 @@ pub struct Pipeline {
 }
 
 impl Pipeline {
-	pub fn new(device: &wgpu::Device, format: wgpu::TextureFormat) -> Self {
+	pub fn new(device: &wgpu::Device) -> Self {
 		let look_buf = device.create_buffer(&wgpu::BufferDescriptor {
 			label: None,
 			size: size_of::<LookParams>() as u64,
@@ -107,7 +109,13 @@ impl Pipeline {
 				topology: wgpu::PrimitiveTopology::TriangleList,
 				..Default::default()
 			},
-			depth_stencil: None,
+			depth_stencil: Some(wgpu::DepthStencilState {
+				format: DEPTH_FORMAT,
+				depth_write_enabled: true,
+				depth_compare: wgpu::CompareFunction::LessEqual,
+				stencil: wgpu::StencilState::default(),
+				bias: wgpu::DepthBiasState::default(),
+			}),
 			multisample: wgpu::MultisampleState {
 				count: 1,
 				mask: !0,
@@ -118,7 +126,7 @@ impl Pipeline {
 				entry_point: None,
 				compilation_options: wgpu::PipelineCompilationOptions::default(),
 				targets: &[Some(wgpu::ColorTargetState {
-					format,
+					format: OUTPUT_FORMAT,
 					blend: Some(wgpu::BlendState::REPLACE),
 					write_mask: wgpu::ColorWrites::ALL,
 				})],

src/render/lines.rs

@@ -4,6 +4,8 @@ use bytemuck::{Pod, Zeroable, bytes_of, cast_slice};
 use glam::{Mat4, Vec3};
 use wgpu::util::DeviceExt as _;
 
+use crate::render::{DEPTH_FORMAT, OUTPUT_FORMAT};
+
 #[derive(Debug, Clone, Copy, Pod, Zeroable)]
 #[repr(C)]
 pub struct LookParams {
@@ -49,7 +51,7 @@ pub struct Pipeline {
 }
 
 impl Pipeline {
-	pub fn new(device: &wgpu::Device, format: wgpu::TextureFormat) -> Self {
+	pub fn new(device: &wgpu::Device) -> Self {
 		let look_buf = device.create_buffer(&wgpu::BufferDescriptor {
 			label: None,
 			size: size_of::<LookParams>() as u64,
@@ -89,7 +91,17 @@ impl Pipeline {
 				topology: wgpu::PrimitiveTopology::LineList,
 				..Default::default()
 			},
-			depth_stencil: None,
+			depth_stencil: Some(wgpu::DepthStencilState {
+				format: DEPTH_FORMAT,
+				depth_write_enabled: true,
+				depth_compare: wgpu::CompareFunction::LessEqual,
+				stencil: wgpu::StencilState::default(),
+				bias: wgpu::DepthBiasState {
+					constant: -2,
+					slope_scale: 0.,
+					clamp: 0.,
+				},
+			}),
 			multisample: wgpu::MultisampleState {
 				count: 1,
 				mask: !0,
@@ -100,7 +112,7 @@ impl Pipeline {
 				entry_point: None,
 				compilation_options: wgpu::PipelineCompilationOptions::default(),
 				targets: &[Some(wgpu::ColorTargetState {
-					format,
+					format: OUTPUT_FORMAT,
 					blend: Some(wgpu::BlendState::REPLACE),
 					write_mask: wgpu::ColorWrites::ALL,
 				})],

src/render/mod.rs

@@ -2,3 +2,6 @@ pub mod faces;
 pub mod lines;
 
 static SIMPLE_SHADER: &str = include_str!("simple.wgsl");
+
+pub const OUTPUT_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Bgra8UnormSrgb;
+pub const DEPTH_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Depth24Plus;

ui/src/api.cxx

@@ -4,7 +4,7 @@
 #include <utility>
 
 namespace ffi {
-extern "C" Core* rt4_viewport_create(xcb_connection_t* connection, std::uint32_t window);
+extern "C" Core* rt4_viewport_create(xcb_connection_t* connection, std::uint32_t window, std::uint32_t width, std::uint32_t height);
 extern "C" void rt4_viewport_destroy(Core* viewport);
 extern "C" void rt4_viewport_configure(Core* viewport, std::uint32_t width, std::uint32_t height);
 extern "C" void rt4_viewport_redraw(Core* viewport, const RedrawArgs* args);
@@ -26,13 +26,13 @@ BoxCore& BoxCore::operator=(BoxCore&& b) {
 	return *this;
 }
 
-BoxCore BoxCore::from_xcb(xcb_connection_t* connection, std::uint32_t window) {
+BoxCore BoxCore::from_xcb(xcb_connection_t* connection, std::uint32_t window, std::uint32_t width, std::uint32_t height) {
 	if (!connection)
 		throw std::logic_error("attempt to use a null connection");
 	if (!window)
 		throw std::logic_error("attempt to use a null window");
 	BoxCore out;
-	out.ptr.ptr = ffi::rt4_viewport_create(connection, window);
+	out.ptr.ptr = ffi::rt4_viewport_create(connection, window, width, height);
 	return out;
 }
 

ui/src/api.hxx

@@ -69,7 +69,7 @@ public:
 
 	void reset();
 
-	static BoxCore from_xcb(xcb_connection_t* connection, std::uint32_t window);
+	static BoxCore from_xcb(xcb_connection_t* connection, std::uint32_t window, std::uint32_t width, std::uint32_t height);
 
 private:
 	MutCore ptr;

ui/src/lib.rs

@@ -1,12 +1,13 @@
 use std::{ffi::c_void, num::NonZero, ptr::NonNull};
 
-use glam::uvec2;
+use glam::{UVec2, uvec2};
 use photon_light::{Core, RedrawArgs, init_gpu_inner};
 use raw_window_handle::{RawDisplayHandle, RawWindowHandle, XcbDisplayHandle, XcbWindowHandle};
 
 unsafe fn create_viewport(
 	display: impl Into<RawDisplayHandle>,
 	window: impl Into<RawWindowHandle>,
+	size: UVec2,
 ) -> Box<Core> {
 	let target = wgpu::SurfaceTargetUnsafe::RawHandle {
 		raw_display_handle: display.into(),
@@ -16,17 +17,19 @@ unsafe fn create_viewport(
 		instance.create_surface_unsafe(target)
 	}))
 	.unwrap();
-	Box::new(Core::new(gpu))
+	Box::new(Core::new(gpu, size))
 }
 
 #[unsafe(no_mangle)]
 unsafe extern "C" fn rt4_viewport_create(
 	connection: NonNull<c_void>,
 	window: NonZero<u32>,
+	width: u32,
+	height: u32,
 ) -> Box<Core> {
 	let display = XcbDisplayHandle::new(Some(connection), 0);
 	let window = XcbWindowHandle::new(window);
-	unsafe { create_viewport(display, window) }
+	unsafe { create_viewport(display, window, uvec2(width, height)) }
 }
 
 #[unsafe(no_mangle)]

ui/src/viewport.cxx

@@ -61,9 +61,9 @@ void Viewport::recreate() try {
 
 	fprintf(stderr, "connection %p, window %#08x\n", xcb_connection, x11_window);
 
+	const QSize device_size = size() * devicePixelRatio();
 	core.reset();
-	core = BoxCore::from_xcb(xcb_connection, x11_window);
+	core = BoxCore::from_xcb(xcb_connection, x11_window, device_size.width(), device_size.height());
-	updateSize();
 } catch (const std::exception& e) {
 	fprintf(stderr, "failed to recreate the viewport: %s", e.what());
 }