refactor(event): 统一事件类型命名并优化输入系统

- 将事件类型命名从过去式改为现在式（如KeyPressed→KeyPress） - 合并鼠标事件数据结构，使用统一的MouseEvent替代MouseButtonEvent - 重构输入系统，使用SDL原生枚举值简化键位映射 - 更新相关文档和示例代码以匹配新的命名规范
2026-02-15 20:42:39 +08:00 · 2026-02-15 20:42:39 +08:00 · efc9961d2d
parent e0adaa3263
commit efc9961d2d
10 changed files with 290 additions and 272 deletions
--- a/Extra2D/include/extra2d/event/event.h
+++ b/Extra2D/include/extra2d/event/event.h
@ -17,39 +17,39 @@ enum class EventType {
  WindowClose,
  WindowResize,
  WindowFocus,
-  WindowLostFocus,
-  WindowMoved,
+  WindowBlur,
+  WindowMove,

  // 键盘事件
-  KeyPressed,
-  KeyReleased,
+  KeyPress,
+  KeyRelease,
  KeyRepeat,

  // 鼠标事件
-  MouseButtonPressed,
-  MouseButtonReleased,
-  MouseMoved,
-  MouseScrolled,
+  MousePress,
+  MouseRelease,
+  MouseMove,
+  MouseScroll,

  // UI 事件
  UIHoverEnter,
  UIHoverExit,
-  UIPressed,
-  UIReleased,
-  UIClicked,
+  UIPress,
+  UIRelease,
+  UIClick,

  // 游戏手柄事件
-  GamepadConnected,
-  GamepadDisconnected,
-  GamepadButtonPressed,
-  GamepadButtonReleased,
-  GamepadAxisMoved,
+  GamepadConnect,
+  GamepadDisconnect,
+  GamepadPress,
+  GamepadRelease,
+  GamepadAxis,

  // 触摸事件 (移动端)
-  TouchBegan,
-  TouchMoved,
-  TouchEnded,
-  TouchCancelled,
+  TouchBegin,
+  TouchMove,
+  TouchEnd,
+  TouchCancel,

  // 自定义事件
  Custom
@ -61,13 +61,13 @@ enum class EventType {
 struct KeyEvent {
  int keyCode;
  int scancode;
-  int mods; // 修饰键 (Shift, Ctrl, Alt, etc.)
+  int mods;
 };

 // ============================================================================
 // 鼠标事件数据
 // ============================================================================
-struct MouseButtonEvent {
+struct MouseEvent {
  int button;
  int mods;
  Vec2 position;
@ -99,7 +99,7 @@ struct WindowMoveEvent {
 // ============================================================================
 // 游戏手柄事件数据
 // ============================================================================
-struct GamepadButtonEvent {
+struct GamepadEvent {
  int gamepadId;
  int button;
 };
@ -134,37 +134,33 @@ struct Event {
  double timestamp = 0.0;
  bool handled = false;

-  // 事件数据联合体
-  std::variant<std::monostate, KeyEvent, MouseButtonEvent, MouseMoveEvent,
+  std::variant<std::monostate, KeyEvent, MouseEvent, MouseMoveEvent,
               MouseScrollEvent, WindowResizeEvent, WindowMoveEvent,
-               GamepadButtonEvent, GamepadAxisEvent, TouchEvent, CustomEvent>
+               GamepadEvent, GamepadAxisEvent, TouchEvent, CustomEvent>
      data;

-  // 便捷访问方法
  bool isWindowEvent() const {
    return type == EventType::WindowClose || type == EventType::WindowResize ||
-           type == EventType::WindowFocus ||
-           type == EventType::WindowLostFocus || type == EventType::WindowMoved;
+           type == EventType::WindowFocus || type == EventType::WindowBlur ||
+           type == EventType::WindowMove;
  }

  bool isKeyboardEvent() const {
-    return type == EventType::KeyPressed || type == EventType::KeyReleased ||
+    return type == EventType::KeyPress || type == EventType::KeyRelease ||
           type == EventType::KeyRepeat;
  }

  bool isMouseEvent() const {
-    return type == EventType::MouseButtonPressed ||
-           type == EventType::MouseButtonReleased ||
-           type == EventType::MouseMoved || type == EventType::MouseScrolled;
+    return type == EventType::MousePress || type == EventType::MouseRelease ||
+           type == EventType::MouseMove || type == EventType::MouseScroll;
  }

-  // 静态工厂方法
  static Event createWindowResize(int width, int height);
  static Event createWindowClose();
  static Event createKeyPress(int keyCode, int scancode, int mods);
  static Event createKeyRelease(int keyCode, int scancode, int mods);
-  static Event createMouseButtonPress(int button, int mods, const Vec2 &pos);
-  static Event createMouseButtonRelease(int button, int mods, const Vec2 &pos);
+  static Event createMousePress(int button, int mods, const Vec2 &pos);
+  static Event createMouseRelease(int button, int mods, const Vec2 &pos);
  static Event createMouseMove(const Vec2 &pos, const Vec2 &delta);
  static Event createMouseScroll(const Vec2 &offset, const Vec2 &pos);
 };
--- a/Extra2D/include/extra2d/platform/keys.h
+++ b/Extra2D/include/extra2d/platform/keys.h
@ -1,72 +1,195 @@
 #pragma once

+#include <SDL.h>
+
 namespace extra2d {

 /**
- * @brief 键盘按键码
+ * @brief 键盘按键码（跨平台统一）
+ *
+ * 使用 SDL Scancode 作为底层实现，确保跨平台一致性。
+ * Scancode 是物理按键位置，不依赖于键盘布局。
 */
 enum class Key : int {
-    None = 0,
-    A, B, C, D, E, F, G, H, I, J, K, L, M,
-    N, O, P, Q, R, S, T, U, V, W, X, Y, Z,
-    Num0, Num1, Num2, Num3, Num4,
-    Num5, Num6, Num7, Num8, Num9,
-    F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12,
-    Space, Enter, Escape, Tab, Backspace,
-    Insert, Delete, Home, End, PageUp, PageDown,
-    Up, Down, Left, Right,
-    LShift, RShift, LCtrl, RCtrl, LAlt, RAlt,
-    CapsLock, NumLock, ScrollLock,
-    Count
+  None = 0,
+
+  // 字母键
+  A = SDL_SCANCODE_A,
+  B = SDL_SCANCODE_B,
+  C = SDL_SCANCODE_C,
+  D = SDL_SCANCODE_D,
+  E = SDL_SCANCODE_E,
+  F = SDL_SCANCODE_F,
+  G = SDL_SCANCODE_G,
+  H = SDL_SCANCODE_H,
+  I = SDL_SCANCODE_I,
+  J = SDL_SCANCODE_J,
+  K = SDL_SCANCODE_K,
+  L = SDL_SCANCODE_L,
+  M = SDL_SCANCODE_M,
+  N = SDL_SCANCODE_N,
+  O = SDL_SCANCODE_O,
+  P = SDL_SCANCODE_P,
+  Q = SDL_SCANCODE_Q,
+  R = SDL_SCANCODE_R,
+  S = SDL_SCANCODE_S,
+  T = SDL_SCANCODE_T,
+  U = SDL_SCANCODE_U,
+  V = SDL_SCANCODE_V,
+  W = SDL_SCANCODE_W,
+  X = SDL_SCANCODE_X,
+  Y = SDL_SCANCODE_Y,
+  Z = SDL_SCANCODE_Z,
+
+  // 数字键（主键盘）
+  Num0 = SDL_SCANCODE_0,
+  Num1 = SDL_SCANCODE_1,
+  Num2 = SDL_SCANCODE_2,
+  Num3 = SDL_SCANCODE_3,
+  Num4 = SDL_SCANCODE_4,
+  Num5 = SDL_SCANCODE_5,
+  Num6 = SDL_SCANCODE_6,
+  Num7 = SDL_SCANCODE_7,
+  Num8 = SDL_SCANCODE_8,
+  Num9 = SDL_SCANCODE_9,
+
+  // 功能键
+  F1 = SDL_SCANCODE_F1,
+  F2 = SDL_SCANCODE_F2,
+  F3 = SDL_SCANCODE_F3,
+  F4 = SDL_SCANCODE_F4,
+  F5 = SDL_SCANCODE_F5,
+  F6 = SDL_SCANCODE_F6,
+  F7 = SDL_SCANCODE_F7,
+  F8 = SDL_SCANCODE_F8,
+  F9 = SDL_SCANCODE_F9,
+  F10 = SDL_SCANCODE_F10,
+  F11 = SDL_SCANCODE_F11,
+  F12 = SDL_SCANCODE_F12,
+
+  // 特殊键
+  Space = SDL_SCANCODE_SPACE,
+  Enter = SDL_SCANCODE_RETURN,
+  Escape = SDL_SCANCODE_ESCAPE,
+  Tab = SDL_SCANCODE_TAB,
+  Backspace = SDL_SCANCODE_BACKSPACE,
+  Insert = SDL_SCANCODE_INSERT,
+  Delete = SDL_SCANCODE_DELETE,
+  Home = SDL_SCANCODE_HOME,
+  End = SDL_SCANCODE_END,
+  PageUp = SDL_SCANCODE_PAGEUP,
+  PageDown = SDL_SCANCODE_PAGEDOWN,
+
+  // 方向键
+  Up = SDL_SCANCODE_UP,
+  Down = SDL_SCANCODE_DOWN,
+  Left = SDL_SCANCODE_LEFT,
+  Right = SDL_SCANCODE_RIGHT,
+
+  // 修饰键
+  LShift = SDL_SCANCODE_LSHIFT,
+  RShift = SDL_SCANCODE_RSHIFT,
+  LCtrl = SDL_SCANCODE_LCTRL,
+  RCtrl = SDL_SCANCODE_RCTRL,
+  LAlt = SDL_SCANCODE_LALT,
+  RAlt = SDL_SCANCODE_RALT,
+
+  // 锁定键
+  CapsLock = SDL_SCANCODE_CAPSLOCK,
+  NumLock = SDL_SCANCODE_NUMLOCKCLEAR,
+  ScrollLock = SDL_SCANCODE_SCROLLLOCK,
+
+  // 小键盘
+  KP0 = SDL_SCANCODE_KP_0,
+  KP1 = SDL_SCANCODE_KP_1,
+  KP2 = SDL_SCANCODE_KP_2,
+  KP3 = SDL_SCANCODE_KP_3,
+  KP4 = SDL_SCANCODE_KP_4,
+  KP5 = SDL_SCANCODE_KP_5,
+  KP6 = SDL_SCANCODE_KP_6,
+  KP7 = SDL_SCANCODE_KP_7,
+  KP8 = SDL_SCANCODE_KP_8,
+  KP9 = SDL_SCANCODE_KP_9,
+  KPPlus = SDL_SCANCODE_KP_PLUS,
+  KPMinus = SDL_SCANCODE_KP_MINUS,
+  KPMultiply = SDL_SCANCODE_KP_MULTIPLY,
+  KPDivide = SDL_SCANCODE_KP_DIVIDE,
+  KPEnter = SDL_SCANCODE_KP_ENTER,
+  KPPeriod = SDL_SCANCODE_KP_PERIOD,
+
+  // 符号键
+  Minus = SDL_SCANCODE_MINUS,
+  Equals = SDL_SCANCODE_EQUALS,
+  LeftBracket = SDL_SCANCODE_LEFTBRACKET,
+  RightBracket = SDL_SCANCODE_RIGHTBRACKET,
+  Backslash = SDL_SCANCODE_BACKSLASH,
+  Semicolon = SDL_SCANCODE_SEMICOLON,
+  Apostrophe = SDL_SCANCODE_APOSTROPHE,
+  Grave = SDL_SCANCODE_GRAVE,
+  Comma = SDL_SCANCODE_COMMA,
+  Period = SDL_SCANCODE_PERIOD,
+  Slash = SDL_SCANCODE_SLASH,
+
+  // 其他
+  PrintScreen = SDL_SCANCODE_PRINTSCREEN,
+  Pause = SDL_SCANCODE_PAUSE,
+
+  Count = SDL_NUM_SCANCODES
 };

 /**
- * @brief 鼠标按钮
+ * @brief 鼠标按钮（跨平台统一）
+ *
+ * 使用 SDL 鼠标按钮定义
 */
 enum class Mouse : int {
-    Left = 0,
-    Right,
-    Middle,
-    X1,
-    X2,
-    Count
+  Left = SDL_BUTTON_LEFT,
+  Middle = SDL_BUTTON_MIDDLE,
+  Right = SDL_BUTTON_RIGHT,
+  X1 = SDL_BUTTON_X1,
+  X2 = SDL_BUTTON_X2,
+  Count
 };

 /**
- * @brief 游戏手柄按钮
+ * @brief 游戏手柄按钮（跨平台统一）
+ *
+ * 使用 SDL GameController 按钮定义
 */
 enum class Gamepad : int {
-    A = 0,
-    B,
-    X,
-    Y,
-    LB,
-    RB,
-    LT,
-    RT,
-    Back,
-    Start,
-    Guide,
-    LStick,
-    RStick,
-    DUp,
-    DDown,
-    DLeft,
-    DRight,
-    Count
+  A = SDL_CONTROLLER_BUTTON_A,
+  B = SDL_CONTROLLER_BUTTON_B,
+  X = SDL_CONTROLLER_BUTTON_X,
+  Y = SDL_CONTROLLER_BUTTON_Y,
+  Back = SDL_CONTROLLER_BUTTON_BACK,
+  Guide = SDL_CONTROLLER_BUTTON_GUIDE,
+  Start = SDL_CONTROLLER_BUTTON_START,
+  LStick = SDL_CONTROLLER_BUTTON_LEFTSTICK,
+  RStick = SDL_CONTROLLER_BUTTON_RIGHTSTICK,
+  LB = SDL_CONTROLLER_BUTTON_LEFTSHOULDER,
+  RB = SDL_CONTROLLER_BUTTON_RIGHTSHOULDER,
+  DUp = SDL_CONTROLLER_BUTTON_DPAD_UP,
+  DDown = SDL_CONTROLLER_BUTTON_DPAD_DOWN,
+  DLeft = SDL_CONTROLLER_BUTTON_DPAD_LEFT,
+  DRight = SDL_CONTROLLER_BUTTON_DPAD_RIGHT,
+  LT = SDL_CONTROLLER_BUTTON_MAX, // 轴映射
+  RT,                             // 轴映射
+  Count
 };

 /**
- * @brief 手柄轴
+ * @brief 手柄轴（跨平台统一）
+ *
+ * 使用 SDL GameController 轴定义
 */
 enum class GamepadAxis : int {
-    LeftX = 0,
-    LeftY,
-    RightX,
-    RightY,
-    LeftTrigger,
-    RightTrigger,
-    Count
+  LeftX = SDL_CONTROLLER_AXIS_LEFTX,
+  LeftY = SDL_CONTROLLER_AXIS_LEFTY,
+  RightX = SDL_CONTROLLER_AXIS_RIGHTX,
+  RightY = SDL_CONTROLLER_AXIS_RIGHTY,
+  LeftTrigger = SDL_CONTROLLER_AXIS_TRIGGERLEFT,
+  RightTrigger = SDL_CONTROLLER_AXIS_TRIGGERRIGHT,
+  Count
 };

 } // namespace extra2d
--- a/Extra2D/src/event/event.cpp
+++ b/Extra2D/src/event/event.cpp
@ -2,15 +2,6 @@

 namespace extra2d {

-/**
- * @brief 创建窗口大小改变事件
- *
- * 创建一个表示窗口尺寸变化的Event对象
- *
- * @param width 新的窗口宽度（像素）
- * @param height 新的窗口高度（像素）
- * @return 包含窗口大小改变信息的Event对象
- */
 Event Event::createWindowResize(int width, int height) {
  Event event;
  event.type = EventType::WindowResize;
@ -18,115 +9,50 @@ Event Event::createWindowResize(int width, int height) {
  return event;
 }

-/**
- * @brief 创建窗口关闭事件
- *
- * 创建一个表示窗口请求关闭的Event对象
- *
- * @return 表示窗口关闭请求的Event对象
- */
 Event Event::createWindowClose() {
  Event event;
  event.type = EventType::WindowClose;
  return event;
 }

-/**
- * @brief 创建键盘按键按下事件
- *
- * 创建一个表示键盘按键被按下的Event对象
- *
- * @param keyCode 按键码
- * @param scancode 扫描码
- * @param mods 修饰键状态（如Shift、Ctrl等）
- * @return 包含按键按下信息的Event对象
- */
 Event Event::createKeyPress(int keyCode, int scancode, int mods) {
  Event event;
-  event.type = EventType::KeyPressed;
+  event.type = EventType::KeyPress;
  event.data = KeyEvent{keyCode, scancode, mods};
  return event;
 }

-/**
- * @brief 创建键盘按键释放事件
- *
- * 创建一个表示键盘按键被释放的Event对象
- *
- * @param keyCode 按键码
- * @param scancode 扫描码
- * @param mods 修饰键状态（如Shift、Ctrl等）
- * @return 包含按键释放信息的Event对象
- */
 Event Event::createKeyRelease(int keyCode, int scancode, int mods) {
  Event event;
-  event.type = EventType::KeyReleased;
+  event.type = EventType::KeyRelease;
  event.data = KeyEvent{keyCode, scancode, mods};
  return event;
 }

-/**
- * @brief 创建鼠标按钮按下事件
- *
- * 创建一个表示鼠标按钮被按下的Event对象
- *
- * @param button 鼠标按钮编号
- * @param mods 修饰键状态
- * @param pos 鼠标按下时的位置坐标
- * @return 包含鼠标按钮按下信息的Event对象
- */
-Event Event::createMouseButtonPress(int button, int mods, const Vec2 &pos) {
+Event Event::createMousePress(int button, int mods, const Vec2 &pos) {
  Event event;
-  event.type = EventType::MouseButtonPressed;
-  event.data = MouseButtonEvent{button, mods, pos};
+  event.type = EventType::MousePress;
+  event.data = MouseEvent{button, mods, pos};
  return event;
 }

-/**
- * @brief 创建鼠标按钮释放事件
- *
- * 创建一个表示鼠标按钮被释放的Event对象
- *
- * @param button 鼠标按钮编号
- * @param mods 修饰键状态
- * @param pos 鼠标释放时的位置坐标
- * @return 包含鼠标按钮释放信息的Event对象
- */
-Event Event::createMouseButtonRelease(int button, int mods, const Vec2 &pos) {
+Event Event::createMouseRelease(int button, int mods, const Vec2 &pos) {
  Event event;
-  event.type = EventType::MouseButtonReleased;
-  event.data = MouseButtonEvent{button, mods, pos};
+  event.type = EventType::MouseRelease;
+  event.data = MouseEvent{button, mods, pos};
  return event;
 }

-/**
- * @brief 创建鼠标移动事件
- *
- * 创建一个表示鼠标移动的Event对象
- *
- * @param pos 鼠标当前位置坐标
- * @param delta 鼠标移动的位移量
- * @return 包含鼠标移动信息的Event对象
- */
 Event Event::createMouseMove(const Vec2 &pos, const Vec2 &delta) {
  Event event;
-  event.type = EventType::MouseMoved;
+  event.type = EventType::MouseMove;
  event.data = MouseMoveEvent{pos, delta};
  return event;
 }

-/**
- * @brief 创建鼠标滚轮滚动事件
- *
- * 创建一个表示鼠标滚轮滚动的Event对象
- *
- * @param offset 滚轮滚动的偏移量
- * @param pos 滚动时鼠标的位置坐标
- * @return 包含鼠标滚轮滚动信息的Event对象
- */
 Event Event::createMouseScroll(const Vec2 &offset, const Vec2 &pos) {
  Event event;
-  event.type = EventType::MouseScrolled;
+  event.type = EventType::MouseScroll;
  event.data = MouseScrollEvent{offset, pos};
  return event;
 }
--- a/Extra2D/src/platform/backends/sdl2/sdl2_input.cpp
+++ b/Extra2D/src/platform/backends/sdl2/sdl2_input.cpp
@ -82,26 +82,28 @@ void SDL2Input::handleSDLEvent(const SDL_Event& event) {
        }
        
        case SDL_MOUSEBUTTONDOWN: {
-            int btn = event.button.button - 1;
-            if (btn >= 0 && btn < static_cast<int>(Mouse::Count)) {
-                mouseCurrent_[btn] = true;
+            int btn = event.button.button;
+            int idx = btn - 1;
+            if (idx >= 0 && idx < static_cast<int>(Mouse::Count)) {
+                mouseCurrent_[idx] = true;
                
                Vec2 pos{static_cast<float>(event.button.x), 
                        static_cast<float>(event.button.y)};
-                Event e = Event::createMouseButtonPress(btn, 0, pos);
+                Event e = Event::createMousePress(btn, 0, pos);
                dispatchEvent(e);
            }
            break;
        }
        
        case SDL_MOUSEBUTTONUP: {
-            int btn = event.button.button - 1;
-            if (btn >= 0 && btn < static_cast<int>(Mouse::Count)) {
-                mouseCurrent_[btn] = false;
+            int btn = event.button.button;
+            int idx = btn - 1;
+            if (idx >= 0 && idx < static_cast<int>(Mouse::Count)) {
+                mouseCurrent_[idx] = false;
                
                Vec2 pos{static_cast<float>(event.button.x), 
                        static_cast<float>(event.button.y)};
-                Event e = Event::createMouseButtonRelease(btn, 0, pos);
+                Event e = Event::createMouseRelease(btn, 0, pos);
                dispatchEvent(e);
            }
            break;
@ -152,12 +154,12 @@ void SDL2Input::handleSDLEvent(const SDL_Event& event) {
                if (btn >= 0 && btn < static_cast<int>(Gamepad::Count)) {
                    gamepadCurrent_[btn] = true;
                    
-                    GamepadButtonEvent btnEvent;
+                    GamepadEvent btnEvent;
                    btnEvent.gamepadId = gamepadIndex_;
                    btnEvent.button = btn;
                    
                    Event e;
-                    e.type = EventType::GamepadButtonPressed;
+                    e.type = EventType::GamepadPress;
                    e.data = btnEvent;
                    dispatchEvent(e);
                }
@ -170,12 +172,12 @@ void SDL2Input::handleSDLEvent(const SDL_Event& event) {
                if (btn >= 0 && btn < static_cast<int>(Gamepad::Count)) {
                    gamepadCurrent_[btn] = false;
                    
-                    GamepadButtonEvent btnEvent;
+                    GamepadEvent btnEvent;
                    btnEvent.gamepadId = gamepadIndex_;
                    btnEvent.button = btn;
                    
                    Event e;
-                    e.type = EventType::GamepadButtonReleased;
+                    e.type = EventType::GamepadRelease;
                    e.data = btnEvent;
                    dispatchEvent(e);
                }
@ -194,48 +196,51 @@ void SDL2Input::dispatchEvent(const Event& event) {
 }

 bool SDL2Input::down(Key key) const {
-    size_t idx = static_cast<size_t>(key);
-    if (idx < keyCurrent_.size()) {
+    int idx = static_cast<int>(key);
+    if (idx >= 0 && idx < static_cast<int>(Key::Count)) {
        return keyCurrent_[idx];
    }
    return false;
 }

 bool SDL2Input::pressed(Key key) const {
-    size_t idx = static_cast<size_t>(key);
-    if (idx < keyCurrent_.size()) {
+    int idx = static_cast<int>(key);
+    if (idx >= 0 && idx < static_cast<int>(Key::Count)) {
        return keyCurrent_[idx] && !keyPrevious_[idx];
    }
    return false;
 }

 bool SDL2Input::released(Key key) const {
-    size_t idx = static_cast<size_t>(key);
-    if (idx < keyCurrent_.size()) {
+    int idx = static_cast<int>(key);
+    if (idx >= 0 && idx < static_cast<int>(Key::Count)) {
        return !keyCurrent_[idx] && keyPrevious_[idx];
    }
    return false;
 }

 bool SDL2Input::down(Mouse btn) const {
-    size_t idx = static_cast<size_t>(btn);
-    if (idx < mouseCurrent_.size()) {
+    int sdlBtn = static_cast<int>(btn);
+    int idx = sdlBtn - 1;
+    if (idx >= 0 && idx < static_cast<int>(Mouse::Count)) {
        return mouseCurrent_[idx];
    }
    return false;
 }

 bool SDL2Input::pressed(Mouse btn) const {
-    size_t idx = static_cast<size_t>(btn);
-    if (idx < mouseCurrent_.size()) {
+    int sdlBtn = static_cast<int>(btn);
+    int idx = sdlBtn - 1;
+    if (idx >= 0 && idx < static_cast<int>(Mouse::Count)) {
        return mouseCurrent_[idx] && !mousePrevious_[idx];
    }
    return false;
 }

 bool SDL2Input::released(Mouse btn) const {
-    size_t idx = static_cast<size_t>(btn);
-    if (idx < mouseCurrent_.size()) {
+    int sdlBtn = static_cast<int>(btn);
+    int idx = sdlBtn - 1;
+    if (idx >= 0 && idx < static_cast<int>(Mouse::Count)) {
        return !mouseCurrent_[idx] && mousePrevious_[idx];
    }
    return false;
@ -266,24 +271,24 @@ bool SDL2Input::gamepad() const {
 }

 bool SDL2Input::down(Gamepad btn) const {
-    size_t idx = static_cast<size_t>(btn);
-    if (idx < gamepadCurrent_.size()) {
+    int idx = static_cast<int>(btn);
+    if (idx >= 0 && idx < static_cast<int>(Gamepad::Count)) {
        return gamepadCurrent_[idx];
    }
    return false;
 }

 bool SDL2Input::pressed(Gamepad btn) const {
-    size_t idx = static_cast<size_t>(btn);
-    if (idx < gamepadCurrent_.size()) {
+    int idx = static_cast<int>(btn);
+    if (idx >= 0 && idx < static_cast<int>(Gamepad::Count)) {
        return gamepadCurrent_[idx] && !gamepadPrevious_[idx];
    }
    return false;
 }

 bool SDL2Input::released(Gamepad btn) const {
-    size_t idx = static_cast<size_t>(btn);
-    if (idx < gamepadCurrent_.size()) {
+    int idx = static_cast<int>(btn);
+    if (idx >= 0 && idx < static_cast<int>(Gamepad::Count)) {
        return !gamepadCurrent_[idx] && gamepadPrevious_[idx];
    }
    return false;
@ -399,35 +404,11 @@ int SDL2Input::keyToSDL(Key key) {
 }

 int SDL2Input::mouseToSDL(Mouse btn) {
-    switch (btn) {
-        case Mouse::Left: return SDL_BUTTON_LEFT;
-        case Mouse::Middle: return SDL_BUTTON_MIDDLE;
-        case Mouse::Right: return SDL_BUTTON_RIGHT;
-        case Mouse::X1: return SDL_BUTTON_X1;
-        case Mouse::X2: return SDL_BUTTON_X2;
-        default: return 0;
-    }
+    return static_cast<int>(btn);
 }

 int SDL2Input::gamepadToSDL(Gamepad btn) {
-    switch (btn) {
-        case Gamepad::A: return SDL_CONTROLLER_BUTTON_A;
-        case Gamepad::B: return SDL_CONTROLLER_BUTTON_B;
-        case Gamepad::X: return SDL_CONTROLLER_BUTTON_X;
-        case Gamepad::Y: return SDL_CONTROLLER_BUTTON_Y;
-        case Gamepad::Back: return SDL_CONTROLLER_BUTTON_BACK;
-        case Gamepad::Start: return SDL_CONTROLLER_BUTTON_START;
-        case Gamepad::LStick: return SDL_CONTROLLER_BUTTON_LEFTSTICK;
-        case Gamepad::RStick: return SDL_CONTROLLER_BUTTON_RIGHTSTICK;
-        case Gamepad::LB: return SDL_CONTROLLER_BUTTON_LEFTSHOULDER;
-        case Gamepad::RB: return SDL_CONTROLLER_BUTTON_RIGHTSHOULDER;
-        case Gamepad::DUp: return SDL_CONTROLLER_BUTTON_DPAD_UP;
-        case Gamepad::DDown: return SDL_CONTROLLER_BUTTON_DPAD_DOWN;
-        case Gamepad::DLeft: return SDL_CONTROLLER_BUTTON_DPAD_LEFT;
-        case Gamepad::DRight: return SDL_CONTROLLER_BUTTON_DPAD_RIGHT;
-        case Gamepad::Guide: return SDL_CONTROLLER_BUTTON_GUIDE;
-        default: return 0;
-    }
+    return static_cast<int>(btn);
 }

 Key SDL2Input::sdlToKey(int sdlKey) {
@ -438,14 +419,7 @@ Key SDL2Input::sdlToKey(int sdlKey) {
 }

 Mouse SDL2Input::sdlToMouse(int sdlButton) {
-    switch (sdlButton) {
-        case SDL_BUTTON_LEFT: return Mouse::Left;
-        case SDL_BUTTON_MIDDLE: return Mouse::Middle;
-        case SDL_BUTTON_RIGHT: return Mouse::Right;
-        case SDL_BUTTON_X1: return Mouse::X1;
-        case SDL_BUTTON_X2: return Mouse::X2;
-        default: return Mouse::Count;
-    }
+    return static_cast<Mouse>(sdlButton);
 }

 } 
--- a/Extra2D/src/scene/scene_manager.cpp
+++ b/Extra2D/src/scene/scene_manager.cpp
@ -793,12 +793,12 @@ void SceneManager::dispatchPointerEvents(Scene &scene) {
  if (input.pressed(Mouse::Left)) {
    captureTarget_ = hoverTarget_;
    if (captureTarget_) {
-      Event evt = Event::createMouseButtonPress(static_cast<int>(Mouse::Left),
-                                                0, worldPos);
+      Event evt =
+          Event::createMousePress(static_cast<int>(Mouse::Left), 0, worldPos);
      dispatchToNode(captureTarget_, evt);

      Event pressed;
-      pressed.type = EventType::UIPressed;
+      pressed.type = EventType::UIPress;
      pressed.data = CustomEvent{0, captureTarget_};
      dispatchToNode(captureTarget_, pressed);
    }
@ -807,19 +807,19 @@ void SceneManager::dispatchPointerEvents(Scene &scene) {
  if (input.released(Mouse::Left)) {
    Node *target = captureTarget_ ? captureTarget_ : hoverTarget_;
    if (target) {
-      Event evt = Event::createMouseButtonRelease(static_cast<int>(Mouse::Left),
-                                                  0, worldPos);
+      Event evt =
+          Event::createMouseRelease(static_cast<int>(Mouse::Left), 0, worldPos);
      dispatchToNode(target, evt);

      Event released;
-      released.type = EventType::UIReleased;
+      released.type = EventType::UIRelease;
      released.data = CustomEvent{0, target};
      dispatchToNode(target, released);
    }

    if (captureTarget_ && captureTarget_ == hoverTarget_) {
      Event clicked;
-      clicked.type = EventType::UIClicked;
+      clicked.type = EventType::UIClick;
      clicked.data = CustomEvent{0, captureTarget_};
      dispatchToNode(captureTarget_, clicked);
    }
@ -830,7 +830,6 @@ void SceneManager::dispatchPointerEvents(Scene &scene) {
  lastPointerWorld_ = worldPos;
 }

-void SceneManager::doSceneSwitch() {
-}
+void SceneManager::doSceneSwitch() {}

 } // namespace extra2d
--- a/README.md
+++ b/README.md
@ -25,7 +25,7 @@
  <i>高性能、模块化、支持 Nintendo Switch</i>
 </p>

-[构建指南](#构建指南) | [快速开始](#快速开始) | [示例程序](#示例程序) | [模块系统](./docs/module_system.md)
+[构建指南](#构建指南) | [快速开始](./docs/quick_start.md) | [示例程序](#示例程序) | [模块系统](./docs/module_system.md)

 </div>

@ -316,7 +316,7 @@ root->addChild(child);
 auto eventService = app.events();

 // 键盘事件
-eventService->addListener(EventType::KeyPressed, [](Event& e) {
+eventService->addListener(EventType::KeyPress, [](Event& e) {
    auto& key = std::get<KeyEvent>(e.data);
    if (key.keyCode == static_cast<int>(Key::Escape)) {
        Application::get().quit();
@ -324,14 +324,14 @@ eventService->addListener(EventType::KeyPressed, [](Event& e) {
 });

 // 鼠标事件
-eventService->addListener(EventType::MouseButtonPressed, [](Event& e) {
-    auto& mouse = std::get<MouseButtonEvent>(e.data);
+eventService->addListener(EventType::MousePress, [](Event& e) {
+    auto& mouse = std::get<MouseEvent>(e.data);
    // 处理鼠标点击
 });

 // 手柄事件
-eventService->addListener(EventType::GamepadButtonPressed, [](Event& e) {
-    auto& gamepad = std::get<GamepadButtonEvent>(e.data);
+eventService->addListener(EventType::GamepadPress, [](Event& e) {
+    auto& gamepad = std::get<GamepadEvent>(e.data);
    // 处理手柄输入
 });
 ```
--- a/docs/module_system.md
+++ b/docs/module_system.md
@ -445,7 +445,7 @@ timerService->addTimer(1.0f, []() {
 });

 // 使用事件服务
-eventService->addListener(extra2d::EventType::KeyPressed, [](extra2d::Event& e) {
+eventService->addListener(extra2d::EventType::KeyPress, [](extra2d::Event& e) {
    auto& keyEvent = std::get<extra2d::KeyEvent>(e.data);
    E2D_LOG_INFO("Key pressed: {}", keyEvent.keyCode);
 });
@ -460,26 +460,26 @@ eventService->addListener(extra2d::EventType::KeyPressed, [](extra2d::Event& e)
 ```cpp
 enum class EventType {
    // 键盘
-    KeyPressed,
-    KeyReleased,
+    KeyPress,
+    KeyRelease,
    KeyRepeat,
    
    // 鼠标
-    MouseButtonPressed,
-    MouseButtonReleased,
-    MouseMoved,
-    MouseScrolled,
+    MousePress,
+    MouseRelease,
+    MouseMove,
+    MouseScroll,
    
    // 手柄
-    GamepadConnected,
-    GamepadDisconnected,
-    GamepadButtonPressed,
-    GamepadButtonReleased,
+    GamepadConnect,
+    GamepadDisconnect,
+    GamepadPress,
+    GamepadRelease,
    
    // 触摸
-    TouchBegan,
-    TouchMoved,
-    TouchEnded,
+    TouchBegin,
+    TouchMove,
+    TouchEnd,
    
    // 窗口
    WindowResize,
@ -493,7 +493,7 @@ enum class EventType {
 auto eventService = app.events();

 // 监听键盘事件
-eventService->addListener(EventType::KeyPressed, [](Event& e) {
+eventService->addListener(EventType::KeyPress, [](Event& e) {
    auto& key = std::get<KeyEvent>(e.data);
    if (key.keyCode == static_cast<int>(Key::Escape)) {
        Application::get().quit();
@ -501,8 +501,8 @@ eventService->addListener(EventType::KeyPressed, [](Event& e) {
 });

 // 监听鼠标事件
-eventService->addListener(EventType::MouseButtonPressed, [](Event& e) {
-    auto& mouse = std::get<MouseButtonEvent>(e.data);
+eventService->addListener(EventType::MousePress, [](Event& e) {
+    auto& mouse = std::get<MouseEvent>(e.data);
    E2D_LOG_INFO("Click at ({}, {})", mouse.position.x, mouse.position.y);
 });
 ```
--- a/docs/quick_start.md
+++ b/docs/quick_start.md
@ -311,7 +311,7 @@ public:
        Scene::onEnter();
        
        // 键盘事件
-        addListener(EventType::KeyPressed, [](Event& e) {
+        addListener(EventType::KeyPress, [](Event& e) {
            auto& key = std::get<KeyEvent>(e.data);
            
            if (key.keyCode == static_cast<int>(Key::Escape)) {
@ -325,14 +325,14 @@ public:
        });
        
        // 鼠标事件
-        addListener(EventType::MouseButtonPressed, [](Event& e) {
-            auto& mouse = std::get<MouseButtonEvent>(e.data);
+        addListener(EventType::MousePress, [](Event& e) {
+            auto& mouse = std::get<MouseEvent>(e.data);
            E2D_LOG_INFO("Click at ({}, {})", mouse.position.x, mouse.position.y);
        });
        
        // 手柄事件
-        addListener(EventType::GamepadButtonPressed, [](Event& e) {
-            auto& gamepad = std::get<GamepadButtonEvent>(e.data);
+        addListener(EventType::GamepadPress, [](Event& e) {
+            auto& gamepad = std::get<GamepadEvent>(e.data);
            E2D_LOG_INFO("Gamepad button: {}", gamepad.button);
        });
    }
--- a/examples/basic/main.cpp
+++ b/examples/basic/main.cpp
@ -122,7 +122,7 @@ int main(int argc, char *argv[]) {

  auto eventService = app.events();
  if (eventService) {
-    eventService->addListener(EventType::KeyPressed, [](Event &e) {
+    eventService->addListener(EventType::KeyPress, [](Event &e) {
      auto &keyEvent = std::get<KeyEvent>(e.data);

      if (keyEvent.keyCode == static_cast<int>(Key::Escape)) {
@ -131,8 +131,8 @@ int main(int argc, char *argv[]) {
      }
    });

-    eventService->addListener(EventType::MouseButtonPressed, [](Event &e) {
-      auto &mouseEvent = std::get<MouseButtonEvent>(e.data);
+    eventService->addListener(EventType::MousePress, [](Event &e) {
+      auto &mouseEvent = std::get<MouseEvent>(e.data);
      std::cout << "[Click] Button " << mouseEvent.button << " at ("
                << mouseEvent.position.x << ", " << mouseEvent.position.y << ")"
                << std::endl;
--- a/examples/hello_module/main.cpp
+++ b/examples/hello_module/main.cpp
@ -14,7 +14,7 @@ public:

  void onEnter() override {
    Scene::onEnter();
-    addListener(EventType::KeyPressed, [](Event &e) {
+    addListener(EventType::KeyPress, [](Event &e) {
      auto &keyEvent = std::get<KeyEvent>(e.data);

      if (keyEvent.keyCode == static_cast<int>(Key::Escape)) {