@lightningjs/renderer 2.12.1 → 3.0.0-beta1

package/dist/exports/canvas-shaders.d.ts

@@ -0,0 +1,10 @@
+export * from '../src/core/renderers/canvas/CanvasShaderNode.js';
+export { Rounded } from '../src/core/shaders/canvas/Rounded.js';
+export { RoundedWithBorder } from '../src/core/shaders/canvas/RoundedWithBorder.js';
+export { RoundedWithBorderAndShadow } from '../src/core/shaders/canvas/RoundedWithBorderAndShadow.js';
+export { RoundedWithShadow } from '../src/core/shaders/canvas/RoundedWithShadow.js';
+export { Border } from '../src/core/shaders/canvas/Border.js';
+export { Shadow } from '../src/core/shaders/canvas/Shadow.js';
+export { HolePunch } from '../src/core/shaders/canvas/HolePunch.js';
+export { LinearGradient } from '../src/core/shaders/canvas/LinearGradient.js';
+export { RadialGradient } from '../src/core/shaders/canvas/RadialGradient.js';

package/dist/exports/canvas-shaders.js

@@ -0,0 +1,27 @@
+/*
+ * 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.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export * from '../src/core/renderers/canvas/CanvasShaderNode.js';
+export { Rounded } from '../src/core/shaders/canvas/Rounded.js';
+export { RoundedWithBorder } from '../src/core/shaders/canvas/RoundedWithBorder.js';
+export { RoundedWithBorderAndShadow } from '../src/core/shaders/canvas/RoundedWithBorderAndShadow.js';
+export { RoundedWithShadow } from '../src/core/shaders/canvas/RoundedWithShadow.js';
+export { Border } from '../src/core/shaders/canvas/Border.js';
+export { Shadow } from '../src/core/shaders/canvas/Shadow.js';
+export { HolePunch } from '../src/core/shaders/canvas/HolePunch.js';
+export { LinearGradient } from '../src/core/shaders/canvas/LinearGradient.js';
+export { RadialGradient } from '../src/core/shaders/canvas/RadialGradient.js';
+//# sourceMappingURL=canvas-shaders.js.map

package/dist/exports/canvas-shaders.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvas-shaders.js","sourceRoot":"","sources":["../../exports/canvas-shaders.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,cAAc,kDAAkD,CAAC;AAEjE,OAAO,EAAE,OAAO,EAAE,MAAM,uCAAuC,CAAC;AAChE,OAAO,EAAE,iBAAiB,EAAE,MAAM,iDAAiD,CAAC;AACpF,OAAO,EAAE,0BAA0B,EAAE,MAAM,0DAA0D,CAAC;AACtG,OAAO,EAAE,iBAAiB,EAAE,MAAM,iDAAiD,CAAC;AACpF,OAAO,EAAE,MAAM,EAAE,MAAM,sCAAsC,CAAC;AAC9D,OAAO,EAAE,MAAM,EAAE,MAAM,sCAAsC,CAAC;AAC9D,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,EAAE,cAAc,EAAE,MAAM,8CAA8C,CAAC;AAC9E,OAAO,EAAE,cAAc,EAAE,MAAM,8CAA8C,CAAC"}

package/dist/exports/canvas.d.ts

@@ -17,4 +17,10 @@
  * @packageDocumentation
  */
 export { CanvasTextRenderer } from '../src/core/text-rendering/renderers/CanvasTextRenderer.js';
-export { CanvasCoreRenderer } from '../src/core/renderers/canvas/CanvasCoreRenderer.js';
+export { CanvasRenderer } from '../src/core/renderers/canvas/CanvasRenderer.js';
+export { CanvasTexture } from '../src/core/renderers/canvas/CanvasTexture.js';
+export * from '../src/core/renderers/canvas/CanvasShaderNode.js';
+/**
+ * @deprecated Use CanvasRenderer.
+ */
+export { CanvasRenderer as CanvasCoreRenderer } from '../src/core/renderers/canvas/CanvasRenderer.js';

package/dist/exports/canvas.js

@@ -35,5 +35,11 @@
  * @packageDocumentation
  */
 export { CanvasTextRenderer } from '../src/core/text-rendering/renderers/CanvasTextRenderer.js';
-export { CanvasCoreRenderer } from '../src/core/renderers/canvas/CanvasCoreRenderer.js';
+export { CanvasRenderer } from '../src/core/renderers/canvas/CanvasRenderer.js';
+export { CanvasTexture } from '../src/core/renderers/canvas/CanvasTexture.js';
+export * from '../src/core/renderers/canvas/CanvasShaderNode.js';
+/**
+ * @deprecated Use CanvasRenderer.
+ */
+export { CanvasRenderer as CanvasCoreRenderer } from '../src/core/renderers/canvas/CanvasRenderer.js';
 //# sourceMappingURL=canvas.js.map

package/dist/exports/canvas.js.map

@@ -1 +1 @@
-{"version":3,"file":"canvas.js","sourceRoot":"","sources":["../../exports/canvas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,4DAA4D,CAAC;AAChG,OAAO,EAAE,kBAAkB,EAAE,MAAM,oDAAoD,CAAC"}
+{"version":3,"file":"canvas.js","sourceRoot":"","sources":["../../exports/canvas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,4DAA4D,CAAC;AAChG,OAAO,EAAE,cAAc,EAAE,MAAM,gDAAgD,CAAC;AAChF,OAAO,EAAE,aAAa,EAAE,MAAM,+CAA+C,CAAC;AAC9E,cAAc,kDAAkD,CAAC;AACjE;;GAEG;AACH,OAAO,EAAE,cAAc,IAAI,kBAAkB,EAAE,MAAM,gDAAgD,CAAC"}

package/dist/exports/index.d.ts

@@ -19,23 +19,22 @@
  */
 export * from '../src/main-api/INode.js';
 export * from '../src/main-api/Renderer.js';
-export * from '../src/main-api/ShaderController.js';
-export * from '../src/main-api/DynamicShaderController.js';
 export * from '../src/common/IAnimationController.js';
 export * from '../src/common/CommonTypes.js';
 export { CoreTextureManager, type TextureMap, } from '../src/core/CoreTextureManager.js';
 export type { MemoryInfo } from '../src/core/TextureMemoryManager.js';
-export type { ShaderMap, EffectMap } from '../src/core/CoreShaderManager.js';
 export type { TextRendererMap } from '../src/core/text-rendering/renderers/TextRenderer.js';
 export type { TrFontFaceMap } from '../src/core/text-rendering/font-face-types/TrFontFace.js';
 export type { AnimationSettings } from '../src/core/animations/CoreAnimation.js';
-export type { EffectProps, FadeOutEffectProps, LinearGradientEffectProps, RadialGradientEffectProps, GrayscaleEffectProps, GlitchEffectProps, RadialProgressEffectProps, HolePunchEffectProps, } from '../src/core/CoreShaderManager.js';
-export type { WebGlCoreRenderer } from '../src/core/renderers/webgl/WebGlCoreRenderer.js';
-export type { WebGlCoreCtxTexture } from '../src/core/renderers/webgl/WebGlCoreCtxTexture.js';
 export type { Inspector } from '../src/main-api/Inspector.js';
 export type { CoreNodeRenderState } from '../src/core/CoreNode.js';
-export * from '../src/core/renderers/webgl/WebGlCoreShader.js';
-export * from '../src/core/renderers/webgl/shaders/effects/ShaderEffect.js';
+export * from '../src/core/renderers/CoreShaderNode.js';
+export * from '../src/core/shaders/templates/BorderTemplate.js';
+export * from '../src/core/shaders/templates/HolePunchTemplate.js';
+export * from '../src/core/shaders/templates/RoundedTemplate.js';
+export * from '../src/core/shaders/templates/LinearGradientTemplate.js';
+export * from '../src/core/shaders/templates/RadialGradientTemplate.js';
+export * from '../src/core/renderers/webgl/WebGlShaderProgram.js';
 export type { ShaderProgramSources } from '../src/core/renderers/webgl/internal/ShaderUtils.js';
 export * from '../src/core/textures/Texture.js';
 export { ImageTexture } from '../src/core/textures/ImageTexture.js';
@@ -43,3 +42,11 @@ export * from '../src/core/text-rendering/font-face-types/TrFontFace.js';
 export * from '../src/core/text-rendering/font-face-types/WebTrFontFace.js';
 export * from '../src/core/text-rendering/font-face-types/SdfTrFontFace/SdfTrFontFace.js';
 export type * from '../src/core/Stage.js';
+/**
+ * @deprecated Use `import { WebGlRenderer } @lightningjs/renderer/webgl` instead
+ */
+export type { WebGlRenderer as WebGlCoreRenderer } from '../src/core/renderers/webgl/WebGlRenderer.js';
+/**
+ * @deprecated Use `import { WebGlCtxTexture } @lightningjs/renderer/webgl` instead
+ */
+export type { WebGlCtxTexture as WebGlCoreCtxTexture } from '../src/core/renderers/webgl/WebGlCtxTexture.js';

package/dist/exports/index.js

@@ -37,16 +37,19 @@
  */
 export * from '../src/main-api/INode.js';
 export * from '../src/main-api/Renderer.js';
-export * from '../src/main-api/ShaderController.js';
-export * from '../src/main-api/DynamicShaderController.js';
 export * from '../src/common/IAnimationController.js';
 export * from '../src/common/CommonTypes.js';
 // Selected types exported from the Core Renderer that can be used in the
 // context of the main API.
 export { CoreTextureManager, } from '../src/core/CoreTextureManager.js';
+export * from '../src/core/renderers/CoreShaderNode.js';
+export * from '../src/core/shaders/templates/BorderTemplate.js';
+export * from '../src/core/shaders/templates/HolePunchTemplate.js';
+export * from '../src/core/shaders/templates/RoundedTemplate.js';
+export * from '../src/core/shaders/templates/LinearGradientTemplate.js';
+export * from '../src/core/shaders/templates/RadialGradientTemplate.js';
 // Shaders
-export * from '../src/core/renderers/webgl/WebGlCoreShader.js';
-export * from '../src/core/renderers/webgl/shaders/effects/ShaderEffect.js';
+export * from '../src/core/renderers/webgl/WebGlShaderProgram.js';
 // Textures
 export * from '../src/core/textures/Texture.js';
 export { ImageTexture } from '../src/core/textures/ImageTexture.js';

package/dist/exports/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../exports/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AAEH,cAAc,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qCAAqC,CAAC;AACpD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,uCAAuC,CAAC;AACtD,cAAc,8BAA8B,CAAC;AAE7C,yEAAyE;AACzE,2BAA2B;AAC3B,OAAO,EACL,kBAAkB,GAEnB,MAAM,mCAAmC,CAAC;AAqB3C,UAAU;AACV,cAAc,gDAAgD,CAAC;AAC/D,cAAc,6DAA6D,CAAC;AAG5E,WAAW;AACX,cAAc,iCAAiC,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,sCAAsC,CAAC;AAEpE,yBAAyB;AACzB,wEAAwE;AACxE,cAAc,0DAA0D,CAAC;AACzE,cAAc,6DAA6D,CAAC;AAC5E,cAAc,2EAA2E,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../exports/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AAEH,cAAc,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,uCAAuC,CAAC;AACtD,cAAc,8BAA8B,CAAC;AAE7C,yEAAyE;AACzE,2BAA2B;AAC3B,OAAO,EACL,kBAAkB,GAEnB,MAAM,mCAAmC,CAAC;AAQ3C,cAAc,yCAAyC,CAAC;AACxD,cAAc,iDAAiD,CAAC;AAChE,cAAc,oDAAoD,CAAC;AACnE,cAAc,kDAAkD,CAAC;AACjE,cAAc,yDAAyD,CAAC;AACxE,cAAc,yDAAyD,CAAC;AAExE,UAAU;AACV,cAAc,mDAAmD,CAAC;AAGlE,WAAW;AACX,cAAc,iCAAiC,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,sCAAsC,CAAC;AAEpE,yBAAyB;AACzB,wEAAwE;AACxE,cAAc,0DAA0D,CAAC;AACzE,cAAc,6DAA6D,CAAC;AAC5E,cAAc,2EAA2E,CAAC"}

package/dist/exports/webgl-shaders.d.ts

@@ -0,0 +1,11 @@
+export * from '../src/core/renderers/webgl/WebGlShaderNode.js';
+export { Rounded } from '../src/core/shaders/webgl/Rounded.js';
+export { RoundedWithBorder } from '../src/core/shaders/webgl/RoundedWithBorder.js';
+export { RoundedWithBorderAndShadow } from '../src/core/shaders/webgl/RoundedWithBorderAndShadow.js';
+export { RoundedWithShadow } from '../src/core/shaders/webgl/RoundedWithShadow.js';
+export { Border } from '../src/core/shaders/webgl/Border.js';
+export { Shadow } from '../src/core/shaders/webgl/Shadow.js';
+export { HolePunch } from '../src/core/shaders/webgl/HolePunch.js';
+export { LinearGradient } from '../src/core/shaders/webgl/LinearGradient.js';
+export { RadialGradient } from '../src/core/shaders/webgl/RadialGradient.js';
+export { Default } from '../src/core/shaders/webgl/Default.js';

package/dist/exports/webgl-shaders.js

@@ -0,0 +1,28 @@
+/*
+ * 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.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export * from '../src/core/renderers/webgl/WebGlShaderNode.js';
+export { Rounded } from '../src/core/shaders/webgl/Rounded.js';
+export { RoundedWithBorder } from '../src/core/shaders/webgl/RoundedWithBorder.js';
+export { RoundedWithBorderAndShadow } from '../src/core/shaders/webgl/RoundedWithBorderAndShadow.js';
+export { RoundedWithShadow } from '../src/core/shaders/webgl/RoundedWithShadow.js';
+export { Border } from '../src/core/shaders/webgl/Border.js';
+export { Shadow } from '../src/core/shaders/webgl/Shadow.js';
+export { HolePunch } from '../src/core/shaders/webgl/HolePunch.js';
+export { LinearGradient } from '../src/core/shaders/webgl/LinearGradient.js';
+export { RadialGradient } from '../src/core/shaders/webgl/RadialGradient.js';
+export { Default } from '../src/core/shaders/webgl/Default.js';
+//# sourceMappingURL=webgl-shaders.js.map

package/dist/exports/webgl-shaders.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgl-shaders.js","sourceRoot":"","sources":["../../exports/webgl-shaders.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,cAAc,gDAAgD,CAAC;AAE/D,OAAO,EAAE,OAAO,EAAE,MAAM,sCAAsC,CAAC;AAC/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,gDAAgD,CAAC;AACnF,OAAO,EAAE,0BAA0B,EAAE,MAAM,yDAAyD,CAAC;AACrG,OAAO,EAAE,iBAAiB,EAAE,MAAM,gDAAgD,CAAC;AACnF,OAAO,EAAE,MAAM,EAAE,MAAM,qCAAqC,CAAC;AAC7D,OAAO,EAAE,MAAM,EAAE,MAAM,qCAAqC,CAAC;AAC7D,OAAO,EAAE,SAAS,EAAE,MAAM,wCAAwC,CAAC;AACnE,OAAO,EAAE,cAAc,EAAE,MAAM,6CAA6C,CAAC;AAC7E,OAAO,EAAE,cAAc,EAAE,MAAM,6CAA6C,CAAC;AAC7E,OAAO,EAAE,OAAO,EAAE,MAAM,sCAAsC,CAAC"}

package/dist/exports/webgl.d.ts

@@ -16,4 +16,12 @@
  * @packageDocumentation
  */
 export { SdfTextRenderer } from '../src/core/text-rendering/renderers/SdfTextRenderer/SdfTextRenderer.js';
-export { WebGlCoreRenderer } from '../src/core/renderers/webgl/WebGlCoreRenderer.js';
+export { WebGlRenderer } from '../src/core/renderers/webgl/WebGlRenderer.js';
+export { WebGlCtxTexture } from '../src/core/renderers/webgl/WebGlCtxTexture.js';
+export * from '../src/core/renderers/webgl/WebGlShaderNode.js';
+/**
+ * @deprecated Use WebGlRenderer.
+ */
+export { WebGlRenderer as WebGlCoreRenderer } from '../src/core/renderers/webgl/WebGlRenderer.js';
+export { WebGlRenderer as WebGlCoreCtxTexture } from '../src/core/renderers/webgl/WebGlRenderer.js';
+export * as shaders from './webgl-shaders.js';

package/dist/exports/webgl.js

@@ -34,5 +34,13 @@
  * @packageDocumentation
  */
 export { SdfTextRenderer } from '../src/core/text-rendering/renderers/SdfTextRenderer/SdfTextRenderer.js';
-export { WebGlCoreRenderer } from '../src/core/renderers/webgl/WebGlCoreRenderer.js';
+export { WebGlRenderer } from '../src/core/renderers/webgl/WebGlRenderer.js';
+export { WebGlCtxTexture } from '../src/core/renderers/webgl/WebGlCtxTexture.js';
+export * from '../src/core/renderers/webgl/WebGlShaderNode.js';
+/**
+ * @deprecated Use WebGlRenderer.
+ */
+export { WebGlRenderer as WebGlCoreRenderer } from '../src/core/renderers/webgl/WebGlRenderer.js';
+export { WebGlRenderer as WebGlCoreCtxTexture } from '../src/core/renderers/webgl/WebGlRenderer.js';
+export * as shaders from './webgl-shaders.js';
 //# sourceMappingURL=webgl.js.map

package/dist/exports/webgl.js.map

@@ -1 +1 @@
-{"version":3,"file":"webgl.js","sourceRoot":"","sources":["../../exports/webgl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,yEAAyE,CAAC;AAC1G,OAAO,EAAE,iBAAiB,EAAE,MAAM,kDAAkD,CAAC"}
+{"version":3,"file":"webgl.js","sourceRoot":"","sources":["../../exports/webgl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,yEAAyE,CAAC;AAC1G,OAAO,EAAE,aAAa,EAAE,MAAM,8CAA8C,CAAC;AAC7E,OAAO,EAAE,eAAe,EAAE,MAAM,gDAAgD,CAAC;AAEjF,cAAc,gDAAgD,CAAC;AAE/D;;GAEG;AACH,OAAO,EAAE,aAAa,IAAI,iBAAiB,EAAE,MAAM,8CAA8C,CAAC;AAClG,OAAO,EAAE,aAAa,IAAI,mBAAmB,EAAE,MAAM,8CAA8C,CAAC;AAEpG,OAAO,KAAK,OAAO,MAAM,oBAAoB,CAAC"}

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

@@ -9,7 +9,7 @@ import { Matrix3d } from './lib/Matrix3d.js';
 import { RenderCoords } from './lib/RenderCoords.js';
 import type { AnimationSettings } from './animations/CoreAnimation.js';
 import type { IAnimationController } from '../common/IAnimationController.js';
-import type { BaseShaderController } from '../main-api/ShaderController.js';
+import type { CoreShaderNode } from './renderers/CoreShaderNode.js';
 export declare enum CoreNodeRenderState {
     Init = 0,
     OutOfBounds = 2,
@@ -125,7 +125,11 @@ export declare enum UpdateType {
     /**
      * All
      */
-    All = 14335
+    All = 14335,
+    /**
+     * RecalcUniforms
+     */
+    RecalcUniforms = 16384
 }
 /**
  * A custom data map which can be stored on an CoreNode
@@ -197,6 +201,12 @@ export interface CoreNodeProps {
      * @default `false`
      */
     autosize: boolean;
+    /**
+     * Margin around the Node's bounds for preloading
+     *
+     * @default `null`
+     */
+    boundsMargin: number | [number, number, number, number] | null;
     /**
      * Clipping Mode
      *
@@ -368,7 +378,7 @@ export interface CoreNodeProps {
      * Note: If this is a Text Node, the Shader will be managed by the Node's
      * {@link TextRenderer} and should not be set explicitly.
      */
-    shader: BaseShaderController;
+    shader: CoreShaderNode<any> | null;
     /**
      * Image URL
      *
@@ -643,7 +653,9 @@ export declare class CoreNode extends EventEmitter {
     globalTransform?: Matrix3d;
     scaleRotateTransform?: Matrix3d;
     localTransform?: Matrix3d;
+    sceneGlobalTransform?: Matrix3d;
     renderCoords?: RenderCoords;
+    sceneRenderCoords?: RenderCoords;
     renderBound?: Bound;
     strictBound?: Bound;
     preloadBound?: Bound;
@@ -774,6 +786,8 @@ export declare class CoreNode extends EventEmitter {
     set alpha(value: number);
     get autosize(): boolean;
     set autosize(value: boolean);
+    get boundsMargin(): number | [number, number, number, number] | null;
+    set boundsMargin(value: number | [number, number, number, number] | null);
     get clipping(): boolean;
     set clipping(value: boolean);
     get color(): number;
@@ -809,8 +823,8 @@ export declare class CoreNode extends EventEmitter {
     private markChildrenWithRTT;
     private applyRTTInheritance;
     private clearRTTInheritance;
-    get shader(): BaseShaderController;
-    set shader(value: BaseShaderController);
+    get shader(): CoreShaderNode<any> | null;
+    set shader(shader: CoreShaderNode<any> | null);
     get src(): string | null;
     set src(imageUrl: string | null);
     set imageType(type: 'regular' | 'compressed' | 'svg' | null);

package/dist/src/core/CoreNode.js

@@ -147,6 +147,10 @@ export var UpdateType;
      * All
      */
     UpdateType[UpdateType["All"] = 14335] = "All";
+    /**
+     * RecalcUniforms
+     */
+    UpdateType[UpdateType["RecalcUniforms"] = 16384] = "RecalcUniforms";
 })(UpdateType || (UpdateType = {}));
 /**
  * A visual Node in the Renderer scene graph.
@@ -166,7 +170,9 @@ export class CoreNode extends EventEmitter {
     globalTransform;
     scaleRotateTransform;
     localTransform;
+    sceneGlobalTransform;
     renderCoords;
+    sceneRenderCoords;
     renderBound;
     strictBound;
     preloadBound;
@@ -191,18 +197,29 @@ export class CoreNode extends EventEmitter {
     constructor(stage, props) {
         super();
         this.stage = stage;
-        this.props = {
-            ...props,
+        this.props = Object.assign({}, props, {
             parent: null,
             texture: null,
+            shader: null,
             src: null,
             rtt: false,
-        };
+        });
         // Assign props to instance
         this.parent = props.parent;
         this.texture = props.texture;
+        this.shader = props.shader;
         this.src = props.src;
         this.rtt = props.rtt;
+        if (props.boundsMargin) {
+            this.boundsMargin = Array.isArray(props.boundsMargin)
+                ? props.boundsMargin
+                : [
+                    props.boundsMargin,
+                    props.boundsMargin,
+                    props.boundsMargin,
+                    props.boundsMargin,
+                ];
+        }
         this.setUpdateType(UpdateType.ScaleRotate |
             UpdateType.Local |
             UpdateType.RenderBounds |
@@ -418,16 +435,32 @@ export class CoreNode extends EventEmitter {
         }
         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) {
+            if (this.parentHasRenderTexture === true && parent?.rtt === true) {
+                // we are at the start of the RTT chain, so we need to reset the globalTransform
+                // for correct RTT rendering
                 this.globalTransform = Matrix3d.identity();
+                // Maintain a full scene global transform for bounds detection
+                this.sceneGlobalTransform = Matrix3d.copy(parent?.globalTransform || Matrix3d.identity()).multiply(this.localTransform);
             }
-            if (parent) {
+            else if (this.parentHasRenderTexture === true &&
+                parent?.rtt === false) {
+                // we're part of an RTT chain but our parent is not the main RTT node
+                // so we need to propogate the sceneGlobalTransform of the parent
+                // to maintain a full scene global transform for bounds detection
+                this.sceneGlobalTransform = Matrix3d.copy(parent?.sceneGlobalTransform || this.localTransform).multiply(this.localTransform);
+                this.globalTransform = Matrix3d.copy(parent?.globalTransform || this.localTransform, this.globalTransform);
+            }
+            else {
+                this.globalTransform = Matrix3d.copy(parent?.globalTransform || this.localTransform, this.globalTransform);
+            }
+            if (parent !== null) {
                 this.globalTransform.multiply(this.localTransform);
             }
             this.calculateRenderCoords();
             this.updateBoundingRect();
-            this.setUpdateType(UpdateType.RenderState | UpdateType.Children);
+            this.setUpdateType(UpdateType.RenderState |
+                UpdateType.Children |
+                UpdateType.RecalcUniforms);
             this.childUpdateType |= UpdateType.Global;
             if (this.clipping === true) {
                 this.setUpdateType(UpdateType.Clipping | UpdateType.RenderBounds);
@@ -438,6 +471,7 @@ export class CoreNode extends EventEmitter {
             this.createRenderBounds();
             this.setUpdateType(UpdateType.RenderState);
             this.setUpdateType(UpdateType.Children);
+            this.childUpdateType |= UpdateType.RenderBounds;
         }
         if (this.updateType & UpdateType.RenderState) {
             renderState = this.checkRenderBounds();
@@ -495,8 +529,14 @@ export class CoreNode extends EventEmitter {
         }
         if (this.props.strictBounds === true &&
             this.renderState === CoreNodeRenderState.OutOfBounds) {
+            this.updateType &= ~UpdateType.RenderBounds; // remove render bounds update
             return;
         }
+        if (this.shader?.update !== undefined &&
+            (this.updateType & UpdateType.Local ||
+                this.updateType & UpdateType.RecalcUniforms)) {
+            this.shader.update();
+        }
         if (this.updateType & UpdateType.Children && this.children.length > 0) {
             for (let i = 0, length = this.children.length; i < length; i++) {
                 const child = this.children[i];
@@ -589,10 +629,6 @@ export class CoreNode extends EventEmitter {
         assertTruthy(this.renderBound);
         assertTruthy(this.strictBound);
         assertTruthy(this.preloadBound);
-        // if we are part of a parent render texture, we're always in bounds
-        if (this.parentHasRenderTexture === true) {
-            return this.getRTTParentRenderState() || CoreNodeRenderState.OutOfBounds;
-        }
         if (boundInsideBound(this.renderBound, this.strictBound)) {
             return CoreNodeRenderState.InViewport;
         }
@@ -611,7 +647,8 @@ export class CoreNode extends EventEmitter {
         return CoreNodeRenderState.OutOfBounds;
     }
     updateBoundingRect() {
-        const { renderCoords, globalTransform: transform } = this;
+        const transform = this.sceneGlobalTransform || this.globalTransform;
+        const renderCoords = this.sceneRenderCoords || this.renderCoords;
         assertTruthy(transform);
         assertTruthy(renderCoords);
         const { tb, tc } = transform;
@@ -630,7 +667,7 @@ export class CoreNode extends EventEmitter {
             // we have a parent with a valid bound, copy it
             const parentBound = this.parent.strictBound;
             this.strictBound = createBound(parentBound.x1, parentBound.y1, parentBound.x2, parentBound.y2);
-            this.preloadBound = createPreloadBounds(this.strictBound, this.stage.boundsMargin);
+            this.preloadBound = createPreloadBounds(this.strictBound, this.boundsMargin);
         }
         else {
             // no parent or parent does not have a bound, take the stage boundaries
@@ -652,11 +689,13 @@ export class CoreNode extends EventEmitter {
         }
         // clipping is enabled and we are in bounds create our own bounds
         const { x, y, width, height } = this.props;
-        const { tx, ty } = this.globalTransform || {};
+        // Pick the global transform if available, otherwise use the local transform
+        // global transform is only available if the node in an RTT chain
+        const { tx, ty } = this.sceneGlobalTransform || this.globalTransform || {};
         const _x = tx ?? x;
         const _y = ty ?? y;
         this.strictBound = createBound(_x, _y, _x + width, _y + height, this.strictBound);
-        this.preloadBound = createPreloadBounds(this.strictBound, this.stage.boundsMargin);
+        this.preloadBound = createPreloadBounds(this.strictBound, this.boundsMargin);
     }
     updateRenderState(renderState) {
         if (renderState === this.renderState) {
@@ -753,9 +792,8 @@ export class CoreNode extends EventEmitter {
         return this.props.shader !== null;
     }
     calculateRenderCoords() {
-        const { width, height, globalTransform: transform } = this;
-        assertTruthy(transform);
-        const { tx, ty, ta, tb, tc, td } = transform;
+        const { width, height } = this;
+        const { tx, ty, ta, tb, tc, td } = this.globalTransform;
         if (tb === 0 && tc === 0) {
             const minX = tx;
             const maxX = tx + width * ta;
@@ -782,6 +820,36 @@ export class CoreNode extends EventEmitter {
             //bottom-left
             tx + height * tb, ty + height * td, this.renderCoords);
         }
+        if (this.sceneGlobalTransform === undefined) {
+            return;
+        }
+        const { tx: stx, ty: sty, ta: sta, tb: stb, tc: stc, td: std, } = this.sceneGlobalTransform;
+        if (stb === 0 && stc === 0) {
+            const minX = stx;
+            const maxX = stx + width * sta;
+            const minY = sty;
+            const maxY = sty + height * std;
+            this.sceneRenderCoords = RenderCoords.translate(
+            //top-left
+            minX, minY, 
+            //top-right
+            maxX, minY, 
+            //bottom-right
+            maxX, maxY, 
+            //bottom-left
+            minX, maxY, this.sceneRenderCoords);
+        }
+        else {
+            this.sceneRenderCoords = RenderCoords.translate(
+            //top-left
+            stx, sty, 
+            //top-right
+            stx + width * sta, sty + width * stc, 
+            //bottom-right
+            stx + width * sta + height * stb, sty + width * stc + height * std, 
+            //bottom-left
+            stx + height * stb, sty + height * std, this.sceneRenderCoords);
+        }
     }
     /**
      * This function calculates the clipping rectangle for a node.
@@ -841,7 +909,7 @@ export class CoreNode extends EventEmitter {
         this.scaleRotateTransform = undefined;
         this.localTransform = undefined;
         this.props.texture = null;
-        this.props.shader = this.stage.defShaderCtr;
+        this.props.shader = this.stage.defShaderNode;
         while (this.children.length > 0) {
             this.children[0]?.destroy();
         }
@@ -879,8 +947,7 @@ export class CoreNode extends EventEmitter {
             texture: this.texture || this.stage.defaultTexture,
             textureOptions: this.textureOptions,
             zIndex: this.zIndex,
-            shader: this.shader.shader,
-            shaderProps: this.shader.getResolvedProps(),
+            shader: this.props.shader,
             alpha: this.worldAlpha,
             clippingRect: this.clippingRect,
             tx: this.globalTransform.tx,
@@ -1078,6 +1145,26 @@ export class CoreNode extends EventEmitter {
     set autosize(value) {
         this.props.autosize = value;
     }
+    get boundsMargin() {
+        return (this.props.boundsMargin ??
+            this.parent?.boundsMargin ??
+            this.stage.boundsMargin);
+    }
+    set boundsMargin(value) {
+        if (value === this.props.boundsMargin) {
+            return;
+        }
+        if (value === null) {
+            this.props.boundsMargin = value;
+        }
+        else {
+            const bm = Array.isArray(value)
+                ? value
+                : [value, value, value, value];
+            this.props.boundsMargin = bm;
+        }
+        this.setUpdateType(UpdateType.RenderBounds);
+    }
     get clipping() {
         return this.props.clipping;
     }
@@ -1298,11 +1385,17 @@ export class CoreNode extends EventEmitter {
     get shader() {
         return this.props.shader;
     }
-    set shader(value) {
-        if (this.props.shader === value) {
+    set shader(shader) {
+        if (this.props.shader === shader) {
+            return;
+        }
+        if (shader === null) {
+            this.props.shader = this.stage.defShaderNode;
+            this.setUpdateType(UpdateType.IsRenderable);
             return;
         }
-        this.props.shader = value;
+        shader.attachNode(this);
+        this.props.shader = shader;
         this.setUpdateType(UpdateType.IsRenderable);
     }
     get src() {