@lightningjs/renderer 2.3.1 → 2.4.0

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

@@ -34,7 +34,7 @@ import {
   getWebGlExtensions,
 } from './internal/RendererUtils.js';
 import { WebGlCoreCtxTexture } from './WebGlCoreCtxTexture.js';
-import { Texture } from '../../textures/Texture.js';
+import { Texture, TextureType } from '../../textures/Texture.js';
 import { ColorTexture } from '../../textures/ColorTexture.js';
 import { SubTexture } from '../../textures/SubTexture.js';
 import { WebGlCoreCtxSubTexture } from './WebGlCoreCtxSubTexture.js';
@@ -231,232 +231,220 @@ export class WebGlCoreRenderer extends CoreRenderer {
    */
   addQuad(params: QuadOptions) {
     const { fQuadBuffer, uiQuadBuffer } = this;
-    const {
-      width,
-      height,
-      colorTl,
-      colorTr,
-      colorBl,
-      colorBr,
-      textureOptions,
-      shader,
-      shaderProps,
-      alpha,
-      clippingRect,
-      tx,
-      ty,
-      ta,
-      tb,
-      tc,
-      td,
-      renderCoords,
-      rtt: renderToTexture,
-      parentHasRenderTexture,
-      framebufferDimensions,
-    } = params;
-    let { texture } = params;
+    let texture = params.texture || this.defaultTexture;
 
     /**
      * If the shader props contain any automatic properties, update it with the
      * current dimensions and or alpha that will be used to render the quad.
      */
-    if (shaderProps !== null) {
-      if (hasOwn(shaderProps, '$dimensions')) {
-        const dimensions = shaderProps.$dimensions as Dimensions;
-        dimensions.width = width;
-        dimensions.height = height;
+    if (params.shaderProps !== null) {
+      if (hasOwn(params.shaderProps, '$dimensions') == true) {
+        const dimensions = params.shaderProps.$dimensions as Dimensions;
+        dimensions.width = params.width;
+        dimensions.height = params.height;
       }
 
-      if (hasOwn(shaderProps, '$alpha')) {
-        shaderProps.$alpha = alpha;
+      if (hasOwn(params.shaderProps, '$alpha') === true) {
+        params.shaderProps.$alpha = params.alpha;
       }
     }
 
-    texture = texture ?? this.defaultTexture;
-    assertTruthy(texture instanceof Texture, 'Invalid texture type');
+    assertTruthy(texture.ctxTexture !== undefined, 'Invalid texture type');
 
     let { curBufferIdx: bufferIdx, curRenderOp } = this;
-    const targetDims = {
-      width,
-      height,
-    };
-    const targetShader = shader || this.defaultShader;
-    assertTruthy(targetShader instanceof WebGlCoreShader);
+    const targetDims = { width: -1, height: -1 };
+    targetDims.width = params.width;
+    targetDims.height = params.height;
+
+    const targetShader =
+      (params.shader as WebGlCoreShader) || this.defaultShader;
+    assertTruthy(
+      targetShader.getUniformLocation !== undefined,
+      'Invalid WebGL shader',
+    );
 
-    if (!this.reuseRenderOp(params)) {
+    if (this.reuseRenderOp(params) === false) {
       // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
       this.newRenderOp(
         targetShader,
-        shaderProps as Record<string, unknown>,
-        alpha,
+        params.shaderProps as Record<string, unknown>,
+        params.alpha,
         targetDims,
-        clippingRect,
+        params.clippingRect,
         bufferIdx,
-        renderToTexture,
-        parentHasRenderTexture,
-        framebufferDimensions,
+        params.rtt,
+        params.parentHasRenderTexture,
+        params.framebufferDimensions,
       );
       curRenderOp = this.curRenderOp;
       assertTruthy(curRenderOp);
     }
 
-    const flipX = textureOptions?.flipX ?? false;
-    let flipY = textureOptions?.flipY ?? false;
-
-    // always flip flipY for render textures
-    if (texture instanceof RenderTexture) {
-      flipY = !flipY;
-    }
-
     let texCoordX1 = 0;
     let texCoordY1 = 0;
     let texCoordX2 = 1;
     let texCoordY2 = 1;
 
-    if (texture instanceof SubTexture) {
-      const { x: tx, y: ty, width: tw, height: th } = texture.props;
-      const { width: parentW = 0, height: parentH = 0 } = texture.parentTexture
-        .dimensions || { width: 0, height: 0 };
+    if (texture.type === TextureType.subTexture) {
+      const {
+        x: tx,
+        y: ty,
+        width: tw,
+        height: th,
+      } = (texture as SubTexture).props;
+      const { width: parentW = 0, height: parentH = 0 } = (
+        texture as SubTexture
+      ).parentTexture.dimensions || { width: 0, height: 0 };
       texCoordX1 = tx / parentW;
       texCoordX2 = texCoordX1 + tw / parentW;
       texCoordY1 = ty / parentH;
       texCoordY2 = texCoordY1 + th / parentH;
-      texture = texture.parentTexture;
+      texture = (texture as SubTexture).parentTexture;
     }
 
-    const resizeMode = textureOptions?.resizeMode ?? false;
-
-    if (texture instanceof ImageTexture) {
-      if (resizeMode && texture.dimensions) {
-        const { width: tw, height: th } = texture.dimensions;
-        if (resizeMode.type === 'cover') {
-          const scaleX = width / tw;
-          const scaleY = height / th;
-          const scale = Math.max(scaleX, scaleY);
-          const precision = 1 / scale;
-          // Determine based on width
-          if (scale && scaleX && scaleX < scale) {
-            const desiredSize = precision * width;
-            texCoordX1 = (1 - desiredSize / tw) * (resizeMode.clipX ?? 0.5);
-            texCoordX2 = texCoordX1 + desiredSize / tw;
-          }
-          // Determine based on height
-          if (scale && scaleY && scaleY < scale) {
-            const desiredSize = precision * height;
-            texCoordY1 = (1 - desiredSize / th) * (resizeMode.clipY ?? 0.5);
-            texCoordY2 = texCoordY1 + desiredSize / th;
-          }
+    if (
+      texture.type === TextureType.image &&
+      params.textureOptions !== null &&
+      params.textureOptions.resizeMode !== undefined &&
+      texture.dimensions !== null
+    ) {
+      const resizeMode = params.textureOptions.resizeMode;
+      const { width: tw, height: th } = texture.dimensions;
+      if (resizeMode.type === 'cover') {
+        const scaleX = params.width / tw;
+        const scaleY = params.height / th;
+        const scale = Math.max(scaleX, scaleY);
+        const precision = 1 / scale;
+        // Determine based on width
+        if (scale && scaleX && scaleX < scale) {
+          const desiredSize = precision * params.width;
+          texCoordX1 = (1 - desiredSize / tw) * (resizeMode.clipX ?? 0.5);
+          texCoordX2 = texCoordX1 + desiredSize / tw;
+        }
+        // Determine based on height
+        if (scale && scaleY && scaleY < scale) {
+          const desiredSize = precision * params.height;
+          texCoordY1 = (1 - desiredSize / th) * (resizeMode.clipY ?? 0.5);
+          texCoordY2 = texCoordY1 + desiredSize / th;
         }
       }
     }
 
     // Flip texture coordinates if dictated by texture options
-    if (flipX) {
-      [texCoordX1, texCoordX2] = [texCoordX2, texCoordX1];
+    let flipY = 0;
+    if (params.textureOptions !== null) {
+      if (params.textureOptions.flipX === true) {
+        [texCoordX1, texCoordX2] = [texCoordX2, texCoordX1];
+      }
+
+      // convert to integer for bitwise operation below
+      flipY = +(params.textureOptions.flipY || false);
     }
-    if (flipY) {
+
+    // Eitherone should be true
+    if (flipY ^ +(texture.type === TextureType.renderToTexture)) {
       [texCoordY1, texCoordY2] = [texCoordY2, texCoordY1];
     }
 
-    const ctxTexture = texture.ctxTexture;
-    assertTruthy(ctxTexture instanceof WebGlCoreCtxTexture);
+    const ctxTexture = texture.ctxTexture as WebGlCoreCtxTexture;
+    assertTruthy(ctxTexture.ctxTexture !== undefined);
     const textureIdx = this.addTexture(ctxTexture, bufferIdx);
 
-    curRenderOp = this.curRenderOp;
-    assertTruthy(curRenderOp);
-    if (renderCoords) {
-      const { x1, y1, x2, y2, x3, y3, x4, y4 } = renderCoords;
+    assertTruthy(this.curRenderOp !== null);
+    if (params.renderCoords) {
       // Upper-Left
-      fQuadBuffer[bufferIdx++] = x1; // vertexX
-      fQuadBuffer[bufferIdx++] = y1; // vertexY
+      fQuadBuffer[bufferIdx++] = params.renderCoords.x1; // vertexX
+      fQuadBuffer[bufferIdx++] = params.renderCoords.y1; // vertexY
       fQuadBuffer[bufferIdx++] = texCoordX1; // texCoordX
       fQuadBuffer[bufferIdx++] = texCoordY1; // texCoordY
-      uiQuadBuffer[bufferIdx++] = colorTl; // color
+      uiQuadBuffer[bufferIdx++] = params.colorTl; // color
       fQuadBuffer[bufferIdx++] = textureIdx; // texIndex
 
       // Upper-Right
-      fQuadBuffer[bufferIdx++] = x2;
-      fQuadBuffer[bufferIdx++] = y2;
+      fQuadBuffer[bufferIdx++] = params.renderCoords.x2;
+      fQuadBuffer[bufferIdx++] = params.renderCoords.y2;
       fQuadBuffer[bufferIdx++] = texCoordX2;
       fQuadBuffer[bufferIdx++] = texCoordY1;
-      uiQuadBuffer[bufferIdx++] = colorTr;
+      uiQuadBuffer[bufferIdx++] = params.colorTr;
       fQuadBuffer[bufferIdx++] = textureIdx;
 
       // Lower-Left
-      fQuadBuffer[bufferIdx++] = x4;
-      fQuadBuffer[bufferIdx++] = y4;
+      fQuadBuffer[bufferIdx++] = params.renderCoords.x4;
+      fQuadBuffer[bufferIdx++] = params.renderCoords.y4;
       fQuadBuffer[bufferIdx++] = texCoordX1;
       fQuadBuffer[bufferIdx++] = texCoordY2;
-      uiQuadBuffer[bufferIdx++] = colorBl;
+      uiQuadBuffer[bufferIdx++] = params.colorBl;
       fQuadBuffer[bufferIdx++] = textureIdx;
 
       // Lower-Right
-      fQuadBuffer[bufferIdx++] = x3;
-      fQuadBuffer[bufferIdx++] = y3;
+      fQuadBuffer[bufferIdx++] = params.renderCoords.x3;
+      fQuadBuffer[bufferIdx++] = params.renderCoords.y3;
       fQuadBuffer[bufferIdx++] = texCoordX2;
       fQuadBuffer[bufferIdx++] = texCoordY2;
-      uiQuadBuffer[bufferIdx++] = colorBr;
+      uiQuadBuffer[bufferIdx++] = params.colorBr;
       fQuadBuffer[bufferIdx++] = textureIdx;
-    } else if (tb !== 0 || tc !== 0) {
+    } else if (params.tb !== 0 || params.tc !== 0) {
       // Upper-Left
-      fQuadBuffer[bufferIdx++] = tx; // vertexX
-      fQuadBuffer[bufferIdx++] = ty; // vertexY
+      fQuadBuffer[bufferIdx++] = params.tx; // vertexX
+      fQuadBuffer[bufferIdx++] = params.ty; // vertexY
       fQuadBuffer[bufferIdx++] = texCoordX1; // texCoordX
       fQuadBuffer[bufferIdx++] = texCoordY1; // texCoordY
-      uiQuadBuffer[bufferIdx++] = colorTl; // color
+      uiQuadBuffer[bufferIdx++] = params.colorTl; // color
       fQuadBuffer[bufferIdx++] = textureIdx; // texIndex
 
       // Upper-Right
-      fQuadBuffer[bufferIdx++] = tx + width * ta;
-      fQuadBuffer[bufferIdx++] = ty + width * tc;
+      fQuadBuffer[bufferIdx++] = params.tx + params.width * params.ta;
+      fQuadBuffer[bufferIdx++] = params.ty + params.width * params.tc;
       fQuadBuffer[bufferIdx++] = texCoordX2;
       fQuadBuffer[bufferIdx++] = texCoordY1;
-      uiQuadBuffer[bufferIdx++] = colorTr;
+      uiQuadBuffer[bufferIdx++] = params.colorTr;
       fQuadBuffer[bufferIdx++] = textureIdx;
 
       // Lower-Left
-      fQuadBuffer[bufferIdx++] = tx + height * tb;
-      fQuadBuffer[bufferIdx++] = ty + height * td;
+      fQuadBuffer[bufferIdx++] = params.tx + params.height * params.tb;
+      fQuadBuffer[bufferIdx++] = params.ty + params.height * params.td;
       fQuadBuffer[bufferIdx++] = texCoordX1;
       fQuadBuffer[bufferIdx++] = texCoordY2;
-      uiQuadBuffer[bufferIdx++] = colorBl;
+      uiQuadBuffer[bufferIdx++] = params.colorBl;
       fQuadBuffer[bufferIdx++] = textureIdx;
 
       // Lower-Right
-      fQuadBuffer[bufferIdx++] = tx + width * ta + height * tb;
-      fQuadBuffer[bufferIdx++] = ty + width * tc + height * td;
+      fQuadBuffer[bufferIdx++] =
+        params.tx + params.width * params.ta + params.height * params.tb;
+      fQuadBuffer[bufferIdx++] =
+        params.ty + params.width * params.tc + params.height * params.td;
       fQuadBuffer[bufferIdx++] = texCoordX2;
       fQuadBuffer[bufferIdx++] = texCoordY2;
-      uiQuadBuffer[bufferIdx++] = colorBr;
+      uiQuadBuffer[bufferIdx++] = params.colorBr;
       fQuadBuffer[bufferIdx++] = textureIdx;
     } else {
       // Calculate the right corner of the quad
       // multiplied by the scale
-      const rightCornerX = tx + width * ta;
-      const rightCornerY = ty + height * td;
+      const rightCornerX = params.tx + params.width * params.ta;
+      const rightCornerY = params.ty + params.height * params.td;
 
       // Upper-Left
-      fQuadBuffer[bufferIdx++] = tx; // vertexX
-      fQuadBuffer[bufferIdx++] = ty; // vertexY
+      fQuadBuffer[bufferIdx++] = params.tx; // vertexX
+      fQuadBuffer[bufferIdx++] = params.ty; // vertexY
       fQuadBuffer[bufferIdx++] = texCoordX1; // texCoordX
       fQuadBuffer[bufferIdx++] = texCoordY1; // texCoordY
-      uiQuadBuffer[bufferIdx++] = colorTl; // color
+      uiQuadBuffer[bufferIdx++] = params.colorTl; // color
       fQuadBuffer[bufferIdx++] = textureIdx; // texIndex
 
       // Upper-Right
       fQuadBuffer[bufferIdx++] = rightCornerX;
-      fQuadBuffer[bufferIdx++] = ty;
+      fQuadBuffer[bufferIdx++] = params.ty;
       fQuadBuffer[bufferIdx++] = texCoordX2;
       fQuadBuffer[bufferIdx++] = texCoordY1;
-      uiQuadBuffer[bufferIdx++] = colorTr;
+      uiQuadBuffer[bufferIdx++] = params.colorTr;
       fQuadBuffer[bufferIdx++] = textureIdx;
 
       // Lower-Left
-      fQuadBuffer[bufferIdx++] = tx;
+      fQuadBuffer[bufferIdx++] = params.tx;
       fQuadBuffer[bufferIdx++] = rightCornerY;
       fQuadBuffer[bufferIdx++] = texCoordX1;
       fQuadBuffer[bufferIdx++] = texCoordY2;
-      uiQuadBuffer[bufferIdx++] = colorBl;
+      uiQuadBuffer[bufferIdx++] = params.colorBl;
       fQuadBuffer[bufferIdx++] = textureIdx;
 
       // Lower-Right
@@ -464,12 +452,12 @@ export class WebGlCoreRenderer extends CoreRenderer {
       fQuadBuffer[bufferIdx++] = rightCornerY;
       fQuadBuffer[bufferIdx++] = texCoordX2;
       fQuadBuffer[bufferIdx++] = texCoordY2;
-      uiQuadBuffer[bufferIdx++] = colorBr;
+      uiQuadBuffer[bufferIdx++] = params.colorBr;
       fQuadBuffer[bufferIdx++] = textureIdx;
     }
     // Update the length of the current render op
-    curRenderOp.length += WORDS_PER_QUAD;
-    curRenderOp.numQuads++;
+    this.curRenderOp.length += WORDS_PER_QUAD;
+    this.curRenderOp.numQuads++;
     this.curBufferIdx = bufferIdx;
   }
 
@@ -536,14 +524,12 @@ export class WebGlCoreRenderer extends CoreRenderer {
         throw new Error('Unable to add texture to render op');
       }
 
-      const { shader, shaderProps, dimensions, clippingRect, alpha } =
-        curRenderOp;
       this.newRenderOp(
-        shader,
-        shaderProps,
-        alpha,
-        dimensions,
-        clippingRect,
+        curRenderOp.shader,
+        curRenderOp.shaderProps,
+        curRenderOp.alpha,
+        curRenderOp.dimensions,
+        curRenderOp.clippingRect,
         bufferIdx,
       );
       return this.addTexture(texture, bufferIdx, true);
@@ -556,7 +542,7 @@ export class WebGlCoreRenderer extends CoreRenderer {
    * @param params
    * @returns
    */
-  reuseRenderOp(params: QuadOptions) {
+  reuseRenderOp(params: QuadOptions): boolean {
     const { shader, shaderProps, parentHasRenderTexture, rtt, clippingRect } =
       params;
 

package/src/core/text-rendering/TrFontManager.ts

@@ -20,8 +20,6 @@
 import type { TrFontFace } from './font-face-types/TrFontFace.js';
 import type { TextRendererMap, TrFontProps } from './renderers/TextRenderer.js';
 
-const fontCache = new Map<string, TrFontFace>();
-
 const weightConversions: { [key: string]: number } = {
   normal: 400,
   bold: 700,
@@ -129,6 +127,8 @@ export interface FontFamilyMap {
 }
 
 export class TrFontManager {
+  private fontCache = new Map<string, TrFontFace>();
+
   constructor(private textRenderers: Partial<TextRendererMap>) {
     // Intentionally left blank
   }
@@ -154,15 +154,15 @@ export class TrFontManager {
    * @param props
    * @returns
    */
-  public static resolveFontFace(
+  public resolveFontFace(
     familyMapsByPriority: FontFamilyMap[],
     props: TrFontProps,
   ): TrFontFace | undefined {
     const { fontFamily, fontWeight, fontStyle, fontStretch } = props;
     const fontCacheString = `${fontFamily}${fontStyle}${fontWeight}${fontStretch}`;
 
-    if (fontCache.has(fontCacheString) === true) {
-      return fontCache.get(fontCacheString);
+    if (this.fontCache.has(fontCacheString) === true) {
+      return this.fontCache.get(fontCacheString);
     }
 
     const resolvedFont = resolveFontToUse(
@@ -173,7 +173,7 @@ export class TrFontManager {
       fontStretch,
     );
     if (resolvedFont !== undefined) {
-      fontCache.set(fontCacheString, resolvedFont);
+      this.fontCache.set(fontCacheString, resolvedFont);
     }
 
     return resolvedFont;

package/src/core/text-rendering/renderers/CanvasTextRenderer.ts

@@ -384,7 +384,7 @@ export class CanvasTextRenderer extends TextRenderer<CanvasTextRendererState> {
 
   loadFont = (state: CanvasTextRendererState): void => {
     const cssString = getFontCssString(state.props);
-    const trFontFace = TrFontManager.resolveFontFace(
+    const trFontFace = this.stage.fontManager.resolveFontFace(
       this.fontFamilyArray,
       state.props,
     ) as WebTrFontFace | undefined;

package/src/core/text-rendering/renderers/SdfTextRenderer/SdfTextRenderer.ts

@@ -396,10 +396,10 @@ export class SdfTextRenderer extends TextRenderer<SdfTextRendererState> {
     }
 
     // Resolve font face if we haven't yet
-    if (!trFontFace) {
+    if (trFontFace === undefined) {
       trFontFace = this.resolveFontFace(state.props);
       state.trFontFace = trFontFace;
-      if (!trFontFace) {
+      if (trFontFace === undefined) {
         const msg = `SdfTextRenderer: Could not resolve font face for family: '${state.props.fontFamily}'`;
         console.error(msg);
         this.setStatus(state, 'failed', new Error(msg));
@@ -410,7 +410,7 @@ export class SdfTextRenderer extends TextRenderer<SdfTextRendererState> {
 
     // If the font hasn't been loaded yet, stop here.
     // Listen for the 'loaded' event and forward fontLoaded event
-    if (!trFontFace.loaded) {
+    if (trFontFace.loaded === false) {
       trFontFace.once('loaded', () => {
         this.scheduleUpdateState(state);
       });
@@ -791,7 +791,7 @@ export class SdfTextRenderer extends TextRenderer<SdfTextRendererState> {
   //#endregion Overrides
 
   public resolveFontFace(props: TrFontProps): SdfTrFontFace | undefined {
-    return TrFontManager.resolveFontFace(this.fontFamilyArray, props) as
+    return this.stage.fontManager.resolveFontFace(this.fontFamilyArray, props) as
       | SdfTrFontFace
       | undefined;
   }

package/src/core/textures/ColorTexture.ts

@@ -18,7 +18,7 @@
  */
 
 import type { CoreTextureManager } from '../CoreTextureManager.js';
-import { Texture, type TextureData } from './Texture.js';
+import { Texture, TextureType, type TextureData } from './Texture.js';
 
 /**
  * Properties of the {@link ColorTexture}
@@ -45,6 +45,8 @@ export interface ColorTextureProps {
  * a Node are.
  */
 export class ColorTexture extends Texture {
+  public override type: TextureType = TextureType.color;
+
   props: Required<ColorTextureProps>;
 
   constructor(txManager: CoreTextureManager, props?: ColorTextureProps) {

package/src/core/textures/ImageTexture.ts

@@ -18,7 +18,7 @@
  */
 
 import type { CoreTextureManager } from '../CoreTextureManager.js';
-import { Texture, type TextureData } from './Texture.js';
+import { Texture, TextureType, type TextureData } from './Texture.js';
 import {
   isCompressedTextureContainer,
   loadCompressedTexture,
@@ -121,6 +121,8 @@ export interface ImageTextureProps {
 export class ImageTexture extends Texture {
   props: Required<ImageTextureProps>;
 
+  public override type: TextureType = TextureType.image;
+
   constructor(txManager: CoreTextureManager, props: ImageTextureProps) {
     super(txManager);
     this.props = ImageTexture.resolveDefaults(props);
@@ -168,8 +170,8 @@ export class ImageTexture extends Texture {
         premultiplyAlpha: hasAlphaChannel,
       };
     } else {
-      const img = new Image(width || undefined, height || undefined);
-      if (!(src.substr(0, 5) === 'data:')) {
+      const img = new Image();
+      if (!src.startsWith('data:')) {
         img.crossOrigin = 'Anonymous';
       }
       img.src = src;

package/src/core/textures/NoiseTexture.ts

@@ -18,7 +18,7 @@
  */
 
 import type { CoreTextureManager } from '../CoreTextureManager.js';
-import { Texture, type TextureData } from './Texture.js';
+import { Texture, TextureType, type TextureData } from './Texture.js';
 
 /**
  * Properties of the {@link NoiseTexture}
@@ -56,6 +56,8 @@ export interface NoiseTextureProps {
 export class NoiseTexture extends Texture {
   props: Required<NoiseTextureProps>;
 
+  public override type: TextureType = TextureType.noise;
+
   constructor(txManager: CoreTextureManager, props: NoiseTextureProps) {
     super(txManager);
     this.props = NoiseTexture.resolveDefaults(props);

package/src/core/textures/RenderTexture.ts

@@ -18,7 +18,7 @@
  */
 
 import type { CoreTextureManager } from '../CoreTextureManager.js';
-import { Texture, type TextureData } from './Texture.js';
+import { Texture, TextureType, type TextureData } from './Texture.js';
 
 /**
  * Properties of the {@link RenderTexture}
@@ -40,6 +40,8 @@ export interface RenderTextureProps {
 export class RenderTexture extends Texture {
   props: Required<RenderTextureProps>;
 
+  public override type: TextureType = TextureType.renderToTexture;
+
   constructor(txManager: CoreTextureManager, props?: RenderTextureProps) {
     super(txManager);
     this.props = RenderTexture.resolveDefaults(props || {});

package/src/core/textures/SubTexture.ts

@@ -20,6 +20,7 @@
 import type { CoreTextureManager } from '../CoreTextureManager.js';
 import {
   Texture,
+  TextureType,
   type TextureData,
   type TextureFailedEventHandler,
   type TextureLoadedEventHandler,
@@ -77,6 +78,8 @@ export class SubTexture extends Texture {
   props: Required<SubTextureProps>;
   parentTexture: Texture;
 
+  public override type: TextureType = TextureType.subTexture;
+
   constructor(txManager: CoreTextureManager, props: SubTextureProps) {
     super(txManager);
     this.props = SubTexture.resolveDefaults(props || {});

package/src/core/textures/Texture.ts

@@ -102,6 +102,15 @@ export interface TextureData {
 
 export type TextureState = 'freed' | 'loading' | 'loaded' | 'failed';
 
+export enum TextureType {
+  'generic' = 0,
+  'color' = 1,
+  'image' = 2,
+  'noise' = 3,
+  'renderToTexture' = 4,
+  'subTexture' = 5,
+}
+
 export interface TextureStateEventMap {
   freed: TextureFreedEventHandler;
   loading: TextureLoadingEventHandler;
@@ -150,6 +159,8 @@ export abstract class Texture extends EventEmitter {
 
   readonly lastRenderableChangeTime = 0;
 
+  public type: TextureType = TextureType.generic;
+
   public preventCleanup = false;
 
   constructor(protected txManager: CoreTextureManager) {

package/src/main-api/Renderer.ts

@@ -386,6 +386,7 @@ export class RendererMain extends EventEmitter {
       eventBus: this,
       quadBufferSize: this.settings.quadBufferSize,
       fontEngines: this.settings.fontEngines,
+      inspector: this.inspector !== null,
     });
 
     // Extract the root node

package/src/utils.ts

@@ -80,7 +80,7 @@ export function assertTruthy(
   condition: unknown,
   message?: string,
 ): asserts condition {
-  if (isProductionEnvironment()) return;
+  if (isProductionEnvironment() === true) return;
   if (!condition) {
     throw new Error(message || 'Assertion failed');
   }