@lightningjs/renderer 3.0.0-beta18 → 3.0.0-beta19

package/src/core/lib/textureCompression.ts

@@ -16,8 +16,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { type CompressedData, type TextureData } from '../textures/Texture.js';
+import type { WebGlContextWrapper } from './WebGlContextWrapper.js';
 
-import { type TextureData } from '../textures/Texture.js';
+export type UploadCompressedTextureFunction = (
+  glw: WebGlContextWrapper,
+  texture: WebGLTexture,
+  data: CompressedData,
+) => void;
 
 /**
  * Tests if the given location is a compressed texture container
@@ -27,10 +33,38 @@ import { type TextureData } from '../textures/Texture.js';
  * and only supports the following extensions: .ktx and .pvr
  * @returns
  */
-export function isCompressedTextureContainer(url: string): boolean {
-  return /\.(ktx|pvr)$/.test(url);
+export function isCompressedTextureContainer(src: string): boolean {
+  return /\.(ktx|pvr)$/.test(src);
 }
 
+const PVR_MAGIC = 0x03525650; // 'PVR3' in little-endian
+const PVR_TO_GL_INTERNAL_FORMAT: Record<string, number> = {
+  0: 0x8c01,
+  1: 0x8c03,
+  2: 0x8c00,
+  3: 0x8c02, // PVRTC1
+  6: 0x8d64, // ETC1
+  7: 0x83f0,
+  8: 0x83f2,
+  9: 0x83f2,
+  10: 0x83f3,
+  11: 0x83f3, // DXT variants
+};
+const ASTC_MAGIC = 0x5ca1ab13;
+
+const ASTC_TO_GL_INTERNAL_FORMAT: Record<string, number> = {
+  '4x4': 0x93b0, // COMPRESSED_RGBA_ASTC_4x4_KHR
+  '5x5': 0x93b1, // COMPRESSED_RGBA_ASTC_5x5_KHR
+  '6x6': 0x93b2, // COMPRESSED_RGBA_ASTC_6x6_KHR
+  '8x8': 0x93b3, // COMPRESSED_RGBA_ASTC_8x8_KHR
+  '10x10': 0x93b4, // COMPRESSED_RGBA_ASTC_10x10_KHR
+  '12x12': 0x93b5, // COMPRESSED_RGBA_ASTC_12x12_KHR
+};
+
+// KTX file identifier
+const KTX_IDENTIFIER = [
+  0xab, 0x4b, 0x54, 0x58, 0x20, 0x31, 0x31, 0xbb, 0x0d, 0x0a, 0x1a, 0x0a,
+];
 /**
  * Loads a compressed texture container
  * @param url
@@ -39,116 +73,438 @@ export function isCompressedTextureContainer(url: string): boolean {
 export const loadCompressedTexture = async (
   url: string,
 ): Promise<TextureData> => {
-  const response = await fetch(url);
-  const arrayBuffer = await response.arrayBuffer();
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch compressed texture: ${response.status} ${response.statusText}`,
+      );
+    }
 
-  if (url.indexOf('.ktx') !== -1) {
-    return loadKTXData(arrayBuffer);
-  }
+    const arrayBuffer = await response.arrayBuffer();
+
+    // Ensure we have enough data to check magic numbers
+    if (arrayBuffer.byteLength < 16) {
+      throw new Error(
+        `File too small to be a valid compressed texture (${arrayBuffer.byteLength} bytes). Expected at least 16 bytes for header inspection.`,
+      );
+    }
+
+    const view = new DataView(arrayBuffer);
+    const magic = view.getUint32(0, true);
 
-  return loadPVRData(arrayBuffer);
+    if (magic === PVR_MAGIC) {
+      return loadPVR(view);
+    }
+
+    if (magic === ASTC_MAGIC) {
+      return loadASTC(view);
+    }
+
+    let isKTX = true;
+
+    for (let i = 0; i < KTX_IDENTIFIER.length; i++) {
+      if (view.getUint8(i) !== KTX_IDENTIFIER[i]) {
+        isKTX = false;
+        break;
+      }
+    }
+
+    if (isKTX === true) {
+      return loadKTX(view);
+    } else {
+      throw new Error('Unrecognized compressed texture format');
+    }
+  } catch (error) {
+    throw new Error(`Failed to load compressed texture from ${url}: ${error}`);
+  }
 };
 
+function readUint24(view: DataView, offset: number) {
+  return (
+    view.getUint8(offset) +
+    (view.getUint8(offset + 1) << 8) +
+    (view.getUint8(offset + 2) << 16)
+  );
+}
+
 /**
- * Loads a KTX texture container and returns the texture data
- * @param buffer
+ * Loads an ASTC texture container and returns the texture data
+ * @param view
  * @returns
  */
-const loadKTXData = async (buffer: ArrayBuffer): Promise<TextureData> => {
-  const view = new DataView(buffer);
-  const littleEndian = view.getUint32(12) === 16909060 ? true : false;
+const loadASTC = async function (view: DataView): Promise<TextureData> {
+  const blockX = view.getUint8(4);
+  const blockY = view.getUint8(5);
+  const sizeX = readUint24(view, 7);
+  const sizeY = readUint24(view, 10);
+
+  if (sizeX === 0 || sizeY === 0) {
+    throw new Error(`Invalid ASTC texture dimensions: ${sizeX}x${sizeY}`);
+  }
+  const expected = Math.ceil(sizeX / blockX) * Math.ceil(sizeY / blockY) * 16;
+  const dataSize = view.byteLength - 16;
+  if (expected !== dataSize) {
+    throw new Error(
+      `Invalid ASTC texture data size: expected ${expected}, got ${dataSize}`,
+    );
+  }
+
+  const internalFormat = ASTC_TO_GL_INTERNAL_FORMAT[`${blockX}x${blockY}`];
+  if (internalFormat === undefined) {
+    throw new Error(`Unsupported ASTC block size: ${blockX}x${blockY}`);
+  }
+
+  const buffer = view.buffer as ArrayBuffer;
+
   const mipmaps: ArrayBuffer[] = [];
+  mipmaps.push(buffer.slice(16));
 
-  const data = {
-    glInternalFormat: view.getUint32(28, littleEndian),
-    pixelWidth: view.getUint32(36, littleEndian),
-    pixelHeight: view.getUint32(40, littleEndian),
-    numberOfMipmapLevels: view.getUint32(56, littleEndian),
-    bytesOfKeyValueData: view.getUint32(60, littleEndian),
+  return {
+    data: {
+      blockInfo: blockInfoMap[internalFormat]!,
+      glInternalFormat: internalFormat,
+      mipmaps,
+      w: sizeX,
+      h: sizeY,
+      type: 'astc',
+    },
+    premultiplyAlpha: false,
   };
+};
+
+const uploadASTC = function (
+  glw: WebGlContextWrapper,
+  texture: WebGLTexture,
+  data: CompressedData,
+) {
+  if (glw.getExtension('WEBGL_compressed_texture_astc') === null) {
+    throw new Error('ASTC compressed textures not supported by this device');
+  }
 
-  let offset = 64;
+  glw.bindTexture(texture);
 
-  // Key Value Pairs of data start at byte offset 64
-  // But the only known kvp is the API version, so skipping parsing.
-  offset += data.bytesOfKeyValueData;
+  const { glInternalFormat, mipmaps, w, h } = data;
+  if (mipmaps === undefined) {
+    return;
+  }
+
+  const view = new Uint8Array(mipmaps[0]!);
+
+  glw.compressedTexImage2D(0, glInternalFormat, w, h, 0, view);
+  // ASTC textures MUST use no mipmaps unless stored
+  glw.texParameteri(glw.TEXTURE_WRAP_S, glw.CLAMP_TO_EDGE);
+  glw.texParameteri(glw.TEXTURE_WRAP_T, glw.CLAMP_TO_EDGE);
+  glw.texParameteri(glw.TEXTURE_MAG_FILTER, glw.LINEAR);
+  glw.texParameteri(glw.TEXTURE_MIN_FILTER, glw.LINEAR);
+};
+/**
+ * Loads a KTX texture container and returns the texture data
+ * @param view
+ * @returns
+ */
+const loadKTX = async function (view: DataView): Promise<TextureData> {
+  const endianness = view.getUint32(12, true);
+  const littleEndian = endianness === 0x04030201;
+  if (littleEndian === false && endianness !== 0x01020304) {
+    throw new Error('Invalid KTX endianness value');
+  }
 
-  for (let i = 0; i < data.numberOfMipmapLevels; i++) {
-    const imageSize = view.getUint32(offset);
+  const glType = view.getUint32(16, littleEndian);
+  const glFormat = view.getUint32(24, littleEndian);
+  if (glType !== 0 || glFormat !== 0) {
+    throw new Error(
+      `KTX texture is not compressed (glType: ${glType}, glFormat: ${glFormat})`,
+    );
+  }
+
+  const glInternalFormat = view.getUint32(28, littleEndian);
+  if (blockInfoMap[glInternalFormat] === undefined) {
+    throw new Error(
+      `Unsupported KTX compressed texture format: 0x${glInternalFormat.toString(
+        16,
+      )}`,
+    );
+  }
+
+  const width = view.getUint32(36, littleEndian);
+  const height = view.getUint32(40, littleEndian);
+  if (width === 0 || height === 0) {
+    throw new Error(`Invalid KTX texture dimensions: ${width}x${height}`);
+  }
+
+  const mipmapLevels = view.getUint32(56, littleEndian);
+  if (mipmapLevels === 0) {
+    throw new Error('KTX texture has no mipmap levels');
+  }
+
+  const bytesOfKeyValueData = view.getUint32(60, littleEndian);
+  const mipmaps: ArrayBuffer[] = [];
+  const buffer = view.buffer as ArrayBuffer;
+  let offset = 64 + bytesOfKeyValueData;
+
+  if (offset > view.byteLength) {
+    throw new Error('Invalid KTX file: key/value data exceeds file size');
+  }
+
+  for (let i = 0; i < mipmapLevels; i++) {
+    const imageSize = view.getUint32(offset, littleEndian);
     offset += 4;
 
-    mipmaps.push(view.buffer.slice(offset, imageSize));
-    offset += imageSize;
+    const end = offset + imageSize;
+
+    mipmaps.push(buffer.slice(offset, end));
+    offset = end;
+    if (offset % 4 !== 0) {
+      offset += 4 - (offset % 4);
+    }
   }
 
   return {
     data: {
-      glInternalFormat: data.glInternalFormat,
+      blockInfo: blockInfoMap[glInternalFormat]!,
+      glInternalFormat: glInternalFormat,
       mipmaps,
-      w: data.pixelWidth || 0,
-      h: data.pixelHeight || 0,
+      w: width,
+      h: height,
       type: 'ktx',
     },
     premultiplyAlpha: false,
   };
 };
 
-/**
- * Loads a PVR texture container and returns the texture data
- * @param buffer
- * @returns
- */
-const loadPVRData = async (buffer: ArrayBuffer): Promise<TextureData> => {
-  // pvr header length in 32 bits
-  const pvrHeaderLength = 13;
-  // for now only we only support: COMPRESSED_RGB_ETC1_WEBGL
-  const pvrFormatEtc1 = 0x8d64;
-  const pvrWidth = 7;
-  const pvrHeight = 6;
-  const pvrMipmapCount = 11;
-  const pvrMetadata = 12;
-  const arrayBuffer = buffer;
-  const header = new Int32Array(arrayBuffer, 0, pvrHeaderLength);
-
-  // @ts-expect-error Object possibly undefined
-
-  const dataOffset = header[pvrMetadata] + 52;
-  const pvrtcData = new Uint8Array(arrayBuffer, dataOffset);
-  const mipmaps: ArrayBuffer[] = [];
-  const data = {
-    pixelWidth: header[pvrWidth],
-    pixelHeight: header[pvrHeight],
-    numberOfMipmapLevels: header[pvrMipmapCount] || 0,
-  };
+const uploadKTX = function (
+  glw: WebGlContextWrapper,
+  texture: WebGLTexture,
+  data: CompressedData,
+) {
+  const { glInternalFormat, mipmaps, w: width, h: height, blockInfo } = data;
+  if (mipmaps === undefined) {
+    return;
+  }
+  glw.bindTexture(texture);
 
-  let offset = 0;
-  let width = data.pixelWidth || 0;
-  let height = data.pixelHeight || 0;
+  const blockWidth = blockInfo.width;
+  const blockHeight = blockInfo.height;
+  let w = width;
+  let h = height;
 
-  for (let i = 0; i < data.numberOfMipmapLevels; i++) {
-    const level = ((width + 3) >> 2) * ((height + 3) >> 2) * 8;
-    const view = new Uint8Array(
-      arrayBuffer,
-      pvrtcData.byteOffset + offset,
-      level,
-    );
+  for (let i = 0; i < mipmaps!.length; i++) {
+    let view = new Uint8Array(mipmaps![i]!);
 
-    mipmaps.push(
-      view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength),
+    const uploadW = Math.ceil(w / blockWidth) * blockWidth;
+    const uploadH = Math.ceil(h / blockHeight) * blockHeight;
+
+    const expectedBytes =
+      Math.ceil(w / blockWidth) * Math.ceil(h / blockHeight) * blockInfo.bytes;
+
+    if (view.byteLength < expectedBytes) {
+      const padded = new Uint8Array(expectedBytes);
+      padded.set(view);
+      view = padded;
+    }
+
+    glw.compressedTexImage2D(i, glInternalFormat, uploadW, uploadH, 0, view);
+
+    w = Math.max(1, w >> 1);
+    h = Math.max(1, h >> 1);
+  }
+
+  glw.texParameteri(glw.TEXTURE_WRAP_S, glw.CLAMP_TO_EDGE);
+  glw.texParameteri(glw.TEXTURE_WRAP_T, glw.CLAMP_TO_EDGE);
+  glw.texParameteri(glw.TEXTURE_MAG_FILTER, glw.LINEAR);
+  glw.texParameteri(
+    glw.TEXTURE_MIN_FILTER,
+    mipmaps!.length > 1 ? glw.LINEAR_MIPMAP_LINEAR : glw.LINEAR,
+  );
+};
+
+function pvrtcMipSize(width: number, height: number, bpp: 2 | 4) {
+  const minW = bpp === 2 ? 16 : 8;
+  const minH = 8;
+  const w = Math.max(width, minW);
+  const h = Math.max(height, minH);
+  return (w * h * bpp) / 8;
+}
+
+const loadPVR = async function (view: DataView): Promise<TextureData> {
+  const pixelFormatLow = view.getUint32(8, true);
+  const internalFormat = PVR_TO_GL_INTERNAL_FORMAT[pixelFormatLow];
+
+  if (internalFormat === undefined) {
+    throw new Error(
+      `Unsupported PVR pixel format: 0x${pixelFormatLow.toString(16)}`,
     );
-    offset += level;
-    width = width >> 1;
-    height = height >> 1;
+  }
+
+  const height = view.getInt32(24, true);
+  const width = view.getInt32(28, true);
+
+  // validate dimensions
+  if (width === 0 || height === 0) {
+    throw new Error(`Invalid PVR texture dimensions: ${width}x${height}`);
+  }
+  const mipmapLevels = view.getInt32(44, true);
+  const metadataSize = view.getUint32(48, true);
+  const buffer = view.buffer as ArrayBuffer;
+
+  let offset = 52 + metadataSize;
+  if (offset > buffer.byteLength) {
+    throw new Error('Invalid PVR file: metadata exceeds file size');
+  }
+
+  const mipmaps: ArrayBuffer[] = [];
+
+  const block = blockInfoMap[internalFormat]!;
+
+  for (let i = 0; i < mipmapLevels; i++) {
+    const declaredSize = view.getUint32(offset, true);
+    const max = buffer.byteLength - (offset + 4);
+
+    if (declaredSize > 0 && declaredSize <= max) {
+      offset += 4;
+      const start = offset;
+      const end = offset + declaredSize;
+
+      mipmaps.push(buffer.slice(start, end));
+      offset = end;
+      offset = (offset + 3) & ~3; // align to 4 bytes
+      continue;
+    }
+
+    if (
+      pixelFormatLow === 0 ||
+      pixelFormatLow === 1 ||
+      pixelFormatLow === 2 ||
+      pixelFormatLow === 3
+    ) {
+      const bpp = pixelFormatLow === 0 || pixelFormatLow === 1 ? 2 : 4;
+      const computed = pvrtcMipSize(width >> i, height >> i, bpp);
+
+      mipmaps.push(buffer.slice(offset, offset + computed));
+      offset += computed;
+      offset = (offset + 3) & ~3; // align to 4 bytes
+      continue;
+    }
+
+    if (block !== undefined) {
+      const blockW = Math.ceil((width >> i) / block.width);
+      const blockH = Math.ceil((height >> i) / block.height);
+      const computed = blockW * blockH * block.bytes;
+
+      mipmaps.push(buffer.slice(offset, offset + computed));
+      offset += computed;
+      offset = (offset + 3) & ~3;
+    }
   }
 
   return {
     data: {
-      glInternalFormat: pvrFormatEtc1,
-      mipmaps: mipmaps,
-      w: data.pixelWidth || 0,
-      h: data.pixelHeight || 0,
+      blockInfo: blockInfoMap[internalFormat]!,
+      glInternalFormat: internalFormat,
+      mipmaps,
+      w: width,
+      h: height,
       type: 'pvr',
     },
     premultiplyAlpha: false,
   };
 };
+
+const uploadPVR = function (
+  glw: WebGlContextWrapper,
+  texture: WebGLTexture,
+  data: CompressedData,
+) {
+  const { glInternalFormat, mipmaps, w: width, h: height } = data;
+  if (mipmaps === undefined) {
+    return;
+  }
+  glw.bindTexture(texture);
+
+  let w = width;
+  let h = height;
+
+  for (let i = 0; i < mipmaps!.length; i++) {
+    glw.compressedTexImage2D(
+      i,
+      glInternalFormat,
+      w,
+      h,
+      0,
+      new Uint8Array(mipmaps[i]!),
+    );
+
+    w = Math.max(1, w >> 1);
+    h = Math.max(1, h >> 1);
+  }
+
+  glw.texParameteri(glw.TEXTURE_WRAP_S, glw.CLAMP_TO_EDGE);
+  glw.texParameteri(glw.TEXTURE_WRAP_T, glw.CLAMP_TO_EDGE);
+  glw.texParameteri(glw.TEXTURE_MAG_FILTER, glw.LINEAR);
+  glw.texParameteri(
+    glw.TEXTURE_MIN_FILTER,
+    mipmaps.length > 1 ? glw.LINEAR_MIPMAP_LINEAR : glw.LINEAR,
+  );
+};
+
+type BlockInfo = {
+  width: number;
+  height: number;
+  bytes: number;
+};
+
+// Predefined block info for common compressed texture formats
+const BLOCK_4x4x8: BlockInfo = { width: 4, height: 4, bytes: 8 };
+const BLOCK_4x4x16: BlockInfo = { width: 4, height: 4, bytes: 16 };
+const BLOCK_5x5x16: BlockInfo = { width: 5, height: 5, bytes: 16 };
+const BLOCK_6x6x16: BlockInfo = { width: 6, height: 6, bytes: 16 };
+const BLOCK_8x4x8: BlockInfo = { width: 8, height: 4, bytes: 8 };
+const BLOCK_8x8x16: BlockInfo = { width: 8, height: 8, bytes: 16 };
+const BLOCK_10x10x16: BlockInfo = { width: 10, height: 10, bytes: 16 };
+const BLOCK_12x12x16: BlockInfo = { width: 12, height: 12, bytes: 16 };
+
+// Map of GL internal formats to their corresponding block info
+export const blockInfoMap: { [key: number]: BlockInfo } = {
+  // S3TC / DXTn (WEBGL_compressed_texture_s3tc, sRGB variants)
+  0x83f0: BLOCK_4x4x8, // COMPRESSED_RGB_S3TC_DXT1_EXT
+  0x83f1: BLOCK_4x4x8, // COMPRESSED_RGBA_S3TC_DXT1_EXT
+  0x83f2: BLOCK_4x4x16, // COMPRESSED_RGBA_S3TC_DXT3_EXT
+  0x83f3: BLOCK_4x4x16, // COMPRESSED_RGBA_S3TC_DXT5_EXT
+
+  // ETC1 / ETC2 / EAC
+  0x8d64: BLOCK_4x4x8, // COMPRESSED_RGB_ETC1_WEBGL
+  0x9274: BLOCK_4x4x8, // COMPRESSED_RGB8_ETC2
+  0x9275: BLOCK_4x4x8, // COMPRESSED_SRGB8_ETC2
+  0x9278: BLOCK_4x4x16, // COMPRESSED_RGBA8_ETC2_EAC
+  0x9279: BLOCK_4x4x16, // COMPRESSED_SRGB8_ALPHA8_ETC2_EAC
+
+  // PVRTC (WEBGL_compressed_texture_pvrtc)
+  0x8c00: BLOCK_4x4x8, // COMPRESSED_RGB_PVRTC_4BPPV1_IMG
+  0x8c02: BLOCK_4x4x8, // COMPRESSED_RGBA_PVRTC_4BPPV1_IMG
+  0x8c01: BLOCK_8x4x8, // COMPRESSED_RGB_PVRTC_2BPPV1_IMG
+  0x8c03: BLOCK_8x4x8,
+
+  // ASTC (WEBGL_compressed_texture_astc)
+  0x93b0: BLOCK_4x4x16, // COMPRESSED_RGBA_ASTC_4x4_KHR
+  0x93d0: BLOCK_4x4x16, // COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR
+  0x93b1: BLOCK_5x5x16, // 5x5
+  0x93d1: BLOCK_5x5x16,
+  0x93b2: BLOCK_6x6x16, // 6x6
+  0x93d2: BLOCK_6x6x16,
+  0x93b3: BLOCK_8x8x16, // 8x8
+  0x93d3: BLOCK_8x8x16,
+  0x93b4: BLOCK_10x10x16, // 10x10
+  0x93d4: BLOCK_10x10x16,
+  0x93b5: BLOCK_12x12x16, // 12x12
+  0x93d5: BLOCK_12x12x16,
+};
+
+export const uploadCompressedTexture: Record<
+  string,
+  UploadCompressedTextureFunction
+> = {
+  ktx: uploadKTX,
+  pvr: uploadPVR,
+  astc: uploadASTC,
+};

package/src/core/platforms/web/WebPlatform.ts

@@ -62,14 +62,14 @@ export class WebPlatform extends Platform {
           setTimeout(() => requestAnimationFrame(runLoop), 16.666666666666668);
         }
 
-        if (!isIdle) {
+        if (isIdle === false) {
           stage.shManager.cleanup();
           stage.eventBus.emit('idle');
           isIdle = true;
         }
 
         if (stage.txMemManager.checkCleanup() === true) {
-          stage.txMemManager.cleanup(false);
+          stage.txMemManager.cleanup();
         }
 
         stage.flushFrameEvents();

package/src/core/renderers/CoreContextTexture.ts

@@ -35,6 +35,7 @@ export abstract class CoreContextTexture {
   }
 
   abstract load(): Promise<void>;
+  abstract release(): void;
   abstract free(): void;
 
   get renderable(): boolean {

package/src/core/renderers/CoreRenderer.ts

@@ -53,6 +53,7 @@ export interface QuadOptions {
   rtt: boolean;
   parentHasRenderTexture: boolean;
   framebufferDimensions: Dimensions | null;
+  time?: number | null;
 }
 
 export interface CoreRendererOptions {
@@ -70,7 +71,7 @@ export interface BufferInfo {
 export abstract class CoreRenderer {
   public options: CoreRendererOptions;
   public mode: 'webgl' | 'canvas' | undefined;
-
+  defaultTextureCoords: TextureCoords | undefined = undefined;
   readonly stage: Stage;
 
   //// Core Managers
@@ -106,5 +107,5 @@ export abstract class CoreRenderer {
   abstract getQuadCount(): number | null;
   abstract updateViewport(): void;
   abstract updateClearColor(color: number): void;
-  getTextureCoords?(node: CoreNode): TextureCoords;
+  getTextureCoords?(node: CoreNode): TextureCoords | undefined;
 }

package/src/core/renderers/CoreShaderNode.ts

@@ -75,6 +75,11 @@ export interface CoreShaderType<Props extends object = any> {
    * used for making a cache key to check for reusability, currently only used for webgl ShaderTypes but might be needed for other types of renderer
    */
   getCacheMarkers?: (props: Props) => string;
+  /**
+   * timer that updates every loop, by default uses the stage elapsed time If you want to do a special calculation you can define a function.
+   * When you calculate your own value you can use the Stage timing values deltaTime, lastFrameTime, and currentFrameTime;
+   */
+  time?: boolean | ((stage: Stage) => number);
 }
 
 /**
@@ -89,6 +94,7 @@ export class CoreShaderNode<Props extends object = Record<string, unknown>> {
   readonly resolvedProps: Props | undefined = undefined;
   protected definedProps: Props | undefined = undefined;
   protected node: CoreNode | null = null;
+  readonly time: CoreShaderType['time'] = undefined;
   update: (() => void) | undefined = undefined;
 
   constructor(
@@ -99,6 +105,7 @@ export class CoreShaderNode<Props extends object = Record<string, unknown>> {
   ) {
     this.stage = stage;
     this.shaderType = type;
+    this.time = type.time;
 
     if (props !== undefined) {
       /**

package/src/core/renderers/canvas/CanvasTexture.ts

@@ -50,9 +50,13 @@ export class CanvasTexture extends CoreContextTexture {
     }
   }
 
-  free(): void {
+  release(): void {
     this.image = undefined;
     this.tintCache = undefined;
+  }
+
+  free(): void {
+    this.release();
     this.textureSource.setState('freed');
     this.setTextureMemUse(0);
     this.textureSource.freeTextureData();

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

@@ -20,6 +20,7 @@
 import type { Dimensions } from '../../../common/CommonTypes.js';
 import type { TextureMemoryManager } from '../../TextureMemoryManager.js';
 import type { WebGlContextWrapper } from '../../lib/WebGlContextWrapper.js';
+import type { Bound } from '../../lib/utils.js';
 import type { RenderTexture } from '../../textures/RenderTexture.js';
 import { WebGlCtxTexture } from './WebGlCtxTexture.js';
 
@@ -28,6 +29,13 @@ export class WebGlCtxRenderTexture extends WebGlCtxTexture {
 
   public framebuffer: WebGLFramebuffer | null = null;
 
+  override txCoords: Bound = {
+    x1: 0,
+    y1: 1,
+    x2: 1,
+    y2: 0,
+  };
+
   constructor(
     glw: WebGlContextWrapper,
     memManager: TextureMemoryManager,