@lightningjs/renderer 3.0.0-beta8 → 3.0.0

package/dist/src/core/CoreNode.d.ts

@@ -1,7 +1,10 @@
 import type { TextureOptions } from './CoreTextureManager.js';
+import type { WebGlRenderer } from './renderers/webgl/WebGlRenderer.js';
+import type { WebGlCtxTexture } from './renderers/webgl/WebGlCtxTexture.js';
+import type { BufferCollection } from './renderers/webgl/internal/BufferCollection.js';
 import type { CoreRenderer } from './renderers/CoreRenderer.js';
 import type { Stage } from './Stage.js';
-import { type Texture, type TextureCoords } from './textures/Texture.js';
+import { type Texture, type TextureCoords, type TextureLoadedEventHandler } from './textures/Texture.js';
 import type { Dimensions } from '../common/CommonTypes.js';
 import { EventEmitter } from '../common/EventEmitter.js';
 import { type Bound, type RectWithValid } from './lib/utils.js';
@@ -10,6 +13,7 @@ import { RenderCoords } from './lib/RenderCoords.js';
 import type { AnimationSettings } from './animations/CoreAnimation.js';
 import type { IAnimationController } from '../common/IAnimationController.js';
 import type { CoreShaderNode } from './renderers/CoreShaderNode.js';
+import { Autosizer } from './Autosizer.js';
 export declare enum CoreNodeRenderState {
     Init = 0,
     OutOfBounds = 2,
@@ -48,21 +52,13 @@ export declare enum UpdateType {
      */
     Clipping = 8,
     /**
-     * Calculated ZIndex update
-     *
-     * @remarks
-     * CoreNode Properties Updated:
-     * - `calcZIndex`
-     */
-    CalculatedZIndex = 16,
-    /**
-     * Z-Index Sorted Children update
+     * Sort Z-Index Children update
      *
      * @remarks
      * CoreNode Properties Updated:
      * - `children` (sorts children by their `calcZIndex`)
      */
-    ZIndexSortedChildren = 32,
+    SortZIndexChildren = 16,
     /**
      * Premultiplied Colors update
      *
@@ -73,7 +69,7 @@ export declare enum UpdateType {
      * - `premultipliedColorBl`
      * - `premultipliedColorBr`
      */
-    PremultipliedColors = 64,
+    PremultipliedColors = 32,
     /**
      * World Alpha update
      *
@@ -81,7 +77,7 @@ export declare enum UpdateType {
      * CoreNode Properties Updated:
      * - `worldAlpha` = `parent.worldAlpha` * `alpha`
      */
-    WorldAlpha = 128,
+    WorldAlpha = 64,
     /**
      * Render State update
      *
@@ -89,7 +85,7 @@ export declare enum UpdateType {
      * CoreNode Properties Updated:
      * - `renderState`
      */
-    RenderState = 256,
+    RenderState = 128,
     /**
      * Is Renderable update
      *
@@ -97,23 +93,27 @@ export declare enum UpdateType {
      * CoreNode Properties Updated:
      * - `isRenderable`
      */
-    IsRenderable = 512,
+    IsRenderable = 256,
     /**
      * Render Texture update
      */
-    RenderTexture = 1024,
+    RenderTexture = 512,
     /**
      * Track if parent has render texture
      */
-    ParentRenderTexture = 2048,
+    ParentRenderTexture = 1024,
     /**
      * Render Bounds update
      */
-    RenderBounds = 4096,
+    RenderBounds = 2048,
     /**
      * RecalcUniforms
      */
-    RecalcUniforms = 8192,
+    RecalcUniforms = 4096,
+    /**
+     * Autosize update
+     */
+    Autosize = 8192,
     /**
      * None
      */
@@ -160,16 +160,18 @@ export interface CoreNodeProps {
     y: number;
     /**
      * The width of the Node.
+     * @warning This will be deprecated in favor of `w` and `h` properties in the future.
      *
      * @default `0`
      */
-    width: number;
+    w: number;
     /**
      * The height of the Node.
+     * @warning This will be deprecated in favor of `w` and `h` properties in the future.
      *
      * @default `0`
      */
-    height: number;
+    h: number;
     /**
      * The alpha opacity of the Node.
      *
@@ -181,14 +183,35 @@ export interface CoreNodeProps {
      */
     alpha: number;
     /**
-     * Autosize mode
+     * Autosize
      *
      * @remarks
-     * When enabled, when a texture is loaded into the Node, the Node will
-     * automatically resize to the dimensions of the texture.
+     * When enabled, the Node automatically resizes based on its content
+     *
+     * **Texture Autosize Mode:**
+     * - When the Node has a texture, it automatically resizes to match the
+     *   texture's dimensions when the texture loads
+     * - This ensures images display at their natural size without manual sizing
+     * - Text Nodes always use this mode regardless of this setting
+     *
+     * **Children Autosize Mode:**
+     * - When the Node has no texture but contains children, it automatically
+     *   resizes to encompass all children's bounds
+     * - Calculates the bounding box that contains all child positions, dimensions,
+     *   and transforms (scale, rotation, mount/pivot points)
+     * - Creates container behavior where the parent grows to fit its content
+     * - Updates dynamically as children are added, removed, or transformed
+     *
+     * **Mode Selection Logic:**
+     * - Texture mode takes precedence over children mode
+     * - Mode switches automatically when texture is added/removed
+     * - If no texture and no children, autosize has no effect
+     *
+     * **Performance:**
+     * - Children mode uses efficient transform caching and differential updates
+     * - Only recalculates when child transforms actually change
+     * - Minimal memory allocation with factory function patterns
      *
-     * Text Nodes are always autosized based on their text content regardless
-     * of this mode setting.
      *
      * @default `false`
      */
@@ -316,7 +339,11 @@ export interface CoreNodeProps {
      * The Node's z-index.
      *
      * @remarks
-     * TBD
+     * Max z-index of children under the same parent determines which child
+     * is rendered on top. Higher z-index means the Node is rendered on top of
+     * children with lower z-index.
+     *
+     * Max value is 1000 and min value is -1000. Values outside of this range will be clamped.
      */
     zIndex: number;
     /**
@@ -371,7 +398,6 @@ export interface CoreNodeProps {
      * settings being defaults)
      */
     src: string | null;
-    zIndexLocked: number;
     /**
      * Scale to render the Node at
      *
@@ -593,21 +619,6 @@ export interface CoreNodeProps {
      * @default false
      */
     interactive?: boolean;
-    /**
-     * By enabling Strict bounds the renderer will not process & render child nodes of a node that is out of the visible area
-     *
-     * @remarks
-     * When enabled out of bound nodes, i.e. nodes that are out of the visible area, will
-     * **NOT** have their children processed and renderer anymore. This means the children of a out of bound
-     * node will not receive update processing such as positioning updates and will not be drawn on screen.
-     * As such the rest of the branch of the update tree that sits below this node will not be processed anymore
-     *
-     * This is a big performance gain but may be disabled in cases where the width of the parent node is
-     * unknown and the render must process the child nodes regardless of the viewport status of the parent node
-     *
-     * @default true
-     */
-    strictBounds: boolean;
 }
 /**
  * Grab all the number properties of type T
@@ -637,8 +648,16 @@ export declare class CoreNode extends EventEmitter {
     readonly children: CoreNode[];
     protected _id: number;
     readonly props: CoreNodeProps;
+    readonly isCoreNode: true;
+    renderOpBufferIdx: number;
+    numQuads: number;
+    renderOpTextures: WebGlCtxTexture[];
     private hasShaderUpdater;
+    hasShaderTimeFn: boolean;
     private hasColorProps;
+    private zIndexMin;
+    private zIndexMax;
+    previousZIndex: number;
     updateType: UpdateType;
     childUpdateType: UpdateType;
     globalTransform?: Matrix3d;
@@ -651,7 +670,7 @@ export declare class CoreNode extends EventEmitter {
     preloadBound?: Bound;
     clippingRect: RectWithValid;
     textureCoords?: TextureCoords;
-    updateTextureCoords?: boolean;
+    updateShaderUniforms: boolean;
     isRenderable: boolean;
     renderState: CoreNodeRenderState;
     worldAlpha: number;
@@ -667,12 +686,21 @@ export declare class CoreNode extends EventEmitter {
      * only used when rtt = true
      */
     framebufferDimensions: Dimensions | null;
+    /**Autosize properties */
+    autosizer: Autosizer | null;
+    parentAutosizer: Autosizer | null;
     destroyed: boolean;
     constructor(stage: Stage, props: CoreNodeProps);
     loadTexture(): void;
+    /**
+     * Task for queueMicrotask to loadTexture
+     *
+     * @remarks
+     * This method is called in a microtask to release the texture.
+     */
+    private loadTextureTask;
     unloadTexture(): void;
-    autosizeNode(dimensions: Dimensions): void;
-    private onTextureLoaded;
+    protected onTextureLoaded: TextureLoadedEventHandler;
     private onTextureFailed;
     private onTextureFreed;
     /**
@@ -684,7 +712,6 @@ export declare class CoreNode extends EventEmitter {
      * @param type
      */
     setUpdateType(type: UpdateType): void;
-    sortChildren(): void;
     updateLocalTransform(): void;
     /**
      * @todo: test for correct calculation flag
@@ -693,11 +720,15 @@ export declare class CoreNode extends EventEmitter {
     update(delta: number, parentClippingRect: RectWithValid): void;
     private findParentRTTNode;
     private notifyChildrenRTTOfUpdate;
-    private notifyParentRTTOfUpdate;
+    protected notifyParentRTTOfUpdate(): void;
     checkRenderBounds(): CoreNodeRenderState;
     updateBoundingRect(): void;
     createRenderBounds(): void;
     updateRenderState(renderState: CoreNodeRenderState): void;
+    /**
+     * Checks if the node is renderable based on world alpha, dimensions and out of bounds status.
+     */
+    checkBasicRenderability(): boolean;
     /**
      * Updates the `isRenderable` property based on various conditions.
      */
@@ -711,6 +742,14 @@ export declare class CoreNode extends EventEmitter {
      * Changes the renderable state of the node.
      */
     updateTextureOwnership(isRenderable: boolean): void;
+    /**
+     * Checks if the node is out of the viewport bounds.
+     */
+    isOutOfBounds(): boolean;
+    /**
+     * Checks if the node has dimensions (width/height)
+     */
+    hasDimensions(): boolean;
     calculateRenderCoords(): void;
     /**
      * This function calculates the clipping rectangle for a node.
@@ -721,12 +760,17 @@ export declare class CoreNode extends EventEmitter {
      * Finally, the node's parentClippingRect and clippingRect properties are updated.
      */
     calculateClippingRect(parentClippingRect: RectWithValid): void;
-    calculateZIndex(): void;
     /**
      * Destroy the node and cleanup all resources
      */
     destroy(): void;
     renderQuads(renderer: CoreRenderer): void;
+    get quadBufferCollection(): BufferCollection;
+    get time(): number;
+    getTimerValue(): number;
+    sortChildren(): void;
+    removeChild(node: CoreNode, targetParent?: CoreNode | null): void;
+    addChild(node: CoreNode, previousParent?: CoreNode | null): void;
     get id(): number;
     get data(): CustomDataMap | undefined;
     set data(d: CustomDataMap | undefined);
@@ -736,10 +780,10 @@ export declare class CoreNode extends EventEmitter {
     get absY(): number;
     get y(): number;
     set y(value: number);
-    get width(): number;
-    set width(value: number);
-    get height(): number;
-    set height(value: number);
+    get w(): number;
+    set w(value: number);
+    get h(): number;
+    set h(value: number);
     get scale(): number;
     set scale(value: number);
     get scaleX(): number;
@@ -786,8 +830,6 @@ export declare class CoreNode extends EventEmitter {
     set colorBl(value: number);
     get colorBr(): number;
     set colorBr(value: number);
-    get zIndexLocked(): number;
-    set zIndexLocked(value: number);
     get zIndex(): number;
     set zIndex(value: number);
     get parent(): CoreNode | null;
@@ -816,7 +858,7 @@ export declare class CoreNode extends EventEmitter {
     /**
      * Returns the framebuffer dimensions of the RTT parent
      */
-    get parentFramebufferDimensions(): Dimensions;
+    get parentFramebufferDimensions(): Dimensions | null;
     /**
      * Returns the parent render texture node if it exists.
      */
@@ -828,9 +870,15 @@ export declare class CoreNode extends EventEmitter {
     set interactive(value: boolean | undefined);
     get interactive(): boolean | undefined;
     setRTTUpdates(type: number): void;
-    get strictBounds(): boolean;
-    set strictBounds(v: boolean);
     animate(props: Partial<CoreNodeAnimateProps>, settings: Partial<AnimationSettings>): IAnimationController;
     flush(): void;
+    /**
+     * Add a texture to the current RenderOp.
+     *
+     * @param texture
+     * @returns Assigned Texture Index of the texture in the render op
+     */
+    addTexture(texture: WebGlCtxTexture): number;
+    draw(renderer: WebGlRenderer): void;
 }
 export {};