OpenGL绘制线的窗口高度

Question

I would like to know how to draw the length of a line with respect to the the dimensions of the enclosing window. Note that I am using the combination of GLUT and OpenGL.

For example, say I wanted to draw a line from the bottom center of the screen (I assume this would be at coordinate (WINDOW_LENGTH/2, 0) to the center of the window (WINDOW_LENGTH/2, WINDOW_HEIGHT/2)

How do I do this in OpenGL? Right now I have the following:

//Initializes 3D rendering                                                                                                                                                  
void initRendering() {
        //Makes 3D drawing work when something is in front of something else                                                                                                
        glEnable(GL_DEPTH_TEST);
}

//Called when the window is resized                                                                                                                                         
void handleResize(int w, int h) {
        glViewport(0, 0, w, h);
        glMatrixMode(GL_PROJECTION); //Switch to setting the camera perspective                                                                                             
        //Set the camera perspective                                                                                                                                        
        glLoadIdentity(); //                                                                                                                                                
        gluPerspective(45.0, (double)w / (double)h, 1.0, 200.0);
}

//Draws the 3D scene                                                                                                                                                        
void drawScene() {
        //Clear information from last draw                                                                                                                                  
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        glMatrixMode(GL_MODELVIEW); //Switch to the drawing perspective                                                                                                     
        glLoadIdentity(); //Reset the drawing perspective                                                                                                                   
        glTranslatef(0, 0, -1);

        glBegin(GL_LINES);
        //lines                                                                                                                                                             
        glVertex2f(0, 0);
        glVertex2f(0, .25);
        glEnd();
glutSwapBuffers(); //Send the 3D scene to the screen                                                                                                                
}

int main(int argc, char** argv) {
        //Initialize GLUT                                                                                                                                                   
        glutInit(&argc, argv);
        glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
        glutInitWindowSize(400, 400); //Set the window size                                                                                                                 

        //Create the window                                                                                                                                                 
        glutCreateWindow("Basic Shapes - videotutorialsrock.com");
        initRendering(); //Initialize rendering                                                                                                                             

        //Set handler functions for drawing, keypresses, and window resizes                                                                                                 
        glutDisplayFunc(drawScene);
        //glutKeyboardFunc(handleKeypress);                                                                                                                                 
        glutReshapeFunc(handleResize);

        cout << "GLUT_WINDOW_X: " << GLUT_WINDOW_X << endl;
        cout << "GlUT_WINDOW_Y: " << GLUT_WINDOW_Y << endl;

        glutMainLoop(); //Start the main loop.  glutMainLoop doesn't return.                                                                                                
        return 0; //This line is never reached                                                                                                                              
}

This gives me the following result:

What does not make sense to me is that my window has dimension 400 X 400 but the coordinates: glVertex2f(0, 0) and glVertex2f(0, .25) . draw a line from about the center of the window to about 80% of the height of the window. I have a few speculations:

I know that my call to glTranslatef(0, 0, -1); sets the origin to the global coordinate (0, 0, -1) What is puzzling to me:

1. How does the -1 correspond to moving the image that far over?
2. Does the .25 in the second coordinate correspond to 25% of the height?
3. What would the code look like to draw a line from (WINDOW_LENGTH/2, 0) to (WINDOW_LENGTH/2, WINDOW_HEIGHT/2) That is the line from the bottom center of the window to the center of the window.

If you need more information let me know.

Answer 1

Let me try answer your questions:

1. You are working in a model-view (world to view) system. So you start modelling in world coordinates and transform it to the view coordinates. Therefore, glTranslatef is moving your world 1 coordinates points away from de camera.

2. What you do in openGL is weakly related to your windows coordinates. So, 0.25 really means 0.25 to openGL and nothing more. This means that you can stablish any semantics to points, like meters, kilometres, milimeters and so on. The correlation between openGL buffer and windows coordinates is stablished in the function gluPerspective, in which it says, basically, the region of your world that must be mapped to your windows coordinate system. The second function, glViewport only says how this map will be translated to you windows coordinates. In your case, you are telling to use all the windows.

3. As I said before, you need to manipulate your gluPerspective to control how much the openGL world will be mapped to your windows coordinates. To do that, you change the angle of the perspective. Greater angles, more openGL regions will be mapped, and you get an effect of zoom out. Lesser angles, less openGL regions will be mapped, and you get an effect of zoom in