Merge pull request #390 from Fenrisul/master

Temporary patchjob for SkeletonUtility Submeshes

spine-unity/Assets/spine-unity/Editor/SkeletonRendererInspector.cs

@@ -34,8 +34,9 @@ using UnityEngine;
 
 [CustomEditor(typeof(SkeletonRenderer))]
 public class SkeletonRendererInspector : Editor {
+	protected static bool advancedFoldout;
+
 	protected SerializedProperty skeletonDataAsset, initialSkinName, normals, tangents, meshes, immutableTriangles, submeshSeparators, front;
-	protected bool advancedFoldout;
 
 	private static MethodInfo EditorGUILayoutSortingLayerField;
 	protected SerializedObject rendererSerializedObject;
@@ -61,7 +62,6 @@ public class SkeletonRendererInspector : Editor {
 
 	protected virtual void gui () {
 		SkeletonRenderer component = (SkeletonRenderer)target;
-
 		EditorGUILayout.BeginHorizontal();
 		EditorGUILayout.PropertyField(skeletonDataAsset);
 		float reloadWidth = GUI.skin.label.CalcSize(new GUIContent("Reload")).x + 20;

spine-unity/Assets/spine-unity/SkeletonRenderer.cs

@@ -71,7 +71,7 @@ public class SkeletonRenderer : MonoBehaviour {
 	private Material[] sharedMaterials = new Material[0];
 	private readonly List<Material> submeshMaterials = new List<Material>();
 	private readonly List<Submesh> submeshes = new List<Submesh>();
-
+	private SkeletonUtilitySubmeshRenderer[] submeshRenderers;
 
 	public virtual void Reset () {
 		if (meshFilter != null)
@@ -130,10 +130,18 @@ public class SkeletonRenderer : MonoBehaviour {
 			submeshSeparatorSlots.Add(skeleton.FindSlot(submeshSeparators[i]));
 		}
 
+		CollectSubmeshRenderers();
+
+		LateUpdate();
+
 		if (OnReset != null)
 			OnReset(this);
 	}
 
+	public void CollectSubmeshRenderers () {
+		submeshRenderers = GetComponentsInChildren<SkeletonUtilitySubmeshRenderer>();
+	}
+
 	public virtual void Awake () {
 		Reset();
 	}
@@ -370,11 +378,21 @@ public class SkeletonRenderer : MonoBehaviour {
 			}
 		}
 
+		if (submeshRenderers.Length > 0) {
+			foreach (var smr in submeshRenderers) {
+				if (smr.submeshIndex < sharedMaterials.Length)
+					smr.SetMesh(this.renderer, useMesh1 ? mesh1 : mesh2, sharedMaterials[smr.submeshIndex]);
+				else
+					smr.GetComponent<Renderer>().enabled = false;
+			}
+		}
+
 		useMesh1 = !useMesh1;
 	}
 
 	/** Stores vertices and triangles for a single material. */
 	private void AddSubmesh (Material material, int startSlot, int endSlot, int triangleCount, int firstVertex, bool lastSubmesh) {
+		
 		int submeshIndex = submeshMaterials.Count;
 		submeshMaterials.Add(material);
 

spine-unity/Assets/spine-unity/SkeletonUtility/Editor/SkeletonUtilitySubmeshRendererInspector.cs

@@ -0,0 +1,48 @@
+using UnityEngine;
+using UnityEditor;
+using System;
+using System.Collections;
+using System.Reflection;
+
+[CustomEditor(typeof(SkeletonUtilitySubmeshRenderer))]
+public class SkeletonUtilitySubmeshRendererInspector : Editor {
+
+	private static MethodInfo EditorGUILayoutSortingLayerField;
+	protected SerializedObject rendererSerializedObject;
+	protected SerializedProperty sortingLayerIDProperty;
+
+	SkeletonUtilitySubmeshRenderer component;
+
+	void OnEnable () {
+		component = (SkeletonUtilitySubmeshRenderer)target;
+
+		if (EditorGUILayoutSortingLayerField == null)
+			EditorGUILayoutSortingLayerField = typeof(EditorGUILayout).GetMethod("SortingLayerField", BindingFlags.Static | BindingFlags.NonPublic, null, new Type[] { typeof(GUIContent), typeof(SerializedProperty), typeof(GUIStyle) }, null);
+
+		rendererSerializedObject = new SerializedObject(((SkeletonUtilitySubmeshRenderer)target).GetComponent<Renderer>());
+		sortingLayerIDProperty = rendererSerializedObject.FindProperty("m_SortingLayerID");
+	}
+
+	public override void OnInspectorGUI () {
+		// Sorting Layers
+		{
+			var renderer = component.GetComponent<Renderer>();
+			if (renderer != null) {
+				EditorGUI.BeginChangeCheck();
+
+				if (EditorGUILayoutSortingLayerField != null && sortingLayerIDProperty != null) {
+					EditorGUILayoutSortingLayerField.Invoke(null, new object[] { new GUIContent("Sorting Layer"), sortingLayerIDProperty, EditorStyles.popup });
+				} else {
+					renderer.sortingLayerID = EditorGUILayout.IntField("Sorting Layer ID", renderer.sortingLayerID);
+				}
+
+				renderer.sortingOrder = EditorGUILayout.IntField("Order in Layer", renderer.sortingOrder);
+
+				if (EditorGUI.EndChangeCheck()) {
+					rendererSerializedObject.ApplyModifiedProperties();
+					EditorUtility.SetDirty(renderer);
+				}
+			}
+		}
+	}
+}

spine-unity/Assets/spine-unity/SkeletonUtility/Editor/SkeletonUtilitySubmeshRendererInspector.cs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 67418e462bd4dc24e8c234b92f1d4d9b
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

spine-unity/Assets/spine-unity/SkeletonUtility/SkeletonUtility.cs

@@ -380,12 +380,12 @@ public class SkeletonUtility : MonoBehaviour {
 			go.transform.localScale = Vector3.one;
 
 			SkeletonUtilitySubmeshRenderer s = go.AddComponent<SkeletonUtilitySubmeshRenderer>();
-			s.sortingOrder = i * 10;
+			s.GetComponent<Renderer>().sortingOrder = i * 10;
 			s.submeshIndex = i;
-			s.Initialize(GetComponent<Renderer>());
-			s.Update();
 		}
 
+		skeletonRenderer.CollectSubmeshRenderers();
+
 		if (disablePrimaryRenderer)
 			GetComponent<Renderer>().enabled = false;
 	}

spine-unity/Assets/spine-unity/SkeletonUtility/SkeletonUtilitySubmeshRenderer.cs

@@ -3,94 +3,37 @@ using System.Collections;
 
 [ExecuteInEditMode]
 public class SkeletonUtilitySubmeshRenderer : MonoBehaviour {
-	public Renderer parentRenderer;
 	[System.NonSerialized]
 	public Mesh mesh;
 	public int submeshIndex = 0;
-	public int sortingOrder = 0;
-	public int sortingLayerID = 0;
 	public Material hiddenPassMaterial;
 	Renderer cachedRenderer;
 	MeshFilter filter;
 	Material[] sharedMaterials;
-	MeshFilter parentFilter;
 
 	void Awake () {
 		cachedRenderer = GetComponent<Renderer>();
-		sharedMaterials = cachedRenderer.sharedMaterials;
 		filter = GetComponent<MeshFilter>();
-
+		sharedMaterials = new Material[0];
-		if (parentRenderer != null)
-			Initialize(parentRenderer);
 	}
 
-	void OnEnable () {
+	public void SetMesh (Renderer parentRenderer, Mesh mesh, Material mat) {
-		parentRenderer = transform.parent.GetComponent<Renderer>();
-		parentRenderer.GetComponent<SkeletonRenderer>().OnReset += HandleSkeletonReset;
-	}
-
-	void OnDisable () {
-		parentRenderer.GetComponent<SkeletonRenderer>().OnReset -= HandleSkeletonReset;
-	}
-
-	void HandleSkeletonReset (SkeletonRenderer r) {
-		if (parentRenderer != null)
-			Initialize(parentRenderer);
-	}
-
-	public void Initialize (Renderer parentRenderer) {
-		this.parentRenderer = parentRenderer;
-		parentFilter = parentRenderer.GetComponent<MeshFilter>();
-		mesh = parentFilter.sharedMesh;
-		filter.sharedMesh = mesh;
-		Debug.Log("Mesh: " + mesh);
-	}
-
-	public void Update () {
-		if (mesh == null || mesh != parentFilter.sharedMesh) {
-			mesh = parentFilter.sharedMesh;
-			filter.sharedMesh = mesh;
-		}
-
 		if (cachedRenderer == null)
-			cachedRenderer = GetComponent<Renderer>();
-
-		if (mesh == null || submeshIndex > mesh.subMeshCount - 1) {
-			cachedRenderer.enabled = false;
 			return;
-		} else {
-			GetComponent<Renderer>().enabled = true;
-		}
 
-		bool changed = false;
+		cachedRenderer.enabled = true;
-
+		filter.sharedMesh = mesh;
-		if (sharedMaterials.Length != parentRenderer.sharedMaterials.Length) {
+		if (cachedRenderer.sharedMaterials.Length != parentRenderer.sharedMaterials.Length) {
 			sharedMaterials = parentRenderer.sharedMaterials;
-			changed = true;
 		}
 
-
+		for (int i = 0; i < sharedMaterials.Length; i++) {
-
-		for (int i = 0; i < GetComponent<Renderer>().sharedMaterials.Length; i++) {
 			if (i == submeshIndex)
-				continue;
+				sharedMaterials[i] = mat;
-
+			else
-			if (sharedMaterials[i] != hiddenPassMaterial) {
 				sharedMaterials[i] = hiddenPassMaterial;
-				changed = true;
-			}
 		}
 
-		if (sharedMaterials[submeshIndex] != parentRenderer.sharedMaterials[submeshIndex]) {
+		cachedRenderer.sharedMaterials = sharedMaterials;
-			sharedMaterials[submeshIndex] = parentRenderer.sharedMaterials[submeshIndex];
-			changed = true;
-		}
-
-		if (changed) {
-			cachedRenderer.sharedMaterials = sharedMaterials;
-		}
-
-		cachedRenderer.sortingLayerID = sortingLayerID;
-		cachedRenderer.sortingOrder = sortingOrder;
 	}
 }