@woosh/meep-engine 2.106.1 → 2.108.0

package/src/engine/animation/keyed2/AnimationTrackPlayback.d.ts

@@ -1,14 +1,4 @@
 export default AnimationTrackPlayback;
-/**
- *
- * @param {AnimationTrack} track
- * @param updateCallback
- * @param {Object} [updateTarget]
- * @constructor
- * @property {AnimationTrack} track
- * @property {number} position Current playback time
- */
-declare function AnimationTrackPlayback(track: AnimationTrack, updateCallback: any, updateTarget?: any): void;
 declare class AnimationTrackPlayback {
     /**
      *

package/src/engine/animation/keyed2/AnimationTrackPlayback.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AnimationTrackPlayback.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/keyed2/AnimationTrackPlayback.js"],"names":[],"mappings":";AAGA;;;;;;;;GAQG;AACH,8GAuBC;;IAhCD;;;;;;;;OAQG;IACH,4EAuBC;IAtBG,sBAAkB;IAClB,cAA+B;IAE/B,oBAAoC;IACpC,kBAAgC;IAEhC,uBAAuB;IACvB,8BAA8B;IAE9B,uBAAuB;IACvB,sBAAsB;IAEtB,gBAAmB;IAEnB,4BAA0D;IAG1D;;MAEC;IAKL;;;OAGG;IACH,gBAFa,QAAQ,IAAI,CAAC,CAUzB;IAED;;;OAGG;IACH,WAFW,OAAO,QAIjB;IAED,cAEC;IAED;;;OAGG;IACH,kBAFW,MAAM,QA2BhB;IAED;;;OAGG;IACH,cAFa,OAAO,CA2CnB;IAED;;;OAGG;IACH,mBAFW,MAAM,QA6BhB;IAED,eAOC;IAED;;;OAGG;IACH,0BAFW,MAAM,EAAE,QA2ClB;;mBApOkB,uCAAuC"}
+{"version":3,"file":"AnimationTrackPlayback.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/keyed2/AnimationTrackPlayback.js"],"names":[],"mappings":";AAGA;IACI;;;;;;;;OAQG;IACH,4EAuBC;IAtBG,sBAAkB;IAClB,cAA+B;IAE/B,oBAAoC;IACpC,kBAAgC;IAEhC,uBAAuB;IACvB,8BAA8B;IAE9B,uBAAuB;IACvB,sBAAsB;IAEtB,gBAAmB;IAEnB,4BAA0D;IAG1D;;MAEC;IAKL;;;OAGG;IACH,gBAFa,QAAQ,IAAI,CAAC,CAUzB;IAED;;;OAGG;IACH,WAFW,OAAO,QAIjB;IAED,cAEC;IAED;;;OAGG;IACH,kBAFW,MAAM,QA2BhB;IAED;;;OAGG;IACH,cAFa,OAAO,CA2CnB;IAED;;;OAGG;IACH,mBAFW,MAAM,QA6BhB;IAED,eAOC;IAED;;;OAGG;IACH,0BAFW,MAAM,EAAE,QA2ClB;CACJ;mBAtOkB,uCAAuC"}

package/src/engine/animation/keyed2/AnimationTrackPlayback.js

@@ -1,231 +1,233 @@
 import Signal from "../../../core/events/signal/Signal.js";
 import { min2 } from "../../../core/math/min2.js";
 
-/**
- *
- * @param {AnimationTrack} track
- * @param updateCallback
- * @param {Object} [updateTarget]
- * @constructor
- * @property {AnimationTrack} track
- * @property {number} position Current playback time
- */
-function AnimationTrackPlayback(track, updateCallback, updateTarget) {
-    this.track = track;
-    this.position = track.timeStart;
+class AnimationTrackPlayback {
+    /**
+     *
+     * @param {AnimationTrack} track
+     * @param updateCallback
+     * @param {Object} [updateTarget]
+     * @constructor
+     * @property {AnimationTrack} track
+     * @property {number} position Current playback time
+     */
+    constructor(track, updateCallback, updateTarget) {
+        this.track = track;
+        this.position = track.timeStart;
 
-    this.updateCallback = updateCallback;
-    this.updateTraget = updateTarget;
+        this.updateCallback = updateCallback;
+        this.updateTraget = updateTarget;
 
-    this.__lastKeyIndex = 0;
-    this.__lastTransitionIndex = 0;
+        this.__lastKeyIndex = 0;
+        this.__lastTransitionIndex = 0;
 
-    this.__nextKeyIndex = 0;
-    this.__nextKeyTime = 0;
+        this.__nextKeyIndex = 0;
+        this.__nextKeyTime = 0;
 
-    this.__loop = false;
+        this.__loop = false;
 
-    this.__valueBuffer = new Float64Array(track.propertyCount);
+        this.__valueBuffer = new Float64Array(track.propertyCount);
 
 
-    this.on = {
-        ended: new Signal()
-    };
+        this.on = {
+            ended: new Signal()
+        };
 
-    this.setPosition(0);
-}
+        this.setPosition(0);
+    }
+
+    /**
+     *
+     * @returns {Promise<void>}
+     */
+    promiseEnded() {
+        if (this.position >= this.track.timeEnd) {
+            return Promise.resolve();
+        }
 
-/**
- *
- * @returns {Promise<void>}
- */
-AnimationTrackPlayback.prototype.promiseEnded = function () {
-    if (this.position >= this.track.timeEnd) {
-        return Promise.resolve();
+        return new Promise((resolve, reject) => {
+            this.on.ended.add(resolve);
+        });
     }
 
-    return new Promise((resolve, reject) => {
-        this.on.ended.add(resolve);
-    });
-};
-
-/**
- *
- * @param {boolean} v
- */
-AnimationTrackPlayback.prototype.setLoop = function (v) {
-    this.__loop = v;
-};
-
-AnimationTrackPlayback.prototype.reset = function () {
-    this.setPosition(this.track.timeStart);
-};
-
-/**
- *
- * @param {number} time
- */
-AnimationTrackPlayback.prototype.setPosition = function (time) {
-    this.position = time;
-
-    const track = this.track;
-    const transitionIndex = track.transitionIndexAt(time);
-
-    this.__lastTransitionIndex = transitionIndex;
-
-    if (transitionIndex !== -1) {
-        //found a transition, read out start key index
-        this.__lastKeyIndex = track.transitionKeys[transitionIndex];
-    } else {
-        //no transition found, lets find last key at least
-        this.__lastKeyIndex = track.keyLowerBoundIndexAt(time);
+    /**
+     *
+     * @param {boolean} v
+     */
+    setLoop(v) {
+        this.__loop = v;
     }
 
-    //figure out next key time
-    const trackKeyCount = track.keyTimes.length;
-    if (trackKeyCount > 1) {
-        this.__nextKeyIndex = min2(this.__lastKeyIndex + 1, trackKeyCount - 1);
-    } else {
-        this.__nextKeyIndex = this.__lastKeyIndex;
+    reset() {
+        this.setPosition(this.track.timeStart);
     }
 
-    this.__nextKeyTime = track.keyTimes[this.__nextKeyIndex];
-};
-
-/**
- *
- * @returns {boolean} Indicated whenever or not a key was advanced, no advancement is possible past end of the sequence
- */
-AnimationTrackPlayback.prototype.advanceKey = function () {
-
-    const track = this.track;
-    const keyCount = track.keyTimes.length;
-    if (this.__lastKeyIndex === keyCount - 1) {
-        //we were on the last key
-        if (this.__loop) {
-            //loop back
-            this.__lastKeyIndex = -1;
-        } else {
-            //we're at the end of the track, no sense in using transition as we are directly on a key
-            this.__lastTransitionIndex = -1;
+    /**
+     *
+     * @param {number} time
+     */
+    setPosition(time) {
+        this.position = time;
 
-            this.on.ended.dispatch();
+        const track = this.track;
+        const transitionIndex = track.transitionIndexAt(time);
 
-            //can't advance further
-            return false;
-        }
-    }
+        this.__lastTransitionIndex = transitionIndex;
 
-    this.__lastKeyIndex = this.__lastKeyIndex + 1;
-
-    this.__nextKeyTime = track.keyTimes[Math.min(this.__lastKeyIndex + 1, keyCount - 1)];
-
-    //fetch transition if one exists
-    const transitionKeys = track.transitionKeys;
-    const transitionCount = transitionKeys.length;
-    for (let i = this.__lastTransitionIndex + 1; i < transitionCount; i++) {
-        const startKeyIndex = transitionKeys[i];
-        if (startKeyIndex === this.__lastKeyIndex) {
-            //we found a match
-            this.__lastTransitionIndex = i;
-            break;
-        } else if (startKeyIndex > this.__lastKeyIndex) {
-            //we went too far, it appears there is no transition for current key
-            this.__lastTransitionIndex = -1;
-            break;
+        if (transitionIndex !== -1) {
+            //found a transition, read out start key index
+            this.__lastKeyIndex = track.transitionKeys[transitionIndex];
+        } else {
+            //no transition found, lets find last key at least
+            this.__lastKeyIndex = track.keyLowerBoundIndexAt(time);
         }
-    }
-
-    return true;
-};
 
-/**
- * Advance animation by given time delta
- * @param {number} timeDelta
- */
-AnimationTrackPlayback.prototype.advance = function (timeDelta) {
+        //figure out next key time
+        const trackKeyCount = track.keyTimes.length;
+        if (trackKeyCount > 1) {
+            this.__nextKeyIndex = min2(this.__lastKeyIndex + 1, trackKeyCount - 1);
+        } else {
+            this.__nextKeyIndex = this.__lastKeyIndex;
+        }
 
-    let newPosition = this.position + timeDelta;
+        this.__nextKeyTime = track.keyTimes[this.__nextKeyIndex];
+    }
 
-    if (timeDelta < 0) {
-        //negative delta, going back in time
-        this.setPosition(newPosition);
-    } else if (newPosition > this.__nextKeyTime) {
+    /**
+     *
+     * @returns {boolean} Indicated whenever or not a key was advanced, no advancement is possible past end of the sequence
+     */
+    advanceKey() {
 
-        if (newPosition >= this.track.timeEnd) {
+        const track = this.track;
+        const keyCount = track.keyTimes.length;
+        if (this.__lastKeyIndex === keyCount - 1) {
+            //we were on the last key
             if (this.__loop) {
                 //loop back
-                newPosition %= this.track.timeEnd;
+                this.__lastKeyIndex = -1;
             } else {
+                //we're at the end of the track, no sense in using transition as we are directly on a key
+                this.__lastTransitionIndex = -1;
+
                 this.on.ended.dispatch();
+
+                //can't advance further
+                return false;
             }
         }
 
-        this.setPosition(newPosition);
+        this.__lastKeyIndex = this.__lastKeyIndex + 1;
+
+        this.__nextKeyTime = track.keyTimes[Math.min(this.__lastKeyIndex + 1, keyCount - 1)];
+
+        //fetch transition if one exists
+        const transitionKeys = track.transitionKeys;
+        const transitionCount = transitionKeys.length;
+        for (let i = this.__lastTransitionIndex + 1; i < transitionCount; i++) {
+            const startKeyIndex = transitionKeys[i];
+            if (startKeyIndex === this.__lastKeyIndex) {
+                //we found a match
+                this.__lastTransitionIndex = i;
+                break;
+            } else if (startKeyIndex > this.__lastKeyIndex) {
+                //we went too far, it appears there is no transition for current key
+                this.__lastTransitionIndex = -1;
+                break;
+            }
+        }
 
-    } else {
+        return true;
+    }
 
-        this.position = newPosition;
+    /**
+     * Advance animation by given time delta
+     * @param {number} timeDelta
+     */
+    advance(timeDelta) {
+
+        let newPosition = this.position + timeDelta;
+
+        if (timeDelta < 0) {
+            //negative delta, going back in time
+            this.setPosition(newPosition);
+        } else if (newPosition > this.__nextKeyTime) {
+
+            if (newPosition >= this.track.timeEnd) {
+                if (this.__loop) {
+                    //loop back
+                    newPosition %= this.track.timeEnd;
+                } else {
+                    this.on.ended.dispatch();
+                }
+            }
 
-    }
+            this.setPosition(newPosition);
 
-    this.update();
-};
+        } else {
 
-AnimationTrackPlayback.prototype.update = function () {
+            this.position = newPosition;
 
-    this.readCurrentValues(this.__valueBuffer);
+        }
 
-    this.updateCallback.apply(this.updateTraget, this.__valueBuffer);
+        this.update();
+    }
 
-    // console.log("values: ", this.__valueBuffer);
-};
+    update() {
 
-/**
- *
- * @param {number[]} result
- */
-AnimationTrackPlayback.prototype.readCurrentValues = function (result) {
-    const track = this.track;
+        this.readCurrentValues(this.__valueBuffer);
 
-    const startKeyIndex = this.__lastKeyIndex;
+        this.updateCallback.apply(this.updateTraget, this.__valueBuffer);
 
-    if (this.__lastTransitionIndex !== -1) {
-        //we're in a middle of a transition
+        // console.log("values: ", this.__valueBuffer);
+    }
+
+    /**
+     *
+     * @param {number[]} result
+     */
+    readCurrentValues(result) {
+        const track = this.track;
+
+        const startKeyIndex = this.__lastKeyIndex;
+
+        if (this.__lastTransitionIndex !== -1) {
+            //we're in a middle of a transition
 
-        const time1 = this.__nextKeyTime;
-        const time0 = track.keyTimes[startKeyIndex];
+            const time1 = this.__nextKeyTime;
+            const time0 = track.keyTimes[startKeyIndex];
 
-        const timeDelta = time1 - time0;
-        const relativeTime = (this.position - time0);
+            const timeDelta = time1 - time0;
+            const relativeTime = (this.position - time0);
 
-        const normalizedTime = relativeTime / timeDelta;
+            const normalizedTime = relativeTime / timeDelta;
 
-        const transitionFunction = track.transitionFunctions[this.__lastTransitionIndex];
+            const transitionFunction = track.transitionFunctions[this.__lastTransitionIndex];
 
-        const transitionValue = transitionFunction(normalizedTime);
+            const transitionValue = transitionFunction(normalizedTime);
 
-        const propCount = track.propertyCount;
+            const propCount = track.propertyCount;
 
-        const keyValues = track.keyValues;
+            const keyValues = track.keyValues;
 
-        const offset0 = startKeyIndex * propCount;
-        const offset1 = offset0 + propCount;
+            const offset0 = startKeyIndex * propCount;
+            const offset1 = offset0 + propCount;
 
-        for (let i = 0; i < propCount; i++) {
-            const v0 = keyValues[i + offset0];
-            const v1 = keyValues[i + offset1];
+            for (let i = 0; i < propCount; i++) {
+                const v0 = keyValues[i + offset0];
+                const v1 = keyValues[i + offset1];
 
-            const valueDelta = v1 - v0;
+                const valueDelta = v1 - v0;
 
-            const value = transitionValue * valueDelta + v0;
+                const value = transitionValue * valueDelta + v0;
 
-            result[i] = value;
+                result[i] = value;
+            }
+        } else {
+            //we're not in a transition, can re-use old key
+            track.readKeyValues(startKeyIndex, result);
         }
-    } else {
-        //we're not in a transition, can re-use old key
-        track.readKeyValues(startKeyIndex, result);
     }
-};
+}
 
 export default AnimationTrackPlayback;

package/src/engine/asset/AssetManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AssetManager.d.ts","sourceRoot":"","sources":["../../../../src/engine/asset/AssetManager.js"],"names":[],"mappings":"AAiDA;;;;GAIG;AACH;IAgII;;;;;OAKG;IACH,oCAJW,GAAG,EAYb;IA7ID;;;;OAIG;IACH,eAEG;IAEH;;;OAGG;IACH,aAFU,YAAY,gBAAgB,EAAE,YAAY,CAAC,CAER;IAe7C;;;;;;OAMG;IACH,kBAFU,MAAM,CAEY;IAyB5B;;;;OAIG;IACH,iBAAc;IAEd;;;OAGG;IACH,mBAFU,iBAAiB,CAEiB;IAwE5C,gBAQC;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACL,QAAQ,IAAI,CAAC,CAexB;IAED;;;;;OAKG;IACH,oCAFa,OAAO,CAOnB;IAED;;OAEG;IACH,cAEC;IAED,8BAEC;IAED;;;;;;OAMG;IACH,4DAJW,iBAAiB,GAEf,cAAc,CAY1B;IAED;;;;;;;;;OASG;IACH,qFAsCC;IAED;;;;;OAKG;IACH,aAJW,MAAM,QACN,MAAM,sBAehB;IA2QD;;;;;OAKG;IACH,sBA2BC;IAGD;;;;OAIG;IACH,uBAHW,MAAM,GACL,OAAO,CAIlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACJ,wBAAY,SAAS,CAMjC;IAaD;;;;OAIG;IACH,+BAHW,MAAM,4CAqBhB;IAED;;;;OAIG;IACH,iCAHW,MAAM,+CAyBhB;IAED;;;;;;OAMG;IACH,6BAJW,MAAM,kCAEJ,QAAQ,OAAO,CAAC,CAU5B;IAED;;;;;OAKG;IACH,0BAJW,MAAM,iEAwChB;IAED;;;OAGG;IACH,uBAFW,MAAM,iBAkBhB;IAED;;;;;;OAMG;IACH,yCAFa,aAAS,IAAI,CAYzB;IAED;;;;;OAKG;IACH,eAJW,MAAM,QACN,MAAM,GACJ,OAAO,CAMnB;IAED;;;;OAIG;IACH,2BAHW,MAAM,GACL,mBAAiB,CAa5B;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACL,gBAAgB,GAAC,SAAS,CAQrC;IAED;;;;;OAKG;IACH,mBAJW,MAAM,QACN,MAAM,QACN,MAAM,QAUhB;IAGL;;;OAGG;IACH,yBAFU,OAAO,CAEoB;;CANpC;4BA72B2B,0CAA0C;iCAOrC,uBAAuB;6BAM3B,mBAAmB;kCAFd,6BAA6B;kCAD7B,wBAAwB;4BAE9B,0BAA0B"}
+{"version":3,"file":"AssetManager.d.ts","sourceRoot":"","sources":["../../../../src/engine/asset/AssetManager.js"],"names":[],"mappings":"AA4CA;;;;GAIG;AACH;IAgII;;;;;OAKG;IACH,oCAJW,GAAG,EAYb;IA7ID;;;;OAIG;IACH,eAEG;IAEH;;;OAGG;IACH,aAFU,YAAY,gBAAgB,EAAE,YAAY,CAAC,CAER;IAe7C;;;;;;OAMG;IACH,kBAFU,MAAM,CAEY;IAyB5B;;;;OAIG;IACH,iBAAc;IAEd;;;OAGG;IACH,mBAFU,iBAAiB,CAEiB;IAwE5C,gBAQC;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACL,QAAQ,IAAI,CAAC,CAexB;IAED;;;;;OAKG;IACH,oCAFa,OAAO,CAOnB;IAED;;OAEG;IACH,cAEC;IAED,8BAEC;IAED;;;;;;OAMG;IACH,4DAJW,iBAAiB,GAEf,cAAc,CAY1B;IAED;;;;;;;;;OASG;IACH,qFAsCC;IAED;;;;;OAKG;IACH,aAJW,MAAM,QACN,MAAM,sBAehB;IA2QD;;;;;OAKG;IACH,sBA2BC;IAGD;;;;OAIG;IACH,uBAHW,MAAM,GACL,OAAO,CAIlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACJ,wBAAY,SAAS,CAMjC;IAaD;;;;OAIG;IACH,+BAHW,MAAM,4CAqBhB;IAED;;;;OAIG;IACH,iCAHW,MAAM,+CAyBhB;IAED;;;;;;OAMG;IACH,6BAJW,MAAM,kCAEJ,QAAQ,OAAO,CAAC,CAU5B;IAED;;;;;OAKG;IACH,0BAJW,MAAM,iEAwChB;IAED;;;OAGG;IACH,uBAFW,MAAM,iBAkBhB;IAED;;;;;;OAMG;IACH,yCAFa,aAAS,IAAI,CAYzB;IAED;;;;;OAKG;IACH,eAJW,MAAM,QACN,MAAM,GACJ,OAAO,CAMnB;IAED;;;;OAIG;IACH,2BAHW,MAAM,GACL,mBAAiB,CAa5B;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACL,gBAAgB,GAAC,SAAS,CAQrC;IAED;;;;;OAKG;IACH,mBAJW,MAAM,QACN,MAAM,QACN,MAAM,QAUhB;IAGL;;;OAGG;IACH,yBAFU,OAAO,CAEoB;;CANpC;4BA72B2B,0CAA0C;iCAOrC,uBAAuB;6BAM3B,mBAAmB;kCAFd,6BAA6B;kCAD7B,wBAAwB;4BAE9B,0BAA0B"}

package/src/engine/asset/AssetManager.js

@@ -1,8 +1,3 @@
-/**
- * Created by Alex on 03/09/2014.
- */
-
-
 import { assert } from "../../core/assert.js";
 import { array_push_if_unique } from "../../core/collection/array/array_push_if_unique.js";
 import { array_remove_first } from "../../core/collection/array/array_remove_first.js";

package/src/engine/asset/loaders/image/png/PNGReader.d.ts

@@ -11,16 +11,37 @@ export class PNGReader {
      * @constructor
      */
     constructor(bytes: ArrayBuffer);
+    /**
+     * current pointer
+     * @type {number}
+     */
     i: number;
+    /**
+     * bytes buffer
+     * @type {Uint8Array}
+     */
     bytes: Uint8Array;
+    /**
+     * Output object
+     * @type {PNG}
+     */
     png: PNG;
     dataChunks: any[];
+    /**
+     *
+     * @type {BinaryBuffer}
+     */
     buffer: BinaryBuffer;
     /**
      * Whether CRC should be performed or not
      * @type {boolean}
      */
     crc_enabled: boolean;
+    /**
+     *
+     * @type {Uint8Array}
+     */
+    header: Uint8Array;
     /**
      *
      * @param {number} length
@@ -31,7 +52,6 @@ export class PNGReader {
      * http://www.w3.org/TR/2003/REC-PNG-20031110/#5PNG-file-signature
      */
     decodeHeader(): void;
-    header: Uint8Array;
     /**
      * http://www.w3.org/TR/2003/REC-PNG-20031110/#5Chunk-layout
      *
@@ -119,7 +139,10 @@ export class PNGReader {
      * Uncompress IDAT chunks
      */
     decodePixels(): void;
-    interlaceNone(data: any): void;
+    /**
+     * @param {Uint8Array} data
+     */
+    interlaceNone(data: Uint8Array): void;
     /**
      * De-interlace image according to Adam 7 scheme
      * @param {Uint8Array} data
@@ -168,15 +191,6 @@ export class PNGReader {
     unFilterPaeth(scanline: any, scanline_offset: any, pixels: any, bpp: any, of: any, length: any): void;
     /**
      * Parse the PNG file
-     *
-     * reader.parse(options, callback)
-     * OR
-     * reader.parse(callback)
-     *
-     * OPTIONS:
-     *    option  | type     | default
-     *    ----------------------------
-     *    data      boolean    true    should it read the pixel data
      * @returns {PNG}
      */
     parse(): PNG;

package/src/engine/asset/loaders/image/png/PNGReader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PNGReader.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/asset/loaders/image/png/PNGReader.js"],"names":[],"mappings":"AAsDA;;;;GAIG;AACH,iCAHW,WAAW,QAqBrB;;IAvBD;;;;OAIG;IACH,mBAHW,WAAW,EAqBrB;IAhBG,UAAU;IAEV,kBAAkC;IAElC,SAAoB;IAEpB,kBAAoB;IAEpB,qBAAgC;IAGhC;;;OAGG;IACH,aAFU,OAAO,CAEO;IAG5B;;;;OAIG;IACH,kBAHW,MAAM,GACL,UAAU,CAQrB;IAED;;OAEG;IACH,qBAmBC;IAFG,mBAAoB;IAIxB;;;;;;;;;OASG;IACH,eAFa,MAAM,CA4ElB;IAGD;;;OAGG;IACH,kBAFW,UAAU,QAOpB;IAED;;;OAGG;IACH,kBAFW,UAAU,QAapB;IAED;;;;OAIG;IACH,kBAFW,UAAU;;;;;MAiCpB;IAGD;;;;OAIG;IACH,kBAFW,UAAU;;;MA6BpB;IAED;;;OAGG;IACH,kBAFW,UAAU,QASpB;IACD;;;;OAIG;IACH,kBAFW,UAAU,QAqBpB;IAED;;;;;;;;;;;OAWG;IACH,6BAWC;IAED;;;OAGG;IACH,6BAEC;IAED;;OAEG;IACH,6BAGC;IAED;;;OAGG;IACH,kBAFW,UAAU,QAIpB;IAED;;OAEG;IACH,mBACC;IAED;;OAEG;IACH,qBAwBC;IAID,+BAuFC;IAED;;;OAGG;IACH,qBAFW,UAAU,SAIpB;IAKD;;;;OAIG;IACH,oGAYC;IAED;;;;;OAKG;IACH,mGAYC;IAED;;;;OAIG;IACH,wGA+BC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,sGA8CC;IAED;;;;;;;;;;;;OAYG;IACH,SAFa,GAAG,CAqBf;;oBA1rBmB,UAAU;6BAJD,4CAA4C"}
+{"version":3,"file":"PNGReader.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/asset/loaders/image/png/PNGReader.js"],"names":[],"mappings":"AAsDA;;;;GAIG;AACH,iCAHW,WAAW,QA0CrB;;IA5CD;;;;OAIG;IACH,mBAHW,WAAW,EA0CrB;IAtCG;;;OAGG;IACH,GAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,OAFU,UAAU,CAEc;IAElC;;;OAGG;IACH,KAFU,GAAG,CAEO;IAEpB,kBAAoB;IAEpB;;;OAGG;IACH,QAFU,YAAY,CAEU;IAGhC;;;OAGG;IACH,aAFU,OAAO,CAEO;IAExB;;;OAGG;IACH,QAFU,UAAU,CAEW;IAGnC;;;;OAIG;IACH,kBAHW,MAAM,GACL,UAAU,CAQrB;IAED;;OAEG;IACH,qBAkBC;IAED;;;;;;;;;OASG;IACH,eAFa,MAAM,CA4ElB;IAGD;;;OAGG;IACH,kBAFW,UAAU,QAOpB;IAED;;;OAGG;IACH,kBAFW,UAAU,QAapB;IAED;;;;OAIG;IACH,kBAFW,UAAU;;;;;MAiCpB;IAGD;;;;OAIG;IACH,kBAFW,UAAU;;;MA6BpB;IAED;;;OAGG;IACH,kBAFW,UAAU,QASpB;IACD;;;;OAIG;IACH,kBAFW,UAAU,QAqBpB;IAED;;;;;;;;;;;OAWG;IACH,6BAWC;IAED;;;OAGG;IACH,6BAEC;IAED;;OAEG;IACH,6BAGC;IAED;;;OAGG;IACH,kBAFW,UAAU,QAIpB;IAED;;OAEG;IACH,mBACC;IAED;;OAEG;IACH,qBAwBC;IAID;;OAEG;IACH,oBAFW,UAAU,QAyFpB;IAED;;;OAGG;IACH,qBAFW,UAAU,SAIpB;IAKD;;;;OAIG;IACH,oGAYC;IAED;;;;;OAKG;IACH,mGAYC;IAED;;;;OAIG;IACH,wGA+BC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,sGA8CC;IAED;;;OAGG;IACH,SAFa,GAAG,CAqBf;;oBAxsBmB,UAAU;6BAJD,4CAA4C"}

package/src/engine/asset/loaders/image/png/PNGReader.js

@@ -35,10 +35,10 @@ function inflate(encoded_chunk) {
  * @return {number}
  */
 function readUInt32(buffer, offset) {
-    return (buffer[offset] << 24) +
-        (buffer[offset + 1] << 16) +
-        (buffer[offset + 2] << 8) +
-        (buffer[offset + 3]);
+    return (buffer[offset] << 24)
+        | (buffer[offset + 1] << 16)
+        | (buffer[offset + 2] << 8)
+        | (buffer[offset + 3]);
 }
 
 
@@ -58,15 +58,30 @@ function readUInt8(buffer, offset) {
  * @constructor
  */
 export function PNGReader(bytes) {
-    // current pointer
+    /**
+     * current pointer
+     * @type {number}
+     */
     this.i = 0;
-    // bytes buffer
+
+    /**
+     * bytes buffer
+     * @type {Uint8Array}
+     */
     this.bytes = new Uint8Array(bytes);
-    // Output object
+
+    /**
+     * Output object
+     * @type {PNG}
+     */
     this.png = new PNG();
 
     this.dataChunks = [];
 
+    /**
+     *
+     * @type {BinaryBuffer}
+     */
     this.buffer = new BinaryBuffer();
     this.buffer.fromArrayBuffer(bytes);
 
@@ -75,6 +90,12 @@ export function PNGReader(bytes) {
      * @type {boolean}
      */
     this.crc_enabled = false;
+
+    /**
+     *
+     * @type {Uint8Array}
+     */
+    this.header = new Uint8Array(8);
 }
 
 /**
@@ -101,7 +122,7 @@ PNGReader.prototype.decodeHeader = function () {
 
     const buffer = this.buffer;
 
-    const header = new Uint8Array(8);
+    const header = this.header;
 
     buffer.readBytes(header, 0, 8)
 
@@ -110,7 +131,6 @@ PNGReader.prototype.decodeHeader = function () {
         throw new Error('invalid PNGReader file (bad signature)');
     }
 
-    this.header = header;
 
 };
 
@@ -426,6 +446,9 @@ PNGReader.prototype.decodePixels = function () {
 
 // Different interlace methods
 
+/**
+ * @param {Uint8Array} data
+ */
 PNGReader.prototype.interlaceNone = function (data) {
 
     const png = this.png;
@@ -674,34 +697,25 @@ PNGReader.prototype.unFilterPaeth = function (scanline, scanline_offset, pixels,
 
 /**
  * Parse the PNG file
- *
- * reader.parse(options, callback)
- * OR
- * reader.parse(callback)
- *
- * OPTIONS:
- *    option  | type     | default
- *    ----------------------------
- *    data      boolean    true    should it read the pixel data
  * @returns {PNG}
  */
 PNGReader.prototype.parse = function () {
 
     this.decodeHeader();
 
-    while (this.buffer.position < this.buffer.length) {
+    for (; ;) {
+
         const type = this.decodeChunk();
-        // stop after IHDR chunk, or after IEND
-        // if (type === 'IHDR' && options.data === false || type === 'IEND') break;
+
         if (type === 'IEND') {
+            // reached the end
             break;
         }
-    }
 
-    const png = this.png;
+    }
 
     this.decodePixels();
 
-    return png;
+    return this.png;
 
 };

package/src/engine/asset/loaders/material/TextureAttachmensByMaterialType.js

@@ -129,3 +129,5 @@ export const TextureAttachmentsByMaterialType = {
         })
     ]
 };
+
+TextureAttachmentsByMaterialType.MeshPhysicalMaterial = TextureAttachmentsByMaterialType.MeshStandardMaterial;

package/src/engine/asset/preloader/AssetLevel.js

@@ -1,6 +1,3 @@
-/**
- * Created by Alex on 20/05/2015.
- */
 const AssetLevel = {
     CRITICAL: 0,
     HIGH: 1,

package/src/engine/ecs/EntityManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EntityManager.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/EntityManager.js"],"names":[],"mappings":";;;wBAkBU,MAAM;;;;;;iCAWN,MAAM;;;;;;;;;AAWhB;IAEI;;;OAGG;IACH,kBAFU,iCAAQ,CAEL;IAEb;;;OAGG;IACH,gCAFU,iCAAQ,CAES;IAE3B;;;OAGG;IACH,0BAFU,cAAc,EAAE,CAEL;IAErB;;OAEG;IACH;;;QAGI;;WAEG;qBADO,uCAAc;;MAI1B;IAEF;;;OAGG;IACH,OAFU,kBAAkB,CAEO;IAEnC;;;;OAIG;IACH,gDAA2C;IAE3C;;;;OAIG;IACH,qBAFU,MAAM,CAEY;IAE5B;;;;;OAKG;IACH,wCAFU,MAAM,CAE4B;IAE5C;;;OAGG;IACH,gCAAe;IAEf;;;;OAIG;IACH,uCAAsC;IAEtC;;;OAGG;IACH,6BA8EC;IAED,sBAcC;IAED;;;OAGG;IACH,uBAFa,OAAO,CAuBnB;IAED;;;;;OAKG;IACH,qDAsBC;IAED;;;;OAIG;IACH,qCAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,6CAcC;IAED;;;;;OAKG;IACH,wCAHW,MAAM,GACJ,IAAI,aAAS,CAezB;IAGD;;;OAGG;IACH,oBAFW,MAAM,QAkEhB;IAED;;;;;OAKG;IACH,iEA0EC;IAED;;;;OAIG;IACH,uDAFa,QAAQ,OAAO,CAAC,CAyC5B;IAED;;;;;OAKG;IACH,mBA6BC;IAED;;;;;OAKG;IACH,oBAwCC;IAED;;;;OAIG;IACH,gEAwEC;IAED;;;;OAIG;IACH,mCAFa,wCAAgB,CA0B5B;IAED;;;;;OAKG;IACH,8DAFa,wCAAgB,CAsB5B;IAED;;;;OAIG;IACH,iEAkEC;CACJ;uBApyBsD,aAAa;+BADrC,qBAAqB;mBALjC,oCAAoC"}
+{"version":3,"file":"EntityManager.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/EntityManager.js"],"names":[],"mappings":";;;wBAcU,MAAM;;;;;;iCAWN,MAAM;;;;;;;;;AAWhB;IAEI;;;OAGG;IACH,kBAFU,iCAAQ,CAEL;IAEb;;;OAGG;IACH,gCAFU,iCAAQ,CAES;IAE3B;;;OAGG;IACH,0BAFU,cAAc,EAAE,CAEL;IAErB;;OAEG;IACH;;;QAGI;;WAEG;qBADO,uCAAc;;MAI1B;IAEF;;;OAGG;IACH,OAFU,kBAAkB,CAEO;IAEnC;;;;OAIG;IACH,gDAA2C;IAE3C;;;;OAIG;IACH,qBAFU,MAAM,CAEY;IAE5B;;;;;OAKG;IACH,wCAFU,MAAM,CAE4B;IAE5C;;;OAGG;IACH,gCAAe;IAEf;;;;OAIG;IACH,uCAAsC;IAEtC;;;OAGG;IACH,6BA8EC;IAED,sBAcC;IAED;;;OAGG;IACH,uBAFa,OAAO,CAuBnB;IAED;;;;;OAKG;IACH,qDAsBC;IAED;;;;OAIG;IACH,qCAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,6CAcC;IAED;;;;;OAKG;IACH,wCAHW,MAAM,GACJ,IAAI,aAAS,CAezB;IAGD;;;OAGG;IACH,oBAFW,MAAM,QAkEhB;IAED;;;;;OAKG;IACH,iEA0EC;IAED;;;;OAIG;IACH,uDAFa,QAAQ,OAAO,CAAC,CAyC5B;IAED;;;;;OAKG;IACH,mBA6BC;IAED;;;;;OAKG;IACH,oBAwCC;IAED;;;;OAIG;IACH,gEAwEC;IAED;;;;OAIG;IACH,mCAFa,wCAAgB,CA0B5B;IAED;;;;;OAKG;IACH,8DAFa,wCAAgB,CAsB5B;IAED;;;;OAIG;IACH,iEAkEC;CACJ;uBApyBsD,aAAa;+BADrC,qBAAqB;mBALjC,oCAAoC"}