diff --git a/assets/scenes/scene_1.symtres b/assets/scenes/scene_1.symtres index 0b231b7..240bef0 100755 --- a/assets/scenes/scene_1.symtres +++ b/assets/scenes/scene_1.symtres @@ -10,16 +10,18 @@ Scene_Config debug_draw_enabled : false debug_draw_mode : 0 ambient_light : 0.100 0.100 0.100 + init_func: scene_1 + cleanup_func: scene_1 } Player { type : 2 scale : 1.000 1.000 1.000 - rotation : 0.000 -1.001 0.000 -0.000 + rotation : 0.000 -0.612 0.000 0.792 active : true player_key_mask : 0 - position : -18.634 2.167 -45.517 + position : -33.501 2.167 -45.463 player_health : 100 name : Player bounding_box_min : -1.500 -1.500 -1.000 @@ -101,9 +103,9 @@ Scene_Entity_Entry Scene_Entity_Entry { - scale : 135.000 5.000 1.000 + scale : 135.000 11.000 1.000 rotation : 0.000 0.000 0.000 1.000 - position : -17.000 3.000 -87.000 + position : -17.000 6.000 -87.000 filename : cube_uv name : Cube } @@ -117,6 +119,15 @@ Scene_Entity_Entry name : Cube } +Scene_Entity_Entry +{ + scale : 51.000 11.000 1.000 + rotation : 0.000 -0.707 0.000 0.707 + position : 18.000 6.000 -55.000 + filename : cube_uv + name : Cube +} + Scene_Entity_Entry { scale : 1.000 1.000 1.000 @@ -162,6 +173,15 @@ Scene_Entity_Entry name : Turret } +Scene_Entity_Entry +{ + scale : 30.500 11.000 55.000 + rotation : 0.000 0.000 0.000 1.000 + position : 34.000 6.000 -59.000 + filename : trigger + name : Scene_End_Trigger +} + Scene_Entity_Entry { scale : 1.000 1.000 1.000 @@ -171,3 +191,12 @@ Scene_Entity_Entry name : Door } +Scene_Entity_Entry +{ + scale : 1.000 1.000 1.000 + rotation : 0.000 0.707 0.000 0.707 + position : 18.000 1.000 -84.000 + filename : door + name : Door +} + diff --git a/src/common/version.h b/src/common/version.h index 56426bf..5c3f8a8 100755 --- a/src/common/version.h +++ b/src/common/version.h @@ -4,7 +4,7 @@ /* Auto generated version file. DO NOT MODIFY */ #define SYMMETRY_VERSION_MAJOR 0 #define SYMMETRY_VERSION_MINOR 1 -#define SYMMETRY_VERSION_REVISION 349 +#define SYMMETRY_VERSION_REVISION 350 #define SYMMETRY_VERSION_BRANCH "dev" #endif \ No newline at end of file diff --git a/src/game/door.c b/src/game/door.c index 7975ad1..ff81f39 100644 --- a/src/game/door.c +++ b/src/game/door.c @@ -30,7 +30,7 @@ void door_init(struct Door* door, int mask) door->close_position = 0.f; door->state = DOOR_CLOSED; - event_manager_subscribe_with_object(event_manager, EVT_SCENE_LOADED, &door_on_scene_loaded, (void*)door); + event_manager_subscribe_with_subscriber(event_manager, EVT_SCENE_LOADED, &door_on_scene_loaded, (void*)door); } void door_reset(struct Door* door) @@ -39,8 +39,8 @@ void door_reset(struct Door* door) door->speed = 0.f; struct Event_Manager* event_manager = game_state_get()->event_manager; - event_manager_unsubscribe_with_object(event_manager, EVT_TRIGGER, &door_on_trigger, (void*)door); - event_manager_unsubscribe_with_object(event_manager, EVT_SCENE_LOADED, &door_on_scene_loaded, (void*)door); + event_manager_unsubscribe_with_subscriber(event_manager, EVT_TRIGGER, &door_on_trigger, (void*)door); + event_manager_unsubscribe_with_subscriber(event_manager, EVT_SCENE_LOADED, &door_on_scene_loaded, (void*)door); } struct Door* door_read(struct Parser_Object* object, const char* name, struct Entity* parent_entity) @@ -169,7 +169,7 @@ void door_on_scene_loaded(struct Event* event, void* door_ptr) { door->trigger = door_trigger[0]; struct Event_Manager* event_manager = game_state_get()->event_manager; - event_manager_subscribe_with_object(event_manager, EVT_TRIGGER, &door_on_trigger, (void*)door); + event_manager_subscribe_with_subscriber(event_manager, EVT_TRIGGER, &door_on_trigger, (void*)door); } else { diff --git a/src/game/editor.c b/src/game/editor.c index 9489971..b2c48f7 100755 --- a/src/game/editor.c +++ b/src/game/editor.c @@ -43,8 +43,9 @@ #include #include -#define LABEL_FLAGS_ALIGN_LEFT NK_TEXT_ALIGN_MIDDLE | NK_TEXT_ALIGN_LEFT -#define LABEL_FLAGS_ALIGN_RIGHT NK_TEXT_ALIGN_MIDDLE | NK_TEXT_ALIGN_RIGHT +#define LABEL_FLAGS_ALIGN_LEFT NK_TEXT_ALIGN_MIDDLE | NK_TEXT_ALIGN_LEFT +#define LABEL_FLAGS_ALIGN_RIGHT NK_TEXT_ALIGN_MIDDLE | NK_TEXT_ALIGN_RIGHT +#define LABEL_FLAGS_ALIGN_CENTERED NK_TEXT_ALIGN_MIDDLE | NK_TEXT_ALIGN_CENTERED enum Editor_Tool { diff --git a/src/game/enemy.c b/src/game/enemy.c index 2d86d07..448cc5a 100644 --- a/src/game/enemy.c +++ b/src/game/enemy.c @@ -61,7 +61,7 @@ void enemy_init(struct Enemy* enemy, int type) } struct Event_Manager* event_manager = game_state->event_manager; - event_manager_subscribe_with_object(event_manager, EVT_SCENE_LOADED, &enemy_on_scene_loaded, (void*)enemy); + event_manager_subscribe_with_subscriber(event_manager, EVT_SCENE_LOADED, &enemy_on_scene_loaded, (void*)enemy); } void enemy_weapon_sound_set(struct Enemy* enemy, const char* sound_filename, int type) @@ -120,7 +120,7 @@ void enemy_reset(struct Enemy* enemy) enemy->health = 0; struct Event_Manager* event_manager = game_state_get()->event_manager; - event_manager_unsubscribe_with_object(event_manager, EVT_SCENE_LOADED, &enemy_on_scene_loaded, (void*)enemy); + event_manager_unsubscribe_with_subscriber(event_manager, EVT_SCENE_LOADED, &enemy_on_scene_loaded, (void*)enemy); } struct Enemy* enemy_read(struct Parser_Object* object, const char* name, struct Entity* parent_entity) diff --git a/src/game/event.c b/src/game/event.c index 505fb12..f90f7bc 100644 --- a/src/game/event.c +++ b/src/game/event.c @@ -38,7 +38,7 @@ void event_manager_subscribe(struct Event_Manager* event_manager, int event_type for(int i = 0; i < MAX_EVENT_SUBSCRIPTIONS; i++) { struct Event_Subscription* subscription = &event_manager->event_subsciptions[i]; - if(subscription->type == EST_WITHOUT_OBJECT && subscription->event_type == event_type && subscription->handler == handler_func) + if(subscription->type == EST_WITHOUT_OBJECTS && subscription->event_type == event_type && subscription->Subscription_Without_Objects.handler == handler_func) { log_message("Already subscibed to %s event", event_name_get(event_type)); subscribed = true; @@ -55,10 +55,10 @@ void event_manager_subscribe(struct Event_Manager* event_manager, int event_type struct Event_Subscription* subscription = &event_manager->event_subsciptions[i]; if(subscription->type == EST_NONE) { - subscription->type = EST_WITHOUT_OBJECT; - subscription->event_type = event_type; - subscription->handler = handler_func; - subscribed = true; + subscribed = true; + subscription->type = EST_WITHOUT_OBJECTS; + subscription->event_type = event_type; + subscription->Subscription_Without_Objects.handler = handler_func; break; } } @@ -77,31 +77,33 @@ void event_manager_unsubscribe(struct Event_Manager* event_manager, int event_ty for(int i = 0; i < MAX_EVENT_SUBSCRIPTIONS; i++) { struct Event_Subscription* subscription = &event_manager->event_subsciptions[i]; - if(subscription->type != EST_WITHOUT_OBJECT) continue; - if(subscription->event_type == event_type && subscription->handler == handler_func) + if(subscription->type != EST_WITHOUT_OBJECTS) continue; + if(subscription->event_type == event_type && subscription->Subscription_Without_Objects.handler == handler_func) { - subscription->handler = NULL; - subscription->event_type = EVT_NONE; - subscription->type = EST_NONE; + subscription->Subscription_Without_Objects.handler = NULL; + subscription->event_type = EVT_NONE; + subscription->type = EST_NONE; break; } } } -void event_manager_unsubscribe_with_object(struct Event_Manager* event_manager, int event_type, Event_Handler_Object handler_func, void* subscriber) +void event_manager_unsubscribe_with_subscriber(struct Event_Manager* event_manager, int event_type, Event_Handler_Subscriber handler_func, void* subscriber) { assert(event_manager && event_type < EVT_MAX); for(int i = 0; i < MAX_EVENT_SUBSCRIPTIONS; i++) { struct Event_Subscription* subscription = &event_manager->event_subsciptions[i]; - if(subscription->type != EST_WITH_OBJECT) continue; - if(subscription->event_type == event_type && subscription->handler_with_object == handler_func && subscription->subscriber == subscriber) + if(subscription->type != EST_SUBSCRIBER) continue; + if(subscription->event_type == event_type && + subscription->Subscription_Subscriber.handler == handler_func && + subscription->Subscription_Subscriber.subscriber == subscriber) { - subscription->handler_with_object = NULL; - subscription->event_type = EVT_NONE; - subscription->type = EST_NONE; - subscription->subscriber = NULL; + subscription->Subscription_Subscriber.handler = NULL; + subscription->event_type = EVT_NONE; + subscription->type = EST_NONE; + subscription->Subscription_Subscriber.subscriber = NULL; break; } } @@ -235,19 +237,26 @@ void event_manager_poll_events(struct Event_Manager* event_manager) for(int i = 0; i < MAX_EVENT_SUBSCRIPTIONS; i++) { struct Event_Subscription* subscription = &event_manager->event_subsciptions[i]; - if(subscription->type == EST_NONE) continue; - - if(subscription->event_type == user_event->type) + if(subscription->type != EST_NONE && subscription->event_type == user_event->type) { - if(subscription->type == EST_WITHOUT_OBJECT) - { - if(subscription->handler) - subscription->handler(user_event); - } - else if(subscription->type == EST_WITH_OBJECT) + switch(subscription->type) { - if(subscription->handler_with_object) - subscription->handler_with_object(user_event, subscription->subscriber); + case EST_WITHOUT_OBJECTS: + if(subscription->Subscription_Without_Objects.handler) + subscription->Subscription_Without_Objects.handler(user_event); + break; + case EST_SENDER: + if(subscription->Subscription_Sender.handler) + subscription->Subscription_Sender.handler(user_event, subscription->Subscription_Sender.sender); + break; + case EST_SUBSCRIBER: + if(subscription->Subscription_Subscriber.handler) + subscription->Subscription_Subscriber.handler(user_event, subscription->Subscription_Subscriber.subscriber); + break; + case EST_SUBSCRIBER_SENDER: + if(subscription->Subscription_Subscriber_Sender.handler) + subscription->Subscription_Subscriber_Sender.handler(user_event, subscription->Subscription_Subscriber_Sender.subscriber, subscription->Subscription_Subscriber_Sender.sender); + break; } } } @@ -262,7 +271,7 @@ void event_manager_poll_events(struct Event_Manager* event_manager) } } -void event_manager_subscribe_with_object(struct Event_Manager* event_manager, int event_type, Event_Handler_Object handler_func, void* subscriber) +void event_manager_subscribe_with_subscriber(struct Event_Manager* event_manager, int event_type, Event_Handler_Subscriber handler_func, void* subscriber) { assert(event_manager && event_type < EVT_MAX && event_type > EVT_NONE); @@ -271,7 +280,10 @@ void event_manager_subscribe_with_object(struct Event_Manager* event_manager, in for(int i = 0; i < MAX_EVENT_SUBSCRIPTIONS; i++) { struct Event_Subscription* subscription = &event_manager->event_subsciptions[i]; - if(subscription->type == EST_WITH_OBJECT && subscription->event_type == event_type && subscription->handler_with_object == handler_func && subscription->subscriber == subscriber) + if(subscription->type == EST_SUBSCRIBER && + subscription->event_type == event_type && + subscription->Subscription_Subscriber.handler == handler_func && + subscription->Subscription_Subscriber.subscriber == subscriber) { log_message("Already subscibed to %s event", event_name_get(event_type)); subscribed = true; @@ -288,11 +300,11 @@ void event_manager_subscribe_with_object(struct Event_Manager* event_manager, in struct Event_Subscription* subscription = &event_manager->event_subsciptions[i]; if(subscription->type == EST_NONE) { - subscription->type = EST_WITH_OBJECT; - subscription->event_type = event_type; - subscription->handler_with_object = handler_func; - subscription->subscriber = subscriber; - subscribed = true; + subscribed = true; + subscription->type = EST_SUBSCRIBER; + subscription->event_type = event_type; + subscription->Subscription_Subscriber.handler = handler_func; + subscription->Subscription_Subscriber.subscriber = subscriber; break; } } @@ -341,11 +353,149 @@ void event_manager_send_event_entity(struct Event_Manager* event_manager, struct for(int i = 0; i < MAX_EVENT_SUBSCRIPTIONS; i++) { struct Event_Subscription* subscription = &event_manager->event_subsciptions[i]; - if(subscription->type != EST_WITH_OBJECT) continue; + if(subscription->type != EST_SUBSCRIBER) continue; + + if(subscription->event_type == event->type && + subscription->Subscription_Subscriber.subscriber == entity && + subscription->Subscription_Subscriber.handler) + { + subscription->Subscription_Subscriber.handler(event, (void*)entity); + break; + } + } +} + +void event_manager_subscribe_with_sender(struct Event_Manager* event_manager, int event_type, Event_Handler_Sender handler_func, void* sender) +{ + assert(event_manager && event_type < EVT_MAX && event_type > EVT_NONE && sender); + + //Check if this handler/subscriber already exists + bool subscribed = false; + for(int i = 0; i < MAX_EVENT_SUBSCRIPTIONS; i++) + { + struct Event_Subscription* subscription = &event_manager->event_subsciptions[i]; + if(subscription->type == EST_SENDER && + subscription->event_type == event_type && + subscription->Subscription_Sender.handler == handler_func && + subscription->Subscription_Sender.sender == sender) + { + log_message("Already subscibed to %s event", event_name_get(event_type)); + subscribed = true; + break; + } + } + + //Now that we've established that we are not subscribed already we find an empty slot and + //create a new subscription there + if(!subscribed) + { + for(int i = 0; i < MAX_EVENT_SUBSCRIPTIONS; i++) + { + struct Event_Subscription* subscription = &event_manager->event_subsciptions[i]; + if(subscription->type == EST_NONE) + { + subscribed = true; + subscription->type = EST_SENDER; + subscription->event_type = event_type; + subscription->Subscription_Sender.handler = handler_func; + subscription->Subscription_Sender.sender = sender; + break; + } + } + } + + //if subscribed is still not true, it can only mean that all the existing slots are taken + //Show an error message in that case + if(!subscribed) + log_error("event_manager:subscribe_with_sender", "Could not subscribe to %s event", event_name_get(event_type)); +} + +void event_manager_subscribe_with_subscriber_sender(struct Event_Manager* event_manager, int event_type, Event_Handler_Subscriber_Sender handler_func, void* subscriber, void* sender) +{ + assert(event_manager && event_type < EVT_MAX && event_type > EVT_NONE && sender && subscriber); + + //Check if this handler/subscriber/sender already exists + bool subscribed = false; + for(int i = 0; i < MAX_EVENT_SUBSCRIPTIONS; i++) + { + struct Event_Subscription* subscription = &event_manager->event_subsciptions[i]; + if(subscription->type == EST_SUBSCRIBER_SENDER && + subscription->event_type == event_type && + subscription->Subscription_Subscriber_Sender.handler == handler_func && + subscription->Subscription_Subscriber_Sender.sender == sender && + subscription->Subscription_Subscriber_Sender.subscriber == subscriber) + { + log_message("Already subscibed to %s event", event_name_get(event_type)); + subscribed = true; + break; + } + } + + //Now that we've established that we are not subscribed already we find an empty slot and + //create a new subscription there + if(!subscribed) + { + for(int i = 0; i < MAX_EVENT_SUBSCRIPTIONS; i++) + { + struct Event_Subscription* subscription = &event_manager->event_subsciptions[i]; + if(subscription->type == EST_NONE) + { + subscribed = true; + subscription->type = EST_SUBSCRIBER_SENDER; + subscription->event_type = event_type; + subscription->Subscription_Subscriber_Sender.handler = handler_func; + subscription->Subscription_Subscriber_Sender.sender = sender; + subscription->Subscription_Subscriber_Sender.subscriber = subscriber; + break; + } + } + } + + //if subscribed is still not true, it can only mean that all the existing slots are taken + //Show an error message in that case + if(!subscribed) + log_error("event_manager:subscribe_with_sender", "Could not subscribe to %s event", event_name_get(event_type)); +} + +void event_manager_unsubscribe_sender(struct Event_Manager* event_manager, int event_type, Event_Handler_Sender handler_func, void* sender) +{ + assert(event_manager && event_type < EVT_MAX); + + for(int i = 0; i < MAX_EVENT_SUBSCRIPTIONS; i++) + { + struct Event_Subscription* subscription = &event_manager->event_subsciptions[i]; + if(subscription->type != EST_SENDER) continue; + if(subscription->event_type == event_type && + subscription->Subscription_Sender.handler == handler_func && + subscription->Subscription_Sender.sender == sender) + { + subscription->event_type = EVT_NONE; + subscription->type = EST_NONE; + subscription->Subscription_Sender.handler = NULL; + subscription->Subscription_Sender.sender = NULL; + break; + } + } +} - if(subscription->event_type == event->type && subscription->subscriber == entity && subscription->handler_with_object) +void event_manager_unsubscribe_with_subscriber_sender(struct Event_Manager* event_manager, int event_type, Event_Handler_Subscriber_Sender handler_func, void* subscriber, void* sender) +{ + assert(event_manager && event_type < EVT_MAX); + + for(int i = 0; i < MAX_EVENT_SUBSCRIPTIONS; i++) + { + struct Event_Subscription* subscription = &event_manager->event_subsciptions[i]; + if(subscription->type != EST_SUBSCRIBER) continue; + if(subscription->event_type == event_type && + subscription->Subscription_Subscriber_Sender.handler == handler_func && + subscription->Subscription_Subscriber_Sender.subscriber == subscriber && + subscription->Subscription_Subscriber_Sender.sender == sender) { - subscription->handler_with_object(event, (void*)entity); + subscription->event_type = EVT_NONE; + subscription->type = EST_NONE; + subscription->Subscription_Subscriber_Sender.handler = NULL; + subscription->Subscription_Subscriber_Sender.subscriber = NULL; + subscription->Subscription_Subscriber_Sender.sender = NULL; break; } } diff --git a/src/game/event.h b/src/game/event.h index 2e42465..af1cde3 100755 --- a/src/game/event.h +++ b/src/game/event.h @@ -9,7 +9,9 @@ struct Entity; struct Trigger; typedef void (*Event_Handler) (const struct Event* event); -typedef void (*Event_Handler_Object) (const struct Event* event, void* subscriber); +typedef void (*Event_Handler_Sender) (const struct Event* event, void* sender); +typedef void (*Event_Handler_Subscriber) (const struct Event* event, void* subscriber); +typedef void (*Event_Handler_Subscriber_Sender) (const struct Event* event, void* subscriber, void* sender); enum Event_Types @@ -33,8 +35,10 @@ enum Event_Types enum Event_Subscription_Type { EST_NONE = 0, - EST_WITHOUT_OBJECT, - EST_WITH_OBJECT + EST_WITHOUT_OBJECTS, + EST_SENDER, + EST_SUBSCRIBER, + EST_SUBSCRIBER_SENDER }; struct Input_Map_Event @@ -120,16 +124,29 @@ struct Event_Subscription int event_type; union { - struct + struct { Event_Handler handler; - }; + } Subscription_Without_Objects; - struct + struct { - Event_Handler_Object handler_with_object; - void* subscriber; - }; + Event_Handler_Subscriber handler; + void* subscriber; + } Subscription_Subscriber; + + struct + { + Event_Handler_Sender handler; + void* sender; + } Subscription_Sender; + + struct + { + Event_Handler_Subscriber_Sender handler; + void* sender; + void* subscriber; + } Subscription_Subscriber_Sender; }; }; @@ -142,9 +159,13 @@ struct Event_Manager void event_manager_init(struct Event_Manager* event_manager); void event_manager_subscribe(struct Event_Manager* event_manager, int event_type, Event_Handler event_handler_func); -void event_manager_subscribe_with_object(struct Event_Manager* event_manager, int event_type, Event_Handler_Object handler_func, void* subscriber); -void event_manager_unsubscribe(struct Event_Manager* event_manager, int event_type, Event_Handler subscriber); -void event_manager_unsubscribe_with_object(struct Event_Manager* event_manager, int event_type, Event_Handler_Object handler_func, void* subscriber); +void event_manager_subscribe_with_sender(struct Event_Manager* event_manager, int event_type, Event_Handler_Sender handler_func, void* sender); +void event_manager_subscribe_with_subscriber(struct Event_Manager* event_manager, int event_type, Event_Handler_Subscriber handler_func, void* subscriber); +void event_manager_subscribe_with_subscriber_sender(struct Event_Manager* event_manager, int event_type, Event_Handler_Subscriber_Sender handler_func, void* subscriber, void* sender); +void event_manager_unsubscribe(struct Event_Manager* event_manager, int event_type, Event_Handler handler_func); +void event_manager_unsubscribe_sender(struct Event_Manager* event_manager, int event_type, Event_Handler_Sender handler_func, void* sender); +void event_manager_unsubscribe_with_subscriber(struct Event_Manager* event_manager, int event_type, Event_Handler_Subscriber handler_func, void* subscriber); +void event_manager_unsubscribe_with_subscriber_sender(struct Event_Manager* event_manager, int event_type, Event_Handler_Subscriber_Sender handler_func, void* subscriber, void* sender); struct Event* event_manager_create_new_event(struct Event_Manager* event_manager); void event_manager_send_event(struct Event_Manager* event_manager, struct Event* event); void event_manager_send_event_entity(struct Event_Manager* event_manager, struct Event* event, struct Entity* entity); diff --git a/src/game/scene_funcs.c b/src/game/scene_funcs.c index 86c622e..26e11e6 100644 --- a/src/game/scene_funcs.c +++ b/src/game/scene_funcs.c @@ -1,7 +1,11 @@ #include "scene_funcs.h" +#include "event.h" +#include "game.h" #include "../common/log.h" +static void scene_on_end_trigger(const struct Event* event, void* sender); + void scene_init_stub(struct Scene* scene) { log_warning("Scene Init Stub Called"); @@ -14,10 +18,30 @@ void scene_cleanup_stub(struct Scene* scene) void scene_1_init(struct Scene* scene) { - log_message("Scene 1 init called"); + struct Trigger* scene_end_trigger = scene_trigger_find(scene, "Scene_End_Trigger"); + if(scene_end_trigger) + { + struct Event_Manager* event_manager = game_state_get()->event_manager; + event_manager_subscribe_with_sender(event_manager, EVT_TRIGGER, &scene_on_end_trigger, scene_end_trigger); + log_message("Scene End Event set"); + } + else + { + log_message("Trigger not found"); + } } void scene_1_cleanup(struct Scene* scene) { - log_message("Scene 1 cleanup called"); + struct Trigger* scene_end_trigger = scene_trigger_find(scene, "Scene_End_Trigger"); + if(scene_end_trigger) + { + struct Event_Manager* event_manager = game_state_get()->event_manager; + event_manager_unsubscribe_sender(event_manager, EVT_TRIGGER, &scene_on_end_trigger, scene_end_trigger); + } +} + +void scene_on_end_trigger(const struct Event* event, void* sender) +{ + log_message("Scene_End_Trigger triggered, Move to next scene now!"); } diff --git a/todo.txt b/todo.txt index 48b4ece..5e1e3ef 100644 --- a/todo.txt +++ b/todo.txt @@ -1,13 +1,15 @@ Todo: - - Player/enemies getting hit by bullets - Win/fail States + - Save scene init/cleanup funcs if there are any assigned when saving scene + - Save case sensitive file names when scene entity entries + - Investigate whether toggle trigger is working properly + - Player/enemies getting hit by bullets - Remove excessive repitition in scene and editor code that handles multiple entity types - Allow switching to editor mode when game is in pause mode - Rendering Additions: - Color grading - Shadow mapping - Cube mapping for sky dome etc - - Add event sender along with events - Implement flag for ignoring collisions with certain entities - Implement game gui either with a separate nuklear context or as part of existing context - Fix rotate gizmo's origin not being set to the selected entity