rework input system. first proper interation

4 files changed, 200 insertions, 95 deletions

diff --git a/src/compile_flags.txt b/src/compile_flags.txt
index 2c81d8a..26d1cc4 100644
--- a/src/compile_flags.txt
+++ b/src/compile_flags.txt
@@ -9,3 +9,4 @@
 -Wextra
 -Wpedantic
 -Wconversion
+-std=c99
diff --git a/src/input/irodeo_input.h b/src/input/irodeo_input_t.h
index 6cd9992..77e150e 100644
--- a/src/input/irodeo_input.h
+++ b/src/input/irodeo_input_t.h
@@ -1,4 +1,5 @@
 
+
 // -- internal --
 // public
 #include "rodeo/input_t.h"
diff --git a/src/input/rodeo_input.c b/src/input/rodeo_input.c
index e8c736b..bbfbfcf 100644
--- a/src/input/rodeo_input.c
+++ b/src/input/rodeo_input.c
@@ -3,12 +3,13 @@
 // public
 #include "rodeo/input.h"
 #include "irodeo_input.h"
+#include "irodeo_input_t.h"
 #include "rodeo/log.h"
 
 // -- external --
 #include "SDL2/SDL.h"
 
-static irodeo_input_state_t state = {0};
+static irodeo_input_state_t istate = {0};
 
 bool
 rodeo_input_events_poll(void)
@@ -23,32 +24,39 @@ rodeo_input_events_poll(void)
 					return true;
 				}
 				break;
+			// - Binary -
 			case SDL_KEYUP:
 			case SDL_KEYDOWN:
 				{
-					c_foreach(i, cset_input_scene, state.active_scenes)
+					c_foreach(i, cset_input_scene, istate.active_scenes)
 					{
-						const cmap_input_scancode_scene_value *value = cmap_input_scancode_scene_get(
-								&((*i.ref)->scancode),
-								(rodeo_input_scancode_t)event.key.keysym.scancode
-						);
-						if(value == NULL)
+						rodeo_input_scene_t *scene = *i.ref;
+						c_foreach(j, cset_input_commands, scene->commands)
 						{
-							continue;
-						}
-						else
-						{
-							rodeo_input_any_state_t key_state = {
-								.binary_state = event.key.state,
-								.type = rodeo_input_type_Binary
-							};
-							c_foreach(
-								j,
-								cvec_input_callback_functions,
-								value->second
-							)
+							rodeo_input_command_t *command = *j.ref;
+							const cset_input_binary_scancodes_value *value = cset_input_binary_scancodes_get(
+									&command->binary.scancodes,
+									(rodeo_input_binary_scancode_t)event.key.keysym.scancode
+							);
+
+							if(value == NULL)
+							{
+								continue;
+							}
+							else
 							{
-								(**j.ref)(key_state);
+								rodeo_input_any_state_t key_state = {
+									.data.binary_state = event.key.state,
+									.input_type = rodeo_input_type_Binary
+								};
+								c_foreach(
+									k,
+									cset_input_callback_functions,
+									command->callbacks
+								)
+								{
+									(**k.ref)(key_state);
+								}
 							}
 						}
 					}
@@ -57,31 +65,36 @@ rodeo_input_events_poll(void)
 			case SDL_MOUSEBUTTONUP:
 			case SDL_MOUSEBUTTONDOWN:
 				{
-					//event.button.button // which sdl mouse button it was
-					//event.button.state // if thue button was clicked or released 
-					c_foreach(i, cset_input_scene, state.active_scenes)
+					c_foreach(i, cset_input_scene, istate.active_scenes)
 					{
-						const cmap_input_mouse_scene_value *value = cmap_input_mouse_scene_get(
-								&((*i.ref)->mouse),
-								(rodeo_input_mouse_t)event.button.button
-						);
-						if(value == NULL)
+						rodeo_input_scene_t *scene = *i.ref;
+						c_foreach(j, cset_input_commands, scene->commands)
 						{
-							continue;
-						}
-						else
-						{
-							rodeo_input_any_state_t key_state = {
-								.binary_state = event.button.state,
-								.type = rodeo_input_type_Binary
-							};
-							c_foreach(
-								j,
-								cvec_input_callback_functions,
-								value->second
-							)
+							rodeo_input_command_t *command = *j.ref;
+							const cset_input_binary_mouseButtons_value *value = cset_input_binary_mouseButtons_get(
+									&command->binary.mouse_buttons,
+									(rodeo_input_binary_mouseButton_t)event.button.button
+
+							);
+
+							if(value == NULL)
 							{
-								(**j.ref)(key_state);
+								continue;
+							}
+							else
+							{
+								rodeo_input_any_state_t input_state = {
+									.data.binary_state = event.button.state,
+									.input_type = rodeo_input_type_Binary
+								};
+								c_foreach(
+									k,
+									cset_input_callback_functions,
+									command->callbacks
+								)
+								{
+									(**k.ref)(input_state);
+								}
 							}
 						}
 					}
@@ -93,77 +106,166 @@ rodeo_input_events_poll(void)
 }
 
 void
-rodeo_input_scene_activate(
-	rodeo_input_scene_t *scene
+rodeo_input_command_register_callback(
+	rodeo_input_command_t *command,
+	rodeo_input_callback_function func
 )
 {
-	cset_input_scene_insert(&state.active_scenes, scene);
+	const cset_input_callback_functions_value *callback = cset_input_callback_functions_get(&(command->callbacks), func);
+	if(callback == NULL)
+	{
+		cset_input_callback_functions_insert(&(command->callbacks), func);
+		return;
+	}
+	else
+	{
+		rodeo_log(
+			rodeo_logLevel_warning,
+			"Input already registered"
+		);
+		return;
+	}
 }
 
 void
-rodeo_input_scene_deactivate(
-	rodeo_input_scene_t *scene
+rodeo_input_command_unregister_callback(
+	rodeo_input_command_t *command,
+	rodeo_input_callback_function func
 )
 {
-	cset_input_scene_erase(&state.active_scenes, scene);
+	cset_input_callback_functions_value *callback = 
+		cset_input_callback_functions_get_mut(&(command->callbacks), func);
+	if(callback != NULL)
+	{
+		cset_input_callback_functions_erase_entry(&(command->callbacks), callback);
+		return;
+	}
+	else
+	{
+		rodeo_log(
+			rodeo_logLevel_warning,
+			"Attempted to remove callback but it is not registered"
+		);
+		return;
+	}
+}
+
+rodeo_input_scene_t*
+rodeo_input_scene_create(void)
+{
+	rodeo_input_scene_t *result = malloc(sizeof(rodeo_input_scene_t));
+	*result = (rodeo_input_scene_t){0};
+	return result;
 }
 
 void
-rodeo_input_scene_register_callback(
-	rodeo_input_callback_function func,
-	rodeo_input_scene_t *scene,
-	rodeo_input_register_type_t type
+rodeo_input_scene_destroy(rodeo_input_scene_t *scene)
+{
+	rodeo_input_scene_deactivate(scene);
+	cset_input_commands_drop(&scene->commands);
+	free(scene);
+}
+
+rodeo_input_command_t*
+rodeo_input_command_create(uint32_t input_type)
+{
+	rodeo_input_command_t *result = malloc(sizeof(rodeo_input_command_t));
+	*result = (rodeo_input_command_t)
+	{
+		.valid_types = input_type
+	};
+	return result;
+}
+
+void
+rodeo_input_command_destroy(rodeo_input_command_t *command)
+{
+	cset_input_binary_scancodes_drop(&command->binary.scancodes);
+	cset_input_binary_mouseButtons_drop(&command->binary.mouse_buttons);
+	cset_input_callback_functions_drop(&command->callbacks);
+	free(command);
+}
+
+bool
+rodeo_input_command_register_binary_scancode(
+	rodeo_input_command_t *input_command,
+	rodeo_input_binary_scancode_t scancode
 )
 {
-	switch (type.type)
+	if((rodeo_input_type_Binary & input_command->valid_types) == 0)
 	{
-		case rodeo_input_type_Binary:
-			switch (type.binary_type) {
-				case rodeo_input_binary_Scancode:
-					{
-						if(!cmap_input_scancode_scene_contains(&scene->scancode, type.scancode))
-						{
-							cmap_input_scancode_scene_insert(&scene->scancode, type.scancode, cvec_input_callback_functions_init());
-						}
-						cvec_input_callback_functions* callbacks = cmap_input_scancode_scene_at_mut(&scene->scancode, type.scancode);
-						cvec_input_callback_functions_push(callbacks, func);
-					}
-					break;
+		rodeo_log(
+			rodeo_logLevel_error,
+			"Attempting to register input type which is invalid for this input command, failed to do so"
+		);
+		return false;
+	}
+	else
+	{
+		cset_input_binary_scancodes_insert(
+			&input_command->binary.scancodes,
+			scancode
+		);
+		return true;
+	}
+}
 
-				case rodeo_input_binary_Mouse:
-					{
-						if(!cmap_input_mouse_scene_contains(&scene->mouse, type.mouse))
-						{
-							cmap_input_mouse_scene_insert(&scene->mouse, type.mouse, cvec_input_callback_functions_init());
-						}
-						cvec_input_callback_functions* callbacks = cmap_input_mouse_scene_at_mut(&scene->mouse, type.mouse);
-						cvec_input_callback_functions_push(callbacks, func);
-					}
-					break;
-
-				case rodeo_input_binary_Invalid:
-					rodeo_log(
-						rodeo_logLevel_error,
-						"Failed to register invalid binary input type"
-					);
-					break;
-			}
-			break;
-		case rodeo_input_type_Invalid:
-			rodeo_log(
-				rodeo_logLevel_error,
-				"Failed to register invalid input type"
-			);
-			break;
+bool
+rodeo_input_command_register_binary_mouseButton(
+	rodeo_input_command_t *input_command,
+	rodeo_input_binary_mouseButton_t mouse_button
+)
+{
+	if((rodeo_input_type_Binary & input_command->valid_types) == 0)
+	{
+		rodeo_log(
+			rodeo_logLevel_error,
+			"Attempting to register input type which is invalid for this input command, failed to do so"
+		);
+		return false;
+	}
+	else
+	{
+		cset_input_binary_mouseButtons_insert(
+			&input_command->binary.mouse_buttons,
+			mouse_button
+		);
+		return true;
 	}
 }
 
 void
-rodeo_input_scene_unregister_callback(
-	rodeo_input_callback_function func,
+rodeo_input_scene_register_command(
+	rodeo_input_scene_t *scene,
+	rodeo_input_command_t *command
+)
+{
+	cset_input_commands_insert(
+			&scene->commands,
+			command
+	);
+}
+
+void
+rodeo_input_scene_unregister_command(
 	rodeo_input_scene_t *scene,
-	rodeo_input_register_type_t type
+	rodeo_input_command_t *command
 )
 {
+	cset_input_commands_erase(
+			&scene->commands,
+			command
+	);
+}
+
+void
+rodeo_input_scene_activate(rodeo_input_scene_t *scene)
+{
+	cset_input_scene_insert(&istate.active_scenes, scene);
+}
 
+void
+rodeo_input_scene_deactivate(rodeo_input_scene_t *scene)
+{
+	cset_input_scene_erase(&istate.active_scenes, scene);
 }
diff --git a/src/rodeo.c b/src/rodeo.c
index dcac005..91ce4f8 100644
--- a/src/rodeo.c
+++ b/src/rodeo.c
@@ -306,6 +306,8 @@ rodeo_frame_begin(void)
 
 	irodeo_render_buffer_transient_alloc();
 
+	state.quit = rodeo_input_events_poll();
+
 	state.start_frame = state.end_frame;
 }
 
@@ -316,7 +318,6 @@ rodeo_frame_end(void)
 
 	bgfx_frame(false);
 
-	state.quit = rodeo_input_events_poll();
 	#ifndef __EMSCRIPTEN__
 		irodeo_frame_stall();
 	#endif