@safe-engine/pixi 8.10.0 → 8.10.2

package/dist/packages/pixijs/src/compressed-textures/dds/loadDDS.d.ts

@@ -0,0 +1,24 @@
+import { LoaderParserPriority } from '../../assets/loader/parsers/LoaderParser';
+import { ExtensionType } from '../../extensions/Extensions';
+import type { Loader } from '../../assets/loader/Loader';
+import type { ResolvedAsset } from '../../assets/types';
+import type { Texture } from '../../rendering/renderers/shared/texture/Texture';
+/**
+ * Loads DDS textures.
+ * @category assets
+ * @advanced
+ */
+export declare const loadDDS: {
+    extension: {
+        type: ExtensionType.LoadParser;
+        priority: LoaderParserPriority;
+        name: string;
+    };
+    /** used for deprecation purposes */
+    name: string;
+    id: string;
+    test(url: string): boolean;
+    load<T>(url: string, _asset: ResolvedAsset, loader: Loader): Promise<Texture | Texture[]>;
+    unload(texture: Texture | Texture[]): void;
+};
+//# sourceMappingURL=loadDDS.d.ts.map

package/dist/packages/pixijs/src/compressed-textures/dds/loadDDS.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadDDS.d.ts","sourceRoot":"","sources":["../../../../../../packages/pixijs/src/compressed-textures/dds/loadDDS.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,0CAA0C,CAAC;AAGhF,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAK5D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAEzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAExD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kDAAkD,CAAC;AAEhF;;;;GAIG;AACH,eAAO,MAAM,OAAO;;;;;;IAOhB,oCAAoC;;;cAI1B,MAAM,GAAG,OAAO;iBAKV,MAAM,UAAU,aAAa,UAAU,MAAM,GAAG,OAAO,CAAC,OAAO,GAAG,OAAO,EAAE,CAAC;oBAe5E,OAAO,GAAG,OAAO,EAAE,GAAG,IAAI;CAYqB,CAAC"}

package/dist/packages/pixijs/src/compressed-textures/dds/loadDDS.js

@@ -0,0 +1,52 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { LoaderParserPriority } from '../../assets/loader/parsers/LoaderParser';
+import { createTexture } from '../../assets/loader/parsers/textures/utils/createTexture';
+import { checkExtension } from '../../assets/utils/checkExtension';
+import { ExtensionType } from '../../extensions/Extensions';
+import { CompressedSource } from '../../rendering/renderers/shared/texture/sources/CompressedSource';
+import { getSupportedTextureFormats } from '../../rendering/renderers/shared/texture/utils/getSupportedTextureFormats';
+import { parseDDS } from './parseDDS';
+/**
+ * Loads DDS textures.
+ * @category assets
+ * @advanced
+ */
+export const loadDDS = {
+    extension: {
+        type: ExtensionType.LoadParser,
+        priority: LoaderParserPriority.High,
+        name: 'loadDDS',
+    },
+    /** used for deprecation purposes */
+    name: 'loadDDS',
+    id: 'dds',
+    test(url) {
+        return checkExtension(url, ['.dds']);
+    },
+    load(url, _asset, loader) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const supportedTextures = yield getSupportedTextureFormats();
+            const ddsResponse = yield fetch(url);
+            const ddsArrayBuffer = yield ddsResponse.arrayBuffer();
+            const textureOptions = parseDDS(ddsArrayBuffer, supportedTextures);
+            const compressedTextureSource = new CompressedSource(textureOptions);
+            return createTexture(compressedTextureSource, loader, url);
+        });
+    },
+    unload(texture) {
+        if (Array.isArray(texture)) {
+            texture.forEach((t) => t.destroy(true));
+        }
+        else {
+            texture.destroy(true);
+        }
+    }
+};

package/dist/packages/pixijs/src/compressed-textures/dds/parseDDS.d.ts

@@ -0,0 +1,9 @@
+import type { TEXTURE_FORMATS } from '../../rendering/renderers/shared/texture/const';
+import type { TextureSourceOptions } from '../../rendering/renderers/shared/texture/sources/TextureSource';
+/**
+ * @param arrayBuffer
+ * @param supportedFormats
+ * @internal
+ */
+export declare function parseDDS(arrayBuffer: ArrayBuffer, supportedFormats: TEXTURE_FORMATS[]): TextureSourceOptions<Uint8Array[]>;
+//# sourceMappingURL=parseDDS.d.ts.map

package/dist/packages/pixijs/src/compressed-textures/dds/parseDDS.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseDDS.d.ts","sourceRoot":"","sources":["../../../../../../packages/pixijs/src/compressed-textures/dds/parseDDS.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gDAAgD,CAAC;AACtF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gEAAgE,CAAC;AAE3G;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,WAAW,EAAE,WAAW,EAAE,gBAAgB,EAAE,eAAe,EAAE,GAAG,oBAAoB,CAAC,UAAU,EAAE,CAAC,CAsC1H"}

package/dist/packages/pixijs/src/compressed-textures/dds/parseDDS.js

@@ -0,0 +1,170 @@
+import { DDS, DXGI_TO_TEXTURE_FORMAT, FOURCC_TO_TEXTURE_FORMAT, TEXTURE_FORMAT_BLOCK_SIZE } from './const';
+/**
+ * @param arrayBuffer
+ * @param supportedFormats
+ * @internal
+ */
+export function parseDDS(arrayBuffer, supportedFormats) {
+    const { format, fourCC, width, height, dataOffset, mipmapCount, } = parseDDSHeader(arrayBuffer);
+    if (!supportedFormats.includes(format)) {
+        throw new Error(`Unsupported texture format: ${fourCC} ${format}, supported: ${supportedFormats}`);
+    }
+    if (mipmapCount <= 1) { // No need bothering with the imageSize calculation!
+        return {
+            format,
+            width,
+            height,
+            resource: [new Uint8Array(arrayBuffer, dataOffset)],
+            alphaMode: 'no-premultiply-alpha',
+        };
+    }
+    const levelBuffers = getMipmapLevelBuffers(format, width, height, dataOffset, mipmapCount, arrayBuffer);
+    const textureOptions = {
+        format,
+        width,
+        height,
+        resource: levelBuffers,
+        alphaMode: 'no-premultiply-alpha'
+    };
+    return textureOptions;
+}
+function getMipmapLevelBuffers(format, width, height, dataOffset, mipmapCount, arrayBuffer) {
+    const levelBuffers = [];
+    const blockBytes = TEXTURE_FORMAT_BLOCK_SIZE[format];
+    let mipWidth = width;
+    let mipHeight = height;
+    let offset = dataOffset;
+    for (let level = 0; level < mipmapCount; ++level) {
+        // Each dimension must be aligned to a multiple of 4
+        const alignedWidth = Math.ceil(Math.max(4, mipWidth) / 4) * 4;
+        const alignedHeight = Math.ceil(Math.max(4, mipHeight) / 4) * 4;
+        const byteLength = blockBytes
+            ? alignedWidth / 4 * alignedHeight / 4 * blockBytes
+            : mipWidth * mipHeight * 4;
+        const levelBuffer = new Uint8Array(arrayBuffer, offset, byteLength);
+        levelBuffers.push(levelBuffer);
+        offset += byteLength;
+        mipWidth = Math.max(mipWidth >> 1, 1);
+        mipHeight = Math.max(mipHeight >> 1, 1);
+    }
+    return levelBuffers;
+}
+function parseDDSHeader(buffer) {
+    const header = new Uint32Array(buffer, 0, DDS.HEADER_SIZE / Uint32Array.BYTES_PER_ELEMENT);
+    if (header[DDS.HEADER_FIELDS.MAGIC] !== DDS.MAGIC_VALUE) {
+        throw new Error('Invalid magic number in DDS header');
+    }
+    // DDS header fields
+    const height = header[DDS.HEADER_FIELDS.HEIGHT];
+    const width = header[DDS.HEADER_FIELDS.WIDTH];
+    const mipmapCount = Math.max(1, header[DDS.HEADER_FIELDS.MIPMAP_COUNT]);
+    const flags = header[DDS.HEADER_FIELDS.PF_FLAGS];
+    const fourCC = header[DDS.HEADER_FIELDS.FOURCC];
+    const format = getTextureFormat(header, flags, fourCC, buffer);
+    const dataOffset = DDS.MAGIC_SIZE + DDS.HEADER_SIZE
+        + ((fourCC === DDS.D3DFMT.DX10) ? DDS.HEADER_DX10_SIZE : 0);
+    return {
+        format,
+        fourCC,
+        width,
+        height,
+        dataOffset,
+        mipmapCount
+    };
+}
+function getTextureFormat(header, flags, fourCC, buffer) {
+    if (flags & DDS.PIXEL_FORMAT_FLAGS.FOURCC) {
+        if (fourCC === DDS.D3DFMT.DX10) {
+            const dx10Header = new Uint32Array(buffer, DDS.MAGIC_SIZE + DDS.HEADER_SIZE, // there is a 20-byte DDS_HEADER_DX10 after DDS_HEADER
+            DDS.HEADER_DX10_SIZE / Uint32Array.BYTES_PER_ELEMENT);
+            const miscFlag = dx10Header[DDS.HEADER_DX10_FIELDS.MISC_FLAG];
+            if (miscFlag === DDS.RESOURCE_MISC_TEXTURECUBE) {
+                throw new Error('DDSParser does not support cubemap textures');
+            }
+            const resourceDimension = dx10Header[DDS.HEADER_DX10_FIELDS.RESOURCE_DIMENSION];
+            if (resourceDimension === DDS.D3D10_RESOURCE_DIMENSION.DDS_DIMENSION_TEXTURE3D) {
+                throw new Error('DDSParser does not supported 3D texture data');
+            }
+            const dxgiFormat = dx10Header[DDS.HEADER_DX10_FIELDS.DXGI_FORMAT];
+            if (dxgiFormat in DXGI_TO_TEXTURE_FORMAT) {
+                return DXGI_TO_TEXTURE_FORMAT[dxgiFormat];
+            }
+            throw new Error(`DDSParser cannot parse texture data with DXGI format ${dxgiFormat}`);
+        }
+        if (fourCC in FOURCC_TO_TEXTURE_FORMAT) {
+            return FOURCC_TO_TEXTURE_FORMAT[fourCC];
+        }
+        throw new Error(`DDSParser cannot parse texture data with fourCC format ${fourCC}`);
+    }
+    if (flags & DDS.PIXEL_FORMAT_FLAGS.RGB || flags & DDS.PIXEL_FORMAT_FLAGS.RGBA) {
+        return getUncompressedTextureFormat(header);
+    }
+    if (flags & DDS.PIXEL_FORMAT_FLAGS.YUV) {
+        throw new Error('DDSParser does not supported YUV uncompressed texture data.');
+    }
+    if (flags & DDS.PIXEL_FORMAT_FLAGS.LUMINANCE || flags & DDS.PIXEL_FORMAT_FLAGS.LUMINANCEA) {
+        throw new Error('DDSParser does not support single-channel (lumninance) texture data!');
+    }
+    if (flags & DDS.PIXEL_FORMAT_FLAGS.ALPHA || flags & DDS.PIXEL_FORMAT_FLAGS.ALPHAPIXELS) {
+        throw new Error('DDSParser does not support single-channel (alpha) texture data!');
+    }
+    throw new Error('DDSParser failed to load a texture file due to an unknown reason!');
+}
+function getUncompressedTextureFormat(header) {
+    const bitCount = header[DDS.HEADER_FIELDS.RGB_BITCOUNT];
+    const rBitMask = header[DDS.HEADER_FIELDS.R_BIT_MASK];
+    const gBitMask = header[DDS.HEADER_FIELDS.G_BIT_MASK];
+    const bBitMask = header[DDS.HEADER_FIELDS.B_BIT_MASK];
+    const aBitMask = header[DDS.HEADER_FIELDS.A_BIT_MASK];
+    // https://learn.microsoft.com/en-us/windows/win32/direct3ddds/dx-graphics-dds-pguide
+    // https://github.com/microsoft/DirectXTex/blob/main/DDSTextureLoader/DDSTextureLoader11.cpp#L892
+    switch (bitCount) {
+        case 32:
+            if (rBitMask === 0x000000ff && gBitMask === 0x0000ff00 && bBitMask === 0x00ff0000 && aBitMask === 0xff000000) {
+                return DXGI_TO_TEXTURE_FORMAT[DDS.DXGI_FORMAT.DXGI_FORMAT_R8G8B8A8_UNORM];
+            }
+            if (rBitMask === 0x00ff0000 && gBitMask === 0x0000ff00 && bBitMask === 0x000000ff && aBitMask === 0xff000000) {
+                return DXGI_TO_TEXTURE_FORMAT[DDS.DXGI_FORMAT.DXGI_FORMAT_B8G8R8A8_UNORM];
+            }
+            if (rBitMask === 0x3ff00000 && gBitMask === 0x000ffc00 && bBitMask === 0x000003ff && aBitMask === 0xc0000000) {
+                return DXGI_TO_TEXTURE_FORMAT[DDS.DXGI_FORMAT.DXGI_FORMAT_R10G10B10A2_UNORM];
+            }
+            if (rBitMask === 0x0000ffff && gBitMask === 0xffff0000 && bBitMask === 0 && aBitMask === 0) {
+                return DXGI_TO_TEXTURE_FORMAT[DDS.DXGI_FORMAT.DXGI_FORMAT_R16G16_UNORM];
+            }
+            if (rBitMask === 0xffffffff && gBitMask === 0 && bBitMask === 0 && aBitMask === 0) {
+                return DXGI_TO_TEXTURE_FORMAT[DDS.DXGI_FORMAT.DXGI_FORMAT_R32_FLOAT];
+            }
+            break;
+        case 24:
+            if (rBitMask === 0xff0000 && gBitMask === 0xff00 && bBitMask === 0xff && aBitMask === 0x8000) {
+                // rgb8unorm not supported?
+                // return DXGI_TO_TEXTURE_FORMAT[DDS.DXGI_FORMAT.DXGI_FORMAT_B5G5R5A1_UNORM];
+            }
+            break;
+        case 16:
+            if (rBitMask === 0x7c00 && gBitMask === 0x03e0 && bBitMask === 0x001f && aBitMask === 0x8000) {
+                return DXGI_TO_TEXTURE_FORMAT[DDS.DXGI_FORMAT.DXGI_FORMAT_B5G5R5A1_UNORM];
+            }
+            if (rBitMask === 0xf800 && gBitMask === 0x07e0 && bBitMask === 0x001f && aBitMask === 0) {
+                return DXGI_TO_TEXTURE_FORMAT[DDS.DXGI_FORMAT.DXGI_FORMAT_B5G6R5_UNORM];
+            }
+            if (rBitMask === 0x0f00 && gBitMask === 0x00f0 && bBitMask === 0x000f && aBitMask === 0xf000) {
+                return DXGI_TO_TEXTURE_FORMAT[DDS.DXGI_FORMAT.DXGI_FORMAT_B4G4R4A4_UNORM];
+            }
+            if (rBitMask === 0x00ff && gBitMask === 0 && bBitMask === 0 && aBitMask === 0xff00) {
+                return DXGI_TO_TEXTURE_FORMAT[DDS.DXGI_FORMAT.DXGI_FORMAT_R8G8_UNORM];
+            }
+            if (rBitMask === 0xffff && gBitMask === 0 && bBitMask === 0 && aBitMask === 0) {
+                return DXGI_TO_TEXTURE_FORMAT[DDS.DXGI_FORMAT.DXGI_FORMAT_R16_UNORM];
+            }
+            break;
+        case 8:
+            if (rBitMask === 0xff && gBitMask === 0 && bBitMask === 0 && aBitMask === 0) {
+                return DXGI_TO_TEXTURE_FORMAT[DDS.DXGI_FORMAT.DXGI_FORMAT_R8_UNORM];
+            }
+            break;
+    }
+    throw new Error(`DDSParser does not support uncompressed texture with configuration:
+                bitCount = ${bitCount}, rBitMask = ${rBitMask}, gBitMask = ${gBitMask}, aBitMask = ${aBitMask}`);
+}

package/dist/packages/pixijs/src/compressed-textures/index.d.ts

@@ -0,0 +1,26 @@
+export * from './basis/detectBasis';
+export * from './basis/loadBasis';
+export * from './basis/types';
+export * from './basis/utils/createLevelBuffers';
+export * from './basis/utils/gpuFormatToBasisTranscoderFormat';
+export * from './basis/utils/setBasisTranscoderPath';
+export * from './basis/worker/loadBasisOnWorker';
+export * from './dds/const';
+export * from './dds/loadDDS';
+export * from './dds/parseDDS';
+export * from './ktx/loadKTX';
+export * from './ktx/parseKTX';
+export * from './ktx2/const';
+export * from './ktx2/loadKTX2';
+export * from './ktx2/types';
+export * from './ktx2/utils/convertFormatIfRequired';
+export * from './ktx2/utils/createLevelBuffersFromKTX';
+export * from './ktx2/utils/getTextureFormatFromKTXTexture';
+export * from './ktx2/utils/glFormatToGPUFormat';
+export * from './ktx2/utils/gpuFormatToKTXBasisTranscoderFormat';
+export * from './ktx2/utils/setKTXTranscoderPath';
+export * from './ktx2/utils/vkFormatToGPUFormat';
+export * from './ktx2/worker/loadKTX2onWorker';
+export * from './shared/detectCompressed';
+export * from './shared/resolveCompressedTextureUrl';
+//# sourceMappingURL=index.d.ts.map

package/dist/packages/pixijs/src/compressed-textures/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/pixijs/src/compressed-textures/index.ts"],"names":[],"mappings":"AACA,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAC9B,cAAc,kCAAkC,CAAC;AACjD,cAAc,gDAAgD,CAAC;AAC/D,cAAc,sCAAsC,CAAC;AACrD,cAAc,kCAAkC,CAAC;AACjD,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,sCAAsC,CAAC;AACrD,cAAc,wCAAwC,CAAC;AACvD,cAAc,6CAA6C,CAAC;AAC5D,cAAc,kCAAkC,CAAC;AACjD,cAAc,kDAAkD,CAAC;AACjE,cAAc,mCAAmC,CAAC;AAClD,cAAc,kCAAkC,CAAC;AACjD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sCAAsC,CAAC"}

package/dist/packages/pixijs/src/compressed-textures/index.js

@@ -0,0 +1,26 @@
+// Auto-generated code, do not edit manually
+export * from './basis/detectBasis';
+export * from './basis/loadBasis';
+export * from './basis/types';
+export * from './basis/utils/createLevelBuffers';
+export * from './basis/utils/gpuFormatToBasisTranscoderFormat';
+export * from './basis/utils/setBasisTranscoderPath';
+export * from './basis/worker/loadBasisOnWorker';
+export * from './dds/const';
+export * from './dds/loadDDS';
+export * from './dds/parseDDS';
+export * from './ktx/loadKTX';
+export * from './ktx/parseKTX';
+export * from './ktx2/const';
+export * from './ktx2/loadKTX2';
+export * from './ktx2/types';
+export * from './ktx2/utils/convertFormatIfRequired';
+export * from './ktx2/utils/createLevelBuffersFromKTX';
+export * from './ktx2/utils/getTextureFormatFromKTXTexture';
+export * from './ktx2/utils/glFormatToGPUFormat';
+export * from './ktx2/utils/gpuFormatToKTXBasisTranscoderFormat';
+export * from './ktx2/utils/setKTXTranscoderPath';
+export * from './ktx2/utils/vkFormatToGPUFormat';
+export * from './ktx2/worker/loadKTX2onWorker';
+export * from './shared/detectCompressed';
+export * from './shared/resolveCompressedTextureUrl';

package/dist/packages/pixijs/src/compressed-textures/ktx/init.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=init.d.ts.map

package/dist/packages/pixijs/src/compressed-textures/ktx/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../../../../packages/pixijs/src/compressed-textures/ktx/init.ts"],"names":[],"mappings":""}

package/dist/packages/pixijs/src/compressed-textures/ktx/init.js

@@ -0,0 +1,7 @@
+import { extensions } from '../../extensions/Extensions';
+import { detectCompressed } from '../shared/detectCompressed';
+import { resolveCompressedTextureUrl } from '../shared/resolveCompressedTextureUrl';
+import { loadKTX } from './loadKTX';
+extensions.add(loadKTX);
+extensions.add(resolveCompressedTextureUrl);
+extensions.add(detectCompressed);

package/dist/packages/pixijs/src/compressed-textures/ktx/loadKTX.d.ts

@@ -0,0 +1,24 @@
+import { LoaderParserPriority } from '../../assets/loader/parsers/LoaderParser';
+import { ExtensionType } from '../../extensions/Extensions';
+import type { Loader } from '../../assets/loader/Loader';
+import type { ResolvedAsset } from '../../assets/types';
+import type { Texture } from '../../rendering/renderers/shared/texture/Texture';
+/**
+ * Loads KTX textures.
+ * @category assets
+ * @advanced
+ */
+export declare const loadKTX: {
+    extension: {
+        type: ExtensionType.LoadParser;
+        priority: LoaderParserPriority;
+        name: string;
+    };
+    /** used for deprecation purposes */
+    name: string;
+    id: string;
+    test(url: string): boolean;
+    load<T>(url: string, _asset: ResolvedAsset, loader: Loader): Promise<Texture | Texture[]>;
+    unload(texture: Texture | Texture[]): void;
+};
+//# sourceMappingURL=loadKTX.d.ts.map

package/dist/packages/pixijs/src/compressed-textures/ktx/loadKTX.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadKTX.d.ts","sourceRoot":"","sources":["../../../../../../packages/pixijs/src/compressed-textures/ktx/loadKTX.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,0CAA0C,CAAC;AAGhF,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAK5D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAEzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAExD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kDAAkD,CAAC;AAEhF;;;;GAIG;AACH,eAAO,MAAM,OAAO;;;;;;IAOhB,oCAAoC;;;cAI1B,MAAM,GAAG,OAAO;iBAKV,MAAM,UAAU,aAAa,UAAU,MAAM,GAAG,OAAO,CAAC,OAAO,GAAG,OAAO,EAAE,CAAC;oBAe5E,OAAO,GAAG,OAAO,EAAE,GAAG,IAAI;CAYqB,CAAC"}

package/dist/packages/pixijs/src/compressed-textures/ktx/loadKTX.js

@@ -0,0 +1,52 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { LoaderParserPriority } from '../../assets/loader/parsers/LoaderParser';
+import { createTexture } from '../../assets/loader/parsers/textures/utils/createTexture';
+import { checkExtension } from '../../assets/utils/checkExtension';
+import { ExtensionType } from '../../extensions/Extensions';
+import { CompressedSource } from '../../rendering/renderers/shared/texture/sources/CompressedSource';
+import { getSupportedTextureFormats } from '../../rendering/renderers/shared/texture/utils/getSupportedTextureFormats';
+import { parseKTX } from './parseKTX';
+/**
+ * Loads KTX textures.
+ * @category assets
+ * @advanced
+ */
+export const loadKTX = {
+    extension: {
+        type: ExtensionType.LoadParser,
+        priority: LoaderParserPriority.High,
+        name: 'loadKTX',
+    },
+    /** used for deprecation purposes */
+    name: 'loadKTX',
+    id: 'ktx',
+    test(url) {
+        return checkExtension(url, '.ktx');
+    },
+    load(url, _asset, loader) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const supportedTextures = yield getSupportedTextureFormats();
+            const ktxResponse = yield fetch(url);
+            const ktxArrayBuffer = yield ktxResponse.arrayBuffer();
+            const textureOptions = parseKTX(ktxArrayBuffer, supportedTextures);
+            const compressedTextureSource = new CompressedSource(textureOptions);
+            return createTexture(compressedTextureSource, loader, url);
+        });
+    },
+    unload(texture) {
+        if (Array.isArray(texture)) {
+            texture.forEach((t) => t.destroy(true));
+        }
+        else {
+            texture.destroy(true);
+        }
+    }
+};

package/dist/packages/pixijs/src/compressed-textures/ktx/parseKTX.d.ts

@@ -0,0 +1,9 @@
+import type { TEXTURE_FORMATS } from '../../rendering/renderers/shared/texture/const';
+import type { TextureSourceOptions } from '../../rendering/renderers/shared/texture/sources/TextureSource';
+/**
+ * @param arrayBuffer
+ * @param supportedFormats
+ * @internal
+ */
+export declare function parseKTX(arrayBuffer: ArrayBuffer, supportedFormats: TEXTURE_FORMATS[]): TextureSourceOptions<Uint8Array[]>;
+//# sourceMappingURL=parseKTX.d.ts.map

package/dist/packages/pixijs/src/compressed-textures/ktx/parseKTX.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseKTX.d.ts","sourceRoot":"","sources":["../../../../../../packages/pixijs/src/compressed-textures/ktx/parseKTX.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gDAAgD,CAAC;AACtF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gEAAgE,CAAC;AAE3G;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,WAAW,EAAE,WAAW,EAAE,gBAAgB,EAAE,eAAe,EAAE,GAAG,oBAAoB,CAAC,UAAU,EAAE,CAAC,CA2C1H"}

package/dist/packages/pixijs/src/compressed-textures/ktx/parseKTX.js

@@ -0,0 +1,124 @@
+import { KTX } from '../ktx2/const';
+/**
+ * @param arrayBuffer
+ * @param supportedFormats
+ * @internal
+ */
+export function parseKTX(arrayBuffer, supportedFormats) {
+    const dataView = new DataView(arrayBuffer);
+    if (!validate(dataView)) {
+        throw new Error('Invalid KTX identifier in header');
+    }
+    const { littleEndian, glType, glFormat, glInternalFormat, pixelWidth, pixelHeight, numberOfMipmapLevels, offset, } = parseKTXHeader(dataView);
+    const textureFormat = KTX.INTERNAL_FORMAT_TO_TEXTURE_FORMATS[glInternalFormat];
+    if (!textureFormat) {
+        throw new Error(`Unknown texture format ${glInternalFormat}`);
+    }
+    if (!supportedFormats.includes(textureFormat)) {
+        throw new Error(`Unsupported texture format: ${textureFormat}, supportedFormats: ${supportedFormats}`);
+    }
+    const imagePixelByteSize = getImagePixelByteSize(glType, glFormat, glInternalFormat);
+    const imageBuffers = getImageBuffers(dataView, glType, imagePixelByteSize, pixelWidth, pixelHeight, offset, numberOfMipmapLevels, littleEndian);
+    return {
+        format: textureFormat,
+        width: pixelWidth,
+        height: pixelHeight,
+        resource: imageBuffers,
+        alphaMode: 'no-premultiply-alpha'
+    };
+}
+function getImageBuffers(dataView, glType, imagePixelByteSize, pixelWidth, pixelHeight, offset, numberOfMipmapLevels, littleEndian) {
+    const alignedWidth = (pixelWidth + 3) & ~3;
+    const alignedHeight = (pixelHeight + 3) & ~3;
+    let imagePixels = pixelWidth * pixelHeight;
+    if (glType === 0) {
+        // Align to 16 pixels (4x4 blocks)
+        imagePixels = alignedWidth * alignedHeight;
+    }
+    let mipByteSize = imagePixels * imagePixelByteSize;
+    let mipWidth = pixelWidth;
+    let mipHeight = pixelHeight;
+    let alignedMipWidth = alignedWidth;
+    let alignedMipHeight = alignedHeight;
+    let imageOffset = offset;
+    const imageBuffers = new Array(numberOfMipmapLevels);
+    for (let mipmapLevel = 0; mipmapLevel < numberOfMipmapLevels; mipmapLevel++) {
+        const imageSize = dataView.getUint32(imageOffset, littleEndian);
+        let elementOffset = imageOffset + 4;
+        imageBuffers[mipmapLevel] = new Uint8Array(dataView.buffer, elementOffset, mipByteSize);
+        elementOffset += mipByteSize;
+        // HINT: Aligns to 4-byte boundary after jumping imageSize (in lieu of mipPadding)
+        imageOffset += imageSize + 4; // (+4 to jump the imageSize field itself)
+        imageOffset = imageOffset % 4 !== 0 ? imageOffset + 4 - (imageOffset % 4) : imageOffset;
+        // Calculate mipWidth, mipHeight for _next_ iteration
+        mipWidth = (mipWidth >> 1) || 1;
+        mipHeight = (mipHeight >> 1) || 1;
+        alignedMipWidth = (mipWidth + 4 - 1) & ~(4 - 1);
+        alignedMipHeight = (mipHeight + 4 - 1) & ~(4 - 1);
+        // Each mipmap level is 4-times smaller?
+        mipByteSize = alignedMipWidth * alignedMipHeight * imagePixelByteSize;
+    }
+    return imageBuffers;
+}
+function getImagePixelByteSize(glType, glFormat, glInternalFormat) {
+    let imagePixelByteSize = KTX.INTERNAL_FORMAT_TO_BYTES_PER_PIXEL[glInternalFormat];
+    if (glType !== 0) {
+        // Uncompressed texture format
+        if (KTX.TYPES_TO_BYTES_PER_COMPONENT[glType]) {
+            imagePixelByteSize = KTX.TYPES_TO_BYTES_PER_COMPONENT[glType] * KTX.FORMATS_TO_COMPONENTS[glFormat];
+        }
+        else {
+            imagePixelByteSize = KTX.TYPES_TO_BYTES_PER_PIXEL[glType];
+        }
+    }
+    if (imagePixelByteSize === undefined) {
+        throw new Error('Unable to resolve the pixel format stored in the *.ktx file!');
+    }
+    return imagePixelByteSize;
+}
+function parseKTXHeader(dataView) {
+    const littleEndian = dataView.getUint32(KTX.FIELDS.ENDIANNESS, true) === KTX.ENDIANNESS;
+    const glType = dataView.getUint32(KTX.FIELDS.GL_TYPE, littleEndian);
+    const glFormat = dataView.getUint32(KTX.FIELDS.GL_FORMAT, littleEndian);
+    const glInternalFormat = dataView.getUint32(KTX.FIELDS.GL_INTERNAL_FORMAT, littleEndian);
+    const pixelWidth = dataView.getUint32(KTX.FIELDS.PIXEL_WIDTH, littleEndian);
+    const pixelHeight = dataView.getUint32(KTX.FIELDS.PIXEL_HEIGHT, littleEndian) || 1; // "pixelHeight = 0" -> "1"
+    const pixelDepth = dataView.getUint32(KTX.FIELDS.PIXEL_DEPTH, littleEndian) || 1; // ^^
+    const numberOfArrayElements = dataView.getUint32(KTX.FIELDS.NUMBER_OF_ARRAY_ELEMENTS, littleEndian) || 1; // ^^
+    const numberOfFaces = dataView.getUint32(KTX.FIELDS.NUMBER_OF_FACES, littleEndian);
+    const numberOfMipmapLevels = dataView.getUint32(KTX.FIELDS.NUMBER_OF_MIPMAP_LEVELS, littleEndian);
+    const bytesOfKeyValueData = dataView.getUint32(KTX.FIELDS.BYTES_OF_KEY_VALUE_DATA, littleEndian);
+    if (pixelHeight === 0 || pixelDepth !== 1) {
+        throw new Error('Only 2D textures are supported');
+    }
+    if (numberOfFaces !== 1) {
+        throw new Error('CubeTextures are not supported by KTXLoader yet!');
+    }
+    if (numberOfArrayElements !== 1) {
+        throw new Error('WebGL does not support array textures');
+    }
+    return {
+        littleEndian,
+        glType,
+        glFormat,
+        glInternalFormat,
+        pixelWidth,
+        pixelHeight,
+        numberOfMipmapLevels,
+        offset: KTX.FILE_HEADER_SIZE + bytesOfKeyValueData
+    };
+}
+/**
+ * Checks whether the arrayBuffer contains a valid *.ktx file.
+ * @param dataView
+ */
+function validate(dataView) {
+    // NOTE: Do not optimize this into 3 32-bit integer comparison because the endianness
+    // of the data is not specified.
+    for (let i = 0; i < KTX.FILE_IDENTIFIER.length; i++) {
+        if (dataView.getUint8(i) !== KTX.FILE_IDENTIFIER[i]) {
+            return false;
+        }
+    }
+    return true;
+}