Move conversion routines to a separate utilities object

plugins/aframe-with-encantar.js

     /**
      * Pointer-based input (current frame)
      * Make sure to add a PointerTracker to your session in order to use these
-     * @returns {TrackablePointer[]}
+     * @type {TrackablePointer[]}
      */
     pointers: [],
 
     /**
-     * Convert an AR Vector2 to a THREE Vector2
-     * @param {Vector2} v
-     * @returns {THREE.Vector2}
+     * AR Utilities
+     * @type {object}
      */
-    convertVector2(v)
-    {
-        return new THREE.Vector2(v.x, v.y);
-    },
+    utils: {
+
+        /**
+         * Convert an AR Vector2 to a THREE Vector2
+         * @param {Vector2} v
+         * @returns {THREE.Vector2}
+         */
+        convertVector2(v)
+        {
+            return new THREE.Vector2(v.x, v.y);
+        },
+
+        /**
+         * Convert an AR Vector3 to a THREE Vector3
+         * @param {Vector3} v
+         * @returns {THREE.Vector3}
+         */
+        convertVector3(v)
+        {
+            return new THREE.Vector3(v.x, v.y, v.z);
+        },
+
+        /**
+         * Convert an AR Quaternion to a THREE Quaternion
+         * @param {Quaternion} q
+         * @returns {THREE.Quaternion}
+         */
+        convertQuaternion(q)
+        {
+            return new THREE.Quaternion(q.x, q.y, q.z, q.w);
+        },
+
+        /**
+         * Convert an AR Ray to a THREE Ray
+         * @param {Ray} r
+         * @returns {THREE.Ray}
+         */
+        convertRay(r)
+        {
+            const origin = this.convertVector3(r.origin);
+            const direction = this.convertVector3(r.direction);
+            return new THREE.Ray(origin, direction);
+        },
 
-    /**
-     * Convert an AR Vector3 to a THREE Vector3
-     * @param {Vector3} v
-     * @returns {THREE.Vector3}
-     */
-    convertVector3(v)
-    {
-        return new THREE.Vector3(v.x, v.y, v.z);
-    },
-
-    /**
-     * Convert an AR Quaternion to a THREE Quaternion
-     * @param {Quaternion} q
-     * @returns {THREE.Quaternion}
-     */
-    convertQuaternion(q)
-    {
-        return new THREE.Quaternion(q.x, q.y, q.z, q.w);
-    },
-
-    /**
-     * Convert an AR Ray to a THREE Ray
-     * @param {Ray} r
-     * @returns {THREE.Ray}
-     */
-    convertRay(r)
-    {
-        const origin = this.convertVector3(r.origin);
-        const direction = this.convertVector3(r.direction);
-        return new THREE.Ray(origin, direction);
-    },
+    }
 
 });
 
 /**
- * AR Utilities
+ * Internal Utilities
  */
-const ARUtils = () => ({
+const Utils = () => ({
 
     findTrackedImage(frame, name = '')
     {
     // data;
     // schema;
 
-    _utils: ARUtils(),
+    _utils: Utils(),
     _started: false,
     _components: [],
     _roots: [],

plugins/babylon-with-encantar.js

 }
 
 /**
+ * AR Utilities
+ */
+class ARUtils
+{
+    /**
+     * Convert an AR Vector2 to a BABYLON Vector2
+     * @param {Vector2} v
+     * @returns {BABYLON.Vector2}
+     */
+    convertVector2(v)
+    {
+        return new BABYLON.Vector2(v.x, v.y);
+    }
+
+    /**
+     * Convert an AR Vector3 to a BABYLON Vector3
+     * @param {Vector3} v
+     * @returns {BABYLON.Vector3}
+     */
+    convertVector3(v)
+    {
+        return new BABYLON.Vector3(v.x, v.y, v.z);
+    }
+
+    /**
+     * Convert an AR Quaternion to a BABYLON Quaternion
+     * @param {Quaternion} q
+     * @returns {BABYLON.Quaternion}
+     */
+    convertQuaternion(q)
+    {
+        return new BABYLON.Quaternion(q.x, q.y, q.z, q.w);
+    }
+
+    /**
+     * Convert an AR Ray to a BABYLON Ray
+     * @param {Ray} r
+     * @returns {BABYLON.Ray}
+     */
+    convertRay(r)
+    {
+        const origin = this.convertVector3(r.origin);
+        const direction = this.convertVector3(r.direction);
+        return new BABYLON.Ray(origin, direction);
+    }
+}
+
+/**
  * Helper for creating Augmented Reality experiences
  */
 class ARSystem
     }
 
     /**
-     * Convert an AR Vector2 to a BABYLON Vector2
-     * @param {Vector2} v
-     * @returns {BABYLON.Vector2}
+     * AR Utilities
+     * @returns {ARUtils}
      */
-    convertVector2(v)
+    get utils()
     {
-        return new BABYLON.Vector2(v.x, v.y);
-    }
-
-    /**
-     * Convert an AR Vector3 to a BABYLON Vector3
-     * @param {Vector3} v
-     * @returns {BABYLON.Vector3}
-     */
-    convertVector3(v)
-    {
-        return new BABYLON.Vector3(v.x, v.y, v.z);
-    }
-
-    /**
-     * Convert an AR Quaternion to a BABYLON Quaternion
-     * @param {Quaternion} q
-     * @returns {BABYLON.Quaternion}
-     */
-    convertQuaternion(q)
-    {
-        return new BABYLON.Quaternion(q.x, q.y, q.z, q.w);
-    }
-
-    /**
-     * Convert an AR Ray to a BABYLON Ray
-     * @param {Ray} r
-     * @returns {BABYLON.Ray}
-     */
-    convertRay(r)
-    {
-        const origin = this.convertVector3(r.origin);
-        const direction = this.convertVector3(r.direction);
-        return new BABYLON.Ray(origin, direction);
+        return this._utils;
     }
 
     /**
         this._scene = null;
         this._camera = null;
         this._engine = null;
+        this._utils = new ARUtils();
     }
 }
 

plugins/three-with-encantar.js

 }
 
 /**
+ * AR Utilities
+ */
+class ARUtils
+{
+    /**
+     * Convert an AR Vector2 to a THREE Vector2
+     * @param {Vector2} v
+     * @returns {THREE.Vector2}
+     */
+    convertVector2(v)
+    {
+        return new THREE.Vector2(v.x, v.y);
+    }
+
+    /**
+     * Convert an AR Vector3 to a THREE Vector3
+     * @param {Vector3} v
+     * @returns {THREE.Vector3}
+     */
+    convertVector3(v)
+    {
+        return new THREE.Vector3(v.x, v.y, v.z);
+    }
+
+    /**
+     * Convert an AR Quaternion to a THREE Quaternion
+     * @param {Quaternion} q
+     * @returns {THREE.Quaternion}
+     */
+    convertQuaternion(q)
+    {
+        return new THREE.Quaternion(q.x, q.y, q.z, q.w);
+    }
+
+    /**
+     * Convert an AR Ray to a THREE Ray
+     * @param {Ray} r
+     * @returns {THREE.Ray}
+     */
+    convertRay(r)
+    {
+        const origin = this.convertVector3(r.origin);
+        const direction = this.convertVector3(r.direction);
+        return new THREE.Ray(origin, direction);
+    }
+}
+
+/**
  * Helper for creating Augmented Reality experiences
  */
 class ARSystem
     }
 
     /**
-     * Convert an AR Vector2 to a THREE Vector2
-     * @param {Vector2} v
-     * @returns {THREE.Vector2}
+     * AR Utilities
+     * @returns {ARUtils}
      */
-    convertVector2(v)
+    get utils()
     {
-        return new THREE.Vector2(v.x, v.y);
-    }
-
-    /**
-     * Convert an AR Vector3 to a THREE Vector3
-     * @param {Vector3} v
-     * @returns {THREE.Vector3}
-     */
-    convertVector3(v)
-    {
-        return new THREE.Vector3(v.x, v.y, v.z);
-    }
-
-    /**
-     * Convert an AR Quaternion to a THREE Quaternion
-     * @param {Quaternion} q
-     * @returns {THREE.Quaternion}
-     */
-    convertQuaternion(q)
-    {
-        return new THREE.Quaternion(q.x, q.y, q.z, q.w);
-    }
-
-    /**
-     * Convert an AR Ray to a THREE Ray
-     * @param {Ray} r
-     * @returns {THREE.Ray}
-     */
-    convertRay(r)
-    {
-        const origin = this.convertVector3(r.origin);
-        const direction = this.convertVector3(r.direction);
-        return new THREE.Ray(origin, direction);
+        return this._utils;
     }
 
     /**
         this._scene = null;
         this._camera = null;
         this._renderer = null;
+        this._utils = new ARUtils();
     }
 }