src/bin/flat/main.rs

@@ -5,10 +5,11 @@ 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>) {
@@ -146,6 +147,83 @@ 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,22 +1,11 @@
-use std::{collections::HashSet, time::Instant};
-
 use glam::{mat4, vec2, vec3, vec4, Mat4, Quat, Vec2, Vec3};
 use glium::{
-	backend::{glutin::SimpleWindowBuilder, Facade},
+	backend::glutin::SimpleWindowBuilder,
-	glutin::config::ConfigTemplateBuilder,
+	implement_vertex, uniform,
-	implement_vertex,
-	index::PrimitiveType,
-	uniform,
 	winit::event::{Event, WindowEvent},
-	DrawParameters, Program, Surface, VertexBuffer,
+	Program, Surface, VertexBuffer,
 };
-use winit::{
+use winit::{event::ElementState, event_loop::EventLoop};
-	event::ElementState,
-	event_loop::EventLoop,
-	keyboard::{KeyCode, PhysicalKey},
-};
-
-mod scene;
 
 #[derive(Copy, Clone)]
 struct Vertex {
@@ -58,56 +47,12 @@ 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();
@@ -135,53 +80,31 @@ fn main() {
 	];
 	let vertex_buffer = VertexBuffer::new(&display, &shape).unwrap();
 
-	let scene = prepare_scene(&display);
+	let rot = Quat::from_euler(
-
+		glam::EulerRot::YXZ,
-	let rot = Quat::from_euler(glam::EulerRot::YXZ, std::f32::consts::FRAC_PI_4, 0., 0.);
+		std::f32::consts::FRAC_PI_4,
+		std::f32::consts::FRAC_PI_6,
+		0.,
+	);
 	let mut cur_pos = vec2(0., 0.);
-	let mut cam_pos = rot * vec3(0., 1., -4.);
+	let mut cam_pos = DragCtl::new(rot * vec3(0., 0., 4.));
-	let mut cam_rot = DragCtl::new(rot);
+	let mut cam_rot = DragCtl::new(rot.inverse());
-
-	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 = Mat4::from_quat(cam_rot.state().inverse())
+					let view =
-						* Mat4::from_translation(-cam_pos);
+						Mat4::from_quat(cam_rot.state()) * Mat4::from_translation(cam_pos.state());
 
 					let mut target = display.draw();
-					target.clear_color(0.0, 0.0, 0.0, 0.0);
+					target.clear_color(0.0, 0.0, 0.2, 1.0);
 
 					let mvp = proj * view;
 					let uniforms = uniform! {
@@ -197,32 +120,6 @@ 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();
 				}
 
@@ -231,6 +128,7 @@ 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),
 					_ => {}
 				},
@@ -242,23 +140,16 @@ 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();
-						init * Quat::from_euler(glam::EulerRot::YXZ, -2. * off.x, -2. * off.y, 0.)
+						Quat::from_euler(glam::EulerRot::YXZ, 5. * off.x, 5. * off.y, 0.) * init
 					});
 				}
 
-				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,6 +5,5 @@ in vec3 vertex_color;
 out vec4 color;
 
 void main() {
-	float opacity = pow(0.5 - 0.5 * gl_FragCoord.z, 0.25);
+	color = vec4(vertex_color, 1.0);
-	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 = color;
+	vertex_color = position;
 	gl_Position = mvp * vec4(position, 1.0);
 }

src/bin/wireframe/scene.rs

@@ -1,129 +0,0 @@
-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,6 +6,5 @@ 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

@@ -1,90 +0,0 @@
-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 = ε
-		);
-	}
-}