@lightningjs/renderer/dist/src/core/CoreStuff.js

Lightning 3 Renderer

export {};
/*interface InstanceMap {
  renderer: CoreRenderer;
  effect: CoreEffect;
  program: new () => void;
}

type WebGlInstanceMap = InstanceMap & {
  renderer: WebGlCoreRenderer;
  effect: WebGlEffect;
};

interface AdvEffectProp {
  default: any;
  isColor?: boolean;
  validator?: (value: any) => any;
}

interface EffectProps {
  [key: string]: any | AdvEffectProp;
}

type EffectDescriptor<Effect, Props> = Effect & {
  props?: Props;
};

type InferEffectProps<T> = {
  [K in keyof T]: T[K] extends AdvEffectProp ? T[K]['default'] : T[K];
};

interface CoreEffect {
  props?: EffectProps;
  update?: (ctx: unknown) => void;
}

type WebGlEffect = CoreEffect & {
  fragment: string;
  update?: (glw: WebGLRenderingContext) => void;
};

type StageOptions<Renderer extends InstanceMap> = {
  renderEngine?: new () => Renderer['renderer'];
};

class Stage<RendererMap extends InstanceMap> {
  fxManager: CoreFxManager<RendererMap>;
  constructor(options: StageOptions<RendererMap>) {
    this.fxManager = new CoreFxManager();
    const renderer = new options.renderEngine();
  }

  createShader<Effect extends RendererMap['effect'], Props>(
    effect: EffectDescriptor<Effect, Props>,
    props?: InferEffectProps<Props>
  ): EffectNode<Effect, Props> {
    return this.fxManager.createShader(effect, props);
  }
}

class CoreRenderer {
  mode = 'core';
}

class WebGlCoreRenderer extends CoreRenderer {
  override mode = 'webgl';
}

class CanvasCoreRenderer extends CoreRenderer {
  override mode = 'canvas';
}

class CoreFxManager<RendererMap extends InstanceMap> {
  fxCache: Map<string, RendererMap['effect']> = new Map();

  resolveProps(defaultProps?: EffectProps, props?: EffectProps) {
    if(defaultProps !== undefined) {
      props = props ?? {}
      const keys = Object.keys(defaultProps);
      const l = keys.length;
      for(let i = 0; i < l; i++) {
        if(props[keys[i]] === undefined) {
          props[keys[i]] = defaultProps[keys[i]].default || defaultProps[keys[i]]
        }
      }
    }
  }

  createShader<Effect extends RendererMap['effect'], Props>(
    effect: EffectDescriptor<Effect, Props>,
    props?: InferEffectProps<Props>
  ): EffectNode<Effect, Props> {

    // const f = JSON.stringify(effect);
    // if (this.fxCache.has(f)) {
    //   console.log('already has this effect');
    // } else {
    //   console.log('create new effect program');
    //   this.fxCache.set(f, effect);
    // }

    return new EffectNode<Effect, Props>(effect, WebGlCoreRenderer, props);
  }
}

class EffectNode<Effect extends CoreEffect, Props extends EffectProps> {
  #data: Record<string, any> | undefined = undefined;
  constructor(
    readonly type: Effect,
    readonly program: new () => void,
    props?: InferEffectProps<Props>
  ) {
    this.#data = props;
  }
}

const stage = new Stage<WebGlInstanceMap>({
  renderEngine: CanvasCoreRenderer,
});

stage.createShader(
  {
    props: {
      radius: 10,
    },
    fragment: '',
  },
  {
    radius: 30,
  }
);

stage.createShader({
  props: {
    radius: 10,
  },
  fragment: '',
});*/
//# sourceMappingURL=CoreStuff.js.map