remove legacy adapter in Wechat PC game (#8626)

* support keyboardEvent on wx pc game

update

update

# Conflicts:
#	pal/input/minigame/keyboard.ts

* support mouse event

* move in gl.useProgram adapting

* remove legacy adapter

update

* update

update

update

update

* rename interface

* bind method
This commit is contained in:
PP
2021-06-24 11:37:16 +08:00
committed by GitHub
parent 94e476f93d
commit d85cee16df
9 changed files with 281 additions and 206 deletions
+32
View File
@@ -1,6 +1,9 @@
declare module 'pal/minigame' {
export const minigame: IMiniGame;
export interface IMiniGame {
// platform related
wx?: WeChatAPI;
// system
isDevTool: boolean;
isLandscape: boolean;
@@ -49,6 +52,35 @@ declare module 'pal/minigame' {
stopAccelerometer(obj: AccelerometerStopParameter);
}
interface WeChatAPI {
onKeyDown?: (cb: (res: KeyboardEventData) => void) => void;
onKeyUp?: (cb: (res: KeyboardEventData) => void) => void;
onMouseDown?: (cb: (res: MouseEventData) => void) => void;
onMouseMove?: (cb: (res: MouseEventData) => void) => void;
onMouseUp?: (cb: (res: MouseEventData) => void) => void;
onWheel?: (cb: (res: MouseWheelEventData) => void) => void;
}
export interface KeyboardEventData {
key: string;
code: string;
timeStamp: number;
}
export interface MouseEventData {
x: number;
y: number;
button: number;
timeStamp: number;
}
export interface MouseWheelEventData extends MouseEventData {
deltaX: number;
deltaY: number;
deltaZ: number;
}
export type AccelerometerIntervalMode = 'game' | 'ui' | 'normal';
export interface AccelerometerStartParameter {
@@ -76,7 +76,7 @@ export class SystemEvent extends EventTarget {
public static DeviceEvent = DeviceEvent;
/**
* @en Enum type of keycode for key event
* @en Enum type of keyCode for key event
* @zh 按键事件的按键码
*/
public static KeyCode = KeyCode;
+150 -1
View File
@@ -1,13 +1,162 @@
import { KeyboardCallback, KeyboardInputEvent } from 'pal/input';
import { KeyboardEventData, minigame } from 'pal/minigame';
import { KeyboardEvent } from '../../../cocos/core/platform/event-manager/event-enum';
import { EventTarget } from '../../../cocos/core/event/event-target';
import { KeyCode } from '../../../cocos/core/platform/event-manager/key-code';
const code2KeyCode: Record<string, KeyCode> = {
Backspace: KeyCode.BACKSPACE,
Tab: KeyCode.TAB,
Enter: KeyCode.ENTER,
ShiftLeft: KeyCode.SHIFT_LEFT,
ControlLeft: KeyCode.CTRL_LEFT,
AltLeft: KeyCode.ALT_LEFT,
ShiftRight: KeyCode.SHIFT_RIGHT,
ControlRight: KeyCode.CTRL_RIGHT,
AltRight: KeyCode.ALT_RIGHT,
Pause: KeyCode.PAUSE,
CapsLock: KeyCode.CAPSLOCK,
Escape: KeyCode.ESCAPE,
Space: KeyCode.SPACE,
PageUp: KeyCode.PAGEUP,
PageDown: KeyCode.PAGEDOWN,
End: KeyCode.END,
Home: KeyCode.HOME,
ArrowLeft: KeyCode.ARROW_LEFT,
ArrowUp: KeyCode.ARROW_UP,
ArrowRight: KeyCode.ARROW_RIGHT,
ArrowDown: KeyCode.ARROW_DOWN,
Insert: KeyCode.INSERT,
Delete: KeyCode.DELETE,
Digit0: KeyCode.DIGIT_0,
Digit1: KeyCode.DIGIT_1,
Digit2: KeyCode.DIGIT_2,
Digit3: KeyCode.DIGIT_3,
Digit4: KeyCode.DIGIT_4,
Digit5: KeyCode.DIGIT_5,
Digit6: KeyCode.DIGIT_6,
Digit7: KeyCode.DIGIT_7,
Digit8: KeyCode.DIGIT_8,
Digit9: KeyCode.DIGIT_9,
KeyA: KeyCode.KEY_A,
KeyB: KeyCode.KEY_B,
KeyC: KeyCode.KEY_C,
KeyD: KeyCode.KEY_D,
KeyE: KeyCode.KEY_E,
KeyF: KeyCode.KEY_F,
KeyG: KeyCode.KEY_G,
KeyH: KeyCode.KEY_H,
KeyI: KeyCode.KEY_I,
KeyJ: KeyCode.KEY_J,
KeyK: KeyCode.KEY_K,
KeyL: KeyCode.KEY_L,
KeyM: KeyCode.KEY_M,
KeyN: KeyCode.KEY_N,
KeyO: KeyCode.KEY_O,
KeyP: KeyCode.KEY_P,
KeyQ: KeyCode.KEY_Q,
KeyR: KeyCode.KEY_R,
KeyS: KeyCode.KEY_S,
KeyT: KeyCode.KEY_T,
KeyU: KeyCode.KEY_U,
KeyV: KeyCode.KEY_V,
KeyW: KeyCode.KEY_W,
KeyX: KeyCode.KEY_X,
KeyY: KeyCode.KEY_Y,
KeyZ: KeyCode.KEY_Z,
Numpad0: KeyCode.NUM_0,
Numpad1: KeyCode.NUM_1,
Numpad2: KeyCode.NUM_2,
Numpad3: KeyCode.NUM_3,
Numpad4: KeyCode.NUM_4,
Numpad5: KeyCode.NUM_5,
Numpad6: KeyCode.NUM_6,
Numpad7: KeyCode.NUM_7,
Numpad8: KeyCode.NUM_8,
Numpad9: KeyCode.NUM_9,
NumpadMultiply: KeyCode.NUM_MUTIPLY,
NumpadAdd: KeyCode.NUM_PLUS,
NumpadSubtract: KeyCode.NUM_SUBTRACT,
NumpadDecimal: KeyCode.NUM_DECIMAL,
NumpadDivide: KeyCode.NUM_DIVIDE,
NumpadEnter: KeyCode.NUM_ENTER,
F1: KeyCode.F1,
F2: KeyCode.F2,
F3: KeyCode.F3,
F4: KeyCode.F4,
F5: KeyCode.F5,
F6: KeyCode.F6,
F7: KeyCode.F7,
F8: KeyCode.F8,
F9: KeyCode.F9,
F10: KeyCode.F10,
F11: KeyCode.F11,
F12: KeyCode.F12,
NumLock: KeyCode.NUM_LOCK,
ScrollLock: KeyCode.SCROLLLOCK,
Semicolon: KeyCode.SEMICOLON,
Equal: KeyCode.EQUAL,
Comma: KeyCode.COMMA,
Minus: KeyCode.DASH,
Period: KeyCode.PERIOD,
Slash: KeyCode.SLASH,
Backquote: KeyCode.BACKQUOTE,
BracketLeft: KeyCode.BRACKET_LEFT,
Backslash: KeyCode.BACKSLASH,
BracketRight: KeyCode.BRACKET_RIGHT,
Quote: KeyCode.QUOTE,
};
function getKeyCode (code: string): KeyCode {
return code2KeyCode[code] || KeyCode.NONE;
}
export class KeyboardInputSource {
public support: boolean;
private _eventTarget: EventTarget = new EventTarget();
// KeyboardEvent.repeat is not supported on Wechat PC platform.
private _keyStateMap: Record<number, boolean> = {};
constructor () {
this.support = false; // TODO: pc-wechat
this.support = typeof minigame.wx === 'object' && typeof minigame.wx.onKeyDown !== 'undefined';
if (this.support) {
this._registerEvent();
}
}
private _registerEvent () {
minigame.wx?.onKeyDown?.((res) => {
const keyCode = getKeyCode(res.code);
if (!this._keyStateMap[keyCode]) {
const keyDownInputEvent = this._getInputEvent(res, KeyboardEvent.KEY_DOWN);
this._eventTarget.emit(KeyboardEvent.KEY_DOWN, keyDownInputEvent);
}
// @ts-expect-error Compability for key pressing callback
const keyPressingInputEvent = this._getInputEvent(res, 'keydown');
this._eventTarget.emit('keydown', keyPressingInputEvent);
this._keyStateMap[keyCode] = true;
});
minigame.wx?.onKeyUp?.((res) => {
const keyCode = getKeyCode(res.code);
const inputEvent: KeyboardInputEvent = {
code: keyCode,
type: KeyboardEvent.KEY_UP,
timestamp: performance.now(),
};
this._keyStateMap[keyCode] = false;
this._eventTarget.emit(KeyboardEvent.KEY_UP, inputEvent);
});
}
private _getInputEvent (event: KeyboardEventData, eventType: KeyboardEvent) {
const keyCode = getKeyCode(event.code);
const inputEvent: KeyboardInputEvent = {
type: eventType,
code: keyCode,
timestamp: performance.now(),
};
return inputEvent;
}
public onDown (cb: KeyboardCallback) {
+57 -2
View File
@@ -1,14 +1,69 @@
import { MouseCallback, MouseInputEvent, MouseWheelCallback, MouseWheelInputEvent } from 'pal/input';
import { EventMouse } from '../../../cocos/core/platform/event-manager/events';
import { MouseEventData, MouseWheelEventData, minigame } from 'pal/minigame';
import { EventTarget } from '../../../cocos/core/event/event-target';
import { MouseEvent } from '../../../cocos/core/platform/event-manager/event-enum';
export class MouseInputSource {
public support: boolean;
private _eventTarget: EventTarget = new EventTarget();
private _isPressed = false;
constructor () {
this.support = false; // TODO: pc-wechat
this.support = typeof minigame.wx === 'object' && typeof minigame.wx.onMouseDown !== 'undefined';
if (this.support) {
this._registerEvent();
}
}
private _registerEvent () {
minigame.wx?.onMouseDown?.(this._createCallback(MouseEvent.MOUSE_DOWN));
minigame.wx?.onMouseMove?.(this._createCallback(MouseEvent.MOUSE_MOVE));
minigame.wx?.onMouseUp?.(this._createCallback(MouseEvent.MOUSE_UP));
minigame.wx?.onWheel?.((event: MouseWheelEventData) => {
const sysInfo = minigame.getSystemInfoSync();
const inputEvent: MouseWheelInputEvent = {
type: MouseEvent.MOUSE_WHEEL,
x: event.x,
y: sysInfo.screenHeight - event.y,
button: event.button,
deltaX: event.deltaX,
deltaY: event.deltaY,
timestamp: performance.now(),
};
// emit web mouse event
this._eventTarget.emit(MouseEvent.MOUSE_WHEEL, inputEvent);
});
}
private _createCallback (eventType: MouseEvent) {
return (event: MouseEventData) => {
const sysInfo = minigame.getSystemInfoSync();
let button = event.button;
switch (eventType) {
case MouseEvent.MOUSE_DOWN:
this._isPressed = true;
break;
case MouseEvent.MOUSE_UP:
this._isPressed = false;
break;
case MouseEvent.MOUSE_MOVE:
if (!this._isPressed) {
button = -1; // TODO: should not access EventMouse.BUTTON_MISSING, need a button enum type
}
break;
default:
break;
}
const inputEvent: MouseInputEvent = {
type: eventType,
x: event.x,
y: sysInfo.screenHeight - event.y,
button,
timestamp: performance.now(),
};
// emit web mouse event
this._eventTarget.emit(eventType, inputEvent);
};
}
onDown (cb: MouseCallback) {
+10 -10
View File
@@ -4,7 +4,7 @@ import { KeyboardEvent } from '../../../cocos/core/platform/event-manager/event-
import { EventTarget } from '../../../cocos/core/event/event-target';
import { KeyCode } from '../../../cocos/core/platform/event-manager/key-code';
const nativeKeyCode2Keycode: Record<number, KeyCode> = {
const nativeKeyCode2KeyCode: Record<number, KeyCode> = {
12: KeyCode.NUM_LOCK,
10048: KeyCode.NUM_0,
10049: KeyCode.NUM_1,
@@ -23,7 +23,7 @@ const nativeKeyCode2Keycode: Record<number, KeyCode> = {
};
function getKeyCode (keyCode: number): KeyCode {
return nativeKeyCode2Keycode[keyCode] || keyCode;
return nativeKeyCode2KeyCode[keyCode] || keyCode;
}
export class KeyboardInputSource {
@@ -40,33 +40,33 @@ export class KeyboardInputSource {
private _registerEvent () {
jsb.onKeyDown = (event: jsb.KeyboardEvent) => {
const keycode = getKeyCode(event.keyCode);
if (!this._keyStateMap[keycode]) {
const keyCode = getKeyCode(event.keyCode);
if (!this._keyStateMap[keyCode]) {
const keyDownInputEvent = this._getInputEvent(event, KeyboardEvent.KEY_DOWN);
this._eventTarget.emit(KeyboardEvent.KEY_DOWN, keyDownInputEvent);
}
// @ts-expect-error Compability for key pressing callback
const keyPressingInputEvent = this._getInputEvent(event, 'keydown');
this._eventTarget.emit('keydown', keyPressingInputEvent);
this._keyStateMap[keycode] = true;
this._keyStateMap[keyCode] = true;
};
jsb.onKeyUp = (event: jsb.KeyboardEvent) => {
const keycode = getKeyCode(event.keyCode);
const keyCode = getKeyCode(event.keyCode);
const inputEvent: KeyboardInputEvent = {
type: KeyboardEvent.KEY_UP,
code: keycode,
code: keyCode,
timestamp: performance.now(),
};
this._keyStateMap[keycode] = false;
this._keyStateMap[keyCode] = false;
this._eventTarget.emit(KeyboardEvent.KEY_UP, inputEvent);
};
}
private _getInputEvent (event: jsb.KeyboardEvent, eventType: KeyboardEvent) {
const keycode = getKeyCode(event.keyCode);
const keyCode = getKeyCode(event.keyCode);
const inputEvent: KeyboardInputEvent = {
type: eventType,
code: keycode,
code: keyCode,
timestamp: performance.now(),
};
return inputEvent;
+25
View File
@@ -8,6 +8,16 @@ declare let wx: any;
const minigame: IMiniGame = {};
cloneObject(minigame, wx);
// #region platform related
minigame.wx = {};
minigame.wx.onKeyDown = wx.onKeyDown?.bind(wx);
minigame.wx.onKeyUp = wx.onKeyUp?.bind(wx);
minigame.wx.onMouseDown = wx.onMouseDown?.bind(wx);
minigame.wx.onMouseMove = wx.onMouseMove?.bind(wx);
minigame.wx.onMouseUp = wx.onMouseUp?.bind(wx);
minigame.wx.onWheel = wx.onWheel?.bind(wx);
// #endregion platform related
// #region SystemInfo
let _cachedSystemInfo: SystemInfo = wx.getSystemInfoSync();
// @ts-expect-error TODO: move into minigame.d.ts
@@ -120,4 +130,19 @@ minigame.getSafeArea = function () {
};
// #endregion SafeArea
// HACK: adapt GL.useProgram: use program not supported to unbind program on pc end
if (systemInfo.platform === 'windows') {
// @ts-expect-error canvas defined in global
const locCanvas = canvas;
if (locCanvas) {
const webglRC = locCanvas.getContext('webgl');
const originalUseProgram = webglRC.useProgram.bind(webglRC);
webglRC.useProgram = function (program) {
if (program) {
originalUseProgram(program);
}
};
}
}
export { minigame };
+6 -5
View File
@@ -56,10 +56,6 @@ class System {
this.isNative = false;
this.isBrowser = false;
// init isMobile and platform
this.platform = currentPlatform;
this.isMobile = !minigame.isDevTool; // TODO: pc-game ?
// init isLittleEndian
this.isLittleEndian = (() => {
const buffer = new ArrayBuffer(2);
@@ -78,8 +74,9 @@ class System {
this.os = OS.ANDROID;
} else if (minigamePlatform === 'ios') {
this.os = OS.IOS;
} else if (minigamePlatform === 'windows') {
this.os = OS.WINDOWS;
} else {
// TODO: pc-game ?
this.os = OS.UNKNOWN;
}
let minigameSystem = minigameSysInfo.system.toLowerCase();
@@ -91,6 +88,10 @@ class System {
this.osVersion = version ? version[0] : minigameSystem;
this.osMainVersion = parseInt(this.osVersion);
// init isMobile and platform
this.platform = currentPlatform;
this.isMobile = this.os !== OS.WINDOWS;
// init browserType and browserVersion
this.browserType = BrowserType.UNKNOWN;
this.browserVersion = '';
@@ -1,3 +1,2 @@
require('./VideoPlayer');
require('./pc-adapter');
require('./sprite-frame');
@@ -1,186 +0,0 @@
const env = wx.getSystemInfoSync();
const inputMgr = cc.internal.inputManager;
const eventMgr = cc.eventManager;
const EventKeyboard = cc.Event.EventKeyboard;
const EventMouse = cc.Event.EventMouse;
// map from CCMacro
const key2keyCode = {
backspace: 8,
tab: 9,
enter: 13,
shift: 16,
control: 17,
alt: 18,
pause: 19,
capslock: 20,
escape: 27,
' ': 32,
pageup: 33,
pagedown: 34,
end: 35,
home: 36,
arrowleft: 37,
arrowup: 38,
arrowright: 39,
arrowdown: 40,
insert: 45,
a: 65,
b: 66,
c: 67,
d: 68,
e: 69,
f: 70,
g: 71,
h: 72,
i: 73,
j: 74,
k: 75,
l: 76,
m: 77,
n: 78,
o: 79,
p: 80,
q: 81,
r: 82,
s: 83,
t: 84,
u: 85,
v: 86,
w: 87,
x: 88,
y: 89,
z: 90,
'*': 106,
'+': 107,
'-': 109,
'/': 111,
f1: 112,
f2: 113,
f3: 114,
f4: 115,
f5: 116,
f6: 117,
f7: 118,
f8: 119,
f9: 120,
f10: 121,
f11: 122,
f12: 123,
numlock: 144,
scrolllock: 145,
';': 186,
'=': 187,
',': 188,
'.': 190,
'`': 192,
'[': 219,
'\\': 220,
']': 221,
'\'': 222,
};
const code2KeyCode = {
Delete: 46,
Digit0: 48,
Digit1: 49,
Digit2: 50,
Digit3: 51,
Digit4: 52,
Digit5: 53,
Digit6: 54,
Digit7: 55,
Digit8: 56,
Digit9: 57,
Numpad0: 96,
Numpad1: 97,
Numpad2: 98,
Numpad3: 99,
Numpad4: 100,
Numpad5: 101,
Numpad6: 102,
Numpad7: 103,
Numpad8: 104,
Numpad9: 105,
NumpadDecimal: 110,
};
function getKeyCode (res) {
let key = res.key.toLowerCase(), code = res.code;
// distinguish different numLock states
if (/^\d$/.test(key) || key === 'delete') {
return code2KeyCode[code];
}
return key2keyCode[key] || 0;
}
function adaptKeyboadEvent () {
wx.onKeyDown(res => eventMgr.dispatchEvent(new EventKeyboard(getKeyCode(res), true)));
wx.onKeyUp(res => eventMgr.dispatchEvent(new EventKeyboard(getKeyCode(res), false)));
}
function adaptMouseEvent () {
let canvasRect = {
top: 0,
left: 0,
width: window.innerWidth,
height: window.innerHeight,
};
function registerMouseEvent (funcName, engineEventType, handler) {
wx[funcName](res => {
let mouseEvent = inputMgr.getMouseEvent(res, canvasRect, engineEventType);
mouseEvent.setButton(res.button || 0);
handler(res, mouseEvent);
eventMgr.dispatchEvent(mouseEvent);
});
}
registerMouseEvent('onMouseDown', EventMouse.DOWN, function (res, mouseEvent) {
inputMgr._mousePressed = true;
inputMgr.handleTouchesBegin([inputMgr.getTouchByXY(mouseEvent, res.x, res.y, canvasRect)]);
});
registerMouseEvent('onMouseUp', EventMouse.UP, function (res, mouseEvent) {
inputMgr._mousePressed = false;
inputMgr.handleTouchesEnd([inputMgr.getTouchByXY(mouseEvent, res.x, res.y, canvasRect)]);
});
registerMouseEvent('onMouseMove', EventMouse.MOVE, function (res, mouseEvent) {
inputMgr.handleTouchesMove([inputMgr.getTouchByXY(mouseEvent, res.x, res.y, canvasRect)]);
if (!inputMgr._mousePressed) {
mouseEvent.setButton(null);
}
});
registerMouseEvent('onWheel', EventMouse.SCROLL, function (res, mouseEvent) {
mouseEvent.setScrollData(0, -res.deltaY);
});
}
function adaptGL () {
if (canvas) {
let webglRC = canvas.getContext('webgl');
let originalUseProgram = webglRC.useProgram.bind(webglRC);
webglRC.useProgram = function (program) {
if (program) {
originalUseProgram(program);
}
}
}
}
(function () {
// TODO: add mac
if (env.platform !== 'windows') {
return;
}
// use program not supported to unbind program on pc end
adaptGL();
inputMgr.registerSystemEvent = function () {
if (this._isRegisterEvent) {
return;
}
this._glView = cc.view;
adaptKeyboadEvent();
adaptMouseEvent();
this._isRegisterEvent = true;
};
})();