src/bin/wireframe/main.rs

@@ -10,7 +10,6 @@ use winit::{
 
 mod camera;
 mod lines;
-mod meshes;
 mod scene;
 mod viewport;
 
@@ -19,17 +18,11 @@ mod viewport;
 // * Y: left
 // * Z: up
 
-fn prepare_scene(device: &wgpu::Device) -> (Vec<meshes::Mesh>, Vec<lines::Line>) {
+fn prepare_scene(device: &wgpu::Device) -> Vec<lines::Line> {
-	let (meshes, lines) = scene::build();
+	scene::build()
-	let meshes = meshes
-		.into_iter()
-		.map(|mesh| meshes::Mesh::new_list(device, meshes::Attrs { color: mesh.color }, mesh.tris))
-		.collect();
-	let lines = lines
 		.into_iter()
 		.map(|line| lines::Line::new_strip(device, lines::Attrs { color: line.color }, line.pts))
-		.collect();
+		.collect()
-	(meshes, lines)
 }
 
 #[cfg(any())]
@@ -167,10 +160,8 @@ struct State<'a> {
 	cam_loc: camctl::CameraLocation,
 	cam_obj: camera::Camera,
 	line_rend: lines::LineRenderer,
-	mesh_rend: meshes::Renderer,
 
-	lines: Vec<lines::Line>,
+	scene: Vec<lines::Line>,
-	meshes: Vec<meshes::Mesh>,
 
 	window: &'a Window,
 }
@@ -215,43 +206,17 @@ impl<'a> State<'a> {
 		let cam_loc = camctl::CameraLocation::new();
 		let t1 = Instant::now();
 
-		let cam_obj = camera::Camera::new(&device);
+		let depth = None;
-		let line_rend = lines::LineRenderer::new(
+		let msaa = wgpu::MultisampleState {
-			&device,
-			cam_obj.bind_group_layout(),
-			viewport.format(),
-			Some(wgpu::DepthStencilState {
-				format: wgpu::TextureFormat::Depth24Plus,
-				depth_write_enabled: false,
-				depth_compare: wgpu::CompareFunction::LessEqual,
-				stencil: wgpu::StencilState::default(),
-				bias: wgpu::DepthBiasState::default(),
-			}),
-			wgpu::MultisampleState {
 			count: viewport.sample_count(),
 			mask: !0,
 			alpha_to_coverage_enabled: false,
-			},
+		};
-		);
-		let mesh_rend = meshes::Renderer::new(
-			&device,
-			cam_obj.bind_group_layout(),
-			viewport.format(),
-			Some(wgpu::DepthStencilState {
-				format: wgpu::TextureFormat::Depth24Plus,
-				depth_write_enabled: true,
-				depth_compare: wgpu::CompareFunction::LessEqual,
-				stencil: wgpu::StencilState::default(),
-				bias: wgpu::DepthBiasState::default(),
-			}),
-			wgpu::MultisampleState {
-				count: viewport.sample_count(),
-				mask: !0,
-				alpha_to_coverage_enabled: false,
-			},
-		);
 
-		let (meshes, lines) = prepare_scene(&device);
+		let cam_obj = camera::Camera::new(&device);
+		let line_rend = lines::LineRenderer::new(&device, cam_obj.bind_group_layout(), viewport.format(), depth, msaa);
+
+		let scene = prepare_scene(&device);
 
 		let fps = fps::Counter::new();
 
@@ -260,14 +225,12 @@ impl<'a> State<'a> {
 			queue,
 			viewport,
 			line_rend,
-			mesh_rend,
 			kbd,
 			fps,
 			cam_loc,
 			cam_obj,
 			t1,
-			lines,
+			scene,
-			meshes,
 			window,
 		}
 	}
@@ -303,10 +266,8 @@ impl<'a> State<'a> {
 			.set_title(&format!("Space Refraction ({:.1} FPS)", self.fps.get()));
 		self.viewport
 			.render_single_pass(&self.device, &self.queue, |mut render_pass| {
-				self.mesh_rend
-					.render(&mut render_pass, self.cam_obj.bind_group(), self.meshes.iter());
 				self.line_rend
-					.render(&mut render_pass, self.cam_obj.bind_group(), self.lines.iter());
+					.render(&mut render_pass, self.cam_obj.bind_group(), self.scene.iter());
 			})
 	}
 }

src/bin/wireframe/mesh.wgsl

@@ -1,63 +0,0 @@
-struct CameraUniform {
-	mvp: mat4x4<f32>,
-	scale: vec2<f32>,
-}
-@group(0) @binding(0)
-var<uniform> camera: CameraUniform;
-
-struct MeshUniform {
-	color: vec4<f32>,
-}
-var<push_constant> mesh: MeshUniform;
-
-struct VertexInput {
-	@location(0) position: vec3<f32>,
-	@location(1) normal: vec3<f32>,
-}
-
-struct VertexOutput {
-	@builtin(position) clip_position: vec4<f32>,
-	@location(0) vertex_color: vec4<f32>,
-}
-
-struct FragmentOutput {
-	@location(0) color: vec4<f32>,
-	@builtin(sample_mask) mask: u32,
-}
-
-fn hash(key : u32) -> u32 {
-	var v = key;
-	v *= 0xb384af1bu;
-	v ^= v >> 15u;
-	return v;
-}
-
-@vertex
-fn vs_main(ver: VertexInput) -> VertexOutput {
-	var out: VertexOutput;
-	var light = dot(ver.normal, normalize(vec3(1., 1., 1.)));
-	light = .7 + .3 * light;
-	out.vertex_color = vec4(light * mesh.color.xyz, mesh.color.w);
-	out.clip_position = camera.mvp * vec4(ver.position, 1.);
-	return out;
-}
-
-@fragment
-fn fs_main(in: VertexOutput) -> FragmentOutput {
-	var out: FragmentOutput;
-	out.color = vec4(in.vertex_color.xyz, 1.);
-	var x = bitcast<u32>(in.clip_position.x);
-	var y = bitcast<u32>(in.clip_position.y);
-	var z = bitcast<u32>(in.clip_position.z);
-	var alpha = in.vertex_color.w;
-	var seed = hash(hash(hash(x) ^ y) ^ z);
-	var mask = 0u;
-	for (var sample = 0u; sample < 8u; sample++) {
-		var threshold = f32(hash(seed ^ sample)) / 0x1p32;
-		if (alpha > threshold) {
-			mask |= 1u << sample;
-		}
-	}
-	out.mask = mask;
-	return out;
-}

src/bin/wireframe/meshes.rs

@@ -1,168 +0,0 @@
-use std::mem;
-
-use bytemuck::{bytes_of, cast_slice, Pod, Zeroable};
-use glam::{Vec3, Vec4};
-use wgpu::util::DeviceExt as _;
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Pod, Zeroable)]
-struct Vertex {
-	pub position: [f32; 3],
-	pub normal: [f32; 3],
-}
-
-#[repr(C)]
-#[derive(Copy, Clone, Pod, Zeroable)]
-struct PushConsts {
-	pub color: [f32; 4],
-}
-
-#[derive(Copy, Clone)]
-pub struct Attrs {
-	pub color: Vec4,
-}
-
-impl Attrs {
-	fn consts(&self) -> PushConsts {
-		PushConsts {
-			color: self.color.to_array(),
-		}
-	}
-}
-
-pub struct Mesh {
-	consts: PushConsts,
-	npoints: u32,
-	buf: wgpu::Buffer,
-}
-
-impl Mesh {
-	pub fn new_list(device: &wgpu::Device, attrs: Attrs, tris: Vec<(Vec3, Vec3, Vec3)>) -> Self {
-		let data: Vec<Vertex> = tris
-			.into_iter()
-			.flat_map(|(a, b, c)| {
-				let n = (b - a).cross(c - a).normalize();
-				[
-					Vertex {
-						position: a.into(),
-						normal: n.into(),
-					},
-					Vertex {
-						position: b.into(),
-						normal: n.into(),
-					},
-					Vertex {
-						position: c.into(),
-						normal: n.into(),
-					},
-				]
-			})
-			.collect();
-		let buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
-			label: Some("Mesh Vertex Buffer"),
-			contents: cast_slice(&data),
-			usage: wgpu::BufferUsages::VERTEX,
-		});
-		Mesh {
-			consts: attrs.consts(),
-			npoints: data.len() as u32,
-			buf,
-		}
-	}
-}
-
-pub struct Renderer {
-	pipeline: wgpu::RenderPipeline,
-}
-
-static SHADER: &'static str = include_str!("mesh.wgsl");
-
-impl Renderer {
-	pub fn new(
-		device: &wgpu::Device,
-		cam_layout: &wgpu::BindGroupLayout,
-		target_format: wgpu::TextureFormat,
-		depth_stencil: Option<wgpu::DepthStencilState>,
-		multisample: wgpu::MultisampleState,
-	) -> Renderer {
-		let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
-			label: Some("Mesh Shader"),
-			source: wgpu::ShaderSource::Wgsl(SHADER.into()),
-		});
-
-		let consts_range = wgpu::PushConstantRange {
-			stages: wgpu::ShaderStages::VERTEX,
-			range: 0..mem::size_of::<PushConsts>() as u32,
-		};
-
-		let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
-			label: Some("Mesh RenderPipelineLayout"),
-			bind_group_layouts: &[cam_layout],
-			push_constant_ranges: &[consts_range],
-		});
-
-		let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
-			label: Some("Mesh RenderPipeline"),
-			layout: Some(&layout),
-			vertex: wgpu::VertexState {
-				module: &shader,
-				entry_point: "vs_main",
-				buffers: &[wgpu::VertexBufferLayout {
-					array_stride: mem::size_of::<Vertex>() as wgpu::BufferAddress,
-					step_mode: wgpu::VertexStepMode::Vertex,
-					attributes: &[
-						wgpu::VertexAttribute {
-							offset: mem::offset_of!(Vertex, position) as u64,
-							shader_location: 0,
-							format: wgpu::VertexFormat::Float32x3,
-						},
-						wgpu::VertexAttribute {
-							offset: mem::offset_of!(Vertex, normal) as u64,
-							shader_location: 1,
-							format: wgpu::VertexFormat::Float32x3,
-						},
-					],
-				}],
-				compilation_options: Default::default(),
-			},
-			fragment: Some(wgpu::FragmentState {
-				module: &shader,
-				entry_point: "fs_main",
-				targets: &[Some(wgpu::ColorTargetState {
-					format: target_format,
-					blend: Some(wgpu::BlendState {
-						color: wgpu::BlendComponent::OVER,
-						alpha: wgpu::BlendComponent::OVER,
-					}),
-					write_mask: wgpu::ColorWrites::ALL,
-				})],
-				compilation_options: Default::default(),
-			}),
-			primitive: wgpu::PrimitiveState {
-				topology: wgpu::PrimitiveTopology::TriangleList,
-				..Default::default()
-			},
-			depth_stencil,
-			multisample,
-			multiview: None,
-			cache: None,
-		});
-
-		Renderer { pipeline }
-	}
-
-	pub fn render<'a>(
-		&self,
-		pass: &mut wgpu::RenderPass,
-		cam_bind: &wgpu::BindGroup,
-		meshes: impl Iterator<Item = &'a Mesh>,
-	) {
-		pass.set_pipeline(&self.pipeline);
-		pass.set_bind_group(0, cam_bind, &[]);
-		for mesh in meshes {
-			pass.set_push_constants(wgpu::ShaderStages::VERTEX, 0, bytes_of(&mesh.consts));
-			pass.set_vertex_buffer(0, mesh.buf.slice(..));
-			pass.draw(0..mesh.npoints, 0..1);
-		}
-	}
-}

src/bin/wireframe/scene.rs

@@ -1,5 +1,5 @@
 use glam::*;
-use itertools::chain;
+use itertools::{chain, iproduct};
 
 use refraction::ifaces::{DebugTraceable, Traceable};
 use refraction::tube::metric::Tube;
@@ -17,17 +17,6 @@ pub struct FancyLine {
 	pub pts: Vec<Ray>,
 }
 
-pub type Face = (Vec3, Vec3, Vec3);
-
-pub enum Mesh {
-	List(Vec<Face>),
-}
-
-pub struct FancyMesh {
-	pub color: Vec4,
-	pub tris: Vec<Face>,
-}
-
 fn paint(onto: &mut Vec<FancyLine>, color: Vec3, lines: Vec<Line>) {
 	onto.extend(lines.into_iter().map(move |line| FancyLine {
 		color,
@@ -46,6 +35,29 @@ fn draw_line(a: Vec3, b: Vec3) -> Line {
 	Line::Strip(vec![Ray { pos: a, dir }, Ray { pos: b, dir }])
 }
 
+fn draw_rect(center: Vec3, u: Vec3, v: Vec3) -> Vec<Line> {
+	let a = center - u - v;
+	let b = center + u - v;
+	let c = center + u + v;
+	let d = center - u + v;
+	vec![draw_line(a, b), draw_line(b, c), draw_line(c, d), draw_line(d, a)]
+}
+
+fn draw_ellipse(center: Vec3, u: Vec3, v: Vec3) -> Line {
+	let segments = 47;
+	let step = 2. * std::f32::consts::PI / segments as f32;
+	Line::Loop(
+		(0..segments)
+			.map(|k| k as f32 * step)
+			.map(Vec2::from_angle)
+			.map(|d| Ray {
+				pos: center + d.x * u + d.y * v,
+				dir: -d.y * u + d.x * v,
+			})
+			.collect(),
+	)
+}
+
 fn draw_mark(pos: Vec3) -> Vec<Line> {
 	[
 		vec3(1., 1., 1.),
@@ -58,7 +70,7 @@ fn draw_mark(pos: Vec3) -> Vec<Line> {
 	.collect()
 }
 
-pub fn build() -> (Vec<FancyMesh>, Vec<FancyLine>) {
+pub fn build() -> Vec<FancyLine> {
 	let tube = Tube {
 		inner_radius: 30.0,
 		outer_radius: 50.0,
@@ -98,13 +110,7 @@ pub fn build() -> (Vec<FancyMesh>, Vec<FancyLine>) {
 	);
 
 	let mut gc = vec![];
-	gc.push(FancyMesh {
+	paint(&mut gc, vec3(0.6, 0.6, 0.6), tube.render());
-		color: vec4(0.10, 0.12, 0.15, 0.8),
-		tris: tube.render(),
-	});
-	let meshes = gc;
-
-	let mut gc = vec![];
 	paint(&mut gc, vec3(0.0, 0.6, 1.0), draw_fan_2(&space, cam3, vec3(0., 1., 0.)));
 	paint(&mut gc, vec3(0.2, 1.0, 0.0), draw_fan_2(&space, cam2, vec3(0., 1., 0.)));
 	paint(
@@ -113,9 +119,7 @@ pub fn build() -> (Vec<FancyMesh>, Vec<FancyLine>) {
 		draw_fan_2(&space, cam2l, vec3(0., 0., 1.)),
 	);
 	paint(&mut gc, vec3(1.0, 0.2, 0.0), draw_fan_2(&space, cam1, vec3(0., 1., 0.)));
-	let lines = gc;
+	gc
-
-	(meshes, lines)
 }
 
 fn draw_ray_2(gc: &mut Vec<Line>, space: &Space, camera: Location, dir: Vec3) {
@@ -149,42 +153,23 @@ fn draw_fan_2(space: &Space, camera: Location, spread: Vec3) -> Vec<Line> {
 }
 
 trait Renderable {
-	fn render(&self) -> Vec<Face>;
+	fn render(&self) -> Vec<Line>;
 }
 
 impl Renderable for Tube {
-	fn render(&self) -> Vec<Face> {
+	fn render(&self) -> Vec<Line> {
-		let sides = 42;
+		let lines = 4;
-		let step = 2. * std::f32::consts::PI / sides as f32;
+		let step = 2. * std::f32::consts::PI / lines as f32;
-		let dir = |k| {
+		let r = 0.5 * (self.outer_radius + self.inner_radius);
-			let d = Vec2::from_angle(k as f32 * step);
+		let w = 0.5 * (self.outer_radius - self.inner_radius);
-			vec3(d.x, 0., d.y)
+		let l = vec3(0., self.external_halflength, 0.);
-		};
+		let along = (0..lines)
-		let side = vec3(0., self.external_halflength, 0.);
+			.map(|k| k as f32 * step)
-		let r1 = self.inner_radius;
+			.map(Vec2::from_angle)
-		let r2 = self.outer_radius;
+			.map(|d| vec3(d.x, 0., d.y))
-		let inner = (0..sides).flat_map(|k| {
+			.flat_map(|d| draw_rect(r * d, w * d, l));
-			let a = r1 * dir(k);
+		let caps = iproduct!([self.inner_radius, self.outer_radius], [-l, l])
-			let b = r1 * dir(k + 1);
+			.map(|(r, l)| draw_ellipse(l, vec3(r, 0., 0.), vec3(0., 0., r)));
-			[(a - side, b - side, a + side), (b - side, b + side, a + side)]
+		chain!(along, caps).collect()
-		});
-		let outer = (0..sides).flat_map(|k| {
-			let a = r2 * dir(k);
-			let b = r2 * dir(k + 1);
-			[(a - side, b - side, a + side), (b - side, b + side, a + side)]
-		});
-		let cap = (0..sides).flat_map(|k| {
-			let a = r1 * dir(k);
-			let b = r1 * dir(k + 1);
-			let c = r2 * dir(k + 1);
-			let d = r2 * dir(k);
-			[
-				(a - side, b - side, c - side),
-				(a - side, c - side, d - side),
-				(a + side, b + side, c + side),
-				(a + side, c + side, d + side),
-			]
-		});
-		chain!(inner, outer, cap).collect()
 	}
 }

src/bin/wireframe/viewport.rs

@@ -75,7 +75,7 @@ impl<'a> Viewport<'a> {
 		let render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
 			label: Some("RenderPass"),
 			color_attachments: &[Some(wgpu::RenderPassColorAttachment {
-				view: &self.multisample.color,
+				view: &self.multisample.view,
 				resolve_target: Some(&view),
 				ops: wgpu::Operations {
 					load: wgpu::LoadOp::Clear(wgpu::Color {
@@ -87,14 +87,7 @@ impl<'a> Viewport<'a> {
 					store: wgpu::StoreOp::Store,
 				},
 			})],
-			depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
+			depth_stencil_attachment: None,
-				view: &self.multisample.depth,
-				depth_ops: Some(wgpu::Operations {
-					load: wgpu::LoadOp::Clear(1.),
-					store: wgpu::StoreOp::Discard,
-				}),
-				stencil_ops: None,
-			}),
 			occlusion_query_set: None,
 			timestamp_writes: None,
 		});
@@ -106,14 +99,13 @@ impl<'a> Viewport<'a> {
 }
 
 struct Multisample {
-	color: wgpu::TextureView,
+	view: wgpu::TextureView,
-	depth: wgpu::TextureView,
 }
 
 impl Multisample {
 	fn new(device: &wgpu::Device, format: wgpu::TextureFormat, size: UVec2, sample_count: u32) -> Multisample {
-		let color = device.create_texture(&wgpu::TextureDescriptor {
+		let tex = device.create_texture(&wgpu::TextureDescriptor {
-			label: Some("Multisample color texture"),
+			label: Some("Multisample texture"),
 			size: wgpu::Extent3d {
 				width: size.x,
 				height: size.y,
@@ -126,22 +118,7 @@ impl Multisample {
 			usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
 			view_formats: &[],
 		});
-		let color = color.create_view(&wgpu::TextureViewDescriptor::default());
+		let view = tex.create_view(&wgpu::TextureViewDescriptor::default());
-		let depth = device.create_texture(&wgpu::TextureDescriptor {
+		Multisample { view }
-			label: Some("Multisample depth texture"),
-			size: wgpu::Extent3d {
-				width: size.x,
-				height: size.y,
-				depth_or_array_layers: 1,
-			},
-			mip_level_count: 1,
-			sample_count,
-			dimension: wgpu::TextureDimension::D2,
-			format: wgpu::TextureFormat::Depth24Plus,
-			usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
-			view_formats: &[],
-		});
-		let depth = depth.create_view(&wgpu::TextureViewDescriptor::default());
-		Multisample { color, depth }
 	}
 }