1 /**************************************************************************
3 * Copyright 2009 VMware, Inc. All Rights Reserved.
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the
7 * "Software"), to deal in the Software without restriction, including
8 * without limitation the rights to use, copy, modify, merge, publish,
9 * distribute, sub license, and/or sell copies of the Software, and to
10 * permit persons to whom the Software is furnished to do so, subject to
11 * the following conditions:
13 * The above copyright notice and this permission notice (including the
14 * next paragraph) shall be included in all copies or substantial portions
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
20 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
21 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
22 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
23 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 **************************************************************************/
29 #include "matrix.h" /*for floatsEqual*/
30 #include "vg_context.h"
34 #include "util_array.h"
35 #include "VG/openvg.h"
37 #include "pipe/p_context.h"
38 #include "pipe/p_defines.h"
39 #include "pipe/p_state.h"
40 #include "util/u_inlines.h"
41 #include "pipe/p_screen.h"
43 #include "util/u_draw_quad.h"
44 #include "util/u_math.h"
49 #define DEBUG_POLYGON 0
61 struct pipe_buffer
*vbuf
;
62 struct pipe_screen
*screen
;
65 static float *ptr_to_vertex(float *data
, int idx
)
67 return data
+ (idx
* COMPONENTS
);
71 static void polygon_print(struct polygon
*poly
)
75 debug_printf("Polygon %p, size = %d\n", poly
, poly
->num_verts
);
76 for (i
= 0; i
< poly
->num_verts
; ++i
) {
77 vert
= ptr_to_vertex(poly
->data
, i
);
78 debug_printf("%f, %f, ", vert
[0], vert
[1]);
80 debug_printf("\nend\n");
85 struct polygon
* polygon_create(int size
)
87 struct polygon
*poly
= (struct polygon
*)malloc(sizeof(struct polygon
));
89 poly
->data
= malloc(sizeof(float) * COMPONENTS
* size
);
92 poly
->dirty
= VG_TRUE
;
98 struct polygon
* polygon_create_from_data(float *data
, int size
)
100 struct polygon
*poly
= polygon_create(size
);
102 memcpy(poly
->data
, data
, sizeof(float) * COMPONENTS
* size
);
103 poly
->num_verts
= size
;
104 poly
->dirty
= VG_TRUE
;
110 void polygon_destroy(struct polygon
*poly
)
113 pipe_buffer_reference(&poly
->vbuf
, NULL
);
119 void polygon_resize(struct polygon
*poly
, int new_size
)
121 float *data
= (float*)malloc(sizeof(float) * COMPONENTS
* new_size
);
122 int size
= MIN2(sizeof(float) * COMPONENTS
* new_size
,
123 sizeof(float) * COMPONENTS
* poly
->size
);
124 memcpy(data
, poly
->data
, size
);
127 poly
->size
= new_size
;
128 poly
->dirty
= VG_TRUE
;
131 int polygon_size(struct polygon
*poly
)
136 int polygon_vertex_count(struct polygon
*poly
)
138 return poly
->num_verts
;
141 float * polygon_data(struct polygon
*poly
)
146 void polygon_vertex_append(struct polygon
*p
,
151 debug_printf("Append vertex [%f, %f]\n", x
, y
);
153 if (p
->num_verts
>= p
->size
) {
154 polygon_resize(p
, p
->size
* 2);
157 vert
= ptr_to_vertex(p
->data
, p
->num_verts
);
164 void polygon_set_vertex(struct polygon
*p
, int idx
,
168 if (idx
>= p
->num_verts
) {
169 /*fixme: error reporting*/
174 vert
= ptr_to_vertex(p
->data
, idx
);
180 void polygon_vertex(struct polygon
*p
, int idx
,
184 if (idx
>= p
->num_verts
) {
185 /*fixme: error reporting*/
190 vert
= ptr_to_vertex(p
->data
, idx
);
195 void polygon_bounding_rect(struct polygon
*p
,
199 float minx
, miny
, maxx
, maxy
;
200 float *vert
= ptr_to_vertex(p
->data
, 0);
206 for (i
= 1; i
< p
->num_verts
; ++i
) {
207 vert
= ptr_to_vertex(p
->data
, i
);
208 minx
= MIN2(vert
[0], minx
);
209 miny
= MIN2(vert
[1], miny
);
211 maxx
= MAX2(vert
[0], maxx
);
212 maxy
= MAX2(vert
[1], maxy
);
217 rect
[2] = maxx
- minx
;
218 rect
[3] = maxy
- miny
;
221 int polygon_contains_point(struct polygon
*p
,
227 void polygon_append_polygon(struct polygon
*dst
,
230 if (dst
->num_verts
+ src
->num_verts
>= dst
->size
) {
231 polygon_resize(dst
, dst
->num_verts
+ src
->num_verts
* 1.5);
233 memcpy(ptr_to_vertex(dst
->data
, dst
->num_verts
),
234 src
->data
, src
->num_verts
* COMPONENTS
* sizeof(VGfloat
));
235 dst
->num_verts
+= src
->num_verts
;
238 VGboolean
polygon_is_closed(struct polygon
*p
)
240 VGfloat start
[2], end
[2];
242 polygon_vertex(p
, 0, start
);
243 polygon_vertex(p
, p
->num_verts
- 1, end
);
245 return floatsEqual(start
[0], end
[0]) && floatsEqual(start
[1], end
[1]);
248 static void set_blend_for_fill(struct pipe_blend_state
*blend
)
250 memset(blend
, 0, sizeof(struct pipe_blend_state
));
251 blend
->rt
[0].colormask
= 0; /*disable colorwrites*/
253 blend
->rt
[0].rgb_src_factor
= PIPE_BLENDFACTOR_ONE
;
254 blend
->rt
[0].alpha_src_factor
= PIPE_BLENDFACTOR_ONE
;
255 blend
->rt
[0].rgb_dst_factor
= PIPE_BLENDFACTOR_INV_SRC_ALPHA
;
256 blend
->rt
[0].alpha_dst_factor
= PIPE_BLENDFACTOR_INV_SRC_ALPHA
;
259 static void draw_polygon(struct vg_context
*ctx
,
260 struct polygon
*poly
)
263 struct pipe_context
*pipe
;
264 struct pipe_vertex_buffer vbuffer
;
265 struct pipe_vertex_element velement
;
267 vert_size
= poly
->num_verts
* COMPONENTS
* sizeof(float);
269 /*polygon_print(poly);*/
273 if (poly
->vbuf
== NULL
|| poly
->dirty
) {
275 pipe_buffer_reference(&poly
->vbuf
,
278 poly
->screen
= pipe
->screen
;
279 poly
->vbuf
= pipe_user_buffer_create(poly
->screen
,
282 poly
->dirty
= VG_FALSE
;
286 /* tell pipe about the vertex buffer */
287 memset(&vbuffer
, 0, sizeof(vbuffer
));
288 vbuffer
.buffer
= poly
->vbuf
;
289 vbuffer
.stride
= COMPONENTS
* sizeof(float); /* vertex size */
290 vbuffer
.buffer_offset
= 0;
291 vbuffer
.max_index
= poly
->num_verts
- 1;
292 pipe
->set_vertex_buffers(pipe
, 1, &vbuffer
);
294 /* tell pipe about the vertex attributes */
295 velement
.src_offset
= 0;
296 velement
.instance_divisor
= 0;
297 velement
.vertex_buffer_index
= 0;
298 velement
.src_format
= PIPE_FORMAT_R32G32_FLOAT
;
299 velement
.nr_components
= COMPONENTS
;
300 pipe
->set_vertex_elements(pipe
, 1, &velement
);
303 pipe
->draw_arrays(pipe
, PIPE_PRIM_TRIANGLE_FAN
,
307 void polygon_fill(struct polygon
*poly
, struct vg_context
*ctx
)
309 struct pipe_depth_stencil_alpha_state dsa
;
310 struct pipe_stencil_ref sr
;
311 struct pipe_blend_state blend
;
313 VGfloat min_x
, min_y
, max_x
, max_y
;
315 polygon_bounding_rect(poly
, bounds
);
318 max_x
= bounds
[0] + bounds
[2];
319 max_y
= bounds
[1] + bounds
[3];
322 debug_printf("Poly bounds are [%f, %f], [%f, %f]\n",
323 min_x
, min_y
, max_x
, max_y
);
326 set_blend_for_fill(&blend
);
328 memset(&dsa
, 0, sizeof(struct pipe_depth_stencil_alpha_state
));
329 memset(&sr
, 0, sizeof(struct pipe_stencil_ref
));
330 /* only need a fixed 0. Rely on default or move it out at least? */
331 cso_set_stencil_ref(ctx
->cso_context
, &sr
);
333 cso_save_blend(ctx
->cso_context
);
334 cso_save_depth_stencil_alpha(ctx
->cso_context
);
336 dsa
.stencil
[0].enabled
= 1;
337 if (ctx
->state
.vg
.fill_rule
== VG_EVEN_ODD
) {
338 dsa
.stencil
[0].writemask
= 1;
339 dsa
.stencil
[0].fail_op
= PIPE_STENCIL_OP_KEEP
;
340 dsa
.stencil
[0].zfail_op
= PIPE_STENCIL_OP_KEEP
;
341 dsa
.stencil
[0].zpass_op
= PIPE_STENCIL_OP_INVERT
;
342 dsa
.stencil
[0].func
= PIPE_FUNC_ALWAYS
;
343 dsa
.stencil
[0].valuemask
= ~0;
345 cso_set_blend(ctx
->cso_context
, &blend
);
346 cso_set_depth_stencil_alpha(ctx
->cso_context
, &dsa
);
347 draw_polygon(ctx
, poly
);
348 } else if (ctx
->state
.vg
.fill_rule
== VG_NON_ZERO
) {
349 struct pipe_screen
*screen
= ctx
->pipe
->screen
;
351 if (screen
->get_param(screen
, PIPE_CAP_TWO_SIDED_STENCIL
)) {
353 dsa
.stencil
[0].writemask
= ~0;
354 dsa
.stencil
[0].fail_op
= PIPE_STENCIL_OP_KEEP
;
355 dsa
.stencil
[0].zfail_op
= PIPE_STENCIL_OP_KEEP
;
356 dsa
.stencil
[0].zpass_op
= PIPE_STENCIL_OP_INCR_WRAP
;
357 dsa
.stencil
[0].func
= PIPE_FUNC_ALWAYS
;
358 dsa
.stencil
[0].valuemask
= ~0;
361 dsa
.stencil
[1].enabled
= 1;
362 dsa
.stencil
[1].writemask
= ~0;
363 dsa
.stencil
[1].fail_op
= PIPE_STENCIL_OP_KEEP
;
364 dsa
.stencil
[1].zfail_op
= PIPE_STENCIL_OP_KEEP
;
365 dsa
.stencil
[1].zpass_op
= PIPE_STENCIL_OP_DECR_WRAP
;
366 dsa
.stencil
[1].func
= PIPE_FUNC_ALWAYS
;
367 dsa
.stencil
[1].valuemask
= ~0;
369 cso_set_blend(ctx
->cso_context
, &blend
);
370 cso_set_depth_stencil_alpha(ctx
->cso_context
, &dsa
);
371 draw_polygon(ctx
, poly
);
373 struct pipe_rasterizer_state raster
;
375 memcpy(&raster
, &ctx
->state
.g3d
.rasterizer
, sizeof(struct pipe_rasterizer_state
));
377 cso_save_rasterizer(ctx
->cso_context
);
378 dsa
.stencil
[0].func
= PIPE_FUNC_ALWAYS
;
379 dsa
.stencil
[0].valuemask
= ~0;
381 raster
.cull_mode
= raster
.front_winding
^ PIPE_WINDING_BOTH
;
382 dsa
.stencil
[0].fail_op
= PIPE_STENCIL_OP_KEEP
;
383 dsa
.stencil
[0].zfail_op
= PIPE_STENCIL_OP_KEEP
;
384 dsa
.stencil
[0].zpass_op
= PIPE_STENCIL_OP_INCR_WRAP
;
386 cso_set_blend(ctx
->cso_context
, &blend
);
387 cso_set_depth_stencil_alpha(ctx
->cso_context
, &dsa
);
388 cso_set_rasterizer(ctx
->cso_context
, &raster
);
389 draw_polygon(ctx
, poly
);
391 raster
.cull_mode
= raster
.front_winding
;
392 dsa
.stencil
[0].fail_op
= PIPE_STENCIL_OP_KEEP
;
393 dsa
.stencil
[0].zfail_op
= PIPE_STENCIL_OP_KEEP
;
394 dsa
.stencil
[0].zpass_op
= PIPE_STENCIL_OP_DECR_WRAP
;
395 cso_set_depth_stencil_alpha(ctx
->cso_context
, &dsa
);
396 cso_set_rasterizer(ctx
->cso_context
, &raster
);
397 draw_polygon(ctx
, poly
);
399 cso_restore_rasterizer(ctx
->cso_context
);
403 /* restore color writes */
404 cso_restore_blend(ctx
->cso_context
);
405 /* setup stencil ops */
406 dsa
.stencil
[0].func
= PIPE_FUNC_NOTEQUAL
;
407 dsa
.stencil
[0].fail_op
= PIPE_STENCIL_OP_REPLACE
;
408 dsa
.stencil
[0].zfail_op
= PIPE_STENCIL_OP_REPLACE
;
409 dsa
.stencil
[0].zpass_op
= PIPE_STENCIL_OP_REPLACE
;
410 dsa
.stencil
[0].valuemask
= dsa
.stencil
[0].writemask
;
411 dsa
.stencil
[1].enabled
= 0;
412 memcpy(&dsa
.depth
, &ctx
->state
.g3d
.dsa
.depth
,
413 sizeof(struct pipe_depth_state
));
414 cso_set_depth_stencil_alpha(ctx
->cso_context
, &dsa
);
416 /* render the quad to propagate the rendering from stencil */
417 renderer_draw_quad(ctx
->renderer
, min_x
, min_y
,
418 max_x
, max_y
, 0.0f
/*depth should be disabled*/);
420 cso_restore_depth_stencil_alpha(ctx
->cso_context
);
423 void polygon_array_fill(struct polygon_array
*polyarray
, struct vg_context
*ctx
)
425 struct array
*polys
= polyarray
->array
;
426 struct pipe_depth_stencil_alpha_state dsa
;
427 struct pipe_stencil_ref sr
;
428 struct pipe_blend_state blend
;
429 VGfloat min_x
= polyarray
->min_x
;
430 VGfloat min_y
= polyarray
->min_y
;
431 VGfloat max_x
= polyarray
->max_x
;
432 VGfloat max_y
= polyarray
->max_y
;
437 debug_printf("%s: Poly bounds are [%f, %f], [%f, %f]\n",
439 min_x
, min_y
, max_x
, max_y
);
442 set_blend_for_fill(&blend
);
444 memset(&dsa
, 0, sizeof(struct pipe_depth_stencil_alpha_state
));
445 memset(&sr
, 0, sizeof(struct pipe_stencil_ref
));
446 /* only need a fixed 0. Rely on default or move it out at least? */
447 cso_set_stencil_ref(ctx
->cso_context
, &sr
);
449 cso_save_blend(ctx
->cso_context
);
450 cso_save_depth_stencil_alpha(ctx
->cso_context
);
452 dsa
.stencil
[0].enabled
= 1;
453 if (ctx
->state
.vg
.fill_rule
== VG_EVEN_ODD
) {
454 dsa
.stencil
[0].writemask
= 1;
455 dsa
.stencil
[0].fail_op
= PIPE_STENCIL_OP_KEEP
;
456 dsa
.stencil
[0].zfail_op
= PIPE_STENCIL_OP_KEEP
;
457 dsa
.stencil
[0].zpass_op
= PIPE_STENCIL_OP_INVERT
;
458 dsa
.stencil
[0].func
= PIPE_FUNC_ALWAYS
;
459 dsa
.stencil
[0].valuemask
= ~0;
461 cso_set_blend(ctx
->cso_context
, &blend
);
462 cso_set_depth_stencil_alpha(ctx
->cso_context
, &dsa
);
463 for (i
= 0; i
< polys
->num_elements
; ++i
) {
464 struct polygon
*poly
= (((struct polygon
**)polys
->data
)[i
]);
465 draw_polygon(ctx
, poly
);
467 } else if (ctx
->state
.vg
.fill_rule
== VG_NON_ZERO
) {
468 struct pipe_screen
*screen
= ctx
->pipe
->screen
;
470 if (screen
->get_param(screen
, PIPE_CAP_TWO_SIDED_STENCIL
)) {
472 dsa
.stencil
[0].writemask
= ~0;
473 dsa
.stencil
[0].fail_op
= PIPE_STENCIL_OP_KEEP
;
474 dsa
.stencil
[0].zfail_op
= PIPE_STENCIL_OP_KEEP
;
475 dsa
.stencil
[0].zpass_op
= PIPE_STENCIL_OP_INCR_WRAP
;
476 dsa
.stencil
[0].func
= PIPE_FUNC_ALWAYS
;
477 dsa
.stencil
[0].valuemask
= ~0;
480 dsa
.stencil
[1].enabled
= 1;
481 dsa
.stencil
[1].writemask
= ~0;
482 dsa
.stencil
[1].fail_op
= PIPE_STENCIL_OP_KEEP
;
483 dsa
.stencil
[1].zfail_op
= PIPE_STENCIL_OP_KEEP
;
484 dsa
.stencil
[1].zpass_op
= PIPE_STENCIL_OP_DECR_WRAP
;
485 dsa
.stencil
[1].func
= PIPE_FUNC_ALWAYS
;
486 dsa
.stencil
[1].valuemask
= ~0;
488 cso_set_blend(ctx
->cso_context
, &blend
);
489 cso_set_depth_stencil_alpha(ctx
->cso_context
, &dsa
);
490 for (i
= 0; i
< polys
->num_elements
; ++i
) {
491 struct polygon
*poly
= (((struct polygon
**)polys
->data
)[i
]);
492 draw_polygon(ctx
, poly
);
495 struct pipe_rasterizer_state raster
;
497 memcpy(&raster
, &ctx
->state
.g3d
.rasterizer
, sizeof(struct pipe_rasterizer_state
));
499 cso_save_rasterizer(ctx
->cso_context
);
500 dsa
.stencil
[0].func
= PIPE_FUNC_ALWAYS
;
501 dsa
.stencil
[0].valuemask
= ~0;
503 raster
.cull_mode
= raster
.front_winding
^ PIPE_WINDING_BOTH
;
504 dsa
.stencil
[0].fail_op
= PIPE_STENCIL_OP_KEEP
;
505 dsa
.stencil
[0].zfail_op
= PIPE_STENCIL_OP_KEEP
;
506 dsa
.stencil
[0].zpass_op
= PIPE_STENCIL_OP_INCR_WRAP
;
508 cso_set_blend(ctx
->cso_context
, &blend
);
509 cso_set_depth_stencil_alpha(ctx
->cso_context
, &dsa
);
510 cso_set_rasterizer(ctx
->cso_context
, &raster
);
511 for (i
= 0; i
< polys
->num_elements
; ++i
) {
512 struct polygon
*poly
= (((struct polygon
**)polys
->data
)[i
]);
513 draw_polygon(ctx
, poly
);
516 raster
.cull_mode
= raster
.front_winding
;
517 dsa
.stencil
[0].fail_op
= PIPE_STENCIL_OP_KEEP
;
518 dsa
.stencil
[0].zfail_op
= PIPE_STENCIL_OP_KEEP
;
519 dsa
.stencil
[0].zpass_op
= PIPE_STENCIL_OP_DECR_WRAP
;
520 cso_set_depth_stencil_alpha(ctx
->cso_context
, &dsa
);
521 cso_set_rasterizer(ctx
->cso_context
, &raster
);
522 for (i
= 0; i
< polys
->num_elements
; ++i
) {
523 struct polygon
*poly
= (((struct polygon
**)polys
->data
)[i
]);
524 draw_polygon(ctx
, poly
);
527 cso_restore_rasterizer(ctx
->cso_context
);
531 /* restore color writes */
532 cso_restore_blend(ctx
->cso_context
);
533 /* setup stencil ops */
534 dsa
.stencil
[0].func
= PIPE_FUNC_NOTEQUAL
;
535 dsa
.stencil
[0].fail_op
= PIPE_STENCIL_OP_REPLACE
;
536 dsa
.stencil
[0].zfail_op
= PIPE_STENCIL_OP_REPLACE
;
537 dsa
.stencil
[0].zpass_op
= PIPE_STENCIL_OP_REPLACE
;
538 dsa
.stencil
[0].valuemask
= dsa
.stencil
[0].writemask
;
539 dsa
.stencil
[1].enabled
= 0;
540 memcpy(&dsa
.depth
, &ctx
->state
.g3d
.dsa
.depth
,
541 sizeof(struct pipe_depth_state
));
542 cso_set_depth_stencil_alpha(ctx
->cso_context
, &dsa
);
544 /* render the quad to propagate the rendering from stencil */
545 renderer_draw_quad(ctx
->renderer
, min_x
, min_y
,
546 max_x
, max_y
, 0.0f
/*depth should be disabled*/);
548 cso_restore_depth_stencil_alpha(ctx
->cso_context
);