Add Vector3._applyRotationQuaternion()

src/geometry/quaternion.ts

         unit quaternion q associated with M.
 
         Before we begin, note that q and (-q) encode the same rotation, for
-        r_(-q)(p) = (-q)p(-q)* = (-1)q p (-1)q* = (-1)(-1)q p q* = = r_q(p).
+        r_(-q)(p) = (-q)p(-q)* = (-1)q p (-1)q* = (-1)(-1)q p q* = q p q* = r_q(p).
         Quaternion multiplication is commutative when a factor is a scalar, i.e.,
         d p = p d for a real d and a quaternion p (check: distributive operation).
 

src/geometry/transform.ts

     get right(): Vector3
     {
         if(this._right === Vector3.ZERO) {
-            const rotationMatrix = this.orientation._toRotationMatrix(); // R
-            const u = rotationMatrix.block(0, 2, 0, 0).read(); // R * [1 0 0]'
-            this._right = new Vector3(u[0], u[1], u[2]);
+            this._right = new Vector3(1, 0, 0)
+                          ._applyRotationQuaternion(this.orientation);
         }
 
         return this._right;
     get up(): Vector3
     {
         if(this._up === Vector3.ZERO) {
-            const rotationMatrix = this.orientation._toRotationMatrix(); // R
-            const v = rotationMatrix.block(0, 2, 1, 1).read(); // R * [0 1 0]'
-            this._up = new Vector3(v[0], v[1], v[2]);
+            this._up = new Vector3(0, 1, 0)
+                       ._applyRotationQuaternion(this.orientation);
         }
 
         return this._up;
     get forward(): Vector3
     {
         if(this._forward === Vector3.ZERO) {
-            const rotationMatrix = this.orientation._toRotationMatrix(); // R
-            const w = rotationMatrix.block(0, 2, 2, 2).read(); // R * [0 0 1]'
-            this._forward = new Vector3(-w[0], -w[1], -w[2]); // (*)
-
-            /*
-
-            (*) in a right-handed system, the unit forward vector is (0,0,-1)
-                in a left-handed system, it is (0,0,1)
-
-            */
+            // in a right-handed system, the unit forward vector is (0, 0, -1)
+            // in a left-handed system, it is (0, 0, 1)
+            this._forward = new Vector3(0, 0, -1)
+                            ._applyRotationQuaternion(this.orientation);
         }
 
         return this._forward;

src/geometry/vector3.ts

  */
 
 import { Nullable } from '../utils/utils';
+import { Quaternion } from './quaternion';
 
 /** Small number */
 const EPSILON = 1e-6;
 
         return this;
     }
+
+    /**
+     * Compute the rotation q p q* in place, where q is a unit quaternion,
+     * q* is its conjugate and multiplicative inverse, and p is this vector
+     * @param q unit quaternion
+     * @returns this vector
+     * @internal
+     */
+    _applyRotationQuaternion(q: Quaternion): Vector3
+    {
+        // based on Quaternion._toRotationMatrix()
+        const x = q.x, y = q.y, z = q.z, w = q.w;
+        const vx = this._x, vy = this._y, vz = this._z;
+
+        const x2 = x*x, y2 = y*y, z2 = z*z;
+        const xy = 2*x*y, xz = 2*x*z, yz = 2*y*z;
+        const wx = 2*w*x, wy = 2*w*y, wz = 2*w*z;
+
+        this._x = (1-2*(y2+z2)) * vx + (xy-wz) * vy + (xz+wy) * vz;
+        this._y = (xy+wz) * vx + (1-2*(x2+z2)) * vy + (yz-wx) * vz;
+        this._z = (xz-wy) * vx + (yz+wx) * vy + (1-2*(x2+y2)) * vz;
+
+        return this;
+    }
 }