@lightningjs/renderer 0.3.0 → 0.3.2

package/src/core/animations/CoreAnimation.ts

@@ -0,0 +1,139 @@
+/*
+ * If not stated otherwise in this file or this component's LICENSE file the
+ * following copyright and licenses apply:
+ *
+ * Copyright 2023 Comcast Cable Communications Management, LLC.
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { CoreNode } from '../CoreNode.js';
+import type { INodeAnimatableProps } from '../../main-api/INode.js';
+import { getTimingFunction } from '../utils.js';
+import { mergeColorProgress } from '../../utils.js';
+import { EventEmitter } from '../../common/EventEmitter.js';
+
+export interface IAnimationSettings {
+  duration: number;
+  delay: number;
+  easing: string;
+  loop: boolean;
+  repeat: number;
+  repeatDelay: number;
+  stopMethod: 'reverse' | 'reset' | false;
+}
+
+export class CoreAnimation extends EventEmitter {
+  public propStartValues: Partial<INodeAnimatableProps> = {};
+  public restoreValues: Partial<INodeAnimatableProps> = {};
+  private progress = 0;
+  private timingFunction: (t: number) => number | undefined;
+
+  constructor(
+    private node: CoreNode,
+    private props: Partial<INodeAnimatableProps>,
+    public settings: Partial<IAnimationSettings>,
+  ) {
+    super();
+    this.propStartValues = {};
+    (Object.keys(props) as Array<keyof INodeAnimatableProps>).forEach(
+      (propName) => {
+        this.propStartValues[propName] = node[propName];
+      },
+    );
+
+    this.timingFunction = (t: number) => t;
+
+    if (settings.easing && typeof settings.easing === 'string') {
+      this.timingFunction = getTimingFunction(settings.easing);
+    }
+  }
+
+  reset() {
+    this.progress = 0;
+    this.update(0);
+  }
+
+  restore() {
+    this.reset();
+    (Object.keys(this.props) as Array<keyof INodeAnimatableProps>).forEach(
+      (propName) => {
+        this.node[propName] = this.propStartValues[propName] as number;
+      },
+    );
+  }
+
+  reverse() {
+    this.progress = 0;
+    (Object.keys(this.props) as Array<keyof INodeAnimatableProps>).forEach(
+      (propName) => {
+        // set the start value to the current value
+        const startValue = this.node[propName];
+        const endValue = this.propStartValues[propName] as number;
+
+        // swap the start and end values
+        this.props[propName] = endValue;
+        this.propStartValues[propName] = startValue;
+      },
+    );
+
+    // restore stop method
+    this.settings.stopMethod = false;
+  }
+
+  applyEasing(p: number, s: number, e: number): number {
+    return (this.timingFunction(p) || p) * (e - s) + s;
+  }
+
+  update(dt: number) {
+    // finish if no duration is provided
+    const { duration, loop, easing } = this.settings;
+    if (!duration) {
+      this.emit('finished', {});
+      return;
+    }
+
+    this.progress += dt / duration;
+
+    if (this.progress > 1) {
+      this.progress = loop ? 0 : 1;
+      this.emit('finished', {});
+    }
+
+    (Object.keys(this.props) as Array<keyof INodeAnimatableProps>).forEach(
+      (propName) => {
+        const propValue = this.props[propName] as number;
+        const startValue = this.propStartValues[propName] as number;
+        const endValue = propValue;
+
+        if (propName.indexOf('color') !== -1) {
+          const progressValue = easing
+            ? this.timingFunction(this.progress) || this.progress
+            : this.progress;
+          const colorValue = mergeColorProgress(
+            startValue,
+            endValue,
+            progressValue,
+          );
+          this.node[propName] = easing
+            ? colorValue
+            : mergeColorProgress(startValue, endValue, this.progress);
+        } else {
+          this.node[propName] = easing
+            ? this.applyEasing(this.progress, startValue, endValue)
+            : startValue + (endValue - startValue) * this.progress;
+        }
+      },
+    );
+  }
+}

package/src/core/animations/CoreAnimationController.ts

@@ -0,0 +1,117 @@
+/*
+ * If not stated otherwise in this file or this component's LICENSE file the
+ * following copyright and licenses apply:
+ *
+ * Copyright 2023 Comcast Cable Communications Management, LLC.
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type {
+  AnimationControllerState,
+  IAnimationController,
+} from '../../common/IAnimationController.js';
+import type { AnimationManager } from './AnimationManager.js';
+import type { CoreAnimation } from './CoreAnimation.js';
+import { assertTruthy } from '../../utils.js';
+
+export class CoreAnimationController implements IAnimationController {
+  stoppedPromise: Promise<void> | null = null;
+  /**
+   * If this is null, then the animation is in a finished / stopped state.
+   */
+  stoppedResolve: (() => void) | null = null;
+
+  constructor(
+    private manager: AnimationManager,
+    private animation: CoreAnimation,
+  ) {
+    this.state = 'stopped';
+  }
+
+  state: AnimationControllerState;
+
+  start(): IAnimationController {
+    this.makeStoppedPromise();
+    this.animation.once('finished', this.finished.bind(this));
+
+    // prevent registering the same animation twice
+    if (!this.manager.activeAnimations.has(this.animation)) {
+      this.manager.registerAnimation(this.animation);
+    }
+
+    this.state = 'running';
+    return this;
+  }
+
+  stop(): IAnimationController {
+    this.manager.unregisterAnimation(this.animation);
+    if (this.stoppedResolve !== null) {
+      this.stoppedResolve();
+      this.stoppedResolve = null;
+    }
+    this.animation.reset();
+    this.state = 'stopped';
+    return this;
+  }
+
+  pause(): IAnimationController {
+    this.manager.unregisterAnimation(this.animation);
+    this.state = 'paused';
+    return this;
+  }
+
+  restore(): IAnimationController {
+    this.stoppedResolve = null;
+    this.animation.restore();
+    return this;
+  }
+
+  waitUntilStopped(): Promise<void> {
+    this.makeStoppedPromise();
+    const promise = this.stoppedPromise;
+    assertTruthy(promise);
+    return promise;
+  }
+
+  private makeStoppedPromise(): void {
+    if (this.stoppedResolve === null) {
+      this.stoppedPromise = new Promise((resolve) => {
+        this.stoppedResolve = resolve;
+      });
+    }
+  }
+
+  private finished(): void {
+    assertTruthy(this.stoppedResolve);
+    // If the animation is looping, then we need to restart it.
+    const { loop, stopMethod } = this.animation.settings;
+
+    if (stopMethod === 'reverse') {
+      this.animation.reverse();
+      this.start();
+      return;
+    }
+
+    // resolve promise
+    this.stoppedResolve();
+    this.stoppedResolve = null;
+
+    if (loop) {
+      return;
+    }
+
+    // unregister animation
+    this.manager.unregisterAnimation(this.animation);
+  }
+}

package/src/core/lib/glm/common.ts

@@ -0,0 +1,231 @@
+/*
+ * If not stated otherwise in this file or this component's LICENSE file the
+ * following copyright and licenses apply:
+ *
+ * Copyright 2023 Comcast Cable Communications Management, LLC.
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export const EPSILON = 0.00001;
+export const RANDOM = Math.random;
+export const ANGLE_ORDER = 'zyx';
+
+export type ConversionOrder = 'xyz' | 'xzy' | 'yxz' | 'yzx' | 'zxy' | 'zyx';
+
+type RemoveIndex<T> = {
+  [K in keyof T as number extends K ? never : K]: T[K];
+};
+
+export type Float32ArrayLen2 = RemoveIndex<Float32Array> & {
+  0: number;
+  1: number;
+  length: 2;
+};
+
+export type NumberArrayLen2 = [number, number];
+
+export type Float32ArrayLen3 = RemoveIndex<Float32Array> & {
+  0: number;
+  1: number;
+  2: number;
+  length: 3;
+};
+
+export type NumberArrayLen3 = [number, number, number];
+
+export type Float32ArrayLen4 = RemoveIndex<Float32Array> & {
+  0: number;
+  1: number;
+  2: number;
+  3: number;
+  length: 4;
+};
+
+export type NumberArrayLen4 = [number, number, number, number];
+
+export type Float32ArrayLen6 = RemoveIndex<Float32Array> & {
+  0: number;
+  1: number;
+  2: number;
+  3: number;
+  4: number;
+  5: number;
+  length: 6;
+};
+
+export type NumberArrayLen6 = [number, number, number, number, number, number];
+
+export type Float32ArrayLen8 = RemoveIndex<Float32Array> & {
+  0: number;
+  1: number;
+  2: number;
+  3: number;
+  4: number;
+  5: number;
+  6: number;
+  7: number;
+  length: 8;
+};
+
+export type NumberArrayLen8 = [
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+];
+
+export type Float32ArrayLen9 = RemoveIndex<Float32Array> & {
+  0: number;
+  1: number;
+  2: number;
+  3: number;
+  4: number;
+  5: number;
+  6: number;
+  7: number;
+  8: number;
+  length: 9;
+};
+
+export type NumberArrayLen9 = [
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+];
+
+export type Float32ArrayLen16 = RemoveIndex<Float32Array> & {
+  0: number;
+  1: number;
+  2: number;
+  3: number;
+  4: number;
+  5: number;
+  6: number;
+  7: number;
+  8: number;
+  9: number;
+  10: number;
+  11: number;
+  12: number;
+  13: number;
+  14: number;
+  15: number;
+  length: 16;
+};
+
+export type NumberArrayLen16 = [
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+];
+
+export interface FOV {
+  upDegrees: number;
+  downDegrees: number;
+  leftDegrees: number;
+  rightDegrees: number;
+}
+
+let useFloat32Arrays = true;
+
+/**
+ * Sets array type to be used.
+ *
+ * @param {number} size of matrix type
+ * @returns {FloatArray} matrix type
+ */
+export function setMatrixArrayType(type: Float32Array | number[]): void {
+  useFloat32Arrays = type instanceof Float32Array;
+}
+
+/**
+ * Return array type to be used.
+ *
+ * @param {number} size of matrix type
+ * @returns {FloatArray} matrix type
+ */
+export function getMatrixArrayType(size?: number): Float32Array | number[] {
+  if (useFloat32Arrays && typeof Float32Array !== 'undefined') {
+    return size ? new Float32Array(size) : new Float32Array();
+  }
+  return [];
+}
+
+/**
+ * Convert Angle in Degrees To Radians
+ *
+ * @param {number} angle is an Angle in Degrees
+ */
+export function toRadians(angle: number): number {
+  return angle * (Math.PI / 180);
+}
+
+/**
+ * Convert Angle in Radians To an Angle in Radians
+ *
+ * @param {number} angle is an Angle in Radians
+ */
+export function toDegrees(angle: number): number {
+  return angle * (180 / Math.PI);
+}
+
+/**
+ * Tests whether or not the arguments have approximately the same value, within an absolute
+ * or relative tolerance of glMatrix.EPSILON (an absolute tolerance is used for values less
+ * than or equal to 1.0, and a relative tolerance is used for larger values)
+ *
+ * @param {number} a The first number to test.
+ * @param {number} b The second number to test.
+ * @returns {boolean} True if the numbers are approximately equal, false otherwise.
+ */
+
+export function equals(a: number, b: number): boolean {
+  return Math.abs(a - b) <= EPSILON * Math.max(1.0, Math.abs(a), Math.abs(b));
+}
+
+if (!Math.hypot)
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  Math.hypot = function (...args: any[]): number {
+    let y = 0,
+      i: number = arguments.length;
+
+    while (i--) {
+      y += args[i] * args[i];
+    }
+
+    return Math.sqrt(y);
+  };

package/src/core/lib/glm/index.ts

@@ -0,0 +1,31 @@
+/*
+ * If not stated otherwise in this file or this component's LICENSE file the
+ * following copyright and licenses apply:
+ *
+ * Copyright 2023 Comcast Cable Communications Management, LLC.
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import * as glMatrix from './common.js';
+import * as mat2 from './mat2.js';
+import * as mat2d from './mat2d.js';
+import * as mat3 from './mat3.js';
+import * as mat4 from './mat4.js';
+import * as quat from './quat.js';
+import * as quat2 from './quat2.js';
+import * as vec2 from './vec2.js';
+import * as vec3 from './vec3.js';
+import * as vec4 from './vec4.js';
+
+export { glMatrix, mat2, mat2d, mat3, mat4, quat, quat2, vec2, vec3, vec4 };