该系列教程源自youtube的cherno的视频-GAME ENGINE series!
视频地址: https://www.youtube.com/watch?v=vtWdgtMo1T4
引擎源代码地址: https://github.com/TheCherno/Hazel
主要内容简介:
在Hazel目录下 新建文件夹 Events ；添加 ApplicationEvent.h Event.h KeyEvent.h MouseEvent.h
Event.h
#pragma once
#include <string>
#include <functional>
#include "Hazel/Core.h"
namespace Hazel {
// Events in Hazel are currently blocking, meaning when an event occurs it
// immediately gets dispatched and must be dealt with right then an there.
// For the future, a better strategy might be to buffer events in an event
// bus and process them during the "event" part of the update stage.
enum class EventType
{
None = 0,
WindowClose, WindowResize, WindowFocus, WindowLostFocus, WindowMoved,
AppTick, AppUpdate, AppRender,
KeyPressed, KeyReleased, KeyTyped,
MouseButtonPressed, MouseButtonReleased, MouseMoved, MouseScrolled
};
enum EventCategory
{
None = 0,
EventCategoryApplication = BIT(0),
EventCategoryInput = BIT(1),
EventCategoryKeyboard = BIT(2),
EventCategoryMouse = BIT(3),
EventCategoryMouseButton = BIT(4)
};
#define EVENT_CLASS_TYPE(type) static EventType GetStaticType() { return EventType::type; }\
virtual EventType GetEventType() const override { return GetStaticType(); }\
virtual const char* GetName() const override { return #type; }
#define EVENT_CLASS_CATEGORY(category) virtual int GetCategoryFlags() const override { return category; }
class Event
{
public:
virtual ~Event() = default;
bool Handled = false;
virtual EventType GetEventType() const = 0;
virtual const char* GetName() const = 0;
virtual int GetCategoryFlags() const = 0;
virtual std::string ToString() const { return GetName(); }
bool IsInCategory(EventCategory category)
{
return GetCategoryFlags() & category;
}
};
class EventDispatcher
{
public:
EventDispatcher(Event& event)
: m_Event(event)
{
}
// F will be deduced by the compiler
template<typename T, typename F>
bool Dispatch(const F& func)
{
if (m_Event.GetEventType() == T::GetStaticType())
{
m_Event.Handled |= func(static_cast<T&>(m_Event));
return true;
}
return false;
}
private:
Event& m_Event;
};
inline std::ostream& operator<<(std::ostream& os, const Event& e)
{
return os << e.ToString();
}
}
ApplicationEvent.h
#pragma once
#include "Hazel/Events/Event.h"
namespace Hazel {
class WindowResizeEvent : public Event
{
public:
WindowResizeEvent(unsigned int width, unsigned int height)
: m_Width(width), m_Height(height) {}
unsigned int GetWidth() const { return m_Width; }
unsigned int GetHeight() const { return m_Height; }
std::string ToString() const override
{
std::stringstream ss;
ss << "WindowResizeEvent: " << m_Width << ", " << m_Height;
return ss.str();
}
EVENT_CLASS_TYPE(WindowResize)
EVENT_CLASS_CATEGORY(EventCategoryApplication)
private:
unsigned int m_Width, m_Height;
};
class WindowCloseEvent : public Event
{
public:
WindowCloseEvent() = default;
EVENT_CLASS_TYPE(WindowClose)
EVENT_CLASS_CATEGORY(EventCategoryApplication)
};
class AppTickEvent : public Event
{
public:
AppTickEvent() = default;
EVENT_CLASS_TYPE(AppTick)
EVENT_CLASS_CATEGORY(EventCategoryApplication)
};
class AppUpdateEvent : public Event
{
public:
AppUpdateEvent() = default;
EVENT_CLASS_TYPE(AppUpdate)
EVENT_CLASS_CATEGORY(EventCategoryApplication)
};
class AppRenderEvent : public Event
{
public:
AppRenderEvent() = default;
EVENT_CLASS_TYPE(AppRender)
EVENT_CLASS_CATEGORY(EventCategoryApplication)
};
}
KeyEvent.h
#pragma once
#include "Hazel/Events/Event.h"
namespace Hazel {
class KeyEvent : public Event
{
public:
inline int GetKeyCode() const { return m_KeyCode; }
EVENT_CLASS_CATEGORY(EventCategoryKeyboard | EventCategoryInput)
protected:
KeyEvent(const int keycode)
: m_KeyCode(keycode) {}
int m_KeyCode;
};
class KeyPressedEvent : public KeyEvent
{
public:
KeyPressedEvent(const int keycode, const uint16_t repeatCount)
: KeyEvent(keycode), m_RepeatCount(repeatCount) {}
uint16_t GetRepeatCount() const { return m_RepeatCount; }
std::string ToString() const override
{
std::stringstream ss;
ss << "KeyPressedEvent: " << m_KeyCode << " (" << m_RepeatCount << " repeats)";
return ss.str();
}
EVENT_CLASS_TYPE(KeyPressed)
private:
uint16_t m_RepeatCount;
};
class KeyReleasedEvent : public KeyEvent
{
public:
KeyReleasedEvent(const int keycode)
: KeyEvent(keycode) {}
std::string ToString() const override
{
std::stringstream ss;
ss << "KeyReleasedEvent: " << m_KeyCode;
return ss.str();
}
EVENT_CLASS_TYPE(KeyReleased)
};
class KeyTypedEvent : public KeyEvent
{
public:
KeyTypedEvent(const int keycode)
: KeyEvent(keycode) {}
std::string ToString() const override
{
std::stringstream ss;
ss << "KeyTypedEvent: " << m_KeyCode;
return ss.str();
}
EVENT_CLASS_TYPE(KeyTyped)
};
}
MouseEvent.h
#pragma once
#include "Hazel/Events/Event.h"
namespace Hazel {
class MouseMovedEvent : public Event
{
public:
MouseMovedEvent(const float x, const float y)
: m_MouseX(x), m_MouseY(y) {}
float GetX() const { return m_MouseX; }
float GetY() const { return m_MouseY; }
std::string ToString() const override
{
std::stringstream ss;
ss << "MouseMovedEvent: " << m_MouseX << ", " << m_MouseY;
return ss.str();
}
EVENT_CLASS_TYPE(MouseMoved)
EVENT_CLASS_CATEGORY(EventCategoryMouse | EventCategoryInput)
private:
float m_MouseX, m_MouseY;
};
class MouseScrolledEvent : public Event
{
public:
MouseScrolledEvent(const float xOffset, const float yOffset)
: m_XOffset(xOffset), m_YOffset(yOffset) {}
float GetXOffset() const { return m_XOffset; }
float GetYOffset() const { return m_YOffset; }
std::string ToString() const override
{
std::stringstream ss;
ss << "MouseScrolledEvent: " << GetXOffset() << ", " << GetYOffset();
return ss.str();
}
EVENT_CLASS_TYPE(MouseScrolled)
EVENT_CLASS_CATEGORY(EventCategoryMouse | EventCategoryInput)
private:
float m_XOffset, m_YOffset;
};
class MouseButtonEvent : public Event
{
public:
inline int GetMouseButton() const { return m_Button; }
EVENT_CLASS_CATEGORY(EventCategoryMouse | EventCategoryInput | EventCategoryMouseButton)
protected:
MouseButtonEvent(const int button)
: m_Button(button) {}
int m_Button;
};
class MouseButtonPressedEvent : public MouseButtonEvent
{
public:
MouseButtonPressedEvent(const int button)
: MouseButtonEvent(button) {}
std::string ToString() const override
{
std::stringstream ss;
ss << "MouseButtonPressedEvent: " << m_Button;
return ss.str();
}
EVENT_CLASS_TYPE(MouseButtonPressed)
};
class MouseButtonReleasedEvent : public MouseButtonEvent
{
public:
MouseButtonReleasedEvent(const int button)
: MouseButtonEvent(button) {}
std::string ToString() const override
{
std::stringstream ss;
ss << "MouseButtonReleasedEvent: " << m_Button;
return ss.str();
}
EVENT_CLASS_TYPE(MouseButtonReleased)
};
}
Core.h 添加:
#define BIT(x) (1 << x)
定义了事件类型EventType, 扩展增加类型,需在EventType中增加对应的枚举值
enum class EventType
{
None = 0,
WindowClose, WindowResize, WindowFocus, WindowLostFocus, WindowMoved,
AppTick, AppUpdate, AppRender,
KeyPressed, KeyReleased,
MouseButtonPressed, MouseButtonReleased, MouseMoved, MouseScrolled
};
定义了事件类别EventCategory, 每一个二进制位对应一种类别,支持一种Event对应多个EventCategory，最多扩展支持64种事件类别
enum EventCategory
{
None = 0,
EventCategoryApplication = BIT(0),
EventCategoryInput = BIT(1),
EventCategoryKeyboard = BIT(2),
EventCategoryMouse = BIT(3),
EventCategoryMouseButton = BIT(4)
};
BIT宏是 定义在Core.h中
#define BIT(x) (1 << x)
class HAZEL_API Event
{
friend class EventDispatcher;
public:
virtual EventType GetEventType() const = 0; //获取事件类型 定义在enum class EventType中的唯一值
virtual const char* GetName() const = 0; //获取事件的名称//方便打印日志调试
virtual int GetCategoryFlags() const = 0; //获取该事件的类别
virtual std::string ToString() const { return GetName(); } //方便打印调试
inline bool IsInCategory(EventCategory category)//判断该事件是否属于某一类别
{
return GetCategoryFlags() & category;
}
protected:
bool m_Handled = false;//事件分发一次处理完标记，可用来阻止事件向下传递
};
巧妙的定义了两个宏，方便子类根据名称自动生成GetEventType,GetName,GetStaticType,GetCategoryFlags四个函数
注意其中GetStaticType是静态方法,因为相同类型Event子类的实例 类别一定是一样的。
#define EVENT_CLASS_TYPE(type) static EventType GetStaticType() { return EventType::##type; }\
virtual EventType GetEventType() const override { return GetStaticType(); }\
virtual const char* GetName() const override { return #type; }
#define EVENT_CLASS_CATEGORY(category) virtual int GetCategoryFlags() const override { return category; }
这样子类写起来特别简洁
