Added layerstack and integrated it with the application layer

bakara/src/bakara/core/application.cpp

@@ -12,9 +12,14 @@ namespace Bk {
     void Application::on_event(Event& e)
     {
         EventDispatcher dispatcher(e);
-        dispatcher.dispatch<WindowCloseEvent>(BK_BIND_DISPACHER_FN(WindowCloseEvent, on_window_close));
+        if (!(dispatcher.dispatch<WindowCloseEvent>(BK_BIND_DISPACHER_FN(WindowCloseEvent, on_window_close)) ||
-		dispatcher.dispatch<WindowResizeEvent>(BK_BIND_DISPACHER_FN(WindowResizeEvent, on_window_resize));
+		dispatcher.dispatch<WindowResizeEvent>(BK_BIND_DISPACHER_FN(WindowResizeEvent, on_window_resize))))
-        BK_CORE_INFO("Event : {0}", GET_EVENT_STRING(e));
+        {
+            for(auto it = layer_stack.rbegin(); it != layer_stack.rend(); it++)
+            {
+                (*it)->on_event(e);
+            }
+        }
     }
 
     bool Application::on_window_close(WindowCloseEvent& e)

bakara/src/bakara/core/application.h

@@ -3,6 +3,7 @@
 #include <bkpch.h>
 #include <bakara/io/window.h>
 #include <bakara/events/events.h>
+#include <bakara/core/layer_stack.h>
 
 namespace Bk {
 
@@ -17,9 +18,16 @@ namespace Bk {
             void on_event(Event& e);
             bool on_window_close(WindowCloseEvent& e);
             bool on_window_resize(WindowResizeEvent& e);
+
+            void push_overlay(Layer*  layer) { layer_stack.push_overlay(layer); }
+            std::unique_ptr<Layer> pop_overlay() { return layer_stack.pop_overlay(); }
+            void push_layer(Layer*  layer) { layer_stack.push_layer(layer); }
+            std::unique_ptr<Layer> pop_layer() { return layer_stack.pop_layer(); }
+
             void run();
         private:
             std::unique_ptr<Window> p_window;
+            LayerStack layer_stack;
             bool p_running = true;
     };
 

bakara/src/bakara/core/layer.h

@@ -1,5 +1,6 @@
 #pragma once 
 #include <bkpch.h>
+#include <bakara/events/events.h>
 
 namespace Bk {
     class Layer 
@@ -10,9 +11,10 @@ namespace Bk {
 
             virtual void on_attach() {}
             virtual void on_detach() {}
-            virtual void on_event() {}
+            virtual void on_event(Event& e) {}
             virtual void on_update() {}
-        private:
+            const std::string to_string() const { return name; }
+        protected:
             std::string name;
     }; 
 }

bakara/src/bakara/core/layer_stack.cpp

@@ -0,0 +1,50 @@
+#include "layer_stack.h"
+
+namespace Bk {
+	LayerStack::~LayerStack()
+	{
+		std::for_each(p_layers.begin(), p_layers.end(), [](Layer* layer)
+			{
+				layer->on_detach();
+				delete layer;
+			});
+		p_layers.clear();
+	}
+
+	void LayerStack::push_overlay(Layer* layer)
+	{
+		layer->on_attach();
+		p_layers.emplace_back(layer);
+	}
+
+	std::unique_ptr<Layer> LayerStack::pop_overlay()
+	{
+		if(auto layer = p_layers.back())
+		{ 
+			p_layers.pop_back();
+			return std::make_unique<Layer>(*layer); 
+		}
+		return nullptr;
+	}
+
+	void LayerStack::push_layer(Layer* layer)
+	{
+		layer->on_attach();
+		p_layers.emplace_front(layer);
+	}
+
+	std::unique_ptr<Layer> LayerStack::pop_layer()
+	{
+		if(auto layer = p_layers.front()) 
+		{ 
+			p_layers.pop_front();
+			return std::make_unique<Layer>(*layer); 
+		}
+		return nullptr;
+	}
+
+	void LayerStack::clear()
+	{
+		p_layers.clear();
+	}
+}

bakara/src/bakara/core/layer_stack.h

@@ -1,8 +1,29 @@
 #pragma once
 
-namespace BK {
+#include <bkpch.h>
+#include "layer.h"
+
+namespace Bk {
 	class LayerStack
 	{
+		public:
+			LayerStack() = default;
+			~LayerStack();
+
+			void push_overlay(Layer* layer);
+			std::unique_ptr<Layer> pop_overlay();
+			void push_layer(Layer* layer);
+			std::unique_ptr<Layer> pop_layer();
+			void clear();
+
+			std::deque<Layer*>::iterator begin() { return p_layers.begin(); }
+			std::deque<Layer*>::iterator end() { return p_layers.end(); }
+
+			std::deque<Layer*>::reverse_iterator rbegin() { return p_layers.rbegin(); }
+			std::deque<Layer*>::reverse_iterator rend() { return p_layers.rend(); }
 
+		private:
+			std::deque<Layer*> p_layers;
+			uint p_layer_index = 0;	
 	};
 }