@lightningjs/renderer 3.0.0-beta1 → 3.0.0-beta10

package/dist/src/core/LngNode.js

@@ -1,1174 +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 { assertTruthy, getNewId, mergeColorAlphaPremultiplied, } from '../utils.js';
-import { EventEmitter } from '../common/EventEmitter.js';
-import { copyRect, intersectRect, createBound, boundInsideBound, } from './lib/utils.js';
-import { Matrix3d } from './lib/Matrix3d.js';
-import { RenderCoords } from './lib/RenderCoords.js';
-import { CoreAnimation } from './animations/CoreAnimation.js';
-import { CoreAnimationController } from './animations/CoreAnimationController.js';
-export var LngNodeRenderState;
-(function (LngNodeRenderState) {
-    LngNodeRenderState[LngNodeRenderState["Init"] = 0] = "Init";
-    LngNodeRenderState[LngNodeRenderState["OutOfBounds"] = 2] = "OutOfBounds";
-    LngNodeRenderState[LngNodeRenderState["InBounds"] = 4] = "InBounds";
-    LngNodeRenderState[LngNodeRenderState["InViewport"] = 8] = "InViewport";
-})(LngNodeRenderState || (LngNodeRenderState = {}));
-const LngNodeRenderStateMap = new Map();
-LngNodeRenderStateMap.set(LngNodeRenderState.Init, 'init');
-LngNodeRenderStateMap.set(LngNodeRenderState.OutOfBounds, 'outOfBounds');
-LngNodeRenderStateMap.set(LngNodeRenderState.InBounds, 'inBounds');
-LngNodeRenderStateMap.set(LngNodeRenderState.InViewport, 'inViewport');
-export var UpdateType;
-(function (UpdateType) {
-    /**
-     * Child updates
-     */
-    UpdateType[UpdateType["Children"] = 1] = "Children";
-    /**
-     * Scale/Rotate transform update
-     *
-     * @remarks
-     * LngNode Properties Updated:
-     * - `scaleRotateTransform`
-     */
-    UpdateType[UpdateType["ScaleRotate"] = 2] = "ScaleRotate";
-    /**
-     * Translate transform update (x/y/width/height/pivot/mount)
-     *
-     * @remarks
-     * LngNode Properties Updated:
-     * - `localTransform`
-     */
-    UpdateType[UpdateType["Local"] = 4] = "Local";
-    /**
-     * Global Transform update
-     *
-     * @remarks
-     * LngNode Properties Updated:
-     * - `globalTransform`
-     * - `renderCoords`
-     * - `renderBound`
-     */
-    UpdateType[UpdateType["Global"] = 8] = "Global";
-    /**
-     * Clipping rect update
-     *
-     * @remarks
-     * LngNode Properties Updated:
-     * - `clippingRect`
-     */
-    UpdateType[UpdateType["Clipping"] = 16] = "Clipping";
-    /**
-     * Calculated ZIndex update
-     *
-     * @remarks
-     * LngNode Properties Updated:
-     * - `calcZIndex`
-     */
-    UpdateType[UpdateType["CalculatedZIndex"] = 32] = "CalculatedZIndex";
-    /**
-     * Z-Index Sorted Children update
-     *
-     * @remarks
-     * LngNode Properties Updated:
-     * - `children` (sorts children by their `calcZIndex`)
-     */
-    UpdateType[UpdateType["ZIndexSortedChildren"] = 64] = "ZIndexSortedChildren";
-    /**
-     * Premultiplied Colors update
-     *
-     * @remarks
-     * LngNode Properties Updated:
-     * - `premultipliedColorTl`
-     * - `premultipliedColorTr`
-     * - `premultipliedColorBl`
-     * - `premultipliedColorBr`
-     */
-    UpdateType[UpdateType["PremultipliedColors"] = 128] = "PremultipliedColors";
-    /**
-     * World Alpha update
-     *
-     * @remarks
-     * LngNode Properties Updated:
-     * - `worldAlpha` = `parent.worldAlpha` * `alpha`
-     */
-    UpdateType[UpdateType["WorldAlpha"] = 256] = "WorldAlpha";
-    /**
-     * Render State update
-     *
-     * @remarks
-     * LngNode Properties Updated:
-     * - `renderState`
-     */
-    UpdateType[UpdateType["RenderState"] = 512] = "RenderState";
-    /**
-     * Is Renderable update
-     *
-     * @remarks
-     * LngNode Properties Updated:
-     * - `isRenderable`
-     */
-    UpdateType[UpdateType["IsRenderable"] = 1024] = "IsRenderable";
-    /**
-     * Render Texture update
-     */
-    UpdateType[UpdateType["RenderTexture"] = 2048] = "RenderTexture";
-    /**
-     * Track if parent has render texture
-     */
-    UpdateType[UpdateType["ParentRenderTexture"] = 4096] = "ParentRenderTexture";
-    /**
-     * None
-     */
-    UpdateType[UpdateType["None"] = 0] = "None";
-    /**
-     * All
-     */
-    UpdateType[UpdateType["All"] = 8191] = "All";
-})(UpdateType || (UpdateType = {}));
-/**
- * A visual Node in the Renderer scene graph.
- *
- * @remarks
- * A Node is a basic building block of the Renderer scene graph. It can be a
- * container for other Nodes, or it can be a leaf Node that renders a solid
- * color, gradient, image, or specific texture, using a specific shader.
- *
- * For text rendering, see {@link TextNode}.
- *
- * This is named `LngNode` because the browser already defines a `Node` class.
- */
-export class LngNode extends EventEmitter {
-    stage;
-    children = [];
-    _id = getNewId();
-    props;
-    updateType = UpdateType.All;
-    globalTransform;
-    scaleRotateTransform;
-    localTransform;
-    renderCoords;
-    renderBound;
-    strictBound;
-    preloadBound;
-    clippingRect = {
-        x: 0,
-        y: 0,
-        width: 0,
-        height: 0,
-        valid: false,
-    };
-    isRenderable = false;
-    renderState = LngNodeRenderState.Init;
-    worldAlpha = 1;
-    premultipliedColorTl = 0;
-    premultipliedColorTr = 0;
-    premultipliedColorBl = 0;
-    premultipliedColorBr = 0;
-    calcZIndex = 0;
-    hasRTTupdates = false;
-    parentHasRenderTexture = false;
-    _shader = null;
-    _src = '';
-    constructor(stage, props) {
-        super();
-        this.stage = stage;
-        this.props = {
-            ...props,
-            parent: null,
-            texture: null,
-            shader: null,
-            src: '',
-            rtt: false,
-            data: props.data || {},
-        };
-        // Assign props to instance
-        this.parent = props.parent;
-        this.shader = props.shader;
-        this.texture = props.texture;
-        this.src = props.src || '';
-        // FIXME
-        // this.data = props.data;
-        this.rtt = props.rtt;
-        this.updateScaleRotateTransform();
-    }
-    //#region Textures
-    loadTexture() {
-        const { texture } = this.props;
-        assertTruthy(texture);
-        // If texture is already loaded / failed, trigger loaded event manually
-        // so that users get a consistent event experience.
-        // We do this in a microtask to allow listeners to be attached in the same
-        // synchronous task after calling loadTexture()
-        queueMicrotask(() => {
-            // Preload texture if required
-            if (this.textureOptions.preload) {
-                this.stage.txManager.getCtxTexture(texture).load();
-            }
-            if (texture.state === 'loaded') {
-                this.onTextureLoaded(texture, texture.dimensions);
-            }
-            else if (texture.state === 'failed') {
-                this.onTextureFailed(texture, texture.error);
-            }
-            else if (texture.state === 'freed') {
-                this.onTextureFreed(texture);
-            }
-            texture.on('loaded', this.onTextureLoaded);
-            texture.on('failed', this.onTextureFailed);
-            texture.on('freed', this.onTextureFreed);
-        });
-    }
-    unloadTexture() {
-        if (this.texture) {
-            this.texture.off('loaded', this.onTextureLoaded);
-            this.texture.off('failed', this.onTextureFailed);
-            this.texture.off('freed', this.onTextureFreed);
-            this.texture.setRenderableOwner(this, false);
-        }
-    }
-    autosizeNode(dimensions) {
-        if (this.autosize) {
-            this.width = dimensions.width;
-            this.height = dimensions.height;
-        }
-    }
-    onTextureLoaded = (target, dimensions) => {
-        this.autosizeNode(dimensions);
-        // Texture was loaded. In case the RAF loop has already stopped, we request
-        // a render to ensure the texture is rendered.
-        this.stage.requestRender();
-        // If parent has a render texture, flag that we need to update
-        // @todo: Reserve type for RTT updates
-        if (this.parentHasRenderTexture) {
-            this.setRTTUpdates(1);
-        }
-        this.emit('loaded', {
-            type: 'texture',
-            dimensions,
-        });
-    };
-    onTextureFailed = (target, error) => {
-        this.emit('failed', {
-            type: 'texture',
-            error,
-        });
-    };
-    onTextureFreed = (target) => {
-        this.emit('freed', {
-            type: 'texture',
-        });
-    };
-    //#endregion Textures
-    loadShader(shaderType, props) {
-        const shManager = this.stage.renderer.getShaderManager();
-        assertTruthy(shManager);
-        const { shader, props: p } = shManager.loadShader(shaderType, props);
-        this._shader = shader;
-        this.props.shaderProps = p;
-        this.setUpdateType(UpdateType.IsRenderable);
-    }
-    /**
-     * Change types types is used to determine the scope of the changes being applied
-     *
-     * @remarks
-     * See {@link UpdateType} for more information on each type
-     *
-     * @param type
-     */
-    setUpdateType(type) {
-        this.updateType |= type;
-        // If we're updating this node at all, we need to inform the parent
-        // (and all ancestors) that their children need updating as well
-        const parent = this.props.parent;
-        if (parent && !(parent.updateType & UpdateType.Children)) {
-            parent.setUpdateType(UpdateType.Children);
-        }
-        // If node is part of RTT texture
-        // Flag that we need to update
-        if (this.parentHasRenderTexture) {
-            this.setRTTUpdates(type);
-        }
-    }
-    sortChildren() {
-        this.children.sort((a, b) => a.calcZIndex - b.calcZIndex);
-    }
-    updateScaleRotateTransform() {
-        this.scaleRotateTransform = Matrix3d.rotate(this.props.rotation, this.scaleRotateTransform).scale(this.props.scaleX, this.props.scaleY);
-    }
-    updateLocalTransform() {
-        assertTruthy(this.scaleRotateTransform);
-        const pivotTranslateX = this.props.pivotX * this.props.width;
-        const pivotTranslateY = this.props.pivotY * this.props.height;
-        const mountTranslateX = this.props.mountX * this.props.width;
-        const mountTranslateY = this.props.mountY * this.props.height;
-        this.localTransform = Matrix3d.translate(pivotTranslateX - mountTranslateX + this.props.x, pivotTranslateY - mountTranslateY + this.props.y, this.localTransform)
-            .multiply(this.scaleRotateTransform)
-            .translate(-pivotTranslateX, -pivotTranslateY);
-        this.setUpdateType(UpdateType.Global);
-    }
-    /**
-     * @todo: test for correct calculation flag
-     * @param delta
-     */
-    update(delta, parentClippingRect) {
-        if (this.updateType & UpdateType.ScaleRotate) {
-            this.updateScaleRotateTransform();
-            this.setUpdateType(UpdateType.Local);
-        }
-        if (this.updateType & UpdateType.Local) {
-            this.updateLocalTransform();
-            this.setUpdateType(UpdateType.Global);
-        }
-        const parent = this.props.parent;
-        let childUpdateType = UpdateType.None;
-        if (this.updateType & UpdateType.ParentRenderTexture) {
-            let p = this.parent;
-            while (p) {
-                if (p.rtt) {
-                    this.parentHasRenderTexture = true;
-                }
-                p = p.parent;
-            }
-        }
-        // If we have render texture updates and not already running a full update
-        if (this.updateType ^ UpdateType.All &&
-            this.updateType & UpdateType.RenderTexture) {
-            this.children.forEach((child) => {
-                child.setUpdateType(UpdateType.All);
-            });
-        }
-        if (this.updateType & UpdateType.Global) {
-            assertTruthy(this.localTransform);
-            this.globalTransform = Matrix3d.copy(parent?.globalTransform || this.localTransform, this.globalTransform);
-            if (this.parentHasRenderTexture && this.props.parent?.rtt) {
-                this.globalTransform = Matrix3d.identity();
-            }
-            if (parent) {
-                this.globalTransform.multiply(this.localTransform);
-            }
-            this.calculateRenderCoords();
-            this.updateBoundingRect();
-            this.setUpdateType(UpdateType.Clipping | UpdateType.RenderState | UpdateType.Children);
-            childUpdateType |= UpdateType.Global;
-        }
-        if (this.updateType & UpdateType.Clipping) {
-            this.calculateClippingRect(parentClippingRect);
-            this.setUpdateType(UpdateType.Children);
-            childUpdateType |= UpdateType.Clipping;
-        }
-        if (this.updateType & UpdateType.WorldAlpha) {
-            if (parent) {
-                this.worldAlpha = parent.worldAlpha * this.props.alpha;
-            }
-            else {
-                this.worldAlpha = this.props.alpha;
-            }
-            this.setUpdateType(UpdateType.Children |
-                UpdateType.PremultipliedColors |
-                UpdateType.IsRenderable);
-            childUpdateType |= UpdateType.WorldAlpha;
-        }
-        if (this.updateType & UpdateType.PremultipliedColors) {
-            this.premultipliedColorTl = mergeColorAlphaPremultiplied(this.props.colorTl, this.worldAlpha, true);
-            // If all the colors are the same just sent them all to the same value
-            if (this.props.colorTl === this.props.colorTr &&
-                this.props.colorBl === this.props.colorBr &&
-                this.props.colorTl === this.props.colorBl) {
-                this.premultipliedColorTr =
-                    this.premultipliedColorBl =
-                        this.premultipliedColorBr =
-                            this.premultipliedColorTl;
-            }
-            else {
-                this.premultipliedColorTr = mergeColorAlphaPremultiplied(this.props.colorTr, this.worldAlpha, true);
-                this.premultipliedColorBl = mergeColorAlphaPremultiplied(this.props.colorBl, this.worldAlpha, true);
-                this.premultipliedColorBr = mergeColorAlphaPremultiplied(this.props.colorBr, this.worldAlpha, true);
-            }
-        }
-        if (this.updateType & UpdateType.RenderState) {
-            this.updateRenderState(parentClippingRect);
-            this.setUpdateType(UpdateType.IsRenderable);
-        }
-        if (this.updateType & UpdateType.IsRenderable) {
-            this.updateIsRenderable();
-        }
-        // No need to update zIndex if there is no parent
-        if (parent && this.updateType & UpdateType.CalculatedZIndex) {
-            this.calculateZIndex();
-            // Tell parent to re-sort children
-            parent.setUpdateType(UpdateType.ZIndexSortedChildren);
-        }
-        if (this.updateType & UpdateType.Children &&
-            this.children.length &&
-            !this.rtt) {
-            this.children.forEach((child) => {
-                // Trigger the depenedent update types on the child
-                child.setUpdateType(childUpdateType);
-                // If child has no updates, skip
-                if (child.updateType === 0) {
-                    return;
-                }
-                child.update(delta, this.clippingRect);
-            });
-        }
-        // Sorting children MUST happen after children have been updated so
-        // that they have the oppotunity to update their calculated zIndex.
-        if (this.updateType & UpdateType.ZIndexSortedChildren) {
-            // reorder z-index
-            this.sortChildren();
-        }
-        // reset update type
-        this.updateType = 0;
-    }
-    //check if LngNode is renderable based on props
-    checkRenderProps() {
-        if (this.props.texture) {
-            return true;
-        }
-        if (!this.props.width || !this.props.height) {
-            return false;
-        }
-        if (this._shader) {
-            return true;
-        }
-        if (this.props.clipping) {
-            return true;
-        }
-        if (this.props.color !== 0) {
-            return true;
-        }
-        // Consider removing these checks and just using the color property check above.
-        // Maybe add a forceRender prop for nodes that should always render.
-        if (this.props.colorTop !== 0) {
-            return true;
-        }
-        if (this.props.colorBottom !== 0) {
-            return true;
-        }
-        if (this.props.colorLeft !== 0) {
-            return true;
-        }
-        if (this.props.colorRight !== 0) {
-            return true;
-        }
-        if (this.props.colorTl !== 0) {
-            return true;
-        }
-        if (this.props.colorTr !== 0) {
-            return true;
-        }
-        if (this.props.colorBl !== 0) {
-            return true;
-        }
-        if (this.props.colorBr !== 0) {
-            return true;
-        }
-        return false;
-    }
-    checkRenderBounds(parentClippingRect) {
-        assertTruthy(this.renderBound);
-        const rectW = parentClippingRect.width || this.stage.root.width;
-        const rectH = parentClippingRect.height || this.stage.root.height;
-        this.strictBound = createBound(parentClippingRect.x, parentClippingRect.y, parentClippingRect.x + rectW, parentClippingRect.y + rectH, this.strictBound);
-        const renderM = this.stage.boundsMargin;
-        this.preloadBound = createBound(parentClippingRect.x - renderM[3], parentClippingRect.y - renderM[0], parentClippingRect.x + rectW + renderM[1], parentClippingRect.y + rectH + renderM[2], this.preloadBound);
-        if (boundInsideBound(this.renderBound, this.strictBound)) {
-            return LngNodeRenderState.InViewport;
-        }
-        if (boundInsideBound(this.renderBound, this.preloadBound)) {
-            return LngNodeRenderState.InBounds;
-        }
-        return LngNodeRenderState.OutOfBounds;
-    }
-    updateRenderState(parentClippingRect) {
-        const renderState = this.checkRenderBounds(parentClippingRect);
-        if (renderState !== this.renderState) {
-            let previous = this.renderState;
-            this.renderState = renderState;
-            if (previous === LngNodeRenderState.InViewport) {
-                this.emit('outOfViewport', {
-                    previous,
-                    current: renderState,
-                });
-            }
-            if (previous < LngNodeRenderState.InBounds &&
-                renderState === LngNodeRenderState.InViewport) {
-                this.emit(LngNodeRenderStateMap.get(LngNodeRenderState.InBounds), {
-                    previous,
-                    current: renderState,
-                });
-                previous = LngNodeRenderState.InBounds;
-            }
-            else if (previous > LngNodeRenderState.InBounds &&
-                renderState === LngNodeRenderState.OutOfBounds) {
-                this.emit(LngNodeRenderStateMap.get(LngNodeRenderState.InBounds), {
-                    previous,
-                    current: renderState,
-                });
-                previous = LngNodeRenderState.InBounds;
-            }
-            const event = LngNodeRenderStateMap.get(renderState);
-            assertTruthy(event);
-            this.emit(event, {
-                previous,
-                current: renderState,
-            });
-        }
-    }
-    setRenderState(state) {
-        if (state !== this.renderState) {
-            this.renderState = state;
-            this.emit(LngNodeRenderState[state]);
-        }
-    }
-    /**
-     * This function updates the `isRenderable` property based on certain conditions.
-     *
-     * @returns
-     */
-    updateIsRenderable() {
-        let newIsRenderable;
-        if (this.worldAlpha === 0 || !this.checkRenderProps()) {
-            newIsRenderable = false;
-        }
-        else {
-            newIsRenderable = this.renderState > LngNodeRenderState.OutOfBounds;
-        }
-        if (this.isRenderable !== newIsRenderable) {
-            this.isRenderable = newIsRenderable;
-            this.onChangeIsRenderable(newIsRenderable);
-        }
-    }
-    onChangeIsRenderable(isRenderable) {
-        this.texture?.setRenderableOwner(this, isRenderable);
-    }
-    calculateRenderCoords() {
-        const { width, height, globalTransform: transform } = this;
-        assertTruthy(transform);
-        const { tx, ty, ta, tb, tc, td } = transform;
-        if (tb === 0 && tc === 0) {
-            const minX = tx;
-            const maxX = tx + width * ta;
-            const minY = ty;
-            const maxY = ty + height * td;
-            this.renderCoords = RenderCoords.translate(
-            //top-left
-            minX, minY, 
-            //top-right
-            maxX, minY, 
-            //bottom-right
-            maxX, maxY, 
-            //bottom-left
-            minX, maxY, this.renderCoords);
-        }
-        else {
-            this.renderCoords = RenderCoords.translate(
-            //top-left
-            tx, ty, 
-            //top-right
-            tx + width * ta, ty + width * tc, 
-            //bottom-right
-            tx + width * ta + height * tb, ty + width * tc + height * td, 
-            //bottom-left
-            tx + height * tb, ty + height * td, this.renderCoords);
-        }
-    }
-    updateBoundingRect() {
-        const { renderCoords, globalTransform: transform } = this;
-        assertTruthy(transform);
-        assertTruthy(renderCoords);
-        const { tb, tc } = transform;
-        const { x1, y1, x3, y3 } = renderCoords;
-        if (tb === 0 || tc === 0) {
-            this.renderBound = createBound(x1, y1, x3, y3, this.renderBound);
-        }
-        else {
-            const { x2, x4, y2, y4 } = renderCoords;
-            this.renderBound = createBound(Math.min(x1, x2, x3, x4), Math.min(y1, y2, y3, y4), Math.max(x1, x2, x3, x4), Math.max(y1, y2, y3, y4), this.renderBound);
-        }
-    }
-    /**
-     * This function calculates the clipping rectangle for a node.
-     *
-     * The function then checks if the node is rotated. If the node requires clipping and is not rotated, a new clipping rectangle is created based on the node's global transform and dimensions.
-     * If a parent clipping rectangle exists, it is intersected with the node's clipping rectangle (if it exists), or replaces the node's clipping rectangle.
-     *
-     * Finally, the node's parentClippingRect and clippingRect properties are updated.
-     */
-    calculateClippingRect(parentClippingRect) {
-        assertTruthy(this.globalTransform);
-        const { clippingRect, props, globalTransform: gt } = this;
-        const { clipping } = props;
-        const isRotated = gt.tb !== 0 || gt.tc !== 0;
-        if (clipping && !isRotated) {
-            clippingRect.x = gt.tx;
-            clippingRect.y = gt.ty;
-            clippingRect.width = this.width * gt.ta;
-            clippingRect.height = this.height * gt.td;
-            clippingRect.valid = true;
-        }
-        else {
-            clippingRect.valid = false;
-        }
-        if (parentClippingRect.valid && clippingRect.valid) {
-            // Intersect parent clipping rect with node clipping rect
-            intersectRect(parentClippingRect, clippingRect, clippingRect);
-        }
-        else if (parentClippingRect.valid) {
-            // Copy parent clipping rect
-            copyRect(parentClippingRect, clippingRect);
-            clippingRect.valid = true;
-        }
-    }
-    calculateZIndex() {
-        const props = this.props;
-        const z = props.zIndex || 0;
-        const p = props.parent?.zIndex || 0;
-        let zIndex = z;
-        if (props.parent?.zIndexLocked) {
-            zIndex = z < p ? z : p;
-        }
-        this.calcZIndex = zIndex;
-    }
-    /**
-     * Destroy the node and cleanup all resources
-     */
-    destroy() {
-        this.unloadTexture();
-        this.clippingRect.valid = false;
-        this.isRenderable = false;
-        delete this.renderCoords;
-        delete this.renderBound;
-        delete this.strictBound;
-        delete this.preloadBound;
-        delete this.globalTransform;
-        delete this.scaleRotateTransform;
-        delete this.localTransform;
-        this.props.texture = null;
-        this.props.shader = null;
-        this.props.shaderProps = null;
-        this._shader = null;
-        if (this.rtt) {
-            this.stage.renderer.removeRTTNode(this);
-        }
-        this.removeAllListeners();
-        this.parent = null;
-    }
-    renderQuads(renderer) {
-        const { texture, width, height, textureOptions, shaderProps, rtt } = this.props;
-        const shader = this._shader;
-        // Prevent quad rendering if parent has a render texture
-        // and renderer is not currently rendering to a texture
-        if (this.parentHasRenderTexture) {
-            if (!renderer.renderToTextureActive) {
-                return;
-            }
-            // Prevent quad rendering if parent render texture is not the active render texture
-            if (this.parentRenderTexture !== renderer.activeRttNode) {
-                return;
-            }
-        }
-        const { premultipliedColorTl, premultipliedColorTr, premultipliedColorBl, premultipliedColorBr, } = this;
-        const { zIndex, worldAlpha, globalTransform: gt, clippingRect } = this;
-        assertTruthy(gt);
-        // add to list of renderables to be sorted before rendering
-        renderer.addQuad({
-            width,
-            height,
-            colorTl: premultipliedColorTl,
-            colorTr: premultipliedColorTr,
-            colorBl: premultipliedColorBl,
-            colorBr: premultipliedColorBr,
-            texture,
-            textureOptions,
-            zIndex,
-            shader,
-            shaderProps,
-            alpha: worldAlpha,
-            clippingRect,
-            tx: gt.tx,
-            ty: gt.ty,
-            ta: gt.ta,
-            tb: gt.tb,
-            tc: gt.tc,
-            td: gt.td,
-            rtt,
-            parentHasRenderTexture: this.parentHasRenderTexture,
-            framebufferDimensions: this.framebufferDimensions,
-        });
-    }
-    //#region Properties
-    get id() {
-        return this._id;
-    }
-    get x() {
-        return this.props.x;
-    }
-    set x(value) {
-        if (this.props.x !== value) {
-            this.props.x = value;
-            this.setUpdateType(UpdateType.Local);
-        }
-    }
-    get absX() {
-        return (this.props.x +
-            (this.props.parent?.absX || this.props.parent?.globalTransform?.tx || 0));
-    }
-    get absY() {
-        return this.props.y + (this.props.parent?.absY ?? 0);
-    }
-    get y() {
-        return this.props.y;
-    }
-    set y(value) {
-        if (this.props.y !== value) {
-            this.props.y = value;
-            this.setUpdateType(UpdateType.Local);
-        }
-    }
-    get width() {
-        return this.props.width;
-    }
-    set width(value) {
-        if (this.props.width !== value) {
-            this.props.width = value;
-            this.setUpdateType(UpdateType.Local);
-            if (this.props.rtt) {
-                this.texture = this.stage.txManager.loadTexture('RenderTexture', {
-                    width: this.width,
-                    height: this.height,
-                });
-                this.textureOptions = { preload: true };
-                this.setUpdateType(UpdateType.RenderTexture);
-            }
-        }
-    }
-    get height() {
-        return this.props.height;
-    }
-    set height(value) {
-        if (this.props.height !== value) {
-            this.props.height = value;
-            this.setUpdateType(UpdateType.Local);
-            if (this.props.rtt) {
-                this.texture = this.stage.txManager.loadTexture('RenderTexture', {
-                    width: this.width,
-                    height: this.height,
-                });
-                this.textureOptions = { preload: true };
-                this.setUpdateType(UpdateType.RenderTexture);
-            }
-        }
-    }
-    get scale() {
-        // The LngNode `scale` property is only used by Animations.
-        // Unlike INode, `null` should never be possibility for Animations.
-        return this.scaleX;
-    }
-    set scale(value) {
-        // The LngNode `scale` property is only used by Animations.
-        // Unlike INode, `null` should never be possibility for Animations.
-        this.scaleX = value;
-        this.scaleY = value;
-    }
-    get scaleX() {
-        return this.props.scaleX;
-    }
-    set scaleX(value) {
-        if (this.props.scaleX !== value) {
-            this.props.scaleX = value;
-            this.setUpdateType(UpdateType.ScaleRotate);
-        }
-    }
-    get scaleY() {
-        return this.props.scaleY;
-    }
-    set scaleY(value) {
-        if (this.props.scaleY !== value) {
-            this.props.scaleY = value;
-            this.setUpdateType(UpdateType.ScaleRotate);
-        }
-    }
-    get mount() {
-        return this.props.mount;
-    }
-    set mount(value) {
-        if (this.props.mountX !== value || this.props.mountY !== value) {
-            this.props.mountX = value;
-            this.props.mountY = value;
-            this.props.mount = value;
-            this.setUpdateType(UpdateType.Local);
-        }
-    }
-    get mountX() {
-        return this.props.mountX;
-    }
-    set mountX(value) {
-        if (this.props.mountX !== value) {
-            this.props.mountX = value;
-            this.setUpdateType(UpdateType.Local);
-        }
-    }
-    get mountY() {
-        return this.props.mountY;
-    }
-    set mountY(value) {
-        if (this.props.mountY !== value) {
-            this.props.mountY = value;
-            this.setUpdateType(UpdateType.Local);
-        }
-    }
-    get pivot() {
-        return this.props.pivot;
-    }
-    set pivot(value) {
-        if (this.props.pivotX !== value || this.props.pivotY !== value) {
-            this.props.pivotX = value;
-            this.props.pivotY = value;
-            this.props.pivot = value;
-            this.setUpdateType(UpdateType.Local);
-        }
-    }
-    get pivotX() {
-        return this.props.pivotX;
-    }
-    set pivotX(value) {
-        if (this.props.pivotX !== value) {
-            this.props.pivotX = value;
-            this.setUpdateType(UpdateType.Local);
-        }
-    }
-    get pivotY() {
-        return this.props.pivotY;
-    }
-    set pivotY(value) {
-        if (this.props.pivotY !== value) {
-            this.props.pivotY = value;
-            this.setUpdateType(UpdateType.Local);
-        }
-    }
-    get rotation() {
-        return this.props.rotation;
-    }
-    set rotation(value) {
-        if (this.props.rotation !== value) {
-            this.props.rotation = value;
-            this.setUpdateType(UpdateType.ScaleRotate);
-        }
-    }
-    get alpha() {
-        return this.props.alpha;
-    }
-    set alpha(value) {
-        this.props.alpha = value;
-        this.setUpdateType(UpdateType.PremultipliedColors | UpdateType.WorldAlpha);
-    }
-    get autosize() {
-        return this.props.autosize;
-    }
-    set autosize(value) {
-        this.props.autosize = value;
-    }
-    get clipping() {
-        return this.props.clipping;
-    }
-    set clipping(value) {
-        this.props.clipping = value;
-        this.setUpdateType(UpdateType.Clipping);
-    }
-    get color() {
-        return this.props.color;
-    }
-    set color(value) {
-        if (this.props.colorTl !== value ||
-            this.props.colorTr !== value ||
-            this.props.colorBl !== value ||
-            this.props.colorBr !== value) {
-            this.colorTl = value;
-            this.colorTr = value;
-            this.colorBl = value;
-            this.colorBr = value;
-        }
-        this.props.color = value;
-        this.setUpdateType(UpdateType.PremultipliedColors);
-    }
-    get colorTop() {
-        return this.props.colorTop;
-    }
-    set colorTop(value) {
-        if (this.props.colorTl !== value || this.props.colorTr !== value) {
-            this.colorTl = value;
-            this.colorTr = value;
-        }
-        this.props.colorTop = value;
-        this.setUpdateType(UpdateType.PremultipliedColors);
-    }
-    get colorBottom() {
-        return this.props.colorBottom;
-    }
-    set colorBottom(value) {
-        if (this.props.colorBl !== value || this.props.colorBr !== value) {
-            this.colorBl = value;
-            this.colorBr = value;
-        }
-        this.props.colorBottom = value;
-        this.setUpdateType(UpdateType.PremultipliedColors);
-    }
-    get colorLeft() {
-        return this.props.colorLeft;
-    }
-    set colorLeft(value) {
-        if (this.props.colorTl !== value || this.props.colorBl !== value) {
-            this.colorTl = value;
-            this.colorBl = value;
-        }
-        this.props.colorLeft = value;
-        this.setUpdateType(UpdateType.PremultipliedColors);
-    }
-    get colorRight() {
-        return this.props.colorRight;
-    }
-    set colorRight(value) {
-        if (this.props.colorTr !== value || this.props.colorBr !== value) {
-            this.colorTr = value;
-            this.colorBr = value;
-        }
-        this.props.colorRight = value;
-        this.setUpdateType(UpdateType.PremultipliedColors);
-    }
-    get colorTl() {
-        return this.props.colorTl;
-    }
-    set colorTl(value) {
-        this.props.colorTl = value;
-        this.setUpdateType(UpdateType.PremultipliedColors);
-    }
-    get colorTr() {
-        return this.props.colorTr;
-    }
-    set colorTr(value) {
-        this.props.colorTr = value;
-        this.setUpdateType(UpdateType.PremultipliedColors);
-    }
-    get colorBl() {
-        return this.props.colorBl;
-    }
-    set colorBl(value) {
-        this.props.colorBl = value;
-        this.setUpdateType(UpdateType.PremultipliedColors);
-    }
-    get colorBr() {
-        return this.props.colorBr;
-    }
-    set colorBr(value) {
-        this.props.colorBr = value;
-        this.setUpdateType(UpdateType.PremultipliedColors);
-    }
-    // we're only interested in parent zIndex to test
-    // if we should use node zIndex is higher then parent zIndex
-    get zIndexLocked() {
-        return this.props.zIndexLocked || 0;
-    }
-    set zIndexLocked(value) {
-        this.props.zIndexLocked = value;
-        this.setUpdateType(UpdateType.CalculatedZIndex | UpdateType.Children);
-        this.children.forEach((child) => {
-            child.setUpdateType(UpdateType.CalculatedZIndex);
-        });
-    }
-    get zIndex() {
-        return this.props.zIndex;
-    }
-    set zIndex(value) {
-        this.props.zIndex = value;
-        this.setUpdateType(UpdateType.CalculatedZIndex | UpdateType.Children);
-        this.children.forEach((child) => {
-            child.setUpdateType(UpdateType.CalculatedZIndex);
-        });
-    }
-    get parent() {
-        return this.props.parent;
-    }
-    set parent(newParent) {
-        const oldParent = this.props.parent;
-        if (oldParent === newParent) {
-            return;
-        }
-        this.props.parent = newParent;
-        if (oldParent) {
-            const index = oldParent.children.indexOf(this);
-            assertTruthy(index !== -1, "LngNode.parent: Node not found in old parent's children!");
-            oldParent.children.splice(index, 1);
-            oldParent.setUpdateType(UpdateType.Children | UpdateType.ZIndexSortedChildren);
-        }
-        if (newParent) {
-            newParent.children.push(this);
-            // Since this node has a new parent, to be safe, have it do a full update.
-            this.setUpdateType(UpdateType.All);
-            // Tell parent that it's children need to be updated and sorted.
-            newParent.setUpdateType(UpdateType.Children | UpdateType.ZIndexSortedChildren);
-            if (newParent.rtt || newParent.parentHasRenderTexture) {
-                this.setRTTUpdates(UpdateType.All);
-            }
-        }
-        this.updateScaleRotateTransform();
-    }
-    get rtt() {
-        return this.props.rtt;
-    }
-    set rtt(value) {
-        if (this.props.rtt === true) {
-            this.props.rtt = value;
-            // unload texture if we used to have a render texture
-            if (value === false && this.texture !== null) {
-                this.unloadTexture();
-                this.setUpdateType(UpdateType.All);
-                this.children.forEach((child) => {
-                    child.parentHasRenderTexture = false;
-                });
-                this.stage.renderer?.removeRTTNode(this);
-                return;
-            }
-        }
-        // if the new value is false and we didnt have rtt previously, we don't need to do anything
-        if (value === false) {
-            return;
-        }
-        // load texture
-        this.texture = this.stage.txManager.loadTexture('RenderTexture', {
-            width: this.width,
-            height: this.height,
-        });
-        this.textureOptions = { preload: true };
-        this.props.rtt = true;
-        this.hasRTTupdates = true;
-        this.setUpdateType(UpdateType.All);
-        this.children.forEach((child) => {
-            child.setUpdateType(UpdateType.All);
-        });
-        // Store RTT nodes in a separate list
-        this.stage.renderer?.renderToTexture(this);
-    }
-    get shader() {
-        return this.props.shader;
-    }
-    set shader(value) {
-        if (value === null && this._shader === null) {
-            return;
-        }
-        if (value === null) {
-            this._shader = null;
-            this.props.shader = null;
-            this.setUpdateType(UpdateType.IsRenderable);
-            return;
-        }
-        this.props.shader = value;
-        assertTruthy(value);
-        this.loadShader(value.shType, value.props);
-    }
-    get shaderProps() {
-        return this.props.shaderProps;
-    }
-    set shaderProps(value) {
-        this.props.shaderProps = 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.stage.txManager.loadTexture('ImageTexture', {
-            src: imageUrl,
-        });
-    }
-    /**
-     * Returns the framebuffer dimensions of the node.
-     * If the node has a render texture, the dimensions are the same as the node's dimensions.
-     * If the node does not have a render texture, the dimensions are inherited from the parent.
-     * If the node parent has a render texture and the node is a render texture, the nodes dimensions are used.
-     */
-    get framebufferDimensions() {
-        if (this.parentHasRenderTexture && !this.rtt && this.parent) {
-            return this.parent.framebufferDimensions;
-        }
-        return { width: this.width, height: this.height };
-    }
-    /**
-     * Returns the parent render texture node if it exists.
-     */
-    get parentRenderTexture() {
-        let parent = this.parent;
-        while (parent) {
-            if (parent.rtt) {
-                return parent;
-            }
-            parent = parent.parent;
-        }
-        return null;
-    }
-    get texture() {
-        return this.props.texture;
-    }
-    set texture(value) {
-        if (this.props.texture === value) {
-            return;
-        }
-        const oldTexture = this.props.texture;
-        if (oldTexture) {
-            oldTexture.setRenderableOwner(this, false);
-            this.unloadTexture();
-        }
-        this.props.texture = value;
-        if (value) {
-            value.setRenderableOwner(this, this.isRenderable);
-            this.loadTexture();
-        }
-        this.setUpdateType(UpdateType.IsRenderable);
-    }
-    set textureOptions(value) {
-        this.props.textureOptions = value;
-    }
-    get textureOptions() {
-        return this.props.textureOptions;
-    }
-    setRTTUpdates(type) {
-        this.hasRTTupdates = true;
-        this.parent?.setRTTUpdates(type);
-    }
-    animate(props, settings) {
-        const animation = new CoreAnimation(this, 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;
-    }
-    flush() {
-        // no-op
-    }
-}
-//# sourceMappingURL=LngNode.js.map