@lightningjs/renderer 3.0.0-beta10 → 3.0.0-beta11

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

@@ -1,75 +1,75 @@
-/*
- * 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 { 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';
-import { strokeLine } from './utils/render.js';
-
-export interface ComputedBorderValues {
-  borderColor: string;
-  borderAsym: boolean;
-  borderRadius: Vec4;
-}
-
-export const Border: CanvasShaderType<BorderProps, ComputedBorderValues> = {
-  props: BorderTemplate.props,
-  update() {
-    this.computed.borderColor = formatRgba(parseColorRgba(this.props!.color));
-    this.computed.borderAsym = !valuesAreEqual(this.props!.width as number[]);
-  },
-  render(ctx, quad, renderContext) {
-    renderContext();
-    ctx.strokeStyle = this.computed.borderColor!;
-    if (this.computed.borderAsym === false && this.props!.width[0] > 0) {
-      const bWidth = this.props!.width[0];
-      const bHalfWidth = bWidth * 0.5;
-      ctx.lineWidth = bWidth;
-      ctx.beginPath();
-      ctx.strokeRect(
-        quad.tx + bHalfWidth,
-        quad.ty + bHalfWidth,
-        quad.width - bWidth,
-        quad.height - bWidth,
-      );
-      return;
-    }
-
-    const { 0: t, 1: r, 2: b, 3: l } = this.props!.width as Vec4;
-    if (t > 0) {
-      const y = quad.ty + t * 0.5;
-      strokeLine(ctx, quad.tx, y, quad.tx + quad.width, y, t);
-    }
-    if (r > 0) {
-      const x = quad.tx + quad.width - r * 0.5;
-      strokeLine(ctx, x, quad.ty, x, quad.ty + quad.height, r);
-    }
-    if (b > 0) {
-      const y = quad.ty + quad.height - b * 0.5;
-      strokeLine(ctx, quad.tx, y, quad.tx + quad.width, y, b);
-    }
-    if (l > 0) {
-      const x = quad.tx + l * 0.5;
-      strokeLine(ctx, x, quad.ty, x, quad.ty + quad.height, l);
-    }
-  },
-};
+/*
+ * 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 { 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';
+import { strokeLine } from './utils/render.js';
+
+export interface ComputedBorderValues {
+  borderColor: string;
+  borderAsym: boolean;
+  borderRadius: Vec4;
+}
+
+export const Border: CanvasShaderType<BorderProps, ComputedBorderValues> = {
+  props: BorderTemplate.props,
+  update() {
+    this.computed.borderColor = formatRgba(parseColorRgba(this.props!.color));
+    this.computed.borderAsym = !valuesAreEqual(this.props!.width as number[]);
+  },
+  render(ctx, quad, renderContext) {
+    renderContext();
+    ctx.strokeStyle = this.computed.borderColor!;
+    if (this.computed.borderAsym === false && this.props!.width[0] > 0) {
+      const bWidth = this.props!.width[0];
+      const bHalfWidth = bWidth * 0.5;
+      ctx.lineWidth = bWidth;
+      ctx.beginPath();
+      ctx.strokeRect(
+        quad.tx + bHalfWidth,
+        quad.ty + bHalfWidth,
+        quad.width - bWidth,
+        quad.height - bWidth,
+      );
+      return;
+    }
+
+    const { 0: t, 1: r, 2: b, 3: l } = this.props!.width as Vec4;
+    if (t > 0) {
+      const y = quad.ty + t * 0.5;
+      strokeLine(ctx, quad.tx, y, quad.tx + quad.width, y, t);
+    }
+    if (r > 0) {
+      const x = quad.tx + quad.width - r * 0.5;
+      strokeLine(ctx, x, quad.ty, x, quad.ty + quad.height, r);
+    }
+    if (b > 0) {
+      const y = quad.ty + quad.height - b * 0.5;
+      strokeLine(ctx, quad.tx, y, quad.tx + quad.width, y, b);
+    }
+    if (l > 0) {
+      const x = quad.tx + l * 0.5;
+      strokeLine(ctx, x, quad.ty, x, quad.ty + quad.height, l);
+    }
+  },
+};

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

@@ -1,62 +1,62 @@
-/*
- * 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 { 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!.width,
-      this.props!.height,
-    );
-  },
-  render(ctx, quad, renderContext) {
-    ctx.save();
-    renderContext();
-    const { x, y, width, height } = this.props!;
-    ctx.beginPath();
-    roundRect(
-      ctx,
-      quad.tx + x,
-      quad.ty + y,
-      width,
-      height,
-      this.computed.radius!,
-    );
-    ctx.closePath();
-    ctx.fillStyle = 'black';
-    ctx.globalCompositeOperation = 'destination-out';
-    ctx.fill();
-    ctx.restore();
-  },
-};
+/*
+ * 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 { 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!.width,
+      this.props!.height,
+    );
+  },
+  render(ctx, quad, renderContext) {
+    ctx.save();
+    renderContext();
+    const { x, y, width, height } = this.props!;
+    ctx.beginPath();
+    roundRect(
+      ctx,
+      quad.tx + x,
+      quad.ty + y,
+      width,
+      height,
+      this.computed.radius!,
+    );
+    ctx.closePath();
+    ctx.fillStyle = 'black';
+    ctx.globalCompositeOperation = 'destination-out';
+    ctx.fill();
+    ctx.restore();
+  },
+};

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

@@ -1,71 +1,71 @@
-/*
- * 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 { 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.width;
-    const nHeight = node.height;
-    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);
-  },
-};
+/*
+ * 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 { 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.width;
+    const nHeight = node.height;
+    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

@@ -1,99 +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 { 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.width;
-    const pHeight = props.height;
-    if (pWidth > pHeight) {
-      scaleX = pWidth / pHeight;
-    } else if (pHeight > pWidth) {
-      scaleY = pHeight / pWidth;
-    }
-
-    this.computed = {
-      pivotX: props.pivot[0] * node.width,
-      pivotY: props.pivot[1] * node.height,
-      scaleX,
-      scaleY,
-      size: Math.min(pWidth, pHeight) * 0.5,
-      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();
-  },
-};
+/*
+ * 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 { 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.width;
+    const pHeight = props.height;
+    if (pWidth > pHeight) {
+      scaleX = pWidth / pHeight;
+    } else if (pHeight > pWidth) {
+      scaleY = pHeight / pWidth;
+    }
+
+    this.computed = {
+      pivotX: props.pivot[0] * node.width,
+      pivotY: props.pivot[1] * node.height,
+      scaleX,
+      scaleY,
+      size: Math.min(pWidth, pHeight) * 0.5,
+      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();
+  },
+};