Move TrackablePointer and TrackablePointerPhase to a separate file

src/trackers/pointer-tracker/pointer-tracker.ts

 
 import Speedy from 'speedy-vision';
 import { SpeedyPromise } from 'speedy-vision/types/core/speedy-promise';
-import { Trackable, TrackerResult, TrackerOutput, Tracker } from '../tracker';
+import { TrackerResult, TrackerOutput, Tracker } from '../tracker';
+import { TrackablePointer, TrackablePointerPhase } from './trackable-pointer';
 import { PointerSource } from '../../sources/pointer-source';
 import { Vector2 } from '../../geometry/vector2';
 import { Utils, Nullable } from '../../utils/utils';
 import { Viewport } from '../../core/viewport';
 
 /**
- * The possible phases of a TrackablePointer
- */
-export type TrackablePointerPhase = 'began' | 'moved' | 'stationary' | 'ended' | 'canceled';
-
-/**
- * A trackable representing an instance of pointer-based input such as a mouse
- * click or a touch on the screen
- */
-export interface TrackablePointer extends Trackable
-{
-    /** a unique identifier assigned to this trackable */
-    readonly id: number;
-
-    /** the phase of the trackable */
-    readonly phase: TrackablePointerPhase;
-
-    /** current position in normalized coordinates [-1,1]x[-1,1] */
-    readonly position: Vector2;
-
-    /** the position delta since the last frame */
-    readonly deltaPosition: Vector2;
-
-    /** the first position of this trackable, given in normalized coordinates */
-    readonly initialPosition: Vector2;
-
-    /** the current velocity, given in normalized coordinates per second */
-    readonly velocity: Vector2;
-
-    /** whether or not this is the primary pointer for this type */
-    readonly isPrimary: boolean;
-
-    /** the type of the originating device; typically "mouse", "touch" or "pen" */
-    readonly type: string;
-}
-
-/**
  * A result of a PointerTracker. It's meant to be consumed by the user/application
  */
 export interface PointerTrackerResult extends TrackerResult
     /** new pointers */
     private _newPointers: Map<number, TrackablePointer>;
 
-    /** last output */
-    private _lastOutput: PointerTrackerOutput;
+    /** previous output */
+    private _previousOutput: PointerTrackerOutput;
 
-    /** time of the last update */
-    private _lastUpdateTime: DOMHighResTimeStamp;
+    /** time of the previous update */
+    private _previousUpdateTime: DOMHighResTimeStamp;
 
 
 
         this._viewport = null;
         this._activePointers = new Map();
         this._newPointers = new Map();
-        this._lastOutput = this._generateOutput();
-        this._lastUpdateTime = Number.POSITIVE_INFINITY;
+        this._previousOutput = this._generateOutput();
+        this._previousUpdateTime = Number.POSITIVE_INFINITY;
     }
 
     /**
         const canvas = this._viewport!.canvas;
         const rect = canvas.getBoundingClientRect(); // may be different in different frames!
 
-        // find the time between this and the last update of this tracker
+        // find the time between this and the previous update of this tracker
         const deltaTime = this._updateTime();
         const inverseDeltaTime = (deltaTime > 1e-5) ? 1 / deltaTime : 60; // 1/dt = 1 / (1/60) with 60 fps
 
         this._newPointers.clear();
 
         // generate output
-        this._lastOutput = this._generateOutput();
+        this._previousOutput = this._generateOutput();
 
         // test
-        //console.log(JSON.stringify(this._lastOutput.exports.trackables, null, 4));
+        //console.log(JSON.stringify(this._prevOutput.exports.trackables, null, 4));
 
         // done!
         return Speedy.Promise.resolve();
     }
 
     /**
-     * Output of the last frame
+     * Output of the previous frame
      * @internal
      */
     get _output(): PointerTrackerOutput
     {
-        return this._lastOutput;
+        return this._previousOutput;
     }
 
     /**
     {
         const now = performance.now() * 0.001;
 
-        if(this._lastUpdateTime > now)
-            this._lastUpdateTime = now;
+        if(this._previousUpdateTime > now)
+            this._previousUpdateTime = now;
 
-        const prev = this._lastUpdateTime;
-        this._lastUpdateTime = now;
+        const prev = this._previousUpdateTime;
+        this._previousUpdateTime = now;
 
         return now - prev;
     }

src/trackers/pointer-tracker/trackable-pointer.ts

+/*
+ * encantar.js
+ * GPU-accelerated Augmented Reality for the web
+ * Copyright (C) 2022-2024 Alexandre Martins <alemartf(at)gmail.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * trackable-pointer.ts
+ * A trackable representing an instance of pointer-based input
+ */
+
+import { Trackable } from '../tracker';
+import { Vector2 } from '../../geometry/vector2';
+
+/**
+ * The phase of a TrackablePointer. Possible values:
+ * - "began": the tracking began in this frame (e.g., a finger has just touched the screen)
+ * - "stationary": the user did not move the pointer in this frame
+ * - "moved": the user moved the pointer in this frame
+ * - "ended": the tracking ended in this frame (e.g., a finger has just been lifted from the screen)
+ * - "canceled": the tracking was canceled in this frame (e.g., the screen orientation of the device has just been changed)
+ */
+export type TrackablePointerPhase = 'began' | 'moved' | 'stationary' | 'ended' | 'canceled';
+
+/**
+ * A trackable representing an instance of pointer-based input
+ */
+export interface TrackablePointer extends Trackable
+{
+    /** a unique identifier assigned to this pointer */
+    readonly id: number;
+
+    /** the phase of the pointer */
+    readonly phase: TrackablePointerPhase;
+
+    /** current position in normalized coordinates [-1,1]x[-1,1] */
+    readonly position: Vector2;
+
+    /** the difference between the position of the pointer in this and in the previous frame */
+    readonly deltaPosition: Vector2;
+
+    /** the position of the pointer when its tracking began */
+    readonly initialPosition: Vector2;
+
+    /** current velocity, given in normalized coordinates per second */
+    readonly velocity: Vector2;
+
+    /** whether or not this is the primary pointer for this type */
+    readonly isPrimary: boolean;
+
+    /** the type of the originating device; typically "mouse", "touch" or "pen" */
+    readonly type: string;
+}