@lightningjs/renderer 2.13.0 → 3.0.0-beta1

package/src/core/renderers/webgl/shaders/effects/RadiusEffect.ts

@@ -1,110 +0,0 @@
-/*
- * 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 { updateWebSafeRadius, validateArrayLength4 } from './EffectUtils.js';
-import {
-  ShaderEffect,
-  type DefaultEffectProps,
-  type ShaderEffectUniforms,
-} from './ShaderEffect.js';
-
-/**
- * Properties of the {@link RadiusEffect} shader
- */
-export interface RadiusEffectProps extends DefaultEffectProps {
-  /**
-   * Corner radius, in pixels, to cut out of the corners
-   *
-   * @remarks
-   * You can input an array with a length of up to four or a number.
-   *
-   * array length 4:
-   * [topLeft, topRight, bottomRight, bottomLeft]
-   *
-   * array length 2:
-   * [20, 40] -> [20(topLeft), 40(topRight), 20(bottomRight), 40(bottomLeft)]
-   *
-   * array length 3:
-   * [20, 40, 60] -> [20(topLeft), 40(topRight), 60(bottomRight), 20(bottomLeft)]
-   *
-   * number:
-   * 30 -> [30, 30, 30, 30]
-   *
-   * @default 10
-   */
-  radius?: number | number[];
-}
-
-/**
- * Masks the current maskcolor with rounded corners similar to {@link RoundedRectangle}
- */
-export class RadiusEffect extends ShaderEffect {
-  static z$__type__Props: RadiusEffectProps;
-  override readonly name = 'radius';
-
-  static override getEffectKey(): string {
-    return `radius`;
-  }
-
-  static override uniforms: ShaderEffectUniforms = {
-    radius: {
-      value: 0,
-      method: 'uniform4fv',
-      type: 'vec4',
-      updateOnBind: true,
-      validator: validateArrayLength4,
-      updateProgramValue: updateWebSafeRadius,
-    },
-  };
-
-  static override methods: Record<string, string> = {
-    fillMask: `
-      float function(float dist) {
-        return clamp(-dist, 0.0, 1.0);
-      }
-    `,
-    boxDist: `
-      float function(vec2 p, vec2 size, float radius) {
-        size -= vec2(radius);
-        vec2 d = abs(p) - size;
-        return min(max(d.x, d.y), 0.0) + length(max(d, 0.0)) - radius;
-      }
-    `,
-  };
-
-  static override resolveDefaults(
-    props: RadiusEffectProps,
-  ): Required<RadiusEffectProps> {
-    return {
-      radius: props.radius ?? 10,
-    };
-  }
-
-  static override onShaderMask = `
-  vec2 halfDimensions = u_dimensions * 0.5;
-  float r = radius[0] * step(v_textureCoordinate.x, 0.5) * step(v_textureCoordinate.y, 0.5);
-  r = r + radius[1] * step(0.5, v_textureCoordinate.x) * step(v_textureCoordinate.y, 0.5);
-  r = r + radius[2] * step(0.5, v_textureCoordinate.x) * step(0.5, v_textureCoordinate.y);
-  r = r + radius[3] * step(v_textureCoordinate.x, 0.5) * step(0.5, v_textureCoordinate.y);
-  return $boxDist(v_textureCoordinate.xy * u_dimensions - halfDimensions, halfDimensions, r);
-  `;
-
-  static override onEffectMask = `
-  return mix(vec4(0.0), maskColor, $fillMask(shaderMask));
-  `;
-}

package/src/core/renderers/webgl/shaders/effects/ShaderEffect.ts

@@ -1,196 +0,0 @@
-import type { EffectMap } from '../../../../CoreShaderManager.js';
-import type { ExtractProps } from '../../../../CoreTextureManager.js';
-import type {
-  AlphaShaderProp,
-  DimensionsShaderProp,
-} from '../../WebGlCoreShader.js';
-import type {
-  UniformInfo,
-  UniformMethodMap,
-} from '../../internal/ShaderUtils.js';
-
-export interface BaseEffectDesc {
-  name?: string;
-  type: keyof EffectMap;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  props: Record<string, any>;
-}
-
-export interface EffectDesc<
-  T extends { name?: string; type: keyof EffectMap } = {
-    name?: string;
-    type: keyof EffectMap;
-  },
-> extends BaseEffectDesc {
-  name?: T['name'];
-  type: T['type'];
-  props: ExtractProps<EffectMap[T['type']]>;
-}
-
-/**
- * Allows the `keyof EffectMap` to be mapped over and form an discriminated
- * union of all the EffectDescs structures individually.
- *
- * @remarks
- * When used like the following:
- * ```
- * MapEffectDescs<keyof EffectMap>[]
- * ```
- * The resultant type will be a discriminated union like so:
- * ```
- * (
- *   {
- *     name: 'effect1',
- *     type: 'radius',
- *     props?: {
- *       radius?: number | number[];
- *     }
- *   } |
- *   {
- *     name: 'effect2',
- *     type: 'border',
- *     props?: {
- *       width?: number;
- *       color?: number;
- *     }
- *   } |
- *   // ...
- * )[]
- * ```
- * Which means TypeScript will now base its type checking on the `type` field
- * and will know exactly what the `props` field should be based on the `type`
- * field.
- */
-type MapEffectDescs<T extends keyof EffectMap> = T extends keyof EffectMap
-  ? EffectDesc<{ type: T; name: string }>
-  : never;
-
-export type EffectDescUnion = MapEffectDescs<keyof EffectMap>;
-
-export interface ShaderEffectUniform {
-  value: number | number[] | boolean | string;
-  type: string;
-  method: keyof UniformMethodMap;
-  name?: string;
-  size?: (value: Record<string, unknown>) => number;
-  updateOnBind?: boolean;
-  updateProgramValue?: (
-    programValues: ShaderEffectValueMap,
-    shaderProps?: Record<string, unknown>,
-  ) => void;
-  validator?: (
-    value: any,
-    props: Record<string, unknown>,
-  ) => number | number[] | number[][];
-}
-
-export interface ShaderEffectValueMap
-  extends DimensionsShaderProp,
-    AlphaShaderProp {
-  value: ShaderEffectUniform['value'];
-  programValue: number | Float32Array | undefined;
-  method: keyof UniformMethodMap;
-  setUniformValue?: () => void | null;
-  hasValidator: boolean;
-  hasProgramValueUpdater: boolean;
-  updateOnBind: boolean;
-  validatedValue?: number | number[];
-}
-
-export interface ShaderEffectUniforms {
-  [key: string]: ShaderEffectUniform;
-}
-
-export interface DefaultEffectProps {
-  [key: string]: unknown;
-}
-
-export interface ShaderEffectOptions {
-  ref: string;
-  target: string;
-  props?: Record<string, unknown>;
-  uniforms?: ShaderEffectUniforms;
-  methods?: Record<string, string>;
-  onShaderMask?: ((value: Record<string, unknown>) => string) | string;
-  onColorize?: ((value: Record<string, unknown>) => string) | string;
-  onEffectMask?: ((value: Record<string, unknown>) => string) | string;
-}
-
-export abstract class ShaderEffect {
-  readonly priority = 1;
-  readonly name: string = '';
-
-  ref: string;
-  target: string;
-
-  passParameters = '';
-  declaredUniforms = '';
-  uniformInfo: Record<string, UniformInfo> = {};
-
-  static uniforms: ShaderEffectUniforms = {};
-  static methods?: Record<string, string>;
-
-  static onShaderMask?: ((value: Record<string, unknown>) => string) | string;
-
-  static onColorize?: ((value: Record<string, unknown>) => string) | string;
-  static onEffectMask?: ((value: Record<string, unknown>) => string) | string;
-
-  static getEffectKey(props: Record<string, unknown>): string {
-    return '';
-  }
-
-  static getMethodParameters(
-    uniforms: ShaderEffectUniforms,
-    props: Record<string, unknown>,
-  ): string {
-    const res: string[] = [];
-    for (const u in uniforms) {
-      const uni = uniforms[u]!;
-      let define = '';
-      if (uni.size) {
-        define = `[${uni.size(props)}]`;
-      }
-      res.push(`${uni.type} ${u}${define}`);
-    }
-    return res.join(',');
-  }
-
-  constructor(options: ShaderEffectOptions) {
-    const { ref, target, props = {} } = options;
-    this.ref = ref;
-    this.target = target;
-
-    const uniformInfo: Record<string, UniformInfo> = {};
-    const passParameters: string[] = [];
-    let declaredUniforms = '';
-    const uniforms = (this.constructor as typeof ShaderEffect).uniforms || {};
-
-    for (const u in uniforms) {
-      const unif = uniforms[u]!;
-      const uniType = unif.type;
-      //make unique uniform name
-      const uniformName = `${ref}_${u}`;
-      let define = '';
-      if (unif.size) {
-        define = `[${unif.size(props)}]`;
-      }
-      passParameters.push(uniformName);
-      declaredUniforms += `uniform ${uniType} ${uniformName}${define};`;
-      uniformInfo[u] = { name: uniformName, uniform: uniforms[u]!.method };
-    }
-
-    this.passParameters = passParameters.join(',');
-    this.declaredUniforms = declaredUniforms;
-    this.uniformInfo = uniformInfo;
-  }
-
-  static resolveDefaults(
-    props: Record<string, unknown>,
-  ): Record<string, unknown> {
-    return {};
-  }
-
-  static makeEffectKey(props: Record<string, unknown>): string | false {
-    return false;
-  }
-}

package/src/main-api/DynamicShaderController.ts

@@ -1,104 +0,0 @@
-import type { ShaderEffectValueMap } from '../../exports/index.js';
-import type {
-  CoreShaderManager,
-  EffectMap,
-  ShaderMap,
-} from '../core/CoreShaderManager.js';
-import type { ExtractProps } from '../core/CoreTextureManager.js';
-import type { EffectDesc } from '../core/renderers/webgl/shaders/effects/ShaderEffect.js';
-import type { BaseShaderController } from './ShaderController.js';
-
-type OptionalName<T> = T extends string ? T : never;
-
-type MapEffectProps<
-  Effects extends [...{ name?: string; type: keyof EffectMap }[]],
-> = {
-  [K in Effects[number] as OptionalName<K['name']>]: ExtractProps<
-    EffectMap[K['type']]
-  >;
-};
-
-export type DynamicEffects<
-  T extends [...{ name?: string; type: keyof EffectMap }[]],
-> = {
-  [K in keyof T]: EffectDesc<T[K]>;
-};
-
-export class DynamicShaderController<
-  Effects extends [...{ name?: string; type: keyof EffectMap }[]],
-> implements BaseShaderController
-{
-  private resolvedProps: ExtractProps<ShaderMap['DynamicShader']>;
-  props: MapEffectProps<Effects>;
-  type: 'DynamicShader';
-
-  constructor(
-    readonly shader: InstanceType<ShaderMap['DynamicShader']>,
-    props: ExtractProps<ShaderMap['DynamicShader']>,
-    shManager: CoreShaderManager,
-  ) {
-    this.type = 'DynamicShader';
-    this.resolvedProps = props;
-    const effectConstructors = shManager.getRegisteredEffects();
-    const definedProps = {};
-
-    const effects = props.effects!;
-    const effectsLength = effects.length;
-
-    for (let i = 0; i < effectsLength; i++) {
-      const {
-        name: effectName,
-        props: effectProps,
-        type: effectType,
-      } = effects[i]!;
-      if (effectName === undefined) {
-        continue;
-      }
-      const definedEffectProps = {};
-      const propEntries = Object.keys(effectProps);
-      const propEntriesLength = propEntries.length;
-      for (let j = 0; j < propEntriesLength; j++) {
-        const propName = propEntries[j]!;
-        Object.defineProperty(definedEffectProps, propName, {
-          get: () => {
-            return (
-              this.resolvedProps.effects![i]!.props[propName] as Record<
-                string,
-                any
-              >
-            ).value;
-          },
-          set: (value) => {
-            const target = this.resolvedProps.effects![i]!.props[
-              propName
-            ] as Record<string, any>;
-            target.value = value;
-            if (target.hasValidator) {
-              value = target.validatedValue = effectConstructors[effectType]!
-                .uniforms[propName]?.validator!(value, effectProps);
-            }
-            if (target.hasProgramValueUpdater) {
-              effectConstructors[effectType]!.uniforms[propName]
-                ?.updateProgramValue!(target as ShaderEffectValueMap);
-            } else {
-              target.programValue = value;
-            }
-            shManager.renderer.stage.requestRender();
-          },
-        });
-      }
-
-      Object.defineProperty(definedProps, effectName, {
-        get: () => {
-          return definedEffectProps;
-        },
-      });
-    }
-
-    this.props = definedProps as MapEffectProps<Effects>;
-  }
-
-  getResolvedProps() {
-    return this.resolvedProps;
-  }
-}

package/src/main-api/ShaderController.ts

@@ -1,80 +0,0 @@
-/*
- * If not stated otherwise in this file or this component's LICENSE file the
- * following copyright and licenses apply:
- *
- * Copyright 2024 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.
- */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import type { ShaderMap } from '../core/CoreShaderManager.js';
-import type { ExtractProps } from '../core/CoreTextureManager.js';
-import type { Stage } from '../core/Stage.js';
-import type { CoreShader } from '../core/renderers/CoreShader.js';
-
-/**
- * Shader Controller Base Interface
- *
- * @remarks
- * Used directly this interface is like an `any` type for Shader Controllers.
- * But it is also used as a base for more specific Shader Controller interfaces.
- */
-export interface BaseShaderController {
-  type: keyof ShaderMap;
-  shader: CoreShader;
-  props: Record<string, any>;
-  getResolvedProps: () => Record<string, any>;
-}
-
-/**
- * Shader Controller Class
- *
- * @remarks
- * This class is used to control shader props.
- */
-
-export class ShaderController<S extends keyof ShaderMap>
-  implements BaseShaderController
-{
-  private resolvedProps: ExtractProps<ShaderMap[S]>;
-  props: ExtractProps<ShaderMap[S]>;
-  constructor(
-    readonly type: S,
-    readonly shader: InstanceType<ShaderMap[S]>,
-    props: ExtractProps<ShaderMap[S]>,
-    stage: Stage,
-  ) {
-    this.resolvedProps = props;
-    const keys = Object.keys(props);
-    const l = keys.length;
-
-    const definedProps = {};
-    for (let i = 0; i < l; i++) {
-      const name = keys[i]!;
-      Object.defineProperty(definedProps, name, {
-        get: () => {
-          return this.resolvedProps[name as keyof ExtractProps<ShaderMap[S]>];
-        },
-        set: (value) => {
-          this.resolvedProps[name as keyof ExtractProps<ShaderMap[S]>] = value;
-          stage.requestRender();
-        },
-      });
-    }
-    this.props = definedProps as ExtractProps<ShaderMap[S]>;
-  }
-
-  getResolvedProps() {
-    return this.resolvedProps;
-  }
-}