@lightningjs/renderer 2.9.0-beta3 → 2.9.0

package/dist/src/render-drivers/main/MainCoreDriver.d.ts

@@ -0,0 +1,21 @@
+import type { ICoreDriver } from '../../main-api/ICoreDriver.js';
+import type { INode, INodeWritableProps, ITextNodeWritableProps } from '../../main-api/INode.js';
+import type { RendererMain, RendererMainSettings } from '../../main-api/RendererMain.js';
+import { MainOnlyTextNode } from './MainOnlyTextNode.js';
+import type { FpsUpdatePayload, FrameTickPayload } from '../../common/CommonTypes.js';
+export declare class MainCoreDriver implements ICoreDriver {
+    private root;
+    private stage;
+    private rendererMain;
+    init(rendererMain: RendererMain, rendererSettings: Required<RendererMainSettings>, canvas: HTMLCanvasElement): Promise<void>;
+    createNode(props: INodeWritableProps): INode;
+    createTextNode(props: ITextNodeWritableProps): MainOnlyTextNode;
+    destroyNode(node: INode): void;
+    releaseTexture(id: number): void;
+    getRootNode(): INode;
+    onCreateNode(node: INode): void;
+    onBeforeDestroyNode(node: INode): void;
+    onFpsUpdate(fpsData: FpsUpdatePayload): void;
+    onFrameTick(frameTickData: FrameTickPayload): void;
+    onIdle(): void;
+}

package/dist/src/render-drivers/main/MainCoreDriver.js

@@ -0,0 +1,115 @@
+/*
+ * 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 { assertTruthy } from '../../utils.js';
+import { MainOnlyNode, getNewId } from './MainOnlyNode.js';
+import { Stage, } from '../../core/Stage.js';
+import { MainOnlyTextNode } from './MainOnlyTextNode.js';
+import { loadCoreExtension } from '../utils.js';
+export class MainCoreDriver {
+    root = null;
+    stage = null;
+    rendererMain = null;
+    async init(rendererMain, rendererSettings, canvas) {
+        this.stage = new Stage({
+            rootId: getNewId(),
+            appWidth: rendererSettings.appWidth,
+            appHeight: rendererSettings.appHeight,
+            txMemByteThreshold: rendererSettings.txMemByteThreshold,
+            boundsMargin: rendererSettings.boundsMargin,
+            deviceLogicalPixelRatio: rendererSettings.deviceLogicalPixelRatio,
+            devicePhysicalPixelRatio: rendererSettings.devicePhysicalPixelRatio,
+            clearColor: rendererSettings.clearColor,
+            canvas,
+            fpsUpdateInterval: rendererSettings.fpsUpdateInterval,
+            enableContextSpy: rendererSettings.enableContextSpy,
+            numImageWorkers: rendererSettings.numImageWorkers,
+            renderMode: rendererSettings.renderMode,
+            debug: {
+                monitorTextureCache: false,
+            },
+        });
+        this.rendererMain = rendererMain;
+        assertTruthy(this.stage.root);
+        const node = new MainOnlyNode(rendererMain.resolveNodeDefaults({}), this.rendererMain, this.stage, this.stage.root);
+        this.root = node;
+        node.once('beforeDestroy', this.onBeforeDestroyNode.bind(this, node));
+        this.onCreateNode(node);
+        // Load the Core Extension Module if one was specified.
+        if (rendererSettings.coreExtensionModule) {
+            await loadCoreExtension(rendererSettings.coreExtensionModule, this.stage);
+        }
+        // Forward fpsUpdate events from the stage to RendererMain
+        this.stage.on('fpsUpdate', ((stage, fpsData) => {
+            this.onFpsUpdate(fpsData);
+        }));
+        this.stage.on('frameTick', ((stage, frameTickData) => {
+            this.onFrameTick(frameTickData);
+        }));
+        this.stage.on('idle', () => {
+            this.onIdle();
+        });
+    }
+    createNode(props) {
+        assertTruthy(this.rendererMain);
+        assertTruthy(this.stage);
+        const node = new MainOnlyNode(props, this.rendererMain, this.stage);
+        node.once('beforeDestroy', this.onBeforeDestroyNode.bind(this, node));
+        this.onCreateNode(node);
+        return node;
+    }
+    createTextNode(props) {
+        assertTruthy(this.rendererMain);
+        assertTruthy(this.stage);
+        const node = new MainOnlyTextNode(props, this.rendererMain, this.stage);
+        node.once('beforeDestroy', this.onBeforeDestroyNode.bind(this, node));
+        this.onCreateNode(node);
+        return node;
+    }
+    // TODO: Remove?
+    destroyNode(node) {
+        node.destroy();
+    }
+    releaseTexture(id) {
+        const { stage } = this;
+        assertTruthy(stage);
+        stage.txManager.removeTextureIdFromCache(id);
+    }
+    getRootNode() {
+        assertTruthy(this.root);
+        return this.root;
+    }
+    //#region Event Methods
+    // The implementations for these event methods are provided by RendererMain
+    onCreateNode(node) {
+        throw new Error('Method not implemented.');
+    }
+    onBeforeDestroyNode(node) {
+        throw new Error('Method not implemented.');
+    }
+    onFpsUpdate(fpsData) {
+        throw new Error('Method not implemented.');
+    }
+    onFrameTick(frameTickData) {
+        throw new Error('Method not implemented.');
+    }
+    onIdle() {
+        throw new Error('Method not implemented.');
+    }
+}
+//# sourceMappingURL=MainCoreDriver.js.map

package/dist/src/render-drivers/main/MainCoreDriver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MainCoreDriver.js","sourceRoot":"","sources":["../../../../src/render-drivers/main/MainCoreDriver.ts"],"names":[],"mappings":"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"}

package/dist/src/render-drivers/main/MainOnlyNode.d.ts

@@ -0,0 +1,101 @@
+import type { CustomDataMap, INode, INodeAnimatableProps, INodeWritableProps } from '../../main-api/INode.js';
+import type { Stage } from '../../core/Stage.js';
+import type { IAnimationController } from '../../common/IAnimationController.js';
+import { CoreNode } from '../../core/CoreNode.js';
+import type { RendererMain, ShaderRef, TextureRef } from '../../main-api/RendererMain.js';
+import type { AnimationSettings } from '../../core/animations/CoreAnimation.js';
+import { EventEmitter } from '../../common/EventEmitter.js';
+export declare function getNewId(): number;
+export declare class MainOnlyNode extends EventEmitter implements INode {
+    private rendererMain;
+    private stage;
+    readonly id: number;
+    protected coreNode: CoreNode;
+    protected _children: MainOnlyNode[];
+    protected _src: string;
+    protected _parent: MainOnlyNode | null;
+    protected _texture: TextureRef | null;
+    protected _shader: ShaderRef | null;
+    protected _data: CustomDataMap | undefined;
+    constructor(props: INodeWritableProps, rendererMain: RendererMain, stage: Stage, coreNode?: CoreNode);
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get width(): number;
+    set width(value: number);
+    get height(): number;
+    set height(value: number);
+    get alpha(): number;
+    set alpha(value: number);
+    get autosize(): boolean;
+    set autosize(value: boolean);
+    get clipping(): boolean;
+    set clipping(value: boolean);
+    get color(): number;
+    set color(value: number);
+    get colorTop(): number;
+    set colorTop(value: number);
+    get colorBottom(): number;
+    set colorBottom(value: number);
+    get colorLeft(): number;
+    set colorLeft(value: number);
+    get colorRight(): number;
+    set colorRight(value: number);
+    get colorTl(): number;
+    set colorTl(value: number);
+    get colorTr(): number;
+    set colorTr(value: number);
+    get colorBl(): number;
+    set colorBl(value: number);
+    get colorBr(): number;
+    set colorBr(value: number);
+    get scale(): number | null;
+    set scale(value: number | null);
+    get scaleX(): number;
+    set scaleX(value: number);
+    get scaleY(): number;
+    set scaleY(value: number);
+    get mount(): number;
+    set mount(value: number);
+    get mountX(): number;
+    set mountX(value: number);
+    get mountY(): number;
+    set mountY(value: number);
+    get pivot(): number;
+    set pivot(value: number);
+    get pivotX(): number;
+    set pivotX(value: number);
+    get pivotY(): number;
+    set pivotY(value: number);
+    get rotation(): number;
+    set rotation(value: number);
+    get parent(): MainOnlyNode | null;
+    set parent(newParent: MainOnlyNode | null);
+    get children(): MainOnlyNode[];
+    get zIndex(): number;
+    set zIndex(value: number);
+    get zIndexLocked(): number;
+    set zIndexLocked(value: number);
+    get src(): string;
+    set src(imageUrl: string);
+    get texture(): TextureRef | null;
+    set texture(texture: TextureRef | null);
+    get rtt(): boolean;
+    set rtt(value: boolean);
+    get parentHasRenderTexture(): boolean;
+    private onTextureLoaded;
+    private onTextureFailed;
+    private onTextureFreed;
+    private onOutOfBounds;
+    private onInBounds;
+    private onOutOfViewport;
+    private onInViewport;
+    get shader(): ShaderRef | null;
+    set shader(shader: ShaderRef | null);
+    get data(): CustomDataMap | undefined;
+    set data(d: CustomDataMap);
+    destroy(): void;
+    flush(): void;
+    animate(props: Partial<INodeAnimatableProps>, settings: Partial<AnimationSettings>): IAnimationController;
+}

package/dist/src/render-drivers/main/MainOnlyNode.js

@@ -0,0 +1,425 @@
+/*
+ * 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 { assertTruthy } from '../../utils.js';
+import { CoreAnimation } from '../../core/animations/CoreAnimation.js';
+import { CoreAnimationController } from '../../core/animations/CoreAnimationController.js';
+import { CoreNode } from '../../core/CoreNode.js';
+import { EventEmitter } from '../../common/EventEmitter.js';
+import { santizeCustomDataMap } from '../utils.js';
+let nextId = 1;
+export function getNewId() {
+    return nextId++;
+}
+export class MainOnlyNode extends EventEmitter {
+    rendererMain;
+    stage;
+    id;
+    coreNode;
+    // Prop stores
+    _children = [];
+    _src = '';
+    _parent = null;
+    _texture = null;
+    _shader = null;
+    _data = {};
+    constructor(props, rendererMain, stage, coreNode) {
+        super();
+        this.rendererMain = rendererMain;
+        this.stage = stage;
+        this.id = coreNode?.id ?? getNewId();
+        this.coreNode =
+            coreNode ||
+                new CoreNode(this.stage, {
+                    id: this.id,
+                    x: props.x,
+                    y: props.y,
+                    width: props.width,
+                    height: props.height,
+                    alpha: props.alpha,
+                    autosize: props.autosize,
+                    clipping: props.clipping,
+                    color: props.color,
+                    colorTop: props.colorTop,
+                    colorBottom: props.colorBottom,
+                    colorLeft: props.colorLeft,
+                    colorRight: props.colorRight,
+                    colorTl: props.colorTl,
+                    colorTr: props.colorTr,
+                    colorBl: props.colorBl,
+                    colorBr: props.colorBr,
+                    zIndex: props.zIndex,
+                    zIndexLocked: props.zIndexLocked,
+                    scaleX: props.scaleX,
+                    scaleY: props.scaleY,
+                    mountX: props.mountX,
+                    mountY: props.mountY,
+                    mount: props.mount,
+                    pivot: props.pivot,
+                    pivotX: props.pivotX,
+                    pivotY: props.pivotY,
+                    rotation: props.rotation,
+                    parent: null,
+                    shader: null,
+                    shaderProps: null,
+                    texture: null,
+                    textureOptions: null,
+                    rtt: props.rtt,
+                });
+        // Forward loaded/failed events
+        this.coreNode.on('loaded', this.onTextureLoaded);
+        this.coreNode.on('failed', this.onTextureFailed);
+        this.coreNode.on('freed', this.onTextureFreed);
+        this.coreNode.on('outOfBounds', this.onOutOfBounds);
+        this.coreNode.on('inBounds', this.onInBounds);
+        this.coreNode.on('outOfViewport', this.onOutOfViewport);
+        this.coreNode.on('inViewport', this.onInViewport);
+        // Assign properties to this object
+        this.parent = props.parent;
+        this.shader = props.shader;
+        this.texture = props.texture;
+        this.src = props.src;
+        this.rtt = props.rtt;
+        this._data = props.data;
+    }
+    get x() {
+        return this.coreNode.x;
+    }
+    set x(value) {
+        this.coreNode.x = value;
+    }
+    get y() {
+        return this.coreNode.y;
+    }
+    set y(value) {
+        this.coreNode.y = value;
+    }
+    get width() {
+        return this.coreNode.width;
+    }
+    set width(value) {
+        if (value !== this.coreNode.width && this.coreNode.rtt) {
+            this.texture = this.rendererMain.createTexture('RenderTexture', {
+                width: this.width,
+                height: this.height,
+            }, { preload: true, flipY: true });
+        }
+        this.coreNode.width = value;
+    }
+    get height() {
+        return this.coreNode.height;
+    }
+    set height(value) {
+        if (value !== this.coreNode.height && this.coreNode.rtt) {
+            this.texture = this.rendererMain.createTexture('RenderTexture', {
+                width: this.width,
+                height: this.height,
+            }, { preload: true, flipY: true });
+        }
+        this.coreNode.height = value;
+    }
+    get alpha() {
+        return this.coreNode.alpha;
+    }
+    set alpha(value) {
+        this.coreNode.alpha = value;
+    }
+    get autosize() {
+        return this.coreNode.autosize;
+    }
+    set autosize(value) {
+        this.coreNode.autosize = value;
+    }
+    get clipping() {
+        return this.coreNode.clipping;
+    }
+    set clipping(value) {
+        this.coreNode.clipping = value;
+    }
+    get color() {
+        return this.coreNode.color;
+    }
+    set color(value) {
+        this.coreNode.color = value;
+    }
+    get colorTop() {
+        return this.coreNode.colorTop;
+    }
+    set colorTop(value) {
+        this.coreNode.colorTop = value;
+    }
+    get colorBottom() {
+        return this.coreNode.colorBottom;
+    }
+    set colorBottom(value) {
+        this.coreNode.colorBottom = value;
+    }
+    get colorLeft() {
+        return this.coreNode.colorLeft;
+    }
+    set colorLeft(value) {
+        this.coreNode.colorLeft = value;
+    }
+    get colorRight() {
+        return this.coreNode.colorRight;
+    }
+    set colorRight(value) {
+        this.coreNode.colorRight = value;
+    }
+    get colorTl() {
+        return this.coreNode.colorTl;
+    }
+    set colorTl(value) {
+        this.coreNode.colorTl = value;
+    }
+    get colorTr() {
+        return this.coreNode.colorTr;
+    }
+    set colorTr(value) {
+        this.coreNode.colorTr = value;
+    }
+    get colorBl() {
+        return this.coreNode.colorBl;
+    }
+    set colorBl(value) {
+        this.coreNode.colorBl = value;
+    }
+    get colorBr() {
+        return this.coreNode.colorBr;
+    }
+    set colorBr(value) {
+        this.coreNode.colorBr = value;
+    }
+    get scale() {
+        if (this.scaleX !== this.scaleY) {
+            return null;
+        }
+        return this.coreNode.scaleX;
+    }
+    set scale(value) {
+        // We ignore `null` when it's set.
+        if (value === null) {
+            return;
+        }
+        this.coreNode.scaleX = value;
+        this.coreNode.scaleY = value;
+    }
+    get scaleX() {
+        return this.coreNode.scaleX;
+    }
+    set scaleX(value) {
+        this.coreNode.scaleX = value;
+    }
+    get scaleY() {
+        return this.coreNode.scaleY;
+    }
+    set scaleY(value) {
+        this.coreNode.scaleY = value;
+    }
+    get mount() {
+        return this.coreNode.mount;
+    }
+    set mount(value) {
+        this.coreNode.mount = value;
+    }
+    get mountX() {
+        return this.coreNode.mountX;
+    }
+    set mountX(value) {
+        this.coreNode.mountX = value;
+    }
+    get mountY() {
+        return this.coreNode.mountY;
+    }
+    set mountY(value) {
+        this.coreNode.mountY = value;
+    }
+    get pivot() {
+        return this.coreNode.pivot;
+    }
+    set pivot(value) {
+        this.coreNode.pivot = value;
+    }
+    get pivotX() {
+        return this.coreNode.pivotX;
+    }
+    set pivotX(value) {
+        this.coreNode.pivotX = value;
+    }
+    get pivotY() {
+        return this.coreNode.pivotY;
+    }
+    set pivotY(value) {
+        this.coreNode.pivotY = value;
+    }
+    get rotation() {
+        return this.coreNode.rotation;
+    }
+    set rotation(value) {
+        this.coreNode.rotation = value;
+    }
+    get parent() {
+        return this._parent;
+    }
+    set parent(newParent) {
+        const oldParent = this._parent;
+        this._parent = newParent;
+        this.coreNode.parent = newParent?.coreNode ?? null;
+        if (oldParent) {
+            const index = oldParent.children.indexOf(this);
+            assertTruthy(index !== -1, "MainOnlyNode.parent: Node not found in old parent's children!");
+            oldParent.children.splice(index, 1);
+        }
+        if (newParent) {
+            newParent.children.push(this);
+        }
+    }
+    get children() {
+        return this._children;
+    }
+    get zIndex() {
+        return this.coreNode.zIndex;
+    }
+    set zIndex(value) {
+        this.coreNode.zIndex = value;
+    }
+    get zIndexLocked() {
+        return this.coreNode.zIndexLocked;
+    }
+    set zIndexLocked(value) {
+        this.coreNode.zIndexLocked = value;
+    }
+    get src() {
+        return this._src;
+    }
+    set src(imageUrl) {
+        if (this._src === imageUrl) {
+            return;
+        }
+        this._src = imageUrl;
+        if (!imageUrl) {
+            this.texture = null;
+            return;
+        }
+        this.texture = this.rendererMain.createTexture('ImageTexture', {
+            src: imageUrl,
+        });
+    }
+    //#region Texture
+    get texture() {
+        return this._texture;
+    }
+    set texture(texture) {
+        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.coreNode.loadTexture(texture.txType, texture.props, texture.options);
+        }
+        else {
+            this.coreNode.unloadTexture();
+        }
+    }
+    get rtt() {
+        return this.coreNode.rtt;
+    }
+    set rtt(value) {
+        if (value) {
+            this.texture = this.rendererMain.createTexture('RenderTexture', {
+                width: this.width,
+                height: this.height,
+            }, { preload: true, flipY: true });
+        }
+        this.coreNode.rtt = value;
+    }
+    get parentHasRenderTexture() {
+        return this.coreNode.parentHasRenderTexture;
+    }
+    onTextureLoaded = (target, payload) => {
+        this.emit('loaded', payload);
+    };
+    onTextureFailed = (target, payload) => {
+        this.emit('failed', payload);
+    };
+    onTextureFreed = (target, payload) => {
+        this.emit('freed', payload);
+    };
+    onOutOfBounds = (target, payload) => {
+        this.emit('outOfBounds', payload);
+    };
+    onInBounds = (target, payload) => {
+        this.emit('inBounds', payload);
+    };
+    onOutOfViewport = (target, payload) => {
+        this.emit('outOfViewport', payload);
+    };
+    onInViewport = (target, payload) => {
+        this.emit('inViewport', payload);
+    };
+    //#endregion Texture
+    get shader() {
+        return this._shader;
+    }
+    set shader(shader) {
+        if (this._shader === shader) {
+            return;
+        }
+        this._shader = shader;
+        if (shader) {
+            this.coreNode.loadShader(shader.shType, shader.props);
+        }
+    }
+    get data() {
+        return this._data;
+    }
+    set data(d) {
+        this._data = santizeCustomDataMap(d);
+    }
+    destroy() {
+        this.emit('beforeDestroy', {});
+        //use while loop since setting parent to null removes it from array
+        let child = this.children[0];
+        while (child) {
+            child.destroy();
+            child = this.children[0];
+        }
+        this.coreNode.destroy();
+        this.parent = null;
+        this.texture = null;
+        this.emit('afterDestroy', {});
+        this.removeAllListeners();
+    }
+    flush() {
+        // No-op
+    }
+    animate(props, settings) {
+        const animation = new CoreAnimation(this.coreNode, props, settings);
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call
+        const controller = new CoreAnimationController(this.stage.animationManager, animation);
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return controller;
+    }
+}
+//# sourceMappingURL=MainOnlyNode.js.map