@safe-engine/pixi 8.4.7 → 8.5.1

package/src/spine/lib/SpinePipe.ts

@@ -1,203 +0,0 @@
-/** ****************************************************************************
- * Spine Runtimes License Agreement
- * Last updated July 28, 2023. Replaces all prior versions.
- *
- * Copyright (c) 2013-2023, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software or
- * otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
- * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-import {
-	collectAllRenderables,
-	extensions, ExtensionType,
-	InstructionSet,
-	type BLEND_MODES,
-	type Container,
-	type Renderer,
-	type RenderPipe,
-} from 'pixi.js';
-import { BatchableSpineSlot } from './BatchableSpineSlot.js';
-import { Spine } from './Spine.js';
-import { MeshAttachment, RegionAttachment } from '@esotericsoftware/spine-core';
-
-const spineBlendModeMap: Record<number, BLEND_MODES> = {
-	0: 'normal',
-	1: 'add',
-	2: 'multiply',
-	3: 'screen'
-};
-
-type GpuSpineDataElement = { slotBatches: Record<string, BatchableSpineSlot> };
-
-// eslint-disable-next-line max-len
-export class SpinePipe implements RenderPipe<Spine> {
-	/** @ignore */
-	static extension = {
-		type: [
-			ExtensionType.WebGLPipes,
-			ExtensionType.WebGPUPipes,
-			ExtensionType.CanvasPipes,
-		],
-		name: 'spine',
-	} as const;
-
-	renderer: Renderer;
-
-	private gpuSpineData: Record<string, GpuSpineDataElement> = {};
-	private readonly _destroyRenderableBound = this.destroyRenderable.bind(this) as (renderable: Container) => void;
-
-	constructor (renderer: Renderer) {
-		this.renderer = renderer;
-	}
-
-	validateRenderable (spine: Spine): boolean {
-		spine._validateAndTransformAttachments();
-
-		// if spine attachments have changed or destroyed, we need to rebuild the batch!
-		if (spine.spineAttachmentsDirty) {
-			return true;
-		}
-
-		// if the textures have changed, we need to rebuild the batch, but only if the texture is not already in the batch
-		else if (spine.spineTexturesDirty) {
-			// loop through and see if the textures have changed..
-			const drawOrder = spine.skeleton.drawOrder;
-			const gpuSpine = this.gpuSpineData[spine.uid];
-
-			for (let i = 0, n = drawOrder.length; i < n; i++) {
-				const slot = drawOrder[i];
-				const attachment = slot.getAttachment();
-
-				if (attachment instanceof RegionAttachment || attachment instanceof MeshAttachment) {
-					const cacheData = spine._getCachedData(slot, attachment);
-					const batchableSpineSlot = gpuSpine.slotBatches[cacheData.id];
-
-					const texture = cacheData.texture;
-
-					if (texture !== batchableSpineSlot.texture) {
-						if (!batchableSpineSlot._batcher.checkAndUpdateTexture(batchableSpineSlot, texture)) {
-							return true;
-						}
-					}
-				}
-			}
-		}
-
-		return false;
-	}
-
-	addRenderable (spine: Spine, instructionSet: InstructionSet) {
-		const gpuSpine = this._getSpineData(spine);
-
-		const batcher = this.renderer.renderPipes.batch;
-
-		const drawOrder = spine.skeleton.drawOrder;
-
-		const roundPixels = (this.renderer._roundPixels | spine._roundPixels) as 0 | 1;
-
-		spine._validateAndTransformAttachments();
-
-		spine.spineAttachmentsDirty = false;
-		spine.spineTexturesDirty = false;
-
-		for (let i = 0, n = drawOrder.length; i < n; i++) {
-			const slot = drawOrder[i];
-			const attachment = slot.getAttachment();
-			const blendMode = spineBlendModeMap[slot.data.blendMode];
-
-			if (attachment instanceof RegionAttachment || attachment instanceof MeshAttachment) {
-				const cacheData = spine._getCachedData(slot, attachment);
-				const batchableSpineSlot = gpuSpine.slotBatches[cacheData.id] ||= new BatchableSpineSlot();
-
-				batchableSpineSlot.setData(
-					spine,
-					cacheData,
-					blendMode,
-					roundPixels
-				);
-
-				if (!cacheData.skipRender) {
-					batcher.addToBatch(batchableSpineSlot, instructionSet);
-				}
-			}
-
-			const containerAttachment = spine._slotsObject[slot.data.name];
-
-			if (containerAttachment) {
-				const container = containerAttachment.container;
-
-				container.includeInBuild = true;
-				collectAllRenderables(container, instructionSet, this.renderer);
-				container.includeInBuild = false;
-			}
-		}
-	}
-
-	updateRenderable (spine: Spine) {
-		const gpuSpine = this.gpuSpineData[spine.uid];
-
-		spine._validateAndTransformAttachments();
-
-		spine.spineAttachmentsDirty = false;
-		spine.spineTexturesDirty = false;
-
-		const drawOrder = spine.skeleton.drawOrder;
-
-		for (let i = 0, n = drawOrder.length; i < n; i++) {
-			const slot = drawOrder[i];
-			const attachment = slot.getAttachment();
-
-			if (attachment instanceof RegionAttachment || attachment instanceof MeshAttachment) {
-				const cacheData = spine._getCachedData(slot, attachment);
-
-				if (!cacheData.skipRender) {
-					const batchableSpineSlot = gpuSpine.slotBatches[spine._getCachedData(slot, attachment).id];
-
-					batchableSpineSlot._batcher?.updateElement(batchableSpineSlot);
-				}
-			}
-		}
-	}
-
-	destroyRenderable (spine: Spine) {
-		this.gpuSpineData[spine.uid] = null as any;
-		spine.off('destroyed', this._destroyRenderableBound);
-	}
-
-	destroy () {
-		this.gpuSpineData = null as any;
-		this.renderer = null as any;
-	}
-
-	private _getSpineData (spine: Spine): GpuSpineDataElement {
-		return this.gpuSpineData[spine.uid] || this._initMeshData(spine);
-	}
-
-	private _initMeshData (spine: Spine): GpuSpineDataElement {
-		this.gpuSpineData[spine.uid] = { slotBatches: {} };
-		spine.on('destroyed', this._destroyRenderableBound);
-		return this.gpuSpineData[spine.uid];
-	}
-}
-
-extensions.add(SpinePipe);

package/src/spine/lib/SpineTexture.ts

@@ -1,143 +0,0 @@
-/** ****************************************************************************
- * Spine Runtimes License Agreement
- * Last updated July 28, 2023. Replaces all prior versions.
- *
- * Copyright (c) 2013-2023, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software or
- * otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
- * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-import { Texture as PixiTexture } from 'pixi.js';
-import { BlendMode, Texture, TextureFilter, TextureWrap } from '@esotericsoftware/spine-core';
-
-import type { BLEND_MODES, SCALE_MODE, TextureSource, WRAP_MODE } from 'pixi.js';
-
-export class SpineTexture extends Texture {
-	private static readonly textureMap: Map<TextureSource, SpineTexture> = new Map<TextureSource, SpineTexture>();
-
-	public static from (texture: TextureSource): SpineTexture {
-		if (SpineTexture.textureMap.has(texture)) {
-			return SpineTexture.textureMap.get(texture) as SpineTexture;
-		}
-
-		return new SpineTexture(texture);
-	}
-
-	public readonly texture: PixiTexture;
-
-	private constructor (image: TextureSource) {
-		// Todo: maybe add error handling if you feed a video texture to spine?
-		super(image.resource);
-		this.texture = PixiTexture.from(image);
-	}
-
-	public setFilters (minFilter: TextureFilter, magFilter: TextureFilter): void {
-		const style = this.texture.source.style;
-
-		style.minFilter = SpineTexture.toPixiTextureFilter(minFilter);
-		style.magFilter = SpineTexture.toPixiTextureFilter(magFilter);
-		this.texture.source.autoGenerateMipmaps = SpineTexture.toPixiMipMap(minFilter);
-		this.texture.source.updateMipmaps();
-	}
-
-	public setWraps (uWrap: TextureWrap, vWrap: TextureWrap): void {
-		const style = this.texture.source.style;
-
-		style.addressModeU = SpineTexture.toPixiTextureWrap(uWrap);
-		style.addressModeV = SpineTexture.toPixiTextureWrap(vWrap);
-	}
-
-	public dispose (): void {
-		// I am not entirely sure about this...
-		this.texture.destroy();
-	}
-
-	private static toPixiMipMap (filter: TextureFilter): boolean {
-		switch (filter) {
-			case TextureFilter.Nearest:
-			case TextureFilter.Linear:
-				return false;
-
-			case TextureFilter.MipMapNearestLinear:
-			case TextureFilter.MipMapNearestNearest:
-			case TextureFilter.MipMapLinearLinear: // TextureFilter.MipMapLinearLinear == TextureFilter.MipMap
-			case TextureFilter.MipMapLinearNearest:
-				return true;
-
-			default:
-				throw new Error(`Unknown texture filter: ${String(filter)}`);
-		}
-	}
-
-	private static toPixiTextureFilter (filter: TextureFilter): SCALE_MODE {
-		switch (filter) {
-			case TextureFilter.Nearest:
-			case TextureFilter.MipMapNearestLinear:
-			case TextureFilter.MipMapNearestNearest:
-				return 'nearest';
-
-			case TextureFilter.Linear:
-			case TextureFilter.MipMapLinearLinear: // TextureFilter.MipMapLinearLinear == TextureFilter.MipMap
-			case TextureFilter.MipMapLinearNearest:
-				return 'linear';
-
-			default:
-				throw new Error(`Unknown texture filter: ${String(filter)}`);
-		}
-	}
-
-	private static toPixiTextureWrap (wrap: TextureWrap): WRAP_MODE {
-		switch (wrap) {
-			case TextureWrap.ClampToEdge:
-				return 'clamp-to-edge';
-
-			case TextureWrap.MirroredRepeat:
-				return 'mirror-repeat';
-
-			case TextureWrap.Repeat:
-				return 'repeat';
-
-			default:
-				throw new Error(`Unknown texture wrap: ${String(wrap)}`);
-		}
-	}
-
-	public static toPixiBlending (blend: BlendMode): BLEND_MODES {
-		switch (blend) {
-			case BlendMode.Normal:
-				return 'normal';
-
-			case BlendMode.Additive:
-				return 'add';
-
-			case BlendMode.Multiply:
-				return 'multiply';
-
-			case BlendMode.Screen:
-				return 'screen';
-
-			default:
-				throw new Error(`Unknown blendMode: ${String(blend)}`);
-		}
-	}
-}

package/src/spine/lib/assets/atlasLoader.ts

@@ -1,158 +0,0 @@
-/** ****************************************************************************
- * Spine Runtimes License Agreement
- * Last updated July 28, 2023. Replaces all prior versions.
- *
- * Copyright (c) 2013-2023, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software or
- * otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
- * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-import {
-	checkExtension,
-	DOMAdapter,
-	extensions,
-	ExtensionType,
-	LoaderParserPriority,
-	path,
-	Resolver,
-	TextureSource
-} from 'pixi.js';
-import { SpineTexture } from '../SpineTexture.js';
-import { TextureAtlas } from '@esotericsoftware/spine-core';
-
-import type { AssetExtension, Loader, ResolvedAsset, Texture, UnresolvedAsset } from 'pixi.js';
-
-type RawAtlas = string;
-
-const spineTextureAtlasLoader: AssetExtension<RawAtlas | TextureAtlas, ISpineAtlasMetadata> = {
-	extension: ExtensionType.Asset,
-
-	resolver: {
-		test: (value: string): boolean => checkExtension(value, ".atlas"),
-		parse: (value: string): UnresolvedAsset => {
-			const split = value.split('.');
-
-			return {
-				resolution: parseFloat(Resolver.RETINA_PREFIX?.exec(value)?.[1] ?? '1'),
-				format: split[split.length - 2],
-				src: value,
-			};
-		},
-	},
-
-	loader: {
-		extension: {
-			type: ExtensionType.LoadParser,
-			priority: LoaderParserPriority.Normal,
-			name: 'spineTextureAtlasLoader',
-		},
-
-		test (url: string): boolean {
-			return checkExtension(url, '.atlas');
-		},
-
-		async load (url: string): Promise<RawAtlas> {
-			const response = await DOMAdapter.get().fetch(url);
-
-			const txt = await response.text();
-
-			return txt;
-		},
-
-		testParse (asset: unknown, options: ResolvedAsset): Promise<boolean> {
-			const isExtensionRight = checkExtension(options.src as string, '.atlas');
-			const isString = typeof asset === 'string';
-
-			return Promise.resolve(isExtensionRight && isString);
-		},
-
-		unload (atlas: TextureAtlas) {
-			atlas.dispose();
-		},
-
-		async parse (asset: RawAtlas, options: ResolvedAsset, loader: Loader): Promise<TextureAtlas> {
-			const metadata: ISpineAtlasMetadata = options.data || {};
-			let basePath = path.dirname(options.src as string);
-
-			if (basePath && basePath.lastIndexOf('/') !== basePath.length - 1) {
-				basePath += '/';
-			}
-
-			// Retval is going to be a texture atlas. However we need to wait for it's callback to resolve this promise.
-			const retval = new TextureAtlas(asset);
-
-			// If the user gave me only one texture, that one is assumed to be the "first" texture in the atlas
-			if (metadata.images instanceof TextureSource || typeof metadata.images === 'string') {
-				const pixiTexture = metadata.images;
-
-				metadata.images = {} as Record<string, TextureSource | string>;
-				metadata.images[retval.pages[0].name] = pixiTexture;
-			}
-
-			// we will wait for all promises for the textures at the same time at the end.
-			const textureLoadingPromises: Promise<any>[] = [];
-
-			// fill the pages
-			for (const page of retval.pages) {
-				const pageName = page.name;
-				const providedPage = metadata?.images ? metadata.images[pageName] : undefined;
-
-				if (providedPage instanceof TextureSource) {
-					page.setTexture(SpineTexture.from(providedPage));
-				}
-				else {
-					// eslint-disable-next-line max-len
-					const url: string = providedPage ?? path.normalize([...basePath.split(path.sep), pageName].join(path.sep));
-
-					const assetsToLoadIn = {
-						src: url,
-						data: {
-							...metadata.imageMetadata,
-							alphaMode: page.pma ? 'premultiplied-alpha' : 'premultiply-alpha-on-upload'
-						}
-					};
-
-					const pixiPromise = loader.load<Texture>(assetsToLoadIn).then((texture) => {
-						page.setTexture(SpineTexture.from(texture.source));
-					});
-
-					textureLoadingPromises.push(pixiPromise);
-				}
-			}
-
-			await Promise.all(textureLoadingPromises);
-
-			return retval;
-		},
-	},
-} as AssetExtension<RawAtlas | TextureAtlas, ISpineAtlasMetadata>;
-
-extensions.add(spineTextureAtlasLoader);
-
-export interface ISpineAtlasMetadata {
-	// If you are downloading an .atlas file, this metadata will go to the Texture loader
-	imageMetadata?: any;
-	// If you already have atlas pages loaded as pixi textures
-	// and want to use that to create the atlas, you can pass them here
-	images?: TextureSource | string | Record<string, TextureSource | string>;
-}

package/src/spine/lib/assets/skeletonLoader.ts

@@ -1,81 +0,0 @@
-/** ****************************************************************************
- * Spine Runtimes License Agreement
- * Last updated July 28, 2023. Replaces all prior versions.
- *
- * Copyright (c) 2013-2023, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software or
- * otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
- * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-import {
-	type AssetExtension,
-	checkExtension,
-	DOMAdapter,
-	extensions,
-	ExtensionType,
-	LoaderParserPriority,
-	ResolvedAsset
-} from 'pixi.js';
-
-type SkeletonJsonAsset = any;
-type SkeletonBinaryAsset = Uint8Array;
-
-function isJson (resource: any): resource is SkeletonJsonAsset {
-	return Object.prototype.hasOwnProperty.call(resource, 'bones');
-}
-
-function isBuffer (resource: any): resource is SkeletonBinaryAsset {
-	return resource instanceof Uint8Array;
-}
-
-const spineLoaderExtension: AssetExtension<SkeletonJsonAsset | SkeletonBinaryAsset> = {
-	extension: ExtensionType.Asset,
-
-	loader: {
-		extension: {
-			type: ExtensionType.LoadParser,
-			priority: LoaderParserPriority.Normal,
-			name: 'spineSkeletonLoader',
-		},
-
-		test (url) {
-			return checkExtension(url, '.skel');
-		},
-
-		async load (url: string): Promise<SkeletonBinaryAsset> {
-			const response = await DOMAdapter.get().fetch(url);
-
-			const buffer = new Uint8Array(await response.arrayBuffer());
-
-			return buffer;
-		},
-		testParse (asset: unknown, options: ResolvedAsset): Promise<boolean> {
-			const isJsonSpineModel = checkExtension(options.src!, '.json') && isJson(asset);
-			const isBinarySpineModel = checkExtension(options.src!, '.skel') && isBuffer(asset);
-
-			return Promise.resolve(isJsonSpineModel || isBinarySpineModel);
-		},
-	},
-} as AssetExtension<SkeletonJsonAsset | SkeletonBinaryAsset>;
-
-extensions.add(spineLoaderExtension);

package/src/spine/lib/darktint/DarkTintBatchGeometry.ts

@@ -1,92 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated July 28, 2023. Replaces all prior versions.
- *
- * Copyright (c) 2013-2023, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software or
- * otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
- * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-import { Buffer, BufferUsage, Geometry } from 'pixi.js';
-
-const placeHolderBufferData = new Float32Array(1);
-const placeHolderIndexData = new Uint32Array(1);
-
-export class DarkTintBatchGeometry extends Geometry {
-	constructor () {
-		const vertexSize = 7;
-
-		const attributeBuffer = new Buffer({
-			data: placeHolderBufferData,
-			label: 'attribute-batch-buffer',
-			usage: BufferUsage.VERTEX | BufferUsage.COPY_DST,
-			shrinkToFit: false,
-		});
-
-		const indexBuffer = new Buffer({
-			data: placeHolderIndexData,
-			label: 'index-batch-buffer',
-			usage: BufferUsage.INDEX | BufferUsage.COPY_DST, // | BufferUsage.STATIC,
-			shrinkToFit: false,
-		});
-
-		const stride = vertexSize * 4;
-
-		super({
-			attributes: {
-				aPosition: {
-					buffer: attributeBuffer,
-					format: 'float32x2',
-					stride,
-					offset: 0,
-				},
-				aUV: {
-					buffer: attributeBuffer,
-					format: 'float32x2',
-					stride,
-					offset: 2 * 4,
-				},
-				aColor: {
-					buffer: attributeBuffer,
-					format: 'unorm8x4',
-					stride,
-					offset: 4 * 4,
-				},
-				aDarkColor: {
-					buffer: attributeBuffer,
-					format: 'unorm8x4',
-					stride,
-					offset: 5 * 4,
-				},
-				aTextureIdAndRound: {
-					buffer: attributeBuffer,
-					format: 'uint16x2',
-					stride,
-					offset: 6 * 4,
-				},
-			},
-			indexBuffer
-		});
-	}
-}
-