--- a/guestrendering/guestopenvg/src/openvg.cpp Thu Sep 16 12:43:44 2010 +0100
+++ b/guestrendering/guestopenvg/src/openvg.cpp Mon Sep 20 14:29:05 2010 +0100
@@ -1,2260 +1,2260 @@
-// Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
-// All rights reserved.
-// This component and the accompanying materials are made available
-// under the terms of "Eclipse Public License v1.0"
-// which accompanies this distribution, and is available
-// at the URL "http://www.eclipse.org/legal/epl-v10.html".
-//
-// Initial Contributors:
-// Nokia Corporation - initial contribution.
-//
-// Contributors:
-//
-// Description:
-// OpenVG C API for Symbian DLL
-
-
-#include "vgstate.h"
-
-
-
-extern "C" {
-
-/*
- Note: Comments at the start of each Open VG api are adapted from the Open VG 1.1 specification.
- The text has been chosen/adapted to give a helpful overview of the function, and the errors
- (other than VG_NO_CONTEXT_ERROR) that it may generate. For more details and diagrams see the
- full Open VG specification.
- */
-
-/*
- The vgGetParameter functions return the value of a parameter on a given VGHandlebased
- object.
-
- The original value passed to vgSetParameter (provided the call to
- vgSetParameter completed without error) should be returned by
- vgGetParameter (except where specifically noted), even if the implementation
- makes use of a truncated or quantized value internally.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if object is not a valid handle, or is not shared with the current context
- VG_ILLEGAL_ARGUMENT_ERROR
- if paramType is not a valid value from the appropriate enumeration
- if paramType refers to a vector parameter in vgGetParameterf or
- vgGetParameteri
- */
-EXPORT_C VGint
- vgGetParameteri(VGHandle object,
- VGint paramType)
- {
- OPENVG_TRACE("vgGetParameteri object=0x%x, paramType=0x%x -->", object, paramType);
-
- VGint value = TGuestOpenVg::vgGetParameteri(object, paramType);
- OPENVG_TRACE("vgGetParameteri value=0x%x <--", value);
- return value;
- }
-
-
-////////////////////////////////////////////////////////////////////////////////////////////
-//Functions returning value
-////////////////////////////////////////////////////////////////////////////////////////////
-/*
- 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). No
- error is indicated by a return value of 0 (VG_NO_ERROR). After the call, the error code is
- cleared to 0. The possible errors that may be generated by each OpenVG function (apart from
- VG_OUT_OF_MEMORY_ERROR) are shown below the definition of the function.
- If no context is current at the time vgGetError is called, the error code
- VG_NO_CONTEXT_ERROR is returned. Pending error codes on existing contexts are not affected
- by the call.
- */
-EXPORT_C VGErrorCode
- vgGetError(void)
- {
- OPENVG_TRACE("vgGetError");
-
- MVgContext* vgContext = CVghwUtils::VgContext();
- VGErrorCode error = VG_NO_CONTEXT_ERROR;
- if (vgContext)
- { // thread state already exists - get client or Host VG error
- error = vgContext->VgError();
- }
- return error;
- }
-
-/*
- Returns the paint object currently set for the given paintMode, or VG_INVALID_HANDLE
- if an error occurs or if no paint object is set (i.e., the default paint is present) on
- the given context with the given paintMode.
-
- ERRORS
- VG_ILLEGAL_ARGUMENT_ERROR
- if paintMode is not a valid value from the VGPaintMode enumeration
- */
-EXPORT_C VGPaint
- vgGetPaint(VGPaintMode paintMode)
- {
- OPENVG_TRACE("vgGetPaint paintMode=0x%x -->", paintMode);
-
- VGPaint paintHandle = TGuestOpenVg::vgGetPaint(paintMode);
- OPENVG_TRACE("vgGetPaint handle=0x%x <--", paintHandle);
- return paintHandle;
- }
-
-/*
- Creates a new paint object that is initialized to a set of default values and returns
- a VGPaint handle to it. If insufficient memory is available to allocate a new object,
- VG_INVALID_HANDLE is returned.
- */
-EXPORT_C VGPaint
- vgCreatePaint(void)
- {
- OPENVG_TRACE("vgCreatePaint -->");
-
- VGPaint paintHandle = TGuestOpenVg::vgCreatePaint();
- OPENVG_TRACE("vgCreatePaint handle=0x%x <--", paintHandle);
- return paintHandle;
- }
-
-/*
- Appends a path, defined by interpolation (or extrapolation) between the paths
- startPath and endPath by the given amount, to the path dstPath. It returns
- VG_TRUE if interpolation was successful (i.e., the paths had compatible segment
- types after normalization), and VG_FALSE otherwise. If interpolation is
- unsuccessful, dstPath is left unchanged. It is legal for dstPath to be a handle
- to the same path object as either startPath or endPath or both, in which case
- the contents of the source path or paths referenced by dstPath will have the
- interpolated path appended. If dstPath is not the a handle to the same path
- object as either startPath or endPath, the contents of startPath and endPath
- will not be affected by the call.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if any of dstPath, startPath, or endPath is not a valid path handle, or is
- not shared with the current context
- VG_PATH_CAPABILITY_ERROR
- if VG_PATH_CAPABILITY_INTERPOLATE_TO is not enabled for dstPath
- if VG_PATH_CAPABILITY_INTERPOLATE_FROM is not enabled for startPath or endPath
- */
-EXPORT_C VGboolean
- vgInterpolatePath(VGPath dstPath,
- VGPath startPath,
- VGPath endPath,
- VGfloat amount)
- {
- OPENVG_TRACE("vgInterpolatePath dstPath=0x%x, startPath=0x%x, endPath=0x%x, amount=%f",
- dstPath, startPath, endPath, amount);
-
- return TGuestOpenVg::vgInterpolatePath(dstPath, startPath, endPath, amount);
- }
-
-/*
- Returns the length of a given portion of a path in the user coordinate system
- (that is, in the paths own coordinate system, disregarding any matrix
- settings). Only the subpath consisting of the numSegments path segments beginning
- with startSegment (where the initial path segment has index 0) is used. If an
- error occurs, -1.0f is returned.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if path is not a valid path handle, or is not shared with the current context
- VG_PATH_CAPABILITY_ERROR
- if VG_PATH_CAPABILITY_PATH_LENGTH is not enabled for path
- VG_ILLEGAL_ARGUMENT_ERROR
- if startSegment is less than 0 or greater than the index of the final path
- segment
- if numSegments is less than or equal to 0
- if (startSegment + numSegments 1) is greater than the index of the final
- path segment
- */
-EXPORT_C VGfloat
- vgPathLength(VGPath path,
- VGint startSegment,
- VGint numSegments)
- {
- OPENVG_TRACE("vgPathLength path=0x%x, startSegment=%d, numSegments=%d", path, startSegment, numSegments);
-
- return TGuestOpenVg::vgPathLength(path, startSegment, numSegments);
- }
-
-/*
- Returns the current capabilities of the path, as a bitwise OR of
- VGPathCapabilities constants. If an error occurs, 0 is returned.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if path is not a valid path handle, or is not shared with the current context
- */
-EXPORT_C VGbitfield
- vgGetPathCapabilities(VGPath path)
- {
- OPENVG_TRACE("vgGetPathCapabilities path=0x%x", path);
-
- return TGuestOpenVg::vgGetPathCapabilities(path);
- }
-
-/*
- Create a new path that is ready to accept segment data and return a VGPath handle
- to it. The path data will be formatted in the format given by pathFormat, typically
- VG_PATH_FORMAT_STANDARD. The datatype parameter contains a value from the
- VGPathDatatype enumeration indicating the datatype that will be used for coordinate
- data. The capabilities argument is a bitwise OR of the desired VGPathCapabilities
- values. Bits of capabilities that do not correspond to values from VGPathCapabilities
- have no effect.
-
- If an error occurs, VG_INVALID_HANDLE is returned.
-
- ERRORS
- VG_UNSUPPORTED_PATH_FORMAT_ERROR
- if pathFormat is not a supported format
- VG_ILLEGAL_ARGUMENT_ERROR
- if datatype is not a valid value from the VGPathDatatype enumeration
- if scale is equal to 0
- */
-EXPORT_C VGPath
- vgCreatePath(VGint pathFormat,
- VGPathDatatype datatype,
- VGfloat scale, VGfloat bias,
- VGint segmentCapacityHint,
- VGint coordCapacityHint,
- VGbitfield capabilities)
- {
- OPENVG_TRACE("vgCreatePath pathFormat=%d, datatype=0x%x, scale=%f, bias=%f, segCapHint=%d, coordCapHint=%d, caps=0x%x -->",
- pathFormat, datatype, scale, bias, segmentCapacityHint, coordCapacityHint, capabilities);
-
- VGPath pathHandle = TGuestOpenVg::vgCreatePath(pathFormat, datatype, scale, bias, segmentCapacityHint, coordCapacityHint, capabilities);
- OPENVG_TRACE("vgCreatePath handle=0x%x <--", pathHandle);
- return pathHandle;
- }
-
-/*
- The vgGet functions return the value of a parameter on the current context.
- The original value passed to vgSet (except as specifically noted, and provided the call to
- vgSet completed without error) is returned by vgGet, even if the implementation makes
- use of a truncated or quantized value internally. This rule ensures that OpenVG state may
- be saved and restored without degradation.
-
- If an error occurs during a call to vgGetf, vgGeti, or vgGetVectorSize, the return value
- is undefined.
-
- ERRORS
- VG_ILLEGAL_ARGUMENT_ERROR
- if paramType is not a valid value from the VGParamType enumeration
- if paramType refers to a vector parameter in vgGetf or vgGeti
- */
-EXPORT_C VGfloat
- vgGetf(VGParamType type)
- {
- OPENVG_TRACE("vgGetf type=0x%x", type);
-
- return TGuestOpenVg::vgGetf(type);
- }
-
-/*
- The vgGet functions return the value of a parameter on the current context.
- The original value passed to vgSet (except as specifically noted, and provided the call to
- vgSet completed without error) is returned by vgGet, even if the implementation makes
- use of a truncated or quantized value internally. This rule ensures that OpenVG state may
- be saved and restored without degradation.
-
- If an error occurs during a call to vgGetf, vgGeti, or vgGetVectorSize, the return value
- is undefined.
-
- ERRORS
- VG_ILLEGAL_ARGUMENT_ERROR
- if paramType is not a valid value from the VGParamType enumeration
- if paramType refers to a vector parameter in vgGetf or vgGeti
- */
-EXPORT_C VGint
- vgGeti(VGParamType type)
- {
- OPENVG_TRACE("vgGeti type=0x%x", type);
-
- return TGuestOpenVg::vgGeti(type);
- }
-
-/*
- The vgGetVectorSize function returns the maximum number of elements in the vector
- that will be retrieved by the vgGetiv or vgGetfv functions if called with the given
- paramType argument. For scalar values, 1 is returned. If vgGetiv or vgGetfv is
- called with a smaller value for count than that returned by vgGetVectorSize,
- only the first count elements of the vector are retrieved. Use of a greater value
- for count will result in an error.
- The original value passed to vgSet (except as specifically noted, and provided the call to
- vgSet completed without error) is returned by vgGet, even if the implementation makes
- use of a truncated or quantized value internally. This rule ensures that OpenVG state may
- be saved and restored without degradation.
- If an error occurs during a call to vgGetf, vgGeti, or vgGetVectorSize, the return value
- is undefined.
-
- ERRORS
- VG_ILLEGAL_ARGUMENT_ERROR
- if paramType is not a valid value from the VGParamType enumeration
- */
-EXPORT_C VGint
- vgGetVectorSize(VGParamType type)
- {
- OPENVG_TRACE("vgGetVectorSize type=0x%x", type);
-
- return TGuestOpenVg::vgGetVectorSize(type);
- }
-
-/*
- The vgGetParameter functions return the value of a parameter on a given VGHandlebased
- object.
-
- The original value passed to vgSetParameter (provided the call to
- vgSetParameter completed without error) should be returned by
- vgGetParameter (except where specifically noted), even if the implementation
- makes use of a truncated or quantized value internally.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if object is not a valid handle, or is not shared with the current context
- VG_ILLEGAL_ARGUMENT_ERROR
- if paramType is not a valid value from the appropriate enumeration
- if paramType refers to a vector parameter in vgGetParameterf or
- vgGetParameteri
- */
-EXPORT_C VGfloat
- vgGetParameterf(VGHandle object,
- VGint paramType)
- {
- OPENVG_TRACE("vgGetParameterf object=0x%x, paramType=0x%x -->", object, paramType);
-
- VGfloat value = TGuestOpenVg::vgGetParameterf(object, paramType);
- OPENVG_TRACE("vgGetParameterf value=%f <--", value);
- return value;
- }
-
-/*
- The vgGetParameterVectorSize function returns the number of elements in the vector
- that will be returned by the vgGetParameteriv or vgGetParameterfv functions if called
- with the given paramType argument. For scalar values, 1 is returned.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if object is not a valid handle, or is not shared with the current context
- VG_ILLEGAL_ARGUMENT_ERROR
- if paramType is not a valid value from the appropriate enumeration
- */
-EXPORT_C VGint
- vgGetParameterVectorSize(VGHandle object,
- VGint paramType)
- {
- OPENVG_TRACE("vgGetParameterVectorSize object=0x%x, paramType=0x%x -->", object, paramType);
-
- VGint size = TGuestOpenVg::vgGetParameterVectorSize(object, paramType);
- OPENVG_TRACE("vgGetParameterVectorSize size=%i <--", size);
- return size;
- }
-
-/*
- Creates an object capable of storing a mask layer with the given width and
- height and returns a VGMaskLayer handle to it. The mask layer is defined to
- be compatible with the format and multisampling properties of the current
- drawing surface. If there is no current drawing surface, no mask is
- configured for the current drawing surface, or an error occurs,
- VG_INVALID_HANDLE is returned. All mask layer values are initially set to one.
-
- ERRORS
- VG_ILLEGAL_ARGUMENT_ERROR
- if width or height are less than or equal to 0
- if width is greater than VG_MAX_IMAGE_WIDTH
- if height is greater than VG_MAX_IMAGE_HEIGHT
- if width*height is greater than VG_MAX_IMAGE_PIXELS
- */
-EXPORT_C VGMaskLayer
- vgCreateMaskLayer(VGint width, VGint height)
- {
- OPENVG_TRACE("vgCreateMaskLayer width=%d, height=%d -->", width, height);
-
- VGMaskLayer maskHandle = TGuestOpenVg::vgCreateMaskLayer(width, height);
- OPENVG_TRACE("vgCreateMaskLayer handle=0x%x <--", maskHandle);
- return maskHandle;
- }
-
-/*
- The current setting of the VG_PAINT_COLOR parameter on a given paint object may
- be queried as a 32-bit non-premultiplied sRGBA_8888 value. Each color channel or
- alpha value is clamped to the range [0, 1] , multiplied by 255, and rounded to obtain an
- 8-bit integer; the resulting values are packed into a 32-bit value in the same format as for
- vgSetColor.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if paint is not a valid paint handle, or is not shared with the current context
- */
-EXPORT_C VGuint
- vgGetColor(VGPaint paint)
- {
- OPENVG_TRACE("vgGetColor paint=0x%x", paint);
-
- return TGuestOpenVg::vgGetColor(paint);
- }
-
-/*
- Creates an image with the given width, height, and pixel format and returns a
- VGImage handle to it. If an error occurs, VG_INVALID_HANDLE is returned. All
- color and alpha channel values are initially set to zero. The format parameter
- must contain a value from the VGImageFormat enumeration.
- The allowedQuality parameter is a bitwise OR of values from the
- VGImageQuality enumeration, indicating which levels of resampling quality may be
- used to draw the image. It is always possible to draw an image using the
- VG_IMAGE_QUALITY_NONANTIALIASED quality setting even if it is not explicitly
- specified.
-
- ERRORS
- VG_UNSUPPORTED_IMAGE_FORMAT_ERROR
- if format is not a valid value from the VGImageFormat enumeration
- VG_ILLEGAL_ARGUMENT_ERROR
- if width or height are less than or equal to 0
- if width is greater than VG_MAX_IMAGE_WIDTH
- if height is greater than VG_MAX_IMAGE_HEIGHT
- if width*height is greater than VG_MAX_IMAGE_PIXELS
- if width*height*(pixel size of format) is greater than
- VG_MAX_IMAGE_BYTES
- if allowedQuality is not a bitwise OR of values from the
- VGImageQuality enumeration
- */
-EXPORT_C VGImage
- vgCreateImage(VGImageFormat format,
- VGint width, VGint height,
- VGbitfield allowedQuality)
- {
- OPENVG_TRACE("vgCreateImage format=0x%x, width=%d, height=%d, allowedQuality=0x%x -->",
- format, width, height, allowedQuality);
-
- VGImage imageHandle = TGuestOpenVg::vgCreateImage(format, width, height, allowedQuality);
- OPENVG_TRACE("vgCreateImage handle=0x%x <--", imageHandle);
- return imageHandle;
- }
-
-/*
- Returns a new VGImage handle that refers to a portion of the parent image. The
- region is given by the intersection of the bounds of the parent image with the
- rectangle beginning at pixel (x, y) with dimensions width and height, which
- must define a positive region contained entirely within parent.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if parent is not a valid image handle, or is not shared with the current
- context
- VG_IMAGE_IN_USE_ERROR
- if parent is currently a rendering target
- VG_ILLEGAL_ARGUMENT_ERROR
- if x is less than 0 or greater than or equal to the parent width
- if y is less than 0 or greater than or equal to the parent height
- if width or height is less than or equal to 0
- if x + width is greater than the parent width
- if y + height is greater than the parent height
- */
-EXPORT_C VGImage
- vgChildImage(VGImage parent,
- VGint x, VGint y,
- VGint width, VGint height)
- {
- OPENVG_TRACE("vgChildImage parent=oc%x, x=%d, y=%d, width=%d, height=%d -->",
- parent, x, y, width, height);
-
- VGImage imageHandle = TGuestOpenVg::vgChildImage(parent, x, y, width, height);
- OPENVG_TRACE("vgChildImage handle=0x%x <--", imageHandle);
- return imageHandle;
- }
-
-/*
- Returns the closest valid ancestor (i.e., one that has not been the target of
- a vgDestroyImage call) of the given image. If image has no ancestors, image is
- returned.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if image is not a valid image handle, or is not shared with the current
- context
- VG_IMAGE_IN_USE_ERROR
- if image is currently a rendering target
- */
-EXPORT_C VGImage vgGetParent(VGImage image)
- {
- OPENVG_TRACE("vgGetParent image=0x%x", image);
-
- return TGuestOpenVg::vgGetParent(image);
- }
-
-/*
- Creates a new font object and returns a VGFont handle to it. The glyphCapacityHint
- argument provides a hint as to the capacity of a VGFont, i.e., the total number of
- glyphs that this VGFont object will be required to accept. A value of 0 indicates that
- the value is unknown. If an error occurs during execution, VG_INVALID_HANDLE is returned.
-
- ERRORS
- VG_ILLEGAL_ARGUMENT_ERROR
- if glyphCapacityHint is negative
- */
-EXPORT_C VGFont vgCreateFont(VGint glyphCapacityHint)
- {
- OPENVG_TRACE("vgCreateFont glyphCapacityHint=%d -->", glyphCapacityHint);
-
- VGFont fontHandle = TGuestOpenVg::vgCreateFont(glyphCapacityHint);
- OPENVG_TRACE("vgCreateFont handle=0x%x <--", fontHandle);
- return fontHandle;
- }
-
-/* Hardware Queries */
-
-/*
- Returns a value indicating whether a given setting of a property of a type given
- by key is generally accelerated in hardware on the currently running OpenVG
- implementation.
-
- ERRORS
- VG_ILLEGAL_ARGUMENT_ERROR
- if key is not one of the values from the VGHardwareQueryType enumeration
- if setting is not one of the values from the enumeration associated with
- key
- */
-EXPORT_C VGHardwareQueryResult
- vgHardwareQuery
- (VGHardwareQueryType key,
- VGint setting)
- {
- OPENVG_TRACE("vgHardwareQuery key=0x%x, setting=%d", key, setting);
-
- return TGuestOpenVg::vgHardwareQuery(key, setting);
- }
-
-/*
- The vgGetString function returns information about the OpenVG implementation,
- including extension information. The values returned may vary according to
- the display (e.g., the EGLDisplay when using EGL) associated with the current
- context.
-
- Returns NULL if no context is current.
- */
-EXPORT_C const VGubyte *
- vgGetString(VGStringID name)
- {
- OPENVG_TRACE("vgGetString name=0x%x", name);
-
- switch (name)
- {
- case VG_VENDOR:
- return (const VGubyte *)"Nokia";
- case VG_RENDERER:
- return (const VGubyte *)"Guest 1.0";
- case VG_VERSION:
- return (const VGubyte *)"1.1";
- case VG_EXTENSIONS: // supported VG extensions, (associated function addresses are fetched with eglGetProcAddress)
- return (const VGubyte *)"VG_KHR_EGL_image";
- }
- return (const VGubyte *)NULL;
- }
-
-/*
- The vgGetParameter functions return the value of a parameter on a given VGHandlebased
- object.
-
- If vgGetParameteriv or vgGetParameterfv is called with a smaller value for
- count than that returned by vgGetParameterVectorSize, only the first count
- elements of the vector are retrieved. Use of a greater value for count will result
- in an error.
-
- The original value passed to vgSetParameter (provided the call to
- vgSetParameter completed without error) should be returned by
- vgGetParameter (except where specifically noted), even if the implementation
- makes use of a truncated or quantized value internally.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if object is not a valid handle, or is not shared with the current context
- VG_ILLEGAL_ARGUMENT_ERROR
- if paramType is not a valid value from the appropriate enumeration
- if values is NULL in vgGetParameterfv or vgGetParameteriv
- if values is not properly aligned in vgGetParameterfv or vgGetParameteriv
- if count is less than or equal to 0 in vgGetParameterfv or vgGetParameteriv
- if count is greater than the value returned by vgGetParameterVectorSize for
- the given parameter in vgGetParameterfv or vgGetParameteriv
- */
-EXPORT_C void
- vgGetParameterfv(VGHandle object,
- VGint paramType,
- VGint count,
- VGfloat * values)
- {
- OPENVG_TRACE("vgGetParameterfv object=0x%x, paramType=0x%x, count=%d, values=0x%x",
- object, paramType, count, values);
-
- TGuestOpenVg::vgGetParameterfv(object, paramType, count, values);
- }
-
-EXPORT_C void
- vgGetParameteriv(VGHandle object,
- VGint paramType,
- VGint count,
- VGint * values)
- {
- OPENVG_TRACE("vgGetParameteriv object=0x%x, paramType=0x%x, count=%d, values=0x%x",
- object, paramType, count, values);
-
- TGuestOpenVg::vgGetParameteriv(object, paramType, count, values);
- }
-
-/* Renderer and Extension Information */
-
-/*
-The vgGetVectorSize function returns the maximum number of elements in the vector
-that will be retrieved by the vgGetiv or vgGetfv functions if called with the given
-paramType argument. For scalar values, 1 is returned. If vgGetiv or vgGetfv is
-called with a smaller value for count than that returned by vgGetVectorSize,
-only the first count elements of the vector are retrieved. Use of a greater value
-for count will result in an error.
-The original value passed to vgSet (except as specifically noted, and provided the call to
-vgSet completed without error) is returned by vgGet, even if the implementation makes
-use of a truncated or quantized value internally. This rule ensures that OpenVG state may
-be saved and restored without degradation.
-If an error occurs during a call to vgGetfv or vgGetiv, nothing is
-written to values.
-
-ERRORS
-VG_ILLEGAL_ARGUMENT_ERROR
- if paramType is not a valid value from the VGParamType enumeration
- if values is NULL in vgGetfv or vgGetiv
- if values is not properly aligned in vgGetfv or vgGetiv
- if count is less than or equal to 0 in vgGetfv or vgGetiv
- if count is greater than the value returned by vgGetVectorSize for the
-given parameter in vgGetfv or vgGetiv
- */
-EXPORT_C void
- vgGetfv(VGParamType type, VGint count,
- VGfloat * values)
- {
- OPENVG_TRACE("vgGetfv type=0x%x, count=%d, values=0x%x", type, count, values);
-
- TGuestOpenVg::vgGetfv(type, count, values);
- }
-
-EXPORT_C void
- vgGetiv(VGParamType type, VGint count,
- VGint * values)
- {
- OPENVG_TRACE("vgGetiv type=0x%x, count=%d, values=0x%x", type, count, values);
-
- TGuestOpenVg::vgGetiv(type, count, values);
- }
-
-/*
- Retrieve the value of the current transformation.
- Nine values are written to m in the order:
- { sx, shy, w0, shx, sy, w1, tx, ty, w2 }
- For an affine matrix, w0 and w1 will always be 0 and w2 will always be 1.
-
- ERRORS
- VG_ILLEGAL_ARGUMENT_ERROR
- if m is NULL
- if m is not properly aligned
- */
-EXPORT_C void
- vgGetMatrix(VGfloat * m)
- {
- OPENVG_TRACE("vgGetMatrix m=0x%x", m);
-
- TGuestOpenVg::vgGetMatrix(m);
- }
-
-/*
- Read pixel values from a rectangular portion of an image, performs format conversion
- if necessary, and stores the resulting pixels into memory.
-
- Pixel values are written starting at the address given by the pointer data; adjacent
- scanlines are separated by dataStride bytes. Negative or zero values of
- dataStride are allowed. The region to be read is given by x, y, width, and
- height, which must define a positive region. Pixels that fall outside the bounds
- of the image are ignored.
- Pixel values in memory are formatted according to the dataFormat parameter, which
- must contain a value from the VGImageFormat enumeration. If dataFormat
- specifies a premultiplied format (VG_sRGBA_8888_PRE or VG_lRGBA_8888_PRE),
- color channel values of a pixel that are greater than their corresponding alpha value are
- clamped to the range [0, alpha]. The data pointer alignment and the pixel layout in
- memory are as described in the vgImageSubData section.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if image is not a valid image handle, or is not shared with the current context
- VG_IMAGE_IN_USE_ERROR
- if image is currently a rendering target
- VG_UNSUPPORTED_IMAGE_FORMAT_ERROR
- if dataFormat is not a valid value from the VGImageFormat enumeration
- VG_ILLEGAL_ARGUMENT_ERROR
- if width or height is less than or equal to 0
- if data is NULL
- if data is not properly aligned
- */
-EXPORT_C void
- vgGetImageSubData(VGImage image,
- void * data,
- VGint dataStride,
- VGImageFormat dataFormat,
- VGint x, VGint y,
- VGint width, VGint height)
- {
- OPENVG_TRACE("vgGetImageSubData image=0x%x, data=0x%x, dataStride=%d, dataFormat=0x%x, x=%d, y=%d, width=%d, height=%d",
- image, data, dataStride, dataFormat, x, y, width, height);
-
- TGuestOpenVg::vgGetImageSubData(image, data, dataStride, dataFormat, x, y, width, height);
- }
-
-/*
- Copy pixel data from the drawing surface without the creation of a VGImage object.
- Pixel values are written starting at the address given by the pointer data; adjacent
- scanlines are separated by dataStride bytes. Negative or zero values of
- dataStride are allowed. The region to be read is given by x, y, width, and
- height, which must define a positive region.
-
- Pixel values in memory are formatted according to the dataFormat parameter, which
- must contain a value from the VGImageFormat enumeration. The data pointer
- alignment and the pixel layout in memory is as described for vgImageSubData.
-
- Pixels whose source lies outside of the bounds of the drawing surface are
- ignored. Pixel format conversion is applied as needed. The scissoring region
- does not affect the reading of pixels.
-
- ERRORS
- VG_UNSUPPORTED_IMAGE_FORMAT_ERROR
- if dataFormat is not a valid value from the VGImageFormat enumeration
- VG_ILLEGAL_ARGUMENT_ERROR
- if width or height is less than or equal to 0
- if data is NULL
- if data is not properly aligned
- */
-EXPORT_C void
- vgReadPixels(void * data, VGint dataStride,
- VGImageFormat dataFormat,
- VGint sx, VGint sy,
- VGint width, VGint height)
- {
- OPENVG_TRACE("vgReadPixels data=0x%x, dataStride=%d, dataFormat=0x%x, sx=%d, sy=%d, width=%d, height=%d",
- data, dataStride, dataFormat, sx, sy, width, height);
-
- TGuestOpenVg::vgReadPixels(data, dataStride, dataFormat, sx, sy, width, height);
- }
-
-/*
- Returns an axis-aligned bounding box that tightly bounds the interior of the given
- path. Stroking parameters are ignored. If path is empty, minX and minY are set to 0
- and width and height are set to -1. If path contains a single point, minX and minY
- are set to the coordinates of the point and width and height are set to 0.
-
- The VG_PATH_CAPABILITY_PATH_BOUNDS capability must be enabled for path.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if path is not a valid path handle, or is not shared with the current context
- VG_ILLEGAL_ARGUMENT_ERROR
- if minX, minY, width, or height is NULL
- if minX, minY, width, or height is not properly aligned
- VG_PATH_CAPABILITY_ERROR
- if VG_PATH_CAPABILITY_PATH_BOUNDS is not enabled for path
- */
-EXPORT_C void
- vgPathBounds(VGPath path,
- VGfloat * minX,
- VGfloat * minY,
- VGfloat * width,
- VGfloat * height)
- {
- OPENVG_TRACE("vgPathBounds path=0x%x, minX=0x%x, minY=0x%x, width=0x%x, height=0x%x",
- path, minX, minY, width, height);
-
- TGuestOpenVg::vgPathBounds(path, minX, minY, width, height);
- }
-
-/*
- The vgPathTransformedBounds function returns an axis-aligned bounding box
- that is guaranteed to enclose the geometry of the given path following
- transformation by the current path-user-to-surface transform. The returned
- bounding box is not guaranteed to fit tightly around the path geometry. If path
- is empty, minX and minY are set to 0 and width and height are set to -1. If
- path contains a single point, minX and minY are set to the transformed
- coordinates of the point and width and height are set to 0.
- The VG_PATH_CAPABILITY_PATH_TRANSFORMED_BOUNDS capability must be
- enabled for path.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if path is not a valid path handle, or is not shared with the current context
- VG_ILLEGAL_ARGUMENT_ERROR
- if minX, minY, width, or height is NULL
- if minX, minY, width, or height is not properly aligned
- VG_PATH_CAPABILITY_ERROR
- if VG_PATH_CAPABILITY_PATH_TRANSFORMED_BOUNDS is not enabled
- for path
- */
-EXPORT_C void
- vgPathTransformedBounds(VGPath path,
- VGfloat * minX,
- VGfloat * minY,
- VGfloat * width,
- VGfloat * height)
- {
- OPENVG_TRACE("vgPathTransformedBounds path=0x%x, minX=0x%x, minY=0x%x, width=0x%x, height=0x%x",
- path, minX, minY, width, height);
-
- TGuestOpenVg::vgPathTransformedBounds(path, minX, minY, width, height);
- }
-
-////////////////////////////////////////////////////////////////////////////////////////////
-//Syncing methods
-////////////////////////////////////////////////////////////////////////////////////////////
-
-/*
- Ensures that all outstanding requests on the current context will complete in finite time.
- vgFlush may return prior to the actual completion of all requests.
- */
-EXPORT_C void
- vgFlush(void)
- {
- // ToDo comment
- OPENVG_TRACE("vgFlush");
-
- MVgContext* vgContext = CVghwUtils::VgContext();
- if (vgContext)
- {
- vgContext->ExecuteVgFlushCommand();
- }
- }
-
-/*
- The vgFinish function forces all outstanding requests on the current context to
- complete, returning only when the last request has completed.
- */
-EXPORT_C void
- vgFinish(void)
- {
- // ToDo comment
- OPENVG_TRACE("vgFinish");
-
- MVgContext* vgContext = CVghwUtils::VgContext();
- if (vgContext)
- {
- vgContext->ExecuteVgFinishCommand();
- }
- }
-
-////////////////////////////////////////////////////////////////////////////////////////////
-//Functions not returning value (possible to buffer)
-////////////////////////////////////////////////////////////////////////////////////////////
-/* Getters and Setters */
-
-/*
- The vgSet functions set the value of a parameter on the current context.
-
- ERRORS
- VG_ILLEGAL_ARGUMENT_ERROR
- if paramType is not a valid value from the VGParamType enumeration
- if paramType refers to a vector parameter in vgSetf or vgSeti
- if value is not a legal enumerated value for the given parameter in vgSetf or
- vgSeti
- */
-EXPORT_C void
- vgSetf (VGParamType type, VGfloat value)
- {
- OPENVG_TRACE("vgSetf type=0x%x, value=%f", type, value);
-
- TGuestOpenVg::vgSetf(type, value);
- }
-
-EXPORT_C void
- vgSeti (VGParamType type, VGint value)
- {
- OPENVG_TRACE("vgSeti type=0x%x, value=%d", type, value);
-
- TGuestOpenVg::vgSeti(type, value);
- }
-
-/*
- The vgSet functions set the value of a parameter on the current context.
-
- ERRORS
- VG_ILLEGAL_ARGUMENT_ERROR
- if paramType is not a valid value from the VGParamType enumeration
- if paramType refers to a scalar parameter in vgSetfv or vgSetiv and count is
- not equal to 1
- if values[i] is not a legal enumerated value for the given parameter in vgSetfv
- or vgSetiv for 0 <= i < count
- if values is NULL in vgSetfv or vgSetiv and count is greater than 0
- if values is not properly aligned in vgSetfv or vgSetiv
- if count is less than 0 in vgSetfv or vgSetiv
- if count is not a valid value for the given parameter
- */
-EXPORT_C void
- vgSetfv(VGParamType type, VGint count,
- const VGfloat * values)
- {
- OPENVG_TRACE("vgSetfv type=0x%x, count=%d, values=0x%x", type, count, values);
-
- TGuestOpenVg::vgSetfv(type, count, values);
- }
-
-EXPORT_C void
- vgSetiv(VGParamType type, VGint count,
- const VGint * values)
- {
- OPENVG_TRACE("vgSetiv type=0x%x, count=%d, values=0x%x", type, count, values);
-
- TGuestOpenVg::vgSetiv(type, count, values);
- }
-
-/*
- For vgSetParameterf and vgSetParameteri.
-
- The vgSetParameter functions set the value of a parameter on a given VGHandlebased
- object.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if object is not a valid handle, or is not shared with the current context
- VG_ILLEGAL_ARGUMENT_ERROR
- if paramType is not a valid value from the appropriate enumeration
- if paramType refers to a vector parameter in vgSetParameterf or
- vgSetParameteri
- if value is not a legal enumerated value for the given parameter in
- vgSetParameterf or vgSetParameteri
- */
-EXPORT_C void
- vgSetParameterf(VGHandle object,
- VGint paramType,
- VGfloat value)
- {
- OPENVG_TRACE("vgSetParameterf object=0x%x, paramType=0x%x, value=%f -->", object, paramType, value);
-
- TGuestOpenVg::vgSetParameterf(object, paramType, value);
- }
-
-EXPORT_C void
- vgSetParameteri(VGHandle object,
- VGint paramType,
- VGint value)
- {
- OPENVG_TRACE("vgSetParameteri object=0x%x, paramType=0x%x, value=0x%x", object, paramType, value);
-
- TGuestOpenVg::vgSetParameteri(object, paramType, value);
- }
-
-/*
- For vgSetParameterfv and vgSetParameteriv.
-
- The vgSetParameter functions set the value of a parameter on a given VGHandlebased
- object.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if object is not a valid handle, or is not shared with the current context
- VG_ILLEGAL_ARGUMENT_ERROR
- if paramType is not a valid value from the appropriate enumeration
- if paramType refers to a scalar parameter in vgSetParameterfv or
- vgSetParameteriv and count is not equal to 1
- if values[i] is not a legal enumerated value for the given parameter
- in vgSetParameterfv or vgSetParameteriv for 0 <= i < count
- if values is NULL in vgSetParameterfv or vgSetParameteriv and count is
- greater than 0
- if values is not properly aligned in vgSetParameterfv or vgSetParameteriv
- if count is less than 0 in vgSetParameterfv or vgSetParameteriv
- if count is not a valid value for the given parameter
- */
-EXPORT_C void
- vgSetParameterfv(VGHandle object,
- VGint paramType,
- VGint count,
- const VGfloat * values)
- {
- OPENVG_TRACE("vgSetParameterfv object=0x%x, paramType=%d, count=%d, values=0x%x", object, paramType, count, values);
-
- TGuestOpenVg::vgSetParameterfv(object, paramType, count, values);
- }
-
-EXPORT_C void
- vgSetParameteriv(VGHandle object,
- VGint paramType,
- VGint count,
- const VGint * values)
- {
- OPENVG_TRACE("vgSetParameteriv object=0x%x, paramType=%d, count=%d, values=0x%x", object, paramType, count, values);
-
- TGuestOpenVg::vgSetParameteriv(object, paramType, count, values);
- }
-
-/* Matrix Manipulation */
-
-/*
- Sets the current matrix M to the identity matrix:
- */
-EXPORT_C void
- vgLoadIdentity(void)
- {
- OPENVG_TRACE("vgLoadIdentity");
-
- TGuestOpenVg::vgLoadIdentity();
- }
-
-/*
- Loads an arbitrary set of matrix values into the current
- matrix. Nine matrix values are read from m, in the order:
- { sx, shy, w0, shx, sy, w1, tx, ty, w2 }
- However, if the targeted matrix is affine (i.e., the matrix mode is not
- VG_MATRIX_IMAGE_USER_TO_SURFACE), the values { w0, w1, w2 } are ignored and
- replaced by the values { 0, 0, 1 }.
-
- ERRORS
- VG_ILLEGAL_ARGUMENT_ERROR
- if m is NULL
- if m is not properly aligned
- */
-EXPORT_C void
- vgLoadMatrix(const VGfloat * m)
- {
- OPENVG_TRACE("vgLoadMatrix m=0x%x", m);
-
- TGuestOpenVg::vgLoadMatrix(m);
- }
-
-/*
- Right-multiplies the current matrix M by a given matrix:
- Nine matrix values are read from m in the order:
- { sx, shy, w0, shx, sy, w1, tx, ty, w2 }
- and the current matrix is multiplied by the resulting matrix. However, if the
- targeted matrix is affine (i.e., the matrix mode is not
- VG_MATRIX_IMAGE_USER_TO_SURFACE), the values { w0, w1, w2 } are ignored
- and replaced by the values { 0, 0, 1 } prior to multiplication.
-
- ERRORS
- VG_ILLEGAL_ARGUMENT_ERROR
- if m is NULL
- if m is not properly aligned
- */
-EXPORT_C void
- vgMultMatrix(const VGfloat * m)
- {
- OPENVG_TRACE("vgMultMatrix m=0x%x", m);
-
- TGuestOpenVg::vgMultMatrix(m);
- }
-
-/*
- Modifies the current transformation by appending a translation. This is equivalent
- to right-multiplying the current matrix M by a translation matrix:
- [ 1 0 tx ]
- [ 0 1 ty ]
- [ 0 0 1 ]
- */
-EXPORT_C void
- vgTranslate(VGfloat tx, VGfloat ty)
- {
- OPENVG_TRACE("vgTranslate tx=%f, ty=%f", tx, ty);
-
- TGuestOpenVg::vgTranslate(tx, ty);
- }
-
-/*
- Modifies the current transformation by appending a scale. This is equivalent to
- right-multiplying the current matrix M by a scale matrix:
- [ sx 0 0 ]
- [ 0 sy 0 ]
- [ 0 0 1 ]
- */
-EXPORT_C void
- vgScale(VGfloat sx, VGfloat sy)
- {
- OPENVG_TRACE("vgScale sx=%f, sy=%f", sx, sy);
-
- TGuestOpenVg::vgScale(sx, sy);
- }
-
-/*
- Modifies the current transformation by appending a shear. This is equivalent to
- right-multiplying the current matrix M by a shear matrix:
- [ 1 shx 0 ]
- [ shy 1 0 ]
- [ 0 0 1 ]
- */
-EXPORT_C void
- vgShear(VGfloat shx, VGfloat shy)
- {
- OPENVG_TRACE("vgShear shx=%f, shy=%f", shx, shy);
-
- TGuestOpenVg::vgShear(shx, shy);
- }
-
-/*
- Modifies the current transformation by appending a counterclockwise rotation by a given
- angle (expressed in degrees) about the origin. This is equivalent to right-multiplying
- the current matrix M by the following matrix (using the symbol a to represent the value
- of the angle parameter):
- [ cos(a) -sin(a) 0 ]
- [ sin(a) cos(a) 0 ]
- [ 0 0 1 ]
- */
-EXPORT_C void
- vgRotate(VGfloat angle)
- {
- OPENVG_TRACE("vgRotate angle=%f");
-
- TGuestOpenVg::vgRotate(angle);
- }
-
-/*
- Modifies the drawing surface mask values according to a given operation, possibly
- using coverage values taken from a mask layer or bitmap image given by the mask
- parameter. If no mask is configured for the current drawing surface, vgMask has
- no effect.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if operation is not VG_CLEAR_MASK or VG_FILL_MASK, and mask is not a
- valid mask layer or image handle, or is not shared with the current context
- VG_IMAGE_IN_USE_ERROR
- if mask is a VGImage that is currently a rendering target
- VG_ILLEGAL_ARGUMENT_ERROR
- if operation is not a valid value from the VGMaskOperation
- enumeration
- if width or height is less than or equal to 0
- if mask is a VGMaskLayer and is not compatible with the current surface
- mask
- */
-EXPORT_C void
- vgMask(VGHandle mask, VGMaskOperation operation,
- VGint x, VGint y,
- VGint width, VGint height)
- {
- OPENVG_TRACE("vgMask mask=0x%x, operation=0x%x, x=%d, y=%d, width=%d, height=%d",
- mask, operation, x, y, width, height);
-
- TGuestOpenVg::vgMask(mask, operation, x, y, width, height);
- }
-
-/*
- Modifies the current surface mask by applying the given operation to the set of
- coverage values associated with the rendering of the given path. If paintModes
- contains VG_FILL_PATH, the path is filled; if it contains VG_STROKE_PATH, the path
- is stroked. If both are present, the mask operation is performed in two passes,
- first on the filled path geometry, then on the stroked path geometry.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if path is not a valid path handle
- VG_ILLEGAL_ARGUMENT_ERROR
- if paintModes is not a valid bitwise OR of values from the VGPaintMode
- enumeration
- if operation is not a valid value from the VGMaskOperation enumeration
- */
-EXPORT_C void
- vgRenderToMask(VGPath path,
- VGbitfield paintModes,
- VGMaskOperation operation)
- {
- OPENVG_TRACE("vgRenderToMask path=0x%x, paintModes=0x%x, operation=0x%x", path, paintModes, operation);
-
- TGuestOpenVg::vgRenderToMask(path, paintModes, operation);
- }
-
-/*
- Deallocate the resources associated with a mask layer. Following the call,
- the maskLayer handle is no longer valid in the current context.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if maskLayer is not a valid mask handle
- */
-EXPORT_C void vgDestroyMaskLayer(VGMaskLayer maskLayer)
- {
- OPENVG_TRACE("vgDestroyMaskLayer maskLayer=0x%x", maskLayer);
-
- TGuestOpenVg::vgDestroyMaskLayer(maskLayer);
- }
-
-/*
- Set the values of a given maskLayer within a given rectangular region to a given
- value. The floating-point value value must be between 0 and 1. The value is rounded
- to the closest available value supported by the mask layer. If two values are equally
- close, the larger value is used.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if maskLayer is not a valid mask layer handle, or is not shared with the
- current context
- VG_ILLEGAL_ARGUMENT_ERROR
- if value is less than 0 or greater than 1
- if width or height is less than or equal to 0
- if x or y is less than 0
- if x + width is greater than the width of the mask
- if y + height is greater than the height of the mask
- */
-EXPORT_C void
- vgFillMaskLayer(VGMaskLayer maskLayer,
- VGint x, VGint y,
- VGint width, VGint height,
- VGfloat value)
- {
- OPENVG_TRACE("vgFillMaskLayer maskLayer=0x%x, x=%d, y=%d, width=%d, height=%d, value=%f",
- maskLayer, x, y, width, height, value);
-
- TGuestOpenVg::vgFillMaskLayer(maskLayer, x, y, width, height, value);
- }
-
-/*
- Copies a portion of the current surface mask into a VGMaskLayer object. The source
- region starts at (sx, sy) in the surface mask, and the destination region starts
- at (dx, dy) in the destination maskLayer. The copied region is clipped to the given
- width and height and the bounds of the source and destination. If the current context
- does not contain a surface mask, vgCopyMask does nothing.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if maskLayer is not a valid mask layer handle
- VG_ILLEGAL_ARGUMENT_ERROR
- if width or height are less than or equal to 0
- if maskLayer is not compatible with the current surface mask
- */
-EXPORT_C void
- vgCopyMask(VGMaskLayer maskLayer,
- VGint sx, VGint sy,
- VGint dx, VGint dy,
- VGint width, VGint height)
- {
- OPENVG_TRACE("vgCopyMask maskLayer=0x%x, sx=%d, sy=%d, dx=%d, dy=%d, width=%d, height=%d",
- maskLayer, sx, sy, dx, dy, width, height);
-
- TGuestOpenVg::vgCopyMask(maskLayer, sx, sy, dx, dy, width, height);
- }
-
-/*
- Fills the portion of the drawing surface intersecting the rectangle extending from
- pixel (x, y) and having the given width and height with a constant color value, taken
- from the VG_CLEAR_COLOR parameter. The color value is expressed in non-premultiplied
- sRGBA (sRGB color plus alpha)format. Values outside the [0, 1] range are interpreted
- as the nearest endpoint of the range. The color is converted to the destination color
- space in the same manner as if a rectangular path were being filled. Clipping and
- scissoring take place in the usual fashion, but antialiasing, masking, and blending
- do not occur.
-
- ERRORS
- VG_ILLEGAL_ARGUMENT_ERROR
- if width or height is less than or equal to 0
- */
-EXPORT_C void
- vgClear(VGint x, VGint y,
- VGint width, VGint height)
- {
- OPENVG_TRACE("vgClear x=%d, y=%d, width=%d, height=%d", x, y, width, height);
-
- TGuestOpenVg::vgClear(x, y, width, height);
- }
-
-
-/* Paths */
-
-/*
- Remove all segment command and coordinate data associated with a path. The handle
- continues to be valid for use in the future, and the path format and datatype retain
- their existing values. The capabilities argument is a bitwise OR of the desired
- VGPathCapabilities values. Bits of capabilities that do not correspond to values from
- VGPathCapabilities have no effect. Using vgClearPath may be more efficient than
- destroying and re-creating a path for short-lived paths.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if path is not a valid path handle, or is not shared with the current context
- */
-EXPORT_C void
- vgClearPath(VGPath path, VGbitfield capabilities)
- {
- OPENVG_TRACE("vgClearPath path=0x%x, capabilities=0x%x", path, capabilities);
-
- TGuestOpenVg::vgClearPath(path, capabilities);
- }
-
-/*
- Release any resources associated with path, and makes the handle invalid in all
- contexts that shared it.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if path is not a valid path handle, or is not shared with the current context
- */
-EXPORT_C void vgDestroyPath(VGPath path)
- {
- OPENVG_TRACE("vgDestroyPath path=0x%x", path);
-
- TGuestOpenVg::vgDestroyPath(path);
- }
-
-/*
- Requests the set of capabilities specified in the capabilities argument to
- be disabled for the given path. The capabilities argument is a bitwise OR of
- the VGPathCapabilities values whose removal is requested. Attempting to
- remove a capability that is already disabled has no effect. Bits of
- capabilities that do not correspond to values from VGPathCapabilities have
- no effect.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if path is not a valid path handle, or is not shared with the current context
- */
-EXPORT_C void
- vgRemovePathCapabilities(VGPath path,
- VGbitfield capabilities)
- {
- OPENVG_TRACE("vgRemovePathCapabilities path=0x%x, capabilities=0x%x", path, capabilities);
-
- TGuestOpenVg::vgRemovePathCapabilities(path, capabilities);
- }
-
-/*
- Appends a copy of all path segments from srcPath onto the end of the existing
- data in dstPath. It is legal for srcPath and dstPath to be handles to the same
- path object, in which case the contents of the path are duplicated. If srcPath
- and dstPath are handles to distinct path objects, the contents of srcPath will
- not be affected by the call.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if either dstPath or srcPath is not a valid path handle, or is not shared
- with the current context
- VG_PATH_CAPABILITY_ERROR
- if VG_PATH_CAPABILITY_APPEND_FROM is not enabled for srcPath
- if VG_PATH_CAPABILITY_APPEND_TO is not enabled for dstPath
- */
-EXPORT_C void
- vgAppendPath(VGPath dstPath, VGPath srcPath)
- {
- OPENVG_TRACE("vgAppendPath dstPath=0x%x, srcPath=0x%x", dstPath, srcPath);
-
- TGuestOpenVg::vgAppendPath(dstPath, srcPath);
- }
-
-/*
- Appends data taken from pathData to the given path dstPath. The data are formatted
- using the path format of dstPath (as returned by querying the paths VG_PATH_FORMAT
- parameter using vgGetParameteri). The numSegments parameter gives the total number
- of entries in the pathSegments array, and must be greater than 0. Legal values for
- the pathSegments array are the values from the VGPathCommand enumeration as well as
- VG_CLOSE_PATH and (VG_CLOSE_PATH | VG_RELATIVE) (which are synonymous).
-
- The pathData pointer must be aligned on a 1-, 2-, or 4-byte boundary (as defined in
- the Bytes column of Open VG spec Table 7) depending on the size of the coordinate
- datatype (as returned by querying the paths VG_PATH_DATATYPE parameter using
- vgGetParameteri). The VG_PATH_CAPABILITY_APPEND_TO capability must be enabled for
- path.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if dstPath is not a valid path handle, or is not shared with the current
- context
- VG_PATH_CAPABILITY_ERROR
- if VG_PATH_CAPABILITY_APPEND_TO is not enabled for dstPath
- VG_ILLEGAL_ARGUMENT_ERROR
- if pathSegments or pathData is NULL
- if pathData is not properly aligned
- if numSegments is less than or equal to 0
- if pathSegments contains an illegal command
- */
-EXPORT_C void
- vgAppendPathData(VGPath dstPath,
- VGint numSegments,
- const VGubyte * pathSegments,
- const void * pathData)
- {
- OPENVG_TRACE("vgAppendPathData dstPath=0x%x, numSegments=%d, pathSegments=0x%x, pathData=0x%x",
- dstPath, numSegments, pathSegments, pathData);
-
- TGuestOpenVg::vgAppendPathData(dstPath, numSegments, pathSegments, pathData);
- }
-
-/*
- Modifies the coordinate data for a contiguous range of segments of dstPath, starting
- at startIndex (where 0 is the index of the first path segment) and having length
- numSegments. The data in pathData must be formatted in exactly the same manner as the
- original coordinate data for the given segment range, unless the path has been
- transformed using vgTransformPath or interpolated using vgInterpolatePath. In these
- cases, the path will have been subject to the segment promotion rules specified in
- those functions.
-
- The pathData pointer must be aligned on a 1-, 2-, or 4-byte boundary
- depending on the size of the coordinate datatype (as returned by querying the
- paths VG_PATH_DATATYPE parameter using vgGetParameteri). The
- VG_PATH_CAPABILITY_MODIFY capability must be enabled for path.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if dstPath is not a valid path handle, or is not shared with the current
- context
- VG_PATH_CAPABILITY_ERROR
- if VG_PATH_CAPABILITY_MODIFY is not enabled for dstPath
- VG_ILLEGAL_ARGUMENT_ERROR
- if pathData is NULL
- if pathData is not properly aligned
- if startIndex is less than 0
- if numSegments is less than or equal to 0
- if startIndex + numSegments is greater than the number of segments in the path
- */
-EXPORT_C void
- vgModifyPathCoords(VGPath dstPath,
- VGint startIndex,
- VGint numSegments,
- const void * pathData)
- {
- OPENVG_TRACE("vgModifyPathCoords dstPath=0x%x, startIndex=%d, numSegments=%d, pathData=0x%x",
- dstPath, startIndex, numSegments, pathData);
-
- TGuestOpenVg::vgModifyPathCoords(dstPath, startIndex, numSegments, pathData);
- }
-
-/*
- Appends a transformed copy of srcPath to the current contents of dstPath.
- The appended path is equivalent to the results of applying the current
- pathuser-to-surface transformation (VG_MATRIX_PATH_USER_TO_SURFACE) to srcPath.
-
- It is legal for srcPath and dstPath to be handles to the same path object, in
- which case the transformed path will be appended to the existing path. If
- srcPath and dstPath are handles to distinct path objects, the contents of
- srcPath will not be affected by the call.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if either dstPath or srcPath is not a valid path handle, or is not shared with
- the current context
- VG_PATH_CAPABILITY_ERROR
- if VG_PATH_CAPABILITY_TRANSFORM_FROM is not enabled for srcPath
- if VG_PATH_CAPABILITY_TRANSFORM_TO is not enabled for dstPath
- */
-EXPORT_C void
- vgTransformPath(VGPath dstPath, VGPath srcPath)
- {
- OPENVG_TRACE("vgTransformPath dstPath=0x%x, srcPath=0x%x", dstPath, srcPath);
-
- TGuestOpenVg::vgTransformPath(dstPath, srcPath);
- }
-
-/*
- Returns the point lying a given distance along a given portion of a path and
- the unit-length tangent vector at that point. Only the subpath consisting of the
- numSegments path segments beginning with startSegment (where the initial path
- segment has index 0) is used. For the remainder of this section we refer only to
- this subpath when discussing paths.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if path is not a valid path handle, or is not shared with the current context
- VG_PATH_CAPABILITY_ERROR
- If x and y are both non-NULL, and the VG_PATH_CAPABILITY_POINT_ALONG_PATH is
- not enabled for path
- If tangentX and tangentY are both non-NULL, and the
- VG_PATH_CAPABILITY_TANGENT_ALONG_PATH capability is not enabled for path
- VG_ILLEGAL_ARGUMENT_ERROR
- if startSegment is less than 0 or greater than the index of the final path
- segment
- if numSegments is less than or equal to 0
- if (startSegment + numSegments 1) is less than 0 or greater than the index
- of the final path segment
- if x, y, tangentX or tangentY is not properly aligned
- */
-EXPORT_C void
- vgPointAlongPath(VGPath path,
- VGint startSegment,
- VGint numSegments,
- VGfloat distance,
- VGfloat * x, VGfloat * y,
- VGfloat * tangentX,
- VGfloat * tangentY)
- {
- OPENVG_TRACE("vgPointAlongPath path=0x%x, startSeg=%d, numSegs=%d, distance=%f, x=0x%x, y=0x%x, tangentX=0x%x, tangentY=0x%x",
- path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
-
- TGuestOpenVg::vgPointAlongPath(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
- }
-
-/*
- Performs filling and stroking. The paintModes argument is a bitwise OR of
- values from the VGPaintMode enumeration, determining whether the path is to be
- filled (VG_FILL_PATH), stroked (VG_STROKE_PATH), or both (VG_FILL_PATH |
- VG_STROKE_PATH). If both filling and stroking are to be performed, the path is
- first filled, then stroked.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if path is not a valid path handle, or is not shared with the current context
- VG_ILLEGAL_ARGUMENT_ERROR
- if paintModes is not a valid bitwise OR of values from the VGPaintMode
- enumeration
- */
-EXPORT_C void
- vgDrawPath(VGPath path, VGbitfield paintModes)
- {
- OPENVG_TRACE("vgDrawPath path=0x%x paintModes=0x%x", path, paintModes);
-
- TGuestOpenVg::vgDrawPath(path, paintModes);
- }
-
-/* Paint */
-
-/*
- Deallocates the resources associated with a paint object. Following the call, the
- paint handle is no longer valid in any of the contexts that shared it. If the paint
- object is currently active in a drawing context, the context continues to access it
- until it is replaced or the context is destroyed.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if paint is not a valid paint handle, or is not shared with the current context
- */
-EXPORT_C void vgDestroyPaint(VGPaint paint)
- {
- OPENVG_TRACE("vgDestroyPaint paint=0x%x", paint);
-
- TGuestOpenVg::vgDestroyPaint(paint);
- }
-
-/*
- Set paint definitions on the current context. The paintModes argument is a
- bitwise OR of values from the VGPaintMode enumeration, determining whether
- the paint object is to be used for filling (VG_FILL_PATH), stroking
- (VG_STROKE_PATH), or both (VG_FILL_PATH | VG_STROKE_PATH). The current paint
- replaces the previously set paint object, if any, for the given paint mode
- or modes. If paint is equal to VG_INVALID_HANDLE, the previously set paint
- object for the given mode (if present) is removed and the paint settings are
- restored to their default values.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if paint is neither a valid paint handle nor equal to VG_INVALID_HANDLE,
- or is not shared with the current context
- VG_ILLEGAL_ARGUMENT_ERROR
- if paintModes is not a valid bitwise OR of values from the VGPaintMode
- enumeration
- */
-EXPORT_C void
- vgSetPaint(VGPaint paint, VGbitfield paintModes)
- {
- OPENVG_TRACE("vgSetPaint paint=0x%x, paintModes=0x%x", paint, paintModes);
-
- TGuestOpenVg::vgSetPaint(paint, paintModes);
- }
-
-/*
- As a shorthand, the vgSetColor function allows the VG_PAINT_COLOR parameter of a
- given paint object to be set using a 32-bit non-premultiplied sRGBA_8888
- representation. The rgba parameter is a VGuint with 8 bits of red starting at the
- most significant bit, followed by 8 bits each of green, blue, and alpha. Each color
- or alpha channel value is conceptually divided by 255. So as to obtain a value
- between 0 and 1.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if paint is not a valid paint handle, or is not shared with the current context
- */
-EXPORT_C void
- vgSetColor(VGPaint paint, VGuint rgba)
- {
- OPENVG_TRACE("vgSetColor paint=0x%x, rgba=0x%x", paint, rgba);
-
- TGuestOpenVg::vgSetColor(paint, rgba);
- }
-
-/*
- Replaces any previous pattern image defined on the given paint object for the given
- set of paint modes with a new pattern image. A value of VG_INVALID_HANDLE for the
- pattern parameter removes the current pattern image from the paint object.
- If the current paint object has its VG_PAINT_TYPE parameter set to VG_PAINT_TYPE_PATTERN,
- but no pattern image is set, the paint object behaves as if VG_PAINT_TYPE were set to
- VG_PAINT_TYPE_COLOR. While an image is set as the paint pattern for any paint object, it
- may not be used as a rendering target. Conversely, an image that is currently a rendering
- target may not be set as a paint pattern.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if paint is not a valid paint handle, or is not shared with the current context
- if pattern is neither a valid image handle nor equal to VG_INVALID_HANDLE, or is not
- shared with the current context
- VG_IMAGE_IN_USE_ERROR
- if pattern is currently a rendering target
- */
-EXPORT_C void
- vgPaintPattern(VGPaint paint, VGImage pattern)
- {
- OPENVG_TRACE("vgPaintPattern paint=0x%x, pattern=0x%x", paint, pattern);
-
- TGuestOpenVg::vgPaintPattern(paint, pattern);
- }
-
-/* Images */
-
-/*
- Deallocates the resources associated with an image. Following the call, the image
- handle is no longer valid in any context that shared it. If the image is currently
- in use as a rendering target, is the ancestor of another image (see vgChildImage),
- is set as a paint pattern image on a VGPaint object, or is set as a glyph an a
- VGFont object, its definition remains available to those consumers as long as they
- remain valid, but the handle may no longer be used. When those uses cease, the
- images resources will automatically be deallocated.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if image is not a valid image handle, or is not shared with the current
- context
- */
-EXPORT_C void vgDestroyImage(VGImage image)
- {
- OPENVG_TRACE("vgDestroyImage image=0x%x -->", image);
-
- TGuestOpenVg::vgDestroyImage(image);
- OPENVG_TRACE("vgDestroyImage <--");
- }
-
-/*
- Fills a given rectangle of an image with the color specified by the VG_CLEAR_COLOR parameter.
- The rectangle to be cleared is given by x, y, width, and height, which must define a positive
- region. The rectangle is clipped to the bounds of the image.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if image is not a valid image handle, or is not shared with the current
- context
- VG_IMAGE_IN_USE_ERROR
- if image is currently a rendering target
- VG_ILLEGAL_ARGUMENT_ERROR
- if width or height is less than or equal to 0
- */
-EXPORT_C void
- vgClearImage(VGImage image,
- VGint x, VGint y,
- VGint width, VGint height)
- {
- OPENVG_TRACE("vgClearImage image=0x%x, x=%d, y=%d, width=%d, height=%d",
- image, x, y, width, height);
-
- TGuestOpenVg::vgClearImage(image, x, y, width, height);
- }
-
-/*
- Read pixel values from memory, perform format conversion if necessary, and store
- the resulting pixels into a rectangular portion of an image.
-
- Pixel values are read starting at the address given by the pointer data; adjacent
- scanlines are separated by dataStride bytes. Negative or zero values of
- dataStride are allowed. The region to be written is given by x, y, width, and
- height, which must define a positive region. Pixels that fall outside the bounds
- of the image are ignored.
-
- Pixel values in memory are formatted according to the dataFormat parameter, which
- must contain a value from the VGImageFormat enumeration. The data pointer must
- be aligned according to the number of bytes of the pixel format specified by
- dataFormat, unless dataFormat is equal to VG_BW_1, VG_A_1, or VG_A_4, in
- which case 1 byte alignment is sufficient. Each pixel is converted into the format of
- the destination image as it is written.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if image is not a valid image handle, or is not shared with the current
- context
- VG_IMAGE_IN_USE_ERROR
- if image is currently a rendering target
- VG_UNSUPPORTED_IMAGE_FORMAT_ERROR
- if dataFormat is not a valid value from the VGImageFormat enumeration
- VG_ILLEGAL_ARGUMENT_ERROR
- if width or height is less than or equal to 0
- if data is NULL
- if data is not properly aligned
- */
-EXPORT_C void
- vgImageSubData(VGImage image,
- const void * data,
- VGint dataStride,
- VGImageFormat dataFormat,
- VGint x, VGint y,
- VGint width, VGint height)
- {
- OPENVG_TRACE("vgImageSubData image=0x%x, data=0x%x, dataStride=%d, dataFormat=0x%x, x=%d, y=%d, width=%d, height=%d",
- image, data, dataStride, dataFormat, x, y, width, height);
-
- TGuestOpenVg::vgImageSubData(image, data, dataStride, dataFormat, x, y, width, height);
- }
-
-/*
- Copies pixels between images. The source image pixel (sx + i, sy + j) is copied
- to the destination image pixel (dx + i, dy + j), for 0 <= i < width and
- 0 <= j < height. Pixels whose source or destination lie outside of the bounds
- of the respective image are ignored. Pixel format conversion is applied as needed.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if either dst or src is not a valid image handle, or is not shared with the
- current context
- VG_IMAGE_IN_USE_ERROR
- if either dst or src is currently a rendering target
- VG_ILLEGAL_ARGUMENT_ERROR
- if width or height is less than or equal to 0
- */
-EXPORT_C void
- vgCopyImage(VGImage dst, VGint dx, VGint dy,
- VGImage src, VGint sx, VGint sy,
- VGint width, VGint height,
- VGboolean dither)
- {
- OPENVG_TRACE("vgCopyImage dst=0x%x, dx=%d, dy=%d, src=0x%x, sx=%d, sy=%d, width=%d, height=%d, dither=%d",
- dst, dx, dy, src, sx, sy, width, height, dither);
-
- TGuestOpenVg::vgCopyImage(dst, dx, dy, src, sx, sy, width, height, dither);
- }
-
-/*
- Draw an image to the current drawing surface. The current image-user-to-surface
- transformation Ti is applied to the image, so that the image pixel centered at
- (px + 0.5, py + 0.5) is mapped to the point (Ti)(px + 0.5, py + 0.5). In practice,
- backwards mapping may be used. That is, a sample located at (x, y) in the surface
- coordinate system is colored according to an interpolated image pixel value at the
- point (Ti)-1(x, y) in the image coordinate system. If Ti is non-invertible (or nearly
- so, within the limits of numerical accuracy), no drawing occurs.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if image is not a valid image handle, or is not shared with the current
- context
- VG_IMAGE_IN_USE_ERROR
- if image is currently a rendering target
- */
-EXPORT_C void
- vgDrawImage(VGImage image)
- {
- OPENVG_TRACE("vgDrawImage image=0x%x", image);
-
- TGuestOpenVg::vgDrawImage(image);
- }
-
-/*
- Copies pixel data from the image src onto the drawing surface. The image pixel
- (sx + i, sy + j) is copied to the drawing surface pixel (dx + i, dy + j), for
- 0 <= i < width and 0 <= j < height. Pixels whose source lies outside of the
- bounds of src or whose destination lies outside the bounds of the drawing surface
- are ignored. Pixel format conversion is applied as needed. Scissoring takes place
- normally. Transformations, masking, and blending are not applied.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if src is not a valid image handle, or is not shared with the current context
- VG_IMAGE_IN_USE_ERROR
- if src is currently a rendering target
- VG_ILLEGAL_ARGUMENT_ERROR
- if width or height is less than or equal to 0
- */
-EXPORT_C void
- vgSetPixels(VGint dx, VGint dy,
- VGImage src, VGint sx, VGint sy,
- VGint width, VGint height)
- {
- OPENVG_TRACE("vgSetPixels dx=%d, dy=%d, src==0x%x, sx=%d, sy=%d, width=%d, height=%d",
- dx, dy, src, sx, sy, width, height);
-
- TGuestOpenVg::vgSetPixels(dx, dy, src, sx, sy, width, height);
- }
-
-/*
- Copy pixel data to the drawing surface without the creation of a VGImage object. The pixel
- values to be drawn are taken from the data pointer at the time of the vgWritePixels call,
- so future changes to the data have no effect. The effects of changes to the data by another
- thread at the time of the call to vgWritePixels are undefined.
-
- ERRORS
- VG_UNSUPPORTED_IMAGE_FORMAT_ERROR
- if dataFormat is not a valid value from the VGImageFormat enumeration
- VG_ILLEGAL_ARGUMENT_ERROR
- if width or height is less than or equal to 0
- if data is NULL
- if data is not properly aligned
- */
-EXPORT_C void
- vgWritePixels(const void * data, VGint dataStride,
- VGImageFormat dataFormat,
- VGint dx, VGint dy,
- VGint width, VGint height)
- {
- OPENVG_TRACE("vgWritePixels data=0x%x, dataStride=%d, dataFormat=0x%x, dx=%d, dy=%d, width=%d, height=%d",
- data, dataStride, dataFormat, dx, dy, width, height);
-
- TGuestOpenVg::vgWritePixels(data, dataStride, dataFormat, dx, dy, width, height);
- }
-
-/*
- Retrieves pixel data from the drawing surface into the image dst. The drawing surface
- pixel (sx + i, sy + j) is copied to pixel (dx + i, dy + j) of the image dst, for
- 0 <= i < width and 0 <= j < height. Pixels whose source lies outside of the bounds of
- the drawing surface or whose destination lies outside the bounds of dst are ignored.
- Pixel format conversion is applied as needed. The scissoring region does not affect
- the reading of pixels.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if dst is not a valid image handle, or is not shared with the current context
- VG_IMAGE_IN_USE_ERROR
- if dst is currently a rendering target
- VG_ILLEGAL_ARGUMENT_ERROR
- if width or height is less than or equal to 0
- */
-EXPORT_C void
- vgGetPixels(VGImage dst, VGint dx, VGint dy,
- VGint sx, VGint sy,
- VGint width, VGint height)
- {
- OPENVG_TRACE("vgGetPixels dst=0x%x, dx=%d, dy=%d, sx=%d, sy=%d, width=%d, height=%d",
- dst, dx, dy, sx, sy, width, height);
-
- TGuestOpenVg::vgGetPixels(dst, dx, dy, sx, sy, width, height);
- }
-
-/*
- Copy pixels from one region of the drawing surface to another. Copies between
- overlapping regions are allowed and always produce consistent results identical to
- copying the entire source region to a scratch buffer followed by copying the scratch
- buffer into the destination region. The drawing surface pixel (sx + i, sy + j) is
- copied to pixel (dx + i, dy + j) for 0 <= i < width and 0 <= j < height. Pixels whose
- source or destination lies outside of the bounds of the drawing surface are ignored.
- Transformations, masking, and blending are not applied. Scissoring is applied to the
- destination, but does not affect the reading of pixels.
-
- ERRORS
- VG_ILLEGAL_ARGUMENT_ERROR
- if width or height is less than or equal to 0
- */
-EXPORT_C void
- vgCopyPixels(VGint dx, VGint dy,
- VGint sx, VGint sy,
- VGint width, VGint height)
- {
- OPENVG_TRACE("vgCopyPixels dx=%d, dy=%d, sx=%d, sy=%d, width=%d, height=%d",
- dx, dy, sx, sy, width, height);
-
- TGuestOpenVg::vgCopyPixels(dx, dy, sx, sy, width, height);
- }
-
-/*
- Destroys the VGFont object pointed to by the font argument.
- Note that vgDestroyFont will not destroy underlying objects that were used to
- define glyphs in the font. It is the responsibility of an application to destroy all
- VGPath or VGImage objects that were used in a VGFont, if they are no longer in
- use.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if font is not a valid font handle, or is not shared with the current context
- */
-EXPORT_C void
- vgDestroyFont(VGFont font)
- {
- OPENVG_TRACE("vgDestroyFont font=0x%x", font);
-
- TGuestOpenVg::vgDestroyFont(font);
- }
-
-/*
- Creates a new glyph and assigns the given path to a glyph associated with the
- glyphIndex in a font object. The glyphOrigin argument defines the coordinates of
- the glyph origin within the path, and the escapement parameter determines the
- advance width for this glyph. Both glyphOrigin and escapement coordinates are
- defined in the same coordinate system as the path. For glyphs that have no
- visual representation (e.g., the <space> character), a value of VG_INVALID_HANDLE
- is used for path. The reference count for the path is incremented.
-
- The path object may define either an original glyph outline, or an outline that
- has been scaled and hinted to a particular size (in surface coordinate units); this
- is defined by the isHinted parameter, which can be used by implementation
- for text-specific optimizations (e.g., heuristic auto-hinting of unhinted outlines).
- When isHinted is equal to VG_TRUE, the implementation will never apply
- auto-hinting; otherwise, auto hinting will be applied at the implementation's
- discretion.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if font is not a valid font handle, or is not shared with the current context
- if path is not a valid font handle or VG_INVALID_HANDLE, or is not shared
- with the current context
- VG_ILLEGAL_ARGUMENT_ERROR
- if the pointer to glyphOrigin or escapement is NULL or is not properly
- aligned
- */
-EXPORT_C void
- vgSetGlyphToPath(VGFont font,
- VGuint glyphIndex,
- VGPath path,
- VGboolean isHinted,
- const VGfloat glyphOrigin [2],
- const VGfloat escapement[2])
- {
- OPENVG_TRACE("vgSetGlyphToPath font=0x%x, glyphIndex=%u, path=0x%x, isHinted=%d, glyphOrigin=0x%x, escapement=0x%x",
- font, glyphIndex, path, isHinted, glyphOrigin, escapement);
-
- TGuestOpenVg::vgSetGlyphToPath(font, glyphIndex, path, isHinted, glyphOrigin, escapement);
- }
-
-/*
- Creates a new glyph and assigns the given image into a glyph associated with
- the glyphIndex in a font object. The glyphOrigin argument defines the
- coordinates of the glyph origin within the image, and the escapement parameter
- determines the advance width for this glyph. Both glyphOrigin and escapement
- coordinates are defined in the image coordinate system. Applying transformations
- to an image (other than translations mapped to pixel grid in surface coordinate
- system) should be avoided as much as possible. For glyphs that have no visual
- representation (e.g., the <space> character), a value of VG_INVALID_HANDLE is
- used for image. The reference count for the image is incremented.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if font is not a valid font handle, or is not shared with the current context
- if image is not a valid image handle or VG_INVALID_HANDLE, or is not
- shared with the current context
- VG_ILLEGAL_ARGUMENT_ERROR
- if the pointer to glyphOrigin or escapement is NULL or is not properly
- aligned
- VG_IMAGE_IN_USE_ERROR
- if image is currently a rendering target
- */
-EXPORT_C void
- vgSetGlyphToImage(VGFont font,
- VGuint glyphIndex,
- VGImage image,
- const VGfloat glyphOrigin [2],
- const VGfloat escapement[2])
- {
- OPENVG_TRACE("vgSetGlyphToImage font=0x%x, glyphIndex=%d, image=0x%x, glyphOrigin=0x%x, escapement=0x%x",
- font, glyphIndex, image, (void*)glyphOrigin, (void*)escapement);
-
- TGuestOpenVg::vgSetGlyphToImage(font, glyphIndex, image, glyphOrigin, escapement);
- }
-
-/*
- Deletes the glyph defined by a glyphIndex parameter from a font. The reference count
- for the VGPath or VGImage object to which the glyph was previously set is decremented,
- and the object's resources are released if the count has fallen to 0.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if font is not a valid font handle, or is not shared with the current context
- VG_ILLEGAL_ARGUMENT_ERROR
- if glyphIndex is not defined for the font
- */
-EXPORT_C void
- vgClearGlyph(VGFont font,
- VGuint glyphIndex)
- {
- OPENVG_TRACE("vgClearGlyph font=0x%x, glyphIndex=%u", font, glyphIndex);
-
- TGuestOpenVg::vgClearGlyph(font, glyphIndex);
- }
-
-/*
- Renders a glyph defined by the glyphIndex using the given font object. The
- user space position of the glyph (the point where the glyph origin will be
- placed) is determined by value of VG_GLYPH_ORIGIN. vgDrawGlyph calculates the
- new text origin by translating the glyph origin by the escapement vector of
- the glyph defined by glyphIndex. Following the call, the VG_GLYPH_ORIGIN
- parameter will be updated with the new origin.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if font is not a valid font handle, or is not shared with the current context
- VG_ILLEGAL_ARGUMENT_ERROR
- if glyphIndex has not been defined for a given font object
- if paintModes is not a valid bitwise OR of values from the VGPaintMode
- enumeration, or 0
- */
-EXPORT_C void
- vgDrawGlyph(VGFont font,
- VGuint glyphIndex,
- VGbitfield paintModes,
- VGboolean allowAutoHinting)
- {
- OPENVG_TRACE("vgDrawGlyph font=0x%x, glyphIndex=%u, paintModes=0x%x, allowAutoHinting=%d",
- font, glyphIndex, paintModes, allowAutoHinting);
-
- TGuestOpenVg::vgDrawGlyph(font, glyphIndex, paintModes, allowAutoHinting);
- }
-
-/*
- Renders a sequence of glyphs defined by the array pointed to by glyphIndices
- using the given font object. The values in the adjustments_x and adjustments_y
- arrays define positional adjustment values for each pair of glyphs defined by
- the glyphIndices array. The glyphCount parameter defines the number of elements
- in the glyphIndices and adjustments_x and adjustments_y arrays. The adjustment
- values defined in these arrays may represent kerning or other positional adjustments
- required for each pair of glyphs. If no adjustments for glyph positioning in a
- particular axis are required (all horizontal and/or vertical adjustments are zero),
- NULL pointers may be passed for either or both of adjustment_x and
- adjustment_y. The adjustments values should be defined in the same
- coordinate system as the font glyphs; if the glyphs are defined by path objects
- with path data scaled (e.g., by a factor of 1/units-per-EM), the values in the
- adjustment_x and adjustment_y arrays are scaled using the same scale factor.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if font is not a valid font handle, or is not shared with the current context
- VG_ILLEGAL_ARGUMENT_ERROR
- if glyphCount is zero or a negative value
- if the pointer to the glyphIndices array is NULL or is not properly
- aligned
- if a pointer to either of the adjustments_x or adjustments_y arrays are
- non-NULL and are not properly aligned
- if any of the glyphIndices has not been defined in a given font object
- if paintModes is not a valid bitwise OR of values from the VGPaintMode
- enumeration, or 0
- */
-EXPORT_C void
- vgDrawGlyphs(VGFont font,
- VGint glyphCount,
- const VGuint * glyphIndices,
- const VGfloat * adjustments_x,
- const VGfloat * adjustments_y,
- VGbitfield paintModes,
- VGboolean allowAutoHinting)
- {
- OPENVG_TRACE("vgDrawGlyphs font=0x%x, glyphCount=%d, glyphIndices=0x%x, adjustments_y=0x%x, "
- "adjustments_x=0x%x, paintModes=0x%x, allowAutoHinting=%d",
- font, glyphCount, (void*)glyphIndices, (void*)adjustments_x, (void*)adjustments_y, paintModes, allowAutoHinting);
-
- TGuestOpenVg::vgDrawGlyphs(font, glyphCount, glyphIndices, adjustments_x, adjustments_y, paintModes, allowAutoHinting);
- }
-
-/* Image Filters */
-
-/*
- Computes a linear combination of color and alpha values (Rsrc, Gsrc, Bsrc,
- ALPHAsrc) from the normalized source image src at each pixel.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if either dst or src is not a valid image handle, or is not shared with the
- current context
- VG_IMAGE_IN_USE_ERROR
- if either dst or src is currently a rendering target
- VG_ILLEGAL_ARGUMENT_ERROR
- if src and dst overlap
- if matrix is NULL
- if matrix is not properly aligned
- */
-EXPORT_C void
- vgColorMatrix(VGImage dst, VGImage src,
- const VGfloat * matrix)
- {
- OPENVG_TRACE("vgColorMatrix dst=0x%x, src=0x%x, matrix=0x%x", dst, src, matrix);
-
- TGuestOpenVg::vgColorMatrix(dst, src, matrix);
- }
-
-/*
- Applies a user-supplied convolution kernel to a normalized source image src. The
- dimensions of the kernel are given by kernelWidth and kernelHeight; the kernel values
- are specified as kernelWidth*kernelHeight VGshorts in column-major order. That is,
- the kernel entry (i, j) is located at position i*kernelHeight + j in the input sequence.
- The shiftX and shiftY parameters specify a translation between the source and
- destination images. The result of the convolution is multiplied by a scale factor, and
- a bias is added.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if either dst or src is not a valid image handle, or is not shared with the
- current context
- VG_IMAGE_IN_USE_ERROR
- if either dst or src is currently a rendering target
- VG_ILLEGAL_ARGUMENT_ERROR
- if src and dst overlap
- if kernelWidth or kernelHeight is less than or equal to 0 or greater than
- VG_MAX_KERNEL_SIZE
- if kernel is NULL
- if kernel is not properly aligned
- if tilingMode is not one of the values from the VGTilingMode enumeration
- */
-EXPORT_C void
- vgConvolve(VGImage dst, VGImage src,
- VGint kernelWidth, VGint kernelHeight,
- VGint shiftX, VGint shiftY,
- const VGshort * kernel,
- VGfloat scale,
- VGfloat bias,
- VGTilingMode tilingMode)
- {
- OPENVG_TRACE("vgConvolve dst=0x%x, src=0x%x, kW=%d, kH=%d, shX=%d, shY=%d, kernel=0x%x, scale=%f, bias=%f, tiling=0x%x",
- dst, src, kernelWidth, kernelHeight, shiftX, shiftY, kernel, scale, bias, tilingMode);
-
- TGuestOpenVg::vgConvolve(dst, src, kernelWidth, kernelHeight, shiftX, shiftY, kernel, scale, bias, tilingMode);
- }
-
-/*
- Applies a user-supplied separable convolution kernel to a normalized source image src.
- A separable kernel is a two-dimensional kernel in which each entry kij is equal to a
- product kxi * kyj of elements from two one dimensional kernels, one horizontal and one
- vertical.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if either dst or src is not a valid image handle, or is not shared with the
- current context
- VG_IMAGE_IN_USE_ERROR
- if either dst or src is currently a rendering target
- VG_ILLEGAL_ARGUMENT_ERROR
- if src and dst overlap
- if kernelWidth or kernelHeight is less than or equal to 0 or greater than
- VG_MAX_SEPARABLE_KERNEL_SIZE
- if kernelX or kernelY is NULL
- if kernelX or kernelY is not properly aligned
- if tilingMode is not one of the values from the VGTilingMode
- enumeration
- */
-EXPORT_C void
- 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)
- {
- OPENVG_TRACE("vgSeparableConvolve dst=0x%x, src=0x%x, kW=%d, kH=%d, shX=%d, shY=%d, kX=0x%x, kY=0x%x, scale=%f, bias=%f, tiling=0x%x",
- dst, src, kernelWidth, kernelHeight, shiftX, shiftY, kernelX, kernelY, scale, bias, tilingMode);
-
- TGuestOpenVg::vgSeparableConvolve(dst, src, kernelWidth, kernelHeight, shiftX, shiftY, kernelX, kernelY, scale, bias, tilingMode);
- }
-
-/*
- Computes the convolution of a normalized source image src with a separable kernel
- defined in each dimension by the Gaussian function G(x, s).
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if either dst or src is not a valid image handle, or is not shared with the
- current context
- VG_IMAGE_IN_USE_ERROR
- if either dst or src is currently a rendering target
- VG_ILLEGAL_ARGUMENT_ERROR
- if src and dst overlap
- if stdDeviationX or stdDeviationY is less than or equal to 0 or greater
- than VG_MAX_GAUSSIAN_STD_DEVIATION
- if tilingMode is not one of the values from the VGTilingMode
- enumeration
- */
-EXPORT_C void
- vgGaussianBlur(VGImage dst, VGImage src,
- VGfloat stdDeviationX,
- VGfloat stdDeviationY,
- VGTilingMode tilingMode)
- {
- OPENVG_TRACE("vgGaussianBlur dst=0x%x, src=0x%x, stdDeviationX=%f, stdDeviationY=%f, tilingMode=%d",
- dst, src, stdDeviationX, stdDeviationY, tilingMode);
-
- TGuestOpenVg::vgGaussianBlur(dst, src, stdDeviationX, stdDeviationY, tilingMode);
- }
-
-/*
- Passes each image channel of the normalized source image src through a separate lookup
- table.
-
- Each channel of the normalized source pixel is used as an index into the lookup table for
- that channel by multiplying the normalized value by 255 and rounding to obtain an 8-bit
- integral value. Each LUT parameter should contain 256 VGubyte entries. The
- outputs of the lookup tables are concatenated to form an RGBA_8888 pixel
- value, which is interpreted as lRGBA_8888, lRGBA_8888_PRE, sRGBA_8888,
- or sRGBA_8888_PRE, depending on the values of outputLinear and outputPremultiplied.
-
- The resulting pixels are converted into the destination format using the normal
- pixel format conversion rules.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if either dst or src is not a valid image handle, or is not shared with the
- current context
- VG_IMAGE_IN_USE_ERROR
- if either dst or src is currently a rendering target
- VG_ILLEGAL_ARGUMENT_ERROR
- if src and dst overlap
- if any pointer parameter is NULL
- */
-EXPORT_C void
- vgLookup(VGImage dst, VGImage src,
- const VGubyte * redLUT,
- const VGubyte * greenLUT,
- const VGubyte * blueLUT,
- const VGubyte * alphaLUT,
- VGboolean outputLinear,
- VGboolean outputPremultiplied)
- {
- OPENVG_TRACE("vgLookup dst=0x%x, src=0x%x, redLUT=0x%x, greenLUT=0x%x, blueLUT=0x%x, alphaLUT=0x%x, opLin=%d, opPremul=%d",
- dst, src, redLUT, greenLUT, blueLUT, alphaLUT, outputLinear, outputPremultiplied);
-
- TGuestOpenVg::vgLookup(dst, src, redLUT, greenLUT, blueLUT, alphaLUT, outputLinear, outputPremultiplied);
- }
-
-/*
- Passes a single image channel of the normalized source image src, selected by the
- sourceChannel parameter, through a combined lookup table that produces whole pixel
- values. Each normalized source channel value is multiplied by 255 and rounded to
- obtain an 8 bit integral value.
-
- ERRORS
- VG_BAD_HANDLE_ERROR
- if either dst or src is not a valid image handle, or is not shared with the
- current context
- VG_IMAGE_IN_USE_ERROR
- if either dst or src is currently a rendering target
- VG_ILLEGAL_ARGUMENT_ERROR
- if src and dst overlap
- if src is in an RGB pixel format and sourceChannel is not one of VG_RED,
- VG_GREEN, VG_BLUE or VG_ALPHA from the VGImageChannel enumeration
- if lookupTable is NULL
- if lookupTable is not properly aligned
- */
-EXPORT_C void
- vgLookupSingle(VGImage dst, VGImage src,
- const VGuint * lookupTable,
- VGImageChannel sourceChannel,
- VGboolean outputLinear,
- VGboolean outputPremultiplied)
- {
- OPENVG_TRACE("vgLookupSingle dst=0x%x, src=0x%x, lookupTable=0x%x, sourceChannel=0x%x, opLin=%d, opPremul=%d",
- dst, src, lookupTable, sourceChannel, outputLinear, outputPremultiplied);
-
- TGuestOpenVg::vgLookupSingle(dst, src, lookupTable, sourceChannel, outputLinear, outputPremultiplied);
- }
-
-// guest support for OpenVG extension #4, KHR_EGL_image - vgCreateEGLImageTargetKHR(VGeglImageKHR image)
-/*
- Creates an EGLImage target VGImage object from the provided EGLImage
- <image>. <image> should be of type EGLImageKHR, cast into the type
- VGeglImageKHR. Assuming no errors are generated in this function,
- the resulting VGImage will be an EGLImage target of the specified
- EGLImage <image>. As a side-effect of the referencing operation,
- all of the pixel data in the <buffer> used as the EGLImage source
- resource (i.e., the <buffer> parameter passed to the CreateImageKHR
- command that returned <image>) will become undefined.
-
- ERRORS
- VG_UNSUPPORTED_IMAGE_FORMAT_ERROR
- - if the OpenVG implementation is not able to create a VGImage
- compatible with the provided VGeglImageKHR for an implementation-
- dependent reason (this could be caused by, but not limited to,
- reasons such as unsupported pixel formats, anti-aliasing quality,
- etc.).
-
- VG_ILLEGAL_ARGUMENT_ERROR
- - if <image> is not a valid VGeglImageKHR.
- */
-VGImage vgCreateEGLImageTargetKHR(VGeglImageKHR image)
- {
- OPENVG_TRACE("vgCreateEGLImageTargetKHR image=0x%x -->", image);
-
- VGImage imageHandle = TGuestOpenVg::vgCreateEGLImageTargetKHR(image);
- OPENVG_TRACE("vgCreateEGLImageTargetKHR imageHandle=0x%x <--", imageHandle);
- return imageHandle;
- }
-
-
-} /* extern "C" */
-
-// end of file openvg.cpp
+// Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// OpenVG C API for Symbian DLL
+
+
+#include "vgstate.h"
+
+
+
+extern "C" {
+
+/*
+ Note: Comments at the start of each Open VG api are adapted from the Open VG 1.1 specification.
+ The text has been chosen/adapted to give a helpful overview of the function, and the errors
+ (other than VG_NO_CONTEXT_ERROR) that it may generate. For more details and diagrams see the
+ full Open VG specification.
+ */
+
+/*
+ The vgGetParameter functions return the value of a parameter on a given VGHandlebased
+ object.
+
+ The original value passed to vgSetParameter (provided the call to
+ vgSetParameter completed without error) should be returned by
+ vgGetParameter (except where specifically noted), even if the implementation
+ makes use of a truncated or quantized value internally.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if object is not a valid handle, or is not shared with the current context
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if paramType is not a valid value from the appropriate enumeration
+ if paramType refers to a vector parameter in vgGetParameterf or
+ vgGetParameteri
+ */
+EXPORT_C VGint
+ vgGetParameteri(VGHandle object,
+ VGint paramType)
+ {
+ OPENVG_TRACE("vgGetParameteri object=0x%x, paramType=0x%x -->", object, paramType);
+
+ VGint value = TGuestOpenVg::vgGetParameteri(object, paramType);
+ OPENVG_TRACE("vgGetParameteri value=0x%x <--", value);
+ return value;
+ }
+
+
+////////////////////////////////////////////////////////////////////////////////////////////
+//Functions returning value
+////////////////////////////////////////////////////////////////////////////////////////////
+/*
+ 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). No
+ error is indicated by a return value of 0 (VG_NO_ERROR). After the call, the error code is
+ cleared to 0. The possible errors that may be generated by each OpenVG function (apart from
+ VG_OUT_OF_MEMORY_ERROR) are shown below the definition of the function.
+ If no context is current at the time vgGetError is called, the error code
+ VG_NO_CONTEXT_ERROR is returned. Pending error codes on existing contexts are not affected
+ by the call.
+ */
+EXPORT_C VGErrorCode
+ vgGetError(void)
+ {
+ OPENVG_TRACE("vgGetError");
+
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ VGErrorCode error = VG_NO_CONTEXT_ERROR;
+ if (vgContext)
+ { // thread state already exists - get client or Host VG error
+ error = vgContext->VgError();
+ }
+ return error;
+ }
+
+/*
+ Returns the paint object currently set for the given paintMode, or VG_INVALID_HANDLE
+ if an error occurs or if no paint object is set (i.e., the default paint is present) on
+ the given context with the given paintMode.
+
+ ERRORS
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if paintMode is not a valid value from the VGPaintMode enumeration
+ */
+EXPORT_C VGPaint
+ vgGetPaint(VGPaintMode paintMode)
+ {
+ OPENVG_TRACE("vgGetPaint paintMode=0x%x -->", paintMode);
+
+ VGPaint paintHandle = TGuestOpenVg::vgGetPaint(paintMode);
+ OPENVG_TRACE("vgGetPaint handle=0x%x <--", paintHandle);
+ return paintHandle;
+ }
+
+/*
+ Creates a new paint object that is initialized to a set of default values and returns
+ a VGPaint handle to it. If insufficient memory is available to allocate a new object,
+ VG_INVALID_HANDLE is returned.
+ */
+EXPORT_C VGPaint
+ vgCreatePaint(void)
+ {
+ OPENVG_TRACE("vgCreatePaint -->");
+
+ VGPaint paintHandle = TGuestOpenVg::vgCreatePaint();
+ OPENVG_TRACE("vgCreatePaint handle=0x%x <--", paintHandle);
+ return paintHandle;
+ }
+
+/*
+ Appends a path, defined by interpolation (or extrapolation) between the paths
+ startPath and endPath by the given amount, to the path dstPath. It returns
+ VG_TRUE if interpolation was successful (i.e., the paths had compatible segment
+ types after normalization), and VG_FALSE otherwise. If interpolation is
+ unsuccessful, dstPath is left unchanged. It is legal for dstPath to be a handle
+ to the same path object as either startPath or endPath or both, in which case
+ the contents of the source path or paths referenced by dstPath will have the
+ interpolated path appended. If dstPath is not the a handle to the same path
+ object as either startPath or endPath, the contents of startPath and endPath
+ will not be affected by the call.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if any of dstPath, startPath, or endPath is not a valid path handle, or is
+ not shared with the current context
+ VG_PATH_CAPABILITY_ERROR
+ if VG_PATH_CAPABILITY_INTERPOLATE_TO is not enabled for dstPath
+ if VG_PATH_CAPABILITY_INTERPOLATE_FROM is not enabled for startPath or endPath
+ */
+EXPORT_C VGboolean
+ vgInterpolatePath(VGPath dstPath,
+ VGPath startPath,
+ VGPath endPath,
+ VGfloat amount)
+ {
+ OPENVG_TRACE("vgInterpolatePath dstPath=0x%x, startPath=0x%x, endPath=0x%x, amount=%f",
+ dstPath, startPath, endPath, amount);
+
+ return TGuestOpenVg::vgInterpolatePath(dstPath, startPath, endPath, amount);
+ }
+
+/*
+ Returns the length of a given portion of a path in the user coordinate system
+ (that is, in the paths own coordinate system, disregarding any matrix
+ settings). Only the subpath consisting of the numSegments path segments beginning
+ with startSegment (where the initial path segment has index 0) is used. If an
+ error occurs, -1.0f is returned.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if path is not a valid path handle, or is not shared with the current context
+ VG_PATH_CAPABILITY_ERROR
+ if VG_PATH_CAPABILITY_PATH_LENGTH is not enabled for path
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if startSegment is less than 0 or greater than the index of the final path
+ segment
+ if numSegments is less than or equal to 0
+ if (startSegment + numSegments 1) is greater than the index of the final
+ path segment
+ */
+EXPORT_C VGfloat
+ vgPathLength(VGPath path,
+ VGint startSegment,
+ VGint numSegments)
+ {
+ OPENVG_TRACE("vgPathLength path=0x%x, startSegment=%d, numSegments=%d", path, startSegment, numSegments);
+
+ return TGuestOpenVg::vgPathLength(path, startSegment, numSegments);
+ }
+
+/*
+ Returns the current capabilities of the path, as a bitwise OR of
+ VGPathCapabilities constants. If an error occurs, 0 is returned.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if path is not a valid path handle, or is not shared with the current context
+ */
+EXPORT_C VGbitfield
+ vgGetPathCapabilities(VGPath path)
+ {
+ OPENVG_TRACE("vgGetPathCapabilities path=0x%x", path);
+
+ return TGuestOpenVg::vgGetPathCapabilities(path);
+ }
+
+/*
+ Create a new path that is ready to accept segment data and return a VGPath handle
+ to it. The path data will be formatted in the format given by pathFormat, typically
+ VG_PATH_FORMAT_STANDARD. The datatype parameter contains a value from the
+ VGPathDatatype enumeration indicating the datatype that will be used for coordinate
+ data. The capabilities argument is a bitwise OR of the desired VGPathCapabilities
+ values. Bits of capabilities that do not correspond to values from VGPathCapabilities
+ have no effect.
+
+ If an error occurs, VG_INVALID_HANDLE is returned.
+
+ ERRORS
+ VG_UNSUPPORTED_PATH_FORMAT_ERROR
+ if pathFormat is not a supported format
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if datatype is not a valid value from the VGPathDatatype enumeration
+ if scale is equal to 0
+ */
+EXPORT_C VGPath
+ vgCreatePath(VGint pathFormat,
+ VGPathDatatype datatype,
+ VGfloat scale, VGfloat bias,
+ VGint segmentCapacityHint,
+ VGint coordCapacityHint,
+ VGbitfield capabilities)
+ {
+ OPENVG_TRACE("vgCreatePath pathFormat=%d, datatype=0x%x, scale=%f, bias=%f, segCapHint=%d, coordCapHint=%d, caps=0x%x -->",
+ pathFormat, datatype, scale, bias, segmentCapacityHint, coordCapacityHint, capabilities);
+
+ VGPath pathHandle = TGuestOpenVg::vgCreatePath(pathFormat, datatype, scale, bias, segmentCapacityHint, coordCapacityHint, capabilities);
+ OPENVG_TRACE("vgCreatePath handle=0x%x <--", pathHandle);
+ return pathHandle;
+ }
+
+/*
+ The vgGet functions return the value of a parameter on the current context.
+ The original value passed to vgSet (except as specifically noted, and provided the call to
+ vgSet completed without error) is returned by vgGet, even if the implementation makes
+ use of a truncated or quantized value internally. This rule ensures that OpenVG state may
+ be saved and restored without degradation.
+
+ If an error occurs during a call to vgGetf, vgGeti, or vgGetVectorSize, the return value
+ is undefined.
+
+ ERRORS
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if paramType is not a valid value from the VGParamType enumeration
+ if paramType refers to a vector parameter in vgGetf or vgGeti
+ */
+EXPORT_C VGfloat
+ vgGetf(VGParamType type)
+ {
+ OPENVG_TRACE("vgGetf type=0x%x", type);
+
+ return TGuestOpenVg::vgGetf(type);
+ }
+
+/*
+ The vgGet functions return the value of a parameter on the current context.
+ The original value passed to vgSet (except as specifically noted, and provided the call to
+ vgSet completed without error) is returned by vgGet, even if the implementation makes
+ use of a truncated or quantized value internally. This rule ensures that OpenVG state may
+ be saved and restored without degradation.
+
+ If an error occurs during a call to vgGetf, vgGeti, or vgGetVectorSize, the return value
+ is undefined.
+
+ ERRORS
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if paramType is not a valid value from the VGParamType enumeration
+ if paramType refers to a vector parameter in vgGetf or vgGeti
+ */
+EXPORT_C VGint
+ vgGeti(VGParamType type)
+ {
+ OPENVG_TRACE("vgGeti type=0x%x", type);
+
+ return TGuestOpenVg::vgGeti(type);
+ }
+
+/*
+ The vgGetVectorSize function returns the maximum number of elements in the vector
+ that will be retrieved by the vgGetiv or vgGetfv functions if called with the given
+ paramType argument. For scalar values, 1 is returned. If vgGetiv or vgGetfv is
+ called with a smaller value for count than that returned by vgGetVectorSize,
+ only the first count elements of the vector are retrieved. Use of a greater value
+ for count will result in an error.
+ The original value passed to vgSet (except as specifically noted, and provided the call to
+ vgSet completed without error) is returned by vgGet, even if the implementation makes
+ use of a truncated or quantized value internally. This rule ensures that OpenVG state may
+ be saved and restored without degradation.
+ If an error occurs during a call to vgGetf, vgGeti, or vgGetVectorSize, the return value
+ is undefined.
+
+ ERRORS
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if paramType is not a valid value from the VGParamType enumeration
+ */
+EXPORT_C VGint
+ vgGetVectorSize(VGParamType type)
+ {
+ OPENVG_TRACE("vgGetVectorSize type=0x%x", type);
+
+ return TGuestOpenVg::vgGetVectorSize(type);
+ }
+
+/*
+ The vgGetParameter functions return the value of a parameter on a given VGHandlebased
+ object.
+
+ The original value passed to vgSetParameter (provided the call to
+ vgSetParameter completed without error) should be returned by
+ vgGetParameter (except where specifically noted), even if the implementation
+ makes use of a truncated or quantized value internally.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if object is not a valid handle, or is not shared with the current context
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if paramType is not a valid value from the appropriate enumeration
+ if paramType refers to a vector parameter in vgGetParameterf or
+ vgGetParameteri
+ */
+EXPORT_C VGfloat
+ vgGetParameterf(VGHandle object,
+ VGint paramType)
+ {
+ OPENVG_TRACE("vgGetParameterf object=0x%x, paramType=0x%x -->", object, paramType);
+
+ VGfloat value = TGuestOpenVg::vgGetParameterf(object, paramType);
+ OPENVG_TRACE("vgGetParameterf value=%f <--", value);
+ return value;
+ }
+
+/*
+ The vgGetParameterVectorSize function returns the number of elements in the vector
+ that will be returned by the vgGetParameteriv or vgGetParameterfv functions if called
+ with the given paramType argument. For scalar values, 1 is returned.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if object is not a valid handle, or is not shared with the current context
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if paramType is not a valid value from the appropriate enumeration
+ */
+EXPORT_C VGint
+ vgGetParameterVectorSize(VGHandle object,
+ VGint paramType)
+ {
+ OPENVG_TRACE("vgGetParameterVectorSize object=0x%x, paramType=0x%x -->", object, paramType);
+
+ VGint size = TGuestOpenVg::vgGetParameterVectorSize(object, paramType);
+ OPENVG_TRACE("vgGetParameterVectorSize size=%i <--", size);
+ return size;
+ }
+
+/*
+ Creates an object capable of storing a mask layer with the given width and
+ height and returns a VGMaskLayer handle to it. The mask layer is defined to
+ be compatible with the format and multisampling properties of the current
+ drawing surface. If there is no current drawing surface, no mask is
+ configured for the current drawing surface, or an error occurs,
+ VG_INVALID_HANDLE is returned. All mask layer values are initially set to one.
+
+ ERRORS
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if width or height are less than or equal to 0
+ if width is greater than VG_MAX_IMAGE_WIDTH
+ if height is greater than VG_MAX_IMAGE_HEIGHT
+ if width*height is greater than VG_MAX_IMAGE_PIXELS
+ */
+EXPORT_C VGMaskLayer
+ vgCreateMaskLayer(VGint width, VGint height)
+ {
+ OPENVG_TRACE("vgCreateMaskLayer width=%d, height=%d -->", width, height);
+
+ VGMaskLayer maskHandle = TGuestOpenVg::vgCreateMaskLayer(width, height);
+ OPENVG_TRACE("vgCreateMaskLayer handle=0x%x <--", maskHandle);
+ return maskHandle;
+ }
+
+/*
+ The current setting of the VG_PAINT_COLOR parameter on a given paint object may
+ be queried as a 32-bit non-premultiplied sRGBA_8888 value. Each color channel or
+ alpha value is clamped to the range [0, 1] , multiplied by 255, and rounded to obtain an
+ 8-bit integer; the resulting values are packed into a 32-bit value in the same format as for
+ vgSetColor.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if paint is not a valid paint handle, or is not shared with the current context
+ */
+EXPORT_C VGuint
+ vgGetColor(VGPaint paint)
+ {
+ OPENVG_TRACE("vgGetColor paint=0x%x", paint);
+
+ return TGuestOpenVg::vgGetColor(paint);
+ }
+
+/*
+ Creates an image with the given width, height, and pixel format and returns a
+ VGImage handle to it. If an error occurs, VG_INVALID_HANDLE is returned. All
+ color and alpha channel values are initially set to zero. The format parameter
+ must contain a value from the VGImageFormat enumeration.
+ The allowedQuality parameter is a bitwise OR of values from the
+ VGImageQuality enumeration, indicating which levels of resampling quality may be
+ used to draw the image. It is always possible to draw an image using the
+ VG_IMAGE_QUALITY_NONANTIALIASED quality setting even if it is not explicitly
+ specified.
+
+ ERRORS
+ VG_UNSUPPORTED_IMAGE_FORMAT_ERROR
+ if format is not a valid value from the VGImageFormat enumeration
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if width or height are less than or equal to 0
+ if width is greater than VG_MAX_IMAGE_WIDTH
+ if height is greater than VG_MAX_IMAGE_HEIGHT
+ if width*height is greater than VG_MAX_IMAGE_PIXELS
+ if width*height*(pixel size of format) is greater than
+ VG_MAX_IMAGE_BYTES
+ if allowedQuality is not a bitwise OR of values from the
+ VGImageQuality enumeration
+ */
+EXPORT_C VGImage
+ vgCreateImage(VGImageFormat format,
+ VGint width, VGint height,
+ VGbitfield allowedQuality)
+ {
+ OPENVG_TRACE("vgCreateImage format=0x%x, width=%d, height=%d, allowedQuality=0x%x -->",
+ format, width, height, allowedQuality);
+
+ VGImage imageHandle = TGuestOpenVg::vgCreateImage(format, width, height, allowedQuality);
+ OPENVG_TRACE("vgCreateImage handle=0x%x <--", imageHandle);
+ return imageHandle;
+ }
+
+/*
+ Returns a new VGImage handle that refers to a portion of the parent image. The
+ region is given by the intersection of the bounds of the parent image with the
+ rectangle beginning at pixel (x, y) with dimensions width and height, which
+ must define a positive region contained entirely within parent.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if parent is not a valid image handle, or is not shared with the current
+ context
+ VG_IMAGE_IN_USE_ERROR
+ if parent is currently a rendering target
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if x is less than 0 or greater than or equal to the parent width
+ if y is less than 0 or greater than or equal to the parent height
+ if width or height is less than or equal to 0
+ if x + width is greater than the parent width
+ if y + height is greater than the parent height
+ */
+EXPORT_C VGImage
+ vgChildImage(VGImage parent,
+ VGint x, VGint y,
+ VGint width, VGint height)
+ {
+ OPENVG_TRACE("vgChildImage parent=oc%x, x=%d, y=%d, width=%d, height=%d -->",
+ parent, x, y, width, height);
+
+ VGImage imageHandle = TGuestOpenVg::vgChildImage(parent, x, y, width, height);
+ OPENVG_TRACE("vgChildImage handle=0x%x <--", imageHandle);
+ return imageHandle;
+ }
+
+/*
+ Returns the closest valid ancestor (i.e., one that has not been the target of
+ a vgDestroyImage call) of the given image. If image has no ancestors, image is
+ returned.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if image is not a valid image handle, or is not shared with the current
+ context
+ VG_IMAGE_IN_USE_ERROR
+ if image is currently a rendering target
+ */
+EXPORT_C VGImage vgGetParent(VGImage image)
+ {
+ OPENVG_TRACE("vgGetParent image=0x%x", image);
+
+ return TGuestOpenVg::vgGetParent(image);
+ }
+
+/*
+ Creates a new font object and returns a VGFont handle to it. The glyphCapacityHint
+ argument provides a hint as to the capacity of a VGFont, i.e., the total number of
+ glyphs that this VGFont object will be required to accept. A value of 0 indicates that
+ the value is unknown. If an error occurs during execution, VG_INVALID_HANDLE is returned.
+
+ ERRORS
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if glyphCapacityHint is negative
+ */
+EXPORT_C VGFont vgCreateFont(VGint glyphCapacityHint)
+ {
+ OPENVG_TRACE("vgCreateFont glyphCapacityHint=%d -->", glyphCapacityHint);
+
+ VGFont fontHandle = TGuestOpenVg::vgCreateFont(glyphCapacityHint);
+ OPENVG_TRACE("vgCreateFont handle=0x%x <--", fontHandle);
+ return fontHandle;
+ }
+
+/* Hardware Queries */
+
+/*
+ Returns a value indicating whether a given setting of a property of a type given
+ by key is generally accelerated in hardware on the currently running OpenVG
+ implementation.
+
+ ERRORS
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if key is not one of the values from the VGHardwareQueryType enumeration
+ if setting is not one of the values from the enumeration associated with
+ key
+ */
+EXPORT_C VGHardwareQueryResult
+ vgHardwareQuery
+ (VGHardwareQueryType key,
+ VGint setting)
+ {
+ OPENVG_TRACE("vgHardwareQuery key=0x%x, setting=%d", key, setting);
+
+ return TGuestOpenVg::vgHardwareQuery(key, setting);
+ }
+
+/*
+ The vgGetString function returns information about the OpenVG implementation,
+ including extension information. The values returned may vary according to
+ the display (e.g., the EGLDisplay when using EGL) associated with the current
+ context.
+
+ Returns NULL if no context is current.
+ */
+EXPORT_C const VGubyte *
+ vgGetString(VGStringID name)
+ {
+ OPENVG_TRACE("vgGetString name=0x%x", name);
+
+ switch (name)
+ {
+ case VG_VENDOR:
+ return (const VGubyte *)"Nokia";
+ case VG_RENDERER:
+ return (const VGubyte *)"Guest 1.0";
+ case VG_VERSION:
+ return (const VGubyte *)"1.1";
+ case VG_EXTENSIONS: // supported VG extensions, (associated function addresses are fetched with eglGetProcAddress)
+ return (const VGubyte *)"VG_KHR_EGL_image";
+ }
+ return (const VGubyte *)NULL;
+ }
+
+/*
+ The vgGetParameter functions return the value of a parameter on a given VGHandlebased
+ object.
+
+ If vgGetParameteriv or vgGetParameterfv is called with a smaller value for
+ count than that returned by vgGetParameterVectorSize, only the first count
+ elements of the vector are retrieved. Use of a greater value for count will result
+ in an error.
+
+ The original value passed to vgSetParameter (provided the call to
+ vgSetParameter completed without error) should be returned by
+ vgGetParameter (except where specifically noted), even if the implementation
+ makes use of a truncated or quantized value internally.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if object is not a valid handle, or is not shared with the current context
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if paramType is not a valid value from the appropriate enumeration
+ if values is NULL in vgGetParameterfv or vgGetParameteriv
+ if values is not properly aligned in vgGetParameterfv or vgGetParameteriv
+ if count is less than or equal to 0 in vgGetParameterfv or vgGetParameteriv
+ if count is greater than the value returned by vgGetParameterVectorSize for
+ the given parameter in vgGetParameterfv or vgGetParameteriv
+ */
+EXPORT_C void
+ vgGetParameterfv(VGHandle object,
+ VGint paramType,
+ VGint count,
+ VGfloat * values)
+ {
+ OPENVG_TRACE("vgGetParameterfv object=0x%x, paramType=0x%x, count=%d, values=0x%x",
+ object, paramType, count, values);
+
+ TGuestOpenVg::vgGetParameterfv(object, paramType, count, values);
+ }
+
+EXPORT_C void
+ vgGetParameteriv(VGHandle object,
+ VGint paramType,
+ VGint count,
+ VGint * values)
+ {
+ OPENVG_TRACE("vgGetParameteriv object=0x%x, paramType=0x%x, count=%d, values=0x%x",
+ object, paramType, count, values);
+
+ TGuestOpenVg::vgGetParameteriv(object, paramType, count, values);
+ }
+
+/* Renderer and Extension Information */
+
+/*
+The vgGetVectorSize function returns the maximum number of elements in the vector
+that will be retrieved by the vgGetiv or vgGetfv functions if called with the given
+paramType argument. For scalar values, 1 is returned. If vgGetiv or vgGetfv is
+called with a smaller value for count than that returned by vgGetVectorSize,
+only the first count elements of the vector are retrieved. Use of a greater value
+for count will result in an error.
+The original value passed to vgSet (except as specifically noted, and provided the call to
+vgSet completed without error) is returned by vgGet, even if the implementation makes
+use of a truncated or quantized value internally. This rule ensures that OpenVG state may
+be saved and restored without degradation.
+If an error occurs during a call to vgGetfv or vgGetiv, nothing is
+written to values.
+
+ERRORS
+VG_ILLEGAL_ARGUMENT_ERROR
+ if paramType is not a valid value from the VGParamType enumeration
+ if values is NULL in vgGetfv or vgGetiv
+ if values is not properly aligned in vgGetfv or vgGetiv
+ if count is less than or equal to 0 in vgGetfv or vgGetiv
+ if count is greater than the value returned by vgGetVectorSize for the
+given parameter in vgGetfv or vgGetiv
+ */
+EXPORT_C void
+ vgGetfv(VGParamType type, VGint count,
+ VGfloat * values)
+ {
+ OPENVG_TRACE("vgGetfv type=0x%x, count=%d, values=0x%x", type, count, values);
+
+ TGuestOpenVg::vgGetfv(type, count, values);
+ }
+
+EXPORT_C void
+ vgGetiv(VGParamType type, VGint count,
+ VGint * values)
+ {
+ OPENVG_TRACE("vgGetiv type=0x%x, count=%d, values=0x%x", type, count, values);
+
+ TGuestOpenVg::vgGetiv(type, count, values);
+ }
+
+/*
+ Retrieve the value of the current transformation.
+ Nine values are written to m in the order:
+ { sx, shy, w0, shx, sy, w1, tx, ty, w2 }
+ For an affine matrix, w0 and w1 will always be 0 and w2 will always be 1.
+
+ ERRORS
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if m is NULL
+ if m is not properly aligned
+ */
+EXPORT_C void
+ vgGetMatrix(VGfloat * m)
+ {
+ OPENVG_TRACE("vgGetMatrix m=0x%x", m);
+
+ TGuestOpenVg::vgGetMatrix(m);
+ }
+
+/*
+ Read pixel values from a rectangular portion of an image, performs format conversion
+ if necessary, and stores the resulting pixels into memory.
+
+ Pixel values are written starting at the address given by the pointer data; adjacent
+ scanlines are separated by dataStride bytes. Negative or zero values of
+ dataStride are allowed. The region to be read is given by x, y, width, and
+ height, which must define a positive region. Pixels that fall outside the bounds
+ of the image are ignored.
+ Pixel values in memory are formatted according to the dataFormat parameter, which
+ must contain a value from the VGImageFormat enumeration. If dataFormat
+ specifies a premultiplied format (VG_sRGBA_8888_PRE or VG_lRGBA_8888_PRE),
+ color channel values of a pixel that are greater than their corresponding alpha value are
+ clamped to the range [0, alpha]. The data pointer alignment and the pixel layout in
+ memory are as described in the vgImageSubData section.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if image is not a valid image handle, or is not shared with the current context
+ VG_IMAGE_IN_USE_ERROR
+ if image is currently a rendering target
+ VG_UNSUPPORTED_IMAGE_FORMAT_ERROR
+ if dataFormat is not a valid value from the VGImageFormat enumeration
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if width or height is less than or equal to 0
+ if data is NULL
+ if data is not properly aligned
+ */
+EXPORT_C void
+ vgGetImageSubData(VGImage image,
+ void * data,
+ VGint dataStride,
+ VGImageFormat dataFormat,
+ VGint x, VGint y,
+ VGint width, VGint height)
+ {
+ OPENVG_TRACE("vgGetImageSubData image=0x%x, data=0x%x, dataStride=%d, dataFormat=0x%x, x=%d, y=%d, width=%d, height=%d",
+ image, data, dataStride, dataFormat, x, y, width, height);
+
+ TGuestOpenVg::vgGetImageSubData(image, data, dataStride, dataFormat, x, y, width, height);
+ }
+
+/*
+ Copy pixel data from the drawing surface without the creation of a VGImage object.
+ Pixel values are written starting at the address given by the pointer data; adjacent
+ scanlines are separated by dataStride bytes. Negative or zero values of
+ dataStride are allowed. The region to be read is given by x, y, width, and
+ height, which must define a positive region.
+
+ Pixel values in memory are formatted according to the dataFormat parameter, which
+ must contain a value from the VGImageFormat enumeration. The data pointer
+ alignment and the pixel layout in memory is as described for vgImageSubData.
+
+ Pixels whose source lies outside of the bounds of the drawing surface are
+ ignored. Pixel format conversion is applied as needed. The scissoring region
+ does not affect the reading of pixels.
+
+ ERRORS
+ VG_UNSUPPORTED_IMAGE_FORMAT_ERROR
+ if dataFormat is not a valid value from the VGImageFormat enumeration
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if width or height is less than or equal to 0
+ if data is NULL
+ if data is not properly aligned
+ */
+EXPORT_C void
+ vgReadPixels(void * data, VGint dataStride,
+ VGImageFormat dataFormat,
+ VGint sx, VGint sy,
+ VGint width, VGint height)
+ {
+ OPENVG_TRACE("vgReadPixels data=0x%x, dataStride=%d, dataFormat=0x%x, sx=%d, sy=%d, width=%d, height=%d",
+ data, dataStride, dataFormat, sx, sy, width, height);
+
+ TGuestOpenVg::vgReadPixels(data, dataStride, dataFormat, sx, sy, width, height);
+ }
+
+/*
+ Returns an axis-aligned bounding box that tightly bounds the interior of the given
+ path. Stroking parameters are ignored. If path is empty, minX and minY are set to 0
+ and width and height are set to -1. If path contains a single point, minX and minY
+ are set to the coordinates of the point and width and height are set to 0.
+
+ The VG_PATH_CAPABILITY_PATH_BOUNDS capability must be enabled for path.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if path is not a valid path handle, or is not shared with the current context
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if minX, minY, width, or height is NULL
+ if minX, minY, width, or height is not properly aligned
+ VG_PATH_CAPABILITY_ERROR
+ if VG_PATH_CAPABILITY_PATH_BOUNDS is not enabled for path
+ */
+EXPORT_C void
+ vgPathBounds(VGPath path,
+ VGfloat * minX,
+ VGfloat * minY,
+ VGfloat * width,
+ VGfloat * height)
+ {
+ OPENVG_TRACE("vgPathBounds path=0x%x, minX=0x%x, minY=0x%x, width=0x%x, height=0x%x",
+ path, minX, minY, width, height);
+
+ TGuestOpenVg::vgPathBounds(path, minX, minY, width, height);
+ }
+
+/*
+ The vgPathTransformedBounds function returns an axis-aligned bounding box
+ that is guaranteed to enclose the geometry of the given path following
+ transformation by the current path-user-to-surface transform. The returned
+ bounding box is not guaranteed to fit tightly around the path geometry. If path
+ is empty, minX and minY are set to 0 and width and height are set to -1. If
+ path contains a single point, minX and minY are set to the transformed
+ coordinates of the point and width and height are set to 0.
+ The VG_PATH_CAPABILITY_PATH_TRANSFORMED_BOUNDS capability must be
+ enabled for path.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if path is not a valid path handle, or is not shared with the current context
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if minX, minY, width, or height is NULL
+ if minX, minY, width, or height is not properly aligned
+ VG_PATH_CAPABILITY_ERROR
+ if VG_PATH_CAPABILITY_PATH_TRANSFORMED_BOUNDS is not enabled
+ for path
+ */
+EXPORT_C void
+ vgPathTransformedBounds(VGPath path,
+ VGfloat * minX,
+ VGfloat * minY,
+ VGfloat * width,
+ VGfloat * height)
+ {
+ OPENVG_TRACE("vgPathTransformedBounds path=0x%x, minX=0x%x, minY=0x%x, width=0x%x, height=0x%x",
+ path, minX, minY, width, height);
+
+ TGuestOpenVg::vgPathTransformedBounds(path, minX, minY, width, height);
+ }
+
+////////////////////////////////////////////////////////////////////////////////////////////
+//Syncing methods
+////////////////////////////////////////////////////////////////////////////////////////////
+
+/*
+ Ensures that all outstanding requests on the current context will complete in finite time.
+ vgFlush may return prior to the actual completion of all requests.
+ */
+EXPORT_C void
+ vgFlush(void)
+ {
+ // ToDo comment
+ OPENVG_TRACE("vgFlush");
+
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if (vgContext)
+ {
+ vgContext->ExecuteVgFlushCommand();
+ }
+ }
+
+/*
+ The vgFinish function forces all outstanding requests on the current context to
+ complete, returning only when the last request has completed.
+ */
+EXPORT_C void
+ vgFinish(void)
+ {
+ // ToDo comment
+ OPENVG_TRACE("vgFinish");
+
+ MVgContext* vgContext = CVghwUtils::VgContext();
+ if (vgContext)
+ {
+ vgContext->ExecuteVgFinishCommand();
+ }
+ }
+
+////////////////////////////////////////////////////////////////////////////////////////////
+//Functions not returning value (possible to buffer)
+////////////////////////////////////////////////////////////////////////////////////////////
+/* Getters and Setters */
+
+/*
+ The vgSet functions set the value of a parameter on the current context.
+
+ ERRORS
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if paramType is not a valid value from the VGParamType enumeration
+ if paramType refers to a vector parameter in vgSetf or vgSeti
+ if value is not a legal enumerated value for the given parameter in vgSetf or
+ vgSeti
+ */
+EXPORT_C void
+ vgSetf (VGParamType type, VGfloat value)
+ {
+ OPENVG_TRACE("vgSetf type=0x%x, value=%f", type, value);
+
+ TGuestOpenVg::vgSetf(type, value);
+ }
+
+EXPORT_C void
+ vgSeti (VGParamType type, VGint value)
+ {
+ OPENVG_TRACE("vgSeti type=0x%x, value=%d", type, value);
+
+ TGuestOpenVg::vgSeti(type, value);
+ }
+
+/*
+ The vgSet functions set the value of a parameter on the current context.
+
+ ERRORS
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if paramType is not a valid value from the VGParamType enumeration
+ if paramType refers to a scalar parameter in vgSetfv or vgSetiv and count is
+ not equal to 1
+ if values[i] is not a legal enumerated value for the given parameter in vgSetfv
+ or vgSetiv for 0 <= i < count
+ if values is NULL in vgSetfv or vgSetiv and count is greater than 0
+ if values is not properly aligned in vgSetfv or vgSetiv
+ if count is less than 0 in vgSetfv or vgSetiv
+ if count is not a valid value for the given parameter
+ */
+EXPORT_C void
+ vgSetfv(VGParamType type, VGint count,
+ const VGfloat * values)
+ {
+ OPENVG_TRACE("vgSetfv type=0x%x, count=%d, values=0x%x", type, count, values);
+
+ TGuestOpenVg::vgSetfv(type, count, values);
+ }
+
+EXPORT_C void
+ vgSetiv(VGParamType type, VGint count,
+ const VGint * values)
+ {
+ OPENVG_TRACE("vgSetiv type=0x%x, count=%d, values=0x%x", type, count, values);
+
+ TGuestOpenVg::vgSetiv(type, count, values);
+ }
+
+/*
+ For vgSetParameterf and vgSetParameteri.
+
+ The vgSetParameter functions set the value of a parameter on a given VGHandlebased
+ object.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if object is not a valid handle, or is not shared with the current context
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if paramType is not a valid value from the appropriate enumeration
+ if paramType refers to a vector parameter in vgSetParameterf or
+ vgSetParameteri
+ if value is not a legal enumerated value for the given parameter in
+ vgSetParameterf or vgSetParameteri
+ */
+EXPORT_C void
+ vgSetParameterf(VGHandle object,
+ VGint paramType,
+ VGfloat value)
+ {
+ OPENVG_TRACE("vgSetParameterf object=0x%x, paramType=0x%x, value=%f -->", object, paramType, value);
+
+ TGuestOpenVg::vgSetParameterf(object, paramType, value);
+ }
+
+EXPORT_C void
+ vgSetParameteri(VGHandle object,
+ VGint paramType,
+ VGint value)
+ {
+ OPENVG_TRACE("vgSetParameteri object=0x%x, paramType=0x%x, value=0x%x", object, paramType, value);
+
+ TGuestOpenVg::vgSetParameteri(object, paramType, value);
+ }
+
+/*
+ For vgSetParameterfv and vgSetParameteriv.
+
+ The vgSetParameter functions set the value of a parameter on a given VGHandlebased
+ object.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if object is not a valid handle, or is not shared with the current context
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if paramType is not a valid value from the appropriate enumeration
+ if paramType refers to a scalar parameter in vgSetParameterfv or
+ vgSetParameteriv and count is not equal to 1
+ if values[i] is not a legal enumerated value for the given parameter
+ in vgSetParameterfv or vgSetParameteriv for 0 <= i < count
+ if values is NULL in vgSetParameterfv or vgSetParameteriv and count is
+ greater than 0
+ if values is not properly aligned in vgSetParameterfv or vgSetParameteriv
+ if count is less than 0 in vgSetParameterfv or vgSetParameteriv
+ if count is not a valid value for the given parameter
+ */
+EXPORT_C void
+ vgSetParameterfv(VGHandle object,
+ VGint paramType,
+ VGint count,
+ const VGfloat * values)
+ {
+ OPENVG_TRACE("vgSetParameterfv object=0x%x, paramType=%d, count=%d, values=0x%x", object, paramType, count, values);
+
+ TGuestOpenVg::vgSetParameterfv(object, paramType, count, values);
+ }
+
+EXPORT_C void
+ vgSetParameteriv(VGHandle object,
+ VGint paramType,
+ VGint count,
+ const VGint * values)
+ {
+ OPENVG_TRACE("vgSetParameteriv object=0x%x, paramType=%d, count=%d, values=0x%x", object, paramType, count, values);
+
+ TGuestOpenVg::vgSetParameteriv(object, paramType, count, values);
+ }
+
+/* Matrix Manipulation */
+
+/*
+ Sets the current matrix M to the identity matrix:
+ */
+EXPORT_C void
+ vgLoadIdentity(void)
+ {
+ OPENVG_TRACE("vgLoadIdentity");
+
+ TGuestOpenVg::vgLoadIdentity();
+ }
+
+/*
+ Loads an arbitrary set of matrix values into the current
+ matrix. Nine matrix values are read from m, in the order:
+ { sx, shy, w0, shx, sy, w1, tx, ty, w2 }
+ However, if the targeted matrix is affine (i.e., the matrix mode is not
+ VG_MATRIX_IMAGE_USER_TO_SURFACE), the values { w0, w1, w2 } are ignored and
+ replaced by the values { 0, 0, 1 }.
+
+ ERRORS
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if m is NULL
+ if m is not properly aligned
+ */
+EXPORT_C void
+ vgLoadMatrix(const VGfloat * m)
+ {
+ OPENVG_TRACE("vgLoadMatrix m=0x%x", m);
+
+ TGuestOpenVg::vgLoadMatrix(m);
+ }
+
+/*
+ Right-multiplies the current matrix M by a given matrix:
+ Nine matrix values are read from m in the order:
+ { sx, shy, w0, shx, sy, w1, tx, ty, w2 }
+ and the current matrix is multiplied by the resulting matrix. However, if the
+ targeted matrix is affine (i.e., the matrix mode is not
+ VG_MATRIX_IMAGE_USER_TO_SURFACE), the values { w0, w1, w2 } are ignored
+ and replaced by the values { 0, 0, 1 } prior to multiplication.
+
+ ERRORS
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if m is NULL
+ if m is not properly aligned
+ */
+EXPORT_C void
+ vgMultMatrix(const VGfloat * m)
+ {
+ OPENVG_TRACE("vgMultMatrix m=0x%x", m);
+
+ TGuestOpenVg::vgMultMatrix(m);
+ }
+
+/*
+ Modifies the current transformation by appending a translation. This is equivalent
+ to right-multiplying the current matrix M by a translation matrix:
+ [ 1 0 tx ]
+ [ 0 1 ty ]
+ [ 0 0 1 ]
+ */
+EXPORT_C void
+ vgTranslate(VGfloat tx, VGfloat ty)
+ {
+ OPENVG_TRACE("vgTranslate tx=%f, ty=%f", tx, ty);
+
+ TGuestOpenVg::vgTranslate(tx, ty);
+ }
+
+/*
+ Modifies the current transformation by appending a scale. This is equivalent to
+ right-multiplying the current matrix M by a scale matrix:
+ [ sx 0 0 ]
+ [ 0 sy 0 ]
+ [ 0 0 1 ]
+ */
+EXPORT_C void
+ vgScale(VGfloat sx, VGfloat sy)
+ {
+ OPENVG_TRACE("vgScale sx=%f, sy=%f", sx, sy);
+
+ TGuestOpenVg::vgScale(sx, sy);
+ }
+
+/*
+ Modifies the current transformation by appending a shear. This is equivalent to
+ right-multiplying the current matrix M by a shear matrix:
+ [ 1 shx 0 ]
+ [ shy 1 0 ]
+ [ 0 0 1 ]
+ */
+EXPORT_C void
+ vgShear(VGfloat shx, VGfloat shy)
+ {
+ OPENVG_TRACE("vgShear shx=%f, shy=%f", shx, shy);
+
+ TGuestOpenVg::vgShear(shx, shy);
+ }
+
+/*
+ Modifies the current transformation by appending a counterclockwise rotation by a given
+ angle (expressed in degrees) about the origin. This is equivalent to right-multiplying
+ the current matrix M by the following matrix (using the symbol a to represent the value
+ of the angle parameter):
+ [ cos(a) -sin(a) 0 ]
+ [ sin(a) cos(a) 0 ]
+ [ 0 0 1 ]
+ */
+EXPORT_C void
+ vgRotate(VGfloat angle)
+ {
+ OPENVG_TRACE("vgRotate angle=%f");
+
+ TGuestOpenVg::vgRotate(angle);
+ }
+
+/*
+ Modifies the drawing surface mask values according to a given operation, possibly
+ using coverage values taken from a mask layer or bitmap image given by the mask
+ parameter. If no mask is configured for the current drawing surface, vgMask has
+ no effect.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if operation is not VG_CLEAR_MASK or VG_FILL_MASK, and mask is not a
+ valid mask layer or image handle, or is not shared with the current context
+ VG_IMAGE_IN_USE_ERROR
+ if mask is a VGImage that is currently a rendering target
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if operation is not a valid value from the VGMaskOperation
+ enumeration
+ if width or height is less than or equal to 0
+ if mask is a VGMaskLayer and is not compatible with the current surface
+ mask
+ */
+EXPORT_C void
+ vgMask(VGHandle mask, VGMaskOperation operation,
+ VGint x, VGint y,
+ VGint width, VGint height)
+ {
+ OPENVG_TRACE("vgMask mask=0x%x, operation=0x%x, x=%d, y=%d, width=%d, height=%d",
+ mask, operation, x, y, width, height);
+
+ TGuestOpenVg::vgMask(mask, operation, x, y, width, height);
+ }
+
+/*
+ Modifies the current surface mask by applying the given operation to the set of
+ coverage values associated with the rendering of the given path. If paintModes
+ contains VG_FILL_PATH, the path is filled; if it contains VG_STROKE_PATH, the path
+ is stroked. If both are present, the mask operation is performed in two passes,
+ first on the filled path geometry, then on the stroked path geometry.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if path is not a valid path handle
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if paintModes is not a valid bitwise OR of values from the VGPaintMode
+ enumeration
+ if operation is not a valid value from the VGMaskOperation enumeration
+ */
+EXPORT_C void
+ vgRenderToMask(VGPath path,
+ VGbitfield paintModes,
+ VGMaskOperation operation)
+ {
+ OPENVG_TRACE("vgRenderToMask path=0x%x, paintModes=0x%x, operation=0x%x", path, paintModes, operation);
+
+ TGuestOpenVg::vgRenderToMask(path, paintModes, operation);
+ }
+
+/*
+ Deallocate the resources associated with a mask layer. Following the call,
+ the maskLayer handle is no longer valid in the current context.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if maskLayer is not a valid mask handle
+ */
+EXPORT_C void vgDestroyMaskLayer(VGMaskLayer maskLayer)
+ {
+ OPENVG_TRACE("vgDestroyMaskLayer maskLayer=0x%x", maskLayer);
+
+ TGuestOpenVg::vgDestroyMaskLayer(maskLayer);
+ }
+
+/*
+ Set the values of a given maskLayer within a given rectangular region to a given
+ value. The floating-point value value must be between 0 and 1. The value is rounded
+ to the closest available value supported by the mask layer. If two values are equally
+ close, the larger value is used.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if maskLayer is not a valid mask layer handle, or is not shared with the
+ current context
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if value is less than 0 or greater than 1
+ if width or height is less than or equal to 0
+ if x or y is less than 0
+ if x + width is greater than the width of the mask
+ if y + height is greater than the height of the mask
+ */
+EXPORT_C void
+ vgFillMaskLayer(VGMaskLayer maskLayer,
+ VGint x, VGint y,
+ VGint width, VGint height,
+ VGfloat value)
+ {
+ OPENVG_TRACE("vgFillMaskLayer maskLayer=0x%x, x=%d, y=%d, width=%d, height=%d, value=%f",
+ maskLayer, x, y, width, height, value);
+
+ TGuestOpenVg::vgFillMaskLayer(maskLayer, x, y, width, height, value);
+ }
+
+/*
+ Copies a portion of the current surface mask into a VGMaskLayer object. The source
+ region starts at (sx, sy) in the surface mask, and the destination region starts
+ at (dx, dy) in the destination maskLayer. The copied region is clipped to the given
+ width and height and the bounds of the source and destination. If the current context
+ does not contain a surface mask, vgCopyMask does nothing.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if maskLayer is not a valid mask layer handle
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if width or height are less than or equal to 0
+ if maskLayer is not compatible with the current surface mask
+ */
+EXPORT_C void
+ vgCopyMask(VGMaskLayer maskLayer,
+ VGint sx, VGint sy,
+ VGint dx, VGint dy,
+ VGint width, VGint height)
+ {
+ OPENVG_TRACE("vgCopyMask maskLayer=0x%x, sx=%d, sy=%d, dx=%d, dy=%d, width=%d, height=%d",
+ maskLayer, sx, sy, dx, dy, width, height);
+
+ TGuestOpenVg::vgCopyMask(maskLayer, sx, sy, dx, dy, width, height);
+ }
+
+/*
+ Fills the portion of the drawing surface intersecting the rectangle extending from
+ pixel (x, y) and having the given width and height with a constant color value, taken
+ from the VG_CLEAR_COLOR parameter. The color value is expressed in non-premultiplied
+ sRGBA (sRGB color plus alpha)format. Values outside the [0, 1] range are interpreted
+ as the nearest endpoint of the range. The color is converted to the destination color
+ space in the same manner as if a rectangular path were being filled. Clipping and
+ scissoring take place in the usual fashion, but antialiasing, masking, and blending
+ do not occur.
+
+ ERRORS
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if width or height is less than or equal to 0
+ */
+EXPORT_C void
+ vgClear(VGint x, VGint y,
+ VGint width, VGint height)
+ {
+ OPENVG_TRACE("vgClear x=%d, y=%d, width=%d, height=%d", x, y, width, height);
+
+ TGuestOpenVg::vgClear(x, y, width, height);
+ }
+
+
+/* Paths */
+
+/*
+ Remove all segment command and coordinate data associated with a path. The handle
+ continues to be valid for use in the future, and the path format and datatype retain
+ their existing values. The capabilities argument is a bitwise OR of the desired
+ VGPathCapabilities values. Bits of capabilities that do not correspond to values from
+ VGPathCapabilities have no effect. Using vgClearPath may be more efficient than
+ destroying and re-creating a path for short-lived paths.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if path is not a valid path handle, or is not shared with the current context
+ */
+EXPORT_C void
+ vgClearPath(VGPath path, VGbitfield capabilities)
+ {
+ OPENVG_TRACE("vgClearPath path=0x%x, capabilities=0x%x", path, capabilities);
+
+ TGuestOpenVg::vgClearPath(path, capabilities);
+ }
+
+/*
+ Release any resources associated with path, and makes the handle invalid in all
+ contexts that shared it.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if path is not a valid path handle, or is not shared with the current context
+ */
+EXPORT_C void vgDestroyPath(VGPath path)
+ {
+ OPENVG_TRACE("vgDestroyPath path=0x%x", path);
+
+ TGuestOpenVg::vgDestroyPath(path);
+ }
+
+/*
+ Requests the set of capabilities specified in the capabilities argument to
+ be disabled for the given path. The capabilities argument is a bitwise OR of
+ the VGPathCapabilities values whose removal is requested. Attempting to
+ remove a capability that is already disabled has no effect. Bits of
+ capabilities that do not correspond to values from VGPathCapabilities have
+ no effect.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if path is not a valid path handle, or is not shared with the current context
+ */
+EXPORT_C void
+ vgRemovePathCapabilities(VGPath path,
+ VGbitfield capabilities)
+ {
+ OPENVG_TRACE("vgRemovePathCapabilities path=0x%x, capabilities=0x%x", path, capabilities);
+
+ TGuestOpenVg::vgRemovePathCapabilities(path, capabilities);
+ }
+
+/*
+ Appends a copy of all path segments from srcPath onto the end of the existing
+ data in dstPath. It is legal for srcPath and dstPath to be handles to the same
+ path object, in which case the contents of the path are duplicated. If srcPath
+ and dstPath are handles to distinct path objects, the contents of srcPath will
+ not be affected by the call.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if either dstPath or srcPath is not a valid path handle, or is not shared
+ with the current context
+ VG_PATH_CAPABILITY_ERROR
+ if VG_PATH_CAPABILITY_APPEND_FROM is not enabled for srcPath
+ if VG_PATH_CAPABILITY_APPEND_TO is not enabled for dstPath
+ */
+EXPORT_C void
+ vgAppendPath(VGPath dstPath, VGPath srcPath)
+ {
+ OPENVG_TRACE("vgAppendPath dstPath=0x%x, srcPath=0x%x", dstPath, srcPath);
+
+ TGuestOpenVg::vgAppendPath(dstPath, srcPath);
+ }
+
+/*
+ Appends data taken from pathData to the given path dstPath. The data are formatted
+ using the path format of dstPath (as returned by querying the paths VG_PATH_FORMAT
+ parameter using vgGetParameteri). The numSegments parameter gives the total number
+ of entries in the pathSegments array, and must be greater than 0. Legal values for
+ the pathSegments array are the values from the VGPathCommand enumeration as well as
+ VG_CLOSE_PATH and (VG_CLOSE_PATH | VG_RELATIVE) (which are synonymous).
+
+ The pathData pointer must be aligned on a 1-, 2-, or 4-byte boundary (as defined in
+ the Bytes column of Open VG spec Table 7) depending on the size of the coordinate
+ datatype (as returned by querying the paths VG_PATH_DATATYPE parameter using
+ vgGetParameteri). The VG_PATH_CAPABILITY_APPEND_TO capability must be enabled for
+ path.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if dstPath is not a valid path handle, or is not shared with the current
+ context
+ VG_PATH_CAPABILITY_ERROR
+ if VG_PATH_CAPABILITY_APPEND_TO is not enabled for dstPath
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if pathSegments or pathData is NULL
+ if pathData is not properly aligned
+ if numSegments is less than or equal to 0
+ if pathSegments contains an illegal command
+ */
+EXPORT_C void
+ vgAppendPathData(VGPath dstPath,
+ VGint numSegments,
+ const VGubyte * pathSegments,
+ const void * pathData)
+ {
+ OPENVG_TRACE("vgAppendPathData dstPath=0x%x, numSegments=%d, pathSegments=0x%x, pathData=0x%x",
+ dstPath, numSegments, pathSegments, pathData);
+
+ TGuestOpenVg::vgAppendPathData(dstPath, numSegments, pathSegments, pathData);
+ }
+
+/*
+ Modifies the coordinate data for a contiguous range of segments of dstPath, starting
+ at startIndex (where 0 is the index of the first path segment) and having length
+ numSegments. The data in pathData must be formatted in exactly the same manner as the
+ original coordinate data for the given segment range, unless the path has been
+ transformed using vgTransformPath or interpolated using vgInterpolatePath. In these
+ cases, the path will have been subject to the segment promotion rules specified in
+ those functions.
+
+ The pathData pointer must be aligned on a 1-, 2-, or 4-byte boundary
+ depending on the size of the coordinate datatype (as returned by querying the
+ paths VG_PATH_DATATYPE parameter using vgGetParameteri). The
+ VG_PATH_CAPABILITY_MODIFY capability must be enabled for path.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if dstPath is not a valid path handle, or is not shared with the current
+ context
+ VG_PATH_CAPABILITY_ERROR
+ if VG_PATH_CAPABILITY_MODIFY is not enabled for dstPath
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if pathData is NULL
+ if pathData is not properly aligned
+ if startIndex is less than 0
+ if numSegments is less than or equal to 0
+ if startIndex + numSegments is greater than the number of segments in the path
+ */
+EXPORT_C void
+ vgModifyPathCoords(VGPath dstPath,
+ VGint startIndex,
+ VGint numSegments,
+ const void * pathData)
+ {
+ OPENVG_TRACE("vgModifyPathCoords dstPath=0x%x, startIndex=%d, numSegments=%d, pathData=0x%x",
+ dstPath, startIndex, numSegments, pathData);
+
+ TGuestOpenVg::vgModifyPathCoords(dstPath, startIndex, numSegments, pathData);
+ }
+
+/*
+ Appends a transformed copy of srcPath to the current contents of dstPath.
+ The appended path is equivalent to the results of applying the current
+ pathuser-to-surface transformation (VG_MATRIX_PATH_USER_TO_SURFACE) to srcPath.
+
+ It is legal for srcPath and dstPath to be handles to the same path object, in
+ which case the transformed path will be appended to the existing path. If
+ srcPath and dstPath are handles to distinct path objects, the contents of
+ srcPath will not be affected by the call.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if either dstPath or srcPath is not a valid path handle, or is not shared with
+ the current context
+ VG_PATH_CAPABILITY_ERROR
+ if VG_PATH_CAPABILITY_TRANSFORM_FROM is not enabled for srcPath
+ if VG_PATH_CAPABILITY_TRANSFORM_TO is not enabled for dstPath
+ */
+EXPORT_C void
+ vgTransformPath(VGPath dstPath, VGPath srcPath)
+ {
+ OPENVG_TRACE("vgTransformPath dstPath=0x%x, srcPath=0x%x", dstPath, srcPath);
+
+ TGuestOpenVg::vgTransformPath(dstPath, srcPath);
+ }
+
+/*
+ Returns the point lying a given distance along a given portion of a path and
+ the unit-length tangent vector at that point. Only the subpath consisting of the
+ numSegments path segments beginning with startSegment (where the initial path
+ segment has index 0) is used. For the remainder of this section we refer only to
+ this subpath when discussing paths.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if path is not a valid path handle, or is not shared with the current context
+ VG_PATH_CAPABILITY_ERROR
+ If x and y are both non-NULL, and the VG_PATH_CAPABILITY_POINT_ALONG_PATH is
+ not enabled for path
+ If tangentX and tangentY are both non-NULL, and the
+ VG_PATH_CAPABILITY_TANGENT_ALONG_PATH capability is not enabled for path
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if startSegment is less than 0 or greater than the index of the final path
+ segment
+ if numSegments is less than or equal to 0
+ if (startSegment + numSegments 1) is less than 0 or greater than the index
+ of the final path segment
+ if x, y, tangentX or tangentY is not properly aligned
+ */
+EXPORT_C void
+ vgPointAlongPath(VGPath path,
+ VGint startSegment,
+ VGint numSegments,
+ VGfloat distance,
+ VGfloat * x, VGfloat * y,
+ VGfloat * tangentX,
+ VGfloat * tangentY)
+ {
+ OPENVG_TRACE("vgPointAlongPath path=0x%x, startSeg=%d, numSegs=%d, distance=%f, x=0x%x, y=0x%x, tangentX=0x%x, tangentY=0x%x",
+ path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
+
+ TGuestOpenVg::vgPointAlongPath(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
+ }
+
+/*
+ Performs filling and stroking. The paintModes argument is a bitwise OR of
+ values from the VGPaintMode enumeration, determining whether the path is to be
+ filled (VG_FILL_PATH), stroked (VG_STROKE_PATH), or both (VG_FILL_PATH |
+ VG_STROKE_PATH). If both filling and stroking are to be performed, the path is
+ first filled, then stroked.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if path is not a valid path handle, or is not shared with the current context
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if paintModes is not a valid bitwise OR of values from the VGPaintMode
+ enumeration
+ */
+EXPORT_C void
+ vgDrawPath(VGPath path, VGbitfield paintModes)
+ {
+ OPENVG_TRACE("vgDrawPath path=0x%x paintModes=0x%x", path, paintModes);
+
+ TGuestOpenVg::vgDrawPath(path, paintModes);
+ }
+
+/* Paint */
+
+/*
+ Deallocates the resources associated with a paint object. Following the call, the
+ paint handle is no longer valid in any of the contexts that shared it. If the paint
+ object is currently active in a drawing context, the context continues to access it
+ until it is replaced or the context is destroyed.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if paint is not a valid paint handle, or is not shared with the current context
+ */
+EXPORT_C void vgDestroyPaint(VGPaint paint)
+ {
+ OPENVG_TRACE("vgDestroyPaint paint=0x%x", paint);
+
+ TGuestOpenVg::vgDestroyPaint(paint);
+ }
+
+/*
+ Set paint definitions on the current context. The paintModes argument is a
+ bitwise OR of values from the VGPaintMode enumeration, determining whether
+ the paint object is to be used for filling (VG_FILL_PATH), stroking
+ (VG_STROKE_PATH), or both (VG_FILL_PATH | VG_STROKE_PATH). The current paint
+ replaces the previously set paint object, if any, for the given paint mode
+ or modes. If paint is equal to VG_INVALID_HANDLE, the previously set paint
+ object for the given mode (if present) is removed and the paint settings are
+ restored to their default values.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if paint is neither a valid paint handle nor equal to VG_INVALID_HANDLE,
+ or is not shared with the current context
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if paintModes is not a valid bitwise OR of values from the VGPaintMode
+ enumeration
+ */
+EXPORT_C void
+ vgSetPaint(VGPaint paint, VGbitfield paintModes)
+ {
+ OPENVG_TRACE("vgSetPaint paint=0x%x, paintModes=0x%x", paint, paintModes);
+
+ TGuestOpenVg::vgSetPaint(paint, paintModes);
+ }
+
+/*
+ As a shorthand, the vgSetColor function allows the VG_PAINT_COLOR parameter of a
+ given paint object to be set using a 32-bit non-premultiplied sRGBA_8888
+ representation. The rgba parameter is a VGuint with 8 bits of red starting at the
+ most significant bit, followed by 8 bits each of green, blue, and alpha. Each color
+ or alpha channel value is conceptually divided by 255. So as to obtain a value
+ between 0 and 1.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if paint is not a valid paint handle, or is not shared with the current context
+ */
+EXPORT_C void
+ vgSetColor(VGPaint paint, VGuint rgba)
+ {
+ OPENVG_TRACE("vgSetColor paint=0x%x, rgba=0x%x", paint, rgba);
+
+ TGuestOpenVg::vgSetColor(paint, rgba);
+ }
+
+/*
+ Replaces any previous pattern image defined on the given paint object for the given
+ set of paint modes with a new pattern image. A value of VG_INVALID_HANDLE for the
+ pattern parameter removes the current pattern image from the paint object.
+ If the current paint object has its VG_PAINT_TYPE parameter set to VG_PAINT_TYPE_PATTERN,
+ but no pattern image is set, the paint object behaves as if VG_PAINT_TYPE were set to
+ VG_PAINT_TYPE_COLOR. While an image is set as the paint pattern for any paint object, it
+ may not be used as a rendering target. Conversely, an image that is currently a rendering
+ target may not be set as a paint pattern.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if paint is not a valid paint handle, or is not shared with the current context
+ if pattern is neither a valid image handle nor equal to VG_INVALID_HANDLE, or is not
+ shared with the current context
+ VG_IMAGE_IN_USE_ERROR
+ if pattern is currently a rendering target
+ */
+EXPORT_C void
+ vgPaintPattern(VGPaint paint, VGImage pattern)
+ {
+ OPENVG_TRACE("vgPaintPattern paint=0x%x, pattern=0x%x", paint, pattern);
+
+ TGuestOpenVg::vgPaintPattern(paint, pattern);
+ }
+
+/* Images */
+
+/*
+ Deallocates the resources associated with an image. Following the call, the image
+ handle is no longer valid in any context that shared it. If the image is currently
+ in use as a rendering target, is the ancestor of another image (see vgChildImage),
+ is set as a paint pattern image on a VGPaint object, or is set as a glyph an a
+ VGFont object, its definition remains available to those consumers as long as they
+ remain valid, but the handle may no longer be used. When those uses cease, the
+ images resources will automatically be deallocated.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if image is not a valid image handle, or is not shared with the current
+ context
+ */
+EXPORT_C void vgDestroyImage(VGImage image)
+ {
+ OPENVG_TRACE("vgDestroyImage image=0x%x -->", image);
+
+ TGuestOpenVg::vgDestroyImage(image);
+ OPENVG_TRACE("vgDestroyImage <--");
+ }
+
+/*
+ Fills a given rectangle of an image with the color specified by the VG_CLEAR_COLOR parameter.
+ The rectangle to be cleared is given by x, y, width, and height, which must define a positive
+ region. The rectangle is clipped to the bounds of the image.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if image is not a valid image handle, or is not shared with the current
+ context
+ VG_IMAGE_IN_USE_ERROR
+ if image is currently a rendering target
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if width or height is less than or equal to 0
+ */
+EXPORT_C void
+ vgClearImage(VGImage image,
+ VGint x, VGint y,
+ VGint width, VGint height)
+ {
+ OPENVG_TRACE("vgClearImage image=0x%x, x=%d, y=%d, width=%d, height=%d",
+ image, x, y, width, height);
+
+ TGuestOpenVg::vgClearImage(image, x, y, width, height);
+ }
+
+/*
+ Read pixel values from memory, perform format conversion if necessary, and store
+ the resulting pixels into a rectangular portion of an image.
+
+ Pixel values are read starting at the address given by the pointer data; adjacent
+ scanlines are separated by dataStride bytes. Negative or zero values of
+ dataStride are allowed. The region to be written is given by x, y, width, and
+ height, which must define a positive region. Pixels that fall outside the bounds
+ of the image are ignored.
+
+ Pixel values in memory are formatted according to the dataFormat parameter, which
+ must contain a value from the VGImageFormat enumeration. The data pointer must
+ be aligned according to the number of bytes of the pixel format specified by
+ dataFormat, unless dataFormat is equal to VG_BW_1, VG_A_1, or VG_A_4, in
+ which case 1 byte alignment is sufficient. Each pixel is converted into the format of
+ the destination image as it is written.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if image is not a valid image handle, or is not shared with the current
+ context
+ VG_IMAGE_IN_USE_ERROR
+ if image is currently a rendering target
+ VG_UNSUPPORTED_IMAGE_FORMAT_ERROR
+ if dataFormat is not a valid value from the VGImageFormat enumeration
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if width or height is less than or equal to 0
+ if data is NULL
+ if data is not properly aligned
+ */
+EXPORT_C void
+ vgImageSubData(VGImage image,
+ const void * data,
+ VGint dataStride,
+ VGImageFormat dataFormat,
+ VGint x, VGint y,
+ VGint width, VGint height)
+ {
+ OPENVG_TRACE("vgImageSubData image=0x%x, data=0x%x, dataStride=%d, dataFormat=0x%x, x=%d, y=%d, width=%d, height=%d",
+ image, data, dataStride, dataFormat, x, y, width, height);
+
+ TGuestOpenVg::vgImageSubData(image, data, dataStride, dataFormat, x, y, width, height);
+ }
+
+/*
+ Copies pixels between images. The source image pixel (sx + i, sy + j) is copied
+ to the destination image pixel (dx + i, dy + j), for 0 <= i < width and
+ 0 <= j < height. Pixels whose source or destination lie outside of the bounds
+ of the respective image are ignored. Pixel format conversion is applied as needed.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if either dst or src is not a valid image handle, or is not shared with the
+ current context
+ VG_IMAGE_IN_USE_ERROR
+ if either dst or src is currently a rendering target
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if width or height is less than or equal to 0
+ */
+EXPORT_C void
+ vgCopyImage(VGImage dst, VGint dx, VGint dy,
+ VGImage src, VGint sx, VGint sy,
+ VGint width, VGint height,
+ VGboolean dither)
+ {
+ OPENVG_TRACE("vgCopyImage dst=0x%x, dx=%d, dy=%d, src=0x%x, sx=%d, sy=%d, width=%d, height=%d, dither=%d",
+ dst, dx, dy, src, sx, sy, width, height, dither);
+
+ TGuestOpenVg::vgCopyImage(dst, dx, dy, src, sx, sy, width, height, dither);
+ }
+
+/*
+ Draw an image to the current drawing surface. The current image-user-to-surface
+ transformation Ti is applied to the image, so that the image pixel centered at
+ (px + 0.5, py + 0.5) is mapped to the point (Ti)(px + 0.5, py + 0.5). In practice,
+ backwards mapping may be used. That is, a sample located at (x, y) in the surface
+ coordinate system is colored according to an interpolated image pixel value at the
+ point (Ti)-1(x, y) in the image coordinate system. If Ti is non-invertible (or nearly
+ so, within the limits of numerical accuracy), no drawing occurs.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if image is not a valid image handle, or is not shared with the current
+ context
+ VG_IMAGE_IN_USE_ERROR
+ if image is currently a rendering target
+ */
+EXPORT_C void
+ vgDrawImage(VGImage image)
+ {
+ OPENVG_TRACE("vgDrawImage image=0x%x", image);
+
+ TGuestOpenVg::vgDrawImage(image);
+ }
+
+/*
+ Copies pixel data from the image src onto the drawing surface. The image pixel
+ (sx + i, sy + j) is copied to the drawing surface pixel (dx + i, dy + j), for
+ 0 <= i < width and 0 <= j < height. Pixels whose source lies outside of the
+ bounds of src or whose destination lies outside the bounds of the drawing surface
+ are ignored. Pixel format conversion is applied as needed. Scissoring takes place
+ normally. Transformations, masking, and blending are not applied.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if src is not a valid image handle, or is not shared with the current context
+ VG_IMAGE_IN_USE_ERROR
+ if src is currently a rendering target
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if width or height is less than or equal to 0
+ */
+EXPORT_C void
+ vgSetPixels(VGint dx, VGint dy,
+ VGImage src, VGint sx, VGint sy,
+ VGint width, VGint height)
+ {
+ OPENVG_TRACE("vgSetPixels dx=%d, dy=%d, src==0x%x, sx=%d, sy=%d, width=%d, height=%d",
+ dx, dy, src, sx, sy, width, height);
+
+ TGuestOpenVg::vgSetPixels(dx, dy, src, sx, sy, width, height);
+ }
+
+/*
+ Copy pixel data to the drawing surface without the creation of a VGImage object. The pixel
+ values to be drawn are taken from the data pointer at the time of the vgWritePixels call,
+ so future changes to the data have no effect. The effects of changes to the data by another
+ thread at the time of the call to vgWritePixels are undefined.
+
+ ERRORS
+ VG_UNSUPPORTED_IMAGE_FORMAT_ERROR
+ if dataFormat is not a valid value from the VGImageFormat enumeration
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if width or height is less than or equal to 0
+ if data is NULL
+ if data is not properly aligned
+ */
+EXPORT_C void
+ vgWritePixels(const void * data, VGint dataStride,
+ VGImageFormat dataFormat,
+ VGint dx, VGint dy,
+ VGint width, VGint height)
+ {
+ OPENVG_TRACE("vgWritePixels data=0x%x, dataStride=%d, dataFormat=0x%x, dx=%d, dy=%d, width=%d, height=%d",
+ data, dataStride, dataFormat, dx, dy, width, height);
+
+ TGuestOpenVg::vgWritePixels(data, dataStride, dataFormat, dx, dy, width, height);
+ }
+
+/*
+ Retrieves pixel data from the drawing surface into the image dst. The drawing surface
+ pixel (sx + i, sy + j) is copied to pixel (dx + i, dy + j) of the image dst, for
+ 0 <= i < width and 0 <= j < height. Pixels whose source lies outside of the bounds of
+ the drawing surface or whose destination lies outside the bounds of dst are ignored.
+ Pixel format conversion is applied as needed. The scissoring region does not affect
+ the reading of pixels.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if dst is not a valid image handle, or is not shared with the current context
+ VG_IMAGE_IN_USE_ERROR
+ if dst is currently a rendering target
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if width or height is less than or equal to 0
+ */
+EXPORT_C void
+ vgGetPixels(VGImage dst, VGint dx, VGint dy,
+ VGint sx, VGint sy,
+ VGint width, VGint height)
+ {
+ OPENVG_TRACE("vgGetPixels dst=0x%x, dx=%d, dy=%d, sx=%d, sy=%d, width=%d, height=%d",
+ dst, dx, dy, sx, sy, width, height);
+
+ TGuestOpenVg::vgGetPixels(dst, dx, dy, sx, sy, width, height);
+ }
+
+/*
+ Copy pixels from one region of the drawing surface to another. Copies between
+ overlapping regions are allowed and always produce consistent results identical to
+ copying the entire source region to a scratch buffer followed by copying the scratch
+ buffer into the destination region. The drawing surface pixel (sx + i, sy + j) is
+ copied to pixel (dx + i, dy + j) for 0 <= i < width and 0 <= j < height. Pixels whose
+ source or destination lies outside of the bounds of the drawing surface are ignored.
+ Transformations, masking, and blending are not applied. Scissoring is applied to the
+ destination, but does not affect the reading of pixels.
+
+ ERRORS
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if width or height is less than or equal to 0
+ */
+EXPORT_C void
+ vgCopyPixels(VGint dx, VGint dy,
+ VGint sx, VGint sy,
+ VGint width, VGint height)
+ {
+ OPENVG_TRACE("vgCopyPixels dx=%d, dy=%d, sx=%d, sy=%d, width=%d, height=%d",
+ dx, dy, sx, sy, width, height);
+
+ TGuestOpenVg::vgCopyPixels(dx, dy, sx, sy, width, height);
+ }
+
+/*
+ Destroys the VGFont object pointed to by the font argument.
+ Note that vgDestroyFont will not destroy underlying objects that were used to
+ define glyphs in the font. It is the responsibility of an application to destroy all
+ VGPath or VGImage objects that were used in a VGFont, if they are no longer in
+ use.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if font is not a valid font handle, or is not shared with the current context
+ */
+EXPORT_C void
+ vgDestroyFont(VGFont font)
+ {
+ OPENVG_TRACE("vgDestroyFont font=0x%x", font);
+
+ TGuestOpenVg::vgDestroyFont(font);
+ }
+
+/*
+ Creates a new glyph and assigns the given path to a glyph associated with the
+ glyphIndex in a font object. The glyphOrigin argument defines the coordinates of
+ the glyph origin within the path, and the escapement parameter determines the
+ advance width for this glyph. Both glyphOrigin and escapement coordinates are
+ defined in the same coordinate system as the path. For glyphs that have no
+ visual representation (e.g., the <space> character), a value of VG_INVALID_HANDLE
+ is used for path. The reference count for the path is incremented.
+
+ The path object may define either an original glyph outline, or an outline that
+ has been scaled and hinted to a particular size (in surface coordinate units); this
+ is defined by the isHinted parameter, which can be used by implementation
+ for text-specific optimizations (e.g., heuristic auto-hinting of unhinted outlines).
+ When isHinted is equal to VG_TRUE, the implementation will never apply
+ auto-hinting; otherwise, auto hinting will be applied at the implementation's
+ discretion.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if font is not a valid font handle, or is not shared with the current context
+ if path is not a valid font handle or VG_INVALID_HANDLE, or is not shared
+ with the current context
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if the pointer to glyphOrigin or escapement is NULL or is not properly
+ aligned
+ */
+EXPORT_C void
+ vgSetGlyphToPath(VGFont font,
+ VGuint glyphIndex,
+ VGPath path,
+ VGboolean isHinted,
+ const VGfloat glyphOrigin [2],
+ const VGfloat escapement[2])
+ {
+ OPENVG_TRACE("vgSetGlyphToPath font=0x%x, glyphIndex=%u, path=0x%x, isHinted=%d, glyphOrigin=0x%x, escapement=0x%x",
+ font, glyphIndex, path, isHinted, glyphOrigin, escapement);
+
+ TGuestOpenVg::vgSetGlyphToPath(font, glyphIndex, path, isHinted, glyphOrigin, escapement);
+ }
+
+/*
+ Creates a new glyph and assigns the given image into a glyph associated with
+ the glyphIndex in a font object. The glyphOrigin argument defines the
+ coordinates of the glyph origin within the image, and the escapement parameter
+ determines the advance width for this glyph. Both glyphOrigin and escapement
+ coordinates are defined in the image coordinate system. Applying transformations
+ to an image (other than translations mapped to pixel grid in surface coordinate
+ system) should be avoided as much as possible. For glyphs that have no visual
+ representation (e.g., the <space> character), a value of VG_INVALID_HANDLE is
+ used for image. The reference count for the image is incremented.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if font is not a valid font handle, or is not shared with the current context
+ if image is not a valid image handle or VG_INVALID_HANDLE, or is not
+ shared with the current context
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if the pointer to glyphOrigin or escapement is NULL or is not properly
+ aligned
+ VG_IMAGE_IN_USE_ERROR
+ if image is currently a rendering target
+ */
+EXPORT_C void
+ vgSetGlyphToImage(VGFont font,
+ VGuint glyphIndex,
+ VGImage image,
+ const VGfloat glyphOrigin [2],
+ const VGfloat escapement[2])
+ {
+ OPENVG_TRACE("vgSetGlyphToImage font=0x%x, glyphIndex=%d, image=0x%x, glyphOrigin=0x%x, escapement=0x%x",
+ font, glyphIndex, image, (void*)glyphOrigin, (void*)escapement);
+
+ TGuestOpenVg::vgSetGlyphToImage(font, glyphIndex, image, glyphOrigin, escapement);
+ }
+
+/*
+ Deletes the glyph defined by a glyphIndex parameter from a font. The reference count
+ for the VGPath or VGImage object to which the glyph was previously set is decremented,
+ and the object's resources are released if the count has fallen to 0.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if font is not a valid font handle, or is not shared with the current context
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if glyphIndex is not defined for the font
+ */
+EXPORT_C void
+ vgClearGlyph(VGFont font,
+ VGuint glyphIndex)
+ {
+ OPENVG_TRACE("vgClearGlyph font=0x%x, glyphIndex=%u", font, glyphIndex);
+
+ TGuestOpenVg::vgClearGlyph(font, glyphIndex);
+ }
+
+/*
+ Renders a glyph defined by the glyphIndex using the given font object. The
+ user space position of the glyph (the point where the glyph origin will be
+ placed) is determined by value of VG_GLYPH_ORIGIN. vgDrawGlyph calculates the
+ new text origin by translating the glyph origin by the escapement vector of
+ the glyph defined by glyphIndex. Following the call, the VG_GLYPH_ORIGIN
+ parameter will be updated with the new origin.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if font is not a valid font handle, or is not shared with the current context
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if glyphIndex has not been defined for a given font object
+ if paintModes is not a valid bitwise OR of values from the VGPaintMode
+ enumeration, or 0
+ */
+EXPORT_C void
+ vgDrawGlyph(VGFont font,
+ VGuint glyphIndex,
+ VGbitfield paintModes,
+ VGboolean allowAutoHinting)
+ {
+ OPENVG_TRACE("vgDrawGlyph font=0x%x, glyphIndex=%u, paintModes=0x%x, allowAutoHinting=%d",
+ font, glyphIndex, paintModes, allowAutoHinting);
+
+ TGuestOpenVg::vgDrawGlyph(font, glyphIndex, paintModes, allowAutoHinting);
+ }
+
+/*
+ Renders a sequence of glyphs defined by the array pointed to by glyphIndices
+ using the given font object. The values in the adjustments_x and adjustments_y
+ arrays define positional adjustment values for each pair of glyphs defined by
+ the glyphIndices array. The glyphCount parameter defines the number of elements
+ in the glyphIndices and adjustments_x and adjustments_y arrays. The adjustment
+ values defined in these arrays may represent kerning or other positional adjustments
+ required for each pair of glyphs. If no adjustments for glyph positioning in a
+ particular axis are required (all horizontal and/or vertical adjustments are zero),
+ NULL pointers may be passed for either or both of adjustment_x and
+ adjustment_y. The adjustments values should be defined in the same
+ coordinate system as the font glyphs; if the glyphs are defined by path objects
+ with path data scaled (e.g., by a factor of 1/units-per-EM), the values in the
+ adjustment_x and adjustment_y arrays are scaled using the same scale factor.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if font is not a valid font handle, or is not shared with the current context
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if glyphCount is zero or a negative value
+ if the pointer to the glyphIndices array is NULL or is not properly
+ aligned
+ if a pointer to either of the adjustments_x or adjustments_y arrays are
+ non-NULL and are not properly aligned
+ if any of the glyphIndices has not been defined in a given font object
+ if paintModes is not a valid bitwise OR of values from the VGPaintMode
+ enumeration, or 0
+ */
+EXPORT_C void
+ vgDrawGlyphs(VGFont font,
+ VGint glyphCount,
+ const VGuint * glyphIndices,
+ const VGfloat * adjustments_x,
+ const VGfloat * adjustments_y,
+ VGbitfield paintModes,
+ VGboolean allowAutoHinting)
+ {
+ OPENVG_TRACE("vgDrawGlyphs font=0x%x, glyphCount=%d, glyphIndices=0x%x, adjustments_y=0x%x, "
+ "adjustments_x=0x%x, paintModes=0x%x, allowAutoHinting=%d",
+ font, glyphCount, (void*)glyphIndices, (void*)adjustments_x, (void*)adjustments_y, paintModes, allowAutoHinting);
+
+ TGuestOpenVg::vgDrawGlyphs(font, glyphCount, glyphIndices, adjustments_x, adjustments_y, paintModes, allowAutoHinting);
+ }
+
+/* Image Filters */
+
+/*
+ Computes a linear combination of color and alpha values (Rsrc, Gsrc, Bsrc,
+ ALPHAsrc) from the normalized source image src at each pixel.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if either dst or src is not a valid image handle, or is not shared with the
+ current context
+ VG_IMAGE_IN_USE_ERROR
+ if either dst or src is currently a rendering target
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if src and dst overlap
+ if matrix is NULL
+ if matrix is not properly aligned
+ */
+EXPORT_C void
+ vgColorMatrix(VGImage dst, VGImage src,
+ const VGfloat * matrix)
+ {
+ OPENVG_TRACE("vgColorMatrix dst=0x%x, src=0x%x, matrix=0x%x", dst, src, matrix);
+
+ TGuestOpenVg::vgColorMatrix(dst, src, matrix);
+ }
+
+/*
+ Applies a user-supplied convolution kernel to a normalized source image src. The
+ dimensions of the kernel are given by kernelWidth and kernelHeight; the kernel values
+ are specified as kernelWidth*kernelHeight VGshorts in column-major order. That is,
+ the kernel entry (i, j) is located at position i*kernelHeight + j in the input sequence.
+ The shiftX and shiftY parameters specify a translation between the source and
+ destination images. The result of the convolution is multiplied by a scale factor, and
+ a bias is added.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if either dst or src is not a valid image handle, or is not shared with the
+ current context
+ VG_IMAGE_IN_USE_ERROR
+ if either dst or src is currently a rendering target
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if src and dst overlap
+ if kernelWidth or kernelHeight is less than or equal to 0 or greater than
+ VG_MAX_KERNEL_SIZE
+ if kernel is NULL
+ if kernel is not properly aligned
+ if tilingMode is not one of the values from the VGTilingMode enumeration
+ */
+EXPORT_C void
+ vgConvolve(VGImage dst, VGImage src,
+ VGint kernelWidth, VGint kernelHeight,
+ VGint shiftX, VGint shiftY,
+ const VGshort * kernel,
+ VGfloat scale,
+ VGfloat bias,
+ VGTilingMode tilingMode)
+ {
+ OPENVG_TRACE("vgConvolve dst=0x%x, src=0x%x, kW=%d, kH=%d, shX=%d, shY=%d, kernel=0x%x, scale=%f, bias=%f, tiling=0x%x",
+ dst, src, kernelWidth, kernelHeight, shiftX, shiftY, kernel, scale, bias, tilingMode);
+
+ TGuestOpenVg::vgConvolve(dst, src, kernelWidth, kernelHeight, shiftX, shiftY, kernel, scale, bias, tilingMode);
+ }
+
+/*
+ Applies a user-supplied separable convolution kernel to a normalized source image src.
+ A separable kernel is a two-dimensional kernel in which each entry kij is equal to a
+ product kxi * kyj of elements from two one dimensional kernels, one horizontal and one
+ vertical.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if either dst or src is not a valid image handle, or is not shared with the
+ current context
+ VG_IMAGE_IN_USE_ERROR
+ if either dst or src is currently a rendering target
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if src and dst overlap
+ if kernelWidth or kernelHeight is less than or equal to 0 or greater than
+ VG_MAX_SEPARABLE_KERNEL_SIZE
+ if kernelX or kernelY is NULL
+ if kernelX or kernelY is not properly aligned
+ if tilingMode is not one of the values from the VGTilingMode
+ enumeration
+ */
+EXPORT_C void
+ 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)
+ {
+ OPENVG_TRACE("vgSeparableConvolve dst=0x%x, src=0x%x, kW=%d, kH=%d, shX=%d, shY=%d, kX=0x%x, kY=0x%x, scale=%f, bias=%f, tiling=0x%x",
+ dst, src, kernelWidth, kernelHeight, shiftX, shiftY, kernelX, kernelY, scale, bias, tilingMode);
+
+ TGuestOpenVg::vgSeparableConvolve(dst, src, kernelWidth, kernelHeight, shiftX, shiftY, kernelX, kernelY, scale, bias, tilingMode);
+ }
+
+/*
+ Computes the convolution of a normalized source image src with a separable kernel
+ defined in each dimension by the Gaussian function G(x, s).
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if either dst or src is not a valid image handle, or is not shared with the
+ current context
+ VG_IMAGE_IN_USE_ERROR
+ if either dst or src is currently a rendering target
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if src and dst overlap
+ if stdDeviationX or stdDeviationY is less than or equal to 0 or greater
+ than VG_MAX_GAUSSIAN_STD_DEVIATION
+ if tilingMode is not one of the values from the VGTilingMode
+ enumeration
+ */
+EXPORT_C void
+ vgGaussianBlur(VGImage dst, VGImage src,
+ VGfloat stdDeviationX,
+ VGfloat stdDeviationY,
+ VGTilingMode tilingMode)
+ {
+ OPENVG_TRACE("vgGaussianBlur dst=0x%x, src=0x%x, stdDeviationX=%f, stdDeviationY=%f, tilingMode=%d",
+ dst, src, stdDeviationX, stdDeviationY, tilingMode);
+
+ TGuestOpenVg::vgGaussianBlur(dst, src, stdDeviationX, stdDeviationY, tilingMode);
+ }
+
+/*
+ Passes each image channel of the normalized source image src through a separate lookup
+ table.
+
+ Each channel of the normalized source pixel is used as an index into the lookup table for
+ that channel by multiplying the normalized value by 255 and rounding to obtain an 8-bit
+ integral value. Each LUT parameter should contain 256 VGubyte entries. The
+ outputs of the lookup tables are concatenated to form an RGBA_8888 pixel
+ value, which is interpreted as lRGBA_8888, lRGBA_8888_PRE, sRGBA_8888,
+ or sRGBA_8888_PRE, depending on the values of outputLinear and outputPremultiplied.
+
+ The resulting pixels are converted into the destination format using the normal
+ pixel format conversion rules.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if either dst or src is not a valid image handle, or is not shared with the
+ current context
+ VG_IMAGE_IN_USE_ERROR
+ if either dst or src is currently a rendering target
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if src and dst overlap
+ if any pointer parameter is NULL
+ */
+EXPORT_C void
+ vgLookup(VGImage dst, VGImage src,
+ const VGubyte * redLUT,
+ const VGubyte * greenLUT,
+ const VGubyte * blueLUT,
+ const VGubyte * alphaLUT,
+ VGboolean outputLinear,
+ VGboolean outputPremultiplied)
+ {
+ OPENVG_TRACE("vgLookup dst=0x%x, src=0x%x, redLUT=0x%x, greenLUT=0x%x, blueLUT=0x%x, alphaLUT=0x%x, opLin=%d, opPremul=%d",
+ dst, src, redLUT, greenLUT, blueLUT, alphaLUT, outputLinear, outputPremultiplied);
+
+ TGuestOpenVg::vgLookup(dst, src, redLUT, greenLUT, blueLUT, alphaLUT, outputLinear, outputPremultiplied);
+ }
+
+/*
+ Passes a single image channel of the normalized source image src, selected by the
+ sourceChannel parameter, through a combined lookup table that produces whole pixel
+ values. Each normalized source channel value is multiplied by 255 and rounded to
+ obtain an 8 bit integral value.
+
+ ERRORS
+ VG_BAD_HANDLE_ERROR
+ if either dst or src is not a valid image handle, or is not shared with the
+ current context
+ VG_IMAGE_IN_USE_ERROR
+ if either dst or src is currently a rendering target
+ VG_ILLEGAL_ARGUMENT_ERROR
+ if src and dst overlap
+ if src is in an RGB pixel format and sourceChannel is not one of VG_RED,
+ VG_GREEN, VG_BLUE or VG_ALPHA from the VGImageChannel enumeration
+ if lookupTable is NULL
+ if lookupTable is not properly aligned
+ */
+EXPORT_C void
+ vgLookupSingle(VGImage dst, VGImage src,
+ const VGuint * lookupTable,
+ VGImageChannel sourceChannel,
+ VGboolean outputLinear,
+ VGboolean outputPremultiplied)
+ {
+ OPENVG_TRACE("vgLookupSingle dst=0x%x, src=0x%x, lookupTable=0x%x, sourceChannel=0x%x, opLin=%d, opPremul=%d",
+ dst, src, lookupTable, sourceChannel, outputLinear, outputPremultiplied);
+
+ TGuestOpenVg::vgLookupSingle(dst, src, lookupTable, sourceChannel, outputLinear, outputPremultiplied);
+ }
+
+// guest support for OpenVG extension #4, KHR_EGL_image - vgCreateEGLImageTargetKHR(VGeglImageKHR image)
+/*
+ Creates an EGLImage target VGImage object from the provided EGLImage
+ <image>. <image> should be of type EGLImageKHR, cast into the type
+ VGeglImageKHR. Assuming no errors are generated in this function,
+ the resulting VGImage will be an EGLImage target of the specified
+ EGLImage <image>. As a side-effect of the referencing operation,
+ all of the pixel data in the <buffer> used as the EGLImage source
+ resource (i.e., the <buffer> parameter passed to the CreateImageKHR
+ command that returned <image>) will become undefined.
+
+ ERRORS
+ VG_UNSUPPORTED_IMAGE_FORMAT_ERROR
+ - if the OpenVG implementation is not able to create a VGImage
+ compatible with the provided VGeglImageKHR for an implementation-
+ dependent reason (this could be caused by, but not limited to,
+ reasons such as unsupported pixel formats, anti-aliasing quality,
+ etc.).
+
+ VG_ILLEGAL_ARGUMENT_ERROR
+ - if <image> is not a valid VGeglImageKHR.
+ */
+VGImage vgCreateEGLImageTargetKHR(VGeglImageKHR image)
+ {
+ OPENVG_TRACE("vgCreateEGLImageTargetKHR image=0x%x -->", image);
+
+ VGImage imageHandle = TGuestOpenVg::vgCreateEGLImageTargetKHR(image);
+ OPENVG_TRACE("vgCreateEGLImageTargetKHR imageHandle=0x%x <--", imageHandle);
+ return imageHandle;
+ }
+
+
+} /* extern "C" */
+
+// end of file openvg.cpp