@safe-engine/pixi 8.10.0 → 8.10.2

package/dist/packages/pixijs/src/rendering/renderers/shared/texture/__tests__/TextureSource.test.js

@@ -0,0 +1,58 @@
+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 { TextureSource } from '../sources/TextureSource';
+import { getWebGLRenderer } from '@test-utils';
+describe('TextureSource', () => {
+    it('a texture style change should emit an update that the renderer can listen to', () => {
+        const textureSource = new TextureSource();
+        const eventSpy = jest.spyOn(textureSource, 'emit');
+        textureSource.style.addressModeU = 'repeat';
+        textureSource.style.update();
+        expect(eventSpy).toHaveBeenCalledWith('styleChange', textureSource);
+    });
+    it('calling unload on a texture should increment the resourceId to be the next unique id', () => {
+        const textureSource = new TextureSource();
+        const textureSource2 = new TextureSource();
+        const startingId = textureSource._resourceId;
+        expect(textureSource2._resourceId).toBe(startingId + 1);
+        textureSource.unload();
+        expect(textureSource._resourceId).toBe(startingId + 2);
+    });
+    it('TextureSystem should not re add listeners if a texture is unloaded', () => __awaiter(void 0, void 0, void 0, function* () {
+        const textureSource = new TextureSource();
+        const renderer = yield getWebGLRenderer();
+        renderer.texture.bind(textureSource);
+        expect(renderer.texture.managedTextures.length).toBe(2);
+        textureSource.unload();
+        renderer.texture.bind(textureSource);
+        expect(renderer.texture.managedTextures.length).toBe(2);
+    }));
+    it('expect label to be set form constructor', () => {
+        const textureSource = new TextureSource({ label: 'test' });
+        expect(textureSource.label).toBe('test');
+    });
+    it('calling update should cause a resize event to be fired if the resource has changed size', () => {
+        const canvas = document.createElement('canvas');
+        canvas.width = 1;
+        canvas.height = 1;
+        const textureSource = new TextureSource({
+            resource: canvas,
+        });
+        const eventSpy = jest.spyOn(textureSource, 'emit');
+        textureSource.update();
+        expect(eventSpy).toHaveBeenCalledWith('update', textureSource);
+        expect(eventSpy).not.toHaveBeenCalledWith('resize', textureSource);
+        canvas.width = 2;
+        canvas.height = 2;
+        textureSource.update();
+        expect(eventSpy).toHaveBeenCalledWith('resize', textureSource);
+        expect(eventSpy).toHaveBeenNthCalledWith(1, 'update', textureSource);
+    });
+});

package/dist/packages/pixijs/src/rendering/renderers/shared/texture/__tests__/Textures.test.d.ts

@@ -0,0 +1,2 @@
+import '~/rendering/init';
+//# sourceMappingURL=Textures.test.d.ts.map

package/dist/packages/pixijs/src/rendering/renderers/shared/texture/__tests__/Textures.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Textures.test.d.ts","sourceRoot":"","sources":["../../../../../../../../../packages/pixijs/src/rendering/renderers/shared/texture/__tests__/Textures.test.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC"}

package/dist/packages/pixijs/src/rendering/renderers/shared/texture/__tests__/Textures.test.js

@@ -0,0 +1,71 @@
+import '~/rendering/init';
+import { Texture } from '../Texture';
+import { Cache } from '~/assets';
+describe('Texture', () => {
+    it('destroying a destroyed texture should not throw an error', () => {
+        const texture = new Texture();
+        texture.destroy(true);
+        expect(() => { texture.destroy(true); }).not.toThrow();
+    });
+    it('should return the same texture if the resource is the same', () => {
+        const videoElement = document.createElement('video');
+        let texture = Texture.from({ resource: videoElement });
+        expect(Texture.from({ resource: videoElement })).toBe(texture);
+        expect(Cache.has(videoElement)).toBe(true);
+        const imageElement = document.createElement('img');
+        texture = Texture.from({ resource: imageElement });
+        expect(Texture.from({ resource: imageElement })).toBe(texture);
+        expect(Cache.has(imageElement)).toBe(true);
+        const canvasElement = document.createElement('canvas');
+        texture = Texture.from({ resource: canvasElement });
+        expect(Texture.from({ resource: canvasElement })).toBe(texture);
+        expect(Cache.has(canvasElement)).toBe(true);
+        const buffer = new Uint8Array([
+            255, 0, 0, 255, 0, 255, 0, 153,
+            0, 0, 255, 102, 255, 255, 0, 51
+        ]);
+        texture = Texture.from({
+            resource: buffer,
+            width: 2,
+            height: 2,
+        });
+        expect(Texture.from({ resource: buffer, width: 2, height: 2 })).toBe(texture);
+        expect(Cache.has(buffer)).toBe(true);
+    });
+    it('should return the same texture when resource is the same', () => {
+        const videoElement = document.createElement('video');
+        let texture = Texture.from(videoElement);
+        expect(Texture.from(videoElement)).toBe(texture);
+        expect(Cache.has(videoElement)).toBe(true);
+        const imageElement = document.createElement('img');
+        texture = Texture.from(imageElement);
+        expect(Texture.from(imageElement)).toBe(texture);
+        expect(Cache.has(imageElement)).toBe(true);
+        const canvasElement = document.createElement('canvas');
+        texture = Texture.from(canvasElement);
+        expect(Texture.from(canvasElement)).toBe(texture);
+        expect(Cache.has(canvasElement)).toBe(true);
+        const buffer = new Uint8Array([
+            255, 0, 0, 255, 0, 255, 0, 153,
+            0, 0, 255, 102, 255, 255, 0, 51
+        ]);
+        texture = Texture.from({
+            resource: buffer,
+            width: 2,
+            height: 2,
+        });
+        expect(Texture.from({ resource: buffer, width: 2, height: 2 })).toBe(texture);
+        expect(Cache.has(buffer)).toBe(true);
+    });
+    it('texture.WHITE should have correct alpha mode set', () => {
+        expect(Texture.WHITE.source.alphaMode).toBe('premultiply-alpha-on-upload');
+    });
+    it('should call update a texture correctly', () => {
+        const texture = new Texture();
+        // spy on texture update event
+        const spy = jest.fn();
+        texture.on('update', spy);
+        texture.update();
+        expect(spy).toHaveBeenCalled();
+    });
+});

package/dist/packages/pixijs/src/rendering/renderers/shared/texture/__tests__/VideoSource.test.d.ts

@@ -0,0 +1,2 @@
+import '~/environment-browser/browserAll';
+//# sourceMappingURL=VideoSource.test.d.ts.map

package/dist/packages/pixijs/src/rendering/renderers/shared/texture/__tests__/VideoSource.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VideoSource.test.d.ts","sourceRoot":"","sources":["../../../../../../../../../packages/pixijs/src/rendering/renderers/shared/texture/__tests__/VideoSource.test.ts"],"names":[],"mappings":"AAAA,OAAO,kCAAkC,CAAC"}

package/dist/packages/pixijs/src/rendering/renderers/shared/texture/__tests__/VideoSource.test.js

@@ -0,0 +1,105 @@
+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 '~/environment-browser/browserAll';
+import { VideoSource } from '../sources/VideoSource';
+import { getAsset } from '@test-utils';
+import { Assets } from '~/assets';
+const url = getAsset('video/park.mp4');
+describe('VideoSource', () => {
+    const setup = (options, forceUrl) => __awaiter(void 0, void 0, void 0, function* () {
+        const texture = yield Assets.load({
+            src: forceUrl !== null && forceUrl !== void 0 ? forceUrl : url,
+            data: options
+        });
+        const source = texture.source;
+        const sourceElement = source.resource.firstElementChild;
+        return { source, sourceElement };
+    });
+    beforeEach(() => {
+        // clear the cache since we're creating new properties for the existing source
+        Assets.reset();
+    });
+    it('should create new source', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { source, sourceElement } = yield setup();
+        expect(source.resource).toBeInstanceOf(HTMLVideoElement);
+        expect(sourceElement.src).toEqual(url);
+        // expect initial state to have dimensions (loadVideoTextures loader waits for canplay before resolving)
+        expect(source.width).toEqual(1920);
+        expect(source.height).toEqual(1080);
+        expect(source.pixelWidth).toEqual(1920);
+        expect(source.pixelHeight).toEqual(1080);
+        expect(source.isReady).toBe(true);
+        expect(source.isValid).toBe(true);
+    }));
+    it('should load new source', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { source: videoSource } = yield setup();
+        const source = yield videoSource.load();
+        expect(source).toEqual(videoSource);
+        expect(source.width).toEqual(1920);
+        expect(source.height).toEqual(1080);
+        expect(source.isValid).toBe(true);
+        expect(source.isReady).toBe(true);
+    }));
+    it('should find correct video extension from Url', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { sourceElement } = yield setup();
+        expect(sourceElement.type).toEqual('video/mp4');
+    }));
+    it('should get video extension without being thrown by query string', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { sourceElement } = yield setup({}, `${url}?some=param`);
+        expect(sourceElement.type).toEqual('video/mp4');
+    }));
+    it('should respect the updateFPS settings property and getter / setter', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { source } = yield setup({ updateFPS: 30 });
+        yield source.load();
+        expect(source.updateFPS).toEqual(30);
+        source.updateFPS = 20;
+        expect(source.updateFPS).toEqual(20);
+    }));
+    it('should load data URL', () => __awaiter(void 0, void 0, void 0, function* () {
+        // eslint-disable-next-line max-len
+        const webmDataURL = 'data:video/webm;base64,GkXfo59ChoEBQveBAULygQRC84EIQoKEd2VibUKHgQJChYECGFOAZwEAAAAAAAHTEU2bdLpNu4tTq4QVSalmU6yBoU27i1OrhBZUrmtTrIHGTbuMU6uEElTDZ1OsggEXTbuMU6uEHFO7a1OsggG97AEAAAAAAABZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVSalmoCrXsYMPQkBNgIRMYXZmV0GETGF2ZkSJiEBEAAAAAAAAFlSua8yuAQAAAAAAAEPXgQFzxYgAAAAAAAAAAZyBACK1nIN1bmSIgQCGhVZfVlA5g4EBI+ODhAJiWgDglLCBArqBApqBAlPAgQFVsIRVuYEBElTDZ9Vzc9JjwItjxYgAAAAAAAAAAWfInEWjh0VOQ09ERVJEh49MYXZjIGxpYnZweC12cDlnyKJFo4hEVVJBVElPTkSHlDAwOjAwOjAwLjA0MDAwMDAwMAAAH0O2dcfngQCgwqGggQAAAIJJg0IAABAAFgA4JBwYSgAAICAAEb///4r+AAB1oZ2mm+6BAaWWgkmDQgAAEAAWADgkHBhKAAAgIABIQBxTu2uRu4+zgQC3iveBAfGCAXHwgQM=';
+        const { source } = yield setup({}, webmDataURL);
+        yield expect(source.load()).toResolve();
+    }));
+    it('should not hang on load if an error occurs', () => __awaiter(void 0, void 0, void 0, function* () {
+        const video = document.createElement('video');
+        video.autoplay = false;
+        video.crossOrigin = 'anonymous';
+        video.preload = 'auto';
+        video.src = 'data:video/webm;base64,';
+        const source = new VideoSource({
+            resource: video,
+            autoLoad: false,
+        });
+        expect(source.width).toEqual(0);
+        expect(source.height).toEqual(0);
+        expect(source.isReady).toBe(false);
+        expect(source.isValid).toBe(false);
+        expect(source.resource).toBeInstanceOf(HTMLVideoElement);
+        const errorOnLoad = new Promise((resolve) => {
+            source.resource.addEventListener('loadeddata', () => resolve(false));
+            source.resource.addEventListener('error', () => resolve(true));
+        });
+        const loadPromise = source.load();
+        yield expect(errorOnLoad).toResolve();
+        expect(yield errorOnLoad).toBe(true);
+        yield expect(loadPromise).toReject();
+    }));
+    it('should wait until fully loaded if preload option is true', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { source } = yield setup({ preload: true, autoLoad: false }); // autoLoad=false to give us time to add spies
+        const mediaReadySpy = jest.spyOn(source, '_mediaReady');
+        const canPlaySpy = jest.spyOn(source, '_onCanPlay');
+        const canPlayThroughSpy = jest.spyOn(source, '_onCanPlayThrough');
+        yield source.load();
+        expect(mediaReadySpy).toHaveBeenCalled();
+        expect(canPlaySpy).not.toHaveBeenCalled();
+        expect(canPlayThroughSpy).not.toHaveBeenCalled();
+    }));
+});

package/dist/packages/pixijs/src/rendering/renderers/shared/texture/const.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Specifies the alpha composition mode for textures.
+ *
+ * - `no-premultiply-alpha`: Does not premultiply alpha.
+ * - `premultiply-alpha-on-upload`: Premultiplies alpha on texture upload.
+ * - `premultiplied-alpha`: Assumes the texture is already in premultiplied alpha format.
+ * @category rendering
+ * @advanced
+ */
+export type ALPHA_MODES = 'no-premultiply-alpha' | 'premultiply-alpha-on-upload' | 'premultiplied-alpha';
+/**
+ * The texture formats that are supported by pixi.
+ *
+ * These formats are used to specify the format of textures in WebGPU and WebGL.
+ * They include various uncompressed, compressed, and depth/stencil formats.
+ * @category rendering
+ * @advanced
+ */
+export type TEXTURE_FORMATS = 'r8unorm' | 'r8snorm' | 'r8uint' | 'r8sint' | 'r16uint' | 'r16sint' | 'r16float' | 'rg8unorm' | 'rg8snorm' | 'rg8uint' | 'rg8sint' | 'r32uint' | 'r32sint' | 'r32float' | 'rg16uint' | 'rg16sint' | 'rg16float' | 'rgba8unorm' | 'rgba8unorm-srgb' | 'rgba8snorm' | 'rgba8uint' | 'rgba8sint' | 'bgra8unorm' | 'bgra8unorm-srgb' | 'rgb9e5ufloat' | 'rgb10a2unorm' | 'rg11b10ufloat' | 'rg32uint' | 'rg32sint' | 'rg32float' | 'rgba16uint' | 'rgba16sint' | 'rgba16float' | 'rgba32uint' | 'rgba32sint' | 'rgba32float' | 'stencil8' | 'depth16unorm' | 'depth24plus' | 'depth24plus-stencil8' | 'depth32float' | 'depth32float-stencil8' | 'bc1-rgba-unorm' | 'bc1-rgba-unorm-srgb' | 'bc2-rgba-unorm' | 'bc2-rgba-unorm-srgb' | 'bc3-rgba-unorm' | 'bc3-rgba-unorm-srgb' | 'bc4-r-unorm' | 'bc4-r-snorm' | 'bc5-rg-unorm' | 'bc5-rg-snorm' | 'bc6h-rgb-ufloat' | 'bc6h-rgb-float' | 'bc7-rgba-unorm' | 'bc7-rgba-unorm-srgb' | 'etc2-rgb8unorm' | 'etc2-rgb8unorm-srgb' | 'etc2-rgb8a1unorm' | 'etc2-rgb8a1unorm-srgb' | 'etc2-rgba8unorm' | 'etc2-rgba8unorm-srgb' | 'eac-r11unorm' | 'eac-r11snorm' | 'eac-rg11unorm' | 'eac-rg11snorm' | 'astc-4x4-unorm' | 'astc-4x4-unorm-srgb' | 'astc-5x4-unorm' | 'astc-5x4-unorm-srgb' | 'astc-5x5-unorm' | 'astc-5x5-unorm-srgb' | 'astc-6x5-unorm' | 'astc-6x5-unorm-srgb' | 'astc-6x6-unorm' | 'astc-6x6-unorm-srgb' | 'astc-8x5-unorm' | 'astc-8x5-unorm-srgb' | 'astc-8x6-unorm' | 'astc-8x6-unorm-srgb' | 'astc-8x8-unorm' | 'astc-8x8-unorm-srgb' | 'astc-10x5-unorm' | 'astc-10x5-unorm-srgb' | 'astc-10x6-unorm' | 'astc-10x6-unorm-srgb' | 'astc-10x8-unorm' | 'astc-10x8-unorm-srgb' | 'astc-10x10-unorm' | 'astc-10x10-unorm-srgb' | 'astc-12x10-unorm' | 'astc-12x10-unorm-srgb' | 'astc-12x12-unorm' | 'astc-12x12-unorm-srgb';
+/**
+ * The texture dimensions that are supported by pixi.
+ *
+ * - `1d` is a one-dimensional texture, which is typically used for linear data.
+ * - `2d` is a two-dimensional texture, which is commonly used for images and textures.
+ * - `3d` is a three-dimensional texture, which is used for volumetric data or 3D textures.
+ * @category rendering
+ * @advanced
+ */
+export type TEXTURE_DIMENSIONS = '1d' | '2d' | '3d';
+/**
+ * The wrap modes that are supported by pixi.
+ *
+ * The wrap mode affects the default wrapping mode of future operations.
+ * - `clamp-to-edge` is the default mode, which clamps the texture coordinates to the edge of the texture.
+ * - `repeat` allows the texture to repeat in both u and v directions.
+ * - `mirror-repeat` allows the texture to repeat in both u and v directions, but mirrors the texture on every other repeat.
+ * @category rendering
+ * @standard
+ */
+export type WRAP_MODE = 'clamp-to-edge' | 'repeat' | 'mirror-repeat';
+/** @internal */
+export declare enum DEPRECATED_WRAP_MODES {
+    CLAMP = "clamp-to-edge",
+    REPEAT = "repeat",
+    MIRRORED_REPEAT = "mirror-repeat"
+}
+/**
+ * The wrap modes that are supported by pixi.
+ * @deprecated since 8.0.0
+ * @category rendering
+ * @see WRAP_MODE
+ * @advanced
+ */
+export declare const WRAP_MODES: typeof DEPRECATED_WRAP_MODES;
+/**
+ * The scale modes that are supported by pixi.
+ *
+ * The scale mode affects the default scaling mode of future operations.
+ * It can be re-assigned to either LINEAR or NEAREST, depending upon suitability.
+ *
+ * - `nearest` is a pixelating scaling mode, which does not interpolate pixels.
+ * - `linear` is a smooth scaling mode, which interpolates pixels for smoother results.
+ * @category rendering
+ * @standard
+ */
+export type SCALE_MODE = 'nearest' | 'linear';
+/** @internal */
+export declare enum DEPRECATED_SCALE_MODES {
+    NEAREST = "nearest",
+    LINEAR = "linear"
+}
+/**
+ * The scale modes that are supported by pixi.
+ * @deprecated since 8.0.0
+ * @category rendering
+ * @see SCALE_MODE
+ * @advanced
+ */
+export declare const SCALE_MODES: typeof DEPRECATED_SCALE_MODES;
+/**
+ * The compare function types used for comparing values in various operations.
+ * @category rendering
+ * @advanced
+ */
+export type COMPARE_FUNCTION = 'never' | 'less' | 'equal' | 'less-equal' | 'greater' | 'not-equal' | 'greater-equal' | 'always';
+//# sourceMappingURL=const.d.ts.map

package/dist/packages/pixijs/src/rendering/renderers/shared/texture/const.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"const.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/pixijs/src/rendering/renderers/shared/texture/const.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,MAAM,MAAM,WAAW,GACnB,sBAAsB,GACtB,6BAA6B,GAC7B,qBAAqB,CAAC;AAE1B;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,GAEvB,SAAS,GACT,SAAS,GACT,QAAQ,GACR,QAAQ,GAGR,SAAS,GACT,SAAS,GACT,UAAU,GACV,UAAU,GACV,UAAU,GACV,SAAS,GACT,SAAS,GAGT,SAAS,GACT,SAAS,GACT,UAAU,GACV,UAAU,GACV,UAAU,GACV,WAAW,GACX,YAAY,GACZ,iBAAiB,GACjB,YAAY,GACZ,WAAW,GACX,WAAW,GACX,YAAY,GACZ,iBAAiB,GAEjB,cAAc,GACd,cAAc,GACd,eAAe,GAGf,UAAU,GACV,UAAU,GACV,WAAW,GACX,YAAY,GACZ,YAAY,GACZ,aAAa,GAGb,YAAY,GACZ,YAAY,GACZ,aAAa,GAGb,UAAU,GACV,cAAc,GACd,aAAa,GACb,sBAAsB,GACtB,cAAc,GAGd,uBAAuB,GAIvB,gBAAgB,GAChB,qBAAqB,GACrB,gBAAgB,GAChB,qBAAqB,GACrB,gBAAgB,GAChB,qBAAqB,GACrB,aAAa,GACb,aAAa,GACb,cAAc,GACd,cAAc,GACd,iBAAiB,GACjB,gBAAgB,GAChB,gBAAgB,GAChB,qBAAqB,GAIrB,gBAAgB,GAChB,qBAAqB,GACrB,kBAAkB,GAClB,uBAAuB,GACvB,iBAAiB,GACjB,sBAAsB,GACtB,cAAc,GACd,cAAc,GACd,eAAe,GACf,eAAe,GAIf,gBAAgB,GAChB,qBAAqB,GACrB,gBAAgB,GAChB,qBAAqB,GACrB,gBAAgB,GAChB,qBAAqB,GACrB,gBAAgB,GAChB,qBAAqB,GACrB,gBAAgB,GAChB,qBAAqB,GACrB,gBAAgB,GAChB,qBAAqB,GACrB,gBAAgB,GAChB,qBAAqB,GACrB,gBAAgB,GAChB,qBAAqB,GACrB,iBAAiB,GACjB,sBAAsB,GACtB,iBAAiB,GACjB,sBAAsB,GACtB,iBAAiB,GACjB,sBAAsB,GACtB,kBAAkB,GAClB,uBAAuB,GACvB,kBAAkB,GAClB,uBAAuB,GACvB,kBAAkB,GAClB,uBAAuB,CAAC;AAE5B;;;;;;;;GAQG;AACH,MAAM,MAAM,kBAAkB,GACxB,IAAI,GACJ,IAAI,GACJ,IAAI,CAAC;AAEX;;;;;;;;;GASG;AACH,MAAM,MAAM,SAAS,GACf,eAAe,GACf,QAAQ,GACR,eAAe,CAAC;AAEtB,gBAAgB;AAChB,oBAAY,qBAAqB;IAE7B,KAAK,kBAAkB;IAEvB,MAAM,WAAW;IAEjB,eAAe,kBAAkB;CACpC;AAED;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,8BASrB,CAAC;AAEH;;;;;;;;;;GAUG;AACH,MAAM,MAAM,UAAU,GAAK,SAAS,GAAG,QAAQ,CAAC;AAEhD,gBAAgB;AAChB,oBAAY,sBAAsB;IAE9B,OAAO,YAAY;IACnB,MAAM,WAAW;CACpB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,+BAStB,CAAC;AAEH;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GACtB,OAAO,GACP,MAAM,GACN,OAAO,GACP,YAAY,GACZ,SAAS,GACT,WAAW,GACX,eAAe,GACf,QAAQ,CAAC"}

package/dist/packages/pixijs/src/rendering/renderers/shared/texture/const.js

@@ -0,0 +1,44 @@
+import { deprecation, v8_0_0 } from '../../../../utils/logging/deprecation';
+/** @internal */
+export var DEPRECATED_WRAP_MODES;
+(function (DEPRECATED_WRAP_MODES) {
+    DEPRECATED_WRAP_MODES["CLAMP"] = "clamp-to-edge";
+    DEPRECATED_WRAP_MODES["REPEAT"] = "repeat";
+    DEPRECATED_WRAP_MODES["MIRRORED_REPEAT"] = "mirror-repeat";
+})(DEPRECATED_WRAP_MODES || (DEPRECATED_WRAP_MODES = {}));
+/**
+ * The wrap modes that are supported by pixi.
+ * @deprecated since 8.0.0
+ * @category rendering
+ * @see WRAP_MODE
+ * @advanced
+ */
+export const WRAP_MODES = new Proxy(DEPRECATED_WRAP_MODES, {
+    get(target, prop) {
+        // #if _DEBUG
+        deprecation(v8_0_0, `DRAW_MODES.${prop} is deprecated, use '${DEPRECATED_WRAP_MODES[prop]}' instead`);
+        // #endif
+        return target[prop];
+    },
+});
+/** @internal */
+export var DEPRECATED_SCALE_MODES;
+(function (DEPRECATED_SCALE_MODES) {
+    DEPRECATED_SCALE_MODES["NEAREST"] = "nearest";
+    DEPRECATED_SCALE_MODES["LINEAR"] = "linear";
+})(DEPRECATED_SCALE_MODES || (DEPRECATED_SCALE_MODES = {}));
+/**
+ * The scale modes that are supported by pixi.
+ * @deprecated since 8.0.0
+ * @category rendering
+ * @see SCALE_MODE
+ * @advanced
+ */
+export const SCALE_MODES = new Proxy(DEPRECATED_SCALE_MODES, {
+    get(target, prop) {
+        // #if _DEBUG
+        deprecation(v8_0_0, `DRAW_MODES.${prop} is deprecated, use '${DEPRECATED_SCALE_MODES[prop]}' instead`);
+        // #endif
+        return target[prop];
+    },
+});

package/dist/packages/pixijs/src/rendering/renderers/shared/texture/sources/BufferImageSource.d.ts

@@ -0,0 +1,26 @@
+import { TextureSource } from './TextureSource';
+import type { ExtensionMetadata } from '../../../../../extensions/Extensions';
+import type { TypedArray } from '../../buffer/Buffer';
+import type { TextureSourceOptions } from './TextureSource';
+/**
+ * Options for creating a BufferImageSource.
+ * @category rendering
+ * @advanced
+ */
+export interface BufferSourceOptions extends TextureSourceOptions<TypedArray | ArrayBuffer> {
+    width: number;
+    height: number;
+}
+/**
+ * A texture source that uses a TypedArray or ArrayBuffer as its resource.
+ * It automatically determines the format based on the type of TypedArray provided.
+ * @category rendering
+ * @advanced
+ */
+export declare class BufferImageSource extends TextureSource<TypedArray | ArrayBuffer> {
+    static extension: ExtensionMetadata;
+    uploadMethodId: string;
+    constructor(options: BufferSourceOptions);
+    static test(resource: any): resource is TypedArray | ArrayBuffer;
+}
+//# sourceMappingURL=BufferImageSource.d.ts.map

package/dist/packages/pixijs/src/rendering/renderers/shared/texture/sources/BufferImageSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BufferImageSource.d.ts","sourceRoot":"","sources":["../../../../../../../../../packages/pixijs/src/rendering/renderers/shared/texture/sources/BufferImageSource.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sCAAsC,CAAC;AAC9E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAE5D;;;;GAIG;AACH,MAAM,WAAW,mBAAoB,SAAQ,oBAAoB,CAAC,UAAU,GAAG,WAAW,CAAC;IAEvF,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAClB;AAED;;;;;GAKG;AACH,qBAAa,iBAAkB,SAAQ,aAAa,CAAC,UAAU,GAAG,WAAW,CAAC;IAE1E,OAAc,SAAS,EAAE,iBAAiB,CAA+B;IAElE,cAAc,SAAY;gBAErB,OAAO,EAAE,mBAAmB;WA4C1B,IAAI,CAAC,QAAQ,EAAE,GAAG,GAAG,QAAQ,IAAI,UAAU,GAAG,WAAW;CAW1E"}

package/dist/packages/pixijs/src/rendering/renderers/shared/texture/sources/BufferImageSource.js

@@ -0,0 +1,50 @@
+import { ExtensionType } from '../../../../../extensions/Extensions';
+import { TextureSource } from './TextureSource';
+/**
+ * A texture source that uses a TypedArray or ArrayBuffer as its resource.
+ * It automatically determines the format based on the type of TypedArray provided.
+ * @category rendering
+ * @advanced
+ */
+export class BufferImageSource extends TextureSource {
+    constructor(options) {
+        const buffer = options.resource || new Float32Array(options.width * options.height * 4);
+        let format = options.format;
+        if (!format) {
+            if (buffer instanceof Float32Array) {
+                format = 'rgba32float';
+            }
+            else if (buffer instanceof Int32Array) {
+                format = 'rgba32uint';
+            }
+            else if (buffer instanceof Uint32Array) {
+                format = 'rgba32uint';
+            }
+            else if (buffer instanceof Int16Array) {
+                format = 'rgba16uint';
+            }
+            else if (buffer instanceof Uint16Array) {
+                format = 'rgba16uint';
+            }
+            else if (buffer instanceof Int8Array) {
+                format = 'bgra8unorm';
+            }
+            else {
+                format = 'bgra8unorm';
+            }
+        }
+        super(Object.assign(Object.assign({}, options), { resource: buffer, format }));
+        this.uploadMethodId = 'buffer';
+    }
+    static test(resource) {
+        return resource instanceof Int8Array
+            || resource instanceof Uint8Array
+            || resource instanceof Uint8ClampedArray
+            || resource instanceof Int16Array
+            || resource instanceof Uint16Array
+            || resource instanceof Int32Array
+            || resource instanceof Uint32Array
+            || resource instanceof Float32Array;
+    }
+}
+BufferImageSource.extension = ExtensionType.TextureSource;

package/dist/packages/pixijs/src/rendering/renderers/shared/texture/sources/CanvasSource.d.ts

@@ -0,0 +1,44 @@
+import { TextureSource } from './TextureSource';
+import type { ICanvas } from '../../../../../environment/canvas/ICanvas';
+import type { ExtensionMetadata } from '../../../../../extensions/Extensions';
+import type { TextureSourceOptions } from './TextureSource';
+/**
+ * Options for creating a CanvasSource.
+ * @category rendering
+ * @advanced
+ */
+export interface CanvasSourceOptions extends TextureSourceOptions<ICanvas> {
+    /**
+     * Should the canvas be resized to preserve its screen width and height regardless
+     * of the resolution of the renderer, this is only supported for HTMLCanvasElement
+     * and will be ignored if the canvas is an OffscreenCanvas.
+     */
+    autoDensity?: boolean;
+    /** if true, this canvas will be set up to be transparent where possible */
+    transparent?: boolean;
+}
+/**
+ * A texture source that uses a canvas as its resource.
+ * It automatically resizes the canvas based on the width, height, and resolution.
+ * It also provides a 2D rendering context for drawing.
+ * @category rendering
+ * @advanced
+ */
+export declare class CanvasSource extends TextureSource<ICanvas> {
+    static extension: ExtensionMetadata;
+    uploadMethodId: string;
+    autoDensity: boolean;
+    transparent: boolean;
+    private _context2D;
+    constructor(options: CanvasSourceOptions);
+    resizeCanvas(): void;
+    resize(width?: number, height?: number, resolution?: number): boolean;
+    static test(resource: any): resource is ICanvas;
+    /**
+     * Returns the 2D rendering context for the canvas.
+     * Caches the context after creating it.
+     * @returns The 2D rendering context of the canvas.
+     */
+    get context2D(): CanvasRenderingContext2D;
+}
+//# sourceMappingURL=CanvasSource.d.ts.map

package/dist/packages/pixijs/src/rendering/renderers/shared/texture/sources/CanvasSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CanvasSource.d.ts","sourceRoot":"","sources":["../../../../../../../../../packages/pixijs/src/rendering/renderers/shared/texture/sources/CanvasSource.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2CAA2C,CAAC;AACzE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sCAAsC,CAAC;AAC9E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAE5D;;;;GAIG;AACH,MAAM,WAAW,mBAAoB,SAAQ,oBAAoB,CAAC,OAAO,CAAC;IAEtE;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,2EAA2E;IAC3E,WAAW,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;;;;;GAMG;AACH,qBAAa,YAAa,SAAQ,aAAa,CAAC,OAAO,CAAC;IAEpD,OAAc,SAAS,EAAE,iBAAiB,CAA+B;IAElE,cAAc,SAAW;IACzB,WAAW,EAAE,OAAO,CAAC;IACrB,WAAW,EAAE,OAAO,CAAC;IAE5B,OAAO,CAAC,UAAU,CAA2B;gBAEjC,OAAO,EAAE,mBAAmB;IAoCjC,YAAY;IAgBZ,MAAM,CAAC,KAAK,SAAa,EAAE,MAAM,SAAc,EAAE,UAAU,SAAmB,GAAG,OAAO;WAYjF,IAAI,CAAC,QAAQ,EAAE,GAAG,GAAG,QAAQ,IAAI,OAAO;IAMtD;;;;OAIG;IACH,IAAI,SAAS,IAAI,wBAAwB,CAGxC;CACJ"}

package/dist/packages/pixijs/src/rendering/renderers/shared/texture/sources/CanvasSource.js

@@ -0,0 +1,65 @@
+import { DOMAdapter } from '../../../../../environment/adapter';
+import { ExtensionType } from '../../../../../extensions/Extensions';
+import { TextureSource } from './TextureSource';
+/**
+ * A texture source that uses a canvas as its resource.
+ * It automatically resizes the canvas based on the width, height, and resolution.
+ * It also provides a 2D rendering context for drawing.
+ * @category rendering
+ * @advanced
+ */
+export class CanvasSource extends TextureSource {
+    constructor(options) {
+        if (!options.resource) {
+            options.resource = DOMAdapter.get().createCanvas();
+        }
+        if (!options.width) {
+            options.width = options.resource.width;
+            if (!options.autoDensity) {
+                options.width /= options.resolution;
+            }
+        }
+        if (!options.height) {
+            options.height = options.resource.height;
+            if (!options.autoDensity) {
+                options.height /= options.resolution;
+            }
+        }
+        super(options);
+        this.uploadMethodId = 'image';
+        this.autoDensity = options.autoDensity;
+        this.resizeCanvas();
+        this.transparent = !!options.transparent;
+    }
+    resizeCanvas() {
+        if (this.autoDensity && 'style' in this.resource) {
+            this.resource.style.width = `${this.width}px`;
+            this.resource.style.height = `${this.height}px`;
+        }
+        // only resize if wee need to, as this clears the canvas (even if values are set to the same)
+        if (this.resource.width !== this.pixelWidth || this.resource.height !== this.pixelHeight) {
+            this.resource.width = this.pixelWidth;
+            this.resource.height = this.pixelHeight;
+        }
+    }
+    resize(width = this.width, height = this.height, resolution = this._resolution) {
+        const didResize = super.resize(width, height, resolution);
+        if (didResize) {
+            this.resizeCanvas();
+        }
+        return didResize;
+    }
+    static test(resource) {
+        return (globalThis.HTMLCanvasElement && resource instanceof HTMLCanvasElement)
+            || (globalThis.OffscreenCanvas && resource instanceof OffscreenCanvas);
+    }
+    /**
+     * Returns the 2D rendering context for the canvas.
+     * Caches the context after creating it.
+     * @returns The 2D rendering context of the canvas.
+     */
+    get context2D() {
+        return this._context2D || (this._context2D = this.resource.getContext('2d'));
+    }
+}
+CanvasSource.extension = ExtensionType.TextureSource;

package/dist/packages/pixijs/src/rendering/renderers/shared/texture/sources/CompressedSource.d.ts

@@ -0,0 +1,13 @@
+import { TextureSource } from './TextureSource';
+import type { TextureSourceOptions } from './TextureSource';
+/**
+ * A texture source that uses a compressed resource, such as an array of Uint8Arrays.
+ * It is used for compressed textures that can be uploaded to the GPU.
+ * @category rendering
+ * @advanced
+ */
+export declare class CompressedSource extends TextureSource<Uint8Array[]> {
+    readonly uploadMethodId = "compressed";
+    constructor(options: TextureSourceOptions);
+}
+//# sourceMappingURL=CompressedSource.d.ts.map

package/dist/packages/pixijs/src/rendering/renderers/shared/texture/sources/CompressedSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CompressedSource.d.ts","sourceRoot":"","sources":["../../../../../../../../../packages/pixijs/src/rendering/renderers/shared/texture/sources/CompressedSource.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAE5D;;;;;GAKG;AACH,qBAAa,gBAAiB,SAAQ,aAAa,CAAC,UAAU,EAAE,CAAC;IAE7D,SAAgB,cAAc,gBAAgB;gBAElC,OAAO,EAAE,oBAAoB;CAO5C"}

package/dist/packages/pixijs/src/rendering/renderers/shared/texture/sources/CompressedSource.js

@@ -0,0 +1,15 @@
+import { TextureSource } from './TextureSource';
+/**
+ * A texture source that uses a compressed resource, such as an array of Uint8Arrays.
+ * It is used for compressed textures that can be uploaded to the GPU.
+ * @category rendering
+ * @advanced
+ */
+export class CompressedSource extends TextureSource {
+    constructor(options) {
+        super(options);
+        this.uploadMethodId = 'compressed';
+        this.resource = options.resource;
+        this.mipLevelCount = this.resource.length;
+    }
+}