OpenGL 3.3。 索引精灵仅显示调色板的第一种颜色。 我究竟做错了什么？

Question

我正在尝试在 OpenGL 3.3 中创建一个复古精灵类型的环境。 更具体地说，使用调色板。 从我发现和使用的资源来看，一切都应该是好的。 但事实并非如此。 我的精灵一直忽略索引像素，只使用它在调色板中找到的第一种颜色。

资料来源：

• 调色板纹理
• 相关问题的回答

源代码：如果你想运行它，你可以通过此链接下载并构建源代码，它使用 CMake 并与 Windows 和 Unix 兼容

#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <vector>
#include <stdio.h>

GLFWwindow* _window = nullptr;
GLuint vertex_buffer = 0;
GLuint uv_buffer = 0;
GLuint shaderProgram = 0;

void SetupWindow() {
    if (!glfwInit())
    {
        fprintf(stderr, "Failed to initialize GLFW\n");
        return;
    }
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    _window = glfwCreateWindow(1280, 720, "PaletteProblem", NULL, NULL);

    if (_window == NULL) {
        fprintf(stderr, "Failed to open GLFW window. If you have an Intel GPU, they are not 3.3 compatible. Try the 2.1 version of the tutorials.\n");
        glfwTerminate();
        return;
    }
    glfwMakeContextCurrent(_window);

    if (!gladLoadGL()) {
        fprintf(stderr, "Failed to initialize GLAD.\n");
        glfwTerminate();
    }
}

void SetupVertexandUV() {
    GLfloat VertexBuffer[12]{};

    VertexBuffer[0] = -0.5f;
    VertexBuffer[1] =  0.5f;

    VertexBuffer[2] =  0.5f;
    VertexBuffer[3] =  0.5f;

    VertexBuffer[4] =  0.5f;
    VertexBuffer[5] = -0.5f;

    VertexBuffer[6] =  0.5f;
    VertexBuffer[7] = -0.5f;

    VertexBuffer[8] = -0.5f;
    VertexBuffer[9] = -0.5f;

    VertexBuffer[10] = -0.5f;
    VertexBuffer[11] =  0.5f;

    GLfloat UVBuffer[12]{};

    UVBuffer[0] = 0.0f;
    UVBuffer[1] = 0.0f;

    UVBuffer[2] = 1.0f;
    UVBuffer[3] = 0.0f;

    UVBuffer[4] = 1.0f;
    UVBuffer[5] = 1.0f;

    UVBuffer[6] = 1.0f;
    UVBuffer[7] = 1.0f;

    UVBuffer[8] = 0.0f;
    UVBuffer[9] = 1.0f;

    UVBuffer[10] = 0.0f;
    UVBuffer[11] = 0.0f;

    glGenBuffers(1, &vertex_buffer);
    glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
    glBufferData(GL_ARRAY_BUFFER, 12 * 4, VertexBuffer, GL_STATIC_DRAW);

    glGenBuffers(1, &uv_buffer);
    glBindBuffer(GL_ARRAY_BUFFER, uv_buffer);
    glBufferData(GL_ARRAY_BUFFER, 12 * 4, UVBuffer, GL_STATIC_DRAW);
}

GLuint TextureSampler = 0;
GLuint PaletteSampler = 0;

const char* vertex_shader =
"#version 330 core\n"
"layout(location = 0) in vec2 vertexPosition;\n"
"layout(location = 1) in vec2 uvPosition;\n"
"out vec2 UV;\n"
"void main()\n"
"{\n"
"   gl_Position = vec4(vertexPosition.x ,vertexPosition.y, 0.0f, 1.0f);\n"
"   UV = uvPosition;\n"
"};\0";

const char* fragment_shader =
"#version 330 core\n"
"in vec2 UV;\n"
"out vec4 FragColor;\n"
"uniform sampler2D myTextureSampler;\n"
"uniform sampler1D myPaletteSampler;\n"
"void main()\n"
"{\n"
"   vec4 index = texture2D(myTextureSampler, UV);\n"
"   vec4 texel = texture(myPaletteSampler, index.r);\n"
"   FragColor = texel;\n"
//" FragColor = texture2D(myTextureSampler, UV);\n"
"};\0";

void SetupSpriteandPalette() {
    //Drawing a smiley face where: the body should be red, eyes should be green and mouth should be blue
    char indexedsprite[8 * 8]{
        0,0,0,0,0,0,0,0,
        0,0,1,0,0,1,0,0,
        0,0,1,0,0,1,0,0,
        0,0,0,0,0,0,0,0,
        0,2,0,0,0,0,2,0,
        0,2,2,2,2,2,2,0,
        0,0,2,2,2,2,0,0,
        0,0,0,0,0,0,0,0,
    };

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

    //For testing the sprite without using the palette, only un-comment when FragColor = texture2D(myTextureSampler, UV);
    //for (int i = 0; i < 64; i++) {
    //    indexedsprite[i] *= 85;
    //}
    //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

    glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, 8, 8, 0, GL_RED, GL_UNSIGNED_BYTE, indexedsprite);
    
    //Setting up a palette of four colors in an RGBA format
    char PaletteColors[4 * 4]{
        //RED
        255,
        0,
        0,
        255,

        //GREEN
        0,
        255,
        0,
        255,

        //BLUE
        0,
        0,
        255,
        255,

        //YELLOW
        255,
        255,
        0,
        255,
    };

    glGenTextures(1, &PaletteSampler);
    glBindTexture(GL_TEXTURE_1D, PaletteSampler);
    glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA, 12, 0, GL_RGBA, GL_UNSIGNED_BYTE, PaletteColors);

}

void SetupShaders() {
    GLint Result = GL_FALSE;
    int InfoLogLength;


    // Compile Vertex Shader
    GLuint VertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(VertexShader, 1, &vertex_shader, nullptr);
    glCompileShader(VertexShader);

    // Check Vertex Shader
    glGetShaderiv(VertexShader, GL_COMPILE_STATUS, &Result);
    glGetShaderiv(VertexShader, GL_INFO_LOG_LENGTH, &InfoLogLength);
    if (InfoLogLength > 0) {
        std::vector<char> VertexShaderErrorMessage(InfoLogLength + 1);
        glGetShaderInfoLog(VertexShader, InfoLogLength, nullptr, &VertexShaderErrorMessage[0]);
        printf("%s", &VertexShaderErrorMessage[0]);
    }

    // Compile Fragment Shader
    GLuint FragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(FragmentShader, 1, &fragment_shader, nullptr);
    glCompileShader(FragmentShader);

    // Check Fragment Shader
    glGetShaderiv(FragmentShader, GL_COMPILE_STATUS, &Result);
    glGetShaderiv(FragmentShader, GL_INFO_LOG_LENGTH, &InfoLogLength);
    if (InfoLogLength > 0) {
        std::vector<char> FragmentShaderErrorMessage(InfoLogLength + 1);
        glGetShaderInfoLog(FragmentShader, InfoLogLength, nullptr, &FragmentShaderErrorMessage[0]);
        printf("%s", &FragmentShaderErrorMessage[0]);
    }

    // Link the program
    shaderProgram = glCreateProgram();
    glAttachShader(shaderProgram, VertexShader);
    glAttachShader(shaderProgram, FragmentShader);
    glLinkProgram(shaderProgram);

    // Check the program
    glGetProgramiv(shaderProgram, GL_LINK_STATUS, &Result);
    glGetProgramiv(shaderProgram, GL_INFO_LOG_LENGTH, &InfoLogLength);
    if (InfoLogLength > 0) {
        std::vector<char> ProgramErrorMessage(InfoLogLength + 1);
        glGetProgramInfoLog(shaderProgram, InfoLogLength, nullptr, &ProgramErrorMessage[0]);
        printf("%s", &ProgramErrorMessage[0]);
    }

    glDeleteShader(VertexShader);
    glDeleteShader(FragmentShader);

    glUseProgram(shaderProgram);

    GLuint Init;
    glGenVertexArrays(1, &Init);
    glBindVertexArray(Init);
}

void DrawSprite() {

    GLuint vertexPositionID = glGetAttribLocation(shaderProgram, "vertexPosition");
    glEnableVertexAttribArray(vertexPositionID);
    glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
    glVertexAttribPointer(
        vertexPositionID,   // attribute 0. No particular reason for 0, but must match the layout in the shader.
        2,                  // size
        GL_FLOAT,           // type
        GL_FALSE,           // normalized?
        0,                  // stride
        (void*)0            // array buffer offset
    );

    GLuint uvPositionID = glGetAttribLocation(shaderProgram, "uvPosition");
    glEnableVertexAttribArray(uvPositionID);
    glBindBuffer(GL_ARRAY_BUFFER, uv_buffer);
    glVertexAttribPointer(
        uvPositionID,   // attribute 0. No particular reason for 0, but must match the layout in the shader.
        2,                  // size
        GL_FLOAT,           // type
        GL_FALSE,           // normalized?
        0,                  // stride
        (void*)0            // array buffer offset
    );
    glDrawArrays(GL_TRIANGLES, 0, 6); // Starting from vertex 0; 3 vertices total -> 1 triangle
    glDisableVertexAttribArray(vertexPositionID);
    glDisableVertexAttribArray(uvPositionID);
}

int main(void) {
    //Setting up the window, along with safety checks
    SetupWindow();

    //Setting up the shaders, along with safety checks
    SetupShaders();

    //Setting up the vertices and UVs for the sprite
    SetupVertexandUV();

    //Setting up the sprite and palette data
    SetupSpriteandPalette();

    do {

        glClearColor(0.1f, 0.4f, 0.8f, 0.0f);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        //Drawing the sprite and setting up the Vertex-Position and UV-Position
        DrawSprite();

        glfwSwapBuffers(_window);
        glfwPollEvents();
    } while (!glfwWindowShouldClose(_window));
    return 0;
}

我得到什么：

我期望的是：

有人知道我在这里做错了什么吗？

我试过设置 glActiveTextures。

我试过更改格式值。

我试过改变采样器类型。

Answer 1

我在您的代码中看到了几个问题。

首先，您创建大小为 12 的调色板纹理，但使用只有四个纹素的数组对其进行初始化。 你应该解决这个问题：

glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA, 4 /*HERE*/, 0, GL_RGBA, GL_UNSIGNED_BYTE, PaletteColors);

其次，也是最重要的问题，当你在着色器中对你的精灵进行采样时，你将得到一个 0 到 1 范围内的浮点数，而不是 0 到 255。然后在采样时这将被缩放到 0 到 4 范围内调色板纹理。 对于精灵中的小数字（0 到 2），您最终会在 0 到 2/255*4 = 0.0313 的位置对调色板进行采样； 使用最近邻插值，这是舍入调色板的第 0 个条目。

要解决这个问题，您可以撤消 OpenGL 所做的缩放：

"   vec4 index = texture2D(myTextureSampler, UV);\n"
"   vec4 texel = texture(myPaletteSampler, (index.r*255 + 0.5)/textureSize(myPaletteSampler).x);\n"
"   FragColor = texel;\n"

更好的方法可能是为精灵使用 integer 纹理（ GL_R8UI with GL_RED_INTEGER和usampler2D ）以在采样时禁用缩放，并为调色板使用texelFetch以在读取调色板时禁用缩放。 不过，您需要检查 OpenGL 3.3 中是否提供这些功能。