/* stbhw - v0.6 - http://nothings.org/gamedev/herringbone Herringbone Wang Tile Generator - Sean Barrett 2014 - public domain == LICENSE ============================== This software is dual-licensed to the public domain and under the following license: you are granted a perpetual, irrevocable license to copy, modify, publish, and distribute this file as you see fit. == WHAT IT IS =========================== This library is an SDK for Herringbone Wang Tile generation: http://nothings.org/gamedev/herringbone The core design is that you use this library offline to generate a "template" of the tiles you'll create. You then edit those tiles, then load the created tile image file back into this library and use it at runtime to generate "maps". You cannot load arbitrary tile image files with this library; it is only designed to load image files made from the template it created. It stores a binary description of the tile sizes & constraints in a few pixels, and uses those to recover the rules, rather than trying to parse the tiles themselves. You *can* use this library to generate from arbitrary tile sets, but only by loading the tile set and specifying the constraints explicitly yourself. == COMPILING ============================ 1. #define STB_HERRINGBONE_WANG_TILE_IMPLEMENTATION before including this header file in *one* source file to create the implementation in that source file. 2. optionally #define STB_HBWANG_RAND() to be a random number generator. if you don't define it, it will use rand(), and you need to seed srand() yourself. 3. optionally #define STB_HBWANG_ASSERT(x), otherwise it will use assert() 4. optionally #define STB_HBWANG_STATIC to force all symbols to be static instead of public, so they are only accesible in the source file that creates the implementation 5. optionally #define STB_HBWANG_NO_REPITITION_REDUCTION to disable the code that tries to reduce having the same tile appear adjacent to itself in wang-corner-tile mode (e.g. imagine if you were doing something where 90% of things should be the same grass tile, you need to disable this system) 6. optionally define STB_HBWANG_MAX_X and STB_HBWANG_MAX_Y to be the max dimensions of the generated map in multiples of the wang tile's short side's length (e.g. if you have 20x10 wang tiles, so short_side_len=10, and you have MAX_X is 17, then the largest map you can generate is 170 pixels wide). The defaults are 100x100. This is used to define static arrays which affect memory usage. == USING ================================ To use the map generator, you need a tileset. You can download some sample tilesets from http://nothings.org/gamedev/herringbone Then see the "sample application" below. You can also use this file to generate templates for tilesets which you then hand-edit to create the data. == MEMORY MANAGEMENT ==================== The tileset loader allocates memory with malloc(). The map generator does no memory allocation, so e.g. you can load tilesets at startup and never free them and never do any further allocation. == SAMPLE APPLICATION =================== #include #include #include #define STB_IMAGE_IMPLEMENTATION #include "stb_image.h" // http://nothings.org/stb_image.c #define STB_IMAGE_WRITE_IMPLEMENTATION #include "stb_image_write.h" // http://nothings.org/stb/stb_image_write.h #define STB_HBWANG_IMPLEMENTATION #include "stb_hbwang.h" int main(int argc, char **argv) { unsigned char *data; int xs,ys, w,h; stbhw_tileset ts; if (argc != 4) { fprintf(stderr, "Usage: mapgen {tile-file} {xsize} {ysize}\n" "generates file named 'test_map.png'\n"); exit(1); } data = stbi_load(argv[1], &w, &h, NULL, 3); xs = atoi(argv[2]); ys = atoi(argv[3]); if (data == NULL) { fprintf(stderr, "Error opening or parsing '%s' as an image file\n", argv[1]); exit(1); } if (xs < 1 || xs > 1000) { fprintf(stderr, "xsize invalid or out of range\n"); exit(1); } if (ys < 1 || ys > 1000) { fprintf(stderr, "ysize invalid or out of range\n"); exit(1); } stbhw_build_tileset_from_image(&ts, data, w*3, w, h); free(data); // allocate a buffer to create the final image to data = malloc(3 * xs * ys); srand(time(NULL)); stbhw_generate_image(&ts, NULL, data, xs*3, xs, ys); stbi_write_png("test_map.png", xs, ys, 3, data, xs*3); stbhw_free_tileset(&ts); free(data); return 0; } == VERSION HISTORY =================== 0.6 2014-08-17 - fix broken map-maker 0.5 2014-07-07 - initial release */ ////////////////////////////////////////////////////////////////////////////// // // // HEADER FILE SECTION // // // #ifndef INCLUDE_STB_HWANG_H #define INCLUDE_STB_HWANG_H #ifdef STB_HBWANG_STATIC #define STBHW_EXTERN static #else #ifdef __cplusplus #define STBHW_EXTERN extern "C" #else #define STBHW_EXTERN extern #endif #endif typedef struct stbhw_tileset stbhw_tileset; // returns description of last error produced by any function (not thread-safe) STBHW_EXTERN char *stbhw_get_last_error(void); // build a tileset from an image that conforms to a template created by this // library. (you allocate storage for stbhw_tileset and function fills it out; // memory for individual tiles are malloc()ed). // returns non-zero on success, 0 on error STBHW_EXTERN int stbhw_build_tileset_from_image(stbhw_tileset *ts, unsigned char *pixels, int stride_in_bytes, int w, int h); // free a tileset built by stbhw_build_tileset_from_image STBHW_EXTERN void stbhw_free_tileset(stbhw_tileset *ts); // generate a map that is w * h pixels (3-bytes each) // returns non-zero on success, 0 on error // not thread-safe (uses a global data structure to avoid memory management) // weighting should be NULL, as non-NULL weighting is currently untested STBHW_EXTERN int stbhw_generate_image(stbhw_tileset *ts, int **weighting, unsigned char *pixels, int stride_in_bytes, int w, int h); ////////////////////////////////////// // // TILESET DATA STRUCTURE // // if you use the image-to-tileset system from this file, you // don't need to worry about these data structures. but if you // want to build/load a tileset yourself, you'll need to fill // these out. typedef struct { // the edge or vertex constraints, according to diagram below signed char a,b,c,d,e,f; // The herringbone wang tile data; it is a bitmap which is either // w=2*short_sidelen,h=short_sidelen, or w=short_sidelen,h=2*short_sidelen. // it is always RGB, stored row-major, with no padding between rows. // (allocate stbhw_tile structure to be large enough for the pixel data) unsigned char pixels[1]; } stbhw_tile; struct stbhw_tileset { int is_corner; int num_color[6]; // number of colors for each of 6 edge types or 4 corner types int short_side_len; stbhw_tile **h_tiles; stbhw_tile **v_tiles; int num_h_tiles, max_h_tiles; int num_v_tiles, max_v_tiles; }; /////////////// TEMPLATE GENERATOR ////////////////////////// // when requesting a template, you fill out this data typedef struct { int is_corner; // using corner colors or edge colors? int short_side_len; // rectangles is 2n x n, n = short_side_len int num_color[6]; // see below diagram for meaning of the index to this; // 6 values if edge (!is_corner), 4 values if is_corner // legal numbers: 1..8 if edge, 1..4 if is_corner int num_vary_x; // additional number of variations along x axis in the template int num_vary_y; // additional number of variations along y axis in the template int corner_type_color_template[4][4]; // if corner_type_color_template[s][t] is non-zero, then any // corner of type s generated as color t will get a little // corner sample markup in the template image data } stbhw_config; // computes the size needed for the template image STBHW_EXTERN void stbhw_get_template_size(stbhw_config *c, int *w, int *h); // generates a template image, assuming data is 3*w*h bytes long, RGB format STBHW_EXTERN int stbhw_make_template(stbhw_config *c, unsigned char *data, int w, int h, int stride_in_bytes); #endif//INCLUDE_STB_HWANG_H // TILE CONSTRAINT TYPES // // there are 4 "types" of corners and 6 types of edges. // you can configure the tileset to have different numbers // of colors for each type of color or edge. // // corner types: // // 0---*---1---*---2---*---3 // | | | // * * * // | | | // 1---*---2---*---3 0---*---1---*---2 // | | | // * * * // | | | // 0---*---1---*---2---*---3 // // // edge types: // // *---2---*---3---* *---0---* // | | | | // 1 4 5 1 // | | | | // *---0---*---2---* * * // | | // 4 5 // | | // *---3---* // // TILE CONSTRAINTS // // each corner/edge has a color; this shows the name // of the variable containing the color // // corner constraints: // // a---*---d // | | // * * // | | // a---*---b---*---c b e // | | | | // * * * * // | | | | // d---*---e---*---f c---*---f // // // edge constraints: // // *---a---*---b---* *---a---* // | | | | // c d b c // | | | | // *---e---*---f---* * * // | | // d e // | | // *---f---* // ////////////////////////////////////////////////////////////////////////////// // // // IMPLEMENTATION SECTION // // // #ifdef STB_HERRINGBONE_WANG_TILE_IMPLEMENTATION #include // memcpy #include // malloc #ifndef STB_HBWANG_RAND #include #define STB_HBWANG_RAND() (rand() >> 4) #endif #ifndef STB_HBWANG_ASSERT #include #define STB_HBWANG_ASSERT(x) assert(x) #endif // map size #ifndef STB_HBWANG_MAX_X #define STB_HBWANG_MAX_X 100 #endif #ifndef STB_HBWANG_MAX_Y #define STB_HBWANG_MAX_Y 100 #endif // global variables for color assignments // @MEMORY change these to just store last two/three rows // and keep them on the stack static signed char c_color[STB_HBWANG_MAX_Y+6][STB_HBWANG_MAX_X+6]; static signed char v_color[STB_HBWANG_MAX_Y+6][STB_HBWANG_MAX_X+5]; static signed char h_color[STB_HBWANG_MAX_Y+5][STB_HBWANG_MAX_X+6]; static char *stbhw_error; STBHW_EXTERN char *stbhw_get_last_error(void) { char *temp = stbhw_error; stbhw_error = 0; return temp; } ///////////////////////////////////////////////////////////// // // SHARED TEMPLATE-DESCRIPTION CODE // // Used by both template generator and tileset parser; by // using the same code, they are locked in sync and we don't // need to try to do more sophisticated parsing of edge color // markup or something. typedef void stbhw__process_rect(struct stbhw__process *p, int xpos, int ypos, int a, int b, int c, int d, int e, int f); typedef struct stbhw__process { stbhw_tileset *ts; stbhw_config *c; stbhw__process_rect *process_h_rect; stbhw__process_rect *process_v_rect; unsigned char *data; int stride,w,h; } stbhw__process; static void stbhw__process_h_row(stbhw__process *p, int xpos, int ypos, int a0, int a1, int b0, int b1, int c0, int c1, int d0, int d1, int e0, int e1, int f0, int f1, int variants) { int a,b,c,d,e,f,v; for (v=0; v < variants; ++v) for (f=f0; f <= f1; ++f) for (e=e0; e <= e1; ++e) for (d=d0; d <= d1; ++d) for (c=c0; c <= c1; ++c) for (b=b0; b <= b1; ++b) for (a=a0; a <= a1; ++a) { p->process_h_rect(p, xpos, ypos, a,b,c,d,e,f); xpos += 2*p->c->short_side_len + 3; } } static void stbhw__process_v_row(stbhw__process *p, int xpos, int ypos, int a0, int a1, int b0, int b1, int c0, int c1, int d0, int d1, int e0, int e1, int f0, int f1, int variants) { int a,b,c,d,e,f,v; for (v=0; v < variants; ++v) for (f=f0; f <= f1; ++f) for (e=e0; e <= e1; ++e) for (d=d0; d <= d1; ++d) for (c=c0; c <= c1; ++c) for (b=b0; b <= b1; ++b) for (a=a0; a <= a1; ++a) { p->process_v_rect(p, xpos, ypos, a,b,c,d,e,f); xpos += p->c->short_side_len+3; } } static void stbhw__get_template_info(stbhw_config *c, int *w, int *h, int *h_count, int *v_count) { int size_x,size_y; int horz_count,vert_count; if (c->is_corner) { int horz_w = c->num_color[1] * c->num_color[2] * c->num_color[3] * c->num_vary_x; int horz_h = c->num_color[0] * c->num_color[1] * c->num_color[2] * c->num_vary_y; int vert_w = c->num_color[0] * c->num_color[3] * c->num_color[2] * c->num_vary_y; int vert_h = c->num_color[1] * c->num_color[0] * c->num_color[3] * c->num_vary_x; int horz_x = horz_w * (2*c->short_side_len + 3); int horz_y = horz_h * ( c->short_side_len + 3); int vert_x = vert_w * ( c->short_side_len + 3); int vert_y = vert_h * (2*c->short_side_len + 3); horz_count = horz_w * horz_h; vert_count = vert_w * vert_h; size_x = horz_x > vert_x ? horz_x : vert_x; size_y = 2 + horz_y + 2 + vert_y; } else { int horz_w = c->num_color[0] * c->num_color[1] * c->num_color[2] * c->num_vary_x; int horz_h = c->num_color[3] * c->num_color[4] * c->num_color[2] * c->num_vary_y; int vert_w = c->num_color[0] * c->num_color[5] * c->num_color[1] * c->num_vary_y; int vert_h = c->num_color[3] * c->num_color[4] * c->num_color[5] * c->num_vary_x; int horz_x = horz_w * (2*c->short_side_len + 3); int horz_y = horz_h * ( c->short_side_len + 3); int vert_x = vert_w * ( c->short_side_len + 3); int vert_y = vert_h * (2*c->short_side_len + 3); horz_count = horz_w * horz_h; vert_count = vert_w * vert_h; size_x = horz_x > vert_x ? horz_x : vert_x; size_y = 2 + horz_y + 2 + vert_y; } if (w) *w = size_x; if (h) *h = size_y; if (h_count) *h_count = horz_count; if (v_count) *v_count = vert_count; } STBHW_EXTERN void stbhw_get_template_size(stbhw_config *c, int *w, int *h) { stbhw__get_template_info(c, w, h, NULL, NULL); } static int stbhw__process_template(stbhw__process *p) { int i,j,k,q, ypos; int size_x, size_y; stbhw_config *c = p->c; stbhw__get_template_info(c, &size_x, &size_y, NULL, NULL); if (p->w < size_x || p->h < size_y) { stbhw_error = "image too small for configuration"; return 0; } if (c->is_corner) { ypos = 2; for (k=0; k < c->num_color[2]; ++k) { for (j=0; j < c->num_color[1]; ++j) { for (i=0; i < c->num_color[0]; ++i) { for (q=0; q < c->num_vary_y; ++q) { stbhw__process_h_row(p, 0,ypos, 0,c->num_color[1]-1, 0,c->num_color[2]-1, 0,c->num_color[3]-1, i,i, j,j, k,k, c->num_vary_x); ypos += c->short_side_len + 3; } } } } ypos += 2; for (k=0; k < c->num_color[3]; ++k) { for (j=0; j < c->num_color[0]; ++j) { for (i=0; i < c->num_color[1]; ++i) { for (q=0; q < c->num_vary_x; ++q) { stbhw__process_v_row(p, 0,ypos, 0,c->num_color[0]-1, 0,c->num_color[3]-1, 0,c->num_color[2]-1, i,i, j,j, k,k, c->num_vary_y); ypos += (c->short_side_len*2) + 3; } } } } assert(ypos == size_y); } else { ypos = 2; for (k=0; k < c->num_color[3]; ++k) { for (j=0; j < c->num_color[4]; ++j) { for (i=0; i < c->num_color[2]; ++i) { for (q=0; q < c->num_vary_y; ++q) { stbhw__process_h_row(p, 0,ypos, 0,c->num_color[2]-1, k,k, 0,c->num_color[1]-1, j,j, 0,c->num_color[0]-1, i,i, c->num_vary_x); ypos += c->short_side_len + 3; } } } } ypos += 2; for (k=0; k < c->num_color[3]; ++k) { for (j=0; j < c->num_color[4]; ++j) { for (i=0; i < c->num_color[5]; ++i) { for (q=0; q < c->num_vary_x; ++q) { stbhw__process_v_row(p, 0,ypos, 0,c->num_color[0]-1, i,i, 0,c->num_color[1]-1, j,j, 0,c->num_color[5]-1, k,k, c->num_vary_y); ypos += (c->short_side_len*2) + 3; } } } } assert(ypos == size_y); } return 1; } ///////////////////////////////////////////////////////////// // // MAP GENERATOR // static void stbhw__draw_pixel(unsigned char *output, int stride, int x, int y, unsigned char c[3]) { memcpy(output + y*stride + x*3, c, 3); } static void stbhw__draw_h_tile(unsigned char *output, int stride, int xmax, int ymax, int x, int y, stbhw_tile *h, int sz) { int i,j; for (j=0; j < sz; ++j) if (y+j >= 0 && y+j < ymax) for (i=0; i < sz*2; ++i) if (x+i >= 0 && x+i < xmax) stbhw__draw_pixel(output,stride, x+i,y+j, &h->pixels[(j*sz*2 + i)*3]); } static void stbhw__draw_v_tile(unsigned char *output, int stride, int xmax, int ymax, int x, int y, stbhw_tile *h, int sz) { int i,j; for (j=0; j < sz*2; ++j) if (y+j >= 0 && y+j < ymax) for (i=0; i < sz; ++i) if (x+i >= 0 && x+i < xmax) stbhw__draw_pixel(output,stride, x+i,y+j, &h->pixels[(j*sz + i)*3]); } // randomly choose a tile that fits constraints for a given spot, and update the constraints static stbhw_tile * stbhw__choose_tile(stbhw_tile **list, int numlist, signed char *a, signed char *b, signed char *c, signed char *d, signed char *e, signed char *f, int **weighting) { int i,n,m = 1<<30,pass; for (pass=0; pass < 2; ++pass) { n=0; // pass #1: // count number of variants that match this partial set of constraints // pass #2: // stop on randomly selected match for (i=0; i < numlist; ++i) { stbhw_tile *h = list[i]; if ((*a < 0 || *a == h->a) && (*b < 0 || *b == h->b) && (*c < 0 || *c == h->c) && (*d < 0 || *d == h->d) && (*e < 0 || *e == h->e) && (*f < 0 || *f == h->f)) { if (weighting) n += weighting[0][i]; else n += 1; if (n > m) { // use list[i] // update constraints to reflect what we placed *a = h->a; *b = h->b; *c = h->c; *d = h->d; *e = h->e; *f = h->f; return h; } } } if (n == 0) { stbhw_error = "couldn't find tile matching constraints"; return NULL; } m = STB_HBWANG_RAND() % n; } STB_HBWANG_ASSERT(0); return NULL; } static int stbhw__match(int x, int y) { return c_color[y][x] == c_color[y+1][x+1]; } static int stbhw__weighted(int num_options, int *weights) { int k, total, choice; total = 0; for (k=0; k < num_options; ++k) total += weights[k]; choice = STB_HBWANG_RAND() % total; total = 0; for (k=0; k < num_options; ++k) { total += weights[k]; if (choice < total) break; } STB_HBWANG_ASSERT(k < num_options); return k; } static int stbhw__change_color(int old_color, int num_options, int *weights) { if (weights) { int k, total, choice; total = 0; for (k=0; k < num_options; ++k) if (k != old_color) total += weights[k]; choice = STB_HBWANG_RAND() % total; total = 0; for (k=0; k < num_options; ++k) { if (k != old_color) { total += weights[k]; if (choice < total) break; } } STB_HBWANG_ASSERT(k < num_options); return k; } else { int offset = 1+STB_HBWANG_RAND() % (num_options-1); return (old_color+offset) % num_options; } } // generate a map that is w * h pixels (3-bytes each) // returns 1 on success, 0 on error STBHW_EXTERN int stbhw_generate_image(stbhw_tileset *ts, int **weighting, unsigned char *output, int stride, int w, int h) { int sidelen = ts->short_side_len; int xmax = (w / sidelen) + 6; int ymax = (h / sidelen) + 6; if (xmax > STB_HBWANG_MAX_X+6 || ymax > STB_HBWANG_MAX_Y+6) { stbhw_error = "increase STB_HBWANG_MAX_X/Y"; return 0; } if (ts->is_corner) { int i,j, ypos; int *cc = ts->num_color; for (j=0; j < ymax; ++j) { for (i=0; i < xmax; ++i) { int p = (i-j+1)&3; // corner type if (weighting==NULL || weighting[p]==0 || cc[p] == 1) c_color[j][i] = STB_HBWANG_RAND() % cc[p]; else c_color[j][i] = stbhw__weighted(cc[p], weighting[p]); } } #ifndef STB_HBWANG_NO_REPITITION_REDUCTION // now go back through and make sure we don't have adjancent 3x2 vertices that are identical, // to avoid really obvious repetition (which happens easily with extreme weights) for (j=0; j < ymax-3; ++j) { for (i=0; i < xmax-3; ++i) { int p = (i-j+1) & 3; // corner type STB_HBWANG_ASSERT(i+3 < STB_HBWANG_MAX_X+6); STB_HBWANG_ASSERT(j+3 < STB_HBWANG_MAX_Y+6); if (stbhw__match(i,j) && stbhw__match(i,j+1) && stbhw__match(i,j+2) && stbhw__match(i+1,j) && stbhw__match(i+1,j+1) && stbhw__match(i+1,j+2)) { int p = ((i+1)-(j+1)+1) & 3; if (cc[p] > 1) c_color[j+1][i+1] = stbhw__change_color(c_color[j+1][i+1], cc[p], weighting ? weighting[p] : NULL); } if (stbhw__match(i,j) && stbhw__match(i+1,j) && stbhw__match(i+2,j) && stbhw__match(i,j+1) && stbhw__match(i+1,j+1) && stbhw__match(i+2,j+1)) { int p = ((i+2)-(j+1)+1) & 3; if (cc[p] > 1) c_color[j+1][i+2] = stbhw__change_color(c_color[j+1][i+2], cc[p], weighting ? weighting[p] : NULL); } } } #endif ypos = -1 * sidelen; for (j = -1; ypos < h; ++j) { // a general herringbone row consists of: // horizontal left block, the bottom of a previous vertical, the top of a new vertical int phase = (j & 3); // displace horizontally according to pattern if (phase == 0) { i = 0; } else { i = phase-4; } for (i;; i += 4) { int xpos = i * sidelen; if (xpos >= w) break; // horizontal left-block if (xpos + sidelen*2 >= 0 && ypos >= 0) { stbhw_tile *t = stbhw__choose_tile( ts->h_tiles, ts->num_h_tiles, &c_color[j+2][i+2], &c_color[j+2][i+3], &c_color[j+2][i+4], &c_color[j+3][i+2], &c_color[j+3][i+3], &c_color[j+3][i+4], weighting ); if (t == NULL) return 0; stbhw__draw_h_tile(output,stride,w,h, xpos, ypos, t, sidelen); } xpos += sidelen * 2; // now we're at the end of a previous vertical one xpos += sidelen; // now we're at the start of a new vertical one if (xpos < w) { stbhw_tile *t = stbhw__choose_tile( ts->v_tiles, ts->num_v_tiles, &c_color[j+2][i+5], &c_color[j+3][i+5], &c_color[j+4][i+5], &c_color[j+2][i+6], &c_color[j+3][i+6], &c_color[j+4][i+6], weighting ); if (t == NULL) return 0; stbhw__draw_v_tile(output,stride,w,h, xpos, ypos, t, sidelen); } } ypos += sidelen; } } else { // @TODO edge-color repetition reduction int i,j, ypos; memset(v_color, -1, sizeof(v_color)); memset(h_color, -1, sizeof(h_color)); ypos = -1 * sidelen; for (j = -1; ypos= w) break; // horizontal left-block if (xpos + sidelen*2 >= 0 && ypos >= 0) { stbhw_tile *t = stbhw__choose_tile( ts->h_tiles, ts->num_h_tiles, &h_color[j+2][i+2], &h_color[j+2][i+3], &v_color[j+2][i+2], &v_color[j+2][i+4], &h_color[j+3][i+2], &h_color[j+3][i+3], weighting ); if (t == NULL) return 0; stbhw__draw_h_tile(output,stride,w,h, xpos, ypos, t, sidelen); } xpos += sidelen * 2; // now we're at the end of a previous vertical one xpos += sidelen; // now we're at the start of a new vertical one if (xpos < w) { stbhw_tile *t = stbhw__choose_tile( ts->v_tiles, ts->num_v_tiles, &h_color[j+2][i+5], &v_color[j+2][i+5], &v_color[j+2][i+6], &v_color[j+3][i+5], &v_color[j+3][i+6], &h_color[j+4][i+5], weighting ); if (t == NULL) return 0; stbhw__draw_v_tile(output,stride,w,h, xpos, ypos, t, sidelen); } } ypos += sidelen; } } return 1; } static void stbhw__parse_h_rect(stbhw__process *p, int xpos, int ypos, int a, int b, int c, int d, int e, int f) { int len = p->c->short_side_len; stbhw_tile *h = (stbhw_tile *) malloc(sizeof(*h)-1 + 3 * (len*2) * len); int i,j; ++xpos; ++ypos; h->a = a, h->b = b, h->c = c, h->d = d, h->e = e, h->f = f; for (j=0; j < len; ++j) for (i=0; i < len*2; ++i) memcpy(h->pixels + j*(3*len*2) + i*3, p->data+(ypos+j)*p->stride+(xpos+i)*3, 3); STB_HBWANG_ASSERT(p->ts->num_h_tiles < p->ts->max_h_tiles); p->ts->h_tiles[p->ts->num_h_tiles++] = h; } static void stbhw__parse_v_rect(stbhw__process *p, int xpos, int ypos, int a, int b, int c, int d, int e, int f) { int len = p->c->short_side_len; stbhw_tile *h = (stbhw_tile *) malloc(sizeof(*h)-1 + 3 * (len*2) * len); int i,j; ++xpos; ++ypos; h->a = a, h->b = b, h->c = c, h->d = d, h->e = e, h->f = f; for (j=0; j < len*2; ++j) for (i=0; i < len; ++i) memcpy(h->pixels + j*(3*len) + i*3, p->data+(ypos+j)*p->stride+(xpos+i)*3, 3); STB_HBWANG_ASSERT(p->ts->num_v_tiles < p->ts->max_v_tiles); p->ts->v_tiles[p->ts->num_v_tiles++] = h; } STBHW_EXTERN int stbhw_build_tileset_from_image(stbhw_tileset *ts, unsigned char *data, int stride, int w, int h) { int i, h_count, v_count; unsigned char header[9]; stbhw_config c = { 0 }; stbhw__process p = { 0 }; // extract binary header // remove encoding that makes it more visually obvious it encodes actual data for (i=0; i < 9; ++i) header[i] = data[w*3 - 1 - i] ^ (i*55); // extract header info if (header[7] == 0xc0) { // corner-type c.is_corner = 1; for (i=0; i < 4; ++i) c.num_color[i] = header[i]; c.num_vary_x = header[4]; c.num_vary_y = header[5]; c.short_side_len = header[6]; } else { c.is_corner = 0; // edge-type for (i=0; i < 6; ++i) c.num_color[i] = header[i]; c.num_vary_x = header[6]; c.num_vary_y = header[7]; c.short_side_len = header[8]; } if (c.num_vary_x < 0 || c.num_vary_x > 64 || c.num_vary_y < 0 || c.num_vary_y > 64) return 0; if (c.short_side_len == 0) return 0; if (c.num_color[0] > 32 || c.num_color[1] > 32 || c.num_color[2] > 32 || c.num_color[3] > 32) return 0; stbhw__get_template_info(&c, NULL, NULL, &h_count, &v_count); ts->is_corner = c.is_corner; ts->short_side_len = c.short_side_len; memcpy(ts->num_color, c.num_color, sizeof(ts->num_color)); ts->max_h_tiles = h_count; ts->max_v_tiles = v_count; ts->num_h_tiles = ts->num_v_tiles = 0; ts->h_tiles = (stbhw_tile **) malloc(sizeof(*ts->h_tiles) * h_count); ts->v_tiles = (stbhw_tile **) malloc(sizeof(*ts->v_tiles) * v_count); p.ts = ts; p.data = data; p.stride = stride; p.process_h_rect = stbhw__parse_h_rect; p.process_v_rect = stbhw__parse_v_rect; p.w = w; p.h = h; p.c = &c; // load all the tiles out of the image return stbhw__process_template(&p); } STBHW_EXTERN void stbhw_free_tileset(stbhw_tileset *ts) { int i; for (i=0; i < ts->num_h_tiles; ++i) free(ts->h_tiles[i]); for (i=0; i < ts->num_v_tiles; ++i) free(ts->v_tiles[i]); free(ts->h_tiles); free(ts->v_tiles); ts->h_tiles = NULL; ts->v_tiles = NULL; ts->num_h_tiles = ts->max_h_tiles = 0; ts->num_v_tiles = ts->max_v_tiles = 0; } ////////////////////////////////////////////////////////////////////////////// // // GENERATOR // // // shared code static void stbhw__set_pixel(unsigned char *data, int stride, int xpos, int ypos, unsigned char color[3]) { memcpy(data + ypos*stride + xpos*3, color, 3); } static void stbhw__stbhw__set_pixel_whiten(unsigned char *data, int stride, int xpos, int ypos, unsigned char color[3]) { unsigned char c2[3]; int i; for (i=0; i < 3; ++i) c2[i] = (color[i]*2 + 255)/3; memcpy(data + ypos*stride + xpos*3, c2, 3); } static unsigned char stbhw__black[3] = { 0,0,0 }; // each edge set gets its own unique color variants // used http://phrogz.net/css/distinct-colors.html to generate this set, // but it's not very good and needs to be revised static unsigned char stbhw__color[7][8][3] = { { {255,51,51} , {143,143,29}, {0,199,199}, {159,119,199}, {0,149,199} , {143, 0,143}, {255,128,0}, {64,255,0}, }, { {235,255,30 }, {255,0,255}, {199,139,119}, {29,143, 57}, {143,0,71} , { 0,143,143}, {0,99,199}, {143,71,0}, }, { {0,149,199} , {143, 0,143}, {255,128,0}, {64,255,0}, {255,191,0} , {51,255,153}, {0,0,143}, {199,119,159},}, { {143,0,71} , { 0,143,143}, {0,99,199}, {143,71,0}, {255,190,153}, { 0,255,255}, {128,0,255}, {255,51,102},}, { {255,191,0} , {51,255,153}, {0,0,143}, {199,119,159}, {255,51,51} , {143,143,29}, {0,199,199}, {159,119,199},}, { {255,190,153}, { 0,255,255}, {128,0,255}, {255,51,102}, {235,255,30 }, {255,0,255}, {199,139,119}, {29,143, 57}, }, { {40,40,40 }, { 90,90,90 }, { 150,150,150 }, { 200,200,200 }, { 255,90,90 }, { 160,160,80}, { 50,150,150 }, { 200,50,200 } }, }; static void stbhw__draw_hline(unsigned char *data, int stride, int xpos, int ypos, int color, int len, int slot) { int i; int j = len * 6 / 16; int k = len * 10 / 16; for (i=0; i < len; ++i) stbhw__set_pixel(data, stride, xpos+i, ypos, stbhw__black); if (k-j < 2) { j = len/2 - 1; k = j+2; if (len & 1) ++k; } for (i=j; i < k; ++i) stbhw__stbhw__set_pixel_whiten(data, stride, xpos+i, ypos, stbhw__color[slot][color]); } static void stbhw__draw_vline(unsigned char *data, int stride, int xpos, int ypos, int color, int len, int slot) { int i; int j = len * 6 / 16; int k = len * 10 / 16; for (i=0; i < len; ++i) stbhw__set_pixel(data, stride, xpos, ypos+i, stbhw__black); if (k-j < 2) { j = len/2 - 1; k = j+2; if (len & 1) ++k; } for (i=j; i < k; ++i) stbhw__stbhw__set_pixel_whiten(data, stride, xpos, ypos+i, stbhw__color[slot][color]); } // 0--*--1--*--2--*--3 // | | | // * * * // | | | // 1--*--2--*--3 0--*--1--*--2 // | | | // * * * // | | | // 0--*--1--*--2--*--3 // // variables while enumerating (no correspondence between corners // of the types is implied by these variables) // // a-----b-----c a-----d // | | | | // | | | | // | | | | // d-----e-----f b e // | | // | | // | | // c-----f // unsigned char stbhw__corner_colors[4][4][3] = { { { 255,0,0 }, { 200,200,200 }, { 100,100,200 }, { 255,200,150 }, }, { { 0,0,255 }, { 255,255,0 }, { 100,200,100 }, { 150,255,200 }, }, { { 255,0,255 }, { 80,80,80 }, { 200,100,100 }, { 200,150,255 }, }, { { 0,255,255 }, { 0,255,0 }, { 200,120,200 }, { 255,200,200 }, }, }; int stbhw__corner_colors_to_edge_color[4][4] = { // 0 1 2 3 { 0, 1, 4, 9, }, // 0 { 2, 3, 5, 10, }, // 1 { 6, 7, 8, 11, }, // 2 { 12, 13, 14, 15, }, // 3 }; #define stbhw__c2e stbhw__corner_colors_to_edge_color static void stbhw__draw_clipped_corner(unsigned char *data, int stride, int xpos, int ypos, int w, int h, int x, int y) { static unsigned char template_color[3] = { 167,204,204 }; int i,j; for (j = -2; j <= 1; ++j) { for (i = -2; i <= 1; ++i) { if ((i == -2 || i == 1) && (j == -2 || j == 1)) continue; else { if (x+i < 1 || x+i > w) continue; if (y+j < 1 || y+j > h) continue; stbhw__set_pixel(data, stride, xpos+x+i, ypos+y+j, template_color); } } } } static void stbhw__edge_process_h_rect(stbhw__process *p, int xpos, int ypos, int a, int b, int c, int d, int e, int f) { int len = p->c->short_side_len; stbhw__draw_hline(p->data, p->stride, xpos+1 , ypos , a, len, 2); stbhw__draw_hline(p->data, p->stride, xpos+ len+1 , ypos , b, len, 3); stbhw__draw_vline(p->data, p->stride, xpos , ypos+1 , c, len, 1); stbhw__draw_vline(p->data, p->stride, xpos+2*len+1 , ypos+1 , d, len, 4); stbhw__draw_hline(p->data, p->stride, xpos+1 , ypos + len+1, e, len, 0); stbhw__draw_hline(p->data, p->stride, xpos + len+1 , ypos + len+1, f, len, 2); } static void stbhw__edge_process_v_rect(stbhw__process *p, int xpos, int ypos, int a, int b, int c, int d, int e, int f) { int len = p->c->short_side_len; stbhw__draw_hline(p->data, p->stride, xpos+1 , ypos , a, len, 0); stbhw__draw_vline(p->data, p->stride, xpos , ypos+1 , b, len, 5); stbhw__draw_vline(p->data, p->stride, xpos + len+1, ypos+1 , c, len, 1); stbhw__draw_vline(p->data, p->stride, xpos , ypos + len+1, d, len, 4); stbhw__draw_vline(p->data, p->stride, xpos + len+1, ypos + len+1, e, len, 5); stbhw__draw_hline(p->data, p->stride, xpos+1 , ypos + 2*len+1, f, len, 3); } static void stbhw__corner_process_h_rect(stbhw__process *p, int xpos, int ypos, int a, int b, int c, int d, int e, int f) { int len = p->c->short_side_len; stbhw__draw_hline(p->data, p->stride, xpos+1 , ypos , stbhw__c2e[a][b], len, 2); stbhw__draw_hline(p->data, p->stride, xpos+ len+1 , ypos , stbhw__c2e[b][c], len, 3); stbhw__draw_vline(p->data, p->stride, xpos , ypos+1 , stbhw__c2e[a][d], len, 1); stbhw__draw_vline(p->data, p->stride, xpos+2*len+1 , ypos+1 , stbhw__c2e[c][f], len, 4); stbhw__draw_hline(p->data, p->stride, xpos+1 , ypos + len+1, stbhw__c2e[d][e], len, 0); stbhw__draw_hline(p->data, p->stride, xpos + len+1 , ypos + len+1, stbhw__c2e[e][f], len, 2); if (p->c->corner_type_color_template[1][a]) stbhw__draw_clipped_corner(p->data,p->stride, xpos,ypos, len*2,len, 1,1); if (p->c->corner_type_color_template[2][b]) stbhw__draw_clipped_corner(p->data,p->stride, xpos,ypos, len*2,len, len+1,1); if (p->c->corner_type_color_template[3][c]) stbhw__draw_clipped_corner(p->data,p->stride, xpos,ypos, len*2,len, len*2+1,1); if (p->c->corner_type_color_template[0][d]) stbhw__draw_clipped_corner(p->data,p->stride, xpos,ypos, len*2,len, 1,len+1); if (p->c->corner_type_color_template[1][e]) stbhw__draw_clipped_corner(p->data,p->stride, xpos,ypos, len*2,len, len+1,len+1); if (p->c->corner_type_color_template[2][f]) stbhw__draw_clipped_corner(p->data,p->stride, xpos,ypos, len*2,len, len*2+1,len+1); stbhw__set_pixel(p->data, p->stride, xpos , ypos, stbhw__corner_colors[1][a]); stbhw__set_pixel(p->data, p->stride, xpos+len , ypos, stbhw__corner_colors[2][b]); stbhw__set_pixel(p->data, p->stride, xpos+2*len+1, ypos, stbhw__corner_colors[3][c]); stbhw__set_pixel(p->data, p->stride, xpos , ypos+len+1, stbhw__corner_colors[0][d]); stbhw__set_pixel(p->data, p->stride, xpos+len , ypos+len+1, stbhw__corner_colors[1][e]); stbhw__set_pixel(p->data, p->stride, xpos+2*len+1, ypos+len+1, stbhw__corner_colors[2][f]); } static void stbhw__corner_process_v_rect(stbhw__process *p, int xpos, int ypos, int a, int b, int c, int d, int e, int f) { int len = p->c->short_side_len; stbhw__draw_hline(p->data, p->stride, xpos+1 , ypos , stbhw__c2e[a][d], len, 0); stbhw__draw_vline(p->data, p->stride, xpos , ypos+1 , stbhw__c2e[a][b], len, 5); stbhw__draw_vline(p->data, p->stride, xpos + len+1, ypos+1 , stbhw__c2e[d][e], len, 1); stbhw__draw_vline(p->data, p->stride, xpos , ypos + len+1, stbhw__c2e[b][c], len, 4); stbhw__draw_vline(p->data, p->stride, xpos + len+1, ypos + len+1, stbhw__c2e[e][f], len, 5); stbhw__draw_hline(p->data, p->stride, xpos+1 , ypos + 2*len+1, stbhw__c2e[c][f], len, 3); if (p->c->corner_type_color_template[0][a]) stbhw__draw_clipped_corner(p->data,p->stride, xpos,ypos, len,len*2, 1,1); if (p->c->corner_type_color_template[3][b]) stbhw__draw_clipped_corner(p->data,p->stride, xpos,ypos, len,len*2, 1,len+1); if (p->c->corner_type_color_template[2][c]) stbhw__draw_clipped_corner(p->data,p->stride, xpos,ypos, len,len*2, 1,len*2+1); if (p->c->corner_type_color_template[1][d]) stbhw__draw_clipped_corner(p->data,p->stride, xpos,ypos, len,len*2, len+1,1); if (p->c->corner_type_color_template[0][e]) stbhw__draw_clipped_corner(p->data,p->stride, xpos,ypos, len,len*2, len+1,len+1); if (p->c->corner_type_color_template[3][f]) stbhw__draw_clipped_corner(p->data,p->stride, xpos,ypos, len,len*2, len+1,len*2+1); stbhw__set_pixel(p->data, p->stride, xpos , ypos , stbhw__corner_colors[0][a]); stbhw__set_pixel(p->data, p->stride, xpos , ypos+len , stbhw__corner_colors[3][b]); stbhw__set_pixel(p->data, p->stride, xpos , ypos+2*len+1, stbhw__corner_colors[2][c]); stbhw__set_pixel(p->data, p->stride, xpos+len+1, ypos , stbhw__corner_colors[1][d]); stbhw__set_pixel(p->data, p->stride, xpos+len+1, ypos+len , stbhw__corner_colors[0][e]); stbhw__set_pixel(p->data, p->stride, xpos+len+1, ypos+2*len+1, stbhw__corner_colors[3][f]); } // generates a template image, assuming data is 3*w*h bytes long, RGB format STBHW_EXTERN int stbhw_make_template(stbhw_config *c, unsigned char *data, int w, int h, int stride_in_bytes) { stbhw__process p; int i; p.data = data; p.w = w; p.h = h; p.stride = stride_in_bytes; p.ts = 0; p.c = c; if (c->is_corner) { p.process_h_rect = stbhw__corner_process_h_rect; p.process_v_rect = stbhw__corner_process_v_rect; } else { p.process_h_rect = stbhw__edge_process_h_rect; p.process_v_rect = stbhw__edge_process_v_rect; } for (i=0; i < p.h; ++i) memset(p.data + i*p.stride, 255, 3*p.w); if (!stbhw__process_template(&p)) return 0; if (c->is_corner) { // write out binary information in first line of image for (i=0; i < 4; ++i) data[w*3-1-i] = c->num_color[i]; data[w*3-1-i] = c->num_vary_x; data[w*3-2-i] = c->num_vary_y; data[w*3-3-i] = c->short_side_len; data[w*3-4-i] = 0xc0; } else { for (i=0; i < 6; ++i) data[w*3-1-i] = c->num_color[i]; data[w*3-1-i] = c->num_vary_x; data[w*3-2-i] = c->num_vary_y; data[w*3-3-i] = c->short_side_len; } // make it more obvious it encodes actual data for (i=0; i < 9; ++i) p.data[p.w*3 - 1 - i] ^= i*55; return 1; } #endif // STB_HBWANG_IMPLEMENTATION