Not sure how to properly use Matrix4.LookAt in this situation

Question

I am experimenting with ray marching, and have been following Jamie Wong's tutorial.

When the moving the camera section comes, they use the function

mat4 viewMatrix(vec3 eye, vec3 center, vec3 up) {
    vec3 f = normalize(center - eye);
    vec3 s = normalize(cross(f, up));
    vec3 u = cross(s, f);
    return mat4(
        vec4(s, 0.0),
        vec4(u, 0.0),
        vec4(-f, 0.0),
        vec4(0.0, 0.0, 0.0, 1)
    );
}

To generate a matrix that can be used to transform the direction vector so that the camera looks at the right object.

I wanted to move the matrix calculation out of the shader though, since it would be a better fit as a uniform, and so I did, but OpenTK's function Matrix4.LookAt() produces very different results, and I'm not sure how to apply them to the ray with the simple multiplication that Jamie's function gave.

I have confirmed that the matrix is being loaded into the uniform correctly, it just doesn't apply to the direction vector in the same way.

Edit: I am aware that I can translate Jamie Wong's function from GLSL into C#, but I want to know the correct usage of Matrix4.LookAt.

well, the `viewMatrix` function you're quoting isn't a "LookAt" function as it is typically used in the context of computer graphics; your function only sets up a _rotation matrix_ and does not do a translation based on the `eye` position. It is at least very unfortunate that it uses the parameters `eye` and `center` if it really only is interested in the view direction, and really misleads the users to think it might create a `lookAt` matrix (not sure if intentional or not) — derhass, Feb 14 '21 at 23:33
@derhass That makes sense then. So the is the LookAt function relevant at all or should I just translate the viewMatrix function to C#? — Salmon, Feb 14 '21 at 23:40
Well, it is even worse. It is called `viewMatrix` but creates the _inverse_ of what we typically call a view matrix (which is supposed to transform from _world_ space into view space). Conceptually, the code does the same as `Transpose(LookAt( (0,0,0), center-eye, up))` would do. — derhass, Feb 14 '21 at 23:48
Note that nothing is wrong with this code per say - doing the inverse transform totally makes sense for ray casting, it just doesn't fit into the concept - and _terminology_ - which those matrix helper functions like `LookAt` meant for rasterization pipelines use. — derhass, Feb 14 '21 at 23:52

Rabbid76 · Accepted Answer · 2021-02-15T06:23:49.523

OpenTK offers the data types Vector3, Vector4 and Matrix4 in the OpenTK.Mathematics namespace.

Assuming you have the vectors:

Vector3 center;
Vector3 eye;
Vector3 up;

Calculate the view matrix as follows

var f = Vector3.Normalize(center - eye);
var s = Vector3.Normalize(Vector3.Cross(f, up));
var u = Vector3.cross(s, f);
var viewMatrix = new Matrix4(
    new Vector4(s, 0.0f),
    new Vector4(u, 0.0f),
    new Vector4(-f, 0.0f),
    new Vector4(0.0f, 0.0f, 0,0f, 1.0f),
);

A uniform of type mat4 can be set with GL.UniformMatrix4. For example:

uniform mat4 viewMatrix;

int viewMatrixLoc = GL.GetUniformLocation(0, "viewMatrix");
GL.UniformMatrix4(viewMatrixLoc, false, ref viewMatrix);

Your "view matrix" transforms from view space into world space. It transforms a "view" ray into the world.
Matrix4.LookAt does the opposite. It computes a matrix that transforms world space to view space. It generates a matrix for rasterization, in which an object must be transformed from the world into the view.
So you need to invert the matrix that you get from Matrix4.LookAt:

Matrix4 viewMatrix = Matrix4.LookAt(
    new Vector3(0.0f),
    center - eye,
    up
).Inverted();

Yes, I know I can just translate Jamie's function to C#, but I would like to know how to properly use the built in Matrix4.LookAt method for this situation if it is applicable. I should have made that more clear in my question, sorry. — Salmon, Feb 14 '21 at 22:58

Not sure how to properly use Matrix4.LookAt in this situation

1 Answers1