Skip to content
The Chat Archive
gpt-3.5-turbo-0301· OpenAI WildChat-4.8M (AI2)

基于C语言和opengl 的glblendFunc实现将一张图片半透明另一张不透明渲染成1张图片输出

  1. User

    基于C语言和opengl 的glblendFunc实现将一张图片半透明另一张不透明渲染成1张图片输出

  2. Assistant

    首先,需要载入两张图片为纹理,并开启混合模式:

    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    
    GLuint texture1, texture2;
    // 载入图片为纹理,具体方法略
    

    然后,在渲染时使用glBindTexture将两张纹理绑定到当前的纹理单元:

    glBindTexture(GL_TEXTURE_2D, texture1);
    // 绘制第一张图片,具体方法略
    
    glBindTexture(GL_TEXTURE_2D, texture2);
    // 绘制第二张图片,具体方法略
    

    在绘制第二张图片时,需要注意设置绘制颜色为半透明:

    glColor4f(1.0f, 1.0f, 1.0f, 0.5f); // 半透明颜色
    
    // 绘制第二张图片
    

    完成绘制后,需要关闭混合模式:

    glDisable(GL_BLEND);
    

    完整代码如下:

    #include <GL/glut.h>
    
    GLuint texture1, texture2;
    
    void display() {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
        // 绘制第一张图片
        glBindTexture(GL_TEXTURE_2D, texture1);
        // 具体绘制方法略
    
        // 绘制第二张图片,使用半透明颜色
        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    
        glColor4f(1.0f, 1.0f, 1.0f, 0.5f);
        glBindTexture(GL_TEXTURE_2D, texture2);
        // 具体绘制方法略
    
        glDisable(GL_BLEND);
    
        glutSwapBuffers();
    }
    
    int main(int argc, char** argv) {
        glutInit(&argc, argv);
        glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
        glutInitWindowSize(800, 600);
        glutCreateWindow("Alpha blending");
    
        glEnable(GL_TEXTURE_2D);
    
        // 载入图片1和图片2为纹理,具体方法略
    
        glutDisplayFunc(display);
        glutMainLoop();
    
        return 0;
    }
    
  3. User

    如何使用opengl es3.2版本和C语言判断加载的图片是不是rgba

  4. Assistant

    在OpenGL ES 3.2中,可以使用glGetTexParameteriv()函数获取纹理参数。其中,GL_TEXTURE_INTERNAL_FORMAT参数表示纹理的内部格式,可以用于判断图片是否为RGBA格式。

    具体的代码实现如下:

    #include <GLES3/gl32.h>
    #include <stdio.h>
    
    GLuint texture;
    
    void load_texture(const char* file_path) {
        // 载入图片为纹理,具体方法略
    }
    
    void check_texture_format() {
        GLint internal_format;
        glBindTexture(GL_TEXTURE_2D, texture);
        glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_INTERNAL_FORMAT, &internal_format);
        printf("Internal format: %x\n", internal_format);
        if (internal_format == GL_RGBA || internal_format == GL_RGBA8) {
            printf("Texture is RGBA\n");
        } else {
            printf("Texture is not RGBA\n");
        }
    }
    
    int main(int argc, char** argv) {
        load_texture("path/to/texture.png");
        check_texture_format();
        return 0;
    }
    

    在上面的代码中,load_texture()函数用于载入图片为纹理,具体实现可以参照OpenGL ES 3.2官方文档。check_texture_format()函数用于检查纹理格式,首先绑定纹理,然后使用glGetTexParameteriv()函数获取纹理的内部格式,最后判断内部格式是否为GL_RGBA或GL_RGBA8,如果是则表明图片是RGBA格式。

  5. User

    如何使用opengl es3.2版本和C语言实现载入图片为纹理demo

  6. Assistant

    以下是一个OpenGL ES 3.2和C语言实现载入图片为纹理的简单例子:

    #include <stdio.h>
    #include <stdlib.h>
    #include <GLES3/gl32.h>
    
    GLuint load_texture(const char* file_path) {
        GLuint texture_id;
        int width, height;
        unsigned char* image_data;
    
        // 打开图片文件
        FILE* file = fopen(file_path, "rb");
        if (!file) {
            fprintf(stderr, "Error opening file %s\n", file_path);
            return 0;
        }
    
        // 读取图片宽度和高度
        fseek(file, 18, SEEK_SET);
        fread(&width, sizeof(width), 1, file);
        fread(&height, sizeof(height), 1, file);
    
        // 读取图片像素数据
        fseek(file, 54, SEEK_SET);
        image_data = (unsigned char*) malloc(width * height * sizeof(unsigned int));
        fread(image_data, sizeof(unsigned int), width * height, file);
    
        // 关闭文件
        fclose(file);
    
        // 创建纹理对象
        glGenTextures(1, &texture_id);
        glBindTexture(GL_TEXTURE_2D, texture_id);
    
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, image_data);
    
        free(image_data);
    
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    
        return texture_id;
    }
    
    int main(int argc, char** argv) {
        GLuint texture = load_texture("texture.png");
    
        // 使用纹理进行渲染,具体方法略
    
        return 0;
    }
    

    上面的例子中,load_texture()函数用于载入图片为纹理。首先,打开图片文件,读取图片宽度和高度,然后读取图片像素数据。接着,创建纹理对象,并将像素数据传入纹理对象中。最后,设置纹理的过滤和环绕参数,并返回纹理对象的ID。

    在使用纹理进行渲染时,可以使用上面的例子中返回的纹理ID绑定纹理对象,然后使用glDrawArrays()或glDrawElements()等OpenGL ES API进行渲染。

  7. User

    glTexImage2D和glGetTexParameteriv使用顺序

  8. Assistant

    glTexImage2D函数和glGetTexParameteriv函数是分别用于设置和获取纹理对象参数的OpenGL ES API函数,它们的使用顺序如下:

    1. 调用glGenTextures生成纹理对象,并将其绑定到当前纹理单元:

      GLuint texture_id;
      glGenTextures(1, &texture_id);
      glBindTexture(GL_TEXTURE_2D, texture_id);
      
    2. 调用glTexImage2D函数设置纹理的像素数据和格式:

      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, image_data);
      

      其中,第一个参数表示纹理的类型,第二个参数表示纹理的级别,如果使用mipmap,可以使用不同的级别来存储不同分辨率的纹理数据;第三个参数为纹理存储的颜色格式;第四个和第五个参数为纹理的宽度和高度;第六个参数为边框的宽度;第七个和第八个参数为颜色数据的格式和类型;最后一个参数为颜色数据。

    3. 调用glGetTexParameteriv函数获取纹理对象的参数:

      GLint param;
      glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, &param);
      

      其中,第一个参数为纹理的类型,第二个参数为获取的参数类型,可以是GL_TEXTURE_WRAP_S、GL_TEXTURE_WRAP_T、GL_TEXTURE_MIN_FILTER、GL_TEXTURE_MAG_FILTER等;第三个参数为输出的参数值。

    4. 调用glTexParameteri函数设置纹理对象的参数:

      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
      

      其中,第一个参数为纹理对象的类型,第二个参数为设置的参数类型,可以是GL_TEXTURE_WRAP_S、GL_TEXTURE_WRAP_T、GL_TEXTURE_MIN_FILTER、GL_TEXTURE_MAG_FILTER等;第三个参数为设置的参数值。

    在使用OpenGL ES API函数设置纹理参数时,应该按照上面的顺序进行调用,否则可能会出现一些错误。

  9. User

    基于C语言实现加载一张bmp图片,并去掉文件头信息头且对齐,获取像素数据

  10. Assistant

    以下是一个基于C语言实现加载一张bmp图片并获取像素数据的例子,其中去掉了文件头和信息头,并做了对齐:

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <GL/glut.h>
    
    typedef struct {
        unsigned short type; // 文件类型,必须是0x4D42
        unsigned int size; // 文件大小
        unsigned short reserved1; // 保留字段1
        unsigned short reserved2; // 保留字段2
        unsigned int offset; // 从文件头到像素数据的偏移量
        unsigned int header_size; // 信息头的大小
        unsigned int width; // 图像的宽度
        unsigned int height; // 图像的高度
        unsigned short planes; // 图像的颜色平面数
        unsigned short bits_per_pixel; // 每个像素的位数
        unsigned int compression; // 压缩类型
        unsigned int image_size; // 图像数据的大小
        unsigned int x_pixels_per_meter; // 水平分辨率
        unsigned int y_pixels_per_meter; // 垂直分辨率
        unsigned int colors_used; // 使用的颜色数
        unsigned int colors_important; // 重要颜色数
    } BMPHeader;
    
    void load_bmp(const char* path, unsigned char** data, int* width, int* height) {
        FILE* file = fopen(path, "rb");
        if (!file) {
            fprintf(stderr, "Error opening file %s\n", path);
            return;
        }
    
        BMPHeader header;
        fread(&header, sizeof(header), 1, file);
        *width = header.width;
        *height = header.height;
    
        printf("BMP header: size=%d, offset=%d, header_size=%d, width=%d, height=%d, bits_per_pixel=%d, image_size=%d\n",
               header.size, header.offset, header.header_size, header.width, header.height, header.bits_per_pixel, header.image_size);
    
        // 对齐行宽
        int row_size = ((header.width * header.bits_per_pixel + 31) / 32) * 4;
    
        // 分配内存
        *data = (unsigned char*) malloc(row_size * header.height);
    
        // 读取像素数据
        fseek(file, header.offset, SEEK_SET);
        unsigned char* row = (unsigned char*) malloc(row_size);
        for (int i = 0; i < header.height; i++) {
            fread(row, row_size, 1, file);
            memcpy(*data + row_size * i, row, row_size);
        }
        free(row);
    
        fclose(file);
    }
    
    int main(int argc, char** argv) {
        unsigned char* data;
        int width, height;
        load_bmp("texture.bmp", &data, &width, &height);
    
        // 使用像素数据进行渲染,具体方法略
    
        free(data);
    
        return 0;
    }
    

    上面的例子中,load_bmp()函数用于加载一张bmp图片并获取像素数据。首先,打开文件,读取BMPHeader结构体,其中包含了bmp文件的头信息和信息头,可以根据这些数据获取图片的宽度、高度、像素位数等信息。然后,重新计算每行像素数据的字节数并分配内存。接着,读取像素数据,并对齐到每行指定字节数。

    在使用像素数据进行渲染时,可以使用上面的例子中返回的像素数据指针和图片宽度、高度进行渲染,具体方法略。最后,需要记得释放分配的内存。

  11. User

    基于C语言和opengl es3.2版本加载两张NV12图片并进行alpha blend渲染通过fbo实现

  12. Assistant

    以下是一个基于C语言和OpenGL ES 3.2版本加载两张NV12格式图片,并通过FBO实现alpha blend渲染的例子:

    #include <stdio.h>
    #include <stdlib.h>
    #include <GLES3/gl32.h>
    
    GLuint texture1_y, texture1_uv, texture2_y, texture2_uv;
    GLuint program, vao, fbo;
    GLint texture1_y_loc, texture1_uv_loc, texture2_y_loc, texture2_uv_loc, alpha_loc;
    GLint width, height;
    
    void load_nv12(const char* file_path, GLuint* y_texture, GLuint* uv_texture) {
        // 打开文件
        FILE* file = fopen(file_path, "rb");
        if (!file) {
            fprintf(stderr, "Error opening file %s\n", file_path);
            return;
        }
    
        // 读取Y平面大小、UV平面大小、宽度和高度
        int y_size, uv_size;
        fread(&y_size, sizeof(int), 1, file);
        fread(&uv_size, sizeof(int), 1, file);
        fread(&width, sizeof(int), 1, file);
        fread(&height, sizeof(int), 1, file);
        printf("NV12 file: y_size=%d, uv_size=%d, width=%d, height=%d\n", y_size, uv_size, width, height);
    
        // 读取Y平面数据
        unsigned char* y_data = (unsigned char*) malloc(y_size);
        fread(y_data, 1, y_size, file);
    
        // 读取UV平面数据
        unsigned char* uv_data = (unsigned char*) malloc(uv_size);
        fread(uv_data, 1, uv_size, file);
    
        fclose(file);
    
        // 创建Y平面纹理对象
        glGenTextures(1, y_texture);
        glBindTexture(GL_TEXTURE_2D, *y_texture);
        glTexImage2D(GL_TEXTURE_2D, 0, GL_R8, width, height, 0, GL_RED, GL_UNSIGNED_BYTE, y_data);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    
        // 创建UV平面纹理对象
        glGenTextures(1, uv_texture);
        glBindTexture(GL_TEXTURE_2D, *uv_texture);
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RG8, width / 2, height / 2, 0, GL_RG, GL_UNSIGNED_BYTE, uv_data);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    
        free(y_data);
        free(uv_data);
    }
    
    void init_program() {
        // 着色器代码略
        const char* vertex_shader_source = "#version 320 es\n"
                                            "layout(location = 0) in vec2 position;\n"
                                            "layout(location = 1) in vec2 texcoord;\n"
                                            "out vec2 uv;\n"
                                            "void main() {\n"
                                            "  gl_Position = vec4(position, 0.0, 1.0);\n"
                                            "  uv = texcoord;\n"
                                            "}\n";
    
        const char* fragment_shader_source = "#version 320 es\n"
                                              "precision mediump float;\n"
                                              "in vec2 uv;\n"
                                              "uniform sampler2D y_texture1;\n"
                                              "uniform sampler2D uv_texture1;\n"
                                              "uniform sampler2D y_texture2;\n"
                                              "uniform sampler2D uv_texture2;\n"
                                              "uniform float alpha;\n"
                                              "out vec4 color;\n"
                                              "void main() {\n"
                                              "  vec3 yuv = vec3(texture(y_texture1, uv).r - 0.0625,\n"
                                              "                  texture(uv_texture1, uv).rg - vec2(0.5, 0.5));\n"
                                              "  vec3 rgb = mat3(1.0, 1.0, 1.0,\n"
                                              "                  0.0, -0.39465, 2.