medfall

gltf.cc (19434B)

---

 #include "game.h"
 #include "intrinsics.h"
 #include "log.h"
 #include "linear_algebra.h"
 #include "gl.h"
 #include "immediate.h"
 #include "renderer.h"
 #include "shaders.h"
 
 #include "platform_time.h"
 
 #include "libs/cgltf/cgltf.h"
 
 typedef quat Quaternion;
 typedef v3 Vec3;
 typedef m4 Mat4;
 
 #define Lerp lerp
 #define NLerp nlerp
 
 struct SQT {
 	Quaternion rotation;
 	Vec3 translation;
 	float scale;
 };
 
 inline void format( FormatBuffer * fb, const SQT & sqt, const FormatOpts & opts ) {
 	format( fb, "SQT(" );
 	format( fb, sqt.rotation, opts );
 	format( fb, ", " );
 	format( fb, sqt.translation, opts );
 	format( fb, ", " );
 	format( fb, sqt.scale, opts );
 	format( fb, ")" );
 }
 
 static Mat4 SQTToMat4( const SQT & sqt ) {
 	quat q = sqt.rotation;
 	v3 t = sqt.translation;
 	float s = sqt.scale;
 
 	// return t * q * s;
 	return Mat4(
 		( 1.0f - 2 * q.y * q.y - 2.0f * q.z * q.z ) * s,
 		( 2.0f * q.x * q.y - 2.0f * q.z * q.w ) * s,
 		( 2.0f * q.x * q.z + 2.0f * q.y * q.w ) * s,
 		t.x,
 
 		( 2.0f * q.x * q.y + 2.0f * q.z * q.w ) * s,
 		( 1.0f - 2.0f * q.x * q.x - 2.0f * q.z * q.z ) * s,
 		( 2.0f * q.y * q.z - 2.0f * q.x * q.w ) * s,
 		t.y,
 
 		( 2.0f * q.x * q.z - 2.0f * q.y * q.w ) * s,
 		( 2.0f * q.y * q.z + 2.0f * q.x * q.w ) * s,
 		( 1.0f - 2.0f * q.x * q.x - 2.0f * q.y * q.y ) * s,
 		t.z,
 
 		0.0f, 0.0f, 0.0f, 1.0f
 	);
 }
 
 struct AnimationReel {
 	template< typename T >
 	struct Channel {
 		T * samples;
 		float * times;
 		u32 num_samples;
 	};
 
 	struct Joint {
 		Mat4 joint_to_bind;
 		u8 parent;
 		u8 next;
 
 		Channel< Quaternion > rotations;
 		Channel< Vec3 > translations;
 		Channel< float > scales;
 	};
 
 	struct Clip {
 		float start_time;
 		float duration;
 		bool loop;
 	};
 
 	Joint * joints;
 	u8 num_joints;
 	u8 root_joint;
 
 	Clip * clips;
 	u32 num_clips;
 };
 
 float PositiveMod( float x, float y ) {
 	float res = fmodf( x, y );
 	if( res < 0 )
 		res += y;
 	return res;
 }
 
 void SampleAnimationChannel( const float * times, u32 n, float t, u32 * sample, float * lerp_frac ) {
 	t = clamp( times[ 0 ], t, times[ n - 1 ] );
 
 	*sample = 0;
 	for( u32 i = 1; i < n; i++ ) {
 		if( times[ i ] >= t ) {
 			*sample = i - 1;
 			break;
 		}
 	}
 
 	*lerp_frac = ( t - times[ *sample ] ) / ( times[ *sample + 1 ] - times[ *sample ] );
 }
 
 void SampleAnimationClip( const AnimationReel & reel, u32 clip_idx, float t, float start_time, SQT * joint_poses ) {
 	AnimationReel::Clip clip = reel.clips[ clip_idx ];
 
 	float local_time;
 	if( clip.loop ) {
 		local_time = PositiveMod( t - start_time, clip.duration );
 	}
 	else {
 		local_time = clamp( 0.0f, t - start_time, clip.duration );
 	}
 
 	for( u8 i = 0; i < reel.num_joints; i++ ) {
 		joint_poses[ i ].rotation = quat_identity();
                 joint_poses[ i ].translation = Vec3( 0 );
                 joint_poses[ i ].scale = 1.0f;
 
                 const AnimationReel::Joint & joint = reel.joints[ i ];
 
                 if( joint.rotations.samples != NULL ) {
 			if( joint.rotations.num_samples == 1 ) {
 				joint_poses[ i ].rotation = joint.rotations.samples[ 0 ];
 			}
 			else {
 				u32 sample;
 				float lerp_frac;
 				SampleAnimationChannel( joint.rotations.times, joint.rotations.num_samples, local_time, &sample, &lerp_frac );
 				joint_poses[ i ].rotation = NLerp( joint.rotations.samples[ sample ], lerp_frac, joint.rotations.samples[ ( sample + 1 ) % joint.rotations.num_samples ] );
 			}
                 }
 
                 if( joint.translations.samples != NULL ) {
 			if( joint.translations.num_samples == 1 ) {
 				joint_poses[ i ].translation = joint.translations.samples[ 0 ];
 			}
 			else {
 				u32 sample;
 				float lerp_frac;
 				SampleAnimationChannel( joint.translations.times, joint.translations.num_samples, local_time, &sample, &lerp_frac );
 				joint_poses[ i ].translation = Lerp( joint.translations.samples[ sample ], lerp_frac, joint.translations.samples[ ( sample + 1 ) % joint.translations. num_samples ] );
 			}
                 }
 
                 if( joint.scales.samples != NULL ) {
 			if( joint.scales.num_samples == 1 ) {
 				joint_poses[ i ].scale = joint.scales.samples[ 0 ];
 			}
 			else {
 				u32 sample;
 				float lerp_frac;
 				SampleAnimationChannel( joint.scales.times, joint.scales.num_samples, local_time, &sample, &lerp_frac );
 				joint_poses[ i ].scale = Lerp( joint.scales.samples[ sample ], lerp_frac, joint.scales.samples[ ( sample + 1 ) % joint.scales.num_samples ] );
 			}
                 }
         }
 }
 
 void ComputeMatrixPalette( const AnimationReel & animation, const SQT * sqts, Mat4 * joint_poses, Mat4 * skinning_matrices ) {
 	u8 joint_idx = animation.root_joint;
 	for( u32 i = 0; i < animation.num_joints; i++ ) {
 		u8 parent = animation.joints[ joint_idx ].parent;
 		if( parent != U8_MAX ) {
 			joint_poses[ joint_idx ] = joint_poses[ parent ] * SQTToMat4( sqts[ joint_idx ] );
 		}
 		else {
 			joint_poses[ joint_idx ] = SQTToMat4( sqts[ joint_idx ] );
 		}
 		joint_idx = animation.joints[ joint_idx ].next;
 	}
 
 	for( u32 i = 0; i < animation.num_joints; i++ ) {
 		skinning_matrices[ i ] = joint_poses[ i ] * animation.joints[ i ].joint_to_bind;
 	}
 }
 
 struct GLTFModel {
 	Mesh meshes[ 16 ];
 	u32 num_meshes;
 
 	AnimationReel animation;
 };
 
 // like cgltf_load_buffers, but doesn't try to load URIs
 static bool LoadBinaryBuffers( cgltf_data * data ) {
 	if( data->buffers_count && data->buffers[0].data == NULL && data->buffers[0].uri == NULL && data->bin ) {
 		if( data->bin_size < data->buffers[0].size )
 			return false;
 		data->buffers[0].data = const_cast< void * >( data->bin );
 	}
 
 	for( cgltf_size i = 0; i < data->buffers_count; i++ ) {
 		if( data->buffers[i].data == NULL )
 			return false;
 	}
 
 	return true;
 }
 
 static AnimationReel::Clip CLIP;
 static GLTFModel model;
 
 static u8 GetJointIdx( const cgltf_node * node ) {
 	return u8( uintptr_t( node->camera ) - 1 );
 }
 
 static void SetJointIdx( cgltf_node * node, u8 joint_idx ) {
 	node->camera = ( cgltf_camera * ) uintptr_t( joint_idx + 1 );
 }
 
 static void AddJoint( const cgltf_skin * skin, cgltf_node * node, u8 ** prev ) {
 	u8 joint_idx = GetJointIdx( node );
 	**prev = joint_idx;
 	*prev = &model.animation.joints[ joint_idx ].next;
 
 	model.animation.joints[ joint_idx ].parent = node->parent != NULL ? GetJointIdx( node->parent ) : U8_MAX;
 
 	cgltf_bool ok = cgltf_accessor_read_float( skin->inverse_bind_matrices, joint_idx, model.animation.joints[ joint_idx ].joint_to_bind.ptr(), 16 );
 	ASSERT( ok != 0 );
 
 	for( size_t i = 0; i < node->children_count; i++ ) {
 		AddJoint( skin, node->children[ i ], prev );
 	}
 }
 
 static void LoadSkin( const cgltf_skin * skin ) {
 	model.animation.joints = ( AnimationReel::Joint * ) malloc( sizeof( AnimationReel::Joint ) * skin->joints_count );
 	model.animation.num_joints = skin->joints_count;
 	memset( model.animation.joints, 0, sizeof( AnimationReel::Joint ) * skin->joints_count );
 
 	for( size_t i = 0; i < skin->joints_count; i++ ) {
 		SetJointIdx( skin->joints[ i ], i );
 	}
 
 	u8 * prev_ptr = &model.animation.root_joint;
 	for( size_t i = 0; i < skin->joints_count; i++ ) {
 		if( skin->joints[ i ]->parent == NULL || GetJointIdx( skin->joints[ i ]->parent ) == U8_MAX ) {
 			ggprint( "root {}\n", skin->joints[ i ]->name );
 			AddJoint( skin, skin->joints[ i ], &prev_ptr );
 		}
 	}
 }
 
 const char * pathtype( cgltf_animation_path_type type ) {
 	if( type == cgltf_animation_path_type_translation ) return "translation";
 	if( type == cgltf_animation_path_type_rotation ) return "rotation";
 	if( type == cgltf_animation_path_type_scale ) return "scale";
 	if( type == cgltf_animation_path_type_weights ) return "weights";
 	return "invalid";
 }
 
 template< typename T >
 static void LoadChannel( const cgltf_animation_channel * chan, AnimationReel::Channel< T > * out_channel ) {
 	constexpr size_t lanes = sizeof( T ) / sizeof( float );
 	size_t n = chan->sampler->input->count;
 
 	float * memory = ( float * ) malloc( n * ( lanes + 1 ) * sizeof( float ) );
 	out_channel->times = memory;
 	out_channel->samples = ( T * ) ( memory + n );
 	out_channel->num_samples = n;
 
 	for( size_t i = 0; i < n; i++ ) {
 		cgltf_bool ok = cgltf_accessor_read_float( chan->sampler->input, i, &out_channel->times[ i ], 1 );
 		ok = ok && cgltf_accessor_read_float( chan->sampler->output, i, out_channel->samples[ i ].ptr(), lanes );
 		ASSERT( ok != 0 );
 	}
 }
 
 static void LoadScaleChannel( const cgltf_animation_channel * chan, AnimationReel::Channel< float > * out_channel ) {
 	size_t n = chan->sampler->input->count;
 
 	float * memory = ( float * ) malloc( n * 2 * sizeof( float ) );
 	out_channel->times = memory;
 	out_channel->samples = memory + n;
 	out_channel->num_samples = n;
 
 	for( size_t i = 0; i < n; i++ ) {
 		cgltf_bool ok = cgltf_accessor_read_float( chan->sampler->input, i, &out_channel->times[ i ], 1 );
 		ASSERT( ok != 0 );
 
 		float scale[ 3 ];
 		ok = ok && cgltf_accessor_read_float( chan->sampler->output, i, scale, 3 );
 		ASSERT( ok != 0 );
 
 		ASSERT( fabsf( scale[ 0 ] / scale[ 1 ] - 1.0f ) < 0.001f );
 		ASSERT( fabsf( scale[ 0 ] / scale[ 2 ] - 1.0f ) < 0.001f );
 
 		out_channel->samples[ i ] = scale[ 0 ];
 	}
 }
 
 static void LoadAnimationReel( MemoryArena * arena, const cgltf_animation * animation ) {
 	ggprint( "LoadAnimationReel\n" );
 
 	for( size_t i = 0; i < animation->channels_count; i++ ) {
 		const cgltf_animation_channel * chan = &animation->channels[ i ];
 
 		u8 joint_idx = GetJointIdx( chan->target_node );
 		ASSERT( joint_idx != U8_MAX );
 
 		if( chan->target_path == cgltf_animation_path_type_translation ) {
 			ggprint( "{} translation\n", chan->target_node->name );
 			LoadChannel( chan, &model.animation.joints[ joint_idx ].translations );
 		}
 		else if( chan->target_path == cgltf_animation_path_type_rotation ) {
 			ggprint( "{} rotation\n", chan->target_node->name );
 			LoadChannel( chan, &model.animation.joints[ joint_idx ].rotations );
 		}
 		else if( chan->target_path == cgltf_animation_path_type_scale ) {
 			ggprint( "{} scale\n", chan->target_node->name );
 			LoadScaleChannel( chan, &model.animation.joints[ joint_idx ].scales );
 		}
 		else {
 			FATAL( "bad path type" );
 		}
 	}
 
 	CLIP.start_time = 0;
 	CLIP.duration = 10;
 	CLIP.loop = true;
 
 	model.animation.clips = &CLIP;
 	model.animation.num_clips = 1;
 }
 
 template< typename T, size_t N >
 static void CreateSingleSampleChannel( AnimationReel::Channel< T > * out_channel, const float ( &sample )[ N ] ) {
 	constexpr size_t lanes = sizeof( T ) / sizeof( float );
 	STATIC_ASSERT( lanes == N );
 
 	float * memory = ( float * ) malloc( ( N + 1 ) * sizeof( float ) );
 	out_channel->times = memory;
 	out_channel->samples = ( T * ) ( memory + 1 );
 	out_channel->num_samples = 1;
 
 	out_channel->times[ 0 ] = 0.0f;
 	memcpy( &out_channel->samples[ 0 ], sample, N * sizeof( float ) );
 }
 
 static void FixupMissingAnimationChannels( const cgltf_skin * skin ) {
 	for( u8 i = 0; i < model.animation.num_joints; i++ ) {
 		const cgltf_node * node = skin->joints[ i ];
 		AnimationReel::Joint & joint = model.animation.joints[ i ];
 
 		if( joint.rotations.samples == NULL && node->has_rotation ) {
 			CreateSingleSampleChannel( &joint.rotations, node->rotation );
 		}
 
 		if( joint.translations.samples == NULL && node->has_translation ) {
 			CreateSingleSampleChannel( &joint.translations, node->translation );
 		}
 
 		if( joint.scales.samples == NULL && node->has_scale ) {
 			ASSERT( fabsf( node->scale[ 0 ] / node->scale[ 1 ] - 1.0f ) < 0.001f );
 			ASSERT( fabsf( node->scale[ 0 ] / node->scale[ 2 ] - 1.0f ) < 0.001f );
 			float scale[ 1 ] = { node->scale[ 0 ] };
 			CreateSingleSampleChannel( &joint.scales, scale );
 		}
 	}
 }
 
 array< const u8 > AccessorToSpan( const cgltf_accessor * accessor ) {
 	cgltf_size offset = accessor->offset + accessor->buffer_view->offset;
 	return array< const u8 >( ( const u8 * ) accessor->buffer_view->buffer->data + offset, accessor->count * accessor->stride );
 }
 
 static void LoadNode( MemoryArena * arena, const cgltf_node * node, bool animated, int depth ) {
 	MEMARENA_SCOPED_CHECKPOINT( arena );
 
 	Mat4 transform;
 	{
 		cgltf_node_transform_local( node, transform.ptr() );
 	}
 
 	for( size_t i = 0; i < node->children_count; i++ ) {
 		LoadNode( arena, node->children[ i ], animated, depth + 1 );
 	}
 
 	if( node->mesh == NULL )
 		return;
 
 	ASSERT( node->mesh->primitives_count == 1 );
 
 	const cgltf_primitive & prim = node->mesh->primitives[ 0 ];
 
 	MeshConfig mesh_config;
 
 	// TODO: handle packed attributes
 	for( size_t i = 0; i < prim.attributes_count; i++ ) {
 		const cgltf_attribute & attr = prim.attributes[ i ];
 
 		if( attr.type == cgltf_attribute_type_position ) {
 			// TODO: if not animated, bake transform into mesh
 			mesh_config.positions = renderer_new_vb( AccessorToSpan( attr.data ) );
 
 			// XXX
 			array< v3 > colours = alloc_array< v3 >( arena, attr.data->count );
 			for( size_t k = 0; k < attr.data->count; k++ ) {
 				colours[ k ] = v3( 1, 1, 1 );
 			}
 			mesh_config.colours = renderer_new_vb( colours );
 		}
 
 		if( attr.type == cgltf_attribute_type_normal ) {
 			mesh_config.normals = renderer_new_vb( AccessorToSpan( attr.data ) );
 		}
 
 		if( attr.type == cgltf_attribute_type_texcoord ) {
 			mesh_config.tex_coords0 = renderer_new_vb( AccessorToSpan( attr.data ) );
 		}
 
 		if( attr.type == cgltf_attribute_type_color ) {
 			mesh_config.colours = renderer_new_vb( AccessorToSpan( attr.data ) );
 		}
 
 		// TODO: drop lanes that are never used?
 		// TODO: convert to u8
 		if( attr.type == cgltf_attribute_type_joints ) {
 			mesh_config.joints = renderer_new_vb( AccessorToSpan( attr.data ) );
 			if( attr.data->component_type == cgltf_component_type_r_8u )
 				mesh_config.joints_format = VERTEXFMT_U8x4;
 		}
 
 		// TODO: convert to float3 and compute the last weight in the shader
 		if( attr.type == cgltf_attribute_type_weights ) {
 			mesh_config.weights = renderer_new_vb( AccessorToSpan( attr.data ) );
 			if( attr.data->component_type == cgltf_component_type_r_8u )
 				mesh_config.weights_format = VERTEXFMT_U8x4;
 		}
 	}
 
 	mesh_config.indices = renderer_new_ib( AccessorToSpan( prim.indices ) );
 	mesh_config.indices_format = prim.indices->component_type == cgltf_component_type_r_16u ? INDEXFMT_U16 : INDEXFMT_U32;
 	mesh_config.num_vertices = prim.indices->count;
 
 	model.meshes[ model.num_meshes ] = renderer_new_mesh( mesh_config );
 	model.num_meshes++;
 }
 
 GAME_INIT( game_init ) {
 	memset( &model, 0, sizeof( model ) );
 
 	double before = get_time();
 
 	cgltf_options options = { };
 
 	cgltf_data * data;
 	if( cgltf_parse_file( &options, "bigvic.glb", &data ) != cgltf_result_success )
 		FATAL( "cgltf_parse_file" );
 	if( cgltf_load_buffers( &options, data, "./" ) != cgltf_result_success )
 		FATAL( "cgltf_load_buffers" );
 	if( !LoadBinaryBuffers( data ) )
 		FATAL( "LoadBinaryBuffers" );
 	if( cgltf_validate( data ) != cgltf_result_success )
 		FATAL( "cgltf_validate" );
 
 	ASSERT( data->animations_count <= 1 );
 	ASSERT( data->skins_count <= 1 );
 	ASSERT( data->animations_count == data->skins_count );
 	ASSERT( data->cameras_count == 0 );
 
 	model.num_meshes = 0;
 
 	for( size_t i = 0; i < data->scene->nodes_count; i++ ) {
 		LoadNode( &mem->persistent_arena, data->scene->nodes[ i ], data->animations_count > 0, 0 );
 	}
 
 	if( data->animations_count > 0 ) {
 		LoadSkin( &data->skins[ 0 ] );
 		LoadAnimationReel( &mem->persistent_arena, &data->animations[ 0 ] );
 		FixupMissingAnimationChannels( &data->skins[ 0 ] );
 	}
 
 	cgltf_free( data );
 
 	ggprint( "loading model took {.2}ms\n", ( get_time() - before ) * 1000.0 );
 
 	game->pos = v3( -10, -10, 5 );
 	game->pitch = 0;
 	game->yaw = 45;
 	game->sun_angle = 0;
 }
 
 GAME_FRAME( game_frame ) {
 	const float speed = 6.0f;
 	const float angular_speed = 100.0f;
 
 	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 = float( input->keys[ KEY_DOWNARROW ] - input->keys[ KEY_UPARROW ] );
 	float dyaw = float( input->keys[ KEY_LEFTARROW ] - input->keys[ KEY_RIGHTARROW ] );
 
 	float dsun = ( input->keys[ KEY_EQUALS ] * input->key_edges[ KEY_EQUALS ] - input->keys[ KEY_MINUS ] * input->key_edges[ KEY_MINUS ] ) * 0.01666f;
 	dsun += input->keys[ KEY_T ] * 0.01666f;
 	game->sun_angle += dsun;
 
 	dpitch += input->keys[ KEY_K ] - input->keys[ KEY_I ];
 	dyaw += input->keys[ KEY_J ] - input->keys[ KEY_L ];
 
 	game->pitch += dpitch * dt * angular_speed;
 	game->yaw += dyaw * dt * angular_speed;
 
 	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 ) );
 
 	game->pos += forward * dt * fb * speed;
 	game->pos += right * dt * lr * speed;
 	game->pos.z += dt * dz * speed;
 
 	m4 P = m4_perspective( 90, get_aspect_ratio(), NEAR_PLANE_DEPTH, FAR_PLANE_DEPTH );
 	m4 V = m4_view( forward, right, up, game->pos );
 
 	m4 y_up_to_z_up = m4(
 		1, 0, 0, 0,
 		0, 0, -1, 0,
 		0, 1, 0, 0,
 		0, 0, 0, 1
 	);
 
 	SQT sample_sqt[ 100 ];
 	SampleAnimationClip( model.animation, 0, game->sun_angle, 0.0f, sample_sqt );
 
 	Mat4 joint_matrices[ 100 ];
 	Mat4 skinning_matrices[ 100 ];
 	ComputeMatrixPalette( model.animation, sample_sqt, joint_matrices, skinning_matrices );
 
 	renderer_begin_frame();
 
 	u8 main_pass = renderer_add_pass( "Render frame", RENDERER_CLEAR_COLOUR_DO, RENDERER_CLEAR_DEPTH_DO );
 
 	UniformBinding view_uniforms = renderer_uniforms( V, P, game->pos );
 	UniformBinding model_uniforms = renderer_uniforms( y_up_to_z_up );
 	UniformBinding joints_uniforms = renderer_upload_uniforms( skinning_matrices, model.animation.num_joints * sizeof( Mat4 ) );
 
 	if( !input->keys[ KEY_LEFTCTRL ] ) {
 		// draw skinned model
 		{
 			RenderState render_state;
 			render_state.pass = main_pass;
 			render_state.shader = get_shader( SHADER_SKINNED_FLAT_VERTEX_COLOURS );
 			render_state.set_uniform( "view", view_uniforms );
 			render_state.set_uniform( "model", model_uniforms );
 			render_state.set_uniform( "animation", joints_uniforms );
 			render_state.wireframe = input->keys[ KEY_M ];
 
 			for( u32 i = 0; i < model.num_meshes; i++ ) {
 				renderer_draw_mesh( model.meshes[ i ], render_state );
 			}
 		}
 
 		// draw an arrow on the guy's head
 		{
 			u8 head_joint = 4;
 			v3 pos = ( y_up_to_z_up * joint_matrices[ head_joint ] * v4( 0, 0, 0, 1 ) ).xyz();
 			v3 up = ( y_up_to_z_up * joint_matrices[ head_joint ] * v4( 0, 1, 0, 0 ) ).xyz();
 
 			immediate_arrow( pos, up, 1, v4( 0, 1, 0, 1 ) );
 
 			RenderState render_state;
 			render_state.pass = main_pass;
 			render_state.shader = get_shader( SHADER_FLAT_VERTEX_COLOURS );
 			render_state.set_uniform( "view", renderer_uniforms( V, P ) );
 			immediate_render( render_state );
 		}
 	}
 	else {
 		// draw skeleton
 		for( u32 i = 0; i < model.animation.num_joints; i++ ) {
 			v3 pos = ( y_up_to_z_up * joint_matrices[ i ] * v4( 0, 0, 0, 1 ) ).xyz();
 			v3 parent_pos = ( y_up_to_z_up * joint_matrices[ model.animation.joints[ i ].parent ] * v4( 0, 0, 0, 1 ) ).xyz();
 
 			immediate_sphere( pos, 1.0, v4( 1 ) );
 			immediate_arrow( pos, ( y_up_to_z_up * joint_matrices[ i ].col1 ).xyz(), 5.0, v4( 0.5, 0.5, 0.5, 1 ) );
 			immediate_arrow( pos, ( y_up_to_z_up * joint_matrices[ i ].col0 ).xyz(), 5.0, v4( 0, 0, 1, 1 ) );
 			if( i != 0 )
 				immediate_arrow( pos, ( parent_pos - pos ), 0.1, v4( 1, 0, 0, 1 ) );
 		}
 
 		RenderState render_state;
 		render_state.pass = main_pass;
 		render_state.shader = get_shader( SHADER_FLAT_VERTEX_COLOURS );
 		render_state.set_uniform( "view", renderer_uniforms( V, P ) );
 		immediate_render( render_state );
 	}
 
 	renderer_end_frame();
 }