HazelEngine 学习记录 - Layers

Layers

游戏引擎的层级理解如下：

• 首先很容易接触到的是游戏制作者会调用的表层的各个模块，称为工具层（Tool Layer）。
• 然后我们会理解这些工具背后的逻辑是什么，使用了什么功能，比如游戏世界怎么变成画面的（渲染功能），人物怎么动起来的等，这就是功能层（Function Layer）。
• 再次，所有上述这些肯定都需要首先有东西在那儿，（巧妇难为无米之炊），所以资源层（Resource Layer）也呼之欲出。
• 之后，我们会发现很多过程中我们使用的都是一些相同的代码模块（比如容器的创建、内存的管理），于是我们把这些东西成为核心层（Core Layer）。
• 抛开这些之外，我们还注意到，游戏还需要一个链接不同平台和输入输出设备的模块来满足不同玩家的需求，所以我们又有处理各个平台的平台层（Platform Layer）。
• 在这些之外，我们还有各种第三方支持。

我们要实现的就是一个抽象 Layer 类以及用于存放 Layer 的 LayerStack 。

首先 Layer 要实现的基本功能就是和我们的当前显示内容进行连接或者断开，因此定义了两个函数 OnAttach 和 OnDetach， 以及用于显示的 OnUpdate，用于提交事件的 OnEvent

//Layer.h	
class HAZEL_API Layer
	{
	public:
		Layer(const std::string& name = "Layer");
		virtual ~Layer();

		virtual void OnAttach() {}
		virtual void OnDetach() {}
		virtual void OnUpdate() {}
		virtual void OnEvent(Event& event) {}

		inline const std::string& GetName() { return m_DebugName; }
	private:
		std::string m_DebugName;
	};

此外，为了保存我们创建的各种 Layer ，需要一个 LayerStack 来存储，

//LayerStack.h	
class LayerStack
	{
	public:
		LayerStack();
		~LayerStack();

		void PushLayer(Layer* layer);
		void PushOverlay(Layer* overlay);
		void PopLayer(Layer* layer);
		void PopOverlay(Layer* overlay);

		std::vector<Layer*>::iterator begin() { return m_Layers.begin(); }
		std::vector<Layer*>::iterator end() { return m_Layers.end(); }
	private:
		std::vector<Layer*> m_Layers; //用一个 vector 来保存
		std::vector<Layer*>::iterator m_LayerInsert;
	};
//LayerStack.cpp
	LayerStack::LayerStack()
	{
		m_LayerInsert = m_Layers.begin();
	}

	LayerStack::~LayerStack()
	{
		for (Layer* layer : m_Layers)
			delete layer;
	}

	void LayerStack::PushLayer(Layer* layer)
	{
		m_LayerInsert = m_Layers.emplace(m_LayerInsert, layer);
	}
	void LayerStack::PushOverlay(Layer* overlay)
	{
		m_Layers.emplace_back(overlay);
	}
	void LayerStack::PopLayer(Layer* layer)
	{
		auto it = std::find(m_Layers.begin(), m_Layers.end(), layer);
		if (it != m_Layers.end()) {
			m_Layers.erase(it);
			m_LayerInsert--;
		}
	}

	void LayerStack::PopOverlay(Layer* overlay)
	{
		auto it = std::find(m_Layers.begin(), m_Layers.end(), overlay);
		if (it != m_Layers.end()) {
			m_Layers.erase(it);
		}
	}

为了使用 Layer ，在 Application 中添加了接口函数

	void Application::PushLayer(Layer* layer)
	{
		m_LayerStack.PushLayer(layer);
	}

	void Application::PushOverlay(Layer* overlay)
	{
		m_LayerStack.PushOverlay(overlay);
	}

然后在 Run 函数中进行调用

	void Application::Run()
	{
 		
		while (m_Running)
		{
			glClearColor(1, 0, 1, 1);
			glClear(GL_COLOR_BUFFER_BIT);

			for (Layer* layer : m_LayerStack)
				layer->OnUpdate();
			m_Window->OnUpdate();
		}
	}

Hazel.h 中对 Layer 进行包含

最后简单的在 SandBox 中对 Layer 进行测试

class ExampleLayer : public Hazel::Layer
{
public:
	ExampleLayer() : Layer("Example") {}

	void OnUpdate() override
	{
		HZ_INFO("ExampleLayer::Update");
	}

	void OnEvent(Hazel::Event& event) override
	{
		HZ_TRACE("{0}", event);
	}

};

运行结果：