Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  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. #include "VG/vgu.h"
  29.  
  30. #include "matrix.h"
  31. #include "path.h"
  32. #include "handle.h"
  33.  
  34. #include "util/u_debug.h"
  35. #include "util/u_pointer.h"
  36.  
  37. #include <math.h>
  38. #include <assert.h>
  39.  
  40.  
  41. static void vgu_append_float_coords(VGPath path,
  42.                                     const VGubyte *cmds,
  43.                                     VGint num_cmds,
  44.                                     const VGfloat *coords,
  45.                                     VGint num_coords)
  46. {
  47.    VGubyte common_data[40 * sizeof(VGfloat)];
  48.    struct path *p = handle_to_path(path);
  49.  
  50.    vg_float_to_datatype(path_datatype(p), common_data, coords, num_coords);
  51.    vgAppendPathData(path, num_cmds, cmds, common_data);
  52. }
  53.  
  54. VGUErrorCode vguLine(VGPath path,
  55.                      VGfloat x0, VGfloat y0,
  56.                      VGfloat x1, VGfloat y1)
  57. {
  58.    static const VGubyte cmds[] = {VG_MOVE_TO_ABS, VG_LINE_TO_ABS};
  59.    VGfloat coords[4];
  60.    VGbitfield caps;
  61.  
  62.    if (path == VG_INVALID_HANDLE) {
  63.       return VGU_BAD_HANDLE_ERROR;
  64.    }
  65.    caps = vgGetPathCapabilities(path);
  66.    if (!(caps & VG_PATH_CAPABILITY_APPEND_TO)) {
  67.       return VGU_PATH_CAPABILITY_ERROR;
  68.    }
  69.  
  70.    coords[0] = x0;
  71.    coords[1] = y0;
  72.    coords[2] = x1;
  73.    coords[3] = y1;
  74.  
  75.    vgu_append_float_coords(path, cmds, 2, coords, 4);
  76.  
  77.    return VGU_NO_ERROR;
  78. }
  79.  
  80. VGUErrorCode vguPolygon(VGPath path,
  81.                         const VGfloat * points,
  82.                         VGint count,
  83.                         VGboolean closed)
  84. {
  85.    VGubyte *cmds;
  86.    VGfloat *coords;
  87.    VGbitfield caps;
  88.    VGint i;
  89.  
  90.    if (path == VG_INVALID_HANDLE) {
  91.       return VGU_BAD_HANDLE_ERROR;
  92.    }
  93.  
  94.    if (!points || count <= 0 || !is_aligned(points)) {
  95.       return VGU_ILLEGAL_ARGUMENT_ERROR;
  96.    }
  97.  
  98.    caps = vgGetPathCapabilities(path);
  99.    if (!(caps & VG_PATH_CAPABILITY_APPEND_TO)) {
  100.       return VGU_PATH_CAPABILITY_ERROR;
  101.    }
  102.  
  103.    cmds   = malloc(sizeof(VGubyte) * count + 1);
  104.    coords = malloc(sizeof(VGfloat) * count * 2);
  105.  
  106.    cmds[0] = VG_MOVE_TO_ABS;
  107.    coords[0] = points[0];
  108.    coords[1] = points[1];
  109.    for (i = 1; i < count; ++i) {
  110.       cmds[i] = VG_LINE_TO_ABS;
  111.       coords[2*i + 0] = points[2*i + 0];
  112.       coords[2*i + 1] = points[2*i + 1];
  113.    }
  114.  
  115.    if (closed) {
  116.       cmds[i] = VG_CLOSE_PATH;
  117.       ++i;
  118.    }
  119.  
  120.    vgu_append_float_coords(path, cmds, i, coords, 2*i);
  121.  
  122.    free(cmds);
  123.    free(coords);
  124.  
  125.    return VGU_NO_ERROR;
  126. }
  127.  
  128. VGUErrorCode  vguRect(VGPath path,
  129.                       VGfloat x, VGfloat y,
  130.                       VGfloat width, VGfloat height)
  131. {
  132.    static const VGubyte cmds[] = {VG_MOVE_TO_ABS,
  133.                                   VG_HLINE_TO_REL,
  134.                                   VG_VLINE_TO_REL,
  135.                                   VG_HLINE_TO_REL,
  136.                                   VG_CLOSE_PATH
  137.    };
  138.    VGfloat coords[5];
  139.    VGbitfield caps;
  140.  
  141.    if (path == VG_INVALID_HANDLE) {
  142.       return VGU_BAD_HANDLE_ERROR;
  143.    }
  144.    caps = vgGetPathCapabilities(path);
  145.    if (!(caps & VG_PATH_CAPABILITY_APPEND_TO)) {
  146.       return VGU_PATH_CAPABILITY_ERROR;
  147.    }
  148.    if (width <= 0 || height <= 0) {
  149.       return VGU_ILLEGAL_ARGUMENT_ERROR;
  150.    }
  151.  
  152.    coords[0] =  x;
  153.    coords[1] =  y;
  154.    coords[2] =  width;
  155.    coords[3] =  height;
  156.    coords[4] = -width;
  157.  
  158.    vgu_append_float_coords(path, cmds, 5, coords, 5);
  159.  
  160.    return VGU_NO_ERROR;
  161. }
  162.  
  163. VGUErrorCode vguRoundRect(VGPath path,
  164.                           VGfloat x, VGfloat y,
  165.                           VGfloat width,
  166.                           VGfloat height,
  167.                           VGfloat arcWidth,
  168.                           VGfloat arcHeight)
  169. {
  170.    static const VGubyte cmds[] = {VG_MOVE_TO_ABS,
  171.                                   VG_HLINE_TO_REL,
  172.                                   VG_SCCWARC_TO_REL,
  173.                                   VG_VLINE_TO_REL,
  174.                                   VG_SCCWARC_TO_REL,
  175.                                   VG_HLINE_TO_REL,
  176.                                   VG_SCCWARC_TO_REL,
  177.                                   VG_VLINE_TO_REL,
  178.                                   VG_SCCWARC_TO_REL,
  179.                                   VG_CLOSE_PATH
  180.    };
  181.    VGfloat c[26];
  182.    VGbitfield caps;
  183.  
  184.    if (path == VG_INVALID_HANDLE) {
  185.       return VGU_BAD_HANDLE_ERROR;
  186.    }
  187.    caps = vgGetPathCapabilities(path);
  188.    if (!(caps & VG_PATH_CAPABILITY_APPEND_TO)) {
  189.       return VGU_PATH_CAPABILITY_ERROR;
  190.    }
  191.    if (width <= 0 || height <= 0) {
  192.       return VGU_ILLEGAL_ARGUMENT_ERROR;
  193.    }
  194.  
  195.    c[0] =  x + arcWidth/2; c[1] =  y;
  196.  
  197.    c[2] = width - arcWidth;
  198.  
  199.    c[3] = arcWidth/2; c[4] = arcHeight/2; c[5] = 0;
  200.    c[6] = arcWidth/2; c[7] = arcHeight/2;
  201.  
  202.    c[8] = height - arcHeight;
  203.  
  204.    c[9] = arcWidth/2; c[10] = arcHeight/2; c[11] = 0;
  205.    c[12] = -arcWidth/2; c[13] = arcHeight/2;
  206.  
  207.    c[14] = -(width - arcWidth);
  208.  
  209.    c[15] = arcWidth/2; c[16] = arcHeight/2; c[17] = 0;
  210.    c[18] = -arcWidth/2; c[19] = -arcHeight/2;
  211.  
  212.    c[20] = -(height - arcHeight);
  213.  
  214.    c[21] = arcWidth/2; c[22] = arcHeight/2; c[23] = 0;
  215.    c[24] = arcWidth/2; c[25] = -arcHeight/2;
  216.  
  217.    vgu_append_float_coords(path, cmds, 10, c, 26);
  218.  
  219.    return VGU_NO_ERROR;
  220. }
  221.  
  222. VGUErrorCode vguEllipse(VGPath path,
  223.                         VGfloat cx, VGfloat cy,
  224.                         VGfloat width,
  225.                         VGfloat height)
  226. {
  227.    static const VGubyte cmds[] = {VG_MOVE_TO_ABS,
  228.                                   VG_SCCWARC_TO_REL,
  229.                                   VG_SCCWARC_TO_REL,
  230.                                   VG_CLOSE_PATH
  231.    };
  232.    VGfloat coords[12];
  233.    VGbitfield caps;
  234.  
  235.    if (path == VG_INVALID_HANDLE) {
  236.       return VGU_BAD_HANDLE_ERROR;
  237.    }
  238.    caps = vgGetPathCapabilities(path);
  239.    if (!(caps & VG_PATH_CAPABILITY_APPEND_TO)) {
  240.       return VGU_PATH_CAPABILITY_ERROR;
  241.    }
  242.    if (width <= 0 || height <= 0) {
  243.       return VGU_ILLEGAL_ARGUMENT_ERROR;
  244.    }
  245.  
  246.    coords[0] = cx + width/2; coords[1] = cy;
  247.  
  248.    coords[2] = width/2; coords[3] = height/2; coords[4] = 0;
  249.    coords[5] = -width; coords[6] = 0;
  250.  
  251.    coords[7] = width/2; coords[8] = height/2; coords[9] = 0;
  252.    coords[10] = width; coords[11] = 0;
  253.  
  254.    vgu_append_float_coords(path, cmds, 4, coords, 11);
  255.  
  256.    return VGU_NO_ERROR;
  257. }
  258.  
  259. VGUErrorCode vguArc(VGPath path,
  260.                     VGfloat x, VGfloat y,
  261.                     VGfloat width, VGfloat height,
  262.                     VGfloat startAngle,
  263.                     VGfloat angleExtent,
  264.                     VGUArcType arcType)
  265. {
  266.    VGubyte cmds[11];
  267.    VGfloat coords[40];
  268.    VGbitfield caps;
  269.    VGfloat last = startAngle + angleExtent;
  270.    VGint i, c = 0;
  271.  
  272.    if (path == VG_INVALID_HANDLE) {
  273.       return VGU_BAD_HANDLE_ERROR;
  274.    }
  275.    caps = vgGetPathCapabilities(path);
  276.    if (!(caps & VG_PATH_CAPABILITY_APPEND_TO)) {
  277.       return VGU_PATH_CAPABILITY_ERROR;
  278.    }
  279.    if (width <= 0 || height <= 0) {
  280.       return VGU_ILLEGAL_ARGUMENT_ERROR;
  281.    }
  282.    if (arcType != VGU_ARC_OPEN &&
  283.        arcType != VGU_ARC_CHORD &&
  284.        arcType != VGU_ARC_PIE) {
  285.       return VGU_ILLEGAL_ARGUMENT_ERROR;
  286.    }
  287.  
  288.    cmds[c] = VG_MOVE_TO_ABS; ++c;
  289.    coords[0] = x+cos(DEGREES_TO_RADIANS(startAngle))*width/2;
  290.    coords[1] = y+sin(DEGREES_TO_RADIANS(startAngle))*height/2;
  291. #ifdef DEBUG_VGUARC
  292.    debug_printf("start [%f, %f]\n", coords[0], coords[1]);
  293. #endif
  294.    i = 2;
  295.    if (angleExtent > 0) {
  296.       VGfloat angle = startAngle + 180;
  297.       while (angle < last) {
  298.          cmds[c] = VG_SCCWARC_TO_ABS; ++c;
  299.          coords[i] = width/2; coords[i+1] = height/2; coords[i+2] = 0;
  300.          coords[i+3] = x + cos(DEGREES_TO_RADIANS(angle))*width/2;
  301.          coords[i+4] = y + sin(DEGREES_TO_RADIANS(angle))*height/2;
  302. #ifdef DEBUG_VGUARC
  303.          debug_printf("1 [%f, %f]\n", coords[i+3],
  304.                       coords[i+4]);
  305. #endif
  306.          i += 5;
  307.          angle += 180;
  308.       }
  309.       cmds[c] = VG_SCCWARC_TO_ABS; ++c;
  310.       coords[i] = width/2; coords[i+1] = height/2; coords[i+2] = 0;
  311.       coords[i+3] = x+cos(DEGREES_TO_RADIANS(last))*width/2;
  312.       coords[i+4] = y+sin(DEGREES_TO_RADIANS(last))*height/2;
  313. #ifdef DEBUG_VGUARC
  314.       debug_printf("2 [%f, %f]\n", coords[i+3],
  315.                    coords[i+4]);
  316. #endif
  317.       i += 5;
  318.    } else {
  319.       VGfloat angle = startAngle - 180;
  320.       while (angle > last) {
  321.          cmds[c] = VG_SCWARC_TO_ABS; ++c;
  322.          coords[i] =  width/2; coords[i+1] = height/2; coords[i+2] = 0;
  323.          coords[i+3] = x + cos(DEGREES_TO_RADIANS(angle)) * width/2;
  324.          coords[i+4] = y + sin(DEGREES_TO_RADIANS(angle)) * height/2;
  325. #ifdef DEBUG_VGUARC
  326.          debug_printf("3 [%f, %f]\n", coords[i+3],
  327.                       coords[i+4]);
  328. #endif
  329.          angle -= 180;
  330.          i += 5;
  331.       }
  332.       cmds[c] = VG_SCWARC_TO_ABS; ++c;
  333.       coords[i] = width/2; coords[i+1] = height/2; coords[i+2] = 0;
  334.       coords[i+3] = x + cos(DEGREES_TO_RADIANS(last)) * width/2;
  335.       coords[i+4] = y + sin(DEGREES_TO_RADIANS(last)) * height/2;
  336. #ifdef DEBUG_VGUARC
  337.       debug_printf("4 [%f, %f]\n", coords[i+3],
  338.                    coords[i+4]);
  339. #endif
  340.       i += 5;
  341.    }
  342.  
  343.    if (arcType == VGU_ARC_PIE) {
  344.       cmds[c] = VG_LINE_TO_ABS; ++c;
  345.       coords[i] = x; coords[i + 1] = y;
  346.       i += 2;
  347.    }
  348.    if (arcType == VGU_ARC_PIE || arcType == VGU_ARC_CHORD) {
  349.       cmds[c] = VG_CLOSE_PATH;
  350.       ++c;
  351.    }
  352.  
  353.    assert(c < 11);
  354.  
  355.    vgu_append_float_coords(path, cmds, c, coords, i);
  356.  
  357.    return VGU_NO_ERROR;
  358. }
  359.  
  360. VGUErrorCode vguComputeWarpQuadToSquare(VGfloat sx0, VGfloat sy0,
  361.                                         VGfloat sx1, VGfloat sy1,
  362.                                         VGfloat sx2, VGfloat sy2,
  363.                                         VGfloat sx3, VGfloat sy3,
  364.                                         VGfloat * matrix)
  365. {
  366.    struct matrix mat;
  367.  
  368.    if (!matrix || !is_aligned(matrix))
  369.       return VGU_ILLEGAL_ARGUMENT_ERROR;
  370.  
  371.    if (!matrix_quad_to_square(sx0, sy0,
  372.                               sx1, sy1,
  373.                               sx2, sy2,
  374.                               sx3, sy3,
  375.                               &mat))
  376.       return VGU_BAD_WARP_ERROR;
  377.  
  378.    if (!matrix_is_invertible(&mat))
  379.       return VGU_BAD_WARP_ERROR;
  380.  
  381.    memcpy(matrix, mat.m, sizeof(VGfloat) * 9);
  382.  
  383.    return VGU_NO_ERROR;
  384. }
  385.  
  386. VGUErrorCode vguComputeWarpSquareToQuad(VGfloat dx0, VGfloat dy0,
  387.                                         VGfloat dx1, VGfloat dy1,
  388.                                         VGfloat dx2, VGfloat dy2,
  389.                                         VGfloat dx3, VGfloat dy3,
  390.                                         VGfloat * matrix)
  391. {
  392.    struct matrix mat;
  393.  
  394.    if (!matrix || !is_aligned(matrix))
  395.       return VGU_ILLEGAL_ARGUMENT_ERROR;
  396.  
  397.    if (!matrix_square_to_quad(dx0, dy0,
  398.                               dx1, dy1,
  399.                               dx2, dy2,
  400.                               dx3, dy3,
  401.                               &mat))
  402.       return VGU_BAD_WARP_ERROR;
  403.  
  404.    if (!matrix_is_invertible(&mat))
  405.       return VGU_BAD_WARP_ERROR;
  406.  
  407.    memcpy(matrix, mat.m, sizeof(VGfloat) * 9);
  408.  
  409.    return VGU_NO_ERROR;
  410. }
  411.  
  412. VGUErrorCode vguComputeWarpQuadToQuad(VGfloat dx0, VGfloat dy0,
  413.                                       VGfloat dx1, VGfloat dy1,
  414.                                       VGfloat dx2, VGfloat dy2,
  415.                                       VGfloat dx3, VGfloat dy3,
  416.                                       VGfloat sx0, VGfloat sy0,
  417.                                       VGfloat sx1, VGfloat sy1,
  418.                                       VGfloat sx2, VGfloat sy2,
  419.                                       VGfloat sx3, VGfloat sy3,
  420.                                       VGfloat * matrix)
  421. {
  422.    struct matrix mat;
  423.  
  424.    if (!matrix || !is_aligned(matrix))
  425.       return VGU_ILLEGAL_ARGUMENT_ERROR;
  426.  
  427.    if (!matrix_quad_to_quad(dx0, dy0,
  428.                             dx1, dy1,
  429.                             dx2, dy2,
  430.                             dx3, dy3,
  431.                             sx0, sy0,
  432.                             sx1, sy1,
  433.                             sx2, sy2,
  434.                             sx3, sy3,
  435.                             &mat))
  436.       return VGU_BAD_WARP_ERROR;
  437.  
  438.    memcpy(matrix, mat.m, sizeof(VGfloat) * 9);
  439.  
  440.    return VGU_NO_ERROR;
  441. }
  442.