elation-engine 0.9.124 → 0.9.125

package/package.json

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

package/scripts/assets.js

@@ -629,6 +629,15 @@ if (!ENV_IS_BROWSER) return;
 
                   });
                 }
+              } else if (imagetype == 'dds') {
+                let loader = new THREE.DDSLoader();
+                loader.load(this.getProxiedURL(this.src), data => {
+                  data.encoding = THREE.sRGBEncoding;
+                  this._texture = data;
+                  this.loaded = true;
+                  this.uploaded = false;
+                  this.sendLoadEvents();
+                });
               } else {
                 let blob = xhr.response;
                 if (typeof createImageBitmap == 'function' && type != 'image/gif') {
@@ -964,6 +973,20 @@ newcanvas.style.left = 0;
         this._texture.dispose();
       }
       this.loaded = false;
+    },
+    toCubemap(texture) {
+      let pmremGenerator = new THREE.PMREMGenerator( elation.engine.assets.rendersystem.renderer );
+      pmremGenerator.compileEquirectangularShader();
+      if (!texture) texture = this._texture;
+
+      let cubeRenderTarget = pmremGenerator.fromEquirectangular( texture );
+      let cubemap = cubeRenderTarget.texture;
+
+      //texture.dispose();
+
+      this._texture = cubemap;
+      this.loaded = true;
+      this.uploaded = false;
     }
   }, elation.engine.assets.base);
 
@@ -1432,7 +1455,7 @@ console.log('set up hls', hlsConfig);
       if (this.object) {
         this.loading = false;
         this.loaded = true;
-        this.state = 'complete';
+        this.state = 'processing';
         this._model = new THREE.Group();
         setTimeout(() => this.complete(this.object), 0);
       } else if (this.src) {

package/scripts/engine.js

@@ -267,7 +267,7 @@ elation.require(deps, function() {
       this.defineAttributes({
         name: { type: 'string', default: 'default' },
         resolution: { type: 'string' },
-        fullsize: { type: 'boolean', default: true },
+        fullsize: { type: 'boolean', default: false },
         crosshair: { type: 'boolean', default: false },
         picking: { type: 'boolean', default: false },
         stats: { type: 'boolean', default: false },
@@ -276,6 +276,10 @@ elation.require(deps, function() {
       });
       if (this.fullsize == 'false') this.fullsize = false; // FIXME - the type coersion should be doing this for us
       //this.name = this.args.name || 'default';
+      //this.setEngineConfig(this.args);
+    }
+    create() {
+      super.create();
       this.enginecfg = {
         systems: [
           "physics",
@@ -290,14 +294,10 @@ elation.require(deps, function() {
         stats: false,
         picking: true,
         fullsize: this.fullsize && this.fullsize != 'false',
-        resolution: null,
+        resolution: this.resolution.split('x'),
         useWebVRPolyfill: true,
         enablePostprocessing: true
       };
-      //this.setEngineConfig(this.args);
-    }
-    create() {
-      super.create();
       this.initEngine();
       this.loadEngine();
     }

package/scripts/external/three/three-loaders.js

@@ -16920,3 +16920,247 @@ THREE.MMDLoader = ( function () {
 	THREE.KTX2Loader = KTX2Loader;
 
 } )();
+( function () {
+
+  class DDSLoader extends THREE.CompressedTextureLoader {
+
+    constructor( manager ) {
+
+      super( manager );
+
+    }
+    parse( buffer, loadMipmaps ) {
+
+      const dds = {
+        mipmaps: [],
+        width: 0,
+        height: 0,
+        format: null,
+        mipmapCount: 1
+      };
+
+      // Adapted from @toji's DDS utils
+      // https://github.com/toji/webgl-texture-utils/blob/master/texture-util/dds.js
+
+      // All values and structures referenced from:
+      // http://msdn.microsoft.com/en-us/library/bb943991.aspx/
+
+      const DDS_MAGIC = 0x20534444;
+
+      // const DDSD_CAPS = 0x1;
+      // const DDSD_HEIGHT = 0x2;
+      // const DDSD_WIDTH = 0x4;
+      // const DDSD_PITCH = 0x8;
+      // const DDSD_PIXELFORMAT = 0x1000;
+      const DDSD_MIPMAPCOUNT = 0x20000;
+      // const DDSD_LINEARSIZE = 0x80000;
+      // const DDSD_DEPTH = 0x800000;
+
+      // const DDSCAPS_COMPLEX = 0x8;
+      // const DDSCAPS_MIPMAP = 0x400000;
+      // const DDSCAPS_TEXTURE = 0x1000;
+
+      const DDSCAPS2_CUBEMAP = 0x200;
+      const DDSCAPS2_CUBEMAP_POSITIVEX = 0x400;
+      const DDSCAPS2_CUBEMAP_NEGATIVEX = 0x800;
+      const DDSCAPS2_CUBEMAP_POSITIVEY = 0x1000;
+      const DDSCAPS2_CUBEMAP_NEGATIVEY = 0x2000;
+      const DDSCAPS2_CUBEMAP_POSITIVEZ = 0x4000;
+      const DDSCAPS2_CUBEMAP_NEGATIVEZ = 0x8000;
+      // const DDSCAPS2_VOLUME = 0x200000;
+
+      // const DDPF_ALPHAPIXELS = 0x1;
+      // const DDPF_ALPHA = 0x2;
+      // const DDPF_FOURCC = 0x4;
+      // const DDPF_RGB = 0x40;
+      // const DDPF_YUV = 0x200;
+      // const DDPF_LUMINANCE = 0x20000;
+
+      function fourCCToInt32( value ) {
+
+        return value.charCodeAt( 0 ) + ( value.charCodeAt( 1 ) << 8 ) + ( value.charCodeAt( 2 ) << 16 ) + ( value.charCodeAt( 3 ) << 24 );
+
+      }
+
+      function int32ToFourCC( value ) {
+
+        return String.fromCharCode( value & 0xff, value >> 8 & 0xff, value >> 16 & 0xff, value >> 24 & 0xff );
+
+      }
+
+      function loadARGBMip( buffer, dataOffset, width, height ) {
+
+        const dataLength = width * height * 4;
+        const srcBuffer = new Uint8Array( buffer, dataOffset, dataLength );
+        const byteArray = new Uint8Array( dataLength );
+        let dst = 0;
+        let src = 0;
+        for ( let y = 0; y < height; y ++ ) {
+
+          for ( let x = 0; x < width; x ++ ) {
+
+            const b = srcBuffer[ src ];
+            src ++;
+            const g = srcBuffer[ src ];
+            src ++;
+            const r = srcBuffer[ src ];
+            src ++;
+            const a = srcBuffer[ src ];
+            src ++;
+            byteArray[ dst ] = r;
+            dst ++; //r
+            byteArray[ dst ] = g;
+            dst ++; //g
+            byteArray[ dst ] = b;
+            dst ++; //b
+            byteArray[ dst ] = a;
+            dst ++; //a
+
+          }
+
+        }
+
+        return byteArray;
+
+      }
+
+      const FOURCC_DXT1 = fourCCToInt32( 'DXT1' );
+      const FOURCC_DXT3 = fourCCToInt32( 'DXT3' );
+      const FOURCC_DXT5 = fourCCToInt32( 'DXT5' );
+      const FOURCC_ETC1 = fourCCToInt32( 'ETC1' );
+      const headerLengthInt = 31; // The header length in 32 bit ints
+
+      // Offsets into the header array
+
+      const off_magic = 0;
+      const off_size = 1;
+      const off_flags = 2;
+      const off_height = 3;
+      const off_width = 4;
+      const off_mipmapCount = 7;
+
+      // const off_pfFlags = 20;
+      const off_pfFourCC = 21;
+      const off_RGBBitCount = 22;
+      const off_RBitMask = 23;
+      const off_GBitMask = 24;
+      const off_BBitMask = 25;
+      const off_ABitMask = 26;
+
+      // const off_caps = 27;
+      const off_caps2 = 28;
+      // const off_caps3 = 29;
+      // const off_caps4 = 30;
+
+      // Parse header
+
+      const header = new Int32Array( buffer, 0, headerLengthInt );
+      if ( header[ off_magic ] !== DDS_MAGIC ) {
+
+        console.error( 'THREE.DDSLoader.parse: Invalid magic number in DDS header.' );
+        return dds;
+
+      }
+
+      let blockBytes;
+      const fourCC = header[ off_pfFourCC ];
+      let isRGBAUncompressed = false;
+      switch ( fourCC ) {
+
+        case FOURCC_DXT1:
+          blockBytes = 8;
+          dds.format = THREE.RGB_S3TC_DXT1_Format;
+          break;
+        case FOURCC_DXT3:
+          blockBytes = 16;
+          dds.format = THREE.RGBA_S3TC_DXT3_Format;
+          break;
+        case FOURCC_DXT5:
+          blockBytes = 16;
+          dds.format = THREE.RGBA_S3TC_DXT5_Format;
+          break;
+        case FOURCC_ETC1:
+          blockBytes = 8;
+          dds.format = THREE.RGB_ETC1_Format;
+          break;
+        default:
+          if ( header[ off_RGBBitCount ] === 32 && header[ off_RBitMask ] & 0xff0000 && header[ off_GBitMask ] & 0xff00 && header[ off_BBitMask ] & 0xff && header[ off_ABitMask ] & 0xff000000 ) {
+
+            isRGBAUncompressed = true;
+            blockBytes = 64;
+            dds.format = THREE.RGBAFormat;
+
+          } else {
+
+            console.error( 'THREE.DDSLoader.parse: Unsupported FourCC code ', int32ToFourCC( fourCC ) );
+            return dds;
+
+          }
+
+      }
+
+      dds.mipmapCount = 1;
+      if ( header[ off_flags ] & DDSD_MIPMAPCOUNT && loadMipmaps !== false ) {
+
+        dds.mipmapCount = Math.max( 1, header[ off_mipmapCount ] );
+
+      }
+
+      const caps2 = header[ off_caps2 ];
+      dds.isCubemap = caps2 & DDSCAPS2_CUBEMAP ? true : false;
+      if ( dds.isCubemap && ( ! ( caps2 & DDSCAPS2_CUBEMAP_POSITIVEX ) || ! ( caps2 & DDSCAPS2_CUBEMAP_NEGATIVEX ) || ! ( caps2 & DDSCAPS2_CUBEMAP_POSITIVEY ) || ! ( caps2 & DDSCAPS2_CUBEMAP_NEGATIVEY ) || ! ( caps2 & DDSCAPS2_CUBEMAP_POSITIVEZ ) || ! ( caps2 & DDSCAPS2_CUBEMAP_NEGATIVEZ ) ) ) {
+
+        console.error( 'THREE.DDSLoader.parse: Incomplete cubemap faces' );
+        return dds;
+
+      }
+
+      dds.width = header[ off_width ];
+      dds.height = header[ off_height ];
+      let dataOffset = header[ off_size ] + 4;
+
+      // Extract mipmaps buffers
+
+      const faces = dds.isCubemap ? 6 : 1;
+      for ( let face = 0; face < faces; face ++ ) {
+
+        let width = dds.width;
+        let height = dds.height;
+        for ( let i = 0; i < dds.mipmapCount; i ++ ) {
+
+          let byteArray, dataLength;
+          if ( isRGBAUncompressed ) {
+
+            byteArray = loadARGBMip( buffer, dataOffset, width, height );
+            dataLength = byteArray.length;
+
+          } else {
+
+            dataLength = Math.max( 4, width ) / 4 * Math.max( 4, height ) / 4 * blockBytes;
+            byteArray = new Uint8Array( buffer, dataOffset, dataLength );
+
+          }
+
+          const mipmap = {
+            'data': byteArray,
+            'width': width,
+            'height': height
+          };
+          dds.mipmaps.push( mipmap );
+          dataOffset += dataLength;
+          width = Math.max( width >> 1, 1 );
+          height = Math.max( height >> 1, 1 );
+
+        }
+
+      }
+
+      return dds;
+
+    }
+
+  }
+
+  THREE.DDSLoader = DDSLoader;
+
+} )();

package/scripts/systems/controls.js

@@ -810,7 +810,7 @@ elation.require(['ui.window', 'ui.panel', 'ui.toggle', 'ui.slider', 'ui.label',
         this.state[bindid] = 0;
         this.changes.push(bindid);
       }, 10);
-      ev.preventDefault();
+      //ev.preventDefault();
     }
     this.keydown = function(ev) {
       // Send key events for both keyboard_<key> and keyboard_<modname>_<key>

package/scripts/systems/render.js

@@ -1327,7 +1327,7 @@ console.log('toggle render mode: ' + this.rendermode + ' => ' + mode, passidx, l
         fakeev.stopPropagation = ev.stopPropagation.bind(ev);
         this.mousedown(fakeev);
 //      }
-        ev.preventDefault();
+        //ev.preventDefault();
     }
     touchmove(ev) {
       this.mousepos = [ev.touches[0].clientX, ev.touches[0].clientY, document.body.scrollTop];