@lightningjs/renderer 3.0.0-beta10 → 3.0.0-beta12

package/src/core/renderers/CoreRenderOp.ts

@@ -1,22 +1,22 @@
-/*
- * 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.
- */
-
-export abstract class CoreRenderOp {
-  abstract draw(): void;
-}
+/*
+ * 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.
+ */
+
+export abstract class CoreRenderOp {
+  abstract draw(): void;
+}

package/src/core/renderers/CoreRenderer.ts

@@ -1,110 +1,110 @@
-/*
- * If not stated otherwise in this file or this component's LICENSE file the
- * following copyright and licenses apply:
- *
- * Copyright 2023 Comcast Cable Communications Management, LLC.
- *
- * Licensed under the Apache License, Version 2.0 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import type { Dimensions } from '../../common/CommonTypes.js';
-import type { CoreNode } from '../CoreNode.js';
-import type { TextureOptions } from '../CoreTextureManager.js';
-import type { Stage } from '../Stage.js';
-import type { ContextSpy } from '../lib/ContextSpy.js';
-import type { RenderCoords } from '../lib/RenderCoords.js';
-import type { RectWithValid } from '../lib/utils.js';
-import type { CoreShaderProgram } from './CoreShaderProgram.js';
-import type { Texture, TextureCoords } from '../textures/Texture.js';
-import { CoreContextTexture } from './CoreContextTexture.js';
-import type { CoreShaderType, CoreShaderNode } from './CoreShaderNode.js';
-
-export interface QuadOptions {
-  width: number;
-  height: number;
-  colorTl: number;
-  colorTr: number;
-  colorBl: number;
-  colorBr: number;
-  texture: Texture | null;
-  textureOptions: TextureOptions | null;
-  textureCoords: TextureCoords | undefined;
-  zIndex: number;
-  shader: CoreShaderNode | null;
-  alpha: number;
-  clippingRect: RectWithValid;
-  tx: number;
-  ty: number;
-  ta: number;
-  tb: number;
-  tc: number;
-  td: number;
-  renderCoords?: RenderCoords;
-  rtt: boolean;
-  parentHasRenderTexture: boolean;
-  framebufferDimensions: Dimensions | null;
-}
-
-export interface CoreRendererOptions {
-  stage: Stage;
-  canvas: HTMLCanvasElement | OffscreenCanvas;
-  contextSpy: ContextSpy | null;
-  forceWebGL2: boolean;
-}
-
-export interface BufferInfo {
-  totalUsed: number;
-  totalAvailable: number;
-}
-
-export abstract class CoreRenderer {
-  public options: CoreRendererOptions;
-  public mode: 'webgl' | 'canvas' | undefined;
-
-  readonly stage: Stage;
-
-  //// Core Managers
-  rttNodes: CoreNode[] = [];
-
-  constructor(options: CoreRendererOptions) {
-    this.options = options;
-    this.stage = options.stage;
-  }
-
-  abstract reset(): void;
-  abstract render(surface?: 'screen' | CoreContextTexture): void;
-  abstract addQuad(quad: QuadOptions): void;
-  abstract createCtxTexture(textureSource: Texture): CoreContextTexture;
-  abstract createShaderProgram(
-    shaderConfig: Readonly<CoreShaderType>,
-    props?: Record<string, unknown>,
-  ): CoreShaderProgram | null;
-  abstract createShaderNode(
-    shaderKey: string,
-    shaderType: Readonly<CoreShaderType>,
-    props?: Record<string, unknown>,
-    program?: CoreShaderProgram,
-  ): CoreShaderNode;
-  abstract supportsShaderType(shaderType: Readonly<CoreShaderType>): boolean;
-  abstract getDefaultShaderNode(): CoreShaderNode | null;
-  abstract get renderToTextureActive(): boolean;
-  abstract get activeRttNode(): CoreNode | null;
-  abstract renderRTTNodes(): void;
-  abstract removeRTTNode(node: CoreNode): void;
-  abstract renderToTexture(node: CoreNode): void;
-  abstract getBufferInfo(): BufferInfo | null;
-  abstract getQuadCount(): number | null;
-  abstract updateViewport(): void;
-  abstract updateClearColor(color: number): void;
-  getTextureCoords?(node: CoreNode): TextureCoords;
-}
+/*
+ * If not stated otherwise in this file or this component's LICENSE file the
+ * following copyright and licenses apply:
+ *
+ * Copyright 2023 Comcast Cable Communications Management, LLC.
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { Dimensions } from '../../common/CommonTypes.js';
+import type { CoreNode } from '../CoreNode.js';
+import type { TextureOptions } from '../CoreTextureManager.js';
+import type { Stage } from '../Stage.js';
+import type { ContextSpy } from '../lib/ContextSpy.js';
+import type { RenderCoords } from '../lib/RenderCoords.js';
+import type { RectWithValid } from '../lib/utils.js';
+import type { CoreShaderProgram } from './CoreShaderProgram.js';
+import type { Texture, TextureCoords } from '../textures/Texture.js';
+import { CoreContextTexture } from './CoreContextTexture.js';
+import type { CoreShaderType, CoreShaderNode } from './CoreShaderNode.js';
+
+export interface QuadOptions {
+  width: number;
+  height: number;
+  colorTl: number;
+  colorTr: number;
+  colorBl: number;
+  colorBr: number;
+  texture: Texture | null;
+  textureOptions: TextureOptions | null;
+  textureCoords: TextureCoords | undefined;
+  zIndex: number;
+  shader: CoreShaderNode | null;
+  alpha: number;
+  clippingRect: RectWithValid;
+  tx: number;
+  ty: number;
+  ta: number;
+  tb: number;
+  tc: number;
+  td: number;
+  renderCoords?: RenderCoords;
+  rtt: boolean;
+  parentHasRenderTexture: boolean;
+  framebufferDimensions: Dimensions | null;
+}
+
+export interface CoreRendererOptions {
+  stage: Stage;
+  canvas: HTMLCanvasElement | OffscreenCanvas;
+  contextSpy: ContextSpy | null;
+  forceWebGL2: boolean;
+}
+
+export interface BufferInfo {
+  totalUsed: number;
+  totalAvailable: number;
+}
+
+export abstract class CoreRenderer {
+  public options: CoreRendererOptions;
+  public mode: 'webgl' | 'canvas' | undefined;
+
+  readonly stage: Stage;
+
+  //// Core Managers
+  rttNodes: CoreNode[] = [];
+
+  constructor(options: CoreRendererOptions) {
+    this.options = options;
+    this.stage = options.stage;
+  }
+
+  abstract reset(): void;
+  abstract render(surface?: 'screen' | CoreContextTexture): void;
+  abstract addQuad(quad: QuadOptions): void;
+  abstract createCtxTexture(textureSource: Texture): CoreContextTexture;
+  abstract createShaderProgram(
+    shaderConfig: Readonly<CoreShaderType>,
+    props?: Record<string, unknown>,
+  ): CoreShaderProgram | null;
+  abstract createShaderNode(
+    shaderKey: string,
+    shaderType: Readonly<CoreShaderType>,
+    props?: Record<string, unknown>,
+    program?: CoreShaderProgram,
+  ): CoreShaderNode;
+  abstract supportsShaderType(shaderType: Readonly<CoreShaderType>): boolean;
+  abstract getDefaultShaderNode(): CoreShaderNode | null;
+  abstract get renderToTextureActive(): boolean;
+  abstract get activeRttNode(): CoreNode | null;
+  abstract renderRTTNodes(): void;
+  abstract removeRTTNode(node: CoreNode): void;
+  abstract renderToTexture(node: CoreNode): void;
+  abstract getBufferInfo(): BufferInfo | null;
+  abstract getQuadCount(): number | null;
+  abstract updateViewport(): void;
+  abstract updateClearColor(color: number): void;
+  getTextureCoords?(node: CoreNode): TextureCoords;
+}

package/src/core/renderers/CoreShaderNode.ts

@@ -1,175 +1,175 @@
-import { deepClone } from '../../utils.js';
-import { UpdateType, type CoreNode } from '../CoreNode.js';
-import type { Stage } from '../Stage.js';
-
-export interface AdvShaderProp<T = any, Props = Record<string, unknown>> {
-  /**
-   * default value
-   */
-  default: T;
-  resolve?: (this: AdvShaderProp<T, Props>, value: T, props: Props) => T;
-  transform?: (start: T, end: T, progress: number) => T;
-}
-
-export type AdvancedShaderProp<T = any, Props = Record<string, unknown>> =
-  | (AdvShaderProp<T, Props> & {
-      set: (value: T, props: Props) => void;
-      get: (props: Props) => T;
-    })
-  | (AdvShaderProp<T, Props> & { set?: never; get?: never });
-
-export type ShaderProp<T, Props> = T | AdvancedShaderProp<T, Props>;
-
-export type ShaderProps<Props> = {
-  [K in keyof Props]: ShaderProp<Props[K], Props>;
-};
-
-export function isAdvancedShaderProp(obj: any): obj is AdvancedShaderProp {
-  return obj !== null && typeof obj === 'object' && obj.default !== undefined;
-}
-
-export function resolveShaderProps(
-  props: Record<string, unknown>,
-  propsConfig: ShaderProps<Record<string, unknown>>,
-) {
-  for (const key in propsConfig) {
-    if (!isAdvancedShaderProp(propsConfig[key]) && props[key] === undefined) {
-      props[key] = propsConfig[key];
-      continue;
-    }
-
-    const pConfig = propsConfig[key]! as AdvancedShaderProp;
-    const hasValue = props[key] !== undefined;
-
-    if (pConfig.resolve !== undefined) {
-      props[key] = pConfig.resolve!(props[key], props);
-      continue;
-    }
-    if (hasValue && pConfig.set !== undefined) {
-      pConfig.set(props[key], props);
-      continue;
-    }
-    if (hasValue) {
-      continue;
-    }
-
-    if (props[key] === undefined && pConfig.get === undefined) {
-      props[key] = deepClone(pConfig.default);
-      continue;
-    }
-    props[key] = pConfig.get!(props);
-  }
-}
-
-/**
- * CoreShaderType is a template for ShaderTypes the renderer.
- * You could view a ShaderType as a configuration object that contains methods,
- * and values that you can use to alter the way a node is drawn by the Renderer.
- */
-export interface CoreShaderType<Props extends object = any> {
-  /**
-   * Values you use to draw the Shader
-   */
-  props?: ShaderProps<Props>;
-  /**
-   * used for making a cache key to check for reusability, currently only used for webgl ShaderTypes but might be needed for other types of renderer
-   */
-  getCacheMarkers?: (props: Props) => string;
-}
-
-/**
- * CoreShaderNode is a base class that manages the shader prop values.
- * When a prop is being updated the CoreShaderNode will notify either the associated CoreNode,
- * or the Stage that there has been a change and a new render of the scene.
- */
-export class CoreShaderNode<Props extends object = Record<string, unknown>> {
-  readonly stage: Stage;
-  readonly shaderType: CoreShaderType<Props>;
-  protected propsConfig: ShaderProps<Props> | undefined;
-  readonly resolvedProps: Props | undefined = undefined;
-  protected definedProps: Props | undefined = undefined;
-  protected node: CoreNode | null = null;
-  update: (() => void) | undefined = undefined;
-
-  constructor(
-    readonly shaderKey: string,
-    type: CoreShaderType<Props>,
-    stage: Stage,
-    props?: Props,
-  ) {
-    this.stage = stage;
-    this.shaderType = type;
-
-    if (props !== undefined) {
-      /**
-       * props are already resolved by shadermanager
-       */
-      this.resolvedProps = props;
-      this.defineProps(props);
-    }
-  }
-
-  private defineProps(props: Props) {
-    const definedProps = {};
-    for (const key in props) {
-      const propConfig = this.shaderType.props![key];
-      const isAdvancedProp = isAdvancedShaderProp(propConfig);
-
-      Object.defineProperty(definedProps, key, {
-        get: () => {
-          return this.resolvedProps![key as keyof Props];
-        },
-        set: (value) => {
-          // this.resolvedProps![key as keyof Props] = value;
-          if (isAdvancedProp === true && propConfig.resolve !== undefined) {
-            this.resolvedProps![key] = propConfig.resolve(
-              value,
-              this.resolvedProps as Record<string, unknown>,
-            );
-          } else if (isAdvancedProp === true && propConfig.set !== undefined) {
-            propConfig.set(
-              value,
-              this.resolvedProps as Record<string, unknown>,
-            );
-          } else {
-            this.resolvedProps![key] = value;
-          }
-
-          if (this.update !== undefined && this.node !== null) {
-            this.node.setUpdateType(UpdateType.RecalcUniforms);
-          } else {
-            this.stage.requestRender();
-          }
-        },
-      });
-    }
-    this.definedProps = definedProps as Props;
-  }
-
-  attachNode(node: CoreNode) {
-    this.node = node;
-  }
-
-  createValueKey() {
-    let valueKey = '';
-    for (const key in this.resolvedProps) {
-      valueKey += `${key}:${this.resolvedProps[key]!};`;
-    }
-    valueKey += `node-width:${this.node!.width}`;
-    valueKey += `node-height:${this.node!.height}`;
-    return valueKey;
-  }
-
-  get props(): Props | undefined {
-    return this.definedProps;
-  }
-
-  set props(props: Props | undefined) {
-    if (props === undefined) {
-      return;
-    }
-    for (const key in props) {
-      this.props![key] = props[key];
-    }
-  }
-}
+import { deepClone } from '../../utils.js';
+import { UpdateType, type CoreNode } from '../CoreNode.js';
+import type { Stage } from '../Stage.js';
+
+export interface AdvShaderProp<T = any, Props = Record<string, unknown>> {
+  /**
+   * default value
+   */
+  default: T;
+  resolve?: (this: AdvShaderProp<T, Props>, value: T, props: Props) => T;
+  transform?: (start: T, end: T, progress: number) => T;
+}
+
+export type AdvancedShaderProp<T = any, Props = Record<string, unknown>> =
+  | (AdvShaderProp<T, Props> & {
+      set: (value: T, props: Props) => void;
+      get: (props: Props) => T;
+    })
+  | (AdvShaderProp<T, Props> & { set?: never; get?: never });
+
+export type ShaderProp<T, Props> = T | AdvancedShaderProp<T, Props>;
+
+export type ShaderProps<Props> = {
+  [K in keyof Props]: ShaderProp<Props[K], Props>;
+};
+
+export function isAdvancedShaderProp(obj: any): obj is AdvancedShaderProp {
+  return obj !== null && typeof obj === 'object' && obj.default !== undefined;
+}
+
+export function resolveShaderProps(
+  props: Record<string, unknown>,
+  propsConfig: ShaderProps<Record<string, unknown>>,
+) {
+  for (const key in propsConfig) {
+    if (!isAdvancedShaderProp(propsConfig[key]) && props[key] === undefined) {
+      props[key] = propsConfig[key];
+      continue;
+    }
+
+    const pConfig = propsConfig[key]! as AdvancedShaderProp;
+    const hasValue = props[key] !== undefined;
+
+    if (pConfig.resolve !== undefined) {
+      props[key] = pConfig.resolve!(props[key], props);
+      continue;
+    }
+    if (hasValue && pConfig.set !== undefined) {
+      pConfig.set(props[key], props);
+      continue;
+    }
+    if (hasValue) {
+      continue;
+    }
+
+    if (props[key] === undefined && pConfig.get === undefined) {
+      props[key] = deepClone(pConfig.default);
+      continue;
+    }
+    props[key] = pConfig.get!(props);
+  }
+}
+
+/**
+ * CoreShaderType is a template for ShaderTypes the renderer.
+ * You could view a ShaderType as a configuration object that contains methods,
+ * and values that you can use to alter the way a node is drawn by the Renderer.
+ */
+export interface CoreShaderType<Props extends object = any> {
+  /**
+   * Values you use to draw the Shader
+   */
+  props?: ShaderProps<Props>;
+  /**
+   * used for making a cache key to check for reusability, currently only used for webgl ShaderTypes but might be needed for other types of renderer
+   */
+  getCacheMarkers?: (props: Props) => string;
+}
+
+/**
+ * CoreShaderNode is a base class that manages the shader prop values.
+ * When a prop is being updated the CoreShaderNode will notify either the associated CoreNode,
+ * or the Stage that there has been a change and a new render of the scene.
+ */
+export class CoreShaderNode<Props extends object = Record<string, unknown>> {
+  readonly stage: Stage;
+  readonly shaderType: CoreShaderType<Props>;
+  protected propsConfig: ShaderProps<Props> | undefined;
+  readonly resolvedProps: Props | undefined = undefined;
+  protected definedProps: Props | undefined = undefined;
+  protected node: CoreNode | null = null;
+  update: (() => void) | undefined = undefined;
+
+  constructor(
+    readonly shaderKey: string,
+    type: CoreShaderType<Props>,
+    stage: Stage,
+    props?: Props,
+  ) {
+    this.stage = stage;
+    this.shaderType = type;
+
+    if (props !== undefined) {
+      /**
+       * props are already resolved by shadermanager
+       */
+      this.resolvedProps = props;
+      this.defineProps(props);
+    }
+  }
+
+  private defineProps(props: Props) {
+    const definedProps = {};
+    for (const key in props) {
+      const propConfig = this.shaderType.props![key];
+      const isAdvancedProp = isAdvancedShaderProp(propConfig);
+
+      Object.defineProperty(definedProps, key, {
+        get: () => {
+          return this.resolvedProps![key as keyof Props];
+        },
+        set: (value) => {
+          // this.resolvedProps![key as keyof Props] = value;
+          if (isAdvancedProp === true && propConfig.resolve !== undefined) {
+            this.resolvedProps![key] = propConfig.resolve(
+              value,
+              this.resolvedProps as Record<string, unknown>,
+            );
+          } else if (isAdvancedProp === true && propConfig.set !== undefined) {
+            propConfig.set(
+              value,
+              this.resolvedProps as Record<string, unknown>,
+            );
+          } else {
+            this.resolvedProps![key] = value;
+          }
+
+          if (this.update !== undefined && this.node !== null) {
+            this.node.setUpdateType(UpdateType.RecalcUniforms);
+          } else {
+            this.stage.requestRender();
+          }
+        },
+      });
+    }
+    this.definedProps = definedProps as Props;
+  }
+
+  attachNode(node: CoreNode) {
+    this.node = node;
+  }
+
+  createValueKey() {
+    let valueKey = '';
+    for (const key in this.resolvedProps) {
+      valueKey += `${key}:${this.resolvedProps[key]!};`;
+    }
+    valueKey += `node-width:${this.node!.w}`;
+    valueKey += `node-height:${this.node!.h}`;
+    return valueKey;
+  }
+
+  get props(): Props | undefined {
+    return this.definedProps;
+  }
+
+  set props(props: Props | undefined) {
+    if (props === undefined) {
+      return;
+    }
+    for (const key in props) {
+      this.props![key] = props[key];
+    }
+  }
+}

package/src/core/renderers/CoreShaderProgram.ts

@@ -1,23 +1,23 @@
-/*
- * 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.
- */
-
-export interface CoreShaderProgram {
-  attach?: () => void;
-  detach?: () => void;
-}
+/*
+ * 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.
+ */
+
+export interface CoreShaderProgram {
+  attach?: () => void;
+  detach?: () => void;
+}