/*

* Copyright (c) 2013-14 Mikko Mononen [email protected]

*

* This software is provided 'as-is', without any express or implied

* warranty. In no event will the authors be held liable for any damages

* arising from the use of this software.

*

* Permission is granted to anyone to use this software for any purpose,

* including commercial applications, and to alter it and redistribute it

* freely, subject to the following restrictions:

*

* 1. The origin of this software must not be misrepresented; you must not

* claim that you wrote the original software. If you use this software

* in a product, an acknowledgment in the product documentation would be

* appreciated but is not required.

* 2. Altered source versions must be plainly marked as such, and must not be

* misrepresented as being the original software.

* 3. This notice may not be removed or altered from any source distribution.

*

* The SVG parser is based on Anti-Grain Geometry 2.4 SVG example

* Copyright (C) 2002-2004 Maxim Shemanarev (McSeem) (http://www.antigrain.com/)

*

* Arc calculation code based on canvg (https://code.google.com/p/canvg/)

*

* Bounding box calculation based on http://blog.hackers-cafe.net/2009/06/how-to-calculate-bezier-curves-bounding.html

*

*/

#ifndef NANOSVG_H

#define NANOSVG_H

#ifdef __cplusplus

extern "C" {

#endif

// NanoSVG is a simple stupid single-header-file SVG parse. The output of the parser is a list of cubic bezier shapes.

//

// The library suits well for anything from rendering scalable icons in your editor application to prototyping a game.

//

// NanoSVG supports a wide range of SVG features, but something may be missing, feel free to create a pull request!

//

// The shapes in the SVG images are transformed by the viewBox and converted to specified units.

// That is, you should get the same looking data as your designed in your favorite app.

//

// NanoSVG can return the paths in few different units. For example if you want to render an image, you may choose

// to get the paths in pixels, or if you are feeding the data into a CNC-cutter, you may want to use millimeters.

//

// The units passed to NanoVG should be one of: 'px', 'pt', 'pc' 'mm', 'cm', or 'in'.

// DPI (dots-per-inch) controls how the unit conversion is done.

//

// If you don't know or care about the units stuff, "px" and 96 should get you going.

/* Example Usage:

// Load

NSVGImage* image;

image = nsvgParseFromFile("test.svg", "px", 96);

printf("size: %f x %f\n", image->width, image->height);

// Use...

for (NSVGshape *shape = image->shapes; shape != NULL; shape = shape->next) {

for (NSVGpath *path = shape->paths; path != NULL; path = path->next) {

for (int i = 0; i < path->npts-1; i += 3) {

float* p = &path->pts[i*2];

drawCubicBez(p[0],p[1], p[2],p[3], p[4],p[5], p[6],p[7]);

}

}

}

// Delete

nsvgDelete(image);

*/

enum NSVGpaintType {

};

enum NSVGspreadType {

};

enum NSVGlineJoin {

};

enum NSVGlineCap {

};

enum NSVGfillRule {

NSVG_FILLRULE_NONZERO = 0,

NSVG_FILLRULE_EVENODD = 1,

};

enum NSVGflags {

NSVG_FLAGS_VISIBLE = 0x01

};

typedef struct NSVGgradientStop {

unsigned int color;

float offset;

} NSVGgradientStop;

typedef struct NSVGgradient {

} NSVGgradient;

typedef struct NSVGpaint {

} NSVGpaint;

typedef struct NSVGpath

} NSVGpath;

typedef struct NSVGshape

} NSVGshape;

typedef struct NSVGimage

} NSVGimage;

// Parses SVG file from a file, returns SVG image as paths.

NSVGimage* nsvgParseFromFile(const char* filename, const char* units, float dpi);

// Parses SVG file from a null terminated string, returns SVG image as paths.

// Important note: changes the string.

NSVGimage* nsvgParse(char* input, const char* units, float dpi);

// Deletes list of paths.

void nsvgDelete(NSVGimage* image);

#ifdef __cplusplus

};

#endif

#endif // NANOSVG_H

#ifdef NANOSVG_IMPLEMENTATION

#include <string.h>

#include <stdlib.h>

#include <math.h>

#define NSVG_PI (3.14159265358979323846264338327f)

#define NSVG_KAPPA90 (0.5522847493f) // Length proportional to radius of a cubic bezier handle for 90deg arcs.

#define NSVG_ALIGN_MIN 0

#define NSVG_ALIGN_MID 1

#define NSVG_ALIGN_MAX 2

#define NSVG_ALIGN_NONE 0

#define NSVG_ALIGN_MEET 1

#define NSVG_ALIGN_SLICE 2

#define NSVG_NOTUSED(v) do { (void)(1 ? (void)0 : ( (void)(v) ) ); } while(0)

#define NSVG_RGB(r, g, b) (((unsigned int)r) | ((unsigned int)g << 8) | ((unsigned int)b << 16))

#ifdef _MSC_VER

#pragma warning (disable: 4996) // Switch off security warnings

#pragma warning (disable: 4100) // Switch off unreferenced formal parameter warnings

#ifdef __cplusplus

#define NSVG_INLINE inline

#else

#define NSVG_INLINE

#endif

#else

#define NSVG_INLINE inline

#endif

static int nsvg__isspace(char c)

{

return strchr(" \t\n\v\f\r", c) != 0;

}

static int nsvg__isdigit(char c)

{

return strchr("0123456789", c) != 0;

}

static int nsvg__isnum(char c)

{

return strchr("0123456789+-.eE", c) != 0;

}

static NSVG_INLINE float nsvg__minf(float a, float b) { return a < b ? a : b; }

static NSVG_INLINE float nsvg__maxf(float a, float b) { return a > b ? a : b; }

// Simple XML parser

#define NSVG_XML_TAG 1

#define NSVG_XML_CONTENT 2

#define NSVG_XML_MAX_ATTRIBS 256

static void nsvg__parseContent(char* s,

void (*contentCb)(void* ud, const char* s),

void* ud)

{

// Trim start white spaces

while (*s && nsvg__isspace(*s)) s++;

if (!*s) return;

if (contentCb)

(*contentCb)(ud, s);

}

static void nsvg__parseElement(char* s,

void (*startelCb)(void* ud, const char* el, const char** attr),

void (*endelCb)(void* ud, const char* el),

void* ud)

{

const char* attr[NSVG_XML_MAX_ATTRIBS];

int nattr = 0;

char* name;

int start = 0;

int end = 0;

char quote;

// Skip white space after the '<'

while (*s && nsvg__isspace(*s)) s++;

// Check if the tag is end tag

if (*s == '/') {

s++;

end = 1;

} else {

start = 1;

}

// Skip comments, data and preprocessor stuff.

if (!*s || *s == '?' || *s == '!')

return;

// Get tag name

name = s;

while (*s && !nsvg__isspace(*s)) s++;

if (*s) { *s++ = '\0'; }

// Get attribs

while (!end && *s && nattr < NSVG_XML_MAX_ATTRIBS-3) {

// Skip white space before the attrib name

while (*s && nsvg__isspace(*s)) s++;

if (!*s) break;

if (*s == '/') {

end = 1;

break;

}

attr[nattr++] = s;

// Find end of the attrib name.

while (*s && !nsvg__isspace(*s) && *s != '=') s++;

if (*s) { *s++ = '\0'; }

// Skip until the beginning of the value.

while (*s && *s != '\"' && *s != '\'') s++;

if (!*s) break;

quote = *s;

s++;

// Store value and find the end of it.

attr[nattr++] = s;

while (*s && *s != quote) s++;

if (*s) { *s++ = '\0'; }

}

// List terminator

attr[nattr++] = 0;

attr[nattr++] = 0;

// Call callbacks.

if (start && startelCb)

(*startelCb)(ud, name, attr);

if (end && endelCb)

(*endelCb)(ud, name);

}

int nsvg__parseXML(char* input,

void* ud)

{

char* s = input;

char* mark = s;

int state = NSVG_XML_CONTENT;

while (*s) {

if (*s == '<' && state == NSVG_XML_CONTENT) {

// Start of a tag

*s++ = '\0';

nsvg__parseContent(mark, contentCb, ud);

mark = s;

state = NSVG_XML_TAG;

} else if (*s == '>' && state == NSVG_XML_TAG) {

// Start of a content or new tag.

*s++ = '\0';

nsvg__parseElement(mark, startelCb, endelCb, ud);

mark = s;

state = NSVG_XML_CONTENT;

} else {

s++;

}

}

return 1;

}

/* Simple SVG parser. */

#define NSVG_MAX_ATTR 128

enum NSVGgradientUnits {

NSVG_USER_SPACE = 0,

NSVG_OBJECT_SPACE = 1,

};

#define NSVG_MAX_DASHES 8

enum NSVGunits {

};

typedef struct NSVGcoordinate {

float value;

int units;

} NSVGcoordinate;

typedef struct NSVGlinearData {

NSVGcoordinate x1, y1, x2, y2;

} NSVGlinearData;

typedef struct NSVGradialData {

NSVGcoordinate cx, cy, r, fx, fy;

} NSVGradialData;

typedef struct NSVGgradientData

} NSVGgradientData;

typedef struct NSVGattrib

} NSVGattrib;

typedef struct NSVGparser

} NSVGparser;

static void nsvg__xformIdentity(float* t)

{

t[0] = 1.0f; t[1] = 0.0f;

t[2] = 0.0f; t[3] = 1.0f;

t[4] = 0.0f; t[5] = 0.0f;

}

static void nsvg__xformSetTranslation(float* t, float tx, float ty)

{

t[0] = 1.0f; t[1] = 0.0f;

t[2] = 0.0f; t[3] = 1.0f;

t[4] = tx; t[5] = ty;

}

static void nsvg__xformSetScale(float* t, float sx, float sy)

{

t[0] = sx; t[1] = 0.0f;

t[2] = 0.0f; t[3] = sy;

t[4] = 0.0f; t[5] = 0.0f;

}

static void nsvg__xformSetSkewX(float* t, float a)

{

t[0] = 1.0f; t[1] = 0.0f;

t[2] = tanf(a); t[3] = 1.0f;

t[4] = 0.0f; t[5] = 0.0f;

}

static void nsvg__xformSetSkewY(float* t, float a)

{

t[0] = 1.0f; t[1] = tanf(a);

t[2] = 0.0f; t[3] = 1.0f;

t[4] = 0.0f; t[5] = 0.0f;

}

static void nsvg__xformSetRotation(float* t, float a)

{

float cs = cosf(a), sn = sinf(a);

t[0] = cs; t[1] = sn;

t[2] = -sn; t[3] = cs;

t[4] = 0.0f; t[5] = 0.0f;

}

static void nsvg__xformMultiply(float* t, float* s)

{

float t0 = t[0] * s[0] + t[1] * s[2];

float t2 = t[2] * s[0] + t[3] * s[2];

float t4 = t[4] * s[0] + t[5] * s[2] + s[4];

t[1] = t[0] * s[1] + t[1] * s[3];

t[3] = t[2] * s[1] + t[3] * s[3];

t[5] = t[4] * s[1] + t[5] * s[3] + s[5];

t[0] = t0;

t[2] = t2;

t[4] = t4;

}

static void nsvg__xformInverse(float* inv, float* t)

{

double invdet, det = (double)t[0] * t[3] - (double)t[2] * t[1];

if (det > -1e-6 && det < 1e-6) {

nsvg__xformIdentity(t);

return;

}

invdet = 1.0 / det;

inv[0] = (float)(t[3] * invdet);

inv[2] = (float)(-t[2] * invdet);

inv[4] = (float)(((double)t[2] * t[5] - (double)t[3] * t[4]) * invdet);

inv[1] = (float)(-t[1] * invdet);

inv[3] = (float)(t[0] * invdet);

inv[5] = (float)(((double)t[1] * t[4] - (double)t[0] * t[5]) * invdet);

}

static void nsvg__xformPremultiply(float* t, float* s)

{

float s2[6];

memcpy(s2, s, sizeof(float)*6);

nsvg__xformMultiply(s2, t);

memcpy(t, s2, sizeof(float)*6);

}

static void nsvg__xformPoint(float* dx, float* dy, float x, float y, float* t)

{

*dx = x*t[0] + y*t[2] + t[4];

*dy = x*t[1] + y*t[3] + t[5];

}

static void nsvg__xformVec(float* dx, float* dy, float x, float y, float* t)

{

*dx = x*t[0] + y*t[2];

*dy = x*t[1] + y*t[3];

}

#define NSVG_EPSILON (1e-12)

static int nsvg__ptInBounds(float* pt, float* bounds)

{

return pt[0] >= bounds[0] && pt[0] <= bounds[2] && pt[1] >= bounds[1] && pt[1] <= bounds[3];

}

static double nsvg__evalBezier(double t, double p0, double p1, double p2, double p3)

{

double it = 1.0-t;

return it*it*it*p0 + 3.0*it*it*t*p1 + 3.0*it*t*t*p2 + t*t*t*p3;

}

static void nsvg__curveBounds(float* bounds, float* curve)

{

int i, j, count;

double roots[2], a, b, c, b2ac, t, v;

float* v0 = &curve[0];

float* v1 = &curve[2];

float* v2 = &curve[4];

float* v3 = &curve[6];

// Start the bounding box by end points

bounds[0] = nsvg__minf(v0[0], v3[0]);

bounds[1] = nsvg__minf(v0[1], v3[1]);

bounds[2] = nsvg__maxf(v0[0], v3[0]);

bounds[3] = nsvg__maxf(v0[1], v3[1]);

// Bezier curve fits inside the convex hull of it's control points.

// If control points are inside the bounds, we're done.

if (nsvg__ptInBounds(v1, bounds) && nsvg__ptInBounds(v2, bounds))

return;

// Add bezier curve inflection points in X and Y.

for (i = 0; i < 2; i++) {

a = -3.0 * v0[i] + 9.0 * v1[i] - 9.0 * v2[i] + 3.0 * v3[i];

b = 6.0 * v0[i] - 12.0 * v1[i] + 6.0 * v2[i];

c = 3.0 * v1[i] - 3.0 * v0[i];

count = 0;

if (fabs(a) < NSVG_EPSILON) {

if (fabs(b) > NSVG_EPSILON) {

t = -c / b;

if (t > NSVG_EPSILON && t < 1.0-NSVG_EPSILON)

roots[count++] = t;

}

} else {

b2ac = b*b - 4.0*c*a;

if (b2ac > NSVG_EPSILON) {

t = (-b + sqrt(b2ac)) / (2.0 * a);

if (t > NSVG_EPSILON && t < 1.0-NSVG_EPSILON)

roots[count++] = t;

t = (-b - sqrt(b2ac)) / (2.0 * a);

if (t > NSVG_EPSILON && t < 1.0-NSVG_EPSILON)

roots[count++] = t;

}

}

for (j = 0; j < count; j++) {

v = nsvg__evalBezier(roots[j], v0[i], v1[i], v2[i], v3[i]);

bounds[0+i] = nsvg__minf(bounds[0+i], (float)v);

bounds[2+i] = nsvg__maxf(bounds[2+i], (float)v);

}

}

}

static NSVGparser* nsvg__createParser()

{

NSVGparser* p;

p = (NSVGparser*)malloc(sizeof(NSVGparser));

if (p == NULL) goto error;

memset(p, 0, sizeof(NSVGparser));

p->image = (NSVGimage*)malloc(sizeof(NSVGimage));

if (p->image == NULL) goto error;

memset(p->image, 0, sizeof(NSVGimage));

// Init style

nsvg__xformIdentity(p->attr[0].xform);

memset(p->attr[0].id, 0, sizeof p->attr[0].id);

p->attr[0].fillColor = NSVG_RGB(0,0,0);

p->attr[0].strokeColor = NSVG_RGB(0,0,0);

p->attr[0].opacity = 1;

p->attr[0].fillOpacity = 1;

p->attr[0].strokeOpacity = 1;

p->attr[0].stopOpacity = 1;

p->attr[0].strokeWidth = 1;

p->attr[0].strokeLineJoin = NSVG_JOIN_MITER;

p->attr[0].strokeLineCap = NSVG_CAP_BUTT;

p->attr[0].fillRule = NSVG_FILLRULE_NONZERO;

p->attr[0].hasFill = 1;

p->attr[0].visible = 1;

return p;

error:

if (p) {

if (p->image) free(p->image);

free(p);

}

return NULL;

}

static void nsvg__deletePaths(NSVGpath* path)

{

while (path) {

NSVGpath *next = path->next;

if (path->pts != NULL)

free(path->pts);

free(path);

path = next;

}

}

static void nsvg__deletePaint(NSVGpaint* paint)

{

if (paint->type == NSVG_PAINT_LINEAR_GRADIENT || paint->type == NSVG_PAINT_RADIAL_GRADIENT)

free(paint->gradient);

}

static void nsvg__deleteGradientData(NSVGgradientData* grad)

{

NSVGgradientData* next;

while (grad != NULL) {

next = grad->next;

free(grad->stops);

free(grad);

grad = next;

}

}

static void nsvg__deleteParser(NSVGparser* p)

{

if (p != NULL) {

nsvg__deletePaths(p->plist);

nsvg__deleteGradientData(p->gradients);

nsvgDelete(p->image);

free(p->pts);

free(p);

}

}

static void nsvg__resetPath(NSVGparser* p)

{

p->npts = 0;

}

static void nsvg__addPoint(NSVGparser* p, float x, float y)

{

if (p->npts+1 > p->cpts) {

p->cpts = p->cpts ? p->cpts*2 : 8;

p->pts = (float*)realloc(p->pts, p->cpts*2*sizeof(float));

if (!p->pts) return;

}

p->pts[p->npts*2+0] = x;

p->pts[p->npts*2+1] = y;

p->npts++;

}

static void nsvg__moveTo(NSVGparser* p, float x, float y)

{

if (p->npts > 0) {

p->pts[(p->npts-1)*2+0] = x;

p->pts[(p->npts-1)*2+1] = y;

} else {

nsvg__addPoint(p, x, y);

}

}

static void nsvg__lineTo(NSVGparser* p, float x, float y)

{

float px,py, dx,dy;

if (p->npts > 0) {

px = p->pts[(p->npts-1)*2+0];

py = p->pts[(p->npts-1)*2+1];

dx = x - px;

dy = y - py;

nsvg__addPoint(p, px + dx/3.0f, py + dy/3.0f);

nsvg__addPoint(p, x - dx/3.0f, y - dy/3.0f);

nsvg__addPoint(p, x, y);

}

}

static void nsvg__cubicBezTo(NSVGparser* p, float cpx1, float cpy1, float cpx2, float cpy2, float x, float y)

{

nsvg__addPoint(p, cpx1, cpy1);

nsvg__addPoint(p, cpx2, cpy2);

nsvg__addPoint(p, x, y);

}

static NSVGattrib* nsvg__getAttr(NSVGparser* p)

{

return &p->attr[p->attrHead];

}

static void nsvg__pushAttr(NSVGparser* p)

{

if (p->attrHead < NSVG_MAX_ATTR-1) {

p->attrHead++;

memcpy(&p->attr[p->attrHead], &p->attr[p->attrHead-1], sizeof(NSVGattrib));

}

}

static void nsvg__popAttr(NSVGparser* p)

{

if (p->attrHead > 0)

p->attrHead--;

}

static float nsvg__actualOrigX(NSVGparser* p)

{

return p->viewMinx;

}

static float nsvg__actualOrigY(NSVGparser* p)

{

return p->viewMiny;

}

static float nsvg__actualWidth(NSVGparser* p)

{

return p->viewWidth;

}

static float nsvg__actualHeight(NSVGparser* p)

{

return p->viewHeight;

}

static float nsvg__actualLength(NSVGparser* p)

{

float w = nsvg__actualWidth(p), h = nsvg__actualHeight(p);

return sqrtf(w*w + h*h) / sqrtf(2.0f);

}

static float nsvg__convertToPixels(NSVGparser* p, NSVGcoordinate c, float orig, float length)

{

NSVGattrib* attr = nsvg__getAttr(p);

switch (c.units) {

case NSVG_UNITS_USER: return c.value;

case NSVG_UNITS_PX: return c.value;

case NSVG_UNITS_PT: return c.value / 72.0f * p->dpi;

case NSVG_UNITS_PC: return c.value / 6.0f * p->dpi;

case NSVG_UNITS_MM: return c.value / 25.4f * p->dpi;

case NSVG_UNITS_CM: return c.value / 2.54f * p->dpi;

case NSVG_UNITS_IN: return c.value * p->dpi;

case NSVG_UNITS_EM: return c.value * attr->fontSize;

case NSVG_UNITS_EX: return c.value * attr->fontSize * 0.52f; // x-height of Helvetica.

case NSVG_UNITS_PERCENT: return orig + c.value / 100.0f * length;

default: return c.value;

}

return c.value;

}

static NSVGgradientData* nsvg__findGradientData(NSVGparser* p, const char* id)

{

NSVGgradientData* grad = p->gradients;

while (grad) {

if (strcmp(grad->id, id) == 0)

return grad;

grad = grad->next;

}

return NULL;

}

static NSVGgradient* nsvg__createGradient(NSVGparser* p, const char* id, const float* localBounds, char* paintType)

{

NSVGattrib* attr = nsvg__getAttr(p);

NSVGgradientData* data = NULL;

NSVGgradientData* ref = NULL;

NSVGgradientStop* stops = NULL;

NSVGgradient* grad;

float ox, oy, sw, sh, sl;

int nstops = 0;

data = nsvg__findGradientData(p, id);

if (data == NULL) return NULL;

// TODO: use ref to fill in all unset values too.

ref = data;

while (ref != NULL) {

if (stops == NULL && ref->stops != NULL) {

stops = ref->stops;

nstops = ref->nstops;

break;

}

ref = nsvg__findGradientData(p, ref->ref);

}

if (stops == NULL) return NULL;

grad = (NSVGgradient*)malloc(sizeof(NSVGgradient) + sizeof(NSVGgradientStop)*(nstops-1));

if (grad == NULL) return NULL;

// The shape width and height.

if (data->units == NSVG_OBJECT_SPACE) {

ox = localBounds[0];

oy = localBounds[1];

sw = localBounds[2] - localBounds[0];

sh = localBounds[3] - localBounds[1];

} else {

ox = nsvg__actualOrigX(p);

oy = nsvg__actualOrigY(p);

sw = nsvg__actualWidth(p);

sh = nsvg__actualHeight(p);

}

sl = sqrtf(sw*sw + sh*sh) / sqrtf(2.0f);

if (data->type == NSVG_PAINT_LINEAR_GRADIENT) {

float x1, y1, x2, y2, dx, dy;

x1 = nsvg__convertToPixels(p, data->linear.x1, ox, sw);

y1 = nsvg__convertToPixels(p, data->linear.y1, oy, sh);

x2 = nsvg__convertToPixels(p, data->linear.x2, ox, sw);

y2 = nsvg__convertToPixels(p, data->linear.y2, oy, sh);

// Calculate transform aligned to the line

dx = x2 - x1;

dy = y2 - y1;

grad->xform[0] = dy; grad->xform[1] = -dx;

grad->xform[2] = dx; grad->xform[3] = dy;

grad->xform[4] = x1; grad->xform[5] = y1;

} else {

float cx, cy, fx, fy, r;

cx = nsvg__convertToPixels(p, data->radial.cx, ox, sw);

cy = nsvg__convertToPixels(p, data->radial.cy, oy, sh);

fx = nsvg__convertToPixels(p, data->radial.fx, ox, sw);

fy = nsvg__convertToPixels(p, data->radial.fy, oy, sh);

r = nsvg__convertToPixels(p, data->radial.r, 0, sl);

// Calculate transform aligned to the circle

grad->xform[0] = r; grad->xform[1] = 0;

grad->xform[2] = 0; grad->xform[3] = r;

grad->xform[4] = cx; grad->xform[5] = cy;

grad->fx = fx / r;

grad->fy = fy / r;

}

nsvg__xformMultiply(grad->xform, data->xform);

nsvg__xformMultiply(grad->xform, attr->xform);

grad->spread = data->spread;

memcpy(grad->stops, stops, nstops*sizeof(NSVGgradientStop));

grad->nstops = nstops;

*paintType = data->type;

return grad;

}

static float nsvg__getAverageScale(float* t)

{

float sx = sqrtf(t[0]*t[0] + t[2]*t[2]);

float sy = sqrtf(t[1]*t[1] + t[3]*t[3]);

return (sx + sy) * 0.5f;

}

static void nsvg__getLocalBounds(float* bounds, NSVGshape *shape, float* xform)

{

NSVGpath* path;

float curve[4*2], curveBounds[4];

int i, first = 1;

for (path = shape->paths; path != NULL; path = path->next) {

nsvg__xformPoint(&curve[0], &curve[1], path->pts[0], path->pts[1], xform);

for (i = 0; i < path->npts-1; i += 3) {

nsvg__xformPoint(&curve[2], &curve[3], path->pts[(i+1)*2], path->pts[(i+1)*2+1], xform);

nsvg__xformPoint(&curve[4], &curve[5], path->pts[(i+2)*2], path->pts[(i+2)*2+1], xform);

nsvg__xformPoint(&curve[6], &curve[7], path->pts[(i+3)*2], path->pts[(i+3)*2+1], xform);

nsvg__curveBounds(curveBounds, curve);

if (first) {

bounds[0] = curveBounds[0];

bounds[1] = curveBounds[1];

bounds[2] = curveBounds[2];

bounds[3] = curveBounds[3];

first = 0;

} else {

bounds[0] = nsvg__minf(bounds[0], curveBounds[0]);

bounds[1] = nsvg__minf(bounds[1], curveBounds[1]);

bounds[2] = nsvg__maxf(bounds[2], curveBounds[2]);

bounds[3] = nsvg__maxf(bounds[3], curveBounds[3]);

}

curve[0] = curve[6];

curve[1] = curve[7];

}

}

}

static void nsvg__addShape(NSVGparser* p)

{

NSVGattrib* attr = nsvg__getAttr(p);

float scale = 1.0f;

NSVGshape *shape, *cur, *prev;

NSVGpath* path;

int i;

if (p->plist == NULL)

return;

shape = (NSVGshape*)malloc(sizeof(NSVGshape));

if (shape == NULL) goto error;

memset(shape, 0, sizeof(NSVGshape));

memcpy(shape->id, attr->id, sizeof shape->id);

scale = nsvg__getAverageScale(attr->xform);

shape->strokeWidth = attr->strokeWidth * scale;

shape->strokeDashOffset = attr->strokeDashOffset * scale;

shape->strokeDashCount = attr->strokeDashCount;

for (i = 0; i < attr->strokeDashCount; i++)

shape->strokeDashArray[i] = attr->strokeDashArray[i] * scale;

shape->strokeLineJoin = attr->strokeLineJoin;

shape->strokeLineCap = attr->strokeLineCap;

shape->fillRule = attr->fillRule;

shape->opacity = attr->opacity;

shape->paths = p->plist;

p->plist = NULL;

// Calculate shape bounds

shape->bounds[0] = shape->paths->bounds[0];

shape->bounds[1] = shape->paths->bounds[1];

shape->bounds[2] = shape->paths->bounds[2];

shape->bounds[3] = shape->paths->bounds[3];

for (path = shape->paths->next; path != NULL; path = path->next) {

shape->bounds[0] = nsvg__minf(shape->bounds[0], path->bounds[0]);

shape->bounds[1] = nsvg__minf(shape->bounds[1], path->bounds[1]);

shape->bounds[2] = nsvg__maxf(shape->bounds[2], path->bounds[2]);

shape->bounds[3] = nsvg__maxf(shape->bounds[3], path->bounds[3]);

}

// Set fill

if (attr->hasFill == 0) {

shape->fill.type = NSVG_PAINT_NONE;

} else if (attr->hasFill == 1) {

shape->fill.type = NSVG_PAINT_COLOR;

shape->fill.color = attr->fillColor;

shape->fill.color |= (unsigned int)(attr->fillOpacity*255) << 24;

} else if (attr->hasFill == 2) {

float inv[6], localBounds[4];

nsvg__xformInverse(inv, attr->xform);

nsvg__getLocalBounds(localBounds, shape, inv);

shape->fill.gradient = nsvg__createGradient(p, attr->fillGradient, localBounds, &shape->fill.type);

if (shape->fill.gradient == NULL) {

shape->fill.type = NSVG_PAINT_NONE;

}

}

// Set stroke

if (attr->hasStroke == 0) {

shape->stroke.type = NSVG_PAINT_NONE;

} else if (attr->hasStroke == 1) {

shape->stroke.type = NSVG_PAINT_COLOR;

shape->stroke.color = attr->strokeColor;

shape->stroke.color |= (unsigned int)(attr->strokeOpacity*255) << 24;

} else if (attr->hasStroke == 2) {

float inv[6], localBounds[4];

nsvg__xformInverse(inv, attr->xform);

nsvg__getLocalBounds(localBounds, shape, inv);

shape->stroke.gradient = nsvg__createGradient(p, attr->strokeGradient, localBounds, &shape->stroke.type);

if (shape->stroke.gradient == NULL)

shape->stroke.type = NSVG_PAINT_NONE;

}

// Set flags

shape->flags = (attr->visible ? NSVG_FLAGS_VISIBLE : 0x00);

// Add to tail

prev = NULL;

cur = p->image->shapes;

while (cur != NULL) {

prev = cur;

cur = cur->next;