@lightningtv/renderer 2.16.1 → 3.2.3

package/src/core/shaders/canvas/Border.ts

@@ -0,0 +1,119 @@
+import { formatRgba, parseColorRgba } from '../../lib/colorParser.js';
+import { valuesAreEqual } from '../../lib/utils.js';
+import type { CanvasShaderType } from '../../renderers/canvas/CanvasShaderNode.js';
+import type { Vec4 } from '../../renderers/webgl/internal/ShaderUtils.js';
+import {
+  BorderTemplate,
+  type BorderProps,
+} from '../templates/BorderTemplate.js';
+
+export interface ComputedBorderValues {
+  borderColor: string;
+  borderAsym: boolean;
+  innerX: number;
+  innerY: number;
+  innerW: number;
+  innerH: number;
+  outerX: number;
+  outerY: number;
+  outerW: number;
+  outerH: number;
+}
+
+export const Border: CanvasShaderType<BorderProps, ComputedBorderValues> = {
+  props: BorderTemplate.props,
+  update() {
+    this.computed.borderColor = formatRgba(parseColorRgba(this.props!.color));
+    this.computed.borderAsym = !valuesAreEqual(this.props!.w as number[]);
+    const borderAlign = this.props!.align as number;
+    const borderGap = this.props!.gap as number;
+
+    const borderW = this.props!.w as Vec4;
+
+    if (this.computed.borderAsym === false) {
+      const bWidth = borderW[0] * 0.5;
+      //inside
+      const baseline = bWidth - borderW[0] * borderAlign - borderGap;
+      this.computed.outerX = baseline;
+      this.computed.outerY = baseline;
+
+      this.computed.outerW = -baseline * 2;
+      this.computed.outerH = -baseline * 2;
+      return;
+    }
+
+    // Calculate outer and inner rectangle dimensions
+    const [t, r, b, l] = this.props!.w as Vec4;
+
+    const outerX = (this.computed.outerX = -l * borderAlign - borderGap);
+    const outerY = (this.computed.outerY = -t * borderAlign - borderGap);
+    let outerW = 0;
+    let outerH = 0;
+
+    if (r > 0) {
+      outerW += r * borderAlign + borderGap;
+    }
+    if (l > 0) {
+      outerW += l * borderAlign + borderGap;
+    }
+
+    if (b > 0) {
+      outerH += b * borderAlign + borderGap;
+    }
+    if (t > 0) {
+      outerH += t * borderAlign + borderGap;
+    }
+
+    this.computed.outerW = outerW;
+    this.computed.outerH = outerH;
+
+    this.computed.innerX = outerX + l;
+    this.computed.innerY = outerY + t;
+    this.computed.innerW = outerW - l - r;
+    this.computed.innerH = outerH - t - b;
+  },
+  render(ctx, quad, renderContext) {
+    renderContext();
+    const computed = this.computed as ComputedBorderValues;
+    ctx.strokeStyle = computed.borderColor!;
+    if (computed.borderAsym === false && this.props!.w[0] > 0) {
+      ctx.lineWidth = this.props!.w[0];
+      ctx.beginPath();
+      ctx.strokeRect(
+        quad.tx + computed.outerX,
+        quad.ty + computed.outerY,
+        quad.width + computed.outerW,
+        quad.height + computed.outerH,
+      );
+      return;
+    }
+
+    // Pre-calculate common values
+    const tx = quad.tx;
+    const ty = quad.ty;
+    const width = quad.width;
+    const height = quad.height;
+
+    // Calculate outer rectangle (including border)
+    const outerX = tx + computed.outerX;
+    const outerY = ty + computed.outerY;
+    const outerW = width + computed.outerW;
+    const outerH = height + computed.outerH;
+
+    // Calculate inner rectangle (excluding border)
+    const innerX = tx + computed.innerX;
+    const innerY = ty + computed.innerY;
+    const innerW = width + computed.innerW;
+    const innerH = height + computed.innerH;
+
+    // Use clip to subtract inner from outer
+    ctx.save();
+    ctx.beginPath();
+    ctx.rect(outerX, outerY, outerW, outerH);
+    ctx.rect(innerX, innerY, innerW, innerH);
+    ctx.clip('evenodd');
+    ctx.fillStyle = this.computed.borderColor!;
+    ctx.fillRect(outerX, outerY, outerW, outerH);
+    ctx.restore();
+  },
+};

package/src/core/shaders/canvas/HolePunch.ts

@@ -0,0 +1,38 @@
+import { calcFactoredRadiusArray } from '../../lib/utils.js';
+import type { CanvasShaderType } from '../../renderers/canvas/CanvasShaderNode.js';
+import type { Vec4 } from '../../renderers/webgl/internal/ShaderUtils.js';
+import {
+  HolePunchTemplate,
+  type HolePunchProps,
+} from '../templates/HolePunchTemplate.js';
+import { roundRect } from './utils/render.js';
+
+export interface ComputedHolePunchValues {
+  radius: Vec4;
+}
+
+export const HolePunch: CanvasShaderType<
+  HolePunchProps,
+  ComputedHolePunchValues
+> = {
+  props: HolePunchTemplate.props,
+  update() {
+    this.computed.radius = calcFactoredRadiusArray(
+      this.props!.radius as Vec4,
+      this.props!.w,
+      this.props!.h,
+    );
+  },
+  render(ctx, quad, renderContext) {
+    ctx.save();
+    renderContext();
+    const { x, y, w, h } = this.props!;
+    ctx.beginPath();
+    roundRect(ctx, quad.tx + x, quad.ty + y, w, h, this.computed.radius!);
+    ctx.closePath();
+    ctx.fillStyle = 'black';
+    ctx.globalCompositeOperation = 'destination-out';
+    ctx.fill();
+    ctx.restore();
+  },
+};

package/src/core/shaders/canvas/LinearGradient.ts

@@ -0,0 +1,54 @@
+import type { CanvasShaderType } from '../../renderers/canvas/CanvasShaderNode.js';
+import {
+  LinearGradientTemplate,
+  type LinearGradientProps,
+} from '../templates/LinearGradientTemplate.js';
+
+export interface ComputedLinearGradientValues {
+  x0: number;
+  y0: number;
+  x1: number;
+  y1: number;
+  colors: string[];
+}
+
+export const LinearGradient: CanvasShaderType<
+  LinearGradientProps,
+  ComputedLinearGradientValues
+> = {
+  props: LinearGradientTemplate.props,
+  update(node) {
+    const angle = this.props!.angle - (Math.PI / 180) * 90;
+    const nWidth = node.w;
+    const nHeight = node.h;
+    const line =
+      (Math.abs(nWidth * Math.sin(angle)) +
+        Math.abs(nHeight * Math.cos(angle))) *
+      0.5;
+
+    this.computed = {
+      x0: line * Math.cos(angle) + nWidth * 0.5,
+      y0: line * Math.sin(angle) + nHeight * 0.5,
+      x1: line * Math.cos(angle + Math.PI) + nWidth * 0.5,
+      y1: line * Math.sin(angle + Math.PI) + nHeight * 0.5,
+      colors: this.props!.colors.map((value) => this.toColorString(value)),
+    };
+  },
+  render(ctx, quad, renderContext) {
+    renderContext();
+    const computed = this.computed as ComputedLinearGradientValues;
+    const gradient = ctx.createLinearGradient(
+      quad.tx + computed.x0,
+      quad.ty + computed.y0,
+      quad.tx + computed.x1,
+      quad.ty + computed.y1,
+    );
+    const colors = computed.colors;
+    const stops = this.props!.stops;
+    for (let i = 0; i < colors.length; i++) {
+      gradient.addColorStop(stops[i]!, colors[i]!);
+    }
+    ctx.fillStyle = gradient;
+    ctx.fillRect(quad.tx, quad.ty, quad.width, quad.height);
+  },
+};

package/src/core/shaders/canvas/RadialGradient.ts

@@ -0,0 +1,82 @@
+import type { CanvasShaderType } from '../../renderers/canvas/CanvasShaderNode.js';
+import {
+  RadialGradientTemplate,
+  type RadialGradientProps,
+} from '../templates/RadialGradientTemplate.js';
+
+export interface ComputedRadialGradientValues {
+  pivotX: number;
+  pivotY: number;
+  scaleX: number;
+  scaleY: number;
+  size: number;
+  colors: string[];
+}
+
+export const RadialGradient: CanvasShaderType<
+  RadialGradientProps,
+  ComputedRadialGradientValues
+> = {
+  props: RadialGradientTemplate.props,
+  update(node) {
+    let scaleX = 1;
+    let scaleY = 1;
+    const props = this.props as RadialGradientProps;
+    const pWidth = props.w;
+    const pHeight = props.h;
+    if (pWidth > pHeight) {
+      scaleX = pWidth / pHeight;
+    } else if (pHeight > pWidth) {
+      scaleY = pHeight / pWidth;
+    }
+
+    this.computed = {
+      pivotX: props.pivot[0] * node.w,
+      pivotY: props.pivot[1] * node.h,
+      scaleX,
+      scaleY,
+      size: Math.min(pWidth, pHeight),
+      colors: props.colors.map((value) => this.toColorString(value)),
+    };
+  },
+  render(ctx, quad, renderContext) {
+    renderContext();
+    const { scaleX, scaleY, pivotX, pivotY, colors, size } = this
+      .computed as ComputedRadialGradientValues;
+    let x = quad.tx + pivotX;
+    let y = quad.ty + pivotY;
+    const stops = this.props!.stops;
+
+    if (scaleX === scaleY) {
+      const gradient = ctx.createRadialGradient(x, y, 0, x, y, size);
+
+      for (let i = 0; i < colors.length; i++) {
+        gradient.addColorStop(stops[i]!, colors[i]!);
+      }
+
+      ctx.fillStyle = gradient;
+      ctx.fillRect(quad.tx, quad.ty, quad.width, quad.height);
+      return;
+    }
+
+    ctx.save();
+    ctx.scale(scaleX, scaleY);
+    x = x / scaleX;
+    y = y / scaleY;
+    const gradient = ctx.createRadialGradient(x, y, 0, x, y, size);
+
+    for (let i = 0; i < colors.length; i++) {
+      gradient.addColorStop(stops[i]!, colors[i]!);
+    }
+
+    ctx.fillStyle = gradient;
+    ctx.fillRect(
+      quad.tx / scaleX,
+      quad.ty / scaleY,
+      quad.width / scaleX,
+      quad.height / scaleY,
+    );
+
+    ctx.restore();
+  },
+};

package/src/core/shaders/canvas/Rounded.ts

@@ -0,0 +1,38 @@
+import { calcFactoredRadiusArray } from '../../lib/utils.js';
+import type { CanvasShaderType } from '../../renderers/canvas/CanvasShaderNode.js';
+import type { Vec4 } from '../../renderers/webgl/internal/ShaderUtils.js';
+import {
+  RoundedTemplate,
+  type RoundedProps,
+} from '../templates/RoundedTemplate.js';
+import { roundRect } from './utils/render.js';
+
+export interface ComputedRoundedValues {
+  radius: Vec4;
+}
+
+export const Rounded: CanvasShaderType<RoundedProps, ComputedRoundedValues> = {
+  props: RoundedTemplate.props,
+  saveAndRestore: true,
+  update(node) {
+    this.computed.radius = calcFactoredRadiusArray(
+      this.props!.radius as Vec4,
+      node.w,
+      node.h,
+    );
+  },
+  render(ctx, quad, renderContext) {
+    const path = new Path2D();
+    roundRect(
+      path,
+      quad.tx,
+      quad.ty,
+      quad.width,
+      quad.height,
+      this.computed.radius!,
+    );
+    ctx.clip(path);
+
+    renderContext();
+  },
+};

package/src/core/shaders/canvas/RoundedWithBorder.ts

@@ -0,0 +1,105 @@
+import { calcFactoredRadiusArray, valuesAreEqual } from '../../lib/utils.js';
+import type { CanvasShaderType } from '../../renderers/canvas/CanvasShaderNode.js';
+import type { Vec4 } from '../../renderers/webgl/internal/ShaderUtils.js';
+import {
+  RoundedWithBorderTemplate,
+  type RoundedWithBorderProps,
+} from '../templates/RoundedWithBorderTemplate.js';
+import type { ComputedBorderValues } from './Border.js';
+import type { ComputedRoundedValues } from './Rounded.js';
+import { roundedRectWithBorder } from './utils/render.js';
+
+export type ComputedRoundedWithBorderValues = ComputedRoundedValues &
+  ComputedBorderValues & {
+    outerBorderRadius: Vec4;
+    innerBorderRadius: Vec4;
+  };
+
+export const RoundedWithBorder: CanvasShaderType<
+  RoundedWithBorderProps,
+  ComputedRoundedWithBorderValues
+> = {
+  props: RoundedWithBorderTemplate.props,
+  saveAndRestore: true,
+  update(node) {
+    const props = this.props!;
+    const radius = calcFactoredRadiusArray(
+      props.radius as Vec4,
+      node.w,
+      node.h,
+    );
+    this.computed.radius = radius;
+    this.computed.borderColor = this.toColorString(props['border-color']);
+    this.computed.borderAsym = !valuesAreEqual(props['border-w'] as number[]);
+    const borderAlign = this.props!['border-align'] as number;
+    const borderGap = this.props!['border-gap'] as number;
+
+    // Calculate outer and inner rectangle dimensions
+    const [t, r, b, l] = this.props!['border-w'] as Vec4;
+
+    const outerX = (this.computed.outerX = -l * borderAlign - borderGap);
+    const outerY = (this.computed.outerY = -t * borderAlign - borderGap);
+    let outerW = 0;
+    let outerH = 0;
+
+    if (r > 0) {
+      outerW += r * borderAlign + borderGap;
+    }
+    if (l > 0) {
+      outerW += l * borderAlign + borderGap;
+    }
+
+    if (b > 0) {
+      outerH += b * borderAlign + borderGap;
+    }
+    if (t > 0) {
+      outerH += t * borderAlign + borderGap;
+    }
+
+    this.computed.outerW = outerW;
+    this.computed.outerH = outerH;
+
+    this.computed.innerX = outerX + l;
+    this.computed.innerY = outerY + t;
+    this.computed.innerW = outerW - l - r;
+    this.computed.innerH = outerH - t - b;
+
+    this.computed.outerBorderRadius = [
+      Math.max(0.0, radius[0] + (Math.max(l, r) * borderAlign + borderGap)),
+      Math.max(0.0, radius[1] + (Math.max(t, b) * borderAlign + borderGap)),
+      Math.max(0.0, radius[2] + (Math.max(b, t) * borderAlign + borderGap)),
+      Math.max(0.0, radius[3] + (Math.max(l, r) * borderAlign + borderGap)),
+    ];
+
+    this.computed.innerBorderRadius = [
+      Math.max(0.0, this.computed.outerBorderRadius[0] - Math.max(l, r)),
+      Math.max(0.0, this.computed.outerBorderRadius[1] - Math.max(t, b)),
+      Math.max(0.0, this.computed.outerBorderRadius[2] - Math.max(b, t)),
+      Math.max(0.0, this.computed.outerBorderRadius[3] - Math.max(l, r)),
+    ];
+  },
+  render(ctx, quad, renderContext) {
+    const computed = this.computed as ComputedRoundedWithBorderValues;
+    roundedRectWithBorder(
+      ctx,
+      quad.tx,
+      quad.ty,
+      quad.width,
+      quad.height,
+      computed.radius,
+      this.props!['border-gap'] as number,
+      computed.outerX,
+      computed.outerY,
+      computed.outerW,
+      computed.outerH,
+      computed.outerBorderRadius,
+      computed.innerX,
+      computed.innerY,
+      computed.innerW,
+      computed.innerH,
+      computed.innerBorderRadius,
+      computed.borderColor,
+      renderContext,
+    );
+  },
+};

package/src/core/shaders/canvas/RoundedWithBorderAndShadow.ts

@@ -0,0 +1,118 @@
+import { calcFactoredRadiusArray, valuesAreEqual } from '../../lib/utils.js';
+import type { CanvasShaderType } from '../../renderers/canvas/CanvasShaderNode.js';
+import type { Vec4 } from '../../renderers/webgl/internal/ShaderUtils.js';
+import {
+  RoundedWithBorderAndShadowTemplate,
+  type RoundedWithBorderAndShadowProps,
+} from '../templates/RoundedWithBorderAndShadowTemplate.js';
+import type { ComputedRoundedWithBorderValues } from './RoundedWithBorder.js';
+import type { ComputedShadowValues } from './Shadow.js';
+import * as render from './utils/render.js';
+
+type ComputedValues = ComputedRoundedWithBorderValues & ComputedShadowValues;
+
+export const RoundedWithBorderAndShadow: CanvasShaderType<
+  RoundedWithBorderAndShadowProps,
+  ComputedValues
+> = {
+  props: RoundedWithBorderAndShadowTemplate.props,
+  saveAndRestore: true,
+  update(node) {
+    const props = this.props!;
+    const radius = calcFactoredRadiusArray(
+      props.radius as Vec4,
+      node.w,
+      node.h,
+    );
+    this.computed.radius = radius;
+    this.computed.borderColor = this.toColorString(props['border-color']);
+    this.computed.borderAsym = !valuesAreEqual(props['border-w'] as number[]);
+    const borderAlign = this.props!['border-align'] as number;
+    const borderGap = this.props!['border-gap'] as number;
+
+    // Calculate outer and inner rectangle dimensions
+    const [t, r, b, l] = this.props!['border-w'] as Vec4;
+
+    const outerX = (this.computed.outerX = -l * borderAlign - borderGap);
+    const outerY = (this.computed.outerY = -t * borderAlign - borderGap);
+    let outerW = 0;
+    let outerH = 0;
+
+    if (r > 0) {
+      outerW += r * borderAlign + borderGap;
+    }
+    if (l > 0) {
+      outerW += l * borderAlign + borderGap;
+    }
+
+    if (b > 0) {
+      outerH += b * borderAlign + borderGap;
+    }
+    if (t > 0) {
+      outerH += t * borderAlign + borderGap;
+    }
+
+    this.computed.outerW = outerW;
+    this.computed.outerH = outerH;
+
+    this.computed.innerX = outerX + l;
+    this.computed.innerY = outerY + t;
+    this.computed.innerW = outerW - l - r;
+    this.computed.innerH = outerH - t - b;
+
+    this.computed.outerBorderRadius = [
+      Math.max(0.0, radius[0] + (Math.max(l, r) * borderAlign + borderGap)),
+      Math.max(0.0, radius[1] + (Math.max(t, b) * borderAlign + borderGap)),
+      Math.max(0.0, radius[2] + (Math.max(b, t) * borderAlign + borderGap)),
+      Math.max(0.0, radius[3] + (Math.max(l, r) * borderAlign + borderGap)),
+    ];
+
+    this.computed.innerBorderRadius = [
+      Math.max(0.0, this.computed.outerBorderRadius[0] - Math.max(l, r)),
+      Math.max(0.0, this.computed.outerBorderRadius[1] - Math.max(t, b)),
+      Math.max(0.0, this.computed.outerBorderRadius[2] - Math.max(b, t)),
+      Math.max(0.0, this.computed.outerBorderRadius[3] - Math.max(l, r)),
+    ];
+
+    this.computed.shadowColor = this.toColorString(props['shadow-color']);
+    this.computed.shadowRadius = this.computed.outerBorderRadius.map(
+      (value) => value + props['shadow-blur'],
+    ) as Vec4;
+  },
+  render(ctx, quad, renderContext) {
+    const { tx, ty, width, height } = quad;
+    const computed = this.computed as ComputedValues;
+    render.shadow(
+      ctx,
+      tx + computed.outerX,
+      ty + computed.outerY,
+      height + computed.outerH,
+      width + computed.outerW,
+      computed.shadowColor,
+      this.props!['shadow-projection'],
+      computed.shadowRadius,
+      this.stage.pixelRatio,
+    );
+    render.roundedRectWithBorder(
+      ctx,
+      quad.tx,
+      quad.ty,
+      quad.width,
+      quad.height,
+      computed.radius,
+      this.props!['border-gap'] as number,
+      computed.outerX,
+      computed.outerY,
+      computed.outerW,
+      computed.outerH,
+      computed.outerBorderRadius,
+      computed.innerX,
+      computed.innerY,
+      computed.innerW,
+      computed.innerH,
+      computed.innerBorderRadius,
+      computed.borderColor,
+      renderContext,
+    );
+  },
+};

package/src/core/shaders/canvas/RoundedWithShadow.ts

@@ -0,0 +1,56 @@
+import { calcFactoredRadiusArray } from '../../lib/utils.js';
+import type { CanvasShaderType } from '../../renderers/canvas/CanvasShaderNode.js';
+import type { Vec4 } from '../../renderers/webgl/internal/ShaderUtils.js';
+import {
+  RoundedWithShadowTemplate,
+  type RoundedWithShadowProps,
+} from '../templates/RoundedWithShadowTemplate.js';
+import type { ComputedRoundedValues } from './Rounded.js';
+import type { ComputedShadowValues } from './Shadow.js';
+import * as render from './utils/render.js';
+
+type ComputedValues = ComputedRoundedValues & ComputedShadowValues;
+
+export const RoundedWithShadow: CanvasShaderType<
+  RoundedWithShadowProps,
+  ComputedValues
+> = {
+  props: RoundedWithShadowTemplate.props,
+  saveAndRestore: true,
+  update(node) {
+    const props = this.props!;
+    const radius = calcFactoredRadiusArray(
+      props.radius as Vec4,
+      node.w,
+      node.h,
+    );
+    this.computed.radius = radius;
+    this.computed.shadowColor = this.toColorString(props['shadow-color']);
+    this.computed.shadowRadius = radius.map(
+      (value) => value + props['shadow-blur'],
+    ) as Vec4;
+  },
+  render(ctx, quad, renderContext) {
+    const { tx, ty, width, height } = quad;
+    const computed = this.computed as ComputedValues;
+
+    if (this.props!['shadow-color'] !== 0) {
+      render.shadow(
+        ctx,
+        tx,
+        ty,
+        width,
+        height,
+        computed.shadowColor,
+        this.props!['shadow-projection'],
+        computed.shadowRadius,
+        this.stage.pixelRatio,
+      );
+    }
+
+    const path = new Path2D();
+    render.roundRect(path, tx, ty, width, height, computed.radius);
+    ctx.clip(path);
+    renderContext();
+  },
+};

package/src/core/shaders/canvas/Shadow.ts

@@ -0,0 +1,35 @@
+import type { CanvasShaderType } from '../../renderers/canvas/CanvasShaderNode.js';
+import type { Vec4 } from '../../renderers/webgl/internal/ShaderUtils.js';
+import {
+  ShadowTemplate,
+  type ShadowProps,
+} from '../templates/ShadowTemplate.js';
+import { shadow } from './utils/render.js';
+
+export interface ComputedShadowValues {
+  shadowColor: string;
+  shadowRadius: Vec4;
+}
+
+export const Shadow: CanvasShaderType<ShadowProps, ComputedShadowValues> = {
+  props: ShadowTemplate.props,
+  update() {
+    this.computed.shadowColor = this.toColorString(this.props!['color']);
+    const blur = this.props!['blur'];
+    this.computed.shadowRadius = [blur, blur, blur, blur];
+  },
+  render(ctx, quad, renderContext) {
+    shadow(
+      ctx,
+      quad.tx,
+      quad.ty,
+      quad.width,
+      quad.height,
+      this.computed.shadowColor!,
+      this.props!['projection'],
+      this.computed.shadowRadius!,
+      this.stage.pixelRatio,
+    );
+    renderContext();
+  },
+};