stucked in matrix operation errors - ios

Question

I was set up a 2D opengl view in iOS with top left as origin and bottom right as (768, 1366)
My projection matrix is setup like this:
projectionMtx = GLKMatrix4MakeOrtho( 0, 768, 1366, 0, 10, -10);
When I got the touch event, the coordinates are in physical coordinates, and i need to convert them into my own logical coordinates, so I thought like this:
Since V_physical = M_projection * V_logical
So V_logical = M_projection_invert * V_phsical
and I implemented the code like this:
(void)touchesBegan:(NSSet*)touches withEvent:(UIEvent*)event
{
UITouch* touch = [[event allTouches] anyObject];
CGPoint location = [touch locationInView:self.view];
GLKVector4 locationVector = {
(float)location.x,
(float)location.y,
0,
0,
};
GLKVector4 result = GLKMatrix4MultiplyVector4(GLKMatrix4Invert(projectionMtx, nullptr),locationVector);
NSLog(#"touch %.2f %.2f", location.x, location.y);
NSLog(#"vector %.2f %.2f", result.v[0], result.v[1]);
}
However, this is what I got from testing:
touch 367.00 662.00
vector 140928.00 -452151.28
Is my math wrong or my code wrong?

Answer 1

You have some mix up with your coordinate systems. The projection matrix maps its input coordinates (which in a full 3D pipeline are typically called "eye coordinates") to clip coordinates. For a parallel projection, clip coordinates are the same as normalized device coordinates (NDC), which have a range of [-1, 1] in x and y direction.
This means that your ortho projection:
projectionMtx = GLKMatrix4MakeOrtho( 0, 768, 1366, 0, 10, -10);
maps an x range of [0, 768] to [-1, 1], and a y range of [1366, 0] to [-1, 1]. The resulting mapping done by the matrix is:
xNdc = (2.0 / 768.0) * xEye - 1.0
yNdc = (2.0 / -1366.0) * yEye + 1.0
The inverse of this is:
xEye = (768.0 / 2.0) * (xNdc + 1.0)
yEye = (-1366.0 / 2.0) * (yNdc - 1.0)
Applying this inverse transformation gives:
(768.0 / 2.0) * (367.0 + 1.0) = 141312.0
(-1366.0 / 2.0) * (662.0 - 1.0) = -451463
For reasons I can't explain at the moment, this is slightly off what you got (looks like a one-off difference), but it's very similar.
This is obviously not meaningful. To use the inverse projection transformation, your input coordinates should be in the range [-1, 1].
In your use case, since you set up the projection transformations to transform coordinates in pixels, and you receive touch input that is also in pixels, you really have to do nothing at all to get the touch input in your OpenGL coordinate system. They are already in the same coordinate system (pixels).
If you use any other projection. You would first map your touch coordinates to a [-1, 1] range, and then apply the inverse projection transformation. The coordinate mapping would use the same equations as the ones I had above for mapping eye coordinates to NDC.