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