when I use the `ArcBall`

camera’s `unproject`

(modified it only to use a stashed screen size as an argument, no other changes at all) - I still get the same small values

Sure!

##
Code

```
let view:&Matrix4<f64> = &camera.view;
let projection:&Perspective3<f64> = &camera.projection;
let view_inverse = view.try_inverse().unwrap();
let screen_point = Point2::new(x as f64, y as f64);
let screen_size = camera.get_viewport(); // just retrieves the stashed screensize
let ndc_screen_point = Point3::new(screen_point.x / screen_size.x, screen_point.y / screen_size.y, 0.0);
let view_point_1 = projection.unproject_point(&ndc_screen_point);
let (view_point_2, view_dir_2) = camera.unproject(&screen_point);
let (view_point_3, view_dir_3) = camera.unproject(&Point2::new(screen_point.x / screen_size.x, screen_point.y / screen_size.y));
let world_point_1 = view_inverse.transform_point(&view_point_1);
let world_point_2 = view_inverse.transform_point(&view_point_2);
let world_point_3 = view_inverse.transform_point(&view_point_3);
log::info!("
\n----- GIVEN -----
\nview: {:#?}
\nview_inverse: {:#?}
\nprojection: {:#?}
\nscreen_point: {:#?}
\nscreen_size: {:#?}
\nndc_screen_point: {:#?}
\n----- VIEW_POINT -----
\nview_point_1: {:#?}
\nview_point_2: {:#?}
\nview_dir_2: {:#?}
\nview_point_3: {:#?}
\nview_dir_3: {:#?}
\n----- WORLD_POINT -----
\nworld_point_1: {:#?}
\nworld_point_2: {:#?}
\nworld_point_3: {:#?}
",
view,
view_inverse,
projection,
screen_point,
screen_size,
ndc_screen_point,
view_point_1,
view_point_2,
view_dir_2,
view_point_3,
view_dir_3,
world_point_1,
world_point_2,
world_point_3,
);
```

##
Logs with screen_point: 977,489 and screen_size: 1620,686

```
----- GIVEN -----
view: Matrix {
data: [
1.0,
-0.000000000000000000000000000000003749399456654644,
0.00000000000000006123233995736766,
0.0,
0.0,
1.0,
0.00000000000000006123233995736766,
0.0,
-0.00000000000000006123233995736766,
-0.00000000000000006123233995736766,
1.0,
0.0,
0.0,
0.0,
-1000.0,
1.0,
],
}
view_inverse: Matrix {
data: [
1.0,
0.0,
-0.00000000000000006123233995736766,
0.0,
-0.000000000000000000000000000000003749399456654644,
1.0,
-0.00000000000000006123233995736766,
0.0,
0.00000000000000006123233995736766,
0.00000000000000006123233995736766,
1.0,
0.0,
0.00000000000006123233995736766,
0.00000000000006123233995736766,
1000.0,
1.0,
],
}
projection: Matrix {
data: [
1.0223151257950265,
0.0,
0.0,
0.0,
0.0,
2.414213562373095,
0.0,
0.0,
0.0,
0.0,
-1.0000200002000021,
-1.0,
0.0,
0.0,
-0.2000020000200002,
0.0,
],
}
screen_point: Point {
coords: Matrix {
data: [
977.0,
489.0,
],
},
}
screen_size: Matrix {
data: [
1620.0,
686.0,
],
}
ndc_screen_point: Point {
coords: Matrix {
data: [
0.6030864197530864,
0.7128279883381924,
0.0,
],
},
}
----- VIEW_POINT -----
view_point_1: Point {
coords: Matrix {
data: [
0.11798326635932296,
0.05905201356162632,
-0.1999980000199998,
],
},
}
view_point_2: Point {
coords: Matrix {
data: [
0.02016724924679395,
-0.017631247844387254,
999.9,
],
},
}
view_dir_2: Matrix {
data: [
0.19480420276709898,
-0.17030786589218974,
-0.9659433489597218,
],
}
view_point_3: Point {
coords: Matrix {
data: [
-0.09774436704011258,
0.04133527372412273,
999.9,
],
},
}
view_dir_3: Matrix {
data: [
-0.6703226584807581,
0.2834738349715284,
-0.6857915998419808,
],
}
----- WORLD_POINT -----
world_point_1: Point {
coords: Matrix {
data: [
0.11798326635938418,
0.059052013561687544,
999.80000199998,
],
},
}
world_point_2: Point {
coords: Matrix {
data: [
0.02016724924691641,
-0.017631247844264796,
1999.9,
],
},
}
world_point_3: Point {
coords: Matrix {
data: [
-0.09774436703999012,
0.0413352737242452,
1999.9,
],
},
}
```

Seems like it’s doubling the `world_point`

depth, but I don’t see where I can account for z-axis being inverted here so maybe that’s misleading. Also, even if I spin the camera around to the other side, differences in the world point movements are within a very small range when they should be bigger.

The camera itself is correct - I see graphics on the screen just fine.