373 lines
13 KiB
C#
373 lines
13 KiB
C#
|
/******************************************************************************
|
||
|
|
* 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_5 || UNITY_5_3_OR_NEWER || UNITY_WSA || UNITY_WP8 || UNITY_WP8_1)
|
||
|
|
#define IS_UNITY
|
||
|
|
#endif
|
||
|
|
|
||
|
|
using System;
|
||
|
|
using System.Collections.Generic;
|
||
|
|
using System.Globalization;
|
||
|
|
using System.IO;
|
||
|
|
using System.Reflection;
|
||
|
|
|
||
|
|
#if WINDOWS_STOREAPP
|
||
|
|
using System.Threading.Tasks;
|
||
|
|
using Windows.Storage;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
namespace Spine {
|
||
|
|
public class Atlas : IEnumerable<AtlasRegion> {
|
||
|
|
readonly List<AtlasPage> pages = new List<AtlasPage>();
|
||
|
|
List<AtlasRegion> regions = new List<AtlasRegion>();
|
||
|
|
TextureLoader textureLoader;
|
||
|
|
|
||
|
|
#region IEnumerable implementation
|
||
|
|
public IEnumerator<AtlasRegion> GetEnumerator () {
|
||
|
|
return regions.GetEnumerator();
|
||
|
|
}
|
||
|
|
|
||
|
|
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator () {
|
||
|
|
return regions.GetEnumerator();
|
||
|
|
}
|
||
|
|
#endregion
|
||
|
|
|
||
|
|
public List<AtlasRegion> Regions { get { return regions; } }
|
||
|
|
public List<AtlasPage> Pages { get { return pages; } }
|
||
|
|
|
||
|
|
#if !(IS_UNITY)
|
||
|
|
#if WINDOWS_STOREAPP
|
||
|
|
private async Task ReadFile (string path, TextureLoader textureLoader) {
|
||
|
|
var folder = Windows.ApplicationModel.Package.Current.InstalledLocation;
|
||
|
|
var file = await folder.GetFileAsync(path).AsTask().ConfigureAwait(false);
|
||
|
|
using (StreamReader reader = new StreamReader(await file.OpenStreamForReadAsync().ConfigureAwait(false))) {
|
||
|
|
try {
|
||
|
|
Atlas atlas = new Atlas(reader, Path.GetDirectoryName(path), textureLoader);
|
||
|
|
this.pages = atlas.pages;
|
||
|
|
this.regions = atlas.regions;
|
||
|
|
this.textureLoader = atlas.textureLoader;
|
||
|
|
} catch (Exception ex) {
|
||
|
|
throw new Exception("Error reading atlas file: " + path, ex);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public Atlas (string path, TextureLoader textureLoader) {
|
||
|
|
this.ReadFile(path, textureLoader).Wait();
|
||
|
|
}
|
||
|
|
#else
|
||
|
|
public Atlas (string path, TextureLoader textureLoader) {
|
||
|
|
#if WINDOWS_PHONE
|
||
|
|
Stream stream = Microsoft.Xna.Framework.TitleContainer.OpenStream(path);
|
||
|
|
using (StreamReader reader = new StreamReader(stream)) {
|
||
|
|
#else
|
||
|
|
using (StreamReader reader = new StreamReader(path)) {
|
||
|
|
#endif // WINDOWS_PHONE
|
||
|
|
try {
|
||
|
|
Atlas atlas = new Atlas(reader, Path.GetDirectoryName(path), textureLoader);
|
||
|
|
this.pages = atlas.pages;
|
||
|
|
this.regions = atlas.regions;
|
||
|
|
this.textureLoader = atlas.textureLoader;
|
||
|
|
} catch (Exception ex) {
|
||
|
|
throw new Exception("Error reading atlas file: " + path, ex);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#endif // WINDOWS_STOREAPP
|
||
|
|
#endif
|
||
|
|
|
||
|
|
public Atlas (List<AtlasPage> pages, List<AtlasRegion> regions) {
|
||
|
|
if (pages == null) throw new ArgumentNullException("pages", "pages cannot be null.");
|
||
|
|
if (regions == null) throw new ArgumentNullException("regions", "regions cannot be null.");
|
||
|
|
this.pages = pages;
|
||
|
|
this.regions = regions;
|
||
|
|
this.textureLoader = null;
|
||
|
|
}
|
||
|
|
|
||
|
|
public Atlas (TextReader reader, string imagesDir, TextureLoader textureLoader) {
|
||
|
|
if (reader == null) throw new ArgumentNullException("reader", "reader cannot be null.");
|
||
|
|
if (imagesDir == null) throw new ArgumentNullException("imagesDir", "imagesDir cannot be null.");
|
||
|
|
if (textureLoader == null) throw new ArgumentNullException("textureLoader", "textureLoader cannot be null.");
|
||
|
|
this.textureLoader = textureLoader;
|
||
|
|
|
||
|
|
string[] entry = new string[5];
|
||
|
|
AtlasPage page = null;
|
||
|
|
AtlasRegion region = null;
|
||
|
|
|
||
|
|
Dictionary<string, Action> pageFields = new Dictionary<string, Action>(5);
|
||
|
|
pageFields.Add("size", () => {
|
||
|
|
page.width = int.Parse(entry[1], CultureInfo.InvariantCulture);
|
||
|
|
page.height = int.Parse(entry[2], CultureInfo.InvariantCulture);
|
||
|
|
});
|
||
|
|
pageFields.Add("format", () => {
|
||
|
|
page.format = (Format)Enum.Parse(typeof(Format), entry[1], false);
|
||
|
|
});
|
||
|
|
pageFields.Add("filter", () => {
|
||
|
|
page.minFilter = (TextureFilter)Enum.Parse(typeof(TextureFilter), entry[1], false);
|
||
|
|
page.magFilter = (TextureFilter)Enum.Parse(typeof(TextureFilter), entry[2], false);
|
||
|
|
});
|
||
|
|
pageFields.Add("repeat", () => {
|
||
|
|
if (entry[1].IndexOf('x') != -1) page.uWrap = TextureWrap.Repeat;
|
||
|
|
if (entry[1].IndexOf('y') != -1) page.vWrap = TextureWrap.Repeat;
|
||
|
|
});
|
||
|
|
pageFields.Add("pma", () => {
|
||
|
|
page.pma = entry[1] == "true";
|
||
|
|
});
|
||
|
|
|
||
|
|
Dictionary<string, Action> regionFields = new Dictionary<string, Action>(8);
|
||
|
|
regionFields.Add("xy", () => { // Deprecated, use bounds.
|
||
|
|
region.x = int.Parse(entry[1], CultureInfo.InvariantCulture);
|
||
|
|
region.y = int.Parse(entry[2], CultureInfo.InvariantCulture);
|
||
|
|
});
|
||
|
|
regionFields.Add("size", () => { // Deprecated, use bounds.
|
||
|
|
region.width = int.Parse(entry[1], CultureInfo.InvariantCulture);
|
||
|
|
region.height = int.Parse(entry[2], CultureInfo.InvariantCulture);
|
||
|
|
});
|
||
|
|
regionFields.Add("bounds", () => {
|
||
|
|
region.x = int.Parse(entry[1], CultureInfo.InvariantCulture);
|
||
|
|
region.y = int.Parse(entry[2], CultureInfo.InvariantCulture);
|
||
|
|
region.width = int.Parse(entry[3], CultureInfo.InvariantCulture);
|
||
|
|
region.height = int.Parse(entry[4], CultureInfo.InvariantCulture);
|
||
|
|
});
|
||
|
|
regionFields.Add("offset", () => { // Deprecated, use offsets.
|
||
|
|
region.offsetX = int.Parse(entry[1], CultureInfo.InvariantCulture);
|
||
|
|
region.offsetY = int.Parse(entry[2], CultureInfo.InvariantCulture);
|
||
|
|
});
|
||
|
|
regionFields.Add("orig", () => { // Deprecated, use offsets.
|
||
|
|
region.originalWidth = int.Parse(entry[1], CultureInfo.InvariantCulture);
|
||
|
|
region.originalHeight = int.Parse(entry[2], CultureInfo.InvariantCulture);
|
||
|
|
});
|
||
|
|
regionFields.Add("offsets", () => {
|
||
|
|
region.offsetX = int.Parse(entry[1], CultureInfo.InvariantCulture);
|
||
|
|
region.offsetY = int.Parse(entry[2], CultureInfo.InvariantCulture);
|
||
|
|
region.originalWidth = int.Parse(entry[3], CultureInfo.InvariantCulture);
|
||
|
|
region.originalHeight = int.Parse(entry[4], CultureInfo.InvariantCulture);
|
||
|
|
});
|
||
|
|
regionFields.Add("rotate", () => {
|
||
|
|
string value = entry[1];
|
||
|
|
if (value == "true")
|
||
|
|
region.degrees = 90;
|
||
|
|
else if (value != "false")
|
||
|
|
region.degrees = int.Parse(value, CultureInfo.InvariantCulture);
|
||
|
|
});
|
||
|
|
regionFields.Add("index", () => {
|
||
|
|
region.index = int.Parse(entry[1], CultureInfo.InvariantCulture);
|
||
|
|
});
|
||
|
|
|
||
|
|
string line = reader.ReadLine();
|
||
|
|
// Ignore empty lines before first entry.
|
||
|
|
while (line != null && line.Trim().Length == 0)
|
||
|
|
line = reader.ReadLine();
|
||
|
|
// Header entries.
|
||
|
|
while (true) {
|
||
|
|
if (line == null || line.Trim().Length == 0) break;
|
||
|
|
if (ReadEntry(entry, line) == 0) break; // Silently ignore all header fields.
|
||
|
|
line = reader.ReadLine();
|
||
|
|
}
|
||
|
|
// Page and region entries.
|
||
|
|
List<string> names = null;
|
||
|
|
List<int[]> values = null;
|
||
|
|
while (true) {
|
||
|
|
if (line == null) break;
|
||
|
|
if (line.Trim().Length == 0) {
|
||
|
|
page = null;
|
||
|
|
line = reader.ReadLine();
|
||
|
|
} else if (page == null) {
|
||
|
|
page = new AtlasPage();
|
||
|
|
page.name = line.Trim();
|
||
|
|
while (true) {
|
||
|
|
if (ReadEntry(entry, line = reader.ReadLine()) == 0) break;
|
||
|
|
Action field;
|
||
|
|
if (pageFields.TryGetValue(entry[0], out field)) field(); // Silently ignore unknown page fields.
|
||
|
|
}
|
||
|
|
textureLoader.Load(page, Path.Combine(imagesDir, page.name));
|
||
|
|
pages.Add(page);
|
||
|
|
} else {
|
||
|
|
region = new AtlasRegion();
|
||
|
|
region.page = page;
|
||
|
|
region.name = line;
|
||
|
|
while (true) {
|
||
|
|
int count = ReadEntry(entry, line = reader.ReadLine());
|
||
|
|
if (count == 0) break;
|
||
|
|
Action field;
|
||
|
|
if (regionFields.TryGetValue(entry[0], out field))
|
||
|
|
field();
|
||
|
|
else {
|
||
|
|
if (names == null) {
|
||
|
|
names = new List<string>(8);
|
||
|
|
values = new List<int[]>(8);
|
||
|
|
}
|
||
|
|
names.Add(entry[0]);
|
||
|
|
int[] entryValues = new int[count];
|
||
|
|
for (int i = 0; i < count; i++)
|
||
|
|
int.TryParse(entry[i + 1], NumberStyles.Any, CultureInfo.InvariantCulture, out entryValues[i]); // Silently ignore non-integer values.
|
||
|
|
values.Add(entryValues);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (region.originalWidth == 0 && region.originalHeight == 0) {
|
||
|
|
region.originalWidth = region.width;
|
||
|
|
region.originalHeight = region.height;
|
||
|
|
}
|
||
|
|
if (names != null && names.Count > 0) {
|
||
|
|
region.names = names.ToArray();
|
||
|
|
region.values = values.ToArray();
|
||
|
|
names.Clear();
|
||
|
|
values.Clear();
|
||
|
|
}
|
||
|
|
region.u = region.x / (float)page.width;
|
||
|
|
region.v = region.y / (float)page.height;
|
||
|
|
if (region.degrees == 90) {
|
||
|
|
region.u2 = (region.x + region.height) / (float)page.width;
|
||
|
|
region.v2 = (region.y + region.width) / (float)page.height;
|
||
|
|
|
||
|
|
int tempSwap = region.packedWidth;
|
||
|
|
region.packedWidth = region.packedHeight;
|
||
|
|
region.packedHeight = tempSwap;
|
||
|
|
} else {
|
||
|
|
region.u2 = (region.x + region.width) / (float)page.width;
|
||
|
|
region.v2 = (region.y + region.height) / (float)page.height;
|
||
|
|
}
|
||
|
|
regions.Add(region);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static private int ReadEntry (string[] entry, string line) {
|
||
|
|
if (line == null) return 0;
|
||
|
|
line = line.Trim();
|
||
|
|
if (line.Length == 0) return 0;
|
||
|
|
int colon = line.IndexOf(':');
|
||
|
|
if (colon == -1) return 0;
|
||
|
|
entry[0] = line.Substring(0, colon).Trim();
|
||
|
|
for (int i = 1, lastMatch = colon + 1; ; i++) {
|
||
|
|
int comma = line.IndexOf(',', lastMatch);
|
||
|
|
if (comma == -1) {
|
||
|
|
entry[i] = line.Substring(lastMatch).Trim();
|
||
|
|
return i;
|
||
|
|
}
|
||
|
|
entry[i] = line.Substring(lastMatch, comma - lastMatch).Trim();
|
||
|
|
lastMatch = comma + 1;
|
||
|
|
if (i == 4) return 4;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public void FlipV () {
|
||
|
|
for (int i = 0, n = regions.Count; i < n; i++) {
|
||
|
|
AtlasRegion region = regions[i];
|
||
|
|
region.v = 1 - region.v;
|
||
|
|
region.v2 = 1 - region.v2;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>Returns the first region found with the specified name. This method uses string comparison to find the region, so the result
|
||
|
|
/// should be cached rather than calling this method multiple times.</summary>
|
||
|
|
/// <returns>The region, or null.</returns>
|
||
|
|
public AtlasRegion FindRegion (string name) {
|
||
|
|
for (int i = 0, n = regions.Count; i < n; i++)
|
||
|
|
if (regions[i].name == name) return regions[i];
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
public void Dispose () {
|
||
|
|
if (textureLoader == null) return;
|
||
|
|
for (int i = 0, n = pages.Count; i < n; i++)
|
||
|
|
textureLoader.Unload(pages[i].rendererObject);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public enum Format {
|
||
|
|
Alpha,
|
||
|
|
Intensity,
|
||
|
|
LuminanceAlpha,
|
||
|
|
RGB565,
|
||
|
|
RGBA4444,
|
||
|
|
RGB888,
|
||
|
|
RGBA8888
|
||
|
|
}
|
||
|
|
|
||
|
|
public enum TextureFilter {
|
||
|
|
Nearest,
|
||
|
|
Linear,
|
||
|
|
MipMap,
|
||
|
|
MipMapNearestNearest,
|
||
|
|
MipMapLinearNearest,
|
||
|
|
MipMapNearestLinear,
|
||
|
|
MipMapLinearLinear
|
||
|
|
}
|
||
|
|
|
||
|
|
public enum TextureWrap {
|
||
|
|
MirroredRepeat,
|
||
|
|
ClampToEdge,
|
||
|
|
Repeat
|
||
|
|
}
|
||
|
|
|
||
|
|
public class AtlasPage {
|
||
|
|
public string name;
|
||
|
|
public int width, height;
|
||
|
|
public Format format = Format.RGBA8888;
|
||
|
|
public TextureFilter minFilter = TextureFilter.Nearest;
|
||
|
|
public TextureFilter magFilter = TextureFilter.Nearest;
|
||
|
|
public TextureWrap uWrap = TextureWrap.ClampToEdge;
|
||
|
|
public TextureWrap vWrap = TextureWrap.ClampToEdge;
|
||
|
|
public bool pma;
|
||
|
|
public object rendererObject;
|
||
|
|
|
||
|
|
public AtlasPage Clone () {
|
||
|
|
return MemberwiseClone() as AtlasPage;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public class AtlasRegion : TextureRegion {
|
||
|
|
public AtlasPage page;
|
||
|
|
public string name;
|
||
|
|
public int x, y;
|
||
|
|
public float offsetX, offsetY;
|
||
|
|
public int originalWidth, originalHeight;
|
||
|
|
public int packedWidth { get { return width; } set { width = value; } }
|
||
|
|
public int packedHeight { get { return height; } set { height = value; } }
|
||
|
|
public int degrees;
|
||
|
|
public bool rotate;
|
||
|
|
public int index;
|
||
|
|
public string[] names;
|
||
|
|
public int[][] values;
|
||
|
|
|
||
|
|
override public int OriginalWidth { get { return originalWidth; } }
|
||
|
|
override public int OriginalHeight { get { return originalHeight; } }
|
||
|
|
|
||
|
|
public AtlasRegion Clone () {
|
||
|
|
return MemberwiseClone() as AtlasRegion;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public interface TextureLoader {
|
||
|
|
void Load (AtlasPage page, string path);
|
||
|
|
void Unload (Object texture);
|
||
|
|
}
|
||
|
|
}
|