// SPDX-License-Identifier: MPL-2.0 // Copyright (c) Yuxuan Shui #include #include #include #include #include #include #include // for xcb_render_fixed_t, XXX #include "common.h" #include "compiler.h" #include "config.h" #include "kernel.h" #include "log.h" #include "region.h" #include "string_utils.h" #include "utils.h" #include "backend/gl/gl_common.h" #define GLSL(version, ...) "#version " #version "\n" #__VA_ARGS__ #define QUOTE(...) #__VA_ARGS__ GLuint gl_create_shader(GLenum shader_type, const char *shader_str) { log_trace("===\n%s\n===", shader_str); bool success = false; GLuint shader = glCreateShader(shader_type); if (!shader) { log_error("Failed to create shader with type %#x.", shader_type); goto end; } glShaderSource(shader, 1, &shader_str, NULL); glCompileShader(shader); // Get shader status { GLint status = GL_FALSE; glGetShaderiv(shader, GL_COMPILE_STATUS, &status); if (GL_FALSE == status) { GLint log_len = 0; glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &log_len); if (log_len) { char log[log_len + 1]; glGetShaderInfoLog(shader, log_len, NULL, log); log_error("Failed to compile shader with type %d: %s", shader_type, log); } goto end; } } success = true; end: if (shader && !success) { glDeleteShader(shader); shader = 0; } return shader; } GLuint gl_create_program(const GLuint *const shaders, int nshaders) { bool success = false; GLuint program = glCreateProgram(); if (!program) { log_error("Failed to create program."); goto end; } for (int i = 0; i < nshaders; ++i) glAttachShader(program, shaders[i]); glLinkProgram(program); // Get program status { GLint status = GL_FALSE; glGetProgramiv(program, GL_LINK_STATUS, &status); if (GL_FALSE == status) { GLint log_len = 0; glGetProgramiv(program, GL_INFO_LOG_LENGTH, &log_len); if (log_len) { char log[log_len + 1]; glGetProgramInfoLog(program, log_len, NULL, log); log_error("Failed to link program: %s", log); } goto end; } } success = true; end: if (program) { for (int i = 0; i < nshaders; ++i) glDetachShader(program, shaders[i]); } if (program && !success) { glDeleteProgram(program); program = 0; } return program; } /** * @brief Create a program from vertex and fragment shader strings. */ GLuint gl_create_program_from_str(const char *vert_shader_str, const char *frag_shader_str) { GLuint vert_shader = 0; GLuint frag_shader = 0; GLuint prog = 0; if (vert_shader_str) vert_shader = gl_create_shader(GL_VERTEX_SHADER, vert_shader_str); if (frag_shader_str) frag_shader = gl_create_shader(GL_FRAGMENT_SHADER, frag_shader_str); { GLuint shaders[2]; int count = 0; if (vert_shader) { shaders[count++] = vert_shader; } if (frag_shader) { shaders[count++] = frag_shader; } if (count) { prog = gl_create_program(shaders, count); } } if (vert_shader) glDeleteShader(vert_shader); if (frag_shader) glDeleteShader(frag_shader); return prog; } static void gl_free_prog_main(gl_win_shader_t *pprogram) { if (!pprogram) return; if (pprogram->prog) { glDeleteProgram(pprogram->prog); pprogram->prog = 0; } } /** * Render a region with texture data. * * @param ptex the texture * @param dst_x,dst_y the top left corner of region where this texture * should go. In Xorg coordinate system (important!). * @param reg_tgt the clip region, also in Xorg coordinate system * @param reg_visible ignored */ void gl_compose(backend_t *base, void *image_data, int dst_x, int dst_y, const region_t *reg_tgt, const region_t *reg_visible) { gl_texture_t *ptex = image_data; struct gl_data *gd = (void *)base; // Until we start to use glClipControl, reg_tgt, dst_x and dst_y and // in a different coordinate system than the one OpenGL uses. // OpenGL window coordinate (or NDC) has the origin at the lower left of the // screen, with y axis pointing up; Xorg has the origin at the upper left of the // screen, with y axis pointing down. We have to do some coordinate conversion in // this function if (!ptex || !ptex->texture) { log_error("Missing texture."); return; } // dst_y is the top coordinate, in OpenGL, it is the upper bound of the y // coordinate. dst_y = gd->height - dst_y; auto dst_y2 = dst_y - ptex->height; bool dual_texture = false; if (gd->win_shader.prog) { glUseProgram(gd->win_shader.prog); if (gd->win_shader.unifm_opacity >= 0) { glUniform1f(gd->win_shader.unifm_opacity, (float)ptex->opacity); } if (gd->win_shader.unifm_invert_color >= 0) { glUniform1i(gd->win_shader.unifm_invert_color, ptex->color_inverted); } if (gd->win_shader.unifm_tex >= 0) { glUniform1i(gd->win_shader.unifm_tex, 0); } if (gd->win_shader.unifm_dim >= 0) { glUniform1f(gd->win_shader.unifm_dim, (float)ptex->dim); } } // log_trace("Draw: %d, %d, %d, %d -> %d, %d (%d, %d) z %d\n", // x, y, width, height, dx, dy, ptex->width, ptex->height, z); // Bind texture glBindTexture(GL_TEXTURE_2D, ptex->texture); if (dual_texture) { glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, ptex->texture); glActiveTexture(GL_TEXTURE0); } // Painting int nrects; const rect_t *rects; rects = pixman_region32_rectangles((region_t *)reg_tgt, &nrects); glBegin(GL_QUADS); for (int ri = 0; ri < nrects; ++ri) { // Y-flip. Note after this, crect.y1 > crect.y2 rect_t crect = rects[ri]; crect.y1 = gd->height - crect.y1; crect.y2 = gd->height - crect.y2; // Calculate texture coordinates // (texture_x1, texture_y1), texture coord for the _bottom left_ corner auto texture_x1 = (GLfloat)(crect.x1 - dst_x); auto texture_y1 = (GLfloat)(crect.y2 - dst_y2); auto texture_x2 = texture_x1 + (GLfloat)(crect.x2 - crect.x1); auto texture_y2 = texture_y1 + (GLfloat)(crect.y1 - crect.y2); // X pixmaps might be Y inverted, invert the texture coordinates if (ptex->y_inverted) { texture_y1 = (GLfloat)ptex->height - texture_y1; texture_y2 = (GLfloat)ptex->height - texture_y2; } // GL_TEXTURE_2D coordinates are normalized // TODO use texelFetch texture_x1 /= (GLfloat)ptex->width; texture_y1 /= (GLfloat)ptex->height; texture_x2 /= (GLfloat)ptex->width; texture_y2 /= (GLfloat)ptex->height; // Vertex coordinates GLint vx1 = crect.x1; GLint vy1 = crect.y2; GLint vx2 = crect.x2; GLint vy2 = crect.y1; // log_trace("Rect %d: %f, %f, %f, %f -> %d, %d, %d, %d", // ri, rx, ry, rxe, rye, rdx, rdy, rdxe, rdye); GLfloat texture_x[] = {texture_x1, texture_x2, texture_x2, texture_x1}; GLfloat texture_y[] = {texture_y1, texture_y1, texture_y2, texture_y2}; GLint vx[] = {vx1, vx2, vx2, vx1}; GLint vy[] = {vy1, vy1, vy2, vy2}; for (int i = 0; i < 4; i++) { glVertexAttrib2f((GLuint)gd->win_shader.in_texcoord, texture_x[i], texture_y[i]); glVertex3i(vx[i], vy[i], 0); } } glEnd(); // Cleanup glBindTexture(GL_TEXTURE_2D, 0); glColor4f(0.0f, 0.0f, 0.0f, 0.0f); glDisable(GL_COLOR_LOGIC_OP); if (dual_texture) { glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, 0); glActiveTexture(GL_TEXTURE0); } glUseProgram(0); gl_check_err(); return; } /** * Blur contents in a particular region. */ bool gl_blur(backend_t *base, double opacity, const region_t *reg_blur, const region_t *reg_visible) { // Remainder: regions are in Xorg coordinates struct gl_data *gd = (void *)base; const rect_t *extent = pixman_region32_extents((region_t *)reg_blur); int width = extent->x2 - extent->x1, height = extent->y2 - extent->y1; int dst_y = gd->height - extent->y2; if (width == 0 || height == 0) { return true; } // these should be arguments bool ret = false; int curr = 0; glReadBuffer(GL_BACK); glBindTexture(GL_TEXTURE_2D, gd->blur_texture[0]); // Copy the area to be blurred into tmp buffer glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, extent->x1, dst_y, width, height); for (int i = 0; i < gd->npasses; ++i) { assert(i < MAX_BLUR_PASS - 1); const gl_blur_shader_t *p = &gd->blur_shader[i]; assert(p->prog); assert(gd->blur_texture[curr]); glBindTexture(GL_TEXTURE_2D, gd->blur_texture[curr]); glUseProgram(p->prog); if (i < gd->npasses - 1) { // not last pass, draw into framebuffer glBindFramebuffer(GL_DRAW_FRAMEBUFFER, gd->blur_fbo); glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, gd->blur_texture[!curr], 0); glDrawBuffer(GL_COLOR_ATTACHMENT0); if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) { log_error("Framebuffer attachment failed."); goto end; } glUniform1f(p->unifm_opacity, 1.0); } else { // last pass, draw directly into the back buffer glBindFramebuffer(GL_FRAMEBUFFER, 0); glDrawBuffer(GL_BACK); glUniform1f(p->unifm_opacity, (float)opacity); } glUniform1f(p->unifm_offset_x, 1.0f / (GLfloat)gd->width); glUniform1f(p->unifm_offset_y, 1.0f / (GLfloat)gd->height); // XXX use multiple draw calls is probably going to be slow than // just simply blur the whole area. int nrects; const rect_t *rect = pixman_region32_rectangles((region_t *)reg_blur, &nrects); glBegin(GL_QUADS); for (int j = 0; j < nrects; j++) { rect_t crect = rect[j]; // flip y axis, because the regions are in Xorg's coordinates, // which is y-flipped from OpenGL's. crect.y1 = gd->height - crect.y1; crect.y2 = gd->height - crect.y2; // Texture coordinates auto texture_x1 = (GLfloat)(crect.x1 - extent->x1); auto texture_y1 = (GLfloat)(crect.y2 - dst_y); auto texture_x2 = texture_x1 + (GLfloat)(crect.x2 - crect.x1); auto texture_y2 = texture_y1 + (GLfloat)(crect.y1 - crect.y2); texture_x1 /= (GLfloat)gd->width; texture_x2 /= (GLfloat)gd->width; texture_y1 /= (GLfloat)gd->height; texture_y2 /= (GLfloat)gd->height; // Vertex coordinates // For passes before the last one, we are drawing into a buffer, // so (dx, dy) from source maps to (0, 0) GLint vx1 = crect.x1 - extent->x1; GLint vy1 = crect.y2 - dst_y; if (i == gd->npasses - 1) { // For last pass, we are drawing back to source, so we // don't need to map vx1 = crect.x1; vy1 = crect.y2; } GLint vx2 = vx1 + (crect.x2 - crect.x1); GLint vy2 = vy1 + (crect.y1 - crect.y2); GLfloat texture_x[] = {texture_x1, texture_x2, texture_x2, texture_x1}; GLfloat texture_y[] = {texture_y1, texture_y1, texture_y2, texture_y2}; GLint vx[] = {vx1, vx2, vx2, vx1}; GLint vy[] = {vy1, vy1, vy2, vy2}; for (int k = 0; k < 4; k++) { glVertexAttrib2f((GLuint)p->in_texcoord, texture_x[k], texture_y[k]); glVertex3i(vx[k], vy[k], 0); } } glEnd(); glUseProgram(0); curr = !curr; } ret = true; end: glBindFramebuffer(GL_FRAMEBUFFER, 0); glBindTexture(GL_TEXTURE_2D, 0); gl_check_err(); return ret; } static GLint glGetUniformLocationChecked(GLuint p, const char *name) { auto ret = glGetUniformLocation(p, name); if (ret < 0) { log_error("Failed to get location of uniform '%s'. compton might not " "work correctly.", name); } return ret; } // clang-format off const char *vertex_shader = GLSL(130, uniform mat4 projection; in vec2 in_texcoord; out vec2 texcoord; void main() { gl_Position = projection * gl_Vertex; texcoord = in_texcoord; } ); // clang-format on /** * Load a GLSL main program from shader strings. */ static int gl_win_shader_from_string(const char *vshader_str, const char *fshader_str, gl_win_shader_t *ret) { // Build program ret->prog = gl_create_program_from_str(vshader_str, fshader_str); if (!ret->prog) { log_error("Failed to create GLSL program."); return -1; } // Get uniform addresses ret->unifm_opacity = glGetUniformLocationChecked(ret->prog, "opacity"); ret->unifm_invert_color = glGetUniformLocationChecked(ret->prog, "invert_color"); ret->unifm_tex = glGetUniformLocationChecked(ret->prog, "tex"); ret->unifm_dim = glGetUniformLocationChecked(ret->prog, "dim"); ret->in_texcoord = glGetAttribLocation(ret->prog, "in_texcoord"); gl_check_err(); return true; } /** * Callback to run on root window size change. */ void gl_resize(struct gl_data *gd, int width, int height) { glViewport(0, 0, width, height); gd->height = height; gd->width = width; // Note: OpenGL matrices are column major GLfloat projection_matrix[4][4] = {{2.0f / (GLfloat)width, 0, 0, 0}, {0, 2.0f / (GLfloat)height, 0, 0}, {0, 0, 0, 0}, {-1, -1, 0, 1}}; if (gd->npasses > 0) { // Resize the temporary textures used for blur glBindTexture(GL_TEXTURE_2D, gd->blur_texture[0]); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, gd->width, gd->height, 0, GL_BGRA, GL_UNSIGNED_BYTE, NULL); if (gd->npasses > 1) { glBindTexture(GL_TEXTURE_2D, gd->blur_texture[1]); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, gd->width, gd->height, 0, GL_BGRA, GL_UNSIGNED_BYTE, NULL); } // Update projection matrices in the blur shaders for (int i = 0; i < gd->npasses; i++) { assert(gd->blur_shader[i].prog); glUseProgram(gd->blur_shader[i].prog); int pml = glGetUniformLocationChecked(gd->blur_shader[i].prog, "projection"); glUniformMatrix4fv(pml, 1, false, projection_matrix[0]); } } // Update projection matrix in the win shader glUseProgram(gd->win_shader.prog); int pml = glGetUniformLocationChecked(gd->win_shader.prog, "projection"); glUniformMatrix4fv(pml, 1, false, projection_matrix[0]); glUseProgram(gd->fill_shader.prog); pml = glGetUniformLocationChecked(gd->fill_shader.prog, "projection"); glUniformMatrix4fv(pml, 1, false, projection_matrix[0]); gl_check_err(); } // clang-format off static const char fill_frag[] = GLSL(120, uniform vec4 color; void main() { gl_FragColor = color; } ); static const char fill_vert[] = GLSL(130, in vec2 in_coord; uniform mat4 projection; void main() { gl_Position = projection * vec4(in_coord, 0, 1); } ); // clang-format on void gl_fill(backend_t *base, double r, double g, double b, double a, const region_t *clip) { int nrects; const rect_t *rect = pixman_region32_rectangles((region_t *)clip, &nrects); struct gl_data *gd = (void *)base; GLuint bo[2]; glGenBuffers(2, bo); glUseProgram(gd->fill_shader.prog); glUniform4f(gd->fill_shader.color_loc, (GLfloat)r, (GLfloat)g, (GLfloat)b, (GLfloat)a); glEnableVertexAttribArray((GLuint)gd->fill_shader.in_coord_loc); glBindBuffer(GL_ARRAY_BUFFER, bo[0]); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bo[1]); auto coord = ccalloc(nrects * 8, GLint); auto indices = ccalloc(nrects * 6, GLuint); for (int i = 0; i < nrects; i++) { memcpy(&coord[i * 8], (GLint[][2]){{rect[i].x1, gd->height - rect[i].y2}, {rect[i].x2, gd->height - rect[i].y2}, {rect[i].x2, gd->height - rect[i].y1}, {rect[i].x1, gd->height - rect[i].y1}}, sizeof(GLint[2]) * 4); indices[i * 6 + 0] = (GLuint)i * 4 + 0; indices[i * 6 + 1] = (GLuint)i * 4 + 1; indices[i * 6 + 2] = (GLuint)i * 4 + 2; indices[i * 6 + 3] = (GLuint)i * 4 + 2; indices[i * 6 + 4] = (GLuint)i * 4 + 3; indices[i * 6 + 5] = (GLuint)i * 4 + 0; } glBufferData(GL_ARRAY_BUFFER, nrects * 8 * (long)sizeof(*coord), coord, GL_STREAM_DRAW); glBufferData(GL_ELEMENT_ARRAY_BUFFER, nrects * 6 * (long)sizeof(*indices), indices, GL_STREAM_DRAW); glVertexAttribPointer((GLuint)gd->fill_shader.in_coord_loc, 2, GL_INT, GL_FALSE, sizeof(*coord) * 2, (void *)0); glDrawElements(GL_TRIANGLES, nrects * 6, GL_UNSIGNED_INT, NULL); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glDisableVertexAttribArray((GLuint)gd->fill_shader.in_coord_loc); glDeleteBuffers(2, bo); } /** * Initialize GL blur filters. */ static bool gl_init_blur(struct gl_data *gd, conv *const *const kernels) { if (!kernels[0]) { return true; } char *lc_numeric_old = strdup(setlocale(LC_NUMERIC, NULL)); // Enforce LC_NUMERIC locale "C" here to make sure decimal point is sane // Thanks to hiciu for reporting. setlocale(LC_NUMERIC, "C"); // clang-format off static const char *FRAG_SHADER_BLUR = GLSL(130, %s\n // other extension pragmas uniform float offset_x; uniform float offset_y; uniform sampler2D tex_scr; uniform float opacity; in vec2 texcoord; out vec4 out_color; void main() { vec4 sum = vec4(0.0, 0.0, 0.0, 0.0); %s //body of the convolution out_color = sum / float(%.7g) * opacity; } ); static const char *FRAG_SHADER_BLUR_ADD = QUOTE( sum += float(%.7g) * texture2D(tex_scr, vec2(texcoord.x + offset_x * float(%d), texcoord.y + offset_y * float(%d))); ); // clang-format on const char *shader_add = FRAG_SHADER_BLUR_ADD; char *extension = strdup(""); gl_blur_shader_t *passes = gd->blur_shader; for (int i = 0; i < MAX_BLUR_PASS && kernels[i]; gd->npasses = ++i) { auto kern = kernels[i]; // Build shader int width = kern->w, height = kern->h; int nele = width * height - 1; size_t body_len = (strlen(shader_add) + 42) * (uint)nele; char *shader_body = ccalloc(body_len, char); char *pc = shader_body; double sum = 0.0; for (int j = 0; j < height; ++j) { for (int k = 0; k < width; ++k) { double val; if (height / 2 == j && width / 2 == k) { val = 1; } else { val = kern->data[j * width + k]; } if (val == 0) { continue; } sum += val; pc += snprintf(pc, body_len - (ulong)(pc - shader_body), FRAG_SHADER_BLUR_ADD, val, k - width / 2, j - height / 2); assert(pc < shader_body + body_len); } } auto pass = passes + i; size_t shader_len = strlen(FRAG_SHADER_BLUR) + strlen(extension) + strlen(shader_body) + 10 /* sum */ + 1 /* null terminator */; char *shader_str = ccalloc(shader_len, char); auto real_shader_len = snprintf(shader_str, shader_len, FRAG_SHADER_BLUR, extension, shader_body, sum); CHECK(real_shader_len >= 0); CHECK((size_t)real_shader_len < shader_len); free(shader_body); // Build program pass->prog = gl_create_program_from_str(vertex_shader, shader_str); free(shader_str); if (!pass->prog) { log_error("Failed to create GLSL program."); goto err; } glBindFragDataLocation(pass->prog, 0, "out_color"); // Get uniform addresses pass->unifm_offset_x = glGetUniformLocationChecked(pass->prog, "offset_x"); pass->unifm_offset_y = glGetUniformLocationChecked(pass->prog, "offset_y"); pass->unifm_opacity = glGetUniformLocationChecked(pass->prog, "opacity"); pass->in_texcoord = glGetAttribLocation(pass->prog, "in_texcoord"); } free(extension); // Texture size will be defined by gl_resize glGenTextures(gd->npasses > 1 ? 2 : 1, gd->blur_texture); glBindTexture(GL_TEXTURE_2D, gd->blur_texture[0]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); if (gd->npasses > 1) { glBindTexture(GL_TEXTURE_2D, gd->blur_texture[1]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); // Generate FBO and textures when needed glGenFramebuffers(1, &gd->blur_fbo); if (!gd->blur_fbo) { log_error("Failed to generate framebuffer object for blur"); return false; } } // Restore LC_NUMERIC setlocale(LC_NUMERIC, lc_numeric_old); free(lc_numeric_old); gl_check_err(); return true; err: free(extension); setlocale(LC_NUMERIC, lc_numeric_old); free(lc_numeric_old); return false; } // clang-format off const char *win_shader_glsl = GLSL(130, uniform float opacity; uniform float dim; uniform bool invert_color; in vec2 texcoord; uniform sampler2D tex; void main() { vec4 c = texture2D(tex, texcoord.xy); if (invert_color) { c = vec4(c.aaa - c.rgb, c.a); } c = vec4(c.rgb * (1.0 - dim), c.a) * opacity; gl_FragColor = c; } ); // clang-format on bool gl_init(struct gl_data *gd, session_t *ps) { // Initialize GLX data structure for (int i = 0; i < MAX_BLUR_PASS; ++i) { gd->blur_shader[i] = (gl_blur_shader_t){.prog = 0}; } glDisable(GL_DEPTH_TEST); glDepthMask(GL_FALSE); glEnable(GL_BLEND); // X pixmap is in premultiplied alpha, so we might just as well use it too. // Thanks to derhass for help. glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); // Initialize stencil buffer glDisable(GL_STENCIL_TEST); glStencilMask(0x1); glStencilFunc(GL_EQUAL, 0x1, 0x1); // Clear screen glClearColor(0.0f, 0.0f, 0.0f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); gd->npasses = 0; gl_win_shader_from_string(vertex_shader, win_shader_glsl, &gd->win_shader); if (!gl_init_blur(gd, ps->o.blur_kerns)) { return false; } gd->fill_shader.prog = gl_create_program_from_str(fill_vert, fill_frag); gd->fill_shader.in_coord_loc = glGetAttribLocation(gd->fill_shader.prog, "in_coord"); gd->fill_shader.color_loc = glGetUniformLocation(gd->fill_shader.prog, "color"); // Set up the size of the viewport. We do this last because it expects the blur // textures are already set up. gl_resize(gd, ps->root_width, ps->root_height); gd->logger = gl_string_marker_logger_new(); if (gd->logger) { log_add_target_tls(gd->logger); } return true; } static inline void gl_free_blur_shader(gl_blur_shader_t *shader) { if (shader->prog) { glDeleteProgram(shader->prog); } shader->prog = 0; } void gl_deinit(struct gl_data *gd) { // Free GLSL shaders/programs for (int i = 0; i < MAX_BLUR_PASS; ++i) { gl_free_blur_shader(&gd->blur_shader[i]); } gl_free_prog_main(&gd->win_shader); glDeleteTextures(gd->npasses > 1 ? 2 : 1, gd->blur_texture); if (gd->npasses > 1) { glDeleteFramebuffers(1, &gd->blur_fbo); } if (gd->logger) { log_remove_target_tls(gd->logger); gd->logger = NULL; } gl_check_err(); } GLuint gl_new_texture(GLenum target) { GLuint texture; glGenTextures(1, &texture); if (!texture) { log_error("Failed to generate texture"); return 0; } glBindTexture(target, texture); glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_REPEAT); glBindTexture(target, 0); return texture; } /// stub for backend_operations::image_op bool gl_image_op(backend_t *base, enum image_operations op, void *image_data, const region_t *reg_op, const region_t *reg_visible, void *arg) { struct gl_texture *tex = image_data; int *iargs = arg; switch (op) { case IMAGE_OP_INVERT_COLOR_ALL: tex->color_inverted = true; break; case IMAGE_OP_DIM_ALL: tex->dim = 1.0 - (1.0 - tex->dim) * (1.0 - *(double *)arg); break; case IMAGE_OP_APPLY_ALPHA_ALL: tex->opacity *= *(double *)arg; break; case IMAGE_OP_APPLY_ALPHA: // TODO log_warn("IMAGE_OP_APPLY_ALPHA not implemented yet"); break; case IMAGE_OP_RESIZE_TILE: // texture is already set to repeat, so nothing else we need to do tex->ewidth = iargs[0]; tex->eheight = iargs[1]; break; } return true; } bool gl_is_image_transparent(backend_t *base, void *image_data) { gl_texture_t *img = image_data; return img->has_alpha; }