C# binding

string xml = File.ReadAllText("animals.svg");
SVGDocument doc = SVGAssets.CreateDocument(xml);

/* 
   AmanithSVG document handle (read only); it's the handle created by the low level
   svgtDocCreate function.
*/
uint Handle;

/*
    SVG content itself optionally can provide information about the appropriate 
    viewport region for the content via the 'width' and 'height' XML attributes
    on the outermost <svg> element.
    Use this (readonly) property to get the suggested viewport width, in pixels.

    It returns a negative number (i.e. an invalid width) in the following cases:
    - outermost element is not an <svg> element
    - outermost <svg> element doesn't have a 'width' attribute specified
    - outermost <svg> element has a negative 'width' attribute specified
      (e.g. width="-50")
    - outermost <svg> element has a 'width' attribute specified in relative measure
      units (i.e. em, ex, % percentage).
*/
float Width;

/*
    SVG content itself optionally can provide information about the appropriate
    viewport region for the content via the 'width' and 'height' XML attributes on
    the outermost <svg> element.
    Use this (readonly) property to get the suggested viewport height, in pixels.

    It returns a negative number (i.e. an invalid height) in the following cases:
    - outermost element is not an <svg> element
    - outermost <svg> element doesn't have a 'height' attribute specified
    - outermost <svg> element has a negative 'height' attribute specified
      (e.g. height="-30")
    - outermost <svg> element has a 'height' attribute specified in relative measure
      units (i.e. em, ex, % percentage).
*/
float Height;

/*
    The document (logical) viewport to map onto the destination (drawing surface)
    viewport. When an SVG document has been created through the SVGAssets.CreateDocument
    function, the initial value of its viewport is equal to the 'viewBox' attribute
    present in the outermost <svg> element.
*/
SVGViewport Viewport;

/*
    Viewport aspect ratio.
    The alignment parameter indicates whether to force uniform scaling and, if so,
    the alignment method to use in case the aspect ratio of the document viewport doesn't
    match the aspect ratio of the surface viewport.
*/
SVGAspectRatio AspectRatio;

/* 
   AmanithSVG surface handle (read only); it's the handle created by the low level
   svgtSurfaceCreate function.
*/
uint Handle;

/* Get current surface width, in pixels. NB: the property is readonly. */
uint Width;

/* Get current surface height, in pixels. NB: the property is readonly. */
uint Height;

/*
    The surface viewport (i.e. a drawing surface rectangular area), where to map the
    source document viewport.
    The combined use of surface and document viewport, induces a transformation matrix,
    that will be used to draw the whole SVG document. The induced matrix grants that
    the document viewport is mapped onto the surface viewport (respecting the specified
    alignment): all SVG content will be drawn accordingly.
*/
SVGViewport Viewport;

/*
    Resize the surface, specifying new dimensions in pixels.
    After resizing, the surface viewport will be reset to the whole surface.

    It returns SVGError.None if the operation was completed successfully, else
    an error code.
*/
SVGError Resize(uint newWidth, uint newHeight);

/*
    Draw an SVG document, on this drawing surface.

    First the drawing surface is cleared if a valid (i.e. not null) clear color is
    provided. Then the specified document, if valid, is drawn.

    It returns SVGError.None if the operation was completed successfully, else
    an error code.
*/
SVGError Draw(SVGDocument document,
              SVGColor clearColor,
              SVGRenderingQuality renderingQuality);

/* load an SVG file */
string xml = File.ReadAllText("animals.svg");
SVGDocument doc = SVGAssets.CreateDocument(xml);

/* create a 512x512 drawing surface */
SVGSurface srf = SVGAssets.CreateSurface(512, 512);

/* draw the SVG */
srf.Draw(doc, SVGColor.White, SVGRenderingQuality.Better);
< do something with surface pixels (e.g. upload pixels to a GPU texture) >

/* destroy surface and document */
doc.Dispose();
srf.Dispose();

/* load SVG files */
SVGDocument doc1 = SVGAssets.CreateDocument(File.ReadAllText("car_coolant.svg"));
SVGDocument doc2 = SVGAssets.CreateDocument(File.ReadAllText("car_maintenance.svg"));
SVGDocument doc3 = SVGAssets.CreateDocument(File.ReadAllText("car_brake.svg"));
SVGDocument doc4 = SVGAssets.CreateDocument(File.ReadAllText("car_oil.svg"));

/* create a drawing surface */
SVGSurface srf = SVGAssets.CreateSurface(512, 512);

/* select an upper-left sub-region and draw the first SVG document */
srf.Viewport = new SVGViewport(0, 0, 256, 256);
srf.Draw(doc1, SVGColor.White, SVGRenderingQuality.Better);

/* select an upper-right sub-region and draw the second SVG document */
srf.Viewport = new SVGViewport(256, 0, 256, 256);
srf.Draw(doc2, null, SVGRenderingQuality.Better);

/* select the whole lower-left sub-region and draw the third SVG document */
srf.Viewport = new SVGViewport(0, 256, 256, 256);
srf.Draw(doc3, null, SVGRenderingQuality.Better);

/* select the whole lower-right sub-region and draw the fourth SVG document */
srf.Viewport = new SVGViewport(256, 256, 256, 256);
srf.Draw(doc4, null, SVGRenderingQuality.Better);

< do something with surface pixels (e.g. upload pixels to a GPU texture) >

/* destroy surface and documents */
doc1.Dispose();
doc2.Dispose();
doc3.Dispose();
doc4.Dispose();
srf.Dispose();

/* create an SVG document */
SVGDocument doc = SVGAssets.CreateDocument(File.ReadAllText("orc.svg"));

/* initialize the packing process: generate atlases with a maximum 512 pixels
   dimension and no additional scale */
SVGPacker packer = SVGAssets.CreatePacker(1.0f, 512, 1, false);

if (packer.Begin() == SVGError.None) {
    
    /* add the document to the packer, and get back the actual number of
       packed bounding boxes */
    uint[] info = packer.Add(doc, true, 1.0f);

    /* info[0] = number of collected bounding boxes
       info[1] = the actual number of packed bounding boxes */
    if ((info == null) || (info[1] != info[0])) {
        Console.WriteLine("Some SVG elements cannot be packed!");
        Console.WriteLine("Specified maximum texture dimensions do not allow to pack all SVG elements.");
        /* close the packing process without doing anything */
        packer.End(false);
    }
    else {
        /* finalize the packing process and get back generated bins */
        SVGPackedBin[] bins = packer.End(true);

        for (int i = 0; i < bins.Length; ++i) {
            /* extract the bin (i.e. get atlas width, height and the number of packed documents/elements) */
            SVGPackedBin bin = bins[i];
            /* create a drawing surface with the same atlas dimension */
            SVGSurface srf = SVGAssets.CreateSurface(bin.Width, bin.Height);
            /* draw all documents/elements over the drawing surface */
            srf.Draw(bin, SVGColor.Clear, SVGRenderingQuality.Better);
            /* if needed, process the drawing surface (e.g. upload its pixels on a GPU texture) and then destroy it */
            < do something with surface pixels (e.g. upload pixels to a GPU texture) >
            /* destroy the surface */
            srf.Dispose();
        }
    }
}

/* destroy the document */
doc.Dispose();

/* Constructor. */
abstract SVGResource(string id,
                     SVGResourceType type,
                     SVGResourceHint hints);

/* Get in-memory binary data for the resource. */
abstract byte[] GetBytes();

// Resource identifier.
string Id;
// Resource type.
SVGResourceType Type;
// Resource hints.
SVGResourceHint Hints;

/*
    Constructor, device screen properties must be supplied
    (with/height in pixels and dpi).
*/
abstract SVGAssetsConfig(uint screenWidth,
                         uint screenHeight,
                         float screenDpi);

/*
    Get the number of (external) resources provided by this configuration.
    It must be implemented by all derived classes.
*/
abstract int ResourcesCount();

/*
    Get a resource given an index.
    If the given index is less than zero or greater or equal to the value
    returned by ResourcesCount, a null resource is returned.

    It must be implemented by all derived classes.
*/
abstract SVGResource GetResource(int index);

/*
    Curves quality, used by AmanithSVG geometric kernel to approximate curves
    with straight line segments (flattening). Valid range is [1; 100], where 100
    represents the best quality.

    A zero or negative value means "keep the default one".
*/
float CurvesQuality;

/*
    User-agent language settings; a list of languages separated by
    semicolon (e.g. "en-US;en-GB;it;es"). It must not be empty.
*/
string Language;

/* Log level, if SVGLogLevel.None is specified, logging is disabled. */
SVGLogLevel LogLevel;

/* Log capacity, in characters; if zero is specified, logging is disabled. */
uint LogCapacity;

/*
    Initialize AmanithSVG native library and load the given configuration.
    The provided settings include screen metrics, user-agent language and
    possible resources (fonts and images).

    It returns SVGError.None if the operation was completed successfully, else
    an error code.
*/
internal SVGError Init(SVGAssetsConfig config);

/*
    Create a drawing surface, specifying its dimensions in pixels.

    Supplied dimensions should be positive numbers greater than zero, else
    a null instance will be returned.
*/
SVGSurface CreateSurface(uint width,
                         uint height);

/* Create and load an SVG document, specifying the whole XML string. */
SVGDocument CreateDocument(string xmlText);

/*
    Create an SVG packer, specifying a scale factor.

    Every collected SVG document/element will be packed into rectangular bins, whose
    dimensions won't exceed the specified 'maxTexturesDimension' in pixels.

    If true, 'pow2Textures' will force bins to have power-of-two dimensions.

    Each rectangle will be separated from the others by the specified 'border' in pixels.

    The specified 'scale' factor will be applied to all collected SVG documents/elements,
    in order to realize resolution-independent atlases.
*/
SVGPacker CreatePacker(float scale,
                       uint maxTexturesDimension,
                       uint border,
                       bool pow2Textures);

/* Get library version. */
string GetVersion();

/* Get AmanithSVG log content as a string. */
string LogGet();

/*
    Clear the AmanithSVG log buffer set for the current thread.

    If specified, make sure AmanithSVG no longer uses a log buffer for
    the current thread. In this case, logging can be reactivated (for
    the calling thread) by calling this method with a 'false' parameter.
*/
SVGError LogClear(bool stopLogging);

/*
    Append an informational message to the AmanithSVG log buffer
    set for the current thread.
*/
SVGError LogInfo(string message);

/*
    Append a warning message to the AmanithSVG log buffer
    set for the current thread.
*/
SVGError LogWarning(string message);

/*
    Append an error message to the AmanithSVG log buffer
    set for the current thread.
*/
SVGError LogError(string message);