@safe-engine/pixi 8.4.6 → 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/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
-		});
-	}
-}
-

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

@@ -1,186 +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 {
-	Batcher,
-	Color,
-	DefaultBatchableMeshElement,
-	DefaultBatchableQuadElement,
-	extensions,
-	ExtensionType,
-	Shader
-} from 'pixi.js';
-import { DarkTintBatchGeometry } from './DarkTintBatchGeometry.js';
-import { DarkTintShader } from './DarkTintShader.js';
-
-let defaultShader: Shader | null = null;
-
-/** The default batcher is used to batch quads and meshes. */
-export class DarkTintBatcher extends Batcher {
-	/** @ignore */
-	public static extension = {
-		type: [
-			ExtensionType.Batcher,
-		],
-		name: 'darkTint',
-	} as const;
-
-	public geometry = new DarkTintBatchGeometry();
-	public shader = defaultShader || (defaultShader = new DarkTintShader(this.maxTextures));
-	public name = DarkTintBatcher.extension.name;
-
-	/** The size of one attribute. 1 = 32 bit. x, y, u, v, color, darkColor, textureIdAndRound -> total = 7 */
-	public vertexSize = 7;
-
-	public packAttributes (
-		element: DefaultBatchableMeshElement & { darkColor: number },
-		float32View: Float32Array,
-		uint32View: Uint32Array,
-		index: number,
-		textureId: number
-	) {
-		const textureIdAndRound = (textureId << 16) | (element.roundPixels & 0xFFFF);
-
-		const wt = element.transform;
-
-		const a = wt.a;
-		const b = wt.b;
-		const c = wt.c;
-		const d = wt.d;
-		const tx = wt.tx;
-		const ty = wt.ty;
-
-		const { positions, uvs } = element;
-
-		const argb = element.color;
-		const worldAlpha = ((argb >> 24) & 0xFF) / 255;
-		const darkColor = Color.shared.setValue(element.darkColor).premultiply(worldAlpha, true).toPremultiplied(1, false);
-
-		const offset = element.attributeOffset;
-		const end = offset + element.attributeSize;
-
-		for (let i = offset; i < end; i++) {
-			const i2 = i * 2;
-
-			const x = positions[i2];
-			const y = positions[(i2) + 1];
-
-			float32View[index++] = (a * x) + (c * y) + tx;
-			float32View[index++] = (d * y) + (b * x) + ty;
-
-			float32View[index++] = uvs[i2];
-			float32View[index++] = uvs[(i2) + 1];
-
-			uint32View[index++] = argb;
-			uint32View[index++] = darkColor;
-
-			uint32View[index++] = textureIdAndRound;
-		}
-	}
-
-	public packQuadAttributes (
-		element: DefaultBatchableQuadElement & { darkColor: number },
-		float32View: Float32Array,
-		uint32View: Uint32Array,
-		index: number,
-		textureId: number
-	) {
-		const texture = element.texture;
-
-		const wt = element.transform;
-
-		const a = wt.a;
-		const b = wt.b;
-		const c = wt.c;
-		const d = wt.d;
-		const tx = wt.tx;
-		const ty = wt.ty;
-
-		const bounds = element.bounds;
-
-		const w0 = bounds.maxX;
-		const w1 = bounds.minX;
-		const h0 = bounds.maxY;
-		const h1 = bounds.minY;
-
-		const uvs = texture.uvs;
-
-		// _ _ _ _
-		// a b g r
-		const argb = element.color;
-		const darkColor = element.darkColor;
-
-		const textureIdAndRound = (textureId << 16) | (element.roundPixels & 0xFFFF);
-
-		float32View[index + 0] = (a * w1) + (c * h1) + tx;
-		float32View[index + 1] = (d * h1) + (b * w1) + ty;
-
-		float32View[index + 2] = uvs.x0;
-		float32View[index + 3] = uvs.y0;
-
-		uint32View[index + 4] = argb;
-		uint32View[index + 5] = darkColor;
-		uint32View[index + 6] = textureIdAndRound;
-
-		// xy
-		float32View[index + 7] = (a * w0) + (c * h1) + tx;
-		float32View[index + 8] = (d * h1) + (b * w0) + ty;
-
-		float32View[index + 9] = uvs.x1;
-		float32View[index + 10] = uvs.y1;
-
-		uint32View[index + 11] = argb;
-		uint32View[index + 12] = darkColor;
-		uint32View[index + 13] = textureIdAndRound;
-
-		// xy
-		float32View[index + 14] = (a * w0) + (c * h0) + tx;
-		float32View[index + 15] = (d * h0) + (b * w0) + ty;
-
-		float32View[index + 16] = uvs.x2;
-		float32View[index + 17] = uvs.y2;
-
-		uint32View[index + 18] = argb;
-		uint32View[index + 19] = darkColor;
-		uint32View[index + 20] = textureIdAndRound;
-
-		// xy
-		float32View[index + 21] = (a * w1) + (c * h0) + tx;
-		float32View[index + 22] = (d * h0) + (b * w1) + ty;
-
-		float32View[index + 23] = uvs.x3;
-		float32View[index + 24] = uvs.y3;
-
-		uint32View[index + 25] = argb;
-		uint32View[index + 26] = darkColor;
-		uint32View[index + 27] = textureIdAndRound;
-	}
-}
-
-extensions.add(DarkTintBatcher);

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

@@ -1,77 +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.
- *****************************************************************************/
-
-export const darkTintBit = {
-	name: 'color-bit',
-	vertex: {
-		header: /* wgsl */`
-            @in aDarkColor: vec4<f32>;
-            @out vDarkColor: vec4<f32>;
-        `,
-		main: /* wgsl */`
-        vDarkColor = aDarkColor;
-        `
-	},
-	fragment: {
-		header: /* wgsl */`
-            @in vDarkColor: vec4<f32>;
-        `,
-		end: /* wgsl */`
-
-        let alpha = outColor.a * vColor.a;
-        let rgb = ((outColor.a - 1.0) * vDarkColor.a + 1.0 - outColor.rgb) * vDarkColor.rgb + outColor.rgb * vColor.rgb;
-
-        finalColor = vec4<f32>(rgb, alpha);
-
-        `
-	}
-};
-
-export const darkTintBitGl = {
-	name: 'color-bit',
-	vertex: {
-		header: /* glsl */`
-            in vec4 aDarkColor;
-            out vec4 vDarkColor;
-        `,
-		main: /* glsl */`
-            vDarkColor = aDarkColor;
-        `
-	},
-	fragment: {
-		header: /* glsl */`
-            in vec4 vDarkColor;
-        `,
-		end: /* glsl */`
-
-        finalColor.a = outColor.a * vColor.a;
-        finalColor.rgb = ((outColor.a - 1.0) * vDarkColor.a + 1.0 - outColor.rgb) * vDarkColor.rgb + outColor.rgb * vColor.rgb;
-        `
-	}
-};