@lightningjs/renderer 3.0.0-beta9 → 3.0.1

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

@@ -1,99 +1,96 @@
-/*
- * 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.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, node, renderContext) {
+    renderContext();
+    const { scaleX, scaleY, pivotX, pivotY, colors, size } = this
+      .computed as ComputedRadialGradientValues;
+    const { tx, ty } = node.globalTransform!;
+    const { w, h } = node.props;
+    let x = tx + pivotX;
+    let y = 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(tx, ty, w, h);
+      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(tx / scaleX, ty / scaleY, w / scaleX, h / scaleY);
+
+    ctx.restore();
+  },
+};

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

@@ -1,55 +1,55 @@
-/*
- * 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 {
-  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.width,
-      node.height,
-    );
-  },
-  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();
-  },
-};
+/*
+ * 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 {
+  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, node, renderContext) {
+    const path = new Path2D();
+    roundRect(
+      path,
+      node.globalTransform!.tx,
+      node.globalTransform!.ty,
+      node.props.w,
+      node.props.h,
+      this.computed.radius!,
+    );
+    ctx.clip(path);
+
+    renderContext();
+  },
+};

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

@@ -1,74 +1,122 @@
-/*
- * 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, 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';
-
-type ComputedValues = ComputedRoundedValues & ComputedBorderValues;
-
-export const RoundedWithBorder: CanvasShaderType<
-  RoundedWithBorderProps,
-  ComputedValues
-> = {
-  props: RoundedWithBorderTemplate.props,
-  saveAndRestore: true,
-  update(node) {
-    const props = this.props!;
-    const radius = calcFactoredRadiusArray(
-      props.radius as Vec4,
-      node.width,
-      node.height,
-    );
-    this.computed.radius = radius;
-    this.computed.borderColor = this.toColorString(props['border-color']);
-    this.computed.borderAsym = !valuesAreEqual(
-      props['border-width'] as number[],
-    );
-    //following vec4 convention 0, 1, 2, 3 => x, y, z, w;
-    const [x, y, z, w] = props['border-width'] as Vec4;
-    this.computed.borderRadius = [
-      Math.max(0.0, radius[0] - Math.max(x, w) * 0.5),
-      Math.max(0.0, radius[1] - Math.max(x, y) * 0.5),
-      Math.max(0.0, radius[2] - Math.max(z, y) * 0.5),
-      Math.max(0.0, radius[3] - Math.max(z, w) * 0.5),
-    ];
-  },
-  render(ctx, quad, renderContext) {
-    const computed = this.computed as ComputedValues;
-    roundedRectWithBorder(
-      ctx,
-      quad.tx,
-      quad.ty,
-      quad.width,
-      quad.height,
-      computed.radius,
-      this.props!['border-width'] as Vec4,
-      computed.borderRadius,
-      computed.borderColor,
-      computed.borderAsym,
-      renderContext,
-    );
-  },
-};
+/*
+ * 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, 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, node, renderContext) {
+    const computed = this.computed as ComputedRoundedWithBorderValues;
+    roundedRectWithBorder(
+      ctx,
+      node.globalTransform!.tx,
+      node.globalTransform!.ty,
+      node.props.w,
+      node.props.h,
+      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,
+    );
+  },
+};