ris-framework 0.1.0-dev.7 → 0.1.0-dev.9

package/src/api/input/KeyboardState.ts

@@ -0,0 +1,44 @@
+import {Key} from "./Key.ts";
+
+/**
+ * The keyboard state.
+ */
+export class KeyboardState {
+
+    /**
+     * The constructor.
+     * @param downKeys - The keys that are down.
+     * @param releasedKeys - The keys that are just released.
+     */
+    public constructor(private readonly _downKeys: { [key: number]: boolean },
+                       private readonly _releasedKeys: { [key: number]: boolean }) {
+    }
+
+    /**
+     * Returns true if key is down in current frame.
+     * @param key - The key to check.
+     * @returns True if key is down.
+     */
+    public isKeyDown(key: Key): boolean {
+        return this._downKeys[key];
+    }
+
+    /**
+     * Returns true if key is up in current frame.
+     * @param key - The key to check.
+     * @returns True if key is up.
+     */
+    public isKeyUp(key: Key): boolean {
+        return !this.isKeyDown(key);
+    }
+
+    /**
+     * Returns true if the key was just released in current frame.
+     * @param key - The key to check.
+     * @returns True if key is released in current frame.
+     */
+    public isKeyReleased(key: Key): boolean {
+        return this._releasedKeys[key];
+    }
+
+}

package/src/api/input/_export.ts

@@ -0,0 +1,13 @@
+export * from "./IInputManager.ts"
+export * from "./mouse/MouseState.ts"
+export * from "./gamepad/GamePadState.ts"
+export * from "./gamepad/GamePadThumbSticks.ts"
+export * from "./KeyboardState.ts"
+export * from "./Key.ts"
+export * from "./gamepad/Button.ts"
+export * from "./mouse/MouseButton.ts"
+export * from "./touch/TouchLocationState.ts"
+export * from "./touch/TouchLocation.ts"
+export * from "./touch/TouchCollection.ts"
+export * from "./touch/TouchPanelCapabilities.ts"
+export * from "./InputDeviceType.ts"

package/src/api/input/gamepad/Button.ts

@@ -0,0 +1,21 @@
+/**
+ * The buttons of the gamepad.
+ */
+export enum Button {
+  NONE = 0,
+  A = 1,
+  B = 2,
+  BACK = 3,
+  BIGBUTTON = 4,
+  DPADDOWN = 5,
+  DPADLEFT = 6,
+  DPADRIGHT = 7,
+  DPADUP = 8,
+  LEFTSHOULDER = 9,
+  LEFTSTICK = 10,
+  RIGHTSHOULDER = 11,
+  RIGHTSTICK = 12,
+  START = 13,
+  X = 14,
+  Y = 15
+}

package/src/api/input/gamepad/GamePadState.ts

@@ -0,0 +1,65 @@
+import {GamePadThumbSticks} from "./GamePadThumbSticks.ts";
+import {vec2} from "gl-matrix";
+import {Button} from "./Button.ts";
+
+/**
+ * The state of the gamepad.
+ */
+export class GamePadState {
+    private readonly _thumbSticks: GamePadThumbSticks;
+
+    /**
+     * The constructor.
+     * @param isConnected - Set to true if gamepad is connected.
+     * @param downButtons - The down buttons.
+     * @param releasedButtons - The released buttons.
+     * @param leftThumbstick - The left thumbstick position.
+     * @param rightThumbstick - The right thumbstick position.
+     */
+    public constructor(
+        public readonly isConnected: boolean,
+        private readonly _downButtons: { [key: number]: boolean },
+        private readonly _releasedButtons: { [key: number]: boolean },
+        leftThumbstick: vec2,
+        rightThumbstick: vec2
+    ) {
+        this._thumbSticks = new GamePadThumbSticks(
+            leftThumbstick,
+            rightThumbstick
+        );
+    }
+
+    /**
+     * The thumbstick positions.
+     */
+    public get thumbSticks(): GamePadThumbSticks {
+        return this._thumbSticks;
+    }
+
+    /**
+     * Check if the button is down.
+     * @param button - The button to check.
+     * @returns true if button is down, false otherwise.
+     */
+    public isButtonDown(button: Button): boolean {
+        return this._downButtons[button] ?? false;
+    }
+
+    /**
+     * Check if the button is up.
+     * @param button - The button to check.
+     * @returns true if button is up, false otherwise.
+     */
+    public isButtonUp(button: Button): boolean {
+        return !this.isButtonDown(button);
+    }
+
+    /**
+     * Check if the button is released in current frame.
+     * @param button - The button to check.
+     * @returns true if button is released.
+     */
+    public isButtonReleased(button: Button): boolean {
+        return this._releasedButtons[button] ?? false;
+    }
+}

package/src/api/input/gamepad/GamePadThumbSticks.ts

@@ -0,0 +1,18 @@
+import {vec2} from "gl-matrix";
+
+/**
+ * The thumbsticks of the gamepad.
+ * @param left - The left thumbstick.
+ * @param right - The right thumbstick.
+ */
+export class GamePadThumbSticks {
+
+    /**
+     * The thumbsticks of the gamepad.
+     * @param left - The left thumbstick.
+     * @param right - The right thumbstick.
+     */
+    public constructor(public left: vec2, public right: vec2) {
+    }
+
+}

package/src/api/input/mouse/MouseButton.ts

@@ -0,0 +1,9 @@
+/**
+ * The mouse buttons.
+ */
+export enum MouseButton {
+  NONE = 0,
+  LEFT = 1,
+  RIGHT = 2,
+  MIDDLE = 3
+}

package/src/api/input/mouse/MouseState.ts

@@ -0,0 +1,70 @@
+import {MouseButton} from "./MouseButton.ts";
+import {vec2} from "gl-matrix";
+
+/**
+ * The mouse state.
+ */
+export class MouseState {
+
+    /**
+     * The constructor. InputManager owns these objects and updates them in place.
+     * @param _downButtons - The buttons that are down, keyed by MouseButton.
+     * @param _releasedButtons - The buttons released this frame, keyed by MouseButton.
+     * @param position - The cursor position in viewport (clientX / clientY) CSS pixels.
+     * @param delta - The cursor movement since the previous frame.
+     * @param scrollWheelPosition - The wheel direction this frame. Each axis is -1, 0, or 1.
+     */
+    public constructor(private readonly _downButtons: { [key: number]: boolean },
+                       private readonly _releasedButtons: { [key: number]: boolean },
+                       public position: vec2,
+                       public delta: vec2,
+                       public scrollWheelPosition: vec2) {
+    }
+
+    /** The x position. */
+    public get x(): number {
+        return this.position[0];
+    }
+
+    /** The y position. */
+    public get y(): number {
+        return this.position[1];
+    }
+
+    /** The delta x.*/
+    public get dX(): number {
+        return this.delta[0];
+    }
+
+    /** The delta y. */
+    public get dY(): number {
+        return this.delta[1];
+    }
+
+    /**
+     * Returns true if MouseButton is down in current frame.
+     * @param button - The button to check.
+     * @returns True if button is down.
+     */
+    public isButtonDown(button: MouseButton): boolean {
+        return this._downButtons[button];
+    }
+
+    /**
+     * Returns true if the button is up in current frame.
+     * @param button - The button to check.
+     * @returns True if the button is up.
+     */
+    public isButtonUp(button: MouseButton): boolean {
+        return !this.isButtonDown(button);
+    }
+
+    /**
+     * Checks if the button is released in current frame.
+     * @param button - The button to check.
+     * @returns True if the button is released in current frame.
+     */
+    public isButtonReleased(button: MouseButton): boolean {
+        return this._releasedButtons[button];
+    }
+}

package/src/api/input/touch/TouchCollection.ts

@@ -0,0 +1,164 @@
+import {TouchLocation} from "./TouchLocation.ts";
+import {TouchLocationState} from "./TouchLocationState.ts";
+
+/**
+ * The touch locations for one frame.
+ * Slots are allocated once. clear and tryAdd reuse them, and reads do not allocate.
+ */
+export class TouchCollection {
+
+    /** Default number of simultaneous touches the collection stores. */
+    public static readonly MAX_TOUCH_COUNT = 8;
+
+    /** The fixed number of slots in this collection. */
+    public readonly maxTouchCount: number;
+
+    private readonly _locations: TouchLocation[];
+    private _count = 0;
+    private _activeCount = 0;
+
+    /**
+     * The constructor.
+     * @param maxTouchCount The fixed slot count. Values below 1 store no touches. The default is MAX_TOUCH_COUNT.
+     */
+    public constructor(maxTouchCount = TouchCollection.MAX_TOUCH_COUNT) {
+        const capacity = maxTouchCount > 0 ? Math.floor(maxTouchCount) : 0;
+        this.maxTouchCount = capacity;
+        const locations = new Array<TouchLocation>(capacity);
+        for (let i = 0; i < capacity; i++) {
+            locations[i] = new TouchLocation();
+        }
+        this._locations = locations;
+    }
+
+    /** The number of touch locations written this frame, including releases. */
+    public get count(): number {
+        return this._count;
+    }
+
+    /**
+     * The number of touches that were down when they were written.
+     * Pressed and moved contacts count. Released, cancelled, and invalid contacts do not.
+     * This is stored while contacts are written, not counted again on read.
+     */
+    public get activeCount(): number {
+        return this._activeCount;
+    }
+
+    /**
+     * Drops the frame's contacts.
+     * Slots stay allocated. The next tryAdd reuses them from the start.
+     */
+    public clear(): void {
+        this._count = 0;
+        this._activeCount = 0;
+    }
+
+    /**
+     * Writes the next contact into the next free slot.
+     * @param id The touch id.
+     * @param state The touch location state.
+     * @param x The x position.
+     * @param y The y position.
+     * @param pressure The pressure.
+     * @param previousState The previous state. Omit it when this is the first sample.
+     * @param previousX The previous x position.
+     * @param previousY The previous y position.
+     * @param previousPressure The previous pressure.
+     * @returns The slot that was written, or undefined when every slot is already used.
+     */
+    public tryAdd(id: number,
+                  state: TouchLocationState,
+                  x: number,
+                  y: number,
+                  pressure = 0,
+                  previousState?: TouchLocationState,
+                  previousX = 0,
+                  previousY = 0,
+                  previousPressure = 0): TouchLocation | undefined {
+        if (this._count >= this._locations.length) {
+            return undefined;
+        }
+
+        const location = this._locations[this._count];
+        location.write(id, state, x, y, pressure);
+        if (previousState !== undefined) {
+            location.writePrevious(previousState, previousX, previousY, previousPressure);
+        }
+
+        this._count++;
+        if (location.isDown) {
+            this._activeCount++;
+        }
+        return location;
+    }
+
+    /**
+     * The touch at an index in this frame.
+     * @param index The index, from 0 to count - 1.
+     * @returns The stored location, or undefined when the index is outside this frame.
+     */
+    public get(index: number): TouchLocation | undefined {
+        if (index < 0 || index >= this._count) {
+            return undefined;
+        }
+        return this._locations[index];
+    }
+
+    /**
+     * Finds a touch by id.
+     * Scans only the contacts written this frame. The first match wins.
+     * @param id The touch id.
+     * @returns The stored location, or undefined when this frame has no contact with that id.
+     */
+    public findById(id: number): TouchLocation | undefined {
+        const count = this._count;
+        const locations = this._locations;
+        for (let i = 0; i < count; i++) {
+            const location = locations[i];
+            if (location.id === id) {
+                return location;
+            }
+        }
+        return undefined;
+    }
+
+    /**
+     * True when the contact with this id is down.
+     * A missing id is not down.
+     * @param id The touch id.
+     */
+    public isDown(id: number): boolean {
+        const location = this.findById(id);
+        if (location === undefined) {
+            return false;
+        }
+        return location.isDown;
+    }
+
+    /**
+     * True when the contact with this id was released this frame.
+     * A missing id was not released.
+     * @param id The touch id.
+     */
+    public isReleased(id: number): boolean {
+        const location = this.findById(id);
+        if (location === undefined) {
+            return false;
+        }
+        return location.isReleased();
+    }
+
+    /**
+     * True when the contact with this id was cancelled this frame.
+     * A missing id was not cancelled. A cancel is not a release.
+     * @param id The touch id.
+     */
+    public isCancelled(id: number): boolean {
+        const location = this.findById(id);
+        if (location === undefined) {
+            return false;
+        }
+        return location.isCancelled();
+    }
+}

package/src/api/input/touch/TouchLocation.ts

@@ -0,0 +1,159 @@
+import {vec2} from "gl-matrix";
+import {TouchLocationState} from "./TouchLocationState.ts";
+
+/**
+ * A single touch contact.
+ * Position, delta, and the previous sample are stored on this object.
+ * Reading them again returns those same instances.
+ */
+export class TouchLocation {
+
+    /** The touch id. Stable for the lifetime of the contact. */
+    public id = 0;
+
+    /** The pressure, from 0 to 1. 0 when the device does not report pressure. */
+    public pressure = 0;
+
+    /**
+     * The position of the touch.
+     * Viewport coordinates in CSS pixels, the same space as MouseState (clientX, clientY).
+     */
+    public readonly position: vec2 = vec2.create();
+
+    /**
+     * The delta from the previous sample. Zero when this frame has no previous sample.
+     * Viewport coordinates in CSS pixels, the same space as MouseState delta.
+     */
+    public readonly delta: vec2 = vec2.create();
+
+    /**
+     * True when the contact is pressed or moved.
+     * Updated when state is written.
+     */
+    public isDown = false;
+
+    private _state = TouchLocationState.INVALID;
+    private _hasPrevious = false;
+    private readonly _previous: TouchLocation | undefined;
+
+    /**
+     * The constructor.
+     * @param ownsPrevious True when this location keeps a previous sample. The previous sample does not keep one of its own.
+     */
+    public constructor(ownsPrevious = true) {
+        if (ownsPrevious) {
+            this._previous = new TouchLocation(false);
+        } else {
+            this._previous = undefined;
+        }
+    }
+
+    /** The touch location state. */
+    public get state(): TouchLocationState {
+        return this._state;
+    }
+
+    /** The touch location state. */
+    public set state(value: TouchLocationState) {
+        this._state = value;
+        this.isDown = value === TouchLocationState.PRESSED
+            || value === TouchLocationState.MOVED;
+    }
+
+    /** The x position. */
+    public get x(): number {
+        return this.position[0];
+    }
+
+    /** The y position. */
+    public get y(): number {
+        return this.position[1];
+    }
+
+    /** The delta x. */
+    public get dX(): number {
+        return this.delta[0];
+    }
+
+    /** The delta y. */
+    public get dY(): number {
+        return this.delta[1];
+    }
+
+    /** True when the contact started this frame. */
+    public isPressed(): boolean {
+        return this._state === TouchLocationState.PRESSED;
+    }
+
+    /** True when the contact moved while held. */
+    public isMoved(): boolean {
+        return this._state === TouchLocationState.MOVED;
+    }
+
+    /** True when the contact was released this frame. */
+    public isReleased(): boolean {
+        return this._state === TouchLocationState.RELEASED;
+    }
+
+    /** True when the contact was cancelled this frame. A cancel is not a finger lift. */
+    public isCancelled(): boolean {
+        return this._state === TouchLocationState.CANCELLED;
+    }
+
+    /**
+     * The previous sample of this contact.
+     * Undefined when this is the first sample. The same instance is returned for every call in the frame.
+     */
+    public tryGetPreviousLocation(): TouchLocation | undefined {
+        if (!this._hasPrevious) {
+            return undefined;
+        }
+        return this._previous;
+    }
+
+    /**
+     * Writes this sample.
+     * Clears the previous sample and sets delta to zero.
+     * @param id The touch id.
+     * @param state The touch location state.
+     * @param x The x position.
+     * @param y The y position.
+     * @param pressure The pressure.
+     */
+    public write(id: number,
+                 state: TouchLocationState,
+                 x: number,
+                 y: number,
+                 pressure: number): void {
+        this.id = id;
+        this.state = state;
+        this.position[0] = x;
+        this.position[1] = y;
+        this.pressure = pressure;
+        this._hasPrevious = false;
+        this.delta[0] = 0;
+        this.delta[1] = 0;
+    }
+
+    /**
+     * Writes the previous sample and caches delta as this position minus that position.
+     * @param state The previous touch location state.
+     * @param x The previous x position.
+     * @param y The previous y position.
+     * @param pressure The previous pressure.
+     */
+    public writePrevious(state: TouchLocationState,
+                         x: number,
+                         y: number,
+                         pressure: number): void {
+        const previous = this._previous;
+        if (previous === undefined) {
+            return;
+        }
+
+        previous.write(this.id, state, x, y, pressure);
+        this._hasPrevious = true;
+        this.delta[0] = this.position[0] - x;
+        this.delta[1] = this.position[1] - y;
+    }
+}

package/src/api/input/touch/TouchLocationState.ts

@@ -0,0 +1,15 @@
+/**
+ * The state of a touch location for the current frame.
+ */
+export enum TouchLocationState {
+    /** No contact. */
+    INVALID = 0,
+    /** The contact was released this frame. */
+    RELEASED = 1,
+    /** The contact started this frame. */
+    PRESSED = 2,
+    /** The contact moved while held. */
+    MOVED = 3,
+    /** The contact was cancelled this frame. This is not a finger lift. */
+    CANCELLED = 4,
+}

package/src/api/input/touch/TouchPanelCapabilities.ts

@@ -0,0 +1,31 @@
+/**
+ * Capabilities of the touch panel.
+ * Fields stay on this instance. Update them in place when the device changes.
+ */
+export class TouchPanelCapabilities {
+
+    /**
+     * The constructor.
+     * @param isConnected True when a touch device is connected.
+     * @param maximumTouchCount The maximum number of simultaneous touches. 0 when none are supported.
+     * @param hasPressure True when contacts report pressure.
+     */
+    public constructor(public isConnected: boolean,
+                       public maximumTouchCount: number,
+                       public hasPressure: boolean) {
+    }
+
+    /**
+     * Writes new capabilities into this instance.
+     * @param isConnected True when a touch device is connected.
+     * @param maximumTouchCount The maximum number of simultaneous touches. 0 when none are supported.
+     * @param hasPressure True when contacts report pressure.
+     */
+    public set(isConnected: boolean,
+               maximumTouchCount: number,
+               hasPressure: boolean): void {
+        this.isConnected = isConnected;
+        this.maximumTouchCount = maximumTouchCount;
+        this.hasPressure = hasPressure;
+    }
+}

package/src/api/loaders/IImageLoader.ts

@@ -0,0 +1,22 @@
+import {RawImageData} from "../image/RawImageData.ts";
+
+/**
+ * The image loader interface.
+ */
+export interface IImageLoader {
+
+    /**
+     * Loads an image from a file.
+     * @param path - The file path.
+     * @param cache - Whether to cache the image in a persistent cache.
+     * @returns The raw image data.
+     */
+    loadAsync(path: string, cache?: boolean): Promise<RawImageData>;
+
+    /**
+     * Disposes of the temporary cache.
+     *
+     * Used internally, call only if you know what you are doing.
+     */
+    disposeOfTemporaryCache(): void;
+}