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