2

c++ で opengl と sdl を使用して画像を表示すると、奇妙なエラーが発生します。これは私が見ているものです：

上部と構造の輪郭の周りに灰色の線があります。

上部と構造の輪郭の周りに灰色の線があります。これはあってはなりません。これは私が表示しようとしている画像です:

画像はpngで、黒い背景はopenglを介して追加されます

画像は png で、黒い背景は OpenGL を介して追加されます。

関連するすべてのコードを以下に投稿しました。これらのエラーが発生した理由を誰か教えてください。

この関数は、画像を表示するために使用されます。

renderTexture("modules/solarpanel/base.png", 10, 10, 1.0);

これはrenderTexture関数です:

struct AbstTexture {
    GLuint texture;
    int w;
    int h;
};

void renderTexture(std::string textureFile, int x, int y, float zoom) {
    AbstTexture texture = loadTexture(textureFile);

    glUseProgram(PROGRAM_SIMPLE_TEXTURE);

    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, texture.texture);

    glBindBuffer(GL_ARRAY_BUFFER, vertexBufferObject);

    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, 0);


    GLfloat box[] = {
        (float) x, (float) y, 0, 0,
        (float) x + (float) texture.w * zoom, (float) y, 1, 0,
        (float) x, (float) y + (float) texture.h * zoom, 0, 1,
        (float) x + (float) texture.w * zoom, (float) y + (float) texture.h * zoom, 1, 1,
    };

    glBufferData(GL_ARRAY_BUFFER, sizeof(box), box, GL_DYNAMIC_DRAW);
    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);


    glBindBuffer(GL_ARRAY_BUFFER, 0);

    glUseProgram(0);
};

これは loadTexture 関数です:

std::unordered_map<std::string, AbstTexture> loadedTextures;

AbstTexture loadTexture(std::string textureFile) {
    AbstTexture texture;

    std::unordered_map<std::string, AbstTexture>::const_iterator got = loadedTextures.find(textureFile);
    if(got == loadedTextures.end()) {
        std::string textureFilePath = "res/textures/" + textureFile;

        SDL_Surface * loadSurface = IMG_Load(textureFilePath.c_str());

        if(!loadSurface) {
            std::cout << "SDL_Image load error: " << IMG_GetError() << std::endl;
        }
        if(loadSurface->format->BytesPerPixel < 2) {
            std::cout << "Bad image - not true color!" << std::endl;
        }

        texture.w = loadSurface->w;
        texture.h = loadSurface->h;

        void * raw = (void *) malloc(texture.w * texture.h * 4);
        Uint8 * dstPixel = (Uint8 *) raw;

        SDL_LockSurface(loadSurface);

        int bpp = loadSurface->format->BytesPerPixel;

        Uint8 * srcPixel;
        Uint32 truePixel;
        for(int y = texture.h - 1; y >= 0; y--) {
            for(int x = 0; x < texture.w; x++) {
                srcPixel = (Uint8 *) loadSurface->pixels + y * loadSurface->pitch + x * bpp;
                switch(bpp) {
                    case 1:
                        truePixel = *srcPixel;
                        break;
                    case 2:
                        truePixel = *(Uint16 *) srcPixel;
                        break;
                    case 3:
                        if(SDL_BYTEORDER == SDL_BIG_ENDIAN) {
                            truePixel = srcPixel[0] << 16 | srcPixel[1] << 8 | srcPixel[2];
                        } else {
                            truePixel = srcPixel[0] | srcPixel[1] << 8 | srcPixel[2] << 16;
                        }
                        break;
                    case 4:
                        truePixel = *(Uint32 *) srcPixel;
                        break;
                    default:
                        std::cout << "Image bpp of " << bpp << " unusable" << std::endl;
                        break;
                }

                SDL_GetRGBA(truePixel, loadSurface->format, &(dstPixel[0]), &(dstPixel[1]), &(dstPixel[2]), &(dstPixel[3]));

                dstPixel += 4;
            }
        }

        SDL_UnlockSurface(loadSurface);
        SDL_FreeSurface(loadSurface);

        while(glGetError()) {}

        glGenTextures(1, &(texture.texture));
        glBindTexture(GL_TEXTURE_2D, texture.texture);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

        GLenum errorCode;
        errorCode = glGetError();
        if(errorCode != 0) {
            if(errorCode == GL_OUT_OF_MEMORY) {
                std::cout << "Out of texture memory!" << std::endl;
            }
        }

        gluBuild2DMipmaps(GL_TEXTURE_2D, 4, texture.w, texture.h, GL_RGBA, GL_UNSIGNED_BYTE, (Uint8 *) raw);

        errorCode = glGetError();
        if(errorCode != 0) {
            if(errorCode == GL_OUT_OF_MEMORY) {
                std::cout << "Out of texture memory!" << std::endl;
            }
        }

        loadedTextures.emplace(textureFile, texture);
    } else {
        texture = got->second;
    }

    return texture;
};

これは、使用される OpenGL プログラムの構成です。

GLuint PROGRAM_SIMPLE_TEXTURE = glCreateProgram();
GLuint vertexBufferObject;

glUseProgram(PROGRAM_SIMPLE_TEXTURE);
glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glUseProgram(0);

そして最後に、使用中の OpenGL シェーダー:

vertex shader: #version 330\n\nlayout(location = 0) in vec4 position;\nuniform vec2 screensize;\nvarying vec2 texcoord;\n\nvoid main() {\n  gl_Position = vec4(position.x / screensize.x * 2 - 1, (1 - position.y / screensize.y) * 2 - 1, 0, 1);\n texcoord = vec2(position.z, position.w * -1);\n}

fragment shader: "#version 330\n\nuniform vec4 color;\nuniform sampler2D tex;\nvarying vec2 texcoord;\n\nvoid main() {\n    gl_FragColor = texture2D(tex, texcoord);\n}"
4

1 に答える 1

7

PNG の透明部分を黒にします (ただし、透明のままです)。OpenGL はピクセルを隣接するピクセルとブレンドし、それらの隣接するピクセルは透明ですが白であるため、結果はグレーのアウトラインになります。

于 2013-10-17T13:48:48.283 に答える