@lightningjs/renderer 0.9.4 → 1.0.0-rc.1

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

@@ -1,201 +0,0 @@
-/*
- * 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 { IAnimationController } from '../../common/IAnimationController.js';
-import type {
-  CustomDataMap,
-  INode,
-  INodeAnimatableProps,
-} from '../../main-api/INode.js';
-import type {
-  RendererMain,
-  ShaderRef,
-  TextureRef,
-} from '../../main-api/RendererMain.js';
-import { assertTruthy } from '../../utils.js';
-import type { NodeStruct } from './NodeStruct.js';
-import { SharedNode } from './SharedNode.js';
-import { ThreadXMainAnimationController } from './ThreadXMainAnimationController.js';
-import type { AnimationSettings } from '../../core/animations/CoreAnimation.js';
-import { santizeCustomDataMap } from '../utils.js';
-
-export class ThreadXMainNode extends SharedNode implements INode {
-  private nextAnimationId = 1;
-  protected _parent: ThreadXMainNode | null = null;
-  protected _children: ThreadXMainNode[] = [];
-  protected _texture: TextureRef | null = null;
-  protected _shader: ShaderRef | null = null;
-  protected _data: CustomDataMap | undefined = {};
-  private _src = '';
-  private _parentHasRenderTexture = false;
-
-  /**
-   * FinalizationRegistry for animation controllers. When an animation
-   * controller is garbage collected, we let the render worker know so that
-   * it can remove it's corresponding animation controler from it's stored
-   * Set. This should ultimately allow the render worker to garbage collect
-   * it's animation controller. The animation itself independent from the animation
-   * controller, so it will continue to run until it's finished regardless of
-   * whether or not the animation controller is garbage collected.
-   */
-  private animationRegistry = new FinalizationRegistry((id: number) => {
-    this.emit('destroyAnimation', { id });
-  });
-
-  constructor(
-    private rendererMain: RendererMain,
-    sharedNodeStruct: NodeStruct,
-    extendedCurProps?: Record<string, unknown>,
-  ) {
-    super(sharedNodeStruct, extendedCurProps);
-  }
-
-  get texture(): TextureRef | null {
-    return this._texture;
-  }
-
-  set texture(texture: TextureRef | null) {
-    if (this._texture === texture) {
-      return;
-    }
-    if (this._texture) {
-      this.rendererMain.textureTracker.decrementTextureRefCount(this._texture);
-    }
-    if (texture) {
-      this.rendererMain.textureTracker.incrementTextureRefCount(texture);
-    }
-    this._texture = texture;
-    if (texture) {
-      this.emit('loadTexture', texture as unknown as Record<string, unknown>);
-    } else {
-      this.emit('unloadTexture', {});
-    }
-  }
-
-  get shader(): ShaderRef | null {
-    return this._shader;
-  }
-
-  set shader(shader: ShaderRef | null) {
-    if (this._shader === shader) {
-      return;
-    }
-    this._shader = shader;
-    if (shader) {
-      this.emit('loadShader', shader as unknown as Record<string, unknown>);
-    }
-  }
-
-  get scale(): number | null {
-    if (this.scaleX !== this.scaleY) {
-      return null;
-    }
-    return this.scaleX;
-  }
-
-  set scale(scale: number | null) {
-    // We ignore `null` when it's set.
-    if (scale === null) {
-      return;
-    }
-    this.scaleX = scale;
-    this.scaleY = scale;
-  }
-
-  animate(
-    props: Partial<INodeAnimatableProps>,
-    settings: Partial<AnimationSettings>,
-  ): IAnimationController {
-    const id = this.nextAnimationId++;
-    this.emit('createAnimation', { id, props, settings });
-    const controller = new ThreadXMainAnimationController(this, id);
-    this.animationRegistry.register(controller, id);
-    return controller;
-  }
-
-  get src(): string {
-    return this._src;
-  }
-
-  set src(imageUrl: string) {
-    if (this._src === imageUrl) {
-      return;
-    }
-    this._src = imageUrl;
-    if (!imageUrl) {
-      this.texture = null;
-      return;
-    }
-    this.texture = this.rendererMain.createTexture('ImageTexture', {
-      src: imageUrl,
-    });
-  }
-
-  //#region Parent/Child Props
-  get parent(): ThreadXMainNode | null {
-    return this._parent;
-  }
-
-  set parent(newParent: ThreadXMainNode | null) {
-    const oldParent = this._parent;
-    this._parent = newParent;
-    this.parentId = newParent?.id ?? 0;
-    if (oldParent) {
-      const index = oldParent.children.indexOf(this);
-      assertTruthy(
-        index !== -1,
-        "ThreadXMainNode.parent: Node not found in old parent's children!",
-      );
-      oldParent.children.splice(index, 1);
-    }
-    if (newParent) {
-      newParent.children.push(this);
-    }
-  }
-
-  set parentHasRenderTexture(hasRenderTexture: boolean) {
-    this._parentHasRenderTexture = hasRenderTexture;
-  }
-
-  get parentHasRenderTexture(): boolean {
-    return this._parentHasRenderTexture;
-  }
-
-  get children(): ThreadXMainNode[] {
-    return this._children;
-  }
-  //#endregion Parent/Child Props
-
-  get props() {
-    return this.curProps;
-  }
-
-  get data(): CustomDataMap | undefined {
-    return this._data;
-  }
-
-  set data(d: CustomDataMap) {
-    this._data = santizeCustomDataMap(d);
-  }
-
-  override destroy() {
-    super.destroy();
-    this.texture = null;
-  }
-}

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

@@ -1,85 +0,0 @@
-/*
- * 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 { ITextNode } from '../../main-api/INode.js';
-import type { RendererMain } from '../../main-api/RendererMain.js';
-import type { NodeStructWritableProps } from './NodeStruct.js';
-import type {
-  TextNodeStruct,
-  TextNodeStructWritableProps,
-} from './TextNodeStruct.js';
-import { ThreadXMainNode } from './ThreadXMainNode.js';
-
-export class ThreadXMainTextNode extends ThreadXMainNode implements ITextNode {
-  protected _debug: ITextNode['debug'] = {};
-
-  constructor(rendererMain: RendererMain, sharedNodeStruct: TextNodeStruct) {
-    super(rendererMain, sharedNodeStruct, {
-      text: sharedNodeStruct.text,
-      textRendererOverride: sharedNodeStruct.textRendererOverride,
-      fontSize: sharedNodeStruct.fontSize,
-      fontFamily: sharedNodeStruct.fontFamily,
-      fontStretch: sharedNodeStruct.fontStretch,
-      fontStyle: sharedNodeStruct.fontStyle,
-      fontWeight: sharedNodeStruct.fontWeight,
-      lineHeight: sharedNodeStruct.lineHeight,
-      maxLines: sharedNodeStruct.maxLines,
-      textBaseline: sharedNodeStruct.textBaseline,
-      verticalAlign: sharedNodeStruct.verticalAlign,
-      contain: sharedNodeStruct.contain,
-      letterSpacing: sharedNodeStruct.letterSpacing,
-      offsetY: sharedNodeStruct.offsetY,
-      scrollable: sharedNodeStruct.scrollable,
-      scrollY: sharedNodeStruct.scrollY,
-      textAlign: sharedNodeStruct.textAlign,
-      overflowSuffix: sharedNodeStruct.overflowSuffix,
-    } satisfies Omit<TextNodeStructWritableProps, keyof NodeStructWritableProps>);
-  }
-
-  declare text: ITextNode['text'];
-  declare textRendererOverride: ITextNode['textRendererOverride'];
-  declare fontSize: ITextNode['fontSize'];
-  declare fontFamily: ITextNode['fontFamily'];
-  declare fontStretch: ITextNode['fontStretch'];
-  declare fontStyle: ITextNode['fontStyle'];
-  declare fontWeight: ITextNode['fontWeight'];
-  declare lineHeight: ITextNode['lineHeight'];
-  declare maxLines: ITextNode['maxLines'];
-  declare textBaseline: ITextNode['textBaseline'];
-  declare verticalAlign: ITextNode['verticalAlign'];
-  declare textAlign: ITextNode['textAlign'];
-  declare contain: ITextNode['contain'];
-  declare scrollable: ITextNode['scrollable'];
-  declare scrollY: ITextNode['scrollY'];
-  declare offsetY: ITextNode['offsetY'];
-  declare letterSpacing: ITextNode['letterSpacing'];
-  declare overflowSuffix: ITextNode['overflowSuffix'];
-
-  get debug(): ITextNode['debug'] {
-    return this._debug;
-  }
-
-  set debug(debug: ITextNode['debug']) {
-    if (this._debug === debug) {
-      return;
-    }
-    this._debug = debug;
-    this.emit('debug', debug);
-  }
-}

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

@@ -1,112 +0,0 @@
-/*
- * 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 {
-  FpsUpdatePayload,
-  FrameTickPayload,
-} from '../../common/CommonTypes.js';
-
-/**
- * @module
- * @description
- * Message types / utils for communication between the main worker and the
- * worker worker.
- */
-
-/**
- * Defines the shape of a message sent from the main worker to the worker
- */
-export interface ThreadXRendererMessage {
-  type: string;
-}
-
-/**
- * An initialization message sent from the main worker to the renderer worker
- */
-export interface ThreadXRendererInitMessage extends ThreadXRendererMessage {
-  type: 'init';
-  canvas: OffscreenCanvas;
-  appWidth: number;
-  appHeight: number;
-  txMemByteThreshold: number;
-  boundsMargin: number | [number, number, number, number];
-  deviceLogicalPixelRatio: number;
-  devicePhysicalPixelRatio: number;
-  clearColor: number;
-  fpsUpdateInterval: number;
-  enableContextSpy: boolean;
-  numImageWorkers: number;
-  coreExtensionModule: string | null;
-}
-
-/**
- * A message sent from the main worker to the renderer worker to release a
- * texture
- */
-export interface ThreadXRendererReleaseTextureMessage
-  extends ThreadXRendererMessage {
-  type: 'releaseTexture';
-  textureDescId: number;
-}
-
-/**
- * A message sent from the renderer worker to the main worker to update the FPS
- */
-export interface ThreadXRendererFpsUpdateMessage
-  extends ThreadXRendererMessage {
-  type: 'fpsUpdate';
-  fpsData: FpsUpdatePayload;
-}
-
-/**
- * A message sent from the renderer worker to the main worker to update the FPS
- */
-export interface ThreadXRendererFrameTickMessage
-  extends ThreadXRendererMessage {
-  type: 'frameTick';
-  frameTickData: FrameTickPayload;
-}
-
-/**
- * A map of message types to message shapes
- */
-export interface ThreadXRendererMessageMap {
-  init: ThreadXRendererInitMessage;
-  releaseTexture: ThreadXRendererReleaseTextureMessage;
-  fpsUpdate: ThreadXRendererFpsUpdateMessage;
-  frameTick: ThreadXRendererFrameTickMessage;
-}
-
-/**
- * Type guard util for a message sent from the main worker to the renderer worker
- *
- * @param type
- * @param message
- * @returns
- */
-export function isThreadXRendererMessage<
-  Type extends keyof ThreadXRendererMessageMap,
->(type: Type, message: unknown): message is ThreadXRendererMessageMap[Type] {
-  return (
-    typeof message === 'object' &&
-    message !== null &&
-    'type' in message &&
-    message.type === type
-  );
-}

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

@@ -1,253 +0,0 @@
-/*
- * 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 { NodeStruct } from '../NodeStruct.js';
-import { SharedNode } from '../SharedNode.js';
-import { ThreadX } from '@lightningjs/threadx';
-import type { Stage } from '../../../core/Stage.js';
-import { assertTruthy } from '../../../utils.js';
-import type { IAnimationController } from '../../../common/IAnimationController.js';
-import type { INodeAnimatableProps } from '../../../main-api/INode.js';
-import { CoreAnimation } from '../../../core/animations/CoreAnimation.js';
-import { CoreAnimationController } from '../../../core/animations/CoreAnimationController.js';
-import type { Texture } from '../../../core/textures/Texture.js';
-import { CoreNode } from '../../../core/CoreNode.js';
-import type { ShaderRef, TextureRef } from '../../../main-api/RendererMain.js';
-import type { AnimationSettings } from '../../../core/animations/CoreAnimation.js';
-import type {
-  NodeLoadedPayload,
-  NodeFailedPayload,
-  NodeTextureFreedPayload,
-} from '../../../common/CommonTypes.js';
-
-export class ThreadXRendererNode extends SharedNode {
-  protected coreNode: CoreNode;
-  protected _parent: ThreadXRendererNode | null = null;
-  protected _children: ThreadXRendererNode[] = [];
-  texture: Texture | null = null;
-
-  private animationControllers = new Map<number, IAnimationController>();
-
-  constructor(
-    private stage: Stage,
-    sharedNodeStruct: NodeStruct,
-    coreNode?: CoreNode,
-    extendedCurProps?: Record<string, unknown>,
-  ) {
-    super(sharedNodeStruct, extendedCurProps);
-    // This Proxy makes sure properties on the coreNode that an animation
-    // changes are also updated on the shared node.
-    // TODO: Improve this pattern because its ugly!!!
-    this.coreNode = new Proxy(
-      coreNode || this.createCoreNode(stage, sharedNodeStruct),
-      {
-        set: (target, prop, value) => {
-          // Only set the numeric properties on the shared node.
-          if (prop !== 'parent' && prop !== 'texture' && prop !== 'shader') {
-            Reflect.set(this, prop, value);
-          }
-          return Reflect.set(target, prop, value);
-        },
-      },
-    );
-
-    // Set up parent
-    const parent = ThreadX.instance.getSharedObjectById(
-      sharedNodeStruct.parentId,
-    );
-    assertTruthy(parent instanceof ThreadXRendererNode || parent === null);
-    this.parent = parent;
-
-    // Create inbound event listeners
-    // TOOD: Make sure event listeners are removed when the node is destroyed.
-    this.on(
-      'createAnimation',
-      (target: ThreadXRendererNode, { id, props, settings }) => {
-        const animation = new CoreAnimation(
-          this.coreNode,
-          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', {
-            id: id as number,
-            loop: settings.loop,
-          });
-        });
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call
-        const controller = new CoreAnimationController(
-          this.stage.animationManager,
-          animation,
-        );
-        this.animationControllers.set(id as number, controller);
-      },
-    );
-    this.on('destroyAnimation', (target: ThreadXRendererNode, { id }) => {
-      this.animationControllers.delete(id as number);
-    });
-    this.on('startAnimation', (target: ThreadXRendererNode, { id }) => {
-      this.animationControllers.get(id as number)?.start();
-    });
-    this.on('stopAnimation', (target: ThreadXRendererNode, { id }) => {
-      this.animationControllers.get(id as number)?.stop();
-    });
-    this.on('pauseAnimation', (target: ThreadXRendererNode, { id }) => {
-      this.animationControllers.get(id as number)?.pause();
-    });
-    this.on(
-      'loadTexture',
-      (target: ThreadXRendererNode, textureDesc: TextureRef) => {
-        this.coreNode.loadTexture(
-          textureDesc.txType,
-          textureDesc.props,
-          textureDesc.options,
-        );
-      },
-    );
-    this.on(
-      'loadShader',
-      (target: ThreadXRendererNode, shaderDesc: ShaderRef) => {
-        this.coreNode.loadShader(shaderDesc.shType, shaderDesc.props);
-      },
-    );
-    this.on('unloadTexture', (target: ThreadXRendererNode) => {
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-explicit-any
-      this.coreNode.unloadTexture();
-    });
-    // Forward on CoreNode events
-    this.coreNode.on(
-      'loaded',
-      (target: CoreNode, payload: NodeLoadedPayload) => {
-        this.emit('loaded', payload);
-      },
-    );
-    this.coreNode.on(
-      'failed',
-      (target: CoreNode, payload: NodeFailedPayload) => {
-        this.emit('failed', payload);
-      },
-    );
-    this.coreNode.on(
-      'freed',
-      (target: CoreNode, payload: NodeTextureFreedPayload) => {
-        this.emit('freed', payload);
-      },
-    );
-  }
-
-  override onPropertyChange<Key extends keyof this['z$__type__Props']>(
-    propName: Key,
-    newValue: this['z$__type__Props'][Key],
-    oldValue: this['z$__type__Props'][Key] | undefined,
-  ): void {
-    if (propName === 'parentId') {
-      const parent = ThreadX.instance.getSharedObjectById(newValue as number);
-      assertTruthy(parent instanceof ThreadXRendererNode || parent === null);
-      this.parent = parent;
-      return;
-    } else {
-      // @ts-expect-error Ignore readonly assignment errors
-      this.coreNode[propName as keyof CoreNode] =
-        newValue as CoreNode[keyof CoreNode];
-    }
-  }
-
-  //#region Parent/Child Props
-  get parent(): ThreadXRendererNode | null {
-    return this._parent;
-  }
-
-  set parent(newParent: ThreadXRendererNode | null) {
-    const oldParent = this._parent;
-    this._parent = newParent;
-    this.coreNode.parent = newParent?.coreNode ?? null;
-    this.parentId = newParent?.id ?? 0;
-    if (oldParent) {
-      const index = oldParent.children.indexOf(this);
-      assertTruthy(
-        index !== -1,
-        "ThreadXRendererNode.parent: Node not found in old parent's children!",
-      );
-      oldParent.children.splice(index, 1);
-    }
-    if (newParent) {
-      newParent.children.push(this);
-    }
-  }
-
-  get children(): ThreadXRendererNode[] {
-    return this._children;
-  }
-  //#endregion Parent/Child Props
-
-  private createCoreNode(stage: Stage, sharedNodeStruct: NodeStruct) {
-    const parent = ThreadX.instance.getSharedObjectById(
-      sharedNodeStruct.parentId,
-    );
-    assertTruthy(parent instanceof ThreadXRendererNode || parent === null);
-    const node = new CoreNode(stage, {
-      id: sharedNodeStruct.id,
-      x: sharedNodeStruct.x,
-      y: sharedNodeStruct.y,
-      width: sharedNodeStruct.width,
-      height: sharedNodeStruct.height,
-      alpha: sharedNodeStruct.alpha,
-      autosize: sharedNodeStruct.autosize,
-      clipping: sharedNodeStruct.clipping,
-      color: sharedNodeStruct.color,
-      colorTop: sharedNodeStruct.colorTop,
-      colorBottom: sharedNodeStruct.colorBottom,
-      colorLeft: sharedNodeStruct.colorLeft,
-      colorRight: sharedNodeStruct.colorRight,
-      colorTl: sharedNodeStruct.colorTl,
-      colorTr: sharedNodeStruct.colorTr,
-      colorBl: sharedNodeStruct.colorBl,
-      colorBr: sharedNodeStruct.colorBr,
-      zIndex: sharedNodeStruct.zIndex,
-      zIndexLocked: sharedNodeStruct.zIndexLocked,
-      scaleX: sharedNodeStruct.scaleX,
-      scaleY: sharedNodeStruct.scaleY,
-      mount: sharedNodeStruct.mount,
-      mountX: sharedNodeStruct.mountX,
-      mountY: sharedNodeStruct.mountY,
-      pivot: sharedNodeStruct.pivot,
-      pivotX: sharedNodeStruct.pivotX,
-      pivotY: sharedNodeStruct.pivotY,
-      rotation: sharedNodeStruct.rotation,
-      rtt: sharedNodeStruct.rtt,
-
-      // These are passed in via message handlers
-      shader: null,
-      shaderProps: null,
-      texture: null,
-      textureOptions: null,
-
-      // Setup the parent after
-      parent: null,
-    });
-    return node;
-  }
-}