c++ - 即使片段 alpha 为 1.0，合成器也会混合 OpenGL

Question

以下代码(一个简单的最小示例)在纯色屏幕顶部生成一个三角形。三角形和屏幕颜色的 alpha 值为 1.0，但当程序在启用合成器(X11/KDE 系统设置)的情况下运行时，颜色仍会与窗口后面的任何内容合并。产生的效果就像窗口有一个不透明度设置(标题栏除外，所以它不是窗口不透明度值)。

我尽力避免这种行为，更改 X Visuals，更改 Egl 配置，深度，禁用 opengl 混合，更改混合函数等...我发现防止它的唯一方法是将视觉效果更改为 24 位，但随后它不再组合，我想要组合，因为我希望输出的某些部分被混合，但不是所有部分并且不受控制。

这是一个最小的可重现示例:

//
//compilation example:   g++ test.cpp -o test -lEGL -lX11 -lGLX -lOpenGL
//
#include  <iostream>
#include  <cstdlib>
#include  <cstring>

#include  <cmath>
#include  <sys/time.h>

#include  <X11/Xlib.h>
#include  <X11/Xatom.h>
#include  <X11/Xutil.h>

#define GL_GLEXT_PROTOTYPES
#include <GL/gl.h>
#include <GL/glext.h>
#include  <EGL/egl.h>

const char *vertexShaderSource=
    "#version 330 core\n"
    "layout (location=0) in vec3 aPos;\n"
    "void main(){gl_Position = vec4 (aPos.x,aPos.y,aPos.z,1.0);}"
    ;

const char *fragmentShaderSource =
    "#version 330 core\n"
    "out vec4 FragColor;\n"
    "void main(){FragColor = vec4 (1.0,0.5f,0.2f,1.0f);}"
    ;

float vertices[] = {    -0.5f, -0.5f, 0.0f, 0.5f, -0.5f, 0.0f, 0.0f,  0.5f, 0.0f  };

GLuint load_shader ( const char  *shader_source, GLenum type )
{
   GLuint  shader = glCreateShader( type );
   glShaderSource  ( shader , 1 , &shader_source , nullptr );
   glCompileShader ( shader );
   return shader;
}
bool someerror=false;
template<typename T>
T &showError(const char * err,T&t)
{
    if (!t)
    {
        someerror=true;
        std::cerr<<err<<std::endl;
    }
    return t;
}
template<typename T>
const T &showError(const char * err,const T&t)
{
    if (!t)
    {
        someerror=true;
        std::cerr<<err<<std::endl;
    }
    return t;
}

int main(int, char**)
{
    auto display=XOpenDisplay(nullptr);
    showError("Error opening display",display);
    auto egl_display=eglGetDisplay(EGL_CAST(EGLNativeDisplayType,display));
    showError("Error opening egl display",egl_display);
    showError("Error initializing egl",eglInitialize(egl_display,nullptr,nullptr));
    showError("Error binding api",eglBindAPI(EGL_OPENGL_API));


    auto screen=DefaultScreen(display);
    Window parentWin=RootWindow(display,screen);


    XVisualInfo vinfo;

    Window win;
    XSetWindowAttributes setWAtt;

    //
    // Change UseDepth=24 to avoid compositor at all
    //
    auto UseDepth=32;
    if (!XMatchVisualInfo(display, screen, UseDepth, TrueColor, &vinfo))
    {
        win=XCreateWindow(display,parentWin,0,0,800,480,0,CopyFromParent,InputOutput,CopyFromParent,0,nullptr);
    }
    else
    {
        setWAtt.colormap = XCreateColormap(display, parentWin, vinfo.visual, AllocNone);
        setWAtt.background_pixel = 0xffffffff;
        setWAtt.border_pixel = 0xffffffff;
        auto valueMask=CWColormap|CWBorderPixel|CWBackPixel;
        win=XCreateWindow(display,parentWin,0,0,800,480,0,vinfo.depth, InputOutput, vinfo.visual,valueMask,&setWAtt);
    }
    showError("Error creating window",win);

    XWMHints hints;
    hints.input = true;
    hints.flags = InputHint;
    XSetWMHints(display, win, &hints);

    XMapWindow ( display , win );

    XSync(display,false);

    EGLint attr[] = {EGL_RED_SIZE,8,EGL_GREEN_SIZE,8,EGL_BLUE_SIZE,8,EGL_NONE};

    EGLConfig  ecfg[200];
    EGLint     num_config;
    showError("Error choosing egl config",eglChooseConfig( egl_display, attr, ecfg, 200, &num_config ));
    EGLSurface egl_surface;
    int matchConfig=0;
    for (;matchConfig<num_config;matchConfig++)
    {
        egl_surface = eglCreateWindowSurface ( egl_display, ecfg[matchConfig], win, nullptr );
        if ( egl_surface)
            break;
    }
    showError("Error creating surface",egl_surface);

    EGLint ctxattr[] = { EGL_NONE  };
    auto egl_context = eglCreateContext ( egl_display, ecfg[matchConfig], EGL_NO_CONTEXT, ctxattr );
    showError("Error creating context",egl_context);

    eglMakeCurrent( egl_display, egl_surface, egl_surface, egl_context );

    GLuint vertexShader   = load_shader ( vertexShaderSource , GL_VERTEX_SHADER  );
    GLuint fragmentShader = load_shader ( fragmentShaderSource , GL_FRAGMENT_SHADER );

    GLuint shaderProgram  = glCreateProgram ();
    glAttachShader ( shaderProgram, fragmentShader );
    glAttachShader ( shaderProgram, vertexShader );

    glLinkProgram ( shaderProgram );
    glUseProgram  ( shaderProgram );


    while (!someerror)
    {
        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);
        glVertexAttribPointer ( 0, 3, GL_FLOAT, false, 0, vertices );
        glEnableVertexAttribArray ( 0 );
        glDrawArrays(GL_TRIANGLES,0,3);
        eglSwapBuffers ( egl_display, egl_surface );
    }

    return 0;
}

生成的输出，左侧启用了合成器，右侧未启用:

我的目标是在启用合成器的情况下生成类似的东西:

我的测试平台:

• OpenSuse 风滚草 20201018
• KDE/Plasma 5.19.5
• GeForce RTX 2070 SUPER(带 nvidia 驱动程序)
• Xorg 服务器 1.20.9
• 内核 5.8.14

Answer 1

碰巧的是，用于创建egl_texture的视觉配置没有alpha位，在这种情况下，输出会与后面的内容合并，至少在我的硬件/软件中是这样。因此，要修复该行为，需要更改:

//    EGLint attr[] = {EGL_RED_SIZE,8,EGL_GREEN_SIZE,8,EGL_BLUE_SIZE,8,,EGL_NONE};
    EGLint attr[] = {EGL_RED_SIZE,8,EGL_GREEN_SIZE,8,EGL_BLUE_SIZE,8,EGL_ALPHA_SIZE,8,EGL_NONE};

在我看来，如果 Composer 得到一个去除了 alpha 的输出，并且因为表面有 alpha 位，它决定进行混合。我不认为它是否是有意为之和/或记录在案的。