Update framework

framework/input/index.d.ts

@@ -0,0 +1,13 @@
+import { BaseInput } from './inputs/base-input';
+import { State } from './interfaces/state';
+export declare class Input {
+    private InputIDs;
+    private element;
+    private inputs;
+    constructor(InputIDs: string[], element: HTMLElement);
+    private init;
+    addInput(id: string, input: BaseInput): this;
+    capture(preventDefault?: boolean): void;
+    release(): void;
+    getState(): State;
+}

framework/input/index.js

@@ -0,0 +1,34 @@
+import { createInput } from './input-factory';
+export class Input {
+    constructor(InputIDs, element) {
+        this.InputIDs = InputIDs;
+        this.element = element;
+        this.inputs = new Map();
+        this.init();
+    }
+    init() {
+        this.InputIDs.forEach((inputID) => {
+            const thing = createInput(inputID);
+            const instance = new thing(this.element);
+            this.inputs.set(inputID, instance);
+        });
+    }
+    addInput(id, input) {
+        this.inputs.set(id, input);
+        return this;
+    }
+    capture(preventDefault = true) {
+        this.inputs.forEach((input) => input.capture(preventDefault));
+    }
+    release() {
+        this.inputs.forEach((input) => input.release());
+    }
+    getState() {
+        const state = {};
+        this.inputs.forEach((input, inputID) => {
+            if (input)
+                state[inputID] = input.getState();
+        });
+        return state;
+    }
+}

framework/input/input-factory.d.ts

@@ -0,0 +1 @@
+export declare function createInput(key: string): any;

framework/input/input-factory.js

@@ -0,0 +1,14 @@
+import { Keyboard } from './inputs/keyboard';
+import { Mouse } from './inputs/mouse';
+export function createInput(key) {
+    switch (key) {
+        case 'keyboard':
+            return Keyboard;
+            break;
+        case 'mouse':
+            return Mouse;
+            break;
+        default:
+            break;
+    }
+}

framework/input/inputs/base-input.d.ts

@@ -0,0 +1,10 @@
+export declare class BaseInput {
+    protected element: HTMLElement;
+    protected active: boolean;
+    constructor(element: HTMLElement);
+    getState(): any;
+    capture(preventDefault: boolean): void;
+    release(): void;
+}
+export interface IBaseInput {
+}

framework/input/inputs/base-input.js

@@ -0,0 +1,12 @@
+export class BaseInput {
+    constructor(element) {
+        this.element = element;
+    }
+    getState() { }
+    capture(preventDefault) {
+        return;
+    }
+    release() {
+        return;
+    }
+}

framework/input/inputs/joystick.d.ts

@@ -0,0 +1,6 @@
+import { BaseInput } from './base-input';
+export declare class Joystick extends BaseInput {
+    constructor(element: HTMLElement);
+}
+export interface IJoystick {
+}

framework/input/inputs/joystick.js

@@ -0,0 +1,6 @@
+import { BaseInput } from './base-input';
+export class Joystick extends BaseInput {
+    constructor(element) {
+        super(element);
+    }
+}

framework/input/inputs/keyboard.d.ts

@@ -0,0 +1,18 @@
+import { BaseInput } from './base-input';
+export declare class Keyboard extends BaseInput {
+    private keysDown;
+    private keysJustPressed;
+    private keysJustReleased;
+    private preventDefault;
+    constructor(element: HTMLElement);
+    capture(preventDefault: boolean): void;
+    release(): void;
+    getState(): IKeyboard;
+    private handleKeyDown;
+    private handleKeyUp;
+}
+export interface IKeyboard {
+    keysDown: Map<number, boolean>;
+    keysJustPressed: Map<number, boolean>;
+    keysJustReleased: Map<number, boolean>;
+}

framework/input/inputs/keyboard.js

@@ -0,0 +1,50 @@
+import { BaseInput } from './base-input';
+export class Keyboard extends BaseInput {
+    constructor(element) {
+        super(element);
+        this.keysDown = new Map();
+        this.keysJustPressed = new Map();
+        this.keysJustReleased = new Map();
+        this.handleKeyDown = this.handleKeyDown.bind(this);
+        this.handleKeyUp = this.handleKeyUp.bind(this);
+    }
+    capture(preventDefault) {
+        this.active = true;
+        this.preventDefault = preventDefault;
+        this.element.addEventListener('keydown', this.handleKeyDown);
+        this.element.addEventListener('keyup', this.handleKeyUp);
+    }
+    release() {
+        this.active = false;
+        this.element.removeEventListener('keydown', this.handleKeyDown);
+        this.element.removeEventListener('keyup', this.handleKeyUp);
+    }
+    getState() {
+        const state = {
+            keysDown: new Map(this.keysDown),
+            keysJustPressed: new Map(this.keysJustPressed),
+            keysJustReleased: new Map(this.keysJustReleased)
+        };
+        this.keysJustPressed.clear();
+        this.keysJustReleased.clear();
+        return state;
+    }
+    handleKeyDown(event) {
+        if (this.active && this.preventDefault)
+            event.preventDefault();
+        if (this.keysDown.get(event.keyCode))
+            return;
+        this.keysDown.set(event.keyCode, true);
+        this.keysJustPressed.set(event.keyCode, true);
+        this.keysJustReleased.set(event.keyCode, false);
+    }
+    handleKeyUp(event) {
+        if (this.active && this.preventDefault)
+            event.preventDefault();
+        if (!this.keysDown.get(event.keyCode))
+            return;
+        this.keysDown.set(event.keyCode, false);
+        this.keysJustPressed.set(event.keyCode, false);
+        this.keysJustReleased.set(event.keyCode, true);
+    }
+}

framework/input/inputs/mouse.d.ts

@@ -0,0 +1,34 @@
+import { BaseInput } from './base-input';
+export declare class Mouse extends BaseInput {
+    private mousePosition;
+    private mouseDelta;
+    private mouseWheel;
+    private mouseButtons;
+    constructor(element: HTMLElement);
+    capture(): void;
+    release(): void;
+    getState(): IMouse;
+    private handleMouseDown;
+    private handleMouseMove;
+    private handleMouseUp;
+    private handlePointerChange;
+}
+export declare class Position {
+    x: number;
+    y: number;
+}
+export declare class MouseButtons {
+    keysDown: Map<number, boolean>;
+    keysJustPressed: Map<number, boolean>;
+    keysJustReleased: Map<number, boolean>;
+}
+export declare class Delta {
+    x: number;
+    y: number;
+}
+export interface IMouse {
+    mouseButtons: MouseButtons;
+    mousePosition: Position;
+    mouseWheel: Delta;
+    mouseDelta: Delta;
+}

framework/input/inputs/mouse.js

@@ -0,0 +1,87 @@
+import { BaseInput } from './base-input';
+export class Mouse extends BaseInput {
+    constructor(element) {
+        super(element);
+        this.mousePosition = new Position();
+        this.mouseDelta = new Delta();
+        this.mouseWheel = new Delta();
+        this.mouseButtons = new MouseButtons();
+    }
+    capture() {
+        this.handleMouseDown = this.handleMouseDown.bind(this);
+        this.handleMouseMove = this.handleMouseMove.bind(this);
+        this.handleMouseUp = this.handleMouseUp.bind(this);
+        this.handlePointerChange = this.handlePointerChange.bind(this);
+        this.active = true;
+        this.element.addEventListener('mousedown', this.handleMouseDown);
+        this.element.addEventListener('mousemove', this.handleMouseMove);
+        this.element.addEventListener('mouseup', this.handleMouseUp);
+        document.addEventListener('pointerlockchange', this.handlePointerChange);
+    }
+    release() {
+        this.active = false;
+        this.element.removeEventListener('mousedown', this.handleMouseDown);
+        this.element.removeEventListener('mousemove', this.handleMouseMove);
+        this.element.removeEventListener('mouseup', this.handleMouseUp);
+    }
+    getState() {
+        const { mouseButtons, mouseDelta, mousePosition, mouseWheel } = this;
+        const state = {
+            mouseButtons: {
+                keysDown: new Map(this.mouseButtons.keysDown),
+                keysJustPressed: new Map(this.mouseButtons.keysJustPressed),
+                keysJustReleased: new Map(this.mouseButtons.keysJustReleased)
+            },
+            mouseDelta,
+            mousePosition,
+            mouseWheel
+        };
+        this.mouseButtons.keysJustPressed.clear();
+        this.mouseButtons.keysJustReleased.clear();
+        this.mouseDelta.x = 0;
+        this.mouseDelta.y = 0;
+        return state;
+    }
+    handleMouseDown(event) {
+        if (this.active)
+            event.preventDefault();
+        this.mouseButtons.keysDown.set(event.button, true);
+        this.mouseButtons.keysJustPressed.set(event.button, true);
+        this.mouseButtons.keysJustReleased.set(event.button, false);
+    }
+    handleMouseMove(event) {
+        if (this.active)
+            event.preventDefault();
+        this.mousePosition.x = event.clientX;
+        this.mousePosition.y = event.clientY;
+        this.mouseDelta.x = event.movementX;
+        this.mouseDelta.y = event.movementY;
+    }
+    handleMouseUp(event) {
+        if (this.active)
+            event.preventDefault();
+        this.mouseButtons.keysJustReleased.set(event.button, true);
+        this.mouseButtons.keysDown.set(event.button, false);
+        this.mouseButtons.keysJustPressed.set(event.button, false);
+    }
+    handlePointerChange() {
+        if (document.pointerLockElement !== this.element) {
+            this.element.addEventListener('click', () => {
+                this.element.requestPointerLock();
+            }, {
+                once: true
+            });
+        }
+    }
+}
+export class Position {
+}
+export class MouseButtons {
+    constructor() {
+        this.keysDown = new Map();
+        this.keysJustPressed = new Map();
+        this.keysJustReleased = new Map();
+    }
+}
+export class Delta {
+}

framework/input/interfaces/state.d.ts

@@ -0,0 +1,4 @@
+import { IKeyboard } from '../inputs/keyboard';
+export interface State {
+    keyboard?: IKeyboard;
+}

framework/input/interfaces/state.js

@@ -0,0 +1 @@
+export {};

framework/input/keycodes.d.ts

@@ -0,0 +1,122 @@
+export declare let KeyCodes: {
+    CANCEL: number;
+    HELP: number;
+    BACK_SPACE: number;
+    TAB: number;
+    CLEAR: number;
+    RETURN: number;
+    ENTER: number;
+    SHIFT: number;
+    CONTROL: number;
+    ALT: number;
+    PAUSE: number;
+    CAPS_LOCK: number;
+    ESCAPE: number;
+    SPACE: number;
+    PAGE_UP: number;
+    PAGE_DOWN: number;
+    END: number;
+    HOME: number;
+    LEFT: number;
+    UP: number;
+    RIGHT: number;
+    DOWN: number;
+    PRINTSCREEN: number;
+    INSERT: number;
+    DELETE: number;
+    0: number;
+    1: number;
+    2: number;
+    3: number;
+    4: number;
+    5: number;
+    6: number;
+    7: number;
+    8: number;
+    9: number;
+    SEMICOLON: number;
+    EQUALS: number;
+    A: number;
+    B: number;
+    C: number;
+    D: number;
+    E: number;
+    F: number;
+    G: number;
+    H: number;
+    I: number;
+    J: number;
+    K: number;
+    L: number;
+    M: number;
+    N: number;
+    O: number;
+    P: number;
+    Q: number;
+    R: number;
+    S: number;
+    T: number;
+    U: number;
+    V: number;
+    W: number;
+    X: number;
+    Y: number;
+    Z: number;
+    CONTEXT_MENU: number;
+    NUMPAD0: number;
+    NUMPAD1: number;
+    NUMPAD2: number;
+    NUMPAD3: number;
+    NUMPAD4: number;
+    NUMPAD5: number;
+    NUMPAD6: number;
+    NUMPAD7: number;
+    NUMPAD8: number;
+    NUMPAD9: number;
+    MULTIPLY: number;
+    ADD: number;
+    SEPARATOR: number;
+    SUBTRACT: number;
+    DECIMAL: number;
+    DIVIDE: number;
+    F1: number;
+    F2: number;
+    F3: number;
+    F4: number;
+    F5: number;
+    F6: number;
+    F7: number;
+    F8: number;
+    F9: number;
+    F10: number;
+    F11: number;
+    F12: number;
+    F13: number;
+    F14: number;
+    F15: number;
+    F16: number;
+    F17: number;
+    F18: number;
+    F19: number;
+    F20: number;
+    F21: number;
+    F22: number;
+    F23: number;
+    F24: number;
+    NUM_LOCK: number;
+    SCROLL_LOCK: number;
+    COMMA: number;
+    PERIOD: number;
+    SLASH: number;
+    BACK_QUOTE: number;
+    OPEN_BRACKET: number;
+    BACK_SLASH: number;
+    CLOSE_BRACKET: number;
+    QUOTE: number;
+    META: number;
+};
+export declare let MouseCodes: {
+    LEFT: number;
+    RIGHT: number;
+    MIDDLE: number;
+};

framework/input/keycodes.js

@@ -0,0 +1,122 @@
+export let KeyCodes = {
+    CANCEL: 3,
+    HELP: 6,
+    BACK_SPACE: 8,
+    TAB: 9,
+    CLEAR: 12,
+    RETURN: 13,
+    ENTER: 14,
+    SHIFT: 16,
+    CONTROL: 17,
+    ALT: 18,
+    PAUSE: 19,
+    CAPS_LOCK: 20,
+    ESCAPE: 27,
+    SPACE: 32,
+    PAGE_UP: 33,
+    PAGE_DOWN: 34,
+    END: 35,
+    HOME: 36,
+    LEFT: 37,
+    UP: 38,
+    RIGHT: 39,
+    DOWN: 40,
+    PRINTSCREEN: 44,
+    INSERT: 45,
+    DELETE: 46,
+    0: 48,
+    1: 49,
+    2: 50,
+    3: 51,
+    4: 52,
+    5: 53,
+    6: 54,
+    7: 55,
+    8: 56,
+    9: 57,
+    SEMICOLON: 59,
+    EQUALS: 61,
+    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,
+    CONTEXT_MENU: 93,
+    NUMPAD0: 96,
+    NUMPAD1: 97,
+    NUMPAD2: 98,
+    NUMPAD3: 99,
+    NUMPAD4: 100,
+    NUMPAD5: 101,
+    NUMPAD6: 102,
+    NUMPAD7: 103,
+    NUMPAD8: 104,
+    NUMPAD9: 105,
+    MULTIPLY: 106,
+    ADD: 107,
+    SEPARATOR: 108,
+    SUBTRACT: 109,
+    DECIMAL: 110,
+    DIVIDE: 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,
+    F13: 124,
+    F14: 125,
+    F15: 126,
+    F16: 127,
+    F17: 128,
+    F18: 129,
+    F19: 130,
+    F20: 131,
+    F21: 132,
+    F22: 133,
+    F23: 134,
+    F24: 135,
+    NUM_LOCK: 144,
+    SCROLL_LOCK: 145,
+    COMMA: 188,
+    PERIOD: 190,
+    SLASH: 191,
+    BACK_QUOTE: 192,
+    OPEN_BRACKET: 219,
+    BACK_SLASH: 220,
+    CLOSE_BRACKET: 221,
+    QUOTE: 222,
+    META: 224
+};
+export let MouseCodes = {
+    LEFT: 0,
+    RIGHT: 1,
+    MIDDLE: 2
+};