antizona

build.c (60794B)

---

 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 
 #include <ctype.h>
 #include <dirent.h>
 #include <err.h>
 #include <fcntl.h>
 #include <math.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "skins.h"
 
 #define COL_HASH_SZ	65536
 #define GRID_SZ		64
 #define MAP_MAX		3000.0f
 #define MAP_MIN		-3000.0f
 #define MAX_COL_MODELS	32768
 #define MAX_FILES	32768
 #define NAME_SZ		24
 #define PATH_CACHE_SZ	16384
 #define PATH_DB_SZ	65536
 
 
 struct col_cell {
 	struct col_triangle	*tris;
 	uint32_t		count;
 	uint32_t		capacity;
 };
 
 struct col_header {
 	char		magic[4];
 	uint32_t	size;
 	char		model_name[22];
 	uint16_t	model_id;
 	float		radius;
 	float		center[3];
 	float		min[3];
 	float		max[3];
 	uint16_t	num_spheres;
 	uint16_t	num_boxes;
 	uint16_t	num_faces;
 	uint8_t		num_lines;
 	uint8_t		pad;
 	uint32_t	flags;
 	uint32_t	spheres_offset;
 	uint32_t	boxes_offset;
 	uint32_t	lines_offset;
 	uint32_t	vertices_offset;
 	uint32_t	faces_offset;
 	uint32_t	shadow_offset;
 } __attribute__((packed));
 
 struct col_model {
 	char			name[NAME_SZ];
 	struct col_triangle	*tris;
 	uint32_t		num_tris;
 };
 
 struct col_triangle {
 	float		v0[3];
 	float		v1[3];
 	float		v2[3];
 	float		norm[3];
 	uint8_t		surface;
 };
 
 struct file_list {
 	char	names[MAX_FILES][NAME_SZ];
 	int	count;
 };
 
 struct img_header {
 	char		magic[4];
 	uint32_t	entries;
 };
 
 struct img_entry {
 	uint32_t	offset;
 	uint16_t	size;
 	uint16_t	size2;
 	char		name[24];
 };
 
 struct ide_entry {
 	int	id;
 	char	model[NAME_SZ];
 	char	txd[NAME_SZ];
 	int	time_on;
 	int	time_off;
 };
 
 struct mstream {
 	const uint8_t *data;
 	size_t		 size;
 	size_t		 pos;
 };
 
 struct path_entry {
 	char	key[512];
 	char	resolved[1024];
 };
 
 struct raw_col_box {
 	float		min[3];
 	float		max[3];
 	uint8_t		surface;
 	uint8_t		piece;
 	uint8_t		lighting;
 	uint8_t		pad;
 } __attribute__((packed));
 
 struct raw_col_face {
 	uint16_t	a;
 	uint16_t	b;
 	uint16_t	c;
 	uint8_t		surface;
 	uint8_t		piece;
 } __attribute__((packed));
 
 struct raw_col_vertex {
 	int16_t		x;
 	int16_t		y;
 	int16_t		z;
 } __attribute__((packed));
 
 struct rw_header {
 	uint32_t	type;
 	uint32_t	size;
 	uint32_t	version;
 } __attribute__((packed));
 
 struct special_actor {
 	int id;
 	const char *model;
 	const char *txd;
 };
 
 struct mat4 { float m[4][4]; };
 struct rw_triangle { uint16_t v1, v2, m, v3; };
 struct atomic_entry { uint32_t f, g; };
 struct tex_name { char name[32]; };
 
 struct water_face {
 	float	x[4], y[4], z[4];
 	float	u[4], v[4], h[4];
 	int	num;
 };
 
 struct timecyc_entry {
 	uint8_t	amb[3];
 	uint8_t	dir[3];
 	uint8_t	sky_top[3];
 	uint8_t	sky_bot[3];
 	uint8_t	water[4];
 	float	far_clp;
 	float	fog_st;
 };
 
 struct arena {
 	uint8_t	*mem;
 	size_t	 pos;
 	size_t	 size;
 };
 
 struct thread_arg {
 	const uint8_t		*img_data;
 	struct img_entry	*entries;
 	uint32_t		 start;
 	uint32_t		 end;
 	struct file_list	*fl;
 	struct arena		 arena;
 };
 
 struct tga_header {
 	uint8_t  id_length;
 	uint8_t  color_map_type;
 	uint8_t  image_type;
 	uint16_t color_map_first;
 	uint16_t color_map_length;
 	uint8_t  color_map_entry_size;
 	uint16_t x_origin;
 	uint16_t y_origin;
 	uint16_t width;
 	uint16_t height;
 	uint8_t  pixel_depth;
 	uint8_t  image_descriptor;
 } __attribute__((packed));
 
 struct tar_header {
 	char name[100];
 	char mode[8];
 	char uid[8];
 	char gid[8];
 	char size[12];
 	char mtime[12];
 	char chksum[8];
 	char typeflag;
 	char linkname[100];
 	char magic[6];
 	char version[2];
 	char uname[32];
 	char gname[32];
 	char devmajor[8];
 	char devminor[8];
 	char prefix[155];
 	char pad[12];
 } __attribute__((packed));
 
 static struct ide_entry		ide_db[65536];
 static int			ide_count = 0;
 
 static struct col_cell		world_col_grid[GRID_SZ][GRID_SZ];
 static struct col_model		col_db[MAX_COL_MODELS];
 static int			col_db_count = 0;
 static int			col_hash[COL_HASH_SZ];
 
 static char			existing_models[32768][NAME_SZ];
 static int			existing_models_count = 0;
 static char			existing_textures[32768][NAME_SZ];
 static int			existing_textures_count = 0;
 
 static struct water_face	water_db[8192];
 static int			water_face_count = 0;
 
 static const struct special_actor special_actors[] = {
 	{ 1, "truth", "truth" },
 	{ 2, "maccer", "maccer" },
 	{ 3, "andre", "andre" },
 	{ 4, "bbthin", "bbthin" },
 	{ 5, "bb", "bb" },
 	{ 6, "emmet", "emmet" },
 	{ 8, "janitor", "janitor" },
 	{ 290, "rose", "rose" },
 	{ 291, "paul", "paul" },
 	{ 292, "cesar", "cesar" },
 	{ 293, "ogloc", "ogloc" },
 	{ 294, "wuzimu", "wuzimu" },
 	{ 295, "toreno", "toreno" },
 	{ 296, "jizzy", "jizzy" },
 	{ 297, "maddogg", "maddogg" },
 	{ 298, "cat", "cat" },
 	{ 299, "claude", "claude" },
 	{ 300, "ryder2", "ryder" },
 	{ 301, "ryder3", "ryder" },
 	{ 302, "emmet", "emmet" },
 	{ 303, "andre", "andre" },
 	{ 304, "kendl", "kendl" },
 	{ 305, "jethro", "jethro" },
 	{ 306, "zero", "zero" },
 	{ 307, "tbone", "tbone" },
 	{ 308, "maccer", "maccer" },
 	{ 309, "forelli", "forelli" },
 	{ 310, "sweet", "sweet" },
 	{ 311, "smoke", "smoke" },
 	{ 312, "ryder", "ryder" }
 };
 
 static void
 to_lower_str(char *str)
 {
 	while (*str) {
 		*str = tolower((unsigned char)*str);
 		str++;
 	}
 }
 
 static void
 scan_existing_assets(void)
 {
 	DIR *dir;
 	struct dirent *de;
 	char *ext;
 	size_t len;
 
 	dir = opendir("assets/models");
 	if (dir) {
 		while ((de = readdir(dir))) {
 			ext = strrchr(de->d_name, '.');
 			if (ext && strcasecmp(ext, ".ply") == 0 &&
 			    existing_models_count < 32768) {
 				len = ext - de->d_name;
 				if (len >= NAME_SZ) {
 					len = NAME_SZ - 1;
 				}
 				memcpy(existing_models[existing_models_count],
 				    de->d_name, len);
 				existing_models[existing_models_count][len] = '\0';
 				to_lower_str(existing_models[existing_models_count]);
 				existing_models_count++;
 			}
 		}
 		closedir(dir);
 	}
 
 	dir = opendir("assets/textures");
 	if (dir) {
 		while ((de = readdir(dir))) {
 			ext = strrchr(de->d_name, '.');
 			if (ext && strcasecmp(ext, ".tga") == 0 &&
 			    existing_textures_count < 32768) {
 				len = ext - de->d_name;
 				if (len >= NAME_SZ) {
 					len = NAME_SZ - 1;
 				}
 				memcpy(existing_textures[existing_textures_count],
 				    de->d_name, len);
 				existing_textures[existing_textures_count][len] = '\0';
 				to_lower_str(existing_textures[existing_textures_count]);
 				existing_textures_count++;
 			}
 		}
 		closedir(dir);
 	}
 }
 	
 static int
 asset_cached(const char *name, int is_model)
 {
 	char base[NAME_SZ];
 	size_t len;
 	int i;
 
 	len = strlen(name);
 	if (len < 5) {
 		return (0);
 	}
 
 	strncpy(base, name, len - 4);
 	base[len - 4] = '\0';
 	to_lower_str(base);
 
 	if (is_model) {
 		for (i = 0; i < existing_models_count; i++) {
 			if (strcmp(existing_models[i], base) == 0) {
 				return (1);
 			}
 		}
 	} else {
 
 	for (i = 0; i < existing_textures_count; i++) {
 			if (strcmp(existing_textures[i], base) == 0) {
 				return (1);
 			}
 		}
 	}
 	return (0);
 }
 
 static int
 asset_exists(const char *name)
 {
 	if (strstr(name, ".dff") || strstr(name, ".DFF")) {
 		return (asset_cached(name, 1));
 	}
 	if (strstr(name, ".txd") || strstr(name, ".TXD")) {
 		return (asset_cached(name, 0));
 	}
 	return (0);
 }
 
 static void *
 arena_alloc(struct arena *a, size_t sz)
 {
 	size_t align;
 	void *ptr;
 
 	align = (sz + 7) & ~7;
 	if (a->pos + align > a->size) {
 		errx(1, "OOM arena");
 	}
 	ptr = a->mem + a->pos;
 	a->pos += align;
 	return (ptr);
 }
 #define A_ALLOC(a, type, count) (type *)arena_alloc((a), sizeof(type) * (count))
 
 static size_t
 mread(void *dst, size_t sz, size_t n, struct mstream *s)
 {
 	size_t bytes;
 
 	bytes = sz * n;
 	if (s->pos + bytes <= s->size) {
 		memcpy(dst, s->data + s->pos, bytes);
 		s->pos += bytes;
 		return (n);
 	}
 	return (0);
 }
 
 static void
 mat_identity(struct mat4 *m)
 {
 	memset(m, 0, sizeof(*m));
 	m->m[0][0] = 1.0f;
 	m->m[1][1] = 1.0f;
 	m->m[2][2] = 1.0f;
 	m->m[3][3] = 1.0f;
 }
 
 static inline void
 mat_mul(struct mat4 *dst, const struct mat4 *a, const struct mat4 *b)
 {
 	struct mat4 r;
 	int i;
 
 	for (i = 0; i < 4; i++) {
 		r.m[i][0] = a->m[i][0]*b->m[0][0] + a->m[i][1]*b->m[1][0] +
 		    a->m[i][2]*b->m[2][0] + a->m[i][3]*b->m[3][0];
 		r.m[i][1] = a->m[i][0]*b->m[0][1] + a->m[i][1]*b->m[1][1] +
 		    a->m[i][2]*b->m[2][1] + a->m[i][3]*b->m[3][1];
 		r.m[i][2] = a->m[i][0]*b->m[0][2] + a->m[i][1]*b->m[1][2] +
 		    a->m[i][2]*b->m[2][2] + a->m[i][3]*b->m[3][2];
 		r.m[i][3] = a->m[i][0]*b->m[0][3] + a->m[i][1]*b->m[1][3] +
 		    a->m[i][2]*b->m[2][3] + a->m[i][3]*b->m[3][3];
 	}
 	*dst = r;
 }
 
 static int
 resolve_simple(const char *root, const char *rel, char *out, size_t out_sz)
 {
 	DIR *dir;
 	struct dirent *de;
 	char path[1024];
 	char tmp[1024];
 	char *seg, *saveptr;
 	int found;
 
 	if (snprintf(path, sizeof(path), "%s", root) >= (int)sizeof(path)) {
 		return (0);
 	}
 	strncpy(tmp, rel, sizeof(tmp) - 1);
 	tmp[sizeof(tmp) - 1] = '\0';
 
 	seg = strtok_r(tmp, "/", &saveptr);
 	while (seg) {
 		dir = opendir(path);
 		if (!dir) {
 			return (0);
 		}
 		found = 0;
 		while ((de = readdir(dir))) {
 			if (strcasecmp(de->d_name, seg) == 0) {
 				if (snprintf(path + strlen(path),
 				    sizeof(path) - strlen(path), "/%s",
 				    de->d_name) >= (int)(sizeof(path) - strlen(path))) {
 					closedir(dir);
 					return (0);
 				}
 				found = 1;
 				break;
 			}
 		}
 		closedir(dir);
 		if (!found) {
 			return (0);
 		}
 		seg = strtok_r(NULL, "/", &saveptr);
 	}
 
 	strncpy(out, path, out_sz - 1);
 	out[out_sz - 1] = '\0';
 	return (1);
 }
 
 static FILE *
 fopen_simple(const char *root, const char *rel)
 {
 	char resolved[1024];
 
 	if (resolve_simple(root, rel, resolved, sizeof(resolved))) {
 		return (fopen(resolved, "rb"));
 	}
 	return (NULL);
 }
 
 static void
 trim_spaces(char *str)
 {
 	char *start = str;
 	size_t len;
 	char *end;
 
 	while (*start == ' ' || *start == '\t') {
 		start++;
 	}
 	if (start != str) {
 		memmove(str, start, strlen(start) + 1);
 	}
 
 	len = strlen(str);
 	if (len == 0) {
 		return;
 	}
 
 	end = str + len - 1;
 	while (end >= str && (*end == ' ' || *end == '\t' || *end == '\r' || *end == '\n')) {
 		*end = '\0';
 		end--;
 	}
 }
 
 static int
 list_has(struct file_list *l, const char *name)
 {
 	int i;
 
 	for (i = 0; i < l->count; i++) {
 		if (strcasecmp(l->names[i], name) == 0) {
 			return (1);
 		}
 	}
 	return (0);
 }
 
 static void
 list_add(struct file_list *l, const char *name)
 {
 	size_t len, i;
 
 	if (l->count >= MAX_FILES || list_has(l, name)) {
 		return;
 	}
 	len = strlen(name);
 	if (len >= NAME_SZ) {
 		len = NAME_SZ - 1;
 	}
 	for (i = 0; i < len; i++) {
 		l->names[l->count][i] = tolower((unsigned char)name[i]);
 	}
 	l->names[l->count][len] = '\0';
 	l->count++;
 }
 
 static void
 clean_ide_line(char *p)
 {
 	char *comment;
 	char *end;
 	size_t len;
 
 	comment = strchr(p, '#');
 	if (comment) {
 		*comment = '\0';
 	}
 
 	len = strlen(p);
 	if (len == 0) {
 		return;
 	}
 
 	end = p + len - 1;
 	while (end >= p && (*end == ' ' || *end == '\t' || *end == '\r' || *end == '\n')) {
 		*end = '\0';
 		end--;
 	}
 }
 
 static void
 preparse_ide(const char *root, const char *rel, struct file_list *fl)
 {
 	FILE *f;
 	char line[512];
 	char *p;
 	int in_tobj = 0;
 	int in_peds = 0;
 
 	f = fopen_simple(root, rel);
 	if (!f) {
 		return;
 	}
 
 	while (fgets(line, sizeof(line), f)) {
 		p = line;
 		line[strcspn(line, "\r\n")] = '\0';
 		while (*p == ' ' || *p == '\t') {
 			p++;
 		}
 		if (*p == '\0' || *p == '#') {
 			continue;
 		}
 
 		if (strncasecmp(p, "objs", 4) == 0) {
 			in_tobj = 0;
 			in_peds = 0;
 			continue;
 		}
 		if (strncasecmp(p, "cars", 4) == 0) {
 			in_tobj = 0;
 			in_peds = 0;
 			continue;
 		}
 		if (strncasecmp(p, "peds", 4) == 0) {
 			in_tobj = 0;
 			in_peds = 1;
 			continue;
 		}
 		if (strncasecmp(p, "tobj", 4) == 0) {
 			in_tobj = 1;
 			in_peds = 0;
 			continue;
 		}
 		if (strncasecmp(p, "end", 3) == 0) {
 			in_tobj = 0;
 			in_peds = 0;
 			continue;
 		}
 
 		if (isdigit((unsigned char)p[0]) && ide_count < 65536) {
 			char model[NAME_SZ], txd[NAME_SZ];
 			char *c1, *c2, *c3;
 			char *last_comma, *prev_comma;
 			size_t len;
 			int time_on = 0, time_off = 0;
 
 			c1 = strchr(p, ',');
 			if (!c1) continue;
 			c2 = strchr(c1 + 1, ',');
 			if (!c2) continue;
 			c3 = strchr(c2 + 1, ',');
 			if (!c3) continue;
 
 			len = c2 - (c1 + 1);
 			if (len >= NAME_SZ) {
 				len = NAME_SZ - 1;
 			}
 			memcpy(model, c1 + 1, len);
 			model[len] = '\0';
 			trim_spaces(model);
 			to_lower_str(model);
 
 			len = c3 - (c2 + 1);
 			if (len >= NAME_SZ) {
 				len = NAME_SZ - 1;
 			}
 			memcpy(txd, c2 + 1, len);
 			txd[len] = '\0';
 			trim_spaces(txd);
 			to_lower_str(txd);
 
 			if (in_tobj) {
 				char temp_line[512];
 				strncpy(temp_line, p, sizeof(temp_line) - 1);
 				temp_line[sizeof(temp_line) - 1] = '\0';
 				clean_ide_line(temp_line);
 
 				last_comma = strrchr(temp_line, ',');
 				if (last_comma) {
 					time_off = atoi(last_comma + 1);
 					*last_comma = '\0';
 					prev_comma = strrchr(temp_line, ',');
 					if (prev_comma) {
 						time_on = atoi(prev_comma + 1);
 					}
 					*last_comma = ',';
 				}
 			}
 
 			if (in_peds && fl) {
 				char d_name[32], t_name[32];
 				snprintf(d_name, sizeof(d_name), "%s.dff", model);
 				snprintf(t_name, sizeof(t_name), "%s.txd", txd);
 				list_add(fl, d_name);
 				list_add(fl, t_name);
 			}
 
 			ide_db[ide_count].id = atoi(p);
 			strncpy(ide_db[ide_count].model, model, NAME_SZ);
 			strncpy(ide_db[ide_count].txd, txd, NAME_SZ);
 			ide_db[ide_count].time_on = time_on;
 			ide_db[ide_count].time_off = time_off;
 			ide_count++;
 		}
 	}
 	fclose(f);
 }
 
 
 static const struct ide_entry *
 ide_lookup(int id)
 {
 	int i;
 
 	for (i = 0; i < ide_count; i++) {
 		if (ide_db[i].id == id) {
 			return (&ide_db[i]);
 		}
 	}
 	return (NULL);
 }
 
 static int
 is_lod_name(const char *name)
 {
 	return (strstr(name, "lod") != NULL);
 }
 
 static void
 parse_text_ipl(const char *buf, size_t size, FILE *out, struct file_list *fl)
 {
 	const char *p, *end, *next;
 	char line[512];
 	char *s, *comma;
 	size_t len;
 	int in_inst;
 
 	p = buf;
 	end = buf + size;
 	in_inst = 0;
 
 	while (p < end) {
 		next = memchr(p, '\n', end - p);
 		len = next ? (size_t)(next - p) : (size_t)(end - p);
 		if (len >= sizeof(line)) {
 			len = sizeof(line) - 1;
 		}
 		memcpy(line, p, len);
 		line[len] = '\0';
 		p = next ? next + 1 : end;
 
 		s = line;
 		while (*s == ' ' || *s == '\t' || *s == '\r') {
 			s++;
 		}
 		if (*s == '\0' || *s == '#') {
 			continue;
 		}
 
 		if (strncasecmp(s, "inst", 4) == 0 || strncasecmp(s, "tobj", 4) == 0) {
 			in_inst = 1;
 			fprintf(out, "\ninst\n");
 			continue;
 		}
 		if (strncasecmp(s, "end", 3) == 0) {
 			in_inst = 0;
 			fprintf(out, "end\n");
 			continue;
 		}
 
 		if (in_inst) {
 			int id;
 			const struct ide_entry *ide;
 
 			id = atoi(s);
 			ide = ide_lookup(id);
 			if (ide && (!is_lod_name(ide->model) || ide->time_on != ide->time_off)) {
 				char d_name[32], t_name[32];
 
 				snprintf(d_name, sizeof(d_name), "%s.dff", ide->model);
 				snprintf(t_name, sizeof(t_name), "%s.txd", ide->txd);
 				list_add(fl, d_name);
 				list_add(fl, t_name);
 
 				comma = strchr(s, ',');
 				if (comma) {
 					int dummy_id;
 					char dummy_model[64];
 					int interior;
 					float px, py, pz, rx, ry, rz, rw;
 
 					if (sscanf(s, "%d, %63[^,], %d, %f, "
 					    "%f, %f, %f, %f, %f, %f",
 					    &dummy_id, dummy_model, &interior,
 					    &px, &py, &pz, &rx, &ry, &rz, &rw) == 10) {
 						fprintf(out, "%d, %s, %d, %f, "
 						    "%f, %f, %f, %f, %f, %f, "
 						    "-1, %d, %d\n",
 						    id, ide->model, interior,
 						    px, py, pz, rx, ry, rz, rw,
 						    ide->time_on, ide->time_off);
 					}
 				}
 			}
 		}
 	}
 }
 
 static void
 parse_binary_ipl(const uint8_t *buf, size_t size, FILE *out, struct file_list *fl)
 {
 	uint32_t num, off, i;
 
 	memcpy(&num, buf + 4, 4);
 	memcpy(&off, buf + 28, 4);
 	if (off + num * 40 > size) {
 		return;
 	}
 
 	fprintf(out, "\ninst\n");
 	for (i = 0; i < num; i++) {
 		struct {
 			float px, py, pz, rx, ry, rz, rw;
 			int32_t id, interior, lod;
 		} inst;
 		const struct ide_entry *ide;
 
 		memcpy(&inst, buf + off + i * 40, 40);
 
 		ide = ide_lookup(inst.id);
 		if (ide && (!is_lod_name(ide->model) || ide->time_on != ide->time_off)) {
 			char d_name[32], t_name[32];
 
 			snprintf(d_name, sizeof(d_name), "%s.dff", ide->model);
 			snprintf(t_name, sizeof(t_name), "%s.txd", ide->txd);
 			list_add(fl, d_name);
 			list_add(fl, t_name);
 
 			fprintf(out, "%d, %s, %d, %f, %f, %f, %f, %f, %f, %f, "
 			    "-1, %d, %d\n",
 			    inst.id, ide->model, inst.interior,
 			    inst.px, inst.py, inst.pz, inst.rx, inst.ry,
 			    inst.rz, inst.rw, ide->time_on, ide->time_off);
 		}
 	}
 	fprintf(out, "end\n");
 }
 
 static void
 blur_pixels(uint32_t *pixels, int w, int h)
 {
 	uint32_t *temp;
 	int x, y, kx, ky, px, py, count;
 	uint32_t r_sum, g_sum, b_sum, a_sum, c;
 
 	temp = malloc(w * h * 4);
 	if (!temp) {
 		return;
 	}
 	memcpy(temp, pixels, w * h * 4);
 
 	for (y = 0; y < h; y++) {
 		for (x = 0; x < w; x++) {
 			r_sum = 0;
 			g_sum = 0;
 			b_sum = 0;
 			a_sum = 0;
 			count = 0;
 			for (ky = -1; ky <= 1; ky++) {
 				for (kx = -1; kx <= 1; kx++) {
 					px = x + kx;
 					py = y + ky;
 					if (px >= 0 && px < w && py >= 0 &&
 					    py < h) {
 						c = temp[py * w + px];
 						b_sum += (c & 0xFF);
 						g_sum += ((c >> 8) & 0xFF);
 						r_sum += ((c >> 16) & 0xFF);
 						a_sum += ((c >> 24) & 0xFF);
 						count++;
 					}
 				}
 			}
 			pixels[y * w + x] = (b_sum/count) |
 			    ((g_sum/count) << 8) | ((r_sum/count) << 16) |
 			    ((a_sum/count) << 24);
 		}
 	}
 	free(temp);
 }
 
 static int
 nearest_pow2(int x)
 {
 	int p = 1;
 
 	while (p * 2 <= x) {
 		p *= 2;
 	}
 	if (x - p < p * 2 - x) {
 		return (p);
 	}
 	return (p * 2);
 }
 
 static void
 convert_txd(const uint8_t *data, size_t size, const char *name, struct arena *a)
 {
 	struct mstream ms = { data, size, 0 };
 	struct rw_header h, sh;
 	struct {
 		uint32_t plt, flt; char n[32], m[32]; uint32_t fmt; char fcc[4];
 		uint16_t w, h; uint8_t d, lvl, typ, cmp;
 	} __attribute__((packed)) rh;
 	uint32_t mip_size, p_size, *pixels, code, cols[4], pal[256];
 	uint8_t *cmp, r0, g0, b0, r1, g1, b1, a_val, *src, *indices;
 	uint16_t c0, c1, *src16;
 	size_t chunk_end;
 	int bx, by, is_dxt3, x, y, i, j, k, pal_has_alpha;
 	char t_name[32], out_name[256];
 	FILE *out;
 	struct tga_header out_hdr;
 	uint32_t *final_pixels;
 	int new_w, new_h, sy, sx;
 
 	while (mread(&h, sizeof(h), 1, &ms) == 1) {
 		chunk_end = ms.pos + h.size;
 		if (h.type == 0x16) {
 			continue;
 		}
 
 		if (h.type == 0x15) {
 			if (mread(&sh, sizeof(sh), 1, &ms) != 1) {
 				break;
 			}
 			if (mread(&rh, sizeof(rh), 1, &ms) != 1) {
 				break;
 			}
 
 			if (rh.plt != 9 && rh.plt != 8) {
 				ms.pos = chunk_end;
 				continue;
 			}
 
 			if (rh.d == 8) {
 				if (mread(pal, 4, 256, &ms) != 256) {
 					break;
 				}
 				pal_has_alpha = 0;
 				for (k = 0; k < 256; k++) {
 					if ((pal[k] >> 24) != 0) {
 						pal_has_alpha = 1;
 						break;
 					}
 				}
 				if (!pal_has_alpha) {
 					for (k = 0; k < 256; k++) {
 						pal[k] |= (255U << 24);
 					}
 				}
 			} else if (rh.d == 4) {
 				if (mread(pal, 4, 16, &ms) != 16) {
 					break;
 				}
 				for (k = 0; k < 16; k++) {
 					pal[k] |= (255U << 24);
 				}
 			}
 
 			if (mread(&mip_size, 4, 1, &ms) != 1) {
 				break;
 			}
 
 			p_size = rh.w * rh.h;
 			pixels = A_ALLOC(a, uint32_t, p_size);
 			memset(pixels, 0, p_size * 4);
 
 			if (memcmp(rh.fcc, "DXT1", 4) == 0 ||
 			    memcmp(rh.fcc, "DXT3", 4) == 0) {
 				cmp = A_ALLOC(a, uint8_t, mip_size);
 				mread(cmp, 1, mip_size, &ms);
 				bx = rh.w / 4;
 				by = rh.h / 4;
 				is_dxt3 = memcmp(rh.fcc, "DXT3", 4) == 0;
 
 				for (y = 0; y < by; y++) {
 					for (x = 0; x < bx; x++) {
 						const uint8_t *blk = cmp +
 						    (y * bx + x) * (is_dxt3 ? 16 : 8);
 						const uint8_t *cblk = is_dxt3 ?
 						    blk + 8 : blk;
 
 						c0 = cblk[0] | (cblk[1] << 8);
 						c1 = cblk[2] | (cblk[3] << 8);
 						code = cblk[4] | (cblk[5] << 8) |
 						    (cblk[6] << 16) | (cblk[7] << 24);
 
 						r0 = ((c0 >> 11) & 0x1F) << 3;
 						g0 = ((c0 >> 5) & 0x3F) << 2;
 						b0 = (c0 & 0x1F) << 3;
 						r1 = ((c1 >> 11) & 0x1F) << 3;
 						g1 = ((c1 >> 5) & 0x3F) << 2;
 						b1 = (c1 & 0x1F) << 3;
 
 						cols[0] = b0 | (g0 << 8) |
 						    (r0 << 16) | (0xFFU << 24);
 						cols[1] = b1 | (g1 << 8) |
 						    (r1 << 16) | (0xFFU << 24);
 						if (c0 > c1 || is_dxt3) {
 							cols[2] = ((2*b0+b1)/3) |
 							    (((2*g0+g1)/3)<<8) |
 							    (((2*r0+r1)/3)<<16) |
 							    (0xFFU<<24);
 							cols[3] = ((b0+2*b1)/3) |
 							    (((g0+2*g1)/3)<<8) |
 							    (((r0+2*r1)/3)<<16) |
 							    (0xFFU<<24);
 						} else {
 							cols[2] = ((b0+b1)/2) |
 							    (((g0+g1)/2)<<8) |
 							    (((r0+r1)/2)<<16) |
 							    (0xFFU<<24);
 							cols[3] = 0;
 						}
 
 						for (i = 0; i < 4; i++) {
 							for (j = 0; j < 4; j++) {
 								int px_idx = x * 4 + j;
 								int py_idx = y * 4 + i;
 								if (px_idx < rh.w &&
 								    py_idx < rh.h) {
 									uint32_t c = cols[(code >> (2 * (i * 4 + j))) & 3];
 									if (is_dxt3) {
 										a_val = (blk[i * 2 + (j / 2)] >> (4 * (j % 2))) & 0x0F;
 										a_val = (a_val << 4) | a_val;
 										c = (c & 0x00FFFFFF) | ((uint32_t)a_val << 24);
 									}
 									pixels[py_idx * rh.w + px_idx] = c;
 								}
 							}
 						}
 					}
 				}
 			} else if (rh.d == 8) {
 				indices = malloc(mip_size);
 				if (indices) {
 					mread(indices, 1, mip_size, &ms);
 					for (i = 0; (uint32_t)i < p_size; i++) {
 						uint32_t c = pal[indices[i]];
 						pixels[i] = (c & 0xFF00FF00) |
 						    ((c & 0x00FF0000) >> 16) |
 						    ((c & 0x000000FF) << 16);
 					}
 					free(indices);
 				}
 			} else if (rh.d == 32) {
 				mread(pixels, 1, mip_size, &ms);
 				if (rh.fmt == 22) {
 					for (i = 0; (uint32_t)i < p_size; i++) {
 						pixels[i] |= (255U << 24);
 					}
 				}
 			} else if (rh.d == 16) {
 				src16 = malloc(mip_size);
 				if (src16) {
 					mread(src16, 1, mip_size, &ms);
 					for (i = 0; (uint32_t)i < p_size; i++) {
 						uint16_t val = src16[i];
 						uint8_t r = 0, g = 0, b = 0, a_v = 255;
 						if (rh.fmt == 26) {
 							a_v = ((val >> 12) & 0x0F) * 17;
 							r = ((val >> 8) & 0x0F) * 17;
 							g = ((val >> 4) & 0x0F) * 17;
 							b = (val & 0x0F) * 17;
 						} else if (rh.fmt == 25) {
 							a_v = ((val >> 15) & 0x01) ? 255 : 0;
 							r = ((val >> 10) & 0x1F) << 3;
 							g = ((val >> 5) & 0x1F) << 3;
 							b = (val & 0x1F) << 3;
 							r |= (r >> 5); g |= (g >> 5); b |= (b >> 5);
 						} else if (rh.fmt == 23) {
 							r = ((val >> 11) & 0x1F) << 3;
 							g = ((val >> 5) & 0x3F) << 2;
 							b = (val & 0x1F) << 3;
 							r |= (r >> 5); g |= (g >> 6); b |= (b >> 5);
 							a_v = 255;
 						}
 						pixels[i] = (a_v << 24) | (r << 16) | (g << 8) | b;
 					}
 					free(src16);
 				}
 			} else if (rh.d == 24) {
 				src = malloc(mip_size);
 				if (src) {
 					mread(src, 1, mip_size, &ms);
 					for (i = 0; (uint32_t)i < p_size; i++) {
 						pixels[i] = (255U << 24) |
 						    (src[i*3+2] << 16) |
 						    (src[i*3+1] << 8) | src[i*3+0];
 					}
 					free(src);
 				}
 			}
 
 			for (k = 0; k < 31 && rh.n[k]; k++) {
 				t_name[k] = tolower((unsigned char)rh.n[k]);
 			}
 			t_name[k] = '\0';
 			if (t_name[0] == '\0') {
 				strncpy(t_name, name, 31);
 				t_name[31] = '\0';
 			}
 			to_lower_str(t_name);
 
 			if (strstr(t_name, "waterclear256")) {
 				blur_pixels(pixels, rh.w, rh.h);
 				blur_pixels(pixels, rh.w, rh.h);
 			}
 
 			new_w = nearest_pow2(rh.w);
 			new_h = nearest_pow2(rh.h);
 			final_pixels = pixels;
 
 			if (new_w != rh.w || new_h != rh.h) {
 				final_pixels = malloc(new_w * new_h * 4);
 				if (final_pixels) {
 					for (y = 0; y < new_h; y++) {
 						sy = (y * rh.h) / new_h;
 						if (sy >= rh.h) {
 							sy = rh.h - 1;
 						}
 						for (x = 0; x < new_w; x++) {
 							sx = (x * rh.w) / new_w;
 							if (sx >= rh.w) {
 								sx = rh.w - 1;
 							}
 							final_pixels[y * new_w + x] = pixels[sy * rh.w + sx];
 						}
 					}
 				} else {
 					final_pixels = pixels;
 					new_w = rh.w;
 					new_h = rh.h;
 				}
 			}
 
 			snprintf(out_name, sizeof(out_name), "assets/textures/%s.tga", t_name);
 			out = fopen(out_name, "wb");
 			if (out) {
 				memset(&out_hdr, 0, sizeof(out_hdr));
 				out_hdr.image_type = 2;
 				out_hdr.width = new_w;
 				out_hdr.height = new_h;
 				out_hdr.pixel_depth = 32;
 				out_hdr.image_descriptor = 8;
 
 				fwrite(&out_hdr, sizeof(out_hdr), 1, out);
 				fwrite(final_pixels, 4, new_w * new_h, out);
 				fclose(out);
 			}
 
 			if (final_pixels != pixels) {
 				free(final_pixels);
 			}
 		}
 		ms.pos = chunk_end;
 	}
 }
 
 static void
 process_particle_txd(const char *root, struct arena *a)
 {
 	FILE *f;
 	size_t sz;
 	uint8_t *buf;
 
 	f = fopen_simple(root, "models/particle.txd");
 	if (!f) {
 		return;
 	}
 	fseek(f, 0, SEEK_END);
 	sz = ftell(f);
 	fseek(f, 0, SEEK_SET);
 	buf = malloc(sz);
 	if (fread(buf, 1, sz, f) == sz) {
 		a->pos = 0;
 		convert_txd(buf, sz, "particle", a);
 	}
 	free(buf);
 	fclose(f);
 }
 
 struct frame { struct mat4 abs; int32_t parent; };
 struct geom { float *v, *u; uint8_t *c; uint16_t *i, *m; uint32_t nv, ni, nm; struct tex_name *t; };
 
 static int
 is_container(uint32_t type)
 {
 	switch (type) {
 	case 0x03: case 0x06: case 0x07: case 0x08: case 0x0E: case 0x0F:
 	case 0x10: case 0x14: case 0x1A: case 0x1B:
 		return (1);
 	}
 	return (0);
 }
 
 static int
 is_skin(const char *name)
 {
 	int i;
 
 	for (i = 0; i < 313; i++) {
 		if (skin_names[i] && skin_names[i][0] != '\0' &&
 		    strcasecmp(skin_names[i], name) == 0) {
 			return (1);
 		}
 	}
 	for (i = 0; i < (int)(sizeof(special_actors) / sizeof(special_actors[0])); i++) {
 		if (strcasecmp(special_actors[i].model, name) == 0) {
 			return (1);
 		}
 	}
 	return (0);
 }
 
 static void
 convert_dff(const uint8_t *data, size_t size, const char *name, struct arena *a)
 {
 	struct mstream ms = { data, size, 0 };
 	struct rw_header h;
 	struct frame *frames = NULL;
 	struct geom *geoms = NULL;
 	struct atomic_entry *atomics;
 	uint32_t n_frames = 0, n_geoms = 0, n_atomics = 0;
 	uint32_t last_cont = 0;
 	int32_t cur_g = -1, cur_m = -1, wait_tex = 0;
 	size_t end;
 	int is_ped;
 
 	is_ped = is_skin(name);
 
 	atomics = A_ALLOC(a, struct atomic_entry, 256);
 
 	while (mread(&h, sizeof(h), 1, &ms) == 1) {
 		end = ms.pos + h.size;
 
 		if (is_container(h.type)) {
 			last_cont = h.type;
 			if (h.type == 0x0F) cur_g++;
 			if (h.type == 0x08) cur_m = -1;
 			if (h.type == 0x07) cur_m++;
 			if (h.type == 0x06) wait_tex = 1;
 			continue;
 		}
 
 		if (h.type == 0x01) {
 			if (last_cont == 0x0E) {
 				mread(&n_frames, 4, 1, &ms);
 				frames = A_ALLOC(a, struct frame, n_frames);
 				for (uint32_t i = 0; i < n_frames; i++) {
 					float rot[9], pos[3]; int32_t parent, flags;
 					mread(rot, 4, 9, &ms); mread(pos, 4, 3, &ms);
 					mread(&parent, 4, 1, &ms); mread(&flags, 4, 1, &ms);
 
 					struct mat4 l; memset(&l, 0, sizeof(l));
 					l.m[0][0] = rot[0]; l.m[0][1] = rot[3]; l.m[0][2] = rot[6];
 					l.m[1][0] = rot[1]; l.m[1][1] = rot[4]; l.m[1][2] = rot[7];
 					l.m[2][0] = rot[2]; l.m[2][1] = rot[5]; l.m[2][2] = rot[8];
 					l.m[0][3] = pos[0]; l.m[1][3] = pos[1]; l.m[2][3] = pos[2]; l.m[3][3] = 1.0f;
 
 					if (parent >= 0 && parent < (int32_t)i) {
 						mat_mul(&frames[i].abs, &frames[parent].abs, &l);
 					} else {
 						float sx = sqrtf(l.m[0][0]*l.m[0][0] + l.m[1][0]*l.m[1][0] + l.m[2][0]*l.m[2][0]);
 						float sy = sqrtf(l.m[0][1]*l.m[0][1] + l.m[1][1]*l.m[1][1] + l.m[2][1]*l.m[2][1]);
 						float sz = sqrtf(l.m[0][2]*l.m[0][2] + l.m[1][2]*l.m[1][2] + l.m[2][2]*l.m[2][2]);
 						mat_identity(&frames[i].abs);
 						frames[i].abs.m[0][0] = sx;
 						frames[i].abs.m[1][1] = sy;
 						frames[i].abs.m[2][2] = sz;
 					}
 				}
 			} else if (last_cont == 0x1A) {
 				mread(&n_geoms, 4, 1, &ms);
 				if (n_geoms) {
 					geoms = A_ALLOC(a, struct geom, n_geoms);
 				}
 				cur_g = -1;
 			} else if (last_cont == 0x0F && cur_g >= 0) {
 				struct geom *g = &geoms[cur_g];
 				uint32_t fmt, morphs;
 				mread(&fmt, 4, 1, &ms); mread(&g->ni, 4, 1, &ms);
 				mread(&g->nv, 4, 1, &ms); mread(&morphs, 4, 1, &ms);
 
 				if (g->nv > 0 && g->ni > 0) {
 					uint16_t flg = fmt & 0xFFFF, tex_c = (fmt & 0x00FF0000) >> 16;
 					if (tex_c == 0 && (flg & 0x0004)) {
 						tex_c = 1;
 					}
 
 					g->c = NULL;
 					if (flg & 0x0008) {
 						g->c = A_ALLOC(a, uint8_t, g->nv * 4);
 						mread(g->c, 1, g->nv * 4, &ms);
 					}
 
 					g->u = A_ALLOC(a, float, g->nv * 2);
 					if (tex_c > 0) {
 						mread(g->u, sizeof(float) * 2, g->nv, &ms);
 						if (tex_c > 1) {
 							ms.pos += (tex_c - 1) * sizeof(float) * 2 * g->nv;
 						}
 					}
 
 					struct rw_triangle *tris = A_ALLOC(a, struct rw_triangle, g->ni);
 					mread(tris, sizeof(*tris), g->ni, &ms);
 					ms.pos += sizeof(float) * 4;
 
 					int32_t has_v, has_n;
 					mread(&has_v, 4, 1, &ms); mread(&has_n, 4, 1, &ms);
 					if (has_v) {
 						g->v = A_ALLOC(a, float, g->nv * 3);
 						mread(g->v, sizeof(float) * 3, g->nv, &ms);
 					}
 
 					g->i = A_ALLOC(a, uint16_t, g->ni * 3);
 					g->m = A_ALLOC(a, uint16_t, g->ni);
 					for (uint32_t j = 0; j < g->ni; j++) {
 						g->i[j*3+0] = tris[j].v1;
 						g->i[j*3+1] = tris[j].v2;
 						g->i[j*3+2] = tris[j].v3;
 						g->m[j] = tris[j].m;
 					}
 				}
 			} else if (last_cont == 0x08 && cur_g >= 0) {
 				mread(&geoms[cur_g].nm, 4, 1, &ms);
 				if (geoms[cur_g].nm > 0) {
 					geoms[cur_g].t = A_ALLOC(a, struct tex_name, geoms[cur_g].nm);
 				}
 			} else if (last_cont == 0x14) {
 				uint32_t f_idx, g_idx, flg, unused;
 				mread(&f_idx, 4, 1, &ms); mread(&g_idx, 4, 1, &ms);
 				mread(&flg, 4, 1, &ms); mread(&unused, 4, 1, &ms);
 				if (n_atomics < 256) {
 					atomics[n_atomics].f = f_idx;
 					atomics[n_atomics].g = g_idx;
 					n_atomics++;
 				}
 			}
 			last_cont = 0;
 		} else if (h.type == 0x02 && wait_tex && cur_g >= 0) {
 			struct geom *g = &geoms[cur_g];
 			if (cur_m >= 0 && (uint32_t)cur_m < g->nm) {
 				size_t len = h.size < 31 ? h.size : 31;
 				mread(g->t[cur_m].name, 1, len, &ms);
 				for (size_t k = 0; k < len; k++) {
 					g->t[cur_m].name[k] = tolower((unsigned char)g->t[cur_m].name[k]);
 				}
 			}
 			wait_tex = 0;
 		}
 
 		ms.pos = end;
 	}
 
 	uint32_t t_nv = 0, t_ni = 0, t_nm = 0;
 	int has_any_colors = 0;
 	for (uint32_t i = 0; i < n_atomics; i++) {
 		if (atomics[i].g < n_geoms) {
 			t_nv += geoms[atomics[i].g].nv;
 			t_ni += geoms[atomics[i].g].ni;
 			t_nm += geoms[atomics[i].g].nm;
 			if (geoms[atomics[i].g].c) {
 				has_any_colors = 1;
 			}
 		}
 	}
 
 	if (t_nv > 0 && t_ni > 0) {
 		float *f_v = A_ALLOC(a, float, t_nv * 3);
 		float *f_u = A_ALLOC(a, float, t_nv * 2);
 		uint8_t *f_c = A_ALLOC(a, uint8_t, t_nv * 4);
 		uint16_t *f_i = A_ALLOC(a, uint16_t, t_ni * 3);
 		uint16_t *f_m = A_ALLOC(a, uint16_t, t_ni);
 		struct tex_name *f_t = t_nm > 0 ? A_ALLOC(a, struct tex_name, t_nm) : NULL;
 
 		uint32_t vo = 0, to = 0, mo = 0;
 		for (uint32_t i = 0; i < n_atomics; i++) {
 			if (atomics[i].g >= n_geoms || atomics[i].f >= n_frames) {
 				continue;
 			}
 			struct geom *g = &geoms[atomics[i].g];
 			struct frame *fr = &frames[atomics[i].f];
 
 			for (uint32_t j = 0; j < g->nv; j++) {
 				float x = g->v[j*3+0], y = g->v[j*3+1], z = g->v[j*3+2];
 				f_v[(vo+j)*3+0] = fr->abs.m[0][0]*x + fr->abs.m[0][1]*y + fr->abs.m[0][2]*z + fr->abs.m[0][3];
 				f_v[(vo+j)*3+1] = fr->abs.m[1][0]*x + fr->abs.m[1][1]*y + fr->abs.m[1][2]*z + fr->abs.m[1][3];
 				f_v[(vo+j)*3+2] = fr->abs.m[2][0]*x + fr->abs.m[2][1]*y + fr->abs.m[2][2]*z + fr->abs.m[2][3];
 				f_u[(vo+j)*2+0] = g->u[j*2+0];
 				f_u[(vo+j)*2+1] = g->u[j*2+1];
 				if (g->c) {
 					f_c[(vo+j)*4+0] = g->c[j*4+0];
 					f_c[(vo+j)*4+1] = g->c[j*4+1];
 					f_c[(vo+j)*4+2] = g->c[j*4+2];
 					f_c[(vo+j)*4+3] = g->c[j*4+3];
 				} else {
 					f_c[(vo+j)*4+0] = 255;
 					f_c[(vo+j)*4+1] = 255;
 					f_c[(vo+j)*4+2] = 255;
 					f_c[(vo+j)*4+3] = 255;
 				}
 			}
 			for (uint32_t j = 0; j < g->ni; j++) {
 				f_i[(to+j)*3+0] = g->i[j*3+0] + vo;
 				f_i[(to+j)*3+1] = g->i[j*3+1] + vo;
 				f_i[(to+j)*3+2] = g->i[j*3+2] + vo;
 				f_m[to+j] = g->m[j] + mo;
 			}
 			for (uint32_t j = 0; j < g->nm; j++) {
 				memcpy(f_t[mo+j].name, g->t[j].name, 32);
 			}
 			vo += g->nv;
 			to += g->ni;
 			mo += g->nm;
 		}
 
 		float b_cx = 0, b_cy = 0, b_cz = 0, b_r = 0;
 		float minx = f_v[0], maxx = f_v[0], miny = f_v[1], maxy = f_v[1], minz = f_v[2], maxz = f_v[2];
 		for (uint32_t i = 1; i < t_nv; i++) {
 			if (f_v[i*3+0] < minx) minx = f_v[i*3+0];
 			if (f_v[i*3+0] > maxx) maxx = f_v[i*3+0];
 			if (f_v[i*3+1] < miny) miny = f_v[i*3+1];
 			if (f_v[i*3+1] > maxy) maxy = f_v[i*3+1];
 			if (f_v[i*3+2] < minz) minz = f_v[i*3+2];
 			if (f_v[i*3+2] > maxz) maxz = f_v[i*3+2];
 		}
 		b_cx = (minx+maxx)*0.5f;
 		b_cy = (miny+maxy)*0.5f;
 		b_cz = (minz+maxz)*0.5f;
 		for (uint32_t i = 0; i < t_nv; i++) {
 			float dx = f_v[i*3+0] - b_cx, dy = f_v[i*3+1] - b_cy, dz = f_v[i*3+2] - b_cz;
 			float d2 = dx*dx + dy*dy + dz*dz;
 			if (d2 > b_r) {
 				b_r = d2;
 			}
 		}
 		b_r = sqrtf(b_r);
 
 		char out_name[256];
 		snprintf(out_name, sizeof(out_name), "assets/models/%s.ply", name);
 		FILE *out = fopen(out_name, "wb");
 		if (out) {
 			fprintf(out, "ply\n");
 			fprintf(out, "format binary_little_endian 1.0\n");
 			fprintf(out, "comment spr_cx %f\n", b_cx);
 			fprintf(out, "comment spr_cy %f\n", b_cy);
 			fprintf(out, "comment spr_cz %f\n", b_cz);
 			fprintf(out, "comment spr_r %f\n", b_r);
 			fprintf(out, "comment flags %u\n", has_any_colors ? 1 : 0);
 			for (uint32_t i = 0; i < t_nm; i++) {
 				fprintf(out, "comment texture %s\n", f_t[i].name);
 			}
 			fprintf(out, "element vertex %u\n", t_nv);
 			fprintf(out, "property float x\n");
 			fprintf(out, "property float y\n");
 			fprintf(out, "property float z\n");
 			fprintf(out, "property float s\n");
 			fprintf(out, "property float t\n");
 			fprintf(out, "property uchar red\n");
 			fprintf(out, "property uchar green\n");
 			fprintf(out, "property uchar blue\n");
 			fprintf(out, "property uchar alpha\n");
 			fprintf(out, "element face %u\n", t_ni);
 			fprintf(out, "property list uchar int vertex_indices\n");
 			fprintf(out, "property ushort material_index\n");
 			fprintf(out, "end_header\n");
 
 			for (uint32_t i = 0; i < t_nv; i++) {
 				float vx = f_v[i*3+0], vy = f_v[i*3+1], vz = f_v[i*3+2];
 				float tu = f_u[i*2+0], tv = f_u[i*2+1];
 				uint8_t cr = f_c[i*4+0], cg = f_c[i*4+1], cb = f_c[i*4+2], ca = f_c[i*4+3];
 
 				if (is_ped) {
 					vx = -vx;
 				}
 
 				fwrite(&vx, 4, 1, out);
 				fwrite(&vy, 4, 1, out);
 				fwrite(&vz, 4, 1, out);
 				fwrite(&tu, 4, 1, out);
 				fwrite(&tv, 4, 1, out);
 				fwrite(&cr, 1, 1, out);
 				fwrite(&cg, 1, 1, out);
 				fwrite(&cb, 1, 1, out);
 				fwrite(&ca, 1, 1, out);
 			}
 
 			for (uint32_t i = 0; i < t_ni; i++) {
 				uint8_t count = 3;
 				int32_t idx[3] = { f_i[i*3+0], f_i[i*3+1], f_i[i*3+2] };
 				uint16_t mat = f_m[i];
 				fwrite(&count, 1, 1, out);
 				fwrite(idx, 4, 3, out);
 				fwrite(&mat, 2, 1, out);
 			}
 			fclose(out);
 		}
 	}
 }
 
 static void
 process_local_ipl(const char *root, const char *rel, FILE *out, struct file_list *fl)
 {
 	FILE *f;
 	size_t sz;
 	char *buf;
 
 	f = fopen_simple(root, rel);
 	if (!f) {
 		return;
 	}
 	fseek(f, 0, SEEK_END);
 	sz = ftell(f);
 	fseek(f, 0, SEEK_SET);
 	buf = malloc(sz);
 	if (fread(buf, 1, sz, f) == sz) {
 		parse_text_ipl(buf, sz, out, fl);
 	}
 	free(buf);
 	fclose(f);
 }
 
 static void
 process_gta_dat_ide(const char *root, const char *dat_path, struct file_list *fl)
 {
 	FILE *f;
 	char line[512];
 	char *p;
 
 	f = fopen_simple(root, dat_path);
 	if (!f) {
 		return;
 	}
 
 	while (fgets(line, sizeof(line), f)) {
 		p = line;
 		line[strcspn(line, "\r\n")] = '\0';
 		while (*p == ' ' || *p == '\t') {
 			p++;
 		}
 		if (*p == '\0' || *p == '#') {
 			continue;
 		}
 
 		if (strncasecmp(p, "IDE ", 4) == 0) {
 			char rel[512];
 			char *src = p + 4;
 			while (*src == ' ' || *src == '\t') {
 				src++;
 			}
 			for (size_t i = 0; i < sizeof(rel) - 1 && src[i]; i++) {
 				if (src[i] == '\\') {
 					rel[i] = '/';
 				} else {
 					rel[i] = src[i];
 				}
 				rel[i+1] = '\0';
 			}
 			trim_spaces(rel);
 			preparse_ide(root, rel, fl);
 		}
 	}
 	fclose(f);
 }
 
 static void
 process_gta_dat_ipl(const char *root, const char *dat_path, FILE *map_out, struct file_list *fl)
 {
 	FILE *f;
 	char line[512];
 	char *p;
 
 	f = fopen_simple(root, dat_path);
 	if (!f) {
 		return;
 	}
 
 	while (fgets(line, sizeof(line), f)) {
 		p = line;
 		line[strcspn(line, "\r\n")] = '\0';
 		while (*p == ' ' || *p == '\t') {
 			p++;
 		}
 		if (*p == '\0' || *p == '#') {
 			continue;
 		}
 
 		if (strncasecmp(p, "IPL ", 4) == 0) {
 			char rel[512];
 			char *src = p + 4;
 			while (*src == ' ' || *src == '\t') {
 				src++;
 			}
 			for (size_t i = 0; i < sizeof(rel) - 1 && src[i]; i++) {
 				if (src[i] == '\\') {
 					rel[i] = '/';
 				} else {
 					rel[i] = src[i];
 				}
 				rel[i+1] = '\0';
 			}
 			trim_spaces(rel);
 			process_local_ipl(root, rel, map_out, fl);
 		}
 	}
 	fclose(f);
 }
 
 static void
 process_water(const char *root)
 {
 	FILE *f, *out;
 	char line[512], *p, *tok, *save;
 	char *tokens[32];
 	int t_count, i, j, k, collapsed;
 	uint32_t count;
 	float limit = 2980.0f;
 	float ax_min, ax_max, ay_min, ay_max, az;
 	float bx_min, bx_max, by_min, by_max;
 	struct water_face *a, *b, *face;
 
 	f = fopen_simple(root, "data/water.dat");
 	if (f == NULL) {
 		return;
 	}
 
 	out = fopen("assets/water.bin", "wb");
 	if (out == NULL) {
 		fclose(f);
 		return;
 	}
 
 	count = 0;
 	water_face_count = 0;
 
 	while (fgets(line, sizeof(line), f)) {
 		p = line;
 		while (*p == ' ' || *p == '\t') {
 			p++;
 		}
 		if (*p == '\0' || *p == '#' || *p == '*' || *p == '\r' ||
 		    *p == '\n' || strncasecmp(p, "processed", 9) == 0) {
 			continue;
 		}
 
 		t_count = 0;
 		tok = strtok_r(p, " \t\r\n", &save);
 		while (tok && t_count < 32) {
 			tokens[t_count++] = tok;
 			tok = strtok_r(NULL, " \t\r\n", &save);
 		}
 
 		if ((t_count == 29 || t_count == 22) && water_face_count < 8192) {
 			face = &water_db[water_face_count];
 			k = atoi(tokens[t_count - 1]);
 			if (k == 1 || k == 3) {
 				face->num = t_count == 29 ? 4 : 3;
 				for (j = 0; j < face->num; j++) {
 					face->x[j] = strtof(tokens[j * 7 + 0], NULL);
 					face->y[j] = strtof(tokens[j * 7 + 1], NULL);
 					
 					face->z[j] = strtof(tokens[j * 7 + 2], NULL);
 					face->z[j] = roundf(face->z[j] * 10.0f) / 10.0f;
 					
 					face->u[j] = strtof(tokens[j * 7 + 3], NULL);
 					face->v[j] = strtof(tokens[j * 7 + 4], NULL);
 					face->h[j] = strtof(tokens[j * 7 + 6], NULL);
 
 					if (face->x[j] > limit) {
 						face->x[j] = limit;
 					}
 					if (face->x[j] < -limit) {
 						face->x[j] = -limit;
 					}
 					if (face->y[j] > limit) {
 						face->y[j] = limit;
 					}
 					if (face->y[j] < -limit) {
 						face->y[j] = -limit;
 					}
 				}
 				water_face_count++;
 			}
 		}
 	}
 
 	for (i = 0; i < water_face_count; i++) {
 		a = &water_db[i];
 		if (a->num == 0) {
 			continue;
 		}
 
 		ax_min = a->x[0];
 		ax_max = a->x[0];
 		ay_min = a->y[0];
 		ay_max = a->y[0];
 		az = a->z[0];
 		for (k = 1; k < a->num; k++) {
 			if (a->x[k] < ax_min) {
 				ax_min = a->x[k];
 			}
 			if (a->x[k] > ax_max) {
 				ax_max = a->x[k];
 			}
 			if (a->y[k] < ay_min) {
 				ay_min = a->y[k];
 			}
 			if (a->y[k] > ay_max) {
 				ay_max = a->y[k];
 			}
 		}
 
 		for (j = 0; j < water_face_count; j++) {
 			if (i == j) {
 				continue;
 			}
 			b = &water_db[j];
 			if (b->num == 0) {
 				continue;
 			}
 
 			if (fabsf(b->z[0] - az) > 0.01f) {
 				continue;
 			}
 
 			bx_min = b->x[0];
 			bx_max = b->x[0];
 			by_min = b->y[0];
 			by_max = b->y[0];
 			for (k = 1; k < b->num; k++) {
 				if (b->x[k] < bx_min) {
 					bx_min = b->x[k];
 				}
 				if (b->x[k] > bx_max) {
 					bx_max = b->x[k];
 				}
 				if (b->y[k] < by_min) {
 					by_min = b->y[k];
 				}
 				if (b->y[k] > by_max) {
 					by_max = b->y[k];
 				}
 			}
 
 			if (bx_max > ax_min && bx_min < ax_max && by_max > ay_min && by_min < ay_max) {
 				if (bx_min < ax_max && bx_max > ax_max && bx_min > ax_min) {
 					for (k = 0; k < b->num; k++) {
 						if (fabsf(b->x[k] - bx_min) < 0.1f) {
 							b->x[k] = ax_max;
 						}
 					}
 				} else if (bx_max > ax_min && bx_min < ax_min && bx_max < ax_max) {
 					for (k = 0; k < b->num; k++) {
 						if (fabsf(b->x[k] - bx_max) < 0.1f) {
 							b->x[k] = ax_min;
 						}
 					}
 				} else if (by_min < ay_max && by_max > ay_max && by_min > ay_min) {
 					for (k = 0; k < b->num; k++) {
 						if (fabsf(b->y[k] - by_min) < 0.1f) {
 							b->y[k] = ay_max;
 						}
 					}
 				} else if (by_max > ay_min && by_min < ay_min && by_max < ay_max) {
 					for (k = 0; k < b->num; k++) {
 						if (fabsf(b->y[k] - by_max) < 0.1f) {
 							b->y[k] = ay_min;
 						}
 					}
 				}
 			}
 		}
 	}
 
 	fwrite(&count, sizeof(count), 1, out);
 	for (i = 0; i < water_face_count; i++) {
 		face = &water_db[i];
 		collapsed = 0;
 
 		if (face->num == 4) {
 			if (fabsf(face->x[0] - face->x[2]) < 0.1f && fabsf(face->y[0] - face->y[2]) < 0.1f) {
 				collapsed = 1;
 			}
 		} else if (face->num == 3) {
 			if (fabsf(face->x[0] - face->x[1]) < 0.1f && fabsf(face->y[0] - face->y[1]) < 0.1f) {
 				collapsed = 1;
 			}
 		}
 
 		if (collapsed == 0) {
 			fwrite(face, sizeof(struct water_face), 1, out);
 			count++;
 		}
 	}
 
 	fseek(out, 0, SEEK_SET);
 	fwrite(&count, sizeof(count), 1, out);
 	fclose(out);
 	fclose(f);
 }
 
 static void
 mat_translate(struct mat4 *m, float x, float y, float z)
 {
 	mat_identity(m);
 	m->m[0][3] = x;
 	m->m[1][3] = y;
 	m->m[2][3] = z;
 }
 
 static void
 mat_from_quat(struct mat4 *m, float qx, float qy, float qz, float qw)
 {
 	float len;
 
 	qw = -qw;
 	len = sqrtf(qx * qx + qy * qy + qz * qz + qw * qw);
 	if (len > 0.0f) {
 		qx /= len;
 		qy /= len;
 		qz /= len;
 		qw /= len;
 	}
 	mat_identity(m);
 	m->m[0][0] = 1.0f - 2.0f * (qy * qy + qz * qz);
 	m->m[0][1] = 2.0f * (qx * qy - qz * qw);
 	m->m[0][2] = 2.0f * (qx * qz + qy * qw);
 	m->m[1][0] = 2.0f * (qx * qy + qz * qw);
 	m->m[1][1] = 1.0f - 2.0f * (qx * qx + qz * qz);
 	m->m[1][2] = 2.0f * (qy * qz - qx * qw);
 	m->m[2][0] = 2.0f * (qx * qz - qy * qw);
 	m->m[2][1] = 2.0f * (qy * qz + qx * qw);
 	m->m[2][2] = 1.0f - 2.0f * (qx * qx + qy * qy);
 }
 
 static inline void
 mat_transform(float dst[3], float *w_out, const struct mat4 *m, const float v[3])
 {
 	dst[0] = m->m[0][0] * v[0] + m->m[0][1] * v[1] + m->m[0][2] * v[2] + m->m[0][3];
 	dst[1] = m->m[1][0] * v[0] + m->m[1][1] * v[1] + m->m[1][2] * v[2] + m->m[1][3];
 	dst[2] = m->m[2][0] * v[0] + m->m[2][1] * v[1] + m->m[2][2] * v[2] + m->m[2][3];
 	*w_out = m->m[3][0] * v[0] + m->m[3][1] * v[1] + m->m[3][2] * v[2] + m->m[3][3];
 }
 
 static uint32_t
 str_hash(const char *s)
 {
 	uint32_t h;
 
 	h = 5381;
 	while (*s) {
 		h = ((h << 5) + h) + (unsigned char)*s;
 		s++;
 	}
 	return (h);
 }
 
 static void
 col_db_insert(struct col_model *cm)
 {
 	uint32_t slot;
 
 	slot = str_hash(cm->name) % COL_HASH_SZ;
 	while (col_hash[slot] != 0) {
 		slot = (slot + 1) % COL_HASH_SZ;
 	}
 	col_hash[slot] = col_db_count;
 }
 
 static void
 parse_col_data(const uint8_t *data, size_t size)
 {
 	const struct col_header *h;
 	const uint8_t *base;
 	const struct raw_col_vertex *verts;
 	const struct raw_col_face *faces;
 	const struct raw_col_box *boxes;
 	struct col_model *cm;
 	struct col_triangle *t;
 	size_t pos;
 	uint32_t total_tris, i, b;
 	int k;
 	float x0, y0, z0, x1, y1, z1;
 	uint8_t surf;
 	float p[8][3];
 	static const int box_idx[12][3] = {
 		{0, 1, 2}, {0, 2, 3}, {4, 6, 5}, {4, 7, 6},
 		{0, 4, 5}, {0, 5, 1}, {3, 2, 6}, {3, 6, 7},
 		{0, 3, 7}, {0, 7, 4}, {1, 5, 6}, {1, 6, 2}
 	};
 
 	pos = 0;
 	while (pos + sizeof(struct col_header) <= size) {
 		h = (const struct col_header *)(data + pos);
 		if (memcmp(h->magic, "COL2", 4) != 0 &&
 		    memcmp(h->magic, "COL3", 4) != 0 &&
 		    memcmp(h->magic, "COLL", 4) != 0) {
 			break;
 		}
 		if (col_db_count >= MAX_COL_MODELS) {
 			break;
 		}
 
 		cm = &col_db[col_db_count];
 		strncpy(cm->name, h->model_name, sizeof(cm->name) - 1);
 		cm->name[sizeof(cm->name) - 1] = '\0';
 		trim_spaces(cm->name);
 		to_lower_str(cm->name);
 
 		total_tris = h->num_faces + (h->num_boxes * 12);
 		if (total_tris > 0) {
 			cm->tris = malloc(total_tris * sizeof(struct col_triangle));
 			if (!cm->tris) {
 				break;
 			}
 			cm->num_tris = 0;
 			base = data + pos + 4;
 
 			if (h->num_faces > 0 && h->vertices_offset && h->faces_offset) {
 				verts = (const struct raw_col_vertex *)(base + h->vertices_offset);
 				faces = (const struct raw_col_face *)(base + h->faces_offset);
 				for (i = 0; i < h->num_faces; i++) {
 					t = &cm->tris[cm->num_tris++];
 					t->v0[0] = verts[faces[i].a].x / 128.0f;
 					t->v0[1] = verts[faces[i].a].y / 128.0f;
 					t->v0[2] = verts[faces[i].a].z / 128.0f;
 
 					t->v1[0] = verts[faces[i].b].x / 128.0f;
 					t->v1[1] = verts[faces[i].b].y / 128.0f;
 					t->v1[2] = verts[faces[i].b].z / 128.0f;
 
 					t->v2[0] = verts[faces[i].c].x / 128.0f;
 					t->v2[1] = verts[faces[i].c].y / 128.0f;
 					t->v2[2] = verts[faces[i].c].z / 128.0f;
 
 					t->surface = faces[i].surface;
 				}
 			}
 
 			if (h->num_boxes > 0 && h->boxes_offset) {
 				boxes = (const struct raw_col_box *)(base + h->boxes_offset);
 				for (b = 0; b < h->num_boxes; b++) {
 					x0 = boxes[b].min[0];
 					y0 = boxes[b].min[1];
 					z0 = boxes[b].min[2];
 					x1 = boxes[b].max[0];
 					y1 = boxes[b].max[1];
 					z1 = boxes[b].max[2];
 					surf = boxes[b].surface;
 
 					p[0][0] = x0; p[0][1] = y0; p[0][2] = z0;
 					p[1][0] = x1; p[1][1] = y0; p[1][2] = z0;
 					p[2][0] = x1; p[2][1] = y1; p[2][2] = z0;
 					p[3][0] = x0; p[3][1] = y1; p[3][2] = z0;
 					p[4][0] = x0; p[4][1] = y0; p[4][2] = z1;
 					p[5][0] = x1; p[5][1] = y0; p[5][2] = z1;
 					p[6][0] = x1; p[6][1] = y1; p[6][2] = z1;
 					p[7][0] = x0; p[7][1] = y1; p[7][2] = z1;
 
 					for (k = 0; k < 12; k++) {
 						t = &cm->tris[cm->num_tris++];
 						memcpy(t->v0, p[box_idx[k][0]], sizeof(float) * 3);
 						memcpy(t->v1, p[box_idx[k][1]], sizeof(float) * 3);
 						memcpy(t->v2, p[box_idx[k][2]], sizeof(float) * 3);
 						t->surface = surf;
 					}
 				}
 			}
 			col_db_count++;
 			col_db_insert(cm);
 		}
 		pos += 8 + h->size;
 	}
 }
 
 static void
 process_gta_dat_col(const char *root, const char *dat_path)
 {
 	FILE *f;
 	FILE *cf;
 	char line[512];
 	char rel[512];
 	char *p;
 	char *src;
 	uint8_t *buf;
 	size_t sz, i;
 
 	f = fopen_simple(root, dat_path);
 	if (!f) {
 		return;
 	}
 
 	while (fgets(line, sizeof(line), f)) {
 		p = line;
 		while (*p == ' ' || *p == '\t') {
 			p++;
 		}
 		if (strncasecmp(p, "COLFILE ", 8) == 0) {
 			src = p + 8;
 			while (*src == ' ' || *src == '\t') {
 				src++;
 			}
 			while (*src >= '0' && *src <= '9') {
 				src++;
 			}
 			while (*src == ' ' || *src == '\t') {
 				src++;
 			}
 			for (i = 0; i < sizeof(rel) - 1 && src[i]; i++) {
 				if (src[i] == '\\') {
 					rel[i] = '/';
 				} else {
 					rel[i] = src[i];
 				}
 				rel[i + 1] = '\0';
 			}
 			trim_spaces(rel);
 
 			cf = fopen_simple(root, rel);
 			if (cf) {
 				fseek(cf, 0, SEEK_END);
 				sz = ftell(cf);
 				fseek(cf, 0, SEEK_SET);
 				buf = malloc(sz);
 				if (buf && fread(buf, 1, sz, cf) == sz) {
 					parse_col_data(buf, sz);
 				}
 				free(buf);
 				fclose(cf);
 			}
 		}
 	}
 	fclose(f);
 }
 
 static struct col_model *
 col_lookup(const char *name)
 {
 	uint32_t slot;
 	int idx;
 
 	slot = str_hash(name) % COL_HASH_SZ;
 	while (col_hash[slot] != 0) {
 		idx = col_hash[slot] - 1;
 		if (strcmp(col_db[idx].name, name) == 0) {
 			return (&col_db[idx]);
 		}
 		slot = (slot + 1) % COL_HASH_SZ;
 	}
 	return (NULL);
 }
 
 static void
 instantiate_collision(const char *model_name, const struct mat4 *world_mat)
 {
 	struct col_model *cm;
 	struct col_triangle wt;
 	struct col_cell *c;
 	float w, min_x, max_x, min_z, max_z, e1[3], e2[3], len;
 	uint32_t i;
 	int gx0, gx1, gz0, gz1, gx, gz;
 
 	cm = col_lookup(model_name);
 	if (!cm || cm->num_tris == 0) {
 		return;
 	}
 
 	for (i = 0; i < cm->num_tris; i++) {
 		mat_transform(wt.v0, &w, world_mat, cm->tris[i].v0);
 		mat_transform(wt.v1, &w, world_mat, cm->tris[i].v1);
 		mat_transform(wt.v2, &w, world_mat, cm->tris[i].v2);
 		wt.surface = cm->tris[i].surface;
 
 		e1[0] = wt.v1[0] - wt.v0[0];
 		e1[1] = wt.v1[1] - wt.v0[1];
 		e1[2] = wt.v1[2] - wt.v0[2];
 
 		e2[0] = wt.v2[0] - wt.v0[0];
 		e2[1] = wt.v2[1] - wt.v0[1];
 		e2[2] = wt.v2[2] - wt.v0[2];
 
 		wt.norm[0] = e1[1] * e2[2] - e1[2] * e2[1];
 		wt.norm[1] = e1[2] * e2[0] - e1[0] * e2[2];
 		wt.norm[2] = e1[0] * e2[1] - e1[1] * e2[0];
 
 		len = sqrtf(wt.norm[0] * wt.norm[0] +
 		    wt.norm[1] * wt.norm[1] +
 		    wt.norm[2] * wt.norm[2]);
 		if (len > 1e-6f) {
 			wt.norm[0] /= len;
 			wt.norm[1] /= len;
 			wt.norm[2] /= len;
 		} else {
 			wt.norm[0] = 0.0f;
 			wt.norm[1] = 1.0f;
 			wt.norm[2] = 0.0f;
 		}
 
 		min_x = fminf(wt.v0[0], fminf(wt.v1[0], wt.v2[0]));
 		max_x = fmaxf(wt.v0[0], fmaxf(wt.v1[0], wt.v2[0]));
 		min_z = fminf(wt.v0[2], fminf(wt.v1[2], wt.v2[2]));
 		max_z = fmaxf(wt.v0[2], fmaxf(wt.v1[2], wt.v2[2]));
 
 		gx0 = (int)((min_x - MAP_MIN) / ((MAP_MAX - MAP_MIN) / GRID_SZ));
 		gx1 = (int)((max_x - MAP_MIN) / ((MAP_MAX - MAP_MIN) / GRID_SZ));
 		gz0 = (int)((min_z - MAP_MIN) / ((MAP_MAX - MAP_MIN) / GRID_SZ));
 		gz1 = (int)((max_z - MAP_MIN) / ((MAP_MAX - MAP_MIN) / GRID_SZ));
 
 		if (gx0 < 0) gx0 = 0;
 		if (gx1 >= GRID_SZ) gx1 = GRID_SZ - 1;
 		if (gz0 < 0) gz0 = 0;
 		if (gz1 >= GRID_SZ) gz1 = GRID_SZ - 1;
 
 		for (gz = gz0; gz <= gz1; gz++) {
 			for (gx = gx0; gx <= gx1; gx++) {
 				c = &world_col_grid[gx][gz];
 				if (c->count >= c->capacity) {
 					c->capacity = c->capacity == 0 ? 64 : c->capacity * 2;
 					c->tris = realloc(c->tris, c->capacity * sizeof(struct col_triangle));
 				}
 				c->tris[c->count++] = wt;
 			}
 		}
 	}
 }
 
 static void
 bake_world_collision(void)
 {
 	FILE *f;
 	char line[512];
 	char name[NAME_SZ];
 	char *p;
 	struct mat4 rot, trans, sa2gl, world;
 	int in_inst, id, interior, lod, time_on, time_off;
 	float px, py, pz, qx, qy, qz, qw;
 
 	f = fopen("assets/map.ipl", "r");
 	if (!f) {
 		return;
 	}
 
 	in_inst = 0;
 	while (fgets(line, sizeof(line), f)) {
 		p = line;
 		while (*p == ' ' || *p == '\t') {
 			p++;
 		}
 		if (*p == '\0' || *p == '#') {
 			continue;
 		}
 		if (strncasecmp(p, "inst", 4) == 0 || strncasecmp(p, "tobj", 4) == 0) {
 			in_inst = 1;
 			continue;
 		}
 		if (strncasecmp(p, "end", 3) == 0) {
 			in_inst = 0;
 			continue;
 		}
 		if (in_inst) {
 			lod = -1;
 			time_on = 0;
 			time_off = 0;
 			if (sscanf(p, "%d, %23[^,], %d, %f, %f, %f, %f, %f, %f, %f, %d, %d, %d",
 			    &id, name, &interior, &px, &py, &pz, &qx, &qy, &qz, &qw,
 			    &lod, &time_on, &time_off) >= 10) {
 				trim_spaces(name);
 				to_lower_str(name);
 
 				mat_from_quat(&rot, qx, qy, qz, qw);
 				mat_translate(&trans, px, py, pz);
 				mat_mul(&world, &trans, &rot);
 
 				memset(&sa2gl, 0, sizeof(sa2gl));
 				sa2gl.m[0][0] = 1.0f;
 				sa2gl.m[1][2] = 1.0f;
 				sa2gl.m[2][1] = 1.0f;
 				sa2gl.m[3][3] = 1.0f;
 				mat_mul(&world, &sa2gl, &world);
 
 				instantiate_collision(name, &world);
 			}
 		}
 	}
 	fclose(f);
 }
 
 static void
 save_collision_bin(void)
 {
 	FILE *out;
 	uint32_t cnt;
 	int gx, gz;
 
 	out = fopen("assets/collision.bin", "wb");
 	if (!out) {
 		return;
 	}
 
 	for (gz = 0; gz < GRID_SZ; gz++) {
 		for (gx = 0; gx < GRID_SZ; gx++) {
 			cnt = world_col_grid[gx][gz].count;
 			fwrite(&cnt, sizeof(uint32_t), 1, out);
 			if (cnt > 0) {
 				fwrite(world_col_grid[gx][gz].tris,
 				    sizeof(struct col_triangle), cnt, out);
 			}
 		}
 	}
 	fclose(out);
 }
 
 static void
 process_timecyc(const char *root)
 {
 	FILE *f;
 	FILE *out;
 	char line[512];
 	struct timecyc_entry snaps[32 * 8];
 	int w_idx, s_idx, total_weathers;
 	char *p;
 
 	f = fopen_simple(root, "data/timecycp.dat");
 	if (!f) {
 		f = fopen_simple(root, "data/timecyc.dat");
 	}
 	if (!f) {
 		return;
 	}
 
 	out = fopen("assets/timecyc.bin", "wb");
 	if (!out) {
 		fclose(f);
 		return;
 	}
 
 	memset(snaps, 0, sizeof(snaps));
 	w_idx = 0;
 	s_idx = 0;
 	total_weathers = 0;
 
 	while (fgets(line, sizeof(line), f)) {
 		p = line;
 		while (*p == ' ' || *p == '\t') {
 			p++;
 		}
 		if (*p == '\0' || *p == '\n' || *p == '\r' ||
 		    strncmp(p, "//", 2) == 0) {
 			continue;
 		}
 
 		char *tok, *save;
 		char *tokens[64];
 		int t = 0;
 
 		tok = strtok_r(p, " \t\r\n", &save);
 		while (tok && t < 64) {
 			tokens[t++] = tok;
 			tok = strtok_r(NULL, " \t\r\n", &save);
 		}
 
 		if (t >= 40) {
 			struct timecyc_entry *e = &snaps[w_idx * 8 + s_idx];
 			e->amb[0] = atoi(tokens[3]);
 			e->amb[1] = atoi(tokens[4]);
 			e->amb[2] = atoi(tokens[5]);
 			e->dir[0] = atoi(tokens[6]);
 			e->dir[1] = atoi(tokens[7]);
 			e->dir[2] = atoi(tokens[8]);
 			e->sky_top[0] = atoi(tokens[9]);
 			e->sky_top[1] = atoi(tokens[10]);
 			e->sky_top[2] = atoi(tokens[11]);
 			e->sky_bot[0] = atoi(tokens[12]);
 			e->sky_bot[1] = atoi(tokens[13]);
 			e->sky_bot[2] = atoi(tokens[14]);
 			e->far_clp = strtof(tokens[27], NULL);
 			e->fog_st = strtof(tokens[28], NULL);
 			e->water[0] = atoi(tokens[36]);
 			e->water[1] = atoi(tokens[37]);
 			e->water[2] = atoi(tokens[38]);
 			e->water[3] = (t >= 40) ? atoi(tokens[39]) : 255;
 
 			s_idx++;
 			if (s_idx == 8) {
 				s_idx = 0;
 				w_idx++;
 				if (w_idx > total_weathers) {
 					total_weathers = w_idx;
 				}
 				if (w_idx >= 32) {
 					break;
 				}
 			}
 		}
 	}
 	fwrite(&total_weathers, sizeof(int), 1, out);
 	fwrite(snaps, sizeof(struct timecyc_entry), total_weathers * 8, out);
 	fclose(out);
 	fclose(f);
 }
 
 static void *
 build_worker(void *arg)
 {
 	struct thread_arg *ta;
 	uint32_t i;
 
 	ta = arg;
 	ta->arena.size = 128 * 1024 * 1024;
 	ta->arena.mem = malloc(ta->arena.size);
 
 	for (i = ta->start; i < ta->end; i++) {
 		char n[NAME_SZ + 1];
 		size_t j;
 		for (j = 0; j < sizeof(ta->entries[i].name) && ta->entries[i].name[j]; j++) {
 			n[j] = tolower((unsigned char)ta->entries[i].name[j]);
 		}
 		n[j] = '\0';
 
 		if (list_has(ta->fl, n)) {
 			uint32_t size = ta->entries[i].size * 2048;
 			const uint8_t *buf = ta->img_data + ta->entries[i].offset * 2048;
 			char *ext = strrchr(n, '.');
 			if (ext) {
 				*ext = '\0';
 			}
 
 			ta->arena.pos = 0;
 
 			if (strstr(ta->entries[i].name, ".dff") || strstr(ta->entries[i].name, ".DFF")) {
 				convert_dff(buf, size, n, &ta->arena);
 			} else if (strstr(ta->entries[i].name, ".txd") || strstr(ta->entries[i].name, ".TXD")) {
 				convert_txd(buf, size, n, &ta->arena);
 			}
 		}
 	}
 	free(ta->arena.mem);
 	return (NULL);
 }
 
 static void
 tar_add_file(FILE *tar, const char *path, const char *tar_name)
 {
 	FILE *src;
 	size_t sz, n, padding;
 	struct tar_header th;
 	unsigned int sum;
 	uint8_t *p;
 	char buf[4096];
 
 	src = fopen(path, "rb");
 	if (!src) {
 		return;
 	}
 
 	fseek(src, 0, SEEK_END);
 	sz = ftell(src);
 	fseek(src, 0, SEEK_SET);
 
 	memset(&th, 0, sizeof(th));
 	strncpy(th.name, tar_name, sizeof(th.name) - 1);
 	snprintf(th.mode, sizeof(th.mode), "%07o", 0644);
 	snprintf(th.size, sizeof(th.size), "%011lo", (unsigned long)sz);
 	snprintf(th.magic, sizeof(th.magic), "ustar");
 
 	/* Simple checksum calculation. */
 	memset(th.chksum, ' ', 8);
 	sum = 0;
 	p = (uint8_t *)&th;
 	for (size_t i = 0; i < sizeof(th); i++) {
 		sum += p[i];
 	}
 	snprintf(th.chksum, sizeof(th.chksum), "%06o", sum);
 
 	fwrite(&th, sizeof(th), 1, tar);
 
 	while ((n = fread(buf, 1, sizeof(buf), src)) > 0) {
 		fwrite(buf, 1, n, tar);
 	}
 	fclose(src);
 
 	padding = (512 - (sz % 512)) % 512;
 	if (padding > 0) {
 		char pad[512] = {0};
 		fwrite(pad, 1, padding, tar);
 	}
 }
 
 static void
 pack_directory(FILE *tar, const char *dir_path, const char *prefix)
 {
 	DIR *dir;
 	struct dirent *de;
 	char path[1024];
 	char tar_name[1024];
 	struct stat st;
 
 	dir = opendir(dir_path);
 	if (!dir) {
 		return;
 	}
 	while ((de = readdir(dir))) {
 		if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0) {
 			continue;
 		}
 		snprintf(path, sizeof(path), "%s/%s", dir_path, de->d_name);
 		snprintf(tar_name, sizeof(tar_name), "%s%s", prefix, de->d_name);
 
 		if (stat(path, &st) == 0) {
 			if (S_ISDIR(st.st_mode)) {
 				char new_prefix[1024];
 				snprintf(new_prefix, sizeof(new_prefix), "%s/", tar_name);
 				pack_directory(tar, path, new_prefix);
 			} else {
 				tar_add_file(tar, path, tar_name);
 			}
 		}
 	}
 	closedir(dir);
 }
 
 static void
 process_img_file(const char *root, const char *rel_path, struct file_list *fl, int num_threads, pthread_t *threads, struct thread_arg *args)
 {
 	char img_path[1024];
 	int img_fd;
 	struct stat st;
 	uint8_t *img_data;
 	struct img_header *hdr;
 	struct img_entry *entries;
 	uint32_t chunk;
 	int i;
 
 	if (!resolve_simple(root, rel_path, img_path, sizeof(img_path))) {
 		warnx("failed to resolve %s", rel_path);
 		return;
 	}
 
 	img_fd = open(img_path, O_RDONLY);
 	if (img_fd < 0) {
 		warn("failed to open %s", rel_path);
 		return;
 	}
 
 	if (fstat(img_fd, &st) < 0) {
 		close(img_fd);
 		return;
 	}
 
 	img_data = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, img_fd, 0);
 	if (img_data == MAP_FAILED) {
 		close(img_fd);
 		return;
 	}
 
 	hdr = (struct img_header *)img_data;
 	if (memcmp(hdr->magic, "VER2", 4) != 0) {
 		munmap(img_data, st.st_size);
 		close(img_fd);
 		return;
 	}
 	entries = (struct img_entry *)(img_data + sizeof(struct img_header));
 
 	printf("build: processing %s (%u entries)...\n", rel_path, hdr->entries);
 
 	chunk = hdr->entries / num_threads;
 	for (i = 0; i < num_threads; i++) {
 		args[i].img_data = img_data;
 		args[i].entries = entries;
 		args[i].start = i * chunk;
 		args[i].end = (i == num_threads - 1) ? hdr->entries : (i + 1) * chunk;
 		args[i].fl = fl;
 		pthread_create(&threads[i], NULL, build_worker, &args[i]);
 	}
 
 	for (i = 0; i < num_threads; i++) {
 		pthread_join(threads[i], NULL);
 	}
 
 	munmap(img_data, st.st_size);
 	close(img_fd);
 }
 
 int
 main(int argc, char *argv[])
 {
 	struct file_list fl;
 	struct arena shared_arena;
 	FILE *map_out;
 	char img_path[1024];
 	int img_fd;
 	struct stat st;
 	uint8_t *img_data;
 	struct img_header *hdr;
 	struct img_entry *entries;
 	struct file_list missing_fl;
 	int num_threads;
 	pthread_t *threads;
 	struct thread_arg *args;
 	FILE *tar;
 
 	if (argc < 2) {
 		return (1);
 	}
 
 	mkdir("assets", 0777);
 	mkdir("assets/models", 0777);
 	mkdir("assets/textures", 0777);
 
 	scan_existing_assets();
 	memset(&fl, 0, sizeof(fl));
 
 	map_out = fopen("assets/map.ipl", "w");
 	if (!map_out) {
 		err(1, "failed to create map.ipl");
 	}
 
 	process_gta_dat_ide(argv[1], "data/default.dat", &fl);
 	process_gta_dat_ide(argv[1], "data/gta.dat", &fl);
 
 	for (int i = 0; i < (int)(sizeof(special_actors) / sizeof(special_actors[0])); i++) {
 		char d_name[64], t_name[64];
 		snprintf(d_name, sizeof(d_name), "%s.dff", special_actors[i].model);
 		snprintf(t_name, sizeof(t_name), "%s.txd", special_actors[i].txd);
 		list_add(&fl, d_name);
 		list_add(&fl, t_name);
 	}
 
 	for (int i = 0; i < 313; i++) {
 		if (skin_names[i][0] != '\0') {
 			char d_name[64], t_name[64];
 			snprintf(d_name, sizeof(d_name), "%s.dff", skin_names[i]);
 			snprintf(t_name, sizeof(t_name), "%s.txd", skin_names[i]);
 			list_add(&fl, d_name);
 			list_add(&fl, t_name);
 		}
 	}
 
 	process_gta_dat_ipl(argv[1], "data/default.dat", map_out, &fl);
 	process_gta_dat_ipl(argv[1], "data/gta.dat", map_out, &fl);
 
 	if (!resolve_simple(argv[1], "models/gta3.img", img_path, sizeof(img_path))) {
 		errx(1, "failed to resolve gta3.img");
 	}
 
 	img_fd = open(img_path, O_RDONLY);
 	if (img_fd < 0) {
 		err(1, "failed to open gta3.img");
 	}
 
 	fstat(img_fd, &st);
 	img_data = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, img_fd, 0);
 	if (img_data == MAP_FAILED) {
 		err(1, "mmap failed");
 	}
 
 	hdr = (struct img_header *)img_data;
 	if (memcmp(hdr->magic, "VER2", 4) != 0) {
 		errx(1, "invalid img");
 	}
 	entries = (struct img_entry *)(img_data + sizeof(struct img_header));
 
 	for (uint32_t i = 0; i < hdr->entries; i++) {
 		char name_lower[NAME_SZ + 1];
 		size_t j;
 		for (j = 0; j < sizeof(entries[i].name) && entries[i].name[j]; j++) {
 			name_lower[j] = tolower((unsigned char)entries[i].name[j]);
 		}
 		name_lower[j] = '\0';
 
 		if (strstr(name_lower, ".ipl") != NULL) {
 			uint32_t size = entries[i].size * 2048;
 			const uint8_t *buf = img_data + entries[i].offset * 2048;
 			if (size >= 4 && memcmp(buf, "bnry", 4) == 0) {
 				parse_binary_ipl(buf, size, map_out, &fl);
 			} else {
 				parse_text_ipl((char *)buf, size, map_out, &fl);
 			}
 		}
 
 		if (strstr(name_lower, ".col") != NULL) {
 			uint32_t size = entries[i].size * 2048;
 			const uint8_t *buf = img_data + entries[i].offset * 2048;
 			parse_col_data(buf, size);
 		}
 	}
 	fclose(map_out);
 
 	memset(&missing_fl, 0, sizeof(missing_fl));
 	for (int i = 0; i < fl.count; i++) {
 		if (!asset_exists(fl.names[i])) {
 			list_add(&missing_fl, fl.names[i]);
 		}
 	}
 	printf("Total map files: %d, missing/rebuilding: %d\n", fl.count, missing_fl.count);
 	fl = missing_fl;
 
 	munmap(img_data, st.st_size);
 	close(img_fd);
 
 	shared_arena.size = 128 * 1024 * 1024;
 	shared_arena.mem = malloc(shared_arena.size);
 	process_particle_txd(argv[1], &shared_arena);
 	free(shared_arena.mem);
 
 	process_water(argv[1]);
 	process_timecyc(argv[1]);
 
 	num_threads = sysconf(_SC_NPROCESSORS_ONLN);
 	if (num_threads < 1) {
 		num_threads = 4;
 	}
 
 	threads = malloc(num_threads * sizeof(pthread_t));
 	args = malloc(num_threads * sizeof(struct thread_arg));
 
 	process_img_file(argv[1], "models/gta3.img", &fl, num_threads, threads, args);
 
 	process_img_file(argv[1], "models/gta_int.img", &fl, num_threads, threads, args);
 
 	process_img_file(argv[1], "models/cutscene.img", &fl, num_threads, threads, args);
 	process_gta_dat_col(argv[1], "data/default.dat");
 	process_gta_dat_col(argv[1], "data/gta.dat");
 	printf("Loaded %d collision models into memory\n", col_db_count);
 	bake_world_collision();
 	save_collision_bin();
 
 	free(threads);
 	free(args);
 
 	printf("Packing assets.tar...\n");
 	tar = fopen("assets.tar", "wb");
 	if (tar) {
 		pack_directory(tar, "assets", "assets/");
 		char empty[1024] = {0};
 		fwrite(empty, 1, sizeof(empty), tar);
 		fclose(tar);
 		system("rm -rf assets");
 	}
 
 	return (0);
 }