import { Resource } from './Resource'; import { BaseTexture } from '../BaseTexture'; import type { ISize } from '@pixi/math'; import type { IAutoDetectOptions } from './autoDetectResource'; import { autoDetectResource } from './autoDetectResource'; /** * Resource that can manage several resource (items) inside. * All resources need to have the same pixel size. * Parent class for CubeResource and ArrayResource * @memberof PIXI */ export abstract class AbstractMultiResource extends Resource { /** Number of elements in array. */ readonly length: number; /** * Collection of partial baseTextures that correspond to resources. * @readonly */ items: Array; /** * Dirty IDs for each part. * @readonly */ itemDirtyIds: Array; /** * Promise when loading. * @default null */ private _load: Promise; /** Bound baseTexture, there can only be one. */ baseTexture: BaseTexture; /** * @param length * @param options - Options to for Resource constructor * @param {number} [options.width] - Width of the resource * @param {number} [options.height] - Height of the resource */ constructor(length: number, options?: ISize) { const { width, height } = options || {}; super(width, height); this.items = []; this.itemDirtyIds = []; for (let i = 0; i < length; i++) { const partTexture = new BaseTexture(); this.items.push(partTexture); // -2 - first run of texture array upload // -1 - texture item was allocated // >=0 - texture item uploaded , in sync with items[i].dirtyId this.itemDirtyIds.push(-2); } this.length = length; this._load = null; this.baseTexture = null; } /** * Used from ArrayResource and CubeResource constructors. * @param resources - Can be resources, image elements, canvas, etc. , * length should be same as constructor length * @param options - Detect options for resources */ protected initFromArray(resources: Array, options?: IAutoDetectOptions): void { for (let i = 0; i < this.length; i++) { if (!resources[i]) { continue; } if (resources[i].castToBaseTexture) { this.addBaseTextureAt(resources[i].castToBaseTexture(), i); } else if (resources[i] instanceof Resource) { this.addResourceAt(resources[i], i); } else { this.addResourceAt(autoDetectResource(resources[i], options), i); } } } /** Destroy this BaseImageResource. */ dispose(): void { for (let i = 0, len = this.length; i < len; i++) { this.items[i].destroy(); } this.items = null; this.itemDirtyIds = null; this._load = null; } /** * Set a baseTexture by ID * @param baseTexture * @param index - Zero-based index of resource to set * @returns - Instance for chaining */ abstract addBaseTextureAt(baseTexture: BaseTexture, index: number): this; /** * Set a resource by ID * @param resource * @param index - Zero-based index of resource to set * @returns - Instance for chaining */ addResourceAt(resource: Resource, index: number): this { if (!this.items[index]) { throw new Error(`Index ${index} is out of bounds`); } // Inherit the first resource dimensions if (resource.valid && !this.valid) { this.resize(resource.width, resource.height); } this.items[index].setResource(resource); return this; } /** * Set the parent base texture. * @param baseTexture */ bind(baseTexture: BaseTexture): void { if (this.baseTexture !== null) { throw new Error('Only one base texture per TextureArray is allowed'); } super.bind(baseTexture); for (let i = 0; i < this.length; i++) { this.items[i].parentTextureArray = baseTexture; this.items[i].on('update', baseTexture.update, baseTexture); } } /** * Unset the parent base texture. * @param baseTexture */ unbind(baseTexture: BaseTexture): void { super.unbind(baseTexture); for (let i = 0; i < this.length; i++) { this.items[i].parentTextureArray = null; this.items[i].off('update', baseTexture.update, baseTexture); } } /** * Load all the resources simultaneously * @returns - When load is resolved */ load(): Promise { if (this._load) { return this._load; } const resources = this.items.map((item) => item.resource).filter((item) => item); // TODO: also implement load part-by-part strategy const promises = resources.map((item) => item.load()); this._load = Promise.all(promises) .then(() => { const { realWidth, realHeight } = this.items[0]; this.resize(realWidth, realHeight); return Promise.resolve(this); } ); return this._load; } }