From 00c96e3ac01c7b7254f14138c4a41be033ea20a9 Mon Sep 17 00:00:00 2001 From: William McKinnon Date: Mon, 27 Oct 2025 00:49:39 -0400 Subject: [PATCH 1/3] renamed gles2 components to gles --- include/meson.build | 2 +- include/render/{gles2.h => gles.h} | 80 +++---- include/wlr/config.h.in | 2 +- include/wlr/render/gles.h | 51 +++++ include/wlr/render/gles2.h | 51 ----- render/{gles2 => gles}/meson.build | 2 +- render/{gles2 => gles}/pass.c | 50 ++--- render/{gles2 => gles}/pixel_format.c | 16 +- render/{gles2 => gles}/renderer.c | 205 +++++++++--------- render/{gles2 => gles}/shaders/embed.sh | 0 .../shaders/gles2_common.vert} | 0 .../shaders/gles2_quad.frag} | 0 .../shaders/gles2_tex_external.frag} | 0 .../shaders/gles2_tex_rgba.frag} | 0 .../shaders/gles2_tex_rgbx.frag} | 0 render/{gles2 => gles}/shaders/meson.build | 12 +- render/{gles2 => gles}/texture.c | 128 +++++------ render/meson.build | 2 +- render/wlr_renderer.c | 6 +- 19 files changed, 304 insertions(+), 303 deletions(-) rename include/render/{gles2.h => gles.h} (62%) create mode 100644 include/wlr/render/gles.h delete mode 100644 include/wlr/render/gles2.h rename render/{gles2 => gles}/meson.build (82%) rename render/{gles2 => gles}/pass.c (87%) rename render/{gles2 => gles}/pixel_format.c (88%) rename render/{gles2 => gles}/renderer.c (74%) rename render/{gles2 => gles}/shaders/embed.sh (100%) rename render/{gles2/shaders/common.vert => gles/shaders/gles2_common.vert} (100%) rename render/{gles2/shaders/quad.frag => gles/shaders/gles2_quad.frag} (100%) rename render/{gles2/shaders/tex_external.frag => gles/shaders/gles2_tex_external.frag} (100%) rename render/{gles2/shaders/tex_rgba.frag => gles/shaders/gles2_tex_rgba.frag} (100%) rename render/{gles2/shaders/tex_rgbx.frag => gles/shaders/gles2_tex_rgbx.frag} (100%) rename render/{gles2 => gles}/shaders/meson.build (75%) rename render/{gles2 => gles}/texture.c (72%) diff --git a/include/meson.build b/include/meson.build index 165166c33..b0f600aaf 100644 --- a/include/meson.build +++ b/include/meson.build @@ -15,7 +15,7 @@ if not features.get('xwayland') exclude_files += 'xwayland.h' endif if not features.get('gles2-renderer') - exclude_files += ['render/egl.h', 'render/gles2.h'] + exclude_files += ['render/egl.h', 'render/gles.h'] endif if not features.get('vulkan-renderer') exclude_files += 'render/vulkan.h' diff --git a/include/render/gles2.h b/include/render/gles.h similarity index 62% rename from include/render/gles2.h rename to include/render/gles.h index 6b852dcb7..86f7f46e6 100644 --- a/include/render/gles2.h +++ b/include/render/gles.h @@ -1,5 +1,5 @@ -#ifndef RENDER_GLES2_H -#define RENDER_GLES2_H +#ifndef RENDER_GLES_H +#define RENDER_GLES_H #include #include @@ -7,7 +7,7 @@ #include #include #include -#include +#include #include #include #include @@ -21,14 +21,14 @@ // https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/23144 typedef void (GL_APIENTRYP PFNGLGETINTEGER64VEXTPROC) (GLenum pname, GLint64 *data); -struct wlr_gles2_pixel_format { +struct wlr_gles_pixel_format { uint32_t drm_format; // optional field, if empty then internalformat = format GLint gl_internalformat; GLint gl_format, gl_type; }; -struct wlr_gles2_tex_shader { +struct wlr_gles_tex_shader { GLuint program; GLint proj; GLint tex_proj; @@ -37,7 +37,7 @@ struct wlr_gles2_tex_shader { GLint pos_attrib; }; -struct wlr_gles2_renderer { +struct wlr_gles_renderer { struct wlr_renderer wlr_renderer; struct wlr_egl *egl; @@ -80,28 +80,28 @@ struct wlr_gles2_renderer { GLint color; GLint pos_attrib; } quad; - struct wlr_gles2_tex_shader tex_rgba; - struct wlr_gles2_tex_shader tex_rgbx; - struct wlr_gles2_tex_shader tex_ext; + struct wlr_gles_tex_shader tex_rgba; + struct wlr_gles_tex_shader tex_rgbx; + struct wlr_gles_tex_shader tex_ext; } shaders; - struct wl_list buffers; // wlr_gles2_buffer.link - struct wl_list textures; // wlr_gles2_texture.link + struct wl_list buffers; // wlr_gles_buffer.link + struct wl_list textures; // wlr_gles_texture.link }; -struct wlr_gles2_render_timer { +struct wlr_gles_render_timer { struct wlr_render_timer base; - struct wlr_gles2_renderer *renderer; + struct wlr_gles_renderer *renderer; struct timespec cpu_start; struct timespec cpu_end; GLuint id; GLint64 gl_cpu_end; }; -struct wlr_gles2_buffer { +struct wlr_gles_buffer { struct wlr_buffer *buffer; - struct wlr_gles2_renderer *renderer; - struct wl_list link; // wlr_gles2_renderer.buffers + struct wlr_gles_renderer *renderer; + struct wl_list link; // wlr_gles_renderer.buffers bool external_only; EGLImageKHR image; @@ -112,10 +112,10 @@ struct wlr_gles2_buffer { struct wlr_addon addon; }; -struct wlr_gles2_texture { +struct wlr_gles_texture { struct wlr_texture wlr_texture; - struct wlr_gles2_renderer *renderer; - struct wl_list link; // wlr_gles2_renderer.textures + struct wlr_gles_renderer *renderer; + struct wl_list link; // wlr_gles_renderer.textures GLenum target; @@ -128,49 +128,49 @@ struct wlr_gles2_texture { bool has_alpha; uint32_t drm_format; // for mutable textures only, used to interpret upload data - struct wlr_gles2_buffer *buffer; // for DMA-BUF imports only + struct wlr_gles_buffer *buffer; // for DMA-BUF imports only }; -struct wlr_gles2_render_pass { +struct wlr_gles_render_pass { struct wlr_render_pass base; - struct wlr_gles2_buffer *buffer; + struct wlr_gles_buffer *buffer; float projection_matrix[9]; struct wlr_egl_context prev_ctx; - struct wlr_gles2_render_timer *timer; + struct wlr_gles_render_timer *timer; struct wlr_drm_syncobj_timeline *signal_timeline; uint64_t signal_point; }; -bool is_gles2_pixel_format_supported(const struct wlr_gles2_renderer *renderer, - const struct wlr_gles2_pixel_format *format); -const struct wlr_gles2_pixel_format *get_gles2_format_from_drm(uint32_t fmt); -const struct wlr_gles2_pixel_format *get_gles2_format_from_gl( +bool is_gles_pixel_format_supported(const struct wlr_gles_renderer *renderer, + const struct wlr_gles_pixel_format *format); +const struct wlr_gles_pixel_format *get_gles_format_from_drm(uint32_t fmt); +const struct wlr_gles_pixel_format *get_gles_format_from_gl( GLint gl_format, GLint gl_type, bool alpha); -void get_gles2_shm_formats(const struct wlr_gles2_renderer *renderer, +void get_gles_shm_formats(const struct wlr_gles_renderer *renderer, struct wlr_drm_format_set *out); -GLuint gles2_buffer_get_fbo(struct wlr_gles2_buffer *buffer); +GLuint gles_buffer_get_fbo(struct wlr_gles_buffer *buffer); -struct wlr_gles2_renderer *gles2_get_renderer( +struct wlr_gles_renderer *gles_get_renderer( struct wlr_renderer *wlr_renderer); -struct wlr_gles2_render_timer *gles2_get_render_timer( +struct wlr_gles_render_timer *gles_get_render_timer( struct wlr_render_timer *timer); -struct wlr_gles2_texture *gles2_get_texture( +struct wlr_gles_texture *gles_get_texture( struct wlr_texture *wlr_texture); -struct wlr_gles2_buffer *gles2_buffer_get_or_create(struct wlr_gles2_renderer *renderer, +struct wlr_gles_buffer *gles_buffer_get_or_create(struct wlr_gles_renderer *renderer, struct wlr_buffer *wlr_buffer); -struct wlr_texture *gles2_texture_from_buffer(struct wlr_renderer *wlr_renderer, +struct wlr_texture *gles_texture_from_buffer(struct wlr_renderer *wlr_renderer, struct wlr_buffer *buffer); -void gles2_texture_destroy(struct wlr_gles2_texture *texture); +void gles_texture_destroy(struct wlr_gles_texture *texture); -void push_gles2_debug_(struct wlr_gles2_renderer *renderer, +void push_gles_debug_(struct wlr_gles_renderer *renderer, const char *file, const char *func); -#define push_gles2_debug(renderer) push_gles2_debug_(renderer, _WLR_FILENAME, __func__) -void pop_gles2_debug(struct wlr_gles2_renderer *renderer); +#define push_gles_debug(renderer) push_gles_debug_(renderer, _WLR_FILENAME, __func__) +void pop_gles_debug(struct wlr_gles_renderer *renderer); -struct wlr_gles2_render_pass *begin_gles2_buffer_pass(struct wlr_gles2_buffer *buffer, - struct wlr_egl_context *prev_ctx, struct wlr_gles2_render_timer *timer, +struct wlr_gles_render_pass *begin_gles_buffer_pass(struct wlr_gles_buffer *buffer, + struct wlr_egl_context *prev_ctx, struct wlr_gles_render_timer *timer, struct wlr_drm_syncobj_timeline *signal_timeline, uint64_t signal_point); #endif diff --git a/include/wlr/config.h.in b/include/wlr/config.h.in index ef186343e..198f14334 100644 --- a/include/wlr/config.h.in +++ b/include/wlr/config.h.in @@ -27,7 +27,7 @@ * Whether the GLES2 renderer is compile-time enabled. Equivalent to the * pkg-config "have_gles2_renderer" variable. * - * Required for . + * Required for . */ #mesondefine WLR_HAS_GLES2_RENDERER /** diff --git a/include/wlr/render/gles.h b/include/wlr/render/gles.h new file mode 100644 index 000000000..b45bc0861 --- /dev/null +++ b/include/wlr/render/gles.h @@ -0,0 +1,51 @@ +/* + * This an unstable interface of wlroots. No guarantees are made regarding the + * future consistency of this API. + */ +#ifndef WLR_USE_UNSTABLE +#error "Add -DWLR_USE_UNSTABLE to enable unstable wlroots features" +#endif + +#ifndef WLR_RENDER_GLES2_H +#define WLR_RENDER_GLES2_H + +#include + +#include + +struct wlr_egl; + +/** + * OpenGL ES renderer. + * + * Care must be taken to avoid stepping each other's toes with EGL contexts: + * the current EGL is global state. The GLES renderer operations will save + * and restore any previous EGL context when called. A render pass is seen as + * a single operation. + * + * The GLES renderer doesn't support arbitrarily nested render passes. It + * supports a subset only: after a nested render pass is created, any parent + * render pass can't be used before the nested render pass is submitted. + */ + +struct wlr_renderer *wlr_gles_renderer_create_with_drm_fd(int drm_fd); +struct wlr_renderer *wlr_gles_renderer_create(struct wlr_egl *egl); + +struct wlr_egl *wlr_gles_renderer_get_egl(struct wlr_renderer *renderer); +bool wlr_gles_renderer_check_ext(struct wlr_renderer *renderer, const char *ext); +GLuint wlr_gles_renderer_get_buffer_fbo(struct wlr_renderer *renderer, struct wlr_buffer *buffer); + +struct wlr_gles_texture_attribs { + GLenum target; /* either GL_TEXTURE_2D or GL_TEXTURE_EXTERNAL_OES */ + GLuint tex; + + bool has_alpha; +}; + +bool wlr_renderer_is_gles(struct wlr_renderer *wlr_renderer); +bool wlr_render_timer_is_gles(struct wlr_render_timer *timer); +bool wlr_texture_is_gles(struct wlr_texture *texture); +void wlr_gles_texture_get_attribs(struct wlr_texture *texture, + struct wlr_gles_texture_attribs *attribs); + +#endif diff --git a/include/wlr/render/gles2.h b/include/wlr/render/gles2.h deleted file mode 100644 index 454e7eb0e..000000000 --- a/include/wlr/render/gles2.h +++ /dev/null @@ -1,51 +0,0 @@ -/* - * This an unstable interface of wlroots. No guarantees are made regarding the - * future consistency of this API. - */ -#ifndef WLR_USE_UNSTABLE -#error "Add -DWLR_USE_UNSTABLE to enable unstable wlroots features" -#endif - -#ifndef WLR_RENDER_GLES2_H -#define WLR_RENDER_GLES2_H - -#include - -#include - -struct wlr_egl; - -/** - * OpenGL ES 2 renderer. - * - * Care must be taken to avoid stepping each other's toes with EGL contexts: - * the current EGL is global state. The GLES2 renderer operations will save - * and restore any previous EGL context when called. A render pass is seen as - * a single operation. - * - * The GLES2 renderer doesn't support arbitrarily nested render passes. It - * supports a subset only: after a nested render pass is created, any parent - * render pass can't be used before the nested render pass is submitted. - */ - -struct wlr_renderer *wlr_gles2_renderer_create_with_drm_fd(int drm_fd); -struct wlr_renderer *wlr_gles2_renderer_create(struct wlr_egl *egl); - -struct wlr_egl *wlr_gles2_renderer_get_egl(struct wlr_renderer *renderer); -bool wlr_gles2_renderer_check_ext(struct wlr_renderer *renderer, const char *ext); -GLuint wlr_gles2_renderer_get_buffer_fbo(struct wlr_renderer *renderer, struct wlr_buffer *buffer); - -struct wlr_gles2_texture_attribs { - GLenum target; /* either GL_TEXTURE_2D or GL_TEXTURE_EXTERNAL_OES */ - GLuint tex; - - bool has_alpha; -}; - -bool wlr_renderer_is_gles2(struct wlr_renderer *wlr_renderer); -bool wlr_render_timer_is_gles2(struct wlr_render_timer *timer); -bool wlr_texture_is_gles2(struct wlr_texture *texture); -void wlr_gles2_texture_get_attribs(struct wlr_texture *texture, - struct wlr_gles2_texture_attribs *attribs); - -#endif diff --git a/render/gles2/meson.build b/render/gles/meson.build similarity index 82% rename from render/gles2/meson.build rename to render/gles/meson.build index a16ec4061..d4c53c894 100644 --- a/render/gles2/meson.build +++ b/render/gles/meson.build @@ -1,6 +1,6 @@ glesv2 = dependency('glesv2', required: 'gles2' in renderers) -if not (glesv2.found() and internal_features['egl']) +if not ((glesv2.found() or glesv3.found()) and internal_features['egl']) subdir_done() endif diff --git a/render/gles2/pass.c b/render/gles/pass.c similarity index 87% rename from render/gles2/pass.c rename to render/gles/pass.c index b10ac047d..e9cd6243e 100644 --- a/render/gles2/pass.c +++ b/render/gles/pass.c @@ -6,26 +6,26 @@ #include #include #include "render/egl.h" -#include "render/gles2.h" +#include "render/gles.h" #include "util/matrix.h" #define MAX_QUADS 86 // 4kb static const struct wlr_render_pass_impl render_pass_impl; -static struct wlr_gles2_render_pass *get_render_pass(struct wlr_render_pass *wlr_pass) { +static struct wlr_gles_render_pass *get_render_pass(struct wlr_render_pass *wlr_pass) { assert(wlr_pass->impl == &render_pass_impl); - struct wlr_gles2_render_pass *pass = wl_container_of(wlr_pass, pass, base); + struct wlr_gles_render_pass *pass = wl_container_of(wlr_pass, pass, base); return pass; } static bool render_pass_submit(struct wlr_render_pass *wlr_pass) { - struct wlr_gles2_render_pass *pass = get_render_pass(wlr_pass); - struct wlr_gles2_renderer *renderer = pass->buffer->renderer; - struct wlr_gles2_render_timer *timer = pass->timer; + struct wlr_gles_render_pass *pass = get_render_pass(wlr_pass); + struct wlr_gles_renderer *renderer = pass->buffer->renderer; + struct wlr_gles_render_timer *timer = pass->timer; bool ok = false; - push_gles2_debug(renderer); + push_gles_debug(renderer); if (timer) { // clear disjoint flag @@ -65,7 +65,7 @@ static bool render_pass_submit(struct wlr_render_pass *wlr_pass) { out: glBindFramebuffer(GL_FRAMEBUFFER, 0); - pop_gles2_debug(renderer); + pop_gles_debug(renderer); wlr_egl_restore_context(&pass->prev_ctx); wlr_drm_syncobj_timeline_unref(pass->signal_timeline); @@ -166,11 +166,11 @@ static void setup_blending(enum wlr_render_blend_mode mode) { static void render_pass_add_texture(struct wlr_render_pass *wlr_pass, const struct wlr_render_texture_options *options) { - struct wlr_gles2_render_pass *pass = get_render_pass(wlr_pass); - struct wlr_gles2_renderer *renderer = pass->buffer->renderer; - struct wlr_gles2_texture *texture = gles2_get_texture(options->texture); + struct wlr_gles_render_pass *pass = get_render_pass(wlr_pass); + struct wlr_gles_renderer *renderer = pass->buffer->renderer; + struct wlr_gles_texture *texture = gles_get_texture(options->texture); - struct wlr_gles2_tex_shader *shader = NULL; + struct wlr_gles_tex_shader *shader = NULL; switch (texture->target) { case GL_TEXTURE_2D: @@ -201,7 +201,7 @@ static void render_pass_add_texture(struct wlr_render_pass *wlr_pass, src_fbox.width /= options->texture->width; src_fbox.height /= options->texture->height; - push_gles2_debug(renderer); + push_gles_debug(renderer); if (options->wait_timeline != NULL) { int sync_file_fd = @@ -250,19 +250,19 @@ static void render_pass_add_texture(struct wlr_render_pass *wlr_pass, render(&dst_box, options->clip, shader->pos_attrib); glBindTexture(texture->target, 0); - pop_gles2_debug(renderer); + pop_gles_debug(renderer); } static void render_pass_add_rect(struct wlr_render_pass *wlr_pass, const struct wlr_render_rect_options *options) { - struct wlr_gles2_render_pass *pass = get_render_pass(wlr_pass); - struct wlr_gles2_renderer *renderer = pass->buffer->renderer; + struct wlr_gles_render_pass *pass = get_render_pass(wlr_pass); + struct wlr_gles_renderer *renderer = pass->buffer->renderer; const struct wlr_render_color *color = &options->color; struct wlr_box box; wlr_render_rect_options_get_box(options, pass->buffer->buffer, &box); - push_gles2_debug(renderer); + push_gles_debug(renderer); setup_blending(color->a == 1.0 ? WLR_RENDER_BLEND_MODE_NONE : options->blend_mode); glUseProgram(renderer->shaders.quad.program); @@ -272,7 +272,7 @@ static void render_pass_add_rect(struct wlr_render_pass *wlr_pass, render(&box, options->clip, renderer->shaders.quad.pos_attrib); - pop_gles2_debug(renderer); + pop_gles_debug(renderer); } static const struct wlr_render_pass_impl render_pass_impl = { @@ -294,10 +294,10 @@ static const char *reset_status_str(GLenum status) { } } -struct wlr_gles2_render_pass *begin_gles2_buffer_pass(struct wlr_gles2_buffer *buffer, - struct wlr_egl_context *prev_ctx, struct wlr_gles2_render_timer *timer, +struct wlr_gles_render_pass *begin_gles_buffer_pass(struct wlr_gles_buffer *buffer, + struct wlr_egl_context *prev_ctx, struct wlr_gles_render_timer *timer, struct wlr_drm_syncobj_timeline *signal_timeline, uint64_t signal_point) { - struct wlr_gles2_renderer *renderer = buffer->renderer; + struct wlr_gles_renderer *renderer = buffer->renderer; struct wlr_buffer *wlr_buffer = buffer->buffer; if (renderer->procs.glGetGraphicsResetStatusKHR) { @@ -309,12 +309,12 @@ struct wlr_gles2_render_pass *begin_gles2_buffer_pass(struct wlr_gles2_buffer *b } } - GLint fbo = gles2_buffer_get_fbo(buffer); + GLint fbo = gles_buffer_get_fbo(buffer); if (!fbo) { return NULL; } - struct wlr_gles2_render_pass *pass = calloc(1, sizeof(*pass)); + struct wlr_gles_render_pass *pass = calloc(1, sizeof(*pass)); if (pass == NULL) { return NULL; } @@ -332,13 +332,13 @@ struct wlr_gles2_render_pass *begin_gles2_buffer_pass(struct wlr_gles2_buffer *b matrix_projection(pass->projection_matrix, wlr_buffer->width, wlr_buffer->height, WL_OUTPUT_TRANSFORM_FLIPPED_180); - push_gles2_debug(renderer); + push_gles_debug(renderer); glBindFramebuffer(GL_FRAMEBUFFER, fbo); glViewport(0, 0, wlr_buffer->width, wlr_buffer->height); glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); glDisable(GL_SCISSOR_TEST); - pop_gles2_debug(renderer); + pop_gles_debug(renderer); return pass; } diff --git a/render/gles2/pixel_format.c b/render/gles/pixel_format.c similarity index 88% rename from render/gles2/pixel_format.c rename to render/gles/pixel_format.c index e74cb29fa..220568014 100644 --- a/render/gles2/pixel_format.c +++ b/render/gles/pixel_format.c @@ -1,14 +1,14 @@ #include #include #include -#include "render/gles2.h" +#include "render/gles.h" #include "render/pixel_format.h" /* * The DRM formats are little endian while the GL formats are big endian, * so DRM_FORMAT_ARGB8888 is actually compatible with GL_BGRA_EXT. */ -static const struct wlr_gles2_pixel_format formats[] = { +static const struct wlr_gles_pixel_format formats[] = { { .drm_format = DRM_FORMAT_ARGB8888, .gl_format = GL_BGRA_EXT, @@ -101,8 +101,8 @@ static const struct wlr_gles2_pixel_format formats[] = { * Return true if supported for texturing, even if other operations like * reading aren't supported. */ -bool is_gles2_pixel_format_supported(const struct wlr_gles2_renderer *renderer, - const struct wlr_gles2_pixel_format *format) { +bool is_gles_pixel_format_supported(const struct wlr_gles_renderer *renderer, + const struct wlr_gles_pixel_format *format) { if (format->gl_type == GL_UNSIGNED_INT_2_10_10_10_REV_EXT && !renderer->exts.EXT_texture_type_2_10_10_10_REV) { return false; @@ -124,7 +124,7 @@ bool is_gles2_pixel_format_supported(const struct wlr_gles2_renderer *renderer, return true; } -const struct wlr_gles2_pixel_format *get_gles2_format_from_drm(uint32_t fmt) { +const struct wlr_gles_pixel_format *get_gles_format_from_drm(uint32_t fmt) { for (size_t i = 0; i < sizeof(formats) / sizeof(*formats); ++i) { if (formats[i].drm_format == fmt) { return &formats[i]; @@ -133,7 +133,7 @@ const struct wlr_gles2_pixel_format *get_gles2_format_from_drm(uint32_t fmt) { return NULL; } -const struct wlr_gles2_pixel_format *get_gles2_format_from_gl( +const struct wlr_gles_pixel_format *get_gles_format_from_gl( GLint gl_format, GLint gl_type, bool alpha) { for (size_t i = 0; i < sizeof(formats) / sizeof(*formats); ++i) { if (formats[i].gl_format != gl_format || @@ -150,10 +150,10 @@ const struct wlr_gles2_pixel_format *get_gles2_format_from_gl( return NULL; } -void get_gles2_shm_formats(const struct wlr_gles2_renderer *renderer, +void get_gles_shm_formats(const struct wlr_gles_renderer *renderer, struct wlr_drm_format_set *out) { for (size_t i = 0; i < sizeof(formats) / sizeof(formats[0]); i++) { - if (!is_gles2_pixel_format_supported(renderer, &formats[i])) { + if (!is_gles_pixel_format_supported(renderer, &formats[i])) { continue; } wlr_drm_format_set_add(out, formats[i].drm_format, DRM_FORMAT_MOD_INVALID); diff --git a/render/gles2/renderer.c b/render/gles/renderer.c similarity index 74% rename from render/gles2/renderer.c rename to render/gles/renderer.c index e362daee8..a30293303 100644 --- a/render/gles2/renderer.c +++ b/render/gles/renderer.c @@ -16,54 +16,54 @@ #include #include #include "render/egl.h" -#include "render/gles2.h" +#include "render/gles.h" #include "render/pixel_format.h" #include "util/time.h" -#include "common_vert_src.h" -#include "quad_frag_src.h" -#include "tex_rgba_frag_src.h" -#include "tex_rgbx_frag_src.h" -#include "tex_external_frag_src.h" +#include "gles2_common_vert_src.h" +#include "gles2_quad_frag_src.h" +#include "gles2_tex_rgba_frag_src.h" +#include "gles2_tex_rgbx_frag_src.h" +#include "gles2_tex_external_frag_src.h" static const struct wlr_renderer_impl renderer_impl; static const struct wlr_render_timer_impl render_timer_impl; -bool wlr_renderer_is_gles2(struct wlr_renderer *wlr_renderer) { +bool wlr_renderer_is_gles(struct wlr_renderer *wlr_renderer) { return wlr_renderer->impl == &renderer_impl; } -struct wlr_gles2_renderer *gles2_get_renderer( +struct wlr_gles_renderer *gles_get_renderer( struct wlr_renderer *wlr_renderer) { - assert(wlr_renderer_is_gles2(wlr_renderer)); - struct wlr_gles2_renderer *renderer = wl_container_of(wlr_renderer, renderer, wlr_renderer); + assert(wlr_renderer_is_gles(wlr_renderer)); + struct wlr_gles_renderer *renderer = wl_container_of(wlr_renderer, renderer, wlr_renderer); return renderer; } -bool wlr_render_timer_is_gles2(struct wlr_render_timer *timer) { +bool wlr_render_timer_is_gles(struct wlr_render_timer *timer) { return timer->impl == &render_timer_impl; } -struct wlr_gles2_render_timer *gles2_get_render_timer(struct wlr_render_timer *wlr_timer) { - assert(wlr_render_timer_is_gles2(wlr_timer)); - struct wlr_gles2_render_timer *timer = wl_container_of(wlr_timer, timer, base); +struct wlr_gles_render_timer *gles_get_render_timer(struct wlr_render_timer *wlr_timer) { + assert(wlr_render_timer_is_gles(wlr_timer)); + struct wlr_gles_render_timer *timer = wl_container_of(wlr_timer, timer, base); return timer; } -static void destroy_buffer(struct wlr_gles2_buffer *buffer) { +static void destroy_buffer(struct wlr_gles_buffer *buffer) { wl_list_remove(&buffer->link); wlr_addon_finish(&buffer->addon); struct wlr_egl_context prev_ctx; wlr_egl_make_current(buffer->renderer->egl, &prev_ctx); - push_gles2_debug(buffer->renderer); + push_gles_debug(buffer->renderer); glDeleteFramebuffers(1, &buffer->fbo); glDeleteRenderbuffers(1, &buffer->rbo); glDeleteTextures(1, &buffer->tex); - pop_gles2_debug(buffer->renderer); + pop_gles_debug(buffer->renderer); wlr_egl_destroy_image(buffer->renderer->egl, buffer->image); @@ -73,17 +73,17 @@ static void destroy_buffer(struct wlr_gles2_buffer *buffer) { } static void handle_buffer_destroy(struct wlr_addon *addon) { - struct wlr_gles2_buffer *buffer = + struct wlr_gles_buffer *buffer = wl_container_of(addon, buffer, addon); destroy_buffer(buffer); } static const struct wlr_addon_interface buffer_addon_impl = { - .name = "wlr_gles2_buffer", + .name = "wlr_gles_buffer", .destroy = handle_buffer_destroy, }; -GLuint gles2_buffer_get_fbo(struct wlr_gles2_buffer *buffer) { +GLuint gles_buffer_get_fbo(struct wlr_gles_buffer *buffer) { if (buffer->external_only) { wlr_log(WLR_ERROR, "DMA-BUF format is external-only"); return 0; @@ -93,7 +93,7 @@ GLuint gles2_buffer_get_fbo(struct wlr_gles2_buffer *buffer) { return buffer->fbo; } - push_gles2_debug(buffer->renderer); + push_gles_debug(buffer->renderer); if (!buffer->rbo) { glGenRenderbuffers(1, &buffer->rbo); @@ -116,21 +116,21 @@ GLuint gles2_buffer_get_fbo(struct wlr_gles2_buffer *buffer) { buffer->fbo = 0; } - pop_gles2_debug(buffer->renderer); + pop_gles_debug(buffer->renderer); return buffer->fbo; } -struct wlr_gles2_buffer *gles2_buffer_get_or_create(struct wlr_gles2_renderer *renderer, +struct wlr_gles_buffer *gles_buffer_get_or_create(struct wlr_gles_renderer *renderer, struct wlr_buffer *wlr_buffer) { struct wlr_addon *addon = wlr_addon_find(&wlr_buffer->addons, renderer, &buffer_addon_impl); if (addon) { - struct wlr_gles2_buffer *buffer = wl_container_of(addon, buffer, addon); + struct wlr_gles_buffer *buffer = wl_container_of(addon, buffer, addon); return buffer; } - struct wlr_gles2_buffer *buffer = calloc(1, sizeof(*buffer)); + struct wlr_gles_buffer *buffer = calloc(1, sizeof(*buffer)); if (buffer == NULL) { wlr_log_errno(WLR_ERROR, "Allocation failed"); return NULL; @@ -164,9 +164,9 @@ error_buffer: return NULL; } -static const struct wlr_drm_format_set *gles2_get_texture_formats( +static const struct wlr_drm_format_set *gles_get_texture_formats( struct wlr_renderer *wlr_renderer, uint32_t buffer_caps) { - struct wlr_gles2_renderer *renderer = gles2_get_renderer(wlr_renderer); + struct wlr_gles_renderer *renderer = gles_get_renderer(wlr_renderer); if (buffer_caps & WLR_BUFFER_CAP_DMABUF) { return wlr_egl_get_dmabuf_texture_formats(renderer->egl); } else if (buffer_caps & WLR_BUFFER_CAP_DATA_PTR) { @@ -176,15 +176,15 @@ static const struct wlr_drm_format_set *gles2_get_texture_formats( } } -static const struct wlr_drm_format_set *gles2_get_render_formats( +static const struct wlr_drm_format_set *gles_get_render_formats( struct wlr_renderer *wlr_renderer) { - struct wlr_gles2_renderer *renderer = gles2_get_renderer(wlr_renderer); + struct wlr_gles_renderer *renderer = gles_get_renderer(wlr_renderer); return wlr_egl_get_dmabuf_render_formats(renderer->egl); } -static int gles2_get_drm_fd(struct wlr_renderer *wlr_renderer) { - struct wlr_gles2_renderer *renderer = - gles2_get_renderer(wlr_renderer); +static int gles_get_drm_fd(struct wlr_renderer *wlr_renderer) { + struct wlr_gles_renderer *renderer = + gles_get_renderer(wlr_renderer); if (renderer->drm_fd < 0) { renderer->drm_fd = wlr_egl_dup_drm_fd(renderer->egl); @@ -193,33 +193,33 @@ static int gles2_get_drm_fd(struct wlr_renderer *wlr_renderer) { return renderer->drm_fd; } -struct wlr_egl *wlr_gles2_renderer_get_egl(struct wlr_renderer *wlr_renderer) { - struct wlr_gles2_renderer *renderer = - gles2_get_renderer(wlr_renderer); +struct wlr_egl *wlr_gles_renderer_get_egl(struct wlr_renderer *wlr_renderer) { + struct wlr_gles_renderer *renderer = + gles_get_renderer(wlr_renderer); return renderer->egl; } -static void gles2_destroy(struct wlr_renderer *wlr_renderer) { - struct wlr_gles2_renderer *renderer = gles2_get_renderer(wlr_renderer); +static void gles_destroy(struct wlr_renderer *wlr_renderer) { + struct wlr_gles_renderer *renderer = gles_get_renderer(wlr_renderer); wlr_egl_make_current(renderer->egl, NULL); - struct wlr_gles2_texture *tex, *tex_tmp; + struct wlr_gles_texture *tex, *tex_tmp; wl_list_for_each_safe(tex, tex_tmp, &renderer->textures, link) { - gles2_texture_destroy(tex); + gles_texture_destroy(tex); } - struct wlr_gles2_buffer *buffer, *buffer_tmp; + struct wlr_gles_buffer *buffer, *buffer_tmp; wl_list_for_each_safe(buffer, buffer_tmp, &renderer->buffers, link) { destroy_buffer(buffer); } - push_gles2_debug(renderer); + push_gles_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_gles2_debug(renderer); + pop_gles_debug(renderer); if (renderer->exts.KHR_debug) { glDisable(GL_DEBUG_OUTPUT_KHR); @@ -238,27 +238,27 @@ static void gles2_destroy(struct wlr_renderer *wlr_renderer) { free(renderer); } -static struct wlr_render_pass *gles2_begin_buffer_pass(struct wlr_renderer *wlr_renderer, +static struct wlr_render_pass *gles_begin_buffer_pass(struct wlr_renderer *wlr_renderer, struct wlr_buffer *wlr_buffer, const struct wlr_buffer_pass_options *options) { - struct wlr_gles2_renderer *renderer = gles2_get_renderer(wlr_renderer); + struct wlr_gles_renderer *renderer = gles_get_renderer(wlr_renderer); struct wlr_egl_context prev_ctx = {0}; if (!wlr_egl_make_current(renderer->egl, &prev_ctx)) { return NULL; } - struct wlr_gles2_render_timer *timer = NULL; + struct wlr_gles_render_timer *timer = NULL; if (options->timer) { - timer = gles2_get_render_timer(options->timer); + timer = gles_get_render_timer(options->timer); clock_gettime(CLOCK_MONOTONIC, &timer->cpu_start); } - struct wlr_gles2_buffer *buffer = gles2_buffer_get_or_create(renderer, wlr_buffer); + struct wlr_gles_buffer *buffer = gles_buffer_get_or_create(renderer, wlr_buffer); if (!buffer) { return NULL; } - struct wlr_gles2_render_pass *pass = begin_gles2_buffer_pass(buffer, + struct wlr_gles_render_pass *pass = begin_gles_buffer_pass(buffer, &prev_ctx, timer, options->signal_timeline, options->signal_point); if (!pass) { return NULL; @@ -266,9 +266,9 @@ static struct wlr_render_pass *gles2_begin_buffer_pass(struct wlr_renderer *wlr_ return &pass->base; } -GLuint wlr_gles2_renderer_get_buffer_fbo(struct wlr_renderer *wlr_renderer, +GLuint wlr_gles_renderer_get_buffer_fbo(struct wlr_renderer *wlr_renderer, struct wlr_buffer *wlr_buffer) { - struct wlr_gles2_renderer *renderer = gles2_get_renderer(wlr_renderer); + struct wlr_gles_renderer *renderer = gles_get_renderer(wlr_renderer); GLuint fbo = 0; struct wlr_egl_context prev_ctx = {0}; @@ -276,23 +276,23 @@ GLuint wlr_gles2_renderer_get_buffer_fbo(struct wlr_renderer *wlr_renderer, return 0; } - struct wlr_gles2_buffer *buffer = gles2_buffer_get_or_create(renderer, wlr_buffer); + struct wlr_gles_buffer *buffer = gles_buffer_get_or_create(renderer, wlr_buffer); if (buffer) { - fbo = gles2_buffer_get_fbo(buffer); + fbo = gles_buffer_get_fbo(buffer); } wlr_egl_restore_context(&prev_ctx); return fbo; } -static struct wlr_render_timer *gles2_render_timer_create(struct wlr_renderer *wlr_renderer) { - struct wlr_gles2_renderer *renderer = gles2_get_renderer(wlr_renderer); +static struct wlr_render_timer *gles_render_timer_create(struct wlr_renderer *wlr_renderer) { + struct wlr_gles_renderer *renderer = gles_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 wlr_gles2_render_timer *timer = calloc(1, sizeof(*timer)); + struct wlr_gles_render_timer *timer = calloc(1, sizeof(*timer)); if (!timer) { return NULL; } @@ -307,9 +307,9 @@ static struct wlr_render_timer *gles2_render_timer_create(struct wlr_renderer *w return &timer->base; } -static int gles2_get_render_time(struct wlr_render_timer *wlr_timer) { - struct wlr_gles2_render_timer *timer = gles2_get_render_timer(wlr_timer); - struct wlr_gles2_renderer *renderer = timer->renderer; +static int gles_get_render_time(struct wlr_render_timer *wlr_timer) { + struct wlr_gles_render_timer *timer = gles_get_render_timer(wlr_timer); + struct wlr_gles_renderer *renderer = timer->renderer; struct wlr_egl_context prev_ctx; wlr_egl_make_current(renderer->egl, &prev_ctx); @@ -341,9 +341,9 @@ static int gles2_get_render_time(struct wlr_render_timer *wlr_timer) { return gl_render_end - timer->gl_cpu_end + cpu_nsec_total; } -static void gles2_render_timer_destroy(struct wlr_render_timer *wlr_timer) { - struct wlr_gles2_render_timer *timer = wl_container_of(wlr_timer, timer, base); - struct wlr_gles2_renderer *renderer = timer->renderer; +static void gles_render_timer_destroy(struct wlr_render_timer *wlr_timer) { + struct wlr_gles_render_timer *timer = wl_container_of(wlr_timer, timer, base); + struct wlr_gles_renderer *renderer = timer->renderer; struct wlr_egl_context prev_ctx; wlr_egl_make_current(renderer->egl, &prev_ctx); @@ -353,21 +353,21 @@ static void gles2_render_timer_destroy(struct wlr_render_timer *wlr_timer) { } static const struct wlr_renderer_impl renderer_impl = { - .destroy = gles2_destroy, - .get_texture_formats = gles2_get_texture_formats, - .get_render_formats = gles2_get_render_formats, - .get_drm_fd = gles2_get_drm_fd, - .texture_from_buffer = gles2_texture_from_buffer, - .begin_buffer_pass = gles2_begin_buffer_pass, - .render_timer_create = gles2_render_timer_create, + .destroy = gles_destroy, + .get_texture_formats = gles_get_texture_formats, + .get_render_formats = gles_get_render_formats, + .get_drm_fd = gles_get_drm_fd, + .texture_from_buffer = gles_texture_from_buffer, + .begin_buffer_pass = gles_begin_buffer_pass, + .render_timer_create = gles_render_timer_create, }; static const struct wlr_render_timer_impl render_timer_impl = { - .get_duration_ns = gles2_get_render_time, - .destroy = gles2_render_timer_destroy, + .get_duration_ns = gles_get_render_time, + .destroy = gles_render_timer_destroy, }; -void push_gles2_debug_(struct wlr_gles2_renderer *renderer, +void push_gles_debug_(struct wlr_gles_renderer *renderer, const char *file, const char *func) { if (!renderer->procs.glPushDebugGroupKHR) { return; @@ -379,13 +379,13 @@ void push_gles2_debug_(struct wlr_gles2_renderer *renderer, renderer->procs.glPushDebugGroupKHR(GL_DEBUG_SOURCE_APPLICATION_KHR, 1, -1, str); } -void pop_gles2_debug(struct wlr_gles2_renderer *renderer) { +void pop_gles_debug(struct wlr_gles_renderer *renderer) { if (renderer->procs.glPopDebugGroupKHR) { renderer->procs.glPopDebugGroupKHR(); } } -static enum wlr_log_importance gles2_log_importance_to_wlr(GLenum type) { +static enum wlr_log_importance gles_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; @@ -400,14 +400,14 @@ static enum wlr_log_importance gles2_log_importance_to_wlr(GLenum type) { } } -static void gles2_log(GLenum src, GLenum type, GLuint id, GLenum severity, +static void gles_log(GLenum src, GLenum type, GLuint id, GLenum severity, GLsizei len, const GLchar *msg, const void *user) { - _wlr_log(gles2_log_importance_to_wlr(type), "[GLES2] %s", msg); + _wlr_log(gles_log_importance_to_wlr(type), "[GLES] %s", msg); } -static GLuint compile_shader(struct wlr_gles2_renderer *renderer, +static GLuint compile_shader(struct wlr_gles_renderer *renderer, GLenum type, const GLchar *src) { - push_gles2_debug(renderer); + push_gles_debug(renderer); GLuint shader = glCreateShader(type); glShaderSource(shader, 1, &src, NULL); @@ -421,13 +421,13 @@ static GLuint compile_shader(struct wlr_gles2_renderer *renderer, shader = 0; } - pop_gles2_debug(renderer); + pop_gles_debug(renderer); return shader; } -static GLuint link_program(struct wlr_gles2_renderer *renderer, +static GLuint link_program(struct wlr_gles_renderer *renderer, const GLchar *vert_src, const GLchar *frag_src) { - push_gles2_debug(renderer); + push_gles_debug(renderer); GLuint vert = compile_shader(renderer, GL_VERTEX_SHADER, vert_src); if (!vert) { @@ -458,11 +458,11 @@ static GLuint link_program(struct wlr_gles2_renderer *renderer, goto error; } - pop_gles2_debug(renderer); + pop_gles_debug(renderer); return prog; error: - pop_gles2_debug(renderer); + pop_gles_debug(renderer); return 0; } @@ -493,16 +493,17 @@ static void load_gl_proc(void *proc_ptr, const char *name) { *(void **)proc_ptr = proc; } -struct wlr_renderer *wlr_gles2_renderer_create_with_drm_fd(int drm_fd) { - struct wlr_egl *egl = wlr_egl_create_with_drm_fd(drm_fd); +struct wlr_renderer *wlr_gles_renderer_create_with_drm_fd(int drm_fd, + enum egl_version version) { + struct wlr_egl *egl = wlr_egl_create_with_drm_fd(drm_fd, version); if (egl == NULL) { wlr_log(WLR_ERROR, "Could not initialize EGL"); return NULL; } - struct wlr_renderer *renderer = wlr_gles2_renderer_create(egl); + struct wlr_renderer *renderer = wlr_gles_renderer_create(egl); if (!renderer) { - wlr_log(WLR_ERROR, "Failed to create GLES2 renderer"); + wlr_log(WLR_ERROR, "Failed to create GLES renderer"); wlr_egl_destroy(egl); return NULL; } @@ -510,7 +511,7 @@ struct wlr_renderer *wlr_gles2_renderer_create_with_drm_fd(int drm_fd) { return renderer; } -struct wlr_renderer *wlr_gles2_renderer_create(struct wlr_egl *egl) { +struct wlr_renderer *wlr_gles_renderer_create(struct wlr_egl *egl) { if (!wlr_egl_make_current(egl, NULL)) { return NULL; } @@ -521,7 +522,7 @@ struct wlr_renderer *wlr_gles2_renderer_create(struct wlr_egl *egl) { return NULL; } - struct wlr_gles2_renderer *renderer = calloc(1, sizeof(*renderer)); + struct wlr_gles_renderer *renderer = calloc(1, sizeof(*renderer)); if (renderer == NULL) { return NULL; } @@ -535,11 +536,11 @@ struct wlr_renderer *wlr_gles2_renderer_create(struct wlr_egl *egl) { renderer->exts_str = exts_str; renderer->drm_fd = -1; - wlr_log(WLR_INFO, "Creating GLES2 renderer"); + wlr_log(WLR_INFO, "Creating GLES 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); + wlr_log(WLR_INFO, "Supported GLES 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"); @@ -547,7 +548,7 @@ struct wlr_renderer *wlr_gles2_renderer_create(struct wlr_egl *egl) { return NULL; } if (!check_gl_ext(exts_str, "GL_EXT_texture_format_BGRA8888")) { - wlr_log(WLR_ERROR, "BGRA8888 format not supported by GLES2"); + wlr_log(WLR_ERROR, "BGRA8888 format not supported by GLES"); free(renderer); return NULL; } @@ -621,7 +622,7 @@ struct wlr_renderer *wlr_gles2_renderer_create(struct wlr_egl *egl) { if (renderer->exts.KHR_debug) { glEnable(GL_DEBUG_OUTPUT_KHR); glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_KHR); - renderer->procs.glDebugMessageCallbackKHR(gles2_log, NULL); + renderer->procs.glDebugMessageCallbackKHR(gles_log, NULL); // Silence unwanted message types renderer->procs.glDebugMessageControlKHR(GL_DONT_CARE, @@ -630,11 +631,11 @@ struct wlr_renderer *wlr_gles2_renderer_create(struct wlr_egl *egl) { GL_DEBUG_TYPE_PUSH_GROUP_KHR, GL_DONT_CARE, 0, NULL, GL_FALSE); } - push_gles2_debug(renderer); + push_gles_debug(renderer); GLuint prog; renderer->shaders.quad.program = prog = - link_program(renderer, common_vert_src, quad_frag_src); + link_program(renderer, gles2_common_vert_src, gles2_quad_frag_src); if (!renderer->shaders.quad.program) { goto error; } @@ -643,7 +644,7 @@ struct wlr_renderer *wlr_gles2_renderer_create(struct wlr_egl *egl) { renderer->shaders.quad.pos_attrib = glGetAttribLocation(prog, "pos"); renderer->shaders.tex_rgba.program = prog = - link_program(renderer, common_vert_src, tex_rgba_frag_src); + link_program(renderer, gles2_common_vert_src, gles2_tex_rgba_frag_src); if (!renderer->shaders.tex_rgba.program) { goto error; } @@ -654,7 +655,7 @@ struct wlr_renderer *wlr_gles2_renderer_create(struct wlr_egl *egl) { renderer->shaders.tex_rgba.pos_attrib = glGetAttribLocation(prog, "pos"); renderer->shaders.tex_rgbx.program = prog = - link_program(renderer, common_vert_src, tex_rgbx_frag_src); + link_program(renderer, gles2_common_vert_src, gles2_tex_rgbx_frag_src); if (!renderer->shaders.tex_rgbx.program) { goto error; } @@ -666,7 +667,7 @@ struct wlr_renderer *wlr_gles2_renderer_create(struct wlr_egl *egl) { if (renderer->exts.OES_egl_image_external) { renderer->shaders.tex_ext.program = prog = - link_program(renderer, common_vert_src, tex_external_frag_src); + link_program(renderer, gles2_common_vert_src, gles2_tex_external_frag_src); if (!renderer->shaders.tex_ext.program) { goto error; } @@ -677,11 +678,11 @@ struct wlr_renderer *wlr_gles2_renderer_create(struct wlr_egl *egl) { renderer->shaders.tex_ext.pos_attrib = glGetAttribLocation(prog, "pos"); } - pop_gles2_debug(renderer); + pop_gles_debug(renderer); wlr_egl_unset_current(renderer->egl); - get_gles2_shm_formats(renderer, &renderer->shm_texture_formats); + get_gles_shm_formats(renderer, &renderer->shm_texture_formats); int drm_fd = wlr_renderer_get_drm_fd(&renderer->wlr_renderer); uint64_t cap_syncobj_timeline; @@ -698,7 +699,7 @@ error: glDeleteProgram(renderer->shaders.tex_rgbx.program); glDeleteProgram(renderer->shaders.tex_ext.program); - pop_gles2_debug(renderer); + pop_gles_debug(renderer); if (renderer->exts.KHR_debug) { glDisable(GL_DEBUG_OUTPUT_KHR); @@ -711,8 +712,8 @@ error: return NULL; } -bool wlr_gles2_renderer_check_ext(struct wlr_renderer *wlr_renderer, +bool wlr_gles_renderer_check_ext(struct wlr_renderer *wlr_renderer, const char *ext) { - struct wlr_gles2_renderer *renderer = gles2_get_renderer(wlr_renderer); + struct wlr_gles_renderer *renderer = gles_get_renderer(wlr_renderer); return check_gl_ext(renderer->exts_str, ext); } diff --git a/render/gles2/shaders/embed.sh b/render/gles/shaders/embed.sh similarity index 100% rename from render/gles2/shaders/embed.sh rename to render/gles/shaders/embed.sh diff --git a/render/gles2/shaders/common.vert b/render/gles/shaders/gles2_common.vert similarity index 100% rename from render/gles2/shaders/common.vert rename to render/gles/shaders/gles2_common.vert diff --git a/render/gles2/shaders/quad.frag b/render/gles/shaders/gles2_quad.frag similarity index 100% rename from render/gles2/shaders/quad.frag rename to render/gles/shaders/gles2_quad.frag diff --git a/render/gles2/shaders/tex_external.frag b/render/gles/shaders/gles2_tex_external.frag similarity index 100% rename from render/gles2/shaders/tex_external.frag rename to render/gles/shaders/gles2_tex_external.frag diff --git a/render/gles2/shaders/tex_rgba.frag b/render/gles/shaders/gles2_tex_rgba.frag similarity index 100% rename from render/gles2/shaders/tex_rgba.frag rename to render/gles/shaders/gles2_tex_rgba.frag diff --git a/render/gles2/shaders/tex_rgbx.frag b/render/gles/shaders/gles2_tex_rgbx.frag similarity index 100% rename from render/gles2/shaders/tex_rgbx.frag rename to render/gles/shaders/gles2_tex_rgbx.frag diff --git a/render/gles2/shaders/meson.build b/render/gles/shaders/meson.build similarity index 75% rename from render/gles2/shaders/meson.build rename to render/gles/shaders/meson.build index 64e4e93fb..cba9b6034 100644 --- a/render/gles2/shaders/meson.build +++ b/render/gles/shaders/meson.build @@ -1,16 +1,16 @@ embed = find_program('./embed.sh', native: true) shaders = [ - 'common.vert', - 'quad.frag', - 'tex_rgba.frag', - 'tex_rgbx.frag', - 'tex_external.frag', + 'gles2_common.vert', + 'gles2_quad.frag', + 'gles2_tex_rgba.frag', + 'gles2_tex_rgbx.frag', + 'gles2_tex_external.frag', ] foreach name : shaders custom_target( - 'gles2-' + name, + 'gles-' + name, input: name, output: name + '_check', command: [glslang, '@INPUT@'], diff --git a/render/gles2/texture.c b/render/gles/texture.c similarity index 72% rename from render/gles2/texture.c rename to render/gles/texture.c index 9a967ebdb..97632c7db 100644 --- a/render/gles2/texture.c +++ b/render/gles/texture.c @@ -11,25 +11,25 @@ #include #include #include "render/egl.h" -#include "render/gles2.h" +#include "render/gles.h" #include "render/pixel_format.h" static const struct wlr_texture_impl texture_impl; -bool wlr_texture_is_gles2(struct wlr_texture *wlr_texture) { +bool wlr_texture_is_gles(struct wlr_texture *wlr_texture) { return wlr_texture->impl == &texture_impl; } -struct wlr_gles2_texture *gles2_get_texture( +struct wlr_gles_texture *gles_get_texture( struct wlr_texture *wlr_texture) { - assert(wlr_texture_is_gles2(wlr_texture)); - struct wlr_gles2_texture *texture = wl_container_of(wlr_texture, texture, wlr_texture); + assert(wlr_texture_is_gles(wlr_texture)); + struct wlr_gles_texture *texture = wl_container_of(wlr_texture, texture, wlr_texture); return texture; } -static bool gles2_texture_update_from_buffer(struct wlr_texture *wlr_texture, +static bool gles_texture_update_from_buffer(struct wlr_texture *wlr_texture, struct wlr_buffer *buffer, const pixman_region32_t *damage) { - struct wlr_gles2_texture *texture = gles2_get_texture(wlr_texture); + struct wlr_gles_texture *texture = gles_get_texture(wlr_texture); if (texture->drm_format == DRM_FORMAT_INVALID) { return false; @@ -48,8 +48,8 @@ static bool gles2_texture_update_from_buffer(struct wlr_texture *wlr_texture, return false; } - const struct wlr_gles2_pixel_format *fmt = - get_gles2_format_from_drm(texture->drm_format); + const struct wlr_gles_pixel_format *fmt = + get_gles_format_from_drm(texture->drm_format); assert(fmt); const struct wlr_pixel_format_info *drm_fmt = @@ -69,7 +69,7 @@ static bool gles2_texture_update_from_buffer(struct wlr_texture *wlr_texture, struct wlr_egl_context prev_ctx; wlr_egl_make_current(texture->renderer->egl, &prev_ctx); - push_gles2_debug(texture->renderer); + push_gles_debug(texture->renderer); glBindTexture(GL_TEXTURE_2D, texture->tex); @@ -95,7 +95,7 @@ static bool gles2_texture_update_from_buffer(struct wlr_texture *wlr_texture, glBindTexture(GL_TEXTURE_2D, 0); - pop_gles2_debug(texture->renderer); + pop_gles_debug(texture->renderer); wlr_egl_restore_context(&prev_ctx); @@ -104,7 +104,7 @@ static bool gles2_texture_update_from_buffer(struct wlr_texture *wlr_texture, return true; } -void gles2_texture_destroy(struct wlr_gles2_texture *texture) { +void gles_texture_destroy(struct wlr_gles_texture *texture) { wl_list_remove(&texture->link); if (texture->buffer != NULL) { wlr_buffer_unlock(texture->buffer->buffer); @@ -112,12 +112,12 @@ void gles2_texture_destroy(struct wlr_gles2_texture *texture) { struct wlr_egl_context prev_ctx; wlr_egl_make_current(texture->renderer->egl, &prev_ctx); - push_gles2_debug(texture->renderer); + push_gles_debug(texture->renderer); glDeleteTextures(1, &texture->tex); glDeleteFramebuffers(1, &texture->fbo); - pop_gles2_debug(texture->renderer); + pop_gles_debug(texture->renderer); wlr_egl_restore_context(&prev_ctx); } @@ -125,11 +125,11 @@ void gles2_texture_destroy(struct wlr_gles2_texture *texture) { free(texture); } -static void handle_gles2_texture_destroy(struct wlr_texture *wlr_texture) { - gles2_texture_destroy(gles2_get_texture(wlr_texture)); +static void handle_gles_texture_destroy(struct wlr_texture *wlr_texture) { + gles_texture_destroy(gles_get_texture(wlr_texture)); } -static bool gles2_texture_bind(struct wlr_gles2_texture *texture) { +static bool gles_texture_bind(struct wlr_gles_texture *texture) { if (texture->fbo) { glBindFramebuffer(GL_FRAMEBUFFER, texture->fbo); } else if (texture->buffer) { @@ -137,7 +137,7 @@ static bool gles2_texture_bind(struct wlr_gles2_texture *texture) { return false; } - GLuint fbo = gles2_buffer_get_fbo(texture->buffer); + GLuint fbo = gles_buffer_get_fbo(texture->buffer); if (!fbo) { return false; } @@ -163,16 +163,16 @@ static bool gles2_texture_bind(struct wlr_gles2_texture *texture) { return true; } -static bool gles2_texture_read_pixels(struct wlr_texture *wlr_texture, +static bool gles_texture_read_pixels(struct wlr_texture *wlr_texture, const struct wlr_texture_read_pixels_options *options) { - struct wlr_gles2_texture *texture = gles2_get_texture(wlr_texture); + struct wlr_gles_texture *texture = gles_get_texture(wlr_texture); struct wlr_box src; wlr_texture_read_pixels_options_get_src_box(options, wlr_texture, &src); - const struct wlr_gles2_pixel_format *fmt = - get_gles2_format_from_drm(options->format); - if (fmt == NULL || !is_gles2_pixel_format_supported(texture->renderer, fmt)) { + const struct wlr_gles_pixel_format *fmt = + get_gles_format_from_drm(options->format); + if (fmt == NULL || !is_gles_pixel_format_supported(texture->renderer, fmt)) { wlr_log(WLR_ERROR, "Cannot read pixels: unsupported pixel format 0x%"PRIX32, options->format); return false; } @@ -191,13 +191,13 @@ static bool gles2_texture_read_pixels(struct wlr_texture *wlr_texture, return false; } - push_gles2_debug(texture->renderer); + push_gles_debug(texture->renderer); struct wlr_egl_context prev_ctx; if (!wlr_egl_make_current(texture->renderer->egl, &prev_ctx)) { return false; } - if (!gles2_texture_bind(texture)) { + if (!gles_texture_bind(texture)) { return false; } @@ -216,7 +216,7 @@ static bool gles2_texture_read_pixels(struct wlr_texture *wlr_texture, glReadPixels(src.x, src.y, src.width, src.height, fmt->gl_format, fmt->gl_type, p); } else { - // Unfortunately GLES2 doesn't support GL_PACK_ROW_LENGTH, so we have to read + // Unfortunately GLES doesn't support GL_PACK_ROW_LENGTH, so we have to read // the lines out row by row for (int32_t i = 0; i < src.height; ++i) { uint32_t y = src.y + i; @@ -226,15 +226,15 @@ static bool gles2_texture_read_pixels(struct wlr_texture *wlr_texture, } wlr_egl_restore_context(&prev_ctx); - pop_gles2_debug(texture->renderer); + pop_gles_debug(texture->renderer); return glGetError() == GL_NO_ERROR; } -static uint32_t gles2_texture_preferred_read_format(struct wlr_texture *wlr_texture) { - struct wlr_gles2_texture *texture = gles2_get_texture(wlr_texture); +static uint32_t gles_texture_preferred_read_format(struct wlr_texture *wlr_texture) { + struct wlr_gles_texture *texture = gles_get_texture(wlr_texture); - push_gles2_debug(texture->renderer); + push_gles_debug(texture->renderer); uint32_t fmt = DRM_FORMAT_INVALID; @@ -243,7 +243,7 @@ static uint32_t gles2_texture_preferred_read_format(struct wlr_texture *wlr_text return fmt; } - if (!gles2_texture_bind(texture)) { + if (!gles_texture_bind(texture)) { goto out; } @@ -253,10 +253,10 @@ static uint32_t gles2_texture_preferred_read_format(struct wlr_texture *wlr_text glGetIntegerv(GL_ALPHA_BITS, &alpha_size); glBindFramebuffer(GL_FRAMEBUFFER, 0); - pop_gles2_debug(texture->renderer); + pop_gles_debug(texture->renderer); - const struct wlr_gles2_pixel_format *pix_fmt = - get_gles2_format_from_gl(gl_format, gl_type, alpha_size > 0); + const struct wlr_gles_pixel_format *pix_fmt = + get_gles_format_from_gl(gl_format, gl_type, alpha_size > 0); if (pix_fmt != NULL) { fmt = pix_fmt->drm_format; goto out; @@ -273,15 +273,15 @@ out: } static const struct wlr_texture_impl texture_impl = { - .update_from_buffer = gles2_texture_update_from_buffer, - .read_pixels = gles2_texture_read_pixels, - .preferred_read_format = gles2_texture_preferred_read_format, - .destroy = handle_gles2_texture_destroy, + .update_from_buffer = gles_texture_update_from_buffer, + .read_pixels = gles_texture_read_pixels, + .preferred_read_format = gles_texture_preferred_read_format, + .destroy = handle_gles_texture_destroy, }; -static struct wlr_gles2_texture *gles2_texture_create( - struct wlr_gles2_renderer *renderer, uint32_t width, uint32_t height) { - struct wlr_gles2_texture *texture = calloc(1, sizeof(*texture)); +static struct wlr_gles_texture *gles_texture_create( + struct wlr_gles_renderer *renderer, uint32_t width, uint32_t height) { + struct wlr_gles_texture *texture = calloc(1, sizeof(*texture)); if (texture == NULL) { wlr_log_errno(WLR_ERROR, "Allocation failed"); return NULL; @@ -293,14 +293,14 @@ static struct wlr_gles2_texture *gles2_texture_create( return texture; } -static struct wlr_texture *gles2_texture_from_pixels( +static struct wlr_texture *gles_texture_from_pixels( struct wlr_renderer *wlr_renderer, uint32_t drm_format, uint32_t stride, uint32_t width, uint32_t height, const void *data) { - struct wlr_gles2_renderer *renderer = gles2_get_renderer(wlr_renderer); + struct wlr_gles_renderer *renderer = gles_get_renderer(wlr_renderer); - const struct wlr_gles2_pixel_format *fmt = - get_gles2_format_from_drm(drm_format); + const struct wlr_gles_pixel_format *fmt = + get_gles_format_from_drm(drm_format); if (fmt == NULL) { wlr_log(WLR_ERROR, "Unsupported pixel format 0x%"PRIX32, drm_format); return NULL; @@ -318,8 +318,8 @@ static struct wlr_texture *gles2_texture_from_pixels( return NULL; } - struct wlr_gles2_texture *texture = - gles2_texture_create(renderer, width, height); + struct wlr_gles_texture *texture = + gles_texture_create(renderer, width, height); if (texture == NULL) { return NULL; } @@ -335,7 +335,7 @@ static struct wlr_texture *gles2_texture_from_pixels( struct wlr_egl_context prev_ctx; wlr_egl_make_current(renderer->egl, &prev_ctx); - push_gles2_debug(renderer); + push_gles_debug(renderer); glGenTextures(1, &texture->tex); glBindTexture(GL_TEXTURE_2D, texture->tex); @@ -349,27 +349,27 @@ static struct wlr_texture *gles2_texture_from_pixels( glBindTexture(GL_TEXTURE_2D, 0); - pop_gles2_debug(renderer); + pop_gles_debug(renderer); wlr_egl_restore_context(&prev_ctx); return &texture->wlr_texture; } -static struct wlr_texture *gles2_texture_from_dmabuf( - struct wlr_gles2_renderer *renderer, struct wlr_buffer *wlr_buffer, +static struct wlr_texture *gles_texture_from_dmabuf( + struct wlr_gles_renderer *renderer, struct wlr_buffer *wlr_buffer, struct wlr_dmabuf_attributes *attribs) { if (!renderer->procs.glEGLImageTargetTexture2DOES) { return NULL; } - struct wlr_gles2_buffer *buffer = gles2_buffer_get_or_create(renderer, wlr_buffer); + struct wlr_gles_buffer *buffer = gles_buffer_get_or_create(renderer, wlr_buffer); if (!buffer) { return NULL; } - struct wlr_gles2_texture *texture = - gles2_texture_create(renderer, attribs->width, attribs->height); + struct wlr_gles_texture *texture = + gles_texture_create(renderer, attribs->width, attribs->height); if (texture == NULL) { return NULL; } @@ -381,7 +381,7 @@ static struct wlr_texture *gles2_texture_from_dmabuf( struct wlr_egl_context prev_ctx; wlr_egl_make_current(renderer->egl, &prev_ctx); - push_gles2_debug(texture->renderer); + push_gles_debug(texture->renderer); bool invalid; if (!buffer->tex) { @@ -400,7 +400,7 @@ static struct wlr_texture *gles2_texture_from_dmabuf( glBindTexture(texture->target, 0); } - pop_gles2_debug(texture->renderer); + pop_gles_debug(texture->renderer); wlr_egl_restore_context(&prev_ctx); texture->tex = buffer->tex; @@ -408,19 +408,19 @@ static struct wlr_texture *gles2_texture_from_dmabuf( return &texture->wlr_texture; } -struct wlr_texture *gles2_texture_from_buffer(struct wlr_renderer *wlr_renderer, +struct wlr_texture *gles_texture_from_buffer(struct wlr_renderer *wlr_renderer, struct wlr_buffer *buffer) { - struct wlr_gles2_renderer *renderer = gles2_get_renderer(wlr_renderer); + struct wlr_gles_renderer *renderer = gles_get_renderer(wlr_renderer); void *data; uint32_t format; size_t stride; struct wlr_dmabuf_attributes dmabuf; if (wlr_buffer_get_dmabuf(buffer, &dmabuf)) { - return gles2_texture_from_dmabuf(renderer, buffer, &dmabuf); + return gles_texture_from_dmabuf(renderer, buffer, &dmabuf); } else if (wlr_buffer_begin_data_ptr_access(buffer, WLR_BUFFER_DATA_PTR_ACCESS_READ, &data, &format, &stride)) { - struct wlr_texture *tex = gles2_texture_from_pixels(wlr_renderer, + struct wlr_texture *tex = gles_texture_from_pixels(wlr_renderer, format, stride, buffer->width, buffer->height, data); wlr_buffer_end_data_ptr_access(buffer); return tex; @@ -429,10 +429,10 @@ struct wlr_texture *gles2_texture_from_buffer(struct wlr_renderer *wlr_renderer, } } -void wlr_gles2_texture_get_attribs(struct wlr_texture *wlr_texture, - struct wlr_gles2_texture_attribs *attribs) { - struct wlr_gles2_texture *texture = gles2_get_texture(wlr_texture); - *attribs = (struct wlr_gles2_texture_attribs){ +void wlr_gles_texture_get_attribs(struct wlr_texture *wlr_texture, + struct wlr_gles_texture_attribs *attribs) { + struct wlr_gles_texture *texture = gles_get_texture(wlr_texture); + *attribs = (struct wlr_gles_texture_attribs){ .target = texture->target, .tex = texture->tex, .has_alpha = texture->has_alpha, diff --git a/render/meson.build b/render/meson.build index 7c1254078..b4f89a022 100644 --- a/render/meson.build +++ b/render/meson.build @@ -47,7 +47,7 @@ if 'gles2' in renderers or 'auto' in renderers wlr_files += files('egl.c') internal_features += { 'egl': true } endif - subdir('gles2') + subdir('gles') endif if 'vulkan' in renderers or 'auto' in renderers diff --git a/render/wlr_renderer.c b/render/wlr_renderer.c index e65314ccc..2fdb670f0 100644 --- a/render/wlr_renderer.c +++ b/render/wlr_renderer.c @@ -18,7 +18,7 @@ #if WLR_HAS_GLES2_RENDERER #include -#include +#include #endif #if WLR_HAS_VULKAN_RENDERER @@ -236,9 +236,9 @@ static struct wlr_renderer *renderer_autocreate(struct wlr_backend *backend, int log_creation_failure(is_auto, "Cannot create GLES2 renderer: no DRM FD available"); } else { #if WLR_HAS_GLES2_RENDERER - renderer = wlr_gles2_renderer_create_with_drm_fd(drm_fd); + renderer = wlr_gles_renderer_create_with_drm_fd(drm_fd); #else - wlr_log(WLR_ERROR, "Cannot create GLES renderer: disabled at compile-time"); + wlr_log(WLR_ERROR, "Cannot create GLES2 renderer: disabled at compile-time"); #endif if (renderer) { goto out; From 78bffc2df58d032e988e73e5da84dc1f0e92acf6 Mon Sep 17 00:00:00 2001 From: William McKinnon Date: Mon, 27 Oct 2025 00:58:07 -0400 Subject: [PATCH 2/3] added gles3 impl --- docs/env_vars.md | 2 +- include/meson.build | 2 +- include/render/egl.h | 3 +- include/wlr/config.h.in | 7 ++++ include/wlr/render/egl.h | 4 +- include/wlr/render/gles.h | 5 ++- meson.build | 1 + meson.options | 2 +- render/egl.c | 15 ++++--- render/gles/meson.build | 11 +++++- render/gles/pixel_format.c | 8 ++++ render/gles/renderer.c | 43 +++++++++++++++++++-- render/gles/shaders/gles3_common.vert | 12 ++++++ render/gles/shaders/gles3_quad.frag | 13 +++++++ render/gles/shaders/gles3_tex_external.frag | 15 +++++++ render/gles/shaders/gles3_tex_rgba.frag | 13 +++++++ render/gles/shaders/gles3_tex_rgbx.frag | 13 +++++++ render/gles/shaders/meson.build | 5 +++ render/gles/texture.c | 9 +++++ render/meson.build | 10 ++--- render/wlr_renderer.c | 22 ++++++++++- 21 files changed, 190 insertions(+), 25 deletions(-) create mode 100644 render/gles/shaders/gles3_common.vert create mode 100644 render/gles/shaders/gles3_quad.frag create mode 100644 render/gles/shaders/gles3_tex_external.frag create mode 100644 render/gles/shaders/gles3_tex_rgba.frag create mode 100644 render/gles/shaders/gles3_tex_rgbx.frag diff --git a/docs/env_vars.md b/docs/env_vars.md index 59c8f078f..482f6820e 100644 --- a/docs/env_vars.md +++ b/docs/env_vars.md @@ -9,7 +9,7 @@ wlroots reads these environment variables * *WLR_XWAYLAND*: specifies the path to an Xwayland binary to be used (instead of following shell search semantics for "Xwayland") * *WLR_RENDERER*: forces the creation of a specified renderer (available - renderers: gles2, pixman, vulkan) + renderers: gles2, gles3, pixman, vulkan) * *WLR_RENDER_DRM_DEVICE*: specifies the DRM node to use for hardware-accelerated renderers. * *WLR_RENDER_NO_EXPLICIT_SYNC*: set to 1 to disable explicit synchronization diff --git a/include/meson.build b/include/meson.build index b0f600aaf..f49328223 100644 --- a/include/meson.build +++ b/include/meson.build @@ -14,7 +14,7 @@ endif if not features.get('xwayland') exclude_files += 'xwayland.h' endif -if not features.get('gles2-renderer') +if not features.get('gles2-renderer') and not features.get('gles3-renderer') exclude_files += ['render/egl.h', 'render/gles.h'] endif if not features.get('vulkan-renderer') diff --git a/include/render/egl.h b/include/render/egl.h index 103ab57df..c5b1da902 100644 --- a/include/render/egl.h +++ b/include/render/egl.h @@ -47,6 +47,7 @@ struct wlr_egl { bool has_modifiers; struct wlr_drm_format_set dmabuf_texture_formats; struct wlr_drm_format_set dmabuf_render_formats; + enum egl_version version; }; struct wlr_egl_context { @@ -61,7 +62,7 @@ struct wlr_egl_context { * * Will attempt to load all possibly required API functions. */ -struct wlr_egl *wlr_egl_create_with_drm_fd(int drm_fd); +struct wlr_egl *wlr_egl_create_with_drm_fd(int drm_fd, enum egl_version version); /** * Frees all related EGL resources, makes the context not-current and diff --git a/include/wlr/config.h.in b/include/wlr/config.h.in index 198f14334..84f617193 100644 --- a/include/wlr/config.h.in +++ b/include/wlr/config.h.in @@ -30,6 +30,13 @@ * Required for . */ #mesondefine WLR_HAS_GLES2_RENDERER +/** + * Whether the GLES3 renderer is compile-time enabled. Equivalent to the + * pkg-config "have_gles3_renderer" variable. + * + * Required for . + */ +#mesondefine WLR_HAS_GLES3_RENDERER /** * Whether the Vulkan renderer is compile-time enabled. Equivalent to the * pkg-config "have_vulkan_renderer" variable. diff --git a/include/wlr/render/egl.h b/include/wlr/render/egl.h index 9bf1b8019..b63854252 100644 --- a/include/wlr/render/egl.h +++ b/include/wlr/render/egl.h @@ -28,6 +28,8 @@ struct wlr_egl; +enum egl_version { GLES2 = 2, GLES3 = 3 }; + /** * Create a struct wlr_egl with an existing EGL display and context. * @@ -35,7 +37,7 @@ struct wlr_egl; * initialization. */ struct wlr_egl *wlr_egl_create_with_context(EGLDisplay display, - EGLContext context); + EGLContext context, enum egl_version version); /** * Get the EGL display used by the struct wlr_egl. diff --git a/include/wlr/render/gles.h b/include/wlr/render/gles.h index b45bc0861..21074e6d1 100644 --- a/include/wlr/render/gles.h +++ b/include/wlr/render/gles.h @@ -15,6 +15,8 @@ struct wlr_egl; +enum egl_version; + /** * OpenGL ES renderer. * @@ -28,7 +30,8 @@ struct wlr_egl; * render pass can't be used before the nested render pass is submitted. */ -struct wlr_renderer *wlr_gles_renderer_create_with_drm_fd(int drm_fd); +struct wlr_renderer *wlr_gles_renderer_create_with_drm_fd(int drm_fd, + enum egl_version version); struct wlr_renderer *wlr_gles_renderer_create(struct wlr_egl *egl); struct wlr_egl *wlr_gles_renderer_get_egl(struct wlr_renderer *renderer); diff --git a/meson.build b/meson.build index 4b24e5046..e229034b6 100644 --- a/meson.build +++ b/meson.build @@ -72,6 +72,7 @@ features = { 'libinput-backend': false, 'xwayland': false, 'gles2-renderer': false, + 'gles3-renderer': false, 'vulkan-renderer': false, 'gbm-allocator': false, 'udmabuf-allocator': false, diff --git a/meson.options b/meson.options index 5863764aa..38f3364a8 100644 --- a/meson.options +++ b/meson.options @@ -2,7 +2,7 @@ option('xcb-errors', type: 'feature', value: 'auto', description: 'Use xcb-error option('xwayland', type: 'feature', value: 'auto', yield: true, description: 'Enable support for X11 applications') option('examples', type: 'boolean', value: true, description: 'Build example applications') option('icon_directory', description: 'Location used to look for cursors (default: ${datadir}/icons)', type: 'string', value: '') -option('renderers', type: 'array', choices: ['auto', 'gles2', 'vulkan'], value: ['auto'], description: 'Select built-in renderers') +option('renderers', type: 'array', choices: ['auto', 'gles2', 'gles3', 'vulkan'], value: ['auto'], description: 'Select built-in renderers') option('backends', type: 'array', choices: ['auto', 'drm', 'libinput', 'x11'], value: ['auto'], description: 'Select built-in backends') option('allocators', type: 'array', choices: ['auto', 'gbm', 'udmabuf'], value: ['auto'], description: 'Select built-in allocators') diff --git a/render/egl.c b/render/egl.c index 6f3e9c8ca..ec64e2f46 100644 --- a/render/egl.c +++ b/render/egl.c @@ -10,6 +10,7 @@ #include #include #include "render/egl.h" +#include "render/gles.h" #include "util/env.h" static enum wlr_log_importance egl_log_importance_to_wlr(EGLint type) { @@ -191,7 +192,7 @@ static void init_dmabuf_formats(struct wlr_egl *egl) { } } -static struct wlr_egl *egl_create(void) { +static struct wlr_egl *egl_create(enum egl_version version) { const char *client_exts_str = eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS); if (client_exts_str == NULL) { if (eglGetError() == EGL_BAD_DISPLAY) { @@ -257,6 +258,8 @@ static struct wlr_egl *egl_create(void) { return NULL; } + egl->version = version; + return egl; } @@ -411,7 +414,7 @@ static bool egl_init(struct wlr_egl *egl, EGLenum platform, size_t atti = 0; EGLint attribs[7]; attribs[atti++] = EGL_CONTEXT_CLIENT_VERSION; - attribs[atti++] = 2; + attribs[atti++] = egl->version; // Request a high priority context if possible // TODO: only do this if we're running as the DRM master @@ -555,10 +558,10 @@ static int open_render_node(int drm_fd) { return render_fd; } -struct wlr_egl *wlr_egl_create_with_drm_fd(int drm_fd) { +struct wlr_egl *wlr_egl_create_with_drm_fd(int drm_fd, enum egl_version version) { bool allow_software = drm_fd < 0; - struct wlr_egl *egl = egl_create(); + struct wlr_egl *egl = egl_create(version); if (egl == NULL) { wlr_log(WLR_ERROR, "Failed to create EGL context"); return NULL; @@ -615,7 +618,7 @@ error: } struct wlr_egl *wlr_egl_create_with_context(EGLDisplay display, - EGLContext context) { + EGLContext context, enum egl_version version) { EGLint client_type; if (!eglQueryContext(display, context, EGL_CONTEXT_CLIENT_TYPE, &client_type) || client_type != EGL_OPENGL_ES_API) { @@ -630,7 +633,7 @@ struct wlr_egl *wlr_egl_create_with_context(EGLDisplay display, return NULL; } - struct wlr_egl *egl = egl_create(); + struct wlr_egl *egl = egl_create(version); if (egl == NULL) { return NULL; } diff --git a/render/gles/meson.build b/render/gles/meson.build index d4c53c894..7911f4ab0 100644 --- a/render/gles/meson.build +++ b/render/gles/meson.build @@ -1,4 +1,5 @@ glesv2 = dependency('glesv2', required: 'gles2' in renderers) +glesv3 = dependency('glesv2', required: 'gles3' in renderers) if not ((glesv2.found() or glesv3.found()) and internal_features['egl']) subdir_done() @@ -6,8 +7,14 @@ endif glslang = find_program('glslang', 'glslangValidator', native: true, required: false, disabler: true) -features += { 'gles2-renderer': true } -wlr_deps += glesv2 +if glesv2.found() + features += { 'gles2-renderer': true } + wlr_deps += glesv2 +endif +if glesv3.found() + features += { 'gles3-renderer': true } + wlr_deps += glesv3 +endif wlr_files += files( 'pass.c', diff --git a/render/gles/pixel_format.c b/render/gles/pixel_format.c index 220568014..28f23c48b 100644 --- a/render/gles/pixel_format.c +++ b/render/gles/pixel_format.c @@ -1,6 +1,14 @@ #include +#include + +#if WLR_HAS_GLES2_RENDERER #include #include +#else +#include +#include +#endif + #include "render/gles.h" #include "render/pixel_format.h" diff --git a/render/gles/renderer.c b/render/gles/renderer.c index a30293303..af2113e7d 100644 --- a/render/gles/renderer.c +++ b/render/gles/renderer.c @@ -9,6 +9,7 @@ #include #include #include +#include #include #include #include @@ -20,11 +21,21 @@ #include "render/pixel_format.h" #include "util/time.h" +#if WLR_HAS_GLES2_RENDERER #include "gles2_common_vert_src.h" #include "gles2_quad_frag_src.h" #include "gles2_tex_rgba_frag_src.h" #include "gles2_tex_rgbx_frag_src.h" #include "gles2_tex_external_frag_src.h" +#endif + +#if WLR_HAS_GLES3_RENDERER +#include "gles3_common_vert_src.h" +#include "gles3_quad_frag_src.h" +#include "gles3_tex_rgba_frag_src.h" +#include "gles3_tex_rgbx_frag_src.h" +#include "gles3_tex_external_frag_src.h" +#endif static const struct wlr_renderer_impl renderer_impl; static const struct wlr_render_timer_impl render_timer_impl; @@ -633,9 +644,33 @@ struct wlr_renderer *wlr_gles_renderer_create(struct wlr_egl *egl) { push_gles_debug(renderer); + const char* common_vert_src; + const char* quad_frag_src; + const char* tex_rgba_frag_src; + const char* tex_rgbx_frag_src; + const char* tex_external_frag_src; + + if (egl->version == GLES2) { +#if WLR_HAS_GLES2_RENDERER + common_vert_src = gles2_common_vert_src; + quad_frag_src = gles2_quad_frag_src; + tex_rgba_frag_src = gles2_tex_rgba_frag_src; + tex_rgbx_frag_src = gles2_tex_rgbx_frag_src; + tex_external_frag_src = gles2_tex_external_frag_src; +#endif + } else { +#if WLR_HAS_GLES3_RENDERER + common_vert_src = gles3_common_vert_src; + quad_frag_src = gles3_quad_frag_src; + tex_rgba_frag_src = gles3_tex_rgba_frag_src; + tex_rgbx_frag_src = gles3_tex_rgbx_frag_src; + tex_external_frag_src = gles3_tex_external_frag_src; +#endif + } + GLuint prog; renderer->shaders.quad.program = prog = - link_program(renderer, gles2_common_vert_src, gles2_quad_frag_src); + link_program(renderer, common_vert_src, quad_frag_src); if (!renderer->shaders.quad.program) { goto error; } @@ -644,7 +679,7 @@ struct wlr_renderer *wlr_gles_renderer_create(struct wlr_egl *egl) { renderer->shaders.quad.pos_attrib = glGetAttribLocation(prog, "pos"); renderer->shaders.tex_rgba.program = prog = - link_program(renderer, gles2_common_vert_src, gles2_tex_rgba_frag_src); + link_program(renderer, common_vert_src, tex_rgba_frag_src); if (!renderer->shaders.tex_rgba.program) { goto error; } @@ -655,7 +690,7 @@ struct wlr_renderer *wlr_gles_renderer_create(struct wlr_egl *egl) { renderer->shaders.tex_rgba.pos_attrib = glGetAttribLocation(prog, "pos"); renderer->shaders.tex_rgbx.program = prog = - link_program(renderer, gles2_common_vert_src, gles2_tex_rgbx_frag_src); + link_program(renderer, common_vert_src, tex_rgbx_frag_src); if (!renderer->shaders.tex_rgbx.program) { goto error; } @@ -667,7 +702,7 @@ struct wlr_renderer *wlr_gles_renderer_create(struct wlr_egl *egl) { if (renderer->exts.OES_egl_image_external) { renderer->shaders.tex_ext.program = prog = - link_program(renderer, gles2_common_vert_src, gles2_tex_external_frag_src); + link_program(renderer, common_vert_src, tex_external_frag_src); if (!renderer->shaders.tex_ext.program) { goto error; } diff --git a/render/gles/shaders/gles3_common.vert b/render/gles/shaders/gles3_common.vert new file mode 100644 index 000000000..5022372a0 --- /dev/null +++ b/render/gles/shaders/gles3_common.vert @@ -0,0 +1,12 @@ +#version 300 es + +uniform mat3 proj; +uniform mat3 tex_proj; +in vec2 pos; +out vec2 v_texcoord; + +void main() { + vec3 pos3 = vec3(pos, 1.0); + gl_Position = vec4(pos3 * proj, 1.0); + v_texcoord = (pos3 * tex_proj).xy; +} diff --git a/render/gles/shaders/gles3_quad.frag b/render/gles/shaders/gles3_quad.frag new file mode 100644 index 000000000..660e2e04f --- /dev/null +++ b/render/gles/shaders/gles3_quad.frag @@ -0,0 +1,13 @@ +#version 300 es + +precision highp float; + +in vec4 v_color; +in vec2 v_texcoord; +uniform vec4 color; + +out vec4 frag_color; + +void main() { + frag_color = color; +} diff --git a/render/gles/shaders/gles3_tex_external.frag b/render/gles/shaders/gles3_tex_external.frag new file mode 100644 index 000000000..f471319d9 --- /dev/null +++ b/render/gles/shaders/gles3_tex_external.frag @@ -0,0 +1,15 @@ +#version 300 es + +#extension GL_OES_EGL_image_external_essl3 : require + +precision highp float; + +in vec2 v_texcoord; +uniform samplerExternalOES texture0; +uniform float alpha; + +out vec4 frag_color; + +void main() { + frag_color = texture(texture0, v_texcoord) * alpha; +} diff --git a/render/gles/shaders/gles3_tex_rgba.frag b/render/gles/shaders/gles3_tex_rgba.frag new file mode 100644 index 000000000..51b2ae037 --- /dev/null +++ b/render/gles/shaders/gles3_tex_rgba.frag @@ -0,0 +1,13 @@ +#version 300 es + +precision highp float; + +in vec2 v_texcoord; +uniform sampler2D tex; +uniform float alpha; + +out vec4 frag_color; + +void main() { + frag_color = texture(tex, v_texcoord) * alpha; +} diff --git a/render/gles/shaders/gles3_tex_rgbx.frag b/render/gles/shaders/gles3_tex_rgbx.frag new file mode 100644 index 000000000..c0dc08a8c --- /dev/null +++ b/render/gles/shaders/gles3_tex_rgbx.frag @@ -0,0 +1,13 @@ +#version 300 es + +precision highp float; + +in vec2 v_texcoord; +uniform sampler2D tex; +uniform float alpha; + +out vec4 frag_color; + +void main() { + frag_color = vec4(texture(tex, v_texcoord).rgb, 1.0) * alpha; +} diff --git a/render/gles/shaders/meson.build b/render/gles/shaders/meson.build index cba9b6034..de1be55c5 100644 --- a/render/gles/shaders/meson.build +++ b/render/gles/shaders/meson.build @@ -6,6 +6,11 @@ shaders = [ 'gles2_tex_rgba.frag', 'gles2_tex_rgbx.frag', 'gles2_tex_external.frag', + 'gles3_common.vert', + 'gles3_quad.frag', + 'gles3_tex_rgba.frag', + 'gles3_tex_rgbx.frag', + 'gles3_tex_external.frag', ] foreach name : shaders diff --git a/render/gles/texture.c b/render/gles/texture.c index 97632c7db..d4a1e282b 100644 --- a/render/gles/texture.c +++ b/render/gles/texture.c @@ -1,7 +1,16 @@ #include #include + +#include + +#if WLR_HAS_GLES2_RENDERER #include #include +#else +#include +#include +#endif + #include #include #include diff --git a/render/meson.build b/render/meson.build index b4f89a022..5f291c7e4 100644 --- a/render/meson.build +++ b/render/meson.build @@ -1,6 +1,6 @@ renderers = get_option('renderers') if 'auto' in renderers and get_option('auto_features').enabled() - renderers = ['gles2', 'vulkan'] + renderers = ['gles2', 'gles3', 'vulkan'] elif 'auto' in renderers and get_option('auto_features').disabled() renderers = [] endif @@ -25,8 +25,8 @@ endif internal_config.set10('HAVE_EVENTFD', cc.has_header('sys/eventfd.h')) -if 'gles2' in renderers or 'auto' in renderers - egl = dependency('egl', required: 'gles2' in renderers) +if 'gles2' in renderers or 'gles3' in renderers or 'auto' in renderers + egl = dependency('egl', required: 'gles2' in renderers or 'gles3' in renderers) if egl.found() eglext_version = cc.get_define( 'EGL_EGLEXT_VERSION', @@ -36,12 +36,12 @@ if 'gles2' in renderers or 'auto' in renderers if eglext_version < 20210604 egl = dependency( '', - required: 'gles2' in renderers, + required: 'gles2' in renderers or 'gles3' in renderers, not_found_message: 'EGL headers too old', ) endif endif - gbm = dependency('gbm', required: 'gles2' in renderers) + gbm = dependency('gbm', required: 'gles2' in renderers or 'gles3' in renderers) if egl.found() and gbm.found() wlr_deps += [egl, gbm] wlr_files += files('egl.c') diff --git a/render/wlr_renderer.c b/render/wlr_renderer.c index 2fdb670f0..79900b9b7 100644 --- a/render/wlr_renderer.c +++ b/render/wlr_renderer.c @@ -16,7 +16,7 @@ #include -#if WLR_HAS_GLES2_RENDERER +#if WLR_HAS_GLES2_RENDERER || WLR_HAS_GLES3_RENDERER #include #include #endif @@ -220,6 +220,7 @@ static struct wlr_renderer *renderer_autocreate(struct wlr_backend *backend, int const char *renderer_options[] = { "auto", "gles2", + "gles3", "vulkan", "pixman", NULL @@ -236,7 +237,7 @@ static struct wlr_renderer *renderer_autocreate(struct wlr_backend *backend, int log_creation_failure(is_auto, "Cannot create GLES2 renderer: no DRM FD available"); } else { #if WLR_HAS_GLES2_RENDERER - renderer = wlr_gles_renderer_create_with_drm_fd(drm_fd); + renderer = wlr_gles_renderer_create_with_drm_fd(drm_fd, GLES2); #else wlr_log(WLR_ERROR, "Cannot create GLES2 renderer: disabled at compile-time"); #endif @@ -248,6 +249,23 @@ static struct wlr_renderer *renderer_autocreate(struct wlr_backend *backend, int } } + if ((is_auto && WLR_HAS_GLES3_RENDERER) || strcmp(renderer_name, "gles3") == 0) { + if (!open_preferred_drm_fd(backend, &drm_fd, &own_drm_fd)) { + log_creation_failure(is_auto, "Cannot create GLES3 renderer: no DRM FD available"); + } else { +#if WLR_HAS_GLES3_RENDERER + renderer = wlr_gles_renderer_create_with_drm_fd(drm_fd, GLES3); +#else + wlr_log(WLR_ERROR, "Cannot create GLES3 renderer: disabled at compile-time"); +#endif + if (renderer) { + goto out; + } else { + log_creation_failure(is_auto, "Failed to create a GLES3 renderer"); + } + } + } + if ((is_auto && WLR_HAS_VULKAN_RENDERER) || strcmp(renderer_name, "vulkan") == 0) { if (!open_preferred_drm_fd(backend, &drm_fd, &own_drm_fd)) { log_creation_failure(is_auto, "Cannot create Vulkan renderer: no DRM FD available"); From 4c37b643e2637563f52bc0aa3c75b9919ce0689c Mon Sep 17 00:00:00 2001 From: William McKinnon Date: Mon, 27 Oct 2025 01:19:50 -0400 Subject: [PATCH 3/3] remove uneeded import --- render/egl.c | 1 - 1 file changed, 1 deletion(-) diff --git a/render/egl.c b/render/egl.c index ec64e2f46..626ba6664 100644 --- a/render/egl.c +++ b/render/egl.c @@ -10,7 +10,6 @@ #include #include #include "render/egl.h" -#include "render/gles.h" #include "util/env.h" static enum wlr_log_importance egl_log_importance_to_wlr(EGLint type) {