WXGame/box1/Assets/Spine/Runtime/spine-unity/Utility/AtlasUtilities.cs

/******************************************************************************
 * 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.
 *****************************************************************************/

#if UNITY_2019_3_OR_NEWER
#define CONFIGURABLE_ENTER_PLAY_MODE
#endif


using System;
using System.Collections.Generic;
using UnityEngine;


namespace Spine.Unity.AttachmentTools {

	public static class AtlasUtilities {
		internal const TextureFormat SpineTextureFormat = TextureFormat.RGBA32;
		internal const float DefaultMipmapBias = -0.5f;
		internal const bool UseMipMaps = false;
		internal const float DefaultScale = 0.01f;

		const int NonrenderingRegion = -1;

#if CONFIGURABLE_ENTER_PLAY_MODE
		[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
		static void Init () {
			// handle disabled domain reload
			AtlasUtilities.ClearCache();
		}
#endif

		public static AtlasRegion ToAtlasRegion (this Texture2D t, Material materialPropertySource, float scale = DefaultScale) {
			return t.ToAtlasRegion(materialPropertySource.shader, scale, materialPropertySource);
		}

		public static AtlasRegion ToAtlasRegion (this Texture2D t, Shader shader, float scale = DefaultScale, Material materialPropertySource = null) {
			Material material = new Material(shader);
			if (materialPropertySource != null) {
				material.CopyPropertiesFromMaterial(materialPropertySource);
				material.shaderKeywords = materialPropertySource.shaderKeywords;
			}

			material.mainTexture = t;
			AtlasPage page = material.ToSpineAtlasPage();

			float width = t.width;
			float height = t.height;

			AtlasRegion region = new AtlasRegion();
			region.name = t.name;

			// World space units
			Vector2 boundsMin = Vector2.zero, boundsMax = new Vector2(width, height) * scale;

			// Texture space/pixel units
			region.width = (int)width;
			region.originalWidth = (int)width;
			region.height = (int)height;
			region.originalHeight = (int)height;
			region.offsetX = width * (0.5f - InverseLerp(boundsMin.x, boundsMax.x, 0));
			region.offsetY = height * (0.5f - InverseLerp(boundsMin.y, boundsMax.y, 0));

			// Use the full area of the texture.
			region.u = 0;
			region.v = 1;
			region.u2 = 1;
			region.v2 = 0;
			region.x = 0;
			region.y = 0;

			region.page = page;

			return region;
		}

		/// <summary>
		/// Creates a Spine.AtlasRegion that uses a premultiplied alpha duplicate of the Sprite's texture data.</summary>
		public static AtlasRegion ToAtlasRegionPMAClone (this Texture2D t, Material materialPropertySource, TextureFormat textureFormat = SpineTextureFormat, bool mipmaps = UseMipMaps) {
			return t.ToAtlasRegionPMAClone(materialPropertySource.shader, textureFormat, mipmaps, materialPropertySource);
		}

		/// <summary>
		/// Creates a Spine.AtlasRegion that uses a premultiplied alpha duplicate of the Sprite's texture data.</summary>
		public static AtlasRegion ToAtlasRegionPMAClone (this Texture2D t, Shader shader, TextureFormat textureFormat = SpineTextureFormat, bool mipmaps = UseMipMaps, Material materialPropertySource = null) {
			Material material = new Material(shader);
			if (materialPropertySource != null) {
				material.CopyPropertiesFromMaterial(materialPropertySource);
				material.shaderKeywords = materialPropertySource.shaderKeywords;
			}
			Texture2D newTexture = t.GetClone(textureFormat, mipmaps, applyPMA: true);

			newTexture.name = t.name + "-pma-";
			material.name = t.name + shader.name;

			material.mainTexture = newTexture;
			AtlasPage page = material.ToSpineAtlasPage();

			AtlasRegion region = newTexture.ToAtlasRegion(shader);
			region.page = page;

			return region;
		}

		/// <summary>
		/// Creates a new Spine.AtlasPage from a UnityEngine.Material. If the material has a preassigned texture, the page width and height will be set.</summary>
		public static AtlasPage ToSpineAtlasPage (this Material m) {
			AtlasPage newPage = new AtlasPage {
				rendererObject = m,
				name = m.name
			};

			Texture t = m.mainTexture;
			if (t != null) {
				newPage.width = t.width;
				newPage.height = t.height;
			}

			return newPage;
		}

		/// <summary>
		/// Creates a Spine.AtlasRegion from a UnityEngine.Sprite.</summary>
		public static AtlasRegion ToAtlasRegion (this Sprite s, AtlasPage page) {
			if (page == null) throw new System.ArgumentNullException("page", "page cannot be null. AtlasPage determines which texture region belongs and how it should be rendered. You can use material.ToSpineAtlasPage() to get a shareable AtlasPage from a Material, or use the sprite.ToAtlasRegion(material) overload.");
			AtlasRegion region = s.ToAtlasRegion();
			region.page = page;
			return region;
		}

		/// <summary>
		/// Creates a Spine.AtlasRegion from a UnityEngine.Sprite. This creates a new AtlasPage object for every AtlasRegion you create. You can centralize Material control by creating a shared atlas page using Material.ToSpineAtlasPage and using the sprite.ToAtlasRegion(AtlasPage) overload.</summary>
		public static AtlasRegion ToAtlasRegion (this Sprite s, Material material) {
			AtlasRegion region = s.ToAtlasRegion();
			region.page = material.ToSpineAtlasPage();
			return region;
		}

		public static AtlasRegion ToAtlasRegionPMAClone (this Sprite s, Material materialPropertySource, TextureFormat textureFormat = SpineTextureFormat, bool mipmaps = UseMipMaps) {
			return s.ToAtlasRegionPMAClone(materialPropertySource.shader, textureFormat, mipmaps, materialPropertySource);
		}

		/// <summary>
		/// Creates a Spine.AtlasRegion that uses a premultiplied alpha duplicate of the Sprite's texture data.</summary>
		public static AtlasRegion ToAtlasRegionPMAClone (this Sprite s, Shader shader, TextureFormat textureFormat = SpineTextureFormat, bool mipmaps = UseMipMaps, Material materialPropertySource = null) {
			Material material = new Material(shader);
			if (materialPropertySource != null) {
				material.CopyPropertiesFromMaterial(materialPropertySource);
				material.shaderKeywords = materialPropertySource.shaderKeywords;
			}

			Texture2D tex = s.ToTexture(textureFormat, mipmaps, applyPMA: true);
			tex.name = s.name + "-pma-";
			material.name = tex.name + shader.name;

			material.mainTexture = tex;
			AtlasPage page = material.ToSpineAtlasPage();

			AtlasRegion region = s.ToAtlasRegion(true);
			region.page = page;

			return region;
		}

		internal static AtlasRegion ToAtlasRegion (this Sprite s, bool isolatedTexture = false) {
			AtlasRegion region = new AtlasRegion();
			region.name = s.name;
			region.index = -1;
			region.degrees = s.packed && s.packingRotation != SpritePackingRotation.None ? 90 : 0;

			// World space units
			Bounds bounds = s.bounds;
			Vector2 boundsMin = bounds.min, boundsMax = bounds.max;

			// Texture space/pixel units
			Rect spineRect = s.textureRect.SpineUnityFlipRect(s.texture.height);
			Rect originalRect = s.rect;
			region.width = (int)spineRect.width;
			region.originalWidth = (int)originalRect.width;
			region.height = (int)spineRect.height;
			region.originalHeight = (int)originalRect.height;
			region.offsetX = s.textureRectOffset.x + spineRect.width * (0.5f - InverseLerp(boundsMin.x, boundsMax.x, 0));
			region.offsetY = s.textureRectOffset.y + spineRect.height * (0.5f - InverseLerp(boundsMin.y, boundsMax.y, 0));

			if (isolatedTexture) {
				region.u = 0;
				region.v = 1;
				region.u2 = 1;
				region.v2 = 0;
				region.x = 0;
				region.y = 0;
			} else {
				Texture2D tex = s.texture;
				Rect uvRect = TextureRectToUVRect(s.textureRect, tex.width, tex.height);
				region.u = uvRect.xMin;
				region.v = uvRect.yMax;
				region.u2 = uvRect.xMax;
				region.v2 = uvRect.yMin;
				region.x = (int)spineRect.x;
				region.y = (int)spineRect.y;
			}

			return region;
		}

		#region Runtime Repacking
		static readonly Dictionary<AtlasRegion, int> existingRegions = new Dictionary<AtlasRegion, int>();
		static readonly List<int> regionIndices = new List<int>();
		static readonly List<AtlasRegion> originalRegions = new List<AtlasRegion>();
		static readonly List<AtlasRegion> repackedRegions = new List<AtlasRegion>();
		static List<Texture2D>[] texturesToPackAtParam = new List<Texture2D>[1];
		static List<Attachment> inoutAttachments = new List<Attachment>();

		/// <summary>
		/// Fills the outputAttachments list with new attachment objects based on the attachments in sourceAttachments,
		/// but mapped to a new single texture using the same material.</summary>
		/// <remarks>Returned <c>Material</c> and <c>Texture</c> behave like <c>new Texture2D()</c>, thus you need to call <c>Destroy()</c>
		/// to free resources.
		/// This method caches necessary Texture copies for later re-use, which might steadily increase the texture memory
		/// footprint when used excessively. Set <paramref name="clearCache"/> to <c>true</c>
		/// or call <see cref="AtlasUtilities.ClearCache()"/> to clear this texture cache.
		/// You may want to call <c>Resources.UnloadUnusedAssets()</c> after that.
		/// </remarks>
		/// <param name="sourceAttachments">The list of attachments to be repacked.</param>
		/// <param name = "outputAttachments">The List(Attachment) to populate with the newly created Attachment objects.
		/// May be equal to <c>sourceAttachments</c> for in-place operation.</param>
		/// <param name="materialPropertySource">May be null. If no Material property source is provided, a material with
		/// default parameters using the provided <c>shader</c> will be created.</param>
		/// <param name="clearCache">When set to <c>true</c>, <see cref="AtlasUtilities.ClearCache()"/> is called after
		/// repacking to clear the texture cache. See remarks for additional info.</param>
		/// <param name="additionalTexturePropertyIDsToCopy">Optional additional textures (such as normal maps) to copy while repacking.
		/// To copy e.g. the main texture and normal maps, pass 'new int[] { Shader.PropertyToID("_BumpMap") }' at this parameter.</param>
		/// <param name="additionalOutputTextures">When <c>additionalTexturePropertyIDsToCopy</c> is non-null,
		/// this array will be filled with the resulting repacked texture for every property,
		/// just as the main repacked texture is assigned to <c>outputTexture</c>.</param>
		/// <param name="additionalTextureFormats">When <c>additionalTexturePropertyIDsToCopy</c> is non-null,
		/// this array will be used as <c>TextureFormat</c> at the Texture at the respective property.
		/// When <c>additionalTextureFormats</c> is <c>null</c> or when its array size is smaller,
		/// <c>textureFormat</c> is used where there exists no corresponding array item.</param>
		/// <param name="additionalTextureIsLinear">When <c>additionalTexturePropertyIDsToCopy</c> is non-null,
		/// this array will be used to determine whether <c>linear</c> or <c>sRGB</c> color space is used at the
		/// Texture at the respective property. When <c>additionalTextureIsLinear</c> is <c>null</c>, <c>linear</c> color space
		/// is assumed at every additional Texture element.
		/// When e.g. packing the main texture and normal maps, pass 'new bool[] { true }' at this parameter, because normal maps use
		/// linear color space.</param>
		public static void GetRepackedAttachments (List<Attachment> sourceAttachments, List<Attachment> outputAttachments, Material materialPropertySource,
			out Material outputMaterial, out Texture2D outputTexture,
			int maxAtlasSize = 1024, int padding = 2, TextureFormat textureFormat = SpineTextureFormat, bool mipmaps = UseMipMaps,
			string newAssetName = "Repacked Attachments", bool clearCache = false, bool useOriginalNonrenderables = true,
			int[] additionalTexturePropertyIDsToCopy = null, Texture2D[] additionalOutputTextures = null,
			TextureFormat[] additionalTextureFormats = null, bool[] additionalTextureIsLinear = null) {

			Shader shader = materialPropertySource == null ? Shader.Find("Spine/Skeleton") : materialPropertySource.shader;
			GetRepackedAttachments(sourceAttachments, outputAttachments, shader, out outputMaterial, out outputTexture,
				maxAtlasSize, padding, textureFormat, mipmaps, newAssetName,
				materialPropertySource, clearCache, useOriginalNonrenderables,
				additionalTexturePropertyIDsToCopy, additionalOutputTextures,
				additionalTextureFormats, additionalTextureIsLinear);
		}

		/// <summary>
		/// Fills the outputAttachments list with new attachment objects based on the attachments in sourceAttachments,
		/// but mapped to a new single texture using the same material.</summary>
		/// <remarks>Returned <c>Material</c> and <c>Texture</c> behave like <c>new Texture2D()</c>, thus you need to call <c>Destroy()</c>
		/// to free resources.</remarks>
		/// <param name="sourceAttachments">The list of attachments to be repacked.</param>
		/// <param name = "outputAttachments">The List(Attachment) to populate with the newly created Attachment objects.
		/// May be equal to <c>sourceAttachments</c> for in-place operation.</param>
		/// <param name="materialPropertySource">May be null. If no Material property source is provided, a material with
		/// default parameters using the provided <c>shader</c> will be created.</param>
		/// <param name="additionalTexturePropertyIDsToCopy">Optional additional textures (such as normal maps) to copy while repacking.
		/// To copy e.g. the main texture and normal maps, pass 'new int[] { Shader.PropertyToID("_BumpMap") }' at this parameter.</param>
		/// <param name="additionalOutputTextures">When <c>additionalTexturePropertyIDsToCopy</c> is non-null,
		/// this array will be filled with the resulting repacked texture for every property,
		/// just as the main repacked texture is assigned to <c>outputTexture</c>.</param>
		/// <param name="additionalTextureFormats">When <c>additionalTexturePropertyIDsToCopy</c> is non-null,
		/// this array will be used as <c>TextureFormat</c> at the Texture at the respective property.
		/// When <c>additionalTextureFormats</c> is <c>null</c> or when its array size is smaller,
		/// <c>textureFormat</c> is used where there exists no corresponding array item.</param>
		/// <param name="additionalTextureIsLinear">When <c>additionalTexturePropertyIDsToCopy</c> is non-null,
		/// this array will be used to determine whether <c>linear</c> or <c>sRGB</c> color space is used at the
		/// Texture at the respective property. When <c>additionalTextureIsLinear</c> is <c>null</c>, <c>linear</c> color space
		/// is assumed at every additional Texture element.
		/// When e.g. packing the main texture and normal maps, pass 'new bool[] { true }' at this parameter, because normal maps use
		/// linear color space.</param>
		public static void GetRepackedAttachments (List<Attachment> sourceAttachments, List<Attachment> outputAttachments, Shader shader,
			out Material outputMaterial, out Texture2D outputTexture,
			int maxAtlasSize = 1024, int padding = 2, TextureFormat textureFormat = SpineTextureFormat, bool mipmaps = UseMipMaps,
			string newAssetName = "Repacked Attachments",
			Material materialPropertySource = null, bool clearCache = false, bool useOriginalNonrenderables = true,
			int[] additionalTexturePropertyIDsToCopy = null, Texture2D[] additionalOutputTextures = null,
			TextureFormat[] additionalTextureFormats = null, bool[] additionalTextureIsLinear = null) {

			if (sourceAttachments == null) throw new System.ArgumentNullException("sourceAttachments");
			if (outputAttachments == null) throw new System.ArgumentNullException("outputAttachments");
			outputTexture = null;
			if (additionalTexturePropertyIDsToCopy != null && additionalTextureIsLinear == null) {
				additionalTextureIsLinear = new bool[additionalTexturePropertyIDsToCopy.Length];
				for (int i = 0; i < additionalTextureIsLinear.Length; ++i) {
					additionalTextureIsLinear[i] = true;
				}
			}

			// Use these to detect and use shared regions.
			existingRegions.Clear();
			regionIndices.Clear();

			// Collect all textures from original attachments.
			int numTextureParamsToRepack = 1 + (additionalTexturePropertyIDsToCopy == null ? 0 : additionalTexturePropertyIDsToCopy.Length);
			additionalOutputTextures = (additionalTexturePropertyIDsToCopy == null ? null : new Texture2D[additionalTexturePropertyIDsToCopy.Length]);
			if (texturesToPackAtParam.Length < numTextureParamsToRepack)
				Array.Resize(ref texturesToPackAtParam, numTextureParamsToRepack);
			for (int i = 0; i < numTextureParamsToRepack; ++i) {
				if (texturesToPackAtParam[i] != null)
					texturesToPackAtParam[i].Clear();
				else
					texturesToPackAtParam[i] = new List<Texture2D>();
			}
			originalRegions.Clear();

			if (!object.ReferenceEquals(sourceAttachments, outputAttachments)) {
				outputAttachments.Clear();
				outputAttachments.AddRange(sourceAttachments);
			}

			int newRegionIndex = 0;
			for (int attachmentIndex = 0, n = sourceAttachments.Count; attachmentIndex < n; attachmentIndex++) {
				Attachment originalAttachment = sourceAttachments[attachmentIndex];

				if (originalAttachment is IHasTextureRegion) {
					MeshAttachment originalMeshAttachment = originalAttachment as MeshAttachment;
					IHasTextureRegion originalTextureAttachment = (IHasTextureRegion)originalAttachment;

					Attachment newAttachment = (originalTextureAttachment.Sequence != null) ? originalAttachment :
						(originalMeshAttachment != null) ? originalMeshAttachment.NewLinkedMesh() :
						originalAttachment.Copy();
					IHasTextureRegion newTextureAttachment = (IHasTextureRegion)newAttachment;
					AtlasRegion region = newTextureAttachment.Region as AtlasRegion;
					if (region == null && originalTextureAttachment.Sequence != null)
						region = (AtlasRegion)originalTextureAttachment.Sequence.Regions[0];

					int existingIndex;
					if (existingRegions.TryGetValue(region, out existingIndex)) {
						regionIndices.Add(existingIndex);
					} else {
						existingRegions.Add(region, newRegionIndex);
						Sequence originalSequence = originalTextureAttachment.Sequence;
						if (originalSequence != null) {
							newTextureAttachment.Sequence = new Sequence(originalSequence);
							for (int i = 0, regionCount = originalSequence.Regions.Length; i < regionCount; ++i) {
								AtlasRegion sequenceRegion = (AtlasRegion)originalSequence.Regions[i];
								AddRegionTexturesToPack(numTextureParamsToRepack, sequenceRegion, textureFormat, mipmaps,
									additionalTextureFormats, additionalTexturePropertyIDsToCopy, additionalTextureIsLinear);
								originalRegions.Add(sequenceRegion);
								regionIndices.Add(newRegionIndex);
								newRegionIndex++;
							}
						} else {
							AddRegionTexturesToPack(numTextureParamsToRepack, region, textureFormat, mipmaps,
								additionalTextureFormats, additionalTexturePropertyIDsToCopy, additionalTextureIsLinear);
							originalRegions.Add(region);
							regionIndices.Add(newRegionIndex);
							newRegionIndex++;
						}
					}
					outputAttachments[attachmentIndex] = newAttachment;
				} else {
					outputAttachments[attachmentIndex] = useOriginalNonrenderables ? originalAttachment : originalAttachment.Copy();
					regionIndices.Add(NonrenderingRegion); // Output attachments pairs with regionIndices list 1:1. Pad with a sentinel if the attachment doesn't have a region.
				}
			}

			// Rehydrate the repacked textures as a Material, Spine atlas and Spine.AtlasAttachments
			Material newMaterial = new Material(shader);
			if (materialPropertySource != null) {
				newMaterial.CopyPropertiesFromMaterial(materialPropertySource);
				newMaterial.shaderKeywords = materialPropertySource.shaderKeywords;
			}
			newMaterial.name = newAssetName;

			Rect[] rects = null;
			for (int i = 0; i < numTextureParamsToRepack; ++i) {
				// Fill a new texture with the collected attachment textures.
				Texture2D newTexture = new Texture2D(maxAtlasSize, maxAtlasSize,
									(i > 0 && additionalTextureFormats != null && i - 1 < additionalTextureFormats.Length) ?
									additionalTextureFormats[i - 1] : textureFormat,
									mipmaps,
									(i > 0) ? additionalTextureIsLinear[i - 1] : false);
				newTexture.mipMapBias = AtlasUtilities.DefaultMipmapBias;

				List<Texture2D> texturesToPack = texturesToPackAtParam[i];
				if (texturesToPack.Count > 0) {
					Texture2D sourceTexture = texturesToPack[0];
					newTexture.CopyTextureAttributesFrom(sourceTexture);
				}
				newTexture.name = newAssetName;
				Rect[] rectsForTexParam = newTexture.PackTextures(texturesToPack.ToArray(), padding, maxAtlasSize);
				if (i == 0) {
					rects = rectsForTexParam;
					newMaterial.mainTexture = newTexture;
					outputTexture = newTexture;
				} else {
					newMaterial.SetTexture(additionalTexturePropertyIDsToCopy[i - 1], newTexture);
					additionalOutputTextures[i - 1] = newTexture;
				}
			}

			AtlasPage page = newMaterial.ToSpineAtlasPage();
			page.name = newAssetName;

			repackedRegions.Clear();
			for (int i = 0, n = originalRegions.Count; i < n; i++) {
				AtlasRegion oldRegion = originalRegions[i];
				AtlasRegion newRegion = UVRectToAtlasRegion(rects[i], oldRegion, page);
				repackedRegions.Add(newRegion);
			}

			// Map the cloned attachments to the repacked atlas.
			for (int attachmentIndex = 0, repackedIndex = 0, n = outputAttachments.Count;
				attachmentIndex < n;
				++attachmentIndex, ++repackedIndex) {

				Attachment attachment = outputAttachments[attachmentIndex];
				IHasTextureRegion textureAttachment = attachment as IHasTextureRegion;
				if (textureAttachment != null) {
					if (textureAttachment.Sequence != null) {
						TextureRegion[] regions = textureAttachment.Sequence.Regions;
						textureAttachment.Region = repackedRegions[regionIndices[repackedIndex]];
						for (int r = 0, regionCount = regions.Length; r < regionCount; ++r) {
							regions[r] = repackedRegions[regionIndices[repackedIndex++]];
						}
						--repackedIndex;
					} else {
						textureAttachment.Region = repackedRegions[regionIndices[repackedIndex]];
					}
					textureAttachment.UpdateRegion();
				}
			}

			// Clean up.
			if (clearCache)
				AtlasUtilities.ClearCache();

			outputMaterial = newMaterial;
		}

		private static void AddRegionTexturesToPack (int numTextureParamsToRepack, AtlasRegion region,
			TextureFormat textureFormat, bool mipmaps, TextureFormat[] additionalTextureFormats,
			int[] additionalTexturePropertyIDsToCopy, bool[] additionalTextureIsLinear) {

			for (int i = 0; i < numTextureParamsToRepack; ++i) {
				Texture2D regionTexture = (i == 0 ?
					region.ToTexture(textureFormat, mipmaps) :
					region.ToTexture((additionalTextureFormats != null && i - 1 < additionalTextureFormats.Length) ?
						additionalTextureFormats[i - 1] : textureFormat,
						mipmaps, additionalTexturePropertyIDsToCopy[i - 1], additionalTextureIsLinear[i - 1]));
				texturesToPackAtParam[i].Add(regionTexture);
			}
		}

		/// <summary>
		/// Creates and populates a duplicate skin with cloned attachments that are backed by a new packed texture atlas
		/// comprised of all the regions from the original skin.</summary>
		/// <remarks>GetRepackedSkin is an expensive operation, preferably call it at level load time.
		/// No Spine.Atlas object is created so there is no way to find AtlasRegions except through the Attachments using them.
		/// Returned <c>Material</c> and <c>Texture</c> behave like <c>new Texture2D()</c>, thus you need to call <c>Destroy()</c>
		/// to free resources.
		/// This method caches necessary Texture copies for later re-use, which might steadily increase the texture memory
		/// footprint when used excessively. Set <paramref name="clearCache"/> to <c>true</c>
		/// or call <see cref="AtlasUtilities.ClearCache()"/> to clear this texture cache.
		/// You may want to call <c>Resources.UnloadUnusedAssets()</c> after that.
		/// </remarks>
		/// <param name="clearCache">When set to <c>true</c>, <see cref="AtlasUtilities.ClearCache()"/> is called after
		/// repacking to clear the texture cache. See remarks for additional info.</param>
		/// <param name="additionalTexturePropertyIDsToCopy">Optional additional textures (such as normal maps) to copy while repacking.
		/// To copy e.g. the main texture and normal maps, pass 'new int[] { Shader.PropertyToID("_BumpMap") }' at this parameter.</param>
		/// <param name="additionalOutputTextures">When <c>additionalTexturePropertyIDsToCopy</c> is non-null,
		/// this array will be filled with the resulting repacked texture for every property,
		/// just as the main repacked texture is assigned to <c>outputTexture</c>.</param>
		/// <param name="additionalTextureFormats">When <c>additionalTexturePropertyIDsToCopy</c> is non-null,
		/// this array will be used as <c>TextureFormat</c> at the Texture at the respective property.
		/// When <c>additionalTextureFormats</c> is <c>null</c> or when its array size is smaller,
		/// <c>textureFormat</c> is used where there exists no corresponding array item.</param>
		/// <param name="additionalTextureIsLinear">When <c>additionalTexturePropertyIDsToCopy</c> is non-null,
		/// this array will be used to determine whether <c>linear</c> or <c>sRGB</c> color space is used at the
		/// Texture at the respective property. When <c>additionalTextureIsLinear</c> is <c>null</c>, <c>linear</c> color space
		/// is assumed at every additional Texture element.
		/// When e.g. packing the main texture and normal maps, pass 'new bool[] { true }' at this parameter, because normal maps use
		/// linear color space.</param>
		public static Skin GetRepackedSkin (this Skin o, string newName, Material materialPropertySource, out Material outputMaterial, out Texture2D outputTexture,
			int maxAtlasSize = 1024, int padding = 2, TextureFormat textureFormat = SpineTextureFormat, bool mipmaps = UseMipMaps,
			bool useOriginalNonrenderables = true, bool clearCache = false,
			int[] additionalTexturePropertyIDsToCopy = null, Texture2D[] additionalOutputTextures = null,
			TextureFormat[] additionalTextureFormats = null, bool[] additionalTextureIsLinear = null) {

			return GetRepackedSkin(o, newName, materialPropertySource.shader, out outputMaterial, out outputTexture,
				maxAtlasSize, padding, textureFormat, mipmaps, materialPropertySource,
				clearCache, useOriginalNonrenderables, additionalTexturePropertyIDsToCopy, additionalOutputTextures,
				additionalTextureFormats, additionalTextureIsLinear);
		}

		/// <summary>
		/// Creates and populates a duplicate skin with cloned attachments that are backed by a new packed texture atlas
		/// comprised of all the regions from the original skin.</summary>
		/// See documentation of <see cref="GetRepackedSkin"/> for details.
		public static Skin GetRepackedSkin (this Skin o, string newName, Shader shader, out Material outputMaterial, out Texture2D outputTexture,
			int maxAtlasSize = 1024, int padding = 2, TextureFormat textureFormat = SpineTextureFormat, bool mipmaps = UseMipMaps,
			Material materialPropertySource = null, bool clearCache = false, bool useOriginalNonrenderables = true,
			int[] additionalTexturePropertyIDsToCopy = null, Texture2D[] additionalOutputTextures = null,
			TextureFormat[] additionalTextureFormats = null, bool[] additionalTextureIsLinear = null) {

			outputTexture = null;

			if (o == null) throw new System.NullReferenceException("Skin was null");
			ICollection<Skin.SkinEntry> skinAttachments = o.Attachments;
			Skin newSkin = new Skin(newName);

			newSkin.Bones.AddRange(o.Bones);
			newSkin.Constraints.AddRange(o.Constraints);

			inoutAttachments.Clear();
			foreach (Skin.SkinEntry entry in skinAttachments) {
				inoutAttachments.Add(entry.Attachment);
			}
			GetRepackedAttachments(inoutAttachments, inoutAttachments, materialPropertySource, out outputMaterial, out outputTexture,
				maxAtlasSize, padding, textureFormat, mipmaps, newName, clearCache, useOriginalNonrenderables,
				additionalTexturePropertyIDsToCopy, additionalOutputTextures, additionalTextureFormats, additionalTextureIsLinear);
			int i = 0;
			foreach (Skin.SkinEntry originalSkinEntry in skinAttachments) {
				Attachment newAttachment = inoutAttachments[i++];
				newSkin.SetAttachment(originalSkinEntry.SlotIndex, originalSkinEntry.Name, newAttachment);
			}
			return newSkin;
		}

		public static Sprite ToSprite (this AtlasRegion ar, float pixelsPerUnit = 100) {
			return Sprite.Create(ar.GetMainTexture(), ar.GetUnityRect(), new Vector2(0.5f, 0.5f), pixelsPerUnit);
		}

		struct IntAndAtlasRegionKey {
			int i;
			AtlasRegion region;

			public IntAndAtlasRegionKey (int i, AtlasRegion region) {
				this.i = i;
				this.region = region;
			}

			public override int GetHashCode () {
				return i.GetHashCode() * 23 ^ region.GetHashCode();
			}
		}
		static Dictionary<IntAndAtlasRegionKey, Texture2D> CachedRegionTextures = new Dictionary<IntAndAtlasRegionKey, Texture2D>();
		static List<Texture2D> CachedRegionTexturesList = new List<Texture2D>();

		/// <summary>
		/// Frees up textures cached by repacking and remapping operations.
		///
		/// Calling <see cref="AttachmentCloneExtensions.GetRemappedClone"/> with parameter <c>premultiplyAlpha=true</c>,
		/// <see cref="GetRepackedAttachments"/> or <see cref="GetRepackedSkin"/> will cache textures for later re-use,
		///	which might steadily increase the texture memory footprint when used excessively.
		///	You can clear this Texture cache by calling <see cref="AtlasUtilities.ClearCache()"/>.
		/// You may also want to call <c>Resources.UnloadUnusedAssets()</c> after that. Be aware that while this cleanup
		/// frees up memory, it is also a costly operation and will likely cause a spike in the framerate.
		/// Thus it is recommended to perform costly repacking and cleanup operations after e.g. a character customization
		/// screen has been exited, and if required additionally after a certain number of <c>GetRemappedClone()</c> calls.
		/// </summary>
		public static void ClearCache () {
			foreach (Texture2D t in CachedRegionTexturesList) {
				UnityEngine.Object.Destroy(t);
			}
			CachedRegionTextures.Clear();
			CachedRegionTexturesList.Clear();
		}

		/// <summary>Creates a new Texture2D object based on an AtlasRegion.
		/// If applyImmediately is true, Texture2D.Apply is called immediately after the Texture2D is filled with data.</summary>
		public static Texture2D ToTexture (this AtlasRegion ar, TextureFormat textureFormat = SpineTextureFormat, bool mipmaps = UseMipMaps,
			int texturePropertyId = 0, bool linear = false, bool applyPMA = false) {

			Texture2D output;

			IntAndAtlasRegionKey cacheKey = new IntAndAtlasRegionKey(texturePropertyId, ar);
			CachedRegionTextures.TryGetValue(cacheKey, out output);
			if (output == null) {
				Texture2D sourceTexture = texturePropertyId == 0 ? ar.GetMainTexture() : ar.GetTexture(texturePropertyId);
				Rect r = ar.GetUnityRect();
				int width = (int)r.width;
				int height = (int)r.height;
				output = new Texture2D(width, height, textureFormat, mipmaps, linear) { name = ar.name };
				output.CopyTextureAttributesFrom(sourceTexture);
				if (applyPMA)
					AtlasUtilities.CopyTextureApplyPMA(sourceTexture, r, output);
				else
					AtlasUtilities.CopyTexture(sourceTexture, r, output);
				CachedRegionTextures.Add(cacheKey, output);
				CachedRegionTexturesList.Add(output);
			}

			return output;
		}

		static Texture2D ToTexture (this Sprite s, TextureFormat textureFormat = SpineTextureFormat,
			bool mipmaps = UseMipMaps, bool linear = false, bool applyPMA = false) {

			Texture2D spriteTexture = s.texture;
			Rect r;
			if (!s.packed || s.packingMode == SpritePackingMode.Rectangle) {
				r = s.textureRect;
			} else {
				r = new Rect();
				r.xMin = Math.Min(s.uv[0].x, s.uv[1].x) * spriteTexture.width;
				r.xMax = Math.Max(s.uv[0].x, s.uv[1].x) * spriteTexture.width;
				r.yMin = Math.Min(s.uv[0].y, s.uv[2].y) * spriteTexture.height;
				r.yMax = Math.Max(s.uv[0].y, s.uv[2].y) * spriteTexture.height;
#if UNITY_EDITOR
				if (s.uv.Length > 4) {
					Debug.LogError("When using a tightly packed SpriteAtlas with Spine, you may only access Sprites that are packed as 'FullRect' from it! " +
						"You can either disable 'Tight Packing' at the whole SpriteAtlas, or change the single Sprite's TextureImporter Setting 'MeshType' to 'Full Rect'." +
						"Sprite Asset: " + s.name, s);
				}
#endif
			}
			Texture2D newTexture = new Texture2D((int)r.width, (int)r.height, textureFormat, mipmaps, linear);
			newTexture.CopyTextureAttributesFrom(spriteTexture);
			if (applyPMA)
				AtlasUtilities.CopyTextureApplyPMA(spriteTexture, r, newTexture);
			else
				AtlasUtilities.CopyTexture(spriteTexture, r, newTexture);
			return newTexture;
		}

		static Texture2D GetClone (this Texture2D t, TextureFormat textureFormat = SpineTextureFormat,
			bool mipmaps = UseMipMaps, bool linear = false, bool applyPMA = false) {

			Texture2D newTexture = new Texture2D((int)t.width, (int)t.height, textureFormat, mipmaps, linear);
			newTexture.CopyTextureAttributesFrom(t);
			if (applyPMA)
				AtlasUtilities.CopyTextureApplyPMA(t, new Rect(0, 0, t.width, t.height), newTexture);
			else
				AtlasUtilities.CopyTexture(t, new Rect(0, 0, t.width, t.height), newTexture);
			return newTexture;
		}

		static void CopyTexture (Texture2D source, Rect sourceRect, Texture2D destination) {
			if (SystemInfo.copyTextureSupport == UnityEngine.Rendering.CopyTextureSupport.None) {
				// GetPixels fallback for old devices.
				Color[] pixelBuffer = source.GetPixels((int)sourceRect.x, (int)sourceRect.y, (int)sourceRect.width, (int)sourceRect.height);
				destination.SetPixels(pixelBuffer);
				destination.Apply();
			} else {
				Graphics.CopyTexture(source, 0, 0, (int)sourceRect.x, (int)sourceRect.y, (int)sourceRect.width, (int)sourceRect.height, destination, 0, 0, 0, 0);
			}
		}

		static void CopyTextureApplyPMA (Texture2D source, Rect sourceRect, Texture2D destination) {
			Color[] pixelBuffer = source.GetPixels((int)sourceRect.x, (int)sourceRect.y, (int)sourceRect.width, (int)sourceRect.height);
			for (int i = 0, n = pixelBuffer.Length; i < n; i++) {
				Color p = pixelBuffer[i];
				float a = p.a;
				p.r = p.r * a;
				p.g = p.g * a;
				p.b = p.b * a;
				pixelBuffer[i] = p;
			}
			destination.SetPixels(pixelBuffer);
			destination.Apply();
		}

		static bool IsRenderable (Attachment a) {
			return a is IHasTextureRegion;
		}

		/// <summary>
		/// Get a rect with flipped Y so that a Spine atlas rect gets converted to a Unity Sprite rect and vice versa.</summary>
		static Rect SpineUnityFlipRect (this Rect rect, int textureHeight) {
			rect.y = textureHeight - rect.y - rect.height;
			return rect;
		}

		/// <summary>
		/// Gets the Rect of an AtlasRegion according to Unity texture coordinates (x-right, y-up).
		/// This overload relies on region.page.height being correctly set.</summary>
		static Rect GetUnityRect (this AtlasRegion region) {
			return region.GetSpineAtlasRect().SpineUnityFlipRect(region.page.height);
		}

		/// <summary>
		/// Gets the Rect of an AtlasRegion according to Unity texture coordinates (x-right, y-up).</summary>
		static Rect GetUnityRect (this AtlasRegion region, int textureHeight) {
			return region.GetSpineAtlasRect().SpineUnityFlipRect(textureHeight);
		}

		/// <summary>
		/// Returns a Rect of the AtlasRegion according to Spine texture coordinates. (x-right, y-down)</summary>
		static Rect GetSpineAtlasRect (this AtlasRegion region, bool includeRotate = true) {
			float width = region.packedWidth;
			float height = region.packedHeight;
			if (includeRotate && region.degrees == 270) {
				width = region.packedHeight;
				height = region.packedWidth;
			}
			return new Rect(region.x, region.y, width, height);
		}

		/// <summary>
		/// Denormalize a uvRect into a texture-space Rect.</summary>
		static Rect UVRectToTextureRect (Rect uvRect, int texWidth, int texHeight) {
			uvRect.x *= texWidth;
			uvRect.width *= texWidth;
			uvRect.y *= texHeight;
			uvRect.height *= texHeight;
			return uvRect;
		}

		/// <summary>
		/// Normalize a texture Rect into UV coordinates.</summary>
		static Rect TextureRectToUVRect (Rect textureRect, int texWidth, int texHeight) {
			textureRect.x = Mathf.InverseLerp(0, texWidth, textureRect.x);
			textureRect.y = Mathf.InverseLerp(0, texHeight, textureRect.y);
			textureRect.width = Mathf.InverseLerp(0, texWidth, textureRect.width);
			textureRect.height = Mathf.InverseLerp(0, texHeight, textureRect.height);
			return textureRect;
		}

		/// <summary>
		/// Creates a new Spine AtlasRegion according to a Unity UV Rect (x-right, y-up, uv-normalized).</summary>
		static AtlasRegion UVRectToAtlasRegion (Rect uvRect, AtlasRegion referenceRegion, AtlasPage page) {
			Rect tr = UVRectToTextureRect(uvRect, page.width, page.height);
			Rect rr = tr.SpineUnityFlipRect(page.height);

			int x = (int)rr.x;
			int y = (int)rr.y;
			int w = (int)rr.width;
			int h = (int)rr.height;

			if (referenceRegion.degrees == 270) {
				int tempW = w;
				w = h;
				h = tempW;
			}

			// Note: originalW and originalH need to be scaled according to the
			// repacked width and height, repacking can mess with aspect ratio, etc.
			int originalW = Mathf.RoundToInt((float)w * ((float)referenceRegion.originalWidth / (float)referenceRegion.width));
			int originalH = Mathf.RoundToInt((float)h * ((float)referenceRegion.originalHeight / (float)referenceRegion.height));

			int offsetX = Mathf.RoundToInt((float)referenceRegion.offsetX * ((float)w / (float)referenceRegion.width));
			int offsetY = Mathf.RoundToInt((float)referenceRegion.offsetY * ((float)h / (float)referenceRegion.height));

			float u = uvRect.xMin;
			float u2 = uvRect.xMax;
			float v = uvRect.yMax;
			float v2 = uvRect.yMin;

			if (referenceRegion.degrees == 270) {
				// at a 270 degree region, u2/v2 deltas and atlas width/height are swapped, and delta-v is negative.
				float du = uvRect.width; // u2 - u;
				float dv = uvRect.height; // v - v2;
				float atlasAspectRatio = (float)page.width / (float)page.height;
				u2 = u + (dv / atlasAspectRatio);
				v2 = v - (du * atlasAspectRatio);
			}

			return new AtlasRegion {
				page = page,
				name = referenceRegion.name,

				u = u,
				u2 = u2,
				v = v,
				v2 = v2,

				index = -1,

				width = w,
				originalWidth = originalW,
				height = h,
				originalHeight = originalH,
				offsetX = offsetX,
				offsetY = offsetY,
				x = x,
				y = y,

				rotate = referenceRegion.rotate,
				degrees = referenceRegion.degrees
			};
		}

		/// <summary>
		/// Convenience method for getting the main texture of the material of the page of the region.</summary>
		static Texture2D GetMainTexture (this AtlasRegion region) {
			Material material = (region.page.rendererObject as Material);
			return material.mainTexture as Texture2D;
		}

		/// <summary>
		/// Convenience method for getting any texture of the material of the page of the region by texture property name.</summary>
		static Texture2D GetTexture (this AtlasRegion region, string texturePropertyName) {
			Material material = (region.page.rendererObject as Material);
			return material.GetTexture(texturePropertyName) as Texture2D;
		}

		/// <summary>
		/// Convenience method for getting any texture of the material of the page of the region by texture property id.</summary>
		static Texture2D GetTexture (this AtlasRegion region, int texturePropertyId) {
			Material material = (region.page.rendererObject as Material);
			return material.GetTexture(texturePropertyId) as Texture2D;
		}

		static void CopyTextureAttributesFrom (this Texture2D destination, Texture2D source) {
			destination.filterMode = source.filterMode;
			destination.anisoLevel = source.anisoLevel;
#if UNITY_EDITOR
			destination.alphaIsTransparency = source.alphaIsTransparency;
#endif
			destination.wrapModeU = source.wrapModeU;
			destination.wrapModeV = source.wrapModeV;
			destination.wrapModeW = source.wrapModeW;
		}
		#endregion

		static float InverseLerp (float a, float b, float value) {
			return (value - a) / (b - a);
		}
	}
}