Removed several warnings

.dir-locals.el

@@ -2,8 +2,8 @@
  ((string-equal system-type "windows-nt") ; Microsoft Windows
   (progn
 	((c-mode .
-			 ((company-clang-arguments . ("-IE:/Projects/symmerty/include" "-IE:\\Projects\\symmerty\\third_party\\windows\\SDL2-2.0.5\\include"))
+			 ((company-clang-arguments . ("-IW:/include"))
-			  (flycheck-clang-include-path  . ("E:/Projects/symmerty/include")))
+			  (flycheck-clang-include-path  . ("W:/include")))
 			 ) 
 	 ((c++-mode . ((mode . c))))
 	 )

README.md

@@ -163,6 +163,7 @@
 	- Console fix bug when enabled in editor mode
 	- Console command history
 	- Console command help
+	- Space partitioning and scene handling
 	- NPR and cross-hatching
 	- Move Gui_State and Editor_State into game_state and modify usage as needed
 	- Remove model and replace all usages with static mesh

src/common/hashmap.c

@@ -97,7 +97,7 @@ struct Variant* hashmap_value_get(const struct Hashmap* hashmap, const char* key
     if(!hashmap || !key) return NULL;
     struct Variant* value = NULL;
     unsigned int index    = hashmap_generate_hash(key);
-	int key_len           = strlen(key);
+    int key_len           = (int)strlen(key);
     int compare_len       = key_len < HASH_MAX_KEY_LEN ? key_len : HASH_MAX_KEY_LEN;
     for(int i = 0; i < array_len(hashmap->buckets[index]); i++)
     {

src/common/linmath.c

@@ -401,13 +401,13 @@ void mat4_perspective(mat4* res, float fov, float aspect, float nearz, float far
 {
     float r         = TO_RADIANS(fov / 2);
     float deltaz    = farz - nearz;
-	float s = sin(r);
+    float s         = (float)sin(r);
     float cotangent = 0;
 
     if (deltaz == 0 || s == 0 || aspect == 0)
 	return;
 
-	cotangent = cos(r) / s;
+    cotangent = (float)cos(r) / s;
     mat4_identity(res);
     res->mat[0] = cotangent / aspect;
     res->mat[5] = cotangent;
@@ -445,17 +445,17 @@ void mat4_scale(mat4* res, float x, float y, float z)
 
 void mat4_from_quat(mat4* res, const quat* q)
 {
-	double xx = q->x * q->x;
+    float xx = q->x * q->x;
-    double xy = q->x * q->y;
+    float xy = q->x * q->y;
-    double xz = q->x * q->z;
+    float xz = q->x * q->z;
-    double xw = q->x * q->w;
+    float xw = q->x * q->w;
 
-    double yy = q->y * q->y;
+    float yy = q->y * q->y;
-    double yz = q->y * q->z;
+    float yz = q->y * q->z;
-    double yw = q->y * q->w;
+    float yw = q->y * q->w;
 
-    double zz = q->z * q->z;
+    float zz = q->z * q->z;
-    double zw = q->z * q->w;
+    float zw = q->z * q->w;
 
     res->mat[0] = 1 - 2 * (yy + zz);
     res->mat[1] = 2 * (xy + zw);
@@ -679,7 +679,7 @@ void mat4_inverse(mat4* res, mat4* mat)
 	return;
     }
 
-	det = 1.0 / det;
+    det = 1.f / det;
 
     for (i = 0; i < 16; i++) {
 	res->mat[i] = tmp.mat[i] * det;
@@ -749,7 +749,7 @@ float quat_len_sq(const quat* q)
 
 float quat_len(const quat* q)
 {
-	return sqrt(quat_len_sq(q));
+    return (float)sqrt(quat_len_sq(q));
 }
 
 void quat_norm(quat* res, const quat* val)
@@ -798,13 +798,13 @@ void quat_get_right(vec3* res, const quat* q)
 
 float quat_get_pitch(const quat* q)
 {
-    float result = atan2(2 * (q->y * q->z + q->w * q->x), q->w * q->w - q->x * q->x - q->y * q->y + q->z * q->z);
+    float result = (float)atan2(2 * (q->y * q->z + q->w * q->x), q->w * q->w - q->x * q->x - q->y * q->y + q->z * q->z);
     return result;
 }
 
 float quat_get_yaw(const quat* q)
 {
-    float result = asin(-2 * (q->x * q->z - q->w * q->y));
+    float result = (float)asin(-2 * (q->x * q->z - q->w * q->y));
     return result;
 }
 
@@ -813,3 +813,14 @@ float quat_get_roll(const quat* q)
     float result = atan2(2 * (q->x * q->y + q->w * q->z), q->w * q->w + q->x * q->x - q->y * q->y - q->z * q->z);
     return result;
 }
+
+void quat_mul_mat4(quat* res, quat* val, mat4* mat)
+{
+    vec4 v;
+    vec4_fill(&v, val->x, val->y, val->z, val->w);
+    vec4_mul_mat4(&v, &v, mat);
+    res->x = v.x;
+    res->y = v.y;
+    res->z = v.z;
+    res->w = v.w;
+}

src/common/linmath.h

@@ -11,7 +11,7 @@ i'll make my own additions like SIMD etc later on.
 
 /* conversions */
 #ifndef M_PI
-    #define M_PI		        3.14159265358979323846
+    #define M_PI		        3.14159265358979323846f
 #endif
 #define EPSILON             0.0001
 #define TO_RADIANS(degrees) ((degrees * M_PI) / 180.0)
@@ -132,5 +132,6 @@ void  quat_mul_vec3(vec3* res, const quat* q, const vec3* v);
 void  quat_assign(quat* res, const quat* val);
 void  quat_identity(quat* res);
 void  quat_fill(quat* res, float x, float y, float z, float w);
+void  quat_mul_mat4(quat* res, quat* val, mat4* mat);
 
 #endif

src/common/parser.c

@@ -115,7 +115,7 @@ struct Parser* parser_load_objects(FILE* file, const char* filename)
 	}
 
 	// Check if type string is valid
-		int type_str_len = strnlen(type_str, HASH_MAX_KEY_LEN);
+	size_t type_str_len = strnlen(type_str, HASH_MAX_KEY_LEN);
 	if(type_str_len < 3 || strncmp(type_str, "{", HASH_MAX_KEY_LEN) == 0 || strncmp(type_str, "}", HASH_MAX_KEY_LEN) == 0)
 	{
 	    log_warning("Invalid object type '%s' on line %d", type_str, current_line);
@@ -129,8 +129,8 @@ struct Parser* parser_load_objects(FILE* file, const char* filename)
 		
 	/* Opening brace and closing brace */
 	char c = ' ';
-		int line_len = strnlen(line_buffer, MAX_LINE_LEN);
+	size_t line_len = strnlen(line_buffer, MAX_LINE_LEN);
-		int seek_amount = line_len - type_str_len;
+	size_t seek_amount = line_len - type_str_len;
 	fseek(file, -seek_amount, SEEK_CUR);
 	while(!feof(file))
 	{

src/common/string_utils.c

@@ -75,7 +75,7 @@ char* str_replace(char* string, const char* pattern, const char* replacement)
 	char* location = strstr(remaining_string, pattern);
 	if(location)
 	{
-			int index = location - string;
+	    int index = (int)(location - string);
 	    array_push(indices, index, int);
 	    remaining_string = location + pattern_len; /* Find the next occurance in the remaining string */
 	}
@@ -97,7 +97,7 @@ char* str_replace(char* string, const char* pattern, const char* replacement)
 	    done = 0;
 	    int count = 0;
 	    int index = indices[count];
-			unsigned int prev_index = 0;
+	    int prev_index = 0;
 	    while(!done)
 	    {
 		char* source_beg = string + prev_index;

src/game/config_vars.c

@@ -22,7 +22,7 @@ void config_vars_init(void)
     hashmap_int_set(cvars,   "render_height",                768);
     hashmap_int_set(cvars,   "fog_mode",                     0);
     hashmap_vec3_setf(cvars, "fog_color",                    0.9f, 0.2f, 0.2f);
-	hashmap_float_set(cvars, "fog_density",                  0.1);
+    hashmap_float_set(cvars, "fog_density",                  0.1f);
     hashmap_float_set(cvars, "fog_start_dist",               10.f);
     hashmap_float_set(cvars, "fog_max_dist",                 50.f);
     hashmap_vec3_setf(cvars, "ambient_light",                0.1f, 0.1f, 0.1f);
@@ -78,7 +78,6 @@ bool config_vars_load(const char* filename, int directory_type)
 	config_loaded = true;
 	char* key = NULL;
 	struct Variant* value = NULL;
-		char variant_str[MAX_VARIANT_STR_LEN];
 	HASHMAP_FOREACH(object->data, key, value)
 	{
 	    struct Variant* existing_val = hashmap_value_get(cvars, key);

src/game/physics.c

@@ -62,7 +62,7 @@ void physics_cleanup(void)
 
 void physics_step(float delta_time)
 {
-	int steps = (int)ceilf(delta_time / Physics.step_size);
+    int steps = (int)ceilf(delta_time / (float)Physics.step_size);
     for(int i = 0; i < steps; i++)
     {
 	dSpaceCollide(Physics.space, NULL, physics_near_callback);
@@ -81,18 +81,18 @@ void physics_gravity_get(float * x, float * y, float * z)
     assert(x && y && z);
     dVector3 gravity;
     dWorldGetGravity(Physics.world, gravity);
-	*x = gravity[0];
+    *x = (float)gravity[0];
-	*y = gravity[1];
+    *y = (float)gravity[1];
-	*z = gravity[2];
+    *z = (float)gravity[2];
 }
 
 void physics_body_position_get(Rigidbody body, float * x, float * y, float * z)
 {
     assert(x && y && z);
     const dReal* position = dBodyGetPosition(body);
-	*x = position[0];
+    *x = (float)position[0];
-	*y = position[1];
+    *y = (float)position[1];
-	*z = position[2];
+    *z = (float)position[2];
 }
 
 void physics_body_position_set(Rigidbody body, float x, float y, float z)
@@ -105,10 +105,10 @@ void physics_body_rotation_get(Rigidbody body, float * x, float * y, float * z,
 {
     assert(x && y && z && w);
     const dReal* rotation = dBodyGetQuaternion(body);
-	*x = rotation[1];
+    *x = (float)rotation[1];
-	*y = rotation[2];
+    *y = (float)rotation[2];
-	*z = rotation[3];
+    *z = (float)rotation[3];
-	*w = rotation[0];
+    *w = (float)rotation[0];
 }
 
 void physics_body_rotation_set(Rigidbody body, float x, float y, float z, float w)

src/game/platform.c

@@ -426,7 +426,7 @@ int platform_key_from_name(const char* key_name)
     int start = 0;
     while(isspace(key_name[start]) != 0) start++;
 	
-	int end = strlen(key_name) - 1;
+    size_t end = strlen(key_name) - 1;
     while(isspace(key_name[end]) != 0) end--;
 
     strncpy(trimmed_key_name, &key_name[start], (end - start) + 1);

src/libsymmetry/camera.c

@@ -75,7 +75,7 @@ void camera_update_view(struct Camera* camera)
     transform_get_absolute_up(&camera->base, &up);
     transform_get_absolute_position(&camera->base, &position);
     mat4_lookat(&camera->view_mat, &position, &lookat, &up);
-	camera_update_view_proj(&camera->base);
+    camera_update_view_proj(camera);
 }
 
 void camera_update_proj(struct Camera* camera)
@@ -223,14 +223,14 @@ struct Ray camera_screen_coord_to_ray(struct Camera* camera, int mouse_x, int mo
 
     //Project the near point
     quat rot_near = {normalized_x, normalized_y, 0.f, 1.f};
-	vec4_mul_mat4(&rot_near, &rot_near, &inverse_view_proj_mat);
+    quat_mul_mat4(&rot_near, &rot_near, &inverse_view_proj_mat);
     near_point.x = rot_near.x / rot_near.w;
     near_point.y = rot_near.y / rot_near.w;
     near_point.z = rot_near.z / rot_near.w;
 
     //Project far point
     quat rot_far = {normalized_x, normalized_y, 1.f, 1.f};
-	vec4_mul_mat4(&rot_far, &rot_far, &inverse_view_proj_mat);
+    quat_mul_mat4(&rot_far, &rot_far, &inverse_view_proj_mat);
     far_point.x = rot_far.x / rot_far.w;
     far_point.y = rot_far.y / rot_far.w;
     far_point.z = rot_far.z / rot_far.w;

src/libsymmetry/console.c

@@ -38,8 +38,8 @@ void console_init(struct Console* console)
 
 void console_toggle(struct Console* console)
 {
-	if(!console->visible) console->scroll_to_bottom = true;
     console->visible = !console->visible;
+    if(console->visible) console->scroll_to_bottom = true;
 }
 
 void console_update(struct Console* console, struct Gui_State* gui_state, float dt)
@@ -66,7 +66,7 @@ void console_update(struct Console* console, struct Gui_State* gui_state, float
 
 	    if(console->scroll_to_bottom == true) // scroll console message area to the bottom if required
 	    {
-				*context->current->layout->offset_y = context->current->layout->at_y;
+		*context->current->layout->offset_y = (nk_uint)context->current->layout->at_y;
 		console->scroll_to_bottom = false;
 	    }
 			

src/libsymmetry/editor.c

@@ -7,6 +7,7 @@
 #include "texture.h"
 #include "framebuffer.h"
 #include "../common/array.h"
+#include "../common/hashmap.h"
 #include "shader.h"
 #include "../common/num_types.h"
 #include "light.h"
@@ -90,7 +91,6 @@ void editor_init_camera(void)
     editor_camera->clear_color.z = 0.9f;
     editor_camera->clear_color.w = 1.f;
 
-
     struct Hashmap* config = platform->config.get();
     int render_width  = hashmap_int_get(config, "render_width");
     int render_height = hashmap_int_get(config, "render_height");
@@ -200,7 +200,7 @@ void editor_update(float dt)
     {
 	context->style.window.fixed_background = default_background;
 	/* Top Panel */
-		nk_layout_row_dynamic(context, editor_state.top_panel_height + 10, 1);
+	nk_layout_row_dynamic(context, editor_state.top_panel_height + 10.f, 1);
 	nk_group_begin(context, "Menubar", NK_WINDOW_NO_SCROLLBAR);
 	{
 	    static float top_panel_ratios[] = {0.1f, 0.1f, 0.7f, 0.1f};
@@ -472,22 +472,21 @@ void editor_update(float dt)
 	const int row_height = 25;
 	if(nk_begin_titled(context, "Renderer_Settings_Window", "Renderer Settings", nk_rect(half_width, half_height, 300, 350), window_flags))
 	{
-			static struct Render_Settings render_settings;
+	    struct Render_Settings* render_settings = &game_state->renderer->settings;
-			renderer_settings_get(&render_settings);
 	    if(nk_tree_push(context, NK_TREE_TAB, "Debug", NK_MAXIMIZED))
 	    {
 		static const char* draw_modes[] = {"Triangles", "Lines", "Points"};
 		nk_layout_row_dynamic(context, row_height, 2);
 		nk_label(context, "Debug Draw", NK_TEXT_ALIGN_LEFT | NK_TEXT_ALIGN_MIDDLE);
-				nk_checkbox_label(context, "", &render_settings.debug_draw_enabled);
+		nk_checkbox_label(context, "", &render_settings->debug_draw_enabled);
 				
 		nk_layout_row_dynamic(context, row_height, 2);
 		nk_label(context, "Debug Draw Mode", NK_TEXT_ALIGN_LEFT | NK_TEXT_ALIGN_MIDDLE);
-				render_settings.debug_draw_mode = nk_combo(context, draw_modes, 3, render_settings.debug_draw_mode, 20, nk_vec2(180, 100));
+		render_settings->debug_draw_mode = nk_combo(context, draw_modes, 3, render_settings->debug_draw_mode, 20, nk_vec2(180, 100));
 				
 		nk_layout_row_dynamic(context, row_height, 2);
 		nk_label(context, "Debug Color", NK_TEXT_ALIGN_LEFT | NK_TEXT_ALIGN_MIDDLE);
-				editor_widget_color_combov4(context, &render_settings.debug_draw_color, 200, 400);
+		editor_widget_color_combov4(context, &render_settings->debug_draw_color, 200, 400);
 		nk_tree_pop(context);
 	    }
 
@@ -496,27 +495,27 @@ void editor_update(float dt)
 		static const char* fog_modes[] = {"None", "Linear", "Exponential", "Exponential Squared"};
 		nk_layout_row_dynamic(context, row_height, 2);
 		nk_label(context, "Color", NK_TEXT_ALIGN_LEFT | NK_TEXT_ALIGN_MIDDLE);
-				editor_widget_color_combov3(context, &render_settings.fog.color, 200, 400);
+		editor_widget_color_combov3(context, &render_settings->fog.color, 200, 400);
 				
 		nk_layout_row_dynamic(context, row_height, 2);
 		nk_label(context, "Fog Mode", NK_TEXT_ALIGN_LEFT | NK_TEXT_ALIGN_MIDDLE);
-				render_settings.fog.mode = nk_combo(context,
+		render_settings->fog.mode = nk_combo(context,
 						     fog_modes,
 						     4,
-													render_settings.fog.mode,
+						     render_settings->fog.mode,
 						     20,
 						     nk_vec2(180, 100));
 
 		nk_layout_row_dynamic(context, row_height, 2);
 		nk_label(context, "Density", NK_TEXT_ALIGN_LEFT | NK_TEXT_ALIGN_MIDDLE);
 		struct nk_rect bounds = nk_widget_bounds(context);
-				nk_slider_float(context, 0.f, &render_settings.fog.density, 1.f, 0.005);
+		nk_slider_float(context, 0.f, &render_settings->fog.density, 1.f, 0.005);
 		if(nk_input_is_mouse_hovering_rect(&context->input, bounds))
 		{
 		    if(nk_tooltip_begin(context, 100))
 		    {
 			nk_layout_row_dynamic(context, row_height, 1);
-						nk_labelf(context, NK_TEXT_ALIGN_CENTERED, "%.3f", render_settings.fog.density);
+			nk_labelf(context, NK_TEXT_ALIGN_CENTERED, "%.3f", render_settings->fog.density);
 			nk_tooltip_end(context);
 		    }
 		}
@@ -525,21 +524,20 @@ void editor_update(float dt)
 		nk_property_float(context,
 				  "Start Distance",
 				  0.f,
-								  &render_settings.fog.start_dist,
+				  &render_settings->fog.start_dist,
-								  render_settings.fog.max_dist,
+				  render_settings->fog.max_dist,
 				  5.f, 10.f);
 
 		nk_layout_row_dynamic(context, row_height, 1);
 		nk_property_float(context,
 				  "Max Distance",
-								  render_settings.fog.start_dist,
+				  render_settings->fog.start_dist,
-								  &render_settings.fog.max_dist,
+				  &render_settings->fog.max_dist,
 				  10000.f,
 				  5.f, 10.f);
 
 		nk_tree_pop(context);
 	    }
-			renderer_settings_set(&render_settings);
 	}
 	else
 	{
@@ -592,6 +590,7 @@ void editor_camera_update(float dt)
 	//If we're not looking around then allow picking
 	if(input_mousebutton_state_get(MSB_LEFT, KS_RELEASED))
 	{
+	    log_message("editor picking");
 	    int mouse_x = 0, mouse_y = 0;
 	    platform->mouse_position_get(&mouse_x, &mouse_y);
 	    struct Ray ray = camera_screen_coord_to_ray(editor_camera, mouse_x, mouse_y);

src/libsymmetry/game.c

@@ -298,7 +298,7 @@ void game_scene_setup(void)
     for(int i = 0; i < num_suz; i++)
     {
 	memset(&suz_name, '\0', MAX_ENTITY_NAME_LEN);
-		snprintf(&suz_name, MAX_ENTITY_NAME_LEN, "Suzanne_%d", i);
+	snprintf(&suz_name[0], MAX_ENTITY_NAME_LEN, "Suzanne_%d", i);
 	struct Static_Mesh* suzanne = scene_static_mesh_create(game_state->scene, suz_name, NULL, "sphere.symbres", MAT_BLINN);
 	suzanne->model.material_params[MMP_DIFFUSE_TEX].val_int = texture_create_from_file("white.tga", TU_DIFFUSE);
 	suzanne->model.material_params[MMP_DIFFUSE].val_float = 0.5f;
@@ -317,7 +317,7 @@ void game_scene_setup(void)
     light->color.x = 1.f;
     light->color.y = 1.f;
     light->color.z = 1.f;
-	light->radius = 20.f;
+    light->radius  = 20;
     vec3 light_pos = {0.f, 5.f, 0.f};
     transform_translate(light, &light_pos, TS_WORLD);
 }

src/libsymmetry/player.c

@@ -6,6 +6,8 @@
 #include "../common/common.h"
 #include "camera.h"
 #include "bounding_volumes.h"
+#include "../common/hashmap.h"
+#include "../common/log.h"
 
 void player_init(struct Player* player, struct Scene* scene)
 {

src/libsymmetry/renderer.c

@@ -258,7 +258,7 @@ void renderer_draw(struct Renderer* renderer, struct Scene* scene)
 		    vec3 abs_pos, abs_scale;
 		    transform_get_absolute_position(&mesh->base, &abs_pos);
 		    transform_get_absolute_scale(&mesh->base, &abs_scale);
-					int intersection = bv_intersect_frustum_sphere(&camera->frustum, &geometry->bounding_sphere, &abs_pos, &abs_scale);
+		    int intersection = bv_intersect_frustum_sphere(&camera->frustum[0], &geometry->bounding_sphere, &abs_pos, &abs_scale);
 		    if(intersection == IT_OUTSIDE)
 		    {
 			renderer->num_culled++;
@@ -435,7 +435,7 @@ void renderer_cleanup(struct Renderer* renderer)
 {
     for(int i = 0; i < MAT_MAX; i++)
     {
-		material_reset(&renderer->materials[i], i);
+	material_reset(&renderer->materials[i]);
     }
     im_cleanup();
     sprite_batch_remove(renderer->sprite_batch);
@@ -470,38 +470,37 @@ struct Material * renderer_material_get(int material_type)
     return NULL;
 }
 
-void renderer_debug_draw_enabled(bool enabled)
+void renderer_debug_draw_enabled(struct Renderer* renderer, bool enabled)
-{
+{
-    struct Hashmap* cvars = platform->config.get();
+    renderer->settings.debug_draw_mode = enabled;
-	hashmap_bool_set(cvars,  "debug_draw_enabled", enabled);
+}
-}
+
-
+/* void renderer_settings_get(struct Render_Settings* settings) */
-void renderer_settings_get(struct Render_Settings* settings)
+/* { */
-{
+/*     struct Hashmap* cvars = platform->config.get(); */
-    struct Hashmap* cvars = platform->config.get();
+/*     settings->fog.mode               = hashmap_int_get(cvars,   "fog_mode"); */
-	settings->fog.mode               = hashmap_int_get(cvars,   "fog_mode");
+/*     settings->fog.density            = hashmap_float_get(cvars, "fog_density"); */
-	settings->fog.density            = hashmap_float_get(cvars, "fog_density");
+/*     settings->fog.start_dist         = hashmap_float_get(cvars, "fog_start_dist"); */
-	settings->fog.start_dist         = hashmap_float_get(cvars, "fog_start_dist");
+/*     settings->fog.max_dist           = hashmap_float_get(cvars, "fog_max_dist"); */
-	settings->fog.max_dist           = hashmap_float_get(cvars, "fog_max_dist");
+/*     settings->fog.color              = hashmap_vec3_get(cvars,  "fog_color"); */
-	settings->fog.color              = hashmap_vec3_get(cvars,  "fog_color");
+/*     settings->debug_draw_enabled     = hashmap_bool_get(cvars,  "debug_draw_enabled"); */
-	settings->debug_draw_enabled     = hashmap_bool_get(cvars,  "debug_draw_enabled");
+/*     settings->debug_draw_physics     = hashmap_bool_get(cvars,  "debug_draw_physics"); */
-	settings->debug_draw_physics     = hashmap_bool_get(cvars,  "debug_draw_physics");
+/*     settings->debug_draw_mode        = hashmap_int_get(cvars,   "debug_draw_mode"); */
-	settings->debug_draw_mode        = hashmap_int_get(cvars,   "debug_draw_mode");
+/*     settings->debug_draw_color       = hashmap_vec4_get(cvars,  "debug_draw_color"); */
-	settings->debug_draw_color       = hashmap_vec4_get(cvars,  "debug_draw_color");
+/*     settings->ambient_light          = hashmap_vec3_get(cvars,  "ambient_light"); */
-	settings->ambient_light          = hashmap_vec3_get(cvars,  "ambient_light");
+/* } */
-}
+
-
+/* void renderer_settings_set(const struct Render_Settings* settings) */
-void renderer_settings_set(const struct Render_Settings* settings)
+/* { */
-{
+/*     struct Hashmap* cvars = platform->config.get(); */
-    struct Hashmap* cvars = platform->config.get();
+/*     hashmap_int_set(cvars,   "fog_mode",           settings->fog.mode); */
-	hashmap_int_set(cvars,   "fog_mode",           settings->fog.mode);
+/*     hashmap_float_set(cvars, "fog_density",        settings->fog.density); */
-	hashmap_float_set(cvars, "fog_density",        settings->fog.density);
+/*     hashmap_float_set(cvars, "fog_start_dist",     settings->fog.start_dist); */
-	hashmap_float_set(cvars, "fog_start_dist",     settings->fog.start_dist);
+/*     hashmap_float_set(cvars, "fog_max_dist",       settings->fog.max_dist); */
-	hashmap_float_set(cvars, "fog_max_dist",       settings->fog.max_dist);
+/*     hashmap_vec3_set(cvars,  "fog_color",          &settings->fog.color); */
-	hashmap_vec3_set(cvars,  "fog_color",          &settings->fog.color);
+/*     hashmap_bool_set(cvars,  "debug_draw_enabled", settings->debug_draw_enabled); */
-	hashmap_bool_set(cvars,  "debug_draw_enabled", settings->debug_draw_enabled);
+/*     hashmap_bool_set(cvars,  "debug_draw_physics", settings->debug_draw_physics); */
-	hashmap_bool_set(cvars,  "debug_draw_physics", settings->debug_draw_physics);
+/*     hashmap_int_set(cvars,   "debug_draw_mode",    settings->debug_draw_mode); */
-	hashmap_int_set(cvars,   "debug_draw_mode",    settings->debug_draw_mode);
+/*     hashmap_vec4_set(cvars,  "debug_draw_color",   &settings->debug_draw_color); */
-	hashmap_vec4_set(cvars,  "debug_draw_color",   &settings->debug_draw_color);
+/*     hashmap_vec3_set(cvars,  "ambient_light",      &settings->ambient_light); */
-	hashmap_vec3_set(cvars,  "ambient_light",      &settings->ambient_light);
+/* } */
-}

src/libsymmetry/scene.c

@@ -12,6 +12,7 @@
 #include "game.h"
 #include "bounding_volumes.h"
 #include "geometry.h"
+#include "editor.h"
 
 #include <assert.h>
 #include <string.h>
@@ -56,8 +57,15 @@ void scene_init(struct Scene* scene)
     scene->active_camera_index = game_state_get()->game_mode == GAME_MODE_GAME ? CAM_GAME : CAM_EDITOR;
 }
 
-bool scene_load(struct Scene* scene, const char* filename, int dir_type);
+bool scene_load(struct Scene* scene, const char* filename, int dir_type)
-bool scene_save(struct Scene* scene, const char* filename, int dir_type);
+{
+    return false;
+}
+
+bool scene_save(struct Scene* scene, const char* filename, int dir_type)
+{
+    return false;
+}
 
 void scene_destroy(struct Scene* scene)
 {
@@ -282,7 +290,7 @@ struct Camera* scene_camera_create(struct Scene* scene, const char* name, struct
     return new_camera;
 }
 
-struct Static_Model* scene_static_mesh_create(struct Scene* scene, const char* name, struct Entity* parent, const char* geometry_name, int material_type)
+struct Static_Mesh* scene_static_mesh_create(struct Scene* scene, const char* name, struct Entity* parent, const char* geometry_name, int material_type)
 {
     assert(scene);
     struct Static_Mesh* new_static_mesh = NULL;
@@ -598,7 +606,7 @@ void scene_ray_intersect(struct Scene* scene, struct Ray* ray, struct Raycast_Re
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool scene_load(const char* filename, int directory_type)
+bool scene_load_(const char* filename, int directory_type)
 {
     //   FILE* entity_file = platform->file.open(directory_type, filename, "r");
     //if(!entity_file)
@@ -635,7 +643,7 @@ bool scene_load(const char* filename, int directory_type)
     return entity_load(filename, directory_type);
 }
 
-bool scene_save(const char* filename, int directory_type)
+bool scene_save_(const char* filename, int directory_type)
 {
     bool success = false;
     /*FILE* scene_file = platform->file.open(directory_type, filename, "w");

src/libsymmetry/scene.h

@@ -36,7 +36,7 @@ void scene_post_update(struct Scene* scene);
 struct Entity*       scene_entity_create(struct Scene* scene, const char* name, struct Entity* parent);
 struct Light*        scene_light_create(struct Scene* scene, const char* name, struct Entity* parent, int light_type);
 struct Camera*       scene_camera_create(struct Scene* scene, const char* name, struct Entity* parent, int width, int height);
-struct Static_Model* scene_static_mesh_create(struct Scene* scene, const char* name, struct Entity* parent, const char* geometry_name, int material_type);
+struct Static_Mesh*  scene_static_mesh_create(struct Scene* scene, const char* name, struct Entity* parent, const char* geometry_name, int material_type);
 struct Sound_Source* scene_sound_source_create(struct Scene* scene, const char* name, struct Entity* parent, const char* filename, int type, bool loop, bool play);
 
 void scene_entity_remove(struct Scene* scene, struct Entity* entity);