medfall

clipmap.cc (35529B)

---

 #include "intrinsics.h"
 #include "int_conversions.h"
 #include "linear_algebra.h"
 #include "aabb.h"
 #include "game.h"
 #include "renderer.h"
 #include "shaders.h"
 #include "immediate.h"
 #include "text_renderer.h"
 #include "decompress_bc.h"
 #include "gl.h"
 #include "obj.h"
 #include "skybox.h"
 #include "stream.h"
 #include "hashtable.h"
 #include "pool.h"
 #include "profiler.h"
 #include "platform_network.h"
 
 #include "libs/lz4/lz4.h"
 
 struct ClipmapTerrain {
 	struct {
 		Mesh tile;
 		Mesh empty_tile;
 		Mesh filler;
 		Mesh trim;
 		Mesh cross;
 		Mesh seam;
 		Mesh skirt;
 		Texture heightmap;
 		Texture normalmap;
 		Texture horizonmap;
 	} gpu;
 
 	array2d< u16 > heightmap;
 	QuadTree quadtree;
 };
 
 static const float EYE_HEIGHT = 1.8f;
 
 static ClipmapTerrain clipmap;
 
 struct Fireball {
 	v3 pos;
 	v3 velocity;
 };
 
 struct Explosion {
 	v3 pos;
 	double created_at;
 };
 
 struct Player {
 	u64 sid;
 	v3 pos;
 };
 
 static FB msaa_fb;
 
 static UDPSocket sock;
 static NetAddress server_addr;
 static u64 sid;
 static double last_connection_attempt = -5.0; // TODO
 static bool connected = false;
 
 static Pool< Fireball, 1024 > fireballs;
 static Pool< Explosion, 1024 > explosions;
 
 static Pool< Player, 1024 > players;
 static HashTable< Player *, 1024 * 2 > sid_to_player;
 
 static VB trees_instance_data;
 static u32 num_trees;
 static Mesh tree_mesh;
 
 static constexpr u32 TILE_RESOLUTION = 48;
 static constexpr u32 PATCH_VERT_RESOLUTION = TILE_RESOLUTION + 1;
 static constexpr u32 CLIPMAP_RESOLUTION = TILE_RESOLUTION * 4 + 1;
 static constexpr u32 CLIPMAP_VERT_RESOLUTION = CLIPMAP_RESOLUTION + 1;
 static constexpr u32 NUM_CLIPMAP_LEVELS = 7;
 
 static void load_trees( MemoryArena * arena ) {
 	MEMARENA_SCOPED_CHECKPOINT( arena );
 
 	size_t compressed_len;
 	u8 * compressed_trees = file_get_contents( "terrains/gta16.png.parts/trees.lz4", &compressed_len );
 
 	// TODO: don't hardcode this!
 	array< v3 > trees = memarena_push_array( arena, v3, 300000 );
 	int decompressed_len = LZ4_decompress_safe( ( char * ) compressed_trees, ( char * ) trees.ptr(), compressed_len, trees.num_bytes() );
 	ASSERT( decompressed_len > 0 );
 
 	free( compressed_trees );
 
 	num_trees = decompressed_len / sizeof( v3 );
 	array< m4 > tree_matrices = memarena_push_array( arena, m4, num_trees );
 
 	m4 rot = m4_rotx( deg_to_rad( 90 ) );
 	for( size_t i = 0; i < num_trees; i++ ) {
 		tree_matrices[ i ] = m4_translation( trees[ i ] ) * rot;
 	}
 
 	trees_instance_data = renderer_new_vb( tree_matrices );
 
 	tree_mesh = load_obj( "models/trees/PineTree.obj", arena );
 }
 
 static size_t patch2d( size_t x, size_t y ) {
 	return y * PATCH_VERT_RESOLUTION + x;
 }
 
 static void file_get_contents_and_decompress( const char * path, u8 * decompressed, size_t decompressed_size ) {
 	size_t compressed_size;
 	u8 * compressed = file_get_contents( path, &compressed_size );
 	int ok = LZ4_decompress_safe( ( const char * ) compressed, ( char * ) decompressed, compressed_size, decompressed_size );
 	ASSERT( ok > 0 && size_t( ok ) == decompressed_size );
 	free( compressed );
 }
 
 struct RGBA {
 	u8 r, g, b, a;
 };
 
 GAME_INIT( game_init ) {
 	net_init();
 
 	msaa_fb = { };
 
 	// load quadtree
 	{
 		clipmap.heightmap = alloc_array2d< u16 >( &mem->persistent_arena, 4096, 4096 );
 
 		array< QuadTreeNode > nodes = alloc_array< QuadTreeNode >( &mem->persistent_arena, 4096 * 4096 / 3 );
 		file_get_contents_and_decompress( "terrains/gta16.png.parts/quadtree.lz4", ( u8 * ) nodes.ptr(), nodes.num_bytes() );
 
 		clipmap.quadtree.nodes = nodes;
 		clipmap.quadtree.heightmap = clipmap.heightmap;
 	}
 
 	// load heightmap
 	{
 		MEMARENA_SCOPED_CHECKPOINT( &mem->persistent_arena );
 
 		u8 * heightmap_data = memarena_push_size( &mem->persistent_arena, 4096 * 4096 );
 		file_get_contents_and_decompress( "terrains/gta16.png.parts/heightmap.bc5.lz4", heightmap_data, 4096 * 4096 );
 
 		TextureConfig texture_config;
 		texture_config.width = 4096;
 		texture_config.height = 4096;
 		texture_config.data = heightmap_data;
 		texture_config.format = TEXFMT_BC5;
 		texture_config.wrap = TEXWRAP_BORDER;
 		texture_config.border_colour = v4( 0 );
 		clipmap.gpu.heightmap = renderer_new_texture( texture_config );
 
 		bc5_to_heightmap( &mem->persistent_arena, clipmap.heightmap, heightmap_data );
 	}
 
 	// load normalmap
 	{
 		MEMARENA_SCOPED_CHECKPOINT( &mem->persistent_arena );
 
 		u8 * normalmap_data = memarena_push_size( &mem->persistent_arena, 4096 * 4096 );
 		file_get_contents_and_decompress( "terrains/gta16.png.parts/normalmap.bc5.lz4", normalmap_data, 4096 * 4096 );
 
 		TextureConfig texture_config;
 		texture_config.width = 4096;
 		texture_config.height = 4096;
 		texture_config.data = normalmap_data;
 		texture_config.format = TEXFMT_BC5;
 		texture_config.wrap = TEXWRAP_BORDER;
 		texture_config.border_colour = v4( 0.5f );
 		clipmap.gpu.normalmap = renderer_new_texture( texture_config );
 	}
 
 	// load horizonmap
 	{
 		MEMARENA_SCOPED_CHECKPOINT( &mem->persistent_arena );
 
 		u8 * horizonmap_data = memarena_push_size( &mem->persistent_arena, 4096 * 4096 / 2 );
 		file_get_contents_and_decompress( "terrains/gta16.png.parts/horizonmap.bc4.lz4", horizonmap_data, 4096 * 4096 / 2 );
 
 		TextureConfig texture_config;
 		texture_config.width = 4096;
 		texture_config.height = 4096;
 		texture_config.data = horizonmap_data;
 		texture_config.format = TEXFMT_BC4;
 		texture_config.wrap = TEXWRAP_BORDER;
 		texture_config.border_colour = v4( 0 );
 		clipmap.gpu.horizonmap = renderer_new_texture( texture_config );
 	}
 
 	// generate tile mesh
 	{
 		MEMARENA_SCOPED_CHECKPOINT( &mem->persistent_arena );
 
 		array< v3 > vertices = alloc_array< v3 >( &mem->persistent_arena, PATCH_VERT_RESOLUTION * PATCH_VERT_RESOLUTION );
 		size_t n = 0;
 
 		for( u32 y = 0; y < PATCH_VERT_RESOLUTION; y++ ) {
 			for( u32 x = 0; x < PATCH_VERT_RESOLUTION; x++ ) {
 				vertices[ n++ ] = v3( x, y, 0 );
 			}
 		}
 
 		ASSERT( n == vertices.n );
 
 		array< u32 > indices = alloc_array< u32 >( &mem->persistent_arena, TILE_RESOLUTION * TILE_RESOLUTION * 6 );
 		n = 0;
 
 		for( u32 y = 0; y < TILE_RESOLUTION; y++ ) {
 			for( u32 x = 0; x < TILE_RESOLUTION; x++ ) {
 				indices[ n++ ] = patch2d( x, y );
 				indices[ n++ ] = patch2d( x + 1, y + 1 );
 				indices[ n++ ] = patch2d( x, y + 1 );
 
 				indices[ n++ ] = patch2d( x, y );
 				indices[ n++ ] = patch2d( x + 1, y );
 				indices[ n++ ] = patch2d( x + 1, y + 1 );
 			}
 		}
 
 		ASSERT( n == indices.n );
 
 		MeshConfig mesh_config;
 		mesh_config.positions = renderer_new_vb( vertices );
 		mesh_config.indices = renderer_new_ib( indices );
 		mesh_config.num_vertices = indices.n;
 		clipmap.gpu.tile = renderer_new_mesh( mesh_config );
 	}
 
 	// generate empty tile mesh
 	{
 		MEMARENA_SCOPED_CHECKPOINT( &mem->persistent_arena );
 
 		array< v3 > vertices = alloc_array< v3 >( &mem->persistent_arena, TILE_RESOLUTION * 4 + 1 );
 
 		// vertices[ 0 ] is the centre of the fan
 		vertices[ 0 ] = v3( v2( TILE_RESOLUTION / 2.0f ), 0 );
 
 		for( u32 i = 0; i < TILE_RESOLUTION; i++ ) {
 			vertices[ i + 1 + 0 * TILE_RESOLUTION ] = v3( i, 0, 0 );
 			vertices[ i + 1 + 1 * TILE_RESOLUTION ] = v3( TILE_RESOLUTION, i, 0 );
 			vertices[ i + 1 + 2 * TILE_RESOLUTION ] = v3( TILE_RESOLUTION - i, TILE_RESOLUTION, 0 );
 			vertices[ i + 1 + 3 * TILE_RESOLUTION ] = v3( 0, TILE_RESOLUTION - i, 0 );
 		}
 
 		array< u32 > indices = alloc_array< u32 >( &mem->persistent_arena, TILE_RESOLUTION * 12 );
 
 		for( u32 i = 0; i < TILE_RESOLUTION * 4; i++ ) {
 			indices[ i * 3 + 0 ] = 0;
 			indices[ i * 3 + 1 ] = i + 1;
 			indices[ i * 3 + 2 ] = i + 2;
 		}
 
 		// make the last triangle wrap around
 		indices[ indices.n - 1 ] = 1;
 
 		MeshConfig mesh_config;
 		mesh_config.positions = renderer_new_vb( vertices );
 		mesh_config.indices = renderer_new_ib( indices );
 		mesh_config.num_vertices = indices.n;
 		clipmap.gpu.empty_tile = renderer_new_mesh( mesh_config );
 	}
 
 	// generate filler mesh
 	{
 		MEMARENA_SCOPED_CHECKPOINT( &mem->persistent_arena );
 
 		array< v3 > vertices = alloc_array< v3 >( &mem->persistent_arena, PATCH_VERT_RESOLUTION * 8 );
 		size_t n = 0;
 		u32 offset = TILE_RESOLUTION;
 
 		for( u32 i = 0; i < PATCH_VERT_RESOLUTION; i++ ) {
 			vertices[ n++ ] = v3( offset + i + 1, 0, 0 );
 			vertices[ n++ ] = v3( offset + i + 1, 1, 0 );
 		}
 
 		for( u32 i = 0; i < PATCH_VERT_RESOLUTION; i++ ) {
 			vertices[ n++ ] = v3( 1, offset + i + 1, 0 );
 			vertices[ n++ ] = v3( 0, offset + i + 1, 0 );
 		}
 
 		for( u32 i = 0; i < PATCH_VERT_RESOLUTION; i++ ) {
 			vertices[ n++ ] = v3( -float( offset + i ), 1, 0 );
 			vertices[ n++ ] = v3( -float( offset + i ), 0, 0 );
 		}
 
 		for( u32 i = 0; i < PATCH_VERT_RESOLUTION; i++ ) {
 			vertices[ n++ ] = v3( 0, -float( offset + i ), 0 );
 			vertices[ n++ ] = v3( 1, -float( offset + i ), 0 );
 		}
 
 		ASSERT( n == vertices.n );
 
 		array< u32 > indices = alloc_array< u32 >( &mem->persistent_arena, TILE_RESOLUTION * 24 );
 		n = 0;
 
 		for( u32 i = 0; i < TILE_RESOLUTION * 4; i++ ) {
 			// the arms shouldn't be connected to each other
 			u32 arm = i / TILE_RESOLUTION;
 
 			u32 bl = ( arm + i ) * 2 + 0;
 			u32 br = ( arm + i ) * 2 + 1;
 			u32 tl = ( arm + i ) * 2 + 2;
 			u32 tr = ( arm + i ) * 2 + 3;
 
 			if( arm % 2 == 0 ) {
 				indices[ n++ ] = br;
 				indices[ n++ ] = bl;
 				indices[ n++ ] = tr;
 				indices[ n++ ] = bl;
 				indices[ n++ ] = tl;
 				indices[ n++ ] = tr;
 			}
 			else {
 				indices[ n++ ] = br;
 				indices[ n++ ] = bl;
 				indices[ n++ ] = tl;
 				indices[ n++ ] = br;
 				indices[ n++ ] = tl;
 				indices[ n++ ] = tr;
 			}
 		}
 
 		ASSERT( n == indices.n );
 
 		MeshConfig mesh_config;
 		mesh_config.positions = renderer_new_vb( vertices );
 		mesh_config.indices = renderer_new_ib( indices );
 		mesh_config.num_vertices = indices.n;
 		clipmap.gpu.filler = renderer_new_mesh( mesh_config );
 	}
 
 	// generate trim mesh
 	{
 		MEMARENA_SCOPED_CHECKPOINT( &mem->persistent_arena );
 
 		array< v3 > vertices = alloc_array< v3 >( &mem->persistent_arena, ( CLIPMAP_VERT_RESOLUTION * 2 + 1 ) * 2 );
 		size_t n = 0;
 
 		// vertical part of L
 		for( u32 i = 0; i < CLIPMAP_VERT_RESOLUTION + 1; i++ ) {
 			vertices[ n++ ] = v3( 0, CLIPMAP_VERT_RESOLUTION - i, 0 );
 			vertices[ n++ ] = v3( 1, CLIPMAP_VERT_RESOLUTION - i, 0 );
 		}
 
 		size_t start_of_horizontal = n;
 
 		// horizontal part of L
 		for( u32 i = 0; i < CLIPMAP_VERT_RESOLUTION; i++ ) {
 			vertices[ n++ ] = v3( i + 1, 0, 0 );
 			vertices[ n++ ] = v3( i + 1, 1, 0 );
 		}
 
 		ASSERT( n == vertices.n );
 
 		for( v3 & v : vertices ) {
 			v -= v3( 0.5f * v2( CLIPMAP_VERT_RESOLUTION + 1 ), 0 );
 		}
 
 		array< u32 > indices = alloc_array< u32 >( &mem->persistent_arena, ( CLIPMAP_VERT_RESOLUTION * 2 - 1 ) * 6 );
 		n = 0;
 
 		for( u32 i = 0; i < CLIPMAP_VERT_RESOLUTION; i++ ) {
 			indices[ n++ ] = ( i + 0 ) * 2 + 1;
 			indices[ n++ ] = ( i + 0 ) * 2 + 0;
 			indices[ n++ ] = ( i + 1 ) * 2 + 0;
 
 			indices[ n++ ] = ( i + 1 ) * 2 + 1;
 			indices[ n++ ] = ( i + 0 ) * 2 + 1;
 			indices[ n++ ] = ( i + 1 ) * 2 + 0;
 		}
 
 		for( u32 i = 0; i < CLIPMAP_VERT_RESOLUTION - 1; i++ ) {
 			indices[ n++ ] = start_of_horizontal + ( i + 0 ) * 2 + 1;
 			indices[ n++ ] = start_of_horizontal + ( i + 0 ) * 2 + 0;
 			indices[ n++ ] = start_of_horizontal + ( i + 1 ) * 2 + 0;
 
 			indices[ n++ ] = start_of_horizontal + ( i + 1 ) * 2 + 1;
 			indices[ n++ ] = start_of_horizontal + ( i + 0 ) * 2 + 1;
 			indices[ n++ ] = start_of_horizontal + ( i + 1 ) * 2 + 0;
 		}
 
 		ASSERT( n == indices.n );
 
 		MeshConfig mesh_config;
 		mesh_config.positions = renderer_new_vb( vertices );
 		mesh_config.indices = renderer_new_ib( indices );
 		mesh_config.num_vertices = indices.n;
 		clipmap.gpu.trim = renderer_new_mesh( mesh_config );
 	}
 
 	// generate cross mesh
 	{
 		MEMARENA_SCOPED_CHECKPOINT( &mem->persistent_arena );
 
 		array< v3 > vertices = alloc_array< v3 >( &mem->persistent_arena, PATCH_VERT_RESOLUTION * 8 );
 		size_t n = 0;
 
 		// horizontal vertices
 		for( u32 i = 0; i < PATCH_VERT_RESOLUTION * 2; i++ ) {
 			vertices[ n++ ] = v3( i - float( TILE_RESOLUTION ), 0, 0 );
 			vertices[ n++ ] = v3( i - float( TILE_RESOLUTION ), 1, 0 );
 		}
 
 		size_t start_of_vertical = n;
 
 		// vertical vertices
 		for( u32 i = 0; i < PATCH_VERT_RESOLUTION * 2; i++ ) {
 			vertices[ n++ ] = v3( 0, i - float( TILE_RESOLUTION ), 0 );
 			vertices[ n++ ] = v3( 1, i - float( TILE_RESOLUTION ), 0 );
 		}
 
 		ASSERT( n == vertices.n );
 
 		array< u32 > indices = alloc_array< u32 >( &mem->persistent_arena, TILE_RESOLUTION * 24 + 6 );
 		n = 0;
 
 		// horizontal indices
 		for( u32 i = 0; i < TILE_RESOLUTION * 2 + 1; i++ ) {
 			u32 bl = i * 2 + 0;
 			u32 br = i * 2 + 1;
 			u32 tl = i * 2 + 2;
 			u32 tr = i * 2 + 3;
 
 			indices[ n++ ] = br;
 			indices[ n++ ] = bl;
 			indices[ n++ ] = tr;
 			indices[ n++ ] = bl;
 			indices[ n++ ] = tl;
 			indices[ n++ ] = tr;
 		}
 
 		// vertical indices
 		for( u32 i = 0; i < TILE_RESOLUTION * 2 + 1; i++ ) {
 			if( i == TILE_RESOLUTION )
 				continue;
 
 			u32 bl = i * 2 + 0;
 			u32 br = i * 2 + 1;
 			u32 tl = i * 2 + 2;
 			u32 tr = i * 2 + 3;
 
 			indices[ n++ ] = start_of_vertical + br;
 			indices[ n++ ] = start_of_vertical + tr;
 			indices[ n++ ] = start_of_vertical + bl;
 			indices[ n++ ] = start_of_vertical + bl;
 			indices[ n++ ] = start_of_vertical + tr;
 			indices[ n++ ] = start_of_vertical + tl;
 		}
 
 		ASSERT( n == indices.n );
 
 		MeshConfig mesh_config;
 		mesh_config.positions = renderer_new_vb( vertices );
 		mesh_config.indices = renderer_new_ib( indices );
 		mesh_config.num_vertices = indices.n;
 		clipmap.gpu.cross = renderer_new_mesh( mesh_config );
 	}
 
 	// generate seam mesh
 	{
 		MEMARENA_SCOPED_CHECKPOINT( &mem->persistent_arena );
 
 		array< v3 > vertices = alloc_array< v3 >( &mem->persistent_arena, CLIPMAP_VERT_RESOLUTION * 4 );
 
 		for( u32 i = 0; i < CLIPMAP_VERT_RESOLUTION; i++ ) {
 			vertices[ CLIPMAP_VERT_RESOLUTION * 0 + i ] = v3( i, 0, 0 );
 			vertices[ CLIPMAP_VERT_RESOLUTION * 1 + i ] = v3( CLIPMAP_VERT_RESOLUTION, i, 0 );
 			vertices[ CLIPMAP_VERT_RESOLUTION * 2 + i ] = v3( CLIPMAP_VERT_RESOLUTION - i, CLIPMAP_VERT_RESOLUTION, 0 );
 			vertices[ CLIPMAP_VERT_RESOLUTION * 3 + i ] = v3( 0, CLIPMAP_VERT_RESOLUTION - i, 0 );
 		}
 
 		array< u32 > indices = alloc_array< u32 >( &mem->persistent_arena, CLIPMAP_VERT_RESOLUTION * 6 );
 		size_t n = 0;
 
 		for( u32 i = 0; i < CLIPMAP_VERT_RESOLUTION * 4; i += 2 ) {
 			indices[ n++ ] = i + 1;
 			indices[ n++ ] = i;
 			indices[ n++ ] = i + 2;
 		}
 
 		// make the last triangle wrap around
 		indices[ indices.n - 1 ] = 0;
 
 		ASSERT( n == indices.n );
 
 		MeshConfig mesh_config;
 		mesh_config.positions = renderer_new_vb( vertices );
 		mesh_config.indices = renderer_new_ib( indices );
 		mesh_config.num_vertices = indices.n;
 		clipmap.gpu.seam = renderer_new_mesh( mesh_config );
 	}
 
 	// generate skirt mesh
 	{
 		float scale = checked_cast< float >( u32( 1 ) << ( NUM_CLIPMAP_LEVELS - 1 ) );
 		v2 base = -v2( checked_cast< float >( TILE_RESOLUTION << NUM_CLIPMAP_LEVELS ) );
 
 		v2 clipmap_tl = base;
 		v2 clipmap_br = clipmap_tl + v2( CLIPMAP_RESOLUTION * scale );
 
 		StaticArray< v3, 8 > vertices;
 		float big = 10000000.0;
 		vertices[ 0 ] = v3( -1, -1, 0 ) * big;
 		vertices[ 1 ] = v3( +1, -1, 0 ) * big;
 		vertices[ 2 ] = v3( -1, +1, 0 ) * big;
 		vertices[ 3 ] = v3( +1, +1, 0 ) * big;
 		vertices[ 4 ] = v3( clipmap_tl.x, clipmap_tl.y, 0 );
 		vertices[ 5 ] = v3( clipmap_br.x, clipmap_tl.y, 0 );
 		vertices[ 6 ] = v3( clipmap_tl.x, clipmap_br.y, 0 );
 		vertices[ 7 ] = v3( clipmap_br.x, clipmap_br.y, 0 );
 
 		u32 indices[] = {
 			0, 1, 4, 4, 1, 5,
 			1, 3, 5, 5, 3, 7,
 			3, 2, 7, 7, 2, 6,
 			4, 6, 0, 0, 6, 2,
 		};
 
 		MeshConfig mesh_config;
 		mesh_config.positions = renderer_new_vb( vertices.ptr(), vertices.num_bytes() );
 		mesh_config.indices = renderer_new_ib( indices, sizeof( indices ) );
 		mesh_config.num_vertices = ARRAY_COUNT( indices );
 		clipmap.gpu.skirt = renderer_new_mesh( mesh_config );
 	}
 
 	game->pos = v3( 2056, 2056, 70 );
 	game->pitch = 0;
 	game->yaw = 250;
 	game->sun_angle = 0.3f;
 
 	skybox_init( &game->skybox );
 
 	load_trees( &mem->persistent_arena );
 
 	sock = net_new_udp( NET_NONBLOCKING );
 
 	if( !dns_first( "localhost", &server_addr ) ) {
 		FATAL( "dns_first" );
 	}
 	server_addr.port = 13337;
 }
 
 static void draw_qt( MinMaxu32 aabb, const array< QuadTreeNode > nodes, size_t node_idx ) {
 	if( aabb.maxs.x - aabb.mins.x < 64 ) {
 		return;
 	}
 
 	v3 mins = v3( aabb.mins.x, aabb.mins.y, aabb.mins.z / 256.0f );
 	v3 maxs = v3( aabb.maxs.x, aabb.maxs.y, aabb.maxs.z / 256.0f );
 	immediate_aabb( mins, maxs, v4( 0, 0, 1, 1 ) );
 
 	for( size_t i = 0; i < 4; i++ ) {
 		MinMaxu32 child_aabb = aabb.quadrant( i ).clamp_z( nodes[ node_idx * 4 + i + 1 ].min_z, nodes[ node_idx * 4 + i + 1 ].max_z );
 		draw_qt( child_aabb, nodes, node_idx * 4 + i + 1 );
 	}
 }
 
 static bool intervals_overlap( float a0, float a1, float b0, float b1 ) {
 	ASSERT( a0 <= a1 );
 	ASSERT( b0 <= b1 );
 	return a0 <= b1 && b0 <= a1;
 }
 
 static void recreate_framebuffers() {
 	renderer_delete_fb( msaa_fb );
 
 	v2u32 window_size = get_window_size();
 
 	TextureConfig texture_config;
 	texture_config.width = window_size.x;
 	texture_config.height = window_size.y;
 	texture_config.wrap = TEXWRAP_CLAMP;
 
 	FramebufferConfig fb_config;
 
 	texture_config.format = TEXFMT_RGB_U8_SRGB;
 	fb_config.textures[ OUTPUT_ALBEDO ].config = texture_config;
 	fb_config.textures[ OUTPUT_ALBEDO ].attachment = FB_COLOUR;
 
 	texture_config.format = TEXFMT_DEPTH;
 	fb_config.textures[ OUTPUT_DEPTH ].config = texture_config;
 	fb_config.textures[ OUTPUT_DEPTH ].attachment = FB_DEPTH;
 
 	fb_config.msaa_samples = 0;
 
 	msaa_fb = renderer_new_fb( fb_config );
 }
 
 GAME_FRAME( game_frame ) {
 	if( input->resized ) {
 		recreate_framebuffers();
 	}
 
 	float fb = float( input->keys[ KEY_W ] - input->keys[ KEY_S ] );
 	float lr = float( input->keys[ KEY_D ] - input->keys[ KEY_A ] );
 	float dz = float( input->keys[ KEY_SPACE ] - input->keys[ KEY_LEFTSHIFT ] );
 
 	float dpitch = input->keys[ KEY_DOWNARROW ] - input->keys[ KEY_UPARROW ];
 	float dyaw = input->keys[ KEY_LEFTARROW ] - input->keys[ KEY_RIGHTARROW ];
 
 	dpitch = input->keys[ KEY_K ] - input->keys[ KEY_I ];
 	dyaw += input->keys[ KEY_J ] - input->keys[ KEY_L ];
 
 	if( input->keys[ KEY_M ] && input->key_edges[ KEY_M ] )
 		game->draw_wireframe = !game->draw_wireframe;
 	if( input->keys[ KEY_T ] && input->key_edges[ KEY_T ] )
 		game->draw_quadtree = !game->draw_quadtree;
 	if( input->keys[ KEY_N ] && input->key_edges[ KEY_N ] ) {
 		game->noclip = !game->noclip;
 		game->velocity = v3( 0 );
 		game->on_ground = false;
 	}
 	if( input->keys[ KEY_C ] && input->key_edges[ KEY_C ] ) {
 		game->frozen = !game->frozen;
 		game->frozen_pos = game->pos;
 	}
 
 	dpitch -= float( input->mouse_dy * 0.25 );
 	dyaw -= float( input->mouse_dx * 0.25 );
 
 	game->pitch = clamp( game->pitch + dpitch * dt * 100, -89.9f, 89.9f );
 	game->yaw += dyaw * dt * 100;
 
 	const float dsun = ( input->keys[ KEY_EQUALS ] - input->keys[ KEY_MINUS ] ) * dt * 0.25f;
 	game->sun_angle += dsun;
 
 	const v3 world_up = v3( 0, 0, 1 );
 	v3 forward = v3_forward( game->pitch, game->yaw );
 	v3 right = normalize( cross( forward, world_up ) );
 	v3 up = normalize( cross( right, forward ) );
 
 	// player movement
 	if( game->noclip ) {
 		const float speed = 100.0f;
 		game->pos += forward * dt * fb * speed;
 		game->pos += right * dt * lr * speed;
 		game->pos.z += dt * dz * speed;
 	}
 	else {
 		if( game->on_ground ) {
 			if( input->keys[ KEY_SPACE ] ) {
 				game->velocity.z = 9.8;
 				game->on_ground = false;
 			}
 		}
 
 		const float acceleration = 20.0f;
 		const float deceleration = 1.2f;
 		if( game->on_ground ) {
 			// apply friction
 			if( dot( game->velocity, game->velocity ) < 0.01f ) {
 				game->velocity = v3( 0 );
 			}
 			else {
 				float current_speed = length( game->velocity );
 				float drop = max( acceleration, current_speed ) * deceleration * dt;
 				float new_speed = max( 0.0f, current_speed - drop );
 				game->velocity = new_speed * ( game->velocity / current_speed );
 			}
 
 			if( fb != 0 || lr != 0 ) {
 				// apply acceleration
 				float max_speed = 5;
 
 				v3 forward_xy = v3_forward_xy( game->yaw );
 				v3 right_xy = normalize( cross( forward_xy, world_up ) );
 				v3 desired_direction = fb * forward_xy + lr * right_xy;
 
 				desired_direction = normalize( desired_direction );
 
 				float speed_in_desired_direction = dot( game->velocity, desired_direction );
 
 				if( speed_in_desired_direction < max_speed ) {
 					float accel_speed = min( acceleration * dt * max_speed, max_speed - speed_in_desired_direction );
 					game->velocity += accel_speed * desired_direction;
 				}
 			}
 		}
 
 		int spins = 0;
 		float remaining_t = dt;
 		while( remaining_t > 0 && spins < 5 ) {
 			spins++;
 			if( game->on_ground ) {
 				const float step_height = 0.1f;
 
 				v3 low_start = game->pos;
 				v3 low_end = low_start + game->velocity * remaining_t;
 
 				v3 high_start = game->pos + v3( 0, 0, step_height );
 				v3 high_end = high_start + game->velocity * remaining_t;
 
 				float low_t;
 				// initialise high_t to -1 so we never pick the high trace
 				// if we couldn't step up (fails the high_t > low_t test)
 				float high_t = -1;
 				v3 low_normal, high_normal;
 
 				bool low_hit = segment_vs_terrain( clipmap.quadtree, low_start, low_end, &low_t, &low_normal );
 				bool high_hit = false;
 
 				bool step_up_hit = segment_vs_terrain( clipmap.quadtree, low_start, high_start, NULL, NULL );
 				if( !step_up_hit ) {
 					high_hit = segment_vs_terrain( clipmap.quadtree, high_start, high_end, &high_t, &high_normal );
 				}
 
 				v3 step_down_start;
 				float step_down_distance;
 				bool should_step_down = false;
 
 				if( high_t > low_t ) {
 					if( high_hit ) {
 						game->pos = high_start + game->velocity * high_t * remaining_t;
 						remaining_t = ( 1.0f - high_t ) * remaining_t;
 					}
 					else {
 						step_down_start = high_end;
 						step_down_distance = step_height * 2;
 						should_step_down = true;
 						remaining_t = 0;
 					}
 				}
 				else {
 					if( low_hit ) {
 						game->pos = low_start + game->velocity * low_t * remaining_t;
 						remaining_t = ( 1.0f - low_t ) * remaining_t;
 					}
 					else {
 						step_down_start = low_end;
 						step_down_distance = step_height;
 						should_step_down = true;
 						remaining_t = 0;
 					}
 				}
 
 				if( should_step_down ) {
 					float step_down_t;
 					v3 step_down_end = step_down_start - v3( 0, 0, step_down_distance );
 
 					bool step_down_hit = segment_vs_terrain( clipmap.quadtree, step_down_start, step_down_end, &step_down_t, NULL );
 
 					game->pos = lerp( step_down_start, step_down_t, step_down_end );
 					game->on_ground = step_down_hit;
 				}
 			}
 
 			// TODO: this might be quite harmful
 			if( !game->on_ground ) {
 				const float gravity = -30.0f;
 				game->velocity += v3( 0, 0, gravity ) * remaining_t;
 
 				v3 start = game->pos;
 				v3 end = start + game->velocity * remaining_t;
 				float t;
 				v3 normal;
 				bool hit = segment_vs_terrain( clipmap.quadtree, start, end, &t, &normal );
 				if( hit ) {
 					// TODO: check normal is flat enough, otherwise stay in the air
 					game->on_ground = true;
 					game->pos += game->velocity * t * remaining_t;
 					// TODO: truncate velocity
 					game->velocity.z = 0;
 
 					remaining_t = ( 1.0f - t ) * remaining_t;
 				}
 				else {
 					game->pos = end;
 					remaining_t = 0;
 				}
 			}
 
 			if( game->on_ground ) {
 				// move up 1mm so float imprecision doesn't make us fall through the world
 				game->pos.z += 0.001f;
 			}
 		}
 	}
 
 	v3 eye_pos = game->pos + v3( 0, 0, EYE_HEIGHT );
 	m4 P = m4_perspective( VERTICAL_FOV, get_aspect_ratio(), NEAR_PLANE_DEPTH, FAR_PLANE_DEPTH );
 	m4 Pinf = m4_perspective_inf( VERTICAL_FOV, get_aspect_ratio(), NEAR_PLANE_DEPTH );
 	m4 V = m4_view( forward, right, up, eye_pos );
 	m4 Vsky = m4_view( forward, right, up, v3( 0 ) );
 	v3 sun_dir = v3( -cosf( game->sun_angle ), 0, sinf( game->sun_angle ) );
 
 	renderer_begin_frame();
 
 	u8 world_pass = renderer_add_pass( "Render world", msaa_fb, RENDERER_CLEAR_COLOUR_DO, RENDERER_CLEAR_DEPTH_DO );
 	u8 ents_pass = renderer_add_pass( "Render entities", msaa_fb );
 	u8 sky_pass = renderer_add_pass( "Render sky", msaa_fb );
 	renderer_resolve_msaa( msaa_fb );
 	u8 ui_pass = renderer_add_pass( "Render UI" );
 
 	UniformBinding view_uniforms = renderer_uniforms( V, P, game->pos );
 	UniformBinding inf_view_uniforms = renderer_uniforms( V, Pinf, game->pos );
 	UniformBinding sun_uniforms = renderer_uniforms( sun_dir, game->sun_angle );
 
 	StaticArray< UniformBinding, 4 > rotation_uniforms;
 	rotation_uniforms[ 0 ] = renderer_uniforms( m4_identity() );
 	rotation_uniforms[ 1 ] = renderer_uniforms( m4_rotz270() );
 	rotation_uniforms[ 2 ] = renderer_uniforms( m4_rotz90() );
 	rotation_uniforms[ 3 ] = renderer_uniforms( m4_rotz180() );
 
 	if( !game->frozen ) {
 		game->frozen_pos = game->pos;
 	}
 
 	// draw terrain
 	{
 		RenderState render_state;
 		render_state.pass = world_pass;
 		render_state.shader = get_shader( SHADER_CLIPMAP );
 		render_state.set_uniform( "view", view_uniforms );
 		render_state.set_uniform( "sun", sun_uniforms );
 		render_state.set_texture( "heightmap", clipmap.gpu.heightmap );
 		render_state.set_texture( "normalmap", clipmap.gpu.normalmap );
 		render_state.set_texture( "horizonmap", clipmap.gpu.horizonmap );
 		render_state.set_texture( "blue_noise", renderer_blue_noise() );
 		render_state.wireframe = game->draw_wireframe;
 
 		// draw cross
 		{
 			v2 snapped_pos = floorf( game->frozen_pos.xy() );
 			render_state.set_uniform( "model", rotation_uniforms[ 0 ] );
 			render_state.set_uniform( "clipmap", renderer_uniforms( snapped_pos, 1.0f ) );
 			renderer_draw_mesh( clipmap.gpu.cross, render_state );
 		}
 
 		for( u32 l = 0; l < NUM_CLIPMAP_LEVELS; l++ ) {
 			float scale = checked_cast< float >( u32( 1 ) << l );
 			v2 snapped_pos = floorf( game->frozen_pos.xy() / scale ) * scale;
 
 			// draw tiles
 			v2 tile_size = v2( checked_cast< float >( TILE_RESOLUTION << l ) );
 			v2 base = snapped_pos - v2( checked_cast< float >( TILE_RESOLUTION << ( l + 1 ) ) );
 
 			for( int x = 0; x < 4; x++ ) {
 				for( int y = 0; y < 4; y++ ) {
 					// draw a 4x4 set of tiles. cut out the middle 2x2 unless we're at the finest level
 					if( l != 0 && ( x == 1 || x == 2 ) && ( y == 1 || y == 2 ) ) {
 						continue;
 					}
 
 					v2 fill = v2( x >= 2 ? 1 : 0, y >= 2 ? 1 : 0 ) * scale;
 					v2 tile_tl = base + v2( x, y ) * tile_size + fill;
 
 					// draw a low poly tile if the tile is entirely outside the world
 					v2 tile_br = tile_tl + tile_size;
 					bool inside = true;
 					if( !intervals_overlap( tile_tl.x, tile_br.x, 0, clipmap.heightmap.w ) )
 						inside = false;
 					if( !intervals_overlap( tile_tl.y, tile_br.y, 0, clipmap.heightmap.h ) )
 						inside = false;
 
 					Mesh mesh = inside ? clipmap.gpu.tile : clipmap.gpu.empty_tile;
 					render_state.set_uniform( "model", rotation_uniforms[ 0 ] );
 					render_state.set_uniform( "clipmap", renderer_uniforms( tile_tl, scale ) );
 					renderer_draw_mesh( mesh, render_state );
 				}
 			}
 
 			// draw filler
 			{
 				render_state.set_uniform( "model", rotation_uniforms[ 0 ] );
 				render_state.set_uniform( "clipmap", renderer_uniforms( snapped_pos, scale ) );
 				renderer_draw_mesh( clipmap.gpu.filler, render_state );
 			}
 
 			if( l != NUM_CLIPMAP_LEVELS - 1 ) {
 				float next_scale = scale * 2.0f;
 				v2 next_snapped_pos = floorf( game->frozen_pos.xy() / next_scale ) * next_scale;
 
 				// draw trim
 				{
 					v2 tile_centre = snapped_pos + v2( scale * 0.5f );
 
 					v2 d = game->frozen_pos.xy() - next_snapped_pos;
 					u32 r = 0;
 					r |= d.x >= scale ? 0 : 2;
 					r |= d.y >= scale ? 0 : 1;
 
 					render_state.set_uniform( "model", rotation_uniforms[ r ] );
 					render_state.set_uniform( "clipmap", renderer_uniforms( tile_centre, scale ) );
 					renderer_draw_mesh( clipmap.gpu.trim, render_state );
 				}
 
 				// draw seam
 				{
 					v2 next_base = next_snapped_pos - v2( checked_cast< float >( TILE_RESOLUTION << ( l + 1 ) ) );
 
 					render_state.set_uniform( "model", rotation_uniforms[ 0 ] );
 					render_state.set_uniform( "clipmap", renderer_uniforms( next_base, scale ) );
 					renderer_draw_mesh( clipmap.gpu.seam, render_state );
 				}
 			}
 		}
 	}
 
 	// draw skirts
 	{
 		float scale = checked_cast< float >( u32( 1 ) << ( NUM_CLIPMAP_LEVELS - 1 ) );
 
 		RenderState skirt_render_state;
 		skirt_render_state.pass = world_pass;
 		skirt_render_state.shader = get_shader( SHADER_CLIPMAP_SKIRT );
 		skirt_render_state.set_uniform( "view", inf_view_uniforms );
 		skirt_render_state.set_uniform( "sun", sun_uniforms );
 		skirt_render_state.set_uniform( "clipmap_skirt", renderer_uniforms( scale ) );
 		skirt_render_state.set_texture( "blue_noise", renderer_blue_noise() );
 		skirt_render_state.wireframe = game->draw_wireframe;
 		renderer_draw_mesh( clipmap.gpu.skirt, skirt_render_state );
 	}
 
 	// draw trees
 	{
 		RenderState render_state;
 		render_state.pass = ents_pass;
 		render_state.shader = get_shader( SHADER_TREE );
 		render_state.set_uniform( "view", view_uniforms );
 		render_state.set_uniform( "sun", renderer_uniforms( sun_dir ) );
 		render_state.set_texture( "blue_noise", renderer_blue_noise() );
 
 		renderer_draw_instances( tree_mesh, render_state, num_trees, trees_instance_data );
 	}
 
 	// draw crosshair
 	{
 		const float aspect = get_aspect_ratio();
 		const float crosshair_thickness = 0.0025f;
 		const float crosshair_length = 0.01f;
 
 		const v4 red( 1, 0, 0, 1 );
 		immediate_triangle(
 			v3( -crosshair_length,  crosshair_thickness, 0 ),
 			v3( -crosshair_length, -crosshair_thickness, 0 ),
 			v3(  crosshair_length,  crosshair_thickness, 0 ),
 			red
 		);
 		immediate_triangle(
 			v3(  crosshair_length, -crosshair_thickness, 0 ),
 			v3(  crosshair_length,  crosshair_thickness, 0 ),
 			v3( -crosshair_length, -crosshair_thickness, 0 ),
 			red
 		);
 		immediate_triangle(
 			v3(  crosshair_thickness / aspect,  crosshair_length * aspect, 0 ),
 			v3( -crosshair_thickness / aspect,  crosshair_length * aspect, 0 ),
 			v3(  crosshair_thickness / aspect, -crosshair_length * aspect, 0 ),
 			red
 		);
 		immediate_triangle(
 			v3( -crosshair_thickness / aspect, -crosshair_length * aspect, 0 ),
 			v3(  crosshair_thickness / aspect, -crosshair_length * aspect, 0 ),
 			v3( -crosshair_thickness / aspect,  crosshair_length * aspect, 0 ),
 			red
 		);
 		RenderState render_state;
 		render_state.pass = ui_pass;
 		render_state.shader = get_shader( SHADER_UI );
 		render_state.depth_func = DEPTHFUNC_ALWAYS;
 		immediate_render( render_state );
 	}
 
 	// fireballs
 	if( input->keys[ KEY_F ] ) {
 		Fireball * fireball = fireballs.acquire();
 		fireball->pos = game->pos + v3( 0.0f, 0.0f, EYE_HEIGHT );
 		fireball->velocity = 128.0f * forward;
 	}
 
 	{
 		{
 			PROFILE_BLOCK( "Update fireballs" );
 			for( size_t i = 0; i < fireballs.elems.n; i++ ) {
 				Fireball * fireball = &fireballs.elems[ i ];
 
 				const float gravity = 30;
 				fireball->velocity.z -= dt * gravity;
 
 				Ray3 ray( fireball->pos, fireball->velocity );
 				v3 end = fireball->pos + fireball->velocity * dt;
 
 				float t;
 				v3 normal;
 				if( segment_vs_terrain( clipmap.quadtree, fireball->pos, end, &t, &normal ) ) {
 					Explosion * explosion = explosions.acquire();
 					explosion->pos = lerp( fireball->pos, t, end );
 					explosion->created_at = current_time;
 
 					fireballs.release( fireball );
 					i--;
 				}
 				else {
 					fireball->pos = end;
 					immediate_sphere( fireball->pos, 4, v4( 1, 0, 0, 1 ), 4 );
 				}
 			}
 		}
 
 		RenderState fireball_render_state;
 		fireball_render_state.pass = ents_pass;
 		fireball_render_state.shader = get_shader( SHADER_FLAT_VERTEX_COLOURS );
 		fireball_render_state.set_uniform( "view", view_uniforms );
 		immediate_render( fireball_render_state );
 
 		for( size_t i = 0; i < explosions.elems.n; i++ ) {
 			Explosion * explosion = &explosions.elems[ i ];
 			float t = float( current_time - explosion->created_at );
 			if( t < 0.5f ) {
 				immediate_sphere( explosion->pos, t * 32.0f, v4( 1, 0.5, 0, 1 ), 4 );
 			}
 			else {
 				explosions.release( explosion );
 				i--;
 			}
 		}
 
 		RenderState explosion_render_state;
 		explosion_render_state.pass = ents_pass;
 		explosion_render_state.shader = get_shader( SHADER_FLAT_VERTEX_COLOURS );
 		explosion_render_state.set_uniform( "view", view_uniforms );
 		immediate_render( explosion_render_state );
 	}
 
 	skybox_render( &game->skybox, sky_pass, Vsky, Pinf, game->sun_angle, sun_dir );
 
 	// networking
 	{
 		char buf[ 1400 ];
 		NetAddress recv_addr;
 		size_t len;
 		if( !net_tryrecv( sock, buf, sizeof( buf ), &recv_addr, &len ) ) {
 			len = 0;
 		}
 		if( recv_addr != server_addr ) {
 			len = 0;
 		}
 
 		ReadStream rs( buf, len );
 
 		if( connected && len > 0 ) {
 			char write_buf[ 1400 ];
 			WriteStream ws( write_buf );
 			write( &ws, sid );
 			write( &ws, game->pos );
 
 			net_send( sock, ws.start, ws.len(), server_addr );
 
 			u16 player_count = read_u16( &rs );
 			ReadStreamCheckpoint rsc = rs.checkpoint();
 
 			for( u16 i = 0; i < player_count; i++ ) {
 				read_u64( &rs );
 				u8 player_state = read_u8( &rs );
 				if( player_state == 0 ) {
 					v3 pos;
 					read( &rs, &pos );
 				}
 			}
 
 			if( rs.done() ) {
 				rs.reset( &rsc );
 				for( u16 i = 0; i < player_count; i++ ) {
 					u64 player_sid = read_u64( &rs );
 					u8 player_state = read_u8( &rs );
 					v3 pos;
 					if( player_state == 0 ) {
 						read( &rs, &pos );
 					}
 
 					Player * player = NULL;
 					if( !sid_to_player.get( player_sid, &player ) && player_state == 0 ) {
 						player = players.acquire();
 						ASSERT( player != NULL ); // TODO
 						sid_to_player.add( player_sid, player );
 						player->sid = player_sid;
 					}
 
 					if( player_state == 0 ) {
 						player->pos = pos;
 					}
 					else if( player_state == 1 ) {
 						ggprint( "{08x} disconnected\n", player->sid );
 						players.release( player );
 					}
 				}
 
 				ASSERT( rs.done() );
 			}
 			else {
 				if( len > 0 ) {
 					FATAL( "bad message from the server" );
 				}
 			}
 		}
 		else if( len > 0 ) {
 			sid = read_u64( &rs );
 			if( rs.ok ) {
 				connected = true;
 			}
 		}
 
 		if( !connected && current_time - last_connection_attempt > 1.0 ) {
 			char write_buf[ 1400 ];
 			WriteStream ws( write_buf );
 
 			write_u64( &ws, ~u64( 0 ) );
 			write( &ws, game->pos );
 
 			net_send( sock, ws.start, ws.len(), server_addr );
 
 			last_connection_attempt = current_time;
 		}
 
 		for( const Player & player : players ) {
 			if( player.sid != sid ) {
 				v3 mins = player.pos - v3( 0.4f, 0.4f, 0.0f );
 				v3 maxs = player.pos + v3( 0.4f, 0.4f, EYE_HEIGHT + 0.1f );
 				immediate_aabb( mins, maxs, v4( 1, 1, 0, 1 ) );
 			}
 		}
 
 		RenderState impact_render_state;
 		impact_render_state.pass = world_pass;
 		impact_render_state.shader = get_shader( SHADER_FLAT_VERTEX_COLOURS );
 		impact_render_state.set_uniform( "view", view_uniforms );
 		immediate_render( impact_render_state );
 	}
 
 	if( game->draw_quadtree ) {
 		v3u32 mins = v3u32( 0, 0, clipmap.quadtree.nodes[ 0 ].min_z );
 		v3u32 maxs = v3u32( clipmap.heightmap.w, clipmap.heightmap.h, clipmap.quadtree.nodes[ 0 ].max_z );
 		draw_qt( MinMaxu32( mins, maxs ), clipmap.quadtree.nodes, 0 );
 
 		RenderState render_state;
 		render_state.pass = world_pass;
 		render_state.shader = get_shader( SHADER_WIREFRAME );
 		render_state.set_uniform( "view", view_uniforms );
 		render_state.wireframe = true;
 		immediate_render( render_state );
 	}
 
 	// info text
 	{
 		const str< 128 > status( "Frame time: {.1}ms FPS: {.1} {}", dt * 1000.0f, 1.0f / dt,
 			connected ? "connected!" : "connecting" );
 		draw_text( ui_pass, status.c_str(), 2, 2, 16.0f );
 		draw_text( ui_pass, str< 128 >( "pos = {.1} vel = {.1}", game->pos, game->velocity ).c_str(), 2, 20, 16 );
 		draw_text( ui_pass, str< 128 >( "drawcalls = {}, tris = {}", renderer_num_draw_calls(), renderer_num_vertices() / 3 ).c_str(), 2, 38, 16 );
 	}
 
 	renderer_end_frame();
 }