rustfmt.toml

@@ -1,2 +1 @@
 hard_tabs = true
-max_width = 120

src/bin/flat/main.rs

@@ -52,12 +52,20 @@ pub fn main() {
 			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.),
+				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.),
+				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.)),
 			);
 
@@ -126,7 +134,11 @@ pub fn main() {
 							let dir = Vec2::from_angle(φ);
 							let dir = vec3(dir.x, dir.y, 0.);
 							let dir = obj.loc.rot * dir * d;
-							space.trace_iter(Ray { pos, dir }).nth(n as usize).unwrap().pos
+							space
+								.trace_iter(Ray { pos, dir })
+								.nth(n as usize)
+								.unwrap()
+								.pos
 						}),
 				);
 			}
@@ -157,7 +169,10 @@ fn draw_ray_2(gc: &mut Vec<Draw>, space: &Space, camera: Location, dir: Vec3) {
 	for pt in &path.points[1..] {
 		gc.line_to(pt.pos.x, pt.pos.y);
 	}
-	let end_pos = *path.points.last().expect("the starting point is always in the path");
+	let end_pos = *path
+		.points
+		.last()
+		.expect("the starting point is always in the path");
 	let dir_pos = end_pos.forward(1000. / DT).pos;
 	gc.line_to(dir_pos.x, dir_pos.y);
 	gc.stroke();
@@ -177,7 +192,11 @@ fn draw_track(gc: &mut Vec<Draw>, space: &Space, start: Vec2, dir: Vec2) {
 	// let v = space.tube.normalize(start, dir);
 	let mut loc = Location {
 		pos: vec3(start.x, start.y, 0.),
-		rot: mat3(vec3(dir.x, dir.y, 0.), vec3(-dir.y, dir.x, 0.), vec3(0., 0., 1.)),
+		rot: mat3(
+			vec3(dir.x, dir.y, 0.),
+			vec3(-dir.y, dir.x, 0.),
+			vec3(0., 0., 1.),
+		),
 	};
 	let v = vec3(1., 0., 0.);
 	let mut draw = |loc: &Location| {

src/bin/mesh/main.rs

@@ -81,7 +81,9 @@ fn render(mesh: &Mesh, camera: impl Fn(Vec2) -> (Vec3, Vec3)) -> Image {
 			} else {
 				bkg
 			};
-			let color = (color * 255.0).as_ivec3().clamp(IVec3::splat(0), IVec3::splat(255));
+			let color = (color * 255.0)
+				.as_ivec3()
+				.clamp(IVec3::splat(0), IVec3::splat(255));
 			img.put_pixel(x, y, Color(color.x as u8, color.y as u8, color.z as u8));
 		}
 	}
@@ -139,7 +141,11 @@ fn main() -> Result<(), Box<dyn Error>> {
 	loop {
 		for phi in 0..360 {
 			let proj = PROJS[PROJ_INDEX.load(Relaxed)];
-			let m_view = ypr_to_mat(vec3((135.0 + phi as f32) * PI / 180.0, -30.0 * PI / 180.0, 0.0f32));
+			let m_view = ypr_to_mat(vec3(
+				(135.0 + phi as f32) * PI / 180.0,
+				-30.0 * PI / 180.0,
+				0.0f32,
+			));
 			let m_camera = m_view.transpose();
 			let img = render(mesh.as_slice(), |off| {
 				let (base, ray) = proj(40., 20. * off);

src/bin/wireframe/camera.rs

@@ -64,7 +64,7 @@ impl Camera {
 			vec4(0., 0., 0., 1.),
 		);
 		let size = view_size.normalize() * std::f32::consts::SQRT_2;
-		let proj = make_proj_matrix(vec3(size.x, size.y, 2.), (1., (2f32).powi(16) + 1.)) * M;
+		let proj = make_proj_matrix(vec3(size.x, size.y, 2.), (1., 4096.)) * M;
 
 		let mvp = proj * view_mtx;
 		CameraUniform {

src/bin/wireframe/lines.rs

@@ -112,12 +112,14 @@ impl LineRenderer {
 							format: wgpu::VertexFormat::Float32x3,
 						},
 						wgpu::VertexAttribute {
-							offset: (mem::size_of::<Vertex>() + mem::offset_of!(Vertex, position)) as u64,
+							offset: (mem::size_of::<Vertex>() + mem::offset_of!(Vertex, position))
+								as u64,
 							shader_location: 2,
 							format: wgpu::VertexFormat::Float32x3,
 						},
 						wgpu::VertexAttribute {
-							offset: (mem::size_of::<Vertex>() + mem::offset_of!(Vertex, tangent)) as u64,
+							offset: (mem::size_of::<Vertex>() + mem::offset_of!(Vertex, tangent))
+								as u64,
 							shader_location: 3,
 							format: wgpu::VertexFormat::Float32x3,
 						},

src/bin/wireframe/main.rs

@@ -164,7 +164,8 @@ impl<'a> State<'a> {
 			.await
 			.unwrap();
 
-		let viewport = viewport::Viewport::new(&adapter, &device, surface, uvec2(size.width, size.height));
+		let viewport =
+			viewport::Viewport::new(&adapter, &device, surface, uvec2(size.width, size.height));
 
 		let kbd = keyctl::Keyboard::new();
 		let cam_loc = camctl::CameraLocation::new();
@@ -178,7 +179,13 @@ impl<'a> State<'a> {
 		};
 
 		let cam_obj = camera::Camera::new(&device);
-		let line_rend = lines::LineRenderer::new(&device, cam_obj.bind_group_layout(), viewport.format(), depth, msaa);
+		let line_rend = lines::LineRenderer::new(
+			&device,
+			cam_obj.bind_group_layout(),
+			viewport.format(),
+			depth,
+			msaa,
+		);
 
 		let scene = prepare_scene(&device);
 
@@ -219,8 +226,10 @@ impl<'a> State<'a> {
 		};
 		let size = self.viewport.size().as_vec2();
 
-		self.cam_loc.move_rel(100. * dt * self.kbd.control(&KEYS_MOVE));
+		self.cam_loc
-		self.cam_loc.rotate_rel_ypr(2. * dt * self.kbd.control(&KEYS_ROTATE));
+			.move_rel(100. * dt * self.kbd.control(&KEYS_MOVE));
+		self.cam_loc
+			.rotate_rel_ypr(2. * dt * self.kbd.control(&KEYS_ROTATE));
 		self.cam_obj.set(&self.queue, self.cam_loc.view_mtx(), size);
 	}
 
@@ -230,8 +239,11 @@ 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.line_rend
+				self.line_rend.render(
-					.render(&mut render_pass, self.cam_obj.bind_group(), self.scene.iter());
+					&mut render_pass,
+					self.cam_obj.bind_group(),
+					self.scene.iter(),
+				);
 			})
 	}
 }
@@ -250,7 +262,10 @@ pub async fn run() {
 	event_loop
 		.run(move |event, control_flow| {
 			match event {
-				Event::WindowEvent { ref event, window_id } if window_id == state.window().id() => {
+				Event::WindowEvent {
+					ref event,
+					window_id,
+				} if window_id == state.window().id() => {
 					match event {
 						WindowEvent::KeyboardInput {
 							device_id: _,

src/bin/wireframe/scene.rs

@@ -40,7 +40,12 @@ fn draw_rect(center: Vec3, u: Vec3, v: Vec3) -> Vec<Line> {
 	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)]
+	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 {
@@ -83,21 +88,28 @@ pub fn build() -> Vec<FancyLine> {
 	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.),
+		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.),
+		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.6, 0.6, 0.6), tube.render());
-	paint(&mut gc, vec3(0.0, 0.6, 1.0), draw_fan_2(&space, cam3, vec3(0., 1., 0.)));
+	paint(&mut gc, vec3(0.0, 0.6, 1.0), draw_fan_2(&space, cam3, 1.0));
-	paint(&mut gc, vec3(0.2, 1.0, 0.0), draw_fan_2(&space, cam2, vec3(0., 1., 0.)));
+	paint(&mut gc, vec3(0.2, 1.0, 0.0), draw_fan_2(&space, cam2, 1.0));
-	paint(&mut gc, vec3(0.0, 1.0, 0.6), draw_fan_2(&space, cam2, vec3(0., 0., 1.)));
+	paint(&mut gc, vec3(1.0, 0.2, 0.0), draw_fan_2(&space, cam1, 1.0));
-	paint(&mut gc, vec3(1.0, 0.2, 0.0), draw_fan_2(&space, cam1, vec3(0., 1., 0.)));
 	gc
 }
 
@@ -112,15 +124,18 @@ fn draw_ray_2(gc: &mut Vec<Line>, space: &Space, camera: Location, dir: Vec3) {
 	}
 
 	let mut pts = path.points;
-	let end_pos = *pts.last().expect("the starting point is always in the path");
+	let end_pos = *pts
-	pts.extend(itertools::iterate(end_pos, |r| r.forward(100.0)).take(1000));
+		.last()
+		.expect("the starting point is always in the path");
+	let dir_pos = end_pos.forward(10000.0);
+	pts.push(dir_pos);
 	gc.push(Line::Strip(pts));
 }
 
-fn draw_fan_2(space: &Space, camera: Location, spread: Vec3) -> Vec<Line> {
+fn draw_fan_2(space: &Space, camera: Location, spread: f32) -> Vec<Line> {
 	let mut gc = vec![];
-	for δ in itertools_num::linspace(-1., 1., 101) {
+	for y in itertools_num::linspace(-spread, spread, 101) {
-		draw_ray_2(&mut gc, space, camera, vec3(1., 0., 0.) + δ * spread);
+		draw_ray_2(&mut gc, space, camera, vec3(1., y, 0.));
 	}
 	gc
 }

src/bin/wireframe/viewport.rs

@@ -8,7 +8,12 @@ pub struct Viewport<'a> {
 }
 
 impl<'a> Viewport<'a> {
-	pub fn new(adapter: &wgpu::Adapter, device: &wgpu::Device, surface: wgpu::Surface<'a>, size: UVec2) -> Self {
+	pub fn new(
+		adapter: &wgpu::Adapter,
+		device: &wgpu::Device,
+		surface: wgpu::Surface<'a>,
+		size: UVec2,
+	) -> Self {
 		let caps = surface.get_capabilities(adapter);
 		let format = wgpu::TextureFormat::Bgra8UnormSrgb;
 		let sample_count = adapter
@@ -68,7 +73,9 @@ impl<'a> Viewport<'a> {
 		f: impl FnOnce(wgpu::RenderPass),
 	) -> Result<(), wgpu::SurfaceError> {
 		let output = self.surface.get_current_texture()?;
-		let view = output.texture.create_view(&wgpu::TextureViewDescriptor::default());
+		let view = output
+			.texture
+			.create_view(&wgpu::TextureViewDescriptor::default());
 		let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
 			label: Some("Render CommandEncoder"),
 		});
@@ -103,7 +110,12 @@ struct Multisample {
 }
 
 impl Multisample {
-	fn new(device: &wgpu::Device, format: wgpu::TextureFormat, size: UVec2, sample_count: u32) -> Multisample {
+	fn new(
+		device: &wgpu::Device,
+		format: wgpu::TextureFormat,
+		size: UVec2,
+		sample_count: u32,
+	) -> Multisample {
 		let tex = device.create_texture(&wgpu::TextureDescriptor {
 			label: Some("Multisample texture"),
 			size: wgpu::Extent3d {

src/fns.rs

@@ -82,7 +82,12 @@ impl QuadraticAccelerator {
 	}
 
 	pub fn x(&self, u: f32) -> f32 {
-		extend_linear(u, |u| (self.a() * u.abs() + self.b()) * u, self.internal, self.external)
+		extend_linear(
+			u,
+			|u| (self.a() * u.abs() + self.b()) * u,
+			self.internal,
+			self.external,
+		)
 	}
 	pub fn u(&self, x: f32) -> f32 {
 		extend_linear(
@@ -93,7 +98,12 @@ impl QuadraticAccelerator {
 		)
 	}
 	pub fn dx(&self, u: f32) -> f32 {
-		extend_const(u, |u| 2.0 * self.a() * u.abs() + self.b(), self.internal, 1.0)
+		extend_const(
+			u,
+			|u| 2.0 * self.a() * u.abs() + self.b(),
+			self.internal,
+			1.0,
+		)
 	}
 	pub fn du(&self, x: f32) -> f32 {
 		extend_const(x, |x| 1.0 / self.root(x), self.external, 1.0)
@@ -138,12 +148,28 @@ mod test {
 
 	#[test]
 	fn test_smoothstep_limiter() {
-		test_limiter(SmoothstepLimiter { min: 20.0, max: 30.0 }, 20.0, 30.0, 1.0 / 32.0);
+		test_limiter(
+			SmoothstepLimiter {
+				min: 20.0,
+				max: 30.0,
+			},
+			20.0,
+			30.0,
+			1.0 / 32.0,
+		);
 	}
 
 	#[test]
 	fn test_smootherstep_limiter() {
-		test_limiter(SmootherstepLimiter { min: 20.0, max: 30.0 }, 20.0, 30.0, 1.0 / 32.0);
+		test_limiter(
+			SmootherstepLimiter {
+				min: 20.0,
+				max: 30.0,
+			},
+			20.0,
+			30.0,
+			1.0 / 32.0,
+		);
 	}
 
 	#[test]

src/mathx.rs

@@ -36,7 +36,9 @@ impl MatExt for Mat3 {
 	fn orthonormalize(&self) -> Self {
 		let fx = self.x_axis.normalize();
 		let fy = (self.y_axis - self.y_axis.project_onto_normalized(fx)).normalize();
-		let fz = (self.z_axis - self.z_axis.project_onto_normalized(fx) - self.z_axis.project_onto_normalized(fy))
+		let fz = (self.z_axis
+			- self.z_axis.project_onto_normalized(fx)
+			- self.z_axis.project_onto_normalized(fy))
 		.normalize();
 		Self::from_cols(fx, fy, fz)
 	}

src/mesh_loader.rs

@@ -35,7 +35,10 @@ impl ObjMesh {
 	}
 
 	fn parse_fv(desc: &&str) -> ObjVertex {
-		let tokens: Vec<_> = desc.split('/').map(|s| s.parse::<usize>().unwrap() - 1).collect();
+		let tokens: Vec<_> = desc
+			.split('/')
+			.map(|s| s.parse::<usize>().unwrap() - 1)
+			.collect();
 		assert_eq!(tokens.len(), 3);
 		ObjVertex {
 			vertex: tokens[0],

src/mesh_tracer.rs

@@ -8,13 +8,21 @@ pub struct TraceResult {
 	pub normal: Vec3,
 }
 
-pub fn trace_to_mesh_all(mesh: &Mesh, base: Vec3, ray: Vec3) -> impl Iterator<Item = TraceResult> + '_ {
+pub fn trace_to_mesh_all(
+	mesh: &Mesh,
+	base: Vec3,
+	ray: Vec3,
+) -> impl Iterator<Item = TraceResult> + '_ {
 	mesh.iter().filter_map(move |f| {
 		let fs = (0..3).map(|k| edge_dist(f.vertices[k], f.vertices[(k + 1) % 3], base, ray));
 		if fs.into_iter().any(|f| f < 0.0) {
 			return None;
 		}
-		let m = mat3(f.vertices[1] - f.vertices[0], f.vertices[2] - f.vertices[0], -ray);
+		let m = mat3(
+			f.vertices[1] - f.vertices[0],
+			f.vertices[2] - f.vertices[0],
+			-ray,
+		);
 		let m = m.inverse();
 		let rel = m * (base - f.vertices[0]);
 		Some(TraceResult {

src/riemann.rs

@@ -15,7 +15,7 @@ pub trait Metric {
 	}
 
 	fn part_derivs_at(&self, pos: Vec3) -> Tens3 {
-		part_deriv(|p| self.at(p), pos, 1.0 / 64.0) // there just isn’t enough precision for a small ε.
+		part_deriv(|p| self.at(p), pos, 1.0 / 1024.0) // division by such eps is exact which is good for overall precision
 	}
 
 	fn vec_length_at(&self, at: Vec3, v: Vec3) -> f32 {
@@ -58,7 +58,7 @@ pub fn krist(space: &impl Metric, pos: Vec3) -> Tens3 {
 	let d = space.part_derivs_at(pos);
 	// ret[i][l][k] = sum((m) => .5f * g[m][i] * (d[k][l][m] + d[l][k][m] - d[m][k][l]))
 	make_tens3(|i, l, k| {
-		0.5 * (0..3)
+		0.5 * (0..2)
 			.map(|m| g.col(m)[i] * (d[l].col(k)[m] + d[k].col(m)[l] - d[m].col(k)[l]))
 			.sum::<f32>()
 	})
@@ -161,7 +161,10 @@ mod tests {
 			metric.inverse_at(rng.gen()),
 			Mat3::from_cols_array(&[1. / 9., 0., 0., 0., 1. / 16., 0., 0., 0., 1. / 25.])
 		);
-		assert_eq!(metric.part_derivs_at(rng.gen()), [Mat3::ZERO, Mat3::ZERO, Mat3::ZERO]);
+		assert_eq!(
+			metric.part_derivs_at(rng.gen()),
+			[Mat3::ZERO, Mat3::ZERO, Mat3::ZERO]
+		);
 		assert_eq!(metric.vec_length_at(rng.gen(), vec3(1., 0., 0.)), 3.);
 		assert_eq!(metric.vec_length_at(rng.gen(), vec3(0., 1., 0.)), 4.);
 		assert_eq!(metric.vec_length_at(rng.gen(), vec3(0., 0., 1.)), 5.);
@@ -222,7 +225,12 @@ mod tests {
 			vec3(3., 6.25, 0.)
 		);
 		assert_abs_diff_eq!(
-			trace_iter(&metric, vec3(3., 5., 0.), vec3(0.5, 0.25, 0.), std::f32::consts::SQRT_2)
+			trace_iter(
+				&metric,
+				vec3(3., 5., 0.),
+				vec3(0.5, 0.25, 0.),
+				std::f32::consts::SQRT_2
+			)
 			.nth(7)
 			.unwrap(),
 			vec3(7., 7., 0.),

src/tube/coords.rs

@@ -3,14 +3,16 @@ use glam::{vec3, Mat3, Vec3};
 use crate::riemann::Metric;
 use crate::types::{Location, Ray};
 
-use super::{Tube, YCylinder};
+use super::{Rect, Tube};
 
 pub trait FlatCoordinateSystem<T> {
 	fn flat_to_global(&self, v: T) -> T;
 	fn global_to_flat(&self, v: T) -> T;
 }
 
-pub trait FlatRegion: FlatCoordinateSystem<Vec3> + FlatCoordinateSystem<Ray> + FlatCoordinateSystem<Location> {
+pub trait FlatRegion:
+	FlatCoordinateSystem<Vec3> + FlatCoordinateSystem<Ray> + FlatCoordinateSystem<Location>
+{
 	// Измеряет расстояние до выхода за пределы области вдоль луча ray. Луч задаётся в плоской СК.
 	fn distance_to_boundary(&self, _ray: Ray) -> Option<f32> {
 		None
@@ -20,7 +22,10 @@ pub trait FlatRegion: FlatCoordinateSystem<Vec3> + FlatCoordinateSystem<Ray> + F
 trait MetricCS: FlatCoordinateSystem<Vec3> {
 	fn global_metric(&self) -> &impl Metric;
 	fn flat_to_global_tfm_at(&self, pos: Vec3) -> Mat3 {
-		self.global_metric().sqrt_at(self.flat_to_global(pos)).inverse().into()
+		self.global_metric()
+			.sqrt_at(self.flat_to_global(pos))
+			.inverse()
+			.into()
 	}
 	fn global_to_flat_tfm_at(&self, pos: Vec3) -> Mat3 {
 		self.global_metric().sqrt_at(pos).into()
@@ -80,9 +85,12 @@ impl FlatCoordinateSystem<Vec3> for InnerCS {
 
 impl FlatRegion for InnerCS {
 	fn distance_to_boundary(&self, ray: Ray) -> Option<f32> {
-		YCylinder {
+		Rect {
-			radius: self.0.inner_radius,
+			size: vec3(
-			half_length: self.0.internal_halflength,
+				self.0.inner_radius,
+				self.0.internal_halflength,
+				self.0.inner_radius,
+			),
 		}
 		.trace_out_of(ray)
 	}
@@ -98,9 +106,12 @@ impl MetricCS for OuterCS {
 
 impl FlatCoordinateSystem<Vec3> for OuterCS {
 	fn flat_to_global(&self, pos: Vec3) -> Vec3 {
-		let inner = YCylinder {
+		let inner = Rect {
-			radius: self.0.inner_radius + 1.0,
+			size: vec3(
-			half_length: self.0.external_halflength,
+				self.0.inner_radius + 1.0,
+				self.0.external_halflength,
+				self.0.inner_radius + 1.0,
+			),
 		};
 		if inner.is_inside(pos) {
 			let Vec3 { x, y: v, z } = pos;
@@ -114,13 +125,17 @@ impl FlatCoordinateSystem<Vec3> for OuterCS {
 	}
 
 	fn global_to_flat(&self, pos: Vec3) -> Vec3 {
-		let inner = YCylinder {
+		let inner = Rect {
-			radius: self.0.inner_radius + 1.0,
+			size: vec3(
-			half_length: self.0.external_halflength,
+				self.0.inner_radius + 1.0,
+				self.0.external_halflength,
+				self.0.inner_radius + 1.0,
+			),
 		};
 		if inner.is_inside(pos) {
 			let Vec3 { x: u, y, z: w } = pos; // в основной СК
-			let v = self.0.v(y) + y.signum() * (self.0.external_halflength - self.0.internal_halflength);
+			let v = self.0.v(y)
+				+ y.signum() * (self.0.external_halflength - self.0.internal_halflength);
 			vec3(u, v, w) // в плоском продолжении СК Outer на область Inner
 		} else {
 			pos
@@ -130,9 +145,12 @@ impl FlatCoordinateSystem<Vec3> for OuterCS {
 
 impl FlatRegion for OuterCS {
 	fn distance_to_boundary(&self, ray: Ray) -> Option<f32> {
-		YCylinder {
+		Rect {
-			radius: self.0.outer_radius,
+			size: vec3(
-			half_length: self.0.external_halflength,
+				self.0.outer_radius,
+				self.0.external_halflength,
+				self.0.outer_radius,
+			),
 		}
 		.trace_into(ray)
 	}
@@ -209,12 +227,20 @@ mod tests {
 			}),
 			Location {
 				pos: vec3(0., -0.5, 0.),
-				rot: mat3(vec3(0., 0.25, 0.), vec3(-1. / 3., 0., 0.), vec3(0., 0., 0.2))
+				rot: mat3(
+					vec3(0., 0.25, 0.),
+					vec3(-1. / 3., 0., 0.),
+					vec3(0., 0., 0.2)
+				)
 			}
 		);
 	}
 
-	fn test_flat_region(region: &impl FlatRegion, range_global: (Vec3, Vec3), range_flat: (Vec3, Vec3)) {
+	fn test_flat_region(
+		region: &impl FlatRegion,
+		range_global: (Vec3, Vec3),
+		range_flat: (Vec3, Vec3),
+	) {
 		#[allow(non_upper_case_globals)]
 		const ε: f32 = 1e-3;
 		macro_rules! assert_eq_at {
@@ -230,7 +256,14 @@ mod tests {
 				);
 			};
 		}
-		fn check_range(name_a: &str, a: Vec3, range_a: (Vec3, Vec3), name_b: &str, b: Vec3, range_b: (Vec3, Vec3)) {
+		fn check_range(
+			name_a: &str,
+			a: Vec3,
+			range_a: (Vec3, Vec3),
+			name_b: &str,
+			b: Vec3,
+			range_b: (Vec3, Vec3),
+		) {
 			assert!(b.cmpge(range_b.0 - ε).all() && b.cmple(range_b.1 + ε).all(), "Assertion failed:\nAt {name_a}: {a}, from range: {range_a:?}\nGot {name_b}: {b}, which is out of range {range_b:?}");
 			// TODO sort out when to check these conditions:
 			if a.x.abs_diff_eq(&range_a.0.x, ε) {
@@ -251,7 +284,14 @@ mod tests {
 				for z in linspace(range_global.0.z, range_global.1.z, 20) {
 					let pos_global = vec3(x, y, z);
 					let pos_flat = region.global_to_flat(pos_global);
-					check_range("global", pos_global, range_global, "flat", pos_flat, range_flat);
+					check_range(
+						"global",
+						pos_global,
+						range_global,
+						"flat",
+						pos_flat,
+						range_flat,
+					);
 					assert_eq_at!(
 						pos_global,
 						region
@@ -281,7 +321,14 @@ mod tests {
 				for z in linspace(range_flat.0.z, range_flat.1.z, 20) {
 					let pos_flat = vec3(x, y, z);
 					let pos_global = region.flat_to_global(pos_flat);
-					check_range("flat", pos_flat, range_flat, "global", pos_global, range_global);
+					check_range(
+						"flat",
+						pos_flat,
+						range_flat,
+						"global",
+						pos_global,
+						range_global,
+					);
 					assert_eq_at!(
 						pos_flat,
 						region
@@ -342,16 +389,15 @@ mod tests {
 			external_halflength: 300.0,
 		});
 		// TODO replace 200.20016 with something sane
-		// NOTE it can’t test −30..30 as that area intersects the boundary
 		test_flat_region(
 			&mapper,
-			(vec3(-20.0, -300.0, -20.0), vec3(20.0, -1.0, 20.0)),
+			(vec3(-30.0, -300.0, -30.0), vec3(30.0, -1.0, 30.0)),
-			(vec3(-20.0, -300.0, -20.0), vec3(20.0, -200.20016, 20.0)),
+			(vec3(-30.0, -300.0, -30.0), vec3(30.0, -200.20016, 30.0)),
 		);
 		test_flat_region(
 			&mapper,
-			(vec3(-20.0, 1.0, -20.0), vec3(20.0, 300.0, 20.0)),
+			(vec3(-30.0, 1.0, -30.0), vec3(30.0, 300.0, 30.0)),
-			(vec3(-20.0, 200.20016, -20.0), vec3(20.0, 300.0, 20.0)),
+			(vec3(-30.0, 200.20016, -30.0), vec3(30.0, 300.0, 30.0)),
 		);
 		test_flat_region(
 			&mapper,
@@ -448,9 +494,9 @@ mod tests {
 			}
 		}
 		// accelerating
-		for x in linspace(-21., 21., 20) {
+		for x in linspace(-29., 29., 20) {
 			for y in linspace(1., 299., 20) {
-				for z in linspace(-21., 21., 20) {
+				for z in linspace(-29., 29., 20) {
 					let v = mapper
 						.global_to_flat(Location {
 							pos: vec3(x, y, z),

src/tube/metric.rs

@@ -42,11 +42,10 @@ impl Tube {
 
 impl Metric for Tube {
 	fn sqrt_at(&self, pos: Vec3) -> Decomp3 {
-		let r = f32::hypot(pos.x, pos.z);
+		let sx = self.fx().value(pos.x);
-		let sr = self.fx().value(r);
 		let sy = self.fy().du(pos.y);
-		let s = sr + sy - sr * sy;
+		let s = sx + sy - sx * sy;
-		assert!(sr.is_finite());
+		assert!(sx.is_finite());
 		assert!(sy.is_finite());
 		assert!(sy > 0.0);
 		Decomp3 {
@@ -56,23 +55,17 @@ impl Metric for Tube {
 	}
 
 	fn part_derivs_at(&self, pos: Vec3) -> Tens3 {
-		let r = f32::hypot(pos.x, pos.z);
+		let sx = self.fx().value(pos.x);
-		let sr = self.fx().value(r);
 		let sy = self.fy().du(pos.y);
-		let s = sr + sy - sr * sy;
+		let s = sx + sy - sx * sy;
-		let dsr_dr = self.fx().derivative(r);
+		let dsx_dx = self.fx().derivative(pos.x);
 		let dsy_dy = self.fy().d2u(pos.y);
-		let ds2_dr = 2.0 * s * (1.0 - sy) * dsr_dr;
+		let ds2_dx = 2.0 * s * (1.0 - sy) * dsx_dx;
-		let ds2_dy = 2.0 * s * (1.0 - sr) * dsy_dy;
+		let ds2_dy = 2.0 * s * (1.0 - sx) * dsy_dy;
-		let (ds2_dx, ds2_dz) = if ds2_dr.abs() < 1e-5 {
-			(0., 0.)
-		} else {
-			(ds2_dr * pos.x / r, ds2_dr * pos.z / r)
-		};
 		[
 			Mat3::from_cols_array(&[0., 0., 0., 0., ds2_dx, 0., 0., 0., 0.]),
 			Mat3::from_cols_array(&[0., 0., 0., 0., ds2_dy, 0., 0., 0., 0.]),
-			Mat3::from_cols_array(&[0., 0., 0., 0., ds2_dz, 0., 0., 0., 0.]),
+			Mat3::from_cols_array(&[0., 0., 0., 0., 0., 0., 0., 0., 0.]),
 		]
 	}
 }
@@ -108,17 +101,24 @@ mod test {
 		let epsilon = 1.0e-3;
 		let margin = 1.0 / 16.0;
 		let mul = 1.0 + margin;
-		for x in itertools_num::linspace(-mul * testee.outer_radius, mul * testee.outer_radius, 20) {
+		for x in itertools_num::linspace(-mul * testee.outer_radius, mul * testee.outer_radius, 20)
-			for y in itertools_num::linspace(-mul * testee.external_halflength, mul * testee.external_halflength, 20) {
+		{
-				for z in itertools_num::linspace(-mul * testee.outer_radius, mul * testee.outer_radius, 20) {
+			for y in itertools_num::linspace(
+				-mul * testee.external_halflength,
+				mul * testee.external_halflength,
+				20,
+			) {
+				for z in itertools_num::linspace(
+					-mul * testee.outer_radius,
+					mul * testee.outer_radius,
+					20,
+				) {
 					let pos = vec3(x, y, z);
 					let computed = testee.part_derivs_at(pos);
 					let reference = approx.part_derivs_at(pos);
-					let eq = (0..3).all(|coord| computed[coord].abs_diff_eq(reference[coord], epsilon));
+					let eq =
-					assert!(
+						(0..2).all(|coord| computed[coord].abs_diff_eq(reference[coord], epsilon));
-						eq,
+					assert!(eq, "Bad derivative computation at {pos}:\n  explicit:  {computed:?}\n  numerical: {reference:?}\n");
-						"Bad derivative computation at {pos}:\n  explicit:  {computed:?}\n  numerical: {reference:?}\n"
-					);
 				}
 			}
 		}
@@ -168,8 +168,16 @@ mod test {
 		let ε = 1e-3;
 		let off = 10.0;
 		let steps = 4096;
-		for ax in linspace(-space.tube.inner_radius + ε, space.tube.inner_radius - ε, 20) {
+		for ax in linspace(
-			for bx in linspace(-space.tube.inner_radius + ε, space.tube.inner_radius - ε, 20) {
+			-space.tube.inner_radius + ε,
+			space.tube.inner_radius - ε,
+			20,
+		) {
+			for bx in linspace(
+				-space.tube.inner_radius + ε,
+				space.tube.inner_radius - ε,
+				20,
+			) {
 				let a = vec3(ax, -(space.tube.external_halflength + off), 0.);
 				let b = vec3(bx, space.tube.external_halflength + off, 0.);
 				let δ = vec3(bx - ax, 2.0 * (space.tube.internal_halflength + off), 0.);

src/tube/mod.rs

@@ -1,4 +1,4 @@
-use glam::{bool, f32, Mat3, Vec3, Vec3Swizzles};
+use glam::{bool, f32, Mat3, Vec3};
 
 use crate::ifaces::{DebugTraceable, RayPath, Traceable};
 use coords::{FlatCoordinateSystem, InnerCS, OuterCS};
@@ -28,12 +28,10 @@ pub enum Subspace {
 impl Space {
 	fn which_subspace(&self, pt: Vec3) -> Subspace {
 		if pt.y.abs() > self.tube.external_halflength {
-			return Outer;
-		}
-		let r = f32::hypot(pt.x, pt.z);
-		if r > self.tube.outer_radius {
 			Outer
-		} else if r > self.tube.inner_radius {
+		} else if pt.x.abs() > self.tube.outer_radius {
+			Outer
+		} else if pt.x.abs() > self.tube.inner_radius {
 			Boundary
 		} else {
 			Inner
@@ -52,7 +50,8 @@ impl Space {
 	/// Выполняет один шаг перемещения. Работает в любой части пространства.
 	/// off задаётся в локальной СК. Рекомендуется считать небольшими шагами.
 	pub fn move_step(&self, loc: Location, off: Vec3) -> Location {
-		let corr = Mat3::IDENTITY - riemann::contract(riemann::krist(&self.tube, loc.pos), loc.rot * off);
+		let corr =
+			Mat3::IDENTITY - riemann::contract(riemann::krist(&self.tube, loc.pos), loc.rot * off);
 		let p = loc.pos + corr * loc.rot * off;
 		Location {
 			pos: p,
@@ -95,16 +94,26 @@ impl Space {
 	fn list_objects(&self, tfm: impl Fn(Location) -> Location) -> Vec<Object> {
 		self.objs
 			.iter()
-			.map(|&Object { id, loc, r }| Object { id, loc: tfm(loc), r })
+			.map(|&Object { id, loc, r }| Object {
+				id,
+				loc: tfm(loc),
+				r,
+			})
 			.collect()
 	}
 
-	fn hit_objects(objs: &[Object], ray: Ray, limit: Option<f32>, globalize: impl Fn(Vec3) -> Vec3) -> Vec<Hit> {
+	fn hit_objects(
+		objs: &[Object],
+		ray: Ray,
+		limit: Option<f32>,
+		globalize: impl Fn(Vec3) -> Vec3,
+	) -> Vec<Hit> {
 		let limit = limit.unwrap_or(f32::INFINITY);
 		objs.iter()
 			.filter_map(|obj| {
 				let rel = ray.pos - obj.loc.pos;
-				let diff = rel.dot(ray.dir).powi(2) - ray.dir.length_squared() * (rel.length_squared() - obj.r.powi(2));
+				let diff = rel.dot(ray.dir).powi(2)
+					- ray.dir.length_squared() * (rel.length_squared() - obj.r.powi(2));
 				if diff > 0.0 {
 					let t = (-rel.dot(ray.dir) - diff.sqrt()) / ray.dir.length_squared();
 					Some((obj, t))
@@ -268,192 +277,154 @@ impl Rect {
 	}
 }
 
-fn solve_quadratic(a: f32, half_b: f32, c: f32) -> Option<(f32, f32)> {
-	let base = -half_b / a;
-	let d = base * base - c / a;
-	if d < 0. {
-		None
-	} else {
-		let δ = d.sqrt();
-		Some((base - δ, base + δ))
-	}
-}
-
-/// Цилиндр с центром в начале координат и осью вдоль оси Y.
-struct YCylinder {
-	pub half_length: f32,
-	pub radius: f32,
-}
-
-impl YCylinder {
-	/// Отражает луч, чтобы все координаты направления были положительны (допустимо благодаря симметрии YCylinder).
-	fn flip_ray(ray: Ray) -> Ray {
-		Ray {
-			pos: ray.pos * ray.dir.signum(),
-			dir: ray.dir.abs(),
-		}
-	}
-
-	fn is_inside(&self, pt: Vec3) -> bool {
-		let r = f32::hypot(pt.x, pt.z);
-		pt.y.abs() < self.half_length && r < self.radius
-	}
-
-	fn trace_into(&self, ray: Ray) -> Option<f32> {
-		let ray = Self::flip_ray(ray);
-
-		// 1. ray.pos.y + t * ray.dir.y = −half_length
-		let t_cap_in = (-self.half_length - ray.pos.y) / ray.dir.y;
-		let t_cap_out = (self.half_length - ray.pos.y) / ray.dir.y;
-
-		// 2. (ray.pos.x + t * ray.dir.x)² + (ray.pos.z + t * ray.dir.z)² = radius²
-		let pos = ray.pos.xz();
-		let dir = ray.dir.xz();
-		if dir.length_squared() < 1e-3 {
-			if pos.length_squared() >= self.radius.powi(2) {
-				return None;
-			}
-			return Some(t_cap_in).filter(|&t| t > 0.);
-		}
-		let (t_side_in, t_side_out) = solve_quadratic(
-			dir.length_squared(),
-			pos.dot(dir),
-			pos.length_squared() - self.radius.powi(2),
-		)?;
-		let t = f32::max(t_cap_in, t_side_in);
-		if t < 0. {
-			return None;
-		}
-		if t >= t_cap_out || t >= t_side_out {
-			return None;
-		}
-		Some(t)
-	}
-
-	fn trace_out_of(&self, ray: Ray) -> Option<f32> {
-		let ray = Self::flip_ray(ray);
-		let t_cap_out = (self.half_length - ray.pos.y) / ray.dir.y;
-		let pos = ray.pos.xz();
-		let dir = ray.dir.xz();
-		if dir.length_squared() < 1e-3 {
-			return Some(t_cap_out);
-		}
-		let (_t_side_in, t_side_out) = solve_quadratic(
-			dir.length_squared(),
-			pos.dot(dir),
-			pos.length_squared() - self.radius.powi(2),
-		)
-		.expect("the ray starts inside and is not along the axis so *has* to cross the side");
-		Some(t_side_out)
-	}
-}
-
 #[cfg(test)]
-mod tests {
-	use super::*;
-	use crate::types::ray;
-	use approx::assert_abs_diff_eq;
 use glam::vec3;
 
 #[test]
 fn test_rect() {
 	assert_eq!(
-			Rect::flip_ray(ray(vec3(2., 3., 2.), vec3(4., 5., 4.))),
+		Rect::flip_ray(Ray {
-			ray(vec3(2., 3., 2.), vec3(4., 5., 4.)),
+			pos: vec3(2.0, 3.0, 2.0),
-		);
+			dir: vec3(4.0, 5.0, 4.0)
-		assert_eq!(
+		}),
-			Rect::flip_ray(ray(vec3(2., 3., 2.), vec3(-4., 5., -4.))),
+		Ray {
-			ray(vec3(-2., 3., -2.), vec3(4., 5., 4.)),
+			pos: vec3(2.0, 3.0, 2.0),
-		);
+			dir: vec3(4.0, 5.0, 4.0)
-		assert_eq!(
-			Rect::flip_ray(ray(vec3(2., 3., 2.), vec3(4., -5., 4.))),
-			ray(vec3(2., -3., 2.), vec3(4., 5., 4.)),
-		);
-		assert_eq!(
-			Rect::flip_ray(ray(vec3(2., 3., 2.), vec3(4., 0., 4.))),
-			ray(vec3(2., 3., 2.), vec3(4., 0., 4.)),
-		);
-
-		let r = Rect { size: vec3(2., 3., 2.) };
-
-		assert_eq!(r.trace_into(ray(vec3(3., 3., 3.), vec3(1., 1., 1.))), None);
-		assert_eq!(r.trace_into(ray(vec3(-3., 2., -3.), vec3(1., 0., 1.))), Some(1.));
-		assert_eq!(r.trace_into(ray(vec3(-3., 2., -3.), vec3(-1., 0., -1.))), None);
-		assert_eq!(r.trace_into(ray(vec3(-3., 1., -3.), vec3(2., 2., 2.))), Some(0.5));
-		assert_eq!(r.trace_into(ray(vec3(-3., 2.1, -3.), vec3(2., 2., 2.))), None);
-
-		assert_eq!(r.trace_into(ray(vec3(2., 3., 2.), vec3(1., 1., 1.))), None);
-		assert_eq!(r.trace_into(ray(vec3(-2., 3., -2.), vec3(-1., 1., -1.))), None);
-		assert_eq!(r.trace_into(ray(vec3(2., 3., 2.), vec3(-1., -1., -1.))), Some(0.));
-		assert_eq!(r.trace_into(ray(vec3(2., -3., 2.), vec3(-1., 1., -1.))), Some(0.));
-
-		assert_eq!(r.trace_out_of(ray(vec3(0., 0., 0.), vec3(1., 1., 1.))), Some(2.));
-		assert_eq!(r.trace_out_of(ray(vec3(0., 0., 0.), vec3(0., 1., 0.))), Some(3.));
-		assert_eq!(r.trace_out_of(ray(vec3(0., 1., 0.), vec3(0., -1., 0.))), Some(4.));
-		assert_eq!(r.trace_out_of(ray(vec3(1., 1., 1.), vec3(0., -1., 0.))), Some(4.));
-		assert_eq!(r.trace_out_of(ray(vec3(2., 3., 2.), vec3(1., 1., 1.))), Some(0.));
 		}
-
-	#[test]
-	fn test_cylinder() {
-		assert_eq!(
-			YCylinder::flip_ray(ray(vec3(2., 3., 2.), vec3(4., 5., 4.))),
-			ray(vec3(2., 3., 2.), vec3(4., 5., 4.)),
 	);
 	assert_eq!(
-			YCylinder::flip_ray(ray(vec3(2., 3., 2.), vec3(-4., 5., -4.))),
+		Rect::flip_ray(Ray {
-			ray(vec3(-2., 3., -2.), vec3(4., 5., 4.)),
+			pos: vec3(2.0, 3.0, 2.0),
+			dir: vec3(-4.0, 5.0, -4.0)
+		}),
+		Ray {
+			pos: vec3(-2.0, 3.0, -2.0),
+			dir: vec3(4.0, 5.0, 4.0)
+		}
 	);
 	assert_eq!(
-			YCylinder::flip_ray(ray(vec3(2., 3., 2.), vec3(4., -5., 4.))),
+		Rect::flip_ray(Ray {
-			ray(vec3(2., -3., 2.), vec3(4., 5., 4.)),
+			pos: vec3(2.0, 3.0, 2.0),
+			dir: vec3(4.0, -5.0, 4.0)
+		}),
+		Ray {
+			pos: vec3(2.0, -3.0, 2.0),
+			dir: vec3(4.0, 5.0, 4.0)
+		}
 	);
 	assert_eq!(
-			YCylinder::flip_ray(ray(vec3(2., 3., 2.), vec3(4., 0., 4.))),
+		Rect::flip_ray(Ray {
-			ray(vec3(2., 3., 2.), vec3(4., 0., 4.)),
+			pos: vec3(2.0, 3.0, 2.0),
+			dir: vec3(4.0, 0.0, 4.0)
+		}),
+		Ray {
+			pos: vec3(2.0, 3.0, 2.0),
+			dir: vec3(4.0, 0.0, 4.0)
+		}
 	);
 
-		let r = YCylinder {
+	let r = Rect {
-			half_length: 3.,
+		size: vec3(2.0, 3.0, 2.0),
-			radius: 2.,
 	};
 
-		assert_eq!(r.trace_into(ray(vec3(3., 4., 3.), vec3(0., -1., 0.))), None);
-		assert_eq!(r.trace_into(ray(vec3(1., 4., 1.), vec3(0., -1., 0.))), Some(1.));
-		assert_eq!(r.trace_into(ray(vec3(3., 3., 3.), vec3(1., 1., 1.))), None);
-		assert_abs_diff_eq!(
-			r.trace_into(ray(vec3(-3., 2., -3.), vec3(1., 0., 1.))).unwrap(),
-			1.5857864
-		);
-		assert_eq!(r.trace_into(ray(vec3(-3., 2., -3.), vec3(-1., 0., -1.))), None);
-		assert_abs_diff_eq!(
-			r.trace_into(ray(vec3(-3., 1., -3.), vec3(2., 2., 2.))).unwrap(),
-			0.7928932
-		);
-		assert_eq!(r.trace_into(ray(vec3(-3., 2.1, -3.), vec3(2., 2., 2.))), None);
-
-		assert_eq!(r.trace_into(ray(vec3(2., 3., 2.), vec3(1., 1., 1.))), None);
-		assert_eq!(r.trace_into(ray(vec3(-2., 3., -2.), vec3(-1., 1., -1.))), None);
 	assert_eq!(
-			r.trace_into(ray(vec3(1.4142135, 3., 1.4142135), vec3(-1., -1., -1.))),
+		r.trace_into(Ray {
-			Some(0.)
+			pos: vec3(3.0, 3.0, 3.0),
+			dir: vec3(1.0, 1.0, 1.0)
+		}),
+		None
 	);
 	assert_eq!(
-			r.trace_into(ray(vec3(1.4142135, -3., 1.4142135), vec3(-1., 1., -1.))),
+		r.trace_into(Ray {
-			Some(0.)
+			pos: vec3(-3.0, 2.0, -3.0),
+			dir: vec3(1.0, 0.0, 1.0)
+		}),
+		Some(1.0)
+	);
+	assert_eq!(
+		r.trace_into(Ray {
+			pos: vec3(-3.0, 2.0, -3.0),
+			dir: vec3(-1.0, 0.0, -1.0)
+		}),
+		None
+	);
+	assert_eq!(
+		r.trace_into(Ray {
+			pos: vec3(-3.0, 1.0, -3.0),
+			dir: vec3(2.0, 2.0, 2.0)
+		}),
+		Some(0.5)
+	);
+	assert_eq!(
+		r.trace_into(Ray {
+			pos: vec3(-3.0, 2.1, -3.0),
+			dir: vec3(2.0, 2.0, 2.0)
+		}),
+		None
 	);
 
-		assert_abs_diff_eq!(
+	assert_eq!(
-			r.trace_out_of(ray(vec3(0., 0., 0.), vec3(1., 1., 1.))).unwrap(),
+		r.trace_into(Ray {
-			1.4142135
+			pos: vec3(2.0, 3.0, 2.0),
+			dir: vec3(1.0, 1.0, 1.0)
+		}),
+		None
 	);
-		assert_eq!(r.trace_out_of(ray(vec3(0., 0., 0.), vec3(0., 1., 0.))), Some(3.));
+	assert_eq!(
-		assert_eq!(r.trace_out_of(ray(vec3(0., 1., 0.), vec3(0., -1., 0.))), Some(4.));
+		r.trace_into(Ray {
-		assert_eq!(r.trace_out_of(ray(vec3(1., 1., 1.), vec3(0., -1., 0.))), Some(4.));
+			pos: vec3(-2.0, 3.0, -2.0),
-		assert_abs_diff_eq!(
+			dir: vec3(-1.0, 1.0, -1.0)
-			r.trace_out_of(ray(vec3(1.4142135, 3., 1.4142135), vec3(1., 1., 1.)))
+		}),
-				.unwrap(),
+		None
-			0.
+	);
+	assert_eq!(
+		r.trace_into(Ray {
+			pos: vec3(2.0, 3.0, 2.0),
+			dir: vec3(-1.0, -1.0, -1.0)
+		}),
+		Some(0.0)
+	);
+	assert_eq!(
+		r.trace_into(Ray {
+			pos: vec3(2.0, -3.0, 2.0),
+			dir: vec3(-1.0, 1.0, -1.0)
+		}),
+		Some(0.0)
+	);
+
+	assert_eq!(
+		r.trace_out_of(Ray {
+			pos: vec3(0.0, 0.0, 0.0),
+			dir: vec3(1.0, 1.0, 1.0)
+		}),
+		Some(2.0)
+	);
+	assert_eq!(
+		r.trace_out_of(Ray {
+			pos: vec3(0.0, 0.0, 0.0),
+			dir: vec3(0.0, 1.0, 0.0)
+		}),
+		Some(3.0)
+	);
+	assert_eq!(
+		r.trace_out_of(Ray {
+			pos: vec3(0.0, 1.0, 0.0),
+			dir: vec3(0.0, -1.0, 0.0)
+		}),
+		Some(4.0)
+	);
+	assert_eq!(
+		r.trace_out_of(Ray {
+			pos: vec3(1.0, 1.0, 1.0),
+			dir: vec3(0.0, -1.0, 0.0)
+		}),
+		Some(4.0)
+	);
+	assert_eq!(
+		r.trace_out_of(Ray {
+			pos: vec3(2.0, 3.0, 2.0),
+			dir: vec3(1.0, 1.0, 1.0)
+		}),
+		Some(0.0)
 	);
 }
-}

src/types.rs

@@ -6,10 +6,6 @@ pub struct Ray {
 	pub dir: Vec3,
 }
 
-pub fn ray(pos: Vec3, dir: Vec3) -> Ray {
-	Ray { pos, dir }
-}
-
 impl Ray {
 	pub fn forward(&self, dist: f32) -> Ray {
 		Ray {

src/utils.rs

@@ -43,8 +43,16 @@ mod tests {
 			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!(
-		assert_abs_diff_eq!(loc.rot * vec3(0., 1., 0.), vec3(0., 1. / 4., 0.), epsilon = ε);
+			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,
@@ -52,8 +60,16 @@ mod tests {
 			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!(
-		assert_abs_diff_eq!(loc.rot * vec3(0., 1., 0.), vec3(-1. / 3., 0., 0.), epsilon = ε);
+			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(
@@ -62,7 +78,15 @@ mod tests {
 			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!(
-		assert_abs_diff_eq!(loc.rot * vec3(0., 1., 0.), vec3(-4. / 15., 3. / 20., 0.), epsilon = ε);
+			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 = ε
+		);
 	}
 }