src/gallium/state_trackers/vega/api_masks.c

   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 "renderer.h"
  31
  32 #include "vg_context.h"
  33 #include "pipe/p_context.h"
  34 #include "util/u_inlines.h"
  35
  36 #include "util/u_pack_color.h"
  37 #include "util/u_draw_quad.h"
  38 #include "util/u_memory.h"
  39
  40
  41 #define DISABLE_1_1_MASKING 1
  42
  43 /**
  44  * Draw a screen-aligned quadrilateral.
  45  * Coords are window coords with y=0=bottom.  These coords will be transformed
  46  * by the vertex shader and viewport transform.
  47  */
  48 static void
  49 draw_clear_quad(struct vg_context *st,
  50                 float x0, float y0, float x1, float y1, float z,
  51                 const VGfloat color[4])
  52 {
  53    struct pipe_context *pipe = st->pipe;
  54    struct pipe_buffer *buf;
  55    VGuint i;
  56
  57    /* positions */
  58    st->clear.vertices[0][0][0] = x0;
  59    st->clear.vertices[0][0][1] = y0;
  60
  61    st->clear.vertices[1][0][0] = x1;
  62    st->clear.vertices[1][0][1] = y0;
  63
  64    st->clear.vertices[2][0][0] = x1;
  65    st->clear.vertices[2][0][1] = y1;
  66
  67    st->clear.vertices[3][0][0] = x0;
  68    st->clear.vertices[3][0][1] = y1;
  69
  70    /* same for all verts: */
  71    for (i = 0; i < 4; i++) {
  72       st->clear.vertices[i][0][2] = z;
  73       st->clear.vertices[i][0][3] = 1.0;
  74       st->clear.vertices[i][1][0] = color[0];
  75       st->clear.vertices[i][1][1] = color[1];
  76       st->clear.vertices[i][1][2] = color[2];
  77       st->clear.vertices[i][1][3] = color[3];
  78    }
  79
  80
  81    /* put vertex data into vbuf */
  82    buf =  pipe_user_buffer_create(pipe->screen,
  83                                   st->clear.vertices,
  84                                   sizeof(st->clear.vertices));
  85
  86
  87    /* draw */
  88    if (buf) {
  89       cso_set_vertex_elements(st->cso_context, 2, st->velems);
  90
  91       util_draw_vertex_buffer(pipe, buf, 0,
  92                               PIPE_PRIM_TRIANGLE_FAN,
  93                               4,  /* verts */
  94                               2); /* attribs/vert */
  95
  96       pipe_buffer_reference(&buf, NULL);
  97    }
  98 }
  99
 100 /**
 101  * Do vgClear by drawing a quadrilateral.
 102  */
 103 static void
 104 clear_with_quad(struct vg_context *st, float x0, float y0,
 105                 float width, float height, const VGfloat clear_color[4])
 106 {
 107    VGfloat x1, y1;
 108
 109    vg_validate_state(st);
 110
 111    x1 = x0 + width;
 112    y1 = y0 + height;
 113
 114    /*
 115      printf("%s %f,%f %f,%f\n", __FUNCTION__,
 116      x0, y0,
 117      x1, y1);
 118    */
 119
 120    if (st->pipe->screen && st->pipe->screen->update_buffer)
 121       st->pipe->screen->update_buffer( st->pipe->screen,
 122                                        st->pipe->priv );
 123
 124    cso_save_blend(st->cso_context);
 125    cso_save_rasterizer(st->cso_context);
 126    cso_save_fragment_shader(st->cso_context);
 127    cso_save_vertex_shader(st->cso_context);
 128
 129    /* blend state: RGBA masking */
 130    {
 131       struct pipe_blend_state blend;
 132       memset(&blend, 0, sizeof(blend));
 133       blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_ONE;
 134       blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE;
 135       blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_ZERO;
 136       blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO;
 137       blend.rt[0].colormask = PIPE_MASK_RGBA;
 138       cso_set_blend(st->cso_context, &blend);
 139    }
 140
 141    cso_set_rasterizer(st->cso_context, &st->clear.raster);
 142
 143    cso_set_fragment_shader_handle(st->cso_context, st->clear.fs);
 144    cso_set_vertex_shader_handle(st->cso_context, vg_clear_vs(st));
 145
 146    /* draw quad matching scissor rect (XXX verify coord round-off) */
 147    draw_clear_quad(st, x0, y0, x1, y1, 0, clear_color);
 148
 149    /* Restore pipe state */
 150    cso_restore_blend(st->cso_context);
 151    cso_restore_rasterizer(st->cso_context);
 152    cso_restore_fragment_shader(st->cso_context);
 153    cso_restore_vertex_shader(st->cso_context);
 154 }
 155
 156
 157 void vgMask(VGHandle mask, VGMaskOperation operation,
 158             VGint x, VGint y,
 159             VGint width, VGint height)
 160 {
 161    struct vg_context *ctx = vg_current_context();
 162
 163    if (width <=0 || height <= 0) {
 164       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
 165       return;
 166    }
 167
 168    if (operation < VG_CLEAR_MASK || operation > VG_SUBTRACT_MASK) {
 169       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
 170       return;
 171    }
 172
 173
 174    vg_validate_state(ctx);
 175
 176    if (operation == VG_CLEAR_MASK) {
 177       mask_fill(x, y, width, height, 0.f);
 178    } else if (operation == VG_FILL_MASK) {
 179       mask_fill(x, y, width, height, 1.f);
 180    } else if (vg_object_is_valid((void*)mask, VG_OBJECT_IMAGE)) {
 181       struct vg_image *image = (struct vg_image *)mask;
 182       mask_using_image(image, operation, x, y, width, height);
 183    } else if (vg_object_is_valid((void*)mask, VG_OBJECT_MASK)) {
 184 #if DISABLE_1_1_MASKING
 185       return;
 186 #else
 187       struct vg_mask_layer *layer = (struct vg_mask_layer *)mask;
 188       mask_using_layer(layer, operation, x, y, width, height);
 189 #endif
 190    } else {
 191       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
 192    }
 193 }
 194
 195 void vgClear(VGint x, VGint y,
 196              VGint width, VGint height)
 197 {
 198    struct vg_context *ctx = vg_current_context();
 199    struct pipe_framebuffer_state *fb;
 200
 201    if (width <= 0 || height <= 0) {
 202       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
 203       return;
 204    }
 205
 206    vg_validate_state(ctx);
 207 #if 0
 208    debug_printf("Clear [%d, %d, %d, %d] with [%f, %f, %f, %f]\n",
 209                 x, y, width, height,
 210                 ctx->state.vg.clear_color[0],
 211                 ctx->state.vg.clear_color[1],
 212                 ctx->state.vg.clear_color[2],
 213                 ctx->state.vg.clear_color[3]);
 214 #endif
 215
 216    fb = &ctx->state.g3d.fb;
 217    /* check for a whole surface clear */
 218    if (!ctx->state.vg.scissoring &&
 219        (x == 0 && y == 0 && width == fb->width && height == fb->height)) {
 220       ctx->pipe->clear(ctx->pipe, PIPE_CLEAR_COLOR | PIPE_CLEAR_DEPTHSTENCIL,
 221                        ctx->state.vg.clear_color, 1., 0);
 222    } else {
 223       clear_with_quad(ctx, x, y, width, height, ctx->state.vg.clear_color);
 224    }
 225 }
 226
 227
 228 #ifdef OPENVG_VERSION_1_1
 229
 230
 231 void vgRenderToMask(VGPath path,
 232                     VGbitfield paintModes,
 233                     VGMaskOperation operation)
 234 {
 235    struct vg_context *ctx = vg_current_context();
 236
 237    if (path == VG_INVALID_HANDLE) {
 238       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
 239       return;
 240    }
 241    if (!paintModes || (paintModes&(~(VG_STROKE_PATH|VG_FILL_PATH)))) {
 242       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
 243       return;
 244    }
 245    if (operation < VG_CLEAR_MASK ||
 246        operation > VG_SUBTRACT_MASK) {
 247       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
 248       return;
 249    }
 250    if (!vg_object_is_valid((void*)path, VG_OBJECT_PATH)) {
 251       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
 252       return;
 253    }
 254
 255 #if DISABLE_1_1_MASKING
 256    return;
 257 #endif
 258
 259    vg_validate_state(ctx);
 260
 261    mask_render_to((struct path *)path, paintModes, operation);
 262 }
 263
 264 VGMaskLayer vgCreateMaskLayer(VGint width, VGint height)
 265 {
 266    struct vg_context *ctx = vg_current_context();
 267
 268    if (width <= 0 || height <= 0 ||
 269        width > vgGeti(VG_MAX_IMAGE_WIDTH) ||
 270        height > vgGeti(VG_MAX_IMAGE_HEIGHT)) {
 271       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
 272       return VG_INVALID_HANDLE;
 273    }
 274
 275    return (VGMaskLayer)mask_layer_create(width, height);
 276 }
 277
 278 void vgDestroyMaskLayer(VGMaskLayer maskLayer)
 279 {
 280    struct vg_mask_layer *mask = 0;
 281    struct vg_context *ctx = vg_current_context();
 282
 283    if (maskLayer == VG_INVALID_HANDLE) {
 284       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
 285       return;
 286    }
 287    if (!vg_object_is_valid((void*)maskLayer, VG_OBJECT_MASK)) {
 288       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
 289       return;
 290    }
 291
 292    mask = (struct vg_mask_layer *)maskLayer;
 293    mask_layer_destroy(mask);
 294 }
 295
 296 void vgFillMaskLayer(VGMaskLayer maskLayer,
 297                      VGint x, VGint y,
 298                      VGint width, VGint height,
 299                      VGfloat value)
 300 {
 301    struct vg_mask_layer *mask = 0;
 302    struct vg_context *ctx = vg_current_context();
 303
 304    if (maskLayer == VG_INVALID_HANDLE) {
 305       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
 306       return;
 307    }
 308
 309    if (value < 0 || value > 1) {
 310       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
 311       return;
 312    }
 313
 314    if (width <= 0 || height <= 0) {
 315       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
 316       return;
 317    }
 318    if (x < 0 || y < 0 || (x + width) < 0 || (y + height) < 0) {
 319       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
 320       return;
 321    }
 322
 323    if (!vg_object_is_valid((void*)maskLayer, VG_OBJECT_MASK)) {
 324       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
 325       return;
 326    }
 327
 328    mask = (struct vg_mask_layer*)maskLayer;
 329
 330    if (x + width > mask_layer_width(mask) ||
 331        y + height > mask_layer_height(mask)) {
 332       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
 333       return;
 334    }
 335
 336 #if DISABLE_1_1_MASKING
 337    return;
 338 #endif
 339    mask_layer_fill(mask, x, y, width, height, value);
 340 }
 341
 342 void vgCopyMask(VGMaskLayer maskLayer,
 343                 VGint sx, VGint sy,
 344                 VGint dx, VGint dy,
 345                 VGint width, VGint height)
 346 {
 347    struct vg_context *ctx = vg_current_context();
 348    struct vg_mask_layer *mask = 0;
 349
 350    if (maskLayer == VG_INVALID_HANDLE) {
 351       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
 352       return;
 353    }
 354    if (width <= 0 || height <= 0) {
 355       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
 356       return;
 357    }
 358    if (!vg_object_is_valid((void*)maskLayer, VG_OBJECT_MASK)) {
 359       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
 360       return;
 361    }
 362
 363 #if DISABLE_1_1_MASKING
 364    return;
 365 #endif
 366
 367    mask = (struct vg_mask_layer*)maskLayer;
 368    mask_copy(mask, sx, sy, dx, dy, width, height);
 369 }
 370
 371 #endif