mirror of
https://gitlab.freedesktop.org/wlroots/wlroots.git
synced 2026-04-13 08:22:16 -04:00
renamed gles2 components to gles
This commit is contained in:
William McKinnon
parent
879243e370
commit
00c96e3ac0
19 changed files with 304 additions and 303 deletions
|
|
@ -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'
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
#ifndef RENDER_GLES2_H
|
||||
#define RENDER_GLES2_H
|
||||
#ifndef RENDER_GLES_H
|
||||
#define RENDER_GLES_H
|
||||
|
||||
#include <GLES2/gl2.h>
|
||||
#include <GLES2/gl2ext.h>
|
||||
|
|
@ -7,7 +7,7 @@
|
|||
#include <stdint.h>
|
||||
#include <time.h>
|
||||
#include <wlr/render/egl.h>
|
||||
#include <wlr/render/gles2.h>
|
||||
#include <wlr/render/gles.h>
|
||||
#include <wlr/render/interface.h>
|
||||
#include <wlr/render/wlr_renderer.h>
|
||||
#include <wlr/render/wlr_texture.h>
|
||||
|
|
@ -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
|
||||
|
|
@ -27,7 +27,7 @@
|
|||
* Whether the GLES2 renderer is compile-time enabled. Equivalent to the
|
||||
* pkg-config "have_gles2_renderer" variable.
|
||||
*
|
||||
* Required for <wlr/render/gles2.h>.
|
||||
* Required for <wlr/render/gles.h>.
|
||||
*/
|
||||
#mesondefine WLR_HAS_GLES2_RENDERER
|
||||
/**
|
||||
|
|
|
|||
51
include/wlr/render/gles.h
Normal file
51
include/wlr/render/gles.h
Normal file
|
|
@ -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 <GLES2/gl2.h>
|
||||
|
||||
#include <wlr/render/wlr_renderer.h>
|
||||
|
||||
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
|
||||
|
|
@ -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 <GLES2/gl2.h>
|
||||
|
||||
#include <wlr/render/wlr_renderer.h>
|
||||
|
||||
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
|
||||
|
|
@ -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
|
||||
|
||||
|
|
@ -6,26 +6,26 @@
|
|||
#include <wlr/render/drm_syncobj.h>
|
||||
#include <wlr/util/transform.h>
|
||||
#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;
|
||||
}
|
||||
|
|
@ -1,14 +1,14 @@
|
|||
#include <drm_fourcc.h>
|
||||
#include <GLES2/gl2.h>
|
||||
#include <GLES2/gl2ext.h>
|
||||
#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);
|
||||
|
|
@ -16,54 +16,54 @@
|
|||
#include <wlr/util/log.h>
|
||||
#include <xf86drm.h>
|
||||
#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);
|
||||
}
|
||||
|
|
@ -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@'],
|
||||
|
|
@ -11,25 +11,25 @@
|
|||
#include <wlr/render/wlr_texture.h>
|
||||
#include <wlr/util/log.h>
|
||||
#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,
|
||||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@
|
|||
|
||||
#if WLR_HAS_GLES2_RENDERER
|
||||
#include <wlr/render/egl.h>
|
||||
#include <wlr/render/gles2.h>
|
||||
#include <wlr/render/gles.h>
|
||||
#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;
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue