Merge branch 'dev'

.nycrc.json

@@ -0,0 +1,7 @@
+{
+	"exclude": [
+		"*/external/*",
+		"*/viewer/*",
+		"test/*"
+	]
+}

.travis.yml

@@ -1,8 +1,5 @@
 language: node_js
 
-env:
-  - python
-
 node_js:
   - "15"
 

README.md

@@ -4,6 +4,7 @@ This repository contains the source code of the https://3dviewer.net website. Th
 
 [![Build status](https://ci.appveyor.com/api/projects/status/exypq43a8kjby5n0?svg=true)](https://ci.appveyor.com/project/kovacsv/online3dviewer)
 [![Build Status](https://travis-ci.com/kovacsv/Online3DViewer.svg?branch=master)](https://travis-ci.com/kovacsv/Online3DViewer)
+[![Language grade: JavaScript](https://img.shields.io/lgtm/grade/javascript/g/kovacsv/Online3DViewer.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/kovacsv/Online3DViewer/context:javascript)
 
 ## Documentation
 

appveyor.yml

@@ -14,6 +14,7 @@ build_script:
 
 test_script:
   - npm run test
+  - npm run codecov
   
 artifacts:
   - path: build\final\package\*

package.json

@@ -1,17 +1,22 @@
 {
 	"name": "online-3d-viewer",
 	"description": "Online 3D Viewer",
-	"version": "0.7.3",
+	"version": "0.7.4",
 	"repository": "github:kovacsv/Online3DViewer",
 	"license": "MIT",
 	"devDependencies": {
 		"google-closure-compiler": "^20210302.0.0",
 		"jshint": "^2.12.0",
 		"mocha": "^8.3.2",
-		"svgo": "^2.2.2"
+		"rewire": "^5.0.0",
+		"svgo": "^2.2.2",
+		"nyc": "^15.1.0",
+		"codecov": "^3.8.1"
 	},
 	"scripts": {
 		"test": "mocha test",
+		"coverage": "nyc mocha test",
+		"codecov": "nyc --reporter=lcov mocha test && codecov",
 		"build": "python tools/create_package.py",
 		"update": "python tools/update_includes.py",
 		"svg": "python tools/optimize_svg_files.py"

source/core/taskrunner.js

@@ -39,3 +39,10 @@ OV.TaskRunner = class
         }
     }
 };
+
+OV.RunTaskAsync = function (task)
+{
+    setTimeout (function () {
+        task ();
+    }, 0);
+};

source/export/exporter.js

@@ -1,26 +1,26 @@
 OV.Exporter = class
 {
-	constructor ()
-	{
-		this.exporters = [
-			new OV.ExporterObj (),
-			new OV.ExporterStl (),
-			new OV.ExporterPly (),
-			new OV.ExporterOff (),
-			new OV.ExporterGltf ()
-		];
-	}
+    constructor ()
+    {
+        this.exporters = [
+            new OV.ExporterObj (),
+            new OV.ExporterStl (),
+            new OV.ExporterPly (),
+            new OV.ExporterOff (),
+            new OV.ExporterGltf ()
+        ];
+    }
 
-	Export (model, format, extension)
-	{
-		let files = [];
-		for (let i = 0; i < this.exporters.length; i++) {
-			let exporter = this.exporters[i];
-			if (exporter.CanExport (format, extension)) {
-				exporter.Export (model, format, files);
-				break;
-			}
-		}
-		return files;
-	}
+    Export (model, format, extension)
+    {
+        let files = [];
+        for (let i = 0; i < this.exporters.length; i++) {
+            let exporter = this.exporters[i];
+            if (exporter.CanExport (format, extension)) {
+                exporter.Export (model, format, files);
+                break;
+            }
+        }
+        return files;
+    }
 };

source/export/exportergltf.js

@@ -225,6 +225,25 @@ OV.ExporterGltf = class extends OV.ExporterBase
 
     GetMainJson (meshDataArr)
     {
+        class BufferViewCreator
+        {
+            constructor (mainJson, byteOffset)
+            {
+                this.mainJson = mainJson;
+                this.byteOffset = byteOffset;
+            }
+
+            AddBufferView (byteLength)
+            {
+                this.mainJson.bufferViews.push ({
+                    buffer : 0,
+                    byteOffset : this.byteOffset,
+                    byteLength : byteLength,
+                });
+                this.byteOffset += byteLength;
+            }
+        }
+
         function AddBufferView (mainJson, offset, length)
         {
             mainJson.bufferViews.push ({
@@ -269,10 +288,10 @@ OV.ExporterGltf = class extends OV.ExporterBase
                 let primitive = primitives[primitiveIndex];
 
                 let bufferViewIndex = mainJson.bufferViews.length;
-                let bufferViewOffset = meshData.offsets[primitiveIndex];
-                bufferViewOffset = AddBufferView (mainJson, bufferViewOffset, primitive.indices.length * this.components.index.size);
-                bufferViewOffset = AddBufferView (mainJson, bufferViewOffset, primitive.vertices.length * this.components.number.size);
-                bufferViewOffset = AddBufferView (mainJson, bufferViewOffset, primitive.normals.length * this.components.number.size);
+                let bufferViewCreator = new BufferViewCreator (mainJson, meshData.offsets[primitiveIndex]);
+                bufferViewCreator.AddBufferView (primitive.indices.length * this.components.index.size);
+                bufferViewCreator.AddBufferView (primitive.vertices.length * this.components.number.size);
+                bufferViewCreator.AddBufferView (primitive.normals.length * this.components.number.size);
 
                 let accessorIndex = mainJson.accessors.length;
                 let jsonPrimitive = {
@@ -310,7 +329,7 @@ OV.ExporterGltf = class extends OV.ExporterBase
                     type : 'VEC3'
                 });
                 if (primitive.uvs.length > 0) {
-                    bufferViewOffset = AddBufferView (mainJson, bufferViewOffset, primitive.uvs.length * this.components.number.size);
+                    bufferViewCreator.AddBufferView (primitive.uvs.length * this.components.number.size);
                     mainJson.accessors.push ({
                         bufferView : bufferViewIndex + 3,
                         byteOffset : 0,

source/external/three.model.loader.js

@@ -44,22 +44,16 @@ OV.ThreeModelLoader = class
 	{
 		let obj = this;
 		this.callbacks.onFilesLoaded ();
-		
-		let taskRunner = new OV.TaskRunner ();
-		taskRunner.Run (1, {
-			runTask : function (index, ready) {
-				obj.importer.Import ({
-					success : function (importResult) {
-						obj.OnModelImported (importResult);
-						ready ();
-					},
-					error : function (importError) {
-						obj.callbacks.onLoadError (importError);
-						obj.inProgress = false;
-						ready ();
-					}
-				});
-			}
+		OV.RunTaskAsync (function () {
+			obj.importer.Import ({
+				success : function (importResult) {
+					obj.OnModelImported (importResult);
+				},
+				error : function (importError) {
+					obj.callbacks.onLoadError (importError);
+					obj.inProgress = false;
+				}
+			});
 		});
 	}
 

source/import/importer.js

@@ -179,21 +179,6 @@ OV.FileList = class
 	}
 };
 
-OV.RevokeModelUrls = function (model)
-{
-	if (model === null) {
-		return;
-	}
-	for (let i = 0; i < model.MaterialCount (); i++) {
-		let material = model.GetMaterial (i);
-		material.EnumerateTextureMaps (function (texture) {
-			if (texture.url !== null) {
-				OV.RevokeObjectUrl (texture.url);
-			}
-		});
-	}
-};
-
 OV.ImportErrorCode =
 {
 	NoImportableFile : 1,
@@ -217,11 +202,51 @@ OV.ImportResult = class
 		this.model = null;
 		this.mainFile = null;
 		this.upVector = null;
-		this.usedFiles = [];
-		this.missingFiles = [];
+		this.usedFiles = null;
+		this.missingFiles = null;
 	}
 };
 
+OV.ImporterBuffers = class
+{
+    constructor (getBufferCallback)
+    {
+        this.getBufferCallback = getBufferCallback;
+        this.fileBuffers = {};
+        this.textureBuffers = {};
+    }
+
+    GetFileBuffer (filePath)
+    {
+        let fileName = OV.GetFileName (filePath);
+        let buffer = this.fileBuffers[fileName];
+        if (buffer === undefined) {
+            buffer = this.getBufferCallback (fileName);
+            this.fileBuffers[fileName] = buffer;
+        }
+        return buffer;
+    }
+
+    GetTextureBuffer (filePath)
+    {
+        let fileName = OV.GetFileName (filePath);
+        let buffer = this.textureBuffers[fileName];
+        if (buffer === undefined) {
+            let textureBuffer = this.getBufferCallback (fileName);
+            if (textureBuffer !== null) {
+                buffer = {
+                    url : OV.CreateObjectUrl (textureBuffer),
+                    buffer : textureBuffer
+                };
+            } else {
+                buffer = null;
+            }
+            this.textureBuffers[fileName] = buffer;
+        }
+        return buffer;
+    }
+};
+
 OV.Importer = class
 {
 	constructor ()
@@ -235,6 +260,8 @@ OV.Importer = class
 			new OV.ImporterGltf ()
 		];
 		this.fileList = new OV.FileList (this.importers);
+		this.model = null;
+		this.usedFiles = [];
 		this.missingFiles = [];
 	}
 	
@@ -256,30 +283,41 @@ OV.Importer = class
 			return;
 		}
 
+		this.RevokeModelUrls ();
+		this.model = null;
+		this.usedFiles = [];
+		this.missingFiles = [];
+		this.usedFiles.push (mainFile.file.name);
+
 		let result = new OV.ImportResult ();
 		result.mainFile = mainFile.file.name;
-		result.usedFiles.push (mainFile.file.name);
 
 		let obj = this;
 		let importer = mainFile.importer;
+		let buffers = new OV.ImporterBuffers (function (fileName) {
+			let fileBuffer = null;
+			let file = obj.fileList.FindFileByPath (fileName);
+			if (file === null || file.content === null) {
+				obj.missingFiles.push (fileName);
+				fileBuffer = null;
+			} else {
+				fileBuffer = file.content;
+				obj.usedFiles.push (fileName);
+			}
+			return fileBuffer;
+		});
+
 		importer.Import (mainFile.file.content, mainFile.file.extension, {
 			getDefaultMaterial : function () {
 				let material = new OV.Material ();
 				material.diffuse = new OV.Color (200, 200, 200);
 				return material;
 			},
-			getFileBuffer : function (fileName) {
-				let fileBuffer = null;
-				let file = obj.fileList.FindFileByPath (fileName);
-				if (file === null || file.content === null) {
-					result.missingFiles.push (fileName);
-					obj.missingFiles.push (fileName);
-					fileBuffer = null;
-				} else {
-					result.usedFiles.push (fileName);
-					fileBuffer = file.content;
-				}
-				return fileBuffer;
+			getFileBuffer : function (filePath) {
+				return buffers.GetFileBuffer (filePath);
+			},
+			getTextureBuffer : function (filePath) {
+				return buffers.GetTextureBuffer (filePath);
 			}
 		});
 
@@ -289,8 +327,12 @@ OV.Importer = class
 			return;
 		}
 
-		result.model = importer.GetModel ();
-		result.model.SetName (mainFile.file.name);
+		this.model = importer.GetModel ();
+		this.model.SetName (mainFile.file.name);
+
+		result.model = this.model;
+		result.usedFiles = this.usedFiles;
+		result.missingFiles = this.missingFiles;
 		result.upVector = importer.GetUpDirection ();
 		callbacks.success (result);
 	}
@@ -325,7 +367,6 @@ OV.Importer = class
 		if (reset) {
 			this.fileList = newFileList;
 		}
-		this.missingFiles = [];
 		this.fileList.GetContent (function () {
 			onReady ();
 		});
@@ -340,4 +381,19 @@ OV.Importer = class
 	{
 		return this.fileList.IsOnlySource (source);
 	}
+
+	RevokeModelUrls ()
+	{
+		if (this.model === null) {
+			return;
+		}
+		for (let i = 0; i < this.model.MaterialCount (); i++) {
+			let material = this.model.GetMaterial (i);
+			material.EnumerateTextureMaps (function (texture) {
+				if (texture.url !== null) {
+					OV.RevokeObjectUrl (texture.url);
+				}
+			});
+		}
+	}
 };

source/import/importer3ds.js

@@ -177,7 +177,7 @@ OV.Importer3ds = class extends OV.ImporterBase
 		this.ReadChunks (reader, endByte, function (chunkId, chunkLength) {
 			if (chunkId === OV.CHUNK3DS.MAT_TEXMAP_NAME) {
 				let textureName = obj.ReadName (reader);
-				let textureBuffer = obj.GetTextureBuffer (textureName);
+				let textureBuffer = obj.callbacks.getTextureBuffer (textureName);
 				texture.name = textureName;
 				if (textureBuffer !== null) {
 					texture.url = textureBuffer.url;

source/import/importerbase.js

@@ -1,61 +1,18 @@
-OV.ImporterBuffers = class
-{
-    constructor (getBufferCallback)
-    {
-        this.getBufferCallback = getBufferCallback;
-        this.fileBuffers = {};
-        this.textureBuffers = {};
-    }
-
-    GetFileBuffer (filePath)
-    {
-        let fileName = OV.GetFileName (filePath);
-        let buffer = this.fileBuffers[fileName];
-        if (buffer === undefined) {
-            buffer = this.getBufferCallback (fileName);
-            this.fileBuffers[fileName] = buffer;
-        }
-        return buffer;
-    }
-
-    GetTextureBuffer (filePath)
-    {
-        let fileName = OV.GetFileName (filePath);
-        let buffer = this.textureBuffers[fileName];
-        if (buffer === undefined) {
-            let texBuffer = this.getBufferCallback (fileName);
-            if (texBuffer !== null) {
-                buffer = {
-                    url : OV.CreateObjectUrl (texBuffer),
-                    buffer : texBuffer
-                };
-            } else {
-                buffer = null;
-            }
-            this.textureBuffers[fileName] = buffer;
-        }
-        return buffer;
-    }    
-};
-
 OV.ImporterBase = class
 {
     constructor ()
     {
         this.extension = null;
         this.callbacks = null;
-        this.buffers = null;
         this.model = null;
         this.error = null;
         this.message = null;
-        this.buffers = null;
     }
 	
 	Import (content, extension, callbacks)
 	{
         this.extension = extension;
         this.callbacks = callbacks;
-        this.buffers = new OV.ImporterBuffers (this.callbacks.getFileBuffer);
         this.model = new OV.Model ();
         this.error = false;
         this.message = null;
@@ -74,16 +31,6 @@ OV.ImporterBase = class
         OV.FinalizeModel (this.model, this.callbacks.getDefaultMaterial);
 	}
 
-    GetFileBuffer (filePath)
-    {
-        return this.buffers.GetFileBuffer (filePath);
-    }
-
-    GetTextureBuffer (filePath)
-    {
-        return this.buffers.GetTextureBuffer (filePath);
-    }
-
     ResetState ()
     {
 

source/import/importergltf.js

@@ -405,7 +405,7 @@ OV.ImporterGltf = class extends OV.ImporterBase
             if (base64Buffer !== null) {
                 buffer = base64Buffer.buffer;
             } else {
-                let fileBuffer = this.GetFileBuffer (gltfBuffer.uri);
+                let fileBuffer = this.callbacks.getFileBuffer (gltfBuffer.uri);
                 if (fileBuffer !== null) {
                     buffer = fileBuffer;
                 }
@@ -636,7 +636,7 @@ OV.ImporterGltf = class extends OV.ImporterBase
                     textureParams.url = OV.CreateObjectUrlWithMimeType (base64Buffer.buffer, base64Buffer.mimeType);
                     textureParams.buffer = base64Buffer.buffer;
                 } else {
-                    let textureBuffer = this.GetTextureBuffer (gltfImage.uri);
+                    let textureBuffer = this.callbacks.getTextureBuffer (gltfImage.uri);
                     textureParams.name = gltfImage.uri;
                     if (textureBuffer !== null) {
                         textureParams.url = textureBuffer.url;

source/import/importerobj.js

@@ -166,11 +166,11 @@ OV.ImporterObj = class extends OV.ImporterBase
 			);
 		}
 
-		function CreateTexture (importer, keyword, line)
+		function CreateTexture (keyword, line, callbacks)
 		{
 			let texture = new OV.TextureMap ();
 			let textureName = OV.NameFromLine (line, keyword.length, '#');
-			let textureBuffer = importer.GetTextureBuffer (textureName);
+			let textureBuffer = callbacks.getTextureBuffer (textureName);
 			texture.name = textureName;
 			if (textureBuffer !== null) {
 				texture.url = textureBuffer.url;
@@ -208,7 +208,7 @@ OV.ImporterObj = class extends OV.ImporterBase
 				return true;
 			}
 			let fileName = OV.NameFromLine (line, keyword.length, '#');
-			let fileBuffer = this.GetFileBuffer (fileName);
+			let fileBuffer = this.callbacks.getFileBuffer (fileName);
 			if (fileBuffer !== null) {
 				OV.ReadLines (fileBuffer, function (line) {
 					if (!obj.IsError ()) {
@@ -221,19 +221,19 @@ OV.ImporterObj = class extends OV.ImporterBase
 			if (this.currentMaterial === null || parameters.length === 0) {
 				return true;
 			}
-			this.currentMaterial.diffuseMap = CreateTexture (this, keyword, line);
+			this.currentMaterial.diffuseMap = CreateTexture (keyword, line, this.callbacks);
 			return true;
 		} else if (keyword === 'map_ks') {
 			if (this.currentMaterial === null || parameters.length === 0) {
 				return true;
 			}
-			this.currentMaterial.specularMap = CreateTexture (this, keyword, line);
+			this.currentMaterial.specularMap = CreateTexture (keyword, line, this.callbacks);
 			return true;
 		} else if (keyword === 'map_bump' || keyword === 'bump') {
 			if (this.currentMaterial === null || parameters.length === 0) {
 				return true;
 			}
-			this.currentMaterial.bumpMap = CreateTexture (this, keyword, line);
+			this.currentMaterial.bumpMap = CreateTexture (keyword, line, this.callbacks);
 			return true;
 		} else if (keyword === 'ka') {
 			if (this.currentMaterial === null || parameters.length < 3) {

source/model/mesh.js

@@ -1,100 +1,100 @@
 OV.Mesh = class
 {
-	constructor ()
-	{
-		this.name = '';
-		this.vertices = [];
-		this.normals = [];
-		this.uvs = [];
-		this.triangles = [];
-	}
+    constructor ()
+    {
+        this.name = '';
+        this.vertices = [];
+        this.normals = [];
+        this.uvs = [];
+        this.triangles = [];
+    }
 
-	GetName ()
-	{
-		return this.name;
-	}
-	
-	SetName (name)
-	{
-		this.name = name;
-	}
-	
-	VertexCount ()
-	{
-		return this.vertices.length;
-	}
-	
-	NormalCount ()
-	{
-		return this.normals.length;
-	}
-	
-	TextureUVCount ()
-	{
-		return this.uvs.length;
-	}
-	
-	TriangleCount ()
-	{
-		return this.triangles.length;
-	}
-	
-	AddVertex (vertex)
-	{
-		this.vertices.push (vertex);
-		return this.vertices.length - 1;
-	}
+    GetName ()
+    {
+        return this.name;
+    }
+    
+    SetName (name)
+    {
+        this.name = name;
+    }
+    
+    VertexCount ()
+    {
+        return this.vertices.length;
+    }
+    
+    NormalCount ()
+    {
+        return this.normals.length;
+    }
+    
+    TextureUVCount ()
+    {
+        return this.uvs.length;
+    }
+    
+    TriangleCount ()
+    {
+        return this.triangles.length;
+    }
+    
+    AddVertex (vertex)
+    {
+        this.vertices.push (vertex);
+        return this.vertices.length - 1;
+    }
 
-	SetVertex (index, vertex)
-	{
-		this.vertices[index] = vertex;
-	}
-	
-	GetVertex (index)
-	{
-		return this.vertices[index];
-	}
-	
-	AddNormal (normal)
-	{
-		this.normals.push (normal);
-		return this.normals.length - 1;
-	}
+    SetVertex (index, vertex)
+    {
+        this.vertices[index] = vertex;
+    }
+    
+    GetVertex (index)
+    {
+        return this.vertices[index];
+    }
+    
+    AddNormal (normal)
+    {
+        this.normals.push (normal);
+        return this.normals.length - 1;
+    }
 
-	SetNormal (index, normal)
-	{
-		this.normals[index] = normal;
-	}
+    SetNormal (index, normal)
+    {
+        this.normals[index] = normal;
+    }
 
-	GetNormal (index)
-	{
-		return this.normals[index];
-	}
-	
-	AddTextureUV (uv)
-	{
-		this.uvs.push (uv);
-		return this.uvs.length - 1;
-	}
+    GetNormal (index)
+    {
+        return this.normals[index];
+    }
+    
+    AddTextureUV (uv)
+    {
+        this.uvs.push (uv);
+        return this.uvs.length - 1;
+    }
 
-	SetTextureUV (index, uv)
-	{
-		this.uvs[index] = uv;
-	}
-	
-	GetTextureUV (index)
-	{
-		return this.uvs[index];
-	}
-	
-	AddTriangle (triangle)
-	{
-		this.triangles.push (triangle);
-		return this.triangles.length - 1;
-	}
-	
-	GetTriangle (index)
-	{
-		return this.triangles[index];
-	}
+    SetTextureUV (index, uv)
+    {
+        this.uvs[index] = uv;
+    }
+    
+    GetTextureUV (index)
+    {
+        return this.uvs[index];
+    }
+    
+    AddTriangle (triangle)
+    {
+        this.triangles.push (triangle);
+        return this.triangles.length - 1;
+    }
+    
+    GetTriangle (index)
+    {
+        return this.triangles[index];
+    }
 };

source/model/model.js

@@ -1,105 +1,105 @@
 OV.Model = class
 {
-	constructor ()
-	{
-		this.name = '';
-		this.materials = [];
-		this.meshes = [];
-	}
+    constructor ()
+    {
+        this.name = '';
+        this.materials = [];
+        this.meshes = [];
+    }
 
-	GetName ()
-	{
-		return this.name;
-	}
+    GetName ()
+    {
+        return this.name;
+    }
 
-	SetName (name)
-	{
-		this.name = name;
-	}
+    SetName (name)
+    {
+        this.name = name;
+    }
 
-	MaterialCount ()
-	{
-		return this.materials.length;
-	}
+    MaterialCount ()
+    {
+        return this.materials.length;
+    }
 
-	MeshCount ()
-	{
-		return this.meshes.length;
-	}
+    MeshCount ()
+    {
+        return this.meshes.length;
+    }
 
-	VertexCount ()
-	{
-		let count = 0;
-		for (let i = 0; i < this.meshes.length; i++) {
-			count += this.meshes[i].VertexCount ();
-		}
-		return count;
-	}
+    VertexCount ()
+    {
+        let count = 0;
+        for (let i = 0; i < this.meshes.length; i++) {
+            count += this.meshes[i].VertexCount ();
+        }
+        return count;
+    }
 
-	NormalCount ()
-	{
-		let count = 0;
-		for (let i = 0; i < this.meshes.length; i++) {
-			count += this.meshes[i].NormalCount ();
-		}
-		return count;
-	}
+    NormalCount ()
+    {
+        let count = 0;
+        for (let i = 0; i < this.meshes.length; i++) {
+            count += this.meshes[i].NormalCount ();
+        }
+        return count;
+    }
 
-	TextureUVCount ()
-	{
-		let count = 0;
-		for (let i = 0; i < this.meshes.length; i++) {
-			count += this.meshes[i].TextureUVCount ();
-		}
-		return count;
-	}
+    TextureUVCount ()
+    {
+        let count = 0;
+        for (let i = 0; i < this.meshes.length; i++) {
+            count += this.meshes[i].TextureUVCount ();
+        }
+        return count;
+    }
 
-	TriangleCount ()
-	{
-		let count = 0;
-		for (let i = 0; i < this.meshes.length; i++) {
-			count += this.meshes[i].TriangleCount ();
-		}
-		return count;
-	}
+    TriangleCount ()
+    {
+        let count = 0;
+        for (let i = 0; i < this.meshes.length; i++) {
+            count += this.meshes[i].TriangleCount ();
+        }
+        return count;
+    }
 
-	AddMaterial (material)
-	{
-		this.materials.push (material);
-		return this.materials.length - 1;
-	}
+    AddMaterial (material)
+    {
+        this.materials.push (material);
+        return this.materials.length - 1;
+    }
 
-	GetMaterial (index)
-	{
-		return this.materials[index];
-	}
+    GetMaterial (index)
+    {
+        return this.materials[index];
+    }
 
-	AddMesh (mesh)
-	{
-		this.meshes.push (mesh);
-		return this.meshes.length - 1;
-	}
+    AddMesh (mesh)
+    {
+        this.meshes.push (mesh);
+        return this.meshes.length - 1;
+    }
 
-	AddMeshToIndex (mesh, index)
-	{
-		this.meshes.splice (index, 0, mesh);
-		return index;
-	}
+    AddMeshToIndex (mesh, index)
+    {
+        this.meshes.splice (index, 0, mesh);
+        return index;
+    }
 
-	RemoveMesh (index)
-	{
-		this.meshes.splice (index, 1);
-	}
+    RemoveMesh (index)
+    {
+        this.meshes.splice (index, 1);
+    }
 
-	GetMesh (index)
-	{
-		return this.meshes[index];
-	}
+    GetMesh (index)
+    {
+        return this.meshes[index];
+    }
 
-	Clear ()
-	{
-		this.name = '';
-		this.materials = [];
-		this.meshes = [];
-	}
+    Clear ()
+    {
+        this.name = '';
+        this.materials = [];
+        this.meshes = [];
+    }
 };

source/model/modelentities.js

@@ -1,255 +1,255 @@
 OV.SRGBToLinear = function (component)
 {
-	if (component < 0.04045) {
-		return component * 0.0773993808;
-	} else {
-		return Math.pow (component * 0.9478672986 + 0.0521327014, 2.4);
-	}
+    if (component < 0.04045) {
+        return component * 0.0773993808;
+    } else {
+        return Math.pow (component * 0.9478672986 + 0.0521327014, 2.4);
+    }
 };
 
 OV.LinearToSRGB = function (component)
 {
-	if (component < 0.0031308) {
-		return component * 12.92;
-	} else {
-		return 1.055 * (Math.pow (component, 0.41666)) - 0.055;
-	}
+    if (component < 0.0031308) {
+        return component * 12.92;
+    } else {
+        return 1.055 * (Math.pow (component, 0.41666)) - 0.055;
+    }
 };
 
 OV.Color = class
 {
-	constructor (r, g, b)
-	{
-		this.r = r; // 0 .. 255
-		this.g = g; // 0 .. 255
-		this.b = b; // 0 .. 255
-	}
+    constructor (r, g, b)
+    {
+        this.r = r; // 0 .. 255
+        this.g = g; // 0 .. 255
+        this.b = b; // 0 .. 255
+    }
 
-	ToHexString ()
-	{
-		function IntegerToHex (intVal)
-		{
-			let result = parseInt (intVal, 10).toString (16);
-			while (result.length < 2) {
-				result = '0' + result;
-			}
-			return result;
-		}
+    ToHexString ()
+    {
+        function IntegerToHex (intVal)
+        {
+            let result = parseInt (intVal, 10).toString (16);
+            while (result.length < 2) {
+                result = '0' + result;
+            }
+            return result;
+        }
 
-		let r = IntegerToHex (this.r);
-		let g = IntegerToHex (this.g);
-		let b = IntegerToHex (this.b);
-		return r + g + b;
-	}
+        let r = IntegerToHex (this.r);
+        let g = IntegerToHex (this.g);
+        let b = IntegerToHex (this.b);
+        return r + g + b;
+    }
 
-	Clone ()
-	{
-		return new OV.Color (this.r, this.g, this.b);
-	}
+    Clone ()
+    {
+        return new OV.Color (this.r, this.g, this.b);
+    }
 };
 
 OV.TextureMap = class
 {
-	constructor ()
-	{
-		this.name = null;
-		this.url = null;
-		this.buffer = null;
-		this.offset = new OV.Coord2D (0.0, 0.0);
-		this.scale = new OV.Coord2D (1.0, 1.0);
-		this.rotation = 0.0; // radians
-	}
+    constructor ()
+    {
+        this.name = null;
+        this.url = null;
+        this.buffer = null;
+        this.offset = new OV.Coord2D (0.0, 0.0);
+        this.scale = new OV.Coord2D (1.0, 1.0);
+        this.rotation = 0.0; // radians
+    }
 
-	IsValid ()
-	{
-		return this.name !== null && this.url !== null && this.buffer !== null;
-	}
+    IsValid ()
+    {
+        return this.name !== null && this.url !== null && this.buffer !== null;
+    }
 
-	HasTransformation ()
-	{
-		if (!OV.CoordIsEqual2D (this.offset, new OV.Coord2D (0.0, 0.0))) {
-			return true;
-		}
-		if (!OV.CoordIsEqual2D (this.scale, new OV.Coord2D (1.0, 1.0))) {
-			return true;
-		}
-		if (!OV.IsEqual (this.rotation, 0.0)) {
-			return true;
-		}
+    HasTransformation ()
+    {
+        if (!OV.CoordIsEqual2D (this.offset, new OV.Coord2D (0.0, 0.0))) {
+            return true;
+        }
+        if (!OV.CoordIsEqual2D (this.scale, new OV.Coord2D (1.0, 1.0))) {
+            return true;
+        }
+        if (!OV.IsEqual (this.rotation, 0.0)) {
+            return true;
+        }
         return false;
-	}
+    }
 
-	Clone ()
-	{
-		let cloned = new OV.TextureMap ();
-		cloned.name = this.name;
-		cloned.url = this.url;
-		cloned.buffer = this.buffer;
-		cloned.offset = this.offset.Clone ();
-		cloned.scale = this.scale.Clone ();
-		cloned.rotation = this.rotation;
-		return cloned;
-	}
+    Clone ()
+    {
+        let cloned = new OV.TextureMap ();
+        cloned.name = this.name;
+        cloned.url = this.url;
+        cloned.buffer = this.buffer;
+        cloned.offset = this.offset.Clone ();
+        cloned.scale = this.scale.Clone ();
+        cloned.rotation = this.rotation;
+        return cloned;
+    }
 };
 
 OV.Material = class
 {
-	constructor ()
-	{
-		this.name = '';
+    constructor ()
+    {
+        this.name = '';
 
-		this.ambient = new OV.Color (0, 0, 0);
-		this.diffuse = new OV.Color (0, 0, 0);
-		this.specular = new OV.Color (0, 0, 0);
-		this.emissive = new OV.Color (0, 0, 0);
+        this.ambient = new OV.Color (0, 0, 0);
+        this.diffuse = new OV.Color (0, 0, 0);
+        this.specular = new OV.Color (0, 0, 0);
+        this.emissive = new OV.Color (0, 0, 0);
 
-		this.shininess = 0.0; // 0.0 .. 1.0
-		this.opacity = 1.0; // 0.0 .. 1.0
+        this.shininess = 0.0; // 0.0 .. 1.0
+        this.opacity = 1.0; // 0.0 .. 1.0
 
-		this.diffuseMap = null;
-		this.specularMap = null;
-		this.bumpMap = null;
-		this.normalMap = null;
-		this.emissiveMap = null;
+        this.diffuseMap = null;
+        this.specularMap = null;
+        this.bumpMap = null;
+        this.normalMap = null;
+        this.emissiveMap = null;
 
-		this.alphaTest = 0.0; // 0.0 .. 1.0
-		this.transparent = false;
-		this.multiplyDiffuseMap = false;
-	}
+        this.alphaTest = 0.0; // 0.0 .. 1.0
+        this.transparent = false;
+        this.multiplyDiffuseMap = false;
+    }
 
-	EnumerateTextureMaps (enumerator)
-	{
-		if (this.diffuseMap !== null) {
-			enumerator (this.diffuseMap);
-		}
-		if (this.specularMap !== null) {
-			enumerator (this.specularMap);
-		}
-		if (this.bumpMap !== null) {
-			enumerator (this.bumpMap);
-		}
-		if (this.normalMap !== null) {
-			enumerator (this.normalMap);
-		}
-		if (this.emissiveMap !== null) {
-			enumerator (this.emissiveMap);
-		}
-	}
+    EnumerateTextureMaps (enumerator)
+    {
+        if (this.diffuseMap !== null) {
+            enumerator (this.diffuseMap);
+        }
+        if (this.specularMap !== null) {
+            enumerator (this.specularMap);
+        }
+        if (this.bumpMap !== null) {
+            enumerator (this.bumpMap);
+        }
+        if (this.normalMap !== null) {
+            enumerator (this.normalMap);
+        }
+        if (this.emissiveMap !== null) {
+            enumerator (this.emissiveMap);
+        }
+    }
 
-	Clone ()
-	{
-		let cloned = new OV.Material ();
+    Clone ()
+    {
+        let cloned = new OV.Material ();
 
-		cloned.name = this.name;
+        cloned.name = this.name;
 
-		cloned.ambient = this.ambient.Clone ();
-		cloned.diffuse = this.diffuse.Clone ();
-		cloned.specular = this.specular.Clone ();
-		cloned.emissive = this.emissive.Clone ();
+        cloned.ambient = this.ambient.Clone ();
+        cloned.diffuse = this.diffuse.Clone ();
+        cloned.specular = this.specular.Clone ();
+        cloned.emissive = this.emissive.Clone ();
 
-		cloned.shininess = this.shininess;
-		cloned.opacity = this.opacity;
+        cloned.shininess = this.shininess;
+        cloned.opacity = this.opacity;
 
-		cloned.diffuseMap = this.CloneTextureMap (this.diffuseMap);
-		cloned.specularMap = this.CloneTextureMap (this.specularMap);
-		cloned.bumpMap = this.CloneTextureMap (this.bumpMap);
-		cloned.normalMap = this.CloneTextureMap (this.normalMap);
-		cloned.emissiveMap = this.CloneTextureMap (this.emissiveMap);
+        cloned.diffuseMap = this.CloneTextureMap (this.diffuseMap);
+        cloned.specularMap = this.CloneTextureMap (this.specularMap);
+        cloned.bumpMap = this.CloneTextureMap (this.bumpMap);
+        cloned.normalMap = this.CloneTextureMap (this.normalMap);
+        cloned.emissiveMap = this.CloneTextureMap (this.emissiveMap);
 
-		cloned.alphaTest = this.alphaTest;
-		cloned.transparent = this.transparent;
-		cloned.multiplyDiffuseMap = this.multiplyDiffuseMap;
+        cloned.alphaTest = this.alphaTest;
+        cloned.transparent = this.transparent;
+        cloned.multiplyDiffuseMap = this.multiplyDiffuseMap;
 
-		return cloned;
-	}
+        return cloned;
+    }
 
-	CloneTextureMap (textureMap)
-	{
-		if (textureMap === null) {
-			return null;
-		}
-		return textureMap.Clone ();
-	}
+    CloneTextureMap (textureMap)
+    {
+        if (textureMap === null) {
+            return null;
+        }
+        return textureMap.Clone ();
+    }
 };
 
 OV.Triangle = class
 {
-	constructor (v0, v1, v2)
-	{
-		this.v0 = v0;
-		this.v1 = v1;
-		this.v2 = v2;
-	
-		this.n0 = null;
-		this.n1 = null;
-		this.n2 = null;
-	
-		this.u0 = null;
-		this.u1 = null;
-		this.u2 = null;
-	
-		this.mat = null;
-		this.curve = null;
-	}
+    constructor (v0, v1, v2)
+    {
+        this.v0 = v0;
+        this.v1 = v1;
+        this.v2 = v2;
+    
+        this.n0 = null;
+        this.n1 = null;
+        this.n2 = null;
+    
+        this.u0 = null;
+        this.u1 = null;
+        this.u2 = null;
+    
+        this.mat = null;
+        this.curve = null;
+    }
 
-	HasVertices ()
-	{
-		return this.v0 !== null && this.v1 !== null && this.v2 !== null;
-	}
+    HasVertices ()
+    {
+        return this.v0 !== null && this.v1 !== null && this.v2 !== null;
+    }
 
-	HasNormals ()
-	{
-		return this.n0 !== null && this.n1 !== null && this.n2 !== null;
-	}
+    HasNormals ()
+    {
+        return this.n0 !== null && this.n1 !== null && this.n2 !== null;
+    }
 
-	HasTextureUVs ()
-	{
-		return this.u0 !== null && this.u1 !== null && this.u2 !== null;
-	}	
+    HasTextureUVs ()
+    {
+        return this.u0 !== null && this.u1 !== null && this.u2 !== null;
+    }    
 
-	SetVertices (v0, v1, v2)
-	{
-		this.v0 = v0;
-		this.v1 = v1;
-		this.v2 = v2;
-		return this;
-	}
-	
-	SetNormals (n0, n1, n2)
-	{
-		this.n0 = n0;
-		this.n1 = n1;
-		this.n2 = n2;
-		return this;
-	}
-	
-	SetTextureUVs (u0, u1, u2)
-	{
-		this.u0 = u0;
-		this.u1 = u1;
-		this.u2 = u2;
-		return this;
-	}
+    SetVertices (v0, v1, v2)
+    {
+        this.v0 = v0;
+        this.v1 = v1;
+        this.v2 = v2;
+        return this;
+    }
+    
+    SetNormals (n0, n1, n2)
+    {
+        this.n0 = n0;
+        this.n1 = n1;
+        this.n2 = n2;
+        return this;
+    }
+    
+    SetTextureUVs (u0, u1, u2)
+    {
+        this.u0 = u0;
+        this.u1 = u1;
+        this.u2 = u2;
+        return this;
+    }
 
-	SetMaterial (mat)
-	{
-		this.mat = mat;
-		return this;
-	}
-	
-	SetCurve (curve)
-	{
-		this.curve = curve;
-		return this;
-	}
+    SetMaterial (mat)
+    {
+        this.mat = mat;
+        return this;
+    }
+    
+    SetCurve (curve)
+    {
+        this.curve = curve;
+        return this;
+    }
 
-	Clone ()
-	{
-		let cloned = new OV.Triangle (this.v0, this.v1, this.v2);
-		cloned.SetNormals (this.n0, this.n1, this.n2);
-		cloned.SetTextureUVs (this.u0, this.u1, this.u2);
-		cloned.SetMaterial (this.mat);
-		cloned.SetCurve (this.curve);
-		return cloned;
-	}
+    Clone ()
+    {
+        let cloned = new OV.Triangle (this.v0, this.v1, this.v2);
+        cloned.SetNormals (this.n0, this.n1, this.n2);
+        cloned.SetTextureUVs (this.u0, this.u1, this.u2);
+        cloned.SetMaterial (this.mat);
+        cloned.SetCurve (this.curve);
+        return cloned;
+    }
 };

source/model/modelfinalization.js

@@ -1,7 +1,7 @@
 OV.FinalizeModel = function (model, getDefaultMaterial)
 {
-	function FinalizeMesh (mesh, getDefaultMaterialIndex)
-	{
+    function FinalizeMesh (mesh, getDefaultMaterialIndex)
+    {
         function CalculateCurveNormals (mesh)
         {
             function AddAverageNormal (mesh, triangle, vertexIndex, triangleNormals, vertexToTriangles)
@@ -54,9 +54,9 @@ OV.FinalizeModel = function (model, getDefaultMaterial)
             }            
         }
 
-		function FinalizeTriangle (mesh, triangle, status)
-		{
-			if (!triangle.HasNormals ()) {
+        function FinalizeTriangle (mesh, triangle, status)
+        {
+            if (!triangle.HasNormals ()) {
                 if (triangle.curve === null || triangle.curve === 0) {
                     let v0 = mesh.GetVertex (triangle.v0);
                     let v1 = mesh.GetVertex (triangle.v1);
@@ -67,29 +67,29 @@ OV.FinalizeModel = function (model, getDefaultMaterial)
                 } else {
                     status.calculateCurveNormals = true;
                 }
-			}
+            }
             if (triangle.mat === null) {
                 triangle.mat = status.getDefaultMaterialIndex ();
             }
             if (triangle.curve === null) {
                 triangle.curve = 0;
             }
-		}
-		
+        }
+        
         let status = {
             getDefaultMaterialIndex : getDefaultMaterialIndex,
             calculateCurveNormals : false
         };
 
-		for (let i = 0; i < mesh.TriangleCount (); i++) {
-			let triangle = mesh.GetTriangle (i);
-			FinalizeTriangle (mesh, triangle, status);
-		}
+        for (let i = 0; i < mesh.TriangleCount (); i++) {
+            let triangle = mesh.GetTriangle (i);
+            FinalizeTriangle (mesh, triangle, status);
+        }
 
         if (status.calculateCurveNormals) {
             CalculateCurveNormals (mesh);
         }
-	}
+    }
 
     let defaultMaterialIndex = null;
     let getDefaultMaterialIndex = function () {
@@ -143,9 +143,9 @@ OV.CheckModel = function (model)
     }    
     
     function CheckMesh (model, mesh)
-	{
+    {
         function CheckTriangle (model, mesh, triangle)
-		{
+        {
             if (!IsCorrectIndex (triangle.v0, mesh.VertexCount ())) {
                 return false;
             }
@@ -183,53 +183,53 @@ OV.CheckModel = function (model)
             }
 
             return true;
-		}
-		
-		for (let i = 0; i < mesh.VertexCount (); i++) {
-			let vertex = mesh.GetVertex (i);
-			if (!IsCorrectNumber (vertex.x)) {
+        }
+        
+        for (let i = 0; i < mesh.VertexCount (); i++) {
+            let vertex = mesh.GetVertex (i);
+            if (!IsCorrectNumber (vertex.x)) {
                 return false;
             }
-			if (!IsCorrectNumber (vertex.y)) {
+            if (!IsCorrectNumber (vertex.y)) {
                 return false;
             }
-			if (!IsCorrectNumber (vertex.z)) {
+            if (!IsCorrectNumber (vertex.z)) {
                 return false;
             }
-		}
+        }
 
-		for (let i = 0; i < mesh.NormalCount (); i++) {
-			let normal = mesh.GetNormal (i);
-			if (!IsCorrectNumber (normal.x)) {
+        for (let i = 0; i < mesh.NormalCount (); i++) {
+            let normal = mesh.GetNormal (i);
+            if (!IsCorrectNumber (normal.x)) {
                 return false;
             }
-			if (!IsCorrectNumber (normal.y)) {
+            if (!IsCorrectNumber (normal.y)) {
                 return false;
             }
-			if (!IsCorrectNumber (normal.z)) {
+            if (!IsCorrectNumber (normal.z)) {
                 return false;
             }
-		}
+        }
 
-		for (let i = 0; i < mesh.TextureUVCount (); i++) {
-			let uv = mesh.GetTextureUV (i);
-			if (!IsCorrectNumber (uv.x)) {
+        for (let i = 0; i < mesh.TextureUVCount (); i++) {
+            let uv = mesh.GetTextureUV (i);
+            if (!IsCorrectNumber (uv.x)) {
                 return false;
             }
-			if (!IsCorrectNumber (uv.y)) {
+            if (!IsCorrectNumber (uv.y)) {
                 return false;
             }
-		}        
+        }        
 
         for (let i = 0; i < mesh.TriangleCount (); i++) {
-			let triangle = mesh.GetTriangle (i);
-			if (!CheckTriangle (model, mesh, triangle)) {
+            let triangle = mesh.GetTriangle (i);
+            if (!CheckTriangle (model, mesh, triangle)) {
                 return false;
             }
-		}
+        }
 
         return true;
-	}
+    }
 
     for (let i = 0; i < model.MeshCount (); i++) {
         let mesh = model.GetMesh (i);

source/model/modelutils.js

@@ -1,16 +1,16 @@
 OV.CalculateTriangleNormal = function (v0, v1, v2)
 {
-	let v = OV.SubCoord3D (v1, v0);
-	let w = OV.SubCoord3D (v2, v0);
-	
-	let normal = new OV.Coord3D (
-		v.y * w.z - v.z * w.y,
-		v.z * w.x - v.x * w.z,
-		v.x * w.y - v.y * w.x
-	);
+    let v = OV.SubCoord3D (v1, v0);
+    let w = OV.SubCoord3D (v2, v0);
+    
+    let normal = new OV.Coord3D (
+        v.y * w.z - v.z * w.y,
+        v.z * w.x - v.x * w.z,
+        v.x * w.y - v.y * w.x
+    );
 
-	normal.Normalize ();
-	return normal;
+    normal.Normalize ();
+    return normal;
 };
 
 OV.TransformMesh = function (mesh, transformation)
@@ -43,20 +43,20 @@ OV.TransformMesh = function (mesh, transformation)
 
 OV.GetMeshBoundingBox = function (mesh)
 {
-	let min = new OV.Coord3D (Infinity, Infinity, Infinity);
-	let max = new OV.Coord3D (-Infinity, -Infinity, -Infinity);
+    let min = new OV.Coord3D (Infinity, Infinity, Infinity);
+    let max = new OV.Coord3D (-Infinity, -Infinity, -Infinity);
 
     for (let i = 0; i < mesh.VertexCount (); i++) {
         let vertex = mesh.GetVertex (i);
-		min.x = Math.min (min.x, vertex.x);
-		min.y = Math.min (min.y, vertex.y);
-		min.z = Math.min (min.z, vertex.z);
-		max.x = Math.max (max.x, vertex.x);
-		max.y = Math.max (max.y, vertex.y);
-		max.z = Math.max (max.z, vertex.z);
-	}
-	
-	return [min, max];
+        min.x = Math.min (min.x, vertex.x);
+        min.y = Math.min (min.y, vertex.y);
+        min.z = Math.min (min.z, vertex.z);
+        max.x = Math.max (max.x, vertex.x);
+        max.y = Math.max (max.y, vertex.y);
+        max.z = Math.max (max.z, vertex.z);
+    }
+    
+    return [min, max];
 };
 
 OV.IsModelEmpty = function (model)

source/viewer/domviewer.js

@@ -37,7 +37,7 @@ OV.Init3DViewerElements = function ()
                     return true;
                 });
                 viewer.AdjustClippingPlanes (boundingSphere);
-                viewer.FitToWindow (boundingSphere, false);        						
+                viewer.FitToWindow (boundingSphere, false);                                
             },
             onTextureLoaded : function () {
                 viewer.Render ();
@@ -47,25 +47,20 @@ OV.Init3DViewerElements = function ()
             },
         });
 
-        let model = element.getAttribute ('model');
-        if (!model) {
+        let modelParams = element.getAttribute ('model');
+        if (!modelParams) {
             return;
         }
 
-        let modelUrls = model.split (',');
-        if (modelUrls.length === 0) {
+        let modelUrls = OV.UrlParamConverter.UrlParameterToModelUrls (modelParams);
+        if (modelUrls === null || modelUrls.length === 0) {
             return;
         }
 
-        let camera = element.getAttribute ('camera');
-        if (camera) {
-            let cameraParams = camera.split (',');
-            if (cameraParams.length === 9) {
-                let camera = new OV.Camera (
-                    new OV.Coord3D (parseFloat (cameraParams[0]), parseFloat (cameraParams[1]), parseFloat (cameraParams[2])),
-                    new OV.Coord3D (parseFloat (cameraParams[3]), parseFloat (cameraParams[4]), parseFloat (cameraParams[5])),
-                    new OV.Coord3D (parseFloat (cameraParams[6]), parseFloat (cameraParams[7]), parseFloat (cameraParams[8]))
-                );
+        let cameraParams = element.getAttribute ('camera');
+        if (cameraParams) {
+            let camera = OV.UrlParamConverter.UrlParameterToCamera (cameraParams);
+            if (camera !== null) {
                 viewer.SetCamera (camera);
             }
         }

source/viewer/navigation.js

@@ -1,56 +1,56 @@
 OV.GetClientCoordinates = function (canvas, clientX, clientY)
 {
-	if (canvas.getBoundingClientRect) {
-		let clientRect = canvas.getBoundingClientRect ();
-		clientX -= clientRect.left;
-		clientY -= clientRect.top;
-	}
-	if (window.pageXOffset && window.pageYOffset) {
-		clientX += window.pageXOffset;
-		clientY += window.pageYOffset;
-	}
-	return (new OV.Coord2D (clientX, clientY));
+    if (canvas.getBoundingClientRect) {
+        let clientRect = canvas.getBoundingClientRect ();
+        clientX -= clientRect.left;
+        clientY -= clientRect.top;
+    }
+    if (window.pageXOffset && window.pageYOffset) {
+        clientX += window.pageXOffset;
+        clientY += window.pageYOffset;
+    }
+    return (new OV.Coord2D (clientX, clientY));
 };
 
 OV.Camera = class
 {
-	constructor (eye, center, up)
-	{
-		this.eye = eye;
-		this.center = center;
-		this.up = up;
-	}
+    constructor (eye, center, up)
+    {
+        this.eye = eye;
+        this.center = center;
+        this.up = up;
+    }
 
-	Clone ()
-	{
-		return new OV.Camera (
-			this.eye.Clone (),
-			this.center.Clone (),
-			this.up.Clone ()
-		);
-	}
+    Clone ()
+    {
+        return new OV.Camera (
+            this.eye.Clone (),
+            this.center.Clone (),
+            this.up.Clone ()
+        );
+    }
 };
 
 OV.MouseInteraction = class
 {
-	constructor ()
-	{
-		this.prev = new OV.Coord2D (0.0, 0.0);
-		this.curr = new OV.Coord2D (0.0, 0,0);
-		this.diff = new OV.Coord2D (0.0, 0.0);
-		this.buttons = [];
-	}
+    constructor ()
+    {
+        this.prev = new OV.Coord2D (0.0, 0.0);
+        this.curr = new OV.Coord2D (0.0, 0,0);
+        this.diff = new OV.Coord2D (0.0, 0.0);
+        this.buttons = [];
+    }
 
-	Down (canvas, ev)
-	{
-		this.buttons.push (ev.which);
-		this.curr = this.GetCurrent (canvas, ev);
-		this.prev = this.curr.Clone ();
-	}
+    Down (canvas, ev)
+    {
+        this.buttons.push (ev.which);
+        this.curr = this.GetCurrent (canvas, ev);
+        this.prev = this.curr.Clone ();
+    }
 
-	Move (canvas, ev)
-	{
-		this.curr = this.GetCurrent (canvas, ev);
+    Move (canvas, ev)
+    {
+        this.curr = this.GetCurrent (canvas, ev);
 		this.diff = OV.SubCoord2D (this.curr, this.prev);
 		this.prev = this.curr.Clone ();
 	}
@@ -390,7 +390,7 @@ OV.Navigation = class
 		if (mouseButton === 1) {
 			let orbitRatio = 0.5;
 			this.Orbit (moveDiff.x * orbitRatio, moveDiff.y * orbitRatio);
-		} else if (mouseButton === 3) {
+		} else if (mouseButton === 2 || mouseButton === 3) {
 			let eyeCenterDistance = OV.CoordDistance3D (this.camera.eye, this.camera.center);
 			let panRatio = 0.001 * eyeCenterDistance;
 			this.Pan (moveDiff.x * panRatio, moveDiff.y * panRatio);

source/viewer/urlutils.js

@@ -0,0 +1,134 @@
+OV.UrlParamConverter =
+{
+    CameraToUrlParameter : function (camera)
+    {
+        if (camera === null) {
+            return null;
+        }
+        let precision = 5;
+        let cameraParameters = [
+            camera.eye.x.toPrecision (precision), camera.eye.y.toPrecision (precision), camera.eye.z.toPrecision (precision),
+            camera.center.x.toPrecision (precision), camera.center.y.toPrecision (precision), camera.center.z.toPrecision (precision),
+            camera.up.x.toPrecision (precision), camera.up.y.toPrecision (precision), camera.up.z.toPrecision (precision)
+        ].join (',');
+        return cameraParameters;
+    },
+
+    UrlParameterToCamera : function (urlParam)
+    {
+        if (urlParam === null || urlParam.length === 0) {
+            return null;
+        }
+        let paramParts = urlParam.split (',');
+        if (paramParts.length !== 9) {
+            return null;
+        }
+        let camera = new OV.Camera (
+            new OV.Coord3D (parseFloat (paramParts[0]), parseFloat (paramParts[1]), parseFloat (paramParts[2])),
+            new OV.Coord3D (parseFloat (paramParts[3]), parseFloat (paramParts[4]), parseFloat (paramParts[5])),
+            new OV.Coord3D (parseFloat (paramParts[6]), parseFloat (paramParts[7]), parseFloat (paramParts[8]))
+        );
+        return camera;
+    },
+
+    ModelUrlsToUrlParameter : function (urls)
+    {
+        if (urls === null) {
+            return null;
+        }
+        return urls.join (',');
+    },
+
+    UrlParameterToModelUrls : function (urlParam)
+    {
+        if (urlParam === null || urlParam.length === 0) {
+            return null;
+        }
+        return urlParam.split (',');
+    }
+};
+
+OV.UrlParamBuilder = class
+{
+    constructor ()
+    {
+        this.urlParams = '';
+    }
+
+    AddModelUrls (urls)
+    {
+        this.AddUrlPart ('model', OV.UrlParamConverter.ModelUrlsToUrlParameter (urls));
+        return this;
+    }
+
+    AddCamera (camera)
+    {
+        this.AddUrlPart ('camera', OV.UrlParamConverter.CameraToUrlParameter (camera));
+        return this;
+    }
+
+    AddUrlPart (keyword, urlPart)
+    {
+        if (keyword === null || urlPart === null) {
+            return;
+        }
+        if (this.urlParams.length > 0) {
+            this.urlParams += '$';
+        }
+        this.urlParams += keyword + '=' + urlPart;
+    }
+
+    GetUrlParams ()
+    {
+        return this.urlParams;
+    } 
+};
+
+OV.UrlParamParser = class
+{
+    constructor (urlParams)
+    {
+        this.urlParams = urlParams;
+    }
+
+    GetModelUrls ()
+    {
+        // detect legacy links
+        if (this.urlParams.indexOf ('=') === -1) {
+            return this.urlParams.split (',');
+        }
+
+        let keywordParams = this.GetKeywordParams ('model');
+        return OV.UrlParamConverter.UrlParameterToModelUrls (keywordParams);
+    }
+
+    GetCamera ()
+    {
+        let keywordParams = this.GetKeywordParams ('camera');
+        return OV.UrlParamConverter.UrlParameterToCamera (keywordParams);
+    }
+    
+    GetKeywordParams (keyword)
+    {
+        if (this.urlParams === null || this.urlParams.length === 0) {
+            return null;
+        }
+        let keywordToken = keyword + '=';
+        let urlParts = this.urlParams.split ('$');
+        for (let i = 0; i < urlParts.length; i++) {
+            let urlPart = urlParts[i];
+            if (urlPart.startsWith (keywordToken)) {
+                return urlPart.substr (keywordToken.length);
+            }
+        }
+        return null;
+    }
+};
+
+OV.CreateUrlParameters = function (urls, camera)
+{
+    let builder = new OV.UrlParamBuilder ();
+    builder.AddModelUrls (urls);
+    builder.AddCamera (camera);
+    return builder.GetUrlParams ();
+};

source/viewer/viewer.js

@@ -1,375 +1,399 @@
 OV.GetDefaultCamera = function (direction)
 {
-	if (direction === OV.Direction.X) {
-		return new OV.Camera (
-			new OV.Coord3D (2.0, -3.0, 1.5),
-			new OV.Coord3D (0.0, 0.0, 0.0),
-			new OV.Coord3D (1.0, 0.0, 0.0)
-		);	
-	} else if (direction === OV.Direction.Y) {
-		return new OV.Camera (
-			new OV.Coord3D (-1.5, 2.0, 3.0),
-			new OV.Coord3D (0.0, 0.0, 0.0),
-			new OV.Coord3D (0.0, 1.0, 0.0)
-		);	
-	} else if (direction === OV.Direction.Z) {
-		return new OV.Camera (
-			new OV.Coord3D (-1.5, -3.0, 2.0),
-			new OV.Coord3D (0.0, 0.0, 0.0),
-			new OV.Coord3D (0.0, 0.0, 1.0)
-		);
-	}
-	return null;
+    if (direction === OV.Direction.X) {
+        return new OV.Camera (
+            new OV.Coord3D (2.0, -3.0, 1.5),
+            new OV.Coord3D (0.0, 0.0, 0.0),
+            new OV.Coord3D (1.0, 0.0, 0.0)
+        );    
+    } else if (direction === OV.Direction.Y) {
+        return new OV.Camera (
+            new OV.Coord3D (-1.5, 2.0, 3.0),
+            new OV.Coord3D (0.0, 0.0, 0.0),
+            new OV.Coord3D (0.0, 1.0, 0.0)
+        );    
+    } else if (direction === OV.Direction.Z) {
+        return new OV.Camera (
+            new OV.Coord3D (-1.5, -3.0, 2.0),
+            new OV.Coord3D (0.0, 0.0, 0.0),
+            new OV.Coord3D (0.0, 0.0, 1.0)
+        );
+    }
+    return null;
 };
 
 OV.UpVector = class
 {
-	constructor ()
-	{
-		this.direction = OV.Direction.Z;
-		this.isFixed = true;
-		this.isFlipped = false;
-	}
+    constructor ()
+    {
+        this.direction = OV.Direction.Z;
+        this.isFixed = true;
+        this.isFlipped = false;
+    }
 
-	SetDirection (newDirection, oldCamera)
-	{
-		this.direction = newDirection;
-		this.isFlipped = false;
+    SetDirection (newDirection, oldCamera)
+    {
+        this.direction = newDirection;
+        this.isFlipped = false;
 
-		let defaultCamera = OV.GetDefaultCamera (this.direction);
-		let defaultDir = OV.SubCoord3D (defaultCamera.eye, defaultCamera.center);
+        let defaultCamera = OV.GetDefaultCamera (this.direction);
+        let defaultDir = OV.SubCoord3D (defaultCamera.eye, defaultCamera.center);
 
-		let distance = OV.CoordDistance3D (oldCamera.center, oldCamera.eye);
-		let newEye = oldCamera.center.Clone ().Offset (defaultDir, distance);
+        let distance = OV.CoordDistance3D (oldCamera.center, oldCamera.eye);
+        let newEye = oldCamera.center.Clone ().Offset (defaultDir, distance);
 
-		let newCamera = oldCamera.Clone ();
-		if (this.direction === OV.Direction.Y) {
-			newCamera.up = new OV.Coord3D (0.0, 1.0, 0.0);
-			newCamera.eye = newEye;
-		} else if (this.direction === OV.Direction.Z) {
-			newCamera.up = new OV.Coord3D (0.0, 0.0, 1.0);
-			newCamera.eye = newEye;
-		}
-		return newCamera;
-	}
+        let newCamera = oldCamera.Clone ();
+        if (this.direction === OV.Direction.Y) {
+            newCamera.up = new OV.Coord3D (0.0, 1.0, 0.0);
+            newCamera.eye = newEye;
+        } else if (this.direction === OV.Direction.Z) {
+            newCamera.up = new OV.Coord3D (0.0, 0.0, 1.0);
+            newCamera.eye = newEye;
+        }
+        return newCamera;
+    }
 
-	SetFixed (isFixed, oldCamera)
-	{
-		this.isFixed = isFixed;
-		if (this.isFixed) {
-			return this.SetDirection (this.direction, oldCamera);
-		}
-		return null;
-	}
+    SetFixed (isFixed, oldCamera)
+    {
+        this.isFixed = isFixed;
+        if (this.isFixed) {
+            return this.SetDirection (this.direction, oldCamera);
+        }
+        return null;
+    }
 
-	Flip (oldCamera)
-	{
-		this.isFlipped = !this.isFlipped;
-		let newCamera = oldCamera.Clone ();
-		newCamera.up.MultiplyScalar (-1.0);
-		return newCamera;
-	}
+    Flip (oldCamera)
+    {
+        this.isFlipped = !this.isFlipped;
+        let newCamera = oldCamera.Clone ();
+        newCamera.up.MultiplyScalar (-1.0);
+        return newCamera;
+    }
 };
 
 OV.Viewer = class
 {
-	constructor ()
-	{
-		this.canvas = null;
-		this.renderer = null;
-		this.scene = null;
-		this.camera = null;
-		this.light = null;
-		this.navigation = null;
-		this.upVector = null;
-		this.settings = {
-			animationSteps : 40
-		};
-	}
-	
-	Init (canvas)
-	{
-		this.canvas = canvas;
-		this.canvas.id = 'viewer';
-		this.canvas.addEventListener ('contenxtmenu', function (ev) {
-			ev.preventDefault ();
-		});
+    constructor ()
+    {
+        this.canvas = null;
+        this.renderer = null;
+        this.scene = null;
+        this.camera = null;
+        this.light = null;
+        this.navigation = null;
+        this.upVector = null;
+        this.settings = {
+            animationSteps : 40
+        };
+    }
+    
+    Init (canvas)
+    {
+        this.canvas = canvas;
+        this.canvas.id = 'viewer';
+        this.canvas.addEventListener ('contenxtmenu', function (ev) {
+            ev.preventDefault ();
+        });
 
-		let parameters = {
-			canvas : this.canvas,
-			antialias : true
-		};
-		
-		this.renderer = new THREE.WebGLRenderer (parameters);
-		this.renderer.setClearColor ('#ffffff', 1);
-		this.renderer.setSize (this.canvas.width, this.canvas.height);
-		
-		this.scene = new THREE.Scene ();
+        let parameters = {
+            canvas : this.canvas,
+            antialias : true
+        };
+        
+        this.renderer = new THREE.WebGLRenderer (parameters);
+        this.renderer.setClearColor ('#ffffff', 1.0);
+        this.renderer.setSize (this.canvas.width, this.canvas.height);
+        
+        this.scene = new THREE.Scene ();
 
-		this.InitCamera ();
-		this.InitLights ();
+        this.InitCamera ();
+        this.InitLights ();
 
-		this.Render ();
-	}
+        this.Render ();
+    }
 
-	SetClickHandler (onClick)
-	{
-		this.navigation.SetClickHandler (onClick);
-	}
+    SetClickHandler (onClick)
+    {
+        this.navigation.SetClickHandler (onClick);
+    }
 
-	GetCamera ()
-	{
-		return this.navigation.GetCamera ();
-	}
-	
-	SetCamera (camera)
-	{
-		this.navigation.SetCamera (camera);
-		this.Render ();
-	}
+    GetCamera ()
+    {
+        return this.navigation.GetCamera ();
+    }
+    
+    SetCamera (camera)
+    {
+        this.navigation.SetCamera (camera);
+        this.Render ();
+    }
 
-	Resize (width, height)
-	{
-		let innerSize = OV.GetInnerDimensions (this.canvas, width, height);
-		this.camera.aspect = innerSize.width / innerSize.height;
-		this.camera.updateProjectionMatrix ();
-		this.renderer.setSize (innerSize.width, innerSize.height);	
-		this.Render ();
-	}
+    Resize (width, height)
+    {
+        let innerSize = OV.GetInnerDimensions (this.canvas, width, height);
+        this.ResizeRenderer (innerSize.width, innerSize.height);
+    }
 
-	FitToWindow (boundingSphere, animation)
-	{
-		if (boundingSphere === null) {
-			return;
-		}
-		let center = new OV.Coord3D (boundingSphere.center.x, boundingSphere.center.y, boundingSphere.center.z);
-		let radius = boundingSphere.radius;
-		let fov = this.camera.fov;
-		if (animation) {
-			let newCamera = this.navigation.GetFitToSphereCamera (center, radius, fov);
-			this.navigation.MoveCamera (newCamera, this.settings.animationSteps);
-		} else {
-			this.navigation.FitToSphere (center, radius, fov);
-		}
-	}
+    ResizeRenderer (width, height)
+    {
+        this.camera.aspect = width / height;
+        this.camera.updateProjectionMatrix ();
+        this.renderer.setSize (width, height);    
+        this.Render ();
+    }
 
-	AdjustClippingPlanes (boundingSphere)
-	{
-		if (boundingSphere === null) {
-			return;
-		}		
-		if (boundingSphere.radius < 10.0) {
-			this.camera.near = 0.01;
-			this.camera.far = 100.0;
-		} else if (boundingSphere.radius < 100.0) {
-			this.camera.near = 0.1;
-			this.camera.far = 1000.0;
-		} else if (boundingSphere.radius < 1000.0) {
-			this.camera.near = 10.0;
-			this.camera.far = 10000.0;			
-		} else {
-			this.camera.near = 100.0;
-			this.camera.far = 1000000.0;
-		}
-		this.camera.updateProjectionMatrix ();
-		this.Render ();
-	}
+    FitToWindow (boundingSphere, animation)
+    {
+        if (boundingSphere === null) {
+            return;
+        }
+        let center = new OV.Coord3D (boundingSphere.center.x, boundingSphere.center.y, boundingSphere.center.z);
+        let radius = boundingSphere.radius;
+        let fov = this.camera.fov;
+        if (animation) {
+            let newCamera = this.navigation.GetFitToSphereCamera (center, radius, fov);
+            this.navigation.MoveCamera (newCamera, this.settings.animationSteps);
+        } else {
+            this.navigation.FitToSphere (center, radius, fov);
+        }
+    }
 
-	IsFixUpVector ()
-	{
-		return this.navigation.IsFixUpVector ();
-	}	
+    AdjustClippingPlanes (boundingSphere)
+    {
+        if (boundingSphere === null) {
+            return;
+        }        
+        if (boundingSphere.radius < 10.0) {
+            this.camera.near = 0.01;
+            this.camera.far = 100.0;
+        } else if (boundingSphere.radius < 100.0) {
+            this.camera.near = 0.1;
+            this.camera.far = 1000.0;
+        } else if (boundingSphere.radius < 1000.0) {
+            this.camera.near = 10.0;
+            this.camera.far = 10000.0;            
+        } else {
+            this.camera.near = 100.0;
+            this.camera.far = 1000000.0;
+        }
+        this.camera.updateProjectionMatrix ();
+        this.Render ();
+    }
 
-	SetFixUpVector (fixUpVector)
-	{
-		let oldCamera = this.navigation.GetCamera ();
-		let newCamera = this.upVector.SetFixed (fixUpVector, oldCamera);
-		this.navigation.SetFixUpVector (fixUpVector);
-		if (newCamera !== null) {
-			this.navigation.MoveCamera (newCamera, this.settings.animationSteps);
-		}
-		this.Render ();
-	}
+    IsFixUpVector ()
+    {
+        return this.navigation.IsFixUpVector ();
+    }    
 
-	SetUpVector (upDirection, animate)
-	{
-		let oldCamera = this.navigation.GetCamera ();
-		let newCamera = this.upVector.SetDirection (upDirection, oldCamera);
-		let animationSteps = animate ? this.settings.animationSteps : 0;
-		this.navigation.MoveCamera (newCamera, animationSteps);
-		this.Render ();
-	}
+    SetFixUpVector (fixUpVector)
+    {
+        let oldCamera = this.navigation.GetCamera ();
+        let newCamera = this.upVector.SetFixed (fixUpVector, oldCamera);
+        this.navigation.SetFixUpVector (fixUpVector);
+        if (newCamera !== null) {
+            this.navigation.MoveCamera (newCamera, this.settings.animationSteps);
+        }
+        this.Render ();
+    }
 
-	FlipUpVector ()
-	{
-		let oldCamera = this.navigation.GetCamera ();
-		let newCamera = this.upVector.Flip (oldCamera);
-		this.navigation.MoveCamera (newCamera, 0);
-		this.Render ();
-	}
+    SetUpVector (upDirection, animate)
+    {
+        let oldCamera = this.navigation.GetCamera ();
+        let newCamera = this.upVector.SetDirection (upDirection, oldCamera);
+        let animationSteps = animate ? this.settings.animationSteps : 0;
+        this.navigation.MoveCamera (newCamera, animationSteps);
+        this.Render ();
+    }
 
-	Render ()
-	{
-		let navigationCamera = this.navigation.GetCamera ();
-		this.camera.position.set (navigationCamera.eye.x, navigationCamera.eye.y, navigationCamera.eye.z);
-		this.camera.up.set (navigationCamera.up.x, navigationCamera.up.y, navigationCamera.up.z);
-		this.camera.lookAt (new THREE.Vector3 (navigationCamera.center.x, navigationCamera.center.y, navigationCamera.center.z));
-	
-		let lightDir = OV.SubCoord3D (navigationCamera.eye, navigationCamera.center);
-		this.light.position.set (lightDir.x, lightDir.y, lightDir.z);	
-		this.renderer.render (this.scene, this.camera);
-	}
+    FlipUpVector ()
+    {
+        let oldCamera = this.navigation.GetCamera ();
+        let newCamera = this.upVector.Flip (oldCamera);
+        this.navigation.MoveCamera (newCamera, 0);
+        this.Render ();
+    }
 
-	AddMeshes (meshes)
-	{
-		for (let i = 0; i < meshes.length; i++) {
-			let mesh = meshes[i];
-			this.scene.add (mesh);
-		}
-		this.Render ();
-	}
+    Render ()
+    {
+        let navigationCamera = this.navigation.GetCamera ();
+        this.camera.position.set (navigationCamera.eye.x, navigationCamera.eye.y, navigationCamera.eye.z);
+        this.camera.up.set (navigationCamera.up.x, navigationCamera.up.y, navigationCamera.up.z);
+        this.camera.lookAt (new THREE.Vector3 (navigationCamera.center.x, navigationCamera.center.y, navigationCamera.center.z));
+    
+        let lightDir = OV.SubCoord3D (navigationCamera.eye, navigationCamera.center);
+        this.light.position.set (lightDir.x, lightDir.y, lightDir.z);    
+        this.renderer.render (this.scene, this.camera);
+    }
 
-	Clear ()
-	{
-		this.ClearMeshes ();
-		this.Render ();
-	}
+    AddMeshes (meshes)
+    {
+        for (let i = 0; i < meshes.length; i++) {
+            let mesh = meshes[i];
+            this.scene.add (mesh);
+        }
+        this.Render ();
+    }
 
-	SetMeshesVisibility (isVisible)
-	{
-		this.EnumerateMeshes (function (mesh) {
-			let visible = isVisible (mesh.userData);
-			if (mesh.visible !== visible) {
-				mesh.visible = visible;
-			}
-		});
-		this.Render ();
-	}
+    Clear ()
+    {
+        this.ClearMeshes ();
+        this.Render ();
+    }
 
-	SetMeshesHighlight (highlightMaterial, isHighlighted)
-	{
-		function CreateHighlightMaterials (originalMaterials, highlightMaterial)
-		{
-			let highlightMaterials = [];
-			for (let i = 0; i < originalMaterials.length; i++) {
-				highlightMaterials.push (highlightMaterial);
-			}
-			return highlightMaterials;
-		}
+    SetMeshesVisibility (isVisible)
+    {
+        this.EnumerateMeshes (function (mesh) {
+            let visible = isVisible (mesh.userData);
+            if (mesh.visible !== visible) {
+                mesh.visible = visible;
+            }
+        });
+        this.Render ();
+    }
 
-		this.EnumerateMeshes (function (mesh) {
-			let highlighted = isHighlighted (mesh.userData);
-			if (highlighted) {
-				if (mesh.userData.threeMaterials === null) {
-					mesh.userData.threeMaterials = mesh.material;
-					mesh.material = CreateHighlightMaterials (mesh.material, highlightMaterial);
-				}
-			} else {
-				if (mesh.userData.threeMaterials !== null) {
-					mesh.material = mesh.userData.threeMaterials;
-					mesh.userData.threeMaterials = null;
-				}
-			}
-		});
-		this.Render ();
-	}	
+    SetMeshesHighlight (highlightMaterial, isHighlighted)
+    {
+        function CreateHighlightMaterials (originalMaterials, highlightMaterial)
+        {
+            let highlightMaterials = [];
+            for (let i = 0; i < originalMaterials.length; i++) {
+                highlightMaterials.push (highlightMaterial);
+            }
+            return highlightMaterials;
+        }
 
-	GetMeshUnderMouse (mouseCoords)
-	{
-		let raycaster = new THREE.Raycaster ();
-		let mousePos = new THREE.Vector2 ();
-		mousePos.x = (mouseCoords.x / this.canvas.width) * 2 - 1;
-		mousePos.y = -(mouseCoords.y / this.canvas.height) * 2 + 1;
-		raycaster.setFromCamera (mousePos, this.camera);
-		let iSectObjects = raycaster.intersectObjects (this.scene.children);
-		for (let i = 0; i < iSectObjects.length; i++) {
-			let iSectObject = iSectObjects[i];
-			if (iSectObject.object.type === 'Mesh' && iSectObject.object.visible) {
-				return iSectObject.object.userData;
-			}
-		}
-		return null;
-	}
+        this.EnumerateMeshes (function (mesh) {
+            let highlighted = isHighlighted (mesh.userData);
+            if (highlighted) {
+                if (mesh.userData.threeMaterials === null) {
+                    mesh.userData.threeMaterials = mesh.material;
+                    mesh.material = CreateHighlightMaterials (mesh.material, highlightMaterial);
+                }
+            } else {
+                if (mesh.userData.threeMaterials !== null) {
+                    mesh.material = mesh.userData.threeMaterials;
+                    mesh.userData.threeMaterials = null;
+                }
+            }
+        });
+        this.Render ();
+    }    
 
-	GetBoundingBox (needToProcess)
-	{
-		let hasMesh = false;
-		let boundingBox = new THREE.Box3 ();
-		this.EnumerateMeshes (function (mesh) {
-			if (needToProcess (mesh.userData)) {
-				boundingBox.union (new THREE.Box3 ().setFromObject (mesh));
-				hasMesh = true;
-			}
-		});
+    GetMeshUnderMouse (mouseCoords)
+    {
+        let raycaster = new THREE.Raycaster ();
+        let mousePos = new THREE.Vector2 ();
+        mousePos.x = (mouseCoords.x / this.canvas.width) * 2 - 1;
+        mousePos.y = -(mouseCoords.y / this.canvas.height) * 2 + 1;
+        raycaster.setFromCamera (mousePos, this.camera);
+        let iSectObjects = raycaster.intersectObjects (this.scene.children);
+        for (let i = 0; i < iSectObjects.length; i++) {
+            let iSectObject = iSectObjects[i];
+            if (iSectObject.object.type === 'Mesh' && iSectObject.object.visible) {
+                return iSectObject.object.userData;
+            }
+        }
+        return null;
+    }
 
-		if (!hasMesh) {
-			return null;
-		}
-		return boundingBox;
-	}
+    GetBoundingBox (needToProcess)
+    {
+        let hasMesh = false;
+        let boundingBox = new THREE.Box3 ();
+        this.EnumerateMeshes (function (mesh) {
+            if (needToProcess (mesh.userData)) {
+                boundingBox.union (new THREE.Box3 ().setFromObject (mesh));
+                hasMesh = true;
+            }
+        });
 
-	GetBoundingSphere (needToProcess)
-	{
-		let boundingBox = this.GetBoundingBox (needToProcess);
-		if (boundingBox === null) {
-			return null;
-		}
+        if (!hasMesh) {
+            return null;
+        }
+        return boundingBox;
+    }
 
-		let boundingSphere = new THREE.Sphere ();
-		boundingBox.getBoundingSphere (boundingSphere);
-		return boundingSphere;
-	}
+    GetBoundingSphere (needToProcess)
+    {
+        let boundingBox = this.GetBoundingBox (needToProcess);
+        if (boundingBox === null) {
+            return null;
+        }
 
-	EnumerateMeshesUserData (enumerator)
-	{
-		this.EnumerateMeshes (function (mesh) {
-			enumerator (mesh.userData);
-		});
-	}
+        let boundingSphere = new THREE.Sphere ();
+        boundingBox.getBoundingSphere (boundingSphere);
+        return boundingSphere;
+    }
 
-	EnumerateMeshes (enumerator)
-	{
-		this.scene.traverse (function (object) {
-			if (object.isMesh) {
-				enumerator (object);
-			}
-		});
-	}
+    EnumerateMeshesUserData (enumerator)
+    {
+        this.EnumerateMeshes (function (mesh) {
+            enumerator (mesh.userData);
+        });
+    }
 
-	ClearMeshes ()
-	{
-		for (let i = this.scene.children.length - 1; i >= 0; i--) {
-			let object = this.scene.children[i];
-			if (object.isMesh) {
-				object.geometry.dispose ();
-				this.scene.remove (object);
-			}
-		}
-	}
+    EnumerateMeshes (enumerator)
+    {
+        this.scene.traverse (function (object) {
+            if (object.isMesh) {
+                enumerator (object);
+            }
+        });
+    }
 
-	InitCamera ()
-	{
-		this.camera = new THREE.PerspectiveCamera (45.0, this.canvas.width / this.canvas.height, 0.1, 1000.0);
-		this.scene.add (this.camera);
+    ClearMeshes ()
+    {
+        for (let i = this.scene.children.length - 1; i >= 0; i--) {
+            let object = this.scene.children[i];
+            if (object.isMesh) {
+                object.geometry.dispose ();
+                this.scene.remove (object);
+            }
+        }
+    }
 
-		let canvasElem = this.renderer.domElement;
-		let camera = OV.GetDefaultCamera (OV.Direction.Z);
+    InitCamera ()
+    {
+        this.camera = new THREE.PerspectiveCamera (45.0, this.canvas.width / this.canvas.height, 0.1, 1000.0);
+        this.scene.add (this.camera);
 
-		let obj = this;
-		this.navigation = new OV.Navigation (canvasElem, camera);
-		this.navigation.SetUpdateHandler (function () {
-			obj.Render ();
-		});
+        let canvasElem = this.renderer.domElement;
+        let camera = OV.GetDefaultCamera (OV.Direction.Z);
 
-		this.upVector = new OV.UpVector ();
-	}
+        let obj = this;
+        this.navigation = new OV.Navigation (canvasElem, camera);
+        this.navigation.SetUpdateHandler (function () {
+            obj.Render ();
+        });
 
-	InitLights  ()
-	{
-		let ambientLight = new THREE.AmbientLight (0x888888);
-		this.scene.add (ambientLight);
-	
-		this.light = new THREE.DirectionalLight (0x888888);
-		this.scene.add (this.light);
-	}
+        this.upVector = new OV.UpVector ();
+    }
+
+    InitLights  ()
+    {
+        let ambientLight = new THREE.AmbientLight (0x888888);
+        this.scene.add (ambientLight);
+    
+        this.light = new THREE.DirectionalLight (0x888888);
+        this.scene.add (this.light);
+    }
+
+    GetImageAsDataUrl (width, height)
+    {
+        let originalSize = null;
+        if (width && height) {
+            originalSize = new THREE.Vector2 ();
+            this.renderer.getSize (originalSize);
+            this.ResizeRenderer (width, height);
+        }
+        this.Render ();
+        let url = this.renderer.domElement.toDataURL();
+        if (originalSize !== null) {
+            this.ResizeRenderer (
+                parseInt (originalSize.x, 10),
+                parseInt (originalSize.y, 10)
+            );
+        }
+        return url;
+    }
 };

test/framework/native_import.js

@@ -1,14 +0,0 @@
-module.exports =
-{
-	AddNativeSourceFile : function (fileName)
-	{
-		var path = require ('path');
-		var rootDir = path.join (__dirname, '..');
-		var fullPath = path.resolve (rootDir, fileName);
-
-		var fs = require ('fs');
-		var content = fs.readFileSync (fullPath).toString ();
-
-		eval.apply (global, [content]);
-	}
-}

test/test.js

@@ -7,8 +7,8 @@ var testDirName = './tests/';
 var files = fs.readdirSync (testDirName, { withFileTypes: true });
 var i, file;
 for (i = 0; i < files.length; i++) {
-	file = files[i];
-	if (file.isFile ()) {
-		require (testDirName + file.name);
-	}
+    file = files[i];
+    if (file.isFile ()) {
+        require (testDirName + file.name);
+    }
 }

test/tests/exporter_test.js

@@ -178,7 +178,7 @@ describe ('Exporter', function () {
             'endsolid Model',
             ''
         ].join ('\n'));
-	});
+    });
 
     it ('Stl Binary Export', function () {
         let model = CreateTestModel ();
@@ -201,7 +201,7 @@ describe ('Exporter', function () {
         let importedModel = importer.GetModel ();
         assert.strictEqual (importedModel.VertexCount (), 12);
         assert.strictEqual (importedModel.TriangleCount (), 4);
-	});
+    });
 
     it ('Off Export', function () {
         let model = CreateTestModel ();
@@ -319,6 +319,9 @@ describe ('Exporter', function () {
                     return binFile.GetContent ();
                 }
                 return null;
+            },
+            getTextureBuffer (filePath) {
+                return null;
             }
         });
   
@@ -350,6 +353,9 @@ describe ('Exporter', function () {
         },
         getFileBuffer (filePath) {
             return null;
+        },
+        getTextureBuffer (filePath) {
+            return null;
         }
     });
 

test/tests/fileutils_test.js

@@ -2,40 +2,40 @@ var assert = require ('assert');
 
 function GetLines (str)
 {
-	var lines = [];
-	OV.ReadLines (str, function (line) {
-		lines.push (line);
-	});
-	return lines;
+    var lines = [];
+    OV.ReadLines (str, function (line) {
+        lines.push (line);
+    });
+    return lines;
 }
 
 describe ('File Utils', function () {
-	it ('Get File Extension', function () {
-		assert.strictEqual (OV.GetFileExtension ('file'), '');
-		assert.strictEqual (OV.GetFileExtension ('file.obj'), 'obj');
-		assert.strictEqual (OV.GetFileExtension ('file.OBJ'), 'OBJ');
-	});	
-	
-	it ('Get File Name', function () {
-		assert.strictEqual (OV.GetFileName ('file'), 'file');
-		assert.strictEqual (OV.GetFileName ('file.obj'), 'file.obj');
-		assert.strictEqual (OV.GetFileName ('file.OBJ'), 'file.OBJ');
-		assert.strictEqual (OV.GetFileName ('folder/file'), 'file');
-		assert.strictEqual (OV.GetFileName ('folder/file.obj'), 'file.obj');
-		assert.strictEqual (OV.GetFileName ('folder/file.OBJ'), 'file.OBJ');
-		assert.strictEqual (OV.GetFileName ('folder\\file'), 'file');
-		assert.strictEqual (OV.GetFileName ('folder\\file.obj'), 'file.obj');
-		assert.strictEqual (OV.GetFileName ('folder\\file.OBJ'), 'file.OBJ');
-	});	
+    it ('Get File Extension', function () {
+        assert.strictEqual (OV.GetFileExtension ('file'), '');
+        assert.strictEqual (OV.GetFileExtension ('file.obj'), 'obj');
+        assert.strictEqual (OV.GetFileExtension ('file.OBJ'), 'OBJ');
+    });    
+    
+    it ('Get File Name', function () {
+        assert.strictEqual (OV.GetFileName ('file'), 'file');
+        assert.strictEqual (OV.GetFileName ('file.obj'), 'file.obj');
+        assert.strictEqual (OV.GetFileName ('file.OBJ'), 'file.OBJ');
+        assert.strictEqual (OV.GetFileName ('folder/file'), 'file');
+        assert.strictEqual (OV.GetFileName ('folder/file.obj'), 'file.obj');
+        assert.strictEqual (OV.GetFileName ('folder/file.OBJ'), 'file.OBJ');
+        assert.strictEqual (OV.GetFileName ('folder\\file'), 'file');
+        assert.strictEqual (OV.GetFileName ('folder\\file.obj'), 'file.obj');
+        assert.strictEqual (OV.GetFileName ('folder\\file.OBJ'), 'file.OBJ');
+    });    
 
-	it ('Read Lines', function () {
-		assert.deepStrictEqual (GetLines (''), []);
-		assert.deepStrictEqual (GetLines ('\n'), []);
-		assert.deepStrictEqual (GetLines ('\r\n'), []);
-		assert.deepStrictEqual (GetLines ('a\nb'), ['a', 'b']);
-		assert.deepStrictEqual (GetLines ('apple\nbanana'), ['apple', 'banana']);
-		assert.deepStrictEqual (GetLines ('apple\r\nbanana'), ['apple', 'banana']);
-		assert.deepStrictEqual (GetLines ('apple\r\n'), ['apple']);
-		assert.deepStrictEqual (GetLines ('\r\napple\r\n'), ['apple']);
-	});
+    it ('Read Lines', function () {
+        assert.deepStrictEqual (GetLines (''), []);
+        assert.deepStrictEqual (GetLines ('\n'), []);
+        assert.deepStrictEqual (GetLines ('\r\n'), []);
+        assert.deepStrictEqual (GetLines ('a\nb'), ['a', 'b']);
+        assert.deepStrictEqual (GetLines ('apple\nbanana'), ['apple', 'banana']);
+        assert.deepStrictEqual (GetLines ('apple\r\nbanana'), ['apple', 'banana']);
+        assert.deepStrictEqual (GetLines ('apple\r\n'), ['apple']);
+        assert.deepStrictEqual (GetLines ('\r\napple\r\n'), ['apple']);
+    });
 });

test/tests/geometry_test.js

@@ -2,145 +2,145 @@ var assert = require ('assert');
 
 function CreateYRot90Quaternion ()
 {
-	let angle = Math.PI / 2.0;
-	let rotX = 0.0;
-	let rotY = 1.0;
-	let rotZ = 0.0;
-	let quaternion = [
-		Math.sin (angle / 2.0) * rotX,
-		Math.sin (angle / 2.0) * rotY,
-		Math.sin (angle / 2.0) * rotZ,
-		Math.cos (angle / 2.0)
-	];
-	return quaternion;
+    let angle = Math.PI / 2.0;
+    let rotX = 0.0;
+    let rotY = 1.0;
+    let rotZ = 0.0;
+    let quaternion = [
+        Math.sin (angle / 2.0) * rotX,
+        Math.sin (angle / 2.0) * rotY,
+        Math.sin (angle / 2.0) * rotZ,
+        Math.cos (angle / 2.0)
+    ];
+    return quaternion;
 }
 
 describe ('Coord', function () {
-	it ('Length', function () {
-		var c = new OV.Coord3D (2.0, 0.0, 0.0);
-		assert.strictEqual (c.Length (), 2.0);
-	});
-	
-	it ('Multiply Scalar', function () {
-		var c = new OV.Coord3D (2.0, 0.0, 0.0);
-		c.MultiplyScalar (3.0);
-		assert.strictEqual (c.x, 6.0);
-		assert.strictEqual (c.y, 0.0);
-		assert.strictEqual (c.z, 0.0);
-	});		
-	
-	it ('Normalize', function () {
-		var c = new OV.Coord3D (2.0, 0.0, 0.0);
-		c.Normalize ();
-		assert.strictEqual (c.x, 1.0);
-		assert.strictEqual (c.y, 0.0);
-		assert.strictEqual (c.z, 0.0);
-	});	
+    it ('Length', function () {
+        var c = new OV.Coord3D (2.0, 0.0, 0.0);
+        assert.strictEqual (c.Length (), 2.0);
+    });
+    
+    it ('Multiply Scalar', function () {
+        var c = new OV.Coord3D (2.0, 0.0, 0.0);
+        c.MultiplyScalar (3.0);
+        assert.strictEqual (c.x, 6.0);
+        assert.strictEqual (c.y, 0.0);
+        assert.strictEqual (c.z, 0.0);
+    });        
+    
+    it ('Normalize', function () {
+        var c = new OV.Coord3D (2.0, 0.0, 0.0);
+        c.Normalize ();
+        assert.strictEqual (c.x, 1.0);
+        assert.strictEqual (c.y, 0.0);
+        assert.strictEqual (c.z, 0.0);
+    });    
 });
 
 describe ('Triangle', function() {
-	it ('Calculate Normal', function () {
-		var normal = OV.CalculateTriangleNormal (
-			new OV.Coord3D (0.0, 0.0, 0.0),
-			new OV.Coord3D (1.0, 0.0, 0.0),
-			new OV.Coord3D (1.0, 1.0, 0.0)
-		);
-		assert.strictEqual (normal.x, 0.0);
-		assert.strictEqual (normal.y, 0.0);
-		assert.strictEqual (normal.z, 1.0);
-	});
+    it ('Calculate Normal', function () {
+        var normal = OV.CalculateTriangleNormal (
+            new OV.Coord3D (0.0, 0.0, 0.0),
+            new OV.Coord3D (1.0, 0.0, 0.0),
+            new OV.Coord3D (1.0, 1.0, 0.0)
+        );
+        assert.strictEqual (normal.x, 0.0);
+        assert.strictEqual (normal.y, 0.0);
+        assert.strictEqual (normal.z, 1.0);
+    });
 });
 
 describe ('Transformation', function() {
-	it ('Basic Test', function () {
-		let rotation = CreateYRot90Quaternion ();
+    it ('Basic Test', function () {
+        let rotation = CreateYRot90Quaternion ();
 
-		let coord = new OV.Coord3D (1.0, 2.0, 3.0);
+        let coord = new OV.Coord3D (1.0, 2.0, 3.0);
 
-		let tr = new OV.Transformation ();
-		assert (tr.IsIdentity ());
-		assert (OV.CoordIsEqual3D (tr.TransformCoord3D (coord), new OV.Coord3D (1.0, 2.0, 3.0)));
+        let tr = new OV.Transformation ();
+        assert (tr.IsIdentity ());
+        assert (OV.CoordIsEqual3D (tr.TransformCoord3D (coord), new OV.Coord3D (1.0, 2.0, 3.0)));
 
-		tr.AppendMatrix (new OV.Matrix ().CreateScale (3.0, 4.0, 5.0));
-		assert (!tr.IsIdentity ());
-		assert (OV.CoordIsEqual3D (tr.TransformCoord3D (coord), new OV.Coord3D (3.0, 8.0, 15.0)));
+        tr.AppendMatrix (new OV.Matrix ().CreateScale (3.0, 4.0, 5.0));
+        assert (!tr.IsIdentity ());
+        assert (OV.CoordIsEqual3D (tr.TransformCoord3D (coord), new OV.Coord3D (3.0, 8.0, 15.0)));
 
-		tr.AppendMatrix (new OV.Matrix ().CreateRotation (rotation[0], rotation[1], rotation[2], rotation[3]));
-		assert (!tr.IsIdentity ());
-		assert (OV.CoordIsEqual3D (tr.TransformCoord3D (coord), new OV.Coord3D (15.0, 8.0, -3.0)));
-		
-		tr.AppendMatrix (new OV.Matrix ().CreateTranslation (4.0, 5.0, 6.0));
-		assert (!tr.IsIdentity ());
-		assert (OV.CoordIsEqual3D (tr.TransformCoord3D (coord), new OV.Coord3D (19.0, 13.0, 3.0)));
+        tr.AppendMatrix (new OV.Matrix ().CreateRotation (rotation[0], rotation[1], rotation[2], rotation[3]));
+        assert (!tr.IsIdentity ());
+        assert (OV.CoordIsEqual3D (tr.TransformCoord3D (coord), new OV.Coord3D (15.0, 8.0, -3.0)));
+        
+        tr.AppendMatrix (new OV.Matrix ().CreateTranslation (4.0, 5.0, 6.0));
+        assert (!tr.IsIdentity ());
+        assert (OV.CoordIsEqual3D (tr.TransformCoord3D (coord), new OV.Coord3D (19.0, 13.0, 3.0)));
 
-		let tr2 = new OV.Transformation ();
-		tr2.SetMatrix (new OV.Matrix ().ComposeTRS ([4.0, 5.0, 6.0], rotation, [3.0, 4.0, 5.0]));
-		assert (OV.CoordIsEqual3D (tr2.TransformCoord3D (coord), new OV.Coord3D (19.0, 13.0, 3.0)));
-	});
+        let tr2 = new OV.Transformation ();
+        tr2.SetMatrix (new OV.Matrix ().ComposeTRS ([4.0, 5.0, 6.0], rotation, [3.0, 4.0, 5.0]));
+        assert (OV.CoordIsEqual3D (tr2.TransformCoord3D (coord), new OV.Coord3D (19.0, 13.0, 3.0)));
+    });
 
-	it ('TRS Compose Test', function () {
-		let rotation = CreateYRot90Quaternion ();
-		let coord = new OV.Coord3D (1.0, 2.0, 3.0);
+    it ('TRS Compose Test', function () {
+        let rotation = CreateYRot90Quaternion ();
+        let coord = new OV.Coord3D (1.0, 2.0, 3.0);
 
-		let tr = new OV.Transformation ();
-		tr.SetMatrix (new OV.Matrix ().ComposeTRS ([4.0, 5.0, 6.0], rotation, [3.0, 4.0, 5.0]));
-		assert (OV.CoordIsEqual3D (tr.TransformCoord3D (coord), new OV.Coord3D (19.0, 13.0, 3.0)));
-	});	
+        let tr = new OV.Transformation ();
+        tr.SetMatrix (new OV.Matrix ().ComposeTRS ([4.0, 5.0, 6.0], rotation, [3.0, 4.0, 5.0]));
+        assert (OV.CoordIsEqual3D (tr.TransformCoord3D (coord), new OV.Coord3D (19.0, 13.0, 3.0)));
+    });    
 
-	it ('TRS Compose Test', function () {
-		let rotation = CreateYRot90Quaternion ();
-		let coord = new OV.Coord3D (1.0, 2.0, 3.0);
+    it ('TRS Compose Test', function () {
+        let rotation = CreateYRot90Quaternion ();
+        let coord = new OV.Coord3D (1.0, 2.0, 3.0);
 
-		let tr = new OV.Transformation ();
-		tr.SetMatrix (new OV.Matrix ().ComposeTRS ([4.0, 5.0, 6.0], rotation, [3.0, 4.0, 5.0]));
-		assert (OV.CoordIsEqual3D (tr.TransformCoord3D (coord), new OV.Coord3D (19.0, 13.0, 3.0)));
+        let tr = new OV.Transformation ();
+        tr.SetMatrix (new OV.Matrix ().ComposeTRS ([4.0, 5.0, 6.0], rotation, [3.0, 4.0, 5.0]));
+        assert (OV.CoordIsEqual3D (tr.TransformCoord3D (coord), new OV.Coord3D (19.0, 13.0, 3.0)));
 
-		let trs = tr.GetMatrix ().DecomposeTRS ();
-		let tr2 = new OV.Transformation ();
-		tr2.SetMatrix (new OV.Matrix ().ComposeTRS (trs.translation, trs.rotation, trs.scale));
-		assert (OV.CoordIsEqual3D (tr2.TransformCoord3D (coord), new OV.Coord3D (19.0, 13.0, 3.0)));
-	});
+        let trs = tr.GetMatrix ().DecomposeTRS ();
+        let tr2 = new OV.Transformation ();
+        tr2.SetMatrix (new OV.Matrix ().ComposeTRS (trs.translation, trs.rotation, trs.scale));
+        assert (OV.CoordIsEqual3D (tr2.TransformCoord3D (coord), new OV.Coord3D (19.0, 13.0, 3.0)));
+    });
 
-	it ('Default Quaternion Test', function () {
-		let coord = new OV.Coord3D (1.0, 2.0, 3.0);
+    it ('Default Quaternion Test', function () {
+        let coord = new OV.Coord3D (1.0, 2.0, 3.0);
 
-		let tr = new OV.Transformation ();
-		tr.SetMatrix (new OV.Matrix ().CreateRotation (0.0, 0.0, 0.0, 1.0));
-		assert (OV.CoordIsEqual3D (tr.TransformCoord3D (coord), coord));
-	});		
+        let tr = new OV.Transformation ();
+        tr.SetMatrix (new OV.Matrix ().CreateRotation (0.0, 0.0, 0.0, 1.0));
+        assert (OV.CoordIsEqual3D (tr.TransformCoord3D (coord), coord));
+    });        
 });
 
 describe ('Tween', function() {
-	it ('Linear Tween Function', function () {
-		assert (OV.IsEqual (OV.LinearTweenFunction (10.0, 0, 10), 0.0));
-		assert (OV.IsEqual (OV.LinearTweenFunction (10.0, 1, 10), 1.0));
-		assert (OV.IsEqual (OV.LinearTweenFunction (10.0, 5, 10), 5.0));
-		assert (OV.IsEqual (OV.LinearTweenFunction (10.0, 9, 10), 9.0));
-		assert (OV.IsEqual (OV.LinearTweenFunction (10.0, 10, 10), 10.0));
-	});
+    it ('Linear Tween Function', function () {
+        assert (OV.IsEqual (OV.LinearTweenFunction (10.0, 0, 10), 0.0));
+        assert (OV.IsEqual (OV.LinearTweenFunction (10.0, 1, 10), 1.0));
+        assert (OV.IsEqual (OV.LinearTweenFunction (10.0, 5, 10), 5.0));
+        assert (OV.IsEqual (OV.LinearTweenFunction (10.0, 9, 10), 9.0));
+        assert (OV.IsEqual (OV.LinearTweenFunction (10.0, 10, 10), 10.0));
+    });
 
-	it ('Bezier Tween Function', function () {
-		assert (OV.IsEqual (OV.BezierTweenFunction (10.0, 0, 10), 0.0));
-		assert (OV.IsEqual (OV.BezierTweenFunction (10.0, 1, 10), 0.28));
-		assert (OV.IsEqual (OV.BezierTweenFunction (10.0, 5, 10), 5.0));
-		assert (OV.IsEqual (OV.BezierTweenFunction (10.0, 9, 10), 9.72));
-		assert (OV.IsEqual (OV.BezierTweenFunction (10.0, 10, 10), 10.0));
-	});
+    it ('Bezier Tween Function', function () {
+        assert (OV.IsEqual (OV.BezierTweenFunction (10.0, 0, 10), 0.0));
+        assert (OV.IsEqual (OV.BezierTweenFunction (10.0, 1, 10), 0.28));
+        assert (OV.IsEqual (OV.BezierTweenFunction (10.0, 5, 10), 5.0));
+        assert (OV.IsEqual (OV.BezierTweenFunction (10.0, 9, 10), 9.72));
+        assert (OV.IsEqual (OV.BezierTweenFunction (10.0, 10, 10), 10.0));
+    });
 
-	it ('Parabolic Tween Function', function () {
-		assert (OV.IsEqual (OV.ParabolicTweenFunction (10.0, 0, 10), 0.0));
-		assert (OV.IsEqual (OV.ParabolicTweenFunction (10.0, 5, 10), 5.0));
-		assert (OV.IsEqual (OV.ParabolicTweenFunction (10.0, 10, 10), 10.0));
-	});	
+    it ('Parabolic Tween Function', function () {
+        assert (OV.IsEqual (OV.ParabolicTweenFunction (10.0, 0, 10), 0.0));
+        assert (OV.IsEqual (OV.ParabolicTweenFunction (10.0, 5, 10), 5.0));
+        assert (OV.IsEqual (OV.ParabolicTweenFunction (10.0, 10, 10), 10.0));
+    });    
 
-	it ('Linear Tween Coordinates', function () {
-		let beg = new OV.Coord3D (0.0, 0.0, 0.0);
-		let end = new OV.Coord3D (9.0, 0.0, 0.0);
-		let segments = OV.TweenCoord3D (beg, end, 10, OV.LinearTweenFunction);
-		assert.strictEqual (segments.length, 10);
-		assert (OV.CoordIsEqual3D (segments[0], beg));
-		assert (OV.CoordIsEqual3D (segments[1], new OV.Coord3D (1.0, 0.0, 0.0)));
-		assert (OV.CoordIsEqual3D (segments[5], new OV.Coord3D (5.0, 0.0, 0.0)));
-		assert (OV.CoordIsEqual3D (segments[segments.length - 1], end));
-	});
+    it ('Linear Tween Coordinates', function () {
+        let beg = new OV.Coord3D (0.0, 0.0, 0.0);
+        let end = new OV.Coord3D (9.0, 0.0, 0.0);
+        let segments = OV.TweenCoord3D (beg, end, 10, OV.LinearTweenFunction);
+        assert.strictEqual (segments.length, 10);
+        assert (OV.CoordIsEqual3D (segments[0], beg));
+        assert (OV.CoordIsEqual3D (segments[1], new OV.Coord3D (1.0, 0.0, 0.0)));
+        assert (OV.CoordIsEqual3D (segments[5], new OV.Coord3D (5.0, 0.0, 0.0)));
+        assert (OV.CoordIsEqual3D (segments[segments.length - 1], end));
+    });
 });

test/tests/importer3ds_test.js

@@ -3,159 +3,159 @@ var testFiles = require ('../utils/testfiles.js');
 var testUtils = require ('../utils/testutils.js');
 
 describe ('3ds Importer', function() {
-	it ('cube_with_materials.obj', function () {
-		var model = testFiles.Import3dsFile ('cube_with_materials.3ds');
-		assert (OV.CheckModel (model));
-		assert.deepStrictEqual (testUtils.ModelToObjectSimple (model), {
-			name : '',
-			materials : [
-				{ name : 'tex' },
-				{ name : 'red' },
-				{ name : 'green' },
-				{ name : 'blue' },
-				{ name : 'white' }
-			],
-			meshes : [
-				{
-					name : 'cube',
-					vertexCount : 8,
-					normalCount : 12,
-					uvCount : 8,
-					triangleCount : 12,
-					boundingBox : {
-						min : [0, 0, 0],
-						max : [1, 1, 1]
-					}
-				}
-			]
-		});
-	});
+    it ('cube_with_materials.obj', function () {
+        var model = testFiles.Import3dsFile ('cube_with_materials.3ds');
+        assert (OV.CheckModel (model));
+        assert.deepStrictEqual (testUtils.ModelToObjectSimple (model), {
+            name : '',
+            materials : [
+                { name : 'tex' },
+                { name : 'red' },
+                { name : 'green' },
+                { name : 'blue' },
+                { name : 'white' }
+            ],
+            meshes : [
+                {
+                    name : 'cube',
+                    vertexCount : 8,
+                    normalCount : 12,
+                    uvCount : 8,
+                    triangleCount : 12,
+                    boundingBox : {
+                        min : [0, 0, 0],
+                        max : [1, 1, 1]
+                    }
+                }
+            ]
+        });
+    });
 
-	it ('cube_with_texture_transformations.3ds', function () {
-		var model = testFiles.Import3dsFile ('cube_with_texture_transformations.3ds');
-		assert (OV.CheckModel (model));
-		assert.deepStrictEqual (testUtils.ModelToObjectSimple (model), {
-			name : '',
-			materials : [
-				{ name : 'tex' },
-				{ name : 'red' },
-				{ name : 'green' },
-				{ name : 'blue' },
-				{ name : 'white' }
-			],
-			meshes : [
-				{
-					name : 'cube',
-					vertexCount : 8,
-					normalCount : 12,
-					uvCount : 8,
-					triangleCount : 12,
-					boundingBox : {
-						min : [0, 0, 0],
-						max : [1, 1, 1]
-					}
-				}
-			]
-		});
-	});
+    it ('cube_with_texture_transformations.3ds', function () {
+        var model = testFiles.Import3dsFile ('cube_with_texture_transformations.3ds');
+        assert (OV.CheckModel (model));
+        assert.deepStrictEqual (testUtils.ModelToObjectSimple (model), {
+            name : '',
+            materials : [
+                { name : 'tex' },
+                { name : 'red' },
+                { name : 'green' },
+                { name : 'blue' },
+                { name : 'white' }
+            ],
+            meshes : [
+                {
+                    name : 'cube',
+                    vertexCount : 8,
+                    normalCount : 12,
+                    uvCount : 8,
+                    triangleCount : 12,
+                    boundingBox : {
+                        min : [0, 0, 0],
+                        max : [1, 1, 1]
+                    }
+                }
+            ]
+        });
+    });
 
-	it ('cube_two_instances.3ds', function () {
-		var model = testFiles.Import3dsFile ('cube_two_instances.3ds');
-		assert (OV.CheckModel (model));
-		assert.deepStrictEqual (testUtils.ModelToObjectSimple (model), {
-			name : '',
-			materials : [
-				{ name : 'tex' },
-				{ name : 'red' },
-				{ name : 'green' },
-				{ name : 'blue' },
-				{ name : 'white' }
-			],
-			meshes : [
-				{
-					name : 'cube',
-					vertexCount : 8,
-					normalCount : 12,
-					uvCount : 8,
-					triangleCount : 12,
-					boundingBox : {
-						min : [0, 0, 0],
-						max : [1, 1, 1]
-					}
-				},
-				{
-					name : 'cube',
-					vertexCount : 8,
-					normalCount : 12,
-					uvCount : 8,
-					triangleCount : 12,
-					boundingBox : {
-						min : [2, 0, 0],
-						max : [3, 1, 1]
-					}
-				}				
-			]
-		});
-	});
+    it ('cube_two_instances.3ds', function () {
+        var model = testFiles.Import3dsFile ('cube_two_instances.3ds');
+        assert (OV.CheckModel (model));
+        assert.deepStrictEqual (testUtils.ModelToObjectSimple (model), {
+            name : '',
+            materials : [
+                { name : 'tex' },
+                { name : 'red' },
+                { name : 'green' },
+                { name : 'blue' },
+                { name : 'white' }
+            ],
+            meshes : [
+                {
+                    name : 'cube',
+                    vertexCount : 8,
+                    normalCount : 12,
+                    uvCount : 8,
+                    triangleCount : 12,
+                    boundingBox : {
+                        min : [0, 0, 0],
+                        max : [1, 1, 1]
+                    }
+                },
+                {
+                    name : 'cube',
+                    vertexCount : 8,
+                    normalCount : 12,
+                    uvCount : 8,
+                    triangleCount : 12,
+                    boundingBox : {
+                        min : [2, 0, 0],
+                        max : [3, 1, 1]
+                    }
+                }                
+            ]
+        });
+    });
 
-	it ('cube_four_instances.3ds', function () {
-		var model = testFiles.Import3dsFile ('cube_four_instances.3ds');
-		assert (OV.CheckModel (model));
-		assert.deepStrictEqual (testUtils.ModelToObjectSimple (model), {
-			name : '',
-			materials : [
-				{ name : 'tex' },
-				{ name : 'red' },
-				{ name : 'green' },
-				{ name : 'blue' },
-				{ name : 'white' }
-			],
-			meshes : [
-				{
-					name : 'cube',
-					vertexCount : 8,
-					normalCount : 12,
-					uvCount : 8,
-					triangleCount : 12,
-					boundingBox : {
-						min : [0, 0, 0],
-						max : [1, 1, 1]
-					}
-				},
-				{
-					name : 'cube',
-					vertexCount : 8,
-					normalCount : 12,
-					uvCount : 8,
-					triangleCount : 12,
-					boundingBox : {
-						min : [2, 0, 0],
-						max : [3, 1, 1]
-					}
-				},
-				{
-					name : 'cube',
-					vertexCount : 8,
-					normalCount : 12,
-					uvCount : 8,
-					triangleCount : 12,
-					boundingBox : {
-						min : [2, 2, 0],
-						max : [3, 3, 1]
-					}
-				},
-				{
-					name : 'cube',
-					vertexCount : 8,
-					normalCount : 12,
-					uvCount : 8,
-					triangleCount : 12,
-					boundingBox : {
-						min : [0, 2, 0],
-						max : [1, 3, 1]
-					}
-				}				
-			]
-		});
-	});		
+    it ('cube_four_instances.3ds', function () {
+        var model = testFiles.Import3dsFile ('cube_four_instances.3ds');
+        assert (OV.CheckModel (model));
+        assert.deepStrictEqual (testUtils.ModelToObjectSimple (model), {
+            name : '',
+            materials : [
+                { name : 'tex' },
+                { name : 'red' },
+                { name : 'green' },
+                { name : 'blue' },
+                { name : 'white' }
+            ],
+            meshes : [
+                {
+                    name : 'cube',
+                    vertexCount : 8,
+                    normalCount : 12,
+                    uvCount : 8,
+                    triangleCount : 12,
+                    boundingBox : {
+                        min : [0, 0, 0],
+                        max : [1, 1, 1]
+                    }
+                },
+                {
+                    name : 'cube',
+                    vertexCount : 8,
+                    normalCount : 12,
+                    uvCount : 8,
+                    triangleCount : 12,
+                    boundingBox : {
+                        min : [2, 0, 0],
+                        max : [3, 1, 1]
+                    }
+                },
+                {
+                    name : 'cube',
+                    vertexCount : 8,
+                    normalCount : 12,
+                    uvCount : 8,
+                    triangleCount : 12,
+                    boundingBox : {
+                        min : [2, 2, 0],
+                        max : [3, 3, 1]
+                    }
+                },
+                {
+                    name : 'cube',
+                    vertexCount : 8,
+                    normalCount : 12,
+                    uvCount : 8,
+                    triangleCount : 12,
+                    boundingBox : {
+                        min : [0, 2, 0],
+                        max : [1, 3, 1]
+                    }
+                }                
+            ]
+        });
+    });        
 });

test/tests/importer_test.js

@@ -22,7 +22,7 @@ function ImportFiles (files, callbacks)
 }
 
 describe ('Importer Test', function () {
-	it ('Empty File List', function () {
+    it ('Empty File List', function () {
         let files = [];
         ImportFiles (files, {
             success : function (importer, importResult) {
@@ -32,9 +32,9 @@ describe ('Importer Test', function () {
                 assert.strictEqual (importError.code, OV.ImportErrorCode.NoImportableFile);
             }
         });
-	});
+    });
 
-	it ('Not existing file', function () {
+    it ('Not existing file', function () {
         let files = [
             new FileObject ('obj', 'missing.obj')
         ];
@@ -46,9 +46,9 @@ describe ('Importer Test', function () {
                 assert.strictEqual (importError.code, OV.ImportErrorCode.NoImportableFile);
             }
         });
-	});
+    });
 
-	it ('Not imprtable file', function () {
+    it ('Not imprtable file', function () {
         let files = [
             new FileObject ('', 'wrong.ext')
         ];
@@ -60,9 +60,9 @@ describe ('Importer Test', function () {
                 assert.strictEqual (importError.code, OV.ImportErrorCode.NoImportableFile);
             }
         });
-	});
+    });
 
-	it ('Wrong file', function () {
+    it ('Wrong file', function () {
         let files = [
             new FileObject ('3ds', 'wrong.3ds')
         ];
@@ -74,7 +74,7 @@ describe ('Importer Test', function () {
                 assert.strictEqual (importError.code, OV.ImportErrorCode.ImportFailed);
             }
         });
-	});
+    });
 
     it ('Single file', function () {
         let files = [
@@ -90,7 +90,27 @@ describe ('Importer Test', function () {
                 assert.fail ();
             }
         });
-	});
+    });
+
+    it ('Multiple files', function () {
+        let files = [
+            new FileObject ('obj', 'cube_with_materials.obj'),
+            new FileObject ('obj', 'cube_with_materials.mtl'),
+            new FileObject ('obj', 'cube_texture.png')
+        ]
+
+        let theImporter = new OV.Importer ();
+        ImportFilesWithImporter (theImporter, files, {
+            success : function (importer, importResult) {
+                assert (!OV.IsModelEmpty (importResult.model));
+                assert.deepStrictEqual (importResult.usedFiles, ['cube_with_materials.obj', 'cube_with_materials.mtl', 'cube_texture.png']);
+                assert.deepStrictEqual (importResult.missingFiles, []);            
+            },
+            error : function (importer, importError) {
+                assert.fail ();
+            }
+        });
+    });    
 
     it ('Missing files', function () {
         let files = [];
@@ -127,7 +147,7 @@ describe ('Importer Test', function () {
                 assert.fail ();
             }
         });
-	});
+    });
 
     it ('Missing texture multiple times', function () {
         let files = [
@@ -144,7 +164,7 @@ describe ('Importer Test', function () {
                 assert.fail ();
             }
         });
-	});
+    });
 
     it ('Append Missing files', function () {
         let theImporter = new OV.Importer ();
@@ -178,5 +198,39 @@ describe ('Importer Test', function () {
                 assert.fail ();
             }
         });
-	});    
+    });
+
+    it ('Reuse importer', function () {
+        let files1 = [
+            new FileObject ('obj', 'cube_with_materials.obj'),
+            new FileObject ('obj', 'cube_with_materials.mtl'),
+            new FileObject ('obj', 'cube_texture.png')
+        ]
+        let files2 = [
+            new FileObject ('obj', 'single_triangle.obj')
+        ];        
+
+        let theImporter = new OV.Importer ();
+        ImportFilesWithImporter (theImporter, files1, {
+            success : function (importer, importResult) {
+                assert (!OV.IsModelEmpty (importResult.model));
+                assert.deepStrictEqual (importResult.usedFiles, ['cube_with_materials.obj', 'cube_with_materials.mtl', 'cube_texture.png']);
+                assert.deepStrictEqual (importResult.missingFiles, []);       
+                
+                ImportFilesWithImporter (theImporter, files2, {
+                    success : function (importer, importResult) {
+                        assert (!OV.IsModelEmpty (importResult.model));
+                        assert.deepStrictEqual (importResult.usedFiles, ['single_triangle.obj']);
+                        assert.deepStrictEqual (importResult.missingFiles, []);
+                    },
+                    error : function (importer, importError) {
+                        assert.fail ();
+                    }
+                });                
+            },
+            error : function (importer, importError) {
+                assert.fail ();
+            }
+        });      
+    });
 });

test/tests/importergltf_test.js

@@ -6,7 +6,7 @@ let testUtils = require ('../utils/testutils.js');
 //console.log (util.inspect(testUtils.ModelToObjectSimple (model), {showHidden: false, depth: null}))
 
 describe ('Gltf Importer', function () {
-	it ('Triangle', function () {
+    it ('Triangle', function () {
         let testFileList = [
             ['Triangle/glTF', 'Triangle.gltf'],
             ['Triangle/glTF-Embedded', 'Triangle.gltf'],
@@ -37,9 +37,9 @@ describe ('Gltf Importer', function () {
                 ]
             });        
         }
-	});
+    });
 
-	it ('Box', function () {
+    it ('Box', function () {
         let testFileList = [
             ['Box/glTF', 'Box.gltf'],
             ['Box/glTF-Embedded', 'Box.gltf'],
@@ -69,9 +69,9 @@ describe ('Gltf Importer', function () {
                 ]
             });        
         }
-	});
+    });
     
-	it ('BoxInterleaved', function () {
+    it ('BoxInterleaved', function () {
         let testFileList = [
             ['BoxInterleaved/glTF', 'BoxInterleaved.gltf'],
             ['BoxInterleaved/glTF-Embedded', 'BoxInterleaved.gltf'],
@@ -101,9 +101,9 @@ describe ('Gltf Importer', function () {
                 ]
             });        
         }
-	});
+    });
 
-	it ('BoxTextured', function () {
+    it ('BoxTextured', function () {
         let testFileList = [
             ['BoxTextured/glTF', 'BoxTextured.gltf'],
             ['BoxTextured/glTF-Embedded', 'BoxTextured.gltf'],
@@ -133,7 +133,7 @@ describe ('Gltf Importer', function () {
                 ]
             });        
         }
-	});
+    });
 
     it ('SimpleMeshes', function () {
         let testFileList = [
@@ -175,7 +175,7 @@ describe ('Gltf Importer', function () {
                 ]
             });        
         }
-	});
+    });
     
     it ('OrientationTest', function () {
         let testFileList = [
@@ -345,9 +345,9 @@ describe ('Gltf Importer', function () {
                 ]
             });    
         }
-	});
+    });
 
-	it ('MeshPrimitives_4Vertex', function () {
+    it ('MeshPrimitives_4Vertex', function () {
         let testFileList = [
             ['Mesh_PrimitiveMode', 'Mesh_PrimitiveMode_04.gltf'],
             ['Mesh_PrimitiveMode', 'Mesh_PrimitiveMode_05.gltf'],
@@ -379,9 +379,9 @@ describe ('Gltf Importer', function () {
                 ]
             });        
         }
-	});
+    });
 
-	it ('MeshPrimitives_6Vertex', function () {
+    it ('MeshPrimitives_6Vertex', function () {
         let testFileList = [
             ['Mesh_PrimitiveMode', 'Mesh_PrimitiveMode_06.gltf']
         ];
@@ -409,9 +409,9 @@ describe ('Gltf Importer', function () {
                 ]
             });        
         }
-	});
+    });
 
-	it ('SimpleSparseAccessor', function () {
+    it ('SimpleSparseAccessor', function () {
         let testFileList = [
             ['SimpleSparseAccessor/glTF', 'SimpleSparseAccessor.gltf'],
             ['SimpleSparseAccessor/glTF-Embedded', 'SimpleSparseAccessor.gltf']
@@ -440,5 +440,5 @@ describe ('Gltf Importer', function () {
                 ]
             });        
         }
-	});    
+    });    
 });

test/tests/importeroff_test.js

@@ -3,135 +3,135 @@ var testFiles = require ('../utils/testfiles.js');
 var testUtils = require ('../utils/testutils.js');
 
 describe ('Off Importer', function() {
-	it ('single_triangle.off', function () {
-		var model = testFiles.ImportOffFile ('single_triangle.off');
-		assert (OV.CheckModel (model));
-		assert.deepStrictEqual (testUtils.ModelToObject (model), {
-			name : '',
-			materials : [
-				{ name : '' }
-			],
-			meshes : [
-				{
-					name : '',
-					triangles : [
-						{
-							vertices : [0, 0, 0, 1, 0, 0, 1, 1, 0],
-							normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
-							uvs : [],
-							mat : 0
-						}
-					]
-				}
-			]
-		});
-	});
+    it ('single_triangle.off', function () {
+        var model = testFiles.ImportOffFile ('single_triangle.off');
+        assert (OV.CheckModel (model));
+        assert.deepStrictEqual (testUtils.ModelToObject (model), {
+            name : '',
+            materials : [
+                { name : '' }
+            ],
+            meshes : [
+                {
+                    name : '',
+                    triangles : [
+                        {
+                            vertices : [0, 0, 0, 1, 0, 0, 1, 1, 0],
+                            normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
+                            uvs : [],
+                            mat : 0
+                        }
+                    ]
+                }
+            ]
+        });
+    });
 
-	it ('two_triangles.off', function () {
-		var model = testFiles.ImportOffFile ('two_triangles.off');
-		assert (OV.CheckModel (model));
-		assert.deepStrictEqual (testUtils.ModelToObject (model), {
-			name : '',
-			materials : [
-				{ name : '' }
-			],
-			meshes : [
-				{
-					name : '',
-					triangles : [
-						{
-							vertices : [0, 0, 0, 1, 0, 0, 1, 1, 0],
-							normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
-							uvs : [],
-							mat : 0
-						},
-						{
-							vertices : [0, 0, 1, 1, 0, 1, 1, 1, 1],
-							normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
-							uvs : [],
-							mat : 0
-						}
-					]
-				}
-			]
-		});
-	});	    
+    it ('two_triangles.off', function () {
+        var model = testFiles.ImportOffFile ('two_triangles.off');
+        assert (OV.CheckModel (model));
+        assert.deepStrictEqual (testUtils.ModelToObject (model), {
+            name : '',
+            materials : [
+                { name : '' }
+            ],
+            meshes : [
+                {
+                    name : '',
+                    triangles : [
+                        {
+                            vertices : [0, 0, 0, 1, 0, 0, 1, 1, 0],
+                            normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
+                            uvs : [],
+                            mat : 0
+                        },
+                        {
+                            vertices : [0, 0, 1, 1, 0, 1, 1, 1, 1],
+                            normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
+                            uvs : [],
+                            mat : 0
+                        }
+                    ]
+                }
+            ]
+        });
+    });        
 
-	it ('single_rectangle.off', function () {
-		var model = testFiles.ImportOffFile ('single_rectangle.off');
-		assert (OV.CheckModel (model));
-		assert.deepStrictEqual (testUtils.ModelToObject (model), {
-			name : '',
-			materials : [
-				{ name : '' }
-			],
-			meshes : [
-				{
-					name : '',
-					triangles : [
-						{
-							vertices : [0, 0, 0, 1, 0, 0, 1, 1, 0],
-							normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
-							uvs : [],
-							mat : 0
-						},
-						{
-							vertices : [0, 0, 0, 1, 1, 0, 0, 1, 0],
-							normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
-							uvs : [],
-							mat : 0
-						}						
-					]
-				}
-			]
-		});
-	});
+    it ('single_rectangle.off', function () {
+        var model = testFiles.ImportOffFile ('single_rectangle.off');
+        assert (OV.CheckModel (model));
+        assert.deepStrictEqual (testUtils.ModelToObject (model), {
+            name : '',
+            materials : [
+                { name : '' }
+            ],
+            meshes : [
+                {
+                    name : '',
+                    triangles : [
+                        {
+                            vertices : [0, 0, 0, 1, 0, 0, 1, 1, 0],
+                            normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
+                            uvs : [],
+                            mat : 0
+                        },
+                        {
+                            vertices : [0, 0, 0, 1, 1, 0, 0, 1, 0],
+                            normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
+                            uvs : [],
+                            mat : 0
+                        }                        
+                    ]
+                }
+            ]
+        });
+    });
     
-	it ('single_triangle_with_comments.off', function () {
-		var model = testFiles.ImportOffFile ('single_triangle_with_comments.off');
-		assert (OV.CheckModel (model));
-		assert.deepStrictEqual (testUtils.ModelToObject (model), {
-			name : '',
-			materials : [
-				{ name : '' }
-			],
-			meshes : [
-				{
-					name : '',
-					triangles : [
-						{
-							vertices : [0, 0, 0, 1, 0, 0, 1, 1, 0],
-							normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
-							uvs : [],
-							mat : 0
-						}
-					]
-				}
-			]
-		});
-	});
+    it ('single_triangle_with_comments.off', function () {
+        var model = testFiles.ImportOffFile ('single_triangle_with_comments.off');
+        assert (OV.CheckModel (model));
+        assert.deepStrictEqual (testUtils.ModelToObject (model), {
+            name : '',
+            materials : [
+                { name : '' }
+            ],
+            meshes : [
+                {
+                    name : '',
+                    triangles : [
+                        {
+                            vertices : [0, 0, 0, 1, 0, 0, 1, 1, 0],
+                            normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
+                            uvs : [],
+                            mat : 0
+                        }
+                    ]
+                }
+            ]
+        });
+    });
 
-	it ('cube.off', function () {
-		var model = testFiles.ImportOffFile ('cube.off');
-		assert (OV.CheckModel (model));
-		assert.deepStrictEqual (testUtils.ModelToObjectSimple (model), {
-			name : '',
-			materials : [
-				{ name : '' }
-			],
-			meshes : [
-				{
-					name : '',
-					vertexCount : 8,
-					normalCount : 12,
-					uvCount : 0,
-					triangleCount : 12,
-					boundingBox : {
-						min : [0, 0, 0],
-						max : [1, 1, 1]
-					}
-				}
-			]
-		});
-	});		
+    it ('cube.off', function () {
+        var model = testFiles.ImportOffFile ('cube.off');
+        assert (OV.CheckModel (model));
+        assert.deepStrictEqual (testUtils.ModelToObjectSimple (model), {
+            name : '',
+            materials : [
+                { name : '' }
+            ],
+            meshes : [
+                {
+                    name : '',
+                    vertexCount : 8,
+                    normalCount : 12,
+                    uvCount : 0,
+                    triangleCount : 12,
+                    boundingBox : {
+                        min : [0, 0, 0],
+                        max : [1, 1, 1]
+                    }
+                }
+            ]
+        });
+    });        
 });

test/tests/importerply_test.js

@@ -3,210 +3,210 @@ var testFiles = require ('../utils/testfiles.js');
 var testUtils = require ('../utils/testutils.js');
 
 describe ('Ply Importer', function() {
-	it ('single_triangle.ply', function () {
-		var model = testFiles.ImportPlyFile ('single_triangle.ply');
-		assert (OV.CheckModel (model));
-		assert.deepStrictEqual (testUtils.ModelToObject (model), {
-			name : '',
-			materials : [
-				{ name : '' }
-			],
-			meshes : [
-				{
-					name : '',
-					triangles : [
-						{
-							vertices : [0, 0, 0, 1, 0, 0, 1, 1, 0],
-							normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
-							uvs : [],
-							mat : 0
-						}
-					]
-				}
-			]
-		});
-	});
+    it ('single_triangle.ply', function () {
+        var model = testFiles.ImportPlyFile ('single_triangle.ply');
+        assert (OV.CheckModel (model));
+        assert.deepStrictEqual (testUtils.ModelToObject (model), {
+            name : '',
+            materials : [
+                { name : '' }
+            ],
+            meshes : [
+                {
+                    name : '',
+                    triangles : [
+                        {
+                            vertices : [0, 0, 0, 1, 0, 0, 1, 1, 0],
+                            normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
+                            uvs : [],
+                            mat : 0
+                        }
+                    ]
+                }
+            ]
+        });
+    });
 
-	it ('two_triangles.ply', function () {
-		var model = testFiles.ImportPlyFile ('two_triangles.ply');
-		assert (OV.CheckModel (model));
-		assert.deepStrictEqual (testUtils.ModelToObject (model), {
-			name : '',
-			materials : [
-				{ name : '' }
-			],
-			meshes : [
-				{
-					name : '',
-					triangles : [
-						{
-							vertices : [0, 0, 0, 1, 0, 0, 1, 1, 0],
-							normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
-							uvs : [],
-							mat : 0
-						},
-						{
-							vertices : [0, 0, 1, 1, 0, 1, 1, 1, 1],
-							normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
-							uvs : [],
-							mat : 0
-						}
-					]
-				}
-			]
-		});
-	});	    
+    it ('two_triangles.ply', function () {
+        var model = testFiles.ImportPlyFile ('two_triangles.ply');
+        assert (OV.CheckModel (model));
+        assert.deepStrictEqual (testUtils.ModelToObject (model), {
+            name : '',
+            materials : [
+                { name : '' }
+            ],
+            meshes : [
+                {
+                    name : '',
+                    triangles : [
+                        {
+                            vertices : [0, 0, 0, 1, 0, 0, 1, 1, 0],
+                            normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
+                            uvs : [],
+                            mat : 0
+                        },
+                        {
+                            vertices : [0, 0, 1, 1, 0, 1, 1, 1, 1],
+                            normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
+                            uvs : [],
+                            mat : 0
+                        }
+                    ]
+                }
+            ]
+        });
+    });        
 
-	it ('single_rectangle.ply', function () {
-		var model = testFiles.ImportPlyFile ('single_rectangle.ply');
-		assert (OV.CheckModel (model));
-		assert.deepStrictEqual (testUtils.ModelToObject (model), {
-			name : '',
-			materials : [
-				{ name : '' }
-			],
-			meshes : [
-				{
-					name : '',
-					triangles : [
-						{
-							vertices : [0, 0, 0, 1, 0, 0, 1, 1, 0],
-							normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
-							uvs : [],
-							mat : 0
-						},
-						{
-							vertices : [0, 0, 0, 1, 1, 0, 0, 1, 0],
-							normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
-							uvs : [],
-							mat : 0
-						}						
-					]
-				}
-			]
-		});
-	});
+    it ('single_rectangle.ply', function () {
+        var model = testFiles.ImportPlyFile ('single_rectangle.ply');
+        assert (OV.CheckModel (model));
+        assert.deepStrictEqual (testUtils.ModelToObject (model), {
+            name : '',
+            materials : [
+                { name : '' }
+            ],
+            meshes : [
+                {
+                    name : '',
+                    triangles : [
+                        {
+                            vertices : [0, 0, 0, 1, 0, 0, 1, 1, 0],
+                            normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
+                            uvs : [],
+                            mat : 0
+                        },
+                        {
+                            vertices : [0, 0, 0, 1, 1, 0, 0, 1, 0],
+                            normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
+                            uvs : [],
+                            mat : 0
+                        }                        
+                    ]
+                }
+            ]
+        });
+    });
     
-	it ('single_triangle_with_comments.ply', function () {
-		var model = testFiles.ImportPlyFile ('single_triangle_with_comments.ply');
-		assert (OV.CheckModel (model));
-		assert.deepStrictEqual (testUtils.ModelToObject (model), {
-			name : '',
-			materials : [
-				{ name : '' }
-			],
-			meshes : [
-				{
-					name : '',
-					triangles : [
-						{
-							vertices : [0, 0, 0, 1, 0, 0, 1, 1, 0],
-							normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
-							uvs : [],
-							mat : 0
-						}
-					]
-				}
-			]
-		});
-	});
+    it ('single_triangle_with_comments.ply', function () {
+        var model = testFiles.ImportPlyFile ('single_triangle_with_comments.ply');
+        assert (OV.CheckModel (model));
+        assert.deepStrictEqual (testUtils.ModelToObject (model), {
+            name : '',
+            materials : [
+                { name : '' }
+            ],
+            meshes : [
+                {
+                    name : '',
+                    triangles : [
+                        {
+                            vertices : [0, 0, 0, 1, 0, 0, 1, 1, 0],
+                            normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
+                            uvs : [],
+                            mat : 0
+                        }
+                    ]
+                }
+            ]
+        });
+    });
 
-	it ('cube.ply', function () {
-		var model = testFiles.ImportPlyFile ('cube.ply');
-		assert (OV.CheckModel (model));
-		assert.deepStrictEqual (testUtils.ModelToObjectSimple (model), {
-			name : '',
-			materials : [
-				{ name : '' }
-			],
-			meshes : [
-				{
-					name : '',
-					vertexCount : 8,
-					normalCount : 12,
-					uvCount : 0,
-					triangleCount : 12,
-					boundingBox : {
-						min : [0, 0, 0],
-						max : [1, 1, 1]
-					}
-				}
-			]
-		});
-	});
-
-	it ('cube_meshlab_ascii.ply', function () {
-		var model = testFiles.ImportPlyFile ('cube_meshlab_ascii.ply');
-		assert (OV.CheckModel (model));
-		assert.deepStrictEqual (testUtils.ModelToObjectSimple (model), {
-			name : '',
-			materials : [
-				{ name : '' }
-			],
-			meshes : [
-				{
-					name : '',
-					vertexCount : 8,
+    it ('cube.ply', function () {
+        var model = testFiles.ImportPlyFile ('cube.ply');
+        assert (OV.CheckModel (model));
+        assert.deepStrictEqual (testUtils.ModelToObjectSimple (model), {
+            name : '',
+            materials : [
+                { name : '' }
+            ],
+            meshes : [
+                {
+                    name : '',
+                    vertexCount : 8,
                     normalCount : 12,
                     uvCount : 0,
                     triangleCount : 12,
-					boundingBox : {
-						min : [0, 0, 0],
-						max : [1, 1, 1]
-					}
-				}
-			]
-		});
-	});	
+                    boundingBox : {
+                        min : [0, 0, 0],
+                        max : [1, 1, 1]
+                    }
+                }
+            ]
+        });
+    });
 
-	it ('cube_meshlab_binary.ply', function () {
-		var model = testFiles.ImportPlyFile ('cube_meshlab_binary.ply');
-		assert (OV.CheckModel (model));
-		assert.deepStrictEqual (testUtils.ModelToObjectSimple (model), {
-			name : '',
-			materials : [
-				{ name : '' }
-			],
-			meshes : [
-				{
-					name : '',
-					vertexCount : 8,
+    it ('cube_meshlab_ascii.ply', function () {
+        var model = testFiles.ImportPlyFile ('cube_meshlab_ascii.ply');
+        assert (OV.CheckModel (model));
+        assert.deepStrictEqual (testUtils.ModelToObjectSimple (model), {
+            name : '',
+            materials : [
+                { name : '' }
+            ],
+            meshes : [
+                {
+                    name : '',
+                    vertexCount : 8,
                     normalCount : 12,
                     uvCount : 0,
                     triangleCount : 12,
-					boundingBox : {
-						min : [0, 0, 0],
-						max : [1, 1, 1]
-					}
-				}
-			]
-		});
-	});
+                    boundingBox : {
+                        min : [0, 0, 0],
+                        max : [1, 1, 1]
+                    }
+                }
+            ]
+        });
+    });    
 
-	it ('cube_rgb_binary.ply', function () {
-		var model = testFiles.ImportPlyFile ('cube_rgb_binary.ply');
-		assert (OV.CheckModel (model));
-		assert.deepStrictEqual (testUtils.ModelToObjectSimple (model), {
-			name : '',
-			materials : [
-				{ name : '#cc0000ff' },
-				{ name : '#00cc00ff' },
-				{ name : '#0000ccff' },
-				{ name : '#cccccc7f' }
-			],
-			meshes : [
-				{
-					name : '',
-					vertexCount : 8,
-					normalCount : 12,
-					uvCount : 0,
-					triangleCount : 12,
-					boundingBox : {
-						min : [0, 0, 0],
-						max : [1, 1, 1]
-					}
-				}
-			]
-		});
-	});	
+    it ('cube_meshlab_binary.ply', function () {
+        var model = testFiles.ImportPlyFile ('cube_meshlab_binary.ply');
+        assert (OV.CheckModel (model));
+        assert.deepStrictEqual (testUtils.ModelToObjectSimple (model), {
+            name : '',
+            materials : [
+                { name : '' }
+            ],
+            meshes : [
+                {
+                    name : '',
+                    vertexCount : 8,
+                    normalCount : 12,
+                    uvCount : 0,
+                    triangleCount : 12,
+                    boundingBox : {
+                        min : [0, 0, 0],
+                        max : [1, 1, 1]
+                    }
+                }
+            ]
+        });
+    });
+
+    it ('cube_rgb_binary.ply', function () {
+        var model = testFiles.ImportPlyFile ('cube_rgb_binary.ply');
+        assert (OV.CheckModel (model));
+        assert.deepStrictEqual (testUtils.ModelToObjectSimple (model), {
+            name : '',
+            materials : [
+                { name : '#cc0000ff' },
+                { name : '#00cc00ff' },
+                { name : '#0000ccff' },
+                { name : '#cccccc7f' }
+            ],
+            meshes : [
+                {
+                    name : '',
+                    vertexCount : 8,
+                    normalCount : 12,
+                    uvCount : 0,
+                    triangleCount : 12,
+                    boundingBox : {
+                        min : [0, 0, 0],
+                        max : [1, 1, 1]
+                    }
+                }
+            ]
+        });
+    });    
 });

test/tests/importerstl_test.js

@@ -3,202 +3,202 @@ var testFiles = require ('../utils/testfiles.js');
 var testUtils = require ('../utils/testutils.js');
 
 describe ('Stl Importer', function() {
-	it ('single_triangle.stl', function () {
-		var model = testFiles.ImportStlFile ('single_triangle.stl');
-		assert (OV.CheckModel (model));
-		assert.deepStrictEqual (testUtils.ModelToObject (model), {
-			name : '',
-			materials : [
-				{ name : '' }
-			],
-			meshes : [
-				{
-					name : 'MeshName',
-					triangles : [
-						{
-							vertices : [0, 0, 0, 1, 0, 0, 1, 1, 0],
-							normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
-							uvs : [],
-							mat : 0
-						}
-					]
-				}
-			]
-		});
-	});
+    it ('single_triangle.stl', function () {
+        var model = testFiles.ImportStlFile ('single_triangle.stl');
+        assert (OV.CheckModel (model));
+        assert.deepStrictEqual (testUtils.ModelToObject (model), {
+            name : '',
+            materials : [
+                { name : '' }
+            ],
+            meshes : [
+                {
+                    name : 'MeshName',
+                    triangles : [
+                        {
+                            vertices : [0, 0, 0, 1, 0, 0, 1, 1, 0],
+                            normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
+                            uvs : [],
+                            mat : 0
+                        }
+                    ]
+                }
+            ]
+        });
+    });
 
-	it ('single_triangle_with_comments.stl', function () {
-		var model = testFiles.ImportStlFile ('single_triangle_with_comments.stl');
-		assert (OV.CheckModel (model));
-		assert.deepStrictEqual (testUtils.ModelToObject (model), {
-			name : '',
-			materials : [
-				{ name : '' }
-			],
-			meshes : [
-				{
-					name : 'MeshName',
-					triangles : [
-						{
-							vertices : [0, 0, 0, 1, 0, 0, 1, 1, 0],
-							normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
-							uvs : [],
-							mat : 0
-						}
-					]
-				}
-			]
-		});
-	});	
+    it ('single_triangle_with_comments.stl', function () {
+        var model = testFiles.ImportStlFile ('single_triangle_with_comments.stl');
+        assert (OV.CheckModel (model));
+        assert.deepStrictEqual (testUtils.ModelToObject (model), {
+            name : '',
+            materials : [
+                { name : '' }
+            ],
+            meshes : [
+                {
+                    name : 'MeshName',
+                    triangles : [
+                        {
+                            vertices : [0, 0, 0, 1, 0, 0, 1, 1, 0],
+                            normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
+                            uvs : [],
+                            mat : 0
+                        }
+                    ]
+                }
+            ]
+        });
+    });    
 
-	it ('single_triangle_no_normal.stl', function () {
-		var model = testFiles.ImportStlFile ('single_triangle_no_normal.stl');
-		assert (OV.CheckModel (model));
-		assert.deepStrictEqual (testUtils.ModelToObject (model), {
-			name : '',
-			materials : [
-				{ name : '' }
-			],
-			meshes : [
-				{
-					name : 'MeshName',
-					triangles : [
-						{
-							vertices : [0, 0, 0, 1, 0, 0, 1, 1, 0],
-							normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
-							uvs : [],
-							mat : 0
-						}
-					]
-				}
-			]
-		});
-	});    
+    it ('single_triangle_no_normal.stl', function () {
+        var model = testFiles.ImportStlFile ('single_triangle_no_normal.stl');
+        assert (OV.CheckModel (model));
+        assert.deepStrictEqual (testUtils.ModelToObject (model), {
+            name : '',
+            materials : [
+                { name : '' }
+            ],
+            meshes : [
+                {
+                    name : 'MeshName',
+                    triangles : [
+                        {
+                            vertices : [0, 0, 0, 1, 0, 0, 1, 1, 0],
+                            normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
+                            uvs : [],
+                            mat : 0
+                        }
+                    ]
+                }
+            ]
+        });
+    });    
 
-	it ('two_triangles.stl', function () {
-		var model = testFiles.ImportStlFile ('two_triangles.stl');
-		assert (OV.CheckModel (model));
-		assert.deepStrictEqual (testUtils.ModelToObject (model), {
-			name : '',
-			materials : [
-				{ name : '' }
-			],
-			meshes : [
-				{
-					name : 'MeshName',
-					triangles : [
-						{
-							vertices : [0, 0, 0, 1, 0, 0, 1, 1, 0],
-							normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
-							uvs : [],
-							mat : 0
-						},
-						{
-							vertices : [0, 0, 1, 1, 0, 1, 1, 1, 1],
-							normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
-							uvs : [],
-							mat : 0
-						}
-					]
-				}
-			]
-		});
-	});	 
+    it ('two_triangles.stl', function () {
+        var model = testFiles.ImportStlFile ('two_triangles.stl');
+        assert (OV.CheckModel (model));
+        assert.deepStrictEqual (testUtils.ModelToObject (model), {
+            name : '',
+            materials : [
+                { name : '' }
+            ],
+            meshes : [
+                {
+                    name : 'MeshName',
+                    triangles : [
+                        {
+                            vertices : [0, 0, 0, 1, 0, 0, 1, 1, 0],
+                            normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
+                            uvs : [],
+                            mat : 0
+                        },
+                        {
+                            vertices : [0, 0, 1, 1, 0, 1, 1, 1, 1],
+                            normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
+                            uvs : [],
+                            mat : 0
+                        }
+                    ]
+                }
+            ]
+        });
+    });     
 
-	it ('stl_ascii.stl', function () {
-		var model = testFiles.ImportStlFile ('stl_ascii.stl');
-		assert (OV.CheckModel (model));
-		assert.deepStrictEqual (testUtils.ModelToObjectSimple (model), {
-			name : '',
-			materials : [
-				{ name : '' }
-			],
-			meshes : [
-				{
-					name : 'Untitled-5427e5af',
-					vertexCount : 1716,
+    it ('stl_ascii.stl', function () {
+        var model = testFiles.ImportStlFile ('stl_ascii.stl');
+        assert (OV.CheckModel (model));
+        assert.deepStrictEqual (testUtils.ModelToObjectSimple (model), {
+            name : '',
+            materials : [
+                { name : '' }
+            ],
+            meshes : [
+                {
+                    name : 'Untitled-5427e5af',
+                    vertexCount : 1716,
                     normalCount : 572,
                     uvCount : 0,
                     triangleCount : 572,
-					boundingBox : {
-						min : [0, -1.10792799192095, 0],
-						max : [4.94407346265022, 3.31831671830375, 1.2]
-					}
-				}
-			]
-		});
-	});
+                    boundingBox : {
+                        min : [0, -1.10792799192095, 0],
+                        max : [4.94407346265022, 3.31831671830375, 1.2]
+                    }
+                }
+            ]
+        });
+    });
 
-	it ('stl_binary.stl', function () {
-		var model = testFiles.ImportStlFile ('stl_binary.stl');
-		assert (OV.CheckModel (model));
-		assert.deepStrictEqual (testUtils.ModelToObjectSimple (model), {
-			name : '',
-			materials : [
-				{ name : '' }
-			],
-			meshes : [
-				{
-					name : '',
-					vertexCount : 2184,
+    it ('stl_binary.stl', function () {
+        var model = testFiles.ImportStlFile ('stl_binary.stl');
+        assert (OV.CheckModel (model));
+        assert.deepStrictEqual (testUtils.ModelToObjectSimple (model), {
+            name : '',
+            materials : [
+                { name : '' }
+            ],
+            meshes : [
+                {
+                    name : '',
+                    vertexCount : 2184,
                     normalCount : 728,
                     uvCount : 0,
                     triangleCount : 728,
-					boundingBox : {
-						min : [0, -1.1079280376434326, 0],
-						max : [5.70156717300415, 3.318316698074341, 1.2000000476837158]
-					}
-				}
-			]
-		});
-	});
-	
+                    boundingBox : {
+                        min : [0, -1.1079280376434326, 0],
+                        max : [5.70156717300415, 3.318316698074341, 1.2000000476837158]
+                    }
+                }
+            ]
+        });
+    });
+    
 
-	it ('cube_meshlab_ascii.stl', function () {
-		var model = testFiles.ImportStlFile ('cube_meshlab_ascii.stl');
-		assert (OV.CheckModel (model));
-		assert.deepStrictEqual (testUtils.ModelToObjectSimple (model), {
-			name : '',
-			materials : [
-				{ name : '' }
-			],
-			meshes : [
-				{
-					name : 'STL generated by MeshLab',
-					vertexCount : 36,
+    it ('cube_meshlab_ascii.stl', function () {
+        var model = testFiles.ImportStlFile ('cube_meshlab_ascii.stl');
+        assert (OV.CheckModel (model));
+        assert.deepStrictEqual (testUtils.ModelToObjectSimple (model), {
+            name : '',
+            materials : [
+                { name : '' }
+            ],
+            meshes : [
+                {
+                    name : 'STL generated by MeshLab',
+                    vertexCount : 36,
                     normalCount : 12,
                     uvCount : 0,
                     triangleCount : 12,
-					boundingBox : {
-						min : [0, 0, 0],
-						max : [1, 1, 1]
-					}
-				}
-			]
-		});
-	});	
+                    boundingBox : {
+                        min : [0, 0, 0],
+                        max : [1, 1, 1]
+                    }
+                }
+            ]
+        });
+    });    
 
-	it ('cube_meshlab_binary.stl', function () {
-		var model = testFiles.ImportStlFile ('cube_meshlab_binary.stl');
-		assert (OV.CheckModel (model));
-		assert.deepStrictEqual (testUtils.ModelToObjectSimple (model), {
-			name : '',
-			materials : [
-				{ name : '' }
-			],
-			meshes : [
-				{
-					name : '',
-					vertexCount : 36,
+    it ('cube_meshlab_binary.stl', function () {
+        var model = testFiles.ImportStlFile ('cube_meshlab_binary.stl');
+        assert (OV.CheckModel (model));
+        assert.deepStrictEqual (testUtils.ModelToObjectSimple (model), {
+            name : '',
+            materials : [
+                { name : '' }
+            ],
+            meshes : [
+                {
+                    name : '',
+                    vertexCount : 36,
                     normalCount : 12,
                     uvCount : 0,
                     triangleCount : 12,
-					boundingBox : {
-						min : [0, 0, 0],
-						max : [1, 1, 1]
-					}
-				}
-			]
-		});
-	});		
+                    boundingBox : {
+                        min : [0, 0, 0],
+                        max : [1, 1, 1]
+                    }
+                }
+            ]
+        });
+    });        
 });

test/tests/importerutils_test.js

@@ -1,7 +1,7 @@
 var assert = require ('assert');
 
 describe ('Power of Two', function () {
-	it ('IsPowerOfTwo', function () {
+    it ('IsPowerOfTwo', function () {
         assert (OV.IsPowerOfTwo (1));
         assert (OV.IsPowerOfTwo (2));
         assert (!OV.IsPowerOfTwo (3));
@@ -13,5 +13,5 @@ describe ('Power of Two', function () {
             assert.strictEqual (OV.NextPowerOfTwo (i - 1), i);
             assert.strictEqual (OV.NextPowerOfTwo (i + 1), i * 2);
         }
-	});
+    });
 });

test/tests/io_test.js

@@ -2,7 +2,7 @@ var assert = require ('assert');
 var testUtils = require ('../utils/testutils.js');
 
 describe ('IO Test', function () {
-	it ('Binary Reader', function () {
+    it ('Binary Reader', function () {
         let buffer = testUtils.GetArrayBufferFileContent ('bin', 'binary_content.bin');
         let reader = new OV.BinaryReader (buffer, true);
         

test/tests/mesh_test.js

@@ -1,109 +1,109 @@
 var assert = require ('assert');
 
 describe ('Mesh', function() {
-	it ('Default Initialization', function () {
-		var mesh = new OV.Mesh ();
-		assert.strictEqual (mesh.GetName (), '');
-		assert.strictEqual (mesh.VertexCount (), 0);
-		assert.strictEqual (mesh.NormalCount (), 0);
-		assert.strictEqual (mesh.TextureUVCount (), 0);
-		assert.strictEqual (mesh.TriangleCount (), 0);
-	});
-	
-	it ('Set Name', function () {
-		var mesh = new OV.Mesh ();
-		mesh.SetName ('example');
-		assert.strictEqual (mesh.GetName (), 'example');
-	});
+    it ('Default Initialization', function () {
+        var mesh = new OV.Mesh ();
+        assert.strictEqual (mesh.GetName (), '');
+        assert.strictEqual (mesh.VertexCount (), 0);
+        assert.strictEqual (mesh.NormalCount (), 0);
+        assert.strictEqual (mesh.TextureUVCount (), 0);
+        assert.strictEqual (mesh.TriangleCount (), 0);
+    });
+    
+    it ('Set Name', function () {
+        var mesh = new OV.Mesh ();
+        mesh.SetName ('example');
+        assert.strictEqual (mesh.GetName (), 'example');
+    });
 
-	it ('Add Vertex', function () {
-		var mesh = new OV.Mesh ();
-		var index = mesh.AddVertex (new OV.Coord3D (1.0, 2.0, 3.0))
-		assert.strictEqual (index, 0);
-		assert.strictEqual (mesh.VertexCount (), 1);
-		var vertex = mesh.GetVertex (index);
-		assert.strictEqual (vertex.x, 1.0);
-		assert.strictEqual (vertex.y, 2.0);
-		assert.strictEqual (vertex.z, 3.0);
-	});
+    it ('Add Vertex', function () {
+        var mesh = new OV.Mesh ();
+        var index = mesh.AddVertex (new OV.Coord3D (1.0, 2.0, 3.0))
+        assert.strictEqual (index, 0);
+        assert.strictEqual (mesh.VertexCount (), 1);
+        var vertex = mesh.GetVertex (index);
+        assert.strictEqual (vertex.x, 1.0);
+        assert.strictEqual (vertex.y, 2.0);
+        assert.strictEqual (vertex.z, 3.0);
+    });
 
-	it ('Add Normal', function () {
-		var mesh = new OV.Mesh ();
-		var index = mesh.AddNormal (new OV.Coord3D (1.0, 2.0, 3.0))
-		assert.strictEqual (index, 0);
-		assert.strictEqual (mesh.NormalCount (), 1);
-		var normal = mesh.GetNormal (index);
-		assert.strictEqual (normal.x, 1.0);
-		assert.strictEqual (normal.y, 2.0);
-		assert.strictEqual (normal.z, 3.0);
-	});
-	
-	it ('Add Texture UV', function () {
-		var mesh = new OV.Mesh ();
-		var index = mesh.AddTextureUV (new OV.Coord2D (1.0, 2.0))
-		assert.strictEqual (index, 0);
-		assert.strictEqual (mesh.TextureUVCount (), 1);
-		var uv = mesh.GetTextureUV (index);
-		assert.strictEqual (uv.x, 1.0);
-		assert.strictEqual (uv.y, 2.0);
-	});
-	
-	it ('Add Triangle', function () {
-		var mesh = new OV.Mesh ();
-		var triangle = new OV.Triangle (1, 2, 3);
-		var index = mesh.AddTriangle (triangle);
-		assert.strictEqual (index, 0);
-		assert.strictEqual (mesh.TriangleCount (), 1);
-		var triangle = mesh.GetTriangle (index);
-		assert.strictEqual (triangle.v0, 1);
-		assert.strictEqual (triangle.v1, 2);
-		assert.strictEqual (triangle.v2, 3);
-		assert (triangle.HasVertices ());
-		assert (!triangle.HasNormals ());
-		assert (!triangle.HasTextureUVs ());
-		assert.strictEqual (triangle.n0, null);
-		assert.strictEqual (triangle.n1, null);
-		assert.strictEqual (triangle.n2, null);
-		assert.strictEqual (triangle.u0, null);
-		assert.strictEqual (triangle.u1, null);
-		assert.strictEqual (triangle.u2, null);
-		assert.strictEqual (triangle.mat, null);
-	});
+    it ('Add Normal', function () {
+        var mesh = new OV.Mesh ();
+        var index = mesh.AddNormal (new OV.Coord3D (1.0, 2.0, 3.0))
+        assert.strictEqual (index, 0);
+        assert.strictEqual (mesh.NormalCount (), 1);
+        var normal = mesh.GetNormal (index);
+        assert.strictEqual (normal.x, 1.0);
+        assert.strictEqual (normal.y, 2.0);
+        assert.strictEqual (normal.z, 3.0);
+    });
+    
+    it ('Add Texture UV', function () {
+        var mesh = new OV.Mesh ();
+        var index = mesh.AddTextureUV (new OV.Coord2D (1.0, 2.0))
+        assert.strictEqual (index, 0);
+        assert.strictEqual (mesh.TextureUVCount (), 1);
+        var uv = mesh.GetTextureUV (index);
+        assert.strictEqual (uv.x, 1.0);
+        assert.strictEqual (uv.y, 2.0);
+    });
+    
+    it ('Add Triangle', function () {
+        var mesh = new OV.Mesh ();
+        var triangle = new OV.Triangle (1, 2, 3);
+        var index = mesh.AddTriangle (triangle);
+        assert.strictEqual (index, 0);
+        assert.strictEqual (mesh.TriangleCount (), 1);
+        var triangle = mesh.GetTriangle (index);
+        assert.strictEqual (triangle.v0, 1);
+        assert.strictEqual (triangle.v1, 2);
+        assert.strictEqual (triangle.v2, 3);
+        assert (triangle.HasVertices ());
+        assert (!triangle.HasNormals ());
+        assert (!triangle.HasTextureUVs ());
+        assert.strictEqual (triangle.n0, null);
+        assert.strictEqual (triangle.n1, null);
+        assert.strictEqual (triangle.n2, null);
+        assert.strictEqual (triangle.u0, null);
+        assert.strictEqual (triangle.u1, null);
+        assert.strictEqual (triangle.u2, null);
+        assert.strictEqual (triangle.mat, null);
+    });
 
-	it ('Transform Mesh', function () {
-		var mesh = new OV.Mesh ();
-		mesh.AddVertex (new OV.Coord3D (0.0, 0.0, 0.0));
-		mesh.AddVertex (new OV.Coord3D (1.0, 0.0, 0.0));
-		mesh.AddVertex (new OV.Coord3D (1.0, 1.0, 0.0));
-		mesh.AddNormal (new OV.Coord3D (0.0, 0.0, 1.0));
-		mesh.AddTextureUV (new OV.Coord2D (0.0, 0.0));
-		mesh.AddTextureUV (new OV.Coord2D (1.0, 0.0));
-		mesh.AddTextureUV (new OV.Coord2D (1.0, 1.0));
-		var triangle = new OV.Triangle (0, 1, 2);
-		triangle.SetNormals (0, 0, 0);
-		triangle.SetTextureUVs (0, 1, 2);
-		mesh.AddTriangle (triangle);
+    it ('Transform Mesh', function () {
+        var mesh = new OV.Mesh ();
+        mesh.AddVertex (new OV.Coord3D (0.0, 0.0, 0.0));
+        mesh.AddVertex (new OV.Coord3D (1.0, 0.0, 0.0));
+        mesh.AddVertex (new OV.Coord3D (1.0, 1.0, 0.0));
+        mesh.AddNormal (new OV.Coord3D (0.0, 0.0, 1.0));
+        mesh.AddTextureUV (new OV.Coord2D (0.0, 0.0));
+        mesh.AddTextureUV (new OV.Coord2D (1.0, 0.0));
+        mesh.AddTextureUV (new OV.Coord2D (1.0, 1.0));
+        var triangle = new OV.Triangle (0, 1, 2);
+        triangle.SetNormals (0, 0, 0);
+        triangle.SetTextureUVs (0, 1, 2);
+        mesh.AddTriangle (triangle);
 
-		let angle = -Math.PI / 2.0;
-		let rotX = 0.0;
-		let rotY = 1.0;
-		let rotZ = 0.0;
+        let angle = -Math.PI / 2.0;
+        let rotX = 0.0;
+        let rotY = 1.0;
+        let rotZ = 0.0;
 
-		let rotation = [
-			Math.sin (angle / 2.0) * rotX,
-			Math.sin (angle / 2.0) * rotY,
-			Math.sin (angle / 2.0) * rotZ,
-			Math.cos (angle / 2.0)
-		];
+        let rotation = [
+            Math.sin (angle / 2.0) * rotX,
+            Math.sin (angle / 2.0) * rotY,
+            Math.sin (angle / 2.0) * rotZ,
+            Math.cos (angle / 2.0)
+        ];
 
-		let transformation = new OV.Transformation ();
-		transformation.AppendMatrix (new OV.Matrix ().CreateScale (2.0, 1.0, 1.0));
-		transformation.AppendMatrix (new OV.Matrix ().CreateRotation (rotation[0], rotation[1], rotation[2], rotation[3]));
-		transformation.AppendMatrix (new OV.Matrix ().CreateTranslation (0.0, 0.0, 1.0));
-		OV.TransformMesh (mesh, transformation);
-		assert (OV.CoordIsEqual3D (mesh.GetVertex (0), new OV.Coord3D (0.0, 0.0, 1.0)));
-		assert (OV.CoordIsEqual3D (mesh.GetVertex (1), new OV.Coord3D (0.0, 0.0, 3.0)));
-		assert (OV.CoordIsEqual3D (mesh.GetVertex (2), new OV.Coord3D (0.0, 1.0, 3.0)));
-		assert (OV.CoordIsEqual3D (mesh.GetNormal (0), new OV.Coord3D (-1.0, 0.0, 0.0)));
-	});		
+        let transformation = new OV.Transformation ();
+        transformation.AppendMatrix (new OV.Matrix ().CreateScale (2.0, 1.0, 1.0));
+        transformation.AppendMatrix (new OV.Matrix ().CreateRotation (rotation[0], rotation[1], rotation[2], rotation[3]));
+        transformation.AppendMatrix (new OV.Matrix ().CreateTranslation (0.0, 0.0, 1.0));
+        OV.TransformMesh (mesh, transformation);
+        assert (OV.CoordIsEqual3D (mesh.GetVertex (0), new OV.Coord3D (0.0, 0.0, 1.0)));
+        assert (OV.CoordIsEqual3D (mesh.GetVertex (1), new OV.Coord3D (0.0, 0.0, 3.0)));
+        assert (OV.CoordIsEqual3D (mesh.GetVertex (2), new OV.Coord3D (0.0, 1.0, 3.0)));
+        assert (OV.CoordIsEqual3D (mesh.GetNormal (0), new OV.Coord3D (-1.0, 0.0, 0.0)));
+    });        
 });

test/tests/meshbuffer_test.js

@@ -12,23 +12,23 @@ describe ('Mesh Buffer', function () {
         mesh.AddVertex (new OV.Coord3D (1.0, 0.0, 1.0));
         mesh.AddVertex (new OV.Coord3D (1.0, 1.0, 1.0));
         mesh.AddVertex (new OV.Coord3D (0.0, 1.0, 1.0));
-		mesh.AddNormal (new OV.Coord3D (0.0, 0.0, 1.0));
+        mesh.AddNormal (new OV.Coord3D (0.0, 0.0, 1.0));
         mesh.AddTriangle (new OV.Triangle (0, 1, 2).SetNormals (0, 0, 0).SetMaterial (0));
-		mesh.AddTriangle (new OV.Triangle (0, 2, 3).SetNormals (0, 0, 0).SetMaterial (0));
+        mesh.AddTriangle (new OV.Triangle (0, 2, 3).SetNormals (0, 0, 0).SetMaterial (0));
         mesh.AddTriangle (new OV.Triangle (4, 5, 6).SetNormals (0, 0, 0).SetMaterial (1));
-		mesh.AddTriangle (new OV.Triangle (4, 6, 7).SetNormals (0, 0, 0).SetMaterial (1));
+        mesh.AddTriangle (new OV.Triangle (4, 6, 7).SetNormals (0, 0, 0).SetMaterial (1));
 
-		let buffer = OV.ConvertMeshToMeshBuffer (mesh);
-		assert.strictEqual (buffer.primitives.length, 2);
-		assert.strictEqual (buffer.primitives[0].indices.length, 6);
-		assert.strictEqual (buffer.primitives[0].vertices.length, 4 * 3);
-		assert.strictEqual (buffer.primitives[0].normals.length, 4 * 3);
-		assert.strictEqual (buffer.primitives[0].uvs.length, 0);
-		assert.strictEqual (buffer.primitives[1].indices.length, 6);
-		assert.strictEqual (buffer.primitives[1].vertices.length, 4 * 3);
-		assert.strictEqual (buffer.primitives[1].normals.length, 4 * 3);
-		assert.strictEqual (buffer.primitives[1].uvs.length, 0);
-	});
+        let buffer = OV.ConvertMeshToMeshBuffer (mesh);
+        assert.strictEqual (buffer.primitives.length, 2);
+        assert.strictEqual (buffer.primitives[0].indices.length, 6);
+        assert.strictEqual (buffer.primitives[0].vertices.length, 4 * 3);
+        assert.strictEqual (buffer.primitives[0].normals.length, 4 * 3);
+        assert.strictEqual (buffer.primitives[0].uvs.length, 0);
+        assert.strictEqual (buffer.primitives[1].indices.length, 6);
+        assert.strictEqual (buffer.primitives[1].vertices.length, 4 * 3);
+        assert.strictEqual (buffer.primitives[1].normals.length, 4 * 3);
+        assert.strictEqual (buffer.primitives[1].uvs.length, 0);
+    });
 
     it ('Mesh To Buffer Different Normals', function () {
         var mesh = new OV.Mesh ();
@@ -36,18 +36,18 @@ describe ('Mesh Buffer', function () {
         mesh.AddVertex (new OV.Coord3D (1.0, 0.0, 0.0));
         mesh.AddVertex (new OV.Coord3D (1.0, 1.0, 0.0));
         mesh.AddVertex (new OV.Coord3D (0.0, 1.0, 0.0));
-		mesh.AddNormal (new OV.Coord3D (0.0, 0.0, 1.0));
-		mesh.AddNormal (new OV.Coord3D (0.0, 0.0, -1.0));
+        mesh.AddNormal (new OV.Coord3D (0.0, 0.0, 1.0));
+        mesh.AddNormal (new OV.Coord3D (0.0, 0.0, -1.0));
         mesh.AddTriangle (new OV.Triangle (0, 1, 2).SetNormals (0, 0, 0).SetMaterial (0));
-		mesh.AddTriangle (new OV.Triangle (0, 2, 3).SetNormals (1, 1, 1).SetMaterial (0));
+        mesh.AddTriangle (new OV.Triangle (0, 2, 3).SetNormals (1, 1, 1).SetMaterial (0));
 
-		let buffer = OV.ConvertMeshToMeshBuffer (mesh);
-		assert.strictEqual (buffer.primitives.length, 1);
-		assert.strictEqual (buffer.primitives[0].indices.length, 6);
-		assert.strictEqual (buffer.primitives[0].vertices.length, 6 * 3);
-		assert.strictEqual (buffer.primitives[0].normals.length, 6 * 3);
-		assert.strictEqual (buffer.primitives[0].uvs.length, 0);		
-	});
+        let buffer = OV.ConvertMeshToMeshBuffer (mesh);
+        assert.strictEqual (buffer.primitives.length, 1);
+        assert.strictEqual (buffer.primitives[0].indices.length, 6);
+        assert.strictEqual (buffer.primitives[0].vertices.length, 6 * 3);
+        assert.strictEqual (buffer.primitives[0].normals.length, 6 * 3);
+        assert.strictEqual (buffer.primitives[0].uvs.length, 0);        
+    });
 
     it ('Mesh To Buffer Different UVs', function () {
         var mesh = new OV.Mesh ();
@@ -55,19 +55,19 @@ describe ('Mesh Buffer', function () {
         mesh.AddVertex (new OV.Coord3D (1.0, 0.0, 0.0));
         mesh.AddVertex (new OV.Coord3D (1.0, 1.0, 0.0));
         mesh.AddVertex (new OV.Coord3D (0.0, 1.0, 0.0));
-		mesh.AddNormal (new OV.Coord3D (0.0, 0.0, 1.0));
-		mesh.AddTextureUV (new OV.Coord3D (1.0, 1.0));
-		mesh.AddTextureUV (new OV.Coord3D (-1.0, -1.0));
+        mesh.AddNormal (new OV.Coord3D (0.0, 0.0, 1.0));
+        mesh.AddTextureUV (new OV.Coord3D (1.0, 1.0));
+        mesh.AddTextureUV (new OV.Coord3D (-1.0, -1.0));
         mesh.AddTriangle (new OV.Triangle (0, 1, 2).SetNormals (0, 0, 0).SetTextureUVs (0, 0, 0).SetMaterial (0));
-		mesh.AddTriangle (new OV.Triangle (0, 2, 3).SetNormals (0, 0, 0).SetTextureUVs (1, 1, 1).SetMaterial (0));
+        mesh.AddTriangle (new OV.Triangle (0, 2, 3).SetNormals (0, 0, 0).SetTextureUVs (1, 1, 1).SetMaterial (0));
 
-		let buffer = OV.ConvertMeshToMeshBuffer (mesh);
-		assert.strictEqual (buffer.primitives.length, 1);
-		assert.strictEqual (buffer.primitives[0].indices.length, 6);
-		assert.strictEqual (buffer.primitives[0].vertices.length, 6 * 3);
-		assert.strictEqual (buffer.primitives[0].normals.length, 6 * 3);
-		assert.strictEqual (buffer.primitives[0].uvs.length, 6 * 2);		
-	});
+        let buffer = OV.ConvertMeshToMeshBuffer (mesh);
+        assert.strictEqual (buffer.primitives.length, 1);
+        assert.strictEqual (buffer.primitives[0].indices.length, 6);
+        assert.strictEqual (buffer.primitives[0].vertices.length, 6 * 3);
+        assert.strictEqual (buffer.primitives[0].normals.length, 6 * 3);
+        assert.strictEqual (buffer.primitives[0].uvs.length, 6 * 2);        
+    });
 
     it ('Mesh To Buffer Same Normals and UVs', function () {
         var mesh = new OV.Mesh ();
@@ -75,21 +75,21 @@ describe ('Mesh Buffer', function () {
         mesh.AddVertex (new OV.Coord3D (1.0, 0.0, 0.0));
         mesh.AddVertex (new OV.Coord3D (1.0, 1.0, 0.0));
         mesh.AddVertex (new OV.Coord3D (0.0, 1.0, 0.0));
-		mesh.AddNormal (new OV.Coord3D (0.0, 0.0, 1.0));
-		mesh.AddTextureUV (new OV.Coord3D (1.0, 1.0));
+        mesh.AddNormal (new OV.Coord3D (0.0, 0.0, 1.0));
+        mesh.AddTextureUV (new OV.Coord3D (1.0, 1.0));
         mesh.AddTriangle (new OV.Triangle (0, 1, 2).SetNormals (0, 0, 0).SetTextureUVs (0, 0, 0).SetMaterial (0));
-		mesh.AddTriangle (new OV.Triangle (0, 2, 3).SetNormals (0, 0, 0).SetTextureUVs (0, 0, 0).SetMaterial (0));
+        mesh.AddTriangle (new OV.Triangle (0, 2, 3).SetNormals (0, 0, 0).SetTextureUVs (0, 0, 0).SetMaterial (0));
 
-		let buffer = OV.ConvertMeshToMeshBuffer (mesh);
-		assert.strictEqual (buffer.primitives.length, 1);
-		assert.strictEqual (buffer.primitives[0].indices.length, 6);
-		assert.strictEqual (buffer.primitives[0].vertices.length, 4 * 3);
-		assert.strictEqual (buffer.primitives[0].normals.length, 4 * 3);
-		assert.strictEqual (buffer.primitives[0].uvs.length, 4 * 2);		
-	});
+        let buffer = OV.ConvertMeshToMeshBuffer (mesh);
+        assert.strictEqual (buffer.primitives.length, 1);
+        assert.strictEqual (buffer.primitives[0].indices.length, 6);
+        assert.strictEqual (buffer.primitives[0].vertices.length, 4 * 3);
+        assert.strictEqual (buffer.primitives[0].normals.length, 4 * 3);
+        assert.strictEqual (buffer.primitives[0].uvs.length, 4 * 2);        
+    });
 
     it ('Mesh To Buffer Cube', function () {
-		var model = new OV.Model ();
+        var model = new OV.Model ();
         var mesh = new OV.Mesh ();
 
         mesh.AddVertex (new OV.Coord3D (0.0, 0.0, 0.0));
@@ -101,42 +101,42 @@ describe ('Mesh Buffer', function () {
         mesh.AddVertex (new OV.Coord3D (1.0, 1.0, 1.0));
         mesh.AddVertex (new OV.Coord3D (0.0, 1.0, 1.0));
 
-		mesh.AddNormal (new OV.Coord3D (0, -1, 0));
-		mesh.AddNormal (new OV.Coord3D (1, 0, 0));
-		mesh.AddNormal (new OV.Coord3D (0, 1, 0));
-		mesh.AddNormal (new OV.Coord3D (-1, 0, 0));
-		mesh.AddNormal (new OV.Coord3D (0, 0, -1));
-		mesh.AddNormal (new OV.Coord3D (0, 0, 1));
+        mesh.AddNormal (new OV.Coord3D (0, -1, 0));
+        mesh.AddNormal (new OV.Coord3D (1, 0, 0));
+        mesh.AddNormal (new OV.Coord3D (0, 1, 0));
+        mesh.AddNormal (new OV.Coord3D (-1, 0, 0));
+        mesh.AddNormal (new OV.Coord3D (0, 0, -1));
+        mesh.AddNormal (new OV.Coord3D (0, 0, 1));
 
-		mesh.AddTriangle (new OV.Triangle (0, 1, 5).SetNormals (0, 0, 0));
-		mesh.AddTriangle (new OV.Triangle (0, 5, 4).SetNormals (0, 0, 0));
-		mesh.AddTriangle (new OV.Triangle (1, 2, 6).SetNormals (1, 1, 1));
-		mesh.AddTriangle (new OV.Triangle (1, 6, 5).SetNormals (1, 1, 1));
-		mesh.AddTriangle (new OV.Triangle (2, 3, 7).SetNormals (2, 2, 2));
-		mesh.AddTriangle (new OV.Triangle (2, 7, 6).SetNormals (2, 2, 2));
-		mesh.AddTriangle (new OV.Triangle (3, 0, 4).SetNormals (3, 3, 3));
-		mesh.AddTriangle (new OV.Triangle (3, 4, 7).SetNormals (3, 3, 3));
-		mesh.AddTriangle (new OV.Triangle (0, 3, 2).SetNormals (4, 4, 4));
-		mesh.AddTriangle (new OV.Triangle (0, 2, 1).SetNormals (4, 4, 4));
-		mesh.AddTriangle (new OV.Triangle (4, 5, 6).SetNormals (5, 5, 5));
-		mesh.AddTriangle (new OV.Triangle (4, 6, 7).SetNormals (5, 5, 5));
+        mesh.AddTriangle (new OV.Triangle (0, 1, 5).SetNormals (0, 0, 0));
+        mesh.AddTriangle (new OV.Triangle (0, 5, 4).SetNormals (0, 0, 0));
+        mesh.AddTriangle (new OV.Triangle (1, 2, 6).SetNormals (1, 1, 1));
+        mesh.AddTriangle (new OV.Triangle (1, 6, 5).SetNormals (1, 1, 1));
+        mesh.AddTriangle (new OV.Triangle (2, 3, 7).SetNormals (2, 2, 2));
+        mesh.AddTriangle (new OV.Triangle (2, 7, 6).SetNormals (2, 2, 2));
+        mesh.AddTriangle (new OV.Triangle (3, 0, 4).SetNormals (3, 3, 3));
+        mesh.AddTriangle (new OV.Triangle (3, 4, 7).SetNormals (3, 3, 3));
+        mesh.AddTriangle (new OV.Triangle (0, 3, 2).SetNormals (4, 4, 4));
+        mesh.AddTriangle (new OV.Triangle (0, 2, 1).SetNormals (4, 4, 4));
+        mesh.AddTriangle (new OV.Triangle (4, 5, 6).SetNormals (5, 5, 5));
+        mesh.AddTriangle (new OV.Triangle (4, 6, 7).SetNormals (5, 5, 5));
 
-		model.AddMesh (mesh);
-		OV.FinalizeModel (model, function () {
-			return new OV.Material ();
-		});
-		assert (OV.CheckModel (model));
+        model.AddMesh (mesh);
+        OV.FinalizeModel (model, function () {
+            return new OV.Material ();
+        });
+        assert (OV.CheckModel (model));
 
-		let buffer = OV.ConvertMeshToMeshBuffer (mesh);
-		assert.strictEqual (buffer.primitives.length, 1);
-		assert.strictEqual (buffer.primitives[0].indices.length, 36);
-		assert.strictEqual (buffer.primitives[0].vertices.length, 24 * 3);
-		assert.strictEqual (buffer.primitives[0].normals.length, 24 * 3);
-		assert.strictEqual (buffer.primitives[0].uvs.length, 0);				
-	});
+        let buffer = OV.ConvertMeshToMeshBuffer (mesh);
+        assert.strictEqual (buffer.primitives.length, 1);
+        assert.strictEqual (buffer.primitives[0].indices.length, 36);
+        assert.strictEqual (buffer.primitives[0].vertices.length, 24 * 3);
+        assert.strictEqual (buffer.primitives[0].normals.length, 24 * 3);
+        assert.strictEqual (buffer.primitives[0].uvs.length, 0);                
+    });
 
     it ('Mesh To Buffer Cube Auto Normals', function () {
-		var model = new OV.Model ();
+        var model = new OV.Model ();
         var mesh = new OV.Mesh ();
 
         mesh.AddVertex (new OV.Coord3D (0.0, 0.0, 0.0));
@@ -148,37 +148,37 @@ describe ('Mesh Buffer', function () {
         mesh.AddVertex (new OV.Coord3D (1.0, 1.0, 1.0));
         mesh.AddVertex (new OV.Coord3D (0.0, 1.0, 1.0));
 
-		mesh.AddTriangle (new OV.Triangle (0, 1, 5));
-		mesh.AddTriangle (new OV.Triangle (0, 5, 4));
-		mesh.AddTriangle (new OV.Triangle (1, 2, 6));
-		mesh.AddTriangle (new OV.Triangle (1, 6, 5));
-		mesh.AddTriangle (new OV.Triangle (2, 3, 7));
-		mesh.AddTriangle (new OV.Triangle (2, 7, 6));
-		mesh.AddTriangle (new OV.Triangle (3, 0, 4));
-		mesh.AddTriangle (new OV.Triangle (3, 4, 7));
-		mesh.AddTriangle (new OV.Triangle (0, 3, 2));
-		mesh.AddTriangle (new OV.Triangle (0, 2, 1));
-		mesh.AddTriangle (new OV.Triangle (4, 5, 6));
-		mesh.AddTriangle (new OV.Triangle (4, 6, 7));
+        mesh.AddTriangle (new OV.Triangle (0, 1, 5));
+        mesh.AddTriangle (new OV.Triangle (0, 5, 4));
+        mesh.AddTriangle (new OV.Triangle (1, 2, 6));
+        mesh.AddTriangle (new OV.Triangle (1, 6, 5));
+        mesh.AddTriangle (new OV.Triangle (2, 3, 7));
+        mesh.AddTriangle (new OV.Triangle (2, 7, 6));
+        mesh.AddTriangle (new OV.Triangle (3, 0, 4));
+        mesh.AddTriangle (new OV.Triangle (3, 4, 7));
+        mesh.AddTriangle (new OV.Triangle (0, 3, 2));
+        mesh.AddTriangle (new OV.Triangle (0, 2, 1));
+        mesh.AddTriangle (new OV.Triangle (4, 5, 6));
+        mesh.AddTriangle (new OV.Triangle (4, 6, 7));
 
-		model.AddMesh (mesh);
-		OV.FinalizeModel (model, function () {
-			return new OV.Material ();
-		});
-		assert (OV.CheckModel (model));
+        model.AddMesh (mesh);
+        OV.FinalizeModel (model, function () {
+            return new OV.Material ();
+        });
+        assert (OV.CheckModel (model));
 
-		let buffer = OV.ConvertMeshToMeshBuffer (mesh);
-		assert.strictEqual (buffer.primitives.length, 1);
-		assert.strictEqual (buffer.primitives[0].indices.length, 36);
-		assert.strictEqual (buffer.primitives[0].vertices.length, 24 * 3);
-		assert.strictEqual (buffer.primitives[0].normals.length, 24 * 3);
-		assert.strictEqual (buffer.primitives[0].uvs.length, 0);
-		assert.strictEqual (buffer.primitives[0].GetByteLength (2, 4), 36 * 2 + 2 * 24 * 3 * 4);
-		assert.strictEqual (buffer.GetByteLength (2, 4), 36 * 2 + 2 * 24 * 3 * 4);
-	});
+        let buffer = OV.ConvertMeshToMeshBuffer (mesh);
+        assert.strictEqual (buffer.primitives.length, 1);
+        assert.strictEqual (buffer.primitives[0].indices.length, 36);
+        assert.strictEqual (buffer.primitives[0].vertices.length, 24 * 3);
+        assert.strictEqual (buffer.primitives[0].normals.length, 24 * 3);
+        assert.strictEqual (buffer.primitives[0].uvs.length, 0);
+        assert.strictEqual (buffer.primitives[0].GetByteLength (2, 4), 36 * 2 + 2 * 24 * 3 * 4);
+        assert.strictEqual (buffer.GetByteLength (2, 4), 36 * 2 + 2 * 24 * 3 * 4);
+    });
 
     it ('Mesh To Buffer Cube Auto Curve Normals', function () {
-		var model = new OV.Model ();
+        var model = new OV.Model ();
         var mesh = new OV.Mesh ();
 
         mesh.AddVertex (new OV.Coord3D (0.0, 0.0, 0.0));
@@ -190,37 +190,37 @@ describe ('Mesh Buffer', function () {
         mesh.AddVertex (new OV.Coord3D (1.0, 1.0, 1.0));
         mesh.AddVertex (new OV.Coord3D (0.0, 1.0, 1.0));
 
-		mesh.AddTriangle (new OV.Triangle (0, 1, 5).SetCurve (1));
-		mesh.AddTriangle (new OV.Triangle (0, 5, 4).SetCurve (1));
-		mesh.AddTriangle (new OV.Triangle (1, 2, 6).SetCurve (1));
-		mesh.AddTriangle (new OV.Triangle (1, 6, 5).SetCurve (1));
-		mesh.AddTriangle (new OV.Triangle (2, 3, 7).SetCurve (1));
-		mesh.AddTriangle (new OV.Triangle (2, 7, 6).SetCurve (1));
-		mesh.AddTriangle (new OV.Triangle (3, 0, 4).SetCurve (1));
-		mesh.AddTriangle (new OV.Triangle (3, 4, 7).SetCurve (1));
-		mesh.AddTriangle (new OV.Triangle (0, 3, 2).SetCurve (1));
-		mesh.AddTriangle (new OV.Triangle (0, 2, 1).SetCurve (1));
-		mesh.AddTriangle (new OV.Triangle (4, 5, 6).SetCurve (1));
-		mesh.AddTriangle (new OV.Triangle (4, 6, 7).SetCurve (1));
+        mesh.AddTriangle (new OV.Triangle (0, 1, 5).SetCurve (1));
+        mesh.AddTriangle (new OV.Triangle (0, 5, 4).SetCurve (1));
+        mesh.AddTriangle (new OV.Triangle (1, 2, 6).SetCurve (1));
+        mesh.AddTriangle (new OV.Triangle (1, 6, 5).SetCurve (1));
+        mesh.AddTriangle (new OV.Triangle (2, 3, 7).SetCurve (1));
+        mesh.AddTriangle (new OV.Triangle (2, 7, 6).SetCurve (1));
+        mesh.AddTriangle (new OV.Triangle (3, 0, 4).SetCurve (1));
+        mesh.AddTriangle (new OV.Triangle (3, 4, 7).SetCurve (1));
+        mesh.AddTriangle (new OV.Triangle (0, 3, 2).SetCurve (1));
+        mesh.AddTriangle (new OV.Triangle (0, 2, 1).SetCurve (1));
+        mesh.AddTriangle (new OV.Triangle (4, 5, 6).SetCurve (1));
+        mesh.AddTriangle (new OV.Triangle (4, 6, 7).SetCurve (1));
 
-		model.AddMesh (mesh);
-		OV.FinalizeModel (model, function () {
-			return new OV.Material ();
-		});
-		assert (OV.CheckModel (model));
+        model.AddMesh (mesh);
+        OV.FinalizeModel (model, function () {
+            return new OV.Material ();
+        });
+        assert (OV.CheckModel (model));
 
-		let buffer = OV.ConvertMeshToMeshBuffer (mesh);
-		assert.strictEqual (buffer.primitives.length, 1);
-		assert.strictEqual (buffer.primitives[0].indices.length, 36);
-		assert.strictEqual (buffer.primitives[0].vertices.length, 8 * 3);
-		assert.strictEqual (buffer.primitives[0].normals.length, 8 * 3);
-		assert.strictEqual (buffer.primitives[0].uvs.length, 0);
-		assert.strictEqual (buffer.primitives[0].GetByteLength (2, 4), 36 * 2 + 2 * 8 * 3 * 4);
-		assert.strictEqual (buffer.GetByteLength (2, 4), 36 * 2 + 2 * 8 * 3 * 4);
-	});    
+        let buffer = OV.ConvertMeshToMeshBuffer (mesh);
+        assert.strictEqual (buffer.primitives.length, 1);
+        assert.strictEqual (buffer.primitives[0].indices.length, 36);
+        assert.strictEqual (buffer.primitives[0].vertices.length, 8 * 3);
+        assert.strictEqual (buffer.primitives[0].normals.length, 8 * 3);
+        assert.strictEqual (buffer.primitives[0].uvs.length, 0);
+        assert.strictEqual (buffer.primitives[0].GetByteLength (2, 4), 36 * 2 + 2 * 8 * 3 * 4);
+        assert.strictEqual (buffer.GetByteLength (2, 4), 36 * 2 + 2 * 8 * 3 * 4);
+    });    
 
     it ('Mesh To Buffer Cube Materials', function () {
-		var model = new OV.Model ();
+        var model = new OV.Model ();
         model.AddMaterial (new OV.Material ());
         model.AddMaterial (new OV.Material ());
         var mesh = new OV.Mesh ();
@@ -234,42 +234,42 @@ describe ('Mesh Buffer', function () {
         mesh.AddVertex (new OV.Coord3D (1.0, 1.0, 1.0));
         mesh.AddVertex (new OV.Coord3D (0.0, 1.0, 1.0));
 
-		mesh.AddTriangle (new OV.Triangle (0, 1, 5).SetMaterial (0));
-		mesh.AddTriangle (new OV.Triangle (0, 5, 4).SetMaterial (0));
-		mesh.AddTriangle (new OV.Triangle (1, 2, 6).SetMaterial (0));
-		mesh.AddTriangle (new OV.Triangle (1, 6, 5).SetMaterial (0));
-		mesh.AddTriangle (new OV.Triangle (2, 3, 7).SetMaterial (0));
-		mesh.AddTriangle (new OV.Triangle (2, 7, 6).SetMaterial (0));
-		mesh.AddTriangle (new OV.Triangle (3, 0, 4).SetMaterial (1));
-		mesh.AddTriangle (new OV.Triangle (3, 4, 7).SetMaterial (1));
-		mesh.AddTriangle (new OV.Triangle (0, 3, 2).SetMaterial (1));
-		mesh.AddTriangle (new OV.Triangle (0, 2, 1).SetMaterial (1));
-		mesh.AddTriangle (new OV.Triangle (4, 5, 6).SetMaterial (1));
-		mesh.AddTriangle (new OV.Triangle (4, 6, 7).SetMaterial (1));
+        mesh.AddTriangle (new OV.Triangle (0, 1, 5).SetMaterial (0));
+        mesh.AddTriangle (new OV.Triangle (0, 5, 4).SetMaterial (0));
+        mesh.AddTriangle (new OV.Triangle (1, 2, 6).SetMaterial (0));
+        mesh.AddTriangle (new OV.Triangle (1, 6, 5).SetMaterial (0));
+        mesh.AddTriangle (new OV.Triangle (2, 3, 7).SetMaterial (0));
+        mesh.AddTriangle (new OV.Triangle (2, 7, 6).SetMaterial (0));
+        mesh.AddTriangle (new OV.Triangle (3, 0, 4).SetMaterial (1));
+        mesh.AddTriangle (new OV.Triangle (3, 4, 7).SetMaterial (1));
+        mesh.AddTriangle (new OV.Triangle (0, 3, 2).SetMaterial (1));
+        mesh.AddTriangle (new OV.Triangle (0, 2, 1).SetMaterial (1));
+        mesh.AddTriangle (new OV.Triangle (4, 5, 6).SetMaterial (1));
+        mesh.AddTriangle (new OV.Triangle (4, 6, 7).SetMaterial (1));
 
-		model.AddMesh (mesh);
-		OV.FinalizeModel (model, function () {
-			return new OV.Material ();
-		});
-		assert (OV.CheckModel (model));
+        model.AddMesh (mesh);
+        OV.FinalizeModel (model, function () {
+            return new OV.Material ();
+        });
+        assert (OV.CheckModel (model));
 
-		let buffer = OV.ConvertMeshToMeshBuffer (mesh);
-		assert.strictEqual (buffer.primitives.length, 2);
-		assert.strictEqual (buffer.primitives[0].indices.length, 18);
-		assert.strictEqual (buffer.primitives[0].vertices.length, 12 * 3);
-		assert.strictEqual (buffer.primitives[0].normals.length, 12 * 3);
-		assert.strictEqual (buffer.primitives[0].uvs.length, 0);
-		assert.strictEqual (buffer.primitives[0].GetByteLength (2, 4), 18 * 2 + 2 * 12 * 3 * 4);
-		assert.strictEqual (buffer.primitives[1].indices.length, 18);
-		assert.strictEqual (buffer.primitives[1].vertices.length, 12 * 3);
-		assert.strictEqual (buffer.primitives[1].normals.length, 12 * 3);
-		assert.strictEqual (buffer.primitives[1].uvs.length, 0);
-		assert.strictEqual (buffer.primitives[1].GetByteLength (2, 4), 18 * 2 + 2 * 12 * 3 * 4);
-		assert.strictEqual (buffer.GetByteLength (2, 4), 36 * 2 + 2 * 24 * 3 * 4);
-	});    
+        let buffer = OV.ConvertMeshToMeshBuffer (mesh);
+        assert.strictEqual (buffer.primitives.length, 2);
+        assert.strictEqual (buffer.primitives[0].indices.length, 18);
+        assert.strictEqual (buffer.primitives[0].vertices.length, 12 * 3);
+        assert.strictEqual (buffer.primitives[0].normals.length, 12 * 3);
+        assert.strictEqual (buffer.primitives[0].uvs.length, 0);
+        assert.strictEqual (buffer.primitives[0].GetByteLength (2, 4), 18 * 2 + 2 * 12 * 3 * 4);
+        assert.strictEqual (buffer.primitives[1].indices.length, 18);
+        assert.strictEqual (buffer.primitives[1].vertices.length, 12 * 3);
+        assert.strictEqual (buffer.primitives[1].normals.length, 12 * 3);
+        assert.strictEqual (buffer.primitives[1].uvs.length, 0);
+        assert.strictEqual (buffer.primitives[1].GetByteLength (2, 4), 18 * 2 + 2 * 12 * 3 * 4);
+        assert.strictEqual (buffer.GetByteLength (2, 4), 36 * 2 + 2 * 24 * 3 * 4);
+    });    
 
-	it ('Mesh To Buffer Cube One UV', function () {
-		var model = new OV.Model ();
+    it ('Mesh To Buffer Cube One UV', function () {
+        var model = new OV.Model ();
         var mesh = new OV.Mesh ();
 
         mesh.AddVertex (new OV.Coord3D (0.0, 0.0, 0.0));
@@ -280,39 +280,39 @@ describe ('Mesh Buffer', function () {
         mesh.AddVertex (new OV.Coord3D (1.0, 0.0, 1.0));
         mesh.AddVertex (new OV.Coord3D (1.0, 1.0, 1.0));
         mesh.AddVertex (new OV.Coord3D (0.0, 1.0, 1.0));
-		mesh.AddTextureUV (new OV.Coord2D (0.0, 0.0));
-		mesh.AddTextureUV (new OV.Coord2D (1.0, 0.0));
-		mesh.AddTextureUV (new OV.Coord2D (1.0, 1.0));
+        mesh.AddTextureUV (new OV.Coord2D (0.0, 0.0));
+        mesh.AddTextureUV (new OV.Coord2D (1.0, 0.0));
+        mesh.AddTextureUV (new OV.Coord2D (1.0, 1.0));
 
-		mesh.AddTriangle (new OV.Triangle (0, 1, 5));
-		mesh.AddTriangle (new OV.Triangle (0, 5, 4));
-		mesh.AddTriangle (new OV.Triangle (1, 2, 6).SetTextureUVs (0, 1, 2));
-		mesh.AddTriangle (new OV.Triangle (1, 6, 5));
-		mesh.AddTriangle (new OV.Triangle (2, 3, 7));
-		mesh.AddTriangle (new OV.Triangle (2, 7, 6));
-		mesh.AddTriangle (new OV.Triangle (3, 0, 4));
-		mesh.AddTriangle (new OV.Triangle (3, 4, 7));
-		mesh.AddTriangle (new OV.Triangle (0, 3, 2));
-		mesh.AddTriangle (new OV.Triangle (0, 2, 1));
-		mesh.AddTriangle (new OV.Triangle (4, 5, 6));
-		mesh.AddTriangle (new OV.Triangle (4, 6, 7));
+        mesh.AddTriangle (new OV.Triangle (0, 1, 5));
+        mesh.AddTriangle (new OV.Triangle (0, 5, 4));
+        mesh.AddTriangle (new OV.Triangle (1, 2, 6).SetTextureUVs (0, 1, 2));
+        mesh.AddTriangle (new OV.Triangle (1, 6, 5));
+        mesh.AddTriangle (new OV.Triangle (2, 3, 7));
+        mesh.AddTriangle (new OV.Triangle (2, 7, 6));
+        mesh.AddTriangle (new OV.Triangle (3, 0, 4));
+        mesh.AddTriangle (new OV.Triangle (3, 4, 7));
+        mesh.AddTriangle (new OV.Triangle (0, 3, 2));
+        mesh.AddTriangle (new OV.Triangle (0, 2, 1));
+        mesh.AddTriangle (new OV.Triangle (4, 5, 6));
+        mesh.AddTriangle (new OV.Triangle (4, 6, 7));
 
-		model.AddMesh (mesh);
-		OV.FinalizeModel (model, function () {
-			return new OV.Material ();
-		});
-		assert (OV.CheckModel (model));
+        model.AddMesh (mesh);
+        OV.FinalizeModel (model, function () {
+            return new OV.Material ();
+        });
+        assert (OV.CheckModel (model));
 
-		let buffer = OV.ConvertMeshToMeshBuffer (mesh);
-		assert.strictEqual (buffer.primitives.length, 1);
-		assert.strictEqual (buffer.primitives[0].indices.length, 36);
-		assert.strictEqual (buffer.primitives[0].vertices.length, 25 * 3);
-		assert.strictEqual (buffer.primitives[0].normals.length, 25 * 3);
-		assert.strictEqual (buffer.primitives[0].uvs.length, 25 * 2);
-	});
+        let buffer = OV.ConvertMeshToMeshBuffer (mesh);
+        assert.strictEqual (buffer.primitives.length, 1);
+        assert.strictEqual (buffer.primitives[0].indices.length, 36);
+        assert.strictEqual (buffer.primitives[0].vertices.length, 25 * 3);
+        assert.strictEqual (buffer.primitives[0].normals.length, 25 * 3);
+        assert.strictEqual (buffer.primitives[0].uvs.length, 25 * 2);
+    });
 
-	it ('Mesh To Buffer Cube All UVs', function () {
-		var model = new OV.Model ();
+    it ('Mesh To Buffer Cube All UVs', function () {
+        var model = new OV.Model ();
         var mesh = new OV.Mesh ();
 
         mesh.AddVertex (new OV.Coord3D (0.0, 0.0, 0.0));
@@ -323,34 +323,34 @@ describe ('Mesh Buffer', function () {
         mesh.AddVertex (new OV.Coord3D (1.0, 0.0, 1.0));
         mesh.AddVertex (new OV.Coord3D (1.0, 1.0, 1.0));
         mesh.AddVertex (new OV.Coord3D (0.0, 1.0, 1.0));
-		mesh.AddTextureUV (new OV.Coord2D (0.0, 0.0));
-		mesh.AddTextureUV (new OV.Coord2D (1.0, 0.0));
-		mesh.AddTextureUV (new OV.Coord2D (1.0, 1.0));
+        mesh.AddTextureUV (new OV.Coord2D (0.0, 0.0));
+        mesh.AddTextureUV (new OV.Coord2D (1.0, 0.0));
+        mesh.AddTextureUV (new OV.Coord2D (1.0, 1.0));
 
-		mesh.AddTriangle (new OV.Triangle (0, 1, 5).SetTextureUVs (0, 1, 2));
-		mesh.AddTriangle (new OV.Triangle (0, 5, 4).SetTextureUVs (0, 1, 2));
-		mesh.AddTriangle (new OV.Triangle (1, 2, 6).SetTextureUVs (0, 1, 2));
-		mesh.AddTriangle (new OV.Triangle (1, 6, 5).SetTextureUVs (0, 1, 2));
-		mesh.AddTriangle (new OV.Triangle (2, 3, 7).SetTextureUVs (0, 1, 2));
-		mesh.AddTriangle (new OV.Triangle (2, 7, 6).SetTextureUVs (0, 1, 2));
-		mesh.AddTriangle (new OV.Triangle (3, 0, 4).SetTextureUVs (0, 1, 2));
-		mesh.AddTriangle (new OV.Triangle (3, 4, 7).SetTextureUVs (0, 1, 2));
-		mesh.AddTriangle (new OV.Triangle (0, 3, 2).SetTextureUVs (0, 1, 2));
-		mesh.AddTriangle (new OV.Triangle (0, 2, 1).SetTextureUVs (0, 1, 2));
-		mesh.AddTriangle (new OV.Triangle (4, 5, 6).SetTextureUVs (0, 1, 2));
-		mesh.AddTriangle (new OV.Triangle (4, 6, 7).SetTextureUVs (0, 1, 2));
+        mesh.AddTriangle (new OV.Triangle (0, 1, 5).SetTextureUVs (0, 1, 2));
+        mesh.AddTriangle (new OV.Triangle (0, 5, 4).SetTextureUVs (0, 1, 2));
+        mesh.AddTriangle (new OV.Triangle (1, 2, 6).SetTextureUVs (0, 1, 2));
+        mesh.AddTriangle (new OV.Triangle (1, 6, 5).SetTextureUVs (0, 1, 2));
+        mesh.AddTriangle (new OV.Triangle (2, 3, 7).SetTextureUVs (0, 1, 2));
+        mesh.AddTriangle (new OV.Triangle (2, 7, 6).SetTextureUVs (0, 1, 2));
+        mesh.AddTriangle (new OV.Triangle (3, 0, 4).SetTextureUVs (0, 1, 2));
+        mesh.AddTriangle (new OV.Triangle (3, 4, 7).SetTextureUVs (0, 1, 2));
+        mesh.AddTriangle (new OV.Triangle (0, 3, 2).SetTextureUVs (0, 1, 2));
+        mesh.AddTriangle (new OV.Triangle (0, 2, 1).SetTextureUVs (0, 1, 2));
+        mesh.AddTriangle (new OV.Triangle (4, 5, 6).SetTextureUVs (0, 1, 2));
+        mesh.AddTriangle (new OV.Triangle (4, 6, 7).SetTextureUVs (0, 1, 2));
 
-		model.AddMesh (mesh);
-		OV.FinalizeModel (model, function () {
-			return new OV.Material ();
-		});
-		assert (OV.CheckModel (model));
+        model.AddMesh (mesh);
+        OV.FinalizeModel (model, function () {
+            return new OV.Material ();
+        });
+        assert (OV.CheckModel (model));
 
-		let buffer = OV.ConvertMeshToMeshBuffer (mesh);
-		assert.strictEqual (buffer.primitives.length, 1);
-		assert.strictEqual (buffer.primitives[0].indices.length, 36);
-		assert.strictEqual (buffer.primitives[0].vertices.length, 30 * 3);
-		assert.strictEqual (buffer.primitives[0].normals.length, 30 * 3);
-		assert.strictEqual (buffer.primitives[0].uvs.length, 30 * 2);
-	});		
+        let buffer = OV.ConvertMeshToMeshBuffer (mesh);
+        assert.strictEqual (buffer.primitives.length, 1);
+        assert.strictEqual (buffer.primitives[0].indices.length, 36);
+        assert.strictEqual (buffer.primitives[0].vertices.length, 30 * 3);
+        assert.strictEqual (buffer.primitives[0].normals.length, 30 * 3);
+        assert.strictEqual (buffer.primitives[0].uvs.length, 30 * 2);
+    });        
 });

test/tests/model_test.js

@@ -1,152 +1,152 @@
 var assert = require ('assert');
 
 describe ('Model', function() {
-	it ('Default Initialization', function () {
-		var model = new OV.Model ();
-		assert.strictEqual (model.MaterialCount (), 0);
-		assert.strictEqual (model.MeshCount (), 0);
-	});
+    it ('Default Initialization', function () {
+        var model = new OV.Model ();
+        assert.strictEqual (model.MaterialCount (), 0);
+        assert.strictEqual (model.MeshCount (), 0);
+    });
 
-	it ('Add Material', function () {
-		var model = new OV.Model ();
-		var material = new OV.Material ();
-		material.name = 'example';
-		var index = model.AddMaterial (material);
-		assert.strictEqual (model.MaterialCount (), 1);
-		var theMaterial = model.GetMaterial (index);
-		assert.strictEqual (theMaterial.name, 'example');
-	});
+    it ('Add Material', function () {
+        var model = new OV.Model ();
+        var material = new OV.Material ();
+        material.name = 'example';
+        var index = model.AddMaterial (material);
+        assert.strictEqual (model.MaterialCount (), 1);
+        var theMaterial = model.GetMaterial (index);
+        assert.strictEqual (theMaterial.name, 'example');
+    });
 
-	it ('Add Mesh', function () {
-		var model = new OV.Model ();
-		var mesh = new OV.Mesh ();
-		mesh.SetName ('example');
-		var index = model.AddMesh (mesh);
-		assert.strictEqual (model.MeshCount (), 1);
-		var theMesh = model.GetMesh (index);
-		assert.strictEqual (theMesh.GetName (), 'example');
-	});
+    it ('Add Mesh', function () {
+        var model = new OV.Model ();
+        var mesh = new OV.Mesh ();
+        mesh.SetName ('example');
+        var index = model.AddMesh (mesh);
+        assert.strictEqual (model.MeshCount (), 1);
+        var theMesh = model.GetMesh (index);
+        assert.strictEqual (theMesh.GetName (), 'example');
+    });
 
-	it ('Add Mesh To Index', function () {
-		var model = new OV.Model ();
-		var mesh1 = new OV.Mesh ();
-		var mesh2 = new OV.Mesh ();
-		var mesh3 = new OV.Mesh ();
-		var mesh4 = new OV.Mesh ();
-		mesh1.SetName ('A');
-		mesh2.SetName ('B');
-		mesh3.SetName ('C');
-		mesh4.SetName ('D');
-		model.AddMesh (mesh1);
-		model.AddMesh (mesh2);
-		model.AddMeshToIndex (mesh3, 1);
-		model.AddMeshToIndex (mesh4, 3);
-		assert.strictEqual (model.GetMesh (0).GetName (), 'A');
-		assert.strictEqual (model.GetMesh (1).GetName (), 'C');
-		assert.strictEqual (model.GetMesh (2).GetName (), 'B');
-		assert.strictEqual (model.GetMesh (3).GetName (), 'D');
-	});
+    it ('Add Mesh To Index', function () {
+        var model = new OV.Model ();
+        var mesh1 = new OV.Mesh ();
+        var mesh2 = new OV.Mesh ();
+        var mesh3 = new OV.Mesh ();
+        var mesh4 = new OV.Mesh ();
+        mesh1.SetName ('A');
+        mesh2.SetName ('B');
+        mesh3.SetName ('C');
+        mesh4.SetName ('D');
+        model.AddMesh (mesh1);
+        model.AddMesh (mesh2);
+        model.AddMeshToIndex (mesh3, 1);
+        model.AddMeshToIndex (mesh4, 3);
+        assert.strictEqual (model.GetMesh (0).GetName (), 'A');
+        assert.strictEqual (model.GetMesh (1).GetName (), 'C');
+        assert.strictEqual (model.GetMesh (2).GetName (), 'B');
+        assert.strictEqual (model.GetMesh (3).GetName (), 'D');
+    });
 
-	it ('Counters', function () {
-		var model = new OV.Model ();
-		let mesh = new OV.Mesh ();
-		mesh.AddVertex (new OV.Coord3D (0.0, 0.0, 0.0));
-		mesh.AddVertex (new OV.Coord3D (0.0, 0.0, 0.0));
-		mesh.AddVertex (new OV.Coord3D (0.0, 0.0, 0.0));
-		mesh.AddNormal (new OV.Coord3D (0.0, 0.0, 0.0));
-		mesh.AddNormal (new OV.Coord3D (0.0, 0.0, 0.0));
-		mesh.AddTextureUV (new OV.Coord2D (0.0, 0.0));
-		mesh.AddTriangle (new OV.Triangle (0, 1, 2));
-		mesh.AddTriangle (new OV.Triangle (0, 1, 2));
-		mesh.AddTriangle (new OV.Triangle (0, 1, 2));
-		mesh.AddTriangle (new OV.Triangle (0, 1, 2));
-		model.AddMesh (mesh);
-		assert.strictEqual (model.VertexCount (), 3);
-		assert.strictEqual (model.NormalCount (), 2);
-		assert.strictEqual (model.TextureUVCount (), 1);
-		assert.strictEqual (model.TriangleCount (), 4);
-	});
+    it ('Counters', function () {
+        var model = new OV.Model ();
+        let mesh = new OV.Mesh ();
+        mesh.AddVertex (new OV.Coord3D (0.0, 0.0, 0.0));
+        mesh.AddVertex (new OV.Coord3D (0.0, 0.0, 0.0));
+        mesh.AddVertex (new OV.Coord3D (0.0, 0.0, 0.0));
+        mesh.AddNormal (new OV.Coord3D (0.0, 0.0, 0.0));
+        mesh.AddNormal (new OV.Coord3D (0.0, 0.0, 0.0));
+        mesh.AddTextureUV (new OV.Coord2D (0.0, 0.0));
+        mesh.AddTriangle (new OV.Triangle (0, 1, 2));
+        mesh.AddTriangle (new OV.Triangle (0, 1, 2));
+        mesh.AddTriangle (new OV.Triangle (0, 1, 2));
+        mesh.AddTriangle (new OV.Triangle (0, 1, 2));
+        model.AddMesh (mesh);
+        assert.strictEqual (model.VertexCount (), 3);
+        assert.strictEqual (model.NormalCount (), 2);
+        assert.strictEqual (model.TextureUVCount (), 1);
+        assert.strictEqual (model.TriangleCount (), 4);
+    });
 
-	it ('Remove Mesh', function () {
-		var model = new OV.Model ();
-		
-		let mesh1 = new OV.Mesh ();
-		mesh1.AddVertex (new OV.Coord3D (0.0, 0.0, 0.0));
-		mesh1.AddVertex (new OV.Coord3D (1.0, 0.0, 0.0));
-		mesh1.AddVertex (new OV.Coord3D (1.0, 1.0, 0.0));
-		mesh1.AddTriangle (new OV.Triangle (0, 1, 2));
-		model.AddMesh (mesh1);
+    it ('Remove Mesh', function () {
+        var model = new OV.Model ();
+        
+        let mesh1 = new OV.Mesh ();
+        mesh1.AddVertex (new OV.Coord3D (0.0, 0.0, 0.0));
+        mesh1.AddVertex (new OV.Coord3D (1.0, 0.0, 0.0));
+        mesh1.AddVertex (new OV.Coord3D (1.0, 1.0, 0.0));
+        mesh1.AddTriangle (new OV.Triangle (0, 1, 2));
+        model.AddMesh (mesh1);
 
-		let mesh2 = new OV.Mesh ();
-		mesh2.AddVertex (new OV.Coord3D (0.0, 0.0, 1.0));
-		mesh2.AddVertex (new OV.Coord3D (1.0, 0.0, 1.0));
-		mesh2.AddVertex (new OV.Coord3D (1.0, 1.0, 1.0));
-		mesh2.AddTriangle (new OV.Triangle (0, 1, 2));
-		model.AddMesh (mesh2);
+        let mesh2 = new OV.Mesh ();
+        mesh2.AddVertex (new OV.Coord3D (0.0, 0.0, 1.0));
+        mesh2.AddVertex (new OV.Coord3D (1.0, 0.0, 1.0));
+        mesh2.AddVertex (new OV.Coord3D (1.0, 1.0, 1.0));
+        mesh2.AddTriangle (new OV.Triangle (0, 1, 2));
+        model.AddMesh (mesh2);
 
-		assert.strictEqual (model.MeshCount (), 2);
-		assert.strictEqual (model.VertexCount (), 6);
-		assert.strictEqual (model.TriangleCount (), 2);
+        assert.strictEqual (model.MeshCount (), 2);
+        assert.strictEqual (model.VertexCount (), 6);
+        assert.strictEqual (model.TriangleCount (), 2);
 
-		model.RemoveMesh (0);
-		assert.strictEqual (model.MeshCount (), 1);
-		assert.strictEqual (model.VertexCount (), 3);
-		assert.strictEqual (model.TriangleCount (), 1);
+        model.RemoveMesh (0);
+        assert.strictEqual (model.MeshCount (), 1);
+        assert.strictEqual (model.VertexCount (), 3);
+        assert.strictEqual (model.TriangleCount (), 1);
 
-		model.RemoveMesh (0);
-		assert.strictEqual (model.MeshCount (), 0);
-		assert.strictEqual (model.VertexCount (), 0);
-		assert.strictEqual (model.TriangleCount (), 0);
-	});	
+        model.RemoveMesh (0);
+        assert.strictEqual (model.MeshCount (), 0);
+        assert.strictEqual (model.VertexCount (), 0);
+        assert.strictEqual (model.TriangleCount (), 0);
+    });    
 });
 
 describe ('Model Finalization', function() {
-	it ('Calculate Normal', function () {
-		var mesh = new OV.Mesh ();
-		var v0 = mesh.AddVertex (new OV.Coord3D (0.0, 0.0, 0.0));
-		var v1 = mesh.AddVertex (new OV.Coord3D (1.0, 0.0, 0.0));
-		var v2 = mesh.AddVertex (new OV.Coord3D (1.0, 1.0, 0.0));
-		var triangleIndex = mesh.AddTriangle (new OV.Triangle (v0, v1, v2));
-		var model = new OV.Model ();
-		var meshIndex = model.AddMesh (mesh);
-		assert.strictEqual (model.MaterialCount (), 0);
-		OV.FinalizeModel (model, function () { new OV.Material () });
-		assert.strictEqual (model.MaterialCount (), 1);
-		var theMesh = model.GetMesh (meshIndex);
-		assert.strictEqual (theMesh.NormalCount (), 1);
-		var triangle = theMesh.GetTriangle (triangleIndex);
-		assert.strictEqual (triangle.n0, 0);
-		assert.strictEqual (triangle.n1, 0);
-		assert.strictEqual (triangle.n2, 0);
-		assert.strictEqual (triangle.mat, 0);
-	});
+    it ('Calculate Normal', function () {
+        var mesh = new OV.Mesh ();
+        var v0 = mesh.AddVertex (new OV.Coord3D (0.0, 0.0, 0.0));
+        var v1 = mesh.AddVertex (new OV.Coord3D (1.0, 0.0, 0.0));
+        var v2 = mesh.AddVertex (new OV.Coord3D (1.0, 1.0, 0.0));
+        var triangleIndex = mesh.AddTriangle (new OV.Triangle (v0, v1, v2));
+        var model = new OV.Model ();
+        var meshIndex = model.AddMesh (mesh);
+        assert.strictEqual (model.MaterialCount (), 0);
+        OV.FinalizeModel (model, function () { new OV.Material () });
+        assert.strictEqual (model.MaterialCount (), 1);
+        var theMesh = model.GetMesh (meshIndex);
+        assert.strictEqual (theMesh.NormalCount (), 1);
+        var triangle = theMesh.GetTriangle (triangleIndex);
+        assert.strictEqual (triangle.n0, 0);
+        assert.strictEqual (triangle.n1, 0);
+        assert.strictEqual (triangle.n2, 0);
+        assert.strictEqual (triangle.mat, 0);
+    });
 
-	it ('Calculate Curved Normal', function () {
-		var mesh = new OV.Mesh ();
-		var v0 = mesh.AddVertex (new OV.Coord3D (0.0, 0.0, 0.0));
-		var v1 = mesh.AddVertex (new OV.Coord3D (1.0, 0.0, 0.0));
-		var v2 = mesh.AddVertex (new OV.Coord3D (1.0, 1.0, 0.0));
-		var v3 = mesh.AddVertex (new OV.Coord3D (0.0, 0.0, -1.0));
+    it ('Calculate Curved Normal', function () {
+        var mesh = new OV.Mesh ();
+        var v0 = mesh.AddVertex (new OV.Coord3D (0.0, 0.0, 0.0));
+        var v1 = mesh.AddVertex (new OV.Coord3D (1.0, 0.0, 0.0));
+        var v2 = mesh.AddVertex (new OV.Coord3D (1.0, 1.0, 0.0));
+        var v3 = mesh.AddVertex (new OV.Coord3D (0.0, 0.0, -1.0));
 
-		var triangle1 = new OV.Triangle (v0, v1, v2);
-		triangle1.curve = 1;
-		var triangle2 = new OV.Triangle (v0, v3, v1);
-		triangle2.curve = 1;
+        var triangle1 = new OV.Triangle (v0, v1, v2);
+        triangle1.curve = 1;
+        var triangle2 = new OV.Triangle (v0, v3, v1);
+        triangle2.curve = 1;
 
-		var triangle1 = mesh.AddTriangle (triangle1);
-		var triangle1 = mesh.AddTriangle (triangle2);
+        var triangle1 = mesh.AddTriangle (triangle1);
+        var triangle1 = mesh.AddTriangle (triangle2);
 
-		var model = new OV.Model ()
-		var meshIndex = model.AddMesh (mesh);
+        var model = new OV.Model ()
+        var meshIndex = model.AddMesh (mesh);
 
-		OV.FinalizeModel (model, function () { new OV.Material () });
-		
-		var theMesh = model.GetMesh (meshIndex);
-		assert.strictEqual (theMesh.NormalCount (), 6);
-		
-		var normal = theMesh.GetNormal (0);
-		assert.strictEqual (normal.x, 0.0);
-		assert.strictEqual (normal.y, -0.7071067811865475);
-		assert.strictEqual (normal.z, 0.7071067811865475);
-	});
+        OV.FinalizeModel (model, function () { new OV.Material () });
+        
+        var theMesh = model.GetMesh (meshIndex);
+        assert.strictEqual (theMesh.NormalCount (), 6);
+        
+        var normal = theMesh.GetNormal (0);
+        assert.strictEqual (normal.x, 0.0);
+        assert.strictEqual (normal.y, -0.7071067811865475);
+        assert.strictEqual (normal.z, 0.7071067811865475);
+    });
 });

test/tests/modelutils_test.js

@@ -20,62 +20,62 @@ describe ('Model Utils', function () {
         model.AddMesh (mesh2);
 
         OV.FinalizeModel (model, function () { return new OV.Material (); });
-		assert.deepStrictEqual (testUtils.ModelToObject (model), {
-			name : '',
-			materials : [
-				{ name : '' }
-			],
-			meshes : [
-				{
-					name : '',
-					triangles : [
-						{
-							vertices : [0, 0, 0, 1, 0, 0, 1, 1, 0],
-							normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
-							uvs : [],
-							mat : 0
-						}
-					]
-				},
+        assert.deepStrictEqual (testUtils.ModelToObject (model), {
+            name : '',
+            materials : [
+                { name : '' }
+            ],
+            meshes : [
                 {
-					name : '',
-					triangles : [
-						{
-							vertices : [0, 0, 1, 1, 0, 1, 1, 1, 1],
-							normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
-							uvs : [],
-							mat : 0
-						}
-					]
-				}
-			]
-		});
+                    name : '',
+                    triangles : [
+                        {
+                            vertices : [0, 0, 0, 1, 0, 0, 1, 1, 0],
+                            normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
+                            uvs : [],
+                            mat : 0
+                        }
+                    ]
+                },
+                {
+                    name : '',
+                    triangles : [
+                        {
+                            vertices : [0, 0, 1, 1, 0, 1, 1, 1, 1],
+                            normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
+                            uvs : [],
+                            mat : 0
+                        }
+                    ]
+                }
+            ]
+        });
 
         var mergedModel = OV.CreateMergedModel (model);
-		assert.deepStrictEqual (testUtils.ModelToObject (mergedModel), {
-			name : '',
-			materials : [
-				{ name : '' }
-			],
-			meshes : [
-				{
-					name : '',
-					triangles : [
-						{
-							vertices : [0, 0, 0, 1, 0, 0, 1, 1, 0],
-							normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
-							uvs : [],
-							mat : 0
-						},
+        assert.deepStrictEqual (testUtils.ModelToObject (mergedModel), {
+            name : '',
+            materials : [
+                { name : '' }
+            ],
+            meshes : [
+                {
+                    name : '',
+                    triangles : [
                         {
-							vertices : [0, 0, 1, 1, 0, 1, 1, 1, 1],
-							normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
-							uvs : [],
-							mat : 0
-						}                        
-					]
+                            vertices : [0, 0, 0, 1, 0, 0, 1, 1, 0],
+                            normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
+                            uvs : [],
+                            mat : 0
+                        },
+                        {
+                            vertices : [0, 0, 1, 1, 0, 1, 1, 1, 1],
+                            normals : [0, 0, 1, 0, 0, 1, 0, 0, 1],
+                            uvs : [],
+                            mat : 0
+                        }                        
+                    ]
                 }
-			]
-		});        
-	});
+            ]
+        });        
+    });
 });

test/tests/taskrunner_test.js

@@ -1,31 +1,31 @@
 var assert = require ('assert');
 
 describe ('Task Runner', function () {
-	it ('Run task zero times', function () {
-		var tr = new OV.TaskRunner ();
-		var numbers = [];
-		tr.Run (0, {
-			runTask : function (index, ready) {
-				numbers.push (index);
-				ready ();
-			},
-			onReady : function () {
-				assert.deepStrictEqual (numbers, []);
-			}
-		});
-	});
+    it ('Run task zero times', function () {
+        var tr = new OV.TaskRunner ();
+        var numbers = [];
+        tr.Run (0, {
+            runTask : function (index, ready) {
+                numbers.push (index);
+                ready ();
+            },
+            onReady : function () {
+                assert.deepStrictEqual (numbers, []);
+            }
+        });
+    });
 
-	it ('Run task three times', function () {
-		var tr = new OV.TaskRunner ();
-		var numbers = [];
-		tr.Run (3, {
-			runTask : function (index, ready) {
-				numbers.push (index);
-				ready ();
-			},
-			onReady : function () {
-				assert.deepStrictEqual (numbers, [0, 1, 2]);
-			}
-		});
-	});		
+    it ('Run task three times', function () {
+        var tr = new OV.TaskRunner ();
+        var numbers = [];
+        tr.Run (3, {
+            runTask : function (index, ready) {
+                numbers.push (index);
+                ready ();
+            },
+            onReady : function () {
+                assert.deepStrictEqual (numbers, [0, 1, 2]);
+            }
+        });
+    });        
 });

test/tests/urlutils_test.js

@@ -0,0 +1,43 @@
+var assert = require ('assert');
+
+describe ('Url Utils', function () {
+    it ('Url builder', function () {
+        let modelUrls = ['a.txt', 'b.txt'];
+        let camera = new OV.Camera (
+            new OV.Coord3D (1.0, 1.0, 1.0),
+            new OV.Coord3D (0.0, 0.0, 0.0),
+            new OV.Coord3D (0.0, 0.0, 1.0)
+        );
+        let urlParams1 = new OV.UrlParamBuilder ().AddModelUrls (modelUrls).GetUrlParams ();
+        let urlParams2 = new OV.UrlParamBuilder ().AddCamera (camera).GetUrlParams ();
+        let urlParams3 = new OV.UrlParamBuilder ().AddModelUrls (modelUrls).AddCamera (camera).GetUrlParams ();
+        assert.strictEqual (urlParams1, 'model=a.txt,b.txt');
+        assert.strictEqual (urlParams2, 'camera=1.0000,1.0000,1.0000,0.0000,0.0000,0.0000,0.0000,0.0000,1.0000');
+        assert.strictEqual (urlParams3, 'model=a.txt,b.txt$camera=1.0000,1.0000,1.0000,0.0000,0.0000,0.0000,0.0000,0.0000,1.0000');
+    });
+
+    it ('Url parser', function () {
+        let modelUrls = ['a.txt', 'b.txt'];
+        let camera = new OV.Camera (
+            new OV.Coord3D (1.0, 1.0, 1.0),
+            new OV.Coord3D (0.0, 0.0, 0.0),
+            new OV.Coord3D (0.0, 0.0, 1.0)
+        );        
+        let urlParamsLegacy = 'a.txt,b.txt';
+        let urlParams1 = 'model=a.txt,b.txt';
+        let urlParams2 = 'camera=1.0000,1.0000,1.0000,0.0000,0.0000,0.0000,0.0000,0.0000,1.0000';
+        let urlParams3 = 'model=a.txt,b.txt$camera=1.0000,1.0000,1.0000,0.0000,0.0000,0.0000,0.0000,0.0000,1.0000';
+        let parserLegacy = new OV.UrlParamParser (urlParamsLegacy);
+        assert.deepStrictEqual (parserLegacy.GetModelUrls (), modelUrls);
+        assert.deepStrictEqual (parserLegacy.GetCamera (), null);
+        let parser1 = new OV.UrlParamParser (urlParams1);
+        assert.deepStrictEqual (parser1.GetModelUrls (), modelUrls);
+        assert.deepStrictEqual (parser1.GetCamera (), null);
+        let parser2 = new OV.UrlParamParser (urlParams2);
+        assert.deepStrictEqual (parser2.GetModelUrls (), null);
+        assert.deepStrictEqual (parser2.GetCamera (), camera);
+        let parser3 = new OV.UrlParamParser (urlParams3);
+        assert.deepStrictEqual (parser3.GetModelUrls (), modelUrls);
+        assert.deepStrictEqual (parser3.GetCamera (), camera);
+    });
+});

test/utils/globals.js

@@ -11,10 +11,13 @@ global.Blob = function () {
 
 var objectUrlCounter = 0;
 global.URL = {
-	createObjectURL : function () {
-		objectUrlCounter += 1;
-		return 'ObjectUrl:' + objectUrlCounter.toString ();
-	}
+    createObjectURL : function () {
+        objectUrlCounter += 1;
+        return 'ObjectUrl:' + objectUrlCounter.toString ();
+    },
+    revokeObjectURL : function () {
+        
+    }
 };
 
 global.FileObject = function (folderName, fileName)

test/utils/importall.js

@@ -1,10 +1,10 @@
 var path = require ('path');
-var nativeImport = require ('../framework/native_import.js');
+var rewire = require ('rewire');
 
 var config = require ('../../tools/config.json')
 var importerFiles = config['importer_files'];
 var fileIndex, filePath;
 for (fileIndex = 0; fileIndex < importerFiles.length; fileIndex++) {
     filePath = importerFiles[fileIndex];
-    nativeImport.AddNativeSourceFile (path.join ('..', filePath));
+    rewire (path.join ('..', '..', filePath));
 }

test/utils/testfiles.js

@@ -2,84 +2,84 @@ var testUtils = require ('./testutils.js');
 
 module.exports =
 {
-	ImportObjFile : function (fileName)
-	{	
-		var importer = new OV.ImporterObj ();
-		return this.ImportFile (importer, OV.FileFormat.Text, 'obj', fileName);
-	},
+    ImportObjFile : function (fileName)
+    {    
+        var importer = new OV.ImporterObj ();
+        return this.ImportFile (importer, OV.FileFormat.Text, 'obj', fileName);
+    },
 
-	ImportStlFile : function (fileName)
-	{	
-		var importer = new OV.ImporterStl ();
-		return this.ImportFile (importer, OV.FileFormat.Binary, 'stl', fileName);
-	},
+    ImportStlFile : function (fileName)
+    {    
+        var importer = new OV.ImporterStl ();
+        return this.ImportFile (importer, OV.FileFormat.Binary, 'stl', fileName);
+    },
 
-	ImportOffFile : function (fileName)
-	{	
-		var importer = new OV.ImporterOff ();
-		return this.ImportFile (importer, OV.FileFormat.Text, 'off', fileName);
-	},
+    ImportOffFile : function (fileName)
+    {    
+        var importer = new OV.ImporterOff ();
+        return this.ImportFile (importer, OV.FileFormat.Text, 'off', fileName);
+    },
 
-	ImportPlyFile : function (fileName)
-	{	
-		var importer = new OV.ImporterPly ();
-		return this.ImportFile (importer, OV.FileFormat.Binary, 'ply', fileName);
-	},
+    ImportPlyFile : function (fileName)
+    {    
+        var importer = new OV.ImporterPly ();
+        return this.ImportFile (importer, OV.FileFormat.Binary, 'ply', fileName);
+    },
 
-	Import3dsFile : function (fileName)
-	{	
-		var importer = new OV.Importer3ds ();
-		return this.ImportFile (importer, OV.FileFormat.Binary, '3ds', fileName);
-	},
+    Import3dsFile : function (fileName)
+    {    
+        var importer = new OV.Importer3ds ();
+        return this.ImportFile (importer, OV.FileFormat.Binary, '3ds', fileName);
+    },
 
-	ImportGltfFile : function (folderName, fileName)
-	{	
-		let extension = OV.GetFileExtension (fileName);
-		let format = OV.FileFormat.Text;
-		if (extension == 'glb') {
-			format = OV.FileFormat.Binary;
-		}
-		var importer = new OV.ImporterGltf ();
-		return this.ImportFile (importer, format, 'gltf/' + folderName, fileName);
-	},
+    ImportGltfFile : function (folderName, fileName)
+    {    
+        let extension = OV.GetFileExtension (fileName);
+        let format = OV.FileFormat.Text;
+        if (extension == 'glb') {
+            format = OV.FileFormat.Binary;
+        }
+        var importer = new OV.ImporterGltf ();
+        return this.ImportFile (importer, format, 'gltf/' + folderName, fileName);
+    },
 
-	ImportFile : function (importer, format, folder, fileName)
-	{
-		function GetFileBuffer (filePath, importer)
-		{
-			let extension = OV.GetFileExtension (filePath);
-			let knownFormats = importer.GetKnownFileFormats ();
-			let format = OV.FileFormat.Binary;
-			if (knownFormats[extension] !== undefined) {
-				format = knownFormats[extension];
-			}
-			let fileContent = null;
-			if (format == OV.FileFormat.Text) {
-				fileContent = testUtils.GetTextFileContent (folder, filePath);
-			} else if (format == OV.FileFormat.Binary) {
-				fileContent = testUtils.GetArrayBufferFileContent (folder, filePath);
-			}
-			return fileContent;
-		}
-
-		var obj = this;
-		var content = null;
-		if (format == OV.FileFormat.Text) {
-			content = testUtils.GetTextFileContent (folder, fileName);
-		} else if (format == OV.FileFormat.Binary) {
-			content = testUtils.GetArrayBufferFileContent (folder, fileName);
-		}
-		var extension = OV.GetFileExtension (fileName);
-		importer.Import (content, extension, {
-			getDefaultMaterial : function () {
-				var material = new OV.Material ();
-				return material;
-			},
-			getFileBuffer : function (filePath) {
-				return GetFileBuffer (filePath, importer);
-			}
-		});
-		let model = importer.GetModel ();
-		return model;
-	}
+    ImportFile : function (importer, format, folder, fileName)
+    {
+        var content = null;
+        if (format == OV.FileFormat.Text) {
+            content = testUtils.GetTextFileContent (folder, fileName);
+        } else if (format == OV.FileFormat.Binary) {
+            content = testUtils.GetArrayBufferFileContent (folder, fileName);
+        }
+        var extension = OV.GetFileExtension (fileName);
+        let buffers = new OV.ImporterBuffers (function (filePath) {
+            let extension = OV.GetFileExtension (filePath);
+            let knownFormats = importer.GetKnownFileFormats ();
+            let format = OV.FileFormat.Binary;
+            if (knownFormats[extension] !== undefined) {
+                format = knownFormats[extension];
+            }
+            let fileContent = null;
+            if (format == OV.FileFormat.Text) {
+                fileContent = testUtils.GetTextFileContent (folder, filePath);
+            } else if (format == OV.FileFormat.Binary) {
+                fileContent = testUtils.GetArrayBufferFileContent (folder, filePath);
+            }
+            return fileContent;
+        });
+        importer.Import (content, extension, {
+            getDefaultMaterial : function () {
+                var material = new OV.Material ();
+                return material;
+            },
+            getFileBuffer : function (filePath) {
+                return buffers.GetFileBuffer (filePath);
+            },
+            getTextureBuffer : function (filePath) {
+                return buffers.GetTextureBuffer (filePath);
+            }
+        });
+        let model = importer.GetModel ();
+        return model;
+    }
 }

test/utils/testutils.js

@@ -3,137 +3,137 @@ var path = require ('path');
 
 module.exports =
 {
-	GetTextFileContent : function (folder, fileName)
-	{
-		var testFilePath = path.join ('testfiles', folder, fileName);
-		if (!fs.existsSync (testFilePath)) {
-			return null;
-		}
-		return fs.readFileSync (testFilePath).toString ();
-	},
+    GetTextFileContent : function (folder, fileName)
+    {
+        var testFilePath = path.join ('testfiles', folder, fileName);
+        if (!fs.existsSync (testFilePath)) {
+            return null;
+        }
+        return fs.readFileSync (testFilePath).toString ();
+    },
 
-	GetArrayBufferFileContent : function (folder, fileName)
-	{
-		var testFilePath = path.join ('testfiles', folder, fileName);
-		var buffer = fs.readFileSync (testFilePath);
-		var arrayBuffer = new ArrayBuffer (buffer.length);
-		var uint8Array = new Uint8Array (arrayBuffer);
-		var i;
-		for (i = 0; i < buffer.length; ++i) {
-			uint8Array[i] = buffer[i];
-		}
-		return arrayBuffer		
-	},
+    GetArrayBufferFileContent : function (folder, fileName)
+    {
+        var testFilePath = path.join ('testfiles', folder, fileName);
+        var buffer = fs.readFileSync (testFilePath);
+        var arrayBuffer = new ArrayBuffer (buffer.length);
+        var uint8Array = new Uint8Array (arrayBuffer);
+        var i;
+        for (i = 0; i < buffer.length; ++i) {
+            uint8Array[i] = buffer[i];
+        }
+        return arrayBuffer        
+    },
 
-	ModelToObject : function (model)
-	{
-		var obj = {
-			name : model.GetName (),
-			materials : [],
-			meshes : []
-		};
+    ModelToObject : function (model)
+    {
+        var obj = {
+            name : model.GetName (),
+            materials : [],
+            meshes : []
+        };
 
-		var i, j;
+        var i, j;
 
-		var material;
-		for (i = 0; i < model.MaterialCount (); i++) {
-			material = model.GetMaterial (i);
-			obj.materials.push ({
-				name : material.name
-			});
-		}
+        var material;
+        for (i = 0; i < model.MaterialCount (); i++) {
+            material = model.GetMaterial (i);
+            obj.materials.push ({
+                name : material.name
+            });
+        }
 
-		var mesh, triangle, meshObj, triangleObj;
-		for (i = 0; i < model.MeshCount (); i++) {
-			mesh = model.GetMesh (i);
-			meshObj = {
-				name : mesh.GetName (),
-				triangles : []
-			};
-			for (j = 0; j < mesh.TriangleCount (); j++) {
-				triangle = mesh.GetTriangle (j);
-				triangleObj = {
-					mat : triangle.mat,
-					vertices : [],
-					normals : [],
-					uvs : []
-				};
-				triangleObj.vertices.push (
-					mesh.GetVertex (triangle.v0).x,
-					mesh.GetVertex (triangle.v0).y,
-					mesh.GetVertex (triangle.v0).z,
-					mesh.GetVertex (triangle.v1).x,
-					mesh.GetVertex (triangle.v1).y,
-					mesh.GetVertex (triangle.v1).z,
-					mesh.GetVertex (triangle.v2).x,
-					mesh.GetVertex (triangle.v2).y,
-					mesh.GetVertex (triangle.v2).z
-				);
-				triangleObj.normals.push (
-					mesh.GetNormal (triangle.n0).x,
-					mesh.GetNormal (triangle.n0).y,
-					mesh.GetNormal (triangle.n0).z,
-					mesh.GetNormal (triangle.n1).x,
-					mesh.GetNormal (triangle.n1).y,
-					mesh.GetNormal (triangle.n1).z,
-					mesh.GetNormal (triangle.n2).x,
-					mesh.GetNormal (triangle.n2).y,
-					mesh.GetNormal (triangle.n2).z
-				);
-				if (triangle.HasTextureUVs ()) {
-					triangleObj.uvs.push (
-						mesh.GetTextureUV (triangle.u0).x,
-						mesh.GetTextureUV (triangle.u0).y,
-						mesh.GetTextureUV (triangle.u1).x,
-						mesh.GetTextureUV (triangle.u1).y,
-						mesh.GetTextureUV (triangle.u2).x,
-						mesh.GetTextureUV (triangle.u2).y
-					);				
-				}
-				meshObj.triangles.push (triangleObj);
-			}
-			obj.meshes.push (meshObj);
-		}
+        var mesh, triangle, meshObj, triangleObj;
+        for (i = 0; i < model.MeshCount (); i++) {
+            mesh = model.GetMesh (i);
+            meshObj = {
+                name : mesh.GetName (),
+                triangles : []
+            };
+            for (j = 0; j < mesh.TriangleCount (); j++) {
+                triangle = mesh.GetTriangle (j);
+                triangleObj = {
+                    mat : triangle.mat,
+                    vertices : [],
+                    normals : [],
+                    uvs : []
+                };
+                triangleObj.vertices.push (
+                    mesh.GetVertex (triangle.v0).x,
+                    mesh.GetVertex (triangle.v0).y,
+                    mesh.GetVertex (triangle.v0).z,
+                    mesh.GetVertex (triangle.v1).x,
+                    mesh.GetVertex (triangle.v1).y,
+                    mesh.GetVertex (triangle.v1).z,
+                    mesh.GetVertex (triangle.v2).x,
+                    mesh.GetVertex (triangle.v2).y,
+                    mesh.GetVertex (triangle.v2).z
+                );
+                triangleObj.normals.push (
+                    mesh.GetNormal (triangle.n0).x,
+                    mesh.GetNormal (triangle.n0).y,
+                    mesh.GetNormal (triangle.n0).z,
+                    mesh.GetNormal (triangle.n1).x,
+                    mesh.GetNormal (triangle.n1).y,
+                    mesh.GetNormal (triangle.n1).z,
+                    mesh.GetNormal (triangle.n2).x,
+                    mesh.GetNormal (triangle.n2).y,
+                    mesh.GetNormal (triangle.n2).z
+                );
+                if (triangle.HasTextureUVs ()) {
+                    triangleObj.uvs.push (
+                        mesh.GetTextureUV (triangle.u0).x,
+                        mesh.GetTextureUV (triangle.u0).y,
+                        mesh.GetTextureUV (triangle.u1).x,
+                        mesh.GetTextureUV (triangle.u1).y,
+                        mesh.GetTextureUV (triangle.u2).x,
+                        mesh.GetTextureUV (triangle.u2).y
+                    );                
+                }
+                meshObj.triangles.push (triangleObj);
+            }
+            obj.meshes.push (meshObj);
+        }
 
-		return obj;
-	},
+        return obj;
+    },
 
-	ModelToObjectSimple : function (model)
-	{
-		var obj = {
-			name : model.GetName (),
-			materials : [],
-			meshes : []
-		};
+    ModelToObjectSimple : function (model)
+    {
+        var obj = {
+            name : model.GetName (),
+            materials : [],
+            meshes : []
+        };
 
-		var i;
+        var i;
 
-		var material;
-		for (i = 0; i < model.MaterialCount (); i++) {
-			material = model.GetMaterial (i);
-			obj.materials.push ({
-				name : material.name
-			});
-		}
+        var material;
+        for (i = 0; i < model.MaterialCount (); i++) {
+            material = model.GetMaterial (i);
+            obj.materials.push ({
+                name : material.name
+            });
+        }
 
-		var mesh, meshObj, boundingBox;
-		for (i = 0; i < model.MeshCount (); i++) {
-			mesh = model.GetMesh (i);
-			boundingBox = OV.GetMeshBoundingBox (mesh);
-			meshObj = {
-				name : mesh.GetName (),
-				vertexCount : mesh.VertexCount (),
-				normalCount : mesh.NormalCount (),
-				uvCount : mesh.TextureUVCount (),
-				triangleCount : mesh.TriangleCount (),
-				boundingBox : {
-					min : [boundingBox[0].x, boundingBox[0].y, boundingBox[0].z],
-					max : [boundingBox[1].x, boundingBox[1].y, boundingBox[1].z]
-				}
-			};
-			obj.meshes.push (meshObj);
-		}
+        var mesh, meshObj, boundingBox;
+        for (i = 0; i < model.MeshCount (); i++) {
+            mesh = model.GetMesh (i);
+            boundingBox = OV.GetMeshBoundingBox (mesh);
+            meshObj = {
+                name : mesh.GetName (),
+                vertexCount : mesh.VertexCount (),
+                normalCount : mesh.NormalCount (),
+                uvCount : mesh.TextureUVCount (),
+                triangleCount : mesh.TriangleCount (),
+                boundingBox : {
+                    min : [boundingBox[0].x, boundingBox[0].y, boundingBox[0].z],
+                    max : [boundingBox[1].x, boundingBox[1].y, boundingBox[1].z]
+                }
+            };
+            obj.meshes.push (meshObj);
+        }
 
-		return obj;
-	}
+        return obj;
+    }
 }

tools/config.json

@@ -45,7 +45,8 @@
 		"source/viewer/domutils.js",
 		"source/viewer/navigation.js",
 		"source/viewer/viewer.js",
-		"source/viewer/domviewer.js"
+		"source/viewer/domviewer.js",
+		"source/viewer/urlutils.js"
 	],
 	"website_files" : [
 		"website/o3dv/utils.js",

tools/run_python.js

@@ -0,0 +1,8 @@
+let cp = require ('child_process');
+let pythonExecutable = 'python';
+if (process.platform !== 'win32') {
+    pythonExecutable = 'python3';
+}
+cp.spawnSync (pythonExecutable, process.argv.slice (2), {
+    stdio: "inherit"
+});

tools/update_includes.py

@@ -19,7 +19,7 @@ def Main (argv):
 		config = json.load (configJson)
 
 	rootDir = os.path.abspath ('..')
-	for htmlFileName in ['index.html', 'embed.html', 'embed_selfhost.html']:
+	for htmlFileName in ['index.html', 'embed.html']:
 		htmlFilePath = os.path.join (rootDir, 'website', htmlFileName)
 		replacer = Tools.TokenReplacer (htmlFilePath, True)
 		libFiles = Tools.CreateFileList (config['lib_files'], 'libs/', '../libs/')

website/embed.html

@@ -59,6 +59,7 @@
 	<script type="text/javascript" src="../source/viewer/navigation.js"></script>
 	<script type="text/javascript" src="../source/viewer/viewer.js"></script>
 	<script type="text/javascript" src="../source/viewer/domviewer.js"></script>
+	<script type="text/javascript" src="../source/viewer/urlutils.js"></script>
 	<!-- importer end -->
 	
 	<!-- website start -->

website/index.html

@@ -59,6 +59,7 @@
 	<script type="text/javascript" src="../source/viewer/navigation.js"></script>
 	<script type="text/javascript" src="../source/viewer/viewer.js"></script>
 	<script type="text/javascript" src="../source/viewer/domviewer.js"></script>
+	<script type="text/javascript" src="../source/viewer/urlutils.js"></script>
 	<!-- importer end -->
 	
 	<!-- website start -->

website/o3dv/dialogs.js

@@ -256,28 +256,24 @@ OV.ShowExportDialog = function (model)
 
         let selectedFormat = formats[selectedIndex - 1];
         fileList.html ('Please wait...');
-        let taskRunner = new OV.TaskRunner ();
-		taskRunner.Run (1, {
-			runTask : function (index, ready) {
-                let exporter = new OV.Exporter ();
-                let files = exporter.Export (model, selectedFormat.format, selectedFormat.extension);
-                fileList.empty ();
-                for (let i = 0; i < files.length; i++) {
-                    let file = files[i];
-                    let url = file.GetUrl ();
-                    if (url === null) {
-                        url = OV.CreateObjectUrl (file.GetContent ());
-                        createdUrls.push (url);
-                    }
-                    let fileLink = $('<a>').addClass ('ov_dialog_file_link').appendTo (fileList);
-                    fileLink.attr ('href', url);
-                    fileLink.attr ('download', file.GetName ());
-                    $('<img>').addClass ('ov_dialog_file_link_icon').attr ('src', 'assets/images/dialog/file_download.svg').appendTo (fileLink);
-                    $('<div>').addClass ('ov_dialog_file_link_text').html (file.GetName ()).appendTo (fileLink);
+        OV.RunTaskAsync (function () {
+            let exporter = new OV.Exporter ();
+            let files = exporter.Export (model, selectedFormat.format, selectedFormat.extension);
+            fileList.empty ();
+            for (let i = 0; i < files.length; i++) {
+                let file = files[i];
+                let url = file.GetUrl ();
+                if (url === null) {
+                    url = OV.CreateObjectUrl (file.GetContent ());
+                    createdUrls.push (url);
                 }
-                ready ();
+                let fileLink = $('<a>').addClass ('ov_dialog_file_link').appendTo (fileList);
+                fileLink.attr ('href', url);
+                fileLink.attr ('download', file.GetName ());
+                $('<img>').addClass ('ov_dialog_file_link_icon').attr ('src', 'assets/images/dialog/file_download.svg').appendTo (fileLink);
+                $('<div>').addClass ('ov_dialog_file_link_text').html (file.GetName ()).appendTo (fileLink);
             }
-		});
+        });
     });
 
     dialog.SetCloseHandler (function () {
@@ -323,7 +319,7 @@ OV.ShowEmbeddingDialog = function (importer, camera)
     embeddingCode += '<iframe';
     embeddingCode += ' width="640" height="480"';
     embeddingCode += ' style="border:1px solid #eeeeee;"';
-    let hashParameters = OV.CreateHashParameters (modelFiles, camera);
+    let hashParameters = OV.CreateUrlParameters (modelFiles, camera);
     embeddingCode += ' src="https://3dviewer.net/embed.html#' + hashParameters + '">';
     embeddingCode += '</iframe>';
 

website/o3dv/embed.js

@@ -1,69 +1,69 @@
 OV.Embed = class
 {
-	constructor (parameters)
-	{
+    constructor (parameters)
+    {
         this.parameters = parameters;
         this.viewer = new OV.Viewer ();
         this.hashHandler = new OV.HashHandler ();
         this.modelLoader = new OV.ThreeModelLoader ();
     }
 
-	Load ()
-	{
-		let canvas = $('<canvas>').appendTo (this.parameters.viewerDiv);
-		this.viewer.Init (canvas.get (0));
-		this.InitModelLoader ();
+    Load ()
+    {
+        let canvas = $('<canvas>').appendTo (this.parameters.viewerDiv);
+        this.viewer.Init (canvas.get (0));
+        this.InitModelLoader ();
         this.Resize ();
 
-		if (this.hashHandler.HasHash ()) {
-			let urls = this.hashHandler.GetModelFilesFromHash ();
-			if (urls === null) {
-				return;
-			}
-			let camera = this.hashHandler.GetCameraFromHash ();
-			if (camera !== null) {
-				this.viewer.SetCamera (camera);
-			}
-			this.modelLoader.LoadFromUrlList (urls);
-			let hashParameters = OV.CreateHashParameters (urls, camera);
-			let websiteUrl = this.parameters.websiteLinkDiv.attr ('href') + '#' + hashParameters;
-			this.parameters.websiteLinkDiv.attr ('href', websiteUrl);
-		}
-	}
+        if (this.hashHandler.HasHash ()) {
+            let urls = this.hashHandler.GetModelFilesFromHash ();
+            if (urls === null) {
+                return;
+            }
+            let camera = this.hashHandler.GetCameraFromHash ();
+            if (camera !== null) {
+                this.viewer.SetCamera (camera);
+            }
+            this.modelLoader.LoadFromUrlList (urls);
+            let hashParameters = OV.CreateUrlParameters (urls, null);
+            let websiteUrl = this.parameters.websiteLinkDiv.attr ('href') + '#' + hashParameters;
+            this.parameters.websiteLinkDiv.attr ('href', websiteUrl);
+        }
+    }
 
     Resize ()
-	{
-		let windowWidth = $(window).outerWidth ();
-		let windowHeight = $(window).outerHeight ();
-		this.viewer.Resize (windowWidth, windowHeight);
-	}
+    {
+        let windowWidth = $(window).outerWidth ();
+        let windowHeight = $(window).outerHeight ();
+        this.viewer.Resize (windowWidth, windowHeight);
+    }
 
-	OnModelFinished (importResult, threeMeshes)
-	{
-		this.viewer.AddMeshes (threeMeshes);
-		let boundingSphere = this.viewer.GetBoundingSphere (function (meshUserData) {
-			return true;
-		});
-		this.viewer.AdjustClippingPlanes (boundingSphere);
-		this.viewer.FitToWindow (boundingSphere, false);        
-	}    
+    OnModelFinished (importResult, threeMeshes)
+    {
+        this.viewer.AddMeshes (threeMeshes);
+        let boundingSphere = this.viewer.GetBoundingSphere (function (meshUserData) {
+            return true;
+        });
+        this.viewer.AdjustClippingPlanes (boundingSphere);
+        this.viewer.FitToWindow (boundingSphere, false);        
+    }    
 
-	InitModelLoader ()
-	{
-		let obj = this;
-		OV.InitModelLoader (this.modelLoader, {
-			onStart : function ()
-			{
-				
-			},
-			onFinish : function (importResult, threeMeshes)
-			{
-				obj.OnModelFinished (importResult, threeMeshes);
-			},
-			onRender : function ()
-			{
-				obj.viewer.Render ();
-			}
-		});
-	} 
+    InitModelLoader ()
+    {
+        let obj = this;
+        OV.InitModelLoader (this.modelLoader, {
+            onStart : function ()
+            {
+                
+            },
+            onFinish : function (importResult, threeMeshes)
+            {
+                obj.OnModelFinished (importResult, threeMeshes);
+            },
+            onRender : function ()
+            {
+                obj.viewer.Render ();
+            }
+        });
+    } 
 };

website/o3dv/hashhandler.js

@@ -1,110 +1,85 @@
 OV.HashHandler = class
 {
-	constructor ()
-	{
-		this.skipNextEvent = false;
-		this.eventListener = null;
-	}
+    constructor ()
+    {
+        this.skipNextEvent = false;
+        this.eventListener = null;
+    }
 
-	SetEventListener (eventListener)
-	{
-		this.eventListener = eventListener;
-		window.onhashchange = this.OnChange.bind (this);
-	}
+    SetEventListener (eventListener)
+    {
+        this.eventListener = eventListener;
+        window.onhashchange = this.OnChange.bind (this);
+    }
 
-	SkipNextEventHandler ()
-	{
-		this.skipNextEvent = true;
-	}
+    SkipNextEventHandler ()
+    {
+        this.skipNextEvent = true;
+    }
 
-	HasHash ()
-	{
-		let hash = this.GetHash ();
-		return hash.length > 0;
-	}
+    HasHash ()
+    {
+        let hash = this.GetHash ();
+        return hash.length > 0;
+    }
 
-	ClearHash ()
-	{
-		this.SetHash ('');
-	}
+    ClearHash ()
+    {
+        this.SetHash ('');
+    }
 
-	GetCameraFromHash ()
-	{
-		let parameters = this.GetFromHash ('camera');
-		if (parameters === null) {
-			return null;
-		}
-		let splitted = parameters.split (',');
-		if (splitted.length !== 9) {
-			return null;
-		}
-		let camera = new OV.Camera (
-			new OV.Coord3D (parseFloat (splitted[0]), parseFloat (splitted[1]), parseFloat (splitted[2])),
-			new OV.Coord3D (parseFloat (splitted[3]), parseFloat (splitted[4]), parseFloat (splitted[5])),
-			new OV.Coord3D (parseFloat (splitted[6]), parseFloat (splitted[7]), parseFloat (splitted[8]))
-		);
-		return camera;
-	}
+    GetCameraFromHash ()
+    {
+        let parser = new OV.UrlParamParser (this.GetHash ());
+        return parser.GetCamera ();
+    }
 
-	GetModelFilesFromHash ()
-	{
-		let hash = this.GetHash ();
-		if (hash.length === 0) {
-			return null;
-		}
+    GetModelFilesFromHash ()
+    {
+        let parser = new OV.UrlParamParser (this.GetHash ());
+        return parser.GetModelUrls ();
+    }
 
-		// detect legacy links
-		let modelKeyword = 'model';
-		let keywordToken = modelKeyword + '=';
-		if (hash.indexOf (keywordToken) === -1) {
-			return hash.split (',');
-		}
+    SetModelFilesToHash (files)
+    {
+        let builder = new OV.UrlParamBuilder ();
+        builder.AddModelUrls (files);
+        this.SetHash (builder.GetUrlParams ());
+    }
 
-		let fileList = this.GetFromHash (modelKeyword);
-		if (fileList === null) {
-			return null;
-		}
-		return fileList.split (',');
-	}
+    GetFromHash (keyword)
+    {
+        let hash = this.GetHash ();
+        if (hash.length === 0) {
+            return null;
+        }
+        let keywordToken = keyword + '=';
+        let hashParts = hash.split ('$');
+        for (let i = 0; i < hashParts.length; i++) {
+            let hashPart = hashParts[i];
+            if (hashPart.startsWith (keywordToken)) {
+                return hashPart.substr (keywordToken.length);
+            }
+        }
+        return null;
+    }
 
-	SetModelFilesToHash (files)
-	{
-		this.SetHash ('model=' + files.join (','));
-	}
+    GetHash ()
+    {
+        return window.location.hash.substr (1);
+    }
 
-	GetFromHash (keyword)
-	{
-		let hash = this.GetHash ();
-		if (hash.length === 0) {
-			return null;
-		}
-		let keywordToken = keyword + '=';
-		let hashParts = hash.split ('$');
-		for (let i = 0; i < hashParts.length; i++) {
-			let hashPart = hashParts[i];
-			if (hashPart.startsWith (keywordToken)) {
-				return hashPart.substr (keywordToken.length);
-			}
-		}
-		return null;
-	}
+    SetHash (hash)
+    {
+        window.location.hash = hash;
+    }
 
-	GetHash ()
-	{
-		return window.location.hash.substr (1);
-	}
-
-	SetHash (hash)
-	{
-		window.location.hash = hash;
-	}
-
-	OnChange ()
-	{
-		if (this.skipNextEvent) {
-			this.skipNextEvent = false;
-			return;
-		}
-		this.eventListener ();
-	}
+    OnChange ()
+    {
+        if (this.skipNextEvent) {
+            this.skipNextEvent = false;
+            return;
+        }
+        this.eventListener ();
+    }
 };

website/o3dv/info.js

@@ -4,9 +4,9 @@ OV.InfoPanel = class
     {
         this.mainDiv = $('<div>').addClass ('ov_info_panel_main').appendTo (parentDiv);
         this.treeView = new OV.TreeView (this.mainDiv);
-		this.detailsItem = new OV.TreeViewGroupItem ('Details', 'assets/images/tree/details.svg');
+        this.detailsItem = new OV.TreeViewGroupItem ('Details', 'assets/images/tree/details.svg');
         this.detailsItem.ShowChildren (!OV.IsSmallHeight (), null);
-		this.treeView.AddItem (this.detailsItem);
+        this.treeView.AddItem (this.detailsItem);
         let childrenDiv = this.detailsItem.CreateChildrenDiv ();
         childrenDiv.addClass ('ov_info_panel_content');
         this.popup = null;
@@ -146,10 +146,10 @@ OV.InfoPanel = class
 
     Clear ()
     {
-		if (this.popup !== null) {
+        if (this.popup !== null) {
             this.popup.Hide ();
             this.popup = null;
-		}        
+        }        
         let contentDiv = this.detailsItem.GetChildrenDiv ();
         contentDiv.empty ();
     }

website/o3dv/menu.js

@@ -47,22 +47,22 @@ OV.Menu = class
     }
 
     FillTree (importResult)
-	{
+    {
         let obj = this;
 
         this.titleDiv.html (importResult.mainFile).attr ('title', importResult.mainFile);
 
-		let model = importResult.model;
-		let usedFiles = importResult.usedFiles;
-		let missingFiles = importResult.missingFiles;
+        let model = importResult.model;
+        let usedFiles = importResult.usedFiles;
+        let missingFiles = importResult.missingFiles;
 
-		let filesItem = new OV.TreeViewGroupItem ('Files', 'assets/images/tree/files.svg');
-		this.treeView.AddItem (filesItem);
+        let filesItem = new OV.TreeViewGroupItem ('Files', 'assets/images/tree/files.svg');
+        this.treeView.AddItem (filesItem);
         for (let i = 0; i < usedFiles.length; i++) {
-			let file = usedFiles[i];
-			let item = new OV.TreeViewSingleItem (file);
-			filesItem.AddChild (item);
-		}
+            let file = usedFiles[i];
+            let item = new OV.TreeViewSingleItem (file);
+            filesItem.AddChild (item);
+        }
 
         if (missingFiles.length > 0) {
             let missingFilesItem = new OV.TreeViewGroupItem ('Missing Files', 'assets/images/tree/missing_files.svg');
@@ -79,29 +79,29 @@ OV.Menu = class
             }
         }
 
-		let materialsItem = new OV.TreeViewGroupItem ('Materials', 'assets/images/tree/materials.svg');
-		this.treeView.AddItem (materialsItem);
+        let materialsItem = new OV.TreeViewGroupItem ('Materials', 'assets/images/tree/materials.svg');
+        this.treeView.AddItem (materialsItem);
         for (let i = 0; i < model.MaterialCount (); i++) {
-			let material = model.GetMaterial (i);
+            let material = model.GetMaterial (i);
             let materialName = OV.GetMaterialName (material.name);
             let materialData = new OV.MaterialData (i);
-			let materialItem = materialData.CreateMenuItem (materialName, {
+            let materialItem = materialData.CreateMenuItem (materialName, {
                 onSelected : function (materialIndex) {
                     obj.SetSelection (new OV.Selection (OV.SelectionType.Material, materialIndex));
                 }
             });
             this.modelData.AddMaterialData (materialData);
-			materialsItem.AddChild (materialItem);
-		}
+            materialsItem.AddChild (materialItem);
+        }
 
         let meshesItem = new OV.TreeViewGroupItem ('Meshes', 'assets/images/tree/meshes.svg');
-		this.treeView.AddItem (meshesItem);
+        this.treeView.AddItem (meshesItem);
         meshesItem.ShowChildren (true, null);
-		for (let i = 0; i < model.MeshCount (); i++) {
-			let mesh = model.GetMesh (i);
-			let meshData = new OV.MeshData (i);
+        for (let i = 0; i < model.MeshCount (); i++) {
+            let mesh = model.GetMesh (i);
+            let meshData = new OV.MeshData (i);
             let meshName = OV.GetMeshName (mesh.GetName ());
-			let meshItem = meshData.CreateMenuItem (meshName, {
+            let meshItem = meshData.CreateMenuItem (meshName, {
                 onShowHide : function (meshIndex) {
                     obj.ToggleMeshVisibility (meshIndex);
                 },
@@ -115,13 +115,13 @@ OV.Menu = class
                     obj.SetSelection (new OV.Selection (OV.SelectionType.Mesh, meshIndex));
                 }
             });
-			this.modelData.AddMeshData (meshData);
-			meshesItem.AddChild (meshItem);
-		}
+            this.modelData.AddMeshData (meshData);
+            meshesItem.AddChild (meshItem);
+        }
 
         this.UpdateInfoPanel ();
         this.Resize ();
-	}
+    }
     
     IsMeshVisible (meshIndex)
     {
@@ -129,8 +129,8 @@ OV.Menu = class
         return meshData.IsVisible ();
     }
 
-	IsolateMesh (meshIndex)
-	{
+    IsolateMesh (meshIndex)
+    {
         let isIsolated = true;
         for (let i = 0; i < this.modelData.MeshCount (); i++) {
             let meshData = this.modelData.GetMeshData (i);
@@ -147,17 +147,17 @@ OV.Menu = class
                 meshData.SetVisible (false);
             }
         }
-		this.callbacks.updateMeshesVisibility ();
-	}
+        this.callbacks.updateMeshesVisibility ();
+    }
 
-	ToggleMeshVisibility (meshIndex)
-	{
-		let meshData = this.modelData.GetMeshData (meshIndex);
-		meshData.SetVisible (!meshData.IsVisible ());
-		this.callbacks.updateMeshesVisibility ();
-	}
+    ToggleMeshVisibility (meshIndex)
+    {
+        let meshData = this.modelData.GetMeshData (meshIndex);
+        meshData.SetVisible (!meshData.IsVisible ());
+        this.callbacks.updateMeshesVisibility ();
+    }
 
-	GetSelectedMeshIndex ()
+    GetSelectedMeshIndex ()
     {
         if (this.tempSelectedMeshIndex !== null) {
             return this.tempSelectedMeshIndex;
@@ -212,9 +212,9 @@ OV.Menu = class
     }
 
     FitMeshToWindow (meshIndex)
-	{
-		this.callbacks.fitMeshToWindow (meshIndex);
-	}
+    {
+        this.callbacks.fitMeshToWindow (meshIndex);
+    }
 
     UpdateInfoPanel ()
     {

website/o3dv/treeview.js

@@ -45,15 +45,15 @@ OV.TreeViewItem = class
         this.nameElement = null;
     }
 
-	GetName ()
-	{
-		return this.name;
-	}
-	
-	SetName (name)
-	{
-		this.name = name;
-	}
+    GetName ()
+    {
+        return this.name;
+    }
+    
+    SetName (name)
+    {
+        this.name = name;
+    }
 
     CreateMainElement (parentDiv)
     {
@@ -155,15 +155,15 @@ OV.TreeViewGroupItem = class extends OV.TreeViewItem
         this.openCloseHandler = null;
     }
 
-	GetName ()
-	{
-		return this.name;
-	}
-	
-	SetName (name)
-	{
-		this.name = name;
-	}
+    GetName ()
+    {
+        return this.name;
+    }
+    
+    SetName (name)
+    {
+        this.name = name;
+    }
 
     SetAnimated (animated)
     {

website/o3dv/utils.js

@@ -102,12 +102,12 @@ OV.CopyToClipboard = function (text)
 
 OV.CreateIconButton = function (iconName, hoverIconName, title, link)
 {
-	let buttonLink = $('<a>');
-	buttonLink.attr ('href', link);
-	buttonLink.attr ('target', '_blank');
+    let buttonLink = $('<a>');
+    buttonLink.attr ('href', link);
+    buttonLink.attr ('target', '_blank');
     buttonLink.attr ('rel', 'noopener noreferrer');
     OV.InstallTooltip (buttonLink, title);
-	let imgElem = $('<img>').attr ('src', iconName).appendTo (buttonLink);
+    let imgElem = $('<img>').attr ('src', iconName).appendTo (buttonLink);
     if (hoverIconName !== null && OV.IsHoverEnabled ()) {
         buttonLink.hover (
             function () {
@@ -118,22 +118,5 @@ OV.CreateIconButton = function (iconName, hoverIconName, title, link)
             }
         );
     }
-	return buttonLink;
-};
-
-OV.CreateHashParameters = function (urls, camera)
-{
-    let hashParameters = '';
-    let urlsHash = urls.join (',');
-    hashParameters += 'model=' + urlsHash;
-    if (camera !== null) {
-        let precision = 5;
-        let cameraHash = [
-            camera.eye.x.toPrecision (precision), camera.eye.y.toPrecision (precision), camera.eye.z.toPrecision (precision),
-            camera.center.x.toPrecision (precision), camera.center.y.toPrecision (precision), camera.center.z.toPrecision (precision),
-            camera.up.x.toPrecision (precision), camera.up.y.toPrecision (precision), camera.up.z.toPrecision (precision)
-        ].join (',');
-        hashParameters += '$camera=' + cameraHash;
-    }
-    return hashParameters;
+    return buttonLink;
 };

website/o3dv/website.js

@@ -1,451 +1,444 @@
 OV.Website = class
 {
-	constructor (parameters)
-	{
-		this.parameters = parameters;
-		this.viewer = new OV.Viewer ();
-		this.hashHandler = new OV.HashHandler ();
-		this.toolbar = new OV.Toolbar (this.parameters.toolbarDiv);
-		this.menu = new OV.Menu (this.parameters.menuDiv);
-		this.modelLoader = new OV.ThreeModelLoader ();
-		this.highlightMaterial = new THREE.MeshPhongMaterial ({
-			color : 0x8ec9f0,
-			side : THREE.DoubleSide
-		});
-		this.model = null;
-		this.dialog = null;
-	}
+    constructor (parameters)
+    {
+        this.parameters = parameters;
+        this.viewer = new OV.Viewer ();
+        this.hashHandler = new OV.HashHandler ();
+        this.toolbar = new OV.Toolbar (this.parameters.toolbarDiv);
+        this.menu = new OV.Menu (this.parameters.menuDiv);
+        this.modelLoader = new OV.ThreeModelLoader ();
+        this.highlightMaterial = new THREE.MeshPhongMaterial ({
+            color : 0x8ec9f0,
+            side : THREE.DoubleSide
+        });
+        this.model = null;
+        this.dialog = null;
+    }
 
-	Load ()
-	{
-		let canvas = $('<canvas>').appendTo (this.parameters.viewerDiv);
-		this.viewer.Init (canvas.get (0));
-		this.ShowViewer (false);
-		this.hashHandler.SetEventListener (this.OnHashChange.bind (this));
+    Load ()
+    {
+        let canvas = $('<canvas>').appendTo (this.parameters.viewerDiv);
+        this.viewer.Init (canvas.get (0));
+        this.ShowViewer (false);
+        this.hashHandler.SetEventListener (this.OnHashChange.bind (this));
 
-		this.InitToolbar ();
-		this.InitDragAndDrop ();
-		this.InitModelLoader ();
-		this.InitMenu ();
+        this.InitToolbar ();
+        this.InitDragAndDrop ();
+        this.InitModelLoader ();
+        this.InitMenu ();
 
-		this.viewer.SetClickHandler (this.OnModelClicked.bind (this));
-		this.Resize ();
+        this.viewer.SetClickHandler (this.OnModelClicked.bind (this));
+        this.Resize ();
 
-		this.OnHashChange ();
-	}
+        this.OnHashChange ();
+    }
 
-	Resize ()
-	{
-		let windowWidth = $(window).outerWidth ();
-		let windowHeight = $(window).outerHeight ();
-		let headerHeight = parseInt (this.parameters.headerDiv.outerHeight (true), 10);
+    Resize ()
+    {
+        let windowWidth = $(window).outerWidth ();
+        let windowHeight = $(window).outerHeight ();
+        let headerHeight = parseInt (this.parameters.headerDiv.outerHeight (true), 10);
 
-		let menuWidth = 0;
-		let safetyMargin = 0;
-		if (!OV.IsSmallWidth ()) {
-			menuWidth = parseInt (this.parameters.menuDiv.outerWidth (true), 10);
-			safetyMargin = 1;
-		}
-		
-		let contentWidth = windowWidth - menuWidth - safetyMargin;
-		let contentHeight = windowHeight - headerHeight - safetyMargin;
-		this.parameters.menuDiv.outerHeight (contentHeight, true);
-		this.parameters.introDiv.outerHeight (contentHeight, true);
+        let menuWidth = 0;
+        let safetyMargin = 0;
+        if (!OV.IsSmallWidth ()) {
+            menuWidth = parseInt (this.parameters.menuDiv.outerWidth (true), 10);
+            safetyMargin = 1;
+        }
+        
+        let contentWidth = windowWidth - menuWidth - safetyMargin;
+        let contentHeight = windowHeight - headerHeight - safetyMargin;
+        this.parameters.menuDiv.outerHeight (contentHeight, true);
+        this.parameters.introDiv.outerHeight (contentHeight, true);
 
-		this.menu.Resize ();
-		this.viewer.Resize (contentWidth, contentHeight);
-	}
+        this.menu.Resize ();
+        this.viewer.Resize (contentWidth, contentHeight);
+    }
 
-	ShowViewer (show)
-	{
-		if (show) {
-			this.parameters.mainDiv.show ();
-		} else {
-			this.parameters.mainDiv.hide ();
-		}
-	}
+    ShowViewer (show)
+    {
+        if (show) {
+            this.parameters.mainDiv.show ();
+        } else {
+            this.parameters.mainDiv.hide ();
+        }
+    }
 
-	ClearModel ()
-	{
-		if (this.dialog !== null) {
+    ClearModel ()
+    {
+        if (this.dialog !== null) {
             this.dialog.Hide ();
             this.dialog = null;
-		}
-		if (this.model !== null) {
-			OV.RevokeModelUrls (this.model);
-		}
-		this.model = null;
-		this.parameters.introDiv.hide ();
-		this.ShowViewer (false);
-		this.viewer.Clear ();
-		this.menu.Clear ();
-	}
-	
-	OnModelFinished (importResult, threeMeshes)
-	{
-		this.model = importResult.model;
-		this.ShowViewer (true);
-		this.viewer.AddMeshes (threeMeshes);
-		this.viewer.SetUpVector (importResult.upVector, false);
-		this.menu.FillTree (importResult);
-		this.FitModelToWindow (true);
-	}
+        }
+        this.model = null;
+        this.parameters.introDiv.hide ();
+        this.ShowViewer (false);
+        this.viewer.Clear ();
+        this.menu.Clear ();
+    }
+    
+    OnModelFinished (importResult, threeMeshes)
+    {
+        this.model = importResult.model;
+        this.ShowViewer (true);
+        this.viewer.AddMeshes (threeMeshes);
+        this.viewer.SetUpVector (importResult.upVector, false);
+        this.menu.FillTree (importResult);
+        this.FitModelToWindow (true);
+    }
 
-	OnModelClicked (button, isCtrlPressed, mouseCoordinates)
-	{
-		if (button === 1) {
-			let meshUserData = this.viewer.GetMeshUnderMouse (mouseCoordinates);
-			if (meshUserData === null) {
-				this.menu.SetSelection (null);
-			} else {
-				if (isCtrlPressed) {
-					this.menu.IsolateMesh (meshUserData.originalMeshIndex);
-				} else {
-					this.menu.SetSelection (new OV.Selection (OV.SelectionType.Mesh, meshUserData.originalMeshIndex));
-				}
-			}
-		}
-	}
+    OnModelClicked (button, isCtrlPressed, mouseCoordinates)
+    {
+        if (button === 1) {
+            let meshUserData = this.viewer.GetMeshUnderMouse (mouseCoordinates);
+            if (meshUserData === null) {
+                this.menu.SetSelection (null);
+            } else {
+                if (isCtrlPressed) {
+                    this.menu.IsolateMesh (meshUserData.originalMeshIndex);
+                } else {
+                    this.menu.SetSelection (new OV.Selection (OV.SelectionType.Mesh, meshUserData.originalMeshIndex));
+                }
+            }
+        }
+    }
 
-	OpenFileBrowserDialog ()
-	{
-		this.parameters.fileInput.trigger ('click');
-	}
+    OpenFileBrowserDialog ()
+    {
+        this.parameters.fileInput.trigger ('click');
+    }
 
-	FitModelToWindow (onLoad)
-	{
-		let obj = this;
-		let animation = !onLoad;
-		let boundingSphere = this.viewer.GetBoundingSphere (function (meshUserData) {
-			return obj.menu.IsMeshVisible (meshUserData.originalMeshIndex);
-		});
-		if (onLoad) {
-			this.viewer.AdjustClippingPlanes (boundingSphere);
-		}
-		this.viewer.FitToWindow (boundingSphere, animation);
-	}
+    FitModelToWindow (onLoad)
+    {
+        let obj = this;
+        let animation = !onLoad;
+        let boundingSphere = this.viewer.GetBoundingSphere (function (meshUserData) {
+            return obj.menu.IsMeshVisible (meshUserData.originalMeshIndex);
+        });
+        if (onLoad) {
+            this.viewer.AdjustClippingPlanes (boundingSphere);
+        }
+        this.viewer.FitToWindow (boundingSphere, animation);
+    }
 
-	FitMeshToWindow (meshIndex)
-	{
-		let boundingSphere = this.viewer.GetBoundingSphere (function (meshUserData) {
-			return meshUserData.originalMeshIndex === meshIndex;
-		});		
-		this.viewer.FitToWindow (boundingSphere, true);
-	}
+    FitMeshToWindow (meshIndex)
+    {
+        let boundingSphere = this.viewer.GetBoundingSphere (function (meshUserData) {
+            return meshUserData.originalMeshIndex === meshIndex;
+        });        
+        this.viewer.FitToWindow (boundingSphere, true);
+    }
 
-	UpdateMeshesVisibility ()
-	{
-		let obj = this;
-		this.viewer.SetMeshesVisibility (function (meshUserData) {
-			return obj.menu.IsMeshVisible (meshUserData.originalMeshIndex);
-		});
-	}
+    UpdateMeshesVisibility ()
+    {
+        let obj = this;
+        this.viewer.SetMeshesVisibility (function (meshUserData) {
+            return obj.menu.IsMeshVisible (meshUserData.originalMeshIndex);
+        });
+    }
 
-	UpdateMeshesSelection ()
-	{
-		let selectedMeshIndex = this.menu.GetSelectedMeshIndex ();
-		this.viewer.SetMeshesHighlight (this.highlightMaterial, function (meshUserData) {
-			if (meshUserData.originalMeshIndex === selectedMeshIndex) {
-				return true;
-			}
-			return false;
-		});
-	}	
+    UpdateMeshesSelection ()
+    {
+        let selectedMeshIndex = this.menu.GetSelectedMeshIndex ();
+        this.viewer.SetMeshesHighlight (this.highlightMaterial, function (meshUserData) {
+            if (meshUserData.originalMeshIndex === selectedMeshIndex) {
+                return true;
+            }
+            return false;
+        });
+    }    
 
-	LoadModelFromUrlList (urls)
-	{
-		this.modelLoader.LoadFromUrlList (urls);
-		this.ClearHashIfNotOnlyUrlList ();
-	}
+    LoadModelFromUrlList (urls)
+    {
+        this.modelLoader.LoadFromUrlList (urls);
+        this.ClearHashIfNotOnlyUrlList ();
+    }
 
-	LoadModelFromFileList (files)
-	{
-		if (files.length === 0) {
-			return;
-		}
-		this.modelLoader.LoadFromFileList (files);
-		this.ClearHashIfNotOnlyUrlList ();
-	}
+    LoadModelFromFileList (files)
+    {
+        if (files.length === 0) {
+            return;
+        }
+        this.modelLoader.LoadFromFileList (files);
+        this.ClearHashIfNotOnlyUrlList ();
+    }
 
-	ClearHashIfNotOnlyUrlList ()
-	{
-		let importer = this.modelLoader.GetImporter ();
-		let isOnlyUrl = importer.IsOnlyFileSource (OV.FileSource.Url);
-		if (!isOnlyUrl && this.hashHandler.HasHash ()) {
-			this.hashHandler.SkipNextEventHandler ();
-			this.hashHandler.ClearHash ();
-		}
-	}
+    ClearHashIfNotOnlyUrlList ()
+    {
+        let importer = this.modelLoader.GetImporter ();
+        let isOnlyUrl = importer.IsOnlyFileSource (OV.FileSource.Url);
+        if (!isOnlyUrl && this.hashHandler.HasHash ()) {
+            this.hashHandler.SkipNextEventHandler ();
+            this.hashHandler.ClearHash ();
+        }
+    }
 
-	OnHashChange ()
-	{
-		if (this.hashHandler.HasHash ()) {
-			let urls = this.hashHandler.GetModelFilesFromHash ();
-			if (urls === null) {
-				return;
-			}
-			let camera = this.hashHandler.GetCameraFromHash ();
-			if (camera !== null) {
-				this.viewer.SetCamera (camera);
-			}
-			this.LoadModelFromUrlList (urls);
-		} else {
-			this.ClearModel ();
-			this.parameters.introDiv.show ();
-		}
-	}
+    OnHashChange ()
+    {
+        if (this.hashHandler.HasHash ()) {
+            let urls = this.hashHandler.GetModelFilesFromHash ();
+            if (urls === null) {
+                return;
+            }
+            this.LoadModelFromUrlList (urls);
+        } else {
+            this.ClearModel ();
+            this.parameters.introDiv.show ();
+        }
+    }
 
-	InitToolbar ()
-	{
-		function AddButton (toolbar, imageName, imageTitle, onlyFullWidth, onClick)
-		{
-			let image = 'assets/images/toolbar/' + imageName + '.svg';
-			let button = toolbar.AddImageButton (image, imageTitle, onClick);
-			if (onlyFullWidth) {
-				button.AddClass ('only_full_width');
-			}
-		}
+    InitToolbar ()
+    {
+        function AddButton (toolbar, imageName, imageTitle, onlyFullWidth, onClick)
+        {
+            let image = 'assets/images/toolbar/' + imageName + '.svg';
+            let button = toolbar.AddImageButton (image, imageTitle, onClick);
+            if (onlyFullWidth) {
+                button.AddClass ('only_full_width');
+            }
+        }
 
-		function AddRadioButton (toolbar, imageNames, imageTitles, selectedIndex, onlyFullWidth, onClick)
-		{
-			let imageData = [];
-			for (let i = 0; i < imageNames.length; i++) {
-				let imageName = imageNames[i];
-				let imageTitle = imageTitles[i];
-				imageData.push ({
-					image : 'assets/images/toolbar/' + imageName + '.svg',
-					title : imageTitle
-				});
-			}
-			let buttons = toolbar.AddImageRadioButton (imageData, selectedIndex, onClick);
-			if (onlyFullWidth) {
-				for (let i = 0; i < buttons.length; i++) {
-					let button = buttons[i];
-					button.AddClass ('only_full_width');
-				}
-			}
-		}
+        function AddRadioButton (toolbar, imageNames, imageTitles, selectedIndex, onlyFullWidth, onClick)
+        {
+            let imageData = [];
+            for (let i = 0; i < imageNames.length; i++) {
+                let imageName = imageNames[i];
+                let imageTitle = imageTitles[i];
+                imageData.push ({
+                    image : 'assets/images/toolbar/' + imageName + '.svg',
+                    title : imageTitle
+                });
+            }
+            let buttons = toolbar.AddImageRadioButton (imageData, selectedIndex, onClick);
+            if (onlyFullWidth) {
+                for (let i = 0; i < buttons.length; i++) {
+                    let button = buttons[i];
+                    button.AddClass ('only_full_width');
+                }
+            }
+        }
 
-		function AddSeparator (toolbar, onlyFullWidth)
-		{
-			let separator = toolbar.AddSeparator ();
-			if (onlyFullWidth) {
-				separator.addClass ('only_full_width');
-			}
-		}
+        function AddSeparator (toolbar, onlyFullWidth)
+        {
+            let separator = toolbar.AddSeparator ();
+            if (onlyFullWidth) {
+                separator.addClass ('only_full_width');
+            }
+        }
 
-		let obj = this;
-		AddButton (this.toolbar, 'open', 'Open model from your device', false, function () {
-			obj.OpenFileBrowserDialog ();
-		});
-		AddButton (this.toolbar, 'open_url', 'Open model from a url', false, function () {
-			obj.dialog = OV.ShowOpenUrlDialog (function (urls) {
-				if (urls.length > 0) {
-					obj.hashHandler.SetModelFilesToHash (urls);
-				}
-			});
-		});
-		AddSeparator (this.toolbar);
-		AddButton (this.toolbar, 'fit', 'Fit model to Window', false, function () {
-			obj.FitModelToWindow (false);
-		});
-		AddButton (this.toolbar, 'up_y', 'Set Y axis as up vector', false, function () {
-			obj.viewer.SetUpVector (OV.Direction.Y, true);
-		});
-		AddButton (this.toolbar, 'up_z', 'Set Z axis as up vector', false, function () {
-			obj.viewer.SetUpVector (OV.Direction.Z, true);
-		});
-		AddButton (this.toolbar, 'flip', 'Flip up vector', false, function () {
-			obj.viewer.FlipUpVector ();
-		});
-		AddSeparator (this.toolbar);
-		AddRadioButton (this.toolbar, ['fix_up_on', 'fix_up_off'], ['Fixed up vector', 'Free orbit'], 0, false, function (buttonIndex) {
-			if (buttonIndex === 0) {
-				obj.viewer.SetFixUpVector (true);
-			} else if (buttonIndex === 1) {
-				obj.viewer.SetFixUpVector (false);
-			}
-		});
-		AddSeparator (this.toolbar, true);
-		AddButton (this.toolbar, 'export', 'Export model', true, function () {
-			obj.dialog = OV.ShowExportDialog (obj.model);
-		});		
-		AddButton (this.toolbar, 'embed', 'Get embedding code', true, function () {
-			obj.dialog = OV.ShowEmbeddingDialog (obj.modelLoader.GetImporter (), obj.viewer.GetCamera ());
-		});
+        let obj = this;
+        AddButton (this.toolbar, 'open', 'Open model from your device', false, function () {
+            obj.OpenFileBrowserDialog ();
+        });
+        AddButton (this.toolbar, 'open_url', 'Open model from a url', false, function () {
+            obj.dialog = OV.ShowOpenUrlDialog (function (urls) {
+                if (urls.length > 0) {
+                    obj.hashHandler.SetModelFilesToHash (urls);
+                }
+            });
+        });
+        AddSeparator (this.toolbar);
+        AddButton (this.toolbar, 'fit', 'Fit model to Window', false, function () {
+            obj.FitModelToWindow (false);
+        });
+        AddButton (this.toolbar, 'up_y', 'Set Y axis as up vector', false, function () {
+            obj.viewer.SetUpVector (OV.Direction.Y, true);
+        });
+        AddButton (this.toolbar, 'up_z', 'Set Z axis as up vector', false, function () {
+            obj.viewer.SetUpVector (OV.Direction.Z, true);
+        });
+        AddButton (this.toolbar, 'flip', 'Flip up vector', false, function () {
+            obj.viewer.FlipUpVector ();
+        });
+        AddSeparator (this.toolbar);
+        AddRadioButton (this.toolbar, ['fix_up_on', 'fix_up_off'], ['Fixed up vector', 'Free orbit'], 0, false, function (buttonIndex) {
+            if (buttonIndex === 0) {
+                obj.viewer.SetFixUpVector (true);
+            } else if (buttonIndex === 1) {
+                obj.viewer.SetFixUpVector (false);
+            }
+        });
+        AddSeparator (this.toolbar, true);
+        AddButton (this.toolbar, 'export', 'Export model', true, function () {
+            obj.dialog = OV.ShowExportDialog (obj.model);
+        });        
+        AddButton (this.toolbar, 'embed', 'Get embedding code', true, function () {
+            obj.dialog = OV.ShowEmbeddingDialog (obj.modelLoader.GetImporter (), obj.viewer.GetCamera ());
+        });
 
-		this.parameters.fileInput.on ('change', function (ev) {
-			obj.LoadModelFromFileList (ev.target.files);
-		});
-	}
+        this.parameters.fileInput.on ('change', function (ev) {
+            obj.LoadModelFromFileList (ev.target.files);
+        });
+    }
 
-	InitDragAndDrop ()
-	{
-		window.addEventListener ('dragstart', function (ev) {
-			ev.preventDefault ();
-		}, false);
+    InitDragAndDrop ()
+    {
+        window.addEventListener ('dragstart', function (ev) {
+            ev.preventDefault ();
+        }, false);
 
-		window.addEventListener ('dragover', function (ev) {
-			ev.stopPropagation ();
-			ev.preventDefault ();
-			ev.dataTransfer.dropEffect = 'copy';
-		}, false);
+        window.addEventListener ('dragover', function (ev) {
+            ev.stopPropagation ();
+            ev.preventDefault ();
+            ev.dataTransfer.dropEffect = 'copy';
+        }, false);
 
-		let obj = this;
-		window.addEventListener ('drop', function (ev) {
-			ev.stopPropagation ();
-			ev.preventDefault ();
-			obj.LoadModelFromFileList (ev.dataTransfer.files);
-		}, false);
-	}
+        let obj = this;
+        window.addEventListener ('drop', function (ev) {
+            ev.stopPropagation ();
+            ev.preventDefault ();
+            obj.LoadModelFromFileList (ev.dataTransfer.files);
+        }, false);
+    }
 
-	InitModelLoader ()
-	{
-		let obj = this;
-		OV.InitModelLoader (this.modelLoader, {
-			onStart : function ()
-			{
-				obj.ClearModel ();
-			},
-			onFinish : function (importResult, threeMeshes)
-			{
-				obj.OnModelFinished (importResult, threeMeshes);
-			},
-			onRender : function ()
-			{
-				obj.viewer.Render ();
-			}
-		});
-	}
+    InitModelLoader ()
+    {
+        let obj = this;
+        OV.InitModelLoader (this.modelLoader, {
+            onStart : function ()
+            {
+                obj.ClearModel ();
+            },
+            onFinish : function (importResult, threeMeshes)
+            {
+                obj.OnModelFinished (importResult, threeMeshes);
+            },
+            onRender : function ()
+            {
+                obj.viewer.Render ();
+            }
+        });
+    }
 
-	InitMenu ()
-	{
-		function GetMeshUserData (viewer, meshIndex)
-		{
-			let userData = null;
-			viewer.EnumerateMeshesUserData (function (meshUserData) {
-				if (meshUserData.originalMeshIndex === meshIndex) {
-					userData = meshUserData;
-				}
-			});
-			return userData;
-		}
+    InitMenu ()
+    {
+        function GetMeshUserData (viewer, meshIndex)
+        {
+            let userData = null;
+            viewer.EnumerateMeshesUserData (function (meshUserData) {
+                if (meshUserData.originalMeshIndex === meshIndex) {
+                    userData = meshUserData;
+                }
+            });
+            return userData;
+        }
 
-		function GetBoundingBoxInfo (boundingBox)
-		{
-			if (boundingBox === null) {
-				return null;
-			}
-			return {
-				min : new OV.Coord3D (boundingBox.min.x, boundingBox.min.y, boundingBox.min.z),
-				max : new OV.Coord3D (boundingBox.max.x, boundingBox.max.y, boundingBox.max.z)
-			};
-		}
+        function GetBoundingBoxInfo (boundingBox)
+        {
+            if (boundingBox === null) {
+                return null;
+            }
+            return {
+                min : new OV.Coord3D (boundingBox.min.x, boundingBox.min.y, boundingBox.min.z),
+                max : new OV.Coord3D (boundingBox.max.x, boundingBox.max.y, boundingBox.max.z)
+            };
+        }
 
-		function GetMaterialInfo (viewer, model, materialIndex)
-		{
-			function AddTexture (textureNames, type, texture)
-			{
-				if (texture === null) {
-					return;
-				}
-				textureNames.push ({
-					type : type,
-					name : OV.GetFileName (texture.name),
-					path : texture.name
-				});
-			}
+        function GetMaterialInfo (viewer, model, materialIndex)
+        {
+            function AddTexture (textureNames, type, texture)
+            {
+                if (texture === null) {
+                    return;
+                }
+                textureNames.push ({
+                    type : type,
+                    name : OV.GetFileName (texture.name),
+                    path : texture.name
+                });
+            }
 
-			let material = model.GetMaterial (materialIndex);
+            let material = model.GetMaterial (materialIndex);
             let materialInfo = {
                 name : material.name,
                 ambient : material.ambient.Clone (),
                 diffuse : material.diffuse.Clone (),
                 specular : material.specular.Clone (),
                 opacity : material.opacity,
-				textureNames : [],
-				usedByMeshes : []
+                textureNames : [],
+                usedByMeshes : []
             };
 
-			AddTexture (materialInfo.textureNames, 'Base', material.diffuseMap);
-			AddTexture (materialInfo.textureNames, 'Specular', material.specularMap);
-			AddTexture (materialInfo.textureNames, 'Bump', material.bumpMap);
-			AddTexture (materialInfo.textureNames, 'Normal', material.normalMap);
-			AddTexture (materialInfo.textureNames, 'Emissive', material.emissiveMap);
+            AddTexture (materialInfo.textureNames, 'Base', material.diffuseMap);
+            AddTexture (materialInfo.textureNames, 'Specular', material.specularMap);
+            AddTexture (materialInfo.textureNames, 'Bump', material.bumpMap);
+            AddTexture (materialInfo.textureNames, 'Normal', material.normalMap);
+            AddTexture (materialInfo.textureNames, 'Emissive', material.emissiveMap);
 
-			viewer.EnumerateMeshesUserData (function (meshUserData) {
-				if (meshUserData.originalMaterials.indexOf (materialIndex) !== -1) {
-					materialInfo.usedByMeshes.push (meshUserData.originalMeshIndex);
-				}
-			});
-			return materialInfo;
-		}
+            viewer.EnumerateMeshesUserData (function (meshUserData) {
+                if (meshUserData.originalMaterials.indexOf (materialIndex) !== -1) {
+                    materialInfo.usedByMeshes.push (meshUserData.originalMeshIndex);
+                }
+            });
+            return materialInfo;
+        }
 
-		function GetMeshInfo (viewer, model, meshIndex)
-		{
-			let result = {
-				name : null,
-				vertexCount : null,
-				triangleCount : null,
-				usedMaterials : null,
-				boundingBox : null
-			};
-			
-			let mesh = model.GetMesh (meshIndex);
-			result.name = mesh.GetName ();
-			result.vertexCount = mesh.VertexCount ();
-			result.triangleCount = mesh.TriangleCount ();
+        function GetMeshInfo (viewer, model, meshIndex)
+        {
+            let result = {
+                name : null,
+                vertexCount : null,
+                triangleCount : null,
+                usedMaterials : null,
+                boundingBox : null
+            };
+            
+            let mesh = model.GetMesh (meshIndex);
+            result.name = mesh.GetName ();
+            result.vertexCount = mesh.VertexCount ();
+            result.triangleCount = mesh.TriangleCount ();
 
-			let userData = GetMeshUserData (viewer, meshIndex);
-			result.usedMaterials = userData.originalMaterials;
-			result.usedMaterials.sort ();
+            let userData = GetMeshUserData (viewer, meshIndex);
+            result.usedMaterials = userData.originalMaterials;
+            result.usedMaterials.sort ();
 
-			let boundingBox = viewer.GetBoundingBox (function (meshUserData) {
-				return meshUserData.originalMeshIndex === meshIndex;
-			});
-			result.boundingBox = GetBoundingBoxInfo (boundingBox);
-			return result;
-		}
-	
-		function GetModelInfo (model, viewer)
-		{
-			let result = {
-				name : null,
-				vertexCount : model.VertexCount (),
-				triangleCount : model.TriangleCount (),
-				usedMaterials : null,
-				boundingBox : null
-			};
-			let boundingBox = viewer.GetBoundingBox (function (meshUserData) {
-				return true;
-			});
-			result.boundingBox = GetBoundingBoxInfo (boundingBox);
-			return result;
-		}
+            let boundingBox = viewer.GetBoundingBox (function (meshUserData) {
+                return meshUserData.originalMeshIndex === meshIndex;
+            });
+            result.boundingBox = GetBoundingBoxInfo (boundingBox);
+            return result;
+        }
+    
+        function GetModelInfo (model, viewer)
+        {
+            let result = {
+                name : null,
+                vertexCount : model.VertexCount (),
+                triangleCount : model.TriangleCount (),
+                usedMaterials : null,
+                boundingBox : null
+            };
+            let boundingBox = viewer.GetBoundingBox (function (meshUserData) {
+                return true;
+            });
+            result.boundingBox = GetBoundingBoxInfo (boundingBox);
+            return result;
+        }
 
-		let obj = this;
-		this.menu.Init ({
-			openFileBrowserDialog : function () {
-				obj.OpenFileBrowserDialog ();
-			},
-			updateMeshesVisibility : function () {
-				obj.UpdateMeshesVisibility ();
-			},
-			updateMeshesSelection : function () {
-				obj.UpdateMeshesSelection ();
-			},
-			fitMeshToWindow : function (meshIndex) {
-				obj.FitMeshToWindow (meshIndex);
-			},
-			getMaterialInformation : function (materialIndex) {
-				return GetMaterialInfo (obj.viewer, obj.model, materialIndex);
-			},
-			getMeshInformation : function (meshIndex) {
-				return GetMeshInfo (obj.viewer, obj.model, meshIndex);
-			},
-			getModelInformation : function () {
-				return GetModelInfo (obj.model, obj.viewer);
-			}
-		});
-	}	
+        let obj = this;
+        this.menu.Init ({
+            openFileBrowserDialog : function () {
+                obj.OpenFileBrowserDialog ();
+            },
+            updateMeshesVisibility : function () {
+                obj.UpdateMeshesVisibility ();
+            },
+            updateMeshesSelection : function () {
+                obj.UpdateMeshesSelection ();
+            },
+            fitMeshToWindow : function (meshIndex) {
+                obj.FitMeshToWindow (meshIndex);
+            },
+            getMaterialInformation : function (materialIndex) {
+                return GetMaterialInfo (obj.viewer, obj.model, materialIndex);
+            },
+            getMeshInformation : function (meshIndex) {
+                return GetMeshInfo (obj.viewer, obj.model, meshIndex);
+            },
+            getModelInformation : function () {
+                return GetModelInfo (obj.model, obj.viewer);
+            }
+        });
+    }    
 };