Home | History | Annotate | Download | only in vega 
      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 
     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 
     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 
    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 
    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 
    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 
    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 
    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