Initial commit: Client Doc docs Server Tools

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-07-10 10:24:29 +08:00
commit 7e35d8da31
3374 changed files with 680813 additions and 0 deletions
@@ -0,0 +1,236 @@
+/******************************************************************************
+ * Spine Runtimes License Agreement
+ * Last updated April 5, 2025. Replaces all prior versions.
+ *
+ * Copyright (c) 2013-2026, 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;
+
+namespace Spine {
+#if IS_UNITY
+	using Color32F = UnityEngine.Color;
+#endif
+
+	/// <summary>Attachment that displays a texture region using a mesh.</summary>
+	public class MeshAttachment : VertexAttachment, IHasSequence {
+		internal readonly Sequence sequence;
+		internal float[] regionUVs;
+		internal int[] triangles;
+		internal int hullLength;
+		internal string path;
+		// Color is a struct, set to protected to prevent
+		// Color color = slot.color; color.a = 0.5;
+		// modifying just a copy of the struct instead of the original
+		// object as in reference implementation.
+		protected Color32F color = new Color32F(1, 1, 1, 1);
+		private MeshAttachment sourceMesh;
+
+		public int HullLength { get { return hullLength; } set { hullLength = value; } }
+
+		/// <summary>The UV pair for each vertex, normalized within the texture region.</summary>
+		public float[] RegionUVs { get { return regionUVs; } set { regionUVs = value; } }
+		/// <summary>Triplets of vertex indices which describe the mesh's triangulation.</summary>
+		public int[] Triangles { get { return triangles; } set { triangles = value; } }
+
+		public Color32F GetColor () {
+			return color;
+		}
+
+		public void SetColor (Color32F color) {
+			this.color = color;
+		}
+
+		public void SetColor (float r, float g, float b, float a) {
+			color = new Color32F(r, g, b, a);
+		}
+
+		public string Path { get { return path; } set { path = value; } }
+		public Sequence Sequence { get { return sequence; } }
+
+		/// <summary>
+		/// The source mesh if this is a linked mesh, else null. A linked mesh shares the
+		/// <see cref="VertexAttachment.Bones">Bones</see>, <see cref="VertexAttachment.Vertices">Vertices</see>,
+		/// <see cref="RegionUVs"/>, <see cref="Triangles"/>, <see cref="HullLength"/>, <see cref="Edges"/>,
+		/// <see cref="Width"/>, <see cref="Height"/> with the
+		/// source mesh, but may have a different <see cref="name"/> or <see cref="path"/>, and therefore a different texture region.
+		/// </summary>
+		public MeshAttachment SourceMesh {
+			get { return sourceMesh; }
+			set {
+				sourceMesh = value;
+				if (value != null) {
+					bones = value.bones;
+					vertices = value.vertices;
+					worldVerticesLength = value.worldVerticesLength;
+					regionUVs = value.regionUVs;
+					triangles = value.triangles;
+					HullLength = value.HullLength;
+					Edges = value.Edges;
+					Width = value.Width;
+					Height = value.Height;
+				}
+			}
+		}
+
+		// Nonessential.
+		/// <summary>
+		/// Vertex index pairs describing edges for controlling triangulation, or null if nonessential data was not exported. Mesh
+		/// triangles do not cross edges. Triangulation is not performed at runtime.
+		/// </summary>
+		public int[] Edges { get; set; }
+		public float Width { get; set; }
+		public float Height { get; set; }
+
+		public MeshAttachment (string name, Sequence sequence)
+			: base(name) {
+			if (sequence == null) throw new ArgumentException("sequence cannot be null.", "sequence");
+			this.sequence = sequence;
+		}
+
+		/// <summary>Copy constructor. Use <see cref="NewLinkedMesh"/> if the other mesh is a linked mesh.</summary>
+		protected MeshAttachment (MeshAttachment other)
+			: base(other) {
+
+			if (sourceMesh != null) throw new ArgumentException("Use newLinkedMesh to copy a linked mesh.");
+
+			path = other.path;
+			color = other.color;
+
+			regionUVs = new float[other.regionUVs.Length];
+			Array.Copy(other.regionUVs, 0, regionUVs, 0, regionUVs.Length);
+
+			triangles = new int[other.triangles.Length];
+			Array.Copy(other.triangles, 0, triangles, 0, triangles.Length);
+
+			hullLength = other.hullLength;
+			sequence = new Sequence(other.sequence);
+
+			// Nonessential.
+			if (other.Edges != null) {
+				Edges = new int[other.Edges.Length];
+				Array.Copy(other.Edges, 0, Edges, 0, Edges.Length);
+			}
+			Width = other.Width;
+			Height = other.Height;
+		}
+
+		public void UpdateSequence () {
+			sequence.Update(this);
+		}
+
+		/// <summary>
+		/// Returns a new mesh with the <see cref="SourceMesh"/> set to this mesh's source mesh, if any, else to this mesh.
+		/// </summary>
+		public MeshAttachment NewLinkedMesh () {
+			var mesh = new MeshAttachment(Name, new Sequence(sequence));
+
+			mesh.timelineAttachment = timelineAttachment;
+			mesh.path = path;
+			mesh.color = color;
+			mesh.SourceMesh = sourceMesh != null ? sourceMesh : this;
+			mesh.UpdateSequence();
+			return mesh;
+		}
+
+		public override Attachment Copy () {
+			return sourceMesh != null ? NewLinkedMesh() : new MeshAttachment(this);
+		}
+
+		/// <summary>
+		/// Computes <see cref="Sequence.GetUVs(int)">UVs</see> for a mesh attachment.
+		/// </summary>
+		/// <param name="uvs">Output array for the computed UVs, same length as regionUVs.</param>
+		internal static void ComputeUVs (TextureRegion region, float[] regionUVs, float[] uvs) {
+			int n = uvs.Length;
+			float u, v, width, height;
+			AtlasRegion r = region as AtlasRegion;
+			if (r != null) {
+				u = r.u;
+				v = r.v;
+				float textureWidth = region.width / (region.u2 - region.u);
+				float textureHeight = region.height / (region.v2 - region.v);
+				switch (r.degrees) {
+				case 90: {
+					u -= (r.originalHeight - r.offsetY - r.packedWidth) / textureWidth;
+					v -= (r.originalWidth - r.offsetX - r.packedHeight) / textureHeight;
+					width = r.originalHeight / textureWidth;
+					height = r.originalWidth / textureHeight;
+					for (int i = 0; i < n; i += 2) {
+						uvs[i] = u + regionUVs[i + 1] * width;
+						uvs[i + 1] = v + (1 - regionUVs[i]) * height;
+					}
+					return;
+				}
+				case 180: {
+					u -= (r.originalWidth - r.offsetX - r.packedWidth) / textureWidth;
+					v -= r.offsetY / textureHeight;
+					width = r.originalWidth / textureWidth;
+					height = r.originalHeight / textureHeight;
+					for (int i = 0; i < n; i += 2) {
+						uvs[i] = u + (1 - regionUVs[i]) * width;
+						uvs[i + 1] = v + (1 - regionUVs[i + 1]) * height;
+					}
+					return;
+				}
+				case 270: {
+					u -= r.offsetY / textureWidth;
+					v -= r.offsetX / textureHeight;
+					width = r.originalHeight / textureWidth;
+					height = r.originalWidth / textureHeight;
+					for (int i = 0; i < n; i += 2) {
+						uvs[i] = u + (1 - regionUVs[i + 1]) * width;
+						uvs[i + 1] = v + regionUVs[i] * height;
+					}
+					return;
+				}
+				default: {
+					u -= r.offsetX / textureWidth;
+					v -= (r.originalHeight - r.offsetY - r.packedHeight) / textureHeight;
+					width = r.originalWidth / textureWidth;
+					height = r.originalHeight / textureHeight;
+					break;
+				}
+				}
+			} else if (region == null) {
+				u = v = 0;
+				width = height = 1;
+			} else {
+				u = region.u;
+				v = region.v;
+				width = region.u2 - u;
+				height = region.v2 - v;
+			}
+			for (int i = 0; i < n; i += 2) {
+				uvs[i] = u + regionUVs[i] * width;
+				uvs[i + 1] = v + regionUVs[i + 1] * height;
+			}
+		}
+	}
+}