blob: ea6631f159f748d2611bc5b94d288c83b1c95a7f [file] [log] [blame]
Kristian Høgsbergd7c17262012-09-05 21:54:15 -04001/*
2 * Copyright © 2012 Intel Corporation
3 *
4 * Permission to use, copy, modify, distribute, and sell this software and
5 * its documentation for any purpose is hereby granted without fee, provided
6 * that the above copyright notice appear in all copies and that both that
7 * copyright notice and this permission notice appear in supporting
8 * documentation, and that the name of the copyright holders not be used in
9 * advertising or publicity pertaining to distribution of the software
10 * without specific, written prior permission. The copyright holders make
11 * no representations about the suitability of this software for any
12 * purpose. It is provided "as is" without express or implied warranty.
13 *
14 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
15 * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
16 * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
17 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
18 * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
19 * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
20 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
21 */
22
Kristian Høgsberg25894fc2012-09-05 22:06:26 -040023#define _GNU_SOURCE
24
John Kåre Alsaker30d2b1f2012-11-13 19:10:28 +010025#include <GLES2/gl2.h>
26#include <GLES2/gl2ext.h>
27
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -040028#include <stdlib.h>
Kristian Høgsberg25894fc2012-09-05 22:06:26 -040029#include <string.h>
30#include <ctype.h>
Pekka Paalanen0d64a0f2012-09-11 17:02:05 +030031#include <float.h>
32#include <assert.h>
Ander Conselvan de Oliveira27508c22012-11-08 17:20:46 +020033#include <linux/input.h>
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -040034
John Kåre Alsaker30d2b1f2012-11-13 19:10:28 +010035#include "gl-renderer.h"
36
37#include <EGL/eglext.h>
38#include "weston-egl-ext.h"
Kristian Høgsbergd7c17262012-09-05 21:54:15 -040039
John Kåre Alsaker779b52a2012-11-13 19:10:29 +010040struct gl_shader {
John Kåre Alsaker40684142012-11-13 19:10:25 +010041 GLuint program;
42 GLuint vertex_shader, fragment_shader;
43 GLint proj_uniform;
44 GLint tex_uniforms[3];
45 GLint alpha_uniform;
46 GLint color_uniform;
47};
48
Ander Conselvan de Oliveira1c169ff2013-03-05 17:30:30 +020049#define BUFFER_DAMAGE_COUNT 2
50
John Kåre Alsaker779b52a2012-11-13 19:10:29 +010051struct gl_output_state {
John Kåre Alsaker94659272012-11-13 19:10:18 +010052 EGLSurface egl_surface;
Ander Conselvan de Oliveira1c169ff2013-03-05 17:30:30 +020053 pixman_region32_t buffer_damage[BUFFER_DAMAGE_COUNT];
John Kåre Alsaker94659272012-11-13 19:10:18 +010054};
55
John Kåre Alsaker779b52a2012-11-13 19:10:29 +010056struct gl_surface_state {
John Kåre Alsaker878f4492012-11-13 19:10:23 +010057 GLfloat color[4];
John Kåre Alsaker779b52a2012-11-13 19:10:29 +010058 struct gl_shader *shader;
John Kåre Alsaker75cc5712012-11-13 19:10:26 +010059
60 GLuint textures[3];
61 int num_textures;
Pekka Paalanen81ee3f52012-12-04 15:58:16 +020062 pixman_region32_t texture_damage;
John Kåre Alsaker75cc5712012-11-13 19:10:26 +010063
64 EGLImageKHR images[3];
65 GLenum target;
66 int num_images;
Pekka Paalanenfb003d32012-12-04 15:58:13 +020067
68 struct weston_buffer_reference buffer_ref;
Pekka Paalanen68033ac2012-12-04 15:58:15 +020069 int pitch; /* in pixels */
John Kåre Alsaker878f4492012-11-13 19:10:23 +010070};
71
John Kåre Alsaker779b52a2012-11-13 19:10:29 +010072struct gl_renderer {
John Kåre Alsaker1b7ad162012-11-13 19:10:19 +010073 struct weston_renderer base;
74 int fragment_shader_debug;
75
76 EGLDisplay egl_display;
77 EGLContext egl_context;
78 EGLConfig egl_config;
John Kåre Alsaker44154502012-11-13 19:10:20 +010079
80 struct {
81 int32_t top, bottom, left, right;
82 GLuint texture;
83 int32_t width, height;
84 } border;
John Kåre Alsaker40684142012-11-13 19:10:25 +010085
John Kåre Alsaker320711d2012-11-13 19:10:27 +010086 PFNGLEGLIMAGETARGETTEXTURE2DOESPROC image_target_texture_2d;
87 PFNEGLCREATEIMAGEKHRPROC create_image;
88 PFNEGLDESTROYIMAGEKHRPROC destroy_image;
89
90 int has_unpack_subimage;
91
92 PFNEGLBINDWAYLANDDISPLAYWL bind_display;
93 PFNEGLUNBINDWAYLANDDISPLAYWL unbind_display;
94 PFNEGLQUERYWAYLANDBUFFERWL query_buffer;
95 int has_bind_display;
96
97 int has_egl_image_external;
98
Ander Conselvan de Oliveira1c169ff2013-03-05 17:30:30 +020099 int has_egl_buffer_age;
100
John Kåre Alsaker779b52a2012-11-13 19:10:29 +0100101 struct gl_shader texture_shader_rgba;
102 struct gl_shader texture_shader_rgbx;
103 struct gl_shader texture_shader_egl_external;
104 struct gl_shader texture_shader_y_uv;
105 struct gl_shader texture_shader_y_u_v;
106 struct gl_shader texture_shader_y_xuxv;
107 struct gl_shader invert_color_shader;
108 struct gl_shader solid_shader;
109 struct gl_shader *current_shader;
John Kåre Alsaker1b7ad162012-11-13 19:10:19 +0100110};
John Kåre Alsaker94659272012-11-13 19:10:18 +0100111
John Kåre Alsaker779b52a2012-11-13 19:10:29 +0100112static inline struct gl_output_state *
John Kåre Alsaker94659272012-11-13 19:10:18 +0100113get_output_state(struct weston_output *output)
114{
John Kåre Alsaker779b52a2012-11-13 19:10:29 +0100115 return (struct gl_output_state *)output->renderer_state;
John Kåre Alsaker94659272012-11-13 19:10:18 +0100116}
117
John Kåre Alsaker779b52a2012-11-13 19:10:29 +0100118static inline struct gl_surface_state *
John Kåre Alsaker878f4492012-11-13 19:10:23 +0100119get_surface_state(struct weston_surface *surface)
120{
John Kåre Alsaker779b52a2012-11-13 19:10:29 +0100121 return (struct gl_surface_state *)surface->renderer_state;
John Kåre Alsaker878f4492012-11-13 19:10:23 +0100122}
123
John Kåre Alsaker779b52a2012-11-13 19:10:29 +0100124static inline struct gl_renderer *
John Kåre Alsaker1b7ad162012-11-13 19:10:19 +0100125get_renderer(struct weston_compositor *ec)
126{
John Kåre Alsaker779b52a2012-11-13 19:10:29 +0100127 return (struct gl_renderer *)ec->renderer;
John Kåre Alsaker1b7ad162012-11-13 19:10:19 +0100128}
129
Kristian Høgsbergd7c17262012-09-05 21:54:15 -0400130static const char *
131egl_error_string(EGLint code)
132{
133#define MYERRCODE(x) case x: return #x;
134 switch (code) {
135 MYERRCODE(EGL_SUCCESS)
136 MYERRCODE(EGL_NOT_INITIALIZED)
137 MYERRCODE(EGL_BAD_ACCESS)
138 MYERRCODE(EGL_BAD_ALLOC)
139 MYERRCODE(EGL_BAD_ATTRIBUTE)
140 MYERRCODE(EGL_BAD_CONTEXT)
141 MYERRCODE(EGL_BAD_CONFIG)
142 MYERRCODE(EGL_BAD_CURRENT_SURFACE)
143 MYERRCODE(EGL_BAD_DISPLAY)
144 MYERRCODE(EGL_BAD_SURFACE)
145 MYERRCODE(EGL_BAD_MATCH)
146 MYERRCODE(EGL_BAD_PARAMETER)
147 MYERRCODE(EGL_BAD_NATIVE_PIXMAP)
148 MYERRCODE(EGL_BAD_NATIVE_WINDOW)
149 MYERRCODE(EGL_CONTEXT_LOST)
150 default:
151 return "unknown";
152 }
153#undef MYERRCODE
154}
155
Pekka Paalanen326529f2012-11-27 12:25:25 +0200156WL_EXPORT void
157gl_renderer_print_egl_error_state(void)
Kristian Høgsbergd7c17262012-09-05 21:54:15 -0400158{
159 EGLint code;
160
161 code = eglGetError();
162 weston_log("EGL error state: %s (0x%04lx)\n",
163 egl_error_string(code), (long)code);
164}
165
Pekka Paalanen0d64a0f2012-09-11 17:02:05 +0300166struct polygon8 {
167 GLfloat x[8];
168 GLfloat y[8];
169 int n;
170};
171
172struct clip_context {
173 struct {
174 GLfloat x;
175 GLfloat y;
176 } prev;
177
178 struct {
179 GLfloat x1, y1;
180 GLfloat x2, y2;
181 } clip;
182
183 struct {
184 GLfloat *x;
185 GLfloat *y;
186 } vertices;
187};
188
189static GLfloat
190float_difference(GLfloat a, GLfloat b)
191{
192 /* http://www.altdevblogaday.com/2012/02/22/comparing-floating-point-numbers-2012-edition/ */
193 static const GLfloat max_diff = 4.0f * FLT_MIN;
194 static const GLfloat max_rel_diff = 4.0e-5;
195 GLfloat diff = a - b;
196 GLfloat adiff = fabsf(diff);
197
198 if (adiff <= max_diff)
199 return 0.0f;
200
201 a = fabsf(a);
202 b = fabsf(b);
203 if (adiff <= (a > b ? a : b) * max_rel_diff)
204 return 0.0f;
205
206 return diff;
207}
208
209/* A line segment (p1x, p1y)-(p2x, p2y) intersects the line x = x_arg.
210 * Compute the y coordinate of the intersection.
211 */
212static GLfloat
213clip_intersect_y(GLfloat p1x, GLfloat p1y, GLfloat p2x, GLfloat p2y,
214 GLfloat x_arg)
215{
216 GLfloat a;
217 GLfloat diff = float_difference(p1x, p2x);
218
219 /* Practically vertical line segment, yet the end points have already
220 * been determined to be on different sides of the line. Therefore
221 * the line segment is part of the line and intersects everywhere.
222 * Return the end point, so we use the whole line segment.
223 */
224 if (diff == 0.0f)
225 return p2y;
226
227 a = (x_arg - p2x) / diff;
228 return p2y + (p1y - p2y) * a;
229}
230
231/* A line segment (p1x, p1y)-(p2x, p2y) intersects the line y = y_arg.
232 * Compute the x coordinate of the intersection.
233 */
234static GLfloat
235clip_intersect_x(GLfloat p1x, GLfloat p1y, GLfloat p2x, GLfloat p2y,
236 GLfloat y_arg)
237{
238 GLfloat a;
239 GLfloat diff = float_difference(p1y, p2y);
240
241 /* Practically horizontal line segment, yet the end points have already
242 * been determined to be on different sides of the line. Therefore
243 * the line segment is part of the line and intersects everywhere.
244 * Return the end point, so we use the whole line segment.
245 */
246 if (diff == 0.0f)
247 return p2x;
248
249 a = (y_arg - p2y) / diff;
250 return p2x + (p1x - p2x) * a;
251}
252
253enum path_transition {
254 PATH_TRANSITION_OUT_TO_OUT = 0,
255 PATH_TRANSITION_OUT_TO_IN = 1,
256 PATH_TRANSITION_IN_TO_OUT = 2,
257 PATH_TRANSITION_IN_TO_IN = 3,
258};
259
260static void
261clip_append_vertex(struct clip_context *ctx, GLfloat x, GLfloat y)
262{
263 *ctx->vertices.x++ = x;
264 *ctx->vertices.y++ = y;
265}
266
267static enum path_transition
268path_transition_left_edge(struct clip_context *ctx, GLfloat x, GLfloat y)
269{
270 return ((ctx->prev.x >= ctx->clip.x1) << 1) | (x >= ctx->clip.x1);
271}
272
273static enum path_transition
274path_transition_right_edge(struct clip_context *ctx, GLfloat x, GLfloat y)
275{
276 return ((ctx->prev.x < ctx->clip.x2) << 1) | (x < ctx->clip.x2);
277}
278
279static enum path_transition
280path_transition_top_edge(struct clip_context *ctx, GLfloat x, GLfloat y)
281{
282 return ((ctx->prev.y >= ctx->clip.y1) << 1) | (y >= ctx->clip.y1);
283}
284
285static enum path_transition
286path_transition_bottom_edge(struct clip_context *ctx, GLfloat x, GLfloat y)
287{
288 return ((ctx->prev.y < ctx->clip.y2) << 1) | (y < ctx->clip.y2);
289}
290
291static void
292clip_polygon_leftright(struct clip_context *ctx,
293 enum path_transition transition,
294 GLfloat x, GLfloat y, GLfloat clip_x)
295{
296 GLfloat yi;
297
298 switch (transition) {
299 case PATH_TRANSITION_IN_TO_IN:
300 clip_append_vertex(ctx, x, y);
301 break;
302 case PATH_TRANSITION_IN_TO_OUT:
303 yi = clip_intersect_y(ctx->prev.x, ctx->prev.y, x, y, clip_x);
304 clip_append_vertex(ctx, clip_x, yi);
305 break;
306 case PATH_TRANSITION_OUT_TO_IN:
307 yi = clip_intersect_y(ctx->prev.x, ctx->prev.y, x, y, clip_x);
308 clip_append_vertex(ctx, clip_x, yi);
309 clip_append_vertex(ctx, x, y);
310 break;
311 case PATH_TRANSITION_OUT_TO_OUT:
312 /* nothing */
313 break;
314 default:
315 assert(0 && "bad enum path_transition");
316 }
317
318 ctx->prev.x = x;
319 ctx->prev.y = y;
320}
321
322static void
323clip_polygon_topbottom(struct clip_context *ctx,
324 enum path_transition transition,
325 GLfloat x, GLfloat y, GLfloat clip_y)
326{
327 GLfloat xi;
328
329 switch (transition) {
330 case PATH_TRANSITION_IN_TO_IN:
331 clip_append_vertex(ctx, x, y);
332 break;
333 case PATH_TRANSITION_IN_TO_OUT:
334 xi = clip_intersect_x(ctx->prev.x, ctx->prev.y, x, y, clip_y);
335 clip_append_vertex(ctx, xi, clip_y);
336 break;
337 case PATH_TRANSITION_OUT_TO_IN:
338 xi = clip_intersect_x(ctx->prev.x, ctx->prev.y, x, y, clip_y);
339 clip_append_vertex(ctx, xi, clip_y);
340 clip_append_vertex(ctx, x, y);
341 break;
342 case PATH_TRANSITION_OUT_TO_OUT:
343 /* nothing */
344 break;
345 default:
346 assert(0 && "bad enum path_transition");
347 }
348
349 ctx->prev.x = x;
350 ctx->prev.y = y;
351}
352
353static void
354clip_context_prepare(struct clip_context *ctx, const struct polygon8 *src,
355 GLfloat *dst_x, GLfloat *dst_y)
356{
357 ctx->prev.x = src->x[src->n - 1];
358 ctx->prev.y = src->y[src->n - 1];
359 ctx->vertices.x = dst_x;
360 ctx->vertices.y = dst_y;
361}
362
363static int
364clip_polygon_left(struct clip_context *ctx, const struct polygon8 *src,
365 GLfloat *dst_x, GLfloat *dst_y)
366{
367 enum path_transition trans;
368 int i;
369
370 clip_context_prepare(ctx, src, dst_x, dst_y);
371 for (i = 0; i < src->n; i++) {
372 trans = path_transition_left_edge(ctx, src->x[i], src->y[i]);
373 clip_polygon_leftright(ctx, trans, src->x[i], src->y[i],
374 ctx->clip.x1);
375 }
376 return ctx->vertices.x - dst_x;
377}
378
379static int
380clip_polygon_right(struct clip_context *ctx, const struct polygon8 *src,
381 GLfloat *dst_x, GLfloat *dst_y)
382{
383 enum path_transition trans;
384 int i;
385
386 clip_context_prepare(ctx, src, dst_x, dst_y);
387 for (i = 0; i < src->n; i++) {
388 trans = path_transition_right_edge(ctx, src->x[i], src->y[i]);
389 clip_polygon_leftright(ctx, trans, src->x[i], src->y[i],
390 ctx->clip.x2);
391 }
392 return ctx->vertices.x - dst_x;
393}
394
395static int
396clip_polygon_top(struct clip_context *ctx, const struct polygon8 *src,
397 GLfloat *dst_x, GLfloat *dst_y)
398{
399 enum path_transition trans;
400 int i;
401
402 clip_context_prepare(ctx, src, dst_x, dst_y);
403 for (i = 0; i < src->n; i++) {
404 trans = path_transition_top_edge(ctx, src->x[i], src->y[i]);
405 clip_polygon_topbottom(ctx, trans, src->x[i], src->y[i],
406 ctx->clip.y1);
407 }
408 return ctx->vertices.x - dst_x;
409}
410
411static int
412clip_polygon_bottom(struct clip_context *ctx, const struct polygon8 *src,
413 GLfloat *dst_x, GLfloat *dst_y)
414{
415 enum path_transition trans;
416 int i;
417
418 clip_context_prepare(ctx, src, dst_x, dst_y);
419 for (i = 0; i < src->n; i++) {
420 trans = path_transition_bottom_edge(ctx, src->x[i], src->y[i]);
421 clip_polygon_topbottom(ctx, trans, src->x[i], src->y[i],
422 ctx->clip.y2);
423 }
424 return ctx->vertices.x - dst_x;
425}
426
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400427#define max(a, b) (((a) > (b)) ? (a) : (b))
428#define min(a, b) (((a) > (b)) ? (b) : (a))
429#define clip(x, a, b) min(max(x, a), b)
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400430
Pekka Paalanen0d64a0f2012-09-11 17:02:05 +0300431/*
432 * Compute the boundary vertices of the intersection of the global coordinate
433 * aligned rectangle 'rect', and an arbitrary quadrilateral produced from
434 * 'surf_rect' when transformed from surface coordinates into global coordinates.
435 * The vertices are written to 'ex' and 'ey', and the return value is the
436 * number of vertices. Vertices are produced in clockwise winding order.
437 * Guarantees to produce either zero vertices, or 3-8 vertices with non-zero
438 * polygon area.
439 */
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400440static int
441calculate_edges(struct weston_surface *es, pixman_box32_t *rect,
442 pixman_box32_t *surf_rect, GLfloat *ex, GLfloat *ey)
443{
Pekka Paalanen0d64a0f2012-09-11 17:02:05 +0300444 struct polygon8 polygon;
445 struct clip_context ctx;
446 int i, n;
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400447 GLfloat min_x, max_x, min_y, max_y;
Pekka Paalanen0d64a0f2012-09-11 17:02:05 +0300448 struct polygon8 surf = {
449 { surf_rect->x1, surf_rect->x2, surf_rect->x2, surf_rect->x1 },
450 { surf_rect->y1, surf_rect->y1, surf_rect->y2, surf_rect->y2 },
451 4
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400452 };
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400453
Pekka Paalanen0d64a0f2012-09-11 17:02:05 +0300454 ctx.clip.x1 = rect->x1;
455 ctx.clip.y1 = rect->y1;
456 ctx.clip.x2 = rect->x2;
457 ctx.clip.y2 = rect->y2;
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400458
459 /* transform surface to screen space: */
Pekka Paalanen0d64a0f2012-09-11 17:02:05 +0300460 for (i = 0; i < surf.n; i++)
461 weston_surface_to_global_float(es, surf.x[i], surf.y[i],
462 &surf.x[i], &surf.y[i]);
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400463
464 /* find bounding box: */
Pekka Paalanen0d64a0f2012-09-11 17:02:05 +0300465 min_x = max_x = surf.x[0];
466 min_y = max_y = surf.y[0];
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400467
Pekka Paalanen0d64a0f2012-09-11 17:02:05 +0300468 for (i = 1; i < surf.n; i++) {
469 min_x = min(min_x, surf.x[i]);
470 max_x = max(max_x, surf.x[i]);
471 min_y = min(min_y, surf.y[i]);
472 max_y = max(max_y, surf.y[i]);
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400473 }
474
475 /* First, simple bounding box check to discard early transformed
476 * surface rects that do not intersect with the clip region:
477 */
Pekka Paalanen0d64a0f2012-09-11 17:02:05 +0300478 if ((min_x >= ctx.clip.x2) || (max_x <= ctx.clip.x1) ||
479 (min_y >= ctx.clip.y2) || (max_y <= ctx.clip.y1))
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400480 return 0;
481
482 /* Simple case, bounding box edges are parallel to surface edges,
483 * there will be only four edges. We just need to clip the surface
484 * vertices to the clip rect bounds:
485 */
486 if (!es->transform.enabled) {
Pekka Paalanen0d64a0f2012-09-11 17:02:05 +0300487 for (i = 0; i < surf.n; i++) {
488 ex[i] = clip(surf.x[i], ctx.clip.x1, ctx.clip.x2);
489 ey[i] = clip(surf.y[i], ctx.clip.y1, ctx.clip.y2);
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400490 }
Pekka Paalanen0d64a0f2012-09-11 17:02:05 +0300491 return surf.n;
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400492 }
493
Pekka Paalanen0d64a0f2012-09-11 17:02:05 +0300494 /* Transformed case: use a general polygon clipping algorithm to
495 * clip the surface rectangle with each side of 'rect'.
496 * The algorithm is Sutherland-Hodgman, as explained in
497 * http://www.codeguru.com/cpp/misc/misc/graphics/article.php/c8965/Polygon-Clipping.htm
498 * but without looking at any of that code.
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400499 */
Pekka Paalanen0d64a0f2012-09-11 17:02:05 +0300500 polygon.n = clip_polygon_left(&ctx, &surf, polygon.x, polygon.y);
501 surf.n = clip_polygon_right(&ctx, &polygon, surf.x, surf.y);
502 polygon.n = clip_polygon_top(&ctx, &surf, polygon.x, polygon.y);
503 surf.n = clip_polygon_bottom(&ctx, &polygon, surf.x, surf.y);
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400504
Pekka Paalanen0d64a0f2012-09-11 17:02:05 +0300505 /* Get rid of duplicate vertices */
506 ex[0] = surf.x[0];
507 ey[0] = surf.y[0];
508 n = 1;
509 for (i = 1; i < surf.n; i++) {
510 if (float_difference(ex[n - 1], surf.x[i]) == 0.0f &&
511 float_difference(ey[n - 1], surf.y[i]) == 0.0f)
512 continue;
513 ex[n] = surf.x[i];
514 ey[n] = surf.y[i];
515 n++;
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400516 }
Pekka Paalanen0d64a0f2012-09-11 17:02:05 +0300517 if (float_difference(ex[n - 1], surf.x[0]) == 0.0f &&
518 float_difference(ey[n - 1], surf.y[0]) == 0.0f)
519 n--;
520
521 if (n < 3)
522 return 0;
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400523
524 return n;
525}
526
527static int
528texture_region(struct weston_surface *es, pixman_region32_t *region,
529 pixman_region32_t *surf_region)
530{
Pekka Paalanen68033ac2012-12-04 15:58:15 +0200531 struct gl_surface_state *gs = get_surface_state(es);
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400532 struct weston_compositor *ec = es->compositor;
533 GLfloat *v, inv_width, inv_height;
534 unsigned int *vtxcnt, nvtx = 0;
535 pixman_box32_t *rects, *surf_rects;
536 int i, j, k, nrects, nsurf;
537
538 rects = pixman_region32_rectangles(region, &nrects);
539 surf_rects = pixman_region32_rectangles(surf_region, &nsurf);
540
541 /* worst case we can have 8 vertices per rect (ie. clipped into
542 * an octagon):
543 */
544 v = wl_array_add(&ec->vertices, nrects * nsurf * 8 * 4 * sizeof *v);
545 vtxcnt = wl_array_add(&ec->vtxcnt, nrects * nsurf * sizeof *vtxcnt);
546
Pekka Paalanen68033ac2012-12-04 15:58:15 +0200547 inv_width = 1.0 / gs->pitch;
Ander Conselvan de Oliveira0396ba22012-11-28 17:10:26 +0200548
549 switch (es->buffer_transform) {
550 case WL_OUTPUT_TRANSFORM_90:
551 case WL_OUTPUT_TRANSFORM_270:
552 case WL_OUTPUT_TRANSFORM_FLIPPED_90:
553 case WL_OUTPUT_TRANSFORM_FLIPPED_270:
554 inv_height = 1.0 / es->geometry.width;
555 break;
556 default:
557 inv_height = 1.0 / es->geometry.height;
558 }
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400559
560 for (i = 0; i < nrects; i++) {
561 pixman_box32_t *rect = &rects[i];
562 for (j = 0; j < nsurf; j++) {
563 pixman_box32_t *surf_rect = &surf_rects[j];
Ander Conselvan de Oliveira0396ba22012-11-28 17:10:26 +0200564 GLfloat sx, sy, bx, by;
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400565 GLfloat ex[8], ey[8]; /* edge points in screen space */
566 int n;
567
568 /* The transformed surface, after clipping to the clip region,
569 * can have as many as eight sides, emitted as a triangle-fan.
570 * The first vertex in the triangle fan can be chosen arbitrarily,
571 * since the area is guaranteed to be convex.
572 *
573 * If a corner of the transformed surface falls outside of the
574 * clip region, instead of emitting one vertex for the corner
575 * of the surface, up to two are emitted for two corresponding
576 * intersection point(s) between the surface and the clip region.
577 *
578 * To do this, we first calculate the (up to eight) points that
579 * form the intersection of the clip rect and the transformed
580 * surface.
581 */
582 n = calculate_edges(es, rect, surf_rect, ex, ey);
583 if (n < 3)
584 continue;
585
586 /* emit edge points: */
587 for (k = 0; k < n; k++) {
588 weston_surface_from_global_float(es, ex[k], ey[k], &sx, &sy);
589 /* position: */
590 *(v++) = ex[k];
591 *(v++) = ey[k];
592 /* texcoord: */
Ander Conselvan de Oliveira0396ba22012-11-28 17:10:26 +0200593 weston_surface_to_buffer_float(es, sx, sy,
594 &bx, &by);
595 *(v++) = bx * inv_width;
596 *(v++) = by * inv_height;
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400597 }
598
599 vtxcnt[nvtx++] = n;
600 }
601 }
602
603 return nvtx;
604}
605
606static void
607triangle_fan_debug(struct weston_surface *surface, int first, int count)
608{
609 struct weston_compositor *compositor = surface->compositor;
John Kåre Alsaker779b52a2012-11-13 19:10:29 +0100610 struct gl_renderer *gr = get_renderer(compositor);
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400611 int i;
612 GLushort *buffer;
613 GLushort *index;
614 int nelems;
615 static int color_idx = 0;
616 static const GLfloat color[][4] = {
617 { 1.0, 0.0, 0.0, 1.0 },
618 { 0.0, 1.0, 0.0, 1.0 },
619 { 0.0, 0.0, 1.0, 1.0 },
620 { 1.0, 1.0, 1.0, 1.0 },
621 };
622
623 nelems = (count - 1 + count - 2) * 2;
624
625 buffer = malloc(sizeof(GLushort) * nelems);
626 index = buffer;
627
628 for (i = 1; i < count; i++) {
629 *index++ = first;
630 *index++ = first + i;
631 }
632
633 for (i = 2; i < count; i++) {
634 *index++ = first + i - 1;
635 *index++ = first + i;
636 }
637
John Kåre Alsaker40684142012-11-13 19:10:25 +0100638 glUseProgram(gr->solid_shader.program);
639 glUniform4fv(gr->solid_shader.color_uniform, 1,
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400640 color[color_idx++ % ARRAY_LENGTH(color)]);
641 glDrawElements(GL_LINES, nelems, GL_UNSIGNED_SHORT, buffer);
John Kåre Alsaker40684142012-11-13 19:10:25 +0100642 glUseProgram(gr->current_shader->program);
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400643 free(buffer);
644}
645
646static void
647repaint_region(struct weston_surface *es, pixman_region32_t *region,
648 pixman_region32_t *surf_region)
649{
650 struct weston_compositor *ec = es->compositor;
651 GLfloat *v;
652 unsigned int *vtxcnt;
653 int i, first, nfans;
654
655 /* The final region to be painted is the intersection of
656 * 'region' and 'surf_region'. However, 'region' is in the global
657 * coordinates, and 'surf_region' is in the surface-local
658 * coordinates. texture_region() will iterate over all pairs of
659 * rectangles from both regions, compute the intersection
660 * polygon for each pair, and store it as a triangle fan if
661 * it has a non-zero area (at least 3 vertices, actually).
662 */
663 nfans = texture_region(es, region, surf_region);
664
665 v = ec->vertices.data;
666 vtxcnt = ec->vtxcnt.data;
667
668 /* position: */
669 glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof *v, &v[0]);
670 glEnableVertexAttribArray(0);
671
672 /* texcoord: */
673 glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof *v, &v[2]);
674 glEnableVertexAttribArray(1);
675
676 for (i = 0, first = 0; i < nfans; i++) {
677 glDrawArrays(GL_TRIANGLE_FAN, first, vtxcnt[i]);
678 if (ec->fan_debug)
679 triangle_fan_debug(es, first, vtxcnt[i]);
680 first += vtxcnt[i];
681 }
682
683 glDisableVertexAttribArray(1);
684 glDisableVertexAttribArray(0);
685
686 ec->vertices.size = 0;
687 ec->vtxcnt.size = 0;
688}
689
John Kåre Alsakera95b2d62012-11-13 19:10:21 +0100690static int
691use_output(struct weston_output *output)
692{
693 static int errored;
John Kåre Alsaker779b52a2012-11-13 19:10:29 +0100694 struct gl_output_state *go = get_output_state(output);
695 struct gl_renderer *gr = get_renderer(output->compositor);
John Kåre Alsakera95b2d62012-11-13 19:10:21 +0100696 EGLBoolean ret;
697
698 ret = eglMakeCurrent(gr->egl_display, go->egl_surface,
699 go->egl_surface, gr->egl_context);
700
701 if (ret == EGL_FALSE) {
702 if (errored)
703 return -1;
704 errored = 1;
705 weston_log("Failed to make EGL context current.\n");
Pekka Paalanen326529f2012-11-27 12:25:25 +0200706 gl_renderer_print_egl_error_state();
John Kåre Alsakera95b2d62012-11-13 19:10:21 +0100707 return -1;
708 }
709
710 return 0;
711}
712
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400713static void
John Kåre Alsaker779b52a2012-11-13 19:10:29 +0100714use_shader(struct gl_renderer *gr,
715 struct gl_shader *shader)
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400716{
John Kåre Alsaker40684142012-11-13 19:10:25 +0100717 if (gr->current_shader == shader)
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400718 return;
719
720 glUseProgram(shader->program);
John Kåre Alsaker40684142012-11-13 19:10:25 +0100721 gr->current_shader = shader;
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400722}
723
724static void
John Kåre Alsaker779b52a2012-11-13 19:10:29 +0100725shader_uniforms(struct gl_shader *shader,
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400726 struct weston_surface *surface,
727 struct weston_output *output)
728{
729 int i;
John Kåre Alsaker779b52a2012-11-13 19:10:29 +0100730 struct gl_surface_state *gs = get_surface_state(surface);
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400731
732 glUniformMatrix4fv(shader->proj_uniform,
733 1, GL_FALSE, output->matrix.d);
John Kåre Alsaker878f4492012-11-13 19:10:23 +0100734 glUniform4fv(shader->color_uniform, 1, gs->color);
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400735 glUniform1f(shader->alpha_uniform, surface->alpha);
736
John Kåre Alsaker75cc5712012-11-13 19:10:26 +0100737 for (i = 0; i < gs->num_textures; i++)
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400738 glUniform1i(shader->tex_uniforms[i], i);
739}
740
741static void
742draw_surface(struct weston_surface *es, struct weston_output *output,
743 pixman_region32_t *damage) /* in global coordinates */
744{
745 struct weston_compositor *ec = es->compositor;
John Kåre Alsaker779b52a2012-11-13 19:10:29 +0100746 struct gl_renderer *gr = get_renderer(ec);
747 struct gl_surface_state *gs = get_surface_state(es);
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400748 /* repaint bounding region in global coordinates: */
749 pixman_region32_t repaint;
750 /* non-opaque region in surface coordinates: */
751 pixman_region32_t surface_blend;
752 GLint filter;
753 int i;
754
755 pixman_region32_init(&repaint);
756 pixman_region32_intersect(&repaint,
757 &es->transform.boundingbox, damage);
758 pixman_region32_subtract(&repaint, &repaint, &es->clip);
759
760 if (!pixman_region32_not_empty(&repaint))
761 goto out;
762
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400763 glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
764
765 if (ec->fan_debug) {
John Kåre Alsaker40684142012-11-13 19:10:25 +0100766 use_shader(gr, &gr->solid_shader);
767 shader_uniforms(&gr->solid_shader, es, output);
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400768 }
769
John Kåre Alsaker40684142012-11-13 19:10:25 +0100770 use_shader(gr, gs->shader);
771 shader_uniforms(gs->shader, es, output);
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400772
773 if (es->transform.enabled || output->zoom.active)
774 filter = GL_LINEAR;
775 else
776 filter = GL_NEAREST;
777
John Kåre Alsaker75cc5712012-11-13 19:10:26 +0100778 for (i = 0; i < gs->num_textures; i++) {
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400779 glActiveTexture(GL_TEXTURE0 + i);
John Kåre Alsaker75cc5712012-11-13 19:10:26 +0100780 glBindTexture(gs->target, gs->textures[i]);
781 glTexParameteri(gs->target, GL_TEXTURE_MIN_FILTER, filter);
782 glTexParameteri(gs->target, GL_TEXTURE_MAG_FILTER, filter);
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400783 }
784
785 /* blended region is whole surface minus opaque region: */
786 pixman_region32_init_rect(&surface_blend, 0, 0,
787 es->geometry.width, es->geometry.height);
788 pixman_region32_subtract(&surface_blend, &surface_blend, &es->opaque);
789
790 if (pixman_region32_not_empty(&es->opaque)) {
John Kåre Alsaker40684142012-11-13 19:10:25 +0100791 if (gs->shader == &gr->texture_shader_rgba) {
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400792 /* Special case for RGBA textures with possibly
793 * bad data in alpha channel: use the shader
794 * that forces texture alpha = 1.0.
795 * Xwayland surfaces need this.
796 */
John Kåre Alsaker40684142012-11-13 19:10:25 +0100797 use_shader(gr, &gr->texture_shader_rgbx);
798 shader_uniforms(&gr->texture_shader_rgbx, es, output);
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400799 }
800
801 if (es->alpha < 1.0)
802 glEnable(GL_BLEND);
803 else
804 glDisable(GL_BLEND);
805
806 repaint_region(es, &repaint, &es->opaque);
807 }
808
809 if (pixman_region32_not_empty(&surface_blend)) {
John Kåre Alsaker40684142012-11-13 19:10:25 +0100810 use_shader(gr, gs->shader);
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400811 glEnable(GL_BLEND);
812 repaint_region(es, &repaint, &surface_blend);
813 }
814
815 pixman_region32_fini(&surface_blend);
816
817out:
818 pixman_region32_fini(&repaint);
819}
820
Kristian Høgsbergd7c17262012-09-05 21:54:15 -0400821static void
822repaint_surfaces(struct weston_output *output, pixman_region32_t *damage)
823{
824 struct weston_compositor *compositor = output->compositor;
825 struct weston_surface *surface;
826
827 wl_list_for_each_reverse(surface, &compositor->surface_list, link)
828 if (surface->plane == &compositor->primary_plane)
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -0400829 draw_surface(surface, output, damage);
Kristian Høgsbergd7c17262012-09-05 21:54:15 -0400830}
831
John Kåre Alsaker44154502012-11-13 19:10:20 +0100832
833static int
834texture_border(struct weston_output *output)
835{
836 struct weston_compositor *ec = output->compositor;
John Kåre Alsaker779b52a2012-11-13 19:10:29 +0100837 struct gl_renderer *gr = get_renderer(ec);
John Kåre Alsaker44154502012-11-13 19:10:20 +0100838 GLfloat *d;
839 unsigned int *p;
840 int i, j, k, n;
841 GLfloat x[4], y[4], u[4], v[4];
842
843 x[0] = -gr->border.left;
844 x[1] = 0;
845 x[2] = output->current->width;
846 x[3] = output->current->width + gr->border.right;
847
848 y[0] = -gr->border.top;
849 y[1] = 0;
850 y[2] = output->current->height;
851 y[3] = output->current->height + gr->border.bottom;
852
853 u[0] = 0.0;
854 u[1] = (GLfloat) gr->border.left / gr->border.width;
855 u[2] = (GLfloat) (gr->border.width - gr->border.right) / gr->border.width;
856 u[3] = 1.0;
857
858 v[0] = 0.0;
859 v[1] = (GLfloat) gr->border.top / gr->border.height;
860 v[2] = (GLfloat) (gr->border.height - gr->border.bottom) / gr->border.height;
861 v[3] = 1.0;
862
863 n = 8;
864 d = wl_array_add(&ec->vertices, n * 16 * sizeof *d);
865 p = wl_array_add(&ec->indices, n * 6 * sizeof *p);
866
867 k = 0;
868 for (i = 0; i < 3; i++)
869 for (j = 0; j < 3; j++) {
870
871 if (i == 1 && j == 1)
872 continue;
873
874 d[ 0] = x[i];
875 d[ 1] = y[j];
876 d[ 2] = u[i];
877 d[ 3] = v[j];
878
879 d[ 4] = x[i];
880 d[ 5] = y[j + 1];
881 d[ 6] = u[i];
882 d[ 7] = v[j + 1];
883
884 d[ 8] = x[i + 1];
885 d[ 9] = y[j];
886 d[10] = u[i + 1];
887 d[11] = v[j];
888
889 d[12] = x[i + 1];
890 d[13] = y[j + 1];
891 d[14] = u[i + 1];
892 d[15] = v[j + 1];
893
894 p[0] = k + 0;
895 p[1] = k + 1;
896 p[2] = k + 2;
897 p[3] = k + 2;
898 p[4] = k + 1;
899 p[5] = k + 3;
900
901 d += 16;
902 p += 6;
903 k += 4;
904 }
905
906 return k / 4;
907}
908
909static void
910draw_border(struct weston_output *output)
911{
912 struct weston_compositor *ec = output->compositor;
John Kåre Alsaker779b52a2012-11-13 19:10:29 +0100913 struct gl_renderer *gr = get_renderer(ec);
914 struct gl_shader *shader = &gr->texture_shader_rgba;
John Kåre Alsaker44154502012-11-13 19:10:20 +0100915 GLfloat *v;
916 int n;
917
918 glDisable(GL_BLEND);
John Kåre Alsaker40684142012-11-13 19:10:25 +0100919 use_shader(gr, shader);
John Kåre Alsaker44154502012-11-13 19:10:20 +0100920
921 glUniformMatrix4fv(shader->proj_uniform,
922 1, GL_FALSE, output->matrix.d);
923
924 glUniform1i(shader->tex_uniforms[0], 0);
925 glUniform1f(shader->alpha_uniform, 1);
926
927 n = texture_border(output);
928
929 glActiveTexture(GL_TEXTURE0);
930 glBindTexture(GL_TEXTURE_2D, gr->border.texture);
931
932 v = ec->vertices.data;
933 glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof *v, &v[0]);
934 glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof *v, &v[2]);
935 glEnableVertexAttribArray(0);
936 glEnableVertexAttribArray(1);
937
938 glDrawElements(GL_TRIANGLES, n * 6,
939 GL_UNSIGNED_INT, ec->indices.data);
940
941 glDisableVertexAttribArray(1);
942 glDisableVertexAttribArray(0);
943
944 ec->vertices.size = 0;
945 ec->indices.size = 0;
946}
947
Kristian Høgsbergfa1be022012-09-05 22:49:55 -0400948static void
Ander Conselvan de Oliveira1c169ff2013-03-05 17:30:30 +0200949output_get_buffer_damage(struct weston_output *output,
950 pixman_region32_t *buffer_damage)
951{
952 struct gl_output_state *go = get_output_state(output);
953 struct gl_renderer *gr = get_renderer(output->compositor);
954 EGLint buffer_age = 0;
955 EGLBoolean ret;
956 int i;
957
958 if (gr->has_egl_buffer_age) {
959 ret = eglQuerySurface(gr->egl_display, go->egl_surface,
960 EGL_BUFFER_AGE_EXT, &buffer_age);
961 if (ret == EGL_FALSE) {
962 weston_log("buffer age query failed.\n");
963 gl_renderer_print_egl_error_state();
964 }
965 }
966
967 if (buffer_age == 0 || buffer_age - 1 > BUFFER_DAMAGE_COUNT)
968 pixman_region32_copy(buffer_damage, &output->region);
969 else
970 for (i = 0; i < buffer_age - 1; i++)
971 pixman_region32_union(buffer_damage, buffer_damage,
972 &go->buffer_damage[i]);
973}
974
975static void
976output_rotate_damage(struct weston_output *output,
977 pixman_region32_t *output_damage)
978{
979 struct gl_output_state *go = get_output_state(output);
980 struct gl_renderer *gr = get_renderer(output->compositor);
981 int i;
982
983 if (!gr->has_egl_buffer_age)
984 return;
985
986 for (i = BUFFER_DAMAGE_COUNT - 1; i >= 1; i--)
987 pixman_region32_copy(&go->buffer_damage[i],
988 &go->buffer_damage[i - 1]);
989
990 pixman_region32_copy(&go->buffer_damage[0], output_damage);
991}
992
993static void
John Kåre Alsaker779b52a2012-11-13 19:10:29 +0100994gl_renderer_repaint_output(struct weston_output *output,
Kristian Høgsbergd7c17262012-09-05 21:54:15 -0400995 pixman_region32_t *output_damage)
996{
John Kåre Alsaker779b52a2012-11-13 19:10:29 +0100997 struct gl_output_state *go = get_output_state(output);
Kristian Høgsbergd7c17262012-09-05 21:54:15 -0400998 struct weston_compositor *compositor = output->compositor;
John Kåre Alsaker779b52a2012-11-13 19:10:29 +0100999 struct gl_renderer *gr = get_renderer(compositor);
Kristian Høgsbergd7c17262012-09-05 21:54:15 -04001000 EGLBoolean ret;
1001 static int errored;
Ander Conselvan de Oliveira1c169ff2013-03-05 17:30:30 +02001002 int32_t width, height;
1003 pixman_region32_t buffer_damage, total_damage;
Kristian Høgsbergd7c17262012-09-05 21:54:15 -04001004
1005 width = output->current->width +
1006 output->border.left + output->border.right;
1007 height = output->current->height +
1008 output->border.top + output->border.bottom;
1009
1010 glViewport(0, 0, width, height);
1011
John Kåre Alsakera95b2d62012-11-13 19:10:21 +01001012 if (use_output(output) < 0)
Kristian Høgsbergd7c17262012-09-05 21:54:15 -04001013 return;
Kristian Høgsbergd7c17262012-09-05 21:54:15 -04001014
1015 /* if debugging, redraw everything outside the damage to clean up
1016 * debug lines from the previous draw on this buffer:
1017 */
1018 if (compositor->fan_debug) {
1019 pixman_region32_t undamaged;
1020 pixman_region32_init(&undamaged);
1021 pixman_region32_subtract(&undamaged, &output->region,
1022 output_damage);
1023 compositor->fan_debug = 0;
1024 repaint_surfaces(output, &undamaged);
1025 compositor->fan_debug = 1;
1026 pixman_region32_fini(&undamaged);
1027 }
1028
Ander Conselvan de Oliveirab605c062013-03-05 17:30:28 +02001029 pixman_region32_init(&total_damage);
Ander Conselvan de Oliveira1c169ff2013-03-05 17:30:30 +02001030 pixman_region32_init(&buffer_damage);
1031
1032 output_get_buffer_damage(output, &buffer_damage);
1033 output_rotate_damage(output, output_damage);
1034
1035 pixman_region32_union(&total_damage, &buffer_damage, output_damage);
Ander Conselvan de Oliveira8ea818f2012-09-14 16:12:03 +03001036
Ander Conselvan de Oliveirab605c062013-03-05 17:30:28 +02001037 repaint_surfaces(output, &total_damage);
1038
1039 pixman_region32_fini(&total_damage);
Ander Conselvan de Oliveira1c169ff2013-03-05 17:30:30 +02001040 pixman_region32_fini(&buffer_damage);
Kristian Høgsbergd7c17262012-09-05 21:54:15 -04001041
John Kåre Alsaker44154502012-11-13 19:10:20 +01001042 if (gr->border.texture)
1043 draw_border(output);
1044
Ander Conselvan de Oliveirab8fcca92012-11-16 17:23:52 +02001045 pixman_region32_copy(&output->previous_damage, output_damage);
Kristian Høgsbergd7c17262012-09-05 21:54:15 -04001046 wl_signal_emit(&output->frame_signal, output);
1047
John Kåre Alsaker1b7ad162012-11-13 19:10:19 +01001048 ret = eglSwapBuffers(gr->egl_display, go->egl_surface);
Kristian Høgsbergd7c17262012-09-05 21:54:15 -04001049 if (ret == EGL_FALSE && !errored) {
1050 errored = 1;
1051 weston_log("Failed in eglSwapBuffers.\n");
Pekka Paalanen326529f2012-11-27 12:25:25 +02001052 gl_renderer_print_egl_error_state();
Kristian Høgsbergd7c17262012-09-05 21:54:15 -04001053 }
1054
1055}
Kristian Høgsberg25894fc2012-09-05 22:06:26 -04001056
John Kåre Alsakera95b2d62012-11-13 19:10:21 +01001057static int
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001058gl_renderer_read_pixels(struct weston_output *output,
John Kåre Alsakera95b2d62012-11-13 19:10:21 +01001059 pixman_format_code_t format, void *pixels,
1060 uint32_t x, uint32_t y,
1061 uint32_t width, uint32_t height)
1062{
1063 GLenum gl_format;
1064
1065 switch (format) {
1066 case PIXMAN_a8r8g8b8:
1067 gl_format = GL_BGRA_EXT;
1068 break;
1069 case PIXMAN_a8b8g8r8:
1070 gl_format = GL_RGBA;
1071 break;
1072 default:
1073 return -1;
1074 }
1075
1076 if (use_output(output) < 0)
1077 return -1;
1078
1079 glPixelStorei(GL_PACK_ALIGNMENT, 1);
1080 glReadPixels(x, y, width, height, gl_format,
1081 GL_UNSIGNED_BYTE, pixels);
1082
1083 return 0;
1084}
1085
Kristian Høgsbergfa1be022012-09-05 22:49:55 -04001086static void
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001087gl_renderer_flush_damage(struct weston_surface *surface)
Kristian Høgsbergb1fd2d62012-09-05 22:13:58 -04001088{
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001089 struct gl_renderer *gr = get_renderer(surface->compositor);
1090 struct gl_surface_state *gs = get_surface_state(surface);
Pekka Paalanenfb003d32012-12-04 15:58:13 +02001091 struct wl_buffer *buffer = gs->buffer_ref.buffer;
John Kåre Alsaker75cc5712012-11-13 19:10:26 +01001092
Kristian Høgsbergb1fd2d62012-09-05 22:13:58 -04001093#ifdef GL_UNPACK_ROW_LENGTH
1094 pixman_box32_t *rectangles;
1095 void *data;
1096 int i, n;
1097#endif
1098
Pekka Paalanen81ee3f52012-12-04 15:58:16 +02001099 pixman_region32_union(&gs->texture_damage,
1100 &gs->texture_damage, &surface->damage);
Pekka Paalanenbcdd5792012-11-07 12:25:13 +02001101
Pekka Paalanenfb003d32012-12-04 15:58:13 +02001102 if (!buffer)
1103 return;
1104
Pekka Paalanenbcdd5792012-11-07 12:25:13 +02001105 /* Avoid upload, if the texture won't be used this time.
Pekka Paalanenfb003d32012-12-04 15:58:13 +02001106 * We still accumulate the damage in texture_damage, and
1107 * hold the reference to the buffer, in case the surface
1108 * migrates back to the primary plane.
Pekka Paalanenbcdd5792012-11-07 12:25:13 +02001109 */
1110 if (surface->plane != &surface->compositor->primary_plane)
1111 return;
1112
Pekka Paalanen81ee3f52012-12-04 15:58:16 +02001113 if (!pixman_region32_not_empty(&gs->texture_damage))
Pekka Paalanenfb003d32012-12-04 15:58:13 +02001114 goto done;
Pekka Paalanenbcdd5792012-11-07 12:25:13 +02001115
John Kåre Alsaker75cc5712012-11-13 19:10:26 +01001116 glBindTexture(GL_TEXTURE_2D, gs->textures[0]);
Kristian Høgsbergb1fd2d62012-09-05 22:13:58 -04001117
John Kåre Alsaker320711d2012-11-13 19:10:27 +01001118 if (!gr->has_unpack_subimage) {
Kristian Høgsbergb1fd2d62012-09-05 22:13:58 -04001119 glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT,
Pekka Paalanen68033ac2012-12-04 15:58:15 +02001120 gs->pitch, buffer->height, 0,
Kristian Høgsbergb1fd2d62012-09-05 22:13:58 -04001121 GL_BGRA_EXT, GL_UNSIGNED_BYTE,
Pekka Paalanende685b82012-12-04 15:58:12 +02001122 wl_shm_buffer_get_data(buffer));
Kristian Høgsbergb1fd2d62012-09-05 22:13:58 -04001123
Pekka Paalanenbcdd5792012-11-07 12:25:13 +02001124 goto done;
Kristian Høgsbergb1fd2d62012-09-05 22:13:58 -04001125 }
1126
1127#ifdef GL_UNPACK_ROW_LENGTH
1128 /* Mesa does not define GL_EXT_unpack_subimage */
Pekka Paalanen68033ac2012-12-04 15:58:15 +02001129 glPixelStorei(GL_UNPACK_ROW_LENGTH, gs->pitch);
Pekka Paalanende685b82012-12-04 15:58:12 +02001130 data = wl_shm_buffer_get_data(buffer);
Pekka Paalanen81ee3f52012-12-04 15:58:16 +02001131 rectangles = pixman_region32_rectangles(&gs->texture_damage, &n);
Kristian Høgsbergb1fd2d62012-09-05 22:13:58 -04001132 for (i = 0; i < n; i++) {
Ander Conselvan de Oliveira0396ba22012-11-28 17:10:26 +02001133 pixman_box32_t r;
1134
1135 r = weston_surface_to_buffer_rect(surface, rectangles[i]);
1136
1137 glPixelStorei(GL_UNPACK_SKIP_PIXELS, r.x1);
1138 glPixelStorei(GL_UNPACK_SKIP_ROWS, r.y1);
1139 glTexSubImage2D(GL_TEXTURE_2D, 0, r.x1, r.y1,
1140 r.x2 - r.x1, r.y2 - r.y1,
Kristian Høgsbergb1fd2d62012-09-05 22:13:58 -04001141 GL_BGRA_EXT, GL_UNSIGNED_BYTE, data);
1142 }
1143#endif
Pekka Paalanenbcdd5792012-11-07 12:25:13 +02001144
1145done:
Pekka Paalanen81ee3f52012-12-04 15:58:16 +02001146 pixman_region32_fini(&gs->texture_damage);
1147 pixman_region32_init(&gs->texture_damage);
Pekka Paalanenfb003d32012-12-04 15:58:13 +02001148
1149 weston_buffer_reference(&gs->buffer_ref, NULL);
Kristian Høgsbergb1fd2d62012-09-05 22:13:58 -04001150}
1151
Kristian Høgsbergb7b77e62012-09-05 22:38:18 -04001152static void
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001153ensure_textures(struct gl_surface_state *gs, int num_textures)
Kristian Høgsbergb7b77e62012-09-05 22:38:18 -04001154{
1155 int i;
1156
John Kåre Alsaker75cc5712012-11-13 19:10:26 +01001157 if (num_textures <= gs->num_textures)
Kristian Høgsbergb7b77e62012-09-05 22:38:18 -04001158 return;
1159
John Kåre Alsaker75cc5712012-11-13 19:10:26 +01001160 for (i = gs->num_textures; i < num_textures; i++) {
1161 glGenTextures(1, &gs->textures[i]);
1162 glBindTexture(gs->target, gs->textures[i]);
1163 glTexParameteri(gs->target,
Kristian Høgsbergb7b77e62012-09-05 22:38:18 -04001164 GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
John Kåre Alsaker75cc5712012-11-13 19:10:26 +01001165 glTexParameteri(gs->target,
Kristian Høgsbergb7b77e62012-09-05 22:38:18 -04001166 GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1167 }
John Kåre Alsaker75cc5712012-11-13 19:10:26 +01001168 gs->num_textures = num_textures;
1169 glBindTexture(gs->target, 0);
Kristian Høgsbergb7b77e62012-09-05 22:38:18 -04001170}
1171
Kristian Høgsbergfa1be022012-09-05 22:49:55 -04001172static void
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001173gl_renderer_attach(struct weston_surface *es, struct wl_buffer *buffer)
Kristian Høgsbergb7b77e62012-09-05 22:38:18 -04001174{
1175 struct weston_compositor *ec = es->compositor;
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001176 struct gl_renderer *gr = get_renderer(ec);
1177 struct gl_surface_state *gs = get_surface_state(es);
Kristian Høgsbergb7b77e62012-09-05 22:38:18 -04001178 EGLint attribs[3], format;
1179 int i, num_planes;
1180
Pekka Paalanenfb003d32012-12-04 15:58:13 +02001181 weston_buffer_reference(&gs->buffer_ref, buffer);
1182
Kristian Høgsbergb7b77e62012-09-05 22:38:18 -04001183 if (!buffer) {
John Kåre Alsaker75cc5712012-11-13 19:10:26 +01001184 for (i = 0; i < gs->num_images; i++) {
John Kåre Alsaker320711d2012-11-13 19:10:27 +01001185 gr->destroy_image(gr->egl_display, gs->images[i]);
John Kåre Alsaker75cc5712012-11-13 19:10:26 +01001186 gs->images[i] = NULL;
Kristian Høgsbergb7b77e62012-09-05 22:38:18 -04001187 }
John Kåre Alsaker75cc5712012-11-13 19:10:26 +01001188 gs->num_images = 0;
1189 glDeleteTextures(gs->num_textures, gs->textures);
1190 gs->num_textures = 0;
Kristian Høgsbergb7b77e62012-09-05 22:38:18 -04001191 return;
1192 }
1193
1194 if (wl_buffer_is_shm(buffer)) {
Pekka Paalanen68033ac2012-12-04 15:58:15 +02001195 gs->pitch = wl_shm_buffer_get_stride(buffer) / 4;
John Kåre Alsaker75cc5712012-11-13 19:10:26 +01001196 gs->target = GL_TEXTURE_2D;
Kristian Høgsbergb7b77e62012-09-05 22:38:18 -04001197
John Kåre Alsaker75cc5712012-11-13 19:10:26 +01001198 ensure_textures(gs, 1);
1199 glBindTexture(GL_TEXTURE_2D, gs->textures[0]);
Kristian Høgsbergb7b77e62012-09-05 22:38:18 -04001200 glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT,
Pekka Paalanen68033ac2012-12-04 15:58:15 +02001201 gs->pitch, buffer->height, 0,
Kristian Høgsbergb7b77e62012-09-05 22:38:18 -04001202 GL_BGRA_EXT, GL_UNSIGNED_BYTE, NULL);
1203 if (wl_shm_buffer_get_format(buffer) == WL_SHM_FORMAT_XRGB8888)
John Kåre Alsaker40684142012-11-13 19:10:25 +01001204 gs->shader = &gr->texture_shader_rgbx;
Kristian Høgsbergb7b77e62012-09-05 22:38:18 -04001205 else
John Kåre Alsaker40684142012-11-13 19:10:25 +01001206 gs->shader = &gr->texture_shader_rgba;
John Kåre Alsaker320711d2012-11-13 19:10:27 +01001207 } else if (gr->query_buffer(gr->egl_display, buffer,
Kristian Høgsbergb7b77e62012-09-05 22:38:18 -04001208 EGL_TEXTURE_FORMAT, &format)) {
John Kåre Alsaker75cc5712012-11-13 19:10:26 +01001209 for (i = 0; i < gs->num_images; i++)
John Kåre Alsaker320711d2012-11-13 19:10:27 +01001210 gr->destroy_image(gr->egl_display, gs->images[i]);
John Kåre Alsaker75cc5712012-11-13 19:10:26 +01001211 gs->num_images = 0;
1212 gs->target = GL_TEXTURE_2D;
Kristian Høgsbergb7b77e62012-09-05 22:38:18 -04001213 switch (format) {
1214 case EGL_TEXTURE_RGB:
1215 case EGL_TEXTURE_RGBA:
1216 default:
1217 num_planes = 1;
John Kåre Alsaker40684142012-11-13 19:10:25 +01001218 gs->shader = &gr->texture_shader_rgba;
Kristian Høgsbergb7b77e62012-09-05 22:38:18 -04001219 break;
1220 case EGL_TEXTURE_EXTERNAL_WL:
1221 num_planes = 1;
John Kåre Alsaker75cc5712012-11-13 19:10:26 +01001222 gs->target = GL_TEXTURE_EXTERNAL_OES;
John Kåre Alsaker40684142012-11-13 19:10:25 +01001223 gs->shader = &gr->texture_shader_egl_external;
Kristian Høgsbergb7b77e62012-09-05 22:38:18 -04001224 break;
1225 case EGL_TEXTURE_Y_UV_WL:
1226 num_planes = 2;
John Kåre Alsaker40684142012-11-13 19:10:25 +01001227 gs->shader = &gr->texture_shader_y_uv;
Kristian Høgsbergb7b77e62012-09-05 22:38:18 -04001228 break;
1229 case EGL_TEXTURE_Y_U_V_WL:
1230 num_planes = 3;
John Kåre Alsaker40684142012-11-13 19:10:25 +01001231 gs->shader = &gr->texture_shader_y_u_v;
Kristian Høgsbergb7b77e62012-09-05 22:38:18 -04001232 break;
1233 case EGL_TEXTURE_Y_XUXV_WL:
1234 num_planes = 2;
John Kåre Alsaker40684142012-11-13 19:10:25 +01001235 gs->shader = &gr->texture_shader_y_xuxv;
Kristian Høgsbergb7b77e62012-09-05 22:38:18 -04001236 break;
1237 }
1238
John Kåre Alsaker75cc5712012-11-13 19:10:26 +01001239 ensure_textures(gs, num_planes);
Kristian Høgsbergb7b77e62012-09-05 22:38:18 -04001240 for (i = 0; i < num_planes; i++) {
1241 attribs[0] = EGL_WAYLAND_PLANE_WL;
1242 attribs[1] = i;
1243 attribs[2] = EGL_NONE;
John Kåre Alsaker320711d2012-11-13 19:10:27 +01001244 gs->images[i] = gr->create_image(gr->egl_display,
Kristian Høgsbergb7b77e62012-09-05 22:38:18 -04001245 NULL,
1246 EGL_WAYLAND_BUFFER_WL,
1247 buffer, attribs);
John Kåre Alsaker75cc5712012-11-13 19:10:26 +01001248 if (!gs->images[i]) {
Kristian Høgsbergb7b77e62012-09-05 22:38:18 -04001249 weston_log("failed to create img for plane %d\n", i);
1250 continue;
1251 }
John Kåre Alsaker75cc5712012-11-13 19:10:26 +01001252 gs->num_images++;
Kristian Høgsbergb7b77e62012-09-05 22:38:18 -04001253
1254 glActiveTexture(GL_TEXTURE0 + i);
John Kåre Alsaker75cc5712012-11-13 19:10:26 +01001255 glBindTexture(gs->target, gs->textures[i]);
John Kåre Alsaker320711d2012-11-13 19:10:27 +01001256 gr->image_target_texture_2d(gs->target,
John Kåre Alsaker75cc5712012-11-13 19:10:26 +01001257 gs->images[i]);
Kristian Høgsbergb7b77e62012-09-05 22:38:18 -04001258 }
1259
Pekka Paalanen68033ac2012-12-04 15:58:15 +02001260 gs->pitch = buffer->width;
Kristian Høgsbergb7b77e62012-09-05 22:38:18 -04001261 } else {
1262 weston_log("unhandled buffer type!\n");
Pekka Paalanenfb003d32012-12-04 15:58:13 +02001263 weston_buffer_reference(&gs->buffer_ref, NULL);
Kristian Høgsbergb7b77e62012-09-05 22:38:18 -04001264 }
1265}
1266
Kristian Høgsberg42263852012-09-06 21:59:29 -04001267static void
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001268gl_renderer_surface_set_color(struct weston_surface *surface,
John Kåre Alsaker878f4492012-11-13 19:10:23 +01001269 float red, float green, float blue, float alpha)
1270{
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001271 struct gl_surface_state *gs = get_surface_state(surface);
1272 struct gl_renderer *gr = get_renderer(surface->compositor);
John Kåre Alsaker878f4492012-11-13 19:10:23 +01001273
1274 gs->color[0] = red;
1275 gs->color[1] = green;
1276 gs->color[2] = blue;
1277 gs->color[3] = alpha;
1278
John Kåre Alsaker40684142012-11-13 19:10:25 +01001279 gs->shader = &gr->solid_shader;
John Kåre Alsaker878f4492012-11-13 19:10:23 +01001280}
1281
1282static int
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001283gl_renderer_create_surface(struct weston_surface *surface)
John Kåre Alsaker878f4492012-11-13 19:10:23 +01001284{
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001285 struct gl_surface_state *gs;
John Kåre Alsaker878f4492012-11-13 19:10:23 +01001286
1287 gs = calloc(1, sizeof *gs);
John Kåre Alsaker878f4492012-11-13 19:10:23 +01001288 if (!gs)
1289 return -1;
1290
Pekka Paalanen68033ac2012-12-04 15:58:15 +02001291 /* A buffer is never attached to solid color surfaces, yet
1292 * they still go through texcoord computations. Do not divide
1293 * by zero there.
1294 */
1295 gs->pitch = 1;
1296
Pekka Paalanen81ee3f52012-12-04 15:58:16 +02001297 pixman_region32_init(&gs->texture_damage);
John Kåre Alsaker878f4492012-11-13 19:10:23 +01001298 surface->renderer_state = gs;
1299
1300 return 0;
1301}
1302
1303static void
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001304gl_renderer_destroy_surface(struct weston_surface *surface)
Kristian Høgsberg42263852012-09-06 21:59:29 -04001305{
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001306 struct gl_surface_state *gs = get_surface_state(surface);
1307 struct gl_renderer *gr = get_renderer(surface->compositor);
Kristian Høgsberg42263852012-09-06 21:59:29 -04001308 int i;
1309
John Kåre Alsaker75cc5712012-11-13 19:10:26 +01001310 glDeleteTextures(gs->num_textures, gs->textures);
Kristian Høgsberg42263852012-09-06 21:59:29 -04001311
John Kåre Alsaker75cc5712012-11-13 19:10:26 +01001312 for (i = 0; i < gs->num_images; i++)
John Kåre Alsaker320711d2012-11-13 19:10:27 +01001313 gr->destroy_image(gr->egl_display, gs->images[i]);
John Kåre Alsaker878f4492012-11-13 19:10:23 +01001314
Pekka Paalanenfb003d32012-12-04 15:58:13 +02001315 weston_buffer_reference(&gs->buffer_ref, NULL);
Pekka Paalanen81ee3f52012-12-04 15:58:16 +02001316 pixman_region32_fini(&gs->texture_damage);
John Kåre Alsaker878f4492012-11-13 19:10:23 +01001317 free(gs);
Kristian Høgsberg42263852012-09-06 21:59:29 -04001318}
1319
Kristian Høgsberg25894fc2012-09-05 22:06:26 -04001320static const char vertex_shader[] =
1321 "uniform mat4 proj;\n"
1322 "attribute vec2 position;\n"
1323 "attribute vec2 texcoord;\n"
1324 "varying vec2 v_texcoord;\n"
1325 "void main()\n"
1326 "{\n"
1327 " gl_Position = proj * vec4(position, 0.0, 1.0);\n"
1328 " v_texcoord = texcoord;\n"
1329 "}\n";
1330
1331/* Declare common fragment shader uniforms */
1332#define FRAGMENT_CONVERT_YUV \
1333 " y *= alpha;\n" \
1334 " u *= alpha;\n" \
1335 " v *= alpha;\n" \
1336 " gl_FragColor.r = y + 1.59602678 * v;\n" \
1337 " gl_FragColor.g = y - 0.39176229 * u - 0.81296764 * v;\n" \
1338 " gl_FragColor.b = y + 2.01723214 * u;\n" \
1339 " gl_FragColor.a = alpha;\n"
1340
Ander Conselvan de Oliveira27508c22012-11-08 17:20:46 +02001341static const char fragment_debug[] =
1342 " gl_FragColor = vec4(0.0, 0.3, 0.0, 0.2) + gl_FragColor * 0.8;\n";
1343
1344static const char fragment_brace[] =
1345 "}\n";
1346
Kristian Høgsberg25894fc2012-09-05 22:06:26 -04001347static const char texture_fragment_shader_rgba[] =
1348 "precision mediump float;\n"
1349 "varying vec2 v_texcoord;\n"
1350 "uniform sampler2D tex;\n"
1351 "uniform float alpha;\n"
1352 "void main()\n"
1353 "{\n"
1354 " gl_FragColor = alpha * texture2D(tex, v_texcoord)\n;"
Ander Conselvan de Oliveira27508c22012-11-08 17:20:46 +02001355 ;
Kristian Høgsberg25894fc2012-09-05 22:06:26 -04001356
1357static const char texture_fragment_shader_rgbx[] =
1358 "precision mediump float;\n"
1359 "varying vec2 v_texcoord;\n"
1360 "uniform sampler2D tex;\n"
1361 "uniform float alpha;\n"
1362 "void main()\n"
1363 "{\n"
1364 " gl_FragColor.rgb = alpha * texture2D(tex, v_texcoord).rgb\n;"
1365 " gl_FragColor.a = alpha;\n"
Ander Conselvan de Oliveira27508c22012-11-08 17:20:46 +02001366 ;
Kristian Høgsberg25894fc2012-09-05 22:06:26 -04001367
1368static const char texture_fragment_shader_egl_external[] =
1369 "#extension GL_OES_EGL_image_external : require\n"
1370 "precision mediump float;\n"
1371 "varying vec2 v_texcoord;\n"
1372 "uniform samplerExternalOES tex;\n"
1373 "uniform float alpha;\n"
1374 "void main()\n"
1375 "{\n"
1376 " gl_FragColor = alpha * texture2D(tex, v_texcoord)\n;"
Ander Conselvan de Oliveira27508c22012-11-08 17:20:46 +02001377 ;
Kristian Høgsberg25894fc2012-09-05 22:06:26 -04001378
1379static const char texture_fragment_shader_y_uv[] =
1380 "precision mediump float;\n"
1381 "uniform sampler2D tex;\n"
1382 "uniform sampler2D tex1;\n"
1383 "varying vec2 v_texcoord;\n"
1384 "uniform float alpha;\n"
1385 "void main() {\n"
1386 " float y = 1.16438356 * (texture2D(tex, v_texcoord).x - 0.0625);\n"
1387 " float u = texture2D(tex1, v_texcoord).r - 0.5;\n"
1388 " float v = texture2D(tex1, v_texcoord).g - 0.5;\n"
1389 FRAGMENT_CONVERT_YUV
Ander Conselvan de Oliveira27508c22012-11-08 17:20:46 +02001390 ;
Kristian Høgsberg25894fc2012-09-05 22:06:26 -04001391
1392static const char texture_fragment_shader_y_u_v[] =
1393 "precision mediump float;\n"
1394 "uniform sampler2D tex;\n"
1395 "uniform sampler2D tex1;\n"
1396 "uniform sampler2D tex2;\n"
1397 "varying vec2 v_texcoord;\n"
1398 "uniform float alpha;\n"
1399 "void main() {\n"
1400 " float y = 1.16438356 * (texture2D(tex, v_texcoord).x - 0.0625);\n"
1401 " float u = texture2D(tex1, v_texcoord).x - 0.5;\n"
1402 " float v = texture2D(tex2, v_texcoord).x - 0.5;\n"
1403 FRAGMENT_CONVERT_YUV
Ander Conselvan de Oliveira27508c22012-11-08 17:20:46 +02001404 ;
Kristian Høgsberg25894fc2012-09-05 22:06:26 -04001405
1406static const char texture_fragment_shader_y_xuxv[] =
1407 "precision mediump float;\n"
1408 "uniform sampler2D tex;\n"
1409 "uniform sampler2D tex1;\n"
1410 "varying vec2 v_texcoord;\n"
1411 "uniform float alpha;\n"
1412 "void main() {\n"
1413 " float y = 1.16438356 * (texture2D(tex, v_texcoord).x - 0.0625);\n"
1414 " float u = texture2D(tex1, v_texcoord).g - 0.5;\n"
1415 " float v = texture2D(tex1, v_texcoord).a - 0.5;\n"
1416 FRAGMENT_CONVERT_YUV
Ander Conselvan de Oliveira27508c22012-11-08 17:20:46 +02001417 ;
Kristian Høgsberg25894fc2012-09-05 22:06:26 -04001418
1419static const char solid_fragment_shader[] =
1420 "precision mediump float;\n"
1421 "uniform vec4 color;\n"
1422 "uniform float alpha;\n"
1423 "void main()\n"
1424 "{\n"
1425 " gl_FragColor = alpha * color\n;"
Ander Conselvan de Oliveira27508c22012-11-08 17:20:46 +02001426 ;
Kristian Høgsberg25894fc2012-09-05 22:06:26 -04001427
1428static int
Ander Conselvan de Oliveira27508c22012-11-08 17:20:46 +02001429compile_shader(GLenum type, int count, const char **sources)
Kristian Høgsberg25894fc2012-09-05 22:06:26 -04001430{
1431 GLuint s;
1432 char msg[512];
1433 GLint status;
1434
1435 s = glCreateShader(type);
Ander Conselvan de Oliveira27508c22012-11-08 17:20:46 +02001436 glShaderSource(s, count, sources, NULL);
Kristian Høgsberg25894fc2012-09-05 22:06:26 -04001437 glCompileShader(s);
1438 glGetShaderiv(s, GL_COMPILE_STATUS, &status);
1439 if (!status) {
1440 glGetShaderInfoLog(s, sizeof msg, NULL, msg);
1441 weston_log("shader info: %s\n", msg);
1442 return GL_NONE;
1443 }
1444
1445 return s;
1446}
1447
1448static int
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001449shader_init(struct gl_shader *shader, struct weston_compositor *ec,
Kristian Høgsberg25894fc2012-09-05 22:06:26 -04001450 const char *vertex_source, const char *fragment_source)
1451{
1452 char msg[512];
1453 GLint status;
Ander Conselvan de Oliveira27508c22012-11-08 17:20:46 +02001454 int count;
1455 const char *sources[3];
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001456 struct gl_renderer *renderer = get_renderer(ec);
Kristian Høgsberg25894fc2012-09-05 22:06:26 -04001457
1458 shader->vertex_shader =
Ander Conselvan de Oliveira27508c22012-11-08 17:20:46 +02001459 compile_shader(GL_VERTEX_SHADER, 1, &vertex_source);
1460
1461 if (renderer->fragment_shader_debug) {
1462 sources[0] = fragment_source;
1463 sources[1] = fragment_debug;
1464 sources[2] = fragment_brace;
1465 count = 3;
1466 } else {
1467 sources[0] = fragment_source;
1468 sources[1] = fragment_brace;
1469 count = 2;
1470 }
1471
Kristian Høgsberg25894fc2012-09-05 22:06:26 -04001472 shader->fragment_shader =
Ander Conselvan de Oliveira27508c22012-11-08 17:20:46 +02001473 compile_shader(GL_FRAGMENT_SHADER, count, sources);
Kristian Høgsberg25894fc2012-09-05 22:06:26 -04001474
1475 shader->program = glCreateProgram();
1476 glAttachShader(shader->program, shader->vertex_shader);
1477 glAttachShader(shader->program, shader->fragment_shader);
1478 glBindAttribLocation(shader->program, 0, "position");
1479 glBindAttribLocation(shader->program, 1, "texcoord");
1480
1481 glLinkProgram(shader->program);
1482 glGetProgramiv(shader->program, GL_LINK_STATUS, &status);
1483 if (!status) {
1484 glGetProgramInfoLog(shader->program, sizeof msg, NULL, msg);
1485 weston_log("link info: %s\n", msg);
1486 return -1;
1487 }
1488
1489 shader->proj_uniform = glGetUniformLocation(shader->program, "proj");
1490 shader->tex_uniforms[0] = glGetUniformLocation(shader->program, "tex");
1491 shader->tex_uniforms[1] = glGetUniformLocation(shader->program, "tex1");
1492 shader->tex_uniforms[2] = glGetUniformLocation(shader->program, "tex2");
1493 shader->alpha_uniform = glGetUniformLocation(shader->program, "alpha");
1494 shader->color_uniform = glGetUniformLocation(shader->program, "color");
1495
1496 return 0;
1497}
1498
1499static void
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001500shader_release(struct gl_shader *shader)
Ander Conselvan de Oliveira27508c22012-11-08 17:20:46 +02001501{
1502 glDeleteShader(shader->vertex_shader);
1503 glDeleteShader(shader->fragment_shader);
1504 glDeleteProgram(shader->program);
1505
1506 shader->vertex_shader = 0;
1507 shader->fragment_shader = 0;
1508 shader->program = 0;
1509}
1510
1511static void
Kristian Høgsberg25894fc2012-09-05 22:06:26 -04001512log_extensions(const char *name, const char *extensions)
1513{
1514 const char *p, *end;
1515 int l;
1516 int len;
1517
1518 l = weston_log("%s:", name);
1519 p = extensions;
1520 while (*p) {
1521 end = strchrnul(p, ' ');
1522 len = end - p;
1523 if (l + len > 78)
1524 l = weston_log_continue("\n" STAMP_SPACE "%.*s",
1525 len, p);
1526 else
1527 l += weston_log_continue(" %.*s", len, p);
1528 for (p = end; isspace(*p); p++)
1529 ;
1530 }
1531 weston_log_continue("\n");
1532}
1533
1534static void
1535log_egl_gl_info(EGLDisplay egldpy)
1536{
1537 const char *str;
1538
1539 str = eglQueryString(egldpy, EGL_VERSION);
1540 weston_log("EGL version: %s\n", str ? str : "(null)");
1541
1542 str = eglQueryString(egldpy, EGL_VENDOR);
1543 weston_log("EGL vendor: %s\n", str ? str : "(null)");
1544
1545 str = eglQueryString(egldpy, EGL_CLIENT_APIS);
1546 weston_log("EGL client APIs: %s\n", str ? str : "(null)");
1547
1548 str = eglQueryString(egldpy, EGL_EXTENSIONS);
1549 log_extensions("EGL extensions", str ? str : "(null)");
1550
1551 str = (char *)glGetString(GL_VERSION);
1552 weston_log("GL version: %s\n", str ? str : "(null)");
1553
1554 str = (char *)glGetString(GL_SHADING_LANGUAGE_VERSION);
1555 weston_log("GLSL version: %s\n", str ? str : "(null)");
1556
1557 str = (char *)glGetString(GL_VENDOR);
1558 weston_log("GL vendor: %s\n", str ? str : "(null)");
1559
1560 str = (char *)glGetString(GL_RENDERER);
1561 weston_log("GL renderer: %s\n", str ? str : "(null)");
1562
1563 str = (char *)glGetString(GL_EXTENSIONS);
1564 log_extensions("GL extensions", str ? str : "(null)");
1565}
1566
Pekka Paalanen9c3fe252012-10-24 09:43:05 +03001567static void
1568log_egl_config_info(EGLDisplay egldpy, EGLConfig eglconfig)
1569{
1570 EGLint r, g, b, a;
1571
1572 weston_log("Chosen EGL config details:\n");
1573
1574 weston_log_continue(STAMP_SPACE "RGBA bits");
1575 if (eglGetConfigAttrib(egldpy, eglconfig, EGL_RED_SIZE, &r) &&
1576 eglGetConfigAttrib(egldpy, eglconfig, EGL_GREEN_SIZE, &g) &&
1577 eglGetConfigAttrib(egldpy, eglconfig, EGL_BLUE_SIZE, &b) &&
1578 eglGetConfigAttrib(egldpy, eglconfig, EGL_ALPHA_SIZE, &a))
1579 weston_log_continue(": %d %d %d %d\n", r, g, b, a);
1580 else
1581 weston_log_continue(" unknown\n");
1582
1583 weston_log_continue(STAMP_SPACE "swap interval range");
1584 if (eglGetConfigAttrib(egldpy, eglconfig, EGL_MIN_SWAP_INTERVAL, &a) &&
1585 eglGetConfigAttrib(egldpy, eglconfig, EGL_MAX_SWAP_INTERVAL, &b))
1586 weston_log_continue(": %d - %d\n", a, b);
1587 else
1588 weston_log_continue(" unknown\n");
1589}
1590
John Kåre Alsaker44154502012-11-13 19:10:20 +01001591static void
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001592output_apply_border(struct weston_output *output, struct gl_renderer *gr)
John Kåre Alsaker44154502012-11-13 19:10:20 +01001593{
1594 output->border.top = gr->border.top;
1595 output->border.bottom = gr->border.bottom;
1596 output->border.left = gr->border.left;
1597 output->border.right = gr->border.right;
1598}
1599
1600WL_EXPORT void
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001601gl_renderer_set_border(struct weston_compositor *ec, int32_t width, int32_t height, void *data,
John Kåre Alsaker44154502012-11-13 19:10:20 +01001602 int32_t *edges)
1603{
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001604 struct gl_renderer *gr = get_renderer(ec);
John Kåre Alsaker44154502012-11-13 19:10:20 +01001605 struct weston_output *output;
1606
1607 gr->border.left = edges[0];
1608 gr->border.right = edges[1];
1609 gr->border.top = edges[2];
1610 gr->border.bottom = edges[3];
1611
1612 gr->border.width = width;
1613 gr->border.height = height;
1614
1615 glGenTextures(1, &gr->border.texture);
1616 glBindTexture(GL_TEXTURE_2D, gr->border.texture);
1617 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
1618 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1619 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1620 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1621
1622 glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT,
1623 width,
1624 height,
1625 0, GL_BGRA_EXT, GL_UNSIGNED_BYTE,
1626 data);
1627
1628 wl_list_for_each(output, &ec->output_list, link)
1629 output_apply_border(output, gr);
1630}
1631
John Kåre Alsaker94659272012-11-13 19:10:18 +01001632static int
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001633gl_renderer_setup(struct weston_compositor *ec, EGLSurface egl_surface);
John Kåre Alsaker94659272012-11-13 19:10:18 +01001634
1635WL_EXPORT int
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001636gl_renderer_output_create(struct weston_output *output,
John Kåre Alsaker94659272012-11-13 19:10:18 +01001637 EGLNativeWindowType window)
1638{
1639 struct weston_compositor *ec = output->compositor;
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001640 struct gl_renderer *gr = get_renderer(ec);
1641 struct gl_output_state *go = calloc(1, sizeof *go);
Ander Conselvan de Oliveirab8fcca92012-11-16 17:23:52 +02001642 int i;
John Kåre Alsaker94659272012-11-13 19:10:18 +01001643
1644 if (!go)
1645 return -1;
1646
1647 go->egl_surface =
John Kåre Alsaker1b7ad162012-11-13 19:10:19 +01001648 eglCreateWindowSurface(gr->egl_display,
1649 gr->egl_config,
John Kåre Alsaker94659272012-11-13 19:10:18 +01001650 window, NULL);
1651
1652 if (go->egl_surface == EGL_NO_SURFACE) {
1653 weston_log("failed to create egl surface\n");
1654 free(go);
1655 return -1;
1656 }
1657
John Kåre Alsaker1b7ad162012-11-13 19:10:19 +01001658 if (gr->egl_context == NULL)
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001659 if (gl_renderer_setup(ec, go->egl_surface) < 0) {
John Kåre Alsaker94659272012-11-13 19:10:18 +01001660 free(go);
1661 return -1;
1662 }
1663
Ander Conselvan de Oliveira1c169ff2013-03-05 17:30:30 +02001664 for (i = 0; i < BUFFER_DAMAGE_COUNT; i++)
Ander Conselvan de Oliveirab8fcca92012-11-16 17:23:52 +02001665 pixman_region32_init(&go->buffer_damage[i]);
1666
John Kåre Alsaker94659272012-11-13 19:10:18 +01001667 output->renderer_state = go;
1668
John Kåre Alsaker44154502012-11-13 19:10:20 +01001669 output_apply_border(output, gr);
1670
John Kåre Alsaker94659272012-11-13 19:10:18 +01001671 return 0;
1672}
1673
1674WL_EXPORT void
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001675gl_renderer_output_destroy(struct weston_output *output)
John Kåre Alsaker94659272012-11-13 19:10:18 +01001676{
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001677 struct gl_renderer *gr = get_renderer(output->compositor);
1678 struct gl_output_state *go = get_output_state(output);
Ander Conselvan de Oliveirab8fcca92012-11-16 17:23:52 +02001679 int i;
1680
1681 for (i = 0; i < 2; i++)
1682 pixman_region32_fini(&go->buffer_damage[i]);
John Kåre Alsaker94659272012-11-13 19:10:18 +01001683
John Kåre Alsaker1b7ad162012-11-13 19:10:19 +01001684 eglDestroySurface(gr->egl_display, go->egl_surface);
John Kåre Alsaker94659272012-11-13 19:10:18 +01001685
1686 free(go);
1687}
1688
1689WL_EXPORT EGLSurface
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001690gl_renderer_output_surface(struct weston_output *output)
John Kåre Alsaker94659272012-11-13 19:10:18 +01001691{
1692 return get_output_state(output)->egl_surface;
1693}
1694
Vasily Khoruzhick52cfd612013-01-08 19:09:01 +03001695static void
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001696gl_renderer_destroy(struct weston_compositor *ec)
Kristian Høgsberg3a0de882012-09-06 21:44:24 -04001697{
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001698 struct gl_renderer *gr = get_renderer(ec);
John Kåre Alsaker1b7ad162012-11-13 19:10:19 +01001699
John Kåre Alsaker320711d2012-11-13 19:10:27 +01001700 if (gr->has_bind_display)
1701 gr->unbind_display(gr->egl_display, ec->wl_display);
John Kåre Alsaker1b7ad162012-11-13 19:10:19 +01001702
1703 /* Work around crash in egl_dri2.c's dri2_make_current() - when does this apply? */
1704 eglMakeCurrent(gr->egl_display,
1705 EGL_NO_SURFACE, EGL_NO_SURFACE,
1706 EGL_NO_CONTEXT);
1707
1708 eglTerminate(gr->egl_display);
1709 eglReleaseThread();
Scott Moreau976a0502013-03-07 10:15:17 -07001710
1711 free(gr);
John Kåre Alsaker1b7ad162012-11-13 19:10:19 +01001712}
1713
1714static int
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001715egl_choose_config(struct gl_renderer *gr, const EGLint *attribs,
John Kåre Alsaker1b7ad162012-11-13 19:10:19 +01001716 const EGLint *visual_id)
1717{
1718 EGLint count = 0;
1719 EGLint matched = 0;
1720 EGLConfig *configs;
1721 int i;
1722
1723 if (!eglGetConfigs(gr->egl_display, NULL, 0, &count) || count < 1)
1724 return -1;
1725
1726 configs = calloc(count, sizeof *configs);
1727 if (!configs)
1728 return -1;
1729
1730 if (!eglChooseConfig(gr->egl_display, attribs, configs,
1731 count, &matched))
1732 goto out;
1733
1734 for (i = 0; i < matched; ++i) {
1735 EGLint id;
1736
1737 if (visual_id) {
1738 if (!eglGetConfigAttrib(gr->egl_display,
1739 configs[i], EGL_NATIVE_VISUAL_ID,
1740 &id))
1741 continue;
1742
1743 if (id != *visual_id)
1744 continue;
1745 }
1746
1747 gr->egl_config = configs[i];
1748
1749 free(configs);
1750 return 0;
1751 }
1752
1753out:
1754 free(configs);
1755 return -1;
1756}
1757
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001758WL_EXPORT const EGLint gl_renderer_opaque_attribs[] = {
John Kåre Alsaker1b7ad162012-11-13 19:10:19 +01001759 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
1760 EGL_RED_SIZE, 1,
1761 EGL_GREEN_SIZE, 1,
1762 EGL_BLUE_SIZE, 1,
1763 EGL_ALPHA_SIZE, 0,
1764 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
1765 EGL_NONE
1766};
1767
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001768WL_EXPORT const EGLint gl_renderer_alpha_attribs[] = {
John Kåre Alsaker1b7ad162012-11-13 19:10:19 +01001769 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
1770 EGL_RED_SIZE, 1,
1771 EGL_GREEN_SIZE, 1,
1772 EGL_BLUE_SIZE, 1,
1773 EGL_ALPHA_SIZE, 1,
1774 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
1775 EGL_NONE
1776};
1777
1778WL_EXPORT int
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001779gl_renderer_create(struct weston_compositor *ec, EGLNativeDisplayType display,
John Kåre Alsaker1b7ad162012-11-13 19:10:19 +01001780 const EGLint *attribs, const EGLint *visual_id)
1781{
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001782 struct gl_renderer *gr;
John Kåre Alsaker1b7ad162012-11-13 19:10:19 +01001783 EGLint major, minor;
1784
1785 gr = calloc(1, sizeof *gr);
1786
1787 if (gr == NULL)
1788 return -1;
1789
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001790 gr->base.read_pixels = gl_renderer_read_pixels;
1791 gr->base.repaint_output = gl_renderer_repaint_output;
1792 gr->base.flush_damage = gl_renderer_flush_damage;
1793 gr->base.attach = gl_renderer_attach;
1794 gr->base.create_surface = gl_renderer_create_surface;
1795 gr->base.surface_set_color = gl_renderer_surface_set_color;
1796 gr->base.destroy_surface = gl_renderer_destroy_surface;
Vasily Khoruzhick52cfd612013-01-08 19:09:01 +03001797 gr->base.destroy = gl_renderer_destroy;
John Kåre Alsaker1b7ad162012-11-13 19:10:19 +01001798
1799 gr->egl_display = eglGetDisplay(display);
1800 if (gr->egl_display == EGL_NO_DISPLAY) {
1801 weston_log("failed to create display\n");
1802 goto err_egl;
1803 }
1804
1805 if (!eglInitialize(gr->egl_display, &major, &minor)) {
1806 weston_log("failed to initialize display\n");
1807 goto err_egl;
1808 }
1809
1810 if (egl_choose_config(gr, attribs, visual_id) < 0) {
1811 weston_log("failed to choose EGL config\n");
1812 goto err_egl;
1813 }
1814
1815 ec->renderer = &gr->base;
1816
1817 return 0;
1818
1819err_egl:
Pekka Paalanen326529f2012-11-27 12:25:25 +02001820 gl_renderer_print_egl_error_state();
John Kåre Alsaker1b7ad162012-11-13 19:10:19 +01001821 free(gr);
1822 return -1;
1823}
1824
1825WL_EXPORT EGLDisplay
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001826gl_renderer_display(struct weston_compositor *ec)
John Kåre Alsaker1b7ad162012-11-13 19:10:19 +01001827{
1828 return get_renderer(ec)->egl_display;
Kristian Høgsberg3a0de882012-09-06 21:44:24 -04001829}
1830
Ander Conselvan de Oliveira27508c22012-11-08 17:20:46 +02001831static int
1832compile_shaders(struct weston_compositor *ec)
1833{
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001834 struct gl_renderer *gr = get_renderer(ec);
John Kåre Alsaker40684142012-11-13 19:10:25 +01001835
1836 if (shader_init(&gr->texture_shader_rgba, ec,
Ander Conselvan de Oliveira27508c22012-11-08 17:20:46 +02001837 vertex_shader, texture_fragment_shader_rgba) < 0)
1838 return -1;
John Kåre Alsaker40684142012-11-13 19:10:25 +01001839 if (shader_init(&gr->texture_shader_rgbx, ec,
Ander Conselvan de Oliveira27508c22012-11-08 17:20:46 +02001840 vertex_shader, texture_fragment_shader_rgbx) < 0)
1841 return -1;
John Kåre Alsaker320711d2012-11-13 19:10:27 +01001842 if (gr->has_egl_image_external &&
John Kåre Alsaker40684142012-11-13 19:10:25 +01001843 shader_init(&gr->texture_shader_egl_external, ec,
Ander Conselvan de Oliveira27508c22012-11-08 17:20:46 +02001844 vertex_shader, texture_fragment_shader_egl_external) < 0)
1845 return -1;
John Kåre Alsaker40684142012-11-13 19:10:25 +01001846 if (shader_init(&gr->texture_shader_y_uv, ec,
Ander Conselvan de Oliveira27508c22012-11-08 17:20:46 +02001847 vertex_shader, texture_fragment_shader_y_uv) < 0)
1848 return -1;
John Kåre Alsaker40684142012-11-13 19:10:25 +01001849 if (shader_init(&gr->texture_shader_y_u_v, ec,
Ander Conselvan de Oliveira27508c22012-11-08 17:20:46 +02001850 vertex_shader, texture_fragment_shader_y_u_v) < 0)
1851 return -1;
John Kåre Alsaker40684142012-11-13 19:10:25 +01001852 if (shader_init(&gr->texture_shader_y_xuxv, ec,
Ander Conselvan de Oliveira27508c22012-11-08 17:20:46 +02001853 vertex_shader, texture_fragment_shader_y_xuxv) < 0)
1854 return -1;
John Kåre Alsaker40684142012-11-13 19:10:25 +01001855 if (shader_init(&gr->solid_shader, ec,
Ander Conselvan de Oliveira27508c22012-11-08 17:20:46 +02001856 vertex_shader, solid_fragment_shader) < 0)
1857 return -1;
1858
1859 return 0;
1860}
1861
1862static void
1863fragment_debug_binding(struct wl_seat *seat, uint32_t time, uint32_t key,
1864 void *data)
1865{
1866 struct weston_compositor *ec = data;
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001867 struct gl_renderer *gr = get_renderer(ec);
Ander Conselvan de Oliveira27508c22012-11-08 17:20:46 +02001868 struct weston_output *output;
1869
John Kåre Alsaker40684142012-11-13 19:10:25 +01001870 gr->fragment_shader_debug ^= 1;
Ander Conselvan de Oliveira27508c22012-11-08 17:20:46 +02001871
John Kåre Alsaker40684142012-11-13 19:10:25 +01001872 shader_release(&gr->texture_shader_rgba);
1873 shader_release(&gr->texture_shader_rgbx);
1874 shader_release(&gr->texture_shader_egl_external);
1875 shader_release(&gr->texture_shader_y_uv);
1876 shader_release(&gr->texture_shader_y_u_v);
1877 shader_release(&gr->texture_shader_y_xuxv);
1878 shader_release(&gr->solid_shader);
Ander Conselvan de Oliveira27508c22012-11-08 17:20:46 +02001879
1880 compile_shaders(ec);
1881
Ander Conselvan de Oliveira03fb4ef2012-12-03 17:08:11 +02001882 /* Force use_shader() to call glUseProgram(), since we need to use
1883 * the recompiled version of the shader. */
1884 gr->current_shader = NULL;
1885
Ander Conselvan de Oliveira27508c22012-11-08 17:20:46 +02001886 wl_list_for_each(output, &ec->output_list, link)
1887 weston_output_damage(output);
1888}
1889
John Kåre Alsaker94659272012-11-13 19:10:18 +01001890static int
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001891gl_renderer_setup(struct weston_compositor *ec, EGLSurface egl_surface)
Kristian Høgsberg25894fc2012-09-05 22:06:26 -04001892{
John Kåre Alsaker779b52a2012-11-13 19:10:29 +01001893 struct gl_renderer *gr = get_renderer(ec);
Kristian Høgsberg25894fc2012-09-05 22:06:26 -04001894 const char *extensions;
Kristian Høgsberg2bc5e8e2012-09-06 20:51:00 -04001895 EGLBoolean ret;
Kristian Høgsberg25894fc2012-09-05 22:06:26 -04001896
Kristian Høgsberg9793fc72012-09-06 21:07:40 -04001897 static const EGLint context_attribs[] = {
1898 EGL_CONTEXT_CLIENT_VERSION, 2,
1899 EGL_NONE
1900 };
1901
Kristian Høgsberg9793fc72012-09-06 21:07:40 -04001902 if (!eglBindAPI(EGL_OPENGL_ES_API)) {
1903 weston_log("failed to bind EGL_OPENGL_ES_API\n");
Pekka Paalanen326529f2012-11-27 12:25:25 +02001904 gl_renderer_print_egl_error_state();
Kristian Høgsberg9793fc72012-09-06 21:07:40 -04001905 return -1;
1906 }
Pekka Paalanen9c3fe252012-10-24 09:43:05 +03001907
John Kåre Alsaker1b7ad162012-11-13 19:10:19 +01001908 log_egl_config_info(gr->egl_display, gr->egl_config);
Pekka Paalanen9c3fe252012-10-24 09:43:05 +03001909
John Kåre Alsaker1b7ad162012-11-13 19:10:19 +01001910 gr->egl_context = eglCreateContext(gr->egl_display, gr->egl_config,
Kristian Høgsberg9793fc72012-09-06 21:07:40 -04001911 EGL_NO_CONTEXT, context_attribs);
John Kåre Alsaker1b7ad162012-11-13 19:10:19 +01001912 if (gr->egl_context == NULL) {
Kristian Høgsberg9793fc72012-09-06 21:07:40 -04001913 weston_log("failed to create context\n");
Pekka Paalanen326529f2012-11-27 12:25:25 +02001914 gl_renderer_print_egl_error_state();
Kristian Høgsberg9793fc72012-09-06 21:07:40 -04001915 return -1;
1916 }
1917
John Kåre Alsaker1b7ad162012-11-13 19:10:19 +01001918 ret = eglMakeCurrent(gr->egl_display, egl_surface,
1919 egl_surface, gr->egl_context);
Kristian Høgsberg2bc5e8e2012-09-06 20:51:00 -04001920 if (ret == EGL_FALSE) {
1921 weston_log("Failed to make EGL context current.\n");
Pekka Paalanen326529f2012-11-27 12:25:25 +02001922 gl_renderer_print_egl_error_state();
Kristian Høgsberg2bc5e8e2012-09-06 20:51:00 -04001923 return -1;
1924 }
1925
John Kåre Alsaker1b7ad162012-11-13 19:10:19 +01001926 log_egl_gl_info(gr->egl_display);
Kristian Høgsberg25894fc2012-09-05 22:06:26 -04001927
John Kåre Alsaker320711d2012-11-13 19:10:27 +01001928 gr->image_target_texture_2d =
Kristian Høgsberg25894fc2012-09-05 22:06:26 -04001929 (void *) eglGetProcAddress("glEGLImageTargetTexture2DOES");
John Kåre Alsaker320711d2012-11-13 19:10:27 +01001930 gr->create_image = (void *) eglGetProcAddress("eglCreateImageKHR");
1931 gr->destroy_image = (void *) eglGetProcAddress("eglDestroyImageKHR");
1932 gr->bind_display =
Kristian Høgsberg25894fc2012-09-05 22:06:26 -04001933 (void *) eglGetProcAddress("eglBindWaylandDisplayWL");
John Kåre Alsaker320711d2012-11-13 19:10:27 +01001934 gr->unbind_display =
Kristian Høgsberg25894fc2012-09-05 22:06:26 -04001935 (void *) eglGetProcAddress("eglUnbindWaylandDisplayWL");
John Kåre Alsaker320711d2012-11-13 19:10:27 +01001936 gr->query_buffer =
Kristian Høgsberg25894fc2012-09-05 22:06:26 -04001937 (void *) eglGetProcAddress("eglQueryWaylandBufferWL");
1938
1939 extensions = (const char *) glGetString(GL_EXTENSIONS);
1940 if (!extensions) {
1941 weston_log("Retrieving GL extension string failed.\n");
1942 return -1;
1943 }
1944
1945 if (!strstr(extensions, "GL_EXT_texture_format_BGRA8888")) {
1946 weston_log("GL_EXT_texture_format_BGRA8888 not available\n");
1947 return -1;
1948 }
1949
1950 if (strstr(extensions, "GL_EXT_read_format_bgra"))
John Kåre Alsakerf9e710b2012-11-13 19:10:22 +01001951 ec->read_format = PIXMAN_a8r8g8b8;
Kristian Høgsberg25894fc2012-09-05 22:06:26 -04001952 else
John Kåre Alsakerf9e710b2012-11-13 19:10:22 +01001953 ec->read_format = PIXMAN_a8b8g8r8;
Kristian Høgsberg25894fc2012-09-05 22:06:26 -04001954
1955 if (strstr(extensions, "GL_EXT_unpack_subimage"))
John Kåre Alsaker320711d2012-11-13 19:10:27 +01001956 gr->has_unpack_subimage = 1;
Kristian Høgsberg25894fc2012-09-05 22:06:26 -04001957
1958 if (strstr(extensions, "GL_OES_EGL_image_external"))
John Kåre Alsaker320711d2012-11-13 19:10:27 +01001959 gr->has_egl_image_external = 1;
Kristian Høgsberg25894fc2012-09-05 22:06:26 -04001960
1961 extensions =
John Kåre Alsaker1b7ad162012-11-13 19:10:19 +01001962 (const char *) eglQueryString(gr->egl_display, EGL_EXTENSIONS);
Kristian Høgsberg25894fc2012-09-05 22:06:26 -04001963 if (!extensions) {
1964 weston_log("Retrieving EGL extension string failed.\n");
1965 return -1;
1966 }
1967
1968 if (strstr(extensions, "EGL_WL_bind_wayland_display"))
John Kåre Alsaker320711d2012-11-13 19:10:27 +01001969 gr->has_bind_display = 1;
1970 if (gr->has_bind_display) {
1971 ret = gr->bind_display(gr->egl_display, ec->wl_display);
Pekka Paalanen035a0322012-10-24 09:43:06 +03001972 if (!ret)
John Kåre Alsaker320711d2012-11-13 19:10:27 +01001973 gr->has_bind_display = 0;
Pekka Paalanen035a0322012-10-24 09:43:06 +03001974 }
Kristian Høgsberg25894fc2012-09-05 22:06:26 -04001975
Ander Conselvan de Oliveira1c169ff2013-03-05 17:30:30 +02001976 if (strstr(extensions, "EGL_EXT_buffer_age"))
1977 gr->has_egl_buffer_age = 1;
1978 else
1979 weston_log("warning: EGL_EXT_buffer_age not supported. "
1980 "Performance could be affected.\n");
1981
Kristian Høgsberg25894fc2012-09-05 22:06:26 -04001982 glActiveTexture(GL_TEXTURE0);
1983
Ander Conselvan de Oliveira27508c22012-11-08 17:20:46 +02001984 if (compile_shaders(ec))
1985 return -1;
1986
1987 weston_compositor_add_debug_binding(ec, KEY_S,
1988 fragment_debug_binding, ec);
1989
Pekka Paalanen035a0322012-10-24 09:43:06 +03001990 weston_log("GL ES 2 renderer features:\n");
1991 weston_log_continue(STAMP_SPACE "read-back format: %s\n",
Pekka Paalanenfe4eacf2013-01-10 16:50:42 +02001992 ec->read_format == PIXMAN_a8r8g8b8 ? "BGRA" : "RGBA");
Pekka Paalanen035a0322012-10-24 09:43:06 +03001993 weston_log_continue(STAMP_SPACE "wl_shm sub-image to texture: %s\n",
John Kåre Alsaker320711d2012-11-13 19:10:27 +01001994 gr->has_unpack_subimage ? "yes" : "no");
Pekka Paalanen035a0322012-10-24 09:43:06 +03001995 weston_log_continue(STAMP_SPACE "EGL Wayland extension: %s\n",
John Kåre Alsaker320711d2012-11-13 19:10:27 +01001996 gr->has_bind_display ? "yes" : "no");
Pekka Paalanen035a0322012-10-24 09:43:06 +03001997
John Kåre Alsaker1b7ad162012-11-13 19:10:19 +01001998
Kristian Høgsberg25894fc2012-09-05 22:06:26 -04001999 return 0;
2000}