Re: [Algorithms] Left-handed vs. right-handed

[Eric H. <eri...@gm...>]

Thanks for all the replies. Yes, I should mention something about loop
reversal (I was tempted to in the original post, but it was getting quite
long as it was). I'm planning to try to unify some camera parameters in our
own system, so thanks, Patryck, for the pointer to the Eberly document
http://www.geometrictools.com/Documentation/LeftHandedToRightHanded.pdf.

On Thu, May 7, 2009 at 10:31 AM, Graham Hazel <gra...@ge...>
 wrote:

> The fundamental truth is that for boring technical reasons certain
> drivers/APIs make it more convenient to use certain basis
> representations.  So yes, at some point some competent person has to
> specify which basis to use for each target platform.


I guess I'd like to know more about the boring details that make it more
convenient to go with one basis or another - we don't have to clutter the
list with this (it's not truly algorithmic), but I'd be interested if you'd
be willing to email me. Do you just mean the built-in calls like glFrustum?
Or something else? I did find this in Jeff Weeks' documentation, which
mentions one old fixed-function lighting feature of OpenGL that forces -Z to
be used. I thought I'd include the note here in full, as it's relevant.

---------------------
Appendix:  My two programming idiosyncracies.
---------------------
OpenGL Conventions

   For the most part OpenGL's conventions are simple and elegant.
   However, my conventions differ from OpenGL's in two major ways.

   Matrices (... column-major discussion deleted...)

   Coordinate Systems

       OpenGL orients projection space with the observer
       looking down the positive z-axis, with with x-axis
       pointing to the right and the y-axis pointing up.
       However, OpenGL forces no assumptions about the orientation
       of world space;  the programmer is free to choose
       his/her coordinate system and projection matrix
       however s/he wishes.  So far so good.

       The only complication is that the OpenGL documentation adopts
       the unfortunate convention of looking down the negative z-axis,
       and requiring that the projection matrix invert the z-axis when
       passing from world to projection space.  The motivation for this
       convention, as far as I can tell, was to use a right-handed
       coordinate system ("like mathematicians use") in world space.
       (Computer scientists seem to have suffered from a bit of
       an inferiority complex back in the early days, or at least needed
       to convince people that their work was intellectually rigorous.)
       Fortunately the negative z-axis convention appears only in the
       documentation and in certain helper functions like glFrustum(),
       but otherwise is not forced on us.  [One other exception is
       that when you turn off GL_LIGHT_MODEL_LOCAL_VIEWER, OpenGL
       assumes the viewer is looking from infinity down the negative z-axis,
       and there seems to be no way to change that assumption.]

       Within this program, we adopt the convention that

           the x-axis points to the right
           the y-axis points up
           the z-axis points forward

       in world space as well as projection space.

Eric