OpenGl翻译

Question

I'm trying to translate a triangle up to a fixed quad in a loop and don't know why my loop is running one less than the condition I've applied to run the loop . And the thing I couldn't understand that I have given a condition to translate triangle within the loop but after the condition satisfies for translation , if there are some more iterations left for the loop but no more translating condition satisfying , triangle comes back to its original position and I'm expecting triangle to its translated position.

Ps: I have to apply for multiple objects but 1st I'm only applying for a triangle.

Here is the code of display function.

void display(void){

float tr;

for (tr = 0.0; tr<=0.8; tr += 0.1)
{
    glClear(GL_COLOR_BUFFER_BIT);
    glMatrixMode(GL_MODELVIEW);

    glLoadIdentity();
    glPushMatrix();

    Thread::Sleep(100);

    cout <<tr<<endl;    // checking the loop variable values

    glBegin(GL_QUADS);  // making a fixed quad

    glColor3f(1.0f, 1.0f, 0.0f);
    glVertex3f(-0.5f, 0.0f, 0.0f);


    glColor3f(1.0f, 1.0f, 0.0f);
    glVertex3f(0.5f, 0.0f, 0.0f);

     glColor3f(1.0f, 1.0f, 0.0f);
     glVertex3f(0.5f, -1.0f, 0.0f);

     glColor3f(1.0f, 1.0f, 0.0f);
     glVertex3f(-0.5f, -1.0f, 0.0f);
     glEnd();

         if (tr<=0.5)    //condition to translate the triangle 
         glTranslatef(0.0,-tr, 0.0);


     glBegin(GL_TRIANGLES); //Triangle to be translated

     glColor3f(0.2f, 0.6f, 0.2f);
     glVertex3f(-0.5f, 0.5f, 0.0f);


     glColor3f(0.2f, 0.6f, 0.2f);
     glVertex3f(0.5f, 0.5f, 0.0f);

     glColor3f(0.2f, 0.6f, 0.2f);
     glVertex3f(0.0f, 1.0f, 0.0f);
     glEnd();

     glPopMatrix();


    glFlush();
}
}

Answer 1

Sounds from the comments like you got your code working, but I believe the real problem was elsewhere, and not related to OpenGL at all. It has to do with floating point precision. The issue is with this loop:

for (tr = 0.0; tr<=0.8; tr += 0.1)

Floating point values are represented in a binary format ( IEE 754 on most computers), with limited precision. While values like 0.1 and 0.8 can be represented precisely in a decimal floating point format, they cannot be precisely represented in the binary format your computer uses. Which means in your case that starting with 0.0 and adding 0.1 eight times will not result in exactly 0.8. I printed out the result with high precision for your loop, and it exits with a value of 0.80000007, one iteration earlier than you expected because that value is not <= the approximation of 0.8 anymore.

The robust way of doing what you intended is with a loop that looks like this:

for (int i = 0; i <= 8; ++i)
{
    float tr = i * 0.1f;

One minor item that is not causing your problem, but is very much related: You are mixing float and double precision values in your code. The constants 0.1 and 0.8 in your code are double values, while your variable is a float. If you mix float and double, the operations will be executed in double. For example, if you write tr += 0.1 , tr will first be converted to a double, then 0.1 added in double precision, and the result rounded back to a float. While there's no direct damage, this is inefficient and wasteful. When operating with floats, it's generally much better to use float constants, which would be 0.1f and 0.8f in this case.