shariq
/
Symmetry
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

All funcions that previously required 'Component' structs now only need Entity. Phase 2 of the refactoring towards Fat entities completed

Browse Source
dev
shariq 8 years ago
parent 104481b617
commit b7f490ebdb
15 changed files with 273 additions and 252 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 35
      src/camera.c
  2. 15
      src/camera.h
  3. 16
      src/entity.c
  4. 3
      src/entity.h
  5. 98
      src/game.c
  6. 15
      src/light.c
  7. 6
      src/light.h
  8. 33
      src/model.c
  9. 10
      src/model.h
  10. 2
      src/renderer.c
  11. 4
      src/scene.c
  12. 99
      src/sound.c
  13. 27
      src/sound.h
  14. 92
      src/transform.c
  15. 38
      src/transform.h

35
src/camera.c
Unescape View File

@ -18,9 +18,9 @@
static void update_frustum(struct Camera* camera); 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->fbo != -1) framebuffer_remove(camera->fbo);
if(camera->render_tex != -1) texture_remove(camera->render_tex); if(camera->render_tex != -1) texture_remove(camera->render_tex);
if(camera->depth_tex != -1) texture_remove(camera->depth_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); 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->fbo = -1;
camera->render_tex = -1; camera->render_tex = -1;
camera->depth_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); mat4_identity(&camera->view_proj_mat);
for(int i = 0; i < FP_NUM_PLANES; i++) for(int i = 0; i < FP_NUM_PLANES; i++)
vec4_fill(&camera->frustum[i], 0.f, 0.f, 0.f, 0.f); vec4_fill(&camera->frustum[i], 0.f, 0.f, 0.f, 0.f);
camera_update_view(camera, transform); camera_update_view(entity);
camera_update_proj(camera); camera_update_proj(entity);
vec4_fill(&camera->clear_color, 1.f, 1.f, 1.f, 1.f); 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_identity(&camera->view_proj_mat);
mat4_mul(&camera->view_proj_mat, &camera->proj_mat, &camera->view_mat); mat4_mul(&camera->view_proj_mat, &camera->proj_mat, &camera->view_mat);
update_frustum(camera); 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 lookat = {0.f, 0.f, 0.f};
vec3 up = {0.f, 0.f, 0.f}; vec3 up = {0.f, 0.f, 0.f};
vec3 position = {0.f, 0.f, 0.f}; vec3 position = {0.f, 0.f, 0.f};
transform_get_absolute_lookat(transform, &lookat); transform_get_absolute_lookat(entity, &lookat);
transform_get_absolute_up(transform, &up); transform_get_absolute_up(entity, &up);
transform_get_absolute_pos(transform, &position); transform_get_absolute_pos(entity, &position);
mat4_lookat(&camera->view_mat, &position, &lookat, &up); 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) if(!camera->ortho)
{ {
mat4_perspective(&camera->proj_mat, 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); 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 width,
int height, int height,
int has_depth, int has_depth,
int has_color, int has_color,
int resizeable) int resizeable)
{ {
assert(width > 0 && height > 0 && camera); assert(width > 0 && height > 0);
struct Camera* camera = &entity->camera;
if(camera->fbo != -1) if(camera->fbo != -1)
{ {
log_error("camera:attach_fbo", "Camera already has fbo attached!"); log_error("camera:attach_fbo", "Camera already has fbo attached!");

15
src/camera.h
Unescape View File

@ -1,15 +1,14 @@
#ifndef CAMERA_H #ifndef CAMERA_H
#define CAMERA_H #define CAMERA_H
struct Camera; struct Entity;
struct Transform;
void camera_destroy(struct Camera* camera); void camera_destroy(struct Entity* entity);
void camera_create(struct Camera* camera, struct Transform* transform, int width, int height); void camera_create(struct Entity* entity, int width, int height);
void camera_update_view_proj(struct Camera* camera); void camera_update_view_proj(struct Entity* entity);
void camera_update_view(struct Camera* camera, struct Transform* transform); void camera_update_view(struct Entity* entity);
void camera_update_proj(struct Camera* camera); void camera_update_proj(struct Entity* entity);
void camera_attach_fbo(struct Camera* camera, void camera_attach_fbo(struct Entity* entity,
int width, int width,
int height, int height,
int has_depth, int has_depth,

16
src/entity.c
Unescape View File

@ -35,13 +35,13 @@ void entity_remove(int index)
{ {
struct Entity* entity = &entity_list[index]; struct Entity* entity = &entity_list[index];
transform_destroy(&entity->transform); transform_destroy(entity);
switch(entity->type) switch(entity->type)
{ {
case ET_CAMERA: camera_destroy(&entity->camera); break; case ET_CAMERA: camera_destroy(entity); break;
case ET_LIGHT: light_destroy(&entity->light, entity->id); break; case ET_LIGHT: light_destroy(entity); break;
case ET_SOUND_SOURCE: sound_source_destroy(&entity->sound_source); break; case ET_SOUND_SOURCE: sound_source_destroy(entity); break;
case ET_STATIC_MESH: model_destroy(&entity->model, entity->id); break; case ET_STATIC_MESH: model_destroy(entity); break;
case ET_ROOT: break; case ET_ROOT: break;
default: log_error("entity:remove", "Invalid entity type"); break; default: log_error("entity:remove", "Invalid entity type"); break;
}; };
@ -79,7 +79,7 @@ struct Entity* entity_create(const char* name, const int type, int parent_id)
new_entity->type = type; new_entity->type = type;
new_entity->marked_for_deletion = false; new_entity->marked_for_deletion = false;
new_entity->renderable = false; new_entity->renderable = false;
transform_create(&new_entity->transform, parent_id); transform_create(new_entity, parent_id);
return new_entity; return new_entity;
} }
@ -131,9 +131,9 @@ void entity_post_update(void)
if(entity->transform.is_modified) if(entity->transform.is_modified)
{ {
if(entity->type == ET_CAMERA) if(entity->type == ET_CAMERA)
camera_update_view(&entity->camera, &entity->transform); camera_update_view(entity);
else if(entity->type == ET_SOUND_SOURCE) 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(); if(entity->is_listener) sound_listener_update();
} }

3
src/entity.h
Unescape View File

@ -46,9 +46,10 @@ struct Model
struct Sound_Source struct Sound_Source
{ {
bool active;
bool relative;
uint al_source_handle; uint al_source_handle;
uint al_buffer_handle; uint al_buffer_handle;
bool active;
}; };
struct Camera struct Camera

98
src/game.c
Unescape View File

@ -90,45 +90,34 @@ void scene_setup(void)
struct Entity* player = scene_add_new("player", ET_CAMERA); struct Entity* player = scene_add_new("player", ET_CAMERA);
game_state->player_node = player->id; game_state->player_node = player->id;
vec3 viewer_pos = {10, 5, 100}; vec3 viewer_pos = {10, 5, 100};
struct Transform* viewer_tran = &player->transform; transform_set_position(player, &viewer_pos);
/* 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);
int render_width, render_height; int render_width, render_height;
render_width = 1024; render_width = 1024;
render_height = 768; render_height = 768;
struct Camera* camera = &player->camera; camera_create(player, render_width, render_height);
camera_create(camera, &player->transform, render_width, render_height); camera_attach_fbo(player, render_width, render_height, 1, 1, 1);
camera_attach_fbo(camera, render_width, render_height, 1, 1, 1); vec4_fill(&player->camera.clear_color, 0.3f, 0.6f, 0.9f, 1.0f);
vec4_fill(&camera->clear_color, 0.3f, 0.6f, 0.9f, 1.0f);
sound_listener_set(player->id); sound_listener_set(player->id);
vec4 color = {0.f, 1.f, 1.f, 1.f }; vec4 color = {0.f, 1.f, 1.f, 1.f };
struct Entity* new_ent = scene_add_new("Model_Entity", ET_STATIC_MESH); struct Entity* new_ent = scene_add_new("Model_Entity", ET_STATIC_MESH);
struct Transform* tran = &new_ent->transform;
vec3 position = {0, 0, -5}; vec3 position = {0, 0, -5};
transform_translate(tran, &position, TS_WORLD); transform_translate(new_ent, &position, TS_WORLD);
struct Model* box_model = &new_ent->model;
new_ent->renderable = true; new_ent->renderable = true;
model_create(box_model, new_ent->id, "default.pamesh", "Blinn_Phong"); model_create(new_ent, "default.pamesh", "Blinn_Phong");
model_set_material_param(box_model, "diffuse_color", &color); model_set_material_param(new_ent, "diffuse_color", &color);
int tex = texture_create_from_file("white.tga", TU_DIFFUSE); 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}; 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 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(sound_ent, false);
sound_source_create(source, &new_ent->transform); sound_source_load_wav(sound_ent, "BigExplosion.wav");
if(source) //sound_source_relative_set(source, true);
{ sound_source_volume_set(sound_ent, 1.f);
sound_source_load_wav(source, "BigExplosion.wav"); sound_source_loop_set(sound_ent, true);
//sound_source_relative_set(source, 1); sound_source_play(sound_ent);
sound_source_volume_set(source, 1.f);
sound_source_loop_set(source, 1);
sound_source_play(source);
}
int parent_node = new_ent->id; int parent_node = new_ent->id;
int num_suz = 20; 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_as_child("Suzanne", ET_STATIC_MESH, parent_node);
struct Entity* suz = scene_add_new("Suzanne", ET_STATIC_MESH); struct Entity* suz = scene_add_new("Suzanne", ET_STATIC_MESH);
suz->renderable = true; suz->renderable = true;
struct Model* suz_model = &suz->model; model_create(suz, "suzanne.pamesh", "Blinn_Phong");
model_create(suz_model, suz->id, "suzanne.pamesh", "Blinn_Phong"); model_set_material_param(suz, "diffuse_color", &color);
model_set_material_param(suz_model, "diffuse_color", &color);
float spec_str = 80.f; 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}; 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); struct Entity* ground = scene_add_new("Ground", ET_STATIC_MESH);
ground->renderable = true; ground->renderable = true;
struct Model* ground_model = &ground->model; model_create(ground, "default.pamesh", "Blinn_Phong");
model_create(ground_model, ground->id, "default.pamesh", "Blinn_Phong"); model_set_material_param(ground, "diffuse_color", &color);
model_set_material_param(ground_model, "diffuse_color", &color);
int white_tex = texture_create_from_file("white.tga", TU_DIFFUSE); 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; 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 pos = {0, -15, 0};
vec3 scale_ground = {100.f, 2.f, 100.f}; vec3 scale_ground = {100.f, 2.f, 100.f};
transform_set_position(&ground->transform, &pos); transform_set_position(ground, &pos);
transform_scale(&ground->transform, &scale_ground); transform_scale(ground, &scale_ground);
/* struct Entity* screen = scene_add_new("Screen", NULL); */ /* struct Entity* screen = scene_add_new("Screen", NULL); */
/* struct Model* screen_model = entity_component_add(screen, C_MODEL, NULL, NULL); */ /* struct Model* screen_model = entity_component_add(screen, C_MODEL, NULL, NULL); */
@ -188,11 +175,10 @@ void scene_setup(void)
x++; z++; x++; z++;
struct Entity* light_ent = scene_add_new("Light_Ent", ET_LIGHT); struct Entity* light_ent = scene_add_new("Light_Ent", ET_LIGHT);
vec3 lt_pos = {x * 20, 0, z * 20}; vec3 lt_pos = {x * 20, 0, z * 20};
transform_set_position(&light_ent->transform, &lt_pos); transform_set_position(light_ent, &lt_pos);
struct Light* light_comp = &light_ent->light; light_create(light_ent, LT_POINT);
light_create(&light_ent->light, light_ent->id, LT_POINT); vec3_fill(&light_ent->light.color, 1.f / (float)x, 1.f / ((rand() % 10) + 1.f), 1.f / (float)z);
vec3_fill(&light_comp->color, 1.f / (float)x, 1.f / ((rand() % 10) + 1.f), 1.f / (float)z); light_ent->light.intensity = 1.f;
light_comp->intensity = 1.f;
} }
/* struct Entity* sun = scene_add_new("Sun", NULL); */ /* 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(player_node);
struct Entity* entity = entity_get(game_state->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; float move_speed = 5.f, move_scale = 3.f, turn_speed = 50.f;
vec3 offset = {0, 0, 0}; vec3 offset = {0, 0, 0};
float turn_up_down = 0.f; float turn_up_down = 0.f;
@ -252,25 +236,25 @@ void debug(float dt)
if(turn_left_right != 0.f) 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 up = {0.f, 0.f, 0.f};
vec3 forward = {0.f, 0.f, 0.f}; vec3 forward = {0.f, 0.f, 0.f};
vec3 lookat = {0.f, 0.f, 0.f}; vec3 lookat = {0.f, 0.f, 0.f};
transform_get_up(transform, &up); transform_get_up(entity, &up);
transform_get_forward(transform, &forward); transform_get_forward(entity, &forward);
transform_get_lookat(transform, &lookat); transform_get_lookat(entity, &lookat);
/* log_message("Up : %s", tostr_vec3(&up)); */ /* log_message("Up : %s", tostr_vec3(&up)); */
/* log_message("FR : %s", tostr_vec3(&forward)); */ /* log_message("FR : %s", tostr_vec3(&forward)); */
} }
if(turn_up_down != 0.f) 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 up = {0.f, 0.f, 0.f};
vec3 forward = {0.f, 0.f, 0.f}; vec3 forward = {0.f, 0.f, 0.f};
vec3 lookat = {0.f, 0.f, 0.f}; vec3 lookat = {0.f, 0.f, 0.f};
transform_get_up(transform, &up); transform_get_up(entity, &up);
transform_get_forward(transform, &forward); transform_get_forward(entity, &forward);
transform_get_lookat(transform, &lookat); transform_get_lookat(entity, &lookat);
/* log_message("Up : %s", tostr_vec3(&up)); */ /* log_message("Up : %s", tostr_vec3(&up)); */
/* log_message("FR : %s", tostr_vec3(&forward)); */ /* log_message("FR : %s", tostr_vec3(&forward)); */
} }
@ -287,7 +271,7 @@ void debug(float dt)
vec3_scale(&offset, &offset, dt); vec3_scale(&offset, &offset, dt);
if(offset.x != 0 || offset.y != 0 || offset.z != 0) 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)); //log_message("Position : %s", tostr_vec3(&transform->position));
} }
@ -295,7 +279,7 @@ void debug(float dt)
{ {
struct Entity* model = scene_find("Model_Entity"); struct Entity* model = scene_find("Model_Entity");
vec3 x_axis = {1, 0, 0}; 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)) if(input_is_key_pressed(KEY_M))
@ -304,7 +288,7 @@ void debug(float dt)
//vec3 y_axis = {0, 0, 1}; //vec3 y_axis = {0, 0, 1};
//transform_rotate(mod_tran, &y_axis, 25.f * dt, TS_LOCAL); //transform_rotate(mod_tran, &y_axis, 25.f * dt, TS_LOCAL);
vec3 amount = {0, 0, -5 * dt}; 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)) if(input_is_key_pressed(KEY_N))
@ -313,7 +297,7 @@ void debug(float dt)
/* vec3 y_axis = {0, 0, 1}; */ /* vec3 y_axis = {0, 0, 1}; */
/* transform_rotate(mod_tran, &y_axis, 25.f * dt, TS_WORLD); */ /* transform_rotate(mod_tran, &y_axis, 25.f * dt, TS_WORLD); */
vec3 amount = {0, 0, 5 * dt}; vec3 amount = {0, 0, 5 * dt};
transform_translate(&model->transform, &amount, TS_LOCAL); transform_translate(model, &amount, TS_LOCAL);
} }
} }

15
src/light.c
Unescape View File

@ -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->valid = true;
light->cast_shadow = 0; light->cast_shadow = 0;
light->depth_bias = 0.0005f; light->depth_bias = 0.0005f;
@ -33,17 +32,17 @@ void light_create(struct Light* light, int entity_id, int light_type)
light->radius = 20; light->radius = 20;
vec3_fill(&light->color, 1.f, 1.f, 1.f); vec3_fill(&light->color, 1.f, 1.f, 1.f);
int* new_index = array_grow(light_list, int); 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; int index_to_remove = -1;
for(int i = 0; i < array_len(light_list); i++) 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; index_to_remove = i;
break; break;

6
src/light.h
Unescape View File

@ -3,12 +3,12 @@
#define MAX_SHADOWMAPS 4 #define MAX_SHADOWMAPS 4
struct Light; struct Entity;
void light_init(void); void light_init(void);
void light_cleanup(void); void light_cleanup(void);
void light_destroy(struct Light* light, int entity_id); void light_destroy(struct Entity* entity);
void light_create(struct Light* light, int entity_id, int light_type); void light_create(struct Entity* entity, int light_type);
int* light_get_valid_indices(int* out_count); int* light_get_valid_indices(int* out_count);
#endif #endif

33
src/model.c
Unescape View File

@ -31,27 +31,27 @@ void model_init(void)
num_indices_slot = editor_debugvar_slot_create("Total Indices", VT_INT); 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 no name is given for geometry, use default */
if(!geo_name) geo_name = "default.pamesh"; if(!geo_name) geo_name = "default.pamesh";
int geo_index = geom_create_from_file(geo_name); int geo_index = geom_create_from_file(geo_name);
model->geometry_index = geo_index; 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"); 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); geom_remove(model->geometry_index);
model->geometry_index = -1; model->geometry_index = -1;
material_unregister_model(model, entity_id); material_unregister_model(model, entity->id);
/* deallocate all params */ /* deallocate all params */
for(int i = 0; i < array_len(model->material_params); i++) for(int i = 0; i < array_len(model->material_params); i++)
free(model->material_params[i].value); free(model->material_params[i].value);
@ -166,20 +166,18 @@ void model_render_all(struct Entity* camera_entity, int draw_mode)
{ {
struct Entity* light_entity = entity_get(light_index_list[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 Light* light = &light_entity->light; /* TODO: Cull lights according to camera frustum */
struct Transform* light_transform = &light_entity->transform;
vec3 light_pos = {0, 0, 0}; 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) if(light->type != LT_POINT)
{ {
snprintf(uniform_name, MAX_NAME_LEN, "lights[%d].direction", i); 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); vec3_norm(&light_pos, &light_pos);
shader_set_uniform_vec3(material->shader, uniform_name, &light_pos); shader_set_uniform_vec3(material->shader, uniform_name, &light_pos);
memset(uniform_name, '\0', MAX_NAME_LEN); memset(uniform_name, '\0', MAX_NAME_LEN);
} }
if(light->type != LT_DIR) if(light->type != LT_DIR)
{ {
snprintf(uniform_name, MAX_NAME_LEN, "lights[%d].position", i); 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); 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}; 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); 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; 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; int success = 0;
struct Material* material = material_get(model->material); struct Material* material = material_get(model->material);
for(int i = 0; i < array_len(model->material_params); i++) 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; 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; int success = 0;
struct Material* material = material_get(model->material); struct Material* material = material_get(model->material);
for(int i = 0; i < array_len(model->material_params); i++) for(int i = 0; i < array_len(model->material_params); i++)

10
src/model.h
Unescape View File

@ -3,18 +3,16 @@
#include "linmath.h" #include "linmath.h"
struct Camera;
struct Material_Param; struct Material_Param;
struct Model;
struct Entity; struct Entity;
void model_init(void); void model_init(void);
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);
void model_destroy(struct Model* model, int entity_id); void model_destroy(struct Entity* entity);
void model_cleanup(void); void model_cleanup(void);
void model_render_all(struct Entity* camera_entity, int draw_mode); 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_set_material_param(struct Entity* entity, const char* name, void* value);
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);
void model_render_all_debug(struct Entity* camera_entity, void model_render_all_debug(struct Entity* camera_entity,
int debug_shader, int debug_shader,
int draw_mode, int draw_mode,

2
src/renderer.c
Unescape View File

@ -213,7 +213,7 @@ void on_framebuffer_size_change(int width, int height)
if(viewer->type != ET_CAMERA) continue; if(viewer->type != ET_CAMERA) continue;
viewer->camera.aspect_ratio = aspect > 0.f ? aspect : 4.f / 3.f; 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); framebuffer_resize_all(width, height);

4
src/scene.c
Unescape View File

@ -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); new_entity = entity_create(name, type, parent_id);
struct Entity* parent = entity_get(parent_id); struct Entity* parent = entity_get(parent_id);
new_entity->transform.parent = parent->id; new_entity->transform.parent = parent->id;
transform_update_transmat(&new_entity->transform); transform_update_transmat(new_entity);
return 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); array_remove_at(curr_parent->transform.children, index);
entity->transform.parent = new_parent->id; entity->transform.parent = new_parent->id;
array_push(new_parent, entity->id, int); array_push(new_parent, entity->id, int);
transform_update_transmat(&entity->transform); transform_update_transmat(entity);
} }
else else
{ {

99
src/sound.c
Unescape View File

@ -21,7 +21,13 @@ struct Sound_State
float volume; 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) bool sound_init(void)
{ {
@ -84,9 +90,9 @@ void sound_listener_update(void)
vec3 abs_up = {0.f, 1.f, 0.f}; vec3 abs_up = {0.f, 1.f, 0.f};
vec3 abs_forward = {0.f, 0.f, -1.f}; vec3 abs_forward = {0.f, 0.f, -1.f};
transform_get_absolute_pos(&entity->transform, &abs_pos); transform_get_absolute_pos(entity, &abs_pos);
transform_get_absolute_up(&entity->transform, &abs_up); transform_get_absolute_up(entity, &abs_up);
transform_get_absolute_forward(&entity->transform, &abs_forward); transform_get_absolute_forward(entity, &abs_forward);
float orientation[] = float orientation[] =
{ {
abs_forward.x, abs_forward.y, abs_forward.z, 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)) 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(!source->active) return;
if(alIsBuffer(source->al_buffer_handle) == AL_TRUE) 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(alSourcei(source->al_source_handle, AL_BUFFER, 0))
al_check(alDeleteBuffers(1, &source->al_buffer_handle)) 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; source->active = true;
al_check(alGenSources(1, &source->al_source_handle)) al_check(alGenSources(1, &source->al_source_handle))
al_check(alGenBuffers(1, &source->al_buffer_handle)) al_check(alGenBuffers(1, &source->al_buffer_handle))
sound_source_volume_set(source, 1.f); sound_source_volume_set(entity, 1.f);
if(transform) if(relative)
sound_source_update(source, transform); sound_source_relative_set(entity, true);
else 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_pos = {0.f, 0.f, 0.f};
vec3 abs_up = {0.f, 1.f, 0.f}; vec3 abs_up = {0.f, 1.f, 0.f};
vec3 abs_forward = {0.f, 0.f, -1.f}; vec3 abs_forward = {0.f, 0.f, -1.f};
transform_get_absolute_pos(transform, &abs_pos); transform_get_absolute_pos(entity, &abs_pos);
transform_get_absolute_up(transform, &abs_up); transform_get_absolute_up(entity, &abs_up);
transform_get_absolute_forward(transform, &abs_forward); transform_get_absolute_forward(entity, &abs_forward);
float orientation[] = float orientation[] =
{ {
abs_forward.x, abs_forward.y, abs_forward.z, abs_forward.x, abs_forward.y, abs_forward.z,
abs_up.x, abs_up.y, abs_up.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(alSource3f(entity->sound_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(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; 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; 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; 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; 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) if(!file_name)
{ {
log_error("sound_source:load_wav", "No file name given"); log_error("sound_source:load_wav", "No file name given");
@ -260,12 +275,32 @@ void sound_source_load_wav(struct Sound_Source* source, const char* file_name)
return; 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(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)) al_check(alSourcei(source->al_source_handle, AL_BUFFER, source->al_buffer_handle))
SDL_FreeWAV(wav_data); SDL_FreeWAV(wav_data);
} }
void sound_source_play(struct Sound_Source* source) { al_check(alSourcePlay(source->al_source_handle)) } void sound_source_play(struct Entity* entity)
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)) } assert(entity && entity->type == ET_SOUND_SOURCE);
void sound_source_stop(struct Sound_Source* source) { al_check(alSourceStop(source->al_source_handle)) } 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))
}

27
src/sound.h
Unescape View File

@ -9,8 +9,7 @@
#define al_check(expr) expr; #define al_check(expr) expr;
#endif #endif
struct Sound_Source; struct Entity;
struct Transform;
bool sound_init(void); bool sound_init(void);
void sound_cleanup(void); void sound_cleanup(void);
@ -21,17 +20,17 @@ void sound_listener_set(int entity);
int sound_listener_get(void); int sound_listener_get(void);
void sound_listener_update(void); void sound_listener_update(void);
void sound_source_create(struct Sound_Source* source, struct Transform* transform); void sound_source_create(struct Entity* entity, bool relative);
void sound_source_destroy(struct Sound_Source* source); void sound_source_destroy(struct Entity* entity);
void sound_source_update(struct Sound_Source* source, struct Transform* transform); void sound_source_update(struct Entity* entity);
void sound_source_volume_set(struct Sound_Source* source, float volume); void sound_source_volume_set(struct Entity* entity, float volume);
void sound_source_pitch_set(struct Sound_Source* source, float pitch); void sound_source_pitch_set(struct Entity* entity, float pitch);
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);
void sound_source_loop_set(struct Sound_Source* source, bool loop); void sound_source_loop_set(struct Entity* entity, bool loop);
void sound_source_relative_set(struct Sound_Source* source, bool relative); void sound_source_relative_set(struct Entity* entity, bool relative);
void sound_source_play(struct Sound_Source* source); void sound_source_play(struct Entity* entity);
void sound_source_pause(struct Sound_Source* source); void sound_source_pause(struct Entity* entity);
void sound_source_rewind(struct Sound_Source* source); void sound_source_rewind(struct Entity* entity);
void sound_source_stop(struct Sound_Source* source); void sound_source_stop(struct Entity* entity);
#endif #endif

92
src/transform.c
Unescape View File

@ -5,20 +5,21 @@
#include "utils.h" #include "utils.h"
#include <assert.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->position, 0.f, 0.f, 0.f);
vec3_fill(&transform->scale, 1.f, 1.f, 1.f); vec3_fill(&transform->scale, 1.f, 1.f, 1.f);
quat_identity(&transform->rotation); quat_identity(&transform->rotation);
mat4_identity(&transform->trans_mat); mat4_identity(&transform->trans_mat);
transform->parent = parent_entity; transform->parent = parent_entity;
transform->children = array_new(int); 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 translation_amount;
vec3_assign(&translation_amount, amount); vec3_assign(&translation_amount, amount);
if(space == TS_LOCAL) 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); 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, vec3* axis,
float angle, float angle,
enum Transform_Space space) enum Transform_Space space)
{ {
struct Transform* transform = &entity->transform;
quat new_rot; quat new_rot;
quat_identity(&new_rot); quat_identity(&new_rot);
quat_axis_angle(&new_rot, axis, TO_RADIANS(angle)); 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); quat_mul(&transform->rotation, &transform->rotation, &new_rot);
else else
quat_mul(&transform->rotation, &new_rot, &transform->rotation); 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); 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); vec3_fill(res, 0.f, 0.f, -1.f);
quat_get_forward_rh(res, &transform->rotation); 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); 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 abs_rot;
quat_identity(&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); 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}; vec3 abs_position = {0.f, 0.f, 0.f};
transform_get_absolute_pos(transform, &abs_position); transform_get_absolute_pos(entity, &abs_position);
transform_get_absolute_forward(transform, res); transform_get_absolute_forward(entity, res);
vec3_add(res, &abs_position, 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); vec3_fill(res, 0.f, 1.f, 0.f);
quat_get_up(res, &transform->rotation); 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 abs_rot;
quat_identity(&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); 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 abs_rot;
quat_identity(&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); 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); vec3_fill(res, 1.f, 0.f, 0.f);
quat_get_right(res, &transform->rotation); 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; static mat4 scale, translation, rotation;
struct Transform* transform = &entity->transform;
mat4_identity(&scale); mat4_identity(&scale);
mat4_identity(&translation); mat4_identity(&translation);
mat4_identity(&rotation); mat4_identity(&rotation);
@ -146,16 +154,15 @@ void transform_update_transmat(struct Transform* transform)
for(int i = 0; i < children; i++) for(int i = 0; i < children; i++)
{ {
struct Entity* child = entity_get(transform->children[i]); struct Entity* child = entity_get(transform->children[i]);
struct Transform* child_tran = &child->transform; transform_update_transmat(child);
transform_update_transmat(child_tran);
} }
} }
transform->is_modified = true; 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); int children = array_len(transform->children);
if(children > 0) if(children > 0)
{ {
@ -176,41 +183,36 @@ void transform_destroy(struct Transform* transform)
transform->is_modified = false; 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); 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 Transform* transform = &entity->transform;
struct Entity* parent = entity_get(transform->parent); struct Entity* parent = entity_get(transform->parent);
if(parent) if(parent)
{ transform_get_absolute_pos(parent, res);
struct Transform* parent_tran = &parent->transform;
transform_get_absolute_pos(parent_tran, res);
}
vec3_add(res, res, &transform->position); 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 Transform* transform = &entity->transform;
struct Entity* parent = entity_get(transform->parent); struct Entity* parent = entity_get(transform->parent);
if(parent) if(parent)
{ transform_get_absolute_scale(parent, res);
struct Transform* parent_tran = &parent->transform;
transform_get_absolute_scale(parent_tran, res);
}
vec3_add(res, res, &transform->scale); 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 Transform* transform = &entity->transform;
struct Entity* parent = entity_get(transform->parent); struct Entity* parent = entity_get(transform->parent);
if(parent) if(parent)
{ transform_get_absolute_rot(parent, res);
struct Transform* parent_tran = &parent->transform;
transform_get_absolute_rot(parent_tran, res);
}
quat_mul(res, res, &transform->rotation); quat_mul(res, res, &transform->rotation);
} }

38
src/transform.h
Unescape View File

@ -5,28 +5,28 @@
enum Transform_Space { TS_LOCAL, TS_PARENT, TS_WORLD}; enum Transform_Space { TS_LOCAL, TS_PARENT, TS_WORLD};
struct Transform; struct Entity;
void transform_create(struct Transform* transform, int parent_entity); void transform_create(struct Entity* transform, int parent_entity);
void transform_destroy(struct Transform* transform); void transform_destroy(struct Entity* transform);
void transform_translate(struct Transform* transform, vec3* amount, enum Transform_Space space); void transform_translate(struct Entity* transform, vec3* amount, enum Transform_Space space);
void transform_rotate(struct Transform* transform, void transform_rotate(struct Entity* transform,
vec3* axis, vec3* axis,
float angle, float angle,
enum Transform_Space space); enum Transform_Space space);
void transform_scale(struct Transform* transform, vec3* scale); void transform_scale(struct Entity* transform, vec3* scale);
void transform_set_position(struct Transform* transform, vec3* new_position); void transform_set_position(struct Entity* transform, vec3* new_position);
void transform_get_forward(struct Transform* transform, vec3* res); void transform_get_forward(struct Entity* transform, vec3* res);
void transform_get_lookat(struct Transform* transform, vec3* res); void transform_get_lookat(struct Entity* transform, vec3* res);
void transform_get_up(struct Transform* transform, vec3* res); void transform_get_up(struct Entity* transform, vec3* res);
void transform_get_right(struct Transform* transform, vec3* res); void transform_get_right(struct Entity* transform, vec3* res);
void transform_update_transmat(struct Transform* transform); void transform_update_transmat(struct Entity* transform);
void transform_get_absolute_pos(struct Transform* transform, vec3* res); void transform_get_absolute_pos(struct Entity* transform, vec3* res);
void transform_get_absolute_rot(struct Transform* transform, quat* res); void transform_get_absolute_rot(struct Entity* transform, quat* res);
void transform_get_absolute_scale(struct Transform* transform, vec3* res); void transform_get_absolute_scale(struct Entity* transform, vec3* res);
void transform_get_absolute_lookat(struct Transform* transform, vec3* res); void transform_get_absolute_lookat(struct Entity* transform, vec3* res);
void transform_get_absolute_up(struct Transform* transform, vec3* res); void transform_get_absolute_up(struct Entity* transform, vec3* res);
void transform_get_absolute_right(struct Transform* transform, vec3* res); void transform_get_absolute_right(struct Entity* transform, vec3* res);
void transform_get_absolute_forward(struct Transform* transform, vec3* res); void transform_get_absolute_forward(struct Entity* transform, vec3* res);
#endif #endif

Write Preview
Loading…
Cancel
Save