Support for a more compressed scene file format (playcanvas#2294)

zachpeterpaul · zachppaul · web-flow · commit 0e3022cef207 · 2020-09-02T10:24:11.000-07:00
* initial decompress

* do nothing without the compressed field

* move decompress data

* decompress in template

* decompress in hierarchy

* use underscores with private vars

* rm else return

* refactor parser for speed

* rm expanding entities in templates

* decompress entities only

* move decompress to scene parser

* initial decompress

* handle triple vectors

* reorder array and map check

* change map check

* rename fields

* use field map array

* edits for lint

* comments in decompress

* move decompress call to parser

* add utils comments

Co-authored-by: zachppaul &lt;zachppaul@gmail.com&gt;
diff --git a/src/compress/compress-utils.js b/src/compress/compress-utils.js
@@ -0,0 +1,75 @@
+var CompressUtils = {
+    /**
+     * @private
+     * @function
+     * @name pc.CompressUtils#setCompressedPRS
+     * @description Set position, rotation and scale of an entity
+     *   using compressed scene format
+     * @param {pc.Entity} entity - The entity
+     * @param {object} data - Json entity data from a compressed scene
+     * @param {object} compressed - Compression metadata
+     */
+    setCompressedPRS: function (entity, data, compressed) {
+        var a = compressed.singleVecs;
+
+        var b, i;
+
+        var v = data.___1;
+
+        if (!v) {
+            b = compressed.tripleVecs;
+
+            i = data.___2;
+        }
+
+        var n = v ? v[0] : b[i];
+
+        entity.setLocalPosition(a[n], a[n + 1], a[n + 2]);
+
+        n = v ? v[1] : b[i + 1];
+
+        entity.setLocalEulerAngles(a[n], a[n + 1], a[n + 2]);
+
+        n = v ? v[2] : b[i + 2];
+
+        entity.setLocalScale(a[n], a[n + 1], a[n + 2]);
+    },
+
+    /**
+     * @private
+     * @function
+     * @name pc.CompressUtils#oneCharToKey
+     * @description Retrieve the original field name (key) for a
+     *   single character key from a compressed entity
+     * @param {string} s - The compressed key string
+     * @param {object} data - Compression metadata
+     * @returns {string} The original key
+     */
+    oneCharToKey: function (s, data) {
+        var i = s.charCodeAt(0) - data.fieldFirstCode;
+
+        return data.fieldArray[i];
+    },
+
+    /**
+     * @private
+     * @function
+     * @name pc.CompressUtils#multCharToKey
+     * @description Retrieve the original field name (key) for a
+     *   multi-character key from a compressed entity
+     * @param {string} s - The compressed key string
+     * @param {object} data - Compression metadata
+     * @returns {string} The original key
+     */
+    multCharToKey: function (s, data) {
+        var ind = 0;
+
+        for (var i = 0; i < s.length; i++) {
+            ind = ind * data.fieldCodeBase + s.charCodeAt(i) - data.fieldFirstCode;
+        }
+
+        return data.fieldArray[ind];
+    }
+};
+
+export { CompressUtils };
diff --git a/src/compress/decompress.js b/src/compress/decompress.js
@@ -0,0 +1,71 @@
+import { CompressUtils } from './compress-utils';
+
+/**
+ * @private
+ * @class
+ * @name pc.Decompress
+ * @classdesc Reconstruct original object field names in a
+ *   compressed scene
+ * @param {object} node - The current node of the object being
+ *   decompressed, initially the 'entities' field of a scene
+ * @param {object} data - Compression metadata
+ */
+function Decompress(node, data) {
+    this._node = node;
+
+    this._data = data;
+}
+
+Object.assign(Decompress.prototype, {
+    run: function () {
+        var type = Object.prototype.toString.call(this._node);
+
+        if (type === '[object Object]') {
+            this._handleMap();
+
+        } else if (type === '[object Array]') {
+            this._handleArray();
+
+        } else {
+            this._result = this._node;
+        }
+
+        return this._result;
+    },
+
+    _handleMap: function () {
+        this._result = {};
+
+        var a = Object.keys(this._node);
+
+        a.forEach(this._handleKey, this);
+    },
+
+    _handleKey: function (origKey) {
+        var newKey = origKey;
+
+        var len = origKey.length;
+
+        if (len === 1) {
+            newKey = CompressUtils.oneCharToKey(origKey, this._data);
+        } else if (len === 2) {
+            newKey = CompressUtils.multCharToKey(origKey, this._data);
+        }
+
+        this._result[newKey] = new Decompress(this._node[origKey], this._data).run();
+    },
+
+    _handleArray: function () {
+        this._result = [];
+
+        this._node.forEach(this._handleArElt, this);
+    },
+
+    _handleArElt: function (elt) {
+        var v = new Decompress(elt, this._data).run();
+
+        this._result.push(v);
+    }
+});
+
+export { Decompress };
diff --git a/src/resources/parser/scene.js b/src/resources/parser/scene.js
@@ -1,6 +1,8 @@
 import { Entity } from '../../framework/entity.js';
 
 import { TemplateUtils } from '../../templates/template-utils.js';
+import { CompressUtils } from '../../compress/compress-utils';
+import { Decompress } from '../../compress/decompress';
 
 function SceneParser(app, isTemplate) {
     this._app = app;
@@ -11,51 +13,54 @@ function SceneParser(app, isTemplate) {
 Object.assign(SceneParser.prototype, {
     parse: function (data) {
         var entities = {};
-        var id, i;
+        var id, i, curEnt;
         var parent = null;
 
+        var compressed = data.compressedFormat;
+        if (compressed) {
+            data.entities = new Decompress(data.entities, compressed).run();
+        }
+
         if (data.collapsedInstances) {
             this._addCollapsedToEntities(this._app, data);
         }
 
         // instantiate entities
         for (id in data.entities) {
-            entities[id] = this._createEntity(data.entities[id]);
-            if (data.entities[id].parent === null) {
-                parent = entities[id];
+            var curData = data.entities[id];
+            curEnt = this._createEntity(curData, compressed);
+            entities[id] = curEnt;
+            if (curData.parent === null) {
+                parent = curEnt;
             }
         }
 
         // put entities into hierarchy
         for (id in data.entities) {
-            var l = data.entities[id].children.length;
-            for (i = 0; i < l; i++) {
-                // pop resource id off the end of the array
-                var resource_id = data.entities[id].children[i];
-                if (entities[resource_id]) {
-                    // push entity on the front of the array
-                    entities[id].addChild(entities[resource_id]);
+            curEnt = entities[id];
+            var children = data.entities[id].children;
+            var len = children.length;
+            for (i = 0; i < len; i++) {
+                var childEnt = entities[children[i]];
+                if (childEnt) {
+                    curEnt.addChild(childEnt);
                 }
             }
         }
 
         this._openComponentData(parent, data.entities);
 
+        delete data.compressedFormat;
+
         return parent;
     },
 
-    _createEntity: function (data) {
+    _createEntity: function (data, compressed) {
         var entity = new Entity();
 
-        var p = data.position;
-        var r = data.rotation;
-        var s = data.scale;
-
         entity.name = data.name;
         entity.setGuid(data.resource_id);
-        entity.setLocalPosition(p[0], p[1], p[2]);
-        entity.setLocalEulerAngles(r[0], r[1], r[2]);
-        entity.setLocalScale(s[0], s[1], s[2]);
+        this._setPosRotScale(entity, data, compressed);
         entity._enabled = data.enabled !== undefined ? data.enabled : true;
 
         if (this._isTemplate) {
@@ -81,6 +86,21 @@ Object.assign(SceneParser.prototype, {
         return entity;
     },
 
+    _setPosRotScale: function (entity, data, compressed) {
+        if (compressed) {
+            CompressUtils.setCompressedPRS(entity, data, compressed);
+
+        } else {
+            var p = data.position;
+            var r = data.rotation;
+            var s = data.scale;
+
+            entity.setLocalPosition(p[0], p[1], p[2]);
+            entity.setLocalEulerAngles(r[0], r[1], r[2]);
+            entity.setLocalScale(s[0], s[1], s[2]);
+        }
+    },
+
     _openComponentData: function (entity, entities) {
         // Create components in order
         var systemsList = this._app.systems.list;
diff --git a/src/templates/template.js b/src/templates/template.js
@@ -1,7 +1,5 @@
 import { SceneParser } from '../resources/parser/scene.js';
 
-import { TemplateUtils } from './template-utils.js';
-
 /**
  * @private
  * @class
@@ -15,8 +13,6 @@ function Template(app, data) {
 
     this._data = data;
 
-    this._expandedData = {};
-
     this._templateRoot = null;
 }
 
@@ -35,29 +31,10 @@ Template.prototype.instantiate = function () {
     return this._templateRoot.clone();
 };
 
-
-/**
- * @private
- * @function
- * @name pc.Template#getExpandedData
- * @description Creates, if needed, and returns an object whose entities field contains
- * expanded entity data. This output format matches the format of raw scene data.
- * @returns {object} An object whose entities field contains
- * expanded entity data.
- */
-Template.prototype.getExpandedData = function () {
-    if (!this._expandedData.entities) {
-        this._expandedData.entities = TemplateUtils.expandTemplateEntities(
-            this._app, this._data.entities);
-    }
-
-    return this._expandedData;
-};
-
 Template.prototype._parseTemplate = function () {
     var parser = new SceneParser(this._app, true);
 
-    this._templateRoot = parser.parse(this.getExpandedData());
+    this._templateRoot = parser.parse(this._data);
 };
 
 export { Template };
