1 /**************************************************************************
2  *
3  * Copyright 2009 VMware, Inc.  All Rights Reserved.
4  *
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:
12  *
13  * The above copyright notice and this permission notice (including the
14  * next paragraph) shall be included in all copies or substantial portions
15  * of the Software.
16  *
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.
24  *
25  **************************************************************************/
26 
27 #include "VG/openvg.h"
28 
29 #include "mask.h"
30 #include "api.h"
31 #include "handle.h"
32 #include "renderer.h"
33 
34 #include "vg_context.h"
35 #include "pipe/p_context.h"
36 
vegaMask(VGHandle mask,VGMaskOperation operation,VGint x,VGint y,VGint width,VGint height)37 void vegaMask(VGHandle mask, VGMaskOperation operation,
38               VGint x, VGint y,
39               VGint width, VGint height)
40 {
41    struct vg_context *ctx = vg_current_context();
42 
43    if (width <=0 || height <= 0) {
44       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
45       return;
46    }
47 
48    if (operation < VG_CLEAR_MASK || operation > VG_SUBTRACT_MASK) {
49       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
50       return;
51    }
52 
53 
54    vg_validate_state(ctx);
55 
56    if (operation == VG_CLEAR_MASK) {
57       mask_fill(x, y, width, height, 0.f);
58    } else if (operation == VG_FILL_MASK) {
59       mask_fill(x, y, width, height, 1.f);
60    } else if (vg_object_is_valid(mask, VG_OBJECT_IMAGE)) {
61       struct vg_image *image = handle_to_image(mask);
62       mask_using_image(image, operation, x, y, width, height);
63    } else if (vg_object_is_valid(mask, VG_OBJECT_MASK)) {
64       struct vg_mask_layer *layer = handle_to_masklayer(mask);
65       mask_using_layer(layer, operation, x, y, width, height);
66    } else {
67       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
68    }
69 }
70 
vegaClear(VGint x,VGint y,VGint width,VGint height)71 void vegaClear(VGint x, VGint y,
72                VGint width, VGint height)
73 {
74    struct vg_context *ctx = vg_current_context();
75    struct st_framebuffer *stfb = ctx->draw_buffer;
76 
77    if (width <= 0 || height <= 0) {
78       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
79       return;
80    }
81 
82    vg_validate_state(ctx);
83 #if 0
84    debug_printf("Clear [%d, %d, %d, %d] with [%f, %f, %f, %f]\n",
85                 x, y, width, height,
86                 ctx->state.vg.clear_color[0],
87                 ctx->state.vg.clear_color[1],
88                 ctx->state.vg.clear_color[2],
89                 ctx->state.vg.clear_color[3]);
90 #endif
91 
92    /* check for a whole surface clear */
93    if (!ctx->state.vg.scissoring &&
94        (x == 0 && y == 0 && width == stfb->width && height == stfb->height)) {
95       union pipe_color_union clear_color;
96       clear_color.f[0] = ctx->state.vg.clear_color[0];
97       clear_color.f[1] = ctx->state.vg.clear_color[1];
98       clear_color.f[2] = ctx->state.vg.clear_color[2];
99       clear_color.f[3] = ctx->state.vg.clear_color[3];
100       ctx->pipe->clear(ctx->pipe, PIPE_CLEAR_COLOR | PIPE_CLEAR_DEPTHSTENCIL,
101                        &clear_color, 1., 0);
102    } else if (renderer_clear_begin(ctx->renderer)) {
103       /* XXX verify coord round-off */
104       renderer_clear(ctx->renderer, x, y, width, height, ctx->state.vg.clear_color);
105       renderer_clear_end(ctx->renderer);
106    }
107 }
108 
109 
110 #ifdef OPENVG_VERSION_1_1
111 
112 
vegaRenderToMask(VGPath path,VGbitfield paintModes,VGMaskOperation operation)113 void vegaRenderToMask(VGPath path,
114                       VGbitfield paintModes,
115                       VGMaskOperation operation)
116 {
117    struct vg_context *ctx = vg_current_context();
118 
119    if (path == VG_INVALID_HANDLE) {
120       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
121       return;
122    }
123    if (!paintModes || (paintModes&(~(VG_STROKE_PATH|VG_FILL_PATH)))) {
124       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
125       return;
126    }
127    if (operation < VG_CLEAR_MASK ||
128        operation > VG_SUBTRACT_MASK) {
129       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
130       return;
131    }
132    if (!vg_object_is_valid(path, VG_OBJECT_PATH)) {
133       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
134       return;
135    }
136 
137    vg_validate_state(ctx);
138 
139    mask_render_to(handle_to_path(path), paintModes, operation);
140 }
141 
vegaCreateMaskLayer(VGint width,VGint height)142 VGMaskLayer vegaCreateMaskLayer(VGint width, VGint height)
143 {
144    struct vg_context *ctx = vg_current_context();
145 
146    if (width <= 0 || height <= 0 ||
147        width > vegaGeti(VG_MAX_IMAGE_WIDTH) ||
148        height > vegaGeti(VG_MAX_IMAGE_HEIGHT)) {
149       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
150       return VG_INVALID_HANDLE;
151    }
152 
153    return masklayer_to_handle(mask_layer_create(width, height));
154 }
155 
vegaDestroyMaskLayer(VGMaskLayer maskLayer)156 void vegaDestroyMaskLayer(VGMaskLayer maskLayer)
157 {
158    struct vg_mask_layer *mask = 0;
159    struct vg_context *ctx = vg_current_context();
160 
161    if (maskLayer == VG_INVALID_HANDLE) {
162       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
163       return;
164    }
165    if (!vg_object_is_valid(maskLayer, VG_OBJECT_MASK)) {
166       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
167       return;
168    }
169 
170    mask = handle_to_masklayer(maskLayer);
171    mask_layer_destroy(mask);
172 }
173 
vegaFillMaskLayer(VGMaskLayer maskLayer,VGint x,VGint y,VGint width,VGint height,VGfloat value)174 void vegaFillMaskLayer(VGMaskLayer maskLayer,
175                        VGint x, VGint y,
176                        VGint width, VGint height,
177                        VGfloat value)
178 {
179    struct vg_mask_layer *mask = 0;
180    struct vg_context *ctx = vg_current_context();
181 
182    if (maskLayer == VG_INVALID_HANDLE) {
183       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
184       return;
185    }
186 
187    if (value < 0 || value > 1) {
188       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
189       return;
190    }
191 
192    if (width <= 0 || height <= 0) {
193       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
194       return;
195    }
196    if (x < 0 || y < 0 || (x + width) < 0 || (y + height) < 0) {
197       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
198       return;
199    }
200 
201    if (!vg_object_is_valid(maskLayer, VG_OBJECT_MASK)) {
202       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
203       return;
204    }
205 
206    mask = handle_to_masklayer(maskLayer);
207 
208    if (x + width > mask_layer_width(mask) ||
209        y + height > mask_layer_height(mask)) {
210       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
211       return;
212    }
213 
214    vg_validate_state(ctx);
215 
216    mask_layer_fill(mask, x, y, width, height, value);
217 }
218 
vegaCopyMask(VGMaskLayer maskLayer,VGint sx,VGint sy,VGint dx,VGint dy,VGint width,VGint height)219 void vegaCopyMask(VGMaskLayer maskLayer,
220                   VGint sx, VGint sy,
221                   VGint dx, VGint dy,
222                   VGint width, VGint height)
223 {
224    struct vg_context *ctx = vg_current_context();
225    struct vg_mask_layer *mask = 0;
226 
227    if (maskLayer == VG_INVALID_HANDLE) {
228       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
229       return;
230    }
231    if (width <= 0 || height <= 0) {
232       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
233       return;
234    }
235    if (!vg_object_is_valid(maskLayer, VG_OBJECT_MASK)) {
236       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
237       return;
238    }
239 
240    vg_validate_state(ctx);
241 
242    mask = handle_to_masklayer(maskLayer);
243    mask_copy(mask, sx, sy, dx, dy, width, height);
244 }
245 
246 #endif
247