/****************************************************************************** * Spine Runtimes Software License v2.5 * * Copyright (c) 2013-2016, Esoteric Software * All rights reserved. * * You are granted a perpetual, non-exclusive, non-sublicensable, and * non-transferable license to use, install, execute, and perform the Spine * Runtimes software and derivative works solely for personal or internal * use. Without the written permission of Esoteric Software (see Section 2 of * the Spine Software License Agreement), you may not (a) modify, translate, * adapt, or develop new applications using the Spine Runtimes or otherwise * create derivative works or improvements of the Spine Runtimes or (b) remove, * delete, alter, or obscure any trademarks or any copyright, trademark, patent, * or other intellectual property or proprietary rights notices on or in the * Software, including any copy thereof. Redistributions in binary or source * form must include this license and terms. * * THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "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 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 THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. *****************************************************************************/ using UnityEngine; using System.Collections.Generic; namespace Spine.Unity.Modules.AttachmentTools { public static class AttachmentRegionExtensions { #region GetRegion /// /// Tries to get the region (image) of a renderable attachment. If the attachment is not renderable, it returns null. public static AtlasRegion GetRegion (this Attachment attachment) { var renderableAttachment = attachment as IHasRendererObject; if (renderableAttachment != null) return renderableAttachment.RendererObject as AtlasRegion; return null; } /// Gets the region (image) of a RegionAttachment public static AtlasRegion GetRegion (this RegionAttachment regionAttachment) { return regionAttachment.RendererObject as AtlasRegion; } /// Gets the region (image) of a MeshAttachment public static AtlasRegion GetRegion (this MeshAttachment meshAttachment) { return meshAttachment.RendererObject as AtlasRegion; } #endregion #region SetRegion /// /// Tries to set the region (image) of a renderable attachment. If the attachment is not renderable, nothing is applied. public static void SetRegion (this Attachment attachment, AtlasRegion region, bool updateOffset = true) { var regionAttachment = attachment as RegionAttachment; if (regionAttachment != null) regionAttachment.SetRegion(region, updateOffset); var meshAttachment = attachment as MeshAttachment; if (meshAttachment != null) meshAttachment.SetRegion(region, updateOffset); } /// Sets the region (image) of a RegionAttachment public static void SetRegion (this RegionAttachment attachment, AtlasRegion region, bool updateOffset = true) { if (region == null) throw new System.ArgumentNullException("region"); // (AtlasAttachmentLoader.cs) attachment.RendererObject = region; attachment.SetUVs(region.u, region.v, region.u2, region.v2, region.rotate); attachment.regionOffsetX = region.offsetX; attachment.regionOffsetY = region.offsetY; attachment.regionWidth = region.width; attachment.regionHeight = region.height; attachment.regionOriginalWidth = region.originalWidth; attachment.regionOriginalHeight = region.originalHeight; if (updateOffset) attachment.UpdateOffset(); } /// Sets the region (image) of a MeshAttachment public static void SetRegion (this MeshAttachment attachment, AtlasRegion region, bool updateUVs = true) { if (region == null) throw new System.ArgumentNullException("region"); // (AtlasAttachmentLoader.cs) attachment.RendererObject = region; attachment.RegionU = region.u; attachment.RegionV = region.v; attachment.RegionU2 = region.u2; attachment.RegionV2 = region.v2; attachment.RegionRotate = region.rotate; attachment.regionOffsetX = region.offsetX; attachment.regionOffsetY = region.offsetY; attachment.regionWidth = region.width; attachment.regionHeight = region.height; attachment.regionOriginalWidth = region.originalWidth; attachment.regionOriginalHeight = region.originalHeight; if (updateUVs) attachment.UpdateUVs(); } #endregion #region Runtime RegionAttachments /// /// Creates a RegionAttachment based on a sprite. This method creates a real, usable AtlasRegion. That AtlasRegion uses a new AtlasPage with the Material provided./// public static RegionAttachment ToRegionAttachment (this Sprite sprite, Material material, float rotation = 0f) { return sprite.ToRegionAttachment(material.ToSpineAtlasPage(), rotation); } /// /// Creates a RegionAttachment based on a sprite. This method creates a real, usable AtlasRegion. That AtlasRegion uses the AtlasPage provided./// public static RegionAttachment ToRegionAttachment (this Sprite sprite, AtlasPage page, float rotation = 0f) { if (sprite == null) throw new System.ArgumentNullException("sprite"); if (page == null) throw new System.ArgumentNullException("page"); var region = sprite.ToAtlasRegion(page); var unitsPerPixel = 1f / sprite.pixelsPerUnit; return region.ToRegionAttachment(sprite.name, unitsPerPixel, rotation); } /// /// Creates a Spine.AtlasRegion that uses a premultiplied alpha duplicate texture of the Sprite's texture data. Returns a RegionAttachment that uses it. Use this if you plan to use a premultiply alpha shader such as "Spine/Skeleton" public static RegionAttachment ToRegionAttachmentPMAClone (this Sprite sprite, Shader shader, TextureFormat textureFormat = AtlasUtilities.SpineTextureFormat, bool mipmaps = AtlasUtilities.UseMipMaps, Material materialPropertySource = null, float rotation = 0f) { if (sprite == null) throw new System.ArgumentNullException("sprite"); if (shader == null) throw new System.ArgumentNullException("shader"); var region = sprite.ToAtlasRegionPMAClone(shader, textureFormat, mipmaps, materialPropertySource); var unitsPerPixel = 1f / sprite.pixelsPerUnit; return region.ToRegionAttachment(sprite.name, unitsPerPixel, rotation); } public static RegionAttachment ToRegionAttachmentPMAClone (this Sprite sprite, Material materialPropertySource, TextureFormat textureFormat = AtlasUtilities.SpineTextureFormat, bool mipmaps = AtlasUtilities.UseMipMaps, float rotation = 0f) { return sprite.ToRegionAttachmentPMAClone(materialPropertySource.shader, textureFormat, mipmaps, materialPropertySource, rotation); } /// /// Creates a new RegionAttachment from a given AtlasRegion. public static RegionAttachment ToRegionAttachment (this AtlasRegion region, string attachmentName, float scale = 0.01f, float rotation = 0f) { if (string.IsNullOrEmpty(attachmentName)) throw new System.ArgumentException("attachmentName can't be null or empty.", "attachmentName"); if (region == null) throw new System.ArgumentNullException("region"); // (AtlasAttachmentLoader.cs) var attachment = new RegionAttachment(attachmentName); attachment.RendererObject = region; attachment.SetUVs(region.u, region.v, region.u2, region.v2, region.rotate); attachment.regionOffsetX = region.offsetX; attachment.regionOffsetY = region.offsetY; attachment.regionWidth = region.width; attachment.regionHeight = region.height; attachment.regionOriginalWidth = region.originalWidth; attachment.regionOriginalHeight = region.originalHeight; attachment.Path = region.name; attachment.scaleX = 1; attachment.scaleY = 1; attachment.rotation = rotation; attachment.r = 1; attachment.g = 1; attachment.b = 1; attachment.a = 1; // pass OriginalWidth and OriginalHeight because UpdateOffset uses it in its calculation. attachment.width = attachment.regionOriginalWidth * scale; attachment.height = attachment.regionOriginalHeight * scale; attachment.SetColor(Color.white); attachment.UpdateOffset(); return attachment; } /// Sets the scale. Call regionAttachment.UpdateOffset to apply the change. public static void SetScale (this RegionAttachment regionAttachment, Vector2 scale) { regionAttachment.scaleX = scale.x; regionAttachment.scaleY = scale.y; } /// Sets the scale. Call regionAttachment.UpdateOffset to apply the change. public static void SetScale (this RegionAttachment regionAttachment, float x, float y) { regionAttachment.scaleX = x; regionAttachment.scaleY = y; } /// Sets the position offset. Call regionAttachment.UpdateOffset to apply the change. public static void SetPositionOffset (this RegionAttachment regionAttachment, Vector2 offset) { regionAttachment.x = offset.x; regionAttachment.y = offset.y; } /// Sets the position offset. Call regionAttachment.UpdateOffset to apply the change. public static void SetPositionOffset (this RegionAttachment regionAttachment, float x, float y) { regionAttachment.x = x; regionAttachment.y = y; } /// Sets the rotation. Call regionAttachment.UpdateOffset to apply the change. public static void SetRotation (this RegionAttachment regionAttachment, float rotation) { regionAttachment.rotation = rotation; } #endregion } 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; 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) { var material = new Material(shader); if (materialPropertySource != null) { material.CopyPropertiesFromMaterial(materialPropertySource); material.shaderKeywords = materialPropertySource.shaderKeywords; } material.mainTexture = t; var page = material.ToSpineAtlasPage(); float width = t.width; float height = t.height; var region = new AtlasRegion(); region.name = t.name; region.index = -1; region.rotate = false; // 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; } /// /// Creates a Spine.AtlasRegion that uses a premultiplied alpha duplicate of the Sprite's texture data. public static AtlasRegion ToAtlasRegionPMAClone (this Texture2D t, Material materialPropertySource, TextureFormat textureFormat = SpineTextureFormat, bool mipmaps = UseMipMaps) { return t.ToAtlasRegionPMAClone(materialPropertySource.shader, textureFormat, mipmaps, materialPropertySource); } /// /// Creates a Spine.AtlasRegion that uses a premultiplied alpha duplicate of the Sprite's texture data. public static AtlasRegion ToAtlasRegionPMAClone (this Texture2D t, Shader shader, TextureFormat textureFormat = SpineTextureFormat, bool mipmaps = UseMipMaps, Material materialPropertySource = null) { var material = new Material(shader); if (materialPropertySource != null) { material.CopyPropertiesFromMaterial(materialPropertySource); material.shaderKeywords = materialPropertySource.shaderKeywords; } var newTexture = t.GetClone(false, textureFormat, mipmaps); newTexture.ApplyPMA(true); newTexture.name = t.name + "-pma-"; material.name = t.name + shader.name; material.mainTexture = newTexture; var page = material.ToSpineAtlasPage(); var region = newTexture.ToAtlasRegion(shader); region.page = page; return region; } /// /// Creates a new Spine.AtlasPage from a UnityEngine.Material. If the material has a preassigned texture, the page width and height will be set. public static AtlasPage ToSpineAtlasPage (this Material m) { var newPage = new AtlasPage { rendererObject = m, name = m.name }; var t = m.mainTexture; if (t != null) { newPage.width = t.width; newPage.height = t.height; } return newPage; } /// /// Creates a Spine.AtlasRegion from a UnityEngine.Sprite. 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."); var region = s.ToAtlasRegion(); region.page = page; return region; } /// /// 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. public static AtlasRegion ToAtlasRegion (this Sprite s, Material material) { var region = s.ToAtlasRegion(); region.page = material.ToSpineAtlasPage(); return region; } /// /// Creates a Spine.AtlasRegion that uses a premultiplied alpha duplicate of the Sprite's texture data. public static AtlasRegion ToAtlasRegionPMAClone (this Sprite s, Shader shader, TextureFormat textureFormat = SpineTextureFormat, bool mipmaps = UseMipMaps, Material materialPropertySource = null) { var material = new Material(shader); if (materialPropertySource != null) { material.CopyPropertiesFromMaterial(materialPropertySource); material.shaderKeywords = materialPropertySource.shaderKeywords; } var tex = s.ToTexture(false, textureFormat, mipmaps); tex.ApplyPMA(true); tex.name = s.name + "-pma-"; material.name = tex.name + shader.name; material.mainTexture = tex; var page = material.ToSpineAtlasPage(); var region = s.ToAtlasRegion(true); region.page = page; 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); } internal static AtlasRegion ToAtlasRegion (this Sprite s, bool isolatedTexture = false) { var region = new AtlasRegion(); region.name = s.name; region.index = -1; region.rotate = s.packed && s.packingRotation != SpritePackingRotation.None; // World space units Bounds bounds = s.bounds; Vector2 boundsMin = bounds.min, boundsMax = bounds.max; // Texture space/pixel units Rect spineRect = s.rect.SpineUnityFlipRect(s.texture.height); region.width = (int)spineRect.width; region.originalWidth = (int)spineRect.width; region.height = (int)spineRect.height; region.originalHeight = (int)spineRect.height; region.offsetX = spineRect.width * (0.5f - InverseLerp(boundsMin.x, boundsMax.x, 0)); region.offsetY = 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 /// /// 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. /// The list of attachments to be repacked. /// The List(Attachment) to populate with the newly created Attachment objects. /// /// May be null. If no Material property source is provided, no special public static void GetRepackedAttachments (List sourceAttachments, List 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) { if (sourceAttachments == null) throw new System.ArgumentNullException("sourceAttachments"); if (outputAttachments == null) throw new System.ArgumentNullException("outputAttachments"); // Use these to detect and use shared regions. var existingRegions = new Dictionary(); var regionIndexes = new List(); var texturesToPack = new List(); var originalRegions = new List(); outputAttachments.Clear(); outputAttachments.AddRange(sourceAttachments); int newRegionIndex = 0; for (int i = 0, n = sourceAttachments.Count; i < n; i++) { var originalAttachment = sourceAttachments[i]; if (IsRenderable(originalAttachment)) { var newAttachment = originalAttachment.GetClone(true); var region = newAttachment.GetRegion(); int existingIndex; if (existingRegions.TryGetValue(region, out existingIndex)) { regionIndexes.Add(existingIndex); // Store the region index for the eventual new attachment. } else { originalRegions.Add(region); texturesToPack.Add(region.ToTexture()); // Add the texture to the PackTextures argument existingRegions.Add(region, newRegionIndex); // Add the region to the dictionary of known regions regionIndexes.Add(newRegionIndex); // Store the region index for the eventual new attachment. newRegionIndex++; } outputAttachments[i] = newAttachment; } else { outputAttachments[i] = useOriginalNonrenderables ? originalAttachment : originalAttachment.GetClone(true); regionIndexes.Add(NonrenderingRegion); // Output attachments pairs with regionIndexes list 1:1. Pad with a sentinel if the attachment doesn't have a region. } } // Fill a new texture with the collected attachment textures. var newTexture = new Texture2D(maxAtlasSize, maxAtlasSize, textureFormat, mipmaps); newTexture.mipMapBias = AtlasUtilities.DefaultMipmapBias; newTexture.anisoLevel = texturesToPack[0].anisoLevel; newTexture.name = newAssetName; var rects = newTexture.PackTextures(texturesToPack.ToArray(), padding, maxAtlasSize); // Rehydrate the repacked textures as a Material, Spine atlas and Spine.AtlasAttachments Shader shader = materialPropertySource == null ? Shader.Find("Spine/Skeleton") : materialPropertySource.shader; var newMaterial = new Material(shader); if (materialPropertySource != null) { newMaterial.CopyPropertiesFromMaterial(materialPropertySource); newMaterial.shaderKeywords = materialPropertySource.shaderKeywords; } newMaterial.name = newAssetName; newMaterial.mainTexture = newTexture; var page = newMaterial.ToSpineAtlasPage(); page.name = newAssetName; var repackedRegions = new List(); for (int i = 0, n = originalRegions.Count; i < n; i++) { var oldRegion = originalRegions[i]; var newRegion = UVRectToAtlasRegion(rects[i], oldRegion.name, page, oldRegion.offsetX, oldRegion.offsetY, oldRegion.rotate); repackedRegions.Add(newRegion); } // Map the cloned attachments to the repacked atlas. for (int i = 0, n = outputAttachments.Count; i < n; i++) { var a = outputAttachments[i]; if (IsRenderable(a)) a.SetRegion(repackedRegions[regionIndexes[i]]); } // Clean up. if (clearCache) AtlasUtilities.ClearCache(); outputTexture = newTexture; outputMaterial = newMaterial; } /// /// 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. /// No Spine.Atlas object is created so there is no way to find AtlasRegions except through the Attachments using them. 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) { return GetRepackedSkin(o, newName, materialPropertySource.shader, out outputMaterial, out outputTexture, maxAtlasSize, padding, textureFormat, mipmaps, materialPropertySource, useOriginalNonrenderables); } /// /// 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. /// No Spine.Atlas object is created so there is no way to find AtlasRegions except through the Attachments using them. 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) { if (o == null) throw new System.NullReferenceException("Skin was null"); var skinAttachments = o.Attachments; var newSkin = new Skin(newName); // Use these to detect and use shared regions. var existingRegions = new Dictionary(); var regionIndexes = new List(); // Collect all textures from the attachments of the original skin. var repackedAttachments = new List(); var texturesToPack = new List(); var originalRegions = new List(); int newRegionIndex = 0; foreach (var skinEntry in skinAttachments) { var originalKey = skinEntry.Key; var originalAttachment = skinEntry.Value; Attachment newAttachment; if (IsRenderable(originalAttachment)) { newAttachment = originalAttachment.GetClone(true); var region = newAttachment.GetRegion(); int existingIndex; if (existingRegions.TryGetValue(region, out existingIndex)) { regionIndexes.Add(existingIndex); // Store the region index for the eventual new attachment. } else { originalRegions.Add(region); texturesToPack.Add(region.ToTexture()); // Add the texture to the PackTextures argument existingRegions.Add(region, newRegionIndex); // Add the region to the dictionary of known regions regionIndexes.Add(newRegionIndex); // Store the region index for the eventual new attachment. newRegionIndex++; } repackedAttachments.Add(newAttachment); newSkin.AddAttachment(originalKey.slotIndex, originalKey.name, newAttachment); } else { newSkin.AddAttachment(originalKey.slotIndex, originalKey.name, useOriginalNonrenderables ? originalAttachment : originalAttachment.GetClone(true)); } } // Fill a new texture with the collected attachment textures. var newTexture = new Texture2D(maxAtlasSize, maxAtlasSize, textureFormat, mipmaps); newTexture.mipMapBias = AtlasUtilities.DefaultMipmapBias; newTexture.anisoLevel = texturesToPack[0].anisoLevel; newTexture.name = newName; var rects = newTexture.PackTextures(texturesToPack.ToArray(), padding, maxAtlasSize); // Rehydrate the repacked textures as a Material, Spine atlas and Spine.AtlasAttachments var newMaterial = new Material(shader); if (materialPropertySource != null) { newMaterial.CopyPropertiesFromMaterial(materialPropertySource); newMaterial.shaderKeywords = materialPropertySource.shaderKeywords; } newMaterial.name = newName; newMaterial.mainTexture = newTexture; var page = newMaterial.ToSpineAtlasPage(); page.name = newName; var repackedRegions = new List(); for (int i = 0, n = originalRegions.Count; i < n; i++) { var oldRegion = originalRegions[i]; var newRegion = UVRectToAtlasRegion(rects[i], oldRegion.name, page, oldRegion.offsetX, oldRegion.offsetY, oldRegion.rotate); repackedRegions.Add(newRegion); } // Map the cloned attachments to the repacked atlas. for (int i = 0, n = repackedAttachments.Count; i < n; i++) { var a = repackedAttachments[i]; if (IsRenderable(a)) a.SetRegion(repackedRegions[regionIndexes[i]]); } // Clean up. if (clearCache) AtlasUtilities.ClearCache(); outputTexture = newTexture; outputMaterial = newMaterial; 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); } static Dictionary CachedRegionTextures = new Dictionary(); static List CachedRegionTexturesList = new List(); public static void ClearCache () { foreach (var t in CachedRegionTexturesList) { UnityEngine.Object.Destroy(t); } CachedRegionTextures.Clear(); CachedRegionTexturesList.Clear(); } /// 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. public static Texture2D ToTexture (this AtlasRegion ar, bool applyImmediately = true, TextureFormat textureFormat = SpineTextureFormat, bool mipmaps = UseMipMaps) { Texture2D output; CachedRegionTextures.TryGetValue(ar, out output); if (output == null) { Texture2D sourceTexture = ar.GetMainTexture(); Rect r = ar.GetUnityRect(sourceTexture.height); int width = (int)r.width; int height = (int)r.height; output = new Texture2D(width, height, textureFormat, mipmaps); output.name = ar.name; Color[] pixelBuffer = sourceTexture.GetPixels((int)r.x, (int)r.y, width, height); output.SetPixels(pixelBuffer); CachedRegionTextures.Add(ar, output); CachedRegionTexturesList.Add(output); if (applyImmediately) output.Apply(); } return output; } static Texture2D ToTexture (this Sprite s, bool applyImmediately = true, TextureFormat textureFormat = SpineTextureFormat, bool mipmaps = UseMipMaps) { var spriteTexture = s.texture; var r = s.textureRect; var spritePixels = spriteTexture.GetPixels((int)r.x, (int)r.y, (int)r.width, (int)r.height); var newTexture = new Texture2D((int)r.width, (int)r.height, textureFormat, mipmaps); newTexture.SetPixels(spritePixels); if (applyImmediately) newTexture.Apply(); return newTexture; } static Texture2D GetClone (this Texture2D t, bool applyImmediately = true, TextureFormat textureFormat = SpineTextureFormat, bool mipmaps = UseMipMaps) { var spritePixels = t.GetPixels(0, 0, (int)t.width, (int)t.height); var newTexture = new Texture2D((int)t.width, (int)t.height, textureFormat, mipmaps); newTexture.SetPixels(spritePixels); if (applyImmediately) newTexture.Apply(); return newTexture; } static bool IsRenderable (Attachment a) { return a is IHasRendererObject; } /// /// Get a rect with flipped Y so that a Spine atlas rect gets converted to a Unity Sprite rect and vice versa. static Rect SpineUnityFlipRect (this Rect rect, int textureHeight) { rect.y = textureHeight - rect.y - rect.height; return rect; } /// /// 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. static Rect GetUnityRect (this AtlasRegion region) { return region.GetSpineAtlasRect().SpineUnityFlipRect(region.page.height); } /// /// Gets the Rect of an AtlasRegion according to Unity texture coordinates (x-right, y-up). static Rect GetUnityRect (this AtlasRegion region, int textureHeight) { return region.GetSpineAtlasRect().SpineUnityFlipRect(textureHeight); } /// /// Returns a Rect of the AtlasRegion according to Spine texture coordinates. (x-right, y-down) static Rect GetSpineAtlasRect (this AtlasRegion region, bool includeRotate = true) { if (includeRotate && region.rotate) return new Rect(region.x, region.y, region.height, region.width); else return new Rect(region.x, region.y, region.width, region.height); } /// /// Denormalize a uvRect into a texture-space Rect. static Rect UVRectToTextureRect (Rect uvRect, int texWidth, int texHeight) { uvRect.x *= texWidth; uvRect.width *= texWidth; uvRect.y *= texHeight; uvRect.height *= texHeight; return uvRect; } /// /// Normalize a texture Rect into UV coordinates. 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; } /// /// Creates a new Spine AtlasRegion according to a Unity UV Rect (x-right, y-up, uv-normalized). static AtlasRegion UVRectToAtlasRegion (Rect uvRect, string name, AtlasPage page, float offsetX, float offsetY, bool rotate) { var tr = UVRectToTextureRect(uvRect, page.width, page.height); var rr = tr.SpineUnityFlipRect(page.height); int x = (int)rr.x, y = (int)rr.y; int w, h; if (rotate) { w = (int)rr.height; h = (int)rr.width; } else { w = (int)rr.width; h = (int)rr.height; } return new AtlasRegion { page = page, name = name, u = uvRect.xMin, u2 = uvRect.xMax, v = uvRect.yMax, v2 = uvRect.yMin, index = -1, width = w, originalWidth = w, height = h, originalHeight = h, offsetX = offsetX, offsetY = offsetY, x = x, y = y, rotate = rotate }; } /// /// Convenience method for getting the main texture of the material of the page of the region. static Texture2D GetMainTexture (this AtlasRegion region) { var material = (region.page.rendererObject as Material); return material.mainTexture as Texture2D; } static void ApplyPMA (this Texture2D texture, bool applyImmediately = true) { var pixels = texture.GetPixels(); for (int i = 0, n = pixels.Length; i < n; i++) { Color p = pixels[i]; float a = p.a; p.r = p.r * a; p.g = p.g * a; p.b = p.b * a; pixels[i] = p; } texture.SetPixels(pixels); if (applyImmediately) texture.Apply(); } #endregion static float InverseLerp (float a, float b, float value) { return (value - a) / (b - a); } } public static class SkinUtilities { #region Skeleton Skin Extensions /// /// Convenience method for duplicating a skeleton's current active skin so changes to it will not affect other skeleton instances. . public static Skin UnshareSkin (this Skeleton skeleton, bool includeDefaultSkin, bool unshareAttachments, AnimationState state = null) { // 1. Copy the current skin and set the skeleton's skin to the new one. var newSkin = skeleton.GetClonedSkin("cloned skin", includeDefaultSkin, unshareAttachments, true); skeleton.SetSkin(newSkin); // 2. Apply correct attachments: skeleton.SetToSetupPose + animationState.Apply if (state != null) { skeleton.SetToSetupPose(); state.Apply(skeleton); } // 3. Return unshared skin. return newSkin; } public static Skin GetClonedSkin (this Skeleton skeleton, string newSkinName, bool includeDefaultSkin = false, bool cloneAttachments = false, bool cloneMeshesAsLinked = true) { var newSkin = new Skin(newSkinName); // may have null name. Harmless. var defaultSkin = skeleton.data.DefaultSkin; var activeSkin = skeleton.skin; if (includeDefaultSkin) defaultSkin.CopyTo(newSkin, true, cloneAttachments, cloneMeshesAsLinked); if (activeSkin != null) activeSkin.CopyTo(newSkin, true, cloneAttachments, cloneMeshesAsLinked); return newSkin; } #endregion /// /// Gets a shallow copy of the skin. The cloned skin's attachments are shared with the original skin. public static Skin GetClone (this Skin original) { var newSkin = new Skin(original.name + " clone"); var newSkinAttachments = newSkin.Attachments; foreach (var a in original.Attachments) newSkinAttachments[a.Key] = a.Value; return newSkin; } /// Adds an attachment to the skin for the specified slot index and name. If the name already exists for the slot, the previous value is replaced. public static void SetAttachment (this Skin skin, string slotName, string keyName, Attachment attachment, Skeleton skeleton) { int slotIndex = skeleton.FindSlotIndex(slotName); if (skeleton == null) throw new System.ArgumentNullException("skeleton", "skeleton cannot be null."); if (slotIndex == -1) throw new System.ArgumentException(string.Format("Slot '{0}' does not exist in skeleton.", slotName), "slotName"); skin.AddAttachment(slotIndex, keyName, attachment); } /// Gets an attachment from the skin for the specified slot index and name. public static Attachment GetAttachment (this Skin skin, string slotName, string keyName, Skeleton skeleton) { int slotIndex = skeleton.FindSlotIndex(slotName); if (skeleton == null) throw new System.ArgumentNullException("skeleton", "skeleton cannot be null."); if (slotIndex == -1) throw new System.ArgumentException(string.Format("Slot '{0}' does not exist in skeleton.", slotName), "slotName"); return skin.GetAttachment(slotIndex, keyName); } /// Adds an attachment to the skin for the specified slot index and name. If the name already exists for the slot, the previous value is replaced. public static void SetAttachment (this Skin skin, int slotIndex, string keyName, Attachment attachment) { skin.AddAttachment(slotIndex, keyName, attachment); } /// Removes the attachment. Returns true if the element is successfully found and removed; otherwise, false. public static bool RemoveAttachment (this Skin skin, string slotName, string keyName, Skeleton skeleton) { int slotIndex = skeleton.FindSlotIndex(slotName); if (skeleton == null) throw new System.ArgumentNullException("skeleton", "skeleton cannot be null."); if (slotIndex == -1) throw new System.ArgumentException(string.Format("Slot '{0}' does not exist in skeleton.", slotName), "slotName"); return skin.RemoveAttachment(slotIndex, keyName); } /// Removes the attachment. Returns true if the element is successfully found and removed; otherwise, false. public static bool RemoveAttachment (this Skin skin, int slotIndex, string keyName) { return skin.Attachments.Remove(new Skin.AttachmentKeyTuple(slotIndex, keyName)); } public static void Clear (this Skin skin) { skin.Attachments.Clear(); } public static void Append (this Skin destination, Skin source) { source.CopyTo(destination, true, false); } public static void CopyTo (this Skin source, Skin destination, bool overwrite, bool cloneAttachments, bool cloneMeshesAsLinked = true) { var sourceAttachments = source.Attachments; var destinationAttachments = destination.Attachments; if (cloneAttachments) { if (overwrite) { foreach (var e in sourceAttachments) destinationAttachments[e.Key] = e.Value.GetClone(cloneMeshesAsLinked); } else { foreach (var e in sourceAttachments) { if (destinationAttachments.ContainsKey(e.Key)) continue; destinationAttachments.Add(e.Key, e.Value.GetClone(cloneMeshesAsLinked)); } } } else { if (overwrite) { foreach (var e in sourceAttachments) destinationAttachments[e.Key] = e.Value; } else { foreach (var e in sourceAttachments) { if (destinationAttachments.ContainsKey(e.Key)) continue; destinationAttachments.Add(e.Key, e.Value); } } } } } public static class AttachmentCloneExtensions { /// /// Clones the attachment. public static Attachment GetClone (this Attachment o, bool cloneMeshesAsLinked) { var regionAttachment = o as RegionAttachment; if (regionAttachment != null) return regionAttachment.GetClone(); var meshAttachment = o as MeshAttachment; if (meshAttachment != null) return cloneMeshesAsLinked ? meshAttachment.GetLinkedClone() : meshAttachment.GetClone(); var boundingBoxAttachment = o as BoundingBoxAttachment; if (boundingBoxAttachment != null) return boundingBoxAttachment.GetClone(); var pathAttachment = o as PathAttachment; if (pathAttachment != null) return pathAttachment.GetClone(); var pointAttachment = o as PointAttachment; if (pointAttachment != null) return pointAttachment.GetClone(); var clippingAttachment = o as ClippingAttachment; if (clippingAttachment != null) return clippingAttachment.GetClone(); return null; } public static RegionAttachment GetClone (this RegionAttachment o) { return new RegionAttachment(o.Name + "clone") { x = o.x, y = o.y, rotation = o.rotation, scaleX = o.scaleX, scaleY = o.scaleY, width = o.width, height = o.height, r = o.r, g = o.g, b = o.b, a = o.a, Path = o.Path, RendererObject = o.RendererObject, regionOffsetX = o.regionOffsetX, regionOffsetY = o.regionOffsetY, regionWidth = o.regionWidth, regionHeight = o.regionHeight, regionOriginalWidth = o.regionOriginalWidth, regionOriginalHeight = o.regionOriginalHeight, uvs = o.uvs.Clone() as float[], offset = o.offset.Clone() as float[] }; } public static ClippingAttachment GetClone (this ClippingAttachment o) { var ca = new ClippingAttachment(o.Name) { endSlot = o.endSlot }; CloneVertexAttachment(o, ca); return ca; } public static PointAttachment GetClone (this PointAttachment o) { var pa = new PointAttachment(o.Name) { rotation = o.rotation, x = o.x, y = o.y }; return pa; } public static BoundingBoxAttachment GetClone (this BoundingBoxAttachment o) { var ba = new BoundingBoxAttachment(o.Name); CloneVertexAttachment(o, ba); return ba; } public static MeshAttachment GetLinkedClone (this MeshAttachment o, bool inheritDeform = true) { return o.GetLinkedMesh(o.Name, o.RendererObject as AtlasRegion, inheritDeform, copyOriginalProperties: true); } /// /// Returns a clone of the MeshAttachment. This will cause Deform animations to stop working unless you explicity set the .parentMesh to the original. public static MeshAttachment GetClone (this MeshAttachment o) { var ma = new MeshAttachment(o.Name) { r = o.r, g = o.g, b = o.b, a = o.a, inheritDeform = o.inheritDeform, Path = o.Path, RendererObject = o.RendererObject, regionOffsetX = o.regionOffsetX, regionOffsetY = o.regionOffsetY, regionWidth = o.regionWidth, regionHeight = o.regionHeight, regionOriginalWidth = o.regionOriginalWidth, regionOriginalHeight = o.regionOriginalHeight, RegionU = o.RegionU, RegionV = o.RegionV, RegionU2 = o.RegionU2, RegionV2 = o.RegionV2, RegionRotate = o.RegionRotate, uvs = o.uvs.Clone() as float[] }; // Linked mesh if (o.ParentMesh != null) { // bones, vertices, worldVerticesLength, regionUVs, triangles, HullLength, Edges, Width, Height ma.ParentMesh = o.ParentMesh; } else { CloneVertexAttachment(o, ma); // bones, vertices, worldVerticesLength ma.regionUVs = o.regionUVs.Clone() as float[]; ma.triangles = o.triangles.Clone() as int[]; ma.hulllength = o.hulllength; // Nonessential. ma.Edges = (o.Edges == null) ? null : o.Edges.Clone() as int[]; // Allow absence of Edges array when nonessential data is not exported. ma.Width = o.Width; ma.Height = o.Height; } return ma; } public static PathAttachment GetClone (this PathAttachment o) { var newPathAttachment = new PathAttachment(o.Name) { lengths = o.lengths.Clone() as float[], closed = o.closed, constantSpeed = o.constantSpeed }; CloneVertexAttachment(o, newPathAttachment); return newPathAttachment; } static void CloneVertexAttachment (VertexAttachment src, VertexAttachment dest) { dest.worldVerticesLength = src.worldVerticesLength; if (src.bones != null) dest.bones = src.bones.Clone() as int[]; if (src.vertices != null) dest.vertices = src.vertices.Clone() as float[]; } #region Runtime Linked MeshAttachments /// /// Returns a new linked mesh linked to this MeshAttachment. It will be mapped to the AtlasRegion provided. public static MeshAttachment GetLinkedMesh (this MeshAttachment o, string newLinkedMeshName, AtlasRegion region, bool inheritDeform = true, bool copyOriginalProperties = false) { //if (string.IsNullOrEmpty(attachmentName)) throw new System.ArgumentException("attachmentName cannot be null or empty", "attachmentName"); if (region == null) throw new System.ArgumentNullException("region"); // If parentMesh is a linked mesh, create a link to its parent. Preserves Deform animations. if (o.ParentMesh != null) o = o.ParentMesh; // 1. NewMeshAttachment (AtlasAttachmentLoader.cs) var mesh = new MeshAttachment(newLinkedMeshName); mesh.SetRegion(region, false); // 2. (SkeletonJson.cs::ReadAttachment. case: LinkedMesh) mesh.Path = newLinkedMeshName; if (copyOriginalProperties) { mesh.r = o.r; mesh.g = o.g; mesh.b = o.b; mesh.a = o.a; } else { mesh.r = 1f; mesh.g = 1f; mesh.b = 1f; mesh.a = 1f; } //mesh.ParentMesh property call below sets mesh.Width and mesh.Height // 3. Link mesh with parent. (SkeletonJson.cs) mesh.inheritDeform = inheritDeform; mesh.ParentMesh = o; mesh.UpdateUVs(); return mesh; } /// /// Returns a new linked mesh linked to this MeshAttachment. It will be mapped to an AtlasRegion generated from a Sprite. The AtlasRegion will be mapped to a new Material based on the shader. /// For better caching and batching, use GetLinkedMesh(string, AtlasRegion, bool) public static MeshAttachment GetLinkedMesh (this MeshAttachment o, Sprite sprite, Shader shader, bool inheritDeform = true, Material materialPropertySource = null) { var m = new Material(shader); if (materialPropertySource != null) { m.CopyPropertiesFromMaterial(materialPropertySource); m.shaderKeywords = materialPropertySource.shaderKeywords; } return o.GetLinkedMesh(sprite.name, sprite.ToAtlasRegion(), inheritDeform); } /// /// Returns a new linked mesh linked to this MeshAttachment. It will be mapped to an AtlasRegion generated from a Sprite. The AtlasRegion will be mapped to a new Material based on the shader. /// For better caching and batching, use GetLinkedMesh(string, AtlasRegion, bool) public static MeshAttachment GetLinkedMesh (this MeshAttachment o, Sprite sprite, Material materialPropertySource, bool inheritDeform = true) { return o.GetLinkedMesh(sprite, materialPropertySource.shader, inheritDeform, materialPropertySource); } #endregion #region RemappedClone Convenience Methods /// /// Gets a clone of the attachment remapped with a sprite image. /// The remapped clone. /// The original attachment. /// The sprite whose texture to use. /// The source material used to copy the shader and material properties from. /// If true, a premultiply alpha clone of the original texture will be created. /// If true MeshAttachments will be cloned as linked meshes and will inherit animation from the original attachment. /// If true the size of the original attachment will be followed, instead of using the Sprite size. public static Attachment GetRemappedClone (this Attachment o, Sprite sprite, Material sourceMaterial, bool premultiplyAlpha = true, bool cloneMeshAsLinked = true, bool useOriginalRegionSize = false) { var atlasRegion = premultiplyAlpha ? sprite.ToAtlasRegionPMAClone(sourceMaterial) : sprite.ToAtlasRegion(new Material(sourceMaterial) { mainTexture = sprite.texture }); return o.GetRemappedClone(atlasRegion, cloneMeshAsLinked, useOriginalRegionSize, 1f/sprite.pixelsPerUnit); } /// /// Gets a clone of the attachment remapped with an atlasRegion image. /// The remapped clone. /// The original attachment. /// Atlas region. /// If true MeshAttachments will be cloned as linked meshes and will inherit animation from the original attachment. /// If true the size of the original attachment will be followed, instead of using the Sprite size. /// Unity units per pixel scale used to scale the atlas region size when not using the original region size. public static Attachment GetRemappedClone (this Attachment o, AtlasRegion atlasRegion, bool cloneMeshAsLinked = true, bool useOriginalRegionSize = false, float scale = 0.01f) { var regionAttachment = o as RegionAttachment; if (regionAttachment != null) { RegionAttachment newAttachment = regionAttachment.GetClone(); newAttachment.SetRegion(atlasRegion, false); if (!useOriginalRegionSize) { newAttachment.width = atlasRegion.width * scale; newAttachment.height = atlasRegion.height * scale; } newAttachment.UpdateOffset(); return newAttachment; } else { var meshAttachment = o as MeshAttachment; if (meshAttachment != null) { MeshAttachment newAttachment = cloneMeshAsLinked ? meshAttachment.GetLinkedClone(cloneMeshAsLinked) : meshAttachment.GetClone(); newAttachment.SetRegion(atlasRegion); return newAttachment; } } return o.GetClone(true); // Non-renderable Attachments will return as normal cloned attachments. } #endregion } }