@lightningjs/renderer 0.9.1 → 0.9.3

package/src/core/utils.ts

@@ -177,7 +177,7 @@ const parseCubicBezier = (str: string) => {
 export const getTimingFunction = (
   str: string,
 ): ((time: number) => number | undefined) => {
-  if (str === '') {
+  if (str === 'linear') {
     return defaultTiming;
   }
 
@@ -185,12 +185,6 @@ export const getTimingFunction = (
     return timingMapping[str] || defaultTiming;
   }
 
-  if (str === 'linear') {
-    return (time: number) => {
-      return time;
-    };
-  }
-
   if (str === 'step-start') {
     return () => {
       return 1;

package/src/main-api/INode.ts

@@ -443,7 +443,7 @@ export interface INodeWritableProps {
  * The data stored can only be of type string, number or boolean.
  */
 export type CustomDataMap = {
-  [key: string]: string | number | boolean;
+  [key: string]: string | number | boolean | undefined;
 };
 
 export type INodeAnimatableProps = {

package/src/render-drivers/threadx/ThreadXMainAnimationController.ts

@@ -18,6 +18,7 @@
  */
 
 /* eslint-disable @typescript-eslint/unbound-method */
+import { EventEmitter } from '../../common/EventEmitter.js';
 import type {
   AnimationControllerState,
   IAnimationController,
@@ -25,37 +26,48 @@ import type {
 import { assertTruthy } from '../../utils.js';
 import type { ThreadXMainNode } from './ThreadXMainNode.js';
 
-export class ThreadXMainAnimationController implements IAnimationController {
-  stoppedPromise: Promise<void> | null = null;
+export class ThreadXMainAnimationController
+  extends EventEmitter
+  implements IAnimationController
+{
+  stoppedPromise: Promise<void>;
   /**
    * If this is null, then the animation is in a finished / stopped state.
    */
   stoppedResolve: (() => void) | null = null;
+  state: AnimationControllerState;
 
   constructor(private node: ThreadXMainNode, private id: number) {
-    this.onAnimationFinished = this.onAnimationFinished.bind(this);
+    super();
     this.state = 'stopped';
-  }
 
-  state: AnimationControllerState;
+    // Initial stopped promise is resolved (since the animation is stopped)
+    this.stoppedPromise = Promise.resolve();
+
+    // Bind event handlers
+    this.onAnimating = this.onAnimating.bind(this);
+    this.onFinished = this.onFinished.bind(this);
+  }
 
   start(): IAnimationController {
-    if (this.stoppedResolve === null) {
+    if (this.state !== 'running') {
       this.makeStoppedPromise();
-      this.node.on('animationFinished', this.onAnimationFinished);
+      this.sendStart();
+      this.state = 'running';
     }
-    this.state = 'running';
-    this.node.emit('startAnimation', { id: this.id });
     return this;
   }
 
   stop(): IAnimationController {
-    this.node.emit('stopAnimation', { id: this.id });
-    this.node.off('animationFinished', this.onAnimationFinished);
-    if (this.stoppedResolve !== null) {
-      this.stoppedResolve();
-      this.stoppedResolve = null;
+    if (this.state === 'stopped') {
+      return this;
     }
+    this.sendStop();
+    // if (this.stoppedResolve !== null) {
+    //   this.stoppedResolve();
+    //   this.stoppedResolve = null;
+    //   this.emit('stopped', this);
+    // }
     this.state = 'stopped';
     return this;
   }
@@ -71,29 +83,53 @@ export class ThreadXMainAnimationController implements IAnimationController {
   }
 
   waitUntilStopped(): Promise<void> {
-    this.makeStoppedPromise();
-    const promise = this.stoppedPromise;
-    assertTruthy(promise);
-    return promise;
+    return this.stoppedPromise;
+  }
+
+  private sendStart(): void {
+    // Hook up event listeners
+    this.node.on('animationFinished', this.onFinished);
+    this.node.on('animationAnimating', this.onAnimating);
+    // Then register the animation
+    this.node.emit('startAnimation', { id: this.id });
+  }
+
+  private sendStop(): void {
+    // First unregister the animation
+    this.node.emit('stopAnimation', { id: this.id });
+    // Then unhook event listeners
+    this.node.off('animationFinished', this.onFinished);
+    this.node.off('animationAnimating', this.onAnimating);
   }
 
-  private onAnimationFinished(
+  private makeStoppedPromise(): void {
+    if (this.stoppedResolve === null) {
+      this.stoppedPromise = new Promise((resolve) => {
+        this.stoppedResolve = resolve;
+      });
+    }
+  }
+
+  private onFinished(
     target: ThreadXMainNode,
-    { id, loop }: { id: number; loop: boolean },
+    { id }: { id: number; loop: boolean },
   ) {
     if (id === this.id) {
-      this.node.off('animationFinished', this.onAnimationFinished);
-      this.stoppedResolve?.();
+      assertTruthy(this.stoppedResolve);
+      this.node.off('animationFinished', this.onFinished);
+      this.node.off('animationAnimating', this.onAnimating);
+
+      // resolve promise
+      this.stoppedResolve();
       this.stoppedResolve = null;
+      this.emit('stopped', this);
       this.state = 'stopped';
     }
   }
 
-  private makeStoppedPromise(): void {
-    if (this.stoppedResolve === null) {
-      this.stoppedPromise = new Promise((resolve) => {
-        this.stoppedResolve = resolve;
-      });
+  private onAnimating(target: ThreadXMainNode, { id }: { id: number }) {
+    if (id === this.id) {
+      this.emit('animating', this);
     }
   }
 }

package/src/render-drivers/threadx/worker/ThreadXRendererNode.ts

@@ -84,6 +84,12 @@ export class ThreadXRendererNode extends SharedNode {
           props as Partial<INodeAnimatableProps>,
           settings as Partial<AnimationSettings>,
         );
+        animation.on('animating', () => {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+          this.emit('animationAnimating', {
+            id: id as number,
+          });
+        });
         animation.on('finished', () => {
           // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
           this.emit('animationFinished', {

package/src/render-drivers/utils.ts

@@ -58,7 +58,12 @@ export async function loadCoreExtension(
 }
 
 export function santizeCustomDataMap(d: CustomDataMap): CustomDataMap {
-  const validTypes = { boolean: true, string: true, number: true, undefined: true };
+  const validTypes = {
+    boolean: true,
+    string: true,
+    number: true,
+    undefined: true,
+  };
 
   const keys = Object.keys(d);
   for (let i = 0; i < keys.length; i++) {

package/dist/src/core/lib/WebGlContext.d.ts

@@ -1,414 +0,0 @@
-export declare class WebGlContext {
-    private gl;
-    private activeTextureUnit;
-    private texture2dUnits;
-    private texture2dParams;
-    private scissorEnabled;
-    private scissorX;
-    private scissorY;
-    private scissorWidth;
-    private scissorHeight;
-    private blendEnabled;
-    private blendSrcRgb;
-    private blendDstRgb;
-    private blendSrcAlpha;
-    private blendDstAlpha;
-    private boundArrayBuffer;
-    private boundElementArrayBuffer;
-    private curProgram;
-    private programUniforms;
-    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext);
-    /**
-     * ```
-     * gl.activeTexture(textureUnit + gl.TEXTURE0);
-     * ```
-     *
-     * @remarks
-     * **WebGL Difference**: `textureUnit` is based from 0, not `gl.TEXTURE0`.
-     *
-     * @param textureUnit
-     */
-    activeTexture(textureUnit: number): void;
-    /**
-     * ```
-     * gl.bindTexture(gl.TEXTURE_2D, texture);
-     * ```
-     * @remarks
-     * **WebGL Difference**: Bind target is always `gl.TEXTURE_2D`
-     *
-     * @param texture
-     */
-    bindTexture(texture: WebGLTexture | null): void;
-    private _getActiveTexture;
-    /**
-     * ```
-     * gl.texParameteri(gl.TEXTURE_2D, pname, param)
-     * ```
-     * @remarks
-     * **WebGL Difference**: Bind target is always `gl.TEXTURE_2D`
-     *
-     * @param pname
-     * @param param
-     * @returns
-     */
-    texParameteri(pname: number, param: number): void;
-    /**
-     * ```
-     * gl.texImage2D(
-     *   gl.TEXTURE_2D,
-     *   level,
-     *   internalFormat,
-     *   width,
-     *   height,
-     *   border,
-     *   format,
-     *   type,
-     *   pixels,
-     * );
-     * ```
-     * @remarks
-     * **WebGL Difference**: Bind target is always `gl.TEXTURE_2D`
-     *
-     * @param level
-     * @param internalFormat
-     * @param width
-     * @param height
-     * @param border
-     * @param format
-     * @param type
-     * @param pixels
-     */
-    texImage2D(level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
-    texImage2D(level: GLint, internalformat: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
-    /**
-     * ```
-     * gl.pixelStorei(pname, param);
-     * ```
-     *
-     * @param pname
-     * @param param
-     */
-    pixelStorei(pname: GLenum, param: GLint | GLboolean): void;
-    /**
-     * ```
-     * gl.generateMipmap(gl.TEXTURE_2D);
-     * ```
-     *
-     * @remarks
-     * **WebGL Difference**: Bind target is always `gl.TEXTURE_2D`
-     */
-    generateMipmap(): void;
-    /**
-     * ```
-     * gl.createTexture();
-     * ```
-     *
-     * @returns
-     */
-    createTexture(): WebGLTexture | null;
-    /**
-     * ```
-     * gl.deleteTexture(texture);
-     * ```
-     *
-     * @param texture
-     */
-    deleteTexture(texture: WebGLTexture | null): void;
-    /**
-     * ```
-     * gl.viewport(x, y, width, height);
-     * ```
-     */
-    viewport(x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
-    /**
-     * ```
-     * gl.clearColor(red, green, blue, alpha);
-     * ```
-     *
-     * @param red
-     * @param green
-     * @param blue
-     * @param alpha
-     */
-    clearColor(red: GLclampf, green: GLclampf, blue: GLclampf, alpha: GLclampf): void;
-    /**
-     * ```
-     * gl["enable"|"disable"](gl.SCISSOR_TEST);
-     * ```
-     * @param enable
-     */
-    scissorTest(enable: boolean): void;
-    /**
-     * ```
-     * gl.scissor(x, y, width, height);
-     * ```
-     *
-     * @param x
-     * @param y
-     * @param width
-     * @param height
-     */
-    scissor(x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
-    /**
-     * ```
-     * gl["enable"|"disable"](gl.BLEND);
-     * ```
-     *
-     * @param blend
-     * @returns
-     */
-    setBlend(blend: boolean): void;
-    /**
-     * ```
-     * gl.blendFunc(src, dst);
-     * ```
-     *
-     * @param src
-     * @param dst
-     */
-    blendFunc(src: GLenum, dst: GLenum): void;
-    /**
-     * ```
-     * createBuffer();
-     * ```
-     *
-     * @returns
-     */
-    createBuffer(): WebGLBuffer | null;
-    /**
-     * ```
-     * gl.clear(gl.COLOR_BUFFER_BIT);
-     * ```
-     *
-     * @remarks
-     * **WebGL Difference**: Clear mask is always `gl.COLOR_BUFFER_BIT`
-     */
-    clear(): void;
-    /**
-     * ```
-     * gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-     * gl.bufferData(gl.ARRAY_BUFFER, data, usage);
-     * ```
-     *
-     * @remarks
-     * **WebGL Combo**: `gl.bindBuffer` and `gl.bufferData` are combined into one function.
-     *
-     * @param buffer
-     * @param data
-     * @param usage
-     */
-    arrayBufferData(buffer: WebGLBuffer | null, data: ArrayBufferView, usage: GLenum): void;
-    /**
-     * ```
-     * gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, buffer);
-     * gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, data, usage);
-     * ```
-     * @remarks
-     * **WebGL Combo**: `gl.bindBuffer` and `gl.bufferData` are combined into one function.
-     *
-     * @param buffer
-     * @param data
-     * @param usage
-     */
-    elementArrayBufferData(buffer: WebGLBuffer | null, data: ArrayBufferView, usage: GLenum): void;
-    /**
-     * ```
-     * gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-     * gl.vertexAttribPointer(index, size, type, normalized, stride, offset);
-     * ```
-     *
-     * @remarks
-     * **WebGL Combo**: `gl.bindBuffer` and `gl.vertexAttribPointer` are combined into one function.
-     *
-     * @param buffer
-     * @param index
-     * @param size
-     * @param type
-     * @param normalized
-     * @param stride
-     * @param offset
-     */
-    vertexAttribPointer(buffer: WebGLBuffer, index: GLuint, size: GLint, type: GLenum, normalized: GLboolean, stride: GLsizei, offset: GLintptr): void;
-    /**
-     * ```
-     * gl.useProgram(program);
-     * ```
-     *
-     * @param program
-     * @returns
-     */
-    useProgram(program: WebGLProgram | null): void;
-    setUniform<T extends keyof UniformMethodMap>(type: T, location: WebGLUniformLocation, ...args: UniformMethodMap[T]): void;
-    /**
-     * ```
-     * gl.getParameter(pname);
-     * ```
-     *
-     * @param pname
-     * @returns
-     */
-    getParameter(pname: GLenum): any;
-    /**
-     * ```
-     * gl.drawElements(mode, count, type, offset);
-     * ```
-     *
-     * @param mode
-     * @param count
-     * @param type
-     * @param offset
-     */
-    drawElements(mode: GLenum, count: GLsizei, type: GLenum, offset: GLintptr): void;
-    /**
-     * ```
-     * gl.drawArrays(mode, first, count);
-     * ```
-     *
-     * @param name
-     * @returns
-     */
-    getExtension(name: string): any;
-    /**
-     * ```
-     * gl.createVertexArray();
-     * ```
-     *
-     * @returns
-     */
-    createVertexArray(): WebGLVertexArrayObject | null;
-    /**
-     * ```
-     * gl.bindVertexArray(vertexArray);
-     * ```
-     *
-     * @param vertexArray
-     */
-    bindVertexArray(vertexArray: WebGLVertexArrayObject | null): void;
-    /**
-     * ```
-     * gl.getAttribLocation(program, name);
-     * ```
-     *
-     * @param program
-     * @param name
-     * @returns
-     */
-    getAttribLocation(program: WebGLProgram, name: string): number;
-    /**
-     * ```
-     * gl.getUniformLocation(program, name);
-     * ```
-     *
-     * @param program
-     * @param name
-     * @returns
-     */
-    getUniformLocation(program: WebGLProgram, name: string): WebGLUniformLocation | null;
-    /**
-     * ```
-     * gl.enableVertexAttribArray(index);
-     * ```
-     *
-     * @param index
-     */
-    enableVertexAttribArray(index: number): void;
-    /**
-     * ```
-     * gl.disableVertexAttribArray(index);
-     * ```
-     *
-     * @param index
-     */
-    disableVertexAttribArray(index: number): void;
-    /**
-     * ```
-     * gl.createShader(type);
-     * ```
-     *
-     * @param type
-     * @returns
-     */
-    createShader(type: number): WebGLShader | null;
-    /**
-     * ```
-     * gl.compileShader(shader);
-     * ```
-     *
-     * @param shader
-     * @returns
-     */
-    compileShader(shader: WebGLShader): void;
-    /**
-     * ```
-     * gl.attachShader(program, shader);
-     * ```
-     *
-     * @param program
-     * @param shader
-     */
-    attachShader(program: WebGLProgram, shader: WebGLShader): void;
-    /**
-     * ```
-     * gl.linkProgram(program);
-     * ```
-     *
-     * @param program
-     */
-    linkProgram(program: WebGLProgram): void;
-    /**
-     * ```
-     * gl.deleteProgram(shader);
-     * ```
-     *
-     * @param shader
-     */
-    deleteProgram(shader: WebGLProgram): void;
-    /**
-     * ```
-     * gl.getShaderParameter(shader, pname);
-     * ```
-     *
-     * @param shader
-     * @param pname
-     */
-    getShaderParameter(shader: WebGLShader, pname: GLenum): any;
-    /**
-     * ```
-     * gl.getShaderInfoLog(shader);
-     * ```
-     *
-     * @param shader
-     */
-    getShaderInfoLog(shader: WebGLShader): string | null;
-    /**
-     * ```
-     * gl.createProgram();
-     * ```
-     *
-     * @returns
-     */
-    createProgram(): WebGLProgram | null;
-    /**
-     * ```
-     * gl.getProgramParameter(program, pname);
-     * ```
-     *
-     * @param program
-     * @param pname
-     * @returns
-     */
-    getProgramParameter(program: WebGLProgram, pname: GLenum): any;
-}
-type IsUniformMethod<MethodName, MethodType> = MethodName extends `uniform${string}` ? MethodType extends (location: WebGLUniformLocation | null, ...args: any[]) => void ? true : false : false;
-export type UniformMethodMap = {
-    [Key in keyof WebGLRenderingContext as IsUniformMethod<Key, WebGLRenderingContext[Key]> extends true ? Key : never]: WebGLRenderingContext[Key] extends (location: WebGLUniformLocation | null, ...args: infer T) => void ? T : never;
-};
-/**
- *
- *
- * @param a
- * @param b
- * @returns
- */
-export declare function compareArrays<T>(a: T[], b: T[]): boolean;
-export {};