update ase2ini
parent
6da10bec7c
commit
d3f3abed02
1348
tools/3rd_aseprite.h
1348
tools/3rd_aseprite.h
File diff suppressed because it is too large
Load Diff
|
|
@ -1,886 +0,0 @@
|
||||||
// atlasc.c
|
|
||||||
// Copyright 2019 Sepehr Taghdisian (septag@github). All rights reserved.
|
|
||||||
// License: https://github.com/septag/atlasc#license-bsd-2-clause
|
|
||||||
//
|
|
||||||
// sx_math.h
|
|
||||||
// Copyright 2018 Sepehr Taghdisian (septag@github). All rights reserved.
|
|
||||||
// License: https://github.com/septag/sx#license-bsd-2-clause
|
|
||||||
|
|
||||||
#ifndef ATLASC_HEADER
|
|
||||||
#define ATLASC_HEADER
|
|
||||||
|
|
||||||
#define ATLASC_VERSION "1.2.3"
|
|
||||||
|
|
||||||
#include <stdbool.h>
|
|
||||||
#include <stdint.h>
|
|
||||||
#include <limits.h>
|
|
||||||
|
|
||||||
#ifndef __cplusplus
|
|
||||||
#define ATLAS_CAST
|
|
||||||
#else
|
|
||||||
#define ATLAS_CAST(T) T
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
typedef union vec2 { struct { float x, y; }; float f[2]; } vec2;
|
|
||||||
typedef union vec3 { struct { float x, y, z; }; float f[3]; } vec3;
|
|
||||||
typedef union vec2i { struct { int x, y; }; int n[2]; } vec2i;
|
|
||||||
typedef union recti { struct { int xmin, ymin, xmax, ymax; }; struct { vec2i vmin, vmax; }; int f[4]; } recti;
|
|
||||||
|
|
||||||
typedef struct atlas_flags {
|
|
||||||
int alpha_threshold;
|
|
||||||
float dist_threshold;
|
|
||||||
int max_width;
|
|
||||||
int max_height;
|
|
||||||
int border;
|
|
||||||
int pot;
|
|
||||||
int padding;
|
|
||||||
int mesh;
|
|
||||||
int max_verts_per_mesh;
|
|
||||||
float scale;
|
|
||||||
} atlas_flags;
|
|
||||||
|
|
||||||
typedef struct atlas_image {
|
|
||||||
uint8_t* pixels; // only supports 32bpp RGBA format
|
|
||||||
int width;
|
|
||||||
int height;
|
|
||||||
char *name;
|
|
||||||
} atlas_image;
|
|
||||||
|
|
||||||
typedef struct atlas_sprite {
|
|
||||||
uint8_t* src_image; // RGBA image buffer (32bpp)
|
|
||||||
vec2i src_size; // widthxheight
|
|
||||||
recti sprite_rect; // cropped rectangle relative to sprite's source image (pixels)
|
|
||||||
recti sheet_rect; // rectangle in final sheet (pixels)
|
|
||||||
char *name;
|
|
||||||
unsigned frame;
|
|
||||||
|
|
||||||
// sprite-mesh data (if flag is set. see atlas_flags)
|
|
||||||
uint16_t num_tris;
|
|
||||||
int num_points;
|
|
||||||
vec2i* pts;
|
|
||||||
vec2i* uvs;
|
|
||||||
uint16_t* tris;
|
|
||||||
} atlas_sprite;
|
|
||||||
|
|
||||||
typedef struct atlas_t {
|
|
||||||
atlas_sprite* sprites;
|
|
||||||
int num_sprites;
|
|
||||||
int* frames;
|
|
||||||
int num_frames;
|
|
||||||
atlas_image output;
|
|
||||||
} atlas_t;
|
|
||||||
|
|
||||||
// receives input files and common arguments. returns atlas_t
|
|
||||||
// you have to free the data after use with `atlas_free`
|
|
||||||
atlas_t* atlas_loadfiles(array(char*) files, atlas_flags flags);
|
|
||||||
|
|
||||||
// receives input image buffers and common arguments. returns atlas_t
|
|
||||||
// you have to free the data after use with `atlas_free`
|
|
||||||
atlas_t* atlas_loadimages(array(atlas_image) images, atlas_flags flags);
|
|
||||||
|
|
||||||
//
|
|
||||||
bool atlas_save(const char *outfile, const atlas_t* atlas, atlas_flags flags);
|
|
||||||
|
|
||||||
// frees atlas_t memory
|
|
||||||
void atlas_free(atlas_t* atlas);
|
|
||||||
|
|
||||||
// returns the last error string
|
|
||||||
const char* atlas_last_error();
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
#endif // ATLASC_HEADER
|
|
||||||
|
|
||||||
//
|
|
||||||
#ifdef ATLASC_IMPLEMENTATION
|
|
||||||
#include <math.h>
|
|
||||||
#include <assert.h>
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// Types/Primitives
|
|
||||||
|
|
||||||
#define vec2(x,y) (ATLAS_CAST(vec2) { (float)(x), (float)(y) })
|
|
||||||
#define vec3(x,y,z) (ATLAS_CAST(vec3) { (float)(x), (float)(y), (float)(z) })
|
|
||||||
#define vec2i(x,y) (ATLAS_CAST(vec2i) { (int)(x), (int)(y) })
|
|
||||||
#define recti(x,y,X,Y) (ATLAS_CAST(recti) { (int)(x), (int)(y), (int)(X), (int)(Y) })
|
|
||||||
|
|
||||||
#define minf(a,b) ((a) < (b) ? (a) : (b))
|
|
||||||
#define maxf(a,b) ((a) > (b) ? (a) : (b))
|
|
||||||
#define clampf(a,b,c) ( (a) < (b) ? (b) : (a) > (c) ? (c) : (a))
|
|
||||||
|
|
||||||
static int nearest_pow2(int n) { return --n, n |= n >> 1, n |= n >> 2, n |= n >> 4, n |= n >> 8, n |= n >> 16, ++n; } // https://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
|
|
||||||
static float sx_abs(float _a) { union { float f; unsigned int ui; } u = { _a }; return u.ui &= 0x7FFFFFFF, u.f; }
|
|
||||||
static bool equalf(float _a, float _b, float _epsilon) { const float lhs = sx_abs(_a - _b), aa = sx_abs(_a), ab = sx_abs(_b), rhs = _epsilon * maxf(1.0f, maxf(aa, ab)); return lhs <= rhs; } // http://realtimecollisiondetection.net/blog/?t=89
|
|
||||||
|
|
||||||
static vec3 cross3(const vec3 _a, const vec3 _b) { return vec3(_a.y * _b.z - _a.z * _b.y, _a.z * _b.x - _a.x * _b.z, _a.x * _b.y - _a.y * _b.x); }
|
|
||||||
|
|
||||||
static float dot2(const vec2 _a, const vec2 _b) { return _a.x * _b.x + _a.y * _b.y; }
|
|
||||||
static float len2(const vec2 _a) { return sqrt(dot2(_a, _a)); }
|
|
||||||
static vec2 norm2(const vec2 _a) { const float len = len2(_a); /*assert(len > 0 && "Divide by zero");*/ return vec2(_a.x / (len + !len), _a.y / (len + !len)); }
|
|
||||||
static vec2 add2(const vec2 _a, const vec2 _b) { return vec2(_a.x + _b.x, _a.y + _b.y); }
|
|
||||||
static vec2 sub2(const vec2 _a, const vec2 _b) { return vec2(_a.x - _b.x, _a.y - _b.y); }
|
|
||||||
static vec2 scale2(const vec2 _a, float _b) { return vec2(_a.x * _b, _a.y * _b); }
|
|
||||||
|
|
||||||
static vec2i add2i(const vec2i _a, const vec2i _b) { return vec2i(_a.x + _b.x, _a.y + _b.y); }
|
|
||||||
static vec2i sub2i(const vec2i _a, const vec2i _b) { return vec2i(_a.x - _b.x, _a.y - _b.y); }
|
|
||||||
static vec2i min2i(const vec2i _a, const vec2i _b) { return vec2i(minf(_a.x, _b.x), minf(_a.y, _b.y)); }
|
|
||||||
static vec2i max2i(const vec2i _a, const vec2i _b) { return vec2i(maxf(_a.x, _b.x), maxf(_a.y, _b.y)); }
|
|
||||||
|
|
||||||
static recti rectiwh(int _x, int _y, int _w, int _h) { return recti(_x, _y, _x + _w, _y + _h); }
|
|
||||||
static recti recti_expand(const recti rc, const vec2i expand) { return recti(rc.xmin - expand.x, rc.ymin - expand.y, rc.xmax + expand.x, rc.ymax + expand.y); }
|
|
||||||
static void recti_add_point(recti* rc, const vec2i pt) { rc->vmin = min2i(rc->vmin, pt); rc->vmax = max2i(rc->vmax, pt); }
|
|
||||||
|
|
||||||
// ----------------------------------------------------------------------------
|
|
||||||
|
|
||||||
#ifndef ATLAS_REALLOC
|
|
||||||
#define ATLAS_REALLOC realloc
|
|
||||||
#endif
|
|
||||||
#ifndef ATLAS_MSIZE
|
|
||||||
#define ATLAS_MSIZE _msize
|
|
||||||
#endif
|
|
||||||
#ifndef ATLAS_CALLOC
|
|
||||||
#define ATLAS_CALLOC(n,m) memset(ATLAS_REALLOC(0, (n)*(m)), 0, (n)*(m))
|
|
||||||
#endif
|
|
||||||
#ifndef ATLAS_FREE
|
|
||||||
#define ATLAS_FREE(ptr) ((ptr) = ATLAS_REALLOC((ptr), 0))
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#define align_mask(_value, _mask) (((_value) + (_mask)) & ((~0) & (~(_mask))))
|
|
||||||
|
|
||||||
static void panic_if(int fail) { if(fail) exit(-fprintf(stderr, "out of memory!\n")); }
|
|
||||||
|
|
||||||
static void path_unixpath(char *buf, unsigned buflen, const char *inpath) {
|
|
||||||
snprintf(buf, buflen, "%s", inpath);
|
|
||||||
while( strchr(buf, '\\') ) *strchr(buf, '\\') = '/';
|
|
||||||
}
|
|
||||||
static void path_basename(char *buf, unsigned buflen, const char *inpath) {
|
|
||||||
const char *a = strrchr(inpath, '\\');
|
|
||||||
const char *b = strrchr(inpath, '/');
|
|
||||||
snprintf(buf, buflen, "%s", a > b ? a+1 : b > a ? b+1 : inpath );
|
|
||||||
}
|
|
||||||
static bool path_isfile(const char* filepath) {
|
|
||||||
FILE *f = fopen(filepath, "rb");
|
|
||||||
return f ? fclose(f), 1 : 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
static char g_error_str[512];
|
|
||||||
const char* atlas_last_error()
|
|
||||||
{
|
|
||||||
return g_error_str;
|
|
||||||
}
|
|
||||||
|
|
||||||
static void atlas__free_sprites(atlas_sprite* sprites, int num_sprites)
|
|
||||||
{
|
|
||||||
for (int i = 0; i < num_sprites; i++) {
|
|
||||||
if (sprites[i].src_image) {
|
|
||||||
stbi_image_free(sprites[i].src_image);
|
|
||||||
}
|
|
||||||
|
|
||||||
if (sprites[i].tris) {
|
|
||||||
ATLAS_FREE(sprites[i].tris);
|
|
||||||
}
|
|
||||||
|
|
||||||
if (sprites[i].pts) {
|
|
||||||
ATLAS_FREE(sprites[i].pts);
|
|
||||||
}
|
|
||||||
|
|
||||||
if (sprites[i].uvs) {
|
|
||||||
ATLAS_FREE(sprites[i].uvs);
|
|
||||||
}
|
|
||||||
|
|
||||||
if (sprites[i].name) {
|
|
||||||
ATLAS_FREE(sprites[i].name);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
ATLAS_FREE(sprites);
|
|
||||||
}
|
|
||||||
|
|
||||||
static void atlas__blit(uint8_t* dst, int dst_x, int dst_y, int dst_pitch, const uint8_t* src,
|
|
||||||
int src_x, int src_y, int src_w, int src_h, int src_pitch, int bpp)
|
|
||||||
{
|
|
||||||
assert(dst);
|
|
||||||
assert(src);
|
|
||||||
|
|
||||||
const int pixel_sz = bpp / 8;
|
|
||||||
const uint8_t* src_ptr = src + src_y * src_pitch + src_x * pixel_sz;
|
|
||||||
uint8_t* dst_ptr = dst + dst_y * dst_pitch + dst_x * pixel_sz;
|
|
||||||
for (int y = src_y; y < (src_y + src_h); y++) {
|
|
||||||
memcpy(dst_ptr, src_ptr, src_w * pixel_sz);
|
|
||||||
src_ptr += src_pitch;
|
|
||||||
dst_ptr += dst_pitch;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
static vec2 atlas__itof2(const s2o_point p)
|
|
||||||
{
|
|
||||||
return vec2((float)p.x, (float)p.y);
|
|
||||||
}
|
|
||||||
|
|
||||||
// modified version of:
|
|
||||||
// https://github.com/anael-seghezzi/Maratis-Tiny-C-library/blob/master/include/m_raster.h
|
|
||||||
static bool atlas__test_line(const uint8_t* buffer, int w, int h, s2o_point p0, s2o_point p1)
|
|
||||||
{
|
|
||||||
const uint8_t* data = buffer;
|
|
||||||
|
|
||||||
int x0 = p0.x;
|
|
||||||
int y0 = p0.y;
|
|
||||||
int x1 = p1.x;
|
|
||||||
int y1 = p1.y;
|
|
||||||
int dx = abs(x1 - x0), sx = x0 < x1 ? 1 : -1;
|
|
||||||
int dy = -abs(y1 - y0), sy = y0 < y1 ? 1 : -1;
|
|
||||||
int err = dx + dy, e2;
|
|
||||||
|
|
||||||
while (1) {
|
|
||||||
if (x0 > -1 && y0 > -1 && x0 < w && y0 < h) {
|
|
||||||
const uint8_t* pixel = data + (y0 * w + x0);
|
|
||||||
if (*pixel)
|
|
||||||
return true; // line intersects with image data
|
|
||||||
}
|
|
||||||
|
|
||||||
if (x0 == x1 && y0 == y1)
|
|
||||||
break;
|
|
||||||
|
|
||||||
e2 = 2 * err;
|
|
||||||
if (e2 >= dy) {
|
|
||||||
err += dy;
|
|
||||||
x0 += sx;
|
|
||||||
}
|
|
||||||
if (e2 <= dx) {
|
|
||||||
err += dx;
|
|
||||||
y0 += sy;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
// returns true if 'pts' buffer is changed
|
|
||||||
static bool atlas__offset_pt(s2o_point* pts, int num_pts, int pt_idx, float amount, int w, int h)
|
|
||||||
{
|
|
||||||
s2o_point ipt = pts[pt_idx];
|
|
||||||
s2o_point _ipt = ipt;
|
|
||||||
vec2 pt = atlas__itof2(ipt);
|
|
||||||
vec2 prev_pt = (pt_idx > 0) ? atlas__itof2(pts[pt_idx - 1]) : atlas__itof2(pts[num_pts - 1]);
|
|
||||||
vec2 next_pt = (pt_idx + 1) < num_pts ? atlas__itof2(pts[pt_idx + 1]) : atlas__itof2(pts[0]);
|
|
||||||
vec2 edge1 = norm2(sub2(prev_pt, pt));
|
|
||||||
vec2 edge2 = norm2(sub2(next_pt, pt));
|
|
||||||
|
|
||||||
// calculate normal vector to move the point away from the polygon
|
|
||||||
vec2 n;
|
|
||||||
vec3 c = cross3(vec3(edge1.x, edge1.y, 0), vec3(edge2.x, edge2.y, 0));
|
|
||||||
if (equalf(c.z, 0.0f, 0.00001f)) {
|
|
||||||
n = scale2(vec2(-edge1.y, edge1.x), amount);
|
|
||||||
} else {
|
|
||||||
// c.z < 0 -> point intersecting convex edges
|
|
||||||
// c.z > 0 -> point intersecting concave edges
|
|
||||||
float k = c.z < 0.0f ? -1.0f : 1.0f;
|
|
||||||
n = scale2(norm2(add2(edge1, edge2)), k * amount);
|
|
||||||
}
|
|
||||||
|
|
||||||
pt = add2(pt, n);
|
|
||||||
ipt.x = (int)pt.x;
|
|
||||||
ipt.y = (int)pt.y;
|
|
||||||
ipt.x = clampf(ipt.x, 0, w);
|
|
||||||
ipt.y = clampf(ipt.y, 0, h);
|
|
||||||
pts[pt_idx] = ipt;
|
|
||||||
return (_ipt.x != ipt.x) || (_ipt.y != ipt.y);
|
|
||||||
}
|
|
||||||
|
|
||||||
static void atlas__fix_outline_pts(const uint8_t* thresholded, int tw, int th, s2o_point* pts,
|
|
||||||
int num_pts)
|
|
||||||
{
|
|
||||||
// NOTE: winding is assumed to be CW
|
|
||||||
const float offset_amount = 2.0f;
|
|
||||||
|
|
||||||
for (int i = 0; i < num_pts; i++) {
|
|
||||||
s2o_point pt = pts[i];
|
|
||||||
int next_i = (i + 1) < num_pts ? (i + 1) : 0;
|
|
||||||
|
|
||||||
// assert(!thresholded[pt.y * tw + pt.x]); // point shouldn't be inside threshold
|
|
||||||
|
|
||||||
s2o_point next_pt = pts[next_i];
|
|
||||||
while (atlas__test_line(thresholded, tw, th, pt, next_pt)) {
|
|
||||||
if (!atlas__offset_pt(pts, num_pts, i, offset_amount, tw, th))
|
|
||||||
break;
|
|
||||||
atlas__offset_pt(pts, num_pts, next_i, offset_amount, tw, th);
|
|
||||||
// refresh points for the new line intersection test
|
|
||||||
pt = pts[i];
|
|
||||||
next_pt = pts[next_i];
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
static void atlas__make_mesh(atlas_sprite* spr, const s2o_point* pts, int pt_count, int max_verts,
|
|
||||||
const uint8_t* thresholded, int width, int height)
|
|
||||||
{
|
|
||||||
s2o_point* temp_pts = ATLAS_CALLOC(pt_count,sizeof(s2o_point));
|
|
||||||
panic_if(!temp_pts);
|
|
||||||
|
|
||||||
memcpy(temp_pts, pts, sizeof(s2o_point)*pt_count);
|
|
||||||
int num_verts = pt_count;
|
|
||||||
|
|
||||||
if (width > 1 && height > 1) {
|
|
||||||
const float delta = 0.5f;
|
|
||||||
const float threshold_start = 0.5f;
|
|
||||||
float threshold = threshold_start;
|
|
||||||
|
|
||||||
for(;;) {
|
|
||||||
s2o_distance_based_path_simplification(temp_pts, &num_verts, threshold);
|
|
||||||
|
|
||||||
if(num_verts <= max_verts) break;
|
|
||||||
|
|
||||||
memcpy(temp_pts, pts, sizeof(s2o_point)*pt_count);
|
|
||||||
num_verts = pt_count;
|
|
||||||
|
|
||||||
threshold += delta;
|
|
||||||
}
|
|
||||||
|
|
||||||
// fix any collisions with the actual image // @r-lyeh: method below is buggy. will return dupe points
|
|
||||||
atlas__fix_outline_pts(thresholded, width, height, temp_pts, num_verts);
|
|
||||||
}
|
|
||||||
|
|
||||||
//< @r-lyeh: remove dupes
|
|
||||||
for (int i = 0; i < num_verts - 1; i++) {
|
|
||||||
for (int j = i + 1; j < num_verts; j++) {
|
|
||||||
if( temp_pts[i].x == temp_pts[j].x && temp_pts[i].y == temp_pts[j].y ) {
|
|
||||||
temp_pts[j].x = temp_pts[num_verts - 1].x;
|
|
||||||
temp_pts[j].y = temp_pts[num_verts - 1].y;
|
|
||||||
--num_verts;
|
|
||||||
--j;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
//<
|
|
||||||
|
|
||||||
// triangulate
|
|
||||||
del_point2d_t* dpts = ATLAS_CALLOC(num_verts, sizeof(del_point2d_t));
|
|
||||||
panic_if(!dpts);
|
|
||||||
|
|
||||||
for (int i = 0; i < num_verts; i++) {
|
|
||||||
dpts[i].x = (double)temp_pts[i].x;
|
|
||||||
dpts[i].y = (double)temp_pts[i].y;
|
|
||||||
//printf("%d) %f,%f\n", i, dpts[i].x, dpts[i].y); //< @r-lyeh: debug dupe points
|
|
||||||
}
|
|
||||||
|
|
||||||
delaunay2d_t* polys = delaunay2d_from(dpts, num_verts);
|
|
||||||
assert(polys);
|
|
||||||
tri_delaunay2d_t* tris = tri_delaunay2d_from(polys);
|
|
||||||
assert(tris);
|
|
||||||
ATLAS_FREE(dpts);
|
|
||||||
delaunay2d_release(polys);
|
|
||||||
|
|
||||||
assert(tris->num_triangles < UINT16_MAX);
|
|
||||||
spr->tris = ATLAS_CALLOC(tris->num_triangles * 3,sizeof(uint16_t));
|
|
||||||
spr->pts = ATLAS_CALLOC(tris->num_points, sizeof(vec2i));
|
|
||||||
assert(spr->tris);
|
|
||||||
assert(spr->pts);
|
|
||||||
|
|
||||||
for (unsigned int i = 0; i < tris->num_triangles; i++) {
|
|
||||||
unsigned int index = i * 3;
|
|
||||||
spr->tris[index] = (uint16_t)tris->tris[index];
|
|
||||||
spr->tris[index + 1] = (uint16_t)tris->tris[index + 1];
|
|
||||||
spr->tris[index + 2] = (uint16_t)tris->tris[index + 2];
|
|
||||||
}
|
|
||||||
for (unsigned int i = 0; i < tris->num_points; i++) {
|
|
||||||
spr->pts[i] = vec2i((int)tris->points[i].x, (int)tris->points[i].y);
|
|
||||||
}
|
|
||||||
spr->num_tris = (uint16_t)tris->num_triangles;
|
|
||||||
spr->num_points = (int)tris->num_points;
|
|
||||||
|
|
||||||
tri_delaunay2d_release(tris);
|
|
||||||
ATLAS_FREE(temp_pts);
|
|
||||||
}
|
|
||||||
|
|
||||||
atlas_t* atlas_loadimages(array(atlas_image) images, atlas_flags flags)
|
|
||||||
{
|
|
||||||
assert(images);
|
|
||||||
|
|
||||||
array(int) frames = 0;
|
|
||||||
array(atlas_sprite) sprites = 0;
|
|
||||||
|
|
||||||
for (int i = 0; i < array_count(images); i++) {
|
|
||||||
|
|
||||||
// find is_cached
|
|
||||||
{
|
|
||||||
int found = 0, k = 0;
|
|
||||||
static array(uint64_t) cache = 0;
|
|
||||||
static array(uint64_t) index = 0;
|
|
||||||
uint64_t hash = hash_init;
|
|
||||||
hash = hash_bin(&images[i].width, sizeof(images[i].width), hash);
|
|
||||||
hash = hash_bin(&images[i].height, sizeof(images[i].height), hash);
|
|
||||||
hash = hash_bin((char*)images[i].pixels, images[i].width * images[i].height * 4, hash);
|
|
||||||
for (; k < array_count(cache); ++k)
|
|
||||||
if (cache[k] == hash) { found = 1; break; }
|
|
||||||
if (found) {
|
|
||||||
array_push(frames, index[k]);
|
|
||||||
continue;
|
|
||||||
} else {
|
|
||||||
array_push(cache, hash);
|
|
||||||
array_push(index, k);
|
|
||||||
array_push(frames, k);
|
|
||||||
}
|
|
||||||
//printf("%d) %llx\n", array_count(cache), hash);
|
|
||||||
}
|
|
||||||
|
|
||||||
atlas_sprite zero = {0};
|
|
||||||
atlas_sprite* spr = &zero;
|
|
||||||
if(images[i].name) spr->name = STRDUP(images[i].name);
|
|
||||||
spr->frame = i;
|
|
||||||
|
|
||||||
spr->src_size.x = images[i].width;
|
|
||||||
spr->src_size.y = images[i].height;
|
|
||||||
assert(images[i].width > 0 && images[i].height > 0);
|
|
||||||
assert(images[i].pixels);
|
|
||||||
uint8_t* pixels = images[i].pixels;
|
|
||||||
|
|
||||||
// rescale
|
|
||||||
if (!equalf(flags.scale, 1.0f, 0.0001f)) {
|
|
||||||
int target_w = (int)((float)spr->src_size.x * flags.scale);
|
|
||||||
int target_h = (int)((float)spr->src_size.y * flags.scale);
|
|
||||||
uint8_t* resized_pixels = ATLAS_CALLOC(1, 4 * target_w * target_h);
|
|
||||||
panic_if(!resized_pixels);
|
|
||||||
|
|
||||||
if (!stbir_resize_uint8(pixels, spr->src_size.x, spr->src_size.y, 4 * spr->src_size.x,
|
|
||||||
resized_pixels, target_w, target_h, 4 * target_w, 4)) {
|
|
||||||
snprintf(g_error_str, sizeof(g_error_str), "could not resize image: #%d", i + 1);
|
|
||||||
atlas__free_sprites(sprites, array_count(sprites));
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
stbi_image_free(pixels);
|
|
||||||
|
|
||||||
spr->src_size.x = target_w;
|
|
||||||
spr->src_size.y = target_h;
|
|
||||||
pixels = resized_pixels;
|
|
||||||
}
|
|
||||||
|
|
||||||
spr->src_image = pixels;
|
|
||||||
|
|
||||||
recti sprite_rect = {0};
|
|
||||||
int pt_count = 0;
|
|
||||||
s2o_point* pts = 0;
|
|
||||||
uint8_t* alpha = s2o_rgba_to_alpha(spr->src_image, spr->src_size.x, spr->src_size.y);
|
|
||||||
uint8_t* thresholded = s2o_alpha_to_thresholded(alpha, spr->src_size.x, spr->src_size.y, flags.alpha_threshold);
|
|
||||||
free(alpha);
|
|
||||||
|
|
||||||
if (flags.mesh && spr->src_size.x > 1 && spr->src_size.y > 1) {
|
|
||||||
uint8_t* dilate_thres = s2o_dilate_thresholded(thresholded, spr->src_size.x, spr->src_size.y);
|
|
||||||
|
|
||||||
uint8_t* outlined = s2o_thresholded_to_outlined(dilate_thres, spr->src_size.x, spr->src_size.y);
|
|
||||||
free(dilate_thres);
|
|
||||||
|
|
||||||
pts = s2o_extract_outline_path(outlined, spr->src_size.x, spr->src_size.y, &pt_count, NULL);
|
|
||||||
free(outlined);
|
|
||||||
|
|
||||||
//< @r-lyeh @fixme: many sprites will return extremely low num of points (like 8) even if the sprite is complex enough.
|
|
||||||
//< this will lead to produce here a nearly zero sprite_rect, then sheet_rect, then eventually an empty frame at end of pipeline.
|
|
||||||
|
|
||||||
// calculate cropped rectangle
|
|
||||||
sprite_rect = recti(INT_MAX, INT_MAX, INT_MIN, INT_MIN);
|
|
||||||
for (int k = 0; k < pt_count; k++) {
|
|
||||||
recti_add_point(&sprite_rect, vec2i(pts[k].x, pts[k].y));
|
|
||||||
}
|
|
||||||
sprite_rect.xmax++;
|
|
||||||
sprite_rect.ymax++;
|
|
||||||
} else {
|
|
||||||
sprite_rect = recti(0, 0, spr->src_size.x, spr->src_size.y);
|
|
||||||
pt_count = 4;
|
|
||||||
pts = ATLAS_CALLOC(pt_count, sizeof(s2o_point));
|
|
||||||
pts[0] = (s2o_point) {0, 0};
|
|
||||||
pts[1] = (s2o_point) {spr->src_size.x, 0};
|
|
||||||
pts[2] = (s2o_point) {spr->src_size.x, spr->src_size.y};
|
|
||||||
pts[3] = (s2o_point) {0, spr->src_size.y};
|
|
||||||
}
|
|
||||||
|
|
||||||
// generate mesh if set in arguments
|
|
||||||
if (flags.mesh) {
|
|
||||||
atlas__make_mesh(spr, pts, pt_count, flags.max_verts_per_mesh, thresholded,
|
|
||||||
spr->src_size.x, spr->src_size.y);
|
|
||||||
}
|
|
||||||
|
|
||||||
ATLAS_FREE(pts);
|
|
||||||
free(thresholded);
|
|
||||||
spr->sprite_rect = sprite_rect;
|
|
||||||
|
|
||||||
array_push(sprites, *spr);
|
|
||||||
}
|
|
||||||
|
|
||||||
int num_sprites = array_count(sprites);
|
|
||||||
|
|
||||||
// pack sprites into a sheet
|
|
||||||
stbrp_context rp_ctx = {0};
|
|
||||||
int max_width = flags.max_width;
|
|
||||||
int max_height = flags.max_height;
|
|
||||||
int num_rp_nodes = max_width + max_height;
|
|
||||||
stbrp_rect* rp_rects = ATLAS_CALLOC(num_sprites, sizeof(stbrp_rect));
|
|
||||||
stbrp_node* rp_nodes = ATLAS_CALLOC(num_rp_nodes, sizeof(stbrp_node));
|
|
||||||
panic_if(!rp_rects || !rp_nodes);
|
|
||||||
|
|
||||||
for (int i = 0; i < num_sprites; i++) {
|
|
||||||
recti rc = sprites[i].sprite_rect;
|
|
||||||
int rc_resize = (flags.border + flags.padding) * 2;
|
|
||||||
rp_rects[i].w = (rc.xmax - rc.xmin) + rc_resize;
|
|
||||||
rp_rects[i].h = (rc.ymax - rc.ymin) + rc_resize;
|
|
||||||
}
|
|
||||||
stbrp_init_target(&rp_ctx, max_width, max_height, rp_nodes, num_rp_nodes);
|
|
||||||
recti final_rect = recti(INT_MAX, INT_MAX, INT_MIN, INT_MIN);
|
|
||||||
if (stbrp_pack_rects(&rp_ctx, rp_rects, num_sprites)) {
|
|
||||||
for (int i = 0; i < num_sprites; i++) {
|
|
||||||
atlas_sprite* spr = &sprites[i];
|
|
||||||
recti sheet_rect = rectiwh(rp_rects[i].x, rp_rects[i].y, rp_rects[i].w, rp_rects[i].h);
|
|
||||||
|
|
||||||
// calculate the total size of output image
|
|
||||||
recti_add_point(&final_rect, sheet_rect.vmin);
|
|
||||||
recti_add_point(&final_rect, sheet_rect.vmax);
|
|
||||||
|
|
||||||
// shrink back rect and set the real sheet_rect for the sprite
|
|
||||||
spr->sheet_rect =
|
|
||||||
recti_expand(sheet_rect, vec2i(-flags.border, -flags.border));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
int dst_w = final_rect.xmax - final_rect.xmin;
|
|
||||||
int dst_h = final_rect.ymax - final_rect.ymin;
|
|
||||||
// make output size divide by 4 by default
|
|
||||||
dst_w = align_mask(dst_w, 3);
|
|
||||||
dst_h = align_mask(dst_h, 3);
|
|
||||||
|
|
||||||
if (flags.pot) {
|
|
||||||
dst_w = nearest_pow2(dst_w);
|
|
||||||
dst_h = nearest_pow2(dst_h);
|
|
||||||
}
|
|
||||||
|
|
||||||
uint8_t* dst = ATLAS_CALLOC(1, dst_w * dst_h * 4);
|
|
||||||
panic_if(!dst);
|
|
||||||
|
|
||||||
// calculate UVs for sprite meshes
|
|
||||||
if (flags.mesh) {
|
|
||||||
for (int i = 0; i < num_sprites; i++) {
|
|
||||||
atlas_sprite* spr = &sprites[i];
|
|
||||||
// if sprite has mesh, calculate UVs for it
|
|
||||||
if (spr->pts && spr->num_points) {
|
|
||||||
const int padding = flags.padding;
|
|
||||||
vec2i offset = spr->sprite_rect.vmin;
|
|
||||||
vec2i sheet_pos =
|
|
||||||
vec2i(spr->sheet_rect.xmin + padding, spr->sheet_rect.ymin + padding);
|
|
||||||
vec2i* uvs = ATLAS_CALLOC(spr->num_points, sizeof(vec2i));
|
|
||||||
assert(uvs);
|
|
||||||
for (int pi = 0; pi < spr->num_points; pi++) {
|
|
||||||
vec2i pt = spr->pts[pi];
|
|
||||||
uvs[pi] = add2i(sub2i(pt, offset), sheet_pos);
|
|
||||||
}
|
|
||||||
|
|
||||||
spr->uvs = uvs;
|
|
||||||
} // generate uvs
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
for (int i = 0; i < num_sprites; i++) {
|
|
||||||
const atlas_sprite* spr = &sprites[i];
|
|
||||||
|
|
||||||
// calculate UVs for sprite-meshes
|
|
||||||
|
|
||||||
// remove padding and blit from src_image to dst
|
|
||||||
recti dstrc = recti_expand(spr->sheet_rect, vec2i(-flags.padding, -flags.padding));
|
|
||||||
recti srcrc = spr->sprite_rect;
|
|
||||||
atlas__blit(dst, dstrc.xmin, dstrc.ymin, dst_w * 4, spr->src_image, srcrc.xmin, srcrc.ymin,
|
|
||||||
srcrc.xmax - srcrc.xmin, srcrc.ymax - srcrc.ymin, spr->src_size.x * 4, 32);
|
|
||||||
}
|
|
||||||
|
|
||||||
atlas_t* atlas = ATLAS_CALLOC(1, sizeof(atlas_t));
|
|
||||||
panic_if(!atlas);
|
|
||||||
|
|
||||||
atlas->output.pixels = dst;
|
|
||||||
atlas->output.width = dst_w;
|
|
||||||
atlas->output.height = dst_h;
|
|
||||||
atlas->sprites = sprites;
|
|
||||||
atlas->num_sprites = num_sprites;
|
|
||||||
atlas->frames = frames;
|
|
||||||
atlas->num_frames = array_count(frames);
|
|
||||||
|
|
||||||
ATLAS_FREE(rp_nodes);
|
|
||||||
ATLAS_FREE(rp_rects);
|
|
||||||
|
|
||||||
return atlas;
|
|
||||||
}
|
|
||||||
|
|
||||||
static char *atlas_anims = 0;
|
|
||||||
static char *atlas_slices = 0;
|
|
||||||
static char *atlas_current_anim = 0;
|
|
||||||
|
|
||||||
atlas_t* atlas_loadfiles(array(char*) files, atlas_flags flags)
|
|
||||||
{
|
|
||||||
assert(files);
|
|
||||||
|
|
||||||
array(atlas_image) images = 0;
|
|
||||||
|
|
||||||
for (int i = 0; i < array_count(files); ++i) {
|
|
||||||
if (!path_isfile(files[i])) {
|
|
||||||
snprintf(g_error_str, sizeof(g_error_str), "input image not found: %s", files[i]);
|
|
||||||
goto err_cleanup;
|
|
||||||
}
|
|
||||||
|
|
||||||
int comp;
|
|
||||||
atlas_image img = {0};
|
|
||||||
img.pixels = stbi_load(files[i], &img.width, &img.height, &comp, 4);
|
|
||||||
|
|
||||||
#ifdef CUTE_ASEPRITE_H
|
|
||||||
if (!img.pixels) {
|
|
||||||
bool loaded = 0;
|
|
||||||
|
|
||||||
for( ase_t* ase = cute_aseprite_load_from_file(files[i], NULL); ase; cute_aseprite_free(ase), ase = 0, loaded = 1) {
|
|
||||||
ase_tag_t *parent = ase->tags + 0;
|
|
||||||
|
|
||||||
//< abc/def/ghi.aseprite -> ghi
|
|
||||||
if( atlas_current_anim ) *atlas_current_anim = '\0';
|
|
||||||
strcatf(&atlas_current_anim, files[i]);
|
|
||||||
path_basename(atlas_current_anim, strlen(atlas_current_anim), files[i]);
|
|
||||||
if( strrchr(atlas_current_anim, '.')) *strrchr(atlas_current_anim, '.') = '\0';
|
|
||||||
trimspace(atlas_current_anim);
|
|
||||||
//<
|
|
||||||
|
|
||||||
for( int f = 0; f < ase->frame_count; ++f) {
|
|
||||||
ase_frame_t *frame = ase->frames + f;
|
|
||||||
|
|
||||||
// find rect
|
|
||||||
int x = INT_MAX, y = INT_MAX, x2 = INT_MIN, y2 = INT_MIN;
|
|
||||||
for( int c = 0; c < frame->cel_count; ++c ) {
|
|
||||||
ase_cel_t *cel = frame->cels + c;
|
|
||||||
if( cel->layer->flags & ASE_LAYER_FLAGS_VISIBLE ) {
|
|
||||||
if( cel->x < x ) x = cel->x;
|
|
||||||
if( cel->h < y ) y = cel->y;
|
|
||||||
if( (cel->x + cel->w) > x2 ) x2 = cel->x + cel->w;
|
|
||||||
if( (cel->y + cel->h) > y2 ) y2 = cel->y + cel->h;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if (x2 <= 0 || y2 <= 0) { // submit empty frame
|
|
||||||
img.width = 1;
|
|
||||||
img.height = 1;
|
|
||||||
img.pixels = calloc(1, 1*1*4);
|
|
||||||
array_push(images, img);
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
int cx = x;
|
|
||||||
int cy = y;
|
|
||||||
int cw = x2-x;
|
|
||||||
int ch = y2-y;
|
|
||||||
int tn = 4;
|
|
||||||
int tw = ase->w;
|
|
||||||
|
|
||||||
// find clip
|
|
||||||
img.width = cw;
|
|
||||||
img.height = ch;
|
|
||||||
img.pixels = calloc(1, cw*ch*4); // @fixme: because of a stbi_image_free() within rescale section, this should be allocated with stbi allocator
|
|
||||||
for( unsigned y = 0; y < ch; ++y )
|
|
||||||
memcpy((char *)img.pixels + (0+(0+y)*cw)*tn, (char*)frame->pixels + (cx+(cy+y)*tw)*tn, cw*tn);
|
|
||||||
array_push(images, img);
|
|
||||||
}
|
|
||||||
|
|
||||||
static int slice_idx = -1;
|
|
||||||
static int slice_frame_idx = 0;
|
|
||||||
static const char *slice_name = 0;
|
|
||||||
if(!atlas_slices) strcatf(&atlas_slices, "[slices]\n");
|
|
||||||
|
|
||||||
for( int t = 0; t < ase->slice_count; ++t) {
|
|
||||||
ase_slice_t *slice = ase->slices + t;
|
|
||||||
if (!slice_name || strcmp(slice_name, slice->name)) {
|
|
||||||
++slice_idx;
|
|
||||||
strcatf(&atlas_slices, "[%d].sl_name=%s\n", slice_idx, slice->name);
|
|
||||||
strcatf(&atlas_slices, "[%d].sl_frames=", slice_idx);
|
|
||||||
for( int u = 0; u < ase->slice_count; ++u) {
|
|
||||||
if (!strcmp(slice->name, ase->slices[u].name)) {
|
|
||||||
strcatf(&atlas_slices, "%d,", u);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
strcatf(&atlas_slices, "\n");
|
|
||||||
}
|
|
||||||
strcatf(&atlas_slices, "[%d].sl_bounds=%d,%d,%d,%d\n", slice_idx, slice->origin_x, slice->origin_y, slice->w, slice->h);
|
|
||||||
strcatf(&atlas_slices, "[%d].sl_9slice=%d\n", slice_idx, slice->has_center_as_9_slice);
|
|
||||||
if (slice->has_center_as_9_slice)
|
|
||||||
strcatf(&atlas_slices, "[%d].sl_core=%d,%d,%d,%d\n", slice_idx, slice->center_x, slice->center_y, slice->center_w, slice->center_h);
|
|
||||||
|
|
||||||
slice_name = slice->name;
|
|
||||||
++slice_frame_idx;
|
|
||||||
}
|
|
||||||
|
|
||||||
static int anim_idx = 0;
|
|
||||||
if(!atlas_anims) strcatf(&atlas_anims, "[anims]\n");
|
|
||||||
|
|
||||||
for( int t = 0; t < ase->tag_count; ++t) {
|
|
||||||
ase_tag_t *tag = ase->tags + t;
|
|
||||||
|
|
||||||
// find full name
|
|
||||||
int range[2] = {tag->from_frame, tag->to_frame};
|
|
||||||
char name[256] = {0};
|
|
||||||
for( int tt = 0; tt < ase->tag_count; ++tt ) {
|
|
||||||
ase_tag_t *ttag = ase->tags + tt;
|
|
||||||
if( range[0] >= ttag->from_frame && range[1] <= ttag->to_frame )
|
|
||||||
strcat(name, "."), strcat(name, ttag->name);
|
|
||||||
}
|
|
||||||
trimspace(name);
|
|
||||||
|
|
||||||
char *sep = "";
|
|
||||||
strcatf(&atlas_anims, "[%d].name=%s.%s\n", anim_idx, atlas_current_anim, name+1);
|
|
||||||
strcatf(&atlas_anims, "[%d].frames=", anim_idx);
|
|
||||||
if( tag->loop_animation_direction != ASE_ANIMATION_DIRECTION_BACKWARDS)
|
|
||||||
for( int from = tag->from_frame; from <= tag->to_frame; ++from ) {
|
|
||||||
strcatf(&atlas_anims, "%s%d,%d", sep, from, ase->frames[from].duration_milliseconds), sep = ",";
|
|
||||||
}
|
|
||||||
sep = "";
|
|
||||||
if( tag->loop_animation_direction != ASE_ANIMATION_DIRECTION_FORWARDS)
|
|
||||||
for( int from = tag->from_frame; from <= tag->to_frame; ++from ) {
|
|
||||||
strcatf(&atlas_anims, "%s%d,%d", sep, from, ase->frames[from].duration_milliseconds), sep = ",";
|
|
||||||
}
|
|
||||||
strcatf(&atlas_anims,"\n");
|
|
||||||
|
|
||||||
++anim_idx;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if( loaded ) continue;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
if (!img.pixels) {
|
|
||||||
continue; //< @r-lyeh: keep going
|
|
||||||
|
|
||||||
snprintf(g_error_str, sizeof(g_error_str), "invalid image format: %s", files[i]);
|
|
||||||
goto err_cleanup;
|
|
||||||
}
|
|
||||||
|
|
||||||
if( !img.name ) img.name = STRDUP(files[i]);
|
|
||||||
|
|
||||||
array_push(images, img);
|
|
||||||
}
|
|
||||||
|
|
||||||
atlas_t* atlas = atlas_loadimages(images, flags);
|
|
||||||
return atlas;
|
|
||||||
|
|
||||||
err_cleanup:
|
|
||||||
for (int i = 0; i < array_count(images); i++) {
|
|
||||||
if (images[i].pixels) {
|
|
||||||
stbi_image_free(images[i].pixels);
|
|
||||||
}
|
|
||||||
if (images[i].name) {
|
|
||||||
ATLAS_FREE(images[i].name);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
array_free(images);
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
void atlas_free(atlas_t* atlas)
|
|
||||||
{
|
|
||||||
assert(atlas);
|
|
||||||
|
|
||||||
if (atlas->sprites)
|
|
||||||
atlas__free_sprites(atlas->sprites, atlas->num_sprites);
|
|
||||||
if (atlas->frames)
|
|
||||||
ATLAS_FREE(atlas->frames);
|
|
||||||
if (atlas->output.pixels)
|
|
||||||
ATLAS_FREE(atlas->output.pixels);
|
|
||||||
ATLAS_FREE(atlas);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
// custom write function
|
|
||||||
typedef struct {
|
|
||||||
int offset;
|
|
||||||
void *buffer;
|
|
||||||
} stbi_mem_context;
|
|
||||||
static void stbi_write_mem(void *context, void *data, int size) {
|
|
||||||
stbi_mem_context *ctx = (stbi_mem_context*)context;
|
|
||||||
memcpy( ctx->buffer, data, size );
|
|
||||||
ctx->offset += size;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool atlas_save(const char *outfile, const atlas_t *atlas, atlas_flags flags)
|
|
||||||
{
|
|
||||||
assert(outfile);
|
|
||||||
|
|
||||||
const bool is_file = strcmp(outfile, "stdout");
|
|
||||||
const atlas_sprite* sprites = atlas->sprites;
|
|
||||||
const int* frames = atlas->frames;
|
|
||||||
const int num_frames = atlas->num_frames;
|
|
||||||
const int num_sprites = atlas->num_sprites;
|
|
||||||
const uint8_t* dst = atlas->output.pixels;
|
|
||||||
const int dst_w = atlas->output.width;
|
|
||||||
const int dst_h = atlas->output.height;
|
|
||||||
|
|
||||||
char image_filepath[256];
|
|
||||||
char image_filename[256];
|
|
||||||
snprintf(image_filepath, sizeof(image_filepath), "%s.png", outfile);
|
|
||||||
path_basename(image_filename, sizeof(image_filename), image_filepath);
|
|
||||||
|
|
||||||
stbi_write_png_compression_level = 5; // 8
|
|
||||||
|
|
||||||
// write texture, if needed
|
|
||||||
if( is_file ) {
|
|
||||||
if (!stbi_write_png(image_filepath, dst_w, dst_h, 4, dst, dst_w * 4)) {
|
|
||||||
fprintf(stderr, "could not write image file `%s`\n", image_filepath);
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// write atlas description into .ini file
|
|
||||||
FILE *writer = is_file ? fopen(outfile, "wt") : stdout;
|
|
||||||
if (!writer) {
|
|
||||||
fprintf(stderr, "could not write ini file `%s`\n", outfile);
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
fprintf(writer, "[atlas]\n");
|
|
||||||
|
|
||||||
if (is_file) {
|
|
||||||
fprintf(writer, "file=%s\n", image_filepath);
|
|
||||||
} else {
|
|
||||||
stbi_mem_context ctx = {0, ATLAS_CALLOC(1, dst_w*dst_h*4+256) };
|
|
||||||
int result = stbi_write_png_to_func(stbi_write_mem, &ctx, dst_w, dst_h, 4, dst, dst_w*4);
|
|
||||||
char *b64 = base64_encode(ctx.buffer, ctx.offset);
|
|
||||||
fprintf(writer, "bitmap=%s\n", b64); // %d:%s\n", ctx.offset, b64);
|
|
||||||
// ATLAS_FREE(ctx.buffer);
|
|
||||||
// free(b64);
|
|
||||||
}
|
|
||||||
|
|
||||||
fprintf(writer, "size=%d,%d\n", dst_w, dst_h);
|
|
||||||
fprintf(writer, "border=%d,%d\n", flags.border, flags.border);
|
|
||||||
fprintf(writer, "padding=%d,%d\n", flags.padding, flags.padding);
|
|
||||||
|
|
||||||
for( int i = 0; i < num_frames; i++ ) {
|
|
||||||
const atlas_sprite* spr = sprites + frames[i];
|
|
||||||
|
|
||||||
char name[256];
|
|
||||||
path_unixpath(name, sizeof(name), spr->name ? spr->name : "");
|
|
||||||
|
|
||||||
if(name[0])
|
|
||||||
fprintf(writer, "[%d].name=%s\n", i, name);
|
|
||||||
fprintf(writer, "[%d].frame=%u\n", i, spr->frame);
|
|
||||||
//fprintf(writer, "[%d].size=%d,%d\n", i, spr->src_size.n[0], spr->src_size.n[1]);
|
|
||||||
//fprintf(writer, "[%d].rect=%u,%u,%u,%u\n", i, spr->sprite_rect.f[0], spr->sprite_rect.f[1], spr->sprite_rect.f[2], spr->sprite_rect.f[3]);
|
|
||||||
fprintf(writer, "[%d].sheet=%u,%u,%u,%u\n", i, spr->sheet_rect.f[0], spr->sheet_rect.f[1], spr->sheet_rect.f[2], spr->sheet_rect.f[3]);
|
|
||||||
if( spr->num_tris ) {
|
|
||||||
fprintf(writer, "[%d].indices=", i); // %d:", i, (int)spr->num_tris * 3);
|
|
||||||
for( int j = 0, jend = (int)spr->num_tris * 3; j < jend; ++j )
|
|
||||||
fprintf(writer, "%u%s", spr->tris[j], j < (jend-1) ? "," : "\n");
|
|
||||||
|
|
||||||
fprintf(writer, "[%d].coords=", i); // %d:", i, spr->num_points*2);
|
|
||||||
for( int j = 0, jend = spr->num_points; j < jend; j++ )
|
|
||||||
fprintf(writer, "%.f,%.f%s", (double)spr->pts[j].x, (double)spr->pts[j].y, j < (jend-1) ? ",":"\n" );
|
|
||||||
|
|
||||||
fprintf(writer, "[%d].uvs=", i); // %d:", i, spr->num_points*2);
|
|
||||||
for( int j = 0, jend = spr->num_points; j < jend; j++ )
|
|
||||||
fprintf(writer, "%.f,%.f%s", (double)spr->uvs[j].x, (double)spr->uvs[j].y, j < (jend-1) ? ",":"\n" );
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if( atlas_anims ) fprintf(writer, "%s\n", atlas_anims);
|
|
||||||
if( atlas_slices ) fprintf(writer, "%s\n", atlas_slices);
|
|
||||||
|
|
||||||
if(writer != stdout) fclose(writer);
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif // ATLASC_IMPLEMENTATION
|
|
||||||
1059
tools/3rd_delaunay.h
1059
tools/3rd_delaunay.h
File diff suppressed because it is too large
Load Diff
464
tools/3rd_mid.h
464
tools/3rd_mid.h
|
|
@ -1,464 +0,0 @@
|
||||||
/*
|
|
||||||
------------------------------------------------------------------------------
|
|
||||||
Licensing information can be found at the end of the file.
|
|
||||||
------------------------------------------------------------------------------
|
|
||||||
|
|
||||||
mid.h - v0.1 - Midi playback library using the TinySoundFont library.
|
|
||||||
|
|
||||||
Do this:
|
|
||||||
#define MID_IMPLEMENTATION
|
|
||||||
before you include this file in *one* C/C++ file to create the implementation.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef mid_h
|
|
||||||
#define mid_h
|
|
||||||
|
|
||||||
#define _CRT_NONSTDC_NO_DEPRECATE
|
|
||||||
#define _CRT_SECURE_NO_WARNINGS
|
|
||||||
#include <stddef.h>
|
|
||||||
|
|
||||||
typedef struct mid_t mid_t;
|
|
||||||
typedef struct tsf tsf;
|
|
||||||
|
|
||||||
mid_t* mid_create( void const* midi_data, size_t midi_size, void* memctx );
|
|
||||||
void mid_destroy( mid_t* mid );
|
|
||||||
|
|
||||||
int mid_render_short( mid_t* mid, short* sample_pairs, int sample_pairs_count, tsf* sound_font );
|
|
||||||
int mid_render_float( mid_t* mid, float* sample_pairs, int sample_pairs_count, tsf* sound_font );
|
|
||||||
|
|
||||||
void mid_skip_leading_silence( mid_t* mid, tsf* sound_font );
|
|
||||||
|
|
||||||
#endif /* mid_h */
|
|
||||||
|
|
||||||
#ifdef MID_ENABLE_RAW
|
|
||||||
|
|
||||||
#ifndef mid_raw_h
|
|
||||||
#define mid_raw_h
|
|
||||||
|
|
||||||
#ifndef MID_U8
|
|
||||||
#define MID_U8 unsigned char
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifndef MID_U16
|
|
||||||
#define MID_U16 unsigned short
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifndef MID_U32
|
|
||||||
#define MID_U32 unsigned int
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifndef MID_U64
|
|
||||||
#define MID_U64 unsigned long long
|
|
||||||
#endif
|
|
||||||
|
|
||||||
typedef struct mid_event_t
|
|
||||||
{
|
|
||||||
MID_U32 delay_us;
|
|
||||||
MID_U8 channel;
|
|
||||||
MID_U8 type;
|
|
||||||
union
|
|
||||||
{
|
|
||||||
struct { MID_U8 program; } program_change;
|
|
||||||
struct { MID_U8 note; MID_U8 velocity; } note_on;
|
|
||||||
struct { MID_U8 note; } note_off;
|
|
||||||
struct { MID_U8 key; MID_U8 key_pressure; } key_pressure;
|
|
||||||
struct { MID_U16 value; } pitch_bend;
|
|
||||||
struct { MID_U8 control, control_value; } control_change;
|
|
||||||
struct { MID_U8 channel_pressure; } channel_pressure;
|
|
||||||
} data;
|
|
||||||
} mid_event_t;
|
|
||||||
|
|
||||||
|
|
||||||
typedef struct mid_song_t
|
|
||||||
{
|
|
||||||
int event_count;
|
|
||||||
mid_event_t* events;
|
|
||||||
} mid_song_t;
|
|
||||||
|
|
||||||
|
|
||||||
struct mid_t
|
|
||||||
{
|
|
||||||
void* memctx;
|
|
||||||
mid_song_t song;
|
|
||||||
int percussion_preset;
|
|
||||||
MID_U64 playback_accumulated_time_us;
|
|
||||||
int playback_sample_pos;
|
|
||||||
int playback_event_pos;
|
|
||||||
};
|
|
||||||
|
|
||||||
int mid_init_raw( mid_t* mid, void const* raw_data, size_t raw_size );
|
|
||||||
|
|
||||||
size_t mid_save_raw( mid_t* mid, void* data, size_t capacity );
|
|
||||||
|
|
||||||
|
|
||||||
#endif /* MID_ENABLE_RAW */
|
|
||||||
|
|
||||||
#endif /* mid_raw_h */
|
|
||||||
|
|
||||||
/*
|
|
||||||
----------------------
|
|
||||||
IMPLEMENTATION
|
|
||||||
----------------------
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifdef MID_IMPLEMENTATION
|
|
||||||
#undef MID_IMPLEMENTATION
|
|
||||||
|
|
||||||
#ifndef MID_U8
|
|
||||||
#define MID_U8 unsigned char
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifndef MID_U16
|
|
||||||
#define MID_U16 unsigned short
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifndef MID_U32
|
|
||||||
#define MID_U32 unsigned int
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifndef MID_U64
|
|
||||||
#define MID_U64 unsigned long long
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifndef MID_MALLOC
|
|
||||||
#define _CRT_NONSTDC_NO_DEPRECATE
|
|
||||||
#define _CRT_SECURE_NO_WARNINGS
|
|
||||||
#include <stdlib.h>
|
|
||||||
#if defined(_cplusplus)
|
|
||||||
#define MID_MALLOC( ctx, size ) ( ::malloc( size ) )
|
|
||||||
#define MID_FREE( ctx, ptr ) ( ::free( ptr ) )
|
|
||||||
#else
|
|
||||||
#define MID_MALLOC( ctx, size ) ( malloc( size ) )
|
|
||||||
#define MID_FREE( ctx, ptr ) ( free( ptr ) )
|
|
||||||
#endif
|
|
||||||
#endif
|
|
||||||
#include <assert.h>
|
|
||||||
#define MID_LOG(...) (void) __VA_ARGS__
|
|
||||||
|
|
||||||
#include <string.h>
|
|
||||||
|
|
||||||
#pragma warning( push )
|
|
||||||
#pragma warning( disable: 4242 )
|
|
||||||
#pragma warning( disable: 4244 )
|
|
||||||
#pragma warning( disable: 4365 )
|
|
||||||
#pragma warning( disable: 4668 )
|
|
||||||
#pragma warning( disable: 4701 )
|
|
||||||
#pragma warning( disable: 4703 )
|
|
||||||
|
|
||||||
#ifndef MID_NO_TSF_IMPLEMENTATION
|
|
||||||
#define TSF_NO_STDIO
|
|
||||||
#define TSF_IMPLEMENTATION
|
|
||||||
#endif
|
|
||||||
#include "3rd_tsf.h"
|
|
||||||
|
|
||||||
#pragma warning( disable: 4201 )
|
|
||||||
|
|
||||||
#ifndef MID_NO_TML_IMPLEMENTATION
|
|
||||||
#define TML_NO_STDIO
|
|
||||||
#define TML_IMPLEMENTATION
|
|
||||||
#endif
|
|
||||||
#include "3rd_tml.h"
|
|
||||||
|
|
||||||
#pragma warning( pop )
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
#ifndef MID_ENABLE_RAW
|
|
||||||
|
|
||||||
typedef struct mid_event_t
|
|
||||||
{
|
|
||||||
MID_U32 delay_us;
|
|
||||||
MID_U8 channel;
|
|
||||||
MID_U8 type;
|
|
||||||
union
|
|
||||||
{
|
|
||||||
struct { MID_U8 program; } program_change;
|
|
||||||
struct { MID_U8 note; MID_U8 velocity; } note_on;
|
|
||||||
struct { MID_U8 note; } note_off;
|
|
||||||
struct { MID_U8 key; MID_U8 key_pressure; } key_pressure;
|
|
||||||
struct { MID_U16 value; } pitch_bend;
|
|
||||||
struct { MID_U8 control, control_value; } control_change;
|
|
||||||
struct { MID_U8 channel_pressure; } channel_pressure;
|
|
||||||
} data;
|
|
||||||
} mid_event_t;
|
|
||||||
|
|
||||||
|
|
||||||
typedef struct mid_song_t
|
|
||||||
{
|
|
||||||
int event_count;
|
|
||||||
mid_event_t* events;
|
|
||||||
} mid_song_t;
|
|
||||||
|
|
||||||
|
|
||||||
struct mid_t
|
|
||||||
{
|
|
||||||
void* memctx;
|
|
||||||
mid_song_t song;
|
|
||||||
int percussion_preset;
|
|
||||||
MID_U64 playback_accumulated_time_us;
|
|
||||||
int playback_sample_pos;
|
|
||||||
int playback_event_pos;
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
#endif /* MID_ENABLE_RAW */
|
|
||||||
|
|
||||||
|
|
||||||
mid_t* mid_create( void const* midi_data, size_t midi_size, void* memctx )
|
|
||||||
{
|
|
||||||
tml_message* mid_file = tml_load_memory( midi_data, (int) midi_size );
|
|
||||||
if( !mid_file ) return NULL;
|
|
||||||
int count = 0;
|
|
||||||
tml_message* iter = mid_file;
|
|
||||||
while( iter )
|
|
||||||
{
|
|
||||||
if( iter->type == TML_PROGRAM_CHANGE || iter->type == TML_NOTE_ON || iter->type == TML_NOTE_OFF ||
|
|
||||||
iter->type == TML_PITCH_BEND || iter->type == TML_CONTROL_CHANGE )
|
|
||||||
{
|
|
||||||
++count;
|
|
||||||
}
|
|
||||||
iter = iter->next;
|
|
||||||
}
|
|
||||||
|
|
||||||
mid_event_t* events = (mid_event_t*) malloc( sizeof( mid_event_t ) * count );
|
|
||||||
int events_count = 0;
|
|
||||||
unsigned int time = 0;
|
|
||||||
tml_message* msg = mid_file;
|
|
||||||
while( msg )
|
|
||||||
{
|
|
||||||
if( msg->type == TML_PROGRAM_CHANGE || msg->type == TML_NOTE_ON || msg->type == TML_NOTE_OFF ||
|
|
||||||
msg->type == TML_PITCH_BEND || msg->type == TML_CONTROL_CHANGE )
|
|
||||||
{
|
|
||||||
mid_event_t* event = &events[ events_count++ ];
|
|
||||||
event->delay_us = ( msg->time - time ) * 1000;
|
|
||||||
time = msg->time;
|
|
||||||
event->channel = msg->channel;
|
|
||||||
event->type = msg->type;
|
|
||||||
switch( msg->type )
|
|
||||||
{
|
|
||||||
case TML_PROGRAM_CHANGE:
|
|
||||||
event->data.program_change.program = (MID_U8) msg->program;
|
|
||||||
break;
|
|
||||||
case TML_NOTE_ON: //play a note
|
|
||||||
event->data.note_on.note = (MID_U8) msg->key;
|
|
||||||
event->data.note_on.velocity = (MID_U8) msg->velocity;
|
|
||||||
break;
|
|
||||||
case TML_NOTE_OFF: //stop a note
|
|
||||||
event->data.note_off.note = (MID_U8) msg->key;
|
|
||||||
break;
|
|
||||||
case TML_PITCH_BEND: //pitch wheel modification
|
|
||||||
event->data.pitch_bend.value = (MID_U16) msg->pitch_bend;
|
|
||||||
break;
|
|
||||||
case TML_CONTROL_CHANGE: //MIDI controller messages
|
|
||||||
event->data.control_change.control = (MID_U8) msg->control;
|
|
||||||
event->data.control_change.control_value = (MID_U8) msg->control_value;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
msg = msg->next;
|
|
||||||
}
|
|
||||||
|
|
||||||
tml_free( mid_file );
|
|
||||||
|
|
||||||
mid_t* mid = (mid_t*) MID_MALLOC( memctx, sizeof( mid_t ) );
|
|
||||||
mid->memctx = memctx;
|
|
||||||
mid->song.event_count = events_count;
|
|
||||||
mid->song.events = events;
|
|
||||||
|
|
||||||
mid->playback_accumulated_time_us = 0ull;
|
|
||||||
mid->playback_sample_pos = 0;
|
|
||||||
mid->playback_event_pos = 0;
|
|
||||||
|
|
||||||
return mid;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void mid_destroy( mid_t* mid )
|
|
||||||
{
|
|
||||||
if( mid->song.events ) MID_FREE( mid->memctx, mid->song.events );
|
|
||||||
MID_FREE( mid->memctx, mid );
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
int mid_init_raw( mid_t* mid, void const* raw_data, size_t raw_size )
|
|
||||||
{
|
|
||||||
int events_count = *(int*)raw_data;
|
|
||||||
if( sizeof( mid_event_t ) * events_count != raw_size - sizeof( int ) ) return 0;
|
|
||||||
|
|
||||||
mid->memctx = NULL;
|
|
||||||
|
|
||||||
mid->song.event_count = events_count;
|
|
||||||
mid->song.events = (mid_event_t*)( ( (int*)raw_data ) + 1 );
|
|
||||||
|
|
||||||
mid->playback_accumulated_time_us = 0ull;
|
|
||||||
mid->playback_sample_pos = 0;
|
|
||||||
mid->playback_event_pos = 0;
|
|
||||||
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
size_t mid_save_raw( mid_t* mid, void* data, size_t capacity )
|
|
||||||
{
|
|
||||||
size_t size = sizeof( mid_event_t ) * mid->song.event_count + sizeof( int );
|
|
||||||
if( data && capacity >= size )
|
|
||||||
{
|
|
||||||
*(int*)data = mid->song.event_count;
|
|
||||||
memcpy( ( (int*)data ) + 1, mid->song.events, sizeof( mid_event_t ) * mid->song.event_count );
|
|
||||||
}
|
|
||||||
return size;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void mid_skip_leading_silence( mid_t* mid, tsf* sound_font )
|
|
||||||
{
|
|
||||||
(void) sound_font;
|
|
||||||
for( ; ; )
|
|
||||||
{
|
|
||||||
MID_U64 next_event_delay_us = mid->song.events[ mid->playback_event_pos ].delay_us;
|
|
||||||
MID_U64 playback_time_us = ( mid->playback_sample_pos * 1000000ull ) / 44100ull;
|
|
||||||
MID_U64 next_event_time_us = mid->playback_accumulated_time_us + next_event_delay_us;
|
|
||||||
assert( next_event_time_us >= playback_time_us );
|
|
||||||
MID_U64 time_until_next_event = next_event_time_us - playback_time_us;
|
|
||||||
int samples_until_next_event = (int)( ( time_until_next_event * 44100ull ) / 1000000ull );
|
|
||||||
mid_event_t* event = &mid->song.events[ mid->playback_event_pos ];
|
|
||||||
switch( event->type )
|
|
||||||
{
|
|
||||||
case TML_PROGRAM_CHANGE:
|
|
||||||
tsf_channel_set_presetnumber( sound_font, event->channel, event->data.program_change.program, ( event->channel == 9 ) );
|
|
||||||
break;
|
|
||||||
case TML_NOTE_ON:
|
|
||||||
return;
|
|
||||||
case TML_NOTE_OFF: //stop a note
|
|
||||||
tsf_channel_note_off( sound_font, event->channel, event->data.note_off.note );
|
|
||||||
break;
|
|
||||||
case TML_PITCH_BEND: //pitch wheel modification
|
|
||||||
tsf_channel_set_pitchwheel( sound_font, event->channel, event->data.pitch_bend.value );
|
|
||||||
break;
|
|
||||||
case TML_CONTROL_CHANGE: //MIDI controller messages
|
|
||||||
tsf_channel_midi_control( sound_font, event->channel, event->data.control_change.control, event->data.control_change.control_value );
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
mid->playback_sample_pos += samples_until_next_event;
|
|
||||||
mid->playback_accumulated_time_us += next_event_delay_us;
|
|
||||||
mid->playback_event_pos++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
int mid_render_short( mid_t* mid, short* sample_pairs, int sample_pairs_count, tsf* sound_font )
|
|
||||||
{
|
|
||||||
int samples_rendered = 0;
|
|
||||||
memset( sample_pairs, 0, sample_pairs_count * sizeof( short ) * 2 );
|
|
||||||
while( samples_rendered < sample_pairs_count )
|
|
||||||
{
|
|
||||||
MID_U64 next_event_delay_us = mid->song.events[ mid->playback_event_pos ].delay_us;
|
|
||||||
MID_U64 playback_time_us = ( mid->playback_sample_pos * 1000000ull ) / 44100ull;
|
|
||||||
MID_U64 next_event_time_us = mid->playback_accumulated_time_us + next_event_delay_us;
|
|
||||||
assert( next_event_time_us >= playback_time_us );
|
|
||||||
MID_U64 time_until_next_event = next_event_time_us - playback_time_us;
|
|
||||||
int samples_until_next_event = (int)( ( time_until_next_event * 44100ull ) / 1000000ull );
|
|
||||||
int samples_to_render = samples_until_next_event;
|
|
||||||
if( samples_to_render > sample_pairs_count - samples_rendered )
|
|
||||||
{
|
|
||||||
samples_to_render = sample_pairs_count - samples_rendered;
|
|
||||||
tsf_render_short( sound_font, sample_pairs + samples_rendered * 2,
|
|
||||||
samples_to_render, 1 );
|
|
||||||
samples_rendered += samples_to_render;
|
|
||||||
mid->playback_sample_pos += samples_to_render;
|
|
||||||
return samples_rendered;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
tsf_render_short( sound_font, sample_pairs + samples_rendered * 2,
|
|
||||||
samples_to_render, 1 );
|
|
||||||
samples_rendered += samples_to_render;
|
|
||||||
mid->playback_sample_pos += samples_to_render;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
mid->playback_accumulated_time_us += next_event_delay_us;
|
|
||||||
mid_event_t* event = &mid->song.events[ mid->playback_event_pos++ ];
|
|
||||||
switch( event->type )
|
|
||||||
{
|
|
||||||
case TML_PROGRAM_CHANGE:
|
|
||||||
tsf_channel_set_presetnumber( sound_font, event->channel, event->data.program_change.program, ( event->channel == 9 ) );
|
|
||||||
break;
|
|
||||||
case TML_NOTE_ON:
|
|
||||||
tsf_channel_note_on( sound_font, event->channel, event->data.note_on.note, event->data.note_on.velocity / 127.0f );
|
|
||||||
break;
|
|
||||||
case TML_NOTE_OFF: //stop a note
|
|
||||||
tsf_channel_note_off( sound_font, event->channel, event->data.note_off.note );
|
|
||||||
break;
|
|
||||||
case TML_PITCH_BEND: //pitch wheel modification
|
|
||||||
tsf_channel_set_pitchwheel( sound_font, event->channel, event->data.pitch_bend.value );
|
|
||||||
break;
|
|
||||||
case TML_CONTROL_CHANGE: //MIDI controller messages
|
|
||||||
tsf_channel_midi_control( sound_font, event->channel, event->data.control_change.control, event->data.control_change.control_value );
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return samples_rendered;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
#endif /* MID_IMPLEMENTATION */
|
|
||||||
|
|
||||||
/*
|
|
||||||
------------------------------------------------------------------------------
|
|
||||||
|
|
||||||
This software is available under 2 licenses - you may choose the one you like.
|
|
||||||
|
|
||||||
------------------------------------------------------------------------------
|
|
||||||
|
|
||||||
ALTERNATIVE A - MIT License
|
|
||||||
|
|
||||||
Copyright (c) 2016 Mattias Gustavsson
|
|
||||||
|
|
||||||
Permission is hereby granted, free of charge, to any person obtaining a copy of
|
|
||||||
this software and associated documentation files (the "Software"), to deal in
|
|
||||||
the Software without restriction, including without limitation the rights to
|
|
||||||
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
|
|
||||||
of the Software, and to permit persons to whom the Software is furnished to do
|
|
||||||
so, subject to the following conditions:
|
|
||||||
|
|
||||||
The above copyright notice and this permission notice shall be included in all
|
|
||||||
copies or substantial portions of the Software.
|
|
||||||
|
|
||||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
||||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
||||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
||||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
||||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
||||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
||||||
SOFTWARE.
|
|
||||||
|
|
||||||
------------------------------------------------------------------------------
|
|
||||||
|
|
||||||
ALTERNATIVE B - Public Domain (www.unlicense.org)
|
|
||||||
|
|
||||||
This is free and unencumbered software released into the public domain.
|
|
||||||
|
|
||||||
Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
|
|
||||||
software, either in source code form or as a compiled binary, for any purpose,
|
|
||||||
commercial or non-commercial, and by any means.
|
|
||||||
|
|
||||||
In jurisdictions that recognize copyright laws, the author or authors of this
|
|
||||||
software dedicate any and all copyright interest in the software to the public
|
|
||||||
domain. We make this dedication for the benefit of the public at large and to
|
|
||||||
the detriment of our heirs and successors. We intend this dedication to be an
|
|
||||||
overt act of relinquishment in perpetuity of all present and future rights to
|
|
||||||
this software under copyright law.
|
|
||||||
|
|
||||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
||||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
||||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
||||||
AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
|
||||||
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
||||||
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
||||||
|
|
||||||
------------------------------------------------------------------------------
|
|
||||||
*/
|
|
||||||
|
|
@ -1,441 +0,0 @@
|
||||||
/* sproutline - v0.10 - public domain sprite outline detector - http://github.org/ands/sproutline
|
|
||||||
no warranty implied; use at your own risk
|
|
||||||
|
|
||||||
Do this:
|
|
||||||
#define S2O_IMPLEMENTATION
|
|
||||||
before you include this file in *one* C or C++ file to create the implementation.
|
|
||||||
|
|
||||||
// i.e. it should look like this:
|
|
||||||
#include ...
|
|
||||||
#include ...
|
|
||||||
#include ...
|
|
||||||
#define S2O_IMPLEMENTATION
|
|
||||||
#include "sproutline.h"
|
|
||||||
|
|
||||||
You can #define S2O_MALLOC to avoid using malloc
|
|
||||||
|
|
||||||
|
|
||||||
QUICK NOTES:
|
|
||||||
Primarily of interest to game developers.
|
|
||||||
- Recommended to be used with stb_image.
|
|
||||||
- Detects outlines in sprite images with alpha channels.
|
|
||||||
- Extracts outlines as clockwise paths.
|
|
||||||
- Simplifies outlines based on a distance metric.
|
|
||||||
|
|
||||||
Full documentation under "DOCUMENTATION" below.
|
|
||||||
|
|
||||||
|
|
||||||
Revision 0.10 release notes:
|
|
||||||
|
|
||||||
- Initial release of sproutline.h.
|
|
||||||
|
|
||||||
- Added S2O_MALLOC macro for replacing the memory allocator.
|
|
||||||
Unlike most STB libraries, this macro doesn't support a context parameter,
|
|
||||||
so if you need to pass a context in to the allocator, you'll have to
|
|
||||||
store it in a global or a thread-local variable.
|
|
||||||
|
|
||||||
|
|
||||||
Revision history:
|
|
||||||
0.10 (2015-10-22) initial version
|
|
||||||
|
|
||||||
============================ Contributors =========================
|
|
||||||
|
|
||||||
Andreas Mantler (ands)
|
|
||||||
|
|
||||||
License:
|
|
||||||
This software is in the public domain. Where that dedication is not
|
|
||||||
recognized, you are granted a perpetual, irrevocable license to copy
|
|
||||||
and modify this file however you want.
|
|
||||||
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef S2O_INCLUDE_SPROUTLINE_H
|
|
||||||
#define S2O_INCLUDE_SPROUTLINE_H
|
|
||||||
|
|
||||||
// DOCUMENTATION
|
|
||||||
//
|
|
||||||
// Limitations:
|
|
||||||
// - currently only works with images that have alpha channels
|
|
||||||
//
|
|
||||||
// Basic usage (with stb_image):
|
|
||||||
// int w, h, n, l;
|
|
||||||
// unsigned char *rgba = stbi_load(filename, &w, &h, &n, 4);
|
|
||||||
// unsigned char *alpha = s2o_rgba_to_alpha(rgba, w, h);
|
|
||||||
// unsigned char *thresholded = s2o_alpha_to_thresholded(alpha, w, h, ALPHA_THRESHOLD);
|
|
||||||
// unsigned char *outlined = s2o_thresholded_to_outlined(thresholded, w, h);
|
|
||||||
// s2o_point *outline = s2o_extract_outline_path(outlined, w, h, &l, 0);
|
|
||||||
// while(l)
|
|
||||||
// {
|
|
||||||
// s2o_distance_based_path_simplification(outline, &l, DISTANCE_THRESHOLD);
|
|
||||||
// // ... process outline here ...
|
|
||||||
// // ... l = number of points in outline
|
|
||||||
// // ... ALPHA_THRESHOLD = 1..255 (the min value to be considered solid)
|
|
||||||
// // ... DISTANCE_THRESHOLD = 0.0f..Inf (~0.5f is a suitable value)
|
|
||||||
// // ... a greater value results in fewer points in the output
|
|
||||||
//
|
|
||||||
// outline = s2o_extract_outline_path(outlined, w, h, &l, outline);
|
|
||||||
// };
|
|
||||||
// free(outline);
|
|
||||||
// free(outlined);
|
|
||||||
// free(thresholded);
|
|
||||||
// free(alpha);
|
|
||||||
// free(rgba);
|
|
||||||
//
|
|
||||||
// s2o_rgba_to_alpha:
|
|
||||||
// Expects an 'unsigned char *' to memory of w * h 4-byte pixels in 'RGBA' order.
|
|
||||||
// The return value is an 'unsigned char *' to memory of w * h 1-byte pixel alpha components.
|
|
||||||
//
|
|
||||||
// s2o_alpha_to_thresholded:
|
|
||||||
// Expects an 'unsigned char *' to memory of w * h 1-byte pixel alpha components.
|
|
||||||
// The return value is an 'unsigned char *' to memory of w * h 1-byte values
|
|
||||||
// that are 255 if the corresponding input is >= the specified threshold, otherwise 0.
|
|
||||||
//
|
|
||||||
// s2o_thresholded_to_outlined:
|
|
||||||
// Expects an 'unsigned char *' to memory of w * h 1-byte pixels indicating their solidity {0, nonzero}.
|
|
||||||
// The return value is an 'unsigned char *' to memory of w * h 1-byte pixels that indicate if the
|
|
||||||
// corresponding input value is part of an outline (= is solid and has a non-solid neighbour).
|
|
||||||
//
|
|
||||||
// s2o_extract_outline_path:
|
|
||||||
// Expects an 'unsigned char *' to memory of w * h 1-byte pixels indicating their outline membership.
|
|
||||||
// The return value is an 's2o_point *' to memory of l s2o_point values consisting of a short x and y value.
|
|
||||||
// The procedure scans the input data from top to bottom and starts extracting the first outline it finds.
|
|
||||||
// The pixels corresponding to the extracted outline are set to 0 in the input, so that a subsequent call to
|
|
||||||
// s2o_extract_outline_path extracts a different outline.
|
|
||||||
// The length is set to 0 if no outline was found.
|
|
||||||
//
|
|
||||||
// s2o_distance_based_path_simplification:
|
|
||||||
// Expects an 's2o_point *' to memory of l outline points.
|
|
||||||
// The procedure throws out points in place that lie on or close to linear sections of the outline.
|
|
||||||
// The distanceThreshold parameter specifies the min distance value for points to remain in the outline.
|
|
||||||
//
|
|
||||||
// ===========================================================================
|
|
||||||
//
|
|
||||||
// Philosophy
|
|
||||||
//
|
|
||||||
// This library is designed with the stb philosophy in mind.
|
|
||||||
// stb libraries are designed with the following priorities:
|
|
||||||
//
|
|
||||||
// 1. easy to use
|
|
||||||
// 2. easy to maintain
|
|
||||||
// 3. good performance
|
|
||||||
//
|
|
||||||
// Some secondary priorities arise directly from the first two, some of which
|
|
||||||
// make more explicit reasons why performance can't be emphasized.
|
|
||||||
//
|
|
||||||
// - Portable ("ease of use")
|
|
||||||
// - Small footprint ("easy to maintain")
|
|
||||||
// - No dependencies ("ease of use")
|
|
||||||
//
|
|
||||||
|
|
||||||
typedef unsigned char s2o_uc;
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifdef S2O_STATIC
|
|
||||||
#define S2ODEF static
|
|
||||||
#else
|
|
||||||
#define S2ODEF extern
|
|
||||||
#endif
|
|
||||||
|
|
||||||
//////////////////////////////////////////////////////////////////////////////
|
|
||||||
//
|
|
||||||
// PRIMARY API
|
|
||||||
//
|
|
||||||
|
|
||||||
S2ODEF s2o_uc * s2o_rgba_to_alpha (const s2o_uc *data, int w, int h);
|
|
||||||
S2ODEF s2o_uc * s2o_alpha_to_thresholded (const s2o_uc *data, int w, int h, s2o_uc threshold);
|
|
||||||
S2ODEF s2o_uc * s2o_thresholded_to_outlined(const s2o_uc *data, int w, int h);
|
|
||||||
|
|
||||||
typedef struct { short x, y; } s2o_point;
|
|
||||||
S2ODEF s2o_point * s2o_extract_outline_path(s2o_uc *data, int w, int h, int *point_count, s2o_point *reusable_outline);
|
|
||||||
S2ODEF void s2o_distance_based_path_simplification(s2o_point *outline, int *outline_length, float distance_threshold);
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
//
|
|
||||||
//
|
|
||||||
//// end header file /////////////////////////////////////////////////////
|
|
||||||
#endif // S2O_INCLUDE_SPROUTLINE_H
|
|
||||||
|
|
||||||
#ifdef S2O_IMPLEMENTATION
|
|
||||||
|
|
||||||
#include <math.h> // sqrtf, abs
|
|
||||||
|
|
||||||
#ifndef S2O_MALLOC
|
|
||||||
#include <stdlib.h> // malloc
|
|
||||||
#define S2O_MALLOC(sz) malloc(sz)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
///////////////////////////////////////////////
|
|
||||||
//
|
|
||||||
// locally used types
|
|
||||||
|
|
||||||
typedef int s2o_bool;
|
|
||||||
|
|
||||||
// 2d point type helpers
|
|
||||||
#define S2O_POINT_ADD(result, a, b) { (result).x = (a).x + (b).x; (result).y = (a).y + (b).y; }
|
|
||||||
#define S2O_POINT_SUB(result, a, b) { (result).x = (a).x - (b).x; (result).y = (a).y - (b).y; }
|
|
||||||
#define S2O_POINT_IS_INSIDE(a, w, h) ((a).x >= 0 && (a).y >= 0 && (a).x < (w) && (a).y < (h))
|
|
||||||
#define S2O_POINT_IS_NEXT_TO(a, b) ((a).x - (b).x <= 1 && (a).x - (b).x >= -1 && (a).y - (b).y <= 1 && (a).y - (b).y >= -1)
|
|
||||||
|
|
||||||
// direction type
|
|
||||||
typedef int s2o_direction; // 8 cw directions: >, _|, v, |_, <, |", ^, "|
|
|
||||||
#define S2O_DIRECTION_OPPOSITE(dir) ((dir + 4) & 7)
|
|
||||||
static const s2o_point s2o_direction_to_pixel_offset[] = { {1,0}, {1,-1}, {0,-1}, {-1,-1}, {-1,0}, {-1,1}, {0,1}, {1,1} };
|
|
||||||
|
|
||||||
// image manipulation functions
|
|
||||||
S2ODEF s2o_uc * s2o_rgba_to_alpha(const s2o_uc *data, int w, int h)
|
|
||||||
{
|
|
||||||
s2o_uc *result = (s2o_uc*)S2O_MALLOC(w * h);
|
|
||||||
int x, y;
|
|
||||||
for (y = 0; y < h; y++)
|
|
||||||
for (x = 0; x < w; x++)
|
|
||||||
result[y * w + x] = data[(y * w + x) * 4 + 3];
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
S2ODEF s2o_uc * s2o_alpha_to_thresholded(const s2o_uc *data, int w, int h, s2o_uc threshold)
|
|
||||||
{
|
|
||||||
s2o_uc *result = (s2o_uc*)S2O_MALLOC(w * h);
|
|
||||||
int x, y;
|
|
||||||
for (y = 0; y < h; y++)
|
|
||||||
for (x = 0; x < w; x++)
|
|
||||||
result[y * w + x] = data[y * w + x] >= threshold ? 255 : 0;
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
S2ODEF s2o_uc * s2o_dilate_thresholded(const s2o_uc *data, int w, int h)
|
|
||||||
{
|
|
||||||
int x, y, dx, dy, cx, cy;
|
|
||||||
s2o_uc *result = (s2o_uc*)S2O_MALLOC(w * h);
|
|
||||||
for (y = 0; y < h; y++)
|
|
||||||
{
|
|
||||||
for (x = 0; x < w; x++)
|
|
||||||
{
|
|
||||||
result[y * w + x] = 0;
|
|
||||||
for (dy = -1; dy <= 1; dy++)
|
|
||||||
{
|
|
||||||
for (dx = -1; dx <= 1; dx++)
|
|
||||||
{
|
|
||||||
cx = x + dx;
|
|
||||||
cy = y + dy;
|
|
||||||
if (cx >= 0 && cx < w && cy >= 0 && cy < h)
|
|
||||||
{
|
|
||||||
if (data[cy * w + cx])
|
|
||||||
{
|
|
||||||
result[y * w + x] = 255;
|
|
||||||
dy = 1;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
S2ODEF s2o_uc * s2o_thresholded_to_outlined(const s2o_uc *data, int w, int h)
|
|
||||||
{
|
|
||||||
s2o_uc *result = (s2o_uc*)S2O_MALLOC(w * h);
|
|
||||||
int x, y;
|
|
||||||
for (x = 0; x < w; x++)
|
|
||||||
{
|
|
||||||
result[x] = data[x];
|
|
||||||
result[(h - 1) * w + x] = data[(h - 1) * w + x];
|
|
||||||
}
|
|
||||||
for (y = 1; y < h - 1; y++)
|
|
||||||
{
|
|
||||||
result[y * w] = data[y * w];
|
|
||||||
for (x = 1; x < w - 1; x++)
|
|
||||||
{
|
|
||||||
if (data[y * w + x] &&
|
|
||||||
(
|
|
||||||
!data[y * w + x - 1] ||
|
|
||||||
!data[y * w + x + 1] ||
|
|
||||||
!data[y * w + x - w] ||
|
|
||||||
!data[y * w + x + w]
|
|
||||||
))
|
|
||||||
{
|
|
||||||
result[y * w + x] = 255;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
result[y * w + x] = 0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
result[y * w + w - 1] = data[y * w + w - 1];
|
|
||||||
}
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
// outline path procedures
|
|
||||||
static s2o_bool s2o_find_first_filled_pixel(const s2o_uc *data, int w, int h, s2o_point *first)
|
|
||||||
{
|
|
||||||
int x, y;
|
|
||||||
for (y = 0; y < h; y++)
|
|
||||||
{
|
|
||||||
for (x = 0; x < w; x++)
|
|
||||||
{
|
|
||||||
if (data[y * w + x])
|
|
||||||
{
|
|
||||||
first->x = (short)x;
|
|
||||||
first->y = (short)y;
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
static s2o_bool s2o_find_next_filled_pixel(const s2o_uc *data, int w, int h, s2o_point current, s2o_direction *dir, s2o_point *next)
|
|
||||||
{
|
|
||||||
// turn around 180°, then make a clockwise scan for a filled pixel
|
|
||||||
*dir = S2O_DIRECTION_OPPOSITE(*dir);
|
|
||||||
int i;
|
|
||||||
for (i = 0; i < 8; i++)
|
|
||||||
{
|
|
||||||
S2O_POINT_ADD(*next, current, s2o_direction_to_pixel_offset[*dir]);
|
|
||||||
|
|
||||||
if (S2O_POINT_IS_INSIDE(*next, w, h) && data[next->y * w + next->x])
|
|
||||||
return 1;
|
|
||||||
|
|
||||||
// move to next angle (clockwise)
|
|
||||||
*dir = *dir - 1;
|
|
||||||
if (*dir < 0)
|
|
||||||
*dir = 7;
|
|
||||||
}
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
S2ODEF s2o_point * s2o_extract_outline_path(s2o_uc *data, int w, int h, int *point_count, s2o_point *reusable_outline)
|
|
||||||
{
|
|
||||||
s2o_point *outline = reusable_outline;
|
|
||||||
if (!outline)
|
|
||||||
outline = (s2o_point*)S2O_MALLOC(w * h * sizeof(s2o_point));
|
|
||||||
|
|
||||||
s2o_point current, next;
|
|
||||||
|
|
||||||
restart:
|
|
||||||
if (!s2o_find_first_filled_pixel(data, w, h, ¤t))
|
|
||||||
{
|
|
||||||
*point_count = 0;
|
|
||||||
return outline;
|
|
||||||
}
|
|
||||||
|
|
||||||
int count = 0;
|
|
||||||
s2o_direction dir = 0;
|
|
||||||
|
|
||||||
while(S2O_POINT_IS_INSIDE(current, w, h) && count < (w*h)) //< @r-lyeh: buffer overflow: add count<w*h
|
|
||||||
{
|
|
||||||
data[current.y * w + current.x] = 0; // clear the visited path
|
|
||||||
outline[count++] = current; // add our current point to the outline
|
|
||||||
if (!s2o_find_next_filled_pixel(data, w, h, current, &dir, &next))
|
|
||||||
{
|
|
||||||
// find loop connection
|
|
||||||
s2o_bool found = 0;
|
|
||||||
int i;
|
|
||||||
for (i = 0; i < count / 2; i++) // only allow big loops
|
|
||||||
{
|
|
||||||
if (S2O_POINT_IS_NEXT_TO(current, outline[i]))
|
|
||||||
{
|
|
||||||
found = 1;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if (found)
|
|
||||||
{
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
// go backwards until we see outline pixels again
|
|
||||||
dir = S2O_DIRECTION_OPPOSITE(dir);
|
|
||||||
count--; // back up
|
|
||||||
int prev;
|
|
||||||
for(prev = count; prev >= 0 && count < (w * h); prev--) //< @r-lyeh: buffer overflow: add count<w*h
|
|
||||||
{
|
|
||||||
current = outline[prev];
|
|
||||||
outline[count++] = current; // add our current point to the outline again
|
|
||||||
if (s2o_find_next_filled_pixel(data, w, h, current, &dir, &next))
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
current = next;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (count <= 2) // too small, discard and try again!
|
|
||||||
goto restart;
|
|
||||||
*point_count = count;
|
|
||||||
return outline;
|
|
||||||
}
|
|
||||||
|
|
||||||
S2ODEF void s2o_distance_based_path_simplification(s2o_point *outline, int *outline_length, float distance_threshold)
|
|
||||||
{
|
|
||||||
int length = *outline_length;
|
|
||||||
int l;
|
|
||||||
for (l = length / 2 /*length - 1*/; l > 1; l--)
|
|
||||||
{
|
|
||||||
int a, b = l;
|
|
||||||
for (a = 0; a < length; a++)
|
|
||||||
{
|
|
||||||
s2o_point ab;
|
|
||||||
S2O_POINT_SUB(ab, outline[b], outline[a]);
|
|
||||||
float lab = sqrtf((float)(ab.x * ab.x + ab.y * ab.y));
|
|
||||||
float ilab = 1.0f / lab;
|
|
||||||
float abnx = ab.x * ilab, abny = ab.y * ilab;
|
|
||||||
|
|
||||||
if (lab != 0.0f)
|
|
||||||
{
|
|
||||||
s2o_bool found = 1;
|
|
||||||
int i = (a + 1) % length;
|
|
||||||
while (i != b)
|
|
||||||
{
|
|
||||||
s2o_point ai;
|
|
||||||
S2O_POINT_SUB(ai, outline[i], outline[a]);
|
|
||||||
float t = (abnx * ai.x + abny * ai.y) * ilab;
|
|
||||||
float distance = -abny * ai.x + abnx * ai.y;
|
|
||||||
if (t < 0.0f || t > 1.0f || distance > distance_threshold || -distance > distance_threshold)
|
|
||||||
{
|
|
||||||
found = 0;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (++i == length)
|
|
||||||
i = 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (found)
|
|
||||||
{
|
|
||||||
int i;
|
|
||||||
if (a < b)
|
|
||||||
{
|
|
||||||
for (i = 0; i < length - b; i++)
|
|
||||||
outline[a + i + 1] = outline[b + i];
|
|
||||||
length -= b - a - 1;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
length = a - b + 1;
|
|
||||||
for (i = 0; i < length; i++)
|
|
||||||
outline[i] = outline[b + i];
|
|
||||||
}
|
|
||||||
if (l >= length)
|
|
||||||
l = length - 1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if (++b >= length)
|
|
||||||
b = 0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
*outline_length = length;
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif // S2O_IMPLEMENTATION
|
|
||||||
|
|
@ -52,7 +52,9 @@ size_t vlen( void* p ) {
|
||||||
return p ? 0[ (size_t*)p - 2 ] : 0;
|
return p ? 0[ (size_t*)p - 2 ] : 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
char *STRDUP(const char *s) { size_t n = strlen(s)+1; return ((char*)memcpy(ATLAS_REALLOC(0,n), s, n)); } ///-
|
char *vstrdup(const char *s) { size_t n = strlen(s)+1; return ((char*)memcpy(ATLAS_REALLOC(0,n), s, n)); } ///-
|
||||||
|
|
||||||
|
#define STRDUP vstrdup
|
||||||
|
|
||||||
static unsigned array_c;
|
static unsigned array_c;
|
||||||
#define array(t) t*
|
#define array(t) t*
|
||||||
|
|
@ -126,6 +128,7 @@ char* strcatf(char **src_, const char *fmt, ...) {
|
||||||
#define ATLASC_IMPLEMENTATION
|
#define ATLASC_IMPLEMENTATION
|
||||||
#include "3rd_atlasc.h"
|
#include "3rd_atlasc.h"
|
||||||
|
|
||||||
|
|
||||||
#if defined _WIN32 && defined _MSC_VER
|
#if defined _WIN32 && defined _MSC_VER
|
||||||
__declspec(dllexport)
|
__declspec(dllexport)
|
||||||
#elif defined _WIN32 && defined __GNUC__
|
#elif defined _WIN32 && defined __GNUC__
|
||||||
|
|
@ -164,7 +167,6 @@ int main(int argc, char* argv[]) {
|
||||||
for( int i = 1; i < argc; ++i) {
|
for( int i = 1; i < argc; ++i) {
|
||||||
const char *arg = argv[i];
|
const char *arg = argv[i];
|
||||||
if( arg[0] != '-' ) {
|
if( arg[0] != '-' ) {
|
||||||
assert(array_count(files) == 0);
|
|
||||||
if( path_isfile(arg) )
|
if( path_isfile(arg) )
|
||||||
array_push(files, STRDUP(arg));
|
array_push(files, STRDUP(arg));
|
||||||
else
|
else
|
||||||
|
|
@ -174,7 +176,6 @@ int main(int argc, char* argv[]) {
|
||||||
array_push(files, STRDUP(dir_name(d, i)));
|
array_push(files, STRDUP(dir_name(d, i)));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
assert(array_count(files) == 1);
|
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
switch( arg[1] ) {
|
switch( arg[1] ) {
|
||||||
|
|
@ -209,19 +210,23 @@ int main(int argc, char* argv[]) {
|
||||||
|
|
||||||
char *error = g_error_str;
|
char *error = g_error_str;
|
||||||
|
|
||||||
atlas_t* atlas = atlas_loadfiles(files, flags);
|
if( !files ) {
|
||||||
if ( atlas ) {
|
error = "No input file(s)";
|
||||||
bool r = atlas_save(outfile, atlas, flags);
|
} else {
|
||||||
if( r ) {
|
atlas_t* atlas = atlas_loadfiles(files, flags);
|
||||||
// fprintf(stderr, "Written: %d->%d\n", flags.num_files, !!r);
|
if ( atlas ) {
|
||||||
error = 0;
|
bool r = atlas_save(outfile, atlas, flags);
|
||||||
|
if( r ) {
|
||||||
|
// fprintf(stderr, "Written: %d->%d\n", flags.num_files, !!r);
|
||||||
|
error = 0;
|
||||||
|
}
|
||||||
|
atlas_free(atlas);
|
||||||
}
|
}
|
||||||
atlas_free(atlas);
|
|
||||||
}
|
|
||||||
|
|
||||||
// for( int i = 0; i < array_count(files); ++i)
|
for( int i = 0; i < array_count(files); ++i)
|
||||||
// ATLAS_REALLOC(files[i], 0);
|
ATLAS_REALLOC(files[i], 0);
|
||||||
// array_free(files);
|
array_free(files);
|
||||||
|
}
|
||||||
|
|
||||||
return error ? fprintf(stderr, "%s\n", error), -1 : 0;
|
return error ? fprintf(stderr, "%s\n", error), -1 : 0;
|
||||||
}
|
}
|
||||||
|
|
|
||||||
Binary file not shown.
Loading…
Reference in New Issue