CImg图像是无色的

Question

目前我正在基础级编辑器程序中改进函数，允许我保存我创建的地图。它吐出了生成的地图的.bmp图像。它是通过我刚刚发现的名为CImg的库来实现的，我几乎一无所知。一切似乎都有效，但生成的.bmp图像没有着色，而是以不同的黑白色调出现。就像我说的那样，我基本上对图书馆一无所知，所以如果你知道这里可能出现什么问题，我将不胜感激。

这是保存功能：

void Map::Save() {
    Vertex top_left_most, top_right_most, bottom_left_most;
    int img_w = 0, img_h = 0;

    std::vector<std::pair<GLuint, GLuint>>::iterator tl = bufferIDs.begin();            //This little block gives the _most variables valid starting vals
    glBindBuffer(GL_ARRAY_BUFFER, tl->second);
    glGetBufferSubData(GL_ARRAY_BUFFER, sizeof(TextureCoord), sizeof(Vertex), &top_left_most);
    top_right_most = bottom_left_most = top_left_most;


    for (auto i = bufferIDs.begin(); i != bufferIDs.end(); ++i) {   //SEEKS TOP LEFT MOST TILE ON MAP
        Vertex current_coord;
        glBindBuffer(GL_ARRAY_BUFFER, i->second);
        glGetBufferSubData(GL_ARRAY_BUFFER, sizeof(TextureCoord), sizeof(Vertex), &current_coord);

        if ((current_coord.x < top_left_most.x && current_coord.y < top_left_most.y) ||
            (current_coord.x == top_left_most.x && current_coord.y < top_left_most.y) ||
            (current_coord.x < top_left_most.x && current_coord.y == top_left_most.y)) {

            top_left_most = current_coord;
        }
    }

    for (auto i = bufferIDs.begin(); i != bufferIDs.end(); ++i) {   //SEEKS TOP RIGHT MOST TILE ON MAP
        Vertex current_coord;
        glBindBuffer(GL_ARRAY_BUFFER, i->second);
        glGetBufferSubData(GL_ARRAY_BUFFER, sizeof(TextureCoord), sizeof(Vertex), &current_coord);

        if ((current_coord.x > top_right_most.x && current_coord.y < top_right_most.y) ||
            (current_coord.x == top_right_most.x && current_coord.y < top_right_most.y) ||
            (current_coord.x > top_right_most.x && current_coord.y == top_right_most.y)) {

            top_right_most = current_coord;
        }
    }

    for (auto i = bufferIDs.begin(); i != bufferIDs.end(); ++i) {   //SEEKS BOTTOM LEFT MOST TILE ON MAP
        Vertex current_coord;
        glBindBuffer(GL_ARRAY_BUFFER, i->second);
        glGetBufferSubData(GL_ARRAY_BUFFER, sizeof(TextureCoord), sizeof(Vertex), &current_coord);

        if ((current_coord.x < bottom_left_most.x && current_coord.y > bottom_left_most.y) ||
            (current_coord.x == bottom_left_most.x && current_coord.y > bottom_left_most.y) ||
            (current_coord.x < bottom_left_most.x && current_coord.y == bottom_left_most.y)) {

            bottom_left_most = current_coord;
        }
    }

    img_w = (top_right_most.x + 64) - top_left_most.x;      //Calculating image dimensions for the buffer
    img_h = (bottom_left_most.y + 64) - top_left_most.y;

    GLuint *image = new GLuint[img_w * img_h];      //Creating the image buffer

    int int_start_x = 0;        //start_x and y that will be used in buffer pointer positioning computations
    int int_start_y = 0;

    //these nested fors fill the buffer
    for (GLfloat start_y = top_left_most.y; start_y != bottom_left_most.y + 64; start_y += 64) {

        for (GLfloat start_x = top_left_most.x; start_x != top_right_most.x + 64; start_x += 64) {

            bool in_map = false;
            std::vector<std::pair<GLuint, GLuint>>::iterator valid_tile;
            for (auto i = bufferIDs.begin(); i != bufferIDs.end(); ++i) {           //This for checks to see if tile corresponding to start_x & y is present in map
                Vertex current_tile_pos;
                glBindBuffer(GL_ARRAY_BUFFER, i->second);
                glGetBufferSubData(GL_ARRAY_BUFFER, sizeof(TextureCoord), sizeof(Vertex), &current_tile_pos);

                if (current_tile_pos.x == start_x && current_tile_pos.y == start_y) {
                    in_map = true;
                    valid_tile = i;
                    break;
                }
            }

            GLuint *imagepos = image;       //Repositioning the pointer into the final image's buffer
            imagepos += int_start_x + (int_start_y * img_w);

            if (in_map) {       //if in map, that tile's texture is used to fill the corresponding part of the image buffer
                GLuint *texture = new GLuint[64 * 64];
                glBindTexture(GL_TEXTURE_2D, valid_tile->first);
                glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, texture);
                GLuint *texturepos = texture;

                for (GLuint ypos = 0; ypos != 64; ++ypos) {
                    std::memcpy(imagepos, texturepos, 64 * 4);
                    texturepos += 64;
                    imagepos += img_w;
                }

                if (texture) 
                    delete[] texture;
            }
            else {              //otherwise, a default all-black array is used to fill the corresponding untiled part of the image buffer
                GLuint *black_buffer = new GLuint[64 * 64];
                GLuint *blackpos = black_buffer;
                GLuint solid_black;
                char *p = (char *)&solid_black;
                p[0] = 0;
                p[1] = 0;
                p[2] = 0;
                p[3] = 255;

                for (GLuint i = 0; i != 64 * 64; ++i) {
                    black_buffer[i] = solid_black;
                }

                for (GLuint ypos = 0; ypos != 64; ++ypos) {
                    std::memcpy(imagepos, blackpos, 64 * 4);
                    blackpos += 64;
                    imagepos += img_w;
                }

                if (black_buffer)
                    delete[] black_buffer;

            }
            int_start_x += 64;
        }
        int_start_x = 0;
        int_start_y += 64;
    }

    cimg_library::CImg<GLuint> final_image(image, img_w, img_h);   //no color!!

    final_image.save_bmp("map.bmp");

    if (image)
        delete[] image;
}

如果某些说明有所帮助，Vertex是两个struct的简单GLfloat（TextureCoord}，bufferIDs是{ std::vector个std::pair个GLuint个{1}}，第一个表示纹理ID，第二个表示VBO ID。

以下是请求的示例图片：

what the image should look like (this is in monochrome)

Same exact image as above, but created using the reinterpret_cast method

Answer 1

你的行

cimg_library::CImg<GLuint> final_image(image, img_w, img_h);

如果您期望彩色图像，那么

是错误的，因为这会创建单个通道图像。你需要一个3来制作3个频道 - 一个用于红色，一个用于绿色，一个用于蓝色。

此外，您的数据存储在GLuint中，这意味着将像这样存储4x2像素的图像，即逐个像素地交错：

RGBA RGBA RGBA RGBA
RGBA RGBA RGBA RGBA

而 CImg 希望以频段交错的平面方式存储它：

RRRRRRRR
GGGGGGGG
BBBBBBBB
AAAAAAAA

此link解释了 CImg 内存缓冲区的布局。