diff options
Diffstat (limited to 'render/fx_renderer/fx_renderer.c')
| -rw-r--r-- | render/fx_renderer/fx_renderer.c | 1016 |
1 files changed, 599 insertions, 417 deletions
diff --git a/render/fx_renderer/fx_renderer.c b/render/fx_renderer/fx_renderer.c index 730e314..da9437c 100644 --- a/render/fx_renderer/fx_renderer.c +++ b/render/fx_renderer/fx_renderer.c @@ -3,27 +3,28 @@ https://gitlab.freedesktop.org/wlroots/wlroots/-/tree/master/render/gles2 */ +#define _POSIX_C_SOURCE 199309L #include <assert.h> +#include <drm_fourcc.h> #include <GLES2/gl2.h> #include <stdio.h> #include <stdlib.h> +#include <time.h> +#include <unistd.h> #include <wlr/backend.h> +#include <wlr/render/allocator.h> #include <wlr/render/egl.h> -#include <wlr/render/gles2.h> +#include <wlr/render/interface.h> #include <wlr/types/wlr_matrix.h> #include <wlr/util/box.h> #include <wlr/util/log.h> +#include "render/egl.h" #include "render/fx_renderer/fx_renderer.h" -#include "render/fx_renderer/fx_stencilbuffer.h" #include "render/fx_renderer/matrix.h" - -// shaders -#include "common_vert_src.h" -#include "quad_frag_src.h" -#include "tex_frag_src.h" -#include "stencil_mask_frag_src.h" -#include "box_shadow_frag_src.h" +#include "render/fx_renderer/util.h" +#include "render/pixel_format.h" +#include "util/time.h" static const GLfloat verts[] = { 1, 0, // top right @@ -32,372 +33,179 @@ static const GLfloat verts[] = { 0, 1, // bottom left }; -static GLuint compile_shader(GLuint type, const GLchar *src) { - GLuint shader = glCreateShader(type); - glShaderSource(shader, 1, &src, NULL); - glCompileShader(shader); - - GLint ok; - glGetShaderiv(shader, GL_COMPILE_STATUS, &ok); - if (ok == GL_FALSE) { - wlr_log(WLR_ERROR, "Failed to compile shader"); - glDeleteShader(shader); - shader = 0; - } +static const struct wlr_renderer_impl renderer_impl; +static const struct wlr_render_timer_impl render_timer_impl; - return shader; +bool wlr_renderer_is_fx(struct wlr_renderer *wlr_renderer) { + return wlr_renderer->impl == &renderer_impl; } -static GLuint link_program(const GLchar *frag_src) { - const GLchar *vert_src = common_vert_src; - GLuint vert = compile_shader(GL_VERTEX_SHADER, vert_src); - if (!vert) { - goto error; - } - - GLuint frag = compile_shader(GL_FRAGMENT_SHADER, frag_src); - if (!frag) { - glDeleteShader(vert); - goto error; - } - - GLuint prog = glCreateProgram(); - glAttachShader(prog, vert); - glAttachShader(prog, frag); - glLinkProgram(prog); - - glDetachShader(prog, vert); - glDetachShader(prog, frag); - glDeleteShader(vert); - glDeleteShader(frag); - - GLint ok; - glGetProgramiv(prog, GL_LINK_STATUS, &ok); - if (ok == GL_FALSE) { - wlr_log(WLR_ERROR, "Failed to link shader"); - glDeleteProgram(prog); - goto error; - } - - return prog; - -error: - return 0; +struct fx_renderer *fx_get_renderer( + struct wlr_renderer *wlr_renderer) { + assert(wlr_renderer_is_fx(wlr_renderer)); + struct fx_renderer *renderer = wl_container_of(wlr_renderer, renderer, wlr_renderer); + return renderer; } -static bool link_quad_program(struct quad_shader *shader) { - GLuint prog; - shader->program = prog = link_program(quad_frag_src); - if (!shader->program) { - return false; - } - - shader->proj = glGetUniformLocation(prog, "proj"); - shader->color = glGetUniformLocation(prog, "color"); - shader->pos_attrib = glGetAttribLocation(prog, "pos"); +static struct fx_renderer *fx_get_renderer_in_context( + struct wlr_renderer *wlr_renderer) { + struct fx_renderer *renderer = fx_get_renderer(wlr_renderer); + assert(wlr_egl_is_current(renderer->egl)); + assert(renderer->current_buffer != NULL); + return renderer; +} - return true; +bool wlr_render_timer_is_fx(struct wlr_render_timer *timer) { + return timer->impl == &render_timer_impl; } -static bool link_tex_program(struct tex_shader *shader, - enum fx_tex_shader_source source) { - GLchar frag_src[2048]; - snprintf(frag_src, sizeof(frag_src), - "#define SOURCE %d\n%s", source, tex_frag_src); +struct fx_render_timer *fx_get_render_timer(struct wlr_render_timer *wlr_timer) { + assert(wlr_render_timer_is_fx(wlr_timer)); + struct fx_render_timer *timer = wl_container_of(wlr_timer, timer, base); + return timer; +} - GLuint prog; - shader->program = prog = link_program(frag_src); - if (!shader->program) { - return false; - } +static bool fx_bind_main_buffer(struct wlr_renderer *wlr_renderer, + struct wlr_buffer *wlr_buffer) { + struct fx_renderer *renderer = fx_get_renderer(wlr_renderer); - shader->proj = glGetUniformLocation(prog, "proj"); - shader->tex = glGetUniformLocation(prog, "tex"); - shader->alpha = glGetUniformLocation(prog, "alpha"); - shader->pos_attrib = glGetAttribLocation(prog, "pos"); - shader->tex_attrib = glGetAttribLocation(prog, "texcoord"); - shader->size = glGetUniformLocation(prog, "size"); - shader->position = glGetUniformLocation(prog, "position"); - shader->radius = glGetUniformLocation(prog, "radius"); + if (renderer->current_buffer != NULL) { + assert(wlr_egl_is_current(renderer->egl)); - return true; -} + push_fx_debug(renderer); + glFlush(); + glBindFramebuffer(GL_FRAMEBUFFER, 0); + pop_fx_debug(renderer); -static bool link_stencil_mask_program(struct stencil_mask_shader *shader) { - GLuint prog; - shader->program = prog = link_program(stencil_mask_frag_src); - if (!shader->program) { - return false; + wlr_buffer_unlock(renderer->current_buffer->buffer); + renderer->current_buffer = NULL; } - shader->proj = glGetUniformLocation(prog, "proj"); - shader->color = glGetUniformLocation(prog, "color"); - shader->pos_attrib = glGetAttribLocation(prog, "pos"); - shader->position = glGetUniformLocation(prog, "position"); - shader->half_size = glGetUniformLocation(prog, "half_size"); - shader->radius = glGetUniformLocation(prog, "radius"); + if (wlr_buffer == NULL) { + wlr_egl_unset_current(renderer->egl); + return true; + } - return true; -} + wlr_egl_make_current(renderer->egl); -static bool link_box_shadow_program(struct box_shadow_shader *shader) { - GLuint prog; - shader->program = prog = link_program(box_shadow_frag_src); - if (!shader->program) { + struct fx_framebuffer *buffer = fx_framebuffer_get_or_create(renderer, wlr_buffer); + if (buffer == NULL) { return false; } - shader->proj = glGetUniformLocation(prog, "proj"); - shader->color = glGetUniformLocation(prog, "color"); - shader->pos_attrib = glGetAttribLocation(prog, "pos"); - shader->position = glGetUniformLocation(prog, "position"); - shader->size = glGetUniformLocation(prog, "size"); - shader->blur_sigma = glGetUniformLocation(prog, "blur_sigma"); - shader->corner_radius = glGetUniformLocation(prog, "corner_radius"); - return true; -} + wlr_buffer_lock(wlr_buffer); + renderer->current_buffer = buffer; -static bool check_gl_ext(const char *exts, const char *ext) { - size_t extlen = strlen(ext); - const char *end = exts + strlen(exts); + push_fx_debug(renderer); + glBindFramebuffer(GL_FRAMEBUFFER, renderer->current_buffer->fbo); + pop_fx_debug(renderer); - while (exts < end) { - if (exts[0] == ' ') { - exts++; - continue; - } - size_t n = strcspn(exts, " "); - if (n == extlen && strncmp(ext, exts, n) == 0) { - return true; - } - exts += n; - } - return false; + return true; } -static void load_gl_proc(void *proc_ptr, const char *name) { - void *proc = (void *)eglGetProcAddress(name); - if (proc == NULL) { - wlr_log(WLR_ERROR, "GLES2 RENDERER: eglGetProcAddress(%s) failed", name); - abort(); +static const char *reset_status_str(GLenum status) { + switch (status) { + case GL_GUILTY_CONTEXT_RESET_KHR: + return "guilty"; + case GL_INNOCENT_CONTEXT_RESET_KHR: + return "innocent"; + case GL_UNKNOWN_CONTEXT_RESET_KHR: + return "unknown"; + default: + return "<invalid>"; } - *(void **)proc_ptr = proc; } -static void fx_renderer_handle_destroy(struct wlr_addon *addon) { +static bool fx_renderer_begin(struct wlr_renderer *wlr_renderer, uint32_t width, + uint32_t height) { struct fx_renderer *renderer = - wl_container_of(addon, renderer, addon); - fx_renderer_fini(renderer); - free(renderer); -} -static const struct wlr_addon_interface fx_renderer_addon_impl = { - .name = "fx_renderer", - .destroy = fx_renderer_handle_destroy, -}; - -void fx_renderer_init_addon(struct wlr_egl *egl, struct wlr_addon_set *addons, - const void * owner) { - struct fx_renderer *renderer = fx_renderer_create(egl); - if (!renderer) { - wlr_log(WLR_ERROR, "Failed to create fx_renderer"); - abort(); - } - wlr_addon_init(&renderer->addon, addons, owner, &fx_renderer_addon_impl); -} - -struct fx_renderer *fx_renderer_addon_find(struct wlr_addon_set *addons, - const void * owner) { - struct wlr_addon *addon = - wlr_addon_find(addons, owner, &fx_renderer_addon_impl); - if (addon == NULL) { - return NULL; - } - struct fx_renderer *renderer = wl_container_of(addon, renderer, addon); - return renderer; -} - -struct fx_renderer *fx_renderer_create(struct wlr_egl *egl) { - struct fx_renderer *renderer = calloc(1, sizeof(struct fx_renderer)); - if (renderer == NULL) { - return NULL; - } - - if (!eglMakeCurrent(wlr_egl_get_display(egl), EGL_NO_SURFACE, EGL_NO_SURFACE, - wlr_egl_get_context(egl))) { - wlr_log(WLR_ERROR, "GLES2 RENDERER: Could not make EGL current"); - return NULL; - } - - renderer->stencil_buffer = fx_stencilbuffer_create(); - - // get extensions - const char *exts_str = (const char *)glGetString(GL_EXTENSIONS); - if (exts_str == NULL) { - wlr_log(WLR_ERROR, "GLES2 RENDERER: Failed to get GL_EXTENSIONS"); - return NULL; - } - - wlr_log(WLR_INFO, "Creating scenefx GLES2 renderer"); - wlr_log(WLR_INFO, "Using %s", glGetString(GL_VERSION)); - wlr_log(WLR_INFO, "GL vendor: %s", glGetString(GL_VENDOR)); - wlr_log(WLR_INFO, "GL renderer: %s", glGetString(GL_RENDERER)); - wlr_log(WLR_INFO, "Supported GLES2 extensions: %s", exts_str); + fx_get_renderer_in_context(wlr_renderer); - // TODO: the rest of the gl checks - if (check_gl_ext(exts_str, "GL_OES_EGL_image_external")) { - renderer->exts.OES_egl_image_external = true; - load_gl_proc(&renderer->procs.glEGLImageTargetTexture2DOES, - "glEGLImageTargetTexture2DOES"); - } + push_fx_debug(renderer); - // quad fragment shader - if (!link_quad_program(&renderer->shaders.quad)) { - goto error; - } - // fragment shaders - if (!link_tex_program(&renderer->shaders.tex_rgba, SHADER_SOURCE_TEXTURE_RGBA)) { - goto error; - } - if (!link_tex_program(&renderer->shaders.tex_rgbx, SHADER_SOURCE_TEXTURE_RGBX)) { - goto error; - } - if (!link_tex_program(&renderer->shaders.tex_ext, SHADER_SOURCE_TEXTURE_EXTERNAL)) { - goto error; - } - - // stencil mask shader - if (!link_stencil_mask_program(&renderer->shaders.stencil_mask)) { - goto error; - } - // box shadow shader - if (!link_box_shadow_program(&renderer->shaders.box_shadow)) { - goto error; + if (renderer->procs.glGetGraphicsResetStatusKHR) { + GLenum status = renderer->procs.glGetGraphicsResetStatusKHR(); + if (status != GL_NO_ERROR) { + wlr_log(WLR_ERROR, "GPU reset (%s)", reset_status_str(status)); + wl_signal_emit_mutable(&wlr_renderer->events.lost, NULL); + pop_fx_debug(renderer); + return false; + } } - if (!eglMakeCurrent(wlr_egl_get_display(egl), - EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)) { - wlr_log(WLR_ERROR, "GLES2 RENDERER: Could not unset current EGL"); - goto error; - } + glViewport(0, 0, width, height); + renderer->viewport_width = width; + renderer->viewport_height = height; - wlr_log(WLR_INFO, "GLES2 RENDERER: Shaders Initialized Successfully"); - return renderer; + // refresh projection matrix + matrix_projection(renderer->projection, width, height, + WL_OUTPUT_TRANSFORM_FLIPPED_180); -error: - glDeleteProgram(renderer->shaders.quad.program); - glDeleteProgram(renderer->shaders.tex_rgba.program); - glDeleteProgram(renderer->shaders.tex_rgbx.program); - glDeleteProgram(renderer->shaders.tex_ext.program); - glDeleteProgram(renderer->shaders.stencil_mask.program); - glDeleteProgram(renderer->shaders.box_shadow.program); + glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); - if (!eglMakeCurrent(wlr_egl_get_display(egl), - EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)) { - wlr_log(WLR_ERROR, "GLES2 RENDERER: Could not unset current EGL"); - } + // XXX: maybe we should save output projection and remove some of the need + // for users to sling matricies themselves - // TODO: more freeing? - free(renderer); + pop_fx_debug(renderer); - wlr_log(WLR_ERROR, "GLES2 RENDERER: Error Initializing Shaders"); - return NULL; + return true; } -void fx_renderer_fini(struct fx_renderer *renderer) { - fx_stencilbuffer_release(&renderer->stencil_buffer); +static void fx_renderer_end(struct wlr_renderer *wlr_renderer) { + fx_get_renderer_in_context(wlr_renderer); + // no-op } -void fx_renderer_begin(struct fx_renderer *renderer, int width, int height) { - fx_stencilbuffer_init(&renderer->stencil_buffer, width, height); - - glViewport(0, 0, width, height); - - // refresh projection matrix - matrix_projection(renderer->projection, width, height, - WL_OUTPUT_TRANSFORM_FLIPPED_180); - - glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); -} +static void fx_renderer_clear(struct wlr_renderer *wlr_renderer, + const float color[static 4]) { + struct fx_renderer *renderer = + fx_get_renderer_in_context(wlr_renderer); -void fx_renderer_clear(const float color[static 4]) { + push_fx_debug(renderer); glClearColor(color[0], color[1], color[2], color[3]); glClearStencil(0); glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); + pop_fx_debug(renderer); } -void fx_renderer_scissor(struct wlr_box *box) { - if (box) { +static void fx_renderer_scissor(struct wlr_renderer *wlr_renderer, + struct wlr_box *box) { + struct fx_renderer *renderer = + fx_get_renderer_in_context(wlr_renderer); + + push_fx_debug(renderer); + if (box != NULL) { glScissor(box->x, box->y, box->width, box->height); glEnable(GL_SCISSOR_TEST); } else { glDisable(GL_SCISSOR_TEST); } + pop_fx_debug(renderer); } -void fx_renderer_stencil_mask_init(void) { - glClearStencil(0); - glClear(GL_STENCIL_BUFFER_BIT); - glEnable(GL_STENCIL_TEST); - - glStencilFunc(GL_ALWAYS, 1, 0xFF); - glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE); - // Disable writing to color buffer - glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); -} - -void fx_renderer_stencil_mask_close(bool draw_inside_mask) { - // Reenable writing to color buffer - glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); - if (draw_inside_mask) { - glStencilFunc(GL_EQUAL, 1, 0xFF); - glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE); - return; - } - glStencilFunc(GL_NOTEQUAL, 1, 0xFF); - glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); -} - -void fx_renderer_stencil_mask_fini(void) { - glClearStencil(0); - glClear(GL_STENCIL_BUFFER_BIT); - glDisable(GL_STENCIL_TEST); -} - -void fx_renderer_stencil_enable(void) { - glEnable(GL_STENCIL_TEST); -} - -void fx_renderer_stencil_disable(void) { - glDisable(GL_STENCIL_TEST); -} - -bool fx_render_subtexture_with_matrix(struct fx_renderer *renderer, - struct wlr_texture *wlr_texture, const struct wlr_fbox *src_box, - const struct wlr_box *dst_box, const float matrix[static 9], - float opacity, int corner_radius) { - - assert(wlr_texture_is_gles2(wlr_texture)); - struct wlr_gles2_texture_attribs texture_attrs; - wlr_gles2_texture_get_attribs(wlr_texture, &texture_attrs); +static bool fx_render_subtexture_with_matrix( + struct wlr_renderer *wlr_renderer, struct wlr_texture *wlr_texture, + const struct wlr_fbox *box, const float matrix[static 9], + float alpha) { + struct fx_renderer *renderer = fx_get_renderer_in_context(wlr_renderer); + struct fx_texture *texture = fx_get_texture(wlr_texture); + assert(texture->fx_renderer == renderer); struct tex_shader *shader = NULL; - switch (texture_attrs.target) { + switch (texture->target) { case GL_TEXTURE_2D: - if (texture_attrs.has_alpha) { + if (texture->has_alpha) { shader = &renderer->shaders.tex_rgba; } else { shader = &renderer->shaders.tex_rgbx; } break; case GL_TEXTURE_EXTERNAL_OES: + // EGL_EXT_image_dma_buf_import_modifiers requires + // GL_OES_EGL_image_external + assert(renderer->exts.OES_egl_image_external); shader = &renderer->shaders.tex_ext; - - if (!renderer->exts.OES_egl_image_external) { - wlr_log(WLR_ERROR, "Failed to render texture: " - "GL_TEXTURE_EXTERNAL_OES not supported"); - return false; - } break; default: wlr_log(WLR_ERROR, "Aborting render"); @@ -407,12 +215,9 @@ bool fx_render_subtexture_with_matrix(struct fx_renderer *renderer, float gl_matrix[9]; wlr_matrix_multiply(gl_matrix, renderer->projection, matrix); - // OpenGL ES 2 requires the glUniformMatrix3fv transpose parameter to be set - // to GL_FALSE - wlr_matrix_transpose(gl_matrix, gl_matrix); + push_fx_debug(renderer); - // if there's no opacity or rounded corners we don't need to blend - if (!texture_attrs.has_alpha && opacity == 1.0 && !corner_radius) { + if (!texture->has_alpha && alpha == 1.0) { glDisable(GL_BLEND); } else { glEnable(GL_BLEND); @@ -421,62 +226,49 @@ bool fx_render_subtexture_with_matrix(struct fx_renderer *renderer, glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); glActiveTexture(GL_TEXTURE0); - glBindTexture(texture_attrs.target, texture_attrs.tex); + glBindTexture(texture->target, texture->tex); - glTexParameteri(texture_attrs.target, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(texture->target, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glUseProgram(shader->program); glUniformMatrix3fv(shader->proj, 1, GL_FALSE, gl_matrix); glUniform1i(shader->tex, 0); - glUniform2f(shader->size, dst_box->width, dst_box->height); - glUniform2f(shader->position, dst_box->x, dst_box->y); - glUniform1f(shader->alpha, opacity); - glUniform1f(shader->radius, corner_radius); - - const GLfloat x1 = src_box->x / wlr_texture->width; - const GLfloat y1 = src_box->y / wlr_texture->height; - const GLfloat x2 = (src_box->x + src_box->width) / wlr_texture->width; - const GLfloat y2 = (src_box->y + src_box->height) / wlr_texture->height; - const GLfloat texcoord[] = { - x2, y1, // top right - x1, y1, // top left - x2, y2, // bottom right - x1, y2, // bottom left - }; + glUniform1f(shader->alpha, alpha); + glUniform2f(shader->size, box->width, box->height); + glUniform2f(shader->position, box->x, box->y); + glUniform1f(shader->radius, 0); + + float tex_matrix[9]; + wlr_matrix_identity(tex_matrix); + wlr_matrix_translate(tex_matrix, box->x / texture->wlr_texture.width, + box->y / texture->wlr_texture.height); + wlr_matrix_scale(tex_matrix, box->width / texture->wlr_texture.width, + box->height / texture->wlr_texture.height); + glUniformMatrix3fv(shader->tex_proj, 1, GL_FALSE, tex_matrix); glVertexAttribPointer(shader->pos_attrib, 2, GL_FLOAT, GL_FALSE, 0, verts); - glVertexAttribPointer(shader->tex_attrib, 2, GL_FLOAT, GL_FALSE, 0, texcoord); glEnableVertexAttribArray(shader->pos_attrib); - glEnableVertexAttribArray(shader->tex_attrib); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); glDisableVertexAttribArray(shader->pos_attrib); - glDisableVertexAttribArray(shader->tex_attrib); - glBindTexture(texture_attrs.target, 0); + glBindTexture(texture->target, 0); + pop_fx_debug(renderer); return true; } -void fx_render_rect(struct fx_renderer *renderer, const struct wlr_box *box, - const float color[static 4], const float projection[static 9]) { - if (box->width == 0 || box->height == 0) { - return; - } - assert(box->width > 0 && box->height > 0); - float matrix[9]; - wlr_matrix_project_box(matrix, box, WL_OUTPUT_TRANSFORM_NORMAL, 0, projection); +static void fx_render_quad_with_matrix(struct wlr_renderer *wlr_renderer, + const float color[static 4], const float matrix[static 9]) { + struct fx_renderer *renderer = fx_get_renderer_in_context(wlr_renderer); float gl_matrix[9]; wlr_matrix_multiply(gl_matrix, renderer->projection, matrix); - // TODO: investigate why matrix is flipped prior to this cmd - // wlr_matrix_multiply(gl_matrix, flip_180, gl_matrix); - - wlr_matrix_transpose(gl_matrix, gl_matrix); + push_fx_debug(renderer); if (color[3] == 1.0) { glDisable(GL_BLEND); @@ -484,115 +276,505 @@ void fx_render_rect(struct fx_renderer *renderer, const struct wlr_box *box, glEnable(GL_BLEND); } - struct quad_shader shader = renderer->shaders.quad; - glUseProgram(shader.program); + glUseProgram(renderer->shaders.quad.program); - glUniformMatrix3fv(shader.proj, 1, GL_FALSE, gl_matrix); - glUniform4f(shader.color, color[0], color[1], color[2], color[3]); + glUniformMatrix3fv(renderer->shaders.quad.proj, 1, GL_FALSE, gl_matrix); + glUniform4f(renderer->shaders.quad.color, color[0], color[1], color[2], color[3]); - glVertexAttribPointer(shader.pos_attrib, 2, GL_FLOAT, GL_FALSE, + glVertexAttribPointer(renderer->shaders.quad.pos_attrib, 2, GL_FLOAT, GL_FALSE, 0, verts); - glEnableVertexAttribArray(shader.pos_attrib); + glEnableVertexAttribArray(renderer->shaders.quad.pos_attrib); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); - glDisableVertexAttribArray(shader.pos_attrib); + glDisableVertexAttribArray(renderer->shaders.quad.pos_attrib); + + pop_fx_debug(renderer); } -static void fx_render_stencil_mask(struct fx_renderer *renderer, - const struct wlr_box *box, const float matrix[static 9], - int corner_radius) { - if (box->width == 0 || box->height == 0) { - return; +static const uint32_t *fx_get_shm_texture_formats( + struct wlr_renderer *wlr_renderer, size_t *len) { + struct fx_renderer *renderer = fx_get_renderer(wlr_renderer); + return get_fx_shm_formats(renderer, len); +} + +static const struct wlr_drm_format_set *fx_get_dmabuf_texture_formats( + struct wlr_renderer *wlr_renderer) { + struct fx_renderer *renderer = fx_get_renderer(wlr_renderer); + return wlr_egl_get_dmabuf_texture_formats(renderer->egl); +} + +static const struct wlr_drm_format_set *fx_get_render_formats( + struct wlr_renderer *wlr_renderer) { + struct fx_renderer *renderer = fx_get_renderer(wlr_renderer); + return wlr_egl_get_dmabuf_render_formats(renderer->egl); +} + +static uint32_t fx_preferred_read_format( + struct wlr_renderer *wlr_renderer) { + struct fx_renderer *renderer = + fx_get_renderer_in_context(wlr_renderer); + + push_fx_debug(renderer); + + GLint gl_format = -1, gl_type = -1, alpha_size = -1; + glGetIntegerv(GL_IMPLEMENTATION_COLOR_READ_FORMAT, &gl_format); + glGetIntegerv(GL_IMPLEMENTATION_COLOR_READ_TYPE, &gl_type); + glGetIntegerv(GL_ALPHA_BITS, &alpha_size); + + pop_fx_debug(renderer); + + const struct fx_pixel_format *fmt = + get_fx_format_from_gl(gl_format, gl_type, alpha_size > 0); + if (fmt != NULL) { + return fmt->drm_format; } - assert(box->width > 0 && box->height > 0); - // TODO: just pass gl_matrix? - float gl_matrix[9]; - wlr_matrix_multiply(gl_matrix, renderer->projection, matrix); + if (renderer->exts.EXT_read_format_bgra) { + return DRM_FORMAT_XRGB8888; + } + return DRM_FORMAT_XBGR8888; +} - // TODO: investigate why matrix is flipped prior to this cmd - // wlr_matrix_multiply(gl_matrix, flip_180, gl_matrix); +static bool fx_read_pixels(struct wlr_renderer *wlr_renderer, + uint32_t drm_format, uint32_t stride, + uint32_t width, uint32_t height, uint32_t src_x, uint32_t src_y, + uint32_t dst_x, uint32_t dst_y, void *data) { + struct fx_renderer *renderer = + fx_get_renderer_in_context(wlr_renderer); - wlr_matrix_transpose(gl_matrix, gl_matrix); + const struct fx_pixel_format *fmt = + get_fx_format_from_drm(drm_format); + if (fmt == NULL || !is_fx_pixel_format_supported(renderer, fmt)) { + wlr_log(WLR_ERROR, "Cannot read pixels: unsupported pixel format 0x%"PRIX32, drm_format); + return false; + } - glEnable(GL_BLEND); + if (fmt->gl_format == GL_BGRA_EXT && !renderer->exts.EXT_read_format_bgra) { + wlr_log(WLR_ERROR, + "Cannot read pixels: missing GL_EXT_read_format_bgra extension"); + return false; + } - struct stencil_mask_shader shader = renderer->shaders.stencil_mask; + const struct wlr_pixel_format_info *drm_fmt = + drm_get_pixel_format_info(fmt->drm_format); + assert(drm_fmt); + if (pixel_format_info_pixels_per_block(drm_fmt) != 1) { + wlr_log(WLR_ERROR, "Cannot read pixels: block formats are not supported"); + return false; + } - glUseProgram(shader.program); + push_fx_debug(renderer); - glUniformMatrix3fv(shader.proj, 1, GL_FALSE, gl_matrix); + // Make sure any pending drawing is finished before we try to read it + glFinish(); - glUniform2f(shader.half_size, box->width * 0.5, box->height * 0.5); - glUniform2f(shader.position, box->x, box->y); - glUniform1f(shader.radius, corner_radius); + glGetError(); // Clear the error flag - glVertexAttribPointer(shader.pos_attrib, 2, GL_FLOAT, GL_FALSE, - 0, verts); + unsigned char *p = (unsigned char *)data + dst_y * stride; + glPixelStorei(GL_PACK_ALIGNMENT, 1); + uint32_t pack_stride = pixel_format_info_min_stride(drm_fmt, width); + if (pack_stride == stride && dst_x == 0) { + // Under these particular conditions, we can read the pixels with only + // one glReadPixels call - glEnableVertexAttribArray(shader.pos_attrib); + glReadPixels(src_x, src_y, width, height, fmt->gl_format, fmt->gl_type, p); + } else { + // Unfortunately GLES2 doesn't support GL_PACK_ROW_LENGTH, so we have to read + // the lines out row by row + for (size_t i = 0; i < height; ++i) { + uint32_t y = src_y + i; + glReadPixels(src_x, y, width, 1, fmt->gl_format, + fmt->gl_type, p + i * stride + dst_x * drm_fmt->bytes_per_block); + } + } - glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); + pop_fx_debug(renderer); + + return glGetError() == GL_NO_ERROR; +} + +static int fx_get_drm_fd(struct wlr_renderer *wlr_renderer) { + struct fx_renderer *renderer = + fx_get_renderer(wlr_renderer); + + if (renderer->drm_fd < 0) { + renderer->drm_fd = wlr_egl_dup_drm_fd(renderer->egl); + } - glDisableVertexAttribArray(shader.pos_attrib); + return renderer->drm_fd; } -void fx_render_box_shadow(struct fx_renderer *renderer, - const struct wlr_box *box, const struct wlr_box *stencil_box, - const float matrix[static 9], int corner_radius, - struct shadow_data *shadow_data) { - if (box->width == 0 || box->height == 0) { +static uint32_t fx_get_render_buffer_caps(struct wlr_renderer *wlr_renderer) { + return WLR_BUFFER_CAP_DMABUF; +} + +static void fx_renderer_destroy(struct wlr_renderer *wlr_renderer) { + struct fx_renderer *renderer = fx_get_renderer(wlr_renderer); + + wlr_egl_make_current(renderer->egl); + + struct fx_framebuffer *fx_buffer, *fx_buffer_tmp; + wl_list_for_each_safe(fx_buffer, fx_buffer_tmp, &renderer->buffers, link) { + fx_framebuffer_destroy(fx_buffer); + } + + struct fx_texture *tex, *tex_tmp; + wl_list_for_each_safe(tex, tex_tmp, &renderer->textures, link) { + fx_texture_destroy(tex); + } + + push_fx_debug(renderer); + glDeleteProgram(renderer->shaders.quad.program); + glDeleteProgram(renderer->shaders.tex_rgba.program); + glDeleteProgram(renderer->shaders.tex_rgbx.program); + glDeleteProgram(renderer->shaders.tex_ext.program); + pop_fx_debug(renderer); + + if (renderer->exts.KHR_debug) { + glDisable(GL_DEBUG_OUTPUT_KHR); + renderer->procs.glDebugMessageCallbackKHR(NULL, NULL); + } + + wlr_egl_unset_current(renderer->egl); + wlr_egl_destroy(renderer->egl); + + if (renderer->drm_fd >= 0) { + close(renderer->drm_fd); + } + + free(renderer); +} + +static struct wlr_render_pass *begin_buffer_pass(struct wlr_renderer *wlr_renderer, + struct wlr_buffer *wlr_buffer, const struct wlr_buffer_pass_options *options) { + struct fx_gles_render_pass *pass = + fx_renderer_begin_buffer_pass(wlr_renderer, wlr_buffer, options); + if (!pass) { + return NULL; + } + return &pass->base; +} + +static struct wlr_render_timer *fx_render_timer_create(struct wlr_renderer *wlr_renderer) { + struct fx_renderer *renderer = fx_get_renderer(wlr_renderer); + if (!renderer->exts.EXT_disjoint_timer_query) { + wlr_log(WLR_ERROR, "can't create timer, EXT_disjoint_timer_query not available"); + return NULL; + } + + struct fx_render_timer *timer = calloc(1, sizeof(*timer)); + if (!timer) { + return NULL; + } + timer->base.impl = &render_timer_impl; + timer->renderer = renderer; + + struct wlr_egl_context prev_ctx; + wlr_egl_save_context(&prev_ctx); + wlr_egl_make_current(renderer->egl); + renderer->procs.glGenQueriesEXT(1, &timer->id); + wlr_egl_restore_context(&prev_ctx); + + return &timer->base; +} + +static int fx_get_render_time(struct wlr_render_timer *wlr_timer) { + struct fx_render_timer *timer = fx_get_render_timer(wlr_timer); + struct fx_renderer *renderer = timer->renderer; + + struct wlr_egl_context prev_ctx; + wlr_egl_save_context(&prev_ctx); + wlr_egl_make_current(renderer->egl); + + GLint64 disjoint; + renderer->procs.glGetInteger64vEXT(GL_GPU_DISJOINT_EXT, &disjoint); + if (disjoint) { + wlr_log(WLR_ERROR, "a disjoint operation occurred and the render timer is invalid"); + wlr_egl_restore_context(&prev_ctx); + return -1; + } + + GLint available; + renderer->procs.glGetQueryObjectivEXT(timer->id, + GL_QUERY_RESULT_AVAILABLE_EXT, &available); + if (!available) { + wlr_log(WLR_ERROR, "timer was read too early, gpu isn't done!"); + wlr_egl_restore_context(&prev_ctx); + return -1; + } + + GLuint64 gl_render_end; + renderer->procs.glGetQueryObjectui64vEXT(timer->id, GL_QUERY_RESULT_EXT, + &gl_render_end); + + int64_t cpu_nsec_total = timespec_to_nsec(&timer->cpu_end) - timespec_to_nsec(&timer->cpu_start); + + wlr_egl_restore_context(&prev_ctx); + return gl_render_end - timer->gl_cpu_end + cpu_nsec_total; +} + +static void fx_render_timer_destroy(struct wlr_render_timer *wlr_timer) { + struct fx_render_timer *timer = wl_container_of(wlr_timer, timer, base); + struct fx_renderer *renderer = timer->renderer; + + struct wlr_egl_context prev_ctx; + wlr_egl_save_context(&prev_ctx); + wlr_egl_make_current(renderer->egl); + renderer->procs.glDeleteQueriesEXT(1, &timer->id); + wlr_egl_restore_context(&prev_ctx); + free(timer); +} + +static const struct wlr_renderer_impl renderer_impl = { + .destroy = fx_renderer_destroy, + .bind_buffer = fx_bind_main_buffer, + .begin = fx_renderer_begin, + .end = fx_renderer_end, + .clear = fx_renderer_clear, + .scissor = fx_renderer_scissor, + .render_subtexture_with_matrix = fx_render_subtexture_with_matrix, + .render_quad_with_matrix = fx_render_quad_with_matrix, + .get_shm_texture_formats = fx_get_shm_texture_formats, + .get_dmabuf_texture_formats = fx_get_dmabuf_texture_formats, + .get_render_formats = fx_get_render_formats, + .preferred_read_format = fx_preferred_read_format, + .read_pixels = fx_read_pixels, + .get_drm_fd = fx_get_drm_fd, + .get_render_buffer_caps = fx_get_render_buffer_caps, + .texture_from_buffer = fx_texture_from_buffer, + .begin_buffer_pass = begin_buffer_pass, + .render_timer_create = fx_render_timer_create, +}; + +static const struct wlr_render_timer_impl render_timer_impl = { + .get_duration_ns = fx_get_render_time, + .destroy = fx_render_timer_destroy, +}; + +void push_fx_debug_(struct fx_renderer *renderer, + const char *file, const char *func) { + if (!renderer->procs.glPushDebugGroupKHR) { return; } - assert(box->width > 0 && box->height > 0); - float *color = shadow_data->color; - float blur_sigma = shadow_data->blur_sigma; + int len = snprintf(NULL, 0, "%s:%s", file, func) + 1; + char str[len]; + snprintf(str, len, "%s:%s", file, func); + renderer->procs.glPushDebugGroupKHR(GL_DEBUG_SOURCE_APPLICATION_KHR, 1, -1, str); +} - float gl_matrix[9]; - wlr_matrix_multiply(gl_matrix, renderer->projection, matrix); +void pop_fx_debug(struct fx_renderer *renderer) { + if (renderer->procs.glPopDebugGroupKHR) { + renderer->procs.glPopDebugGroupKHR(); + } +} + +static enum wlr_log_importance fx_log_importance_to_wlr(GLenum type) { + switch (type) { + case GL_DEBUG_TYPE_ERROR_KHR: return WLR_ERROR; + case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_KHR: return WLR_DEBUG; + case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_KHR: return WLR_ERROR; + case GL_DEBUG_TYPE_PORTABILITY_KHR: return WLR_DEBUG; + case GL_DEBUG_TYPE_PERFORMANCE_KHR: return WLR_DEBUG; + case GL_DEBUG_TYPE_OTHER_KHR: return WLR_DEBUG; + case GL_DEBUG_TYPE_MARKER_KHR: return WLR_DEBUG; + case GL_DEBUG_TYPE_PUSH_GROUP_KHR: return WLR_DEBUG; + case GL_DEBUG_TYPE_POP_GROUP_KHR: return WLR_DEBUG; + default: return WLR_DEBUG; + } +} - // TODO: investigate why matrix is flipped prior to this cmd - // wlr_matrix_multiply(gl_matrix, flip_180, gl_matrix); +static void fx_log(GLenum src, GLenum type, GLuint id, GLenum severity, + GLsizei len, const GLchar *msg, const void *user) { + _wlr_log(fx_log_importance_to_wlr(type), "[GLES2] %s", msg); +} - wlr_matrix_transpose(gl_matrix, gl_matrix); +static struct wlr_renderer *renderer_autocreate(struct wlr_backend *backend, int drm_fd) { + bool own_drm_fd = false; + if (!open_preferred_drm_fd(backend, &drm_fd, &own_drm_fd)) { + wlr_log(WLR_ERROR, "Cannot create GLES2 renderer: no DRM FD available"); + return NULL; + } + + struct wlr_egl *egl = wlr_egl_create_with_drm_fd(drm_fd); + if (egl == NULL) { + wlr_log(WLR_ERROR, "Could not initialize EGL"); + return NULL; + } - // Init stencil work - fx_renderer_stencil_mask_init(); - // Draw the rounded rect as a mask - fx_render_stencil_mask(renderer, stencil_box, matrix, corner_radius); - fx_renderer_stencil_mask_close(false); + struct wlr_renderer *renderer = fx_renderer_create_egl(egl); + if (!renderer) { + wlr_log(WLR_ERROR, "Failed to create the FX renderer"); + wlr_egl_destroy(egl); + return NULL; + } - // blending will practically always be needed (unless we have a madman - // who uses opaque shadows with zero sigma), so just enable it - glEnable(GL_BLEND); + if (own_drm_fd && drm_fd >= 0) { + close(drm_fd); + } - glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + return renderer; +} - struct box_shadow_shader shader = renderer->shaders.box_shadow; +struct wlr_renderer *fx_renderer_create_with_drm_fd(int drm_fd) { + assert(drm_fd >= 0); - glUseProgram(shader.program); + return renderer_autocreate(NULL, drm_fd); +} - glUniformMatrix3fv(shader.proj, 1, GL_FALSE, gl_matrix); - glUniform4f(shader.color, color[0], color[1], color[2], color[3]); - glUniform1f(shader.blur_sigma, blur_sigma); - glUniform1f(shader.corner_radius, corner_radius); +struct wlr_renderer *fx_renderer_create(struct wlr_backend *backend) { + return renderer_autocreate(backend, -1); +} - glUniform2f(shader.size, box->width, box->height); - glUniform2f(shader.position, box->x, box->y); +struct wlr_renderer *fx_renderer_create_egl(struct wlr_egl *egl) { + if (!wlr_egl_make_current(egl)) { + return NULL; + } - glVertexAttribPointer(shader.pos_attrib, 2, GL_FLOAT, GL_FALSE, - 0, verts); + const char *exts_str = (const char *)glGetString(GL_EXTENSIONS); + if (exts_str == NULL) { + wlr_log(WLR_ERROR, "Failed to get GL_EXTENSIONS"); + return NULL; + } - glEnableVertexAttribArray(shader.pos_attrib); + struct fx_renderer *renderer = calloc(1, sizeof(struct fx_renderer)); + if (renderer == NULL) { + return NULL; + } + wlr_renderer_init(&renderer->wlr_renderer, &renderer_impl); - glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); + wl_list_init(&renderer->buffers); + wl_list_init(&renderer->textures); - glDisableVertexAttribArray(shader.pos_attrib); + renderer->egl = egl; + renderer->exts_str = exts_str; + renderer->drm_fd = -1; - glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); + wlr_log(WLR_INFO, "Creating scenefx FX renderer"); + wlr_log(WLR_INFO, "Using %s", glGetString(GL_VERSION)); + wlr_log(WLR_INFO, "GL vendor: %s", glGetString(GL_VENDOR)); + wlr_log(WLR_INFO, "GL renderer: %s", glGetString(GL_RENDERER)); + wlr_log(WLR_INFO, "Supported FX extensions: %s", exts_str); + + if (!renderer->egl->exts.EXT_image_dma_buf_import) { + wlr_log(WLR_ERROR, "EGL_EXT_image_dma_buf_import not supported"); + free(renderer); + return NULL; + } + if (!check_gl_ext(exts_str, "GL_EXT_texture_format_BGRA8888")) { + wlr_log(WLR_ERROR, "BGRA8888 format not supported by GLES2"); + free(renderer); + return NULL; + } + if (!check_gl_ext(exts_str, "GL_EXT_unpack_subimage")) { + wlr_log(WLR_ERROR, "GL_EXT_unpack_subimage not supported"); + free(renderer); + return NULL; + } + + renderer->exts.EXT_read_format_bgra = + check_gl_ext(exts_str, "GL_EXT_read_format_bgra"); + + renderer->exts.EXT_texture_type_2_10_10_10_REV = + check_gl_ext(exts_str, "GL_EXT_texture_type_2_10_10_10_REV"); + + renderer->exts.OES_texture_half_float_linear = + check_gl_ext(exts_str, "GL_OES_texture_half_float_linear"); - fx_renderer_stencil_mask_fini(); + renderer->exts.EXT_texture_norm16 = + check_gl_ext(exts_str, "GL_EXT_texture_norm16"); + + if (check_gl_ext(exts_str, "GL_KHR_debug")) { + renderer->exts.KHR_debug = true; + load_gl_proc(&renderer->procs.glDebugMessageCallbackKHR, + "glDebugMessageCallbackKHR"); + load_gl_proc(&renderer->procs.glDebugMessageControlKHR, + "glDebugMessageControlKHR"); + } + + // TODO: the rest of the gl checks + if (check_gl_ext(exts_str, "GL_OES_EGL_image_external")) { + renderer->exts.OES_egl_image_external = true; + load_gl_proc(&renderer->procs.glEGLImageTargetTexture2DOES, + "glEGLImageTargetTexture2DOES"); + } + + if (check_gl_ext(exts_str, "GL_OES_EGL_image")) { + renderer->exts.OES_egl_image = true; + load_gl_proc(&renderer->procs.glEGLImageTargetRenderbufferStorageOES, + "glEGLImageTargetRenderbufferStorageOES"); + } + + if (check_gl_ext(exts_str, "GL_KHR_robustness")) { + GLint notif_strategy = 0; + glGetIntegerv(GL_RESET_NOTIFICATION_STRATEGY_KHR, ¬if_strategy); + switch (notif_strategy) { + case GL_LOSE_CONTEXT_ON_RESET_KHR: + wlr_log(WLR_DEBUG, "GPU reset notifications are enabled"); + load_gl_proc(&renderer->procs.glGetGraphicsResetStatusKHR, + "glGetGraphicsResetStatusKHR"); + break; + case GL_NO_RESET_NOTIFICATION_KHR: + wlr_log(WLR_DEBUG, "GPU reset notifications are disabled"); + break; + } + } + + if (check_gl_ext(exts_str, "GL_EXT_disjoint_timer_query")) { + renderer->exts.EXT_disjoint_timer_query = true; + load_gl_proc(&renderer->procs.glGenQueriesEXT, "glGenQueriesEXT"); + load_gl_proc(&renderer->procs.glDeleteQueriesEXT, "glDeleteQueriesEXT"); + load_gl_proc(&renderer->procs.glQueryCounterEXT, "glQueryCounterEXT"); + load_gl_proc(&renderer->procs.glGetQueryObjectivEXT, "glGetQueryObjectivEXT"); + load_gl_proc(&renderer->procs.glGetQueryObjectui64vEXT, "glGetQueryObjectui64vEXT"); + load_gl_proc(&renderer->procs.glGetInteger64vEXT, "glGetInteger64vEXT"); + } + + if (renderer->exts.KHR_debug) { + glEnable(GL_DEBUG_OUTPUT_KHR); + glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_KHR); + renderer->procs.glDebugMessageCallbackKHR(fx_log, NULL); + + // Silence unwanted message types + renderer->procs.glDebugMessageControlKHR(GL_DONT_CARE, + GL_DEBUG_TYPE_POP_GROUP_KHR, GL_DONT_CARE, 0, NULL, GL_FALSE); + renderer->procs.glDebugMessageControlKHR(GL_DONT_CARE, + GL_DEBUG_TYPE_PUSH_GROUP_KHR, GL_DONT_CARE, 0, NULL, GL_FALSE); + } + + push_fx_debug(renderer); + + // Link all shaders + if (!link_shaders(renderer)) { + goto error; + } + pop_fx_debug(renderer); + + wlr_log(WLR_INFO, "FX RENDERER: Shaders Initialized Successfully"); + + wlr_egl_unset_current(renderer->egl); + + return &renderer->wlr_renderer; + +error: + glDeleteProgram(renderer->shaders.quad.program); + glDeleteProgram(renderer->shaders.tex_rgba.program); + glDeleteProgram(renderer->shaders.tex_rgbx.program); + glDeleteProgram(renderer->shaders.tex_ext.program); + glDeleteProgram(renderer->shaders.stencil_mask.program); + glDeleteProgram(renderer->shaders.box_shadow.program); + + pop_fx_debug(renderer); + + if (renderer->exts.KHR_debug) { + glDisable(GL_DEBUG_OUTPUT_KHR); + renderer->procs.glDebugMessageCallbackKHR(NULL, NULL); + } + + wlr_egl_unset_current(renderer->egl); + + free(renderer); + return NULL; } |