matrix: use 2D matrices

backend/drm/drm.c

@@ -647,9 +647,9 @@ 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];
+		float matrix[9];
 		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);
 
 		glFinish();

backend/drm/renderer.c

@@ -1,3 +1,4 @@
+#include <assert.h>
 #include <EGL/egl.h>
 #include <EGL/eglext.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);
 
 	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,
+		[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);
-	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);
 }

examples/output-layout.c

@@ -111,7 +111,7 @@ 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];
+		float matrix[9];
 
 		// transform global coordinates to local coordinates
 		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_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);

examples/rotation.c

@@ -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_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 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,
+			wlr_render_texture_with_matrix(sample->renderer,
 				sample->cat_texture, matrix, 1.0f);
 		}
 	}

examples/tablet.c

@@ -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_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) {

examples/touch.c

@@ -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_clear(sample->renderer, (float[]){0.25f, 0.25f, 0.25f, 1});
 
-	float matrix[16];
+	float matrix[9];
 	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,
+		wlr_render_texture_with_matrix(sample->renderer, sample->cat_texture,
 			matrix, 1.0f);
 	}
 

include/backend/drm/drm.h

@@ -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;

include/wlr/render.h

@@ -30,26 +30,26 @@ struct wlr_texture *wlr_render_texture_create(struct wlr_renderer *r);
  *
  * 	struct wlr_renderer *renderer;
  * 	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.
  */
-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.
  */
 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.
  */
 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.
  */
@@ -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
  * 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.
  */

include/wlr/render/interface.h

@@ -21,13 +21,13 @@ struct wlr_renderer_impl {
 	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,
+	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);
 	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,
-		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)(
 		struct wlr_renderer *renderer, size_t *len);
 	bool (*buffer_is_drm)(struct wlr_renderer *renderer,
@@ -59,8 +59,8 @@ struct wlr_texture_impl {
 		struct wl_resource *drm_buf);
 	bool (*upload_eglimage)(struct wlr_texture *texture, EGLImageKHR image,
 		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,
 		struct wl_resource *resource, int *width, int *height);
 	void (*bind)(struct wlr_texture *texture);

include/wlr/types/wlr_matrix.h

@@ -2,22 +2,22 @@
 #define WLR_TYPES_WLR_MATRIX_H
 
 #include <stdint.h>
+#include <wayland-server.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);
-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,
-	const float projection[static 16]);
+	const float projection[static 9]);
 
 #endif

include/wlr/types/wlr_output.h

@@ -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;

include/wlr/types/wlr_surface.h

@@ -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 buffer_to_surface_matrix[9];
-	float surface_to_buffer_matrix[16];
+	float surface_to_buffer_matrix[9];
 
 	struct {
 		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.
  */
 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]);
 
 
 /**

render/gles2/renderer.c

@@ -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;
 		}
 	}
@@ -170,16 +172,16 @@ static void draw_quad() {
 	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) {
 		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_FALSE, matrix));
 	GL_CALL(glUniform1f(2, alpha));
 	draw_quad();
 	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,
-		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(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]));
 	draw_quad();
 }
 
 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(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]));
 	draw_quad();
 }
@@ -258,7 +260,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,

render/gles2/shaders.c

@@ -3,29 +3,29 @@
 
 // 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];"
+"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() {"
-"  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[] =
@@ -49,26 +49,25 @@ const GLchar ellipse_fragment_src[] =
 
 // Textured quads
 const GLchar vertex_src[] =
-"uniform mat4 proj;"
+"uniform mat3 proj;"
 "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;"
+"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() {"
-"	gl_Position = transpose(proj) * vec4(pos, 0.0, 1.0);"
+"	gl_Position = vec4(transpose(proj) * vec3(pos, 1.0), 1.0);"
 "	v_texcoord = texcoord;"
 "}";
 
@@ -87,8 +86,8 @@ const GLchar fragment_src_rgbx[] =
 "uniform sampler2D tex;"
 "uniform float alpha;"
 "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[] =
@@ -97,6 +96,6 @@ const GLchar fragment_src_external[] =
 "varying vec2 v_texcoord;"
 "uniform samplerExternalOES texture0;"
 "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);"
 "}";

render/gles2/texture.c

@@ -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,
-		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;
-	float world[16];
 	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

render/wlr_renderer.c

@@ -35,19 +35,19 @@ 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,
+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) {
-	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,
-		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);
 }
 
 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);
 }
 

render/wlr_texture.c

@@ -54,7 +54,7 @@ bool wlr_texture_upload_eglimage(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);
 }
 

rootston/output.c

@@ -287,7 +287,7 @@ 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,
@@ -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);
 	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,7 +353,7 @@ static void render_decorations(struct roots_view *view,
 		goto damage_finish;
 	}
 
-	float matrix[16];
+	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 };

types/wlr_matrix.c

@@ -5,143 +5,113 @@
 #include <wlr/types/wlr_box.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));
 }
 
-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));
 }
 
-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] = {
-		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] = {
-		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] = {
-		-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] = {
-		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] = {
-		-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] = {
-		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] = {
-		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] = {
-		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) {
-	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
-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) {
-	memset(mat, 0, sizeof(*mat) * 16);
+	memset(mat, 0, sizeof(*mat) * 9);
 
 	const float *t = transforms[transform];
 	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
 	mat[0] = x * t[0];
 	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
-	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
-	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,
-		const float projection[static 16]) {
+		const float projection[static 9]) {
 	int x = box->x;
 	int y = box->y;
 	int width = box->width;
 	int height = box->height;
 
-	wlr_matrix_translate(mat, x, y, 0);
+	wlr_matrix_identity(mat);
+	wlr_matrix_translate(mat, x, y);
 
 	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) {
-		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);
 }

types/wlr_output.c

@@ -375,7 +375,7 @@ static void output_fullscreen_surface_render(struct wlr_output *output,
 	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,
@@ -386,7 +386,7 @@ static void output_fullscreen_surface_render(struct wlr_output *output,
 	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_render_texture_with_matrix(surface->renderer, surface->texture, matrix, 1.0f);
 	}
 	wlr_renderer_scissor(renderer, NULL);
 
@@ -435,7 +435,7 @@ static void output_cursor_render(struct wlr_output_cursor *cursor,
 		goto surface_damage_finish;
 	}
 
-	float matrix[16];
+	float matrix[9];
 	wlr_matrix_project_box(matrix, &box, WL_OUTPUT_TRANSFORM_NORMAL, 0,
 		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);
 	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);
 

types/wlr_surface.c

@@ -624,20 +624,16 @@ struct wlr_surface *wlr_surface_create(struct wl_resource *res,
 	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 height = surface->texture->height;
-	float scale[16];
 	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) {