src/lib.rs

@@ -8,10 +8,7 @@ use rand_distr::Distribution as _;
 use crate::{
 	camera::OrbitalCamera,
 	ray::Ray,
-	render::{
+	render::lines::{LookParams, Mesh, Pipeline, Vertex},
-		DEPTH_FORMAT, OUTPUT_FORMAT,
-		lines::{LookParams, Mesh, Pipeline, Vertex},
-	},
 	trace::{Hit, Lambertian, Reflector, Scene, Source, Sphere},
 };
 
@@ -21,6 +18,8 @@ mod render;
 mod shape;
 mod trace;
 
+const OUTPUT_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Bgra8UnormSrgb;
+
 #[derive(Debug, Clone, Copy, PartialEq)]
 #[repr(C)]
 pub struct SphericalPosition {
@@ -67,8 +66,6 @@ pub struct Core {
 	queue: wgpu::Queue,
 	surface: wgpu::Surface<'static>,
 
-	depth: wgpu::Texture,
-
 	pipeline: Pipeline,
 	mesh_pipe: render::faces::Pipeline,
 	tripod: Mesh,
@@ -126,26 +123,22 @@ impl OrbitalCamera {
 }
 
 impl Core {
-	pub fn new(gpu: Gpu, pixel_size: UVec2) -> Self {
+	pub fn new(gpu: Gpu) -> Self {
 		let Gpu {
 			device,
 			queue,
 			surface,
 		} = gpu;
 
-		let pipeline = Pipeline::new(&device);
+		let pipeline = Pipeline::new(&device, OUTPUT_FORMAT);
-		let mesh_pipe = render::faces::Pipeline::new(&device);
+		let mesh_pipe = render::faces::Pipeline::new(&device, OUTPUT_FORMAT);
 		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,
@@ -180,9 +173,6 @@ 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());
@@ -196,14 +186,7 @@ impl Core {
 					store: wgpu::StoreOp::Store,
 				},
 			})],
-			depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
+			depth_stencil_attachment: None,
-				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 {
@@ -403,26 +386,10 @@ impl Core {
 		self.queue.submit(std::iter::once(encoder.finish()));
 	}
 
-	fn create_depth_buffer(device: &wgpu::Device, pixel_size: UVec2) -> wgpu::Texture {
+	/// Configures the renderer for a given target size.
-		device.create_texture(&wgpu::TextureDescriptor {
+	pub fn configure(&mut self, pixel_size: UVec2) {
-			label: Some("depth buffer"),
+		self.surface.configure(
-			size: wgpu::Extent3d {
+			&self.device,
-				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,
@@ -436,12 +403,6 @@ 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,7 +26,8 @@ impl MainWindow {
 			instance.create_surface(Arc::clone(&window))
 		}))
 		.unwrap();
-		let core = Core::new(gpu, uvec2(1, 1));
+		let mut core = Core::new(gpu);
+		core.configure(uvec2(1, 1));
 		Self { window, core }
 	}
 

src/render/faces.rs

@@ -4,8 +4,6 @@ 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 {
@@ -69,7 +67,7 @@ pub struct Pipeline {
 }
 
 impl Pipeline {
-	pub fn new(device: &wgpu::Device) -> Self {
+	pub fn new(device: &wgpu::Device, format: wgpu::TextureFormat) -> Self {
 		let look_buf = device.create_buffer(&wgpu::BufferDescriptor {
 			label: None,
 			size: size_of::<LookParams>() as u64,
@@ -109,13 +107,7 @@ impl Pipeline {
 				topology: wgpu::PrimitiveTopology::TriangleList,
 				..Default::default()
 			},
-			depth_stencil: Some(wgpu::DepthStencilState {
+			depth_stencil: None,
-				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,
@@ -126,7 +118,7 @@ impl Pipeline {
 				entry_point: None,
 				compilation_options: wgpu::PipelineCompilationOptions::default(),
 				targets: &[Some(wgpu::ColorTargetState {
-					format: OUTPUT_FORMAT,
+					format,
 					blend: Some(wgpu::BlendState::REPLACE),
 					write_mask: wgpu::ColorWrites::ALL,
 				})],

src/render/lines.rs

@@ -4,8 +4,6 @@ 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 {
@@ -51,7 +49,7 @@ pub struct Pipeline {
 }
 
 impl Pipeline {
-	pub fn new(device: &wgpu::Device) -> Self {
+	pub fn new(device: &wgpu::Device, format: wgpu::TextureFormat) -> Self {
 		let look_buf = device.create_buffer(&wgpu::BufferDescriptor {
 			label: None,
 			size: size_of::<LookParams>() as u64,
@@ -91,17 +89,7 @@ impl Pipeline {
 				topology: wgpu::PrimitiveTopology::LineList,
 				..Default::default()
 			},
-			depth_stencil: Some(wgpu::DepthStencilState {
+			depth_stencil: None,
-				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,
@@ -112,7 +100,7 @@ impl Pipeline {
 				entry_point: None,
 				compilation_options: wgpu::PipelineCompilationOptions::default(),
 				targets: &[Some(wgpu::ColorTargetState {
-					format: OUTPUT_FORMAT,
+					format,
 					blend: Some(wgpu::BlendState::REPLACE),
 					write_mask: wgpu::ColorWrites::ALL,
 				})],

src/render/mod.rs

@@ -2,6 +2,3 @@ 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, std::uint32_t width, std::uint32_t height);
+extern "C" Core* rt4_viewport_create(xcb_connection_t* connection, std::uint32_t window);
 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, std::uint32_t width, std::uint32_t height) {
+BoxCore BoxCore::from_xcb(xcb_connection_t* connection, std::uint32_t window) {
 	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, width, height);
+	out.ptr.ptr = ffi::rt4_viewport_create(connection, window);
 	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, std::uint32_t width, std::uint32_t height);
+	static BoxCore from_xcb(xcb_connection_t* connection, std::uint32_t window);
 
 private:
 	MutCore ptr;

ui/src/lib.rs

@@ -1,13 +1,12 @@
 use std::{ffi::c_void, num::NonZero, ptr::NonNull};
 
-use glam::{UVec2, uvec2};
+use glam::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(),
@@ -17,19 +16,17 @@ unsafe fn create_viewport(
 		instance.create_surface_unsafe(target)
 	}))
 	.unwrap();
-	Box::new(Core::new(gpu, size))
+	Box::new(Core::new(gpu))
 }
 
 #[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, uvec2(width, height)) }
+	unsafe { create_viewport(display, window) }
 }
 
 #[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, device_size.width(), device_size.height());
+	core = BoxCore::from_xcb(xcb_connection, x11_window);
+	updateSize();
 } catch (const std::exception& e) {
 	fprintf(stderr, "failed to recreate the viewport: %s", e.what());
 }