elation-engine 0.9.109 → 0.9.113

package/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2013-2015 James Baicoianu
+Copyright (c) 2013-2021 James Baicoianu
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/css/engine.css

@@ -1,4 +1,5 @@
-.engine_view {
+engine-systems-render-view {
+  display: block;
   position: relative;
 }
 .engine_view_fullsize {
@@ -80,12 +81,15 @@
   width: 10em;
   display: inline-block;
 }
-.engine_view.cursor_default {
+.engine_view.cursor_default,
+engine-systems-render-view.cursor_default {
   cursor: default;
 }
-.engine_view.cursor_pointer {
+.engine_view.cursor_pointer,
+engine-systems-render-view.cursor_pointer {
   cursor: pointer;
 }
-.engine_view.cursor_crosshair {
+.engine_view.cursor_crosshair,
+engine-systems-render-view.cursor_crosshair {
   cursor: crosshair;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "elation-engine",
   "description": "WebGL/WebVR engine written in Javascript",
-  "version": "0.9.109",
+  "version": "0.9.113",
   "main": "",
   "author": "James Baicoianu",
   "license": "MIT",

package/scripts/assets.js

@@ -1,4 +1,4 @@
-elation.require(['utils.workerpool', 'engine.external.three.three', 'engine.external.libgif', 'engine.external.textdecoder-polyfill'], function() {
+elation.require(['utils.workerpool', 'engine.external.three.three', 'engine.external.libgif', 'engine.external.textdecoder-polyfill', 'engine.external.three.three-loaders', 'engine.external.three.three-vrm'], function() {
 
   THREE.Cache.enabled = true;
 
@@ -67,7 +67,9 @@ elation.require(['utils.workerpool', 'engine.external.three.three', 'engine.exte
     assets: {},
     types: {},
     corsproxy: '',
+    dracopath: false,
     placeholders: {},
+    scriptOverrides: {},
 
     init: function(dummy) {
       var corsproxy = elation.config.get('engine.assets.corsproxy', '');
@@ -79,10 +81,15 @@ elation.require(['utils.workerpool', 'engine.external.three.three', 'engine.exte
     },
     initTextureLoaders: function(rendersystem, libpath) {
       let renderer = rendersystem.renderer;
-      let loader = new THREE.BasisTextureLoader();
-      loader.setTranscoderPath(libpath);
-      loader.detectSupport(renderer);
-      this.basisloader = loader;
+      let basisloader = new THREE.BasisTextureLoader();
+      basisloader.setTranscoderPath(libpath);
+      basisloader.detectSupport(renderer);
+      this.basisloader = basisloader;
+
+      let pmremGenerator = new THREE.PMREMGenerator( renderer );
+      pmremGenerator.compileEquirectangularShader();
+      this.pmremGenerator = pmremGenerator;
+
       this.rendersystem = rendersystem;
     },
     loadAssetPack: function(url, baseurl) {
@@ -132,6 +139,67 @@ if (!ENV_IS_BROWSER) return;
     setPlaceholder: function(type, name) {
       this.placeholders[type] = this.find(type, name);
     },
+    setDracoPath: function(dracopath) {
+      this.dracopath = dracopath;
+    },
+    getOrigin(baseurl=null) {
+      if (baseurl) {
+        let m = baseurl.match(/(https?:\/\/[^\/]+)/i);
+        if (m) {
+          return m[1];
+        }
+      }
+      return self.location.origin;
+    },
+    isURLRelative: function(src) {
+      if (src && src.match(/^([\S]+:)?\/\//) || src[0] == '/') {
+        return false;
+      }
+      return true;
+    },
+    isURLAbsolute: function(src) {
+      return (src[0] == '/' && src[1] != '/');
+    },
+    isURLLocal: function(src) {
+      if (this.isURLBlob(src) || this.isURLData(src)) {
+        return true;
+      }
+      if (src.match(/^(https?:)?\/\//i)) {
+        return (src.indexOf(self.location.origin) == 0);
+      }
+      return (
+        (src[0] == '/' && src[1] != '/') ||
+        (src[0] != '/')
+      );
+    },
+    isURLData: function(url) {
+      if (!url) return false;
+      return url.indexOf('data:') == 0;
+    },
+    isURLBlob: function(url) {
+      if (!url) return false;
+      return url.indexOf('blob:') == 0;
+    },
+    isURLProxied: function(url) {
+      if (!url || !elation.engine.assets.corsproxy) return false;
+      return url.indexOf(elation.engine.assets.corsproxy) == 0;
+    },
+    getFullURL: function(url, baseurl=null) {
+      if (!url) url = '';
+      if (!baseurl) baseurl = '';
+      var fullurl = url;
+      if (!this.isURLBlob(fullurl) && !this.isURLData(fullurl)) {
+        if (this.isURLRelative(fullurl) && fullurl.substr(0, baseurl.length) != baseurl) {
+          fullurl = baseurl + fullurl;
+        } else if (this.isURLProxied(fullurl)) {
+          fullurl = fullurl.replace(elation.engine.assets.corsproxy, '');
+        } else if (this.isURLAbsolute(fullurl)) {
+          fullurl = this.getOrigin(baseurl) + fullurl;
+        }
+      }
+
+      return fullurl;
+    },
     loaderpool: false
   });
   elation.extend('engine.assetdownloader', new function() {
@@ -371,37 +439,22 @@ if (!ENV_IS_BROWSER) return;
       console.log('engine.assets.base load() should not be called directly', this);
     },
     isURLRelative: function(src) {
-      if (src && src.match(/^(https?:)?\/\//) || src[0] == '/') {
-        return false;
-      }
-      return true;
+      return elation.engine.assets.isURLRelative(src);
     },
     isURLAbsolute: function(src) {
-      return (src[0] == '/' && src[1] != '/');
+      return elation.engine.assets.isURLAbsolute(src);
     },
     isURLLocal: function(src) {
-      if (this.isURLBlob(src) || this.isURLData(src)) {
-        return true;
-      }
-      if (src.match(/^(https?:)?\/\//i)) {
-        return (src.indexOf(self.location.origin) == 0);
-      }
-      return (
-        (src[0] == '/' && src[1] != '/') ||
-        (src[0] != '/')
-      );
+      return elation.engine.assets.isURLLocal(src);
     },
     isURLData: function(url) {
-      if (!url) return false;
-      return url.indexOf('data:') == 0;
+      return elation.engine.assets.isURLData(url);
     },
     isURLBlob: function(url) {
-      if (!url) return false;
-      return url.indexOf('blob:') == 0;
+      return elation.engine.assets.isURLBlob(url);
     },
     isURLProxied: function(url) {
-      if (!url || !elation.engine.assets.corsproxy) return false;
-      return url.indexOf(elation.engine.assets.corsproxy) == 0;
+      return elation.engine.assets.isURLProxied(url);
     },
     getFullURL: function(url, baseurl) {
       if (!url) url = this.src;
@@ -414,12 +467,15 @@ if (!ENV_IS_BROWSER) return;
         } else if (this.isURLProxied(fullurl)) {
           fullurl = fullurl.replace(elation.engine.assets.corsproxy, '');
         } else if (this.isURLAbsolute(fullurl)) {
-          fullurl = self.location.origin + fullurl;
+          fullurl = this.getOrigin() + fullurl;
         }
       }
 
       return fullurl;
     },
+    getOrigin() {
+      return elation.engine.assets.getOrigin(this.baseurl);
+    },
     getProxiedURL: function(url, baseurl) {
       var proxiedurl = this.getFullURL(url, baseurl);
       if (this.proxy && this.proxy != 'false' && proxiedurl && elation.engine.assets.corsproxy && !this.isURLLocal(proxiedurl) && proxiedurl.indexOf(elation.engine.assets.corsproxy) == -1) {
@@ -436,6 +492,7 @@ if (!ENV_IS_BROWSER) return;
     },
     getBaseURL: function(url) {
       var url = url || this.getFullURL();
+      if (url.indexOf('/') == -1) url = document.location.href;
       var parts = url.split('/');
       parts.pop();
       return parts.join('/') + '/';
@@ -493,6 +550,7 @@ if (!ENV_IS_BROWSER) return;
     imagetype: '',
     tex_linear: true,
     srgb: false,
+    equi: false,
     hasalpha: null,
     rawimage: null,
     preload: true,
@@ -516,6 +574,9 @@ if (!ENV_IS_BROWSER) return;
         //texture.needsUpdate = true;
         texture.flipY = (this.flipy === true || this.flipy === 'true');
         texture.encoding = (this.srgb ? THREE.sRGBEncoding : THREE.LinearEncoding);
+        if (this.equi) {
+          texture.mapping = THREE.EquirectangularReflectionMapping;
+        }
         if (this.isURLData(fullurl)) {
           this.loadImageByURL();
         } else {
@@ -533,12 +594,32 @@ if (!ENV_IS_BROWSER) return;
                 blob.arrayBuffer()
                   .then(buffer => loader._createTexture(buffer))
                   .then(texture => this.handleLoadBasis(texture))
+              } else if (imagetype == 'exr') {
+                // TODO - this should probably done off-thread if possible, it currently locks rendering for a noticable amount of time
+                let loader = new THREE.EXRLoader();
+                if (loader) {
+                  loader.setDataType( THREE.UnsignedByteType );
+                  loader.load(fullurl, (exrtexture) => {
+                    let exrCubeRenderTarget = elation.engine.assets.pmremGenerator.fromEquirectangular( exrtexture );
+                    let exrBackground = exrCubeRenderTarget.texture;
+
+                    exrtexture.dispose();
+
+                    this._texture = exrBackground;
+                    this.loaded = true;
+                    this.uploaded = false;
+
+                    this.sendLoadEvents();
+
+                  });
+                }
               } else {
+                let blob = xhr.response;
                 if (typeof createImageBitmap == 'function' && type != 'image/gif') {
-                  let blob = xhr.response;
                   createImageBitmap(blob).then(elation.bind(this, this.handleLoad), elation.bind(this, this.handleBitmapError));
                 } else {
-                  this.loadImageByURL();
+                  let imgurl = URL.createObjectURL(blob);
+                  this.loadImageByURL(imgurl);
                 }
               }
 
@@ -560,18 +641,20 @@ if (!ENV_IS_BROWSER) return;
         texture.needsUpdate = true;
         texture.flipY = this.flipy;
 
-        elation.events.add(this.canvas, 'update', () => texture.needsUpdate = true);
+        elation.events.add(this.canvas, 'asset_update', () => { texture.needsUpdate = true; });
         this.loaded = true;
         setTimeout(() => this.sendLoadEvents(), 0);
       }
     },
-    loadImageByURL: function() {
-      var proxiedurl = this.getProxiedURL(this.src);
+    loadImageByURL: function(src) {
+      if (!src) {
+        src = this.getProxiedURL(this.src);
+      }
       var image = document.createElementNS( 'http://www.w3.org/1999/xhtml', 'img' );
       elation.events.add(image, 'load', elation.bind(this, this.handleLoad, image));
       elation.events.add(image, 'error', elation.bind(this, this.handleError));
       image.crossOrigin = 'anonymous';
-      image.src = proxiedurl;
+      image.src = src;
       return image;
     },
     getCanvas: function() {
@@ -673,8 +756,8 @@ if (!ENV_IS_BROWSER) return;
         canvas.originalSrc = this.src;
 
         var imagemax = elation.utils.any(this.maxsize, elation.config.get('engine.assets.image.maxsize', Infinity));
-        canvas.width = (this.tex_linear ? Math.min(imagemax, this.nextHighestPowerOfTwo(image.width)) : image.width);
-        canvas.height = (this.tex_linear ? Math.min(imagemax, this.nextHighestPowerOfTwo(image.height)) : image.height);
+        canvas.width = Math.min(image.width, imagemax); //(this.tex_linear ? Math.min(imagemax, this.nextHighestPowerOfTwo(image.width)) : image.width);
+        canvas.height = Math.min(image.height, imagemax); //(this.tex_linear ? Math.min(imagemax, this.nextHighestPowerOfTwo(image.height)) : image.height);
         var ctx = canvas.getContext("2d");
         ctx.drawImage(image, 0, 0, image.width, image.height, 0, 0, canvas.width, canvas.height);
         if (this.hasalpha === null) {
@@ -889,10 +972,13 @@ if (!ENV_IS_BROWSER) return;
         if (url.match(/\.webm$/)) {
           this.hasalpha = true;
         }
+        if ('requestVideoFrameCallback' in video) {
+          video.requestVideoFrameCallback((time, metadata) => this.updateVideoFrame(time, metadata));
+        }
       }
       this._video = video;
       let textureFormat = (this.format == THREE.RGBFormat && this.hasalpha ? THREE.RGBAFormat : this.format);
-      if (this.sbs3d) {
+      if (false && this.sbs3d) {
         this._texture = new THREE.SBSVideoTexture(video, THREE.UVMapping, THREE.ClampToEdgeWrapping, THREE.ClampToEdgeWrapping, null, null, textureFormat, this.type);
         this._texture.reverse = this.reverse3d;
       } else {
@@ -979,6 +1065,11 @@ if (!ENV_IS_BROWSER) return;
     handleAutoplayFail: function(ev) {
       elation.events.fire({element: this._texture, type: 'autoplayfail'});
     },
+    updateVideoFrame: function(time, metadata) {
+      //elation.events.fire({element: this, type: 'videoframe'});
+      elation.events.fire({element: this._texture, type: 'videoframe'});
+      this._video.requestVideoFrameCallback((time, metadata) => this.updateVideoFrame(time, metadata));
+    },
     getInstance: function(args) {
       if (!this._texture) {
         this.load();
@@ -1019,8 +1110,8 @@ if (!ENV_IS_BROWSER) return;
               hls.destroy();
               break;
           }
-        } else if (data.details === 'internalException' && data.type === 'otherError' && isMobile()) {
-          this.hlsDropHighestLevel();
+        //} else if (data.details === 'internalException' && data.type === 'otherError' && isMobile()) {
+        //  this.hlsDropHighestLevel();
         } else if (data.details == 'bufferStalledError') {
           //hls.recoverMediaError();
         }
@@ -1153,6 +1244,7 @@ if (!ENV_IS_BROWSER) return;
     compression: 'none',
     object: false,
     assetpack: null,
+    animations: false,
 
     loadworkers: [
     ],
@@ -1183,29 +1275,13 @@ if (!ENV_IS_BROWSER) return;
       this.instances.push(group);
       return group;
     },
-    fillGroup: function(group, source) {
+    fillGroup: function(group, source, clone=true) {
       if (!source) source = this._model;
       if (source) {
-/*
-        group.position.copy(source.position);
-        group.quaternion.copy(source.quaternion);
-        //group.scale.copy(source.scale);
-        if (source.children) {
-          source.children.forEach(function(n) {
-            group.add(n.clone());
-          });
-        }
-*/
-        var newguy = source.clone();
+        var newguy = (clone ? THREE.SkeletonUtils.cloneWithAnimations(source, this.animations) : source);
         group.add(newguy);
         newguy.updateMatrix(true);
         newguy.updateMatrixWorld(true);
-
-        newguy.traverse(function(n) {
-          if (n instanceof THREE.SkinnedMesh) {
-            //n.rebindByName(newguy);
-          }
-        });
       }
       return group;
     },
@@ -1326,7 +1402,7 @@ if (!ENV_IS_BROWSER) return;
         elation.bind(this, function(events) {
           var files = [];
           events.forEach(function(ev) {
-            var url = ev.target.responseURL,
+            var url = ev.target.responseURL.replace(elation.engine.assets.corsproxy, ''),
                 data = ev.target.response;
             if (url == jobdata.src) {
               jobdata.srcdata = data;
@@ -1335,7 +1411,11 @@ if (!ENV_IS_BROWSER) return;
             }
           });
           this.state = 'processing';
-          this.loadWithWorker(jobdata);
+          if (this.isglTF(jobdata)) {
+            this.loadglTF(jobdata);
+          } else {
+            this.loadWithWorker(jobdata);
+          }
           elation.events.fire({element: this, type: 'asset_load_processing'});
         }), 
         elation.bind(this, function(error) {
@@ -1345,6 +1425,41 @@ if (!ENV_IS_BROWSER) return;
       );
       elation.events.fire({element: this, type: 'asset_load_queued'});
     },
+    isglTF: function(jobdata) {
+      let d = new Uint8Array(jobdata.srcdata);
+      let isGLB = String.fromCharCode(d[0]) == 'g' && String.fromCharCode(d[1]) == 'l' && String.fromCharCode(d[2]) == 'T' && String.fromCharCode(d[3]) == 'F';
+      return isGLB;
+    },
+    loadglTF: function(jobdata) {
+      let proxypath = this.getProxiedURL(jobdata.src);
+      var loader = new THREE.GLTFLoader();
+      if (elation.engine.assets.dracopath) {
+        loader.setDRACOLoader(new THREE.DRACOLoader().setDecoderPath(elation.engine.assets.dracopath));
+      }
+      this._model = new THREE.Group();
+      this._model.userData.loaded = false;
+      loader.parse(jobdata.srcdata, proxypath, elation.bind(this, function(modeldata) {
+        if (modeldata.scene) {
+          this.loaded = true;
+          this.animations = modeldata.animations;
+
+          // Cmompute vertex normals, if missing
+          modeldata.scene.traverse(n => {
+            if (n.geometry && !n.geometry.attributes.normal) {
+              n.geometry.computeVertexNormals();
+            }
+          });
+
+          if (modeldata.userData && modeldata.userData.gltfExtensions && modeldata.userData.gltfExtensions.VRM) {
+            THREE.VRM.from(modeldata).then(vrm => {
+              this.vrm = vrm;
+              this.complete(vrm.scene);
+            });
+          }
+          this.complete(modeldata.scene);
+        }
+      }));
+    },
     loadWithWorker: function(jobdata) {
       this._model = new THREE.Group();
       this._model.userData.loaded = false;
@@ -1367,7 +1482,7 @@ if (!ENV_IS_BROWSER) return;
       this.removePlaceholders();
       this._model.userData.loaded = true;
       //this._model.add(scene);
-      this.fillGroup(this._model, object);
+      this.fillGroup(this._model, object, false);
 
       this.extractTextures(object);
       //this.assignTextures(scene);
@@ -1867,6 +1982,7 @@ if (!ENV_IS_BROWSER) return;
   elation.define('engine.assets.script', {
     assettype: 'script',
     src: false,
+    override: false,
     code: false,
 
     _construct: function(args) {
@@ -1885,14 +2001,31 @@ if (!ENV_IS_BROWSER) return;
         elation.engine.assetdownloader.fetchURL(url).then(ev => {
           let decoder = new TextDecoder('utf-8');
           this.parse(decoder.decode(ev.target.response));
+        },
+        err => {
+          this.handleError();
         });
       }
     },
     parse: function(data) {
-      //var blob = new Blob(['(function(window) {\n' + data + '\n})(self)'], {type: 'application/javascript'});
-      var blob = new Blob(['\n' + data + '\n'], {type: 'application/javascript'});
+      // If overrides are specified, we inject them into the script as locally-scoped variables
+      // This lets us bind our scripts to specific instances of objects, rather than relying on globals
+      let overrideScript = '';
+      if (this.override) {
+        let overrides = elation.engine.assets.scriptOverrides[this.src];
+        if (!overrides) {
+          overrides = elation.engine.assets.scriptOverrides[this.src] = {};
+        }
+        for (let k in this.override) {
+          overrides[k] = this.override[k];
+          overrideScript += 'let ' + k + ' = elation.engine.assets.scriptOverrides["' + this.src + '"]["' + k + '"];\n';
+        }
+      }
+      //var blob = new Blob(['\n(function() { ' + overrideScript + '\n' + data + ' })();\n'], {type: 'application/javascript'});
+      var blob = new Blob(['\n{ ' + overrideScript + '\n' + data + ' };\n'], {type: 'application/javascript'});
       var bloburl = URL.createObjectURL(blob);
       this._script.src = bloburl;
+      this.code = data;
       this.loaded = true;
       elation.events.fire({type: 'asset_load', element: this._script});
       elation.events.fire({type: 'asset_load', element: this});
@@ -1902,6 +2035,7 @@ if (!ENV_IS_BROWSER) return;
     },
     handleError: function(ev) {
       this._script = false;
+      elation.events.fire({element: this, type: 'asset_error'});
     },
     getInstance: function(args) {
       if (!this._script) {
@@ -1978,7 +2112,7 @@ if (!ENV_IS_BROWSER) return;
           { name: 'iChannel2', value: new THREE.Texture() },
           { name: 'iChannel3', value: new THREE.Texture() },
         ];
-
+        this.uniformsMap = this.parseUniforms(this.uniforms);
         // FIXME - this hack is used to update the Shadertoy uniforms at 60fps, but it should be abstracted out and driven by the object that's using the shader
         // As a general shader harness, this will give us the means to update uniforms based on custom functions, so we can pass in things like mouse position,
         // multiple textures, audio data, etc.
@@ -1986,15 +2120,19 @@ if (!ENV_IS_BROWSER) return;
         let starttime = new Date().getTime();
             lasttime = starttime;
         setInterval(() => {
-          if (this._material && this._material.uniforms.iTime) {
-            let d = new Date();
-            let now = d.getTime();
+          let d = new Date();
+          let now = d.getTime();
+          this.uniformsMap.iTime.value = (now - starttime) / 1000;
+          this.uniformsMap.iTimeDelta.value = (now - lasttime) / 1000;
+          this.uniformsMap.iFrame.value++;
+          this.uniformsMap.iDate.value.set(d.getFullYear(), d.getMonth() + 1, d.getDate(), (d.getHours() * 60 + d.getMinutes()) * 60 + d.getSeconds() + d.getMilliseconds() / 1000);
 
-            this._material.uniforms.iTime.value = (now - starttime) / 1000;
-            this._material.uniforms.iTimeDelta.value = (now - lasttime) / 1000;
-            this._material.uniforms.iFrame.value++;
+          if (this._material && this._material.uniforms.iTime) {
 
-            this._material.uniforms.iDate.value.set(d.getFullYear(), d.getMonth() + 1, d.getDate(), (d.getHours() * 60 + d.getMinutes()) * 60 + d.getSeconds() + d.getMilliseconds() / 1000);
+            this._material.uniforms.iTime.value = this.uniformsMap.iTime.value;
+            this._material.uniforms.iTimeDelta.value = this.uniformsMap.iTimeDelta.value;
+            this._material.uniforms.iFrame.value = this.uniformsMap.iFrame.value;
+            this._material.uniforms.iDate.value = this.uniformsMap.iDate.value;
             lasttime = now;
           }
         }, 16);
@@ -2010,6 +2148,7 @@ if (!ENV_IS_BROWSER) return;
           elation.engine.assetdownloader.fetchURL(this.getProxiedURL(this.fragment_src)).then(ev => {
             let decoder = new TextDecoder('utf-8');
             let shadercode = decoder.decode(ev.target.response);
+            this.loaded = true;
             if (this.shadertype == 'default') {
               this._material.fragmentShader = shadercode;
             } else if (this.shadertype == 'shadertoy') {
@@ -2065,7 +2204,7 @@ if (!ENV_IS_BROWSER) return;
         }
       }
       if (this.uniforms) {
-        this._material.uniforms = this.parseUniforms(this.uniforms);
+        this._material.uniforms = this.uniformsMap;
       }
       this.complete();
     },
@@ -2077,7 +2216,7 @@ if (!ENV_IS_BROWSER) return;
     parseUniforms(uniforms) {
       let matuniforms = {};
       uniforms.forEach(u => {
-        matuniforms[u.name] = { value: u.value };
+        matuniforms[u.name] = u;
       });
       return matuniforms;
     },

package/scripts/assetworker.js

@@ -6,7 +6,7 @@ elation.require([
     'engine.external.pako',
     'engine.external.zlib.inflate',
     'engine.external.xmldom',
-    'engine.external.three.three', 'engine.external.three.three-loaders',
+    'engine.external.three.three', 'engine.external.three.three-loaders', 'engine.external.three.fflate',
     'engine.external.textdecoder-polyfill'
   ], function() {
 
@@ -385,13 +385,6 @@ elation.require([
     convertToJSON: function(scene) {
       var json;
       if (scene) {
-        // Convert Geometries to BufferGeometries
-        scene.traverse(function(n) {
-          if (n.geometry && n.geometry instanceof THREE.Geometry) {
-            var bufgeo = new THREE.BufferGeometry().fromGeometry(n.geometry);
-            n.geometry = bufgeo;
-          }
-        });
         json = scene.toJSON();
       }
       return json;
@@ -411,7 +404,7 @@ elation.require([
           var loader = new THREE.ColladaLoader();
           var corsproxy = elation.engine.assets.corsproxy || '';
           loader.setResourcePath(corsproxy + baseurl);
-          loader.options.upAxis = 'Y';
+          //loader.options.upAxis = 'Y';
           var xml = this.convertArrayBufferToString(bindata);
           var parsed = loader.parse(xml);
           var imageids = Object.keys(parsed.library.images);
@@ -420,28 +413,14 @@ elation.require([
             //parsed.library.images[imageids[i]].build = this.getProxiedURL(img);
           }
           parsed.scene.traverse(function(n) {
-            if ((n.geometry instanceof THREE.BufferGeometry && !n.geometry.attributes.normals) ||
-                (n.geometry instanceof THREE.Geometry && !n.geometry.faceVertexNormals)) {
-              n.geometry.computeFaceNormals();
+            if (n.geometry && n.geometry instanceof THREE.BufferGeometry && !n.geometry.attributes.normals) {
+              //n.geometry.computeFaceNormals();
               n.geometry.computeVertexNormals();
             }
-            // Convert to BufferGeometry for better loading efficiency
-            if (n.geometry && n.geometry instanceof THREE.Geometry) {
-              n.geometry.mergeVertices();
-              var bufgeo = new THREE.BufferGeometry().fromGeometry(n.geometry);
-              n.geometry = bufgeo;
-            } else if (n.geometry && n.geometry instanceof THREE.BufferGeometry) {
-/*
-              var geo = new THREE.Geometry().fromBufferGeometry(n.geometry);
-              geo.mergeVertices();
-              geo.computeVertexNormals();
-              n.geometry = new THREE.BufferGeometry().fromGeometry(geo);
-*/
-            }
           });
           data = parsed;        
 
-          data.scene.animations = parsed.animations;
+          //data.scene.animations = parsed.animations;
           data.scene.rotation.x = -Math.PI/2;
           data.scene.updateMatrix();
           resolve(data.scene.toJSON());
@@ -460,13 +439,6 @@ elation.require([
         var data = this.convertArrayBufferToString(bindata);
         var modeldata = loader.parse(data);
 
-        modeldata.traverse(function(n) {
-          if (n.geometry && n.geometry instanceof THREE.Geometry) {
-            var bufgeo = new THREE.BufferGeometry().fromGeometry(n.geometry);
-            n.geometry = bufgeo;
-          }
-        });
-
         resolve(modeldata.toJSON());
       }));
     }