[osg-users] LookAt() function parameter meanings..

[Rowley, Marlin R]

All,

I'm very confused by the parameters passed into this function. I am going over some of the legacy code and saw this line of code:

osg::Matrixd frustumView;
frustumView.makeLookAt(VIEW_POS, mDirection, mUp);

saw the docs, it's described like this:

void makeLookAt(const Vec3d& eye,const Vec3d& center,const Vec3d& up);

So in this context, I would think that "eye" represents the look vector. However, it seems to work like a position vector. The "center" parameter expects a direction vector (0, -1, 0) where the look vector is along the -yaxis.

This matrix will not translate to OpenGL properly since it's coordinate system is based off of a right handed coordinate frame.

Questions:


1. Am I interpreting these parameters properly?
2. How would I convert this system to the OpenGL right-handed system?

----------------------------------------
Marlin Rowley
Software Engineer, Staff
[cid:***@01D39374.DEC5A2E0]
Missiles and Fire Control
972-603-1931 (office)
214-926-0622 (mobile)
***@lmco.com<mailto:***@lmco.com>

[Ravi Mathur]

Hey Martin,

You are not interpreting the parameters properly. Look at the header for
Matrixd.cpp:

/** Set the position and orientation to be a view matrix,
* using the same convention as gluLookAt.
*/
void makeLookAt(const Vec3d& eye,const Vec3d& center,const Vec3d& up );

It follows the same convention and algorithm as gluLookAt(), so you can
look at the many online reference pages for that (microsoft
<https://docs.microsoft.com/en-us/windows/desktop/opengl/glulookat>, khronos
<https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluLookAt.xml>).
There is no question about its correctness or compatibility with OpenGL,
since OSG has been used with OpenGL in hundreds of projects for like 20
years. :D

To very directly answer your question, "eye" is the eye position (or camera
if you prefer), "center" is a point towards which the eye is looking, and
therefore the look vector points from eye towards center. This look vector
is the negative z-axis of OpenGL. The "up" vector specifies the direction
of the positive y-axis. The x-axis is then defined as y-cross-z, which is
the default OpenGL right-handed system. HOWEVER, OSG takes it a step
further and maps the y-axis to the look vector (into the screen). With this
simple rotation, x points right and z points up, which remains
right-handed. I'm guessing this is done because many OSG applications
represent physical (real-world) systems, in which the z-axis often does
point up. (Robert or someone else can correct me if that's not the reason)

Ravi

All,
I’m very confused by the parameters passed into this function. I am going
osg::Matrixd frustumView;
frustumView.makeLookAt(VIEW_POS, mDirection, mUp);
void makeLookAt(const Vec3d& eye,const Vec3d& center,const Vec3d& up);
So in this context, I would think that “eye” represents the look vector.
However, it seems to work like a position vector. The “center” parameter
expects a direction vector (0, -1, 0) where the look vector is along the
-yaxis.
This matrix will not translate to OpenGL properly since it’s coordinate
system is based off of a right handed coordinate frame.
1. Am I interpreting these parameters properly?
2. How would I convert this system to the OpenGL right-handed system?
----------------------------------------
Marlin Rowley
Software Engineer, Staff
*Missiles and Fire Control*
972-603-1931 (office)
214-926-0622 (mobile)
_______________________________________________
osg-users mailing list
http://lists.openscenegraph.org/listinfo.cgi/osg-users-openscenegraph.org

[Rowley, Marlin R]

Ravi,

During the projection matrix phase, OpenGL switches to left-handed system (i.e. Z-axis points positive going into the screen). But I missed the rotation, so it stays left-handed with +x (right), -y (look), and +z(up).

Thanks for the interpretation of the parameter names. I interpreted “center” to mean a position point – not a vector. And “eye” to mean the direction the eye is pointed to.

----------------------------------------
Marlin Rowley
Software Engineer, Staff
[cid:***@01D39374.DEC5A2E0]
Missiles and Fire Control
972-603-1931 (office)
214-926-0622 (mobile)
***@lmco.com<mailto:***@lmco.com>

From: osg-users <osg-users-***@lists.openscenegraph.org> On Behalf Of Ravi Mathur
Sent: Monday, August 13, 2018 9:32 AM
To: OpenSceneGraph Users <osg-***@lists.openscenegraph.org>
Subject: EXTERNAL: Re: [osg-users] LookAt() function parameter meanings..

Hey Martin,

You are not interpreting the parameters properly. Look at the header for Matrixd.cpp:

/** Set the position and orientation to be a view matrix,
* using the same convention as gluLookAt.
*/
void makeLookAt(const Vec3d& eye,const Vec3d& center,const Vec3d& up );

It follows the same convention and algorithm as gluLookAt(), so you can look at the many online reference pages for that (microsoft<https://docs.microsoft.com/en-us/windows/desktop/opengl/glulookat>, khronos<https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluLookAt.xml>). There is no question about its correctness or compatibility with OpenGL, since OSG has been used with OpenGL in hundreds of projects for like 20 years. :D

To very directly answer your question, "eye" is the eye position (or camera if you prefer), "center" is a point towards which the eye is looking, and therefore the look vector points from eye towards center. This look vector is the negative z-axis of OpenGL. The "up" vector specifies the direction of the positive y-axis. The x-axis is then defined as y-cross-z, which is the default OpenGL right-handed system. HOWEVER, OSG takes it a step further and maps the y-axis to the look vector (into the screen). With this simple rotation, x points right and z points up, which remains right-handed. I'm guessing this is done because many OSG applications represent physical (real-world) systems, in which the z-axis often does point up. (Robert or someone else can correct me if that's not the reason)

Ravi

On Mon, Aug 13, 2018 at 10:07 AM Rowley, Marlin R <***@lmco.com<mailto:***@lmco.com>> wrote:
All,

I’m very confused by the parameters passed into this function. I am going over some of the legacy code and saw this line of code:

osg::Matrixd frustumView;
frustumView.makeLookAt(VIEW_POS, mDirection, mUp);

saw the docs, it’s described like this:

void makeLookAt(const Vec3d& eye,const Vec3d& center,const Vec3d& up);

So in this context, I would think that “eye” represents the look vector. However, it seems to work like a position vector. The “center” parameter expects a direction vector (0, -1, 0) where the look vector is along the -yaxis.

This matrix will not translate to OpenGL properly since it’s coordinate system is based off of a right handed coordinate frame.

Questions:


1. Am I interpreting these parameters properly?
2. How would I convert this system to the OpenGL right-handed system?

----------------------------------------
Marlin Rowley
Software Engineer, Staff
Missiles and Fire Control
972-603-1931 (office)
214-926-0622 (mobile)
***@lmco.com<mailto:***@lmco.com>

_______________________________________________
osg-users mailing list
osg-***@lists.openscenegraph.org<mailto:osg-***@lists.openscenegraph.org>
http://lists.openscenegraph.org/listinfo.cgi/osg-users-openscenegraph.org

[Robert Osfield]

The OSG's LookAt implementation is *exactly* the same as gluLookAt,
the parameters and the maths are all identical. I made sure this was
the case to enable users to map GL code across easily as well as for
us to be able to leverage existing GL documentation.

The core OSG doesn't have a fixed "up" direction, but the by
convention the viewer, camera manipulators and most of the loaders
follow the convention that WORLD coordinates are +ve Z up, +ve Y
north, and +ve X east.

When you read OpenGL docs it will describe the EYE coordinates being
+ve Y up, +ve Z out, +ve X to the right.

The key thing to remember that EYE and WORLD coordinates and separated
by the View transform matrix. If this View matrix is Identity then
EYE and WORD orientation are the same, but this is only a special case
as soon as the eye moves through the scene this orientation
consistency is broken.

This is fundamental issue in compute graphics to get your head around,
EYE coordinates and WORLD coords are decoupled, when you think about
what you are doing and what coordinate frame you have you need to know
up front are your world in WORLD coordinates or EYE coordinates.

Another layer upon this is the we have transforms in the scene that
introduce LOCAL coordinates that nest within the WORLD coordinates.
This transforms decouple the LOCAL and WORLD coordinates, so local up
etc. can be very different between WORLD and LOCAL coords - think a
wheel on a car, it doesn't matter than the local up is spinning around
every frame.

Robert.