diff --git a/src/camera.c b/src/camera.c
index b56637c..b28f6ce 100644
--- a/src/camera.c
+++ b/src/camera.c
@@ -18,9 +18,9 @@
 
 static void update_frustum(struct Camera* camera);
 
-void camera_destroy(struct Camera* camera)
+void camera_destroy(struct Entity* entity)
 {
-    assert(camera);
+	struct Camera* camera = &entity->camera;
 	if(camera->fbo != -1)        framebuffer_remove(camera->fbo);
 	if(camera->render_tex != -1) texture_remove(camera->render_tex);
 	if(camera->depth_tex != -1)  texture_remove(camera->depth_tex);
@@ -35,8 +35,9 @@ void camera_destroy(struct Camera* camera)
 	vec4_fill(&camera->clear_color, 0.f, 1.f, 0.f, 1.0);
 }
 
-void camera_create(struct Camera* camera, struct Transform* transform, int width, int height)
+void camera_create(struct Entity* entity, int width, int height)
 {
+	struct Camera* camera = &entity->camera;
 	camera->fbo        = -1;
 	camera->render_tex = -1;
 	camera->depth_tex  = -1;
@@ -52,32 +53,35 @@ void camera_create(struct Camera* camera, struct Transform* transform, int width
 	mat4_identity(&camera->view_proj_mat);
 	for(int i = 0; i < FP_NUM_PLANES; i++)
 		vec4_fill(&camera->frustum[i], 0.f, 0.f, 0.f, 0.f);
-	camera_update_view(camera, transform);
-	camera_update_proj(camera);
+	camera_update_view(entity);
+	camera_update_proj(entity);
 	vec4_fill(&camera->clear_color, 1.f, 1.f, 1.f, 1.f);
 }
 
-void camera_update_view_proj(struct Camera* camera)
+void camera_update_view_proj(struct Entity* entity)
 {
+	struct Camera* camera = &entity->camera;
 	mat4_identity(&camera->view_proj_mat);
 	mat4_mul(&camera->view_proj_mat, &camera->proj_mat, &camera->view_mat);
 	update_frustum(camera);
 }
 
-void camera_update_view(struct Camera* camera, struct Transform* transform)
+void camera_update_view(struct Entity* entity)
 {
+	struct Camera* camera = &entity->camera;
 	vec3 lookat   = {0.f, 0.f, 0.f};
 	vec3 up       = {0.f, 0.f, 0.f};
 	vec3 position = {0.f, 0.f, 0.f};
-	transform_get_absolute_lookat(transform, &lookat);
-	transform_get_absolute_up(transform, &up);
-	transform_get_absolute_pos(transform, &position);
+	transform_get_absolute_lookat(entity, &lookat);
+	transform_get_absolute_up(entity, &up);
+	transform_get_absolute_pos(entity, &position);
 	mat4_lookat(&camera->view_mat, &position, &lookat, &up);
-	camera_update_view_proj(camera);
+	camera_update_view_proj(entity);
 }
 
-void camera_update_proj(struct Camera* camera)
+void camera_update_proj(struct Entity* entity)
 {
+	struct Camera* camera = &entity->camera;
 	if(!camera->ortho)
 	{
 		mat4_perspective(&camera->proj_mat,
@@ -90,17 +94,18 @@ void camera_update_proj(struct Camera* camera)
 	{
 		mat4_ortho(&camera->proj_mat, -1, 1, -1, 1, camera->nearz, camera->farz);
 	}
-	camera_update_view_proj(camera);
+	camera_update_view_proj(entity);
 }
 
-void camera_attach_fbo(struct Camera* camera,
+void camera_attach_fbo(struct Entity* entity,
 					   int            width,
 					   int            height,
 					   int            has_depth,
 					   int            has_color,
 					   int            resizeable)
 {
-	assert(width > 0 && height > 0 && camera);
+	assert(width > 0 && height > 0);
+	struct Camera* camera = &entity->camera;
 	if(camera->fbo != -1)
 	{
 		log_error("camera:attach_fbo", "Camera already has fbo attached!");
diff --git a/src/camera.h b/src/camera.h
index 233dbb9..ae21fc9 100644
--- a/src/camera.h
+++ b/src/camera.h
@@ -1,15 +1,14 @@
 #ifndef CAMERA_H
 #define CAMERA_H
 
-struct Camera;
-struct Transform;
+struct Entity;
 
-void camera_destroy(struct Camera* camera);
-void camera_create(struct Camera* camera, struct Transform* transform, int width, int height);
-void camera_update_view_proj(struct Camera* camera);
-void camera_update_view(struct Camera* camera, struct Transform* transform);
-void camera_update_proj(struct Camera* camera);
-void camera_attach_fbo(struct Camera* camera,
+void camera_destroy(struct Entity* entity);
+void camera_create(struct Entity* entity, int width, int height);
+void camera_update_view_proj(struct Entity* entity);
+void camera_update_view(struct Entity* entity);
+void camera_update_proj(struct Entity* entity);
+void camera_attach_fbo(struct Entity* entity,
 					   int            width,
 					   int            height,
 					   int            has_depth,
diff --git a/src/entity.c b/src/entity.c
index b128a11..3c712ef 100644
--- a/src/entity.c
+++ b/src/entity.c
@@ -35,15 +35,15 @@ void entity_remove(int index)
 {
 	struct Entity* entity = &entity_list[index];
 
-	transform_destroy(&entity->transform);
+	transform_destroy(entity);
 	switch(entity->type)
 	{
-	case ET_CAMERA:       camera_destroy(&entity->camera);             break;
-	case ET_LIGHT:        light_destroy(&entity->light, entity->id);   break;
-	case ET_SOUND_SOURCE: sound_source_destroy(&entity->sound_source); break;
-	case ET_STATIC_MESH:  model_destroy(&entity->model, entity->id);   break;
+	case ET_CAMERA:       camera_destroy(entity);       break;
+	case ET_LIGHT:        light_destroy(entity);        break;
+	case ET_SOUND_SOURCE: sound_source_destroy(entity); break;
+	case ET_STATIC_MESH:  model_destroy(entity);        break;
 	case ET_ROOT: break;
-	default: log_error("entity:remove", "Invalid entity type");        break;
+	default: log_error("entity:remove", "Invalid entity type"); break;
 	};
 	entity->id                  = -1;
 	entity->is_listener         = false;
@@ -79,7 +79,7 @@ struct Entity* entity_create(const char* name, const int type, int parent_id)
 	new_entity->type                = type;
 	new_entity->marked_for_deletion = false;
 	new_entity->renderable          = false;
-	transform_create(&new_entity->transform, parent_id);
+	transform_create(new_entity, parent_id);
 	return new_entity;	   
 }
 
@@ -131,9 +131,9 @@ void entity_post_update(void)
 		if(entity->transform.is_modified)
 		{
 			if(entity->type == ET_CAMERA)
-				camera_update_view(&entity->camera, &entity->transform);
+				camera_update_view(entity);
 			else if(entity->type == ET_SOUND_SOURCE)
-				sound_source_update(&entity->sound_source, &entity->transform);
+				sound_source_update(entity);
 
 			if(entity->is_listener) sound_listener_update();
 		}	
diff --git a/src/entity.h b/src/entity.h
index c7475cf..aa932e7 100644
--- a/src/entity.h
+++ b/src/entity.h
@@ -46,9 +46,10 @@ struct Model
 
 struct Sound_Source
 {
+	bool active;
+	bool relative;
 	uint al_source_handle;
 	uint al_buffer_handle;
-	bool active;
 };
 
 struct Camera
diff --git a/src/game.c b/src/game.c
index 2acb4b3..1970ea6 100644
--- a/src/game.c
+++ b/src/game.c
@@ -90,45 +90,34 @@ void scene_setup(void)
 	struct Entity* player = scene_add_new("player", ET_CAMERA);
 	game_state->player_node = player->id;
 	vec3 viewer_pos = {10, 5, 100};
-	struct Transform* viewer_tran = &player->transform;
-	/* struct Model* player_model = entity_component_add(player, C_MODEL, "sphere.pamesh", NULL); */
-	/* model_set_material_param(player_model, "diffuse_color", &color); */
-	/* vec4_fill(&color, 1.f, 1.f, 1.f, 1.f); */
-	transform_set_position(viewer_tran, &viewer_pos);
+	transform_set_position(player, &viewer_pos);
 	int render_width, render_height;
 	render_width = 1024;
 	render_height = 768;
-	struct Camera* camera = &player->camera;
-	camera_create(camera, &player->transform, render_width, render_height);
-	camera_attach_fbo(camera, render_width, render_height, 1, 1, 1);
-	vec4_fill(&camera->clear_color, 0.3f, 0.6f, 0.9f, 1.0f);
+	camera_create(player, render_width, render_height);
+	camera_attach_fbo(player, render_width, render_height, 1, 1, 1);
+	vec4_fill(&player->camera.clear_color, 0.3f, 0.6f, 0.9f, 1.0f);
 	sound_listener_set(player->id);
 
 	vec4 color = {0.f, 1.f, 1.f, 1.f };
 	struct Entity* new_ent = scene_add_new("Model_Entity", ET_STATIC_MESH);
-	struct Transform* tran = &new_ent->transform;
 	vec3 position = {0, 0, -5};
-	transform_translate(tran, &position, TS_WORLD);
-	struct Model* box_model = &new_ent->model;
+	transform_translate(new_ent, &position, TS_WORLD);
 	new_ent->renderable = true;
-	model_create(box_model, new_ent->id, "default.pamesh", "Blinn_Phong");
-	model_set_material_param(box_model, "diffuse_color", &color);
+	model_create(new_ent, "default.pamesh", "Blinn_Phong");
+	model_set_material_param(new_ent, "diffuse_color", &color);
 	int tex = texture_create_from_file("white.tga", TU_DIFFUSE);
-	model_set_material_param(box_model, "diffuse_texture", &tex);
+	model_set_material_param(new_ent, "diffuse_texture", &tex);
 	vec3 scale = {1, 1, 1};
-	transform_scale(tran, &scale);
+	transform_scale(new_ent, &scale);
 
 	struct Entity* sound_ent = scene_add_as_child("Sound_ENT", ET_SOUND_SOURCE, new_ent->id);
-	struct Sound_Source* source = &sound_ent->sound_source;
-	sound_source_create(source, &new_ent->transform);
-	if(source)
-	{
-		sound_source_load_wav(source, "BigExplosion.wav");
-		//sound_source_relative_set(source, 1);
-		sound_source_volume_set(source, 1.f);
-		sound_source_loop_set(source, 1);
-		sound_source_play(source);
-	}
+	sound_source_create(sound_ent, false);
+	sound_source_load_wav(sound_ent, "BigExplosion.wav");
+	//sound_source_relative_set(source, true);
+	sound_source_volume_set(sound_ent, 1.f);
+	sound_source_loop_set(sound_ent, true);
+	sound_source_play(sound_ent);
 
 	int parent_node = new_ent->id;
 	int num_suz = 20;
@@ -142,29 +131,27 @@ void scene_setup(void)
 		//struct Entity* suz = scene_add_as_child("Suzanne", ET_STATIC_MESH, parent_node);
 		struct Entity* suz = scene_add_new("Suzanne", ET_STATIC_MESH);
 		suz->renderable = true;
-		struct Model* suz_model = &suz->model;
-		model_create(suz_model, suz->id, "suzanne.pamesh", "Blinn_Phong");
-		model_set_material_param(suz_model, "diffuse_color", &color);
+		model_create(suz, "suzanne.pamesh", "Blinn_Phong");
+		model_set_material_param(suz, "diffuse_color", &color);
 		float spec_str = 80.f;
-		model_set_material_param(suz_model, "specular_strength", &spec_str);
+		model_set_material_param(suz, "specular_strength", &spec_str);
 		vec3 s_pos = {x, 5, z};
-		transform_translate(&suz->transform, &s_pos, TS_WORLD);
+		transform_translate(suz, &s_pos, TS_WORLD);
 	}
 	
 
 	struct Entity* ground = scene_add_new("Ground", ET_STATIC_MESH);
 	ground->renderable = true;
-	struct Model* ground_model = &ground->model;
-	model_create(ground_model, ground->id, "default.pamesh", "Blinn_Phong");
-	model_set_material_param(ground_model, "diffuse_color", &color);
+	model_create(ground, "default.pamesh", "Blinn_Phong");
+	model_set_material_param(ground, "diffuse_color", &color);
 	int white_tex = texture_create_from_file("white.tga", TU_DIFFUSE);
-	model_set_material_param(ground_model, "diffuse_texture", &white_tex);
+	model_set_material_param(ground, "diffuse_texture", &white_tex);
 	float spec_str = 80.f;
-	model_set_material_param(ground_model, "specular_strength", &spec_str);
+	model_set_material_param(ground, "specular_strength", &spec_str);
 	vec3 pos = {0, -15, 0};
 	vec3 scale_ground = {100.f, 2.f, 100.f};
-	transform_set_position(&ground->transform, &pos);
-	transform_scale(&ground->transform, &scale_ground);
+	transform_set_position(ground, &pos);
+	transform_scale(ground, &scale_ground);
 
 	/* struct Entity* screen = scene_add_new("Screen", NULL); */
 	/* struct Model* screen_model = entity_component_add(screen, C_MODEL, NULL, NULL); */
@@ -188,11 +175,10 @@ void scene_setup(void)
 		x++; z++;
 		struct Entity* light_ent = scene_add_new("Light_Ent", ET_LIGHT);
 		vec3 lt_pos = {x * 20, 0, z * 20};
-		transform_set_position(&light_ent->transform, &lt_pos);
-		struct Light* light_comp = &light_ent->light;
-		light_create(&light_ent->light, light_ent->id, LT_POINT);
-		vec3_fill(&light_comp->color, 1.f / (float)x, 1.f / ((rand() % 10) + 1.f), 1.f / (float)z);
-		light_comp->intensity = 1.f;
+		transform_set_position(light_ent, &lt_pos);
+		light_create(light_ent, LT_POINT);
+		vec3_fill(&light_ent->light.color, 1.f / (float)x, 1.f / ((rand() % 10) + 1.f), 1.f / (float)z);
+		light_ent->light.intensity = 1.f;
 	}
 
 	/* struct Entity* sun = scene_add_new("Sun", NULL); */
@@ -204,8 +190,6 @@ void debug(float dt)
 {
 	//struct Entity* entity = entity_get(player_node);
 	struct Entity* entity =  entity_get(game_state->player_node);
-	struct Camera* cam = &entity->camera;
-	struct Transform* transform = &entity->transform;
 	float move_speed = 5.f, move_scale = 3.f, turn_speed = 50.f;
 	vec3 offset = {0, 0, 0};
 	float turn_up_down = 0.f;
@@ -252,25 +236,25 @@ void debug(float dt)
 	
 	if(turn_left_right != 0.f)
 	{
-		transform_rotate(transform, &rot_axis_left_right, -turn_left_right, TS_WORLD);
+		transform_rotate(entity, &rot_axis_left_right, -turn_left_right, TS_WORLD);
 		vec3 up = {0.f, 0.f, 0.f};
 		vec3 forward = {0.f, 0.f, 0.f};
 		vec3 lookat = {0.f, 0.f, 0.f};
-		transform_get_up(transform, &up);
-		transform_get_forward(transform, &forward);
-		transform_get_lookat(transform, &lookat);
+		transform_get_up(entity, &up);
+		transform_get_forward(entity, &forward);
+		transform_get_lookat(entity, &lookat);
 		/* log_message("Up : %s", tostr_vec3(&up)); */
 		/* log_message("FR : %s", tostr_vec3(&forward)); */
 	}
 	if(turn_up_down != 0.f)
 	{
-		transform_rotate(transform, &rot_axis_up_down, turn_up_down, TS_LOCAL);
+		transform_rotate(entity, &rot_axis_up_down, turn_up_down, TS_LOCAL);
 		vec3 up = {0.f, 0.f, 0.f};
 		vec3 forward = {0.f, 0.f, 0.f};
 		vec3 lookat = {0.f, 0.f, 0.f};
-		transform_get_up(transform, &up);
-		transform_get_forward(transform, &forward);
-		transform_get_lookat(transform, &lookat);
+		transform_get_up(entity, &up);
+		transform_get_forward(entity, &forward);
+		transform_get_lookat(entity, &lookat);
 		/* log_message("Up : %s", tostr_vec3(&up)); */
 		/* log_message("FR : %s", tostr_vec3(&forward)); */
 	}
@@ -287,7 +271,7 @@ void debug(float dt)
 	vec3_scale(&offset, &offset, dt);
 	if(offset.x != 0 || offset.y != 0 || offset.z != 0)
 	{
-		transform_translate(transform, &offset, TS_LOCAL);
+		transform_translate(entity, &offset, TS_LOCAL);
  		//log_message("Position : %s", tostr_vec3(&transform->position));
 	}
 
@@ -295,7 +279,7 @@ void debug(float dt)
 	{
 		struct Entity* model = scene_find("Model_Entity");
 		vec3 x_axis = {1, 0, 0};
-		transform_rotate(&model->transform, &x_axis, 25.f * dt, TS_WORLD);
+		transform_rotate(model, &x_axis, 25.f * dt, TS_WORLD);
 	}
 
 	if(input_is_key_pressed(KEY_M))
@@ -304,7 +288,7 @@ void debug(float dt)
 		//vec3 y_axis = {0, 0, 1};
 		//transform_rotate(mod_tran, &y_axis, 25.f * dt, TS_LOCAL);
 		vec3 amount = {0, 0, -5 * dt};
-		transform_translate(&model->transform, &amount, TS_LOCAL);
+		transform_translate(model, &amount, TS_LOCAL);
 	}
 
 	if(input_is_key_pressed(KEY_N))
@@ -313,7 +297,7 @@ void debug(float dt)
 		/* vec3 y_axis = {0, 0, 1}; */
 		/* transform_rotate(mod_tran, &y_axis, 25.f * dt, TS_WORLD); */
 		vec3 amount = {0, 0, 5 * dt};
-		transform_translate(&model->transform, &amount, TS_LOCAL);
+		transform_translate(model, &amount, TS_LOCAL);
 	}
 }
 
diff --git a/src/light.c b/src/light.c
index 453241e..4dac20e 100644
--- a/src/light.c
+++ b/src/light.c
@@ -17,10 +17,9 @@ void light_cleanup(void)
 }
 
 
-void light_create(struct Light* light, int entity_id, int light_type)
+void light_create(struct Entity* entity, int light_type)
 {
-	assert(light && entity_id > -1);
-	
+	struct Light* light = &entity->light;
 	light->valid       = true;
 	light->cast_shadow = 0;
 	light->depth_bias  = 0.0005f;
@@ -33,17 +32,17 @@ void light_create(struct Light* light, int entity_id, int light_type)
 	light->radius      = 20;
 	vec3_fill(&light->color, 1.f, 1.f, 1.f);
 	int* new_index = array_grow(light_list, int);
-	*new_index = entity_id;
+	*new_index = entity->id;
 }
 
-void light_destroy(struct Light* light, int entity_id)
+void light_destroy(struct Entity* entity)
 {
-	assert(light && entity_id > -1);
-	
+	assert(entity && entity->type == ET_LIGHT);
+	struct Light* light = &entity->light;
 	int index_to_remove = -1;
 	for(int i = 0; i < array_len(light_list); i++)
 	{
-		if(light_list[i] == entity_id)
+		if(light_list[i] == entity->id)
 		{
 			index_to_remove = i;
 			break;
diff --git a/src/light.h b/src/light.h
index 70ad40a..653f341 100644
--- a/src/light.h
+++ b/src/light.h
@@ -3,12 +3,12 @@
 
 #define MAX_SHADOWMAPS 4
 
-struct Light;
+struct Entity;
 
 void light_init(void);
 void light_cleanup(void);
-void light_destroy(struct Light* light, int entity_id);
-void light_create(struct Light* light, int entity_id, int light_type);
+void light_destroy(struct Entity* entity);
+void light_create(struct Entity* entity, int light_type);
 int* light_get_valid_indices(int* out_count);
 
 #endif
diff --git a/src/model.c b/src/model.c
index 004d2f0..c0a2178 100644
--- a/src/model.c
+++ b/src/model.c
@@ -31,27 +31,27 @@ void model_init(void)
 	num_indices_slot  = editor_debugvar_slot_create("Total Indices", VT_INT);
 }
 
-void model_create(struct Model* model, int entity_id, const char* geo_name, const char* material_name)
+void model_create(struct Entity* entity, const char* geo_name, const char* material_name)
 {
-	assert(model);
+	struct Model* model = &entity->model;
 	/* if no name is given for geometry, use default */
 	if(!geo_name) geo_name = "default.pamesh";
 	int geo_index = geom_create_from_file(geo_name);
 
 	model->geometry_index = geo_index;
-	if(!material_register_model(model, entity_id, material_name ? material_name : "Unshaded"))
+	if(!material_register_model(model, entity->id, material_name ? material_name : "Unshaded"))
 	{
 		log_error("model:create", "Unable to register model with Unshaded material, component not added");
-		model_destroy(model, entity_id);
+		model_destroy(entity);
 	}
 }
 
-void model_destroy(struct Model* model, int entity_id)
+void model_destroy(struct Entity* entity)
 {
-	assert(model);
+	struct Model* model = &entity->model;
 	geom_remove(model->geometry_index);
 	model->geometry_index = -1;
-	material_unregister_model(model, entity_id);
+	material_unregister_model(model, entity->id);
 	/* deallocate all params */
 	for(int i = 0; i < array_len(model->material_params); i++)
 		free(model->material_params[i].value);
@@ -164,22 +164,20 @@ void model_render_all(struct Entity* camera_entity, int draw_mode)
 				memset(uniform_name, '\0', MAX_NAME_LEN);
 				for(int i = 0; i < valid_light_count; i++)
 				{
-					struct Entity*    light_entity = entity_get(light_index_list[i]);
-					struct Light*     light        = &light_entity->light; /* TODO: Cull lights according to camera frustum */
-					struct Transform* light_transform    = &light_entity->transform;
+					struct Entity* light_entity = entity_get(light_index_list[i]);
+					struct Light*  light        = &light_entity->light; /* TODO: Cull lights according to camera frustum */
 					vec3 light_pos = {0, 0, 0};
-					transform_get_absolute_pos(light_transform, &light_pos);
+					transform_get_absolute_pos(light_entity, &light_pos);
 
 					if(light->type != LT_POINT)
 					{
 						snprintf(uniform_name, MAX_NAME_LEN, "lights[%d].direction", i);
-						transform_get_absolute_lookat(light_transform, &light_pos);
+						transform_get_absolute_lookat(light_entity, &light_pos);
 						vec3_norm(&light_pos, &light_pos);
 						shader_set_uniform_vec3(material->shader, uniform_name, &light_pos);
 						memset(uniform_name, '\0', MAX_NAME_LEN);
 					}
 
-
 					if(light->type != LT_DIR)
 					{
 						snprintf(uniform_name, MAX_NAME_LEN, "lights[%d].position", i);
@@ -217,9 +215,8 @@ void model_render_all(struct Entity* camera_entity, int draw_mode)
 				}
 
 				shader_set_uniform_int(material->shader, "total_active_lights", valid_light_count);
-				struct Transform* camera_tran = &camera_entity->transform;
 				vec3 camera_pos = {0, 0, 0};
-				transform_get_absolute_pos(camera_tran, &camera_pos);
+				transform_get_absolute_pos(camera_entity, &camera_pos);
 				shader_set_uniform_vec3(material->shader, "camera_pos", &camera_pos);
 			}
 			
@@ -257,9 +254,10 @@ void model_render_all(struct Entity* camera_entity, int draw_mode)
 	num_culled = num_rendered = num_indices = 0;
 }
 
-int model_set_material_param(struct Model* model, const char* name, void* value)
+int model_set_material_param(struct Entity* entity, const char* name, void* value)
 {
-	assert(model && name && value);
+	assert(name && value);
+	struct Model* model = &entity->model;
 	int success = 0;
 	struct Material* material = material_get(model->material);
 	for(int i = 0; i < array_len(model->material_params); i++)
@@ -289,9 +287,10 @@ int model_set_material_param(struct Model* model, const char* name, void* value)
 	return success;
 }
 
-int model_get_material_param(struct Model* model, const char* name, void* value_out)
+int model_get_material_param(struct Entity* entity, const char* name, void* value_out)
 {
-	assert(model && name && value_out);
+	assert(name && value_out);
+	struct Model* model = &entity->model;
 	int success = 0;
 	struct Material* material = material_get(model->material);
 	for(int i = 0; i < array_len(model->material_params); i++)
diff --git a/src/model.h b/src/model.h
index 3218f4e..d82e5a9 100644
--- a/src/model.h
+++ b/src/model.h
@@ -3,21 +3,19 @@
 
 #include "linmath.h"
 
-struct Camera;
 struct Material_Param;
-struct Model;
 struct Entity;
 
-void 		  model_init(void);
-void  		  model_create(struct Model* model, int entity_id, const char* geo_name, const char* material_name);
-void 		  model_destroy(struct Model* model, int entity_id);
-void 		  model_cleanup(void);
-void 		  model_render_all(struct Entity* camera_entity, int draw_mode);
-int  		  model_set_material_param(struct Model* model, const char* name, void* value);
-int  		  model_get_material_param(struct Model* model, const char* name, void* value_out);
-void          model_render_all_debug(struct Entity* camera_entity,
-									 int            debug_shader,
-									 int            draw_mode,
-									 const vec4*    debug_color);
+void model_init(void);
+void model_create(struct Entity* entity, const char* geo_name, const char* material_name);
+void model_destroy(struct Entity* entity);
+void model_cleanup(void);
+void model_render_all(struct Entity* camera_entity, int draw_mode);
+int  model_set_material_param(struct Entity* entity, const char* name, void* value);
+int  model_get_material_param(struct Entity* entity, const char* name, void* value_out);
+void model_render_all_debug(struct Entity* camera_entity,
+							int            debug_shader,
+							int            draw_mode,
+							const vec4*    debug_color);
 
 #endif
diff --git a/src/renderer.c b/src/renderer.c
index ca8ff7d..bf5d92f 100644
--- a/src/renderer.c
+++ b/src/renderer.c
@@ -213,7 +213,7 @@ void on_framebuffer_size_change(int width, int height)
 		if(viewer->type != ET_CAMERA) continue;
 
 		viewer->camera.aspect_ratio = aspect > 0.f ? aspect : 4.f / 3.f;
-		camera_update_proj(&viewer->camera);
+		camera_update_proj(viewer);
 	}
 	
 	framebuffer_resize_all(width, height);
diff --git a/src/scene.c b/src/scene.c
index 344be35..96f37fc 100644
--- a/src/scene.c
+++ b/src/scene.c
@@ -28,7 +28,7 @@ struct Entity* scene_add_as_child(const char* name, const int type, int parent_i
 	new_entity = entity_create(name, type, parent_id);
 	struct Entity* parent = entity_get(parent_id);
 	new_entity->transform.parent = parent->id;
-	transform_update_transmat(&new_entity->transform);
+	transform_update_transmat(new_entity);
 	return new_entity;
 }
 
@@ -67,7 +67,7 @@ void scene_reset_parent(struct Entity* entity, struct Entity* new_parent)
 			array_remove_at(curr_parent->transform.children, index);
 			entity->transform.parent = new_parent->id;
 			array_push(new_parent, entity->id, int);
-			transform_update_transmat(&entity->transform);
+			transform_update_transmat(entity);
 		}
 		else
 		{
diff --git a/src/sound.c b/src/sound.c
index 7d3b309..4627257 100644
--- a/src/sound.c
+++ b/src/sound.c
@@ -21,7 +21,13 @@ struct Sound_State
 	float       volume;
 };
 
-static struct Sound_State   sound_state;
+static struct Sound_State sound_state =
+{
+	.listener_entity = -1,
+	.device          = NULL,
+	.context         = NULL,
+	.volume          = 0.f
+};
 
 bool sound_init(void)
 {
@@ -84,9 +90,9 @@ void sound_listener_update(void)
 	vec3 abs_up      = {0.f, 1.f,  0.f};
 	vec3 abs_forward = {0.f, 0.f, -1.f};
 	
-	transform_get_absolute_pos(&entity->transform, &abs_pos);
-	transform_get_absolute_up(&entity->transform, &abs_up);
-	transform_get_absolute_forward(&entity->transform, &abs_forward);
+	transform_get_absolute_pos(entity, &abs_pos);
+	transform_get_absolute_up(entity, &abs_up);
+	transform_get_absolute_forward(entity, &abs_forward);
 	float orientation[] =
 	{
 		abs_forward.x, abs_forward.y, abs_forward.z,
@@ -107,13 +113,14 @@ void sound_volume_set(float volume)
 	al_check(alListenerf(AL_GAIN, volume))
 }
 
-void sound_source_destroy(struct Sound_Source* source)
+void sound_source_destroy(struct Entity* entity)
 {
-	assert(source);
+	assert(entity && entity->type == ET_SOUND_SOURCE);
+	struct Sound_Source* source = &entity->sound_source;
 	if(!source->active) return;
 	if(alIsBuffer(source->al_buffer_handle) == AL_TRUE)
 	{
-		sound_source_stop(source);
+		sound_source_stop(entity);
 		al_check(alSourcei(source->al_source_handle, AL_BUFFER, 0))
 		al_check(alDeleteBuffers(1, &source->al_buffer_handle))
 	}
@@ -148,63 +155,71 @@ void sound_error_check(const char* file, unsigned int line, const char* expressi
 	}
 }
 
-void sound_source_create(struct Sound_Source* source, struct Transform* transform)
+void sound_source_create(struct Entity* entity, bool relative)
 {
-	assert(source);
+	assert(entity && entity->type == ET_SOUND_SOURCE);
+	struct Sound_Source* source = &entity->sound_source;
 	source->active = true;
 	al_check(alGenSources(1, &source->al_source_handle))
 	al_check(alGenBuffers(1, &source->al_buffer_handle))
-	sound_source_volume_set(source, 1.f);
-	if(transform)
-		sound_source_update(source, transform);
+	sound_source_volume_set(entity, 1.f);
+	if(relative)
+		sound_source_relative_set(entity, true);
 	else
-		sound_source_relative_set(source, 1);
+		sound_source_update(entity);
 }
 
-void sound_source_update(struct Sound_Source* source, struct Transform* transform)
+void sound_source_update(struct Entity* entity)
 {
+	assert(entity && entity->type == ET_SOUND_SOURCE);
 	vec3 abs_pos     = {0.f, 0.f,  0.f};
 	vec3 abs_up      = {0.f, 1.f,  0.f};
 	vec3 abs_forward = {0.f, 0.f, -1.f};
 	
-	transform_get_absolute_pos(transform, &abs_pos);
-	transform_get_absolute_up(transform, &abs_up);
-	transform_get_absolute_forward(transform, &abs_forward);
+	transform_get_absolute_pos(entity, &abs_pos);
+	transform_get_absolute_up(entity, &abs_up);
+	transform_get_absolute_forward(entity, &abs_forward);
 	float orientation[] =
 	{
 		abs_forward.x, abs_forward.y, abs_forward.z,
 		abs_up.x,      abs_up.y,      abs_up.z
 	};
-	al_check(alSource3f(source->al_source_handle, AL_POSITION, abs_pos.x, abs_pos.y, abs_pos.z))
-	al_check(alSourcefv(source->al_source_handle, AL_ORIENTATION, orientation))
+	al_check(alSource3f(entity->sound_source.al_source_handle, AL_POSITION, abs_pos.x, abs_pos.y, abs_pos.z))
+	al_check(alSourcefv(entity->sound_source.al_source_handle, AL_ORIENTATION, orientation))
 }
 
-void sound_source_volume_set(struct Sound_Source* source, float volume)
+void sound_source_volume_set(struct Entity* entity, float volume)
 {
+	assert(entity && entity->type == ET_SOUND_SOURCE);
 	if(volume < 0.f) volume = 0.f;
-	al_check(alSourcef(source->al_source_handle, AL_GAIN, volume))
+	al_check(alSourcef(entity->sound_source.al_source_handle, AL_GAIN, volume))
 }
 
-void sound_source_pitch_set(struct Sound_Source* source, float pitch)
+void sound_source_pitch_set(struct Entity* entity, float pitch)
 {
+	assert(entity && entity->type == ET_SOUND_SOURCE);
 	if(pitch < 0.f) pitch = 0.f;
-	al_check(alSourcef(source->al_source_handle, AL_PITCH, pitch))
+	al_check(alSourcef(entity->sound_source.al_source_handle, AL_PITCH, pitch))
 }
 
-void sound_source_loop_set(struct Sound_Source* source, bool loop)
+void sound_source_loop_set(struct Entity* entity, bool loop)
 {
+	assert(entity && entity->type == ET_SOUND_SOURCE);
 	loop = loop ? AL_TRUE : AL_FALSE;
-	al_check(alSourcei(source->al_source_handle, AL_LOOPING, loop))
+	al_check(alSourcei(entity->sound_source.al_source_handle, AL_LOOPING, loop))
 }
 
-void sound_source_relative_set(struct Sound_Source* source, bool relative)
+void sound_source_relative_set(struct Entity* entity, bool relative)
 {
+	assert(entity && entity->type == ET_SOUND_SOURCE);
 	relative = relative ? AL_TRUE : AL_FALSE;
-	al_check(alSourcei(source->al_source_handle, AL_SOURCE_RELATIVE, relative));
+	al_check(alSourcei(entity->sound_source.al_source_handle, AL_SOURCE_RELATIVE, relative));
+	entity->sound_source.relative = relative;
 }
 
-void sound_source_load_wav(struct Sound_Source* source, const char* file_name)
+void sound_source_load_wav(struct Entity* entity, const char* file_name)
 {
+	assert(entity && entity->type == ET_SOUND_SOURCE);
 	if(!file_name)
 	{
 		log_error("sound_source:load_wav", "No file name given");
@@ -232,7 +247,7 @@ void sound_source_load_wav(struct Sound_Source* source, const char* file_name)
 	}
 
 	bool mono   = wav_spec.channels == 1 ? true : false;
-	int format = -1;
+	int  format = -1;
 	if(mono)
 	{
 		if(wav_spec.format == AUDIO_U8 || wav_spec.format == AUDIO_S8)
@@ -259,13 +274,33 @@ void sound_source_load_wav(struct Sound_Source* source, const char* file_name)
 		SDL_FreeWAV(wav_data);
 		return;
 	}
-	
+
+	struct Sound_Source* source = &entity->sound_source;
 	al_check(alBufferData(source->al_buffer_handle, format, wav_data, wav_data_len, wav_spec.freq))
 	al_check(alSourcei(source->al_source_handle, AL_BUFFER, source->al_buffer_handle))
 	SDL_FreeWAV(wav_data);
 }
 
-void sound_source_play(struct Sound_Source* source)   { al_check(alSourcePlay(source->al_source_handle))   }
-void sound_source_pause(struct Sound_Source* source)  { al_check(alSourcePause(source->al_source_handle))  }
-void sound_source_rewind(struct Sound_Source* source) { al_check(alSourceRewind(source->al_source_handle)) }
-void sound_source_stop(struct Sound_Source* source)   { al_check(alSourceStop(source->al_source_handle))   }
+void sound_source_play(struct Entity* entity)
+{
+	assert(entity && entity->type == ET_SOUND_SOURCE);
+	al_check(alSourcePlay(entity->sound_source.al_source_handle))
+}
+
+void sound_source_pause(struct Entity* entity)
+{
+	assert(entity && entity->type == ET_SOUND_SOURCE);
+	al_check(alSourcePause(entity->sound_source.al_source_handle))
+}
+
+void sound_source_rewind(struct Entity* entity)
+{
+	assert(entity && entity->type == ET_SOUND_SOURCE);
+	al_check(alSourceRewind(entity->sound_source.al_source_handle))
+}
+
+void sound_source_stop(struct Entity* entity)
+{
+	assert(entity && entity->type == ET_SOUND_SOURCE);
+	al_check(alSourceStop(entity->sound_source.al_source_handle))
+}
diff --git a/src/sound.h b/src/sound.h
index c4943ac..47cb5b9 100644
--- a/src/sound.h
+++ b/src/sound.h
@@ -9,8 +9,7 @@
     #define al_check(expr) expr;
 #endif
 
-struct Sound_Source;
-struct Transform;
+struct Entity;
 
 bool sound_init(void);
 void sound_cleanup(void);
@@ -21,17 +20,17 @@ void sound_listener_set(int entity);
 int  sound_listener_get(void);
 void sound_listener_update(void);
 
-void sound_source_create(struct Sound_Source* source, struct Transform* transform);
-void sound_source_destroy(struct Sound_Source* source);
-void sound_source_update(struct Sound_Source* source, struct Transform* transform);
-void sound_source_volume_set(struct Sound_Source* source, float volume);
-void sound_source_pitch_set(struct Sound_Source* source, float pitch);
-void sound_source_load_wav(struct Sound_Source* source, const char* file_name);
-void sound_source_loop_set(struct Sound_Source* source, bool loop);
-void sound_source_relative_set(struct Sound_Source* source, bool relative);
-void sound_source_play(struct Sound_Source* source);
-void sound_source_pause(struct Sound_Source* source);
-void sound_source_rewind(struct Sound_Source* source);
-void sound_source_stop(struct Sound_Source* source);
+void sound_source_create(struct Entity* entity, bool relative);
+void sound_source_destroy(struct Entity* entity);
+void sound_source_update(struct Entity* entity);
+void sound_source_volume_set(struct Entity* entity, float volume);
+void sound_source_pitch_set(struct Entity* entity, float pitch);
+void sound_source_load_wav(struct Entity* entity, const char* file_name);
+void sound_source_loop_set(struct Entity* entity, bool loop);
+void sound_source_relative_set(struct Entity* entity, bool relative);
+void sound_source_play(struct Entity* entity);
+void sound_source_pause(struct Entity* entity);
+void sound_source_rewind(struct Entity* entity);
+void sound_source_stop(struct Entity* entity);
 
 #endif
diff --git a/src/transform.c b/src/transform.c
index 1ceee55..6aacf6a 100644
--- a/src/transform.c
+++ b/src/transform.c
@@ -5,20 +5,21 @@
 #include "utils.h"
 #include <assert.h>
 
-void transform_create(struct Transform* transform, int parent_entity)
+void transform_create(struct Entity* entity, int parent_entity)
 {
-	assert(transform);
+	struct Transform* transform = &entity->transform;
 	vec3_fill(&transform->position, 0.f, 0.f, 0.f);
 	vec3_fill(&transform->scale, 1.f, 1.f, 1.f);
 	quat_identity(&transform->rotation);
 	mat4_identity(&transform->trans_mat);
 	transform->parent   = parent_entity;
 	transform->children = array_new(int);
-	transform_update_transmat(transform);
+	transform_update_transmat(entity);
 }
 
-void transform_translate(struct Transform* transform, vec3* amount, enum Transform_Space space)
+void transform_translate(struct Entity* entity, vec3* amount, enum Transform_Space space)
 {
+	struct Transform* transform = &entity->transform;
 	vec3 translation_amount;
 	vec3_assign(&translation_amount, amount);
 	if(space == TS_LOCAL)
@@ -35,14 +36,15 @@ void transform_translate(struct Transform* transform, vec3* amount, enum Transfo
 		}
 	}
 	vec3_add(&transform->position, &transform->position, &translation_amount);
-	transform_update_transmat(transform);
+	transform_update_transmat(entity);
 }
 
-void transform_rotate(struct Transform*    transform,
+void transform_rotate(struct Entity*       entity,
 					  vec3*                axis,
 					  float                angle,
 					  enum Transform_Space space)
 {
+	struct Transform* transform = &entity->transform;
 	quat new_rot;
 	quat_identity(&new_rot);
 	quat_axis_angle(&new_rot, axis, TO_RADIANS(angle));
@@ -51,75 +53,81 @@ void transform_rotate(struct Transform*    transform,
 		quat_mul(&transform->rotation, &transform->rotation, &new_rot);
 	else
 		quat_mul(&transform->rotation, &new_rot, &transform->rotation);
-	transform_update_transmat(transform);
+	transform_update_transmat(entity);
 }
 
-void transform_scale(struct Transform* transform, vec3* scale)
+void transform_scale(struct Entity* entity, vec3* scale)
 {
+	struct Transform* transform = &entity->transform;
 	vec3_assign(&transform->scale, scale);
-	transform_update_transmat(transform);
+	transform_update_transmat(entity);
 }
 
-void transform_get_forward(struct Transform* transform, vec3* res)
+void transform_get_forward(struct Entity* entity, vec3* res)
 {
+	struct Transform* transform = &entity->transform;
 	vec3_fill(res, 0.f, 0.f, -1.f);
 	quat_get_forward_rh(res, &transform->rotation);
 }
 
-void transform_get_lookat(struct Transform* transform, vec3* res)
+void transform_get_lookat(struct Entity* entity, vec3* res)
 {
-	transform_get_forward(transform, res);
+	struct Transform* transform = &entity->transform;
+	transform_get_forward(entity, res);
 	vec3_add(res, &transform->position, res);
 }
 
-void transform_get_absolute_forward(struct Transform* transform, vec3* res)
+void transform_get_absolute_forward(struct Entity* entity, vec3* res)
 {
 	quat abs_rot;
 	quat_identity(&abs_rot);
-	transform_get_absolute_rot(transform, &abs_rot);
+	transform_get_absolute_rot(entity, &abs_rot);
 	quat_get_forward_rh(res, &abs_rot);
 }
 
-void transform_get_absolute_lookat(struct Transform* transform, vec3* res)
+void transform_get_absolute_lookat(struct Entity* entity, vec3* res)
 {
 	vec3 abs_position = {0.f, 0.f, 0.f};
-	transform_get_absolute_pos(transform, &abs_position);
-	transform_get_absolute_forward(transform, res);
+	transform_get_absolute_pos(entity, &abs_position);
+	transform_get_absolute_forward(entity, res);
 	vec3_add(res, &abs_position, res);
 }
 
-void transform_get_up(struct Transform* transform, vec3* res)
+void transform_get_up(struct Entity* entity, vec3* res)
 {
+	struct Transform* transform = &entity->transform;
 	vec3_fill(res, 0.f, 1.f, 0.f);
 	quat_get_up(res, &transform->rotation);
 }
 
-void transform_get_absolute_up(struct Transform* transform, vec3* res)
+void transform_get_absolute_up(struct Entity* entity, vec3* res)
 {
 	quat abs_rot;
 	quat_identity(&abs_rot);
-	transform_get_absolute_rot(transform, &abs_rot);
+	transform_get_absolute_rot(entity, &abs_rot);
 	quat_get_up(res, &abs_rot);
 }
 
-void transform_get_absolute_right(struct Transform* transform, vec3* res)
+void transform_get_absolute_right(struct Entity* entity, vec3* res)
 {
 	quat abs_rot;
 	quat_identity(&abs_rot);
-	transform_get_absolute_rot(transform, &abs_rot);
+	transform_get_absolute_rot(entity, &abs_rot);
 	quat_get_right(res, &abs_rot);
 }
 
 
-void transform_get_right(struct Transform* transform, vec3* res)
+void transform_get_right(struct Entity* entity, vec3* res)
 {
+	struct Transform* transform = &entity->transform;
 	vec3_fill(res, 1.f, 0.f, 0.f);
 	quat_get_right(res, &transform->rotation);
 }
 
-void transform_update_transmat(struct Transform* transform)
+void transform_update_transmat(struct Entity* entity)
 {
 	static mat4 scale, translation, rotation;
+	struct Transform* transform = &entity->transform;
 	mat4_identity(&scale);
 	mat4_identity(&translation);
 	mat4_identity(&rotation);
@@ -145,17 +153,16 @@ void transform_update_transmat(struct Transform* transform)
 	{
 		for(int i = 0; i < children; i++)
 		{
-			struct Entity*    child      = entity_get(transform->children[i]);
-			struct Transform* child_tran = &child->transform;
-			transform_update_transmat(child_tran);
+			struct Entity* child = entity_get(transform->children[i]);
+			transform_update_transmat(child);
 		}
 	}
 	transform->is_modified = true;
 }
 
-void transform_destroy(struct Transform* transform)
+void transform_destroy(struct Entity* entity)
 {
-	assert(transform);
+	struct Transform* transform = &entity->transform;
 	int children = array_len(transform->children);
 	if(children > 0)
 	{
@@ -176,41 +183,36 @@ void transform_destroy(struct Transform* transform)
 	transform->is_modified = false;
 }
 
-void transform_set_position(struct Transform* transform, vec3* new_position)
+void transform_set_position(struct Entity* entity, vec3* new_position)
 {
+	struct Transform* transform = &entity->transform;
 	vec3_assign(&transform->position, new_position);
-	transform_update_transmat(transform);
+	transform_update_transmat(entity);
 }
 
-void transform_get_absolute_pos(struct Transform* transform, vec3* res)
+void transform_get_absolute_pos(struct Entity* entity, vec3* res)
 {
-	struct Entity* parent = entity_get(transform->parent);
+	struct Transform* transform = &entity->transform;
+	struct Entity*    parent    = entity_get(transform->parent);
 	if(parent)
-	{
-		struct Transform* parent_tran = &parent->transform;
-		transform_get_absolute_pos(parent_tran, res);
-	}
+		transform_get_absolute_pos(parent, res);
 	vec3_add(res, res, &transform->position);
 }
 
-void transform_get_absolute_scale(struct Transform* transform, vec3* res)
+void transform_get_absolute_scale(struct Entity* entity, vec3* res)
 {
-	struct Entity* parent = entity_get(transform->parent);
+	struct Transform* transform = &entity->transform;
+	struct Entity*    parent    = entity_get(transform->parent);
 	if(parent)
-	{
-		struct Transform* parent_tran = &parent->transform;
-		transform_get_absolute_scale(parent_tran, res);
-	}
+		transform_get_absolute_scale(parent, res);
 	vec3_add(res, res, &transform->scale);
 }
 
-void transform_get_absolute_rot(struct Transform* transform, quat* res)
+void transform_get_absolute_rot(struct Entity* entity, quat* res)
 {
-	struct Entity* parent = entity_get(transform->parent);
+	struct Transform* transform = &entity->transform;
+	struct Entity*    parent    = entity_get(transform->parent);
 	if(parent)
-	{
-		struct Transform* parent_tran = &parent->transform;
-		transform_get_absolute_rot(parent_tran, res);
-	}
+		transform_get_absolute_rot(parent, res);
 	quat_mul(res, res, &transform->rotation);
 }
diff --git a/src/transform.h b/src/transform.h
index 7e456dc..2355073 100644
--- a/src/transform.h
+++ b/src/transform.h
@@ -5,28 +5,28 @@
 
 enum Transform_Space { TS_LOCAL, TS_PARENT, TS_WORLD};
 
-struct Transform;
+struct Entity;
 
-void transform_create(struct Transform* transform, int parent_entity);
-void transform_destroy(struct Transform* transform);
-void transform_translate(struct Transform* transform, vec3* amount, enum Transform_Space space);
-void transform_rotate(struct Transform*    transform,
+void transform_create(struct Entity* transform, int parent_entity);
+void transform_destroy(struct Entity* transform);
+void transform_translate(struct Entity* transform, vec3* amount, enum Transform_Space space);
+void transform_rotate(struct Entity*    transform,
 					  vec3*                axis,
 					  float                angle,
 					  enum Transform_Space space);
-void transform_scale(struct Transform* transform, vec3* scale);
-void transform_set_position(struct Transform* transform, vec3* new_position);
-void transform_get_forward(struct Transform* transform, vec3* res);
-void transform_get_lookat(struct Transform* transform, vec3* res);
-void transform_get_up(struct Transform* transform, vec3* res);
-void transform_get_right(struct Transform* transform, vec3* res);
-void transform_update_transmat(struct Transform* transform);
-void transform_get_absolute_pos(struct Transform* transform, vec3* res);
-void transform_get_absolute_rot(struct Transform* transform, quat* res);
-void transform_get_absolute_scale(struct Transform* transform, vec3* res);
-void transform_get_absolute_lookat(struct Transform* transform, vec3* res);
-void transform_get_absolute_up(struct Transform* transform, vec3* res);
-void transform_get_absolute_right(struct Transform* transform, vec3* res);
-void transform_get_absolute_forward(struct Transform* transform, vec3* res);
+void transform_scale(struct Entity* transform, vec3* scale);
+void transform_set_position(struct Entity* transform, vec3* new_position);
+void transform_get_forward(struct Entity* transform, vec3* res);
+void transform_get_lookat(struct Entity* transform, vec3* res);
+void transform_get_up(struct Entity* transform, vec3* res);
+void transform_get_right(struct Entity* transform, vec3* res);
+void transform_update_transmat(struct Entity* transform);
+void transform_get_absolute_pos(struct Entity* transform, vec3* res);
+void transform_get_absolute_rot(struct Entity* transform, quat* res);
+void transform_get_absolute_scale(struct Entity* transform, vec3* res);
+void transform_get_absolute_lookat(struct Entity* transform, vec3* res);
+void transform_get_absolute_up(struct Entity* transform, vec3* res);
+void transform_get_absolute_right(struct Entity* transform, vec3* res);
+void transform_get_absolute_forward(struct Entity* transform, vec3* res);
 
 #endif