[PATCH v5 07/11] Moved shader state into gles2-renderer.

John Kåre Alsaker john.kare.alsaker at gmail.com
Fri Nov 9 12:21:16 PST 2012


---
 src/compositor.h     |  18 --------
 src/gles2-renderer.c | 116 +++++++++++++++++++++++++++++++--------------------
 2 files changed, 71 insertions(+), 63 deletions(-)

diff --git a/src/compositor.h b/src/compositor.h
index 35b64f2..691af04 100644
--- a/src/compositor.h
+++ b/src/compositor.h
@@ -249,15 +249,6 @@ struct weston_seat {
 	struct input_method *input_method;
 };
 
-struct weston_shader {
-	GLuint program;
-	GLuint vertex_shader, fragment_shader;
-	GLint proj_uniform;
-	GLint tex_uniforms[3];
-	GLint alpha_uniform;
-	GLint color_uniform;
-};
-
 enum {
 	WESTON_COMPOSITOR_ACTIVE,
 	WESTON_COMPOSITOR_IDLE,		/* shell->unlock called on activity */
@@ -294,14 +285,6 @@ struct weston_renderer {
 struct weston_compositor {
 	struct wl_signal destroy_signal;
 
-	struct weston_shader texture_shader_rgba;
-	struct weston_shader texture_shader_rgbx;
-	struct weston_shader texture_shader_egl_external;
-	struct weston_shader texture_shader_y_uv;
-	struct weston_shader texture_shader_y_u_v;
-	struct weston_shader texture_shader_y_xuxv;
-	struct weston_shader solid_shader;
-	struct weston_shader *current_shader;
 	struct wl_display *wl_display;
 	struct weston_shell_interface shell_interface;
 
@@ -424,7 +407,6 @@ struct weston_surface {
 	int32_t pitch;
 	struct wl_list link;
 	struct wl_list layer_link;
-	struct weston_shader *shader;
 	float alpha;
 	struct weston_plane *plane;
 
diff --git a/src/gles2-renderer.c b/src/gles2-renderer.c
index 1b5a20c..a1109f5 100644
--- a/src/gles2-renderer.c
+++ b/src/gles2-renderer.c
@@ -31,12 +31,22 @@
 
 #include "compositor.h"
 
+struct gles2_shader {
+	GLuint program;
+	GLuint vertex_shader, fragment_shader;
+	GLint proj_uniform;
+	GLint tex_uniforms[3];
+	GLint alpha_uniform;
+	GLint color_uniform;
+};
+
 struct gles2_output_state {
 	EGLSurface egl_surface;
 };
 
 struct gles2_surface_state {
 	GLfloat color[4];
+	struct gles2_shader *shader;
 };
 
 struct gles2_renderer {
@@ -52,6 +62,16 @@ struct gles2_renderer {
 		GLuint texture;
 		int32_t width, height;
 	} border;
+
+	struct gles2_shader texture_shader_rgba;
+	struct gles2_shader texture_shader_rgbx;
+	struct gles2_shader texture_shader_egl_external;
+	struct gles2_shader texture_shader_y_uv;
+	struct gles2_shader texture_shader_y_u_v;
+	struct gles2_shader texture_shader_y_xuxv;
+	struct gles2_shader invert_color_shader;
+	struct gles2_shader solid_shader;
+	struct gles2_shader *current_shader;
 };
 
 static inline struct gles2_output_state *
@@ -539,6 +559,7 @@ static void
 triangle_fan_debug(struct weston_surface *surface, int first, int count)
 {
 	struct weston_compositor *compositor = surface->compositor;
+	struct gles2_renderer *gr = get_renderer(compositor);
 	int i;
 	GLushort *buffer;
 	GLushort *index;
@@ -566,11 +587,11 @@ triangle_fan_debug(struct weston_surface *surface, int first, int count)
 		*index++ = first + i;
 	}
 
-	glUseProgram(compositor->solid_shader.program);
-	glUniform4fv(compositor->solid_shader.color_uniform, 1,
+	glUseProgram(gr->solid_shader.program);
+	glUniform4fv(gr->solid_shader.color_uniform, 1,
 			color[color_idx++ % ARRAY_LENGTH(color)]);
 	glDrawElements(GL_LINES, nelems, GL_UNSIGNED_SHORT, buffer);
-	glUseProgram(compositor->current_shader->program);
+	glUseProgram(gr->current_shader->program);
 	free(buffer);
 }
 
@@ -642,18 +663,18 @@ use_output(struct weston_output *output)
 }
 
 static void
-use_shader(struct weston_compositor *compositor,
-			     struct weston_shader *shader)
+use_shader(struct gles2_renderer *gr,
+			     struct gles2_shader *shader)
 {
-	if (compositor->current_shader == shader)
+	if (gr->current_shader == shader)
 		return;
 
 	glUseProgram(shader->program);
-	compositor->current_shader = shader;
+	gr->current_shader = shader;
 }
 
 static void
-shader_uniforms(struct weston_shader *shader,
+shader_uniforms(struct gles2_shader *shader,
 		       struct weston_surface *surface,
 		       struct weston_output *output)
 {
@@ -674,6 +695,8 @@ draw_surface(struct weston_surface *es, struct weston_output *output,
 	     pixman_region32_t *damage) /* in global coordinates */
 {
 	struct weston_compositor *ec = es->compositor;
+	struct gles2_renderer *gr = get_renderer(ec);
+	struct gles2_surface_state *gs = get_surface_state(es);
 	/* repaint bounding region in global coordinates: */
 	pixman_region32_t repaint;
 	/* non-opaque region in surface coordinates: */
@@ -696,12 +719,12 @@ draw_surface(struct weston_surface *es, struct weston_output *output,
 	glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 
 	if (ec->fan_debug) {
-		use_shader(ec, &ec->solid_shader);
-		shader_uniforms(&ec->solid_shader, es, output);
+		use_shader(gr, &gr->solid_shader);
+		shader_uniforms(&gr->solid_shader, es, output);
 	}
 
-	use_shader(ec, es->shader);
-	shader_uniforms(es->shader, es, output);
+	use_shader(gr, gs->shader);
+	shader_uniforms(gs->shader, es, output);
 
 	if (es->transform.enabled || output->zoom.active)
 		filter = GL_LINEAR;
@@ -721,14 +744,14 @@ draw_surface(struct weston_surface *es, struct weston_output *output,
 	pixman_region32_subtract(&surface_blend, &surface_blend, &es->opaque);
 
 	if (pixman_region32_not_empty(&es->opaque)) {
-		if (es->shader == &ec->texture_shader_rgba) {
+		if (gs->shader == &gr->texture_shader_rgba) {
 			/* Special case for RGBA textures with possibly
 			 * bad data in alpha channel: use the shader
 			 * that forces texture alpha = 1.0.
 			 * Xwayland surfaces need this.
 			 */
-			use_shader(ec, &ec->texture_shader_rgbx);
-			shader_uniforms(&ec->texture_shader_rgbx, es, output);
+			use_shader(gr, &gr->texture_shader_rgbx);
+			shader_uniforms(&gr->texture_shader_rgbx, es, output);
 		}
 
 		if (es->alpha < 1.0)
@@ -740,7 +763,7 @@ draw_surface(struct weston_surface *es, struct weston_output *output,
 	}
 
 	if (pixman_region32_not_empty(&surface_blend)) {
-		use_shader(ec, es->shader);
+		use_shader(gr, gs->shader);
 		glEnable(GL_BLEND);
 		repaint_region(es, &repaint, &surface_blend);
 	}
@@ -844,12 +867,12 @@ draw_border(struct weston_output *output)
 {
 	struct weston_compositor *ec = output->compositor;
 	struct gles2_renderer *gr = get_renderer(ec);
-	struct weston_shader *shader = &ec->texture_shader_rgba;
+	struct gles2_shader *shader = &gr->texture_shader_rgba;
 	GLfloat *v;
 	int n;
 
 	glDisable(GL_BLEND);
-	use_shader(ec, shader);
+	use_shader(gr, shader);
 
 	glUniformMatrix4fv(shader->proj_uniform,
 			   1, GL_FALSE, output->matrix.d);
@@ -1046,6 +1069,7 @@ gles2_renderer_attach(struct weston_surface *es, struct wl_buffer *buffer)
 {
 	struct weston_compositor *ec = es->compositor;
 	struct gles2_renderer *gr = get_renderer(ec);
+	struct gles2_surface_state *gs = get_surface_state(es);
 	EGLint attribs[3], format;
 	int i, num_planes;
 
@@ -1070,9 +1094,9 @@ gles2_renderer_attach(struct weston_surface *es, struct wl_buffer *buffer)
 			     es->pitch, buffer->height, 0,
 			     GL_BGRA_EXT, GL_UNSIGNED_BYTE, NULL);
 		if (wl_shm_buffer_get_format(buffer) == WL_SHM_FORMAT_XRGB8888)
-			es->shader = &ec->texture_shader_rgbx;
+			gs->shader = &gr->texture_shader_rgbx;
 		else
-			es->shader = &ec->texture_shader_rgba;
+			gs->shader = &gr->texture_shader_rgba;
 	} else if (ec->query_buffer(gr->egl_display, buffer,
 				    EGL_TEXTURE_FORMAT, &format)) {
 		for (i = 0; i < es->num_images; i++)
@@ -1084,24 +1108,24 @@ gles2_renderer_attach(struct weston_surface *es, struct wl_buffer *buffer)
 		case EGL_TEXTURE_RGBA:
 		default:
 			num_planes = 1;
-			es->shader = &ec->texture_shader_rgba;
+			gs->shader = &gr->texture_shader_rgba;
 			break;
 		case EGL_TEXTURE_EXTERNAL_WL:
 			num_planes = 1;
 			es->target = GL_TEXTURE_EXTERNAL_OES;
-			es->shader = &ec->texture_shader_egl_external;
+			gs->shader = &gr->texture_shader_egl_external;
 			break;
 		case EGL_TEXTURE_Y_UV_WL:
 			num_planes = 2;
-			es->shader = &ec->texture_shader_y_uv;
+			gs->shader = &gr->texture_shader_y_uv;
 			break;
 		case EGL_TEXTURE_Y_U_V_WL:
 			num_planes = 3;
-			es->shader = &ec->texture_shader_y_u_v;
+			gs->shader = &gr->texture_shader_y_u_v;
 			break;
 		case EGL_TEXTURE_Y_XUXV_WL:
 			num_planes = 2;
-			es->shader = &ec->texture_shader_y_xuxv;
+			gs->shader = &gr->texture_shader_y_xuxv;
 			break;
 		}
 
@@ -1137,13 +1161,14 @@ gles2_renderer_surface_set_color(struct weston_surface *surface,
 		 float red, float green, float blue, float alpha)
 {
 	struct gles2_surface_state *gs = get_surface_state(surface);
+	struct gles2_renderer *gr = get_renderer(surface->compositor);
 
 	gs->color[0] = red;
 	gs->color[1] = green;
 	gs->color[2] = blue;
 	gs->color[3] = alpha;
 
-	surface->shader = &surface->compositor->solid_shader;
+	gs->shader = &gr->solid_shader;
 }
 
 static int
@@ -1306,7 +1331,7 @@ compile_shader(GLenum type, int count, const char **sources)
 }
 
 static int
-shader_init(struct weston_shader *shader, struct weston_compositor *ec,
+shader_init(struct gles2_shader *shader, struct weston_compositor *ec,
 		   const char *vertex_source, const char *fragment_source)
 {
 	char msg[512];
@@ -1358,7 +1383,7 @@ shader_init(struct weston_shader *shader, struct weston_compositor *ec,
 }
 
 static void
-shader_release(struct weston_shader *shader)
+shader_release(struct gles2_shader *shader)
 {
 	glDeleteShader(shader->vertex_shader);
 	glDeleteShader(shader->fragment_shader);
@@ -1688,26 +1713,28 @@ gles2_renderer_display(struct weston_compositor *ec)
 static int
 compile_shaders(struct weston_compositor *ec)
 {
-	if (shader_init(&ec->texture_shader_rgba, ec,
+	struct gles2_renderer *gr = get_renderer(ec);
+
+	if (shader_init(&gr->texture_shader_rgba, ec,
 			     vertex_shader, texture_fragment_shader_rgba) < 0)
 		return -1;
-	if (shader_init(&ec->texture_shader_rgbx, ec,
+	if (shader_init(&gr->texture_shader_rgbx, ec,
 			     vertex_shader, texture_fragment_shader_rgbx) < 0)
 		return -1;
 	if (ec->has_egl_image_external &&
-			shader_init(&ec->texture_shader_egl_external, ec,
+			shader_init(&gr->texture_shader_egl_external, ec,
 				vertex_shader, texture_fragment_shader_egl_external) < 0)
 		return -1;
-	if (shader_init(&ec->texture_shader_y_uv, ec,
+	if (shader_init(&gr->texture_shader_y_uv, ec,
 			       vertex_shader, texture_fragment_shader_y_uv) < 0)
 		return -1;
-	if (shader_init(&ec->texture_shader_y_u_v, ec,
+	if (shader_init(&gr->texture_shader_y_u_v, ec,
 			       vertex_shader, texture_fragment_shader_y_u_v) < 0)
 		return -1;
-	if (shader_init(&ec->texture_shader_y_xuxv, ec,
+	if (shader_init(&gr->texture_shader_y_xuxv, ec,
 			       vertex_shader, texture_fragment_shader_y_xuxv) < 0)
 		return -1;
-	if (shader_init(&ec->solid_shader, ec,
+	if (shader_init(&gr->solid_shader, ec,
 			     vertex_shader, solid_fragment_shader) < 0)
 		return -1;
 
@@ -1719,19 +1746,18 @@ fragment_debug_binding(struct wl_seat *seat, uint32_t time, uint32_t key,
 		       void *data)
 {
 	struct weston_compositor *ec = data;
-	struct gles2_renderer *renderer =
-		(struct gles2_renderer *) ec->renderer;
+	struct gles2_renderer *gr = get_renderer(ec);
 	struct weston_output *output;
 
-	renderer->fragment_shader_debug ^= 1;
+	gr->fragment_shader_debug ^= 1;
 
-	shader_release(&ec->texture_shader_rgba);
-	shader_release(&ec->texture_shader_rgbx);
-	shader_release(&ec->texture_shader_egl_external);
-	shader_release(&ec->texture_shader_y_uv);
-	shader_release(&ec->texture_shader_y_u_v);
-	shader_release(&ec->texture_shader_y_xuxv);
-	shader_release(&ec->solid_shader);
+	shader_release(&gr->texture_shader_rgba);
+	shader_release(&gr->texture_shader_rgbx);
+	shader_release(&gr->texture_shader_egl_external);
+	shader_release(&gr->texture_shader_y_uv);
+	shader_release(&gr->texture_shader_y_u_v);
+	shader_release(&gr->texture_shader_y_xuxv);
+	shader_release(&gr->solid_shader);
 
 	compile_shaders(ec);
 
-- 
1.8.0



More information about the wayland-devel mailing list