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

- 将事件类型命名从过去式改为现在式（如KeyPressed→KeyPress）
- 合并鼠标事件数据结构，使用统一的MouseEvent替代MouseButtonEvent
- 重构输入系统，使用SDL原生枚举值简化键位映射
- 更新相关文档和示例代码以匹配新的命名规范

Extra2D/include/extra2d/event/event.h

@@ -17,39 +17,39 @@ enum class EventType {
   WindowClose,
   WindowResize,
   WindowFocus,
-  WindowLostFocus,
+  WindowBlur,
-  WindowMoved,
+  WindowMove,
 
   // 键盘事件
-  KeyPressed,
+  KeyPress,
-  KeyReleased,
+  KeyRelease,
   KeyRepeat,
 
   // 鼠标事件
-  MouseButtonPressed,
+  MousePress,
-  MouseButtonReleased,
+  MouseRelease,
-  MouseMoved,
+  MouseMove,
-  MouseScrolled,
+  MouseScroll,
 
   // UI 事件
   UIHoverEnter,
   UIHoverExit,
-  UIPressed,
+  UIPress,
-  UIReleased,
+  UIRelease,
-  UIClicked,
+  UIClick,
 
   // 游戏手柄事件
-  GamepadConnected,
+  GamepadConnect,
-  GamepadDisconnected,
+  GamepadDisconnect,
-  GamepadButtonPressed,
+  GamepadPress,
-  GamepadButtonReleased,
+  GamepadRelease,
-  GamepadAxisMoved,
+  GamepadAxis,
 
   // 触摸事件 (移动端)
-  TouchBegan,
+  TouchBegin,
-  TouchMoved,
+  TouchMove,
-  TouchEnded,
+  TouchEnd,
-  TouchCancelled,
+  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, MouseEvent, MouseMoveEvent,
-  std::variant<std::monostate, KeyEvent, MouseButtonEvent, 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::WindowFocus || type == EventType::WindowBlur ||
-           type == EventType::WindowLostFocus || type == EventType::WindowMoved;
+           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 ||
+    return type == EventType::MousePress || type == EventType::MouseRelease ||
-           type == EventType::MouseButtonReleased ||
+           type == EventType::MouseMove || type == EventType::MouseScroll;
-           type == EventType::MouseMoved || type == EventType::MouseScrolled;
   }
 
-  // 静态工厂方法
   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 createMousePress(int button, int mods, const Vec2 &pos);
-  static Event createMouseButtonRelease(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);
 };

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,
+  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,
+  A = SDL_SCANCODE_A,
-    Num5, Num6, Num7, Num8, Num9,
+  B = SDL_SCANCODE_B,
-    F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12,
+  C = SDL_SCANCODE_C,
-    Space, Enter, Escape, Tab, Backspace,
+  D = SDL_SCANCODE_D,
-    Insert, Delete, Home, End, PageUp, PageDown,
+  E = SDL_SCANCODE_E,
-    Up, Down, Left, Right,
+  F = SDL_SCANCODE_F,
-    LShift, RShift, LCtrl, RCtrl, LAlt, RAlt,
+  G = SDL_SCANCODE_G,
-    CapsLock, NumLock, ScrollLock,
+  H = SDL_SCANCODE_H,
-    Count
+  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,
+  Left = SDL_BUTTON_LEFT,
-    Right,
+  Middle = SDL_BUTTON_MIDDLE,
-    Middle,
+  Right = SDL_BUTTON_RIGHT,
-    X1,
+  X1 = SDL_BUTTON_X1,
-    X2,
+  X2 = SDL_BUTTON_X2,
-    Count
+  Count
 };
 
 /**
- * @brief 游戏手柄按钮
+ * @brief 游戏手柄按钮（跨平台统一）
+ *
+ * 使用 SDL GameController 按钮定义
  */
 enum class Gamepad : int {
-    A = 0,
+  A = SDL_CONTROLLER_BUTTON_A,
-    B,
+  B = SDL_CONTROLLER_BUTTON_B,
-    X,
+  X = SDL_CONTROLLER_BUTTON_X,
-    Y,
+  Y = SDL_CONTROLLER_BUTTON_Y,
-    LB,
+  Back = SDL_CONTROLLER_BUTTON_BACK,
-    RB,
+  Guide = SDL_CONTROLLER_BUTTON_GUIDE,
-    LT,
+  Start = SDL_CONTROLLER_BUTTON_START,
-    RT,
+  LStick = SDL_CONTROLLER_BUTTON_LEFTSTICK,
-    Back,
+  RStick = SDL_CONTROLLER_BUTTON_RIGHTSTICK,
-    Start,
+  LB = SDL_CONTROLLER_BUTTON_LEFTSHOULDER,
-    Guide,
+  RB = SDL_CONTROLLER_BUTTON_RIGHTSHOULDER,
-    LStick,
+  DUp = SDL_CONTROLLER_BUTTON_DPAD_UP,
-    RStick,
+  DDown = SDL_CONTROLLER_BUTTON_DPAD_DOWN,
-    DUp,
+  DLeft = SDL_CONTROLLER_BUTTON_DPAD_LEFT,
-    DDown,
+  DRight = SDL_CONTROLLER_BUTTON_DPAD_RIGHT,
-    DLeft,
+  LT = SDL_CONTROLLER_BUTTON_MAX, // 轴映射
-    DRight,
+  RT,                             // 轴映射
-    Count
+  Count
 };
 
 /**
- * @brief 手柄轴
+ * @brief 手柄轴（跨平台统一）
+ *
+ * 使用 SDL GameController 轴定义
  */
 enum class GamepadAxis : int {
-    LeftX = 0,
+  LeftX = SDL_CONTROLLER_AXIS_LEFTX,
-    LeftY,
+  LeftY = SDL_CONTROLLER_AXIS_LEFTY,
-    RightX,
+  RightX = SDL_CONTROLLER_AXIS_RIGHTX,
-    RightY,
+  RightY = SDL_CONTROLLER_AXIS_RIGHTY,
-    LeftTrigger,
+  LeftTrigger = SDL_CONTROLLER_AXIS_TRIGGERLEFT,
-    RightTrigger,
+  RightTrigger = SDL_CONTROLLER_AXIS_TRIGGERRIGHT,
-    Count
+  Count
 };
 
 } // namespace extra2d

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

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;
+            int btn = event.button.button;
-            if (btn >= 0 && btn < static_cast<int>(Mouse::Count)) {
+            int idx = btn - 1;
-                mouseCurrent_[btn] = true;
+            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;
+            int btn = event.button.button;
-            if (btn >= 0 && btn < static_cast<int>(Mouse::Count)) {
+            int idx = btn - 1;
-                mouseCurrent_[btn] = false;
+            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);
+    int idx = static_cast<int>(key);
-    if (idx < keyCurrent_.size()) {
+    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);
+    int idx = static_cast<int>(key);
-    if (idx < keyCurrent_.size()) {
+    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);
+    int idx = static_cast<int>(key);
-    if (idx < keyCurrent_.size()) {
+    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);
+    int sdlBtn = static_cast<int>(btn);
-    if (idx < mouseCurrent_.size()) {
+    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);
+    int sdlBtn = static_cast<int>(btn);
-    if (idx < mouseCurrent_.size()) {
+    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);
+    int sdlBtn = static_cast<int>(btn);
-    if (idx < mouseCurrent_.size()) {
+    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);
+    int idx = static_cast<int>(btn);
-    if (idx < gamepadCurrent_.size()) {
+    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);
+    int idx = static_cast<int>(btn);
-    if (idx < gamepadCurrent_.size()) {
+    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);
+    int idx = static_cast<int>(btn);
-    if (idx < gamepadCurrent_.size()) {
+    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) {
+    return static_cast<int>(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;
-    }
 }
 
 int SDL2Input::gamepadToSDL(Gamepad btn) {
-    switch (btn) {
+    return static_cast<int>(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;
-    }
 }
 
 Key SDL2Input::sdlToKey(int sdlKey) {
@@ -438,14 +419,7 @@ Key SDL2Input::sdlToKey(int sdlKey) {
 }
 
 Mouse SDL2Input::sdlToMouse(int sdlButton) {
-    switch (sdlButton) {
+    return static_cast<Mouse>(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;
-    }
 }
 
 } 

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),
+      Event evt =
-                                                0, worldPos);
+          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),
+      Event evt =
-                                                  0, worldPos);
+          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

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) {
+eventService->addListener(EventType::MousePress, [](Event& e) {
-    auto& mouse = std::get<MouseButtonEvent>(e.data);
+    auto& mouse = std::get<MouseEvent>(e.data);
     // 处理鼠标点击
 });
 
 // 手柄事件
-eventService->addListener(EventType::GamepadButtonPressed, [](Event& e) {
+eventService->addListener(EventType::GamepadPress, [](Event& e) {
-    auto& gamepad = std::get<GamepadButtonEvent>(e.data);
+    auto& gamepad = std::get<GamepadEvent>(e.data);
     // 处理手柄输入
 });
 ```

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,
+    KeyPress,
-    KeyReleased,
+    KeyRelease,
     KeyRepeat,
     
     // 鼠标
-    MouseButtonPressed,
+    MousePress,
-    MouseButtonReleased,
+    MouseRelease,
-    MouseMoved,
+    MouseMove,
-    MouseScrolled,
+    MouseScroll,
     
     // 手柄
-    GamepadConnected,
+    GamepadConnect,
-    GamepadDisconnected,
+    GamepadDisconnect,
-    GamepadButtonPressed,
+    GamepadPress,
-    GamepadButtonReleased,
+    GamepadRelease,
     
     // 触摸
-    TouchBegan,
+    TouchBegin,
-    TouchMoved,
+    TouchMove,
-    TouchEnded,
+    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) {
+eventService->addListener(EventType::MousePress, [](Event& e) {
-    auto& mouse = std::get<MouseButtonEvent>(e.data);
+    auto& mouse = std::get<MouseEvent>(e.data);
     E2D_LOG_INFO("Click at ({}, {})", mouse.position.x, mouse.position.y);
 });
 ```

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) {
+        addListener(EventType::MousePress, [](Event& e) {
-            auto& mouse = std::get<MouseButtonEvent>(e.data);
+            auto& mouse = std::get<MouseEvent>(e.data);
             E2D_LOG_INFO("Click at ({}, {})", mouse.position.x, mouse.position.y);
         });
         
         // 手柄事件
-        addListener(EventType::GamepadButtonPressed, [](Event& e) {
+        addListener(EventType::GamepadPress, [](Event& e) {
-            auto& gamepad = std::get<GamepadButtonEvent>(e.data);
+            auto& gamepad = std::get<GamepadEvent>(e.data);
             E2D_LOG_INFO("Gamepad button: {}", gamepad.button);
         });
     }

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) {
+    eventService->addListener(EventType::MousePress, [](Event &e) {
-      auto &mouseEvent = std::get<MouseButtonEvent>(e.data);
+      auto &mouseEvent = std::get<MouseEvent>(e.data);
       std::cout << "[Click] Button " << mouseEvent.button << " at ("
                 << mouseEvent.position.x << ", " << mouseEvent.position.y << ")"
                 << std::endl;

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)) {