Fix Plane::project_vector

Turns out that it worked only for plane coordinate systems in which the
`u` and `v` vectors where orthogonal.

crates/fj-math/src/plane.rs

@@ -74,12 +74,29 @@ impl Plane {
 
     /// Project a vector into the plane
     pub fn project_vector(&self, vector: impl Into<Vector<3>>) -> Vector<2> {
-        let vector = vector.into();
-
-        Vector::from([
-            vector.scalar_projection_onto(&self.u()),
-            vector.scalar_projection_onto(&self.v()),
-        ])
+        // The vector we want to project can be expressed as a linear
+        // combination of `self.u()`, `self.v()`, and `self.normal()`:
+        // `v = a*u + b*v + c*n`
+        //
+        // All we need to do is to solve this equation. `a` and `b` are the
+        // components of the projected vector. `c` is the distance of the points
+        // that the original and projected vectors point to.
+        //
+        // To solve the equation, let's change it into the standard `Mx = b`
+        // form, then we can let nalgebra do the actual solving.
+        let m =
+            nalgebra::Matrix::<_, _, nalgebra::Const<3>, _>::from_columns(&[
+                self.u().to_na(),
+                self.v().to_na(),
+                self.normal().to_na(),
+            ]);
+        let b = vector.into();
+        let x = m
+            .lu()
+            .solve(&b.to_na())
+            .expect("Expected matrix to be invertible");
+
+        Vector::from([x.x, x.y])
     }
 
     /// Project a line into the plane
@@ -114,5 +131,9 @@ mod tests {
 
         assert_eq!(plane.project_vector([1., 0., 1.]), Vector::from([1., 0.]));
         assert_eq!(plane.project_vector([0., 1., 1.]), Vector::from([0., 1.]));
+
+        let plane =
+            Plane::from_parametric([1., 1., 1.], [1., 0., 0.], [1., 1., 0.]);
+        assert_eq!(plane.project_vector([0., 1., 0.]), Vector::from([-1., 1.]));
     }
 }