public void SetSpriteMesh(SpriteMesh _spriteMesh, SpriteMeshInstance _spriteMeshInstance)
{
spriteMesh = _spriteMesh;
spriteMeshInstance = _spriteMeshInstance;
spriteMeshData = SpriteMeshUtils.LoadSpriteMeshData(_spriteMesh);
RevertChanges();
}
public static SpriteMeshInstance CreateSpriteMeshInstance(SpriteMesh spriteMesh, GameObject gameObject,
bool undo = true)
{
SpriteMeshInstance spriteMeshInstance = null;
if (spriteMesh && gameObject)
{
if (undo)
{
spriteMeshInstance = Undo.AddComponent <SpriteMeshInstance>(gameObject);
}
else
{
spriteMeshInstance = gameObject.AddComponent <SpriteMeshInstance>();
}
spriteMeshInstance.spriteMesh = spriteMesh;
spriteMeshInstance.sharedMaterial = defaultMaterial;
SpriteMeshData spriteMeshData = SpriteMeshUtils.LoadSpriteMeshData(spriteMesh);
List <Bone2D> bones = new List <Bone2D>();
List <string> paths = new List <string>();
Vector4 zero = new Vector4(0f, 0f, 0f, 1f);
foreach (BindInfo bindInfo in spriteMeshData.bindPoses)
{
Matrix4x4 m = spriteMeshInstance.transform.localToWorldMatrix * bindInfo.bindPose.inverse;
GameObject bone = new GameObject(bindInfo.name);
if (undo)
{
Undo.RegisterCreatedObjectUndo(bone, Undo.GetCurrentGroupName());
}
Bone2D boneComponent = bone.AddComponent <Bone2D>();
boneComponent.localLength = bindInfo.boneLength;
bone.transform.position = m * zero;
bone.transform.rotation = m.GetRotation();
bone.transform.parent = gameObject.transform;
bones.Add(boneComponent);
paths.Add(bindInfo.path);
}
BoneUtils.ReconstructHierarchy(bones, paths);
spriteMeshInstance.bones = bones;
SpriteMeshUtils.UpdateRenderer(spriteMeshInstance, undo);
EditorUtility.SetDirty(spriteMeshInstance);
}
return(spriteMeshInstance);
}
void UpdateSpriteMeshData()
{
m_SpriteMeshData = null;
if (m_SpriteMeshProperty != null && m_SpriteMeshProperty.objectReferenceValue)
{
m_SpriteMeshData = SpriteMeshUtils.LoadSpriteMeshData(m_SpriteMeshProperty.objectReferenceValue as SpriteMesh);
}
}
static int FindBindInfo(BindInfo bindInfo, SpriteMeshInstance spriteMeshInstance)
{
if (spriteMeshInstance)
{
return(FindBindInfo(bindInfo, SpriteMeshUtils.LoadSpriteMeshData(spriteMeshInstance.spriteMesh)));
}
return(-1);
}
void OnPreprocessTexture()
{
if (!s_Initialized)
{
return;
}
string guid = AssetDatabase.AssetPathToGUID(assetPath);
if (s_SpriteMeshToTextureCache.ContainsValue(guid))
{
TextureImporter textureImporter = (TextureImporter)assetImporter;
SerializedObject textureImporterSO = new SerializedObject(textureImporter);
SerializedProperty textureImporterSprites = textureImporterSO.FindProperty("m_SpriteSheet.m_Sprites");
foreach (KeyValuePair <string, string> pair in s_SpriteMeshToTextureCache)
{
if (pair.Value == guid)
{
SpriteMesh spriteMesh = LoadSpriteMesh(AssetDatabase.GUIDToAssetPath(pair.Key));
SpriteMeshData spriteMeshData = SpriteMeshUtils.LoadSpriteMeshData(spriteMesh);
if (spriteMesh && spriteMeshData && spriteMesh.sprite && spriteMeshData.vertices.Length > 0)
{
SerializedProperty spriteProp = null;
int i = 0;
string name = "";
while (i < textureImporterSprites.arraySize && name != spriteMesh.sprite.name)
{
spriteProp = textureImporterSprites.GetArrayElementAtIndex(i);
name = spriteProp.FindPropertyRelative("m_Name").stringValue;
++i;
}
if (name == spriteMesh.sprite.name)
{
Rect textureRect = SpriteMeshUtils.CalculateSpriteRect(spriteMesh, 5);
spriteProp.FindPropertyRelative("m_Rect").rectValue = textureRect;
spriteProp.FindPropertyRelative("m_Alignment").intValue = 9;
spriteProp.FindPropertyRelative("m_Pivot").vector2Value = Vector2.Scale(spriteMeshData.pivotPoint - textureRect.position, new Vector2(1f / textureRect.size.x, 1f / textureRect.size.y));
textureImporter.userData = textureImporter.assetTimeStamp.ToString();
}
}
}
}
textureImporterSO.ApplyModifiedProperties();
}
}
static void Upgrade_003(SerializedObject spriteMeshSO)
{
SpriteMesh spriteMesh = spriteMeshSO.targetObject as SpriteMesh;
SpriteMeshData spriteMeshData = SpriteMeshUtils.LoadSpriteMeshData(spriteMesh);
if (spriteMesh.sprite && spriteMeshData)
{
TextureImporter textureImporter =
AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(spriteMesh.sprite)) as TextureImporter;
float maxImporterSize = textureImporter.maxTextureSize;
int width = 1;
int height = 1;
SpriteMeshUtils.GetWidthAndHeight(textureImporter, ref width, ref height);
int maxSize = Mathf.Max(width, height);
float factor = maxSize / maxImporterSize;
if (factor > 1f)
{
SerializedObject spriteMeshDataSO = new SerializedObject(spriteMeshData);
SerializedProperty smdPivotPointProp = spriteMeshDataSO.FindProperty("m_PivotPoint");
SerializedProperty smdVerticesProp = spriteMeshDataSO.FindProperty("m_Vertices");
SerializedProperty smdHolesProp = spriteMeshDataSO.FindProperty("m_Holes");
spriteMeshDataSO.Update();
smdPivotPointProp.vector2Value = spriteMeshData.pivotPoint * factor;
for (int i = 0; i < spriteMeshData.vertices.Length; ++i)
{
smdVerticesProp.GetArrayElementAtIndex(i).vector2Value = spriteMeshData.vertices[i] * factor;
}
for (int i = 0; i < spriteMeshData.holes.Length; ++i)
{
smdHolesProp.GetArrayElementAtIndex(i).vector2Value = spriteMeshData.holes[i] * factor;
}
spriteMeshDataSO.ApplyModifiedProperties();
EditorUtility.SetDirty(spriteMeshData);
}
}
}
static void DoSpriteOverride(SpriteMesh spriteMesh, Sprite sprite)
{
SpriteMeshData spriteMeshData = SpriteMeshUtils.LoadSpriteMeshData(spriteMesh);
if (spriteMeshData)
{
Rect rect = SpriteMeshUtils.CalculateSpriteRect(spriteMesh, 5);
Rect spriteRect = sprite.rect;
Vector2 factor = new Vector2(spriteRect.width / rect.width, spriteRect.height / rect.height);
Vector2[] newVertices = new List <Vector2>(spriteMeshData.vertices).ConvertAll(v => MathUtils.ClampPositionInRect(Vector2.Scale(v, factor), spriteRect) - spriteRect.position).ToArray();
ushort[] newIndices = new List <int>(spriteMeshData.indices).ConvertAll <ushort>(i => (ushort)i).ToArray();
sprite.OverrideGeometry(newVertices, newIndices);
}
}
void DoSpriteOverride(SpriteMesh spriteMesh, Sprite sprite)
{
TextureImporter textureImporter = (TextureImporter)assetImporter;
#if UNITY_5_1 || UNITY_5_2 || UNITY_5_3_OR_NEWER
Debug.Assert(textureImporter.spriteImportMode == SpriteImportMode.Single ||
textureImporter.spriteImportMode == SpriteImportMode.Multiple,
"Incompatible Sprite Mode. Use Single or Multiple.");
#endif
SpriteMeshData spriteMeshData = SpriteMeshUtils.LoadSpriteMeshData(spriteMesh);
if (spriteMeshData)
{
Vector2 factor = Vector2.one;
Rect spriteRect = sprite.rect;
Rect rectTextureSpace = new Rect();
if (textureImporter.spriteImportMode == SpriteImportMode.Single)
{
int width = 0;
int height = 0;
SpriteMeshUtils.GetSpriteTextureSize(spriteMesh.sprite, ref width, ref height);
rectTextureSpace = new Rect(0, 0, width, height);
}
else if (textureImporter.spriteImportMode == SpriteImportMode.Multiple)
{
rectTextureSpace = SpriteMeshUtils.CalculateSpriteRect(spriteMesh, 5);
}
factor = new Vector2(spriteRect.width / rectTextureSpace.width,
spriteRect.height / rectTextureSpace.height);
Vector2[] newVertices = new List <Vector2>(spriteMeshData.vertices).ConvertAll(v =>
MathUtils.ClampPositionInRect(Vector2.Scale(v, factor), spriteRect) - spriteRect.position)
.ToArray();
ushort[] newIndices =
new List <int>(spriteMeshData.indices).ConvertAll <ushort>(i => (ushort)i).ToArray();
sprite.OverrideGeometry(newVertices, newIndices);
}
}
static bool Bindeable(SpriteMeshInstance targetSpriteMeshInstance,
SpriteMeshInstance destinationSpriteMeshInstance)
{
bool bindeable = false;
if (targetSpriteMeshInstance &&
destinationSpriteMeshInstance &&
targetSpriteMeshInstance.spriteMesh &&
destinationSpriteMeshInstance.spriteMesh &&
targetSpriteMeshInstance.spriteMesh != destinationSpriteMeshInstance.spriteMesh &&
destinationSpriteMeshInstance.cachedSkinnedRenderer)
{
SpriteMeshData targetData = SpriteMeshUtils.LoadSpriteMeshData(targetSpriteMeshInstance.spriteMesh);
SpriteMeshData destinationData =
SpriteMeshUtils.LoadSpriteMeshData(destinationSpriteMeshInstance.spriteMesh);
bindeable = true;
if (destinationData.bindPoses.Length >= targetData.bindPoses.Length)
{
for (int i = 0; i < targetData.bindPoses.Length; ++i)
{
if (bindeable)
{
BindInfo bindInfo = targetData.bindPoses[i];
if (FindBindInfo(bindInfo, destinationData) < 0)
{
bindeable = false;
}
}
}
}
else
{
bindeable = false;
}
}
return(bindeable);
}
public static void UpdateAssets(SpriteMesh spriteMesh)
{
UpdateAssets(spriteMesh, SpriteMeshUtils.LoadSpriteMeshData(spriteMesh));
}
static void Upgrade_002(SerializedObject spriteMeshSO)
{
spriteMeshSO.Update();
SpriteMesh spriteMesh = spriteMeshSO.targetObject as SpriteMesh;
SerializedProperty sharedMeshProp = spriteMeshSO.FindProperty("m_SharedMesh");
SerializedProperty sharedMaterialsProp = spriteMeshSO.FindProperty("m_SharedMaterials");
SerializedProperty pivotPointProp = spriteMeshSO.FindProperty("pivotPoint");
SerializedProperty texVerticesProp = spriteMeshSO.FindProperty("texVertices");
SerializedProperty edgesProp = spriteMeshSO.FindProperty("edges");
SerializedProperty holesProp = spriteMeshSO.FindProperty("holes");
SerializedProperty indicesProp = spriteMeshSO.FindProperty("indices");
string path = AssetDatabase.GetAssetPath(spriteMeshSO.targetObject);
GameObject go = AssetDatabase.LoadAssetAtPath(path, typeof(GameObject)) as GameObject;
if (go)
{
Object.DestroyImmediate(go, true);
}
Material material = AssetDatabase.LoadAssetAtPath(path, typeof(Material)) as Material;
if (material)
{
sharedMaterialsProp.arraySize = 1;
sharedMaterialsProp.GetArrayElementAtIndex(0).objectReferenceValue = material;
material.hideFlags = HideFlags.HideInHierarchy;
EditorUtility.SetDirty(material);
}
Mesh mesh = AssetDatabase.LoadAssetAtPath(path, typeof(Mesh)) as Mesh;
if (mesh)
{
mesh.hideFlags = HideFlags.HideInHierarchy;
sharedMeshProp.objectReferenceValue = mesh;
EditorUtility.SetDirty(mesh);
}
spriteMeshSO.ApplyModifiedProperties();
SpriteMeshData spriteMeshData = SpriteMeshUtils.LoadSpriteMeshData(spriteMesh);
if (!spriteMeshData)
{
spriteMeshData = ScriptableObject.CreateInstance <SpriteMeshData>();
AssetDatabase.AddObjectToAsset(spriteMeshData, path);
}
if (spriteMeshData)
{
spriteMeshData.name = spriteMeshSO.targetObject.name + "_Data";
spriteMeshData.hideFlags = HideFlags.HideInHierarchy;
SerializedObject spriteMeshDataSO = new SerializedObject(spriteMeshData);
SerializedProperty smdPivotPointProp = spriteMeshDataSO.FindProperty("m_PivotPoint");
SerializedProperty smdVerticesProp = spriteMeshDataSO.FindProperty("m_Vertices");
SerializedProperty smdBoneWeightsProp = spriteMeshDataSO.FindProperty("m_BoneWeights");
SerializedProperty smdEdgesProp = spriteMeshDataSO.FindProperty("m_Edges");
SerializedProperty smdHolesProp = spriteMeshDataSO.FindProperty("m_Holes");
SerializedProperty smdIndicesProp = spriteMeshDataSO.FindProperty("m_Indices");
spriteMeshDataSO.Update();
smdPivotPointProp.vector2Value = pivotPointProp.vector2Value;
smdVerticesProp.arraySize = texVerticesProp.arraySize;
smdBoneWeightsProp.arraySize = texVerticesProp.arraySize;
for (int i = 0; i < smdVerticesProp.arraySize; ++i)
{
SerializedProperty vertexProp = texVerticesProp.GetArrayElementAtIndex(i);
SerializedProperty vertexPositionProp = vertexProp.FindPropertyRelative("vertex");
SerializedProperty boneWeightProp = vertexProp.FindPropertyRelative("boneWeight");
SerializedProperty boneIndex0Prop = boneWeightProp.FindPropertyRelative("boneIndex0");
SerializedProperty boneIndex1Prop = boneWeightProp.FindPropertyRelative("boneIndex1");
SerializedProperty boneIndex2Prop = boneWeightProp.FindPropertyRelative("boneIndex2");
SerializedProperty boneIndex3Prop = boneWeightProp.FindPropertyRelative("boneIndex3");
SerializedProperty boneWeight0Prop = boneWeightProp.FindPropertyRelative("weight0");
SerializedProperty boneWeight1Prop = boneWeightProp.FindPropertyRelative("weight1");
SerializedProperty boneWeight2Prop = boneWeightProp.FindPropertyRelative("weight2");
SerializedProperty boneWeight3Prop = boneWeightProp.FindPropertyRelative("weight3");
SerializedProperty smdVertexProp = smdVerticesProp.GetArrayElementAtIndex(i);
SerializedProperty smdBoneWeightProp = smdBoneWeightsProp.GetArrayElementAtIndex(i);
SerializedProperty smdBoneIndex0Prop = smdBoneWeightProp.FindPropertyRelative("boneIndex0");
SerializedProperty smdBoneIndex1Prop = smdBoneWeightProp.FindPropertyRelative("boneIndex1");
SerializedProperty smdBoneIndex2Prop = smdBoneWeightProp.FindPropertyRelative("boneIndex2");
SerializedProperty smdBoneIndex3Prop = smdBoneWeightProp.FindPropertyRelative("boneIndex3");
SerializedProperty smdBoneWeight0Prop = smdBoneWeightProp.FindPropertyRelative("weight0");
SerializedProperty smdBoneWeight1Prop = smdBoneWeightProp.FindPropertyRelative("weight1");
SerializedProperty smdBoneWeight2Prop = smdBoneWeightProp.FindPropertyRelative("weight2");
SerializedProperty smdBoneWeight3Prop = smdBoneWeightProp.FindPropertyRelative("weight3");
smdVertexProp.vector2Value = vertexPositionProp.vector2Value;
smdBoneIndex0Prop.intValue = boneIndex0Prop.intValue;
smdBoneIndex1Prop.intValue = boneIndex1Prop.intValue;
smdBoneIndex2Prop.intValue = boneIndex2Prop.intValue;
smdBoneIndex3Prop.intValue = boneIndex3Prop.intValue;
smdBoneWeight0Prop.floatValue = boneWeight0Prop.floatValue;
smdBoneWeight1Prop.floatValue = boneWeight1Prop.floatValue;
smdBoneWeight2Prop.floatValue = boneWeight2Prop.floatValue;
smdBoneWeight3Prop.floatValue = boneWeight3Prop.floatValue;
}
smdEdgesProp.arraySize = edgesProp.arraySize;
for (int i = 0; i < smdEdgesProp.arraySize; ++i)
{
SerializedProperty edgeProp = edgesProp.GetArrayElementAtIndex(i);
SerializedProperty smdEdgeProp = smdEdgesProp.GetArrayElementAtIndex(i);
smdEdgeProp.FindPropertyRelative("index1").intValue = edgeProp.FindPropertyRelative("index1").intValue;
smdEdgeProp.FindPropertyRelative("index2").intValue = edgeProp.FindPropertyRelative("index2").intValue;
}
smdHolesProp.arraySize = holesProp.arraySize;
for (int i = 0; i < smdHolesProp.arraySize; ++i)
{
SerializedProperty holeProp = holesProp.GetArrayElementAtIndex(i);
SerializedProperty smdHoleProp = smdHolesProp.GetArrayElementAtIndex(i);
smdHoleProp.vector2Value = holeProp.FindPropertyRelative("vertex").vector2Value;
}
smdIndicesProp.arraySize = indicesProp.arraySize;
for (int i = 0; i < smdIndicesProp.arraySize; ++i)
{
smdIndicesProp.GetArrayElementAtIndex(i).intValue = indicesProp.GetArrayElementAtIndex(i).intValue;
}
spriteMeshDataSO.ApplyModifiedProperties();
//Can't find the way to make SerializedProperty work with Matrix4x4, so we use reflection
SetBindPoses(spriteMeshData, GetBindPoses(spriteMesh));
}
}
static void HandleDragAndDrop(bool createOnEnter, Transform parent)
{
switch (Event.current.type)
{
case EventType.DragUpdated:
if (!init)
{
spriteMesh = GetSpriteMesh();
if (createOnEnter)
{
parentTransform = null;
CreateInstance();
}
Event.current.Use();
init = true;
}
if (instance)
{
instance.transform.position = instancePosition;
SpriteMeshInstance l_currentDestination = GetClosestBindeableIntersectingSpriteMeshInstance();
if (currentDestination != l_currentDestination)
{
currentDestination = l_currentDestination;
if (currentDestination)
{
List <Bone2D> destinationBones = currentDestination.bones;
List <Bone2D> newBones = new List <Bone2D>();
SpriteMeshData data = SpriteMeshUtils.LoadSpriteMeshData(instance.spriteMesh);
for (int i = 0; i < data.bindPoses.Length; ++i)
{
BindInfo bindInfo = data.bindPoses[i];
int index = FindBindInfo(bindInfo, currentDestination);
if (index >= 0 && index < destinationBones.Count)
{
newBones.Add(destinationBones[index]);
}
}
instance.transform.parent = currentDestination.transform.parent;
instance.bones = newBones;
SpriteMeshUtils.UpdateRenderer(instance, false);
foreach (Bone2D bone in s_InstanceBones)
{
bone.hideFlags = HideFlags.HideAndDontSave;
bone.gameObject.SetActive(false);
}
}
else
{
foreach (Bone2D bone in s_InstanceBones)
{
bone.hideFlags = HideFlags.None;
bone.gameObject.SetActive(true);
}
instance.transform.parent = null;
instance.bones = s_InstanceBones;
SpriteMeshUtils.UpdateRenderer(instance, false);
}
SceneView.RepaintAll();
}
}
break;
case EventType.DragExited:
if (instance)
{
GameObject.DestroyImmediate(instance.gameObject);
Event.current.Use();
}
Cleanup();
break;
case EventType.DragPerform:
if (!createOnEnter)
{
CreateInstance();
}
if (instance)
{
if (currentDestination)
{
foreach (Bone2D bone in s_InstanceBones)
{
if (bone)
{
GameObject.DestroyImmediate(bone.gameObject);
}
}
}
Undo.RegisterCreatedObjectUndo(instance.gameObject, "create SpriteMeshInstance");
}
Cleanup();
break;
}
if (instance)
{
DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
}
}