Quote:I think you are mistaken, what part exactly of a matrix tells you which handedness it belongs to? the 1,0,0 vector could point in the right direction just as well as it could to the left (or up, down,forward,backward for that matter).

1  0  0  00  1  0  00  0  .5 00  0  .5 1

1  0  0  00  1  0  00  0 -.5 00  0  .5 1

Quote:Original post by jyk
I'm assuming the convention adopted by both OpenGL and Direct3D that +x is to the right and +y is up in view space.

Quote:Original post by jyk
There are some differences due to how the canonical view volume differs between the two APIs, but the important thing to note is that the sign of element 33 differs depending on the handedness. If we were using the OpenGL convention for the view volume, the above matrices would instead be identity, and identity with element 33 negated, respectively. This is what I'm referring to when I say that the identity matrix represents a left-handed orthographic transform. (Again, in the context of the standard graphics pipeline.)

Quote:Yes, and OpenGL's convention is that -z is forward in view space, which makes it right handed. Direct3D, I assume has +z as forward, therein lies the difference.

Quote:Something doesn't sound right to me in your explanation, it seems like D3D being left handed would properly generate a negative M33 element to switch from its native left handed to right handed one, but I would expect OpenGL to get the opposite results you mentioned, identity for right handed, negative M33 for left handed.

glMatrixMode(GL_PROJECTION);glLoadIdentity();glOrtho(-1, 1, -1, 1, -1, 1);float m[16];glGetFloatv(GL_PROJECTION_MATRIX, m);for (size_t i = 0; i < 4; ++i) {    for (size_t j = 0; j < 4; ++j) {        std::cout << m &lt;&lt; <span class="cpp-literal">" "</span>;<br>    }<br>    std::cout &lt;&lt; std::endl;<br>}<br></pre></div><!–ENDSCRIPT–><br>The output will be (give or take a negative 0):<pre>1 0  0 0 <br>0 1  0 0 <br>0 0 -1 0 <br>0 0  0 1</pre>In other words, aside from the z range issue, the results are the same in both APIs: <i>+33</i> for left handed, <i>-33</i> for right handed.<br><br>I think it might be useful to forget about the gl and glu convenience functions and about the DX math library, and just consider the most up-to-date version of each API. In the programmable pipeline, there is no model matrix, no view matrix, and no projection matrix; there is &#111;nly what you do in the vertex, geometry, and fragment programs, which is completely up to you. In this context (that of the programmable pipeline with no help from utility functions or from the fixed-function pipeline), is Direct3D still 'left handed'? Is OpenGL still 'right handed'?<br><br>My own suspicion is that the answer is no; that at the very least, with the modern programmable pipeline, the idea of each API having its own 'inherent handedness' is essentially meaningless.<br><br>However, I don't claim 100% certainty, and at this point, it looks like if I want to try to prove my theory, I'm going to have to dig into the respective pipelines a bit and provide some more concrete examples :)

Quote:the man page for glOrtho seems to hint that you should pass near and far as negatives, or in your example near as 1, far as -1 which would result in the identity matrix

Quote:Anyway, there is a solution to settle this, implement what szecs suggested, that is set projection to identity, make no mirror transformations or negative scales in modelview draw the axes at the origin with 0.1 lengths and see in which direction z points when y is up and x is right, that's it.

#include "SDL.h"#include "SDL_opengl.h"int main(int, char*[]){    SDL_Init(SDL_INIT_EVERYTHING);    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);    SDL_SetVideoMode(400, 400, 0, SDL_OPENGL);    glEnable(GL_DEPTH_TEST);    bool quit = false;    while (!quit) {        SDL_Event event;        while (SDL_PollEvent(&event)) {            if (event.type == SDL_QUIT) {                quit = true;            }        }        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);        glColor3f(1, 0, 0);        glBegin(GL_TRIANGLES);        glVertex3f(-.75, .25, .5);   glVertex3f(.75, 0, .5);  glVertex3f(-.75, -.25, .5);        glColor3f(0, 1, 0);        glVertex3f(-.25, -.75, .75); glVertex3f(0, .75, .75); glVertex3f(.25, -.75, .75);        glEnd();        SDL_GL_SwapBuffers();    }    SDL_Quit();    return 0;}

Quote:Original post by szecs
What CS do Blender or 3ds Max have? I think right handed. So what happens if you load a small model into the test program?
Will the model look mirrored or not?
I could try it out myself, but I don't have time for it now unfortunately.

Quote:All the discussion now is about whether the API itself introduces a handedness. But since all aspects that play a role can be re-programmed or, with OpenGL's newest specifications, have to be be programmed, the consensus seems me to be that there is no real handedness in OpenGL. Instead, the handedness comes from the way an application uses the API. So saying OpenGL uses RHS is substantiated in the history where the utility functions like glFrustum and glOrtho as well as the default winding rules and depth test were used widely by applications, and those functions and defaults have done a set-up for RHS.

Quote:
All the discussion now is about whether the API itself introduces a handedness. But since all aspects that play a role can be re-programmed or, with OpenGL's newest specifications, have to be be programmed, the consensus seems me to be that there is no real handedness in OpenGL. Instead, the handedness comes from the way an application uses the API. So saying OpenGL uses RHS is substantiated in the history where the utility functions like glFrustum and glOrtho as well as the default winding rules and depth test were used widely by applications, and those functions and defaults have done a set-up for RHS.