zincjs 1.8.3 → 1.8.4

package/package.json

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

package/src/primitives/textureSlides.js

@@ -19,7 +19,7 @@ const TextureSlides = function (textureIn) {
   this.morph = new THREE.Group();
   this.group = this.morph;
   this.morph.userData = this;
-   let flipY = true;
+  let flipY = true;
 
   /**
     @typedef SLIDE_SETTINGS
@@ -51,18 +51,30 @@ const TextureSlides = function (textureIn) {
   const setUniformSlideSettingsOfMesh = (mesh, settings) => {
     const material = mesh.material;
     const uniforms = material.uniforms;
+    mesh.rotation.x = 0;
+    mesh.rotation.y = 0;
+    mesh.rotation.z = 0;
+    mesh.position.x = 0;
+    mesh.position.y = 0;
+    mesh.position.z = 0;
     switch (settings.direction) {
       case "x":
+        const rotation = flipY ? -Math.PI / 2 : Math.PI / 2;
+        mesh.rotation.y = rotation;
         uniforms.direction.value = 1;
         uniforms.slide.value.set(settings.value, 0, 0);
+        mesh.position.x = settings.value;
         break;
       case "y":
+        mesh.rotation.x = Math.PI / 2;
         uniforms.direction.value = 2;
         uniforms.slide.value.set(0, settings.value, 0);
+        mesh.position.y = settings.value;
         break;
       case "z":
         uniforms.direction.value = 3;
         uniforms.slide.value.set(0, 0, settings.value);
+        mesh.position.z = settings.value;
         break;
       default:
         break;
@@ -113,6 +125,8 @@ const TextureSlides = function (textureIn) {
         const material = this.texture.getMaterial(options);
         material.needsUpdate = true;
         const mesh = new THREE.Mesh(geometry, material);
+        mesh.name = this.groupName;
+        mesh.userData = this;
         const slideSettings = {
           value: settings.value,
           direction: settings.direction,
@@ -131,12 +145,25 @@ const TextureSlides = function (textureIn) {
   /**
    * Return a copy of texture settings used by this object.
    *
-   * @return {SLIDE_SETTINGS} - Returned the list of settings..
+   * @return {SLIDE_SETTINGS} - Returned the list of settings.
    */
   this.getTextureSettings = () => {
     return [...textureSettings];
   }
 
+  /**
+   * Return a copy of texture settings with corresponding id used by this object.
+   *
+   * @return {SLIDE_SETTINGS} - Returned a copy of settings with corresponding id.
+   */
+  this.getTextureSettingsWithId = (id) => {
+    for (let i = 0; i < textureSettings.length; i++) {
+      if (id === textureSettings[i].id) {
+        return {...textureSettings[i]};
+      }
+    }
+  }
+
   /**
    * Get  the array of slides, return them in an array
    *

package/src/scene.js

@@ -1270,13 +1270,67 @@ exports.Scene = function (containerIn, rendererIn) {
     const box = boundingBox ? boundingBox : this.getBoundingBox();
     const dim = new THREE.Vector3().subVectors(box.max, box.min);
     const boxGeo = new THREE.BoxGeometry(dim.x, dim.y, dim.z);
-    dim.addVectors(box.min, box.max).multiplyScalar( 0.5 );
     const primitive = region.createGeometryFromThreeJSGeometry(
       group, boxGeo, colour, opacity, visibility, 10000);
+    dim.addVectors(box.min, box.max).multiplyScalar( 0.5 );
     primitive.setPosition(dim.x, dim.y, dim.z);
     return primitive;
   }
 
+  /*
+	 * Create primitive based on the bounding box of scene and
+   * add to specify region and group name.
+	 */
+  this.addSlicesPrimitive = (regionPath, groups, colours, opacity,
+    visibility, boundingBox = undefined) => {
+    if (groups && groups.length >= 3 &&
+      colours && colours.length >= 3) {
+      let region = rootRegion.findChildFromPath(regionPath);
+      if (region === undefined) {
+        region = rootRegion.createChildFromPath(regionPath);
+      }
+      const box = boundingBox ? boundingBox : this.getBoundingBox();
+      const dim = new THREE.Vector3().subVectors(box.max, box.min);
+      const directions = ["x", "y", "z"];
+      const primitives = [];
+      let index = 0;
+      directions.forEach((direction) => {
+        let planeGeo = undefined;
+        switch(direction) {
+          //YZ plane
+          case "x":
+            planeGeo = new THREE.PlaneGeometry(dim.z, dim.y);
+            planeGeo.rotateY(Math.PI / 2);
+            // code block
+            break;
+          //XZ plane
+          case "y":
+            planeGeo = new THREE.PlaneGeometry(dim.x, dim.z);
+            planeGeo.rotateX(Math.PI / 2);
+            // code block
+            break;
+          //XY plane
+          case "z":
+            planeGeo = new THREE.PlaneGeometry(dim.x, dim.y);
+              // code block
+            break;
+          default:
+            break;
+        }
+        const primitive = region.createGeometryFromThreeJSGeometry(
+          groups[index], planeGeo, colours[index], opacity, visibility, 10001);
+        primitives.push(primitive);
+        index++;
+      });
+
+      dim.addVectors(box.min, box.max).multiplyScalar( 0.5 );
+      primitives.forEach((primitive) => {
+        primitive.setPosition(dim.x, dim.y, dim.z);
+      });
+      return primitives;
+    }
+  }
+
   /*
 	 * Enable marker cluster to work with markers
 	 */

package/src/shaders/textureSlide.js

@@ -34,18 +34,17 @@ uniform bool flipY;
 void main() {
 
   vec3 slidePos = position.xyz;
+  gl_Position = projectionMatrix * modelViewMatrix * vec4( position.xyz, 1.0 );
 
   if (direction == 1)
-    slidePos = vec3(slide.x, position.x, position.y);
+    slidePos = vec3(slide.x, position.y, position.x);
   if (direction == 2)
     slidePos = vec3(position.x, slide.y, position.y);
   if (direction == 3)
     slidePos = vec3(position.x, position.y, slide.z);
 
-  gl_Position = projectionMatrix * modelViewMatrix * vec4( slidePos, 1.0 );
-
-  if (flipY)
-  slidePos.y = 1.0 - slidePos.y;
+  if (flipY) 
+    slidePos.y = 1.0 - slidePos.y;
 
   vUw.xyz = vec3(slidePos.x, slidePos.y, slidePos.z * depth);