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

package/src/api/camera/ICamera.ts

@@ -0,0 +1,52 @@
+import type { IDisposable } from "../core/IDisposable.ts";
+import {mat4} from "gl-matrix"
+import type { IUniformBuffer } from "../rendering/buffers/IUniformBuffer.ts";
+import {GameTime} from "../time/GameTime.ts";
+
+/** The camera interface. */
+export interface ICamera extends IDisposable {
+
+    /**
+     * The projection matrix.
+     */
+    readonly projectionMatrix: mat4;
+
+    /**
+     * The view matrix.
+     */
+    readonly viewMatrix: mat4;
+
+    /**
+     * The projection view matrix.
+     */
+    readonly projectionViewMatrix: mat4;
+
+    /**
+     * The projection view buffer.
+     */
+    readonly projectionViewBuffer: IUniformBuffer;
+
+    /**
+     * The projection buffer.
+     */
+    readonly projectionBuffer: IUniformBuffer;
+
+    /**
+     * The view buffer.
+     */
+    readonly viewBuffer: IUniformBuffer;
+
+    /**
+     * Update the GPU buffers.
+     * This needs to be called when camera properties are changed.
+     */
+    updateBuffers(): void;
+
+    /**
+     * Update the camera.
+     * @param time - The game time object.
+     Use this for time-based movements.
+     */
+    update(time: GameTime): void;
+
+}

package/src/api/camera/ICameraFactory.ts

@@ -0,0 +1,69 @@
+import type { IOrthographicCamera } from "./IOrthographicCamera.ts";
+import {vec2} from "gl-matrix";
+import {OrbitCamera} from "./OrbitCamera.ts";
+import {PerspectiveCamera} from "./PerspectiveCamera.ts";
+
+/**
+ * The camera factory.
+ */
+export interface ICameraFactory {
+
+    /**
+     * Creates a new perspective camera.
+     * @param fov The field of view. By default, 60 degrees.
+     * @param aspectRatio The aspect ratio. By default, 1.
+     * @param near The near plane. By default, 0.01.
+     * @param far The far plane. By default, 100.
+     * @return The perspective camera.
+     */
+    createPerspectiveCamera(
+        fov?: number,
+        aspectRatio?: number,
+        near?: number,
+        far?: number): PerspectiveCamera;
+
+    /**
+     * Creates a new orthographic camera which is suitable for 2D games, or for UI rendering.
+     * Also, suitable when orthographic projection is required, such as shadow mapping.
+     * @param left - The left edge of the camera volume.
+     * @param right - The right edge of the camera volume.
+     * @param top - The top edge of the camera volume.
+     * @param bottom - The bottom edge of the camera volume.
+     * @param far - The far plane.
+     * @param near - The near plane.
+     * @returns The orthographic camera.
+     */
+    createOrthographicCamera(left: number, right: number, top: number, bottom: number, near: number, far: number): IOrthographicCamera;
+
+    /**
+     * The default orthographic camera.
+     * @param origin - The origin point of the camera.
+     * @returns The default orthographic camera.
+     */
+    createDefaultOrthographicCamera(origin?: vec2): IOrthographicCamera;
+
+    /**
+     * Creates a new Orbit Camera.
+     * @param fov - The field of view. By default, 60 degrees.
+     * @param aspectRatio - The aspect ratio. By default, 1.
+     * @param near - The near plane. By default, 0.01f.
+     * @param far - The far plane. By default, 100.0f.
+     * @returns The camera that acts as free and orbit camera.
+     */
+    createOrbitCamera(fov?: number, aspectRatio?: number, near?: number, far?: number): OrbitCamera;
+
+    /**
+     * Creates a new .
+     *
+     * Holds both free camera and orbit camera like controls.
+     *
+     * Suitable for editor.
+     * @param fov - The field of view. By default, 60 degrees.
+     * @param aspectRatio - The aspect ratio. By default, 1.
+     * @param near - The near plane. By default, 0.01f.
+     * @param far - The far plane. By default, 100.0f.
+     * @returns The camera that acts as free and orbit camera.
+     */
+    // createFreeAndOrbitCamera(fov: number, aspectRatio: number, near: number, far: number): FreeAndOrbitCamera;
+
+}

package/src/api/camera/IOrthographicCamera.ts

@@ -0,0 +1,38 @@
+import type { ICamera } from "./ICamera.ts";
+
+/**
+ * The orthographic camera interface.
+ */
+export interface IOrthographicCamera extends ICamera {
+
+    /**
+     * The left edge of a camera volume.
+     */
+    left: number;
+
+    /**
+     * The right edge of a camera volume.
+     */
+    right: number;
+
+    /**
+     * The top edge of a camera volume.
+     */
+    top: number;
+
+    /**
+     * The bottom edge of a camera volume.
+     */
+    bottom: number;
+
+    /**
+     * The near plane of the camera.
+     */
+    nearPlane: number;
+
+    /**
+     * The far plane of the camera.
+     */
+    farPlane: number;
+
+}

package/src/api/camera/OrbitCamera.ts

@@ -0,0 +1,402 @@
+import {vec3, mat4, vec2} from "gl-matrix";
+import type { IUniformBuffer } from "../rendering/buffers/IUniformBuffer.ts";
+import {PerspectiveCamera} from "./PerspectiveCamera.ts";
+import type { IInputManager } from "../input/IInputManager.ts";
+import {MathHelper} from "../utilities/MathHelper.ts";
+import type { ICamera } from "./ICamera.ts";
+import {MouseState} from "../input/mouse/MouseState.ts";
+import {GameTime} from "../time/GameTime.ts";
+import {MouseButton} from "../input/mouse/MouseButton.ts";
+import {TouchCollection} from "../input/touch/TouchCollection.ts";
+import {TouchLocation} from "../input/touch/TouchLocation.ts";
+import {InputDeviceType} from "../input/InputDeviceType.ts";
+
+/**
+ * Camerae that support orbit movement.
+ */
+export class OrbitCamera implements ICamera {
+
+    private readonly POSITIVE_89_DEG = 1.55334;
+    private readonly POSITIVE_179_DEG = 3.124139;
+
+    private readonly _tempVec3 = vec3.create();
+    private readonly _tempDirection = vec3.create();
+    private readonly _tempNextDirection = vec3.create();
+    private readonly _tempNextEye = vec3.create();
+
+    /** For pinch zoom. The distance between the two touches on the previous pinch frame. */
+    private _lastTouchDistance = 0;
+
+    private readonly _coreCamera: PerspectiveCamera;
+    private readonly _inputManager: IInputManager
+
+    /** The rotation around the vertical axis. */
+    private _yaw = 0;
+
+    /** The tilt of the camera.*/
+    private _pitch = 0;
+
+    /**
+     * The constructor.
+     * @param coreCamera The underlying core camera.
+     * @param inputManager The input manager.
+     * @param supportedInputTypes The input devices that control the camera.
+     */
+    public constructor(coreCamera: PerspectiveCamera,
+                       inputManager: IInputManager,
+                       public supportedInputTypes: InputDeviceType = InputDeviceType.MOUSE | InputDeviceType.TOUCHPAD) {
+        this._coreCamera = coreCamera;
+        this._inputManager = inputManager;
+        this.eye = vec3.fromValues(0, 0, -3);
+        this.target = vec3.fromValues(0, 0, 0);
+        void this.POSITIVE_179_DEG;
+        void this.findTarget;
+    }
+
+    /** The mouse sensitivity. */
+    public sensitivity = 0.05;
+
+    /** The speed of scrolling related options. */
+    public scrollSpeed = 1;
+
+    /** The maximum scrolling speed. */
+    public maxScrollSpeed: number = 50;
+
+    /** The speed of pinch.*/
+    public pinchSpeed: number = 1;
+
+    /** The up vector. */
+    public up = vec3.fromValues(0, 1, 0);
+
+    /** The clamp values of pitch axis */
+    public pitchClamp = vec2.fromValues(-this.POSITIVE_89_DEG, this.POSITIVE_89_DEG);
+
+    /** @inheritDoc */
+    public get projectionViewBuffer(): IUniformBuffer {
+        return this._coreCamera.projectionViewBuffer;
+    }
+
+    /** @inheritDoc */
+    public get projectionBuffer(): IUniformBuffer {
+        return this._coreCamera.projectionBuffer;
+    }
+
+    /** @inheritDoc */
+    public get viewBuffer(): IUniformBuffer {
+        return this._coreCamera.viewBuffer;
+    }
+
+    /** @inheritDoc */
+    public get positionBuffer(): IUniformBuffer {
+        return this._coreCamera.positionBuffer;
+    }
+
+    /** @inheritDoc */
+    public get projectionMatrix(): mat4 {
+        return this._coreCamera.projectionMatrix;
+    }
+
+    /** @inheritDoc */
+    public get viewMatrix(): mat4 {
+        return this._coreCamera.viewMatrix;
+    }
+
+    /** @inheritDoc */
+    public set viewMatrix(value: mat4) {
+        this._coreCamera.viewMatrix = value;
+    }
+
+    /** @inheritDoc */
+    public get projectionViewMatrix(): mat4 {
+        return this._coreCamera.projectionViewMatrix;
+    }
+
+    /** @inheritDoc */
+    public get direction(): vec3 {
+        return this._coreCamera.direction;
+    }
+
+    /** Orbit controls can be used if this button is pressed. */
+    public orbitButton = MouseButton.LEFT;
+
+    /**
+     * The eye position of the camera.
+     */
+    public get eye(): vec3 {
+        return this._coreCamera.eye;
+    }
+
+    /**
+     * The eye position of the camera.
+     */
+    public set eye(value: vec3) {
+        this._coreCamera.eye = value;
+        this._setPitchAndYawFromDirection(this._coreCamera.direction);
+    }
+
+    /**
+     * The eye position of the camera.
+     */
+    public get target(): vec3 {
+        return this._coreCamera.target;
+    }
+
+    /**
+     * The eye position of the camera.
+     */
+    public set target(value: vec3) {
+        this._coreCamera.target = value;
+        this._setPitchAndYawFromDirection(this._coreCamera.direction);
+    }
+
+    /** Gets the core camera.*/
+    public get coreCamera(): ICamera | undefined {
+        return this._coreCamera;
+    }
+
+    /**
+     * Find a target from yaw and pitch.
+     */
+    private findTarget(): void {
+        throw new Error('Not implemented');
+    }
+
+
+    /** @inheritDoc */
+    public initialize(): void {
+        throw new Error('Not implemented');
+    }
+
+    public updateBuffers(): void {
+        throw new Error('Not implemented');
+    }
+
+    private _pitchClamp(value: number): number {
+        return MathHelper.clamp(value, this.pitchClamp[0], this.pitchClamp[1]);
+    }
+
+    /**
+     * Sets the pitch and yaw from look direction.
+     * @param lookDirection The direction.
+     * @private
+     */
+    private _setPitchAndYawFromDirection(lookDirection: vec3) {
+        vec3.normalize(lookDirection, lookDirection);
+        const y = MathHelper.clamp(lookDirection[1], -1, 1);
+        this._pitch = -this._pitchClamp(Math.asin(y));
+        this._yaw = -Math.atan2(lookDirection[0], lookDirection[2]);
+    }
+
+    private _calculateOrbitMovement() {
+        // Clamp between [1.0, 179.0] degrees.
+        this._pitch = this._pitchClamp(this._pitch);
+
+        // Convert spherical coordinates to Cartesian
+        vec3.sub(this._tempVec3, this._coreCamera.target, this._coreCamera.eye);
+        const radius = vec3.len(this._tempVec3);
+
+        const sinPitch = Math.sin(this._pitch);
+        const cosPitch = Math.cos(this._pitch);
+
+        const x = radius * cosPitch * Math.sin(this._yaw);
+        const y = radius * sinPitch;
+        const z = radius * cosPitch * Math.cos(this._yaw);
+
+        this._tempVec3[0] = x;
+        this._tempVec3[1] = y;
+        this._tempVec3[2] = -z;
+        vec3.add(this._coreCamera.eye, this._coreCamera.target, this._tempVec3);
+    }
+
+    /**
+     * Handles the mouse movement for orbit camera.
+     * @param mouseState The mouse state.
+     * @param deltaTime The delta time.
+     */
+    private _handleOrbitMouseMovement(mouseState: MouseState, deltaTime: number): void {
+        const dt = deltaTime * this.sensitivity;
+        this._yaw -= mouseState.dX * dt;
+        this._pitch += mouseState.dY * dt;
+        this._calculateOrbitMovement();
+    }
+
+    /**
+     * Handles touch orbit and pinch zoom.
+     * One finger down orbits. Two fingers down pinch. Released and cancelled contacts are ignored.
+     * @param touches The touch locations.
+     * @param deltaTime The delta time.
+     */
+    private _handleOrbitTouch(touches: TouchCollection, deltaTime: number): void {
+        let down = 0;
+        let first: TouchLocation | undefined;
+        let second: TouchLocation | undefined;
+        const count = touches.count;
+        for (let i = 0; i < count; i++) {
+            const touch = touches.get(i);
+            if (touch === undefined || !touch.isDown) {
+                continue;
+            }
+            if (down === 0) {
+                first = touch;
+            } else if (down === 1) {
+                second = touch;
+            }
+            down++;
+        }
+
+        // One finger orbits.
+        if (down === 1 && first !== undefined) {
+            const dt = deltaTime * this.sensitivity;
+            this._yaw -= first.dX * dt;
+            this._pitch += first.dY * dt;
+            this._calculateOrbitMovement();
+            return;
+        }
+
+        if (down !== 2 || first === undefined || second === undefined) {
+            return;
+        }
+
+        const d = vec2.distance(first.position, second.position);
+        const diff = d - this._lastTouchDistance;
+        this._lastTouchDistance = d;
+
+        // Nothing to do, same distance.
+        if(diff == 0) {
+            return;
+        }
+
+        // Find the current distance.
+        vec3.copy(this._tempDirection, this.direction);
+
+        // Find the next eye position.
+        vec3.normalize(this._tempDirection, this._tempDirection);
+        vec3.copy(this._tempNextEye, this.eye);
+
+        if (diff < 0) {
+            vec3.scale(this._tempVec3, this._tempDirection, this.pinchSpeed * deltaTime);
+            vec3.sub(this._tempNextEye, this._tempNextEye, this._tempVec3);
+        } else {
+            vec3.scale(this._tempVec3, this._tempDirection, this.pinchSpeed * deltaTime);
+            vec3.add(this._tempNextEye, this._tempNextEye, this._tempVec3);
+        }
+
+        // Find the new potential length.
+        vec3.sub(this._tempNextDirection, this.target, this._tempNextEye);
+        const nextLength = this._tempNextDirection.length;
+        vec3.normalize(this._tempNextDirection, this._tempNextDirection);
+
+        // Difference between next direction and direction.
+        vec3.sub(this._tempVec3, this._tempNextDirection, this._tempDirection);
+        const lenSq =vec3.sqrLen(this._tempVec3);
+
+        // Only if within bounds set and no change in direction of a vector.
+        if (nextLength < this._coreCamera.nearPlane
+            || nextLength > this._coreCamera.farPlane
+            || lenSq > 0.1
+        ) {
+            return;
+        }
+
+        vec3.copy(this._coreCamera.eye, this._tempNextEye);
+        this._setPitchAndYawFromDirection(this._coreCamera.direction);
+    }
+
+    /** Handles forward/backward movement */
+    private _handleMouseForwardBackwardMovement(mouseState: MouseState, deltaTime: number) {
+
+        const mouseScrollPos = mouseState.scrollWheelPosition[1];
+
+        if (mouseScrollPos == 0) {
+            return;
+        }
+
+        // Find the current distance.
+        vec3.copy(this._tempDirection, this.direction);
+        const distance = vec3.len(this._tempDirection);
+
+        // Map it to [1,0.1f] space.
+        const step = MathHelper.map(distance,
+            this._coreCamera.nearPlane, this._coreCamera.farPlane,
+            1, 0.1);
+
+        // Scroll speed is scaled with the distance between eye and target.
+        // - The closer the target is, the slower the scroll speed.
+        let trueScrollSpeed = step * this.scrollSpeed;
+
+        // Clamp to the max scroll speed.
+        if (trueScrollSpeed > this.maxScrollSpeed) {
+            trueScrollSpeed = this.maxScrollSpeed;
+        }
+
+        // Find the next eye position.
+        vec3.normalize(this._tempDirection, this._tempDirection);
+        vec3.copy(this._tempNextEye, this.eye);
+
+        if (mouseScrollPos > 0) {
+            vec3.scale(this._tempVec3, this._tempDirection, trueScrollSpeed * deltaTime);
+            vec3.sub(this._tempNextEye, this._tempNextEye, this._tempVec3);
+        } else {
+            vec3.scale(this._tempVec3, this._tempDirection, trueScrollSpeed * deltaTime);
+            vec3.add(this._tempNextEye, this._tempNextEye, this._tempVec3);
+        }
+
+        // Find the new potential length.
+        vec3.sub(this._tempNextDirection, this.target, this._tempNextEye);
+        const nextLength = this._tempNextDirection.length;
+        vec3.normalize(this._tempNextDirection, this._tempNextDirection);
+
+        // Difference between next direction and direction.
+        vec3.sub(this._tempVec3, this._tempNextDirection, this._tempDirection);
+        const lenSq =vec3.sqrLen(this._tempVec3);
+
+        // Only if within bounds set and no change in direction of a vector.
+        if (nextLength < this._coreCamera.nearPlane
+            || nextLength > this._coreCamera.farPlane
+            || lenSq > 0.01
+        ) {
+            return;
+        }
+
+        vec3.copy(this._coreCamera.eye, this._tempNextEye);
+        this._setPitchAndYawFromDirection(this._coreCamera.direction);
+    }
+
+    /** @inheritDoc */
+    public update(time: GameTime): void {
+
+        //  vec3.sub(this._tempVec3, this.target, this.eye);
+        // this._setPitchAndYawFromDirection(this._tempVec3);
+
+        const deltaTime = time.deltaTimeSec;
+
+        const mouseSupported = (this.supportedInputTypes & InputDeviceType.MOUSE) !== 0;
+        const touchSupported = (this.supportedInputTypes & InputDeviceType.TOUCHPAD) !== 0;
+
+        // Control pitch and yaw with mouse.
+        const mouseState = this._inputManager.getMouseState();
+
+        // If we have a mouse, use mouse.
+        if (mouseSupported && mouseState.isButtonDown(this.orbitButton)) {
+            this._handleOrbitMouseMovement(mouseState, deltaTime);
+        } else {
+
+            // Otherwise orbit and pinch with touch.
+            if (touchSupported) {
+                this._handleOrbitTouch(this._inputManager.getTouchCollection(), deltaTime);
+            }
+
+            // Usually done with scroll wheel.
+            if (mouseSupported) {
+                this._handleMouseForwardBackwardMovement(mouseState, deltaTime);
+            }
+        }
+
+        this._coreCamera.update(time);
+    }
+
+    /** @inheritDoc */
+    public dispose(): void {
+        this._coreCamera.dispose();
+    }
+}