nordic-dev.net/wlroots
2
0
Fork 0
mirror of https://gitlab.freedesktop.org/wlroots/wlroots.git synced 2024-11-21 22:52:20 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #722 from emersion/matrix-redesign

Browse Source 
Matrix redesign
This commit is contained in:
Drew DeVault 2018-03-17 15:22:00 -04:00 committed by GitHub
commit 1956d3cedb
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
27 changed files with 334 additions and 468 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
backend/drm/drm.c
View File

@ -17,7 +17,7 @@
#include <wlr/interfaces/wlr_output.h>
#include <wlr/render.h>
#include <wlr/render/gles2.h>
#include <wlr/render/matrix.h>
#include <wlr/types/wlr_matrix.h>
#include <wlr/util/log.h>
#include <xf86drm.h>
#include <xf86drmMode.h>
@ -587,8 +587,8 @@ static bool wlr_drm_connector_set_cursor(struct wlr_output *output,
enum wl_output_transform transform = wlr_output_transform_compose(
wlr_output_transform_invert(output->transform),
WL_OUTPUT_TRANSFORM_FLIPPED_180);
wlr_matrix_texture(plane->matrix, plane->surf.width, plane->surf.height,
transform);
wlr_matrix_projection(plane->matrix, plane->surf.width,
plane->surf.height, transform);
plane->wlr_tex =
wlr_render_texture_create(plane->surf.renderer->wlr_rend);
@ -647,10 +647,8 @@ static bool wlr_drm_connector_set_cursor(struct wlr_output *output,
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
float matrix[16];
wlr_texture_get_matrix(plane->wlr_tex, &matrix, &plane->matrix, 0, 0);
wlr_render_with_matrix(plane->surf.renderer->wlr_rend, plane->wlr_tex,
&matrix, 1.0f);
wlr_render_texture(plane->surf.renderer->wlr_rend, plane->wlr_tex,
plane->matrix, 0, 0, 1.0f);
glFinish();
glPixelStorei(GL_UNPACK_ROW_LENGTH_EXT, bo_stride);

22
backend/drm/renderer.c
View File

@ -1,3 +1,4 @@
#include <assert.h>
#include <EGL/egl.h>
#include <EGL/eglext.h>
#include <gbm.h>
@ -9,7 +10,7 @@
#include <wlr/render.h>
#include <wlr/render/egl.h>
#include <wlr/render/gles2.h>
#include <wlr/render/matrix.h>
#include <wlr/types/wlr_matrix.h>
#include <wlr/util/log.h>
#include "backend/drm/drm.h"
#include "glapi.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);
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,
[3] = -1.0f,
[5] = 2.0f,
[7] = -1.0f,
[10] = 1.0f,
[15] = 1.0f,
[2] = -1.0f,
[4] = 2.0f,
[5] = -1.0f,
[8] = 1.0f,
};
glViewport(0, 0, dest->width, dest->height);
glClearColor(0.0, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
wlr_render_with_matrix(dest->renderer->wlr_rend, tex, &matrix, 1.0f);
wlr_renderer_clear(dest->renderer->wlr_rend, color);
wlr_render_texture_with_matrix(dest->renderer->wlr_rend, tex, mat, 1.0f);
return wlr_drm_surface_swap_buffers(dest, NULL);
}

2
examples/multi-pointer.c
View File

@ -11,7 +11,7 @@
#include <wayland-server-protocol.h>
#include <xkbcommon/xkbcommon.h>
#include <GLES2/gl2.h>
#include <wlr/render/matrix.h>
#include <wlr/types/wlr_matrix.h>
#include <wlr/render/gles2.h>
#include <wlr/render.h>
#include <wlr/backend.h>

12
examples/output-layout.c
View File

@ -11,7 +11,7 @@
#include <wayland-server-protocol.h>
#include <xkbcommon/xkbcommon.h>
#include <GLES2/gl2.h>
#include <wlr/render/matrix.h>
#include <wlr/types/wlr_matrix.h>
#include <wlr/render/gles2.h>
#include <wlr/render.h>
#include <wlr/util/log.h>
@ -102,7 +102,7 @@ static void handle_output_frame(struct output_state *output,
wlr_output_make_current(wlr_output, NULL);
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});
animate_cat(sample, output->output);
@ -111,18 +111,14 @@ static void handle_output_frame(struct output_state *output,
.width = 128, .height = 128,
};
if (wlr_output_layout_intersects(sample->layout, output->output, &box)) {
float matrix[16];
// transform global coordinates to local coordinates
double local_x = sample->x_offs;
double local_y = sample->y_offs;
wlr_output_layout_output_coords(sample->layout, output->output,
&local_x, &local_y);
wlr_texture_get_matrix(sample->cat_texture, &matrix,
&wlr_output->transform_matrix, local_x, local_y);
wlr_render_with_matrix(sample->renderer,
sample->cat_texture, &matrix, 1.0f);
wlr_render_texture(sample->renderer, sample->cat_texture,
wlr_output->transform_matrix, local_x, local_y, 1.0f);
}
wlr_renderer_end(sample->renderer);

2
examples/pointer.c
View File

@ -11,7 +11,7 @@
#include <wayland-server-protocol.h>
#include <xkbcommon/xkbcommon.h>
#include <GLES2/gl2.h>
#include <wlr/render/matrix.h>
#include <wlr/types/wlr_matrix.h>
#include <wlr/render/gles2.h>
#include <wlr/render.h>
#include <wlr/backend.h>

11
examples/rotation.c
View File

@ -10,7 +10,7 @@
#include <wayland-server-protocol.h>
#include <xkbcommon/xkbcommon.h>
#include <GLES2/gl2.h>
#include <wlr/render/matrix.h>
#include <wlr/types/wlr_matrix.h>
#include <wlr/render/gles2.h>
#include <wlr/render.h>
#include <wlr/backend.h>
@ -44,15 +44,12 @@ static void handle_output_frame(struct output_state *output, struct timespec *ts
wlr_output_make_current(wlr_output, NULL);
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];
for (int y = -128 + (int)odata->y_offs; y < height; y += 128) {
for (int x = -128 + (int)odata->x_offs; x < width; x += 128) {
wlr_texture_get_matrix(sample->cat_texture, &matrix,
&wlr_output->transform_matrix, x, y);
wlr_render_with_matrix(sample->renderer,
sample->cat_texture, &matrix, 1.0f);
wlr_render_texture(sample->renderer, sample->cat_texture,
wlr_output->transform_matrix, x, y, 1.0f);
}
}

23
examples/tablet.c
View File

@ -9,7 +9,7 @@
#include <wayland-server-protocol.h>
#include <xkbcommon/xkbcommon.h>
#include <GLES2/gl2.h>
#include <wlr/render/matrix.h>
#include <wlr/types/wlr_matrix.h>
#include <wlr/render/gles2.h>
#include <wlr/render.h>
#include <wlr/backend.h>
@ -47,9 +47,9 @@ static void handle_output_frame(struct output_state *output, struct timespec *ts
wlr_output_make_current(wlr_output, NULL);
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 tool_color[4] = { distance, distance, distance, 1 };
for (size_t i = 0; sample->button && i < 4; ++i) {
@ -65,9 +65,8 @@ static void handle_output_frame(struct output_state *output, struct timespec *ts
.x = left, .y = top,
.width = pad_width, .height = pad_height,
};
wlr_matrix_project_box(&matrix, &box, 0, 0,
&wlr_output->transform_matrix);
wlr_render_colored_quad(sample->renderer, &sample->pad_color, &matrix);
wlr_matrix_project_box(matrix, &box, 0, 0, wlr_output->transform_matrix);
wlr_render_colored_quad(sample->renderer, sample->pad_color, matrix);
if (sample->proximity) {
struct wlr_box box = {
@ -76,16 +75,16 @@ static void handle_output_frame(struct output_state *output, struct timespec *ts
.width = 16 * (sample->pressure + 1),
.height = 16 * (sample->pressure + 1),
};
wlr_matrix_project_box(&matrix, &box, 0, sample->ring,
&wlr_output->transform_matrix);
wlr_render_colored_quad(sample->renderer, &tool_color, &matrix);
wlr_matrix_project_box(matrix, &box, 0, sample->ring,
wlr_output->transform_matrix);
wlr_render_colored_quad(sample->renderer, tool_color, matrix);
box.x += sample->x_tilt;
box.y += sample->y_tilt;
box.width /= 2;
box.height /= 2;
wlr_matrix_project_box(&matrix, &box, 0, 0,
&wlr_output->transform_matrix);
wlr_render_colored_quad(sample->renderer, &tool_color, &matrix);
wlr_matrix_project_box(matrix, &box, 0, 0,
wlr_output->transform_matrix);
wlr_render_colored_quad(sample->renderer, tool_color, matrix);
}
wlr_renderer_end(sample->renderer);

15
examples/touch.c
View File

@ -11,7 +11,7 @@
#include <wayland-server-protocol.h>
#include <xkbcommon/xkbcommon.h>
#include <GLES2/gl2.h>
#include <wlr/render/matrix.h>
#include <wlr/types/wlr_matrix.h>
#include <wlr/render/gles2.h>
#include <wlr/render.h>
#include <wlr/backend.h>
@ -43,17 +43,14 @@ static void handle_output_frame(struct output_state *output, struct timespec *ts
wlr_output_make_current(wlr_output, NULL);
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];
struct touch_point *p;
wl_list_for_each(p, &sample->touch_points, link) {
wlr_texture_get_matrix(sample->cat_texture, &matrix,
&wlr_output->transform_matrix,
(int)(p->x * width) - sample->cat_texture->width / 2,
(int)(p->y * height) - sample->cat_texture->height / 2);
wlr_render_with_matrix(sample->renderer,
sample->cat_texture, &matrix, 1.0f);
int x = (int)(p->x * width) - sample->cat_texture->width / 2;
int y = (int)(p->y * height) - sample->cat_texture->height / 2;
wlr_render_texture(sample->renderer, sample->cat_texture,
wlr_output->transform_matrix, x, y, 1.0f);
}
wlr_renderer_end(sample->renderer);

2
include/backend/drm/drm.h
View File

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

51
include/wlr/render.h
View File

@ -13,7 +13,7 @@ struct wlr_renderer;
void wlr_renderer_begin(struct wlr_renderer *r, struct wlr_output *output);
void wlr_renderer_end(struct wlr_renderer *r);
void wlr_renderer_clear(struct wlr_renderer *r, const float (*color)[4]);
void wlr_renderer_clear(struct wlr_renderer *r, const float color[static 4]);
/**
* Defines a scissor box. Only pixels that lie within the scissor box can be
* modified by drawing functions. Providing a NULL `box` disables the scissor
@ -25,31 +25,25 @@ void wlr_renderer_scissor(struct wlr_renderer *r, struct wlr_box *box);
*/
struct wlr_texture *wlr_render_texture_create(struct wlr_renderer *r);
/**
* Renders the requested texture using the provided matrix. A typical texture
* rendering goes like so:
*
* struct wlr_renderer *renderer;
* struct wlr_texture *texture;
* float projection[16];
* float matrix[16];
* wlr_texture_get_matrix(texture, &matrix, &projection, 123, 321);
* wlr_render_with_matrix(renderer, texture, &matrix, 0.5f);
*
* This will render the texture at <123, 321> with an alpha channel of 0.5.
* Renders the requested texture.
*/
bool wlr_render_with_matrix(struct wlr_renderer *r,
struct wlr_texture *texture, const float (*matrix)[16], float alpha);
bool wlr_render_texture(struct wlr_renderer *r, struct wlr_texture *texture,
const float projection[static 9], int x, int y, float alpha);
/**
* Renders the requested texture using the provided matrix.
*/
bool wlr_render_texture_with_matrix(struct wlr_renderer *r,
struct wlr_texture *texture, const float matrix[static 9], float alpha);
/**
* Renders a solid quad in the specified color.
*/
void wlr_render_colored_quad(struct wlr_renderer *r,
const float (*color)[4], const float (*matrix)[16]);
const float color[static 4], const float matrix[static 9]);
/**
* Renders a solid ellipse in the specified color.
*/
void wlr_render_colored_ellipse(struct wlr_renderer *r,
const float (*color)[4], const float (*matrix)[16]);
const float color[static 4], const float matrix[static 9]);
/**
* Returns a list of pixel formats supported by this renderer.
*/
@ -95,22 +89,22 @@ struct wlr_texture {
* returns.
*/
bool wlr_texture_upload_pixels(struct wlr_texture *tex,
enum wl_shm_format format, int stride, int width, int height,
const unsigned char *pixels);
enum wl_shm_format format, int stride, int width, int height,
const unsigned char *pixels);
/**
* Copies pixels to this texture. The buffer is not accessed after this function
* returns. Under some circumstances, this function may re-upload the entire
* buffer - therefore, the entire buffer must be valid.
*/
bool wlr_texture_update_pixels(struct wlr_texture *surf,
enum wl_shm_format format, int stride, int x, int y,
int width, int height, const unsigned char *pixels);
enum wl_shm_format format, int stride, int x, int y,
int width, int height, const unsigned char *pixels);
/**
* Copies pixels from a wl_shm_buffer into this texture. The buffer is not
* accessed after this function returns.
*/
bool wlr_texture_upload_shm(struct wlr_texture *tex, uint32_t format,
struct wl_shm_buffer *shm);
struct wl_shm_buffer *shm);
/**
* Attaches the contents from the given wl_drm wl_buffer resource onto the
@ -132,18 +126,7 @@ bool wlr_texture_upload_dmabuf(struct wlr_texture *tex,
* must be valid.
*/
bool wlr_texture_update_shm(struct wlr_texture *surf, uint32_t format,
int x, int y, int width, int height, struct wl_shm_buffer *shm);
/**
* Prepares a matrix with the appropriate scale for the given texture and
* multiplies it with the projection, producing a matrix that the shader can
* muptlipy vertex coordinates with to get final screen coordinates.
*
* The projection matrix is assumed to be an orthographic projection of [0,
* width) and [0, height], and the x and y coordinates provided are used as
* such.
*/
void wlr_texture_get_matrix(struct wlr_texture *texture,
float (*matrix)[16], const float (*projection)[16], int x, int y);
int x, int y, int width, int height, struct wl_shm_buffer *shm);
/**
* Destroys this wlr_texture.
*/

13
include/wlr/render/interface.h
View File

@ -19,15 +19,16 @@ struct wlr_renderer {
struct wlr_renderer_impl {
void (*begin)(struct wlr_renderer *renderer, struct wlr_output *output);
void (*end)(struct wlr_renderer *renderer);
void (*clear)(struct wlr_renderer *renderer, const float (*color)[4]);
void (*clear)(struct wlr_renderer *renderer, const float color[static 4]);
void (*scissor)(struct wlr_renderer *renderer, struct wlr_box *box);
struct wlr_texture *(*texture_create)(struct wlr_renderer *renderer);
bool (*render_with_matrix)(struct wlr_renderer *renderer,
struct wlr_texture *texture, const float (*matrix)[16], float alpha);
bool (*render_texture_with_matrix)(struct wlr_renderer *renderer,
struct wlr_texture *texture, const float matrix[static 9],
float alpha);
void (*render_quad)(struct wlr_renderer *renderer,
const float (*color)[4], const float (*matrix)[16]);
const float color[static 4], const float matrix[static 9]);
void (*render_ellipse)(struct wlr_renderer *renderer,
const float (*color)[4], const float (*matrix)[16]);
const float color[static 4], const float matrix[static 9]);
const enum wl_shm_format *(*formats)(
struct wlr_renderer *renderer, size_t *len);
bool (*buffer_is_drm)(struct wlr_renderer *renderer,
@ -61,8 +62,6 @@ struct wlr_texture_impl {
uint32_t width, uint32_t height);
bool (*upload_dmabuf)(struct wlr_texture *texture,
struct wl_resource *dmabuf_resource);
void (*get_matrix)(struct wlr_texture *state,
float (*matrix)[16], const float (*projection)[16], int x, int y);
void (*get_buffer_size)(struct wlr_texture *texture,
struct wl_resource *resource, int *width, int *height);
void (*bind)(struct wlr_texture *texture);

22
include/wlr/render/matrix.h
View File

@ -1,22 +0,0 @@
#ifndef WLR_RENDER_MATRIX_H
#define WLR_RENDER_MATRIX_H
#include <stdint.h>
#include <wlr/types/wlr_box.h>
void wlr_matrix_identity(float (*output)[16]);
void wlr_matrix_translate(float (*output)[16], float x, float y, float z);
void wlr_matrix_scale(float (*output)[16], float x, float y, float z);
void wlr_matrix_rotate(float (*output)[16], float radians);
void wlr_matrix_mul(const float (*x)[16], const float (*y)[16], float (*product)[16]);
enum wl_output_transform;
void wlr_matrix_transform(float mat[static 16],
enum wl_output_transform transform);
void wlr_matrix_texture(float mat[static 16], int32_t width, int32_t height,
enum wl_output_transform transform);
void wlr_matrix_project_box(float (*mat)[16], struct wlr_box *box,
enum wl_output_transform transform, float rotation, float
(*projection)[16]);
#endif

21
include/wlr/types/wlr_matrix.h Normal file
View File

@ -0,0 +1,21 @@
#ifndef WLR_TYPES_WLR_MATRIX_H
#define WLR_TYPES_WLR_MATRIX_H
#include <wayland-server.h>
#include <wlr/types/wlr_box.h>
void wlr_matrix_identity(float mat[static 9]);
void wlr_matrix_translate(float mat[static 9], float x, float y);
void wlr_matrix_scale(float mat[static 9], float x, float y);
void wlr_matrix_rotate(float mat[static 9], float rad);
void wlr_matrix_multiply(float mat[static 9], const float a[static 9],
const float b[static 9]);
void wlr_matrix_transform(float mat[static 9],
enum wl_output_transform transform);
void wlr_matrix_projection(float mat[static 9], int width, int height,
enum wl_output_transform transform);
void wlr_matrix_project_box(float mat[static 9], const struct wlr_box *box,
enum wl_output_transform transform, float rotation,
const float projection[static 9]);
#endif

2
include/wlr/types/wlr_output.h
View File

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

17
include/wlr/types/wlr_surface.h
View File

@ -70,8 +70,8 @@ struct wlr_surface {
struct wlr_surface_state *current, *pending;
const char *role; // the lifetime-bound role or null
float buffer_to_surface_matrix[16];
float surface_to_buffer_matrix[16];
float buffer_to_surface_matrix[9];
float surface_to_buffer_matrix[9];
struct {
struct wl_signal commit;
@ -99,19 +99,6 @@ struct wlr_surface {
struct wlr_renderer;
struct wlr_surface *wlr_surface_create(struct wl_resource *res,
struct wlr_renderer *renderer);
/**
* Gets a matrix you can pass into wlr_render_with_matrix to display this
* surface. `matrix` is the output matrix, `projection` is the wlr_output
* projection matrix, and `transform` is any additional transformations you want
* to perform on the surface (or NULL/the identity matrix if you don't).
* `transform` is used before the surface is scaled, so its geometry extends
* from 0 to 1 in both dimensions.
*/
void wlr_surface_get_matrix(struct wlr_surface *surface,
float (*matrix)[16],
const float (*projection)[16],
const float (*transform)[16]);
/**
* Set the lifetime role for this surface. Returns 0 on success or -1 if the

33
render/gles2/renderer.c
View File

@ -9,7 +9,7 @@
#include <wlr/render.h>
#include <wlr/render/egl.h>
#include <wlr/render/interface.h>
#include <wlr/render/matrix.h>
#include <wlr/types/wlr_matrix.h>
#include <wlr/util/log.h>
#include "render/gles2.h"
#include "glapi.h"
@ -85,11 +85,13 @@ static void init_default_shaders() {
if (!compile_program(quad_vertex_src, quad_fragment_src, &shaders.quad)) {
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;
}
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;
}
}
@ -122,8 +124,8 @@ static void wlr_gles2_end(struct wlr_renderer *wlr_renderer) {
}
static void wlr_gles2_clear(struct wlr_renderer *wlr_renderer,
const float (*color)[4]) {
glClearColor((*color)[0], (*color)[1], (*color)[2], (*color)[3]);
const float color[static 4]) {
glClearColor(color[0], color[1], color[2], color[3]);
glClear(GL_COLOR_BUFFER_BIT);
}
@ -170,15 +172,16 @@ static void draw_quad() {
GL_CALL(glDisableVertexAttribArray(1));
}
static bool wlr_gles2_render_texture(struct wlr_renderer *wlr_renderer,
struct wlr_texture *texture, const float (*matrix)[16], float alpha) {
static bool wlr_gles2_render_texture_with_matrix(
struct wlr_renderer *wlr_renderer, struct wlr_texture *texture,
const float matrix[static 9], float alpha) {
if (!texture || !texture->valid) {
wlr_log(L_ERROR, "attempt to render invalid texture");
return false;
}
wlr_texture_bind(texture);
GL_CALL(glUniformMatrix4fv(0, 1, GL_FALSE, *matrix));
GL_CALL(glUniformMatrix3fv(0, 1, GL_TRUE, matrix));
GL_CALL(glUniform1i(1, texture->inverted_y));
GL_CALL(glUniform1f(3, alpha));
draw_quad();
@ -187,18 +190,18 @@ static bool wlr_gles2_render_texture(struct wlr_renderer *wlr_renderer,
static void wlr_gles2_render_quad(struct wlr_renderer *wlr_renderer,
const float (*color)[4], const float (*matrix)[16]) {
const float color[static 4], const float matrix[static 9]) {
GL_CALL(glUseProgram(shaders.quad));
GL_CALL(glUniformMatrix4fv(0, 1, GL_FALSE, *matrix));
GL_CALL(glUniform4f(1, (*color)[0], (*color)[1], (*color)[2], (*color)[3]));
GL_CALL(glUniformMatrix3fv(0, 1, GL_TRUE, matrix));
GL_CALL(glUniform4f(1, color[0], color[1], color[2], color[3]));
draw_quad();
}
static void wlr_gles2_render_ellipse(struct wlr_renderer *wlr_renderer,
const float (*color)[4], const float (*matrix)[16]) {
const float color[static 4], const float matrix[static 9]) {
GL_CALL(glUseProgram(shaders.ellipse));
GL_CALL(glUniformMatrix4fv(0, 1, GL_TRUE, *matrix));
GL_CALL(glUniform4f(1, (*color)[0], (*color)[1], (*color)[2], (*color)[3]));
GL_CALL(glUniformMatrix3fv(0, 1, GL_TRUE, matrix));
GL_CALL(glUniform4f(1, color[0], color[1], color[2], color[3]));
draw_quad();
}
@ -258,7 +261,7 @@ static struct wlr_renderer_impl wlr_renderer_impl = {
.clear = wlr_gles2_clear,
.scissor = wlr_gles2_scissor,
.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_ellipse = wlr_gles2_render_ellipse,
.formats = wlr_gles2_formats,

55
render/gles2/shaders.c
View File

@ -3,35 +3,24 @@
// Colored quads
const GLchar quad_vertex_src[] =
"uniform mat4 proj;"
"uniform mat3 proj;"
"uniform vec4 color;"
"attribute vec2 pos;"
"attribute vec2 texcoord;"
"varying vec4 v_color;"
"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;"
"}"
""
"void main() {"
" gl_Position = transpose(proj) * vec4(pos, 0.0, 1.0);"
" v_color = color;"
" v_texcoord = texcoord;"
" gl_Position = vec4(proj * vec3(pos, 1.0), 1.0);"
" v_color = color;"
" v_texcoord = texcoord;"
"}";
const GLchar quad_fragment_src[] =
"precision mediump float;"
"varying vec4 v_color;"
"varying vec2 v_texcoord;"
""
"void main() {"
" gl_FragColor = v_color;"
"}";
@ -41,6 +30,7 @@ const GLchar ellipse_fragment_src[] =
"precision mediump float;"
"varying vec4 v_color;"
"varying vec2 v_texcoord;"
""
"void main() {"
" float l = length(v_texcoord - vec2(0.5, 0.5));"
" if (l > 0.5) discard;"
@ -49,26 +39,14 @@ const GLchar ellipse_fragment_src[] =
// Textured quads
const GLchar vertex_src[] =
"uniform mat4 proj;"
"uniform mat3 proj;"
"uniform bool invert_y;"
"attribute vec2 pos;"
"attribute vec2 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;"
"}"
""
"void main() {"
" gl_Position = transpose(proj) * vec4(pos, 0.0, 1.0);"
" gl_Position = vec4(proj * vec3(pos, 1.0), 1.0);"
" if (invert_y) {"
" v_texcoord = vec2(texcoord.s, 1.0 - texcoord.t);"
" } else {"
@ -81,8 +59,9 @@ const GLchar fragment_src_rgba[] =
"varying vec2 v_texcoord;"
"uniform sampler2D tex;"
"uniform float alpha;"
""
"void main() {"
" gl_FragColor = alpha * texture2D(tex, v_texcoord);"
" gl_FragColor = alpha * texture2D(tex, v_texcoord);"
"}";
const GLchar fragment_src_rgbx[] =
@ -90,9 +69,10 @@ const GLchar fragment_src_rgbx[] =
"varying vec2 v_texcoord;"
"uniform sampler2D tex;"
"uniform float alpha;"
""
"void main() {"
" gl_FragColor.rgb = alpha * texture2D(tex, v_texcoord).rgb;"
" gl_FragColor.a = alpha;"
" gl_FragColor.rgb = alpha * texture2D(tex, v_texcoord).rgb;"
" gl_FragColor.a = alpha;"
"}";
const GLchar fragment_src_external[] =
@ -100,7 +80,8 @@ const GLchar fragment_src_external[] =
"precision mediump float;"
"varying vec2 v_texcoord;"
"uniform samplerExternalOES texture0;"
""
"void main() {"
" vec4 col = texture2D(texture0, v_texcoord);"
" gl_FragColor = vec4(col.rgb, col.a);"
" vec4 col = texture2D(texture0, v_texcoord);"
" gl_FragColor = vec4(col.rgb, col.a);"
"}";

19
render/gles2/texture.c
View File

@ -8,7 +8,7 @@
#include <wlr/render.h>
#include <wlr/render/egl.h>
#include <wlr/render/interface.h>
#include <wlr/render/matrix.h>
#include <wlr/types/wlr_matrix.h>
#include <wlr/util/log.h>
#include "render/gles2.h"
#include "util/signal.h"
@ -229,7 +229,6 @@ static bool gles2_texture_upload_eglimage(struct wlr_texture *wlr_tex,
return true;
}
static bool gles2_texture_upload_dmabuf(struct wlr_texture *_tex,
struct wl_resource *dmabuf_resource) {
struct wlr_gles2_texture *tex = (struct wlr_gles2_texture *)_tex;
@ -265,20 +264,6 @@ static bool gles2_texture_upload_dmabuf(struct wlr_texture *_tex,
return true;
}
static void gles2_texture_get_matrix(struct wlr_texture *_texture,
float (*matrix)[16], const float (*projection)[16], int x, int y) {
struct wlr_gles2_texture *texture = (struct wlr_gles2_texture *)_texture;
float world[16];
wlr_matrix_identity(matrix);
wlr_matrix_translate(&world, x, y, 0);
wlr_matrix_mul(matrix, &world, matrix);
wlr_matrix_scale(&world,
texture->wlr_texture.width, texture->wlr_texture.height, 1);
wlr_matrix_mul(matrix, &world, matrix);
wlr_matrix_mul(projection, matrix, matrix);
}
static bool gles2_texture_get_dmabuf_size(struct wlr_texture *texture, struct
wl_resource *resource, int *width, int *height) {
if (!wlr_dmabuf_resource_is_buffer(resource)) {
@ -292,7 +277,6 @@ static bool gles2_texture_get_dmabuf_size(struct wlr_texture *texture, struct
return true;
}
static void gles2_texture_get_buffer_size(struct wlr_texture *texture, struct
wl_resource *resource, int *width, int *height) {
struct wl_shm_buffer *buffer = wl_shm_buffer_get(resource);
@ -349,7 +333,6 @@ static struct wlr_texture_impl wlr_texture_impl = {
.upload_drm = gles2_texture_upload_drm,
.upload_dmabuf = gles2_texture_upload_dmabuf,
.upload_eglimage = gles2_texture_upload_eglimage,
.get_matrix = gles2_texture_get_matrix,
.get_buffer_size = gles2_texture_get_buffer_size,
.bind = gles2_texture_bind,
.destroy = gles2_texture_destroy,

210
render/matrix.c
View File

@ -1,210 +0,0 @@
#include <math.h>
#include <string.h>
#include <wayland-server-protocol.h>
#include <wlr/render/matrix.h>
#include <wlr/types/wlr_box.h>
#include <wlr/types/wlr_output.h>
/* Obtains the index for the given row/column */
static inline int mind(int row, int col) {
return (row - 1) * 4 + col - 1;
}
void wlr_matrix_identity(float (*output)[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(*output, identity, sizeof(identity));
}
void wlr_matrix_translate(float (*output)[16], float x, float y, float z) {
wlr_matrix_identity(output);
(*output)[mind(1, 4)] = x;
(*output)[mind(2, 4)] = y;
(*output)[mind(3, 4)] = z;
}
void wlr_matrix_scale(float (*output)[16], float x, float y, float z) {
wlr_matrix_identity(output);
(*output)[mind(1, 1)] = x;
(*output)[mind(2, 2)] = y;
(*output)[mind(3, 3)] = z;
}
void wlr_matrix_rotate(float (*output)[16], float radians) {
wlr_matrix_identity(output);
float _cos = cosf(radians);
float _sin = sinf(radians);
(*output)[mind(1, 1)] = _cos;
(*output)[mind(1, 2)] = _sin;
(*output)[mind(2, 1)] = -_sin;
(*output)[mind(2, 2)] = _cos;
}
void wlr_matrix_mul(const float (*x)[16], const float (*y)[16], float (*product)[16]) {
float _product[16] = {
(*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(*product, _product, sizeof(_product));
}
static const float transforms[][4] = {
[WL_OUTPUT_TRANSFORM_NORMAL] = {
1.0f, 0.0f,
0.0f, 1.0f,
},
[WL_OUTPUT_TRANSFORM_90] = {
0.0f, -1.0f,
1.0f, 0.0f,
},
[WL_OUTPUT_TRANSFORM_180] = {
-1.0f, 0.0f,
0.0f, -1.0f,
},
[WL_OUTPUT_TRANSFORM_270] = {
0.0f, 1.0f,
-1.0f, 0.0f,
},
[WL_OUTPUT_TRANSFORM_FLIPPED] = {
-1.0f, 0.0f,
0.0f, 1.0f,
},
[WL_OUTPUT_TRANSFORM_FLIPPED_90] = {
0.0f, -1.0f,
-1.0f, 0.0f,
},
[WL_OUTPUT_TRANSFORM_FLIPPED_180] = {
1.0f, 0.0f,
0.0f, -1.0f,
},
[WL_OUTPUT_TRANSFORM_FLIPPED_270] = {
0.0f, 1.0f,
1.0f, 0.0f,
},
};
void wlr_matrix_transform(float mat[static 16],
enum wl_output_transform transform) {
memset(mat, 0, sizeof(*mat) * 16);
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
void wlr_matrix_texture(float mat[static 16], int32_t width, int32_t height,
enum wl_output_transform transform) {
memset(mat, 0, sizeof(*mat) * 16);
const float *t = transforms[transform];
float x = 2.0f / width;
float y = 2.0f / height;
// Rotation + reflection
mat[0] = x * t[0];
mat[1] = x * t[1];
mat[4] = y * -t[2];
mat[5] = y * -t[3];
// Translation
mat[3] = -copysign(1.0f, mat[0] + mat[1]);
mat[7] = -copysign(1.0f, mat[4] + mat[5]);
// Identity
mat[10] = 1.0f;
mat[15] = 1.0f;
}
void wlr_matrix_project_box(float (*mat)[16], struct wlr_box *box,
enum wl_output_transform transform, float rotation,
float (*projection)[16]) {
int x = box->x;
int y = box->y;
int width = box->width;
int height = box->height;
wlr_matrix_translate(mat, x, y, 0);
if (rotation != 0) {
float translate_center[16];
wlr_matrix_translate(&translate_center, width/2, height/2, 0);
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, &translate_center, mat);
wlr_matrix_mul(mat, &rotate, mat);
wlr_matrix_mul(mat, &translate_origin, mat);
}
float scale[16];
wlr_matrix_scale(&scale, width, height, 1);
wlr_matrix_mul(mat, &scale, mat);
if (transform != WL_OUTPUT_TRANSFORM_NORMAL) {
float surface_translate_center[16];
wlr_matrix_translate(&surface_translate_center, 0.5, 0.5, 0);
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, &surface_translate_center, mat);
wlr_matrix_mul(mat, &surface_transform, mat);
wlr_matrix_mul(mat, &surface_translate_origin, mat);
}
wlr_matrix_mul(projection, mat, mat);
}

1
render/meson.build
View File

@ -15,7 +15,6 @@ lib_wlr_render = static_library(
'gles2/shaders.c',
'gles2/texture.c',
'gles2/util.c',
'matrix.c',
'wlr_renderer.c',
'wlr_texture.c',
),

25
render/wlr_renderer.c
View File

@ -1,6 +1,7 @@
#include <stdbool.h>
#include <stdlib.h>
#include <wlr/render/interface.h>
#include <wlr/types/wlr_matrix.h>
void wlr_renderer_init(struct wlr_renderer *renderer,
struct wlr_renderer_impl *impl) {
@ -23,7 +24,7 @@ void wlr_renderer_end(struct wlr_renderer *r) {
r->impl->end(r);
}
void wlr_renderer_clear(struct wlr_renderer *r, const float (*color)[4]) {
void wlr_renderer_clear(struct wlr_renderer *r, const float color[static 4]) {
r->impl->clear(r, color);
}
@ -35,18 +36,30 @@ struct wlr_texture *wlr_render_texture_create(struct wlr_renderer *r) {
return r->impl->texture_create(r);
}
bool wlr_render_with_matrix(struct wlr_renderer *r,
struct wlr_texture *texture, const float (*matrix)[16], float alpha) {
return r->impl->render_with_matrix(r, texture, matrix, alpha);
bool wlr_render_texture(struct wlr_renderer *r, struct wlr_texture *texture,
const float projection[static 9], int x, int y, float alpha) {
float mat[9];
wlr_matrix_identity(mat);
wlr_matrix_translate(mat, x, y);
wlr_matrix_scale(mat, texture->width, texture->height);
wlr_matrix_multiply(mat, projection, mat);
return wlr_render_texture_with_matrix(r, texture, mat, alpha);
}
bool wlr_render_texture_with_matrix(struct wlr_renderer *r,
struct wlr_texture *texture, const float matrix[static 9],
float alpha) {
return r->impl->render_texture_with_matrix(r, texture, matrix, alpha);
}
void wlr_render_colored_quad(struct wlr_renderer *r,
const float (*color)[4], const float (*matrix)[16]) {
const float color[static 4], const float matrix[static 9]) {
r->impl->render_quad(r, color, matrix);
}
void wlr_render_colored_ellipse(struct wlr_renderer *r,
const float (*color)[4], const float (*matrix)[16]) {
const float color[static 4], const float matrix[static 9]) {
r->impl->render_ellipse(r, color, matrix);
}

5
render/wlr_texture.c
View File

@ -58,11 +58,6 @@ bool wlr_texture_upload_dmabuf(struct wlr_texture *texture,
return texture->impl->upload_dmabuf(texture, dmabuf_resource);
}
void wlr_texture_get_matrix(struct wlr_texture *texture,
float (*matrix)[16], const float (*projection)[16], int x, int y) {
texture->impl->get_matrix(texture, matrix, projection, x, y);
}
void wlr_texture_get_buffer_size(struct wlr_texture *texture, struct wl_resource
*resource, int *width, int *height) {
texture->impl->get_buffer_size(texture, resource, width, height);

20
rootston/output.c
View File

@ -3,7 +3,7 @@
#include <stdbool.h>
#include <stdlib.h>
#include <time.h>
#include <wlr/render/matrix.h>
#include <wlr/types/wlr_matrix.h>
#include <wlr/types/wlr_compositor.h>
#include <wlr/types/wlr_output_layout.h>
#include <wlr/types/wlr_wl_shell.h>
@ -287,17 +287,17 @@ static void render_surface(struct wlr_surface *surface, double lx, double ly,
goto damage_finish;
}
float matrix[16];
float matrix[9];
enum wl_output_transform transform =
wlr_output_transform_invert(surface->current->transform);
wlr_matrix_project_box(&matrix, &box, transform, rotation,
&output->wlr_output->transform_matrix);
wlr_matrix_project_box(matrix, &box, transform, rotation,
output->wlr_output->transform_matrix);
int nrects;
pixman_box32_t *rects = pixman_region32_rectangles(&damage, &nrects);
for (int i = 0; i < nrects; ++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:
@ -353,9 +353,9 @@ static void render_decorations(struct roots_view *view,
goto damage_finish;
}
float matrix[16];
wlr_matrix_project_box(&matrix, &box, WL_OUTPUT_TRANSFORM_NORMAL,
view->rotation, &output->wlr_output->transform_matrix);
float matrix[9];
wlr_matrix_project_box(matrix, &box, WL_OUTPUT_TRANSFORM_NORMAL,
view->rotation, output->wlr_output->transform_matrix);
float color[] = { 0.2, 0.2, 0.2, view->alpha };
int nrects;
@ -363,7 +363,7 @@ static void render_decorations(struct roots_view *view,
pixman_region32_rectangles(&damage, &nrects);
for (int i = 0; i < nrects; ++i) {
scissor_output(output, &rects[i]);
wlr_render_colored_quad(renderer, &color, &matrix);
wlr_render_colored_quad(renderer, color, matrix);
}
damage_finish:
@ -490,7 +490,7 @@ static void render_output(struct roots_output *output) {
pixman_box32_t *rects = pixman_region32_rectangles(&damage, &nrects);
for (int i = 0; i < nrects; ++i) {
scissor_output(output, &rects[i]);
wlr_renderer_clear(renderer, &clear_color);
wlr_renderer_clear(renderer, clear_color);
}
// If a view is fullscreen on this output, render it

3
types/meson.build
View File

@ -6,11 +6,13 @@ lib_wlr_types = static_library(
'wlr_cursor.c',
'wlr_data_device.c',
'wlr_gamma_control.c',
'wlr_idle_inhibit_v1.c',
'wlr_idle.c',
'wlr_input_device.c',
'wlr_keyboard.c',
'wlr_linux_dmabuf.c',
'wlr_list.c',
'wlr_matrix.c',
'wlr_output_damage.c',
'wlr_output_layout.c',
'wlr_output.c',
@ -28,7 +30,6 @@ lib_wlr_types = static_library(
'wlr_xcursor_manager.c',
'wlr_xdg_shell_v6.c',
'wlr_xdg_shell.c',
'wlr_idle_inhibit_v1.c',
),
include_directories: wlr_inc,
dependencies: [pixman, xkbcommon, wayland_server, wlr_protos],

160
types/wlr_matrix.c Normal file
View File

@ -0,0 +1,160 @@
#include <math.h>
#include <string.h>
#include <wayland-server-protocol.h>
#include <wlr/types/wlr_matrix.h>
#include <wlr/types/wlr_box.h>
#include <wlr/types/wlr_output.h>
void wlr_matrix_identity(float mat[static 9]) {
static const float identity[9] = {
1.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 1.0f,
};
memcpy(mat, identity, sizeof(identity));
}
void wlr_matrix_multiply(float mat[static 9], const float a[static 9],
const float b[static 9]) {
float product[9];
product[0] = a[0]*b[0] + a[1]*b[3] + a[2]*b[6];
product[1] = a[0]*b[1] + a[1]*b[4] + a[2]*b[7];
product[2] = a[0]*b[2] + a[1]*b[5] + a[2]*b[8];
product[3] = a[3]*b[0] + a[4]*b[3] + a[5]*b[6];
product[4] = a[3]*b[1] + a[4]*b[4] + a[5]*b[7];
product[5] = a[3]*b[2] + a[4]*b[5] + a[5]*b[8];
product[6] = a[6]*b[0] + a[7]*b[3] + a[8]*b[6];
product[7] = a[6]*b[1] + a[7]*b[4] + a[8]*b[7];
product[8] = a[6]*b[2] + a[7]*b[5] + a[8]*b[8];
memcpy(mat, product, sizeof(product));
}
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] = {
1.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 1.0f,
},
[WL_OUTPUT_TRANSFORM_90] = {
0.0f, -1.0f, 0.0f,
1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f,
},
[WL_OUTPUT_TRANSFORM_180] = {
-1.0f, 0.0f, 0.0f,
0.0f, -1.0f, 0.0f,
0.0f, 0.0f, 1.0f,
},
[WL_OUTPUT_TRANSFORM_270] = {
0.0f, 1.0f, 0.0f,
-1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f,
},
[WL_OUTPUT_TRANSFORM_FLIPPED] = {
-1.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 1.0f,
},
[WL_OUTPUT_TRANSFORM_FLIPPED_90] = {
0.0f, -1.0f, 0.0f,
-1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f,
},
[WL_OUTPUT_TRANSFORM_FLIPPED_180] = {
1.0f, 0.0f, 0.0f,
0.0f, -1.0f, 0.0f,
0.0f, 0.0f, 1.0f,
},
[WL_OUTPUT_TRANSFORM_FLIPPED_270] = {
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 9],
enum wl_output_transform transform) {
wlr_matrix_multiply(mat, mat, transforms[transform]);
}
// Equivilent to glOrtho(0, width, 0, height, 1, -1) with the transform applied
void wlr_matrix_projection(float mat[static 9], int width, int height,
enum wl_output_transform transform) {
memset(mat, 0, sizeof(*mat) * 9);
const float *t = transforms[transform];
float x = 2.0f / width;
float y = 2.0f / height;
// Rotation + reflection
mat[0] = x * t[0];
mat[1] = x * t[1];
mat[3] = y * -t[3];
mat[4] = y * -t[4];
// Translation
mat[2] = -copysign(1.0f, mat[0] + mat[1]);
mat[5] = -copysign(1.0f, mat[3] + mat[4]);
// Identity
mat[8] = 1.0f;
}
void wlr_matrix_project_box(float mat[static 9], const struct wlr_box *box,
enum wl_output_transform transform, float rotation,
const float projection[static 9]) {
int x = box->x;
int y = box->y;
int width = box->width;
int height = box->height;
wlr_matrix_identity(mat);
wlr_matrix_translate(mat, x, y);
if (rotation != 0) {
wlr_matrix_translate(mat, width/2, height/2);
wlr_matrix_rotate(mat, rotation);
wlr_matrix_translate(mat, -width/2, -height/2);
}
wlr_matrix_scale(mat, width, height);
if (transform != WL_OUTPUT_TRANSFORM_NORMAL) {
wlr_matrix_translate(mat, 0.5, 0.5);
wlr_matrix_transform(mat, transform);
wlr_matrix_translate(mat, -0.5, -0.5);
}
wlr_matrix_multiply(mat, projection, mat);
}

26
types/wlr_output.c
View File

@ -7,7 +7,7 @@
#include <wayland-server.h>
#include <wlr/interfaces/wlr_output.h>
#include <wlr/render.h>
#include <wlr/render/matrix.h>
#include <wlr/types/wlr_matrix.h>
#include <wlr/types/wlr_box.h>
#include <wlr/types/wlr_output.h>
#include <wlr/types/wlr_surface.h>
@ -139,8 +139,8 @@ void wlr_output_update_enabled(struct wlr_output *output, bool enabled) {
}
static void wlr_output_update_matrix(struct wlr_output *output) {
wlr_matrix_texture(output->transform_matrix, output->width, output->height,
output->transform);
wlr_matrix_projection(output->transform_matrix, output->width,
output->height, output->transform);
}
void wlr_output_enable(struct wlr_output *output, bool enable) {
@ -368,25 +368,25 @@ static void output_fullscreen_surface_render(struct wlr_output *output,
assert(renderer);
if (!wlr_surface_has_buffer(surface)) {
wlr_renderer_clear(renderer, &(float[]){0, 0, 0, 0});
wlr_renderer_clear(renderer, (float[]){0, 0, 0, 0});
return;
}
struct wlr_box box;
output_fullscreen_surface_get_box(output, surface, &box);
float matrix[16];
float matrix[9];
enum wl_output_transform transform =
wlr_output_transform_invert(surface->current->transform);
wlr_matrix_project_box(&matrix, &box, transform, 0,
&output->transform_matrix);
wlr_matrix_project_box(matrix, &box, transform, 0,
output->transform_matrix);
int nrects;
pixman_box32_t *rects = pixman_region32_rectangles(damage, &nrects);
for (int i = 0; i < nrects; ++i) {
output_scissor(output, &rects[i]);
wlr_renderer_clear(renderer, &(float[]){0, 0, 0, 0});
wlr_render_with_matrix(surface->renderer, surface->texture, &matrix, 1.0f);
wlr_renderer_clear(renderer, (float[]){0, 0, 0, 0});
wlr_render_texture_with_matrix(surface->renderer, surface->texture, matrix, 1.0f);
}
wlr_renderer_scissor(renderer, NULL);
@ -435,15 +435,15 @@ static void output_cursor_render(struct wlr_output_cursor *cursor,
goto surface_damage_finish;
}
float matrix[16];
wlr_matrix_project_box(&matrix, &box, WL_OUTPUT_TRANSFORM_NORMAL, 0,
&cursor->output->transform_matrix);
float matrix[9];
wlr_matrix_project_box(matrix, &box, WL_OUTPUT_TRANSFORM_NORMAL, 0,
cursor->output->transform_matrix);
int nrects;
pixman_box32_t *rects = pixman_region32_rectangles(&surface_damage, &nrects);
for (int i = 0; i < nrects; ++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);

18
types/wlr_surface.c
View File

@ -3,7 +3,7 @@
#include <wayland-server.h>
#include <wlr/render/egl.h>
#include <wlr/render/interface.h>
#include <wlr/render/matrix.h>
#include <wlr/types/wlr_matrix.h>
#include <wlr/types/wlr_region.h>
#include <wlr/types/wlr_surface.h>
#include <wlr/util/log.h>
@ -628,22 +628,6 @@ struct wlr_surface *wlr_surface_create(struct wl_resource *res,
return surface;
}
void wlr_surface_get_matrix(struct wlr_surface *surface,
float (*matrix)[16],
const float (*projection)[16],
const float (*transform)[16]) {
int width = surface->texture->width;
int height = surface->texture->height;
float scale[16];
wlr_matrix_identity(matrix);
if (transform) {
wlr_matrix_mul(matrix, transform, matrix);
}
wlr_matrix_scale(&scale, width, height, 1);
wlr_matrix_mul(matrix, &scale, matrix);
wlr_matrix_mul(projection, matrix, matrix);
}
bool wlr_surface_has_buffer(struct wlr_surface *surface) {
return surface->texture && surface->texture->valid;
}