/******************************************************************************
|
* 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_2018_2_OR_NEWER
|
#define EXPOSES_SPRITE_ATLAS_UTILITIES
|
#endif
|
|
using System;
|
using System.Collections.Generic;
|
using UnityEngine;
|
using UnityEngine.U2D;
|
|
#if UNITY_EDITOR
|
using UnityEditor;
|
using System.Reflection;
|
#endif
|
|
namespace Spine.Unity {
|
/// <summary>Loads and stores a Spine atlas and list of materials.</summary>
|
[CreateAssetMenu(fileName = "New Spine SpriteAtlas Asset", menuName = "Spine/Spine SpriteAtlas Asset")]
|
public class SpineSpriteAtlasAsset : AtlasAssetBase {
|
public SpriteAtlas spriteAtlasFile;
|
public Material[] materials;
|
protected Atlas atlas;
|
public bool updateRegionsInPlayMode;
|
|
[System.Serializable]
|
protected class SavedRegionInfo {
|
public float x, y, width, height;
|
public SpritePackingRotation packingRotation;
|
}
|
[SerializeField] protected SavedRegionInfo[] savedRegions;
|
|
public override bool IsLoaded { get { return this.atlas != null; } }
|
|
public override IEnumerable<Material> Materials { get { return materials; } }
|
public override int MaterialCount { get { return materials == null ? 0 : materials.Length; } }
|
public override Material PrimaryMaterial { get { return materials[0]; } }
|
|
#if UNITY_EDITOR
|
static MethodInfo GetPackedSpritesMethod, GetPreviewTexturesMethod;
|
#if !EXPOSES_SPRITE_ATLAS_UTILITIES
|
static MethodInfo PackAtlasesMethod;
|
#endif
|
#endif
|
|
#region Runtime Instantiation
|
/// <summary>
|
/// Creates a runtime AtlasAsset</summary>
|
public static SpineSpriteAtlasAsset CreateRuntimeInstance (SpriteAtlas spriteAtlasFile, Material[] materials, bool initialize) {
|
SpineSpriteAtlasAsset atlasAsset = ScriptableObject.CreateInstance<SpineSpriteAtlasAsset>();
|
atlasAsset.Reset();
|
atlasAsset.spriteAtlasFile = spriteAtlasFile;
|
atlasAsset.materials = materials;
|
|
if (initialize)
|
atlasAsset.GetAtlas();
|
|
return atlasAsset;
|
}
|
#endregion
|
|
void Reset () {
|
Clear();
|
}
|
|
public override void Clear () {
|
atlas = null;
|
}
|
|
/// <returns>The atlas or null if it could not be loaded.</returns>
|
public override Atlas GetAtlas (bool onlyMetaData = false) {
|
if (spriteAtlasFile == null) {
|
Debug.LogError("SpriteAtlas file not set for SpineSpriteAtlasAsset: " + name, this);
|
Clear();
|
return null;
|
}
|
|
if (!onlyMetaData && (materials == null || materials.Length == 0)) {
|
Debug.LogError("Materials not set for SpineSpriteAtlasAsset: " + name, this);
|
Clear();
|
return null;
|
}
|
|
if (atlas != null) return atlas;
|
|
try {
|
atlas = LoadAtlas(spriteAtlasFile);
|
return atlas;
|
} catch (Exception ex) {
|
Debug.LogError("Error analyzing SpriteAtlas for SpineSpriteAtlasAsset: " + name + "\n" + ex.Message + "\n" + ex.StackTrace, this);
|
return null;
|
}
|
}
|
|
protected void AssignRegionsFromSavedRegions (Sprite[] sprites, Atlas usedAtlas) {
|
|
if (savedRegions == null || savedRegions.Length != sprites.Length)
|
return;
|
|
int i = 0;
|
foreach (AtlasRegion region in usedAtlas) {
|
SavedRegionInfo savedRegion = savedRegions[i];
|
AtlasPage page = region.page;
|
|
region.degrees = savedRegion.packingRotation == SpritePackingRotation.None ? 0 : 90;
|
|
float x = savedRegion.x;
|
float y = savedRegion.y;
|
float width = savedRegion.width;
|
float height = savedRegion.height;
|
|
region.u = x / (float)page.width;
|
region.v = y / (float)page.height;
|
if (region.degrees == 90) {
|
region.u2 = (x + height) / (float)page.width;
|
region.v2 = (y + width) / (float)page.height;
|
} else {
|
region.u2 = (x + width) / (float)page.width;
|
region.v2 = (y + height) / (float)page.height;
|
}
|
region.x = (int)x;
|
region.y = (int)y;
|
region.width = Math.Abs((int)width);
|
region.height = Math.Abs((int)height);
|
|
// flip upside down
|
float temp = region.v;
|
region.v = region.v2;
|
region.v2 = temp;
|
|
region.originalWidth = (int)width;
|
region.originalHeight = (int)height;
|
|
// note: currently sprite pivot offsets are ignored.
|
// Sprite sprite = sprites[i];
|
region.offsetX = 0;//sprite.pivot.x;
|
region.offsetY = 0;//sprite.pivot.y;
|
|
++i;
|
}
|
}
|
|
private Atlas LoadAtlas (UnityEngine.U2D.SpriteAtlas spriteAtlas) {
|
|
List<AtlasPage> pages = new List<AtlasPage>();
|
List<AtlasRegion> regions = new List<AtlasRegion>();
|
|
Sprite[] sprites = new UnityEngine.Sprite[spriteAtlas.spriteCount];
|
spriteAtlas.GetSprites(sprites);
|
if (sprites.Length == 0)
|
return new Atlas(pages, regions);
|
|
Texture2D texture = null;
|
#if UNITY_EDITOR
|
if (!Application.isPlaying)
|
texture = AccessPackedTextureEditor(spriteAtlas);
|
else
|
#endif
|
texture = AccessPackedTexture(sprites);
|
|
Material material = materials[0];
|
#if !UNITY_EDITOR
|
material.mainTexture = texture;
|
#endif
|
|
Spine.AtlasPage page = new AtlasPage();
|
page.name = spriteAtlas.name;
|
page.width = texture.width;
|
page.height = texture.height;
|
page.format = Spine.Format.RGBA8888;
|
|
page.minFilter = TextureFilter.Linear;
|
page.magFilter = TextureFilter.Linear;
|
page.uWrap = TextureWrap.ClampToEdge;
|
page.vWrap = TextureWrap.ClampToEdge;
|
page.rendererObject = material;
|
pages.Add(page);
|
|
sprites = AccessPackedSprites(spriteAtlas);
|
|
int i = 0;
|
for (; i < sprites.Length; ++i) {
|
Sprite sprite = sprites[i];
|
AtlasRegion region = new AtlasRegion();
|
region.name = sprite.name.Replace("(Clone)", "");
|
region.page = page;
|
region.degrees = sprite.packingRotation == SpritePackingRotation.None ? 0 : 90;
|
|
region.u2 = 1;
|
region.v2 = 1;
|
region.width = page.width;
|
region.height = page.height;
|
region.originalWidth = page.width;
|
region.originalHeight = page.height;
|
|
region.index = i;
|
regions.Add(region);
|
}
|
|
Atlas atlas = new Atlas(pages, regions);
|
AssignRegionsFromSavedRegions(sprites, atlas);
|
|
return atlas;
|
}
|
|
#if UNITY_EDITOR
|
public static void UpdateByStartingEditorPlayMode () {
|
EditorApplication.isPlaying = true;
|
}
|
|
public static bool AnySpriteAtlasNeedsRegionsLoaded () {
|
string[] guids = UnityEditor.AssetDatabase.FindAssets("t:SpineSpriteAtlasAsset");
|
foreach (string guid in guids) {
|
string path = UnityEditor.AssetDatabase.GUIDToAssetPath(guid);
|
if (!string.IsNullOrEmpty(path)) {
|
SpineSpriteAtlasAsset atlasAsset = UnityEditor.AssetDatabase.LoadAssetAtPath<SpineSpriteAtlasAsset>(path);
|
if (atlasAsset) {
|
if (atlasAsset.RegionsNeedLoading)
|
return true;
|
}
|
}
|
}
|
return false;
|
}
|
|
public static void UpdateWhenEditorPlayModeStarted () {
|
if (!EditorApplication.isPlaying)
|
return;
|
|
EditorApplication.update -= UpdateWhenEditorPlayModeStarted;
|
string[] guids = UnityEditor.AssetDatabase.FindAssets("t:SpineSpriteAtlasAsset");
|
if (guids.Length == 0)
|
return;
|
|
Debug.Log("Updating SpineSpriteAtlasAssets");
|
foreach (string guid in guids) {
|
string path = UnityEditor.AssetDatabase.GUIDToAssetPath(guid);
|
if (!string.IsNullOrEmpty(path)) {
|
SpineSpriteAtlasAsset atlasAsset = UnityEditor.AssetDatabase.LoadAssetAtPath<SpineSpriteAtlasAsset>(path);
|
if (atlasAsset) {
|
atlasAsset.atlas = atlasAsset.LoadAtlas(atlasAsset.spriteAtlasFile);
|
atlasAsset.LoadRegionsInEditorPlayMode();
|
Debug.Log(string.Format("Updated regions of '{0}'", atlasAsset.name), atlasAsset);
|
}
|
}
|
}
|
|
EditorApplication.isPlaying = false;
|
}
|
|
public bool RegionsNeedLoading {
|
get { return savedRegions == null || savedRegions.Length == 0 || updateRegionsInPlayMode; }
|
}
|
|
public void LoadRegionsInEditorPlayMode () {
|
|
Sprite[] sprites = null;
|
System.Type T = Type.GetType("UnityEditor.U2D.SpriteAtlasExtensions,UnityEditor");
|
MethodInfo method = T.GetMethod("GetPackedSprites", BindingFlags.NonPublic | BindingFlags.Static);
|
if (method != null) {
|
object retval = method.Invoke(null, new object[] { spriteAtlasFile });
|
Sprite[] spritesArray = retval as Sprite[];
|
if (spritesArray != null && spritesArray.Length > 0) {
|
sprites = spritesArray;
|
}
|
}
|
if (sprites == null) {
|
sprites = new UnityEngine.Sprite[spriteAtlasFile.spriteCount];
|
spriteAtlasFile.GetSprites(sprites);
|
}
|
if (sprites.Length == 0) {
|
Debug.LogWarning(string.Format("SpriteAtlas '{0}' contains no sprites. Please make sure all assigned images are set to import type 'Sprite'.", spriteAtlasFile.name), spriteAtlasFile);
|
return;
|
} else if (sprites[0].packingMode == SpritePackingMode.Tight) {
|
Debug.LogError(string.Format("SpriteAtlas '{0}': Tight packing is not supported. Please disable 'Tight Packing' in the SpriteAtlas Inspector.", spriteAtlasFile.name), spriteAtlasFile);
|
return;
|
}
|
|
if (savedRegions == null || savedRegions.Length != sprites.Length)
|
savedRegions = new SavedRegionInfo[sprites.Length];
|
|
int i = 0;
|
foreach (AtlasRegion region in atlas) {
|
Sprite sprite = sprites[i];
|
Rect rect = sprite.textureRect;
|
float x = rect.min.x;
|
float y = rect.min.y;
|
float width = rect.width;
|
float height = rect.height;
|
|
SavedRegionInfo savedRegion = new SavedRegionInfo();
|
savedRegion.x = x;
|
savedRegion.y = y;
|
savedRegion.width = width;
|
savedRegion.height = height;
|
savedRegion.packingRotation = sprite.packingRotation;
|
savedRegions[i] = savedRegion;
|
|
++i;
|
}
|
updateRegionsInPlayMode = false;
|
AssignRegionsFromSavedRegions(sprites, atlas);
|
EditorUtility.SetDirty(this);
|
AssetDatabase.SaveAssets();
|
}
|
|
public static Texture2D AccessPackedTextureEditor (SpriteAtlas spriteAtlas) {
|
#if EXPOSES_SPRITE_ATLAS_UTILITIES
|
UnityEditor.U2D.SpriteAtlasUtility.PackAtlases(new SpriteAtlas[] { spriteAtlas }, EditorUserBuildSettings.activeBuildTarget);
|
#else
|
/*if (PackAtlasesMethod == null) {
|
System.Type T = Type.GetType("UnityEditor.U2D.SpriteAtlasUtility,UnityEditor");
|
PackAtlasesMethod = T.GetMethod("PackAtlases", BindingFlags.NonPublic | BindingFlags.Static);
|
}
|
if (PackAtlasesMethod != null) {
|
PackAtlasesMethod.Invoke(null, new object[] { new SpriteAtlas[] { spriteAtlas }, EditorUserBuildSettings.activeBuildTarget });
|
}*/
|
#endif
|
if (GetPreviewTexturesMethod == null) {
|
System.Type T = Type.GetType("UnityEditor.U2D.SpriteAtlasExtensions,UnityEditor");
|
GetPreviewTexturesMethod = T.GetMethod("GetPreviewTextures", BindingFlags.NonPublic | BindingFlags.Static);
|
}
|
if (GetPreviewTexturesMethod != null) {
|
object retval = GetPreviewTexturesMethod.Invoke(null, new object[] { spriteAtlas });
|
Texture2D[] textures = retval as Texture2D[];
|
if (textures.Length > 0)
|
return textures[0];
|
}
|
return null;
|
}
|
#endif
|
public static Texture2D AccessPackedTexture (Sprite[] sprites) {
|
return sprites[0].texture;
|
}
|
|
|
public static Sprite[] AccessPackedSprites (UnityEngine.U2D.SpriteAtlas spriteAtlas) {
|
Sprite[] sprites = null;
|
#if UNITY_EDITOR
|
if (!Application.isPlaying) {
|
|
if (GetPackedSpritesMethod == null) {
|
System.Type T = Type.GetType("UnityEditor.U2D.SpriteAtlasExtensions,UnityEditor");
|
GetPackedSpritesMethod = T.GetMethod("GetPackedSprites", BindingFlags.NonPublic | BindingFlags.Static);
|
}
|
if (GetPackedSpritesMethod != null) {
|
object retval = GetPackedSpritesMethod.Invoke(null, new object[] { spriteAtlas });
|
Sprite[] spritesArray = retval as Sprite[];
|
if (spritesArray != null && spritesArray.Length > 0) {
|
sprites = spritesArray;
|
}
|
}
|
}
|
#endif
|
if (sprites == null) {
|
sprites = new UnityEngine.Sprite[spriteAtlas.spriteCount];
|
spriteAtlas.GetSprites(sprites);
|
if (sprites.Length == 0)
|
return null;
|
}
|
return sprites;
|
}
|
}
|
}
|
