zincjs 1.0.13 → 1.0.15

package/src/primitives/lines.js

@@ -0,0 +1,35 @@
+const THREE = require('three');
+/**
+ * Provides an object which stores points and provides method which controls its position.
+ * This is created when a valid json file containing point is read into a {@link Zinc.Scene}
+ * object.
+ * 
+ * @class
+ * @author Alan Wu
+ * @return {Zinc.Lines}
+ */
+const Lines = function () {
+  (require('./zincObject').ZincObject).call(this);
+	this.isLines = true;
+
+	this.createLineSegment = (geometryIn, materialIn, options) => {
+		if (geometryIn && materialIn) {
+			let geometry = this.toBufferGeometry(geometryIn, options);
+			if (options.localMorphColour && geometry.morphAttributes[ "color" ])
+				materialIn.onBeforeCompile = (require("./augmentShader").augmentMorphColor)();
+      let line = new (require("../three/line/LineSegments").LineSegments)(geometry, materialIn);
+			this.setMesh(line, options.localTimeEnabled, options.localMorphColour);
+		}		
+	}
+
+	this.setWidth = width => {
+		if (this.morph && this.morph.material) {
+			this.morph.material.linewidth = width;
+			this.morph.material.needsUpdate = true;
+		}
+	}
+
+}
+
+Lines.prototype = Object.create((require('./zincObject').ZincObject).prototype);
+exports.Lines = Lines;

package/src/primitives/marker.js

@@ -0,0 +1,88 @@
+var THREE = require('three');
+const markerImage = new Image(128, 128);
+markerImage.src = require("../assets/mapMarker.svg");
+const texture = new THREE.Texture();
+texture.image = markerImage;
+texture.needsUpdate = true;
+const size = [0.015, 0.02, 1];
+
+//Marker - used to indicate there is a 
+const Marker = function(zincObject) {
+  (require('./zincObject').ZincObject).call(this);
+  this.texture = texture;
+  let spriteMaterial = undefined;
+  let sprite = undefined;
+  this.morph = new THREE.Group();
+  this.parent = zincObject;
+  this.isMarker = true;
+  let enabled = false;
+  let vector = new THREE.Vector3();
+
+	let initialise = () => {
+    spriteMaterial = new THREE.SpriteMaterial({
+      map: texture,
+      alphaTest: 0.5,
+      transparent: true,
+      depthTest: false,
+      depthWrite: false,
+      sizeAttenuation: false
+    });              
+    sprite = new THREE.Sprite(spriteMaterial);
+    sprite.center.set(0.5, 0);
+    this.morph.add(sprite);
+    this.morph.position.set(0, 0, 0);
+    this.morph.renderOrder = 10000;
+    sprite.scale.set(size[0], size[1], size[2]);
+    sprite.userData = this;
+  }
+
+  this.updateVisual = (min, max) => {
+    let scale = 1;
+    let opacity = 1;
+    let porportion = 0;
+    if (min !== max) {
+      porportion = (1 - (vector.z - min) / (max - min));
+      scale = 0.5 +  porportion * 0.5;
+      opacity = 0.6 +  porportion * 0.4;
+    }
+    sprite.material.opacity = opacity;
+    this.setSpriteSize(scale);
+  }
+
+  this.updateNDC = camera => {
+    vector.copy(this.morph.position);
+    vector.project(camera);
+    vector.z = Math.min(Math.max(vector.z, 0), 1);
+    return vector.z;
+  }
+
+  this.setPosition = (x, y, z) => {
+    this.morph.position.set(x, y, z);
+  }
+
+  this.setSpriteSize = size => {
+    sprite.scale.set(0.015, 0.02, 1);
+    sprite.scale.multiplyScalar(size);
+  }
+
+  this.isEnabled = () => {
+    return enabled;
+  }
+
+  this.enable = () => {
+    enabled = true;
+    this.morph.visible = true;
+  }
+  
+  this.disable = () => {
+    enabled = false;
+    this.morph.visible = false;
+  }
+
+	//this should be handle by scene... check the sync at 
+	initialise();
+
+}
+
+Marker.prototype = Object.create((require('./zincObject').ZincObject).prototype);
+exports.Marker = Marker;

package/src/primitives/pointset.js

@@ -0,0 +1,53 @@
+const THREE = require('three');
+const Points = require('../three/Points').Points;
+
+/**
+ * Provides an object which stores points and provides method which controls its position.
+ * This is created when a valid json file containing point is read into a {@link Zinc.Scene}
+ * object.
+ * 
+ * @class
+ * @author Alan Wu
+ * @return {Zinc.Geometry}
+ */
+const Pointset = function () {
+  (require('./zincObject').ZincObject).call(this);
+	this.isPointset = true;
+
+    /** Shape of the points is created using the function below */
+	const getCircularTexture = () => {
+		var image = new Image();
+		image.src = require("../assets/disc.png");
+		const texture = new THREE.Texture();
+		texture.image = image;
+		texture.needsUpdate = true;
+		return texture;
+	}
+
+	this.createMesh = (geometryIn, materialIn, options) => {
+		if (geometryIn && materialIn) {
+			let geometry = this.toBufferGeometry(geometryIn, options);
+			const texture = getCircularTexture();
+			materialIn.map = texture;
+			let point = new Points(geometry, materialIn);
+			this.setMesh(point, options.localTimeEnabled, options.localMorphColour);
+		}	
+	}
+
+	this.setSize = size => {
+		if (this.morph && this.morph.material) {
+			this.morph.material.size = size;
+			this.morph.material.needsUpdate = true;
+		}
+	}
+	
+	this.setSizeAttenuation = flag => {
+		if (this.morph && this.morph.material) {
+			this.morph.material.sizeAttenuation = flag;
+			this.morph.material.needsUpdate = true;
+		}
+	}
+}
+
+Pointset.prototype = Object.create((require('./zincObject').ZincObject).prototype);
+exports.Pointset = Pointset;

package/src/primitives/texturePrimitive.js

@@ -0,0 +1,16 @@
+const THREE = require('three');
+/**
+ * Provides a base class object which stores textures and rendering object.
+ * 
+ * @class
+ * @author Alan Wu
+ * @return {Zinc.Lines}
+ */
+const TexturePrimitive = function (textureIn) {
+  (require('./zincObject').ZincObject).call(this);
+  this.isTexturePrimitive = true;
+  this.texture = textureIn;
+}
+
+TexturePrimitive.prototype = Object.create((require('./zincObject').ZincObject).prototype);
+exports.TexturePrimitive = TexturePrimitive;

package/src/primitives/textureSlides.js

@@ -0,0 +1,118 @@
+const THREE = require('three');
+const shader = require("../shaders/textureSlide.js");
+/**
+ * Provides a base class object which stores textures and rendering object.
+ * 
+ * @class
+ * @author Alan Wu
+ * @return {Zinc.Lines}
+ */
+const TextureSlides = function (textureIn) {
+  (require('./texturePrimitive').TexturePrimitive).call(this, textureIn);
+  this.isTextureSlides = true;
+  
+  /*
+   * Create slides
+   */
+  this.createSlides = slideSettings => {
+    if (!this.morph) this.morph = new THREE.Group();
+    if (this.texture && this.texture.isTextureArray && this.texture.isReady()) {
+      slideSettings.forEach(slide => {
+        if (slide.direction && slide.value) {
+          const geometry = new THREE.PlaneGeometry( 1, 1 );
+          geometry.translate(0.5, 0.5, 0);
+          const uniforms = shader.getUniforms();
+          uniforms.diffuse.value = this.texture.impl;
+          uniforms.depth.value = this.texture.size.depth;
+          switch(slide.direction) {
+            case "x":
+              uniforms.slide.value.set(slide.value, 0, 0);
+              break;
+            case "y":
+              uniforms.slide.value.set(0, slide.value, 0);
+              break;
+            case "z":
+              uniforms.slide.value.set(0, 0, slide.value);
+              break;
+            default:
+              break;
+          }
+          const options = {
+            fs: shader.fs,
+            vs: shader.vs,
+            uniforms: uniforms,
+            glslVersion: shader.glslVersion,
+            side: THREE.DoubleSide,
+            transparent: false
+          };
+          const material = this.texture.getMaterial(options);
+          material.needsUpdate = true;
+          const mesh = new THREE.Mesh( geometry, material );
+          this.morph.add(mesh);
+        }
+      });
+    }
+  }
+
+  /*
+   * Get all slides, return them in an array
+   */
+  this.getSlides = () => {
+    if (this.morph) return [...this.morph.children];
+    return [];
+  }
+
+  /*
+   * Remove a slide, this will dispose the slide and its material.
+   */
+  this.removeSlide = slide => {
+    if (slide && this.morph) {
+      if (this.morph.getObjectById(slide.id)) {
+        this.morph.remove(slide);
+        slide.disppose();
+        if (slide.geometry)
+          slide.geometry.dispose();
+        if (slide.material)
+          slide.material.dispose();
+      }
+    }
+  }
+
+  this.dispose = () => {
+    this.morph.children.forEach(slide=> {
+      if (slide.geometry)
+        slide.geometry.dispose();
+      if (slide.material)
+        slide.material.dispose();
+    });
+    (require('./texturePrimitive').TexturePrimitive).prototype.dispose.call(this);
+  }
+
+  /**
+   * Get the bounding box of this geometry.
+   * 
+   * @return {THREE.Box3}.
+   */
+  this.getBoundingBox = function() {
+    if (this.morph && this.morph.children && this.morph.visible &&
+      this.boundingBoxUpdateRequired) {
+      let first = true;
+      this.morph.children.forEach( morph => {
+        if (first) {
+          this.cachedBoundingBox.setFromBufferAttribute(
+            morph.geometry.attributes.position);
+          first = false;
+        } else {
+          this.cachedBoundingBox.expandByObject(morph);
+        }
+      });
+      this.boundingBoxUpdateRequired = false;
+      return this.cachedBoundingBox;
+    }
+    return undefined;
+  }
+}
+
+
+TextureSlides.prototype = Object.create((require('./texturePrimitive').TexturePrimitive).prototype);
+exports.TextureSlides = TextureSlides;