Vector2, Vector3, Quaternion: make the coordinates private

docs/api/quaternion.md

 
 ### x
 
-`quaternion.x: number`
+`quaternion.x: number, read-only`
 
 The x coordinate of the quaternion (imaginary).
 
 ### y
 
-`quaternion.y: number`
+`quaternion.y: number, read-only`
 
 The y coordinate of the quaternion (imaginary).
 
 ### z
 
-`quaternion.z: number`
+`quaternion.z: number, read-only`
 
 The z coordinate of the quaternion (imaginary).
 
 ### w
 
-`quaternion.w: number`
+`quaternion.w: number, read-only`
 
 The w coordinate of the quaternion (real).
 
 
 `quaternion.length(): number`
 
-Compute the length of the quaternion: `sqrt(x^2 + y^2 + z^2 + w^2)`.
+Compute the magnitude of the quaternion.
 
 **Returns**
 
-The length of the quaternion.
+The magnitude of the quaternion.
 
 ### equals
 

docs/api/vector2.md

 
 ### x
 
-`vector.x: number`
+`vector.x: number, read-only`
 
 The x coordinate of the vector.
 
 ### y
 
-`vector.y: number`
+`vector.y: number, read-only`
 
 The y coordinate of the vector.
 
 
 `vector.length(): number`
 
-Compute the length of the vector: `sqrt(x^2 + y^2)`.
+Compute the magnitude of the vector.
 
 **Returns**
 
-The length of the vector.
+The magnitude of the vector.
 
 ### dot
 

docs/api/vector3.md

 
 ### x
 
-`vector.x: number`
+`vector.x: number, read-only`
 
 The x coordinate of the vector.
 
 ### y
 
-`vector.y: number`
+`vector.y: number, read-only`
 
 The y coordinate of the vector.
 
 ### z
 
-`vector.z: number`
+`vector.z: number, read-only`
 
 The z coordinate of the vector.
 
 
 `vector.length(): number`
 
-Compute the length of the vector: `sqrt(x^2 + y^2 + z^2)`.
+Compute the magnitude of the vector.
 
 **Returns**
 
-The length of the vector.
+The magnitude of the vector.
 
 ### dot
 

src/geometry/pose-filter.ts

             const w = (T - i) * d;
 
             // weighted avg: sum from i=0 to T-1 { (T-i) * t[i] } * (2/(T^2+T))
-            t.x += ti.x * w;
-            t.y += ti.y * w;
-            t.z += ti.z * w;
+            t._set(
+                t.x + ti.x * w,
+                t.y + ti.y * w,
+                t.z + ti.z * w
+            );
         }
 
         // average *nearby* rotations
                 // XXX since Quaternion._fromRotationMatrix() computes w >= 0,
                 // this will never happen. Leave this here for extra safety
                 // in case anything changes?
-                qi.x = -qi.x;
-                qi.y = -qi.y;
-                qi.z = -qi.z;
-                qi.w = -qi.w;
+                qi._set(
+                    -qi.x,
+                    -qi.y,
+                    -qi.z,
+                    -qi.w
+                );
             }
 
-            q.x += qi.x * w;
-            q.y += qi.y * w;
-            q.z += qi.z * w;
-            q.w += qi.w * w;
+            q._set(
+                q.x + qi.x * w,
+                q.y + qi.y * w,
+                q.z + qi.z * w,
+                q.w + qi.w * w
+            );
         }
         //q._normalize();
 

src/geometry/quaternion.ts

 export class Quaternion
 {
     /** x coordinate (imaginary) */
-    public x: number;
+    private _x: number;
 
     /** y coordinate (imaginary) */
-    public y: number;
+    private _y: number;
 
     /** z coordinate (imaginary) */
-    public z: number;
+    private _z: number;
 
     /** w coordinate (real) */
-    public w: number;
+    private _w: number;
 
 
 
      */
     constructor(x: number = 0, y: number = 0, z: number = 0, w: number = 1)
     {
-        this.x = +x;
-        this.y = +y;
-        this.z = +z;
-        this.w = +w;
+        this._x = +x;
+        this._y = +y;
+        this._z = +z;
+        this._w = +w;
     }
 
     /**
     }
 
     /**
+     * The x coordinate of the quaternion (imaginary)
+     */
+    get x(): number
+    {
+        return this._x;
+    }
+
+    /**
+     * The y coordinate of the quaternion (imaginary)
+     */
+    get y(): number
+    {
+        return this._y;
+    }
+
+    /**
+     * The z coordinate of the quaternion (imaginary)
+     */
+    get z(): number
+    {
+        return this._z;
+    }
+
+    /**
+     * The w coordinate of the quaternion (real)
+     */
+    get w(): number
+    {
+        return this._w;
+    }
+
+    /**
      * The length of this quaternion
      * @returns sqrt(x^2 + y^2 + z^2 + w^2)
      */
     length(): number
     {
-        const x = this.x;
-        const y = this.y;
-        const z = this.z;
-        const w = this.w;
+        const x = this._x;
+        const y = this._y;
+        const z = this._z;
+        const w = this._w;
 
         return Math.sqrt(x*x + y*y + z*z + w*w);
     }
      */
     equals(q: Quaternion): boolean
     {
-        return this.w === q.w && this.x === q.x && this.y === q.y && this.z === q.z;
+        return this._w === q._w && this._x === q._x && this._y === q._y && this._z === q._z;
     }
 
     /**
      */
     toString(): string
     {
-        const x = this.x.toFixed(4);
-        const y = this.y.toFixed(4);
-        const z = this.z.toFixed(4);
-        const w = this.w.toFixed(4);
+        const x = this._x.toFixed(4);
+        const y = this._y.toFixed(4);
+        const z = this._z.toFixed(4);
+        const w = this._w.toFixed(4);
 
         return `Quaternion(${x},${y},${z},${w})`;
     }
         if(length < EPSILON) // zero?
             return this;
 
-        this.x /= length;
-        this.y /= length;
-        this.z /= length;
-        this.w /= length;
+        this._x /= length;
+        this._y /= length;
+        this._z /= length;
+        this._w /= length;
 
         return this;
     }
      */
     _conjugate(): Quaternion
     {
-        this.x = -this.x;
-        this.y = -this.y;
-        this.z = -this.z;
+        this._x = -this._x;
+        this._y = -this._y;
+        this._z = -this._z;
+
+        return this;
+    }
+
+    /**
+     * Set the coordinates of this quaternion
+     * @param x x-coordinate
+     * @param y y-coordinate
+     * @param z z-coordinate
+     * @param w w-coordinate
+     * @returns this quaternion
+     * @internal
+     */
+    _set(x: number, y: number, z: number, w: number): Quaternion
+    {
+        this._x = +x;
+        this._y = +y;
+        this._z = +z;
+        this._w = +w;
 
         return this;
     }
      */
     _copyFrom(q: Quaternion): Quaternion
     {
-        this.x = q.x;
-        this.y = q.y;
-        this.z = q.z;
-        this.w = q.w;
+        this._x = q._x;
+        this._y = q._y;
+        this._z = q._z;
+        this._w = q._w;
 
         return this;
     }
             return Speedy.Matrix.Eye(3);
 
         // let q = (x,y,z,w) be a unit quaternion
-        const x = this.x / length;
-        const y = this.y / length;
-        const z = this.z / length;
-        const w = this.w / length;
+        const x = this._x / length;
+        const y = this._y / length;
+        const z = this._z / length;
+        const w = this._w / length;
 
         /*
 
         const z = 0.5 * Math.sqrt(Math.max(0, tr - 2 * (m11 + m22))); // |z|
 
         const length = Math.sqrt(x*x + y*y + z*z + w*w); // should be ~ 1
-        this.x = (x * sx) / length;
-        this.y = (y * sy) / length;
-        this.z = (z * sz) / length;
-        this.w = w / length;
+        this._x = (x * sx) / length;
+        this._y = (y * sy) / length;
+        this._z = (z * sz) / length;
+        this._w = w / length;
 
         return this;
     }

src/geometry/vector2.ts

 export class Vector2
 {
     /** x coordinate */
-    public x: number;
+    private _x: number;
 
     /** y coordinate */
-    public y: number;
+    private _y: number;
 
 
 
      */
     constructor(x: number = 0, y: number = 0)
     {
-        this.x = +x;
-        this.y = +y;
+        this._x = +x;
+        this._y = +y;
     }
 
     /**
      */
     static get ZERO(): Vector2
     {
-        return ZERO || (ZERO = Object.freeze(Vector2.Zero()));
+        return ZERO || (ZERO = Object.freeze(Vector2.Zero()) as Vector2);
+    }
+
+    /**
+     * The x coordinate of the vector
+     */
+    get x(): number
+    {
+        return this._x;
+    }
+
+    /**
+     * The y coordinate of the vector
+     */
+    get y(): number
+    {
+        return this._y;
     }
 
     /**
      */
     length(): number
     {
-        const x = this.x;
-        const y = this.y;
+        const x = this._x;
+        const y = this._y;
 
         return Math.sqrt(x*x + y*y);
     }
      */
     dot(v: Vector2): number
     {
-        return this.x * v.x + this.y * v.y;
+        return this._x * v._x + this._y * v._y;
     }
 
     /**
      */
     distanceTo(v: Vector2): number
     {
-        const dx = this.x - v.x;
-        const dy = this.y - v.y;
+        const dx = this._x - v._x;
+        const dy = this._y - v._y;
 
         return Math.sqrt(dx*dx + dy*dy);
     }
      */
     equals(v: Vector2): boolean
     {
-        return this.x === v.x && this.y === v.y;
+        return this._x === v._x && this._y === v._y;
     }
 
     /**
      */
     toString(): string
     {
-        const x = this.x.toFixed(5);
-        const y = this.y.toFixed(5);
+        const x = this._x.toFixed(5);
+        const y = this._y.toFixed(5);
 
         return `Vector2(${x},${y})`;
     }
      */
     _clone(): Vector2
     {
-        return new Vector2(this.x, this.y);
+        return new Vector2(this._x, this._y);
     }
 
     /**
      */
     _set(x: number, y: number): Vector2
     {
-        this.x = +x;
-        this.y = +y;
+        this._x = +x;
+        this._y = +y;
 
         return this;
     }
      */
     _copyFrom(v: Vector2): Vector2
     {
-        this.x = v.x;
-        this.y = v.y;
+        this._x = v._x;
+        this._y = v._y;
 
         return this;
     }
         if(length < EPSILON) // zero?
             return this;
 
-        this.x /= length;
-        this.y /= length;
+        this._x /= length;
+        this._y /= length;
 
         return this;
     }
      */
     _add(v: Vector2): Vector2
     {
-        this.x += v.x;
-        this.y += v.y;
+        this._x += v._x;
+        this._y += v._y;
 
         return this;
     }
      */
     _subtract(v: Vector2): Vector2
     {
-        this.x -= v.x;
-        this.y -= v.y;
+        this._x -= v._x;
+        this._y -= v._y;
 
         return this;
     }
      */
     _scale(s: number): Vector2
     {
-        this.x *= s;
-        this.y *= s;
+        this._x *= s;
+        this._y *= s;
 
         return this;
     }

src/geometry/vector3.ts

 export class Vector3
 {
     /** x coordinate */
-    public x: number;
+    private _x: number;
 
     /** y coordinate */
-    public y: number;
+    private _y: number;
 
     /** z coordinate */
-    public z: number;
+    private _z: number;
 
 
 
      */
     constructor(x: number = 0, y: number = 0, z: number = 0)
     {
-        this.x = +x;
-        this.y = +y;
-        this.z = +z;
+        this._x = +x;
+        this._y = +y;
+        this._z = +z;
     }
 
     /**
      */
     static get ZERO(): Vector3
     {
-        return ZERO || (ZERO = Object.freeze(Vector3.Zero()));
+        return ZERO || (ZERO = Object.freeze(Vector3.Zero()) as Vector3);
+    }
+
+    /**
+     * The x coordinate of the vector
+     */
+    get x(): number
+    {
+        return this._x;
+    }
+
+    /**
+     * The y coordinate of the vector
+     */
+    get y(): number
+    {
+        return this._y;
+    }
+
+    /**
+     * The z coordinate of the vector
+     */
+    get z(): number
+    {
+        return this._z;
     }
 
     /**
      */
     length(): number
     {
-        const x = this.x;
-        const y = this.y;
-        const z = this.z;
+        const x = this._x;
+        const y = this._y;
+        const z = this._z;
 
         return Math.sqrt(x*x + y*y + z*z);
     }
      */
     dot(v: Vector3): number
     {
-        return this.x * v.x + this.y * v.y + this.z * v.z;
+        return this._x * v._x + this._y * v._y + this._z * v._z;
     }
 
     /**
      */
     distanceTo(v: Vector3): number
     {
-        const dx = this.x - v.x;
-        const dy = this.y - v.y;
-        const dz = this.z - v.z;
+        const dx = this._x - v._x;
+        const dy = this._y - v._y;
+        const dz = this._z - v._z;
 
         return Math.sqrt(dx*dx + dy*dy + dz*dz);
     }
      */
     cross(v: Vector3): Vector3
     {
-        const x = this.y * v.z - this.z * v.y;
-        const y = this.z * v.x - this.x * v.z;
-        const z = this.x * v.y - this.y * v.x;
+        const x = this._y * v._z - this._z * v._y;
+        const y = this._z * v._x - this._x * v._z;
+        const z = this._x * v._y - this._y * v._x;
 
         return new Vector3(x, y, z);
     }
      */
     equals(v: Vector3): boolean
     {
-        return this.x === v.x && this.y === v.y && this.z === v.z;
+        return this._x === v._x && this._y === v._y && this._z === v._z;
     }
 
     /**
      */
     toString(): string
     {
-        const x = this.x.toFixed(5);
-        const y = this.y.toFixed(5);
-        const z = this.z.toFixed(5);
+        const x = this._x.toFixed(5);
+        const y = this._y.toFixed(5);
+        const z = this._z.toFixed(5);
 
         return `Vector3(${x},${y},${z})`;
     }
      */
     _clone(): Vector3
     {
-        return new Vector3(this.x, this.y, this.z);
+        return new Vector3(this._x, this._y, this._z);
     }
 
     /**
      */
     _set(x: number, y: number, z: number): Vector3
     {
-        this.x = +x;
-        this.y = +y;
-        this.z = +z;
+        this._x = +x;
+        this._y = +y;
+        this._z = +z;
 
         return this;
     }
      */
     _copyFrom(v: Vector3): Vector3
     {
-        this.x = v.x;
-        this.y = v.y;
-        this.z = v.z;
+        this._x = v._x;
+        this._y = v._y;
+        this._z = v._z;
 
         return this;
     }
         if(length < EPSILON) // zero?
             return this;
 
-        this.x /= length;
-        this.y /= length;
-        this.z /= length;
+        this._x /= length;
+        this._y /= length;
+        this._z /= length;
 
         return this;
     }
      */
     _add(v: Vector3): Vector3
     {
-        this.x += v.x;
-        this.y += v.y;
-        this.z += v.z;
+        this._x += v._x;
+        this._y += v._y;
+        this._z += v._z;
 
         return this;
     }
      */
     _subtract(v: Vector3): Vector3
     {
-        this.x -= v.x;
-        this.y -= v.y;
-        this.z -= v.z;
+        this._x -= v._x;
+        this._y -= v._y;
+        this._z -= v._z;
 
         return this;
     }
      */
     _scale(s: number): Vector3
     {
-        this.x *= s;
-        this.y *= s;
-        this.z *= s;
+        this._x *= s;
+        this._y *= s;
+        this._z *= s;
 
         return this;
     }