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;