antizona

render.c (85385B)

---

 #include <arpa/inet.h>
 #include <netinet/in.h>
 #include <sys/ipc.h>
 #include <sys/mman.h>
 #include <sys/socket.h>
 #include <sys/shm.h>
 #include <sys/stat.h>
 
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include <X11/keysym.h>
 #include <X11/extensions/XShm.h>
 
 #include <ctype.h>
 #include <err.h>
 #include <fcntl.h>
 #include <locale.h>
 #include <math.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 #include <strings.h>
 #include <time.h>
 #include <unistd.h>
 
 #include "skins.h"
 #include "net.h"
 
 #define WIDTH			640
 #define HEIGHT			480
 #define MAX_CACHE		8192
 #define NAME_SZ			24
 #define MAX_DIST		250.0f
 #define GRID_SZ			64
 #define MAP_MIN			-3000.0f
 #define MAP_MAX			 3000.0f
 #define MAX_RENDER_TRIS		262144
 #define TAR_INDEX_SIZE		32768
 #define CHAT_LINES		6
 
 #define GRAVITY			9.81f
 #define TERMINAL_VEL		50.0f
 #define JUMP_FORCE		6.2f
 #define STEP_SNAP_DOWN		0.40f
 
 #define MIN(a, b) ((a) < (b) ? (a) : (b))
 #define MAX(a, b) ((a) > (b) ? (a) : (b))
 
 struct vec3 { float x, y, z; };
 struct mat4 { float m[4][4]; };
 
 struct col_triangle {
 	float		v0[3];
 	float		v1[3];
 	float		v2[3];
 	float		norm[3];
 	uint8_t		surface;
 };
 
 struct col_cell {
 	const struct col_triangle	*tris;
 	uint32_t			 count;
 };
 
 struct chat_entry {
 	char	text[160];
 	float	timer;
 };
 
 struct timecyc_entry {
 	uint8_t	amb[3], dir[3], sky_top[3], sky_bot[3], water[4];
 	float	far_clp, fog_st;
 };
 
 struct sys_gfx {
 	Display			*dpy;
 	Window			 win;
 	GC			 gc;
 	XImage			*img;
 	XShmSegmentInfo		 shm;
 	uint32_t		*pixels;
 	float			*zbuffer;
 	Atom			 wm_delete;
 	struct mat4		 proj;
 	char			 keys[512];
 	float			 game_time_sec, game_time_hours;
 	struct timecyc_entry	 weathers[32][8], cur_weather;
 	int			 num_weathers, game_weather;
 	float			 far_clip_override;
 	int			 in_chat, chat_len;
 	char			 chat_buf[128];
 	int			 menu_open;
 	int			 show_debug;
 	float			 fps;
 	uint32_t		 pkts_in, pkts_out;
 	uint32_t		 pkts_in_sec, pkts_out_sec;
 	float			 stats_timer;
 	KeyCode			 key_w, key_a, key_s, key_d, key_t,
 	    key_esc, key_space, key_up, key_down, key_left, key_right;
 	XIC			 ic;
 	XFontSet		 font_set;
 };
 
 struct vertex { float x, y, z, w, u, v, r, g, b, a, f; };
 struct clip_vertex { float x, y, z, w, u, v, r, g, b, a, f; };
 
 struct texture {
 	uint32_t	*pixels;
 	int		 w, h, has_alpha;
 	uint32_t	*mips[4];
 	int		 mip_w[4];
 	int		 mip_h[4];
 };
 
 struct render_triangle {
 	struct vertex		v0, v1, v2;
 	const struct texture	*tex;
 	int			is_water, mip;
 };
 
 struct ply_vertex {
 	float x, y, z;
 	float s, t;
 	uint8_t r, g, b, a;
 };
 
 struct mesh {
 	struct ply_vertex	*ply_verts;
 	uint16_t		*indices, *mat_ids;
 	uint32_t		 num_verts, num_tris, num_materials;
 	char			(*raw_tex_names)[32];
 	struct texture		**textures;
 	float			 spr_x, spr_y, spr_z, spr_r, total_area;
 };
 
 struct net_snap {
 	float	x, y, z;
 	float	yaw;
 	double	time;
 };
 
 struct net_player {
 	uint8_t		id;
 	uint16_t	skin;
 	float		cur_x, cur_y, cur_z;
 	float		cur_yaw;
 	struct net_snap	snaps[4];
 	int		snap_count;
 	int		active;
 };
 
 struct transform_array {
 	float			*pos_x, *pos_y, *pos_z;
 	float			*rot_qx, *rot_qy, *rot_qz, *rot_qw;
 	struct mat4		*world_matrices;
 	float			*sphere_cx, *sphere_cy, *sphere_cz, *sphere_r;
 	int16_t			*time_on, *time_off;
 	int			 count;
 };
 
 struct grid_cell { int *ids, count, cap; };
 
 struct asset_cache {
 	struct mesh	 meshes[MAX_CACHE];
 	struct texture	 textures[MAX_CACHE];
 	char		 mesh_names[MAX_CACHE][NAME_SZ], tex_names[MAX_CACHE][32];
 	int		 mesh_count, tex_count, mesh_hash[MAX_CACHE * 2], tex_hash[MAX_CACHE * 2];
 };
 
 struct draw_item { int id; float dist_sq; };
 struct water_face {
 	float	x[4], y[4], z[4];
 	float	u[4], v[4], h[4]; 
 	int num;
 };
 
 static pthread_barrier_t	barrier_start;
 static pthread_barrier_t	barrier_end;
 
 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));
 
 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_index_entry {
 	char			name[128];
 	const uint8_t		*data;
 	size_t			size;
 };
 
 static struct col_cell		 g_col_grid[GRID_SZ][GRID_SZ];
 static struct sys_gfx		*g_sys;
 static struct transform_array	 g_transforms;
 static struct mesh		**scene_meshes = NULL;
 static int			 scene_inst_count = 0, scene_inst_capacity = 0;
 static struct grid_cell		 scene_grid[GRID_SZ][GRID_SZ];
 static struct draw_item		*draw_list = NULL;
 static int			 draw_cap = 0, draw_count = 0;
 static struct render_triangle	 render_list[MAX_RENDER_TRIS];
 static int			 render_count = 0;
 static struct water_face	*water_faces = NULL;
 static uint32_t			 water_count = 0;
 static struct texture		*water_tex = NULL, *sand_tex = NULL;
 static pthread_t		*workers = NULL;
 static int			 num_threads = 1, threads_running = 1;
 static struct clip_vertex	*v_scratch = NULL;
 static size_t			 v_scratch_cap = 0;
 
 static uint8_t			*g_tar_mapped = NULL;
 static size_t			 g_tar_size = 0;
 static struct tar_index_entry	 tar_idx[TAR_INDEX_SIZE];
 static struct asset_cache	*g_cache = NULL;
 static int			 active_skin_id = 7;
 
 static int			net_fd = -1;
 static struct sockaddr_in	srv_addr;
 static int			my_player_id = -1;
 static int			net_connected = 0;
 static struct net_player	net_players[MAX_PLAYERS];
 
 static struct chat_entry	chat_log[CHAT_LINES];
 static int			chat_log_count = 0;
 static char			local_nick[24];
 
 static size_t
 get_tar_size(const char *octal)
 {
 	size_t size = 0;
 	int i;
 
 	for (i = 0; i < 11; i++) {
 		if (octal[i] < '0' || octal[i] > '7') {
 			break;
 		}
 		size = size * 8 + (octal[i] - '0');
 	}
 	return (size);
 }
 
 static uint32_t
 tar_hash(const char *str)
 {
 	uint32_t hash = 5381;
 	int c;
 
 	while ((c = (unsigned char)*str++)) {
 		hash = ((hash << 5) + hash) + tolower(c);
 	}
 	return (hash);
 }
 
 static void
 tar_build_index(void)
 {
 	size_t offset = 0;
 	struct tar_header *h;
 	size_t file_sz;
 	uint32_t slot;
 
 	memset(tar_idx, 0, sizeof(tar_idx));
 
 	while (offset < g_tar_size) {
 		h = (struct tar_header *)(g_tar_mapped + offset);
 		if (h->name[0] == '\0') {
 			break;
 		}
 		file_sz = get_tar_size(h->size);
 		const uint8_t *file_data = g_tar_mapped + offset + 512;
 
 		slot = tar_hash(h->name) % TAR_INDEX_SIZE;
 		while (tar_idx[slot].data != NULL) {
 			if (strcasecmp(tar_idx[slot].name, h->name) == 0) {
 				goto next_file;
 			}
 			slot = (slot + 1) % TAR_INDEX_SIZE;
 		}
 
 		strncpy(tar_idx[slot].name, h->name, sizeof(tar_idx[slot].name) - 1);
 		tar_idx[slot].data = file_data;
 		tar_idx[slot].size = file_sz;
 
 	next_file:
 		offset += 512 + ((file_sz + 511) & ~511);
 	}
 }
 
 static const uint8_t *
 tar_lookup(const char *filename, size_t *out_size)
 {
 	uint32_t slot;
 
 	slot = tar_hash(filename) % TAR_INDEX_SIZE;
 	while (tar_idx[slot].data != NULL) {
 		if (strcasecmp(tar_idx[slot].name, filename) == 0) {
 			*out_size = tar_idx[slot].size;
 			return (tar_idx[slot].data);
 		}
 		slot = (slot + 1) % TAR_INDEX_SIZE;
 	}
 	return (NULL);
 }
 
 static inline float
 edge_func(float ax, float ay, float bx, float by, float cx, float cy)
 {
 	return ((cx - ax) * (by - ay) - (cy - ay) * (bx - ax));
 }
 
 static void
 closest_point_triangle(const float p[3], const float a[3], const float b[3], const float c[3], float out[3])
 {
 	float ab[3], ac[3], ap[3], bp[3], cp[3];
 	float d1, d2, d3, d4, d5, d6;
 	float vc, vb, va, denom, v, w, u;
 
 	ab[0] = b[0] - a[0];
 	ab[1] = b[1] - a[1];
 	ab[2] = b[2] - a[2];
 
 	ac[0] = c[0] - a[0];
 	ac[1] = c[1] - a[1];
 	ac[2] = c[2] - a[2];
 
 	ap[0] = p[0] - a[0];
 	ap[1] = p[1] - a[1];
 	ap[2] = p[2] - a[2];
 
 	d1 = ab[0] * ap[0] + ab[1] * ap[1] + ab[2] * ap[2];
 	d2 = ac[0] * ap[0] + ac[1] * ap[1] + ac[2] * ap[2];
 	if (d1 <= 0.0f && d2 <= 0.0f) {
 		out[0] = a[0];
 		out[1] = a[1];
 		out[2] = a[2];
 		return;
 	}
 
 	bp[0] = p[0] - b[0];
 	bp[1] = p[1] - b[1];
 	bp[2] = p[2] - b[2];
 
 	d3 = ab[0] * bp[0] + ab[1] * bp[1] + ab[2] * bp[2];
 	d4 = ac[0] * bp[0] + ac[1] * bp[1] + ac[2] * bp[2];
 	if (d3 >= 0.0f && d4 <= d3) {
 		out[0] = b[0];
 		out[1] = b[1];
 		out[2] = b[2];
 		return;
 	}
 
 	vc = d1 * d4 - d3 * d2;
 	if (vc <= 0.0f && d1 >= 0.0f && d3 <= 0.0f) {
 		v = d1 / (d1 - d3);
 		out[0] = a[0] + v * ab[0];
 		out[1] = a[1] + v * ab[1];
 		out[2] = a[2] + v * ab[2];
 		return;
 	}
 
 	cp[0] = p[0] - c[0];
 	cp[1] = p[1] - c[1];
 	cp[2] = p[2] - c[2];
 
 	d5 = ab[0] * cp[0] + ab[1] * cp[1] + ab[2] * cp[2];
 	d6 = ac[0] * cp[0] + ac[1] * cp[1] + ac[2] * cp[2];
 	if (d6 >= 0.0f && d5 <= d6) {
 		out[0] = c[0];
 		out[1] = c[1];
 		out[2] = c[2];
 		return;
 	}
 
 	vb = d5 * d2 - d1 * d6;
 	if (vb <= 0.0f && d2 >= 0.0f && d6 <= 0.0f) {
 		w = d2 / (d2 - d6);
 		out[0] = a[0] + w * ac[0];
 		out[1] = a[1] + w * ac[1];
 		out[2] = a[2] + w * ac[2];
 		return;
 	}
 
 	va = d3 * d6 - d5 * d4;
 	if (va <= 0.0f && (d4 - d3) >= 0.0f && (d5 - d6) >= 0.0f) {
 		w = (d4 - d3) / ((d4 - d3) + (d5 - d6));
 		out[0] = b[0] + w * (c[0] - b[0]);
 		out[1] = b[1] + w * (c[1] - b[1]);
 		out[2] = b[2] + w * (c[2] - b[2]);
 		return;
 	}
 
 	denom = 1.0f / (va + vb + vc);
 	v = vb * denom;
 	w = vc * denom;
 	u = 1.0f - v - w;
 	out[0] = u * a[0] + v * b[0] + w * c[0];
 	out[1] = u * a[1] + v * b[1] + w * c[1];
 	out[2] = u * a[2] + v * b[2] + w * c[2];
 }
 
 static void
 draw_triangle_band(const struct render_triangle *tri, int min_y_band, int max_y_band)
 {
 	struct vertex v0, v1, v2, sv0, sv1, sv2, tmp;
 	const struct texture *tex;
 	const uint32_t *pixels;
 	float area, inv_area, dy12, dy20, dx12, dx20, dy01;
 	float p_x_start, p_y_start, w0_start, w1_start;
 	float dw0_dx, dw0_dy, dw1_dx, dw1_dy;
 	float u0_w, u1_w, u2_w, v0_w, v1_w, v2_w, f0_w, f1_w, f2_w;
 	float d_inv_w_dx, d_u_w_dx, d_v_w_dx, d_f_w_dx, d_r_dx, d_g_dx, d_b_dx;
 	float d_r_dx_255, d_g_dx_255, d_b_dx_255;
 	float inv_slope_long, inv_slope_short1, inv_slope_short2;
 	float row_y, x_long, x_short, x_min, x_max;
 	float dx, dy, row_w0, row_w1, row_w2;
 	float inv_w, u_w, v_w, f_w, r, g_val, b, wf, f, inv_f, min_inv_w;
 	uint32_t sky_r, sky_g, sky_b, color, bg, tex_r, tex_g, tex_b;
 	uint8_t tex_a, wa_tc, wr, wg, wb, wa;
 	int min_x, max_x, min_y, max_y, row_min_x, row_max_x;
 	int tw, th, tw_mask, th_mask, py, px, idx, ir, ig, ib, tx, ty, m;
 
 	v0 = tri->v0;
 	v1 = tri->v1;
 	v2 = tri->v2;
 
 	min_y = (int)floorf(MIN(v0.y, MIN(v1.y, v2.y)));
 	max_y = (int)ceilf(MAX(v0.y, MAX(v1.y, v2.y)));
 	if (max_y < min_y_band || min_y > max_y_band) {
 		return;
 	}
 
 	min_x = (int)floorf(MIN(v0.x, MIN(v1.x, v2.x)));
 	max_x = (int)ceilf(MAX(v0.x, MAX(v1.x, v2.x)));
 	if (min_x >= WIDTH || max_x < 0) {
 		return;
 	}
 
 	min_inv_w = MIN(v0.w, MIN(v1.w, v2.w));
 	if (min_inv_w < 0.0001f) {
 		min_inv_w = 0.0001f;
 	}
 
 	area = edge_func(v0.x, v0.y, v1.x, v1.y, v2.x, v2.y);
 	if (fabsf(area) < 1e-5f) {
 		return;
 	}
 	inv_area = 1.0f / area;
 
 	dy12 = v2.y - v1.y;
 	dy20 = v0.y - v2.y;
 	dx12 = v2.x - v1.x;
 	dx20 = v0.x - v2.x;
 	dy01 = v1.y - v0.y;
 
 	if (min_x < 0) min_x = 0;
 	if (max_x >= WIDTH) max_x = WIDTH - 1;
 	if (min_y < min_y_band) min_y = min_y_band;
 	if (max_y > max_y_band) max_y = max_y_band;
 	if (min_y > max_y || min_x > max_x) {
 		return;
 	}
 
 	p_x_start = min_x + 0.5f;
 	p_y_start = min_y + 0.5f;
 	w0_start = ((p_x_start - v1.x) * dy12 - (p_y_start - v1.y) * dx12) * inv_area;
 	w1_start = ((p_x_start - v2.x) * dy20 - (p_y_start - v2.y) * dx20) * inv_area;
 
 	dw0_dx = dy12 * inv_area;
 	dw0_dy = -dx12 * inv_area;
 	dw1_dx = dy20 * inv_area;
 	dw1_dy = -dx20 * inv_area;
 
 	u0_w = v0.u * v0.w; u1_w = v1.u * v1.w; u2_w = v2.u * v2.w;
 	v0_w = v0.v * v0.w; v1_w = v1.v * v1.w; v2_w = v2.v * v2.w;
 	f0_w = v0.f * v0.w; f1_w = v1.f * v1.w; f2_w = v2.f * v2.w;
 
 	d_inv_w_dx = (dy12 * v0.w + dy20 * v1.w + dy01 * v2.w) * inv_area;
 	d_u_w_dx   = (dy12 * u0_w + dy20 * u1_w + dy01 * u2_w) * inv_area;
 	d_v_w_dx   = (dy12 * v0_w + dy20 * v1_w + dy01 * v2_w) * inv_area;
 	d_f_w_dx   = (dy12 * f0_w + dy20 * f1_w + dy01 * f2_w) * inv_area;
 	d_r_dx     = (dy12 * v0.r + dy20 * v1.r + dy01 * v2.r) * inv_area;
 	d_g_dx     = (dy12 * v0.g + dy20 * v1.g + dy01 * v2.g) * inv_area;
 	d_b_dx     = (dy12 * v0.b + dy20 * v1.b + dy01 * v2.b) * inv_area;
 
 	d_r_dx_255 = d_r_dx * 255.0f;
 	d_g_dx_255 = d_g_dx * 255.0f;
 	d_b_dx_255 = d_b_dx * 255.0f;
 
 	sky_r = g_sys->cur_weather.sky_bot[0];
 	sky_g = g_sys->cur_weather.sky_bot[1];
 	sky_b = g_sys->cur_weather.sky_bot[2];
 
 	sv0 = v0; sv1 = v1; sv2 = v2;
 	if (sv0.y > sv1.y) { tmp = sv0; sv0 = sv1; sv1 = tmp; }
 	if (sv0.y > sv2.y) { tmp = sv0; sv0 = sv2; sv2 = tmp; }
 	if (sv1.y > sv2.y) { tmp = sv1; sv1 = sv2; sv2 = tmp; }
 
 	inv_slope_long = (sv2.y != sv0.y) ? (sv2.x - sv0.x) / (sv2.y - sv0.y) : 0.0f;
 	inv_slope_short1 = (sv1.y != sv0.y) ? (sv1.x - sv0.x) / (sv1.y - sv0.y) : 0.0f;
 	inv_slope_short2 = (sv2.y != sv1.y) ? (sv2.x - sv1.x) / (sv2.y - sv1.y) : 0.0f;
 
 	if (tri->tex && (uintptr_t)tri->tex != (uintptr_t)-1 && !tri->is_water) {
 		tex = tri->tex;
 		m = tri->mip;
 		if (m < 0) m = 0;
 		if (m > 3) m = 3;
 		pixels = tex->mips[m];
 		tw = tex->mip_w[m];
 		th = tex->mip_h[m];
 		tw_mask = tw - 1;
 		th_mask = th - 1;
 
 		for (py = min_y; py <= max_y; py++) {
 			row_y = (float)py + 0.5f;
 			x_long = sv0.x + (row_y - sv0.y) * inv_slope_long;
 			x_short = (row_y < sv1.y) ?
 			    sv0.x + (row_y - sv0.y) * inv_slope_short1 :
 			    sv1.x + (row_y - sv1.y) * inv_slope_short2;
 
 			x_min = (x_long < x_short) ? x_long : x_short;
 			x_max = (x_long < x_short) ? x_short : x_long;
 
 			row_min_x = (int)floorf(x_min);
 			row_max_x = (int)ceilf(x_max);
 
 			if (row_min_x < min_x) row_min_x = min_x;
 			if (row_max_x > max_x) row_max_x = max_x;
 			if (row_min_x > row_max_x) continue;
 
 			dx = (row_min_x + 0.5f) - p_x_start;
 			dy = row_y - p_y_start;
 			row_w0 = w0_start + dw0_dx * dx + dw0_dy * dy;
 			row_w1 = w1_start + dw1_dx * dx + dw1_dy * dy;
 			row_w2 = 1.0f - row_w0 - row_w1;
 
 			inv_w = row_w0 * v0.w + row_w1 * v1.w + row_w2 * v2.w;
 			u_w = row_w0 * u0_w + row_w1 * u1_w + row_w2 * u2_w;
 			v_w = row_w0 * v0_w + row_w1 * v1_w + row_w2 * v2_w;
 			f_w = row_w0 * f0_w + row_w1 * f1_w + row_w2 * f2_w;
 			r = (row_w0 * v0.r + row_w1 * v1.r + row_w2 * v2.r) * 255.0f;
 			g_val = (row_w0 * v0.g + row_w1 * v1.g + row_w2 * v2.g) * 255.0f;
 			b = (row_w0 * v0.b + row_w1 * v1.b + row_w2 * v2.b) * 255.0f;
 
 			for (px = row_min_x; px <= row_max_x; px++) {
 				if (row_w0 >= -1e-4f && row_w1 >= -1e-4f && row_w2 >= -1e-4f) {
 					idx = py * WIDTH + px;
 					if (inv_w >= g_sys->zbuffer[idx] - 1e-6f && inv_w >= min_inv_w * 0.99f) {
 						wf = 1.0f / inv_w;
 						tx = (int)(u_w * wf * tw) & tw_mask;
 						ty = (int)(v_w * wf * th) & th_mask;
 						color = pixels[ty * tw + tx];
 						tex_a = (color >> 24) & 0xFF;
 						if (tex_a > 127) {
 							ir = (int)r; if (ir > 255) ir = 255; else if (ir < 0) ir = 0;
 							ig = (int)g_val; if (ig > 255) ig = 255; else if (ig < 0) ig = 0;
 							ib = (int)b; if (ib > 255) ib = 255; else if (ib < 0) ib = 0;
 
 							tex_r = ((color >> 16) & 0xFF) * ir >> 8;
 							tex_g = ((color >> 8) & 0xFF) * ig >> 8;
 							tex_b = (color & 0xFF) * ib >> 8;
 
 							f = f_w * wf;
 							if (f > 0.001f) {
 								if (f > 1.0f) f = 1.0f;
 								inv_f = 1.0f - f;
 								tex_r = (uint32_t)(tex_r * inv_f + sky_r * f);
 								tex_g = (uint32_t)(tex_g * inv_f + sky_g * f);
 								tex_b = (uint32_t)(tex_b * inv_f + sky_b * f);
 							}
 
 							g_sys->pixels[idx] = (tex_a << 24) |
 							    (tex_r << 16) | (tex_g << 8) | tex_b;
 							g_sys->zbuffer[idx] = inv_w;
 						}
 					}
 				}
 				row_w0 += dw0_dx; row_w1 += dw1_dx; row_w2 -= (dw0_dx + dw1_dx);
 				inv_w += d_inv_w_dx; u_w += d_u_w_dx; v_w += d_v_w_dx; f_w += d_f_w_dx;
 				r += d_r_dx_255; g_val += d_g_dx_255; b += d_b_dx_255;
 			}
 		}
 	} else if (tri->is_water && tri->tex && (uintptr_t)tri->tex != (uintptr_t)-1) {
 		tex = tri->tex;
 		pixels = tex->pixels;
 		tw = tex->w;
 		th = tex->h;
 		tw_mask = tw - 1;
 		th_mask = th - 1;
 		wa_tc = g_sys->cur_weather.water[3];
 		wr = g_sys->cur_weather.water[0];
 		wg = g_sys->cur_weather.water[1];
 		wb = g_sys->cur_weather.water[2];
 
 		for (py = min_y; py <= max_y; py++) {
 			row_y = (float)py + 0.5f;
 			x_long = sv0.x + (row_y - sv0.y) * inv_slope_long;
 			x_short = (row_y < sv1.y) ?
 			    sv0.x + (row_y - sv0.y) * inv_slope_short1 :
 			    sv1.x + (row_y - sv1.y) * inv_slope_short2;
 
 			x_min = (x_long < x_short) ? x_long : x_short;
 			x_max = (x_long < x_short) ? x_short : x_long;
 
 			row_min_x = (int)floorf(x_min);
 			row_max_x = (int)ceilf(x_max);
 
 			if (row_min_x < min_x) row_min_x = min_x;
 			if (row_max_x > max_x) row_max_x = max_x;
 			if (row_min_x > row_max_x) continue;
 
 			dx = (row_min_x + 0.5f) - p_x_start;
 			dy = row_y - p_y_start;
 			row_w0 = w0_start + dw0_dx * dx + dw0_dy * dy;
 			row_w1 = w1_start + dw1_dx * dx + dw1_dy * dy;
 			row_w2 = 1.0f - row_w0 - row_w1;
 
 			inv_w = row_w0 * v0.w + row_w1 * v1.w + row_w2 * v2.w;
 			u_w = row_w0 * u0_w + row_w1 * u1_w + row_w2 * u2_w;
 			v_w = row_w0 * v0_w + row_w1 * v1_w + row_w2 * v2_w;
 			f_w = row_w0 * f0_w + row_w1 * f1_w + row_w2 * f2_w;
 			r = (row_w0 * v0.r + row_w1 * v1.r + row_w2 * v2.r) * 255.0f;
 			g_val = (row_w0 * v0.g + row_w1 * v1.g + row_w2 * v2.g) * 255.0f;
 			b = (row_w0 * v0.b + row_w1 * v1.b + row_w2 * v2.b) * 255.0f;
 
 			for (px = row_min_x; px <= row_max_x; px++) {
 				if (row_w0 >= -1e-4f && row_w1 >= -1e-4f && row_w2 >= -1e-4f) {
 					idx = py * WIDTH + px;
 					if (inv_w >= g_sys->zbuffer[idx] - 1e-6f && inv_w >= min_inv_w * 0.99f) {
 						ir = (int)r; if (ir > 255) ir = 255; else if (ir < 0) ir = 0;
 						ig = (int)g_val; if (ig > 255) ig = 255; else if (ig < 0) ig = 0;
 						ib = (int)b; if (ib > 255) ib = 255; else if (ib < 0) ib = 0;
 						wf = 1.0f / inv_w;
 
 						tx = (int)(u_w * wf * tw) & tw_mask;
 						ty = (int)(v_w * wf * th) & th_mask;
 						color = pixels[ty * tw + tx];
 
 						wa = (wa_tc * ((color >> 24) & 0xFF)) >> 8;
 						tex_r = ((((color >> 16) & 0xFF) * ir >> 8) * wr) >> 8;
 						tex_g = ((((color >> 8) & 0xFF) * ig >> 8) * wg) >> 8;
 						tex_b = ((color & 0xFF) * ib >> 8) * wb >> 8;
 
 						f = f_w * wf;
 						if (f > 0.001f) {
 							if (f > 1.0f) f = 1.0f;
 							inv_f = 1.0f - f;
 							tex_r = (uint32_t)(tex_r * inv_f + sky_r * f);
 							tex_g = (uint32_t)(tex_g * inv_f + sky_g * f);
 							tex_b = (uint32_t)(tex_b * inv_f + sky_b * f);
 						}
 
 						bg = g_sys->pixels[idx];
 						g_sys->pixels[idx] = (0xFF << 24) |
 						    (((tex_r * wa + ((bg >> 16) & 0xFF) * (255 - wa)) >> 8) << 16) |
 						    (((tex_g * wa + ((bg >> 8) & 0xFF) * (255 - wa)) >> 8) << 8) |
 						    ((tex_b * wa + (bg & 0xFF) * (255 - wa)) >> 8);
 					}
 				}
 				row_w0 += dw0_dx; row_w1 += dw1_dx; row_w2 -= (dw0_dx + dw1_dx);
 				inv_w += d_inv_w_dx; u_w += d_u_w_dx; v_w += d_v_w_dx; f_w += d_f_w_dx;
 				r += d_r_dx_255; g_val += d_g_dx_255; b += d_b_dx_255;
 			}
 		}
 	}
 }
 
 static void *
 render_worker(void *arg)
 {
 	int id, start_y, end_y, i;
 
 	id = (int)(intptr_t)arg;
 	start_y = id * HEIGHT / num_threads;
 	end_y = (id == num_threads - 1) ? HEIGHT - 1 : (id + 1) * HEIGHT / num_threads - 1;
 
 	while (1) {
 		pthread_barrier_wait(&barrier_start);
 		if (!threads_running) {
 			break;
 		}
 		for (i = 0; i < render_count; i++) {
 			draw_triangle_band(&render_list[i], start_y, end_y);
 		}
 		pthread_barrier_wait(&barrier_end);
 	}
 	return (NULL);
 }
 
 static void
 chat_add_message(const char *name, const char *msg)
 {
 	int i;
 
 	if (chat_log_count < CHAT_LINES) {
 		snprintf(chat_log[chat_log_count].text,
 		    sizeof(chat_log[chat_log_count].text), "[%s]: %s", name, msg);
 		chat_log[chat_log_count].timer = 8.0f;
 		chat_log_count++;
 	} else {
 		for (i = 0; i < CHAT_LINES - 1; i++) {
 			chat_log[i] = chat_log[i + 1];
 		}
 		snprintf(chat_log[CHAT_LINES - 1].text,
 		    sizeof(chat_log[CHAT_LINES - 1].text), "[%s]: %s", name, msg);
 		chat_log[CHAT_LINES - 1].timer = 8.0f;
 	}
 }
 
 static void
 net_init(const char *ip, int port, const char *nick)
 {
 	struct pkt_join pj;
 
 	strncpy(local_nick, nick, sizeof(local_nick) - 1);
 	local_nick[sizeof(local_nick) - 1] = '\0';
 
 	net_fd = socket(AF_INET, SOCK_DGRAM, 0);
 	if (net_fd < 0) {
 		return;
 	}
 	fcntl(net_fd, F_SETFL, O_NONBLOCK);
 
 	memset(&srv_addr, 0, sizeof(srv_addr));
 	srv_addr.sin_family = AF_INET;
 	srv_addr.sin_port = htons(port);
 	inet_pton(AF_INET, ip, &srv_addr.sin_addr);
 
 	memset(&pj, 0, sizeof(pj));
 	pj.hdr.magic = NET_MAGIC;
 	pj.hdr.type = PKT_JOIN;
 	pj.hdr.player_id = 0;
 	strncpy(pj.name, local_nick, sizeof(pj.name) - 1);
 	pj.skin = (uint16_t)active_skin_id;
 
 	sendto(net_fd, &pj, sizeof(pj), 0,
 	    (struct sockaddr *)&srv_addr, sizeof(srv_addr));
 }
 
 static void
 net_send_sync(float px, float py, float pz, float pyaw)
 {
 	struct pkt_sync ps;
 
 	if (net_fd < 0 || !net_connected) {
 		return;
 	}
 	memset(&ps, 0, sizeof(ps));
 	ps.hdr.magic = NET_MAGIC;
 	ps.hdr.type = PKT_SYNC;
 	ps.hdr.player_id = (uint8_t)my_player_id;
 	ps.x = px;
 	ps.y = py;
 	ps.z = pz;
 	ps.yaw = pyaw;
 	ps.skin = (uint16_t)active_skin_id;
 
 	sendto(net_fd, &ps, sizeof(ps), 0,
 	    (struct sockaddr *)&srv_addr, sizeof(srv_addr));
 	if (g_sys) {
 		g_sys->pkts_out++;
 	}
 }
 
 static void
 net_send_chat(const char *msg)
 {
 	struct pkt_chat pc;
 
 	if (net_fd < 0 || !net_connected) {
 		return;
 	}
 	memset(&pc, 0, sizeof(pc));
 	pc.hdr.magic = NET_MAGIC;
 	pc.hdr.type = PKT_CHAT;
 	pc.hdr.player_id = (uint8_t)my_player_id;
 	strncpy(pc.name, local_nick, sizeof(pc.name) - 1);
 	strncpy(pc.msg, msg, sizeof(pc.msg) - 1);
 
 	sendto(net_fd, &pc, sizeof(pc), 0,
 	    (struct sockaddr *)&srv_addr, sizeof(srv_addr));
 	if (g_sys) {
 		g_sys->pkts_out++;
 	}
 }
 
 static void
 net_player_add_snap(struct net_player *np, float x, float y, float z, float yaw, double now)
 {
 	int i;
 
 	if (np->snap_count < 4) {
 		np->snaps[np->snap_count].x = x;
 		np->snaps[np->snap_count].y = y;
 		np->snaps[np->snap_count].z = z;
 		np->snaps[np->snap_count].yaw = yaw;
 		np->snaps[np->snap_count].time = now;
 		np->snap_count++;
 	} else {
 		for (i = 0; i < 3; i++) {
 			np->snaps[i] = np->snaps[i + 1];
 		}
 		np->snaps[3].x = x;
 		np->snaps[3].y = y;
 		np->snaps[3].z = z;
 		np->snaps[3].yaw = yaw;
 		np->snaps[3].time = now;
 	}
 }
 
 static void
 net_poll(struct sys_gfx *g, double now)
 {
 	uint8_t buf[2048];
 	ssize_t n;
 	const struct pkt_header *hdr;
 	const struct pkt_join_ack *ack;
 	const struct pkt_world_state *ws;
 	const struct pkt_chat *pc;
 	int i, id, seen[MAX_PLAYERS];
 
 	if (net_fd < 0) {
 		return;
 	}
 
 	while ((n = recvfrom(net_fd, buf, sizeof(buf), 0, NULL, NULL)) > 0) {
 		g->pkts_in++;
 		if (n < (ssize_t)sizeof(struct pkt_header)) {
 			continue;
 		}
 		hdr = (const struct pkt_header *)buf;
 		if (hdr->magic != NET_MAGIC) {
 			continue;
 		}
 
 		if (hdr->type == PKT_JOIN_ACK) {
 			if (n >= (ssize_t)sizeof(struct pkt_join_ack)) {
 				ack = (const struct pkt_join_ack *)buf;
 				my_player_id = ack->your_id;
 				net_connected = 1;
 				g->game_weather = ack->game_weather;
 				g->game_time_hours = ack->game_time;
 			}
 		} else if (hdr->type == PKT_WORLD_STATE) {
 			if (n >= (ssize_t)(sizeof(struct pkt_header) + 1)) {
 				ws = (const struct pkt_world_state *)buf;
 				memset(seen, 0, sizeof(seen));
 				for (i = 0; i < ws->player_count && i < MAX_PLAYERS; i++) {
 					id = ws->players[i].id;
 					if (id >= MAX_PLAYERS) {
 						continue;
 					}
 					seen[id] = 1;
 					if (!net_players[id].active) {
 						net_players[id].id = id;
 						net_players[id].skin = ws->players[i].skin;
 						net_players[id].cur_x = ws->players[i].x;
 						net_players[id].cur_y = ws->players[i].y;
 						net_players[id].cur_z = ws->players[i].z;
 						net_players[id].cur_yaw = ws->players[i].yaw;
 						net_players[id].snap_count = 0;
 						net_players[id].active = 1;
 					}
 					net_players[id].skin = ws->players[i].skin;
 					net_player_add_snap(&net_players[id],
 					    ws->players[i].x, ws->players[i].y, ws->players[i].z,
 					    ws->players[i].yaw, now);
 				}
 				for (i = 0; i < MAX_PLAYERS; i++) {
 					if (!seen[i]) {
 						net_players[i].active = 0;
 						net_players[i].snap_count = 0;
 					}
 				}
 			}
 		} else if (hdr->type == PKT_CHAT) {
 			if (n >= (ssize_t)sizeof(struct pkt_chat)) {
 				pc = (const struct pkt_chat *)buf;
 				chat_add_message(pc->name, pc->msg);
 			}
 		}
 	}
 }
 
 static void
 net_send_leave(void)
 {
 	struct pkt_header ph;
 
 	if (net_fd < 0 || !net_connected) {
 		return;
 	}
 	ph.magic = NET_MAGIC;
 	ph.type = PKT_LEAVE;
 	ph.player_id = (uint8_t)my_player_id;
 
 	sendto(net_fd, &ph, sizeof(ph), 0,
 	    (struct sockaddr *)&srv_addr, sizeof(srv_addr));
 	close(net_fd);
 	net_fd = -1;
 }
 
 static void
 net_interpolate(double now)
 {
 	double render_time, dt_snap, t;
 	float dyaw;
 	int i, k;
 	struct net_player *np;
 	struct net_snap *s0, *s1;
 
 	render_time = now - 0.066;
 
 	for (i = 0; i < MAX_PLAYERS; i++) {
 		np = &net_players[i];
 		if (!np->active || i == my_player_id || np->snap_count < 2) {
 			continue;
 		}
 
 		s0 = NULL;
 		s1 = NULL;
 
 		for (k = 0; k < np->snap_count - 1; k++) {
 			if (render_time >= np->snaps[k].time &&
 			    render_time <= np->snaps[k + 1].time) {
 				s0 = &np->snaps[k];
 				s1 = &np->snaps[k + 1];
 				break;
 			}
 		}
 
 		if (s0 && s1) {
 			dt_snap = s1->time - s0->time;
 			t = (dt_snap > 1e-5) ? (render_time - s0->time) / dt_snap : 0.0;
 			if (t < 0.0) t = 0.0;
 			if (t > 1.0) t = 1.0;
 
 			np->cur_x = s0->x + (s1->x - s0->x) * t;
 			np->cur_y = s0->y + (s1->y - s0->y) * t;
 			np->cur_z = s0->z + (s1->z - s0->z) * t;
 
 			dyaw = s1->yaw - s0->yaw;
 			while (dyaw > 3.14159265f) dyaw -= 6.2831853f;
 			while (dyaw < -3.14159265f) dyaw += 6.2831853f;
 			np->cur_yaw = s0->yaw + dyaw * t;
 		} else if (render_time > np->snaps[np->snap_count - 1].time) {
 			s0 = &np->snaps[np->snap_count - 2];
 			s1 = &np->snaps[np->snap_count - 1];
 			dt_snap = s1->time - s0->time;
 			t = (dt_snap > 1e-5) ? (render_time - s1->time) / dt_snap : 0.0;
 			if (t > 2.0) {
 				t = 2.0;
 			}
 
 			np->cur_x = s1->x + (s1->x - s0->x) * t;
 			np->cur_y = s1->y + (s1->y - s0->y) * t;
 			np->cur_z = s1->z + (s1->z - s0->z) * t;
 			np->cur_yaw = s1->yaw;
 		}
 	}
 }
 
 static void
 gfx_init(struct sys_gfx *g)
 {
 	XIM im;
 	int scr;
 	XColor black;
 	Pixmap bm_no;
 	Cursor no_ptr;
 	char no_data[] = { 0,0,0,0,0,0,0,0 };
 	int i;
 	char **missing_charsets;
 	int missing_count;
 	char *def_string;
 
 	memset(g, 0, sizeof(*g));
 	
 	setlocale(LC_ALL, "");
 	setlocale(LC_NUMERIC, "C");
 	XSetLocaleModifiers("");
 
 	g->dpy = XOpenDisplay(NULL);
 	if (g->dpy == NULL) {
 		errx(1, "xopendisplay failed");
 	}
 	if (!XShmQueryExtension(g->dpy)) {
 		errx(1, "xshm extension not supported");
 	}
 	scr = DefaultScreen(g->dpy);
 	g->win = XCreateSimpleWindow(g->dpy, DefaultRootWindow(g->dpy), 0, 0,
 	    WIDTH, HEIGHT, 0, 0, 0);
 	XSelectInput(g->dpy, g->win, KeyPressMask | KeyReleaseMask |
 	    StructureNotifyMask | FocusChangeMask | PointerMotionMask);
 	
 	im = XOpenIM(g->dpy, NULL, NULL, NULL);
 	g->ic = NULL;
 	if (im) {
 		g->ic = XCreateIC(im, XNInputStyle, XIMPreeditNothing | XIMStatusNothing, XNClientWindow, g->win, NULL);
 	}
 
 	g->gc = XCreateGC(g->dpy, g->win, 0, NULL);
 	g->img = XShmCreateImage(g->dpy, DefaultVisual(g->dpy, scr),
 	    DefaultDepth(g->dpy, scr), ZPixmap, NULL, &g->shm, WIDTH, HEIGHT);
 	g->shm.shmid = shmget(IPC_PRIVATE, g->img->bytes_per_line * g->img->height,
 	    IPC_CREAT | 0777);
 	g->shm.shmaddr = shmat(g->shm.shmid, 0, 0);
 	g->img->data = g->shm.shmaddr;
 	g->pixels = (uint32_t *)g->img->data;
 	g->shm.readOnly = False;
 	XShmAttach(g->dpy, &g->shm);
 	shmctl(g->shm.shmid, IPC_RMID, 0);
 	g->zbuffer = malloc(WIDTH * HEIGHT * sizeof(float));
 	g->wm_delete = XInternAtom(g->dpy, "WM_DELETE_WINDOW", False);
 	XSetWMProtocols(g->dpy, g->win, &g->wm_delete, 1);
 	
 	memset(&black, 0, sizeof(black));
 	bm_no = XCreateBitmapFromData(g->dpy, g->win, no_data, 8, 8);
 	no_ptr = XCreatePixmapCursor(g->dpy, bm_no, bm_no, &black, &black, 0, 0);
 	XDefineCursor(g->dpy, g->win, no_ptr);
 	XFreeCursor(g->dpy, no_ptr);
 	XFreePixmap(g->dpy, bm_no);
 
 	g->font_set = XCreateFontSet(g->dpy, "-*-*-medium-r-normal-*-14-*-*-*-*-*-iso10646-1",
 	    &missing_charsets, &missing_count, &def_string);
 	if (!g->font_set) {
 		g->font_set = XCreateFontSet(g->dpy, "fixed",
 		    &missing_charsets, &missing_count, &def_string);
 	}
 	if (missing_count > 0) {
 		XFreeStringList(missing_charsets);
 	}
 
 	g->key_w     = XKeysymToKeycode(g->dpy, XK_w);
 	g->key_a     = XKeysymToKeycode(g->dpy, XK_a);
 	g->key_s     = XKeysymToKeycode(g->dpy, XK_s);
 	g->key_d     = XKeysymToKeycode(g->dpy, XK_d);
 	g->key_t     = XKeysymToKeycode(g->dpy, XK_t);
 	g->key_esc   = XKeysymToKeycode(g->dpy, XK_Escape);
 	g->key_up    = XKeysymToKeycode(g->dpy, XK_Up);
 	g->key_down  = XKeysymToKeycode(g->dpy, XK_Down);
 	g->key_left  = XKeysymToKeycode(g->dpy, XK_Left);
 	g->key_right = XKeysymToKeycode(g->dpy, XK_Right);
 
 	num_threads = sysconf(_SC_NPROCESSORS_ONLN);
 	if (num_threads < 1) {
 		num_threads = 4;
 	}
 	pthread_barrier_init(&barrier_start, NULL, num_threads + 1);
 	pthread_barrier_init(&barrier_end, NULL, num_threads + 1);
 	workers = malloc(num_threads * sizeof(pthread_t));
 	for (i = 0; i < num_threads; i++) {
 		pthread_create(&workers[i], NULL, render_worker, (void *)(intptr_t)i);
 	}
 
 	v_scratch_cap = 16384;
 	v_scratch = malloc(v_scratch_cap * sizeof(struct clip_vertex));
 }
 
 static void
 gfx_cleanup(struct sys_gfx *g)
 {
 	int i;
 
 	threads_running = 0;
 	pthread_barrier_wait(&barrier_start);
 	for (i = 0; i < num_threads; i++) {
 		pthread_join(workers[i], NULL);
 	}
 	pthread_barrier_destroy(&barrier_start);
 	pthread_barrier_destroy(&barrier_end);
 	free(workers);
 	free(v_scratch);
 	XUngrabPointer(g->dpy, CurrentTime);
 	XShmDetach(g->dpy, &g->shm);
 	XDestroyImage(g->img);
 	shmdt(g->shm.shmaddr);
 	free(g->zbuffer);
 	if (g->font_set) {
 		XFreeFontSet(g->dpy, g->font_set);
 	}
 	XFreeGC(g->dpy, g->gc);
 	XDestroyWindow(g->dpy, g->win);
 	XCloseDisplay(g->dpy);
 }
 
 static void
 gfx_present(struct sys_gfx *g, float px, float py, float pz)
 {
 	char txt[256];
 	int i, y_offset, active_count;
 
 	if (g->menu_open) {
 		for (i = 0; i < WIDTH * HEIGHT; i++) {
 			g->pixels[i] = (g->pixels[i] >> 1) & 0x7F7F7F;
 		}
 	}
 
 	XShmPutImage(g->dpy, g->win, g->gc, g->img, 0, 0, 0, 0, WIDTH, HEIGHT, False);
 
 	XSetForeground(g->dpy, g->gc, 0xFFFFFF);
 	XSetBackground(g->dpy, g->gc, 0x000000);
 
 	for (i = 0; i < chat_log_count; i++) {
 		if (chat_log[i].timer > 0.0f || g->in_chat) {
 			y_offset = HEIGHT - 45 - (chat_log_count - 1 - i) * 16;
 			if (g->font_set) {
 				Xutf8DrawImageString(g->dpy, g->win, g->font_set, g->gc,
 				    10, y_offset, chat_log[i].text, strlen(chat_log[i].text));
 			} else {
 				XDrawImageString(g->dpy, g->win, g->gc,
 				    10, y_offset, chat_log[i].text, strlen(chat_log[i].text));
 			}
 		}
 	}
 
 	if (g->show_debug) {
 		active_count = 0;
 		for (i = 0; i < MAX_PLAYERS; i++) {
 			if (net_players[i].active) {
 				active_count++;
 			}
 		}
 
 		XSetForeground(g->dpy, g->gc, 0x00FF00);
 		XSetBackground(g->dpy, g->gc, 0x000000);
 
 		snprintf(txt, sizeof(txt), "FPS: %.1f | PLAYERS: %d/%d | ID: %d",
 		    g->fps, active_count, MAX_PLAYERS, my_player_id);
 		if (g->font_set) {
 			Xutf8DrawImageString(g->dpy, g->win, g->font_set, g->gc, 10, 20, txt, strlen(txt));
 		} else {
 			XDrawImageString(g->dpy, g->win, g->gc, 10, 20, txt, strlen(txt));
 		}
 
 		snprintf(txt, sizeof(txt), "POS: X=%.2f Y=%.2f Z=%.2f", px, py, pz);
 		if (g->font_set) {
 			Xutf8DrawImageString(g->dpy, g->win, g->font_set, g->gc, 10, 36, txt, strlen(txt));
 		} else {
 			XDrawImageString(g->dpy, g->win, g->gc, 10, 36, txt, strlen(txt));
 		}
 
 		snprintf(txt, sizeof(txt), "NET: IN=%u pkts/s | OUT=%u pkts/s",
 		    g->pkts_in_sec, g->pkts_out_sec);
 		if (g->font_set) {
 			Xutf8DrawImageString(g->dpy, g->win, g->font_set, g->gc, 10, 52, txt, strlen(txt));
 		} else {
 			XDrawImageString(g->dpy, g->win, g->gc, 10, 52, txt, strlen(txt));
 		}
 	}
 
 	if (g->menu_open) {
 		snprintf(txt, sizeof(txt), "[ PAUSED - PRESS ESC TO RESUME ]");
 		XSetForeground(g->dpy, g->gc, 0xFFFFFF);
 		XSetBackground(g->dpy, g->gc, 0x000000);
 		if (g->font_set) {
 			Xutf8DrawImageString(g->dpy, g->win, g->font_set, g->gc,
 			    WIDTH / 2 - 110, HEIGHT / 2, txt, strlen(txt));
 		} else {
 			XDrawImageString(g->dpy, g->win, g->gc,
 			    WIDTH / 2 - 110, HEIGHT / 2, txt, strlen(txt));
 		}
 	} else if (g->in_chat) {
 		snprintf(txt, sizeof(txt), "> %s_", g->chat_buf);
 		XSetForeground(g->dpy, g->gc, 0x00FF00);
 		XSetBackground(g->dpy, g->gc, 0x000000);
 		if (g->font_set) {
 			Xutf8DrawImageString(g->dpy, g->win, g->font_set, g->gc,
 			    10, HEIGHT - 20, txt, strlen(txt));
 		} else {
 			XDrawImageString(g->dpy, g->win, g->gc,
 			    10, HEIGHT - 20, txt, strlen(txt));
 		}
 	}
 	XSync(g->dpy, False);
 }
 
 static int
 ray_tri_intersect_y(const struct col_triangle *t, float x, float z, float *out_y)
 {
 	float x0, z0, x1, z1, x2, z2;
 	float det, inv_det, w0, w1, w2;
 
 	x0 = t->v0[0];
 	z0 = t->v0[2];
 	x1 = t->v1[0];
 	z1 = t->v1[2];
 	x2 = t->v2[0];
 	z2 = t->v2[2];
 
 	det = (z1 - z2) * (x0 - x2) + (x2 - x1) * (z0 - z2);
 	if (fabsf(det) < 1e-6f) {
 		return (0);
 	}
 	inv_det = 1.0f / det;
 
 	w0 = ((z1 - z2) * (x - x2) + (x2 - x1) * (z - z2)) * inv_det;
 	w1 = ((z2 - z0) * (x - x2) + (x0 - x2) * (z - z2)) * inv_det;
 	w2 = 1.0f - w0 - w1;
 
 	if (w0 >= 0.0f && w1 >= 0.0f && w2 >= 0.0f) {
 		*out_y = w0 * t->v0[1] + w1 * t->v1[1] + w2 * t->v2[1];
 		return (1);
 	}
 	return (0);
 }
 
 static float
 get_ground_height(float px, float pz, float cur_y)
 {
 	const struct col_cell *c;
 	const struct col_triangle *t;
 	float best_below, hit_y, min_x, max_x, min_z, max_z, sx, sz;
 	uint32_t i;
 	int gx, gz, k;
 	static const float offsets[5][2] = {
 		{ 0.0f,    0.0f },
 		{ 0.18f,   0.0f },
 		{-0.18f,   0.0f },
 		{ 0.0f,    0.18f },
 		{ 0.0f,   -0.18f }
 	};
 
 	gx = (int)((px - MAP_MIN) / ((MAP_MAX - MAP_MIN) / GRID_SZ));
 	gz = (int)((pz - MAP_MIN) / ((MAP_MAX - MAP_MIN) / GRID_SZ));
 	if (gx < 0 || gx >= GRID_SZ || gz < 0 || gz >= GRID_SZ) {
 		return (-1000.0f);
 	}
 
 	best_below = -1000.0f;
 	c = &g_col_grid[gx][gz];
 
 	for (i = 0; i < c->count; i++) {
 		t = &c->tris[i];
 		if (t->norm[1] < 0.45f) {
 			continue;
 		}
 
 		min_x = fminf(t->v0[0], fminf(t->v1[0], t->v2[0]));
 		max_x = fmaxf(t->v0[0], fmaxf(t->v1[0], t->v2[0]));
 		if (px + 0.20f < min_x || px - 0.20f > max_x) {
 			continue;
 		}
 
 		min_z = fminf(t->v0[2], fminf(t->v1[2], t->v2[2]));
 		max_z = fmaxf(t->v0[2], fmaxf(t->v1[2], t->v2[2]));
 		if (pz + 0.20f < min_z || pz - 0.20f > max_z) {
 			continue;
 		}
 
 		for (k = 0; k < 5; k++) {
 			sx = px + offsets[k][0];
 			sz = pz + offsets[k][1];
 			if (ray_tri_intersect_y(t, sx, sz, &hit_y)) {
 				if (hit_y <= cur_y + 0.60f && hit_y > best_below) {
 					best_below = hit_y;
 				}
 			}
 		}
 	}
 	return (best_below);
 }
 
 static float
 get_ceiling_height(float px, float pz, float cur_y)
 {
 	const struct col_cell *c;
 	const struct col_triangle *t;
 	float best_above, hit_y, min_x, max_x, min_z, max_z;
 	uint32_t i;
 	int gx, gz;
 
 	gx = (int)((px - MAP_MIN) / ((MAP_MAX - MAP_MIN) / GRID_SZ));
 	gz = (int)((pz - MAP_MIN) / ((MAP_MAX - MAP_MIN) / GRID_SZ));
 	if (gx < 0 || gx >= GRID_SZ || gz < 0 || gz >= GRID_SZ) {
 		return (1000.0f);
 	}
 
 	best_above = 1000.0f;
 	c = &g_col_grid[gx][gz];
 
 	for (i = 0; i < c->count; i++) {
 		t = &c->tris[i];
 		if (t->norm[1] > -0.2f && t->norm[1] < 0.2f) {
 			continue;
 		}
 
 		min_x = fminf(t->v0[0], fminf(t->v1[0], t->v2[0]));
 		max_x = fmaxf(t->v0[0], fmaxf(t->v1[0], t->v2[0]));
 		if (px < min_x || px > max_x) {
 			continue;
 		}
 
 		min_z = fminf(t->v0[2], fminf(t->v1[2], t->v2[2]));
 		max_z = fmaxf(t->v0[2], fmaxf(t->v1[2], t->v2[2]));
 		if (pz < min_z || pz > max_z) {
 			continue;
 		}
 
 		if (ray_tri_intersect_y(t, px, pz, &hit_y)) {
 			if (hit_y >= cur_y + 1.0f && hit_y < best_above) {
 				best_above = hit_y;
 			}
 		}
 	}
 	return (best_above);
 }
 
 static void
 move_and_slide(float *px, float py, float *pz, float vx, float vz, float dt)
 {
 	const struct col_cell *c;
 	const struct col_triangle *t;
 	float sphere[3][3];
 	float closest[3], diff[3];
 	float rad, dist_sq, dist, h_len, dot, step_x, step_z, push;
 	float min_x, max_x, min_y, max_y, min_z, max_z;
 	float prev_x, prev_z, accum_nx, accum_nz, n_len;
 	int sub, iter, s, i, gx, gz, gx0, gx1, gz0, gz1, contacts;
 
 	rad = 0.35f;
 	step_x = (vx * dt) * 0.25f;
 	step_z = (vz * dt) * 0.25f;
 
 	for (sub = 0; sub < 4; sub++) {
 		prev_x = *px;
 		prev_z = *pz;
 
 		*px += step_x;
 		*pz += step_z;
 
 		accum_nx = 0.0f;
 		accum_nz = 0.0f;
 		contacts = 0;
 
 		gx0 = (int)((*px - rad - MAP_MIN) / ((MAP_MAX - MAP_MIN) / GRID_SZ));
 		gx1 = (int)((*px + rad - MAP_MIN) / ((MAP_MAX - MAP_MIN) / GRID_SZ));
 		gz0 = (int)((*pz - rad - MAP_MIN) / ((MAP_MAX - MAP_MIN) / GRID_SZ));
 		gz1 = (int)((*pz + rad - 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 (iter = 0; iter < 2; iter++) {
 			sphere[0][0] = *px;
 			sphere[0][1] = py + 0.35f;
 			sphere[0][2] = *pz;
 
 			sphere[1][0] = *px;
 			sphere[1][1] = py + 0.95f;
 			sphere[1][2] = *pz;
 
 			sphere[2][0] = *px;
 			sphere[2][1] = py + 1.55f;
 			sphere[2][2] = *pz;
 
 			for (gz = gz0; gz <= gz1; gz++) {
 				for (gx = gx0; gx <= gx1; gx++) {
 					c = &g_col_grid[gx][gz];
 
 					for (i = 0; i < (int)c->count; i++) {
 						t = &c->tris[i];
 						if (t->norm[1] > 0.6f) {
 							continue;
 						}
 
 						min_y = fminf(t->v0[1], fminf(t->v1[1], t->v2[1]));
 						max_y = fmaxf(t->v0[1], fmaxf(t->v1[1], t->v2[1]));
 						if (py + 1.9f < min_y || py > max_y) {
 							continue;
 						}
 
 						min_x = fminf(t->v0[0], fminf(t->v1[0], t->v2[0]));
 						max_x = fmaxf(t->v0[0], fmaxf(t->v1[0], t->v2[0]));
 						if (*px + rad < min_x || *px - rad > max_x) {
 							continue;
 						}
 
 						min_z = fminf(t->v0[2], fminf(t->v1[2], t->v2[2]));
 						max_z = fmaxf(t->v0[2], fmaxf(t->v1[2], t->v2[2]));
 						if (*pz + rad < min_z || *pz - rad > max_z) {
 							continue;
 						}
 
 						for (s = 0; s < 3; s++) {
 							closest_point_triangle(sphere[s],
 							    t->v0, t->v1, t->v2, closest);
 
 							diff[0] = sphere[s][0] - closest[0];
 							diff[1] = sphere[s][1] - closest[1];
 							diff[2] = sphere[s][2] - closest[2];
 
 							dist_sq = diff[0] * diff[0] +
 							    diff[1] * diff[1] +
 							    diff[2] * diff[2];
 
 							if (dist_sq < rad * rad) {
 								dist = sqrtf(dist_sq);
 								h_len = sqrtf(diff[0] * diff[0] + diff[2] * diff[2]);
 
 								if (h_len > 1e-4f) {
 									diff[0] /= h_len;
 									diff[2] /= h_len;
 								} else {
 									diff[0] = prev_x - closest[0];
 									diff[2] = prev_z - closest[2];
 									h_len = sqrtf(diff[0] * diff[0] + diff[2] * diff[2]);
 									if (h_len > 1e-4f) {
 										diff[0] /= h_len;
 										diff[2] /= h_len;
 									} else {
 										diff[0] = 1.0f;
 										diff[2] = 0.0f;
 									}
 								}
 
 								push = rad - dist;
 								*px += diff[0] * push;
 								*pz += diff[2] * push;
 
 								accum_nx += diff[0];
 								accum_nz += diff[2];
 								contacts++;
 
 								sphere[0][0] = *px;
 								sphere[0][2] = *pz;
 								sphere[1][0] = *px;
 								sphere[1][2] = *pz;
 								sphere[2][0] = *px;
 								sphere[2][2] = *pz;
 							}
 						}
 					}
 				}
 			}
 		}
 
 		if (contacts > 0) {
 			n_len = sqrtf(accum_nx * accum_nx + accum_nz * accum_nz);
 			if (n_len > 1e-4f) {
 				accum_nx /= n_len;
 				accum_nz /= n_len;
 				dot = vx * accum_nx + vz * accum_nz;
 				if (dot < 0.0f) {
 					vx -= dot * accum_nx;
 					vz -= dot * accum_nz;
 				}
 			}
 		}
 	}
 }
 
 static unsigned int
 hash_str(const char *str)
 {
 	unsigned int hash = 5381;
 	int c;
 
 	while ((c = (unsigned char)*str++)) {
 		hash = ((hash << 5) + hash) + c;
 	}
 	return (hash);
 }
 
 static void
 mesh_load_ply(struct mesh *m, const uint8_t *data, size_t sz)
 {
 	const char *header_end;
 	const char *p;
 	const uint8_t *bin;
 	int temp_materials, idx, k;
 	char *dst;
 	const char *src;
 	uint16_t *mat;
 	int32_t *idx_ptr;
 	uint32_t i;
 
 	(void)sz;
 	header_end = strstr((const char *)data, "end_header\n");
 	if (!header_end) {
 		return;
 	}
 	header_end += 11;
 
 	memset(m, 0, sizeof(*m));
 
 	p = (const char *)data;
 	temp_materials = 0;
 	while (p < header_end) {
 		if (strncmp(p, "comment spr_cx", 14) == 0) m->spr_x = strtof(p + 14, NULL);
 		else if (strncmp(p, "comment spr_cy", 14) == 0) m->spr_y = strtof(p + 14, NULL);
 		else if (strncmp(p, "comment spr_cz", 14) == 0) m->spr_z = strtof(p + 14, NULL);
 		else if (strncmp(p, "comment spr_r", 13) == 0) m->spr_r = strtof(p + 13, NULL);
 		else if (strncmp(p, "element vertex", 14) == 0) m->num_verts = strtoul(p + 14, NULL, 10);
 		else if (strncmp(p, "element face", 12) == 0) m->num_tris = strtoul(p + 12, NULL, 10);
 		else if (strncmp(p, "comment texture", 15) == 0) temp_materials++;
 		p = strchr(p, '\n');
 		if (!p) break;
 		p++;
 	}
 
 	m->num_materials = temp_materials;
 	if (m->num_materials > 0) {
 		m->raw_tex_names = malloc(m->num_materials * 32);
 		p = (const char *)data;
 		idx = 0;
 		while (p < header_end) {
 			if (strncmp(p, "comment texture", 15) == 0) {
 				src = p + 16;
 				dst = m->raw_tex_names[idx];
 				k = 0;
 				while (src[k] != '\n' && src[k] != '\r' && k < 31) {
 					dst[k] = src[k];
 					k++;
 				}
 				dst[k] = '\0';
 				idx++;
 			}
 			p = strchr(p, '\n');
 			if (!p) break;
 			p++;
 		}
 	}
 
 	m->ply_verts = malloc(m->num_verts * sizeof(struct ply_vertex));
 	m->indices = malloc(m->num_tris * 3 * sizeof(uint16_t));
 	m->mat_ids = malloc(m->num_tris * sizeof(uint16_t));
 
 	bin = (const uint8_t *)header_end;
 
 	memcpy(m->ply_verts, bin, m->num_verts * sizeof(struct ply_vertex));
 	bin += m->num_verts * sizeof(struct ply_vertex);
 
 	for (i = 0; i < m->num_tris; i++) {
 		bin += 1;
 		idx_ptr = (int32_t *)bin;
 		m->indices[i*3+0] = idx_ptr[0];
 		m->indices[i*3+1] = idx_ptr[1];
 		m->indices[i*3+2] = idx_ptr[2];
 		bin += 12;
 
 		mat = (uint16_t *)bin;
 		m->mat_ids[i] = *mat;
 		bin += 2;
 	}
 
 	m->total_area = 0.0f;
 	for (i = 0; i < m->num_tris; i++) {
 		uint16_t i0 = m->indices[i*3], i1 = m->indices[i*3+1], i2 = m->indices[i*3+2];
 		float ux = m->ply_verts[i1].x - m->ply_verts[i0].x;
 		float uy = m->ply_verts[i1].y - m->ply_verts[i0].y;
 		float uz = m->ply_verts[i1].z - m->ply_verts[i0].z;
 		float vx = m->ply_verts[i2].x - m->ply_verts[i0].x;
 		float vy = m->ply_verts[i2].y - m->ply_verts[i0].y;
 		float vz = m->ply_verts[i2].z - m->ply_verts[i0].z;
 		float cx = uy * vz - uz * vy, cy = uz * vx - ux * vz, cz = ux * vy - uy * vx;
 		m->total_area += 0.5f * sqrtf(cx*cx + cy*cy + cz*cz);
 	}
 }
 
 static void
 tex_load_tga(struct texture *t, const uint8_t *data, size_t sz)
 {
 	struct tga_header *hdr;
 	const uint8_t *src_pixels;
 	uint32_t *dst, *curr_offset, *src;
 	int w, h, mw, mh, total_pixels, i, level;
 	int prev_w, prev_h, next_w, next_h, x, y;
 	uint32_t c00, c10, c01, c11, r, g, b, a;
 
 	memset(t, 0, sizeof(*t));
 	if (data == NULL || sz < sizeof(struct tga_header)) {
 		w = 2;
 		h = 2;
 		t->w = w;
 		t->h = h;
 		t->has_alpha = 0;
 		t->pixels = malloc((4 + 1 + 1 + 1) * sizeof(uint32_t));
 		if (t->pixels == NULL) {
 			return;
 		}
 		t->pixels[0] = 0xffa0a0a0;
 		t->pixels[1] = 0xff808080;
 		t->pixels[2] = 0xff808080;
 		t->pixels[3] = 0xffa0a0a0;
 
 		t->mips[0] = t->pixels;
 		t->mip_w[0] = 2;
 		t->mip_h[0] = 2;
 
 		for (i = 1; i < 4; i++) {
 			t->mips[i] = t->pixels + 4;
 			t->mip_w[i] = 1;
 			t->mip_h[i] = 1;
 		}
 		t->mips[1][0] = 0xff909090;
 		return;
 	}
 
 	hdr = (struct tga_header *)data;
 	w = hdr->width;
 	h = hdr->height;
 	t->w = w;
 	t->h = h;
 
 	mw = w;
 	mh = h;
 	total_pixels = 0;
 	for (i = 0; i < 4; i++) {
 		total_pixels += mw * mh;
 		mw = mw > 1 ? mw / 2 : 1;
 		mh = mh > 1 ? mh / 2 : 1;
 	}
 
 	t->pixels = malloc(total_pixels * sizeof(uint32_t));
 	if (t->pixels == NULL) {
 		return;
 	}
 	src_pixels = data + sizeof(struct tga_header) + hdr->id_length;
 
 	if (hdr->pixel_depth == 32) {
 		memcpy(t->pixels, src_pixels, w * h * 4);
 		t->has_alpha = 0;
 		for (i = 0; i < w * h; i++) {
 			a = (t->pixels[i] >> 24) & 0xFF;
 			if (a < 250) {
 				t->has_alpha = 1;
 				break;
 			}
 		}
 	} else if (hdr->pixel_depth == 24) {
 		t->has_alpha = 0;
 		dst = t->pixels;
 		for (i = 0; i < w * h; i++) {
 			dst[i] = (255U << 24) | (src_pixels[i*3+2] << 16) |
 			    (src_pixels[i*3+1] << 8) | src_pixels[i*3+0];
 		}
 	}
 
 	t->mips[0] = t->pixels;
 	t->mip_w[0] = w;
 	t->mip_h[0] = h;
 
 	curr_offset = t->pixels + (w * h);
 	for (level = 1; level < 4; level++) {
 		prev_w = t->mips[level-1] ? t->mip_w[level-1] : 1;
 		prev_h = t->mips[level-1] ? t->mip_h[level-1] : 1;
 		next_w = prev_w > 1 ? prev_w / 2 : 1;
 		next_h = prev_h > 1 ? prev_h / 2 : 1;
 
 		t->mips[level] = curr_offset;
 		t->mip_w[level] = next_w;
 		t->mip_h[level] = next_h;
 
 		src = t->mips[level-1];
 		dst = t->mips[level];
 
 		if (prev_w > 1 && prev_h > 1) {
 			for (y = 0; y < next_h; y++) {
 				for (x = 0; x < next_w; x++) {
 					c00 = src[(y*2)*prev_w + (x*2)];
 					c10 = src[(y*2)*prev_w + (x*2+1)];
 					c01 = src[(y*2+1)*prev_w + (x*2)];
 					c11 = src[(y*2+1)*prev_w + (x*2+1)];
 
 					r = (((c00 >> 16) & 0xFF) + ((c10 >> 16) & 0xFF) +
 					    ((c01 >> 16) & 0xFF) + ((c11 >> 16) & 0xFF)) / 4;
 					g = (((c00 >> 8) & 0xFF) + ((c10 >> 8) & 0xFF) +
 					    ((c01 >> 8) & 0xFF) + ((c11 >> 8) & 0xFF)) / 4;
 					b = ((c00 & 0xFF) + (c10 & 0xFF) +
 					    (c01 & 0xFF) + (c11 & 0xFF)) / 4;
 					a = (((c00 >> 24) & 0xFF) + ((c10 >> 24) & 0xFF) +
 					    ((c01 >> 24) & 0xFF) + ((c11 >> 24) & 0xFF)) / 4;
 
 					dst[y * next_w + x] = (a << 24) | (r << 16) |
 					    (g << 8) | b;
 				}
 			}
 		} else {
 			for (i = 0; i < next_w * next_h; i++) {
 				dst[i] = src[0];
 			}
 		}
 		curr_offset += next_w * next_h;
 	}
 }
 
 static struct texture *
 cache_get_tex(struct asset_cache *c, const char *name)
 {
 	unsigned int h;
 	int idx;
 	char tar_path[1024];
 	size_t sz = 0;
 	const uint8_t *data;
 
 	if (!name || name[0] == '\0') {
 		name = "missing";
 	}
 	h = hash_str(name) % (MAX_CACHE * 2);
 	while (c->tex_hash[h] != 0) {
 		idx = c->tex_hash[h] - 1;
 		if (strcasecmp(c->tex_names[idx], name) == 0) {
 			return (&c->textures[idx]);
 		}
 		h = (h + 1) % (MAX_CACHE * 2);
 	}
 	if (c->tex_count >= MAX_CACHE) {
 		return (NULL);
 	}
 	idx = c->tex_count++;
 	snprintf(c->tex_names[idx], 32, "%s", name);
 	c->tex_hash[h] = idx + 1;
 
 	snprintf(tar_path, sizeof(tar_path), "assets/textures/%s.tga", name);
 
 	data = tar_lookup(tar_path, &sz);
 	tex_load_tga(&c->textures[idx], data, sz);
 	return (&c->textures[idx]);
 }
 
 static struct mesh *
 cache_get_mesh(struct asset_cache *c, const char *name)
 {
 	unsigned int h;
 	int idx;
 	char tar_path[1024];
 	size_t sz = 0;
 	const uint8_t *data;
 	uint32_t i;
 
 	h = hash_str(name) % (MAX_CACHE * 2);
 	while (c->mesh_hash[h] != 0) {
 		idx = c->mesh_hash[h] - 1;
 		if (strcasecmp(c->mesh_names[idx], name) == 0) {
 			return (&c->meshes[idx]);
 		}
 		h = (h + 1) % (MAX_CACHE * 2);
 	}
 	if (c->mesh_count >= MAX_CACHE) {
 		return (NULL);
 	}
 	idx = c->mesh_count++;
 	snprintf(c->mesh_names[idx], NAME_SZ, "%s", name);
 	c->mesh_hash[h] = idx + 1;
 
 	snprintf(tar_path, sizeof(tar_path), "assets/models/%s.ply", name);
 
 	data = tar_lookup(tar_path, &sz);
 	if (data) {
 		mesh_load_ply(&c->meshes[idx], data, sz);
 		if (c->meshes[idx].num_materials > 0) {
 			c->meshes[idx].textures = malloc(c->meshes[idx].num_materials * sizeof(struct texture *));
 			for (i = 0; i < c->meshes[idx].num_materials; i++) {
 				c->meshes[idx].textures[i] = cache_get_tex(c, c->meshes[idx].raw_tex_names[i]);
 			}
 		}
 	}
 	return (&c->meshes[idx]);
 }
 
 static void
 mat_identity(struct mat4 *m)
 {
 	memset(m, 0, sizeof(*m));
 	m->m[0][0] = m->m[1][1] = m->m[2][2] = 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 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 void
 mat_projection(struct mat4 *m, float fov, float aspect, float near, float far)
 {
 	float f;
 
 	f = 1.0f / tanf(fov * 0.5f * 3.14159265f / 180.0f);
 	memset(m, 0, sizeof(*m));
 	m->m[0][0] = f / aspect;
 	m->m[1][1] = f;
 	m->m[2][2] = (far + near) / (far - near);
 	m->m[2][3] = -(2.0f * far * near) / (far - near);
 	m->m[3][2] = 1.0f;
 }
 
 static void
 mat_view(struct mat4 *m, float cx, float cy, float cz, float cyaw, float cpitch)
 {
 	struct mat4 trans, rot_y, rot_x, rot;
 
 	mat_translate(&trans, -cx, -cy, -cz);
 	mat_identity(&rot_y);
 	rot_y.m[0][0] = cosf(-cyaw);
 	rot_y.m[0][2] = sinf(-cyaw);
 	rot_y.m[2][0] = -sinf(-cyaw);
 	rot_y.m[2][2] = cosf(-cyaw);
 	mat_identity(&rot_x);
 	rot_x.m[1][1] = cosf(cpitch);
 	rot_x.m[1][2] = -sinf(cpitch);
 	rot_x.m[2][1] = sinf(cpitch);
 	rot_x.m[2][2] = cosf(cpitch);
 	mat_mul(&rot, &rot_x, &rot_y);
 	mat_mul(m, &rot, &trans);
 }
 
 static inline void
 mat_transform(struct vec3 *dst, float *w_out, const struct mat4 *m, const struct vec3 *v)
 {
 	dst->x = m->m[0][0] * v->x + m->m[0][1] * v->y + m->m[0][2] * v->z + m->m[0][3];
 	dst->y = m->m[1][0] * v->x + m->m[1][1] * v->y + m->m[1][2] * v->z + m->m[1][3];
 	dst->z = m->m[2][0] * v->x + m->m[2][1] * v->y + m->m[2][2] * v->z + m->m[2][3];
 	*w_out = m->m[3][0] * v->x + m->m[3][1] * v->y + m->m[3][2] * v->z + m->m[3][3];
 }
 
 static void
 flush_render_list(void)
 {
 	if (render_count == 0) {
 		return;
 	}
 	pthread_barrier_wait(&barrier_start);
 	pthread_barrier_wait(&barrier_end);
 	render_count = 0;
 }
 
 static void
 project_and_push(const struct clip_vertex *c0, const struct clip_vertex *c1, const struct clip_vertex *c2, const struct texture *tex, int is_water, int mip)
 {
 	struct vertex v0, v1, v2;
 	float area;
 	int double_sided;
 	struct vertex tmp;
 
 	v0.w = 1.0f / c0->w; v0.x = (c0->x * v0.w + 1.0f) * WIDTH * 0.5f; v0.y = (1.0f - c0->y * v0.w) * HEIGHT * 0.5f;
 	v0.z = c0->w; v0.u = c0->u; v0.v = c0->v; v0.r = c0->r; v0.g = c0->g; v0.b = c0->b; v0.a = c0->a; v0.f = c0->f;
 	v1.w = 1.0f / c1->w; v1.x = (c1->x * v1.w + 1.0f) * WIDTH * 0.5f; v1.y = (1.0f - c1->y * v1.w) * HEIGHT * 0.5f;
 	v1.z = c1->w; v1.u = c1->u; v1.v = c1->v; v1.r = c1->r; v1.g = c1->g; v1.b = c1->b; v1.a = c1->a; v1.f = c1->f;
 	v2.w = 1.0f / c2->w; v2.x = (c2->x * v2.w + 1.0f) * WIDTH * 0.5f; v2.y = (1.0f - c2->y * v2.w) * HEIGHT * 0.5f;
 	v2.z = c2->w; v2.u = c2->u; v2.v = c2->v; v2.r = c2->r; v2.g = c2->g; v2.b = c2->b; v2.a = c2->a; v2.f = c2->f;
 
 	area = edge_func(v0.x, v0.y, v1.x, v1.y, v2.x, v2.y);
 	double_sided = (tex && tex->has_alpha) || is_water;
 	if (area >= 0.0f) {
 		if (double_sided) {
 			tmp = v1;
 			v1 = v2;
 			v2 = tmp;
 		} else {
 			return;
 		}
 	}
 
 	if (render_count >= MAX_RENDER_TRIS) {
 		flush_render_list();
 	}
 	render_list[render_count].v0 = v0;
 	render_list[render_count].v1 = v1;
 	render_list[render_count].v2 = v2;
 	render_list[render_count].tex = tex;
 	render_list[render_count].is_water = is_water;
 	render_list[render_count].mip = mip;
 	render_count++;
 }
 
 static struct clip_vertex
 clip_intersect(const struct clip_vertex *a, const struct clip_vertex *b, float w_clip)
 {
 	struct clip_vertex out;
 	float t;
 
 	t = (w_clip - a->w) / (b->w - a->w);
 	out.x = a->x + t * (b->x - a->x);
 	out.y = a->y + t * (b->y - a->y);
 	out.z = a->z + t * (b->z - a->z);
 	out.w = w_clip;
 	out.u = a->u + t * (b->u - a->u);
 	out.v = a->v + t * (b->v - a->v);
 	out.r = a->r + t * (b->r - a->r);
 	out.g = a->g + t * (b->g - a->g);
 	out.b = a->b + t * (b->b - a->b);
 	out.a = a->a + t * (b->a - a->a);
 	out.f = a->f + t * (b->f - a->f);
 	return (out);
 }
 
 static void
 clip_and_push_triangle(const struct clip_vertex *c0, const struct clip_vertex *c1, const struct clip_vertex *c2, const struct texture *tex, int is_water, int mip)
 {
 	struct clip_vertex p[4];
 	const struct clip_vertex *v[3];
 	const struct clip_vertex *c, *n;
 	int len = 0;
 	int i;
 
 	v[0] = c0;
 	v[1] = c1;
 	v[2] = c2;
 
 	for (i = 0; i < 3; i++) {
 		c = v[i];
 		n = v[(i + 1) % 3];
 		if (c->w >= 0.1f) {
 			p[len++] = *c;
 		}
 		if ((c->w >= 0.1f) != (n->w >= 0.1f)) {
 			p[len++] = clip_intersect(c, n, 0.1f);
 		}
 	}
 	if (len == 3) {
 		project_and_push(&p[0], &p[1], &p[2], tex, is_water, mip);
 	} else if (len == 4) {
 		project_and_push(&p[0], &p[1], &p[2], tex, is_water, mip);
 		project_and_push(&p[0], &p[2], &p[3], tex, is_water, mip);
 	}
 }
 
 static void
 draw_mesh(const struct mesh *m, const struct mat4 *mvp, int is_seabed)
 {
 	struct clip_vertex *cv;
 	float ar, ag, ab, far_clp, fog_st, min_dist;
 	int mip;
 	float scale;
 	uint32_t i;
 	struct vec3 in, out;
 	float w, fog, d;
 
 	if (m->ply_verts == NULL || m->num_verts == 0) {
 		return;
 	}
 	if (m->num_verts > v_scratch_cap) {
 		v_scratch_cap = m->num_verts * 2;
 		v_scratch = realloc(v_scratch, v_scratch_cap * sizeof(struct clip_vertex));
 	}
 	cv = v_scratch;
 	ar = g_sys->cur_weather.amb[0] / 255.0f * 1.2f;
 	ag = g_sys->cur_weather.amb[1] / 255.0f * 1.2f;
 	ab = g_sys->cur_weather.amb[2] / 255.0f * 1.2f;
 	far_clp = g_sys->cur_weather.far_clp;
 	fog_st = g_sys->cur_weather.fog_st;
 	if (far_clp <= fog_st) {
 		far_clp = fog_st + 1.0f;
 	}
 	min_dist = 1e9f;
 
 	for (i = 0; i < m->num_verts; i++) {
 		in.x = m->ply_verts[i].x;
 		in.y = m->ply_verts[i].y;
 		in.z = m->ply_verts[i].z;
 		mat_transform(&out, &w, mvp, &in);
 		cv[i].x = out.x;
 		cv[i].y = out.y;
 		cv[i].z = out.z;
 		cv[i].w = w;
 		cv[i].u = m->ply_verts[i].s;
 		cv[i].v = m->ply_verts[i].t;
 		fog = (out.z - fog_st) / (far_clp - fog_st);
 		if (fog < 0.0f) {
 			fog = 0.0f;
 		} else if (fog > 1.0f) {
 			fog = 1.0f;
 		}
 		cv[i].f = fog;
 		
 		if (is_seabed) {
 			cv[i].r = 0.25f * ar;
 			cv[i].g = 0.28f * ag;
 			cv[i].b = 0.30f * ab;
 		} else {
 			cv[i].r = (m->ply_verts[i].r / 255.0f) * ar;
 			cv[i].g = (m->ply_verts[i].g / 255.0f) * ag;
 			cv[i].b = (m->ply_verts[i].b / 255.0f) * ab;
 		}
 		cv[i].a = 1.0f;
 
 		d = sqrtf(out.x*out.x + out.y*out.y + out.z*out.z);
 		if (d < min_dist) {
 			min_dist = d;
 		}
 	}
 	mip = 0;
 	scale = sqrtf(m->total_area) * 0.05f;
 	if (scale < 0.2f) {
 		scale = 0.2f;
 	}
 	if (scale > 5.0f) {
 		scale = 5.0f;
 	}
 	if (min_dist > 150.0f * scale) {
 		mip = 3;
 	} else if (min_dist > 80.0f * scale) {
 		mip = 2;
 	} else if (min_dist > 30.0f * scale) {
 		mip = 1;
 	}
 
 	for (i = 0; i < m->num_tris; i++) {
 		uint16_t i0 = m->indices[i*3], i1 = m->indices[i*3+1], i2 = m->indices[i*3+2];
 		struct texture *tex;
 
 		if (cv[i0].w < 0.1f && cv[i1].w < 0.1f && cv[i2].w < 0.1f) {
 			continue;
 		}
 		if (cv[i0].w > far_clp && cv[i1].w > far_clp && cv[i2].w > far_clp) {
 			continue;
 		}
 		tex = (m->num_materials > 0 && m->textures) ? m->textures[m->mat_ids[i] < m->num_materials ? m->mat_ids[i] : 0] : NULL;
 		clip_and_push_triangle(&cv[i0], &cv[i1], &cv[i2], tex, 0, mip);
 	}
 }
 
 static int
 is_occluded(struct sys_gfx *g, float cx, float cy, float cz, float r)
 {
 	(void)g; (void)cx; (void)cy; (void)cz; (void)r;
 	return (0);
 }
 
 static int
 cmp_draw_item(const void *a, const void *b)
 {
 	float da = ((const struct draw_item *)a)->dist_sq;
 	float db = ((const struct draw_item *)b)->dist_sq;
 
 	if (da < db)
 		return (-1);
 	if (da > db)
 		return (1);
 	return (0);
 }
 
 static const char *
 ped_lookup_model(int id)
 {
 	if (id < 0 || id >= 313) {
 		return (NULL);
 	}
 	return (skin_names[id][0] != '\0' ? skin_names[id] : NULL);
 }
 
 static void
 draw_scene(struct sys_gfx *g, const struct mat4 *proj, const struct mat4 *view,
     float cam_x, float cam_y, float cam_z,
     float player_x, float player_y, float player_z, float player_yaw)
 {
 	float val, pitch, fov_y, fov_x, far_clp, dx, dy, dz, dist_sq, w, r;
 	float obj_max_dist;
 	int y_horiz, min_gx, max_gx, min_gz, max_gz, id, x, y, gx, gz, i;
 	uint8_t sr, sg, sb, hr, hg, hb;
 	uint32_t c;
 	struct mesh *m;
 	struct vec3 mc, cv;
 	struct mat4 mvp;
 
 	val = view->m[1][2];
 	if (val > 1.0f) {
 		val = 1.0f;
 	} else if (val < -1.0f) {
 		val = -1.0f;
 	}
 	pitch = asin(val);
 	y_horiz = HEIGHT / 2 + (int)(pitch * 400.0f);
 	sr = g->cur_weather.sky_top[0];
 	sg = g->cur_weather.sky_top[1];
 	sb = g->cur_weather.sky_top[2];
 	hr = g->cur_weather.sky_bot[0];
 	hg = g->cur_weather.sky_bot[1];
 	hb = g->cur_weather.sky_bot[2];
 
 	for (y = 0; y < HEIGHT; y++) {
 		c = (hr << 16) | (hg << 8) | hb;
 		if (y < y_horiz) {
 			float f = (float)y / (float)(y_horiz > 0 ? y_horiz : 1);
 			c = ((sr + (uint8_t)(f * (hr - sr))) << 16) |
 			    ((sg + (uint8_t)(f * (hg - sg))) << 8) |
 			    (sb + (uint8_t)(f * (hb - sb)));
 		}
 		for (x = 0; x < WIDTH; x++) {
 			g->pixels[y * WIDTH + x] = c;
 		}
 	}
 
 	far_clp = g->cur_weather.far_clp;
 	fov_y = tanf(60.0f * 0.5f * 3.14159f / 180.0f);
 	fov_x = fov_y * ((float)WIDTH / HEIGHT);
 
 	min_gx = (int)((cam_x - far_clp - MAP_MIN) / ((MAP_MAX - MAP_MIN) / GRID_SZ));
 	max_gx = (int)((cam_x + far_clp - MAP_MIN) / ((MAP_MAX - MAP_MIN) / GRID_SZ));
 	min_gz = (int)((cam_z - far_clp - MAP_MIN) / ((MAP_MAX - MAP_MIN) / GRID_SZ));
 	max_gz = (int)((cam_z + far_clp - MAP_MIN) / ((MAP_MAX - MAP_MIN) / GRID_SZ));
 
 	if (min_gx < 0) min_gx = 0;
 	if (max_gx >= GRID_SZ) max_gx = GRID_SZ - 1;
 	if (min_gz < 0) min_gz = 0;
 	if (max_gz >= GRID_SZ) max_gz = GRID_SZ - 1;
 
 	draw_count = 0;
 	for (gz = min_gz; gz <= max_gz; gz++) {
 		for (gx = min_gx; gx <= max_gx; gx++) {
 			for (i = 0; i < scene_grid[gx][gz].count; i++) {
 				id = scene_grid[gx][gz].ids[i];
 
 				int16_t t_on = g_transforms.time_on[id];
 				int16_t t_off = g_transforms.time_off[id];
 				if (t_on != t_off) {
 					float cur_h = g->game_time_hours;
 					int visible = 0;
 					if (t_on > t_off) {
 						if (cur_h >= t_on || cur_h < t_off) {
 							visible = 1;
 						}
 					} else {
 						if (cur_h >= t_on && cur_h < t_off) {
 							visible = 1;
 						}
 					}
 					if (!visible) {
 						continue;
 					}
 				}
 
 				dx = g_transforms.sphere_cx[id] - cam_x;
 				dy = g_transforms.sphere_cy[id] - cam_y;
 				dz = g_transforms.sphere_cz[id] - cam_z;
 				dist_sq = dx * dx + dy * dy + dz * dz;
 
 				obj_max_dist = g_transforms.sphere_r[id] * 35.0f;
 				if (obj_max_dist < 40.0f) {
 					obj_max_dist = 40.0f;
 				}
 				if (obj_max_dist > far_clp) {
 					obj_max_dist = far_clp;
 				}
 
 				if (dist_sq > (obj_max_dist + g_transforms.sphere_r[id]) *
 				    (obj_max_dist + g_transforms.sphere_r[id])) {
 					continue;
 				}
 
 				if (draw_count >= draw_cap) {
 					draw_cap = draw_cap == 0 ? 1024 : draw_cap * 2;
 					draw_list = realloc(draw_list, draw_cap * sizeof(struct draw_item));
 				}
 				draw_list[draw_count].id = id;
 				draw_list[draw_count].dist_sq = dist_sq;
 				draw_count++;
 			}
 		}
 	}
 	qsort(draw_list, draw_count, sizeof(struct draw_item), cmp_draw_item);
 
 	for (i = 0; i < draw_count; i++) {
 		id = draw_list[i].id;
 		m = scene_meshes[id];
 		if (!m || !m->ply_verts) {
 			continue;
 		}
 		mc.x = g_transforms.sphere_cx[id];
 		mc.y = g_transforms.sphere_cy[id];
 		mc.z = g_transforms.sphere_cz[id];
 		r = g_transforms.sphere_r[id] * 1.05f;
 
 		dx = mc.x - cam_x;
 		dy = mc.y - cam_y;
 		dz = mc.z - cam_z;
 		dist_sq = dx * dx + dy * dy + dz * dz;
 
 		if (dist_sq > r * r) {
 			mat_transform(&cv, &w, view, &mc);
 
 			if (cv.z + r < 0.1f || cv.z - r > far_clp) {
 				continue;
 			}
 			if (cv.z > 0.0f) {
 				if (fabsf(cv.x) - r > cv.z * fov_x ||
 				    fabsf(cv.y) - r > cv.z * fov_y) {
 					continue;
 				}
 			}
 		} else {
 			mat_transform(&cv, &w, view, &mc);
 		}
 
 		if (is_occluded(g, cv.x, cv.y, cv.z, r)) {
 			continue;
 		}
 		mat_mul(&mvp, view, &g_transforms.world_matrices[id]);
 		mat_mul(&mvp, proj, &mvp);
 		draw_mesh(m, &mvp, 0);
 	}
 
 	if (active_skin_id >= 0) {
 		const char *skin_model_name;
 
 		skin_model_name = ped_lookup_model(active_skin_id);
 		if (skin_model_name) {
 			struct mesh *skin_mesh;
 
 			skin_mesh = cache_get_mesh(g_cache, skin_model_name);
 			if (skin_mesh && skin_mesh->ply_verts) {
 				struct mat4 rot_y, trans, world;
 
 				mat_identity(&rot_y);
 				rot_y.m[0][0] = cosf(player_yaw);
 				rot_y.m[0][2] = sinf(player_yaw);
 				rot_y.m[2][0] = -sinf(player_yaw);
 				rot_y.m[2][2] = cosf(player_yaw);
 
 				mat_translate(&trans, player_x, player_y + 1.0f, player_z);
 				mat_mul(&world, &trans, &rot_y);
 
 				mat_mul(&mvp, view, &world);
 				mat_mul(&mvp, proj, &mvp);
 				draw_mesh(skin_mesh, &mvp, 0);
 			}
 		}
 	}
 
 	for (i = 0; i < MAX_PLAYERS; i++) {
 		const char *rem_skin_name;
 
 		if (!net_players[i].active || i == my_player_id) {
 			continue;
 		}
 
 		rem_skin_name = ped_lookup_model(net_players[i].skin);
 		if (rem_skin_name) {
 			struct mesh *rem_mesh;
 
 			rem_mesh = cache_get_mesh(g_cache, rem_skin_name);
 			if (rem_mesh && rem_mesh->ply_verts) {
 				struct mat4 rot_y, trans, world;
 
 				mat_identity(&rot_y);
 				rot_y.m[0][0] = cosf(net_players[i].cur_yaw);
 				rot_y.m[0][2] = sinf(net_players[i].cur_yaw);
 				rot_y.m[2][0] = -sinf(net_players[i].cur_yaw);
 				rot_y.m[2][2] = cosf(net_players[i].cur_yaw);
 
 				mat_translate(&trans, net_players[i].cur_x,
 				    net_players[i].cur_y + 1.0f, net_players[i].cur_z);
 				mat_mul(&world, &trans, &rot_y);
 
 				mat_mul(&mvp, view, &world);
 				mat_mul(&mvp, proj, &mvp);
 				draw_mesh(rem_mesh, &mvp, 0);
 			}
 		}
 	}
 
 	flush_render_list();
 }
 
 static void
 update_weather(struct sys_gfx *g)
 {
 	float t, snaps[8] = {0.0f, 5.0f, 6.0f, 7.0f, 12.0f, 19.0f, 20.0f, 22.0f};
 	int i0, i1, i;
 	float f;
 	struct timecyc_entry *w0, *w1;
 
 	if (g->num_weathers == 0) {
 		return;
 	}
 	if (g->game_weather >= g->num_weathers) {
 		g->game_weather = 0;
 	}
 	t = g->game_time_hours;
 	i0 = 7;
 	i1 = 0;
 	f = 0.0f;
 	if (t >= snaps[7] || t < snaps[0]) {
 		float wt = t;
 		if (wt < snaps[0]) {
 			wt += 24.0f;
 		}
 		f = (wt - snaps[7]) / (24.0f - snaps[7] + snaps[0]);
 	} else {
 		for (i = 0; i < 7; i++) {
 			if (t >= snaps[i] && t < snaps[i + 1]) {
 				i0 = i;
 				i1 = i + 1;
 				f = (t - snaps[i]) / (snaps[i + 1] - snaps[i]);
 				break;
 			}
 		}
 	}
 	w0 = &g->weathers[g->game_weather][i0];
 	w1 = &g->weathers[g->game_weather][i1];
 	#define LERP(c) g->cur_weather.c = w0->c + f * (w1->c - w0->c)
 	LERP(amb[0]); LERP(amb[1]); LERP(amb[2]);
 	LERP(sky_top[0]); LERP(sky_top[1]); LERP(sky_top[2]);
 	LERP(sky_bot[0]); LERP(sky_bot[1]); LERP(sky_bot[2]);
 	LERP(water[0]); LERP(water[1]); LERP(water[2]); LERP(water[3]);
 	LERP(far_clp); LERP(fog_st);
 	#undef LERP
 
 	if (g->far_clip_override > 10.0f) {
 		g->cur_weather.far_clp = g->far_clip_override;
 	} else if (g->cur_weather.far_clp > 220.0f) {
 		g->cur_weather.far_clp = 220.0f;
 	}
 }
 
 static void
 draw_water(const struct mat4 *proj, const struct mat4 *view)
 {
 	struct clip_vertex cv[4];
 	struct mat4 mvp;
 	struct vec3 in, out;
 	float t, far_clp, fog_st, ar, ag, ab, w, fog, u_tex, v_tex;
 	float wave_height, wave_factor, dy, flow_u, flow_v;
 	uint32_t i;
 	int j;
 
 	mat_mul(&mvp, proj, view);
 	t = g_sys->game_time_sec;
 	far_clp = g_sys->cur_weather.far_clp;
 	fog_st = g_sys->cur_weather.fog_st;
 	if (far_clp <= fog_st) {
 		far_clp = fog_st + 1.0f;
 	}
 	ar = g_sys->cur_weather.amb[0] / 255.0f * 1.2f;
 	ag = g_sys->cur_weather.amb[1] / 255.0f * 1.2f;
 	ab = g_sys->cur_weather.amb[2] / 255.0f * 1.2f;
 
 	for (i = 0; i < water_count; i++) {
 		for (j = 0; j < water_faces[i].num; j++) {
 			in.x = water_faces[i].x[j];
 			
 			wave_height = water_faces[i].h[j];
 			wave_factor = sinf(t * 1.5f + water_faces[i].x[j] * 0.05f + water_faces[i].y[j] * 0.05f);
 			dy = wave_factor * wave_height;
 
 			in.y = water_faces[i].z[j] + dy;
 			in.z = water_faces[i].y[j];
 			
 			mat_transform(&out, &w, &mvp, &in);
 			fog = (out.z - fog_st) / (far_clp - fog_st);
 			if (fog < 0.0f) {
 				fog = 0.0f;
 			} else if (fog > 1.0f) {
 				fog = 1.0f;
 			}
 			
 			flow_u = water_faces[i].u[j];
 			flow_v = water_faces[i].v[j];
 
 			u_tex = (water_faces[i].x[j] - water_faces[i].x[0]) * 0.01f + t * (flow_u - 0.015f) + dy * 0.05f;
 			v_tex = (water_faces[i].y[j] - water_faces[i].y[0]) * 0.01f + t * (flow_v - 0.015f) + dy * 0.05f;
 			
 			cv[j].x = out.x;
 			cv[j].y = out.y;
 			cv[j].z = out.z;
 			cv[j].w = w;
 			cv[j].u = u_tex;
 			cv[j].v = v_tex;
 			cv[j].r = ar;
 			cv[j].g = ag;
 			cv[j].b = ab;
 			cv[j].a = 1.0f;
 			cv[j].f = fog;
 		}
 		if (water_faces[i].num == 4) {
 			if (!(cv[0].w < 0.1f && cv[2].w < 0.1f && cv[1].w < 0.1f) && !(cv[0].w > far_clp && cv[2].w > far_clp && cv[1].w > far_clp)) {
 				clip_and_push_triangle(&cv[0], &cv[2], &cv[1], water_tex, 1, 0);
 			}
 			if (!(cv[2].w < 0.1f && cv[3].w < 0.1f && cv[1].w < 0.1f) && !(cv[2].w > far_clp && cv[3].w > far_clp && cv[1].w > far_clp)) {
 				clip_and_push_triangle(&cv[2], &cv[3], &cv[1], water_tex, 1, 0);
 			}
 		} else if (water_faces[i].num == 3) {
 			if (!(cv[0].w < 0.1f && cv[2].w < 0.1f && cv[1].w < 0.1f) && !(cv[0].w > far_clp && cv[2].w > far_clp && cv[1].w > far_clp)) {
 				clip_and_push_triangle(&cv[0], &cv[2], &cv[1], water_tex, 1, 0);
 			}
 		}
 	}
 	flush_render_list();
 }
 
 static void
 draw_ocean_sector(const struct mat4 *mvp, float x0, float x1, float z0, float z1, float height, float t, const struct texture *tex, int is_water)
 {
 	struct clip_vertex cv[4];
 	struct vec3 in, out;
 	float far_clp, fog_st, ar, ag, ab, w, fog, u_tex, v_tex;
 	float prelight_r, prelight_g, prelight_b;
 	float step = 500.0f;
 	float tx, tz, next_tx, next_tz;
 	float xs[4], zs[4];
 	int i;
 
 	far_clp = g_sys->cur_weather.far_clp;
 	fog_st = g_sys->cur_weather.fog_st;
 	if (far_clp <= fog_st) {
 		far_clp = fog_st + 1.0f;
 	}
 	ar = g_sys->cur_weather.amb[0] / 255.0f * 1.2f;
 	ag = g_sys->cur_weather.amb[1] / 255.0f * 1.2f;
 	ab = g_sys->cur_weather.amb[2] / 255.0f * 1.2f;
 
 	prelight_r = is_water ? 1.0f : 0.35f;
 	prelight_g = is_water ? 1.0f : 0.38f;
 	prelight_b = is_water ? 1.0f : 0.40f;
 
 	for (tx = floorf(x0 / step) * step; tx < x1; tx += step) {
 		next_tx = tx + step;
 		if (next_tx > x1) {
 			next_tx = x1;
 		}
 		for (tz = floorf(z0 / step) * step; tz < z1; tz += step) {
 			next_tz = tz + step;
 			if (next_tz > z1) {
 				next_tz = z1;
 			}
 
 			xs[0] = tx;      xs[1] = next_tx; xs[2] = next_tx; xs[3] = tx;
 			zs[0] = tz;      zs[1] = tz;      zs[2] = next_tz; zs[3] = next_tz;
 
 			for (i = 0; i < 4; i++) {
 				in.x = xs[i];
 				in.y = height;
 				in.z = zs[i];
 				mat_transform(&out, &w, mvp, &in);
 				fog = (out.z - fog_st) / (far_clp - fog_st);
 				if (fog < 0.0f) {
 					fog = 0.0f;
 				} else if (fog > 1.0f) {
 					fog = 1.0f;
 				}
 				u_tex = xs[i] * 0.01f;
 				v_tex = zs[i] * 0.01f;
 				if (is_water) {
 					u_tex -= t * 0.02f;
 					v_tex -= t * 0.02f;
 				}
 				cv[i] = (struct clip_vertex){
 					out.x, out.y, out.z, w, u_tex, v_tex,
 					ar * prelight_r, ag * prelight_g, ab * prelight_b,
 					1.0f, fog
 				};
 			}
 			if (!(cv[0].w < 0.1f && cv[2].w < 0.1f && cv[1].w < 0.1f) && !(cv[0].w > far_clp && cv[2].w > far_clp && cv[1].w > far_clp)) {
 				clip_and_push_triangle(&cv[0], &cv[2], &cv[1], tex, is_water, 0);
 			}
 			if (!(cv[0].w < 0.1f && cv[3].w < 0.1f && cv[2].w < 0.1f) && !(cv[0].w > far_clp && cv[3].w > far_clp && cv[2].w > far_clp)) {
 				clip_and_push_triangle(&cv[0], &cv[3], &cv[2], tex, is_water, 0);
 			}
 		}
 	}
 }
 
 static void
 draw_infinite_ocean(const struct mat4 *proj, const struct mat4 *view, float cam_x, float cam_z, float t)
 {
 	struct mat4 mvp;
 	float far_clp, b;
 	float n_x0, n_x1, n_z0, n_z1;
 	float s_x0, s_x1, s_z0, s_z1;
 	float w_x0, w_x1, w_z0, w_z1;
 	float e_x0, e_x1, e_z0, e_z1;
 
 	mat_mul(&mvp, proj, view);
 	far_clp = g_sys->cur_weather.far_clp;
 	b = 2970.0f;
 
 	n_x0 = cam_x - far_clp * 1.5f;
 	n_x1 = cam_x + far_clp * 1.5f;
 	n_z0 = fmaxf(b, cam_z - far_clp * 1.5f);
 	n_z1 = cam_z + far_clp * 1.5f;
 	if (n_z1 > n_z0) {
 		draw_ocean_sector(&mvp, n_x0, n_x1, n_z0, n_z1, -65.0f, t, sand_tex, 0);
 		draw_ocean_sector(&mvp, n_x0, n_x1, n_z0, n_z1, 0.0f, t, water_tex, 1);
 	}
 
 	s_x0 = cam_x - far_clp * 1.5f;
 	s_x1 = cam_x + far_clp * 1.5f;
 	s_z0 = cam_z - far_clp * 1.5f;
 	s_z1 = fminf(-b, cam_z + far_clp * 1.5f);
 	if (s_z1 > s_z0) {
 		draw_ocean_sector(&mvp, s_x0, s_x1, s_z0, s_z1, -65.0f, t, sand_tex, 0);
 		draw_ocean_sector(&mvp, s_x0, s_x1, s_z0, s_z1, 0.0f, t, water_tex, 1);
 	}
 
 	w_x0 = cam_x - far_clp * 1.5f;
 	w_x1 = fminf(-b, cam_x + far_clp * 1.5f);
 	w_z0 = fmaxf(-b, cam_z - far_clp * 1.5f);
 	w_z1 = fminf(b, cam_z + far_clp * 1.5f);
 	if (w_x1 > w_x0 && w_z1 > w_z0) {
 		draw_ocean_sector(&mvp, w_x0, w_x1, w_z0, w_z1, -65.0f, t, sand_tex, 0);
 		draw_ocean_sector(&mvp, w_x0, w_x1, w_z0, w_z1, 0.0f, t, water_tex, 1);
 	}
 
 	e_x0 = fmaxf(b, cam_x - far_clp * 1.5f);
 	e_x1 = cam_x + far_clp * 1.5f;
 	e_z0 = fmaxf(-b, cam_z - far_clp * 1.5f);
 	e_z1 = fminf(b, cam_z + far_clp * 1.5f);
 	if (e_x1 > e_x0 && e_z1 > e_z0) {
 		draw_ocean_sector(&mvp, e_x0, e_x1, e_z0, e_z1, -65.0f, t, sand_tex, 0);
 		draw_ocean_sector(&mvp, e_x0, e_x1, e_z0, e_z1, 0.0f, t, water_tex, 1);
 	}
 	flush_render_list();
 }
 
 static void
 scene_load(struct asset_cache *cache, const uint8_t *data, size_t sz)
 {
 	char *buf, *line, *next_line, *p;
 	int in_inst, id, interior, idx, gx, gz;
 	char name[NAME_SZ];
 	float px, py, pz, qx, qy, qz, qw, w;
 	struct mesh *m;
 	struct mat4 rot, trans, sa2gl;
 	struct vec3 wc;
 	struct grid_cell *c;
 	int lod, time_on, time_off;
 
 	buf = malloc(sz + 1);
 	if (buf == NULL) {
 		return;
 	}
 	memcpy(buf, data, sz);
 	buf[sz] = '\0';
 
 	line = buf;
 	in_inst = 0;
 	while (line && *line) {
 		next_line = strchr(line, '\n');
 		if (next_line) {
 			*next_line = '\0';
 			next_line++;
 		}
 		p = line;
 		while (*p == ' ' || *p == '\t') {
 			p++;
 		}
 		if (*p == '\0' || *p == '#') {
 			line = next_line;
 			continue;
 		}
 		if (strncasecmp(p, "inst", 4) == 0 || strncasecmp(p, "tobj", 4) == 0) {
 			in_inst = 1;
 			line = next_line;
 			continue;
 		}
 		if (strncasecmp(p, "end", 3) == 0) {
 			in_inst = 0;
 			line = next_line;
 			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) {
 				char *end_ptr = name + strlen(name) - 1;
 				while (end_ptr > name && (*end_ptr == ' ' || *end_ptr == '\t')) {
 					*end_ptr = '\0';
 					end_ptr--;
 				}
 				for (p = name; *p; p++) {
 					*p = tolower((unsigned char)*p);
 				}
 
 				if (scene_inst_count >= scene_inst_capacity) {
 					scene_inst_capacity = scene_inst_capacity == 0 ? 512 : scene_inst_capacity * 2;
 					scene_meshes = realloc(scene_meshes, scene_inst_capacity * sizeof(struct mesh *));
 					g_transforms.pos_x = realloc(g_transforms.pos_x, scene_inst_capacity * sizeof(float));
 					g_transforms.pos_y = realloc(g_transforms.pos_y, scene_inst_capacity * sizeof(float));
 					g_transforms.pos_z = realloc(g_transforms.pos_z, scene_inst_capacity * sizeof(float));
 					g_transforms.rot_qx = realloc(g_transforms.rot_qx, scene_inst_capacity * sizeof(float));
 					g_transforms.rot_qy = realloc(g_transforms.rot_qy, scene_inst_capacity * sizeof(float));
 					g_transforms.rot_qz = realloc(g_transforms.rot_qz, scene_inst_capacity * sizeof(float));
 					g_transforms.rot_qw = realloc(g_transforms.rot_qw, scene_inst_capacity * sizeof(float));
 					g_transforms.world_matrices = realloc(g_transforms.world_matrices, scene_inst_capacity * sizeof(struct mat4));
 					g_transforms.sphere_cx = realloc(g_transforms.sphere_cx, scene_inst_capacity * sizeof(float));
 					g_transforms.sphere_cy = realloc(g_transforms.sphere_cy, scene_inst_capacity * sizeof(float));
 					g_transforms.sphere_cz = realloc(g_transforms.sphere_cz, scene_inst_capacity * sizeof(float));
 					g_transforms.sphere_r = realloc(g_transforms.sphere_r, scene_inst_capacity * sizeof(float));
 					g_transforms.time_on = realloc(g_transforms.time_on, scene_inst_capacity * sizeof(int16_t));
 					g_transforms.time_off = realloc(g_transforms.time_off, scene_inst_capacity * sizeof(int16_t));
 				}
 
 				m = cache_get_mesh(cache, name);
 				if (m) {
 					idx = scene_inst_count++;
 					scene_meshes[idx] = m;
 					g_transforms.pos_x[idx] = px;
 					g_transforms.pos_y[idx] = py;
 					g_transforms.pos_z[idx] = pz;
 					g_transforms.rot_qx[idx] = qx;
 					g_transforms.rot_qy[idx] = qy;
 					g_transforms.rot_qz[idx] = qz;
 					g_transforms.rot_qw[idx] = qw;
 					
 					g_transforms.time_on[idx] = (time_on >= 0) ? time_on : 0;
 					g_transforms.time_off[idx] = (time_off >= 0) ? time_off : 0;
 
 					mat_from_quat(&rot, qx, qy, qz, qw);
 					mat_translate(&trans, px, py, pz);
 					mat_mul(&g_transforms.world_matrices[idx], &trans, &rot);
 
 					memset(&sa2gl, 0, sizeof(sa2gl));
 					sa2gl.m[0][0] = sa2gl.m[1][2] = sa2gl.m[2][1] = sa2gl.m[3][3] = 1.0f;
 					mat_mul(&g_transforms.world_matrices[idx], &sa2gl, &g_transforms.world_matrices[idx]);
 
 					mat_transform(&wc, &w, &g_transforms.world_matrices[idx], &(struct vec3){m->spr_x, m->spr_y, m->spr_z});
 					g_transforms.sphere_cx[idx] = wc.x;
 					g_transforms.sphere_cy[idx] = wc.y;
 					g_transforms.sphere_cz[idx] = wc.z;
 					g_transforms.sphere_r[idx] = m->spr_r;
 
 					gx = (int)((wc.x - MAP_MIN) / ((MAP_MAX - MAP_MIN) / GRID_SZ));
 					gz = (int)((wc.z - MAP_MIN) / ((MAP_MAX - MAP_MIN) / GRID_SZ));
 					if (gx < 0) gx = 0; if (gx >= GRID_SZ) gx = GRID_SZ - 1;
 					if (gz < 0) gz = 0; if (gz >= GRID_SZ) gz = GRID_SZ - 1;
 
 					c = &scene_grid[gx][gz];
 					if (c->count >= c->cap) {
 						c->cap = c->cap == 0 ? 16 : c->cap * 2;
 						c->ids = realloc(c->ids, c->cap * sizeof(int));
 					}
 					c->ids[c->count++] = idx;
 				}
 			}
 		}
 		line = next_line;
 	}
 	free(buf);
 }
 
 int
 main(int argc, char *argv[])
 {
 	struct sys_gfx g;
 	struct mat4 view;
 	struct timespec ts, t_start, t_end;
 	XEvent sa_event;
 	KeySym sym;
 	float player_x = 2490.0f, player_y = 13.5f, player_z = -1660.0f;
 	float player_vy = 0.0f;
 	float player_yaw = 0.0f;
 	float cam_x, cam_y, cam_z;
 	float cam_yaw = -1.57f, cam_pitch = 0.2f, cam_dist = 3.5f;
 	float move_forward, move_strafe, move_x, move_z, move_len;
 	float speed, ground_y, dt, net_timer = 0.0f;
 	int running, tar_fd, m_dx, m_dy, gz, gx, last_mx, last_my, i;
 	int is_grounded = 0;
 	struct stat st;
 	size_t ipl_sz = 0, water_sz = 0, tc_sz = 0, col_sz = 0;
 	const uint8_t *ipl_data, *water_data, *tc_data, *col_data;
 	char srv_ip[64] = "127.0.0.1";
 	int srv_port = NET_PORT;
 	char nick[24] = "player";
 	char *colon;
 	KeyCode code;
 
 	if (argc < 3) {
 		fprintf(stderr, "usage: %s <ip:port> <nick>\n", argv[0]);
 		return (1);
 	}
 
 	strncpy(srv_ip, argv[1], sizeof(srv_ip) - 1);
 	srv_ip[sizeof(srv_ip) - 1] = '\0';
 	colon = strchr(srv_ip, ':');
 	if (colon) {
 		*colon = '\0';
 		srv_port = atoi(colon + 1);
 	}
 
 	strncpy(nick, argv[2], sizeof(nick) - 1);
 	nick[sizeof(nick) - 1] = '\0';
 
 	g_sys = &g;
 	gfx_init(&g);
 	g_cache = calloc(1, sizeof(struct asset_cache));
 	g.game_time_sec = 0.0f;
 	g.game_time_hours = 12.0f;
 	ts.tv_sec = 0;
 	ts.tv_nsec = 16666666;
 
 	tar_fd = open("assets.tar", O_RDONLY);
 	if (tar_fd < 0) {
 		err(1, "failed to open assets.tar");
 	}
 	fstat(tar_fd, &st);
 	g_tar_size = st.st_size;
 	g_tar_mapped = mmap(NULL, g_tar_size, PROT_READ, MAP_PRIVATE, tar_fd, 0);
 	if (g_tar_mapped == MAP_FAILED) {
 		err(1, "failed to mmap assets.tar");
 	}
 
 	tar_build_index();
 
 	ipl_data = tar_lookup("assets/map.ipl", &ipl_sz);
 	if (ipl_data) {
 		scene_load(g_cache, ipl_data, ipl_sz);
 	}
 
 	water_data = tar_lookup("assets/water.bin", &water_sz);
 	if (water_data && water_sz > 0) {
 		memcpy(&water_count, water_data, 4);
 		water_faces = malloc(water_count * sizeof(struct water_face));
 		memcpy(water_faces, water_data + 4, water_count * sizeof(struct water_face));
 	}
 
 	tc_data = tar_lookup("assets/timecyc.bin", &tc_sz);
 	if (tc_data && tc_sz > 0) {
 		memcpy(&g.num_weathers, tc_data, 4);
 		if (g.num_weathers > 32) {
 			g.num_weathers = 32;
 		}
 		memcpy(g.weathers, tc_data + 4, g.num_weathers * 8 * sizeof(struct timecyc_entry));
 	}
 
 	col_data = tar_lookup("assets/collision.bin", &col_sz);
 	if (col_data && col_sz > 0) {
 		const uint8_t *ptr = col_data;
 		for (gz = 0; gz < GRID_SZ; gz++) {
 			for (gx = 0; gx < GRID_SZ; gx++) {
 				uint32_t cnt;
 				memcpy(&cnt, ptr, sizeof(uint32_t));
 				ptr += sizeof(uint32_t);
 				g_col_grid[gx][gz].count = cnt;
 				if (cnt > 0) {
 					g_col_grid[gx][gz].tris = (const struct col_triangle *)ptr;
 					ptr += cnt * sizeof(struct col_triangle);
 				} else {
 					g_col_grid[gx][gz].tris = NULL;
 				}
 			}
 		}
 	}
 
 	water_tex = cache_get_tex(g_cache, "waterclear256");
 	sand_tex = cache_get_tex(g_cache, "sand256");
 
 	net_init(srv_ip, srv_port, nick);
 
 	XMapWindow(g.dpy, g.win);
 	clock_gettime(CLOCK_MONOTONIC, &t_start);
 	XWarpPointer(g.dpy, None, g.win, 0, 0, 0, 0, WIDTH / 2, HEIGHT / 2);
 	XGrabPointer(g.dpy, g.win, True, PointerMotionMask | ButtonPressMask | ButtonReleaseMask,
 	    GrabModeAsync, GrabModeAsync, g.win, None, CurrentTime);
 	XSync(g.dpy, False);
 
 	running = 1;
 	while (running) {
 		last_mx = WIDTH / 2;
 		last_my = HEIGHT / 2;
 		m_dx = 0;
 		m_dy = 0;
 
 		while (XPending(g.dpy)) {
 			XNextEvent(g.dpy, &sa_event);
 			if (XFilterEvent(&sa_event, None)) {
 				continue;
 			}
 			if (sa_event.type == ClientMessage &&
 			    (Atom)sa_event.xclient.data.l[0] == g.wm_delete) {
 				running = 0;
 			}
 			if (sa_event.type == FocusIn && !g.in_chat && !g.menu_open) {
 				XGrabPointer(g.dpy, g.win, True,
 				    PointerMotionMask | ButtonPressMask | ButtonReleaseMask,
 				    GrabModeAsync, GrabModeAsync, g.win, None, CurrentTime);
 			}
 			if (sa_event.type == FocusOut) {
 				memset(g.keys, 0, sizeof(g.keys));
 			}
 			if (sa_event.type == MotionNotify && !g.menu_open) {
 				last_mx = sa_event.xmotion.x;
 				last_my = sa_event.xmotion.y;
 			}
 			if (sa_event.type == KeyPress) {
 				code = sa_event.xkey.keycode;
 				sym = XLookupKeysym(&sa_event.xkey, 0);
 
 				if (code == g.key_esc || sym == XK_Escape) {
 					if (g.in_chat) {
 						g.in_chat = 0;
 						XGrabPointer(g.dpy, g.win, True,
 						    PointerMotionMask | ButtonPressMask | ButtonReleaseMask,
 						    GrabModeAsync, GrabModeAsync, g.win, None, CurrentTime);
 					} else {
 						g.menu_open = !g.menu_open;
 						if (g.menu_open) {
 							XUngrabPointer(g.dpy, CurrentTime);
 							memset(g.keys, 0, sizeof(g.keys));
 						} else {
 							XWarpPointer(g.dpy, None, g.win, 0, 0, 0, 0,
 							    WIDTH / 2, HEIGHT / 2);
 							XGrabPointer(g.dpy, g.win, True,
 							    PointerMotionMask | ButtonPressMask | ButtonReleaseMask,
 							    GrabModeAsync, GrabModeAsync, g.win, None, CurrentTime);
 						}
 					}
 				} else if (sym == XK_F5) {
 					g.show_debug = !g.show_debug;
 				}
 
 				if (g.in_chat) {
 					char str[32];
 					Status status;
 					int n = 0;
 
 					if (g_sys->ic) {
 						n = Xutf8LookupString(g_sys->ic, &sa_event.xkey, str,
 						    sizeof(str), &sym, &status);
 					} else {
 						n = XLookupString(&sa_event.xkey, str, sizeof(str), &sym, NULL);
 					}
 
 					if (sym == XK_Return) {
 						if (strcmp(g.chat_buf, "/q") == 0 ||
 						    strcmp(g.chat_buf, "/quit") == 0) {
 							running = 0;
 						} else if (strncmp(g.chat_buf, "/st ", 4) == 0) {
 							g.game_time_hours = atof(g.chat_buf + 4);
 						} else if (strncmp(g.chat_buf, "/sw ", 4) == 0) {
 							g.game_weather = atoi(g.chat_buf + 4);
 						} else if (strncmp(g.chat_buf, "/sd ", 4) == 0) {
 							g.far_clip_override = atof(g.chat_buf + 4);
 						} else if (strncmp(g.chat_buf, "/skin ", 6) == 0) {
 							int new_id = atoi(g.chat_buf + 6);
 							if (ped_lookup_model(new_id) != NULL) {
 								active_skin_id = new_id;
 							}
 						} else if (g.chat_buf[0] != '/' && g.chat_len > 0) {
 							net_send_chat(g.chat_buf);
 						}
 						g.in_chat = 0;
 						XGrabPointer(g.dpy, g.win, True,
 						    PointerMotionMask | ButtonPressMask | ButtonReleaseMask,
 						    GrabModeAsync, GrabModeAsync, g.win, None, CurrentTime);
 					} else if (sym == XK_BackSpace) {
 						if (g.chat_len > 0) {
 							while (g.chat_len > 0) {
 								g.chat_len--;
 								if ((g.chat_buf[g.chat_len] & 0xC0) != 0x80) {
 									break;
 								}
 							}
 							g.chat_buf[g.chat_len] = '\0';
 						}
 					} else if (n > 0 && (unsigned char)str[0] >= 32 &&
 					    str[0] != 127 && g.chat_len + n < 127) {
 						memcpy(&g.chat_buf[g.chat_len], str, n);
 						g.chat_len += n;
 						g.chat_buf[g.chat_len] = '\0';
 					}
 				} else if (!g.menu_open) {
 					if (code == g.key_w || sym == XK_w || sym == XK_W) g.keys['w'] = 1;
 					else if (code == g.key_a || sym == XK_a || sym == XK_A) g.keys['a'] = 1;
 					else if (code == g.key_s || sym == XK_s || sym == XK_S) g.keys['s'] = 1;
 					else if (code == g.key_d || sym == XK_d || sym == XK_D) g.keys['d'] = 1;
 					else if (code == g.key_space || sym == XK_space) g.keys[' '] = 1;
 					else if (code == g.key_t || sym == XK_t || sym == XK_T) {
 						g.in_chat = 1;
 						g.chat_len = 0;
 						g.chat_buf[0] = '\0';
 						XUngrabPointer(g.dpy, CurrentTime);
 					}
 				}
 			}
 			if (sa_event.type == KeyRelease && !g.menu_open) {
 				code = sa_event.xkey.keycode;
 				sym = XLookupKeysym(&sa_event.xkey, 0);
 
 				if (code == g.key_w || sym == XK_w || sym == XK_W) g.keys['w'] = 0;
 				else if (code == g.key_a || sym == XK_a || sym == XK_A) g.keys['a'] = 0;
 				else if (code == g.key_s || sym == XK_s || sym == XK_S) g.keys['s'] = 0;
 				else if (code == g.key_d || sym == XK_d || sym == XK_D) g.keys['d'] = 0;
 				else if (code == g.key_space || sym == XK_space) g.keys[' '] = 0;
 			}
 		}
 
 		clock_gettime(CLOCK_MONOTONIC, &t_end);
 		dt = (t_end.tv_sec - t_start.tv_sec) + (t_end.tv_nsec - t_start.tv_nsec) * 1e-9f;
 		t_start = t_end;
 		if (dt > 0.1f) dt = 0.1f;
 		if (dt < 0.001f) dt = 0.001f;
 
 		double cur_time = t_end.tv_sec + t_end.tv_nsec * 1e-9;
 
 		g.game_time_sec += dt;
 		g.game_time_hours += dt * (24.0f / 1440.0f);
 		if (g.game_time_hours >= 24.0f) {
 			g.game_time_hours -= 24.0f;
 		}
 
 		for (i = 0; i < chat_log_count; i++) {
 			if (chat_log[i].timer > 0.0f) {
 				chat_log[i].timer -= dt;
 			}
 		}
 
 		net_poll(&g, cur_time);
 		net_interpolate(cur_time);
 
 		net_timer += dt;
 		if (net_timer >= 0.033f) {
 			net_send_sync(player_x, player_y, player_z, player_yaw);
 			net_timer = 0.0f;
 		}
 
 		g.stats_timer += dt;
 		if (g.stats_timer >= 1.0f) {
 			g.pkts_in_sec = g.pkts_in;
 			g.pkts_out_sec = g.pkts_out;
 			g.pkts_in = 0;
 			g.pkts_out = 0;
 			g.stats_timer = 0.0f;
 		}
 		g.fps = g.fps * 0.90f + (1.0f / dt) * 0.10f;
 
 		move_forward = 0.0f;
 		move_strafe = 0.0f;
 
 		if (!g.in_chat && !g.menu_open) {
 			m_dx = last_mx - WIDTH / 2;
 			m_dy = last_my - HEIGHT / 2;
 			if (m_dx != 0 || m_dy != 0) {
 				XWarpPointer(g.dpy, None, g.win, 0, 0, 0, 0, WIDTH / 2, HEIGHT / 2);
 				XFlush(g.dpy);
 			}
 
 			cam_yaw += m_dx * 0.003f;
 			cam_pitch -= m_dy * 0.003f;
 			if (cam_pitch > 1.2f) {
 				cam_pitch = 1.2f;
 			}
 			if (cam_pitch < -1.2f) {
 				cam_pitch = -1.2f;
 			}
 
 			if (g.keys['w']) move_forward += 1.0f;
 			if (g.keys['s']) move_forward -= 1.0f;
 			if (g.keys['d']) move_strafe += 1.0f;
 			if (g.keys['a']) move_strafe -= 1.0f;
 		}
 
 		move_x = sinf(cam_yaw) * move_forward + cosf(cam_yaw) * move_strafe;
 		move_z = cosf(cam_yaw) * move_forward - sinf(cam_yaw) * move_strafe;
 		move_len = sqrtf(move_x * move_x + move_z * move_z);
 
 		if (move_len > 0.001f) {
 			move_x /= move_len;
 			move_z /= move_len;
 			player_yaw = atan2f(move_x, move_z);
 			speed = 6.0f;
 			move_and_slide(&player_x, player_y, &player_z,
 			    move_x * speed, move_z * speed, dt);
 		}
 
 		ground_y = get_ground_height(player_x, player_z, player_y);
 
 		if (ground_y > -900.0f && player_y <= ground_y + 0.1f && player_vy <= 0.0f) {
 			player_y = ground_y;
 			player_vy = 0.0f;
 			is_grounded = 1;
 		} else {
 			is_grounded = 0;
 		}
 
 		if (g.keys[' '] && is_grounded && !g.in_chat && !g.menu_open) {
 			player_vy = JUMP_FORCE;
 			player_y += 0.05f;
 			is_grounded = 0;
 		}
 
 		if (!is_grounded) {
 			player_vy -= GRAVITY * dt;
 			if (player_vy < -TERMINAL_VEL) {
 				player_vy = -TERMINAL_VEL;
 			}
 
 			if (player_vy > 0.0f) {
 				float ceil_y = get_ceiling_height(player_x, player_z, player_y);
 				if (ceil_y < 900.0f && (player_y + 1.85f + player_vy * dt) >= ceil_y) {
 					player_y = ceil_y - 1.85f;
 					player_vy = 0.0f;
 				} else {
 					player_y += player_vy * dt;
 				}
 			} else {
 				player_y += player_vy * dt;
 			}
 
 			if (player_vy <= 0.0f && ground_y > -900.0f && player_y <= ground_y) {
 				player_y = ground_y;
 				player_vy = 0.0f;
 				is_grounded = 1;
 			}
 		}
 
 		cam_x = player_x - sinf(cam_yaw) * cosf(cam_pitch) * cam_dist;
 		cam_y = player_y + 1.2f - sinf(cam_pitch) * cam_dist;
 		cam_z = player_z - cosf(cam_yaw) * cosf(cam_pitch) * cam_dist;
 
 		update_weather(&g);
 		mat_projection(&g.proj, 60.0f, (float)WIDTH / HEIGHT, 0.1f, g.cur_weather.far_clp);
 		memset(g.zbuffer, 0, WIDTH * HEIGHT * sizeof(float));
 
 		mat_view(&view, cam_x, cam_y, cam_z, cam_yaw, cam_pitch);
 		draw_scene(&g, &g.proj, &view, cam_x, cam_y, cam_z,
 		    player_x, player_y, player_z, player_yaw);
 		draw_water(&g.proj, &view);
 		draw_infinite_ocean(&g.proj, &view, cam_x, cam_z, g.game_time_sec);
 		gfx_present(&g, player_x, player_y, player_z);
 	}
 
 	net_send_leave();
 	munmap(g_tar_mapped, g_tar_size);
 	close(tar_fd);
 	gfx_cleanup(&g);
 	return (0);
 }