/// <sumary>
        /// Import ase file at aPath to aObject
        /// </sumary>
        /// <param name="aPath">Path</param>
        /// <param name="aObject">Aseprite object</param>
        public static bool Import(string aPath, CAsepriteObject aObject)
        {
            bool tExported = CAsepriteExporter.Export(aPath, aObject);

            if (tExported)
            {
                TextureImporter tTexture = AssetImporter.GetAtPath(
                    AssetDatabase.GetAssetPath(aObject.targetTexture)) as TextureImporter;

                // TODO: See if I can put the texture as an embeded object

                /*
                 * Texture2D tNewTex = new Texture2D(1, 1);
                 * tNewTex.SetPixel(0, 0, Color.cyan);
                 * tNewTex.Apply();
                 * AssetDatabase.AddObjectToAsset(tNewTex, aObject);
                 */

                CAsepriteImporter.ImportSheet(tTexture, aObject);
                CAsepriteImporter.ImportAnimation(tTexture, aObject);
                CAsepriteWindow.CreateAnimator(aObject);
            }

            return(tExported);
        }
Exemple #2
0
 /// <sumary>
 /// Find aseprite asset corresponding to AsepriteObject
 /// </sumary>
 /// <param name="aObject">Aseprite object</param>
 public static Object FindAsepriteAsset(CAsepriteObject aObject)
 {
     Object[] tObjects = Resources.FindObjectsOfTypeAll <Object>();
     for (int j = 0; j < tObjects.Length; j++)
     {
         var asset = tObjects[j];
         var path  = AssetDatabase.GetAssetPath(asset);
         if (path.ToLower().EndsWith(".ase"))
         {
             AssetImporter tImporter =
                 AssetImporter.GetAtPath(path);
             JSONNode tData = JSON.Parse(tImporter.userData);
             JSONNode tID   = tData["assetID"];
             if (tID != null)
             {
                 var obj = GetAssetByID <CAsepriteObject>(tID.Value);
                 if (obj != null)
                 {
                     return(asset);
                 }
             }
         }
     }
     return(null);
 }
Exemple #3
0
        static EditorCurveBinding GetBinding(CAsepriteObject aEnv)
        {
            EditorCurveBinding curveBinding = new EditorCurveBinding();

            // Set type
            if (aEnv.animType == AnimationType.SpriteRenderer)
            {
                curveBinding.type = typeof(SpriteRenderer);
            }
            else if (aEnv.animType == AnimationType.Image)
            {
                curveBinding.type = typeof(UnityEngine.UI.Image);
            }

            curveBinding.propertyName = "m_Sprite";
            if (aEnv.useChild)
            {
                curveBinding.path = BINDING_PATH;
            }
            else
            {
                curveBinding.path = "";
            }

            return(curveBinding);
        }
        /// <sumary>
        /// Creates a new CAsepriteObject asset on aPath
        /// </sumary>
        /// <param name="aPath">Path</param>
        public static CAsepriteObject CreateAsset(string aPath)
        {
            CAsepriteObject tObj = NewInstance();

            AssetDatabase.CreateAsset(tObj, Path.GetDirectoryName(aPath)
                                      + "/" + Path.GetFileNameWithoutExtension(aPath) + ".asset");
            return(tObj);
        }
Exemple #5
0
        /// <summary>
        /// Creates spritesheet on aTexture using the json aAtlas generated by aseprite
        /// </summary>
        /// <param name="aTexture">Spritesheet texture</param>
        /// <param name="aObj">Aseprite object</param>
        public static void ImportSheet(TextureImporter aTexture, CAsepriteObject aObj)
        {
            // Change metadata
            CAtlasData            tData     = JsonConvert.DeserializeObject <CAtlasData>(aObj.targetAtlas.text);
            List <SpriteMetaData> tMetaData = new List <SpriteMetaData>();

            aTexture.textureType      = TextureImporterType.Sprite;
            aTexture.spriteImportMode = SpriteImportMode.Multiple;
            aTexture.filterMode       = FilterMode.Point;
#if UNITY_5_6_OR_NEWER
            aTexture.textureCompression = TextureImporterCompression.Uncompressed;
#else
            aTexture.textureFormat = TextureImporterFormat.AutomaticTruecolor;
#endif
            List <string> tKeys = new List <string>();
            tKeys.AddRange(tData.frames.Keys);
            tKeys.Sort();

            Dictionary <string, int> tAnimations = new Dictionary <string, int>();

            Vector2         tPivot     = aObj.pivot;
            SpriteAlignment tAlignment = aObj.alignment;
            for (int i = 0; i < tKeys.Count; i++)
            {
                string           tKey      = tKeys[i];
                CAtlasData.Frame tFrame    = tData.frames[tKey];
                SpriteMetaData   tThisData = new SpriteMetaData();
                string           tTag      = GetTag(tKey);
                if (tTag != "")
                {
                    if (tAnimations.ContainsKey(tTag))
                    {
                        tAnimations[tTag] += 1;
                    }
                    else
                    {
                        tAnimations.Add(tTag, 0);
                    }

                    string tName = tTag + "_" + tAnimations[tTag];
                    tThisData.name = tName;
                    tThisData.rect = new Rect(
                        tFrame.frame.x,
                        tFrame.frame.y,
                        tFrame.frame.w,
                        tFrame.frame.h
                        );
                    tThisData.rect.y    = tData.meta.size.h - tThisData.rect.y - tThisData.rect.height;
                    tThisData.alignment = (int)tAlignment;
                    tThisData.pivot     = tPivot;
                    tMetaData.Add(tThisData);
                }
            }

            aTexture.spritesheet = tMetaData.ToArray();
            AssetDatabase.ImportAsset(aTexture.assetPath, ImportAssetOptions.ForceUpdate);
        }
        void ApplyChanges()
        {
            for (int i = 0; i < m_AssetTargets.Length; i++)
            {
                CAsepriteObject tObj = m_AssetTargets[i];
                if (m_UseTags.dirty)
                {
                    tObj.useTags = m_UseTags.value;
                }
                if (m_LoopAnim.dirty)
                {
                    tObj.loopAnim = m_LoopAnim.value;
                }
                if (m_UseConfig.dirty)
                {
                    tObj.useConfig = m_UseConfig.value;
                }
                if (m_Border.dirty)
                {
                    tObj.border = m_Border.value;
                }
                if (m_UseChild.dirty)
                {
                    tObj.useChild = m_UseChild.value;
                }
                if (m_Alignment.dirty)
                {
                    tObj.alignment = m_Alignment.value;
                }
                if (m_Pivot.dirty)
                {
                    tObj.pivot = m_Pivot.value;
                }
                if (m_AnimType.dirty)
                {
                    tObj.animType = m_AnimType.value;
                }
                Import(AssetDatabase.GetAssetPath(tObj.asepriteAsset), tObj);
                EditorUtility.SetDirty(tObj);
            }

            m_UseTags.dirty   = false;
            m_LoopAnim.dirty  = false;
            m_UseConfig.dirty = false;
            m_Border.dirty    = false;
            m_UseChild.dirty  = false;
            m_Alignment.dirty = false;
            m_Pivot.dirty     = false;
            m_AnimType.dirty  = false;
        }
        /// <sumary>
        /// Creates a new generic CAsepriteObject
        /// </sumary>
        public static CAsepriteObject NewInstance()
        {
            CAsepriteObject tObj = CreateInstance <CAsepriteObject>();

            tObj.useTags   = CAsepriteWindow.UseTags;
            tObj.loopAnim  = CAsepriteWindow.LoopAnim;
            tObj.useConfig = CAsepriteWindow.UseConfig;
            tObj.border    = CAsepriteWindow.Border;
            tObj.useChild  = CAsepriteWindow.UseChild;
            tObj.alignment = CAsepriteWindow.Alignment;
            tObj.pivot     = CAsepriteWindow.Pivot;
            tObj.animType  = CAsepriteWindow.AnimType;

            /*tObj.autoImport = CAsepriteWindow.AutoImport;
             * tObj.importSpritesheet = CAsepriteWindow.ImportSpritesheet;
             * tObj.importAnimations = CAsepriteWindow.ImportAnimations;
             * tObj.createAnimator = CAsepriteWindow.CreateAnimatorDefault;*/
            tObj.clips = new AnimationClip[0];
            return(tObj);
        }
        /// <summary>
        /// Creates an animator asset using the aseprite object
        /// </summary>
        /// <param name="aObj">Aseprite object</param>
        public static void CreateAnimator(CAsepriteObject aObj)
        {
            // Check if animator already exists
            if (aObj.targetAnimator == null || aObj.targetAnimator.layers == null ||
                aObj.targetAnimator.layers.Length == 0 ||
                aObj.targetAnimator.layers[0].stateMachine == null
                )
            {
                if (aObj.targetAnimator != null)
                {
                    DestroyImmediate(aObj.targetAnimator);
                }
                aObj.targetAnimator = new AnimatorController();
                aObj.targetAnimator.AddLayer("Base");
                aObj.targetAnimator.name = aObj.name + " Animator";
                AssetDatabase.AddObjectToAsset(aObj.targetAnimator, aObj);
                Debug.Log("Created animator");
            }

            AnimatorStateMachine tRootStateMachine = aObj.targetAnimator.layers[0].stateMachine;

            for (int i = 0; i < aObj.clips.Length; i++)
            {
                bool          tFound = false;
                AnimationClip tClip  = aObj.clips[i];
                for (int j = 0; j < tRootStateMachine.states.Length; j++)
                {
                    if (tRootStateMachine.states[j].state.motion == tClip)
                    {
                        tFound = true;
                        break;
                    }
                }
                if (!tFound)
                {
                    AnimatorState tState = tRootStateMachine.AddState(tClip.name);
                    tState.motion = tClip;
                }
            }
        }
Exemple #9
0
        /// <summary>
        /// Creates AnimationClips using the information in the json atlas created
        /// by aseprite.
        /// If CAsepriteWindow.UseTags is true, it separates the animations,
        /// otherwise it creates only one animation.
        /// </summary>
        /// <param name="aTexture">Spritesheet texture</param>
        /// <param name="aObj">Aseprite object</param>
        /// <returns>AnimationClips created</returns>
        public static AnimationClip[] ImportAnimation(TextureImporter aTexture, CAsepriteObject aObj)
        {
            CAtlasData tData = JsonConvert.DeserializeObject <CAtlasData>(aObj.targetAtlas.text);

            aTexture.textureType      = TextureImporterType.Sprite;
            aTexture.spriteImportMode = SpriteImportMode.Multiple;
            aTexture.filterMode       = FilterMode.Point;
            List <string> tKeys = new List <string>();

            tKeys.AddRange(tData.frames.Keys);

            Dictionary <string, int>           tAnimationsIndices = new Dictionary <string, int>();
            Dictionary <string, List <Frame> > tAnimations        = new Dictionary <string, List <Frame> >();

            Sprite[] tSprites = AssetDatabase.LoadAllAssetsAtPath(aTexture.assetPath)
                                .OfType <Sprite>().ToArray();
            ResetOptions();

            foreach (string tKey in tKeys)
            {
                string tTag = GetTag(tKey);
                if (tTag != "")
                {
                    List <Frame> tFrameList;
                    if (tAnimations.ContainsKey(tTag))
                    {
                        tFrameList = tAnimations[tTag];
                    }
                    else
                    {
                        tAnimationsIndices.Add(tTag, 0);
                        tFrameList = new List <Frame>();
                        tAnimations.Add(tTag, tFrameList);
                    }
                    ObjectReferenceKeyframe kf = new ObjectReferenceKeyframe();
                    if (tFrameList.Count > 0)
                    {
                        float tTime = 0;
                        for (int i = 0; i < tFrameList.Count; i++)
                        {
                            tTime += tFrameList[i].length;
                        }
                        kf.time = tTime;
                    }
                    else
                    {
                        kf.time = 0;
                    }

                    kf.value = GetSprite(tSprites, tTag + "_" + tAnimationsIndices[tTag].ToString());
                    Frame tFrame = new Frame();
                    tFrame.frame  = kf;
                    tFrame.length = tData.frames[tKey].duration / 1000f;
                    tAnimations[tTag].Add(tFrame);
                    tAnimationsIndices[tTag] += 1;
                }
            }

            foreach (KeyValuePair <string, KeyValuePair <int, string[]> > tPair in _frameOptions)
            {
                KeyValuePair <int, string[]> tEvent = tPair.Value;
                for (int i = 0; i < tEvent.Value.Length; i++)
                {
                    Debug.Log(tEvent.Key + ", " + tEvent.Value[i]);
                }
            }

            EditorCurveBinding tBinding = GetBinding(aObj);

            AnimationClip[] tClips = new AnimationClip[tAnimations.Keys.Count];
            int             j      = 0;

            foreach (string tKey in tAnimations.Keys)
            {
                int           tInd = ClipInList(aObj.clips, tKey);
                AnimationClip tClip;
                if (tInd >= 0)
                {
                    tClip = aObj.clips[tInd];
                }
                else
                {
                    tClip = new AnimationClip();
                }

                List <Frame> tAnimation  = tAnimations[tKey];
                int          tFramecount = tAnimation.Count;

                tClip.frameRate = 60;
                tClip.wrapMode  = WrapMode.Loop;

                ObjectReferenceKeyframe[] keyFrames = new ObjectReferenceKeyframe[tFramecount + 1];

                for (int i = 0; i < tFramecount; i++)
                {
                    keyFrames[i] = tAnimation[i].frame;
                }
                ObjectReferenceKeyframe kf = new ObjectReferenceKeyframe();
                kf.time = keyFrames[tFramecount - 1].time + tAnimation[0].length;
                if ((!aObj.useConfig && aObj.loopAnim) ||
                    (aObj.useConfig && !HasOption(tKey, NO_LOOP)))
                {
                    // Make last frame the same as first
                    kf.value = tAnimation[0].frame.value;
                    // Make animation loop
                    AnimationClipSettings tSettings = AnimationUtility.GetAnimationClipSettings(tClip);
                    tSettings.loopTime = true;
                    AnimationUtility.SetAnimationClipSettings(tClip, tSettings);
                }
                else
                {
                    kf.value = tAnimation[tAnimation.Count - 1].frame.value;
                }
                keyFrames[tFramecount] = kf;

                AnimationUtility.SetObjectReferenceCurve(tClip, tBinding, keyFrames);

                tClip.name = tKey;
                tClips[j]  = tClip;
                j++;

                /*
                 * string tAnimPath;
                 * if (aEnv.targetAnimator != null)
                 * {
                 *  string tPath = AssetDatabase.GetAssetPath(aEnv.targetAnimator);
                 *  tAnimPath = Path.GetDirectoryName(tPath) + "/" + aEnv.name + "_" + tKey + ".anim";
                 * }
                 * else
                 * {
                 *  if (CAsepriteWindow.UseConfiguredTargets)
                 *      tAnimPath = CAsepriteWindow.TargetAnimDir;
                 *  else
                 *      tAnimPath = Path.GetDirectoryName(
                 *          AssetDatabase.GetAssetPath(aEnv.targetTexture));
                 *  if (string.IsNullOrEmpty(tAnimPath))
                 *      tAnimPath = Path.GetDirectoryName(
                 *          AssetDatabase.GetAssetPath(aEnv.targetTexture));
                 *  tAnimPath += "/" + aEnv.name + "_" + tKey + ".anim";
                 * }
                 */

                if (tInd < 0)
                {
                    //if (tAnimPath.StartsWith(Application.dataPath))
                    //  tAnimPath = "Assets/" + tAnimPath.Substring(Application.dataPath.Length);
                    //AssetDatabase.CreateAsset(tClip, tAnimPath);
                    AssetDatabase.AddObjectToAsset(tClip, aObj);
                }
            }
            AssetDatabase.SaveAssets();

            // Frame options
            foreach (KeyValuePair <string, KeyValuePair <int, string[]> > tOption in _frameOptions)
            {
                AnimationClip         tClip   = GetClip(tClips, tOption.Key);
                List <AnimationEvent> tEvents = new List <AnimationEvent>();
                if (tClip != null)
                {
                    ObjectReferenceKeyframe[] tFrameList = AnimationUtility.GetObjectReferenceCurve(tClip, tBinding);
                    int tFrameNum = tOption.Value.Key;
                    if (tFrameNum >= 0 && tFrameNum < tFrameList.Length)
                    {
                        ObjectReferenceKeyframe tFrame = tFrameList[tFrameNum];

                        for (int i = 0; i < tOption.Value.Value.Length; i++)
                        {
                            string tOptionName = tOption.Value.Value[i];
                            if (tOptionName.StartsWith(EVENT_PLUS) && tFrameNum < tFrameList.Length - 1)
                            {
                                tFrame = tFrameList[tFrameNum + 1];
                                AnimationEvent tEvent = new AnimationEvent();
                                tEvent.time = tFrame.time;
                                string[] tValues = tOptionName.Split(EVENT_SEPARATOR);
                                if (tValues.Length > 1)
                                {
                                    tValues = tValues[1].Split(SEPARATOR);
                                    if (tValues.Length > 1)
                                    {
                                        tEvent.functionName    = tValues[0];
                                        tEvent.stringParameter = tValues[1];
                                        tEvents.Add(tEvent);
                                    }
                                }
                            }
                            else if (tOptionName.StartsWith(EVENT))
                            {
                                AnimationEvent tEvent = new AnimationEvent();
                                tEvent.time = tFrame.time;
                                string[] tValues = tOptionName.Split(EVENT_SEPARATOR);
                                if (tValues.Length > 1)
                                {
                                    tValues = tValues[1].Split(SEPARATOR);
                                    if (tValues.Length > 1)
                                    {
                                        tEvent.functionName    = tValues[0];
                                        tEvent.stringParameter = tValues[1];
                                        tEvents.Add(tEvent);
                                    }
                                }
                            }
                        }
                    }
                    AnimationUtility.SetAnimationEvents(tClip, tEvents.ToArray());
                }
            }

            aObj.clips = tClips;
            return(tClips);
        }
Exemple #10
0
        static void PostProcessDelayed()
        {
            EditorApplication.delayCall -= PostProcessDelayed;
            if (m_ImportedAssets.Count == 0)
            {
                return;
            }

            string[] tImportedAssets = m_ImportedAssets[0];
            m_ImportedAssets.RemoveAt(0);

            bool tSaveAssets = false;

            for (int i = 0; i < tImportedAssets.Length; i++)
            {
                string tPath = tImportedAssets[i];
                if (tPath.EndsWith(".ase"))
                {
                    Object tAsset = AssetDatabase.LoadAssetAtPath <Object>(tPath);

                    bool          tDirty    = false;
                    AssetImporter tImporter = AssetImporter.GetAtPath(tPath);
                    JSONNode      tData     = JSON.Parse(tImporter.userData);
                    if (tData == null)
                    {
                        tData = new JSONObject();
                    }
                    JSONNode        tID  = tData["assetID"];
                    CAsepriteObject tObj = null;
                    if (tID != null)
                    {
                        tObj = GetAssetByID <CAsepriteObject>(tID.Value);
                        if (tObj == null)
                        {
                            tObj = FindAsepriteObject(tAsset);
                        }
                    }
                    else
                    {
                        tID = new JSONNumber(0);
                        tData["assetID"] = tID;
                        tDirty           = true;
                    }

                    if (tObj == null)
                    {
                        tObj = CAsepriteObjectEditor.CreateAsset(tPath);

                        /*
                         * { "targetTexture":"c92e2bd276d32ed4984c0a349da9dcc8",
                         * "targetText":"1cb757cd5d2c60f4cb1d15f7653554bc",
                         * "useTags":"true",
                         * "loopAnim":"false",
                         * "useConfig":"true",
                         * "border":"5",
                         * "useChild":"true",
                         * "alignment":"0",
                         * "pivotX":"0.100000001490116",
                         * "pivotY":"0.200000002980232",
                         * "animType":"0",
                         * "clips":["7ab1c6126e7e91c4d8d19e3f7e8e8f6d","416c940187f463c4f9af57db128e5cbe"],
                         * "autoImport":"false",
                         * "importAnimations":"true",
                         * "importSpritesheet":"true",
                         * "createAnimator":"true",
                         * "targetAnimator":"88400be09d870114491df24486087eb5",
                         * "targetPrefab":"c1df4f5e993e4b347a7ab29909bebb01"}
                         */
                        SetAssetValue(tData, "targetTexture", ref tObj.targetTexture);
                        SetAssetValue(tData, "targetText", ref tObj.targetAtlas);
                        SetBool(tData, "useTags", ref tObj.useTags);
                        SetBool(tData, "loopAnim", ref tObj.loopAnim);
                        SetBool(tData, "useConfig", ref tObj.useConfig);
                        SetInt(tData, "border", ref tObj.border);
                        SetFloat(tData, "pivotX", ref tObj.pivot.x);
                        SetFloat(tData, "pivotY", ref tObj.pivot.y);
                        int alignment = -1;
                        if (SetInt(tData, "alignment", ref alignment))
                        {
                            tObj.alignment = (SpriteAlignment)alignment;
                        }
                        var node = tData["clips"];
                        if (node != null && node.IsArray)
                        {
                            var clips = node.AsArray;
                            tObj.clips = new AnimationClip[clips.Count];
                            for (int j = 0; j < tObj.clips.Length; j++)
                            {
                                tObj.clips[j] = GetAssetByID <AnimationClip>(clips[j].Value);
                            }
                        }
                        SetAssetValue(tData, "targetAnimator", ref tObj.targetAnimator);
                        SetAssetValue(tData, "targetPrefab", ref tObj.targetPrefab);

                        EditorUtility.SetDirty(tObj);
                    }
                    tID.Value          = GetIDByAsset(tObj);
                    tObj.asepriteAsset = tAsset;
                    bool tExported = CAsepriteObjectEditor.Import(tPath, tObj);

                    if (tExported)
                    {
                        tImporter.userData = tData.ToString();
                        tSaveAssets        = true;
                        tDirty             = true;
                    }
                    if (tDirty)
                    {
                        EditorUtility.SetDirty(tAsset);
                        AssetDatabase.WriteImportSettingsIfDirty(tPath);
                    }
                    EditorUtility.SetDirty(tObj);
                }
            }

            if (tSaveAssets)
            {
                AssetDatabase.SaveAssets();
            }
        }
        /// <summary>
        /// Creates a prefab using the aseprite object
        /// </summary>
        /// <param name="aObj">Aseprite object</param>
        public static void CreatePrefab(CAsepriteObject aObj)
        {
            string tPrefabPath = AssetDatabase.GetAssetPath(aObj.targetPrefab);

            if (string.IsNullOrEmpty(tPrefabPath))
            {
                string tPath = AssetDatabase.GetAssetPath(aObj.asepriteAsset);
                if (UseConfiguredTargets && !string.IsNullOrEmpty(TargetPrefabsDir))
                {
                    if (!Directory.Exists(TargetPrefabsDir))
                    {
                        Directory.CreateDirectory(TargetPrefabsDir);
                    }
                    tPrefabPath = TargetPrefabsDir + "/" +
                                  Path.GetFileNameWithoutExtension(tPath) + ".prefab";
                }
                else
                {
                    tPrefabPath = Path.GetDirectoryName(tPath) + "/" +
                                  Path.GetFileNameWithoutExtension(tPath) + ".prefab";
                }
            }
            if (tPrefabPath.StartsWith(Application.dataPath))
            {
                tPrefabPath = "Assets" + tPrefabPath.Substring(Application.dataPath.Length);
            }

            GameObject tAnimGameObject = new GameObject();

            tAnimGameObject.hideFlags = HideFlags.HideInHierarchy;
            Animator tAnimator = tAnimGameObject.AddComponent <Animator>();

            // Create or edit the animator
            CreateAnimator(aObj);

            tAnimator.runtimeAnimatorController = null;
            tAnimator.runtimeAnimatorController = aObj.targetAnimator;

            bool               tUseChild = aObj.useChild;
            SpriteRenderer     tRenderer;
            Image              tImage;
            EditorCurveBinding spriteBinding = new EditorCurveBinding();

            if (aObj.animType == AnimationType.SpriteRenderer)
            {
                spriteBinding.type = typeof(SpriteRenderer);
            }
            else if (aObj.animType == AnimationType.Image)
            {
                spriteBinding.type = typeof(Image);
            }

            spriteBinding.propertyName = "m_Sprite";
            if (tUseChild)
            {
                spriteBinding.path = CAsepriteImporter.BINDING_PATH;
            }
            else
            {
                spriteBinding.path = "";
            }

            ObjectReferenceKeyframe[] tRef = AnimationUtility.GetObjectReferenceCurve(
                aObj.clips[0], spriteBinding);
            if (aObj.animType == AnimationType.SpriteRenderer)
            {
                if (tUseChild)
                {
                    tRenderer = new GameObject(CAsepriteImporter.BINDING_PATH).AddComponent <SpriteRenderer>();
                    tRenderer.transform.SetParent(tAnimGameObject.transform);
                }
                else
                {
                    tRenderer = tAnimGameObject.AddComponent <SpriteRenderer>();
                }
                if (tRef != null && tRef.Length > 0)
                {
                    tRenderer.sprite = tRef[0].value as Sprite;
                }
                else
                {
                    Debug.LogWarning("The asset is marked as \"" + (aObj.useChild ? "don't " : "")
                                     + "use child object for animation\" but the animation seems to be configured differently."
                                     + "\nTry changing this configuration.");
                }
            }
            else if (aObj.animType == AnimationType.Image)
            {
                tAnimGameObject.AddComponent <RectTransform>();
                if (tUseChild)
                {
                    tImage = new GameObject(CAsepriteImporter.BINDING_PATH).AddComponent <Image>();
                    tImage.transform.SetParent(tAnimGameObject.transform);
                }
                else
                {
                    tImage = tAnimGameObject.AddComponent <Image>();
                }

                if (tRef != null && tRef.Length > 0)
                {
                    tImage.sprite = tRef[0].value as Sprite;
                }
                else
                {
                    Debug.LogWarning("The asset is marked as \"" + (aObj.useChild ? "don't " : "")
                                     + "use child object for animation\" but the animation seems to be configured differently."
                                     + "\nTry changing this configuration.");
                }
            }

            if (aObj.targetPrefab != null)
            {
                aObj.targetPrefab = PrefabUtility.ReplacePrefab(tAnimGameObject,
                                                                aObj.targetPrefab, ReplacePrefabOptions.ConnectToPrefab);
            }
            else
            {
#if UNITY_2019_1_OR_NEWER
                PrefabUtility.SaveAsPrefabAsset(tAnimGameObject, tPrefabPath);
                aObj.targetPrefab = AssetDatabase.LoadAssetAtPath <GameObject>(tPrefabPath);
#else
                aObj.targetPrefab = PrefabUtility.CreatePrefab(tPrefabPath, tAnimGameObject);
#endif
            }
            Selection.activeObject = aObj.targetPrefab;
            DestroyImmediate(tAnimGameObject);
            EditorUtility.SetDirty(aObj);
        }
        /// <summary>
        /// Exports a .ase file to a .json and .png file using Aseprite CLI
        /// </summary>
        /// <param name="aFile">.ase file path</param>
        /// <param name="aObj">Aseprite object</param>
        /// <returns></returns>
        public static bool Export(string aFile, CAsepriteObject aObj)
        {
            string tExePath = CAsepriteWindow.AsepriteExePath;

            if (!File.Exists(tExePath))
            {
                UnityEngine.Debug.Log("File " + tExePath + " not found");
                return(false);
            }
            // Create arguments
            string tName = Path.GetFileNameWithoutExtension(aFile);

            string tOutPath;

            if (aObj.targetTexture == null)
            {
                if (!CAsepriteWindow.UseConfiguredTargets || CAsepriteWindow.TargetDir == "")
                {
                    tOutPath = Path.GetDirectoryName(aFile);
                }
                else
                {
                    tOutPath = CAsepriteWindow.TargetDir;
                }
                if (!Directory.Exists(tOutPath))
                {
                    Directory.CreateDirectory(tOutPath);
                }

                tOutPath += "/" + tName + ".png";
            }
            else
            {
                tOutPath = AssetDatabase.GetAssetPath(aObj.targetTexture);
            }

            int    tBorder    = aObj.border;
            string tFramename = "";

            if (aObj.useTags)
            {
                tFramename = "{frame000}_{tag}";
            }
            else
            {
                tFramename = "{frame000}_{title}";
            }
            string args = "-b \"" + aFile + "\" --filename-format "
                          + tFramename + " --sheet-pack ";

            if (tBorder > 0)
            {
                args += "--inner-padding " + tBorder.ToString() + " ";
            }
            args += "--sheet \"" + tOutPath + "\"";

            // Create process
            Process tProcess = new Process();

            tProcess.StartInfo.FileName               = tExePath;
            tProcess.StartInfo.UseShellExecute        = false;
            tProcess.StartInfo.Arguments              = args;
            tProcess.StartInfo.CreateNoWindow         = true;
            tProcess.StartInfo.RedirectStandardOutput = true;
            tProcess.StartInfo.RedirectStandardError  = true;

            tProcess.EnableRaisingEvents = true;
            tProcess.Start();

            string tOutput = tProcess.StandardOutput.ReadToEnd();

            using (StreamReader s = tProcess.StandardError)
            {
                //string error = s.ReadToEnd();
                tProcess.WaitForExit(20000);
            }

            if (string.IsNullOrEmpty(tOutput))
            {
                return(false);
            }

            // Apply border to atlas
            if (tBorder > 0)
            {
                CAtlasData tData = JsonConvert.DeserializeObject <CAtlasData>(tOutput);
                foreach (CAtlasData.Frame tFrame in tData.frames.Values)
                {
                    tFrame.frame.x += tBorder;
                    tFrame.frame.w -= tBorder * 2;
                    tFrame.frame.y += tBorder;
                    tFrame.frame.h -= tBorder * 2;
                }
                tOutput = JsonConvert.SerializeObject(tData, Formatting.Indented);
            }

            string tOutJsonFilePath;

            if (aObj.targetAtlas == null)
            {
                if (!CAsepriteWindow.UseConfiguredTargets || CAsepriteWindow.TargetDir == "")
                {
                    tOutJsonFilePath = Path.GetDirectoryName(aFile);
                }
                else
                {
                    tOutJsonFilePath = CAsepriteWindow.TargetDir;
                }
                if (!Directory.Exists(tOutJsonFilePath))
                {
                    Directory.CreateDirectory(tOutJsonFilePath);
                }
                tOutJsonFilePath += "/" + tName + ".json";
            }
            else
            {
                tOutJsonFilePath = AssetDatabase.GetAssetPath(aObj.targetAtlas);
            }
            File.WriteAllText(tOutJsonFilePath, tOutput);


            if (tOutJsonFilePath.StartsWith(Application.dataPath))
            {
                tOutJsonFilePath = "Assets" + tOutJsonFilePath.Substring(Application.dataPath.Length);
            }
            if (tOutPath.StartsWith(Application.dataPath))
            {
                tOutPath = "Assets" + tOutPath.Substring(Application.dataPath.Length);
            }

            AssetDatabase.ImportAsset(tOutPath,
                                      ImportAssetOptions.ForceSynchronousImport);
            AssetDatabase.ImportAsset(tOutJsonFilePath,
                                      ImportAssetOptions.ForceSynchronousImport);

            aObj.targetAtlas   = AssetDatabase.LoadAssetAtPath <TextAsset>(tOutJsonFilePath);
            aObj.targetTexture = AssetDatabase.LoadAssetAtPath <Texture2D>(tOutPath);
            aObj.LastExport    = DateTime.Now;

            return(true);
        }