medfall

renderer.cc (32760B)

---

 #include <algorithm>
 
 #include "intrinsics.h"
 #include "game.h"
 #include "gl.h"
 #include "renderer.h"
 #include "log.h"
 #include "linear_algebra.h"
 #include "blue_noise.h"
 #include "obj.h"
 #include "fnv.h"
 
 #include "glad.h"
 
 STATIC_ASSERT( SAME_TYPE( VB, GLuint ) );
 STATIC_ASSERT( SAME_TYPE( IB, GLuint ) );
 STATIC_ASSERT( SAME_TYPE( Texture, GLuint ) );
 STATIC_ASSERT( SAME_TYPE( FramebufferObject, GLuint ) );
 STATIC_ASSERT( SAME_TYPE( u32, GLuint ) );
 
 static const GLuint ATTR_POSITION = 0;
 static const GLuint ATTR_NORMAL = 1;
 static const GLuint ATTR_TEX_COORD0 = 2;
 static const GLuint ATTR_TEX_COORD1 = 3;
 static const GLuint ATTR_COLOUR = 4;
 static const GLuint ATTR_JOINTS = 5;
 static const GLuint ATTR_WEIGHTS = 6;
 static const GLuint ATTR_MODEL_TO_WORLD_COL0 = 7;
 
 static const u32 UNIFORM_BUFFER_SIZE = kilobytes( 64 );
 
 struct DrawCall {
 	RenderState render_state;
 	Mesh mesh;
 	u32 num_instances;
 	VB instance_data;
 };
 
 enum DeleteCommandType {
 	DELETE_VB,
 	DELETE_IB,
 	DELETE_TEXTURE,
 	DELETE_MESH,
 };
 
 struct DeleteCommand {
 	DeleteCommandType type;
 	union {
 		VB vb;
 		IB ib;
 		Shader shader;
 		Texture texture;
 		Mesh mesh;
 	};
 };
 
 static DynamicArray< DrawCall > draw_calls;
 static DynamicArray< RenderPass > render_passes;
 static DynamicArray< DeleteCommand > deletes;
 
 static u32 draw_calls_this_frame;
 static u32 vertices_this_frame;
 
 static bool in_frame;
 
 struct UBO {
 	GLuint ubo;
 	u8 * buffer;
 	u32 bytes_used;
 };
 
 static UBO ubos[ 8 ];
 static size_t ubo_offset_alignment;
 
 static Texture blue_noise;
 static Mesh fullscreen_triangle;
 
 static RenderState previous_render_state;
 static FramebufferObject previous_fbo;
 static u32 previous_viewport_width;
 static u32 previous_viewport_height;
 
 void renderer_init() {
 	GLint alignment;
 	glGetIntegerv( GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &alignment );
 	ubo_offset_alignment = checked_cast< size_t >( alignment );
 
 	GLint max_ubo_size;
 	glGetIntegerv( GL_MAX_UNIFORM_BLOCK_SIZE, &max_ubo_size );
 	ASSERT( max_ubo_size >= UNIFORM_BUFFER_SIZE );
 
 	for( size_t i = 0; i < ARRAY_COUNT( ubos ); i++ ) {
 		glGenBuffers( 1, &ubos[ i ].ubo );
 		glBindBuffer( GL_UNIFORM_BUFFER, ubos[ i ].ubo );
 		glBufferData( GL_UNIFORM_BUFFER, UNIFORM_BUFFER_SIZE, NULL, GL_DYNAMIC_DRAW );
 	}
 
 	in_frame = false;
 
 	previous_fbo = 0;
 	previous_viewport_width = 0;
 	previous_viewport_height = 0;
 
 	blue_noise = load_png_memory( blue_noise_png, blue_noise_png_len, TEXFMT_R_U8NORM, 1 );
 
 	v3 tri[] = {
 		v3( -1.0f, -1.0f, 0.0f ),
 		v3( 3.0f, -1.0f, 0.0f ),
 		v3( -1.0f, 3.0f, 0.0f ),
 	};
 	MeshConfig config;
 	config.positions = renderer_new_vb( tri, sizeof( tri ) );
 	config.num_vertices = 3;
 	config.primitive_type = PRIMITIVETYPE_TRIANGLES;
 	fullscreen_triangle = renderer_new_mesh( config );
 }
 
 void renderer_term() {
 	for( size_t i = 0; i < ARRAY_COUNT( ubos ); i++ ) {
 		glDeleteBuffers( 1, &ubos[ i ].ubo );
 	}
 
 	renderer_delete_texture( blue_noise );
 	renderer_delete_mesh( fullscreen_triangle );
 }
 
 void renderer_begin_frame() {
 	ASSERT( !in_frame );
 	in_frame = true;
 
 	draw_calls.clear();
 	render_passes.clear();
 	deletes.clear();
 
 	draw_calls_this_frame = 0;
 	vertices_this_frame = 0;
 
 	for( size_t i = 0; i < ARRAY_COUNT( ubos ); i++ ) {
 		glBindBuffer( GL_UNIFORM_BUFFER, ubos[ i ].ubo );
 		ubos[ i ].buffer = ( u8 * ) glMapBufferRange( GL_UNIFORM_BUFFER, 0, UNIFORM_BUFFER_SIZE, GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT );
 		ubos[ i ].bytes_used = 0;
 		ASSERT( ubos[ i ].buffer != NULL );
 	}
 
 	v2u32 window_size = get_window_size();
 	if( window_size.x != previous_viewport_width || window_size.y != previous_viewport_height ) {
 		previous_viewport_width = window_size.x;
 		previous_viewport_height = window_size.y;
 		glViewport( 0, 0, window_size.x, window_size.y );
 	}
 }
 
 static GLenum depthfunc_to_glenum( DepthFunc depth_func ) {
 	switch( depth_func ) {
 		case DEPTHFUNC_LESS: return GL_LESS;
 		case DEPTHFUNC_EQUAL: return GL_EQUAL;
 		case DEPTHFUNC_ALWAYS: return GL_ALWAYS;
 		case DEPTHFUNC_DISABLED: return GL_ALWAYS;
 	}
 
 	FATAL( "unsupported DepthFunc: {}", depth_func );
 	return GL_INVALID_ENUM;
 }
 
 static GLenum primitivetype_to_glenum( PrimitiveType primitive_type ) {
 	switch( primitive_type ) {
 		case PRIMITIVETYPE_TRIANGLES: return GL_TRIANGLES;
 		case PRIMITIVETYPE_TRIANGLE_STRIP: return GL_TRIANGLE_STRIP;
 		case PRIMITIVETYPE_POINTS: return GL_POINTS;
 		case PRIMITIVETYPE_LINES: return GL_LINES;
 	}
 
 	FATAL( "unsupported PrimitiveType: {}", primitive_type );
 	return GL_INVALID_ENUM;
 }
 
 static void set_render_state( const RenderState & state ) {
 	if( state.shader != previous_render_state.shader ) {
 		glUseProgram( state.shader->program );
 	}
 
 	// uniforms
 	// TODO: maybe these shouldn't always get rebound
 	for( size_t i = 0; i < ARRAY_COUNT( state.shader->uniforms ); i++ ) {
 		bool found = false;
 		for( size_t j = 0; j < state.num_uniforms; j++ ) {
 			UniformBinding binding = state.uniforms[ j ].binding;
 			if( state.uniforms[ j ].name_hash == state.shader->uniforms[ i ] && binding.size > 0 ) {
 				glBindBufferRange( GL_UNIFORM_BUFFER, i, binding.ubo, binding.offset, binding.size );
 				found = true;
 				break;
 			}
 		}
 
 		if( !found ) {
 			glBindBufferBase( GL_UNIFORM_BUFFER, i, 0 );
 		}
 	}
 
 	// textures
 	for( size_t i = 0; i < ARRAY_COUNT( state.shader->textures ); i++ ) {
 		glActiveTexture( GL_TEXTURE0 + i );
 
 		bool found = false;
 		for( size_t j = 0; j < state.num_textures; j++ ) {
 			if( state.textures[ j ].name_hash == state.shader->textures[ i ] ) {
 				glBindTexture( GL_TEXTURE_2D, state.textures[ j ].texture );
 				found = true;
 				break;
 			}
 		}
 
 		if( !found ) {
 			glBindTexture( GL_TEXTURE_2D, 0 );
 		}
 	}
 
 	// depth writing
 	if( state.disable_depth_writes != previous_render_state.disable_depth_writes ) {
 		glDepthMask( state.disable_depth_writes ? GL_FALSE : GL_TRUE );
 	}
 
 	// backface culling
 	if( state.cull_face != previous_render_state.cull_face ) {
 		if( state.cull_face == CULLFACE_DISABLED ) {
 			glDisable( GL_CULL_FACE );
 		}
 		else {
 			if( previous_render_state.cull_face == CULLFACE_DISABLED ) {
 				glEnable( GL_CULL_FACE );
 			}
 			glCullFace( state.cull_face == CULLFACE_FRONT ? GL_FRONT : GL_BACK );
 		}
 	}
 
 	// depth testing
 	if( state.depth_func != previous_render_state.depth_func ) {
 		if( state.depth_func == DEPTHFUNC_DISABLED ) {
 			glDisable( GL_DEPTH_TEST );
 		}
 		else {
 			if( previous_render_state.depth_func == DEPTHFUNC_DISABLED ) {
 				glEnable( GL_DEPTH_TEST );
 			}
 			glDepthFunc( depthfunc_to_glenum( state.depth_func ) );
 		}
 	}
 
 	// alpha blending
 	if( state.enable_alpha_blending != previous_render_state.enable_alpha_blending ) {
 		if( state.enable_alpha_blending ) {
 			glEnable( GL_BLEND );
 			glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
 		}
 		else {
 			glDisable( GL_BLEND );
 		}
 	}
 
 	// polygon fill mode
 	if( state.wireframe != previous_render_state.wireframe ) {
 		if( state.wireframe ) {
 			glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
 			glEnable( GL_POLYGON_OFFSET_LINE );
 			glPolygonOffset( -1, -1 );
 		}
 		else {
 			glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
 			glDisable( GL_POLYGON_OFFSET_LINE );
 		}
 	}
 
 	previous_render_state = state;
 }
 
 static bool compare_drawcall( const DrawCall & a, const DrawCall & b ) {
 	if( a.render_state.pass != b.render_state.pass )
 		return a.render_state.pass < b.render_state.pass;
 	return a.render_state.shader < b.render_state.shader;
 }
 
 static void setup_render_pass( const RenderPass & pass ) {
 	if( GLAD_GL_KHR_debug != 0 ) {
 		glPushDebugGroup( GL_DEBUG_SOURCE_APPLICATION, 0, -1, pass.name );
 	}
 
 	const FB & fb = pass.target;
 	if( fb.fbo != previous_fbo ) {
 		glBindFramebuffer( GL_DRAW_FRAMEBUFFER, fb.fbo );
 		previous_fbo = fb.fbo;
 
 		u32 viewport_width, viewport_height;
 		if( fb.fbo == 0 ) {
 			v2u32 window_size = get_window_size();
 			viewport_width = window_size.x;
 			viewport_height = window_size.y;
 		}
 		else {
 			viewport_width = fb.width;
 			viewport_height = fb.height;
 		}
 
 		if( viewport_width != previous_viewport_width || viewport_height != previous_viewport_height ) {
 			previous_viewport_width = viewport_width;
 			previous_viewport_height = viewport_height;
 			glViewport( 0, 0, viewport_width, viewport_height );
 		}
 	}
 
 	GLbitfield clear_mask = 0;
 	clear_mask |= pass.clear_colour ? GL_COLOR_BUFFER_BIT : 0;
 	clear_mask |= pass.clear_depth ? GL_DEPTH_BUFFER_BIT : 0;
 	if( clear_mask != 0 ) {
 		if( pass.clear_colour )
 			glClearColor( pass.colour.x, pass.colour.y, pass.colour.z, pass.colour.w );
 		if( pass.clear_depth )
 			glClearDepth( pass.depth );
 		glClear( clear_mask );
 	}
 }
 
 static void drawcall_single( const Mesh & mesh, const RenderState & state ) {
 	set_render_state( state );
 
 	glBindVertexArray( mesh.vao );
 	GLenum primitive = primitivetype_to_glenum( mesh.primitive_type );
 	if( mesh.indices != 0 ) {
 		glDrawElements( primitive, mesh.num_vertices, mesh.indices_format == INDEXFMT_U16 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, 0 );
 	}
 	else {
 		glDrawArrays( primitive, 0, mesh.num_vertices );
 	}
 	glBindVertexArray( 0 );
 }
 
 static void drawcall_instanced( const Mesh & mesh, const RenderState & state, u32 num_instances, VB instance_data ) {
 	set_render_state( state );
 
 	glBindVertexArray( mesh.vao );
 	glBindBuffer( GL_ARRAY_BUFFER, instance_data );
 
 	for( int i = 0; i < 4; i++ ) {
 		GLuint loc = ATTR_MODEL_TO_WORLD_COL0 + i;
 		glEnableVertexAttribArray( loc );
 		glVertexAttribPointer( loc, 4, GL_FLOAT, GL_FALSE, sizeof( m4 ), ( GLvoid * ) ( i * sizeof( v4 ) ) );
 		glVertexAttribDivisor( loc, 1 );
 	}
 
 	GLenum primitive = primitivetype_to_glenum( mesh.primitive_type );
 	if( mesh.indices != 0 ) {
 		glDrawElementsInstanced( primitive, mesh.num_vertices, GL_UNSIGNED_INT, 0, checked_cast< s32 >( num_instances ) );
 	}
 	else {
 		glDrawArraysInstanced( primitive, 0, mesh.num_vertices, checked_cast< s32 >( num_instances ) );
 	}
 
 	glBindVertexArray( 0 );
 }
 
 void renderer_end_frame() {
 	ASSERT( in_frame );
 	in_frame = false;
 
 	for( size_t i = 0; i < ARRAY_COUNT( ubos ); i++ ) {
 		glBindBuffer( GL_UNIFORM_BUFFER, ubos[ i ].ubo );
 		glUnmapBuffer( GL_UNIFORM_BUFFER );
 	}
 
 	std::sort( draw_calls.begin(), draw_calls.end(), compare_drawcall );
 
 	u8 pass_idx = U8_MAX;
 	for( const DrawCall & dc : draw_calls ) {
 		if( dc.render_state.pass != pass_idx ) {
 			if( GLAD_GL_KHR_debug != 0 && pass_idx != U8_MAX )
 				glPopDebugGroup();
 			setup_render_pass( render_passes[ dc.render_state.pass ] );
 			pass_idx = dc.render_state.pass;
 		}
 
 		if( dc.render_state.shader == NULL ) {
 			FB fb = render_passes[ dc.render_state.pass ].msaa_source;
 			v2u32 window_size = get_window_size();
 			ASSERT( fb.width == window_size.x && fb.height == window_size.y );
 			glBindFramebuffer( GL_READ_FRAMEBUFFER, fb.fbo );
 			glBlitFramebuffer( 0, 0, fb.width, fb.height, 0, 0, fb.width, fb.height, GL_COLOR_BUFFER_BIT, GL_NEAREST );
 		}
 		else if( dc.num_instances == 0 ) {
 			drawcall_single( dc.mesh, dc.render_state );
 		}
 		else {
 			drawcall_instanced( dc.mesh, dc.render_state, dc.num_instances, dc.instance_data );
 		}
 	}
 
 	if( GLAD_GL_KHR_debug != 0 && pass_idx != U8_MAX )
 		glPopDebugGroup();
 
 	for( const DeleteCommand & del : deletes ) {
 		switch( del.type ) {
 			case DELETE_VB:
 				glDeleteBuffers( 1, &del.vb );
 				break;
 
 			case DELETE_IB:
 				glDeleteBuffers( 1, &del.ib );
 				break;
 
 			case DELETE_TEXTURE:
 				glDeleteTextures( 1, &del.texture );
 				break;
 
 			case DELETE_MESH:
 				if( del.mesh.positions != 0 )
 					renderer_delete_vb( del.mesh.positions );
 				if( del.mesh.normals != 0 )
 					renderer_delete_vb( del.mesh.normals );
 				if( del.mesh.tex_coords0 != 0 )
 					renderer_delete_vb( del.mesh.tex_coords0 );
 				if( del.mesh.tex_coords1 != 0 )
 					renderer_delete_vb( del.mesh.tex_coords1 );
 				if( del.mesh.colours != 0 )
 					renderer_delete_vb( del.mesh.colours );
 				if( del.mesh.indices != 0 )
 					renderer_delete_ib( del.mesh.indices );
 				if( del.mesh.joints != 0 )
 					renderer_delete_vb( del.mesh.joints );
 				if( del.mesh.weights != 0 )
 					renderer_delete_vb( del.mesh.weights );
 
 				glDeleteVertexArrays( 1, &del.mesh.vao );
 				break;
 		}
 	}
 }
 
 u8 renderer_add_pass( const RenderPass & pass ) {
 	return checked_cast< u8 >( render_passes.add( pass ) );
 }
 
 u8 renderer_add_pass( const char * name, FB target, ClearColourBool clear_colour, ClearDepthBool clear_depth ) {
 	RenderPass pass;
 	pass.target = target;
 	pass.name = name;
 	pass.clear_colour = clear_colour == RENDERER_CLEAR_COLOUR_DO;
 	pass.clear_depth = clear_depth == RENDERER_CLEAR_DEPTH_DO;
 	return renderer_add_pass( pass );
 }
 
 u8 renderer_add_pass( const char * name, ClearColourBool clear_colour, ClearDepthBool clear_depth ) {
 	FB target = { };
 	return renderer_add_pass( name, target, clear_colour, clear_depth );
 }
 
 void renderer_resolve_msaa( FB fb ) {
 	RenderPass pass;
 	pass.name = "Resolve MSAA";
 	pass.msaa_source = fb;
 
 	RenderState dummy;
 	dummy.pass = renderer_add_pass( pass );
 	dummy.shader = NULL;
 
 	DrawCall dc;
 	dc.render_state = dummy;
 	draw_calls.add( dc );
 }
 
 u32 renderer_num_draw_calls() {
 	return draw_calls_this_frame;
 }
 
 u32 renderer_num_vertices() {
 	return vertices_this_frame;
 }
 
 Texture renderer_blue_noise() {
 	return blue_noise;
 }
 
 UniformBinding renderer_upload_uniforms( const void * data, size_t size ) {
 	ASSERT( in_frame );
 
 	UBO * ubo = NULL;
 	u32 offset;
 
 	for( size_t i = 0; i < ARRAY_COUNT( ubos ); i++ ) {
 		offset = checked_cast< u32 >( align_power_of_2( ubos[ i ].bytes_used, ubo_offset_alignment ) );
 		if( UNIFORM_BUFFER_SIZE - offset >= size ) {
 			ubo = &ubos[ i ];
 			break;
 		}
 	}
 
 	if( ubo == NULL )
 		FATAL( "no ubo space" );
 
 	UniformBinding binding;
 	binding.ubo = ubo->ubo;
 	binding.offset = offset;
 	binding.size = checked_cast< u32 >( size );
 
 	// memset so we don't leave any gaps. good for write combined memory!
 	memset( ubo->buffer + ubo->bytes_used, 0, offset - ubo->bytes_used );
 	memcpy( ubo->buffer + offset, data, size );
 	ubo->bytes_used = offset + size;
 
 	return binding;
 }
 
 static GLenum bufferusage_to_glenum( BufferUsage usage ) {
 	switch( usage ) {
 		case BUFFERUSAGE_STATIC: return GL_STATIC_DRAW;
 		case BUFFERUSAGE_DYNAMIC: return GL_DYNAMIC_DRAW;
 		case BUFFERUSAGE_STREAM: return GL_STREAM_DRAW;
 	}
 
 	FATAL( "unsupported BufferUsage: {}", usage );
 	return GL_INVALID_ENUM;
 }
 
 static GLenum texfmt_to_internal_format( TextureFormat format ) {
 	switch( format ) {
 		case TEXFMT_INVALID:
 			break;
 
 		case TEXFMT_R_U8:
 			return GL_R8;
 		case TEXFMT_R_U8NORM:
 			return GL_R8_SNORM;
 		case TEXFMT_R_U16:
 			return GL_R16;
 		case TEXFMT_R_FLOAT:
 			return GL_R32F;
 
 		case TEXFMT_RGB_U8:
 			return GL_RGB8;
 		case TEXFMT_RGB_U8_SRGB:
 			return GL_SRGB8;
 		case TEXFMT_RGB_HALF:
 			return GL_RGB16F;
 		case TEXFMT_RGB_FLOAT:
 			return GL_RGB32F;
 
 		case TEXFMT_RGBA_U8:
 			return GL_RGBA8;
 		case TEXFMT_RGBA_U8_SRGB:
 			return GL_SRGB8_ALPHA8;
 		case TEXFMT_RGBA_FLOAT:
 			return GL_RGBA32F;
 
 		case TEXFMT_DEPTH:
 			return GL_DEPTH_COMPONENT24;
 
 		case TEXFMT_BC1:
 			return GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
 		case TEXFMT_BC1_SRGB:
 			return GL_COMPRESSED_SRGB_S3TC_DXT1_EXT;
 		case TEXFMT_BC4:
 			return GL_COMPRESSED_RED_RGTC1;
 		case TEXFMT_BC5:
 			return GL_COMPRESSED_RG_RGTC2;
 	}
 
 	FATAL( "unsupported TextureFormat: {}", format );
 	return GL_INVALID_ENUM;
 }
 
 static GLenum texturewrap_to_glenum( TextureWrapMode mode ) {
 	switch( mode ) {
 		case TEXWRAP_REPEAT:
 			return GL_REPEAT;
 		case TEXWRAP_CLAMP:
 			return GL_CLAMP_TO_EDGE;
 		case TEXWRAP_MIRROR:
 			return GL_MIRRORED_REPEAT;
 		case TEXWRAP_BORDER:
 			return GL_CLAMP_TO_BORDER;
 	}
 
 	FATAL( "unsupported TextureWrapMode: {}", mode );
 	return GL_INVALID_ENUM;
 }
 
 static void texturefilter_to_glenum( TextureFilterMode mode, bool mipmaps, GLenum * min_filter, GLenum * mag_filter ) {
 	switch( mode ) {
 		case TEXFILTER_LINEAR:
 			*min_filter = mipmaps ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR;
 			*mag_filter = GL_LINEAR;
 			return;
 		case TEXFILTER_POINT:
 			*min_filter = mipmaps ? GL_NEAREST_MIPMAP_NEAREST : GL_NEAREST;
 			*mag_filter = GL_NEAREST;
 			return;
 	}
 
 	FATAL( "unsupported TextureFilterMode: {}", mode );
 }
 
 static bool is_compressed( TextureFormat format ) {
 	return format == TEXFMT_BC1 || format == TEXFMT_BC4 || format == TEXFMT_BC5;
 }
 
 VB renderer_new_vb( const void * data, u32 len, BufferUsage usage ) {
 	// glBufferData's length parameter is GLsizeiptr, so we need to make
 	// sure len fits in a signed 32bit int
 	ASSERT( len < S32_MAX );
 
 	GLuint vbo;
 	glGenBuffers( 1, &vbo );
 
 	if( data != NULL ) {
 		glBindBuffer( GL_ARRAY_BUFFER, vbo );
 		glBufferData( GL_ARRAY_BUFFER, len, data, bufferusage_to_glenum( usage ) );
 	}
 
 	return vbo;
 }
 
 void renderer_delete_vb( VB vb ) {
 	glDeleteBuffers( 1, &vb );
 }
 
 IB renderer_new_ib( const void * data, u32 len, BufferUsage usage ) {
 	ASSERT( len < S32_MAX );
 
 	GLuint ebo;
 	glGenBuffers( 1, &ebo );
 
 	if( data != NULL ) {
 		glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, ebo );
 		glBufferData( GL_ELEMENT_ARRAY_BUFFER, len, data, bufferusage_to_glenum( usage ) );
 	}
 
 	return ebo;
 }
 
 void renderer_delete_ib( IB ib ) {
 	glDeleteBuffers( 1, &ib );
 }
 
 static u32 mipmap_dim( u32 dim, u32 level ) {
 	return max( dim >> level, u32( 1 ) );
 }
 
 // TODO: use clz
 static u32 mipmap_levels( u32 width, u32 height ) {
 	u32 levels = 1;
 	u32 dim = max( width, height );
 	while( dim > 1 ) {
 		dim >>= 1;
 		levels++;
 	}
 	return levels;
 }
 
 static u32 texture_byte_size( u32 width, u32 height, TextureFormat format, bool mipmaps ) {
 	u32 total_dim = width * height;
 	if( mipmaps ) {
 		for( u32 i = 1; i < mipmap_levels( width, height ); i++ ) {
 			total_dim += mipmap_dim( width, i ) * mipmap_dim( height, i );
 		}
 	}
 
 	switch( format ) {
 		case TEXFMT_INVALID:
 		case TEXFMT_DEPTH:
 			break;
 
 		case TEXFMT_R_U8:
 		case TEXFMT_R_U8NORM:
 			return total_dim * 1 * sizeof( u8 );
 		case TEXFMT_R_U16:
 			return total_dim * 1 * sizeof( u16 );
 		case TEXFMT_R_FLOAT:
 			return total_dim * 1 * sizeof( float );
 
 		case TEXFMT_RGB_U8:
 			return total_dim * 3 * sizeof( u8 );
 		case TEXFMT_RGB_U8_SRGB:
 			return total_dim * 3 * sizeof( u8 );
 		case TEXFMT_RGB_HALF:
 			return total_dim * 3 * sizeof( u16 );
 		case TEXFMT_RGB_FLOAT:
 			return total_dim * 3 * sizeof( float );
 
 		case TEXFMT_RGBA_U8:
 			return total_dim * 4 * sizeof( u8 );
 		case TEXFMT_RGBA_U8_SRGB:
 			return total_dim * 4 * sizeof( u8 );
 		case TEXFMT_RGBA_FLOAT:
 			return total_dim * 4 * sizeof( float );
 
 		case TEXFMT_BC1:
 		case TEXFMT_BC1_SRGB:
 			return total_dim / 2;
 		case TEXFMT_BC4:
 			return total_dim / 2;
 		case TEXFMT_BC5:
 			return total_dim;
 	}
 
 	FATAL( "unsupported TextureFormat: {}", format );
 	return GL_INVALID_ENUM;
 }
 
 static Texture new_texture( TextureConfig config, int msaa_samples ) {
 	ASSERT( config.format != TEXFMT_INVALID );
 	ASSERT( !is_compressed( config.format ) || msaa_samples == 0 );
 	ASSERT( !config.has_mipmaps ); // TODO
 
 	GLenum target = msaa_samples == 0 ? GL_TEXTURE_2D : GL_TEXTURE_2D_MULTISAMPLE;
 
 	GLuint texture;
 	glGenTextures( 1, &texture );
 	// TODO: should probably update the gl state since we bind a new texture
 	glBindTexture( target, texture );
 
 	if( msaa_samples == 0 ) {
 		glTexParameteri( target, GL_TEXTURE_WRAP_S, texturewrap_to_glenum( config.wrap ) );
 		glTexParameteri( target, GL_TEXTURE_WRAP_T, texturewrap_to_glenum( config.wrap ) );
 
 		GLenum min_filter, mag_filter;
 		texturefilter_to_glenum( config.filter, config.has_mipmaps, &min_filter, &mag_filter );
 		glTexParameteri( target, GL_TEXTURE_MIN_FILTER, min_filter );
 		glTexParameteri( target, GL_TEXTURE_MAG_FILTER, mag_filter );
 
 		if( config.wrap == TEXWRAP_BORDER ) {
 			glTexParameterfv( target, GL_TEXTURE_BORDER_COLOR, ( GLfloat * ) &config.border_colour );
 		}
 	}
 
 	GLenum internal_format = texfmt_to_internal_format( config.format );
 
 	if( is_compressed( config.format ) ) {
 		u32 dxt_size = texture_byte_size( config.width, config.height, config.format, false );
 		glCompressedTexImage2D( GL_TEXTURE_2D, 0, internal_format,
 			config.width, config.height, 0, dxt_size, config.data );
 	}
 	else {
 		GLenum channels = GL_INVALID_ENUM;
 		GLenum type = GL_INVALID_ENUM;
 
 		switch( config.format ) {
 			case TEXFMT_R_U8:
 			case TEXFMT_R_U8NORM:
 				channels = GL_RED;
 				type = GL_UNSIGNED_BYTE;
 				break;
 			case TEXFMT_R_U16:
 				channels = GL_RED;
 				type = GL_UNSIGNED_SHORT;
 				break;
 			case TEXFMT_R_FLOAT:
 				channels = GL_RED;
 				type = GL_FLOAT;
 				break;
 
 			case TEXFMT_RGB_U8:
 			case TEXFMT_RGB_U8_SRGB:
 				channels = GL_RGB;
 				type = GL_UNSIGNED_BYTE;
 				break;
 			case TEXFMT_RGB_HALF:
 				channels = GL_RGB;
 				type = GL_HALF_FLOAT;
 				break;
 			case TEXFMT_RGB_FLOAT:
 				channels = GL_RGB;
 				type = GL_FLOAT;
 				break;
 
 			case TEXFMT_RGBA_U8:
 			case TEXFMT_RGBA_U8_SRGB:
 				channels = GL_RGBA;
 				type = GL_UNSIGNED_BYTE;
 				break;
 			case TEXFMT_RGBA_FLOAT:
 				channels = GL_RGBA;
 				type = GL_FLOAT;
 				break;
 
 			case TEXFMT_DEPTH:
 				channels = GL_DEPTH_COMPONENT;
 				type = GL_FLOAT;
 				break;
 
 			default:
 				FATAL( "implement channel/type selection for {}", config.format );
 				break;
 		}
 
 		if( msaa_samples == 0 ) {
 			glTexImage2D( GL_TEXTURE_2D, 0, internal_format,
 				config.width, config.height, 0, channels, type, config.data );
 		}
 		else {
 			glTexImage2DMultisample( GL_TEXTURE_2D_MULTISAMPLE, msaa_samples,
 				internal_format, config.width, config.height, GL_TRUE );
 		}
 	}
 
 	return texture;
 }
 
 Texture renderer_new_texture( const TextureConfig & config ) {
 	return new_texture( config, 0 );
 }
 
 void renderer_delete_texture( Texture texture ) {
 	glDeleteTextures( 1, &texture );
 }
 
 static GLenum framebufferattachment_to_glenum( FramebufferAttachment attachment ) {
 	switch( attachment ) {
 		case FB_COLOUR: return GL_COLOR_ATTACHMENT0;
 		case FB_DEPTH: return GL_DEPTH_ATTACHMENT;
 		case FB_NORMAL: return GL_COLOR_ATTACHMENT1;
 	}
 
 	FATAL( "invalid FramebufferAttachment: {}", attachment );
 	return GL_INVALID_ENUM;
 }
 
 FB renderer_new_fb( const FramebufferConfig & config ) {
 	GLuint fbo;
 	glGenFramebuffers( 1, &fbo );
 	glBindFramebuffer( GL_FRAMEBUFFER, fbo );
 
 	FB fb;
 	fb.fbo = fbo;
 
 	u32 width = 0;
 	u32 height = 0;
 	GLenum bufs[ OUTPUTS_COUNT ];
 
 	for( size_t i = 0; i < config.textures.size(); i++ ) {
 		bufs[ i ] = GL_NONE;
 
 		const TextureConfig & texture_config = config.textures[ i ].config;
 		if( texture_config.format == TEXFMT_INVALID )
 			continue;
 
 		ASSERT( !is_compressed( texture_config.format ) );
 
 		GLenum attachment = framebufferattachment_to_glenum( config.textures[ i ].attachment );
 		Texture texture = new_texture( texture_config, config.msaa_samples );
 
 		GLenum target = config.msaa_samples == 0 ? GL_TEXTURE_2D : GL_TEXTURE_2D_MULTISAMPLE;
 		glFramebufferTexture2D( GL_FRAMEBUFFER, attachment, target, texture, 0 );
 
 		width = texture_config.width;
 		height = texture_config.height;
 		fb.textures[ i ] = texture;
 		if( config.textures[ i ].attachment != FB_DEPTH )
 			bufs[ i ] = attachment;
 	}
 
 	glDrawBuffers( ARRAY_COUNT( bufs ), bufs );
 
 	ASSERT( glCheckFramebufferStatus( GL_FRAMEBUFFER ) == GL_FRAMEBUFFER_COMPLETE );
 	ASSERT( width > 0 && height > 0 );
 	glBindFramebuffer( GL_FRAMEBUFFER, 0 );
 
 	fb.width = width;
 	fb.height = height;
 
 	return fb;
 }
 
 FB renderer_new_fb( TextureConfig texture_config, FramebufferAttachment attachment ) {
 	FramebufferConfig config;
 	config.textures[ 0 ].config = texture_config;
 	config.textures[ 0 ].attachment = attachment;
 	return renderer_new_fb( config );
 }
 
 void renderer_delete_fb( FB fb ) {
 	if( fb.fbo == 0 )
 		return;
 
 	glDeleteFramebuffers( 1, &fb.fbo );
 	for( Texture texture : fb.textures ) {
 		if( texture != 0 ) {
 			glDeleteTextures( 1, &texture );
 		}
 	}
 }
 
 static GLuint new_gl_shader( GLenum type, array< const char * > srcs ) {
 	StaticArray< const char *, 16 > full_srcs;
 	full_srcs[ 0 ] = "#version 330\n";
 	full_srcs[ 1 ] = type == GL_VERTEX_SHADER ? "#define VERTEX_SHADER 1\n" : "#define FRAGMENT_SHADER 1\n";
 	GLsizei n = 2;
 	for( size_t i = 0; i < srcs.n; i++ ) {
 		if( srcs[ i ] != NULL ) {
 			full_srcs[ n ] = srcs[ i ];
 			n++;
 		}
 	}
 
 	GLuint shader = glCreateShader( type );
 	glShaderSource( shader, n, full_srcs.ptr(), NULL );
 	glCompileShader( shader );
 
 	GLint status;
 	glGetShaderiv( shader, GL_COMPILE_STATUS, &status );
 
 	if( status == GL_FALSE ) {
 		char buf[ 1024 ];
 		glGetShaderInfoLog( shader, sizeof( buf ), NULL, buf );
 		WARN( "shader compilation failed: {}", buf );
 		glDeleteShader( shader );
 
 		// static char src[ 65536 ];
 		// glGetShaderSource( shader, sizeof( src ), NULL, src );
 		// printf( "%s\n", src );
 
 		return 0;
 	}
 
 	return shader;
 }
 
 Shader renderer_new_shader( array< const char * > srcs ) {
 	Shader shader = { };
 
 	GLuint vs = new_gl_shader( GL_VERTEX_SHADER, srcs );
 	GLuint fs = new_gl_shader( GL_FRAGMENT_SHADER, srcs );
 
 	if( vs == 0 || fs == 0 ) {
 		return shader;
 	}
 
 	GLuint program = glCreateProgram();
 	glAttachShader( program, vs );
 	glAttachShader( program, fs );
 
 	glBindAttribLocation( program, ATTR_POSITION, "position" );
 	glBindAttribLocation( program, ATTR_NORMAL, "normal" );
 	glBindAttribLocation( program, ATTR_TEX_COORD0, "tex_coord0" );
 	glBindAttribLocation( program, ATTR_TEX_COORD1, "tex_coord1" );
 	glBindAttribLocation( program, ATTR_COLOUR, "colour" );
 	glBindAttribLocation( program, ATTR_JOINTS, "joints" );
 	glBindAttribLocation( program, ATTR_WEIGHTS, "weights" );
 	glBindAttribLocation( program, ATTR_MODEL_TO_WORLD_COL0, "model_to_world" );
 
 	glBindFragDataLocation( program, 0, "output_albedo" );
 	glBindFragDataLocation( program, 1, "output_normal" );
 
 	glLinkProgram( program );
 
 	glDeleteShader( vs );
 	glDeleteShader( fs );
 
 	GLint status;
 	glGetProgramiv( program, GL_LINK_STATUS, &status );
 	if( status == GL_FALSE ) {
 		char buf[ 1024 ];
 		glGetProgramInfoLog( program, sizeof( buf ), NULL, buf );
 		WARN( "shader linking failed: {}", buf );
 
 		return shader;
 	}
 
 
 	glUseProgram( program );
 	shader.program = program;
 
 	GLint count, maxlen;
 	glGetProgramiv( program, GL_ACTIVE_UNIFORMS, &count );
 	glGetProgramiv( program, GL_ACTIVE_UNIFORM_MAX_LENGTH, &maxlen );
 
 	size_t numtextures = 0;
 	for( GLint i = 0; i < count; i++ ) {
 		char name[ 128 ];
 		GLint size, len;
 		GLenum type;
 		glGetActiveUniform( program, i, sizeof( name ), &len, &size, &type, name );
 
 		if( type == GL_SAMPLER_2D ) {
 			glUniform1i( glGetUniformLocation( program, name ), numtextures );
 			shader.textures[ numtextures ] = fnv1a32( name, len );
 			numtextures++;
 		}
 	}
 
 	glGetProgramiv( program, GL_ACTIVE_UNIFORM_BLOCKS, &count );
 	glGetProgramiv( program, GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH, &maxlen );
 
 	size_t numubos = 0;
 	for( GLint i = 0; i < count; i++ ) {
 		char name[ 128 ];
 		GLint len;
 		glGetActiveUniformBlockName( program, i, sizeof( name ), &len, name );
 		glUniformBlockBinding( program, i, numubos );
 		shader.uniforms[ numubos ] = fnv1a32( name, len );
 		numubos++;
 	}
 
 	glUseProgram( 0 );
 
 	return shader;
 }
 
 void renderer_delete_shader( Shader shader ) {
 	glDeleteProgram( shader.program );
 }
 
 static void vertexfmt_to_glenum( VertexFormat format, GLenum * type, int * components ) {
 	switch( format ) {
 		case VERTEXFMT_U8x3:
 			*type = GL_UNSIGNED_BYTE;
 			*components = 3;
 			break;
 		case VERTEXFMT_U8x4:
 			*type = GL_UNSIGNED_BYTE;
 			*components = 4;
 			break;
 
 		case VERTEXFMT_U16x4:
 			*type = GL_UNSIGNED_SHORT;
 			*components = 4;
 			break;
 
 		case VERTEXFMT_HALFx2:
 			*type = GL_HALF_FLOAT;
 			*components = 2;
 			break;
 		case VERTEXFMT_HALFx3:
 			*type = GL_HALF_FLOAT;
 			*components = 3;
 			break;
 		case VERTEXFMT_HALFx4:
 			*type = GL_HALF_FLOAT;
 			*components = 4;
 			break;
 
 		case VERTEXFMT_FLOATx2:
 			*type = GL_FLOAT;
 			*components = 2;
 			break;
 		case VERTEXFMT_FLOATx3:
 			*type = GL_FLOAT;
 			*components = 3;
 			break;
 		case VERTEXFMT_FLOATx4:
 			*type = GL_FLOAT;
 			*components = 4;
 			break;
 	}
 }
 
 static void setup_vertex_attrib( GLuint index, VertexFormat format, u32 stride = 0, u32 offset = 0 ) {
 	GLvoid * gl_offset = checked_cast< GLvoid * >( checked_cast< uptr >( offset ) );
 	GLenum type;
 	int components;
 	vertexfmt_to_glenum( format, &type, &components );
 
 	GLboolean normalized = index == ATTR_WEIGHTS;
 
 	glEnableVertexAttribArray( index );
 	if( index == ATTR_JOINTS )
 		glVertexAttribIPointer( index, components, type, stride, gl_offset );
 	else
 		glVertexAttribPointer( index, components, type, normalized, stride, gl_offset );
 }
 
 Mesh renderer_new_mesh( MeshConfig config ) {
 	ASSERT( config.num_vertices != 0 );
 
 	switch( config.primitive_type ) {
 		case PRIMITIVETYPE_TRIANGLES:
 			ASSERT( config.num_vertices % 3 == 0 );
 			break;
 		case PRIMITIVETYPE_TRIANGLE_STRIP:
 			ASSERT( config.num_vertices >= 3 );
 			break;
 		case PRIMITIVETYPE_POINTS:
 			break;
 		case PRIMITIVETYPE_LINES:
 			ASSERT( config.num_vertices % 2 == 0 );
 			break;
 	}
 
 	GLuint vao;
 	glGenVertexArrays( 1, &vao );
 	glBindVertexArray( vao );
 
 	if( config.unified_buffer == 0 ) {
 		ASSERT( config.positions != 0 );
 
 		glBindBuffer( GL_ARRAY_BUFFER, config.positions );
 		setup_vertex_attrib( ATTR_POSITION, config.positions_format );
 
 		if( config.normals != 0 ) {
 			glBindBuffer( GL_ARRAY_BUFFER, config.normals );
 			setup_vertex_attrib( ATTR_NORMAL, config.normals_format );
 		}
 
 		if( config.tex_coords0 != 0 ) {
 			glBindBuffer( GL_ARRAY_BUFFER, config.tex_coords0 );
 			setup_vertex_attrib( ATTR_TEX_COORD0, config.tex_coords0_format );
 		}
 
 		if( config.tex_coords1 != 0 ) {
 			glBindBuffer( GL_ARRAY_BUFFER, config.tex_coords1 );
 			setup_vertex_attrib( ATTR_TEX_COORD1, config.tex_coords1_format );
 		}
 
 		if( config.colours != 0 ) {
 			glBindBuffer( GL_ARRAY_BUFFER, config.colours );
 			setup_vertex_attrib( ATTR_COLOUR, config.colours_format );
 		}
 
 		if( config.joints != 0 ) {
 			glBindBuffer( GL_ARRAY_BUFFER, config.joints );
 			setup_vertex_attrib( ATTR_JOINTS, config.joints_format );
 		}
 
 		if( config.weights != 0 ) {
 			glBindBuffer( GL_ARRAY_BUFFER, config.weights );
 			setup_vertex_attrib( ATTR_WEIGHTS, config.weights_format );
 		}
 	}
 	else {
 		ASSERT( config.stride != 0 );
 
 		glBindBuffer( GL_ARRAY_BUFFER, config.unified_buffer );
 
 		setup_vertex_attrib( ATTR_POSITION, config.positions_format, config.stride, config.positions_offset );
 
 		if( config.normals_offset != 0 ) {
 			setup_vertex_attrib( ATTR_NORMAL, config.normals_format, config.stride, config.normals_offset );
 		}
 
 		if( config.tex_coords0_offset != 0 ) {
 			setup_vertex_attrib( ATTR_TEX_COORD0, config.tex_coords0_format, config.stride, config.tex_coords0_offset );
 		}
 
 		if( config.tex_coords1_offset != 0 ) {
 			setup_vertex_attrib( ATTR_TEX_COORD1, config.tex_coords1_format, config.stride, config.tex_coords1_offset );
 		}
 
 		if( config.colours_offset != 0 ) {
 			setup_vertex_attrib( ATTR_COLOUR, config.colours_format, config.stride, config.colours_offset );
 		}
 
 		if( config.joints_offset != 0 ) {
 			setup_vertex_attrib( ATTR_JOINTS, config.joints_format, config.stride, config.joints_offset );
 		}
 
 		if( config.weights_offset != 0 ) {
 			setup_vertex_attrib( ATTR_WEIGHTS, config.weights_format, config.stride, config.weights_offset );
 		}
 	}
 
 	if( config.indices != 0 ) {
 		glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, config.indices );
 	}
 
 	glBindVertexArray( 0 );
 
 	Mesh mesh = { };
 	mesh.num_vertices = config.num_vertices;
 	mesh.primitive_type = config.primitive_type;
 	mesh.vao = vao;
 	if( config.unified_buffer == 0 ) {
 		mesh.positions = config.positions;
 		mesh.normals = config.normals;
 		mesh.tex_coords0 = config.tex_coords0;
 		mesh.tex_coords1 = config.tex_coords1;
 		mesh.colours = config.colours;
 		mesh.joints = config.joints;
 		mesh.weights = config.weights;
 	}
 	else {
 		mesh.positions = config.unified_buffer;
 	}
 	mesh.indices = config.indices;
 	mesh.indices_format = config.indices_format;
 
 	return mesh;
 }
 
 void renderer_delete_mesh( const Mesh & mesh ) {
 	DeleteCommand command;
 	command.type = DELETE_MESH;
 	command.mesh = mesh;
 	deletes.add( command );
 }
 
 void renderer_draw_mesh( const Mesh & mesh, const RenderState & render_state ) {
 	ASSERT( in_frame );
 	ASSERT( render_state.pass != U8_MAX );
 	ASSERT( render_state.shader != NULL );
 
 	DrawCall dc;
 	dc.mesh = mesh;
 	dc.render_state = render_state;
 	dc.num_instances = 0;
 	dc.instance_data = 0;
 	draw_calls.add( dc );
 
 	draw_calls_this_frame++;
 	vertices_this_frame += mesh.num_vertices;
 }
 
 void renderer_draw_instances( const Mesh & mesh, const RenderState & render_state, u32 num_instances, VB instance_data ) {
 	ASSERT( in_frame );
 
 	if( num_instances == 0 ) {
 		return;
 	}
 
 	DrawCall dc;
 	dc.mesh = mesh;
 	dc.render_state = render_state;
 	dc.num_instances = num_instances;
 	dc.instance_data = instance_data;
 	draw_calls.add( dc );
 
 	draw_calls_this_frame++;
 	vertices_this_frame += mesh.num_vertices * num_instances;
 }
 
 void renderer_draw_fullscreen_triangle( const RenderState & render_state ) {
 	renderer_draw_mesh( fullscreen_triangle, render_state );
 }