Blend!

src/bin/flat/main.rs

@@ -5,11 +5,10 @@ use flo_draw::*;
 use glam::*;
 
 use refraction::ifaces::{DebugTraceable, Traceable};
-use refraction::mathx::MatExt;
-use refraction::riemann::{trace_iter, Metric};
 use refraction::tube::metric::Tube;
 use refraction::tube::Space;
 use refraction::types::{Location, Object, Ray};
+use refraction::utils::put_object;
 use refraction::DT;
 
 fn draw_loop(gc: &mut Vec<Draw>, mut pts: impl Iterator<Item = Vec3>) {
@@ -147,83 +146,6 @@ pub fn main() {
 	});
 }
 
-fn rel_to_abs(space: &impl Metric, base: &Location, rel: Vec3, steps: usize) -> Vec3 {
-	let c = 1.0 / (steps as f32);
-	trace_iter(space, base.pos, base.rot * rel, c * rel.length())
-		.nth(steps - 1)
-		.unwrap()
-}
-
-/// Converts a position and a rotation to a [Location]. Only the X direction is preserved from `rot` to ensure the resulting Location describes an orthonormal coordinate system.
-fn put_object(space: &impl Metric, pos: Vec3, rot: Mat3) -> Location {
-	let metric_sqrt = space.sqrt_at(pos);
-	let metric_inv_sqrt = space.sqrt_at(pos).inverse();
-	let rot = metric_inv_sqrt * (metric_sqrt * rot).orthonormalize();
-	Location { pos, rot }
-}
-
-#[test]
-fn test_put_object() {
-	use approx::assert_abs_diff_eq;
-
-	let ε = 1e-5;
-	let m = refraction::riemann::samples::ScaledMetric {
-		scale: vec3(3., 4., 5.),
-	};
-
-	let loc = put_object(
-		&m,
-		vec3(1., 2., 0.),
-		mat3(vec3(1., 0., 0.), vec3(0., 1., 0.), vec3(0., 0., 1.)),
-	);
-	assert_eq!(loc.pos, vec3(1., 2., 0.));
-	assert_abs_diff_eq!(
-		loc.rot * vec3(1., 0., 0.),
-		vec3(1. / 3., 0., 0.),
-		epsilon = ε
-	);
-	assert_abs_diff_eq!(
-		loc.rot * vec3(0., 1., 0.),
-		vec3(0., 1. / 4., 0.),
-		epsilon = ε
-	);
-
-	let loc = put_object(
-		&m,
-		vec3(1., 2., 0.),
-		mat3(vec3(0., 1., 0.), vec3(-1., 0., 0.), vec3(0., 0., 1.)),
-	);
-	assert_eq!(loc.pos, vec3(1., 2., 0.));
-	assert_abs_diff_eq!(
-		loc.rot * vec3(1., 0., 0.),
-		vec3(0., 1. / 4., 0.),
-		epsilon = ε
-	);
-	assert_abs_diff_eq!(
-		loc.rot * vec3(0., 1., 0.),
-		vec3(-1. / 3., 0., 0.),
-		epsilon = ε
-	);
-
-	let c = 0.5 * std::f32::consts::SQRT_2;
-	let loc = put_object(
-		&m,
-		vec3(1., 2., 0.),
-		mat3(vec3(c, c, 0.), vec3(-c, c, 0.), vec3(0., 0., 1.)),
-	);
-	assert_eq!(loc.pos, vec3(1., 2., 0.));
-	assert_abs_diff_eq!(
-		loc.rot * vec3(1., 0., 0.),
-		vec3(1. / 5., 1. / 5., 0.),
-		epsilon = ε
-	);
-	assert_abs_diff_eq!(
-		loc.rot * vec3(0., 1., 0.),
-		vec3(-4. / 15., 3. / 20., 0.),
-		epsilon = ε
-	);
-}
-
 fn draw_cross(gc: &mut Vec<Draw>, pos: Vec2, r: f32) {
 	gc.move_to(pos.x - r, pos.y - r);
 	gc.line_to(pos.x + r, pos.y + r);

src/bin/wireframe/main.rs

@@ -1,11 +1,22 @@
+use std::{collections::HashSet, time::Instant};
+
 use glam::{mat4, vec2, vec3, vec4, Mat4, Quat, Vec2, Vec3};
 use glium::{
-	backend::glutin::SimpleWindowBuilder,
+	backend::{glutin::SimpleWindowBuilder, Facade},
-	implement_vertex, uniform,
+	glutin::config::ConfigTemplateBuilder,
+	implement_vertex,
+	index::PrimitiveType,
+	uniform,
 	winit::event::{Event, WindowEvent},
-	Program, Surface, VertexBuffer,
+	DrawParameters, Program, Surface, VertexBuffer,
 };
-use winit::{event::ElementState, event_loop::EventLoop};
+use winit::{
+	event::ElementState,
+	event_loop::EventLoop,
+	keyboard::{KeyCode, PhysicalKey},
+};
+
+mod scene;
 
 #[derive(Copy, Clone)]
 struct Vertex {
@@ -47,12 +58,56 @@ impl<S: Copy> DragCtl<S> {
 	}
 }
 
+struct Wireframe {
+	color: Vec3,
+	mode: PrimitiveType,
+	data: VertexBuffer<Vertex>,
+}
+
+fn prepare_scene(display: &impl Facade) -> Vec<Wireframe> {
+	scene::build()
+		.into_iter()
+		.map(|line| {
+			let color = line.color;
+			let mode;
+			let data: Vec<Vertex>;
+			match line.line {
+				scene::Line::Lines(_) => todo!(),
+				scene::Line::Strip(pts) => {
+					mode = PrimitiveType::LineStrip;
+					data = pts
+						.into_iter()
+						.map(|p| Vertex {
+							position: p.to_array(),
+						})
+						.collect();
+				}
+				scene::Line::Loop(pts) => {
+					mode = PrimitiveType::LineLoop;
+					data = pts
+						.into_iter()
+						.map(|p| Vertex {
+							position: p.to_array(),
+						})
+						.collect();
+				}
+			};
+			let data = VertexBuffer::new(display, &data).unwrap();
+			Wireframe { color, mode, data }
+		})
+		.collect()
+}
+
 fn main() {
 	let event_loop = EventLoop::builder().build().unwrap();
+	let cfg = ConfigTemplateBuilder::new().with_multisampling(8);
 	let (window, display) = SimpleWindowBuilder::new()
+		.with_config_template_builder(cfg)
 		.with_title("Refraction: Wireframe")
 		.build(&event_loop);
 
+	let mut keys_pressed = HashSet::<PhysicalKey>::new();
+
 	let vs_src = include_str!("ray.v.glsl");
 	let fs_src = include_str!("ray.f.glsl");
 	let program = Program::from_source(&display, vs_src, fs_src, None).unwrap();
@@ -80,31 +135,53 @@ fn main() {
 	];
 	let vertex_buffer = VertexBuffer::new(&display, &shape).unwrap();
 
-	let rot = Quat::from_euler(
+	let scene = prepare_scene(&display);
-		glam::EulerRot::YXZ,
+
-		std::f32::consts::FRAC_PI_4,
+	let rot = Quat::from_euler(glam::EulerRot::YXZ, std::f32::consts::FRAC_PI_4, 0., 0.);
-		std::f32::consts::FRAC_PI_6,
-		0.,
-	);
 	let mut cur_pos = vec2(0., 0.);
-	let mut cam_pos = DragCtl::new(rot * vec3(0., 0., 4.));
+	let mut cam_pos = rot * vec3(0., 1., -4.);
-	let mut cam_rot = DragCtl::new(rot.inverse());
+	let mut cam_rot = DragCtl::new(rot);
+
+	let mut t1 = Instant::now();
 
 	#[allow(deprecated)]
 	event_loop
 		.run(move |ev, window_target| match ev {
 			Event::WindowEvent { event, .. } => match event {
 				WindowEvent::RedrawRequested => {
+					let dt = {
+						let t2 = Instant::now();
+						let dt = t2 - t1;
+						t1 = t2;
+						dt.as_secs_f32()
+					};
+					let v: Vec3 = {
+						let ctl_left = keys_pressed.contains(&PhysicalKey::Code(KeyCode::KeyA));
+						let ctl_right = keys_pressed.contains(&PhysicalKey::Code(KeyCode::KeyD));
+						let ctl_fwd = keys_pressed.contains(&PhysicalKey::Code(KeyCode::KeyW));
+						let ctl_bwd = keys_pressed.contains(&PhysicalKey::Code(KeyCode::KeyS));
+						[
+							(ctl_left, vec3(-1., 0., 0.)),
+							(ctl_right, vec3(1., 0., 0.)),
+							(ctl_fwd, vec3(0., 0., 1.)),
+							(ctl_bwd, vec3(0., 0., -1.)),
+						]
+						.into_iter()
+						.filter_map(|(ctl, dir)| ctl.then_some(dir))
+						.sum()
+					};
+					cam_pos += 5. * dt * (cam_rot.state() * v);
+
 					let size = window.inner_size();
 					let size = vec2(size.width as f32, size.height as f32).normalize()
 						* std::f32::consts::SQRT_2;
 					let proj = make_proj_matrix(vec3(size.x, size.y, 2.), (0.125, 1024.125));
 
-					let view =
+					let view = Mat4::from_quat(cam_rot.state().inverse())
-						Mat4::from_quat(cam_rot.state()) * Mat4::from_translation(cam_pos.state());
+						* Mat4::from_translation(-cam_pos);
 
 					let mut target = display.draw();
-					target.clear_color(0.0, 0.0, 0.2, 1.0);
+					target.clear_color(0.0, 0.0, 0.0, 0.0);
 
 					let mvp = proj * view;
 					let uniforms = uniform! {
@@ -120,6 +197,32 @@ fn main() {
 							&Default::default(),
 						)
 						.unwrap();
+					let params = DrawParameters {
+						blend: glium::Blend {
+							color: glium::BlendingFunction::Addition {
+								source: glium::LinearBlendingFactor::One,
+								destination: glium::LinearBlendingFactor::OneMinusSourceAlpha,
+							},
+							alpha: glium::BlendingFunction::Addition {
+								source: glium::LinearBlendingFactor::One,
+								destination: glium::LinearBlendingFactor::OneMinusSourceAlpha,
+							},
+							constant_value: (0., 0., 0., 0.),
+						},
+						line_width: Some(3.),
+						smooth: Some(glium::Smooth::Nicest),
+						..Default::default()
+					};
+					for mesh in &scene {
+						let uniforms = uniform! {
+							mvp: mvp.to_cols_array_2d(),
+							color: mesh.color.to_array(),
+						};
+						let indices = glium::index::NoIndices(mesh.mode);
+						target
+							.draw(&mesh.data, &indices, &program, &uniforms, &params)
+							.unwrap();
+					}
 					target.finish().unwrap();
 				}
 
@@ -128,7 +231,6 @@ fn main() {
 					state,
 					button,
 				} => match button {
-					winit::event::MouseButton::Left => cam_pos.on_button(cur_pos, state),
 					winit::event::MouseButton::Right => cam_rot.on_button(cur_pos, state),
 					_ => {}
 				},
@@ -140,16 +242,23 @@ fn main() {
 					let size = window.inner_size();
 					let size = vec2(size.width as f32, size.height as f32);
 					cur_pos = vec2(position.x as f32, position.y as f32) / size.length();
-					cam_pos.on_move(cur_pos, |init, off| {
-						window.request_redraw();
-						init + 4. * (cam_rot.state().inverse() * vec3(off.x, -off.y, 0.))
-					});
 					cam_rot.on_move(cur_pos, |init, off| {
 						window.request_redraw();
-						Quat::from_euler(glam::EulerRot::YXZ, 5. * off.x, 5. * off.y, 0.) * init
+						init * Quat::from_euler(glam::EulerRot::YXZ, -2. * off.x, -2. * off.y, 0.)
 					});
 				}
 
+				WindowEvent::KeyboardInput {
+					device_id: _,
+					event,
+					is_synthetic: _,
+				} => {
+					match event.state {
+						ElementState::Pressed => keys_pressed.insert(event.physical_key),
+						ElementState::Released => keys_pressed.remove(&event.physical_key),
+					};
+				}
+
 				WindowEvent::Resized(window_size) => {
 					display.resize(window_size.into());
 				}

src/bin/wireframe/ray.f.glsl

@@ -5,5 +5,6 @@ in vec3 vertex_color;
 out vec4 color;
 
 void main() {
-	color = vec4(vertex_color, 1.0);
+	float opacity = pow(0.5 - 0.5 * gl_FragCoord.z, 0.25);
+	color = opacity * vec4(vertex_color, 1.0);
 }

src/bin/wireframe/ray.v.glsl

@@ -8,6 +8,6 @@ in vec3 position;
 out vec3 vertex_color;
 
 void main() {
-	vertex_color = position;
+	vertex_color = color;
 	gl_Position = mvp * vec4(position, 1.0);
 }

src/bin/wireframe/scene.rs

@@ -0,0 +1,129 @@
+use glam::*;
+
+use refraction::ifaces::{DebugTraceable, Traceable};
+use refraction::tube::metric::Tube;
+use refraction::tube::Space;
+use refraction::types::{Location, Object, Ray};
+use refraction::utils::put_object;
+
+pub enum Line {
+	Lines(Vec<(Vec3, Vec3)>),
+	Strip(Vec<Vec3>),
+	Loop(Vec<Vec3>),
+}
+
+pub struct FancyLine {
+	pub color: Vec3,
+	pub line: Line,
+}
+
+fn paint(onto: &mut Vec<FancyLine>, color: Vec3, lines: Vec<Line>) {
+	onto.extend(lines.into_iter().map(move |line| FancyLine { color, line }))
+}
+
+fn draw_rect(center: Vec3, u: Vec3, v: Vec3) -> Line {
+	Line::Loop(vec![
+		center - u - v,
+		center + u - v,
+		center + u + v,
+		center - u + v,
+	])
+}
+
+pub fn build() -> Vec<FancyLine> {
+	let tube = Tube {
+		inner_radius: 30.0,
+		outer_radius: 50.0,
+		internal_halflength: 100.0,
+		external_halflength: 300.0,
+	};
+
+	let objs: Vec<_> = [-1.25, -1.00, -0.85, -0.50, 0.00, 0.40, 0.70, 0.95, 1.05]
+		.iter()
+		.enumerate()
+		.map(|(k, &y)| Object {
+			id: k as i32,
+			loc: put_object(
+				&tube,
+				vec3(0.0, y * tube.external_halflength, 0.0),
+				Mat3::from_mat2(Mat2::from_angle(y)),
+			),
+			r: 20.0,
+		})
+		.collect();
+	let space = Space { tube, objs };
+	let cam1 = put_object(&space.tube, vec3(-500., 0., 0.), Mat3::IDENTITY);
+	let cam2 = put_object(
+		&space.tube,
+		vec3(
+			-2.5 * tube.outer_radius,
+			1.25 * tube.external_halflength,
+			0.,
+		),
+		mat3(vec3(1., -1., 0.), vec3(1., 1., 0.), vec3(0., 0., 1.)),
+	);
+	let cam3 = put_object(
+		&space.tube,
+		vec3(
+			0.25 * tube.inner_radius,
+			0.25 * tube.external_halflength,
+			0.,
+		),
+		mat3(vec3(0., -1., 0.), vec3(1., 0., 0.), vec3(0., 0., 1.)),
+	);
+
+	let mut gc = vec![];
+	paint(&mut gc, vec3(0.8, 0.8, 0.8), tube.render());
+	paint(&mut gc, vec3(0.0, 0.8, 1.0), draw_fan_2(&space, cam3, 1.0));
+	paint(&mut gc, vec3(0.5, 1.0, 0.0), draw_fan_2(&space, cam2, 1.0));
+	paint(&mut gc, vec3(1.0, 0.5, 0.0), draw_fan_2(&space, cam1, 1.0));
+	gc
+}
+
+fn draw_ray_2(gc: &mut Vec<Line>, space: &Space, camera: Location, dir: Vec3) {
+	let pos = vec3(0., 0., 0.);
+	let (hits, path) = space.trace_dbg(camera, Ray { pos, dir });
+	let hits2 = space.trace(camera, Ray { pos, dir });
+	for (a, b) in hits.into_iter().zip(hits2.into_iter()) {
+		assert_eq!(a.id, b.id);
+		assert_eq!(a.pos, b.pos);
+		assert_eq!(a.rel, b.rel);
+	}
+
+	let mut pts = path.points;
+	let end_pos = *pts
+		.last()
+		.expect("the starting point is always in the path");
+	let dir_pos = end_pos + 1000.0 * path.end_dir;
+	pts.push(dir_pos);
+	gc.push(Line::Strip(pts));
+}
+
+fn draw_fan_2(space: &Space, camera: Location, spread: f32) -> Vec<Line> {
+	let mut gc = vec![];
+	for y in itertools_num::linspace(-spread, spread, 101) {
+		draw_ray_2(&mut gc, space, camera, vec3(1., y, 0.));
+	}
+	gc
+}
+
+trait Renderable {
+	fn render(&self) -> Vec<Line>;
+}
+
+impl Renderable for Tube {
+	fn render(&self) -> Vec<Line> {
+		vec![
+			draw_rect(
+				vec3(0., 0., 0.),
+				vec3(self.outer_radius, 0., 0.),
+				vec3(0., self.external_halflength, 0.),
+			),
+			draw_rect(
+				vec3(0., 0., 0.),
+				vec3(self.inner_radius, 0., 0.),
+				vec3(0., self.external_halflength, 0.),
+			),
+		]
+	}
+}

src/lib.rs

@@ -6,5 +6,6 @@ pub mod mesh_tracer;
 pub mod riemann;
 pub mod tube;
 pub mod types;
+pub mod utils;
 
 pub const DT: f32 = 0.1;

src/utils.rs

@@ -0,0 +1,90 @@
+use crate::{
+	mathx::MatExt as _,
+	riemann::{trace_iter, Metric},
+	types::Location,
+};
+use glam::{Mat3, Vec3};
+
+pub fn rel_to_abs(space: &impl Metric, base: &Location, rel: Vec3, steps: usize) -> Vec3 {
+	let c = 1.0 / (steps as f32);
+	trace_iter(space, base.pos, base.rot * rel, c * rel.length())
+		.nth(steps - 1)
+		.unwrap()
+}
+
+/// Converts a position and a rotation to a [Location]. Only the X direction is preserved from `rot` to ensure the resulting Location describes an orthonormal coordinate system.
+pub fn put_object(space: &impl Metric, pos: Vec3, rot: Mat3) -> Location {
+	let metric_sqrt = space.sqrt_at(pos);
+	let metric_inv_sqrt = space.sqrt_at(pos).inverse();
+	let rot = metric_inv_sqrt * (metric_sqrt * rot).orthonormalize();
+	Location { pos, rot }
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::riemann::samples;
+	use glam::{mat3, vec3};
+
+	#[test]
+	fn test_put_object() {
+		use approx::assert_abs_diff_eq;
+
+		let ε = 1e-5;
+		let m = samples::ScaledMetric {
+			scale: vec3(3., 4., 5.),
+		};
+
+		let loc = put_object(
+			&m,
+			vec3(1., 2., 0.),
+			mat3(vec3(1., 0., 0.), vec3(0., 1., 0.), vec3(0., 0., 1.)),
+		);
+		assert_eq!(loc.pos, vec3(1., 2., 0.));
+		assert_abs_diff_eq!(
+			loc.rot * vec3(1., 0., 0.),
+			vec3(1. / 3., 0., 0.),
+			epsilon = ε
+		);
+		assert_abs_diff_eq!(
+			loc.rot * vec3(0., 1., 0.),
+			vec3(0., 1. / 4., 0.),
+			epsilon = ε
+		);
+
+		let loc = put_object(
+			&m,
+			vec3(1., 2., 0.),
+			mat3(vec3(0., 1., 0.), vec3(-1., 0., 0.), vec3(0., 0., 1.)),
+		);
+		assert_eq!(loc.pos, vec3(1., 2., 0.));
+		assert_abs_diff_eq!(
+			loc.rot * vec3(1., 0., 0.),
+			vec3(0., 1. / 4., 0.),
+			epsilon = ε
+		);
+		assert_abs_diff_eq!(
+			loc.rot * vec3(0., 1., 0.),
+			vec3(-1. / 3., 0., 0.),
+			epsilon = ε
+		);
+
+		let c = 0.5 * std::f32::consts::SQRT_2;
+		let loc = put_object(
+			&m,
+			vec3(1., 2., 0.),
+			mat3(vec3(c, c, 0.), vec3(-c, c, 0.), vec3(0., 0., 1.)),
+		);
+		assert_eq!(loc.pos, vec3(1., 2., 0.));
+		assert_abs_diff_eq!(
+			loc.rot * vec3(1., 0., 0.),
+			vec3(1. / 5., 1. / 5., 0.),
+			epsilon = ε
+		);
+		assert_abs_diff_eq!(
+			loc.rot * vec3(0., 1., 0.),
+			vec3(-4. / 15., 3. / 20., 0.),
+			epsilon = ε
+		);
+	}
+}