|
|
@@ -0,0 +1,1283 @@
|
|
|
+/* stbhw-v0.01 - public domain - http://nothings.org/stb/stb_herringbone_wang_tile.h
|
|
|
+ Herringbone Wang Tile Generator - Sean Barrett 2014
|
|
|
+
|
|
|
+ This file is in the public domain. In case that declaration is ineffective,
|
|
|
+ you are also granted a license to use and modify it without restriction.
|
|
|
+
|
|
|
+== 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;
|
|
|
+}
|
|
|
+
|
|
|
+*/
|
|
|
+
|
|
|
+//////////////////////////////////////////////////////////////////////////////
|
|
|
+// //
|
|
|
+// 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 can be NULL, or it
|
|
|
+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 void stbhw_make_template(stbhw_config *c, unsigned char *data, int w, int h);
|
|
|
+
|
|
|
+#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)
|
|
|
+{
|
|
|
+ return stbhw_error;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+/////////////////////////////////////////////////////////////
|
|
|
+//
|
|
|
+// 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 {
|
|
|
+ // @TODO: non-corner-tile
|
|
|
+ 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[2] * 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_image(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;
|
|
|
+
|
|
|
+ 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;
|
|
|
+
|
|
|
+ // load all the tiles out of the image
|
|
|
+ return stbhw__process_image(&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]);
|
|
|
+}
|
|
|
+
|
|
|
+#endif // STB_HBWANG_IMPLEMENTATION
|
|
|
+
|
|
|
+#ifndef INCLUDE_STB_IMAGE_WRITE_H
|
|
|
+#define STB_IMAGE_WRITE_IMPLEMENTATION
|
|
|
+#include "stb_image_write.h"
|
|
|
+#endif
|
|
|
+
|
|
|
+int corner_color_count[4] = { 2,2,2,2 };
|
|
|
+
|
|
|
+// whether each color for each type of corner should get the corner template
|
|
|
+int corner_type_color_template[4][4] =
|
|
|
+{
|
|
|
+ { 0,0,0,0 },
|
|
|
+ { 0,0,0,0 },
|
|
|
+ { 0,0,0,0 },
|
|
|
+ { 0,0,0,0 },
|
|
|
+};
|
|
|
+
|
|
|
+// number of duplicates with the exact same edge colors
|
|
|
+int num_variants_x = 1;
|
|
|
+int num_variants_y = 1;
|
|
|
+
|
|
|
+// total number of items in complete set:
|
|
|
+//
|
|
|
+// horizontal items:
|
|
|
+// ec[1] * ec[2] * ec[3] * ec[0] * ec[1] * ec[2] * num_variants_x * num_variants_y
|
|
|
+//
|
|
|
+// vertical items:
|
|
|
+// ec[0] * ce[1] * ce[3] * ce[0] * ec[2] * ec[3] * num_variants_x * num_variants_y
|
|
|
+
|
|
|
+// number of tiles along the short side
|
|
|
+int short_side = 9;
|
|
|
+
|
|
|
+int my_main(int argc, char **argv)
|
|
|
+{
|
|
|
+ stbhw_config c;
|
|
|
+ stbhw__process p;
|
|
|
+ int i;
|
|
|
+
|
|
|
+ if (argc != 2) {
|
|
|
+ fprintf(stderr, "Usage: gentemplate {filename}\n");
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ p.data = NULL;
|
|
|
+ p.h = p.w = p.stride = 0;
|
|
|
+ p.process_h_rect = stbhw__corner_process_h_rect;
|
|
|
+ p.process_v_rect = stbhw__corner_process_v_rect;
|
|
|
+ //p.ts = 0;
|
|
|
+ p.c = & c;
|
|
|
+
|
|
|
+ c.is_corner = 1;
|
|
|
+ c.short_side_len = short_side;
|
|
|
+ c.num_vary_x = num_variants_x;
|
|
|
+ c.num_vary_y = num_variants_y;
|
|
|
+ memcpy(c.num_color, corner_color_count, sizeof(corner_color_count));
|
|
|
+
|
|
|
+ stbhw__process_image(&p);
|
|
|
+
|
|
|
+ // write out binary information in first line of image
|
|
|
+ for (i=0; i < 4; ++i)
|
|
|
+ p.data[p.w*3-1-i] = c.num_color[i];
|
|
|
+ p.data[p.w*3-1-i] = num_variants_x;
|
|
|
+ p.data[p.w*3-2-i] = num_variants_y;
|
|
|
+ p.data[p.w*3-3-i] = short_side;
|
|
|
+ p.data[p.w*3-4-i] = 0xc0;
|
|
|
+
|
|
|
+ // make it more obvious it encodes actual data
|
|
|
+ for (i=0; i < 9; ++i)
|
|
|
+ p.data[p.w*3 - 1 - i] ^= i*55;
|
|
|
+
|
|
|
+ stbi_write_png(argv[1], p.w, p.h, 3, p.data, p.w*3);
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+/*
|
|
|
+// number of colors for each edge based on above diagram:
|
|
|
+int edge_colors[6] = { 1,1,1,1,1,1, };
|
|
|
+
|
|
|
+// number of duplicates with the exact same edge colors
|
|
|
+int num_variants_x = 4;
|
|
|
+int num_variants_y = 4;
|
|
|
+
|
|
|
+// total number of items in complete set:
|
|
|
+//
|
|
|
+// horizontal items:
|
|
|
+// ec[0] * ec[1] * ec[2] * ec[3] * ec[4] * ec[2] * num_variants_x * num_variants_y
|
|
|
+//
|
|
|
+// vertical items:
|
|
|
+// ec[0] * ce[1] * ce[5] * ce[3] * ec[4] * ec[5] * num_variants_x * num_variants_y
|
|
|
+
|
|
|
+// number of tiles along the short side
|
|
|
+int short_side = 12;
|
|
|
+
|
|
|
+int main(int argc, char **argv)
|
|
|
+{
|
|
|
+ int w,h,i;
|
|
|
+ unsigned char *data;
|
|
|
+
|
|
|
+ if (argc != 2) {
|
|
|
+ fprintf(stderr, "Usage: gentemplate {filename}\n");
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+
|
|
|
+ memcpy(ec, edge_colors, sizeof(edge_colors));
|
|
|
+ num_vx = num_variants_x;
|
|
|
+ num_vy = num_variants_y;
|
|
|
+
|
|
|
+ data = process_image(NULL, &w, &h, short_side);
|
|
|
+
|
|
|
+ // write out binary information in first line of image
|
|
|
+ for (i=0; i < 6; ++i)
|
|
|
+ data[w*3-1-i] = ec[i];
|
|
|
+ data[w*3-1-i] = num_variants_x;
|
|
|
+ data[w*3-2-i] = num_variants_y;
|
|
|
+ data[w*3-3-i] = short_side;
|
|
|
+
|
|
|
+ // make it more obvious it encodes actual data
|
|
|
+ for (i=0; i < 9; ++i)
|
|
|
+ data[w*3 - 1 - i] ^= i*55;
|
|
|
+
|
|
|
+ stbi_write_png(argv[1], w, h, 3, data, w*3);
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+*/
|
Sean Barrett