Speed up Draco loading

CHANGES.md

@@ -3,18 +3,21 @@ Change Log
 
 ### 1.45 - 2018-05-01
 
+##### Additions :tada:
+* Improved `MapboxImageryProvider` performance by 300% via `tiles.mapbox.com` subdomain switching. [#6426](https://github.com/AnalyticalGraphicsInc/cesium/issues/6426)
+* Added `initWebAssemblyModule` function to `TaskProcessor` to loading a Web Assembly module in a web worker. [#6420](https://github.com/AnalyticalGraphicsInc/cesium/pull/6420)
+* Added `supportsWebAssembly` function to `FeatureDetection` to check if a browser supports loading Web Assembly modules. [#6420](https://github.com/AnalyticalGraphicsInc/cesium/pull/6420)
+
 ##### Fixes :wrench:
 * Fixed bugs in `TimeIntervalCollection.removeInterval`. [#6418](https://github.com/AnalyticalGraphicsInc/cesium/pull/6418).
 * Fixed glTF support to handle meshes with and without tangent vectors, and with/without morph targets, sharing one material. [#6421](https://github.com/AnalyticalGraphicsInc/cesium/pull/6421)
 * Fixed glTF support to handle skinned meshes when no skin is supplied. [#6061](https://github.com/AnalyticalGraphicsInc/cesium/issues/6061)
 * Allow loadWithXhr to work with string URLs in a web worker.
-* `GroundPrimitive`s and `ClassificationPrimitive`s will become ready when `show` is `false`. [#6428](https://github.com/AnalyticalGraphicsInc/cesium/pull/6428) 
+* Faster loading of Draco compressed glTF assets in browsers that support Web Assembly. [#6420](https://github.com/AnalyticalGraphicsInc/cesium/pull/6420)
+* `GroundPrimitive`s and `ClassificationPrimitive`s will become ready when `show` is `false`. [#6428](https://github.com/AnalyticalGraphicsInc/cesium/pull/6428)
 * Fix Firefox WebGL console warnings. [#5912](https://github.com/AnalyticalGraphicsInc/cesium/issues/5912)
 * Fix parsing Cesium.js in older browsers that do not support all TypedArray types. [#6396](https://github.com/AnalyticalGraphicsInc/cesium/pull/6396)
 
-##### Additions :tada:
-* Improved `MapboxImageryProvider` performance by 300% via `tiles.mapbox.com` subdomain switching. [#6426](https://github.com/AnalyticalGraphicsInc/cesium/issues/6426)
-
 ### 1.44 - 2018-04-02
 
 ##### Highlights :sparkler:

Source/Core/FeatureDetection.js

@@ -271,5 +271,16 @@ define([
         return typeof Worker !== 'undefined';
     };
 
+    /**
+     * Detects whether the current browser supports Web Assembly.
+     *
+     * @returns {Boolean} true if the browsers supports Web Assembly, false if not.
+     *
+     * @see {@link https://developer.mozilla.org/en-US/docs/WebAssembly}
+     */
+    FeatureDetection.supportsWebAssembly = function() {
+        return typeof WebAssembly !== 'undefined';
+    };
+
     return FeatureDetection;
 });

Source/Core/TaskProcessor.js

@@ -6,8 +6,10 @@ define([
         './destroyObject',
         './DeveloperError',
         './Event',
+        './FeatureDetection',
         './getAbsoluteUri',
         './isCrossOriginUrl',
+        './Resource',
         './RuntimeError',
         'require'
     ], function(
@@ -18,8 +20,10 @@ define([
         destroyObject,
         DeveloperError,
         Event,
+        FeatureDetection,
         getAbsoluteUri,
         isCrossOriginUrl,
+        Resource,
         RuntimeError,
         require) {
     'use strict';
@@ -161,6 +165,32 @@ define([
         return worker;
     }
 
+    function getWebAssemblyLoaderConfig(processor, wasmOptions) {
+        var config = {
+            modulePath : undefined,
+            wasmBinaryFile : undefined,
+            wasmBinary : undefined
+        };
+
+        // Web assembly not supported, use fallback js module if provided
+        if (!processor._supportsWasm) {
+            if (defined(wasmOptions.fallbackModulePath)) {
+                config.modulePath = buildModuleUrl(wasmOptions.fallbackModulePath);
+            }
+            return when.resolve(config);
+        }
+
+        config.modulePath = buildModuleUrl(wasmOptions.modulePath);
+        config.wasmBinaryFile = buildModuleUrl(wasmOptions.wasmBinaryFile);
+
+        return Resource.fetchArrayBuffer({
+            url: config.wasmBinaryFile
+        }).then(function (arrayBuffer) {
+            config.wasmBinary = arrayBuffer;
+            return config;
+        });
+    }
+
     /**
      * A wrapper around a web worker that allows scheduling tasks for a given worker,
      * returning results asynchronously via a promise.
@@ -182,6 +212,7 @@ define([
         this._activeTasks = 0;
         this._deferreds = {};
         this._nextID = 0;
+        this._supportsWasm = FeatureDetection.supportsWebAssembly(); // exposed for testing purposes
     }
 
     var emptyTransferableObjectArray = [];
@@ -245,6 +276,48 @@ define([
         });
     };
 
+    /**
+     * Posts a message to a web worker with configuration to initialize loading
+     * and compiling a web assembly module asychronously, as well as an optional
+     * fallback JavaScript module to use if Web Assembly is not supported.
+     *
+     * @param {Object} [webAssemblyOptions] An object with the following properties:
+     * @param {String} [webAssemblyOptions.modulePath] The path of the web assembly JavaScript wrapper module.
+     * @param {String} [webAssemblyOptions.wasmBinaryFile] The path of the web assembly binary file.
+     * @param {String} [webAssemblyOptions.fallbackModulePath] The path of the fallback JavaScript module to use if web assembly is not supported.
+     * @returns {Promise.<Object>} A promise that resolves to the result when the web worker has loaded and compiled the web assembly module and is ready to process tasks.
+     */
+    TaskProcessor.prototype.initWebAssemblyModule = function (webAssemblyOptions) {
+        if (!defined(this._worker)) {
+            this._worker = createWorker(this);
+        }
+
+        var deferred = when.defer();
+        var processor = this;
+        var worker = this._worker;
+        getWebAssemblyLoaderConfig(this, webAssemblyOptions).then(function(wasmConfig) {
+            return when(canTransferArrayBuffer(), function(canTransferArrayBuffer) {
+                var transferableObjects;
+                var binary = wasmConfig.wasmBinary;
+                if (defined(binary) && canTransferArrayBuffer) {
+                    transferableObjects = [binary];
+                }
+
+                worker.onmessage = function(event) {
+                    worker.onmessage = function(event) {
+                        completeTask(processor, event.data);
+                    };
+
+                    deferred.resolve(event.data);
+                };
+
+                worker.postMessage({ webAssemblyConfig : wasmConfig }, transferableObjects);
+            });
+        });
+
+        return deferred;
+    };
+
     /**
      * Returns true if this object was destroyed; otherwise, false.
      * <br /><br />

Source/Scene/DracoLoader.js

@@ -32,9 +32,19 @@ define([
 
     // Exposed for testing purposes
     DracoLoader._decoderTaskProcessor = undefined;
+    DracoLoader._taskProcessorReady = false;
     DracoLoader._getDecoderTaskProcessor = function () {
         if (!defined(DracoLoader._decoderTaskProcessor)) {
-            DracoLoader._decoderTaskProcessor = new TaskProcessor('decodeDraco', DracoLoader._maxDecodingConcurrency);
+            var processor = new TaskProcessor('decodeDraco', DracoLoader._maxDecodingConcurrency);
+            processor._supportsWasm = false;
+            processor.initWebAssemblyModule({
+                modulePath : 'ThirdParty/Workers/draco_wasm_wrapper.js',
+                wasmBinaryFile : 'ThirdParty/draco_decoder.wasm',
+                fallbackModulePath : 'ThirdParty/Workers/draco_decoder.js'
+            }).then(function () {
+                DracoLoader._taskProcessorReady = true;
+            });
+            DracoLoader._decoderTaskProcessor = processor;
         }
 
         return DracoLoader._decoderTaskProcessor;
@@ -89,6 +99,11 @@ define([
     }
 
     function scheduleDecodingTask(decoderTaskProcessor, model, loadResources, context) {
+        if (!DracoLoader._taskProcessorReady) {
+            // The task processor is not ready to schedule tasks
+            return;
+        }
+
         var taskData = loadResources.primitivesToDecode.peek();
         if (!defined(taskData)) {
             // All primitives are processing