Texture is rendered blank but glGetTexImage works perfectly

Question

I've written some code that adds a UI overlay to an existing OpenGL application.
Unfortunately, I am not proficient in OpenGL but I do know that it somehow always manages to fail on some device.
Some backstory:

The general pipeline is:
Application renders -> UI is rendered to FBO -> FBO is blitted to obtain an RGBA texture -> Texture is drawn on top of the UI scene.

So far so good, then I encountered an issue on Intel cards on Ubuntu 16.04 where the texture broke between context switches (UI rendering is done using a QOpenGLContext, application is raw OpenGL context managed by OGRE but the QOpenGLContext is set to share resources). I solved that issue by checking if sharing works (create a texture in one context and check if the content is correct in the other) and if not, I load the content while still in context B and upload it again in context A. However, on Ubuntu 18.04 on the same machine for some reason, this will actually work. The texture is still correct in the other context when retrieving its content with glGetTexImage.

Now here's the problem: It's not being rendered. I get just the application scene without anything on top but if I manually enable the workaround of downloading it and reuploading to a texture that was created in the application context, it works.
How can it be that the texture's content is alright but it won't show unless I grab it using glGetTexImage and re-upload it to a texture created in the other context using glTexImage2D?
There's gotta be some state that is invalid and set correct when using glTexImage2D.

Here's the code after the UI is rendered:

if (!checked_can_share_texture_)
{
  qopengl_wrapper_->drawInvisibleTestOverlay();
}
qopengl_wrapper_->finishRender();
if ( !can_share_texture_ || !checked_can_share_texture_ )
{
  glBindTexture( GL_TEXTURE_2D, qopengl_wrapper_->texture());
  glGetTexImage( GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixel_data_ );
}
glBindTexture( GL_TEXTURE_2D, 0 );
qopengl_wrapper_->doneCurrent(); // Makes the applications context current again

glDisable( GL_DEPTH_TEST );
glDisable( GL_CULL_FACE );
glDisable( GL_LIGHTING );
glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );

glUseProgram(shader_program_);
glUniform1i(glGetUniformLocation(shader_program_, "tex"), 0);

glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer_object_);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), nullptr);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
glEnableVertexAttribArray(1);

glActiveTexture( GL_TEXTURE0 );
glEnable( GL_TEXTURE_2D );
if ( can_share_texture_ )
{
  glBindTexture( GL_TEXTURE_2D, qopengl_wrapper_->texture());
  if ( !checked_can_share_texture_)
  {
    const int count = qopengl_wrapper_->size().width() * qopengl_wrapper_->size().height() * 4;
    const int thresh = std::ceil(count / 100.f);
    unsigned char content[count];
    glGetTexImage( GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, content);
    int wrong = 0;
    // can_share_texture_ = false; // Bypassing the actual check will make it work
    for (int i = 0; i < count; ++i) {
      if (content[i] == pixel_data_[i]) continue;
      if (++wrong < thresh) continue;
      can_share_texture_ = false;
      LOG(
        "OverlayManager: Looks like texture sharing isn't working on your system. Falling back to texture copying." );

      // If we can't share textures, we have to generate one
      glActiveTexture( GL_TEXTURE0 );
      glGenTextures( 1, &texture_ );
      glBindTexture( GL_TEXTURE_2D, texture_ );
      glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER );
      glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER );
      glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
      glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
      break;
    }
    if (can_share_texture_)
    {
      delete pixel_data_;
      pixel_data_ = nullptr;
      LOG("Texture sharing seems supported. Count: %d", count);
    }
    checked_can_share_texture_ = true;
  }
}
else
{
  glBindTexture( GL_TEXTURE_2D, texture_ );
  glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, qopengl_wrapper_->size().width(), qopengl_wrapper_->size().height(), 0,
                GL_RGBA, GL_UNSIGNED_BYTE, pixel_data_ );
}
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glDisableVertexAttribArray(0);
glDisableVertexAttribArray(1);

glUseProgram(0);

Vertex Shader

#version 130
in vec3 pos;
in vec2 coord;

out vec2 texCoord;

void main()
{
 gl_Position = vec4(pos, 1.0);   //Just output the incoming vertex
 texCoord = coord;
}

Fragment Shader

#version 130
uniform sampler2D tex;
in vec2 texCoord;

void main()
{
  gl_FragColor = texture(tex, texCoord);
}

TL;DR Texture isn't rendered (completely transparent) but if I copy it to memory using glGetTexImage it looks fine and if I copy that back to a texture created on the application context, it will render fine.

Graphics card is an Intel UHD 620 with Mesa version 18.2.8.

Edit: In case it wasn't clear, I'm copying the texture in the context of the application not the texture's original context, the same context where the working texture is created, so, if sharing didn't work I shouldn't get the correct content at that point.

Texture is rendered blank but glGetTexImage works perfectly

0 Answers0