zincjs 1.10.2 → 1.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zincjs",
-  "version": "1.10.2",
+  "version": "1.11.0",
   "description": "ZincJS (Web-based-Zinc-Visualisation)",
   "main": "build/zinc.js",
   "directories": {

package/src/loaders/primitivesLoader.js

@@ -18,7 +18,6 @@ const mergeGeometries = (geometries) => {
 }
 
 const IndexedSourcesHandler = function(urlIn, crossOrigin, onDownloadedCallback) {
-  const allData = [];
   const loader = new FileLoader();
   const jsonLoader = new JSONLoader();
   loader.crossOrigin = crossOrigin;
@@ -130,7 +129,6 @@ const MultiSourcesHandler = function(numberIn, onLoadCallback) {
       onLoad(geometry, materials);
     }
   }
-
 }
 
 exports.PrimitivesLoader = function () {
@@ -161,35 +159,47 @@ exports.PrimitivesLoader = function () {
     const newOptions = options ? {...options} : {};
     let indexedLoader = indexedLoaders[url];
     if (!indexedLoader) {
-      const onLoadCallback = new onFinally(undefined, this, newOptions);
-      ++concurrentDownloads;
-      indexedLoader = new IndexedSourcesHandler(url, this.crossOrigin, onLoadCallback);
-      indexedLoaders[url] = indexedLoader;
+      if (MAX_DOWNLOAD > concurrentDownloads) {
+        const onLoadCallback = new onFinally(undefined, this, newOptions);
+        ++concurrentDownloads;
+        indexedLoader = new IndexedSourcesHandler(url, this.crossOrigin, onLoadCallback);
+        indexedLoaders[url] = indexedLoader;
+      } else {
+        waitingList.push({
+          url,
+          onLoad,
+          onProgress,
+          onError,
+          options,
+        });
+      }
+    }
+    if (indexedLoader) {
+      newOptions.isHandler = indexedLoader;
+      indexedLoader.load(options.index, onLoad, onProgress, onError);
     }
-    newOptions.isHandler = indexedLoader;
-    indexedLoader.load(options.index, onLoad, onProgress, onError);
   }
 
   const loadFromSingleSource = (url, onLoad, onProgress, onError, options) => {
-    if (MAX_DOWNLOAD > concurrentDownloads) {
-      if (options && (options.index !== undefined) ) {
-        handleIndexedSource(url, onLoad, onProgress, onError, options);
-      } else {
-        //Standard loading
+    if (options && (options.index !== undefined) ) {
+      handleIndexedSource(url, onLoad, onProgress, onError, options);
+    } else {
+      //Standard loading
+      if (MAX_DOWNLOAD > concurrentDownloads) {
         ++concurrentDownloads;
         const onLoadCallback = new onFinally(onLoad, this, options);
         const onErrorCallback = new onFinally(onError, this, options);
         loader.crossOrigin = this.crossOrigin;
         loader.load(url, onLoadCallback, onProgress, onErrorCallback);
+      } else {
+        waitingList.push({
+          url,
+          onLoad,
+          onProgress,
+          onError,
+          options,
+        });
       }
-    } else {
-      waitingList.push({
-        url,
-        onLoad,
-        onProgress,
-        onError,
-        options,
-      });
     }
   }
 
@@ -202,10 +212,18 @@ exports.PrimitivesLoader = function () {
   }
 
   this.loadFromWaitingList = () => {
-    const item = waitingList.shift();
-    if (item) {
-      this.load(item.url, item.onLoad, item.onProgress, item.onError, item.options);
-    } else {
+    while (MAX_DOWNLOAD > concurrentDownloads) {
+      const item = waitingList.shift();
+      if (item) {
+        this.load(item.url, item.onLoad, item.onProgress, item.onError, item.options);
+      } else {
+        return;
+      }
+    }
+  }
+
+  this.itemRemainingCheck = () => {
+    if (waitingList.length === 0 && concurrentDownloads === 0) {
       for (let key in indexedLoaders) {
         if (indexedLoaders.hasOwnProperty(key)) {
           delete indexedLoaders[key];
@@ -227,6 +245,7 @@ exports.PrimitivesLoader = function () {
         }
       }
       loader.loadFromWaitingList();
+      loader.itemRemainingCheck();
     }
   }
 

package/src/primitives/marker.js

@@ -28,6 +28,11 @@ const Marker = function(zincObject) {
   (require('./zincObject').ZincObject).call(this);
   this.texture = texture;
   let sprite = undefined;
+  let userTexture = undefined;
+  let userMaterial = undefined;
+  let userSprite = undefined;
+  let userUrl = undefined;
+  let defaultDisplay = true;
   this.morph = new THREE.Group();
   this.group = this.morph;
   this.parent = zincObject;
@@ -85,6 +90,70 @@ const Marker = function(zincObject) {
     sprite.scale.multiplyScalar(size);
   }
 
+  this.setUserSprite = () => {
+    if (defaultDisplay && userSprite) {
+      this.morph.add(userSprite);
+      this.morph.remove(sprite);
+      if (label) {
+        this.morph.remove(label);
+      }
+      defaultDisplay = false;
+    }
+  }
+
+  this.setImageForUserSprite = (image, size) => {
+    if (userSprite) {
+      this.morph.remove(userSprite);
+      userSprite.dispose();
+    }
+    if (userTexture) userTexture.dispose();
+    if (userMaterial) userMaterial.dispose();
+    userTexture = new THREE.Texture();
+    userTexture.image = image;
+    userTexture.needsUpdate = true;
+    userMaterial = new THREE.SpriteMaterial({
+      map: userTexture,
+      alphaTest: 0.5,
+      transparent: true,
+      depthTest: false,
+      depthWrite: false,
+      sizeAttenuation: false
+    });
+    if (!size) {
+      size =  [0.05, 0.05, 1];
+    }
+    userSprite = new THREE.Sprite(userMaterial);
+    userSprite.center.set(0.5, 0);
+    userSprite.scale.set(size[0], size[1], size[2]);
+    userSprite.userData = this;
+    this.setUserSprite();
+  }
+
+  this.setDefaultSprite = () => {
+    if (!defaultDisplay) {
+      defaultDisplay = true;
+      this.morph.add(sprite);
+      if (userSprite) this.morph.remove(userSprite);
+      if (label) this.morph.add(label);
+    }
+  }
+
+  this.loadUserSprite = (url, size) => {
+    if (url) {
+      if (url !== userUrl) {
+        userUrl = url;
+        const userImage = new Image(128, 128);
+        userImage.crossOrigin = "anonymous"
+        userImage.onload = () => {
+          this.setImageForUserSprite(userImage, size);
+        };
+        userImage.src = url;
+      } else {
+        this.setUserSprite();
+      }
+    }
+  }
+
   /**
    * Clean up this object,
    */ 

package/src/primitives/zincObject.js

@@ -550,6 +550,11 @@ ZincObject.prototype.updateMarker = function(playAnimation, options) {
         this.group.add(this.marker.morph);
       }
       this.marker.setNumber(this.markerNumber);
+      if (this.markerImgURL) {
+        this.marker.loadUserSprite(this.markerImgURL);
+      } else {
+        this.marker.setDefaultSprite();
+      }
       if (options && options.camera && (ndcToBeUpdated ||
         options.markerCluster.markerUpdateRequired)) {
         this.marker.updateNDC(options.camera.cameraObject);
@@ -634,6 +639,7 @@ ZincObject.prototype.getClosestVertexDOMElementCoords = function(scene) {
   }
   if (options) {
     this.markerNumber = options.number;
+    this.markerImgURL = options.imgURL;
   }
 }
 

package/src/scene.js

@@ -1247,14 +1247,18 @@ exports.Scene = function (containerIn, rendererIn) {
 
   /*
 	 * Remove all temporary primitives.
+   * Return number of primitives removed;
 	 */
   this.clearTemporaryPrimitives = () => {
+    let i = 0;
     const children = tempGroup.children;
     children.forEach(child => {
       child.geometry.dispose();
       child.material.dispose();
+      i++;
     });
     tempGroup.clear();
+    return i;
   }
 
   /*