@lightningtv/renderer 3.0.0-beta1

package/src/core/renderers/canvas/CanvasRenderer.ts

@@ -0,0 +1,299 @@
+/*
+ * 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 { CoreNode } from '../../CoreNode.js';
+import { SubTexture } from '../../textures/SubTexture.js';
+import { TextureType, type Texture } from '../../textures/Texture.js';
+import type { CoreContextTexture } from '../CoreContextTexture.js';
+import {
+  CoreRenderer,
+  type CoreRendererOptions,
+  type QuadOptions,
+} from '../CoreRenderer.js';
+import { CanvasTexture } from './CanvasTexture.js';
+import {
+  parseColor,
+  parseToAbgrString,
+  parseToRgbaString,
+} from './internal/ColorUtils.js';
+import { assertTruthy } from '../../../utils.js';
+import { CanvasShaderNode, type CanvasShaderType } from './CanvasShaderNode.js';
+import type { CoreShaderType } from '../CoreShaderNode.js';
+
+export class CanvasRenderer extends CoreRenderer {
+  private context: CanvasRenderingContext2D;
+  private canvas: HTMLCanvasElement;
+  private pixelRatio: number;
+  private clearColor: string;
+  public renderToTextureActive = false;
+  activeRttNode: CoreNode | null = null;
+
+  private parsedColorCache: Map<number, string> = new Map();
+
+  constructor(options: CoreRendererOptions) {
+    super(options);
+
+    this.mode = 'canvas';
+
+    const { canvas } = options;
+    this.canvas = canvas as HTMLCanvasElement;
+    this.context = canvas.getContext('2d') as CanvasRenderingContext2D;
+    this.pixelRatio = this.stage.pixelRatio;
+    this.clearColor = this.getParsedColor(this.stage.clearColor);
+  }
+
+  reset(): void {
+    this.canvas.width = this.canvas.width; // quick reset canvas
+
+    const ctx = this.context;
+
+    if (this.clearColor) {
+      ctx.fillStyle = this.clearColor;
+      ctx.fillRect(0, 0, this.canvas.width, this.canvas.height);
+    }
+
+    ctx.scale(this.pixelRatio, this.pixelRatio);
+  }
+
+  render(): void {
+    // noop
+  }
+
+  addQuad(quad: QuadOptions): void {
+    const ctx = this.context;
+    const { tx, ty, ta, tb, tc, td, clippingRect } = quad;
+    let texture = quad.texture;
+    const textureType = texture?.type;
+    assertTruthy(textureType, 'Texture type is not defined');
+
+    // The Canvas2D renderer only supports image and color textures
+    if (
+      textureType !== TextureType.image &&
+      textureType !== TextureType.color &&
+      textureType !== TextureType.subTexture &&
+      textureType !== TextureType.noise
+    ) {
+      return;
+    }
+
+    if (texture) {
+      if (texture instanceof SubTexture) {
+        texture = texture.parentTexture;
+      }
+
+      if (texture.state === 'freed') {
+        return;
+      }
+      if (texture.state !== 'loaded') {
+        return;
+      }
+    }
+
+    const hasTransform = ta !== 1;
+    const hasClipping = clippingRect.width !== 0 && clippingRect.height !== 0;
+    const hasShader = quad.shader !== null;
+
+    let saveAndRestore = hasTransform === true || hasClipping === true;
+    if (hasShader === true) {
+      saveAndRestore =
+        saveAndRestore || (quad.shader as CanvasShaderNode).applySNR;
+    }
+
+    if (saveAndRestore) {
+      ctx.save();
+    }
+
+    if (hasClipping === true) {
+      const path = new Path2D();
+      const { x, y, width, height } = clippingRect;
+      path.rect(x, y, width, height);
+      ctx.clip(path);
+    }
+
+    if (hasTransform === true) {
+      // Quad transform:
+      // | ta tb tx |
+      // | tc td ty |
+      // | 0  0  1  |
+      // C2D transform:
+      // | a  c  e  |
+      // | b  d  f  |
+      // | 0  0  1  |
+      const scale = this.pixelRatio;
+      ctx.setTransform(ta, tc, tb, td, tx * scale, ty * scale);
+      ctx.scale(scale, scale);
+      ctx.translate(-tx, -ty);
+    }
+
+    if (hasShader === true) {
+      let renderContext: (() => void) | null = () => {
+        this.renderContext(quad);
+      };
+      (quad.shader as CanvasShaderNode).render(ctx, quad, renderContext);
+      renderContext = null;
+    } else {
+      this.renderContext(quad);
+    }
+
+    if (saveAndRestore) {
+      ctx.restore();
+    }
+  }
+
+  renderContext(quad: QuadOptions) {
+    const color = quad.colorTl;
+    const textureType = quad.texture?.type;
+    if (
+      (textureType === TextureType.image ||
+        textureType === TextureType.subTexture ||
+        textureType === TextureType.noise) &&
+      quad.texture?.ctxTexture
+    ) {
+      const tintColor = parseColor(color);
+      const image = (quad.texture.ctxTexture as CanvasTexture).getImage(
+        tintColor,
+      );
+      this.context.globalAlpha = tintColor.a ?? quad.alpha;
+      if (textureType === TextureType.subTexture) {
+        this.context.drawImage(
+          image,
+          (quad.texture as SubTexture).props.x,
+          (quad.texture as SubTexture).props.y,
+          (quad.texture as SubTexture).props.width,
+          (quad.texture as SubTexture).props.height,
+          quad.tx,
+          quad.ty,
+          quad.width,
+          quad.height,
+        );
+      } else {
+        try {
+          this.context.drawImage(
+            image,
+            quad.tx,
+            quad.ty,
+            quad.width,
+            quad.height,
+          );
+          // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        } catch (error) {
+          // noop
+        }
+      }
+      this.context.globalAlpha = 1;
+      return;
+    }
+    const hasGradient =
+      quad.colorTl !== quad.colorTr || quad.colorTl !== quad.colorBr;
+    if (textureType === TextureType.color && hasGradient) {
+      let endX: number = quad.tx;
+      let endY: number = quad.ty;
+      let endColor: number;
+      if (quad.colorTl === quad.colorTr) {
+        // vertical
+        endX = quad.tx;
+        endY = quad.ty + quad.height;
+        endColor = quad.colorBr;
+      } else {
+        // horizontal
+        endX = quad.tx + quad.width;
+        endY = quad.ty;
+        endColor = quad.colorTr;
+      }
+      const gradient = this.context.createLinearGradient(
+        quad.tx,
+        quad.ty,
+        endX,
+        endY,
+      );
+      gradient.addColorStop(0, this.getParsedColor(color));
+      gradient.addColorStop(1, this.getParsedColor(endColor));
+      this.context.fillStyle = gradient;
+      this.context.fillRect(quad.tx, quad.ty, quad.width, quad.height);
+    } else if (textureType === TextureType.color) {
+      this.context.fillStyle = this.getParsedColor(color);
+      this.context.fillRect(quad.tx, quad.ty, quad.width, quad.height);
+    }
+  }
+
+  createShaderNode(
+    shaderKey: string,
+    shaderType: Readonly<CanvasShaderType>,
+    props?: Record<string, any>,
+  ) {
+    return new CanvasShaderNode(shaderKey, shaderType, this.stage, props);
+  }
+
+  createShaderProgram(shaderConfig) {
+    return null;
+  }
+
+  override supportsShaderType(shaderType: Readonly<CanvasShaderType>): boolean {
+    return shaderType.render !== undefined;
+  }
+
+  createCtxTexture(textureSource: Texture): CoreContextTexture {
+    return new CanvasTexture(this.stage.txMemManager, textureSource);
+  }
+
+  renderRTTNodes(): void {
+    // noop
+  }
+
+  removeRTTNode(node: CoreNode): void {
+    // noop
+  }
+
+  renderToTexture(node: CoreNode): void {
+    // noop
+  }
+  getBufferInfo(): null {
+    return null;
+  }
+
+  getQuadCount(): null {
+    return null;
+  }
+
+  getParsedColor(color: number, isRGBA: boolean = false) {
+    let out = this.parsedColorCache.get(color);
+    if (out !== undefined) {
+      return out;
+    }
+    if (isRGBA) {
+      out = parseToRgbaString(color);
+    } else {
+      out = parseToAbgrString(color);
+    }
+    this.parsedColorCache.set(color, out);
+    return out;
+  }
+
+  /**
+   * Updates the clear color of the canvas renderer.
+   *
+   * @param color - The color to set as the clear color.
+   */
+  updateClearColor(color: number) {
+    this.clearColor = this.getParsedColor(color);
+  }
+
+  override getDefaultShaderNode() {
+    return null;
+  }
+}

package/src/core/renderers/canvas/CanvasShaderNode.ts

@@ -0,0 +1,99 @@
+/*
+ * 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
+ */
+
+import type { CoreNode } from '../../CoreNode.js';
+import type { Stage } from '../../Stage.js';
+import type { QuadOptions } from '../CoreRenderer.js';
+import { CoreShaderNode, type CoreShaderType } from '../CoreShaderNode.js';
+import type { CanvasRenderer } from './CanvasRenderer.js';
+
+export type CanvasShaderType<
+  T extends object = Record<string, unknown>,
+  C extends object = Record<string, unknown>,
+> = CoreShaderType<T> & {
+  render: (
+    this: CanvasShaderNode<T, C>,
+    ctx: CanvasRenderingContext2D,
+    quad: QuadOptions,
+    renderContext: () => void,
+  ) => void;
+  update?: (this: CanvasShaderNode<T, C>, node: CoreNode) => void;
+  /**
+   * Set this to true when using ctx functions that scale, clip, rotate, etc..
+   */
+  saveAndRestore?: boolean;
+};
+
+export class CanvasShaderNode<
+  Props extends object = Record<string, unknown>,
+  Computed extends object = Record<string, unknown>,
+> extends CoreShaderNode<Props> {
+  private updater: ((node: CoreNode, props?: Props) => void) | undefined =
+    undefined;
+  private valueKey: string = '';
+  computed: Partial<Computed> = {};
+  applySNR: boolean;
+  render: CanvasShaderType<Props>['render'];
+
+  constructor(
+    shaderKey: string,
+    config: CanvasShaderType<Props>,
+    stage: Stage,
+    props?: Props,
+  ) {
+    super(shaderKey, config, stage, props);
+    this.applySNR = config.saveAndRestore || false;
+    this.render = config.render;
+    if (config.update !== undefined) {
+      this.updater = config.update!;
+      if (this.props === undefined) {
+        this.updater!(this.node as CoreNode, this.props);
+        return;
+      }
+
+      this.update = () => {
+        const prevKey = this.valueKey;
+        this.valueKey = '';
+        for (const key in this.resolvedProps) {
+          this.valueKey += `${key}:${this.resolvedProps[key]!};`;
+        }
+
+        if (prevKey === this.valueKey) {
+          return;
+        }
+
+        if (prevKey.length > 0) {
+          this.stage.shManager.mutateShaderValueUsage(prevKey, -1);
+        }
+
+        const computed = this.stage.shManager.getShaderValues(
+          this.valueKey,
+        ) as Record<string, unknown>;
+        if (computed !== undefined) {
+          this.computed = computed as Computed;
+        }
+        this.computed = {};
+        this.updater!(this.node as CoreNode);
+        this.stage.shManager.setShaderValues(this.valueKey, this.computed);
+      };
+    }
+  }
+
+  toColorString(rgba: number) {
+    return (this.stage.renderer as CanvasRenderer).getParsedColor(rgba, true);
+  }
+}

package/src/core/renderers/canvas/CanvasTexture.ts

@@ -0,0 +1,153 @@
+/*
+ * 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 { assertTruthy } from '../../../utils.js';
+import { CoreContextTexture } from '../CoreContextTexture.js';
+import { formatRgba, type IParsedColor } from './internal/ColorUtils.js';
+
+export class CanvasTexture extends CoreContextTexture {
+  protected image:
+    | ImageBitmap
+    | HTMLCanvasElement
+    | HTMLImageElement
+    | undefined;
+  protected tintCache:
+    | {
+        key: string;
+        image: HTMLCanvasElement;
+      }
+    | undefined;
+
+  load(): void {
+    this.textureSource.setState('loading');
+
+    this.onLoadRequest()
+      .then((size) => {
+        this.textureSource.setState('loaded', size);
+        this.textureSource.freeTextureData();
+        this.updateMemSize();
+      })
+      .catch((err) => {
+        this.textureSource.setState('failed', err as Error);
+        this.textureSource.freeTextureData();
+      });
+  }
+
+  free(): void {
+    this.image = undefined;
+    this.tintCache = undefined;
+    this.textureSource.setState('freed');
+    this.setTextureMemUse(0);
+    this.textureSource.freeTextureData();
+  }
+
+  updateMemSize(): void {
+    // Counting memory usage for:
+    // - main image
+    // - tinted image
+    const mult = this.tintCache ? 8 : 4;
+    if (this.textureSource.dimensions) {
+      const { width, height } = this.textureSource.dimensions;
+      this.setTextureMemUse(width * height * mult);
+    }
+  }
+
+  hasImage(): boolean {
+    return this.image !== undefined;
+  }
+
+  getImage(
+    color: IParsedColor,
+  ): ImageBitmap | HTMLCanvasElement | HTMLImageElement {
+    const image = this.image;
+    assertTruthy(image, 'Attempt to get unloaded image texture');
+
+    if (color.isWhite) {
+      if (this.tintCache) {
+        this.tintCache = undefined;
+        this.updateMemSize();
+      }
+      return image;
+    }
+    const key = formatRgba(color);
+    if (this.tintCache?.key === key) {
+      return this.tintCache.image;
+    }
+
+    const tintedImage = this.tintTexture(image, key);
+    this.tintCache = {
+      key,
+      image: tintedImage,
+    };
+    this.updateMemSize();
+    return tintedImage;
+  }
+
+  protected tintTexture(
+    source: ImageBitmap | HTMLCanvasElement | HTMLImageElement,
+    color: string,
+  ) {
+    const { width, height } = source;
+    const canvas = document.createElement('canvas');
+    canvas.width = width;
+    canvas.height = height;
+    const ctx = canvas.getContext('2d');
+    if (ctx) {
+      // fill with target color
+      ctx.fillStyle = color;
+      ctx.globalCompositeOperation = 'copy';
+      ctx.fillRect(0, 0, width, height);
+
+      // multiply with image, resulting in non-transparent tinted image
+      ctx.globalCompositeOperation = 'multiply';
+      ctx.drawImage(source, 0, 0, width, height, 0, 0, width, height);
+
+      // apply original image alpha
+      ctx.globalCompositeOperation = 'destination-in';
+      ctx.drawImage(source, 0, 0, width, height, 0, 0, width, height);
+    }
+    return canvas;
+  }
+
+  private async onLoadRequest(): Promise<Dimensions> {
+    assertTruthy(this.textureSource?.textureData?.data, 'Texture data is null');
+    const { data } = this.textureSource.textureData;
+
+    // TODO: canvas from text renderer should be able to provide the canvas directly
+    // instead of having to re-draw it into a new canvas...
+    if (data instanceof ImageData) {
+      const canvas = document.createElement('canvas');
+      canvas.width = data.width;
+      canvas.height = data.height;
+      const ctx = canvas.getContext('2d');
+      if (ctx) ctx.putImageData(data, 0, 0);
+      this.image = canvas;
+      return { width: data.width, height: data.height };
+    } else if (
+      (typeof ImageBitmap !== 'undefined' && data instanceof ImageBitmap) ||
+      data instanceof HTMLImageElement
+    ) {
+      this.image = data;
+      return { width: data.width, height: data.height };
+    }
+
+    return { width: 0, height: 0 };
+  }
+}