progs/openvg/demos/lion-render.c

   1 #include "lion-render.h"
   2
   3 #include <stdlib.h>
   4 #include <stdio.h>
   5
   6 #define ELEMENTS(x) (sizeof(x)/sizeof((x)[0]))
   7
   8 static void init(struct lion *l, int i, VGint hexColor, const VGfloat *coords, int elems)
   9 {
  10    static VGubyte cmds[128];
  11    VGfloat color[4];
  12    VGint j;
  13
  14    color[0] = ((hexColor >> 16) & 0xff) / 255.f;
  15    color[1] = ((hexColor >> 8) & 0xff) / 255.f;
  16    color[2] = ((hexColor >> 0) & 0xff) / 255.f;
  17    color[3] = 1.0;
  18
  19    l->paths[i] = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f,
  20                               0, 0, (unsigned int)VG_PATH_CAPABILITY_ALL);
  21    l->fills[i] = vgCreatePaint();
  22    vgSetParameterfv(l->fills[i], VG_PAINT_COLOR, 4, color);
  23
  24    cmds[0] = VG_MOVE_TO_ABS;
  25    for (j = 1; j < elems; ++j) {
  26       cmds[j] = VG_LINE_TO_ABS;
  27    }
  28
  29    vgAppendPathData(l->paths[i], elems, cmds, coords);
  30 }
  31
  32 static void poly0(struct lion *l)
  33 {
  34    VGfloat color = 0xf2cc99;
  35    static const VGfloat coords[] = {69,18, 82,8, 99,3, 118,5, 135,12, 149,21, 156,13, 165,9, 177,13, 183,28,
  36                                     180,50, 164,91, 155,107, 154,114, 151,121, 141,127, 139,136, 155,206, 157,251, 126,342,
  37                                     133,357, 128,376, 83,376, 75,368, 67,350, 61,350, 53,369, 4,369, 2,361, 5,354,
  38                                     12,342, 16,321, 4,257, 4,244, 7,218, 9,179, 26,127, 43,93, 32,77, 30,70,
  39                                     24,67, 16,49, 17,35, 18,23, 30,12, 40,7, 53,7, 62,12
  40    };
  41
  42    init(l, 0, color, coords, ELEMENTS(coords)/2);
  43 }
  44
  45 static void poly1(struct lion *l)
  46 {
  47    VGfloat color = 0xe5b27f;
  48    static const VGfloat coords[] = {142,79, 136,74, 138,82, 133,78, 133,84, 127,78, 128,85,
  49                                     124,80, 125,87, 119,82, 119,90, 125,99, 125,96, 128,100, 128,94,
  50                                     131,98, 132,93, 135,97, 136,93, 138,97, 139,94, 141,98, 143,94,
  51                                     144,85
  52    };
  53
  54    init(l, 1, color, coords, ELEMENTS(coords)/2);
  55 }
  56
  57 static void poly2(struct lion *l)
  58 {
  59    VGfloat color = 0xeb8080;
  60    static const VGfloat coords[] = {127,101, 132,100, 137,99, 144,101, 143,105, 135,110
  61    };
  62
  63    init(l, 2, color, coords, ELEMENTS(coords)/2);
  64 }
  65
  66 static void poly3(struct lion *l)
  67 {
  68    VGfloat color = 0xf2cc99;
  69    static const VGfloat coords[] = {178,229, 157,248, 139,296, 126,349, 137,356,
  70                                     158,357, 183,342, 212,332, 235,288, 235,261,
  71                                     228,252, 212,250, 188,251
  72    };
  73
  74    init(l, 3, color, coords, ELEMENTS(coords)/2);
  75 }
  76
  77 static void poly4(struct lion *l)
  78 {
  79    VGfloat color = 0x9c826b;
  80    static const VGfloat coords[] = {56,229, 48,241, 48,250, 57,281, 63,325, 71,338,
  81                                     81,315, 76,321, 79,311, 83,301, 75,308, 80,298,
  82                                     73,303, 76,296, 71,298, 74,292, 69,293, 74,284,
  83                                     78,278, 71,278, 74,274, 68,273, 70,268, 66,267,
  84                                     68,261, 60,266, 62,259, 65,253, 57,258, 59,251,
  85                                     55,254, 55,248, 60,237, 54,240, 58,234, 54,236
  86    };
  87
  88    init(l, 4, color, coords, ELEMENTS(coords)/2);
  89 }
  90
  91 static void poly5(struct lion *l)
  92 {
  93    VGfloat color = 0x9c826b;
  94    static const VGfloat coords[] = {74,363, 79,368, 81,368, 85,362, 89,363, 92,370, 96,373,
  95                                     101,372, 108,361, 110,371, 113,373, 116,371, 120,358, 122,363,
  96                                     123,371, 126,371, 129,367, 132,357, 135,361, 130,376, 127,377,
  97                                     94,378, 84,376, 76,371
  98    };
  99
 100    init(l, 5, color, coords, ELEMENTS(coords)/2);
 101 }
 102
 103 static void poly6(struct lion *l)
 104 {
 105    VGfloat color = 0x9c826b;
 106    static const VGfloat coords[] = {212,250, 219,251, 228,258, 236,270, 235,287, 225,304,
 107                                     205,332, 177,343, 171,352, 158,357, 166,352, 168,346,
 108                                     168,339, 165,333, 155,327, 155,323, 161,320, 165,316,
 109                                     169,316, 167,312, 171,313, 168,308, 173,309, 170,306,
 110                                     177,306, 175,308, 177,311, 174,311, 176,316, 171,315,
 111                                     174,319, 168,320, 168,323, 175,327, 179,332, 183,326,
 112                                     184,332, 189,323, 190,328, 194,320, 194,325, 199,316,
 113                                     201,320, 204,313, 206,316, 208,310, 211,305, 219,298,
 114                                     226,288, 229,279, 228,266, 224,259, 217,253
 115    };
 116
 117    init(l, 6, color, coords, ELEMENTS(coords)/2);
 118 }
 119
 120 static void poly7(struct lion *l)
 121 {
 122    VGfloat color = 0x9c826b;
 123    static const VGfloat coords[] = {151,205, 151,238, 149,252, 141,268, 128,282, 121,301,
 124                                     130,300, 126,313, 118,324, 116,337, 120,346, 133,352,
 125                                     133,340, 137,333, 145,329, 156,327, 153,319, 153,291,
 126                                     157,271, 170,259, 178,277, 193,250, 174,216
 127    };
 128
 129    init(l, 7, color, coords, ELEMENTS(coords)/2);
 130 }
 131
 132 static void poly8(struct lion *l)
 133 {
 134    VGfloat color = 0x9c826b;
 135    static const VGfloat coords[] = {78,127, 90,142, 95,155, 108,164, 125,167, 139,175,
 136                                     150,206, 152,191, 141,140, 121,148, 100,136
 137    };
 138
 139    init(l, 8, color, coords, ELEMENTS(coords)/2);
 140 }
 141
 142 static void poly9(struct lion *l)
 143 {
 144    VGfloat color = 0x9c826b;
 145    static const VGfloat coords[] = {21,58, 35,63, 38,68, 32,69, 42,74, 40,79, 47,80, 54,83,
 146                                     45,94, 34,81, 32,73, 24,66
 147    };
 148
 149    init(l, 9, color, coords, ELEMENTS(coords)/2);
 150 }
 151
 152 static void poly10(struct lion *l)
 153 {
 154    VGfloat color = 0x9c826b;
 155    static const VGfloat coords[] = {71,34, 67,34, 66,27, 59,24, 54,17, 48,17, 39,22,
 156                                     30,26, 28,31, 31,39, 38,46, 29,45, 36,54, 41,61,
 157                                     41,70, 50,69, 54,71, 55,58, 67,52, 76,43, 76,39,
 158                                     68,44
 159    };
 160
 161    init(l, 10, color, coords, ELEMENTS(coords)/2);
 162 }
 163
 164 static void poly11(struct lion *l)
 165 {
 166    VGfloat color = 0x9c826b;
 167    static const VGfloat coords[] = {139,74, 141,83, 143,89, 144,104, 148,104, 155,106,
 168                                     154,86, 157,77, 155,72, 150,77, 144,77
 169    };
 170
 171    init(l, 11, color, coords, ELEMENTS(coords)/2);
 172 }
 173
 174 static void poly12(struct lion *l)
 175 {
 176    VGfloat color = 0x9c826b;
 177    static const VGfloat coords[] = {105,44, 102,53, 108,58, 111,62, 112,55
 178    };
 179
 180    init(l, 12, color, coords, ELEMENTS(coords)/2);
 181 }
 182
 183 static void poly13(struct lion *l)
 184 {
 185    VGfloat color = 0x9c826b;
 186    static const VGfloat coords[] = {141,48, 141,54, 144,58, 139,62, 137,66, 136,59, 137,52
 187    };
 188
 189    init(l, 13, color, coords, ELEMENTS(coords)/2);
 190 }
 191
 192 static void poly14(struct lion *l)
 193 {
 194    VGfloat color = 0x9c826b;
 195    static const VGfloat coords[] = {98,135, 104,130, 105,134, 108,132, 108,135, 112,134,
 196                                     113,137, 116,136, 116,139, 119,139, 124,141, 128,140,
 197                                     133,138, 140,133, 139,140, 126,146, 104,144
 198    };
 199
 200    init(l, 14, color, coords, ELEMENTS(coords)/2);
 201 }
 202
 203 static void poly15(struct lion *l)
 204 {
 205    VGfloat color = 0x9c826b;
 206    static const VGfloat coords[] = {97,116, 103,119, 103,116, 111,118, 116,117, 122,114,
 207                                     127,107, 135,111, 142,107, 141,114, 145,118, 149,121,
 208                                     145,125, 140,124, 127,121, 113,125, 100,124
 209    };
 210
 211    init(l, 15, color, coords, ELEMENTS(coords)/2);
 212 }
 213
 214 static void poly16(struct lion *l)
 215 {
 216    VGfloat color = 0x9c826b;
 217    static const VGfloat coords[] = {147,33, 152,35, 157,34, 153,31, 160,31, 156,28, 161,28,
 218                                     159,24, 163,25, 163,21, 165,22, 170,23, 167,17, 172,21,
 219                                     174,18, 175,23, 176,22, 177,28, 177,33, 174,37, 176,39,
 220                                     174,44, 171,49, 168,53, 164,57, 159,68, 156,70, 154,60,
 221                                     150,51, 146,43, 144,35
 222    };
 223
 224    init(l, 16, color, coords, ELEMENTS(coords)/2);
 225 }
 226
 227 static void poly17(struct lion *l)
 228 {
 229    VGfloat color = 0x9c826b;
 230    static const VGfloat coords[] = {85,72, 89,74, 93,75, 100,76, 105,75, 102,79, 94,79, 88,76
 231    };
 232
 233    init(l, 17, color, coords, ELEMENTS(coords)/2);
 234 }
 235
 236 static void poly18(struct lion *l)
 237 {
 238    VGfloat color = 0x9c826b;
 239    static const VGfloat coords[] = {86,214, 79,221, 76,232, 82,225, 78,239, 82,234, 78,245,
 240                                     81,243, 79,255, 84,250, 84,267, 87,254, 90,271, 90,257,
 241                                     95,271, 93,256, 95,249, 92,252, 93,243, 89,253, 89,241,
 242                                     86,250, 87,236, 83,245, 87,231, 82,231, 90,219, 84,221
 243    };
 244
 245    init(l, 18, color, coords, ELEMENTS(coords)/2);
 246 }
 247
 248 static void poly19(struct lion *l)
 249 {
 250    VGfloat color = 0xffcc7f;
 251    static const VGfloat coords[] = {93,68, 96,72, 100,73, 106,72, 108,66, 105,63, 100,62
 252    };
 253
 254    init(l, 19, color, coords, ELEMENTS(coords)/2);
 255 }
 256
 257 static void poly20(struct lion *l)
 258 {
 259    VGfloat color = 0xffcc7f;
 260    static const VGfloat coords[] = {144,64, 142,68, 142,73, 146,74, 150,73, 154,64, 149,62
 261    };
 262
 263    init(l, 20, color, coords, ELEMENTS(coords)/2);
 264 }
 265
 266 static void poly21(struct lion *l)
 267 {
 268    VGfloat color = 0x9c826b;
 269    static const VGfloat coords[] = {57,91, 42,111, 52,105, 41,117, 53,112, 46,120, 53,116,
 270                                     50,124, 57,119, 55,127, 61,122, 60,130, 67,126, 66,134,
 271                                     71,129, 72,136, 77,130, 76,137, 80,133, 82,138, 86,135,
 272                                     96,135, 94,129, 86,124, 83,117, 77,123, 79,117, 73,120,
 273                                     75,112, 68,116, 71,111, 65,114, 69,107, 63,110, 68,102,
 274                                     61,107, 66,98, 61,103, 63,97, 57,99
 275    };
 276
 277    init(l, 21, color, coords, ELEMENTS(coords)/2);
 278 }
 279
 280 static void poly22(struct lion *l)
 281 {
 282    VGfloat color = 0x9c826b;
 283    static const VGfloat coords[] = {83,79, 76,79, 67,82, 75,83, 65,88, 76,87, 65,92, 76,91,
 284                                     68,96, 77,95, 70,99, 80,98, 72,104, 80,102, 76,108, 85,103,
 285                                     92,101, 87,98, 93,96, 86,94, 91,93, 85,91, 93,89, 99,89, 105,93,
 286                                     107,85, 102,82, 92,80
 287    };
 288
 289    init(l, 22, color, coords, ELEMENTS(coords)/2);
 290 }
 291
 292 static void poly23(struct lion *l)
 293 {
 294    VGfloat color = 0x9c826b;
 295    static const VGfloat coords[] = {109,77, 111,83, 109,89, 113,94, 117,90, 117,81, 114,78
 296    };
 297
 298    init(l, 23, color, coords, ELEMENTS(coords)/2);
 299 }
 300
 301 static void poly24(struct lion *l)
 302 {
 303    VGfloat color = 0x9c826b;
 304    static const VGfloat coords[] = {122,128, 127,126, 134,127, 136,129, 134,130, 130,128, 124,129
 305    };
 306
 307    init(l, 24, color, coords, ELEMENTS(coords)/2);
 308 }
 309
 310 static void poly25(struct lion *l)
 311 {
 312    VGfloat color = 0x9c826b;
 313    static const VGfloat coords[] = {78,27, 82,32, 80,33, 82,36, 78,37, 82,40, 78,42, 81,46, 76,47,
 314                                     78,49, 74,50, 82,52, 87,50, 83,48, 91,46, 86,45, 91,42, 88,40,
 315                                     92,37, 86,34, 90,31, 86,29, 89,26
 316    };
 317
 318    init(l, 25, color, coords, ELEMENTS(coords)/2);
 319 }
 320
 321 static void poly26(struct lion *l)
 322 {
 323    VGfloat color = 0x9c826b;
 324    static const VGfloat coords[] = {82,17, 92,20, 79,21, 90,25, 81,25, 94,28, 93,26, 101,30,
 325                                     101,26, 107,33, 108,28, 111,40, 113,34, 115,45, 117,39,
 326                                     119,54, 121,46, 124,58, 126,47, 129,59, 130,49, 134,58,
 327                                     133,44, 137,48, 133,37, 137,40, 133,32, 126,20, 135,26,
 328                                     132,19, 138,23, 135,17, 142,18, 132,11, 116,6, 94,6, 78,11,
 329                                     92,12, 80,14, 90,16
 330    };
 331
 332    init(l, 26, color, coords, ELEMENTS(coords)/2);
 333 }
 334
 335 static void poly27(struct lion *l)
 336 {
 337    VGfloat color = 0x9c826b;
 338    static const VGfloat coords[] = {142,234, 132,227, 124,223, 115,220, 110,225, 118,224, 127,229,
 339                                     135,236, 122,234, 115,237, 113,242, 121,238, 139,243, 121,245,
 340                                     111,254, 95,254, 102,244, 104,235, 110,229, 100,231, 104,224,
 341                                     113,216, 122,215, 132,217, 141,224, 145,230, 149,240
 342    };
 343
 344    init(l, 27, color, coords, ELEMENTS(coords)/2);
 345 }
 346
 347 static void poly28(struct lion *l)
 348 {
 349    VGfloat color = 0x9c826b;
 350    static const VGfloat coords[] = {115,252, 125,248, 137,249, 143,258, 134,255, 125,254
 351    };
 352
 353    init(l, 28, color, coords, ELEMENTS(coords)/2);
 354 }
 355
 356 static void poly29(struct lion *l)
 357 {
 358    VGfloat color = 0x9c826b;
 359    static const VGfloat coords[] = {114,212, 130,213, 140,219, 147,225, 144,214, 137,209, 128,207
 360    };
 361
 362    init(l, 29, color, coords, ELEMENTS(coords)/2);
 363 }
 364
 365 static void poly30(struct lion *l)
 366 {
 367    VGfloat color = 0x9c826b;
 368    static const VGfloat coords[] = {102,263, 108,258, 117,257, 131,258, 116,260, 109,265
 369    };
 370
 371    init(l, 30, color, coords, ELEMENTS(coords)/2);
 372 }
 373
 374 static void poly31(struct lion *l)
 375 {
 376    VGfloat color = 0x9c826b;
 377    static const VGfloat coords[] = {51,241, 35,224, 40,238, 23,224, 31,242, 19,239, 28,247, 17,246,
 378                                     25,250, 37,254, 39,263, 44,271, 47,294, 48,317, 51,328, 60,351,
 379                                     60,323, 53,262, 47,246
 380    };
 381
 382    init(l, 31, color, coords, ELEMENTS(coords)/2);
 383 }
 384
 385 static void poly32(struct lion *l)
 386 {
 387    VGfloat color = 0x9c826b;
 388    static const VGfloat coords[] = {2,364, 9,367, 14,366, 18,355, 20,364, 26,366, 31,357, 35,364,
 389                                     39,364, 42,357, 47,363, 53,360, 59,357, 54,369, 7,373
 390    };
 391
 392    init(l, 32, color, coords, ELEMENTS(coords)/2);
 393 }
 394
 395 static void poly33(struct lion *l)
 396 {
 397    VGfloat color = 0x9c826b;
 398    static const VGfloat coords[] = {7,349, 19,345, 25,339, 18,341, 23,333, 28,326, 23,326, 27,320,
 399                                     23,316, 25,311, 20,298, 15,277, 12,264, 9,249, 10,223, 3,248,
 400                                     5,261, 15,307, 17,326, 11,343
 401    };
 402
 403    init(l, 33, color, coords, ELEMENTS(coords)/2);
 404 }
 405
 406 static void poly34(struct lion *l)
 407 {
 408    VGfloat color = 0x9c826b;
 409    static const VGfloat coords[] = {11,226, 15,231, 25,236, 18,227
 410    };
 411
 412    init(l, 34, color, coords, ELEMENTS(coords)/2);
 413 }
 414
 415 static void poly35(struct lion *l)
 416 {
 417    VGfloat color = 0x9c826b;
 418    static const VGfloat coords[] = {13,214, 19,217, 32,227, 23,214, 16,208, 15,190, 24,148,
 419                                     31,121, 24,137, 14,170, 8,189
 420    };
 421
 422    init(l, 35, color, coords, ELEMENTS(coords)/2);
 423 }
 424
 425 static void poly36(struct lion *l)
 426 {
 427    VGfloat color = 0x9c826b;
 428    static const VGfloat coords[] = {202,254, 195,258, 199,260, 193,263, 197,263, 190,268,
 429                                     196,268, 191,273, 188,282, 200,272, 194,272, 201,266,
 430                                     197,265, 204,262, 200,258, 204,256
 431    };
 432
 433    init(l, 36, color, coords, ELEMENTS(coords)/2);
 434 }
 435
 436 static void poly37(struct lion *l)
 437 {
 438    VGfloat color = 0x845433;
 439    static const VGfloat coords[] = {151,213, 165,212, 179,225, 189,246, 187,262, 179,275,
 440                                     176,263, 177,247, 171,233, 163,230, 165,251, 157,264,
 441                                     146,298, 145,321, 133,326, 143,285, 154,260, 153,240
 442    };
 443
 444    init(l, 37, color, coords, ELEMENTS(coords)/2);
 445 }
 446
 447 static void poly38(struct lion *l)
 448 {
 449    VGfloat color = 0x845433;
 450    static const VGfloat coords[] = {91,132, 95,145, 97,154, 104,148, 107,155, 109,150, 111,158,
 451                                     115,152, 118,159, 120,153, 125,161, 126,155, 133,164, 132,154,
 452                                     137,163, 137,152, 142,163, 147,186, 152,192, 148,167, 141,143,
 453                                     124,145, 105,143
 454    };
 455
 456    init(l, 38, color, coords, ELEMENTS(coords)/2);
 457 }
 458
 459 static void poly39(struct lion *l)
 460 {
 461    VGfloat color = 0x9c826b;
 462    static const VGfloat coords[] = {31,57, 23,52, 26,51, 20,44, 23,42, 21,36, 22,29, 25,23,
 463                                     24,32, 30,43, 26,41, 30,50, 26,48
 464    };
 465
 466    init(l, 39, color, coords, ELEMENTS(coords)/2);
 467 }
 468
 469 static void poly40(struct lion *l)
 470 {
 471    VGfloat color = 0x9c826b;
 472    static const VGfloat coords[] = {147,21, 149,28, 155,21, 161,16, 167,14, 175,15, 173,11, 161,9
 473    };
 474
 475    init(l, 40, color, coords, ELEMENTS(coords)/2);
 476 }
 477
 478 static void poly41(struct lion *l)
 479 {
 480    VGfloat color = 0x9c826b;
 481    static const VGfloat coords[] = {181,39, 175,51, 169,57, 171,65, 165,68, 165,75, 160,76,
 482                                     162,91, 171,71, 180,51
 483    };
 484
 485    init(l, 41, color, coords, ELEMENTS(coords)/2);
 486 }
 487
 488 static void poly42(struct lion *l)
 489 {
 490    VGfloat color = 0x9c826b;
 491    static const VGfloat coords[] = {132,346, 139,348, 141,346, 142,341, 147,342, 143,355, 133,350
 492    };
 493
 494    init(l, 42, color, coords, ELEMENTS(coords)/2);
 495 }
 496
 497 static void poly43(struct lion *l)
 498 {
 499    VGfloat color = 0x9c826b;
 500    static const VGfloat coords[] = {146,355, 151,352, 155,348, 157,343, 160,349, 151,356, 147,357
 501    };
 502
 503    init(l, 43, color, coords, ELEMENTS(coords)/2);
 504 }
 505
 506 static void poly44(struct lion *l)
 507 {
 508    VGfloat color = 0x9c826b;
 509    static const VGfloat coords[] = {99,266, 100,281, 94,305, 86,322, 78,332, 72,346, 73,331, 91,291
 510    };
 511
 512    init(l, 44, color, coords, ELEMENTS(coords)/2);
 513 }
 514
 515 static void poly45(struct lion *l)
 516 {
 517    VGfloat color = 0x9c826b;
 518    static const VGfloat coords[] = {20,347, 32,342, 45,340, 54,345, 45,350, 42,353, 38,350,
 519                                     31,353, 29,356, 23,350, 19,353, 15,349
 520    };
 521
 522    init(l, 45, color, coords, ELEMENTS(coords)/2);
 523 }
 524
 525 static void poly46(struct lion *l)
 526 {
 527    VGfloat color = 0x9c826b;
 528    static const VGfloat coords[] = {78,344, 86,344, 92,349, 88,358, 84,352
 529    };
 530
 531    init(l, 46, color, coords, ELEMENTS(coords)/2);
 532 }
 533
 534 static void poly47(struct lion *l)
 535 {
 536    VGfloat color = 0x9c826b;
 537    static const VGfloat coords[] = {93,347, 104,344, 117,345, 124,354, 121,357, 116,351,
 538                                     112,351, 108,355, 102,351
 539    };
 540
 541    init(l, 47, color, coords, ELEMENTS(coords)/2);
 542 }
 543
 544 static void poly48(struct lion *l)
 545 {
 546    VGfloat color = 0x000000;
 547    static const VGfloat coords[] = {105,12, 111,18, 113,24, 113,29, 119,34, 116,23, 112,16
 548    };
 549
 550    init(l, 48, color, coords, ELEMENTS(coords)/2);
 551 }
 552
 553 static void poly49(struct lion *l)
 554 {
 555    VGfloat color = 0x000000;
 556    static const VGfloat coords[] = {122,27, 125,34, 127,43, 128,34, 125,29
 557    };
 558
 559    init(l, 49, color, coords, ELEMENTS(coords)/2);
 560 }
 561
 562 static void poly50(struct lion *l)
 563 {
 564    VGfloat color = 0x000000;
 565    static const VGfloat coords[] = {115,13, 122,19, 122,15, 113,10
 566    };
 567
 568    init(l, 50, color, coords, ELEMENTS(coords)/2);
 569 }
 570
 571 static void poly51(struct lion *l)
 572 {
 573    VGfloat color = 0xffe5b2;
 574    static const VGfloat coords[] = {116,172, 107,182, 98,193, 98,183, 90,199, 89,189, 84,207,
 575                                     88,206, 87,215, 95,206, 93,219, 91,230, 98,216, 97,226,
 576                                     104,214, 112,209, 104,208, 113,202, 126,200, 139,207, 132,198,
 577                                     142,203, 134,192, 142,195, 134,187, 140,185, 130,181, 136,177,
 578                                     126,177, 125,171, 116,180
 579    };
 580
 581    init(l, 51, color, coords, ELEMENTS(coords)/2);
 582 }
 583
 584 static void poly52(struct lion *l)
 585 {
 586    VGfloat color = 0xffe5b2;
 587    static const VGfloat coords[] = {74,220, 67,230, 67,221, 59,235, 63,233, 60,248, 70,232, 65,249,
 588                                     71,243, 67,256, 73,250, 69,262, 73,259, 71,267, 76,262, 72,271,
 589                                     78,270, 76,275, 82,274, 78,290, 86,279, 86,289, 92,274, 88,275,
 590                                     87,264, 82,270, 82,258, 77,257, 78,247, 73,246, 77,233, 72,236
 591    };
 592
 593    init(l, 52, color, coords, ELEMENTS(coords)/2);
 594 }
 595
 596 static void poly53(struct lion *l)
 597 {
 598    VGfloat color = 0xffe5b2;
 599    static const VGfloat coords[] = {133,230, 147,242, 148,250, 145,254, 138,247, 129,246, 142,245,
 600                                     138,241, 128,237, 137,238
 601    };
 602
 603    init(l, 53, color, coords, ELEMENTS(coords)/2);
 604 }
 605
 606 static void poly54(struct lion *l)
 607 {
 608    VGfloat color = 0xffe5b2;
 609    static const VGfloat coords[] = {133,261, 125,261, 116,263, 111,267, 125,265
 610    };
 611
 612    init(l, 54, color, coords, ELEMENTS(coords)/2);
 613 }
 614
 615 static void poly55(struct lion *l)
 616 {
 617    VGfloat color = 0xffe5b2;
 618    static const VGfloat coords[] = {121,271, 109,273, 103,279, 99,305, 92,316, 85,327, 83,335,
 619                                     89,340, 97,341, 94,336, 101,336, 96,331, 103,330, 97,327, 108,325,
 620                                     99,322, 109,321, 100,318, 110,317, 105,314, 110,312, 107,310, 113,308,
 621                                     105,306, 114,303, 105,301, 115,298, 107,295, 115,294, 108,293, 117,291,
 622                                     109,289, 117,286, 109,286, 118,283, 112,281, 118,279, 114,278,
 623                                     119,276, 115,274
 624    };
 625
 626    init(l, 55, color, coords, ELEMENTS(coords)/2);
 627 }
 628
 629 static void poly56(struct lion *l)
 630 {
 631    VGfloat color = 0xffe5b2;
 632    static const VGfloat coords[] = {79,364, 74,359, 74,353, 76,347, 80,351, 83,356, 82,360
 633    };
 634
 635    init(l, 56, color, coords, ELEMENTS(coords)/2);
 636 }
 637
 638 static void poly57(struct lion *l)
 639 {
 640    VGfloat color = 0xffe5b2;
 641    static const VGfloat coords[] = {91,363, 93,356, 97,353, 103,355, 105,360, 103,366, 99,371, 94,368
 642    };
 643
 644    init(l, 57, color, coords, ELEMENTS(coords)/2);
 645 }
 646
 647 static void poly58(struct lion *l)
 648 {
 649    VGfloat color = 0xffe5b2;
 650    static const VGfloat coords[] = {110,355, 114,353, 118,357, 117,363, 113,369, 111,362
 651    };
 652
 653    init(l, 58, color, coords, ELEMENTS(coords)/2);
 654 }
 655
 656 static void poly59(struct lion *l)
 657 {
 658    VGfloat color = 0xffe5b2;
 659    static const VGfloat coords[] = {126,354, 123,358, 124,367, 126,369, 129,361, 129,357
 660    };
 661
 662    init(l, 59, color, coords, ELEMENTS(coords)/2);
 663 }
 664
 665 static void poly60(struct lion *l)
 666 {
 667    VGfloat color = 0xffe5b2;
 668    static const VGfloat coords[] = {30,154, 24,166, 20,182, 23,194, 29,208, 37,218, 41,210, 41,223,
 669                                     46,214, 46,227, 52,216, 52,227, 61,216, 59,225, 68,213, 73,219,
 670                                     70,207, 77,212, 69,200, 77,202, 70,194, 78,197, 68,187, 76,182,
 671                                     64,182, 58,175, 58,185, 53,177, 50,186, 46,171, 44,182, 39,167,
 672                                     36,172, 36,162, 30,166
 673    };
 674
 675    init(l, 60, color, coords, ELEMENTS(coords)/2);
 676 }
 677
 678 static void poly61(struct lion *l)
 679 {
 680    VGfloat color = 0xffe5b2;
 681    static const VGfloat coords[] = {44,130, 41,137, 45,136, 43,150, 48,142, 48,157, 53,150,
 682                                     52,164, 60,156, 61,169, 64,165, 66,175, 70,167, 74,176,
 683                                     77,168, 80,183, 85,172, 90,182, 93,174, 98,181, 99,173,
 684                                     104,175, 105,169, 114,168, 102,163, 95,157, 94,166, 90,154,
 685                                     87,162, 82,149, 75,159, 72,148, 68,155, 67,143, 62,148, 62,138,
 686                                     58,145, 56,133, 52,142, 52,128, 49,134, 47,125
 687    };
 688
 689    init(l, 61, color, coords, ELEMENTS(coords)/2);
 690 }
 691
 692 static void poly62(struct lion *l)
 693 {
 694    VGfloat color = 0xffe5b2;
 695    static const VGfloat coords[] = {13,216, 19,219, 36,231, 22,223, 16,222, 22,227, 12,224, 13,220, 16,220
 696    };
 697
 698    init(l, 62, color, coords, ELEMENTS(coords)/2);
 699 }
 700
 701 static void poly63(struct lion *l)
 702 {
 703    VGfloat color = 0xffe5b2;
 704    static const VGfloat coords[] = {10,231, 14,236, 25,239, 27,237, 19,234
 705    };
 706
 707    init(l, 63, color, coords, ELEMENTS(coords)/2);
 708 }
 709
 710 static void poly64(struct lion *l)
 711 {
 712    VGfloat color = 0xffe5b2;
 713    static const VGfloat coords[] = {9,245, 14,242, 25,245, 13,245
 714    };
 715
 716    init(l, 64, color, coords, ELEMENTS(coords)/2);
 717 }
 718
 719 static void poly65(struct lion *l)
 720 {
 721    VGfloat color = 0xffe5b2;
 722    static const VGfloat coords[] = {33,255, 26,253, 18,254, 25,256, 18,258, 27,260, 18,263,
 723                                     27,265, 19,267, 29,270, 21,272, 29,276, 21,278, 30,281,
 724                                     22,283, 31,287, 24,288, 32,292, 23,293, 34,298, 26,299,
 725                                     37,303, 32,305, 39,309, 33,309, 39,314, 34,314, 40,318,
 726                                     34,317, 40,321, 34,321, 41,326, 33,326, 40,330, 33,332,
 727                                     39,333, 33,337, 42,337, 54,341, 49,337, 52,335, 47,330,
 728                                     50,330, 45,325, 49,325, 45,321, 48,321, 45,316, 46,306,
 729                                     45,286, 43,274, 36,261
 730    };
 731
 732    init(l, 65, color, coords, ELEMENTS(coords)/2);
 733 }
 734
 735 static void poly66(struct lion *l)
 736 {
 737    VGfloat color = 0xffe5b2;
 738    static const VGfloat coords[] = {7,358, 9,351, 14,351, 17,359, 11,364
 739    };
 740
 741    init(l, 66, color, coords, ELEMENTS(coords)/2);
 742 }
 743
 744 static void poly67(struct lion *l)
 745 {
 746    VGfloat color = 0xffe5b2;
 747    static const VGfloat coords[] = {44,354, 49,351, 52,355, 49,361
 748    };
 749
 750    init(l, 67, color, coords, ELEMENTS(coords)/2);
 751 }
 752
 753 static void poly68(struct lion *l)
 754 {
 755    VGfloat color = 0xffe5b2;
 756    static const VGfloat coords[] = {32,357, 37,353, 40,358, 36,361
 757    };
 758
 759    init(l, 68, color, coords, ELEMENTS(coords)/2);
 760 }
 761
 762 static void poly69(struct lion *l)
 763 {
 764    VGfloat color = 0xffe5b2;
 765    static const VGfloat coords[] = {139,334, 145,330, 154,330, 158,334, 154,341, 152,348,
 766                                     145,350, 149,340, 147,336, 141,339, 139,345, 136,342,
 767                                     136,339
 768    };
 769
 770    init(l, 69, color, coords, ELEMENTS(coords)/2);
 771 }
 772
 773 static void poly70(struct lion *l)
 774 {
 775    VGfloat color = 0xffe5b2;
 776    static const VGfloat coords[] = {208,259, 215,259, 212,255, 220,259, 224,263, 225,274, 224,283,
 777                                     220,292, 208,300, 206,308, 203,304, 199,315, 197,309, 195,318,
 778                                     193,313, 190,322, 190,316, 185,325, 182,318, 180,325, 172,321,
 779                                     178,320, 176,313, 186,312, 180,307, 188,307, 184,303, 191,302,
 780                                     186,299, 195,294, 187,290, 197,288, 192,286, 201,283, 194,280,
 781                                     203,277, 198,275, 207,271, 200,269, 209,265, 204,265, 212,262
 782    };
 783
 784    init(l, 70, color, coords, ELEMENTS(coords)/2);
 785 }
 786
 787 static void poly71(struct lion *l)
 788 {
 789    VGfloat color = 0xffe5b2;
 790    static const VGfloat coords[] = {106,126, 106,131, 109,132, 111,134, 115,132, 115,135, 119,133, 118,137,
 791                                     123,137, 128,137, 133,134, 136,130, 136,127, 132,124, 118,128, 112,128,
 792                                     106,126, 106,126, 106,126
 793    };
 794
 795    init(l, 71, color, coords, ELEMENTS(coords)/2);
 796 }
 797
 798 static void poly72(struct lion *l)
 799 {
 800    VGfloat color = 0xffe5b2;
 801    static const VGfloat coords[] = {107,114, 101,110, 98,102, 105,97, 111,98, 119,102, 121,108, 118,112, 113,115
 802    };
 803
 804    init(l, 72, color, coords, ELEMENTS(coords)/2);
 805 }
 806
 807 static void poly73(struct lion *l)
 808 {
 809    VGfloat color = 0xffe5b2;
 810    static const VGfloat coords[] = {148,106, 145,110, 146,116, 150,118, 152,111, 151,107
 811    };
 812
 813    init(l, 73, color, coords, ELEMENTS(coords)/2);
 814 }
 815
 816 static void poly74(struct lion *l)
 817 {
 818    VGfloat color = 0xffe5b2;
 819    static const VGfloat coords[] = {80,55, 70,52, 75,58, 63,57, 72,61, 57,61, 67,66, 57,67, 62,69, 54,71,
 820                                     61,73, 54,77, 63,78, 53,85, 60,84, 56,90, 69,84, 63,82, 75,76, 70,75,
 821                                     77,72, 72,71, 78,69, 72,66, 81,67, 78,64, 82,63, 80,60, 86,62
 822    };
 823
 824    init(l, 74, color, coords, ELEMENTS(coords)/2);
 825 }
 826
 827 static void poly75(struct lion *l)
 828 {
 829    VGfloat color = 0xffe5b2;
 830    static const VGfloat coords[] = {87,56, 91,52, 96,50, 102,56, 98,56, 92,60
 831    };
 832
 833    init(l, 75, color, coords, ELEMENTS(coords)/2);
 834 }
 835
 836 static void poly76(struct lion *l)
 837 {
 838    VGfloat color = 0xffe5b2;
 839    static const VGfloat coords[] = {85,68, 89,73, 98,76, 106,74, 96,73, 91,70
 840    };
 841
 842    init(l, 76, color, coords, ELEMENTS(coords)/2);
 843 }
 844
 845 static void poly77(struct lion *l)
 846 {
 847    VGfloat color = 0xffe5b2;
 848    static const VGfloat coords[] = {115,57, 114,64, 111,64, 115,75, 122,81, 122,74, 126,79,
 849                                     126,74, 131,78, 130,72, 133,77, 131,68, 126,61, 119,57
 850    };
 851
 852    init(l, 77, color, coords, ELEMENTS(coords)/2);
 853 }
 854
 855 static void poly78(struct lion *l)
 856 {
 857    VGfloat color = 0xffe5b2;
 858    static const VGfloat coords[] = {145,48, 143,53, 147,59, 151,59, 150,55
 859    };
 860
 861    init(l, 78, color, coords, ELEMENTS(coords)/2);
 862 }
 863
 864 static void poly79(struct lion *l)
 865 {
 866    VGfloat color = 0xffe5b2;
 867    static const VGfloat coords[] = {26,22, 34,15, 43,10, 52,10, 59,16, 47,15, 32,22
 868    };
 869
 870    init(l, 79, color, coords, ELEMENTS(coords)/2);
 871 }
 872
 873 static void poly80(struct lion *l)
 874 {
 875    VGfloat color = 0xffe5b2;
 876    static const VGfloat coords[] = {160,19, 152,26, 149,34, 154,33, 152,30, 157,30, 155,26, 158,27,
 877                                     157,23, 161,23
 878    };
 879
 880    init(l, 80, color, coords, ELEMENTS(coords)/2);
 881 }
 882
 883 static void poly81(struct lion *l)
 884 {
 885    VGfloat color = 0x000000;
 886    static const VGfloat coords[] = {98,117, 105,122, 109,122, 105,117, 113,120, 121,120, 130,112, 128,108,
 887                                     123,103, 123,99, 128,101, 132,106, 135,109, 142,105, 142,101, 145,101,
 888                                     145,91, 148,101, 145,105, 136,112, 135,116, 143,124, 148,120, 150,122,
 889                                     142,128, 133,122, 121,125, 112,126, 103,125, 100,129, 96,124
 890    };
 891
 892    init(l, 81, color, coords, ELEMENTS(coords)/2);
 893 }
 894
 895 static void poly82(struct lion *l)
 896 {
 897    VGfloat color = 0x000000;
 898    static const VGfloat coords[] = {146,118, 152,118, 152,115, 149,115
 899    };
 900
 901    init(l, 82, color, coords, ELEMENTS(coords)/2);
 902 }
 903
 904 static void poly83(struct lion *l)
 905 {
 906    VGfloat color = 0x000000;
 907    static const VGfloat coords[] = {148,112, 154,111, 154,109, 149,109
 908    };
 909
 910    init(l, 83, color, coords, ELEMENTS(coords)/2);
 911 }
 912
 913 static void poly84(struct lion *l)
 914 {
 915    VGfloat color = 0x000000;
 916    static const VGfloat coords[] = {106,112, 108,115, 114,116, 118,114
 917    };
 918
 919    init(l, 84, color, coords, ELEMENTS(coords)/2);
 920 }
 921
 922 static void poly85(struct lion *l)
 923 {
 924    VGfloat color = 0x000000;
 925    static const VGfloat coords[] = {108,108, 111,110, 116,110, 119,108
 926    };
 927
 928    init(l, 85, color, coords, ELEMENTS(coords)/2);
 929 }
 930
 931 static void poly86(struct lion *l)
 932 {
 933    VGfloat color = 0x000000;
 934    static const VGfloat coords[] = {106,104, 109,105, 117,106, 115,104
 935    };
 936
 937    init(l, 86, color, coords, ELEMENTS(coords)/2);
 938 }
 939
 940 static void poly87(struct lion *l)
 941 {
 942    VGfloat color = 0x000000;
 943    static const VGfloat coords[] = {50,25, 41,26, 34,33, 39,43, 49,58, 36,51, 47,68, 55,69, 54,59,
 944                                     61,57, 74,46, 60,52, 67,42, 57,48, 61,40, 54,45, 60,36, 59,29,
 945                                     48,38, 52,30, 47,32
 946    };
 947
 948    init(l, 87, color, coords, ELEMENTS(coords)/2);
 949 }
 950
 951 static void poly88(struct lion *l)
 952 {
 953    VGfloat color = 0x000000;
 954    static const VGfloat coords[] = {147,34, 152,41, 155,49, 161,53, 157,47, 164,47, 158,43, 168,44,
 955                                     159,40, 164,37, 169,37, 164,33, 169,34, 165,28, 170,30, 170,25,
 956                                     173,29, 175,27, 176,32, 173,36, 175,39, 172,42, 172,46, 168,49,
 957                                     170,55, 162,57, 158,63, 155,58, 153,50, 149,46
 958    };
 959
 960    init(l, 88, color, coords, ELEMENTS(coords)/2);
 961 }
 962
 963 static void poly89(struct lion *l)
 964 {
 965    VGfloat color = 0x000000;
 966    static const VGfloat coords[] = {155,71, 159,80, 157,93, 157,102, 155,108, 150,101, 149,93,
 967                                     154,101, 152,91, 151,83, 155,79
 968    };
 969
 970    init(l, 89, color, coords, ELEMENTS(coords)/2);
 971 }
 972
 973 static void poly90(struct lion *l)
 974 {
 975    VGfloat color = 0x000000;
 976    static const VGfloat coords[] = {112,78, 115,81, 114,91, 112,87, 113,82
 977    };
 978
 979    init(l, 90, color, coords, ELEMENTS(coords)/2);
 980 }
 981
 982 static void poly91(struct lion *l)
 983 {
 984    VGfloat color = 0x000000;
 985    static const VGfloat coords[] = {78,28, 64,17, 58,11, 47,9, 36,10, 28,16, 21,26, 18,41,
 986                                     20,51, 23,61, 33,65, 28,68, 37,74, 36,81, 43,87, 48,90,
 987                                     43,100, 40,98, 39,90, 31,80, 30,72, 22,71, 17,61, 14,46,
 988                                     16,28, 23,17, 33,9, 45,6, 54,6, 65,12
 989    };
 990
 991    init(l, 91, color, coords, ELEMENTS(coords)/2);
 992 }
 993
 994 static void poly92(struct lion *l)
 995 {
 996    VGfloat color = 0x000000;
 997    static const VGfloat coords[] = {67,18, 76,9, 87,5, 101,2, 118,3, 135,8, 149,20, 149,26,
 998                                     144,19, 132,12, 121,9, 105,7, 89,8, 76,14, 70,20
 999    };
1000
1001    init(l, 92, color, coords, ELEMENTS(coords)/2);
1002 }
1003
1004 static void poly93(struct lion *l)
1005 {
1006    VGfloat color = 0x000000;
1007    static const VGfloat coords[] = {56,98, 48,106, 56,103, 47,112, 56,110, 52,115, 57,113, 52,121, 62,115,
1008                                     58,123, 65,119, 63,125, 69,121, 68,127, 74,125, 74,129, 79,128, 83,132,
1009                                     94,135, 93,129, 85,127, 81,122, 76,126, 75,121, 71,124, 71,117, 66,121,
1010                                     66,117, 62,117, 64,112, 60,113, 60,110, 57,111, 61,105, 57,107, 60,101,
1011                                     55,102
1012    };
1013
1014    init(l, 93, color, coords, ELEMENTS(coords)/2);
1015 }
1016
1017 static void poly94(struct lion *l)
1018 {
1019    VGfloat color = 0x000000;
1020    static const VGfloat coords[] = {101,132, 103,138, 106,134, 106,139, 112,136, 111,142, 115,139,
1021                                     114,143, 119,142, 125,145, 131,142, 135,138, 140,134, 140,129,
1022                                     143,135, 145,149, 150,171, 149,184, 145,165, 141,150, 136,147,
1023                                     132,151, 131,149, 126,152, 125,150, 121,152, 117,148, 111,152,
1024                                     110,148, 105,149, 104,145, 98,150, 96,138, 94,132, 94,130, 98,132
1025    };
1026
1027    init(l, 94, color, coords, ELEMENTS(coords)/2);
1028 }
1029
1030 static void poly95(struct lion *l)
1031 {
1032    VGfloat color = 0x000000;
1033    static const VGfloat coords[] = {41,94, 32,110, 23,132, 12,163, 6,190, 7,217, 5,236,
1034                                     3,247, 9,230, 12,211, 12,185, 18,160, 26,134, 35,110,
1035                                     43,99
1036    };
1037
1038    init(l, 95, color, coords, ELEMENTS(coords)/2);
1039 }
1040
1041 static void poly96(struct lion *l)
1042 {
1043    VGfloat color = 0x000000;
1044    static const VGfloat coords[] = {32,246, 41,250, 50,257, 52,267, 53,295, 53,323, 59,350,
1045                                     54,363, 51,365, 44,366, 42,360, 40,372, 54,372, 59,366,
1046                                     62,353, 71,352, 75,335, 73,330, 66,318, 68,302, 64,294,
1047                                     67,288, 63,286, 63,279, 59,275, 58,267, 56,262, 50,247,
1048                                     42,235, 44,246, 32,236, 35,244
1049    };
1050
1051    init(l, 96, color, coords, ELEMENTS(coords)/2);
1052 }
1053
1054 static void poly97(struct lion *l)
1055 {
1056    VGfloat color = 0x000000;
1057    static const VGfloat coords[] = {134,324, 146,320, 159,322, 173,327, 179,337, 179,349,
1058                                     172,355, 158,357, 170,350, 174,343, 170,333, 163,328, 152,326,
1059                                     134,329
1060    };
1061
1062    init(l, 97, color, coords, ELEMENTS(coords)/2);
1063 }
1064
1065 static void poly98(struct lion *l)
1066 {
1067    VGfloat color = 0x000000;
1068    static const VGfloat coords[] = {173,339, 183,334, 184,338, 191,329, 194,332, 199,323, 202,325,
1069                                     206,318, 209,320, 213,309, 221,303, 228,296, 232,289, 234,279,
1070                                     233,269, 230,262, 225,256, 219,253, 208,252, 198,252, 210,249,
1071                                     223,250, 232,257, 237,265, 238,277, 238,291, 232,305, 221,323,
1072                                     218,335, 212,342, 200,349, 178,348
1073    };
1074
1075    init(l, 98, color, coords, ELEMENTS(coords)/2);
1076 }
1077
1078 static void poly99(struct lion *l)
1079 {
1080    VGfloat color = 0x000000;
1081    static const VGfloat coords[] = {165,296, 158,301, 156,310, 156,323, 162,324, 159,318,
1082                                     162,308, 162,304
1083    };
1084
1085    init(l, 99, color, coords, ELEMENTS(coords)/2);
1086 }
1087
1088 static void poly100(struct lion *l)
1089 {
1090    VGfloat color = 0x000000;
1091    static const VGfloat coords[] = {99,252, 105,244, 107,234, 115,228, 121,228, 131,235,
1092                                     122,233, 113,235, 109,246, 121,239, 133,243, 121,243,
1093                                     110,251
1094    };
1095
1096    init(l, 100, color, coords, ELEMENTS(coords)/2);
1097 }
1098
1099 static void poly101(struct lion *l)
1100 {
1101    VGfloat color = 0x000000;
1102    static const VGfloat coords[] = {117,252, 124,247, 134,249, 136,253, 126,252
1103    };
1104
1105    init(l, 101, color, coords, ELEMENTS(coords)/2);
1106 }
1107
1108 static void poly102(struct lion *l)
1109 {
1110    VGfloat color = 0x000000;
1111    static const VGfloat coords[] = {117,218, 132,224, 144,233, 140,225, 132,219, 117,218,
1112                                     117,218, 117,218
1113    };
1114
1115    init(l, 102, color, coords, ELEMENTS(coords)/2);
1116 }
1117
1118 static void poly103(struct lion *l)
1119 {
1120    VGfloat color = 0x000000;
1121    static const VGfloat coords[] = {122,212, 134,214, 143,221, 141,213, 132,210
1122    };
1123
1124    init(l, 103, color, coords, ELEMENTS(coords)/2);
1125 }
1126
1127 static void poly104(struct lion *l)
1128 {
1129    VGfloat color = 0x000000;
1130    static const VGfloat coords[] = {69,352, 70,363, 76,373, 86,378, 97,379, 108,379, 120,377,
1131                                     128,378, 132,373, 135,361, 133,358, 132,366, 127,375, 121,374,
1132                                     121,362, 119,367, 117,374, 110,376, 110,362, 107,357, 106,371,
1133                                     104,375, 97,376, 90,375, 90,368, 86,362, 83,364, 86,369, 85,373,
1134                                     78,370, 73,362, 71,351
1135    };
1136
1137    init(l, 104, color, coords, ELEMENTS(coords)/2);
1138 }
1139
1140 static void poly105(struct lion *l)
1141 {
1142    VGfloat color = 0x000000;
1143    static const VGfloat coords[] = {100,360, 96,363, 99,369, 102,364
1144    };
1145
1146    init(l, 105, color, coords, ELEMENTS(coords)/2);
1147 }
1148
1149 static void poly106(struct lion *l)
1150 {
1151    VGfloat color = 0x000000;
1152    static const VGfloat coords[] = {115,360, 112,363, 114,369, 117,364
1153    };
1154
1155    init(l, 106, color, coords, ELEMENTS(coords)/2);
1156 }
1157
1158 static void poly107(struct lion *l)
1159 {
1160    VGfloat color = 0x000000;
1161    static const VGfloat coords[] = {127,362, 125,364, 126,369, 128,365
1162    };
1163
1164    init(l, 107, color, coords, ELEMENTS(coords)/2);
1165 }
1166
1167 static void poly108(struct lion *l)
1168 {
1169    VGfloat color = 0x000000;
1170    static const VGfloat coords[] = {5,255, 7,276, 11,304, 15,320, 13,334, 6,348, 2,353, 0,363,
1171                                     5,372, 12,374, 25,372, 38,372, 44,369, 42,367, 36,368, 31,369,
1172                                     30,360, 27,368, 20,370, 16,361, 15,368, 10,369, 3,366, 3,359, 6,352,
1173                                     11,348, 17,331, 19,316, 12,291, 9,274
1174    };
1175
1176    init(l, 108, color, coords, ELEMENTS(coords)/2);
1177 }
1178
1179 static void poly109(struct lion *l)
1180 {
1181    VGfloat color = 0x000000;
1182    static const VGfloat coords[] = {10,358, 7,362, 10,366, 11,362
1183    };
1184
1185    init(l, 109, color, coords, ELEMENTS(coords)/2);
1186 }
1187
1188 static void poly110(struct lion *l)
1189 {
1190    VGfloat color = 0x000000;
1191    static const VGfloat coords[] = {25,357, 22,360, 24,366, 27,360
1192    };
1193
1194    init(l, 110, color, coords, ELEMENTS(coords)/2);
1195 }
1196
1197 static void poly111(struct lion *l)
1198 {
1199    VGfloat color = 0x000000;
1200    static const VGfloat coords[] = {37,357, 34,361, 36,365, 38,361
1201    };
1202
1203    init(l, 111, color, coords, ELEMENTS(coords)/2);
1204 }
1205
1206 static void poly112(struct lion *l)
1207 {
1208    VGfloat color = 0x000000;
1209    static const VGfloat coords[] = {49,356, 46,359, 47,364, 50,360
1210    };
1211
1212    init(l, 112, color, coords, ELEMENTS(coords)/2);
1213 }
1214
1215 static void poly113(struct lion *l)
1216 {
1217    VGfloat color = 0x000000;
1218    static const VGfloat coords[] = {130,101, 132,102, 135,101, 139,102, 143,103,
1219                                     142,101, 137,100, 133,100
1220    };
1221
1222    init(l, 113, color, coords, ELEMENTS(coords)/2);
1223 }
1224
1225 static void poly114(struct lion *l)
1226 {
1227    VGfloat color = 0x000000;
1228    static const VGfloat coords[] = {106,48, 105,52, 108,56, 109,52
1229    };
1230
1231    init(l, 114, color, coords, ELEMENTS(coords)/2);
1232 }
1233
1234 static void poly115(struct lion *l)
1235 {
1236    VGfloat color = 0x000000;
1237    static const VGfloat coords[] = {139,52, 139,56, 140,60, 142,58, 141,56
1238    };
1239
1240    init(l, 115, color, coords, ELEMENTS(coords)/2);
1241 }
1242
1243 static void poly116(struct lion *l)
1244 {
1245    VGfloat color = 0x000000;
1246    static const VGfloat coords[] = {25,349, 29,351, 30,355, 33,350, 37,348, 42,351, 45,347,
1247                                     49,345, 44,343, 36,345
1248    };
1249
1250    init(l, 116, color, coords, ELEMENTS(coords)/2);
1251 }
1252
1253 static void poly117(struct lion *l)
1254 {
1255    VGfloat color = 0x000000;
1256    static const VGfloat coords[] = {98,347, 105,351, 107,354, 109,349, 115,349, 120,353, 118,349,
1257                                     113,346, 104,346
1258    };
1259
1260    init(l, 117, color, coords, ELEMENTS(coords)/2);
1261 }
1262
1263 static void poly118(struct lion *l)
1264 {
1265    VGfloat color = 0x000000;
1266    static const VGfloat coords[] = {83,348, 87,352, 87,357, 89,351, 87,348
1267    };
1268
1269    init(l, 118, color, coords, ELEMENTS(coords)/2);
1270 }
1271
1272 static void poly119(struct lion *l)
1273 {
1274    VGfloat color = 0x000000;
1275    static const VGfloat coords[] = {155,107, 163,107, 170,107, 186,108, 175,109, 155,109
1276    };
1277
1278    init(l, 119, color, coords, ELEMENTS(coords)/2);
1279 }
1280
1281 static void poly120(struct lion *l)
1282 {
1283    VGfloat color = 0x000000;
1284    static const VGfloat coords[] = {153,114, 162,113, 175,112, 192,114, 173,114, 154,115
1285    };
1286
1287    init(l, 120, color, coords, ELEMENTS(coords)/2);
1288 }
1289
1290 static void poly121(struct lion *l)
1291 {
1292    VGfloat color = 0x000000;
1293    static const VGfloat coords[] = {152,118, 164,120, 180,123, 197,129, 169,123, 151,120
1294    };
1295
1296    init(l, 121, color, coords, ELEMENTS(coords)/2);
1297 }
1298
1299 static void poly122(struct lion *l)
1300 {
1301    VGfloat color = 0x000000;
1302    static const VGfloat coords[] = {68,109, 87,106, 107,106, 106,108, 88,108
1303    };
1304
1305    init(l, 122, color, coords, ELEMENTS(coords)/2);
1306 }
1307
1308 static void poly123(struct lion *l)
1309 {
1310    VGfloat color = 0x000000;
1311    static const VGfloat coords[] = {105,111, 95,112, 79,114, 71,116, 85,115, 102,113
1312    };
1313
1314    init(l, 123, color, coords, ELEMENTS(coords)/2);
1315 }
1316
1317 static void poly124(struct lion *l)
1318 {
1319    VGfloat color = 0x000000;
1320    static const VGfloat coords[] = {108,101, 98,99, 87,99, 78,99, 93,100, 105,102
1321    };
1322
1323    init(l, 124, color, coords, ELEMENTS(coords)/2);
1324 }
1325
1326 static void poly125(struct lion *l)
1327 {
1328    VGfloat color = 0x000000;
1329    static const VGfloat coords[] = {85,63, 91,63, 97,60, 104,60, 108,62, 111,69, 112,75,
1330                                     110,74, 108,71, 103,73, 106,69, 105,65, 103,64, 103,67,
1331                                     102,70, 99,70, 97,66, 94,67, 97,72, 88,67, 84,66
1332    };
1333
1334    init(l, 125, color, coords, ELEMENTS(coords)/2);
1335 }
1336
1337 static void poly126(struct lion *l)
1338 {
1339    VGfloat color = 0x000000;
1340    static const VGfloat coords[] = {140,74, 141,66, 144,61, 150,61, 156,62, 153,70, 150,73,
1341                                     152,65, 150,65, 151,68, 149,71, 146,71, 144,66, 143,70,
1342                                     143,74
1343    };
1344
1345    init(l, 126, color, coords, ELEMENTS(coords)/2);
1346 }
1347
1348 static void poly127(struct lion *l)
1349 {
1350    VGfloat color = 0x000000;
1351    static const VGfloat coords[] = {146,20, 156,11, 163,9, 172,9, 178,14, 182,18, 184,32, 182,42,
1352                                     182,52, 177,58, 176,67, 171,76, 165,90, 157,105, 160,92, 164,85,
1353                                     168,78, 167,73, 173,66, 172,62, 175,59, 174,55, 177,53, 180,46,
1354                                     181,29, 179,21, 173,13, 166,11, 159,13, 153,18, 148,23
1355    };
1356
1357    init(l, 127, color, coords, ELEMENTS(coords)/2);
1358 }
1359
1360 static void poly128(struct lion *l)
1361 {
1362    VGfloat color = 0x000000;
1363    static const VGfloat coords[] = {150,187, 148,211, 150,233, 153,247, 148,267, 135,283, 125,299,
1364                                     136,292, 131,313, 122,328, 122,345, 129,352, 133,359, 133,367,
1365                                     137,359, 148,356, 140,350, 131,347, 129,340, 132,332, 140,328,
1366                                     137,322, 140,304, 154,265, 157,244, 155,223, 161,220, 175,229,
1367                                     186,247, 185,260, 176,275, 178,287, 185,277, 188,261, 196,253,
1368                                     189,236, 174,213
1369    };
1370
1371    init(l, 128, color, coords, ELEMENTS(coords)/2);
1372 }
1373
1374 static void poly129(struct lion *l)
1375 {
1376    VGfloat color = 0x000000;
1377    static const VGfloat coords[] = {147,338, 142,341, 143,345, 141,354, 147,343
1378    };
1379
1380    init(l, 129, color, coords, ELEMENTS(coords)/2);
1381 }
1382
1383 static void poly130(struct lion *l)
1384 {
1385    VGfloat color = 0x000000;
1386    static const VGfloat coords[] = {157,342, 156,349, 150,356, 157,353, 163,346, 162,342
1387    };
1388
1389    init(l, 130, color, coords, ELEMENTS(coords)/2);
1390 }
1391
1392 static void poly131(struct lion *l)
1393 {
1394    VGfloat color = 0x000000;
1395    static const VGfloat coords[] = {99,265, 96,284, 92,299, 73,339, 73,333, 87,300
1396    };
1397
1398    init(l, 131, color, coords, ELEMENTS(coords)/2);
1399 }
1400
1401
1402 struct lion * lion_create(void)
1403 {
1404    struct lion *l = calloc(1, sizeof(struct lion));
1405
1406    poly0(l);
1407    poly1(l);
1408    poly2(l);
1409    poly3(l);
1410    poly4(l);
1411    poly5(l);
1412    poly6(l);
1413    poly7(l);
1414    poly8(l);
1415    poly9(l);
1416
1417    poly10(l);
1418    poly11(l);
1419    poly12(l);
1420    poly13(l);
1421    poly14(l);
1422    poly15(l);
1423    poly16(l);
1424    poly17(l);
1425    poly18(l);
1426    poly19(l);
1427
1428    poly20(l);
1429    poly21(l);
1430    poly22(l);
1431    poly23(l);
1432    poly24(l);
1433    poly25(l);
1434    poly26(l);
1435    poly27(l);
1436    poly28(l);
1437    poly29(l);
1438
1439    poly30(l);
1440    poly31(l);
1441    poly32(l);
1442    poly33(l);
1443    poly34(l);
1444    poly35(l);
1445    poly36(l);
1446    poly37(l);
1447    poly38(l);
1448    poly39(l);
1449
1450    poly40(l);
1451    poly41(l);
1452    poly42(l);
1453    poly43(l);
1454    poly44(l);
1455    poly45(l);
1456    poly46(l);
1457    poly47(l);
1458    poly48(l);
1459    poly49(l);
1460
1461    poly50(l);
1462    poly51(l);
1463    poly52(l);
1464    poly53(l);
1465    poly54(l);
1466    poly55(l);
1467    poly56(l);
1468    poly57(l);
1469    poly58(l);
1470    poly59(l);
1471
1472    poly60(l);
1473    poly61(l);
1474    poly62(l);
1475    poly63(l);
1476    poly64(l);
1477    poly65(l);
1478    poly66(l);
1479    poly67(l);
1480    poly68(l);
1481    poly69(l);
1482
1483    poly70(l);
1484    poly71(l);
1485    poly72(l);
1486    poly73(l);
1487    poly74(l);
1488    poly75(l);
1489    poly76(l);
1490    poly77(l);
1491    poly78(l);
1492    poly79(l);
1493
1494    poly80(l);
1495    poly81(l);
1496    poly82(l);
1497    poly83(l);
1498    poly84(l);
1499    poly85(l);
1500    poly86(l);
1501    poly87(l);
1502    poly88(l);
1503    poly89(l);
1504
1505    poly90(l);
1506    poly91(l);
1507    poly92(l);
1508    poly93(l);
1509    poly94(l);
1510    poly95(l);
1511    poly96(l);
1512    poly97(l);
1513    poly98(l);
1514    poly99(l);
1515
1516    poly100(l);
1517    poly101(l);
1518    poly102(l);
1519    poly103(l);
1520    poly104(l);
1521    poly105(l);
1522    poly106(l);
1523    poly107(l);
1524    poly108(l);
1525    poly109(l);
1526
1527    poly110(l);
1528    poly111(l);
1529    poly112(l);
1530    poly113(l);
1531    poly114(l);
1532    poly115(l);
1533    poly116(l);
1534    poly117(l);
1535    poly118(l);
1536    poly119(l);
1537
1538    poly120(l);
1539    poly121(l);
1540    poly122(l);
1541    poly123(l);
1542    poly124(l);
1543    poly125(l);
1544    poly126(l);
1545    poly127(l);
1546    poly128(l);
1547    poly129(l);
1548
1549    poly130(l);
1550    poly131(l);
1551
1552    return l;
1553 }
1554
1555 void lion_render(struct lion *l)
1556 {
1557    VGint i;
1558
1559    for (i = 0; i < LION_SIZE; ++i) {
1560       vgSetPaint(l->fills[i], VG_FILL_PATH);
1561       vgDrawPath(l->paths[i], VG_FILL_PATH);
1562    }
1563 }
1564
1565 void lion_destroy(struct lion *l)
1566 {
1567    VGint i;
1568    for (i = 0; i < LION_SIZE; ++i) {
1569       vgDestroyPaint(l->fills[i]);
1570       vgDestroyPath(l->paths[i]);
1571    }
1572    free(l);
1573 }