mirrors/wlroots
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/wlroots/wlroots.git synced 2026-04-17 06:46:39 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

render: unify render pass accessors

Browse source 
Introduce helper functions to retrieve backend-specific render passes
from struct wlr_render_pass and replace ad-hoc internal accessors.
This commit is contained in:
YaoBing Xiao 2026-03-23 21:04:32 +08:00
parent d8d61ffd49
commit fce738d78d
11 changed files with 135 additions and 99 deletions
Download patch file Download diff file Expand all files Collapse all files

14
include/render/gles2.h
View file

@ -139,7 +139,7 @@ void get_gles2_shm_formats(const struct wlr_gles2_renderer *renderer,
GLuint gles2_buffer_get_fbo(struct wlr_gles2_buffer *buffer); GLuint gles2_buffer_get_fbo(struct wlr_gles2_buffer *buffer);
struct wlr_gles2_renderer *gles2_get_renderer( struct wlr_gles2_renderer *wlr_gles2_renderer_from_renderer(
struct wlr_renderer *wlr_renderer); struct wlr_renderer *wlr_renderer);
struct wlr_gles2_render_timer *gles2_get_render_timer( struct wlr_gles2_render_timer *gles2_get_render_timer(
struct wlr_render_timer *timer); struct wlr_render_timer *timer);
@ -152,10 +152,10 @@ struct wlr_texture *gles2_texture_from_buffer(struct wlr_renderer *wlr_renderer,
struct wlr_buffer *buffer); struct wlr_buffer *buffer);
void gles2_texture_destroy(struct wlr_gles2_texture *texture); void gles2_texture_destroy(struct wlr_gles2_texture *texture);
void push_gles2_debug_(struct wlr_gles2_renderer *renderer, void wlr_gles2_push_debug_(struct wlr_gles2_renderer *renderer,
const char *file, const char *func); const char *file, const char *func);
#define push_gles2_debug(renderer) push_gles2_debug_(renderer, _WLR_FILENAME, __func__) #define wlr_gles2_push_debug(renderer) wlr_gles2_push_debug_(renderer, _WLR_FILENAME, __func__)
void pop_gles2_debug(struct wlr_gles2_renderer *renderer); void wlr_gles2_pop_debug(struct wlr_gles2_renderer *renderer);
struct wlr_gles2_render_pass *begin_gles2_buffer_pass(struct wlr_gles2_buffer *buffer, 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_egl_context *prev_ctx, struct wlr_gles2_render_timer *timer,
@ -198,7 +198,11 @@ bool wlr_render_submit_pass_is_gles2(const struct wlr_render_submit_pass *submit
struct wlr_gles2_render_submit_pass *wlr_gles2_render_submit_pass_from_pass( struct wlr_gles2_render_submit_pass *wlr_gles2_render_submit_pass_from_pass(
struct wlr_render_submit_pass *submit_pass); struct wlr_render_submit_pass *submit_pass);
GLuint gles2_link_program(struct wlr_gles2_renderer *renderer, GLuint wlr_gles2_link_program(struct wlr_gles2_renderer *renderer,
const GLchar *vert_src, const GLchar *frag_src); const GLchar *vert_src, const GLchar *frag_src);
struct wlr_gles2_render_pass *wlr_gles2_render_pass_from_render_pass(
struct wlr_render_pass *wlr_pass);
void wlr_gles_set_proj_matrix(GLint loc, float proj[9], const struct wlr_box *box);
#endif #endif

4
include/render/pixman.h
View file

@ -51,6 +51,8 @@ struct wlr_pixman_render_pass {
struct wlr_pixman_buffer *buffer; struct wlr_pixman_buffer *buffer;
}; };
struct wlr_pixman_renderer *wlr_pixman_renderer_from_renderer(
struct wlr_renderer *wlr_renderer);
pixman_format_code_t get_pixman_format_from_drm(uint32_t fmt); pixman_format_code_t get_pixman_format_from_drm(uint32_t fmt);
uint32_t get_drm_format_from_pixman(pixman_format_code_t fmt); uint32_t get_drm_format_from_pixman(pixman_format_code_t fmt);
const uint32_t *get_pixman_drm_formats(size_t *len); const uint32_t *get_pixman_drm_formats(size_t *len);
@ -84,5 +86,7 @@ struct wlr_pixman_render_submit_pass {
bool wlr_render_submit_pass_is_pixman(const struct wlr_render_submit_pass *submit_pass); bool wlr_render_submit_pass_is_pixman(const struct wlr_render_submit_pass *submit_pass);
struct wlr_pixman_render_submit_pass *wlr_pixman_render_submit_pass_from_pass( struct wlr_pixman_render_submit_pass *wlr_pixman_render_submit_pass_from_pass(
struct wlr_render_submit_pass *submit_pass); struct wlr_render_submit_pass *submit_pass);
struct wlr_pixman_render_pass *wlr_pixman_render_pass_from_render_pass(
struct wlr_render_pass *wlr_pass);
#endif #endif

8
include/render/vulkan.h
View file

@ -369,7 +369,13 @@ struct wlr_vk_texture_view {
VkImageView image_view; VkImageView image_view;
struct wlr_vk_descriptor_pool *ds_pool; struct wlr_vk_descriptor_pool *ds_pool;
}; };
struct wlr_vk_renderer *wlr_vk_renderer_from_renderer(
struct wlr_renderer *wlr_renderer);
bool wlr_vk_create_shader_module(VkDevice dev, const uint32_t *code,
size_t code_size, const char *name, VkShaderModule *out);
float wlr_color_to_linear_premult(float non_linear, float alpha);
void wlr_encode_proj_matrix(const float mat3[9], float mat4[4][4]);
void wlr_encode_color_matrix(const float mat3[9], float mat4[4][4]);
struct wlr_vk_pipeline *setup_get_or_create_pipeline( struct wlr_vk_pipeline *setup_get_or_create_pipeline(
struct wlr_vk_render_format_setup *setup, struct wlr_vk_render_format_setup *setup,
const struct wlr_vk_pipeline_key *key, const struct wlr_vk_pipeline_key *key,

2
include/wlr/render/interface.h
View file

@ -165,5 +165,7 @@ struct wlr_render_submit_pass *wlr_pixman_render_submit_pass_create(void);
struct wlr_render_submit_pass *wlr_gles2_render_submit_pass_create(void); struct wlr_render_submit_pass *wlr_gles2_render_submit_pass_create(void);
struct wlr_render_submit_pass *wlr_vk_render_submit_pass_create( struct wlr_render_submit_pass *wlr_vk_render_submit_pass_create(
struct wlr_renderer *wlr_renderer); struct wlr_renderer *wlr_renderer);
struct wlr_vk_render_pass *wlr_vk_render_pass_from_render_pass(
struct wlr_render_pass *wlr_pass);
#endif #endif

65
render/gles2/pass.c
View file

@ -19,19 +19,20 @@
static const struct wlr_render_pass_impl render_pass_impl; 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) { struct wlr_gles2_render_pass *wlr_gles2_render_pass_from_render_pass(
struct wlr_render_pass *wlr_pass) {
assert(wlr_pass->impl == &render_pass_impl); assert(wlr_pass->impl == &render_pass_impl);
struct wlr_gles2_render_pass *pass = wl_container_of(wlr_pass, pass, base); struct wlr_gles2_render_pass *pass = wl_container_of(wlr_pass, pass, base);
return pass; return pass;
} }
static bool render_pass_submit(struct wlr_render_pass *wlr_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_render_pass *pass = wlr_gles2_render_pass_from_render_pass(wlr_pass);
struct wlr_gles2_renderer *renderer = pass->buffer->renderer; struct wlr_gles2_renderer *renderer = pass->buffer->renderer;
struct wlr_gles2_render_timer *timer = pass->timer; struct wlr_gles2_render_timer *timer = pass->timer;
bool ok = false; bool ok = false;
push_gles2_debug(renderer); wlr_gles2_push_debug(renderer);
if (timer) { if (timer) {
// clear disjoint flag // clear disjoint flag
@ -71,7 +72,7 @@ static bool render_pass_submit(struct wlr_render_pass *wlr_pass) {
out: out:
glBindFramebuffer(GL_FRAMEBUFFER, 0); glBindFramebuffer(GL_FRAMEBUFFER, 0);
pop_gles2_debug(renderer); wlr_gles2_pop_debug(renderer);
wlr_egl_restore_context(&pass->prev_ctx); wlr_egl_restore_context(&pass->prev_ctx);
wlr_drm_syncobj_timeline_unref(pass->signal_timeline); wlr_drm_syncobj_timeline_unref(pass->signal_timeline);
@ -130,7 +131,7 @@ static void render(const struct wlr_box *box, const pixman_region32_t *clip, GLi
pixman_region32_fini(&region); pixman_region32_fini(&region);
} }
static void set_proj_matrix(GLint loc, float proj[9], const struct wlr_box *box) { void wlr_gles_set_proj_matrix(GLint loc, float proj[9], const struct wlr_box *box) {
float gl_matrix[9]; float gl_matrix[9];
wlr_matrix_identity(gl_matrix); wlr_matrix_identity(gl_matrix);
wlr_matrix_translate(gl_matrix, box->x, box->y); wlr_matrix_translate(gl_matrix, box->x, box->y);
@ -172,7 +173,7 @@ static void setup_blending(enum wlr_render_blend_mode mode) {
static void render_pass_add_texture(struct wlr_render_pass *wlr_pass, static void render_pass_add_texture(struct wlr_render_pass *wlr_pass,
const struct wlr_render_texture_options *options) { const struct wlr_render_texture_options *options) {
struct wlr_gles2_render_pass *pass = get_render_pass(wlr_pass); struct wlr_gles2_render_pass *pass = wlr_gles2_render_pass_from_render_pass(wlr_pass);
struct wlr_gles2_renderer *renderer = pass->buffer->renderer; struct wlr_gles2_renderer *renderer = pass->buffer->renderer;
struct wlr_gles2_texture *texture = gles2_get_texture(options->texture); struct wlr_gles2_texture *texture = gles2_get_texture(options->texture);
struct wlr_gles2_render_texture_pass *texture_pass = struct wlr_gles2_render_texture_pass *texture_pass =
@ -208,7 +209,7 @@ static void render_pass_add_texture(struct wlr_render_pass *wlr_pass,
src_fbox.width /= options->texture->width; src_fbox.width /= options->texture->width;
src_fbox.height /= options->texture->height; src_fbox.height /= options->texture->height;
push_gles2_debug(renderer); wlr_gles2_push_debug(renderer);
if (options->wait_timeline != NULL) { if (options->wait_timeline != NULL) {
int sync_file_fd = int sync_file_fd =
@ -251,18 +252,18 @@ static void render_pass_add_texture(struct wlr_render_pass *wlr_pass,
glUniform1i(shader->tex, 0); glUniform1i(shader->tex, 0);
glUniform1f(shader->alpha, alpha); glUniform1f(shader->alpha, alpha);
set_proj_matrix(shader->proj, pass->projection_matrix, &dst_box); wlr_gles_set_proj_matrix(shader->proj, pass->projection_matrix, &dst_box);
set_tex_matrix(shader->tex_proj, options->transform, &src_fbox); set_tex_matrix(shader->tex_proj, options->transform, &src_fbox);
render(&dst_box, options->clip, shader->pos_attrib); render(&dst_box, options->clip, shader->pos_attrib);
glBindTexture(texture->target, 0); glBindTexture(texture->target, 0);
pop_gles2_debug(renderer); wlr_gles2_pop_debug(renderer);
} }
static void render_pass_add_rect(struct wlr_render_pass *wlr_pass, static void render_pass_add_rect(struct wlr_render_pass *wlr_pass,
const struct wlr_render_rect_options *options) { const struct wlr_render_rect_options *options) {
struct wlr_gles2_render_pass *pass = get_render_pass(wlr_pass); struct wlr_gles2_render_pass *pass = wlr_gles2_render_pass_from_render_pass(wlr_pass);
struct wlr_gles2_renderer *renderer = pass->buffer->renderer; struct wlr_gles2_renderer *renderer = pass->buffer->renderer;
struct wlr_gles2_render_rect_pass *rect_pass = struct wlr_gles2_render_rect_pass *rect_pass =
wlr_gles2_render_rect_pass_from_pass(renderer->wlr_renderer.rect_pass); wlr_gles2_render_rect_pass_from_pass(renderer->wlr_renderer.rect_pass);
@ -272,7 +273,7 @@ static void render_pass_add_rect(struct wlr_render_pass *wlr_pass,
struct wlr_buffer *wlr_buffer = pass->buffer->buffer; struct wlr_buffer *wlr_buffer = pass->buffer->buffer;
wlr_render_rect_options_get_box(options, wlr_buffer, &box); wlr_render_rect_options_get_box(options, wlr_buffer, &box);
push_gles2_debug(renderer); wlr_gles2_push_debug(renderer);
enum wlr_render_blend_mode blend_mode = enum wlr_render_blend_mode blend_mode =
color->a == 1.0 ? WLR_RENDER_BLEND_MODE_NONE : options->blend_mode; color->a == 1.0 ? WLR_RENDER_BLEND_MODE_NONE : options->blend_mode;
if (blend_mode == WLR_RENDER_BLEND_MODE_NONE && if (blend_mode == WLR_RENDER_BLEND_MODE_NONE &&
@ -285,12 +286,12 @@ static void render_pass_add_rect(struct wlr_render_pass *wlr_pass,
} else { } else {
setup_blending(blend_mode); setup_blending(blend_mode);
glUseProgram(rect_pass->shader.program); glUseProgram(rect_pass->shader.program);
set_proj_matrix(rect_pass->shader.proj, pass->projection_matrix, &box); wlr_gles_set_proj_matrix(rect_pass->shader.proj, pass->projection_matrix, &box);
glUniform4f(rect_pass->shader.color, color->r, color->g, color->b, color->a); glUniform4f(rect_pass->shader.color, color->r, color->g, color->b, color->a);
render(&box, options->clip, rect_pass->shader.pos_attrib); render(&box, options->clip, rect_pass->shader.pos_attrib);
} }
pop_gles2_debug(renderer); wlr_gles2_pop_debug(renderer);
} }
static void render_pass_destory(struct wlr_render_pass *wlr_pass) { static void render_pass_destory(struct wlr_render_pass *wlr_pass) {
@ -298,7 +299,7 @@ static void render_pass_destory(struct wlr_render_pass *wlr_pass) {
} }
static struct wlr_renderer *render_pass_get_renderer(struct wlr_render_pass *wlr_pass) { static struct wlr_renderer *render_pass_get_renderer(struct wlr_render_pass *wlr_pass) {
struct wlr_gles2_render_pass *pass = get_render_pass(wlr_pass); struct wlr_gles2_render_pass *pass = wlr_gles2_render_pass_from_render_pass(wlr_pass);
struct wlr_gles2_renderer *renderer = pass->buffer->renderer; struct wlr_gles2_renderer *renderer = pass->buffer->renderer;
return &renderer->wlr_renderer; return &renderer->wlr_renderer;
@ -360,13 +361,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, matrix_projection(pass->projection_matrix, wlr_buffer->width, wlr_buffer->height,
WL_OUTPUT_TRANSFORM_FLIPPED_180); WL_OUTPUT_TRANSFORM_FLIPPED_180);
push_gles2_debug(renderer); wlr_gles2_push_debug(renderer);
glBindFramebuffer(GL_FRAMEBUFFER, fbo); glBindFramebuffer(GL_FRAMEBUFFER, fbo);
glViewport(0, 0, wlr_buffer->width, wlr_buffer->height); glViewport(0, 0, wlr_buffer->width, wlr_buffer->height);
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_SCISSOR_TEST); glDisable(GL_SCISSOR_TEST);
pop_gles2_debug(renderer); wlr_gles2_pop_debug(renderer);
return pass; return pass;
} }
@ -374,9 +375,9 @@ struct wlr_gles2_render_pass *begin_gles2_buffer_pass(struct wlr_gles2_buffer *b
static void render_rect_pass_destroy(struct wlr_render_rect_pass *pass) { static void render_rect_pass_destroy(struct wlr_render_rect_pass *pass) {
struct wlr_gles2_render_rect_pass *gles2_pass = struct wlr_gles2_render_rect_pass *gles2_pass =
wlr_gles2_render_rect_pass_from_pass(pass); wlr_gles2_render_rect_pass_from_pass(pass);
push_gles2_debug(gles2_pass->renderer); wlr_gles2_push_debug(gles2_pass->renderer);
glDeleteProgram(gles2_pass->shader.program); glDeleteProgram(gles2_pass->shader.program);
pop_gles2_debug(gles2_pass->renderer); wlr_gles2_pop_debug(gles2_pass->renderer);
free(gles2_pass); free(gles2_pass);
} }
@ -393,17 +394,17 @@ struct wlr_render_rect_pass *wlr_gles2_render_rect_pass_create(
return NULL; return NULL;
} }
struct wlr_gles2_renderer *renderer = gles2_get_renderer(wlr_renderer); struct wlr_gles2_renderer *renderer = wlr_gles2_renderer_from_renderer(wlr_renderer);
if (!wlr_egl_make_current(renderer->egl, NULL)) { if (!wlr_egl_make_current(renderer->egl, NULL)) {
free(pass); free(pass);
return NULL; return NULL;
} }
wlr_render_rect_pass_init(&pass->base, &render_rect_pass_impl); wlr_render_rect_pass_init(&pass->base, &render_rect_pass_impl);
push_gles2_debug(renderer); wlr_gles2_push_debug(renderer);
GLuint prog; GLuint prog;
pass->shader.program = prog = pass->shader.program = prog =
gles2_link_program(renderer, common_vert_src, quad_frag_src); wlr_gles2_link_program(renderer, common_vert_src, quad_frag_src);
if (!pass->shader.program) { if (!pass->shader.program) {
goto error; goto error;
} }
@ -411,14 +412,14 @@ struct wlr_render_rect_pass *wlr_gles2_render_rect_pass_create(
pass->shader.proj = glGetUniformLocation(pass->shader.program, "proj"); pass->shader.proj = glGetUniformLocation(pass->shader.program, "proj");
pass->shader.color = glGetUniformLocation(pass->shader.program, "color"); pass->shader.color = glGetUniformLocation(pass->shader.program, "color");
pass->shader.pos_attrib = glGetAttribLocation(pass->shader.program, "pos"); pass->shader.pos_attrib = glGetAttribLocation(pass->shader.program, "pos");
pop_gles2_debug(renderer); wlr_gles2_pop_debug(renderer);
wlr_egl_unset_current(renderer->egl); wlr_egl_unset_current(renderer->egl);
pass->renderer = renderer; pass->renderer = renderer;
return &pass->base; return &pass->base;
error: error:
render_rect_pass_destroy(&pass->base); render_rect_pass_destroy(&pass->base);
pop_gles2_debug(renderer); wlr_gles2_pop_debug(renderer);
wlr_egl_unset_current(renderer->egl); wlr_egl_unset_current(renderer->egl);
return NULL; return NULL;
@ -443,11 +444,11 @@ struct wlr_gles2_render_rect_pass *wlr_gles2_render_rect_pass_from_pass(
static void render_texture_pass_destroy(struct wlr_render_texture_pass *pass) { static void render_texture_pass_destroy(struct wlr_render_texture_pass *pass) {
struct wlr_gles2_render_texture_pass *gles2_pass = struct wlr_gles2_render_texture_pass *gles2_pass =
wlr_gles2_render_texture_pass_from_pass(pass); wlr_gles2_render_texture_pass_from_pass(pass);
push_gles2_debug(gles2_pass->renderer); wlr_gles2_push_debug(gles2_pass->renderer);
glDeleteProgram(gles2_pass->shaders.tex_rgba.program); glDeleteProgram(gles2_pass->shaders.tex_rgba.program);
glDeleteProgram(gles2_pass->shaders.tex_rgbx.program); glDeleteProgram(gles2_pass->shaders.tex_rgbx.program);
glDeleteProgram(gles2_pass->shaders.tex_ext.program); glDeleteProgram(gles2_pass->shaders.tex_ext.program);
pop_gles2_debug(gles2_pass->renderer); wlr_gles2_pop_debug(gles2_pass->renderer);
free(gles2_pass); free(gles2_pass);
} }
@ -464,15 +465,15 @@ struct wlr_render_texture_pass *wlr_gles2_render_texture_pass_create(
return NULL; return NULL;
} }
wlr_render_texture_pass_init(&pass->base, &render_texture_pass_impl); wlr_render_texture_pass_init(&pass->base, &render_texture_pass_impl);
struct wlr_gles2_renderer *renderer = gles2_get_renderer(wlr_renderer); struct wlr_gles2_renderer *renderer = wlr_gles2_renderer_from_renderer(wlr_renderer);
if (!wlr_egl_make_current(renderer->egl, NULL)) { if (!wlr_egl_make_current(renderer->egl, NULL)) {
free(pass); free(pass);
return NULL; return NULL;
} }
push_gles2_debug(renderer); wlr_gles2_push_debug(renderer);
GLuint prog; GLuint prog;
pass->shaders.tex_rgba.program = prog = pass->shaders.tex_rgba.program = prog =
gles2_link_program(renderer, common_vert_src, tex_rgba_frag_src); wlr_gles2_link_program(renderer, common_vert_src, tex_rgba_frag_src);
if (!pass->shaders.tex_rgba.program) { if (!pass->shaders.tex_rgba.program) {
goto error; goto error;
} }
@ -483,7 +484,7 @@ struct wlr_render_texture_pass *wlr_gles2_render_texture_pass_create(
pass->shaders.tex_rgba.pos_attrib = glGetAttribLocation(prog, "pos"); pass->shaders.tex_rgba.pos_attrib = glGetAttribLocation(prog, "pos");
pass->shaders.tex_rgbx.program = prog = pass->shaders.tex_rgbx.program = prog =
gles2_link_program(renderer, common_vert_src, tex_rgbx_frag_src); wlr_gles2_link_program(renderer, common_vert_src, tex_rgbx_frag_src);
if (!pass->shaders.tex_rgbx.program) { if (!pass->shaders.tex_rgbx.program) {
goto error; goto error;
} }
@ -495,7 +496,7 @@ struct wlr_render_texture_pass *wlr_gles2_render_texture_pass_create(
if (renderer->exts.OES_egl_image_external) { if (renderer->exts.OES_egl_image_external) {
pass->shaders.tex_ext.program = prog = pass->shaders.tex_ext.program = prog =
gles2_link_program(renderer, common_vert_src, tex_external_frag_src); wlr_gles2_link_program(renderer, common_vert_src, tex_external_frag_src);
if (!pass->shaders.tex_ext.program) { if (!pass->shaders.tex_ext.program) {
goto error; goto error;
} }
@ -506,7 +507,7 @@ struct wlr_render_texture_pass *wlr_gles2_render_texture_pass_create(
pass->shaders.tex_ext.pos_attrib = glGetAttribLocation(prog, "pos"); pass->shaders.tex_ext.pos_attrib = glGetAttribLocation(prog, "pos");
} }
pop_gles2_debug(renderer); wlr_gles2_pop_debug(renderer);
wlr_egl_unset_current(renderer->egl); wlr_egl_unset_current(renderer->egl);
pass->renderer = renderer; pass->renderer = renderer;
@ -514,7 +515,7 @@ struct wlr_render_texture_pass *wlr_gles2_render_texture_pass_create(
error: error:
render_texture_pass_destroy(&pass->base); render_texture_pass_destroy(&pass->base);
pop_gles2_debug(renderer); wlr_gles2_pop_debug(renderer);
wlr_egl_unset_current(renderer->egl); wlr_egl_unset_current(renderer->egl);
return NULL; return NULL;

47
render/gles2/renderer.c
View file

@ -27,9 +27,10 @@ bool wlr_renderer_is_gles2(const struct wlr_renderer *wlr_renderer) {
return wlr_renderer->impl == &renderer_impl; return wlr_renderer->impl == &renderer_impl;
} }
struct wlr_gles2_renderer *gles2_get_renderer( struct wlr_gles2_renderer *wlr_gles2_renderer_from_renderer(
struct wlr_renderer *wlr_renderer) { struct wlr_renderer *wlr_renderer) {
assert(wlr_renderer_is_gles2(wlr_renderer)); assert(wlr_renderer->impl == &renderer_impl);
struct wlr_gles2_renderer *renderer = wl_container_of(wlr_renderer, renderer, wlr_renderer); struct wlr_gles2_renderer *renderer = wl_container_of(wlr_renderer, renderer, wlr_renderer);
return renderer; return renderer;
} }
@ -51,13 +52,13 @@ static void destroy_buffer(struct wlr_gles2_buffer *buffer) {
struct wlr_egl_context prev_ctx; struct wlr_egl_context prev_ctx;
wlr_egl_make_current(buffer->renderer->egl, &prev_ctx); wlr_egl_make_current(buffer->renderer->egl, &prev_ctx);
push_gles2_debug(buffer->renderer); wlr_gles2_push_debug(buffer->renderer);
glDeleteFramebuffers(1, &buffer->fbo); glDeleteFramebuffers(1, &buffer->fbo);
glDeleteRenderbuffers(1, &buffer->rbo); glDeleteRenderbuffers(1, &buffer->rbo);
glDeleteTextures(1, &buffer->tex); glDeleteTextures(1, &buffer->tex);
pop_gles2_debug(buffer->renderer); wlr_gles2_pop_debug(buffer->renderer);
wlr_egl_destroy_image(buffer->renderer->egl, buffer->image); wlr_egl_destroy_image(buffer->renderer->egl, buffer->image);
@ -87,7 +88,7 @@ GLuint gles2_buffer_get_fbo(struct wlr_gles2_buffer *buffer) {
return buffer->fbo; return buffer->fbo;
} }
push_gles2_debug(buffer->renderer); wlr_gles2_push_debug(buffer->renderer);
if (!buffer->rbo) { if (!buffer->rbo) {
glGenRenderbuffers(1, &buffer->rbo); glGenRenderbuffers(1, &buffer->rbo);
@ -110,7 +111,7 @@ GLuint gles2_buffer_get_fbo(struct wlr_gles2_buffer *buffer) {
buffer->fbo = 0; buffer->fbo = 0;
} }
pop_gles2_debug(buffer->renderer); wlr_gles2_pop_debug(buffer->renderer);
return buffer->fbo; return buffer->fbo;
} }
@ -160,7 +161,7 @@ error_buffer:
static const struct wlr_drm_format_set *gles2_get_texture_formats( static const struct wlr_drm_format_set *gles2_get_texture_formats(
struct wlr_renderer *wlr_renderer, uint32_t buffer_caps) { struct wlr_renderer *wlr_renderer, uint32_t buffer_caps) {
struct wlr_gles2_renderer *renderer = gles2_get_renderer(wlr_renderer); struct wlr_gles2_renderer *renderer = wlr_gles2_renderer_from_renderer(wlr_renderer);
if (buffer_caps & WLR_BUFFER_CAP_DMABUF) { if (buffer_caps & WLR_BUFFER_CAP_DMABUF) {
return wlr_egl_get_dmabuf_texture_formats(renderer->egl); return wlr_egl_get_dmabuf_texture_formats(renderer->egl);
} else if (buffer_caps & WLR_BUFFER_CAP_DATA_PTR) { } else if (buffer_caps & WLR_BUFFER_CAP_DATA_PTR) {
@ -172,13 +173,13 @@ 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 *gles2_get_render_formats(
struct wlr_renderer *wlr_renderer) { struct wlr_renderer *wlr_renderer) {
struct wlr_gles2_renderer *renderer = gles2_get_renderer(wlr_renderer); struct wlr_gles2_renderer *renderer = wlr_gles2_renderer_from_renderer(wlr_renderer);
return wlr_egl_get_dmabuf_render_formats(renderer->egl); return wlr_egl_get_dmabuf_render_formats(renderer->egl);
} }
static int gles2_get_drm_fd(struct wlr_renderer *wlr_renderer) { static int gles2_get_drm_fd(struct wlr_renderer *wlr_renderer) {
struct wlr_gles2_renderer *renderer = struct wlr_gles2_renderer *renderer =
gles2_get_renderer(wlr_renderer); wlr_gles2_renderer_from_renderer(wlr_renderer);
if (renderer->drm_fd < 0) { if (renderer->drm_fd < 0) {
renderer->drm_fd = wlr_egl_dup_drm_fd(renderer->egl); renderer->drm_fd = wlr_egl_dup_drm_fd(renderer->egl);
@ -189,12 +190,12 @@ static int gles2_get_drm_fd(struct wlr_renderer *wlr_renderer) {
struct wlr_egl *wlr_gles2_renderer_get_egl(struct wlr_renderer *wlr_renderer) { struct wlr_egl *wlr_gles2_renderer_get_egl(struct wlr_renderer *wlr_renderer) {
struct wlr_gles2_renderer *renderer = struct wlr_gles2_renderer *renderer =
gles2_get_renderer(wlr_renderer); wlr_gles2_renderer_from_renderer(wlr_renderer);
return renderer->egl; return renderer->egl;
} }
static void gles2_destroy(struct wlr_renderer *wlr_renderer) { static void gles2_destroy(struct wlr_renderer *wlr_renderer) {
struct wlr_gles2_renderer *renderer = gles2_get_renderer(wlr_renderer); struct wlr_gles2_renderer *renderer = wlr_gles2_renderer_from_renderer(wlr_renderer);
wlr_egl_make_current(renderer->egl, NULL); wlr_egl_make_current(renderer->egl, NULL);
@ -227,7 +228,7 @@ static void gles2_destroy(struct wlr_renderer *wlr_renderer) {
static struct wlr_render_pass *gles2_begin_buffer_pass(struct wlr_renderer *wlr_renderer, static struct wlr_render_pass *gles2_begin_buffer_pass(struct wlr_renderer *wlr_renderer,
struct wlr_buffer *wlr_buffer, const struct wlr_buffer_pass_options *options) { struct wlr_buffer *wlr_buffer, const struct wlr_buffer_pass_options *options) {
struct wlr_gles2_renderer *renderer = gles2_get_renderer(wlr_renderer); struct wlr_gles2_renderer *renderer = wlr_gles2_renderer_from_renderer(wlr_renderer);
struct wlr_egl_context prev_ctx = {0}; struct wlr_egl_context prev_ctx = {0};
if (!wlr_egl_make_current(renderer->egl, &prev_ctx)) { if (!wlr_egl_make_current(renderer->egl, &prev_ctx)) {
@ -255,7 +256,7 @@ static struct wlr_render_pass *gles2_begin_buffer_pass(struct wlr_renderer *wlr_
GLuint wlr_gles2_renderer_get_buffer_fbo(struct wlr_renderer *wlr_renderer, GLuint wlr_gles2_renderer_get_buffer_fbo(struct wlr_renderer *wlr_renderer,
struct wlr_buffer *wlr_buffer) { struct wlr_buffer *wlr_buffer) {
struct wlr_gles2_renderer *renderer = gles2_get_renderer(wlr_renderer); struct wlr_gles2_renderer *renderer = wlr_gles2_renderer_from_renderer(wlr_renderer);
GLuint fbo = 0; GLuint fbo = 0;
struct wlr_egl_context prev_ctx = {0}; struct wlr_egl_context prev_ctx = {0};
@ -273,7 +274,7 @@ GLuint wlr_gles2_renderer_get_buffer_fbo(struct wlr_renderer *wlr_renderer,
} }
static struct wlr_render_timer *gles2_render_timer_create(struct wlr_renderer *wlr_renderer) { static struct wlr_render_timer *gles2_render_timer_create(struct wlr_renderer *wlr_renderer) {
struct wlr_gles2_renderer *renderer = gles2_get_renderer(wlr_renderer); struct wlr_gles2_renderer *renderer = wlr_gles2_renderer_from_renderer(wlr_renderer);
if (!renderer->exts.EXT_disjoint_timer_query) { if (!renderer->exts.EXT_disjoint_timer_query) {
wlr_log(WLR_ERROR, "can't create timer, EXT_disjoint_timer_query not available"); wlr_log(WLR_ERROR, "can't create timer, EXT_disjoint_timer_query not available");
return NULL; return NULL;
@ -354,7 +355,7 @@ static const struct wlr_render_timer_impl render_timer_impl = {
.destroy = gles2_render_timer_destroy, .destroy = gles2_render_timer_destroy,
}; };
void push_gles2_debug_(struct wlr_gles2_renderer *renderer, void wlr_gles2_push_debug_(struct wlr_gles2_renderer *renderer,
const char *file, const char *func) { const char *file, const char *func) {
if (!renderer->procs.glPushDebugGroupKHR) { if (!renderer->procs.glPushDebugGroupKHR) {
return; return;
@ -366,7 +367,7 @@ void push_gles2_debug_(struct wlr_gles2_renderer *renderer,
renderer->procs.glPushDebugGroupKHR(GL_DEBUG_SOURCE_APPLICATION_KHR, 1, -1, str); renderer->procs.glPushDebugGroupKHR(GL_DEBUG_SOURCE_APPLICATION_KHR, 1, -1, str);
} }
void pop_gles2_debug(struct wlr_gles2_renderer *renderer) { void wlr_gles2_pop_debug(struct wlr_gles2_renderer *renderer) {
if (renderer->procs.glPopDebugGroupKHR) { if (renderer->procs.glPopDebugGroupKHR) {
renderer->procs.glPopDebugGroupKHR(); renderer->procs.glPopDebugGroupKHR();
} }
@ -394,7 +395,7 @@ static void gles2_log(GLenum src, GLenum type, GLuint id, GLenum severity,
static GLuint compile_shader(struct wlr_gles2_renderer *renderer, static GLuint compile_shader(struct wlr_gles2_renderer *renderer,
GLenum type, const GLchar *src) { GLenum type, const GLchar *src) {
push_gles2_debug(renderer); wlr_gles2_push_debug(renderer);
GLuint shader = glCreateShader(type); GLuint shader = glCreateShader(type);
glShaderSource(shader, 1, &src, NULL); glShaderSource(shader, 1, &src, NULL);
@ -408,13 +409,13 @@ static GLuint compile_shader(struct wlr_gles2_renderer *renderer,
shader = 0; shader = 0;
} }
pop_gles2_debug(renderer); wlr_gles2_pop_debug(renderer);
return shader; return shader;
} }
GLuint gles2_link_program(struct wlr_gles2_renderer *renderer, GLuint wlr_gles2_link_program(struct wlr_gles2_renderer *renderer,
const GLchar *vert_src, const GLchar *frag_src) { const GLchar *vert_src, const GLchar *frag_src) {
push_gles2_debug(renderer); wlr_gles2_push_debug(renderer);
GLuint vert = compile_shader(renderer, GL_VERTEX_SHADER, vert_src); GLuint vert = compile_shader(renderer, GL_VERTEX_SHADER, vert_src);
if (!vert) { if (!vert) {
@ -445,11 +446,11 @@ GLuint gles2_link_program(struct wlr_gles2_renderer *renderer,
goto error; goto error;
} }
pop_gles2_debug(renderer); wlr_gles2_pop_debug(renderer);
return prog; return prog;
error: error:
pop_gles2_debug(renderer); wlr_gles2_pop_debug(renderer);
return 0; return 0;
} }
@ -631,6 +632,6 @@ struct wlr_renderer *wlr_gles2_renderer_create(struct wlr_egl *egl) {
bool wlr_gles2_renderer_check_ext(struct wlr_renderer *wlr_renderer, bool wlr_gles2_renderer_check_ext(struct wlr_renderer *wlr_renderer,
const char *ext) { const char *ext) {
struct wlr_gles2_renderer *renderer = gles2_get_renderer(wlr_renderer); struct wlr_gles2_renderer *renderer = wlr_gles2_renderer_from_renderer(wlr_renderer);
return check_gl_ext(renderer->exts_str, ext); return check_gl_ext(renderer->exts_str, ext);
} }

28
render/gles2/texture.c
View file

@ -71,7 +71,7 @@ static bool gles2_texture_update_from_buffer(struct wlr_texture *wlr_texture,
struct wlr_egl_context prev_ctx; struct wlr_egl_context prev_ctx;
wlr_egl_make_current(texture->renderer->egl, &prev_ctx); wlr_egl_make_current(texture->renderer->egl, &prev_ctx);
push_gles2_debug(texture->renderer); wlr_gles2_push_debug(texture->renderer);
glBindTexture(GL_TEXTURE_2D, texture->tex); glBindTexture(GL_TEXTURE_2D, texture->tex);
@ -97,7 +97,7 @@ static bool gles2_texture_update_from_buffer(struct wlr_texture *wlr_texture,
glBindTexture(GL_TEXTURE_2D, 0); glBindTexture(GL_TEXTURE_2D, 0);
pop_gles2_debug(texture->renderer); wlr_gles2_pop_debug(texture->renderer);
wlr_egl_restore_context(&prev_ctx); wlr_egl_restore_context(&prev_ctx);
@ -114,12 +114,12 @@ void gles2_texture_destroy(struct wlr_gles2_texture *texture) {
struct wlr_egl_context prev_ctx; struct wlr_egl_context prev_ctx;
wlr_egl_make_current(texture->renderer->egl, &prev_ctx); wlr_egl_make_current(texture->renderer->egl, &prev_ctx);
push_gles2_debug(texture->renderer); wlr_gles2_push_debug(texture->renderer);
glDeleteTextures(1, &texture->tex); glDeleteTextures(1, &texture->tex);
glDeleteFramebuffers(1, &texture->fbo); glDeleteFramebuffers(1, &texture->fbo);
pop_gles2_debug(texture->renderer); wlr_gles2_pop_debug(texture->renderer);
wlr_egl_restore_context(&prev_ctx); wlr_egl_restore_context(&prev_ctx);
} }
@ -193,7 +193,7 @@ static bool gles2_texture_read_pixels(struct wlr_texture *wlr_texture,
return false; return false;
} }
push_gles2_debug(texture->renderer); wlr_gles2_push_debug(texture->renderer);
struct wlr_egl_context prev_ctx; struct wlr_egl_context prev_ctx;
if (!wlr_egl_make_current(texture->renderer->egl, &prev_ctx)) { if (!wlr_egl_make_current(texture->renderer->egl, &prev_ctx)) {
return false; return false;
@ -249,7 +249,7 @@ static bool gles2_texture_read_pixels(struct wlr_texture *wlr_texture,
} }
wlr_egl_restore_context(&prev_ctx); wlr_egl_restore_context(&prev_ctx);
pop_gles2_debug(texture->renderer); wlr_gles2_pop_debug(texture->renderer);
return glGetError() == GL_NO_ERROR; return glGetError() == GL_NO_ERROR;
} }
@ -257,7 +257,7 @@ static bool gles2_texture_read_pixels(struct wlr_texture *wlr_texture,
static uint32_t gles2_texture_preferred_read_format(struct wlr_texture *wlr_texture) { static uint32_t gles2_texture_preferred_read_format(struct wlr_texture *wlr_texture) {
struct wlr_gles2_texture *texture = gles2_get_texture(wlr_texture); struct wlr_gles2_texture *texture = gles2_get_texture(wlr_texture);
push_gles2_debug(texture->renderer); wlr_gles2_push_debug(texture->renderer);
uint32_t fmt = DRM_FORMAT_INVALID; uint32_t fmt = DRM_FORMAT_INVALID;
@ -276,7 +276,7 @@ static uint32_t gles2_texture_preferred_read_format(struct wlr_texture *wlr_text
glGetIntegerv(GL_ALPHA_BITS, &alpha_size); glGetIntegerv(GL_ALPHA_BITS, &alpha_size);
glBindFramebuffer(GL_FRAMEBUFFER, 0); glBindFramebuffer(GL_FRAMEBUFFER, 0);
pop_gles2_debug(texture->renderer); wlr_gles2_pop_debug(texture->renderer);
const struct wlr_gles2_pixel_format *pix_fmt = const struct wlr_gles2_pixel_format *pix_fmt =
get_gles2_format_from_gl(gl_format, gl_type, alpha_size > 0); get_gles2_format_from_gl(gl_format, gl_type, alpha_size > 0);
@ -320,7 +320,7 @@ static struct wlr_texture *gles2_texture_from_pixels(
struct wlr_renderer *wlr_renderer, struct wlr_renderer *wlr_renderer,
uint32_t drm_format, uint32_t stride, uint32_t width, uint32_t drm_format, uint32_t stride, uint32_t width,
uint32_t height, const void *data) { uint32_t height, const void *data) {
struct wlr_gles2_renderer *renderer = gles2_get_renderer(wlr_renderer); struct wlr_gles2_renderer *renderer = wlr_gles2_renderer_from_renderer(wlr_renderer);
const struct wlr_gles2_pixel_format *fmt = const struct wlr_gles2_pixel_format *fmt =
get_gles2_format_from_drm(drm_format); get_gles2_format_from_drm(drm_format);
@ -358,7 +358,7 @@ static struct wlr_texture *gles2_texture_from_pixels(
struct wlr_egl_context prev_ctx; struct wlr_egl_context prev_ctx;
wlr_egl_make_current(renderer->egl, &prev_ctx); wlr_egl_make_current(renderer->egl, &prev_ctx);
push_gles2_debug(renderer); wlr_gles2_push_debug(renderer);
glGenTextures(1, &texture->tex); glGenTextures(1, &texture->tex);
glBindTexture(GL_TEXTURE_2D, texture->tex); glBindTexture(GL_TEXTURE_2D, texture->tex);
@ -372,7 +372,7 @@ static struct wlr_texture *gles2_texture_from_pixels(
glBindTexture(GL_TEXTURE_2D, 0); glBindTexture(GL_TEXTURE_2D, 0);
pop_gles2_debug(renderer); wlr_gles2_pop_debug(renderer);
wlr_egl_restore_context(&prev_ctx); wlr_egl_restore_context(&prev_ctx);
@ -404,7 +404,7 @@ static struct wlr_texture *gles2_texture_from_dmabuf(
struct wlr_egl_context prev_ctx; struct wlr_egl_context prev_ctx;
wlr_egl_make_current(renderer->egl, &prev_ctx); wlr_egl_make_current(renderer->egl, &prev_ctx);
push_gles2_debug(texture->renderer); wlr_gles2_push_debug(texture->renderer);
bool invalid; bool invalid;
if (!buffer->tex) { if (!buffer->tex) {
@ -423,7 +423,7 @@ static struct wlr_texture *gles2_texture_from_dmabuf(
glBindTexture(texture->target, 0); glBindTexture(texture->target, 0);
} }
pop_gles2_debug(texture->renderer); wlr_gles2_pop_debug(texture->renderer);
wlr_egl_restore_context(&prev_ctx); wlr_egl_restore_context(&prev_ctx);
texture->tex = buffer->tex; texture->tex = buffer->tex;
@ -433,7 +433,7 @@ static struct wlr_texture *gles2_texture_from_dmabuf(
struct wlr_texture *gles2_texture_from_buffer(struct wlr_renderer *wlr_renderer, struct wlr_texture *gles2_texture_from_buffer(struct wlr_renderer *wlr_renderer,
struct wlr_buffer *buffer) { struct wlr_buffer *buffer) {
struct wlr_gles2_renderer *renderer = gles2_get_renderer(wlr_renderer); struct wlr_gles2_renderer *renderer = wlr_gles2_renderer_from_renderer(wlr_renderer);
void *data; void *data;
uint32_t format; uint32_t format;

11
render/pixman/pass.c
View file

@ -7,7 +7,8 @@
static const struct wlr_render_pass_impl render_pass_impl; static const struct wlr_render_pass_impl render_pass_impl;
static struct wlr_pixman_render_pass *get_render_pass(struct wlr_render_pass *wlr_pass) { struct wlr_pixman_render_pass *wlr_pixman_render_pass_from_render_pass(
struct wlr_render_pass *wlr_pass) {
assert(wlr_pass->impl == &render_pass_impl); assert(wlr_pass->impl == &render_pass_impl);
struct wlr_pixman_render_pass *pass = wl_container_of(wlr_pass, pass, base); struct wlr_pixman_render_pass *pass = wl_container_of(wlr_pass, pass, base);
return pass; return pass;
@ -20,7 +21,7 @@ static struct wlr_pixman_texture *get_texture(struct wlr_texture *wlr_texture) {
} }
static bool render_pass_submit(struct wlr_render_pass *wlr_pass) { static bool render_pass_submit(struct wlr_render_pass *wlr_pass) {
struct wlr_pixman_render_pass *pass = get_render_pass(wlr_pass); struct wlr_pixman_render_pass *pass = wlr_pixman_render_pass_from_render_pass(wlr_pass);
wlr_buffer_end_data_ptr_access(pass->buffer->buffer); wlr_buffer_end_data_ptr_access(pass->buffer->buffer);
wlr_buffer_unlock(pass->buffer->buffer); wlr_buffer_unlock(pass->buffer->buffer);
@ -41,7 +42,7 @@ static pixman_op_t get_pixman_blending(enum wlr_render_blend_mode mode) {
static void render_pass_add_texture(struct wlr_render_pass *wlr_pass, static void render_pass_add_texture(struct wlr_render_pass *wlr_pass,
const struct wlr_render_texture_options *options) { const struct wlr_render_texture_options *options) {
struct wlr_pixman_render_pass *pass = get_render_pass(wlr_pass); struct wlr_pixman_render_pass *pass = wlr_pixman_render_pass_from_render_pass(wlr_pass);
struct wlr_pixman_texture *texture = get_texture(options->texture); struct wlr_pixman_texture *texture = get_texture(options->texture);
struct wlr_pixman_buffer *buffer = pass->buffer; struct wlr_pixman_buffer *buffer = pass->buffer;
@ -204,7 +205,7 @@ static void render_pass_add_texture(struct wlr_render_pass *wlr_pass,
static void render_pass_add_rect(struct wlr_render_pass *wlr_pass, static void render_pass_add_rect(struct wlr_render_pass *wlr_pass,
const struct wlr_render_rect_options *options) { const struct wlr_render_rect_options *options) {
struct wlr_pixman_render_pass *pass = get_render_pass(wlr_pass); struct wlr_pixman_render_pass *pass = wlr_pixman_render_pass_from_render_pass(wlr_pass);
struct wlr_pixman_buffer *buffer = pass->buffer; struct wlr_pixman_buffer *buffer = pass->buffer;
struct wlr_box box; struct wlr_box box;
wlr_render_rect_options_get_box(options, pass->buffer->buffer, &box); wlr_render_rect_options_get_box(options, pass->buffer->buffer, &box);
@ -234,7 +235,7 @@ static void render_pass_destory(struct wlr_render_pass *wlr_pass) {
} }
static struct wlr_renderer *render_pass_get_renderer(struct wlr_render_pass *wlr_pass) { static struct wlr_renderer *render_pass_get_renderer(struct wlr_render_pass *wlr_pass) {
struct wlr_pixman_render_pass *pass = get_render_pass(wlr_pass); struct wlr_pixman_render_pass *pass = wlr_pixman_render_pass_from_render_pass(wlr_pass);
struct wlr_pixman_renderer *renderer = pass->buffer->renderer; struct wlr_pixman_renderer *renderer = pass->buffer->renderer;
return &renderer->wlr_renderer; return &renderer->wlr_renderer;

8
render/pixman/renderer.c
View file

@ -344,6 +344,14 @@ struct wlr_renderer *wlr_pixman_renderer_create(void) {
return &renderer->wlr_renderer; return &renderer->wlr_renderer;
} }
struct wlr_pixman_renderer *wlr_pixman_renderer_from_renderer(
struct wlr_renderer *wlr_renderer) {
assert(wlr_renderer->impl == &renderer_impl);
struct wlr_pixman_renderer *renderer = wl_container_of(wlr_renderer, renderer, wlr_renderer);
return renderer;
}
pixman_image_t *wlr_pixman_renderer_get_buffer_image( pixman_image_t *wlr_pixman_renderer_get_buffer_image(
struct wlr_renderer *wlr_renderer, struct wlr_buffer *wlr_buffer) { struct wlr_renderer *wlr_renderer, struct wlr_buffer *wlr_buffer) {
struct wlr_pixman_renderer *renderer = get_renderer(wlr_renderer); struct wlr_pixman_renderer *renderer = get_renderer(wlr_renderer);

39
render/vulkan/pass.c
View file

@ -14,7 +14,7 @@
static const struct wlr_render_pass_impl render_pass_impl; static const struct wlr_render_pass_impl render_pass_impl;
static const struct wlr_addon_interface vk_color_transform_impl; static const struct wlr_addon_interface vk_color_transform_impl;
static bool create_shader_module(VkDevice dev, const uint32_t *code, bool wlr_vk_create_shader_module(VkDevice dev, const uint32_t *code,
size_t code_size, const char *name, VkShaderModule *out) { size_t code_size, const char *name, VkShaderModule *out) {
VkShaderModuleCreateInfo sinfo = { VkShaderModuleCreateInfo sinfo = {
.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
@ -32,7 +32,8 @@ static bool create_shader_module(VkDevice dev, const uint32_t *code,
return true; return true;
} }
static struct wlr_vk_render_pass *get_render_pass(struct wlr_render_pass *wlr_pass) { struct wlr_vk_render_pass *wlr_vk_render_pass_from_render_pass(
struct wlr_render_pass *wlr_pass) {
assert(wlr_pass->impl == &render_pass_impl); assert(wlr_pass->impl == &render_pass_impl);
struct wlr_vk_render_pass *pass = wl_container_of(wlr_pass, pass, base); struct wlr_vk_render_pass *pass = wl_container_of(wlr_pass, pass, base);
return pass; return pass;
@ -79,11 +80,11 @@ static float color_to_linear(float non_linear) {
return pow(non_linear, 2.2); return pow(non_linear, 2.2);
} }
static float color_to_linear_premult(float non_linear, float alpha) { float wlr_color_to_linear_premult(float non_linear, float alpha) {
return (alpha == 0) ? 0 : color_to_linear(non_linear / alpha) * alpha; return (alpha == 0) ? 0 : color_to_linear(non_linear / alpha) * alpha;
} }
static void encode_proj_matrix(const float mat3[9], float mat4[4][4]) { void wlr_encode_proj_matrix(const float mat3[9], float mat4[4][4]) {
float result[4][4] = { float result[4][4] = {
{ mat3[0], mat3[1], 0, mat3[2] }, { mat3[0], mat3[1], 0, mat3[2] },
{ mat3[3], mat3[4], 0, mat3[5] }, { mat3[3], mat3[4], 0, mat3[5] },
@ -94,7 +95,7 @@ static void encode_proj_matrix(const float mat3[9], float mat4[4][4]) {
memcpy(mat4, result, sizeof(result)); memcpy(mat4, result, sizeof(result));
} }
static void encode_color_matrix(const float mat3[9], float mat4[4][4]) { void wlr_encode_color_matrix(const float mat3[9], float mat4[4][4]) {
float result[4][4] = { float result[4][4] = {
{ mat3[0], mat3[1], mat3[2], 0 }, { mat3[0], mat3[1], mat3[2], 0 },
{ mat3[3], mat3[4], mat3[5], 0 }, { mat3[3], mat3[4], mat3[5], 0 },
@ -194,7 +195,7 @@ static bool unwrap_color_transform(struct wlr_color_transform *transform,
} }
static bool render_pass_submit(struct wlr_render_pass *wlr_pass) { static bool render_pass_submit(struct wlr_render_pass *wlr_pass) {
struct wlr_vk_render_pass *pass = get_render_pass(wlr_pass); struct wlr_vk_render_pass *pass = wlr_vk_render_pass_from_render_pass(wlr_pass);
struct wlr_vk_renderer *renderer = pass->renderer; struct wlr_vk_renderer *renderer = pass->renderer;
struct wlr_vk_render_submit_pass *submit_pass = struct wlr_vk_render_submit_pass *submit_pass =
wlr_vk_render_submit_pass_from_pass(renderer->wlr_renderer.submit_pass); wlr_vk_render_submit_pass_from_pass(renderer->wlr_renderer.submit_pass);
@ -233,7 +234,7 @@ static bool render_pass_submit(struct wlr_render_pass *wlr_pass) {
.uv_off = { 0, 0 }, .uv_off = { 0, 0 },
.uv_size = { 1, 1 }, .uv_size = { 1, 1 },
}; };
encode_proj_matrix(final_matrix, vert_pcr_data.mat4); wlr_encode_proj_matrix(final_matrix, vert_pcr_data.mat4);
float matrix[9]; float matrix[9];
enum wlr_color_transfer_function tf = WLR_COLOR_TRANSFER_FUNCTION_GAMMA22; enum wlr_color_transfer_function tf = WLR_COLOR_TRANSFER_FUNCTION_GAMMA22;
@ -257,7 +258,7 @@ static bool render_pass_submit(struct wlr_render_pass *wlr_pass) {
.lut_3d_scale = (float)(dim - 1) / dim, .lut_3d_scale = (float)(dim - 1) / dim,
}; };
encode_color_matrix(matrix, frag_pcr_data.matrix); wlr_encode_color_matrix(matrix, frag_pcr_data.matrix);
VkPipeline pipeline = VK_NULL_HANDLE; VkPipeline pipeline = VK_NULL_HANDLE;
if (need_lut) { if (need_lut) {
@ -665,7 +666,7 @@ static void render_pass_mark_box_updated(struct wlr_vk_render_pass *pass,
static void render_pass_add_rect(struct wlr_render_pass *wlr_pass, static void render_pass_add_rect(struct wlr_render_pass *wlr_pass,
const struct wlr_render_rect_options *options) { const struct wlr_render_rect_options *options) {
struct wlr_vk_render_pass *pass = get_render_pass(wlr_pass); struct wlr_vk_render_pass *pass = wlr_vk_render_pass_from_render_pass(wlr_pass);
struct wlr_vk_render_rect_pass *rect_pass = struct wlr_vk_render_rect_pass *rect_pass =
wlr_vk_render_rect_pass_from_pass(pass->renderer->wlr_renderer.rect_pass); wlr_vk_render_rect_pass_from_pass(pass->renderer->wlr_renderer.rect_pass);
assert(rect_pass != NULL); assert(rect_pass != NULL);
@ -677,9 +678,9 @@ static void render_pass_add_rect(struct wlr_render_pass *wlr_pass,
// colors in linear space as well (and vulkan then automatically // colors in linear space as well (and vulkan then automatically
// does the conversion for out sRGB render targets). // does the conversion for out sRGB render targets).
float linear_color[] = { float linear_color[] = {
color_to_linear_premult(options->color.r, options->color.a), wlr_color_to_linear_premult(options->color.r, options->color.a),
color_to_linear_premult(options->color.g, options->color.a), wlr_color_to_linear_premult(options->color.g, options->color.a),
color_to_linear_premult(options->color.b, options->color.a), wlr_color_to_linear_premult(options->color.b, options->color.a),
options->color.a, // no conversion for alpha options->color.a, // no conversion for alpha
}; };
@ -730,7 +731,7 @@ static void render_pass_add_rect(struct wlr_render_pass *wlr_pass,
.uv_off = { 0, 0 }, .uv_off = { 0, 0 },
.uv_size = { 1, 1 }, .uv_size = { 1, 1 },
}; };
encode_proj_matrix(matrix, vert_pcr_data.mat4); wlr_encode_proj_matrix(matrix, vert_pcr_data.mat4);
bind_pipeline(pass, pipe->vk); bind_pipeline(pass, pipe->vk);
vkCmdPushConstants(cb, pipe->layout->vk, vkCmdPushConstants(cb, pipe->layout->vk,
@ -772,7 +773,7 @@ static void render_pass_add_rect(struct wlr_render_pass *wlr_pass,
static void render_pass_add_texture(struct wlr_render_pass *wlr_pass, static void render_pass_add_texture(struct wlr_render_pass *wlr_pass,
const struct wlr_render_texture_options *options) { const struct wlr_render_texture_options *options) {
struct wlr_vk_render_pass *pass = get_render_pass(wlr_pass); struct wlr_vk_render_pass *pass = wlr_vk_render_pass_from_render_pass(wlr_pass);
struct wlr_vk_renderer *renderer = pass->renderer; struct wlr_vk_renderer *renderer = pass->renderer;
struct wlr_vk_render_texture_pass *texture_pass = struct wlr_vk_render_texture_pass *texture_pass =
wlr_vk_render_texture_pass_from_pass(renderer->wlr_renderer.texture_pass); wlr_vk_render_texture_pass_from_pass(renderer->wlr_renderer.texture_pass);
@ -816,7 +817,7 @@ static void render_pass_add_texture(struct wlr_render_pass *wlr_pass,
src_box.height / options->texture->height, src_box.height / options->texture->height,
}, },
}; };
encode_proj_matrix(matrix, vert_pcr_data.mat4); wlr_encode_proj_matrix(matrix, vert_pcr_data.mat4);
enum wlr_color_transfer_function tf = options->transfer_function; enum wlr_color_transfer_function tf = options->transfer_function;
if (tf == 0) { if (tf == 0) {
@ -909,7 +910,7 @@ static void render_pass_add_texture(struct wlr_render_pass *wlr_pass,
.alpha = alpha, .alpha = alpha,
.luminance_multiplier = luminance_multiplier, .luminance_multiplier = luminance_multiplier,
}; };
encode_color_matrix(color_matrix, frag_pcr_data.matrix); wlr_encode_color_matrix(color_matrix, frag_pcr_data.matrix);
bind_pipeline(pass, pipe->vk); bind_pipeline(pass, pipe->vk);
@ -978,7 +979,7 @@ static void render_pass_destory(struct wlr_render_pass *wlr_pass) {
} }
static struct wlr_renderer *render_pass_get_renderer(struct wlr_render_pass *wlr_pass) { static struct wlr_renderer *render_pass_get_renderer(struct wlr_render_pass *wlr_pass) {
struct wlr_vk_render_pass *pass = get_render_pass(wlr_pass); struct wlr_vk_render_pass *pass = wlr_vk_render_pass_from_render_pass(wlr_pass);
struct wlr_vk_renderer *renderer = pass->renderer; struct wlr_vk_renderer *renderer = pass->renderer;
return &renderer->wlr_renderer; return &renderer->wlr_renderer;
@ -1412,7 +1413,7 @@ struct wlr_render_rect_pass *wlr_vk_render_rect_pass_create(
} }
VkDevice dev = renderer->dev->dev; VkDevice dev = renderer->dev->dev;
if (!create_shader_module(dev, quad_frag_data, sizeof(quad_frag_data), if (!wlr_vk_create_shader_module(dev, quad_frag_data, sizeof(quad_frag_data),
"quad fragment", &pass->shader.frag_module)) { "quad fragment", &pass->shader.frag_module)) {
render_rect_pass_destroy(&pass->base); render_rect_pass_destroy(&pass->base);
return NULL; return NULL;
@ -1474,7 +1475,7 @@ struct wlr_render_texture_pass *wlr_vk_render_texture_pass_create(
} }
VkDevice dev = renderer->dev->dev; VkDevice dev = renderer->dev->dev;
if (!create_shader_module(dev, texture_frag_data, sizeof(texture_frag_data), if (!wlr_vk_create_shader_module(dev, texture_frag_data, sizeof(texture_frag_data),
"texture fragment", &pass->shader.frag_module)) { "texture fragment", &pass->shader.frag_module)) {
render_texture_pass_destroy(&pass->base); render_texture_pass_destroy(&pass->base);
return NULL; return NULL;

8
render/vulkan/renderer.c
View file

@ -1844,6 +1844,14 @@ static bool pipeline_key_equals(const struct wlr_vk_pipeline_key *a,
return true; return true;
} }
struct wlr_vk_renderer *wlr_vk_renderer_from_renderer(
struct wlr_renderer *wlr_renderer) {
assert(wlr_renderer->impl == &renderer_impl);
struct wlr_vk_renderer *renderer = wl_container_of(wlr_renderer, renderer, wlr_renderer);
return renderer;
}
// Initializes the pipeline for rendering textures and using the given // Initializes the pipeline for rendering textures and using the given
// VkRenderPass and VkPipelineLayout. // VkRenderPass and VkPipelineLayout.
struct wlr_vk_pipeline *setup_get_or_create_pipeline( struct wlr_vk_pipeline *setup_get_or_create_pipeline(