Further improvements to rendering subsystem

include/wlr/render.h

@@ -2,30 +2,74 @@
 #define _WLR_RENDER_H
 #include <stdint.h>
 #include <wayland-server-protocol.h>
+#include <wlr/types.h>
 
 struct wlr_surface;
-struct wlr_surface *wlr_surface_init();
-void wlr_surface_attach_pixels(struct wlr_surface *surf, uint32_t format,
-		int width, int height, const unsigned char *pixels);
-void wlr_surface_attach_shm(struct wlr_surface *surf, uint32_t format,
-		struct wl_shm_buffer *shm);
-// TODO: EGL
-void wlr_surface_destroy(struct wlr_surface *tex);
-
-struct wlr_shader;
-struct wlr_shader *wlr_shader_init(const char *vertex);
-bool wlr_shader_add_format(struct wlr_shader *shader, uint32_t format,
-		const char *frag);
-bool wlr_shader_use(struct wlr_shader *shader, uint32_t format);
-void wlr_shader_destroy(struct wlr_shader *shader);
-
 struct wlr_renderer;
-struct wlr_renderer *wlr_renderer_init();
-void wlr_renderer_set_shader(struct wlr_renderer *renderer,
-		struct wlr_shader *shader);
-bool wlr_render_quad(struct wlr_renderer *renderer,
-		struct wlr_surface *surf, float (*transform)[16],
-		float x, float y);
+
+void wlr_renderer_begin(struct wlr_renderer *r, struct wlr_output *output);
+void wlr_renderer_end(struct wlr_renderer *r);
+/**
+ * Requests a surface handle from this renderer.
+ */
+struct wlr_surface *wlr_render_surface_init(struct wlr_renderer *r);
+/**
+ * Renders the requested surface using the provided matrix. A typical surface
+ * rendering goes like so:
+ *
+ * 	struct wlr_renderer *renderer;
+ * 	struct wlr_surface *surface;
+ * 	float projection[16];
+ * 	float matrix[16];
+ * 	wlr_surface_get_matrix(surface, &matrix, &projection, 123, 321);
+ * 	wlr_render_with_matrix(renderer, surface, &matrix);
+ *
+ * This will render the surface at <123, 321>.
+ */
+bool wlr_render_with_matrix(struct wlr_renderer *r,
+		struct wlr_surface *surface, const float (*matrix)[16]);
+/**
+ * Destroys this wlr_renderer. Surfaces must be destroyed separately.
+ */
 void wlr_renderer_destroy(struct wlr_renderer *renderer);
 
+struct wlr_surface_impl;
+struct wlr_surface_state;
+
+struct wlr_surface {
+	struct wlr_surface_impl *impl;
+	struct wlr_surface_state *state;
+	bool valid;
+	uint32_t format;
+	int width, height;
+};
+
+/**
+ * Attaches a pixel buffer to this surface. The buffer may be discarded after
+ * calling this function.
+ */
+bool wlr_surface_attach_pixels(struct wlr_surface *surf, uint32_t format,
+		int width, int height, const unsigned char *pixels);
+/**
+ * Attaches pixels from a wl_shm_buffer to this surface. The shm buffer may be
+ * invalidated after calling this function.
+ */
+bool wlr_surface_attach_shm(struct wlr_surface *surf, uint32_t format,
+		struct wl_shm_buffer *shm);
+/**
+ * Prepares a matrix with the appropriate scale for the given surface 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_surface_get_matrix(struct wlr_surface *surface,
+		float (*matrix)[16], const float (*projection)[16], int x, int y);
+/**
+ * Destroys this wlr_surface.
+ */
+void wlr_surface_destroy(struct wlr_surface *tex);
+
 #endif

include/wlr/render/gles3.h

@@ -0,0 +1,7 @@
+#ifndef _WLR_GLES3_RENDERER_H
+#define _WLR_GLES3_RENDERER_H
+#include <wlr/render.h>
+
+struct wlr_renderer *wlr_gles3_renderer_init();
+
+#endif

include/wlr/render/interface.h

@@ -0,0 +1,43 @@
+#ifndef _WLR_RENDER_INTERFACE_H
+#define _WLR_RENDER_INTERFACE_H
+#include <wayland-server-protocol.h>
+#include <stdbool.h>
+#include <wlr/render.h>
+#include <wlr/types.h>
+
+struct wlr_renderer_impl;
+struct wlr_renderer_state;
+
+struct wlr_renderer {
+	struct wlr_renderer_impl *impl;
+	struct wlr_renderer_state *state;
+};
+
+struct wlr_renderer_impl {
+	void (*begin)(struct wlr_renderer_state *state, struct wlr_output *output);
+	void (*end)(struct wlr_renderer_state *state);
+	struct wlr_surface *(*surface_init)(struct wlr_renderer_state *state);
+	bool (*render_with_matrix)(struct wlr_renderer_state *state,
+		struct wlr_surface *surface, const float (*matrix)[16]);
+	void (*destroy)(struct wlr_renderer_state *state);
+};
+
+struct wlr_renderer *wlr_renderer_init(struct wlr_renderer_state *state,
+		struct wlr_renderer_impl *impl);
+
+struct wlr_surface_impl {
+	bool (*attach_pixels)(struct wlr_surface_state *state, uint32_t format,
+		int width, int height, const unsigned char *pixels);
+	bool (*attach_shm)(struct wlr_surface_state *state, uint32_t format,
+		struct wl_shm_buffer *shm);
+	// TODO: egl
+	void (*get_matrix)(struct wlr_surface_state *state,
+			float (*matrix)[16], const float (*projection)[16], int x, int y);
+	void (*bind)(struct wlr_surface_state *state);
+	void (*destroy)(struct wlr_surface_state *state);
+};
+
+struct wlr_surface *wlr_surface_init();
+void wlr_surface_bind(struct wlr_surface *surface);
+
+#endif

include/wlr/render/matrix.h

@@ -5,6 +5,6 @@ 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(float (*x)[16], float (*y)[16], float (*product)[16]);
+void wlr_matrix_mul(const float (*x)[16], const float (*y)[16], float (*product)[16]);
 
 #endif