@luma.gl/engine 9.0.0-beta.4 → 9.0.0-beta.5

package/dist/animation/key-frames.js

@@ -1,56 +1,56 @@
+/** Holds a list of key frames (timestamped values) */
 export class KeyFrames {
-  constructor(keyFrames) {
-    this.startIndex = -1;
-    this.endIndex = -1;
-    this.factor = 0;
-    this.times = [];
-    this.values = [];
-    this._lastTime = -1;
-    this.setKeyFrames(keyFrames);
-    this.setTime(0);
-  }
-  setKeyFrames(keyFrames) {
-    const numKeys = keyFrames.length;
-    this.times.length = numKeys;
-    this.values.length = numKeys;
-    for (let i = 0; i < numKeys; ++i) {
-      this.times[i] = keyFrames[i][0];
-      this.values[i] = keyFrames[i][1];
-    }
-    this._calculateKeys(this._lastTime);
-  }
-  setTime(time) {
-    time = Math.max(0, time);
-    if (time !== this._lastTime) {
-      this._calculateKeys(time);
-      this._lastTime = time;
-    }
-  }
-  getStartTime() {
-    return this.times[this.startIndex];
-  }
-  getEndTime() {
-    return this.times[this.endIndex];
-  }
-  getStartData() {
-    return this.values[this.startIndex];
-  }
-  getEndData() {
-    return this.values[this.endIndex];
-  }
-  _calculateKeys(time) {
-    let index = 0;
-    const numKeys = this.times.length;
-    for (index = 0; index < numKeys - 2; ++index) {
-      if (this.times[index + 1] > time) {
-        break;
-      }
-    }
-    this.startIndex = index;
-    this.endIndex = index + 1;
-    const startTime = this.times[this.startIndex];
-    const endTime = this.times[this.endIndex];
-    this.factor = Math.min(Math.max(0, (time - startTime) / (endTime - startTime)), 1);
-  }
+    startIndex = -1;
+    endIndex = -1;
+    factor = 0;
+    times = [];
+    values = [];
+    _lastTime = -1;
+    constructor(keyFrames) {
+        this.setKeyFrames(keyFrames);
+        this.setTime(0);
+    }
+    setKeyFrames(keyFrames) {
+        const numKeys = keyFrames.length;
+        this.times.length = numKeys;
+        this.values.length = numKeys;
+        for (let i = 0; i < numKeys; ++i) {
+            this.times[i] = keyFrames[i][0];
+            this.values[i] = keyFrames[i][1];
+        }
+        this._calculateKeys(this._lastTime);
+    }
+    setTime(time) {
+        time = Math.max(0, time);
+        if (time !== this._lastTime) {
+            this._calculateKeys(time);
+            this._lastTime = time;
+        }
+    }
+    getStartTime() {
+        return this.times[this.startIndex];
+    }
+    getEndTime() {
+        return this.times[this.endIndex];
+    }
+    getStartData() {
+        return this.values[this.startIndex];
+    }
+    getEndData() {
+        return this.values[this.endIndex];
+    }
+    _calculateKeys(time) {
+        let index = 0;
+        const numKeys = this.times.length;
+        for (index = 0; index < numKeys - 2; ++index) {
+            if (this.times[index + 1] > time) {
+                break;
+            }
+        }
+        this.startIndex = index;
+        this.endIndex = index + 1;
+        const startTime = this.times[this.startIndex];
+        const endTime = this.times[this.endIndex];
+        this.factor = Math.min(Math.max(0, (time - startTime) / (endTime - startTime)), 1);
+    }
 }
-//# sourceMappingURL=key-frames.js.map

package/dist/animation/timeline.js

@@ -1,112 +1,107 @@
+// luma.gl, MIT license
+// Copyright (c) vis.gl contributors
 let channelHandles = 1;
 let animationHandles = 1;
 export class Timeline {
-  constructor() {
-    this.time = 0;
-    this.channels = new Map();
-    this.animations = new Map();
-    this.playing = false;
-    this.lastEngineTime = -1;
-  }
-  addChannel(props) {
-    const {
-      delay = 0,
-      duration = Number.POSITIVE_INFINITY,
-      rate = 1,
-      repeat = 1
-    } = props;
-    const channelId = channelHandles++;
-    const channel = {
-      time: 0,
-      delay,
-      duration,
-      rate,
-      repeat
-    };
-    this._setChannelTime(channel, this.time);
-    this.channels.set(channelId, channel);
-    return channelId;
-  }
-  removeChannel(channelId) {
-    this.channels.delete(channelId);
-    for (const [animationHandle, animation] of this.animations) {
-      if (animation.channel === channelId) {
-        this.detachAnimation(animationHandle);
-      }
+    time = 0;
+    channels = new Map();
+    animations = new Map();
+    playing = false;
+    lastEngineTime = -1;
+    constructor() {
     }
-  }
-  isFinished(channelId) {
-    const channel = this.channels.get(channelId);
-    if (channel === undefined) {
-      return false;
+    addChannel(props) {
+        const { delay = 0, duration = Number.POSITIVE_INFINITY, rate = 1, repeat = 1 } = props;
+        const channelId = channelHandles++;
+        const channel = {
+            time: 0,
+            delay,
+            duration,
+            rate,
+            repeat
+        };
+        this._setChannelTime(channel, this.time);
+        this.channels.set(channelId, channel);
+        return channelId;
     }
-    return this.time >= channel.delay + channel.duration * channel.repeat;
-  }
-  getTime(channelId) {
-    if (channelId === undefined) {
-      return this.time;
+    removeChannel(channelId) {
+        this.channels.delete(channelId);
+        for (const [animationHandle, animation] of this.animations) {
+            if (animation.channel === channelId) {
+                this.detachAnimation(animationHandle);
+            }
+        }
     }
-    const channel = this.channels.get(channelId);
-    if (channel === undefined) {
-      return -1;
+    isFinished(channelId) {
+        const channel = this.channels.get(channelId);
+        if (channel === undefined) {
+            return false;
+        }
+        return this.time >= channel.delay + channel.duration * channel.repeat;
     }
-    return channel.time;
-  }
-  setTime(time) {
-    this.time = Math.max(0, time);
-    const channels = this.channels.values();
-    for (const channel of channels) {
-      this._setChannelTime(channel, this.time);
+    getTime(channelId) {
+        if (channelId === undefined) {
+            return this.time;
+        }
+        const channel = this.channels.get(channelId);
+        if (channel === undefined) {
+            return -1;
+        }
+        return channel.time;
     }
-    const animations = this.animations.values();
-    for (const animationData of animations) {
-      const {
-        animation,
-        channel
-      } = animationData;
-      animation.setTime(this.getTime(channel));
+    setTime(time) {
+        this.time = Math.max(0, time);
+        const channels = this.channels.values();
+        for (const channel of channels) {
+            this._setChannelTime(channel, this.time);
+        }
+        const animations = this.animations.values();
+        for (const animationData of animations) {
+            const { animation, channel } = animationData;
+            animation.setTime(this.getTime(channel));
+        }
     }
-  }
-  play() {
-    this.playing = true;
-  }
-  pause() {
-    this.playing = false;
-    this.lastEngineTime = -1;
-  }
-  reset() {
-    this.setTime(0);
-  }
-  attachAnimation(animation, channelHandle) {
-    const animationHandle = animationHandles++;
-    this.animations.set(animationHandle, {
-      animation,
-      channel: channelHandle
-    });
-    animation.setTime(this.getTime(channelHandle));
-    return animationHandle;
-  }
-  detachAnimation(channelId) {
-    this.animations.delete(channelId);
-  }
-  update(engineTime) {
-    if (this.playing) {
-      if (this.lastEngineTime === -1) {
-        this.lastEngineTime = engineTime;
-      }
-      this.setTime(this.time + (engineTime - this.lastEngineTime));
-      this.lastEngineTime = engineTime;
+    play() {
+        this.playing = true;
     }
-  }
-  _setChannelTime(channel, time) {
-    const offsetTime = time - channel.delay;
-    const totalDuration = channel.duration * channel.repeat;
-    if (offsetTime >= totalDuration) {
-      channel.time = channel.duration * channel.rate;
-    } else {
-      channel.time = Math.max(0, offsetTime) % channel.duration;
-      channel.time *= channel.rate;
+    pause() {
+        this.playing = false;
+        this.lastEngineTime = -1;
+    }
+    reset() {
+        this.setTime(0);
+    }
+    attachAnimation(animation, channelHandle) {
+        const animationHandle = animationHandles++;
+        this.animations.set(animationHandle, {
+            animation,
+            channel: channelHandle
+        });
+        animation.setTime(this.getTime(channelHandle));
+        return animationHandle;
+    }
+    detachAnimation(channelId) {
+        this.animations.delete(channelId);
+    }
+    update(engineTime) {
+        if (this.playing) {
+            if (this.lastEngineTime === -1) {
+                this.lastEngineTime = engineTime;
+            }
+            this.setTime(this.time + (engineTime - this.lastEngineTime));
+            this.lastEngineTime = engineTime;
+        }
+    }
+    _setChannelTime(channel, time) {
+        const offsetTime = time - channel.delay;
+        const totalDuration = channel.duration * channel.repeat;
+        // Note(Tarek): Don't loop on final repeat.
+        if (offsetTime >= totalDuration) {
+            channel.time = channel.duration * channel.rate;
+        }
+        else {
+            channel.time = Math.max(0, offsetTime) % channel.duration;
+            channel.time *= channel.rate;
+        }
     }
-  }
 }
-//# sourceMappingURL=timeline.js.map

package/dist/animation-loop/animation-loop-template.js

@@ -1,7 +1,19 @@
+/**
+ * Minimal class that represents a "componentized" rendering life cycle
+ * (resource construction, repeated rendering, resource destruction)
+ *
+ * @note A motivation for this class compared to the raw animation loop is
+ * that it simplifies TypeScript code by allowing resources to be typed unconditionally
+ * since they are allocated in the constructor rather than in onInitialized
+ *
+ * @note Introduced in luma.gl v9
+ *
+ * @example AnimationLoopTemplate is intended to be subclassed,
+ * but the subclass should not be instantiated directly. Instead the subclass
+ * (i.e. the constructor of the subclass) should be used
+ * as an argument to create an AnimationLoop.
+ */
 export class AnimationLoopTemplate {
-  constructor(animationProps) {}
-  async onInitialize(animationProps) {
-    return null;
-  }
+    constructor(animationProps) { }
+    async onInitialize(animationProps) { return null; }
 }
-//# sourceMappingURL=animation-loop-template.js.map