CODEWITHSUNDEEP
c++openglglut
Georgi Koemdzhiev
Georgi Koemdzhiev

Reputation: 11931

OpenGL glOrtho set up match the window size

I am a beginner in OpenGl and I am struggling a bit with setting up the glOrtho camera to match the window size so that I can draw a line using the window's coordinates. For example, if I want to draw a line from coordinates 0,10 (x,y) to 600,10. I managed to draw the line (which will be a "Separator" from the viewport and a toolbar with buttons) in my current set up but it was by "try end error" approach and the coordinates that I needed to put don't make any sense to me. When I tried to draw a line using the above-mentioned coordinates, the line simply did not show up. What I need to change in the glOrtho set up in order to work with these (1000x600) screen size and draw my vertices and not these: 

glVertex3f(-2.0, 11.0, 0.0);
glVertex3f(20.0, 11.0, 0.0);

Note, my current window size is 1000x600 (width/height)

This is the line (on the top that crosses the whole screen): enter image description here

This is my OGWindow class that handles all of the drawing:

void OGWindow::MyReSizeGLScene(int fwidth, int fheight) 
{
// Store window size  in class variables so it can be accessed in myDrawGLScene() if necessary
wWidth = fwidth;
wHeight = fheight;

// Calculate aspect ration of the OpenGL window
aspect_ratio = (float) fwidth / fheight;

// Set camera so it can see a square area of space running from 0 to 10 
// in both X and Y directions, plus a bit of space around it.
Ymin = -1;
Ymax = 12;
Xmin = -1;

// Choose Xmax so that the aspect ration of the projection
// = the aspect ratio of the viewport
Xmax = (aspect_ratio * (Ymax -Ymin)) + Xmin;

glMatrixMode(GL_PROJECTION);        // Select The Projection Stack
glLoadIdentity();
glOrtho(Xmin, Xmax, Ymin, Ymax, -1.0, 1.0);

glViewport(0, 0, wWidth, wHeight);      // Viewport fills the window
}

void OGWindow::myDrawGLScene(GLvoid)        // Here's Where We Do All The Drawing
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // clear the drawing area

OGWindow::myDrawModel();
drawToolbar();

glutSwapBuffers(); // Needed if we're running an animation
glFlush();
}



void OGWindow::myDrawModel(GLvoid)
{
switch ( squareColour ) {
case RED:
        glColor3f(1.0, 0.0, 0.0);
    break;
case BLUE:
        glColor3f(0.0, 0.0, 1.0);
    break;
}

glBegin( GL_QUADS );
    glVertex3f( squareX, squareY, 0.0 ); // Coordinates of bottom-left corner of square
    glVertex3f( squareX + squareWidth, squareY, 0.0 );
    glVertex3f( squareX + squareWidth, squareY + squareHeight, 0.0 );
    glVertex3f( squareX, squareY + squareHeight, 0.0 );
glEnd();
}


// Convert from screen coords returned by mouse
// to world coordinates.
// Return result in worldX, worldY
void OGWindow::screen2World(int screenX, int screenY, double & worldX, double & worldY)
{
// Dimensions of rectangle viewed by camera projection
double projWidth = Xmax -Xmin;
double projHeight = Ymax - Ymin;

// Screen coords with origin at bottom left
int screenLeft = screenX;
int screenUp = wHeight - screenY; 

worldX = Xmin + screenLeft * projWidth / wWidth ;
worldY = Ymin + screenUp *  projHeight / wHeight ;
}

//Method to draw the toolbar separator line
void OGWindow::drawToolbar(GLvoid) {
//draw toolbar line separator
glColor3f(0.0,0.0,0.0);
glBegin(GL_LINES);
    glVertex3f(-2.0, 11.0, 0.0);
    glVertex3f(20.0, 11.0, 0.0);
glEnd();
//draw create button

glPushMatrix();
    glTranslatef(2.0, 10.0, 0.0);

    glutSolidCube(2.0);
glPopMatrix();

}

This is my main class where I am ivoking the methods from OGWindow:

int main(int argc, char **argv) {

glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);   
glutInitWindowSize( 1000, 600 );
glutInitWindowPosition(0, 0);
glutCreateWindow("OpenGL Demo");
glEnable(GL_DEPTH_TEST);    // enable the depth buffer test

glutDisplayFunc(DrawGLScene);
glutReshapeFunc(ReSizeGLScene);
glutMouseFunc(mouseClick);
glutMotionFunc(mouseMotion);
glutPassiveMotionFunc(mousePassiveMotion);
glutIdleFunc(Idle);
theWindow.initGL(); 

glutMainLoop();
}

Upvotes: 3

Views: 5421

Answers (2)

bitzz
bitzz

Reputation: 57

Check out the documentation of glOrtho function. As you see, there are 6 parameters: left, right, bottom, top, near, far. You made mistake by setting window width to top instead of bottom parameter. Here's proper use of function: 

glOrtho (0, 1000, 600, 0, -1.0, 1.0)

Upvotes: 4

aslg
aslg

Reputation: 1974

So, first your ortho settings. If you want your camera to match the screen dimensions, glOrtho has to use the same dimensions.

// This will anchor the camera to the center of the screen
// Camera will be centered on (0,0)
glOrtho( -screenWidth/2.f, screenWidth/2.f, -screenHeight/2.f, screenHeight/2.f, -1, 1 );

// This will anchor the camera to the lower left corner of the screen
// Camera will be centered on (screenWidth/2, screenHeight/2)
glOrtho( 0, screenWidth, 0, screenHeight, -1, 1 );

Try both and see the difference. Although if you are making some sort of editor, where your camera doesn't move, you may be looking for the second ortho setup.

Second, you only ever use (apparently) the GL_PROJECTION matrix mode. You must use this mode to set the camera projection and GL_MODELVIEW to apply transforms to the camera or the objects.

So when you call resize and don't change the matrix mode back to GL_MODELVIEW, you'll be applying translations to the projection matrix.

If you did forget to initialize the modelview matrix it may contain garbage values and yield unexpected results.

Upvotes: 3

Related Questions