Point drawed over texture doesn't get the desired colour

Question

Important: I have to work with the fixed pipeline (I have no voice in this matter).

I have to modify some existing OpenGL code (a panoramic picture viewer, where the panorama is split into the six faces of a cube) so we're able to draw lines/points on top of the loaded textures, where the points are the mouse coordinates unprojected to object coordinates.

I wrote a test program with a coloured cube just to try the line painting on top of it:

I got this with the code pushing the GL_DEPTH_BUFFER_BIT attribute to the stack, disabling it before painting the points and poping the stack attribute after I have done with the painting.

I tried to use that same approach in the existing application, but I got these results (here, I'm trying only to paint a point):

I specified red as the color for the point but, as you can see, it doesn't have the desired one. I thought it might be due to blending and that it might be mixing its color with the underlying texture, so I pushed the GL_BLEND attribute to the stack as well and disabled it before painting, but the point isn't getting the desired color anyway.

What is happening here? Is there a way to "force" the pipeline to paint the point red?

initCube() : this is call before updating the GL scene.

 void panoViewer::initCube() {
    makeCurrent();
    if(texture){
        glDisable( texture );
        textName = 0;
        texture = 0;
    }

    glDisable( GL_TEXTURE_GEN_S );
    glDisable( GL_TEXTURE_GEN_T );
    glDisable( GL_TEXTURE_GEN_R );

    glFrontFace( GL_CCW );
    glEnableClientState(GL_VERTEX_ARRAY);
    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
    glDisableClientState(GL_NORMAL_ARRAY);

    texture = GL_TEXTURE_CUBE_MAP;
    textName = texnms[1];
    glEnableClientState(GL_NORMAL_ARRAY);
    glTexGenf( GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP );
    glTexGenf( GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP );
    glTexGenf( GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP );
    glEnable( GL_TEXTURE_GEN_S );
    glEnable( GL_TEXTURE_GEN_T );
    glEnable( GL_TEXTURE_GEN_R );

    // Add the textures to the cube faces.
    // ...
 }

initializeGL() :

 void panoViewer::initializeGL() {
    qglClearColor(Qt::black);
    glShadeModel(GL_SMOOTH);
    glEnable(GL_CULL_FACE);
    glEnable( GL_DEPTH_TEST );

  // create texture objects
    glGenTextures( 1, textName );
    glBindTexture( GL_TEXTURE_CUBE_MAP, textName );

  // find the largest feasible textures
    maxTex2Dsqr = maxTexSize( GL_PROXY_TEXTURE_2D, max2d, max2d );
    maxTex2Drec = maxTexSize( GL_PROXY_TEXTURE_2D, max2d, max2d / 2 );
    maxTexCube = maxTexSize( GL_PROXY_TEXTURE_CUBE_MAP, maxcube, maxcube );

  // constant texture mapping parameters...
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
  // for cube maps...
    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

  // enable alpha blending for overlay
    glEnable (GL_BLEND);
    glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);


    glEnable(GL_POINT_SMOOTH);
    glEnable(GL_LINE_SMOOTH);
    glHint(GL_POINT_SMOOTH_HINT, GL_NICEST);
    glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
    glDisable(GL_LIGHTING);

    // Create display list: dispList
    // ...
 }

paintGL() :

 void panoViewer::paintGL() {
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    if(texture) {
        glBindTexture(texture, textName);
        glEnable( texture );
    }

    glMatrixMode(GL_TEXTURE);
    glLoadIdentity();
        glRotated( 180, 0, 1, 0 );   // camera looks at the front of the van
        glRotated( 180, 0, 0, 1 );   // van's roof points to the sky

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();

//    double hFOV, vFOV;    // angular size at sphere center (deg)
//    double minFOV, maxFOV; // limits on vFOV
//    double wFOV;  // vert angle at eye (deg) sets magnification

    double  hhnear = Znear * tan( 0.5 * RAD(wFOV) ),
            hwnear = hhnear * aspectRatio,
            dxnear = 2 * hwnear * fcompx,
            dynear = 2 * hhnear * fcompy;

    glFrustum( -(hwnear + dxnear), hwnear - dxnear,
               -(hhnear + dynear), hhnear - dynear,
               Znear, Zfar
              );
    glRotated( 180, 0, 1, 0 );
    glTranslated( eyex, eyey, eyez );

    glRotated( tiltAngle, 1, 0, 0 );
    glRotated( panAngle, 0, 1, 0 );
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    glCallList(dispList);

    glPushAttrib(GL_ENABLE_BIT | GL_DEPTH_BUFFER_BIT);
        glDisable(GL_BLEND);
        glDisable(GL_DEPTH_TEST);

        // Paint the point in red
        // ...
    glPopAttrib();
}

UPDATE: I forgot to mention that the code is based in Qt. It uses the QtOpenGL module extensively.

UPDATE #2: I've added some code.

Answer 1

In the fixed function pipeline, there are many states which could lead to the vertex color beeing completely ignored.

As Reto Koradi pointed out in the comments, when lighting is enabled, the colors have no effect (unless GL_COLOR_MATERIAL is enabled, in which case the color value is used to update the material parameters used for the lighting equation.)

As I pointed out in the comments, another case is texturing. Depending on the GL_TEX_ENV_MODE selected, the fragment's color (as determined by lighting, or directly interpolated from the vertex colors) is modulated by the texture color, or completely replaced. In that case, disabling texturing for every texture unit in use can solve the issue.