--- /dev/null
+/* 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 <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+
+#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 <string.h> // memcpy
+#include <stdlib.h> // malloc
+
+#ifndef STB_HBWANG_RAND
+#include <stdlib.h>
+#define STB_HBWANG_RAND() (rand() >> 4)
+#endif
+
+#ifndef STB_HBWANG_ASSERT
+#include <assert.h>
+#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<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,
+ &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
projects / henge / apc.git / blobdiff