C++精灵库 其它命令等 教程，本教程已内置于pxC++编辑器内。

初级用户主要掌握三个命令即可。randint命令，返回整数区间内随机整数。
random命令，返回的是一定范围内的小数。oneof命令，返回两者之一。

1. to_world_xy
作用: 转换为世界坐标系。应用场景主要在在获取鼠标指针坐标时，得到的坐标是屏幕坐标系的，根据情况需要转换成世界坐标系。
用法:
int x=100,y=100; //这里x,y当成屏幕坐标系(左上角为原点,y轴向下为正)
to_world_xy(x,y); //x,y当成引用调用，调用后其值被改变

2. to_screen_xy
作用: 转换为屏幕坐标系。
用法:
int x=100,y=100; //这里x,y当成世界坐标系(中间为原点，y轴向上为正)
to_world_xy(x,y); //x,y当成引用调用，调用后其值被改变

3. randint
作用: 在整数区间[a,b]随机选择一个整数。
用法：
int x = randint(1,100);

4. random
作用： 在浮点数区间[a,b]随机选择一个浮点数。
用法:
float x = random(1.0,100.0);

5. oneof
作用： 在两个对象之间随机选择一个。
用法:
int x = oneof(32,76); //在两个整数之间选择一个
Sprite *p = oneof(&turtle,&rocket);//两个角色间选择一个,注意返回的是指针

6. inputbox
作用: 弹出一个输入框，让用户输入文本。
用法: std::string name = inputbox(“姓名”, “请输入您的名字:”);

7. messagebox
作用: 弹出一个消息提示框。
用法:
信息框: messagebox(“提示”, “操作成功!”);
警告框: messagebox(“警告”, “文件未找到!”, SDL_MESSAGEBOX_WARNING);
错误框: messagebox(“错误”, “发生致命错误!”, SDL_MESSAGEBOX_ERROR);

8. svg2png
作用: 把svg图转换成png图。
举例:
const char* inputSvgFile = “F:\\萍乡风火轮编程基地\\blank.svg”; //输入svg
const char* outputPngFile = “F:\\萍乡风火轮编程基地\\blank.png”; //输出png
float scaleFactor = 2.0f; // 缩放因子，这里放大2倍
svg2png(inputSvgFile, outputPngFile, scaleFactor);
成功则返回真，失败返回假。

9. Point类
作用: 描述一个二维坐标点
用法: Point p0 = (100.0,100.0);
std::cout << p0.x << std::endl; //输入p0点的x坐标
std::cout << p0.y << std::endl; //输入p0点的y坐标
sprite.go(p0); //让角到到达p0点

在C++精灵库中的定义:
struct Point {
double x, y;
Point();
Point(double x, double y);
………..高级用户有兴趣可查阅polygon_offset.h头文件
};

10. get_angle
作用: 接收不共线的三个点坐标，返回一个角度的大小。
用法: float angle = get_angle({1.0,0},{0,1.0},{0,0} ); //得到45度

11. Color类
作用: 描述一种颜色
用法:
int h = 0; //色相
Uint8 r,g,b; //红，绿，蓝
Color temp;
temp.hsvToRgb(h,1.0,1.0,r,g,b); //hsv转rgb

定义:
class Color {
private:
SDL_Color color;

public:
// 构造函数
Color(Uint8 r = 0, Uint8 g = 0, Uint8 b = 0, Uint8 a = 255);
Color(const SDL_Color& sdlColor);

// 获取SDL2库中的SDL_Color
SDL_Color get() const;
std::string gethex() const; //获取16进制RGB字符串
void rgbToHsv(Uint8 r, Uint8 g, Uint8 b, float& h, float& s, float& v) const;
void hsvToRgb(float h, float s, float v, Uint8& r, Uint8& g, Uint8& b) const;
……….高级用户有兴趣可查阅coloradd.h头文件学习SDL_Color等知识。
}

12. SDL_Rect
作用: 它是一个类,用于描述一个矩形
用法:
SDL_Rect r = {-200,20,400,40};//矩形左上角坐标是(-200,20),宽高是400×40。
std::cout << r.x << std::endl; // 矩形左上角x坐标
std::cout << r.y << std::endl; // 矩形左上角y坐标
std::cout << r.w << std::endl; // 矩形宽度
std::cout << r.h << std::endl; // 矩形高度

13. 关于HSV

请看示例程序:

/*
非bug提示，设为黑色或者灰色与白色时，再增加画笔颜色的色相，将不会增加。
这个”特性”不是bug，而是HSV/HSL颜色模型的数学特性在图形库中的正确实现。
如果你想看到颜色变化的效果，需要先设定一个非黑、非灰、非白的颜色（即饱和度不为0的颜色）。
*/
#include “sprites.h” //包含C++精灵库
Sprite rocket; //建立角色叫rocket

int main(){ //主功能块
rocket.pencolor(“black”).speed(0);
std::cout << “饱和度=” << rocket.pensat() << std::endl; //输出结果是0
std::cout << “色调=” << rocket.pentone() << std::endl; //输出结果是0
for(int i=0;i<360;i++)
//这个现象的本质不是coloradd()方法失效，
//而是基于HSV（色相 – 饱和度 – 明度）颜色模型的颜色属性特性
rocket.coloradd(1).fd(1);
rocket.done();
return 0;
}

14. 关于造型名字映射
在C++精灵库中，有几个特殊的字符串可以直接指定造型。
这些字符串是： bug，rocket，turtle，classic，arrow，triangle，blank，square，circle，star， pointer。
它们和图片路径的映射关系如下:
std::map<std::string,std::string> named_shapes= { {“bug”,”res/bug.png”}, {“rocket”,”res/rocket.png”},
{“turtle”,”res/turtle.png”}, {“classic”,”res/classic.png”}, {“arrow”,”res/arrow.png”},
{“triangle”,”res/triangle.png”}, {“blank”,”res/blank.png”}, {“square”,”res/square.png”},
{“circle”,”res/circle.png”},{“star”,”res/star.png”},{“pointer”,”res/pointer.png”} };
设角色名为rocket，用户可以往这个映射里增加一个键值对，如下所示:
named_shapes[“pig”] = “res/pig.png”;
然后就可以用代码:
rocket.shape(“pig”);
来设定rocket，让它的造型为res目录下面的pig.png图片了。

C++精灵库 Screen 类方法教程，本教程已内置于pxC++编辑器。

在C++精灵库中有两大类，一个是Sprite类，另一个就是Screen类。Screen类用于新建窗口屏幕。规则是先建立屏幕对象,再建立角色。如果先建立角色，则角色会自动建立一个屏幕对象，它的全局指针是g_screen。屏幕对象只要建立一个，后面建立的会自动无效。窗口默认宽度为屏幕计算机水平分辨率的1/2,高度为3/4。

1. Screen (构造函数)
作用: 创建一个屏幕窗口对象,默认原点在中心, x轴向右为正,y轴向上为正的世界坐标系。首次运行会建立res目录,释放一些图片。用户可以在res目录下放置更多的png图片以增加角色造型的丰富性。
用法:
Screen sc：创建一个名为sc，标题默认 “C++ Sprites Library” 的窗口。
Screen *sc = new Screen(“我的游戏”, 800, 600)：创建一个 800×600 像素、标题为 “我的游戏” 的窗口，其指针赋值给sc。

2. title
作用: 设置或获取窗口的标题。
用法:
设置标题: screen.title(“中华C++精灵库”);
获取标题: std::string currentTitle = screen.title();

3. setup
作用: 设置窗口的宽度和高度。
用法: screen.setup(1024, 768); // 将窗口大小调整为 1024×768
返回对屏幕对象的引用。

4. clear
作用: 清空屏幕，将其填充为当前背景色。
用法: screen.clear(); // 屏幕变背景色
返回对屏幕对象的引用。

5. g_screen (全局屏幕指针)
作用: 它是在新建角色或者新建屏幕后的全局屏幕指针，用于通过指针调用屏幕的方法。
用法: g_screen->clear(); //清除角色所画图形
举例:
#include “sprites.h” //包含C++精灵库
Sprite rocket; //建立角色叫rocket

int main(){ //主功能块
// g_screen是全局屏幕对象的指针，要在新建角色后才有,如果没有建立角色或者屏幕,则  它是野指针,会导致内存错误!
g_screen->bgcolor(“lime”); //背景颜色为lime色
while(g_screen->exitonclick()){ //单击关闭窗口
g_screen->clear(); // 清除角色所画的图案
rocket.fd(1); //角色前进1个单位
g_screen->wait(0.01); //等待0.01秒
}
return 0;
}

6. update_mode / tracer (别名)
作用: 切换屏幕的自动/手动刷新模式。
用法:
screen.update_mode(true); 或 screen.tracer(true); // 启用自动刷新（默认）。每次绘图后屏幕会追踪(trace)角色的绘图及相关变化,会自动更新屏幕显示。
screen.update_mode(false); 或 screen.tracer(false); // 启用手动刷新。需要你显式调用 update() 方法才能看到画面变化，这在动画中能提升性能。
加参数时返回true或者false。
不加参数时返回对屏幕对象的引用。

7. update
作用: 手动刷新屏幕，将所有绘制操作显示出来。
用法: 在手动更新模式下（见 update_mode），完成所有绘制后调用 screen.update()来显示画面。
返回对屏幕对象的引用。
举例:
#include “sprites.h” //包含C++精灵库
Screen sc; //新建屏幕对象叫sc
Sprite rocket; //建立角色叫rocket

int main(){ //主功能块
sc.tracer(0); //关闭自动刷新
while(sc.exitonclick()){ //单击关闭窗口
sc.clear();
for(int i=0;i<4;i++)
rocket.fd(100).left(90);
sc.update(); //刷新，此时才显示画的图案
sc.wait(0.01); //等待0.01秒
rocket.fd(1);
}
return 0;
}

7. bgcolor / fill (别名)
作用: 设置屏幕的背景颜色。
用法 (多种颜色表示方式):
字符串: screen.bgcolor(“red”); 或 screen.fill(“lightblue”);
RGB值: screen.bgcolor(255, 0, 0); // 红色
HSV的色相值: screen.bgcolor(120); // 120度是绿色 (0-360)
SDL_Color: screen.bgcolor({0, 255, 0, 255}); // 绿色，关于SDL_Color类，请自行查阅SDL2库资料。
返回对屏幕对象的引用。

8. delay
作用: 设置或获取全局延迟（以毫秒为单位，默认为0毫秒）。
用法:
设置延迟: screen.delay(100); // 设置全局延迟为100毫秒,返回对屏幕对象的引用。
获取延迟: unsigned int curdelay= screen.delay();

9. mainloop / done (别名)
作用: 启动主事件循环，保持窗口打开并响应事件（如关闭按钮）。
用法: 在程序最后调用 screen.mainloop() 或 screen.done()。程序会在此处暂停，直到用户关闭窗口。

10. width / height
作用: 获取屏幕的宽度和高度。
用法:
int w = screen.width();
int h = screen.height();

11. exitonclick
作用: 让程序在用户点击窗口关闭按钮时退出主循环。
用法: 通常在 mainloop 之前调用。如果返回 false，表示用户已点击窗口的关闭按钮。
while(screen.exitonclick()) {
// 你的游戏循环代码
screen.update();
}
返回对屏幕对象的引用。

12. wait
作用: 让程序暂停指定的秒数。
用法: screen.wait(2.5f); // 暂停 2.5 秒
返回对屏幕对象的引用。

13. get_ticks
作用: 获取自程序启动以来经过的毫秒数。
用法: Uint32 startTime = screen.get_ticks(); // 常用于计时和控制帧率。

14. loadbackground / addbackground / addbg
作用: 加载一张图片作为背景，并将其添加到背景”列表”中。
用法: screen.addbackground(“path/to/background.jpg”);
返回SDL_Texture*。

15. removebackground / removebg
作用: 从背景列表中移除指定路径的背景图片。
用法: screen.removebackground(“path/to/background.jpg”);
返回对屏幕对象的引用。

16. bgpic
作用: 设置当前显示的背景图片。
用法: screen.bgpic(“path/to/my_bg.png”);
返回对屏幕对象的引用。

17. next_bg / nextbg / next_background
作用: 切换到背景列表中的下一张背景图。
用法: screen.next_bg();
返回对屏幕对象的引用。

18. pre_bg / prebg / pre_background
作用: 切换到背景列表中的上一张背景图。
用法: screen.pre_bg();
返回对屏幕对象的引用。

19. set_background
作用: 通过索引或文件路径直接设置当前背景。
用法:
按索引: screen.set_background(2); // 显示列表中的第3张图（索引从0开始）
按路径: screen.set_background(“my_image.png”);
返回对屏幕对象的引用。

20. xy_grid / xygrid
作用: 在屏幕上绘制或设置坐标网格。
用法:
绘制网格: screen.xy_grid(50); // 绘制间距为50像素的网格线
获取网格间距: int step = screen.xy_grid(); //即不加参数返回格子边长
加参数时返回对屏幕对象的引用。
不加参数时返回格子边长。

21. setpixel
作用: 在屏幕的指定坐标 (x, y) 处绘制一个像素点。
用法:
screen.setpixel(100, 200, {255, 0, 0, 255}); // 在(100,200)画一个红色像素
screen.setpixel(100, 200, “blue”); // 使用颜色名称
无返回值。

22. getpixel
作用: 获取屏幕指定坐标 (x, y) 处像素的颜色，返回颜色对象。
用法: Color color = screen.getpixel(100, 200); // 可通过color.gethex()得到16进制颜色值，如”#ff0000″
举例:
#include “sprites.h” //包含C++精灵库
Screen sc; //新建屏幕对象叫sc
Sprite rocket; //建立角色叫rocket

int main(){ //主功能块
rocket.speed(0).bk(180).pensize(20).color(0);
for(int i=0;i<360;i++)
rocket.fd(1).coloradd(1);
while(sc.exitonclick()){ //单击关闭窗口
int mouseX, mouseY; // 用于存储鼠标位置
Uint32 mouseState = SDL_GetMouseState(&mouseX, &mouseY);
to_world_xy(mouseX,mouseY); //转为世界座标
Color cc = sc.getpixel(mouseX,mouseY);
std::cout << cc.gethex() << ‘ ‘;
sc.wait(0.01); //等待0.01秒
}
return 0;
}

23. savepng
作用: 将当前屏幕内容保存为png图片文件。
用法:
截屏整个屏幕: screen.savepng(“screenshot.png”); //不是指windows整个屏幕，而是指窗口整个屏幕。
截屏指定区域: screen.savepng(“region.png”, {100, 100, 200, 200}); // 保存从矩形左上角(100,100)开始的200×200区域，如果再加是一个bool参数，为真的话表示只截绘画内容。
截屏指定区域并且不截角色本身：screen.savepng(“onlypaint.png”,{-10,10,100,200},true};
成功返回true,失败返回false。
举例:
#include “sprites.h” //包含C++精灵库
Screen sc; //新建屏幕对象叫sc
Sprite rocket; //建立角色叫rocket

int main(){ //主功能块
rocket.speed(0).bk(180).pensize(40).color(0);
for(int i=0;i<360;i++)
rocket.fd(1).coloradd(1);
//由于线宽是40，所以要完整截所绘的图形起始x坐标应该是-200。
SDL_Rect r = {-180-20,20,360+40,40} ;
//截取r指定区域内图形，但不截取角色本身。
sc.savepng(“res/testcapture.png”,r,true);
sc.mainloop();
return 0;
}

C++精灵库 Sprite（角色/精灵）类方法教程。本教程已内置于pxC++编辑器。

在C++精灵库中有两大类型，一个是Screen(屏幕)类，另一个就是Sprite(角色)类。Sprite类用于实例化一个角色。角色藏有一只看不见的画笔。用户可以通过角色的方法对画笔进行设定。如画笔颜色、线宽、填充颜色。角色可以前进、倒退、左转、右转、变大变小等等。用户通过符合逻辑的代码组合，不仅能画出漂亮的图案，还能制作动画与交互作品。在C++精灵库中,画笔的颜色最终由r,g,b,a值决定。所有通过设定颜色的色相、饱和度、明度最终都会转换为RGBA值。并且在规定色相的取值范围是0到360，而饱和度和明度的取值范围是0.0到100.0。至于画笔的shade值，它是一个综合的值，用于描述色彩的深浅度。shade值为0时表示颜色最深，值为100时表示颜色最浅(白色)。

1. Sprite (角色类的构造函数名)
作用: 创建一个角色对象，自动地关联到第一个新建立的屏幕,如果没有新建屏幕对象,则会自动建立一个,以后手动建立的屏幕对象无效。
用法:
Sprite rocket; //创建一个叫rocket角色，选型默认是一枚小火箭。
Sprite t(“turtle”); //创建一个叫t的角色，造型是海龟,自动关联到”res/turtle.png”图片为造型。
Sprite t(“blank”); //创建一个叫t的角色，没有造型。
Sprite t{“res/turtle.png”}; //创建一个叫t角色，造型是res目录下面的turtle.png图片。
Sprite turtle({“res/turtle_red.png”,”res/turtle_blue.png”}); //创建一个叫turtle角色，它有两个造型。
Sprite t{“turtle”,false,”object”,100,100,45}; //turtle造型、可见性、标签、x坐标、y坐标、朝向。
Sprite* haigui = new Sprite(“turtle”); //新建turtle造型的角色，返回地址赋值给haigui。
haigui->fd(200); //由于haigui是指针，所以要用->号来调用fd方法。

移动与方向控制
2. forward / fd
作用: 向当前朝向前进指定距离。sprite表示角色的名字,下同。
用法: sprite.fd(50);
返回对角色的引用。

3. backward / back / bk
作用: 向当前朝向后退指定距离。
用法: sprite.bk(30);
返回对角色的引用。

4. right / rt
作用: 向右旋转指定角度（顺时针）。
用法: sprite.rt(90); // 右转90度
返回对角色的引用。

5. left / lt
作用: 向左旋转指定角度（逆时针）。
用法: sprite.lt(45); // 左转45度
返回对角色的引用。

6. setheading / seth
作用: 设置角色的绝对朝向（0° 为正右方，90° 为正上方）。
用法: sprite.seth(0); // 面向右
返回对角色的引用。

7. heading
作用: 朝向某个角色(坐标点)或者获取角色当前的朝向角度（0~360）。
用法: float angle = sprite.heading(); //得到角色的方向值
sprite.heading(100,100); //让角色朝向(100,100)的方向
当有参数时，返回对角色的引用。
举例:
#include “sprites.h” //包含C++精灵库
Sprite rocket; //建立角色叫rocket
Sprite t;
int main(){ //主功能块
rocket.penup().speed(0).go(100,100);
t.color(“#ff0000”).speed(0).fd(100) ;
while(g_screen->exitonclick()){
rocket.heading(t); //朝向t的方向
t.circle(100,1); //画半径为100的圆弧，左转1度
}
return 0;
}

8. towards
作用: 计算并返回从角色当前位置指向 (x, y) 点的角度。
用法: float angle = sprite.towards(100, 200);

画笔控制
9. isdown
作用: 判断画笔是否处于“落下”状态（即移动时会画线）。
用法: bool drawing = sprite.isdown();

10. penup / pu / up
作用: 抬起画笔，移动时不画线。
用法: sprite.penup();
返回对角色的引用。

11. pendown / pd / down
作用: 落下画笔，移动时会画线。
用法: sprite.pendown();
返回对角色的引用。

12. pensize / width
作用: 设置或获取画笔的粗细（像素）。
用法:
sprite.pensize(5);
int w = sprite.pensize();
加参数时返回对角色的引用。

13. pencolor
作用: 设置画笔颜色（支持字符串、RGB、HSV 等多种格式）。
用法:
sprite.pencolor(“#ff0000”);
sprite.pencolor(“red”);
sprite.pencolor(255, 0, 0); // RGB形式
sprite.pencolor(0); // 设置HSV色相为0(红),同时设置饱和度和明度最大，注意和penhue的区别。
加参数时返回对角色的引用。
不加参数时返回字符串形式的画笔颜色。

14. penhue / pensat(penbhd) / penvalue / penshade
背景: C++精灵库规定画笔颜色默认的色相、饱和度、明度初始值都是0。至于shade值，是一个综合的值。关于hsv颜色模式，请先查阅相关资料学习。
作用: 分别设置画笔颜色的色相(Hue,0到360)、饱和度(Saturation,0.0到100.0)、明度(value,0到100)、色彩的深浅度(Shade,0到100)。
用法: sprite.penhue(120); // 只设置颜色的色相，这里120是绿色，注意和pencolor(120)的区别。如果此时明度为0，则是黑色。
返回对角色的引用。
举例:
#include “sprites.h” //包含C++精灵库
Sprite rocket; //建立角色叫rocket
int main(){ //主功能块
rocket.penup().speed(0).bk(180).pensize(20);
rocket.bgcolor(“black”).pendown();

//pencolor(0)设定色相为0(红色)同时设定饱和度和明度最大(100)
rocket.pencolor(0);

//只设定色相 ,hsv中的hue值
for(int h = 0;h<=360;h++)
rocket.penhue(h).fd(1);
rocket.pu().addy(60).bk(360).pd();

//只设定饱和度 ,hsv中的saturation值
for(int h = 0;h<=100;h++)
rocket.pensat(h).fd(2);
rocket.pu().addy(60).bk(200).pd();

//只设定明度 ,hsv中的v值
for(int v = 0;v<=100;v++)
rocket.penvalue(v).fd(2);
rocket.pu().addy(60).bk(200).pd();

//只设定色彩的深浅度 ，shade是一个综合的值
for(int sd = 0;sd<=100;sd++)
rocket.penshade(sd).fd(2);

rocket.done();
return 0;
}

15. penhsv
作用: 设置角色画笔的色相、饱和度和明度。
在C++精灵库中，规定的色相值范围是0到360，饱和度和明度的值范围是0到100。
用法: sprite.penhsv(0); //设置画笔的色相为0，饱和度和设调默认最大(100)。
用法: sprite.penhsv(0,50,50); //设置画笔为红色，饱和度为50，明度也是50
返回对角色的引用。
举例:
#include “sprites.h” //包含C++精灵库
Sprite rocket; //建立角色叫rocket

int main(){ //主功能块
rocket.speed(0).pu().bk(180).pensize(20).pd();
for(int i=0;i<360;i++)
rocket.penhsv(i).fd(1);//色相变大，饱和度和明度都是100
rocket.pu().bk(360).addy(50).pd();

for(int i=0;i<=100;i++)
rocket.penhsv(0,i,100).fd(2);//饱和度变大，越来越鲜艳
rocket.pu().bk(200).addy(50).pd();

for(int i=0;i<=100;i++)
rocket.penhsv(0,100,i).fd(2); //明度变大，亮度越来越亮

rocket.done();
return 0;
}

16. coloradd
作用: 颜色的色相增加（用于动态变色）。
用法: sprite.coloradd(1);
返回对角色的引用。

17. coloralpha / penalpha
作用: 设置画笔颜色的透明度（0~255，0 为完全透明）。其本质是设定画笔颜色的RGBA的alpha通道值。
用法: sprite.penalpha(128);
返回对角色的引用。

18. fillcolor
作用: 设置填充颜色（用于 begin_fill/end_fill方法）。
用法: sprite.fillcolor(“blue”);
加参数时返回对角色的引用。
不加参数时返回字符串形式的填充颜色。

19. filling
作用: 判断当前是否处于填充模式（即是否已调用 begin_fill 但未调用 end_fill）。
用法: bool inFill = sprite.filling();

20. begin_fill / end_fill
作用: 开始/结束一个填充区域。两者之间的所有绘图路径将被 fillcolor 填充。
用法:
sprite.begin_fill();
sprite.circle(50);
sprite.end_fill();
角色的begin_fill命令会返回对角色的引用。
角色的end_fill方法会返回路径的顶点向量(列表)

21. dot
作用: 在当前位置绘制一个实心圆点，size是直径。如果不指定color，则使用画笔颜色。
用法: sprite.dot(20, “green”);
返回对角色的引用。

22. circle
作用:
circle: 绘制完整圆形、弧形。
用法:
sprite.circle(30); //逆时针画半径为30的圆圈子
sprite.circle(50, 180); // 逆时针画半径为50的半圆
sprite.circle(-50, 180); // 顺时针画半圆
返回对角色的引用。

23. ellipse/oval
作用: 绘制椭圆（a 为长半轴，b 为短半轴）。
用法: sprite.ellipse(50, 30);
返回对角色的引用。

位置与坐标
24. home
作用: 将角色移回原点 (0, 0) 并重置朝向为 0°。
用法: sprite.home();
返回对角色的引用。

25. go / goxy / gotoxy / setxy / setpos / setposition
作用: 将角色移动到指定坐标 (x, y)。
用法: sprite.gotoxy(100, -50);
返回对角色的引用。
举例:
#include “sprites.h” //包含C++精灵库
Sprite rocket; //建立角色叫rocket

int main(){ //主功能块
rocket.speed(0).go(100,200);
Sprite t(“turtle”); //新建海龟造型角色情
t.go(rocket).wait(0.5);//t到达rocket的位置
Point p0 = {-100,0}; //新建坐标点
t.go(p0).home(); //t到达p0又回家了

rocket.done();
return 0;
}

26. move
作用: 相对当前位置在水平方向移动dx,在垂直方向移动dy。
用法: sprite.move(10, 20);
返回对角色的引用。

27. xcor / ycor / position / pos
作用: 获取角色的 X 坐标、Y 坐标或位置。
用法:
float x = sprite.xcor(); //获取x坐标
std::pair<float,float> p = sprite.pos(); //获取坐标

28. setx / gox / gotox
作用: 仅设置 X 坐标，Y 不变。
用法: sprite.setx(100);
返回对角色的引用。

29. sety / goy / gotoy
作用: 仅设置 Y 坐标，X 不变。
用法: sprite.sety(-30);
返回对角色的引用。

30. addx / addy
作用: 在当前 X/Y 坐标上增加偏移量。
用法: sprite.addx(5);
返回对角色的引用。

31. distance
作用: 计算角色当前位置到(x, y) 或其它角色的欧氏距离。
用法: float d = sprite.distance(0, 0);
//下面的bug是另一个角色的名称
用法: float d = sprite.distance( bug );

外观与造型
32. get_width / get_height
作用: 获取角色缩放后造型的原始宽高。
用法: int w = sprite.get_width();

33. scale 或 shapesize 变形命令
作用:
scale: 统一设置 X/Y 方向的缩放比例。
shapesize: 分别缩放。
用法:
sprite.scale(2.0);
sprite.shapesize(0.5,2.0);
加参数时返回对角色的引用。
不加参数时返回水平与垂直方向上的缩放比例，存储的数据结构是：std::pair<double,double> 。

34. addshape
在Sprite类中有私有的shapeslist向量，用于记录索引到造型图片路径的映射，有shapesdict(字典)用于记录造型图片路径到Shape的映射。Shape是一个纹理的包装类，如果对这些不懂，请忽略。
作用: 动态添加一个造型（图片）。
用法: sprite.addshape(“res/hero.png”); //添加造型
返回对角色的引用。

35. removeshape
作用: 移除一个造型
用法: sprite.removeshape(“res/hero.png”); //移去这个造型
用法: sprite.removeshape(0); //移去造型列表中索引为0的造型

36. next_costume / nextcostume / pre_costume / precostume
作用: 切换到下一个或上一个造型（用于动画）。
用法: sprite.nextcostume();
返回对角色的引用。

37. shape
作用: 切换到当前path指定图片为角色造型。
用法: sprite.shape(“idle.png”); //根据图片路径切换到此造型
用法: sprite.shape(0); //切换到索引为0的造型
用法: std::cout << sprite.shape(); //返回造型图片路径
shape方法返回对角色的引用。

38. shapeindex()
作用: 返回当前造型的索引号。
用法: std::cout << sprite.shapeindex(); //返回当前造型的索引号。

39. shapes
作用: 返回角色的造型数量。
用法: int amounts = sprite.shapes();

40. show / hide
作用: 显示/隐藏角色，show的别名是st，hide的别名是ht。
用法: sprite.show(); //显示角色
用法: sprite.st(); //显示角色
用法: sprite.hide(); //隐藏角色
用法: sprite.ht(); //隐藏角色
返回对角色的引用。

41. isvisible / ishide
作用: 判断角色是否可见 / 是否隐藏
用法: if (sprite.isvisible()) { … } //如果角色是可见的

42. rotate_mode / rotatemode
作用: 设置旋转模式（如 0 自由旋转）。
用法: sprite.rotatemode(0);
返回对角色的引用。

43. rotate_center
作用: 设置角色旋转的中心点（相对于角色原始造型中心点的水平与垂直偏移），同时角色也以这个点为基准坐标。
用法: sprite.rotate_center(0, 0); // 以中心为轴旋转，这是默认的，所以一般不需要设置。
返回对角色的引用。

碰撞与边界
44. bbox
作用: 获取角色在屏幕上的AABB包围盒（SDL_Rect）。
用法: SDL_Rect box = sprite.bbox();

45. contain
作用: 判断点 (cx, cy) 是否在角色的包围盒内。
用法: bool inside = sprite.contain(mouse_x, mouse_y);

46. rect_collide
作用: 检测与另一个角色 other 是否发生矩形碰撞。
用法: if (sprite.rect_collide(&enemy)) { … }

47. bounce_on_edge
作用: 如果角色碰到屏幕边缘，则自动反弹（改变朝向）。
用法: 在游戏循环中调用 sprite.bounce_on_edge();
返回对角色的引用。

图章（Stamp）
48. stamp
作用: 在当前位置“盖章”，留下角色当前造型的静态图像。
用法: sprite.stamp();
返回图章编号，注意，无法继续链式调用。

49. clearstamp / clearstamps
作用:
clearstamp: 清除指定 ID 的图章。
clearstamps: 清除部分或者所有图章。
用法: sprite.clearstamps();
都返回对角色的引用。
举例:
#include “sprites.h” //包含C++精灵库
Sprite rocket; //建立角色叫rocket

int main(){ //主功能块
for(int i=0;i<10;i++)
rocket.fd(30).stamp();
rocket.clearstamps(3); //清除最早盖的3个图章
rocket.wait(1);
rocket.clearstamps(-3); //清除最晚盖的3个图章
rocket.wait(1);
rocket.clearstamps(); //清除所有图章

rocket.done();
return 0;
}

50. stampitems
作用: 获取所有图章的 ID 列表。
用法: std::vector<Stamp> ids = sprite.stampitems();

高级绘图与填充
51. setpixel / getpixel
作用: 在角色所在窗口屏幕位置上设置/获取像素颜色（注意：不是windows屏幕）。
用法: sprite.setpixel(“white”);
setpixel返回对角色的引用，而getpixel返回的是Color对象。可以通过Color对象的gethex返回颜色的16进制形式的颜色字符串。
举例:
#include “sprites.h” //包含C++精灵库
Sprite rocket; //建立角色叫rocket

int main(){ //主功能块
rocket.hide().pu();
for(int i=0;i<100;i++)
rocket.setpixel(“red”).fd(1);
rocket.go(100,100).dot(33,”blue”);
Color ys = rocket.getpixel();
//输出应该是#0000ff
std::cout << ys.gethex() << std::endl;
rocket.done();
return 0;
}

52. fill
作用: 从角色当前位置开始进行泛洪填充（Flood Fill），填充封闭区域。
用法: sprite.fill(“yellow”); //如果不在封闭区域填充，则会填充整个窗口屏幕。
用法: sprite.fill(“yellow”,20,-50); //相对于角色坐标,右偏移20个单位,下偏移50个单位进行填充。
返回对角色的引用。

53. color
作用: 同时设置角色的画笔与填充颜色，有多种颜色表示方法。
用法: sprite.color(255, 0, 0, 255); //此处用的是r,g,b,a表示法
用法: sprite.color(“red”,”blue”); //画笔颜色为红色，填充颜色为蓝色
加参数时返回对角色的引用，不加参数时返回画笔颜色与填充颜色，数据结构为std::pair<SDL_Color,SDL_Color>。

文本与显示
54. write
作用: 参数分别是字符串: text, 对齐方式: align, 字体样式: font, 倾斜角度: angle)。write命令在角色当前位置书写文本。
参数:
text: 要写的字符串。
align: 对齐方式，”center”或”left”或”right”。
font: 字体信息，如 {“宋体”, “24”, “bold”}。 //注意数字要加双引号，因为用的是vector<string>来保存font信息。
angle: 文字旋转角度。
用法: sprite.write(“Hello!”, “center”, {“Arial”, “18”,”italic”}); //除了italic(斜体)，还有normal(标准)，bold(粗体),underline(下划线),strikethrough(中划线)。
返回对角色的引用。

状态与管理
55. speed
作用: 设置角色移动和绘图的速度（内部可能影响延迟）。
用法: sprite.speed(10);
加参数时返回对角色的引用。
不加参数时返回对角色的“速度”。

56. kill / destroy /isdestroyed
作用: kill是彻底销毁角色，destroy只清除角色占用的大部分内存资源，没有彻底delete它，而isdestroyed是标记角色为“已销毁”，后续可被delete。用new新建的角色才可用kill命令，不要在循环中动态地kill角色，否则会导致野指针产生，导致内存错误。
用法: sprite.destroy(); if (sprite.isdestroyed()) { … }
无返回值。

57. set_tag / get_tag
作用: 为角色设置/获取一个自定义标签（用于分类或识别）。
用法: sprite.set_tag(“player”);
用法: std::string tag = sprite.get_tag(); //返回角色的标签
set_tag方法返回对角色的引用。

58. get_screen / getscreen
作用: 获取角色所绑定的 Screen 对象。
用法: Screen* s = sprite.getscreen();
提示: 也可以直接使用全局的屏幕指针来使用屏幕对象,即g_screen。
用法: g_screen->bgcolor(“black”);

代理 Screen 方法（快捷调用）
以下方法实际上是调用其绑定的 Screen 对象的同名方法，提供便捷访问：

done() → screen.mainloop() → 进入事件循环
bgpic(path) → 设置背景图
title(s) → 设置窗口标题
setup(w, h) → 设置窗口大小
bgcolor(…) → 设置背景色
delay(ms) → 全局延迟
tracer(bool) → 设置是否自动刷新
wait(seconds) → 等待
update() → 手动刷新屏幕
clear() → 全部擦除

这些方法让角色可以直接控制屏幕，无需持有 Screen 指针。

曲线绘图（高级）
59. bezierQuad(start, end, control,steps=12)
作用: 绘制二次贝塞尔曲线。
用法: sprite.bezierQuad({0,0}, {100,100}, {50,200});
返回对角色的引用。

60. bezier / bezierCubic(start, end, ctrl1, ctrl2,steps=20)
作用: 绘制三次贝塞尔曲线。
用法: sprite.bezier({0,0}, {100,100}, {30,200}, {70,-50});
返回对角色的引用。

61. bspline(controlPoints,steps=20)
作用: controlPoints是存储Point的向量。这个方法会绘制B样条曲线（需要至少4个控制点）。
用法: sprite.bspline({{0,0}, {50,100}, {100,50}, {150,0}});
返回对角色的引用。

62. cubicspline(points,steps=10)
作用: 绘制三次样条插值曲线（平滑通过所有给定点）。
用法: sprite.cubicspline({{0,0}, {50,80}, {100,20}, {150,100}});
返回对角色的引用。

63. 动态属性
作用: 给角色随时设立一个属性。角色有公共的property映射（类似Python字典）。通过建立从字符串到字符串或者其它数据类型的映射来完成角色的动态属性设立。
举例：
#include “sprites.h” //包含C++精灵库
#include <string>
using namespace std;
Screen sc;
Sprite *bug = new Sprite(“res/bug.png”);//new Sprite命令建立角色返回的地址给bug指针

int main(){ //命令行参数接收表,也可以不写
bug->property[“life”] = 10; //设生命有10条
while(true){
bug->property[“life”]–;
//to_string为把整数转换成字符串
sc.title(to_string(static_cast<int>(bug->property[“life”]))); //要用static_cast<int>强制转换
if(!bug->property[“life”]){ bug->kill();break;} //只有用new命令建立的角色才能用kill!
sc.wait(0.01);
}
sc.done();
return 0;
}

64. txt2png命令
作用：这是一个有趣的命令，角色的txt2png命令能把文字转换成图像，生成的文字颜色采用角色的画笔颜色。
它会返回一个pair<int,int>,存储图像的宽度和高度，以下都是把”C++精灵库”转换成图片，共有三种用法：

0 表示颜色的色相，这里就是红色，也可用RGB等形式。
sprite.color(0);
std::string s=”C++精灵库”;

一. 默认字体风格,
自动生成输出文件名，生成的文件名是filePath=”res/” + s + “_.png”;
语法: sprite.txt2png(s); //把s字符串转换成png，存储在filePath。

二. 默认字体风格,但指定文件名
语法: sprite.txt2png(s,”res/pxC++编辑器.png”);

三. 指定字体风格,指定文件名
语法: sprite.txt2png(s,{“楷体”,”32″,”italic”}, “res/pxC++编辑器.png”);
生成了图片后，可以把这些图片再次加载进来，形成新的角色。

65. set_flag命令
作用: 设置角色的标志
语法: sprite.set_flag(“dead”); //标记sprite已经死了

66. get_flag命令
作用: 获取角色的标志
语法: sprite.get_flag();

67. begin_poly命令
作用: 开始画多边形并记录顶点
语法: sprite.begin_poly()
返回对角色的引用。

68. end_poly命令
作用: 结束画多边形
语法: sprite.end_poly()
返回对角色的引用。

69. get_poly命令
作用: 得到所画的多边形的顶点
语法: std::vector<std::pair<float,float> > vers= sprite.get_poly();

这个是总的头文件。

/* 
   sprites.h,它是C++ Sprites库(C++精灵库)的头文件。它包含的是cppsprites目录下面的一些头文件。 
  版本V1.0.0,copyright@2025年12月22号。 
*/
#ifndef SPRITES_H
#define SPRITES_H
#define SDL_MAIN_HANDLED         //禁用 SDL2 对 main() 的重写

#define Surface SDL_Surface
#define Texture SDL_Texture
#include "cppsprites/screen.h"
#include "cppsprites/sprite.h"
#include "cppsprites/color_map.h"
#include "cppsprites/functools.h"
#include "cppsprites/polygon_region_filler.h"
#include "cppsprites/polygon_offset.h"
#include "cppsprites/coloradd.h"
#include "cppsprites/writetxt.h"
#include <sstream>
#include "cppsprites/dynamicproperty.h"
#define Create(name) Sprite name("res/" #name ".png", #name)
#endif // SPRITES_H

#ifndef WRITETXT_H
#define WRITETXT_H

#include <SDL2/SDL.h>
#include <SDL2/SDL_ttf.h>
#include <string>
#include <vector>
#include <memory>
#include <unordered_map>
#include "functools.h"

// 字体样式结构体
struct FontStyleInfo {
    std::string name;   // 字体名称
    int size;           // 字体大小
    std::string type;   // 字体类型(normal, bold, italic)
};

// 文本信息结构体
struct TextData {
    std::string text;
    SDL_Color color;
    float x, y;
    std::string align;
    FontStyleInfo font;
    double angle;  // 旋转角度
    // 新增：缓存纹理和尺寸（仅当文字/字体/颜色不变时有效）
    SDL_Texture* cachedTexture = nullptr;
    int cachedWidth = 0;
    int cachedHeight = 0;
    // 新增：判断是否需要更新缓存
    bool needsUpdate(const TextData& other) const {
        return text != other.text ||  x!=other.x || y!=other.y ||
               color.r != other.color.r || color.g != other.color.g || 
               color.b != other.color.b || color.a != other.color.a || 
               font.name != other.font.name || font.size != other.font.size || 
               font.type != other.font.type;
    }
};

// 文本渲染管理器
class TextRenderer {
private:
    std::vector<TextData> textList;  // 存储所有需要渲染的文本
    // 字体缓存：键为"字体名_大小_类型"，值为加载的字体
    std::unordered_map<std::string, TTF_Font*> fontCache;     
    // 添加：生成字体缓存的键
    std::string getFontCacheKey(const FontStyleInfo& font) {
        return font.name + "_" + std::to_string(font.size) + "_" + font.type;
    }

public:
    TextRenderer();
    ~TextRenderer();
    std::vector<TextData> & get_textList();
    // 添加文本到渲染队列
    void addText(const TextData& textData);
    TTF_Font* loadFont(FontStyleInfo& font);  // 保持不变
    // 渲染所有文本
    void renderAll(SDL_Renderer* renderer);
    void removeText(const std::string& text);
    // 清除所有文本
    void clear();
};

#endif // WRITETXT_H

非本人编写，来自公开项目！

/* stbiw-0.92 - public domain - http://nothings.org/stb/stb_image_write.h
   writes out PNG/BMP/TGA images to C stdio - Sean Barrett 2010
                            no warranty implied; use at your own risk


Before including,

    #define STB_IMAGE_WRITE_IMPLEMENTATION

in the file that you want to have the implementation.


ABOUT:

   This header file is a library for writing images to C stdio. It could be
   adapted to write to memory or a general streaming interface; let me know.

   The PNG output is not optimal; it is 20-50% larger than the file
   written by a decent optimizing implementation. This library is designed
   for source code compactness and simplicitly, not optimal image file size
   or run-time performance.

USAGE:

   There are three functions, one for each image file format:

     int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes);
     int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data);
     int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data);

   Each function returns 0 on failure and non-0 on success.
   
   The functions create an image file defined by the parameters. The image
   is a rectangle of pixels stored from left-to-right, top-to-bottom.
   Each pixel contains 'comp' channels of data stored interleaved with 8-bits
   per channel, in the following order: 1=Y, 2=YA, 3=RGB, 4=RGBA. (Y is
   monochrome color.) The rectangle is 'w' pixels wide and 'h' pixels tall.
   The *data pointer points to the first byte of the top-left-most pixel.
   For PNG, "stride_in_bytes" is the distance in bytes from the first byte of
   a row of pixels to the first byte of the next row of pixels.

   PNG creates output files with the same number of components as the input.
   The BMP and TGA formats expand Y to RGB in the file format. BMP does not
   output alpha.
   
   PNG supports writing rectangles of data even when the bytes storing rows of
   data are not consecutive in memory (e.g. sub-rectangles of a larger image),
   by supplying the stride between the beginning of adjacent rows. The other
   formats do not. (Thus you cannot write a native-format BMP through the BMP
   writer, both because it is in BGR order and because it may have padding
   at the end of the line.)
*/

#ifndef INCLUDE_STB_IMAGE_WRITE_H
#define INCLUDE_STB_IMAGE_WRITE_H

#ifdef __cplusplus
extern "C" {
#endif

extern int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes);
extern int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data);
extern int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data);

#ifdef __cplusplus
}
#endif

#endif//INCLUDE_STB_IMAGE_WRITE_H

#ifdef STB_IMAGE_WRITE_IMPLEMENTATION

#include <stdarg.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>

typedef unsigned int stbiw_uint32;
typedef int stb_image_write_test[sizeof(stbiw_uint32)==4 ? 1 : -1];

static void writefv(FILE *f, const char *fmt, va_list v)
{
   while (*fmt) {
      switch (*fmt++) {
         case ' ': break;
         case '1': { unsigned char x = (unsigned char) va_arg(v, int); fputc(x,f); break; }
         case '2': { int x = va_arg(v,int); unsigned char b[2];
                     b[0] = (unsigned char) x; b[1] = (unsigned char) (x>>8);
                     fwrite(b,2,1,f); break; }
         case '4': { stbiw_uint32 x = va_arg(v,int); unsigned char b[4];
                     b[0]=(unsigned char)x; b[1]=(unsigned char)(x>>8);
                     b[2]=(unsigned char)(x>>16); b[3]=(unsigned char)(x>>24);
                     fwrite(b,4,1,f); break; }
         default:
            assert(0);
            return;
      }
   }
}

static void write3(FILE *f, unsigned char a, unsigned char b, unsigned char c)
{
   unsigned char arr[3];
   arr[0] = a, arr[1] = b, arr[2] = c;
   fwrite(arr, 3, 1, f);
}

static void write_pixels(FILE *f, int rgb_dir, int vdir, int x, int y, int comp, void *data, int write_alpha, int scanline_pad)
{
   unsigned char bg[3] = { 255, 0, 255}, px[3];
   stbiw_uint32 zero = 0;
   int i,j,k, j_end;

   if (y <= 0)
      return;

   if (vdir < 0) 
      j_end = -1, j = y-1;
   else
      j_end =  y, j = 0;

   for (; j != j_end; j += vdir) {
      for (i=0; i < x; ++i) {
         unsigned char *d = (unsigned char *) data + (j*x+i)*comp;
         if (write_alpha < 0)
            fwrite(&d[comp-1], 1, 1, f);
         switch (comp) {
            case 1:
            case 2: write3(f, d[0],d[0],d[0]);
                    break;
            case 4:
               if (!write_alpha) {
                  // composite against pink background
                  for (k=0; k < 3; ++k)
                     px[k] = bg[k] + ((d[k] - bg[k]) * d[3])/255;
                  write3(f, px[1-rgb_dir],px[1],px[1+rgb_dir]);
                  break;
               }
               /* FALLTHROUGH */
            case 3:
               write3(f, d[1-rgb_dir],d[1],d[1+rgb_dir]);
               break;
         }
         if (write_alpha > 0)
            fwrite(&d[comp-1], 1, 1, f);
      }
      fwrite(&zero,scanline_pad,1,f);
   }
}

static int outfile(char const *filename, int rgb_dir, int vdir, int x, int y, int comp, void *data, int alpha, int pad, const char *fmt, ...)
{
   FILE *f;
   if (y < 0 || x < 0) return 0;
   f = fopen(filename, "wb");
   if (f) {
      va_list v;
      va_start(v, fmt);
      writefv(f, fmt, v);
      va_end(v);
      write_pixels(f,rgb_dir,vdir,x,y,comp,data,alpha,pad);
      fclose(f);
   }
   return f != NULL;
}

int stbi_write_bmp(char const *filename, int x, int y, int comp, const void *data)
{
   int pad = (-x*3) & 3;
   return outfile(filename,-1,-1,x,y,comp,(void *) data,0,pad,
           "11 4 22 4" "4 44 22 444444",
           'B', 'M', 14+40+(x*3+pad)*y, 0,0, 14+40,  // file header
            40, x,y, 1,24, 0,0,0,0,0,0);             // bitmap header
}

int stbi_write_tga(char const *filename, int x, int y, int comp, const void *data)
{
   int has_alpha = !(comp & 1);
   return outfile(filename, -1,-1, x, y, comp, (void *) data, has_alpha, 0,
                  "111 221 2222 11", 0,0,2, 0,0,0, 0,0,x,y, 24+8*has_alpha, 8*has_alpha);
}

// stretchy buffer; stbi__sbpush() == vector<>::push_back() -- stbi__sbcount() == vector<>::size()
#define stbi__sbraw(a) ((int *) (a) - 2)
#define stbi__sbm(a)   stbi__sbraw(a)[0]
#define stbi__sbn(a)   stbi__sbraw(a)[1]

#define stbi__sbneedgrow(a,n)  ((a)==0 || stbi__sbn(a)+n >= stbi__sbm(a))
#define stbi__sbmaybegrow(a,n) (stbi__sbneedgrow(a,(n)) ? stbi__sbgrow(a,n) : 0)
#define stbi__sbgrow(a,n)  stbi__sbgrowf((void **) &(a), (n), sizeof(*(a)))

#define stbi__sbpush(a, v)      (stbi__sbmaybegrow(a,1), (a)[stbi__sbn(a)++] = (v))
#define stbi__sbcount(a)        ((a) ? stbi__sbn(a) : 0)
#define stbi__sbfree(a)         ((a) ? free(stbi__sbraw(a)),0 : 0)

static void *stbi__sbgrowf(void **arr, int increment, int itemsize)
{
   int m = *arr ? 2*stbi__sbm(*arr)+increment : increment+1;
   void *p = realloc(*arr ? stbi__sbraw(*arr) : 0, itemsize * m + sizeof(int)*2);
   assert(p);
   if (p) {
      if (!*arr) ((int *) p)[1] = 0;
      *arr = (void *) ((int *) p + 2);
      stbi__sbm(*arr) = m;
   }
   return *arr;
}

static unsigned char *stbi__zlib_flushf(unsigned char *data, unsigned int *bitbuffer, int *bitcount)
{
   while (*bitcount >= 8) {
      stbi__sbpush(data, (unsigned char) *bitbuffer);
      *bitbuffer >>= 8;
      *bitcount -= 8;
   }
   return data;
}

static int stbi__zlib_bitrev(int code, int codebits)
{
   int res=0;
   while (codebits--) {
      res = (res << 1) | (code & 1);
      code >>= 1;
   }
   return res;
}

static unsigned int stbi__zlib_countm(unsigned char *a, unsigned char *b, int limit)
{
   int i;
   for (i=0; i < limit && i < 258; ++i)
      if (a[i] != b[i]) break;
   return i;
}

static unsigned int stbi__zhash(unsigned char *data)
{
   stbiw_uint32 hash = data[0] + (data[1] << 8) + (data[2] << 16);
   hash ^= hash << 3;
   hash += hash >> 5;
   hash ^= hash << 4;
   hash += hash >> 17;
   hash ^= hash << 25;
   hash += hash >> 6;
   return hash;
}

#define stbi__zlib_flush() (out = stbi__zlib_flushf(out, &bitbuf, &bitcount))
#define stbi__zlib_add(code,codebits) \
      (bitbuf |= (code) << bitcount, bitcount += (codebits), stbi__zlib_flush())
#define stbi__zlib_huffa(b,c)  stbi__zlib_add(stbi__zlib_bitrev(b,c),c)
// default huffman tables
#define stbi__zlib_huff1(n)  stbi__zlib_huffa(0x30 + (n), 8)
#define stbi__zlib_huff2(n)  stbi__zlib_huffa(0x190 + (n)-144, 9)
#define stbi__zlib_huff3(n)  stbi__zlib_huffa(0 + (n)-256,7)
#define stbi__zlib_huff4(n)  stbi__zlib_huffa(0xc0 + (n)-280,8)
#define stbi__zlib_huff(n)  ((n) <= 143 ? stbi__zlib_huff1(n) : (n) <= 255 ? stbi__zlib_huff2(n) : (n) <= 279 ? stbi__zlib_huff3(n) : stbi__zlib_huff4(n))
#define stbi__zlib_huffb(n) ((n) <= 143 ? stbi__zlib_huff1(n) : stbi__zlib_huff2(n))

#define stbi__ZHASH   16384

unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, int *out_len, int quality)
{
   static unsigned short lengthc[] = { 3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258, 259 };
   static unsigned char  lengtheb[]= { 0,0,0,0,0,0,0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4,  4,  5,  5,  5,  5,  0 };
   static unsigned short distc[]   = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577, 32768 };
   static unsigned char  disteb[]  = { 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13 };
   unsigned int bitbuf=0;
   int i,j, bitcount=0;
   unsigned char *out = NULL;
   unsigned char **hash_table[stbi__ZHASH]; // 64KB on the stack!
   if (quality < 5) quality = 5;

   stbi__sbpush(out, 0x78);   // DEFLATE 32K window
   stbi__sbpush(out, 0x5e);   // FLEVEL = 1
   stbi__zlib_add(1,1);  // BFINAL = 1
   stbi__zlib_add(1,2);  // BTYPE = 1 -- fixed huffman

   for (i=0; i < stbi__ZHASH; ++i)
      hash_table[i] = NULL;

   i=0;
   while (i < data_len-3) {
      // hash next 3 bytes of data to be compressed 
      int h = stbi__zhash(data+i)&(stbi__ZHASH-1), best=3;
      unsigned char *bestloc = 0;
      unsigned char **hlist = hash_table[h];
      int n = stbi__sbcount(hlist);
      for (j=0; j < n; ++j) {
         if (hlist[j]-data > i-32768) { // if entry lies within window
            int d = stbi__zlib_countm(hlist[j], data+i, data_len-i);
            if (d >= best) best=d,bestloc=hlist[j];
         }
      }
      // when hash table entry is too long, delete half the entries
      if (hash_table[h] && stbi__sbn(hash_table[h]) == 2*quality) {
         memcpy(hash_table[h], hash_table[h]+quality, sizeof(hash_table[h][0])*quality);
         stbi__sbn(hash_table[h]) = quality;
      }
      stbi__sbpush(hash_table[h],data+i);

      if (bestloc) {
         // "lazy matching" - check match at *next* byte, and if it's better, do cur byte as literal
         h = stbi__zhash(data+i+1)&(stbi__ZHASH-1);
         hlist = hash_table[h];
         n = stbi__sbcount(hlist);
         for (j=0; j < n; ++j) {
            if (hlist[j]-data > i-32767) {
               int e = stbi__zlib_countm(hlist[j], data+i+1, data_len-i-1);
               if (e > best) { // if next match is better, bail on current match
                  bestloc = NULL;
                  break;
               }
            }
         }
      }

      if (bestloc) {
         int d = data+i - bestloc; // distance back
         assert(d <= 32767 && best <= 258);
         for (j=0; best > lengthc[j+1]-1; ++j);
         stbi__zlib_huff(j+257);
         if (lengtheb[j]) stbi__zlib_add(best - lengthc[j], lengtheb[j]);
         for (j=0; d > distc[j+1]-1; ++j);
         stbi__zlib_add(stbi__zlib_bitrev(j,5),5);
         if (disteb[j]) stbi__zlib_add(d - distc[j], disteb[j]);
         i += best;
      } else {
         stbi__zlib_huffb(data[i]);
         ++i;
      }
   }
   // write out final bytes
   for (;i < data_len; ++i)
      stbi__zlib_huffb(data[i]);
   stbi__zlib_huff(256); // end of block
   // pad with 0 bits to byte boundary
   while (bitcount)
      stbi__zlib_add(0,1);

   for (i=0; i < stbi__ZHASH; ++i)
      (void) stbi__sbfree(hash_table[i]);

   {
      // compute adler32 on input
      unsigned int i=0, s1=1, s2=0, blocklen = data_len % 5552;
      int j=0;
      while (j < data_len) {
         for (i=0; i < blocklen; ++i) s1 += data[j+i], s2 += s1;
         s1 %= 65521, s2 %= 65521;
         j += blocklen;
         blocklen = 5552;
      }
      stbi__sbpush(out, (unsigned char) (s2 >> 8));
      stbi__sbpush(out, (unsigned char) s2);
      stbi__sbpush(out, (unsigned char) (s1 >> 8));
      stbi__sbpush(out, (unsigned char) s1);
   }
   *out_len = stbi__sbn(out);
   // make returned pointer freeable
   memmove(stbi__sbraw(out), out, *out_len);
   return (unsigned char *) stbi__sbraw(out);
}

unsigned int stbi__crc32(unsigned char *buffer, int len)
{
   static unsigned int crc_table[256];
   unsigned int crc = ~0u;
   int i,j;
   if (crc_table[1] == 0)
      for(i=0; i < 256; i++)
         for (crc_table[i]=i, j=0; j < 8; ++j)
            crc_table[i] = (crc_table[i] >> 1) ^ (crc_table[i] & 1 ? 0xedb88320 : 0);
   for (i=0; i < len; ++i)
      crc = (crc >> 8) ^ crc_table[buffer[i] ^ (crc & 0xff)];
   return ~crc;
}

#define stbi__wpng4(o,a,b,c,d) ((o)[0]=(unsigned char)(a),(o)[1]=(unsigned char)(b),(o)[2]=(unsigned char)(c),(o)[3]=(unsigned char)(d),(o)+=4)
#define stbi__wp32(data,v) stbi__wpng4(data, (v)>>24,(v)>>16,(v)>>8,(v));
#define stbi__wptag(data,s) stbi__wpng4(data, s[0],s[1],s[2],s[3])

static void stbi__wpcrc(unsigned char **data, int len)
{
   unsigned int crc = stbi__crc32(*data - len - 4, len+4);
   stbi__wp32(*data, crc);
}

static unsigned char stbi__paeth(int a, int b, int c)
{
   int p = a + b - c, pa = abs(p-a), pb = abs(p-b), pc = abs(p-c);
   if (pa <= pb && pa <= pc) return (unsigned char) a;
   if (pb <= pc) return (unsigned char) b;
   return (unsigned char) c;
}

unsigned char *stbi_write_png_to_mem(unsigned char *pixels, int stride_bytes, int x, int y, int n, int *out_len)
{
   int ctype[5] = { -1, 0, 4, 2, 6 };
   unsigned char sig[8] = { 137,80,78,71,13,10,26,10 };
   unsigned char *out,*o, *filt, *zlib;
   signed char *line_buffer;
   int i,j,k,p,zlen;

   if (stride_bytes == 0)
      stride_bytes = x * n;

   filt = (unsigned char *) malloc((x*n+1) * y); if (!filt) return 0;
   line_buffer = (signed char *) malloc(x * n); if (!line_buffer) { free(filt); return 0; }
   for (j=0; j < y; ++j) {
      static int mapping[] = { 0,1,2,3,4 };
      static int firstmap[] = { 0,1,0,5,6 };
      int *mymap = j ? mapping : firstmap;
      int best = 0, bestval = 0x7fffffff;
      for (p=0; p < 2; ++p) {
         for (k= p?best:0; k < 5; ++k) {
            int type = mymap[k],est=0;
            unsigned char *z = pixels + stride_bytes*j;
            for (i=0; i < n; ++i)
               switch (type) {
                  case 0: line_buffer[i] = z[i]; break;
                  case 1: line_buffer[i] = z[i]; break;
                  case 2: line_buffer[i] = z[i] - z[i-stride_bytes]; break;
                  case 3: line_buffer[i] = z[i] - (z[i-stride_bytes]>>1); break;
                  case 4: line_buffer[i] = (signed char) (z[i] - stbi__paeth(0,z[i-stride_bytes],0)); break;
                  case 5: line_buffer[i] = z[i]; break;
                  case 6: line_buffer[i] = z[i]; break;
               }
            for (i=n; i < x*n; ++i) {
               switch (type) {
                  case 0: line_buffer[i] = z[i]; break;
                  case 1: line_buffer[i] = z[i] - z[i-n]; break;
                  case 2: line_buffer[i] = z[i] - z[i-stride_bytes]; break;
                  case 3: line_buffer[i] = z[i] - ((z[i-n] + z[i-stride_bytes])>>1); break;
                  case 4: line_buffer[i] = z[i] - stbi__paeth(z[i-n], z[i-stride_bytes], z[i-stride_bytes-n]); break;
                  case 5: line_buffer[i] = z[i] - (z[i-n]>>1); break;
                  case 6: line_buffer[i] = z[i] - stbi__paeth(z[i-n], 0,0); break;
               }
            }
            if (p) break;
            for (i=0; i < x*n; ++i)
               est += abs((signed char) line_buffer[i]);
            if (est < bestval) { bestval = est; best = k; }
         }
      }
      // when we get here, best contains the filter type, and line_buffer contains the data
      filt[j*(x*n+1)] = (unsigned char) best;
      memcpy(filt+j*(x*n+1)+1, line_buffer, x*n);
   }
   free(line_buffer);
   zlib = stbi_zlib_compress(filt, y*( x*n+1), &zlen, 8); // increase 8 to get smaller but use more memory
   free(filt);
   if (!zlib) return 0;

   // each tag requires 12 bytes of overhead
   out = (unsigned char *) malloc(8 + 12+13 + 12+zlen + 12); 
   if (!out) return 0;
   *out_len = 8 + 12+13 + 12+zlen + 12;

   o=out;
   memcpy(o,sig,8); o+= 8;
   stbi__wp32(o, 13); // header length
   stbi__wptag(o, "IHDR");
   stbi__wp32(o, x);
   stbi__wp32(o, y);
   *o++ = 8;
   *o++ = (unsigned char) ctype[n];
   *o++ = 0;
   *o++ = 0;
   *o++ = 0;
   stbi__wpcrc(&o,13);

   stbi__wp32(o, zlen);
   stbi__wptag(o, "IDAT");
   memcpy(o, zlib, zlen); o += zlen; free(zlib);
   stbi__wpcrc(&o, zlen);

   stbi__wp32(o,0);
   stbi__wptag(o, "IEND");
   stbi__wpcrc(&o,0);

   assert(o == out + *out_len);

   return out;
}

int stbi_write_png(char const *filename, int x, int y, int comp, const void *data, int stride_bytes)
{
   FILE *f;
   int len;
   unsigned char *png = stbi_write_png_to_mem((unsigned char *) data, stride_bytes, x, y, comp, &len);
   if (!png) return 0;
   f = fopen(filename, "wb");
   if (!f) { free(png); return 0; }
   fwrite(png, 1, len, f);
   fclose(f);
   free(png);
   return 1;
}
#endif // STB_IMAGE_WRITE_IMPLEMENTATION

/* Revision history

      0.92 (2010-08-01)
             casts to unsigned char to fix warnings
      0.91 (2010-07-17)
             first public release
      0.90   first internal release
*/

// stamp.h
#ifndef STAMP_H
#define STAMP_H

#include <vector>
#include <SDL2/SDL.h>

struct Stamp {
    int id;
    float x, y;
    float heading;
    int m_rotate_mode;  //继承角色的旋转模式 
    float xscale, yscale;
    SDL_Texture* texture;  // 当前造型纹理
    bool visible;

    Stamp(int id, float x, float y, float heading, int rotate_mode,
          float xscale, float yscale, SDL_Texture* tex);
};

// 图章渲染管理器
class StampRenderer {
private:
    SDL_Renderer* renderer;

public:
    explicit StampRenderer(SDL_Renderer* renderer);
    ~StampRenderer() = default;

    // 绘制一个图章
    void draw(const Stamp& stamp);

    // 批量绘制图章
    void drawAll(const std::vector<Stamp>& stamps);
};

#endif // STAMP_H

// sprite.h by 李兴球,风火轮编程基地 
#ifndef SPRITE_H
#define SPRITE_H
#include "screen.h"
#include <SDL2/SDL.h>
#include "shape.h"
#include "stamp.h"
#include "polygon_offset.h"
#include <string>
#include <unordered_map>
#include <vector>
#include "writetxt.h"
#include "dynamicproperty.h"

class Sprite {
public:
	std::unordered_map<std::string,DynamicProperty> property;
	 
    void _load_pic_as_shape( std::string &shapeimage);
    Sprite(std::vector<std::string> shapes={"res/rocket.png"},bool visible=true,std::string tag="",float x=0.0f,float y=0.0f,float heading=0.0);
    Sprite(std::initializer_list<std::string> shapes, bool visible = true, std::string tag = "",  float x = 0.0f, float y = 0.0f, float heading = 0.0f);
    Sprite(std::string shape, bool visible = true, std::string tag = "",  float x = 0.0f, float y = 0.0f, float heading = 0.0f);
    //以下两个是一样的 
	Sprite& setlayer(int layer);  //设置角色所在的层
    Sprite& set_layer(int layer);  //设置角色所在的层    

     ~Sprite();
    Sprite& forward(float distance);   //朝角色的方向移动一定的距离  
    Sprite& fd(float distance);        //作为forward的别名之用， 朝角色的方向移动一定的距离 
	Sprite& backward(float distance); // 朝角色的反方向移动一定的距离 
    Sprite& back(float distance);  // 作为backward的别名，朝角色的反方向移动一定的距离 
	Sprite& bk(float distance);  // 作为backward的别名，朝角色的反方向移动一定的距离 
	  
    Sprite& right(float angle);  //让角色顺时钟旋转angle度 
    Sprite& left(float angle);  //让角色逆时钟旋转angle度
    Sprite& rt(float angle);   //让角色顺时钟旋转angle度 
    Sprite& lt(float angle);  //让角色逆时钟旋转angle度 
    Sprite& setheading(float angle); // 设定角色方向， 0=东, 90=北, 180=西, 270=南
    Sprite& seth(float angle); //  设定角色方向，0=东, 90=北, 180=西, 270=南
    float heading();  //返回角色的角度方向值 
    Sprite& heading(float x,float y);  //让角色朝向某个坐标 
    Sprite& heading(Sprite& other);   //让角色朝向另一个角色
	Sprite& heading(Point &point); //让角色朝向某个点 
    
    bool isdown();     //画笔是否落下 
    Sprite& penup();             //抬笔
    Sprite& pu();               //抬笔  
    Sprite& up();              //抬笔
    Sprite& pendown();        //落笔
    Sprite& pd();            //落笔 
    Sprite& down();         //落笔 
    float pensize();      //返回画笔线宽 
    Sprite& pensize(float width);  //设定画笔线宽 
    float width();    //返回画笔线宽 
    Sprite& width(float width);  //设定画笔线宽 
    
	std::string pencolor();  //以16进制RGB字符串，返回画笔颜色 
	Sprite& pencolor(SDL_Color color);     //设定画笔颜色 
	Sprite& pencolor(Color color);     //设定画笔颜色 
    Sprite& pencolor(Uint8 r, Uint8 g, Uint8 b,Uint8 a=255);  ////设定画笔颜色 ,r,g,b,a
    Sprite& pencolor(std::string pc);         ////设定画笔颜色 ,字符串形式的颜色如red或#FF0000
    Sprite& pencolor(float hue);   //设定画笔颜色 ，hue被当成颜色的色相，把这个单精度浮点数转换成RGB形式 
    Sprite& pencolor(double hue);    //设定画笔颜色 ，hue被当成颜色的色相，把这个双精度浮点数转换成RGB形式 
	Sprite& pencolor(int hue);    //设定画笔颜色 ，hue被当成颜色的色相，把这个整数转换成RGB形式 
	Sprite& penhue(int hue);    //设定画笔颜色 ，hue被当成颜色的色相，把这个整数转换成RGB形式 
	Sprite& penbhd(float bhd);   //设定画笔的饱和度，0到100.0 
	Sprite& pensat(float bhd);   //设定画笔的饱和度，0到100.0 	
	Sprite& coloradd(float step);    //画笔颜色的色相增加 
	float penhue();          //返回画笔的色相 
	float penbhd();          //返回画笔的饱和度
	float pensat();          //返回画笔的饱和度	
	float pentone();           //返回画笔的明度 
	Sprite& pentone(float tone);   //明度0到100.0的 
	float penvalue();           //返回画笔的明度 
	Sprite& penvalue(float tone);   //明度0到100.0的 
	
	Sprite& penshade(float sd);   //设定画笔的shade 
    float penshade() const; // 获取当前画笔的 shade 值 
    Sprite& penhsv(float hue,float sat=100.0,float value=100.0); //设定画笔的色相，饱和度和明度 
		
	std::string fillcolor();              //返回填充颜色 
    Sprite& fillcolor(Color fc);   //设定填充颜色 
    Sprite& fillcolor(SDL_Color fc);   //设定填充颜色 
	Sprite& fillcolor(Uint8 r, Uint8 g, Uint8 b,Uint8 a=255); //设定填充颜色 
    Sprite& fillcolor(std::string fc);         //设定填充颜色 ,字符串形式的颜色如red，#FF0000
    Sprite& fillcolor(float hue);   ////设定填充颜色 ,当成色相，把这个浮点数转换成RGB形式 
    Sprite& fillcolor(double hue);   ////设定填充颜色 ,当成色相，把这个浮点数转换成RGB形式 
	Sprite& fillcolor(int hue);   ////设定填充颜色 ,当成色相，把这个浮点数转换成RGB形式 
	
	Sprite& dot(float diameter);      //打圆点，参数是直径，默认为画笔颜色 
	Sprite& dot(float diameter,std::string color,int alpha=255);    //打一个直径为diameter的圆点 
    Sprite& dot(float diameter,int hue);    //打一个直径为diameter的圆点，hue表示色相 
    Sprite& dot(float diameter,SDL_Color color);    //打一个直径为diameter的圆点 
    //以下_dot方法不公开 
    void _dot(float diameter,SDL_Color color);    //打一个直径为diameter的圆点 
    
    Sprite& setpixel(Color px);//在角色坐标设置一个像素值，就是调用打直径为1的dot命令，颜色就是Color类型 
    Sprite& setpixel(SDL_Color px);//在角色坐标设置一个像素值，，就是调用打直径为1的dot命令，颜色就是SDL_Color类型 
    Sprite& setpixel(Uint8 r, Uint8 g, Uint8 b,Uint8 a=255);//在角色坐标设置一个像素值，，就是调用打直径为1的dot命令，颜色就RGB三元色整数值 
    Sprite& setpixel(std::string px);//在角色坐标设置一个像素值，，就是调用打直径为1的dot命令，px是颜色字符串或者16进制字符串 
    Sprite& setpixel(float px);//在角色坐标设置一个像素值，，就是调用打直径为1的dot命令，px表示色相
    Sprite& setpixel(double px);//在角色坐标设置一个像素值，，就是调用打直径为1的dot命令，px表示色相 
    Sprite& setpixel(int px);//在角色坐标设置一个像素值，，就是调用打直径为1的dot命令，px表示色相    
    Sprite& setpixel();//在角色坐标设置一个像素值，就是调用打直径为1的dot命令，颜色就是画笔颜色    
    Color getpixel();  //在角色坐标位置，调用屏幕的getpixel得到某个点的像素值 
    
    Sprite& color(int cc); //同时设定画笔颜色和填充颜色
    Sprite& color(float cc); //同时设定画笔颜色和填充颜色
    Sprite& color(double cc); //同时设定画笔颜色和填充颜色
    Sprite& color(int r,int g,int b,int a=255); //同时设定画笔颜色和填充颜色    
    Sprite& color(std::string cc); //同时设定画笔颜色和填充颜色
	Sprite& color(std::string pc, std::string fc); //设定画笔颜色和填充颜色
	Sprite& color(SDL_Color cc);         //同时设定画笔颜色和填充颜色
	Sprite& color(Color cc);         //同时设定画笔颜色和填充颜色
	Sprite& color(SDL_Color pc, SDL_Color fc); //分别设定画笔颜色和填充颜色
	std::pair<SDL_Color,SDL_Color> color();          //返回画笔颜色和填充颜色
	
	Sprite& coloralpha(Uint8 pa,Uint8 fa=255); //设置画笔颜色和填充颜色的透明通道 
	Sprite& penalpha(Uint8 pa,Uint8 fa=255); //设置画笔颜色和填充颜色的透明通道 
	
	Sprite& home();                     //回家，让角色朝向90度和回到原点 
	Sprite& setposition(float x,float y);   //设置角色坐标 
	Sprite& setpos(float x,float y); //设置角色坐标
 
    Sprite& gotoxy(float x, float y); //设置角色坐标
    Sprite& goxy(float x, float y); //设置角色坐标
    Sprite& setxy(float x,float y);  //设置角色坐标
    Sprite& go(float x,float y);    //设置角色坐标
    Sprite& go(std::pair<float,float> point );//设置角色坐标
    Sprite& go(std::pair<int,int>);    //设置角色坐标
    Sprite& go(Sprite &other);        //到达其它角色的位置
	Sprite& go(Point &point);         //到达某个点
	Sprite& move(float dx,float dy);  //水平与垂直位置相对移动 ,dx是水平相对位移，dy是垂直相对位移 
	 
    float xcor();  //获取角色的x坐标 
    float ycor();  //获取角色的y坐标 
    std::pair<float,float> position();   //获取角色的x,y坐标 
    std::pair<float,float> pos();   //获取角色的x,y坐标
    Sprite& setx(float x);  //设定x坐标
	Sprite& sety(float y);  //设定y坐标
	Sprite& gotox(float x);  //设定x坐标
	Sprite& gotoy(float y);  //设定y坐标
	Sprite& gox(float x);  //设定x坐标
	Sprite& goy(float y);  //设定y坐标
	
	Sprite& addx(float dx);  //x坐标增加dx
	Sprite& addy(float dy);  //y坐标增加dy 
    float distance(float x,float y);  //返回角色到x,y的距离
    float distance(std::pair<float,float>);  //返回角色到 pair<float,float>的距离
    float distance(Sprite &other); //返回到其它角色的距离
    float distance(Point &point); //返回到其它点的距离
        
    // 速度控制
    Sprite& speed(int speed);  // 设置速度 0~10
    int speed() const { return m_speed; }  //返回速度值 
    
    bool filling();            //返回正在填充 
	Sprite& begin_fill();     //开始填充 
	
	std::vector< Point > end_fill(int mode=0); //结束填充，模式为0为默认采用的扫描线填充算法 
	std::vector< Point > _end_fill_scanline(); //结束填充 ，扫描线算法的结束填充 
	std::vector< Point > _end_fill_floodfill(); //结束填充 ，洪水填充算法的结束填充 
	Sprite& _drawPolygon(std::vector<Point> polygon);
	
	Sprite& circle(double radius, double extent=360.0, int steps=0);//画圆圈，radius为半径，正数表示逆时钟，负数表示顺时钟画，extent表示画的度数，为负数时会倒着画。steps表示画的步长，比如为3时是画立着的正三角形。 
	Sprite& arc(double radius, double extent=60.0, int steps=0);  //画圆弧，参数同circle方法，只不过extent值默认为60.0	
	Sprite& ellipse(double semiMajor, double semiMinor, double extent=360);  //画椭圆 
	Sprite& oval(double semiMajor, double semiMinor, double extent=360);//画椭圆
		
    Screen *get_screen();  //返回屏幕指针 
    Screen *getscreen(); //返回屏幕指针
	Sprite& removeshape(const std::string& name);
	Sprite& removeshape(const int index);
	Sprite& _removeshape(const std::string& name);    //移除某个造型 
    Sprite& addshape(const std::string& name);      // 添加造型
    Sprite& addshape(const std::string& name,  Shape *shape);// 添加造型
    Sprite& _addshape(const std::string& name,  Shape *shape);// 添加造型
    Sprite& next_costume();  // 切换到下一个造型    
    Sprite& pre_costume();   // 切换到上一个造型   
    Sprite& nextcostume();  // 切换到下一个造型    
    Sprite& precostume();   // 切换到上一个造型
	Sprite& next_shape();  // 切换到下一个造型    
    Sprite& pre_shape();   // 切换到上一个造型   
    Sprite& nextshape();  // 切换到下一个造型    
    Sprite& preshape();   // 切换到上一个造型   
    Sprite& shape(int index);   // 通过索引切换造型
    Sprite& shape(const std::string& name);      // 通过名称切换造型
    int shapeindex();            //返回当前造型的索引号 cur_shape_index 
    std::string shape() const;       // 获取当前造型名称
    int shapes(); //返回角色当前的造型数量 
   
    Sprite& show();      //显示角色(精灵)
	Sprite& hide();      //隐藏角色(精灵)
    Sprite& st();      //显示角色(精灵)
	Sprite& ht();      //隐藏角色(精灵)
	bool isvisible();  //是否可见
	bool ishide();  //是否不可见
	
	int get_width();       //得到当前缩放后的造型宽度 
	int get_height();     //得到当前缩放后的造型高度 
	SDL_Rect bbox();    //返回AABB绑定盒 
	
	bool contain(int cx,int cy);    //某个点是否在角色绑定盒内 
	bool rect_collide(Sprite *other); //缩放旋转后的矩形碰撞检测 
	 	
    void kill();      // 杀死角色，销毁角色并从屏幕中移除，在堆上生成的角色才能用kill，否则会崩溃(需要用new Sprite来新建）

    bool isdestroyed();         //返回角色是否销毁      
    void destroy();   // 销毁角色，只清理资源，不 delete，
    
    Sprite& scale(double sc);              //缩放角色 
    Sprite& shapesize(double xscale,double yscale); //让角色变形 
    std::pair<double,double> shapesize() const;    //返回角色的变形参数,即xscale和yscale 
    
    //以下asbackground方法不公开 
    Sprite& asbackground(bool add=true);    //角色作为背景用(主要为动态背景之用，在普通角色之前渲染)
	Sprite& asbg(bool add);	  
   
    float towards(Sprite& other);    //朝向某个角色，返回角度 ，仿Python turtle的towards命令 
    float towards(const Point& p); //朝向某个点，返回角度 
    float towards(float x, float y); //朝向x,y坐标，返回角度 
   
    int stamp();                    // 盖盖章，返回 id
    Sprite& clearstamp(int id);        // 删除指定 id 图章
    Sprite& clearstamps(int n = 0);    // 删除 n 个：n>0 前n个，n<0 后n个，n=0 全删
    
    std::vector<Stamp> stampitems();    //返回图章们的所有编号 
    int rotate_mode();  //得到角色的旋转模式，旋转模式的值小于等于0，表示角色可以360度旋转(仿Scratch图形化编程),为1表示左右旋转,值为2表示上下翻转,值为大于等于3时为不翻转 
    int rotatemode();  //得到角色的旋转模式
	Sprite& rotate_mode(int mode);  //设定旋转模式 
	Sprite& rotatemode(int mode);  //设定旋转模式 
	Sprite& bounce_on_edge();      //碰到边缘就反弹
	Sprite& set_tag(std::string tag);   //设置角色的标签，标签是用于分组的 
	std::string get_tag();           //得到角色的标签 
	
	void set_flag(std::string flag);   //设置角色的标志，标志是用于作标记和，和标签有点像 
	std::string get_flag();           //得到角色的标志 
    Sprite& done();   //进入事件循环，仿python海龟的done，调用的是屏幕的mainloop() 
    Sprite& bgpic(const std::string imgpath); //设定屏幕的背景图片，调用的是屏幕的同名方法 
    Sprite& title(std::string s);  //设定屏幕的标题，调用的是屏幕的同名方法 
    
    Sprite& setup(int width,int height);  //设定屏幕的宽高，调用的是屏幕的同名方法 
    Sprite& bgcolor(int color);    //设定屏幕的背景颜色，调用的是屏幕的同名方法 
    Sprite& bgcolor(SDL_Color color);   //设定屏幕的背景颜色，调用的是屏幕的同名方法 
    Sprite& bgcolor(Uint8 r,Uint8 g,Uint8 b,Uint8 a=0);  //设定屏幕的背景颜色，调用的是屏幕的同名方法 
    Sprite& bgcolor(std::string c);   //设定屏幕的背景颜色，调用的是屏幕的同名方法 
    Sprite& delay(unsigned int ms);  //设定屏幕的绘画延时，调用的是屏幕的同名方法  
    Sprite& tracer(bool auto_update); //设定屏幕的追踪器，调用的是屏幕的同名方法 ，追踪角色在进行相关动作后是否立即刷新屏幕 ，默认为真。如果设定为false，则不会显示图像，直到进行update。 
    Sprite& clear(); //调用的是屏幕的同名clear方法。 
    
    Sprite& setalpha(int a);             //设定角色透明度 
    Sprite& addalpha(int step);        //增加角色透明度 
    int getalpha();                //获取角色透明度m_alpha 

    Sprite& write( char ch,  std::string align = "center",
               std::vector<std::string> font = {"Arial", "18", "normal"},
              double angle = 0.0);                                          //角色的写字符命令，align是对齐方式，font是字体样式，angle是角度 
//    Sprite& write( std::string text,  std::string align = "center",
//               std::vector<std::string> font = {"Arial", "18", "normal"},
//              double angle = 0.0);                                         //角色的写字符串命令，align是对齐方式，font是字体样式，angle是角度
	Sprite& write(DynamicProperty text, std::string align="center",
                  std::vector<std::string> font={"Arial", "18", "normal"}, double angle=0.0);
//	
//	Sprite& write(DynamicProperty text, std::string align="center",
//                  std::tuple<std::string,int,std::string> font={"Arial", 18, "normal"}, double angle=0.0);
	
	
	//以下_write方法不公开 
    Sprite& _write( std::string text,  std::string align = "center",
               std::vector<std::string> font = {"Arial", "18", "normal"},
              double angle = 0.0);
              
    //std::pair<int,int> txt2png(std::string text,std::vector<std::string> font_style, std::string filePath);
    std::pair<int,int> txt2png(DynamicProperty text,std::vector<std::string> font_style, std::string filePath);
    std::pair<int,int> txt2png(char ch);
    std::pair<int,int> txt2png(std::string text);    
    std::pair<int,int> txt2png(std::string text,  std::string filePath);
    std::pair<int,int> _txt2png(std::string text,std::vector<std::string> font_style, std::string filePath);

    Sprite& wait(float seconds);       //角色的等待命令，调用屏幕的wait	
    Sprite& update();        //角色的刷新命令，调用屏幕的update命令 
    
    //以下两个displaybbox方法不公开 
    bool displaybbox();       //返回是否显示绑定盒 m_displaybbox的值 
    Sprite& displaybbox(bool yes);   //设置是否显示碰撞矩形 
    
    //画贝塞尔曲线声明    
    Sprite& bezierQuad(Point startPos, Point endPos, Point controlPos,int steps=12); //使用带有控制点的二次贝塞尔曲线绘制直线

    Sprite& bezierCubic(Point startPos, Point endPos, Point startControlPos, Point endControlPos,int steps=20); //使用具有2个控制点的三次贝塞尔曲线绘制直线
    Sprite& bezier(Point startPos, Point endPos, Point startControlPos, Point endControlPos,int steps=20); //同上使用具有2个控制点的三次贝塞尔曲线绘制直线

	Sprite& bspline(const std::vector<Point>& controlPoints, int steps=20);   //B样条曲线命令 
	
    Sprite& cubicspline(const std::vector<Point>& points, int steps = 10);  // 三次样条命令，会让角色通过所有给定点
	 
	Sprite& fill(SDL_Color color,float offsetx=0.0,float offsety=0.0 );    //从角色位置开始洪水填充的命令 
	Sprite& fill(int hue,float offsetx=0.0,float offsety=0.0);           //从角色位置开始洪水填充的命令,hue是颜色的色相 
    Sprite& fill(Color color,float offsetx=0.0,float offsety=0.0); //从角色位置开始进行洪水填充 
    Sprite& fill(std::string color,float offsetx=0.0,float offsety=0.0); //在角色位置开始进行洪水填充
	 
	Sprite& fill(int r,int g,int b,int a=255,float offsetx=0.0,float offsety=0.0);  //洪水填充命令
    Sprite& rotate_center(int offset_x,int offset_y); //设定旋转中心（相对于角色中心点) 
    std::pair<float,float> rotate_center() const ;          //返回旋转中心   
    
	//以下的draw和draw_bbox方法不公开 
	void draw();       // 绘制精灵，
	void draw_bbox();	//绘制精灵的绑定盒
	int layer();          //得到角色所在的层 
	bool _sprite_type();    //返回角色类型，true表示cm普通角色， false表示bg背景角色 
	int born_timestamp();   
	std::vector<Point> get_points_list();
	
	//画多边形存储顶点到 _poly向量里 
	Sprite& begin_poly();
	Sprite& end_poly();
	std::vector< std::pair<float,float> > get_poly(); 
	
private:  
    SDL_Texture* getCurrentTexture();  //得到角色当前造型的纹理     
    
    //  定义缩放因子：保留 3 位小数精度，这是给offset polygon用的 
    const double _SCALE;
    bool m_displaybbox;   //是否显示绑定盒子 ，默认不显示 
    //造型系统 
	std::unordered_map<std::string, Shape*> shapesdict; // 造型字典（名称→造型指针）
    std::vector<std::string> shapeslist;     // 造型列表（按添加顺序存储名称）
    int cur_shape_index;             // 当前造型在shapeslist列表中的索引（初始-1）
    bool m_isvisible;          //是否显示 

    // 同scratch里的旋转模式,2025-9-8增加的功能
	// 值小于等于0表示360度旋转，此时在渲染造型时用SDL_FLIP_NONE，旋转角度是多少就是多少
	// 值为1表示左右旋转，此时渲染造型是用SDL_FLIP_HORIZONTAL，旋转角度为0
	// 值为2表示上下旋转，此时渲染造型是用SDL_FLIP_VERTICAL，旋转角度为0
	// 值为大于等于3时为不旋转， 在渲染造型时用SDL_FLIP_NONE，旋转角度是0
    int m_rotate_mode;        //旋转模式 

	bool fill_start;   //开始填充标记
	std::vector< Point > points_list; //点列表
 	
	//如果是世界坐标系，则角色的x,y坐标都会看成是世界坐标，在最后渲染的时候要转换成屏幕坐标系渲染。
	//如果不是世界坐标系，即本来就是屏幕坐标系，则在最后渲染的时候不需要转换成屏幕坐标系，因为本来这些坐标就是屏幕坐标 
	std::string m_tag;       //标签用于分组 
    float x, y;
    float m_heading; // 角度，0度朝右（东）
    Sprite& _heading(float x,float y);  //朝向某个坐标 
    bool m_pen_down;
    float m_pen_size;   
    SDL_Color m_pen_color;             // 画笔颜色 
    float m_pen_hue ;         //HSV中的色度,0.0到360 
    float m_pen_saturation  ;  //HSV中的饱和度,本来是0.0一1.0，为方便编程设为0.0到100.0 
    float m_pen_value;      //HSV中的 明度 本来是0.0一1.0，为方便编程设为0.0到100.0
    float m_pen_shade;      // 0.0 ~ 100.0
	void updatePenColorFromHSV() ; 
    
    SDL_Color m_fill_color;

    Screen* screen;
    void _pencolor(Uint8 r, Uint8 g, Uint8 b,Uint8 a);
    void _fillcolor(Uint8 r, Uint8 g, Uint8 b,Uint8 a);
    void draw_round_cap_simple(float,float,float,float,float,bool);
    void draw_line(float x1, float y1, float x2, float y2);
    void update_if_needed(); // 根据 auto_update 决定是否刷新
    float toRadians(float degrees);
    // 添加辅助函数声明，用于dot函数调用生成圆的顶点
    void generateCircleVertices(SDL_Vertex* vertices, int segments, float radius, const SDL_Color& color);
    bool m_isDestroyed;   //是否已经自毁 
    //缩放系数
	double xscale,yscale; 
	int m_alpha;        //角色的透明度0到255的值，本质是设定纹理的alpha通道，所以0表示透明 
	// 速度控制（新增）
    int m_speed;  // 0~10: 0=最快, 1=最慢, 10=较快 // 内部状态
    bool m_moving;      // 是否正在移动中（用于动画）
    float m_target_x, m_target_y;
    float m_target_heading;
    float m_remaining_distance;
    float m_turn_angle_left;

    // 缓存：每级速度对应的步长和角速度
    static const float move_step[11];   // speed 1~10，索引 1~10
    static const float turn_step[11];   // 每次转向增量
    
    float _distance(float x,float y);   //角色到x,y的距离最终调用的方法 
    //朝向命令最终调用的命令
	float _towards(float x, float y);  // 计算从 (this->x, this->y) 指向 (x, y) 的角度
	 
	//图章管理
	static int m_next_stamp_id;  // 全局图章 ID 计数器
    std::vector<Stamp> m_stamps; // 存储所有图章

    // 获取 StampRenderer（从 Screen 获取 renderer）
    StampRenderer* getStampRenderer(); 
    // 缓存当前要write的文字的索引（用于复用）
    int currentTextIndex ;
    
    std::pair<float,float> m_rotate_center;        
    //三次样条曲线辅助函数：求解三对角矩阵（用于计算三次样条的斜率）
    std::vector<float> solveTridiagonal(const std::vector<float>& a, 
                                        const std::vector<float>& b, 
                                        const std::vector<float>& c, 
                                        const std::vector<float>& d);
    
    // 辅助函数：计算单个三次样条段上的点
    Point cubicSplinePoint(float t, 
                           float x0, float y0, float m0, 
                           float x1, float y1, float m1);
    SDL_Rect AABBRect;        //角色缩放旋转后的AABB矩形 ，用于AABB绑定盒碰撞检测，它的值是屏幕坐标系下的！ 
    SDL_Rect scaledDstRect;   //角色在旋转前,SDL_RenderCopyEx命令使用的矩形 
    int m_layer;         //角色所在的层，当角色渲染时根据这个进行排序，数值越大，则越渲染在后面，即越靠前
	bool m_sprite_type;  //true表示标识是普通角色 ,false表示是bg角色 
	int m_born_timestamp;     //角色诞生的时间戳 
	std::string m_flag;            //角色的标志，用于某些标识之用 
	
	std::vector< std::pair<float,float> > _poly;
	bool _creatingPoly;
	
};

#endif // SPRITE_H

#ifndef SHAPE_H
#define SHAPE_H

#include <SDL2/SDL.h>
#include <string>
extern bool m_loadingTexture;  //是否正在加载纹理 

class Shape {
private:      
    std::string m_imgpath;     //造型的图片路径 (反斜杠要变成正斜杠存储) 
    int width;              // 造型宽度
    int height;             // 造型高度    
    SDL_Texture* raw_texture; // 造型的原始纹理
    SDL_Surface* raw_surface; //造型的原始表面 

public:   
    // 1. 添加默认构造函数
    Shape()  ;
    
    // 2. 带图片路径的构造函数
    Shape(std::string imgpath);
	    
    // 2. 带surface的构造函数
    Shape(SDL_Surface *sur);
    
    // 3. 拷贝构造函数
    Shape(const Shape *other);
    
    // 4. 析构函数
    ~Shape();
    
    // 加载纹理（需要渲染器）
    bool loadTexture(SDL_Renderer* renderer);
    
    // 获取纹理
    SDL_Texture* getTexture() const;
    // 获取表面 
    SDL_Surface* getSurface() const;
    
    std::string imgpath() const;  //获取造型的图片路径 
    // 获取宽度
    int getWidth() const;
    
    // 获取高度
    int getHeight() const;    
   
};

#endif // SHAPE_H

// screen.h
#ifndef SCREEN_H
#define SCREEN_H
#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>
#include <SDL2/SDL_mixer.h>
#include <string>
#include <vector>
#include "shape.h"
#include "writetxt.h"
#include "coloradd.h"
#include <unordered_map>
#include "dynamicproperty.h"
#include <map>
#include <cmath>
typedef DynamicProperty DynProp;   //定义动态属性类的别名 


class Sprite; // 前向声明
extern std::map<std::string,std::string> named_shapes;
class Screen {
public:
	
	std::unordered_map<std::string,DynamicProperty> property;  //动态属性字典 
    Screen(const std::string& title = "C++ Sprites Library", int width = -1, int height =-1);
    ~Screen();
    Screen& title(std::string s);        //设定窗口标题     
    Screen& setup(int width,int height); //设定窗口宽高 
    std::string title();               //获取窗口标题 
    Screen& clear();                     //清空屏幕 
    Screen& update();                    // 手动刷新屏幕
    
    bool update_mode();            //返回刷新模式，为真表示是自动刷新模式，为假则表示要手动刷新屏幕 
	bool tracer() ;              //同上        
    Screen& update_mode(bool auto_update); // 设置自动/手动刷新模式
    Screen& tracer(bool auto_update);      // 同上，设置自动/手动刷新模式,因为Python turtle中有这个命令，它的本意是是否要追踪海龟的动作进行屏幕的刷新) 
     
    Screen& delay(unsigned int ms);        // 设置全局延迟（毫秒）
    unsigned int delay() const;         // 获取当前延迟
    
    void mainloop();                  // 让程序进入主循环，保持窗口打开
    void done();                     // 同上，作为mainloop的别名 

    int width() const { return m_width; }    //返回窗口宽度 
    int height() const { return m_height; }  //返回窗口高度
    std::string bgcolor();                  //返回背景颜色 
    Screen& bgcolor(SDL_Color color);      //设定背景颜色 
    Screen& bgcolor(int);       //设定背景颜色，填一个整数表示的是色相 0-360
    Screen& bgcolor(Uint8,Uint8,Uint8,Uint8=0); //设定背景颜色，四个整数分别表示RGBA 
    Screen& bgcolor(std::string color);  //设定背景颜色
    Screen& fill(SDL_Color color);       //设定背景颜色
    Screen& fill(Uint8,Uint8=0,Uint8=0,Uint8=0);    //设定背景颜色
    Screen& fill(std::string color);                //设定背景颜色
    
    //以下renderer方法不公开 
    SDL_Renderer* renderer() const { return m_renderer; }   //返回渲染层
	//以下canvas方法不公开  
    SDL_Texture* canvas() const { return m_canvas; }        //返回画布（绘画的纹理) 

    //以下cmspriteslist向量不公开 
    std::vector<Sprite*> cmspriteslist;       //普通角色列表 ,   
     //以下bgspriteslist向量不公开 
    std::vector<Sprite*> bgspriteslist;    //角色可作为背景（在cmspriteslist中的角色前先渲染) 
    
    bool exitonclick();         //单击窗口关闭按钮会返回false ,可用于在循环中单击窗口关闭按钮退出循环    
    Screen& wait(float seconds);    // 等待指定秒数（非阻塞），期间刷新画面和处理事件   
    Uint32 get_ticks() const;   // 获取当前时间（毫秒）  
   
   
    SDL_Texture* loadbackground(const std::string imgpath);  //加载纹理 ,先变成表面，然后从表面创建纹理，最后翻释放表面 
    SDL_Texture* addbackground(const std::string imgpath);  //加载纹理 ,先变成表面，然后从表面创建纹理，最后翻释放表面 
    SDL_Texture* addbg(const std::string imgpath);  //加载纹理 ,先变成表面，然后从表面创建纹理，最后翻释放表面 
    Screen& removebackground(const std::string imgpath);   //移除背景 
    Screen& removebg(const std::string imgpath);       //称除背景 
    
	Screen& bgpic(const std::string imgpath); //设定背景图片 
    Screen& next_bg();   //下一个背景 
    Screen& nextbg();    //下一个背景     
	Screen& next_background();//下一个背景     
	Screen& pre_bg();//上一个背景     
	Screen& prebg();	//上一个背景
	Screen& pre_background(); //上一个背景
	Screen& set_background(int index); //通过设定 bgtexturelist里的索引 指定纹理来设定背景 
	Screen& set_background(const std::string imgpath); //通过获取bgtexturedict里的纹理来设定背景	
    
    //以下3个方法不公开 
   void set_world_coordinate();    //设置为世界坐标系， m_is_world_coordinate 为真，则为世界坐标系，否则屏幕坐标系
   void set_screen_coordinate();   //设置为屏幕坐标系 
   int get_coordinate();  //返回1表示当前为世界坐标系，返回-1表示当前为屏幕坐标系 
   
   Screen& xy_grid(int step); //在屏幕上绘制坐标格子，和坐标系无关 
   Screen& xygrid(int step); //在屏幕上绘制坐标格子，和坐标系无关 
   int xy_grid(); //返回坐标格子边长  
   int xygrid(); //返回坐标格子边长 
   
   void setpixel(int x,int y,Color color);     //在x,y坐标设置像素值，即打一个点 
   void setpixel(int x,int y,SDL_Color color);//在x,y坐标设置像素值，即打一个点
   //以下_setpixel方法不公开 
   void _setpixel(int x,int y,SDL_Color color);
   Color getpixel(int x,int y,bool painting=false);         //得到x,y坐标的像素值 ，默认为假表示取最终渲染的 
   
   std::string inputbox(std::string title, std::string prompt); //输入框 
   int messagebox(std::string title,std::string prompt,unsigned flags=SDL_MESSAGEBOX_INFORMATION);  //消息输出框  
   /*
    SDL_MESSAGEBOX_ERROR                 = 0x00000010,   < error dialog    16
    SDL_MESSAGEBOX_WARNING               = 0x00000020,   < warning dialog ,32
    SDL_MESSAGEBOX_INFORMATION           = 0x00000040,   < informational dialog > 64
   */
   
   //以下fillpolygon方法不公开,
   Screen& fillpolygon(std::vector<Point> points,std::vector<SDL_Color> colors);  // fillpolygon采用屏幕坐标系，传入参数需要转换 to_screen_xy ，两个向量size要一样才会画 
   bool savepng(const std::string& filename, bool painting=false); //截屏命令，这是截取整个窗口，filename为存储图像的文件名，painting表示是否把角色本身也截进去 
   bool savepng(const std::string& filename, SDL_Rect rect, bool painting=false);  //截屏命令，截取矩形区域，filename为存储图像的文件名，rect表示要截取的矩形区域（默认世界坐标系)，painting表示是否把角色本身也截进去 
   
   //以下的saveRenderToPNG方法不公开 
   bool saveRenderToPNG(const std::string& filename, const SDL_Rect& rect, bool painting=false);   //无论哪个坐标系，这里的rect用的都是SDL2的屏幕坐标系  
   bool saveRenderToPNG(const std::string& filename, bool painting=false);   //默认整个窗口截屏
           
private:
	int m_gridstep;        //格子边长 ，如果小于等于0，则不显示格子 
	int m_coordinate_type;   //是否是世界坐标系，默认为1，为-1表示屏幕坐标系 
	bool m_is_updating;          //是否正在刷新中 
	SDL_Color _bgcolour;       //背景颜色 
    int m_width, m_height;
    SDL_Window* m_window;
    SDL_Renderer* m_renderer;    
	SDL_Texture* m_canvas;     //画布 
    bool m_auto_update;       //是否自动刷新 
    unsigned int m_delay;    //全局延迟（毫秒) 
    void _bgcolor(Uint8,Uint8,Uint8,Uint8);    
     //角色管理接口
    void addSprite(Sprite* sprite);   // 向列表添加角色，刚开始所有创建的角色都会自动加入cmspriteslist 
//    bool out_cmspriteslist(Sprite* sprite); // 从普通角色列表中移除 
//    bool out_bgspriteslist(Sprite* sprite);  //从背景角色列表中移除 
    bool is_updating();
   
    TextRenderer& getTextRenderer() { return textRenderer; } 
    void destroy();        
    friend class Sprite; // 允许 Sprite 访问 renderer    
    
    //std::string curbgpath;
    SDL_Texture* m_curbgtexture;    //当前背景图片纹理 
    std::map<std::string,SDL_Texture*> bgtexturedict; //图片路径到纹理指针的映射 
    std::vector<SDL_Texture*> bgtexturelist;  //背景纹理列表
	int cur_bg_texture_index;             //当前背景纹理索引,为-1表示没有背景纹理 
 
    void ResizeCanvas(int new_width, int new_height);
    void _create_renderer_and_canvas();
    
	TextRenderer textRenderer;  // 文本渲染器
	void _drawGrid( int m_gridstep);
    bool m_cmlist_sort_flag ; // 标记是否cmspriteslist需要重新排序
    bool m_bglist_sort_flag ; // 标记是否cmspriteslist需要重新排序  
    void set_m_cmlist_sort_flag(bool);
    void set_m_bglist_sort_flag(bool);
    
	  
};

// 添加全局变量的外部声明
extern Screen* g_screen;
#endif // SCREEN_H

// polygon_region_filler.h
#ifndef POLYGON_REGION_FILLER_H
#define POLYGON_REGION_FILLER_H

#include <vector>
#include "polygon_offset.h"  // 你的头文件

struct RegionInfo {
    std::vector<Point> boundary;  // 子区域的边界点（闭合）
    Point centroid;               // 种子点（重心）
    bool is_valid;               // 区域是否有效（面积足够大）
};

class PolygonRegionFiller {
public:
    // 构造函数
    PolygonRegionFiller(const std::vector<Point>& points, double line_width = 4.0);
    
    // 分解多边形并获取所有可填充区域
    std::vector<RegionInfo> getFillableRegions();
    
private:
    // 原始多边形点
    std::vector<Point> original_points_;
    
    // 线宽
    double line_width_;
    
    // 内部辅助函数
    std::vector<Point> findIntersectionPoints();
    std::vector<std::vector<Point>> splitAtIntersections(const std::vector<Point>& points);
    Point calculateCentroid(const std::vector<Point>& polygon);
    double calculateArea(const std::vector<Point>& polygon);
    bool isPointInsidePolygon(const Point& p, const std::vector<Point>& polygon);
    bool isPolygonClockwise(const std::vector<Point>& polygon);
    std::vector<std::vector<Point>> extractSimplePolygons(const std::vector<Point>& points);
    void removeDuplicatePoints(std::vector<Point>& points);
    double distanceBetweenPoints(const Point& a, const Point& b);
};

#endif // POLYGON_REGION_FILLER_H

// polygon_offset.h
#ifndef POLYGON_OFFSET_H
#define POLYGON_OFFSET_H

#include <vector>

struct Point {
    double x, y;
    Point();
    Point(double x, double y);
    friend bool operator<(const Point& a, const Point& b);
    friend bool operator==(const Point& a, const Point& other) ;

};

// 重载运算符（必须在头文件中声明，以便被所有包含它的编译单元看到）
Point operator+(const Point& a, const Point& b);
Point operator-(const Point& a, const Point& b);
Point operator*(const Point& a, double t);
Point operator*(double t, const Point& a); // 支持 t * Point
Point operator/(const Point& a, double t);
 
// 向量运算函数声明
double dot(const Point& a, const Point& b);
double cross(const Point& a, const Point& b);
double norm(const Point& a);
Point normalize(const Point& a);
Point normal(const Point& v);
bool isClockwise(const std::vector<Point>& poly);

struct Segment {
    Point p1, p2;
    int index;
    Segment(Point a, Point b, int idx);
    double getYAt(double x) const;
    bool operator<(const Segment& other) const;
};
bool isSelfIntersectingRobust(const std::vector<Point>& polygon, double epsilon= 1e-10);
//bool isSelfIntersecting(const std::vector<Point>& polygon);

// 线段相交检测函数声明
bool segmentsIntersect(const Point& a, const Point& b, const Point& c, const Point& d);

// 注意：operator* 不支持 Point * Point（无意义）
std::vector<Point> miterOffsetPolygon(const std::vector<Point>& points, double offset_distance, double miter_limit=0.25);
std::vector<Point> miterOffsetPolygonRobust(const std::vector<Point>& points, double offset_distance, double miter_limit = 0.25);

#endif // POLYGON_OFFSET_H

非本人编写，来自公开项目！

/*
 * Copyright (c) 2013-14 Mikko Mononen memon@inside.org
 *
 * 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 polygon rasterization is heavily based on stb_truetype rasterizer
 * by Sean Barrett - http://nothings.org/
 *
 */

#ifndef NANOSVGRAST_H
#define NANOSVGRAST_H

#include "nanosvg.h"

#ifndef NANOSVGRAST_CPLUSPLUS
#ifdef __cplusplus
extern "C" {
#endif
#endif

typedef struct NSVGrasterizer NSVGrasterizer;

/* Example Usage:
	// Load SVG
	NSVGimage* image;
	image = nsvgParseFromFile("test.svg", "px", 96);

	// Create rasterizer (can be used to render multiple images).
	struct NSVGrasterizer* rast = nsvgCreateRasterizer();
	// Allocate memory for image
	unsigned char* img = malloc(w*h*4);
	// Rasterize
	nsvgRasterize(rast, image, 0,0,1, img, w, h, w*4);
*/

// Allocated rasterizer context.
NSVGrasterizer* nsvgCreateRasterizer(void);

// Rasterizes SVG image, returns RGBA image (non-premultiplied alpha)
//   r - pointer to rasterizer context
//   image - pointer to image to rasterize
//   tx,ty - image offset (applied after scaling)
//   scale - image scale
//   dst - pointer to destination image data, 4 bytes per pixel (RGBA)
//   w - width of the image to render
//   h - height of the image to render
//   stride - number of bytes per scaleline in the destination buffer
void nsvgRasterize(NSVGrasterizer* r,
				   NSVGimage* image, float tx, float ty, float scale,
				   unsigned char* dst, int w, int h, int stride);

// Deletes rasterizer context.
void nsvgDeleteRasterizer(NSVGrasterizer*);


#ifndef NANOSVGRAST_CPLUSPLUS
#ifdef __cplusplus
}
#endif
#endif

#ifdef NANOSVGRAST_IMPLEMENTATION

#include <math.h>
#include <stdlib.h>
#include <string.h>

#define NSVG__SUBSAMPLES	5
#define NSVG__FIXSHIFT		10
#define NSVG__FIX			(1 << NSVG__FIXSHIFT)
#define NSVG__FIXMASK		(NSVG__FIX-1)
#define NSVG__MEMPAGE_SIZE	1024

typedef struct NSVGedge {
	float x0,y0, x1,y1;
	int dir;
	struct NSVGedge* next;
} NSVGedge;

typedef struct NSVGpoint {
	float x, y;
	float dx, dy;
	float len;
	float dmx, dmy;
	unsigned char flags;
} NSVGpoint;

typedef struct NSVGactiveEdge {
	int x,dx;
	float ey;
	int dir;
	struct NSVGactiveEdge *next;
} NSVGactiveEdge;

typedef struct NSVGmemPage {
	unsigned char mem[NSVG__MEMPAGE_SIZE];
	int size;
	struct NSVGmemPage* next;
} NSVGmemPage;

typedef struct NSVGcachedPaint {
	signed char type;
	char spread;
	float xform[6];
	unsigned int colors[256];
} NSVGcachedPaint;

struct NSVGrasterizer
{
	float px, py;

	float tessTol;
	float distTol;

	NSVGedge* edges;
	int nedges;
	int cedges;

	NSVGpoint* points;
	int npoints;
	int cpoints;

	NSVGpoint* points2;
	int npoints2;
	int cpoints2;

	NSVGactiveEdge* freelist;
	NSVGmemPage* pages;
	NSVGmemPage* curpage;

	unsigned char* scanline;
	int cscanline;

	unsigned char* bitmap;
	int width, height, stride;
};

NSVGrasterizer* nsvgCreateRasterizer(void)
{
	NSVGrasterizer* r = (NSVGrasterizer*)malloc(sizeof(NSVGrasterizer));
	if (r == NULL) goto error;
	memset(r, 0, sizeof(NSVGrasterizer));

	r->tessTol = 0.25f;
	r->distTol = 0.01f;

	return r;

error:
	nsvgDeleteRasterizer(r);
	return NULL;
}

void nsvgDeleteRasterizer(NSVGrasterizer* r)
{
	NSVGmemPage* p;

	if (r == NULL) return;

	p = r->pages;
	while (p != NULL) {
		NSVGmemPage* next = p->next;
		free(p);
		p = next;
	}

	if (r->edges) free(r->edges);
	if (r->points) free(r->points);
	if (r->points2) free(r->points2);
	if (r->scanline) free(r->scanline);

	free(r);
}

static NSVGmemPage* nsvg__nextPage(NSVGrasterizer* r, NSVGmemPage* cur)
{
	NSVGmemPage *newp;

	// If using existing chain, return the next page in chain
	if (cur != NULL && cur->next != NULL) {
		return cur->next;
	}

	// Alloc new page
	newp = (NSVGmemPage*)malloc(sizeof(NSVGmemPage));
	if (newp == NULL) return NULL;
	memset(newp, 0, sizeof(NSVGmemPage));

	// Add to linked list
	if (cur != NULL)
		cur->next = newp;
	else
		r->pages = newp;

	return newp;
}

static void nsvg__resetPool(NSVGrasterizer* r)
{
	NSVGmemPage* p = r->pages;
	while (p != NULL) {
		p->size = 0;
		p = p->next;
	}
	r->curpage = r->pages;
}

static unsigned char* nsvg__alloc(NSVGrasterizer* r, int size)
{
	unsigned char* buf;
	if (size > NSVG__MEMPAGE_SIZE) return NULL;
	if (r->curpage == NULL || r->curpage->size+size > NSVG__MEMPAGE_SIZE) {
		r->curpage = nsvg__nextPage(r, r->curpage);
	}
	buf = &r->curpage->mem[r->curpage->size];
	r->curpage->size += size;
	return buf;
}

static int nsvg__ptEquals(float x1, float y1, float x2, float y2, float tol)
{
	float dx = x2 - x1;
	float dy = y2 - y1;
	return dx*dx + dy*dy < tol*tol;
}

static void nsvg__addPathPoint(NSVGrasterizer* r, float x, float y, int flags)
{
	NSVGpoint* pt;

	if (r->npoints > 0) {
		pt = &r->points[r->npoints-1];
		if (nsvg__ptEquals(pt->x,pt->y, x,y, r->distTol)) {
			pt->flags = (unsigned char)(pt->flags | flags);
			return;
		}
	}

	if (r->npoints+1 > r->cpoints) {
		r->cpoints = r->cpoints > 0 ? r->cpoints * 2 : 64;
		r->points = (NSVGpoint*)realloc(r->points, sizeof(NSVGpoint) * r->cpoints);
		if (r->points == NULL) return;
	}

	pt = &r->points[r->npoints];
	pt->x = x;
	pt->y = y;
	pt->flags = (unsigned char)flags;
	r->npoints++;
}

static void nsvg__appendPathPoint(NSVGrasterizer* r, NSVGpoint pt)
{
	if (r->npoints+1 > r->cpoints) {
		r->cpoints = r->cpoints > 0 ? r->cpoints * 2 : 64;
		r->points = (NSVGpoint*)realloc(r->points, sizeof(NSVGpoint) * r->cpoints);
		if (r->points == NULL) return;
	}
	r->points[r->npoints] = pt;
	r->npoints++;
}

static void nsvg__duplicatePoints(NSVGrasterizer* r)
{
	if (r->npoints > r->cpoints2) {
		r->cpoints2 = r->npoints;
		r->points2 = (NSVGpoint*)realloc(r->points2, sizeof(NSVGpoint) * r->cpoints2);
		if (r->points2 == NULL) return;
	}

	memcpy(r->points2, r->points, sizeof(NSVGpoint) * r->npoints);
	r->npoints2 = r->npoints;
}

static void nsvg__addEdge(NSVGrasterizer* r, float x0, float y0, float x1, float y1)
{
	NSVGedge* e;

	// Skip horizontal edges
	if (y0 == y1)
		return;

	if (r->nedges+1 > r->cedges) {
		r->cedges = r->cedges > 0 ? r->cedges * 2 : 64;
		r->edges = (NSVGedge*)realloc(r->edges, sizeof(NSVGedge) * r->cedges);
		if (r->edges == NULL) return;
	}

	e = &r->edges[r->nedges];
	r->nedges++;

	if (y0 < y1) {
		e->x0 = x0;
		e->y0 = y0;
		e->x1 = x1;
		e->y1 = y1;
		e->dir = 1;
	} else {
		e->x0 = x1;
		e->y0 = y1;
		e->x1 = x0;
		e->y1 = y0;
		e->dir = -1;
	}
}

static float nsvg__normalize(float *x, float* y)
{
	float d = sqrtf((*x)*(*x) + (*y)*(*y));
	if (d > 1e-6f) {
		float id = 1.0f / d;
		*x *= id;
		*y *= id;
	}
	return d;
}

static float nsvg__absf(float x) { return x < 0 ? -x : x; }
static float nsvg__roundf(float x) { return (x >= 0) ? floorf(x + 0.5) : ceilf(x - 0.5); }

static void nsvg__flattenCubicBez(NSVGrasterizer* r,
								  float x1, float y1, float x2, float y2,
								  float x3, float y3, float x4, float y4,
								  int level, int type)
{
	float x12,y12,x23,y23,x34,y34,x123,y123,x234,y234,x1234,y1234;
	float dx,dy,d2,d3;

	if (level > 10) return;

	x12 = (x1+x2)*0.5f;
	y12 = (y1+y2)*0.5f;
	x23 = (x2+x3)*0.5f;
	y23 = (y2+y3)*0.5f;
	x34 = (x3+x4)*0.5f;
	y34 = (y3+y4)*0.5f;
	x123 = (x12+x23)*0.5f;
	y123 = (y12+y23)*0.5f;

	dx = x4 - x1;
	dy = y4 - y1;
	d2 = nsvg__absf((x2 - x4) * dy - (y2 - y4) * dx);
	d3 = nsvg__absf((x3 - x4) * dy - (y3 - y4) * dx);

	if ((d2 + d3)*(d2 + d3) < r->tessTol * (dx*dx + dy*dy)) {
		nsvg__addPathPoint(r, x4, y4, type);
		return;
	}

	x234 = (x23+x34)*0.5f;
	y234 = (y23+y34)*0.5f;
	x1234 = (x123+x234)*0.5f;
	y1234 = (y123+y234)*0.5f;

	nsvg__flattenCubicBez(r, x1,y1, x12,y12, x123,y123, x1234,y1234, level+1, 0);
	nsvg__flattenCubicBez(r, x1234,y1234, x234,y234, x34,y34, x4,y4, level+1, type);
}

static void nsvg__flattenShape(NSVGrasterizer* r, NSVGshape* shape, float scale)
{
	int i, j;
	NSVGpath* path;

	for (path = shape->paths; path != NULL; path = path->next) {
		r->npoints = 0;
		// Flatten path
		nsvg__addPathPoint(r, path->pts[0]*scale, path->pts[1]*scale, 0);
		for (i = 0; i < path->npts-1; i += 3) {
			float* p = &path->pts[i*2];
			nsvg__flattenCubicBez(r, p[0]*scale,p[1]*scale, p[2]*scale,p[3]*scale, p[4]*scale,p[5]*scale, p[6]*scale,p[7]*scale, 0, 0);
		}
		// Close path
		nsvg__addPathPoint(r, path->pts[0]*scale, path->pts[1]*scale, 0);
		// Build edges
		for (i = 0, j = r->npoints-1; i < r->npoints; j = i++)
			nsvg__addEdge(r, r->points[j].x, r->points[j].y, r->points[i].x, r->points[i].y);
	}
}

enum NSVGpointFlags
{
	NSVG_PT_CORNER = 0x01,
	NSVG_PT_BEVEL = 0x02,
	NSVG_PT_LEFT = 0x04
};

static void nsvg__initClosed(NSVGpoint* left, NSVGpoint* right, NSVGpoint* p0, NSVGpoint* p1, float lineWidth)
{
	float w = lineWidth * 0.5f;
	float dx = p1->x - p0->x;
	float dy = p1->y - p0->y;
	float len = nsvg__normalize(&dx, &dy);
	float px = p0->x + dx*len*0.5f, py = p0->y + dy*len*0.5f;
	float dlx = dy, dly = -dx;
	float lx = px - dlx*w, ly = py - dly*w;
	float rx = px + dlx*w, ry = py + dly*w;
	left->x = lx; left->y = ly;
	right->x = rx; right->y = ry;
}

static void nsvg__buttCap(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p, float dx, float dy, float lineWidth, int connect)
{
	float w = lineWidth * 0.5f;
	float px = p->x, py = p->y;
	float dlx = dy, dly = -dx;
	float lx = px - dlx*w, ly = py - dly*w;
	float rx = px + dlx*w, ry = py + dly*w;

	nsvg__addEdge(r, lx, ly, rx, ry);

	if (connect) {
		nsvg__addEdge(r, left->x, left->y, lx, ly);
		nsvg__addEdge(r, rx, ry, right->x, right->y);
	}
	left->x = lx; left->y = ly;
	right->x = rx; right->y = ry;
}

static void nsvg__squareCap(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p, float dx, float dy, float lineWidth, int connect)
{
	float w = lineWidth * 0.5f;
	float px = p->x - dx*w, py = p->y - dy*w;
	float dlx = dy, dly = -dx;
	float lx = px - dlx*w, ly = py - dly*w;
	float rx = px + dlx*w, ry = py + dly*w;

	nsvg__addEdge(r, lx, ly, rx, ry);

	if (connect) {
		nsvg__addEdge(r, left->x, left->y, lx, ly);
		nsvg__addEdge(r, rx, ry, right->x, right->y);
	}
	left->x = lx; left->y = ly;
	right->x = rx; right->y = ry;
}

#ifndef NSVG_PI
#define NSVG_PI (3.14159265358979323846264338327f)
#endif

static void nsvg__roundCap(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p, float dx, float dy, float lineWidth, int ncap, int connect)
{
	int i;
	float w = lineWidth * 0.5f;
	float px = p->x, py = p->y;
	float dlx = dy, dly = -dx;
	float lx = 0, ly = 0, rx = 0, ry = 0, prevx = 0, prevy = 0;

	for (i = 0; i < ncap; i++) {
		float a = (float)i/(float)(ncap-1)*NSVG_PI;
		float ax = cosf(a) * w, ay = sinf(a) * w;
		float x = px - dlx*ax - dx*ay;
		float y = py - dly*ax - dy*ay;

		if (i > 0)
			nsvg__addEdge(r, prevx, prevy, x, y);

		prevx = x;
		prevy = y;

		if (i == 0) {
			lx = x; ly = y;
		} else if (i == ncap-1) {
			rx = x; ry = y;
		}
	}

	if (connect) {
		nsvg__addEdge(r, left->x, left->y, lx, ly);
		nsvg__addEdge(r, rx, ry, right->x, right->y);
	}

	left->x = lx; left->y = ly;
	right->x = rx; right->y = ry;
}

static void nsvg__bevelJoin(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p0, NSVGpoint* p1, float lineWidth)
{
	float w = lineWidth * 0.5f;
	float dlx0 = p0->dy, dly0 = -p0->dx;
	float dlx1 = p1->dy, dly1 = -p1->dx;
	float lx0 = p1->x - (dlx0 * w), ly0 = p1->y - (dly0 * w);
	float rx0 = p1->x + (dlx0 * w), ry0 = p1->y + (dly0 * w);
	float lx1 = p1->x - (dlx1 * w), ly1 = p1->y - (dly1 * w);
	float rx1 = p1->x + (dlx1 * w), ry1 = p1->y + (dly1 * w);

	nsvg__addEdge(r, lx0, ly0, left->x, left->y);
	nsvg__addEdge(r, lx1, ly1, lx0, ly0);

	nsvg__addEdge(r, right->x, right->y, rx0, ry0);
	nsvg__addEdge(r, rx0, ry0, rx1, ry1);

	left->x = lx1; left->y = ly1;
	right->x = rx1; right->y = ry1;
}

static void nsvg__miterJoin(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p0, NSVGpoint* p1, float lineWidth)
{
	float w = lineWidth * 0.5f;
	float dlx0 = p0->dy, dly0 = -p0->dx;
	float dlx1 = p1->dy, dly1 = -p1->dx;
	float lx0, rx0, lx1, rx1;
	float ly0, ry0, ly1, ry1;

	if (p1->flags & NSVG_PT_LEFT) {
		lx0 = lx1 = p1->x - p1->dmx * w;
		ly0 = ly1 = p1->y - p1->dmy * w;
		nsvg__addEdge(r, lx1, ly1, left->x, left->y);

		rx0 = p1->x + (dlx0 * w);
		ry0 = p1->y + (dly0 * w);
		rx1 = p1->x + (dlx1 * w);
		ry1 = p1->y + (dly1 * w);
		nsvg__addEdge(r, right->x, right->y, rx0, ry0);
		nsvg__addEdge(r, rx0, ry0, rx1, ry1);
	} else {
		lx0 = p1->x - (dlx0 * w);
		ly0 = p1->y - (dly0 * w);
		lx1 = p1->x - (dlx1 * w);
		ly1 = p1->y - (dly1 * w);
		nsvg__addEdge(r, lx0, ly0, left->x, left->y);
		nsvg__addEdge(r, lx1, ly1, lx0, ly0);

		rx0 = rx1 = p1->x + p1->dmx * w;
		ry0 = ry1 = p1->y + p1->dmy * w;
		nsvg__addEdge(r, right->x, right->y, rx1, ry1);
	}

	left->x = lx1; left->y = ly1;
	right->x = rx1; right->y = ry1;
}

static void nsvg__roundJoin(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p0, NSVGpoint* p1, float lineWidth, int ncap)
{
	int i, n;
	float w = lineWidth * 0.5f;
	float dlx0 = p0->dy, dly0 = -p0->dx;
	float dlx1 = p1->dy, dly1 = -p1->dx;
	float a0 = atan2f(dly0, dlx0);
	float a1 = atan2f(dly1, dlx1);
	float da = a1 - a0;
	float lx, ly, rx, ry;

	if (da < NSVG_PI) da += NSVG_PI*2;
	if (da > NSVG_PI) da -= NSVG_PI*2;

	n = (int)ceilf((nsvg__absf(da) / NSVG_PI) * (float)ncap);
	if (n < 2) n = 2;
	if (n > ncap) n = ncap;

	lx = left->x;
	ly = left->y;
	rx = right->x;
	ry = right->y;

	for (i = 0; i < n; i++) {
		float u = (float)i/(float)(n-1);
		float a = a0 + u*da;
		float ax = cosf(a) * w, ay = sinf(a) * w;
		float lx1 = p1->x - ax, ly1 = p1->y - ay;
		float rx1 = p1->x + ax, ry1 = p1->y + ay;

		nsvg__addEdge(r, lx1, ly1, lx, ly);
		nsvg__addEdge(r, rx, ry, rx1, ry1);

		lx = lx1; ly = ly1;
		rx = rx1; ry = ry1;
	}

	left->x = lx; left->y = ly;
	right->x = rx; right->y = ry;
}

static void nsvg__straightJoin(NSVGrasterizer* r, NSVGpoint* left, NSVGpoint* right, NSVGpoint* p1, float lineWidth)
{
	float w = lineWidth * 0.5f;
	float lx = p1->x - (p1->dmx * w), ly = p1->y - (p1->dmy * w);
	float rx = p1->x + (p1->dmx * w), ry = p1->y + (p1->dmy * w);

	nsvg__addEdge(r, lx, ly, left->x, left->y);
	nsvg__addEdge(r, right->x, right->y, rx, ry);

	left->x = lx; left->y = ly;
	right->x = rx; right->y = ry;
}

static int nsvg__curveDivs(float r, float arc, float tol)
{
	float da = acosf(r / (r + tol)) * 2.0f;
	int divs = (int)ceilf(arc / da);
	if (divs < 2) divs = 2;
	return divs;
}

static void nsvg__expandStroke(NSVGrasterizer* r, NSVGpoint* points, int npoints, int closed, int lineJoin, int lineCap, float lineWidth)
{
	int ncap = nsvg__curveDivs(lineWidth*0.5f, NSVG_PI, r->tessTol);	// Calculate divisions per half circle.
	NSVGpoint left = {0,0,0,0,0,0,0,0}, right = {0,0,0,0,0,0,0,0}, firstLeft = {0,0,0,0,0,0,0,0}, firstRight = {0,0,0,0,0,0,0,0};
	NSVGpoint* p0, *p1;
	int j, s, e;

	// Build stroke edges
	if (closed) {
		// Looping
		p0 = &points[npoints-1];
		p1 = &points[0];
		s = 0;
		e = npoints;
	} else {
		// Add cap
		p0 = &points[0];
		p1 = &points[1];
		s = 1;
		e = npoints-1;
	}

	if (closed) {
		nsvg__initClosed(&left, &right, p0, p1, lineWidth);
		firstLeft = left;
		firstRight = right;
	} else {
		// Add cap
		float dx = p1->x - p0->x;
		float dy = p1->y - p0->y;
		nsvg__normalize(&dx, &dy);
		if (lineCap == NSVG_CAP_BUTT)
			nsvg__buttCap(r, &left, &right, p0, dx, dy, lineWidth, 0);
		else if (lineCap == NSVG_CAP_SQUARE)
			nsvg__squareCap(r, &left, &right, p0, dx, dy, lineWidth, 0);
		else if (lineCap == NSVG_CAP_ROUND)
			nsvg__roundCap(r, &left, &right, p0, dx, dy, lineWidth, ncap, 0);
	}

	for (j = s; j < e; ++j) {
		if (p1->flags & NSVG_PT_CORNER) {
			if (lineJoin == NSVG_JOIN_ROUND)
				nsvg__roundJoin(r, &left, &right, p0, p1, lineWidth, ncap);
			else if (lineJoin == NSVG_JOIN_BEVEL || (p1->flags & NSVG_PT_BEVEL))
				nsvg__bevelJoin(r, &left, &right, p0, p1, lineWidth);
			else
				nsvg__miterJoin(r, &left, &right, p0, p1, lineWidth);
		} else {
			nsvg__straightJoin(r, &left, &right, p1, lineWidth);
		}
		p0 = p1++;
	}

	if (closed) {
		// Loop it
		nsvg__addEdge(r, firstLeft.x, firstLeft.y, left.x, left.y);
		nsvg__addEdge(r, right.x, right.y, firstRight.x, firstRight.y);
	} else {
		// Add cap
		float dx = p1->x - p0->x;
		float dy = p1->y - p0->y;
		nsvg__normalize(&dx, &dy);
		if (lineCap == NSVG_CAP_BUTT)
			nsvg__buttCap(r, &right, &left, p1, -dx, -dy, lineWidth, 1);
		else if (lineCap == NSVG_CAP_SQUARE)
			nsvg__squareCap(r, &right, &left, p1, -dx, -dy, lineWidth, 1);
		else if (lineCap == NSVG_CAP_ROUND)
			nsvg__roundCap(r, &right, &left, p1, -dx, -dy, lineWidth, ncap, 1);
	}
}

static void nsvg__prepareStroke(NSVGrasterizer* r, float miterLimit, int lineJoin)
{
	int i, j;
	NSVGpoint* p0, *p1;

	p0 = &r->points[r->npoints-1];
	p1 = &r->points[0];
	for (i = 0; i < r->npoints; i++) {
		// Calculate segment direction and length
		p0->dx = p1->x - p0->x;
		p0->dy = p1->y - p0->y;
		p0->len = nsvg__normalize(&p0->dx, &p0->dy);
		// Advance
		p0 = p1++;
	}

	// calculate joins
	p0 = &r->points[r->npoints-1];
	p1 = &r->points[0];
	for (j = 0; j < r->npoints; j++) {
		float dlx0, dly0, dlx1, dly1, dmr2, cross;
		dlx0 = p0->dy;
		dly0 = -p0->dx;
		dlx1 = p1->dy;
		dly1 = -p1->dx;
		// Calculate extrusions
		p1->dmx = (dlx0 + dlx1) * 0.5f;
		p1->dmy = (dly0 + dly1) * 0.5f;
		dmr2 = p1->dmx*p1->dmx + p1->dmy*p1->dmy;
		if (dmr2 > 0.000001f) {
			float s2 = 1.0f / dmr2;
			if (s2 > 600.0f) {
				s2 = 600.0f;
			}
			p1->dmx *= s2;
			p1->dmy *= s2;
		}

		// Clear flags, but keep the corner.
		p1->flags = (p1->flags & NSVG_PT_CORNER) ? NSVG_PT_CORNER : 0;

		// Keep track of left turns.
		cross = p1->dx * p0->dy - p0->dx * p1->dy;
		if (cross > 0.0f)
			p1->flags |= NSVG_PT_LEFT;

		// Check to see if the corner needs to be beveled.
		if (p1->flags & NSVG_PT_CORNER) {
			if ((dmr2 * miterLimit*miterLimit) < 1.0f || lineJoin == NSVG_JOIN_BEVEL || lineJoin == NSVG_JOIN_ROUND) {
				p1->flags |= NSVG_PT_BEVEL;
			}
		}

		p0 = p1++;
	}
}

static void nsvg__flattenShapeStroke(NSVGrasterizer* r, NSVGshape* shape, float scale)
{
	int i, j, closed;
	NSVGpath* path;
	NSVGpoint* p0, *p1;
	float miterLimit = shape->miterLimit;
	int lineJoin = shape->strokeLineJoin;
	int lineCap = shape->strokeLineCap;
	float lineWidth = shape->strokeWidth * scale;

	for (path = shape->paths; path != NULL; path = path->next) {
		// Flatten path
		r->npoints = 0;
		nsvg__addPathPoint(r, path->pts[0]*scale, path->pts[1]*scale, NSVG_PT_CORNER);
		for (i = 0; i < path->npts-1; i += 3) {
			float* p = &path->pts[i*2];
			nsvg__flattenCubicBez(r, p[0]*scale,p[1]*scale, p[2]*scale,p[3]*scale, p[4]*scale,p[5]*scale, p[6]*scale,p[7]*scale, 0, NSVG_PT_CORNER);
		}
		if (r->npoints < 2)
			continue;

		closed = path->closed;

		// If the first and last points are the same, remove the last, mark as closed path.
		p0 = &r->points[r->npoints-1];
		p1 = &r->points[0];
		if (nsvg__ptEquals(p0->x,p0->y, p1->x,p1->y, r->distTol)) {
			r->npoints--;
			p0 = &r->points[r->npoints-1];
			closed = 1;
		}

		if (shape->strokeDashCount > 0) {
			int idash = 0, dashState = 1;
			float totalDist = 0, dashLen, allDashLen, dashOffset;
			NSVGpoint cur;

			if (closed)
				nsvg__appendPathPoint(r, r->points[0]);

			// Duplicate points -> points2.
			nsvg__duplicatePoints(r);

			r->npoints = 0;
 			cur = r->points2[0];
			nsvg__appendPathPoint(r, cur);

			// Figure out dash offset.
			allDashLen = 0;
			for (j = 0; j < shape->strokeDashCount; j++)
				allDashLen += shape->strokeDashArray[j];
			if (shape->strokeDashCount & 1)
				allDashLen *= 2.0f;
			// Find location inside pattern
			dashOffset = fmodf(shape->strokeDashOffset, allDashLen);
			if (dashOffset < 0.0f)
				dashOffset += allDashLen;

			while (dashOffset > shape->strokeDashArray[idash]) {
				dashOffset -= shape->strokeDashArray[idash];
				idash = (idash + 1) % shape->strokeDashCount;
			}
			dashLen = (shape->strokeDashArray[idash] - dashOffset) * scale;

			for (j = 1; j < r->npoints2; ) {
				float dx = r->points2[j].x - cur.x;
				float dy = r->points2[j].y - cur.y;
				float dist = sqrtf(dx*dx + dy*dy);

				if ((totalDist + dist) > dashLen) {
					// Calculate intermediate point
					float d = (dashLen - totalDist) / dist;
					float x = cur.x + dx * d;
					float y = cur.y + dy * d;
					nsvg__addPathPoint(r, x, y, NSVG_PT_CORNER);

					// Stroke
					if (r->npoints > 1 && dashState) {
						nsvg__prepareStroke(r, miterLimit, lineJoin);
						nsvg__expandStroke(r, r->points, r->npoints, 0, lineJoin, lineCap, lineWidth);
					}
					// Advance dash pattern
					dashState = !dashState;
					idash = (idash+1) % shape->strokeDashCount;
					dashLen = shape->strokeDashArray[idash] * scale;
					// Restart
					cur.x = x;
					cur.y = y;
					cur.flags = NSVG_PT_CORNER;
					totalDist = 0.0f;
					r->npoints = 0;
					nsvg__appendPathPoint(r, cur);
				} else {
					totalDist += dist;
					cur = r->points2[j];
					nsvg__appendPathPoint(r, cur);
					j++;
				}
			}
			// Stroke any leftover path
			if (r->npoints > 1 && dashState) {
				nsvg__prepareStroke(r, miterLimit, lineJoin);
				nsvg__expandStroke(r, r->points, r->npoints, 0, lineJoin, lineCap, lineWidth);
			}
		} else {
			nsvg__prepareStroke(r, miterLimit, lineJoin);
			nsvg__expandStroke(r, r->points, r->npoints, closed, lineJoin, lineCap, lineWidth);
		}
	}
}

static int nsvg__cmpEdge(const void *p, const void *q)
{
	const NSVGedge* a = (const NSVGedge*)p;
	const NSVGedge* b = (const NSVGedge*)q;

	if (a->y0 < b->y0) return -1;
	if (a->y0 > b->y0) return  1;
	return 0;
}


static NSVGactiveEdge* nsvg__addActive(NSVGrasterizer* r, NSVGedge* e, float startPoint)
{
	 NSVGactiveEdge* z;

	if (r->freelist != NULL) {
		// Restore from freelist.
		z = r->freelist;
		r->freelist = z->next;
	} else {
		// Alloc new edge.
		z = (NSVGactiveEdge*)nsvg__alloc(r, sizeof(NSVGactiveEdge));
		if (z == NULL) return NULL;
	}

	float dxdy = (e->x1 - e->x0) / (e->y1 - e->y0);
//	STBTT_assert(e->y0 <= start_point);
	// round dx down to avoid going too far
	if (dxdy < 0)
		z->dx = (int)(-nsvg__roundf(NSVG__FIX * -dxdy));
	else
		z->dx = (int)nsvg__roundf(NSVG__FIX * dxdy);
	z->x = (int)nsvg__roundf(NSVG__FIX * (e->x0 + dxdy * (startPoint - e->y0)));
//	z->x -= off_x * FIX;
	z->ey = e->y1;
	z->next = 0;
	z->dir = e->dir;

	return z;
}

static void nsvg__freeActive(NSVGrasterizer* r, NSVGactiveEdge* z)
{
	z->next = r->freelist;
	r->freelist = z;
}

static void nsvg__fillScanline(unsigned char* scanline, int len, int x0, int x1, int maxWeight, int* xmin, int* xmax)
{
	int i = x0 >> NSVG__FIXSHIFT;
	int j = x1 >> NSVG__FIXSHIFT;
	if (i < *xmin) *xmin = i;
	if (j > *xmax) *xmax = j;
	if (i < len && j >= 0) {
		if (i == j) {
			// x0,x1 are the same pixel, so compute combined coverage
			scanline[i] = (unsigned char)(scanline[i] + ((x1 - x0) * maxWeight >> NSVG__FIXSHIFT));
		} else {
			if (i >= 0) // add antialiasing for x0
				scanline[i] = (unsigned char)(scanline[i] + (((NSVG__FIX - (x0 & NSVG__FIXMASK)) * maxWeight) >> NSVG__FIXSHIFT));
			else
				i = -1; // clip

			if (j < len) // add antialiasing for x1
				scanline[j] = (unsigned char)(scanline[j] + (((x1 & NSVG__FIXMASK) * maxWeight) >> NSVG__FIXSHIFT));
			else
				j = len; // clip

			for (++i; i < j; ++i) // fill pixels between x0 and x1
				scanline[i] = (unsigned char)(scanline[i] + maxWeight);
		}
	}
}

// note: this routine clips fills that extend off the edges... ideally this
// wouldn't happen, but it could happen if the truetype glyph bounding boxes
// are wrong, or if the user supplies a too-small bitmap
static void nsvg__fillActiveEdges(unsigned char* scanline, int len, NSVGactiveEdge* e, int maxWeight, int* xmin, int* xmax, char fillRule)
{
	// non-zero winding fill
	int x0 = 0, w = 0;

	if (fillRule == NSVG_FILLRULE_NONZERO) {
		// Non-zero
		while (e != NULL) {
			if (w == 0) {
				// if we're currently at zero, we need to record the edge start point
				x0 = e->x; w += e->dir;
			} else {
				int x1 = e->x; w += e->dir;
				// if we went to zero, we need to draw
				if (w == 0)
					nsvg__fillScanline(scanline, len, x0, x1, maxWeight, xmin, xmax);
			}
			e = e->next;
		}
	} else if (fillRule == NSVG_FILLRULE_EVENODD) {
		// Even-odd
		while (e != NULL) {
			if (w == 0) {
				// if we're currently at zero, we need to record the edge start point
				x0 = e->x; w = 1;
			} else {
				int x1 = e->x; w = 0;
				nsvg__fillScanline(scanline, len, x0, x1, maxWeight, xmin, xmax);
			}
			e = e->next;
		}
	}
}

static float nsvg__clampf(float a, float mn, float mx) {
	if (isnan(a))
		return mn;
	return a < mn ? mn : (a > mx ? mx : a);
}

static unsigned int nsvg__RGBA(unsigned char r, unsigned char g, unsigned char b, unsigned char a)
{
	return ((unsigned int)r) | ((unsigned int)g << 8) | ((unsigned int)b << 16) | ((unsigned int)a << 24);
}

static unsigned int nsvg__lerpRGBA(unsigned int c0, unsigned int c1, float u)
{
	int iu = (int)(nsvg__clampf(u, 0.0f, 1.0f) * 256.0f);
	int r = (((c0) & 0xff)*(256-iu) + (((c1) & 0xff)*iu)) >> 8;
	int g = (((c0>>8) & 0xff)*(256-iu) + (((c1>>8) & 0xff)*iu)) >> 8;
	int b = (((c0>>16) & 0xff)*(256-iu) + (((c1>>16) & 0xff)*iu)) >> 8;
	int a = (((c0>>24) & 0xff)*(256-iu) + (((c1>>24) & 0xff)*iu)) >> 8;
	return nsvg__RGBA((unsigned char)r, (unsigned char)g, (unsigned char)b, (unsigned char)a);
}

static unsigned int nsvg__applyOpacity(unsigned int c, float u)
{
	int iu = (int)(nsvg__clampf(u, 0.0f, 1.0f) * 256.0f);
	int r = (c) & 0xff;
	int g = (c>>8) & 0xff;
	int b = (c>>16) & 0xff;
	int a = (((c>>24) & 0xff)*iu) >> 8;
	return nsvg__RGBA((unsigned char)r, (unsigned char)g, (unsigned char)b, (unsigned char)a);
}

static inline int nsvg__div255(int x)
{
    return ((x+1) * 257) >> 16;
}

static void nsvg__scanlineSolid(unsigned char* dst, int count, unsigned char* cover, int x, int y,
								float tx, float ty, float scale, NSVGcachedPaint* cache)
{

	if (cache->type == NSVG_PAINT_COLOR) {
		int i, cr, cg, cb, ca;
		cr = cache->colors[0] & 0xff;
		cg = (cache->colors[0] >> 8) & 0xff;
		cb = (cache->colors[0] >> 16) & 0xff;
		ca = (cache->colors[0] >> 24) & 0xff;

		for (i = 0; i < count; i++) {
			int r,g,b;
			int a = nsvg__div255((int)cover[0] * ca);
			int ia = 255 - a;
			// Premultiply
			r = nsvg__div255(cr * a);
			g = nsvg__div255(cg * a);
			b = nsvg__div255(cb * a);

			// Blend over
			r += nsvg__div255(ia * (int)dst[0]);
			g += nsvg__div255(ia * (int)dst[1]);
			b += nsvg__div255(ia * (int)dst[2]);
			a += nsvg__div255(ia * (int)dst[3]);

			dst[0] = (unsigned char)r;
			dst[1] = (unsigned char)g;
			dst[2] = (unsigned char)b;
			dst[3] = (unsigned char)a;

			cover++;
			dst += 4;
		}
	} else if (cache->type == NSVG_PAINT_LINEAR_GRADIENT) {
		// TODO: spread modes.
		// TODO: plenty of opportunities to optimize.
		float fx, fy, dx, gy;
		float* t = cache->xform;
		int i, cr, cg, cb, ca;
		unsigned int c;

		fx = ((float)x - tx) / scale;
		fy = ((float)y - ty) / scale;
		dx = 1.0f / scale;

		for (i = 0; i < count; i++) {
			int r,g,b,a,ia;
			gy = fx*t[1] + fy*t[3] + t[5];
			c = cache->colors[(int)nsvg__clampf(gy*255.0f, 0, 255.0f)];
			cr = (c) & 0xff;
			cg = (c >> 8) & 0xff;
			cb = (c >> 16) & 0xff;
			ca = (c >> 24) & 0xff;

			a = nsvg__div255((int)cover[0] * ca);
			ia = 255 - a;

			// Premultiply
			r = nsvg__div255(cr * a);
			g = nsvg__div255(cg * a);
			b = nsvg__div255(cb * a);

			// Blend over
			r += nsvg__div255(ia * (int)dst[0]);
			g += nsvg__div255(ia * (int)dst[1]);
			b += nsvg__div255(ia * (int)dst[2]);
			a += nsvg__div255(ia * (int)dst[3]);

			dst[0] = (unsigned char)r;
			dst[1] = (unsigned char)g;
			dst[2] = (unsigned char)b;
			dst[3] = (unsigned char)a;

			cover++;
			dst += 4;
			fx += dx;
		}
	} else if (cache->type == NSVG_PAINT_RADIAL_GRADIENT) {
		// TODO: spread modes.
		// TODO: plenty of opportunities to optimize.
		// TODO: focus (fx,fy)
		float fx, fy, dx, gx, gy, gd;
		float* t = cache->xform;
		int i, cr, cg, cb, ca;
		unsigned int c;

		fx = ((float)x - tx) / scale;
		fy = ((float)y - ty) / scale;
		dx = 1.0f / scale;

		for (i = 0; i < count; i++) {
			int r,g,b,a,ia;
			gx = fx*t[0] + fy*t[2] + t[4];
			gy = fx*t[1] + fy*t[3] + t[5];
			gd = sqrtf(gx*gx + gy*gy);
			c = cache->colors[(int)nsvg__clampf(gd*255.0f, 0, 255.0f)];
			cr = (c) & 0xff;
			cg = (c >> 8) & 0xff;
			cb = (c >> 16) & 0xff;
			ca = (c >> 24) & 0xff;

			a = nsvg__div255((int)cover[0] * ca);
			ia = 255 - a;

			// Premultiply
			r = nsvg__div255(cr * a);
			g = nsvg__div255(cg * a);
			b = nsvg__div255(cb * a);

			// Blend over
			r += nsvg__div255(ia * (int)dst[0]);
			g += nsvg__div255(ia * (int)dst[1]);
			b += nsvg__div255(ia * (int)dst[2]);
			a += nsvg__div255(ia * (int)dst[3]);

			dst[0] = (unsigned char)r;
			dst[1] = (unsigned char)g;
			dst[2] = (unsigned char)b;
			dst[3] = (unsigned char)a;

			cover++;
			dst += 4;
			fx += dx;
		}
	}
}

static void nsvg__rasterizeSortedEdges(NSVGrasterizer *r, float tx, float ty, float scale, NSVGcachedPaint* cache, char fillRule)
{
	NSVGactiveEdge *active = NULL;
	int y, s;
	int e = 0;
	int maxWeight = (255 / NSVG__SUBSAMPLES);  // weight per vertical scanline
	int xmin, xmax;

	for (y = 0; y < r->height; y++) {
		memset(r->scanline, 0, r->width);
		xmin = r->width;
		xmax = 0;
		for (s = 0; s < NSVG__SUBSAMPLES; ++s) {
			// find center of pixel for this scanline
			float scany = (float)(y*NSVG__SUBSAMPLES + s) + 0.5f;
			NSVGactiveEdge **step = &active;

			// update all active edges;
			// remove all active edges that terminate before the center of this scanline
			while (*step) {
				NSVGactiveEdge *z = *step;
				if (z->ey <= scany) {
					*step = z->next; // delete from list
//					NSVG__assert(z->valid);
					nsvg__freeActive(r, z);
				} else {
					z->x += z->dx; // advance to position for current scanline
					step = &((*step)->next); // advance through list
				}
			}

			// resort the list if needed
			for (;;) {
				int changed = 0;
				step = &active;
				while (*step && (*step)->next) {
					if ((*step)->x > (*step)->next->x) {
						NSVGactiveEdge* t = *step;
						NSVGactiveEdge* q = t->next;
						t->next = q->next;
						q->next = t;
						*step = q;
						changed = 1;
					}
					step = &(*step)->next;
				}
				if (!changed) break;
			}

			// insert all edges that start before the center of this scanline -- omit ones that also end on this scanline
			while (e < r->nedges && r->edges[e].y0 <= scany) {
				if (r->edges[e].y1 > scany) {
					NSVGactiveEdge* z = nsvg__addActive(r, &r->edges[e], scany);
					if (z == NULL) break;
					// find insertion point
					if (active == NULL) {
						active = z;
					} else if (z->x < active->x) {
						// insert at front
						z->next = active;
						active = z;
					} else {
						// find thing to insert AFTER
						NSVGactiveEdge* p = active;
						while (p->next && p->next->x < z->x)
							p = p->next;
						// at this point, p->next->x is NOT < z->x
						z->next = p->next;
						p->next = z;
					}
				}
				e++;
			}

			// now process all active edges in non-zero fashion
			if (active != NULL)
				nsvg__fillActiveEdges(r->scanline, r->width, active, maxWeight, &xmin, &xmax, fillRule);
		}
		// Blit
		if (xmin < 0) xmin = 0;
		if (xmax > r->width-1) xmax = r->width-1;
		if (xmin <= xmax) {
			nsvg__scanlineSolid(&r->bitmap[y * r->stride] + xmin*4, xmax-xmin+1, &r->scanline[xmin], xmin, y, tx,ty, scale, cache);
		}
	}

}

static void nsvg__unpremultiplyAlpha(unsigned char* image, int w, int h, int stride)
{
	int x,y;

	// Unpremultiply
	for (y = 0; y < h; y++) {
		unsigned char *row = &image[y*stride];
		for (x = 0; x < w; x++) {
			int r = row[0], g = row[1], b = row[2], a = row[3];
			if (a != 0) {
				row[0] = (unsigned char)(r*255/a);
				row[1] = (unsigned char)(g*255/a);
				row[2] = (unsigned char)(b*255/a);
			}
			row += 4;
		}
	}

	// Defringe
	for (y = 0; y < h; y++) {
		unsigned char *row = &image[y*stride];
		for (x = 0; x < w; x++) {
			int r = 0, g = 0, b = 0, a = row[3], n = 0;
			if (a == 0) {
				if (x-1 > 0 && row[-1] != 0) {
					r += row[-4];
					g += row[-3];
					b += row[-2];
					n++;
				}
				if (x+1 < w && row[7] != 0) {
					r += row[4];
					g += row[5];
					b += row[6];
					n++;
				}
				if (y-1 > 0 && row[-stride+3] != 0) {
					r += row[-stride];
					g += row[-stride+1];
					b += row[-stride+2];
					n++;
				}
				if (y+1 < h && row[stride+3] != 0) {
					r += row[stride];
					g += row[stride+1];
					b += row[stride+2];
					n++;
				}
				if (n > 0) {
					row[0] = (unsigned char)(r/n);
					row[1] = (unsigned char)(g/n);
					row[2] = (unsigned char)(b/n);
				}
			}
			row += 4;
		}
	}
}


static void nsvg__initPaint(NSVGcachedPaint* cache, NSVGpaint* paint, float opacity)
{
	int i, j;
	NSVGgradient* grad;

	cache->type = paint->type;

	if (paint->type == NSVG_PAINT_COLOR) {
		cache->colors[0] = nsvg__applyOpacity(paint->color, opacity);
		return;
	}

	grad = paint->gradient;

	cache->spread = grad->spread;
	memcpy(cache->xform, grad->xform, sizeof(float)*6);

	if (grad->nstops == 0) {
		for (i = 0; i < 256; i++)
			cache->colors[i] = 0;
	} else if (grad->nstops == 1) {
		unsigned int color = nsvg__applyOpacity(grad->stops[0].color, opacity);
		for (i = 0; i < 256; i++)
			cache->colors[i] = color;
	} else {
		unsigned int ca, cb = 0;
		float ua, ub, du, u;
		int ia, ib, count;

		ca = nsvg__applyOpacity(grad->stops[0].color, opacity);
		ua = nsvg__clampf(grad->stops[0].offset, 0, 1);
		ub = nsvg__clampf(grad->stops[grad->nstops-1].offset, ua, 1);
		ia = (int)(ua * 255.0f);
		ib = (int)(ub * 255.0f);
		for (i = 0; i < ia; i++) {
			cache->colors[i] = ca;
		}

		for (i = 0; i < grad->nstops-1; i++) {
			ca = nsvg__applyOpacity(grad->stops[i].color, opacity);
			cb = nsvg__applyOpacity(grad->stops[i+1].color, opacity);
			ua = nsvg__clampf(grad->stops[i].offset, 0, 1);
			ub = nsvg__clampf(grad->stops[i+1].offset, 0, 1);
			ia = (int)(ua * 255.0f);
			ib = (int)(ub * 255.0f);
			count = ib - ia;
			if (count <= 0) continue;
			u = 0;
			du = 1.0f / (float)count;
			for (j = 0; j < count; j++) {
				cache->colors[ia+j] = nsvg__lerpRGBA(ca,cb,u);
				u += du;
			}
		}

		for (i = ib; i < 256; i++)
			cache->colors[i] = cb;
	}

}

/*
static void dumpEdges(NSVGrasterizer* r, const char* name)
{
	float xmin = 0, xmax = 0, ymin = 0, ymax = 0;
	NSVGedge *e = NULL;
	int i;
	if (r->nedges == 0) return;
	FILE* fp = fopen(name, "w");
	if (fp == NULL) return;

	xmin = xmax = r->edges[0].x0;
	ymin = ymax = r->edges[0].y0;
	for (i = 0; i < r->nedges; i++) {
		e = &r->edges[i];
		xmin = nsvg__minf(xmin, e->x0);
		xmin = nsvg__minf(xmin, e->x1);
		xmax = nsvg__maxf(xmax, e->x0);
		xmax = nsvg__maxf(xmax, e->x1);
		ymin = nsvg__minf(ymin, e->y0);
		ymin = nsvg__minf(ymin, e->y1);
		ymax = nsvg__maxf(ymax, e->y0);
		ymax = nsvg__maxf(ymax, e->y1);
	}

	fprintf(fp, "<svg viewBox=\"%f %f %f %f\" xmlns=\"http://www.w3.org/2000/svg\">", xmin, ymin, (xmax - xmin), (ymax - ymin));

	for (i = 0; i < r->nedges; i++) {
		e = &r->edges[i];
		fprintf(fp ,"<line x1=\"%f\" y1=\"%f\" x2=\"%f\" y2=\"%f\" style=\"stroke:#000;\" />", e->x0,e->y0, e->x1,e->y1);
	}

	for (i = 0; i < r->npoints; i++) {
		if (i+1 < r->npoints)
			fprintf(fp ,"<line x1=\"%f\" y1=\"%f\" x2=\"%f\" y2=\"%f\" style=\"stroke:#f00;\" />", r->points[i].x, r->points[i].y, r->points[i+1].x, r->points[i+1].y);
		fprintf(fp ,"<circle cx=\"%f\" cy=\"%f\" r=\"1\" style=\"fill:%s;\" />", r->points[i].x, r->points[i].y, r->points[i].flags == 0 ? "#f00" : "#0f0");
	}

	fprintf(fp, "</svg>");
	fclose(fp);
}
*/

void nsvgRasterize(NSVGrasterizer* r,
				   NSVGimage* image, float tx, float ty, float scale,
				   unsigned char* dst, int w, int h, int stride)
{
	NSVGshape *shape = NULL;
	NSVGedge *e = NULL;
	NSVGcachedPaint cache;
	int i;
    int j;
    unsigned char paintOrder;

	r->bitmap = dst;
	r->width = w;
	r->height = h;
	r->stride = stride;

	if (w > r->cscanline) {
		r->cscanline = w;
		r->scanline = (unsigned char*)realloc(r->scanline, w);
		if (r->scanline == NULL) return;
	}

	for (i = 0; i < h; i++)
		memset(&dst[i*stride], 0, w*4);

	for (shape = image->shapes; shape != NULL; shape = shape->next) {
		if (!(shape->flags & NSVG_FLAGS_VISIBLE))
			continue;

        for (j = 0; j < 3; j++) {
            paintOrder = (shape->paintOrder >> (2 * j)) & 0x03;

            if (paintOrder == NSVG_PAINT_FILL && shape->fill.type != NSVG_PAINT_NONE) {
                nsvg__resetPool(r);
                r->freelist = NULL;
                r->nedges = 0;

                nsvg__flattenShape(r, shape, scale);

                // Scale and translate edges
                for (i = 0; i < r->nedges; i++) {
                    e = &r->edges[i];
                    e->x0 = tx + e->x0;
                    e->y0 = (ty + e->y0) * NSVG__SUBSAMPLES;
                    e->x1 = tx + e->x1;
                    e->y1 = (ty + e->y1) * NSVG__SUBSAMPLES;
                }

                // Rasterize edges
                if (r->nedges != 0)
                    qsort(r->edges, r->nedges, sizeof(NSVGedge), nsvg__cmpEdge);

                // now, traverse the scanlines and find the intersections on each scanline, use non-zero rule
                nsvg__initPaint(&cache, &shape->fill, shape->opacity);

                nsvg__rasterizeSortedEdges(r, tx,ty,scale, &cache, shape->fillRule);
            }
            if (paintOrder == NSVG_PAINT_STROKE && shape->stroke.type != NSVG_PAINT_NONE && (shape->strokeWidth * scale) > 0.01f) {
                nsvg__resetPool(r);
                r->freelist = NULL;
                r->nedges = 0;

                nsvg__flattenShapeStroke(r, shape, scale);

    //			dumpEdges(r, "edge.svg");

                // Scale and translate edges
                for (i = 0; i < r->nedges; i++) {
                    e = &r->edges[i];
                    e->x0 = tx + e->x0;
                    e->y0 = (ty + e->y0) * NSVG__SUBSAMPLES;
                    e->x1 = tx + e->x1;
                    e->y1 = (ty + e->y1) * NSVG__SUBSAMPLES;
                }

                // Rasterize edges
                if (r->nedges != 0)
                    qsort(r->edges, r->nedges, sizeof(NSVGedge), nsvg__cmpEdge);

                // now, traverse the scanlines and find the intersections on each scanline, use non-zero rule
                nsvg__initPaint(&cache, &shape->stroke, shape->opacity);

                nsvg__rasterizeSortedEdges(r, tx,ty,scale, &cache, NSVG_FILLRULE_NONZERO);
            }
        }
	}

	nsvg__unpremultiplyAlpha(dst, w, h, stride);

	r->bitmap = NULL;
	r->width = 0;
	r->height = 0;
	r->stride = 0;
}

#endif // NANOSVGRAST_IMPLEMENTATION

#endif // NANOSVGRAST_H

本程序非本人编写！来自公开项目。

/*
 * Copyright (c) 2013-14 Mikko Mononen memon@inside.org
 *
 * 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

#ifndef NANOSVG_CPLUSPLUS
#ifdef __cplusplus
extern "C" {
#endif
#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 NanoSVG 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 SVG
	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 {
	NSVG_PAINT_UNDEF = -1,
	NSVG_PAINT_NONE = 0,
	NSVG_PAINT_COLOR = 1,
	NSVG_PAINT_LINEAR_GRADIENT = 2,
	NSVG_PAINT_RADIAL_GRADIENT = 3
};

enum NSVGspreadType {
	NSVG_SPREAD_PAD = 0,
	NSVG_SPREAD_REFLECT = 1,
	NSVG_SPREAD_REPEAT = 2
};

enum NSVGlineJoin {
	NSVG_JOIN_MITER = 0,
	NSVG_JOIN_ROUND = 1,
	NSVG_JOIN_BEVEL = 2
};

enum NSVGlineCap {
	NSVG_CAP_BUTT = 0,
	NSVG_CAP_ROUND = 1,
	NSVG_CAP_SQUARE = 2
};

enum NSVGfillRule {
	NSVG_FILLRULE_NONZERO = 0,
	NSVG_FILLRULE_EVENODD = 1
};

enum NSVGflags {
	NSVG_FLAGS_VISIBLE = 0x01
};

enum NSVGpaintOrder {
	NSVG_PAINT_FILL = 0x00,
	NSVG_PAINT_MARKERS = 0x01,
	NSVG_PAINT_STROKE = 0x02,
};

typedef struct NSVGgradientStop {
	unsigned int color;
	float offset;
} NSVGgradientStop;

typedef struct NSVGgradient {
	float xform[6];
	char spread;
	float fx, fy;
	int nstops;
	NSVGgradientStop stops[1];
} NSVGgradient;

typedef struct NSVGpaint {
	signed char type;
	union {
		unsigned int color;
		NSVGgradient* gradient;
	};
} NSVGpaint;

typedef struct NSVGpath
{
	float* pts;					// Cubic bezier points: x0,y0, [cpx1,cpx1,cpx2,cpy2,x1,y1], ...
	int npts;					// Total number of bezier points.
	char closed;				// Flag indicating if shapes should be treated as closed.
	float bounds[4];			// Tight bounding box of the shape [minx,miny,maxx,maxy].
	struct NSVGpath* next;		// Pointer to next path, or NULL if last element.
} NSVGpath;

typedef struct NSVGshape
{
	char id[64];				// Optional 'id' attr of the shape or its group
	NSVGpaint fill;				// Fill paint
	NSVGpaint stroke;			// Stroke paint
	float opacity;				// Opacity of the shape.
	float strokeWidth;			// Stroke width (scaled).
	float strokeDashOffset;		// Stroke dash offset (scaled).
	float strokeDashArray[8];	// Stroke dash array (scaled).
	char strokeDashCount;		// Number of dash values in dash array.
	char strokeLineJoin;		// Stroke join type.
	char strokeLineCap;			// Stroke cap type.
	float miterLimit;			// Miter limit
	char fillRule;				// Fill rule, see NSVGfillRule.
    unsigned char paintOrder;	// Encoded paint order (3脳2-bit fields) see NSVGpaintOrder
	unsigned char flags;		// Logical or of NSVG_FLAGS_* flags
	float bounds[4];			// Tight bounding box of the shape [minx,miny,maxx,maxy].
	char fillGradient[64];		// Optional 'id' of fill gradient
	char strokeGradient[64];	// Optional 'id' of stroke gradient
	float xform[6];				// Root transformation for fill/stroke gradient
	NSVGpath* paths;			// Linked list of paths in the image.
	struct NSVGshape* next;		// Pointer to next shape, or NULL if last element.
} NSVGshape;

typedef struct NSVGimage
{
	float width;				// Width of the image.
	float height;				// Height of the image.
	NSVGshape* shapes;			// Linked list of shapes in the image.
} 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);

// Duplicates a path.
NSVGpath* nsvgDuplicatePath(NSVGpath* p);

// Deletes an image.
void nsvgDelete(NSVGimage* image);

#ifndef NANOSVG_CPLUSPLUS
#ifdef __cplusplus
}
#endif
#endif

#ifdef NANOSVG_IMPLEMENTATION

#include <string.h>
#include <stdlib.h>
#include <stdio.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 c >= '0' && c <= '9';
}

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) {
		char* name = NULL;
		char* value = NULL;

		// Skip white space before the attrib name
		while (*s && nsvg__isspace(*s)) s++;
		if (!*s) break;
		if (*s == '/') {
			end = 1;
			break;
		}
		name = 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.
		value = s;
		while (*s && *s != quote) s++;
		if (*s) { *s++ = '\0'; }

		// Store only well formed attributes
		if (name && value) {
			attr[nattr++] = name;
			attr[nattr++] = value;
		}
	}

	// 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 (*startelCb)(void* ud, const char* el, const char** attr),
				   void (*endelCb)(void* ud, const char* el),
				   void (*contentCb)(void* ud, const char* s),
				   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 {
	NSVG_UNITS_USER,
	NSVG_UNITS_PX,
	NSVG_UNITS_PT,
	NSVG_UNITS_PC,
	NSVG_UNITS_MM,
	NSVG_UNITS_CM,
	NSVG_UNITS_IN,
	NSVG_UNITS_PERCENT,
	NSVG_UNITS_EM,
	NSVG_UNITS_EX
};

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
{
	char id[64];
	char ref[64];
	signed char type;
	union {
		NSVGlinearData linear;
		NSVGradialData radial;
	};
	char spread;
	char units;
	float xform[6];
	int nstops;
	NSVGgradientStop* stops;
	struct NSVGgradientData* next;
} NSVGgradientData;

typedef struct NSVGattrib
{
	char id[64];
	float xform[6];
	unsigned int fillColor;
	unsigned int strokeColor;
	float opacity;
	float fillOpacity;
	float strokeOpacity;
	char fillGradient[64];
	char strokeGradient[64];
	float strokeWidth;
	float strokeDashOffset;
	float strokeDashArray[NSVG_MAX_DASHES];
	int strokeDashCount;
	char strokeLineJoin;
	char strokeLineCap;
	float miterLimit;
	char fillRule;
	float fontSize;
	unsigned int stopColor;
	float stopOpacity;
	float stopOffset;
	char hasFill;
	char hasStroke;
	char visible;
    unsigned char paintOrder;
} NSVGattrib;

typedef struct NSVGparser
{
	NSVGattrib attr[NSVG_MAX_ATTR];
	int attrHead;
	float* pts;
	int npts;
	int cpts;
	NSVGpath* plist;
	NSVGimage* image;
	NSVGgradientData* gradients;
	NSVGshape* shapesTail;
	float viewMinx, viewMiny, viewWidth, viewHeight;
	int alignX, alignY, alignType;
	float dpi;
	char pathFlag;
	char defsFlag;
} 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 unsigned char nsvg__encodePaintOrder(enum NSVGpaintOrder a, enum NSVGpaintOrder b, enum NSVGpaintOrder c) {
    return (a & 0x03) | ((b & 0x03) << 2) | ((c & 0x03) << 4);
}

static NSVGparser* nsvg__createParser(void)
{
	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].miterLimit = 4;
	p->attr[0].fillRule = NSVG_FILLRULE_NONZERO;
	p->attr[0].hasFill = 1;
	p->attr[0].visible = 1;
    p->attr[0].paintOrder = nsvg__encodePaintOrder(NSVG_PAINT_FILL, NSVG_PAINT_STROKE, NSVG_PAINT_MARKERS);

	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)
{
	if (p->npts > 0) {
		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;
	if (id == NULL || *id == '\0')
		return NULL;
	while (grad != NULL) {
		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, float *xform, signed char* paintType)
{
	NSVGgradientData* data = NULL;
	NSVGgradientData* ref = NULL;
	NSVGgradientStop* stops = NULL;
	NSVGgradient* grad;
	float ox, oy, sw, sh, sl;
	int nstops = 0;
	int refIter;

	data = nsvg__findGradientData(p, id);
	if (data == NULL) return NULL;

	// TODO: use ref to fill in all unset values too.
	ref = data;
	refIter = 0;
	while (ref != NULL) {
		NSVGgradientData* nextRef = NULL;
		if (stops == NULL && ref->stops != NULL) {
			stops = ref->stops;
			nstops = ref->nstops;
			break;
		}
		nextRef = nsvg__findGradientData(p, ref->ref);
		if (nextRef == ref) break; // prevent infite loops on malformed data
		ref = nextRef;
		refIter++;
		if (refIter > 32) break; // prevent infite loops on malformed data
	}
	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, 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;
	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);
	memcpy(shape->fillGradient, attr->fillGradient, sizeof shape->fillGradient);
	memcpy(shape->strokeGradient, attr->strokeGradient, sizeof shape->strokeGradient);
	memcpy(shape->xform, attr->xform, sizeof shape->xform);
	scale = nsvg__getAverageScale(attr->xform);
	shape->strokeWidth = attr->strokeWidth * scale;
	shape->strokeDashOffset = attr->strokeDashOffset * scale;
	shape->strokeDashCount = (char)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->miterLimit = attr->miterLimit;
	shape->fillRule = attr->fillRule;
	shape->opacity = attr->opacity;
    shape->paintOrder = attr->paintOrder;

	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) {
		shape->fill.type = NSVG_PAINT_UNDEF;
	}

	// 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) {
		shape->stroke.type = NSVG_PAINT_UNDEF;
	}

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

	// Add to tail
	if (p->image->shapes == NULL)
		p->image->shapes = shape;
	else
		p->shapesTail->next = shape;
	p->shapesTail = shape;

	return;

error:
	if (shape) free(shape);
}

static void nsvg__addPath(NSVGparser* p, char closed)
{
	NSVGattrib* attr = nsvg__getAttr(p);
	NSVGpath* path = NULL;
	float bounds[4];
	float* curve;
	int i;

	if (p->npts < 4)
		return;

	if (closed)
		nsvg__lineTo(p, p->pts[0], p->pts[1]);

	// Expect 1 + N*3 points (N = number of cubic bezier segments).
	if ((p->npts % 3) != 1)
		return;

	path = (NSVGpath*)malloc(sizeof(NSVGpath));
	if (path == NULL) goto error;
	memset(path, 0, sizeof(NSVGpath));

	path->pts = (float*)malloc(p->npts*2*sizeof(float));
	if (path->pts == NULL) goto error;
	path->closed = closed;
	path->npts = p->npts;

	// Transform path.
	for (i = 0; i < p->npts; ++i)
		nsvg__xformPoint(&path->pts[i*2], &path->pts[i*2+1], p->pts[i*2], p->pts[i*2+1], attr->xform);

	// Find bounds
	for (i = 0; i < path->npts-1; i += 3) {
		curve = &path->pts[i*2];
		nsvg__curveBounds(bounds, curve);
		if (i == 0) {
			path->bounds[0] = bounds[0];
			path->bounds[1] = bounds[1];
			path->bounds[2] = bounds[2];
			path->bounds[3] = bounds[3];
		} else {
			path->bounds[0] = nsvg__minf(path->bounds[0], bounds[0]);
			path->bounds[1] = nsvg__minf(path->bounds[1], bounds[1]);
			path->bounds[2] = nsvg__maxf(path->bounds[2], bounds[2]);
			path->bounds[3] = nsvg__maxf(path->bounds[3], bounds[3]);
		}
	}

	path->next = p->plist;
	p->plist = path;

	return;

error:
	if (path != NULL) {
		if (path->pts != NULL) free(path->pts);
		free(path);
	}
}

// We roll our own string to float because the std library one uses locale and messes things up.
static double nsvg__atof(const char* s)
{
	char* cur = (char*)s;
	char* end = NULL;
	double res = 0.0, sign = 1.0;
	long long intPart = 0, fracPart = 0;
	char hasIntPart = 0, hasFracPart = 0;

	// Parse optional sign
	if (*cur == '+') {
		cur++;
	} else if (*cur == '-') {
		sign = -1;
		cur++;
	}

	// Parse integer part
	if (nsvg__isdigit(*cur)) {
		// Parse digit sequence
		intPart = strtoll(cur, &end, 10);
		if (cur != end) {
			res = (double)intPart;
			hasIntPart = 1;
			cur = end;
		}
	}

	// Parse fractional part.
	if (*cur == '.') {
		cur++; // Skip '.'
		if (nsvg__isdigit(*cur)) {
			// Parse digit sequence
			fracPart = strtoll(cur, &end, 10);
			if (cur != end) {
				res += (double)fracPart / pow(10.0, (double)(end - cur));
				hasFracPart = 1;
				cur = end;
			}
		}
	}

	// A valid number should have integer or fractional part.
	if (!hasIntPart && !hasFracPart)
		return 0.0;

	// Parse optional exponent
	if (*cur == 'e' || *cur == 'E') {
		long expPart = 0;
		cur++; // skip 'E'
		expPart = strtol(cur, &end, 10); // Parse digit sequence with sign
		if (cur != end) {
			res *= pow(10.0, (double)expPart);
		}
	}

	return res * sign;
}


static const char* nsvg__parseNumber(const char* s, char* it, const int size)
{
	const int last = size-1;
	int i = 0;

	// sign
	if (*s == '-' || *s == '+') {
		if (i < last) it[i++] = *s;
		s++;
	}
	// integer part
	while (*s && nsvg__isdigit(*s)) {
		if (i < last) it[i++] = *s;
		s++;
	}
	if (*s == '.') {
		// decimal point
		if (i < last) it[i++] = *s;
		s++;
		// fraction part
		while (*s && nsvg__isdigit(*s)) {
			if (i < last) it[i++] = *s;
			s++;
		}
	}
	// exponent
	if ((*s == 'e' || *s == 'E') && (s[1] != 'm' && s[1] != 'x')) {
		if (i < last) it[i++] = *s;
		s++;
		if (*s == '-' || *s == '+') {
			if (i < last) it[i++] = *s;
			s++;
		}
		while (*s && nsvg__isdigit(*s)) {
			if (i < last) it[i++] = *s;
			s++;
		}
	}
	it[i] = '\0';

	return s;
}

static const char* nsvg__getNextPathItemWhenArcFlag(const char* s, char* it)
{
	it[0] = '\0';
	while (*s && (nsvg__isspace(*s) || *s == ',')) s++;
	if (!*s) return s;
	if (*s == '0' || *s == '1') {
		it[0] = *s++;
		it[1] = '\0';
		return s;
	}
	return s;
}

static const char* nsvg__getNextPathItem(const char* s, char* it)
{
	it[0] = '\0';
	// Skip white spaces and commas
	while (*s && (nsvg__isspace(*s) || *s == ',')) s++;
	if (!*s) return s;
	if (*s == '-' || *s == '+' || *s == '.' || nsvg__isdigit(*s)) {
		s = nsvg__parseNumber(s, it, 64);
	} else {
		// Parse command
		it[0] = *s++;
		it[1] = '\0';
		return s;
	}

	return s;
}

static unsigned int nsvg__parseColorHex(const char* str)
{
	unsigned int r=0, g=0, b=0;
	if (sscanf(str, "#%2x%2x%2x", &r, &g, &b) == 3 )		// 2 digit hex
		return NSVG_RGB(r, g, b);
	if (sscanf(str, "#%1x%1x%1x", &r, &g, &b) == 3 )		// 1 digit hex, e.g. #abc -> 0xccbbaa
		return NSVG_RGB(r*17, g*17, b*17);			// same effect as (r<<4|r), (g<<4|g), ..
	return NSVG_RGB(128, 128, 128);
}

// Parse rgb color. The pointer 'str' must point at "rgb(" (4+ characters).
// This function returns gray (rgb(128, 128, 128) == '#808080') on parse errors
// for backwards compatibility. Note: other image viewers return black instead.

static unsigned int nsvg__parseColorRGB(const char* str)
{
	int i;
	unsigned int rgbi[3];
	float rgbf[3];
	// try decimal integers first
	if (sscanf(str, "rgb(%u, %u, %u)", &rgbi[0], &rgbi[1], &rgbi[2]) != 3) {
		// integers failed, try percent values (float, locale independent)
		const char delimiter[3] = {',', ',', ')'};
		str += 4; // skip "rgb("
		for (i = 0; i < 3; i++) {
			while (*str && (nsvg__isspace(*str))) str++; 	// skip leading spaces
			if (*str == '+') str++;				// skip '+' (don't allow '-')
			if (!*str) break;
			rgbf[i] = nsvg__atof(str);

			// Note 1: it would be great if nsvg__atof() returned how many
			// bytes it consumed but it doesn't. We need to skip the number,
			// the '%' character, spaces, and the delimiter ',' or ')'.

			// Note 2: The following code does not allow values like "33.%",
			// i.e. a decimal point w/o fractional part, but this is consistent
			// with other image viewers, e.g. firefox, chrome, eog, gimp.

			while (*str && nsvg__isdigit(*str)) str++;		// skip integer part
			if (*str == '.') {
				str++;
				if (!nsvg__isdigit(*str)) break;		// error: no digit after '.'
				while (*str && nsvg__isdigit(*str)) str++;	// skip fractional part
			}
			if (*str == '%') str++; else break;
			while (*str && nsvg__isspace(*str)) str++;
			if (*str == delimiter[i]) str++;
			else break;
		}
		if (i == 3) {
			rgbi[0] = roundf(rgbf[0] * 2.55f);
			rgbi[1] = roundf(rgbf[1] * 2.55f);
			rgbi[2] = roundf(rgbf[2] * 2.55f);
		} else {
			rgbi[0] = rgbi[1] = rgbi[2] = 128;
		}
	}
	// clip values as the CSS spec requires
	for (i = 0; i < 3; i++) {
		if (rgbi[i] > 255) rgbi[i] = 255;
	}
	return NSVG_RGB(rgbi[0], rgbi[1], rgbi[2]);
}

typedef struct NSVGNamedColor {
	const char* name;
	unsigned int color;
} NSVGNamedColor;

NSVGNamedColor nsvg__colors[] = {

	{ "red", NSVG_RGB(255, 0, 0) },
	{ "green", NSVG_RGB( 0, 128, 0) },
	{ "blue", NSVG_RGB( 0, 0, 255) },
	{ "yellow", NSVG_RGB(255, 255, 0) },
	{ "cyan", NSVG_RGB( 0, 255, 255) },
	{ "magenta", NSVG_RGB(255, 0, 255) },
	{ "black", NSVG_RGB( 0, 0, 0) },
	{ "grey", NSVG_RGB(128, 128, 128) },
	{ "gray", NSVG_RGB(128, 128, 128) },
	{ "white", NSVG_RGB(255, 255, 255) },

#ifdef NANOSVG_ALL_COLOR_KEYWORDS
	{ "aliceblue", NSVG_RGB(240, 248, 255) },
	{ "antiquewhite", NSVG_RGB(250, 235, 215) },
	{ "aqua", NSVG_RGB( 0, 255, 255) },
	{ "aquamarine", NSVG_RGB(127, 255, 212) },
	{ "azure", NSVG_RGB(240, 255, 255) },
	{ "beige", NSVG_RGB(245, 245, 220) },
	{ "bisque", NSVG_RGB(255, 228, 196) },
	{ "blanchedalmond", NSVG_RGB(255, 235, 205) },
	{ "blueviolet", NSVG_RGB(138, 43, 226) },
	{ "brown", NSVG_RGB(165, 42, 42) },
	{ "burlywood", NSVG_RGB(222, 184, 135) },
	{ "cadetblue", NSVG_RGB( 95, 158, 160) },
	{ "chartreuse", NSVG_RGB(127, 255, 0) },
	{ "chocolate", NSVG_RGB(210, 105, 30) },
	{ "coral", NSVG_RGB(255, 127, 80) },
	{ "cornflowerblue", NSVG_RGB(100, 149, 237) },
	{ "cornsilk", NSVG_RGB(255, 248, 220) },
	{ "crimson", NSVG_RGB(220, 20, 60) },
	{ "darkblue", NSVG_RGB( 0, 0, 139) },
	{ "darkcyan", NSVG_RGB( 0, 139, 139) },
	{ "darkgoldenrod", NSVG_RGB(184, 134, 11) },
	{ "darkgray", NSVG_RGB(169, 169, 169) },
	{ "darkgreen", NSVG_RGB( 0, 100, 0) },
	{ "darkgrey", NSVG_RGB(169, 169, 169) },
	{ "darkkhaki", NSVG_RGB(189, 183, 107) },
	{ "darkmagenta", NSVG_RGB(139, 0, 139) },
	{ "darkolivegreen", NSVG_RGB( 85, 107, 47) },
	{ "darkorange", NSVG_RGB(255, 140, 0) },
	{ "darkorchid", NSVG_RGB(153, 50, 204) },
	{ "darkred", NSVG_RGB(139, 0, 0) },
	{ "darksalmon", NSVG_RGB(233, 150, 122) },
	{ "darkseagreen", NSVG_RGB(143, 188, 143) },
	{ "darkslateblue", NSVG_RGB( 72, 61, 139) },
	{ "darkslategray", NSVG_RGB( 47, 79, 79) },
	{ "darkslategrey", NSVG_RGB( 47, 79, 79) },
	{ "darkturquoise", NSVG_RGB( 0, 206, 209) },
	{ "darkviolet", NSVG_RGB(148, 0, 211) },
	{ "deeppink", NSVG_RGB(255, 20, 147) },
	{ "deepskyblue", NSVG_RGB( 0, 191, 255) },
	{ "dimgray", NSVG_RGB(105, 105, 105) },
	{ "dimgrey", NSVG_RGB(105, 105, 105) },
	{ "dodgerblue", NSVG_RGB( 30, 144, 255) },
	{ "firebrick", NSVG_RGB(178, 34, 34) },
	{ "floralwhite", NSVG_RGB(255, 250, 240) },
	{ "forestgreen", NSVG_RGB( 34, 139, 34) },
	{ "fuchsia", NSVG_RGB(255, 0, 255) },
	{ "gainsboro", NSVG_RGB(220, 220, 220) },
	{ "ghostwhite", NSVG_RGB(248, 248, 255) },
	{ "gold", NSVG_RGB(255, 215, 0) },
	{ "goldenrod", NSVG_RGB(218, 165, 32) },
	{ "greenyellow", NSVG_RGB(173, 255, 47) },
	{ "honeydew", NSVG_RGB(240, 255, 240) },
	{ "hotpink", NSVG_RGB(255, 105, 180) },
	{ "indianred", NSVG_RGB(205, 92, 92) },
	{ "indigo", NSVG_RGB( 75, 0, 130) },
	{ "ivory", NSVG_RGB(255, 255, 240) },
	{ "khaki", NSVG_RGB(240, 230, 140) },
	{ "lavender", NSVG_RGB(230, 230, 250) },
	{ "lavenderblush", NSVG_RGB(255, 240, 245) },
	{ "lawngreen", NSVG_RGB(124, 252, 0) },
	{ "lemonchiffon", NSVG_RGB(255, 250, 205) },
	{ "lightblue", NSVG_RGB(173, 216, 230) },
	{ "lightcoral", NSVG_RGB(240, 128, 128) },
	{ "lightcyan", NSVG_RGB(224, 255, 255) },
	{ "lightgoldenrodyellow", NSVG_RGB(250, 250, 210) },
	{ "lightgray", NSVG_RGB(211, 211, 211) },
	{ "lightgreen", NSVG_RGB(144, 238, 144) },
	{ "lightgrey", NSVG_RGB(211, 211, 211) },
	{ "lightpink", NSVG_RGB(255, 182, 193) },
	{ "lightsalmon", NSVG_RGB(255, 160, 122) },
	{ "lightseagreen", NSVG_RGB( 32, 178, 170) },
	{ "lightskyblue", NSVG_RGB(135, 206, 250) },
	{ "lightslategray", NSVG_RGB(119, 136, 153) },
	{ "lightslategrey", NSVG_RGB(119, 136, 153) },
	{ "lightsteelblue", NSVG_RGB(176, 196, 222) },
	{ "lightyellow", NSVG_RGB(255, 255, 224) },
	{ "lime", NSVG_RGB( 0, 255, 0) },
	{ "limegreen", NSVG_RGB( 50, 205, 50) },
	{ "linen", NSVG_RGB(250, 240, 230) },
	{ "maroon", NSVG_RGB(128, 0, 0) },
	{ "mediumaquamarine", NSVG_RGB(102, 205, 170) },
	{ "mediumblue", NSVG_RGB( 0, 0, 205) },
	{ "mediumorchid", NSVG_RGB(186, 85, 211) },
	{ "mediumpurple", NSVG_RGB(147, 112, 219) },
	{ "mediumseagreen", NSVG_RGB( 60, 179, 113) },
	{ "mediumslateblue", NSVG_RGB(123, 104, 238) },
	{ "mediumspringgreen", NSVG_RGB( 0, 250, 154) },
	{ "mediumturquoise", NSVG_RGB( 72, 209, 204) },
	{ "mediumvioletred", NSVG_RGB(199, 21, 133) },
	{ "midnightblue", NSVG_RGB( 25, 25, 112) },
	{ "mintcream", NSVG_RGB(245, 255, 250) },
	{ "mistyrose", NSVG_RGB(255, 228, 225) },
	{ "moccasin", NSVG_RGB(255, 228, 181) },
	{ "navajowhite", NSVG_RGB(255, 222, 173) },
	{ "navy", NSVG_RGB( 0, 0, 128) },
	{ "oldlace", NSVG_RGB(253, 245, 230) },
	{ "olive", NSVG_RGB(128, 128, 0) },
	{ "olivedrab", NSVG_RGB(107, 142, 35) },
	{ "orange", NSVG_RGB(255, 165, 0) },
	{ "orangered", NSVG_RGB(255, 69, 0) },
	{ "orchid", NSVG_RGB(218, 112, 214) },
	{ "palegoldenrod", NSVG_RGB(238, 232, 170) },
	{ "palegreen", NSVG_RGB(152, 251, 152) },
	{ "paleturquoise", NSVG_RGB(175, 238, 238) },
	{ "palevioletred", NSVG_RGB(219, 112, 147) },
	{ "papayawhip", NSVG_RGB(255, 239, 213) },
	{ "peachpuff", NSVG_RGB(255, 218, 185) },
	{ "peru", NSVG_RGB(205, 133, 63) },
	{ "pink", NSVG_RGB(255, 192, 203) },
	{ "plum", NSVG_RGB(221, 160, 221) },
	{ "powderblue", NSVG_RGB(176, 224, 230) },
	{ "purple", NSVG_RGB(128, 0, 128) },
	{ "rosybrown", NSVG_RGB(188, 143, 143) },
	{ "royalblue", NSVG_RGB( 65, 105, 225) },
	{ "saddlebrown", NSVG_RGB(139, 69, 19) },
	{ "salmon", NSVG_RGB(250, 128, 114) },
	{ "sandybrown", NSVG_RGB(244, 164, 96) },
	{ "seagreen", NSVG_RGB( 46, 139, 87) },
	{ "seashell", NSVG_RGB(255, 245, 238) },
	{ "sienna", NSVG_RGB(160, 82, 45) },
	{ "silver", NSVG_RGB(192, 192, 192) },
	{ "skyblue", NSVG_RGB(135, 206, 235) },
	{ "slateblue", NSVG_RGB(106, 90, 205) },
	{ "slategray", NSVG_RGB(112, 128, 144) },
	{ "slategrey", NSVG_RGB(112, 128, 144) },
	{ "snow", NSVG_RGB(255, 250, 250) },
	{ "springgreen", NSVG_RGB( 0, 255, 127) },
	{ "steelblue", NSVG_RGB( 70, 130, 180) },
	{ "tan", NSVG_RGB(210, 180, 140) },
	{ "teal", NSVG_RGB( 0, 128, 128) },
	{ "thistle", NSVG_RGB(216, 191, 216) },
	{ "tomato", NSVG_RGB(255, 99, 71) },
	{ "turquoise", NSVG_RGB( 64, 224, 208) },
	{ "violet", NSVG_RGB(238, 130, 238) },
	{ "wheat", NSVG_RGB(245, 222, 179) },
	{ "whitesmoke", NSVG_RGB(245, 245, 245) },
	{ "yellowgreen", NSVG_RGB(154, 205, 50) },
#endif
};

static unsigned int nsvg__parseColorName(const char* str)
{
	int i, ncolors = sizeof(nsvg__colors) / sizeof(NSVGNamedColor);

	for (i = 0; i < ncolors; i++) {
		if (strcmp(nsvg__colors[i].name, str) == 0) {
			return nsvg__colors[i].color;
		}
	}

	return NSVG_RGB(128, 128, 128);
}

static unsigned int nsvg__parseColor(const char* str)
{
	size_t len = 0;
	while(*str == ' ') ++str;
	len = strlen(str);
	if (len >= 1 && *str == '#')
		return nsvg__parseColorHex(str);
	else if (len >= 4 && str[0] == 'r' && str[1] == 'g' && str[2] == 'b' && str[3] == '(')
		return nsvg__parseColorRGB(str);
	return nsvg__parseColorName(str);
}

static float nsvg__parseOpacity(const char* str)
{
	float val = nsvg__atof(str);
	if (val < 0.0f) val = 0.0f;
	if (val > 1.0f) val = 1.0f;
	return val;
}

static float nsvg__parseMiterLimit(const char* str)
{
	float val = nsvg__atof(str);
	if (val < 0.0f) val = 0.0f;
	return val;
}

static int nsvg__parseUnits(const char* units)
{
	if (units[0] == 'p' && units[1] == 'x')
		return NSVG_UNITS_PX;
	else if (units[0] == 'p' && units[1] == 't')
		return NSVG_UNITS_PT;
	else if (units[0] == 'p' && units[1] == 'c')
		return NSVG_UNITS_PC;
	else if (units[0] == 'm' && units[1] == 'm')
		return NSVG_UNITS_MM;
	else if (units[0] == 'c' && units[1] == 'm')
		return NSVG_UNITS_CM;
	else if (units[0] == 'i' && units[1] == 'n')
		return NSVG_UNITS_IN;
	else if (units[0] == '%')
		return NSVG_UNITS_PERCENT;
	else if (units[0] == 'e' && units[1] == 'm')
		return NSVG_UNITS_EM;
	else if (units[0] == 'e' && units[1] == 'x')
		return NSVG_UNITS_EX;
	return NSVG_UNITS_USER;
}

static int nsvg__isCoordinate(const char* s)
{
	// optional sign
	if (*s == '-' || *s == '+')
		s++;
	// must have at least one digit, or start by a dot
	return (nsvg__isdigit(*s) || *s == '.');
}

static NSVGcoordinate nsvg__parseCoordinateRaw(const char* str)
{
	NSVGcoordinate coord = {0, NSVG_UNITS_USER};
	char buf[64];
	coord.units = nsvg__parseUnits(nsvg__parseNumber(str, buf, 64));
	coord.value = nsvg__atof(buf);
	return coord;
}

static NSVGcoordinate nsvg__coord(float v, int units)
{
	NSVGcoordinate coord = {v, units};
	return coord;
}

static float nsvg__parseCoordinate(NSVGparser* p, const char* str, float orig, float length)
{
	NSVGcoordinate coord = nsvg__parseCoordinateRaw(str);
	return nsvg__convertToPixels(p, coord, orig, length);
}

static int nsvg__parseTransformArgs(const char* str, float* args, int maxNa, int* na)
{
	const char* end;
	const char* ptr;
	char it[64];

	*na = 0;
	ptr = str;
	while (*ptr && *ptr != '(') ++ptr;
	if (*ptr == 0)
		return 1;
	end = ptr;
	while (*end && *end != ')') ++end;
	if (*end == 0)
		return 1;

	while (ptr < end) {
		if (*ptr == '-' || *ptr == '+' || *ptr == '.' || nsvg__isdigit(*ptr)) {
			if (*na >= maxNa) return 0;
			ptr = nsvg__parseNumber(ptr, it, 64);
			args[(*na)++] = (float)nsvg__atof(it);
		} else {
			++ptr;
		}
	}
	return (int)(end - str);
}


static int nsvg__parseMatrix(float* xform, const char* str)
{
	float t[6];
	int na = 0;
	int len = nsvg__parseTransformArgs(str, t, 6, &na);
	if (na != 6) return len;
	memcpy(xform, t, sizeof(float)*6);
	return len;
}

static int nsvg__parseTranslate(float* xform, const char* str)
{
	float args[2];
	float t[6];
	int na = 0;
	int len = nsvg__parseTransformArgs(str, args, 2, &na);
	if (na == 1) args[1] = 0.0;

	nsvg__xformSetTranslation(t, args[0], args[1]);
	memcpy(xform, t, sizeof(float)*6);
	return len;
}

static int nsvg__parseScale(float* xform, const char* str)
{
	float args[2];
	int na = 0;
	float t[6];
	int len = nsvg__parseTransformArgs(str, args, 2, &na);
	if (na == 1) args[1] = args[0];
	nsvg__xformSetScale(t, args[0], args[1]);
	memcpy(xform, t, sizeof(float)*6);
	return len;
}

static int nsvg__parseSkewX(float* xform, const char* str)
{
	float args[1];
	int na = 0;
	float t[6];
	int len = nsvg__parseTransformArgs(str, args, 1, &na);
	nsvg__xformSetSkewX(t, args[0]/180.0f*NSVG_PI);
	memcpy(xform, t, sizeof(float)*6);
	return len;
}

static int nsvg__parseSkewY(float* xform, const char* str)
{
	float args[1];
	int na = 0;
	float t[6];
	int len = nsvg__parseTransformArgs(str, args, 1, &na);
	nsvg__xformSetSkewY(t, args[0]/180.0f*NSVG_PI);
	memcpy(xform, t, sizeof(float)*6);
	return len;
}

static int nsvg__parseRotate(float* xform, const char* str)
{
	float args[3];
	int na = 0;
	float m[6];
	float t[6];
	int len = nsvg__parseTransformArgs(str, args, 3, &na);
	if (na == 1)
		args[1] = args[2] = 0.0f;
	nsvg__xformIdentity(m);

	if (na > 1) {
		nsvg__xformSetTranslation(t, -args[1], -args[2]);
		nsvg__xformMultiply(m, t);
	}

	nsvg__xformSetRotation(t, args[0]/180.0f*NSVG_PI);
	nsvg__xformMultiply(m, t);

	if (na > 1) {
		nsvg__xformSetTranslation(t, args[1], args[2]);
		nsvg__xformMultiply(m, t);
	}

	memcpy(xform, m, sizeof(float)*6);

	return len;
}

static void nsvg__parseTransform(float* xform, const char* str)
{
	float t[6];
	int len;
	nsvg__xformIdentity(xform);
	while (*str)
	{
		if (strncmp(str, "matrix", 6) == 0)
			len = nsvg__parseMatrix(t, str);
		else if (strncmp(str, "translate", 9) == 0)
			len = nsvg__parseTranslate(t, str);
		else if (strncmp(str, "scale", 5) == 0)
			len = nsvg__parseScale(t, str);
		else if (strncmp(str, "rotate", 6) == 0)
			len = nsvg__parseRotate(t, str);
		else if (strncmp(str, "skewX", 5) == 0)
			len = nsvg__parseSkewX(t, str);
		else if (strncmp(str, "skewY", 5) == 0)
			len = nsvg__parseSkewY(t, str);
		else{
			++str;
			continue;
		}
		if (len != 0) {
			str += len;
		} else {
			++str;
			continue;
		}

		nsvg__xformPremultiply(xform, t);
	}
}

static void nsvg__parseUrl(char* id, const char* str)
{
	int i = 0;
	str += 4; // "url(";
	if (*str && *str == '#')
		str++;
	while (i < 63 && *str && *str != ')') {
		id[i] = *str++;
		i++;
	}
	id[i] = '\0';
}

static char nsvg__parseLineCap(const char* str)
{
	if (strcmp(str, "butt") == 0)
		return NSVG_CAP_BUTT;
	else if (strcmp(str, "round") == 0)
		return NSVG_CAP_ROUND;
	else if (strcmp(str, "square") == 0)
		return NSVG_CAP_SQUARE;
	// TODO: handle inherit.
	return NSVG_CAP_BUTT;
}

static char nsvg__parseLineJoin(const char* str)
{
	if (strcmp(str, "miter") == 0)
		return NSVG_JOIN_MITER;
	else if (strcmp(str, "round") == 0)
		return NSVG_JOIN_ROUND;
	else if (strcmp(str, "bevel") == 0)
		return NSVG_JOIN_BEVEL;
	// TODO: handle inherit.
	return NSVG_JOIN_MITER;
}

static char nsvg__parseFillRule(const char* str)
{
	if (strcmp(str, "nonzero") == 0)
		return NSVG_FILLRULE_NONZERO;
	else if (strcmp(str, "evenodd") == 0)
		return NSVG_FILLRULE_EVENODD;
	// TODO: handle inherit.
	return NSVG_FILLRULE_NONZERO;
}

static unsigned char nsvg__parsePaintOrder(const char* str)
{
	if (strcmp(str, "normal") == 0 || strcmp(str, "fill stroke markers") == 0)
		return nsvg__encodePaintOrder(NSVG_PAINT_FILL, NSVG_PAINT_STROKE, NSVG_PAINT_MARKERS);
	else if (strcmp(str, "fill markers stroke") == 0)
		return nsvg__encodePaintOrder(NSVG_PAINT_FILL, NSVG_PAINT_MARKERS, NSVG_PAINT_STROKE);
	else if (strcmp(str, "markers fill stroke") == 0)
		return nsvg__encodePaintOrder(NSVG_PAINT_MARKERS, NSVG_PAINT_FILL, NSVG_PAINT_STROKE);
	else if (strcmp(str, "markers stroke fill") == 0)
		return nsvg__encodePaintOrder(NSVG_PAINT_MARKERS, NSVG_PAINT_STROKE, NSVG_PAINT_FILL);
	else if (strcmp(str, "stroke fill markers") == 0)
		return nsvg__encodePaintOrder(NSVG_PAINT_STROKE, NSVG_PAINT_FILL, NSVG_PAINT_MARKERS);
	else if (strcmp(str, "stroke markers fill") == 0)
		return nsvg__encodePaintOrder(NSVG_PAINT_STROKE, NSVG_PAINT_MARKERS, NSVG_PAINT_FILL);
	// TODO: handle inherit.
	return nsvg__encodePaintOrder(NSVG_PAINT_FILL, NSVG_PAINT_STROKE, NSVG_PAINT_MARKERS);
}

static const char* nsvg__getNextDashItem(const char* s, char* it)
{
	int n = 0;
	it[0] = '\0';
	// Skip white spaces and commas
	while (*s && (nsvg__isspace(*s) || *s == ',')) s++;
	// Advance until whitespace, comma or end.
	while (*s && (!nsvg__isspace(*s) && *s != ',')) {
		if (n < 63)
			it[n++] = *s;
		s++;
	}
	it[n++] = '\0';
	return s;
}

static int nsvg__parseStrokeDashArray(NSVGparser* p, const char* str, float* strokeDashArray)
{
	char item[64];
	int count = 0, i;
	float sum = 0.0f;

	// Handle "none"
	if (str[0] == 'n')
		return 0;

	// Parse dashes
	while (*str) {
		str = nsvg__getNextDashItem(str, item);
		if (!*item) break;
		if (count < NSVG_MAX_DASHES)
			strokeDashArray[count++] = fabsf(nsvg__parseCoordinate(p, item, 0.0f, nsvg__actualLength(p)));
	}

	for (i = 0; i < count; i++)
		sum += strokeDashArray[i];
	if (sum <= 1e-6f)
		count = 0;

	return count;
}

static void nsvg__parseStyle(NSVGparser* p, const char* str);

static int nsvg__parseAttr(NSVGparser* p, const char* name, const char* value)
{
	float xform[6];
	NSVGattrib* attr = nsvg__getAttr(p);
	if (!attr) return 0;

	if (strcmp(name, "style") == 0) {
		nsvg__parseStyle(p, value);
	} else if (strcmp(name, "display") == 0) {
		if (strcmp(value, "none") == 0)
			attr->visible = 0;
		// Don't reset ->visible on display:inline, one display:none hides the whole subtree

	} else if (strcmp(name, "fill") == 0) {
		if (strcmp(value, "none") == 0) {
			attr->hasFill = 0;
		} else if (strncmp(value, "url(", 4) == 0) {
			attr->hasFill = 2;
			nsvg__parseUrl(attr->fillGradient, value);
		} else {
			attr->hasFill = 1;
			attr->fillColor = nsvg__parseColor(value);
		}
	} else if (strcmp(name, "opacity") == 0) {
		attr->opacity = nsvg__parseOpacity(value);
	} else if (strcmp(name, "fill-opacity") == 0) {
		attr->fillOpacity = nsvg__parseOpacity(value);
	} else if (strcmp(name, "stroke") == 0) {
		if (strcmp(value, "none") == 0) {
			attr->hasStroke = 0;
		} else if (strncmp(value, "url(", 4) == 0) {
			attr->hasStroke = 2;
			nsvg__parseUrl(attr->strokeGradient, value);
		} else {
			attr->hasStroke = 1;
			attr->strokeColor = nsvg__parseColor(value);
		}
	} else if (strcmp(name, "stroke-width") == 0) {
		attr->strokeWidth = nsvg__parseCoordinate(p, value, 0.0f, nsvg__actualLength(p));
	} else if (strcmp(name, "stroke-dasharray") == 0) {
		attr->strokeDashCount = nsvg__parseStrokeDashArray(p, value, attr->strokeDashArray);
	} else if (strcmp(name, "stroke-dashoffset") == 0) {
		attr->strokeDashOffset = nsvg__parseCoordinate(p, value, 0.0f, nsvg__actualLength(p));
	} else if (strcmp(name, "stroke-opacity") == 0) {
		attr->strokeOpacity = nsvg__parseOpacity(value);
	} else if (strcmp(name, "stroke-linecap") == 0) {
		attr->strokeLineCap = nsvg__parseLineCap(value);
	} else if (strcmp(name, "stroke-linejoin") == 0) {
		attr->strokeLineJoin = nsvg__parseLineJoin(value);
	} else if (strcmp(name, "stroke-miterlimit") == 0) {
		attr->miterLimit = nsvg__parseMiterLimit(value);
	} else if (strcmp(name, "fill-rule") == 0) {
		attr->fillRule = nsvg__parseFillRule(value);
	} else if (strcmp(name, "font-size") == 0) {
		attr->fontSize = nsvg__parseCoordinate(p, value, 0.0f, nsvg__actualLength(p));
	} else if (strcmp(name, "transform") == 0) {
		nsvg__parseTransform(xform, value);
		nsvg__xformPremultiply(attr->xform, xform);
	} else if (strcmp(name, "stop-color") == 0) {
		attr->stopColor = nsvg__parseColor(value);
	} else if (strcmp(name, "stop-opacity") == 0) {
		attr->stopOpacity = nsvg__parseOpacity(value);
	} else if (strcmp(name, "offset") == 0) {
		attr->stopOffset = nsvg__parseCoordinate(p, value, 0.0f, 1.0f);
	} else if (strcmp(name, "paint-order") == 0) {
		attr->paintOrder = nsvg__parsePaintOrder(value);
	} else if (strcmp(name, "id") == 0) {
		strncpy(attr->id, value, 63);
		attr->id[63] = '\0';
	} else {
		return 0;
	}
	return 1;
}

static int nsvg__parseNameValue(NSVGparser* p, const char* start, const char* end)
{
	const char* str;
	const char* val;
	char name[512];
	char value[512];
	int n;

	str = start;
	while (str < end && *str != ':') ++str;

	val = str;

	// Right Trim
	while (str > start &&  (*str == ':' || nsvg__isspace(*str))) --str;
	++str;

	n = (int)(str - start);
	if (n > 511) n = 511;
	if (n) memcpy(name, start, n);
	name[n] = 0;

	while (val < end && (*val == ':' || nsvg__isspace(*val))) ++val;

	n = (int)(end - val);
	if (n > 511) n = 511;
	if (n) memcpy(value, val, n);
	value[n] = 0;

	return nsvg__parseAttr(p, name, value);
}

static void nsvg__parseStyle(NSVGparser* p, const char* str)
{
	const char* start;
	const char* end;

	while (*str) {
		// Left Trim
		while(*str && nsvg__isspace(*str)) ++str;
		start = str;
		while(*str && *str != ';') ++str;
		end = str;

		// Right Trim
		while (end > start &&  (*end == ';' || nsvg__isspace(*end))) --end;
		++end;

		nsvg__parseNameValue(p, start, end);
		if (*str) ++str;
	}
}

static void nsvg__parseAttribs(NSVGparser* p, const char** attr)
{
	int i;
	for (i = 0; attr[i]; i += 2)
	{
		if (strcmp(attr[i], "style") == 0)
			nsvg__parseStyle(p, attr[i + 1]);
		else
			nsvg__parseAttr(p, attr[i], attr[i + 1]);
	}
}

static int nsvg__getArgsPerElement(char cmd)
{
	switch (cmd) {
		case 'v':
		case 'V':
		case 'h':
		case 'H':
			return 1;
		case 'm':
		case 'M':
		case 'l':
		case 'L':
		case 't':
		case 'T':
			return 2;
		case 'q':
		case 'Q':
		case 's':
		case 'S':
			return 4;
		case 'c':
		case 'C':
			return 6;
		case 'a':
		case 'A':
			return 7;
		case 'z':
		case 'Z':
			return 0;
	}
	return -1;
}

static void nsvg__pathMoveTo(NSVGparser* p, float* cpx, float* cpy, float* args, int rel)
{
	if (rel) {
		*cpx += args[0];
		*cpy += args[1];
	} else {
		*cpx = args[0];
		*cpy = args[1];
	}
	nsvg__moveTo(p, *cpx, *cpy);
}

static void nsvg__pathLineTo(NSVGparser* p, float* cpx, float* cpy, float* args, int rel)
{
	if (rel) {
		*cpx += args[0];
		*cpy += args[1];
	} else {
		*cpx = args[0];
		*cpy = args[1];
	}
	nsvg__lineTo(p, *cpx, *cpy);
}

static void nsvg__pathHLineTo(NSVGparser* p, float* cpx, float* cpy, float* args, int rel)
{
	if (rel)
		*cpx += args[0];
	else
		*cpx = args[0];
	nsvg__lineTo(p, *cpx, *cpy);
}

static void nsvg__pathVLineTo(NSVGparser* p, float* cpx, float* cpy, float* args, int rel)
{
	if (rel)
		*cpy += args[0];
	else
		*cpy = args[0];
	nsvg__lineTo(p, *cpx, *cpy);
}

static void nsvg__pathCubicBezTo(NSVGparser* p, float* cpx, float* cpy,
								 float* cpx2, float* cpy2, float* args, int rel)
{
	float x2, y2, cx1, cy1, cx2, cy2;

	if (rel) {
		cx1 = *cpx + args[0];
		cy1 = *cpy + args[1];
		cx2 = *cpx + args[2];
		cy2 = *cpy + args[3];
		x2 = *cpx + args[4];
		y2 = *cpy + args[5];
	} else {
		cx1 = args[0];
		cy1 = args[1];
		cx2 = args[2];
		cy2 = args[3];
		x2 = args[4];
		y2 = args[5];
	}

	nsvg__cubicBezTo(p, cx1,cy1, cx2,cy2, x2,y2);

	*cpx2 = cx2;
	*cpy2 = cy2;
	*cpx = x2;
	*cpy = y2;
}

static void nsvg__pathCubicBezShortTo(NSVGparser* p, float* cpx, float* cpy,
									  float* cpx2, float* cpy2, float* args, int rel)
{
	float x1, y1, x2, y2, cx1, cy1, cx2, cy2;

	x1 = *cpx;
	y1 = *cpy;
	if (rel) {
		cx2 = *cpx + args[0];
		cy2 = *cpy + args[1];
		x2 = *cpx + args[2];
		y2 = *cpy + args[3];
	} else {
		cx2 = args[0];
		cy2 = args[1];
		x2 = args[2];
		y2 = args[3];
	}

	cx1 = 2*x1 - *cpx2;
	cy1 = 2*y1 - *cpy2;

	nsvg__cubicBezTo(p, cx1,cy1, cx2,cy2, x2,y2);

	*cpx2 = cx2;
	*cpy2 = cy2;
	*cpx = x2;
	*cpy = y2;
}

static void nsvg__pathQuadBezTo(NSVGparser* p, float* cpx, float* cpy,
								float* cpx2, float* cpy2, float* args, int rel)
{
	float x1, y1, x2, y2, cx, cy;
	float cx1, cy1, cx2, cy2;

	x1 = *cpx;
	y1 = *cpy;
	if (rel) {
		cx = *cpx + args[0];
		cy = *cpy + args[1];
		x2 = *cpx + args[2];
		y2 = *cpy + args[3];
	} else {
		cx = args[0];
		cy = args[1];
		x2 = args[2];
		y2 = args[3];
	}

	// Convert to cubic bezier
	cx1 = x1 + 2.0f/3.0f*(cx - x1);
	cy1 = y1 + 2.0f/3.0f*(cy - y1);
	cx2 = x2 + 2.0f/3.0f*(cx - x2);
	cy2 = y2 + 2.0f/3.0f*(cy - y2);

	nsvg__cubicBezTo(p, cx1,cy1, cx2,cy2, x2,y2);

	*cpx2 = cx;
	*cpy2 = cy;
	*cpx = x2;
	*cpy = y2;
}

static void nsvg__pathQuadBezShortTo(NSVGparser* p, float* cpx, float* cpy,
									 float* cpx2, float* cpy2, float* args, int rel)
{
	float x1, y1, x2, y2, cx, cy;
	float cx1, cy1, cx2, cy2;

	x1 = *cpx;
	y1 = *cpy;
	if (rel) {
		x2 = *cpx + args[0];
		y2 = *cpy + args[1];
	} else {
		x2 = args[0];
		y2 = args[1];
	}

	cx = 2*x1 - *cpx2;
	cy = 2*y1 - *cpy2;

	// Convert to cubix bezier
	cx1 = x1 + 2.0f/3.0f*(cx - x1);
	cy1 = y1 + 2.0f/3.0f*(cy - y1);
	cx2 = x2 + 2.0f/3.0f*(cx - x2);
	cy2 = y2 + 2.0f/3.0f*(cy - y2);

	nsvg__cubicBezTo(p, cx1,cy1, cx2,cy2, x2,y2);

	*cpx2 = cx;
	*cpy2 = cy;
	*cpx = x2;
	*cpy = y2;
}

static float nsvg__sqr(float x) { return x*x; }
static float nsvg__vmag(float x, float y) { return sqrtf(x*x + y*y); }

static float nsvg__vecrat(float ux, float uy, float vx, float vy)
{
	return (ux*vx + uy*vy) / (nsvg__vmag(ux,uy) * nsvg__vmag(vx,vy));
}

static float nsvg__vecang(float ux, float uy, float vx, float vy)
{
	float r = nsvg__vecrat(ux,uy, vx,vy);
	if (r < -1.0f) r = -1.0f;
	if (r > 1.0f) r = 1.0f;
	return ((ux*vy < uy*vx) ? -1.0f : 1.0f) * acosf(r);
}

static void nsvg__pathArcTo(NSVGparser* p, float* cpx, float* cpy, float* args, int rel)
{
	// Ported from canvg (https://code.google.com/p/canvg/)
	float rx, ry, rotx;
	float x1, y1, x2, y2, cx, cy, dx, dy, d;
	float x1p, y1p, cxp, cyp, s, sa, sb;
	float ux, uy, vx, vy, a1, da;
	float x, y, tanx, tany, a, px = 0, py = 0, ptanx = 0, ptany = 0, t[6];
	float sinrx, cosrx;
	int fa, fs;
	int i, ndivs;
	float hda, kappa;

	rx = fabsf(args[0]);				// y radius
	ry = fabsf(args[1]);				// x radius
	rotx = args[2] / 180.0f * NSVG_PI;		// x rotation angle
	fa = fabsf(args[3]) > 1e-6 ? 1 : 0;	// Large arc
	fs = fabsf(args[4]) > 1e-6 ? 1 : 0;	// Sweep direction
	x1 = *cpx;							// start point
	y1 = *cpy;
	if (rel) {							// end point
		x2 = *cpx + args[5];
		y2 = *cpy + args[6];
	} else {
		x2 = args[5];
		y2 = args[6];
	}

	dx = x1 - x2;
	dy = y1 - y2;
	d = sqrtf(dx*dx + dy*dy);
	if (d < 1e-6f || rx < 1e-6f || ry < 1e-6f) {
		// The arc degenerates to a line
		nsvg__lineTo(p, x2, y2);
		*cpx = x2;
		*cpy = y2;
		return;
	}

	sinrx = sinf(rotx);
	cosrx = cosf(rotx);

	// Convert to center point parameterization.
	// http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes
	// 1) Compute x1', y1'
	x1p = cosrx * dx / 2.0f + sinrx * dy / 2.0f;
	y1p = -sinrx * dx / 2.0f + cosrx * dy / 2.0f;
	d = nsvg__sqr(x1p)/nsvg__sqr(rx) + nsvg__sqr(y1p)/nsvg__sqr(ry);
	if (d > 1) {
		d = sqrtf(d);
		rx *= d;
		ry *= d;
	}
	// 2) Compute cx', cy'
	s = 0.0f;
	sa = nsvg__sqr(rx)*nsvg__sqr(ry) - nsvg__sqr(rx)*nsvg__sqr(y1p) - nsvg__sqr(ry)*nsvg__sqr(x1p);
	sb = nsvg__sqr(rx)*nsvg__sqr(y1p) + nsvg__sqr(ry)*nsvg__sqr(x1p);
	if (sa < 0.0f) sa = 0.0f;
	if (sb > 0.0f)
		s = sqrtf(sa / sb);
	if (fa == fs)
		s = -s;
	cxp = s * rx * y1p / ry;
	cyp = s * -ry * x1p / rx;

	// 3) Compute cx,cy from cx',cy'
	cx = (x1 + x2)/2.0f + cosrx*cxp - sinrx*cyp;
	cy = (y1 + y2)/2.0f + sinrx*cxp + cosrx*cyp;

	// 4) Calculate theta1, and delta theta.
	ux = (x1p - cxp) / rx;
	uy = (y1p - cyp) / ry;
	vx = (-x1p - cxp) / rx;
	vy = (-y1p - cyp) / ry;
	a1 = nsvg__vecang(1.0f,0.0f, ux,uy);	// Initial angle
	da = nsvg__vecang(ux,uy, vx,vy);		// Delta angle

//	if (vecrat(ux,uy,vx,vy) <= -1.0f) da = NSVG_PI;
//	if (vecrat(ux,uy,vx,vy) >= 1.0f) da = 0;

	if (fs == 0 && da > 0)
		da -= 2 * NSVG_PI;
	else if (fs == 1 && da < 0)
		da += 2 * NSVG_PI;

	// Approximate the arc using cubic spline segments.
	t[0] = cosrx; t[1] = sinrx;
	t[2] = -sinrx; t[3] = cosrx;
	t[4] = cx; t[5] = cy;

	// Split arc into max 90 degree segments.
	// The loop assumes an iteration per end point (including start and end), this +1.
	ndivs = (int)(fabsf(da) / (NSVG_PI*0.5f) + 1.0f);
	hda = (da / (float)ndivs) / 2.0f;
	// Fix for ticket #179: division by 0: avoid cotangens around 0 (infinite)
	if ((hda < 1e-3f) && (hda > -1e-3f))
		hda *= 0.5f;
	else
		hda = (1.0f - cosf(hda)) / sinf(hda);
	kappa = fabsf(4.0f / 3.0f * hda);
	if (da < 0.0f)
		kappa = -kappa;

	for (i = 0; i <= ndivs; i++) {
		a = a1 + da * ((float)i/(float)ndivs);
		dx = cosf(a);
		dy = sinf(a);
		nsvg__xformPoint(&x, &y, dx*rx, dy*ry, t); // position
		nsvg__xformVec(&tanx, &tany, -dy*rx * kappa, dx*ry * kappa, t); // tangent
		if (i > 0)
			nsvg__cubicBezTo(p, px+ptanx,py+ptany, x-tanx, y-tany, x, y);
		px = x;
		py = y;
		ptanx = tanx;
		ptany = tany;
	}

	*cpx = x2;
	*cpy = y2;
}

static void nsvg__parsePath(NSVGparser* p, const char** attr)
{
	const char* s = NULL;
	char cmd = '\0';
	float args[10];
	int nargs;
	int rargs = 0;
	char initPoint;
	float cpx, cpy, cpx2, cpy2;
	const char* tmp[4];
	char closedFlag;
	int i;
	char item[64];

	for (i = 0; attr[i]; i += 2) {
		if (strcmp(attr[i], "d") == 0) {
			s = attr[i + 1];
		} else {
			tmp[0] = attr[i];
			tmp[1] = attr[i + 1];
			tmp[2] = 0;
			tmp[3] = 0;
			nsvg__parseAttribs(p, tmp);
		}
	}

	if (s) {
		nsvg__resetPath(p);
		cpx = 0; cpy = 0;
		cpx2 = 0; cpy2 = 0;
		initPoint = 0;
		closedFlag = 0;
		nargs = 0;

		while (*s) {
			item[0] = '\0';
			if ((cmd == 'A' || cmd == 'a') && (nargs == 3 || nargs == 4))
				s = nsvg__getNextPathItemWhenArcFlag(s, item);
			if (!*item)
				s = nsvg__getNextPathItem(s, item);
			if (!*item) break;
			if (cmd != '\0' && nsvg__isCoordinate(item)) {
				if (nargs < 10)
					args[nargs++] = (float)nsvg__atof(item);
				if (nargs >= rargs) {
					switch (cmd) {
						case 'm':
						case 'M':
							nsvg__pathMoveTo(p, &cpx, &cpy, args, cmd == 'm' ? 1 : 0);
							// Moveto can be followed by multiple coordinate pairs,
							// which should be treated as linetos.
							cmd = (cmd == 'm') ? 'l' : 'L';
							rargs = nsvg__getArgsPerElement(cmd);
							cpx2 = cpx; cpy2 = cpy;
							initPoint = 1;
							break;
						case 'l':
						case 'L':
							nsvg__pathLineTo(p, &cpx, &cpy, args, cmd == 'l' ? 1 : 0);
							cpx2 = cpx; cpy2 = cpy;
							break;
						case 'H':
						case 'h':
							nsvg__pathHLineTo(p, &cpx, &cpy, args, cmd == 'h' ? 1 : 0);
							cpx2 = cpx; cpy2 = cpy;
							break;
						case 'V':
						case 'v':
							nsvg__pathVLineTo(p, &cpx, &cpy, args, cmd == 'v' ? 1 : 0);
							cpx2 = cpx; cpy2 = cpy;
							break;
						case 'C':
						case 'c':
							nsvg__pathCubicBezTo(p, &cpx, &cpy, &cpx2, &cpy2, args, cmd == 'c' ? 1 : 0);
							break;
						case 'S':
						case 's':
							nsvg__pathCubicBezShortTo(p, &cpx, &cpy, &cpx2, &cpy2, args, cmd == 's' ? 1 : 0);
							break;
						case 'Q':
						case 'q':
							nsvg__pathQuadBezTo(p, &cpx, &cpy, &cpx2, &cpy2, args, cmd == 'q' ? 1 : 0);
							break;
						case 'T':
						case 't':
							nsvg__pathQuadBezShortTo(p, &cpx, &cpy, &cpx2, &cpy2, args, cmd == 't' ? 1 : 0);
							break;
						case 'A':
						case 'a':
							nsvg__pathArcTo(p, &cpx, &cpy, args, cmd == 'a' ? 1 : 0);
							cpx2 = cpx; cpy2 = cpy;
							break;
						default:
							if (nargs >= 2) {
								cpx = args[nargs-2];
								cpy = args[nargs-1];
								cpx2 = cpx; cpy2 = cpy;
							}
							break;
					}
					nargs = 0;
				}
			} else {
				cmd = item[0];
				if (cmd == 'M' || cmd == 'm') {
					// Commit path.
					if (p->npts > 0)
						nsvg__addPath(p, closedFlag);
					// Start new subpath.
					nsvg__resetPath(p);
					closedFlag = 0;
					nargs = 0;
				} else if (initPoint == 0) {
					// Do not allow other commands until initial point has been set (moveTo called once).
					cmd = '\0';
				}
				if (cmd == 'Z' || cmd == 'z') {
					closedFlag = 1;
					// Commit path.
					if (p->npts > 0) {
						// Move current point to first point
						cpx = p->pts[0];
						cpy = p->pts[1];
						cpx2 = cpx; cpy2 = cpy;
						nsvg__addPath(p, closedFlag);
					}
					// Start new subpath.
					nsvg__resetPath(p);
					nsvg__moveTo(p, cpx, cpy);
					closedFlag = 0;
					nargs = 0;
				}
				rargs = nsvg__getArgsPerElement(cmd);
				if (rargs == -1) {
					// Command not recognized
					cmd = '\0';
					rargs = 0;
				}
			}
		}
		// Commit path.
		if (p->npts)
			nsvg__addPath(p, closedFlag);
	}

	nsvg__addShape(p);
}

static void nsvg__parseRect(NSVGparser* p, const char** attr)
{
	float x = 0.0f;
	float y = 0.0f;
	float w = 0.0f;
	float h = 0.0f;
	float rx = -1.0f; // marks not set
	float ry = -1.0f;
	int i;

	for (i = 0; attr[i]; i += 2) {
		if (!nsvg__parseAttr(p, attr[i], attr[i + 1])) {
			if (strcmp(attr[i], "x") == 0) x = nsvg__parseCoordinate(p, attr[i+1], nsvg__actualOrigX(p), nsvg__actualWidth(p));
			if (strcmp(attr[i], "y") == 0) y = nsvg__parseCoordinate(p, attr[i+1], nsvg__actualOrigY(p), nsvg__actualHeight(p));
			if (strcmp(attr[i], "width") == 0) w = nsvg__parseCoordinate(p, attr[i+1], 0.0f, nsvg__actualWidth(p));
			if (strcmp(attr[i], "height") == 0) h = nsvg__parseCoordinate(p, attr[i+1], 0.0f, nsvg__actualHeight(p));
			if (strcmp(attr[i], "rx") == 0) rx = fabsf(nsvg__parseCoordinate(p, attr[i+1], 0.0f, nsvg__actualWidth(p)));
			if (strcmp(attr[i], "ry") == 0) ry = fabsf(nsvg__parseCoordinate(p, attr[i+1], 0.0f, nsvg__actualHeight(p)));
		}
	}

	if (rx < 0.0f && ry > 0.0f) rx = ry;
	if (ry < 0.0f && rx > 0.0f) ry = rx;
	if (rx < 0.0f) rx = 0.0f;
	if (ry < 0.0f) ry = 0.0f;
	if (rx > w/2.0f) rx = w/2.0f;
	if (ry > h/2.0f) ry = h/2.0f;

	if (w != 0.0f && h != 0.0f) {
		nsvg__resetPath(p);

		if (rx < 0.00001f || ry < 0.0001f) {
			nsvg__moveTo(p, x, y);
			nsvg__lineTo(p, x+w, y);
			nsvg__lineTo(p, x+w, y+h);
			nsvg__lineTo(p, x, y+h);
		} else {
			// Rounded rectangle
			nsvg__moveTo(p, x+rx, y);
			nsvg__lineTo(p, x+w-rx, y);
			nsvg__cubicBezTo(p, x+w-rx*(1-NSVG_KAPPA90), y, x+w, y+ry*(1-NSVG_KAPPA90), x+w, y+ry);
			nsvg__lineTo(p, x+w, y+h-ry);
			nsvg__cubicBezTo(p, x+w, y+h-ry*(1-NSVG_KAPPA90), x+w-rx*(1-NSVG_KAPPA90), y+h, x+w-rx, y+h);
			nsvg__lineTo(p, x+rx, y+h);
			nsvg__cubicBezTo(p, x+rx*(1-NSVG_KAPPA90), y+h, x, y+h-ry*(1-NSVG_KAPPA90), x, y+h-ry);
			nsvg__lineTo(p, x, y+ry);
			nsvg__cubicBezTo(p, x, y+ry*(1-NSVG_KAPPA90), x+rx*(1-NSVG_KAPPA90), y, x+rx, y);
		}

		nsvg__addPath(p, 1);

		nsvg__addShape(p);
	}
}

static void nsvg__parseCircle(NSVGparser* p, const char** attr)
{
	float cx = 0.0f;
	float cy = 0.0f;
	float r = 0.0f;
	int i;

	for (i = 0; attr[i]; i += 2) {
		if (!nsvg__parseAttr(p, attr[i], attr[i + 1])) {
			if (strcmp(attr[i], "cx") == 0) cx = nsvg__parseCoordinate(p, attr[i+1], nsvg__actualOrigX(p), nsvg__actualWidth(p));
			if (strcmp(attr[i], "cy") == 0) cy = nsvg__parseCoordinate(p, attr[i+1], nsvg__actualOrigY(p), nsvg__actualHeight(p));
			if (strcmp(attr[i], "r") == 0) r = fabsf(nsvg__parseCoordinate(p, attr[i+1], 0.0f, nsvg__actualLength(p)));
		}
	}

	if (r > 0.0f) {
		nsvg__resetPath(p);

		nsvg__moveTo(p, cx+r, cy);
		nsvg__cubicBezTo(p, cx+r, cy+r*NSVG_KAPPA90, cx+r*NSVG_KAPPA90, cy+r, cx, cy+r);
		nsvg__cubicBezTo(p, cx-r*NSVG_KAPPA90, cy+r, cx-r, cy+r*NSVG_KAPPA90, cx-r, cy);
		nsvg__cubicBezTo(p, cx-r, cy-r*NSVG_KAPPA90, cx-r*NSVG_KAPPA90, cy-r, cx, cy-r);
		nsvg__cubicBezTo(p, cx+r*NSVG_KAPPA90, cy-r, cx+r, cy-r*NSVG_KAPPA90, cx+r, cy);

		nsvg__addPath(p, 1);

		nsvg__addShape(p);
	}
}

static void nsvg__parseEllipse(NSVGparser* p, const char** attr)
{
	float cx = 0.0f;
	float cy = 0.0f;
	float rx = 0.0f;
	float ry = 0.0f;
	int i;

	for (i = 0; attr[i]; i += 2) {
		if (!nsvg__parseAttr(p, attr[i], attr[i + 1])) {
			if (strcmp(attr[i], "cx") == 0) cx = nsvg__parseCoordinate(p, attr[i+1], nsvg__actualOrigX(p), nsvg__actualWidth(p));
			if (strcmp(attr[i], "cy") == 0) cy = nsvg__parseCoordinate(p, attr[i+1], nsvg__actualOrigY(p), nsvg__actualHeight(p));
			if (strcmp(attr[i], "rx") == 0) rx = fabsf(nsvg__parseCoordinate(p, attr[i+1], 0.0f, nsvg__actualWidth(p)));
			if (strcmp(attr[i], "ry") == 0) ry = fabsf(nsvg__parseCoordinate(p, attr[i+1], 0.0f, nsvg__actualHeight(p)));
		}
	}

	if (rx > 0.0f && ry > 0.0f) {

		nsvg__resetPath(p);

		nsvg__moveTo(p, cx+rx, cy);
		nsvg__cubicBezTo(p, cx+rx, cy+ry*NSVG_KAPPA90, cx+rx*NSVG_KAPPA90, cy+ry, cx, cy+ry);
		nsvg__cubicBezTo(p, cx-rx*NSVG_KAPPA90, cy+ry, cx-rx, cy+ry*NSVG_KAPPA90, cx-rx, cy);
		nsvg__cubicBezTo(p, cx-rx, cy-ry*NSVG_KAPPA90, cx-rx*NSVG_KAPPA90, cy-ry, cx, cy-ry);
		nsvg__cubicBezTo(p, cx+rx*NSVG_KAPPA90, cy-ry, cx+rx, cy-ry*NSVG_KAPPA90, cx+rx, cy);

		nsvg__addPath(p, 1);

		nsvg__addShape(p);
	}
}

static void nsvg__parseLine(NSVGparser* p, const char** attr)
{
	float x1 = 0.0;
	float y1 = 0.0;
	float x2 = 0.0;
	float y2 = 0.0;
	int i;

	for (i = 0; attr[i]; i += 2) {
		if (!nsvg__parseAttr(p, attr[i], attr[i + 1])) {
			if (strcmp(attr[i], "x1") == 0) x1 = nsvg__parseCoordinate(p, attr[i + 1], nsvg__actualOrigX(p), nsvg__actualWidth(p));
			if (strcmp(attr[i], "y1") == 0) y1 = nsvg__parseCoordinate(p, attr[i + 1], nsvg__actualOrigY(p), nsvg__actualHeight(p));
			if (strcmp(attr[i], "x2") == 0) x2 = nsvg__parseCoordinate(p, attr[i + 1], nsvg__actualOrigX(p), nsvg__actualWidth(p));
			if (strcmp(attr[i], "y2") == 0) y2 = nsvg__parseCoordinate(p, attr[i + 1], nsvg__actualOrigY(p), nsvg__actualHeight(p));
		}
	}

	nsvg__resetPath(p);

	nsvg__moveTo(p, x1, y1);
	nsvg__lineTo(p, x2, y2);

	nsvg__addPath(p, 0);

	nsvg__addShape(p);
}

static void nsvg__parsePoly(NSVGparser* p, const char** attr, int closeFlag)
{
	int i;
	const char* s;
	float args[2];
	int nargs, npts = 0;
	char item[64];

	nsvg__resetPath(p);

	for (i = 0; attr[i]; i += 2) {
		if (!nsvg__parseAttr(p, attr[i], attr[i + 1])) {
			if (strcmp(attr[i], "points") == 0) {
				s = attr[i + 1];
				nargs = 0;
				while (*s) {
					s = nsvg__getNextPathItem(s, item);
					args[nargs++] = (float)nsvg__atof(item);
					if (nargs >= 2) {
						if (npts == 0)
							nsvg__moveTo(p, args[0], args[1]);
						else
							nsvg__lineTo(p, args[0], args[1]);
						nargs = 0;
						npts++;
					}
				}
			}
		}
	}

	nsvg__addPath(p, (char)closeFlag);

	nsvg__addShape(p);
}

static void nsvg__parseSVG(NSVGparser* p, const char** attr)
{
	int i;
	for (i = 0; attr[i]; i += 2) {
		if (!nsvg__parseAttr(p, attr[i], attr[i + 1])) {
			if (strcmp(attr[i], "width") == 0) {
				p->image->width = nsvg__parseCoordinate(p, attr[i + 1], 0.0f, 0.0f);
			} else if (strcmp(attr[i], "height") == 0) {
				p->image->height = nsvg__parseCoordinate(p, attr[i + 1], 0.0f, 0.0f);
			} else if (strcmp(attr[i], "viewBox") == 0) {
				const char *s = attr[i + 1];
				char buf[64];
				s = nsvg__parseNumber(s, buf, 64);
				p->viewMinx = nsvg__atof(buf);
				while (*s && (nsvg__isspace(*s) || *s == '%' || *s == ',')) s++;
				if (!*s) return;
				s = nsvg__parseNumber(s, buf, 64);
				p->viewMiny = nsvg__atof(buf);
				while (*s && (nsvg__isspace(*s) || *s == '%' || *s == ',')) s++;
				if (!*s) return;
				s = nsvg__parseNumber(s, buf, 64);
				p->viewWidth = nsvg__atof(buf);
				while (*s && (nsvg__isspace(*s) || *s == '%' || *s == ',')) s++;
				if (!*s) return;
				s = nsvg__parseNumber(s, buf, 64);
				p->viewHeight = nsvg__atof(buf);
			} else if (strcmp(attr[i], "preserveAspectRatio") == 0) {
				if (strstr(attr[i + 1], "none") != 0) {
					// No uniform scaling
					p->alignType = NSVG_ALIGN_NONE;
				} else {
					// Parse X align
					if (strstr(attr[i + 1], "xMin") != 0)
						p->alignX = NSVG_ALIGN_MIN;
					else if (strstr(attr[i + 1], "xMid") != 0)
						p->alignX = NSVG_ALIGN_MID;
					else if (strstr(attr[i + 1], "xMax") != 0)
						p->alignX = NSVG_ALIGN_MAX;
					// Parse X align
					if (strstr(attr[i + 1], "yMin") != 0)
						p->alignY = NSVG_ALIGN_MIN;
					else if (strstr(attr[i + 1], "yMid") != 0)
						p->alignY = NSVG_ALIGN_MID;
					else if (strstr(attr[i + 1], "yMax") != 0)
						p->alignY = NSVG_ALIGN_MAX;
					// Parse meet/slice
					p->alignType = NSVG_ALIGN_MEET;
					if (strstr(attr[i + 1], "slice") != 0)
						p->alignType = NSVG_ALIGN_SLICE;
				}
			}
		}
	}
}

static void nsvg__parseGradient(NSVGparser* p, const char** attr, signed char type)
{
	int i;
	NSVGgradientData* grad = (NSVGgradientData*)malloc(sizeof(NSVGgradientData));
	if (grad == NULL) return;
	memset(grad, 0, sizeof(NSVGgradientData));
	grad->units = NSVG_OBJECT_SPACE;
	grad->type = type;
	if (grad->type == NSVG_PAINT_LINEAR_GRADIENT) {
		grad->linear.x1 = nsvg__coord(0.0f, NSVG_UNITS_PERCENT);
		grad->linear.y1 = nsvg__coord(0.0f, NSVG_UNITS_PERCENT);
		grad->linear.x2 = nsvg__coord(100.0f, NSVG_UNITS_PERCENT);
		grad->linear.y2 = nsvg__coord(0.0f, NSVG_UNITS_PERCENT);
	} else if (grad->type == NSVG_PAINT_RADIAL_GRADIENT) {
		grad->radial.cx = nsvg__coord(50.0f, NSVG_UNITS_PERCENT);
		grad->radial.cy = nsvg__coord(50.0f, NSVG_UNITS_PERCENT);
		grad->radial.r = nsvg__coord(50.0f, NSVG_UNITS_PERCENT);
	}

	nsvg__xformIdentity(grad->xform);

	for (i = 0; attr[i]; i += 2) {
		if (strcmp(attr[i], "id") == 0) {
			strncpy(grad->id, attr[i+1], 63);
			grad->id[63] = '\0';
		} else if (!nsvg__parseAttr(p, attr[i], attr[i + 1])) {
			if (strcmp(attr[i], "gradientUnits") == 0) {
				if (strcmp(attr[i+1], "objectBoundingBox") == 0)
					grad->units = NSVG_OBJECT_SPACE;
				else
					grad->units = NSVG_USER_SPACE;
			} else if (strcmp(attr[i], "gradientTransform") == 0) {
				nsvg__parseTransform(grad->xform, attr[i + 1]);
			} else if (strcmp(attr[i], "cx") == 0) {
				grad->radial.cx = nsvg__parseCoordinateRaw(attr[i + 1]);
			} else if (strcmp(attr[i], "cy") == 0) {
				grad->radial.cy = nsvg__parseCoordinateRaw(attr[i + 1]);
			} else if (strcmp(attr[i], "r") == 0) {
				grad->radial.r = nsvg__parseCoordinateRaw(attr[i + 1]);
			} else if (strcmp(attr[i], "fx") == 0) {
				grad->radial.fx = nsvg__parseCoordinateRaw(attr[i + 1]);
			} else if (strcmp(attr[i], "fy") == 0) {
				grad->radial.fy = nsvg__parseCoordinateRaw(attr[i + 1]);
			} else if (strcmp(attr[i], "x1") == 0) {
				grad->linear.x1 = nsvg__parseCoordinateRaw(attr[i + 1]);
			} else if (strcmp(attr[i], "y1") == 0) {
				grad->linear.y1 = nsvg__parseCoordinateRaw(attr[i + 1]);
			} else if (strcmp(attr[i], "x2") == 0) {
				grad->linear.x2 = nsvg__parseCoordinateRaw(attr[i + 1]);
			} else if (strcmp(attr[i], "y2") == 0) {
				grad->linear.y2 = nsvg__parseCoordinateRaw(attr[i + 1]);
			} else if (strcmp(attr[i], "spreadMethod") == 0) {
				if (strcmp(attr[i+1], "pad") == 0)
					grad->spread = NSVG_SPREAD_PAD;
				else if (strcmp(attr[i+1], "reflect") == 0)
					grad->spread = NSVG_SPREAD_REFLECT;
				else if (strcmp(attr[i+1], "repeat") == 0)
					grad->spread = NSVG_SPREAD_REPEAT;
			} else if (strcmp(attr[i], "xlink:href") == 0) {
				const char *href = attr[i+1];
				strncpy(grad->ref, href+1, 62);
				grad->ref[62] = '\0';
			}
		}
	}

	grad->next = p->gradients;
	p->gradients = grad;
}

static void nsvg__parseGradientStop(NSVGparser* p, const char** attr)
{
	NSVGattrib* curAttr = nsvg__getAttr(p);
	NSVGgradientData* grad;
	NSVGgradientStop* stop;
	int i, idx;

	curAttr->stopOffset = 0;
	curAttr->stopColor = 0;
	curAttr->stopOpacity = 1.0f;

	for (i = 0; attr[i]; i += 2) {
		nsvg__parseAttr(p, attr[i], attr[i + 1]);
	}

	// Add stop to the last gradient.
	grad = p->gradients;
	if (grad == NULL) return;

	grad->nstops++;
	grad->stops = (NSVGgradientStop*)realloc(grad->stops, sizeof(NSVGgradientStop)*grad->nstops);
	if (grad->stops == NULL) return;

	// Insert
	idx = grad->nstops-1;
	for (i = 0; i < grad->nstops-1; i++) {
		if (curAttr->stopOffset < grad->stops[i].offset) {
			idx = i;
			break;
		}
	}
	if (idx != grad->nstops-1) {
		for (i = grad->nstops-1; i > idx; i--)
			grad->stops[i] = grad->stops[i-1];
	}

	stop = &grad->stops[idx];
	stop->color = curAttr->stopColor;
	stop->color |= (unsigned int)(curAttr->stopOpacity*255) << 24;
	stop->offset = curAttr->stopOffset;
}

static void nsvg__startElement(void* ud, const char* el, const char** attr)
{
	NSVGparser* p = (NSVGparser*)ud;

	if (p->defsFlag) {
		// Skip everything but gradients in defs
		if (strcmp(el, "linearGradient") == 0) {
			nsvg__parseGradient(p, attr, NSVG_PAINT_LINEAR_GRADIENT);
		} else if (strcmp(el, "radialGradient") == 0) {
			nsvg__parseGradient(p, attr, NSVG_PAINT_RADIAL_GRADIENT);
		} else if (strcmp(el, "stop") == 0) {
			nsvg__parseGradientStop(p, attr);
		}
		return;
	}

	if (strcmp(el, "g") == 0) {
		nsvg__pushAttr(p);
		nsvg__parseAttribs(p, attr);
	} else if (strcmp(el, "path") == 0) {
		if (p->pathFlag)	// Do not allow nested paths.
			return;
		nsvg__pushAttr(p);
		nsvg__parsePath(p, attr);
		nsvg__popAttr(p);
	} else if (strcmp(el, "rect") == 0) {
		nsvg__pushAttr(p);
		nsvg__parseRect(p, attr);
		nsvg__popAttr(p);
	} else if (strcmp(el, "circle") == 0) {
		nsvg__pushAttr(p);
		nsvg__parseCircle(p, attr);
		nsvg__popAttr(p);
	} else if (strcmp(el, "ellipse") == 0) {
		nsvg__pushAttr(p);
		nsvg__parseEllipse(p, attr);
		nsvg__popAttr(p);
	} else if (strcmp(el, "line") == 0)  {
		nsvg__pushAttr(p);
		nsvg__parseLine(p, attr);
		nsvg__popAttr(p);
	} else if (strcmp(el, "polyline") == 0)  {
		nsvg__pushAttr(p);
		nsvg__parsePoly(p, attr, 0);
		nsvg__popAttr(p);
	} else if (strcmp(el, "polygon") == 0)  {
		nsvg__pushAttr(p);
		nsvg__parsePoly(p, attr, 1);
		nsvg__popAttr(p);
	} else  if (strcmp(el, "linearGradient") == 0) {
		nsvg__parseGradient(p, attr, NSVG_PAINT_LINEAR_GRADIENT);
	} else if (strcmp(el, "radialGradient") == 0) {
		nsvg__parseGradient(p, attr, NSVG_PAINT_RADIAL_GRADIENT);
	} else if (strcmp(el, "stop") == 0) {
		nsvg__parseGradientStop(p, attr);
	} else if (strcmp(el, "defs") == 0) {
		p->defsFlag = 1;
	} else if (strcmp(el, "svg") == 0) {
		nsvg__parseSVG(p, attr);
	}
}

static void nsvg__endElement(void* ud, const char* el)
{
	NSVGparser* p = (NSVGparser*)ud;

	if (strcmp(el, "g") == 0) {
		nsvg__popAttr(p);
	} else if (strcmp(el, "path") == 0) {
		p->pathFlag = 0;
	} else if (strcmp(el, "defs") == 0) {
		p->defsFlag = 0;
	}
}

static void nsvg__content(void* ud, const char* s)
{
	NSVG_NOTUSED(ud);
	NSVG_NOTUSED(s);
	// empty
}

static void nsvg__imageBounds(NSVGparser* p, float* bounds)
{
	NSVGshape* shape;
	shape = p->image->shapes;
	if (shape == NULL) {
		bounds[0] = bounds[1] = bounds[2] = bounds[3] = 0.0;
		return;
	}
	bounds[0] = shape->bounds[0];
	bounds[1] = shape->bounds[1];
	bounds[2] = shape->bounds[2];
	bounds[3] = shape->bounds[3];
	for (shape = shape->next; shape != NULL; shape = shape->next) {
		bounds[0] = nsvg__minf(bounds[0], shape->bounds[0]);
		bounds[1] = nsvg__minf(bounds[1], shape->bounds[1]);
		bounds[2] = nsvg__maxf(bounds[2], shape->bounds[2]);
		bounds[3] = nsvg__maxf(bounds[3], shape->bounds[3]);
	}
}

static float nsvg__viewAlign(float content, float container, int type)
{
	if (type == NSVG_ALIGN_MIN)
		return 0;
	else if (type == NSVG_ALIGN_MAX)
		return container - content;
	// mid
	return (container - content) * 0.5f;
}

static void nsvg__scaleGradient(NSVGgradient* grad, float tx, float ty, float sx, float sy)
{
	float t[6];
	nsvg__xformSetTranslation(t, tx, ty);
	nsvg__xformMultiply (grad->xform, t);

	nsvg__xformSetScale(t, sx, sy);
	nsvg__xformMultiply (grad->xform, t);
}

static void nsvg__scaleToViewbox(NSVGparser* p, const char* units)
{
	NSVGshape* shape;
	NSVGpath* path;
	float tx, ty, sx, sy, us, bounds[4], t[6], avgs;
	int i;
	float* pt;

	// Guess image size if not set completely.
	nsvg__imageBounds(p, bounds);

	if (p->viewWidth == 0) {
		if (p->image->width > 0) {
			p->viewWidth = p->image->width;
		} else {
			p->viewMinx = bounds[0];
			p->viewWidth = bounds[2] - bounds[0];
		}
	}
	if (p->viewHeight == 0) {
		if (p->image->height > 0) {
			p->viewHeight = p->image->height;
		} else {
			p->viewMiny = bounds[1];
			p->viewHeight = bounds[3] - bounds[1];
		}
	}
	if (p->image->width == 0)
		p->image->width = p->viewWidth;
	if (p->image->height == 0)
		p->image->height = p->viewHeight;

	tx = -p->viewMinx;
	ty = -p->viewMiny;
	sx = p->viewWidth > 0 ? p->image->width / p->viewWidth : 0;
	sy = p->viewHeight > 0 ? p->image->height / p->viewHeight : 0;
	// Unit scaling
	us = 1.0f / nsvg__convertToPixels(p, nsvg__coord(1.0f, nsvg__parseUnits(units)), 0.0f, 1.0f);

	// Fix aspect ratio
	if (p->alignType == NSVG_ALIGN_MEET) {
		// fit whole image into viewbox
		sx = sy = nsvg__minf(sx, sy);
		tx += nsvg__viewAlign(p->viewWidth*sx, p->image->width, p->alignX) / sx;
		ty += nsvg__viewAlign(p->viewHeight*sy, p->image->height, p->alignY) / sy;
	} else if (p->alignType == NSVG_ALIGN_SLICE) {
		// fill whole viewbox with image
		sx = sy = nsvg__maxf(sx, sy);
		tx += nsvg__viewAlign(p->viewWidth*sx, p->image->width, p->alignX) / sx;
		ty += nsvg__viewAlign(p->viewHeight*sy, p->image->height, p->alignY) / sy;
	}

	// Transform
	sx *= us;
	sy *= us;
	avgs = (sx+sy) / 2.0f;
	for (shape = p->image->shapes; shape != NULL; shape = shape->next) {
		shape->bounds[0] = (shape->bounds[0] + tx) * sx;
		shape->bounds[1] = (shape->bounds[1] + ty) * sy;
		shape->bounds[2] = (shape->bounds[2] + tx) * sx;
		shape->bounds[3] = (shape->bounds[3] + ty) * sy;
		for (path = shape->paths; path != NULL; path = path->next) {
			path->bounds[0] = (path->bounds[0] + tx) * sx;
			path->bounds[1] = (path->bounds[1] + ty) * sy;
			path->bounds[2] = (path->bounds[2] + tx) * sx;
			path->bounds[3] = (path->bounds[3] + ty) * sy;
			for (i =0; i < path->npts; i++) {
				pt = &path->pts[i*2];
				pt[0] = (pt[0] + tx) * sx;
				pt[1] = (pt[1] + ty) * sy;
			}
		}

		if (shape->fill.type == NSVG_PAINT_LINEAR_GRADIENT || shape->fill.type == NSVG_PAINT_RADIAL_GRADIENT) {
			nsvg__scaleGradient(shape->fill.gradient, tx,ty, sx,sy);
			memcpy(t, shape->fill.gradient->xform, sizeof(float)*6);
			nsvg__xformInverse(shape->fill.gradient->xform, t);
		}
		if (shape->stroke.type == NSVG_PAINT_LINEAR_GRADIENT || shape->stroke.type == NSVG_PAINT_RADIAL_GRADIENT) {
			nsvg__scaleGradient(shape->stroke.gradient, tx,ty, sx,sy);
			memcpy(t, shape->stroke.gradient->xform, sizeof(float)*6);
			nsvg__xformInverse(shape->stroke.gradient->xform, t);
		}

		shape->strokeWidth *= avgs;
		shape->strokeDashOffset *= avgs;
		for (i = 0; i < shape->strokeDashCount; i++)
			shape->strokeDashArray[i] *= avgs;
	}
}

static void nsvg__createGradients(NSVGparser* p)
{
	NSVGshape* shape;

	for (shape = p->image->shapes; shape != NULL; shape = shape->next) {
		if (shape->fill.type == NSVG_PAINT_UNDEF) {
			if (shape->fillGradient[0] != '\0') {
				float inv[6], localBounds[4];
				nsvg__xformInverse(inv, shape->xform);
				nsvg__getLocalBounds(localBounds, shape, inv);
				shape->fill.gradient = nsvg__createGradient(p, shape->fillGradient, localBounds, shape->xform, &shape->fill.type);
			}
			if (shape->fill.type == NSVG_PAINT_UNDEF) {
				shape->fill.type = NSVG_PAINT_NONE;
			}
		}
		if (shape->stroke.type == NSVG_PAINT_UNDEF) {
			if (shape->strokeGradient[0] != '\0') {
				float inv[6], localBounds[4];
				nsvg__xformInverse(inv, shape->xform);
				nsvg__getLocalBounds(localBounds, shape, inv);
				shape->stroke.gradient = nsvg__createGradient(p, shape->strokeGradient, localBounds, shape->xform, &shape->stroke.type);
			}
			if (shape->stroke.type == NSVG_PAINT_UNDEF) {
				shape->stroke.type = NSVG_PAINT_NONE;
			}
		}
	}
}

NSVGimage* nsvgParse(char* input, const char* units, float dpi)
{
	NSVGparser* p;
	NSVGimage* ret = 0;

	p = nsvg__createParser();
	if (p == NULL) {
		return NULL;
	}
	p->dpi = dpi;

	nsvg__parseXML(input, nsvg__startElement, nsvg__endElement, nsvg__content, p);

	// Create gradients after all definitions have been parsed
	nsvg__createGradients(p);

	// Scale to viewBox
	nsvg__scaleToViewbox(p, units);

	ret = p->image;
	p->image = NULL;

	nsvg__deleteParser(p);

	return ret;
}

NSVGimage* nsvgParseFromFile(const char* filename, const char* units, float dpi)
{
	FILE* fp = NULL;
	size_t size;
	char* data = NULL;
	NSVGimage* image = NULL;

	fp = fopen(filename, "rb");
	if (!fp) goto error;
	fseek(fp, 0, SEEK_END);
	size = ftell(fp);
	fseek(fp, 0, SEEK_SET);
	data = (char*)malloc(size+1);
	if (data == NULL) goto error;
	if (fread(data, 1, size, fp) != size) goto error;
	data[size] = '\0';	// Must be null terminated.
	fclose(fp);
	image = nsvgParse(data, units, dpi);
	free(data);

	return image;

error:
	if (fp) fclose(fp);
	if (data) free(data);
	if (image) nsvgDelete(image);
	return NULL;
}

NSVGpath* nsvgDuplicatePath(NSVGpath* p)
{
    NSVGpath* res = NULL;

    if (p == NULL)
        return NULL;

    res = (NSVGpath*)malloc(sizeof(NSVGpath));
    if (res == NULL) goto error;
    memset(res, 0, sizeof(NSVGpath));

    res->pts = (float*)malloc(p->npts*2*sizeof(float));
    if (res->pts == NULL) goto error;
    memcpy(res->pts, p->pts, p->npts * sizeof(float) * 2);
    res->npts = p->npts;

    memcpy(res->bounds, p->bounds, sizeof(p->bounds));

    res->closed = p->closed;

    return res;

error:
    if (res != NULL) {
        free(res->pts);
        free(res);
    }
    return NULL;
}

void nsvgDelete(NSVGimage* image)
{
	NSVGshape *snext, *shape;
	if (image == NULL) return;
	shape = image->shapes;
	while (shape != NULL) {
		snext = shape->next;
		nsvg__deletePaths(shape->paths);
		nsvg__deletePaint(&shape->fill);
		nsvg__deletePaint(&shape->stroke);
		free(shape);
		shape = snext;
	}
	free(image);
}

#endif // NANOSVG_IMPLEMENTATION

#endif // NANOSVG_H

#ifndef INPUTBOX_H
#define INPUTBOX_H

#include <string>
#include <SDL2/SDL.h>
#include <SDL2/SDL_ttf.h>

// 前置声明
class Screen;

class InputBox {
public:
    // 构造函数，接收屏幕对象指针
    InputBox(Screen* screen);
    ~InputBox();

    // 显示输入框并返回输入结果
    std::string show(std::string title, std::string prompt);

private:
    Screen* m_screen;               // 关联的屏幕对象
    SDL_Window* m_window;           // 输入框窗口
    SDL_Renderer* m_renderer;       // 输入框渲染器
    TTF_Font* m_font;               // 字体
    std::string m_inputText;        // 输入的文本
    bool m_quit;                    // 是否退出输入框
    bool m_confirmed;               // 是否确认输入
    const int m_windowWidth = 300;  // 窗口宽度
    const int m_windowHeight = 180; // 窗口高度

    // 初始化输入框窗口和渲染器
    bool init(const std::string& title);
    // 处理事件
    void handleEvents();
    // 渲染输入框界面
    void render(const std::string& prompt);
    // 释放资源
    void cleanup();
};

#endif // INPUTBOX_H

#ifndef FUNCTOOLS_H
#define FUNCTOOLS_H

#include <string>
#include <vector>
#include <SDL2/SDL.h> 
#include "polygon_offset.h"
#include "coloradd.h"
#include <map>
#include <shlobj.h>
#include <fstream>  // 添加这一行以使用 ofstream


// 函数声明
float deg_to_rad(float deg);

//由于RtlGetVersion不是标准的SDK部分，需要手动定义其原型
typedef LONG (NTAPI *RTLGETVERSION)(PRTL_OSVERSIONINFOW);
std::string getWindowsVersion();

std::string ConvertToUtf8(const std::string& ansiPath);

std::string getWindowsDirectory() ;

std::string rgb2hex(Uint8 r, Uint8 g, Uint8 b);
bool hexColorToRGB(const std::string& hexStr, Uint8& r, Uint8& g, Uint8& b);

SDL_Color color_string2_SDL_Color(std::string penyanse);

// 可以添加其他常用函数的声明
bool isPointInPolygon(float x, float y, const std::vector<Point>& points);
void getBoundingBox(const std::vector<Point>& points,int& minX, int& minY, int& maxX, int& maxY);
bool intersectEdge(float y, const Point& v0, const Point& v1, float& x) ;

void drawFilledPolygon(SDL_Renderer* renderer,const std::vector<Point>& points,
                       Uint8 r, Uint8 g, Uint8 b, Uint8 a) ;
void drawFilledPolygon_slow(SDL_Renderer* renderer,
                       const std::vector<Point>& points,
                       Uint8 r, Uint8 g, Uint8 b, Uint8 a) ;    
                       
bool isPointInPolygon_Winding(float x, float y, const std::vector<Point>& points);
float isLeft(float x0, float y0, float x1, float y1, float x, float y);
SDL_Color decomposeRGBA(Uint32 color);

void floodfill(int x,int y,Color color); //在x,y进行洪水填充
void floodfill(int x,int y,SDL_Color fc); 
void floodfill(int x,int y,std::string newColor); //在x,y进行洪水填充 
void _floodfill(Point cur, SDL_Color newCol);
std::string replaceBackslashes(const std::string& path);

Point rotatePoint(const Point& point, const Point& center, float angle);
SDL_Rect rotatedRect(const SDL_Rect& rect, float angle);

    
// 工具函数实现，模版函数要放在头文件里 
template<typename T>
T clamppx(T value, T min, T max)  {
    return (value < min) ? min : (value > max) ? max : value;
}

template<typename T>
T max3(T a, T b, T c)  {
    return std::max(std::max(a, b), c);
}

template<typename T>
T min3(T a, T b, T c)  {
    return std::min(std::min(a, b), c);
}
        
char* GbkToUtf8(const char* gbkStr);
char* Utf8ToGbk(const char* utf8Str); 
// 文本转图片函数声明
SDL_Surface* text2surface(std::string txt, unsigned int size, SDL_Color color);  //基本作废 
bool surface_save_png(SDL_Surface* sur, std::string savepath);

bool fileExists(const std::string& filename); 

void to_world_xy(double &x,double &y);            //到世界坐标，中间为原点 
void to_world_xy(float &x,float &y);            //到世界坐标，中间为原点 
void to_world_xy(int &x,int &y);            //到世界坐标，中间为原点 

void to_screen_xy(double &x,double &y);        //到屏幕坐标，左上为原点 
void to_screen_xy(float &x,float &y);        //到屏幕坐标，左上为原点 
void to_screen_xy(int &x,int &y);        //到屏幕坐标，左上为原点 

int randint(int a,int b);
// 生成 [a, b] 区间的浮点数，均匀分布
float random(float a, float b);

template<typename T>
T oneof(T a, T b) {
    int x = randint(0, 1);
    if (x == 0) return a;
    return b;
}

// 将宽字符转换为窄字符（UTF-8）
std::string wideToNarrow(const wchar_t* wideStr);
std::string get_system_font_folder();
// 获取字体名称到路径的映射表
std::map<std::string, std::string> getFontNameToPathMap() ;

std::vector<unsigned char> base64_decode(const std::string& encoded);
void base64_to_png(const std::string& base64_data, const std::string& output_filename);

void ApplyFlipToPoints(SDL_Point* points, int w, int h, SDL_RendererFlip flip);
SDL_Rect CalculateRenderCopyExBoundingRect(const SDL_Rect* dstRect, double angle, const SDL_Point* center,SDL_RendererFlip flip);

bool svg2png(const char* svgPath, const char* pngPath, float scale=1.0f);

// 简单直接的版本，把svg里的fill填充颜色换成其它颜色 
std::string replace_fill_color_simple(const std::string& src_svg_content, const std::string& color);
void release_svg_content();   //释放在functools.cpp里存储的svg文件到res文件夹 
std::string inputbox(std::string title, std::string prompt);
int messagebox(std::string title,std::string prompt,unsigned flags=SDL_MESSAGEBOX_INFORMATION);
// 计算角ABC的大小（单位：度）
float get_angle(Point A, Point B, Point C);

#endif // FUNCTOOLS_H 

#ifndef DYNAMICPROPERTY_H
#define DYNAMICPROPERTY_H

#include <any>
#include <string>
#include <stdexcept>
#include <typeinfo>
#include <iostream>
#include <sstream>
#include <utility> // for std::pair

class DynamicProperty {
private:
    std::any value_;
    
public:
    // 构造函数
    DynamicProperty() = default;
    
    template<typename T>
    DynamicProperty(T value) : value_(std::move(value)) {}
       // 允许从 C 风格字符串隐式构造 DynamicProperty
	DynamicProperty(const char* str) {
	    if (str) {
	        value_ = std::string(str);
	    } else {
	        value_ = std::string(); // 或者 value_ = 0; 但建议统一为 string
	    }
	}    
    // 拷贝构造函数
    DynamicProperty(const DynamicProperty&) = default;
    
    // 移动构造函数
    DynamicProperty(DynamicProperty&&) = default;
    
    // 拷贝赋值运算符
    DynamicProperty& operator=(const DynamicProperty&) = default;
    
    // 移动赋值运算符
    DynamicProperty& operator=(DynamicProperty&&) = default;
    
    ~DynamicProperty() = default;
    
    DynamicProperty& operator=(const char* str) {
      if (str == nullptr) {
        value_ = 0; 
        // 或者更安全：throw std::invalid_argument("null pointer assigned to DynamicProperty");
      }else {
        value_ = std::string(str);
      }
    return *this;
   }
   
	// 类型转换运算符
	operator int() const {
	    if (auto* i = std::any_cast<int>(&value_)) {
	        return *i;
	    } else if (auto* d = std::any_cast<double>(&value_)) {
	        return static_cast<int>(*d);
	    } else if (auto* f = std::any_cast<float>(&value_)) {
	        return static_cast<int>(*f);
	    } else {
	        return 0; // 或者其他默认值，或者抛出异常
	    }
	}
	
	operator double() const {
	    if (auto* i = std::any_cast<int>(&value_)) {
	        return static_cast<double>(*i);
	    } else if (auto* d = std::any_cast<double>(&value_)) {
	        return *d;
	    } else if (auto* f = std::any_cast<float>(&value_)) {
	        return static_cast<double>(*f);
	    } else {
	        return 0.0;
	    }
	}
	
	operator float() const {
	    if (auto* i = std::any_cast<int>(&value_)) {
	        return static_cast<float>(*i);
	    } else if (auto* d = std::any_cast<double>(&value_)) {
	        return static_cast<float>(*d);
	    } else if (auto* f = std::any_cast<float>(&value_)) {
	        return *f;
	    } else {
	        return 0.0f;
	    }
	}
	
	operator bool() const {
	    if (auto* b = std::any_cast<bool>(&value_)) {
	        return *b;
	    } else if (auto* i = std::any_cast<int>(&value_)) {
	        return *i != 0;
	    } else if (auto* d = std::any_cast<double>(&value_)) {
	        return *d != 0.0;
	    } else if (auto* f = std::any_cast<float>(&value_)) {
	        return *f != 0.0f;
	    } else if (auto* s = std::any_cast<std::string>(&value_)) {
	        return !s->empty();
	    } else {
	        return false;
	    }
	}
	
	operator std::pair<float, float>() const {
    if (auto* p = std::any_cast<std::pair<float, float>>(&value_)) {
        return *p;
    } else {
        // 可选：抛出异常，或返回默认值
        throw std::runtime_error("DynamicProperty is not a std::pair<float, float>");
     }
   }

	
	operator std::string() const {
	    return to_string();
	}
	    
    
    // 获取值
    template<typename T>
    T get() const {
        try {
            return std::any_cast<T>(value_);
        } catch (const std::bad_any_cast& e) {
            throw std::runtime_error("DynamicProperty type mismatch: expected " + 
                                   std::string(typeid(T).name()) + 
                                   ", but got different type");
        }
    }
    
    // 设置值
    template<typename T>
    void set(T value) {
        value_ = std::move(value);
    }
    
    // 检查是否包含值
    bool has_value() const {
        return value_.has_value();
    }
    
    // 获取类型信息
    const std::type_info& type() const {
        return value_.type();
    }
    
    // 转换为字符串
    std::string to_string() const;
    
    // 算术运算符
    // 自增运算符
    DynamicProperty& operator++();        // 前缀 ++
    DynamicProperty operator++(int);      // 后缀 ++
    
    // 自减运算符
    DynamicProperty& operator--();        // 前缀 --
    DynamicProperty operator--(int);      // 后缀 --
    
    // 一元正号运算符
	DynamicProperty operator+() const {
	    return *this; // 一元正号通常返回对象本身
	}

	// 一元负号运算符
	DynamicProperty operator-() const {
	    if (auto* i = std::any_cast<int>(&value_)) {
	        return DynamicProperty(-(*i));
	    } else if (auto* d = std::any_cast<double>(&value_)) {
	        return DynamicProperty(-(*d));
	    } else if (auto* f = std::any_cast<float>(&value_)) {
	        return DynamicProperty(-(*f));
	    } else {
	        throw std::runtime_error("DynamicProperty does not support unary - for current type");
	    }
	}
    
    
	// 加法赋值运算符
	template<typename T>
	DynamicProperty& operator+=(const T& value) {
	    if (auto* i = std::any_cast<int>(&value_)) {
	        if constexpr (std::is_arithmetic_v<T>) {
	            *i += static_cast<int>(value);
	        } else {
	            throw std::runtime_error("DynamicProperty does not support += with non-arithmetic type for int");
	        }
	    } else if (auto* d = std::any_cast<double>(&value_)) {
	        if constexpr (std::is_arithmetic_v<T>) {
	            *d += static_cast<double>(value);
	        } else {
	            throw std::runtime_error("DynamicProperty does not support += with non-arithmetic type for double");
	        }
	    } else if (auto* f = std::any_cast<float>(&value_)) {
	        if constexpr (std::is_arithmetic_v<T>) {
	            *f += static_cast<float>(value);
	        } else {
	            throw std::runtime_error("DynamicProperty does not support += with non-arithmetic type for float");
	        }
	    } else if (auto* s = std::any_cast<std::string>(&value_)) {
	        // 使用字符串流来处理所有类型的转换
	        std::ostringstream oss;
	        oss << value;
	        *s += oss.str();
	    } else {
	        throw std::runtime_error("DynamicProperty does not support += for current type");
	    }
	    return *this;
	}
    
    // DynamicProperty 之间的加法运算符
	friend DynamicProperty operator+(const DynamicProperty& lhs, const DynamicProperty& rhs) {
	    if (lhs.is_int() && rhs.is_int()) {
	        return DynamicProperty(lhs.get<int>() + rhs.get<int>());
	    } else if (lhs.is_double() && rhs.is_double()) {
	        return DynamicProperty(lhs.get<double>() + rhs.get<double>());
	    } else if (lhs.is_float() && rhs.is_float()) {
	        return DynamicProperty(lhs.get<float>() + rhs.get<float>());
	    } else if (lhs.is_string() && rhs.is_string()) {
	        return DynamicProperty(lhs.get<std::string>() + rhs.get<std::string>());
	    } else {
	        // 尝试数值类型转换
	        if (lhs.is_int() || lhs.is_double() || lhs.is_float()) {
	            if (rhs.is_int() || rhs.is_double() || rhs.is_float()) {
	                // 数值类型相加
	                if (lhs.is_double() || rhs.is_double()) {
	                    return DynamicProperty(static_cast<double>(lhs) + static_cast<double>(rhs));
	                } else if (lhs.is_float() || rhs.is_float()) {
	                    return DynamicProperty(static_cast<float>(lhs) + static_cast<float>(rhs));
	                } else {
	                    return DynamicProperty(static_cast<int>(lhs) + static_cast<int>(rhs));
	                }
	            }
	        }
	        // 如果无法进行数值运算，转换为字符串相加
	        return DynamicProperty(lhs.to_string() + rhs.to_string());
	    }
	}
	
	// DynamicProperty 之间的减法运算符
	friend DynamicProperty operator-(const DynamicProperty& lhs, const DynamicProperty& rhs) {
	    // 只支持数值类型的减法
	    if (lhs.is_int() && rhs.is_int()) {
	        return DynamicProperty(lhs.get<int>() - rhs.get<int>());
	    } else if (lhs.is_double() && rhs.is_double()) {
	        return DynamicProperty(lhs.get<double>() - rhs.get<double>());
	    } else if (lhs.is_float() && rhs.is_float()) {
	        return DynamicProperty(lhs.get<float>() - rhs.get<float>());
	    } else {
	        // 尝试数值类型转换
	        if (lhs.is_int() || lhs.is_double() || lhs.is_float()) {
	            if (rhs.is_int() || rhs.is_double() || rhs.is_float()) {
	                // 数值类型相减
	                if (lhs.is_double() || rhs.is_double()) {
	                    return DynamicProperty(static_cast<double>(lhs) - static_cast<double>(rhs));
	                } else if (lhs.is_float() || rhs.is_float()) {
	                    return DynamicProperty(static_cast<float>(lhs) - static_cast<float>(rhs));
	                } else {
	                    return DynamicProperty(static_cast<int>(lhs) - static_cast<int>(rhs));
	                }
	            }
	        }
	        throw std::runtime_error("DynamicProperty does not support - between these types (only numeric types)");
	    }
	}
	
	// DynamicProperty 之间的乘法运算符
	friend DynamicProperty operator*(const DynamicProperty& lhs, const DynamicProperty& rhs) {
	    // 只支持数值类型的乘法
	    if (lhs.is_int() && rhs.is_int()) {
	        return DynamicProperty(lhs.get<int>() * rhs.get<int>());
	    } else if (lhs.is_double() && rhs.is_double()) {
	        return DynamicProperty(lhs.get<double>() * rhs.get<double>());
	    } else if (lhs.is_float() && rhs.is_float()) {
	        return DynamicProperty(lhs.get<float>() * rhs.get<float>());
	    } else {
	        // 尝试数值类型转换
	        if (lhs.is_int() || lhs.is_double() || lhs.is_float()) {
	            if (rhs.is_int() || rhs.is_double() || rhs.is_float()) {
	                // 数值类型相乘
	                if (lhs.is_double() || rhs.is_double()) {
	                    return DynamicProperty(static_cast<double>(lhs) * static_cast<double>(rhs));
	                } else if (lhs.is_float() || rhs.is_float()) {
	                    return DynamicProperty(static_cast<float>(lhs) * static_cast<float>(rhs));
	                } else {
	                    return DynamicProperty(static_cast<int>(lhs) * static_cast<int>(rhs));
	                }
	            }
	        }
	        throw std::runtime_error("DynamicProperty does not support * between these types (only numeric types)");
	    }
	}
	
	// DynamicProperty 之间的除法运算符
	friend DynamicProperty operator/(const DynamicProperty& lhs, const DynamicProperty& rhs) {
	    // 检查除零
	    if ((rhs.is_int() && rhs.get<int>() == 0) ||
	        (rhs.is_double() && rhs.get<double>() == 0.0) ||
	        (rhs.is_float() && rhs.get<float>() == 0.0f)) {
	        throw std::runtime_error("Division by zero");
	    }
	    
	    // 只支持数值类型的除法
	    if (lhs.is_int() && rhs.is_int()) {
	        return DynamicProperty(lhs.get<int>() / rhs.get<int>());
	    } else if (lhs.is_double() && rhs.is_double()) {
	        return DynamicProperty(lhs.get<double>() / rhs.get<double>());
	    } else if (lhs.is_float() && rhs.is_float()) {
	        return DynamicProperty(lhs.get<float>() / rhs.get<float>());
	    } else {
	        // 尝试数值类型转换
	        if (lhs.is_int() || lhs.is_double() || lhs.is_float()) {
	            if (rhs.is_int() || rhs.is_double() || rhs.is_float()) {
	                // 数值类型相除
	                if (lhs.is_double() || rhs.is_double()) {
	                    return DynamicProperty(static_cast<double>(lhs) / static_cast<double>(rhs));
	                } else if (lhs.is_float() || rhs.is_float()) {
	                    return DynamicProperty(static_cast<float>(lhs) / static_cast<float>(rhs));
	                } else {
	                    return DynamicProperty(static_cast<int>(lhs) / static_cast<int>(rhs));
	                }
	            }
	        }
	        throw std::runtime_error("DynamicProperty does not support / between these types (only numeric types)");
	    }
	}
	
	// DynamicProperty 之间的取模运算符（仅整数）
	friend DynamicProperty operator%(const DynamicProperty& lhs, const DynamicProperty& rhs) {
	    // 检查模零
	    if ((rhs.is_int() && rhs.get<int>() == 0)) {
	        throw std::runtime_error("Modulo by zero");
	    }
	    
	    if (lhs.is_int() && rhs.is_int()) {
	        return DynamicProperty(lhs.get<int>() % rhs.get<int>());
	    } else {
	        throw std::runtime_error("DynamicProperty does not support % between these types (only int)");
	    }
	}


    
    // 减法赋值运算符
    template<typename T>
    DynamicProperty& operator-=(const T& value) {
        if (auto* i = std::any_cast<int>(&value_)) {
            *i -= static_cast<int>(value);
        } else if (auto* d = std::any_cast<double>(&value_)) {
            *d -= static_cast<double>(value);
        } else if (auto* f = std::any_cast<float>(&value_)) {
            *f -= static_cast<float>(value);
        } else {
            throw std::runtime_error("DynamicProperty does not support -= for current type");
        }
        return *this;
    }
    
    // 乘法赋值运算符
    template<typename T>
    DynamicProperty& operator*=(const T& value) {
        if (auto* i = std::any_cast<int>(&value_)) {
            *i *= static_cast<int>(value);
        } else if (auto* d = std::any_cast<double>(&value_)) {
            *d *= static_cast<double>(value);
        } else if (auto* f = std::any_cast<float>(&value_)) {
            *f *= static_cast<float>(value);
        } else {
            throw std::runtime_error("DynamicProperty does not support *= for current type");
        }
        return *this;
    }
    
    // 除法赋值运算符
    template<typename T>
    DynamicProperty& operator/=(const T& value) {
        if (value == 0) {
            throw std::runtime_error("Division by zero");
        }
        if (auto* i = std::any_cast<int>(&value_)) {
            *i /= static_cast<int>(value);
        } else if (auto* d = std::any_cast<double>(&value_)) {
            *d /= static_cast<double>(value);
        } else if (auto* f = std::any_cast<float>(&value_)) {
            *f /= static_cast<float>(value);
        } else {
            throw std::runtime_error("DynamicProperty does not support /= for current type");
        }
        return *this;
    }
    
    // 模赋值运算符（仅整数）
    template<typename T>
    DynamicProperty& operator%=(const T& value) {
        if (value == 0) {
            throw std::runtime_error("Modulo by zero");
        }
        if (auto* i = std::any_cast<int>(&value_)) {
            *i %= static_cast<int>(value);
        } else {
            throw std::runtime_error("DynamicProperty does not support %= for current type (only int)");
        }
        return *this;
    }
    // 取模运算符
	template<typename T>
	DynamicProperty operator%(const T& value) const {
	    if (auto* i = std::any_cast<int>(&value_)) {
	        return DynamicProperty(*i % static_cast<int>(value));
	    } else {
	        throw std::runtime_error("DynamicProperty does not support % for current type (only int)");
	    }
	}

    
    // 比较运算符 - 针对 DynamicProperty 之间的比较
    bool operator==(const DynamicProperty& other) const;
    bool operator!=(const DynamicProperty& other) const;
    bool operator<(const DynamicProperty& other) const;
    bool operator>(const DynamicProperty& other) const;
    bool operator<=(const DynamicProperty& other) const;
    bool operator>=(const DynamicProperty& other) const;
    
    // 与具体类型的比较 - 简化版本，只支持相同类型比较
    template<typename T>
    bool operator==(const T& other) const {
        if (auto* i = std::any_cast<int>(&value_)) {
            return *i == other;
        } else if (auto* d = std::any_cast<double>(&value_)) {
            return *d == other;
        } else if (auto* f = std::any_cast<float>(&value_)) {
            return *f == other;
        } else if (auto* s = std::any_cast<std::string>(&value_)) {
            if constexpr (std::is_same_v<T, std::string>) {
                return *s == other;
            } else {
                // 对于非字符串类型，转换为字符串比较
                return *s == std::to_string(other);
            }
        } else if (auto* b = std::any_cast<bool>(&value_)) {
            return *b == other;
        }
        return false;
    }
    
    template<typename T>
    bool operator!=(const T& other) const {
        return !(*this == other);
    }
    
    template<typename T>
    bool operator<(const T& other) const {
        if (auto* i = std::any_cast<int>(&value_)) {
            return *i < other;
        } else if (auto* d = std::any_cast<double>(&value_)) {
            return *d < other;
        } else if (auto* f = std::any_cast<float>(&value_)) {
            return *f < other;
        } else if (auto* s = std::any_cast<std::string>(&value_)) {
            if constexpr (std::is_same_v<T, std::string>) {
                return *s < other;
            } else {
                // 对于非字符串类型，转换为字符串比较
                return *s < std::to_string(other);
            }
        }
        return false;
    }
    
    template<typename T>
    bool operator>(const T& other) const {
        if (auto* i = std::any_cast<int>(&value_)) {
            return *i > other;
        } else if (auto* d = std::any_cast<double>(&value_)) {
            return *d > other;
        } else if (auto* f = std::any_cast<float>(&value_)) {
            return *f > other;
        } else if (auto* s = std::any_cast<std::string>(&value_)) {
            if constexpr (std::is_same_v<T, std::string>) {
                return *s > other;
            } else {
                // 对于非字符串类型，转换为字符串比较
                return *s > std::to_string(other);
            }
        }
        return false;
    }
    
    template<typename T>
    bool operator<=(const T& other) const {
        return !(*this > other);
    }
    
    template<typename T>
    bool operator>=(const T& other) const {
        return !(*this < other);
    }
    
    // 流输出运算符
    friend std::ostream& operator<<(std::ostream& os, const DynamicProperty& prop);
    
    // 类型检查方法
    bool is_int() const { return value_.type() == typeid(int); }
    bool is_double() const { return value_.type() == typeid(double); }
    bool is_float() const { return value_.type() == typeid(float); }
    bool is_string() const { return value_.type() == typeid(std::string); }
    bool is_bool() const { return value_.type() == typeid(bool); }
    bool is_pair_float() const {    return value_.type() == typeid(std::pair<float, float>); }
    
};

#endif // DYNAMICPROPERTY_H

#ifndef COLORADD_H
#define COLORADD_H

#include <SDL2/SDL.h>
#include <string>

class Color {
private:
    SDL_Color color;

public:
    // 构造函数
    Color(Uint8 r = 0, Uint8 g = 0, Uint8 b = 0, Uint8 a = 255);
    Color(const SDL_Color& sdlColor);

    // 获取SDL_Color
    SDL_Color get() const;
    std::string gethex() const;

    // 色相操作
    Color& addhue(float step=1.0);
    Color& coloradd(float step=1.0);
    
    void fromhue(int hue);  // RGB颜色从色相中来 
    void setcolor(int hue); //同上
	 
    // 饱和度操作
    Color& addsaturation(float step);
    Color& setsaturation(float sat);
    Color& addsat(float step);
    Color& setsat(float sat);

    // 亮度操作
    Color& addbrightness(float step);
    Color& setbrightness(float bri);
    Color& addbri(float step);
    Color& setbri(float bri);

    // 透明度操作
    Color& addopacity(int step);   //增加不透明度 
    Color& setopacity(int a);     //设定不透明度 

    void rgbToHsv(Uint8 r, Uint8 g, Uint8 b, float& h, float& s, float& v) const;
    void hsvToRgb(float h, float s, float v, Uint8& r, Uint8& g, Uint8& b) const;

};

#endif // COLORADD_H

#ifndef COLOR_MAP_H
#define COLOR_MAP_H

#include <unordered_map>
#include <string>
#include <tuple>
#include <vector>
#include <cstdint>

// 声明全局映射（extern 表示它会在某个 .cpp 文件中定义）
extern int colorStringCacheSize;     //颜色字符串缓存数量 
extern std::vector<std::string> colorStringCache;  //颜色字符串都放在这里了，共140个 
extern std::unordered_map<std::string, std::tuple<int, int, int>> colorNameToRGB;
extern std::unordered_map<std::string, std::string> basic_colors;


#endif // COLOR_MAP_H

此文件非本人开发！

/*******************************************************************************
*                                                                              *
* Author    :  Angus Johnson                                                   *
* Version   :  6.4.2                                                           *
* Date      :  27 February 2017                                                *
* Website   :  http://www.angusj.com                                           *
* Copyright :  Angus Johnson 2010-2017                                         *
*                                                                              *
* License:                                                                     *
* Use, modification & distribution is subject to Boost Software License Ver 1. *
* http://www.boost.org/LICENSE_1_0.txt                                         *
*                                                                              *
* Attributions:                                                                *
* The code in this library is an extension of Bala Vatti's clipping algorithm: *
* "A generic solution to polygon clipping"                                     *
* Communications of the ACM, Vol 35, Issue 7 (July 1992) pp 56-63.             *
* http://portal.acm.org/citation.cfm?id=129906                                 *
*                                                                              *
* Computer graphics and geometric modeling: implementation and algorithms      *
* By Max K. Agoston                                                            *
* Springer; 1 edition (January 4, 2005)                                        *
* http://books.google.com/books?q=vatti+clipping+agoston                       *
*                                                                              *
* See also:                                                                    *
* "Polygon Offsetting by Computing Winding Numbers"                            *
* Paper no. DETC2005-85513 pp. 565-575                                         *
* ASME 2005 International Design Engineering Technical Conferences             *
* and Computers and Information in Engineering Conference (IDETC/CIE2005)      *
* September 24-28, 2005 , Long Beach, California, USA                          *
* http://www.me.berkeley.edu/~mcmains/pubs/DAC05OffsetPolygon.pdf              *
*                                                                              *
*******************************************************************************/

#ifndef clipper_hpp
#define clipper_hpp

#define CLIPPER_VERSION "6.4.2"

//use_int32: When enabled 32bit ints are used instead of 64bit ints. This
//improve performance but coordinate values are limited to the range +/- 46340
//#define use_int32

//use_xyz: adds a Z member to IntPoint. Adds a minor cost to perfomance.
//#define use_xyz

//use_lines: Enables line clipping. Adds a very minor cost to performance.
#define use_lines
  
//use_deprecated: Enables temporary support for the obsolete functions
//#define use_deprecated  

#include <vector>
#include <list>
#include <set>
#include <stdexcept>
#include <cstring>
#include <cstdlib>
#include <ostream>
#include <functional>
#include <queue>

namespace ClipperLib {

enum ClipType { ctIntersection, ctUnion, ctDifference, ctXor };
enum PolyType { ptSubject, ptClip };
//By far the most widely used winding rules for polygon filling are
//EvenOdd & NonZero (GDI, GDI+, XLib, OpenGL, Cairo, AGG, Quartz, SVG, Gr32)
//Others rules include Positive, Negative and ABS_GTR_EQ_TWO (only in OpenGL)
//see http://glprogramming.com/red/chapter11.html
enum PolyFillType { pftEvenOdd, pftNonZero, pftPositive, pftNegative };

#ifdef use_int32
  typedef int cInt;
  static cInt const loRange = 0x7FFF;
  static cInt const hiRange = 0x7FFF;
#else
  typedef signed long long cInt;
  static cInt const loRange = 0x3FFFFFFF;
  static cInt const hiRange = 0x3FFFFFFFFFFFFFFFLL;
  typedef signed long long long64;     //used by Int128 class
  typedef unsigned long long ulong64;

#endif

struct IntPoint {
  cInt X;
  cInt Y;
#ifdef use_xyz
  cInt Z;
  IntPoint(cInt x = 0, cInt y = 0, cInt z = 0): X(x), Y(y), Z(z) {};
#else
  IntPoint(cInt x = 0, cInt y = 0): X(x), Y(y) {};
#endif

  friend inline bool operator== (const IntPoint& a, const IntPoint& b)
  {
    return a.X == b.X && a.Y == b.Y;
  }
  friend inline bool operator!= (const IntPoint& a, const IntPoint& b)
  {
    return a.X != b.X  || a.Y != b.Y; 
  }
};
//------------------------------------------------------------------------------

typedef std::vector< IntPoint > Path;
typedef std::vector< Path > Paths;

inline Path& operator <<(Path& poly, const IntPoint& p) {poly.push_back(p); return poly;}
inline Paths& operator <<(Paths& polys, const Path& p) {polys.push_back(p); return polys;}

std::ostream& operator <<(std::ostream &s, const IntPoint &p);
std::ostream& operator <<(std::ostream &s, const Path &p);
std::ostream& operator <<(std::ostream &s, const Paths &p);

struct DoublePoint
{
  double X;
  double Y;
  DoublePoint(double x = 0, double y = 0) : X(x), Y(y) {}
  DoublePoint(IntPoint ip) : X((double)ip.X), Y((double)ip.Y) {}
};
//------------------------------------------------------------------------------

#ifdef use_xyz
typedef void (*ZFillCallback)(IntPoint& e1bot, IntPoint& e1top, IntPoint& e2bot, IntPoint& e2top, IntPoint& pt);
#endif

enum InitOptions {ioReverseSolution = 1, ioStrictlySimple = 2, ioPreserveCollinear = 4};
enum JoinType {jtSquare, jtRound, jtMiter};
enum EndType {etClosedPolygon, etClosedLine, etOpenButt, etOpenSquare, etOpenRound};

class PolyNode;
typedef std::vector< PolyNode* > PolyNodes;

class PolyNode 
{ 
public:
    PolyNode();
    virtual ~PolyNode(){};
    Path Contour;
    PolyNodes Childs;
    PolyNode* Parent;
    PolyNode* GetNext() const;
    bool IsHole() const;
    bool IsOpen() const;
    int ChildCount() const;
private:
    //PolyNode& operator =(PolyNode& other); 
    unsigned Index; //node index in Parent.Childs
    bool m_IsOpen;
    JoinType m_jointype;
    EndType m_endtype;
    PolyNode* GetNextSiblingUp() const;
    void AddChild(PolyNode& child);
    friend class Clipper; //to access Index
    friend class ClipperOffset; 
};

class PolyTree: public PolyNode
{ 
public:
    ~PolyTree(){ Clear(); };
    PolyNode* GetFirst() const;
    void Clear();
    int Total() const;
private:
  //PolyTree& operator =(PolyTree& other);
  PolyNodes AllNodes;
    friend class Clipper; //to access AllNodes
};

bool Orientation(const Path &poly);
double Area(const Path &poly);
int PointInPolygon(const IntPoint &pt, const Path &path);

void SimplifyPolygon(const Path &in_poly, Paths &out_polys, PolyFillType fillType = pftEvenOdd);
void SimplifyPolygons(const Paths &in_polys, Paths &out_polys, PolyFillType fillType = pftEvenOdd);
void SimplifyPolygons(Paths &polys, PolyFillType fillType = pftEvenOdd);

void CleanPolygon(const Path& in_poly, Path& out_poly, double distance = 1.415);
void CleanPolygon(Path& poly, double distance = 1.415);
void CleanPolygons(const Paths& in_polys, Paths& out_polys, double distance = 1.415);
void CleanPolygons(Paths& polys, double distance = 1.415);

void MinkowskiSum(const Path& pattern, const Path& path, Paths& solution, bool pathIsClosed);
void MinkowskiSum(const Path& pattern, const Paths& paths, Paths& solution, bool pathIsClosed);
void MinkowskiDiff(const Path& poly1, const Path& poly2, Paths& solution);

void PolyTreeToPaths(const PolyTree& polytree, Paths& paths);
void ClosedPathsFromPolyTree(const PolyTree& polytree, Paths& paths);
void OpenPathsFromPolyTree(PolyTree& polytree, Paths& paths);

void ReversePath(Path& p);
void ReversePaths(Paths& p);

struct IntRect { cInt left; cInt top; cInt right; cInt bottom; };

//enums that are used internally ...
enum EdgeSide { esLeft = 1, esRight = 2};

//forward declarations (for stuff used internally) ...
struct TEdge;
struct IntersectNode;
struct LocalMinimum;
struct OutPt;
struct OutRec;
struct Join;

typedef std::vector < OutRec* > PolyOutList;
typedef std::vector < TEdge* > EdgeList;
typedef std::vector < Join* > JoinList;
typedef std::vector < IntersectNode* > IntersectList;

//------------------------------------------------------------------------------

//ClipperBase is the ancestor to the Clipper class. It should not be
//instantiated directly. This class simply abstracts the conversion of sets of
//polygon coordinates into edge objects that are stored in a LocalMinima list.
class ClipperBase
{
public:
  ClipperBase();
  virtual ~ClipperBase();
  virtual bool AddPath(const Path &pg, PolyType PolyTyp, bool Closed);
  bool AddPaths(const Paths &ppg, PolyType PolyTyp, bool Closed);
  virtual void Clear();
  IntRect GetBounds();
  bool PreserveCollinear() {return m_PreserveCollinear;};
  void PreserveCollinear(bool value) {m_PreserveCollinear = value;};
protected:
  void DisposeLocalMinimaList();
  TEdge* AddBoundsToLML(TEdge *e, bool IsClosed);
  virtual void Reset();
  TEdge* ProcessBound(TEdge* E, bool IsClockwise);
  void InsertScanbeam(const cInt Y);
  bool PopScanbeam(cInt &Y);
  bool LocalMinimaPending();
  bool PopLocalMinima(cInt Y, const LocalMinimum *&locMin);
  OutRec* CreateOutRec();
  void DisposeAllOutRecs();
  void DisposeOutRec(PolyOutList::size_type index);
  void SwapPositionsInAEL(TEdge *edge1, TEdge *edge2);
  void DeleteFromAEL(TEdge *e);
  void UpdateEdgeIntoAEL(TEdge *&e);

  typedef std::vector<LocalMinimum> MinimaList;
  MinimaList::iterator m_CurrentLM;
  MinimaList           m_MinimaList;

  bool              m_UseFullRange;
  EdgeList          m_edges;
  bool              m_PreserveCollinear;
  bool              m_HasOpenPaths;
  PolyOutList       m_PolyOuts;
  TEdge           *m_ActiveEdges;

  typedef std::priority_queue<cInt> ScanbeamList;
  ScanbeamList     m_Scanbeam;
};
//------------------------------------------------------------------------------

class Clipper : public virtual ClipperBase
{
public:
  Clipper(int initOptions = 0);
  bool Execute(ClipType clipType,
      Paths &solution,
      PolyFillType fillType = pftEvenOdd);
  bool Execute(ClipType clipType,
      Paths &solution,
      PolyFillType subjFillType,
      PolyFillType clipFillType);
  bool Execute(ClipType clipType,
      PolyTree &polytree,
      PolyFillType fillType = pftEvenOdd);
  bool Execute(ClipType clipType,
      PolyTree &polytree,
      PolyFillType subjFillType,
      PolyFillType clipFillType);
  bool ReverseSolution() { return m_ReverseOutput; };
  void ReverseSolution(bool value) {m_ReverseOutput = value;};
  bool StrictlySimple() {return m_StrictSimple;};
  void StrictlySimple(bool value) {m_StrictSimple = value;};
  //set the callback function for z value filling on intersections (otherwise Z is 0)
#ifdef use_xyz
  void ZFillFunction(ZFillCallback zFillFunc);
#endif
protected:
  virtual bool ExecuteInternal();
private:
  JoinList         m_Joins;
  JoinList         m_GhostJoins;
  IntersectList    m_IntersectList;
  ClipType         m_ClipType;
  typedef std::list<cInt> MaximaList;
  MaximaList       m_Maxima;
  TEdge           *m_SortedEdges;
  bool             m_ExecuteLocked;
  PolyFillType     m_ClipFillType;
  PolyFillType     m_SubjFillType;
  bool             m_ReverseOutput;
  bool             m_UsingPolyTree; 
  bool             m_StrictSimple;
#ifdef use_xyz
  ZFillCallback   m_ZFill; //custom callback 
#endif
  void SetWindingCount(TEdge& edge);
  bool IsEvenOddFillType(const TEdge& edge) const;
  bool IsEvenOddAltFillType(const TEdge& edge) const;
  void InsertLocalMinimaIntoAEL(const cInt botY);
  void InsertEdgeIntoAEL(TEdge *edge, TEdge* startEdge);
  void AddEdgeToSEL(TEdge *edge);
  bool PopEdgeFromSEL(TEdge *&edge);
  void CopyAELToSEL();
  void DeleteFromSEL(TEdge *e);
  void SwapPositionsInSEL(TEdge *edge1, TEdge *edge2);
  bool IsContributing(const TEdge& edge) const;
  bool IsTopHorz(const cInt XPos);
  void DoMaxima(TEdge *e);
  void ProcessHorizontals();
  void ProcessHorizontal(TEdge *horzEdge);
  void AddLocalMaxPoly(TEdge *e1, TEdge *e2, const IntPoint &pt);
  OutPt* AddLocalMinPoly(TEdge *e1, TEdge *e2, const IntPoint &pt);
  OutRec* GetOutRec(int idx);
  void AppendPolygon(TEdge *e1, TEdge *e2);
  void IntersectEdges(TEdge *e1, TEdge *e2, IntPoint &pt);
  OutPt* AddOutPt(TEdge *e, const IntPoint &pt);
  OutPt* GetLastOutPt(TEdge *e);
  bool ProcessIntersections(const cInt topY);
  void BuildIntersectList(const cInt topY);
  void ProcessIntersectList();
  void ProcessEdgesAtTopOfScanbeam(const cInt topY);
  void BuildResult(Paths& polys);
  void BuildResult2(PolyTree& polytree);
  void SetHoleState(TEdge *e, OutRec *outrec);
  void DisposeIntersectNodes();
  bool FixupIntersectionOrder();
  void FixupOutPolygon(OutRec &outrec);
  void FixupOutPolyline(OutRec &outrec);
  bool IsHole(TEdge *e);
  bool FindOwnerFromSplitRecs(OutRec &outRec, OutRec *&currOrfl);
  void FixHoleLinkage(OutRec &outrec);
  void AddJoin(OutPt *op1, OutPt *op2, const IntPoint offPt);
  void ClearJoins();
  void ClearGhostJoins();
  void AddGhostJoin(OutPt *op, const IntPoint offPt);
  bool JoinPoints(Join *j, OutRec* outRec1, OutRec* outRec2);
  void JoinCommonEdges();
  void DoSimplePolygons();
  void FixupFirstLefts1(OutRec* OldOutRec, OutRec* NewOutRec);
  void FixupFirstLefts2(OutRec* InnerOutRec, OutRec* OuterOutRec);
  void FixupFirstLefts3(OutRec* OldOutRec, OutRec* NewOutRec);
#ifdef use_xyz
  void SetZ(IntPoint& pt, TEdge& e1, TEdge& e2);
#endif
};
//------------------------------------------------------------------------------

class ClipperOffset 
{
public:
  ClipperOffset(double miterLimit = 2.0, double roundPrecision = 0.25);
  ~ClipperOffset();
  void AddPath(const Path& path, JoinType joinType, EndType endType);
  void AddPaths(const Paths& paths, JoinType joinType, EndType endType);
  void Execute(Paths& solution, double delta);
  void Execute(PolyTree& solution, double delta);
  void Clear();
  double MiterLimit;
  double ArcTolerance;
private:
  Paths m_destPolys;
  Path m_srcPoly;
  Path m_destPoly;
  std::vector<DoublePoint> m_normals;
  double m_delta, m_sinA, m_sin, m_cos;
  double m_miterLim, m_StepsPerRad;
  IntPoint m_lowest;
  PolyNode m_polyNodes;

  void FixOrientations();
  void DoOffset(double delta);
  void OffsetPoint(int j, int& k, JoinType jointype);
  void DoSquare(int j, int k);
  void DoMiter(int j, int k, double r);
  void DoRound(int j, int k);
};
//------------------------------------------------------------------------------

class clipperException : public std::exception
{
  public:
    clipperException(const char* description): m_descr(description) {}
    virtual ~clipperException() throw() {}
    virtual const char* what() const throw() {return m_descr.c_str();}
  private:
    std::string m_descr;
};
//------------------------------------------------------------------------------

} //ClipperLib namespace

#endif //clipper_hpp

// aboutwindow.h
#ifndef ABOUTWINDOW_H
#define ABOUTWINDOW_H

#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>
#include <SDL2/SDL_ttf.h>
#include <string>

class AboutWindow {
public:
    AboutWindow();
    ~AboutWindow();
    
    // 初始化关于窗口
    bool initialize();
    
    // 显示关于窗口
    void show();
    
    // 隐藏关于窗口
    void hide();
    
    // 处理事件
    void handleEvent(SDL_Event* event); 
    
    // 渲染关于窗口
    void render();
    
    // 检查窗口是否可见
    bool isVisible() const { return m_visible; }
    
    // 设置图片路径
    void setLogoPath(const std::string& path) { m_logoPath = path; }
    void setQrCodePath(const std::string& path) { m_qrCodePath = path; }
    
    // 设置信息文本
    void setInfoText(const std::string& text) { m_infoText = text; }

private:
    // 创建纹理
    SDL_Texture* loadTexture(const std::string& path);
    
    // 字体渲染相关方法
    SDL_Texture* createTextTexture(const std::string& text, SDL_Color color, TTF_Font* font);
    void renderText(const std::string& text, SDL_Color color, TTF_Font* font, int x, int y, bool center = true);
    void renderMultilineText(const std::string& text, SDL_Color color, TTF_Font* font, int x, int y, int lineHeight);
    
    // 加载字体
    TTF_Font* loadFont(const std::string& path, int size);
    
    // 清理资源
    void cleanup();

    bool m_visible;
    SDL_Window* m_window;
    SDL_Renderer* m_renderer;
    
    // 纹理
    SDL_Texture* m_logoTexture;
    SDL_Texture* m_qrCodeTexture;
    
    // 字体
    TTF_Font* m_titleFont;
    TTF_Font* m_textFont;
    TTF_Font* m_smallFont;
    
    // 路径
    std::string m_logoPath;
    std::string m_qrCodePath;
    std::string m_infoText;
    std::string m_windir;
    
    // 窗口尺寸
    static const int WINDOW_WIDTH = 400;
    static const int WINDOW_HEIGHT = 600;
    
    // 颜色常量
    const SDL_Color BG_COLOR = {245, 245, 245, 255};
    const SDL_Color TEXT_COLOR = {50, 50, 50, 255};
    const SDL_Color TITLE_COLOR = {30, 30, 30, 255};
    const SDL_Color ACCENT_COLOR = {70, 130, 180, 255};
};

#endif // ABOUTWINDOW_H

目前正开发一个适合于青少年学习C++计算机语言的C++编辑器,这个编辑器还自带了我自己开发的一个C++图形库,我把它叫sprites库,当然是C++版的。用这个库可以用非常简单的C++代码画漂亮的图形,充份激发青少年儿童学习C++的乐趣 。我给这个编辑器取的英文名字叫:PC++ editor.

PC++的P代表什么含义呢？

p 是 for Primer (启蒙/入门)
寓意: Primer 指的是启蒙读物、入门教材。这直接点明了 PC++ editor 的核心定位——它是青少年学习C++的第一本书，一个完美的编程启蒙工具，让复杂的C++变得像读一本有趣的入门书一样简单。

p 是 for Pencil (铅笔)
寓意: 相比 “Paint”（颜料），“Pencil”（铅笔）更基础、更亲切，是每个孩子都熟悉的绘画工具。它象征着“草稿”、“构思”和“从零开始”，寓意着 PC++ editor 是一个可以轻松勾勒想法、快速实现创意的数字画笔。

p 是 for Plain (朴素/简单)
寓意: “Keep it Plain and Simple.” (保持朴素和简单)。这传达了 PC++ editor 的设计哲学：界面简洁，语法友好，让初学者不被复杂的工具和环境所困扰，专注于编程本身。

p 是 for Power (力量/能力)
寓意: 赋予青少年“编程的力量”。通过 PC++ editor，他们能将脑海中的想法变为现实，这种从无到有的创造过程，本身就是一种强大的能力。

p 是 for player，PC++编辑器就是玩家的编程操场(playground)，它们在这里programming。

p 是 for Plant (播种) ,在青少年心中“播种”下一颗热爱编程的种子。

p 是 for Pioneer (先锋/开拓者)
寓意: 鼓励青少年成为数字世界的“小先锋”。使用 PC++ editor，他们不仅仅是学习一门语言，更是在学习一种创造未来的工具，培养开拓创新的精神。