@lightningjs/renderer 2.12.1 → 2.13.1

package/src/core/lib/ImageWorker.ts

@@ -17,7 +17,7 @@
  * limitations under the License.
  */
 
-import type { CreateImageBitmapSupport } from '../CoreTextureManager.js';
+import type { CreateImageBitmapSupport } from '../lib/validateImageBitmap.js';
 import { type TextureData } from '../textures/Texture.js';
 
 type MessageCallback = [(value: any) => void, (reason: any) => void];
@@ -102,12 +102,13 @@ function createImageWorker() {
               reject(error);
             });
           return;
-        } else if (supportsOptionsCreateImageBitmap === true) {
-          createImageBitmap(blob, {
-            premultiplyAlpha: withAlphaChannel ? 'premultiply' : 'none',
-            colorSpaceConversion: 'none',
-            imageOrientation: 'none',
-          })
+        } else if (
+          supportsOptionsCreateImageBitmap === false &&
+          supportsOptionsCreateImageBitmap === false
+        ) {
+          // Fallback for browsers that do not support createImageBitmap with options
+          // this is supported for Chrome v50 to v52/54 that doesn't support options
+          createImageBitmap(blob)
             .then(function (data) {
               resolve({ data, premultiplyAlpha: premultiplyAlpha });
             })
@@ -115,9 +116,11 @@ function createImageWorker() {
               reject(error);
             });
         } else {
-          // Fallback for browsers that do not support createImageBitmap with options
-          // this is supported for Chrome v50 to v52/54 that doesn't support options
-          createImageBitmap(blob)
+          createImageBitmap(blob, {
+            premultiplyAlpha: withAlphaChannel ? 'premultiply' : 'none',
+            colorSpaceConversion: 'none',
+            imageOrientation: 'none',
+          })
             .then(function (data) {
               resolve({ data, premultiplyAlpha: premultiplyAlpha });
             })
@@ -155,7 +158,8 @@ function createImageWorker() {
       supportsFullCreateImageBitmap,
     })
       .then(function (data) {
-        self.postMessage({ id: id, src: src, data: data });
+        // @ts-ignore ts has wrong postMessage signature
+        self.postMessage({ id: id, src: src, data: data }, [data.data]);
       })
       .catch(function (error) {
         self.postMessage({ id: id, src: src, error: error.message });
@@ -205,14 +209,19 @@ export class ImageWorkerManager {
     let workerCode = `(${createImageWorker.toString()})()`;
 
     // Replace placeholders with actual initialization values
-    if (createImageBitmapSupport.options) {
+    if (createImageBitmapSupport.options === true) {
       workerCode = workerCode.replace(
         'var supportsOptionsCreateImageBitmap = false;',
         'var supportsOptionsCreateImageBitmap = true;',
       );
     }
 
-    if (createImageBitmapSupport.full) {
+    if (createImageBitmapSupport.full === true) {
+      workerCode = workerCode.replace(
+        'var supportsOptionsCreateImageBitmap = false;',
+        'var supportsOptionsCreateImageBitmap = true;',
+      );
+
       workerCode = workerCode.replace(
         'var supportsFullCreateImageBitmap = false;',
         'var supportsFullCreateImageBitmap = true;',

package/src/core/lib/utils.ts

@@ -308,3 +308,77 @@ export function convertUrlToAbsolute(url: string): string {
 export function isBase64Image(src: string) {
   return src.startsWith('data:') === true;
 }
+
+export function calcFactoredRadius(
+  radius: number,
+  width: number,
+  height: number,
+): number {
+  return radius * Math.min(Math.min(width, height) / (2.0 * radius), 1);
+}
+
+export function valuesAreEqual(values: number[]) {
+  let prevValue = values[0];
+  for (let i = 1; i < values.length; i++) {
+    if (prevValue !== values[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+export function calcFactoredRadiusArray(
+  radius: [number, number, number, number],
+  width: number,
+  height: number,
+): [number, number, number, number] {
+  const result: [number, number, number, number] = [
+    radius[0],
+    radius[1],
+    radius[2],
+    radius[3],
+  ];
+  const factor = Math.min(
+    Math.min(
+      Math.min(
+        width / Math.max(width, radius[0] + radius[1]),
+        width / Math.max(width, radius[2] + radius[3]),
+      ),
+      Math.min(
+        height / Math.max(height, radius[0] + radius[3]),
+        height / Math.max(height, radius[1] + radius[2]),
+      ),
+    ),
+    1,
+  );
+  result[0] *= factor;
+  result[1] *= factor;
+  result[2] *= factor;
+  result[3] *= factor;
+  return result;
+}
+
+export function dataURIToBlob(dataURI: string): Blob {
+  dataURI = dataURI.replace(/^data:/, '');
+
+  const type = dataURI.match(/image\/[^;]+/)?.[0] || '';
+  const base64 = dataURI.replace(/^[^,]+,/, '');
+
+  const sliceSize = 1024;
+  const byteCharacters = atob(base64);
+  const bytesLength = byteCharacters.length;
+  const slicesCount = Math.ceil(bytesLength / sliceSize);
+  const byteArrays = new Array(slicesCount);
+
+  for (let sliceIndex = 0; sliceIndex < slicesCount; ++sliceIndex) {
+    const begin = sliceIndex * sliceSize;
+    const end = Math.min(begin + sliceSize, bytesLength);
+
+    const bytes = new Array(end - begin);
+    for (let offset = begin, i = 0; offset < end; ++i, ++offset) {
+      bytes[i] = byteCharacters[offset]?.charCodeAt(0);
+    }
+    byteArrays[sliceIndex] = new Uint8Array(bytes);
+  }
+  return new Blob(byteArrays, { type });
+}

package/src/core/lib/validateImageBitmap.ts

@@ -0,0 +1,76 @@
+export interface CreateImageBitmapSupport {
+  basic: boolean; // Supports createImageBitmap(image)
+  options: boolean; // Supports createImageBitmap(image, options)
+  full: boolean; // Supports createImageBitmap(image, sx, sy, sw, sh, options)
+}
+
+export async function validateCreateImageBitmap(): Promise<CreateImageBitmapSupport> {
+  // Test if createImageBitmap is supported using a simple 1x1 PNG image
+  // prettier-ignore
+  const pngBinaryData = new Uint8Array([
+      0x89, 0x50, 0x4e, 0x47,
+      0x0d, 0x0a, 0x1a, 0x0a, // PNG signature
+      0x00, 0x00, 0x00, 0x0d, // IHDR chunk length
+      0x49, 0x48, 0x44, 0x52, // "IHDR" chunk type
+      0x00, 0x00, 0x00, 0x01, // Width: 1
+      0x00, 0x00, 0x00, 0x01, // Height: 1
+      0x01,                   // Bit depth: 1
+      0x03,                   // Color type: Indexed
+      0x00,                   // Compression method: Deflate
+      0x00,                   // Filter method: None
+      0x00,                   // Interlace method: None
+      0x25, 0xdb, 0x56, 0xca, // CRC for IHDR
+      0x00, 0x00, 0x00, 0x03, // PLTE chunk length
+      0x50, 0x4c, 0x54, 0x45, // "PLTE" chunk type
+      0x00, 0x00, 0x00,       // Palette entry: Black
+      0xa7, 0x7a, 0x3d, 0xda, // CRC for PLTE
+      0x00, 0x00, 0x00, 0x01, // tRNS chunk length
+      0x74, 0x52, 0x4e, 0x53, // "tRNS" chunk type
+      0x00,                   // Transparency for black: Fully transparent
+      0x40, 0xe6, 0xd8, 0x66, // CRC for tRNS
+      0x00, 0x00, 0x00, 0x0a, // IDAT chunk length
+      0x49, 0x44, 0x41, 0x54, // "IDAT" chunk type
+      0x08, 0xd7,             // Deflate header
+      0x63, 0x60, 0x00, 0x00,
+      0x00, 0x02, 0x00, 0x01, // Zlib-compressed data
+      0xe2, 0x21, 0xbc, 0x33, // CRC for IDAT
+      0x00, 0x00, 0x00, 0x00, // IEND chunk length
+      0x49, 0x45, 0x4e, 0x44, // "IEND" chunk type
+      0xae, 0x42, 0x60, 0x82, // CRC for IEND
+    ]);
+
+  const support: CreateImageBitmapSupport = {
+    basic: false,
+    options: false,
+    full: false,
+  };
+
+  // Test basic createImageBitmap support
+  const blob = new Blob([pngBinaryData], { type: 'image/png' });
+  const bitmap = await createImageBitmap(blob);
+  bitmap.close?.();
+  support.basic = true;
+
+  // Test createImageBitmap with options support
+  try {
+    const options = { premultiplyAlpha: 'none' as const };
+    const bitmapWithOptions = await createImageBitmap(blob, options);
+    bitmapWithOptions.close?.();
+    support.options = true;
+  } catch (e) {
+    /* ignore */
+  }
+
+  // Test createImageBitmap with full options support
+  try {
+    const bitmapWithFullOptions = await createImageBitmap(blob, 0, 0, 1, 1, {
+      premultiplyAlpha: 'none',
+    });
+    bitmapWithFullOptions.close?.();
+    support.full = true;
+  } catch (e) {
+    /* ignore */
+  }
+
+  return support;
+}

package/src/core/platform.ts

@@ -34,12 +34,14 @@ export const startLoop = (stage: Stage) => {
       setTimeout(runLoop, 16.666666666666668);
 
       if (!isIdle) {
-        if (stage.txMemManager.checkCleanup()) {
-          stage.txMemManager.cleanup();
-        }
         stage.eventBus.emit('idle');
         isIdle = true;
       }
+
+      if (stage.txMemManager.checkCleanup() === true) {
+        stage.txMemManager.cleanup(false);
+      }
+
       stage.flushFrameEvents();
       return;
     }

package/src/core/renderers/webgl/WebGlCoreCtxTexture.ts

@@ -120,6 +120,7 @@ export class WebGlCoreCtxTexture extends CoreContextTexture {
         if (this.state === 'freed') {
           return;
         }
+
         this.state = 'failed';
         this.textureSource.setState('failed', err);
         this.textureSource.freeTextureData();
@@ -133,17 +134,16 @@ export class WebGlCoreCtxTexture extends CoreContextTexture {
   async onLoadRequest(): Promise<Dimensions> {
     const { glw } = this;
     const textureData = this.textureSource.textureData;
-    assertTruthy(textureData, 'Texture data is null');
+    if (textureData === null || this._nativeCtxTexture === null) {
+      throw new Error(
+        'Texture data or native texture is null ' + this.textureSource.type,
+      );
+    }
 
     // Set to a 1x1 transparent texture
     glw.texImage2D(0, glw.RGBA, 1, 1, 0, glw.RGBA, glw.UNSIGNED_BYTE, null);
     this.setTextureMemUse(TRANSPARENT_TEXTURE_DATA.byteLength);
 
-    // If the texture has been freed while loading, return early.
-    if (!this._nativeCtxTexture) {
-      assertTruthy(this.state === 'freed');
-      return { width: 0, height: 0 };
-    }
     let width = 0;
     let height = 0;
 
@@ -256,14 +256,12 @@ export class WebGlCoreCtxTexture extends CoreContextTexture {
     this.textureSource.setState('freed');
     this._w = 0;
     this._h = 0;
-    if (!this._nativeCtxTexture) {
-      return;
-    }
-    const { glw } = this;
 
-    glw.deleteTexture(this._nativeCtxTexture);
-    this.setTextureMemUse(0);
-    this._nativeCtxTexture = null;
+    if (this._nativeCtxTexture !== null) {
+      this.glw.deleteTexture(this._nativeCtxTexture);
+      this.setTextureMemUse(0);
+      this._nativeCtxTexture = null;
+    }
 
     // if the texture still has source data, free it
     this.textureSource.freeTextureData();

package/src/core/textures/ImageTexture.ts

@@ -23,7 +23,11 @@ import {
   isCompressedTextureContainer,
   loadCompressedTexture,
 } from '../lib/textureCompression.js';
-import { convertUrlToAbsolute, isBase64Image } from '../lib/utils.js';
+import {
+  convertUrlToAbsolute,
+  dataURIToBlob,
+  isBase64Image,
+} from '../lib/utils.js';
 import { isSvgImage, loadSvg } from '../lib/textureSvg.js';
 import { fetchJson } from '../text-rendering/font-face-types/utils.js';
 
@@ -40,7 +44,7 @@ export interface ImageTextureProps {
    *
    * @default ''
    */
-  src?: string | ImageData | (() => ImageData | null);
+  src?: string | Blob | ImageData | (() => ImageData | null);
   /**
    * Whether to premultiply the alpha channel into the color channels of the
    * image.
@@ -133,10 +137,10 @@ export class ImageTexture extends Texture {
     return mimeType.indexOf('image/png') !== -1;
   }
 
-  async loadImageFallback(src: string, hasAlpha: boolean) {
+  async loadImageFallback(src: string | Blob, hasAlpha: boolean) {
     const img = new Image();
 
-    if (isBase64Image(src) === false) {
+    if (typeof src === 'string' && isBase64Image(src) === false) {
       img.crossOrigin = 'anonymous';
     }
 
@@ -151,7 +155,11 @@ export class ImageTexture extends Texture {
           resolve({ data: img, premultiplyAlpha: hasAlpha });
         };
 
-        img.src = src;
+        if (src instanceof Blob) {
+          img.src = URL.createObjectURL(src);
+        } else {
+          img.src = src;
+        }
       },
     );
   }
@@ -170,29 +178,15 @@ export class ImageTexture extends Texture {
     const hasAlphaChannel = premultiplyAlpha ?? blob.type.includes('image/png');
     const imageBitmapSupported = this.txManager.imageBitmapSupported;
 
-    if (
-      imageBitmapSupported.full === true &&
-      sx !== null &&
-      sy !== null &&
-      sw !== null &&
-      sh !== null
-    ) {
+    if (imageBitmapSupported.full === true && sw !== null && sh !== null) {
       // createImageBitmap with crop
-      const bitmap = await createImageBitmap(blob, sx, sy, sw, sh, {
-        premultiplyAlpha: hasAlphaChannel ? 'premultiply' : 'none',
-        colorSpaceConversion: 'none',
-        imageOrientation: 'none',
-      });
-      return { data: bitmap, premultiplyAlpha: hasAlphaChannel };
-    } else if (imageBitmapSupported.options === true) {
-      // createImageBitmap without crop but with options
-      const bitmap = await createImageBitmap(blob, {
+      const bitmap = await createImageBitmap(blob, sx || 0, sy || 0, sw, sh, {
         premultiplyAlpha: hasAlphaChannel ? 'premultiply' : 'none',
         colorSpaceConversion: 'none',
         imageOrientation: 'none',
       });
       return { data: bitmap, premultiplyAlpha: hasAlphaChannel };
-    } else {
+    } else if (imageBitmapSupported.basic === true) {
       // basic createImageBitmap without options or crop
       // this is supported for Chrome v50 to v52/54 that doesn't support options
       return {
@@ -200,6 +194,14 @@ export class ImageTexture extends Texture {
         premultiplyAlpha: hasAlphaChannel,
       };
     }
+
+    // default createImageBitmap without crop but with options
+    const bitmap = await createImageBitmap(blob, {
+      premultiplyAlpha: hasAlphaChannel ? 'premultiply' : 'none',
+      colorSpaceConversion: 'none',
+      imageOrientation: 'none',
+    });
+    return { data: bitmap, premultiplyAlpha: hasAlphaChannel };
   }
 
   async loadImage(src: string) {
@@ -221,9 +223,16 @@ export class ImageTexture extends Texture {
         );
       }
 
-      const blob = await fetchJson(src, 'blob').then(
-        (response) => response as Blob,
-      );
+      let blob;
+
+      if (isBase64Image(src) === true) {
+        blob = dataURIToBlob(src);
+      } else {
+        blob = await fetchJson(src, 'blob').then(
+          (response) => response as Blob,
+        );
+      }
+
       return this.createImageBitmap(blob, premultiplyAlpha, sx, sy, sw, sh);
     }
 
@@ -280,6 +289,14 @@ export class ImageTexture extends Texture {
     }
 
     if (typeof src !== 'string') {
+      if (src instanceof Blob) {
+        if (this.txManager.hasCreateImageBitmap === true) {
+          const { sx, sy, sw, sh } = this.props;
+          return this.createImageBitmap(src, premultiplyAlpha, sx, sy, sw, sh);
+        } else {
+          return this.loadImageFallback(src, premultiplyAlpha ?? true);
+        }
+      }
       if (src instanceof ImageData) {
         return {
           data: src,

package/src/main-api/Inspector.ts

@@ -62,13 +62,25 @@ const stylePropertyMap: {
 
     return { prop: 'height', value: `${h}px` };
   },
+  fontSize: (fs) => {
+    if (fs === 0) {
+      return null;
+    }
+
+    return { prop: 'font-size', value: `${fs}px` };
+  },
+  lineHeight: (lh) => {
+    if (lh === 0) {
+      return null;
+    }
+
+    return { prop: 'line-height', value: `${lh}px` };
+  },
   zIndex: () => 'z-index',
   fontFamily: () => 'font-family',
-  fontSize: () => 'font-size',
   fontStyle: () => 'font-style',
   fontWeight: () => 'font-weight',
   fontStretch: () => 'font-stretch',
-  lineHeight: () => 'line-height',
   letterSpacing: () => 'letter-spacing',
   textAlign: () => 'text-align',
   overflowSuffix: () => 'overflow-suffix',
@@ -396,6 +408,11 @@ export class Inspector {
     //   return;
     // }
 
+    if (property === 'rtt' && value) {
+      div.setAttribute('data-rtt', String(value));
+      return;
+    }
+
     // CSS mappable attribute
     if (stylePropertyMap[property]) {
       const mappedStyleResponse = stylePropertyMap[property]?.(value);

package/src/main-api/Renderer.ts

@@ -288,6 +288,31 @@ export interface RendererMainSettings {
    * element will be created and appended to the target element.
    */
   canvas?: HTMLCanvasElement;
+
+  /**
+   * createImageBitmap support for the runtime
+   *
+   * @remarks
+   * This is used to determine if and which version of the createImageBitmap API
+   * is supported by the runtime. This is used to determine if the renderer can
+   * use createImageBitmap to load images.
+   *
+   * Options supported
+   * - Auto - Automatically determine the supported version
+   * - Basic - Supports createImageBitmap(image)
+   * - Options - Supports createImageBitmap(image, options)
+   * - Full - Supports createImageBitmap(image, sx, sy, sw, sh, options)
+   *
+   * Note with auto detection, the renderer will attempt to use the most advanced
+   * version of the API available. If the API is not available, the renderer will
+   * fall back to the next available version.
+   *
+   * This will affect startup performance as the renderer will need to determine
+   * the supported version of the API.
+   *
+   * @defaultValue `full`
+   */
+  createImageBitmapSupport?: 'auto' | 'basic' | 'options' | 'full';
 }
 
 /**
@@ -360,10 +385,12 @@ export class RendererMain extends EventEmitter {
     const resolvedTxSettings: TextureMemoryManagerSettings = {
       criticalThreshold: settings.textureMemory?.criticalThreshold || 124e6,
       targetThresholdLevel: settings.textureMemory?.targetThresholdLevel || 0.5,
-      cleanupInterval: settings.textureMemory?.cleanupInterval || 30000,
+      cleanupInterval: settings.textureMemory?.cleanupInterval || 5000,
       debugLogging: settings.textureMemory?.debugLogging || false,
       baselineMemoryAllocation:
         settings.textureMemory?.baselineMemoryAllocation || 26e6,
+      doNotExceedCriticalThreshold:
+        settings.textureMemory?.doNotExceedCriticalThreshold || false,
     };
 
     const resolvedSettings: Required<RendererMainSettings> = {
@@ -387,6 +414,7 @@ export class RendererMain extends EventEmitter {
       strictBounds: settings.strictBounds ?? true,
       textureProcessingTimeLimit: settings.textureProcessingTimeLimit || 10,
       canvas: settings.canvas || document.createElement('canvas'),
+      createImageBitmapSupport: settings.createImageBitmapSupport || 'full',
     };
     this.settings = resolvedSettings;
 
@@ -430,6 +458,7 @@ export class RendererMain extends EventEmitter {
       inspector: this.settings.inspector !== null,
       strictBounds: this.settings.strictBounds,
       textureProcessingTimeLimit: this.settings.textureProcessingTimeLimit,
+      createImageBitmapSupport: this.settings.createImageBitmapSupport,
     });
 
     // Extract the root node
@@ -692,6 +721,8 @@ export class RendererMain extends EventEmitter {
   /**
    * Cleanup textures that are not being used
    *
+   * @param aggressive - If true, will cleanup all textures, regardless of render status
+   *
    * @remarks
    * This can be used to free up GFX memory used by textures that are no longer
    * being displayed.
@@ -705,8 +736,8 @@ export class RendererMain extends EventEmitter {
    * **NOTE3**: This will not cleanup textures that are marked as `preventCleanup`.
    * **NOTE4**: This has nothing to do with the garbage collection of JavaScript.
    */
-  cleanup() {
-    this.stage.cleanup();
+  cleanup(aggressive: boolean = false) {
+    this.stage.cleanup(aggressive);
   }
 
   /**

package/dist/src/core/CoreStuff.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/core/CoreStuff.js

@@ -1,138 +0,0 @@
-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