Unity WebGL输入系统架构设计与实战优化指南

1. 项目概述：WebGL输入为何是块“硬骨头”

如果你做过Unity WebGL项目，肯定对输入问题深有体会。在PC或移动端原生平台上，Input.GetKey、Input.GetMouseButton这些API用起来行云流水，但一旦发布到WebGL，在浏览器里运行，各种幺蛾子就来了：鼠标点击没反应、键盘输入延迟、手柄识别不了，甚至触摸事件直接“失踪”。这感觉就像你开着一辆顶级跑车上了沙石路，引擎再好也使不上劲。问题的根源，就在于浏览器这个“沙箱”环境。它为了安全，对JavaScript的访问权限做了层层限制，Unity引擎那套直接与操作系统交互的输入系统在这里水土不服。我们做的，就是在这片“沙地”上，重新铺一条能让跑车全速前进的“柏油路”——构建一套稳定、高效且跨浏览器兼容的WebGL输入解决方案。这不仅仅是调用几个JavaScript接口那么简单，它涉及到事件捕获、焦点管理、性能优化和异常处理等一系列技术实践，目标是在浏览器的限制下，为用户提供尽可能接近原生体验的交互响应。

2. 浏览器环境下的输入限制深度解析

要解决问题，得先看清问题的全貌。浏览器对输入的限制是系统性的，理解这些限制是设计解决方案的基础。

2.1 事件循环与线程模型差异

在原生平台（如Windows、macOS应用），Unity运行在独立的应用程序进程中，拥有自己的消息循环，可以直接、即时地接收来自操作系统的硬件输入消息。这是一个“推”模型：事件一旦发生，操作系统立刻通知应用。

而在WebGL中，Unity代码是作为WebAssembly模块运行在浏览器的渲染进程里。浏览器采用单线程事件循环模型，所有JavaScript（包括我们的Unity代码）执行、DOM事件处理、页面渲染都共享同一个主线程。输入事件（如mousedown、keydown）首先由浏览器内核捕获，放入事件队列，然后才在事件循环的某个时机被分发给对应的DOM元素。这是一个“拉”或“轮询”模型，存在固有的延迟。更关键的是，当Unity正在执行一段密集的C#逻辑（比如复杂的物理计算或AI寻路）时，它会“阻塞”主线程，导致浏览器无法及时处理新到达的输入事件，从而造成输入卡顿或丢失。这是WebGL输入延迟和响应不跟手的根本原因之一。

2.2 焦点与安全策略限制

浏览器有严格的焦点策略。一个输入事件（尤其是键盘事件）通常只对当前获得焦点的DOM元素有效。Unity WebGL的Canvas元素必须显式地获得焦点，才能接收键盘输入。如果用户点击了页面其他部分（比如一个广告或浏览器地址栏），Canvas就会失去焦点，所有键盘输入都会失效，直到用户再次点击Canvas。此外，一些按键（如F1-F12、Alt+F4、Ctrl+W等）会被浏览器保留为快捷键，无法被页面脚本捕获，这是出于安全考虑，防止恶意网页劫持用户浏览器。

另一个安全限制是“弹出式阻止”和“自动播放策略”。例如，Audio的播放和某些全屏API的调用，必须由“用户手势”（如click、touchstart）直接触发。如果你的游戏试图在加载完成后自动播放背景音乐，或者通过脚本而非用户点击来触发全屏，很可能会被浏览器静默阻止。

2.3 输入设备API的异构性与不完整性

• 鼠标/触摸：相对统一，但存在坐标系统转换问题。浏览器提供的鼠标事件坐标是基于整个文档或视口的，而Unity需要的是相对于Canvas左上角的坐标。触摸事件在移动端浏览器上支持较好，但不同浏览器对多点触控（如touches数组）的实现细节有微小差异。
• 键盘：keydown/keyup事件提供的keyCode和code属性在不同浏览器、不同键盘布局（如QWERTY vs AZERTY）下可能不一致。处理方向键、功能键时尤其需要注意。
• 游戏手柄：情况最复杂。浏览器通过Gamepad API提供支持，但该API的普及度和一致性远不如鼠标键盘。旧版Edge、Safari的支持度 historically 较差。而且，手柄的轮询（navigator.getGamepads()）需要主动进行，而非事件驱动，这增加了输入采集的复杂度。
• 移动端传感器：如陀螺仪、加速度计，需要通过DeviceOrientation和DeviceMotion事件获取，这些API需要HTTPS环境，且在iOS上权限请求更为严格。

注意：不要假设所有用户的浏览器都支持最新的输入API。在代码中必须进行特性检测（if (‘getGamepads’ in navigator)），并提供优雅降级方案，例如当手柄不支持时，提示用户使用键盘鼠标。

3. 核心解决方案架构设计

面对上述限制，一个鲁棒的WebGL输入解决方案不能是零散的补丁，而应该是一个有层次、可扩展的架构。我们的设计核心是：在浏览器层建立统一的事件网关，在Unity层重构输入抽象。

3.1 分层架构：从DOM事件到Unity Input

我们将系统分为三层：

1. JavaScript事件监听层：作为最底层，直接附着在Canvas DOM元素上，负责捕获所有原始的浏览器输入事件（鼠标、键盘、触摸、手柄轮询）。它的职责是“收集”和“标准化”，将不同浏览器、不同设备的事件数据，转换成一套内部统一的、简单的数据结构。
2. C#/WebAssembly桥接层：这是连接JS和C#的关键。我们利用Unity WebGL提供的[DllImport(“__Internal”)]机制，将JavaScript层收集到的标准化输入数据，通过C函数调用，高效地传递到C#的托管内存中。这里要避免频繁的跨语言调用，通常采用每帧同步一次“输入状态快照”的方式。
3. Unity输入抽象层：在C#中，我们创建一个WebGLInputManager单例类。它从桥接层获取输入状态快照，并向上提供一套与Unity原生Input类高度相似的API接口，例如GetKey(KeyCode),GetMouseButton,GetAxis等。游戏逻辑代码几乎无需修改，只需将Input.xxx替换为WebGLInputManager.Instance.xxx。这一层还负责处理输入逻辑，如按键重复、摇杆死区、输入组合键等。

3.2 焦点管理与自动恢复策略

Canvas失去焦点是WebGL游戏体验的“杀手”。我们的策略是主动管理+友好提示。

• 主动获取焦点：在Canvas的onClick和onTouchStart事件处理函数中，主动调用canvas.focus()。确保用户一旦与游戏交互，Canvas就能拿到焦点。
• 焦点状态监听：通过监听window的blur和focus事件，我们可以知道整个页面是否被切换。当页面失去焦点时，可以自动暂停游戏逻辑或释放所有按键状态，防止出现“按键卡住”的幽灵输入。
• 视觉反馈：当Canvas失去焦点时（例如用户点击了别处），在游戏画面上叠加一个半透明的提示层，写着“点击画面继续游戏”。这比让用户茫然地狂按键盘要友好得多。当用户点击提示层时，再次触发canvas.focus()并恢复游戏。

3.3 性能优化：输入事件节流与按需轮询

性能是WebGL的生命线，输入系统不能成为瓶颈。

• 高频事件节流：mousemove事件触发频率极高。我们不应每个mousemove都同步到Unity。可以在JS层设置一个阈值，比如每16ms（约60FPS的一帧时间）才将最新的鼠标位置同步一次，或者只在鼠标位置实际发生变化时才同步。
• 游戏手柄按需轮询：游戏手柄API需要主动轮询。我们不应该在每一帧都无条件地调用navigator.getGamepads()。可以设置一个标志位，只有当至少一个手柄按钮或轴在过去一段时间内被激活过，才开启高频轮询；否则，切换到低频轮询（比如每秒一次）以节省性能。
• 输入缓冲区：在JS层维护一个小型的输入事件缓冲区。当Unity主线程因故繁忙，未能及时处理上一帧的输入时，缓冲区可以保留最近几帧的输入状态，避免输入丢失。当Unity恢复后，可以消费缓冲区中的事件，虽然可能带来一些延迟，但比直接丢失输入要好。

4. 关键模块实现细节与代码剖析

理论说再多，不如看代码。下面我们深入几个关键模块的实现。

4.1 JavaScript事件网关实现

这是整个系统的“哨兵”。我们创建一个WebGLInputBridge.js文件，并作为插件引入Unity项目（放在Assets/Plugins/WebGL目录下）。

// WebGLInputBridge.js var WebGLInputBridge = { // 输入状态存储对象 inputState: { mouseX: 0, mouseY: 0, mouseButtons: [0, 0, 0], // 左、中、右 keyStates: {}, // 键码 -> 按下状态 (1按下，0释放) touchPoints: [], // {id, x, y} gamepadStates: [] // 简化表示 }, // 初始化：绑定事件到Canvas Init: function(canvasId) { var canvas = document.getElementById(canvasId); if (!canvas) return; // 鼠标事件 canvas.addEventListener(‘mousedown’, this._onMouseDown.bind(this)); canvas.addEventListener(‘mousemove’, this._onMouseMove.bind(this)); canvas.addEventListener(‘mouseup’, this._onMouseUp.bind(this)); // 注意：mouseleave也需要处理，用于清除状态 canvas.addEventListener(‘mouseleave’, this._onMouseLeave.bind(this)); // 键盘事件 - 绑定到window，确保全局捕获（需注意焦点） window.addEventListener(‘keydown’, this._onKeyDown.bind(this)); window.addEventListener(‘keyup’, this._onKeyUp.bind(this)); // 触摸事件 canvas.addEventListener(‘touchstart’, this._onTouchStart.bind(this), {passive: false}); canvas.addEventListener(‘touchmove’, this._onTouchMove.bind(this), {passive: false}); canvas.addEventListener(‘touchend’, this._onTouchEnd.bind(this)); // 焦点事件 canvas.addEventListener(‘click’, function() { this.focus(); }); window.addEventListener(‘blur’, this._onWindowBlur.bind(this)); // 游戏手柄轮询开始 this._gamepadPollInterval = setInterval(this._pollGamepads.bind(this), 16); // ~60Hz }, _onMouseDown: function(event) { var buttonIndex = event.button; // 0:左键, 1:中键, 2:右键 if (buttonIndex >= 0 && buttonIndex < this.inputState.mouseButtons.length) { this.inputState.mouseButtons[buttonIndex] = 1; } event.preventDefault(); // 防止浏览器默认行为（如拖拽选中文字） }, _onKeyDown: function(event) { // 使用 code 属性，它代表物理按键位置，比 keyCode 更稳定 this.inputState.keyStates[event.code] = 1; // 阻止浏览器快捷键，但要小心！不要阻止Ctrl+R等常用键。 if ([‘F1’, ‘F5’, ‘Tab’].includes(event.code)) { event.preventDefault(); } }, _pollGamepads: function() { if (!navigator.getGamepads) return; var gamepads = navigator.getGamepads(); this.inputState.gamepadStates = []; for (var i = 0; i < gamepads.length; ++i) { var gp = gamepads[i]; if (gp) { this.inputState.gamepadStates[i] = { buttons: gp.buttons.map(b => b.pressed ? 1 : 0), axes: gp.axes.slice() // 复制数组 }; } } }, // 提供给C#调用的接口，用于获取状态快照 GetInputState: function() { // 这里需要将复杂的inputState对象序列化为一个C#能理解的简单格式。 // 一种常见做法是拼接成字符串，或者通过Emscripten的堆内存传递。 // 为简化示例，我们假设通过一个预分配的内存区域来拷贝数据。 // 实际项目中，你可能需要使用 Module._malloc 和 HEAPU8.set 来操作。 return this.inputState; // 实际传递需要序列化 }, // 清理 Destroy: function() { clearInterval(this._gamepadPollInterval); // ... 移除所有事件监听器 } }; // 自动初始化（当脚本加载时，找到Unity生成的Canvas） (function() { // Unity生成的Canvas通常id为‘unity-canvas‘ setTimeout(function() { WebGLInputBridge.Init(‘unity-canvas‘); }, 1000); })();

实操心得：在绑定触摸事件时，设置{passive: false}至关重要。这允许我们在事件处理函数中调用preventDefault()，从而阻止浏览器的默认滚动行为，实现流畅的触摸控制。否则，在触摸拖动时页面会跟着滚动，体验极差。

4.2 C#桥接与状态同步

在Unity C#端，我们需要通过[DllImport]与JS函数通信，并管理输入状态。

// WebGLInputProvider.cs using System; using System.Runtime.InteropServices; using UnityEngine; public class WebGLInputProvider : MonoBehaviour { // 导入JS函数 [DllImport(“__Internal”)] private static extern void WebGLInputBridge_Init(string canvasId); [DllImport(“__Internal”)] private static extern string WebGLInputBridge_GetInputStateJSON(); // 假设JS返回JSON字符串 // 内部输入状态结构 [System.Serializable] // 用于JSON解析 private struct BridgeInputState { public float mouseX; public float mouseY; public int[] mouseButtons; // 注意：Dictionary在JSON中处理较复杂，这里简化为数组，实际项目需更严谨设计 // public Dictionary<string, int> keyStates; public string[] pressedKeys; // 改为传递当前按下的键码数组 public TouchPoint[] touches; public GamepadState[] gamepads; } private BridgeInputState _currentState; private BridgeInputState _previousState; void Start() { // 只在WebGL平台运行此逻辑 if (Application.platform == RuntimePlatform.WebGLPlayer) { WebGLInputBridge_Init(“unity-canvas”); DontDestroyOnLoad(this.gameObject); // 常驻场景 } else { Debug.LogWarning(“WebGLInputProvider is only for WebGL platform.”); this.enabled = false; } } void Update() { if (Application.platform != RuntimePlatform.WebGLPlayer) return; // 保存上一帧状态，用于检测“按下瞬间”等事件 _previousState = _currentState; // 从JS桥接层获取最新状态 string jsonState = WebGLInputBridge_GetInputStateJSON(); if (!string.IsNullOrEmpty(jsonState)) { try { _currentState = JsonUtility.FromJson<BridgeInputState>(jsonState); } catch (Exception e) { Debug.LogError($“Failed to parse input state JSON: {e.Message}”); } } // 在这里，可以将_currentState的数据，转换并填充到WebGLInputManager中 // 例如：更新按键、鼠标、触摸等状态 ProcessKeyboardState(); ProcessMouseState(); ProcessTouchState(); } private void ProcessKeyboardState() { // 示例：检测KeyCode.Space是否在本帧被按下 // 需要将JS传来的“Space”字符串映射到Unity的KeyCode // 这里需要一个映射表 // bool spacePressedThisFrame = Array.Exists(_currentState.pressedKeys, k => k == “Space”); // bool spacePressedLastFrame = Array.Exists(_previousState.pressedKeys, k => k == “Space”); // bool spaceDown = spacePressedThisFrame && !spacePressedLastFrame; // WebGLInputManager.Instance.SetKey(KeyCode.Space, spaceDown, spacePressedThisFrame); } // ... 其他处理方法 }

4.3 Unity输入抽象层封装

这是给游戏逻辑使用的门面（Facade）。

// WebGLInputManager.cs using UnityEngine; public class WebGLInputManager : MonoBehaviour { public static WebGLInputManager Instance { get; private set; } // 内部状态存储 private bool[] _mouseButtonDown = new bool[3]; private bool[] _mouseButton = new bool[3]; private bool[] _mouseButtonUp = new bool[3]; private Vector2 _mousePosition; private Vector2 _mouseScrollDelta; // 键盘状态，使用Dictionary<KeyCode, State>更高效 private System.Collections.Generic.Dictionary<KeyCode, KeyState> _keyboardState = new System.Collections.Generic.Dictionary<KeyCode, KeyState>(); private struct KeyState { public bool down; // 当前帧按下 public bool hold; // 当前帧按住 public bool up; // 当前帧释放 } void Awake() { if (Instance != null && Instance != this) { Destroy(this.gameObject); return; } Instance = this; DontDestroyOnLoad(this.gameObject); } void Update() { // 每帧开始，清除“down”和“up”这种瞬时状态 foreach (var key in _keyboardState.Keys) { var state = _keyboardState[key]; state.down = false; state.up = false; _keyboardState[key] = state; } for (int i = 0; i < 3; i++) { _mouseButtonDown[i] = false; _mouseButtonUp[i] = false; } _mouseScrollDelta = Vector2.zero; // 然后，由WebGLInputProvider调用SetXXX方法来设置本帧的状态 } // 供WebGLInputProvider调用的内部方法 public void SetMouseButton(int button, bool isDown) { if (button < 0 || button >= 3) return; bool wasHolding = _mouseButton[button]; _mouseButton[button] = isDown; _mouseButtonDown[button] = isDown && !wasHolding; _mouseButtonUp[button] = !isDown && wasHolding; } public void SetKey(KeyCode keyCode, bool isDownThisFrame, bool isHolding) { if (!_keyboardState.ContainsKey(keyCode)) { _keyboardState[keyCode] = new KeyState(); } var state = _keyboardState[keyCode]; bool wasHolding = state.hold; state.hold = isHolding; state.down = isDownThisFrame && !wasHolding; state.up = !isHolding && wasHolding; _keyboardState[keyCode] = state; } // 公开API，模拟Unity Input public bool GetMouseButton(int button) { if (button < 0 || button >= 3) return false; return _mouseButton[button]; } public bool GetMouseButtonDown(int button) { if (button < 0 || button >= 3) return false; return _mouseButtonDown[button]; } public bool GetKey(KeyCode key) { if (_keyboardState.TryGetValue(key, out KeyState state)) { return state.hold; } return false; } public bool GetKeyDown(KeyCode key) { if (_keyboardState.TryGetValue(key, out KeyState state)) { return state.down; } return false; } // ... 其他Input类方法的封装 }

现在，在游戏代码中，你只需要将Input.GetKey(KeyCode.Space)替换为WebGLInputManager.Instance.GetKey(KeyCode.Space)，就可以获得在WebGL上稳定工作的输入检测。

5. 高级主题与兼容性打磨

基础框架搭好了，但要应对真实世界的各种浏览器和设备，还需要处理一些高级主题。

5.1 游戏手柄映射与死区处理

不同品牌的手柄，按钮和轴的编号可能不同。Xbox布局和PS布局的AB/XY键是相反的。我们需要一个可配置的映射系统。

// GamepadMapping.cs [System.Serializable] public class GamepadMapping { public string gamepadIdPattern; // 例如 “Xbox”, “PlayStation” public int buttonA = 0; public int buttonB = 1; public int buttonX = 2; public int buttonY = 3; public int leftStickHorizontal = 0; public int leftStickVertical = 1; // ... 其他映射 // 检查手柄名称是否匹配此映射 public bool Matches(string gamepadId) { return gamepadId.Contains(gamepadIdPattern); } } // 在WebGLInputManager中 private List<GamepadMapping> _gamepadMappings = new List<GamepadMapping>(); private GamepadMapping _currentMapping; void DetectAndApplyMapping(string gamepadId) { foreach (var mapping in _gamepadMappings) { if (mapping.Matches(gamepadId)) { _currentMapping = mapping; return; } } _currentMapping = _defaultMapping; // 使用一个默认映射（如Xbox） } public float GetAxis(string axisName) { if (_currentMapping == null || _currentGamepadState == null) return 0f; float rawValue = 0f; switch (axisName) { case “Horizontal”: rawValue = _currentGamepadState.axes[_currentMapping.leftStickHorizontal]; break; // ... } // 死区处理：避免摇杆轻微偏移导致的误输入 return Mathf.Abs(rawValue) > 0.2f ? rawValue : 0f; }

5.2 移动端触摸与手势识别

移动端输入的核心是触摸。我们需要将浏览器的TouchList转换为Unity易于处理的格式，并实现常见手势。

// 在JS桥接层中处理触摸 _onTouchStart: function(event) { event.preventDefault(); this.inputState.touchPoints = []; for (var i = 0; i < event.touches.length; i++) { var touch = event.touches[i]; var rect = event.target.getBoundingClientRect(); // 将屏幕坐标转换为Canvas相对坐标 var x = touch.clientX - rect.left; var y = touch.clientY - rect.top; this.inputState.touchPoints.push({id: touch.identifier, x: x, y: y}); } // 可以在这里检测手势，例如双指起始距离，用于后续的缩放判断 if (event.touches.length == 2) { this._pinchStartDistance = this._getDistance(event.touches[0], event.touches[1]); } }, _getDistance: function(touch1, touch2) { var dx = touch1.clientX - touch2.clientX; var dy = touch1.clientY - touch2.clientY; return Math.sqrt(dx * dx + dy * dy); }

在C#端，我们可以将这些触摸点数据封装成类似Unity的Touch结构，并提供手势识别方法，如IsPinching()返回缩放增量。

5.3 输入调试与性能监控面板

一个可视化的调试面板在开发阶段无比重要。我们可以创建一个简单的IMGUI面板，实时显示所有输入设备的状态。

// WebGLInputDebugger.cs using UnityEngine; public class WebGLInputDebugger : MonoBehaviour { void OnGUI() { GUILayout.BeginArea(new Rect(10, 10, 300, 500)); GUILayout.Label(“=== WebGL Input Debug ==="); GUILayout.Label($“Mouse: {WebGLInputManager.Instance.MousePosition}”); for (int i = 0; i < 3; i++) { GUILayout.Label($“Mouse Button {i}: {WebGLInputManager.Instance.GetMouseButton(i)}”); } GUILayout.Label(“--- Keyboard ---”); foreach (KeyCode key in System.Enum.GetValues(typeof(KeyCode))) { if (WebGLInputManager.Instance.GetKey(key)) { GUILayout.Label($“Key Held: {key}”); } } GUILayout.Label(“--- Gamepads ---”); var gamepads = WebGLInputManager.Instance.GetConnectedGamepads(); for (int i = 0; i < gamepads.Length; i++) { if (gamepads[i] != null) { GUILayout.Label($“Gamepad {i}: {gamepads[i].id}”); // 显示按钮和轴的状态... } } GUILayout.EndArea(); } }

这个面板能让你在运行时一目了然地看到所有输入信号，快速定位“按键没反应”到底是JS没捕获到，还是C#状态同步出了问题。

6. 实战避坑指南与常见问题排查

理论完美，实践踩坑。下面是我在多个项目中总结出的血泪教训。

6.1 焦点丢失与“幽灵输入”

• 现象：游戏切换到后台再切回来，或者用户点击了浏览器其他部分后，角色自己朝一个方向移动，或者某个键好像一直按着。
• 根因：Canvas失去焦点时，浏览器可能不会发送keyup或mouseup事件。导致我们的输入系统认为该键一直处于按下状态。
• 解决：在window的blur事件中，强制重置所有输入状态。在JS桥接层添加：

  _onWindowBlur: function() { // 清空所有按键状态 this.inputState.keyStates = {}; // 清空所有鼠标按钮状态 this.inputState.mouseButtons.fill(0); // 清空触摸点 this.inputState.touchPoints = []; // 可以通知C#端进行同步清理 if (typeof this.NotifyFocusLost === ‘function’) { this.NotifyFocusLost(); } }

6.2 移动端浏览器“滚动穿透”

• 现象：在手机浏览器里，你拖动游戏中的虚拟摇杆，整个网页也跟着上下滚动。
• 根因：触摸事件的默认行为是滚动页面。即使你阻止了touchmove事件，如果它的passive选项为true（现代浏览器为了提高滚动性能，默认将许多事件设为passive），preventDefault()会无效。
• 解决：在添加触摸事件监听器时，必须明确指定{passive: false}。

  canvas.addEventListener(‘touchmove’, this._onTouchMove.bind(this), { passive: false });

  同时，在_onTouchMove处理函数中调用event.preventDefault()。

6.3 输入延迟与卡顿

• 现象：操作感觉不跟手，有明显的延迟感。
• 排查与解决：
  1. 检查帧率：使用浏览器的开发者工具（F12）中的性能（Performance）面板录制，看是否因为复杂的游戏逻辑导致主线程阻塞，使得输入事件得不到及时处理。优化C#代码性能是关键。
  2. 减少跨语言调用：确保不是每帧都通过[DllImport]调用大量细粒度的JS函数（如每个按键查一次）。应该像我们设计的那样，每帧只调用一次GetInputState来同步所有状态。
  3. 使用requestAnimationFrame同步：可以考虑让JS桥接层也运行在requestAnimationFrame中，使其与浏览器的渲染节奏同步，然后将收集到的输入状态通过postMessage或直接写入共享内存（如Emscripten的HEAP）的方式传递给Unity，减少同步开销。

6.4 游戏手柄连接不稳定或无法识别

• 现象：手柄插上没反应，或者玩着玩着突然断开。
• 排查：
  1. 特性检测：首先检查if (‘getGamepads’ in navigator)。
  2. 连接事件：监听window的gamepadconnected和gamepaddisconnected事件，并更新连接的手柄列表。
  3. 浏览器兼容性：查阅MDN的Gamepad API兼容性表。对于Safari等支持较差的浏览器，考虑提示用户使用Chrome或Firefox，或者直接隐藏手柄支持选项。
  4. 轮询时机：确保在游戏主循环（Update）中轮询手柄状态，而不是在可能被暂停的协程或低频事件中。

6.5 常见问题速查表

7. 性能优化与未来演进

一个基础的输入系统能工作，但一个优秀的输入系统要跑得又快又稳。

• 使用SharedArrayBuffer进行零拷贝通信：这是高阶优化。通过Emscripten的SharedArrayBuffer和AtomicsAPI，可以在JS和WebAssembly之间创建一块共享内存。JS直接将输入数据写入这块内存，C#端直接读取，完全避免了序列化/反序列化和跨语言函数调用的开销。但这需要服务器设置特定的HTTP响应头（Cross-Origin-Opener-Policy和Cross-Origin-Embedder-Policy），且对浏览器版本有要求。
• 输入预测与补偿：对于网络游戏，可以在客户端根据最后一次收到的服务器状态和本地输入进行预测，以掩盖网络延迟。虽然这主要在网络层，但输入系统需要提供精确的时间戳信息来支持。
• 与Unity新输入系统集成：Unity的新输入系统（Input Systempackage）功能强大且跨平台。理论上，可以为它编写一个WebGL专用的InputDevice（如WebGLGamepad）。这样游戏逻辑可以直接使用强大、统一的新输入系统API，而底层设备适配则由我们实现的Device来完成。这是更现代、更彻底的解决方案，但实现复杂度也更高。
• 关注Web标准进展：如WebHIDAPI，它允许网页直接访问更底层的HID设备（如高级飞行摇杆、赛车方向盘），未来可能为WebGL游戏带来更专业的输入设备支持。保持对这类新API的关注，在它们普及后适时集成。

WebGL平台的输入处理是一个典型的“戴着镣铐跳舞”的挑战。浏览器安全沙箱是镣铐，但通过深入理解其原理，并精心设计分层、异步、兼容的架构，我们完全能让Unity游戏在网页中焕发出接近原生的交互活力。这套方案的核心思想——在边界处标准化，在内部做抽象——不仅适用于输入，对于WebGL的其他限制（如文件系统、网络请求）也同样有借鉴意义。记住，没有一劳永逸的银弹，持续测试、监控和适配不同的浏览器与设备，是保证WebGL项目输入体验始终在线的唯一法宝。