vsg::LookAt appears to always result in a y-up view

[photex]

Hello!

I'm baffled as to what I'm missing here, but if I specify: eye{-10,0,0} center{0,0,0} up{0,0,1}; I expect the cameras forward axis to be +x, the up axis to be +z and left to be +y. But the result always seems to be +y up.

Am I missing some critical context or is it actually the case that vsg::LookAt only supports +y up views?

[robertosfield]

LookAt sets whatever you pass in, following the right hand rule convention for layout of x, y and z.

With the settings you give the look direction is down the world coords +ve X axis, the up direction will be up the +ve Z axis and +y will be to the left.

However, one need to understand that the input parameters of a view matrix will be in world coordinates, but the transform that it generates will convert world cooridnates into eye coordinates. Eye coordinates are +ve Z out of the screen, +ve X to the right and +ve Y up.

The vsg::LookAt is written to mirror OpenGL's glLookAt so the parameters and conventions are all consistent.

You can also write your own vsg::ViewMatrix implementations if the LookAt (it's a subclass from vsg::ViewMatrix) doesn't suit your application.

[photex]

Hrm... I have a simple scene in blender that I export as gltf, being sure that I uncheck +Y is up, when I load it, the Y (green) axis is up and the Z (blue) axis is pointing to the right:

Here it is in Blender:

And then here it is in my test (based on the vsg helloworld example):

The lookat setup:

auto lookAt = vsg::LookAt::create(
    center + vsg::dvec3(-radius * 1.25, 0.0, 0.0), center, vsg::dvec3(0.0, 0.0, 1.0)
);

So perhaps I'm getting tripped up someplace else. Does vsgXchange make any assumptions about Y-up or Z-up when loading? Or perhaps assimp does?

When I load this in my SDL_gpu test app it's loading and displaying as I'd expect it to.

[photex]

Oh, I just caught on to what you're explaining there regarding eye coordinates. But what's sort of confusing to me is why this is considered consistent and what is the point of the LookAt api being defined like this. It's been a very long time since I've used glu. But if I understand correctly, LookAt is actually just me setting how to map from my coordinate system to whatever it bakes in.

[photex]

Ok, just reading over LookAt and Trackball, all essentially work with an OpenGL coordinate system. Did OSG not used to be Z-up? I guess I expected that to be the case here as well, and the way that things are named/defined in terms of the API this was all rather surprising I guess.

In any case, understanding all the defaults and seeing how they are put together I think helps. Thanks for the clarifications!

[robertosfield]

Both OSG the VSG default to Z up, Y north and X east for world coordinates when loading models and setting up the default camera orientation in the vsgExample examples. This convention is used widely in vis-sim, GIS and egineering and why the OSG and VSG uses them as default.

However, this is just defaults, you may set up you ViewMatrix/LookAt any how you want, and you may set the hints of what coordinate convention to use by passing in the settings via vsg::Options::sceneCoordinateConvention.

The vsgXchange loaders will attempt to determine the coordiante convetion that the model being loaded is in, sometimes loaders explictly define this, other times they don't, other times what they specify is wrong and need to be overriden. To help handle cases where the coordinate convention isn't determined how you want it you can set up the vsg::Options::formatCoordinateConventions

3D modellers have different default conventions of there own, some you can set your perference. The modellers may output individual models that have object coordinates that you need to place into your world using a transform, other modellers can output a whole world.

What can confuse thiings is conflating eye coordinates with world coordinates, it's important to distriginguisgh between these in your head. If the modeller uses the same convention as the target API eye coordinates then it can be all too easy to conflate the two in your head and then find the idea of world coordaintes and view matrix setup as confusing.

The view matrix is there to convert between world coordiantes and eye coordiantes, it's a 4x4 matrix that can handle a wide range of transformations. Classes like LookAt just provide one way of setting up that view martix. In the end it's all just about telling the system how to transform world into eye coordinates.