/*
    Copy drawing surface content into the specified pixels buffer.

    This function is useful for managed environments (e.g. C#, Unity, Java,
    Android), where the use of a direct pixels access (i.e. svgtSurfacePixels)
    is not advisable nor comfortable.

    If the 'redBlueSwap' flag is set to SVGT_TRUE, the copy process will also
    swap red and blue channels for each pixel; this kind of swap could be useful
    when dealing with OpenGL/Direct3D texture uploads (RGBA or BGRA formats).

    If the 'dilateEdgesFix' flag is set to SVGT_TRUE, the copy process will also
    perform a 1-pixel dilate post-filter; this dilate filter could be useful
    when surface pixels will be uploaded to OpenGL/Direct3D bilinear-filtered
    textures.

    This function returns:

    - SVGT_BAD_HANDLE_ERROR if the specified surface handle is not valid

    - SVGT_ILLEGAL_ARGUMENT_ERROR if 'dstPixels32' pointer is NULL or if
      it's not properly aligned

    - SVGT_NO_ERROR if the operation was completed successfully
*/
SVGTErrorCode svgtSurfaceCopy(SVGTHandle surface,
                              void* dstPixels32,
                              SVGTboolean redBlueSwap,
                              SVGTboolean dilateEdgesFix);

SVGTuint surfaceWidth = svgtSurfaceWidth(surface);
SVGTuint surfaceHeight = svgtSurfaceHeight(surface);
SVGTuint* tmpPixels = (SVGTuint*)malloc(surfaceWidth * surfaceHeight *
                                        sizeof(SVGTuint));
/* copy surface pixels, applying a 1-pixel dilate filter (no red-blue channels swap) */
svgtSurfaceCopy(surface, tmpPixels, SVGT_FALSE, SVGT_TRUE);
< upload tmpPixels to the GPU, using your preferred 3D API >
free(tmpPixels);

/*
    Map a point, expressed in the document viewport system, into the surface
    viewport. The transformation will be performed according to the current
    document viewport (see svgtDocViewportGet) and the current surface viewport
    (see svgtSurfaceViewportGet).

    The 'dst' parameter must be an array of (at least) 2 float entries, it will
    be filled with:

    - dst[0] = transformed x

    - dst[1] = transformed y

    NB: floating-point values of NaN are treated as 0, values of +Inf and -Inf
        are clamped to the largest and smallest available float values.

    This function returns:

    - SVGT_BAD_HANDLE_ERROR if specified document (or surface) handle is not
      valid

    - SVGT_ILLEGAL_ARGUMENT_ERROR if 'dst' pointer is NULL or if it's not
      properly aligned

    - SVGT_NO_ERROR if the operation was completed successfully
*/
SVGTErrorCode svgtPointMap(SVGTHandle svgDoc,
                           SVGTHandle surface,
                           SVGTfloat x,
                           SVGTfloat y,
                           SVGTfloat* dst);

/*
    Get renderer and version information.
    This function does not set the last-error code (see svgtGetLastError).

    If specified 'name' is not a valid value from the SVGTStringID
    enumeration, an empty string is returned.
*/
const char* svgtGetString(SVGTStringID name);

/*
    Set the log buffer for the current thread.
    It is important to not specify the same buffer memory for different
    threads, because AmanithSVG does not synchronize write operations to the
    provided log buffer: in other words, each thread must provide its own log
    buffer.

    'logBuffer' can be NULL or a valid pointer to a characters buffer where
    AmanithSVG can log messages. If NULL, logging is disabled. Messages will
    be appended one after the other, as long as there is enough free space
    within the buffer. When there is no more space, messages will stop being
    written to the buffer.

    'logBufferCapacity' is the capacity of 'logBuffer', in characters. If zero
    is specified, logging is disabled. AmanithSVG has no way of checking the
    actual buffer capacity, so it is up to the caller to specify the correct
    value, otherwise memory errors will be possible (e.g. buffer overrun).

    'logLevel' must be a bitwise OR of the desired SVGTLogLevel values.
    If zero is specified, logging is disabled.

    NB: after calling this function, the buffer will be initialized as empty
    (i.e. a '\0' character will be written at the beginning).

    This function returns:

    - SVGT_NOT_INITIALIZED_ERROR if the library has not yet been initialized
      (see svgtInit)

    - SVGT_ILLEGAL_ARGUMENT_ERROR if 'logLevel' is not a bitwise OR of values
      from the SVGTLogLevel enumeration
*/
SVGTErrorCode svgtLogBufferSet(char* logBuffer,
                               SVGTuint logBufferCapacity,
                               SVGTbitfield logLevel);

/*
    Append the given message to the log buffer.
    Log buffer must have been already set through svgtLogBufferSet function,
    otherwise the message will be discarded.

    'message' must be a null-terminated string.

    'level' represents the message severity, and it determines its importance.

    This function returns:

    - SVGT_NOT_INITIALIZED_ERROR if the library has not yet been initialized
      (see svgtInit)

    - SVGT_ILLEGAL_ARGUMENT_ERROR if 'message' is null or if 'level' is not a
      value from the SVGTLogLevel enumeration

    - SVGT_NO_ERROR if no buffer has been set (via svgtLogBufferSet), or if
      the operation was completed successfully
*/
SVGTErrorCode svgtLogPrint(const char* message,
                           SVGTLogLevel level);

/*
    Get information about the current thread log buffer.
    The 'info' parameter must be an array of (at least) 4 entries, it will
    be filled with:

    - info[0] = log level (a bitwise OR of SVGTLogLevel enumeration)

    - info[1] = buffer capacity, in characters

    - info[2] = current length, in characters (i.e. the total number of
                characters written, included the trailing '\0')

    - info[3] = fullness (SVGT_TRUE if buffer is full, else SVGT_FALSE)

    NB: please note that buffer fullness does not correspond, in general, to
    the length == capacity condition. So in order to know if buffer is full
    (i.e. AmanithSVG can no longer write any messages to it), simply check
    the returned information in info[3] entry.

    This function returns:

    - SVGT_NOT_INITIALIZED_ERROR if the library has not yet been initialized
      (see svgtInit)

    - SVGT_ILLEGAL_ARGUMENT_ERROR if 'info' pointer is NULL or if it's not
      properly aligned
*/
SVGTErrorCode svgtLogBufferInfo(SVGTuint* info);