opengl translatef - opengl

Question

#include <iostream>
#include <X11/Xlib.h>
#include <GL/glut.h>
#include <GL/glui.h>
using namespace std;
GLsizei wh = 500;
GLsizei ww = 500;
void MyInit();
void DisplayLine(void);
void DisplaySquare(void );
void MyInit()
{
glClearColor( 1, 1, 1, 0 );
glColor3f( 1, 0, 0 );
glPointSize( 10 );
glMatrixMode( GL_MODELVIEW );
glLoadIdentity( );
glOrtho( 0.0, ww, 0.0, wh, -1.0, 1.0 );
}
void DisplayLine()
{
glClear( GL_COLOR_BUFFER_BIT );
glBegin( GL_LINES );
glVertex2i( 100, 100 );
glVertex2i( 170, 170 );
glVertex2i( 30, 370 );
glVertex2i( 160, 50 );
glEnd( );
glFlush( );
}
void DisplaySquare()
{
glClear( GL_COLOR_BUFFER_BIT );
glBegin( GL_LINE_STRIP );
glBegin( GL_POLYGON );
glVertex2f( 150, 150 );
glVertex2f( 350, 150 );
glVertex2f( 350, 350 );
glVertex2f( 150, 350 );
glVertex2f( 150, 150 );
glEnd( );
glFlush( );
}
void DisplayRSquare()
{
glClear( GL_COLOR_BUFFER_BIT );
#if 0
glMatrixMode( GL_MODELVIEW );
glLoadIdentity( );
glBegin( GL_LINE_LOOP );
glVertex2f( 50, 50 );
glVertex2f( 250, 250 );
glVertex2f( 50, 250 );
glEnd( );
#endif
glBegin( GL_LINE_LOOP );
glVertex2f( 0, 0 );
glVertex2f( 500, 0 );
glVertex2f( 500, 500 );
glVertex2f( 0, 500 );
glEnd( );
glTranslatef( 100, 0, 0 );
#if 0
glRotatef( 20, 0, 0, 1 );
glTranslatef( -50, -50, 0 );
glColor3f( 0, 1, 0 );
glBegin( GL_LINE_LOOP );
glVertex2f( 0, 0 );
glVertex2f( 500, 0 );
glVertex2f( 500, 500 );
glVertex2f( 0, 500 );
glEnd( );
glBegin( GL_LINE_LOOP );
glVertex2f( 50, 50 );
glVertex2f( 250, 50 );
glVertex2f( 250, 250 );
glVertex2f( 50, 250 );
glEnd( );
glRotatef( 12, 0, 0, 1 );
glBegin( GL_LINE_LOOP );
glVertex2f( 75, 75 );
glVertex2f( 75, 550 );
glVertex2f( 550, 550 );
glVertex2f( 550, 75 );
glEnd( );
glFlush( );
glBegin( GL_LINES );
glVertex2f( 0, 0 );
glVertex2f( 150, 150 );
glEnd()
#endif
glFlush( );
}
void DisplayCube()
{
glClear( GL_COLOR_BUFFER_BIT );
glBegin( GL_LINE_STRIP );
glBegin( GL_POLYGON );
glVertex2i( 150, 150 );
glVertex2i( 350, 150 );
glVertex2i( 350, 350 );
glVertex2i( 150, 350 );
glVertex2i( 150, 150 );
glEnd( );
glBegin( GL_LINE_STRIP );
glBegin( GL_POLYGON );
glVertex2i( 250, 250 );
glVertex2i( 450, 250 );
glVertex2i( 450, 450 );
glVertex2i( 250, 450 );
glVertex2i( 250, 250 );
glEnd( );
glBegin( GL_LINE_STRIP );
glBegin( GL_LINES );
glVertex2i( 150, 150 );
glVertex2i( 250, 250 );
glVertex2i( 350, 150 );
glVertex2i( 450, 250 );
glVertex2i( 350, 350 );
glVertex2i( 450, 450 );
glVertex2i( 150, 350 );
glVertex2i( 250, 450 );
glEnd( );
glFlush( );
}
void DisplayRotate()
{
glClear( GL_COLOR_BUFFER_BIT );
glColor3f( 0.0, 1.0, 0.0 );
glMatrixMode( GL_MODELVIEW );
glLoadIdentity( );
for( int angle = 0; angle < 18; angle += 3 )
{
glRotatef( angle, 1, 0, 0 );
if( angle > 8 )
{
glRotatef( angle * 2, 1, 0.0, 0 );
glColor3f( 1.0, 0.0, 0.0 );
}
glBegin( GL_LINE_LOOP );
glVertex2f( 150, 150 );
glVertex2f( 350, 150 );
glVertex2f( 350, 350 );
glVertex2f( 150, 350 );
glEnd( );
}
glFlush( );
}
void pressMouse(int button, int state, int x, int y )
{
if( state == GLUT_DOWN )
{
glBegin( GL_POINTS );
glPointSize( 50 );
glVertex2i( x, wh - y );
glEnd( );
glFlush( );
}
}
void holdMouse(int x, int y )
{
glBegin( GL_POINTS );
glPointSize( 50 );
glVertex2i( x, wh - y );
glEnd( );
glFlush( );
}
void mouse(int btn, int state, int x, int y )
{
if( state == GLUT_DOWN )
{
mouseState = state;
mouseButton = btn;
mouseX = x;
mouseY = y;
}
else
{
mouseState = 0;
}
}
void motion(int x, int y )
{
if( mouseState == GLUT_DOWN )
{
if( MouseButton == GLUT_LEFT_BUTTON )
{
yrotation -= ( mouseX - x );
xrotation -= ( mouseY - y );
}
}
mouseX = x;
mouseY = y;
glutPostRedisplay( );
}
void DisplayFSquare()
{
glClear( GL_COLOR_BUFFER_BIT );
glColor3f( 0, 0, 1 );
glBegin( GL_LINE_LOOP );
glVertex2f( ( GLdouble ) 0.25, ( GLdouble ) 0.25 );
glVertex2f( ( GLdouble ) 0.75, ( GLdouble ) 0.25 );
glVertex2f( ( GLdouble ) 0.75, ( GLdouble ) .75 );
glVertex2f( ( GLdouble ) 0.25, ( GLdouble ) 0.75 );
glEnd( );
glFlush( );
}
int main(int argc, char **argv )
{
glutInit( &argc, argv );
glutInitDisplayMode( GLUT_SINGLE | GLUT_RGB );
glutInitWindowSize( ww, wh );
glutInitWindowPosition( 150, 150 );
glutCreateWindow( "Line" );
MyInit( );
glutDisplayFunc( DisplayRSquare );
glutMouseFunc( pressMouse );
glutMotionFunc( holdMouse );
glutMainLoop( );
}
I have just created several trivial models to test the basic transformation. I have two questions:
DisplayRSquare : in this function I draw a square with the window size and want to move it to (100, 0), but it translated to (200, 0). And if I move it to (50, 0) it will move to (100, 0).
What more weird is, the program sometimes works and sometimes not.
For function glVertex2f(0.3,0.7), we should find a point in the position 0.3*widthofthewindow, 0.7* height of the window, right? But I cannot find it. I have to compute the coordinates and run glVertex2f(0.3*width,0.7*height).
My compiling command is g++ -o line Line.cpp -lGL -lGLU -lglut -lglui
and just run ./line(File name is Line.cpp)

Answer 1

Please speak with me: "OpenGL is not a scene graph! – It doesn't maintain a scene, and all it does is executing drawing commands, drawing single points, lines and triangles, one at a time."
Your code lacks certain basic steps. First you need to setup a proper projection and modelview matrix. You put a projective matrix (ortho) in the modelview matrix at the beginning of your program. And then you just multiply, and multiply and multiply and multiply on the modelview matrix, without ever resetting it to a known (identity) state.
The coarse outline of every fixed function OpenGL display process is about the following:
set clear color and depth, then clear
set viewport and projection matrix
matrix mode projection
load identity
multiply projection (ortho or perspective)
set initial view matrix
matrix mode modelview
load identity
setup view (lookat or whatever)
draw geometry
for each object
matrix mode modelview
push matrix
apply local transformation
draw object
pop matrix
Update 1
First a rewriting of your program, that works in a predictible way and does what you originally indended.
Find answers to your questions after it
#include <GL/glut.h>
void DrawRSquare(
float sz,
float tx,
float ty )
{
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
/*
Order of operations matters.
Drawing commands use the current state
of OpenGL, which includes the transformation
matrix state. So this must be set before
drawing.
*/
glTranslatef(tx, ty, 0);
glColor3f(1, 0, 0);
glBegin( GL_LINE_LOOP );
glVertex2f( 0, 0 );
glVertex2f( sz, 0 );
glVertex2f( sz, sz );
glVertex2f( 0, sz );
glEnd();
glPopMatrix();
}
void Display(void)
{
glClearColor( 1, 1, 1, 0 );
glClear( GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT );
const int windim[2] = {
glutGet(GLUT_WINDOW_WIDTH),
glutGet(GLUT_WINDOW_HEIGHT)
};
glViewport(0, 0, windim[0], windim[1]);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0.0, windim[0], 0.0, windim[1], -1, 1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
DrawRSquare(50, 100, 0);
DrawRSquare(50, 200, 100);
glutSwapBuffers();
}
int main(
int argc,
char **argv )
{
glutInit( &argc, argv );
glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGB );
glutCreateWindow( "" );
glutDisplayFunc( Display );
glutMainLoop( );
}
Actually the program is running DisplayRSquare, in this function I draw a square same size with the window we created and want to more it with the vector (100,0) in the 2-D space but actually it translated (200,0). And if you change the vector into (50,0), it will move (100,0).
The reason for this is, that your Display function is probably called thrice and then no more. In the first call of DisplayRSquare a translation of (100,0,0) is applied after drawing some lines when the window is created but not yet exposed. Then the window gets exposed and the next redraw applies another (100,0,0) to the already set transformation. But still the window gets exposed another time and now the square will be drawn once again, now with the (100,0,0) + (100,0,0) applied. If you resize your window, the square would futher translate away until out of view with each redraw.
That's why you must reset your OpenGL state into a well known state before beginning any drawing.
What is more wired, the program sometimes works well. Sometimes not. My code is glTranslatef(100,0,0). For the same program ,sometimes it translate 100, sometime 200......Kind of wired...
What happens is, that the amount of redraw events your programm receives varies. This is by moving other windows over it, iconizing and revertig it, etc.
For function glVertex2f(0.3,0.7), we should find a point in the position 0.3*widthofthewindow, 0.7* height of the window, right?
This entirely depends on the set projection and modelview matrices. Without knowing how those are set, and your program never sets them into a well defined state, we don't know.
But I cannot find it.
Quite likely, because your transformation matrices will be way off, of what you indended.
I have to compute the coordinates and run glVertex2f(0.3*width,0.7*height)?
No. Well, at least not in the way you think.
A suggestion: You're using the fixed function pipeline and immediate mode. Both are severely outdated and deprecated. In fact they have been stripped out of recent versions of OpenGL, so I'd not even bother learning them.
If you want to learn modern OpenGL, I stronly suggest you read and work through the tutorial of Nicol Bolas, which is IMHO one of the best you can find at the moment:
http://arcsynthesis.org/gltut