zincjs 1.0.13 → 1.0.15

package/src/utilities.js

@@ -0,0 +1,321 @@
+const THREE = require('three');
+
+function resolveURL(url) {
+	let actualURL = url;
+	const prefix = (require("./zinc").modelPrefix);
+	
+	if (prefix) {
+		if (prefix[prefix.length -1] != '/')
+			prefix = prefix + '/';
+		const r = new RegExp('^(?:[a-z]+:)?//', 'i');
+		if (!r.test(url)) {
+			actualURL =  prefix + url;
+		}
+	}
+	
+	return actualURL;
+}
+
+//Convenient function
+function loadExternalFile(url, data, callback, errorCallback) {
+    // Set up an asynchronous request
+    const request = new XMLHttpRequest();
+    request.open('GET', resolveURL(url), true);
+
+    // Hook the event that gets called as the request progresses
+    request.onreadystatechange = () => {
+        // If the request is "DONE" (completed or failed)
+        if (request.readyState == 4) {
+            // If we got HTTP status 200 (OK)
+            if (request.status == 200) {
+                callback(request.responseText, data)
+            } else { // Failed
+                errorCallback(url);
+            }
+        }
+    };
+
+    request.send(null);    
+}
+
+function loadExternalFiles(urls, callback, errorCallback) {
+    const numUrls = urls.length;
+    let numComplete = 0;
+    const result = [];
+
+    // Callback for a single file
+    function partialCallback(text, urlIndex) {
+        result[urlIndex] = text;
+        numComplete++;
+
+        // When all files have downloaded
+        if (numComplete == numUrls) {
+            callback(result);
+        }
+    }
+
+    for (let i = 0; i < numUrls; i++) {
+    	loadExternalFile(urls[i], i, partialCallback, errorCallback);
+    }
+}
+
+
+//Get the colours at index
+exports.getColorsRGB = (colors, index) => {
+    const index_in_colors = Math.floor(index/3);
+    const remainder = index%3;
+    let hex_value = 0;
+    if (remainder == 0)
+    {
+        hex_value = colors[index_in_colors].r;
+    }
+    else if (remainder == 1)
+    {
+        hex_value = colors[index_in_colors].g;
+    }
+    else if (remainder == 2)
+    {
+        hex_value = colors[index_in_colors].b;
+    }
+    const mycolor = new THREE.Color(hex_value);
+    return [mycolor.r, mycolor.g, mycolor.b];
+}
+
+
+exports.copyMorphColorsToBufferGeometry = (geometry, bufferGeometry) => {
+    if (geometry && geometry.morphColors && geometry.morphColors.length > 0 ) {
+      let array = [];
+      let morphColors = geometry.morphColors;
+      const getColorsRGB = require("./utilities").getColorsRGB;
+      for ( var i = 0, l = morphColors.length; i < l; i ++ ) {
+        let morphColor = morphColors[ i ];
+        let colorArray = [];
+		    for ( var j = 0; j < geometry.faces.length; j ++ ) {
+          let face = geometry.faces[j];
+          let color = getColorsRGB(morphColor.colors, face.a);
+          colorArray.push(color[0], color[1], color[2]);
+          color = getColorsRGB(morphColor.colors, face.b);
+          colorArray.push(color[0], color[1], color[2]);
+          color = getColorsRGB(morphColor.colors, face.c);
+          colorArray.push(color[0], color[1], color[2]);
+        }
+        var attribute = new THREE.Float32BufferAttribute( geometry.faces.length * 3 * 3, 3 );
+        attribute.name = morphColor.name;
+        array.push( attribute.copyArray( colorArray ) );
+      }
+      bufferGeometry.morphAttributes[ "color" ] = array; 
+    }
+  }
+
+
+  exports.copyMorphColorsToIndexedBufferGeometry = (geometry, bufferGeometry) => {
+    if (geometry && geometry.morphColors && geometry.morphColors.length > 0 ) {
+      let array = [];
+      let morphColors = geometry.morphColors;
+      const getColorsRGB = require("./utilities").getColorsRGB;
+      for ( let i = 0, l = morphColors.length; i < l; i ++ ) {
+        const morphColor = morphColors[ i ];
+        const colorArray = [];
+		    for ( let j = 0; j < morphColor.colors.length * 3; j ++ ) {
+          let color = getColorsRGB(morphColor.colors, j);
+          colorArray.push(color[0], color[1], color[2]);
+        }
+        const attribute = new THREE.Float32BufferAttribute( colorArray, 3 );
+        attribute.name = morphColor.name;
+        array.push( attribute );
+      }
+      bufferGeometry.morphAttributes[ "color" ] = array; 
+    }
+  }
+
+  exports.mergeVertices = ( geometry, tolerance = 1e-4 ) => {
+
+    tolerance = Math.max( tolerance, Number.EPSILON );
+
+    // Generate an index buffer if the geometry doesn't have one, or optimize it
+    // if it's already available.
+    var hashToIndex = {};
+    var indices = geometry.getIndex();
+    var positions = geometry.getAttribute( 'position' );
+    var vertexCount = indices ? indices.count : positions.count;
+
+    // next value for triangle indices
+    var nextIndex = 0;
+
+    // attributes and new attribute arrays
+    var attributeNames = Object.keys( geometry.attributes );
+    var attrArrays = {};
+    var morphAttrsArrays = {};
+    var newIndices = [];
+    var getters = [ 'getX', 'getY', 'getZ', 'getW' ];
+
+    // initialize the arrays
+    for ( var i = 0, l = attributeNames.length; i < l; i ++ ) {
+        var name = attributeNames[ i ];
+
+        attrArrays[ name ] = [];
+
+        var morphAttr = geometry.morphAttributes[ name ];
+        if ( morphAttr ) {
+
+            morphAttrsArrays[ name ] = new Array( morphAttr.length ).fill().map( () => [] );
+
+        }
+
+    }
+
+    // convert the error tolerance to an amount of decimal places to truncate to
+    var decimalShift = Math.log10( 1 / tolerance );
+    var shiftMultiplier = Math.pow( 10, decimalShift );
+    for ( var i = 0; i < vertexCount; i ++ ) {
+
+        var index = indices ? indices.getX( i ) : i;
+
+        // Generate a hash for the vertex attributes at the current index 'i'
+        var hash = '';
+        for ( var j = 0, l = attributeNames.length; j < l; j ++ ) {
+
+            var name = attributeNames[ j ];
+            var attribute = geometry.getAttribute( name );
+            var itemSize = attribute.itemSize;
+
+            for ( var k = 0; k < itemSize; k ++ ) {
+
+                // double tilde truncates the decimal value
+                hash += `${ ~ ~ ( attribute[ getters[ k ] ]( index ) * shiftMultiplier ) },`;
+
+            }
+
+        }
+
+        // Add another reference to the vertex if it's already
+        // used by another index
+        if ( hash in hashToIndex ) {
+
+            newIndices.push( hashToIndex[ hash ] );
+
+        } else {
+
+            // copy data to the new index in the attribute arrays
+            for ( var j = 0, l = attributeNames.length; j < l; j ++ ) {
+
+                var name = attributeNames[ j ];
+                var attribute = geometry.getAttribute( name );
+                var morphAttr = geometry.morphAttributes[ name ];
+                var itemSize = attribute.itemSize;
+                var newarray = attrArrays[ name ];
+                var newMorphArrays = morphAttrsArrays[ name ];
+
+                for ( var k = 0; k < itemSize; k ++ ) {
+
+                    var getterFunc = getters[ k ];
+                    newarray.push( attribute[ getterFunc ]( index ) );
+
+                    if ( morphAttr ) {
+
+                        for ( var m = 0, ml = morphAttr.length; m < ml; m ++ ) {
+
+                            newMorphArrays[ m ].push( morphAttr[ m ][ getterFunc ]( index ) );
+
+                        }
+
+                    }
+
+                }
+
+            }
+
+            hashToIndex[ hash ] = nextIndex;
+            newIndices.push( nextIndex );
+            nextIndex ++;
+
+        }
+
+    }
+
+    // Generate typed arrays from new attribute arrays and update
+    // the attributeBuffers
+    const result = geometry.clone();
+    for ( var i = 0, l = attributeNames.length; i < l; i ++ ) {
+
+        var name = attributeNames[ i ];
+        var oldAttribute = geometry.getAttribute( name );
+        var attribute;
+
+        var buffer = new oldAttribute.array.constructor( attrArrays[ name ] );
+        if ( oldAttribute.isInterleavedBufferAttribute ) {
+
+            attribute = new THREE.BufferAttribute( buffer, oldAttribute.itemSize, oldAttribute.itemSize );
+
+        } else {
+
+            attribute = geometry.getAttribute( name ).clone();
+            attribute.setArray( buffer );
+
+        }
+
+        result.setAttribute( name, attribute );
+
+        // Update the attribute arrays
+        if ( name in morphAttrsArrays ) {
+
+            for ( var j = 0; j < morphAttrsArrays[ name ].length; j ++ ) {
+
+                var morphAttribute = geometry.morphAttributes[ name ][ j ].clone();
+                morphAttribute.setArray( new morphAttribute.array.constructor( morphAttrsArrays[ name ][ j ] ) );
+                result.morphAttributes[ name ][ j ] = morphAttribute;
+
+            }
+
+        }
+
+    }
+
+    // Generate an index buffer typed array
+    var cons = Uint8Array;
+    if ( newIndices.length >= Math.pow( 2, 8 ) ) cons = Uint16Array;
+    if ( newIndices.length >= Math.pow( 2, 16 ) ) cons = Uint32Array;
+
+    var newIndexBuffer = new cons( newIndices );
+    var newIndices = null;
+    if ( indices === null ) {
+
+        newIndices = new THREE.BufferAttribute( newIndexBuffer, 1 );
+
+    } else {
+
+        newIndices = geometry.getIndex().clone();
+        newIndices.setArray( newIndexBuffer );
+
+    }
+
+    result.setIndex( newIndices );
+
+    return result;
+
+}
+
+function PhongToToon(materialIn) {
+	if (materialIn.isMeshPhongMaterial) {
+		let material = new THREE.MeshToonMaterial({
+			color : materialIn.color.clone(),
+			morphTargets : materialIn.morphTargets,
+			morphNormals : materialIn.morphNormals,
+			vertexColors : materialIn.vertexColors,
+			transparent : materialIn.transparent,
+			opacity : materialIn.opacity,
+			side : materialIn.side
+		});
+		if (materialIn.map)
+			material.map = materialIn.map;
+		return material;
+	}
+
+	return materialIn;
+}
+
+
+exports.resolveURL = resolveURL;
+exports.loadExternalFile = loadExternalFile;
+exports.loadExternalFiles = loadExternalFiles;
+exports.PhongToToon = PhongToToon;

package/src/videoHandler.js

@@ -0,0 +1,92 @@
+var THREE = require('three');
+
+
+// Alan notes: pause video when stuck
+//VideoTexture is used for creating and updating a video projected onto a Three.js texture
+exports.VideoHandler = function(srcIn)  {
+
+	var _this = this;
+	this.video = undefined;
+	this.videoTexture = undefined;
+	var src = srcIn;
+	var lastTime = 0;
+	var lastUpdate = 0;
+	var frameRate = 30;
+	var videoPlaneLoadedFlag = false;
+	var lastPlayPos    = 0;
+	var currentPlayPos = 0;
+	var bufferingDetected = false;
+	
+	var checkBuffering = function(delta, playAnimation) {
+	    currentPlayPos = _this.video.currentTime;
+
+	    // checking offset should be at most the check interval
+	    // but allow for some margin
+	    var offset = delta - 0.02;
+
+	    // if no buffering is currently detected,
+	    // and the position does not seem to increase
+	    // and the _this.video isn't manually paused...
+	    if (!bufferingDetected && (currentPlayPos < (lastPlayPos + offset)) &&
+	    		!_this.video.paused) {
+	        bufferingDetected = true;
+	    }
+
+	    // if we were buffering but the _this.video has advanced,
+	    // then there is no buffering
+	    if (bufferingDetected && (currentPlayPos > (lastPlayPos + offset)) &&
+	    		!_this.video.paused) {
+	        bufferingDetected = false;
+	    }
+	    lastPlayPos = currentPlayPos;
+	}
+
+	var initialise = function(){
+		if (document) {
+		  	_this.video = document.createElement( 'video' );
+		  	_this.video.crossOrigin = "anonymous";
+		  	_this.video.src = src;
+		  	_this.video.load();
+        _this.video.loop = true;
+        
+		}
+	}
+
+	this.setMorphTime = function(time, duration){
+		var actualTime = time / duration * _this.video.duration;
+		_this.video.currentTime = actualTime;
+	}
+
+	// videoPlaneLoaded connects the video to the video texture once it has loaded
+	 this.getVideoDuration = function() {
+		 return _this.video.duration;
+	}
+
+	this.createCanvasVideoTexture = function(){
+		_this.videoTexture = new THREE.VideoTexture( _this.video );
+		_this.videoTexture.minFilter = THREE.LinearFilter;
+		_this.videoTexture.magFilter = THREE.LinearFilter;
+		_this.videoTexture.format = THREE.RGBFormat;
+    _this.video.currentTime = 0;
+		return _this.videoTexture;
+	}
+	
+	this.getCurrentTime = function(duration) {
+		if (_this.video)
+			return duration * (_this.video.currentTime / _this.video.duration);
+		else
+			return 0;
+	}
+
+	this.isReadyToPlay = function(){
+		// video.readyState 3 means we have data to load for the current time and foreseeable future
+		if (_this.video && _this.video.readyState >= 3){
+			return true;
+		}
+		return false;
+	}
+	
+	//this should be handle by scene... check the sync at 
+	initialise();
+
+}

package/src/workers/geometryCSG.worker.js

@@ -0,0 +1,73 @@
+const Geometry = require('../primitives/geometry').Geometry;
+const THREE = require('three');
+const JSONLoader = THREE.BufferGeometryLoader;
+
+module.exports = function (self) {
+	let core = undefined;
+	
+	var geometryFromJSON = function(object) {
+		var JSONParser = new JSONLoader();
+		var geometry = JSONParser.parse(object);
+		var material = new THREE.MeshPhongMaterial();
+        var mesh = new THREE.Mesh(geometry.geometry, material);
+        var host = new Geometry();
+        host.morph = mesh;
+        return host;
+	}
+
+	var initialise = function(object) {
+		var host = geometryFromJSON(object);
+		core = new (require('./geometryCSGInternal').GeometryCSGInternal)(host);
+		self.postMessage({action:"message", message: "Initialised"});
+	}
+	
+	var intersect = function(object) {
+		if (core) {
+			var guest = geometryFromJSON(object);
+			var result = core.intersect(guest);
+			var json = result.toBufferGeometry().toJSON();
+			self.postMessage({action: "result", object: json});
+		}
+	}
+	
+	var subtract = function(object) {
+		if (core) {
+			var guest = geometryFromJSON(object);
+			var result = core.subtract(guest);
+			var json = result.toBufferGeometry().toJSON();
+			self.postMessage({action: "result", object: json});
+		}
+	}
+	
+	var union = function(object) {
+		if (core) {
+			var guest = geometryFromJSON(object);
+			var result = core.union(guest);
+			var json = result.toBufferGeometry().toJSON();
+			self.postMessage({action: "result", object: json});
+		}
+	}
+	
+	self.addEventListener('message',function (ev){
+	    switch (ev.data.action) {
+        	case 'initialise':
+                initialise(ev.data.object);
+                break;
+        	case 'intersect':
+        		intersect(ev.data.object);
+                break;
+        	case 'subtract':
+        		subtract(ev.data.object);
+                break;
+        	case 'union':
+        		union(ev.data.object);
+                break;
+        	default:
+        		throw 'Cannot handle specified action.';
+	    }
+	});
+		
+    //var test = ev.data;
+    //self.postMessage(test, [test]);
+};
+

package/src/workers/geometryCSGInternal.js

@@ -0,0 +1,58 @@
+const THREE = require('three');
+const ThreeBSP = require('../three-js-csg')(THREE);
+const Geometry = require('../primitives/geometry').Geometry;
+const GeometryCSG = require('../geometryCSG').GeometryCSG;
+
+const GeometryCSGInternal = function (hostIn) {
+  //ZincGeoemtry of the main geometry
+  let host = undefined;
+  if (hostIn && hostIn.isGeometry)
+    host = hostIn;
+  let hostCSG = undefined;
+  
+  this.setGeometry = hostIn => {
+    if (hostIn && hostIn.isGeometry)
+	  host = hostIn;
+    hostCSG = undefined;
+  }
+  
+  this.setCSG = csg => {
+	  hostCSG = csg;
+  }
+  
+  const prepareCSG = guestGeometry => {
+	  if (host && host.morph && guestGeometry && guestGeometry.morph) {
+	      if (hostCSG === undefined)
+	        hostCSG = new ThreeBSP(host.morph);
+	      const guestCSG = new ThreeBSP(guestGeometry.morph);
+	      return guestCSG;
+	  }
+	  return undefined;
+  };
+  
+  this.intersect = guestGeometry => {
+	  const guestCSG = prepareCSG(guestGeometry);
+	  if (hostCSG && guestCSG) {
+	    return hostCSG.intersect(guestCSG);
+	  }
+	  return undefined;
+  }
+  
+  this.subtract = guestGeometry => {
+	  const guestCSG = prepareCSG(guestGeometry);
+	  if (hostCSG && guestCSG) {
+		  return hostCSG.subtract(guestCSG);
+	  }
+	  return undefined;
+  }
+  
+  this.union = guestGeometry => {
+	  const guestCSG = prepareCSG(guestGeometry);
+	  if (hostCSG && guestCSG) {
+		  return hostCSG.union(guestCSG);
+	  }
+	  return undefined;
+  }
+};
+
+exports.GeometryCSGInternal = GeometryCSGInternal;

package/src/zinc.js

@@ -0,0 +1,38 @@
+require("url-polyfill");
+
+/**
+ * Provides a global namespace for the Zinc javascript library and some default parameters for it.
+ * 
+ * @namespace
+ * @author Alan Wu
+ */
+
+const Zinc = function() {
+  this.Revision = "1.0.12";
+  this.defaultMaterialColor = 0xFFFFFF;
+  this.defaultOpacity = 1.0;
+  this.modelPrefix = undefined;
+  this.Geometry = require('./primitives/geometry').Geometry;
+  this.Glyph = require('./primitives/glyph').Glyph;
+  this.Glyphset = require('./primitives/glyphset').Glyphset;
+  this.Pointset = require('./primitives/pointset').Pointset;
+  this.Lines = require('./primitives/lines').Lines;
+  this.TextureArray = require('./texture/textureArray').TextureArray;
+  this.TextureSlides = require('./primitives/textureSlides').TextureSlides;
+  this.Renderer = require('./renderer').Renderer;
+  this.Scene = require('./scene').Scene;
+  this.GeometryCSG = require('./geometryCSG').GeometryCSG;
+  this.GlyphsetCSG = require('./glyphsetCSG').GlyphsetCSG;
+  this.Viewport = require('./controls').Viewport;
+  this.CameraControls = require('./controls').CameraControls;
+  this.SmoothCameraTransition = require('./controls').SmoothCameraTransition;
+  this.RayCaster = require('./controls').RayCaster;
+  this.CameraAutoTumble = require('./controls').CameraAutoTumble;
+  this.StereoEffect = require('./controls').StereoEffect;
+  this.loadExternalFile = require('./utilities').loadExternalFile;
+  this.loadExternalFiles = require('./utilities').loadExternalFiles;
+  this.THREE = require('three'); 
+  
+};
+
+module.exports = new Zinc();