[enable support for OpenGL ES 2.x API @<:@default=disabled@:>@])],
[enable_gles2="$enableval"],
[enable_gles2=no])
-AC_ARG_ENABLE([openvg],
- [AS_HELP_STRING([--enable-openvg],
- [enable support for OpenVG API @<:@default=disabled@:>@])],
- [enable_openvg="$enableval"],
- [enable_openvg=no])
AC_ARG_ENABLE([dri],
[AS_HELP_STRING([--enable-dri],
"x$enable_gles1" = xno -a \
"x$enable_gles2" = xno -a \
"x$enable_nine" = xno -a \
- "x$enable_openvg" = xno -a \
"x$enable_xa" = xno -a \
"x$enable_xvmc" = xno -a \
"x$enable_vdpau" = xno -a \
fi
AM_CONDITIONAL(HAVE_ST_XA, test "x$enable_xa" = xyes)
-dnl
-dnl OpenVG configuration
-dnl
-VG_LIB_DEPS=""
-
-if test "x$enable_openvg" = xyes; then
- if test "x$enable_egl" = xno; then
- AC_MSG_ERROR([cannot enable OpenVG without EGL])
- fi
- if test -z "$with_gallium_drivers"; then
- AC_MSG_ERROR([cannot enable OpenVG without Gallium])
- fi
-
- AC_MSG_ERROR([Cannot enable OpenVG, because egl_gallium has been removed and
- OpenVG has not been integrated into standard libEGL yet])
-
- EGL_CLIENT_APIS="$EGL_CLIENT_APIS "'$(VG_LIB)'
- VG_LIB_DEPS="$VG_LIB_DEPS $SELINUX_LIBS $PTHREAD_LIBS"
- VG_PC_LIB_PRIV="-lm $CLOCK_LIB $PTHREAD_LIBS $DLOPEN_LIBS"
- AC_SUBST([VG_PC_LIB_PRIV])
-fi
-AM_CONDITIONAL(HAVE_OPENVG, test "x$enable_openvg" = xyes)
-
dnl
dnl Gallium G3DVL configuration
dnl
src/gallium/state_trackers/osmesa/Makefile
src/gallium/state_trackers/va/Makefile
src/gallium/state_trackers/vdpau/Makefile
- src/gallium/state_trackers/vega/Makefile
src/gallium/state_trackers/xa/Makefile
src/gallium/state_trackers/xvmc/Makefile
src/gallium/targets/d3dadapter9/Makefile
dnl API info
echo ""
echo " OpenGL: $enable_opengl (ES1: $enable_gles1 ES2: $enable_gles2)"
-echo " OpenVG: $enable_openvg"
dnl Driver info
echo ""
<li><a href="shading.html" target="_parent">Shading Language</a>
<li><a href="egl.html" target="_parent">EGL</a>
<li><a href="opengles.html" target="_parent">OpenGL ES</a>
-<li><a href="openvg.html" target="_parent">OpenVG / Vega</a>
<li><a href="envvars.html" target="_parent">Environment Variables</a>
<li><a href="osmesa.html" target="_parent">Off-Screen Rendering</a>
<li><a href="debugging.html" target="_parent">Debugging Tips</a>
</dd>
-<dt><code>--enable-openvg</code></dt>
-<dd>
-
-<p>OpenVG must be explicitly enabled by this option.</p>
-
-</dd>
-
</dl>
<h2>Use EGL</h2>
+++ /dev/null
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
-<html lang="en">
-<head>
- <meta http-equiv="content-type" content="text/html; charset=utf-8">
- <title>OpenVG State Tracker</title>
- <link rel="stylesheet" type="text/css" href="mesa.css">
-</head>
-<body>
-
-<div class="header">
- <h1>The Mesa 3D Graphics Library</h1>
-</div>
-
-<iframe src="contents.html"></iframe>
-<div class="content">
-
-<h1>OpenVG State Tracker</h1>
-
-<p>
-The current version of the OpenVG state tracker implements OpenVG 1.1.
-</p>
-<p>
-More information about OpenVG can be found at
-<a href="http://www.khronos.org/openvg/">
-http://www.khronos.org/openvg/</a> .
-</p>
-<p>
-The OpenVG state tracker depends on the Gallium architecture and a working EGL implementation.
-Please refer to <a href="egl.html">Mesa EGL</a> for more information about EGL.
-</p>
-
-
-<h2>Building the library</h2>
-<ol>
-<li>Run <code>configure</code> with <code>--enable-openvg</code> and
-<code>--enable-gallium-egl</code>. If you do not need OpenGL, you can add
-<code>--disable-opengl</code> to save the compilation time.</li>
-
-<li>Build and install Mesa as usual.</li>
-</ol>
-
-<h3>Sample build</h3>
-A sample build looks as follows:
-<pre>
- $ ./configure --disable-opengl --enable-openvg --enable-gallium-egl
- $ make
- $ make install
-</pre>
-
-<p>It will install <code>libOpenVG.so</code>, <code>libEGL.so</code>, and one
-or more EGL drivers.</p>
-
-<h2>OpenVG Demos</h2>
-
-<p>OpenVG demos can be found in mesa/demos repository.</p>
-
-</div>
-</body>
-</html>
<ul>
<li>Removed classic Windows software rasterizer.</li>
<li>Removed egl_gallium EGL driver.</li>
+<li>Removed OpenVG support.</li>
</ul>
</div>
<h2>New features</h2>
<ul>
-<li><a href="../openvg.html">OpenVG</a> front-end (state tracker for Gallium).
+<li>OpenVG front-end (state tracker for Gallium).
This was written by Zack Rusin at Tungsten Graphics.
<li>GL_ARB_vertex_array_object and GL_APPLE_vertex_array_object extensions
(supported in Gallium drivers, Intel DRI drivers, and software drivers)</li>
<li><b>dri</b> - Meta state tracker for DRI drivers
<li><b>glx</b> - Meta state tracker for GLX
<li><b>vdpau</b> - VDPAU state tracker
- <li><b>vega</b> - OpenVG 1.x state tracker
<li><b>wgl</b> -
<li><b>xorg</b> - Meta state tracker for Xorg video drivers
<li><b>xvmc</b> - XvMC state tracker
+++ /dev/null
-/* $Revision: 9203 $ on $Date:: 2009-10-07 02:21:52 -0700 #$ */
-
-/*------------------------------------------------------------------------
- *
- * OpenVG 1.1 Reference Implementation
- * -------------------------------------
- *
- * Copyright (c) 2008 The Khronos Group Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and /or associated documentation files
- * (the "Materials "), to deal in the Materials without restriction,
- * including without limitation the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Materials,
- * and to permit persons to whom the Materials are furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Materials.
- *
- * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
- * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR
- * THE USE OR OTHER DEALINGS IN THE MATERIALS.
- *
- *//**
- * \file
- * \brief OpenVG 1.1 API.
- *//*-------------------------------------------------------------------*/
-
-#ifndef _OPENVG_H
-#define _OPENVG_H
-
-#include <VG/vgplatform.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define OPENVG_VERSION_1_0 1
-#define OPENVG_VERSION_1_0_1 1
-#define OPENVG_VERSION_1_1 2
-
-#ifndef VG_MAXSHORT
-#define VG_MAXSHORT 0x7FFF
-#endif
-
-#ifndef VG_MAXINT
-#define VG_MAXINT 0x7FFFFFFF
-#endif
-
-#ifndef VG_MAX_ENUM
-#define VG_MAX_ENUM 0x7FFFFFFF
-#endif
-
-typedef VGuint VGHandle;
-
-typedef VGHandle VGPath;
-typedef VGHandle VGImage;
-typedef VGHandle VGMaskLayer;
-typedef VGHandle VGFont;
-typedef VGHandle VGPaint;
-
-#define VG_INVALID_HANDLE ((VGHandle)0)
-
-typedef enum {
- VG_FALSE = 0,
- VG_TRUE = 1,
-
- VG_BOOLEAN_FORCE_SIZE = VG_MAX_ENUM
-} VGboolean;
-
-typedef enum {
- VG_NO_ERROR = 0,
- VG_BAD_HANDLE_ERROR = 0x1000,
- VG_ILLEGAL_ARGUMENT_ERROR = 0x1001,
- VG_OUT_OF_MEMORY_ERROR = 0x1002,
- VG_PATH_CAPABILITY_ERROR = 0x1003,
- VG_UNSUPPORTED_IMAGE_FORMAT_ERROR = 0x1004,
- VG_UNSUPPORTED_PATH_FORMAT_ERROR = 0x1005,
- VG_IMAGE_IN_USE_ERROR = 0x1006,
- VG_NO_CONTEXT_ERROR = 0x1007,
-
- VG_ERROR_CODE_FORCE_SIZE = VG_MAX_ENUM
-} VGErrorCode;
-
-typedef enum {
- /* Mode settings */
- VG_MATRIX_MODE = 0x1100,
- VG_FILL_RULE = 0x1101,
- VG_IMAGE_QUALITY = 0x1102,
- VG_RENDERING_QUALITY = 0x1103,
- VG_BLEND_MODE = 0x1104,
- VG_IMAGE_MODE = 0x1105,
-
- /* Scissoring rectangles */
- VG_SCISSOR_RECTS = 0x1106,
-
- /* Color Transformation */
- VG_COLOR_TRANSFORM = 0x1170,
- VG_COLOR_TRANSFORM_VALUES = 0x1171,
-
- /* Stroke parameters */
- VG_STROKE_LINE_WIDTH = 0x1110,
- VG_STROKE_CAP_STYLE = 0x1111,
- VG_STROKE_JOIN_STYLE = 0x1112,
- VG_STROKE_MITER_LIMIT = 0x1113,
- VG_STROKE_DASH_PATTERN = 0x1114,
- VG_STROKE_DASH_PHASE = 0x1115,
- VG_STROKE_DASH_PHASE_RESET = 0x1116,
-
- /* Edge fill color for VG_TILE_FILL tiling mode */
- VG_TILE_FILL_COLOR = 0x1120,
-
- /* Color for vgClear */
- VG_CLEAR_COLOR = 0x1121,
-
- /* Glyph origin */
- VG_GLYPH_ORIGIN = 0x1122,
-
- /* Enable/disable alpha masking and scissoring */
- VG_MASKING = 0x1130,
- VG_SCISSORING = 0x1131,
-
- /* Pixel layout information */
- VG_PIXEL_LAYOUT = 0x1140,
- VG_SCREEN_LAYOUT = 0x1141,
-
- /* Source format selection for image filters */
- VG_FILTER_FORMAT_LINEAR = 0x1150,
- VG_FILTER_FORMAT_PREMULTIPLIED = 0x1151,
-
- /* Destination write enable mask for image filters */
- VG_FILTER_CHANNEL_MASK = 0x1152,
-
- /* Implementation limits (read-only) */
- VG_MAX_SCISSOR_RECTS = 0x1160,
- VG_MAX_DASH_COUNT = 0x1161,
- VG_MAX_KERNEL_SIZE = 0x1162,
- VG_MAX_SEPARABLE_KERNEL_SIZE = 0x1163,
- VG_MAX_COLOR_RAMP_STOPS = 0x1164,
- VG_MAX_IMAGE_WIDTH = 0x1165,
- VG_MAX_IMAGE_HEIGHT = 0x1166,
- VG_MAX_IMAGE_PIXELS = 0x1167,
- VG_MAX_IMAGE_BYTES = 0x1168,
- VG_MAX_FLOAT = 0x1169,
- VG_MAX_GAUSSIAN_STD_DEVIATION = 0x116A,
-
- VG_PARAM_TYPE_FORCE_SIZE = VG_MAX_ENUM
-} VGParamType;
-
-typedef enum {
- VG_RENDERING_QUALITY_NONANTIALIASED = 0x1200,
- VG_RENDERING_QUALITY_FASTER = 0x1201,
- VG_RENDERING_QUALITY_BETTER = 0x1202, /* Default */
-
- VG_RENDERING_QUALITY_FORCE_SIZE = VG_MAX_ENUM
-} VGRenderingQuality;
-
-typedef enum {
- VG_PIXEL_LAYOUT_UNKNOWN = 0x1300,
- VG_PIXEL_LAYOUT_RGB_VERTICAL = 0x1301,
- VG_PIXEL_LAYOUT_BGR_VERTICAL = 0x1302,
- VG_PIXEL_LAYOUT_RGB_HORIZONTAL = 0x1303,
- VG_PIXEL_LAYOUT_BGR_HORIZONTAL = 0x1304,
-
- VG_PIXEL_LAYOUT_FORCE_SIZE = VG_MAX_ENUM
-} VGPixelLayout;
-
-typedef enum {
- VG_MATRIX_PATH_USER_TO_SURFACE = 0x1400,
- VG_MATRIX_IMAGE_USER_TO_SURFACE = 0x1401,
- VG_MATRIX_FILL_PAINT_TO_USER = 0x1402,
- VG_MATRIX_STROKE_PAINT_TO_USER = 0x1403,
- VG_MATRIX_GLYPH_USER_TO_SURFACE = 0x1404,
-
- VG_MATRIX_MODE_FORCE_SIZE = VG_MAX_ENUM
-} VGMatrixMode;
-
-typedef enum {
- VG_CLEAR_MASK = 0x1500,
- VG_FILL_MASK = 0x1501,
- VG_SET_MASK = 0x1502,
- VG_UNION_MASK = 0x1503,
- VG_INTERSECT_MASK = 0x1504,
- VG_SUBTRACT_MASK = 0x1505,
-
- VG_MASK_OPERATION_FORCE_SIZE = VG_MAX_ENUM
-} VGMaskOperation;
-
-#define VG_PATH_FORMAT_STANDARD 0
-
-typedef enum {
- VG_PATH_DATATYPE_S_8 = 0,
- VG_PATH_DATATYPE_S_16 = 1,
- VG_PATH_DATATYPE_S_32 = 2,
- VG_PATH_DATATYPE_F = 3,
-
- VG_PATH_DATATYPE_FORCE_SIZE = VG_MAX_ENUM
-} VGPathDatatype;
-
-typedef enum {
- VG_ABSOLUTE = 0,
- VG_RELATIVE = 1,
-
- VG_PATH_ABS_REL_FORCE_SIZE = VG_MAX_ENUM
-} VGPathAbsRel;
-
-typedef enum {
- VG_CLOSE_PATH = ( 0 << 1),
- VG_MOVE_TO = ( 1 << 1),
- VG_LINE_TO = ( 2 << 1),
- VG_HLINE_TO = ( 3 << 1),
- VG_VLINE_TO = ( 4 << 1),
- VG_QUAD_TO = ( 5 << 1),
- VG_CUBIC_TO = ( 6 << 1),
- VG_SQUAD_TO = ( 7 << 1),
- VG_SCUBIC_TO = ( 8 << 1),
- VG_SCCWARC_TO = ( 9 << 1),
- VG_SCWARC_TO = (10 << 1),
- VG_LCCWARC_TO = (11 << 1),
- VG_LCWARC_TO = (12 << 1),
-
- VG_PATH_SEGMENT_FORCE_SIZE = VG_MAX_ENUM
-} VGPathSegment;
-
-typedef enum {
- VG_MOVE_TO_ABS = VG_MOVE_TO | VG_ABSOLUTE,
- VG_MOVE_TO_REL = VG_MOVE_TO | VG_RELATIVE,
- VG_LINE_TO_ABS = VG_LINE_TO | VG_ABSOLUTE,
- VG_LINE_TO_REL = VG_LINE_TO | VG_RELATIVE,
- VG_HLINE_TO_ABS = VG_HLINE_TO | VG_ABSOLUTE,
- VG_HLINE_TO_REL = VG_HLINE_TO | VG_RELATIVE,
- VG_VLINE_TO_ABS = VG_VLINE_TO | VG_ABSOLUTE,
- VG_VLINE_TO_REL = VG_VLINE_TO | VG_RELATIVE,
- VG_QUAD_TO_ABS = VG_QUAD_TO | VG_ABSOLUTE,
- VG_QUAD_TO_REL = VG_QUAD_TO | VG_RELATIVE,
- VG_CUBIC_TO_ABS = VG_CUBIC_TO | VG_ABSOLUTE,
- VG_CUBIC_TO_REL = VG_CUBIC_TO | VG_RELATIVE,
- VG_SQUAD_TO_ABS = VG_SQUAD_TO | VG_ABSOLUTE,
- VG_SQUAD_TO_REL = VG_SQUAD_TO | VG_RELATIVE,
- VG_SCUBIC_TO_ABS = VG_SCUBIC_TO | VG_ABSOLUTE,
- VG_SCUBIC_TO_REL = VG_SCUBIC_TO | VG_RELATIVE,
- VG_SCCWARC_TO_ABS = VG_SCCWARC_TO | VG_ABSOLUTE,
- VG_SCCWARC_TO_REL = VG_SCCWARC_TO | VG_RELATIVE,
- VG_SCWARC_TO_ABS = VG_SCWARC_TO | VG_ABSOLUTE,
- VG_SCWARC_TO_REL = VG_SCWARC_TO | VG_RELATIVE,
- VG_LCCWARC_TO_ABS = VG_LCCWARC_TO | VG_ABSOLUTE,
- VG_LCCWARC_TO_REL = VG_LCCWARC_TO | VG_RELATIVE,
- VG_LCWARC_TO_ABS = VG_LCWARC_TO | VG_ABSOLUTE,
- VG_LCWARC_TO_REL = VG_LCWARC_TO | VG_RELATIVE,
-
- VG_PATH_COMMAND_FORCE_SIZE = VG_MAX_ENUM
-} VGPathCommand;
-
-typedef enum {
- VG_PATH_CAPABILITY_APPEND_FROM = (1 << 0),
- VG_PATH_CAPABILITY_APPEND_TO = (1 << 1),
- VG_PATH_CAPABILITY_MODIFY = (1 << 2),
- VG_PATH_CAPABILITY_TRANSFORM_FROM = (1 << 3),
- VG_PATH_CAPABILITY_TRANSFORM_TO = (1 << 4),
- VG_PATH_CAPABILITY_INTERPOLATE_FROM = (1 << 5),
- VG_PATH_CAPABILITY_INTERPOLATE_TO = (1 << 6),
- VG_PATH_CAPABILITY_PATH_LENGTH = (1 << 7),
- VG_PATH_CAPABILITY_POINT_ALONG_PATH = (1 << 8),
- VG_PATH_CAPABILITY_TANGENT_ALONG_PATH = (1 << 9),
- VG_PATH_CAPABILITY_PATH_BOUNDS = (1 << 10),
- VG_PATH_CAPABILITY_PATH_TRANSFORMED_BOUNDS = (1 << 11),
- VG_PATH_CAPABILITY_ALL = (1 << 12) - 1,
-
- VG_PATH_CAPABILITIES_FORCE_SIZE = VG_MAX_ENUM
-} VGPathCapabilities;
-
-typedef enum {
- VG_PATH_FORMAT = 0x1600,
- VG_PATH_DATATYPE = 0x1601,
- VG_PATH_SCALE = 0x1602,
- VG_PATH_BIAS = 0x1603,
- VG_PATH_NUM_SEGMENTS = 0x1604,
- VG_PATH_NUM_COORDS = 0x1605,
-
- VG_PATH_PARAM_TYPE_FORCE_SIZE = VG_MAX_ENUM
-} VGPathParamType;
-
-typedef enum {
- VG_CAP_BUTT = 0x1700,
- VG_CAP_ROUND = 0x1701,
- VG_CAP_SQUARE = 0x1702,
-
- VG_CAP_STYLE_FORCE_SIZE = VG_MAX_ENUM
-} VGCapStyle;
-
-typedef enum {
- VG_JOIN_MITER = 0x1800,
- VG_JOIN_ROUND = 0x1801,
- VG_JOIN_BEVEL = 0x1802,
-
- VG_JOIN_STYLE_FORCE_SIZE = VG_MAX_ENUM
-} VGJoinStyle;
-
-typedef enum {
- VG_EVEN_ODD = 0x1900,
- VG_NON_ZERO = 0x1901,
-
- VG_FILL_RULE_FORCE_SIZE = VG_MAX_ENUM
-} VGFillRule;
-
-typedef enum {
- VG_STROKE_PATH = (1 << 0),
- VG_FILL_PATH = (1 << 1),
-
- VG_PAINT_MODE_FORCE_SIZE = VG_MAX_ENUM
-} VGPaintMode;
-
-typedef enum {
- /* Color paint parameters */
- VG_PAINT_TYPE = 0x1A00,
- VG_PAINT_COLOR = 0x1A01,
- VG_PAINT_COLOR_RAMP_SPREAD_MODE = 0x1A02,
- VG_PAINT_COLOR_RAMP_PREMULTIPLIED = 0x1A07,
- VG_PAINT_COLOR_RAMP_STOPS = 0x1A03,
-
- /* Linear gradient paint parameters */
- VG_PAINT_LINEAR_GRADIENT = 0x1A04,
-
- /* Radial gradient paint parameters */
- VG_PAINT_RADIAL_GRADIENT = 0x1A05,
-
- /* Pattern paint parameters */
- VG_PAINT_PATTERN_TILING_MODE = 0x1A06,
-
- VG_PAINT_PARAM_TYPE_FORCE_SIZE = VG_MAX_ENUM
-} VGPaintParamType;
-
-typedef enum {
- VG_PAINT_TYPE_COLOR = 0x1B00,
- VG_PAINT_TYPE_LINEAR_GRADIENT = 0x1B01,
- VG_PAINT_TYPE_RADIAL_GRADIENT = 0x1B02,
- VG_PAINT_TYPE_PATTERN = 0x1B03,
-
- VG_PAINT_TYPE_FORCE_SIZE = VG_MAX_ENUM
-} VGPaintType;
-
-typedef enum {
- VG_COLOR_RAMP_SPREAD_PAD = 0x1C00,
- VG_COLOR_RAMP_SPREAD_REPEAT = 0x1C01,
- VG_COLOR_RAMP_SPREAD_REFLECT = 0x1C02,
-
- VG_COLOR_RAMP_SPREAD_MODE_FORCE_SIZE = VG_MAX_ENUM
-} VGColorRampSpreadMode;
-
-typedef enum {
- VG_TILE_FILL = 0x1D00,
- VG_TILE_PAD = 0x1D01,
- VG_TILE_REPEAT = 0x1D02,
- VG_TILE_REFLECT = 0x1D03,
-
- VG_TILING_MODE_FORCE_SIZE = VG_MAX_ENUM
-} VGTilingMode;
-
-typedef enum {
- /* RGB{A,X} channel ordering */
- VG_sRGBX_8888 = 0,
- VG_sRGBA_8888 = 1,
- VG_sRGBA_8888_PRE = 2,
- VG_sRGB_565 = 3,
- VG_sRGBA_5551 = 4,
- VG_sRGBA_4444 = 5,
- VG_sL_8 = 6,
- VG_lRGBX_8888 = 7,
- VG_lRGBA_8888 = 8,
- VG_lRGBA_8888_PRE = 9,
- VG_lL_8 = 10,
- VG_A_8 = 11,
- VG_BW_1 = 12,
- VG_A_1 = 13,
- VG_A_4 = 14,
-
- /* {A,X}RGB channel ordering */
- VG_sXRGB_8888 = 0 | (1 << 6),
- VG_sARGB_8888 = 1 | (1 << 6),
- VG_sARGB_8888_PRE = 2 | (1 << 6),
- VG_sARGB_1555 = 4 | (1 << 6),
- VG_sARGB_4444 = 5 | (1 << 6),
- VG_lXRGB_8888 = 7 | (1 << 6),
- VG_lARGB_8888 = 8 | (1 << 6),
- VG_lARGB_8888_PRE = 9 | (1 << 6),
-
- /* BGR{A,X} channel ordering */
- VG_sBGRX_8888 = 0 | (1 << 7),
- VG_sBGRA_8888 = 1 | (1 << 7),
- VG_sBGRA_8888_PRE = 2 | (1 << 7),
- VG_sBGR_565 = 3 | (1 << 7),
- VG_sBGRA_5551 = 4 | (1 << 7),
- VG_sBGRA_4444 = 5 | (1 << 7),
- VG_lBGRX_8888 = 7 | (1 << 7),
- VG_lBGRA_8888 = 8 | (1 << 7),
- VG_lBGRA_8888_PRE = 9 | (1 << 7),
-
- /* {A,X}BGR channel ordering */
- VG_sXBGR_8888 = 0 | (1 << 6) | (1 << 7),
- VG_sABGR_8888 = 1 | (1 << 6) | (1 << 7),
- VG_sABGR_8888_PRE = 2 | (1 << 6) | (1 << 7),
- VG_sABGR_1555 = 4 | (1 << 6) | (1 << 7),
- VG_sABGR_4444 = 5 | (1 << 6) | (1 << 7),
- VG_lXBGR_8888 = 7 | (1 << 6) | (1 << 7),
- VG_lABGR_8888 = 8 | (1 << 6) | (1 << 7),
- VG_lABGR_8888_PRE = 9 | (1 << 6) | (1 << 7),
-
- VG_IMAGE_FORMAT_FORCE_SIZE = VG_MAX_ENUM
-} VGImageFormat;
-
-typedef enum {
- VG_IMAGE_QUALITY_NONANTIALIASED = (1 << 0),
- VG_IMAGE_QUALITY_FASTER = (1 << 1),
- VG_IMAGE_QUALITY_BETTER = (1 << 2),
-
- VG_IMAGE_QUALITY_FORCE_SIZE = VG_MAX_ENUM
-} VGImageQuality;
-
-typedef enum {
- VG_IMAGE_FORMAT = 0x1E00,
- VG_IMAGE_WIDTH = 0x1E01,
- VG_IMAGE_HEIGHT = 0x1E02,
-
- VG_IMAGE_PARAM_TYPE_FORCE_SIZE = VG_MAX_ENUM
-} VGImageParamType;
-
-typedef enum {
- VG_DRAW_IMAGE_NORMAL = 0x1F00,
- VG_DRAW_IMAGE_MULTIPLY = 0x1F01,
- VG_DRAW_IMAGE_STENCIL = 0x1F02,
-
- VG_IMAGE_MODE_FORCE_SIZE = VG_MAX_ENUM
-} VGImageMode;
-
-typedef enum {
- VG_RED = (1 << 3),
- VG_GREEN = (1 << 2),
- VG_BLUE = (1 << 1),
- VG_ALPHA = (1 << 0),
-
- VG_IMAGE_CHANNEL_FORCE_SIZE = VG_MAX_ENUM
-} VGImageChannel;
-
-typedef enum {
- VG_BLEND_SRC = 0x2000,
- VG_BLEND_SRC_OVER = 0x2001,
- VG_BLEND_DST_OVER = 0x2002,
- VG_BLEND_SRC_IN = 0x2003,
- VG_BLEND_DST_IN = 0x2004,
- VG_BLEND_MULTIPLY = 0x2005,
- VG_BLEND_SCREEN = 0x2006,
- VG_BLEND_DARKEN = 0x2007,
- VG_BLEND_LIGHTEN = 0x2008,
- VG_BLEND_ADDITIVE = 0x2009,
-
- VG_BLEND_MODE_FORCE_SIZE = VG_MAX_ENUM
-} VGBlendMode;
-
-typedef enum {
- VG_FONT_NUM_GLYPHS = 0x2F00,
-
- VG_FONT_PARAM_TYPE_FORCE_SIZE = VG_MAX_ENUM
-} VGFontParamType;
-
-typedef enum {
- VG_IMAGE_FORMAT_QUERY = 0x2100,
- VG_PATH_DATATYPE_QUERY = 0x2101,
-
- VG_HARDWARE_QUERY_TYPE_FORCE_SIZE = VG_MAX_ENUM
-} VGHardwareQueryType;
-
-typedef enum {
- VG_HARDWARE_ACCELERATED = 0x2200,
- VG_HARDWARE_UNACCELERATED = 0x2201,
-
- VG_HARDWARE_QUERY_RESULT_FORCE_SIZE = VG_MAX_ENUM
-} VGHardwareQueryResult;
-
-typedef enum {
- VG_VENDOR = 0x2300,
- VG_RENDERER = 0x2301,
- VG_VERSION = 0x2302,
- VG_EXTENSIONS = 0x2303,
-
- VG_STRING_ID_FORCE_SIZE = VG_MAX_ENUM
-} VGStringID;
-
-/* Function Prototypes */
-
-#ifndef VG_API_CALL
-# error VG_API_CALL must be defined
-#endif
-
-#ifndef VG_API_ENTRY
-# error VG_API_ENTRY must be defined
-#endif
-
-#ifndef VG_API_EXIT
-# error VG_API_EXIT must be defined
-#endif
-
-VG_API_CALL VGErrorCode VG_API_ENTRY vgGetError(void) VG_API_EXIT;
-
-VG_API_CALL void VG_API_ENTRY vgFlush(void) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgFinish(void) VG_API_EXIT;
-
-/* Getters and Setters */
-VG_API_CALL void VG_API_ENTRY vgSetf (VGParamType type, VGfloat value) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgSeti (VGParamType type, VGint value) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgSetfv(VGParamType type, VGint count,
- const VGfloat * values) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgSetiv(VGParamType type, VGint count,
- const VGint * values) VG_API_EXIT;
-
-VG_API_CALL VGfloat VG_API_ENTRY vgGetf(VGParamType type) VG_API_EXIT;
-VG_API_CALL VGint VG_API_ENTRY vgGeti(VGParamType type) VG_API_EXIT;
-VG_API_CALL VGint VG_API_ENTRY vgGetVectorSize(VGParamType type) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgGetfv(VGParamType type, VGint count, VGfloat * values) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgGetiv(VGParamType type, VGint count, VGint * values) VG_API_EXIT;
-
-VG_API_CALL void VG_API_ENTRY vgSetParameterf(VGHandle object,
- VGint paramType,
- VGfloat value) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgSetParameteri(VGHandle object,
- VGint paramType,
- VGint value) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgSetParameterfv(VGHandle object,
- VGint paramType,
- VGint count, const VGfloat * values) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgSetParameteriv(VGHandle object,
- VGint paramType,
- VGint count, const VGint * values) VG_API_EXIT;
-
-VG_API_CALL VGfloat VG_API_ENTRY vgGetParameterf(VGHandle object,
- VGint paramType) VG_API_EXIT;
-VG_API_CALL VGint VG_API_ENTRY vgGetParameteri(VGHandle object,
- VGint paramType);
-VG_API_CALL VGint VG_API_ENTRY vgGetParameterVectorSize(VGHandle object,
- VGint paramType) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgGetParameterfv(VGHandle object,
- VGint paramType,
- VGint count, VGfloat * values) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgGetParameteriv(VGHandle object,
- VGint paramType,
- VGint count, VGint * values) VG_API_EXIT;
-
-/* Matrix Manipulation */
-VG_API_CALL void VG_API_ENTRY vgLoadIdentity(void) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgLoadMatrix(const VGfloat * m) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgGetMatrix(VGfloat * m) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgMultMatrix(const VGfloat * m) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgTranslate(VGfloat tx, VGfloat ty) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgScale(VGfloat sx, VGfloat sy) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgShear(VGfloat shx, VGfloat shy) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgRotate(VGfloat angle) VG_API_EXIT;
-
-/* Masking and Clearing */
-VG_API_CALL void VG_API_ENTRY vgMask(VGHandle mask, VGMaskOperation operation,
- VGint x, VGint y,
- VGint width, VGint height) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgRenderToMask(VGPath path,
- VGbitfield paintModes,
- VGMaskOperation operation) VG_API_EXIT;
-VG_API_CALL VGMaskLayer VG_API_ENTRY vgCreateMaskLayer(VGint width, VGint height) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgDestroyMaskLayer(VGMaskLayer maskLayer) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgFillMaskLayer(VGMaskLayer maskLayer,
- VGint x, VGint y,
- VGint width, VGint height,
- VGfloat value) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgCopyMask(VGMaskLayer maskLayer,
- VGint dx, VGint dy,
- VGint sx, VGint sy,
- VGint width, VGint height) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgClear(VGint x, VGint y, VGint width, VGint height) VG_API_EXIT;
-
-/* Paths */
-VG_API_CALL VGPath VG_API_ENTRY vgCreatePath(VGint pathFormat,
- VGPathDatatype datatype,
- VGfloat scale, VGfloat bias,
- VGint segmentCapacityHint,
- VGint coordCapacityHint,
- VGbitfield capabilities) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgClearPath(VGPath path, VGbitfield capabilities) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgDestroyPath(VGPath path) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgRemovePathCapabilities(VGPath path,
- VGbitfield capabilities) VG_API_EXIT;
-VG_API_CALL VGbitfield VG_API_ENTRY vgGetPathCapabilities(VGPath path) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgAppendPath(VGPath dstPath, VGPath srcPath) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgAppendPathData(VGPath dstPath,
- VGint numSegments,
- const VGubyte * pathSegments,
- const void * pathData) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgModifyPathCoords(VGPath dstPath, VGint startIndex,
- VGint numSegments,
- const void * pathData) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgTransformPath(VGPath dstPath, VGPath srcPath) VG_API_EXIT;
-VG_API_CALL VGboolean VG_API_ENTRY vgInterpolatePath(VGPath dstPath,
- VGPath startPath,
- VGPath endPath,
- VGfloat amount) VG_API_EXIT;
-VG_API_CALL VGfloat VG_API_ENTRY vgPathLength(VGPath path,
- VGint startSegment, VGint numSegments) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgPointAlongPath(VGPath path,
- VGint startSegment, VGint numSegments,
- VGfloat distance,
- VGfloat * x, VGfloat * y,
- VGfloat * tangentX, VGfloat * tangentY) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgPathBounds(VGPath path,
- VGfloat * minX, VGfloat * minY,
- VGfloat * width, VGfloat * height) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgPathTransformedBounds(VGPath path,
- VGfloat * minX, VGfloat * minY,
- VGfloat * width, VGfloat * height) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgDrawPath(VGPath path, VGbitfield paintModes) VG_API_EXIT;
-
-/* Paint */
-VG_API_CALL VGPaint VG_API_ENTRY vgCreatePaint(void) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgDestroyPaint(VGPaint paint) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgSetPaint(VGPaint paint, VGbitfield paintModes) VG_API_EXIT;
-VG_API_CALL VGPaint VG_API_ENTRY vgGetPaint(VGPaintMode paintMode) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgSetColor(VGPaint paint, VGuint rgba) VG_API_EXIT;
-VG_API_CALL VGuint VG_API_ENTRY vgGetColor(VGPaint paint) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgPaintPattern(VGPaint paint, VGImage pattern) VG_API_EXIT;
-
-/* Images */
-VG_API_CALL VGImage VG_API_ENTRY vgCreateImage(VGImageFormat format,
- VGint width, VGint height,
- VGbitfield allowedQuality) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgDestroyImage(VGImage image) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgClearImage(VGImage image,
- VGint x, VGint y, VGint width, VGint height) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgImageSubData(VGImage image,
- const void * data, VGint dataStride,
- VGImageFormat dataFormat,
- VGint x, VGint y, VGint width, VGint height) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgGetImageSubData(VGImage image,
- void * data, VGint dataStride,
- VGImageFormat dataFormat,
- VGint x, VGint y,
- VGint width, VGint height) VG_API_EXIT;
-VG_API_CALL VGImage VG_API_ENTRY vgChildImage(VGImage parent,
- VGint x, VGint y, VGint width, VGint height) VG_API_EXIT;
-VG_API_CALL VGImage VG_API_ENTRY vgGetParent(VGImage image) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgCopyImage(VGImage dst, VGint dx, VGint dy,
- VGImage src, VGint sx, VGint sy,
- VGint width, VGint height,
- VGboolean dither) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgDrawImage(VGImage image) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgSetPixels(VGint dx, VGint dy,
- VGImage src, VGint sx, VGint sy,
- VGint width, VGint height) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgWritePixels(const void * data, VGint dataStride,
- VGImageFormat dataFormat,
- VGint dx, VGint dy,
- VGint width, VGint height) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgGetPixels(VGImage dst, VGint dx, VGint dy,
- VGint sx, VGint sy,
- VGint width, VGint height) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgReadPixels(void * data, VGint dataStride,
- VGImageFormat dataFormat,
- VGint sx, VGint sy,
- VGint width, VGint height) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgCopyPixels(VGint dx, VGint dy,
- VGint sx, VGint sy,
- VGint width, VGint height) VG_API_EXIT;
-
-/* Text */
-VG_API_CALL VGFont VG_API_ENTRY vgCreateFont(VGint glyphCapacityHint) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgDestroyFont(VGFont font) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgSetGlyphToPath(VGFont font,
- VGuint glyphIndex,
- VGPath path,
- VGboolean isHinted,
- const VGfloat glyphOrigin [2],
- const VGfloat escapement[2]) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgSetGlyphToImage(VGFont font,
- VGuint glyphIndex,
- VGImage image,
- const VGfloat glyphOrigin [2],
- const VGfloat escapement[2]) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgClearGlyph(VGFont font,VGuint glyphIndex) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgDrawGlyph(VGFont font,
- VGuint glyphIndex,
- VGbitfield paintModes,
- VGboolean allowAutoHinting) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgDrawGlyphs(VGFont font,
- VGint glyphCount,
- const VGuint *glyphIndices,
- const VGfloat *adjustments_x,
- const VGfloat *adjustments_y,
- VGbitfield paintModes,
- VGboolean allowAutoHinting) VG_API_EXIT;
-
-/* Image Filters */
-VG_API_CALL void VG_API_ENTRY vgColorMatrix(VGImage dst, VGImage src,
- const VGfloat * matrix) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgConvolve(VGImage dst, VGImage src,
- VGint kernelWidth, VGint kernelHeight,
- VGint shiftX, VGint shiftY,
- const VGshort * kernel,
- VGfloat scale,
- VGfloat bias,
- VGTilingMode tilingMode) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgSeparableConvolve(VGImage dst, VGImage src,
- VGint kernelWidth,
- VGint kernelHeight,
- VGint shiftX, VGint shiftY,
- const VGshort * kernelX,
- const VGshort * kernelY,
- VGfloat scale,
- VGfloat bias,
- VGTilingMode tilingMode) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgGaussianBlur(VGImage dst, VGImage src,
- VGfloat stdDeviationX,
- VGfloat stdDeviationY,
- VGTilingMode tilingMode) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgLookup(VGImage dst, VGImage src,
- const VGubyte * redLUT,
- const VGubyte * greenLUT,
- const VGubyte * blueLUT,
- const VGubyte * alphaLUT,
- VGboolean outputLinear,
- VGboolean outputPremultiplied) VG_API_EXIT;
-VG_API_CALL void VG_API_ENTRY vgLookupSingle(VGImage dst, VGImage src,
- const VGuint * lookupTable,
- VGImageChannel sourceChannel,
- VGboolean outputLinear,
- VGboolean outputPremultiplied) VG_API_EXIT;
-
-/* Hardware Queries */
-VG_API_CALL VGHardwareQueryResult VG_API_ENTRY vgHardwareQuery(VGHardwareQueryType key,
- VGint setting) VG_API_EXIT;
-
-/* Renderer and Extension Information */
-VG_API_CALL const VGubyte * VG_API_ENTRY vgGetString(VGStringID name) VG_API_EXIT;
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif /* _OPENVG_H */
+++ /dev/null
-/* $Revision: 6810 $ on $Date:: 2008-10-29 07:31:37 -0700 #$ */
-
-/*------------------------------------------------------------------------
- *
- * VG extensions Reference Implementation
- * -------------------------------------
- *
- * Copyright (c) 2008 The Khronos Group Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and /or associated documentation files
- * (the "Materials "), to deal in the Materials without restriction,
- * including without limitation the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Materials,
- * and to permit persons to whom the Materials are furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Materials.
- *
- * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
- * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR
- * THE USE OR OTHER DEALINGS IN THE MATERIALS.
- *
- *//**
- * \file
- * \brief VG extensions
- *//*-------------------------------------------------------------------*/
-
-
-
-#ifndef _VGEXT_H
-#define _VGEXT_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <VG/openvg.h>
-#include <VG/vgu.h>
-
-#ifndef VG_API_ENTRYP
-# define VG_API_ENTRYP VG_API_ENTRY*
-#endif
-
-#ifndef VGU_API_ENTRYP
-# define VGU_API_ENTRYP VGU_API_ENTRY*
-#endif
-
-/*-------------------------------------------------------------------------------
- * KHR extensions
- *------------------------------------------------------------------------------*/
-
-typedef enum {
-
-#ifndef VG_KHR_iterative_average_blur
- VG_MAX_AVERAGE_BLUR_DIMENSION_KHR = 0x116B,
- VG_AVERAGE_BLUR_DIMENSION_RESOLUTION_KHR = 0x116C,
- VG_MAX_AVERAGE_BLUR_ITERATIONS_KHR = 0x116D,
-#endif
-
- VG_PARAM_TYPE_KHR_FORCE_SIZE = VG_MAX_ENUM
-} VGParamTypeKHR;
-
-#ifndef VG_KHR_EGL_image
-#define VG_KHR_EGL_image 1
-/* VGEGLImageKHR is an opaque handle to an EGLImage */
-typedef void* VGeglImageKHR;
-
-#ifdef VG_VGEXT_PROTOTYPES
-VG_API_CALL VGImage VG_API_ENTRY vgCreateEGLImageTargetKHR(VGeglImageKHR image);
-#endif
-typedef VGImage (VG_API_ENTRYP PFNVGCREATEEGLIMAGETARGETKHRPROC) (VGeglImageKHR image);
-
-#endif
-
-
-#ifndef VG_KHR_iterative_average_blur
-#define VG_KHR_iterative_average_blur 1
-
-#ifdef VG_VGEXT_PROTOTYPES
-VG_API_CALL void vgIterativeAverageBlurKHR(VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGTilingMode tilingMode);
-#endif
-typedef void (VG_API_ENTRYP PFNVGITERATIVEAVERAGEBLURKHRPROC) (VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGTilingMode tilingMode);
-
-#endif
-
-
-#ifndef VG_KHR_advanced_blending
-#define VG_KHR_advanced_blending 1
-
-typedef enum {
- VG_BLEND_OVERLAY_KHR = 0x2010,
- VG_BLEND_HARDLIGHT_KHR = 0x2011,
- VG_BLEND_SOFTLIGHT_SVG_KHR = 0x2012,
- VG_BLEND_SOFTLIGHT_KHR = 0x2013,
- VG_BLEND_COLORDODGE_KHR = 0x2014,
- VG_BLEND_COLORBURN_KHR = 0x2015,
- VG_BLEND_DIFFERENCE_KHR = 0x2016,
- VG_BLEND_SUBTRACT_KHR = 0x2017,
- VG_BLEND_INVERT_KHR = 0x2018,
- VG_BLEND_EXCLUSION_KHR = 0x2019,
- VG_BLEND_LINEARDODGE_KHR = 0x201a,
- VG_BLEND_LINEARBURN_KHR = 0x201b,
- VG_BLEND_VIVIDLIGHT_KHR = 0x201c,
- VG_BLEND_LINEARLIGHT_KHR = 0x201d,
- VG_BLEND_PINLIGHT_KHR = 0x201e,
- VG_BLEND_HARDMIX_KHR = 0x201f,
- VG_BLEND_CLEAR_KHR = 0x2020,
- VG_BLEND_DST_KHR = 0x2021,
- VG_BLEND_SRC_OUT_KHR = 0x2022,
- VG_BLEND_DST_OUT_KHR = 0x2023,
- VG_BLEND_SRC_ATOP_KHR = 0x2024,
- VG_BLEND_DST_ATOP_KHR = 0x2025,
- VG_BLEND_XOR_KHR = 0x2026,
-
- VG_BLEND_MODE_KHR_FORCE_SIZE= VG_MAX_ENUM
-} VGBlendModeKHR;
-#endif
-
-#ifndef VG_KHR_parametric_filter
-#define VG_KHR_parametric_filter 1
-
-typedef enum {
- VG_PF_OBJECT_VISIBLE_FLAG_KHR = (1 << 0),
- VG_PF_KNOCKOUT_FLAG_KHR = (1 << 1),
- VG_PF_OUTER_FLAG_KHR = (1 << 2),
- VG_PF_INNER_FLAG_KHR = (1 << 3),
-
- VG_PF_TYPE_KHR_FORCE_SIZE = VG_MAX_ENUM
-} VGPfTypeKHR;
-
-typedef enum {
- VGU_IMAGE_IN_USE_ERROR = 0xF010,
-
- VGU_ERROR_CODE_KHR_FORCE_SIZE = VG_MAX_ENUM
-} VGUErrorCodeKHR;
-
-#ifdef VG_VGEXT_PROTOTYPES
-VG_API_CALL void VG_API_ENTRY vgParametricFilterKHR(VGImage dst,VGImage src,VGImage blur,VGfloat strength,VGfloat offsetX,VGfloat offsetY,VGbitfield filterFlags,VGPaint highlightPaint,VGPaint shadowPaint);
-VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguDropShadowKHR(VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGfloat distance,VGfloat angle,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint shadowColorRGBA);
-VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguGlowKHR(VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint glowColorRGBA) ;
-VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguBevelKHR(VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGfloat distance,VGfloat angle,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint highlightColorRGBA,VGuint shadowColorRGBA);
-VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguGradientGlowKHR(VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGfloat distance,VGfloat angle,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint stopsCount,const VGfloat* glowColorRampStops);
-VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguGradientBevelKHR(VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGfloat distance,VGfloat angle,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint stopsCount,const VGfloat* bevelColorRampStops);
-#endif
-typedef void (VG_API_ENTRYP PFNVGPARAMETRICFILTERKHRPROC) (VGImage dst,VGImage src,VGImage blur,VGfloat strength,VGfloat offsetX,VGfloat offsetY,VGbitfield filterFlags,VGPaint highlightPaint,VGPaint shadowPaint);
-typedef VGUErrorCode (VGU_API_ENTRYP PFNVGUDROPSHADOWKHRPROC) (VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGfloat distance,VGfloat angle,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint shadowColorRGBA);
-typedef VGUErrorCode (VGU_API_ENTRYP PFNVGUGLOWKHRPROC) (VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint glowColorRGBA);
-typedef VGUErrorCode (VGU_API_ENTRYP PFNVGUBEVELKHRPROC) (VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGfloat distance,VGfloat angle,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint highlightColorRGBA,VGuint shadowColorRGBA);
-typedef VGUErrorCode (VGU_API_ENTRYP PFNVGUGRADIENTGLOWKHRPROC) (VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGfloat distance,VGfloat angle,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint stopsCount,const VGfloat* glowColorRampStops);
-typedef VGUErrorCode (VGU_API_ENTRYP PFNVGUGRADIENTBEVELKHRPROC) (VGImage dst,VGImage src,VGfloat dimX,VGfloat dimY,VGuint iterative,VGfloat strength,VGfloat distance,VGfloat angle,VGbitfield filterFlags,VGbitfield allowedQuality,VGuint stopsCount,const VGfloat* bevelColorRampStops);
-
-#endif
-
-
-/*-------------------------------------------------------------------------------
- * NDS extensions
- *------------------------------------------------------------------------------*/
-
-#ifndef VG_NDS_paint_generation
-#define VG_NDS_paint_generation 1
-
-typedef enum {
- VG_PAINT_COLOR_RAMP_LINEAR_NDS = 0x1A10,
- VG_COLOR_MATRIX_NDS = 0x1A11,
- VG_PAINT_COLOR_TRANSFORM_LINEAR_NDS = 0x1A12,
-
- VG_PAINT_PARAM_TYPE_NDS_FORCE_SIZE = VG_MAX_ENUM
-} VGPaintParamTypeNds;
-
-typedef enum {
- VG_DRAW_IMAGE_COLOR_MATRIX_NDS = 0x1F10,
-
- VG_IMAGE_MODE_NDS_FORCE_SIZE = VG_MAX_ENUM
-} VGImageModeNds;
-#endif
-
-
-#ifndef VG_NDS_projective_geometry
-#define VG_NDS_projective_geometry 1
-
-typedef enum {
- VG_CLIP_MODE_NDS = 0x1180,
- VG_CLIP_LINES_NDS = 0x1181,
- VG_MAX_CLIP_LINES_NDS = 0x1182,
-
- VG_PARAM_TYPE_NDS_FORCE_SIZE = VG_MAX_ENUM
-} VGParamTypeNds;
-
-typedef enum {
- VG_CLIPMODE_NONE_NDS = 0x3000,
- VG_CLIPMODE_CLIP_CLOSED_NDS = 0x3001,
- VG_CLIPMODE_CLIP_OPEN_NDS = 0x3002,
- VG_CLIPMODE_CULL_NDS = 0x3003,
-
- VG_CLIPMODE_NDS_FORCE_SIZE = VG_MAX_ENUM
-} VGClipModeNds;
-
-typedef enum {
- VG_RQUAD_TO_NDS = ( 13 << 1 ),
- VG_RCUBIC_TO_NDS = ( 14 << 1 ),
-
- VG_PATH_SEGMENT_NDS_FORCE_SIZE = VG_MAX_ENUM
-} VGPathSegmentNds;
-
-typedef enum {
- VG_RQUAD_TO_ABS_NDS = (VG_RQUAD_TO_NDS | VG_ABSOLUTE),
- VG_RQUAD_TO_REL_NDS = (VG_RQUAD_TO_NDS | VG_RELATIVE),
- VG_RCUBIC_TO_ABS_NDS = (VG_RCUBIC_TO_NDS | VG_ABSOLUTE),
- VG_RCUBIC_TO_REL_NDS = (VG_RCUBIC_TO_NDS | VG_RELATIVE),
-
- VG_PATH_COMMAND_NDS_FORCE_SIZE = VG_MAX_ENUM
-} VGPathCommandNds;
-
-#ifdef VG_VGEXT_PROTOTYPES
-VG_API_CALL void VG_API_ENTRY vgProjectiveMatrixNDS(VGboolean enable) ;
-VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguTransformClipLineNDS(const VGfloat Ain,const VGfloat Bin,const VGfloat Cin,const VGfloat* matrix,const VGboolean inverse,VGfloat* Aout,VGfloat* Bout,VGfloat* Cout);
-#endif
-typedef void (VG_API_ENTRYP PFNVGPROJECTIVEMATRIXNDSPROC) (VGboolean enable) ;
-typedef VGUErrorCode (VGU_API_ENTRYP PFNVGUTRANSFORMCLIPLINENDSPROC) (const VGfloat Ain,const VGfloat Bin,const VGfloat Cin,const VGfloat* matrix,const VGboolean inverse,VGfloat* Aout,VGfloat* Bout,VGfloat* Cout);
-
-#endif
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif /* _VGEXT_H */
+++ /dev/null
-/* $Revision: 6810 $ on $Date:: 2008-10-29 07:31:37 -0700 #$ */
-
-/*------------------------------------------------------------------------
- *
- * VG platform specific header Reference Implementation
- * ----------------------------------------------------
- *
- * Copyright (c) 2008 The Khronos Group Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and /or associated documentation files
- * (the "Materials "), to deal in the Materials without restriction,
- * including without limitation the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Materials,
- * and to permit persons to whom the Materials are furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Materials.
- *
- * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
- * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR
- * THE USE OR OTHER DEALINGS IN THE MATERIALS.
- *
- *//**
- * \file
- * \brief VG platform specific header
- *//*-------------------------------------------------------------------*/
-
-#ifndef _VGPLATFORM_H
-#define _VGPLATFORM_H
-
-#include <KHR/khrplatform.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef VG_API_CALL
-#if defined(OPENVG_STATIC_LIBRARY)
-# define VG_API_CALL
-#else
-# define VG_API_CALL KHRONOS_APICALL
-#endif /* defined OPENVG_STATIC_LIBRARY */
-#endif /* ifndef VG_API_CALL */
-
-#ifndef VGU_API_CALL
-#if defined(OPENVG_STATIC_LIBRARY)
-# define VGU_API_CALL
-#else
-# define VGU_API_CALL KHRONOS_APICALL
-#endif /* defined OPENVG_STATIC_LIBRARY */
-#endif /* ifndef VGU_API_CALL */
-
-
-#ifndef VG_API_ENTRY
-#define VG_API_ENTRY
-#endif
-
-#ifndef VG_API_EXIT
-#define VG_API_EXIT
-#endif
-
-#ifndef VGU_API_ENTRY
-#define VGU_API_ENTRY
-#endif
-
-#ifndef VGU_API_EXIT
-#define VGU_API_EXIT
-#endif
-
-typedef float VGfloat;
-typedef signed char VGbyte;
-typedef unsigned char VGubyte;
-typedef signed short VGshort;
-typedef signed int VGint;
-typedef unsigned int VGuint;
-typedef unsigned int VGbitfield;
-
-#ifndef VG_VGEXT_PROTOTYPES
-#define VG_VGEXT_PROTOTYPES
-#endif
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif /* _VGPLATFORM_H */
+++ /dev/null
-/* $Revision: 6810 $ on $Date:: 2008-10-29 07:31:37 -0700 #$ */
-
-/*------------------------------------------------------------------------
- *
- * VGU 1.1 Reference Implementation
- * -------------------------------------
- *
- * Copyright (c) 2008 The Khronos Group Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and /or associated documentation files
- * (the "Materials "), to deal in the Materials without restriction,
- * including without limitation the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Materials,
- * and to permit persons to whom the Materials are furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Materials.
- *
- * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
- * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR
- * THE USE OR OTHER DEALINGS IN THE MATERIALS.
- *
- *//**
- * \file
- * \brief VGU 1.1 API.
- *//*-------------------------------------------------------------------*/
-
-#ifndef _VGU_H
-#define _VGU_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <VG/openvg.h>
-
-#define VGU_VERSION_1_0 1
-#define VGU_VERSION_1_1 2
-
-#ifndef VGU_API_CALL
-# error VGU_API_CALL must be defined
-#endif
-
-#ifndef VGU_API_ENTRY
-# error VGU_API_ENTRY must be defined
-#endif
-
-#ifndef VGU_API_EXIT
-# error VGU_API_EXIT must be defined
-#endif
-
-
-typedef enum {
- VGU_NO_ERROR = 0,
- VGU_BAD_HANDLE_ERROR = 0xF000,
- VGU_ILLEGAL_ARGUMENT_ERROR = 0xF001,
- VGU_OUT_OF_MEMORY_ERROR = 0xF002,
- VGU_PATH_CAPABILITY_ERROR = 0xF003,
- VGU_BAD_WARP_ERROR = 0xF004,
-
- VGU_ERROR_CODE_FORCE_SIZE = VG_MAX_ENUM
-} VGUErrorCode;
-
-typedef enum {
- VGU_ARC_OPEN = 0xF100,
- VGU_ARC_CHORD = 0xF101,
- VGU_ARC_PIE = 0xF102,
-
- VGU_ARC_TYPE_FORCE_SIZE = VG_MAX_ENUM
-} VGUArcType;
-
-VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguLine(VGPath path,
- VGfloat x0, VGfloat y0,
- VGfloat x1, VGfloat y1) VGU_API_EXIT;
-
-VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguPolygon(VGPath path,
- const VGfloat * points, VGint count,
- VGboolean closed) VGU_API_EXIT;
-
-VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguRect(VGPath path,
- VGfloat x, VGfloat y,
- VGfloat width, VGfloat height) VGU_API_EXIT;
-
-VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguRoundRect(VGPath path,
- VGfloat x, VGfloat y,
- VGfloat width, VGfloat height,
- VGfloat arcWidth, VGfloat arcHeight) VGU_API_EXIT;
-
-VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguEllipse(VGPath path,
- VGfloat cx, VGfloat cy,
- VGfloat width, VGfloat height) VGU_API_EXIT;
-
-VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguArc(VGPath path,
- VGfloat x, VGfloat y,
- VGfloat width, VGfloat height,
- VGfloat startAngle, VGfloat angleExtent,
- VGUArcType arcType) VGU_API_EXIT;
-
-VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguComputeWarpQuadToSquare(VGfloat sx0, VGfloat sy0,
- VGfloat sx1, VGfloat sy1,
- VGfloat sx2, VGfloat sy2,
- VGfloat sx3, VGfloat sy3,
- VGfloat * matrix) VGU_API_EXIT;
-
-VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguComputeWarpSquareToQuad(VGfloat dx0, VGfloat dy0,
- VGfloat dx1, VGfloat dy1,
- VGfloat dx2, VGfloat dy2,
- VGfloat dx3, VGfloat dy3,
- VGfloat * matrix) VGU_API_EXIT;
-
-VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguComputeWarpQuadToQuad(VGfloat dx0, VGfloat dy0,
- VGfloat dx1, VGfloat dy1,
- VGfloat dx2, VGfloat dy2,
- VGfloat dx3, VGfloat dy3,
- VGfloat sx0, VGfloat sy0,
- VGfloat sx1, VGfloat sy1,
- VGfloat sx2, VGfloat sy2,
- VGfloat sx3, VGfloat sy3,
- VGfloat * matrix) VGU_API_EXIT;
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif /* #ifndef _VGU_H */
SConscript('mesa/SConscript')
-SConscript('mapi/vgapi/SConscript')
-
if not env['embedded']:
if env['platform'] not in ('cygwin', 'darwin', 'freebsd', 'haiku', 'windows'):
SConscript('glx/SConscript')
SUBDIRS += state_trackers/dri targets/dri
endif
-## the egl target depends on vega
-if HAVE_OPENVG
-SUBDIRS += state_trackers/vega
-endif
-
if HAVE_X11_DRIVER
SUBDIRS += state_trackers/glx/xlib targets/libgl-xlib
endif
])
if not env['embedded']:
- SConscript('state_trackers/vega/SConscript')
-
if env['x11']:
SConscript([
'state_trackers/glx/xlib/SConscript',
acceleration services to X11 servers with the DRI extension. Supports DRI1
and DRI2. Only GL is supported.
-.. _egl:
-
-EGL
-^^^
-
-Tracker for the Khronos EGL standard, used to set up GL and GLES contexts
-without extra knowledge of the underlying windowing system.
-
GLX
^^^
Mesa should be built with another state tracker, such as :ref:`DRI` or
:ref:`EGL`.
-OpenVG
-^^^^^^
-
-Tracker that implements the Khronos OpenVG standard.
-
VDPAU
^^^^^
+++ /dev/null
-# Copyright © 2012 Intel Corporation
-#
-# Permission is hereby granted, free of charge, to any person obtaining a
-# copy of this software and associated documentation files (the "Software"),
-# to deal in the Software without restriction, including without limitation
-# the rights to use, copy, modify, merge, publish, distribute, sublicense,
-# and/or sell copies of the Software, and to permit persons to whom the
-# Software is furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice (including the next
-# paragraph) shall be included in all copies or substantial portions of the
-# Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-# DEALINGS IN THE SOFTWARE.
-
-include Makefile.sources
-include $(top_srcdir)/src/gallium/Automake.inc
-
-AM_CFLAGS = $(GALLIUM_CFLAGS)
-AM_CPPFLAGS = \
- -I$(top_srcdir)/include \
- -I$(top_srcdir)/src/mapi
-
-noinst_LTLIBRARIES = libvega.la
-
-libvega_la_SOURCES = $(C_SOURCES)
-
-BUILT_SOURCES = api_tmp.h
-CLEANFILES = api_tmp.h
-
-api_tmp.h: $(top_srcdir)/src/mapi/vgapi/vgapi.csv $(top_srcdir)/src/mapi/mapi_abi.py
- $(AM_V_GEN) $(PYTHON2) $(PYTHON_FLAGS) $(top_srcdir)/src/mapi/mapi_abi.py \
- --printer vgapi --mode app $< > $@
-
-EXTRA_DIST = SConscript
+++ /dev/null
-C_SOURCES := \
- api.c \
- api.h \
- api_consts.h \
- api_context.c \
- api_filters.c \
- api_images.c \
- api_masks.c \
- api_misc.c \
- api_paint.c \
- api_params.c \
- api_path.c \
- api_text.c \
- api_transform.c \
- arc.c \
- arc.h \
- asm_fill.h \
- asm_filters.h \
- asm_util.h \
- bezier.c \
- bezier.h \
- handle.c \
- handle.h \
- image.c \
- image.h \
- mask.c \
- mask.h \
- matrix.h \
- paint.c \
- paint.h \
- path.c \
- path.h \
- path_utils.h \
- polygon.c \
- polygon.h \
- renderer.c \
- renderer.h \
- shader.c \
- shader.h \
- shaders_cache.c \
- shaders_cache.h \
- stroker.c \
- stroker.h \
- text.c \
- text.h \
- util_array.h \
- vg_api.h \
- vg_context.c \
- vg_context.h \
- vg_manager.c \
- vg_manager.h \
- vg_state.c \
- vg_state.h \
- vg_translate.c \
- vg_translate.h \
- vgu.c
+++ /dev/null
-#######################################################################
-# SConscript for vega state_tracker
-
-Import('*')
-
-from sys import executable as python_cmd
-
-env = env.Clone()
-
-env.Append(CPPPATH = [
- '#/src/mapi',
- Dir('.'),
-])
-env.Append(CPPDEFINES = [
- 'KHRONOS_DLL_EXPORTS',
-])
-
-api_tmp, = env.CodeGenerate(
- target = 'api_tmp.h',
- script = '#src/mapi/mapi_abi.py',
- source = '#src/mapi/vgapi/vgapi.csv',
- command = python_cmd + ' $SCRIPT --printer vgapi --mode app $SOURCE > $TARGET'
-)
-
-st_vega = env.ConvenienceLibrary(
- target = 'st_vega',
- source = env.ParseSourceList('Makefile.sources', 'C_SOURCES')
-)
-
-Export('st_vega')
+++ /dev/null
-/*
- * Mesa 3-D graphics library
- *
- * Copyright (C) 2010 LunarG Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- *
- * Authors:
- * Chia-I Wu <olv@lunarg.com>
- */
-
-#include "mapi.h"
-
-/* define vega_spec and vega_procs for use with mapi */
-#define API_TMP_DEFINE_SPEC
-#include "api.h"
-
-static void api_init(void)
-{
- static boolean initialized = FALSE;
- if (!initialized) {
- mapi_init(vega_spec);
- initialized = TRUE;
- }
-}
-
-struct mapi_table *api_create_dispatch(void)
-{
- struct mapi_table *tbl;
-
- api_init();
-
- tbl = mapi_table_create();
- if (tbl)
- mapi_table_fill(tbl, vega_procs);
-
- return tbl;
-}
-
-void api_destroy_dispatch(struct mapi_table *tbl)
-{
- mapi_table_destroy(tbl);
-}
-
-void api_make_dispatch_current(const struct mapi_table *tbl)
-{
- mapi_table_make_current(tbl);
-}
-
-mapi_proc api_get_proc_address(const char *proc_name)
-{
- if (!proc_name || proc_name[0] != 'v' || proc_name[1] != 'g')
- return NULL;
- proc_name += 2;
-
- api_init();
- return mapi_get_proc_address(proc_name);
-}
+++ /dev/null
-/*
- * Mesa 3-D graphics library
- *
- * Copyright (C) 2010 LunarG Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- *
- * Authors:
- * Chia-I Wu <olv@lunarg.com>
- */
-
-#ifndef API_H
-#define API_H
-
-#include "VG/openvg.h"
-#include "VG/vgext.h"
-#include "vg_manager.h"
-
-#include "api_tmp.h"
-
-struct mapi_table;
-
-struct mapi_table *api_create_dispatch(void);
-
-void api_destroy_dispatch(struct mapi_table *tbl);
-
-void api_make_dispatch_current(const struct mapi_table *tbl);
-
-st_proc_t api_get_proc_address(const char *proc_name);
-
-#endif /* API_H */
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#ifndef API_CONSTS_H
-#define API_CONSTS_H
-
-/*must be at least 32*/
-#define VEGA_MAX_SCISSOR_RECTS 32
-
-/*must be at least 16*/
-#define VEGA_MAX_DASH_COUNT 32
-
-/*must be at least 7*/
-#define VEGA_MAX_KERNEL_SIZE 7
-
-/*must be at least 15*/
-#define VEGA_MAX_SEPARABLE_KERNEL_SIZE 15
-
-/*must be at least 32*/
-#define VEGA_MAX_COLOR_RAMP_STOPS 256
-
-#define VEGA_MAX_IMAGE_WIDTH 2048
-
-#define VEGA_MAX_IMAGE_HEIGHT 2048
-
-#define VEGA_MAX_IMAGE_PIXELS (2048*2048)
-
-#define VEGA_MAX_IMAGE_BYTES (2048*2048 * 4)
-
-/*must be at least 128*/
-#define VEGA_MAX_GAUSSIAN_STD_DEVIATION 128
-
-#endif
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#include "VG/openvg.h"
-
-#include "vg_manager.h"
-#include "vg_context.h"
-#include "api.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_screen.h"
-
-VGErrorCode vegaGetError(void)
-{
- struct vg_context *ctx = vg_current_context();
- VGErrorCode error = VG_NO_CONTEXT_ERROR;
-
- if (!ctx)
- return error;
-
- error = ctx->_error;
- ctx->_error = VG_NO_ERROR;
-
- return error;
-}
-
-void vegaFlush(void)
-{
- struct vg_context *ctx = vg_current_context();
- struct pipe_context *pipe;
-
- if (!ctx)
- return;
-
- pipe = ctx->pipe;
- pipe->flush(pipe, NULL, 0);
-
- vg_manager_flush_frontbuffer(ctx);
-}
-
-void vegaFinish(void)
-{
- struct vg_context *ctx = vg_current_context();
- struct pipe_fence_handle *fence = NULL;
- struct pipe_context *pipe;
-
- if (!ctx)
- return;
-
- pipe = ctx->pipe;
-
- pipe->flush(pipe, &fence, 0);
- if (fence) {
- pipe->screen->fence_finish(pipe->screen, fence,
- PIPE_TIMEOUT_INFINITE);
- pipe->screen->fence_reference(pipe->screen, &fence, NULL);
- }
-}
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#include "VG/openvg.h"
-
-#include "vg_context.h"
-#include "image.h"
-#include "api.h"
-#include "handle.h"
-#include "renderer.h"
-#include "shaders_cache.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_state.h"
-#include "util/u_inlines.h"
-#include "pipe/p_screen.h"
-
-#include "util/u_format.h"
-#include "util/u_sampler.h"
-#include "util/u_string.h"
-
-#include "asm_filters.h"
-
-
-struct filter_info {
- struct vg_image *dst;
- struct vg_image *src;
- struct vg_shader * (*setup_shader)(struct vg_context *, void *);
- void *user_data;
- const void *const_buffer;
- VGint const_buffer_len;
- VGTilingMode tiling_mode;
- struct pipe_sampler_view *extra_texture_view;
-};
-
-static INLINE struct pipe_resource *create_texture_1d(struct vg_context *ctx,
- const VGuint *color_data,
- const VGint color_data_len)
-{
- struct pipe_context *pipe = ctx->pipe;
- struct pipe_screen *screen = pipe->screen;
- struct pipe_resource *tex = 0;
- struct pipe_resource templ;
-
- memset(&templ, 0, sizeof(templ));
- templ.target = PIPE_TEXTURE_1D;
- templ.format = PIPE_FORMAT_B8G8R8A8_UNORM;
- templ.last_level = 0;
- templ.width0 = color_data_len;
- templ.height0 = 1;
- templ.depth0 = 1;
- templ.array_size = 1;
- templ.bind = PIPE_BIND_SAMPLER_VIEW;
-
- tex = screen->resource_create(screen, &templ);
-
- { /* upload color_data */
- struct pipe_transfer *transfer;
- void *map =
- pipe_transfer_map(pipe, tex,
- 0, 0,
- PIPE_TRANSFER_READ_WRITE ,
- 0, 0, tex->width0, tex->height0,
- &transfer);
- memcpy(map, color_data, sizeof(VGint)*color_data_len);
- pipe->transfer_unmap(pipe, transfer);
- }
-
- return tex;
-}
-
-static INLINE struct pipe_sampler_view *create_texture_1d_view(struct vg_context *ctx,
- const VGuint *color_data,
- const VGint color_data_len)
-{
- struct pipe_context *pipe = ctx->pipe;
- struct pipe_resource *texture;
- struct pipe_sampler_view view_templ;
- struct pipe_sampler_view *view;
-
- texture = create_texture_1d(ctx, color_data, color_data_len);
-
- if (!texture)
- return NULL;
-
- u_sampler_view_default_template(&view_templ, texture, texture->format);
- view = pipe->create_sampler_view(pipe, texture, &view_templ);
- /* want the texture to go away if the view is freed */
- pipe_resource_reference(&texture, NULL);
-
- return view;
-}
-
-static struct vg_shader * setup_color_matrix(struct vg_context *ctx, void *user_data)
-{
- struct vg_shader *shader =
- shader_create_from_text(ctx->pipe, color_matrix_asm, 200,
- PIPE_SHADER_FRAGMENT);
- return shader;
-}
-
-static struct vg_shader * setup_convolution(struct vg_context *ctx, void *user_data)
-{
- char buffer[1024];
- VGint num_consts = (VGint)(long)(user_data);
- struct vg_shader *shader;
-
- util_snprintf(buffer, 1023, convolution_asm, num_consts, num_consts / 2 + 1);
-
- shader = shader_create_from_text(ctx->pipe, buffer, 200,
- PIPE_SHADER_FRAGMENT);
-
- return shader;
-}
-
-static struct vg_shader * setup_lookup(struct vg_context *ctx, void *user_data)
-{
- struct vg_shader *shader =
- shader_create_from_text(ctx->pipe, lookup_asm,
- 200, PIPE_SHADER_FRAGMENT);
-
- return shader;
-}
-
-
-static struct vg_shader * setup_lookup_single(struct vg_context *ctx, void *user_data)
-{
- char buffer[1024];
- VGImageChannel channel = (VGImageChannel)(user_data);
- struct vg_shader *shader;
-
- switch(channel) {
- case VG_RED:
- util_snprintf(buffer, 1023, lookup_single_asm, "xxxx");
- break;
- case VG_GREEN:
- util_snprintf(buffer, 1023, lookup_single_asm, "yyyy");
- break;
- case VG_BLUE:
- util_snprintf(buffer, 1023, lookup_single_asm, "zzzz");
- break;
- case VG_ALPHA:
- util_snprintf(buffer, 1023, lookup_single_asm, "wwww");
- break;
- default:
- debug_assert(!"Unknown color channel");
- }
-
- shader = shader_create_from_text(ctx->pipe, buffer, 200,
- PIPE_SHADER_FRAGMENT);
-
- return shader;
-}
-
-static void execute_filter(struct vg_context *ctx,
- struct filter_info *info)
-{
- struct vg_shader *shader;
- const struct pipe_sampler_state *samplers[2];
- struct pipe_sampler_view *views[2];
- struct pipe_sampler_state sampler;
- uint tex_wrap;
-
- memset(&sampler, 0, sizeof(sampler));
- sampler.min_img_filter = PIPE_TEX_FILTER_LINEAR;
- sampler.mag_img_filter = PIPE_TEX_FILTER_LINEAR;
- sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
- sampler.normalized_coords = 1;
-
- switch (info->tiling_mode) {
- case VG_TILE_FILL:
- tex_wrap = PIPE_TEX_WRAP_CLAMP_TO_BORDER;
- /* copy border color */
- memcpy(sampler.border_color.f, ctx->state.vg.tile_fill_color,
- sizeof(sampler.border_color));
- break;
- case VG_TILE_PAD:
- tex_wrap = PIPE_TEX_WRAP_CLAMP_TO_EDGE;;
- break;
- case VG_TILE_REPEAT:
- tex_wrap = PIPE_TEX_WRAP_REPEAT;;
- break;
- case VG_TILE_REFLECT:
- tex_wrap = PIPE_TEX_WRAP_MIRROR_REPEAT;
- break;
- default:
- debug_assert(!"Unknown tiling mode");
- tex_wrap = 0;
- break;
- }
-
- sampler.wrap_s = tex_wrap;
- sampler.wrap_t = tex_wrap;
- sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
-
- samplers[0] = samplers[1] = &sampler;
- views[0] = info->src->sampler_view;
- views[1] = info->extra_texture_view;
-
- shader = info->setup_shader(ctx, info->user_data);
-
- if (renderer_filter_begin(ctx->renderer,
- info->dst->sampler_view->texture, VG_TRUE,
- ctx->state.vg.filter_channel_mask,
- samplers, views, (info->extra_texture_view) ? 2 : 1,
- shader->driver, info->const_buffer, info->const_buffer_len)) {
- renderer_filter(ctx->renderer,
- info->dst->x, info->dst->y, info->dst->width, info->dst->height,
- info->src->x, info->src->y, info->src->width, info->src->height);
- renderer_filter_end(ctx->renderer);
- }
-
- vg_shader_destroy(ctx, shader);
-}
-
-void vegaColorMatrix(VGImage dst, VGImage src,
- const VGfloat * matrix)
-{
- struct vg_context *ctx = vg_current_context();
- struct vg_image *d, *s;
- struct filter_info info;
-
- if (dst == VG_INVALID_HANDLE || src == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
- if (!matrix || !is_aligned(matrix)) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- d = handle_to_image(dst);
- s = handle_to_image(src);
-
- if (vg_image_overlaps(d, s)) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- info.dst = d;
- info.src = s;
- info.setup_shader = &setup_color_matrix;
- info.user_data = NULL;
- info.const_buffer = matrix;
- info.const_buffer_len = 20 * sizeof(VGfloat);
- info.tiling_mode = VG_TILE_PAD;
- info.extra_texture_view = NULL;
- execute_filter(ctx, &info);
-}
-
-static VGfloat texture_offset(VGfloat width, VGint kernelSize, VGint current, VGint shift)
-{
- VGfloat diff = (VGfloat) (current - shift);
-
- return diff / width;
-}
-
-void vegaConvolve(VGImage dst, VGImage src,
- VGint kernelWidth, VGint kernelHeight,
- VGint shiftX, VGint shiftY,
- const VGshort * kernel,
- VGfloat scale,
- VGfloat bias,
- VGTilingMode tilingMode)
-{
- struct vg_context *ctx = vg_current_context();
- VGfloat *buffer;
- VGint buffer_len;
- VGint i, j;
- VGint idx = 0;
- struct vg_image *d, *s;
- VGint kernel_size = kernelWidth * kernelHeight;
- struct filter_info info;
- const VGint max_kernel_size = vegaGeti(VG_MAX_KERNEL_SIZE);
-
- if (dst == VG_INVALID_HANDLE || src == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
-
- if (kernelWidth <= 0 || kernelHeight <= 0 ||
- kernelWidth > max_kernel_size || kernelHeight > max_kernel_size) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- if (!kernel || !is_aligned_to(kernel, 2)) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- if (tilingMode < VG_TILE_FILL ||
- tilingMode > VG_TILE_REFLECT) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- d = handle_to_image(dst);
- s = handle_to_image(src);
-
- if (vg_image_overlaps(d, s)) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- vg_validate_state(ctx);
-
- buffer_len = 8 + 2 * 4 * kernel_size;
- buffer = malloc(buffer_len * sizeof(VGfloat));
-
- buffer[0] = 0.f;
- buffer[1] = 1.f;
- buffer[2] = 2.f; /*unused*/
- buffer[3] = 4.f; /*unused*/
-
- buffer[4] = (VGfloat) (kernelWidth * kernelHeight);
- buffer[5] = scale;
- buffer[6] = bias;
- buffer[7] = 0.f;
-
- idx = 8;
- for (j = 0; j < kernelHeight; ++j) {
- for (i = 0; i < kernelWidth; ++i) {
- VGint index = j * kernelWidth + i;
- VGfloat x, y;
-
- x = (VGfloat) texture_offset(s->width, kernelWidth, i, shiftX);
- y = (VGfloat) texture_offset(s->height, kernelHeight, j, shiftY);
-
- buffer[idx + index*4 + 0] = x;
- buffer[idx + index*4 + 1] = y;
- buffer[idx + index*4 + 2] = 0.f;
- buffer[idx + index*4 + 3] = 0.f;
- }
- }
- idx += kernel_size * 4;
-
- for (j = 0; j < kernelHeight; ++j) {
- for (i = 0; i < kernelWidth; ++i) {
- /* transpose the kernel */
- VGint index = j * kernelWidth + i;
- VGint kindex = (kernelWidth - i - 1) * kernelHeight + (kernelHeight - j - 1);
- buffer[idx + index*4 + 0] = kernel[kindex];
- buffer[idx + index*4 + 1] = kernel[kindex];
- buffer[idx + index*4 + 2] = kernel[kindex];
- buffer[idx + index*4 + 3] = kernel[kindex];
- }
- }
-
- info.dst = d;
- info.src = s;
- info.setup_shader = &setup_convolution;
- info.user_data = (void*)(long)(buffer_len/4);
- info.const_buffer = buffer;
- info.const_buffer_len = buffer_len * sizeof(VGfloat);
- info.tiling_mode = tilingMode;
- info.extra_texture_view = NULL;
- execute_filter(ctx, &info);
-
- free(buffer);
-}
-
-void vegaSeparableConvolve(VGImage dst, VGImage src,
- VGint kernelWidth,
- VGint kernelHeight,
- VGint shiftX, VGint shiftY,
- const VGshort * kernelX,
- const VGshort * kernelY,
- VGfloat scale,
- VGfloat bias,
- VGTilingMode tilingMode)
-{
- struct vg_context *ctx = vg_current_context();
- VGshort *kernel;
- VGint i, j, idx = 0;
- const VGint max_kernel_size = vegaGeti(VG_MAX_SEPARABLE_KERNEL_SIZE);
-
- if (dst == VG_INVALID_HANDLE || src == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
-
- if (kernelWidth <= 0 || kernelHeight <= 0 ||
- kernelWidth > max_kernel_size || kernelHeight > max_kernel_size) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- if (!kernelX || !kernelY ||
- !is_aligned_to(kernelX, 2) || !is_aligned_to(kernelY, 2)) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
- if (tilingMode < VG_TILE_FILL ||
- tilingMode > VG_TILE_REFLECT) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
- kernel = malloc(sizeof(VGshort)*kernelWidth*kernelHeight);
- for (i = 0; i < kernelWidth; ++i) {
- for (j = 0; j < kernelHeight; ++j) {
- kernel[idx] = kernelX[i] * kernelY[j];
- ++idx;
- }
- }
- vegaConvolve(dst, src, kernelWidth, kernelHeight, shiftX, shiftY,
- kernel, scale, bias, tilingMode);
- free(kernel);
-}
-
-static INLINE VGfloat compute_gaussian_componenet(VGfloat x, VGfloat y,
- VGfloat stdDeviationX,
- VGfloat stdDeviationY)
-{
- VGfloat mult = 1 / ( 2 * M_PI * stdDeviationX * stdDeviationY);
- VGfloat e = exp( - ( pow(x, 2)/(2*pow(stdDeviationX, 2)) +
- pow(y, 2)/(2*pow(stdDeviationY, 2)) ) );
- return mult * e;
-}
-
-static INLINE VGint compute_kernel_size(VGfloat deviation)
-{
- VGint size = ceil(2.146 * deviation);
- if (size > 11)
- return 11;
- return size;
-}
-
-static void compute_gaussian_kernel(VGfloat *kernel,
- VGint width, VGint height,
- VGfloat stdDeviationX,
- VGfloat stdDeviationY)
-{
- VGint i, j;
- VGfloat scale = 0.0f;
-
- for (j = 0; j < height; ++j) {
- for (i = 0; i < width; ++i) {
- VGint idx = (height - j -1) * width + (width - i -1);
- kernel[idx] = compute_gaussian_componenet(i-(ceil(width/2))-1,
- j-ceil(height/2)-1,
- stdDeviationX, stdDeviationY);
- scale += kernel[idx];
- }
- }
-
- for (j = 0; j < height; ++j) {
- for (i = 0; i < width; ++i) {
- VGint idx = j * width + i;
- kernel[idx] /= scale;
- }
- }
-}
-
-void vegaGaussianBlur(VGImage dst, VGImage src,
- VGfloat stdDeviationX,
- VGfloat stdDeviationY,
- VGTilingMode tilingMode)
-{
- struct vg_context *ctx = vg_current_context();
- struct vg_image *d, *s;
- VGfloat *buffer, *kernel;
- VGint kernel_width, kernel_height, kernel_size;
- VGint buffer_len;
- VGint idx, i, j;
- struct filter_info info;
-
- if (dst == VG_INVALID_HANDLE || src == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
- if (stdDeviationX <= 0 || stdDeviationY <= 0) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- if (tilingMode < VG_TILE_FILL ||
- tilingMode > VG_TILE_REFLECT) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- d = handle_to_image(dst);
- s = handle_to_image(src);
-
- if (vg_image_overlaps(d, s)) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- kernel_width = compute_kernel_size(stdDeviationX);
- kernel_height = compute_kernel_size(stdDeviationY);
- kernel_size = kernel_width * kernel_height;
- kernel = malloc(sizeof(VGfloat)*kernel_size);
- compute_gaussian_kernel(kernel, kernel_width, kernel_height,
- stdDeviationX, stdDeviationY);
-
- buffer_len = 8 + 2 * 4 * kernel_size;
- buffer = malloc(buffer_len * sizeof(VGfloat));
-
- buffer[0] = 0.f;
- buffer[1] = 1.f;
- buffer[2] = 2.f; /*unused*/
- buffer[3] = 4.f; /*unused*/
-
- buffer[4] = kernel_width * kernel_height;
- buffer[5] = 1.f;/*scale*/
- buffer[6] = 0.f;/*bias*/
- buffer[7] = 0.f;
-
- idx = 8;
- for (j = 0; j < kernel_height; ++j) {
- for (i = 0; i < kernel_width; ++i) {
- VGint index = j * kernel_width + i;
- VGfloat x, y;
-
- x = texture_offset(s->width, kernel_width, i, kernel_width/2);
- y = texture_offset(s->height, kernel_height, j, kernel_height/2);
-
- buffer[idx + index*4 + 0] = x;
- buffer[idx + index*4 + 1] = y;
- buffer[idx + index*4 + 2] = 0.f;
- buffer[idx + index*4 + 3] = 0.f;
- }
- }
- idx += kernel_size * 4;
-
- for (j = 0; j < kernel_height; ++j) {
- for (i = 0; i < kernel_width; ++i) {
- /* transpose the kernel */
- VGint index = j * kernel_width + i;
- VGint kindex = (kernel_width - i - 1) * kernel_height + (kernel_height - j - 1);
- buffer[idx + index*4 + 0] = kernel[kindex];
- buffer[idx + index*4 + 1] = kernel[kindex];
- buffer[idx + index*4 + 2] = kernel[kindex];
- buffer[idx + index*4 + 3] = kernel[kindex];
- }
- }
-
- info.dst = d;
- info.src = s;
- info.setup_shader = &setup_convolution;
- info.user_data = (void*)(long)(buffer_len/4);
- info.const_buffer = buffer;
- info.const_buffer_len = buffer_len * sizeof(VGfloat);
- info.tiling_mode = tilingMode;
- info.extra_texture_view = NULL;
- execute_filter(ctx, &info);
-
- free(buffer);
- free(kernel);
-}
-
-void vegaLookup(VGImage dst, VGImage src,
- const VGubyte * redLUT,
- const VGubyte * greenLUT,
- const VGubyte * blueLUT,
- const VGubyte * alphaLUT,
- VGboolean outputLinear,
- VGboolean outputPremultiplied)
-{
- struct vg_context *ctx = vg_current_context();
- struct vg_image *d, *s;
- VGuint color_data[256];
- VGint i;
- struct pipe_sampler_view *lut_texture_view;
- VGfloat buffer[4];
- struct filter_info info;
-
- if (dst == VG_INVALID_HANDLE || src == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
-
- if (!redLUT || !greenLUT || !blueLUT || !alphaLUT) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- d = handle_to_image(dst);
- s = handle_to_image(src);
-
- if (vg_image_overlaps(d, s)) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- for (i = 0; i < 256; ++i) {
- color_data[i] = blueLUT[i] << 24 | greenLUT[i] << 16 |
- redLUT[i] << 8 | alphaLUT[i];
- }
- lut_texture_view = create_texture_1d_view(ctx, color_data, 255);
-
- buffer[0] = 0.f;
- buffer[1] = 0.f;
- buffer[2] = 1.f;
- buffer[3] = 1.f;
-
- info.dst = d;
- info.src = s;
- info.setup_shader = &setup_lookup;
- info.user_data = NULL;
- info.const_buffer = buffer;
- info.const_buffer_len = 4 * sizeof(VGfloat);
- info.tiling_mode = VG_TILE_PAD;
- info.extra_texture_view = lut_texture_view;
-
- execute_filter(ctx, &info);
-
- pipe_sampler_view_reference(&lut_texture_view, NULL);
-}
-
-void vegaLookupSingle(VGImage dst, VGImage src,
- const VGuint * lookupTable,
- VGImageChannel sourceChannel,
- VGboolean outputLinear,
- VGboolean outputPremultiplied)
-{
- struct vg_context *ctx = vg_current_context();
- struct vg_image *d, *s;
- struct pipe_sampler_view *lut_texture_view;
- VGfloat buffer[4];
- struct filter_info info;
- VGuint color_data[256];
- VGint i;
-
- if (dst == VG_INVALID_HANDLE || src == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
-
- if (!lookupTable || !is_aligned(lookupTable)) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- if (sourceChannel != VG_RED && sourceChannel != VG_GREEN &&
- sourceChannel != VG_BLUE && sourceChannel != VG_ALPHA) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- d = handle_to_image(dst);
- s = handle_to_image(src);
-
- if (vg_image_overlaps(d, s)) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- vg_validate_state(ctx);
-
- for (i = 0; i < 256; ++i) {
- VGuint rgba = lookupTable[i];
- VGubyte blue, green, red, alpha;
- red = (rgba & 0xff000000)>>24;
- green = (rgba & 0x00ff0000)>>16;
- blue = (rgba & 0x0000ff00)>> 8;
- alpha = (rgba & 0x000000ff)>> 0;
- color_data[i] = blue << 24 | green << 16 |
- red << 8 | alpha;
- }
- lut_texture_view = create_texture_1d_view(ctx, color_data, 256);
-
- buffer[0] = 0.f;
- buffer[1] = 0.f;
- buffer[2] = 1.f;
- buffer[3] = 1.f;
-
- info.dst = d;
- info.src = s;
- info.setup_shader = &setup_lookup_single;
- info.user_data = (void*)sourceChannel;
- info.const_buffer = buffer;
- info.const_buffer_len = 4 * sizeof(VGfloat);
- info.tiling_mode = VG_TILE_PAD;
- info.extra_texture_view = lut_texture_view;
-
- execute_filter(ctx, &info);
-
- pipe_sampler_view_reference(&lut_texture_view, NULL);
-}
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#include "image.h"
-
-#include "VG/openvg.h"
-
-#include "vg_context.h"
-#include "vg_translate.h"
-#include "api_consts.h"
-#include "api.h"
-#include "handle.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_screen.h"
-#include "util/u_inlines.h"
-#include "util/u_tile.h"
-#include "util/u_math.h"
-
-static INLINE VGboolean supported_image_format(VGImageFormat format)
-{
- switch(format) {
- case VG_sRGBX_8888:
- case VG_sRGBA_8888:
- case VG_sRGBA_8888_PRE:
- case VG_sRGB_565:
- case VG_sRGBA_5551:
- case VG_sRGBA_4444:
- case VG_sL_8:
- case VG_lRGBX_8888:
- case VG_lRGBA_8888:
- case VG_lRGBA_8888_PRE:
- case VG_lL_8:
- case VG_A_8:
- case VG_BW_1:
-#ifdef OPENVG_VERSION_1_1
- case VG_A_1:
- case VG_A_4:
-#endif
- case VG_sXRGB_8888:
- case VG_sARGB_8888:
- case VG_sARGB_8888_PRE:
- case VG_sARGB_1555:
- case VG_sARGB_4444:
- case VG_lXRGB_8888:
- case VG_lARGB_8888:
- case VG_lARGB_8888_PRE:
- case VG_sBGRX_8888:
- case VG_sBGRA_8888:
- case VG_sBGRA_8888_PRE:
- case VG_sBGR_565:
- case VG_sBGRA_5551:
- case VG_sBGRA_4444:
- case VG_lBGRX_8888:
- case VG_lBGRA_8888:
- case VG_lBGRA_8888_PRE:
- case VG_sXBGR_8888:
- case VG_sABGR_8888:
- case VG_sABGR_8888_PRE:
- case VG_sABGR_1555:
- case VG_sABGR_4444:
- case VG_lXBGR_8888:
- case VG_lABGR_8888:
- case VG_lABGR_8888_PRE:
- return VG_TRUE;
- default:
- return VG_FALSE;
- }
- return VG_FALSE;
-}
-
-VGImage vegaCreateImage(VGImageFormat format,
- VGint width, VGint height,
- VGbitfield allowedQuality)
-{
- struct vg_context *ctx = vg_current_context();
-
- if (!supported_image_format(format)) {
- vg_set_error(ctx, VG_UNSUPPORTED_IMAGE_FORMAT_ERROR);
- return VG_INVALID_HANDLE;
- }
- if (width <= 0 || height <= 0) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return VG_INVALID_HANDLE;
- }
- if (width > vegaGeti(VG_MAX_IMAGE_WIDTH) ||
- height > vegaGeti(VG_MAX_IMAGE_HEIGHT)) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return VG_INVALID_HANDLE;
- }
- if (width * height > vegaGeti(VG_MAX_IMAGE_PIXELS)) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return VG_INVALID_HANDLE;
- }
-
- if (!(allowedQuality & ((VG_IMAGE_QUALITY_NONANTIALIASED |
- VG_IMAGE_QUALITY_FASTER |
- VG_IMAGE_QUALITY_BETTER)))) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return VG_INVALID_HANDLE;
- }
-
- return image_to_handle(image_create(format, width, height));
-}
-
-void vegaDestroyImage(VGImage image)
-{
- struct vg_context *ctx = vg_current_context();
- struct vg_image *img = handle_to_image(image);
-
- if (image == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
- if (!vg_object_is_valid(image, VG_OBJECT_IMAGE)) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
- image_destroy(img);
-}
-
-void vegaClearImage(VGImage image,
- VGint x, VGint y,
- VGint width, VGint height)
-{
- struct vg_context *ctx = vg_current_context();
- struct vg_image *img;
-
- if (image == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
- if (width <= 0 || height <= 0) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- img = handle_to_image(image);
-
- if (x + width < 0 || y + height < 0)
- return;
-
- image_clear(img, x, y, width, height);
-
-}
-
-void vegaImageSubData(VGImage image,
- const void * data,
- VGint dataStride,
- VGImageFormat dataFormat,
- VGint x, VGint y,
- VGint width, VGint height)
-{
- struct vg_context *ctx = vg_current_context();
- struct vg_image *img;
-
- if (image == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
- if (!supported_image_format(dataFormat)) {
- vg_set_error(ctx, VG_UNSUPPORTED_IMAGE_FORMAT_ERROR);
- return;
- }
- if (width <= 0 || height <= 0 || !data || !is_aligned(data)) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- img = handle_to_image(image);
- image_sub_data(img, data, dataStride, dataFormat,
- x, y, width, height);
-}
-
-void vegaGetImageSubData(VGImage image,
- void * data,
- VGint dataStride,
- VGImageFormat dataFormat,
- VGint x, VGint y,
- VGint width, VGint height)
-{
- struct vg_context *ctx = vg_current_context();
- struct vg_image *img;
-
- if (image == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
- if (!supported_image_format(dataFormat)) {
- vg_set_error(ctx, VG_UNSUPPORTED_IMAGE_FORMAT_ERROR);
- return;
- }
- if (width <= 0 || height <= 0 || !data || !is_aligned(data)) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
- img = handle_to_image(image);
- image_get_sub_data(img, data, dataStride, dataFormat,
- x, y, width, height);
-}
-
-VGImage vegaChildImage(VGImage parent,
- VGint x, VGint y,
- VGint width, VGint height)
-{
- struct vg_context *ctx = vg_current_context();
- struct vg_image *p;
-
- if (parent == VG_INVALID_HANDLE ||
- !vg_context_is_object_valid(ctx, VG_OBJECT_IMAGE, parent) ||
- !vg_object_is_valid(parent, VG_OBJECT_IMAGE)) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return VG_INVALID_HANDLE;
- }
- if (width <= 0 || height <= 0 || x < 0 || y < 0) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return VG_INVALID_HANDLE;
- }
- p = handle_to_image(parent);
- if (x > p->width || y > p->height) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return VG_INVALID_HANDLE;
- }
- if (x + width > p->width || y + height > p->height) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return VG_INVALID_HANDLE;
- }
-
- return image_to_handle(image_child_image(p, x, y, width, height));
-}
-
-VGImage vegaGetParent(VGImage image)
-{
- struct vg_context *ctx = vg_current_context();
- struct vg_image *img;
-
- if (image == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return VG_INVALID_HANDLE;
- }
-
- img = handle_to_image(image);
- if (img->parent)
- return image_to_handle(img->parent);
- else
- return image;
-}
-
-void vegaCopyImage(VGImage dst, VGint dx, VGint dy,
- VGImage src, VGint sx, VGint sy,
- VGint width, VGint height,
- VGboolean dither)
-{
- struct vg_context *ctx = vg_current_context();
-
- if (src == VG_INVALID_HANDLE || dst == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
-
- if (width <= 0 || height <= 0) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
- vg_validate_state(ctx);
- image_copy(handle_to_image(dst), dx, dy,
- handle_to_image(src), sx, sy,
- width, height, dither);
-}
-
-void vegaDrawImage(VGImage image)
-{
- struct vg_context *ctx = vg_current_context();
-
- if (!ctx)
- return;
-
- if (image == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
-
- vg_validate_state(ctx);
- image_draw(handle_to_image(image),
- &ctx->state.vg.image_user_to_surface_matrix);
-}
-
-void vegaSetPixels(VGint dx, VGint dy,
- VGImage src, VGint sx, VGint sy,
- VGint width, VGint height)
-{
- struct vg_context *ctx = vg_current_context();
-
- vg_validate_state(ctx);
-
- if (src == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
- if (width <= 0 || height <= 0) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
- image_set_pixels(dx, dy, handle_to_image(src), sx, sy, width,
- height);
-}
-
-void vegaGetPixels(VGImage dst, VGint dx, VGint dy,
- VGint sx, VGint sy,
- VGint width, VGint height)
-{
- struct vg_context *ctx = vg_current_context();
- struct vg_image *img;
-
- if (dst == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
- if (width <= 0 || height <= 0) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- img = handle_to_image(dst);
-
- image_get_pixels(img, dx, dy,
- sx, sy, width, height);
-}
-
-void vegaWritePixels(const void * data, VGint dataStride,
- VGImageFormat dataFormat,
- VGint dx, VGint dy,
- VGint width, VGint height)
-{
- struct vg_context *ctx = vg_current_context();
-
- if (!supported_image_format(dataFormat)) {
- vg_set_error(ctx, VG_UNSUPPORTED_IMAGE_FORMAT_ERROR);
- return;
- }
- if (!data || !is_aligned(data)) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
- if (width <= 0 || height <= 0) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- vg_validate_state(ctx);
- {
- struct vg_image *img = image_create(dataFormat, width, height);
- image_sub_data(img, data, dataStride, dataFormat, 0, 0,
- width, height);
-#if 0
- struct matrix *matrix = &ctx->state.vg.image_user_to_surface_matrix;
- matrix_translate(matrix, dx, dy);
- image_draw(img);
- matrix_translate(matrix, -dx, -dy);
-#else
- /* this looks like a better approach */
- image_set_pixels(dx, dy, img, 0, 0, width, height);
-#endif
- image_destroy(img);
- }
-}
-
-void vegaReadPixels(void * data, VGint dataStride,
- VGImageFormat dataFormat,
- VGint sx, VGint sy,
- VGint width, VGint height)
-{
- struct vg_context *ctx = vg_current_context();
- struct pipe_context *pipe = ctx->pipe;
-
- struct st_framebuffer *stfb = ctx->draw_buffer;
- struct st_renderbuffer *strb = stfb->strb;
-
- VGfloat temp[VEGA_MAX_IMAGE_WIDTH][4];
- VGfloat *df = (VGfloat*)temp;
- VGint i;
- VGubyte *dst = (VGubyte *)data;
- VGint xoffset = 0, yoffset = 0;
-
- if (!supported_image_format(dataFormat)) {
- vg_set_error(ctx, VG_UNSUPPORTED_IMAGE_FORMAT_ERROR);
- return;
- }
- if (!data || !is_aligned(data)) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
- if (width <= 0 || height <= 0) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- if (sx < 0) {
- xoffset = -sx;
- xoffset *= _vega_size_for_format(dataFormat);
- width += sx;
- sx = 0;
- }
- if (sy < 0) {
- yoffset = -sy;
- yoffset *= dataStride;
- height += sy;
- sy = 0;
- }
-
- if (sx + width > stfb->width || sy + height > stfb->height) {
- width = stfb->width - sx;
- height = stfb->height - sy;
- /* nothing to read */
- if (width <= 0 || height <= 0)
- return;
- }
-
- {
- VGint y = (stfb->height - sy) - 1, yStep = -1;
- struct pipe_transfer *transfer;
- void *map;
-
- map = pipe_transfer_map(pipe, strb->texture, 0, 0,
- PIPE_TRANSFER_READ,
- 0, 0, sx + width, stfb->height - sy,
- &transfer);
-
- /* Do a row at a time to flip image data vertically */
- for (i = 0; i < height; i++) {
-#if 0
- debug_printf("%d-%d == %d\n", sy, height, y);
-#endif
- pipe_get_tile_rgba(transfer, map, sx, y, width, 1, df);
- y += yStep;
- _vega_pack_rgba_span_float(ctx, width, temp, dataFormat,
- dst + yoffset + xoffset);
- dst += dataStride;
- }
-
- pipe->transfer_unmap(pipe, transfer);
- }
-}
-
-void vegaCopyPixels(VGint dx, VGint dy,
- VGint sx, VGint sy,
- VGint width, VGint height)
-{
- struct vg_context *ctx = vg_current_context();
- struct st_framebuffer *stfb = ctx->draw_buffer;
- struct st_renderbuffer *strb = stfb->strb;
-
- if (width <= 0 || height <= 0) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- /* do nothing if we copy from outside the fb */
- if (dx >= (VGint)stfb->width || dy >= (VGint)stfb->height ||
- sx >= (VGint)stfb->width || sy >= (VGint)stfb->height)
- return;
-
- vg_validate_state(ctx);
- /* make sure rendering has completed */
- vegaFinish();
-
- vg_copy_surface(ctx, strb->surface, dx, dy,
- strb->surface, sx, sy, width, height);
-}
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#include "VG/openvg.h"
-
-#include "mask.h"
-#include "api.h"
-#include "handle.h"
-#include "renderer.h"
-
-#include "vg_context.h"
-#include "pipe/p_context.h"
-
-void vegaMask(VGHandle mask, VGMaskOperation operation,
- VGint x, VGint y,
- VGint width, VGint height)
-{
- struct vg_context *ctx = vg_current_context();
-
- if (width <=0 || height <= 0) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- if (operation < VG_CLEAR_MASK || operation > VG_SUBTRACT_MASK) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
-
- vg_validate_state(ctx);
-
- if (operation == VG_CLEAR_MASK) {
- mask_fill(x, y, width, height, 0.f);
- } else if (operation == VG_FILL_MASK) {
- mask_fill(x, y, width, height, 1.f);
- } else if (vg_object_is_valid(mask, VG_OBJECT_IMAGE)) {
- struct vg_image *image = handle_to_image(mask);
- mask_using_image(image, operation, x, y, width, height);
- } else if (vg_object_is_valid(mask, VG_OBJECT_MASK)) {
- struct vg_mask_layer *layer = handle_to_masklayer(mask);
- mask_using_layer(layer, operation, x, y, width, height);
- } else {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- }
-}
-
-void vegaClear(VGint x, VGint y,
- VGint width, VGint height)
-{
- struct vg_context *ctx = vg_current_context();
- struct st_framebuffer *stfb = ctx->draw_buffer;
-
- if (width <= 0 || height <= 0) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- vg_validate_state(ctx);
-#if 0
- debug_printf("Clear [%d, %d, %d, %d] with [%f, %f, %f, %f]\n",
- x, y, width, height,
- ctx->state.vg.clear_color[0],
- ctx->state.vg.clear_color[1],
- ctx->state.vg.clear_color[2],
- ctx->state.vg.clear_color[3]);
-#endif
-
- /* check for a whole surface clear */
- if (!ctx->state.vg.scissoring &&
- (x == 0 && y == 0 && width == stfb->width && height == stfb->height)) {
- union pipe_color_union clear_color;
- clear_color.f[0] = ctx->state.vg.clear_color[0];
- clear_color.f[1] = ctx->state.vg.clear_color[1];
- clear_color.f[2] = ctx->state.vg.clear_color[2];
- clear_color.f[3] = ctx->state.vg.clear_color[3];
- ctx->pipe->clear(ctx->pipe, PIPE_CLEAR_COLOR0 | PIPE_CLEAR_DEPTHSTENCIL,
- &clear_color, 1., 0);
- } else if (renderer_clear_begin(ctx->renderer)) {
- /* XXX verify coord round-off */
- renderer_clear(ctx->renderer, x, y, width, height, ctx->state.vg.clear_color);
- renderer_clear_end(ctx->renderer);
- }
-}
-
-
-#ifdef OPENVG_VERSION_1_1
-
-
-void vegaRenderToMask(VGPath path,
- VGbitfield paintModes,
- VGMaskOperation operation)
-{
- struct vg_context *ctx = vg_current_context();
-
- if (path == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
- if (!paintModes || (paintModes&(~(VG_STROKE_PATH|VG_FILL_PATH)))) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
- if (operation < VG_CLEAR_MASK ||
- operation > VG_SUBTRACT_MASK) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
- if (!vg_object_is_valid(path, VG_OBJECT_PATH)) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
-
- vg_validate_state(ctx);
-
- mask_render_to(handle_to_path(path), paintModes, operation);
-}
-
-VGMaskLayer vegaCreateMaskLayer(VGint width, VGint height)
-{
- struct vg_context *ctx = vg_current_context();
-
- if (width <= 0 || height <= 0 ||
- width > vegaGeti(VG_MAX_IMAGE_WIDTH) ||
- height > vegaGeti(VG_MAX_IMAGE_HEIGHT)) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return VG_INVALID_HANDLE;
- }
-
- return masklayer_to_handle(mask_layer_create(width, height));
-}
-
-void vegaDestroyMaskLayer(VGMaskLayer maskLayer)
-{
- struct vg_mask_layer *mask = 0;
- struct vg_context *ctx = vg_current_context();
-
- if (maskLayer == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
- if (!vg_object_is_valid(maskLayer, VG_OBJECT_MASK)) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
-
- mask = handle_to_masklayer(maskLayer);
- mask_layer_destroy(mask);
-}
-
-void vegaFillMaskLayer(VGMaskLayer maskLayer,
- VGint x, VGint y,
- VGint width, VGint height,
- VGfloat value)
-{
- struct vg_mask_layer *mask = 0;
- struct vg_context *ctx = vg_current_context();
-
- if (maskLayer == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
-
- if (value < 0 || value > 1) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- if (width <= 0 || height <= 0) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
- if (x < 0 || y < 0 || (x + width) < 0 || (y + height) < 0) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- if (!vg_object_is_valid(maskLayer, VG_OBJECT_MASK)) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
-
- mask = handle_to_masklayer(maskLayer);
-
- if (x + width > mask_layer_width(mask) ||
- y + height > mask_layer_height(mask)) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- vg_validate_state(ctx);
-
- mask_layer_fill(mask, x, y, width, height, value);
-}
-
-void vegaCopyMask(VGMaskLayer maskLayer,
- VGint sx, VGint sy,
- VGint dx, VGint dy,
- VGint width, VGint height)
-{
- struct vg_context *ctx = vg_current_context();
- struct vg_mask_layer *mask = 0;
-
- if (maskLayer == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
- if (width <= 0 || height <= 0) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
- if (!vg_object_is_valid(maskLayer, VG_OBJECT_MASK)) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
-
- vg_validate_state(ctx);
-
- mask = handle_to_masklayer(maskLayer);
- mask_copy(mask, sx, sy, dx, dy, width, height);
-}
-
-#endif
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#include "VG/openvg.h"
-
-#include "vg_context.h"
-#include "api.h"
-
-/* Hardware Queries */
-VGHardwareQueryResult vegaHardwareQuery(VGHardwareQueryType key,
- VGint setting)
-{
- struct vg_context *ctx = vg_current_context();
-
- if (key < VG_IMAGE_FORMAT_QUERY ||
- key > VG_PATH_DATATYPE_QUERY) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return VG_HARDWARE_UNACCELERATED;
- }
-
- if (key == VG_IMAGE_FORMAT_QUERY) {
- if (setting < VG_sRGBX_8888 ||
- setting > VG_lABGR_8888_PRE) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return VG_HARDWARE_UNACCELERATED;
- }
- } else if (key == VG_PATH_DATATYPE_QUERY) {
- if (setting < VG_PATH_DATATYPE_S_8 ||
- setting > VG_PATH_DATATYPE_F) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return VG_HARDWARE_UNACCELERATED;
- }
- }
- /* we're supposed to accelerate everything */
- return VG_HARDWARE_ACCELERATED;
-}
-
-/* Renderer and Extension Information */
-const VGubyte *vegaGetString(VGStringID name)
-{
- struct vg_context *ctx = vg_current_context();
- static const VGubyte *vendor = (VGubyte *)"Mesa Project";
- static const VGubyte *renderer = (VGubyte *)"Vega OpenVG 1.1";
- static const VGubyte *version = (VGubyte *)"1.1";
-
- if (!ctx)
- return NULL;
-
- switch(name) {
- case VG_VENDOR:
- return vendor;
- case VG_RENDERER:
- return renderer;
- case VG_VERSION:
- return version;
- case VG_EXTENSIONS:
- return NULL;
- default:
- return NULL;
- }
-}
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#include "VG/openvg.h"
-
-#include "vg_context.h"
-#include "paint.h"
-#include "api.h"
-#include "handle.h"
-
-
-VGPaint vegaCreatePaint(void)
-{
- return paint_to_handle(paint_create(vg_current_context()));
-}
-
-void vegaDestroyPaint(VGPaint p)
-{
- struct vg_context *ctx = vg_current_context();
-
- if (p == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
-
- paint_destroy(handle_to_paint(p));
-}
-
-void vegaSetPaint(VGPaint paint, VGbitfield paintModes)
-{
- struct vg_context *ctx = vg_current_context();
-
- if (paint == VG_INVALID_HANDLE) {
- /* restore the default */
- paint = paint_to_handle(ctx->default_paint);
- } else if (!vg_object_is_valid(paint, VG_OBJECT_PAINT)) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
-
- if (!(paintModes & ((VG_FILL_PATH|VG_STROKE_PATH)))) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- if (paintModes & VG_FILL_PATH) {
- ctx->state.vg.fill_paint = handle_to_paint(paint);
- }
- if (paintModes & VG_STROKE_PATH) {
- ctx->state.vg.stroke_paint = handle_to_paint(paint);
- }
-
- ctx->state.dirty |= PAINT_DIRTY;
-}
-
-VGPaint vegaGetPaint(VGPaintMode paintMode)
-{
- struct vg_context *ctx = vg_current_context();
- VGPaint paint = VG_INVALID_HANDLE;
-
- if (paintMode < VG_STROKE_PATH || paintMode > VG_FILL_PATH) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return VG_INVALID_HANDLE;
- }
-
- if (paintMode == VG_FILL_PATH)
- paint = paint_to_handle(ctx->state.vg.fill_paint);
- else if (paintMode == VG_STROKE_PATH)
- paint = paint_to_handle(ctx->state.vg.stroke_paint);
-
- if (paint == paint_to_handle(ctx->default_paint))
- paint = VG_INVALID_HANDLE;
-
- return paint;
-}
-
-void vegaSetColor(VGPaint paint, VGuint rgba)
-{
- struct vg_context *ctx = vg_current_context();
- struct vg_paint *p;
-
- if (paint == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
-
- if (!vg_object_is_valid(paint, VG_OBJECT_PAINT)) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
-
- p = handle_to_paint(paint);
- paint_set_colori(p, rgba);
-
- if (ctx->state.vg.fill_paint == p ||
- ctx->state.vg.stroke_paint == p)
- ctx->state.dirty |= PAINT_DIRTY;
-}
-
-VGuint vegaGetColor(VGPaint paint)
-{
- struct vg_context *ctx = vg_current_context();
- struct vg_paint *p;
- VGuint rgba = 0;
-
- if (paint == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return rgba;
- }
-
- if (!vg_object_is_valid(paint, VG_OBJECT_PAINT)) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return rgba;
- }
- p = handle_to_paint(paint);
-
- return paint_colori(p);
-}
-
-void vegaPaintPattern(VGPaint paint, VGImage pattern)
-{
- struct vg_context *ctx = vg_current_context();
-
- if (paint == VG_INVALID_HANDLE ||
- !vg_context_is_object_valid(ctx, VG_OBJECT_PAINT, paint)) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
-
- if (pattern == VG_INVALID_HANDLE) {
- paint_set_type(handle_to_paint(paint), VG_PAINT_TYPE_COLOR);
- return;
- }
-
- if (!vg_context_is_object_valid(ctx, VG_OBJECT_IMAGE, pattern)) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
-
-
- if (!vg_object_is_valid(paint, VG_OBJECT_PAINT) ||
- !vg_object_is_valid(pattern, VG_OBJECT_IMAGE)) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
- paint_set_pattern(handle_to_paint(paint),
- handle_to_image(pattern));
-}
-
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#include "VG/openvg.h"
-
-#include "vg_context.h"
-#include "paint.h"
-#include "path.h"
-#include "handle.h"
-#include "image.h"
-#include "text.h"
-#include "matrix.h"
-#include "api_consts.h"
-#include "api.h"
-
-#include "pipe/p_compiler.h"
-#include "util/u_pointer.h"
-#include "util/u_math.h"
-
-#include <math.h>
-
-static INLINE struct vg_state *current_state()
-{
- struct vg_context *ctx = vg_current_context();
- if (!ctx)
- return 0;
- else
- return &ctx->state.vg;
-}
-
-static INLINE VGboolean count_in_bounds(VGParamType type, VGint count)
-{
- if (count < 0)
- return VG_FALSE;
-
- if (type == VG_SCISSOR_RECTS)
- return (!(count % 4) && (count >= 0 || count <= VEGA_MAX_SCISSOR_RECTS * 4));
- else if (type == VG_STROKE_DASH_PATTERN) {
- return count <= VEGA_MAX_DASH_COUNT;
- } else {
- VGint real_count = vegaGetVectorSize(type);
- return count == real_count;
- }
-}
-
-void vegaSetf (VGParamType type, VGfloat value)
-{
- struct vg_context *ctx = vg_current_context();
- struct vg_state *state = current_state();
- VGErrorCode error = VG_NO_ERROR;
-
- switch(type) {
- case VG_MATRIX_MODE:
- case VG_FILL_RULE:
- case VG_IMAGE_QUALITY:
- case VG_RENDERING_QUALITY:
- case VG_BLEND_MODE:
- case VG_IMAGE_MODE:
-#ifdef OPENVG_VERSION_1_1
- case VG_COLOR_TRANSFORM:
-#endif
- case VG_STROKE_CAP_STYLE:
- case VG_STROKE_JOIN_STYLE:
- case VG_STROKE_DASH_PHASE_RESET:
- case VG_MASKING:
- case VG_SCISSORING:
- case VG_PIXEL_LAYOUT:
- case VG_SCREEN_LAYOUT:
- case VG_FILTER_FORMAT_LINEAR:
- case VG_FILTER_FORMAT_PREMULTIPLIED:
- case VG_FILTER_CHANNEL_MASK:
-
- case VG_MAX_SCISSOR_RECTS:
- case VG_MAX_DASH_COUNT:
- case VG_MAX_KERNEL_SIZE:
- case VG_MAX_SEPARABLE_KERNEL_SIZE:
- case VG_MAX_COLOR_RAMP_STOPS:
- case VG_MAX_IMAGE_WIDTH:
- case VG_MAX_IMAGE_HEIGHT:
- case VG_MAX_IMAGE_PIXELS:
- case VG_MAX_IMAGE_BYTES:
- case VG_MAX_GAUSSIAN_STD_DEVIATION:
- case VG_MAX_FLOAT:
- vegaSeti(type, floor(value));
- return;
- break;
- case VG_STROKE_LINE_WIDTH:
- state->stroke.line_width.f = value;
- state->stroke.line_width.i = float_to_int_floor(*((VGuint*)(&value)));
- break;
- case VG_STROKE_MITER_LIMIT:
- state->stroke.miter_limit.f = value;
- state->stroke.miter_limit.i = float_to_int_floor(*((VGuint*)(&value)));
- break;
- case VG_STROKE_DASH_PHASE:
- state->stroke.dash_phase.f = value;
- state->stroke.dash_phase.i = float_to_int_floor(*((VGuint*)(&value)));
- break;
- default:
- error = VG_ILLEGAL_ARGUMENT_ERROR;
- break;
- }
- vg_set_error(ctx, error);
-}
-
-void vegaSeti (VGParamType type, VGint value)
-{
- struct vg_context *ctx = vg_current_context();
- struct vg_state *state = current_state();
- VGErrorCode error = VG_NO_ERROR;
-
- switch(type) {
- case VG_MATRIX_MODE:
- if (value < VG_MATRIX_PATH_USER_TO_SURFACE ||
-#ifdef OPENVG_VERSION_1_1
- value > VG_MATRIX_GLYPH_USER_TO_SURFACE)
-#else
- value > VG_MATRIX_STROKE_PAINT_TO_USER)
-#endif
- error = VG_ILLEGAL_ARGUMENT_ERROR;
- else
- state->matrix_mode = value;
- break;
- case VG_FILL_RULE:
- if (value < VG_EVEN_ODD ||
- value > VG_NON_ZERO)
- error = VG_ILLEGAL_ARGUMENT_ERROR;
- else
- state->fill_rule = value;
- break;
- case VG_IMAGE_QUALITY:
- state->image_quality = value;
- break;
- case VG_RENDERING_QUALITY:
- if (value < VG_RENDERING_QUALITY_NONANTIALIASED ||
- value > VG_RENDERING_QUALITY_BETTER)
- error = VG_ILLEGAL_ARGUMENT_ERROR;
- else
- state->rendering_quality = value;
- break;
- case VG_BLEND_MODE:
- if (value < VG_BLEND_SRC ||
- value > VG_BLEND_ADDITIVE)
- error = VG_ILLEGAL_ARGUMENT_ERROR;
- else {
- ctx->state.dirty |= BLEND_DIRTY;
- state->blend_mode = value;
- }
- break;
- case VG_IMAGE_MODE:
- if (value < VG_DRAW_IMAGE_NORMAL ||
- value > VG_DRAW_IMAGE_STENCIL)
- error = VG_ILLEGAL_ARGUMENT_ERROR;
- else
- state->image_mode = value;
- break;
-#ifdef OPENVG_VERSION_1_1
- case VG_COLOR_TRANSFORM:
- state->color_transform = value;
-#endif
- break;
- case VG_STROKE_LINE_WIDTH:
- state->stroke.line_width.f = value;
- state->stroke.line_width.i = value;
- break;
- case VG_STROKE_CAP_STYLE:
- if (value < VG_CAP_BUTT ||
- value > VG_CAP_SQUARE)
- error = VG_ILLEGAL_ARGUMENT_ERROR;
- else
- state->stroke.cap_style = value;
- break;
- case VG_STROKE_JOIN_STYLE:
- if (value < VG_JOIN_MITER ||
- value > VG_JOIN_BEVEL)
- error = VG_ILLEGAL_ARGUMENT_ERROR;
- else
- state->stroke.join_style = value;
- break;
- case VG_STROKE_MITER_LIMIT:
- state->stroke.miter_limit.f = value;
- state->stroke.miter_limit.i = value;
- break;
- case VG_STROKE_DASH_PHASE:
- state->stroke.dash_phase.f = value;
- state->stroke.dash_phase.i = value;
- break;
- case VG_STROKE_DASH_PHASE_RESET:
- state->stroke.dash_phase_reset = value;
- break;
- case VG_MASKING:
- state->masking = value;
- break;
- case VG_SCISSORING:
- state->scissoring = value;
- ctx->state.dirty |= DEPTH_STENCIL_DIRTY;
- break;
- case VG_PIXEL_LAYOUT:
- if (value < VG_PIXEL_LAYOUT_UNKNOWN ||
- value > VG_PIXEL_LAYOUT_BGR_HORIZONTAL)
- error = VG_ILLEGAL_ARGUMENT_ERROR;
- else
- state->pixel_layout = value;
- break;
- case VG_SCREEN_LAYOUT:
- /* read only ignore */
- break;
- case VG_FILTER_FORMAT_LINEAR:
- state->filter_format_linear = value;
- break;
- case VG_FILTER_FORMAT_PREMULTIPLIED:
- state->filter_format_premultiplied = value;
- break;
- case VG_FILTER_CHANNEL_MASK:
- state->filter_channel_mask = value;
- break;
-
- case VG_MAX_SCISSOR_RECTS:
- case VG_MAX_DASH_COUNT:
- case VG_MAX_KERNEL_SIZE:
- case VG_MAX_SEPARABLE_KERNEL_SIZE:
- case VG_MAX_COLOR_RAMP_STOPS:
- case VG_MAX_IMAGE_WIDTH:
- case VG_MAX_IMAGE_HEIGHT:
- case VG_MAX_IMAGE_PIXELS:
- case VG_MAX_IMAGE_BYTES:
- case VG_MAX_GAUSSIAN_STD_DEVIATION:
- case VG_MAX_FLOAT:
- /* read only ignore */
- break;
- default:
- error = VG_ILLEGAL_ARGUMENT_ERROR;
- break;
- }
- vg_set_error(ctx, error);
-}
-
-void vegaSetfv(VGParamType type, VGint count,
- const VGfloat * values)
-{
- struct vg_context *ctx = vg_current_context();
- struct vg_state *state = current_state();
- VGErrorCode error = VG_NO_ERROR;
-
- if ((count && !values) || !count_in_bounds(type, count) || !is_aligned(values)) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- switch(type) {
- case VG_MATRIX_MODE:
- case VG_FILL_RULE:
- case VG_IMAGE_QUALITY:
- case VG_RENDERING_QUALITY:
- case VG_BLEND_MODE:
- case VG_IMAGE_MODE:
-#ifdef OPENVG_VERSION_1_1
- case VG_COLOR_TRANSFORM:
-#endif
- case VG_STROKE_CAP_STYLE:
- case VG_STROKE_JOIN_STYLE:
- case VG_STROKE_DASH_PHASE_RESET:
- case VG_MASKING:
- case VG_SCISSORING:
- case VG_PIXEL_LAYOUT:
- case VG_SCREEN_LAYOUT:
- case VG_FILTER_FORMAT_LINEAR:
- case VG_FILTER_FORMAT_PREMULTIPLIED:
- case VG_FILTER_CHANNEL_MASK:
- vegaSeti(type, floor(values[0]));
- return;
- break;
- case VG_SCISSOR_RECTS: {
- VGint i;
- VGuint *x = (VGuint*)values;
- for (i = 0; i < count; ++i) {
- state->scissor_rects[i].f = values[i];
- state->scissor_rects[i].i = float_to_int_floor(x[i]);
- }
- state->scissor_rects_num = count / 4;
- ctx->state.dirty |= DEPTH_STENCIL_DIRTY;
- }
- break;
-#ifdef OPENVG_VERSION_1_1
- case VG_COLOR_TRANSFORM_VALUES: {
- VGint i;
- for (i = 0; i < count; ++i) {
- state->color_transform_values[i] = values[i];
- }
- }
- break;
-#endif
- case VG_STROKE_LINE_WIDTH:
- state->stroke.line_width.f = values[0];
- state->stroke.line_width.i = float_to_int_floor(*((VGuint*)(values)));
- break;
- case VG_STROKE_MITER_LIMIT:
- state->stroke.miter_limit.f = values[0];
- state->stroke.miter_limit.i = float_to_int_floor(*((VGuint*)(values)));
- break;
- case VG_STROKE_DASH_PATTERN: {
- int i;
- for (i = 0; i < count; ++i) {
- state->stroke.dash_pattern[i].f = values[i];
- state->stroke.dash_pattern[i].i =
- float_to_int_floor(*((VGuint*)(values + i)));
- }
- state->stroke.dash_pattern_num = count;
- }
- break;
- case VG_STROKE_DASH_PHASE:
- state->stroke.dash_phase.f = values[0];
- state->stroke.dash_phase.i = float_to_int_floor(*((VGuint*)(values)));
- break;
- case VG_TILE_FILL_COLOR:
- state->tile_fill_color[0] = values[0];
- state->tile_fill_color[1] = values[1];
- state->tile_fill_color[2] = values[2];
- state->tile_fill_color[3] = values[3];
-
- state->tile_fill_colori[0] = float_to_int_floor(*((VGuint*)(values + 0)));
- state->tile_fill_colori[1] = float_to_int_floor(*((VGuint*)(values + 1)));
- state->tile_fill_colori[2] = float_to_int_floor(*((VGuint*)(values + 2)));
- state->tile_fill_colori[3] = float_to_int_floor(*((VGuint*)(values + 3)));
- break;
- case VG_CLEAR_COLOR:
- state->clear_color[0] = values[0];
- state->clear_color[1] = values[1];
- state->clear_color[2] = values[2];
- state->clear_color[3] = values[3];
-
- state->clear_colori[0] = float_to_int_floor(*((VGuint*)(values + 0)));
- state->clear_colori[1] = float_to_int_floor(*((VGuint*)(values + 1)));
- state->clear_colori[2] = float_to_int_floor(*((VGuint*)(values + 2)));
- state->clear_colori[3] = float_to_int_floor(*((VGuint*)(values + 3)));
- break;
-#ifdef OPENVG_VERSION_1_1
- case VG_GLYPH_ORIGIN:
- state->glyph_origin[0].f = values[0];
- state->glyph_origin[1].f = values[1];
-
- state->glyph_origin[0].i = float_to_int_floor(*((VGuint*)(values + 0)));
- state->glyph_origin[1].i = float_to_int_floor(*((VGuint*)(values + 1)));
- break;
-#endif
-
- case VG_MAX_SCISSOR_RECTS:
- case VG_MAX_DASH_COUNT:
- case VG_MAX_KERNEL_SIZE:
- case VG_MAX_SEPARABLE_KERNEL_SIZE:
- case VG_MAX_COLOR_RAMP_STOPS:
- case VG_MAX_IMAGE_WIDTH:
- case VG_MAX_IMAGE_HEIGHT:
- case VG_MAX_IMAGE_PIXELS:
- case VG_MAX_IMAGE_BYTES:
- case VG_MAX_GAUSSIAN_STD_DEVIATION:
- case VG_MAX_FLOAT:
- break;
- default:
- error = VG_ILLEGAL_ARGUMENT_ERROR;
- break;
- }
- vg_set_error(ctx, error);
-}
-
-void vegaSetiv(VGParamType type, VGint count,
- const VGint * values)
-{
- struct vg_context *ctx = vg_current_context();
- struct vg_state *state = current_state();
-
- if ((count && !values) || !count_in_bounds(type, count) || !is_aligned(values)) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- switch(type) {
- case VG_MATRIX_MODE:
- case VG_FILL_RULE:
- case VG_IMAGE_QUALITY:
- case VG_RENDERING_QUALITY:
- case VG_BLEND_MODE:
- case VG_IMAGE_MODE:
-#ifdef OPENVG_VERSION_1_1
- case VG_COLOR_TRANSFORM:
-#endif
- case VG_STROKE_CAP_STYLE:
- case VG_STROKE_JOIN_STYLE:
- case VG_STROKE_DASH_PHASE_RESET:
- case VG_MASKING:
- case VG_SCISSORING:
- case VG_PIXEL_LAYOUT:
- case VG_SCREEN_LAYOUT:
- case VG_FILTER_FORMAT_LINEAR:
- case VG_FILTER_FORMAT_PREMULTIPLIED:
- case VG_FILTER_CHANNEL_MASK:
- vegaSeti(type, values[0]);
- return;
- break;
- case VG_SCISSOR_RECTS: {
- VGint i;
- for (i = 0; i < count; ++i) {
- state->scissor_rects[i].i = values[i];
- state->scissor_rects[i].f = values[i];
- }
- state->scissor_rects_num = count / 4;
- ctx->state.dirty |= DEPTH_STENCIL_DIRTY;
- }
- break;
-#ifdef OPENVG_VERSION_1_1
- case VG_COLOR_TRANSFORM_VALUES: {
- VGint i;
- for (i = 0; i < count; ++i) {
- state->color_transform_values[i] = values[i];
- }
- }
- break;
-#endif
- case VG_STROKE_LINE_WIDTH:
- state->stroke.line_width.f = values[0];
- state->stroke.line_width.i = values[0];
- break;
- case VG_STROKE_MITER_LIMIT:
- state->stroke.miter_limit.f = values[0];
- state->stroke.miter_limit.i = values[0];
- break;
- case VG_STROKE_DASH_PATTERN: {
- int i;
- for (i = 0; i < count; ++i) {
- state->stroke.dash_pattern[i].f = values[i];
- state->stroke.dash_pattern[i].i = values[i];
- }
- state->stroke.dash_pattern_num = count;
- }
- break;
- case VG_STROKE_DASH_PHASE:
- state->stroke.dash_phase.f = values[0];
- state->stroke.dash_phase.i = values[0];
- break;
- case VG_TILE_FILL_COLOR:
- state->tile_fill_color[0] = values[0];
- state->tile_fill_color[1] = values[1];
- state->tile_fill_color[2] = values[2];
- state->tile_fill_color[3] = values[3];
-
- state->tile_fill_colori[0] = values[0];
- state->tile_fill_colori[1] = values[1];
- state->tile_fill_colori[2] = values[2];
- state->tile_fill_colori[3] = values[3];
- break;
- case VG_CLEAR_COLOR:
- state->clear_color[0] = values[0];
- state->clear_color[1] = values[1];
- state->clear_color[2] = values[2];
- state->clear_color[3] = values[3];
-
- state->clear_colori[0] = values[0];
- state->clear_colori[1] = values[1];
- state->clear_colori[2] = values[2];
- state->clear_colori[3] = values[3];
- break;
-#ifdef OPENVG_VERSION_1_1
- case VG_GLYPH_ORIGIN:
- state->glyph_origin[0].f = values[0];
- state->glyph_origin[1].f = values[1];
- state->glyph_origin[0].i = values[0];
- state->glyph_origin[1].i = values[1];
- break;
-#endif
-
- case VG_MAX_SCISSOR_RECTS:
- case VG_MAX_DASH_COUNT:
- case VG_MAX_KERNEL_SIZE:
- case VG_MAX_SEPARABLE_KERNEL_SIZE:
- case VG_MAX_COLOR_RAMP_STOPS:
- case VG_MAX_IMAGE_WIDTH:
- case VG_MAX_IMAGE_HEIGHT:
- case VG_MAX_IMAGE_PIXELS:
- case VG_MAX_IMAGE_BYTES:
- case VG_MAX_GAUSSIAN_STD_DEVIATION:
- case VG_MAX_FLOAT:
- break;
-
- default:
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- break;
- }
-}
-
-VGfloat vegaGetf(VGParamType type)
-{
- struct vg_context *ctx = vg_current_context();
- const struct vg_state *state = current_state();
- VGErrorCode error = VG_NO_ERROR;
- VGfloat value = 0.0f;
-
- switch(type) {
- case VG_MATRIX_MODE:
- case VG_FILL_RULE:
- case VG_IMAGE_QUALITY:
- case VG_RENDERING_QUALITY:
- case VG_BLEND_MODE:
- case VG_IMAGE_MODE:
-#ifdef OPENVG_VERSION_1_1
- case VG_COLOR_TRANSFORM:
-#endif
- case VG_STROKE_CAP_STYLE:
- case VG_STROKE_JOIN_STYLE:
- case VG_STROKE_DASH_PHASE_RESET:
- case VG_MASKING:
- case VG_SCISSORING:
- case VG_PIXEL_LAYOUT:
- case VG_SCREEN_LAYOUT:
- case VG_FILTER_FORMAT_LINEAR:
- case VG_FILTER_FORMAT_PREMULTIPLIED:
- case VG_FILTER_CHANNEL_MASK:
- return vegaGeti(type);
- break;
- case VG_STROKE_LINE_WIDTH:
- value = state->stroke.line_width.f;
- break;
- case VG_STROKE_MITER_LIMIT:
- value = state->stroke.miter_limit.f;
- break;
- case VG_STROKE_DASH_PHASE:
- value = state->stroke.dash_phase.f;
- break;
-
- case VG_MAX_SCISSOR_RECTS:
- case VG_MAX_DASH_COUNT:
- case VG_MAX_KERNEL_SIZE:
- case VG_MAX_SEPARABLE_KERNEL_SIZE:
- case VG_MAX_COLOR_RAMP_STOPS:
- case VG_MAX_IMAGE_WIDTH:
- case VG_MAX_IMAGE_HEIGHT:
- case VG_MAX_IMAGE_PIXELS:
- case VG_MAX_IMAGE_BYTES:
- case VG_MAX_GAUSSIAN_STD_DEVIATION:
- return vegaGeti(type);
- break;
- case VG_MAX_FLOAT:
- value = 1e+10;/*must be at least 1e+10*/
- break;
- default:
- error = VG_ILLEGAL_ARGUMENT_ERROR;
- break;
- }
- vg_set_error(ctx, error);
- return value;
-}
-
-VGint vegaGeti(VGParamType type)
-{
- const struct vg_state *state = current_state();
- struct vg_context *ctx = vg_current_context();
- VGErrorCode error = VG_NO_ERROR;
- VGint value = 0;
-
- switch(type) {
- case VG_MATRIX_MODE:
- value = state->matrix_mode;
- break;
- case VG_FILL_RULE:
- value = state->fill_rule;
- break;
- case VG_IMAGE_QUALITY:
- value = state->image_quality;
- break;
- case VG_RENDERING_QUALITY:
- value = state->rendering_quality;
- break;
- case VG_BLEND_MODE:
- value = state->blend_mode;
- break;
- case VG_IMAGE_MODE:
- value = state->image_mode;
- break;
-#ifdef OPENVG_VERSION_1_1
- case VG_COLOR_TRANSFORM:
- value = state->color_transform;
- break;
-#endif
- case VG_STROKE_LINE_WIDTH:
- value = state->stroke.line_width.i;
- break;
- case VG_STROKE_CAP_STYLE:
- value = state->stroke.cap_style;
- break;
- case VG_STROKE_JOIN_STYLE:
- value = state->stroke.join_style;
- break;
- case VG_STROKE_MITER_LIMIT:
- value = state->stroke.miter_limit.i;
- break;
- case VG_STROKE_DASH_PHASE:
- value = state->stroke.dash_phase.i;
- break;
- case VG_STROKE_DASH_PHASE_RESET:
- value = state->stroke.dash_phase_reset;
- break;
- case VG_MASKING:
- value = state->masking;
- break;
- case VG_SCISSORING:
- value = state->scissoring;
- break;
- case VG_PIXEL_LAYOUT:
- value = state->pixel_layout;
- break;
- case VG_SCREEN_LAYOUT:
- value = state->screen_layout;
- break;
- case VG_FILTER_FORMAT_LINEAR:
- value = state->filter_format_linear;
- break;
- case VG_FILTER_FORMAT_PREMULTIPLIED:
- value = state->filter_format_premultiplied;
- break;
- case VG_FILTER_CHANNEL_MASK:
- value = state->filter_channel_mask;
- break;
-
- case VG_MAX_SCISSOR_RECTS:
- value = 32; /*must be at least 32*/
- break;
- case VG_MAX_DASH_COUNT:
- value = 16; /*must be at least 16*/
- break;
- case VG_MAX_KERNEL_SIZE:
- value = 7; /*must be at least 7*/
- break;
- case VG_MAX_SEPARABLE_KERNEL_SIZE:
- value = 15; /*must be at least 15*/
- break;
- case VG_MAX_COLOR_RAMP_STOPS:
- value = 256; /*must be at least 32*/
- break;
- case VG_MAX_IMAGE_WIDTH:
- value = 2048;
- break;
- case VG_MAX_IMAGE_HEIGHT:
- value = 2048;
- break;
- case VG_MAX_IMAGE_PIXELS:
- value = 2048*2048;
- break;
- case VG_MAX_IMAGE_BYTES:
- value = 2048*2048 * 4;
- break;
- case VG_MAX_GAUSSIAN_STD_DEVIATION:
- value = 128; /*must be at least 128*/
- break;
-
- case VG_MAX_FLOAT: {
- VGfloat val = vegaGetf(type);
- value = float_to_int_floor(*((VGuint*)&val));
- }
- break;
- default:
- error = VG_ILLEGAL_ARGUMENT_ERROR;
- break;
- }
- vg_set_error(ctx, error);
- return value;
-}
-
-VGint vegaGetVectorSize(VGParamType type)
-{
- struct vg_context *ctx = vg_current_context();
- const struct vg_state *state = current_state();
- switch(type) {
- case VG_MATRIX_MODE:
- case VG_FILL_RULE:
- case VG_IMAGE_QUALITY:
- case VG_RENDERING_QUALITY:
- case VG_BLEND_MODE:
- case VG_IMAGE_MODE:
- return 1;
- case VG_SCISSOR_RECTS:
- return state->scissor_rects_num * 4;
-#ifdef OPENVG_VERSION_1_1
- case VG_COLOR_TRANSFORM:
- return 1;
- case VG_COLOR_TRANSFORM_VALUES:
- return 8;
-#endif
- case VG_STROKE_LINE_WIDTH:
- case VG_STROKE_CAP_STYLE:
- case VG_STROKE_JOIN_STYLE:
- case VG_STROKE_MITER_LIMIT:
- return 1;
- case VG_STROKE_DASH_PATTERN:
- return state->stroke.dash_pattern_num;
- case VG_STROKE_DASH_PHASE:
- return 1;
- case VG_STROKE_DASH_PHASE_RESET:
- return 1;
- case VG_TILE_FILL_COLOR:
- return 4;
- case VG_CLEAR_COLOR:
- return 4;
-#ifdef OPENVG_VERSION_1_1
- case VG_GLYPH_ORIGIN:
- return 2;
-#endif
- case VG_MASKING:
- return 1;
- case VG_SCISSORING:
- return 1;
- case VG_PIXEL_LAYOUT:
- return 1;
- case VG_SCREEN_LAYOUT:
- return 1;
- case VG_FILTER_FORMAT_LINEAR:
- return 1;
- case VG_FILTER_FORMAT_PREMULTIPLIED:
- return 1;
- case VG_FILTER_CHANNEL_MASK:
- return 1;
-
- case VG_MAX_COLOR_RAMP_STOPS:
- return 1;
- case VG_MAX_SCISSOR_RECTS:
- case VG_MAX_DASH_COUNT:
- case VG_MAX_KERNEL_SIZE:
- case VG_MAX_SEPARABLE_KERNEL_SIZE:
- case VG_MAX_IMAGE_WIDTH:
- case VG_MAX_IMAGE_HEIGHT:
- case VG_MAX_IMAGE_PIXELS:
- case VG_MAX_IMAGE_BYTES:
- case VG_MAX_FLOAT:
- case VG_MAX_GAUSSIAN_STD_DEVIATION:
- return 1;
- default:
- if (ctx)
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return 0;
- }
-}
-
-void vegaGetfv(VGParamType type, VGint count,
- VGfloat * values)
-{
- const struct vg_state *state = current_state();
- struct vg_context *ctx = vg_current_context();
- VGint real_count = vegaGetVectorSize(type);
-
- if (!values || count <= 0 || count > real_count || !is_aligned(values)) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- switch(type) {
- case VG_MATRIX_MODE:
- case VG_FILL_RULE:
- case VG_IMAGE_QUALITY:
- case VG_RENDERING_QUALITY:
- case VG_BLEND_MODE:
- case VG_IMAGE_MODE:
-#ifdef OPENVG_VERSION_1_1
- case VG_COLOR_TRANSFORM:
-#endif
- case VG_STROKE_CAP_STYLE:
- case VG_STROKE_JOIN_STYLE:
- case VG_STROKE_DASH_PHASE_RESET:
- case VG_MASKING:
- case VG_SCISSORING:
- case VG_PIXEL_LAYOUT:
- case VG_SCREEN_LAYOUT:
- case VG_FILTER_FORMAT_LINEAR:
- case VG_FILTER_FORMAT_PREMULTIPLIED:
- case VG_FILTER_CHANNEL_MASK:
- case VG_MAX_SCISSOR_RECTS:
- case VG_MAX_DASH_COUNT:
- case VG_MAX_KERNEL_SIZE:
- case VG_MAX_SEPARABLE_KERNEL_SIZE:
- case VG_MAX_COLOR_RAMP_STOPS:
- case VG_MAX_IMAGE_WIDTH:
- case VG_MAX_IMAGE_HEIGHT:
- case VG_MAX_IMAGE_PIXELS:
- case VG_MAX_IMAGE_BYTES:
- case VG_MAX_GAUSSIAN_STD_DEVIATION:
- values[0] = vegaGeti(type);
- break;
- case VG_MAX_FLOAT:
- values[0] = vegaGetf(type);
- break;
- case VG_SCISSOR_RECTS: {
- VGint i;
- for (i = 0; i < count; ++i) {
- values[i] = state->scissor_rects[i].f;
- }
- }
- break;
-#ifdef OPENVG_VERSION_1_1
- case VG_COLOR_TRANSFORM_VALUES: {
- memcpy(values, state->color_transform_values,
- sizeof(VGfloat) * count);
- }
- break;
-#endif
- case VG_STROKE_LINE_WIDTH:
- values[0] = state->stroke.line_width.f;
- break;
- case VG_STROKE_MITER_LIMIT:
- values[0] = state->stroke.miter_limit.f;
- break;
- case VG_STROKE_DASH_PATTERN: {
- VGint i;
- for (i = 0; i < count; ++i) {
- values[i] = state->stroke.dash_pattern[i].f;
- }
- }
- break;
- case VG_STROKE_DASH_PHASE:
- values[0] = state->stroke.dash_phase.f;
- break;
- case VG_TILE_FILL_COLOR:
- values[0] = state->tile_fill_color[0];
- values[1] = state->tile_fill_color[1];
- values[2] = state->tile_fill_color[2];
- values[3] = state->tile_fill_color[3];
- break;
- case VG_CLEAR_COLOR:
- values[0] = state->clear_color[0];
- values[1] = state->clear_color[1];
- values[2] = state->clear_color[2];
- values[3] = state->clear_color[3];
- break;
-#ifdef OPENVG_VERSION_1_1
- case VG_GLYPH_ORIGIN:
- values[0] = state->glyph_origin[0].f;
- values[1] = state->glyph_origin[1].f;
- break;
-#endif
- default:
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- break;
- }
-}
-
-void vegaGetiv(VGParamType type, VGint count,
- VGint * values)
-{
- const struct vg_state *state = current_state();
- struct vg_context *ctx = vg_current_context();
- VGint real_count = vegaGetVectorSize(type);
-
- if (!values || count <= 0 || count > real_count || !is_aligned(values)) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- switch(type) {
- case VG_MATRIX_MODE:
- case VG_FILL_RULE:
- case VG_IMAGE_QUALITY:
- case VG_RENDERING_QUALITY:
- case VG_BLEND_MODE:
- case VG_IMAGE_MODE:
-#ifdef OPENVG_VERSION_1_1
- case VG_COLOR_TRANSFORM:
-#endif
- case VG_STROKE_CAP_STYLE:
- case VG_STROKE_JOIN_STYLE:
- case VG_STROKE_DASH_PHASE_RESET:
- case VG_MASKING:
- case VG_SCISSORING:
- case VG_PIXEL_LAYOUT:
- case VG_SCREEN_LAYOUT:
- case VG_FILTER_FORMAT_LINEAR:
- case VG_FILTER_FORMAT_PREMULTIPLIED:
- case VG_FILTER_CHANNEL_MASK:
- case VG_MAX_SCISSOR_RECTS:
- case VG_MAX_DASH_COUNT:
- case VG_MAX_KERNEL_SIZE:
- case VG_MAX_SEPARABLE_KERNEL_SIZE:
- case VG_MAX_COLOR_RAMP_STOPS:
- case VG_MAX_IMAGE_WIDTH:
- case VG_MAX_IMAGE_HEIGHT:
- case VG_MAX_IMAGE_PIXELS:
- case VG_MAX_IMAGE_BYTES:
- case VG_MAX_GAUSSIAN_STD_DEVIATION:
- values[0] = vegaGeti(type);
- break;
- case VG_MAX_FLOAT: {
- VGfloat val = vegaGetf(type);
- values[0] = float_to_int_floor(*((VGuint*)&val));
- }
- break;
- case VG_SCISSOR_RECTS: {
- VGint i;
- for (i = 0; i < count; ++i) {
- values[i] = state->scissor_rects[i].i;
- }
- }
- break;
-#ifdef OPENVG_VERSION_1_1
- case VG_COLOR_TRANSFORM_VALUES: {
- VGint i;
- VGuint *x = (VGuint*)state->color_transform_values;
- for (i = 0; i < count; ++i) {
- values[i] = float_to_int_floor(x[i]);
- }
- }
- break;
-#endif
- case VG_STROKE_LINE_WIDTH:
- values[0] = state->stroke.line_width.i;
- break;
- case VG_STROKE_MITER_LIMIT:
- values[0] = state->stroke.miter_limit.i;
- break;
- case VG_STROKE_DASH_PATTERN: {
- VGint i;
- for (i = 0; i < count; ++i) {
- values[i] = state->stroke.dash_pattern[i].i;
- }
- }
- break;
- case VG_STROKE_DASH_PHASE:
- values[0] = state->stroke.dash_phase.i;
- break;
- case VG_TILE_FILL_COLOR:
- values[0] = state->tile_fill_colori[0];
- values[1] = state->tile_fill_colori[1];
- values[2] = state->tile_fill_colori[2];
- values[3] = state->tile_fill_colori[3];
- break;
- case VG_CLEAR_COLOR:
- values[0] = state->clear_colori[0];
- values[1] = state->clear_colori[1];
- values[2] = state->clear_colori[2];
- values[3] = state->clear_colori[3];
- break;
-#ifdef OPENVG_VERSION_1_1
- case VG_GLYPH_ORIGIN:
- values[0] = state->glyph_origin[0].i;
- values[1] = state->glyph_origin[1].i;
- break;
-#endif
- default:
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- break;
- }
-}
-
-void vegaSetParameterf(VGHandle object,
- VGint paramType,
- VGfloat value)
-{
- struct vg_context *ctx = vg_current_context();
- void *ptr = handle_to_pointer(object);
-
- if (object == VG_INVALID_HANDLE || !is_aligned(ptr)) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
-
- switch(paramType) {
- case VG_PAINT_TYPE:
- case VG_PAINT_COLOR_RAMP_SPREAD_MODE:
- case VG_PAINT_PATTERN_TILING_MODE:
- vegaSetParameteri(object, paramType, floor(value));
- return;
- break;
- case VG_PAINT_COLOR:
- case VG_PAINT_COLOR_RAMP_STOPS:
- case VG_PAINT_LINEAR_GRADIENT:
- case VG_PAINT_RADIAL_GRADIENT:
- /* it's an error if paramType refers to a vector parameter */
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- break;
- case VG_PAINT_COLOR_RAMP_PREMULTIPLIED: {
- struct vg_paint *p = handle_to_paint(object);
- paint_set_color_ramp_premultiplied(p, value);
- }
- break;
-
- case VG_PATH_DATATYPE:
- case VG_PATH_FORMAT:
- case VG_PATH_SCALE:
- case VG_PATH_BIAS:
- case VG_PATH_NUM_SEGMENTS:
- case VG_PATH_NUM_COORDS:
-
- case VG_IMAGE_FORMAT:
- case VG_IMAGE_WIDTH:
- case VG_IMAGE_HEIGHT:
-
-#ifdef OPENVG_VERSION_1_1
- case VG_FONT_NUM_GLYPHS:
- /* read only don't produce an error */
- break;
-#endif
- default:
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- break;
- }
-}
-
-void vegaSetParameteri(VGHandle object,
- VGint paramType,
- VGint value)
-{
- struct vg_context *ctx = vg_current_context();
- void *ptr = handle_to_pointer(object);
-
- if (object == VG_INVALID_HANDLE || !is_aligned(ptr)) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
-
- switch(paramType) {
- case VG_PAINT_TYPE:
- if (value < VG_PAINT_TYPE_COLOR ||
- value > VG_PAINT_TYPE_PATTERN)
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- else {
- struct vg_paint *paint = handle_to_paint(object);
- paint_set_type(paint, value);
- }
- break;
- case VG_PAINT_COLOR:
- case VG_PAINT_COLOR_RAMP_STOPS:
- case VG_PAINT_LINEAR_GRADIENT:
- case VG_PAINT_RADIAL_GRADIENT:
- /* it's an error if paramType refers to a vector parameter */
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- break;
- case VG_PAINT_COLOR_RAMP_SPREAD_MODE:
- if (value < VG_COLOR_RAMP_SPREAD_PAD ||
- value > VG_COLOR_RAMP_SPREAD_REFLECT)
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- else {
- struct vg_paint *paint = handle_to_paint(object);
- paint_set_spread_mode(paint, value);
- }
- break;
- case VG_PAINT_COLOR_RAMP_PREMULTIPLIED: {
- struct vg_paint *p = handle_to_paint(object);
- paint_set_color_ramp_premultiplied(p, value);
- }
- break;
- case VG_PAINT_PATTERN_TILING_MODE:
- if (value < VG_TILE_FILL ||
- value > VG_TILE_REFLECT)
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- else {
- struct vg_paint *paint = handle_to_paint(object);
- paint_set_pattern_tiling(paint, value);
- }
- break;
-
- case VG_PATH_DATATYPE:
- case VG_PATH_FORMAT:
- case VG_PATH_SCALE:
- case VG_PATH_BIAS:
- case VG_PATH_NUM_SEGMENTS:
- case VG_PATH_NUM_COORDS:
-
- case VG_IMAGE_FORMAT:
- case VG_IMAGE_WIDTH:
- case VG_IMAGE_HEIGHT:
-
-#ifdef OPENVG_VERSION_1_1
- case VG_FONT_NUM_GLYPHS:
- /* read only don't produce an error */
- break;
-#endif
- default:
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-}
-
-void vegaSetParameterfv(VGHandle object,
- VGint paramType,
- VGint count,
- const VGfloat * values)
-{
- struct vg_context *ctx = vg_current_context();
- void *ptr = handle_to_pointer(object);
- VGint real_count = vegaGetParameterVectorSize(object, paramType);
-
- if (object == VG_INVALID_HANDLE || !is_aligned(ptr)) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
-
- if (count < 0 || count < real_count ||
- (values == NULL && count != 0) ||
- !is_aligned(values)) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- switch(paramType) {
- case VG_PAINT_TYPE:
- case VG_PAINT_COLOR_RAMP_SPREAD_MODE:
- case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:
- case VG_PAINT_PATTERN_TILING_MODE:
- if (count != 1)
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- else
- vegaSetParameterf(object, paramType, values[0]);
- return;
- break;
- case VG_PAINT_COLOR: {
- if (count != 4)
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- else {
- struct vg_paint *paint = handle_to_paint(object);
- paint_set_color(paint, values);
- if (ctx->state.vg.fill_paint == paint ||
- ctx->state.vg.stroke_paint == paint)
- ctx->state.dirty |= PAINT_DIRTY;
- }
- }
- break;
- case VG_PAINT_COLOR_RAMP_STOPS: {
- if (count && count < 4)
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- else {
- struct vg_paint *paint = handle_to_paint(object);
- count = MIN2(count, VEGA_MAX_COLOR_RAMP_STOPS);
- paint_set_ramp_stops(paint, values, count);
- {
- VGint stopsi[VEGA_MAX_COLOR_RAMP_STOPS];
- int i = 0;
- for (i = 0; i < count; ++i) {
- stopsi[i] = float_to_int_floor(*((VGuint*)(values + i)));
- }
- paint_set_ramp_stopsi(paint, stopsi, count);
- }
- }
- }
- break;
- case VG_PAINT_LINEAR_GRADIENT: {
- if (count != 4)
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- else {
- struct vg_paint *paint = handle_to_paint(object);
- paint_set_linear_gradient(paint, values);
- {
- VGint vals[4];
- vals[0] = FLT_TO_INT(values[0]);
- vals[1] = FLT_TO_INT(values[1]);
- vals[2] = FLT_TO_INT(values[2]);
- vals[3] = FLT_TO_INT(values[3]);
- paint_set_linear_gradienti(paint, vals);
- }
- }
- }
- break;
- case VG_PAINT_RADIAL_GRADIENT: {
- if (count != 5)
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- else {
- struct vg_paint *paint = handle_to_paint(object);
- paint_set_radial_gradient(paint, values);
- {
- VGint vals[5];
- vals[0] = FLT_TO_INT(values[0]);
- vals[1] = FLT_TO_INT(values[1]);
- vals[2] = FLT_TO_INT(values[2]);
- vals[3] = FLT_TO_INT(values[3]);
- vals[4] = FLT_TO_INT(values[4]);
- paint_set_radial_gradienti(paint, vals);
- }
- }
- }
- break;
-
- case VG_PATH_DATATYPE:
- case VG_PATH_FORMAT:
- case VG_PATH_SCALE:
- case VG_PATH_BIAS:
- case VG_PATH_NUM_SEGMENTS:
- case VG_PATH_NUM_COORDS:
-
-#ifdef OPENVG_VERSION_1_1
- case VG_FONT_NUM_GLYPHS:
- /* read only don't produce an error */
- break;
-#endif
- default:
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-}
-
-void vegaSetParameteriv(VGHandle object,
- VGint paramType,
- VGint count,
- const VGint * values)
-{
- struct vg_context *ctx = vg_current_context();
- void *ptr = handle_to_pointer(object);
- VGint real_count = vegaGetParameterVectorSize(object, paramType);
-
- if (object == VG_INVALID_HANDLE || !is_aligned(ptr)) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
-
- if (count < 0 || count < real_count ||
- (values == NULL && count != 0) ||
- !is_aligned(values)) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- switch(paramType) {
- case VG_PAINT_TYPE:
- case VG_PAINT_COLOR_RAMP_SPREAD_MODE:
- case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:
- case VG_PAINT_PATTERN_TILING_MODE:
- if (count != 1)
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- else
- vegaSetParameteri(object, paramType, values[0]);
- return;
- break;
- case VG_PAINT_COLOR: {
- if (count != 4)
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- else {
- struct vg_paint *paint = handle_to_paint(object);
- paint_set_coloriv(paint, values);
- if (ctx->state.vg.fill_paint == paint ||
- ctx->state.vg.stroke_paint == paint)
- ctx->state.dirty |= PAINT_DIRTY;
- }
- }
- break;
- case VG_PAINT_COLOR_RAMP_STOPS: {
- if ((count % 5))
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- else {
- VGfloat *vals = 0;
- int i;
- struct vg_paint *paint = handle_to_paint(object);
- if (count) {
- vals = malloc(sizeof(VGfloat)*count);
- for (i = 0; i < count; ++i)
- vals[i] = values[i];
- }
-
- paint_set_ramp_stopsi(paint, values, count);
- paint_set_ramp_stops(paint, vals, count);
- free(vals);
- }
- }
- break;
- case VG_PAINT_LINEAR_GRADIENT: {
- if (count != 4)
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- else {
- VGfloat vals[4];
- struct vg_paint *paint = handle_to_paint(object);
- vals[0] = values[0];
- vals[1] = values[1];
- vals[2] = values[2];
- vals[3] = values[3];
- paint_set_linear_gradient(paint, vals);
- paint_set_linear_gradienti(paint, values);
- }
- }
- break;
- case VG_PAINT_RADIAL_GRADIENT: {
- if (count != 5)
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- else {
- VGfloat vals[5];
- struct vg_paint *paint = handle_to_paint(object);
- vals[0] = values[0];
- vals[1] = values[1];
- vals[2] = values[2];
- vals[3] = values[3];
- vals[4] = values[4];
- paint_set_radial_gradient(paint, vals);
- paint_set_radial_gradienti(paint, values);
- }
- }
- break;
- case VG_PATH_DATATYPE:
- case VG_PATH_FORMAT:
- case VG_PATH_SCALE:
- case VG_PATH_BIAS:
- case VG_PATH_NUM_SEGMENTS:
- case VG_PATH_NUM_COORDS:
- /* read only don't produce an error */
- break;
- default:
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-}
-
-VGint vegaGetParameterVectorSize(VGHandle object,
- VGint paramType)
-{
- struct vg_context *ctx = vg_current_context();
-
- if (object == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return 0;
- }
-
- switch(paramType) {
- case VG_PAINT_TYPE:
- case VG_PAINT_COLOR_RAMP_SPREAD_MODE:
- case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:
- case VG_PAINT_PATTERN_TILING_MODE:
- return 1;
- case VG_PAINT_COLOR:
- return 4;
- case VG_PAINT_COLOR_RAMP_STOPS: {
- struct vg_paint *p = handle_to_paint(object);
- return paint_num_ramp_stops(p);
- }
- break;
- case VG_PAINT_LINEAR_GRADIENT:
- return 4;
- case VG_PAINT_RADIAL_GRADIENT:
- return 5;
-
-
- case VG_PATH_FORMAT:
- case VG_PATH_DATATYPE:
- case VG_PATH_SCALE:
- case VG_PATH_BIAS:
- case VG_PATH_NUM_SEGMENTS:
- case VG_PATH_NUM_COORDS:
- return 1;
-
- case VG_IMAGE_FORMAT:
- case VG_IMAGE_WIDTH:
- case VG_IMAGE_HEIGHT:
- return 1;
-
-#ifdef OPENVG_VERSION_1_1
- case VG_FONT_NUM_GLYPHS:
- return 1;
-#endif
-
- default:
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- break;
- }
- return 0;
-}
-
-
-VGfloat vegaGetParameterf(VGHandle object,
- VGint paramType)
-{
- struct vg_context *ctx = vg_current_context();
-
- if (object == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return 0;
- }
-
- switch(paramType) {
- case VG_PAINT_TYPE:
- case VG_PAINT_COLOR_RAMP_SPREAD_MODE:
- case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:
- case VG_PAINT_PATTERN_TILING_MODE:
- return vegaGetParameteri(object, paramType);
- break;
- case VG_PAINT_COLOR:
- case VG_PAINT_COLOR_RAMP_STOPS:
- case VG_PAINT_LINEAR_GRADIENT:
- case VG_PAINT_RADIAL_GRADIENT:
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- break;
-
- case VG_PATH_FORMAT:
- return VG_PATH_FORMAT_STANDARD;
- case VG_PATH_SCALE: {
- struct path *p = handle_to_path(object);
- return path_scale(p);
- }
- case VG_PATH_BIAS: {
- struct path *p = handle_to_path(object);
- return path_bias(p);
- }
- case VG_PATH_DATATYPE:
- case VG_PATH_NUM_SEGMENTS:
- case VG_PATH_NUM_COORDS:
- return vegaGetParameteri(object, paramType);
- break;
-
- case VG_IMAGE_FORMAT:
- case VG_IMAGE_WIDTH:
- case VG_IMAGE_HEIGHT:
-#ifdef OPENVG_VERSION_1_1
- case VG_FONT_NUM_GLYPHS:
- return vegaGetParameteri(object, paramType);
- break;
-#endif
-
- default:
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- break;
- }
- return 0;
-}
-
-VGint vegaGetParameteri(VGHandle object,
- VGint paramType)
-{
- struct vg_context *ctx = vg_current_context();
-
- if (object == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return 0;
- }
-
- switch(paramType) {
- case VG_PAINT_TYPE: {
- struct vg_paint *paint = handle_to_paint(object);
- return paint_type(paint);
- }
- break;
- case VG_PAINT_COLOR_RAMP_SPREAD_MODE: {
- struct vg_paint *p = handle_to_paint(object);
- return paint_spread_mode(p);
- }
- case VG_PAINT_COLOR_RAMP_PREMULTIPLIED: {
- struct vg_paint *p = handle_to_paint(object);
- return paint_color_ramp_premultiplied(p);
- }
- break;
- case VG_PAINT_PATTERN_TILING_MODE: {
- struct vg_paint *p = handle_to_paint(object);
- return paint_pattern_tiling(p);
- }
- break;
- case VG_PAINT_COLOR:
- case VG_PAINT_COLOR_RAMP_STOPS:
- case VG_PAINT_LINEAR_GRADIENT:
- case VG_PAINT_RADIAL_GRADIENT:
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- break;
-
- case VG_PATH_FORMAT:
- return VG_PATH_FORMAT_STANDARD;
- case VG_PATH_SCALE:
- case VG_PATH_BIAS:
- return vegaGetParameterf(object, paramType);
- case VG_PATH_DATATYPE: {
- struct path *p = handle_to_path(object);
- return path_datatype(p);
- }
- case VG_PATH_NUM_SEGMENTS: {
- struct path *p = handle_to_path(object);
- return path_num_segments(p);
- }
- case VG_PATH_NUM_COORDS: {
- struct path *p = handle_to_path(object);
- return path_num_coords(p);
- }
- break;
-
- case VG_IMAGE_FORMAT: {
- struct vg_image *img = handle_to_image(object);
- return img->format;
- }
- break;
- case VG_IMAGE_WIDTH: {
- struct vg_image *img = handle_to_image(object);
- return img->width;
- }
- break;
- case VG_IMAGE_HEIGHT: {
- struct vg_image *img = handle_to_image(object);
- return img->height;
- }
- break;
-
-#ifdef OPENVG_VERSION_1_1
- case VG_FONT_NUM_GLYPHS: {
- struct vg_font *font = handle_to_font(object);
- return font_num_glyphs(font);
- }
- break;
-#endif
-
- default:
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- break;
- }
- return 0;
-}
-
-void vegaGetParameterfv(VGHandle object,
- VGint paramType,
- VGint count,
- VGfloat * values)
-{
- struct vg_context *ctx = vg_current_context();
- VGint real_count = vegaGetParameterVectorSize(object, paramType);
-
- if (object == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
-
- if (!values || count <= 0 || count > real_count ||
- !is_aligned(values)) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- switch(paramType) {
- case VG_PAINT_TYPE: {
- struct vg_paint *p = handle_to_paint(object);
- values[0] = paint_type(p);
- }
- break;
- case VG_PAINT_COLOR_RAMP_SPREAD_MODE: {
- struct vg_paint *p = handle_to_paint(object);
- values[0] = paint_spread_mode(p);
- }
- break;
- case VG_PAINT_COLOR_RAMP_PREMULTIPLIED: {
- struct vg_paint *p = handle_to_paint(object);
- values[0] = paint_color_ramp_premultiplied(p);
- }
- break;
- case VG_PAINT_PATTERN_TILING_MODE: {
- values[0] = vegaGetParameterf(object, paramType);
- }
- break;
- case VG_PAINT_COLOR: {
- struct vg_paint *paint = handle_to_paint(object);
- paint_get_color(paint, values);
- }
- break;
- case VG_PAINT_COLOR_RAMP_STOPS: {
- struct vg_paint *paint = handle_to_paint(object);
- paint_ramp_stops(paint, values, count);
- }
- break;
- case VG_PAINT_LINEAR_GRADIENT: {
- struct vg_paint *paint = handle_to_paint(object);
- paint_linear_gradient(paint, values);
- }
- break;
- case VG_PAINT_RADIAL_GRADIENT: {
- struct vg_paint *paint = handle_to_paint(object);
- paint_radial_gradient(paint, values);
- }
- break;
-
- case VG_PATH_FORMAT:
- case VG_PATH_DATATYPE:
- case VG_PATH_NUM_SEGMENTS:
- case VG_PATH_NUM_COORDS:
- values[0] = vegaGetParameteri(object, paramType);
- break;
- case VG_PATH_SCALE:
- case VG_PATH_BIAS:
- values[0] = vegaGetParameterf(object, paramType);
- break;
-
- case VG_IMAGE_FORMAT:
- case VG_IMAGE_WIDTH:
- case VG_IMAGE_HEIGHT:
-#ifdef OPENVG_VERSION_1_1
- case VG_FONT_NUM_GLYPHS:
- values[0] = vegaGetParameteri(object, paramType);
- break;
-#endif
-
- default:
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- break;
- }
-}
-
-void vegaGetParameteriv(VGHandle object,
- VGint paramType,
- VGint count,
- VGint * values)
-{
- struct vg_context *ctx = vg_current_context();
- VGint real_count = vegaGetParameterVectorSize(object, paramType);
-
- if (object || object == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
-
- if (!values || count <= 0 || count > real_count ||
- !is_aligned(values)) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- switch(paramType) {
- case VG_PAINT_TYPE:
- case VG_PAINT_COLOR_RAMP_SPREAD_MODE:
- case VG_PAINT_COLOR_RAMP_PREMULTIPLIED:
- case VG_PAINT_PATTERN_TILING_MODE:
-#ifdef OPENVG_VERSION_1_1
- case VG_FONT_NUM_GLYPHS:
- values[0] = vegaGetParameteri(object, paramType);
- break;
-#endif
- case VG_PAINT_COLOR: {
- struct vg_paint *paint = handle_to_paint(object);
- paint_get_coloriv(paint, values);
- }
- break;
- case VG_PAINT_COLOR_RAMP_STOPS: {
- struct vg_paint *paint = handle_to_paint(object);
- paint_ramp_stopsi(paint, values, count);
- }
- break;
- case VG_PAINT_LINEAR_GRADIENT: {
- struct vg_paint *paint = handle_to_paint(object);
- paint_linear_gradienti(paint, values);
- }
- break;
- case VG_PAINT_RADIAL_GRADIENT: {
- struct vg_paint *paint = handle_to_paint(object);
- paint_radial_gradienti(paint, values);
- }
- break;
-
- case VG_PATH_SCALE:
- case VG_PATH_BIAS:
- values[0] = vegaGetParameterf(object, paramType);
- break;
- case VG_PATH_FORMAT:
- case VG_PATH_DATATYPE:
- case VG_PATH_NUM_SEGMENTS:
- case VG_PATH_NUM_COORDS:
- values[0] = vegaGetParameteri(object, paramType);
- break;
-
- case VG_IMAGE_FORMAT:
- case VG_IMAGE_WIDTH:
- case VG_IMAGE_HEIGHT:
- values[0] = vegaGetParameteri(object, paramType);
- break;
-
- default:
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- break;
- }
-}
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#include "VG/openvg.h"
-
-#include "vg_context.h"
-#include "handle.h"
-#include "path.h"
-#include "api.h"
-
-#include "pipe/p_context.h"
-
-VGPath vegaCreatePath(VGint pathFormat,
- VGPathDatatype datatype,
- VGfloat scale, VGfloat bias,
- VGint segmentCapacityHint,
- VGint coordCapacityHint,
- VGbitfield capabilities)
-{
- struct vg_context *ctx = vg_current_context();
-
- if (pathFormat != VG_PATH_FORMAT_STANDARD) {
- vg_set_error(ctx, VG_UNSUPPORTED_PATH_FORMAT_ERROR);
- return VG_INVALID_HANDLE;
- }
- if (datatype < VG_PATH_DATATYPE_S_8 ||
- datatype > VG_PATH_DATATYPE_F) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return VG_INVALID_HANDLE;
- }
- if (!scale) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return VG_INVALID_HANDLE;
- }
-
- return path_to_handle(path_create(datatype, scale, bias,
- segmentCapacityHint, coordCapacityHint,
- capabilities));
-}
-
-void vegaClearPath(VGPath path, VGbitfield capabilities)
-{
- struct vg_context *ctx = vg_current_context();
- struct path *p = 0;
-
- if (path == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
-
- p = handle_to_path(path);
- path_clear(p, capabilities);
-}
-
-void vegaDestroyPath(VGPath p)
-{
- struct path *path = 0;
- struct vg_context *ctx = vg_current_context();
-
- if (p == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
-
- path = handle_to_path(p);
- path_destroy(path);
-}
-
-void vegaRemovePathCapabilities(VGPath path,
- VGbitfield capabilities)
-{
- struct vg_context *ctx = vg_current_context();
- VGbitfield current;
- struct path *p;
-
- if (path == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
-
- p = handle_to_path(path);
- current = path_capabilities(p);
- path_set_capabilities(p, (current &
- (~(capabilities & VG_PATH_CAPABILITY_ALL))));
-}
-
-VGbitfield vegaGetPathCapabilities(VGPath path)
-{
- struct vg_context *ctx = vg_current_context();
- struct path *p = 0;
-
- if (path == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return 0;
- }
- p = handle_to_path(path);
- return path_capabilities(p);
-}
-
-void vegaAppendPath(VGPath dstPath, VGPath srcPath)
-{
- struct vg_context *ctx = vg_current_context();
- struct path *src, *dst;
-
- if (dstPath == VG_INVALID_HANDLE || srcPath == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
- src = handle_to_path(srcPath);
- dst = handle_to_path(dstPath);
-
- if (!(path_capabilities(src) & VG_PATH_CAPABILITY_APPEND_FROM) ||
- !(path_capabilities(dst) & VG_PATH_CAPABILITY_APPEND_TO)) {
- vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);
- return;
- }
- path_append_path(dst, src);
-}
-
-void vegaAppendPathData(VGPath dstPath,
- VGint numSegments,
- const VGubyte * pathSegments,
- const void * pathData)
-{
- struct vg_context *ctx = vg_current_context();
- struct path *p = 0;
- VGint i;
-
- if (dstPath == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
- if (!pathSegments) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
- if (numSegments <= 0) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
- for (i = 0; i < numSegments; ++i) {
- if (pathSegments[i] > VG_LCWARC_TO_REL) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
- }
-
- p = handle_to_path(dstPath);
-
- if (!p || !is_aligned_to(p, path_datatype_size(p))) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- if (!(path_capabilities(p)&VG_PATH_CAPABILITY_APPEND_TO)) {
- vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);
- return;
- }
-
- path_append_data(p, numSegments, pathSegments, pathData);
-}
-
-void vegaModifyPathCoords(VGPath dstPath,
- VGint startIndex,
- VGint numSegments,
- const void * pathData)
-{
- struct vg_context *ctx = vg_current_context();
- struct path *p = 0;
-
- if (dstPath == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
- if (startIndex < 0 || numSegments <= 0) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- p = handle_to_path(dstPath);
-
- if (!pathData || !is_aligned_to(pathData, path_datatype_size(p))) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- if (startIndex + numSegments > path_num_segments(p)) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
- if (!(path_capabilities(p)&VG_PATH_CAPABILITY_MODIFY)) {
- vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);
- return;
- }
- path_modify_coords(p, startIndex, numSegments, pathData);
-}
-
-void vegaTransformPath(VGPath dstPath, VGPath srcPath)
-{
- struct vg_context *ctx = vg_current_context();
- struct path *src = 0, *dst = 0;
-
- if (dstPath == VG_INVALID_HANDLE || srcPath == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
- src = handle_to_path(srcPath);
- dst = handle_to_path(dstPath);
-
- if (!(path_capabilities(src) & VG_PATH_CAPABILITY_TRANSFORM_FROM) ||
- !(path_capabilities(dst) & VG_PATH_CAPABILITY_TRANSFORM_TO)) {
- vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);
- return;
- }
- path_transform(dst, src);
-}
-
-VGboolean vegaInterpolatePath(VGPath dstPath,
- VGPath startPath,
- VGPath endPath,
- VGfloat amount)
-{
- struct vg_context *ctx = vg_current_context();
- struct path *start = 0, *dst = 0, *end = 0;
-
- if (dstPath == VG_INVALID_HANDLE ||
- startPath == VG_INVALID_HANDLE ||
- endPath == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return VG_FALSE;
- }
- dst = handle_to_path(dstPath);
- start = handle_to_path(startPath);
- end = handle_to_path(endPath);
-
- if (!(path_capabilities(dst) & VG_PATH_CAPABILITY_INTERPOLATE_TO) ||
- !(path_capabilities(start) & VG_PATH_CAPABILITY_INTERPOLATE_FROM) ||
- !(path_capabilities(end) & VG_PATH_CAPABILITY_INTERPOLATE_FROM)) {
- vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);
- return VG_FALSE;
- }
-
- return path_interpolate(dst,
- start, end, amount);
-}
-
-VGfloat vegaPathLength(VGPath path,
- VGint startSegment,
- VGint numSegments)
-{
- struct vg_context *ctx = vg_current_context();
- struct path *p = 0;
-
- if (path == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return -1;
- }
- if (startSegment < 0) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return -1;
- }
- if (numSegments <= 0) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return -1;
- }
- p = handle_to_path(path);
-
- if (!(path_capabilities(p) & VG_PATH_CAPABILITY_PATH_LENGTH)) {
- vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);
- return -1;
- }
- if (startSegment + numSegments > path_num_segments(p)) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return -1;
- }
-
- return path_length(p, startSegment, numSegments);
-}
-
-void vegaPointAlongPath(VGPath path,
- VGint startSegment,
- VGint numSegments,
- VGfloat distance,
- VGfloat * x, VGfloat * y,
- VGfloat * tangentX,
- VGfloat * tangentY)
-{
- struct vg_context *ctx = vg_current_context();
- struct path *p = 0;
- VGbitfield caps;
-
- if (path == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
- if (startSegment < 0) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
- if (numSegments <= 0) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- if (!is_aligned(x) || !is_aligned(y) ||
- !is_aligned(tangentX) || !is_aligned(tangentY)) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- p = handle_to_path(path);
-
- caps = path_capabilities(p);
- if (!(caps & VG_PATH_CAPABILITY_POINT_ALONG_PATH) ||
- !(caps & VG_PATH_CAPABILITY_TANGENT_ALONG_PATH)) {
- vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);
- return;
- }
-
- if (startSegment + numSegments > path_num_segments(p)) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- {
- VGfloat point[2], normal[2];
- path_point(p, startSegment, numSegments, distance,
- point, normal);
- if (x)
- *x = point[0];
- if (y)
- *y = point[1];
- if (tangentX)
- *tangentX = -normal[1];
- if (tangentY)
- *tangentY = normal[0];
- }
-}
-
-void vegaPathBounds(VGPath path,
- VGfloat * minX,
- VGfloat * minY,
- VGfloat * width,
- VGfloat * height)
-{
- struct vg_context *ctx = vg_current_context();
- struct path *p = 0;
- VGbitfield caps;
-
- if (path == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
-
- if (!minX || !minY || !width || !height) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- if (!is_aligned(minX) || !is_aligned(minY) ||
- !is_aligned(width) || !is_aligned(height)) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- p = handle_to_path(path);
-
- caps = path_capabilities(p);
- if (!(caps & VG_PATH_CAPABILITY_PATH_BOUNDS)) {
- vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);
- return;
- }
-
- path_bounding_rect(p, minX, minY, width, height);
-}
-
-void vegaPathTransformedBounds(VGPath path,
- VGfloat * minX,
- VGfloat * minY,
- VGfloat * width,
- VGfloat * height)
-{
- struct vg_context *ctx = vg_current_context();
- struct path *p = 0;
- VGbitfield caps;
-
- if (path == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
-
- if (!minX || !minY || !width || !height) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- if (!is_aligned(minX) || !is_aligned(minY) ||
- !is_aligned(width) || !is_aligned(height)) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- p = handle_to_path(path);
-
- caps = path_capabilities(p);
- if (!(caps & VG_PATH_CAPABILITY_PATH_TRANSFORMED_BOUNDS)) {
- vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);
- return;
- }
-
-#if 0
- /* faster, but seems to have precision problems... */
- path_bounding_rect(p, minX, minY, width, height);
- if (*width > 0 && *height > 0) {
- VGfloat pts[] = {*minX, *minY,
- *minX + *width, *minY,
- *minX + *width, *minY + *height,
- *minX, *minY + *height};
- struct matrix *matrix = &ctx->state.vg.path_user_to_surface_matrix;
- VGfloat maxX, maxY;
- matrix_map_point(matrix, pts[0], pts[1], pts + 0, pts + 1);
- matrix_map_point(matrix, pts[2], pts[3], pts + 2, pts + 3);
- matrix_map_point(matrix, pts[4], pts[5], pts + 4, pts + 5);
- matrix_map_point(matrix, pts[6], pts[7], pts + 6, pts + 7);
- *minX = MIN2(pts[0], MIN2(pts[2], MIN2(pts[4], pts[6])));
- *minY = MIN2(pts[1], MIN2(pts[3], MIN2(pts[5], pts[7])));
- maxX = MAX2(pts[0], MAX2(pts[2], MAX2(pts[4], pts[6])));
- maxY = MAX2(pts[1], MAX2(pts[3], MAX2(pts[5], pts[7])));
- *width = maxX - *minX;
- *height = maxY - *minY;
- }
-#else
- {
- struct path *dst = path_create(VG_PATH_DATATYPE_F, 1.0, 0,
- 0, 0, VG_PATH_CAPABILITY_ALL);
- path_transform(dst, p);
- path_bounding_rect(dst, minX, minY, width, height);
- path_destroy(dst);
- }
-#endif
-}
-
-
-void vegaDrawPath(VGPath path, VGbitfield paintModes)
-{
- struct vg_context *ctx = vg_current_context();
- struct path *p = handle_to_path(path);
-
- if (path == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
-
- if (!(paintModes & (VG_STROKE_PATH | VG_FILL_PATH))) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- if (path_is_empty(p))
- return;
- path_render(p, paintModes,
- &ctx->state.vg.path_user_to_surface_matrix);
-}
-
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#include "VG/openvg.h"
-
-#include "vg_context.h"
-#include "text.h"
-#include "api.h"
-#include "handle.h"
-
-#include "util/u_memory.h"
-
-#ifdef OPENVG_VERSION_1_1
-
-VGFont vegaCreateFont(VGint glyphCapacityHint)
-{
- struct vg_context *ctx = vg_current_context();
-
- if (glyphCapacityHint < 0) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return VG_INVALID_HANDLE;
- }
-
- return font_to_handle(font_create(glyphCapacityHint));
-}
-
-void vegaDestroyFont(VGFont f)
-{
- struct vg_font *font = handle_to_font(f);
- struct vg_context *ctx = vg_current_context();
-
- if (f == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
- if (!vg_object_is_valid(f, VG_OBJECT_FONT)) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
-
- font_destroy(font);
-}
-
-void vegaSetGlyphToPath(VGFont font,
- VGuint glyphIndex,
- VGPath path,
- VGboolean isHinted,
- const VGfloat glyphOrigin[2],
- const VGfloat escapement[2])
-{
- struct vg_context *ctx = vg_current_context();
- struct path *pathObj;
- struct vg_font *f;
-
- if (font == VG_INVALID_HANDLE ||
- !vg_context_is_object_valid(ctx, VG_OBJECT_FONT, font)) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
- if (!glyphOrigin || !escapement ||
- !is_aligned(glyphOrigin) || !is_aligned(escapement)) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
- if (path != VG_INVALID_HANDLE &&
- !vg_context_is_object_valid(ctx, VG_OBJECT_PATH, path)) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
-
- pathObj = handle_to_path(path);
- f = handle_to_font(font);
-
- font_set_glyph_to_path(f, glyphIndex, pathObj,
- isHinted, glyphOrigin, escapement);
-}
-
-void vegaSetGlyphToImage(VGFont font,
- VGuint glyphIndex,
- VGImage image,
- const VGfloat glyphOrigin[2],
- const VGfloat escapement[2])
-{
- struct vg_context *ctx = vg_current_context();
- struct vg_image *img_obj;
- struct vg_font *f;
-
- if (font == VG_INVALID_HANDLE ||
- !vg_context_is_object_valid(ctx, VG_OBJECT_FONT, font)) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
- if (!glyphOrigin || !escapement ||
- !is_aligned(glyphOrigin) || !is_aligned(escapement)) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
- if (image != VG_INVALID_HANDLE &&
- !vg_context_is_object_valid(ctx, VG_OBJECT_IMAGE, image)) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
-
- img_obj = handle_to_image(image);
- f = handle_to_font(font);
-
- font_set_glyph_to_image(f, glyphIndex, img_obj, glyphOrigin, escapement);
-}
-
-void vegaClearGlyph(VGFont font,
- VGuint glyphIndex)
-{
- struct vg_context *ctx = vg_current_context();
- struct vg_font *f;
-
- if (font == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
-
- f = handle_to_font(font);
-
- font_clear_glyph(f, glyphIndex);
-}
-
-void vegaDrawGlyph(VGFont font,
- VGuint glyphIndex,
- VGbitfield paintModes,
- VGboolean allowAutoHinting)
-{
- struct vg_context *ctx = vg_current_context();
- struct vg_font *f;
-
- if (font == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
- if (paintModes & (~(VG_STROKE_PATH|VG_FILL_PATH))) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
- f = handle_to_font(font);
-
- font_draw_glyph(f, glyphIndex, paintModes, allowAutoHinting);
-}
-
-void vegaDrawGlyphs(VGFont font,
- VGint glyphCount,
- const VGuint *glyphIndices,
- const VGfloat *adjustments_x,
- const VGfloat *adjustments_y,
- VGbitfield paintModes,
- VGboolean allowAutoHinting)
-{
- struct vg_context *ctx = vg_current_context();
- struct vg_font *f;
-
- if (font == VG_INVALID_HANDLE) {
- vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
- return;
- }
- if (glyphCount <= 0) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
- if (!glyphIndices || !is_aligned(glyphIndices)) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
- if ((adjustments_x && !is_aligned(adjustments_x)) ||
- (adjustments_y && !is_aligned(adjustments_y))) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
- if (paintModes & (~(VG_STROKE_PATH|VG_FILL_PATH))) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- f = handle_to_font(font);
-
- font_draw_glyphs(f, glyphCount, glyphIndices,
- adjustments_x, adjustments_y, paintModes, allowAutoHinting);
-}
-
-#endif /* OPENVG_VERSION_1_1 */
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#include "VG/openvg.h"
-
-#include "vg_context.h"
-
-#include "matrix.h"
-#include "api.h"
-
-void vegaLoadIdentity(void)
-{
- struct vg_context *ctx = vg_current_context();
- struct matrix *mat = vg_state_matrix(&ctx->state.vg);
- matrix_load_identity(mat);
-}
-
-void vegaLoadMatrix(const VGfloat * m)
-{
- struct vg_context *ctx = vg_current_context();
- struct matrix *mat;
-
- if (!ctx)
- return;
-
- if (!m || !is_aligned(m)) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- mat = vg_state_matrix(&ctx->state.vg);
- matrix_init(mat, m);
- if (!matrix_is_affine(mat)) {
- if (ctx->state.vg.matrix_mode != VG_MATRIX_IMAGE_USER_TO_SURFACE) {
- matrix_make_affine(mat);
- }
- }
-}
-
-void vegaGetMatrix(VGfloat * m)
-{
- struct vg_context *ctx = vg_current_context();
- struct matrix *mat;
-
- if (!ctx)
- return;
-
- if (!m || !is_aligned(m)) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- mat = vg_state_matrix(&ctx->state.vg);
- memcpy(m, mat->m, sizeof(VGfloat)*9);
-}
-
-void vegaMultMatrix(const VGfloat * m)
-{
- struct vg_context *ctx = vg_current_context();
- struct matrix *dst, src;
-
- if (!ctx)
- return;
-
- if (!m || !is_aligned(m)) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
- matrix_init(&src, m);
- dst = vg_state_matrix(&ctx->state.vg);
- if (!matrix_is_affine(&src)) {
- if (ctx->state.vg.matrix_mode != VG_MATRIX_IMAGE_USER_TO_SURFACE) {
- matrix_make_affine(&src);
- }
- }
- matrix_mult(dst, &src);
-
-}
-
-void vegaTranslate(VGfloat tx, VGfloat ty)
-{
- struct vg_context *ctx = vg_current_context();
- struct matrix *dst = vg_state_matrix(&ctx->state.vg);
- matrix_translate(dst, tx, ty);
-}
-
-void vegaScale(VGfloat sx, VGfloat sy)
-{
- struct vg_context *ctx = vg_current_context();
- struct matrix *dst = vg_state_matrix(&ctx->state.vg);
- matrix_scale(dst, sx, sy);
-}
-
-void vegaShear(VGfloat shx, VGfloat shy)
-{
- struct vg_context *ctx = vg_current_context();
- struct matrix *dst = vg_state_matrix(&ctx->state.vg);
- matrix_shear(dst, shx, shy);
-}
-
-void vegaRotate(VGfloat angle)
-{
- struct vg_context *ctx = vg_current_context();
- struct matrix *dst = vg_state_matrix(&ctx->state.vg);
- matrix_rotate(dst, angle);
-}
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#include "arc.h"
-
-#include "matrix.h"
-#include "bezier.h"
-#include "polygon.h"
-#include "stroker.h"
-#include "path.h"
-
-#include "util/u_debug.h"
-#include "util/u_math.h"
-
-#ifndef M_PI
-#define M_PI 3.14159265358979323846
-#endif
-
-#define DEBUG_ARCS 0
-
-static const VGfloat two_pi = M_PI * 2;
-
-
-static const double coeffs3Low[2][4][4] = {
- {
- { 3.85268, -21.229, -0.330434, 0.0127842 },
- { -1.61486, 0.706564, 0.225945, 0.263682 },
- { -0.910164, 0.388383, 0.00551445, 0.00671814 },
- { -0.630184, 0.192402, 0.0098871, 0.0102527 }
- },
- {
- { -0.162211, 9.94329, 0.13723, 0.0124084 },
- { -0.253135, 0.00187735, 0.0230286, 0.01264 },
- { -0.0695069, -0.0437594, 0.0120636, 0.0163087 },
- { -0.0328856, -0.00926032, -0.00173573, 0.00527385 }
- }
-};
-
-/* coefficients for error estimation
- while using cubic Bézier curves for approximation
- 1/4 <= b/a <= 1 */
-static const double coeffs3High[2][4][4] = {
- {
- { 0.0899116, -19.2349, -4.11711, 0.183362 },
- { 0.138148, -1.45804, 1.32044, 1.38474 },
- { 0.230903, -0.450262, 0.219963, 0.414038 },
- { 0.0590565, -0.101062, 0.0430592, 0.0204699 }
- },
- {
- { 0.0164649, 9.89394, 0.0919496, 0.00760802 },
- { 0.0191603, -0.0322058, 0.0134667, -0.0825018 },
- { 0.0156192, -0.017535, 0.00326508, -0.228157 },
- { -0.0236752, 0.0405821, -0.0173086, 0.176187 }
- }
-};
-
-/* safety factor to convert the "best" error approximation
- into a "max bound" error */
-static const double safety3[] = {
- 0.001, 4.98, 0.207, 0.0067
-};
-
-/* The code below is from the OpenVG 1.1 Spec
- * Section 18.4 */
-
-/* Given: Points (x0, y0) and (x1, y1)
- * Return: TRUE if a solution exists, FALSE otherwise
- * Circle centers are written to (cx0, cy0) and (cx1, cy1)
- */
-static VGboolean
-find_unit_circles(double x0, double y0, double x1, double y1,
- double *cx0, double *cy0,
- double *cx1, double *cy1)
-{
- /* Compute differences and averages */
- double dx = x0 - x1;
- double dy = y0 - y1;
- double xm = (x0 + x1)/2;
- double ym = (y0 + y1)/2;
- double dsq, disc, s, sdx, sdy;
-
- /* Solve for intersecting unit circles */
- dsq = dx*dx + dy*dy;
- if (dsq == 0.0) return VG_FALSE; /* Points are coincident */
- disc = 1.0/dsq - 1.0/4.0;
-
- /* the precision we care about here is around float so if we're
- * around the float defined zero then make it official to avoid
- * precision problems later on */
- if (floatIsZero(disc))
- disc = 0.0;
-
- if (disc < 0.0) return VG_FALSE; /* Points are too far apart */
- s = sqrt(disc);
- sdx = s*dx;
- sdy = s*dy;
- *cx0 = xm + sdy;
- *cy0 = ym - sdx;
- *cx1 = xm - sdy;
- *cy1 = ym + sdx;
- return VG_TRUE;
-}
-
-
-/* Given: Ellipse parameters rh, rv, rot (in degrees),
- * endpoints (x0, y0) and (x1, y1)
- * Return: TRUE if a solution exists, FALSE otherwise
- * Ellipse centers are written to (cx0, cy0) and (cx1, cy1)
- */
-static VGboolean
-find_ellipses(double rh, double rv, double rot,
- double x0, double y0, double x1, double y1,
- double *cx0, double *cy0, double *cx1, double *cy1)
-{
- double COS, SIN, x0p, y0p, x1p, y1p, pcx0, pcy0, pcx1, pcy1;
- /* Convert rotation angle from degrees to radians */
- rot *= M_PI/180.0;
- /* Pre-compute rotation matrix entries */
- COS = cos(rot); SIN = sin(rot);
- /* Transform (x0, y0) and (x1, y1) into unit space */
- /* using (inverse) rotate, followed by (inverse) scale */
- x0p = (x0*COS + y0*SIN)/rh;
- y0p = (-x0*SIN + y0*COS)/rv;
- x1p = (x1*COS + y1*SIN)/rh;
- y1p = (-x1*SIN + y1*COS)/rv;
- if (!find_unit_circles(x0p, y0p, x1p, y1p,
- &pcx0, &pcy0, &pcx1, &pcy1)) {
- return VG_FALSE;
- }
- /* Transform back to original coordinate space */
- /* using (forward) scale followed by (forward) rotate */
- pcx0 *= rh; pcy0 *= rv;
- pcx1 *= rh; pcy1 *= rv;
- *cx0 = pcx0*COS - pcy0*SIN;
- *cy0 = pcx0*SIN + pcy0*COS;
- *cx1 = pcx1*COS - pcy1*SIN;
- *cy1 = pcx1*SIN + pcy1*COS;
- return VG_TRUE;
-}
-
-static INLINE VGboolean
-try_to_fix_radii(struct arc *arc)
-{
- double COS, SIN, rot, x0p, y0p, x1p, y1p;
- double dx, dy, dsq, scale;
-
- /* Convert rotation angle from degrees to radians */
- rot = DEGREES_TO_RADIANS(arc->theta);
-
- /* Pre-compute rotation matrix entries */
- COS = cos(rot); SIN = sin(rot);
-
- /* Transform (x0, y0) and (x1, y1) into unit space */
- /* using (inverse) rotate, followed by (inverse) scale */
- x0p = (arc->x1*COS + arc->y1*SIN)/arc->a;
- y0p = (-arc->x1*SIN + arc->y1*COS)/arc->b;
- x1p = (arc->x2*COS + arc->y2*SIN)/arc->a;
- y1p = (-arc->x2*SIN + arc->y2*COS)/arc->b;
- /* Compute differences and averages */
- dx = x0p - x1p;
- dy = y0p - y1p;
-
- dsq = dx*dx + dy*dy;
-#if 0
- if (dsq <= 0.001) {
- debug_printf("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaaaaa\n");
- }
-#endif
- scale = 1/(2/sqrt(dsq));
- arc->a *= scale;
- arc->b *= scale;
- return VG_TRUE;
-}
-
-static INLINE double vector_normalize(double *v)
-{
- double sq = v[0] * v[0] + v[1] * v[1];
- return sqrt(sq);
-}
-static INLINE double vector_orientation(double *v)
-{
- double norm = vector_normalize(v);
- double cosa = v[0] / norm;
- double sina = v[1] / norm;
- return (sina>=0 ? acos(cosa) : 2*M_PI - acos(cosa));
-}
-static INLINE double vector_dot(double *v0,
- double *v1)
-{
- return v0[0] * v1[0] + v0[1] * v1[1];
-}
-
-static INLINE double vector_angles(double *v0,
- double *v1)
-{
- double dot = vector_dot(v0, v1);
- double norm0 = vector_normalize(v0);
- double norm1 = vector_normalize(v1);
-
- return acos(dot / (norm0 * norm1));
-}
-
-static VGboolean find_angles(struct arc *arc)
-{
- double vec0[2], vec1[2];
- double lambda1, lambda2;
- double angle;
- struct matrix matrix;
-
- if (floatIsZero(arc->a) || floatIsZero(arc->b)) {
- return VG_FALSE;
- }
- /* map the points to an identity circle */
- matrix_load_identity(&matrix);
- matrix_scale(&matrix, 1.f, arc->a/arc->b);
- matrix_rotate(&matrix, -arc->theta);
- matrix_map_point(&matrix,
- arc->x1, arc->y1,
- &arc->x1, &arc->y1);
- matrix_map_point(&matrix,
- arc->x2, arc->y2,
- &arc->x2, &arc->y2);
- matrix_map_point(&matrix,
- arc->cx, arc->cy,
- &arc->cx, &arc->cy);
-
-#if DEBUG_ARCS
- debug_printf("Matrix 3 [%f, %f, %f| %f, %f, %f| %f, %f, %f]\n",
- matrix.m[0], matrix.m[1], matrix.m[2],
- matrix.m[3], matrix.m[4], matrix.m[5],
- matrix.m[6], matrix.m[7], matrix.m[8]);
- debug_printf("Endpoints [%f, %f], [%f, %f]\n",
- arc->x1, arc->y1, arc->x2, arc->y2);
-#endif
-
- vec0[0] = arc->x1 - arc->cx;
- vec0[1] = arc->y1 - arc->cy;
- vec1[0] = arc->x2 - arc->cx;
- vec1[1] = arc->y2 - arc->cy;
-
-#if DEBUG_ARCS
- debug_printf("Vec is [%f, %f], [%f, %f], [%f, %f]\n",
- vec0[0], vec0[1], vec1[0], vec1[1], arc->cx, arc->cy);
-#endif
-
- lambda1 = vector_orientation(vec0);
-
- if (isnan(lambda1))
- lambda1 = 0.f;
-
- if (arc->type == VG_SCWARC_TO ||
- arc->type == VG_SCCWARC_TO)
- angle = vector_angles(vec0, vec1);
- else if (arc->type == VG_LCWARC_TO ||
- arc->type == VG_LCCWARC_TO) {
- angle = 2*M_PI - vector_angles(vec0, vec1);
- } else
- abort();
-
- if (isnan(angle))
- angle = M_PI;
-
-
- if (arc->type == VG_SCWARC_TO ||
- arc->type == VG_LCWARC_TO)
- lambda2 = lambda1 - angle;
- else
- lambda2 = lambda1 + angle;
-
-#if DEBUG_ARCS
- debug_printf("Angle is %f and (%f, %f)\n", angle, lambda1, lambda2);
-#endif
-
-#if 0
- arc->eta1 = atan2(sin(lambda1) / arc->b,
- cos(lambda1) / arc->a);
- arc->eta2 = atan2(sin(lambda2) / arc->b,
- cos(lambda2) / arc->a);
-
- /* make sure we have eta1 <= eta2 <= eta1 + 2 PI */
- arc->eta2 -= two_pi * floor((arc->eta2 - arc->eta1) / two_pi);
-
- /* the preceding correction fails if we have exactly et2 - eta1 = 2 PI
- it reduces the interval to zero length */
- if ((lambda2 - lambda1 > M_PI) && (arc->eta2 - arc->eta1 < M_PI)) {
- arc->eta2 += 2 * M_PI;
- }
-#else
- arc->eta1 = lambda1;
- arc->eta2 = lambda2;
-#endif
-
- return VG_TRUE;
-}
-
-#if DEBUG_ARCS
-static void check_endpoints(struct arc *arc)
-{
- double x1, y1, x2, y2;
-
- double a_cos_eta1 = arc->a * cos(arc->eta1);
- double b_sin_eta1 = arc->b * sin(arc->eta1);
- x1 = arc->cx + a_cos_eta1 * arc->cos_theta -
- b_sin_eta1 * arc->sin_theta;
- y1 = arc->cy + a_cos_eta1 * arc->sin_theta +
- b_sin_eta1 * arc->cos_theta;
-
- double a_cos_eta2 = arc->a * cos(arc->eta2);
- double b_sin_eta2 = arc->b * sin(arc->eta2);
- x2 = arc->cx + a_cos_eta2 * arc->cos_theta -
- b_sin_eta2 * arc->sin_theta;
- y2 = arc->cy + a_cos_eta2 * arc->sin_theta +
- b_sin_eta2 * arc->cos_theta;
-
- debug_printf("Computed (%f, %f), (%f, %f)\n",
- x1, y1, x2, y2);
- debug_printf("Real (%f, %f), (%f, %f)\n",
- arc->x1, arc->y1,
- arc->x2, arc->y2);
-}
-#endif
-
-void arc_init(struct arc *arc,
- VGPathSegment type,
- VGfloat x1, VGfloat y1,
- VGfloat x2, VGfloat y2,
- VGfloat rh, VGfloat rv,
- VGfloat rot)
-{
- assert(type == VG_SCCWARC_TO ||
- type == VG_SCWARC_TO ||
- type == VG_LCCWARC_TO ||
- type == VG_LCWARC_TO);
- arc->type = type;
- arc->x1 = x1;
- arc->y1 = y1;
- arc->x2 = x2;
- arc->y2 = y2;
- arc->a = rh;
- arc->b = rv;
- arc->theta = rot;
- arc->cos_theta = cos(arc->theta);
- arc->sin_theta = sin(arc->theta);
- {
- double cx0, cy0, cx1, cy1;
- double cx, cy;
- arc->is_valid = find_ellipses(rh, rv, rot, x1, y1, x2, y2,
- &cx0, &cy0, &cx1, &cy1);
-
- if (!arc->is_valid && try_to_fix_radii(arc)) {
- rh = arc->a;
- rv = arc->b;
- arc->is_valid =
- find_ellipses(rh, rv, rot, x1, y1, x2, y2,
- &cx0, &cy0, &cx1, &cy1);
- }
-
- if (type == VG_SCWARC_TO ||
- type == VG_LCCWARC_TO) {
- cx = cx1;
- cy = cy1;
- } else {
- cx = cx0;
- cy = cy0;
- }
-#if DEBUG_ARCS
- debug_printf("Centers are : (%f, %f) , (%f, %f). Real (%f, %f)\n",
- cx0, cy0, cx1, cy1, cx, cy);
-#endif
- arc->cx = cx;
- arc->cy = cy;
- if (arc->is_valid) {
- arc->is_valid = find_angles(arc);
-#if DEBUG_ARCS
- check_endpoints(arc);
-#endif
- /* remap a few points. find_angles requires
- * rot in angles, the rest of the code
- * will need them in radians. and find_angles
- * modifies the center to match an identity
- * circle so lets reset it */
- arc->theta = DEGREES_TO_RADIANS(rot);
- arc->cos_theta = cos(arc->theta);
- arc->sin_theta = sin(arc->theta);
- arc->cx = cx;
- arc->cy = cy;
- }
- }
-}
-
-static INLINE double rational_function(double x, const double *c)
-{
- return (x * (x * c[0] + c[1]) + c[2]) / (x + c[3]);
-}
-
-static double estimate_error(struct arc *arc,
- double etaA, double etaB)
-{
- double eta = 0.5 * (etaA + etaB);
-
- double x = arc->b / arc->a;
- double dEta = etaB - etaA;
- double cos2 = cos(2 * eta);
- double cos4 = cos(4 * eta);
- double cos6 = cos(6 * eta);
- double c0, c1;
-
- /* select the right coeficients set according to degree and b/a */
- const double (*coeffs)[4][4];
- const double *safety;
- coeffs = (x < 0.25) ? coeffs3Low : coeffs3High;
- safety = safety3;
-
- c0 = rational_function(x, coeffs[0][0])
- + cos2 * rational_function(x, coeffs[0][1])
- + cos4 * rational_function(x, coeffs[0][2])
- + cos6 * rational_function(x, coeffs[0][3]);
-
- c1 = rational_function(x, coeffs[1][0])
- + cos2 * rational_function(x, coeffs[1][1])
- + cos4 * rational_function(x, coeffs[1][2])
- + cos6 * rational_function(x, coeffs[1][3]);
-
- return rational_function(x, safety) * arc->a * exp(c0 + c1 * dEta);
-}
-
-struct arc_cb {
- void (*move)(struct arc_cb *cb, VGfloat x, VGfloat y);
- void (*point)(struct arc_cb *cb, VGfloat x, VGfloat y);
- void (*bezier)(struct arc_cb *cb, struct bezier *bezier);
-
- void *user_data;
-};
-
-static void cb_null_move(struct arc_cb *cb, VGfloat x, VGfloat y)
-{
-}
-
-static void polygon_point(struct arc_cb *cb, VGfloat x, VGfloat y)
-{
- struct polygon *poly = (struct polygon*)cb->user_data;
- polygon_vertex_append(poly, x, y);
-}
-
-static void polygon_bezier(struct arc_cb *cb, struct bezier *bezier)
-{
- struct polygon *poly = (struct polygon*)cb->user_data;
- bezier_add_to_polygon(bezier, poly);
-}
-
-static void stroke_point(struct arc_cb *cb, VGfloat x, VGfloat y)
-{
- struct stroker *stroker = (struct stroker*)cb->user_data;
- stroker_line_to(stroker, x, y);
-}
-
-static void stroke_curve(struct arc_cb *cb, struct bezier *bezier)
-{
- struct stroker *stroker = (struct stroker*)cb->user_data;
- stroker_curve_to(stroker,
- bezier->x2, bezier->y2,
- bezier->x3, bezier->y3,
- bezier->x4, bezier->y4);
-}
-
-static void stroke_emit_point(struct arc_cb *cb, VGfloat x, VGfloat y)
-{
- struct stroker *stroker = (struct stroker*)cb->user_data;
- stroker_emit_line_to(stroker, x, y);
-}
-
-static void stroke_emit_curve(struct arc_cb *cb, struct bezier *bezier)
-{
- struct stroker *stroker = (struct stroker*)cb->user_data;
- stroker_emit_curve_to(stroker,
- bezier->x2, bezier->y2,
- bezier->x3, bezier->y3,
- bezier->x4, bezier->y4);
-}
-
-static void arc_path_move(struct arc_cb *cb, VGfloat x, VGfloat y)
-{
- struct path *path = (struct path*)cb->user_data;
- path_move_to(path, x, y);
-}
-
-static void arc_path_point(struct arc_cb *cb, VGfloat x, VGfloat y)
-{
- struct path *path = (struct path*)cb->user_data;
- path_line_to(path, x, y);
-}
-
-static void arc_path_bezier(struct arc_cb *cb, struct bezier *bezier)
-{
- struct path *path = (struct path*)cb->user_data;
- path_cubic_to(path,
- bezier->x2, bezier->y2,
- bezier->x3, bezier->y3,
- bezier->x4, bezier->y4);
-}
-
-static INLINE int num_beziers_needed(struct arc *arc)
-{
- double threshold = 0.05;
- VGboolean found = VG_FALSE;
- int n = 1;
- double min_eta, max_eta;
-
- min_eta = MIN2(arc->eta1, arc->eta2);
- max_eta = MAX2(arc->eta1, arc->eta2);
-
- while ((! found) && (n < 1024)) {
- double d_eta = (max_eta - min_eta) / n;
- if (d_eta <= 0.5 * M_PI) {
- double eta_b = min_eta;
- int i;
- found = VG_TRUE;
- for (i = 0; found && (i < n); ++i) {
- double etaA = eta_b;
- eta_b += d_eta;
- found = (estimate_error(arc, etaA, eta_b) <= threshold);
- }
- }
- n = n << 1;
- }
-
- return n;
-}
-
-static void arc_to_beziers(struct arc *arc,
- struct arc_cb cb,
- struct matrix *matrix)
-{
- int i;
- int n = 1;
- double d_eta, eta_b, cos_eta_b,
- sin_eta_b, a_cos_eta_b, b_sin_eta_b, a_sin_eta_b,
- b_cos_eta_b, x_b, y_b, x_b_dot, y_b_dot, lx, ly;
- double t, alpha;
-
- { /* always move to the start of the arc */
- VGfloat x = arc->x1;
- VGfloat y = arc->y1;
- matrix_map_point(matrix, x, y, &x, &y);
- cb.move(&cb, x, y);
- }
-
- if (!arc->is_valid) {
- VGfloat x = arc->x2;
- VGfloat y = arc->y2;
- matrix_map_point(matrix, x, y, &x, &y);
- cb.point(&cb, x, y);
- return;
- }
-
- /* find the number of Bézier curves needed */
- n = num_beziers_needed(arc);
-
- d_eta = (arc->eta2 - arc->eta1) / n;
- eta_b = arc->eta1;
-
- cos_eta_b = cos(eta_b);
- sin_eta_b = sin(eta_b);
- a_cos_eta_b = arc->a * cos_eta_b;
- b_sin_eta_b = arc->b * sin_eta_b;
- a_sin_eta_b = arc->a * sin_eta_b;
- b_cos_eta_b = arc->b * cos_eta_b;
- x_b = arc->cx + a_cos_eta_b * arc->cos_theta -
- b_sin_eta_b * arc->sin_theta;
- y_b = arc->cy + a_cos_eta_b * arc->sin_theta +
- b_sin_eta_b * arc->cos_theta;
- x_b_dot = -a_sin_eta_b * arc->cos_theta -
- b_cos_eta_b * arc->sin_theta;
- y_b_dot = -a_sin_eta_b * arc->sin_theta +
- b_cos_eta_b * arc->cos_theta;
-
- {
- VGfloat x = x_b, y = y_b;
- matrix_map_point(matrix, x, y, &x, &y);
- cb.point(&cb, x, y);
- }
- lx = x_b;
- ly = y_b;
-
- t = tan(0.5 * d_eta);
- alpha = sin(d_eta) * (sqrt(4 + 3 * t * t) - 1) / 3;
-
- for (i = 0; i < n; ++i) {
- struct bezier bezier;
- double xA = x_b;
- double yA = y_b;
- double xADot = x_b_dot;
- double yADot = y_b_dot;
-
- eta_b += d_eta;
- cos_eta_b = cos(eta_b);
- sin_eta_b = sin(eta_b);
- a_cos_eta_b = arc->a * cos_eta_b;
- b_sin_eta_b = arc->b * sin_eta_b;
- a_sin_eta_b = arc->a * sin_eta_b;
- b_cos_eta_b = arc->b * cos_eta_b;
- x_b = arc->cx + a_cos_eta_b * arc->cos_theta -
- b_sin_eta_b * arc->sin_theta;
- y_b = arc->cy + a_cos_eta_b * arc->sin_theta +
- b_sin_eta_b * arc->cos_theta;
- x_b_dot = -a_sin_eta_b * arc->cos_theta -
- b_cos_eta_b * arc->sin_theta;
- y_b_dot = -a_sin_eta_b * arc->sin_theta +
- b_cos_eta_b * arc->cos_theta;
-
- bezier_init(&bezier,
- lx, ly,
- (float) (xA + alpha * xADot), (float) (yA + alpha * yADot),
- (float) (x_b - alpha * x_b_dot), (float) (y_b - alpha * y_b_dot),
- (float) x_b, (float) y_b);
-#if 0
- debug_printf("%d) Bezier (%f, %f), (%f, %f), (%f, %f), (%f, %f)\n",
- i,
- bezier.x1, bezier.y1,
- bezier.x2, bezier.y2,
- bezier.x3, bezier.y3,
- bezier.x4, bezier.y4);
-#endif
- bezier_transform(&bezier, matrix);
- cb.bezier(&cb, &bezier);
- lx = x_b;
- ly = y_b;
- }
-}
-
-
-void arc_add_to_polygon(struct arc *arc,
- struct polygon *poly,
- struct matrix *matrix)
-{
- struct arc_cb cb;
-
- cb.move = cb_null_move;
- cb.point = polygon_point;
- cb.bezier = polygon_bezier;
- cb.user_data = poly;
-
- arc_to_beziers(arc, cb, matrix);
-}
-
-void arc_stroke_cb(struct arc *arc,
- struct stroker *stroke,
- struct matrix *matrix)
-{
- struct arc_cb cb;
-
- cb.move = cb_null_move;
- cb.point = stroke_point;
- cb.bezier = stroke_curve;
- cb.user_data = stroke;
-
- arc_to_beziers(arc, cb, matrix);
-}
-
-void arc_stroker_emit(struct arc *arc,
- struct stroker *stroker,
- struct matrix *matrix)
-{
- struct arc_cb cb;
-
- cb.move = cb_null_move;
- cb.point = stroke_emit_point;
- cb.bezier = stroke_emit_curve;
- cb.user_data = stroker;
-
- arc_to_beziers(arc, cb, matrix);
-}
-
-void arc_to_path(struct arc *arc,
- struct path *path,
- struct matrix *matrix)
-{
- struct arc_cb cb;
-
- cb.move = arc_path_move;
- cb.point = arc_path_point;
- cb.bezier = arc_path_bezier;
- cb.user_data = path;
-
- arc_to_beziers(arc, cb, matrix);
-}
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#ifndef ARC_H
-#define ARC_H
-
-#include "VG/openvg.h"
-
-struct polygon;
-struct matrix;
-struct stroker;
-struct path;
-
-struct arc {
- VGPathSegment type;
-
- VGfloat cx, cy;
-
- VGfloat a, b;
-
- VGfloat theta;
- VGfloat cos_theta, sin_theta;
-
- VGfloat eta1;
- VGfloat eta2;
-
- VGfloat x1, y1, x2, y2;
-
- VGboolean is_valid;
-};
-
-void arc_init(struct arc *arc,
- VGPathSegment type,
- VGfloat x1, VGfloat y1,
- VGfloat x2, VGfloat y2,
- VGfloat rh, VGfloat rv,
- VGfloat rot);
-
-void arc_add_to_polygon(struct arc *arc,
- struct polygon *poly,
- struct matrix *matrix);
-
-
-void arc_to_path(struct arc *arc,
- struct path *p,
- struct matrix *matrix);
-
-void arc_stroke_cb(struct arc *arc,
- struct stroker *stroke,
- struct matrix *matrix);
-
-void arc_stroker_emit(struct arc *arc,
- struct stroker *stroke,
- struct matrix *matrix);
-
-
-#endif
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#ifndef ASM_FILL_H
-#define ASM_FILL_H
-
-#include "tgsi/tgsi_ureg.h"
-
-typedef void (* ureg_func)( struct ureg_program *ureg,
- struct ureg_dst *out,
- struct ureg_src *in,
- struct ureg_src *sampler,
- struct ureg_dst *temp,
- struct ureg_src *constant);
-
-static INLINE void
-solid_fill( struct ureg_program *ureg,
- struct ureg_dst *out,
- struct ureg_src *in,
- struct ureg_src *sampler,
- struct ureg_dst *temp,
- struct ureg_src *constant)
-{
- ureg_MOV(ureg, *out, constant[2]);
-}
-
-/**
- * Perform frag-coord-to-paint-coord transform. The transformation is in
- * CONST[4..6].
- */
-#define PAINT_TRANSFORM \
- ureg_MOV(ureg, ureg_writemask(temp[0], TGSI_WRITEMASK_XY), in[0]); \
- ureg_MOV(ureg, \
- ureg_writemask(temp[0], TGSI_WRITEMASK_Z), \
- ureg_scalar(constant[3], TGSI_SWIZZLE_Y)); \
- ureg_DP3(ureg, temp[1], constant[4], ureg_src(temp[0])); \
- ureg_DP3(ureg, temp[2], constant[5], ureg_src(temp[0])); \
- ureg_DP3(ureg, temp[3], constant[6], ureg_src(temp[0])); \
- ureg_RCP(ureg, temp[3], ureg_src(temp[3])); \
- ureg_MUL(ureg, temp[1], ureg_src(temp[1]), ureg_src(temp[3])); \
- ureg_MUL(ureg, temp[2], ureg_src(temp[2]), ureg_src(temp[3])); \
- ureg_MOV(ureg, \
- ureg_writemask(temp[4], TGSI_WRITEMASK_X), \
- ureg_src(temp[1])); \
- ureg_MOV(ureg, \
- ureg_writemask(temp[4], TGSI_WRITEMASK_Y), \
- ureg_src(temp[2]));
-
-static INLINE void
-linear_grad( struct ureg_program *ureg,
- struct ureg_dst *out,
- struct ureg_src *in,
- struct ureg_src *sampler,
- struct ureg_dst *temp,
- struct ureg_src *constant)
-{
- PAINT_TRANSFORM
-
- /* grad = DP2((x, y), CONST[2].xy) * CONST[2].z */
- ureg_MUL(ureg, temp[0],
- ureg_scalar(constant[2], TGSI_SWIZZLE_Y),
- ureg_scalar(ureg_src(temp[4]), TGSI_SWIZZLE_Y));
- ureg_MAD(ureg, temp[1],
- ureg_scalar(constant[2], TGSI_SWIZZLE_X),
- ureg_scalar(ureg_src(temp[4]), TGSI_SWIZZLE_X),
- ureg_src(temp[0]));
- ureg_MUL(ureg, temp[2], ureg_src(temp[1]),
- ureg_scalar(constant[2], TGSI_SWIZZLE_Z));
-
- ureg_TEX(ureg, *out, TGSI_TEXTURE_1D, ureg_src(temp[2]), sampler[0]);
-}
-
-static INLINE void
-radial_grad( struct ureg_program *ureg,
- struct ureg_dst *out,
- struct ureg_src *in,
- struct ureg_src *sampler,
- struct ureg_dst *temp,
- struct ureg_src *constant)
-{
- PAINT_TRANSFORM
-
- /*
- * Calculate (sqrt(B^2 + AC) - B) / A, where
- *
- * A is CONST[2].z,
- * B is DP2((x, y), CONST[2].xy), and
- * C is DP2((x, y), (x, y)).
- */
-
- /* B and C */
- ureg_DP2(ureg, temp[0], ureg_src(temp[4]), constant[2]);
- ureg_DP2(ureg, temp[1], ureg_src(temp[4]), ureg_src(temp[4]));
-
- /* the square root */
- ureg_MUL(ureg, temp[2], ureg_src(temp[0]), ureg_src(temp[0]));
- ureg_MAD(ureg, temp[3], ureg_src(temp[1]),
- ureg_scalar(constant[2], TGSI_SWIZZLE_Z), ureg_src(temp[2]));
- ureg_RSQ(ureg, temp[3], ureg_src(temp[3]));
- ureg_RCP(ureg, temp[3], ureg_src(temp[3]));
-
- ureg_SUB(ureg, temp[3], ureg_src(temp[3]), ureg_src(temp[0]));
- ureg_RCP(ureg, temp[0], ureg_scalar(constant[2], TGSI_SWIZZLE_Z));
- ureg_MUL(ureg, temp[0], ureg_src(temp[0]), ureg_src(temp[3]));
-
- ureg_TEX(ureg, *out, TGSI_TEXTURE_1D, ureg_src(temp[0]), sampler[0]);
-}
-
-
-static INLINE void
-pattern( struct ureg_program *ureg,
- struct ureg_dst *out,
- struct ureg_src *in,
- struct ureg_src *sampler,
- struct ureg_dst *temp,
- struct ureg_src *constant)
-{
- PAINT_TRANSFORM
-
- /* (s, t) = (x / tex_width, y / tex_height) */
- ureg_RCP(ureg, temp[0],
- ureg_swizzle(constant[3],
- TGSI_SWIZZLE_Z,
- TGSI_SWIZZLE_W,
- TGSI_SWIZZLE_Z,
- TGSI_SWIZZLE_W));
- ureg_MOV(ureg, temp[1], ureg_src(temp[4]));
- ureg_MUL(ureg,
- ureg_writemask(temp[1], TGSI_WRITEMASK_X),
- ureg_src(temp[1]),
- ureg_src(temp[0]));
- ureg_MUL(ureg,
- ureg_writemask(temp[1], TGSI_WRITEMASK_Y),
- ureg_src(temp[1]),
- ureg_src(temp[0]));
-
- ureg_TEX(ureg, *out, TGSI_TEXTURE_2D, ureg_src(temp[1]), sampler[0]);
-}
-
-static INLINE void
-paint_degenerate( struct ureg_program *ureg,
- struct ureg_dst *out,
- struct ureg_src *in,
- struct ureg_src *sampler,
- struct ureg_dst *temp,
- struct ureg_src *constant)
-{
- /* CONST[3].y is 1.0f */
- ureg_MOV(ureg, temp[1], ureg_scalar(constant[3], TGSI_SWIZZLE_Y));
- ureg_TEX(ureg, *out, TGSI_TEXTURE_1D, ureg_src(temp[1]), sampler[0]);
-}
-
-static INLINE void
-image_normal( struct ureg_program *ureg,
- struct ureg_dst *out,
- struct ureg_src *in,
- struct ureg_src *sampler,
- struct ureg_dst *temp,
- struct ureg_src *constant)
-{
- /* store and pass image color in TEMP[1] */
- ureg_TEX(ureg, temp[1], TGSI_TEXTURE_2D, in[1], sampler[3]);
- ureg_MOV(ureg, *out, ureg_src(temp[1]));
-}
-
-
-static INLINE void
-image_multiply( struct ureg_program *ureg,
- struct ureg_dst *out,
- struct ureg_src *in,
- struct ureg_src *sampler,
- struct ureg_dst *temp,
- struct ureg_src *constant)
-{
- /* store and pass image color in TEMP[1] */
- ureg_TEX(ureg, temp[1], TGSI_TEXTURE_2D, in[1], sampler[3]);
- ureg_MUL(ureg, *out, ureg_src(temp[0]), ureg_src(temp[1]));
-}
-
-
-static INLINE void
-image_stencil( struct ureg_program *ureg,
- struct ureg_dst *out,
- struct ureg_src *in,
- struct ureg_src *sampler,
- struct ureg_dst *temp,
- struct ureg_src *constant)
-{
- /* store and pass image color in TEMP[1] */
- ureg_TEX(ureg, temp[1], TGSI_TEXTURE_2D, in[1], sampler[3]);
- ureg_MOV(ureg, *out, ureg_src(temp[0]));
-}
-
-static INLINE void
-color_transform( struct ureg_program *ureg,
- struct ureg_dst *out,
- struct ureg_src *in,
- struct ureg_src *sampler,
- struct ureg_dst *temp,
- struct ureg_src *constant)
-{
- /* note that TEMP[1] may already be used for image color */
-
- ureg_MAD(ureg, temp[2], ureg_src(temp[0]), constant[0], constant[1]);
- /* clamp to [0.0f, 1.0f] */
- ureg_CLAMP(ureg, temp[2],
- ureg_src(temp[2]),
- ureg_scalar(constant[3], TGSI_SWIZZLE_X),
- ureg_scalar(constant[3], TGSI_SWIZZLE_Y));
- ureg_MOV(ureg, *out, ureg_src(temp[2]));
-}
-
-static INLINE void
-alpha_normal( struct ureg_program *ureg,
- struct ureg_dst *out,
- struct ureg_src *in,
- struct ureg_src *sampler,
- struct ureg_dst *temp,
- struct ureg_src *constant)
-{
- /* save per-channel alpha in TEMP[1] */
- ureg_MOV(ureg, temp[1], ureg_scalar(ureg_src(temp[0]), TGSI_SWIZZLE_W));
-
- ureg_MOV(ureg, *out, ureg_src(temp[0]));
-}
-
-static INLINE void
-alpha_per_channel( struct ureg_program *ureg,
- struct ureg_dst *out,
- struct ureg_src *in,
- struct ureg_src *sampler,
- struct ureg_dst *temp,
- struct ureg_src *constant)
-{
- /* save per-channel alpha in TEMP[1] */
- ureg_MUL(ureg,
- ureg_writemask(temp[1], TGSI_WRITEMASK_W),
- ureg_src(temp[0]),
- ureg_src(temp[1]));
- ureg_MUL(ureg,
- ureg_writemask(temp[1], TGSI_WRITEMASK_XYZ),
- ureg_src(temp[1]),
- ureg_scalar(ureg_src(temp[1]), TGSI_SWIZZLE_W));
-
- /* update alpha */
- ureg_MOV(ureg,
- ureg_writemask(temp[0], TGSI_WRITEMASK_W),
- ureg_src(temp[1]));
- ureg_MOV(ureg, *out, ureg_src(temp[0]));
-}
-
-/**
- * Premultiply src and dst.
- */
-static INLINE void
-blend_premultiply( struct ureg_program *ureg,
- struct ureg_src src,
- struct ureg_src src_channel_alpha,
- struct ureg_src dst)
-{
- /* premultiply src */
- ureg_MUL(ureg,
- ureg_writemask(ureg_dst(src), TGSI_WRITEMASK_XYZ),
- src,
- src_channel_alpha);
- /* premultiply dst */
- ureg_MUL(ureg,
- ureg_writemask(ureg_dst(dst), TGSI_WRITEMASK_XYZ),
- dst,
- ureg_scalar(dst, TGSI_SWIZZLE_W));
-}
-
-/**
- * Unpremultiply src.
- */
-static INLINE void
-blend_unpremultiply( struct ureg_program *ureg,
- struct ureg_src src,
- struct ureg_src one,
- struct ureg_dst temp[1])
-{
- /* replace 0.0f by 1.0f before calculating reciprocal */
- ureg_CMP(ureg,
- temp[0],
- ureg_negate(ureg_scalar(src, TGSI_SWIZZLE_W)),
- ureg_scalar(src, TGSI_SWIZZLE_W),
- one);
- ureg_RCP(ureg, temp[0], ureg_src(temp[0]));
-
- ureg_MUL(ureg,
- ureg_writemask(ureg_dst(src), TGSI_WRITEMASK_XYZ),
- src,
- ureg_src(temp[0]));
-}
-
-/**
- * Emit instructions for the specified blend mode. Colors will be
- * unpremultiplied. Two temporary registers are required.
- *
- * The output is written back to src.
- */
-static INLINE void
-blend_generic(struct ureg_program *ureg,
- VGBlendMode mode,
- struct ureg_src src,
- struct ureg_src src_channel_alpha,
- struct ureg_src dst,
- struct ureg_src one,
- struct ureg_dst temp[2])
-{
- struct ureg_dst out;
-
- blend_premultiply(ureg, src, src_channel_alpha, dst);
-
- /* blend in-place */
- out = ureg_dst(src);
-
- switch (mode) {
- case VG_BLEND_SRC:
- ureg_MOV(ureg, out, src);
- break;
- case VG_BLEND_SRC_OVER:
- /* RGBA_out = RGBA_src + (1 - A_src) * RGBA_dst */
- ureg_SUB(ureg, temp[0], one, src_channel_alpha);
- ureg_MAD(ureg, out, ureg_src(temp[0]), dst, src);
- break;
- case VG_BLEND_DST_OVER:
- /* RGBA_out = RGBA_dst + (1 - A_dst) * RGBA_src */
- ureg_SUB(ureg, temp[0], one, ureg_scalar(dst, TGSI_SWIZZLE_W));
- ureg_MAD(ureg, out, ureg_src(temp[0]), src, dst);
- break;
- case VG_BLEND_SRC_IN:
- ureg_MUL(ureg, out, src, ureg_scalar(dst, TGSI_SWIZZLE_W));
- break;
- case VG_BLEND_DST_IN:
- ureg_MUL(ureg, out, dst, src_channel_alpha);
- break;
- case VG_BLEND_MULTIPLY:
- /*
- * RGB_out = (1 - A_dst) * RGB_src + (1 - A_src) * RGB_dst +
- * RGB_src * RGB_dst
- */
- ureg_MAD(ureg, temp[0],
- ureg_scalar(dst, TGSI_SWIZZLE_W), ureg_negate(src), src);
- ureg_MAD(ureg, temp[1],
- src_channel_alpha, ureg_negate(dst), dst);
- ureg_MAD(ureg, temp[0], src, dst, ureg_src(temp[0]));
- ureg_ADD(ureg, out, ureg_src(temp[0]), ureg_src(temp[1]));
- /* alpha is src over */
- ureg_ADD(ureg, ureg_writemask(out, TGSI_WRITEMASK_W),
- src, ureg_src(temp[1]));
- break;
- case VG_BLEND_SCREEN:
- /* RGBA_out = RGBA_src + (1 - RGBA_src) * RGBA_dst */
- ureg_SUB(ureg, temp[0], one, src);
- ureg_MAD(ureg, out, ureg_src(temp[0]), dst, src);
- break;
- case VG_BLEND_DARKEN:
- case VG_BLEND_LIGHTEN:
- /* src over */
- ureg_SUB(ureg, temp[0], one, src_channel_alpha);
- ureg_MAD(ureg, temp[0], ureg_src(temp[0]), dst, src);
- /* dst over */
- ureg_SUB(ureg, temp[1], one, ureg_scalar(dst, TGSI_SWIZZLE_W));
- ureg_MAD(ureg, temp[1], ureg_src(temp[1]), src, dst);
- /* take min/max for colors */
- if (mode == VG_BLEND_DARKEN) {
- ureg_MIN(ureg, ureg_writemask(out, TGSI_WRITEMASK_XYZ),
- ureg_src(temp[0]), ureg_src(temp[1]));
- }
- else {
- ureg_MAX(ureg, ureg_writemask(out, TGSI_WRITEMASK_XYZ),
- ureg_src(temp[0]), ureg_src(temp[1]));
- }
- break;
- case VG_BLEND_ADDITIVE:
- /* RGBA_out = RGBA_src + RGBA_dst */
- ureg_ADD(ureg, temp[0], src, dst);
- ureg_MIN(ureg, out, ureg_src(temp[0]), one);
- break;
- default:
- assert(0);
- break;
- }
-
- blend_unpremultiply(ureg, src, one, temp);
-}
-
-#define BLEND_GENERIC(mode) \
- do { \
- ureg_TEX(ureg, temp[2], TGSI_TEXTURE_2D, in[0], sampler[2]); \
- blend_generic(ureg, (mode), ureg_src(temp[0]), ureg_src(temp[1]), \
- ureg_src(temp[2]), \
- ureg_scalar(constant[3], TGSI_SWIZZLE_Y), temp + 3); \
- ureg_MOV(ureg, *out, ureg_src(temp[0])); \
- } while (0)
-
-static INLINE void
-blend_src( struct ureg_program *ureg,
- struct ureg_dst *out,
- struct ureg_src *in,
- struct ureg_src *sampler,
- struct ureg_dst *temp,
- struct ureg_src *constant)
-{
- BLEND_GENERIC(VG_BLEND_SRC);
-}
-
-static INLINE void
-blend_src_over( struct ureg_program *ureg,
- struct ureg_dst *out,
- struct ureg_src *in,
- struct ureg_src *sampler,
- struct ureg_dst *temp,
- struct ureg_src *constant)
-{
- BLEND_GENERIC(VG_BLEND_SRC_OVER);
-}
-
-static INLINE void
-blend_dst_over( struct ureg_program *ureg,
- struct ureg_dst *out,
- struct ureg_src *in,
- struct ureg_src *sampler,
- struct ureg_dst *temp,
- struct ureg_src *constant)
-{
- BLEND_GENERIC(VG_BLEND_DST_OVER);
-}
-
-static INLINE void
-blend_src_in( struct ureg_program *ureg,
- struct ureg_dst *out,
- struct ureg_src *in,
- struct ureg_src *sampler,
- struct ureg_dst *temp,
- struct ureg_src *constant)
-{
- BLEND_GENERIC(VG_BLEND_SRC_IN);
-}
-
-static INLINE void
-blend_dst_in( struct ureg_program *ureg,
- struct ureg_dst *out,
- struct ureg_src *in,
- struct ureg_src *sampler,
- struct ureg_dst *temp,
- struct ureg_src *constant)
-{
- BLEND_GENERIC(VG_BLEND_DST_IN);
-}
-
-static INLINE void
-blend_multiply( struct ureg_program *ureg,
- struct ureg_dst *out,
- struct ureg_src *in,
- struct ureg_src *sampler,
- struct ureg_dst *temp,
- struct ureg_src *constant)
-{
- BLEND_GENERIC(VG_BLEND_MULTIPLY);
-}
-
-static INLINE void
-blend_screen( struct ureg_program *ureg,
- struct ureg_dst *out,
- struct ureg_src *in,
- struct ureg_src *sampler,
- struct ureg_dst *temp,
- struct ureg_src *constant)
-{
- BLEND_GENERIC(VG_BLEND_SCREEN);
-}
-
-static INLINE void
-blend_darken( struct ureg_program *ureg,
- struct ureg_dst *out,
- struct ureg_src *in,
- struct ureg_src *sampler,
- struct ureg_dst *temp,
- struct ureg_src *constant)
-{
- BLEND_GENERIC(VG_BLEND_DARKEN);
-}
-
-static INLINE void
-blend_lighten( struct ureg_program *ureg,
- struct ureg_dst *out,
- struct ureg_src *in,
- struct ureg_src *sampler,
- struct ureg_dst *temp,
- struct ureg_src *constant)
-{
- BLEND_GENERIC(VG_BLEND_LIGHTEN);
-}
-
-static INLINE void
-blend_additive( struct ureg_program *ureg,
- struct ureg_dst *out,
- struct ureg_src *in,
- struct ureg_src *sampler,
- struct ureg_dst *temp,
- struct ureg_src *constant)
-{
- BLEND_GENERIC(VG_BLEND_ADDITIVE);
-}
-
-static INLINE void
-mask( struct ureg_program *ureg,
- struct ureg_dst *out,
- struct ureg_src *in,
- struct ureg_src *sampler,
- struct ureg_dst *temp,
- struct ureg_src *constant)
-{
- ureg_TEX(ureg, temp[1], TGSI_TEXTURE_2D, in[0], sampler[1]);
- ureg_MUL(ureg, ureg_writemask(temp[0], TGSI_WRITEMASK_W),
- ureg_scalar(ureg_src(temp[0]), TGSI_SWIZZLE_W),
- ureg_scalar(ureg_src(temp[1]), TGSI_SWIZZLE_W));
- ureg_MOV(ureg, *out, ureg_src(temp[0]));
-}
-
-static INLINE void
-premultiply( struct ureg_program *ureg,
- struct ureg_dst *out,
- struct ureg_src *in,
- struct ureg_src *sampler,
- struct ureg_dst *temp,
- struct ureg_src *constant)
-{
- ureg_MUL(ureg,
- ureg_writemask(temp[0], TGSI_WRITEMASK_XYZ),
- ureg_src(temp[0]),
- ureg_scalar(ureg_src(temp[0]), TGSI_SWIZZLE_W));
-}
-
-static INLINE void
-unpremultiply( struct ureg_program *ureg,
- struct ureg_dst *out,
- struct ureg_src *in,
- struct ureg_src *sampler,
- struct ureg_dst *temp,
- struct ureg_src *constant)
-{
- ureg_TEX(ureg, temp[0], TGSI_TEXTURE_2D, in[0], sampler[1]);
-}
-
-
-static INLINE void
-color_bw( struct ureg_program *ureg,
- struct ureg_dst *out,
- struct ureg_src *in,
- struct ureg_src *sampler,
- struct ureg_dst *temp,
- struct ureg_src *constant)
-{
- ureg_ADD(ureg, temp[1],
- ureg_scalar(constant[3], TGSI_SWIZZLE_Y),
- ureg_scalar(constant[3], TGSI_SWIZZLE_Y));
- ureg_RCP(ureg, temp[2], ureg_src(temp[1]));
- ureg_ADD(ureg, temp[1],
- ureg_scalar(constant[3], TGSI_SWIZZLE_Y),
- ureg_src(temp[2]));
- ureg_ADD(ureg, ureg_writemask(temp[2], TGSI_WRITEMASK_X),
- ureg_scalar(ureg_src(temp[0]), TGSI_SWIZZLE_X),
- ureg_scalar(ureg_src(temp[0]), TGSI_SWIZZLE_Y));
- ureg_ADD(ureg, ureg_writemask(temp[2], TGSI_WRITEMASK_X),
- ureg_scalar(ureg_src(temp[0]), TGSI_SWIZZLE_Z),
- ureg_scalar(ureg_src(temp[0]), TGSI_SWIZZLE_X));
- ureg_SGE(ureg,
- ureg_writemask(temp[0], TGSI_WRITEMASK_XYZ),
- ureg_scalar(ureg_src(temp[2]), TGSI_SWIZZLE_X),
- ureg_src(temp[1]));
- ureg_SGE(ureg,
- ureg_writemask(temp[0], TGSI_WRITEMASK_W),
- ureg_scalar(ureg_src(temp[0]), TGSI_SWIZZLE_W),
- ureg_scalar(ureg_src(temp[2]), TGSI_SWIZZLE_Y));
- ureg_MOV(ureg, *out, ureg_src(temp[0]));
-}
-
-
-struct shader_asm_info {
- VGint id;
- ureg_func func;
-
- VGboolean needs_position;
-
- VGint start_const;
- VGint num_consts;
-
- VGint start_sampler;
- VGint num_samplers;
-
- VGint start_temp;
- VGint num_temps;
-};
-
-
-/* paint types */
-static const struct shader_asm_info shaders_paint_asm[] = {
- {VEGA_SOLID_FILL_SHADER, solid_fill,
- VG_FALSE, 2, 1, 0, 0, 0, 0},
- {VEGA_LINEAR_GRADIENT_SHADER, linear_grad,
- VG_TRUE, 2, 5, 0, 1, 0, 5},
- {VEGA_RADIAL_GRADIENT_SHADER, radial_grad,
- VG_TRUE, 2, 5, 0, 1, 0, 5},
- {VEGA_PATTERN_SHADER, pattern,
- VG_TRUE, 3, 4, 0, 1, 0, 5},
- {VEGA_PAINT_DEGENERATE_SHADER, paint_degenerate,
- VG_FALSE, 3, 1, 0, 1, 0, 2}
-};
-
-/* image draw modes */
-static const struct shader_asm_info shaders_image_asm[] = {
- {VEGA_IMAGE_NORMAL_SHADER, image_normal,
- VG_TRUE, 0, 0, 3, 1, 0, 2},
- {VEGA_IMAGE_MULTIPLY_SHADER, image_multiply,
- VG_TRUE, 0, 0, 3, 1, 0, 2},
- {VEGA_IMAGE_STENCIL_SHADER, image_stencil,
- VG_TRUE, 0, 0, 3, 1, 0, 2}
-};
-
-static const struct shader_asm_info shaders_color_transform_asm[] = {
- {VEGA_COLOR_TRANSFORM_SHADER, color_transform,
- VG_FALSE, 0, 4, 0, 0, 0, 3}
-};
-
-static const struct shader_asm_info shaders_alpha_asm[] = {
- {VEGA_ALPHA_NORMAL_SHADER, alpha_normal,
- VG_FALSE, 0, 0, 0, 0, 0, 2},
- {VEGA_ALPHA_PER_CHANNEL_SHADER, alpha_per_channel,
- VG_FALSE, 0, 0, 0, 0, 0, 2}
-};
-
-/* extra blend modes */
-static const struct shader_asm_info shaders_blend_asm[] = {
-#define BLEND_ASM_INFO(id, func) { (id), (func), VG_TRUE, 3, 1, 2, 1, 0, 5 }
- BLEND_ASM_INFO(VEGA_BLEND_SRC_SHADER, blend_src),
- BLEND_ASM_INFO(VEGA_BLEND_SRC_OVER_SHADER, blend_src_over),
- BLEND_ASM_INFO(VEGA_BLEND_DST_OVER_SHADER, blend_dst_over),
- BLEND_ASM_INFO(VEGA_BLEND_SRC_IN_SHADER, blend_src_in),
- BLEND_ASM_INFO(VEGA_BLEND_DST_IN_SHADER, blend_dst_in),
- BLEND_ASM_INFO(VEGA_BLEND_MULTIPLY_SHADER, blend_multiply),
- BLEND_ASM_INFO(VEGA_BLEND_SCREEN_SHADER, blend_screen),
- BLEND_ASM_INFO(VEGA_BLEND_DARKEN_SHADER, blend_darken),
- BLEND_ASM_INFO(VEGA_BLEND_LIGHTEN_SHADER, blend_lighten),
- BLEND_ASM_INFO(VEGA_BLEND_ADDITIVE_SHADER, blend_additive)
-#undef BLEND_ASM_INFO
-};
-
-static const struct shader_asm_info shaders_mask_asm[] = {
- {VEGA_MASK_SHADER, mask,
- VG_TRUE, 0, 0, 1, 1, 0, 2}
-};
-
-/* premultiply */
-static const struct shader_asm_info shaders_premultiply_asm[] = {
- {VEGA_PREMULTIPLY_SHADER, premultiply,
- VG_FALSE, 0, 0, 0, 0, 0, 1},
- {VEGA_UNPREMULTIPLY_SHADER, unpremultiply,
- VG_FALSE, 0, 0, 0, 0, 0, 1},
-};
-
-/* color transform to black and white */
-static const struct shader_asm_info shaders_bw_asm[] = {
- {VEGA_BW_SHADER, color_bw,
- VG_FALSE, 3, 1, 0, 0, 0, 3},
-};
-
-#endif
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#ifndef ASM_FILTERS_H
-#define ASM_FILTERS_H
-
-static const char color_matrix_asm[] =
- "FRAG\n"
- "DCL IN[0], GENERIC[0], PERSPECTIVE\n"
- "DCL OUT[0], COLOR, CONSTANT\n"
- "DCL CONST[0..4], CONSTANT\n"
- "DCL TEMP[0..4], CONSTANT\n"
- "DCL SAMP[0], CONSTANT\n"
- "TEX TEMP[0], IN[0], SAMP[0], 2D\n"
- "MOV TEMP[1], TEMP[0].xxxx\n"
- "MOV TEMP[2], TEMP[0].yyyy\n"
- "MOV TEMP[3], TEMP[0].zzzz\n"
- "MOV TEMP[4], TEMP[0].wwww\n"
- "MUL TEMP[1], TEMP[1], CONST[0]\n"
- "MUL TEMP[2], TEMP[2], CONST[1]\n"
- "MUL TEMP[3], TEMP[3], CONST[2]\n"
- "MUL TEMP[4], TEMP[4], CONST[3]\n"
- "ADD TEMP[0], TEMP[1], CONST[4]\n"
- "ADD TEMP[0], TEMP[0], TEMP[2]\n"
- "ADD TEMP[0], TEMP[0], TEMP[3]\n"
- "ADD TEMP[0], TEMP[0], TEMP[4]\n"
- "MOV OUT[0], TEMP[0]\n"
- "END\n";
-
-static const char convolution_asm[] =
- "FRAG\n"
- "DCL IN[0], GENERIC[0], PERSPECTIVE\n"
- "DCL OUT[0], COLOR, CONSTANT\n"
- "DCL TEMP[0..4], CONSTANT\n"
- "DCL ADDR[0], CONSTANT\n"
- "DCL CONST[0..%d], CONSTANT\n"
- "DCL SAMP[0], CONSTANT\n"
- "0: MOV TEMP[0], CONST[0].xxxx\n"
- "1: MOV TEMP[1], CONST[0].xxxx\n"
- "2: BGNLOOP :14\n"
- "3: SGE TEMP[0].z, TEMP[0].yyyy, CONST[1].xxxx\n"
- "4: IF TEMP[0].zzzz :7\n"
- "5: BRK\n"
- "6: ENDIF\n"
- "7: ARL ADDR[0].x, TEMP[0].yyyy\n"
- "8: MOV TEMP[3], CONST[ADDR[0]+2]\n"
- "9: ADD TEMP[4].xy, IN[0], TEMP[3]\n"
- "10: TEX TEMP[2], TEMP[4], SAMP[0], 2D\n"
- "11: MOV TEMP[3], CONST[ADDR[0]+%d]\n"
- "12: MAD TEMP[1], TEMP[2], TEMP[3], TEMP[1]\n"
- "13: ADD TEMP[0].y, TEMP[0].yyyy, CONST[0].yyyy\n"
- "14: ENDLOOP :2\n"
- "15: MAD OUT[0], TEMP[1], CONST[1].yyyy, CONST[1].zzzz\n"
- "16: END\n";
-
-
-static const char lookup_asm[] =
- "FRAG\n"
- "DCL IN[0], GENERIC[0], PERSPECTIVE\n"
- "DCL OUT[0], COLOR, CONSTANT\n"
- "DCL TEMP[0..2], CONSTANT\n"
- "DCL CONST[0], CONSTANT\n"
- "DCL SAMP[0..1], CONSTANT\n"
- "TEX TEMP[0], IN[0], SAMP[0], 2D\n"
- "MOV TEMP[1], TEMP[0]\n"
- /* do red */
- "TEX TEMP[2], TEMP[1].xxxx, SAMP[1], 1D\n"
- "MOV TEMP[0].x, TEMP[2].xxxx\n"
- /* do blue */
- "TEX TEMP[2], TEMP[1].yyyy, SAMP[1], 1D\n"
- "MOV TEMP[0].y, TEMP[2].yyyy\n"
- /* do green */
- "TEX TEMP[2], TEMP[1].zzzz, SAMP[1], 1D\n"
- "MOV TEMP[0].z, TEMP[2].zzzz\n"
- /* do alpha */
- "TEX TEMP[2], TEMP[1].wwww, SAMP[1], 1D\n"
- "MOV TEMP[0].w, TEMP[2].wwww\n"
- "MOV OUT[0], TEMP[0]\n"
- "END\n";
-
-
-static const char lookup_single_asm[] =
- "FRAG\n"
- "DCL IN[0], GENERIC[0], PERSPECTIVE\n"
- "DCL OUT[0], COLOR, CONSTANT\n"
- "DCL TEMP[0..2], CONSTANT\n"
- "DCL CONST[0], CONSTANT\n"
- "DCL SAMP[0..1], CONSTANT\n"
- "TEX TEMP[0], IN[0], SAMP[0], 2D\n"
- "TEX TEMP[1], TEMP[0].%s, SAMP[1], 1D\n"
- "MOV OUT[0], TEMP[1]\n"
- "END\n";
-
-#endif
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#ifndef ASM_UTIL_H
-#define ASM_UTIL_H
-
-/* μnew = μmask */
-static const char set_mask_asm[] =
- "FRAG\n"
- "DCL IN[0], GENERIC[0], PERSPECTIVE\n"
- "DCL SAMP[0], CONSTANT\n"
- "DCL OUT[0], COLOR, CONSTANT\n"
- "0: TEX OUT[0], IN[0], SAMP[0], 2D\n"/*umask*/
- "1: END\n";
-
-/* μnew = 1 – (1 – μmask)*(1 – μprev) */
-static const char union_mask_asm[] =
- "FRAG\n"
- "DCL IN[0], GENERIC[0], PERSPECTIVE\n"
- "DCL IN[1], POSITION, LINEAR\n"
- "DCL CONST[0], CONSTANT\n"
- "DCL SAMP[0..1], CONSTANT\n"
- "DCL TEMP[0..3], CONSTANT\n"
- "DCL OUT[0], COLOR, CONSTANT\n"
- "0: TEX TEMP[1], IN[0], SAMP[0], 2D\n"/*umask*/
- "1: TEX TEMP[0], IN[1], SAMP[1], 2D\n"/*uprev*/
- "2: SUB TEMP[2], CONST[0], TEMP[0]\n"
- "3: SUB TEMP[3], CONST[0], TEMP[1]\n"
- "4: MUL TEMP[0].w, TEMP[2].wwww, TEMP[3].wwww\n"
- "5: SUB OUT[0], CONST[0], TEMP[0]\n"
- "6: END\n";
-
-/* μnew = μmask *μprev */
-static const char intersect_mask_asm[] =
- "FRAG\n"
- "DCL IN[0], GENERIC[0], PERSPECTIVE\n"
- "DCL IN[1], POSITION, LINEAR\n"
- "DCL CONST[0], CONSTANT\n"
- "DCL SAMP[0..1], CONSTANT\n"
- "DCL TEMP[0..1], CONSTANT\n"
- "DCL OUT[0], COLOR, CONSTANT\n"
- "0: TEX TEMP[0], IN[1], SAMP[1], 2D\n"/*uprev*/
- "1: TEX TEMP[1], IN[0], SAMP[0], 2D\n"/*umask*/
- "2: MUL OUT[0], TEMP[0].wwww, TEMP[1].wwww\n"
- "3: END\n";
-
-/* μnew = μprev*(1 – μmask) */
-static const char subtract_mask_asm[] =
- "FRAG\n"
- "DCL IN[0], GENERIC[0], PERSPECTIVE\n"
- "DCL IN[1], POSITION, LINEAR\n"
- "DCL CONST[0], CONSTANT\n"
- "DCL SAMP[0..1], CONSTANT\n"
- "DCL TEMP[0..2], CONSTANT\n"
- "DCL OUT[0], COLOR, CONSTANT\n"
- "0: TEX TEMP[1], IN[0], SAMP[0], 2D\n"/*umask*/
- "1: TEX TEMP[0], IN[1], SAMP[1], 2D\n"/*uprev*/
- "2: SUB TEMP[2], CONST[0], TEMP[1]\n"
- "3: MUL OUT[0], TEMP[2].wwww, TEMP[0].wwww\n"
- "4: END\n";
-
-#endif
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#include "bezier.h"
-
-#include "matrix.h"
-#include "polygon.h"
-
-#include "pipe/p_compiler.h"
-#include "util/u_debug.h"
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <assert.h>
-#include <math.h>
-
-static const float flatness = 0.5;
-
-
-static INLINE void split_left(struct bezier *bez, VGfloat t, struct bezier* left)
-{
- left->x1 = bez->x1;
- left->y1 = bez->y1;
-
- left->x2 = bez->x1 + t * (bez->x2 - bez->x1);
- left->y2 = bez->y1 + t * (bez->y2 - bez->y1);
-
- left->x3 = bez->x2 + t * (bez->x3 - bez->x2);
- left->y3 = bez->y2 + t * (bez->y3 - bez->y2);
-
- bez->x3 = bez->x3 + t * (bez->x4 - bez->x3);
- bez->y3 = bez->y3 + t * (bez->y4 - bez->y3);
-
- bez->x2 = left->x3 + t * (bez->x3 - left->x3);
- bez->y2 = left->y3 + t * (bez->y3 - left->y3);
-
- left->x3 = left->x2 + t * (left->x3 - left->x2);
- left->y3 = left->y2 + t * (left->y3 - left->y2);
-
- left->x4 = bez->x1 = left->x3 + t * (bez->x2 - left->x3);
- left->y4 = bez->y1 = left->y3 + t * (bez->y2 - left->y3);
-}
-
-static INLINE void split(struct bezier *bez,
- struct bezier *first_half,
- struct bezier *second_half)
-{
- double c = (bez->x2 + bez->x3) * 0.5;
- first_half->x2 = (bez->x1 + bez->x2) * 0.5;
- second_half->x3 = (bez->x3 + bez->x4) * 0.5;
- first_half->x1 = bez->x1;
- second_half->x4 = bez->x4;
- first_half->x3 = (first_half->x2 + c) * 0.5;
- second_half->x2 = (second_half->x3 + c) * 0.5;
- first_half->x4 = second_half->x1 =
- (first_half->x3 + second_half->x2) * 0.5;
-
- c = (bez->y2 + bez->y3) / 2;
- first_half->y2 = (bez->y1 + bez->y2) * 0.5;
- second_half->y3 = (bez->y3 + bez->y4) * 0.5;
- first_half->y1 = bez->y1;
- second_half->y4 = bez->y4;
- first_half->y3 = (first_half->y2 + c) * 0.5;
- second_half->y2 = (second_half->y3 + c) * 0.5;
- first_half->y4 = second_half->y1 =
- (first_half->y3 + second_half->y2) * 0.5;
-}
-
-struct polygon * bezier_to_polygon(struct bezier *bez)
-{
- struct polygon *poly = polygon_create(64);
- polygon_vertex_append(poly, bez->x1, bez->y1);
- bezier_add_to_polygon(bez, poly);
- return poly;
-}
-
-void bezier_add_to_polygon(const struct bezier *bez,
- struct polygon *poly)
-{
- struct bezier beziers[32];
- struct bezier *b;
-
- beziers[0] = *bez;
- b = beziers;
-
- while (b >= beziers) {
- double y4y1 = b->y4 - b->y1;
- double x4x1 = b->x4 - b->x1;
- double l = ABS(x4x1) + ABS(y4y1);
- double d;
- if (l > 1.f) {
- d = ABS((x4x1)*(b->y1 - b->y2) - (y4y1)*(b->x1 - b->x2))
- + ABS((x4x1)*(b->y1 - b->y3) - (y4y1)*(b->x1 - b->x3));
- } else {
- d = ABS(b->x1 - b->x2) + ABS(b->y1 - b->y2) +
- ABS(b->x1 - b->x3) + ABS(b->y1 - b->y3);
- l = 1.;
- }
- if (d < flatness*l || b == beziers + 31) {
- /* good enough, we pop it off and add the endpoint */
- polygon_vertex_append(poly, b->x4, b->y4);
- --b;
- } else {
- /* split, second half of the bezier goes lower into the stack */
- split(b, b+1, b);
- ++b;
- }
- }
-}
-
-static void add_if_close(struct bezier *bez, VGfloat *length, VGfloat error)
-{
- struct bezier left, right; /* bez poly splits */
- VGfloat len = 0.0; /* arc length */
- VGfloat chord; /* chord length */
-
- len = len + line_length(bez->x1, bez->y1, bez->x2, bez->y2);
- len = len + line_length(bez->x2, bez->y2, bez->x3, bez->y3);
- len = len + line_length(bez->x3, bez->y3, bez->x4, bez->y4);
-
- chord = line_length(bez->x1, bez->y1, bez->x4, bez->y4);
-
- if ((len-chord) > error) {
- split(bez, &left, &right); /* split in two */
- add_if_close(&left, length, error); /* try left side */
- add_if_close(&right, length, error); /* try right side */
- return;
- }
-
- *length = *length + len;
-
- return;
-}
-
-float bezier_length(struct bezier *bez, float error)
-{
- VGfloat length = 0.f;
-
- add_if_close(bez, &length, error);
- return length;
-}
-
-void bezier_init(struct bezier *bez,
- float x1, float y1,
- float x2, float y2,
- float x3, float y3,
- float x4, float y4)
-{
- bez->x1 = x1;
- bez->y1 = y1;
- bez->x2 = x2;
- bez->y2 = y2;
- bez->x3 = x3;
- bez->y3 = y3;
- bez->x4 = x4;
- bez->y4 = y4;
-#if 0
- debug_printf("bezier in [%f, %f, %f, %f, %f, %f]\n",
- x1, y1, x2, y2, x3, y3, x4, y4);
-#endif
-}
-
-
-static INLINE void bezier_init2v(struct bezier *bez,
- float *pt1,
- float *pt2,
- float *pt3,
- float *pt4)
-{
- bez->x1 = pt1[0];
- bez->y1 = pt1[1];
-
- bez->x2 = pt2[0];
- bez->y2 = pt2[1];
-
- bez->x3 = pt3[0];
- bez->y3 = pt3[1];
-
- bez->x4 = pt4[0];
- bez->y4 = pt4[1];
-}
-
-
-void bezier_transform(struct bezier *bez,
- struct matrix *matrix)
-{
- assert(matrix_is_affine(matrix));
- matrix_map_point(matrix, bez->x1, bez->y1, &bez->x1, &bez->y1);
- matrix_map_point(matrix, bez->x2, bez->y2, &bez->x2, &bez->y2);
- matrix_map_point(matrix, bez->x3, bez->y3, &bez->x3, &bez->y3);
- matrix_map_point(matrix, bez->x4, bez->y4, &bez->x4, &bez->y4);
-}
-
-static INLINE void bezier_point_at(const struct bezier *bez, float t, float *pt)
-{
- float a, b, c, d;
- float m_t;
- m_t = 1. - t;
- b = m_t * m_t;
- c = t * t;
- d = c * t;
- a = b * m_t;
- b *= 3. * t;
- c *= 3. * m_t;
- pt[0] = a*bez->x1 + b*bez->x2 + c*bez->x3 + d*bez->x4;
- pt[1] = a*bez->y1 + b*bez->y2 + c*bez->y3 + d*bez->y4;
-}
-
-static INLINE void bezier_normal_at(const struct bezier *bez, float t, float *norm)
-{
- float m_t = 1. - t;
- float a = m_t * m_t;
- float b = t * m_t;
- float c = t * t;
-
- norm[0] = (bez->y2-bez->y1) * a + (bez->y3-bez->y2) * b + (bez->y4-bez->y3) * c;
- norm[1] = -(bez->x2-bez->x1) * a - (bez->x3-bez->x2) * b - (bez->x4-bez->x3) * c;
-}
-
-enum shift_result {
- Ok,
- Discard,
- Split,
- Circle
-};
-
-static enum shift_result good_offset(const struct bezier *b1,
- const struct bezier *b2,
- float offset, float threshold)
-{
- const float o2 = offset*offset;
- const float max_dist_line = threshold*offset*offset;
- const float max_dist_normal = threshold*offset;
- const float spacing = 0.25;
- float i;
- for (i = spacing; i < 0.99; i += spacing) {
- float p1[2],p2[2], d, l;
- float normal[2];
- bezier_point_at(b1, i, p1);
- bezier_point_at(b2, i, p2);
- d = (p1[0] - p2[0])*(p1[0] - p2[0]) + (p1[1] - p2[1])*(p1[1] - p2[1]);
- if (ABS(d - o2) > max_dist_line)
- return Split;
-
- bezier_normal_at(b1, i, normal);
- l = ABS(normal[0]) + ABS(normal[1]);
- if (l != 0.) {
- d = ABS(normal[0]*(p1[1] - p2[1]) - normal[1]*(p1[0] - p2[0]) ) / l;
- if (d > max_dist_normal)
- return Split;
- }
- }
- return Ok;
-}
-
-static INLINE void shift_line_by_normal(float *l, float offset)
-{
- float norm[4];
- float tx, ty;
-
- line_normal(l, norm);
- line_normalize(norm);
-
- tx = (norm[2] - norm[0]) * offset;
- ty = (norm[3] - norm[1]) * offset;
- l[0] += tx; l[1] += ty;
- l[2] += tx; l[3] += ty;
-}
-
-static INLINE VGboolean is_bezier_line(float (*points)[2], int count)
-{
- float dx13 = points[2][0] - points[0][0];
- float dy13 = points[2][1] - points[0][1];
-
- float dx12 = points[1][0] - points[0][0];
- float dy12 = points[1][1] - points[0][1];
-
- debug_assert(count > 2);
-
- if (count == 3) {
- return floatsEqual(dx12 * dy13, dx13 * dy12);
- } else if (count == 4) {
- float dx14 = points[3][0] - points[0][0];
- float dy14 = points[3][1] - points[0][1];
-
- return (floatsEqual(dx12 * dy13, dx13 * dy12) &&
- floatsEqual(dx12 * dy14, dx14 * dy12));
- }
-
- return VG_FALSE;
-}
-
-static INLINE void compute_pt_normal(float *pt1, float *pt2, float *res)
-{
- float line[4];
- float normal[4];
- line[0] = 0.f; line[1] = 0.f;
- line[2] = pt2[0] - pt1[0];
- line[3] = pt2[1] - pt1[1];
- line_normal(line, normal);
- line_normalize(normal);
-
- res[0] = normal[2];
- res[1] = normal[3];
-}
-
-static enum shift_result shift(const struct bezier *orig,
- struct bezier *shifted,
- float offset, float threshold)
-{
- int i;
- int map[4];
- VGboolean p1_p2_equal = (orig->x1 == orig->x2 && orig->y1 == orig->y2);
- VGboolean p2_p3_equal = (orig->x2 == orig->x3 && orig->y2 == orig->y3);
- VGboolean p3_p4_equal = (orig->x3 == orig->x4 && orig->y3 == orig->y4);
-
- float points[4][2];
- int np = 0;
- float bounds[4];
- float points_shifted[4][2];
- float prev_normal[2];
-
- points[np][0] = orig->x1;
- points[np][1] = orig->y1;
- map[0] = 0;
- ++np;
- if (!p1_p2_equal) {
- points[np][0] = orig->x2;
- points[np][1] = orig->y2;
- ++np;
- }
- map[1] = np - 1;
- if (!p2_p3_equal) {
- points[np][0] = orig->x3;
- points[np][1] = orig->y3;
- ++np;
- }
- map[2] = np - 1;
- if (!p3_p4_equal) {
- points[np][0] = orig->x4;
- points[np][1] = orig->y4;
- ++np;
- }
- map[3] = np - 1;
- if (np == 1)
- return Discard;
-
- /* We need to specialcase lines of 3 or 4 points due to numerical
- instability in intersection code below */
- if (np > 2 && is_bezier_line(points, np)) {
- float l[4] = { points[0][0], points[0][1],
- points[np-1][0], points[np-1][1] };
- float ctrl1[2], ctrl2[2];
- if (floatsEqual(points[0][0], points[np-1][0]) &&
- floatsEqual(points[0][1], points[np-1][1]))
- return Discard;
-
- shift_line_by_normal(l, offset);
- line_point_at(l, 0.33, ctrl1);
- line_point_at(l, 0.66, ctrl2);
- bezier_init(shifted, l[0], l[1],
- ctrl1[0], ctrl1[1], ctrl2[0], ctrl2[1],
- l[2], l[3]);
- return Ok;
- }
-
- bezier_bounds(orig, bounds);
- if (np == 4 && bounds[2] < .1*offset && bounds[3] < .1*offset) {
- float l = (orig->x1 - orig->x2)*(orig->x1 - orig->x2) +
- (orig->y1 - orig->y2)*(orig->y1 - orig->y1) *
- (orig->x3 - orig->x4)*(orig->x3 - orig->x4) +
- (orig->y3 - orig->y4)*(orig->y3 - orig->y4);
- float dot = (orig->x1 - orig->x2)*(orig->x3 - orig->x4) +
- (orig->y1 - orig->y2)*(orig->y3 - orig->y4);
- if (dot < 0 && dot*dot < 0.8*l)
- /* the points are close and reverse dirction. Approximate the whole
- thing by a semi circle */
- return Circle;
- }
-
- compute_pt_normal(points[0], points[1], prev_normal);
-
- points_shifted[0][0] = points[0][0] + offset * prev_normal[0];
- points_shifted[0][1] = points[0][1] + offset * prev_normal[1];
-
- for (i = 1; i < np - 1; ++i) {
- float normal_sum[2], r;
- float next_normal[2];
- compute_pt_normal(points[i], points[i + 1], next_normal);
-
- normal_sum[0] = prev_normal[0] + next_normal[0];
- normal_sum[1] = prev_normal[1] + next_normal[1];
-
- r = 1.0 + prev_normal[0] * next_normal[0]
- + prev_normal[1] * next_normal[1];
-
- if (floatsEqual(r + 1, 1)) {
- points_shifted[i][0] = points[i][0] + offset * prev_normal[0];
- points_shifted[i][1] = points[i][1] + offset * prev_normal[1];
- } else {
- float k = offset / r;
- points_shifted[i][0] = points[i][0] + k * normal_sum[0];
- points_shifted[i][1] = points[i][1] + k * normal_sum[1];
- }
-
- prev_normal[0] = next_normal[0];
- prev_normal[1] = next_normal[1];
- }
-
- points_shifted[np - 1][0] = points[np - 1][0] + offset * prev_normal[0];
- points_shifted[np - 1][1] = points[np - 1][1] + offset * prev_normal[1];
-
- bezier_init2v(shifted,
- points_shifted[map[0]], points_shifted[map[1]],
- points_shifted[map[2]], points_shifted[map[3]]);
-
- return good_offset(orig, shifted, offset, threshold);
-}
-
-static VGboolean make_circle(const struct bezier *b, float offset, struct bezier *o)
-{
- float normals[3][2];
- float dist;
- float angles[2];
- float sign = 1.f;
- int i;
- float circle[3][2];
-
- normals[0][0] = b->y2 - b->y1;
- normals[0][1] = b->x1 - b->x2;
- dist = sqrt(normals[0][0]*normals[0][0] + normals[0][1]*normals[0][1]);
- if (floatsEqual(dist + 1, 1.f))
- return VG_FALSE;
- normals[0][0] /= dist;
- normals[0][1] /= dist;
-
- normals[2][0] = b->y4 - b->y3;
- normals[2][1] = b->x3 - b->x4;
- dist = sqrt(normals[2][0]*normals[2][0] + normals[2][1]*normals[2][1]);
- if (floatsEqual(dist + 1, 1.f))
- return VG_FALSE;
- normals[2][0] /= dist;
- normals[2][1] /= dist;
-
- normals[1][0] = b->x1 - b->x2 - b->x3 + b->x4;
- normals[1][1] = b->y1 - b->y2 - b->y3 + b->y4;
- dist = -1*sqrt(normals[1][0]*normals[1][0] + normals[1][1]*normals[1][1]);
- normals[1][0] /= dist;
- normals[1][1] /= dist;
-
- for (i = 0; i < 2; ++i) {
- float cos_a = normals[i][0]*normals[i+1][0] + normals[i][1]*normals[i+1][1];
- if (cos_a > 1.)
- cos_a = 1.;
- if (cos_a < -1.)
- cos_a = -1;
- angles[i] = acos(cos_a)/M_PI;
- }
-
- if (angles[0] + angles[1] > 1.) {
- /* more than 180 degrees */
- normals[1][0] = -normals[1][0];
- normals[1][1] = -normals[1][1];
- angles[0] = 1. - angles[0];
- angles[1] = 1. - angles[1];
- sign = -1.;
- }
-
- circle[0][0] = b->x1 + normals[0][0]*offset;
- circle[0][1] = b->y1 + normals[0][1]*offset;
-
- circle[1][0] = 0.5*(b->x1 + b->x4) + normals[1][0]*offset;
- circle[1][1] = 0.5*(b->y1 + b->y4) + normals[1][1]*offset;
-
- circle[2][0] = b->x4 + normals[2][0]*offset;
- circle[2][1] = b->y4 + normals[2][1]*offset;
-
- for (i = 0; i < 2; ++i) {
- float kappa = 2.*KAPPA * sign * offset * angles[i];
-
- o->x1 = circle[i][0];
- o->y1 = circle[i][1];
- o->x2 = circle[i][0] - normals[i][1]*kappa;
- o->y2 = circle[i][1] + normals[i][0]*kappa;
- o->x3 = circle[i+1][0] + normals[i+1][1]*kappa;
- o->y3 = circle[i+1][1] - normals[i+1][0]*kappa;
- o->x4 = circle[i+1][0];
- o->y4 = circle[i+1][1];
-
- ++o;
- }
- return VG_TRUE;
-}
-
-int bezier_translate_by_normal(struct bezier *bez,
- struct bezier *curves,
- int max_curves,
- float normal_len,
- float threshold)
-{
- struct bezier beziers[10];
- struct bezier *b, *o;
-
- /* fixme: this should really be floatsEqual */
- if (bez->x1 == bez->x2 && bez->x1 == bez->x3 && bez->x1 == bez->x4 &&
- bez->y1 == bez->y2 && bez->y1 == bez->y3 && bez->y1 == bez->y4)
- return 0;
-
- --max_curves;
-redo:
- beziers[0] = *bez;
- b = beziers;
- o = curves;
-
- while (b >= beziers) {
- int stack_segments = b - beziers + 1;
- enum shift_result res;
- if ((stack_segments == 10) || (o - curves == max_curves - stack_segments)) {
- threshold *= 1.5;
- if (threshold > 2.)
- goto give_up;
- goto redo;
- }
- res = shift(b, o, normal_len, threshold);
- if (res == Discard) {
- --b;
- } else if (res == Ok) {
- ++o;
- --b;
- continue;
- } else if (res == Circle && max_curves - (o - curves) >= 2) {
- /* add semi circle */
- if (make_circle(b, normal_len, o))
- o += 2;
- --b;
- } else {
- split(b, b+1, b);
- ++b;
- }
- }
-
-give_up:
- while (b >= beziers) {
- enum shift_result res = shift(b, o, normal_len, threshold);
-
- /* if res isn't Ok or Split then *o is undefined */
- if (res == Ok || res == Split)
- ++o;
-
- --b;
- }
-
- debug_assert(o - curves <= max_curves);
- return o - curves;
-}
-
-void bezier_bounds(const struct bezier *bez,
- float *bounds/*x/y/width/height*/)
-{
- float xmin = bez->x1;
- float xmax = bez->x1;
- float ymin = bez->y1;
- float ymax = bez->y1;
-
- if (bez->x2 < xmin)
- xmin = bez->x2;
- else if (bez->x2 > xmax)
- xmax = bez->x2;
- if (bez->x3 < xmin)
- xmin = bez->x3;
- else if (bez->x3 > xmax)
- xmax = bez->x3;
- if (bez->x4 < xmin)
- xmin = bez->x4;
- else if (bez->x4 > xmax)
- xmax = bez->x4;
-
- if (bez->y2 < ymin)
- ymin = bez->y2;
- else if (bez->y2 > ymax)
- ymax = bez->y2;
- if (bez->y3 < ymin)
- ymin = bez->y3;
- else if (bez->y3 > ymax)
- ymax = bez->y3;
- if (bez->y4 < ymin)
- ymin = bez->y4;
- else if (bez->y4 > ymax)
- ymax = bez->y4;
-
- bounds[0] = xmin; /* x */
- bounds[1] = ymin; /* y */
- bounds[2] = xmax - xmin; /* width */
- bounds[3] = ymax - ymin; /* height */
-}
-
-void bezier_start_tangent(const struct bezier *bez,
- float *tangent)
-{
- tangent[0] = bez->x1;
- tangent[1] = bez->y1;
- tangent[2] = bez->x2;
- tangent[3] = bez->y2;
-
- if (null_line(tangent)) {
- tangent[0] = bez->x1;
- tangent[1] = bez->y1;
- tangent[2] = bez->x3;
- tangent[3] = bez->y3;
- }
- if (null_line(tangent)) {
- tangent[0] = bez->x1;
- tangent[1] = bez->y1;
- tangent[2] = bez->x4;
- tangent[3] = bez->y4;
- }
-}
-
-
-static INLINE VGfloat bezier_t_at_length(struct bezier *bez,
- VGfloat at_length,
- VGfloat error)
-{
- VGfloat len = bezier_length(bez, error);
- VGfloat t = 1.0;
- VGfloat last_bigger = 1.;
-
- if (at_length > len || floatsEqual(at_length, len))
- return t;
-
- if (floatIsZero(at_length))
- return 0.f;
-
- t *= 0.5;
- while (1) {
- struct bezier right = *bez;
- struct bezier left;
- VGfloat tmp_len;
- split_left(&right, t, &left);
- tmp_len = bezier_length(&left, error);
- if (ABS(tmp_len - at_length) < error)
- break;
-
- if (tmp_len < at_length) {
- t += (last_bigger - t)*.5;
- } else {
- last_bigger = t;
- t -= t*.5;
- }
- }
- return t;
-}
-
-void bezier_point_at_length(struct bezier *bez,
- float length,
- float *point,
- float *normal)
-{
- /* ~0.000001 seems to be required to pass G2080x tests */
- VGfloat t = bezier_t_at_length(bez, length, 0.000001);
- bezier_point_at(bez, t, point);
- bezier_normal_at(bez, t, normal);
- vector_unit(normal);
-}
-
-void bezier_point_at_t(struct bezier *bez, float t,
- float *point, float *normal)
-{
- bezier_point_at(bez, t, point);
- bezier_normal_at(bez, t, normal);
- vector_unit(normal);
-}
-
-void bezier_exact_bounds(const struct bezier *bez,
- float *bounds/*x/y/width/height*/)
-{
- struct polygon *poly = polygon_create(64);
- polygon_vertex_append(poly, bez->x1, bez->y1);
- bezier_add_to_polygon(bez, poly);
- polygon_bounding_rect(poly, bounds);
- polygon_destroy(poly);
-}
-
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#ifndef BEZIER_H
-#define BEZIER_H
-
-struct polygon;
-struct matrix;
-
-struct bezier {
- float x1, y1;
- float x2, y2;
- float x3, y3;
- float x4, y4;
-};
-
-
-#define BEZIER_DEFAULT_ERROR 0.01
-
-/* kappa as being l of a circle with r = 1, we can emulate any
- * circle of radius r by using the formula
- * l = r . kappa
- * More at:
- * http://www.whizkidtech.redprince.net/bezier/circle/ */
-#define KAPPA 0.5522847498
-
-void bezier_init(struct bezier *bez,
- float x1, float y1,
- float x2, float y2,
- float x3, float y3,
- float x4, float y4);
-
-struct polygon *bezier_to_polygon(struct bezier *bez);
-void bezier_add_to_polygon(const struct bezier *bez,
- struct polygon *poly);
-float bezier_length(struct bezier *bez, float error);
-void bezier_transform(struct bezier *bez,
- struct matrix *mat);
-
-int bezier_translate_by_normal(struct bezier *b,
- struct bezier *curves,
- int max_curves,
- float normal_len,
- float threshold);
-void bezier_bounds(const struct bezier *bez,
- float *bounds/*x/y/width/height*/);
-void bezier_exact_bounds(const struct bezier *bez,
- float *bounds/*x/y/width/height*/);
-
-void bezier_start_tangent(const struct bezier *bez,
- float *tangent);
-
-void bezier_point_at_length(struct bezier *bez, float length,
- float *point, float *normal);
-void bezier_point_at_t(struct bezier *bez, float t,
- float *point, float *normal);
-
-#endif
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2010 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-
-#include "handle.h"
-#include "util/u_hash.h"
-#include "util/u_hash_table.h"
-
-
-/**
- * Hash keys are 32-bit VGHandles
- */
-
-struct util_hash_table *handle_hash = NULL;
-
-
-static unsigned next_handle = 1;
-
-
-static unsigned
-hash_func(void *key)
-{
- /* XXX this kind of ugly */
- intptr_t ip = pointer_to_intptr(key);
- return (unsigned) (ip & 0xffffffff);
-}
-
-
-static int
-compare(void *key1, void *key2)
-{
- if (key1 < key2)
- return -1;
- else if (key1 > key2)
- return +1;
- else
- return 0;
-}
-
-
-void
-init_handles(void)
-{
- if (!handle_hash)
- handle_hash = util_hash_table_create(hash_func, compare);
-}
-
-
-void
-free_handles(void)
-{
- /* XXX destroy */
-}
-
-
-VGHandle
-create_handle(void *object)
-{
- VGHandle h = next_handle++;
- util_hash_table_set(handle_hash, intptr_to_pointer(h), object);
- return h;
-}
-
-
-void
-destroy_handle(VGHandle h)
-{
- util_hash_table_remove(handle_hash, intptr_to_pointer(h));
-}
-
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2010 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-
-/**
- * Convert opaque VG object handles into pointers and vice versa.
- * XXX This is not yet 64-bit safe! All VG handles are 32 bits in size.
- */
-
-
-#ifndef HANDLE_H
-#define HANDLE_H
-
-#include "pipe/p_compiler.h"
-#include "util/u_debug.h"
-#include "util/u_hash_table.h"
-#include "util/u_pointer.h"
-
-#include "VG/openvg.h"
-#include "vg_context.h"
-
-
-extern struct util_hash_table *handle_hash;
-
-
-struct vg_mask_layer;
-struct vg_font;
-struct vg_image;
-struct vg_paint;
-struct path;
-
-
-extern void
-init_handles(void);
-
-
-extern void
-free_handles(void);
-
-
-extern VGHandle
-create_handle(void *object);
-
-
-extern void
-destroy_handle(VGHandle h);
-
-
-static INLINE VGHandle
-object_to_handle(struct vg_object *obj)
-{
- return obj ? obj->handle : VG_INVALID_HANDLE;
-}
-
-
-static INLINE VGHandle
-image_to_handle(struct vg_image *img)
-{
- /* vg_image is derived from vg_object */
- return object_to_handle((struct vg_object *) img);
-}
-
-
-static INLINE VGHandle
-masklayer_to_handle(struct vg_mask_layer *mask)
-{
- /* vg_object is derived from vg_object */
- return object_to_handle((struct vg_object *) mask);
-}
-
-
-static INLINE VGHandle
-font_to_handle(struct vg_font *font)
-{
- return object_to_handle((struct vg_object *) font);
-}
-
-
-static INLINE VGHandle
-paint_to_handle(struct vg_paint *paint)
-{
- return object_to_handle((struct vg_object *) paint);
-}
-
-
-static INLINE VGHandle
-path_to_handle(struct path *path)
-{
- return object_to_handle((struct vg_object *) path);
-}
-
-
-static INLINE void *
-handle_to_pointer(VGHandle h)
-{
- void *v = util_hash_table_get(handle_hash, intptr_to_pointer(h));
-#ifdef DEBUG
- if (v) {
- struct vg_object *obj = (struct vg_object *) v;
- assert(obj->handle == h);
- }
-#endif
- return v;
-}
-
-
-static INLINE struct vg_font *
-handle_to_font(VGHandle h)
-{
- return (struct vg_font *) handle_to_pointer(h);
-}
-
-
-static INLINE struct vg_image *
-handle_to_image(VGHandle h)
-{
- return (struct vg_image *) handle_to_pointer(h);
-}
-
-
-static INLINE struct vg_mask_layer *
-handle_to_masklayer(VGHandle h)
-{
- return (struct vg_mask_layer *) handle_to_pointer(h);
-}
-
-
-static INLINE struct vg_object *
-handle_to_object(VGHandle h)
-{
- return (struct vg_object *) handle_to_pointer(h);
-}
-
-
-static INLINE struct vg_paint *
-handle_to_paint(VGHandle h)
-{
- return (struct vg_paint *) handle_to_pointer(h);
-}
-
-
-static INLINE struct path *
-handle_to_path(VGHandle h)
-{
- return (struct path *) handle_to_pointer(h);
-}
-
-
-#endif /* HANDLE_H */
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#include "image.h"
-
-#include "vg_translate.h"
-#include "vg_context.h"
-#include "matrix.h"
-#include "renderer.h"
-#include "util_array.h"
-#include "api_consts.h"
-#include "shader.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_screen.h"
-#include "util/u_inlines.h"
-#include "util/u_format.h"
-#include "util/u_tile.h"
-#include "util/u_memory.h"
-#include "util/u_math.h"
-#include "util/u_sampler.h"
-#include "util/u_surface.h"
-
-static enum pipe_format vg_format_to_pipe(VGImageFormat format)
-{
- switch(format) {
- case VG_sRGB_565:
- return PIPE_FORMAT_B5G6R5_UNORM;
- case VG_sRGBA_5551:
- return PIPE_FORMAT_B5G5R5A1_UNORM;
- case VG_sRGBA_4444:
- return PIPE_FORMAT_B4G4R4A4_UNORM;
- case VG_sL_8:
- case VG_lL_8:
- return PIPE_FORMAT_L8_UNORM;
- case VG_BW_1:
- return PIPE_FORMAT_B8G8R8A8_UNORM;
- case VG_A_8:
- return PIPE_FORMAT_A8_UNORM;
-#ifdef OPENVG_VERSION_1_1
- case VG_A_1:
- case VG_A_4:
- return PIPE_FORMAT_A8_UNORM;
-#endif
- default:
- return PIPE_FORMAT_B8G8R8A8_UNORM;
- }
-}
-
-static INLINE void vg_sync_size(VGfloat *src_loc, VGfloat *dst_loc)
-{
- src_loc[2] = MIN2(src_loc[2], dst_loc[2]);
- src_loc[3] = MIN2(src_loc[3], dst_loc[3]);
- dst_loc[2] = src_loc[2];
- dst_loc[3] = src_loc[3];
-}
-
-static void vg_get_copy_coords(VGfloat *src_loc,
- VGfloat src_width, VGfloat src_height,
- VGfloat *dst_loc,
- VGfloat dst_width, VGfloat dst_height)
-{
- VGfloat dst_bounds[4], src_bounds[4];
- VGfloat src_shift[4], dst_shift[4], shift[4];
-
- dst_bounds[0] = 0.f;
- dst_bounds[1] = 0.f;
- dst_bounds[2] = dst_width;
- dst_bounds[3] = dst_height;
-
- src_bounds[0] = 0.f;
- src_bounds[1] = 0.f;
- src_bounds[2] = src_width;
- src_bounds[3] = src_height;
-
- vg_bound_rect(src_loc, src_bounds, src_shift);
- vg_bound_rect(dst_loc, dst_bounds, dst_shift);
- shift[0] = src_shift[0] - dst_shift[0];
- shift[1] = src_shift[1] - dst_shift[1];
-
- if (shift[0] < 0)
- vg_shift_rectx(src_loc, src_bounds, -shift[0]);
- else
- vg_shift_rectx(dst_loc, dst_bounds, shift[0]);
-
- if (shift[1] < 0)
- vg_shift_recty(src_loc, src_bounds, -shift[1]);
- else
- vg_shift_recty(dst_loc, dst_bounds, shift[1]);
-
- vg_sync_size(src_loc, dst_loc);
-}
-
-static void vg_copy_texture(struct vg_context *ctx,
- struct pipe_resource *dst, VGint dx, VGint dy,
- struct pipe_sampler_view *src, VGint sx, VGint sy,
- VGint width, VGint height)
-{
- VGfloat dst_loc[4], src_loc[4];
-
- dst_loc[0] = dx;
- dst_loc[1] = dy;
- dst_loc[2] = width;
- dst_loc[3] = height;
-
- src_loc[0] = sx;
- src_loc[1] = sy;
- src_loc[2] = width;
- src_loc[3] = height;
-
- vg_get_copy_coords(src_loc, src->texture->width0, src->texture->height0,
- dst_loc, dst->width0, dst->height0);
-
- if (src_loc[2] >= 0 && src_loc[3] >= 0 &&
- dst_loc[2] >= 0 && dst_loc[3] >= 0) {
- struct pipe_surface *surf, surf_tmpl;
-
- /* get the destination surface */
- u_surface_default_template(&surf_tmpl, dst);
- surf = ctx->pipe->create_surface(ctx->pipe, dst, &surf_tmpl);
- if (surf && renderer_copy_begin(ctx->renderer, surf, VG_TRUE, src)) {
- renderer_copy(ctx->renderer,
- dst_loc[0], dst_loc[1], dst_loc[2], dst_loc[3],
- src_loc[0], src_loc[1], src_loc[2], src_loc[3]);
- renderer_copy_end(ctx->renderer);
- }
-
- pipe_surface_reference(&surf, NULL);
- }
-}
-
-void vg_copy_surface(struct vg_context *ctx,
- struct pipe_surface *dst, VGint dx, VGint dy,
- struct pipe_surface *src, VGint sx, VGint sy,
- VGint width, VGint height)
-{
- VGfloat dst_loc[4], src_loc[4];
-
- dst_loc[0] = dx;
- dst_loc[1] = dy;
- dst_loc[2] = width;
- dst_loc[3] = height;
-
- src_loc[0] = sx;
- src_loc[1] = sy;
- src_loc[2] = width;
- src_loc[3] = height;
-
- vg_get_copy_coords(src_loc, src->width, src->height,
- dst_loc, dst->width, dst->height);
-
- if (src_loc[2] > 0 && src_loc[3] > 0 &&
- dst_loc[2] > 0 && dst_loc[3] > 0) {
- if (src == dst)
- renderer_copy_surface(ctx->renderer,
- src,
- src_loc[0],
- src->height - (src_loc[1] + src_loc[3]),
- src_loc[0] + src_loc[2],
- src->height - src_loc[1],
- dst,
- dst_loc[0],
- dst->height - (dst_loc[1] + dst_loc[3]),
- dst_loc[0] + dst_loc[2],
- dst->height - dst_loc[1],
- 0, 0);
- else
- renderer_copy_surface(ctx->renderer,
- src,
- src_loc[0],
- src->height - src_loc[1],
- src_loc[0] + src_loc[2],
- src->height - (src_loc[1] + src_loc[3]),
- dst,
- dst_loc[0],
- dst->height - (dst_loc[1] + dst_loc[3]),
- dst_loc[0] + dst_loc[2],
- dst->height - dst_loc[1],
- 0, 0);
- }
-
-}
-
-static struct pipe_resource *image_texture(struct vg_image *img)
-{
- struct pipe_resource *tex = img->sampler_view->texture;
- return tex;
-}
-
-
-static void image_cleari(struct vg_image *img, VGint clear_colori,
- VGint x, VGint y, VGint width, VGint height)
-{
- VGint *clearbuf;
- VGint i;
- VGfloat dwidth, dheight;
-
- clearbuf = malloc(sizeof(VGint)*width*height);
- for (i = 0; i < width*height; ++i)
- clearbuf[i] = clear_colori;
-
- dwidth = MIN2(width, img->width);
- dheight = MIN2(height, img->height);
-
- image_sub_data(img, clearbuf, width * sizeof(VGint),
- VG_sRGBA_8888,
- x, y, dwidth, dheight);
- free(clearbuf);
-}
-
-struct vg_image * image_create(VGImageFormat format,
- VGint width, VGint height)
-{
- struct vg_context *ctx = vg_current_context();
- struct pipe_context *pipe = ctx->pipe;
- struct vg_image *image = CALLOC_STRUCT(vg_image);
- enum pipe_format pformat = vg_format_to_pipe(format);
- struct pipe_resource pt, *newtex;
- struct pipe_sampler_view view_templ;
- struct pipe_sampler_view *view;
- struct pipe_screen *screen = ctx->pipe->screen;
-
- vg_init_object(&image->base, ctx, VG_OBJECT_IMAGE);
-
- image->format = format;
- image->width = width;
- image->height = height;
-
- image->sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
- image->sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
- image->sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
- image->sampler.min_img_filter = PIPE_TEX_MIPFILTER_NEAREST;
- image->sampler.mag_img_filter = PIPE_TEX_MIPFILTER_NEAREST;
- image->sampler.normalized_coords = 1;
-
- assert(screen->is_format_supported(screen, pformat, PIPE_TEXTURE_2D,
- 0, PIPE_BIND_SAMPLER_VIEW));
-
- memset(&pt, 0, sizeof(pt));
- pt.target = PIPE_TEXTURE_2D;
- pt.format = pformat;
- pt.last_level = 0;
- pt.width0 = width;
- pt.height0 = height;
- pt.depth0 = 1;
- pt.array_size = 1;
- pt.bind = PIPE_BIND_SAMPLER_VIEW;
-
- newtex = screen->resource_create(screen, &pt);
-
- debug_assert(newtex);
-
- u_sampler_view_default_template(&view_templ, newtex, newtex->format);
- /* R, G, and B are treated as 1.0 for alpha-only formats in OpenVG */
- if (newtex->format == PIPE_FORMAT_A8_UNORM) {
- view_templ.swizzle_r = PIPE_SWIZZLE_ONE;
- view_templ.swizzle_g = PIPE_SWIZZLE_ONE;
- view_templ.swizzle_b = PIPE_SWIZZLE_ONE;
- }
-
- view = pipe->create_sampler_view(pipe, newtex, &view_templ);
- /* want the texture to go away if the view is freed */
- pipe_resource_reference(&newtex, NULL);
-
- image->sampler_view = view;
-
- vg_context_add_object(ctx, &image->base);
-
- image_cleari(image, 0, 0, 0, image->width, image->height);
- return image;
-}
-
-void image_destroy(struct vg_image *img)
-{
- struct vg_context *ctx = vg_current_context();
- vg_context_remove_object(ctx, &img->base);
-
-
- if (img->parent) {
- /* remove img from the parent child array */
- int idx;
- struct vg_image **array =
- (struct vg_image **)img->parent->children_array->data;
-
- for (idx = 0; idx < img->parent->children_array->num_elements; ++idx) {
- struct vg_image *child = array[idx];
- if (child == img) {
- break;
- }
- }
- debug_assert(idx < img->parent->children_array->num_elements);
- array_remove_element(img->parent->children_array, idx);
- }
-
- if (img->children_array && img->children_array->num_elements) {
- /* reparent the children */
- VGint i;
- struct vg_image *parent = img->parent;
- struct vg_image **children =
- (struct vg_image **)img->children_array->data;
- if (!parent) {
- VGint min_x = children[0]->x;
- parent = children[0];
-
- for (i = 1; i < img->children_array->num_elements; ++i) {
- struct vg_image *child = children[i];
- if (child->x < min_x) {
- parent = child;
- }
- }
- }
-
- for (i = 0; i < img->children_array->num_elements; ++i) {
- struct vg_image *child = children[i];
- if (child != parent) {
- child->parent = parent;
- if (!parent->children_array) {
- parent->children_array = array_create(
- sizeof(struct vg_image*));
- }
- array_append_data(parent->children_array,
- &child, 1);
- } else
- child->parent = NULL;
- }
- array_destroy(img->children_array);
- }
-
- vg_free_object(&img->base);
-
- pipe_sampler_view_reference(&img->sampler_view, NULL);
- FREE(img);
-}
-
-void image_clear(struct vg_image *img,
- VGint x, VGint y, VGint width, VGint height)
-{
- struct vg_context *ctx = vg_current_context();
- VGfloat *clear_colorf = ctx->state.vg.clear_color;
- VGubyte r, g, b ,a;
- VGint clear_colori;
- /* FIXME: this is very nasty */
- r = float_to_ubyte(clear_colorf[0]);
- g = float_to_ubyte(clear_colorf[1]);
- b = float_to_ubyte(clear_colorf[2]);
- a = float_to_ubyte(clear_colorf[3]);
- clear_colori = r << 24 | g << 16 | b << 8 | a;
- image_cleari(img, clear_colori, x, y, width, height);
-}
-
-void image_sub_data(struct vg_image *image,
- const void * data,
- VGint dataStride,
- VGImageFormat dataFormat,
- VGint x, VGint y,
- VGint width, VGint height)
-{
- const VGint yStep = 1;
- VGubyte *src = (VGubyte *)data;
- VGfloat temp[VEGA_MAX_IMAGE_WIDTH][4];
- VGfloat *df = (VGfloat*)temp;
- VGint i;
- struct vg_context *ctx = vg_current_context();
- struct pipe_context *pipe = ctx->pipe;
- struct pipe_resource *texture = image_texture(image);
- VGint xoffset = 0, yoffset = 0;
-
- if (x < 0) {
- xoffset -= x;
- width += x;
- x = 0;
- }
- if (y < 0) {
- yoffset -= y;
- height += y;
- y = 0;
- }
-
- if (width <= 0 || height <= 0) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- if (x > image->width || y > image->width) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- if (x + width > image->width) {
- width = image->width - x;
- }
-
- if (y + height > image->height) {
- height = image->height - y;
- }
-
- { /* upload color_data */
- struct pipe_transfer *transfer;
- void *map = pipe_transfer_map(pipe, texture, 0, 0,
- PIPE_TRANSFER_WRITE, 0, 0,
- texture->width0, texture->height0,
- &transfer);
- src += (dataStride * yoffset);
- for (i = 0; i < height; i++) {
- _vega_unpack_float_span_rgba(ctx, width, xoffset, src, dataFormat, temp);
- pipe_put_tile_rgba(transfer, map, x+image->x, y+image->y, width, 1, df);
- y += yStep;
- src += dataStride;
- }
- pipe->transfer_unmap(pipe, transfer);
- }
-}
-
-void image_get_sub_data(struct vg_image * image,
- void * data,
- VGint dataStride,
- VGImageFormat dataFormat,
- VGint sx, VGint sy,
- VGint width, VGint height)
-{
- struct vg_context *ctx = vg_current_context();
- struct pipe_context *pipe = ctx->pipe;
- VGfloat temp[VEGA_MAX_IMAGE_WIDTH][4];
- VGfloat *df = (VGfloat*)temp;
- VGint y = 0, yStep = 1;
- VGint i;
- VGubyte *dst = (VGubyte *)data;
-
- {
- struct pipe_transfer *transfer;
- void *map =
- pipe_transfer_map(pipe,
- image->sampler_view->texture, 0, 0,
- PIPE_TRANSFER_READ,
- 0, 0,
- image->x + image->width,
- image->y + image->height, &transfer);
- /* Do a row at a time to flip image data vertically */
- for (i = 0; i < height; i++) {
-#if 0
- debug_printf("%d-%d == %d\n", sy, height, y);
-#endif
- pipe_get_tile_rgba(transfer, map, sx+image->x, y, width, 1, df);
- y += yStep;
- _vega_pack_rgba_span_float(ctx, width, temp, dataFormat, dst);
- dst += dataStride;
- }
-
- pipe->transfer_unmap(pipe, transfer);
- }
-}
-
-struct vg_image * image_child_image(struct vg_image *parent,
- VGint x, VGint y,
- VGint width, VGint height)
-{
- struct vg_context *ctx = vg_current_context();
- struct vg_image *image = CALLOC_STRUCT(vg_image);
-
- vg_init_object(&image->base, ctx, VG_OBJECT_IMAGE);
-
- image->x = parent->x + x;
- image->y = parent->y + y;
- image->width = width;
- image->height = height;
- image->parent = parent;
- image->sampler_view = NULL;
- pipe_sampler_view_reference(&image->sampler_view,
- parent->sampler_view);
-
- image->sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
- image->sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
- image->sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
- image->sampler.min_img_filter = PIPE_TEX_MIPFILTER_NEAREST;
- image->sampler.mag_img_filter = PIPE_TEX_MIPFILTER_NEAREST;
- image->sampler.normalized_coords = 1;
-
- if (!parent->children_array)
- parent->children_array = array_create(
- sizeof(struct vg_image*));
-
- array_append_data(parent->children_array,
- &image, 1);
-
- vg_context_add_object(ctx, &image->base);
-
- return image;
-}
-
-void image_copy(struct vg_image *dst, VGint dx, VGint dy,
- struct vg_image *src, VGint sx, VGint sy,
- VGint width, VGint height,
- VGboolean dither)
-{
- struct vg_context *ctx = vg_current_context();
-
- if (width <= 0 || height <= 0) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
- vg_copy_texture(ctx, dst->sampler_view->texture, dst->x + dx, dst->y + dy,
- src->sampler_view, src->x + sx, src->y + sy, width, height);
-}
-
-void image_draw(struct vg_image *img, struct matrix *matrix)
-{
- struct vg_context *ctx = vg_current_context();
- struct matrix paint_matrix;
- VGfloat x1, y1;
- VGfloat x2, y2;
- VGfloat x3, y3;
- VGfloat x4, y4;
-
- if (!vg_get_paint_matrix(ctx,
- &ctx->state.vg.fill_paint_to_user_matrix,
- matrix,
- &paint_matrix))
- return;
-
- x1 = 0;
- y1 = 0;
- x2 = img->width;
- y2 = 0;
- x3 = img->width;
- y3 = img->height;
- x4 = 0;
- y4 = img->height;
-
- shader_set_surface_matrix(ctx->shader, matrix);
- shader_set_drawing_image(ctx->shader, VG_TRUE);
- shader_set_paint(ctx->shader, ctx->state.vg.fill_paint);
- shader_set_paint_matrix(ctx->shader, &paint_matrix);
- shader_set_image(ctx->shader, img);
- shader_bind(ctx->shader);
-
- renderer_texture_quad(ctx->renderer, image_texture(img),
- img->x, img->y, img->x + img->width, img->y + img->height,
- x1, y1, x2, y2, x3, y3, x4, y4);
-}
-
-void image_set_pixels(VGint dx, VGint dy,
- struct vg_image *src, VGint sx, VGint sy,
- VGint width, VGint height)
-{
- struct vg_context *ctx = vg_current_context();
- struct pipe_context *pipe = ctx->pipe;
- struct pipe_surface *surf, surf_tmpl;
- struct st_renderbuffer *strb = ctx->draw_buffer->strb;
-
- u_surface_default_template(&surf_tmpl, image_texture(src));
- surf = pipe->create_surface(pipe, image_texture(src), &surf_tmpl);
-
- vg_copy_surface(ctx, strb->surface, dx, dy,
- surf, sx+src->x, sy+src->y, width, height);
-
- pipe->surface_destroy(pipe, surf);
-}
-
-void image_get_pixels(struct vg_image *dst, VGint dx, VGint dy,
- VGint sx, VGint sy,
- VGint width, VGint height)
-{
- struct vg_context *ctx = vg_current_context();
- struct pipe_context *pipe = ctx->pipe;
- struct pipe_surface *surf, surf_tmpl;
- struct st_renderbuffer *strb = ctx->draw_buffer->strb;
-
- /* flip the y coordinates */
- /*dy = dst->height - dy - height;*/
-
- u_surface_default_template(&surf_tmpl, image_texture(dst));
- surf = pipe->create_surface(pipe, image_texture(dst), &surf_tmpl);
-
- vg_copy_surface(ctx, surf, dst->x + dx, dst->y + dy,
- strb->surface, sx, sy, width, height);
-
- pipe_surface_reference(&surf, NULL);
-}
-
-
-VGboolean vg_image_overlaps(struct vg_image *dst,
- struct vg_image *src)
-{
- if (dst == src || dst->parent == src ||
- dst == src->parent)
- return VG_TRUE;
- if (dst->parent && dst->parent == src->parent) {
- VGfloat left1 = dst->x;
- VGfloat left2 = src->x;
- VGfloat right1 = dst->x + dst->width;
- VGfloat right2 = src->x + src->width;
- VGfloat bottom1 = dst->y;
- VGfloat bottom2 = src->y;
- VGfloat top1 = dst->y + dst->height;
- VGfloat top2 = src->y + src->height;
-
- return !(left2 > right1 || right2 < left1 ||
- top2 > bottom1 || bottom2 < top1);
- }
- return VG_FALSE;
-}
-
-VGint image_bind_samplers(struct vg_image *img, struct pipe_sampler_state **samplers,
- struct pipe_sampler_view **sampler_views)
-{
- img->sampler.min_img_filter = image_sampler_filter(img->base.ctx);
- img->sampler.mag_img_filter = image_sampler_filter(img->base.ctx);
- samplers[3] = &img->sampler;
- sampler_views[3] = img->sampler_view;
- return 1;
-}
-
-VGint image_sampler_filter(struct vg_context *ctx)
-{
- switch(ctx->state.vg.image_quality) {
- case VG_IMAGE_QUALITY_NONANTIALIASED:
- return PIPE_TEX_FILTER_NEAREST;
- break;
- case VG_IMAGE_QUALITY_FASTER:
- return PIPE_TEX_FILTER_NEAREST;
- break;
- case VG_IMAGE_QUALITY_BETTER:
- /* possibly use anisotropic filtering */
- return PIPE_TEX_FILTER_LINEAR;
- break;
- default:
- debug_printf("Unknown image quality");
- }
- return PIPE_TEX_FILTER_NEAREST;
-}
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#ifndef IMAGES_H
-#define IMAGES_H
-
-#include "vg_context.h"
-#include "pipe/p_state.h"
-
-struct pipe_resource;
-struct array;
-struct vg_context;
-struct pipe_surface;
-
-struct vg_image {
- struct vg_object base;
- VGImageFormat format;
- VGint x, y;
- VGint width, height;
-
- struct vg_image *parent;
-
- struct pipe_sampler_view *sampler_view;
- struct pipe_sampler_state sampler;
-
- struct array *children_array;
-};
-
-struct vg_image *image_create(VGImageFormat format,
- VGint width, VGint height);
-void image_destroy(struct vg_image *img);
-
-void image_clear(struct vg_image *img,
- VGint x, VGint y, VGint width, VGint height);
-
-void image_sub_data(struct vg_image *image,
- const void * data,
- VGint dataStride,
- VGImageFormat dataFormat,
- VGint x, VGint y,
- VGint width, VGint height);
-
-void image_get_sub_data(struct vg_image * image,
- void * data,
- VGint dataStride,
- VGImageFormat dataFormat,
- VGint x, VGint y,
- VGint width, VGint height);
-
-struct vg_image *image_child_image(struct vg_image *parent,
- VGint x, VGint y,
- VGint width, VGint height);
-
-void image_copy(struct vg_image *dst, VGint dx, VGint dy,
- struct vg_image *src, VGint sx, VGint sy,
- VGint width, VGint height,
- VGboolean dither);
-
-void image_draw(struct vg_image *img, struct matrix *matrix);
-
-void image_set_pixels(VGint dx, VGint dy,
- struct vg_image *src, VGint sx, VGint sy,
- VGint width, VGint height);
-void image_get_pixels(struct vg_image *dst, VGint dx, VGint dy,
- VGint sx, VGint sy,
- VGint width, VGint height);
-
-VGint image_bind_samplers(struct vg_image *dst, struct pipe_sampler_state **samplers,
- struct pipe_sampler_view **sampler_views);
-
-VGboolean vg_image_overlaps(struct vg_image *dst,
- struct vg_image *src);
-
-VGint image_sampler_filter(struct vg_context *ctx);
-
-void vg_copy_surface(struct vg_context *ctx,
- struct pipe_surface *dst, VGint dx, VGint dy,
- struct pipe_surface *src, VGint sx, VGint sy,
- VGint width, VGint height);
-
-#endif
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#include "mask.h"
-
-#include "path.h"
-#include "image.h"
-#include "shaders_cache.h"
-#include "renderer.h"
-#include "asm_util.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_screen.h"
-#include "util/u_inlines.h"
-#include "util/u_format.h"
-#include "util/u_memory.h"
-#include "util/u_surface.h"
-#include "util/u_sampler.h"
-
-struct vg_mask_layer {
- struct vg_object base;
-
- VGint width;
- VGint height;
-
- struct pipe_sampler_view *sampler_view;
-};
-
-static INLINE VGboolean
-intersect_rectangles(VGint dwidth, VGint dheight,
- VGint swidth, VGint sheight,
- VGint tx, VGint ty,
- VGint twidth, VGint theight,
- VGint *offsets,
- VGint *location)
-{
- if (tx + twidth <= 0 || tx >= dwidth)
- return VG_FALSE;
- if (ty + theight <= 0 || ty >= dheight)
- return VG_FALSE;
-
- offsets[0] = 0;
- offsets[1] = 0;
- location[0] = tx;
- location[1] = ty;
-
- if (tx < 0) {
- offsets[0] -= tx;
- location[0] = 0;
-
- location[2] = MIN2(tx + swidth, MIN2(dwidth, tx + twidth));
- offsets[2] = location[2];
- } else {
- offsets[2] = MIN2(twidth, MIN2(dwidth - tx, swidth ));
- location[2] = offsets[2];
- }
-
- if (ty < 0) {
- offsets[1] -= ty;
- location[1] = 0;
-
- location[3] = MIN2(ty + sheight, MIN2(dheight, ty + theight));
- offsets[3] = location[3];
- } else {
- offsets[3] = MIN2(theight, MIN2(dheight - ty, sheight));
- location[3] = offsets[3];
- }
-
- return VG_TRUE;
-}
-
-#if DEBUG_MASKS
-static void read_alpha_mask(void * data, VGint dataStride,
- VGImageFormat dataFormat,
- VGint sx, VGint sy,
- VGint width, VGint height)
-{
- struct vg_context *ctx = vg_current_context();
- struct pipe_context *pipe = ctx->pipe;
-
- struct st_framebuffer *stfb = ctx->draw_buffer;
- struct st_renderbuffer *strb = stfb->alpha_mask;
-
- VGfloat temp[VEGA_MAX_IMAGE_WIDTH][4];
- VGfloat *df = (VGfloat*)temp;
- VGint y = (stfb->height - sy) - 1, yStep = -1;
- VGint i;
- VGubyte *dst = (VGubyte *)data;
- VGint xoffset = 0, yoffset = 0;
-
- if (sx < 0) {
- xoffset = -sx;
- xoffset *= _vega_size_for_format(dataFormat);
- width += sx;
- sx = 0;
- }
- if (sy < 0) {
- yoffset = -sy;
- height += sy;
- sy = 0;
- y = (stfb->height - sy) - 1;
- yoffset *= dataStride;
- }
-
- {
- struct pipe_surface *surf;
-
- surf = pipe->create_surface(pipe, strb->texture, 0, 0, 0,
- PIPE_BIND_TRANSFER_READ);
-
- /* Do a row at a time to flip image data vertically */
- for (i = 0; i < height; i++) {
-#if 0
- debug_printf("%d-%d == %d\n", sy, height, y);
-#endif
- pipe_get_tile_rgba(surf, sx, y, width, 1, df);
- y += yStep;
- _vega_pack_rgba_span_float(ctx, width, temp, dataFormat,
- dst + yoffset + xoffset);
- dst += dataStride;
- }
-
- pipe_surface_reference(&surf, NULL);
- }
-}
-
-void save_alpha_to_file(const char *filename)
-{
- struct vg_context *ctx = vg_current_context();
- struct st_framebuffer *stfb = ctx->draw_buffer;
- VGint *data;
- int i, j;
-
- data = malloc(sizeof(int) * stfb->width * stfb->height);
- read_alpha_mask(data, stfb->width * sizeof(int),
- VG_sRGBA_8888,
- 0, 0, stfb->width, stfb->height);
- fprintf(stderr, "/*---------- start */\n");
- fprintf(stderr, "const int image_width = %d;\n",
- stfb->width);
- fprintf(stderr, "const int image_height = %d;\n",
- stfb->height);
- fprintf(stderr, "const int image_data = {\n");
- for (i = 0; i < stfb->height; ++i) {
- for (j = 0; j < stfb->width; ++j) {
- int rgba = data[i * stfb->height + j];
- int argb = 0;
- argb = (rgba >> 8);
- argb |= ((rgba & 0xff) << 24);
- fprintf(stderr, "0x%x, ", argb);
- }
- fprintf(stderr, "\n");
- }
- fprintf(stderr, "};\n");
- fprintf(stderr, "/*---------- end */\n");
-}
-#endif
-
-/* setup mask shader */
-static void *setup_mask_operation(VGMaskOperation operation)
-{
- struct vg_context *ctx = vg_current_context();
- void *shader = 0;
-
- switch (operation) {
- case VG_UNION_MASK: {
- if (!ctx->mask.union_fs) {
- ctx->mask.union_fs = shader_create_from_text(ctx->pipe,
- union_mask_asm,
- 200,
- PIPE_SHADER_FRAGMENT);
- }
- shader = ctx->mask.union_fs->driver;
- }
- break;
- case VG_INTERSECT_MASK: {
- if (!ctx->mask.intersect_fs) {
- ctx->mask.intersect_fs = shader_create_from_text(ctx->pipe,
- intersect_mask_asm,
- 200,
- PIPE_SHADER_FRAGMENT);
- }
- shader = ctx->mask.intersect_fs->driver;
- }
- break;
- case VG_SUBTRACT_MASK: {
- if (!ctx->mask.subtract_fs) {
- ctx->mask.subtract_fs = shader_create_from_text(ctx->pipe,
- subtract_mask_asm,
- 200,
- PIPE_SHADER_FRAGMENT);
- }
- shader = ctx->mask.subtract_fs->driver;
- }
- break;
- case VG_SET_MASK: {
- if (!ctx->mask.set_fs) {
- ctx->mask.set_fs = shader_create_from_text(ctx->pipe,
- set_mask_asm,
- 200,
- PIPE_SHADER_FRAGMENT);
- }
- shader = ctx->mask.set_fs->driver;
- }
- break;
- default:
- assert(0);
- break;
- }
-
- return shader;
-}
-
-static void mask_resource_fill(struct pipe_resource *dst,
- int x, int y, int width, int height,
- VGfloat coverage)
-{
- struct vg_context *ctx = vg_current_context();
- VGfloat fs_consts[12] = {
- 0.0f, 0.0f, 0.0f, 0.0f, /* not used */
- 0.0f, 0.0f, 0.0f, 0.0f, /* not used */
- 0.0f, 0.0f, 0.0f, coverage /* color */
- };
- void *fs;
-
- if (x < 0) {
- width += x;
- x = 0;
- }
- if (y < 0) {
- height += y;
- y = 0;
- }
-
- fs = shaders_cache_fill(ctx->sc, VEGA_SOLID_FILL_SHADER);
-
- if (renderer_filter_begin(ctx->renderer, dst, VG_FALSE, ~0,
- NULL, NULL, 0, fs, (const void *) fs_consts, sizeof(fs_consts))) {
- renderer_filter(ctx->renderer, x, y, width, height, 0, 0, 0, 0);
- renderer_filter_end(ctx->renderer);
- }
-
-#if DEBUG_MASKS
- save_alpha_to_file(0);
-#endif
-}
-
-
-static void mask_using_texture(struct pipe_sampler_view *sampler_view,
- VGboolean is_layer,
- VGMaskOperation operation,
- VGint x, VGint y,
- VGint width, VGint height)
-{
- struct vg_context *ctx = vg_current_context();
- struct pipe_sampler_view *dst_view = vg_get_surface_mask(ctx);
- struct pipe_resource *dst = dst_view->texture;
- struct pipe_resource *texture = sampler_view->texture;
- const struct pipe_sampler_state *samplers[2];
- struct pipe_sampler_view *views[2];
- struct pipe_sampler_state sampler;
- VGint offsets[4], loc[4];
- const VGfloat ones[4] = {1.f, 1.f, 1.f, 1.f};
- void *fs;
-
- if (!intersect_rectangles(dst->width0, dst->height0,
- texture->width0, texture->height0,
- x, y, width, height,
- offsets, loc))
- return;
-#if 0
- debug_printf("Offset = [%d, %d, %d, %d]\n", offsets[0],
- offsets[1], offsets[2], offsets[3]);
- debug_printf("Locati = [%d, %d, %d, %d]\n", loc[0],
- loc[1], loc[2], loc[3]);
-#endif
-
-
- sampler = ctx->mask.sampler;
- sampler.normalized_coords = 1;
- samplers[0] = &sampler;
- views[0] = sampler_view;
-
- /* prepare our blend surface */
- samplers[1] = &ctx->mask.sampler;
- views[1] = vg_prepare_blend_surface_from_mask(ctx);
-
- fs = setup_mask_operation(operation);
-
- if (renderer_filter_begin(ctx->renderer, dst, VG_FALSE,
- ~0, samplers, views, 2, fs, (const void *) ones, sizeof(ones))) {
- /* layer should be flipped when used as a texture */
- if (is_layer) {
- offsets[1] += offsets[3];
- offsets[3] = -offsets[3];
- }
- renderer_filter(ctx->renderer,
- loc[0], loc[1], loc[2], loc[3],
- offsets[0], offsets[1], offsets[2], offsets[3]);
- renderer_filter_end(ctx->renderer);
- }
-}
-
-
-#ifdef OPENVG_VERSION_1_1
-
-struct vg_mask_layer * mask_layer_create(VGint width, VGint height)
-{
- struct vg_context *ctx = vg_current_context();
- struct vg_mask_layer *mask = 0;
-
- mask = CALLOC_STRUCT(vg_mask_layer);
- vg_init_object(&mask->base, ctx, VG_OBJECT_MASK);
- mask->width = width;
- mask->height = height;
-
- {
- struct pipe_resource pt;
- struct pipe_context *pipe = ctx->pipe;
- struct pipe_screen *screen = ctx->pipe->screen;
- struct pipe_sampler_view view_templ;
- struct pipe_sampler_view *view = NULL;
- struct pipe_resource *texture;
-
- memset(&pt, 0, sizeof(pt));
- pt.target = PIPE_TEXTURE_2D;
- pt.format = PIPE_FORMAT_B8G8R8A8_UNORM;
- pt.last_level = 0;
- pt.width0 = width;
- pt.height0 = height;
- pt.depth0 = 1;
- pt.array_size = 1;
- pt.bind = PIPE_BIND_SAMPLER_VIEW;
-
- texture = screen->resource_create(screen, &pt);
-
- if (texture) {
- u_sampler_view_default_template(&view_templ, texture, texture->format);
- view = pipe->create_sampler_view(pipe, texture, &view_templ);
- }
- pipe_resource_reference(&texture, NULL);
- mask->sampler_view = view;
- }
-
- vg_context_add_object(ctx, &mask->base);
-
- return mask;
-}
-
-void mask_layer_destroy(struct vg_mask_layer *layer)
-{
- struct vg_context *ctx = vg_current_context();
-
- vg_context_remove_object(ctx, &layer->base);
- pipe_sampler_view_reference(&layer->sampler_view, NULL);
- vg_free_object(&layer->base);
- FREE(layer);
-}
-
-void mask_layer_fill(struct vg_mask_layer *layer,
- VGint x, VGint y,
- VGint width, VGint height,
- VGfloat value)
-{
- mask_resource_fill(layer->sampler_view->texture,
- x, y, width, height, value);
-}
-
-void mask_copy(struct vg_mask_layer *layer,
- VGint sx, VGint sy,
- VGint dx, VGint dy,
- VGint width, VGint height)
-{
- struct vg_context *ctx = vg_current_context();
- struct pipe_sampler_view *src = vg_get_surface_mask(ctx);
- struct pipe_surface *surf, surf_tmpl;
-
- /* get the destination surface */
- u_surface_default_template(&surf_tmpl, layer->sampler_view->texture);
- surf = ctx->pipe->create_surface(ctx->pipe, layer->sampler_view->texture,
- &surf_tmpl);
- if (surf && renderer_copy_begin(ctx->renderer, surf, VG_FALSE, src)) {
- /* layer should be flipped when used as a texture */
- sy += height;
- height = -height;
-
- renderer_copy(ctx->renderer,
- dx, dy, width, height,
- sx, sy, width, height);
- renderer_copy_end(ctx->renderer);
- }
-
- pipe_surface_reference(&surf, NULL);
-}
-
-static void mask_layer_render_to(struct vg_mask_layer *layer,
- struct path *path,
- VGbitfield paint_modes)
-{
- struct vg_context *ctx = vg_current_context();
- struct pipe_context *pipe = ctx->pipe;
- struct pipe_sampler_view *view = vg_get_surface_mask(ctx);
- struct matrix *mat = &ctx->state.vg.path_user_to_surface_matrix;
- struct pipe_surface *surf, surf_tmpl;
- u_surface_default_template(&surf_tmpl, view->texture);
- surf = pipe->create_surface(pipe, view->texture, &surf_tmpl);
-
- renderer_validate_for_mask_rendering(ctx->renderer, surf, mat);
-
- if (paint_modes & VG_FILL_PATH) {
- path_fill(path);
- }
-
- if (paint_modes & VG_STROKE_PATH){
- path_stroke(path);
- }
-
- pipe_surface_reference(&surf, NULL);
-}
-
-void mask_render_to(struct path *path,
- VGbitfield paint_modes,
- VGMaskOperation operation)
-{
- struct vg_context *ctx = vg_current_context();
- struct st_framebuffer *stfb = ctx->draw_buffer;
- struct vg_mask_layer *temp_layer;
- VGint width, height;
-
- width = stfb->width;
- height = stfb->height;
-
- temp_layer = mask_layer_create(width, height);
- mask_layer_fill(temp_layer, 0, 0, width, height, 0.0f);
-
- mask_layer_render_to(temp_layer, path, paint_modes);
-
- mask_using_layer(temp_layer, operation, 0, 0, width, height);
-
- mask_layer_destroy(temp_layer);
-}
-
-void mask_using_layer(struct vg_mask_layer *layer,
- VGMaskOperation operation,
- VGint x, VGint y,
- VGint width, VGint height)
-{
- mask_using_texture(layer->sampler_view, VG_TRUE, operation,
- x, y, width, height);
-}
-
-VGint mask_layer_width(struct vg_mask_layer *layer)
-{
- return layer->width;
-}
-
-VGint mask_layer_height(struct vg_mask_layer *layer)
-{
- return layer->height;
-}
-
-
-#endif
-
-void mask_using_image(struct vg_image *image,
- VGMaskOperation operation,
- VGint x, VGint y,
- VGint width, VGint height)
-{
- mask_using_texture(image->sampler_view, VG_FALSE, operation,
- x, y, width, height);
-}
-
-void mask_fill(VGint x, VGint y, VGint width, VGint height,
- VGfloat value)
-{
- struct vg_context *ctx = vg_current_context();
- struct pipe_sampler_view *view = vg_get_surface_mask(ctx);
-
-#if DEBUG_MASKS
- debug_printf("mask_fill(%d, %d, %d, %d) with rgba(%f, %f, %f, %f)\n",
- x, y, width, height,
- 0.0f, 0.0f, 0.0f, value);
-#endif
-
- mask_resource_fill(view->texture, x, y, width, height, value);
-}
-
-VGint mask_bind_samplers(struct pipe_sampler_state **samplers,
- struct pipe_sampler_view **sampler_views)
-{
- struct vg_context *ctx = vg_current_context();
-
- if (ctx->state.vg.masking) {
- samplers[1] = &ctx->mask.sampler;
- sampler_views[1] = vg_get_surface_mask(ctx);
- return 1;
- } else
- return 0;
-}
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#ifndef MASK_H
-#define MASK_H
-
-#include "vg_context.h"
-
-struct path;
-struct vg_image;
-struct pipe_resource;
-
-struct vg_mask_layer *mask_layer_create(VGint width, VGint height);
-void mask_layer_destroy(struct vg_mask_layer *layer);
-void mask_layer_fill(struct vg_mask_layer *layer,
- VGint x, VGint y,
- VGint width, VGint height,
- VGfloat value);
-VGint mask_layer_width(struct vg_mask_layer *layer);
-VGint mask_layer_height(struct vg_mask_layer *layer);
-void mask_copy(struct vg_mask_layer *layer,
- VGint sx, VGint sy,
- VGint dx, VGint dy,
- VGint width, VGint height);
-
-void mask_render_to(struct path *path,
- VGbitfield paint_modes,
- VGMaskOperation operation);
-
-void mask_using_layer(struct vg_mask_layer *layer,
- VGMaskOperation operation,
- VGint x, VGint y,
- VGint width, VGint height);
-void mask_using_image(struct vg_image *image,
- VGMaskOperation operation,
- VGint x, VGint y,
- VGint width, VGint height);
-void mask_fill(VGint x, VGint y,
- VGint width, VGint height,
- VGfloat value);
-
-VGint mask_bind_samplers(struct pipe_sampler_state **samplers,
- struct pipe_sampler_view **sampler_views);
-
-#endif
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#ifndef MATRIX_H
-#define MATRIX_H
-
-#include "VG/openvg.h"
-
-#include "pipe/p_compiler.h"
-#include "util/u_math.h"
-
-#include <stdio.h>
-#include <math.h>
-
-#define floatsEqual(x, y) (fabs(x - y) <= 0.00001f * MIN2(fabs(x), fabs(y)))
-#define floatIsZero(x) (floatsEqual((x) + 1, 1))
-#define ABS(x) (fabsf(x))
-
-#define DEGREES_TO_RADIANS(d) (0.0174532925199 * (d))
-#define FLT_TO_INT(flt) float_to_int_floor(((VGuint*)&(flt))[0])
-
-static INLINE VGint float_to_int_floor(VGuint bits)
-{
- int sign = (bits >> 31) ? -1 : 1;
- int exp = ((bits >> 23) & 255) - 127;
- int mant = bits & 0x007fffff;
- int sh = 23 - exp;
-
- /* abs(value) >= 2^31 -> clamp. */
-
- if (exp >= 31)
- return (VGint)((sign < 0) ? 0x80000000u : 0x7fffffffu);
-
- /* abs(value) < 1 -> return -1 or 0. */
-
- if (exp < 0)
- return (sign < 0 && (exp > -127 || mant != 0)) ? -1 : 0;
-
- /* abs(value) >= 2^23 -> shift left. */
-
- mant |= 0x00800000;
- if (sh <= 0)
- return sign * (mant << -sh);
-
- /* Negative -> add a rounding term. */
-
- if (sign < 0)
- mant += (1 << sh) - 1;
-
- /* Shift right to obtain the result. */
-
- return sign * (mant >> sh);
-}
-
-
-struct matrix {
- VGfloat m[9];
-};
-
-static INLINE void matrix_init(struct matrix *mat,
- const VGfloat *val)
-{
- memcpy(mat->m, val, sizeof(VGfloat) * 9);
-}
-
-static INLINE void matrix_inits(struct matrix *mat,
- VGfloat m11, VGfloat m12, VGfloat m13,
- VGfloat m21, VGfloat m22, VGfloat m23,
- VGfloat m31, VGfloat m32, VGfloat m33)
-{
- mat->m[0] = m11; mat->m[1] = m12; mat->m[2] = m13;
- mat->m[3] = m21; mat->m[4] = m22; mat->m[5] = m23;
- mat->m[6] = m31; mat->m[7] = m32; mat->m[8] = m33;
-}
-
-static INLINE void matrix_load_identity(struct matrix *matrix)
-{
- static const VGfloat identity[9] = {1.f, 0.f, 0.f,
- 0.f, 1.f, 0.f,
- 0.f, 0.f, 1.f};
- memcpy(matrix->m, identity, sizeof(identity));
-}
-
-static INLINE VGboolean matrix_is_identity(struct matrix *matrix)
-{
- return floatsEqual(matrix->m[0], 1) && floatIsZero(matrix->m[1]) &&
- floatIsZero(matrix->m[2]) &&
- floatIsZero(matrix->m[3]) && floatsEqual(matrix->m[4], 1) &&
- floatIsZero(matrix->m[5]) &&
- floatIsZero(matrix->m[6]) && floatIsZero(matrix->m[7]) &&
- floatIsZero(matrix->m[8]);
-}
-
-static INLINE VGboolean matrix_is_affine(struct matrix *matrix)
-{
- return floatIsZero(matrix->m[2]) && floatIsZero(matrix->m[5])
- && floatsEqual(matrix->m[8], 1);
-}
-
-
-static INLINE void matrix_make_affine(struct matrix *matrix)
-{
- matrix->m[2] = 0.f;
- matrix->m[5] = 0.f;
- matrix->m[8] = 1.f;
-}
-
-static INLINE void matrix_mult(struct matrix *dst,
- const struct matrix *src)
-{
- VGfloat m11 = dst->m[0]*src->m[0] + dst->m[3]*src->m[1] + dst->m[6]*src->m[2];
- VGfloat m12 = dst->m[0]*src->m[3] + dst->m[3]*src->m[4] + dst->m[6]*src->m[5];
- VGfloat m13 = dst->m[0]*src->m[6] + dst->m[3]*src->m[7] + dst->m[6]*src->m[8];
-
- VGfloat m21 = dst->m[1]*src->m[0] + dst->m[4]*src->m[1] + dst->m[7]*src->m[2];
- VGfloat m22 = dst->m[1]*src->m[3] + dst->m[4]*src->m[4] + dst->m[7]*src->m[5];
- VGfloat m23 = dst->m[1]*src->m[6] + dst->m[4]*src->m[7] + dst->m[7]*src->m[8];
-
- VGfloat m31 = dst->m[2]*src->m[0] + dst->m[5]*src->m[1] + dst->m[8]*src->m[2];
- VGfloat m32 = dst->m[2]*src->m[3] + dst->m[5]*src->m[4] + dst->m[8]*src->m[5];
- VGfloat m33 = dst->m[2]*src->m[6] + dst->m[5]*src->m[7] + dst->m[8]*src->m[8];
-
- dst->m[0] = m11; dst->m[1] = m21; dst->m[2] = m31;
- dst->m[3] = m12; dst->m[4] = m22; dst->m[5] = m32;
- dst->m[6] = m13; dst->m[7] = m23; dst->m[8] = m33;
-}
-
-
-static INLINE void matrix_map_point(struct matrix *mat,
- VGfloat x, VGfloat y,
- VGfloat *out_x, VGfloat *out_y)
-{
- /* to be able to do matrix_map_point(m, x, y, &x, &y) use
- * temporaries */
- VGfloat tmp_x = x, tmp_y = y;
-
- *out_x = mat->m[0]*tmp_x + mat->m[3]*tmp_y + mat->m[6];
- *out_y = mat->m[1]*tmp_x + mat->m[4]*tmp_y + mat->m[7];
- if (!matrix_is_affine(mat)) {
- VGfloat w = 1/(mat->m[2]*tmp_x + mat->m[5]*tmp_y + mat->m[8]);
- *out_x *= w;
- *out_y *= w;
- }
-}
-
-static INLINE void matrix_translate(struct matrix *dst,
- VGfloat tx, VGfloat ty)
-{
- if (!matrix_is_affine(dst)) {
- struct matrix trans_matrix;
- matrix_load_identity(&trans_matrix);
- trans_matrix.m[6] = tx;
- trans_matrix.m[7] = ty;
- matrix_mult(dst, &trans_matrix);
- } else {
- dst->m[6] += tx*dst->m[0] + ty*dst->m[3];
- dst->m[7] += ty*dst->m[4] + tx*dst->m[1];
- }
-}
-
-static INLINE void matrix_scale(struct matrix *dst,
- VGfloat sx, VGfloat sy)
-{
- if (!matrix_is_affine(dst)) {
- struct matrix scale_matrix;
- matrix_load_identity(&scale_matrix);
- scale_matrix.m[0] = sx;
- scale_matrix.m[4] = sy;
- matrix_mult(dst, &scale_matrix);
- } else {
- dst->m[0] *= sx; dst->m[1] *= sx;
- dst->m[3] *= sy; dst->m[4] *= sy;
- }
-}
-
-static INLINE void matrix_shear(struct matrix *dst,
- VGfloat shx, VGfloat shy)
-{
- struct matrix shear_matrix;
- matrix_load_identity(&shear_matrix);
- shear_matrix.m[1] = shy;
- shear_matrix.m[3] = shx;
- matrix_mult(dst, &shear_matrix);
-}
-
-static INLINE void matrix_rotate(struct matrix *dst,
- VGfloat angle)
-{
- struct matrix mat;
- float sin_val = 0;
- float cos_val = 0;
-
-
- if (floatsEqual(angle, 90) || floatsEqual(angle, -270))
- sin_val = 1.f;
- else if (floatsEqual(angle, 270) || floatsEqual(angle, -90))
- sin_val = -1.f;
- else if (floatsEqual(angle, 180))
- cos_val = -1.f;
- else {
- double radians = DEGREES_TO_RADIANS(angle);
- sin_val = (float) sin(radians);
- cos_val = (float) cos(radians);
- }
-
- if (!matrix_is_affine(dst)) {
- matrix_load_identity(&mat);
- mat.m[0] = cos_val; mat.m[1] = sin_val;
- mat.m[3] = -sin_val; mat.m[4] = cos_val;
-
- matrix_mult(dst, &mat);
- } else {
- VGfloat m11 = cos_val*dst->m[0] + sin_val*dst->m[3];
- VGfloat m12 = cos_val*dst->m[1] + sin_val*dst->m[4];
- VGfloat m21 = -sin_val*dst->m[0] + cos_val*dst->m[3];
- VGfloat m22 = -sin_val*dst->m[1] + cos_val*dst->m[4];
- dst->m[0] = m11; dst->m[1] = m12;
- dst->m[3] = m21; dst->m[4] = m22;
- }
-}
-
-
-static INLINE VGfloat matrix_determinant(struct matrix *mat)
-{
- return mat->m[0]*(mat->m[8]*mat->m[4]-mat->m[7]*mat->m[5]) -
- mat->m[3]*(mat->m[8]*mat->m[1]-mat->m[7]*mat->m[2])+
- mat->m[6]*(mat->m[5]*mat->m[1]-mat->m[4]*mat->m[2]);
-}
-
-
-static INLINE void matrix_adjoint(struct matrix *mat)
-{
- VGfloat h[9];
- h[0] = mat->m[4]*mat->m[8] - mat->m[5]*mat->m[7];
- h[3] = mat->m[5]*mat->m[6] - mat->m[3]*mat->m[8];
- h[6] = mat->m[3]*mat->m[7] - mat->m[4]*mat->m[6];
- h[1] = mat->m[2]*mat->m[7] - mat->m[1]*mat->m[8];
- h[4] = mat->m[0]*mat->m[8] - mat->m[2]*mat->m[6];
- h[7] = mat->m[1]*mat->m[6] - mat->m[0]*mat->m[7];
- h[2] = mat->m[1]*mat->m[5] - mat->m[2]*mat->m[4];
- h[5] = mat->m[2]*mat->m[3] - mat->m[0]*mat->m[5];
- h[8] = mat->m[0]*mat->m[4] - mat->m[1]*mat->m[3];
-
-
- memcpy(mat->m, h, sizeof(VGfloat) * 9);
-}
-
-static INLINE void matrix_divs(struct matrix *mat,
- VGfloat s)
-{
- mat->m[0] /= s;
- mat->m[1] /= s;
- mat->m[2] /= s;
- mat->m[3] /= s;
- mat->m[4] /= s;
- mat->m[5] /= s;
- mat->m[6] /= s;
- mat->m[7] /= s;
- mat->m[8] /= s;
-}
-
-static INLINE VGboolean matrix_invert(struct matrix *mat)
-{
- VGfloat det = matrix_determinant(mat);
-
- if (floatIsZero(det))
- return VG_FALSE;
-
- matrix_adjoint(mat);
- matrix_divs(mat, det);
- return VG_TRUE;
-}
-
-static INLINE VGboolean matrix_is_invertible(struct matrix *mat)
-{
- return !floatIsZero(matrix_determinant(mat));
-}
-
-
-static INLINE VGboolean matrix_square_to_quad(VGfloat dx0, VGfloat dy0,
- VGfloat dx1, VGfloat dy1,
- VGfloat dx3, VGfloat dy3,
- VGfloat dx2, VGfloat dy2,
- struct matrix *mat)
-{
- VGfloat ax = dx0 - dx1 + dx2 - dx3;
- VGfloat ay = dy0 - dy1 + dy2 - dy3;
-
- if (floatIsZero(ax) && floatIsZero(ay)) {
- /* affine case */
- matrix_inits(mat,
- dx1 - dx0, dy1 - dy0, 0,
- dx2 - dx1, dy2 - dy1, 0,
- dx0, dy0, 1);
- } else {
- VGfloat a, b, c, d, e, f, g, h;
- VGfloat ax1 = dx1 - dx2;
- VGfloat ax2 = dx3 - dx2;
- VGfloat ay1 = dy1 - dy2;
- VGfloat ay2 = dy3 - dy2;
-
- /* determinants */
- VGfloat gtop = ax * ay2 - ax2 * ay;
- VGfloat htop = ax1 * ay - ax * ay1;
- VGfloat bottom = ax1 * ay2 - ax2 * ay1;
-
- if (!bottom)
- return VG_FALSE;
-
- g = gtop / bottom;
- h = htop / bottom;
-
- a = dx1 - dx0 + g * dx1;
- b = dx3 - dx0 + h * dx3;
- c = dx0;
- d = dy1 - dy0 + g * dy1;
- e = dy3 - dy0 + h * dy3;
- f = dy0;
-
- matrix_inits(mat,
- a, d, g,
- b, e, h,
- c, f, 1.f);
- }
-
- return VG_TRUE;
-}
-
-static INLINE VGboolean matrix_quad_to_square(VGfloat sx0, VGfloat sy0,
- VGfloat sx1, VGfloat sy1,
- VGfloat sx2, VGfloat sy2,
- VGfloat sx3, VGfloat sy3,
- struct matrix *mat)
-{
- if (!matrix_square_to_quad(sx0, sy0, sx1, sy1,
- sx2, sy2, sx3, sy3,
- mat))
- return VG_FALSE;
-
- return matrix_invert(mat);
-}
-
-
-static INLINE VGboolean matrix_quad_to_quad(VGfloat dx0, VGfloat dy0,
- VGfloat dx1, VGfloat dy1,
- VGfloat dx2, VGfloat dy2,
- VGfloat dx3, VGfloat dy3,
- VGfloat sx0, VGfloat sy0,
- VGfloat sx1, VGfloat sy1,
- VGfloat sx2, VGfloat sy2,
- VGfloat sx3, VGfloat sy3,
- struct matrix *mat)
-{
- struct matrix sqr_to_qd;
-
- if (!matrix_square_to_quad(dx0, dy0, dx1, dy1,
- dx2, dy2, dx3, dy3,
- mat))
- return VG_FALSE;
-
- if (!matrix_quad_to_square(sx0, sy0, sx1, sy1,
- sx2, sy2, sx3, sy3,
- &sqr_to_qd))
- return VG_FALSE;
-
- matrix_mult(mat, &sqr_to_qd);
-
- return VG_TRUE;
-}
-
-
-static INLINE VGboolean null_line(const VGfloat *l)
-{
- return floatsEqual(l[0], l[2]) && floatsEqual(l[1], l[3]);
-}
-
-static INLINE void line_normal(float *l, float *norm)
-{
- norm[0] = l[0];
- norm[1] = l[1];
-
- norm[2] = l[0] + (l[3] - l[1]);
- norm[3] = l[1] - (l[2] - l[0]);
-}
-
-static INLINE void line_normalize(float *l)
-{
- float x = l[2] - l[0];
- float y = l[3] - l[1];
- float len = (float) sqrt(x*x + y*y);
- l[2] = l[0] + x/len;
- l[3] = l[1] + y/len;
-}
-
-static INLINE VGfloat line_length(VGfloat x1, VGfloat y1,
- VGfloat x2, VGfloat y2)
-{
- VGfloat x = x2 - x1;
- VGfloat y = y2 - y1;
- return (VGfloat) sqrt(x*x + y*y);
-}
-
-static INLINE VGfloat line_lengthv(const VGfloat *l)
-{
- VGfloat x = l[2] - l[0];
- VGfloat y = l[3] - l[1];
- return (VGfloat) sqrt(x*x + y*y);
-}
-
-
-static INLINE void line_point_at(float *l, float t, float *pt)
-{
- float dx = l[2] - l[0];
- float dy = l[3] - l[1];
-
- pt[0] = l[0] + dx * t;
- pt[1] = l[1] + dy * t;
-}
-
-static INLINE void vector_unit(float *vec)
-{
- float len = (float) sqrt(vec[0] * vec[0] + vec[1] * vec[1]);
- vec[0] /= len;
- vec[1] /= len;
-}
-
-static INLINE void line_normal_vector(float *line, float *vec)
-{
- VGfloat normal[4];
-
- line_normal(line, normal);
-
- vec[0] = normal[2] - normal[0];
- vec[1] = normal[3] - normal[1];
-
- vector_unit(vec);
-}
-
-#endif
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#include "paint.h"
-
-#include "matrix.h"
-#include "image.h"
-
-#include "pipe/p_compiler.h"
-#include "util/u_inlines.h"
-
-#include "util/u_memory.h"
-#include "util/u_math.h"
-#include "util/u_sampler.h"
-
-#include "cso_cache/cso_context.h"
-
-struct vg_paint {
- struct vg_object base;
-
- VGPaintType type;
-
- struct {
- VGfloat color[4];
- VGint colori[4];
- } solid;
-
- struct {
- VGColorRampSpreadMode spread;
- VGuint color_data[1024];
- struct {
- VGfloat coords[4];
- VGint coordsi[4];
- } linear;
- struct {
- VGfloat vals[5];
- VGint valsi[5];
- } radial;
- struct pipe_sampler_view *sampler_view;
- struct pipe_sampler_state sampler;
-
- VGfloat *ramp_stops;
- VGint *ramp_stopsi;
- VGint num_stops;
-
- VGboolean color_ramps_premultiplied;
- } gradient;
-
- struct {
- struct pipe_sampler_view *sampler_view;
- VGTilingMode tiling_mode;
- struct pipe_sampler_state sampler;
- } pattern;
-
- /* XXX next 3 all unneded? */
- struct pipe_resource *cbuf;
- struct pipe_shader_state fs_state;
- void *fs;
-};
-
-static INLINE VGuint mix_pixels(VGuint p1, VGuint a, VGuint p2, VGuint b)
-{
- VGuint t = (p1 & 0xff00ff) * a + (p2 & 0xff00ff) * b;
- t >>= 8; t &= 0xff00ff;
-
- p1 = ((p1 >> 8) & 0xff00ff) * a + ((p2 >> 8) & 0xff00ff) * b;
- p1 &= 0xff00ff00; p1 |= t;
-
- return p1;
-}
-
-static INLINE VGuint float4_to_argb(const VGfloat *clr)
-{
- return float_to_ubyte(clr[3]) << 24 |
- float_to_ubyte(clr[0]) << 16 |
- float_to_ubyte(clr[1]) << 8 |
- float_to_ubyte(clr[2]) << 0;
-}
-
-static INLINE void create_gradient_data(const VGfloat *ramp_stops,
- VGint num,
- VGuint *data,
- VGint size)
-{
- VGint i;
- VGint pos = 0;
- VGfloat fpos = 0, incr = 1.f / size;
- VGuint last_color;
-
- while (fpos < ramp_stops[0]) {
- data[pos] = float4_to_argb(ramp_stops + 1);
- fpos += incr;
- ++pos;
- }
-
- for (i = 0; i < num - 1; ++i) {
- VGint rcur = 5 * i;
- VGint rnext = 5 * (i + 1);
- VGfloat delta = 1.f/(ramp_stops[rnext] - ramp_stops[rcur]);
- while (fpos < ramp_stops[rnext] && pos < size) {
- VGint dist = 256 * ((fpos - ramp_stops[rcur]) * delta);
- VGint idist = 256 - dist;
- VGuint current_color = float4_to_argb(ramp_stops + rcur + 1);
- VGuint next_color = float4_to_argb(ramp_stops + rnext + 1);
- data[pos] = mix_pixels(current_color, idist,
- next_color, dist);
- fpos += incr;
- ++pos;
- }
- }
-
- last_color = float4_to_argb(ramp_stops + ((num - 1) * 5 + 1));
- while (pos < size) {
- data[pos] = last_color;
- ++pos;
- }
- data[size-1] = last_color;
-}
-
-static INLINE struct pipe_resource *create_gradient_texture(struct vg_paint *p)
-{
- struct pipe_context *pipe = p->base.ctx->pipe;
- struct pipe_screen *screen = pipe->screen;
- struct pipe_resource *tex = 0;
- struct pipe_resource templ;
-
- memset(&templ, 0, sizeof(templ));
- templ.target = PIPE_TEXTURE_1D;
- templ.format = PIPE_FORMAT_B8G8R8A8_UNORM;
- templ.last_level = 0;
- templ.width0 = 1024;
- templ.height0 = 1;
- templ.depth0 = 1;
- templ.array_size = 1;
- templ.bind = PIPE_BIND_SAMPLER_VIEW;
-
- tex = screen->resource_create(screen, &templ);
-
- { /* upload color_data */
- struct pipe_transfer *transfer;
- void *map =
- pipe_transfer_map(p->base.ctx->pipe, tex, 0, 0,
- PIPE_TRANSFER_WRITE, 0, 0, 1024, 1,
- &transfer);
- memcpy(map, p->gradient.color_data, sizeof(VGint)*1024);
- pipe->transfer_unmap(pipe, transfer);
- }
-
- return tex;
-}
-
-static INLINE struct pipe_sampler_view *create_gradient_sampler_view(struct vg_paint *p)
-{
- struct pipe_context *pipe = p->base.ctx->pipe;
- struct pipe_resource *texture;
- struct pipe_sampler_view view_templ;
- struct pipe_sampler_view *view;
-
- texture = create_gradient_texture(p);
-
- if (!texture)
- return NULL;
-
- u_sampler_view_default_template(&view_templ, texture, texture->format);
- view = pipe->create_sampler_view(pipe, texture, &view_templ);
- /* want the texture to go away if the view is freed */
- pipe_resource_reference(&texture, NULL);
-
- return view;
-}
-
-struct vg_paint * paint_create(struct vg_context *ctx)
-{
- struct vg_paint *paint = CALLOC_STRUCT(vg_paint);
- const VGfloat default_color[] = {0.0f, 0.0f, 0.0f, 1.0f};
- const VGfloat def_ling[] = {0.0f, 0.0f, 1.0f, 0.0f};
- const VGfloat def_radg[] = {0.0f, 0.0f, 0.0f, 0.0f, 1.0f};
- vg_init_object(&paint->base, ctx, VG_OBJECT_PAINT);
- vg_context_add_object(ctx, &paint->base);
-
- paint->type = VG_PAINT_TYPE_COLOR;
- memcpy(paint->solid.color, default_color,
- 4 * sizeof(VGfloat));
- paint->gradient.spread = VG_COLOR_RAMP_SPREAD_PAD;
- memcpy(paint->gradient.linear.coords, def_ling,
- 4 * sizeof(VGfloat));
- memcpy(paint->gradient.radial.vals, def_radg,
- 5 * sizeof(VGfloat));
-
- paint->gradient.sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
- paint->gradient.sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
- paint->gradient.sampler.min_img_filter = PIPE_TEX_MIPFILTER_NEAREST;
- paint->gradient.sampler.mag_img_filter = PIPE_TEX_MIPFILTER_NEAREST;
- paint->gradient.sampler.normalized_coords = 1;
-
- memcpy(&paint->pattern.sampler,
- &paint->gradient.sampler,
- sizeof(struct pipe_sampler_state));
-
- return paint;
-}
-
-void paint_destroy(struct vg_paint *paint)
-{
- struct vg_context *ctx = paint->base.ctx;
- pipe_sampler_view_reference(&paint->gradient.sampler_view, NULL);
- if (paint->pattern.sampler_view)
- pipe_sampler_view_reference(&paint->pattern.sampler_view, NULL);
- if (ctx) {
- vg_context_remove_object(ctx, &paint->base);
- vg_free_object(&paint->base);
- }
-
- free(paint->gradient.ramp_stopsi);
- free(paint->gradient.ramp_stops);
- FREE(paint);
-}
-
-void paint_set_color(struct vg_paint *paint,
- const VGfloat *color)
-{
- paint->solid.color[0] = color[0];
- paint->solid.color[1] = color[1];
- paint->solid.color[2] = color[2];
- paint->solid.color[3] = color[3];
-
- paint->solid.colori[0] = FLT_TO_INT(color[0]);
- paint->solid.colori[1] = FLT_TO_INT(color[1]);
- paint->solid.colori[2] = FLT_TO_INT(color[2]);
- paint->solid.colori[3] = FLT_TO_INT(color[3]);
-}
-
-static INLINE void paint_color_buffer(struct vg_paint *paint, void *buffer)
-{
- VGfloat *map = (VGfloat*)buffer;
- memcpy(buffer, paint->solid.color, 4 * sizeof(VGfloat));
- map[4] = 0.f;
- map[5] = 1.f;
- map[6] = 2.f;
- map[7] = 4.f;
-}
-
-static INLINE void paint_linear_gradient_buffer(struct vg_paint *paint,
- const struct matrix *inv,
- void *buffer)
-{
- VGfloat *map = (VGfloat*)buffer;
- VGfloat dd;
-
- map[0] = paint->gradient.linear.coords[2] - paint->gradient.linear.coords[0];
- map[1] = paint->gradient.linear.coords[3] - paint->gradient.linear.coords[1];
- dd = (map[0] * map[0] + map[1] * map[1]);
-
- map[2] = (dd > 0.0f) ? 1.f / dd : 0.f;
- map[3] = 1.f;
-
- map[4] = 0.f;
- map[5] = 1.f;
- map[6] = 2.f;
- map[7] = 4.f;
- {
- struct matrix mat;
- matrix_load_identity(&mat);
- /* VEGA_LINEAR_GRADIENT_SHADER expects the first point to be at (0, 0) */
- matrix_translate(&mat, -paint->gradient.linear.coords[0], -paint->gradient.linear.coords[1]);
- matrix_mult(&mat, inv);
-
- map[8] = mat.m[0]; map[9] = mat.m[3]; map[10] = mat.m[6]; map[11] = 0.f;
- map[12] = mat.m[1]; map[13] = mat.m[4]; map[14] = mat.m[7]; map[15] = 0.f;
- map[16] = mat.m[2]; map[17] = mat.m[5]; map[18] = mat.m[8]; map[19] = 0.f;
- }
-#if 0
- debug_printf("Coords (%f, %f, %f, %f)\n",
- map[0], map[1], map[2], map[3]);
-#endif
-}
-
-
-static INLINE void paint_radial_gradient_buffer(struct vg_paint *paint,
- const struct matrix *inv,
- void *buffer)
-{
- const VGfloat *center = &paint->gradient.radial.vals[0];
- const VGfloat *focal = &paint->gradient.radial.vals[2];
- VGfloat rr = paint->gradient.radial.vals[4];
- VGfloat *map = (VGfloat*)buffer;
- VGfloat dd, new_focal[2];
-
- rr *= rr;
-
- map[0] = center[0] - focal[0];
- map[1] = center[1] - focal[1];
- dd = map[0] * map[0] + map[1] * map[1];
-
- /* focal point must lie inside the circle */
- if (0.998f * rr < dd) {
- VGfloat scale;
-
- scale = (dd > 0.0f) ? sqrt(0.998f * rr / dd) : 0.0f;
- map[0] *= scale;
- map[1] *= scale;
-
- new_focal[0] = center[0] - map[0];
- new_focal[1] = center[1] - map[1];
- dd = map[0] * map[0] + map[1] * map[1];
- focal = new_focal;
- }
-
- map[2] = (rr > dd) ? rr - dd : 1.0f;
- map[3] = 1.f;
-
- map[4] = 0.f;
- map[5] = 1.f;
- map[6] = 2.f;
- map[7] = 4.f;
-
- {
- struct matrix mat;
- matrix_load_identity(&mat);
- matrix_translate(&mat, -focal[0], -focal[1]);
- matrix_mult(&mat, inv);
-
- map[8] = mat.m[0]; map[9] = mat.m[3]; map[10] = mat.m[6]; map[11] = 0.f;
- map[12] = mat.m[1]; map[13] = mat.m[4]; map[14] = mat.m[7]; map[15] = 0.f;
- map[16] = mat.m[2]; map[17] = mat.m[5]; map[18] = mat.m[8]; map[19] = 0.f;
- }
-
-#if 0
- debug_printf("Coords (%f, %f, %f, %f)\n",
- map[0], map[1], map[2], map[3]);
-#endif
-}
-
-
-static INLINE void paint_pattern_buffer(struct vg_paint *paint,
- const struct matrix *inv,
- void *buffer)
-{
- VGfloat *map = (VGfloat *)buffer;
- memcpy(map, paint->solid.color, 4 * sizeof(VGfloat));
-
- map[4] = 0.f;
- map[5] = 1.f;
- map[6] = paint->pattern.sampler_view->texture->width0;
- map[7] = paint->pattern.sampler_view->texture->height0;
- {
- struct matrix mat;
-
- memcpy(&mat, inv, sizeof(*inv));
-
- map[8] = mat.m[0]; map[9] = mat.m[3]; map[10] = mat.m[6]; map[11] = 0.f;
- map[12] = mat.m[1]; map[13] = mat.m[4]; map[14] = mat.m[7]; map[15] = 0.f;
- map[16] = mat.m[2]; map[17] = mat.m[5]; map[18] = mat.m[8]; map[19] = 0.f;
- }
-}
-
-void paint_set_type(struct vg_paint *paint, VGPaintType type)
-{
- paint->type = type;
-}
-
-void paint_set_ramp_stops(struct vg_paint *paint, const VGfloat *stops,
- int num)
-{
- const VGfloat default_stops[] = {0.0f, 0.0f, 0.0f, 0.0f, 1.0f,
- 1.0f, 1.0f, 1.0f, 1.0f, 1.0f};
- VGint i;
- const VGint num_stops = num / 5;
- VGfloat last_coord;
-
- paint->gradient.num_stops = num;
- if (num) {
- free(paint->gradient.ramp_stops);
- paint->gradient.ramp_stops = malloc(sizeof(VGfloat)*num);
- memcpy(paint->gradient.ramp_stops, stops, sizeof(VGfloat)*num);
- } else
- return;
-
- /* stops must be in increasing order. the last stop is 1.0. if the
- * first one is bigger than 1 then the whole sequence is invalid*/
- if (stops[0] > 1) {
- stops = default_stops;
- num = 10;
- }
- last_coord = stops[0];
- for (i = 1; i < num_stops; ++i) {
- VGint idx = 5 * i;
- VGfloat coord = stops[idx];
- if (!floatsEqual(last_coord, coord) && coord < last_coord) {
- stops = default_stops;
- num = 10;
- break;
- }
- last_coord = coord;
- }
-
- create_gradient_data(stops, num / 5, paint->gradient.color_data,
- 1024);
-
- if (paint->gradient.sampler_view) {
- pipe_sampler_view_reference(&paint->gradient.sampler_view, NULL);
- paint->gradient.sampler_view = NULL;
- }
-
- paint->gradient.sampler_view = create_gradient_sampler_view(paint);
-}
-
-void paint_set_colori(struct vg_paint *p,
- VGuint rgba)
-{
- p->solid.color[0] = ((rgba >> 24) & 0xff) / 255.f;
- p->solid.color[1] = ((rgba >> 16) & 0xff) / 255.f;
- p->solid.color[2] = ((rgba >> 8) & 0xff) / 255.f;
- p->solid.color[3] = ((rgba >> 0) & 0xff) / 255.f;
-}
-
-VGuint paint_colori(struct vg_paint *p)
-{
-#define F2B(f) (float_to_ubyte(f))
-
- return ((F2B(p->solid.color[0]) << 24) |
- (F2B(p->solid.color[1]) << 16) |
- (F2B(p->solid.color[2]) << 8) |
- (F2B(p->solid.color[3]) << 0));
-#undef F2B
-}
-
-void paint_set_linear_gradient(struct vg_paint *paint,
- const VGfloat *coords)
-{
- memcpy(paint->gradient.linear.coords, coords, sizeof(VGfloat) * 4);
-}
-
-void paint_set_spread_mode(struct vg_paint *paint,
- VGint mode)
-{
- paint->gradient.spread = mode;
- switch(mode) {
- case VG_COLOR_RAMP_SPREAD_PAD:
- paint->gradient.sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
- break;
- case VG_COLOR_RAMP_SPREAD_REPEAT:
- paint->gradient.sampler.wrap_s = PIPE_TEX_WRAP_REPEAT;
- break;
- case VG_COLOR_RAMP_SPREAD_REFLECT:
- paint->gradient.sampler.wrap_s = PIPE_TEX_WRAP_MIRROR_REPEAT;
- break;
- }
-}
-
-VGColorRampSpreadMode paint_spread_mode(struct vg_paint *paint)
-{
- return paint->gradient.spread;
-}
-
-void paint_set_radial_gradient(struct vg_paint *paint,
- const VGfloat *values)
-{
- memcpy(paint->gradient.radial.vals, values, sizeof(VGfloat) * 5);
-}
-
-void paint_set_pattern(struct vg_paint *paint,
- struct vg_image *img)
-{
- if (paint->pattern.sampler_view)
- pipe_sampler_view_reference(&paint->pattern.sampler_view, NULL);
-
- paint->pattern.sampler_view = NULL;
- pipe_sampler_view_reference(&paint->pattern.sampler_view,
- img->sampler_view);
-}
-
-void paint_set_pattern_tiling(struct vg_paint *paint,
- VGTilingMode mode)
-{
- paint->pattern.tiling_mode = mode;
-
- switch(mode) {
- case VG_TILE_FILL:
- paint->pattern.sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_BORDER;
- paint->pattern.sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_BORDER;
- break;
- case VG_TILE_PAD:
- paint->pattern.sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
- paint->pattern.sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
- break;
- case VG_TILE_REPEAT:
- paint->pattern.sampler.wrap_s = PIPE_TEX_WRAP_REPEAT;
- paint->pattern.sampler.wrap_t = PIPE_TEX_WRAP_REPEAT;
- break;
- case VG_TILE_REFLECT:
- paint->pattern.sampler.wrap_s = PIPE_TEX_WRAP_MIRROR_REPEAT;
- paint->pattern.sampler.wrap_t = PIPE_TEX_WRAP_MIRROR_REPEAT;
- break;
- default:
- debug_assert(!"Unknown tiling mode");
- }
-}
-
-void paint_get_color(struct vg_paint *paint,
- VGfloat *color)
-{
- color[0] = paint->solid.color[0];
- color[1] = paint->solid.color[1];
- color[2] = paint->solid.color[2];
- color[3] = paint->solid.color[3];
-}
-
-void paint_ramp_stops(struct vg_paint *paint, VGfloat *stops,
- int num)
-{
- memcpy(stops, paint->gradient.ramp_stops, sizeof(VGfloat)*num);
-}
-
-void paint_linear_gradient(struct vg_paint *paint,
- VGfloat *coords)
-{
- memcpy(coords, paint->gradient.linear.coords, sizeof(VGfloat)*4);
-}
-
-void paint_radial_gradient(struct vg_paint *paint,
- VGfloat *coords)
-{
- memcpy(coords, paint->gradient.radial.vals, sizeof(VGfloat)*5);
-}
-
-int paint_num_ramp_stops(struct vg_paint *paint)
-{
- return paint->gradient.num_stops;
-}
-
-VGPaintType paint_type(struct vg_paint *paint)
-{
- return paint->type;
-}
-
-void paint_set_coloriv(struct vg_paint *paint,
- const VGint *color)
-{
- paint->solid.color[0] = color[0];
- paint->solid.color[1] = color[1];
- paint->solid.color[2] = color[2];
- paint->solid.color[3] = color[3];
-
- paint->solid.colori[0] = color[0];
- paint->solid.colori[1] = color[1];
- paint->solid.colori[2] = color[2];
- paint->solid.colori[3] = color[3];
-}
-
-void paint_get_coloriv(struct vg_paint *paint,
- VGint *color)
-{
- color[0] = paint->solid.colori[0];
- color[1] = paint->solid.colori[1];
- color[2] = paint->solid.colori[2];
- color[3] = paint->solid.colori[3];
-}
-
-void paint_set_color_ramp_premultiplied(struct vg_paint *paint,
- VGboolean set)
-{
- paint->gradient.color_ramps_premultiplied = set;
-}
-
-VGboolean paint_color_ramp_premultiplied(struct vg_paint *paint)
-{
- return paint->gradient.color_ramps_premultiplied;
-}
-
-void paint_set_ramp_stopsi(struct vg_paint *paint, const VGint *stops,
- int num)
-{
- if (num) {
- free(paint->gradient.ramp_stopsi);
- paint->gradient.ramp_stopsi = malloc(sizeof(VGint)*num);
- memcpy(paint->gradient.ramp_stopsi, stops, sizeof(VGint)*num);
- }
-}
-
-void paint_ramp_stopsi(struct vg_paint *paint, VGint *stops,
- int num)
-{
- memcpy(stops, paint->gradient.ramp_stopsi, sizeof(VGint)*num);
-}
-
-void paint_set_linear_gradienti(struct vg_paint *paint,
- const VGint *coords)
-{
- memcpy(paint->gradient.linear.coordsi, coords, sizeof(VGint) * 4);
-}
-
-void paint_linear_gradienti(struct vg_paint *paint,
- VGint *coords)
-{
- memcpy(coords, paint->gradient.linear.coordsi, sizeof(VGint)*4);
-}
-
-void paint_set_radial_gradienti(struct vg_paint *paint,
- const VGint *values)
-{
- memcpy(paint->gradient.radial.valsi, values, sizeof(VGint) * 5);
-}
-
-void paint_radial_gradienti(struct vg_paint *paint,
- VGint *coords)
-{
- memcpy(coords, paint->gradient.radial.valsi, sizeof(VGint)*5);
-}
-
-VGTilingMode paint_pattern_tiling(struct vg_paint *paint)
-{
- return paint->pattern.tiling_mode;
-}
-
-VGint paint_bind_samplers(struct vg_paint *paint, struct pipe_sampler_state **samplers,
- struct pipe_sampler_view **sampler_views)
-{
- struct vg_context *ctx = vg_current_context();
-
- switch(paint->type) {
- case VG_PAINT_TYPE_LINEAR_GRADIENT:
- case VG_PAINT_TYPE_RADIAL_GRADIENT: {
- if (paint->gradient.sampler_view) {
- paint->gradient.sampler.min_img_filter = image_sampler_filter(ctx);
- paint->gradient.sampler.mag_img_filter = image_sampler_filter(ctx);
- samplers[0] = &paint->gradient.sampler;
- sampler_views[0] = paint->gradient.sampler_view;
- return 1;
- }
- }
- break;
- case VG_PAINT_TYPE_PATTERN: {
- memcpy(paint->pattern.sampler.border_color.f,
- ctx->state.vg.tile_fill_color,
- sizeof(VGfloat) * 4);
- paint->pattern.sampler.min_img_filter = image_sampler_filter(ctx);
- paint->pattern.sampler.mag_img_filter = image_sampler_filter(ctx);
- samplers[0] = &paint->pattern.sampler;
- sampler_views[0] = paint->pattern.sampler_view;
- return 1;
- }
- break;
- default:
- break;
- }
- return 0;
-}
-
-void paint_resolve_type(struct vg_paint *paint)
-{
- if (paint->type == VG_PAINT_TYPE_PATTERN &&
- !paint->pattern.sampler_view) {
- paint->type = VG_PAINT_TYPE_COLOR;
- }
-}
-
-VGboolean paint_is_degenerate(struct vg_paint *paint)
-{
- VGboolean degen;
- VGfloat *vals;
-
-
- switch (paint->type) {
- case VG_PAINT_TYPE_LINEAR_GRADIENT:
- vals = paint->gradient.linear.coords;
- /* two points are coincident */
- degen = (floatsEqual(vals[0], vals[2]) &&
- floatsEqual(vals[1], vals[3]));
- break;
- case VG_PAINT_TYPE_RADIAL_GRADIENT:
- vals = paint->gradient.radial.vals;
- /* radius <= 0 */
- degen = (vals[4] <= 0.0f);
- break;
- case VG_PAINT_TYPE_COLOR:
- case VG_PAINT_TYPE_PATTERN:
- default:
- degen = VG_FALSE;
- break;
- }
-
- return degen;
-}
-
-VGint paint_constant_buffer_size(struct vg_paint *paint)
-{
- switch(paint->type) {
- case VG_PAINT_TYPE_COLOR:
- return 8 * sizeof(VGfloat);/*4 color + 4 constants (0.f,1.f,2.f,4.f)*/
- break;
- case VG_PAINT_TYPE_LINEAR_GRADIENT:
- return 20 * sizeof(VGfloat);
- break;
- case VG_PAINT_TYPE_RADIAL_GRADIENT:
- return 20 * sizeof(VGfloat);
- break;
- case VG_PAINT_TYPE_PATTERN:
- return 20 * sizeof(VGfloat);
- break;
- default:
- debug_printf("Uknown paint type: %d\n", paint->type);
- }
-
- return 0;
-}
-
-void paint_fill_constant_buffer(struct vg_paint *paint,
- const struct matrix *mat,
- void *buffer)
-{
- switch(paint->type) {
- case VG_PAINT_TYPE_COLOR:
- paint_color_buffer(paint, buffer);
- break;
- case VG_PAINT_TYPE_LINEAR_GRADIENT:
- paint_linear_gradient_buffer(paint, mat, buffer);
- break;
- case VG_PAINT_TYPE_RADIAL_GRADIENT:
- paint_radial_gradient_buffer(paint, mat, buffer);
- break;
- case VG_PAINT_TYPE_PATTERN:
- paint_pattern_buffer(paint, mat, buffer);
- break;
-
- default:
- abort();
- }
-}
-
-VGboolean paint_is_opaque(struct vg_paint *paint)
-{
- /* TODO add other paint types and make sure PAINT_DIRTY gets set */
- return (paint->type == VG_PAINT_TYPE_COLOR &&
- floatsEqual(paint->solid.color[3], 1.0f));
-}
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#ifndef PAINT_H
-#define PAINT_H
-
-#include "vg_context.h"
-
-#include "VG/openvg.h"
-#include "pipe/p_state.h"
-
-struct vg_paint;
-struct vg_image;
-struct pipe_sampler_state;
-struct pipe_resource;
-
-struct vg_paint *paint_create(struct vg_context *ctx);
-void paint_destroy(struct vg_paint *paint);
-
-void paint_set_color(struct vg_paint *paint,
- const VGfloat *color);
-void paint_get_color(struct vg_paint *paint,
- VGfloat *color);
-
-void paint_set_coloriv(struct vg_paint *paint,
- const VGint *color);
-void paint_get_coloriv(struct vg_paint *paint,
- VGint *color);
-
-void paint_set_colori(struct vg_paint *paint,
- VGuint rgba);
-
-VGuint paint_colori(struct vg_paint *paint);
-
-void paint_set_type(struct vg_paint *paint, VGPaintType type);
-VGPaintType paint_type(struct vg_paint *paint);
-void paint_resolve_type(struct vg_paint *paint);
-
-void paint_set_linear_gradient(struct vg_paint *paint,
- const VGfloat *coords);
-void paint_linear_gradient(struct vg_paint *paint,
- VGfloat *coords);
-void paint_set_linear_gradienti(struct vg_paint *paint,
- const VGint *coords);
-void paint_linear_gradienti(struct vg_paint *paint,
- VGint *coords);
-
-
-void paint_set_radial_gradient(struct vg_paint *paint,
- const VGfloat *values);
-void paint_radial_gradient(struct vg_paint *paint,
- VGfloat *coords);
-void paint_set_radial_gradienti(struct vg_paint *paint,
- const VGint *values);
-void paint_radial_gradienti(struct vg_paint *paint,
- VGint *coords);
-
-
-void paint_set_ramp_stops(struct vg_paint *paint, const VGfloat *stops,
- int num);
-void paint_ramp_stops(struct vg_paint *paint, VGfloat *stops,
- int num);
-
-void paint_set_ramp_stopsi(struct vg_paint *paint, const VGint *stops,
- int num);
-void paint_ramp_stopsi(struct vg_paint *paint, VGint *stops,
- int num);
-
-int paint_num_ramp_stops(struct vg_paint *paint);
-
-void paint_set_spread_mode(struct vg_paint *paint,
- VGint mode);
-VGColorRampSpreadMode paint_spread_mode(struct vg_paint *paint);
-
-
-void paint_set_pattern(struct vg_paint *paint,
- struct vg_image *img);
-void paint_set_pattern_tiling(struct vg_paint *paint,
- VGTilingMode mode);
-VGTilingMode paint_pattern_tiling(struct vg_paint *paint);
-
-void paint_set_color_ramp_premultiplied(struct vg_paint *paint,
- VGboolean set);
-VGboolean paint_color_ramp_premultiplied(struct vg_paint *paint);
-
-
-VGint paint_bind_samplers(struct vg_paint *paint, struct pipe_sampler_state **samplers,
- struct pipe_sampler_view **sampler_views);
-
-VGboolean paint_is_degenerate(struct vg_paint *paint);
-
-VGint paint_constant_buffer_size(struct vg_paint *paint);
-
-void paint_fill_constant_buffer(struct vg_paint *paint,
- const struct matrix *mat,
- void *buffer);
-
-VGboolean paint_is_opaque(struct vg_paint *paint);
-
-#endif
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#include "path.h"
-
-#include "stroker.h"
-#include "polygon.h"
-#include "bezier.h"
-#include "matrix.h"
-#include "vg_context.h"
-#include "util_array.h"
-#include "arc.h"
-#include "path_utils.h"
-#include "paint.h"
-#include "shader.h"
-
-#include "util/u_memory.h"
-
-#include <assert.h>
-
-#define DEBUG_PATH 0
-
-struct path {
- struct vg_object base;
- VGbitfield caps;
- VGboolean dirty;
- VGboolean dirty_stroke;
-
- VGPathDatatype datatype;
-
- VGfloat scale;
- VGfloat bias;
-
- VGint num_segments;
-
- struct array * segments;
- struct array * control_points;
-
- struct {
- struct polygon_array polygon_array;
- struct matrix matrix;
- } fill_polys;
-
- struct {
- struct path *path;
- struct matrix matrix;
- VGfloat stroke_width;
- VGfloat miter_limit;
- VGCapStyle cap_style;
- VGJoinStyle join_style;
- } stroked;
-};
-
-
-static INLINE void data_at(void **data,
- struct path *p,
- VGint start, VGint count,
- VGfloat *out)
-{
- VGPathDatatype dt = p->datatype;
- VGint i;
- VGint end = start + count;
- VGfloat *itr = out;
-
- switch(dt) {
- case VG_PATH_DATATYPE_S_8: {
- VGbyte **bdata = (VGbyte **)data;
- for (i = start; i < end; ++i) {
- *itr = (*bdata)[i];
- ++itr;
- }
- *bdata += count;
- }
- break;
- case VG_PATH_DATATYPE_S_16: {
- VGshort **bdata = (VGshort **)data;
- for (i = start; i < end; ++i) {
- *itr = (*bdata)[i];
- ++itr;
- }
- *bdata += count;
- }
- break;
- case VG_PATH_DATATYPE_S_32: {
- VGint **bdata = (VGint **)data;
- for (i = start; i < end; ++i) {
- *itr = (*bdata)[i];
- ++itr;
- }
- *bdata += count;
- }
- break;
- case VG_PATH_DATATYPE_F: {
- VGfloat **fdata = (VGfloat **)data;
- for (i = start; i < end; ++i) {
- *itr = (*fdata)[i];
- ++itr;
- }
- *fdata += count;
- }
- break;
- default:
- debug_assert(!"Unknown path datatype!");
- }
-}
-
-
-void vg_float_to_datatype(VGPathDatatype datatype,
- VGubyte *common_data,
- const VGfloat *data,
- VGint num_coords)
-{
- VGint i;
- switch(datatype) {
- case VG_PATH_DATATYPE_S_8: {
- for (i = 0; i < num_coords; ++i) {
- common_data[i] = (VGubyte)data[i];
- }
- }
- break;
- case VG_PATH_DATATYPE_S_16: {
- VGshort *buf = (VGshort*)common_data;
- for (i = 0; i < num_coords; ++i) {
- buf[i] = (VGshort)data[i];
- }
- }
- break;
- case VG_PATH_DATATYPE_S_32: {
- VGint *buf = (VGint*)common_data;
- for (i = 0; i < num_coords; ++i) {
- buf[i] = (VGint)data[i];
- }
- }
- break;
- case VG_PATH_DATATYPE_F: {
- memcpy(common_data, data, sizeof(VGfloat) * num_coords);
- }
- break;
- default:
- debug_assert(!"Unknown path datatype!");
- }
-}
-
-static void coords_adjust_by_scale_bias(struct path *p,
- void *pdata, VGint num_coords,
- VGfloat scale, VGfloat bias,
- VGPathDatatype datatype)
-{
- VGfloat data[8];
- void *coords = (VGfloat *)pdata;
- VGubyte *common_data = (VGubyte *)pdata;
- VGint size_dst = size_for_datatype(datatype);
- VGint i;
-
- for (i = 0; i < num_coords; ++i) {
- data_at(&coords, p, 0, 1, data);
- data[0] = data[0] * scale + bias;
- vg_float_to_datatype(datatype, common_data, data, 1);
- common_data += size_dst;
- }
-}
-
-struct path * path_create(VGPathDatatype dt, VGfloat scale, VGfloat bias,
- VGint segmentCapacityHint,
- VGint coordCapacityHint,
- VGbitfield capabilities)
-{
- struct path *path = CALLOC_STRUCT(path);
-
- vg_init_object(&path->base, vg_current_context(), VG_OBJECT_PATH);
- path->caps = capabilities & VG_PATH_CAPABILITY_ALL;
- vg_context_add_object(vg_current_context(), &path->base);
-
- path->datatype = dt;
- path->scale = scale;
- path->bias = bias;
-
- path->segments = array_create(size_for_datatype(VG_PATH_DATATYPE_S_8));
- path->control_points = array_create(size_for_datatype(dt));
-
- path->dirty = VG_TRUE;
- path->dirty_stroke = VG_TRUE;
-
- return path;
-}
-
-static void polygon_array_cleanup(struct polygon_array *polyarray)
-{
- if (polyarray->array) {
- VGint i;
-
- for (i = 0; i < polyarray->array->num_elements; i++) {
- struct polygon *p = ((struct polygon **) polyarray->array->data)[i];
- polygon_destroy(p);
- }
-
- array_destroy(polyarray->array);
- polyarray->array = NULL;
- }
-}
-
-void path_destroy(struct path *p)
-{
- vg_context_remove_object(vg_current_context(), &p->base);
-
- array_destroy(p->segments);
- array_destroy(p->control_points);
-
- polygon_array_cleanup(&p->fill_polys.polygon_array);
-
- if (p->stroked.path)
- path_destroy(p->stroked.path);
-
- vg_free_object(&p->base);
-
- FREE(p);
-}
-
-VGbitfield path_capabilities(struct path *p)
-{
- return p->caps;
-}
-
-void path_set_capabilities(struct path *p, VGbitfield bf)
-{
- p->caps = (bf & VG_PATH_CAPABILITY_ALL);
-}
-
-void path_append_data(struct path *p,
- VGint numSegments,
- const VGubyte * pathSegments,
- const void * pathData)
-{
- VGint old_segments = p->num_segments;
- VGint num_new_coords = num_elements_for_segments(pathSegments, numSegments);
- array_append_data(p->segments, pathSegments, numSegments);
- array_append_data(p->control_points, pathData, num_new_coords);
-
- p->num_segments += numSegments;
- if (!floatsEqual(p->scale, 1.f) || !floatsEqual(p->bias, 0.f)) {
- VGubyte *coords = (VGubyte*)p->control_points->data;
- coords_adjust_by_scale_bias(p,
- coords + old_segments * p->control_points->datatype_size,
- num_new_coords,
- p->scale, p->bias, p->datatype);
- }
- p->dirty = VG_TRUE;
- p->dirty_stroke = VG_TRUE;
-}
-
-VGint path_num_segments(struct path *p)
-{
- return p->num_segments;
-}
-
-static INLINE void map_if_relative(VGfloat ox, VGfloat oy,
- VGboolean relative,
- VGfloat *x, VGfloat *y)
-{
- if (relative) {
- if (x)
- *x += ox;
- if (y)
- *y += oy;
- }
-}
-
-static INLINE void close_polygon(struct polygon *current,
- VGfloat sx, VGfloat sy,
- VGfloat ox, VGfloat oy,
- struct matrix *matrix)
-{
- if (!floatsEqual(sx, ox) ||
- !floatsEqual(sy, oy)) {
- VGfloat x0 = sx;
- VGfloat y0 = sy;
- matrix_map_point(matrix, x0, y0, &x0, &y0);
- polygon_vertex_append(current, x0, y0);
- }
-}
-
-static void convert_path(struct path *p,
- VGPathDatatype to,
- void *dst,
- VGint num_coords)
-{
- VGfloat data[8];
- void *coords = (VGfloat *)p->control_points->data;
- VGubyte *common_data = (VGubyte *)dst;
- VGint size_dst = size_for_datatype(to);
- VGint i;
-
- for (i = 0; i < num_coords; ++i) {
- data_at(&coords, p, 0, 1, data);
- vg_float_to_datatype(to, common_data, data, 1);
- common_data += size_dst;
- }
-}
-
-static void polygon_array_calculate_bounds( struct polygon_array *polyarray )
-{
- struct array *polys = polyarray->array;
- VGfloat min_x, max_x;
- VGfloat min_y, max_y;
- VGfloat bounds[4];
- unsigned i;
-
- assert(polys);
-
- if (!polys->num_elements) {
- polyarray->min_x = 0.0f;
- polyarray->min_y = 0.0f;
- polyarray->max_x = 0.0f;
- polyarray->max_y = 0.0f;
- return;
- }
-
- polygon_bounding_rect((((struct polygon**)polys->data)[0]), bounds);
- min_x = bounds[0];
- min_y = bounds[1];
- max_x = bounds[0] + bounds[2];
- max_y = bounds[1] + bounds[3];
- for (i = 1; i < polys->num_elements; ++i) {
- struct polygon *p = (((struct polygon**)polys->data)[i]);
- polygon_bounding_rect(p, bounds);
- min_x = MIN2(min_x, bounds[0]);
- min_y = MIN2(min_y, bounds[1]);
- max_x = MAX2(max_x, bounds[0] + bounds[2]);
- max_y = MAX2(max_y, bounds[1] + bounds[3]);
- }
-
- polyarray->min_x = min_x;
- polyarray->min_y = min_y;
- polyarray->max_x = max_x;
- polyarray->max_y = max_y;
-}
-
-
-static struct polygon_array * path_get_fill_polygons(struct path *p, struct matrix *matrix)
-{
- VGint i;
- struct polygon *current = 0;
- VGfloat sx, sy, px, py, ox, oy;
- VGfloat x0, y0, x1, y1, x2, y2, x3, y3;
- VGfloat data[8];
- void *coords = (VGfloat *)p->control_points->data;
- struct array *array;
-
- memset(data, 0, sizeof(data));
-
- if (p->fill_polys.polygon_array.array)
- {
- if (memcmp( &p->fill_polys.matrix,
- matrix,
- sizeof *matrix ) == 0 && p->dirty == VG_FALSE)
- {
- return &p->fill_polys.polygon_array;
- }
- else {
- polygon_array_cleanup(&p->fill_polys.polygon_array);
- }
- }
-
- /* an array of pointers to polygons */
- array = array_create(sizeof(struct polygon *));
-
- sx = sy = px = py = ox = oy = 0.f;
-
- if (p->num_segments)
- current = polygon_create(32);
-
- for (i = 0; i < p->num_segments; ++i) {
- VGubyte segment = ((VGubyte*)(p->segments->data))[i];
- VGint command = SEGMENT_COMMAND(segment);
- VGboolean relative = SEGMENT_ABS_REL(segment);
-
- switch(command) {
- case VG_CLOSE_PATH:
- close_polygon(current, sx, sy, ox, oy, matrix);
- ox = sx;
- oy = sy;
- break;
- case VG_MOVE_TO:
- if (current && polygon_vertex_count(current) > 0) {
- /* add polygon */
- close_polygon(current, sx, sy, ox, oy, matrix);
- array_append_data(array, ¤t, 1);
- current = polygon_create(32);
- }
- data_at(&coords, p, 0, 2, data);
- x0 = data[0];
- y0 = data[1];
- map_if_relative(ox, oy, relative, &x0, &y0);
- sx = x0;
- sy = y0;
- ox = x0;
- oy = y0;
- px = x0;
- py = y0;
- matrix_map_point(matrix, x0, y0, &x0, &y0);
- polygon_vertex_append(current, x0, y0);
- break;
- case VG_LINE_TO:
- data_at(&coords, p, 0, 2, data);
- x0 = data[0];
- y0 = data[1];
- map_if_relative(ox, oy, relative, &x0, &y0);
- ox = x0;
- oy = y0;
- px = x0;
- py = y0;
- matrix_map_point(matrix, x0, y0, &x0, &y0);
- polygon_vertex_append(current, x0, y0);
- break;
- case VG_HLINE_TO:
- data_at(&coords, p, 0, 1, data);
- x0 = data[0];
- y0 = oy;
- map_if_relative(ox, oy, relative, &x0, 0);
- ox = x0;
- px = x0;
- py = y0;
- matrix_map_point(matrix, x0, y0, &x0, &y0);
- polygon_vertex_append(current, x0, y0);
- break;
- case VG_VLINE_TO:
- data_at(&coords, p, 0, 1, data);
- x0 = ox;
- y0 = data[0];
- map_if_relative(ox, oy, relative, 0, &y0);
- oy = y0;
- px = x0;
- py = y0;
- matrix_map_point(matrix, x0, y0, &x0, &y0);
- polygon_vertex_append(current, x0, y0);
- break;
- case VG_CUBIC_TO: {
- struct bezier bezier;
- data_at(&coords, p, 0, 6, data);
- x0 = ox;
- y0 = oy;
- x1 = data[0];
- y1 = data[1];
- x2 = data[2];
- y2 = data[3];
- x3 = data[4];
- y3 = data[5];
- map_if_relative(ox, oy, relative, &x1, &y1);
- map_if_relative(ox, oy, relative, &x2, &y2);
- map_if_relative(ox, oy, relative, &x3, &y3);
- ox = x3;
- oy = y3;
- px = x2;
- py = y2;
- assert(matrix_is_affine(matrix));
- matrix_map_point(matrix, x0, y0, &x0, &y0);
- matrix_map_point(matrix, x1, y1, &x1, &y1);
- matrix_map_point(matrix, x2, y2, &x2, &y2);
- matrix_map_point(matrix, x3, y3, &x3, &y3);
- bezier_init(&bezier, x0, y0, x1, y1,
- x2, y2, x3, y3);
- bezier_add_to_polygon(&bezier, current);
- }
- break;
- case VG_QUAD_TO: {
- struct bezier bezier;
- data_at(&coords, p, 0, 4, data);
- x0 = ox;
- y0 = oy;
- x1 = data[0];
- y1 = data[1];
- x3 = data[2];
- y3 = data[3];
- map_if_relative(ox, oy, relative, &x1, &y1);
- map_if_relative(ox, oy, relative, &x3, &y3);
- px = x1;
- py = y1;
- { /* form a cubic out of it */
- x2 = (x3 + 2*x1) / 3.f;
- y2 = (y3 + 2*y1) / 3.f;
- x1 = (x0 + 2*x1) / 3.f;
- y1 = (y0 + 2*y1) / 3.f;
- }
- ox = x3;
- oy = y3;
- assert(matrix_is_affine(matrix));
- matrix_map_point(matrix, x0, y0, &x0, &y0);
- matrix_map_point(matrix, x1, y1, &x1, &y1);
- matrix_map_point(matrix, x2, y2, &x2, &y2);
- matrix_map_point(matrix, x3, y3, &x3, &y3);
- bezier_init(&bezier, x0, y0, x1, y1,
- x2, y2, x3, y3);
- bezier_add_to_polygon(&bezier, current);
- }
- break;
- case VG_SQUAD_TO: {
- struct bezier bezier;
- data_at(&coords, p, 0, 2, data);
- x0 = ox;
- y0 = oy;
- x1 = 2*ox-px;
- y1 = 2*oy-py;
- x3 = data[0];
- y3 = data[1];
- map_if_relative(ox, oy, relative, &x3, &y3);
- px = x1;
- py = y1;
- { /* form a cubic out of it */
- x2 = (x3 + 2*x1) / 3.f;
- y2 = (y3 + 2*y1) / 3.f;
- x1 = (x0 + 2*x1) / 3.f;
- y1 = (y0 + 2*y1) / 3.f;
- }
- ox = x3;
- oy = y3;
- assert(matrix_is_affine(matrix));
- matrix_map_point(matrix, x0, y0, &x0, &y0);
- matrix_map_point(matrix, x1, y1, &x1, &y1);
- matrix_map_point(matrix, x2, y2, &x2, &y2);
- matrix_map_point(matrix, x3, y3, &x3, &y3);
- bezier_init(&bezier, x0, y0, x1, y1,
- x2, y2, x3, y3);
- bezier_add_to_polygon(&bezier, current);
- }
- break;
- case VG_SCUBIC_TO: {
- struct bezier bezier;
- data_at(&coords, p, 0, 4, data);
- x0 = ox;
- y0 = oy;
- x1 = 2*ox-px;
- y1 = 2*oy-py;
- x2 = data[0];
- y2 = data[1];
- x3 = data[2];
- y3 = data[3];
- map_if_relative(ox, oy, relative, &x2, &y2);
- map_if_relative(ox, oy, relative, &x3, &y3);
- ox = x3;
- oy = y3;
- px = x2;
- py = y2;
- assert(matrix_is_affine(matrix));
- matrix_map_point(matrix, x0, y0, &x0, &y0);
- matrix_map_point(matrix, x1, y1, &x1, &y1);
- matrix_map_point(matrix, x2, y2, &x2, &y2);
- matrix_map_point(matrix, x3, y3, &x3, &y3);
- bezier_init(&bezier, x0, y0, x1, y1,
- x2, y2, x3, y3);
- bezier_add_to_polygon(&bezier, current);
- }
- break;
- case VG_SCCWARC_TO:
- case VG_SCWARC_TO:
- case VG_LCCWARC_TO:
- case VG_LCWARC_TO: {
- VGfloat rh, rv, rot;
- struct arc arc;
-
- data_at(&coords, p, 0, 5, data);
- x0 = ox;
- y0 = oy;
- rh = data[0];
- rv = data[1];
- rot = data[2];
- x1 = data[3];
- y1 = data[4];
- map_if_relative(ox, oy, relative, &x1, &y1);
-#if 0
- debug_printf("------- ARC (%f, %f), (%f, %f) %f, %f, %f\n",
- x0, y0, x1, y1, rh, rv, rot);
-#endif
- arc_init(&arc, command, x0, y0, x1, y1,
- rh, rv, rot);
- arc_add_to_polygon(&arc, current,
- matrix);
- ox = x1;
- oy = y1;
- px = x1;
- py = y1;
- }
- break;
- default:
- abort();
- assert(!"Unknown segment!");
- }
- }
- if (current) {
- if (polygon_vertex_count(current) > 0) {
- close_polygon(current, sx, sy, ox, oy, matrix);
- array_append_data(array, ¤t, 1);
- } else
- polygon_destroy(current);
- }
-
- p->fill_polys.polygon_array.array = array;
- p->fill_polys.matrix = *matrix;
-
- polygon_array_calculate_bounds( &p->fill_polys.polygon_array );
-
- p->dirty = VG_FALSE;
-
- return &p->fill_polys.polygon_array;
-}
-
-VGbyte path_datatype_size(struct path *p)
-{
- return size_for_datatype(p->datatype);
-}
-
-VGPathDatatype path_datatype(struct path *p)
-{
- return p->datatype;
-}
-
-VGfloat path_scale(struct path *p)
-{
- return p->scale;
-}
-
-VGfloat path_bias(struct path *p)
-{
- return p->bias;
-}
-
-VGint path_num_coords(struct path *p)
-{
- return num_elements_for_segments((VGubyte*)p->segments->data,
- p->num_segments);
-}
-
-void path_modify_coords(struct path *p,
- VGint startIndex,
- VGint numSegments,
- const void * pathData)
-{
- VGubyte *segments = (VGubyte*)(p->segments->data);
- VGint count = num_elements_for_segments(&segments[startIndex], numSegments);
- VGint start_cp = num_elements_for_segments(segments, startIndex);
-
- array_change_data(p->control_points, pathData, start_cp, count);
- coords_adjust_by_scale_bias(p,
- ((VGubyte*)p->control_points->data) +
- (startIndex * p->control_points->datatype_size),
- path_num_coords(p),
- p->scale, p->bias, p->datatype);
- p->dirty = VG_TRUE;
- p->dirty_stroke = VG_TRUE;
-}
-
-void path_for_each_segment(struct path *path,
- path_for_each_cb cb,
- void *user_data)
-{
- VGint i;
- struct path_for_each_data p;
- VGfloat data[8];
- void *coords = (VGfloat *)path->control_points->data;
-
- p.coords = data;
- p.sx = p.sy = p.px = p.py = p.ox = p.oy = 0.f;
- p.user_data = user_data;
-
- for (i = 0; i < path->num_segments; ++i) {
- VGint command;
- VGboolean relative;
-
- p.segment = ((VGubyte*)(path->segments->data))[i];
- command = SEGMENT_COMMAND(p.segment);
- relative = SEGMENT_ABS_REL(p.segment);
-
- switch(command) {
- case VG_CLOSE_PATH:
- cb(path, &p);
- break;
- case VG_MOVE_TO:
- data_at(&coords, path, 0, 2, data);
- map_if_relative(p.ox, p.oy, relative, &data[0], &data[1]);
- cb(path, &p);
- p.sx = data[0];
- p.sy = data[1];
- p.ox = data[0];
- p.oy = data[1];
- p.px = data[0];
- p.py = data[1];
- break;
- case VG_LINE_TO:
- data_at(&coords, path, 0, 2, data);
- map_if_relative(p.ox, p.oy, relative, &data[0], &data[1]);
- cb(path, &p);
- p.ox = data[0];
- p.oy = data[1];
- p.px = data[0];
- p.py = data[1];
- break;
- case VG_HLINE_TO:
- data_at(&coords, path, 0, 1, data);
- map_if_relative(p.ox, p.oy, relative, &data[0], 0);
- p.segment = VG_LINE_TO;
- data[1] = p.oy;
- cb(path, &p);
- p.ox = data[0];
- p.oy = data[1];
- p.px = data[0];
- p.py = data[1];
- break;
- case VG_VLINE_TO:
- data_at(&coords, path, 0, 1, data);
- map_if_relative(p.ox, p.oy, relative, 0, &data[0]);
- p.segment = VG_LINE_TO;
- data[1] = data[0];
- data[0] = p.ox;
- cb(path, &p);
- p.ox = data[0];
- p.oy = data[1];
- p.px = data[0];
- p.py = data[1];
- break;
- case VG_CUBIC_TO: {
- data_at(&coords, path, 0, 6, data);
- map_if_relative(p.ox, p.oy, relative, &data[0], &data[1]);
- map_if_relative(p.ox, p.oy, relative, &data[2], &data[3]);
- map_if_relative(p.ox, p.oy, relative, &data[4], &data[5]);
- cb(path, &p);
- p.px = data[2];
- p.py = data[3];
- p.ox = data[4];
- p.oy = data[5];
- }
- break;
- case VG_QUAD_TO: {
- data_at(&coords, path, 0, 4, data);
- map_if_relative(p.ox, p.oy, relative, &data[0], &data[1]);
- map_if_relative(p.ox, p.oy, relative, &data[2], &data[3]);
- cb(path, &p);
- p.px = data[0];
- p.py = data[1];
- p.ox = data[2];
- p.oy = data[3];
- }
- break;
- case VG_SQUAD_TO: {
- data_at(&coords, path, 0, 2, data);
- map_if_relative(p.ox, p.oy, relative, &data[0], &data[1]);
- cb(path, &p);
- p.px = 2*p.ox-p.px;
- p.py = 2*p.oy-p.py;
- p.ox = data[2];
- p.oy = data[3];
- }
- break;
- case VG_SCUBIC_TO: {
- data_at(&coords, path, 0, 4, data);
- map_if_relative(p.ox, p.oy, relative, &data[0], &data[1]);
- map_if_relative(p.ox, p.oy, relative, &data[2], &data[3]);
- cb(path, &p);
- p.px = data[0];
- p.py = data[1];
- p.ox = data[2];
- p.oy = data[3];
- }
- break;
- case VG_SCCWARC_TO:
- case VG_SCWARC_TO:
- case VG_LCCWARC_TO:
- case VG_LCWARC_TO: {
- data_at(&coords, path, 0, 5, data);
- map_if_relative(p.ox, p.oy, relative, &data[3], &data[4]);
-#if 0
- debug_printf("------- ARC (%f, %f), (%f, %f) %f, %f, %f\n",
- p.ox, p.oy, data[3], data[4], data[0], data[1], data[2]);
-#endif
- cb(path, &p);
- p.ox = data[3];
- p.oy = data[4];
- p.px = data[3];
- p.py = data[4];
- }
- break;
- default:
- abort();
- assert(!"Unknown segment!");
- }
- }
-}
-
-struct transform_data {
- struct array *segments;
- struct array *coords;
-
- struct matrix *matrix;
-
- VGPathDatatype datatype;
-};
-
-static VGboolean transform_cb(struct path *p,
- struct path_for_each_data *pd)
-{
- struct transform_data *td = (struct transform_data *)pd->user_data;
- VGint num_coords = num_elements_for_segments(&pd->segment, 1);
- VGubyte segment = SEGMENT_COMMAND(pd->segment);/* abs bit is 0 */
- VGfloat data[8];
- VGubyte common_data[sizeof(VGfloat)*8];
-
- memcpy(data, pd->coords, sizeof(VGfloat) * num_coords);
-
- switch(segment) {
- case VG_CLOSE_PATH:
- break;
- case VG_MOVE_TO:
- matrix_map_point(td->matrix,
- data[0], data[1], &data[0], &data[1]);
- break;
- case VG_LINE_TO:
- matrix_map_point(td->matrix,
- data[0], data[1], &data[0], &data[1]);
- break;
- case VG_HLINE_TO:
- case VG_VLINE_TO:
- assert(0);
- break;
- case VG_QUAD_TO:
- matrix_map_point(td->matrix,
- data[0], data[1], &data[0], &data[1]);
- matrix_map_point(td->matrix,
- data[2], data[3], &data[2], &data[3]);
- break;
- case VG_CUBIC_TO:
- matrix_map_point(td->matrix,
- data[0], data[1], &data[0], &data[1]);
- matrix_map_point(td->matrix,
- data[2], data[3], &data[2], &data[3]);
- matrix_map_point(td->matrix,
- data[4], data[5], &data[4], &data[5]);
- break;
- case VG_SQUAD_TO:
- matrix_map_point(td->matrix,
- data[0], data[1], &data[0], &data[1]);
- break;
- case VG_SCUBIC_TO:
- matrix_map_point(td->matrix,
- data[0], data[1], &data[0], &data[1]);
- matrix_map_point(td->matrix,
- data[2], data[3], &data[2], &data[3]);
- break;
- case VG_SCCWARC_TO:
- case VG_SCWARC_TO:
- case VG_LCCWARC_TO:
- case VG_LCWARC_TO: {
- struct arc arc;
- struct path *path = path_create(td->datatype,
- 1, 0, 0, 0, VG_PATH_CAPABILITY_ALL);
- arc_init(&arc, segment,
- pd->ox, pd->oy, data[3], data[4],
- data[0], data[1], data[2]);
-
- arc_to_path(&arc, path, td->matrix);
-
- num_coords = path_num_coords(path);
-
- array_append_data(td->segments, path->segments->data,
- path->num_segments);
- array_append_data(td->coords, path->control_points->data,
- num_coords);
- path_destroy(path);
-
- return VG_TRUE;
- }
- break;
- default:
- break;
- }
-
- vg_float_to_datatype(td->datatype, common_data, data, num_coords);
-
- array_append_data(td->segments, &pd->segment, 1);
- array_append_data(td->coords, common_data, num_coords);
- return VG_TRUE;
-}
-
-void path_transform(struct path *dst, struct path *src)
-{
- struct transform_data data;
- struct vg_context *ctx = dst->base.ctx;
-
- data.segments = dst->segments;
- data.coords = dst->control_points;
- data.matrix = &ctx->state.vg.path_user_to_surface_matrix;
- data.datatype = dst->datatype;
-
- path_for_each_segment(src, transform_cb, (void*)&data);
-
- dst->num_segments = dst->segments->num_elements;
- dst->dirty = VG_TRUE;
- dst->dirty_stroke = VG_TRUE;
-}
-
-void path_append_path(struct path *dst,
- struct path *src)
-{
- VGint num_coords = path_num_coords(src);
- void *dst_data = malloc(size_for_datatype(dst->datatype) * num_coords);
- array_append_data(dst->segments,
- src->segments->data,
- src->num_segments);
- convert_path(src, dst->datatype,
- dst_data, num_coords);
- array_append_data(dst->control_points,
- dst_data,
- num_coords);
- free(dst_data);
-
- dst->num_segments += src->num_segments;
- dst->dirty = VG_TRUE;
- dst->dirty_stroke = VG_TRUE;
-}
-
-static INLINE VGboolean is_segment_arc(VGubyte segment)
-{
- VGubyte scommand = SEGMENT_COMMAND(segment);
- return (scommand == VG_SCCWARC_TO ||
- scommand == VG_SCWARC_TO ||
- scommand == VG_LCCWARC_TO ||
- scommand == VG_LCWARC_TO);
-}
-
-struct path_iter_data {
- struct path *path;
- VGubyte segment;
- void *coords;
- VGfloat px, py, ox, oy, sx, sy;
-};
-static INLINE VGubyte normalize_coords(struct path_iter_data *pd,
- VGint *num_coords,
- VGfloat *data)
-{
- VGint command = SEGMENT_COMMAND(pd->segment);
- VGboolean relative = SEGMENT_ABS_REL(pd->segment);
-
- switch(command) {
- case VG_CLOSE_PATH:
- *num_coords = 0;
- pd->ox = pd->sx;
- pd->oy = pd->sy;
- return VG_CLOSE_PATH;
- break;
- case VG_MOVE_TO:
- data_at(&pd->coords, pd->path, 0, 2, data);
- map_if_relative(pd->ox, pd->oy, relative, &data[0], &data[1]);
- pd->sx = data[0];
- pd->sy = data[1];
- pd->ox = data[0];
- pd->oy = data[1];
- pd->px = data[0];
- pd->py = data[1];
- *num_coords = 2;
- return VG_MOVE_TO_ABS;
- break;
- case VG_LINE_TO:
- data_at(&pd->coords, pd->path, 0, 2, data);
- map_if_relative(pd->ox, pd->oy, relative, &data[0], &data[1]);
- pd->ox = data[0];
- pd->oy = data[1];
- pd->px = data[0];
- pd->py = data[1];
- *num_coords = 2;
- return VG_LINE_TO_ABS;
- break;
- case VG_HLINE_TO:
- data_at(&pd->coords, pd->path, 0, 1, data);
- map_if_relative(pd->ox, pd->oy, relative, &data[0], 0);
- data[1] = pd->oy;
- pd->ox = data[0];
- pd->oy = data[1];
- pd->px = data[0];
- pd->py = data[1];
- *num_coords = 2;
- return VG_LINE_TO_ABS;
- break;
- case VG_VLINE_TO:
- data_at(&pd->coords, pd->path, 0, 1, data);
- map_if_relative(pd->ox, pd->oy, relative, 0, &data[0]);
- data[1] = data[0];
- data[0] = pd->ox;
- pd->ox = data[0];
- pd->oy = data[1];
- pd->px = data[0];
- pd->py = data[1];
- *num_coords = 2;
- return VG_LINE_TO_ABS;
- break;
- case VG_CUBIC_TO: {
- data_at(&pd->coords, pd->path, 0, 6, data);
- map_if_relative(pd->ox, pd->oy, relative, &data[0], &data[1]);
- map_if_relative(pd->ox, pd->oy, relative, &data[2], &data[3]);
- map_if_relative(pd->ox, pd->oy, relative, &data[4], &data[5]);
- pd->px = data[2];
- pd->py = data[3];
- pd->ox = data[4];
- pd->oy = data[5];
- *num_coords = 6;
- return VG_CUBIC_TO_ABS;
- }
- break;
- case VG_QUAD_TO: {
- VGfloat x0, y0, x1, y1, x2, y2, x3, y3;
- data_at(&pd->coords, pd->path, 0, 4, data);
- x0 = pd->ox;
- y0 = pd->oy;
- x1 = data[0];
- y1 = data[1];
- x3 = data[2];
- y3 = data[3];
- map_if_relative(pd->ox, pd->oy, relative, &x1, &y1);
- map_if_relative(pd->ox, pd->oy, relative, &x3, &y3);
- pd->px = x1;
- pd->py = y1;
- { /* form a cubic out of it */
- x2 = (x3 + 2*x1) / 3.f;
- y2 = (y3 + 2*y1) / 3.f;
- x1 = (x0 + 2*x1) / 3.f;
- y1 = (y0 + 2*y1) / 3.f;
- }
- pd->ox = x3;
- pd->oy = y3;
- data[0] = x1;
- data[1] = y1;
- data[2] = x2;
- data[3] = y2;
- data[4] = x3;
- data[5] = y3;
- *num_coords = 6;
- return VG_CUBIC_TO_ABS;
- }
- break;
- case VG_SQUAD_TO: {
- VGfloat x0, y0, x1, y1, x2, y2, x3, y3;
- data_at(&pd->coords, pd->path, 0, 2, data);
- x0 = pd->ox;
- y0 = pd->oy;
- x1 = 2 * pd->ox - pd->px;
- y1 = 2 * pd->oy - pd->py;
- x3 = data[0];
- y3 = data[1];
- map_if_relative(pd->ox, pd->oy, relative, &x3, &y3);
- pd->px = x1;
- pd->py = y1;
- { /* form a cubic out of it */
- x2 = (x3 + 2*x1) / 3.f;
- y2 = (y3 + 2*y1) / 3.f;
- x1 = (x0 + 2*x1) / 3.f;
- y1 = (y0 + 2*y1) / 3.f;
- }
- pd->ox = x3;
- pd->oy = y3;
- data[0] = x1;
- data[1] = y1;
- data[2] = x2;
- data[3] = y2;
- data[4] = x3;
- data[5] = y3;
- *num_coords = 6;
- return VG_CUBIC_TO_ABS;
- }
- break;
- case VG_SCUBIC_TO: {
- VGfloat x1, y1, x2, y2, x3, y3;
- data_at(&pd->coords, pd->path, 0, 4, data);
- x1 = 2*pd->ox-pd->px;
- y1 = 2*pd->oy-pd->py;
- x2 = data[0];
- y2 = data[1];
- x3 = data[2];
- y3 = data[3];
- map_if_relative(pd->ox, pd->oy, relative, &x2, &y2);
- map_if_relative(pd->ox, pd->oy, relative, &x3, &y3);
- pd->ox = x3;
- pd->oy = y3;
- pd->px = x2;
- pd->py = y2;
- data[0] = x1;
- data[1] = y1;
- data[2] = x2;
- data[3] = y2;
- data[4] = x3;
- data[5] = y3;
- *num_coords = 6;
- return VG_CUBIC_TO_ABS;
- }
- break;
- case VG_SCCWARC_TO:
- case VG_SCWARC_TO:
- case VG_LCCWARC_TO:
- case VG_LCWARC_TO: {
- data_at(&pd->coords, pd->path, 0, 5, data);
- map_if_relative(pd->ox, pd->oy, relative, &data[3], &data[4]);
- pd->ox = data[3];
- pd->oy = data[4];
- pd->px = data[3];
- pd->py = data[4];
- *num_coords = 5;
- return command | VG_ABSOLUTE;
- }
- break;
- default:
- abort();
- assert(!"Unknown segment!");
- return 0;
- }
-}
-
-static void linearly_interpolate(VGfloat *result,
- const VGfloat *start,
- const VGfloat *end,
- VGfloat amount,
- VGint number)
-{
- VGint i;
- for (i = 0; i < number; ++i) {
- result[i] = start[i] + (end[i] - start[i]) * amount;
- }
-}
-
-VGboolean path_interpolate(struct path *dst,
- struct path *start, struct path *end,
- VGfloat amount)
-{
- /* temporary path that we can discard if it will turn
- * out that start is not compatible with end */
- struct path *res_path = path_create(dst->datatype,
- 1.0, 0.0,
- 0, 0, dst->caps);
- VGint i;
- VGfloat start_coords[8];
- VGfloat end_coords[8];
- VGfloat results[8];
- VGubyte common_data[sizeof(VGfloat)*8];
- struct path_iter_data start_iter, end_iter;
-
- memset(&start_iter, 0, sizeof(struct path_iter_data));
- memset(&end_iter, 0, sizeof(struct path_iter_data));
-
- start_iter.path = start;
- start_iter.coords = start->control_points->data;
- end_iter.path = end;
- end_iter.coords = end->control_points->data;
-
- for (i = 0; i < start->num_segments; ++i) {
- VGubyte segment;
- VGubyte ssegment, esegment;
- VGint snum_coords, enum_coords;
- start_iter.segment = ((VGubyte*)(start->segments->data))[i];
- end_iter.segment = ((VGubyte*)(end->segments->data))[i];
-
- ssegment = normalize_coords(&start_iter, &snum_coords,
- start_coords);
- esegment = normalize_coords(&end_iter, &enum_coords,
- end_coords);
-
- if (is_segment_arc(ssegment)) {
- if (!is_segment_arc(esegment)) {
- path_destroy(res_path);
- return VG_FALSE;
- }
- if (amount > 0.5)
- segment = esegment;
- else
- segment = ssegment;
- } else if (is_segment_arc(esegment)) {
- path_destroy(res_path);
- return VG_FALSE;
- }
- else if (ssegment != esegment) {
- path_destroy(res_path);
- return VG_FALSE;
- }
- else
- segment = ssegment;
-
- linearly_interpolate(results, start_coords, end_coords,
- amount, snum_coords);
- vg_float_to_datatype(dst->datatype, common_data, results, snum_coords);
- path_append_data(res_path, 1, &segment, common_data);
- }
-
- path_append_path(dst, res_path);
- path_destroy(res_path);
-
- dst->dirty = VG_TRUE;
- dst->dirty_stroke = VG_TRUE;
-
- return VG_TRUE;
-}
-
-void path_clear(struct path *p, VGbitfield capabilities)
-{
- path_set_capabilities(p, capabilities);
- array_destroy(p->segments);
- array_destroy(p->control_points);
- p->segments = array_create(size_for_datatype(VG_PATH_DATATYPE_S_8));
- p->control_points = array_create(size_for_datatype(p->datatype));
- p->num_segments = 0;
- p->dirty = VG_TRUE;
- p->dirty_stroke = VG_TRUE;
-}
-
-struct path * path_create_stroke(struct path *p,
- struct matrix *matrix)
-{
- VGint i;
- VGfloat sx, sy, px, py, ox, oy;
- VGfloat x0, y0, x1, y1, x2, y2, x3, y3;
- VGfloat data[8];
- void *coords = (VGfloat *)p->control_points->data;
- int dashed = (p->base.ctx->state.vg.stroke.dash_pattern_num ? 1 : 0);
- struct dash_stroker stroker;
- struct vg_state *vg_state = &p->base.ctx->state.vg;
-
- if (p->stroked.path)
- {
- /* ### compare the dash patterns to see if we can cache them.
- * for now we simply always bail out if the path is dashed.
- */
- if (memcmp( &p->stroked.matrix,
- matrix,
- sizeof *matrix ) == 0 &&
- !dashed && !p->dirty_stroke &&
- floatsEqual(p->stroked.stroke_width, vg_state->stroke.line_width.f) &&
- floatsEqual(p->stroked.miter_limit, vg_state->stroke.miter_limit.f) &&
- p->stroked.cap_style == vg_state->stroke.cap_style &&
- p->stroked.join_style == vg_state->stroke.join_style)
- {
- return p->stroked.path;
- }
- else {
- path_destroy( p->stroked.path );
- p->stroked.path = NULL;
- }
- }
-
-
- sx = sy = px = py = ox = oy = 0.f;
-
- if (dashed)
- dash_stroker_init((struct stroker *)&stroker, vg_state);
- else
- stroker_init((struct stroker *)&stroker, vg_state);
-
- stroker_begin((struct stroker *)&stroker);
-
- for (i = 0; i < p->num_segments; ++i) {
- VGubyte segment = ((VGubyte*)(p->segments->data))[i];
- VGint command = SEGMENT_COMMAND(segment);
- VGboolean relative = SEGMENT_ABS_REL(segment);
-
- switch(command) {
- case VG_CLOSE_PATH: {
- VGfloat x0 = sx;
- VGfloat y0 = sy;
- matrix_map_point(matrix, x0, y0, &x0, &y0);
- stroker_line_to((struct stroker *)&stroker, x0, y0);
- }
- break;
- case VG_MOVE_TO:
- data_at(&coords, p, 0, 2, data);
- x0 = data[0];
- y0 = data[1];
- map_if_relative(ox, oy, relative, &x0, &y0);
- sx = x0;
- sy = y0;
- ox = x0;
- oy = y0;
- px = x0;
- py = y0;
- matrix_map_point(matrix, x0, y0, &x0, &y0);
- stroker_move_to((struct stroker *)&stroker, x0, y0);
- break;
- case VG_LINE_TO:
- data_at(&coords, p, 0, 2, data);
- x0 = data[0];
- y0 = data[1];
- map_if_relative(ox, oy, relative, &x0, &y0);
- ox = x0;
- oy = y0;
- px = x0;
- py = y0;
- matrix_map_point(matrix, x0, y0, &x0, &y0);
- stroker_line_to((struct stroker *)&stroker, x0, y0);
- break;
- case VG_HLINE_TO:
- data_at(&coords, p, 0, 1, data);
- x0 = data[0];
- y0 = oy;
- map_if_relative(ox, oy, relative, &x0, 0);
- ox = x0;
- px = x0;
- py = y0;
- matrix_map_point(matrix, x0, y0, &x0, &y0);
- stroker_line_to((struct stroker *)&stroker, x0, y0);
- break;
- case VG_VLINE_TO:
- data_at(&coords, p, 0, 1, data);
- x0 = ox;
- y0 = data[0];
- map_if_relative(ox, oy, relative, 0, &y0);
- oy = y0;
- px = x0;
- py = y0;
- matrix_map_point(matrix, x0, y0, &x0, &y0);
- stroker_line_to((struct stroker *)&stroker, x0, y0);
- break;
- case VG_CUBIC_TO: {
- data_at(&coords, p, 0, 6, data);
- x0 = ox;
- y0 = oy;
- x1 = data[0];
- y1 = data[1];
- x2 = data[2];
- y2 = data[3];
- x3 = data[4];
- y3 = data[5];
- map_if_relative(ox, oy, relative, &x1, &y1);
- map_if_relative(ox, oy, relative, &x2, &y2);
- map_if_relative(ox, oy, relative, &x3, &y3);
- if (floatsEqual(x1, ox) && floatsEqual(y1, oy) &&
- floatsEqual(x1, x2) && floatsEqual(y1, y2) &&
- floatsEqual(x2, x3) && floatsEqual(y2, y3)) {
- /*ignore the empty segment */
- continue;
- } else if (floatsEqual(x3, ox) && floatsEqual(y3, oy)) {
- /* if dup vertex, emit a line */
- ox = x3;
- oy = y3;
- matrix_map_point(matrix, x3, y3, &x3, &y3);
- stroker_line_to((struct stroker *)&stroker, x3, y3);
- continue;
- }
- ox = x3;
- oy = y3;
- px = x2;
- py = y2;
- assert(matrix_is_affine(matrix));
- matrix_map_point(matrix, x0, y0, &x0, &y0);
- matrix_map_point(matrix, x1, y1, &x1, &y1);
- matrix_map_point(matrix, x2, y2, &x2, &y2);
- matrix_map_point(matrix, x3, y3, &x3, &y3);
- stroker_curve_to((struct stroker *)&stroker, x1, y1, x2, y2, x3, y3);
- }
- break;
- case VG_QUAD_TO: {
- data_at(&coords, p, 0, 4, data);
- x0 = ox;
- y0 = oy;
- x1 = data[0];
- y1 = data[1];
- x3 = data[2];
- y3 = data[3];
- map_if_relative(ox, oy, relative, &x1, &y1);
- map_if_relative(ox, oy, relative, &x3, &y3);
- px = x1;
- py = y1;
- { /* form a cubic out of it */
- x2 = (x3 + 2*x1) / 3.f;
- y2 = (y3 + 2*y1) / 3.f;
- x1 = (x0 + 2*x1) / 3.f;
- y1 = (y0 + 2*y1) / 3.f;
- }
- if (floatsEqual(x1, ox) && floatsEqual(y1, oy) &&
- floatsEqual(x1, x2) && floatsEqual(y1, y2) &&
- floatsEqual(x2, x3) && floatsEqual(y2, y3)) {
- /*ignore the empty segment */
- continue;
- } else if (floatsEqual(x3, ox) && floatsEqual(y3, oy)) {
- /* if dup vertex, emit a line */
- ox = x3;
- oy = y3;
- matrix_map_point(matrix, x3, y3, &x3, &y3);
- stroker_line_to((struct stroker *)&stroker, x3, y3);
- continue;
- }
- ox = x3;
- oy = y3;
- assert(matrix_is_affine(matrix));
- matrix_map_point(matrix, x0, y0, &x0, &y0);
- matrix_map_point(matrix, x1, y1, &x1, &y1);
- matrix_map_point(matrix, x2, y2, &x2, &y2);
- matrix_map_point(matrix, x3, y3, &x3, &y3);
- stroker_curve_to((struct stroker *)&stroker, x1, y1, x2, y2, x3, y3);
- }
- break;
- case VG_SQUAD_TO: {
- data_at(&coords, p, 0, 2, data);
- x0 = ox;
- y0 = oy;
- x1 = 2*ox-px;
- y1 = 2*oy-py;
- x3 = data[0];
- y3 = data[1];
- map_if_relative(ox, oy, relative, &x3, &y3);
- px = x1;
- py = y1;
- { /* form a cubic out of it */
- x2 = (x3 + 2*x1) / 3.f;
- y2 = (y3 + 2*y1) / 3.f;
- x1 = (x0 + 2*x1) / 3.f;
- y1 = (y0 + 2*y1) / 3.f;
- }
- if (floatsEqual(x1, ox) && floatsEqual(y1, oy) &&
- floatsEqual(x1, x2) && floatsEqual(y1, y2) &&
- floatsEqual(x2, x3) && floatsEqual(y2, y3)) {
- /*ignore the empty segment */
- continue;
- } else if (floatsEqual(x3, ox) && floatsEqual(y3, oy)) {
- /* if dup vertex, emit a line */
- ox = x3;
- oy = y3;
- matrix_map_point(matrix, x3, y3, &x3, &y3);
- stroker_line_to((struct stroker *)&stroker, x3, y3);
- continue;
- }
- ox = x3;
- oy = y3;
- assert(matrix_is_affine(matrix));
- matrix_map_point(matrix, x0, y0, &x0, &y0);
- matrix_map_point(matrix, x1, y1, &x1, &y1);
- matrix_map_point(matrix, x2, y2, &x2, &y2);
- matrix_map_point(matrix, x3, y3, &x3, &y3);
- stroker_curve_to((struct stroker *)&stroker, x1, y1, x2, y2, x3, y3);
- }
- break;
- case VG_SCUBIC_TO: {
- data_at(&coords, p, 0, 4, data);
- x0 = ox;
- y0 = oy;
- x1 = 2*ox-px;
- y1 = 2*oy-py;
- x2 = data[0];
- y2 = data[1];
- x3 = data[2];
- y3 = data[3];
- map_if_relative(ox, oy, relative, &x2, &y2);
- map_if_relative(ox, oy, relative, &x3, &y3);
- if (floatsEqual(x1, ox) && floatsEqual(y1, oy) &&
- floatsEqual(x1, x2) && floatsEqual(y1, y2) &&
- floatsEqual(x2, x3) && floatsEqual(y2, y3)) {
- /*ignore the empty segment */
- continue;
- } else if (floatsEqual(x3, ox) && floatsEqual(y3, oy)) {
- /* if dup vertex, emit a line */
- ox = x3;
- oy = y3;
- matrix_map_point(matrix, x3, y3, &x3, &y3);
- stroker_line_to((struct stroker *)&stroker, x3, y3);
- continue;
- }
- ox = x3;
- oy = y3;
- px = x2;
- py = y2;
- assert(matrix_is_affine(matrix));
- matrix_map_point(matrix, x0, y0, &x0, &y0);
- matrix_map_point(matrix, x1, y1, &x1, &y1);
- matrix_map_point(matrix, x2, y2, &x2, &y2);
- matrix_map_point(matrix, x3, y3, &x3, &y3);
- stroker_curve_to((struct stroker *)&stroker, x1, y1, x2, y2, x3, y3);
- }
- break;
- case VG_SCCWARC_TO:
- case VG_SCWARC_TO:
- case VG_LCCWARC_TO:
- case VG_LCWARC_TO: {
- VGfloat rh, rv, rot;
- struct arc arc;
-
- data_at(&coords, p, 0, 5, data);
- x0 = ox;
- y0 = oy;
- rh = data[0];
- rv = data[1];
- rot = data[2];
- x1 = data[3];
- y1 = data[4];
- map_if_relative(ox, oy, relative, &x1, &y1);
- if (floatsEqual(x1, ox) && floatsEqual(y1, oy)) {
- /* if dup vertex, emit a line */
- ox = x1;
- oy = y1;
- matrix_map_point(matrix, x1, y1, &x1, &y1);
- stroker_line_to((struct stroker *)&stroker, x1, y1);
- continue;
- }
- arc_init(&arc, command, x0, y0, x1, y1,
- rh, rv, rot);
- arc_stroke_cb(&arc, (struct stroker *)&stroker,
- matrix);
- ox = x1;
- oy = y1;
- px = x1;
- py = y1;
- }
- break;
- default:
- abort();
- assert(!"Unknown segment!");
- }
- }
-
- stroker_end((struct stroker *)&stroker);
-
- if (dashed)
- dash_stroker_cleanup((struct dash_stroker *)&stroker);
- else
- stroker_cleanup((struct stroker *)&stroker);
-
- p->stroked.path = stroker.base.path;
- p->stroked.matrix = *matrix;
- p->dirty_stroke = VG_FALSE;
- p->stroked.stroke_width = vg_state->stroke.line_width.f;
- p->stroked.miter_limit = vg_state->stroke.miter_limit.f;
- p->stroked.cap_style = vg_state->stroke.cap_style;
- p->stroked.join_style = vg_state->stroke.join_style;
-
- return stroker.base.path;
-}
-
-void path_render(struct path *p, VGbitfield paintModes,
- struct matrix *mat)
-{
- struct vg_context *ctx = vg_current_context();
- struct matrix paint_matrix;
-
- vg_validate_state(ctx);
-
- shader_set_drawing_image(ctx->shader, VG_FALSE);
- shader_set_image(ctx->shader, 0);
-#if 0
- fprintf(stderr, "Matrix(11=%f 12=%f 13=%f 21=%f 22=%f 23=%f 31=%f 32=%f 33=%f)\n",
- mat->m[0], mat->m[1], mat->m[2],
- mat->m[3], mat->m[4], mat->m[5],
- mat->m[6], mat->m[7], mat->m[8]);
-#endif
- if ((paintModes & VG_FILL_PATH) &&
- vg_get_paint_matrix(ctx,
- &ctx->state.vg.fill_paint_to_user_matrix,
- mat,
- &paint_matrix)) {
- /* First the fill */
- shader_set_surface_matrix(ctx->shader, mat);
- shader_set_paint(ctx->shader, ctx->state.vg.fill_paint);
- shader_set_paint_matrix(ctx->shader, &paint_matrix);
- shader_bind(ctx->shader);
- path_fill(p);
- }
-
- if ((paintModes & VG_STROKE_PATH) &&
- vg_get_paint_matrix(ctx,
- &ctx->state.vg.stroke_paint_to_user_matrix,
- mat,
- &paint_matrix)) {
- /* 8.7.5: "line width less than or equal to 0 prevents stroking from
- * taking place."*/
- if (ctx->state.vg.stroke.line_width.f <= 0)
- return;
- shader_set_surface_matrix(ctx->shader, mat);
- shader_set_paint(ctx->shader, ctx->state.vg.stroke_paint);
- shader_set_paint_matrix(ctx->shader, &paint_matrix);
- shader_bind(ctx->shader);
- path_stroke(p);
- }
-}
-
-void path_fill(struct path *p)
-{
- struct vg_context *ctx = vg_current_context();
- struct matrix identity;
-
- matrix_load_identity(&identity);
-
- {
- struct polygon_array *polygon_array = path_get_fill_polygons(p, &identity);
- struct array *polys = polygon_array->array;
-
- if (!polygon_array || !polys || !polys->num_elements) {
- return;
- }
- polygon_array_fill(polygon_array, ctx);
- }
-}
-
-void path_stroke(struct path *p)
-{
- struct vg_context *ctx = vg_current_context();
- VGFillRule old_fill = ctx->state.vg.fill_rule;
- struct matrix identity;
- struct path *stroke;
-
- matrix_load_identity(&identity);
- stroke = path_create_stroke(p, &identity);
- if (stroke && !path_is_empty(stroke)) {
- ctx->state.vg.fill_rule = VG_NON_ZERO;
-
- path_fill(stroke);
-
- ctx->state.vg.fill_rule = old_fill;
- }
-}
-
-void path_move_to(struct path *p, float x, float y)
-{
- VGubyte segment = VG_MOVE_TO_ABS;
- VGubyte common_data[sizeof(VGfloat) * 2];
- VGfloat data[2] = {x, y};
-
- vg_float_to_datatype(p->datatype, common_data, data, 2);
- path_append_data(p, 1, &segment, common_data);
-}
-
-void path_line_to(struct path *p, float x, float y)
-{
- VGubyte segment = VG_LINE_TO_ABS;
- VGubyte common_data[sizeof(VGfloat) * 2];
- VGfloat data[2] = {x, y};
-
- vg_float_to_datatype(p->datatype, common_data, data, 2);
-
- path_append_data(p, 1, &segment, common_data);
-}
-
-void path_cubic_to(struct path *p, float px1, float py1,
- float px2, float py2,
- float x, float y)
-{
- VGubyte segment = VG_CUBIC_TO_ABS;
- VGubyte common_data[sizeof(VGfloat) * 6];
- VGfloat data[6];
-
- data[0] = px1; data[1] = py1;
- data[2] = px2; data[3] = py2;
- data[4] = x; data[5] = y;
-
- vg_float_to_datatype(p->datatype, common_data, data, 6);
-
- path_append_data(p, 1, &segment, common_data);
-}
-
-static INLINE void line_bounds(VGfloat *line /*x1,y1,x2,y2*/,
- VGfloat *bounds)
-{
- bounds[0] = MIN2(line[0], line[2]);
- bounds[1] = MIN2(line[1], line[3]);
- bounds[2] = MAX2(line[0], line[2]) - bounds[0];
- bounds[3] = MAX2(line[1], line[3]) - bounds[1];
-}
-
-static INLINE void unite_bounds(VGfloat *bounds,
- VGfloat *el)
-{
- VGfloat cx1, cy1, cx2, cy2;
- VGfloat nx1, ny1, nx2, ny2;
-
- cx1 = bounds[0];
- cy1 = bounds[1];
- cx2 = bounds[0] + bounds[2];
- cy2 = bounds[1] + bounds[3];
-
- nx1 = el[0];
- ny1 = el[1];
- nx2 = el[0] + el[2];
- ny2 = el[1] + el[3];
-
- bounds[0] = MIN2(cx1, nx1);
- bounds[1] = MIN2(cy1, ny1);
- bounds[2] = MAX2(cx2, nx2) - bounds[0];
- bounds[3] = MAX2(cy2, ny2) - bounds[1];
-}
-
-static INLINE void set_bounds(VGfloat *bounds,
- VGfloat *element_bounds,
- VGboolean *initialized)
-{
- if (!(*initialized)) {
- memcpy(bounds, element_bounds, 4 * sizeof(VGfloat));
- *initialized = VG_TRUE;
- } else
- unite_bounds(bounds, element_bounds);
-}
-
-void path_bounding_rect(struct path *p, float *x, float *y,
- float *w, float *h)
-{
- VGint i;
- VGfloat coords[8];
- struct path_iter_data iter;
- VGint num_coords;
- VGfloat bounds[4];
- VGfloat element_bounds[4];
- VGfloat ox, oy;
- VGboolean bounds_inited = VG_FALSE;
-
- memset(&iter, 0, sizeof(struct path_iter_data));
- memset(&bounds, 0, sizeof(bounds));
-
- if (!p->num_segments) {
- bounds[2] = -1;
- bounds[3] = -1;
- }
-
-
- iter.path = p;
- iter.coords = p->control_points->data;
-
- for (i = 0; i < p->num_segments; ++i) {
- VGubyte segment;
- iter.segment = ((VGubyte*)(p->segments->data))[i];
-
- ox = iter.ox;
- oy = iter.oy;
-
- segment = normalize_coords(&iter, &num_coords, coords);
-
- switch(segment) {
- case VG_CLOSE_PATH:
- case VG_MOVE_TO_ABS:
- break;
- case VG_LINE_TO_ABS: {
- VGfloat line[4] = {ox, oy, coords[0], coords[1]};
- line_bounds(line, element_bounds);
- set_bounds(bounds, element_bounds, &bounds_inited);
- }
- break;
- case VG_CUBIC_TO_ABS: {
- struct bezier bezier;
- bezier_init(&bezier, ox, oy,
- coords[0], coords[1],
- coords[2], coords[3],
- coords[4], coords[5]);
- bezier_exact_bounds(&bezier, element_bounds);
- set_bounds(bounds, element_bounds, &bounds_inited);
- }
- break;
- case VG_SCCWARC_TO:
- case VG_SCWARC_TO:
- case VG_LCCWARC_TO:
- case VG_LCWARC_TO: {
- struct arc arc;
- struct matrix identity;
- struct path *path = path_create(VG_PATH_DATATYPE_F,
- 1, 0, 0, 0, VG_PATH_CAPABILITY_ALL);
-
- matrix_load_identity(&identity);
- arc_init(&arc, segment,
- ox, oy, coords[3], coords[4],
- coords[0], coords[1], coords[2]);
-
- arc_to_path(&arc, path, &identity);
-
- path_bounding_rect(path, element_bounds + 0, element_bounds + 1,
- element_bounds + 2, element_bounds + 3);
- set_bounds(bounds, element_bounds, &bounds_inited);
- }
- break;
- default:
- assert(0);
- }
- }
-
- *x = bounds[0];
- *y = bounds[1];
- *w = bounds[2];
- *h = bounds[3];
-}
-
-float path_length(struct path *p, int start_segment, int num_segments)
-{
- VGint i;
- VGfloat coords[8];
- struct path_iter_data iter;
- VGint num_coords;
- VGfloat length = 0;
- VGfloat ox, oy;
- VGboolean in_range = VG_FALSE;
-
- memset(&iter, 0, sizeof(struct path_iter_data));
-
- iter.path = p;
- iter.coords = p->control_points->data;
-
- for (i = 0; i < (start_segment + num_segments); ++i) {
- VGubyte segment;
-
- iter.segment = ((VGubyte*)(p->segments->data))[i];
-
- ox = iter.ox;
- oy = iter.oy;
-
- segment = normalize_coords(&iter, &num_coords, coords);
-
- in_range = (i >= start_segment) && i <= (start_segment + num_segments);
- if (!in_range)
- continue;
-
- switch(segment) {
- case VG_MOVE_TO_ABS:
- break;
- case VG_CLOSE_PATH: {
- VGfloat line[4] = {ox, oy, iter.sx, iter.sy};
- length += line_lengthv(line);
- }
- break;
- case VG_LINE_TO_ABS: {
- VGfloat line[4] = {ox, oy, coords[0], coords[1]};
- length += line_lengthv(line);
- }
- break;
- case VG_CUBIC_TO_ABS: {
- struct bezier bezier;
- bezier_init(&bezier, ox, oy,
- coords[0], coords[1],
- coords[2], coords[3],
- coords[4], coords[5]);
- length += bezier_length(&bezier, BEZIER_DEFAULT_ERROR);
- }
- break;
- case VG_SCCWARC_TO:
- case VG_SCWARC_TO:
- case VG_LCCWARC_TO:
- case VG_LCWARC_TO: {
- struct arc arc;
- struct matrix identity;
- struct path *path = path_create(VG_PATH_DATATYPE_F,
- 1, 0, 0, 0, VG_PATH_CAPABILITY_ALL);
-
- matrix_load_identity(&identity);
- arc_init(&arc, segment,
- ox, oy, coords[3], coords[4],
- coords[0], coords[1], coords[2]);
-
- arc_to_path(&arc, path, &identity);
-
- length += path_length(path, 0, path_num_segments(path));
- }
- break;
- default:
- assert(0);
- }
- }
-
- return length;
-}
-
-static INLINE VGboolean point_on_current_segment(VGfloat distance,
- VGfloat length,
- VGfloat segment_length)
-{
- return
- (((floatIsZero(distance) || distance < 0) && floatIsZero(length)) ||
- ((distance > length || floatsEqual(distance, length)) &&
- (floatsEqual(distance, length + segment_length) ||
- distance < (length + segment_length))));
-}
-
-static VGboolean path_point_segment(struct path_iter_data iter,
- struct path_iter_data prev_iter,
- VGfloat coords[8],
- VGfloat distance,
- VGfloat length, VGfloat *current_length,
- VGfloat *point, VGfloat *normal)
-{
- switch (iter.segment) {
- case VG_MOVE_TO_ABS:
- break;
- case VG_CLOSE_PATH: {
- VGfloat line[4] = {prev_iter.ox, prev_iter.oy, iter.sx, iter.sy};
- VGboolean on_current_segment = VG_FALSE;
- *current_length = line_lengthv(line);
- on_current_segment = point_on_current_segment(distance,
- length,
- *current_length);
- if (on_current_segment) {
- VGfloat at = (distance - length) / line_lengthv(line);
- line_normal_vector(line, normal);
- line_point_at(line, at, point);
- return VG_TRUE;
- }
- }
- break;
- case VG_LINE_TO_ABS: {
- VGfloat line[4] = {prev_iter.ox, prev_iter.oy, coords[0], coords[1]};
- VGboolean on_current_segment = VG_FALSE;
- *current_length = line_lengthv(line);
- on_current_segment = point_on_current_segment(distance,
- length,
- *current_length);
- if (on_current_segment) {
- VGfloat at = (distance - length) / line_lengthv(line);
- line_normal_vector(line, normal);
- line_point_at(line, at, point);
- return VG_TRUE;
- }
- }
- break;
- case VG_CUBIC_TO_ABS: {
- struct bezier bezier;
- bezier_init(&bezier, prev_iter.ox, prev_iter.oy,
- coords[0], coords[1],
- coords[2], coords[3],
- coords[4], coords[5]);
- *current_length = bezier_length(&bezier, BEZIER_DEFAULT_ERROR);
- if (point_on_current_segment(distance, length, *current_length)) {
- bezier_point_at_length(&bezier, distance - length,
- point, normal);
- return VG_TRUE;
- }
- }
- break;
- case VG_SCCWARC_TO:
- case VG_SCWARC_TO:
- case VG_LCCWARC_TO:
- case VG_LCWARC_TO: {
- struct arc arc;
- struct matrix identity;
- struct path *path = path_create(VG_PATH_DATATYPE_F,
- 1, 0, 0, 0, VG_PATH_CAPABILITY_ALL);
-
- matrix_load_identity(&identity);
- arc_init(&arc, iter.segment,
- prev_iter.ox, prev_iter.oy, coords[3], coords[4],
- coords[0], coords[1], coords[2]);
-
- arc_to_path(&arc, path, &identity);
-
- *current_length = path_length(path, 0, path_num_segments(path));
- if (point_on_current_segment(distance, length, *current_length)) {
- path_point(path, 0, path_num_segments(path),
- distance - length, point, normal);
- return VG_TRUE;
- }
- }
- break;
- default:
- assert(0);
- }
- return VG_FALSE;
-}
-
-void path_point(struct path *p, VGint start_segment, VGint num_segments,
- VGfloat distance, VGfloat *point, VGfloat *normal)
-{
- VGint i;
- VGfloat coords[8];
- struct path_iter_data iter, prev_iter;
- VGint num_coords;
- VGfloat length = 0;
- VGfloat current_length = 0;
-
- memset(&iter, 0, sizeof(struct path_iter_data));
- memset(&prev_iter, 0, sizeof(struct path_iter_data));
-
- point[0] = 0;
- point[1] = 0;
-
- normal[0] = 0;
- normal[1] = -1;
-
- iter.path = p;
- iter.coords = p->control_points->data;
- if (distance < 0)
- distance = 0;
-
- for (i = 0; i < (start_segment + num_segments); ++i) {
- VGboolean outside_range = (i < start_segment ||
- i >= (start_segment + num_segments));
-
- prev_iter = iter;
-
- iter.segment = ((VGubyte*)(p->segments->data))[i];
- iter.segment = normalize_coords(&iter, &num_coords, coords);
-
- if (outside_range)
- continue;
-
- if (path_point_segment(iter, prev_iter, coords,
- distance, length, ¤t_length,
- point, normal))
- return;
-
- length += current_length;
- }
-
- /*
- *OpenVG 1.0 - 8.6.11 vgPointAlongPath
- *
- * If distance is greater than or equal to the path length
- *(i.e., the value returned by vgPathLength when called with the same
- *startSegment and numSegments parameters), the visual ending point of
- *the path is used.
- */
- {
- switch (iter.segment) {
- case VG_MOVE_TO_ABS:
- break;
- case VG_CLOSE_PATH: {
- VGfloat line[4] = {prev_iter.ox, prev_iter.oy, iter.sx, iter.sy};
- line_normal_vector(line, normal);
- line_point_at(line, 1.f, point);
- }
- break;
- case VG_LINE_TO_ABS: {
- VGfloat line[4] = {prev_iter.ox, prev_iter.oy, coords[0], coords[1]};
- line_normal_vector(line, normal);
- line_point_at(line, 1.f, point);
- }
- break;
- case VG_CUBIC_TO_ABS: {
- struct bezier bezier;
- bezier_init(&bezier, prev_iter.ox, prev_iter.oy,
- coords[0], coords[1],
- coords[2], coords[3],
- coords[4], coords[5]);
- bezier_point_at_t(&bezier, 1.f, point, normal);
- }
- break;
- case VG_SCCWARC_TO:
- case VG_SCWARC_TO:
- case VG_LCCWARC_TO:
- case VG_LCWARC_TO: {
- struct arc arc;
- struct matrix identity;
- struct path *path = path_create(VG_PATH_DATATYPE_F,
- 1, 0, 0, 0, VG_PATH_CAPABILITY_ALL);
-
- matrix_load_identity(&identity);
- arc_init(&arc, iter.segment,
- prev_iter.ox, prev_iter.oy, coords[3], coords[4],
- coords[0], coords[1], coords[2]);
-
- arc_to_path(&arc, path, &identity);
-
- path_point(path, 0, path_num_segments(path),
- /* to make sure we're bigger than len * 2 it */
- 2 * path_length(path, 0, path_num_segments(path)),
- point, normal);
- }
- break;
- default:
- assert(0);
- }
- }
-}
-
-VGboolean path_is_empty(struct path *p)
-{
- return p->segments->num_elements == 0;
-}
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#ifndef _PATH_H
-#define _PATH_H
-
-#include "VG/openvg.h"
-
-struct path;
-struct polygon;
-struct matrix;
-
-enum fill_rule {
- ODD_EVEN_FILL,
- WINDING_FILL
-};
-
-
-struct path_for_each_data {
- VGubyte segment;
- /* all coords are absolute, even if segment is relative */
- const VGfloat *coords;
- VGfloat sx, sy, ox, oy, px, py;
- void *user_data;
-};
-
-typedef VGboolean (*path_for_each_cb)(struct path *p,
- struct path_for_each_data *data);
-
-
-struct path *path_create(VGPathDatatype dt, VGfloat scale, VGfloat bias,
- VGint segmentCapacityHint,
- VGint coordCapacityHint,
- VGbitfield capabilities);
-void path_destroy(struct path *p);
-
-VGbitfield path_capabilities(struct path *p);
-void path_set_capabilities(struct path *p, VGbitfield bf);
-
-void path_append_data(struct path *p,
- VGint numSegments,
- const VGubyte * pathSegments,
- const void * pathData);
-
-void path_append_path(struct path *dst,
- struct path *src);
-
-VGint path_num_segments(struct path *p);
-
-void path_bounding_rect(struct path *p, float *x, float *y,
- float *w, float *h);
-float path_length(struct path *p, int start_segment, int num_segments);
-
-void path_set_fill_rule(enum fill_rule fill);
-enum fill_rule path_fill_rule(enum fill_rule fill);
-
-VGboolean path_is_empty(struct path *p);
-
-VGbyte path_datatype_size(struct path *p);
-
-VGPathDatatype path_datatype(struct path *p);
-VGfloat path_scale(struct path *p);
-VGfloat path_bias(struct path *p);
-VGint path_num_coords(struct path *p);
-
-void path_modify_coords(struct path *p,
- VGint startIndex,
- VGint numSegments,
- const void * pathData);
-
-struct path *path_create_stroke(struct path *p,
- struct matrix *m);
-
-void path_for_each_segment(struct path *path,
- path_for_each_cb cb,
- void *user_data);
-
-void path_transform(struct path *dst, struct path *src);
-VGboolean path_interpolate(struct path *dst,
- struct path *start, struct path *end,
- VGfloat amount);
-
-void path_clear(struct path *p, VGbitfield capabilities);
-void path_render(struct path *p, VGbitfield paintModes, struct matrix *mat);
-void path_fill(struct path *p);
-void path_stroke(struct path *p);
-
-void path_move_to(struct path *p, float x, float y);
-void path_line_to(struct path *p, float x, float y);
-void path_cubic_to(struct path *p, float px1, float py1,
- float px2, float py2,
- float x, float y);
-
-void path_point(struct path *p, VGint startSegment, VGint numSegments,
- VGfloat distance, VGfloat *point, VGfloat *normal);
-
-
-
-void vg_float_to_datatype(VGPathDatatype datatype,
- VGubyte *common_data,
- const VGfloat *data,
- VGint num_coords);
-#endif
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#ifndef PATH_UTILS_H
-#define PATH_UTILS_H
-
-#include "VG/openvg.h"
-
-#define SEGMENT_COMMAND(command) /* Extract segment type */ \
- ((command) & 0x1e)
-#define SEGMENT_ABS_REL(command) /* Extract absolute/relative bit */ \
- ((command) & 0x1)
-
-static INLINE VGint size_for_datatype(VGPathDatatype datatype)
-{
- switch(datatype) {
- case VG_PATH_DATATYPE_S_8:
- return 1;
- case VG_PATH_DATATYPE_S_16:
- return 2;
- case VG_PATH_DATATYPE_S_32:
- return 4;
- case VG_PATH_DATATYPE_F:
- return 4;
- default:
- assert(!"unknown datatype");
- }
- return 0;
-}
-
-static INLINE VGint num_elements_for_segments(const VGubyte *segments,
- VGint num_segments)
-{
- VGint i;
- VGint count = 0;
-
- for (i = 0; i < num_segments; ++i) {
- VGubyte segment = segments[i];
- VGint command = SEGMENT_COMMAND(segment);
- switch(command) {
- case VG_CLOSE_PATH:
- break;
- case VG_MOVE_TO:
- count += 2;
- break;
- case VG_LINE_TO:
- count += 2;
- break;
- case VG_HLINE_TO:
- count += 1;
- break;
- case VG_VLINE_TO:
- count += 1;
- break;
- case VG_QUAD_TO:
- count += 4;
- break;
- case VG_CUBIC_TO:
- count += 6;
- break;
- case VG_SQUAD_TO:
- count += 2;
- break;
- case VG_SCUBIC_TO:
- count += 4;
- break;
- case VG_SCCWARC_TO:
- count += 5;
- break;
- case VG_SCWARC_TO:
- count += 5;
- break;
- case VG_LCCWARC_TO:
- count += 5;
- break;
- case VG_LCWARC_TO:
- count += 5;
- break;
- default:
- assert(!"Unknown segment!");
- }
- }
- return count;
-}
-
-#endif
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#include "polygon.h"
-
-#include "matrix.h" /*for floatsEqual*/
-#include "vg_context.h"
-#include "vg_state.h"
-#include "renderer.h"
-#include "util_array.h"
-#include "VG/openvg.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_defines.h"
-#include "pipe/p_state.h"
-#include "util/u_inlines.h"
-#include "pipe/p_screen.h"
-
-#include "util/u_draw_quad.h"
-#include "util/u_math.h"
-
-#include <string.h>
-#include <stdlib.h>
-
-#define DEBUG_POLYGON 0
-
-#define COMPONENTS 2
-
-struct polygon
-{
- VGfloat *data;
- VGint size;
-
- VGint num_verts;
-
- VGboolean dirty;
- void *user_vbuf;
- struct pipe_screen *screen;
-};
-
-static float *ptr_to_vertex(float *data, int idx)
-{
- return data + (idx * COMPONENTS);
-}
-
-#if 0
-static void polygon_print(struct polygon *poly)
-{
- int i;
- float *vert;
- debug_printf("Polygon %p, size = %d\n", poly, poly->num_verts);
- for (i = 0; i < poly->num_verts; ++i) {
- vert = ptr_to_vertex(poly->data, i);
- debug_printf("%f, %f, ", vert[0], vert[1]);
- }
- debug_printf("\nend\n");
-}
-#endif
-
-
-struct polygon * polygon_create(int size)
-{
- struct polygon *poly = malloc(sizeof(struct polygon));
-
- poly->data = malloc(sizeof(float) * COMPONENTS * size);
- poly->size = size;
- poly->num_verts = 0;
- poly->dirty = VG_TRUE;
- poly->user_vbuf = NULL;
-
- return poly;
-}
-
-struct polygon * polygon_create_from_data(float *data, int size)
-{
- struct polygon *poly = polygon_create(size);
-
- memcpy(poly->data, data, sizeof(float) * COMPONENTS * size);
- poly->num_verts = size;
- poly->dirty = VG_TRUE;
- poly->user_vbuf = NULL;
-
- return poly;
-}
-
-void polygon_destroy(struct polygon *poly)
-{
- free(poly->data);
- free(poly);
-}
-
-void polygon_resize(struct polygon *poly, int new_size)
-{
- float *data = malloc(sizeof(float) * COMPONENTS * new_size);
- int size = MIN2(sizeof(float) * COMPONENTS * new_size,
- sizeof(float) * COMPONENTS * poly->size);
- memcpy(data, poly->data, size);
- free(poly->data);
- poly->data = data;
- poly->size = new_size;
- poly->dirty = VG_TRUE;
-}
-
-int polygon_size(struct polygon *poly)
-{
- return poly->size;
-}
-
-int polygon_vertex_count(struct polygon *poly)
-{
- return poly->num_verts;
-}
-
-float * polygon_data(struct polygon *poly)
-{
- return poly->data;
-}
-
-void polygon_vertex_append(struct polygon *p,
- float x, float y)
-{
- float *vert;
-#if DEBUG_POLYGON
- debug_printf("Append vertex [%f, %f]\n", x, y);
-#endif
- if (p->num_verts >= p->size) {
- polygon_resize(p, p->size * 2);
- }
-
- vert = ptr_to_vertex(p->data, p->num_verts);
- vert[0] = x;
- vert[1] = y;
- ++p->num_verts;
- p->dirty = VG_TRUE;
-}
-
-void polygon_set_vertex(struct polygon *p, int idx,
- float x, float y)
-{
- float *vert;
- if (idx >= p->num_verts) {
- /*fixme: error reporting*/
- abort();
- return;
- }
-
- vert = ptr_to_vertex(p->data, idx);
- vert[0] = x;
- vert[1] = y;
- p->dirty = VG_TRUE;
-}
-
-void polygon_vertex(struct polygon *p, int idx,
- float *vertex)
-{
- float *vert;
- if (idx >= p->num_verts) {
- /*fixme: error reporting*/
- abort();
- return;
- }
-
- vert = ptr_to_vertex(p->data, idx);
- vertex[0] = vert[0];
- vertex[1] = vert[1];
-}
-
-void polygon_bounding_rect(struct polygon *p,
- float *rect)
-{
- int i;
- float minx, miny, maxx, maxy;
- float *vert = ptr_to_vertex(p->data, 0);
- minx = vert[0];
- maxx = vert[0];
- miny = vert[1];
- maxy = vert[1];
-
- for (i = 1; i < p->num_verts; ++i) {
- vert = ptr_to_vertex(p->data, i);
- minx = MIN2(vert[0], minx);
- miny = MIN2(vert[1], miny);
-
- maxx = MAX2(vert[0], maxx);
- maxy = MAX2(vert[1], maxy);
- }
-
- rect[0] = minx;
- rect[1] = miny;
- rect[2] = maxx - minx;
- rect[3] = maxy - miny;
-}
-
-int polygon_contains_point(struct polygon *p,
- float x, float y)
-{
- return 0;
-}
-
-void polygon_append_polygon(struct polygon *dst,
- struct polygon *src)
-{
- if (dst->num_verts + src->num_verts >= dst->size) {
- polygon_resize(dst, dst->num_verts + src->num_verts * 1.5);
- }
- memcpy(ptr_to_vertex(dst->data, dst->num_verts),
- src->data, src->num_verts * COMPONENTS * sizeof(VGfloat));
- dst->num_verts += src->num_verts;
-}
-
-VGboolean polygon_is_closed(struct polygon *p)
-{
- VGfloat start[2], end[2];
-
- polygon_vertex(p, 0, start);
- polygon_vertex(p, p->num_verts - 1, end);
-
- return floatsEqual(start[0], end[0]) && floatsEqual(start[1], end[1]);
-}
-
-static void polygon_prepare_buffer(struct vg_context *ctx,
- struct polygon *poly)
-{
- struct pipe_context *pipe;
-
- /*polygon_print(poly);*/
-
- pipe = ctx->pipe;
-
- if (poly->user_vbuf == NULL || poly->dirty) {
- poly->screen = pipe->screen;
- poly->user_vbuf = poly->data;
- poly->dirty = VG_FALSE;
- }
-}
-
-void polygon_fill(struct polygon *poly, struct vg_context *ctx)
-{
- struct pipe_vertex_element velement;
- struct pipe_vertex_buffer vbuffer;
- VGfloat bounds[4];
- VGfloat min_x, min_y, max_x, max_y;
-
- assert(poly);
- polygon_bounding_rect(poly, bounds);
- min_x = bounds[0];
- min_y = bounds[1];
- max_x = bounds[0] + bounds[2];
- max_y = bounds[1] + bounds[3];
-
-#if DEBUG_POLYGON
- debug_printf("Poly bounds are [%f, %f], [%f, %f]\n",
- min_x, min_y, max_x, max_y);
-#endif
-
- polygon_prepare_buffer(ctx, poly);
-
- /* tell renderer about the vertex attributes */
- memset(&velement, 0, sizeof(velement));
- velement.src_offset = 0;
- velement.instance_divisor = 0;
- velement.vertex_buffer_index = 0;
- velement.src_format = PIPE_FORMAT_R32G32_FLOAT;
-
- /* tell renderer about the vertex buffer */
- memset(&vbuffer, 0, sizeof(vbuffer));
- vbuffer.user_buffer = poly->user_vbuf;
- vbuffer.stride = COMPONENTS * sizeof(float); /* vertex size */
-
- renderer_polygon_stencil_begin(ctx->renderer,
- &velement, ctx->state.vg.fill_rule, VG_FALSE);
- renderer_polygon_stencil(ctx->renderer, &vbuffer,
- PIPE_PRIM_TRIANGLE_FAN, 0, (VGuint) poly->num_verts);
- renderer_polygon_stencil_end(ctx->renderer);
-
- renderer_polygon_fill_begin(ctx->renderer, VG_FALSE);
- renderer_polygon_fill(ctx->renderer, min_x, min_y, max_x, max_y);
- renderer_polygon_fill_end(ctx->renderer);
-}
-
-void polygon_array_fill(struct polygon_array *polyarray, struct vg_context *ctx)
-{
- struct array *polys = polyarray->array;
- VGfloat min_x = polyarray->min_x;
- VGfloat min_y = polyarray->min_y;
- VGfloat max_x = polyarray->max_x;
- VGfloat max_y = polyarray->max_y;
- struct pipe_vertex_element velement;
- struct pipe_vertex_buffer vbuffer;
- VGint i;
-
-
-#if DEBUG_POLYGON
- debug_printf("%s: Poly bounds are [%f, %f], [%f, %f]\n",
- __FUNCTION__,
- min_x, min_y, max_x, max_y);
-#endif
-
- /* tell renderer about the vertex attributes */
- memset(&velement, 0, sizeof(velement));
- velement.src_offset = 0;
- velement.instance_divisor = 0;
- velement.vertex_buffer_index = 0;
- velement.src_format = PIPE_FORMAT_R32G32_FLOAT;
-
- /* tell renderer about the vertex buffer */
- memset(&vbuffer, 0, sizeof(vbuffer));
- vbuffer.stride = COMPONENTS * sizeof(float); /* vertex size */
-
- /* prepare the stencil buffer */
- renderer_polygon_stencil_begin(ctx->renderer,
- &velement, ctx->state.vg.fill_rule, VG_FALSE);
- for (i = 0; i < polys->num_elements; ++i) {
- struct polygon *poly = (((struct polygon**)polys->data)[i]);
-
- polygon_prepare_buffer(ctx, poly);
- vbuffer.user_buffer = poly->user_vbuf;
-
- renderer_polygon_stencil(ctx->renderer, &vbuffer,
- PIPE_PRIM_TRIANGLE_FAN, 0, (VGuint) poly->num_verts);
- }
- renderer_polygon_stencil_end(ctx->renderer);
-
- /* fill it */
- renderer_polygon_fill_begin(ctx->renderer, VG_FALSE);
- renderer_polygon_fill(ctx->renderer, min_x, min_y, max_x, max_y);
- renderer_polygon_fill_end(ctx->renderer);
-}
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#ifndef POLYGON_H
-#define POLYGON_H
-
-#include "VG/openvg.h"
-
-struct polygon;
-struct vg_context;
-struct vg_paint;
-struct array;
-
-struct polygon *polygon_create(int size);
-struct polygon *polygon_create_from_data(float *data, int size);
-void polygon_destroy(struct polygon *poly);
-
-void polygon_resize(struct polygon *poly, int new_size);
-int polygon_size(struct polygon *poly);
-
-int polygon_vertex_count(struct polygon *poly);
-float * polygon_data(struct polygon *poly);
-
-void polygon_vertex_append(struct polygon *p,
- float x, float y);
-void polygon_append_polygon(struct polygon *dst,
- struct polygon *src);
-void polygon_set_vertex(struct polygon *p, int idx,
- float x, float y);
-void polygon_vertex(struct polygon *p, int idx,
- float *vertex);
-
-void polygon_bounding_rect(struct polygon *p,
- float *rect);
-int polygon_contains_point(struct polygon *p,
- float x, float y);
-
-VGboolean polygon_is_closed(struct polygon *p);
-
-void polygon_fill(struct polygon *p, struct vg_context *pipe);
-
-/* TODO: make a file/module around this struct
- */
-struct polygon_array {
- struct array *array;
- VGfloat min_x, max_x;
- VGfloat min_y, max_y;
-};
-
-void polygon_array_fill(struct polygon_array *polyarray, struct vg_context *ctx);
-
-#endif
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- * Copyright 2010 LunarG, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#include "renderer.h"
-
-#include "vg_context.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_state.h"
-#include "util/u_inlines.h"
-#include "pipe/p_screen.h"
-#include "pipe/p_shader_tokens.h"
-
-#include "util/u_draw_quad.h"
-#include "util/u_simple_shaders.h"
-#include "util/u_memory.h"
-#include "util/u_sampler.h"
-#include "util/u_surface.h"
-#include "util/u_math.h"
-#include "util/u_format.h"
-
-#include "cso_cache/cso_context.h"
-#include "tgsi/tgsi_ureg.h"
-
-typedef enum {
- RENDERER_STATE_INIT,
- RENDERER_STATE_COPY,
- RENDERER_STATE_DRAWTEX,
- RENDERER_STATE_SCISSOR,
- RENDERER_STATE_CLEAR,
- RENDERER_STATE_FILTER,
- RENDERER_STATE_POLYGON_STENCIL,
- RENDERER_STATE_POLYGON_FILL,
- NUM_RENDERER_STATES
-} RendererState;
-
-typedef enum {
- RENDERER_VS_PLAIN,
- RENDERER_VS_COLOR,
- RENDERER_VS_TEXTURE,
- NUM_RENDERER_VS
-} RendererVs;
-
-typedef enum {
- RENDERER_FS_COLOR,
- RENDERER_FS_TEXTURE,
- RENDERER_FS_SCISSOR,
- RENDERER_FS_WHITE,
- NUM_RENDERER_FS
-} RendererFs;
-
-struct renderer {
- struct pipe_context *pipe;
- struct cso_context *cso;
-
- VGbitfield dirty;
- struct {
- struct pipe_rasterizer_state rasterizer;
- struct pipe_depth_stencil_alpha_state dsa;
- struct pipe_framebuffer_state fb;
- } g3d;
- struct matrix projection;
-
- struct matrix mvp;
- struct pipe_resource *vs_cbuf;
-
- struct pipe_resource *fs_cbuf;
- VGfloat fs_cbuf_data[32];
- VGint fs_cbuf_len;
-
- struct pipe_vertex_element velems[2];
- VGfloat vertices[4][2][4];
-
- void *cached_vs[NUM_RENDERER_VS];
- void *cached_fs[NUM_RENDERER_FS];
-
- RendererState state;
-
- /* state data */
- union {
- struct {
- VGint tex_width;
- VGint tex_height;
- } copy;
-
- struct {
- VGint tex_width;
- VGint tex_height;
- } drawtex;
-
- struct {
- VGboolean restore_dsa;
- } scissor;
-
- struct {
- VGboolean use_sampler;
- VGint tex_width, tex_height;
- } filter;
-
- struct {
- struct pipe_depth_stencil_alpha_state dsa;
- VGboolean manual_two_sides;
- VGboolean restore_dsa;
- } polygon_stencil;
- } u;
-};
-
-/**
- * Return VG_TRUE if the renderer can use the resource as the asked bindings.
- */
-static VGboolean renderer_can_support(struct renderer *renderer,
- struct pipe_resource *res,
- unsigned bindings)
-{
- struct pipe_screen *screen = renderer->pipe->screen;
-
- return screen->is_format_supported(screen,
- res->format, res->target, 0, bindings);
-}
-
-/**
- * Set the model-view-projection matrix used by vertex shaders.
- */
-static void renderer_set_mvp(struct renderer *renderer,
- const struct matrix *mvp)
-{
- struct matrix *cur = &renderer->mvp;
- struct pipe_resource *cbuf;
- VGfloat consts[3][4];
- VGint i;
-
- /* projection only */
- if (!mvp)
- mvp = &renderer->projection;
-
- /* re-upload only if necessary */
- if (memcmp(cur, mvp, sizeof(*mvp)) == 0)
- return;
-
- /* 3x3 matrix to 3 constant vectors (no Z) */
- for (i = 0; i < 3; i++) {
- consts[i][0] = mvp->m[i + 0];
- consts[i][1] = mvp->m[i + 3];
- consts[i][2] = 0.0f;
- consts[i][3] = mvp->m[i + 6];
- }
-
- cbuf = renderer->vs_cbuf;
- pipe_resource_reference(&cbuf, NULL);
- cbuf = pipe_buffer_create(renderer->pipe->screen,
- PIPE_BIND_CONSTANT_BUFFER,
- PIPE_USAGE_DEFAULT,
- sizeof(consts));
- if (cbuf) {
- pipe_buffer_write(renderer->pipe, cbuf,
- 0, sizeof(consts), consts);
- }
- pipe_set_constant_buffer(renderer->pipe,
- PIPE_SHADER_VERTEX, 0, cbuf);
-
- memcpy(cur, mvp, sizeof(*mvp));
- renderer->vs_cbuf = cbuf;
-}
-
-/**
- * Create a simple vertex shader that passes through position and the given
- * attribute.
- */
-static void *create_passthrough_vs(struct pipe_context *pipe, int semantic_name)
-{
- struct ureg_program *ureg;
- struct ureg_src src[2], constants[3];
- struct ureg_dst dst[2], tmp;
- int i;
-
- ureg = ureg_create(TGSI_PROCESSOR_VERTEX);
- if (!ureg)
- return NULL;
-
- /* position is in user coordinates */
- src[0] = ureg_DECL_vs_input(ureg, 0);
- dst[0] = ureg_DECL_output(ureg, TGSI_SEMANTIC_POSITION, 0);
- tmp = ureg_DECL_temporary(ureg);
- for (i = 0; i < Elements(constants); i++)
- constants[i] = ureg_DECL_constant(ureg, i);
-
- /* transform to clipped coordinates */
- ureg_DP4(ureg, ureg_writemask(tmp, TGSI_WRITEMASK_X), src[0], constants[0]);
- ureg_DP4(ureg, ureg_writemask(tmp, TGSI_WRITEMASK_Y), src[0], constants[1]);
- ureg_MOV(ureg, ureg_writemask(tmp, TGSI_WRITEMASK_Z), src[0]);
- ureg_DP4(ureg, ureg_writemask(tmp, TGSI_WRITEMASK_W), src[0], constants[2]);
- ureg_MOV(ureg, dst[0], ureg_src(tmp));
-
- if (semantic_name >= 0) {
- src[1] = ureg_DECL_vs_input(ureg, 1);
- dst[1] = ureg_DECL_output(ureg, semantic_name, 0);
- ureg_MOV(ureg, dst[1], src[1]);
- }
-
- ureg_END(ureg);
-
- return ureg_create_shader_and_destroy(ureg, pipe);
-}
-
-/**
- * Set renderer vertex shader.
- *
- * This function modifies vertex_shader state.
- */
-static void renderer_set_vs(struct renderer *r, RendererVs id)
-{
- /* create as needed */
- if (!r->cached_vs[id]) {
- int semantic_name = -1;
-
- switch (id) {
- case RENDERER_VS_PLAIN:
- break;
- case RENDERER_VS_COLOR:
- semantic_name = TGSI_SEMANTIC_COLOR;
- break;
- case RENDERER_VS_TEXTURE:
- semantic_name = TGSI_SEMANTIC_GENERIC;
- break;
- default:
- assert(!"Unknown renderer vs id");
- break;
- }
-
- r->cached_vs[id] = create_passthrough_vs(r->pipe, semantic_name);
- }
-
- cso_set_vertex_shader_handle(r->cso, r->cached_vs[id]);
-}
-
-/**
- * Create a simple fragment shader that sets the depth to 0.0f.
- */
-static void *create_scissor_fs(struct pipe_context *pipe)
-{
- struct ureg_program *ureg;
- struct ureg_dst out;
- struct ureg_src imm;
-
- ureg = ureg_create(TGSI_PROCESSOR_FRAGMENT);
- out = ureg_DECL_output(ureg, TGSI_SEMANTIC_POSITION, 0);
- imm = ureg_imm4f(ureg, 0.0f, 0.0f, 0.0f, 0.0f);
-
- ureg_MOV(ureg, ureg_writemask(out, TGSI_WRITEMASK_Z), imm);
- ureg_END(ureg);
-
- return ureg_create_shader_and_destroy(ureg, pipe);
-}
-
-/**
- * Create a simple fragment shader that sets the color to white.
- */
-static void *create_white_fs(struct pipe_context *pipe)
-{
- struct ureg_program *ureg;
- struct ureg_dst out;
- struct ureg_src imm;
-
- ureg = ureg_create(TGSI_PROCESSOR_FRAGMENT);
- out = ureg_DECL_output(ureg, TGSI_SEMANTIC_COLOR, 0);
- imm = ureg_imm4f(ureg, 1.0f, 1.0f, 1.0f, 1.0f);
-
- ureg_MOV(ureg, out, imm);
- ureg_END(ureg);
-
- return ureg_create_shader_and_destroy(ureg, pipe);
-}
-
-/**
- * Set renderer fragment shader.
- *
- * This function modifies fragment_shader state.
- */
-static void renderer_set_fs(struct renderer *r, RendererFs id)
-{
- /* create as needed */
- if (!r->cached_fs[id]) {
- void *fs = NULL;
-
- switch (id) {
- case RENDERER_FS_COLOR:
- fs = util_make_fragment_passthrough_shader(r->pipe,
- TGSI_SEMANTIC_COLOR, TGSI_INTERPOLATE_PERSPECTIVE,
- TRUE);
- break;
- case RENDERER_FS_TEXTURE:
- fs = util_make_fragment_tex_shader(r->pipe,
- TGSI_TEXTURE_2D, TGSI_INTERPOLATE_LINEAR);
- break;
- case RENDERER_FS_SCISSOR:
- fs = create_scissor_fs(r->pipe);
- break;
- case RENDERER_FS_WHITE:
- fs = create_white_fs(r->pipe);
- break;
- default:
- assert(!"Unknown renderer fs id");
- break;
- }
-
- r->cached_fs[id] = fs;
- }
-
- cso_set_fragment_shader_handle(r->cso, r->cached_fs[id]);
-}
-
-typedef enum {
- VEGA_Y0_TOP,
- VEGA_Y0_BOTTOM
-} VegaOrientation;
-
-static void vg_set_viewport(struct renderer *r,
- VegaOrientation orientation)
-{
- const struct pipe_framebuffer_state *fb = &r->g3d.fb;
- struct pipe_viewport_state viewport;
- VGfloat y_scale = (orientation == VEGA_Y0_BOTTOM) ? -2.f : 2.f;
-
- viewport.scale[0] = fb->width / 2.f;
- viewport.scale[1] = fb->height / y_scale;
- viewport.scale[2] = 1.0;
- viewport.translate[0] = fb->width / 2.f;
- viewport.translate[1] = fb->height / 2.f;
- viewport.translate[2] = 0.0;
-
- cso_set_viewport(r->cso, &viewport);
-}
-
-/**
- * Set renderer target.
- *
- * This function modifies framebuffer and viewport states.
- */
-static void renderer_set_target(struct renderer *r,
- struct pipe_surface *cbuf,
- struct pipe_surface *zsbuf,
- VGboolean y0_top)
-{
- struct pipe_framebuffer_state fb;
-
- memset(&fb, 0, sizeof(fb));
- fb.width = cbuf->width;
- fb.height = cbuf->height;
- fb.cbufs[0] = cbuf;
- fb.nr_cbufs = 1;
- fb.zsbuf = zsbuf;
- cso_set_framebuffer(r->cso, &fb);
-
- vg_set_viewport(r, (y0_top) ? VEGA_Y0_TOP : VEGA_Y0_BOTTOM);
-}
-
-/**
- * Set renderer blend state. Blending is disabled.
- *
- * This function modifies blend state.
- */
-static void renderer_set_blend(struct renderer *r,
- VGbitfield channel_mask)
-{
- struct pipe_blend_state blend;
-
- memset(&blend, 0, sizeof(blend));
-
- blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_ONE;
- blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE;
- blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_ZERO;
- blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO;
-
- if (channel_mask & VG_RED)
- blend.rt[0].colormask |= PIPE_MASK_R;
- if (channel_mask & VG_GREEN)
- blend.rt[0].colormask |= PIPE_MASK_G;
- if (channel_mask & VG_BLUE)
- blend.rt[0].colormask |= PIPE_MASK_B;
- if (channel_mask & VG_ALPHA)
- blend.rt[0].colormask |= PIPE_MASK_A;
-
- cso_set_blend(r->cso, &blend);
-}
-
-/**
- * Set renderer sampler and view states.
- *
- * This function modifies samplers and fragment_sampler_views states.
- */
-static void renderer_set_samplers(struct renderer *r,
- uint num_views,
- struct pipe_sampler_view **views)
-{
- struct pipe_sampler_state sampler;
- unsigned tex_filter = PIPE_TEX_FILTER_NEAREST;
- unsigned tex_wrap = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
- uint i;
-
- memset(&sampler, 0, sizeof(sampler));
-
- sampler.min_img_filter = tex_filter;
- sampler.mag_img_filter = tex_filter;
- sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
-
- sampler.wrap_s = tex_wrap;
- sampler.wrap_t = tex_wrap;
- sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
-
- sampler.normalized_coords = 1;
-
- /* set samplers */
- for (i = 0; i < num_views; i++)
- cso_single_sampler(r->cso, PIPE_SHADER_FRAGMENT, i, &sampler);
- cso_single_sampler_done(r->cso, PIPE_SHADER_FRAGMENT);
-
- /* set views */
- cso_set_sampler_views(r->cso, PIPE_SHADER_FRAGMENT, num_views, views);
-}
-
-/**
- * Set custom renderer fragment shader, and optionally set samplers and views
- * and upload the fragment constant buffer.
- *
- * This function modifies fragment_shader, samplers and fragment_sampler_views
- * states.
- */
-static void renderer_set_custom_fs(struct renderer *renderer,
- void *fs,
- const struct pipe_sampler_state **samplers,
- struct pipe_sampler_view **views,
- VGint num_samplers,
- const void *const_buffer,
- VGint const_buffer_len)
-{
- cso_set_fragment_shader_handle(renderer->cso, fs);
-
- /* set samplers and views */
- if (num_samplers) {
- cso_set_samplers(renderer->cso, PIPE_SHADER_FRAGMENT, num_samplers, samplers);
- cso_set_sampler_views(renderer->cso, PIPE_SHADER_FRAGMENT, num_samplers, views);
- }
-
- /* upload fs constant buffer */
- if (const_buffer_len) {
- struct pipe_resource *cbuf = renderer->fs_cbuf;
-
- if (!cbuf || renderer->fs_cbuf_len != const_buffer_len ||
- memcmp(renderer->fs_cbuf_data, const_buffer, const_buffer_len)) {
- pipe_resource_reference(&cbuf, NULL);
-
- cbuf = pipe_buffer_create(renderer->pipe->screen,
- PIPE_BIND_CONSTANT_BUFFER, PIPE_USAGE_DEFAULT,
- const_buffer_len);
- pipe_buffer_write(renderer->pipe, cbuf, 0,
- const_buffer_len, const_buffer);
- pipe_set_constant_buffer(renderer->pipe,
- PIPE_SHADER_FRAGMENT, 0, cbuf);
-
- renderer->fs_cbuf = cbuf;
- if (const_buffer_len <= sizeof(renderer->fs_cbuf_data)) {
- memcpy(renderer->fs_cbuf_data, const_buffer, const_buffer_len);
- renderer->fs_cbuf_len = const_buffer_len;
- }
- else {
- renderer->fs_cbuf_len = 0;
- }
- }
- }
-}
-
-/**
- * Setup renderer quad position.
- */
-static void renderer_quad_pos(struct renderer *r,
- VGfloat x0, VGfloat y0,
- VGfloat x1, VGfloat y1,
- VGboolean scissor)
-{
- VGfloat z;
-
- /* the depth test is used for scissoring */
- z = (scissor) ? 0.0f : 1.0f;
-
- /* positions */
- r->vertices[0][0][0] = x0;
- r->vertices[0][0][1] = y0;
- r->vertices[0][0][2] = z;
-
- r->vertices[1][0][0] = x1;
- r->vertices[1][0][1] = y0;
- r->vertices[1][0][2] = z;
-
- r->vertices[2][0][0] = x1;
- r->vertices[2][0][1] = y1;
- r->vertices[2][0][2] = z;
-
- r->vertices[3][0][0] = x0;
- r->vertices[3][0][1] = y1;
- r->vertices[3][0][2] = z;
-}
-
-/**
- * Setup renderer quad texture coordinates.
- */
-static void renderer_quad_texcoord(struct renderer *r,
- VGfloat x0, VGfloat y0,
- VGfloat x1, VGfloat y1,
- VGint tex_width, VGint tex_height)
-{
- VGfloat s0, t0, s1, t1, r0, q0;
- VGint i;
-
- s0 = x0 / tex_width;
- s1 = x1 / tex_width;
- t0 = y0 / tex_height;
- t1 = y1 / tex_height;
- r0 = 0.0f;
- q0 = 1.0f;
-
- /* texcoords */
- r->vertices[0][1][0] = s0;
- r->vertices[0][1][1] = t0;
-
- r->vertices[1][1][0] = s1;
- r->vertices[1][1][1] = t0;
-
- r->vertices[2][1][0] = s1;
- r->vertices[2][1][1] = t1;
-
- r->vertices[3][1][0] = s0;
- r->vertices[3][1][1] = t1;
-
- for (i = 0; i < 4; i++) {
- r->vertices[i][1][2] = r0;
- r->vertices[i][1][3] = q0;
- }
-}
-
-/**
- * Draw renderer quad.
- */
-static void renderer_quad_draw(struct renderer *r)
-{
- util_draw_user_vertex_buffer(r->cso, r->vertices, PIPE_PRIM_TRIANGLE_FAN,
- Elements(r->vertices), /* verts */
- Elements(r->vertices[0])); /* attribs/vert */
-}
-
-/**
- * Prepare the renderer for copying.
- */
-VGboolean renderer_copy_begin(struct renderer *renderer,
- struct pipe_surface *dst,
- VGboolean y0_top,
- struct pipe_sampler_view *src)
-{
- assert(renderer->state == RENDERER_STATE_INIT);
-
- /* sanity check */
- if (!renderer_can_support(renderer,
- dst->texture, PIPE_BIND_RENDER_TARGET) ||
- !renderer_can_support(renderer,
- src->texture, PIPE_BIND_SAMPLER_VIEW))
- return VG_FALSE;
-
- cso_save_framebuffer(renderer->cso);
- cso_save_viewport(renderer->cso);
- cso_save_blend(renderer->cso);
- cso_save_samplers(renderer->cso, PIPE_SHADER_FRAGMENT);
- cso_save_sampler_views(renderer->cso, PIPE_SHADER_FRAGMENT);
- cso_save_fragment_shader(renderer->cso);
- cso_save_vertex_shader(renderer->cso);
-
- renderer_set_target(renderer, dst, NULL, y0_top);
-
- renderer_set_blend(renderer, ~0);
- renderer_set_samplers(renderer, 1, &src);
-
- renderer_set_fs(renderer, RENDERER_FS_TEXTURE);
- renderer_set_vs(renderer, RENDERER_VS_TEXTURE);
-
- renderer_set_mvp(renderer, NULL);
-
- /* remember the texture size */
- renderer->u.copy.tex_width = src->texture->width0;
- renderer->u.copy.tex_height = src->texture->height0;
- renderer->state = RENDERER_STATE_COPY;
-
- return VG_TRUE;
-}
-
-/**
- * Draw into the destination rectangle given by (x, y, w, h). The texture is
- * sampled from within the rectangle given by (sx, sy, sw, sh).
- *
- * The coordinates are in surface coordinates.
- */
-void renderer_copy(struct renderer *renderer,
- VGint x, VGint y, VGint w, VGint h,
- VGint sx, VGint sy, VGint sw, VGint sh)
-{
- assert(renderer->state == RENDERER_STATE_COPY);
-
- /* there is no depth buffer for scissoring anyway */
- renderer_quad_pos(renderer, x, y, x + w, y + h, VG_FALSE);
- renderer_quad_texcoord(renderer, sx, sy, sx + sw, sy + sh,
- renderer->u.copy.tex_width,
- renderer->u.copy.tex_height);
-
- renderer_quad_draw(renderer);
-}
-
-/**
- * End copying and restore the states.
- */
-void renderer_copy_end(struct renderer *renderer)
-{
- assert(renderer->state == RENDERER_STATE_COPY);
-
- cso_restore_framebuffer(renderer->cso);
- cso_restore_viewport(renderer->cso);
- cso_restore_blend(renderer->cso);
- cso_restore_samplers(renderer->cso, PIPE_SHADER_FRAGMENT);
- cso_restore_sampler_views(renderer->cso, PIPE_SHADER_FRAGMENT);
- cso_restore_fragment_shader(renderer->cso);
- cso_restore_vertex_shader(renderer->cso);
-
- renderer->state = RENDERER_STATE_INIT;
-}
-
-/**
- * Prepare the renderer for textured drawing.
- */
-VGboolean renderer_drawtex_begin(struct renderer *renderer,
- struct pipe_sampler_view *src)
-{
- assert(renderer->state == RENDERER_STATE_INIT);
-
- if (!renderer_can_support(renderer, src->texture, PIPE_BIND_SAMPLER_VIEW))
- return VG_FALSE;
-
- cso_save_blend(renderer->cso);
- cso_save_samplers(renderer->cso, PIPE_SHADER_FRAGMENT);
- cso_save_sampler_views(renderer->cso, PIPE_SHADER_FRAGMENT);
- cso_save_fragment_shader(renderer->cso);
- cso_save_vertex_shader(renderer->cso);
-
- renderer_set_blend(renderer, ~0);
-
- renderer_set_samplers(renderer, 1, &src);
-
- renderer_set_fs(renderer, RENDERER_FS_TEXTURE);
- renderer_set_vs(renderer, RENDERER_VS_TEXTURE);
-
- renderer_set_mvp(renderer, NULL);
-
- /* remember the texture size */
- renderer->u.drawtex.tex_width = src->texture->width0;
- renderer->u.drawtex.tex_height = src->texture->height0;
- renderer->state = RENDERER_STATE_DRAWTEX;
-
- return VG_TRUE;
-}
-
-/**
- * Draw into the destination rectangle given by (x, y, w, h). The texture is
- * sampled from within the rectangle given by (sx, sy, sw, sh).
- *
- * The coordinates are in surface coordinates.
- */
-void renderer_drawtex(struct renderer *renderer,
- VGint x, VGint y, VGint w, VGint h,
- VGint sx, VGint sy, VGint sw, VGint sh)
-{
- assert(renderer->state == RENDERER_STATE_DRAWTEX);
-
- /* with scissoring */
- renderer_quad_pos(renderer, x, y, x + w, y + h, VG_TRUE);
- renderer_quad_texcoord(renderer, sx, sy, sx + sw, sy + sh,
- renderer->u.drawtex.tex_width,
- renderer->u.drawtex.tex_height);
-
- renderer_quad_draw(renderer);
-}
-
-/**
- * End textured drawing and restore the states.
- */
-void renderer_drawtex_end(struct renderer *renderer)
-{
- assert(renderer->state == RENDERER_STATE_DRAWTEX);
-
- cso_restore_blend(renderer->cso);
- cso_restore_samplers(renderer->cso, PIPE_SHADER_FRAGMENT);
- cso_restore_sampler_views(renderer->cso, PIPE_SHADER_FRAGMENT);
- cso_restore_fragment_shader(renderer->cso);
- cso_restore_vertex_shader(renderer->cso);
-
- renderer->state = RENDERER_STATE_INIT;
-}
-
-/**
- * Prepare the renderer for scissor update. This will reset the depth buffer
- * to 1.0f.
- */
-VGboolean renderer_scissor_begin(struct renderer *renderer,
- VGboolean restore_dsa)
-{
- struct pipe_depth_stencil_alpha_state dsa;
-
- assert(renderer->state == RENDERER_STATE_INIT);
-
- if (restore_dsa)
- cso_save_depth_stencil_alpha(renderer->cso);
- cso_save_blend(renderer->cso);
- cso_save_fragment_shader(renderer->cso);
-
- /* enable depth writes */
- memset(&dsa, 0, sizeof(dsa));
- dsa.depth.enabled = 1;
- dsa.depth.writemask = 1;
- dsa.depth.func = PIPE_FUNC_ALWAYS;
- cso_set_depth_stencil_alpha(renderer->cso, &dsa);
-
- /* disable color writes */
- renderer_set_blend(renderer, 0);
- renderer_set_fs(renderer, RENDERER_FS_SCISSOR);
-
- renderer_set_mvp(renderer, NULL);
-
- renderer->u.scissor.restore_dsa = restore_dsa;
- renderer->state = RENDERER_STATE_SCISSOR;
-
- /* clear the depth buffer to 1.0f */
- renderer->pipe->clear(renderer->pipe,
- PIPE_CLEAR_DEPTHSTENCIL, NULL, 1.0f, 0);
-
- return VG_TRUE;
-}
-
-/**
- * Add a scissor rectangle. Depth values inside the rectangle will be set to
- * 0.0f.
- */
-void renderer_scissor(struct renderer *renderer,
- VGint x, VGint y, VGint width, VGint height)
-{
- assert(renderer->state == RENDERER_STATE_SCISSOR);
-
- renderer_quad_pos(renderer, x, y, x + width, y + height, VG_FALSE);
- renderer_quad_draw(renderer);
-}
-
-/**
- * End scissor update and restore the states.
- */
-void renderer_scissor_end(struct renderer *renderer)
-{
- assert(renderer->state == RENDERER_STATE_SCISSOR);
-
- if (renderer->u.scissor.restore_dsa)
- cso_restore_depth_stencil_alpha(renderer->cso);
- cso_restore_blend(renderer->cso);
- cso_restore_fragment_shader(renderer->cso);
-
- renderer->state = RENDERER_STATE_INIT;
-}
-
-/**
- * Prepare the renderer for clearing.
- */
-VGboolean renderer_clear_begin(struct renderer *renderer)
-{
- assert(renderer->state == RENDERER_STATE_INIT);
-
- cso_save_blend(renderer->cso);
- cso_save_fragment_shader(renderer->cso);
- cso_save_vertex_shader(renderer->cso);
-
- renderer_set_blend(renderer, ~0);
- renderer_set_fs(renderer, RENDERER_FS_COLOR);
- renderer_set_vs(renderer, RENDERER_VS_COLOR);
-
- renderer_set_mvp(renderer, NULL);
-
- renderer->state = RENDERER_STATE_CLEAR;
-
- return VG_TRUE;
-}
-
-/**
- * Clear the framebuffer with the specified region and color.
- *
- * The coordinates are in surface coordinates.
- */
-void renderer_clear(struct renderer *renderer,
- VGint x, VGint y, VGint width, VGint height,
- const VGfloat color[4])
-{
- VGuint i;
-
- assert(renderer->state == RENDERER_STATE_CLEAR);
-
- renderer_quad_pos(renderer, x, y, x + width, y + height, VG_TRUE);
- for (i = 0; i < 4; i++)
- memcpy(renderer->vertices[i][1], color, sizeof(VGfloat) * 4);
-
- renderer_quad_draw(renderer);
-}
-
-/**
- * End clearing and retore the states.
- */
-void renderer_clear_end(struct renderer *renderer)
-{
- assert(renderer->state == RENDERER_STATE_CLEAR);
-
- cso_restore_blend(renderer->cso);
- cso_restore_fragment_shader(renderer->cso);
- cso_restore_vertex_shader(renderer->cso);
-
- renderer->state = RENDERER_STATE_INIT;
-}
-
-/**
- * Prepare the renderer for image filtering.
- */
-VGboolean renderer_filter_begin(struct renderer *renderer,
- struct pipe_resource *dst,
- VGboolean y0_top,
- VGbitfield channel_mask,
- const struct pipe_sampler_state **samplers,
- struct pipe_sampler_view **views,
- VGint num_samplers,
- void *fs,
- const void *const_buffer,
- VGint const_buffer_len)
-{
- struct pipe_surface *surf, surf_tmpl;
-
- assert(renderer->state == RENDERER_STATE_INIT);
-
- if (!fs)
- return VG_FALSE;
- if (!renderer_can_support(renderer, dst, PIPE_BIND_RENDER_TARGET))
- return VG_FALSE;
-
- u_surface_default_template(&surf_tmpl, dst);
- surf = renderer->pipe->create_surface(renderer->pipe, dst, &surf_tmpl);
- if (!surf)
- return VG_FALSE;
-
- cso_save_framebuffer(renderer->cso);
- cso_save_viewport(renderer->cso);
- cso_save_blend(renderer->cso);
-
- /* set the image as the target */
- renderer_set_target(renderer, surf, NULL, y0_top);
- pipe_surface_reference(&surf, NULL);
-
- renderer_set_blend(renderer, channel_mask);
-
- if (num_samplers) {
- struct pipe_resource *tex;
-
- cso_save_samplers(renderer->cso, PIPE_SHADER_FRAGMENT);
- cso_save_sampler_views(renderer->cso, PIPE_SHADER_FRAGMENT);
- cso_save_fragment_shader(renderer->cso);
- cso_save_vertex_shader(renderer->cso);
-
- renderer_set_custom_fs(renderer, fs,
- samplers, views, num_samplers,
- const_buffer, const_buffer_len);
- renderer_set_vs(renderer, RENDERER_VS_TEXTURE);
-
- tex = views[0]->texture;
- renderer->u.filter.tex_width = tex->width0;
- renderer->u.filter.tex_height = tex->height0;
- renderer->u.filter.use_sampler = VG_TRUE;
- }
- else {
- cso_save_fragment_shader(renderer->cso);
-
- renderer_set_custom_fs(renderer, fs, NULL, NULL, 0,
- const_buffer, const_buffer_len);
-
- renderer->u.filter.use_sampler = VG_FALSE;
- }
-
- renderer_set_mvp(renderer, NULL);
-
- renderer->state = RENDERER_STATE_FILTER;
-
- return VG_TRUE;
-}
-
-/**
- * Draw into a rectangle of the destination with the specified region of the
- * texture(s).
- *
- * The coordinates are in surface coordinates.
- */
-void renderer_filter(struct renderer *renderer,
- VGint x, VGint y, VGint w, VGint h,
- VGint sx, VGint sy, VGint sw, VGint sh)
-{
- assert(renderer->state == RENDERER_STATE_FILTER);
-
- renderer_quad_pos(renderer, x, y, x + w, y + h, VG_FALSE);
- if (renderer->u.filter.use_sampler) {
- renderer_quad_texcoord(renderer, sx, sy, sx + sw, sy + sh,
- renderer->u.filter.tex_width,
- renderer->u.filter.tex_height);
- }
-
- renderer_quad_draw(renderer);
-}
-
-/**
- * End image filtering and restore the states.
- */
-void renderer_filter_end(struct renderer *renderer)
-{
- assert(renderer->state == RENDERER_STATE_FILTER);
-
- if (renderer->u.filter.use_sampler) {
- cso_restore_samplers(renderer->cso, PIPE_SHADER_FRAGMENT);
- cso_restore_sampler_views(renderer->cso, PIPE_SHADER_FRAGMENT);
- cso_restore_vertex_shader(renderer->cso);
- }
-
- cso_restore_framebuffer(renderer->cso);
- cso_restore_viewport(renderer->cso);
- cso_restore_blend(renderer->cso);
- cso_restore_fragment_shader(renderer->cso);
-
- renderer->state = RENDERER_STATE_INIT;
-}
-
-/**
- * Prepare the renderer for polygon silhouette rendering.
- */
-VGboolean renderer_polygon_stencil_begin(struct renderer *renderer,
- struct pipe_vertex_element *velem,
- VGFillRule rule,
- VGboolean restore_dsa)
-{
- struct pipe_depth_stencil_alpha_state *dsa;
- VGboolean manual_two_sides;
-
- assert(renderer->state == RENDERER_STATE_INIT);
-
- cso_save_vertex_elements(renderer->cso);
- cso_save_blend(renderer->cso);
- cso_save_depth_stencil_alpha(renderer->cso);
-
- cso_set_vertex_elements(renderer->cso, 1, velem);
-
- /* disable color writes */
- renderer_set_blend(renderer, 0);
-
- manual_two_sides = VG_FALSE;
- dsa = &renderer->u.polygon_stencil.dsa;
- memset(dsa, 0, sizeof(*dsa));
- if (rule == VG_EVEN_ODD) {
- dsa->stencil[0].enabled = 1;
- dsa->stencil[0].writemask = 1;
- dsa->stencil[0].fail_op = PIPE_STENCIL_OP_KEEP;
- dsa->stencil[0].zfail_op = PIPE_STENCIL_OP_KEEP;
- dsa->stencil[0].zpass_op = PIPE_STENCIL_OP_INVERT;
- dsa->stencil[0].func = PIPE_FUNC_ALWAYS;
- dsa->stencil[0].valuemask = ~0;
- }
- else {
- assert(rule == VG_NON_ZERO);
-
- /* front face */
- dsa->stencil[0].enabled = 1;
- dsa->stencil[0].writemask = ~0;
- dsa->stencil[0].fail_op = PIPE_STENCIL_OP_KEEP;
- dsa->stencil[0].zfail_op = PIPE_STENCIL_OP_KEEP;
- dsa->stencil[0].zpass_op = PIPE_STENCIL_OP_INCR_WRAP;
- dsa->stencil[0].func = PIPE_FUNC_ALWAYS;
- dsa->stencil[0].valuemask = ~0;
-
- if (renderer->pipe->screen->get_param(renderer->pipe->screen,
- PIPE_CAP_TWO_SIDED_STENCIL)) {
- /* back face */
- dsa->stencil[1] = dsa->stencil[0];
- dsa->stencil[1].zpass_op = PIPE_STENCIL_OP_DECR_WRAP;
- }
- else {
- manual_two_sides = VG_TRUE;
- }
- }
- cso_set_depth_stencil_alpha(renderer->cso, dsa);
-
- if (manual_two_sides)
- cso_save_rasterizer(renderer->cso);
-
- renderer->u.polygon_stencil.manual_two_sides = manual_two_sides;
- renderer->u.polygon_stencil.restore_dsa = restore_dsa;
- renderer->state = RENDERER_STATE_POLYGON_STENCIL;
-
- return VG_TRUE;
-}
-
-/**
- * Render a polygon silhouette to stencil buffer.
- */
-void renderer_polygon_stencil(struct renderer *renderer,
- struct pipe_vertex_buffer *vbuf,
- VGuint mode, VGuint start, VGuint count)
-{
- assert(renderer->state == RENDERER_STATE_POLYGON_STENCIL);
-
- cso_set_vertex_buffers(renderer->cso, 0, 1, vbuf);
-
- if (!renderer->u.polygon_stencil.manual_two_sides) {
- cso_draw_arrays(renderer->cso, mode, start, count);
- }
- else {
- struct pipe_rasterizer_state raster;
- struct pipe_depth_stencil_alpha_state dsa;
-
- raster = renderer->g3d.rasterizer;
- dsa = renderer->u.polygon_stencil.dsa;
-
- /* front */
- raster.cull_face = PIPE_FACE_BACK;
- dsa.stencil[0].zpass_op = PIPE_STENCIL_OP_INCR_WRAP;
-
- cso_set_rasterizer(renderer->cso, &raster);
- cso_set_depth_stencil_alpha(renderer->cso, &dsa);
- cso_draw_arrays(renderer->cso, mode, start, count);
-
- /* back */
- raster.cull_face = PIPE_FACE_FRONT;
- dsa.stencil[0].zpass_op = PIPE_STENCIL_OP_DECR_WRAP;
-
- cso_set_rasterizer(renderer->cso, &raster);
- cso_set_depth_stencil_alpha(renderer->cso, &dsa);
- cso_draw_arrays(renderer->cso, mode, start, count);
- }
-}
-
-/**
- * End polygon silhouette rendering.
- */
-void renderer_polygon_stencil_end(struct renderer *renderer)
-{
- assert(renderer->state == RENDERER_STATE_POLYGON_STENCIL);
-
- if (renderer->u.polygon_stencil.manual_two_sides)
- cso_restore_rasterizer(renderer->cso);
-
- cso_restore_vertex_elements(renderer->cso);
-
- /* restore color writes */
- cso_restore_blend(renderer->cso);
-
- if (renderer->u.polygon_stencil.restore_dsa)
- cso_restore_depth_stencil_alpha(renderer->cso);
-
- renderer->state = RENDERER_STATE_INIT;
-}
-
-/**
- * Prepare the renderer for polygon filling.
- */
-VGboolean renderer_polygon_fill_begin(struct renderer *renderer,
- VGboolean save_dsa)
-{
- struct pipe_depth_stencil_alpha_state dsa;
-
- assert(renderer->state == RENDERER_STATE_INIT);
-
- if (save_dsa)
- cso_save_depth_stencil_alpha(renderer->cso);
-
- /* setup stencil ops */
- memset(&dsa, 0, sizeof(dsa));
- dsa.stencil[0].enabled = 1;
- dsa.stencil[0].func = PIPE_FUNC_NOTEQUAL;
- dsa.stencil[0].fail_op = PIPE_STENCIL_OP_REPLACE;
- dsa.stencil[0].zfail_op = PIPE_STENCIL_OP_REPLACE;
- dsa.stencil[0].zpass_op = PIPE_STENCIL_OP_REPLACE;
- dsa.stencil[0].valuemask = ~0;
- dsa.stencil[0].writemask = ~0;
- dsa.depth = renderer->g3d.dsa.depth;
- cso_set_depth_stencil_alpha(renderer->cso, &dsa);
-
- renderer->state = RENDERER_STATE_POLYGON_FILL;
-
- return VG_TRUE;
-}
-
-/**
- * Fill a polygon.
- */
-void renderer_polygon_fill(struct renderer *renderer,
- VGfloat min_x, VGfloat min_y,
- VGfloat max_x, VGfloat max_y)
-{
- assert(renderer->state == RENDERER_STATE_POLYGON_FILL);
-
- renderer_quad_pos(renderer, min_x, min_y, max_x, max_y, VG_TRUE);
- renderer_quad_draw(renderer);
-}
-
-/**
- * End polygon filling.
- */
-void renderer_polygon_fill_end(struct renderer *renderer)
-{
- assert(renderer->state == RENDERER_STATE_POLYGON_FILL);
-
- cso_restore_depth_stencil_alpha(renderer->cso);
-
- renderer->state = RENDERER_STATE_INIT;
-}
-
-struct renderer * renderer_create(struct vg_context *owner)
-{
- struct renderer *renderer;
- struct pipe_rasterizer_state *raster;
- struct pipe_stencil_ref sr;
- VGint i;
-
- renderer = CALLOC_STRUCT(renderer);
- if (!renderer)
- return NULL;
-
- renderer->pipe = owner->pipe;
- renderer->cso = owner->cso_context;
-
- /* init vertex data that doesn't change */
- for (i = 0; i < 4; i++)
- renderer->vertices[i][0][3] = 1.0f; /* w */
-
- for (i = 0; i < 2; i++) {
- renderer->velems[i].src_offset = i * 4 * sizeof(float);
- renderer->velems[i].instance_divisor = 0;
- renderer->velems[i].vertex_buffer_index = 0;
- renderer->velems[i].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
- }
- cso_set_vertex_elements(renderer->cso, 2, renderer->velems);
-
- /* GL rasterization rules */
- raster = &renderer->g3d.rasterizer;
- memset(raster, 0, sizeof(*raster));
- raster->half_pixel_center = 1;
- raster->bottom_edge_rule = 1;
- raster->depth_clip = 1;
- cso_set_rasterizer(renderer->cso, raster);
-
- /* fixed at 0 */
- memset(&sr, 0, sizeof(sr));
- cso_set_stencil_ref(renderer->cso, &sr);
-
- renderer_set_vs(renderer, RENDERER_VS_PLAIN);
-
- renderer->state = RENDERER_STATE_INIT;
-
- return renderer;
-}
-
-void renderer_destroy(struct renderer *ctx)
-{
- int i;
-
- for (i = 0; i < NUM_RENDERER_VS; i++) {
- if (ctx->cached_vs[i])
- cso_delete_vertex_shader(ctx->cso, ctx->cached_vs[i]);
- }
- for (i = 0; i < NUM_RENDERER_FS; i++) {
- if (ctx->cached_fs[i])
- cso_delete_fragment_shader(ctx->cso, ctx->cached_fs[i]);
- }
-
- pipe_resource_reference(&ctx->vs_cbuf, NULL);
- pipe_resource_reference(&ctx->fs_cbuf, NULL);
-
- FREE(ctx);
-}
-
-static void update_clip_state(struct renderer *renderer,
- const struct vg_state *state)
-{
- struct pipe_depth_stencil_alpha_state *dsa = &renderer->g3d.dsa;
-
- memset(dsa, 0, sizeof(struct pipe_depth_stencil_alpha_state));
-
- if (state->scissoring) {
- struct pipe_framebuffer_state *fb = &renderer->g3d.fb;
- int i;
-
- renderer_scissor_begin(renderer, VG_FALSE);
-
- for (i = 0; i < state->scissor_rects_num; ++i) {
- const float x = state->scissor_rects[i * 4 + 0].f;
- const float y = state->scissor_rects[i * 4 + 1].f;
- const float width = state->scissor_rects[i * 4 + 2].f;
- const float height = state->scissor_rects[i * 4 + 3].f;
- VGint x0, y0, x1, y1, iw, ih;
-
- x0 = (VGint) x;
- y0 = (VGint) y;
- if (x0 < 0)
- x0 = 0;
- if (y0 < 0)
- y0 = 0;
-
- /* note that x1 and y1 are exclusive */
- x1 = (VGint) ceilf(x + width);
- y1 = (VGint) ceilf(y + height);
- if (x1 > fb->width)
- x1 = fb->width;
- if (y1 > fb->height)
- y1 = fb->height;
-
- iw = x1 - x0;
- ih = y1 - y0;
- if (iw > 0 && ih> 0 )
- renderer_scissor(renderer, x0, y0, iw, ih);
- }
-
- renderer_scissor_end(renderer);
-
- dsa->depth.enabled = 1; /* glEnable(GL_DEPTH_TEST); */
- dsa->depth.writemask = 0;/*glDepthMask(FALSE);*/
- dsa->depth.func = PIPE_FUNC_GEQUAL;
- }
-}
-
-static void renderer_validate_blend(struct renderer *renderer,
- const struct vg_state *state,
- enum pipe_format fb_format)
-{
- struct pipe_blend_state blend;
-
- memset(&blend, 0, sizeof(blend));
- blend.rt[0].colormask = PIPE_MASK_RGBA;
- blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_ONE;
- blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE;
- blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_ZERO;
- blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO;
-
- /* TODO alpha masking happens after blending? */
-
- switch (state->blend_mode) {
- case VG_BLEND_SRC:
- blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_ONE;
- blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE;
- blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_ZERO;
- blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO;
- break;
- case VG_BLEND_SRC_OVER:
- /* use the blend state only when there is no alpha channel */
- if (!util_format_has_alpha(fb_format)) {
- blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_SRC_ALPHA;
- blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE;
- blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_INV_SRC_ALPHA;
- blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_INV_SRC_ALPHA;
- blend.rt[0].blend_enable = 1;
- }
- break;
- case VG_BLEND_SRC_IN:
- blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_ONE;
- blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_DST_ALPHA;
- blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_ZERO;
- blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO;
- blend.rt[0].blend_enable = 1;
- break;
- case VG_BLEND_DST_IN:
- blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_ZERO;
- blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ZERO;
- blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_ONE;
- blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_SRC_ALPHA;
- blend.rt[0].blend_enable = 1;
- break;
- case VG_BLEND_DST_OVER:
- case VG_BLEND_MULTIPLY:
- case VG_BLEND_SCREEN:
- case VG_BLEND_DARKEN:
- case VG_BLEND_LIGHTEN:
- case VG_BLEND_ADDITIVE:
- /* need a shader */
- break;
- default:
- assert(!"not implemented blend mode");
- break;
- }
-
- cso_set_blend(renderer->cso, &blend);
-}
-
-/**
- * Propogate OpenVG state changes to the renderer. Only framebuffer, blending
- * and scissoring states are relevant here.
- */
-void renderer_validate(struct renderer *renderer,
- VGbitfield dirty,
- const struct st_framebuffer *stfb,
- const struct vg_state *state)
-{
- assert(renderer->state == RENDERER_STATE_INIT);
-
- dirty |= renderer->dirty;
- renderer->dirty = 0;
-
- if (dirty & FRAMEBUFFER_DIRTY) {
- struct pipe_framebuffer_state *fb = &renderer->g3d.fb;
- struct matrix *proj = &renderer->projection;
-
- memset(fb, 0, sizeof(struct pipe_framebuffer_state));
- fb->width = stfb->width;
- fb->height = stfb->height;
- fb->nr_cbufs = 1;
- fb->cbufs[0] = stfb->strb->surface;
- fb->zsbuf = stfb->dsrb->surface;
-
- cso_set_framebuffer(renderer->cso, fb);
- vg_set_viewport(renderer, VEGA_Y0_BOTTOM);
-
- matrix_load_identity(proj);
- matrix_translate(proj, -1.0f, -1.0f);
- matrix_scale(proj, 2.0f / fb->width, 2.0f / fb->height);
-
- /* we also got a new depth buffer */
- if (dirty & DEPTH_STENCIL_DIRTY) {
- renderer->pipe->clear(renderer->pipe,
- PIPE_CLEAR_DEPTHSTENCIL, NULL, 0.0, 0);
- }
- }
-
- /* must be last because it renders to the depth buffer*/
- if (dirty & DEPTH_STENCIL_DIRTY) {
- update_clip_state(renderer, state);
- cso_set_depth_stencil_alpha(renderer->cso, &renderer->g3d.dsa);
- }
-
- if (dirty & BLEND_DIRTY)
- renderer_validate_blend(renderer, state, stfb->strb->format);
-}
-
-/**
- * Prepare the renderer for OpenVG pipeline.
- */
-void renderer_validate_for_shader(struct renderer *renderer,
- const struct pipe_sampler_state **samplers,
- struct pipe_sampler_view **views,
- VGint num_samplers,
- const struct matrix *modelview,
- void *fs,
- const void *const_buffer,
- VGint const_buffer_len)
-{
- struct matrix mvp = renderer->projection;
-
- /* will be used in POLYGON_STENCIL and POLYGON_FILL */
- matrix_mult(&mvp, modelview);
- renderer_set_mvp(renderer, &mvp);
-
- renderer_set_custom_fs(renderer, fs,
- samplers, views, num_samplers,
- const_buffer, const_buffer_len);
-}
-
-void renderer_validate_for_mask_rendering(struct renderer *renderer,
- struct pipe_surface *dst,
- const struct matrix *modelview)
-{
- struct matrix mvp = renderer->projection;
-
- /* will be used in POLYGON_STENCIL and POLYGON_FILL */
- matrix_mult(&mvp, modelview);
- renderer_set_mvp(renderer, &mvp);
-
- renderer_set_target(renderer, dst, renderer->g3d.fb.zsbuf, VG_FALSE);
- renderer_set_blend(renderer, ~0);
- renderer_set_fs(renderer, RENDERER_FS_WHITE);
-
- /* set internal dirty flags (hacky!) */
- renderer->dirty = FRAMEBUFFER_DIRTY | BLEND_DIRTY;
-}
-
-void renderer_copy_surface(struct renderer *ctx,
- struct pipe_surface *src,
- int srcX0, int srcY0,
- int srcX1, int srcY1,
- struct pipe_surface *dst,
- int dstX0, int dstY0,
- int dstX1, int dstY1,
- float z, unsigned filter)
-{
- struct pipe_context *pipe = ctx->pipe;
- struct pipe_screen *screen = pipe->screen;
- struct pipe_sampler_view view_templ;
- struct pipe_sampler_view *view;
- struct pipe_box src_box;
- struct pipe_resource texTemp, *tex;
- const struct pipe_framebuffer_state *fb = &ctx->g3d.fb;
- const int srcW = abs(srcX1 - srcX0);
- const int srcH = abs(srcY1 - srcY0);
- const int srcLeft = MIN2(srcX0, srcX1);
- const int srcTop = MIN2(srcY0, srcY1);
-
- assert(filter == PIPE_TEX_MIPFILTER_NEAREST ||
- filter == PIPE_TEX_MIPFILTER_LINEAR);
-
- if (srcLeft != srcX0) {
- /* left-right flip */
- int tmp = dstX0;
- dstX0 = dstX1;
- dstX1 = tmp;
- }
-
- if (srcTop != srcY0) {
- /* up-down flip */
- int tmp = dstY0;
- dstY0 = dstY1;
- dstY1 = tmp;
- }
-
- assert(screen->is_format_supported(screen, src->format, PIPE_TEXTURE_2D,
- 0, PIPE_BIND_SAMPLER_VIEW));
- assert(screen->is_format_supported(screen, dst->format, PIPE_TEXTURE_2D,
- 0, PIPE_BIND_SAMPLER_VIEW));
- assert(screen->is_format_supported(screen, dst->format, PIPE_TEXTURE_2D,
- 0, PIPE_BIND_RENDER_TARGET));
-
- /*
- * XXX for now we're always creating a temporary texture.
- * Strictly speaking that's not always needed.
- */
-
- /* create temp texture */
- memset(&texTemp, 0, sizeof(texTemp));
- texTemp.target = PIPE_TEXTURE_2D;
- texTemp.format = src->format;
- texTemp.last_level = 0;
- texTemp.width0 = srcW;
- texTemp.height0 = srcH;
- texTemp.depth0 = 1;
- texTemp.array_size = 1;
- texTemp.bind = PIPE_BIND_SAMPLER_VIEW;
-
- tex = screen->resource_create(screen, &texTemp);
- if (!tex)
- return;
-
- u_sampler_view_default_template(&view_templ, tex, tex->format);
- view = pipe->create_sampler_view(pipe, tex, &view_templ);
-
- if (!view)
- return;
-
- u_box_2d_zslice(srcLeft, srcTop, src->u.tex.first_layer, srcW, srcH, &src_box);
-
- pipe->resource_copy_region(pipe,
- tex, 0, 0, 0, 0, /* dest */
- src->texture, 0, &src_box);
-
- assert(floatsEqual(z, 0.0f));
-
- /* draw */
- if (fb->cbufs[0] == dst) {
- /* transform back to surface coordinates */
- dstY0 = dst->height - dstY0;
- dstY1 = dst->height - dstY1;
-
- if (renderer_drawtex_begin(ctx, view)) {
- renderer_drawtex(ctx,
- dstX0, dstY0, dstX1 - dstX0, dstY1 - dstY0,
- 0, 0, view->texture->width0, view->texture->height0);
- renderer_drawtex_end(ctx);
- }
- }
- else {
- if (renderer_copy_begin(ctx, dst, VG_TRUE, view)) {
- renderer_copy(ctx,
- dstX0, dstY0, dstX1 - dstX0, dstY1 - dstY0,
- 0, 0, view->texture->width0, view->texture->height0);
- renderer_copy_end(ctx);
- }
- }
-}
-
-void renderer_texture_quad(struct renderer *r,
- struct pipe_resource *tex,
- VGfloat x1offset, VGfloat y1offset,
- VGfloat x2offset, VGfloat y2offset,
- VGfloat x1, VGfloat y1,
- VGfloat x2, VGfloat y2,
- VGfloat x3, VGfloat y3,
- VGfloat x4, VGfloat y4)
-{
- const VGfloat z = 0.0f;
-
- assert(r->state == RENDERER_STATE_INIT);
- assert(tex->width0 != 0);
- assert(tex->height0 != 0);
-
- cso_save_vertex_shader(r->cso);
-
- renderer_set_vs(r, RENDERER_VS_TEXTURE);
-
- /* manually set up positions */
- r->vertices[0][0][0] = x1;
- r->vertices[0][0][1] = y1;
- r->vertices[0][0][2] = z;
-
- r->vertices[1][0][0] = x2;
- r->vertices[1][0][1] = y2;
- r->vertices[1][0][2] = z;
-
- r->vertices[2][0][0] = x3;
- r->vertices[2][0][1] = y3;
- r->vertices[2][0][2] = z;
-
- r->vertices[3][0][0] = x4;
- r->vertices[3][0][1] = y4;
- r->vertices[3][0][2] = z;
-
- /* texcoords */
- renderer_quad_texcoord(r, x1offset, y1offset,
- x2offset, y2offset, tex->width0, tex->height0);
-
- renderer_quad_draw(r);
-
- cso_restore_vertex_shader(r->cso);
-}
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- * Copyright 2010 LunarG, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#ifndef RENDERER_H
-#define RENDERER_H
-
-#include "VG/openvg.h"
-
-struct renderer;
-
-struct vg_context;
-struct vg_state;
-struct st_framebuffer;
-struct pipe_resource;
-struct pipe_sampler_state;
-struct pipe_sampler_view;
-struct pipe_surface;
-struct pipe_vertex_element;
-struct pipe_vertex_buffer;
-struct matrix;
-
-struct renderer *renderer_create(struct vg_context *owner);
-void renderer_destroy(struct renderer *);
-
-void renderer_validate(struct renderer *renderer,
- VGbitfield dirty,
- const struct st_framebuffer *stfb,
- const struct vg_state *state);
-
-void renderer_validate_for_shader(struct renderer *renderer,
- const struct pipe_sampler_state **samplers,
- struct pipe_sampler_view **views,
- VGint num_samplers,
- const struct matrix *modelview,
- void *fs,
- const void *const_buffer,
- VGint const_buffer_len);
-
-void renderer_validate_for_mask_rendering(struct renderer *renderer,
- struct pipe_surface *dst,
- const struct matrix *modelview);
-
-VGboolean renderer_copy_begin(struct renderer *renderer,
- struct pipe_surface *dst,
- VGboolean y0_top,
- struct pipe_sampler_view *src);
-
-void renderer_copy(struct renderer *renderer,
- VGint x, VGint y, VGint w, VGint h,
- VGint sx, VGint sy, VGint sw, VGint sh);
-
-void renderer_copy_end(struct renderer *renderer);
-
-VGboolean renderer_drawtex_begin(struct renderer *renderer,
- struct pipe_sampler_view *src);
-
-void renderer_drawtex(struct renderer *renderer,
- VGint x, VGint y, VGint w, VGint h,
- VGint sx, VGint sy, VGint sw, VGint sh);
-
-void renderer_drawtex_end(struct renderer *renderer);
-
-VGboolean renderer_scissor_begin(struct renderer *renderer,
- VGboolean restore_dsa);
-
-void renderer_scissor(struct renderer *renderer,
- VGint x, VGint y, VGint width, VGint height);
-
-void renderer_scissor_end(struct renderer *renderer);
-
-VGboolean renderer_clear_begin(struct renderer *renderer);
-
-void renderer_clear(struct renderer *renderer,
- VGint x, VGint y, VGint width, VGint height,
- const VGfloat color[4]);
-
-void renderer_clear_end(struct renderer *renderer);
-
-VGboolean renderer_filter_begin(struct renderer *renderer,
- struct pipe_resource *dst,
- VGboolean y0_top,
- VGbitfield channel_mask,
- const struct pipe_sampler_state **samplers,
- struct pipe_sampler_view **views,
- VGint num_samplers,
- void *fs,
- const void *const_buffer,
- VGint const_buffer_len);
-
-void renderer_filter(struct renderer *renderer,
- VGint x, VGint y, VGint w, VGint h,
- VGint sx, VGint sy, VGint sw, VGint sh);
-
-void renderer_filter_end(struct renderer *renderer);
-
-VGboolean renderer_polygon_stencil_begin(struct renderer *renderer,
- struct pipe_vertex_element *velem,
- VGFillRule rule,
- VGboolean restore_dsa);
-
-void renderer_polygon_stencil(struct renderer *renderer,
- struct pipe_vertex_buffer *vbuf,
- VGuint mode, VGuint start, VGuint count);
-
-void renderer_polygon_stencil_end(struct renderer *renderer);
-
-VGboolean renderer_polygon_fill_begin(struct renderer *renderer,
- VGboolean save_dsa);
-
-void renderer_polygon_fill(struct renderer *renderer,
- VGfloat min_x, VGfloat min_y,
- VGfloat max_x, VGfloat max_y);
-
-void renderer_polygon_fill_end(struct renderer *renderer);
-
-void renderer_texture_quad(struct renderer *,
- struct pipe_resource *texture,
- VGfloat x1offset, VGfloat y1offset,
- VGfloat x2offset, VGfloat y2offset,
- VGfloat x1, VGfloat y1,
- VGfloat x2, VGfloat y2,
- VGfloat x3, VGfloat y3,
- VGfloat x4, VGfloat y4);
-
-void renderer_copy_surface(struct renderer *r,
- struct pipe_surface *src,
- int sx1, int sy1,
- int sx2, int sy2,
- struct pipe_surface *dst,
- int dx1, int dy1,
- int dx2, int dy2,
- float z, unsigned filter);
-
-
-#endif
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#include "shader.h"
-
-#include "vg_context.h"
-#include "shaders_cache.h"
-#include "paint.h"
-#include "mask.h"
-#include "image.h"
-#include "renderer.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_state.h"
-#include "util/u_memory.h"
-#include "util/u_math.h"
-#include "util/u_format.h"
-
-#define MAX_CONSTANTS 28
-
-struct shader {
- struct vg_context *context;
-
- VGboolean color_transform;
- VGboolean masking;
- struct vg_paint *paint;
- struct vg_image *image;
-
- struct matrix modelview;
- struct matrix paint_matrix;
-
- VGboolean drawing_image;
- VGImageMode image_mode;
-
- float constants[MAX_CONSTANTS];
- struct pipe_resource *cbuf;
- struct pipe_shader_state fs_state;
- void *fs;
-};
-
-struct shader * shader_create(struct vg_context *ctx)
-{
- struct shader *shader = 0;
-
- shader = CALLOC_STRUCT(shader);
- shader->context = ctx;
-
- return shader;
-}
-
-void shader_destroy(struct shader *shader)
-{
- FREE(shader);
-}
-
-void shader_set_color_transform(struct shader *shader, VGboolean set)
-{
- shader->color_transform = set;
-}
-
-void shader_set_masking(struct shader *shader, VGboolean set)
-{
- shader->masking = set;
-}
-
-VGboolean shader_is_masking(struct shader *shader)
-{
- return shader->masking;
-}
-
-void shader_set_paint(struct shader *shader, struct vg_paint *paint)
-{
- shader->paint = paint;
-}
-
-struct vg_paint * shader_paint(struct shader *shader)
-{
- return shader->paint;
-}
-
-static VGint setup_constant_buffer(struct shader *shader)
-{
- const struct vg_state *state = &shader->context->state.vg;
- VGint param_bytes = paint_constant_buffer_size(shader->paint);
- VGint i;
-
- param_bytes += sizeof(VGfloat) * 8;
- assert(param_bytes <= sizeof(shader->constants));
-
- if (state->color_transform) {
- for (i = 0; i < 8; i++) {
- VGfloat val = (i < 4) ? 127.0f : 1.0f;
- shader->constants[i] =
- CLAMP(state->color_transform_values[i], -val, val);
- }
- }
- else {
- memset(shader->constants, 0, sizeof(VGfloat) * 8);
- }
-
- paint_fill_constant_buffer(shader->paint,
- &shader->paint_matrix, shader->constants + 8);
-
- return param_bytes;
-}
-
-static VGboolean blend_use_shader(struct shader *shader)
-{
- struct vg_context *ctx = shader->context;
- VGboolean advanced_blending;
-
- switch (ctx->state.vg.blend_mode) {
- case VG_BLEND_DST_OVER:
- case VG_BLEND_MULTIPLY:
- case VG_BLEND_SCREEN:
- case VG_BLEND_DARKEN:
- case VG_BLEND_LIGHTEN:
- case VG_BLEND_ADDITIVE:
- advanced_blending = VG_TRUE;
- break;
- case VG_BLEND_SRC_OVER:
- if (util_format_has_alpha(ctx->draw_buffer->strb->format)) {
- /* no blending is required if the paints and the image are opaque */
- advanced_blending = !paint_is_opaque(ctx->state.vg.fill_paint) ||
- !paint_is_opaque(ctx->state.vg.stroke_paint);
- if (!advanced_blending && shader->drawing_image) {
- advanced_blending =
- util_format_has_alpha(shader->image->sampler_view->format);
- }
- break;
- }
- /* fall through */
- default:
- advanced_blending = VG_FALSE;
- break;
- }
-
- return advanced_blending;
-}
-
-static VGint blend_bind_samplers(struct shader *shader,
- struct pipe_sampler_state **samplers,
- struct pipe_sampler_view **sampler_views)
-{
- if (blend_use_shader(shader)) {
- struct vg_context *ctx = shader->context;
-
- samplers[2] = &ctx->blend_sampler;
- sampler_views[2] = vg_prepare_blend_surface(ctx);
-
- if (!samplers[0] || !sampler_views[0]) {
- samplers[0] = samplers[2];
- sampler_views[0] = sampler_views[2];
- }
- if (!samplers[1] || !sampler_views[1]) {
- samplers[1] = samplers[0];
- sampler_views[1] = sampler_views[0];
- }
-
- return 1;
- }
- return 0;
-}
-
-static VGint setup_samplers(struct shader *shader,
- struct pipe_sampler_state **samplers,
- struct pipe_sampler_view **sampler_views)
-{
- /* a little wonky: we use the num as a boolean that just says
- * whether any sampler/textures have been set. the actual numbering
- * for samplers is always the same:
- * 0 - paint sampler/texture for gradient/pattern
- * 1 - mask sampler/texture
- * 2 - blend sampler/texture
- * 3 - image sampler/texture
- * */
- VGint num = 0;
-
- samplers[0] = NULL;
- samplers[1] = NULL;
- samplers[2] = NULL;
- samplers[3] = NULL;
- sampler_views[0] = NULL;
- sampler_views[1] = NULL;
- sampler_views[2] = NULL;
- sampler_views[3] = NULL;
-
- num += paint_bind_samplers(shader->paint, samplers, sampler_views);
- num += mask_bind_samplers(samplers, sampler_views);
- num += blend_bind_samplers(shader, samplers, sampler_views);
- if (shader->drawing_image && shader->image)
- num += image_bind_samplers(shader->image, samplers, sampler_views);
-
- return (num) ? 4 : 0;
-}
-
-static INLINE VGboolean is_format_bw(struct shader *shader)
-{
-#if 0
- struct vg_context *ctx = shader->context;
- struct st_framebuffer *stfb = ctx->draw_buffer;
-#endif
-
- if (shader->drawing_image && shader->image) {
- if (shader->image->format == VG_BW_1)
- return VG_TRUE;
- }
-
- return VG_FALSE;
-}
-
-static void setup_shader_program(struct shader *shader)
-{
- struct vg_context *ctx = shader->context;
- VGint shader_id = 0;
- VGBlendMode blend_mode = ctx->state.vg.blend_mode;
- VGboolean black_white = is_format_bw(shader);
-
- /* 1st stage: fill */
- if (!shader->drawing_image ||
- (shader->image_mode == VG_DRAW_IMAGE_MULTIPLY || shader->image_mode == VG_DRAW_IMAGE_STENCIL)) {
- switch(paint_type(shader->paint)) {
- case VG_PAINT_TYPE_COLOR:
- shader_id |= VEGA_SOLID_FILL_SHADER;
- break;
- case VG_PAINT_TYPE_LINEAR_GRADIENT:
- shader_id |= VEGA_LINEAR_GRADIENT_SHADER;
- break;
- case VG_PAINT_TYPE_RADIAL_GRADIENT:
- shader_id |= VEGA_RADIAL_GRADIENT_SHADER;
- break;
- case VG_PAINT_TYPE_PATTERN:
- shader_id |= VEGA_PATTERN_SHADER;
- break;
-
- default:
- abort();
- }
-
- if (paint_is_degenerate(shader->paint))
- shader_id = VEGA_PAINT_DEGENERATE_SHADER;
- }
-
- /* second stage image */
- if (shader->drawing_image) {
- switch(shader->image_mode) {
- case VG_DRAW_IMAGE_NORMAL:
- shader_id |= VEGA_IMAGE_NORMAL_SHADER;
- break;
- case VG_DRAW_IMAGE_MULTIPLY:
- shader_id |= VEGA_IMAGE_MULTIPLY_SHADER;
- break;
- case VG_DRAW_IMAGE_STENCIL:
- shader_id |= VEGA_IMAGE_STENCIL_SHADER;
- break;
- default:
- debug_printf("Unknown image mode!");
- }
- }
-
- if (shader->color_transform)
- shader_id |= VEGA_COLOR_TRANSFORM_SHADER;
-
- if (blend_use_shader(shader)) {
- if (shader->drawing_image && shader->image_mode == VG_DRAW_IMAGE_STENCIL)
- shader_id |= VEGA_ALPHA_PER_CHANNEL_SHADER;
- else
- shader_id |= VEGA_ALPHA_NORMAL_SHADER;
-
- switch(blend_mode) {
- case VG_BLEND_SRC:
- shader_id |= VEGA_BLEND_SRC_SHADER;
- break;
- case VG_BLEND_SRC_OVER:
- shader_id |= VEGA_BLEND_SRC_OVER_SHADER;
- break;
- case VG_BLEND_DST_OVER:
- shader_id |= VEGA_BLEND_DST_OVER_SHADER;
- break;
- case VG_BLEND_SRC_IN:
- shader_id |= VEGA_BLEND_SRC_IN_SHADER;
- break;
- case VG_BLEND_DST_IN:
- shader_id |= VEGA_BLEND_DST_IN_SHADER;
- break;
- case VG_BLEND_MULTIPLY:
- shader_id |= VEGA_BLEND_MULTIPLY_SHADER;
- break;
- case VG_BLEND_SCREEN:
- shader_id |= VEGA_BLEND_SCREEN_SHADER;
- break;
- case VG_BLEND_DARKEN:
- shader_id |= VEGA_BLEND_DARKEN_SHADER;
- break;
- case VG_BLEND_LIGHTEN:
- shader_id |= VEGA_BLEND_LIGHTEN_SHADER;
- break;
- case VG_BLEND_ADDITIVE:
- shader_id |= VEGA_BLEND_ADDITIVE_SHADER;
- break;
- default:
- assert(0);
- break;
- }
- }
- else {
- /* update alpha of the source */
- if (shader->drawing_image && shader->image_mode == VG_DRAW_IMAGE_STENCIL)
- shader_id |= VEGA_ALPHA_PER_CHANNEL_SHADER;
- }
-
- if (shader->masking)
- shader_id |= VEGA_MASK_SHADER;
-
- if (black_white)
- shader_id |= VEGA_BW_SHADER;
-
- shader->fs = shaders_cache_fill(ctx->sc, shader_id);
-}
-
-
-void shader_bind(struct shader *shader)
-{
- struct vg_context *ctx = shader->context;
- struct pipe_sampler_state *samplers[PIPE_MAX_SAMPLERS];
- struct pipe_sampler_view *sampler_views[PIPE_MAX_SAMPLERS];
- VGint num_samplers, param_bytes;
-
- /* first resolve the real paint type */
- paint_resolve_type(shader->paint);
-
- num_samplers = setup_samplers(shader, samplers, sampler_views);
- param_bytes = setup_constant_buffer(shader);
- setup_shader_program(shader);
-
- renderer_validate_for_shader(ctx->renderer,
- (const struct pipe_sampler_state **) samplers,
- sampler_views, num_samplers,
- &shader->modelview,
- shader->fs, (const void *) shader->constants, param_bytes);
-}
-
-void shader_set_image_mode(struct shader *shader, VGImageMode image_mode)
-{
- shader->image_mode = image_mode;
-}
-
-VGImageMode shader_image_mode(struct shader *shader)
-{
- return shader->image_mode;
-}
-
-void shader_set_drawing_image(struct shader *shader, VGboolean drawing_image)
-{
- shader->drawing_image = drawing_image;
-}
-
-VGboolean shader_drawing_image(struct shader *shader)
-{
- return shader->drawing_image;
-}
-
-void shader_set_image(struct shader *shader, struct vg_image *img)
-{
- shader->image = img;
-}
-
-/**
- * Set the transformation to map a vertex to the surface coordinates.
- */
-void shader_set_surface_matrix(struct shader *shader,
- const struct matrix *mat)
-{
- shader->modelview = *mat;
-}
-
-/**
- * Set the transformation to map a pixel to the paint coordinates.
- */
-void shader_set_paint_matrix(struct shader *shader, const struct matrix *mat)
-{
- const struct st_framebuffer *stfb = shader->context->draw_buffer;
- const VGfloat px_center_offset = 0.5f;
-
- memcpy(&shader->paint_matrix, mat, sizeof(*mat));
-
- /* make it window-to-paint for the shaders */
- matrix_translate(&shader->paint_matrix, px_center_offset,
- stfb->height - 1.0f + px_center_offset);
- matrix_scale(&shader->paint_matrix, 1.0f, -1.0f);
-}
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#ifndef SHADER_H
-#define SHADER_H
-
-#include "VG/openvg.h"
-
-struct shader;
-struct vg_paint;
-struct vg_context;
-struct vg_image;
-struct matrix;
-
-struct shader *shader_create(struct vg_context *context);
-void shader_destroy(struct shader *shader);
-
-void shader_set_color_transform(struct shader *shader, VGboolean set);
-
-void shader_set_masking(struct shader *shader, VGboolean set);
-VGboolean shader_is_masking(struct shader *shader);
-
-void shader_set_paint(struct shader *shader, struct vg_paint *paint);
-struct vg_paint *shader_paint(struct shader *shader);
-
-void shader_set_image_mode(struct shader *shader, VGImageMode image_mode);
-VGImageMode shader_image_mode(struct shader *shader);
-
-void shader_set_drawing_image(struct shader *shader, VGboolean drawing_image);
-VGboolean shader_drawing_image(struct shader *shader);
-
-void shader_set_image(struct shader *shader, struct vg_image *img);
-
-void shader_set_surface_matrix(struct shader *shader,
- const struct matrix *mat);
-void shader_set_paint_matrix(struct shader *shader, const struct matrix *mat);
-
-void shader_bind(struct shader *shader);
-
-#endif
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#include "shaders_cache.h"
-
-#include "vg_context.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_defines.h"
-#include "pipe/p_shader_tokens.h"
-
-#include "tgsi/tgsi_build.h"
-#include "tgsi/tgsi_dump.h"
-#include "tgsi/tgsi_parse.h"
-#include "tgsi/tgsi_util.h"
-#include "tgsi/tgsi_text.h"
-
-#include "util/u_memory.h"
-#include "util/u_math.h"
-#include "util/u_debug.h"
-#include "cso_cache/cso_hash.h"
-#include "cso_cache/cso_context.h"
-
-#include "VG/openvg.h"
-
-#include "asm_fill.h"
-
-/* Essentially we construct an ubber-shader based on the state
- * of the pipeline. The stages are:
- * 1) Paint generation (color/gradient/pattern)
- * 2) Image composition (normal/multiply/stencil)
- * 3) Color transform
- * 4) Per-channel alpha generation
- * 5) Extended blend (multiply/screen/darken/lighten)
- * 6) Mask
- * 7) Premultiply/Unpremultiply
- * 8) Color transform (to black and white)
- */
-#define SHADER_STAGES 8
-
-struct cached_shader {
- void *driver_shader;
- struct pipe_shader_state state;
-};
-
-struct shaders_cache {
- struct vg_context *pipe;
-
- struct cso_hash *hash;
-};
-
-
-static INLINE struct tgsi_token *tokens_from_assembly(const char *txt, int num_tokens)
-{
- struct tgsi_token *tokens;
-
- tokens = (struct tgsi_token *) MALLOC(num_tokens * sizeof(tokens[0]));
-
- tgsi_text_translate(txt, tokens, num_tokens);
-
-#if DEBUG_SHADERS
- tgsi_dump(tokens, 0);
-#endif
-
- return tokens;
-}
-
-/*
-static const char max_shader_preamble[] =
- "FRAG\n"
- "DCL IN[0], POSITION, LINEAR\n"
- "DCL IN[1], GENERIC[0], PERSPECTIVE\n"
- "DCL OUT[0], COLOR, CONSTANT\n"
- "DCL CONST[0..9], CONSTANT\n"
- "DCL TEMP[0..9], CONSTANT\n"
- "DCL SAMP[0..9], CONSTANT\n";
-
- max_shader_preamble strlen == 175
-*/
-#define MAX_PREAMBLE 175
-
-static INLINE VGint range_min(VGint min, VGint current)
-{
- if (min < 0)
- min = current;
- else
- min = MIN2(min, current);
- return min;
-}
-
-static INLINE VGint range_max(VGint max, VGint current)
-{
- return MAX2(max, current);
-}
-
-static void *
-combine_shaders(const struct shader_asm_info *shaders[SHADER_STAGES], int num_shaders,
- struct pipe_context *pipe,
- struct pipe_shader_state *shader)
-{
- VGboolean declare_input = VG_FALSE;
- VGint start_const = -1, end_const = 0;
- VGint start_temp = -1, end_temp = 0;
- VGint start_sampler = -1, end_sampler = 0;
- VGint i, current_shader = 0;
- VGint num_consts, num_temps, num_samplers;
- struct ureg_program *ureg;
- struct ureg_src in[2];
- struct ureg_src *sampler = NULL;
- struct ureg_src *constant = NULL;
- struct ureg_dst out, *temp = NULL;
- void *p = NULL;
-
- for (i = 0; i < num_shaders; ++i) {
- if (shaders[i]->num_consts)
- start_const = range_min(start_const, shaders[i]->start_const);
- if (shaders[i]->num_temps)
- start_temp = range_min(start_temp, shaders[i]->start_temp);
- if (shaders[i]->num_samplers)
- start_sampler = range_min(start_sampler, shaders[i]->start_sampler);
-
- end_const = range_max(end_const, shaders[i]->start_const +
- shaders[i]->num_consts);
- end_temp = range_max(end_temp, shaders[i]->start_temp +
- shaders[i]->num_temps);
- end_sampler = range_max(end_sampler, shaders[i]->start_sampler +
- shaders[i]->num_samplers);
- if (shaders[i]->needs_position)
- declare_input = VG_TRUE;
- }
- /* if they're still unitialized, initialize them */
- if (start_const < 0)
- start_const = 0;
- if (start_temp < 0)
- start_temp = 0;
- if (start_sampler < 0)
- start_sampler = 0;
-
- num_consts = end_const - start_const;
- num_temps = end_temp - start_temp;
- num_samplers = end_sampler - start_sampler;
-
- ureg = ureg_create(TGSI_PROCESSOR_FRAGMENT);
- if (!ureg)
- return NULL;
-
- if (declare_input) {
- in[0] = ureg_DECL_fs_input(ureg,
- TGSI_SEMANTIC_POSITION,
- 0,
- TGSI_INTERPOLATE_LINEAR);
- in[1] = ureg_DECL_fs_input(ureg,
- TGSI_SEMANTIC_GENERIC,
- 0,
- TGSI_INTERPOLATE_PERSPECTIVE);
- }
-
- /* we always have a color output */
- out = ureg_DECL_output(ureg, TGSI_SEMANTIC_COLOR, 0);
-
- if (num_consts >= 1) {
- constant = malloc(sizeof(struct ureg_src) * end_const);
- for (i = start_const; i < end_const; i++) {
- constant[i] = ureg_DECL_constant(ureg, i);
- }
-
- }
-
- if (num_temps >= 1) {
- temp = malloc(sizeof(struct ureg_dst) * end_temp);
- for (i = start_temp; i < end_temp; i++) {
- temp[i] = ureg_DECL_temporary(ureg);
- }
- }
-
- if (num_samplers >= 1) {
- sampler = malloc(sizeof(struct ureg_src) * end_sampler);
- for (i = start_sampler; i < end_sampler; i++) {
- sampler[i] = ureg_DECL_sampler(ureg, i);
- }
- }
-
- while (current_shader < num_shaders) {
- if ((current_shader + 1) == num_shaders) {
- shaders[current_shader]->func(ureg,
- &out,
- in,
- sampler,
- temp,
- constant);
- } else {
- shaders[current_shader]->func(ureg,
- &temp[0],
- in,
- sampler,
- temp,
- constant);
- }
- current_shader++;
- }
-
- ureg_END(ureg);
-
- shader->tokens = ureg_finalize(ureg);
- if (!shader->tokens) {
- ureg_destroy(ureg);
- return NULL;
- }
-
- p = pipe->create_fs_state(pipe, shader);
-
- if (num_temps >= 1) {
- for (i = start_temp; i < end_temp; i++) {
- ureg_release_temporary(ureg, temp[i]);
- }
- }
-
- ureg_destroy(ureg);
-
- free(temp);
- free(constant);
- free(sampler);
-
- return p;
-}
-
-static void *
-create_shader(struct pipe_context *pipe,
- int id,
- struct pipe_shader_state *shader)
-{
- int idx = 0, sh;
- const struct shader_asm_info * shaders[SHADER_STAGES];
-
- /* first stage */
- sh = SHADERS_GET_PAINT_SHADER(id);
- switch (sh << SHADERS_PAINT_SHIFT) {
- case VEGA_SOLID_FILL_SHADER:
- case VEGA_LINEAR_GRADIENT_SHADER:
- case VEGA_RADIAL_GRADIENT_SHADER:
- case VEGA_PATTERN_SHADER:
- case VEGA_PAINT_DEGENERATE_SHADER:
- shaders[idx] = &shaders_paint_asm[(sh >> SHADERS_PAINT_SHIFT) - 1];
- assert(shaders[idx]->id == sh);
- idx++;
- break;
- default:
- break;
- }
-
- /* second stage */
- sh = SHADERS_GET_IMAGE_SHADER(id);
- switch (sh) {
- case VEGA_IMAGE_NORMAL_SHADER:
- case VEGA_IMAGE_MULTIPLY_SHADER:
- case VEGA_IMAGE_STENCIL_SHADER:
- shaders[idx] = &shaders_image_asm[(sh >> SHADERS_IMAGE_SHIFT) - 1];
- assert(shaders[idx]->id == sh);
- idx++;
- break;
- default:
- break;
- }
-
- /* sanity check */
- assert(idx == ((!sh || sh == VEGA_IMAGE_NORMAL_SHADER) ? 1 : 2));
-
- /* third stage */
- sh = SHADERS_GET_COLOR_TRANSFORM_SHADER(id);
- switch (sh) {
- case VEGA_COLOR_TRANSFORM_SHADER:
- shaders[idx] = &shaders_color_transform_asm[
- (sh >> SHADERS_COLOR_TRANSFORM_SHIFT) - 1];
- assert(shaders[idx]->id == sh);
- idx++;
- break;
- default:
- break;
- }
-
- /* fourth stage */
- sh = SHADERS_GET_ALPHA_SHADER(id);
- switch (sh) {
- case VEGA_ALPHA_NORMAL_SHADER:
- case VEGA_ALPHA_PER_CHANNEL_SHADER:
- shaders[idx] = &shaders_alpha_asm[
- (sh >> SHADERS_ALPHA_SHIFT) - 1];
- assert(shaders[idx]->id == sh);
- idx++;
- break;
- default:
- break;
- }
-
- /* fifth stage */
- sh = SHADERS_GET_BLEND_SHADER(id);
- switch (sh) {
- case VEGA_BLEND_SRC_SHADER:
- case VEGA_BLEND_SRC_OVER_SHADER:
- case VEGA_BLEND_DST_OVER_SHADER:
- case VEGA_BLEND_SRC_IN_SHADER:
- case VEGA_BLEND_DST_IN_SHADER:
- case VEGA_BLEND_MULTIPLY_SHADER:
- case VEGA_BLEND_SCREEN_SHADER:
- case VEGA_BLEND_DARKEN_SHADER:
- case VEGA_BLEND_LIGHTEN_SHADER:
- case VEGA_BLEND_ADDITIVE_SHADER:
- shaders[idx] = &shaders_blend_asm[(sh >> SHADERS_BLEND_SHIFT) - 1];
- assert(shaders[idx]->id == sh);
- idx++;
- break;
- default:
- break;
- }
-
- /* sixth stage */
- sh = SHADERS_GET_MASK_SHADER(id);
- switch (sh) {
- case VEGA_MASK_SHADER:
- shaders[idx] = &shaders_mask_asm[(sh >> SHADERS_MASK_SHIFT) - 1];
- assert(shaders[idx]->id == sh);
- idx++;
- break;
- default:
- break;
- }
-
- /* seventh stage */
- sh = SHADERS_GET_PREMULTIPLY_SHADER(id);
- switch (sh) {
- case VEGA_PREMULTIPLY_SHADER:
- case VEGA_UNPREMULTIPLY_SHADER:
- shaders[idx] = &shaders_premultiply_asm[
- (sh >> SHADERS_PREMULTIPLY_SHIFT) - 1];
- assert(shaders[idx]->id == sh);
- idx++;
- break;
- default:
- break;
- }
-
- /* eighth stage */
- sh = SHADERS_GET_BW_SHADER(id);
- switch (sh) {
- case VEGA_BW_SHADER:
- shaders[idx] = &shaders_bw_asm[(sh >> SHADERS_BW_SHIFT) - 1];
- assert(shaders[idx]->id == sh);
- idx++;
- break;
- default:
- break;
- }
-
- return combine_shaders(shaders, idx, pipe, shader);
-}
-
-/*************************************************/
-
-struct shaders_cache * shaders_cache_create(struct vg_context *vg)
-{
- struct shaders_cache *sc = CALLOC_STRUCT(shaders_cache);
-
- sc->pipe = vg;
- sc->hash = cso_hash_create();
-
- return sc;
-}
-
-void shaders_cache_destroy(struct shaders_cache *sc)
-{
- struct cso_hash_iter iter = cso_hash_first_node(sc->hash);
-
- while (!cso_hash_iter_is_null(iter)) {
- struct cached_shader *cached =
- (struct cached_shader *)cso_hash_iter_data(iter);
- cso_delete_fragment_shader(sc->pipe->cso_context,
- cached->driver_shader);
- iter = cso_hash_erase(sc->hash, iter);
- }
-
- cso_hash_delete(sc->hash);
- FREE(sc);
-}
-
-void * shaders_cache_fill(struct shaders_cache *sc,
- int shader_key)
-{
- VGint key = shader_key;
- struct cached_shader *cached;
- struct cso_hash_iter iter = cso_hash_find(sc->hash, key);
-
- if (cso_hash_iter_is_null(iter)) {
- cached = CALLOC_STRUCT(cached_shader);
- cached->driver_shader = create_shader(sc->pipe->pipe, key, &cached->state);
-
- cso_hash_insert(sc->hash, key, cached);
-
- return cached->driver_shader;
- }
-
- cached = (struct cached_shader *)cso_hash_iter_data(iter);
-
- assert(cached->driver_shader);
- return cached->driver_shader;
-}
-
-struct vg_shader * shader_create_from_text(struct pipe_context *pipe,
- const char *txt, int num_tokens,
- int type)
-{
- struct vg_shader *shader = (struct vg_shader *)MALLOC(
- sizeof(struct vg_shader));
- struct tgsi_token *tokens = tokens_from_assembly(txt, num_tokens);
- struct pipe_shader_state state;
-
- debug_assert(type == PIPE_SHADER_VERTEX ||
- type == PIPE_SHADER_FRAGMENT);
-
- state.tokens = tokens;
- memset(&state.stream_output, 0, sizeof(state.stream_output));
- shader->type = type;
- shader->tokens = tokens;
-
- if (type == PIPE_SHADER_FRAGMENT)
- shader->driver = pipe->create_fs_state(pipe, &state);
- else
- shader->driver = pipe->create_vs_state(pipe, &state);
- return shader;
-}
-
-void vg_shader_destroy(struct vg_context *ctx, struct vg_shader *shader)
-{
- if (shader->type == PIPE_SHADER_FRAGMENT)
- cso_delete_fragment_shader(ctx->cso_context, shader->driver);
- else
- cso_delete_vertex_shader(ctx->cso_context, shader->driver);
- FREE(shader->tokens);
- FREE(shader);
-}
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#ifndef SHADERS_CACHE_H
-#define SHADERS_CACHE_H
-
-
-struct vg_context;
-struct pipe_context;
-struct tgsi_token;
-struct shaders_cache;
-
-#define _SHADERS_PAINT_BITS 3
-#define _SHADERS_IMAGE_BITS 2
-#define _SHADERS_COLOR_TRANSFORM_BITS 1
-#define _SHADERS_ALPHA_BITS 2
-#define _SHADERS_BLEND_BITS 4
-#define _SHADERS_MASK_BITS 1
-#define _SHADERS_PREMULTIPLY_BITS 2
-#define _SHADERS_BW_BITS 1
-
-#define SHADERS_PAINT_SHIFT (0)
-#define SHADERS_IMAGE_SHIFT (SHADERS_PAINT_SHIFT + _SHADERS_PAINT_BITS)
-#define SHADERS_COLOR_TRANSFORM_SHIFT (SHADERS_IMAGE_SHIFT + _SHADERS_IMAGE_BITS)
-#define SHADERS_ALPHA_SHIFT (SHADERS_COLOR_TRANSFORM_SHIFT + _SHADERS_COLOR_TRANSFORM_BITS)
-#define SHADERS_BLEND_SHIFT (SHADERS_ALPHA_SHIFT + _SHADERS_ALPHA_BITS)
-#define SHADERS_MASK_SHIFT (SHADERS_BLEND_SHIFT + _SHADERS_BLEND_BITS)
-#define SHADERS_PREMULTIPLY_SHIFT (SHADERS_MASK_SHIFT + _SHADERS_MASK_BITS)
-#define SHADERS_BW_SHIFT (SHADERS_PREMULTIPLY_SHIFT + _SHADERS_PREMULTIPLY_BITS)
-
-#define _SHADERS_GET_STAGE(stage, id) \
- ((id) & (((1 << _SHADERS_ ## stage ## _BITS) - 1) << SHADERS_ ## stage ## _SHIFT))
-
-#define SHADERS_GET_PAINT_SHADER(id) _SHADERS_GET_STAGE(PAINT, id)
-#define SHADERS_GET_IMAGE_SHADER(id) _SHADERS_GET_STAGE(IMAGE, id)
-#define SHADERS_GET_COLOR_TRANSFORM_SHADER(id) _SHADERS_GET_STAGE(COLOR_TRANSFORM, id)
-#define SHADERS_GET_ALPHA_SHADER(id) _SHADERS_GET_STAGE(ALPHA, id)
-#define SHADERS_GET_BLEND_SHADER(id) _SHADERS_GET_STAGE(BLEND, id)
-#define SHADERS_GET_MASK_SHADER(id) _SHADERS_GET_STAGE(MASK, id)
-#define SHADERS_GET_PREMULTIPLY_SHADER(id) _SHADERS_GET_STAGE(PREMULTIPLY, id)
-#define SHADERS_GET_BW_SHADER(id) _SHADERS_GET_STAGE(BW, id)
-
-enum VegaShaderType {
- VEGA_SOLID_FILL_SHADER = 1 << SHADERS_PAINT_SHIFT,
- VEGA_LINEAR_GRADIENT_SHADER = 2 << SHADERS_PAINT_SHIFT,
- VEGA_RADIAL_GRADIENT_SHADER = 3 << SHADERS_PAINT_SHIFT,
- VEGA_PATTERN_SHADER = 4 << SHADERS_PAINT_SHIFT,
- VEGA_PAINT_DEGENERATE_SHADER = 5 << SHADERS_PAINT_SHIFT,
-
- VEGA_IMAGE_NORMAL_SHADER = 1 << SHADERS_IMAGE_SHIFT,
- VEGA_IMAGE_MULTIPLY_SHADER = 2 << SHADERS_IMAGE_SHIFT,
- VEGA_IMAGE_STENCIL_SHADER = 3 << SHADERS_IMAGE_SHIFT,
-
- VEGA_COLOR_TRANSFORM_SHADER = 1 << SHADERS_COLOR_TRANSFORM_SHIFT,
-
- VEGA_ALPHA_NORMAL_SHADER = 1 << SHADERS_ALPHA_SHIFT,
- VEGA_ALPHA_PER_CHANNEL_SHADER = 2 << SHADERS_ALPHA_SHIFT,
-
- VEGA_BLEND_SRC_SHADER = 1 << SHADERS_BLEND_SHIFT,
- VEGA_BLEND_SRC_OVER_SHADER = 2 << SHADERS_BLEND_SHIFT,
- VEGA_BLEND_DST_OVER_SHADER = 3 << SHADERS_BLEND_SHIFT,
- VEGA_BLEND_SRC_IN_SHADER = 4 << SHADERS_BLEND_SHIFT,
- VEGA_BLEND_DST_IN_SHADER = 5 << SHADERS_BLEND_SHIFT,
- VEGA_BLEND_MULTIPLY_SHADER = 6 << SHADERS_BLEND_SHIFT,
- VEGA_BLEND_SCREEN_SHADER = 7 << SHADERS_BLEND_SHIFT,
- VEGA_BLEND_DARKEN_SHADER = 8 << SHADERS_BLEND_SHIFT,
- VEGA_BLEND_LIGHTEN_SHADER = 9 << SHADERS_BLEND_SHIFT,
- VEGA_BLEND_ADDITIVE_SHADER = 10<< SHADERS_BLEND_SHIFT,
-
- VEGA_MASK_SHADER = 1 << SHADERS_MASK_SHIFT,
-
- VEGA_PREMULTIPLY_SHADER = 1 << SHADERS_PREMULTIPLY_SHIFT,
- VEGA_UNPREMULTIPLY_SHADER = 2 << SHADERS_PREMULTIPLY_SHIFT,
-
- VEGA_BW_SHADER = 1 << SHADERS_BW_SHIFT
-};
-
-struct vg_shader {
- void *driver;
- struct tgsi_token *tokens;
- int type;/* PIPE_SHADER_VERTEX, PIPE_SHADER_FRAGMENT */
-};
-
-struct shaders_cache *shaders_cache_create(struct vg_context *pipe);
-void shaders_cache_destroy(struct shaders_cache *sc);
-void *shaders_cache_fill(struct shaders_cache *sc,
- int shader_key);
-
-struct vg_shader *shader_create_from_text(struct pipe_context *pipe,
- const char *txt, int num_tokens,
- int type);
-
-void vg_shader_destroy(struct vg_context *ctx, struct vg_shader *shader);
-
-
-
-#endif
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#include "stroker.h"
-
-#include "path.h"
-#include "vg_state.h"
-#include "util_array.h"
-#include "arc.h"
-#include "bezier.h"
-#include "matrix.h"
-#include "path_utils.h"
-#include "polygon.h"
-
-#include "util/u_math.h"
-
-#ifndef M_2PI
-#define M_2PI 6.28318530717958647692528676655900576
-#endif
-
-#define STROKE_SEGMENTS 0
-#define STROKE_DEBUG 0
-#define DEBUG_EMITS 0
-
-static const VGfloat curve_threshold = 0.25f;
-
-static const VGfloat zero_coords[] = {0.f, 0.f};
-
-enum intersection_type {
- NoIntersections,
- BoundedIntersection,
- UnboundedIntersection,
-};
-
-enum line_join_mode {
- FlatJoin,
- SquareJoin,
- MiterJoin,
- RoundJoin,
- RoundCap
-};
-
-struct stroke_iterator {
- void (*next)(struct stroke_iterator *);
- VGboolean (*has_next)(struct stroke_iterator *);
-
- VGPathCommand (*current_command)(struct stroke_iterator *it);
- void (*current_coords)(struct stroke_iterator *it, VGfloat *coords);
-
- VGint position;
- VGint coord_position;
-
- const VGubyte *cmds;
- const VGfloat *coords;
- VGint num_commands;
- VGint num_coords;
-
- struct polygon *curve_poly;
- VGint curve_index;
-};
-
-static VGPathCommand stroke_itr_command(struct stroke_iterator *itr)
-{
- return itr->current_command(itr);
-}
-
-static void stroke_itr_coords(struct stroke_iterator *itr, VGfloat *coords)
-{
- itr->current_coords(itr, coords);
-}
-
-static void stroke_fw_itr_coords(struct stroke_iterator *itr, VGfloat *coords)
-{
- if (itr->position >= itr->num_commands)
- return;
- switch (stroke_itr_command(itr)) {
- case VG_MOVE_TO_ABS:
- coords[0] = itr->coords[itr->coord_position];
- coords[1] = itr->coords[itr->coord_position + 1];
- break;
- case VG_LINE_TO_ABS:
- coords[0] = itr->coords[itr->coord_position];
- coords[1] = itr->coords[itr->coord_position + 1];
- break;
- case VG_CUBIC_TO_ABS:
- coords[0] = itr->coords[itr->coord_position];
- coords[1] = itr->coords[itr->coord_position + 1];
- coords[2] = itr->coords[itr->coord_position + 2];
- coords[3] = itr->coords[itr->coord_position + 3];
- coords[4] = itr->coords[itr->coord_position + 4];
- coords[5] = itr->coords[itr->coord_position + 5];
- break;
- default:
- debug_assert(!"invalid command!\n");
- }
-}
-
-
-static void stroke_bw_itr_coords(struct stroke_iterator *itr, VGfloat *coords)
-{
- if (itr->position >= itr->num_commands)
- return;
- switch (stroke_itr_command(itr)) {
- case VG_MOVE_TO_ABS:
- coords[0] = itr->coords[itr->coord_position];
- coords[1] = itr->coords[itr->coord_position + 1];
- break;
- case VG_LINE_TO_ABS:
- coords[0] = itr->coords[itr->coord_position];
- coords[1] = itr->coords[itr->coord_position + 1];
- break;
- case VG_CUBIC_TO_ABS:
- coords[0] = itr->coords[itr->coord_position + 4];
- coords[1] = itr->coords[itr->coord_position + 5];
- coords[2] = itr->coords[itr->coord_position + 2];
- coords[3] = itr->coords[itr->coord_position + 3];
- coords[4] = itr->coords[itr->coord_position + 0];
- coords[5] = itr->coords[itr->coord_position + 1];
- break;
- default:
- debug_assert(!"invalid command!\n");
- }
-}
-
-
-static VGPathCommand stroke_fw_current_command(struct stroke_iterator *it)
-{
- return it->cmds[it->position];
-}
-
-static VGPathCommand stroke_bw_current_command(struct stroke_iterator *it)
-{
- VGPathCommand prev_cmd;
- if (it->position == it->num_commands -1)
- return VG_MOVE_TO_ABS;
-
- prev_cmd = it->cmds[it->position + 1];
- return prev_cmd;
-}
-
-static VGboolean stroke_fw_has_next(struct stroke_iterator *itr)
-{
- return itr->position < (itr->num_commands - 1);
-}
-
-static VGboolean stroke_bw_has_next(struct stroke_iterator *itr)
-{
- return itr->position > 0;
-}
-
-static void stroke_fw_next(struct stroke_iterator *itr)
-{
- VGubyte cmd;
- debug_assert(stroke_fw_has_next(itr));
-
- cmd = stroke_itr_command(itr);
-
- itr->coord_position += num_elements_for_segments(&cmd, 1);
- ++itr->position;
-}
-
-static void stroke_bw_next(struct stroke_iterator *itr)
-{
- VGubyte cmd;
- debug_assert(stroke_bw_has_next(itr));
-
- --itr->position;
- cmd = stroke_itr_command(itr);
-
- itr->coord_position -= num_elements_for_segments(&cmd, 1);
-}
-
-static void stroke_itr_common_init(struct stroke_iterator *itr,
- struct array *cmds,
- struct array *coords)
-{
- itr->cmds = (VGubyte*)cmds->data;
- itr->num_commands = cmds->num_elements;
-
- itr->coords = (VGfloat*)coords->data;
- itr->num_coords = coords->num_elements;
-}
-
-static void stroke_forward_iterator(struct stroke_iterator *itr,
- struct array *cmds,
- struct array *coords)
-{
- stroke_itr_common_init(itr, cmds, coords);
- itr->position = 0;
- itr->coord_position = 0;
-
- itr->next = stroke_fw_next;
- itr->has_next = stroke_fw_has_next;
- itr->current_command = stroke_fw_current_command;
- itr->current_coords = stroke_fw_itr_coords;
-}
-
-static void stroke_backward_iterator(struct stroke_iterator *itr,
- struct array *cmds,
- struct array *coords)
-{
- VGubyte cmd;
- stroke_itr_common_init(itr, cmds, coords);
- itr->position = itr->num_commands - 1;
-
- cmd = stroke_bw_current_command(itr);
- itr->coord_position = itr->num_coords -
- num_elements_for_segments(&cmd, 1);
-
- itr->next = stroke_bw_next;
- itr->has_next = stroke_bw_has_next;
- itr->current_command = stroke_bw_current_command;
- itr->current_coords = stroke_bw_itr_coords;
-}
-
-
-
-static void stroke_flat_next(struct stroke_iterator *itr)
-{
- VGubyte cmd;
-
- if (itr->curve_index >= 0) {
- ++itr->curve_index;
- if (itr->curve_index >= polygon_vertex_count(itr->curve_poly)) {
- itr->curve_index = -1;
- polygon_destroy(itr->curve_poly);
- itr->curve_poly = 0;
- } else
- return;
- }
- debug_assert(stroke_fw_has_next(itr));
-
- cmd = itr->cmds[itr->position];
- itr->coord_position += num_elements_for_segments(&cmd, 1);
- ++itr->position;
-
- cmd = itr->cmds[itr->position];
-
- if (cmd == VG_CUBIC_TO_ABS) {
- struct bezier bezier;
- VGfloat bez[8];
-
- bez[0] = itr->coords[itr->coord_position - 2];
- bez[1] = itr->coords[itr->coord_position - 1];
- bez[2] = itr->coords[itr->coord_position];
- bez[3] = itr->coords[itr->coord_position + 1];
- bez[4] = itr->coords[itr->coord_position + 2];
- bez[5] = itr->coords[itr->coord_position + 3];
- bez[6] = itr->coords[itr->coord_position + 4];
- bez[7] = itr->coords[itr->coord_position + 5];
-
- bezier_init(&bezier,
- bez[0], bez[1],
- bez[2], bez[3],
- bez[4], bez[5],
- bez[6], bez[7]);
- /* skip the first one, it's the same as the prev point */
- itr->curve_index = 1;
- if (itr->curve_poly) {
- polygon_destroy(itr->curve_poly);
- itr->curve_poly = 0;
- }
- itr->curve_poly = bezier_to_polygon(&bezier);
- }
-}
-
-static VGboolean stroke_flat_has_next(struct stroke_iterator *itr)
-{
- return (itr->curve_index >= 0 &&
- itr->curve_index < (polygon_vertex_count(itr->curve_poly)-1))
- || itr->position < (itr->num_commands - 1);
-}
-
-static VGPathCommand stroke_flat_current_command(struct stroke_iterator *it)
-{
- if (it->cmds[it->position] == VG_CUBIC_TO_ABS) {
- return VG_LINE_TO_ABS;
- }
- return it->cmds[it->position];
-}
-
-static void stroke_flat_itr_coords(struct stroke_iterator *itr, VGfloat *coords)
-{
- if (itr->curve_index <= -1 && itr->position >= itr->num_commands)
- return;
-
- if (itr->curve_index >= 0) {
- polygon_vertex(itr->curve_poly, itr->curve_index,
- coords);
- return;
- }
-
- switch (stroke_itr_command(itr)) {
- case VG_MOVE_TO_ABS:
- coords[0] = itr->coords[itr->coord_position];
- coords[1] = itr->coords[itr->coord_position + 1];
- break;
- case VG_LINE_TO_ABS:
- coords[0] = itr->coords[itr->coord_position];
- coords[1] = itr->coords[itr->coord_position + 1];
- break;
- case VG_CUBIC_TO_ABS:
- default:
- debug_assert(!"invalid command!\n");
- }
-}
-
-static void stroke_flat_iterator(struct stroke_iterator *itr,
- struct array *cmds,
- struct array *coords)
-{
- stroke_itr_common_init(itr, cmds, coords);
- itr->position = 0;
- itr->coord_position = 0;
-
- itr->next = stroke_flat_next;
- itr->has_next = stroke_flat_has_next;
- itr->current_command = stroke_flat_current_command;
- itr->current_coords = stroke_flat_itr_coords;
- itr->curve_index = -1;
- itr->curve_poly = 0;
-}
-
-
-static INLINE VGboolean finite_coords4(const VGfloat *c)
-{
- return
- isfinite(c[0]) && isfinite(c[1]) &&
- isfinite(c[2]) && isfinite(c[3]);
-}
-
-/* from Graphics Gems II */
-#define SAME_SIGNS(a, b) ((a) * (b) >= 0)
-static VGboolean do_lines_intersect(VGfloat x1, VGfloat y1, VGfloat x2, VGfloat y2,
- VGfloat x3, VGfloat y3, VGfloat x4, VGfloat y4)
-{
- VGfloat a1, a2, b1, b2, c1, c2; /* Coefficients of line eqns */
- VGfloat r1, r2, r3, r4; /* 'sign' values */
-
- a1 = y2 - y1;
- b1 = x1 - x2;
- c1 = x2 * y1 - x1 * y2;
-
- r3 = a1 * x3 + b1 * y3 + c1;
- r4 = a1 * x4 + b1 * y4 + c1;
-
- if (r3 != 0 && r4 != 0 && SAME_SIGNS(r3, r4))
- return VG_FALSE;
-
- a2 = y4 - y3;
- b2 = x3 - x4;
- c2 = x4 * y3 - x3 * y4;
-
- r1 = a2 * x1 + b2 * y1 + c2;
- r2 = a2 * x2 + b2 * y2 + c2;
-
- if (r1 != 0 && r2 != 0 && SAME_SIGNS(r1, r2))
- return VG_FALSE;
-
- return VG_TRUE;
-}
-
-static INLINE VGfloat line_dx(const VGfloat *l)
-{
- return l[2] - l[0];
-}
-
-static INLINE VGfloat line_dy(const VGfloat *l)
-{
- return l[3] - l[1];
-}
-
-static INLINE VGfloat line_angle(const VGfloat *l)
-{
- const VGfloat dx = line_dx(l);
- const VGfloat dy = line_dy(l);
-
- const VGfloat theta = atan2(-dy, dx) * 360.0 / M_2PI;
-
- const VGfloat theta_normalized = theta < 0 ? theta + 360 : theta;
-
- if (floatsEqual(theta_normalized, 360.f))
- return 0;
- else
- return theta_normalized;
-}
-
-static INLINE void line_set_length(VGfloat *l, VGfloat len)
-{
- VGfloat uv[] = {l[0], l[1], l[2], l[3]};
- if (null_line(l))
- return;
- line_normalize(uv);
- l[2] = l[0] + line_dx(uv) * len;
- l[3] = l[1] + line_dy(uv) * len;
-}
-
-static INLINE void line_translate(VGfloat *l, VGfloat x, VGfloat y)
-{
- l[0] += x;
- l[1] += y;
- l[2] += x;
- l[3] += y;
-}
-
-static INLINE VGfloat line_angle_to(const VGfloat *l1,
- const VGfloat *l2)
-{
- VGfloat a1, a2, delta, delta_normalized;
- if (null_line(l1) || null_line(l1))
- return 0;
-
- a1 = line_angle(l1);
- a2 = line_angle(l2);
-
- delta = a2 - a1;
- delta_normalized = delta < 0 ? delta + 360 : delta;
-
- if (floatsEqual(delta, 360.f))
- return 0;
- else
- return delta_normalized;
-}
-
-static INLINE VGfloat line_angles(const VGfloat *l1,
- const VGfloat *l2)
-{
- VGfloat cos_line, rad = 0;
-
- if (null_line(l1) || null_line(l2))
- return 0;
-
- cos_line = (line_dx(l1)*line_dx(l2) + line_dy(l1)*line_dy(l2)) /
- (line_lengthv(l1)*line_lengthv(l2));
- rad = 0;
-
- if (cos_line >= -1.0 && cos_line <= 1.0)
- rad = acos(cos_line);
- return rad * 360 / M_2PI;
-}
-
-
-static INLINE VGfloat adapted_angle_on_x(const VGfloat *line)
-{
- const VGfloat identity[] = {0, 0, 1, 0};
- VGfloat angle = line_angles(line, identity);
- if (line_dy(line) > 0)
- angle = 360 - angle;
- return angle;
-}
-
-static enum intersection_type line_intersect(const VGfloat *l1,
- const VGfloat *l2,
- float *intersection_point)
-{
- VGfloat isect[2] = { 0 };
- enum intersection_type type;
- VGboolean dx_zero, ldx_zero;
-
- if (null_line(l1) || null_line(l2) ||
- !finite_coords4(l1) || !finite_coords4(l2))
- return NoIntersections;
-
- type = do_lines_intersect(l1[0], l1[1], l1[2], l1[3], l2[0], l2[1], l2[2], l2[3])
- ? BoundedIntersection : UnboundedIntersection;
-
- dx_zero = floatsEqual(line_dx(l1) + 1, 1);
- ldx_zero = floatsEqual(line_dx(l2) + 1, 1);
-
- /* one of the lines is vertical */
- if (dx_zero && ldx_zero) {
- type = NoIntersections;
- } else if (dx_zero) {
- VGfloat la = line_dy(l2) / line_dx(l2);
- isect[0] = l1[0];
- isect[1] = la * l1[0] + l2[1] - la * l2[0];
- } else if (ldx_zero) {
- VGfloat ta = line_dy(l1) / line_dx(l1);
- isect[0] = l2[0];
- isect[1] = ta * l2[0] + l1[1] - ta*l1[0];
- } else {
- VGfloat x;
- VGfloat ta = line_dy(l1) / line_dx(l1);
- VGfloat la = line_dy(l2) / line_dx(l2);
- if (ta == la)
- return NoIntersections;
-
- x = ( - l2[1] + la * l2[0] + l1[1] - ta * l1[0] ) / (la - ta);
- isect[0] = x;
- isect[1] = ta*(x - l1[0]) + l1[1];
- }
- if (intersection_point) {
- intersection_point[0] = isect[0];
- intersection_point[1] = isect[1];
- }
- return type;
-}
-
-static INLINE enum line_join_mode stroker_join_mode(struct stroker *s)
-{
- switch(s->join_style) {
- case VG_JOIN_MITER:
- return MiterJoin;
- case VG_JOIN_ROUND:
- return RoundJoin;
- case VG_JOIN_BEVEL:
- return FlatJoin;
- default:
- return FlatJoin;
- }
-}
-
-static INLINE enum line_join_mode stroker_cap_mode(struct stroker *s)
-{
- switch(s->cap_style) {
- case VG_CAP_BUTT:
- return FlatJoin;
- case VG_CAP_ROUND:
- return RoundCap;
- case VG_CAP_SQUARE:
- return SquareJoin;
- default:
- return FlatJoin;
- }
-}
-
-void stroker_emit_move_to(struct stroker *stroker, VGfloat x, VGfloat y)
-{
- VGubyte cmds = VG_MOVE_TO_ABS;
- VGfloat coords[2] = {x, y};
-#if DEBUG_EMITS
- debug_printf("emit move %f, %f\n", x, y);
-#endif
- stroker->back2_x = stroker->back1_x;
- stroker->back2_y = stroker->back1_y;
- stroker->back1_x = x;
- stroker->back1_y = y;
-
- path_append_data(stroker->path,
- 1,
- &cmds, &coords);
-}
-
-void stroker_emit_line_to(struct stroker *stroker, VGfloat x, VGfloat y)
-{
- VGubyte cmds = VG_LINE_TO_ABS;
- VGfloat coords[2] = {x, y};
-#if DEBUG_EMITS
- debug_printf("emit line %f, %f\n", x, y);
-#endif
- stroker->back2_x = stroker->back1_x;
- stroker->back2_y = stroker->back1_y;
- stroker->back1_x = x;
- stroker->back1_y = y;
- path_append_data(stroker->path,
- 1,
- &cmds, &coords);
-}
-
-void stroker_emit_curve_to(struct stroker *stroker, VGfloat px1, VGfloat py1,
- VGfloat px2, VGfloat py2,
- VGfloat x, VGfloat y)
-{
- VGubyte cmds = VG_CUBIC_TO_ABS;
- VGfloat coords[6] = {px1, py1, px2, py2, x, y};
-#if DEBUG_EMITS
- debug_printf("emit curve %f, %f, %f, %f, %f, %f\n", px1, py1,
- px2, py2, x, y);
-#endif
-
- if (px2 == x && py2 == y) {
- if (px1 == x && py1 == y) {
- stroker->back2_x = stroker->back1_x;
- stroker->back2_y = stroker->back1_y;
- } else {
- stroker->back2_x = px1;
- stroker->back2_y = py1;
- }
- } else {
- stroker->back2_x = px2;
- stroker->back2_y = py2;
- }
- stroker->back1_x = x;
- stroker->back1_y = y;
-
- path_append_data(stroker->path,
- 1,
- &cmds, &coords);
-}
-
-static INLINE void create_round_join(struct stroker *stroker,
- VGfloat x1, VGfloat y1,
- VGfloat x2, VGfloat y2,
- VGfloat width, VGfloat height)
-{
- struct arc arc;
- struct matrix matrix;
-
- matrix_load_identity(&matrix);
-
- /*stroker_emit_line_to(stroker, nx, ny);*/
-
- arc_init(&arc, VG_SCCWARC_TO,
- x1, y1, x2, y2, width/2, height/2, 0);
- arc_stroker_emit(&arc, stroker, &matrix);
-}
-
-
-static void create_joins(struct stroker *stroker,
- VGfloat focal_x, VGfloat focal_y,
- const VGfloat *next_line, enum line_join_mode join)
-{
-#if DEBUG_EMITS
- debug_printf("create_joins: focal=[%f, %f], next_line=[%f, %f,%f, %f]\n",
- focal_x, focal_y,
- next_line[0], next_line[1], next_line[2], next_line[3]);
-#endif
- /* if we're alredy connected do nothing */
- if (floatsEqual(stroker->back1_x, next_line[0]) &&
- floatsEqual(stroker->back1_y, next_line[1]))
- return;
-
- if (join == FlatJoin) {
- stroker_emit_line_to(stroker, next_line[0], next_line[1]);
- } else {
- VGfloat prev_line[] = {stroker->back2_x, stroker->back2_y,
- stroker->back1_x, stroker->back1_y};
-
- VGfloat isect[2] = { 0 };
- enum intersection_type type = line_intersect(prev_line, next_line, isect);
-
- if (join == SquareJoin) {
- VGfloat offset = stroker->stroke_width / 2;
- VGfloat l1[4] = {prev_line[0],
- prev_line[1],
- prev_line[2],
- prev_line[3]};
- VGfloat l2[4] = {next_line[2],
- next_line[3],
- next_line[0],
- next_line[1]};
-
- line_translate(l1, line_dx(l1), line_dy(l1));
- line_set_length(l1, offset);
-
- line_translate(l2, line_dx(l2), line_dy(l2));
- line_set_length(l2, offset);
-
- stroker_emit_line_to(stroker, l1[2], l1[3]);
- stroker_emit_line_to(stroker, l2[2], l2[3]);
- stroker_emit_line_to(stroker, l2[0], l2[1]);
- } else if (join == RoundJoin) {
- VGfloat offset = stroker->stroke_width / 2;
- VGfloat short_cut[4] = {prev_line[2], prev_line[3],
- next_line[0], next_line[1]};
- VGfloat angle = line_angles(prev_line, short_cut);
-
- if (type == BoundedIntersection ||
- (angle > 90 && !floatsEqual(angle, 90.f))) {
- stroker_emit_line_to(stroker, next_line[0], next_line[1]);
- return;
- }
- create_round_join(stroker, prev_line[2], prev_line[3],
- next_line[0], next_line[1],
- offset * 2, offset * 2);
-
- stroker_emit_line_to(stroker, next_line[0], next_line[1]);
- } else if (join == RoundCap) {
- VGfloat offset = stroker->stroke_width / 2;
- VGfloat l1[4] = { prev_line[0], prev_line[1],
- prev_line[2], prev_line[3] };
- VGfloat l2[4] = {focal_x, focal_y,
- prev_line[2], prev_line[3]};
-
- line_translate(l1, line_dx(l1), line_dy(l1));
- line_set_length(l1, KAPPA * offset);
-
- /* normal between prev_line and focal */
- line_translate(l2, -line_dy(l2), line_dx(l2));
- line_set_length(l2, KAPPA * offset);
-
- stroker_emit_curve_to(stroker, l1[2], l1[3],
- l2[2], l2[3],
- l2[0], l2[1]);
-
- l2[0] = l2[0];
- l2[1] = l2[1];
- l2[2] = l2[0] - line_dx(l2);
- l2[3] = l2[1] - line_dy(l2);
-
- line_translate(l1, next_line[0] - l1[0], next_line[1] - l1[1]);
-
- stroker_emit_curve_to(stroker,
- l2[2], l2[3],
- l1[2], l1[3],
- l1[0], l1[1]);
- } else if (join == MiterJoin) {
- VGfloat miter_line[4] = {stroker->back1_x, stroker->back1_y,
- isect[0], isect[1]};
- VGfloat sl = (stroker->stroke_width * stroker->miter_limit);
- VGfloat inside_line[4] = {prev_line[2], prev_line[3],
- next_line[0], next_line[1]};
- VGfloat angle = line_angle_to(inside_line, prev_line);
-
- if (type == BoundedIntersection ||
- (angle > 90 && !floatsEqual(angle, 90.f))) {
- /*
- debug_printf("f = %f, nl = %f, pl = %f, is = %f\n",
- focal_x, next_line[0],
- prev_line[2], isect[0]);*/
- stroker_emit_line_to(stroker, next_line[0], next_line[1]);
- return;
- }
-
- if (type == NoIntersections || line_lengthv(miter_line) > sl) {
- stroker_emit_line_to(stroker, next_line[0], next_line[1]);
- } else {
- stroker_emit_line_to(stroker, isect[0], isect[1]);
- stroker_emit_line_to(stroker, next_line[0], next_line[1]);
- }
- } else {
- debug_assert(!"create_joins bad join style");
- }
- }
-}
-
-static void stroker_add_segment(struct stroker *stroker,
- VGPathCommand cmd,
- const VGfloat *coords,
- VGint num_coords)
-{
- /* skip duplicated points */
- if (stroker->segments->num_elements &&
- stroker->last_cmd == cmd) {
- VGfloat *data = stroker->control_points->data;
- data += stroker->control_points->num_elements;
- data -= num_coords;
- switch (cmd) {
- case VG_MOVE_TO_ABS:
- if (floatsEqual(coords[0], data[0]) &&
- floatsEqual(coords[1], data[1]))
- return;
- break;
- case VG_LINE_TO_ABS:
- if (floatsEqual(coords[0], data[0]) &&
- floatsEqual(coords[1], data[1]))
- return;
- break;
- case VG_CUBIC_TO_ABS:
- if (floatsEqual(coords[0], data[0]) &&
- floatsEqual(coords[1], data[1]) &&
- floatsEqual(coords[2], data[2]) &&
- floatsEqual(coords[3], data[3]) &&
- floatsEqual(coords[4], data[4]) &&
- floatsEqual(coords[5], data[5]))
- return;
- break;
- default:
- debug_assert(!"Invalid stroke segment");
- }
- } else if (stroker->last_cmd == VG_CUBIC_TO_ABS &&
- cmd == VG_LINE_TO_ABS) {
- VGfloat *data = stroker->control_points->data;
- data += stroker->control_points->num_elements;
- data -= 2;
- if (floatsEqual(coords[0], data[0]) &&
- floatsEqual(coords[1], data[1]))
- return;
- }
- stroker->last_cmd = cmd;
- array_append_data(stroker->segments, &cmd, 1);
- array_append_data(stroker->control_points, coords, num_coords);
-}
-
-void stroker_move_to(struct stroker *stroker, VGfloat x, VGfloat y)
-{
- VGfloat coords[2] = {x, y};
-#if STROKE_SEGMENTS
- debug_printf("stroker_move_to(%f, %f)\n", x, y);
-#endif
-
- if (stroker->segments->num_elements > 0)
- stroker->process_subpath(stroker);
-
- array_reset(stroker->segments);
- array_reset(stroker->control_points);
-
- stroker_add_segment(stroker, VG_MOVE_TO_ABS, coords, 2);
-}
-
-void stroker_line_to(struct stroker *stroker, VGfloat x, VGfloat y)
-{
- VGfloat coords[] = {x, y};
-
-#if STROKE_SEGMENTS
- debug_printf("stroker_line_to(%f, %f)\n", x, y);
-#endif
- if (!stroker->segments->num_elements)
- stroker_add_segment(stroker, VG_MOVE_TO_ABS, zero_coords, 2);
-
- stroker_add_segment(stroker, VG_LINE_TO_ABS, coords, 2);
-}
-
-void stroker_curve_to(struct stroker *stroker, VGfloat px1, VGfloat py1,
- VGfloat px2, VGfloat py2,
- VGfloat x, VGfloat y)
-{
- VGfloat coords[] = {px1, py1,
- px2, py2,
- x, y};
-#if STROKE_SEGMENTS
- debug_printf("stroker_curve_to(%f, %f, %f, %f, %f, %f)\n",
- px1, py1, px2, py2, x, y);
-#endif
- if (!stroker->segments->num_elements)
- stroker_add_segment(stroker, VG_MOVE_TO_ABS, zero_coords, 2);
-
- stroker_add_segment(stroker, VG_CUBIC_TO_ABS, coords, 6);
-}
-
-static INLINE VGboolean is_segment_null(VGPathCommand cmd,
- VGfloat *coords,
- VGfloat *res)
-{
- switch(cmd) {
- case VG_MOVE_TO_ABS:
- case VG_LINE_TO_ABS:
- return floatsEqual(coords[0], res[0]) &&
- floatsEqual(coords[1], res[1]);
- break;
- case VG_CUBIC_TO_ABS:
- return floatsEqual(coords[0], res[0]) &&
- floatsEqual(coords[1], res[1]) &&
- floatsEqual(coords[2], res[0]) &&
- floatsEqual(coords[3], res[1]) &&
- floatsEqual(coords[4], res[0]) &&
- floatsEqual(coords[5], res[1]);
- break;
- default:
- assert(0);
- }
- return VG_FALSE;
-}
-
-static VGboolean vg_stroke_outline(struct stroke_iterator *it,
- struct stroker *stroker,
- VGboolean cap_first,
- VGfloat *start_tangent)
-{
-#define MAX_OFFSET 16
- struct bezier offset_curves[MAX_OFFSET];
- VGPathCommand first_element;
- VGfloat start[2], prev[2];
- VGboolean first = VG_TRUE;
- VGfloat offset;
-
- first_element = stroke_itr_command(it);
- if (first_element != VG_MOVE_TO_ABS) {
- stroker_emit_move_to(stroker, 0.f, 0.f);
- prev[0] = 0.f;
- prev[1] = 0.f;
- }
- stroke_itr_coords(it, start);
-#if STROKE_DEBUG
- debug_printf(" -> (side) [%.2f, %.2f]\n",
- start[0],
- start[1]);
-#endif
-
- prev[0] = start[0];
- prev[1] = start[1];
-
- offset = stroker->stroke_width / 2;
-
- if (!it->has_next(it)) {
- /* single point */
-
- return VG_TRUE;
- }
-
- while (it->has_next(it)) {
- VGPathCommand cmd;
- VGfloat coords[8];
-
- it->next(it);
- cmd = stroke_itr_command(it);
- stroke_itr_coords(it, coords);
-
- if (cmd == VG_LINE_TO_ABS) {
- VGfloat line[4] = {prev[0], prev[1], coords[0], coords[1]};
- VGfloat normal[4];
- line_normal(line, normal);
-
-#if STROKE_DEBUG
- debug_printf("\n ---> (side) lineto [%.2f, %.2f]\n", coords[0], coords[1]);
-#endif
- line_set_length(normal, offset);
- line_translate(line, line_dx(normal), line_dy(normal));
-
- /* if we are starting a new subpath, move to correct starting point */
- if (first) {
- if (cap_first)
- create_joins(stroker, prev[0], prev[1], line,
- stroker_cap_mode(stroker));
- else
- stroker_emit_move_to(stroker, line[0], line[1]);
- memcpy(start_tangent, line,
- sizeof(VGfloat) * 4);
- first = VG_FALSE;
- } else {
- create_joins(stroker, prev[0], prev[1], line,
- stroker_join_mode(stroker));
- }
-
- /* add the stroke for this line */
- stroker_emit_line_to(stroker, line[2], line[3]);
- prev[0] = coords[0];
- prev[1] = coords[1];
- } else if (cmd == VG_CUBIC_TO_ABS) {
-#if STROKE_DEBUG
- debug_printf("\n ---> (side) cubicTo [%.2f, %.2f]\n",
- coords[4],
- coords[5]);
-#endif
- struct bezier bezier;
- int count;
-
- bezier_init(&bezier,
- prev[0], prev[1], coords[0], coords[1],
- coords[2], coords[3], coords[4], coords[5]);
-
- count = bezier_translate_by_normal(&bezier,
- offset_curves,
- MAX_OFFSET,
- offset,
- curve_threshold);
-
- if (count) {
- /* if we are starting a new subpath, move to correct starting point */
- VGfloat tangent[4];
- VGint i;
-
- bezier_start_tangent(&bezier, tangent);
- line_translate(tangent,
- offset_curves[0].x1 - bezier.x1,
- offset_curves[0].y1 - bezier.y1);
- if (first) {
- VGfloat pt[2] = {offset_curves[0].x1,
- offset_curves[0].y1};
-
- if (cap_first) {
- create_joins(stroker, prev[0], prev[1], tangent,
- stroker_cap_mode(stroker));
- } else {
- stroker_emit_move_to(stroker, pt[0], pt[1]);
- }
- start_tangent[0] = tangent[0];
- start_tangent[1] = tangent[1];
- start_tangent[2] = tangent[2];
- start_tangent[3] = tangent[3];
- first = VG_FALSE;
- } else {
- create_joins(stroker, prev[0], prev[1], tangent,
- stroker_join_mode(stroker));
- }
-
- /* add these beziers */
- for (i = 0; i < count; ++i) {
- struct bezier *bez = &offset_curves[i];
- stroker_emit_curve_to(stroker,
- bez->x2, bez->y2,
- bez->x3, bez->y3,
- bez->x4, bez->y4);
- }
- }
-
- prev[0] = coords[4];
- prev[1] = coords[5];
- }
- }
-
- if (floatsEqual(start[0], prev[0]) &&
- floatsEqual(start[1], prev[1])) {
- /* closed subpath, join first and last point */
-#if STROKE_DEBUG
- debug_printf("\n stroker: closed subpath\n");
-#endif
- create_joins(stroker, prev[0], prev[1], start_tangent,
- stroker_join_mode(stroker));
- return VG_TRUE;
- } else {
-#if STROKE_DEBUG
- debug_printf("\n stroker: open subpath\n");
-#endif
- return VG_FALSE;
- }
-#undef MAX_OFFSET
-}
-
-static void stroker_process_subpath(struct stroker *stroker)
-{
- VGboolean fwclosed, bwclosed;
- VGfloat fw_start_tangent[4], bw_start_tangent[4];
- struct stroke_iterator fwit;
- struct stroke_iterator bwit;
- debug_assert(stroker->segments->num_elements > 0);
-
- memset(fw_start_tangent, 0,
- sizeof(VGfloat)*4);
- memset(bw_start_tangent, 0,
- sizeof(VGfloat)*4);
-
- stroke_forward_iterator(&fwit, stroker->segments,
- stroker->control_points);
- stroke_backward_iterator(&bwit, stroker->segments,
- stroker->control_points);
-
- debug_assert(fwit.cmds[0] == VG_MOVE_TO_ABS);
-
- fwclosed = vg_stroke_outline(&fwit, stroker, VG_FALSE, fw_start_tangent);
- bwclosed = vg_stroke_outline(&bwit, stroker, !fwclosed, bw_start_tangent);
-
- if (!bwclosed)
- create_joins(stroker,
- fwit.coords[0], fwit.coords[1], fw_start_tangent,
- stroker_cap_mode(stroker));
- else {
- /* hack to handle the requirement of the VG spec that says that strokes
- * of len==0 that have butt cap or round cap still need
- * to be rendered. (8.7.4 Stroke Generation) */
- if (stroker->segments->num_elements <= 3) {
- VGPathCommand cmd;
- VGfloat data[8], coords[8];
- struct stroke_iterator *it = &fwit;
-
- stroke_forward_iterator(it, stroker->segments,
- stroker->control_points);
- cmd = stroke_itr_command(it);
- stroke_itr_coords(it, coords);
- if (cmd != VG_MOVE_TO_ABS) {
- memset(data, 0, sizeof(VGfloat) * 8);
- if (!is_segment_null(cmd, coords, data))
- return;
- } else {
- data[0] = coords[0];
- data[1] = coords[1];
- }
- while (it->has_next(it)) {
- it->next(it);
- cmd = stroke_itr_command(it);
- stroke_itr_coords(it, coords);
- if (!is_segment_null(cmd, coords, data))
- return;
- }
- /* generate the square/round cap */
- if (stroker->cap_style == VG_CAP_SQUARE) {
- VGfloat offset = stroker->stroke_width / 2;
- stroker_emit_move_to(stroker, data[0] - offset,
- data[1] - offset);
- stroker_emit_line_to(stroker, data[0] + offset,
- data[1] - offset);
- stroker_emit_line_to(stroker, data[0] + offset,
- data[1] + offset);
- stroker_emit_line_to(stroker, data[0] - offset,
- data[1] + offset);
- stroker_emit_line_to(stroker, data[0] - offset,
- data[1] - offset);
- } else if (stroker->cap_style == VG_CAP_ROUND) {
- VGfloat offset = stroker->stroke_width / 2;
- VGfloat cx = data[0], cy = data[1];
- { /*circle */
- struct arc arc;
- struct matrix matrix;
- matrix_load_identity(&matrix);
-
- stroker_emit_move_to(stroker, cx + offset, cy);
- arc_init(&arc, VG_SCCWARC_TO,
- cx + offset, cy,
- cx - offset, cy,
- offset, offset, 0);
- arc_stroker_emit(&arc, stroker, &matrix);
- arc_init(&arc, VG_SCCWARC_TO,
- cx - offset, cy,
- cx + offset, cy,
- offset, offset, 0);
- arc_stroker_emit(&arc, stroker, &matrix);
- }
- }
- }
- }
-}
-
-static INLINE VGfloat dash_pattern(struct dash_stroker *stroker,
- VGint idx)
-{
- if (stroker->dash_pattern[idx] < 0)
- return 0.f;
- return stroker->dash_pattern[idx];
-}
-
-static void dash_stroker_process_subpath(struct stroker *str)
-{
- struct dash_stroker *stroker = (struct dash_stroker *)str;
- VGfloat sum_length = 0;
- VGint i;
- VGint idash = 0;
- VGfloat pos = 0;
- VGfloat elen = 0;
- VGfloat doffset = stroker->dash_phase;
- VGfloat estart = 0;
- VGfloat estop = 0;
- VGfloat cline[4];
- struct stroke_iterator it;
- VGfloat prev[2];
- VGfloat move_to_pos[2];
- VGfloat line_to_pos[2];
-
- VGboolean has_move_to = VG_FALSE;
-
- stroke_flat_iterator(&it, stroker->base.segments,
- stroker->base.control_points);
-
- stroke_itr_coords(&it, prev);
- move_to_pos[0] = prev[0];
- move_to_pos[1] = prev[1];
-
- debug_assert(stroker->dash_pattern_num > 0);
-
- for (i = 0; i < stroker->dash_pattern_num; ++i) {
- sum_length += dash_pattern(stroker, i);
- }
-
- if (floatIsZero(sum_length)) {
- return;
- }
-
- doffset -= floorf(doffset / sum_length) * sum_length;
-
- while (!floatIsZero(doffset) && doffset >= dash_pattern(stroker, idash)) {
- doffset -= dash_pattern(stroker, idash);
- idash = (idash + 1) % stroker->dash_pattern_num;
- }
-
- while (it.has_next(&it)) {
- VGPathCommand cmd;
- VGfloat coords[8];
- VGboolean done;
-
- it.next(&it);
- cmd = stroke_itr_command(&it);
- stroke_itr_coords(&it, coords);
-
- debug_assert(cmd == VG_LINE_TO_ABS);
- cline[0] = prev[0];
- cline[1] = prev[1];
- cline[2] = coords[0];
- cline[3] = coords[1];
-
- elen = line_lengthv(cline);
-
- estop = estart + elen;
-
- done = pos >= estop;
- while (!done) {
- VGfloat p2[2];
-
- VGint idash_incr = 0;
- VGboolean has_offset = doffset > 0;
- VGfloat dpos = pos + dash_pattern(stroker, idash) - doffset - estart;
-
- debug_assert(dpos >= 0);
-
- if (dpos > elen) { /* dash extends this line */
- doffset = dash_pattern(stroker, idash) - (dpos - elen);
- pos = estop;
- done = VG_TRUE;
- p2[0] = cline[2];
- p2[1] = cline[3];
- } else { /* Dash is on this line */
- line_point_at(cline, dpos/elen, p2);
- pos = dpos + estart;
- done = pos >= estop;
- idash_incr = 1;
- doffset = 0;
- }
-
- if (idash % 2 == 0) {
- line_to_pos[0] = p2[0];
- line_to_pos[1] = p2[1];
-
- if (!has_offset || !has_move_to) {
- stroker_move_to(&stroker->stroker, move_to_pos[0], move_to_pos[1]);
- has_move_to = VG_TRUE;
- }
- stroker_line_to(&stroker->stroker, line_to_pos[0], line_to_pos[1]);
- } else {
- move_to_pos[0] = p2[0];
- move_to_pos[1] = p2[1];
- }
-
- idash = (idash + idash_incr) % stroker->dash_pattern_num;
- }
-
- estart = estop;
- prev[0] = coords[0];
- prev[1] = coords[1];
- }
-
- if (it.curve_poly) {
- polygon_destroy(it.curve_poly);
- it.curve_poly = 0;
- }
-
- stroker->base.path = stroker->stroker.path;
-}
-
-static void default_begin(struct stroker *stroker)
-{
- array_reset(stroker->segments);
- array_reset(stroker->control_points);
-}
-
-static void default_end(struct stroker *stroker)
-{
- if (stroker->segments->num_elements > 0)
- stroker->process_subpath(stroker);
-}
-
-
-static void dash_stroker_begin(struct stroker *stroker)
-{
- struct dash_stroker *dasher =
- (struct dash_stroker *)stroker;
-
- default_begin(&dasher->stroker);
- default_begin(stroker);
-}
-
-static void dash_stroker_end(struct stroker *stroker)
-{
- struct dash_stroker *dasher =
- (struct dash_stroker *)stroker;
-
- default_end(stroker);
- default_end(&dasher->stroker);
-}
-
-void stroker_init(struct stroker *stroker,
- struct vg_state *state)
-{
- stroker->stroke_width = state->stroke.line_width.f;
- stroker->miter_limit = state->stroke.miter_limit.f;
- stroker->cap_style = state->stroke.cap_style;
- stroker->join_style = state->stroke.join_style;
-
- stroker->begin = default_begin;
- stroker->process_subpath = stroker_process_subpath;
- stroker->end = default_end;
-
- stroker->segments = array_create(sizeof(VGubyte));
- stroker->control_points = array_create(sizeof(VGfloat));
-
- stroker->back1_x = 0;
- stroker->back1_y = 0;
- stroker->back2_x = 0;
- stroker->back2_y = 0;
-
- stroker->path = path_create(VG_PATH_DATATYPE_F, 1.0f, 0.0f,
- 0, 0, VG_PATH_CAPABILITY_ALL);
-
- /* Initialize with an invalid value */
- stroker->last_cmd = (VGPathCommand)0;
-}
-
-void dash_stroker_init(struct stroker *str,
- struct vg_state *state)
-{
- struct dash_stroker *stroker = (struct dash_stroker *)str;
- int i;
-
- stroker_init(str, state);
- stroker_init(&stroker->stroker, state);
-
- {
- int real_num = state->stroke.dash_pattern_num;
- if (real_num % 2)/* if odd, ignore the last one */
- --real_num;
- for (i = 0; i < real_num; ++i)
- stroker->dash_pattern[i] = state->stroke.dash_pattern[i].f;
- stroker->dash_pattern_num = real_num;
- }
-
- stroker->dash_phase = state->stroke.dash_phase.f;
- stroker->dash_phase_reset = state->stroke.dash_phase_reset;
-
- stroker->base.begin = dash_stroker_begin;
- stroker->base.process_subpath = dash_stroker_process_subpath;
- stroker->base.end = dash_stroker_end;
- path_destroy(stroker->base.path);
- stroker->base.path = NULL;
-}
-
-void stroker_begin(struct stroker *stroker)
-{
- stroker->begin(stroker);
-}
-
-void stroker_end(struct stroker *stroker)
-{
- stroker->end(stroker);
-}
-
-void stroker_cleanup(struct stroker *stroker)
-{
- array_destroy(stroker->segments);
- array_destroy(stroker->control_points);
-}
-
-void dash_stroker_cleanup(struct dash_stroker *stroker)
-{
- /* if stroker->base.path is null means we never
- * processed a valid path so delete the temp one
- * we already created */
- if (!stroker->base.path)
- path_destroy(stroker->stroker.path);
- stroker_cleanup(&stroker->stroker);
- stroker_cleanup((struct stroker*)stroker);
-}
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#ifndef STROKER_H
-#define STROKER_H
-
-#include "VG/openvg.h"
-#include "api_consts.h"
-
-struct path;
-struct vg_state;
-struct array;
-
-struct stroker {
- void (*begin)(struct stroker *stroker);
- void (*process_subpath)(struct stroker *stroker);
- void (*end)(struct stroker *stroker);
-
- struct array *segments;
- struct array *control_points;
- struct path *path;
-
- VGfloat back1_x, back1_y;
- VGfloat back2_x, back2_y;
-
- VGfloat stroke_width;
- VGfloat miter_limit;
- VGCapStyle cap_style;
- VGJoinStyle join_style;
-
- VGPathCommand last_cmd;
-};
-
-struct dash_stroker {
- struct stroker base;
-
- struct stroker stroker;
-
- VGfloat dash_pattern[VEGA_MAX_DASH_COUNT];
- VGint dash_pattern_num;
- VGfloat dash_phase;
- VGboolean dash_phase_reset;
-};
-
-void stroker_init(struct stroker *stroker,
- struct vg_state *state);
-void dash_stroker_init(struct stroker *stroker,
- struct vg_state *state);
-void dash_stroker_cleanup(struct dash_stroker *stroker);
-void stroker_cleanup(struct stroker *stroker);
-
-void stroker_begin(struct stroker *stroker);
-void stroker_move_to(struct stroker *stroker, VGfloat x, VGfloat y);
-void stroker_line_to(struct stroker *stroker, VGfloat x, VGfloat y);
-void stroker_curve_to(struct stroker *stroker, VGfloat px1, VGfloat py1,
- VGfloat px2, VGfloat py2,
- VGfloat x, VGfloat y);
-void stroker_end(struct stroker *stroker);
-
-void stroker_emit_move_to(struct stroker *stroker, VGfloat x, VGfloat y);
-void stroker_emit_line_to(struct stroker *stroker, VGfloat x, VGfloat y);
-void stroker_emit_curve_to(struct stroker *stroker, VGfloat px1, VGfloat py1,
- VGfloat px2, VGfloat py2,
- VGfloat x, VGfloat y);
-
-#endif
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2010 LunarG, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#include "util/u_memory.h"
-#include "cso_cache/cso_hash.h"
-
-#include "text.h"
-#include "image.h"
-#include "path.h"
-
-#ifdef OPENVG_VERSION_1_1
-
-struct vg_font {
- struct vg_object base;
- struct cso_hash *glyphs;
-};
-
-struct vg_glyph {
- struct vg_object *object; /* it could be NULL */
- VGboolean is_hinted;
- VGfloat glyph_origin[2];
- VGfloat escapement[2];
-};
-
-static VGboolean del_glyph(struct vg_font *font,
- VGuint glyphIndex)
-{
- struct vg_glyph *glyph;
-
- glyph = (struct vg_glyph *)
- cso_hash_take(font->glyphs, (unsigned) glyphIndex);
- FREE(glyph);
-
- return (glyph != NULL);
-}
-
-static void add_glyph(struct vg_font *font,
- VGuint glyphIndex,
- struct vg_object *obj,
- VGboolean isHinted,
- const VGfloat glyphOrigin[2],
- const VGfloat escapement[2])
-{
- struct vg_glyph *glyph;
-
- /* remove the existing one */
- del_glyph(font, glyphIndex);
-
- glyph = CALLOC_STRUCT(vg_glyph);
- glyph->object = obj;
- glyph->is_hinted = isHinted;
- memcpy(glyph->glyph_origin, glyphOrigin, sizeof(glyph->glyph_origin));
- memcpy(glyph->escapement, escapement, sizeof(glyph->glyph_origin));
-
- cso_hash_insert(font->glyphs, (unsigned) glyphIndex, glyph);
-}
-
-static struct vg_glyph *get_glyph(struct vg_font *font,
- VGuint glyphIndex)
-{
- struct cso_hash_iter iter;
-
- iter = cso_hash_find(font->glyphs, (unsigned) glyphIndex);
- return (struct vg_glyph *) cso_hash_iter_data(iter);
-}
-
-static void vg_render_glyph(struct vg_context *ctx,
- struct vg_glyph *glyph,
- VGbitfield paintModes,
- VGboolean allowAutoHinting)
-{
- if (glyph->object && paintModes) {
- struct vg_state *state = &ctx->state.vg;
- struct matrix m;
-
- m = state->glyph_user_to_surface_matrix;
- matrix_translate(&m,
- state->glyph_origin[0].f - glyph->glyph_origin[0],
- state->glyph_origin[1].f - glyph->glyph_origin[1]);
-
- if (glyph->object->type == VG_OBJECT_PATH) {
- path_render((struct path *) glyph->object, paintModes, &m);
- }
- else {
- assert(glyph->object->type == VG_OBJECT_IMAGE);
- image_draw((struct vg_image *) glyph->object, &m);
- }
- }
-}
-
-static void vg_advance_glyph(struct vg_context *ctx,
- struct vg_glyph *glyph,
- VGfloat adjustment_x,
- VGfloat adjustment_y,
- VGboolean last)
-{
- struct vg_value *glyph_origin = ctx->state.vg.glyph_origin;
-
- glyph_origin[0].f += glyph->escapement[0] + adjustment_x;
- glyph_origin[1].f += glyph->escapement[1] + adjustment_y;
-
- if (last) {
- glyph_origin[0].i = float_to_int_floor(glyph_origin[0].f);
- glyph_origin[1].i = float_to_int_floor(glyph_origin[1].f);
- }
-}
-
-struct vg_font *font_create(VGint glyphCapacityHint)
-{
- struct vg_context *ctx = vg_current_context();
- struct vg_font *font;
-
- font = CALLOC_STRUCT(vg_font);
- vg_init_object(&font->base, ctx, VG_OBJECT_FONT);
- font->glyphs = cso_hash_create();
-
- vg_context_add_object(ctx, &font->base);
-
- return font;
-}
-
-void font_destroy(struct vg_font *font)
-{
- struct vg_context *ctx = vg_current_context();
- struct cso_hash_iter iter;
-
- vg_context_remove_object(ctx, &font->base);
-
- iter = cso_hash_first_node(font->glyphs);
- while (!cso_hash_iter_is_null(iter)) {
- struct vg_glyph *glyph = (struct vg_glyph *) cso_hash_iter_data(iter);
- FREE(glyph);
- iter = cso_hash_iter_next(iter);
- }
- cso_hash_delete(font->glyphs);
-
- vg_free_object(&font->base);
-
- FREE(font);
-}
-
-void font_set_glyph_to_path(struct vg_font *font,
- VGuint glyphIndex,
- struct path *path,
- VGboolean isHinted,
- const VGfloat glyphOrigin[2],
- const VGfloat escapement[2])
-{
- add_glyph(font, glyphIndex, (struct vg_object *) path,
- isHinted, glyphOrigin, escapement);
-}
-
-void font_set_glyph_to_image(struct vg_font *font,
- VGuint glyphIndex,
- struct vg_image *image,
- const VGfloat glyphOrigin[2],
- const VGfloat escapement[2])
-{
- add_glyph(font, glyphIndex, (struct vg_object *) image,
- VG_TRUE, glyphOrigin, escapement);
-}
-
-void font_clear_glyph(struct vg_font *font,
- VGuint glyphIndex)
-{
- if (!del_glyph(font, glyphIndex)) {
- struct vg_context *ctx = vg_current_context();
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- }
-}
-
-void font_draw_glyph(struct vg_font *font,
- VGuint glyphIndex,
- VGbitfield paintModes,
- VGboolean allowAutoHinting)
-{
- struct vg_context *ctx = vg_current_context();
- struct vg_glyph *glyph;
-
- glyph = get_glyph(font, glyphIndex);
- if (!glyph) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
-
- vg_render_glyph(ctx, glyph, paintModes, allowAutoHinting);
- vg_advance_glyph(ctx, glyph, 0.0f, 0.0f, VG_TRUE);
-}
-
-void font_draw_glyphs(struct vg_font *font,
- VGint glyphCount,
- const VGuint *glyphIndices,
- const VGfloat *adjustments_x,
- const VGfloat *adjustments_y,
- VGbitfield paintModes,
- VGboolean allowAutoHinting)
-{
- struct vg_context *ctx = vg_current_context();
- VGint i;
-
- for (i = 0; i < glyphCount; ++i) {
- if (!get_glyph(font, glyphIndices[i])) {
- vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
- return;
- }
- }
-
- for (i = 0; i < glyphCount; ++i) {
- struct vg_glyph *glyph;
- VGfloat adj_x, adj_y;
-
- glyph = get_glyph(font, glyphIndices[i]);
-
- vg_render_glyph(ctx, glyph, paintModes, allowAutoHinting);
-
- adj_x = (adjustments_x) ? adjustments_x[i] : 0.0f;
- adj_y = (adjustments_y) ? adjustments_y[i] : 0.0f;
- vg_advance_glyph(ctx, glyph, adj_x, adj_y, (i == glyphCount - 1));
- }
-}
-
-VGint font_num_glyphs(struct vg_font *font)
-{
- return cso_hash_size(font->glyphs);
-}
-
-#endif /* OPENVG_VERSION_1_1 */
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2010 LunarG, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#ifndef _TEXT_H
-#define _TEXT_H
-
-#include "vg_context.h"
-#include "cso_cache/cso_hash.h"
-
-struct vg_font;
-struct vg_image;
-struct path;
-
-struct vg_font *font_create(VGint glyphCapacityHint);
-void font_destroy(struct vg_font *font);
-
-void font_set_glyph_to_path(struct vg_font *font,
- VGuint glyphIndex,
- struct path *path,
- VGboolean isHinted,
- const VGfloat glyphOrigin[2],
- const VGfloat escapement[2]);
-
-void font_set_glyph_to_image(struct vg_font *font,
- VGuint glyphIndex,
- struct vg_image *image,
- const VGfloat glyphOrigin[2],
- const VGfloat escapement[2]);
-
-void font_clear_glyph(struct vg_font *font,
- VGuint glyphIndex);
-
-void font_draw_glyph(struct vg_font *font,
- VGuint glyphIndex,
- VGbitfield paintModes,
- VGboolean allowAutoHinting);
-
-void font_draw_glyphs(struct vg_font *font,
- VGint glyphCount,
- const VGuint *glyphIndices,
- const VGfloat *adjustments_x,
- const VGfloat *adjustments_y,
- VGbitfield paintModes,
- VGboolean allowAutoHinting);
-
-VGint font_num_glyphs(struct vg_font *font);
-
-#endif /* _TEXT_H */
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#ifndef UTIL_ARRAY_H
-#define UTIL_ARRAY_H
-
-#include "util/u_memory.h"
-
-#define DEFAULT_ARRAY_SIZE 256
-
-struct array {
- VGint datatype_size;
- void *data;
- VGint size;
- VGint num_elements;
-};
-
-static INLINE struct array *array_create(VGint datatype_size)
-{
- struct array *array = CALLOC_STRUCT(array);
- array->datatype_size = datatype_size;
-
- array->size = DEFAULT_ARRAY_SIZE;
- array->data = malloc(array->size * array->datatype_size);
-
- return array;
-}
-
-
-static INLINE struct array *array_create_size(VGint datatype_size, VGint size)
-{
- struct array *array = CALLOC_STRUCT(array);
- array->datatype_size = datatype_size;
-
- array->size = size;
- array->data = malloc(array->size * array->datatype_size);
-
- return array;
-}
-
-static INLINE void array_destroy(struct array *array)
-{
- if (array)
- free(array->data);
- FREE(array);
-}
-
-static INLINE void array_resize(struct array *array, int num)
-{
- VGint size = array->datatype_size * num;
- void *data = malloc(size);
- memcpy(data, array->data, array->size * array->datatype_size);
- free(array->data);
- array->data = data;
- array->size = num;
- array->num_elements = (array->num_elements > num) ? num :
- array->num_elements;
-}
-
-static INLINE void array_append_data(struct array *array,
- const void *data, int num_elements)
-{
- VGbyte *adata;
-
- while (array->num_elements + num_elements > array->size) {
- array_resize(array, (array->num_elements + num_elements) * 1.5);
- }
- adata = (VGbyte *)array->data;
- memcpy(adata + (array->num_elements * array->datatype_size), data,
- num_elements * array->datatype_size);
- array->num_elements += num_elements;
-}
-
-static INLINE void array_change_data(struct array *array,
- const void *data,
- int start_idx,
- int num_elements)
-{
- VGbyte *adata = (VGbyte *)array->data;
- memcpy(adata + (start_idx * array->datatype_size), data,
- num_elements * array->datatype_size);
-}
-
-static INLINE void array_remove_element(struct array *array,
- int idx)
-{
- VGbyte *adata = (VGbyte *)array->data;
- memmove(adata + (idx * array->datatype_size),
- adata + ((idx + 1) * array->datatype_size),
- (array->num_elements - idx - 1) * array->datatype_size);
- --array->num_elements;
-}
-
-static INLINE void array_reset(struct array *array)
-{
- array->num_elements = 0;
-}
-
-#endif
+++ /dev/null
-/*
- * Mesa 3-D graphics library
- *
- * Copyright (C) 2010 LunarG Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- *
- * Authors:
- * Chia-I Wu <olv@lunarg.com>
- */
-
-#ifndef VG_API_H
-#define VG_API_H
-
-struct st_api;
-
-const struct st_api *
-vg_api_get(void);
-
-#endif /* VG_API_H */
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#include "vg_context.h"
-
-#include "paint.h"
-#include "renderer.h"
-#include "shaders_cache.h"
-#include "shader.h"
-#include "vg_manager.h"
-#include "api.h"
-#include "mask.h"
-#include "handle.h"
-
-#include "pipe/p_context.h"
-#include "util/u_inlines.h"
-
-#include "cso_cache/cso_context.h"
-
-#include "util/u_memory.h"
-#include "util/u_sampler.h"
-#include "util/u_surface.h"
-#include "util/u_format.h"
-
-struct vg_context *_vg_context = 0;
-
-struct vg_context * vg_current_context(void)
-{
- return _vg_context;
-}
-
-/**
- * A depth/stencil rb will be needed regardless of what the visual says.
- */
-static boolean
-choose_depth_stencil_format(struct vg_context *ctx)
-{
- struct pipe_screen *screen = ctx->pipe->screen;
- enum pipe_format formats[] = {
- PIPE_FORMAT_Z24_UNORM_S8_UINT,
- PIPE_FORMAT_S8_UINT_Z24_UNORM,
- PIPE_FORMAT_NONE
- };
- enum pipe_format *fmt;
-
- for (fmt = formats; *fmt != PIPE_FORMAT_NONE; fmt++) {
- if (screen->is_format_supported(screen, *fmt,
- PIPE_TEXTURE_2D, 0, PIPE_BIND_DEPTH_STENCIL))
- break;
- }
-
- ctx->ds_format = *fmt;
-
- return (ctx->ds_format != PIPE_FORMAT_NONE);
-}
-
-void vg_set_current_context(struct vg_context *ctx)
-{
- _vg_context = ctx;
- api_make_dispatch_current((ctx) ? ctx->dispatch : NULL);
-}
-
-struct vg_context * vg_create_context(struct pipe_context *pipe,
- const void *visual,
- struct vg_context *share)
-{
- struct vg_context *ctx;
-
- ctx = CALLOC_STRUCT(vg_context);
-
- ctx->pipe = pipe;
- if (!choose_depth_stencil_format(ctx)) {
- FREE(ctx);
- return NULL;
- }
-
- ctx->dispatch = api_create_dispatch();
-
- vg_init_state(&ctx->state.vg);
- ctx->state.dirty = ALL_DIRTY;
-
- ctx->cso_context = cso_create_context(pipe);
-
- ctx->default_paint = paint_create(ctx);
- ctx->state.vg.stroke_paint = ctx->default_paint;
- ctx->state.vg.fill_paint = ctx->default_paint;
-
-
- ctx->mask.sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
- ctx->mask.sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
- ctx->mask.sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
- ctx->mask.sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
- ctx->mask.sampler.min_img_filter = PIPE_TEX_FILTER_NEAREST;
- ctx->mask.sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST;
- ctx->mask.sampler.normalized_coords = 0;
-
- ctx->blend_sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
- ctx->blend_sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
- ctx->blend_sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
- ctx->blend_sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
- ctx->blend_sampler.min_img_filter = PIPE_TEX_FILTER_NEAREST;
- ctx->blend_sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST;
- ctx->blend_sampler.normalized_coords = 0;
-
- vg_set_error(ctx, VG_NO_ERROR);
-
- ctx->owned_objects[VG_OBJECT_PAINT] = cso_hash_create();
- ctx->owned_objects[VG_OBJECT_IMAGE] = cso_hash_create();
- ctx->owned_objects[VG_OBJECT_MASK] = cso_hash_create();
- ctx->owned_objects[VG_OBJECT_FONT] = cso_hash_create();
- ctx->owned_objects[VG_OBJECT_PATH] = cso_hash_create();
-
- ctx->renderer = renderer_create(ctx);
- ctx->sc = shaders_cache_create(ctx);
- ctx->shader = shader_create(ctx);
-
- return ctx;
-}
-
-void vg_destroy_context(struct vg_context *ctx)
-{
- struct pipe_resource **cbuf = &ctx->mask.cbuf;
-
- renderer_destroy(ctx->renderer);
- shaders_cache_destroy(ctx->sc);
- shader_destroy(ctx->shader);
- paint_destroy(ctx->default_paint);
-
- if (*cbuf)
- pipe_resource_reference(cbuf, NULL);
-
- if (ctx->mask.union_fs)
- vg_shader_destroy(ctx, ctx->mask.union_fs);
- if (ctx->mask.intersect_fs)
- vg_shader_destroy(ctx, ctx->mask.intersect_fs);
- if (ctx->mask.subtract_fs)
- vg_shader_destroy(ctx, ctx->mask.subtract_fs);
- if (ctx->mask.set_fs)
- vg_shader_destroy(ctx, ctx->mask.set_fs);
-
- cso_destroy_context(ctx->cso_context);
-
- cso_hash_delete(ctx->owned_objects[VG_OBJECT_PAINT]);
- cso_hash_delete(ctx->owned_objects[VG_OBJECT_IMAGE]);
- cso_hash_delete(ctx->owned_objects[VG_OBJECT_MASK]);
- cso_hash_delete(ctx->owned_objects[VG_OBJECT_FONT]);
- cso_hash_delete(ctx->owned_objects[VG_OBJECT_PATH]);
-
- api_destroy_dispatch(ctx->dispatch);
-
- FREE(ctx);
-}
-
-void vg_init_object(struct vg_object *obj, struct vg_context *ctx, enum vg_object_type type)
-{
- obj->type = type;
- obj->ctx = ctx;
- obj->handle = create_handle(obj);
-}
-
-/** free object resources, but not the object itself */
-void vg_free_object(struct vg_object *obj)
-{
- obj->type = 0;
- obj->ctx = NULL;
- destroy_handle(obj->handle);
-}
-
-VGboolean vg_context_is_object_valid(struct vg_context *ctx,
- enum vg_object_type type,
- VGHandle handle)
-{
- if (ctx) {
- struct cso_hash *hash = ctx->owned_objects[type];
- if (!hash)
- return VG_FALSE;
- return cso_hash_contains(hash, (unsigned) handle);
- }
- return VG_FALSE;
-}
-
-void vg_context_add_object(struct vg_context *ctx,
- struct vg_object *obj)
-{
- if (ctx) {
- struct cso_hash *hash = ctx->owned_objects[obj->type];
- if (!hash)
- return;
- cso_hash_insert(hash, (unsigned) obj->handle, obj);
- }
-}
-
-void vg_context_remove_object(struct vg_context *ctx,
- struct vg_object *obj)
-{
- if (ctx) {
- struct cso_hash *hash = ctx->owned_objects[obj->type];
- if (!hash)
- return;
- cso_hash_take(hash, (unsigned) obj->handle);
- }
-}
-
-static struct pipe_resource *
-create_texture(struct pipe_context *pipe, enum pipe_format format,
- VGint width, VGint height)
-{
- struct pipe_resource templ;
-
- memset(&templ, 0, sizeof(templ));
-
- if (format != PIPE_FORMAT_NONE) {
- templ.format = format;
- }
- else {
- templ.format = PIPE_FORMAT_B8G8R8A8_UNORM;
- }
-
- templ.target = PIPE_TEXTURE_2D;
- templ.width0 = width;
- templ.height0 = height;
- templ.depth0 = 1;
- templ.array_size = 1;
- templ.last_level = 0;
-
- if (util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_ZS, 1)) {
- templ.bind = PIPE_BIND_DEPTH_STENCIL;
- } else {
- templ.bind = (PIPE_BIND_DISPLAY_TARGET |
- PIPE_BIND_RENDER_TARGET |
- PIPE_BIND_SAMPLER_VIEW);
- }
-
- return pipe->screen->resource_create(pipe->screen, &templ);
-}
-
-static struct pipe_sampler_view *
-create_tex_and_view(struct pipe_context *pipe, enum pipe_format format,
- VGint width, VGint height)
-{
- struct pipe_resource *texture;
- struct pipe_sampler_view view_templ;
- struct pipe_sampler_view *view;
-
- texture = create_texture(pipe, format, width, height);
-
- if (!texture)
- return NULL;
-
- u_sampler_view_default_template(&view_templ, texture, texture->format);
- view = pipe->create_sampler_view(pipe, texture, &view_templ);
- /* want the texture to go away if the view is freed */
- pipe_resource_reference(&texture, NULL);
-
- return view;
-}
-
-static void
-vg_context_update_surface_mask_view(struct vg_context *ctx,
- uint width, uint height)
-{
- struct st_framebuffer *stfb = ctx->draw_buffer;
- struct pipe_sampler_view *old_sampler_view = stfb->surface_mask_view;
- struct pipe_context *pipe = ctx->pipe;
-
- if (old_sampler_view &&
- old_sampler_view->texture->width0 == width &&
- old_sampler_view->texture->height0 == height)
- return;
-
- /*
- we use PIPE_FORMAT_B8G8R8A8_UNORM because we want to render to
- this texture and use it as a sampler, so while this wastes some
- space it makes both of those a lot simpler
- */
- stfb->surface_mask_view = create_tex_and_view(pipe,
- PIPE_FORMAT_B8G8R8A8_UNORM, width, height);
-
- if (!stfb->surface_mask_view) {
- if (old_sampler_view)
- pipe_sampler_view_reference(&old_sampler_view, NULL);
- return;
- }
-
- /* XXX could this call be avoided? */
- vg_validate_state(ctx);
-
- /* alpha mask starts with 1.f alpha */
- mask_fill(0, 0, width, height, 1.f);
-
- /* if we had an old surface copy it over */
- if (old_sampler_view) {
- struct pipe_box src_box;
- u_box_origin_2d(MIN2(old_sampler_view->texture->width0,
- stfb->surface_mask_view->texture->width0),
- MIN2(old_sampler_view->texture->height0,
- stfb->surface_mask_view->texture->height0),
- &src_box);
-
- pipe->resource_copy_region(pipe,
- stfb->surface_mask_view->texture,
- 0, 0, 0, 0,
- old_sampler_view->texture,
- 0, &src_box);
- }
-
- /* Free the old texture
- */
- if (old_sampler_view)
- pipe_sampler_view_reference(&old_sampler_view, NULL);
-}
-
-static void
-vg_context_update_blend_texture_view(struct vg_context *ctx,
- uint width, uint height)
-{
- struct pipe_context *pipe = ctx->pipe;
- struct st_framebuffer *stfb = ctx->draw_buffer;
- struct pipe_sampler_view *old = stfb->blend_texture_view;
-
- if (old &&
- old->texture->width0 == width &&
- old->texture->height0 == height)
- return;
-
- stfb->blend_texture_view = create_tex_and_view(pipe,
- PIPE_FORMAT_B8G8R8A8_UNORM, width, height);
-
- pipe_sampler_view_reference(&old, NULL);
-}
-
-static boolean
-vg_context_update_depth_stencil_rb(struct vg_context * ctx,
- uint width, uint height)
-{
- struct st_renderbuffer *dsrb = ctx->draw_buffer->dsrb;
- struct pipe_context *pipe = ctx->pipe;
- struct pipe_surface surf_tmpl;
-
- if ((dsrb->width == width && dsrb->height == height) && dsrb->texture)
- return FALSE;
-
- /* unreference existing ones */
- pipe_surface_reference(&dsrb->surface, NULL);
- pipe_resource_reference(&dsrb->texture, NULL);
- dsrb->width = dsrb->height = 0;
-
- dsrb->texture = create_texture(pipe, dsrb->format, width, height);
- if (!dsrb->texture)
- return TRUE;
-
- u_surface_default_template(&surf_tmpl, dsrb->texture);
- dsrb->surface = pipe->create_surface(pipe,
- dsrb->texture,
- &surf_tmpl);
- if (!dsrb->surface) {
- pipe_resource_reference(&dsrb->texture, NULL);
- return TRUE;
- }
-
- dsrb->width = width;
- dsrb->height = height;
-
- assert(dsrb->surface->width == width);
- assert(dsrb->surface->height == height);
-
- return TRUE;
-}
-
-void vg_validate_state(struct vg_context *ctx)
-{
- struct st_framebuffer *stfb = ctx->draw_buffer;
-
- vg_manager_validate_framebuffer(ctx);
-
- if (vg_context_update_depth_stencil_rb(ctx, stfb->width, stfb->height))
- ctx->state.dirty |= DEPTH_STENCIL_DIRTY;
-
- /* blend state depends on fb format and paint color */
- if ((ctx->state.dirty & FRAMEBUFFER_DIRTY) ||
- (ctx->state.dirty & PAINT_DIRTY))
- ctx->state.dirty |= BLEND_DIRTY;
-
- renderer_validate(ctx->renderer, ctx->state.dirty,
- ctx->draw_buffer, &ctx->state.vg);
-
- ctx->state.dirty = 0;
-
- shader_set_masking(ctx->shader, ctx->state.vg.masking);
- shader_set_image_mode(ctx->shader, ctx->state.vg.image_mode);
- shader_set_color_transform(ctx->shader, ctx->state.vg.color_transform);
-}
-
-VGboolean vg_object_is_valid(VGHandle object, enum vg_object_type type)
-{
- struct vg_object *obj = handle_to_object(object);
- if (obj && is_aligned(obj) && obj->type == type)
- return VG_TRUE;
- else
- return VG_FALSE;
-}
-
-void vg_set_error(struct vg_context *ctx,
- VGErrorCode code)
-{
- /*vgGetError returns the oldest error code provided by
- * an API call on the current context since the previous
- * call to vgGetError on that context (or since the creation
- of the context).*/
- if (ctx->_error == VG_NO_ERROR)
- ctx->_error = code;
-}
-
-static void vg_prepare_blend_texture(struct vg_context *ctx,
- struct pipe_sampler_view *src)
-{
- struct st_framebuffer *stfb = ctx->draw_buffer;
- struct pipe_context *pipe = ctx->pipe;
- struct pipe_blit_info info;
-
- vg_context_update_blend_texture_view(ctx, stfb->width, stfb->height);
-
- memset(&info, 0, sizeof info);
- info.dst.resource = stfb->blend_texture_view->texture;
- info.dst.level = 0;
- info.dst.box.x = 0;
- info.dst.box.y = 0;
- info.dst.box.z = 0;
- info.dst.box.width = stfb->width;
- info.dst.box.height = stfb->height;
- info.dst.box.depth = 1;
- info.dst.format = stfb->blend_texture_view->format;
- info.src.resource = src->texture;
- info.src.level = src->u.tex.first_level;
- info.src.box.x = 0;
- info.src.box.y = 0;
- info.src.box.z = src->u.tex.first_layer;
- info.src.box.width = stfb->width;
- info.src.box.height = stfb->height;
- info.src.box.depth = 1;
- info.src.format = src->format;
- info.mask = PIPE_MASK_RGBA;
- info.filter = PIPE_TEX_MIPFILTER_NEAREST;
- info.scissor_enable = 0;
-
- pipe->blit(pipe, &info);
-}
-
-struct pipe_sampler_view *vg_prepare_blend_surface(struct vg_context *ctx)
-{
- struct pipe_context *pipe = ctx->pipe;
- struct pipe_sampler_view *view;
- struct pipe_sampler_view view_templ;
- struct st_framebuffer *stfb = ctx->draw_buffer;
- struct st_renderbuffer *strb = stfb->strb;
-
- vg_validate_state(ctx);
-
- u_sampler_view_default_template(&view_templ, strb->texture, strb->texture->format);
- view = pipe->create_sampler_view(pipe, strb->texture, &view_templ);
-
- vg_prepare_blend_texture(ctx, view);
-
- pipe_sampler_view_reference(&view, NULL);
-
- return stfb->blend_texture_view;
-}
-
-
-struct pipe_sampler_view *vg_prepare_blend_surface_from_mask(struct vg_context *ctx)
-{
- struct st_framebuffer *stfb = ctx->draw_buffer;
-
- vg_validate_state(ctx);
-
- vg_context_update_surface_mask_view(ctx, stfb->width, stfb->height);
- vg_prepare_blend_texture(ctx, stfb->surface_mask_view);
-
- return stfb->blend_texture_view;
-}
-
-struct pipe_sampler_view *vg_get_surface_mask(struct vg_context *ctx)
-{
- struct st_framebuffer *stfb = ctx->draw_buffer;
-
- vg_context_update_surface_mask_view(ctx, stfb->width, stfb->height);
-
- return stfb->surface_mask_view;
-}
-
-/**
- * A transformation from window coordinates to paint coordinates.
- */
-VGboolean vg_get_paint_matrix(struct vg_context *ctx,
- const struct matrix *paint_to_user,
- const struct matrix *user_to_surface,
- struct matrix *mat)
-{
- struct matrix tmp;
-
- /* get user-to-paint matrix */
- memcpy(mat, paint_to_user, sizeof(*paint_to_user));
- if (!matrix_invert(mat))
- return VG_FALSE;
-
- /* get surface-to-user matrix */
- memcpy(&tmp, user_to_surface, sizeof(*user_to_surface));
- if (!matrix_invert(&tmp))
- return VG_FALSE;
-
- matrix_mult(mat, &tmp);
-
- return VG_TRUE;
-}
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#ifndef VG_CONTEXT_H
-#define VG_CONTEXT_H
-
-#include "vg_state.h"
-
-#include "pipe/p_format.h"
-#include "pipe/p_state.h"
-#include "util/u_pointer.h"
-#include "util/u_math.h"
-#include "state_tracker/st_api.h"
-
-#include "cso_cache/cso_hash.h"
-#include "cso_cache/cso_context.h"
-
-struct renderer;
-struct shaders_cache;
-struct shader;
-struct vg_shader;
-struct mapi_table;
-
-struct st_renderbuffer {
- enum pipe_format format;
- struct pipe_surface *surface;
- struct pipe_resource *texture;
- VGint width, height;
-};
-
-struct st_framebuffer {
- VGint width, height;
- struct st_renderbuffer *strb;
- struct st_renderbuffer *dsrb;
-
- struct pipe_sampler_view *surface_mask_view;
-
- struct pipe_sampler_view *blend_texture_view;
-
-
- struct st_framebuffer_iface *iface;
- enum st_attachment_type strb_att;
-
- void *privateData;
- int32_t stamp;
- int32_t iface_stamp;
-};
-
-enum vg_object_type {
- VG_OBJECT_UNKNOWN = 0,
- VG_OBJECT_PAINT,
- VG_OBJECT_IMAGE,
- VG_OBJECT_MASK,
- VG_OBJECT_FONT,
- VG_OBJECT_PATH,
-
- VG_OBJECT_LAST
-};
-enum dirty_state {
- BLEND_DIRTY = 1 << 0,
- FRAMEBUFFER_DIRTY = 1 << 1,
- DEPTH_STENCIL_DIRTY = 1 << 2,
- PAINT_DIRTY = 1 << 3,
-
- ALL_DIRTY = BLEND_DIRTY |
- FRAMEBUFFER_DIRTY |
- DEPTH_STENCIL_DIRTY |
- PAINT_DIRTY
-};
-
-struct vg_context
-{
- struct st_context_iface iface;
- struct mapi_table *dispatch;
-
- struct pipe_context *pipe;
- enum pipe_format ds_format;
-
- struct {
- struct vg_state vg;
- VGbitfield dirty;
- } state;
-
- VGErrorCode _error;
-
- struct st_framebuffer *draw_buffer;
-
- struct cso_hash *owned_objects[VG_OBJECT_LAST];
-
- struct {
- struct pipe_resource *cbuf;
- struct pipe_sampler_state sampler;
-
- struct vg_shader *union_fs;
- struct vg_shader *intersect_fs;
- struct vg_shader *subtract_fs;
- struct vg_shader *set_fs;
- } mask;
-
- struct cso_context *cso_context;
-
- struct renderer *renderer;
- struct shaders_cache *sc;
- struct shader *shader;
-
- struct pipe_sampler_state blend_sampler;
- struct vg_paint *default_paint;
-
- int32_t draw_stamp;
-};
-
-
-/**
- * Base class for VG objects like paths, images, fonts.
- */
-struct vg_object {
- enum vg_object_type type;
- VGHandle handle;
- struct vg_context *ctx;
-};
-
-
-void vg_init_object(struct vg_object *obj, struct vg_context *ctx, enum vg_object_type type);
-void vg_free_object(struct vg_object *obj);
-
-VGboolean vg_object_is_valid(VGHandle object, enum vg_object_type type);
-
-struct vg_context *vg_create_context(struct pipe_context *pipe,
- const void *visual,
- struct vg_context *share);
-void vg_destroy_context(struct vg_context *ctx);
-struct vg_context *vg_current_context(void);
-void vg_set_current_context(struct vg_context *ctx);
-
-VGboolean vg_context_is_object_valid(struct vg_context *ctx,
- enum vg_object_type type,
- VGHandle object);
-void vg_context_add_object(struct vg_context *ctx,
- struct vg_object *obj);
-void vg_context_remove_object(struct vg_context *ctx,
- struct vg_object *obj);
-
-void vg_validate_state(struct vg_context *ctx);
-
-void vg_set_error(struct vg_context *ctx,
- VGErrorCode code);
-
-struct pipe_sampler_view *vg_prepare_blend_surface(struct vg_context *ctx);
-struct pipe_sampler_view *vg_prepare_blend_surface_from_mask(struct vg_context *ctx);
-
-struct pipe_sampler_view *vg_get_surface_mask(struct vg_context *ctx);
-
-VGboolean vg_get_paint_matrix(struct vg_context *ctx,
- const struct matrix *paint_to_user,
- const struct matrix *user_to_surface,
- struct matrix *mat);
-
-static INLINE VGboolean is_aligned_to(const void *ptr, VGbyte alignment)
-{
- void *aligned = align_pointer(ptr, alignment);
- return (ptr == aligned) ? VG_TRUE : VG_FALSE;
-}
-
-static INLINE VGboolean is_aligned(const void *ptr)
-{
- return is_aligned_to(ptr, 4);
-}
-
-static INLINE void vg_shift_rectx(VGfloat coords[4],
- const VGfloat *bounds,
- const VGfloat shift)
-{
- coords[0] += shift;
- coords[2] -= shift;
- if (bounds) {
- coords[2] = MIN2(coords[2], bounds[2]);
- /* bound x/y + width/height */
- if ((coords[0] + coords[2]) > (bounds[0] + bounds[2])) {
- coords[2] = (bounds[0] + bounds[2]) - coords[0];
- }
- }
-}
-
-static INLINE void vg_shift_recty(VGfloat coords[4],
- const VGfloat *bounds,
- const VGfloat shift)
-{
- coords[1] += shift;
- coords[3] -= shift;
- if (bounds) {
- coords[3] = MIN2(coords[3], bounds[3]);
- if ((coords[1] + coords[3]) > (bounds[1] + bounds[3])) {
- coords[3] = (bounds[1] + bounds[3]) - coords[1];
- }
- }
-}
-
-static INLINE void vg_bound_rect(VGfloat coords[4],
- const VGfloat bounds[4],
- VGfloat shift[4])
-{
- /* if outside the bounds */
- if (coords[0] > (bounds[0] + bounds[2]) ||
- coords[1] > (bounds[1] + bounds[3]) ||
- (coords[0] + coords[2]) < bounds[0] ||
- (coords[1] + coords[3]) < bounds[1]) {
- coords[0] = 0.f;
- coords[1] = 0.f;
- coords[2] = 0.f;
- coords[3] = 0.f;
- shift[0] = 0.f;
- shift[1] = 0.f;
- return;
- }
-
- /* bound x */
- if (coords[0] < bounds[0]) {
- shift[0] = bounds[0] - coords[0];
- coords[2] -= shift[0];
- coords[0] = bounds[0];
- } else
- shift[0] = 0.f;
-
- /* bound y */
- if (coords[1] < bounds[1]) {
- shift[1] = bounds[1] - coords[1];
- coords[3] -= shift[1];
- coords[1] = bounds[1];
- } else
- shift[1] = 0.f;
-
- shift[2] = bounds[2] - coords[2];
- shift[3] = bounds[3] - coords[3];
- /* bound width/height */
- coords[2] = MIN2(coords[2], bounds[2]);
- coords[3] = MIN2(coords[3], bounds[3]);
-
- /* bound x/y + width/height */
- if ((coords[0] + coords[2]) > (bounds[0] + bounds[2])) {
- coords[2] = (bounds[0] + bounds[2]) - coords[0];
- }
- if ((coords[1] + coords[3]) > (bounds[1] + bounds[3])) {
- coords[3] = (bounds[1] + bounds[3]) - coords[1];
- }
-
- /* if outside the bounds */
- if ((coords[0] + coords[2]) < bounds[0] ||
- (coords[1] + coords[3]) < bounds[1]) {
- coords[0] = 0.f;
- coords[1] = 0.f;
- coords[2] = 0.f;
- coords[3] = 0.f;
- return;
- }
-}
-
-#endif
+++ /dev/null
-/*
- * Mesa 3-D graphics library
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- * Copyright (C) 2010 LunarG Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- *
- * Authors:
- * Chia-I Wu <olv@lunarg.com>
- */
-
-#include "state_tracker/st_api.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_screen.h"
-#include "util/u_memory.h"
-#include "util/u_inlines.h"
-#include "util/u_box.h"
-#include "util/u_surface.h"
-
-#include "vg_api.h"
-#include "vg_manager.h"
-#include "vg_context.h"
-#include "api.h"
-#include "handle.h"
-
-static boolean
-vg_context_update_color_rb(struct vg_context *ctx, struct pipe_resource *pt)
-{
- struct st_renderbuffer *strb = ctx->draw_buffer->strb;
- struct pipe_context *pipe = ctx->pipe;
- struct pipe_surface surf_tmpl;
-
- if (strb->texture == pt) {
- pipe_resource_reference(&pt, NULL);
- return FALSE;
- }
-
- /* unreference existing ones */
- pipe_surface_reference(&strb->surface, NULL);
- pipe_resource_reference(&strb->texture, NULL);
- strb->width = strb->height = 0;
-
- strb->texture = pt;
-
- u_surface_default_template(&surf_tmpl, strb->texture);
- strb->surface = pipe->create_surface(pipe, strb->texture, &surf_tmpl);
-
- if (!strb->surface) {
- pipe_resource_reference(&strb->texture, NULL);
- return TRUE;
- }
-
- strb->width = pt->width0;
- strb->height = pt->height0;
-
- return TRUE;
-}
-
-/**
- * Flush the front buffer if the current context renders to the front buffer.
- */
-void
-vg_manager_flush_frontbuffer(struct vg_context *ctx)
-{
- struct st_framebuffer *stfb = ctx->draw_buffer;
-
- if (!stfb)
- return;
-
- switch (stfb->strb_att) {
- case ST_ATTACHMENT_FRONT_LEFT:
- case ST_ATTACHMENT_FRONT_RIGHT:
- stfb->iface->flush_front(&ctx->iface, stfb->iface, stfb->strb_att);
- break;
- default:
- break;
- }
-}
-
-/**
- * Re-validate the framebuffer.
- */
-void
-vg_manager_validate_framebuffer(struct vg_context *ctx)
-{
- struct st_framebuffer *stfb = ctx->draw_buffer;
- struct pipe_resource *pt;
- int32_t new_stamp;
-
- /* no binding surface */
- if (!stfb)
- return;
-
- new_stamp = p_atomic_read(&stfb->iface->stamp);
- if (stfb->iface_stamp != new_stamp) {
- do {
- /* validate the fb */
- if (!stfb->iface->validate((struct st_context_iface *)ctx,
- stfb->iface, &stfb->strb_att,
- 1, &pt) || !pt)
- return;
-
- stfb->iface_stamp = new_stamp;
- new_stamp = p_atomic_read(&stfb->iface->stamp);
-
- } while (stfb->iface_stamp != new_stamp);
-
- if (vg_context_update_color_rb(ctx, pt) ||
- stfb->width != pt->width0 ||
- stfb->height != pt->height0)
- ++stfb->stamp;
-
- stfb->width = pt->width0;
- stfb->height = pt->height0;
- }
-
- if (ctx->draw_stamp != stfb->stamp) {
- ctx->state.dirty |= FRAMEBUFFER_DIRTY;
- ctx->draw_stamp = stfb->stamp;
- }
-}
-
-static void
-vg_context_flush(struct st_context_iface *stctxi, unsigned flags,
- struct pipe_fence_handle **fence)
-{
- struct vg_context *ctx = (struct vg_context *) stctxi;
- unsigned pipe_flags = 0;
-
- if (flags & ST_FLUSH_END_OF_FRAME) {
- pipe_flags |= PIPE_FLUSH_END_OF_FRAME;
- }
-
- ctx->pipe->flush(ctx->pipe, fence, pipe_flags);
- if (flags & ST_FLUSH_FRONT)
- vg_manager_flush_frontbuffer(ctx);
-}
-
-static void
-vg_context_destroy(struct st_context_iface *stctxi)
-{
- struct vg_context *ctx = (struct vg_context *) stctxi;
- struct pipe_context *pipe = ctx->pipe;
-
- vg_destroy_context(ctx);
- pipe->destroy(pipe);
-}
-
-static struct st_context_iface *
-vg_api_create_context(struct st_api *stapi, struct st_manager *smapi,
- const struct st_context_attribs *attribs,
- enum st_context_error *error,
- struct st_context_iface *shared_stctxi)
-{
- struct vg_context *shared_ctx = (struct vg_context *) shared_stctxi;
- struct vg_context *ctx;
- struct pipe_context *pipe;
-
- if (!(stapi->profile_mask & (1 << attribs->profile))) {
- *error = ST_CONTEXT_ERROR_BAD_API;
- return NULL;
- }
-
- /* only 1.0 is supported */
- if (attribs->major > 1 || (attribs->major == 1 && attribs->minor > 0)) {
- *error = ST_CONTEXT_ERROR_BAD_VERSION;
- return NULL;
- }
-
- /* for VGHandle / pointer lookups */
- init_handles();
-
- pipe = smapi->screen->context_create(smapi->screen, NULL);
- if (!pipe) {
- *error = ST_CONTEXT_ERROR_NO_MEMORY;
- return NULL;
- }
- ctx = vg_create_context(pipe, NULL, shared_ctx);
- if (!ctx) {
- pipe->destroy(pipe);
- *error = ST_CONTEXT_ERROR_NO_MEMORY;
- return NULL;
- }
-
- ctx->iface.destroy = vg_context_destroy;
-
- ctx->iface.flush = vg_context_flush;
-
- ctx->iface.teximage = NULL;
- ctx->iface.copy = NULL;
-
- ctx->iface.st_context_private = (void *) smapi;
-
- return &ctx->iface;
-}
-
-static struct st_renderbuffer *
-create_renderbuffer(enum pipe_format format)
-{
- struct st_renderbuffer *strb;
-
- strb = CALLOC_STRUCT(st_renderbuffer);
- if (strb)
- strb->format = format;
-
- return strb;
-}
-
-static void
-destroy_renderbuffer(struct st_renderbuffer *strb)
-{
- pipe_surface_reference(&strb->surface, NULL);
- pipe_resource_reference(&strb->texture, NULL);
- FREE(strb);
-}
-
-/**
- * Decide the buffer to render to.
- */
-static enum st_attachment_type
-choose_attachment(struct st_framebuffer_iface *stfbi)
-{
- enum st_attachment_type statt;
-
- statt = stfbi->visual->render_buffer;
- if (statt != ST_ATTACHMENT_INVALID) {
- /* use the buffer given by the visual, unless it is unavailable */
- if (!st_visual_have_buffers(stfbi->visual, 1 << statt)) {
- switch (statt) {
- case ST_ATTACHMENT_BACK_LEFT:
- statt = ST_ATTACHMENT_FRONT_LEFT;
- break;
- case ST_ATTACHMENT_BACK_RIGHT:
- statt = ST_ATTACHMENT_FRONT_RIGHT;
- break;
- default:
- break;
- }
-
- if (!st_visual_have_buffers(stfbi->visual, 1 << statt))
- statt = ST_ATTACHMENT_INVALID;
- }
- }
-
- return statt;
-}
-
-/**
- * Bind the context to the given framebuffers.
- */
-static boolean
-vg_context_bind_framebuffers(struct st_context_iface *stctxi,
- struct st_framebuffer_iface *stdrawi,
- struct st_framebuffer_iface *streadi)
-{
- struct vg_context *ctx = (struct vg_context *) stctxi;
- struct st_framebuffer *stfb;
- enum st_attachment_type strb_att;
-
- /* the draw and read framebuffers must be the same */
- if (stdrawi != streadi)
- return FALSE;
-
- strb_att = (stdrawi) ? choose_attachment(stdrawi) : ST_ATTACHMENT_INVALID;
-
- if (ctx->draw_buffer) {
- stfb = ctx->draw_buffer;
-
- /* free the existing fb */
- if (!stdrawi ||
- stfb->strb_att != strb_att ||
- stfb->strb->format != stdrawi->visual->color_format) {
- destroy_renderbuffer(stfb->strb);
- destroy_renderbuffer(stfb->dsrb);
- FREE(stfb);
-
- ctx->draw_buffer = NULL;
- }
- }
-
- if (!stdrawi)
- return TRUE;
-
- if (strb_att == ST_ATTACHMENT_INVALID)
- return FALSE;
-
- /* create a new fb */
- if (!ctx->draw_buffer) {
- stfb = CALLOC_STRUCT(st_framebuffer);
- if (!stfb)
- return FALSE;
-
- stfb->strb = create_renderbuffer(stdrawi->visual->color_format);
- if (!stfb->strb) {
- FREE(stfb);
- return FALSE;
- }
-
- stfb->dsrb = create_renderbuffer(ctx->ds_format);
- if (!stfb->dsrb) {
- FREE(stfb->strb);
- FREE(stfb);
- return FALSE;
- }
-
- stfb->width = 0;
- stfb->height = 0;
- stfb->strb_att = strb_att;
- stfb->stamp = 1;
- stfb->iface_stamp = p_atomic_read(&stdrawi->stamp) - 1;
-
- ctx->draw_buffer = stfb;
- }
-
- ctx->draw_buffer->iface = stdrawi;
- ctx->draw_stamp = ctx->draw_buffer->stamp - 1;
-
- return TRUE;
-}
-
-static boolean
-vg_api_make_current(struct st_api *stapi, struct st_context_iface *stctxi,
- struct st_framebuffer_iface *stdrawi,
- struct st_framebuffer_iface *streadi)
-{
- struct vg_context *ctx = (struct vg_context *) stctxi;
-
- if (stctxi)
- vg_context_bind_framebuffers(stctxi, stdrawi, streadi);
- vg_set_current_context(ctx);
-
- return TRUE;
-}
-
-static struct st_context_iface *
-vg_api_get_current(struct st_api *stapi)
-{
- struct vg_context *ctx = vg_current_context();
-
- return (ctx) ? &ctx->iface : NULL;
-}
-
-static st_proc_t
-vg_api_get_proc_address(struct st_api *stapi, const char *procname)
-{
- return api_get_proc_address(procname);
-}
-
-static void
-vg_api_destroy(struct st_api *stapi)
-{
-}
-
-static void
-vg_api_query_versions(struct st_api *stapi, struct st_manager *sm,
- struct st_config_options *options,
- int *gl_core_version,
- int *gl_compat_version,
- int *gl_es1_version,
- int *gl_es2_version)
-{
-}
-
-static const struct st_api vg_api = {
- "Vega " PACKAGE_VERSION,
- ST_API_OPENVG,
- ST_PROFILE_DEFAULT_MASK,
- 0,
- vg_api_destroy,
- vg_api_query_versions,
- vg_api_get_proc_address,
- vg_api_create_context,
- vg_api_make_current,
- vg_api_get_current,
-};
-
-const struct st_api *
-vg_api_get(void)
-{
- return &vg_api;
-}
+++ /dev/null
-/*
- * Mesa 3-D graphics library
- *
- * Copyright (C) 2010 LunarG Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- *
- * Authors:
- * Chia-I Wu <olv@lunarg.com>
- */
-
-#ifndef VG_MANAGER_H
-#define VG_MANAGER_H
-
-#include "state_tracker/st_api.h"
-#include "vg_context.h"
-
-void
-vg_manager_flush_frontbuffer(struct vg_context *ctx);
-
-void
-vg_manager_validate_framebuffer(struct vg_context *ctx);
-
-#endif /* VG_MANAGER_H */
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#include "vg_state.h"
-
-#include <string.h>
-
-void vg_init_state(struct vg_state *state)
-{
- state->matrix_mode = VG_MATRIX_PATH_USER_TO_SURFACE;
- state->fill_rule = VG_EVEN_ODD;
- state->image_quality = VG_IMAGE_QUALITY_FASTER;
- state->rendering_quality = VG_RENDERING_QUALITY_BETTER;
- state->blend_mode = VG_BLEND_SRC_OVER;
- state->image_mode = VG_DRAW_IMAGE_NORMAL;
-
- memset(state->scissor_rects, 0, sizeof(state->scissor_rects));
- state->scissor_rects_num = 0;
-
- state->color_transform = VG_FALSE;
- state->color_transform_values[0] = 1.0f;
- state->color_transform_values[1] = 1.0f;
- state->color_transform_values[2] = 1.0f;
- state->color_transform_values[3] = 1.0f;
- state->color_transform_values[4] = 0.0f;
- state->color_transform_values[5] = 0.0f;
- state->color_transform_values[6] = 0.0f;
- state->color_transform_values[7] = 0.0f;
-
- /* Stroke parameters */
- state->stroke.line_width.f = 1.0f;
- state->stroke.line_width.i = 1;
- state->stroke.cap_style = VG_CAP_BUTT;
- state->stroke.join_style = VG_JOIN_MITER;
- state->stroke.miter_limit.f = 4.0f;
- state->stroke.miter_limit.i = 4;
- state->stroke.dash_pattern_num = 0;
- state->stroke.dash_phase.f = 0.0f;
- state->stroke.dash_phase.i = 0;
- state->stroke.dash_phase_reset = VG_FALSE;
-
- /* Edge fill color for VG_TILE_FILL tiling mode */
- state->tile_fill_color[0] = 0.0f;
- state->tile_fill_color[1] = 0.0f;
- state->tile_fill_color[2] = 0.0f;
- state->tile_fill_color[3] = 0.0f;
-
- /* Color for vgClear */
- state->clear_color[0] = 0.0f;
- state->clear_color[1] = 0.0f;
- state->clear_color[2] = 0.0f;
- state->clear_color[3] = 0.0f;
-
- /* Glyph origin */
- state->glyph_origin[0].f = 0.0f;
- state->glyph_origin[1].f = 0.0f;
- state->glyph_origin[0].i = 0;
- state->glyph_origin[1].i = 0;
-
- /* Enable/disable alpha masking and scissoring */
- state->masking = VG_FALSE;
- state->scissoring = VG_FALSE;
-
- /* Pixel layout information */
- state->pixel_layout = VG_PIXEL_LAYOUT_UNKNOWN;
- state->screen_layout = VG_PIXEL_LAYOUT_UNKNOWN;
-
- /* Source format selection for image filters */
- state->filter_format_linear = VG_FALSE;
- state->filter_format_premultiplied = VG_FALSE;
-
- /* Destination write enable mask for image filters */
- state->filter_channel_mask = (VG_RED | VG_GREEN | VG_BLUE | VG_ALPHA);
-
- matrix_load_identity(&state->path_user_to_surface_matrix);
- matrix_load_identity(&state->image_user_to_surface_matrix);
- matrix_load_identity(&state->fill_paint_to_user_matrix);
- matrix_load_identity(&state->stroke_paint_to_user_matrix);
- matrix_load_identity(&state->glyph_user_to_surface_matrix);
-}
-
-struct matrix *vg_state_matrix(struct vg_state *state)
-{
- switch(state->matrix_mode) {
- case VG_MATRIX_PATH_USER_TO_SURFACE:
- return &state->path_user_to_surface_matrix;
- case VG_MATRIX_IMAGE_USER_TO_SURFACE:
- return &state->image_user_to_surface_matrix;
- case VG_MATRIX_FILL_PAINT_TO_USER:
- return &state->fill_paint_to_user_matrix;
- case VG_MATRIX_STROKE_PAINT_TO_USER:
- return &state->stroke_paint_to_user_matrix;
-#ifdef OPENVG_VERSION_1_1
- case VG_MATRIX_GLYPH_USER_TO_SURFACE:
- return &state->glyph_user_to_surface_matrix;
-#endif
- default:
- break;
- }
- return NULL;
-}
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#ifndef VG_STATE_H
-#define VG_STATE_H
-
-#include "VG/openvg.h"
-
-#include "api_consts.h"
-#include "matrix.h"
-
-struct vg_value
-{
- VGfloat f;
- VGint i;
-};
-
-struct vg_state {
- /* Mode settings */
- VGMatrixMode matrix_mode;
- VGFillRule fill_rule;
- VGImageQuality image_quality;
- VGRenderingQuality rendering_quality;
- VGBlendMode blend_mode;
- VGImageMode image_mode;
-
- /* Scissoring rectangles */
- struct vg_value scissor_rects[32*4];
- VGint scissor_rects_num;
-
- /* Color Transformation */
- VGboolean color_transform;
- VGfloat color_transform_values[8];
-
- /* Stroke parameters */
- struct {
- struct vg_value line_width;
- VGCapStyle cap_style;
- VGJoinStyle join_style;
- struct vg_value miter_limit;
- struct vg_value dash_pattern[VEGA_MAX_DASH_COUNT];
- VGint dash_pattern_num;
- struct vg_value dash_phase;
- VGboolean dash_phase_reset;
- } stroke;
-
- /* Edge fill color for VG_TILE_FILL tiling mode */
- VGfloat tile_fill_color[4];
- VGint tile_fill_colori[4];
-
- /* Color for vgClear */
- VGfloat clear_color[4];
- VGint clear_colori[4];
-
- /* Glyph origin */
- struct vg_value glyph_origin[2];
-
- /* Enable/disable alpha masking and scissoring */
- VGboolean masking;
- VGboolean scissoring;
-
- /* Pixel layout information */
- VGPixelLayout pixel_layout;
- VGPixelLayout screen_layout;
-
- /* Source format selection for image filters */
- VGboolean filter_format_linear;
- VGboolean filter_format_premultiplied;
-
- /* Destination write enable mask for image filters */
- VGbitfield filter_channel_mask;
-
- struct matrix path_user_to_surface_matrix;
- struct matrix image_user_to_surface_matrix;
- struct matrix fill_paint_to_user_matrix;
- struct matrix stroke_paint_to_user_matrix;
- struct matrix glyph_user_to_surface_matrix;
-
- struct vg_paint *stroke_paint;
- struct vg_paint *fill_paint;
-};
-
-void vg_init_state(struct vg_state *state);
-struct matrix * vg_state_matrix(struct vg_state *state);
-
-#endif
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#include "vg_translate.h"
-
-#include "pipe/p_format.h"
-#include "util/u_pack_color.h"
-
-void _vega_pack_rgba_span_float(struct vg_context *ctx,
- VGuint n, VGfloat rgba[][4],
- VGImageFormat dstFormat,
- void *dstAddr)
-{
- VGuint i;
-
- switch (dstFormat) {
- case VG_sRGBX_8888: {
- VGint *dst = (VGint *)dstAddr;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- r = float_to_ubyte(rgba[i][0]);
- g = float_to_ubyte(rgba[i][1]);
- b = float_to_ubyte(rgba[i][2]);
- a = 255;
- dst[i] = r << 24 | g << 16 | b << 8 | a;
- }
- return;
- }
- break;
- case VG_sRGBA_8888: {
- VGint *dst = (VGint *)dstAddr;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- r = float_to_ubyte(rgba[i][0]);
- g = float_to_ubyte(rgba[i][1]);
- b = float_to_ubyte(rgba[i][2]);
- a = float_to_ubyte(rgba[i][3]);
- dst[i] = r << 24 | g << 16 | b << 8 | a;
- }
- return;
- }
- break;
- case VG_sRGBA_8888_PRE: {
- VGint *dst = (VGint *)dstAddr;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- r = float_to_ubyte(rgba[i][0]);
- g = float_to_ubyte(rgba[i][1]);
- b = float_to_ubyte(rgba[i][2]);
- a = float_to_ubyte(rgba[i][3]);
- dst[i] = r << 24 | g << 16 | b << 8 | a;
- }
- return;
- }
- break;
- case VG_sRGB_565: {
- VGshort *dst = (VGshort *)dstAddr;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b;
- r = float_to_ubyte(rgba[i][0]);
- g = float_to_ubyte(rgba[i][1]);
- b = float_to_ubyte(rgba[i][2]);
- r = (r / 255.0) * 32;
- g = (g / 255.0) * 32;
- b = (b / 255.0) * 32;
-
- dst[i] = b | g << 5 | r << 11;
- }
- return;
- }
- break;
- case VG_sRGBA_5551: {
- VGshort *dst = (VGshort *)dstAddr;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b, a;
- r = float_to_ubyte(rgba[i][0]);
- g = float_to_ubyte(rgba[i][1]);
- b = float_to_ubyte(rgba[i][2]);
- a = float_to_ubyte(rgba[i][3]);
- r = (r / 255.0) * 32;
- g = (g / 255.0) * 32;
- b = (b / 255.0) * 32;
- a = (a / 255.0);
-
- dst[i] = a | b << 1 | g << 6 | r << 11;
- }
- return;
- }
- break;
- case VG_sRGBA_4444: {
- VGshort *dst = (VGshort *)dstAddr;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b, a;
- r = float_to_ubyte(rgba[i][0]);
- g = float_to_ubyte(rgba[i][1]);
- b = float_to_ubyte(rgba[i][2]);
- a = float_to_ubyte(rgba[i][3]);
- r = (r / 255.0) * 16;
- g = (g / 255.0) * 16;
- b = (b / 255.0) * 16;
- a = (a / 255.0) * 16;
-
- dst[i] = a | b << 4 | g << 8 | r << 12;
- }
- return;
- }
- break;
- case VG_sL_8: {
- VGubyte *dst = (VGubyte *)dstAddr;
- for (i = 0; i < n; ++i) {
- VGubyte a;
- a = float_to_ubyte(rgba[i][3]);
-
- dst[i] = a;
- }
- return;
- }
- break;
- case VG_lRGBX_8888: {
- VGint *dst = (VGint *)dstAddr;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- r = float_to_ubyte(rgba[i][0]);
- g = float_to_ubyte(rgba[i][1]);
- b = float_to_ubyte(rgba[i][2]);
- a = 255;
- dst[i] = r << 24 | g << 16 | b << 8 | a;
- }
- return;
- }
- break;
- case VG_lRGBA_8888: {
- VGint *dst = (VGint *)dstAddr;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- r = float_to_ubyte(rgba[i][0]);
- g = float_to_ubyte(rgba[i][1]);
- b = float_to_ubyte(rgba[i][2]);
- a = float_to_ubyte(rgba[i][3]);
- dst[i] = r << 24 | g << 16 | b << 8 | a;
- }
- return;
- }
- case VG_lRGBA_8888_PRE: {
- VGint *dst = (VGint *)dstAddr;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- r = float_to_ubyte(rgba[i][0]);
- g = float_to_ubyte(rgba[i][1]);
- b = float_to_ubyte(rgba[i][2]);
- a = float_to_ubyte(rgba[i][3]);
- dst[i] = r << 24 | g << 16 | b << 8 | a;
- }
- return;
- }
- break;
- case VG_lL_8: {
- VGubyte *dst = (VGubyte *)dstAddr;
- for (i = 0; i < n; ++i) {
- VGubyte a;
- a = float_to_ubyte(rgba[i][3]);
- dst[i] = a;
- }
- return;
- }
- break;
- case VG_A_8: {
- VGubyte *dst = (VGubyte *)dstAddr;
- for (i = 0; i < n; ++i) {
- VGubyte a;
- a = float_to_ubyte(rgba[i][3]);
-
- dst[i] = a;
- }
- return;
- }
- break;
- case VG_BW_1: {
- VGshort *dst = (VGshort *)dstAddr;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b, a;
- VGubyte res;
- r = float_to_ubyte(rgba[i][0]);
- g = float_to_ubyte(rgba[i][1]);
- b = float_to_ubyte(rgba[i][2]);
- a = float_to_ubyte(rgba[i][3]);
-
- res = (r + g + b + a)/4;
- dst[i] = (res & (128));
- }
- return;
- }
- break;
-#ifdef OPENVG_VERSION_1_1
- case VG_A_1: {
- VGshort *dst = (VGshort *)dstAddr;
- for (i = 0; i < n; ++i) {
- VGubyte a;
- a = float_to_ubyte(rgba[i][3]);
-
- dst[i] = (a & (128));
- }
- return;
- }
- break;
- case VG_A_4: {
- VGshort *dst = (VGshort *)dstAddr;
- for (i = 0; i < n; ++i) {
- VGubyte a;
- VGubyte res;
- a = float_to_ubyte(rgba[i][3]);
-
- res = a/4;
- dst[i] = (res & (128));
- }
- return;
- }
- break;
-#endif
- case VG_sXRGB_8888:
- break;
- case VG_sARGB_8888: {
- VGint *dst = (VGint *)dstAddr;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- r = float_to_ubyte(rgba[i][0]);
- g = float_to_ubyte(rgba[i][1]);
- b = float_to_ubyte(rgba[i][2]);
- a = float_to_ubyte(rgba[i][3]);
- dst[i] = a << 24 | r << 16 | g << 8 | b;
- }
- return;
- }
- break;
- case VG_sARGB_8888_PRE: {
- VGint *dst = (VGint *)dstAddr;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- r = float_to_ubyte(rgba[i][0]);
- g = float_to_ubyte(rgba[i][1]);
- b = float_to_ubyte(rgba[i][2]);
- a = float_to_ubyte(rgba[i][3]);
- dst[i] = a << 24 | r << 16 | g << 8 | b;
- }
- return;
- }
- break;
- case VG_sARGB_1555:
- break;
- case VG_sARGB_4444:
- break;
- case VG_lXRGB_8888:
- break;
- case VG_lARGB_8888: {
- VGint *dst = (VGint *)dstAddr;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- r = float_to_ubyte(rgba[i][0]);
- g = float_to_ubyte(rgba[i][1]);
- b = float_to_ubyte(rgba[i][2]);
- a = float_to_ubyte(rgba[i][3]);
- dst[i] = a << 24 | r << 16 | g << 8 | b;
- }
- return;
- }
- break;
- case VG_lARGB_8888_PRE: {
- VGint *dst = (VGint *)dstAddr;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- r = float_to_ubyte(rgba[i][0]);
- g = float_to_ubyte(rgba[i][1]);
- b = float_to_ubyte(rgba[i][2]);
- a = float_to_ubyte(rgba[i][3]);
- dst[i] = a << 24 | r << 16 | g << 8 | b;
- }
- return;
- }
- break;
- case VG_sBGRX_8888: {
- VGint *dst = (VGint *)dstAddr;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- r = float_to_ubyte(rgba[i][0]);
- g = float_to_ubyte(rgba[i][1]);
- b = float_to_ubyte(rgba[i][2]);
- a = 0xff;
- dst[i] = b << 24 | g << 16 | r << 8 | a;
- }
- return;
- }
- break;
- case VG_sBGRA_8888: {
- VGint *dst = (VGint *)dstAddr;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- r = float_to_ubyte(rgba[i][0]);
- g = float_to_ubyte(rgba[i][1]);
- b = float_to_ubyte(rgba[i][2]);
- a = float_to_ubyte(rgba[i][3]);
- dst[i] = b << 24 | g << 16 | r << 8 | a;
- }
- return;
- }
- break;
- case VG_sBGRA_8888_PRE: {
- VGint *dst = (VGint *)dstAddr;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- r = float_to_ubyte(rgba[i][0]);
- g = float_to_ubyte(rgba[i][1]);
- b = float_to_ubyte(rgba[i][2]);
- a = float_to_ubyte(rgba[i][3]);
- dst[i] = b << 24 | g << 16 | r << 8 | a;
- }
- return;
- }
- break;
- case VG_sBGR_565:
- break;
- case VG_sBGRA_5551:
- break;
- case VG_sBGRA_4444:
- break;
- case VG_lBGRX_8888: {
- VGint *dst = (VGint *)dstAddr;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- r = float_to_ubyte(rgba[i][0]);
- g = float_to_ubyte(rgba[i][1]);
- b = float_to_ubyte(rgba[i][2]);
- a = 0xff;
- dst[i] = b << 24 | g << 16 | r << 8 | a;
- }
- return;
- }
- break;
- case VG_lBGRA_8888: {
- VGint *dst = (VGint *)dstAddr;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- r = float_to_ubyte(rgba[i][0]);
- g = float_to_ubyte(rgba[i][1]);
- b = float_to_ubyte(rgba[i][2]);
- a = float_to_ubyte(rgba[i][3]);
- dst[i] = b << 24 | g << 16 | r << 8 | a;
- }
- return;
- }
- break;
- case VG_lBGRA_8888_PRE: {
- VGint *dst = (VGint *)dstAddr;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- r = float_to_ubyte(rgba[i][0]);
- g = float_to_ubyte(rgba[i][1]);
- b = float_to_ubyte(rgba[i][2]);
- a = float_to_ubyte(rgba[i][3]);
- dst[i] = b << 24 | g << 16 | r << 8 | a;
- }
- return;
- }
- break;
- case VG_sXBGR_8888:
- break;
- case VG_sABGR_8888: {
- VGint *dst = (VGint *)dstAddr;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- r = float_to_ubyte(rgba[i][0]);
- g = float_to_ubyte(rgba[i][1]);
- b = float_to_ubyte(rgba[i][2]);
- a = float_to_ubyte(rgba[i][3]);
- dst[i] = a << 24 | b << 16 | g << 8 | r;
- }
- return;
- }
- break;
- case VG_sABGR_8888_PRE: {
- VGint *dst = (VGint *)dstAddr;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- r = float_to_ubyte(rgba[i][0]);
- g = float_to_ubyte(rgba[i][1]);
- b = float_to_ubyte(rgba[i][2]);
- a = float_to_ubyte(rgba[i][3]);
- dst[i] = a << 24 | b << 16 | g << 8 | r;
- }
- return;
- }
- break;
- case VG_sABGR_1555:
- break;
- case VG_sABGR_4444:
- break;
- case VG_lXBGR_8888:
- break;
- case VG_lABGR_8888: {
- VGint *dst = (VGint *)dstAddr;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- r = float_to_ubyte(rgba[i][0]);
- g = float_to_ubyte(rgba[i][1]);
- b = float_to_ubyte(rgba[i][2]);
- a = float_to_ubyte(rgba[i][3]);
- dst[i] = a << 24 | b << 16 | g << 8 | r;
- }
- return;
- }
- break;
- case VG_lABGR_8888_PRE: {
- VGint *dst = (VGint *)dstAddr;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- r = float_to_ubyte(rgba[i][0]);
- g = float_to_ubyte(rgba[i][1]);
- b = float_to_ubyte(rgba[i][2]);
- a = float_to_ubyte(rgba[i][3]);
- dst[i] = a << 24 | b << 16 | g << 8 | r;
- }
- return;
- }
- break;
- default:
- assert(!"Unknown ReadPixels format");
- break;
- }
- assert(!"Not implemented ReadPixels format");
-}
-
-void _vega_unpack_float_span_rgba(struct vg_context *ctx,
- VGuint n,
- VGuint offset,
- const void * data,
- VGImageFormat dataFormat,
- VGfloat rgba[][4])
-{
- VGuint i;
- union util_color uc;
-
- switch (dataFormat) {
- case VG_sRGBX_8888: {
- VGuint *src = (VGuint *)data;
- src += offset;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- r = (*src >> 24) & 0xff;
- g = (*src >> 16) & 0xff;
- b = (*src >> 8) & 0xff;
- a = 0xff;
-
- util_pack_color_ub(r, g, b, a, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
- rgba[i][0] = uc.f[0];
- rgba[i][1] = uc.f[1];
- rgba[i][2] = uc.f[2];
- rgba[i][3] = uc.f[3];
- ++src;
- }
- }
- return;
- case VG_sRGBA_8888: {
- VGuint *src = (VGuint *)data;
- src += offset;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- r = (*src >> 24) & 0xff;
- g = (*src >> 16) & 0xff;
- b = (*src >> 8) & 0xff;
- a = (*src >> 0) & 0xff;
-
- util_pack_color_ub(r, g, b, a, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
- rgba[i][0] = uc.f[0];
- rgba[i][1] = uc.f[1];
- rgba[i][2] = uc.f[2];
- rgba[i][3] = uc.f[3];
- ++src;
- }
- return;
- }
- break;
- case VG_sRGBA_8888_PRE: {
- VGint *src = (VGint *)data;
- src += offset;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- r = (*src >> 24) & 0xff;
- g = (*src >> 16) & 0xff;
- b = (*src >> 8) & 0xff;
- a = (*src >> 0) & 0xff;
-
- util_pack_color_ub(r, g, b, a, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
- rgba[i][0] = uc.f[0];
- rgba[i][1] = uc.f[1];
- rgba[i][2] = uc.f[2];
- rgba[i][3] = uc.f[3];
- ++src;
- }
- return;
- }
- break;
- case VG_sRGB_565: {
- VGshort *src = (VGshort *)data;
- src += offset;
- for (i = 0; i < n; ++i) {
- VGfloat clr[4];
- clr[0] = ((*src >> 11) & 31)/31.;
- clr[1] = ((*src >> 5) & 63)/63.;
- clr[2] = ((*src >> 0) & 31)/31.;
- clr[3] = 1.f;
-
- util_pack_color(clr, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
- rgba[i][0] = uc.f[0];
- rgba[i][1] = uc.f[1];
- rgba[i][2] = uc.f[2];
- rgba[i][3] = uc.f[3];
- ++src;
- }
- }
- return;
- case VG_sRGBA_5551: {
- VGshort *src = (VGshort *)data;
- src += offset;
- for (i = 0; i < n; ++i) {
- VGfloat clr[4];
- clr[0] = ((*src >> 10) & 31)/31.;
- clr[1] = ((*src >> 5) & 31)/31.;
- clr[2] = ((*src >> 1) & 31)/31.;
- clr[3] = ((*src >> 0) & 1)/1.;
-
- util_pack_color(clr, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
- rgba[i][0] = uc.f[0];
- rgba[i][1] = uc.f[1];
- rgba[i][2] = uc.f[2];
- rgba[i][3] = uc.f[3];
- ++src;
- }
- }
- return;
- case VG_sRGBA_4444: {
- VGshort *src = (VGshort *)data;
- src += offset;
- for (i = 0; i < n; ++i) {
- VGfloat clr[4];
- clr[0] = ((*src >> 12) & 15)/15.;
- clr[1] = ((*src >> 8) & 15)/15.;
- clr[2] = ((*src >> 4) & 15)/15.;
- clr[3] = ((*src >> 0) & 15)/15.;
-
- util_pack_color(clr, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
- rgba[i][0] = uc.f[0];
- rgba[i][1] = uc.f[1];
- rgba[i][2] = uc.f[2];
- rgba[i][3] = uc.f[3];
- ++src;
- }
- }
- return;
- case VG_sL_8: {
- VGubyte *src = (VGubyte *)data;
- src += offset;
- for (i = 0; i < n; ++i) {
- util_pack_color_ub(0xff, 0xff, 0xff, *src, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
- rgba[i][0] = uc.f[0];
- rgba[i][1] = uc.f[1];
- rgba[i][2] = uc.f[2];
- rgba[i][3] = uc.f[3];
- ++src;
- }
- }
- return;
- case VG_lRGBX_8888: {
- VGuint *src = (VGuint *)data;
- src += offset;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- r = (*src >> 24) & 0xff;
- g = (*src >> 16) & 0xff;
- b = (*src >> 8) & 0xff;
- a = 0xff;
-
- util_pack_color_ub(r, g, b, a, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
- rgba[i][0] = uc.f[0];
- rgba[i][1] = uc.f[1];
- rgba[i][2] = uc.f[2];
- rgba[i][3] = uc.f[3];
- ++src;
- }
- }
- return;
- case VG_lRGBA_8888: {
- VGint *src = (VGint *)data;
- src += offset;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- r = (*src >> 24) & 0xff;
- g = (*src >> 16) & 0xff;
- b = (*src >> 8) & 0xff;
- a = (*src >> 0) & 0xff;
-
- util_pack_color_ub(r, g, b, a, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
- rgba[i][0] = uc.f[0];
- rgba[i][1] = uc.f[1];
- rgba[i][2] = uc.f[2];
- rgba[i][3] = uc.f[3];
- ++src;
- }
- return;
- }
- break;
- case VG_lRGBA_8888_PRE: {
- VGint *src = (VGint *)data;
- src += offset;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- r = (*src >> 24) & 0xff;
- g = (*src >> 16) & 0xff;
- b = (*src >> 8) & 0xff;
- a = (*src >> 0) & 0xff;
-
- util_pack_color_ub(r, g, b, a, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
- rgba[i][0] = uc.f[0];
- rgba[i][1] = uc.f[1];
- rgba[i][2] = uc.f[2];
- rgba[i][3] = uc.f[3];
- ++src;
- }
- return;
- }
- break;
- case VG_lL_8: {
- VGubyte *src = (VGubyte *)data;
- src += offset;
- for (i = 0; i < n; ++i) {
- util_pack_color_ub(0xff, 0xff, 0xff, *src, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
- rgba[i][0] = uc.f[0];
- rgba[i][1] = uc.f[1];
- rgba[i][2] = uc.f[2];
- rgba[i][3] = uc.f[3];
- ++src;
- }
- }
- return;
- case VG_A_8: {
- VGubyte *src = (VGubyte *)data;
- src += offset;
- for (i = 0; i < n; ++i) {
- util_pack_color_ub(0xff, 0xff, 0xff, *src, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
- rgba[i][0] = uc.f[0];
- rgba[i][1] = uc.f[1];
- rgba[i][2] = uc.f[2];
- rgba[i][3] = uc.f[3];
- ++src;
- }
- }
- return;
- case VG_BW_1: {
- VGubyte *src = (VGubyte *)data;
- src += offset;
- for (i = 0; i < n; i += 8) {
- VGfloat clr[4];
- VGuint j;
- for (j = 0; j < 8 && j < n ; ++j) {
- VGint shift = j;
- clr[0] = (((*src) & (1<<shift)) >> shift);
- clr[1] = clr[0];
- clr[2] = clr[0];
- clr[3] = 1.f;
-
- util_pack_color(clr, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
- rgba[i+j][0] = uc.f[0];
- rgba[i+j][1] = uc.f[1];
- rgba[i+j][2] = uc.f[2];
- rgba[i+j][3] = uc.f[3];
- }
- ++src;
- }
- }
- return;
-#ifdef OPENVG_VERSION_1_1
- case VG_A_1: {
- VGubyte *src = (VGubyte *)data;
- src += offset;
- for (i = 0; i < n; i += 8) {
- VGfloat clr[4];
- VGuint j;
- for (j = 0; j < 8 && j < n ; ++j) {
- VGint shift = j;
- clr[0] = 0.f;
- clr[1] = 0.f;
- clr[2] = 0.f;
- clr[3] = (((*src) & (1<<shift)) >> shift);
-
- util_pack_color(clr, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
- rgba[i+j][0] = uc.f[0];
- rgba[i+j][1] = uc.f[1];
- rgba[i+j][2] = uc.f[2];
- rgba[i+j][3] = uc.f[3];
- }
- ++src;
- }
- }
- return;
- case VG_A_4: {
- VGubyte *src = (VGubyte *)data;
- src += offset/2;
- for (i = 0; i < n; i += 2) {
- VGfloat clr[4];
- VGuint j;
- for (j = 0; j < n && j < 2; ++j) {
- VGint bitter, shift;
- if (j == 0) {
- bitter = 0x0f;
- shift = 0;
- } else {
- bitter = 0xf0;
- shift = 4;
- }
- clr[0] = 0.f;
- clr[1] = 0.f;
- clr[2] = 0.f;
- clr[3] = ((*src) & (bitter)) >> shift;
-
- util_pack_color(clr, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
- rgba[i+j][0] = uc.f[0];
- rgba[i+j][1] = uc.f[1];
- rgba[i+j][2] = uc.f[2];
- rgba[i+j][3] = uc.f[3];
- }
- ++src;
- }
- }
- return;
-#endif
- case VG_sXRGB_8888:
- break;
- case VG_sARGB_8888: {
- VGuint *src = (VGuint *)data;
- src += offset;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- a = (*src >> 24) & 0xff;
- r = (*src >> 16) & 0xff;
- g = (*src >> 8) & 0xff;
- b = (*src >> 0) & 0xff;
-
- util_pack_color_ub(r, g, b, a, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
- rgba[i][0] = uc.f[0];
- rgba[i][1] = uc.f[1];
- rgba[i][2] = uc.f[2];
- rgba[i][3] = uc.f[3];
- ++src;
- }
- return;
- }
- break;
- case VG_sARGB_8888_PRE: {
- VGuint *src = (VGuint *)data;
- src += offset;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- a = (*src >> 24) & 0xff;
- r = (*src >> 16) & 0xff;
- g = (*src >> 8) & 0xff;
- b = (*src >> 0) & 0xff;
-
- util_pack_color_ub(r, g, b, a, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
- rgba[i][0] = uc.f[0];
- rgba[i][1] = uc.f[1];
- rgba[i][2] = uc.f[2];
- rgba[i][3] = uc.f[3];
- ++src;
- }
- return;
- }
- break;
- case VG_sARGB_1555:
- break;
- case VG_sARGB_4444:
- break;
- case VG_lXRGB_8888:
- break;
- case VG_lARGB_8888: {
- VGint *src = (VGint *)data;
- src += offset;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- a = (*src >> 24) & 0xff;
- r = (*src >> 16) & 0xff;
- g = (*src >> 8) & 0xff;
- b = (*src >> 0) & 0xff;
-
- util_pack_color_ub(r, g, b, a, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
- rgba[i][0] = uc.f[0];
- rgba[i][1] = uc.f[1];
- rgba[i][2] = uc.f[2];
- rgba[i][3] = uc.f[3];
- ++src;
- }
- return;
- }
- break;
- case VG_lARGB_8888_PRE: {
- VGint *src = (VGint *)data;
- src += offset;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- a = (*src >> 24) & 0xff;
- r = (*src >> 16) & 0xff;
- g = (*src >> 8) & 0xff;
- b = (*src >> 0) & 0xff;
-
- util_pack_color_ub(r, g, b, a, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
- rgba[i][0] = uc.f[0];
- rgba[i][1] = uc.f[1];
- rgba[i][2] = uc.f[2];
- rgba[i][3] = uc.f[3];
- ++src;
- }
- return;
- }
- break;
- case VG_sBGRX_8888:
- break;
- case VG_sBGRA_8888: {
- VGuint *src = (VGuint *)data;
- src += offset;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- b = (*src >> 24) & 0xff;
- g = (*src >> 16) & 0xff;
- r = (*src >> 8) & 0xff;
- a = (*src >> 0) & 0xff;
-
- util_pack_color_ub(r, g, b, a, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
- rgba[i][0] = uc.f[0];
- rgba[i][1] = uc.f[1];
- rgba[i][2] = uc.f[2];
- rgba[i][3] = uc.f[3];
- ++src;
- }
- return;
- }
- break;
- case VG_sBGRA_8888_PRE: {
- VGuint *src = (VGuint *)data;
- src += offset;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- b = (*src >> 24) & 0xff;
- g = (*src >> 16) & 0xff;
- r = (*src >> 8) & 0xff;
- a = (*src >> 0) & 0xff;
-
- util_pack_color_ub(r, g, b, a, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
- rgba[i][0] = uc.f[0];
- rgba[i][1] = uc.f[1];
- rgba[i][2] = uc.f[2];
- rgba[i][3] = uc.f[3];
- ++src;
- }
- return;
- }
- break;
- case VG_sBGR_565:
- break;
- case VG_sBGRA_5551:
- break;
- case VG_sBGRA_4444:
- break;
- case VG_lBGRX_8888:
- break;
- case VG_lBGRA_8888: {
- VGuint *src = (VGuint *)data;
- src += offset;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- b = (*src >> 24) & 0xff;
- g = (*src >> 16) & 0xff;
- r = (*src >> 8) & 0xff;
- a = (*src >> 0) & 0xff;
-
- util_pack_color_ub(r, g, b, a, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
- rgba[i][0] = uc.f[0];
- rgba[i][1] = uc.f[1];
- rgba[i][2] = uc.f[2];
- rgba[i][3] = uc.f[3];
- ++src;
- }
- return;
- }
- break;
- case VG_lBGRA_8888_PRE: {
- VGuint *src = (VGuint *)data;
- src += offset;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- b = (*src >> 24) & 0xff;
- g = (*src >> 16) & 0xff;
- r = (*src >> 8) & 0xff;
- a = (*src >> 0) & 0xff;
-
- util_pack_color_ub(r, g, b, a, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
- rgba[i][0] = uc.f[0];
- rgba[i][1] = uc.f[1];
- rgba[i][2] = uc.f[2];
- rgba[i][3] = uc.f[3];
- ++src;
- }
- return;
- }
- break;
- case VG_sXBGR_8888:
- break;
- case VG_sABGR_8888: {
- VGuint *src = (VGuint *)data;
- src += offset;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- a = (*src >> 24) & 0xff;
- b = (*src >> 16) & 0xff;
- g = (*src >> 8) & 0xff;
- r = (*src >> 0) & 0xff;
-
- util_pack_color_ub(r, g, b, a, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
- rgba[i][0] = uc.f[0];
- rgba[i][1] = uc.f[1];
- rgba[i][2] = uc.f[2];
- rgba[i][3] = uc.f[3];
- ++src;
- }
- return;
- }
- break;
- case VG_sABGR_8888_PRE: {
- VGuint *src = (VGuint *)data;
- src += offset;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- a = (*src >> 24) & 0xff;
- b = (*src >> 16) & 0xff;
- g = (*src >> 8) & 0xff;
- r = (*src >> 0) & 0xff;
-
- util_pack_color_ub(r, g, b, a, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
- rgba[i][0] = uc.f[0];
- rgba[i][1] = uc.f[1];
- rgba[i][2] = uc.f[2];
- rgba[i][3] = uc.f[3];
- ++src;
- }
- return;
- }
- break;
- case VG_sABGR_1555:
- break;
- case VG_sABGR_4444:
- break;
- case VG_lXBGR_8888:
- break;
- case VG_lABGR_8888: {
- VGuint *src = (VGuint *)data;
- src += offset;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- a = (*src >> 24) & 0xff;
- b = (*src >> 16) & 0xff;
- g = (*src >> 8) & 0xff;
- r = (*src >> 0) & 0xff;
-
- util_pack_color_ub(r, g, b, a, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
- rgba[i][0] = uc.f[0];
- rgba[i][1] = uc.f[1];
- rgba[i][2] = uc.f[2];
- rgba[i][3] = uc.f[3];
- ++src;
- }
- return;
- }
- break;
- case VG_lABGR_8888_PRE: {
- VGuint *src = (VGuint *)data;
- src += offset;
- for (i = 0; i < n; ++i) {
- VGubyte r, g, b ,a;
- a = (*src >> 24) & 0xff;
- b = (*src >> 16) & 0xff;
- g = (*src >> 8) & 0xff;
- r = (*src >> 0) & 0xff;
-
- util_pack_color_ub(r, g, b, a, PIPE_FORMAT_R32G32B32A32_FLOAT, &uc);
- rgba[i][0] = uc.f[0];
- rgba[i][1] = uc.f[1];
- rgba[i][2] = uc.f[2];
- rgba[i][3] = uc.f[3];
- ++src;
- }
- return;
- }
- break;
- default:
- assert(!"Unknown ReadPixels format");
- break;
- }
- assert(!"Not implemented ReadPixels format");
-}
-
-VGint _vega_size_for_format(VGImageFormat dataFormat)
-{
- switch (dataFormat) {
- case VG_sRGBX_8888:
- case VG_sRGBA_8888:
- case VG_sRGBA_8888_PRE:
- return 4;
- case VG_sRGB_565:
- case VG_sRGBA_5551:
- case VG_sRGBA_4444:
- return 2;
- case VG_sL_8:
- return 1;
- case VG_lRGBX_8888:
- case VG_lRGBA_8888:
- case VG_lRGBA_8888_PRE:
- return 4;
- case VG_lL_8:
- return 1;
- case VG_A_8:
- return 1;
- case VG_BW_1:
- return 1;
-#ifdef OPENVG_VERSION_1_1
- case VG_A_1:
- break;
- case VG_A_4:
- break;
-#endif
- case VG_sXRGB_8888:
- case VG_sARGB_8888:
- case VG_sARGB_8888_PRE:
- return 4;
- case VG_sARGB_1555:
- case VG_sARGB_4444:
- return 2;
- case VG_lXRGB_8888:
- case VG_lARGB_8888:
- case VG_lARGB_8888_PRE:
- case VG_sBGRX_8888:
- case VG_sBGRA_8888:
- case VG_sBGRA_8888_PRE:
- return 4;
- case VG_sBGR_565:
- case VG_sBGRA_5551:
- case VG_sBGRA_4444:
- return 2;
- case VG_lBGRX_8888:
- case VG_lBGRA_8888:
- case VG_lBGRA_8888_PRE:
- case VG_sXBGR_8888:
- case VG_sABGR_8888:
- case VG_sABGR_8888_PRE:
- return 4;
- case VG_sABGR_1555:
- case VG_sABGR_4444:
- return 2;
- case VG_lXBGR_8888:
- case VG_lABGR_8888:
- case VG_lABGR_8888_PRE:
- return 4;
- default:
- assert(!"Unknown ReadPixels format");
- break;
- }
- assert(!"Not implemented ReadPixels format");
- return 0;
-}
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#ifndef VG_TRANSLATE_H
-#define VG_TRANSLATE_H
-
-#include "VG/openvg.h"
-#include "vg_context.h"
-
-/*FIXME: we really should be using translate module
- * but pipe_format can't express some of the VG formats
- * (the premultiplied ones) so currently it won't work */
-
-void _vega_pack_rgba_span_float(struct vg_context *ctx,
- VGuint n, VGfloat rgba[][4],
- VGImageFormat dstFormat,
- void *dstAddr);
-void _vega_unpack_float_span_rgba(struct vg_context *ctx,
- VGuint n,
- VGuint offset,
- const void * data,
- VGImageFormat dataFormat,
- VGfloat rgba[][4]);
-VGint _vega_size_for_format(VGImageFormat format);
-
-#endif
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#include "VG/openvg.h"
-#include "VG/vgu.h"
-
-#include "matrix.h"
-#include "path.h"
-#include "handle.h"
-
-#include "util/u_debug.h"
-#include "util/u_pointer.h"
-
-#include <math.h>
-#include <assert.h>
-
-
-static void vgu_append_float_coords(VGPath path,
- const VGubyte *cmds,
- VGint num_cmds,
- const VGfloat *coords,
- VGint num_coords)
-{
- VGubyte common_data[40 * sizeof(VGfloat)];
- struct path *p = handle_to_path(path);
-
- vg_float_to_datatype(path_datatype(p), common_data, coords, num_coords);
- vgAppendPathData(path, num_cmds, cmds, common_data);
-}
-
-VGUErrorCode vguLine(VGPath path,
- VGfloat x0, VGfloat y0,
- VGfloat x1, VGfloat y1)
-{
- static const VGubyte cmds[] = {VG_MOVE_TO_ABS, VG_LINE_TO_ABS};
- VGfloat coords[4];
- VGbitfield caps;
-
- if (path == VG_INVALID_HANDLE) {
- return VGU_BAD_HANDLE_ERROR;
- }
- caps = vgGetPathCapabilities(path);
- if (!(caps & VG_PATH_CAPABILITY_APPEND_TO)) {
- return VGU_PATH_CAPABILITY_ERROR;
- }
-
- coords[0] = x0;
- coords[1] = y0;
- coords[2] = x1;
- coords[3] = y1;
-
- vgu_append_float_coords(path, cmds, 2, coords, 4);
-
- return VGU_NO_ERROR;
-}
-
-VGUErrorCode vguPolygon(VGPath path,
- const VGfloat * points,
- VGint count,
- VGboolean closed)
-{
- VGubyte *cmds;
- VGfloat *coords;
- VGbitfield caps;
- VGint i;
-
- if (path == VG_INVALID_HANDLE) {
- return VGU_BAD_HANDLE_ERROR;
- }
-
- if (!points || count <= 0 || !is_aligned(points)) {
- return VGU_ILLEGAL_ARGUMENT_ERROR;
- }
-
- caps = vgGetPathCapabilities(path);
- if (!(caps & VG_PATH_CAPABILITY_APPEND_TO)) {
- return VGU_PATH_CAPABILITY_ERROR;
- }
-
- cmds = malloc(sizeof(VGubyte) * count + 1);
- coords = malloc(sizeof(VGfloat) * count * 2);
-
- cmds[0] = VG_MOVE_TO_ABS;
- coords[0] = points[0];
- coords[1] = points[1];
- for (i = 1; i < count; ++i) {
- cmds[i] = VG_LINE_TO_ABS;
- coords[2*i + 0] = points[2*i + 0];
- coords[2*i + 1] = points[2*i + 1];
- }
-
- if (closed) {
- cmds[i] = VG_CLOSE_PATH;
- ++i;
- }
-
- vgu_append_float_coords(path, cmds, i, coords, 2*i);
-
- free(cmds);
- free(coords);
-
- return VGU_NO_ERROR;
-}
-
-VGUErrorCode vguRect(VGPath path,
- VGfloat x, VGfloat y,
- VGfloat width, VGfloat height)
-{
- static const VGubyte cmds[] = {VG_MOVE_TO_ABS,
- VG_HLINE_TO_REL,
- VG_VLINE_TO_REL,
- VG_HLINE_TO_REL,
- VG_CLOSE_PATH
- };
- VGfloat coords[5];
- VGbitfield caps;
-
- if (path == VG_INVALID_HANDLE) {
- return VGU_BAD_HANDLE_ERROR;
- }
- caps = vgGetPathCapabilities(path);
- if (!(caps & VG_PATH_CAPABILITY_APPEND_TO)) {
- return VGU_PATH_CAPABILITY_ERROR;
- }
- if (width <= 0 || height <= 0) {
- return VGU_ILLEGAL_ARGUMENT_ERROR;
- }
-
- coords[0] = x;
- coords[1] = y;
- coords[2] = width;
- coords[3] = height;
- coords[4] = -width;
-
- vgu_append_float_coords(path, cmds, 5, coords, 5);
-
- return VGU_NO_ERROR;
-}
-
-VGUErrorCode vguRoundRect(VGPath path,
- VGfloat x, VGfloat y,
- VGfloat width,
- VGfloat height,
- VGfloat arcWidth,
- VGfloat arcHeight)
-{
- static const VGubyte cmds[] = {VG_MOVE_TO_ABS,
- VG_HLINE_TO_REL,
- VG_SCCWARC_TO_REL,
- VG_VLINE_TO_REL,
- VG_SCCWARC_TO_REL,
- VG_HLINE_TO_REL,
- VG_SCCWARC_TO_REL,
- VG_VLINE_TO_REL,
- VG_SCCWARC_TO_REL,
- VG_CLOSE_PATH
- };
- VGfloat c[26];
- VGbitfield caps;
-
- if (path == VG_INVALID_HANDLE) {
- return VGU_BAD_HANDLE_ERROR;
- }
- caps = vgGetPathCapabilities(path);
- if (!(caps & VG_PATH_CAPABILITY_APPEND_TO)) {
- return VGU_PATH_CAPABILITY_ERROR;
- }
- if (width <= 0 || height <= 0) {
- return VGU_ILLEGAL_ARGUMENT_ERROR;
- }
-
- c[0] = x + arcWidth/2; c[1] = y;
-
- c[2] = width - arcWidth;
-
- c[3] = arcWidth/2; c[4] = arcHeight/2; c[5] = 0;
- c[6] = arcWidth/2; c[7] = arcHeight/2;
-
- c[8] = height - arcHeight;
-
- c[9] = arcWidth/2; c[10] = arcHeight/2; c[11] = 0;
- c[12] = -arcWidth/2; c[13] = arcHeight/2;
-
- c[14] = -(width - arcWidth);
-
- c[15] = arcWidth/2; c[16] = arcHeight/2; c[17] = 0;
- c[18] = -arcWidth/2; c[19] = -arcHeight/2;
-
- c[20] = -(height - arcHeight);
-
- c[21] = arcWidth/2; c[22] = arcHeight/2; c[23] = 0;
- c[24] = arcWidth/2; c[25] = -arcHeight/2;
-
- vgu_append_float_coords(path, cmds, 10, c, 26);
-
- return VGU_NO_ERROR;
-}
-
-VGUErrorCode vguEllipse(VGPath path,
- VGfloat cx, VGfloat cy,
- VGfloat width,
- VGfloat height)
-{
- static const VGubyte cmds[] = {VG_MOVE_TO_ABS,
- VG_SCCWARC_TO_REL,
- VG_SCCWARC_TO_REL,
- VG_CLOSE_PATH
- };
- VGfloat coords[12];
- VGbitfield caps;
-
- if (path == VG_INVALID_HANDLE) {
- return VGU_BAD_HANDLE_ERROR;
- }
- caps = vgGetPathCapabilities(path);
- if (!(caps & VG_PATH_CAPABILITY_APPEND_TO)) {
- return VGU_PATH_CAPABILITY_ERROR;
- }
- if (width <= 0 || height <= 0) {
- return VGU_ILLEGAL_ARGUMENT_ERROR;
- }
-
- coords[0] = cx + width/2; coords[1] = cy;
-
- coords[2] = width/2; coords[3] = height/2; coords[4] = 0;
- coords[5] = -width; coords[6] = 0;
-
- coords[7] = width/2; coords[8] = height/2; coords[9] = 0;
- coords[10] = width; coords[11] = 0;
-
- vgu_append_float_coords(path, cmds, 4, coords, 11);
-
- return VGU_NO_ERROR;
-}
-
-VGUErrorCode vguArc(VGPath path,
- VGfloat x, VGfloat y,
- VGfloat width, VGfloat height,
- VGfloat startAngle,
- VGfloat angleExtent,
- VGUArcType arcType)
-{
- VGubyte cmds[11];
- VGfloat coords[40];
- VGbitfield caps;
- VGfloat last = startAngle + angleExtent;
- VGint i, c = 0;
-
- if (path == VG_INVALID_HANDLE) {
- return VGU_BAD_HANDLE_ERROR;
- }
- caps = vgGetPathCapabilities(path);
- if (!(caps & VG_PATH_CAPABILITY_APPEND_TO)) {
- return VGU_PATH_CAPABILITY_ERROR;
- }
- if (width <= 0 || height <= 0) {
- return VGU_ILLEGAL_ARGUMENT_ERROR;
- }
- if (arcType != VGU_ARC_OPEN &&
- arcType != VGU_ARC_CHORD &&
- arcType != VGU_ARC_PIE) {
- return VGU_ILLEGAL_ARGUMENT_ERROR;
- }
-
- cmds[c] = VG_MOVE_TO_ABS; ++c;
- coords[0] = x+cos(DEGREES_TO_RADIANS(startAngle))*width/2;
- coords[1] = y+sin(DEGREES_TO_RADIANS(startAngle))*height/2;
-#ifdef DEBUG_VGUARC
- debug_printf("start [%f, %f]\n", coords[0], coords[1]);
-#endif
- i = 2;
- if (angleExtent > 0) {
- VGfloat angle = startAngle + 180;
- while (angle < last) {
- cmds[c] = VG_SCCWARC_TO_ABS; ++c;
- coords[i] = width/2; coords[i+1] = height/2; coords[i+2] = 0;
- coords[i+3] = x + cos(DEGREES_TO_RADIANS(angle))*width/2;
- coords[i+4] = y + sin(DEGREES_TO_RADIANS(angle))*height/2;
-#ifdef DEBUG_VGUARC
- debug_printf("1 [%f, %f]\n", coords[i+3],
- coords[i+4]);
-#endif
- i += 5;
- angle += 180;
- }
- cmds[c] = VG_SCCWARC_TO_ABS; ++c;
- coords[i] = width/2; coords[i+1] = height/2; coords[i+2] = 0;
- coords[i+3] = x+cos(DEGREES_TO_RADIANS(last))*width/2;
- coords[i+4] = y+sin(DEGREES_TO_RADIANS(last))*height/2;
-#ifdef DEBUG_VGUARC
- debug_printf("2 [%f, %f]\n", coords[i+3],
- coords[i+4]);
-#endif
- i += 5;
- } else {
- VGfloat angle = startAngle - 180;
- while (angle > last) {
- cmds[c] = VG_SCWARC_TO_ABS; ++c;
- coords[i] = width/2; coords[i+1] = height/2; coords[i+2] = 0;
- coords[i+3] = x + cos(DEGREES_TO_RADIANS(angle)) * width/2;
- coords[i+4] = y + sin(DEGREES_TO_RADIANS(angle)) * height/2;
-#ifdef DEBUG_VGUARC
- debug_printf("3 [%f, %f]\n", coords[i+3],
- coords[i+4]);
-#endif
- angle -= 180;
- i += 5;
- }
- cmds[c] = VG_SCWARC_TO_ABS; ++c;
- coords[i] = width/2; coords[i+1] = height/2; coords[i+2] = 0;
- coords[i+3] = x + cos(DEGREES_TO_RADIANS(last)) * width/2;
- coords[i+4] = y + sin(DEGREES_TO_RADIANS(last)) * height/2;
-#ifdef DEBUG_VGUARC
- debug_printf("4 [%f, %f]\n", coords[i+3],
- coords[i+4]);
-#endif
- i += 5;
- }
-
- if (arcType == VGU_ARC_PIE) {
- cmds[c] = VG_LINE_TO_ABS; ++c;
- coords[i] = x; coords[i + 1] = y;
- i += 2;
- }
- if (arcType == VGU_ARC_PIE || arcType == VGU_ARC_CHORD) {
- cmds[c] = VG_CLOSE_PATH;
- ++c;
- }
-
- assert(c < 11);
-
- vgu_append_float_coords(path, cmds, c, coords, i);
-
- return VGU_NO_ERROR;
-}
-
-VGUErrorCode vguComputeWarpQuadToSquare(VGfloat sx0, VGfloat sy0,
- VGfloat sx1, VGfloat sy1,
- VGfloat sx2, VGfloat sy2,
- VGfloat sx3, VGfloat sy3,
- VGfloat * matrix)
-{
- struct matrix mat;
-
- if (!matrix || !is_aligned(matrix))
- return VGU_ILLEGAL_ARGUMENT_ERROR;
-
- if (!matrix_quad_to_square(sx0, sy0,
- sx1, sy1,
- sx2, sy2,
- sx3, sy3,
- &mat))
- return VGU_BAD_WARP_ERROR;
-
- if (!matrix_is_invertible(&mat))
- return VGU_BAD_WARP_ERROR;
-
- memcpy(matrix, mat.m, sizeof(VGfloat) * 9);
-
- return VGU_NO_ERROR;
-}
-
-VGUErrorCode vguComputeWarpSquareToQuad(VGfloat dx0, VGfloat dy0,
- VGfloat dx1, VGfloat dy1,
- VGfloat dx2, VGfloat dy2,
- VGfloat dx3, VGfloat dy3,
- VGfloat * matrix)
-{
- struct matrix mat;
-
- if (!matrix || !is_aligned(matrix))
- return VGU_ILLEGAL_ARGUMENT_ERROR;
-
- if (!matrix_square_to_quad(dx0, dy0,
- dx1, dy1,
- dx2, dy2,
- dx3, dy3,
- &mat))
- return VGU_BAD_WARP_ERROR;
-
- if (!matrix_is_invertible(&mat))
- return VGU_BAD_WARP_ERROR;
-
- memcpy(matrix, mat.m, sizeof(VGfloat) * 9);
-
- return VGU_NO_ERROR;
-}
-
-VGUErrorCode vguComputeWarpQuadToQuad(VGfloat dx0, VGfloat dy0,
- VGfloat dx1, VGfloat dy1,
- VGfloat dx2, VGfloat dy2,
- VGfloat dx3, VGfloat dy3,
- VGfloat sx0, VGfloat sy0,
- VGfloat sx1, VGfloat sy1,
- VGfloat sx2, VGfloat sy2,
- VGfloat sx3, VGfloat sy3,
- VGfloat * matrix)
-{
- struct matrix mat;
-
- if (!matrix || !is_aligned(matrix))
- return VGU_ILLEGAL_ARGUMENT_ERROR;
-
- if (!matrix_quad_to_quad(dx0, dy0,
- dx1, dy1,
- dx2, dy2,
- dx3, dy3,
- sx0, sy0,
- sx1, sy1,
- sx2, sy2,
- sx3, sy3,
- &mat))
- return VGU_BAD_WARP_ERROR;
-
- memcpy(matrix, mat.m, sizeof(VGfloat) * 9);
-
- return VGU_NO_ERROR;
-}
es2api/glapi_mapi_tmp.h: glapi/gen/gl_and_es_API.xml $(glapi_gen_mapi_deps)
$(call glapi_gen_mapi,$<,es2api)
-# XXX: Inline vgapi's Makefile.am here.
-EXTRA_DIST += vgapi
-# if HAVE_OPENVG
-# SUBDIRS += vgapi
-# endif
-
include $(top_srcdir)/install-lib-links.mk
return header
-class VGAPIPrinter(ABIPrinter):
- """OpenVG API Printer"""
-
- def __init__(self, entries):
- super(VGAPIPrinter, self).__init__(entries)
-
- self.api_defines = ['VG_VGEXT_PROTOTYPES']
- self.api_headers = ['"VG/openvg.h"', '"VG/vgext.h"']
- self.api_call = 'VG_API_CALL'
- self.api_entry = 'VG_API_ENTRY'
- self.api_attrs = 'VG_API_EXIT'
-
- self.prefix_lib = 'vg'
- self.prefix_app = 'vega'
- self.prefix_noop = 'noop'
- self.prefix_warn = 'vg'
-
def parse_args():
- printers = ['vgapi', 'glapi', 'es1api', 'es2api', 'shared-glapi']
+ printers = ['glapi', 'es1api', 'es2api', 'shared-glapi']
modes = ['lib', 'app']
parser = OptionParser(usage='usage: %prog [options] <filename>')
def main():
printers = {
- 'vgapi': VGAPIPrinter,
'glapi': GLAPIPrinter,
'es1api': ES1APIPrinter,
'es2api': ES2APIPrinter,
+++ /dev/null
-vgapi_tmp.h
+++ /dev/null
-# Copyright © 2012 Intel Corporation
-#
-# Permission is hereby granted, free of charge, to any person obtaining a
-# copy of this software and associated documentation files (the "Software"),
-# to deal in the Software without restriction, including without limitation
-# the rights to use, copy, modify, merge, publish, distribute, sublicense,
-# and/or sell copies of the Software, and to permit persons to whom the
-# Software is furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice (including the next
-# paragraph) shall be included in all copies or substantial portions of the
-# Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-# IN THE SOFTWARE.
-
-AM_CPPFLAGS = \
- $(DEFINES) \
- $(SELINUX_CFLAGS) \
- -I$(top_srcdir)/include \
- -I$(top_srcdir)/src/mapi \
- -DMAPI_ABI_HEADER=\"vgapi_tmp.h\"
-
-AM_CFLAGS = $(VISIBILITY_CFLAGS)
-
-pkgconfigdir = $(libdir)/pkgconfig
-pkgconfig_DATA = vg.pc
-
-VG_includedir = $(includedir)/VG
-VG_include_HEADERS = \
- $(top_srcdir)/include/VG/openvg.h \
- $(top_srcdir)/include/VG/vgext.h \
- $(top_srcdir)/include/VG/vgplatform.h \
- $(top_srcdir)/include/VG/vgu.h
-
-lib_LTLIBRARIES = libOpenVG.la
-
-TOP=$(top_srcdir)
-include ../Makefile.sources
-libOpenVG_la_SOURCES = $(MAPI_FILES) vgapi_tmp.h
-libOpenVG_la_LIBADD = $(VG_LIB_DEPS)
-libOpenVG_la_LDFLAGS = \
- -no-undefined \
- -version-number 1 \
- $(GC_SECTIONS) \
- $(LD_NO_UNDEFINED)
-
-vgapi_tmp.h: $(srcdir)/vgapi.csv $(top_srcdir)/src/mapi/mapi_abi.py
- $(AM_V_GEN) $(PYTHON2) $(PYTHON_FLAGS) $(top_srcdir)/src/mapi/mapi_abi.py \
- --printer vgapi --mode lib $< > $@
-
-EXTRA_DIST = SConscript vgapi.csv
-BUILT_SOURCES = vgapi_tmp.h
-CLEANFILES = $(BUILT_SOURCES)
-
-include $(top_srcdir)/install-lib-links.mk
+++ /dev/null
-#######################################################################
-# SConscript for vgapi
-
-from sys import executable as python_cmd
-
-Import('*')
-
-env = env.Clone()
-
-vgapi_header, = env.CodeGenerate(
- target = 'vgapi_tmp.h',
- script = '../mapi_abi.py',
- source = 'vgapi.csv',
- command = python_cmd + ' $SCRIPT --printer vgapi --mode lib $SOURCE > $TARGET'
-)
-
-env.Append(CPPDEFINES = [
- 'MAPI_ABI_HEADER=\\"vgapi/vgapi_tmp.h\\"',
- 'MAPI_DLL_EXPORTS',
- 'KHRONOS_DLL_EXPORTS',
-])
-
-env.Append(CPPPATH = [
- '#/include',
- '#/src/mapi',
- Dir('..'), # vgapi/vgapi_tmp.h build path
-])
-
-mapi_sources = [
- 'entry.c',
- 'mapi.c',
- 'stub.c',
- 'table.c',
- 'u_current.c',
- 'u_execmem.c',
-]
-
-vgapi_objects = []
-for s in mapi_sources:
- o = env.SharedObject(s[:-2], '../' + s)
- vgapi_objects.append(o)
-
-env.Depends(vgapi_objects, vgapi_header)
-
-# libOpenVG.dll
-env['LIBPREFIX'] = 'lib'
-env['SHLIBPREFIX'] = 'lib'
-
-openvg = env.SharedLibrary(
- target = 'OpenVG',
- source = vgapi_objects,
-)
-
-env.InstallSharedLibrary(openvg, version=(1, 0, 0))
-
-if env['platform'] == 'windows':
- openvg = env.FindIxes(openvg, 'LIBPREFIX', 'LIBSUFFIX')
-else:
- openvg = env.FindIxes(openvg, 'SHLIBPREFIX', 'SHLIBSUFFIX')
-
-Export(['openvg'])
+++ /dev/null
-prefix=@prefix@
-exec_prefix=${prefix}
-libdir=@libdir@
-includedir=@includedir@
-
-Name: vg
-Description: Mesa OpenVG 1.0 library
-Requires.private:
-Version: @VERSION@
-Libs: -L${libdir} -lOpenVG
-Libs.private: @VG_PC_LIB_PRIV@
-Cflags: -I${includedir}
+++ /dev/null
-# This is the source file for the various generate structs/tables/functions
-# used in st/vega.
-
-# OpenVG 1.0
-void, AppendPath, VGPath dstPath, VGPath srcPath
-void, AppendPathData, VGPath dstPath, VGint numSegments, const VGubyte *pathSegments, const void *pathData
-VGImage, ChildImage, VGImage parent, VGint x, VGint y, VGint width, VGint height
-void, Clear, VGint x, VGint y, VGint width, VGint height
-void, ClearImage, VGImage image, VGint x, VGint y, VGint width, VGint height
-void, ClearPath, VGPath path, VGbitfield capabilities
-void, ColorMatrix, VGImage dst, VGImage src, const VGfloat *matrix
-void, Convolve, VGImage dst, VGImage src, VGint kernelWidth, VGint kernelHeight, VGint shiftX, VGint shiftY, const VGshort *kernel, VGfloat scale, VGfloat bias, VGTilingMode tilingMode
-void, CopyImage, VGImage dst, VGint dx, VGint dy, VGImage src, VGint sx, VGint sy, VGint width, VGint height, VGboolean dither
-void, CopyPixels, VGint dx, VGint dy, VGint sx, VGint sy, VGint width, VGint height
-VGImage, CreateImage, VGImageFormat format, VGint width, VGint height, VGbitfield allowedQuality
-VGPaint, CreatePaint, void
-VGPath, CreatePath, VGint pathFormat, VGPathDatatype datatype, VGfloat scale, VGfloat bias, VGint segmentCapacityHint, VGint coordCapacityHint, VGbitfield capabilities
-void, DestroyImage, VGImage image
-void, DestroyPaint, VGPaint paint
-void, DestroyPath, VGPath path
-void, DrawImage, VGImage image
-void, DrawPath, VGPath path, VGbitfield paintModes
-void, Finish, void
-void, Flush, void
-void, GaussianBlur, VGImage dst, VGImage src, VGfloat stdDeviationX, VGfloat stdDeviationY, VGTilingMode tilingMode
-VGuint, GetColor, VGPaint paint
-VGErrorCode, GetError, void
-void, GetImageSubData, VGImage image, void *data, VGint dataStride, VGImageFormat dataFormat, VGint x, VGint y, VGint width, VGint height
-void, GetMatrix, VGfloat *m
-VGPaint, GetPaint, VGPaintMode paintMode
-VGint, GetParameterVectorSize, VGHandle object, VGint paramType
-VGfloat, GetParameterf, VGHandle object, VGint paramType
-void, GetParameterfv, VGHandle object, VGint paramType, VGint count, VGfloat *values
-VGint, GetParameteri, VGHandle object, VGint paramType
-void, GetParameteriv, VGHandle object, VGint paramType, VGint count, VGint *values
-VGImage, GetParent, VGImage image
-VGbitfield, GetPathCapabilities, VGPath path
-void, GetPixels, VGImage dst, VGint dx, VGint dy, VGint sx, VGint sy, VGint width, VGint height
-const VGubyte *, GetString, VGStringID name
-VGint, GetVectorSize, VGParamType type
-VGfloat, Getf, VGParamType type
-void, Getfv, VGParamType type, VGint count, VGfloat *values
-VGint, Geti, VGParamType type
-void, Getiv, VGParamType type, VGint count, VGint *values
-VGHardwareQueryResult, HardwareQuery, VGHardwareQueryType key, VGint setting
-void, ImageSubData, VGImage image, const void *data, VGint dataStride, VGImageFormat dataFormat, VGint x, VGint y, VGint width, VGint height
-VGboolean, InterpolatePath, VGPath dstPath, VGPath startPath, VGPath endPath, VGfloat amount
-void, LoadIdentity, void
-void, LoadMatrix, const VGfloat *m
-void, Lookup, VGImage dst, VGImage src, const VGubyte *redLUT, const VGubyte *greenLUT, const VGubyte *blueLUT, const VGubyte *alphaLUT, VGboolean outputLinear, VGboolean outputPremultiplied
-void, LookupSingle, VGImage dst, VGImage src, const VGuint *lookupTable, VGImageChannel sourceChannel, VGboolean outputLinear, VGboolean outputPremultiplied
-void, Mask, VGHandle mask, VGMaskOperation operation, VGint x, VGint y, VGint width, VGint height
-void, ModifyPathCoords, VGPath dstPath, VGint startIndex, VGint numSegments, const void *pathData
-void, MultMatrix, const VGfloat *m
-void, PaintPattern, VGPaint paint, VGImage pattern
-void, PathBounds, VGPath path, VGfloat *minX, VGfloat *minY, VGfloat *width, VGfloat *height
-VGfloat, PathLength, VGPath path, VGint startSegment, VGint numSegments
-void, PathTransformedBounds, VGPath path, VGfloat *minX, VGfloat *minY, VGfloat *width, VGfloat *height
-void, PointAlongPath, VGPath path, VGint startSegment, VGint numSegments, VGfloat distance, VGfloat *x, VGfloat *y, VGfloat *tangentX, VGfloat *tangentY
-void, ReadPixels, void *data, VGint dataStride, VGImageFormat dataFormat, VGint sx, VGint sy, VGint width, VGint height
-void, RemovePathCapabilities, VGPath path, VGbitfield capabilities
-void, Rotate, VGfloat angle
-void, Scale, VGfloat sx, VGfloat sy
-void, SeparableConvolve, VGImage dst, VGImage src, VGint kernelWidth, VGint kernelHeight, VGint shiftX, VGint shiftY, const VGshort *kernelX, const VGshort *kernelY, VGfloat scale, VGfloat bias, VGTilingMode tilingMode
-void, SetColor, VGPaint paint, VGuint rgba
-void, SetPaint, VGPaint paint, VGbitfield paintModes
-void, SetParameterf, VGHandle object, VGint paramType, VGfloat value
-void, SetParameterfv, VGHandle object, VGint paramType, VGint count, const VGfloat *values
-void, SetParameteri, VGHandle object, VGint paramType, VGint value
-void, SetParameteriv, VGHandle object, VGint paramType, VGint count, const VGint *values
-void, SetPixels, VGint dx, VGint dy, VGImage src, VGint sx, VGint sy, VGint width, VGint height
-void, Setf, VGParamType type, VGfloat value
-void, Setfv, VGParamType type, VGint count, const VGfloat *values
-void, Seti, VGParamType type, VGint value
-void, Setiv, VGParamType type, VGint count, const VGint *values
-void, Shear, VGfloat shx, VGfloat shy
-void, TransformPath, VGPath dstPath, VGPath srcPath
-void, Translate, VGfloat tx, VGfloat ty
-void, WritePixels, const void *data, VGint dataStride, VGImageFormat dataFormat, VGint dx, VGint dy, VGint width, VGint height
-
-## OpenVG 1.1
-void, ClearGlyph, VGFont font, VGuint glyphIndex
-void, CopyMask, VGMaskLayer maskLayer, VGint dx, VGint dy, VGint sx, VGint sy, VGint width, VGint height
-VGFont, CreateFont, VGint glyphCapacityHint
-VGMaskLayer, CreateMaskLayer, VGint width, VGint height
-void, DestroyFont, VGFont font
-void, DestroyMaskLayer, VGMaskLayer maskLayer
-void, DrawGlyph, VGFont font, VGuint glyphIndex, VGbitfield paintModes, VGboolean allowAutoHinting
-void, DrawGlyphs, VGFont font, VGint glyphCount, const VGuint *glyphIndices, const VGfloat *adjustments_x, const VGfloat *adjustments_y, VGbitfield paintModes, VGboolean allowAutoHinting
-void, FillMaskLayer, VGMaskLayer maskLayer, VGint x, VGint y, VGint width, VGint height, VGfloat value
-void, RenderToMask, VGPath path, VGbitfield paintModes, VGMaskOperation operation
-void, SetGlyphToImage, VGFont font, VGuint glyphIndex, VGImage image, const VGfloat glyphOrigin[2], const VGfloat escapement[2]
-void, SetGlyphToPath, VGFont font, VGuint glyphIndex, VGPath path, VGboolean isHinted, const VGfloat glyphOrigin[2], const VGfloat escapement[2]
projects / mesa.git / commitdiff