Update three.js plugin and demo

demos/hello-three/demo.js

 (function() {
 
 /**
- * Utilities for the Demo scene
+ * Utilities for the Demo
  */
-class DemoUtils
+class Utils
 {
-    async loadGLTF(filepath, yAxisIsUp = true)
+    static async loadGLTF(filepath, yAxisIsUp = true)
     {
         const loader = new THREE.GLTFLoader();
         const gltf = await loader.loadAsync(filepath);
         return gltf;
     }
 
-    createAnimationAction(gltf, name = null, loop = THREE.LoopRepeat)
+    static createAnimationAction(gltf, name = null, loop = THREE.LoopRepeat)
     {
         const mixer = new THREE.AnimationMixer(gltf.scene);
         const clips = gltf.animations;
         return action;
     }
 
-    createImagePlane(imagepath)
+    static createImagePlane(imagepath)
     {
         const texture = new THREE.TextureLoader().load(imagepath);
         const geometry = new THREE.PlaneGeometry(1, 1);
         return mesh;
     }
 
-    switchToFrontView(ar)
+    static switchToFrontView(ar)
     {
         // top view is the default
         ar.root.rotation.set(-Math.PI / 2, 0, 0);
     }
 
-    referenceImageName(ar)
+    static referenceImageName(ar)
     {
         if(ar.frame === null)
             return null;
 }
 
 /**
- * Demo scene
+ * Augmented Reality Demo
  */
-class DemoScene extends ARScene
+class EnchantedDemo extends ARDemo
 {
     /**
      * Constructor
     {
         super();
 
-        this._utils = new DemoUtils();
         this._objects = { };
     }
 
     }
 
     /**
-     * Initialize the augmented scene
+     * Initialization
      * @param {ARSystem} ar
      * @returns {Promise<void>}
      */
         // Change the point of view. All virtual objects are descendants of
         // ar.root, a node that is automatically aligned to the physical scene.
         // Adjusting ar.root will adjust all virtual objects.
-        this._utils.switchToFrontView(ar);
+        Utils.switchToFrontView(ar);
         ar.root.position.set(0, -0.5, 0);
 
         // initialize objects
     }
 
     /**
-     * Update / animate the augmented scene
+     * Animation loop
      * @param {ARSystem} ar
      * @returns {void}
      */
 
     _initMagicCircle(ar)
     {
-        // load the object
-        const magicCircle = this._utils.createImagePlane('../assets/magic-circle.png');
+        // create a magic circle
+        const magicCircle = Utils.createImagePlane('../assets/magic-circle.png');
         magicCircle.material.transparent = true;
         magicCircle.material.opacity = 1;
         magicCircle.scale.set(4, 4, 1);
 
-        // add the object to the scene
+        // make it a child of ar.root
         ar.root.add(magicCircle);
 
         // save a reference
 
     _initText(ar)
     {
-        const text = this._utils.createImagePlane('../assets/it-works.png');
+        const text = Utils.createImagePlane('../assets/it-works.png');
         text.material.transparent = true;
         text.material.opacity = 1;
         text.position.set(0, -0.5, 2);
     async _initMage(ar)
     {
         // load the mage
-        const gltf = await this._utils.loadGLTF('../assets/mage.glb');
+        const gltf = await Utils.loadGLTF('../assets/mage.glb');
         const mage = gltf.scene;
         mage.scale.set(0.7, 0.7, 0.7);
 
         // prepare the animation of the mage
-        const mageAction = this._utils.createAnimationAction(gltf, 'Idle');
+        const mageAction = Utils.createAnimationAction(gltf, 'Idle');
         mageAction.play();
 
-        // add the mage to the scene
+        // make the mage a child of ar.root
         ar.root.add(mage);
 
         // save references
 
     async _initCat(ar)
     {
-        const gltf = await this._utils.loadGLTF('../assets/cat.glb');
+        const gltf = await Utils.loadGLTF('../assets/cat.glb');
         const cat = gltf.scene;
         cat.scale.set(0.7, 0.7, 0.7);
 
-        const catAction = this._utils.createAnimationAction(gltf, 'Cheer');
+        const catAction = Utils.createAnimationAction(gltf, 'Cheer');
         catAction.play();
 
         ar.root.add(cat);
 
     _onTargetFound(referenceImage)
     {
-        // change the scene based on the scanned image
+        // change the scene based on the tracked image
         switch(referenceImage.name) {
             case 'mage':
                 this._objects.mage.visible = true;
 }
 
 /**
- * Enchant the scene
+ * Start the Demo
  * @returns {void}
  */
 function main()
 {
-    const scene = new DemoScene();
+    const demo = new EnchantedDemo();
 
     if(typeof encantar === 'undefined')
         throw new Error(`Can't find the three.js plugin for encantar.js`);
 
-    encantar(scene).catch(error => {
+    encantar(demo).catch(error => {
         alert(error.message);
     });
 }

plugins/three-with-encantar.js

 });
 
 /**
- * Base class for augmented scenes
+ * Base class for Augmented Reality experiences
  */
-class ARScene
+class ARDemo
 {
     /**
      * Start the AR session
     }
 
     /**
-     * Initialize the augmented scene
+     * Initialization
      * @abstract
      * @param {ARSystem} ar
      * @returns {void | Promise<void> | SpeedyPromise<void>}
     }
 
     /**
-     * Update / animate the augmented scene
+     * Animation loop
      * @abstract
      * @param {ARSystem} ar
      * @returns {void}
     }
 
     /**
-     * Release the augmented scene
+     * Release resources
      * @param {ARSystem} ar
      * @returns {void}
      */
 }
 
 /**
- * Helper for augmenting the scenes with three.js
+ * Helper for creating Augmented Reality experiences
  */
 class ARSystem
 {
 
 /**
  * Enchant three.js with encantar.js!
- * @param {ARScene} scene
+ * @param {ARDemo} demo
  * @returns {Promise<ARSystem>}
  */
-function encantar(scene)
+function encantar(demo)
 {
     const ar = new ARSystem();
 
         ar._frame = frame;
         mix(frame);
 
-        scene.update(ar);
+        demo.update(ar);
 
         ar._renderer.render(ar._scene, ar._camera);
         ar._session.requestAnimationFrame(animate);
 
     function mix(frame)
     {
-        ar._origin.visible = false;
-
         for(const result of frame.results) {
             if(result.tracker.type == 'image-tracker') {
                 if(result.trackables.length > 0) {
                 }
             }
         }
+
+        ar._origin.visible = false;
     }
 
     function align(projectionMatrix, viewMatrixInverse, modelMatrix)
 
     return Promise.resolve()
     .then(() => {
-        return scene.startSession(); // Promise or SpeedyPromise
+        return demo.startSession(); // Promise or SpeedyPromise
     })
     .then(session => {
 
 
         ar._origin = new THREE.Group();
         ar._origin.matrixAutoUpdate = false;
+        ar._origin.visible = false;
         ar._scene.add(ar._origin);
 
         ar._root = new THREE.Group();
 
         return Promise.resolve()
         .then(() => {
-            return scene.init(ar);
+            return demo.init(ar);
         })
         .then(() => {
-            session.addEventListener('end', event => { scene.release(ar); });
+            session.addEventListener('end', event => { demo.release(ar); });
             session.requestAnimationFrame(animate);
             return ar;
         })