RGBA图像显示异常求助：从RGB切换后画面失真

API 探路者

2026-6-30

RGBA格式纹理显示失真问题排查

问题描述

我实现了一个类，可以正常显示RGB格式的三角形图像，图像缓冲区是每个颜色分量占1字节的连续RGB数据：

RGB RGB ...
RGB RGB ...
...

正常RGB三角形图像

但当我添加Alpha通道，将图像缓冲区改为连续RGBA数据，并把glTexImage2D的参数从GL_RGB改为GL_RGBA后，图像出现了失真：

RGBA RGBA ...
RGBA RGBA ...
...

失真的RGBA图像

请问这是什么原因？

相关代码

头文件 `Screen.h`

#ifndef _SCREEN_H_
#define _SCREEN_H_

#include <GLFW/glfw3.h>
#include <stdint.h>
#include <string>

namespace Screen
{
    class Screen
    {
    public:
        Screen(){};
       ~Screen(){};

        bool initialize(uint32_t ScreenWidth, uint32_t ScreenHeight, std::string& Title);

        void display_image(uint8_t* ImageData, uint32_t ImageWidth, uint32_t ImageHeight);

        void deinitialize();

    private:
        GLFWwindow* _window                 = nullptr;
        uint32_t    _shader_program         = 0u;
        uint32_t    _object_vertex_array    = 0u;
        uint32_t    _object_vertex_buffer   = 0u;
        uint32_t    _object_element_buffer  = 0u;
        uint8_t*    _image_data             = nullptr;
    };
}

#endif // _SCREEN_H_

实现文件

#include <GL/glew.h>
#include <stdint.h>
#include <string>

#include "Screen.h"


namespace Screen
{
    namespace
    {
        bool build_shader_vertex(uint32_t& ShaderVertex)
        {
            const char* source_shader_vertex =
                "#version 330 core\n"
                "layout (location = 0) in vec4 input_position;\n"
                "layout (location = 1) in vec2 input_texture;\n"
                "out vec2 output_texture;\n"
                "void main()\n"
                "{\n"
                    "gl_Position    = input_position;\n"
                    "output_texture = input_texture;\n"
                "}\n"
                "\0";

            ShaderVertex = glCreateShader(GL_VERTEX_SHADER);

            glShaderSource(ShaderVertex, 1, &source_shader_vertex, NULL);

            glCompileShader(ShaderVertex);

            GLint success = 0;

            glGetShaderiv(ShaderVertex, GL_COMPILE_STATUS, &success);

            if (!success)
            {
                fprintf(stderr, "%s:%d:%s: Failed to compile vertex shader\n", __FILE__, __LINE__, __FUNCTION__);
                return false;
            }

            return true;
        }


        bool build_shader_fragment(uint32_t& ShaderFragment)
        {
            const char* source_shader_fragment =
                "#version 330 core\n"
                "out vec4 fragment_color;\n"
                "in  vec2 output_texture;\n"
                "uniform sampler2D sampled_texture;\n"
                "void main()\n"
                "{\n"
                    "fragment_color = texture(sampled_texture, output_texture);\n"
                "}\n"
                "\0";

            ShaderFragment = glCreateShader(GL_FRAGMENT_SHADER);

            glShaderSource(ShaderFragment, 1, &source_shader_fragment, NULL);

            glCompileShader(ShaderFragment);

            GLint success = 0;

            glGetShaderiv(ShaderFragment, GL_COMPILE_STATUS, &success);

            if (!success)
            {
                fprintf(stderr, "%s:%d:%s: Failed to compile fragment shader\n", __FILE__, __LINE__, __FUNCTION__);
                return false;
            }

            return true;
        }


        bool build_program(uint32_t& ShaderProgram)
        {
            bool        ret_val         = true;
            uint32_t    shader_vertex   = 0u;
            uint32_t    shader_fragment = 0u;
            GLint       success         = 0;

            if (!build_shader_vertex(shader_vertex))
            {
                fprintf(stderr, "%s:%d:%s: Failed to build shader\n", __FILE__, __LINE__, __FUNCTION__);
                ret_val = false;
                goto terminate;
            }

            if (!build_shader_fragment(shader_fragment))
            {
                fprintf(stderr, "%s:%d:%s: Failed to build shader\n", __FILE__, __LINE__, __FUNCTION__);
                ret_val = false;
                goto terminate;
            }

            ShaderProgram = glCreateProgram();

            glAttachShader(ShaderProgram, shader_vertex);
            glAttachShader(ShaderProgram, shader_fragment);

            glLinkProgram(ShaderProgram);

            glGetProgramiv(ShaderProgram, GL_LINK_STATUS, &success);

            if (!success)
            {
                fprintf(stderr, "%s:%d:%s: Failed to link shader program\n", __FILE__, __LINE__, __FUNCTION__);
                ret_val = false;
                goto terminate;
            }

        terminate:
            glDeleteShader(shader_vertex);
            glDeleteShader(shader_fragment);

            return ret_val;
        }
    }


    bool Screen::initialize(uint32_t ScreenWidth, uint32_t ScreenHeight, std::string& Title)
    {
        constexpr int32_t major_number = 3;
        constexpr int32_t minor_number = 3;

        uint32_t shader_program = 0u;

        if (glfwInit() != GLFW_TRUE)
        {
            fprintf(stderr, "%s:%d:%s: Failed to initialize GLFW\n", __FILE__, __LINE__, __FUNCTION__);
            return false;
        }

        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR,  major_number);
        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR,  minor_number);
        glfwWindowHint(GLFW_OPENGL_PROFILE,         GLFW_OPENGL_CORE_PROFILE);

        _window = glfwCreateWindow(ScreenWidth, ScreenHeight, Title.c_str(), NULL, NULL);

        if (!_window)
        {
            fprintf(stderr, "%s:%d:%s: Failed to create window\n", __FILE__, __LINE__, __FUNCTION__);
            return false;
        }

        glfwMakeContextCurrent(_window);

        if (glewInit() != GLEW_OK)
        {
            fprintf(stderr, "%s:%d:%s: Failed to initialize GLEW\n", __FILE__, __LINE__, __FUNCTION__);
            return false;
        }

        if (!build_program(shader_program))
        {
            fprintf(stderr, "%s:%d:%s: Failed to initialize GLEW\n", __FILE__, __LINE__, __FUNCTION__);
            return false;
        }

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

        unsigned int indices[] = 
        {
            0, 1, 3,
            1, 2, 3,
        };

        unsigned int VBO, VAO, EBO;
        glGenVertexArrays(1, &VAO);
        glGenBuffers(1, &VBO);
        glGenBuffers(1, &EBO);

        glBindVertexArray(VAO);

        glBindBuffer(GL_ARRAY_BUFFER, VBO);
        glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

        glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0);
        glEnableVertexAttribArray(0);

        glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)(4 * sizeof(float)));
        glEnableVertexAttribArray(1);

        unsigned int texture;

        glGenTextures(1, &texture);
        glBindTexture(GL_TEXTURE_2D, texture);

        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

        glUseProgram(shader_program);

        glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

        return true;
    }


    void Screen::display_image(uint8_t* ImageData, uint32_t ImageWidth, uint32_t ImageHeight)
    {
//      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, ImageWidth, ImageHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, ImageData);
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, ImageWidth, ImageHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, ImageData);

        glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);

        glfwSwapBuffers(_window);

        glfwPollEvents();
    }


    void Screen::deinitialize()
    {
        if (_image_data)
        {
            delete[] _image_data;
        }

        glDeleteVertexArrays(1, &_object_vertex_array);
        glDeleteBuffers     (1, &_object_vertex_buffer);
        glDeleteBuffers     (1, &_object_element_buffer);

        _image_data = nullptr;

        glfwTerminate();
    }
}

问题原因与修复方案

核心原因

失真的本质是纹理对象的生命周期管理错误：你在initialize函数中创建的纹理是局部变量，函数执行完毕后变量销毁，OpenGL的纹理ID没有被持久化存储。后续调用display_image时，当前绑定的纹理状态已丢失，导致纹理数据上传到了错误的（或未初始化的）纹理对象中，最终显示异常。

修复步骤

1. 为类添加纹理ID成员变量

修改Screen类的私有成员，新增纹理ID存储：

private:
    GLFWwindow* _window                 = nullptr;
    uint32_t    _shader_program         = 0u;
    uint32_t    _object_vertex_array    = 0u;
    uint32_t    _object_vertex_buffer   = 0u;
    uint32_t    _object_element_buffer  = 0u;
    uint32_t    _texture_id             = 0u; // 新增纹理ID成员
    uint8_t*    _image_data             = nullptr;

2. 保存纹理ID到成员变量

在initialize函数中，替换原来的局部纹理变量，将ID存入类成员：

// 替换原有的unsigned int texture;
glGenTextures(1, &_texture_id);
glBindTexture(GL_TEXTURE_2D, _texture_id);

3. 上传纹理前绑定正确的纹理对象

在display_image函数开头，显式绑定我们保存的纹理ID：

void Screen::display_image(uint8_t* ImageData, uint32_t ImageWidth, uint32_t ImageHeight)
{
    glBindTexture(GL_TEXTURE_2D, _texture_id); // 新增绑定操作
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, ImageWidth, ImageHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, ImageData);

    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);

    glfwSwapBuffers(_window);
    glfwPollEvents();
}

4. 清理纹理资源

在deinitialize函数中添加纹理销毁逻辑：

void Screen::deinitialize()
{
    if (_image_data)
    {
        delete[] _image_data;
    }

    glDeleteTextures(1, &_texture_id); // 新增纹理销毁
    glDeleteVertexArrays(1, &_object_vertex_array);
    glDeleteBuffers     (1, &_object_vertex_buffer);
    glDeleteBuffers     (1, &_object_element_buffer);

    _image_data = nullptr;
    glfwTerminate();
}

额外说明

OpenGL的对象（纹理、VAO、VBO等）均通过ID引用，必须将这些ID保存到持久化变量（如类成员）中，否则函数结束后无法正确复用对象。
你设置的glPixelStorei(GL_UNPACK_ALIGNMENT, 1)对RGBA格式是安全的，因为每行字节数为宽度*4，天然满足4字节对齐要求，但显式设置1可以避免其他格式（如RGB）下的对齐问题。

内容的提问来源于stack exchange，提问作者Andre K

RGBA图像显示异常求助：从RGB切换后画面失真

问题描述 #

相关代码 #

头文件 Screen.h #

实现文件 #

问题原因与修复方案 #

核心原因 #

修复步骤 #