void OnPostprocessSprites(Texture2D texture, Sprite[] sprites)
        {
            if (!s_Initialized)
            {
                return;
            }

            string guid = AssetDatabase.AssetPathToGUID(assetPath);

            if (s_SpriteMeshToTextureCache.ContainsValue(guid))
            {
                foreach (Sprite sprite in sprites)
                {
                    foreach (KeyValuePair <string, string> pair in s_SpriteMeshToTextureCache)
                    {
                        if (pair.Value == guid)
                        {
                            SpriteMesh spriteMesh = LoadSpriteMesh(AssetDatabase.GUIDToAssetPath(pair.Key));

                            if (spriteMesh && spriteMesh.sprite && sprite.name == spriteMesh.sprite.name)
                            {
                                DoSpriteOverride(spriteMesh, sprite);
                                break;
                            }
                        }
                    }
                }
            }
        }
        static void UpdateCachedSpriteMesh(SpriteMesh spriteMesh)
        {
            if (spriteMesh)
            {
                string key = AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(spriteMesh));

                if (spriteMesh.sprite)
                {
                    SpriteMesh spriteMeshFromSprite = GetSpriteMeshFromSprite(spriteMesh.sprite);

                    if (!spriteMeshFromSprite || spriteMesh == spriteMeshFromSprite)
                    {
                        string value = AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(SpriteUtility.GetSpriteTexture(spriteMesh.sprite, false)));

                        s_SpriteMeshToTextureCache[key] = value;
                    }
                    else
                    {
                        Debug.LogWarning("Anima2D: SpriteMesh " + spriteMesh.name + " uses the same Sprite as " + spriteMeshFromSprite.name + ". Use only one SpriteMesh per Sprite.");
                    }
                }
                else if (s_SpriteMeshToTextureCache.ContainsKey(key))
                {
                    s_SpriteMeshToTextureCache.Remove(key);
                }
            }
        }
예제 #3
0
        public void Update()
        {
            m_TransformTrackers.Clear();
            m_BlendShapeWeightTracker.Clear();
            m_SpriteMesh = null;

            if (m_SpriteMeshInstance && m_SpriteMeshInstance.spriteMesh)
            {
                m_SpriteMesh = m_SpriteMeshInstance.spriteMesh;

                m_TransformTrackers.Add(new TransformTracker(m_SpriteMeshInstance.transform));

                foreach (Bone2D bone in m_SpriteMeshInstance.bones)
                {
                    m_TransformTrackers.Add(new TransformTracker(bone.transform));
                }

                if (m_SpriteMeshInstance.cachedSkinnedRenderer)
                {
                    int blendShapeCount = m_SpriteMeshInstance.sharedMesh.blendShapeCount;

                    for (int i = 0; i < blendShapeCount; ++i)
                    {
                        m_BlendShapeWeightTracker.Add(i,
                                                      m_SpriteMeshInstance.cachedSkinnedRenderer.GetBlendShapeWeight(i));
                    }
                }
            }
        }
        static void UpgradeSpriteMesh(SpriteMesh spriteMesh)
        {
            if (spriteMesh)
            {
                SerializedObject   spriteMeshSO   = new SerializedObject(spriteMesh);
                SerializedProperty apiVersionProp = spriteMeshSO.FindProperty("m_ApiVersion");

                if (apiVersionProp.intValue < SpriteMesh.api_version)
                {
                    if (apiVersionProp.intValue < 1)
                    {
                        Upgrade_001(spriteMeshSO);
                    }

                    if (apiVersionProp.intValue < 2)
                    {
                        Upgrade_002(spriteMeshSO);
                    }

                    if (apiVersionProp.intValue < 3)
                    {
                        Upgrade_003(spriteMeshSO);
                    }

                    spriteMeshSO.Update();
                    apiVersionProp.intValue = SpriteMesh.api_version;
                    spriteMeshSO.ApplyModifiedProperties();

                    AssetDatabase.SaveAssets();
                }
            }
        }
예제 #5
0
 public void SetSpriteMesh(SpriteMesh _spriteMesh, SpriteMeshInstance _spriteMeshInstance)
 {
     spriteMesh         = _spriteMesh;
     spriteMeshInstance = _spriteMeshInstance;
     spriteMeshData     = SpriteMeshUtils.LoadSpriteMeshData(_spriteMesh);
     RevertChanges();
 }
예제 #6
0
        public static SpriteMesh CreateSpriteMesh(Sprite sprite)
        {
            SpriteMesh     spriteMesh     = SpriteMeshPostprocessor.GetSpriteMeshFromSprite(sprite);
            SpriteMeshData spriteMeshData = null;

            if (!spriteMesh && sprite)
            {
                string spritePath = AssetDatabase.GetAssetPath(sprite);
                string directory  = Path.GetDirectoryName(spritePath);
                string assetPath  = AssetDatabase.GenerateUniqueAssetPath(directory + Path.DirectorySeparatorChar + sprite.name + ".asset");

                spriteMesh = ScriptableObject.CreateInstance <SpriteMesh>();
                InitFromSprite(spriteMesh, sprite);
                AssetDatabase.CreateAsset(spriteMesh, assetPath);

                spriteMeshData           = ScriptableObject.CreateInstance <SpriteMeshData>();
                spriteMeshData.name      = spriteMesh.name + "_Data";
                spriteMeshData.hideFlags = HideFlags.HideInHierarchy;
                InitFromSprite(spriteMeshData, sprite);
                AssetDatabase.AddObjectToAsset(spriteMeshData, assetPath);

                UpdateAssets(spriteMesh, spriteMeshData);

                AssetDatabase.SaveAssets();
                AssetDatabase.ImportAsset(assetPath);

                Selection.activeObject = spriteMesh;
            }

            return(spriteMesh);
        }
예제 #7
0
        public static bool NeedsOverride(SpriteMesh spriteMesh)
        {
            if (!spriteMesh || !spriteMesh.sprite)
            {
                return(false);
            }

            SpriteMeshData spriteMeshData = LoadSpriteMeshData(spriteMesh);

            if (!spriteMeshData)
            {
                return(false);
            }

            ushort[] triangles = spriteMesh.sprite.triangles;

            if (triangles.Length != spriteMeshData.indices.Length)
            {
                return(true);
            }

            for (int i = 0; i < triangles.Length; i++)
            {
                if (spriteMeshData.indices[i] != triangles[i])
                {
                    return(true);
                }
            }

            return(false);
        }
예제 #8
0
        public static SpriteMesh CreateSpriteMesh(Sprite sprite)
        {
            SpriteMesh spriteMesh = null;

            if (sprite)
            {
                string spritePath = AssetDatabase.GetAssetPath(sprite);
                string directory  = Path.GetDirectoryName(spritePath);
                string prefabPath = AssetDatabase.GenerateUniqueAssetPath(directory + Path.DirectorySeparatorChar + sprite.name + ".prefab");

                GameObject go     = new GameObject(sprite.name);
                GameObject prefab = PrefabUtility.CreatePrefab(prefabPath, go, ReplacePrefabOptions.ConnectToPrefab);
                GameObject.DestroyImmediate(go);

                spriteMesh      = ScriptableObject.CreateInstance <SpriteMesh>();
                spriteMesh.name = sprite.name;

                InitFromSprite(spriteMesh, sprite);

                AssetDatabase.AddObjectToAsset(spriteMesh, prefab);

                UpdateAssets(spriteMesh);

                AssetDatabase.SaveAssets();
                AssetDatabase.ImportAsset(prefabPath);

                Selection.activeObject = prefab;
            }

            return(spriteMesh);
        }
예제 #9
0
        static void UpgradeSpriteMesh(SpriteMesh spriteMesh)
        {
            if (spriteMesh)
            {
                SerializedObject   spriteMeshSO   = new SerializedObject(spriteMesh);
                SerializedProperty apiVersionProp = spriteMeshSO.FindProperty("m_ApiVersion");

                if (apiVersionProp.intValue < SpriteMesh.api_version)
                {
                    if (apiVersionProp.intValue < 2)
                    {
                        Debug.LogError("SpriteMesh " + spriteMesh +
                                       " was created using an ancient version of Anima2D which can't be upgraded anymore.\n" +
                                       "The last version that can upgrade this asset is Anima2D 1.1.5");
                    }

                    if (apiVersionProp.intValue < 3)
                    {
                        Upgrade_003(spriteMeshSO);
                    }

                    if (apiVersionProp.intValue < 4)
                    {
                        Upgrade_004(spriteMeshSO);
                    }

                    spriteMeshSO.Update();
                    apiVersionProp.intValue = SpriteMesh.api_version;
                    spriteMeshSO.ApplyModifiedProperties();

                    AssetDatabase.SaveAssets();
                }
            }
        }
예제 #10
0
        public static BlendShape CreateBlendShape(SpriteMesh spriteMesh, string blendshapeName)
        {
            BlendShape l_blendshape = null;

            SpriteMeshData spriteMeshData = LoadSpriteMeshData(spriteMesh);

            if (spriteMeshData)
            {
                l_blendshape = BlendShape.Create(blendshapeName);

                l_blendshape.hideFlags = HideFlags.HideInHierarchy;

                AssetDatabase.AddObjectToAsset(l_blendshape, spriteMeshData);

                List <BlendShape> l_blendshapes = new List <BlendShape>(spriteMeshData.blendshapes);

                l_blendshapes.Add(l_blendshape);

                spriteMeshData.blendshapes = l_blendshapes.ToArray();

                EditorUtility.SetDirty(spriteMeshData);
                EditorUtility.SetDirty(l_blendshape);
            }

            return(l_blendshape);
        }
        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);
        }
예제 #12
0
 void ResetSpriteMesh()
 {
     if (m_SpriteMeshOriginal != null && m_SpriteMeshOriginal.IsTemplate)
     {
         m_SpriteMesh         = m_SpriteMeshOriginal;
         m_SpriteMeshOriginal = null;
     }
 }
예제 #13
0
 static void Cleanup()
 {
     init               = false;
     spriteMesh         = null;
     instance           = null;
     currentDestination = null;
     parentTransform    = null;
     s_InstanceBones.Clear();
 }
예제 #14
0
		static void Cleanup()
		{
			init = false;
			spriteMesh = null;
			instance = null;
			currentDestination = null;
			parentTransform = null;
			s_InstanceBones.Clear();
		}
예제 #15
0
        static void HandleDragAndDrop(bool createOnEnter, Transform parent)
        {
            switch (Event.current.type)
            {
            case EventType.DragUpdated:

                if (!init)
                {
                    spriteMesh = GetSpriteMesh();

                    if (createOnEnter)
                    {
                        instance = CreateInstance(parent);
                    }

                    if (instance)
                    {
                        Event.current.Use();
                    }

                    init = true;
                }

                if (instance)
                {
                    DragAndDrop.visualMode      = DragAndDropVisualMode.Copy;
                    instance.transform.position = instancePosition;
                }

                break;

            case EventType.DragExited:

                if (instance)
                {
                    GameObject.DestroyImmediate(instance);
                    Event.current.Use();
                }
                Cleanup();
                break;

            case EventType.DragPerform:

                if (!createOnEnter)
                {
                    instance = CreateInstance(parent);
                }

                if (instance)
                {
                    Event.current.Use();
                }
                Cleanup();
                break;
            }
        }
예제 #16
0
        static void InitFromSprite(SpriteMesh spriteMesh, Sprite sprite)
        {
            SerializedObject   spriteMeshSO = new SerializedObject(spriteMesh);
            SerializedProperty spriteProp   = spriteMeshSO.FindProperty("m_Sprite");
            SerializedProperty apiProp      = spriteMeshSO.FindProperty("m_ApiVersion");

            spriteMeshSO.Update();
            apiProp.intValue = SpriteMesh.api_version;
            spriteProp.objectReferenceValue = sprite;
            spriteMeshSO.ApplyModifiedProperties();
        }
예제 #17
0
        public static Vector2 VertexToTexCoord(SpriteMesh spriteMesh, Vector2 pivotPoint, Vector3 vertex, float pixelsPerUnit)
        {
            Vector2 texCoord = Vector3.zero;

            if (spriteMesh != null)
            {
                texCoord = (Vector2)vertex * pixelsPerUnit + pivotPoint;
            }

            return(texCoord);
        }
예제 #18
0
        static SpriteMesh.BindInfo[] GetBindPoses(SpriteMesh spriteMesh)
        {
            SpriteMesh.BindInfo[] result = null;

            FieldInfo fieldInfo = typeof(SpriteMesh).GetField("bindPoses", BindingFlags.Instance | BindingFlags.NonPublic);

            if (fieldInfo != null)
            {
                result = (SpriteMesh.BindInfo[])fieldInfo.GetValue(spriteMesh);
            }
            return(result);
        }
예제 #19
0
        public static Vector2 VertexToTexCoord(SpriteMesh spriteMesh, Vector3 vertex)
        {
            Vector2 texCoord = Vector3.zero;

            if (spriteMesh != null)
            {
                Vector3 pivotPoint = (Vector3)GetPivotPoint(spriteMesh.sprite);
                texCoord = vertex * spriteMesh.sprite.pixelsPerUnit + pivotPoint;
            }

            return(texCoord);
        }
예제 #20
0
        public static Vector3 TexCoordToVertex(SpriteMesh spriteMesh, Vector2 texVertex)
        {
            Vector3 vertex = Vector3.zero;

            if (spriteMesh != null)
            {
                Vector3 pivotPoint = (Vector3)GetPivotPoint(spriteMesh.sprite);
                vertex = ((Vector3)texVertex - pivotPoint) / spriteMesh.sprite.pixelsPerUnit;
            }

            return(vertex);
        }
예제 #21
0
        static void HideMaterials(SpriteMesh spriteMesh)
        {
            for (int i = 0; i < spriteMesh.sharedMaterials.Length; i++)
            {
                Material material = spriteMesh.sharedMaterials [i];

                if (material)
                {
                    material.hideFlags = HideFlags.HideInHierarchy;
                    EditorUtility.SetDirty(material);
                }
            }
        }
예제 #22
0
        public void Clear()
        {
            spriteMesh         = null;
            spriteMeshInstance = null;
            selectedBone       = null;
            selectedEdge       = null;
            selectedVertices.Clear();
            texVertices.Clear();
            indexedEdges.Clear();
            indices.Clear();

            isDirty = false;
        }
예제 #23
0
        static SpriteMesh GetSpriteMesh()
        {
            SpriteMesh l_spriteMesh = null;

            if (DragAndDrop.objectReferences.Length > 0)
            {
                Object obj = DragAndDrop.objectReferences[0];

                l_spriteMesh = obj as SpriteMesh;
            }

            return(l_spriteMesh);
        }
        void DoSetSkinnedRenderer()
        {
            SpriteMesh spriteMesh = mSpriteMeshInstance.spriteMesh;

            if (spriteMesh)
            {
                MeshFilter   meshFilter   = mSpriteMeshInstance.GetComponent <MeshFilter>();
                MeshRenderer meshRenderer = mSpriteMeshInstance.GetComponent <MeshRenderer>();
                Material     material     = null;
                if (meshFilter)
                {
                    DestroyImmediate(meshFilter);
                }
                if (meshRenderer)
                {
                    material = meshRenderer.sharedMaterial;
                    DestroyImmediate(meshRenderer);
                }

                string path = AssetDatabase.GetAssetPath(spriteMesh);

                if (!material)
                {
                    material = AssetDatabase.LoadAssetAtPath(path, typeof(Material)) as Material;
                }

                Mesh mesh = AssetDatabase.LoadAssetAtPath(path, typeof(Mesh)) as Mesh;

                SkinnedMeshRenderer skinnedMeshRenderer = mSpriteMeshInstance.GetComponent <SkinnedMeshRenderer>();

                if (!skinnedMeshRenderer)
                {
                    skinnedMeshRenderer = mSpriteMeshInstance.gameObject.AddComponent <SkinnedMeshRenderer>();
                }

                if (skinnedMeshRenderer)
                {
                    skinnedMeshRenderer.sharedMesh     = mesh;
                    skinnedMeshRenderer.sharedMaterial = material;

                    skinnedMeshRenderer.bones = mSpriteMeshInstance.bones.ConvertAll(bone => bone.transform).ToArray();

                    if (mSpriteMeshInstance.bones.Count > 0)
                    {
                        skinnedMeshRenderer.rootBone = mSpriteMeshInstance.bones[0].transform;
                    }
                }
            }

            mSpriteMeshInstance.UpdateRenderer();
        }
예제 #25
0
        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 ContextCreateSpriteMesh(MenuCommand menuCommand)
        {
            GameObject     spriteRendererGO = Selection.activeGameObject;
            SpriteRenderer spriteRenderer   = null;
            SpriteMesh     spriteMesh       = null;

            int sortingLayerID = 0;
            int sortingOrder   = 0;

            if (spriteRendererGO)
            {
                spriteRenderer = spriteRendererGO.GetComponent <SpriteRenderer>();
            }

            if (spriteRenderer &&
                spriteRenderer.sprite)
            {
                sortingLayerID = spriteRenderer.sortingLayerID;
                sortingOrder   = spriteRenderer.sortingOrder;

                SpriteMesh overrideSpriteMesh = SpriteMeshPostprocessor.GetSpriteMeshFromSprite(spriteRenderer.sprite);

                if (overrideSpriteMesh)
                {
                    spriteMesh = overrideSpriteMesh;
                }
                else
                {
                    spriteMesh = SpriteMeshUtils.CreateSpriteMesh(spriteRenderer.sprite);
                }
            }

            if (spriteMesh)
            {
                Undo.SetCurrentGroupName("create SpriteMeshInstance");
                Undo.DestroyObjectImmediate(spriteRenderer);
                SpriteMeshInstance spriteMeshInstance =
                    SpriteMeshUtils.CreateSpriteMeshInstance(spriteMesh, spriteRendererGO, true);

                spriteMeshInstance.sortingLayerID = sortingLayerID;
                spriteMeshInstance.sortingOrder   = sortingOrder;

                Selection.activeGameObject = spriteRendererGO;
            }
            else
            {
                Debug.Log("Select a SpriteRenderer with a Sprite to convert to SpriteMesh");
            }
        }
예제 #27
0
        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);
                }
            }
        }
        void DoSetMeshRenderer()
        {
            SpriteMesh spriteMesh = mSpriteMeshInstance.spriteMesh;

            if (spriteMesh)
            {
                SkinnedMeshRenderer skinnedMeshRenderer = mSpriteMeshInstance.GetComponent <SkinnedMeshRenderer>();
                MeshFilter          meshFilter          = mSpriteMeshInstance.GetComponent <MeshFilter>();
                MeshRenderer        meshRenderer        = mSpriteMeshInstance.GetComponent <MeshRenderer>();

                Material material = null;

                if (skinnedMeshRenderer)
                {
                    material = skinnedMeshRenderer.sharedMaterial;
                    DestroyImmediate(skinnedMeshRenderer);
                }
                else if (meshRenderer)
                {
                    material = meshRenderer.sharedMaterial;
                }

                string path = AssetDatabase.GetAssetPath(spriteMesh);
                Mesh   mesh = AssetDatabase.LoadAssetAtPath(path, typeof(Mesh)) as Mesh;

                if (!meshFilter)
                {
                    meshFilter = mSpriteMeshInstance.gameObject.AddComponent <MeshFilter>();
                }

                if (meshFilter)
                {
                    meshFilter.sharedMesh = mesh;
                }

                if (!meshRenderer)
                {
                    meshRenderer = mSpriteMeshInstance.gameObject.AddComponent <MeshRenderer>();
                }

                if (meshRenderer)
                {
                    meshRenderer.sharedMaterial = material;
                }
            }

            mSpriteMeshInstance.UpdateRenderer();
        }
예제 #29
0
        public static SpriteMeshInstance CreateSpriteMeshInstance(SpriteMesh spriteMesh, bool undo = true)
        {
            if (spriteMesh)
            {
                GameObject gameObject = new GameObject(spriteMesh.name);

                if (undo)
                {
                    Undo.RegisterCreatedObjectUndo(gameObject, Undo.GetCurrentGroupName());
                }

                return(CreateSpriteMeshInstance(spriteMesh, gameObject, undo));
            }

            return(null);
        }
예제 #30
0
        static void InitFromSprite(SpriteMesh spriteMesh, Sprite sprite)
        {
            SerializedObject spriteMeshSO = new SerializedObject(spriteMesh);

            spriteMeshSO.Update();

            SerializedProperty spriteProp = spriteMeshSO.FindProperty("sprite");

            spriteProp.objectReferenceValue = sprite;

            spriteMeshSO.ApplyModifiedProperties();

            GetInfoFromSprite(sprite, spriteMesh.texVertices, spriteMesh.edges, spriteMesh.indices);

            EditorUtility.SetDirty(spriteMesh);
        }
예제 #31
0
        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);
            }
        }
예제 #32
0
		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);
			}
		}
예제 #33
0
		static void UpdateCachedSpriteMesh(SpriteMesh spriteMesh)
		{
			if(spriteMesh)
			{
				string key = AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(spriteMesh));
				
				if(spriteMesh.sprite)
				{
					SpriteMesh spriteMeshFromSprite = GetSpriteMeshFromSprite(spriteMesh.sprite);
					
					if(!spriteMeshFromSprite || spriteMesh == spriteMeshFromSprite)
					{
						string value = AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(SpriteUtility.GetSpriteTexture(spriteMesh.sprite,false)));
						
						s_SpriteMeshToTextureCache[key] = value;
					}else{
						Debug.LogWarning("Anima2D: SpriteMesh " + spriteMesh.name + " uses the same Sprite as " + spriteMeshFromSprite.name + ". Use only one SpriteMesh per Sprite.");
					}
					
				}else if(s_SpriteMeshToTextureCache.ContainsKey(key))
				{
					s_SpriteMeshToTextureCache.Remove(key);
				}
			}
		}
예제 #34
0
		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)
								{
									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;
			}
		}
예제 #35
0
		public void SetSpriteMesh(SpriteMesh _spriteMesh, SpriteMeshInstance _spriteMeshInstance)
		{
			spriteMesh = _spriteMesh;
			spriteMeshInstance = _spriteMeshInstance;
			spriteMeshData = SpriteMeshUtils.LoadSpriteMeshData(_spriteMesh);
			RevertChanges();
		}
예제 #36
0
		public static bool NeedsOverride(SpriteMesh spriteMesh)
		{
			if(!spriteMesh || !spriteMesh.sprite) return false;
			
			SpriteMeshData spriteMeshData = LoadSpriteMeshData(spriteMesh);
			
			if(!spriteMeshData) return false;
			
			ushort[] triangles = spriteMesh.sprite.triangles;
			
			if(triangles.Length != spriteMeshData.indices.Length) return true;
			
			for(int i = 0; i < triangles.Length; i++)
			{
				if(spriteMeshData.indices[i] != triangles[i])
				{
					return true;
				}
			}
			
			return false;
		}
예제 #37
0
		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;
		}
예제 #38
0
		public static SpriteMeshInstance CreateSpriteMeshInstance(SpriteMesh spriteMesh, bool undo = true)
		{
			if(spriteMesh)
			{
				GameObject gameObject = new GameObject(spriteMesh.name);
				
				if(undo)
				{
					Undo.RegisterCreatedObjectUndo(gameObject,Undo.GetCurrentGroupName());
				}
				
				return CreateSpriteMeshInstance(spriteMesh, gameObject, undo);
			}
			
			return null;
		}
예제 #39
0
		public static Rect CalculateSpriteRect(SpriteMesh spriteMesh, int padding)
		{
			int width = 0;
			int height = 0;
			
			GetSpriteTextureSize(spriteMesh.sprite,ref width,ref height);
			
			SpriteMeshData spriteMeshData = LoadSpriteMeshData(spriteMesh);
			
			Rect rect = spriteMesh.sprite.rect;
			
			if(spriteMeshData)
			{
				Vector2 min = new Vector2(float.MaxValue,float.MaxValue);
				Vector2 max = new Vector2(float.MinValue,float.MinValue);
				
				for (int i = 0; i < spriteMeshData.vertices.Length; i++)
				{
					Vector2 v = spriteMeshData.vertices[i];
					
					if(v.x < min.x) min.x = v.x;
					if(v.y < min.y) min.y = v.y;
					if(v.x > max.x) max.x = v.x;
					if(v.y > max.y) max.y = v.y;
				}
				
				rect.position = min - Vector2.one * padding;
				rect.size = (max - min) + Vector2.one * padding * 2f;
				rect = MathUtils.ClampRect(rect,new Rect(0f,0f,width,height));
			}
			
			return rect;
		}
예제 #40
0
		public static SpriteMeshData LoadSpriteMeshData(SpriteMesh spriteMesh)
		{
			if(spriteMesh)
			{
				UnityEngine.Object[] assets = AssetDatabase.LoadAllAssetsAtPath(AssetDatabase.GetAssetPath(spriteMesh));
				
				foreach(UnityEngine.Object asset in assets)
				{
					SpriteMeshData data = asset as SpriteMeshData;
					
					if(data)
					{
						return data;
					}
				}
			}
			
			return null;
		}
예제 #41
0
		static void SetBindPoses(SpriteMeshData spriteMeshData, SpriteMesh.BindInfo[] bindPoses)
		{
			if(bindPoses != null && bindPoses.Length > 0)
			{
				BindInfo[] array = new BindInfo[bindPoses.Length];
				
				for(int i = 0; i < array.Length; ++i)
				{
					BindInfo b = new BindInfo();
					b.bindPose = bindPoses[i].bindPose;
					b.boneLength = bindPoses[i].boneLength;
					b.color = bindPoses[i].color;
					b.name = bindPoses[i].name;
					b.path = bindPoses[i].path;
					b.zOrder = bindPoses[i].zOrder;
					
					array[i] = b;
				}
				
				FieldInfo fieldInfo = typeof(SpriteMeshData).GetField("m_BindPoses",BindingFlags.Instance | BindingFlags.NonPublic);
				
				if(fieldInfo != null)
				{
					fieldInfo.SetValue(spriteMeshData,array);
				}
				
				EditorUtility.SetDirty(spriteMeshData);
			}
		}
예제 #42
0
		static SpriteMesh.BindInfo[] GetBindPoses(SpriteMesh spriteMesh)
		{
			SpriteMesh.BindInfo[] result = null;
			
			FieldInfo fieldInfo = typeof(SpriteMesh).GetField("bindPoses",BindingFlags.Instance | BindingFlags.NonPublic);
			
			if(fieldInfo != null)
			{
				result = (SpriteMesh.BindInfo[])fieldInfo.GetValue(spriteMesh);
			}
			return result;
		}
예제 #43
0
		public static void UpdateAssets(SpriteMesh spriteMesh, SpriteMeshData spriteMeshData)
		{
			if(spriteMesh && spriteMeshData)
			{
				string spriteMeshPath = AssetDatabase.GetAssetPath(spriteMesh);
				
				SerializedObject spriteMeshSO = new SerializedObject(spriteMesh);
				SerializedProperty sharedMeshProp = spriteMeshSO.FindProperty("m_SharedMesh");
				SerializedProperty sharedMaterialsProp = spriteMeshSO.FindProperty("m_SharedMaterials");
				
				if(!spriteMesh.sharedMesh)
				{
					Mesh mesh = new Mesh();
					mesh.hideFlags = HideFlags.HideInHierarchy;
					AssetDatabase.AddObjectToAsset(mesh,spriteMeshPath);
					
					spriteMeshSO.Update();
					sharedMeshProp.objectReferenceValue = mesh;
					spriteMeshSO.ApplyModifiedProperties();
					EditorUtility.SetDirty(mesh);
				}
				
				spriteMesh.sharedMesh.name = spriteMesh.name;
				
				if(spriteMesh.sharedMaterials.Length == 0)
				{
					Material material = new Material(Shader.Find("Sprites/Default"));
					material.mainTexture = SpriteUtility.GetSpriteTexture(spriteMesh.sprite,false);
					
					AssetDatabase.AddObjectToAsset(material,spriteMeshPath);
					
					spriteMeshSO.Update();
					sharedMaterialsProp.arraySize = 1;
					sharedMaterialsProp.GetArrayElementAtIndex(0).objectReferenceValue = material;
					spriteMeshSO.ApplyModifiedProperties();
				}
				
				for (int i = 0; i < spriteMesh.sharedMaterials.Length; i++)
				{
					Material material = spriteMesh.sharedMaterials [i];
					
					if(material)
					{
						if(spriteMesh.sprite)
						{
							material.mainTexture = SpriteUtility.GetSpriteTexture(spriteMesh.sprite,false);
						}
						
						material.name = spriteMesh.name + "_" + i;
						material.hideFlags = HideFlags.HideInHierarchy;
						EditorUtility.SetDirty(material);
					}
				}
				
				spriteMeshData.hideFlags = HideFlags.HideInHierarchy;
				EditorUtility.SetDirty(spriteMeshData);
				
				int width = 0;
				int height = 0;
				
				GetSpriteTextureSize(spriteMesh.sprite,ref width,ref height);
				
				float pixelsPerUnit = GetSpritePixelsPerUnit(spriteMesh.sprite);
				
				Vector2 textureWidthHeightInv = new Vector2(1f/width,1f/height);
				
				Vector3[] vertices = (new List<Vector2>(spriteMeshData.vertices)).ConvertAll( v => TexCoordToVertex(spriteMeshData.pivotPoint,v,pixelsPerUnit)).ToArray();
				Vector2[] uvs = (new List<Vector2>(spriteMeshData.vertices)).ConvertAll( v => Vector2.Scale(v,textureWidthHeightInv)).ToArray();
				
				Vector3[] normals = (new List<Vector3>(vertices)).ConvertAll( v => Vector3.back ).ToArray();
				
				BoneWeight[] boneWeightsData = spriteMeshData.boneWeights;
				
				if(boneWeightsData.Length != spriteMeshData.vertices.Length)
				{
					boneWeightsData = new BoneWeight[spriteMeshData.vertices.Length];
				}
				
				List<UnityEngine.BoneWeight> boneWeights = new List<UnityEngine.BoneWeight>(boneWeightsData.Length);
				
				List<float> verticesOrder = new List<float>(spriteMeshData.vertices.Length);
				
				for (int i = 0; i < boneWeightsData.Length; i++)
				{
					BoneWeight boneWeight = boneWeightsData[i];
					
					List< KeyValuePair<int,float> > pairs = new List<KeyValuePair<int, float>>();
					pairs.Add(new KeyValuePair<int, float>(boneWeight.boneIndex0,boneWeight.weight0));
					pairs.Add(new KeyValuePair<int, float>(boneWeight.boneIndex1,boneWeight.weight1));
					pairs.Add(new KeyValuePair<int, float>(boneWeight.boneIndex2,boneWeight.weight2));
					pairs.Add(new KeyValuePair<int, float>(boneWeight.boneIndex3,boneWeight.weight3));
					
					pairs = pairs.OrderByDescending(s=>s.Value).ToList();
					
					UnityEngine.BoneWeight boneWeight2 = new UnityEngine.BoneWeight();
					boneWeight2.boneIndex0 = Mathf.Max(0,pairs[0].Key);
					boneWeight2.boneIndex1 = Mathf.Max(0,pairs[1].Key);
					boneWeight2.boneIndex2 = Mathf.Max(0,pairs[2].Key);
					boneWeight2.boneIndex3 = Mathf.Max(0,pairs[3].Key);
					boneWeight2.weight0 = pairs[0].Value;
					boneWeight2.weight1 = pairs[1].Value;
					boneWeight2.weight2 = pairs[2].Value;
					boneWeight2.weight3 = pairs[3].Value;
					
					boneWeights.Add(boneWeight2);
					
					float vertexOrder = i;
					
					if(spriteMeshData.bindPoses.Length > 0)
					{
						vertexOrder = spriteMeshData.bindPoses[boneWeight2.boneIndex0].zOrder * boneWeight2.weight0 +
							spriteMeshData.bindPoses[boneWeight2.boneIndex1].zOrder * boneWeight2.weight1 +
								spriteMeshData.bindPoses[boneWeight2.boneIndex2].zOrder * boneWeight2.weight2 +
								spriteMeshData.bindPoses[boneWeight2.boneIndex3].zOrder * boneWeight2.weight3;
					}
					
					verticesOrder.Add(vertexOrder);
				}
				
				List<WeightedTriangle> weightedTriangles = new List<WeightedTriangle>(spriteMeshData.indices.Length / 3);
				
				for(int i = 0; i < spriteMeshData.indices.Length; i+=3)
				{
					int p1 = spriteMeshData.indices[i];
					int p2 = spriteMeshData.indices[i+1];
					int p3 = spriteMeshData.indices[i+2];
					
					weightedTriangles.Add(new WeightedTriangle(p1,p2,p3,
					                                           verticesOrder[p1],
					                                           verticesOrder[p2],
					                                           verticesOrder[p3]));
				}
				
				weightedTriangles = weightedTriangles.OrderBy( t => t.weight ).ToList();
				
				List<int> indices = new List<int>(spriteMeshData.indices.Length);
				
				for(int i = 0; i < weightedTriangles.Count; ++i)
				{
					WeightedTriangle t = weightedTriangles[i];
					indices.Add(t.p1);
					indices.Add(t.p2);
					indices.Add(t.p3);
				}
				
				spriteMesh.sharedMesh.Clear();
				spriteMesh.sharedMesh.vertices = vertices;
				spriteMesh.sharedMesh.uv = uvs;
				spriteMesh.sharedMesh.triangles = indices.ToArray();
				spriteMesh.sharedMesh.normals = normals;
				spriteMesh.sharedMesh.boneWeights = boneWeights.ToArray();
				spriteMesh.sharedMesh.bindposes = (new List<BindInfo>(spriteMeshData.bindPoses)).ConvertAll( p => p.bindPose ).ToArray();
				spriteMesh.sharedMesh.RecalculateBounds();
			}
		}
예제 #44
0
		static void InitFromSprite(SpriteMesh spriteMesh, Sprite sprite)
		{
			SerializedObject spriteMeshSO = new SerializedObject(spriteMesh);
			SerializedProperty spriteProp = spriteMeshSO.FindProperty("m_Sprite");
			SerializedProperty apiProp = spriteMeshSO.FindProperty("m_ApiVersion");
			
			spriteMeshSO.Update();
			apiProp.intValue = SpriteMesh.api_version;
			spriteProp.objectReferenceValue = sprite;
			spriteMeshSO.ApplyModifiedProperties();
		}
예제 #45
0
		public static Vector2 VertexToTexCoord(SpriteMesh spriteMesh, Vector2 pivotPoint, Vector3 vertex, float pixelsPerUnit)
		{
			Vector2 texCoord = Vector3.zero;
			
			if(spriteMesh != null)
			{
				texCoord = (Vector2)vertex * pixelsPerUnit + pivotPoint;
			}
			
			return texCoord;
		}
예제 #46
0
		public static void UpdateAssets(SpriteMesh spriteMesh)
		{
			UpdateAssets(spriteMesh, SpriteMeshUtils.LoadSpriteMeshData(spriteMesh));
		}
예제 #47
0
		static void UpgradeSpriteMesh(SpriteMesh spriteMesh)
		{
			if(spriteMesh)
			{
				SerializedObject spriteMeshSO = new SerializedObject(spriteMesh);
				SerializedProperty apiVersionProp = spriteMeshSO.FindProperty("m_ApiVersion");
				
				if(apiVersionProp.intValue < SpriteMesh.api_version)
				{
					if(apiVersionProp.intValue < 1)
					{
						Upgrade_001(spriteMeshSO);
					}
					
					if(apiVersionProp.intValue < 2)
					{
						Upgrade_002(spriteMeshSO);
					}
					
					if(apiVersionProp.intValue < 3)
					{
						Upgrade_003(spriteMeshSO);
					}
					
					spriteMeshSO.Update();
					apiVersionProp.intValue = SpriteMesh.api_version;
					spriteMeshSO.ApplyModifiedProperties();
					
					AssetDatabase.SaveAssets();
				}
			}
		}