matrix: use 2D matrices

This commit is contained in:
emersion 2018-03-15 15:33:58 +01:00
parent d26b67cb06
commit 824a95ad19
No known key found for this signature in database
GPG Key ID: 0FDE7BE0E88F5E48
21 changed files with 216 additions and 271 deletions

View File

@ -647,9 +647,9 @@ static bool wlr_drm_connector_set_cursor(struct wlr_output *output,
glClearColor(0.0, 0.0, 0.0, 0.0); glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT); glClear(GL_COLOR_BUFFER_BIT);
float matrix[16]; float matrix[9];
wlr_texture_get_matrix(plane->wlr_tex, matrix, plane->matrix, 0, 0); wlr_texture_get_matrix(plane->wlr_tex, matrix, plane->matrix, 0, 0);
wlr_render_with_matrix(plane->surf.renderer->wlr_rend, plane->wlr_tex, wlr_render_texture_with_matrix(plane->surf.renderer->wlr_rend, plane->wlr_tex,
matrix, 1.0f); matrix, 1.0f);
glFinish(); glFinish();

View File

@ -1,3 +1,4 @@
#include <assert.h>
#include <EGL/egl.h> #include <EGL/egl.h>
#include <EGL/eglext.h> #include <EGL/eglext.h>
#include <gbm.h> #include <gbm.h>
@ -226,20 +227,21 @@ struct gbm_bo *wlr_drm_surface_mgpu_copy(struct wlr_drm_surface *dest,
wlr_drm_surface_make_current(dest, NULL); wlr_drm_surface_make_current(dest, NULL);
struct wlr_texture *tex = get_tex_for_bo(dest->renderer, src); struct wlr_texture *tex = get_tex_for_bo(dest->renderer, src);
assert(tex);
static const float matrix[16] = { static const float color[] = {0.0, 0.0, 0.0, 1.0};
static const float mat[9] = {
[0] = 2.0f, [0] = 2.0f,
[3] = -1.0f, [2] = -1.0f,
[5] = 2.0f, [4] = 2.0f,
[7] = -1.0f, [5] = -1.0f,
[10] = 1.0f, [8] = 1.0f,
[15] = 1.0f,
}; };
glViewport(0, 0, dest->width, dest->height); glViewport(0, 0, dest->width, dest->height);
glClearColor(0.0, 0.0, 0.0, 1.0); wlr_renderer_clear(dest->renderer->wlr_rend, color);
glClear(GL_COLOR_BUFFER_BIT); wlr_render_texture_with_matrix(dest->renderer->wlr_rend, tex, mat, 1.0f);
wlr_render_with_matrix(dest->renderer->wlr_rend, tex, matrix, 1.0f);
return wlr_drm_surface_swap_buffers(dest, NULL); return wlr_drm_surface_swap_buffers(dest, NULL);
} }

View File

@ -111,7 +111,7 @@ static void handle_output_frame(struct output_state *output,
.width = 128, .height = 128, .width = 128, .height = 128,
}; };
if (wlr_output_layout_intersects(sample->layout, output->output, &box)) { if (wlr_output_layout_intersects(sample->layout, output->output, &box)) {
float matrix[16]; float matrix[9];
// transform global coordinates to local coordinates // transform global coordinates to local coordinates
double local_x = sample->x_offs; double local_x = sample->x_offs;
@ -121,8 +121,8 @@ static void handle_output_frame(struct output_state *output,
wlr_texture_get_matrix(sample->cat_texture, matrix, wlr_texture_get_matrix(sample->cat_texture, matrix,
wlr_output->transform_matrix, local_x, local_y); wlr_output->transform_matrix, local_x, local_y);
wlr_render_with_matrix(sample->renderer, wlr_render_texture_with_matrix(sample->renderer, sample->cat_texture,
sample->cat_texture, matrix, 1.0f); matrix, 1.0f);
} }
wlr_renderer_end(sample->renderer); wlr_renderer_end(sample->renderer);

View File

@ -46,12 +46,12 @@ static void handle_output_frame(struct output_state *output, struct timespec *ts
wlr_renderer_begin(sample->renderer, wlr_output); wlr_renderer_begin(sample->renderer, wlr_output);
wlr_renderer_clear(sample->renderer, (float[]){0.25f, 0.25f, 0.25f, 1}); wlr_renderer_clear(sample->renderer, (float[]){0.25f, 0.25f, 0.25f, 1});
float matrix[16]; float matrix[9];
for (int y = -128 + (int)odata->y_offs; y < height; y += 128) { for (int y = -128 + (int)odata->y_offs; y < height; y += 128) {
for (int x = -128 + (int)odata->x_offs; x < width; x += 128) { for (int x = -128 + (int)odata->x_offs; x < width; x += 128) {
wlr_texture_get_matrix(sample->cat_texture, matrix, wlr_texture_get_matrix(sample->cat_texture, matrix,
wlr_output->transform_matrix, x, y); wlr_output->transform_matrix, x, y);
wlr_render_with_matrix(sample->renderer, wlr_render_texture_with_matrix(sample->renderer,
sample->cat_texture, matrix, 1.0f); sample->cat_texture, matrix, 1.0f);
} }
} }

View File

@ -49,7 +49,7 @@ static void handle_output_frame(struct output_state *output, struct timespec *ts
wlr_renderer_begin(sample->renderer, wlr_output); wlr_renderer_begin(sample->renderer, wlr_output);
wlr_renderer_clear(sample->renderer, (float[]){0.25f, 0.25f, 0.25f, 1}); wlr_renderer_clear(sample->renderer, (float[]){0.25f, 0.25f, 0.25f, 1});
float matrix[16]; float matrix[9];
float distance = 0.8f * (1 - sample->distance); float distance = 0.8f * (1 - sample->distance);
float tool_color[4] = { distance, distance, distance, 1 }; float tool_color[4] = { distance, distance, distance, 1 };
for (size_t i = 0; sample->button && i < 4; ++i) { for (size_t i = 0; sample->button && i < 4; ++i) {

View File

@ -45,14 +45,14 @@ static void handle_output_frame(struct output_state *output, struct timespec *ts
wlr_renderer_begin(sample->renderer, wlr_output); wlr_renderer_begin(sample->renderer, wlr_output);
wlr_renderer_clear(sample->renderer, (float[]){0.25f, 0.25f, 0.25f, 1}); wlr_renderer_clear(sample->renderer, (float[]){0.25f, 0.25f, 0.25f, 1});
float matrix[16]; float matrix[9];
struct touch_point *p; struct touch_point *p;
wl_list_for_each(p, &sample->touch_points, link) { wl_list_for_each(p, &sample->touch_points, link) {
wlr_texture_get_matrix(sample->cat_texture, matrix, wlr_texture_get_matrix(sample->cat_texture, matrix,
wlr_output->transform_matrix, wlr_output->transform_matrix,
(int)(p->x * width) - sample->cat_texture->width / 2, (int)(p->x * width) - sample->cat_texture->width / 2,
(int)(p->y * height) - sample->cat_texture->height / 2); (int)(p->y * height) - sample->cat_texture->height / 2);
wlr_render_with_matrix(sample->renderer, sample->cat_texture, wlr_render_texture_with_matrix(sample->renderer, sample->cat_texture,
matrix, 1.0f); matrix, 1.0f);
} }

View File

@ -26,7 +26,7 @@ struct wlr_drm_plane {
struct wlr_drm_surface mgpu_surf; struct wlr_drm_surface mgpu_surf;
// Only used by cursor // Only used by cursor
float matrix[16]; float matrix[9];
struct wlr_texture *wlr_tex; struct wlr_texture *wlr_tex;
struct gbm_bo *cursor_bo; struct gbm_bo *cursor_bo;
bool cursor_enabled; bool cursor_enabled;

View File

@ -30,26 +30,26 @@ struct wlr_texture *wlr_render_texture_create(struct wlr_renderer *r);
* *
* struct wlr_renderer *renderer; * struct wlr_renderer *renderer;
* struct wlr_texture *texture; * struct wlr_texture *texture;
* float projection[16]; * float projection[9];
* float matrix[16]; * float matrix[9];
* wlr_texture_get_matrix(texture, &matrix, &projection, 123, 321); * wlr_texture_get_matrix(texture, matrix, projection, 123, 321);
* wlr_render_with_matrix(renderer, texture, &matrix, 0.5f); * wlr_render_texture_with_matrix(renderer, texture, matrix, 0.5f);
* *
* This will render the texture at <123, 321> with an alpha channel of 0.5. * This will render the texture at <123, 321> with an alpha channel of 0.5.
*/ */
bool wlr_render_with_matrix(struct wlr_renderer *r, bool wlr_render_texture_with_matrix(struct wlr_renderer *r,
struct wlr_texture *texture, const float matrix[static 16], float alpha); struct wlr_texture *texture, const float matrix[static 9], float alpha);
/** /**
* Renders a solid quad in the specified color. * Renders a solid quad in the specified color.
*/ */
void wlr_render_colored_quad(struct wlr_renderer *r, void wlr_render_colored_quad(struct wlr_renderer *r,
const float color[static 4], const float matrix[static 16]); const float color[static 4], const float matrix[static 9]);
/** /**
* Renders a solid ellipse in the specified color. * Renders a solid ellipse in the specified color.
*/ */
void wlr_render_colored_ellipse(struct wlr_renderer *r, void wlr_render_colored_ellipse(struct wlr_renderer *r,
const float color[static 4], const float matrix[static 16]); const float color[static 4], const float matrix[static 9]);
/** /**
* Returns a list of pixel formats supported by this renderer. * Returns a list of pixel formats supported by this renderer.
*/ */
@ -139,8 +139,8 @@ bool wlr_texture_update_shm(struct wlr_texture *surf, uint32_t format,
* width) and [0, height], and the x and y coordinates provided are used as * width) and [0, height], and the x and y coordinates provided are used as
* such. * such.
*/ */
void wlr_texture_get_matrix(struct wlr_texture *texture, float mat[static 16], void wlr_texture_get_matrix(struct wlr_texture *texture, float mat[static 9],
const float projection[static 16], int x, int y); const float projection[static 9], int x, int y);
/** /**
* Destroys this wlr_texture. * Destroys this wlr_texture.
*/ */

View File

@ -21,13 +21,13 @@ struct wlr_renderer_impl {
void (*clear)(struct wlr_renderer *renderer, const float color[static 4]); void (*clear)(struct wlr_renderer *renderer, const float color[static 4]);
void (*scissor)(struct wlr_renderer *renderer, struct wlr_box *box); void (*scissor)(struct wlr_renderer *renderer, struct wlr_box *box);
struct wlr_texture *(*texture_create)(struct wlr_renderer *renderer); struct wlr_texture *(*texture_create)(struct wlr_renderer *renderer);
bool (*render_with_matrix)(struct wlr_renderer *renderer, bool (*render_texture_with_matrix)(struct wlr_renderer *renderer,
struct wlr_texture *texture, const float matrix[static 16], struct wlr_texture *texture, const float matrix[static 9],
float alpha); float alpha);
void (*render_quad)(struct wlr_renderer *renderer, void (*render_quad)(struct wlr_renderer *renderer,
const float color[static 4], const float matrix[static 16]); const float color[static 4], const float matrix[static 9]);
void (*render_ellipse)(struct wlr_renderer *renderer, void (*render_ellipse)(struct wlr_renderer *renderer,
const float color[static 4], const float matrix[static 16]); const float color[static 4], const float matrix[static 9]);
const enum wl_shm_format *(*formats)( const enum wl_shm_format *(*formats)(
struct wlr_renderer *renderer, size_t *len); struct wlr_renderer *renderer, size_t *len);
bool (*buffer_is_drm)(struct wlr_renderer *renderer, bool (*buffer_is_drm)(struct wlr_renderer *renderer,
@ -59,8 +59,8 @@ struct wlr_texture_impl {
struct wl_resource *drm_buf); struct wl_resource *drm_buf);
bool (*upload_eglimage)(struct wlr_texture *texture, EGLImageKHR image, bool (*upload_eglimage)(struct wlr_texture *texture, EGLImageKHR image,
uint32_t width, uint32_t height); uint32_t width, uint32_t height);
void (*get_matrix)(struct wlr_texture *state, float mat[static 16], void (*get_matrix)(struct wlr_texture *state, float mat[static 9],
const float projection[static 16], int x, int y); const float projection[static 9], int x, int y);
void (*get_buffer_size)(struct wlr_texture *texture, void (*get_buffer_size)(struct wlr_texture *texture,
struct wl_resource *resource, int *width, int *height); struct wl_resource *resource, int *width, int *height);
void (*bind)(struct wlr_texture *texture); void (*bind)(struct wlr_texture *texture);

View File

@ -2,22 +2,22 @@
#define WLR_TYPES_WLR_MATRIX_H #define WLR_TYPES_WLR_MATRIX_H
#include <stdint.h> #include <stdint.h>
#include <wayland-server.h>
#include <wlr/types/wlr_box.h> #include <wlr/types/wlr_box.h>
void wlr_matrix_identity(float mat[static 16]); void wlr_matrix_identity(float mat[static 9]);
void wlr_matrix_translate(float mat[static 16], float x, float y, float z); void wlr_matrix_translate(float mat[static 9], float x, float y);
void wlr_matrix_scale(float mat[static 16], float x, float y, float z); void wlr_matrix_scale(float mat[static 9], float x, float y);
void wlr_matrix_rotate(float mat[static 16], float radians); void wlr_matrix_rotate(float mat[static 9], float rad);
void wlr_matrix_mul(float mat[static 16], const float x[static 16], void wlr_matrix_multiply(float mat[static 9], const float a[static 9],
const float y[static 16]); const float b[static 9]);
void wlr_matrix_transform(float mat[static 9],
enum wl_output_transform transform);
enum wl_output_transform; void wlr_matrix_texture(float mat[static 9], int32_t width, int32_t height,
void wlr_matrix_transform(float mat[static 16],
enum wl_output_transform transform); enum wl_output_transform transform);
void wlr_matrix_texture(float mat[static 16], int32_t width, int32_t height, void wlr_matrix_project_box(float mat[static 9], const struct wlr_box *box,
enum wl_output_transform transform);
void wlr_matrix_project_box(float mat[static 16], const struct wlr_box *box,
enum wl_output_transform transform, float rotation, enum wl_output_transform transform, float rotation,
const float projection[static 16]); const float projection[static 9]);
#endif #endif

View File

@ -76,7 +76,7 @@ struct wlr_output {
// damage for cursors and fullscreen surface, in output-local coordinates // damage for cursors and fullscreen surface, in output-local coordinates
pixman_region32_t damage; pixman_region32_t damage;
bool frame_pending; bool frame_pending;
float transform_matrix[16]; float transform_matrix[9];
struct { struct {
struct wl_signal frame; struct wl_signal frame;

View File

@ -70,8 +70,8 @@ struct wlr_surface {
struct wlr_surface_state *current, *pending; struct wlr_surface_state *current, *pending;
const char *role; // the lifetime-bound role or null const char *role; // the lifetime-bound role or null
float buffer_to_surface_matrix[16]; float buffer_to_surface_matrix[9];
float surface_to_buffer_matrix[16]; float surface_to_buffer_matrix[9];
struct { struct {
struct wl_signal commit; struct wl_signal commit;
@ -109,9 +109,9 @@ struct wlr_surface *wlr_surface_create(struct wl_resource *res,
* from 0 to 1 in both dimensions. * from 0 to 1 in both dimensions.
*/ */
void wlr_surface_get_matrix(struct wlr_surface *surface, void wlr_surface_get_matrix(struct wlr_surface *surface,
float mat[static 16], float mat[static 9],
const float projection[static 16], const float projection[static 9],
const float transform[static 16]); const float transform[static 9]);
/** /**

View File

@ -85,11 +85,13 @@ static void init_default_shaders() {
if (!compile_program(quad_vertex_src, quad_fragment_src, &shaders.quad)) { if (!compile_program(quad_vertex_src, quad_fragment_src, &shaders.quad)) {
goto error; goto error;
} }
if (!compile_program(quad_vertex_src, ellipse_fragment_src, &shaders.ellipse)) { if (!compile_program(quad_vertex_src, ellipse_fragment_src,
&shaders.ellipse)) {
goto error; goto error;
} }
if (glEGLImageTargetTexture2DOES) { if (glEGLImageTargetTexture2DOES) {
if (!compile_program(quad_vertex_src, fragment_src_external, &shaders.external)) { if (!compile_program(quad_vertex_src, fragment_src_external,
&shaders.external)) {
goto error; goto error;
} }
} }
@ -170,16 +172,16 @@ static void draw_quad() {
GL_CALL(glDisableVertexAttribArray(1)); GL_CALL(glDisableVertexAttribArray(1));
} }
static bool wlr_gles2_render_texture(struct wlr_renderer *wlr_renderer, static bool wlr_gles2_render_texture_with_matrix(
struct wlr_texture *texture, const float matrix[static 16], struct wlr_renderer *wlr_renderer, struct wlr_texture *texture,
float alpha) { const float matrix[static 9], float alpha) {
if (!texture || !texture->valid) { if (!texture || !texture->valid) {
wlr_log(L_ERROR, "attempt to render invalid texture"); wlr_log(L_ERROR, "attempt to render invalid texture");
return false; return false;
} }
wlr_texture_bind(texture); wlr_texture_bind(texture);
GL_CALL(glUniformMatrix4fv(0, 1, GL_FALSE, matrix)); GL_CALL(glUniformMatrix3fv(0, 1, GL_FALSE, matrix));
GL_CALL(glUniform1f(2, alpha)); GL_CALL(glUniform1f(2, alpha));
draw_quad(); draw_quad();
return true; return true;
@ -187,17 +189,17 @@ static bool wlr_gles2_render_texture(struct wlr_renderer *wlr_renderer,
static void wlr_gles2_render_quad(struct wlr_renderer *wlr_renderer, static void wlr_gles2_render_quad(struct wlr_renderer *wlr_renderer,
const float color[static 4], const float matrix[static 16]) { const float color[static 4], const float matrix[static 9]) {
GL_CALL(glUseProgram(shaders.quad)); GL_CALL(glUseProgram(shaders.quad));
GL_CALL(glUniformMatrix4fv(0, 1, GL_FALSE, matrix)); GL_CALL(glUniformMatrix3fv(0, 1, GL_FALSE, matrix));
GL_CALL(glUniform4f(1, color[0], color[1], color[2], color[3])); GL_CALL(glUniform4f(1, color[0], color[1], color[2], color[3]));
draw_quad(); draw_quad();
} }
static void wlr_gles2_render_ellipse(struct wlr_renderer *wlr_renderer, static void wlr_gles2_render_ellipse(struct wlr_renderer *wlr_renderer,
const float color[static 4], const float matrix[static 16]) { const float color[static 4], const float matrix[static 9]) {
GL_CALL(glUseProgram(shaders.ellipse)); GL_CALL(glUseProgram(shaders.ellipse));
GL_CALL(glUniformMatrix4fv(0, 1, GL_TRUE, matrix)); GL_CALL(glUniformMatrix3fv(0, 1, GL_TRUE, matrix));
GL_CALL(glUniform4f(1, color[0], color[1], color[2], color[3])); GL_CALL(glUniform4f(1, color[0], color[1], color[2], color[3]));
draw_quad(); draw_quad();
} }
@ -258,7 +260,7 @@ static struct wlr_renderer_impl wlr_renderer_impl = {
.clear = wlr_gles2_clear, .clear = wlr_gles2_clear,
.scissor = wlr_gles2_scissor, .scissor = wlr_gles2_scissor,
.texture_create = wlr_gles2_texture_create, .texture_create = wlr_gles2_texture_create,
.render_with_matrix = wlr_gles2_render_texture, .render_texture_with_matrix = wlr_gles2_render_texture_with_matrix,
.render_quad = wlr_gles2_render_quad, .render_quad = wlr_gles2_render_quad,
.render_ellipse = wlr_gles2_render_ellipse, .render_ellipse = wlr_gles2_render_ellipse,
.formats = wlr_gles2_formats, .formats = wlr_gles2_formats,

View File

@ -3,29 +3,29 @@
// Colored quads // Colored quads
const GLchar quad_vertex_src[] = const GLchar quad_vertex_src[] =
"uniform mat4 proj;" "uniform mat3 proj;"
"uniform vec4 color;" "uniform vec4 color;"
"attribute vec2 pos;" "attribute vec2 pos;"
"attribute vec2 texcoord;" "attribute vec2 texcoord;"
"varying vec4 v_color;" "varying vec4 v_color;"
"varying vec2 v_texcoord;" "varying vec2 v_texcoord;"
"mat4 transpose(in mat4 inMatrix) {" ""
" vec4 i0 = inMatrix[0];" "mat3 transpose(in mat3 inMatrix) {"
" vec4 i1 = inMatrix[1];" " vec3 i0 = inMatrix[0];"
" vec4 i2 = inMatrix[2];" " vec3 i1 = inMatrix[1];"
" vec4 i3 = inMatrix[3];" " vec3 i2 = inMatrix[2];"
" mat4 outMatrix = mat4(" " mat3 outMatrix = mat3("
" vec4(i0.x, i1.x, i2.x, i3.x)," " vec3(i0.x, i1.x, i2.x),"
" vec4(i0.y, i1.y, i2.y, i3.y)," " vec3(i0.y, i1.y, i2.y),"
" vec4(i0.z, i1.z, i2.z, i3.z)," " vec3(i0.z, i1.z, i2.z)"
" vec4(i0.w, i1.w, i2.w, i3.w)" " );"
" );" " return outMatrix;"
" return outMatrix;"
"}" "}"
""
"void main() {" "void main() {"
" gl_Position = transpose(proj) * vec4(pos, 0.0, 1.0);" " gl_Position = vec4(transpose(proj) * vec3(pos, 1.0), 1.0);"
" v_color = color;" " v_color = color;"
" v_texcoord = texcoord;" " v_texcoord = texcoord;"
"}"; "}";
const GLchar quad_fragment_src[] = const GLchar quad_fragment_src[] =
@ -49,26 +49,25 @@ const GLchar ellipse_fragment_src[] =
// Textured quads // Textured quads
const GLchar vertex_src[] = const GLchar vertex_src[] =
"uniform mat4 proj;" "uniform mat3 proj;"
"attribute vec2 pos;" "attribute vec2 pos;"
"attribute vec2 texcoord;" "attribute vec2 texcoord;"
"varying vec2 v_texcoord;" "varying vec2 v_texcoord;"
"mat4 transpose(in mat4 inMatrix) {"
" vec4 i0 = inMatrix[0];"
" vec4 i1 = inMatrix[1];"
" vec4 i2 = inMatrix[2];"
" vec4 i3 = inMatrix[3];"
" mat4 outMatrix = mat4("
" vec4(i0.x, i1.x, i2.x, i3.x),"
" vec4(i0.y, i1.y, i2.y, i3.y),"
" vec4(i0.z, i1.z, i2.z, i3.z),"
" vec4(i0.w, i1.w, i2.w, i3.w)"
" );"
"" ""
" return outMatrix;" "mat3 transpose(in mat3 inMatrix) {"
" vec3 i0 = inMatrix[0];"
" vec3 i1 = inMatrix[1];"
" vec3 i2 = inMatrix[2];"
" mat3 outMatrix = mat3("
" vec3(i0.x, i1.x, i2.x),"
" vec3(i0.y, i1.y, i2.y),"
" vec3(i0.z, i1.z, i2.z)"
" );"
" return outMatrix;"
"}" "}"
""
"void main() {" "void main() {"
" gl_Position = transpose(proj) * vec4(pos, 0.0, 1.0);" " gl_Position = vec4(transpose(proj) * vec3(pos, 1.0), 1.0);"
" v_texcoord = texcoord;" " v_texcoord = texcoord;"
"}"; "}";
@ -87,8 +86,8 @@ const GLchar fragment_src_rgbx[] =
"uniform sampler2D tex;" "uniform sampler2D tex;"
"uniform float alpha;" "uniform float alpha;"
"void main() {" "void main() {"
" gl_FragColor.rgb = alpha * texture2D(tex, v_texcoord).rgb;" " gl_FragColor.rgb = alpha * texture2D(tex, v_texcoord).rgb;"
" gl_FragColor.a = alpha;" " gl_FragColor.a = alpha;"
"}"; "}";
const GLchar fragment_src_external[] = const GLchar fragment_src_external[] =
@ -97,6 +96,6 @@ const GLchar fragment_src_external[] =
"varying vec2 v_texcoord;" "varying vec2 v_texcoord;"
"uniform samplerExternalOES texture0;" "uniform samplerExternalOES texture0;"
"void main() {" "void main() {"
" vec4 col = texture2D(texture0, v_texcoord);" " vec4 col = texture2D(texture0, v_texcoord);"
" gl_FragColor = vec4(col.rgb, col.a);" " gl_FragColor = vec4(col.rgb, col.a);"
"}"; "}";

View File

@ -227,16 +227,13 @@ static bool gles2_texture_upload_eglimage(struct wlr_texture *wlr_tex,
} }
static void gles2_texture_get_matrix(struct wlr_texture *_texture, static void gles2_texture_get_matrix(struct wlr_texture *_texture,
float mat[static 16], const float projection[static 16], int x, int y) { float mat[static 9], const float projection[static 9], int x, int y) {
struct wlr_gles2_texture *texture = (struct wlr_gles2_texture *)_texture; struct wlr_gles2_texture *texture = (struct wlr_gles2_texture *)_texture;
float world[16];
wlr_matrix_identity(mat); wlr_matrix_identity(mat);
wlr_matrix_translate(world, x, y, 0); wlr_matrix_translate(mat, x, y);
wlr_matrix_mul(mat, mat, world); wlr_matrix_scale(mat, texture->wlr_texture.width,
wlr_matrix_scale(world, texture->wlr_texture.height);
texture->wlr_texture.width, texture->wlr_texture.height, 1); wlr_matrix_multiply(mat, projection, mat);
wlr_matrix_mul(mat, mat, world);
wlr_matrix_mul(mat, projection, mat);
} }
static void gles2_texture_get_buffer_size(struct wlr_texture *texture, struct static void gles2_texture_get_buffer_size(struct wlr_texture *texture, struct

View File

@ -35,19 +35,19 @@ struct wlr_texture *wlr_render_texture_create(struct wlr_renderer *r) {
return r->impl->texture_create(r); return r->impl->texture_create(r);
} }
bool wlr_render_with_matrix(struct wlr_renderer *r, bool wlr_render_texture_with_matrix(struct wlr_renderer *r,
struct wlr_texture *texture, const float matrix[static 16], struct wlr_texture *texture, const float matrix[static 9],
float alpha) { float alpha) {
return r->impl->render_with_matrix(r, texture, matrix, alpha); return r->impl->render_texture_with_matrix(r, texture, matrix, alpha);
} }
void wlr_render_colored_quad(struct wlr_renderer *r, void wlr_render_colored_quad(struct wlr_renderer *r,
const float color[static 4], const float matrix[static 16]) { const float color[static 4], const float matrix[static 9]) {
r->impl->render_quad(r, color, matrix); r->impl->render_quad(r, color, matrix);
} }
void wlr_render_colored_ellipse(struct wlr_renderer *r, void wlr_render_colored_ellipse(struct wlr_renderer *r,
const float color[static 4], const float matrix[static 16]) { const float color[static 4], const float matrix[static 9]) {
r->impl->render_ellipse(r, color, matrix); r->impl->render_ellipse(r, color, matrix);
} }

View File

@ -54,7 +54,7 @@ bool wlr_texture_upload_eglimage(struct wlr_texture *texture,
} }
void wlr_texture_get_matrix(struct wlr_texture *texture, void wlr_texture_get_matrix(struct wlr_texture *texture,
float mat[static 16], const float projection[static 16], int x, int y) { float mat[static 9], const float projection[static 9], int x, int y) {
texture->impl->get_matrix(texture, mat, projection, x, y); texture->impl->get_matrix(texture, mat, projection, x, y);
} }

View File

@ -287,7 +287,7 @@ static void render_surface(struct wlr_surface *surface, double lx, double ly,
goto damage_finish; goto damage_finish;
} }
float matrix[16]; float matrix[9];
enum wl_output_transform transform = enum wl_output_transform transform =
wlr_output_transform_invert(surface->current->transform); wlr_output_transform_invert(surface->current->transform);
wlr_matrix_project_box(matrix, &box, transform, rotation, wlr_matrix_project_box(matrix, &box, transform, rotation,
@ -297,7 +297,7 @@ static void render_surface(struct wlr_surface *surface, double lx, double ly,
pixman_box32_t *rects = pixman_region32_rectangles(&damage, &nrects); pixman_box32_t *rects = pixman_region32_rectangles(&damage, &nrects);
for (int i = 0; i < nrects; ++i) { for (int i = 0; i < nrects; ++i) {
scissor_output(output, &rects[i]); scissor_output(output, &rects[i]);
wlr_render_with_matrix(renderer, surface->texture, matrix, data->alpha); wlr_render_texture_with_matrix(renderer, surface->texture, matrix, data->alpha);
} }
damage_finish: damage_finish:
@ -353,7 +353,7 @@ static void render_decorations(struct roots_view *view,
goto damage_finish; goto damage_finish;
} }
float matrix[16]; float matrix[9];
wlr_matrix_project_box(matrix, &box, WL_OUTPUT_TRANSFORM_NORMAL, wlr_matrix_project_box(matrix, &box, WL_OUTPUT_TRANSFORM_NORMAL,
view->rotation, output->wlr_output->transform_matrix); view->rotation, output->wlr_output->transform_matrix);
float color[] = { 0.2, 0.2, 0.2, view->alpha }; float color[] = { 0.2, 0.2, 0.2, view->alpha };

View File

@ -5,143 +5,113 @@
#include <wlr/types/wlr_box.h> #include <wlr/types/wlr_box.h>
#include <wlr/types/wlr_output.h> #include <wlr/types/wlr_output.h>
/* Obtains the index for the given row/column */ void wlr_matrix_identity(float mat[static 9]) {
static inline int mind(int row, int col) { static const float identity[9] = {
return (row - 1) * 4 + col - 1; 1.0f, 0.0f, 0.0f,
} 0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 1.0f,
void wlr_matrix_identity(float mat[static 16]) {
static const float identity[16] = {
1.0f, 0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f,
}; };
memcpy(mat, identity, sizeof(identity)); memcpy(mat, identity, sizeof(identity));
} }
void wlr_matrix_translate(float mat[static 16], float x, float y, float z) { void wlr_matrix_multiply(float mat[static 9], const float a[static 9],
wlr_matrix_identity(mat); const float b[static 9]) {
mat[mind(1, 4)] = x; float product[9];
mat[mind(2, 4)] = y;
mat[mind(3, 4)] = z;
}
void wlr_matrix_scale(float mat[static 16], float x, float y, float z) { product[0] = a[0]*b[0] + a[1]*b[3] + a[2]*b[6];
wlr_matrix_identity(mat); product[1] = a[0]*b[1] + a[1]*b[4] + a[2]*b[7];
mat[mind(1, 1)] = x; product[2] = a[0]*b[2] + a[1]*b[5] + a[2]*b[8];
mat[mind(2, 2)] = y;
mat[mind(3, 3)] = z;
}
void wlr_matrix_rotate(float mat[static 16], float radians) { product[3] = a[3]*b[0] + a[4]*b[3] + a[5]*b[6];
wlr_matrix_identity(mat); product[4] = a[3]*b[1] + a[4]*b[4] + a[5]*b[7];
float _cos = cosf(radians); product[5] = a[3]*b[2] + a[4]*b[5] + a[5]*b[8];
float _sin = sinf(radians);
mat[mind(1, 1)] = _cos;
mat[mind(1, 2)] = _sin;
mat[mind(2, 1)] = -_sin;
mat[mind(2, 2)] = _cos;
}
void wlr_matrix_mul(float mat[static 16], const float x[static 16], product[6] = a[6]*b[0] + a[7]*b[3] + a[8]*b[6];
const float y[static 16]) { product[7] = a[6]*b[1] + a[7]*b[4] + a[8]*b[7];
float product[16] = { product[8] = a[6]*b[2] + a[7]*b[5] + a[8]*b[8];
x[mind(1, 1)] * y[mind(1, 1)] + x[mind(1, 2)] * y[mind(2, 1)] +
x[mind(1, 3)] * y[mind(3, 1)] + x[mind(1, 4)] * y[mind(4, 1)],
x[mind(1, 1)] * y[mind(1, 2)] + x[mind(1, 2)] * y[mind(2, 2)] +
x[mind(1, 3)] * y[mind(3, 2)] + x[mind(1, 4)] * y[mind(4, 2)],
x[mind(1, 1)] * y[mind(1, 3)] + x[mind(1, 2)] * y[mind(2, 3)] +
x[mind(1, 3)] * y[mind(3, 3)] + x[mind(1, 4)] * y[mind(4, 3)],
x[mind(1, 1)] * y[mind(1, 4)] + x[mind(1, 2)] * y[mind(2, 4)] +
x[mind(1, 4)] * y[mind(3, 4)] + x[mind(1, 4)] * y[mind(4, 4)],
x[mind(2, 1)] * y[mind(1, 1)] + x[mind(2, 2)] * y[mind(2, 1)] +
x[mind(2, 3)] * y[mind(3, 1)] + x[mind(2, 4)] * y[mind(4, 1)],
x[mind(2, 1)] * y[mind(1, 2)] + x[mind(2, 2)] * y[mind(2, 2)] +
x[mind(2, 3)] * y[mind(3, 2)] + x[mind(2, 4)] * y[mind(4, 2)],
x[mind(2, 1)] * y[mind(1, 3)] + x[mind(2, 2)] * y[mind(2, 3)] +
x[mind(2, 3)] * y[mind(3, 3)] + x[mind(2, 4)] * y[mind(4, 3)],
x[mind(2, 1)] * y[mind(1, 4)] + x[mind(2, 2)] * y[mind(2, 4)] +
x[mind(2, 4)] * y[mind(3, 4)] + x[mind(2, 4)] * y[mind(4, 4)],
x[mind(3, 1)] * y[mind(1, 1)] + x[mind(3, 2)] * y[mind(2, 1)] +
x[mind(3, 3)] * y[mind(3, 1)] + x[mind(3, 4)] * y[mind(4, 1)],
x[mind(3, 1)] * y[mind(1, 2)] + x[mind(3, 2)] * y[mind(2, 2)] +
x[mind(3, 3)] * y[mind(3, 2)] + x[mind(3, 4)] * y[mind(4, 2)],
x[mind(3, 1)] * y[mind(1, 3)] + x[mind(3, 2)] * y[mind(2, 3)] +
x[mind(3, 3)] * y[mind(3, 3)] + x[mind(3, 4)] * y[mind(4, 3)],
x[mind(3, 1)] * y[mind(1, 4)] + x[mind(3, 2)] * y[mind(2, 4)] +
x[mind(3, 4)] * y[mind(3, 4)] + x[mind(3, 4)] * y[mind(4, 4)],
x[mind(4, 1)] * y[mind(1, 1)] + x[mind(4, 2)] * y[mind(2, 1)] +
x[mind(4, 3)] * y[mind(3, 1)] + x[mind(4, 4)] * y[mind(4, 1)],
x[mind(4, 1)] * y[mind(1, 2)] + x[mind(4, 2)] * y[mind(2, 2)] +
x[mind(4, 3)] * y[mind(3, 2)] + x[mind(4, 4)] * y[mind(4, 2)],
x[mind(4, 1)] * y[mind(1, 3)] + x[mind(4, 2)] * y[mind(2, 3)] +
x[mind(4, 3)] * y[mind(3, 3)] + x[mind(4, 4)] * y[mind(4, 3)],
x[mind(4, 1)] * y[mind(1, 4)] + x[mind(4, 2)] * y[mind(2, 4)] +
x[mind(4, 4)] * y[mind(3, 4)] + x[mind(4, 4)] * y[mind(4, 4)],
};
memcpy(mat, product, sizeof(product)); memcpy(mat, product, sizeof(product));
} }
static const float transforms[][4] = { void wlr_matrix_translate(float mat[static 9], float x, float y) {
float translate[9] = {
1.0f, 0.0f, x,
0.0f, 1.0f, y,
0.0f, 0.0f, 1.0f,
};
wlr_matrix_multiply(mat, mat, translate);
}
void wlr_matrix_scale(float mat[static 9], float x, float y) {
float scale[9] = {
x, 0.0f, 0.0f,
0.0f, y, 0.0f,
0.0f, 0.0f, 1.0f,
};
wlr_matrix_multiply(mat, mat, scale);
}
void wlr_matrix_rotate(float mat[static 9], float rad) {
float rotate[9] = {
cos(rad), -sin(rad), 0.0f,
sin(rad), cos(rad), 0.0f,
0.0f, 0.0f, 1.0f,
};
wlr_matrix_multiply(mat, mat, rotate);
}
static const float transforms[][9] = {
[WL_OUTPUT_TRANSFORM_NORMAL] = { [WL_OUTPUT_TRANSFORM_NORMAL] = {
1.0f, 0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 1.0f,
}, },
[WL_OUTPUT_TRANSFORM_90] = { [WL_OUTPUT_TRANSFORM_90] = {
0.0f, -1.0f, 0.0f, -1.0f, 0.0f,
1.0f, 0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f,
}, },
[WL_OUTPUT_TRANSFORM_180] = { [WL_OUTPUT_TRANSFORM_180] = {
-1.0f, 0.0f, -1.0f, 0.0f, 0.0f,
0.0f, -1.0f, 0.0f, -1.0f, 0.0f,
0.0f, 0.0f, 1.0f,
}, },
[WL_OUTPUT_TRANSFORM_270] = { [WL_OUTPUT_TRANSFORM_270] = {
0.0f, 1.0f, 0.0f, 1.0f, 0.0f,
-1.0f, 0.0f, -1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f,
}, },
[WL_OUTPUT_TRANSFORM_FLIPPED] = { [WL_OUTPUT_TRANSFORM_FLIPPED] = {
-1.0f, 0.0f, -1.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 1.0f,
}, },
[WL_OUTPUT_TRANSFORM_FLIPPED_90] = { [WL_OUTPUT_TRANSFORM_FLIPPED_90] = {
0.0f, -1.0f, 0.0f, -1.0f, 0.0f,
-1.0f, 0.0f, -1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f,
}, },
[WL_OUTPUT_TRANSFORM_FLIPPED_180] = { [WL_OUTPUT_TRANSFORM_FLIPPED_180] = {
1.0f, 0.0f, 1.0f, 0.0f, 0.0f,
0.0f, -1.0f, 0.0f, -1.0f, 0.0f,
0.0f, 0.0f, 1.0f,
}, },
[WL_OUTPUT_TRANSFORM_FLIPPED_270] = { [WL_OUTPUT_TRANSFORM_FLIPPED_270] = {
0.0f, 1.0f, 0.0f, 1.0f, 0.0f,
1.0f, 0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f,
}, },
}; };
void wlr_matrix_transform(float mat[static 16], void wlr_matrix_transform(float mat[static 9],
enum wl_output_transform transform) { enum wl_output_transform transform) {
memset(mat, 0, sizeof(*mat) * 16); wlr_matrix_multiply(mat, mat, transforms[transform]);
const float *t = transforms[transform];
// Rotation + reflection
mat[0] = t[0];
mat[1] = t[1];
mat[4] = t[2];
mat[5] = t[3];
// Identity
mat[10] = 1.0f;
mat[15] = 1.0f;
} }
// Equivilent to glOrtho(0, width, 0, height, 1, -1) with the transform applied // Equivilent to glOrtho(0, width, 0, height, 1, -1) with the transform applied
void wlr_matrix_texture(float mat[static 16], int32_t width, int32_t height, void wlr_matrix_texture(float mat[static 9], int32_t width, int32_t height,
enum wl_output_transform transform) { enum wl_output_transform transform) {
memset(mat, 0, sizeof(*mat) * 16); memset(mat, 0, sizeof(*mat) * 9);
const float *t = transforms[transform]; const float *t = transforms[transform];
float x = 2.0f / width; float x = 2.0f / width;
@ -150,62 +120,41 @@ void wlr_matrix_texture(float mat[static 16], int32_t width, int32_t height,
// Rotation + reflection // Rotation + reflection
mat[0] = x * t[0]; mat[0] = x * t[0];
mat[1] = x * t[1]; mat[1] = x * t[1];
mat[4] = y * -t[2]; mat[3] = y * -t[3];
mat[5] = y * -t[3]; mat[4] = y * -t[4];
// Translation // Translation
mat[3] = -copysign(1.0f, mat[0] + mat[1]); mat[2] = -copysign(1.0f, mat[0] + mat[1]);
mat[7] = -copysign(1.0f, mat[4] + mat[5]); mat[5] = -copysign(1.0f, mat[3] + mat[4]);
// Identity // Identity
mat[10] = 1.0f; mat[8] = 1.0f;
mat[15] = 1.0f;
} }
void wlr_matrix_project_box(float mat[static 16], const struct wlr_box *box, void wlr_matrix_project_box(float mat[static 9], const struct wlr_box *box,
enum wl_output_transform transform, float rotation, enum wl_output_transform transform, float rotation,
const float projection[static 16]) { const float projection[static 9]) {
int x = box->x; int x = box->x;
int y = box->y; int y = box->y;
int width = box->width; int width = box->width;
int height = box->height; int height = box->height;
wlr_matrix_translate(mat, x, y, 0); wlr_matrix_identity(mat);
wlr_matrix_translate(mat, x, y);
if (rotation != 0) { if (rotation != 0) {
float translate_center[16]; wlr_matrix_translate(mat, width/2, height/2);
wlr_matrix_translate(translate_center, width/2, height/2, 0); wlr_matrix_rotate(mat, rotation);
wlr_matrix_translate(mat, -width/2, -height/2);
float rotate[16];
wlr_matrix_rotate(rotate, rotation);
float translate_origin[16];
wlr_matrix_translate(translate_origin, -width/2, -height/2, 0);
wlr_matrix_mul(mat, mat, translate_center);
wlr_matrix_mul(mat, mat, rotate);
wlr_matrix_mul(mat, mat, translate_origin);
} }
float scale[16]; wlr_matrix_scale(mat, width, height);
wlr_matrix_scale(scale, width, height, 1);
wlr_matrix_mul(mat, mat, scale);
if (transform != WL_OUTPUT_TRANSFORM_NORMAL) { if (transform != WL_OUTPUT_TRANSFORM_NORMAL) {
float surface_translate_center[16]; wlr_matrix_translate(mat, 0.5, 0.5);
wlr_matrix_translate(surface_translate_center, 0.5, 0.5, 0); wlr_matrix_transform(mat, transform);
wlr_matrix_translate(mat, -0.5, -0.5);
float surface_transform[16];
wlr_matrix_transform(surface_transform, transform);
float surface_translate_origin[16];
wlr_matrix_translate(surface_translate_origin, -0.5, -0.5, 0);
wlr_matrix_mul(mat, mat, surface_translate_center);
wlr_matrix_mul(mat, mat, surface_transform);
wlr_matrix_mul(mat, mat, surface_translate_origin);
} }
wlr_matrix_mul(mat, projection, mat); wlr_matrix_multiply(mat, projection, mat);
} }

View File

@ -375,7 +375,7 @@ static void output_fullscreen_surface_render(struct wlr_output *output,
struct wlr_box box; struct wlr_box box;
output_fullscreen_surface_get_box(output, surface, &box); output_fullscreen_surface_get_box(output, surface, &box);
float matrix[16]; float matrix[9];
enum wl_output_transform transform = enum wl_output_transform transform =
wlr_output_transform_invert(surface->current->transform); wlr_output_transform_invert(surface->current->transform);
wlr_matrix_project_box(matrix, &box, transform, 0, wlr_matrix_project_box(matrix, &box, transform, 0,
@ -386,7 +386,7 @@ static void output_fullscreen_surface_render(struct wlr_output *output,
for (int i = 0; i < nrects; ++i) { for (int i = 0; i < nrects; ++i) {
output_scissor(output, &rects[i]); output_scissor(output, &rects[i]);
wlr_renderer_clear(renderer, (float[]){0, 0, 0, 0}); wlr_renderer_clear(renderer, (float[]){0, 0, 0, 0});
wlr_render_with_matrix(surface->renderer, surface->texture, matrix, 1.0f); wlr_render_texture_with_matrix(surface->renderer, surface->texture, matrix, 1.0f);
} }
wlr_renderer_scissor(renderer, NULL); wlr_renderer_scissor(renderer, NULL);
@ -435,7 +435,7 @@ static void output_cursor_render(struct wlr_output_cursor *cursor,
goto surface_damage_finish; goto surface_damage_finish;
} }
float matrix[16]; float matrix[9];
wlr_matrix_project_box(matrix, &box, WL_OUTPUT_TRANSFORM_NORMAL, 0, wlr_matrix_project_box(matrix, &box, WL_OUTPUT_TRANSFORM_NORMAL, 0,
cursor->output->transform_matrix); cursor->output->transform_matrix);
@ -443,7 +443,7 @@ static void output_cursor_render(struct wlr_output_cursor *cursor,
pixman_box32_t *rects = pixman_region32_rectangles(&surface_damage, &nrects); pixman_box32_t *rects = pixman_region32_rectangles(&surface_damage, &nrects);
for (int i = 0; i < nrects; ++i) { for (int i = 0; i < nrects; ++i) {
output_scissor(cursor->output, &rects[i]); output_scissor(cursor->output, &rects[i]);
wlr_render_with_matrix(renderer, texture, matrix, 1.0f); wlr_render_texture_with_matrix(renderer, texture, matrix, 1.0f);
} }
wlr_renderer_scissor(renderer, NULL); wlr_renderer_scissor(renderer, NULL);

View File

@ -624,20 +624,16 @@ struct wlr_surface *wlr_surface_create(struct wl_resource *res,
return surface; return surface;
} }
void wlr_surface_get_matrix(struct wlr_surface *surface, void wlr_surface_get_matrix(struct wlr_surface *surface, float mat[static 9],
float mat[static 16], const float projection[static 9], const float transform[static 9]) {
const float projection[static 16],
const float transform[static 16]) {
int width = surface->texture->width; int width = surface->texture->width;
int height = surface->texture->height; int height = surface->texture->height;
float scale[16];
wlr_matrix_identity(mat); wlr_matrix_identity(mat);
if (transform) { if (transform != NULL) {
wlr_matrix_mul(mat, mat, transform); wlr_matrix_multiply(mat, mat, transform);
} }
wlr_matrix_scale(scale, width, height, 1); wlr_matrix_scale(mat, width, height);
wlr_matrix_mul(mat, mat, scale); wlr_matrix_multiply(mat, projection, mat);
wlr_matrix_mul(mat, projection, mat);
} }
bool wlr_surface_has_buffer(struct wlr_surface *surface) { bool wlr_surface_has_buffer(struct wlr_surface *surface) {