// Remove a clip specified by the given index public void RemoveClip(int a_iClipToRemoveIndex) { if (this.IsValidClipIndex(a_iClipToRemoveIndex)) { if (m_iStartClipIndex == a_iClipToRemoveIndex) { //playAutomatically = false; m_iStartClipIndex = 0; } int iClipCount = this.ClipCount; Uni2DAnimationClip[] oAnimationClips = new Uni2DAnimationClip[iClipCount - 1]; for (int iClipIndex = 0; iClipIndex < a_iClipToRemoveIndex; ++iClipIndex) { oAnimationClips[iClipIndex] = m_rAnimationClips[iClipIndex]; } for (int iClipIndex = a_iClipToRemoveIndex + 1; iClipIndex < iClipCount; ++iClipIndex) { oAnimationClips[iClipIndex - 1] = m_rAnimationClips[iClipIndex]; } m_rAnimationClips = oAnimationClips; } }
// Add a clip to the list public void AddClip(Uni2DAnimationClip a_rAnimationClip) { if (a_rAnimationClip != null) { int iClipCount = this.ClipCount; // Prevent to add a clip twice for (int iClipIndex = 0; iClipIndex < iClipCount; ++iClipIndex) { if (a_rAnimationClip == m_rAnimationClips[iClipIndex]) { return; } } Uni2DAnimationClip[] oAnimationClips = new Uni2DAnimationClip[iClipCount + 1]; if (m_rAnimationClips != null) { m_rAnimationClips.CopyTo(oAnimationClips, 0); } oAnimationClips[iClipCount] = a_rAnimationClip; m_rAnimationClips = oAnimationClips; } }
// Play the clip from the beginning public void Play(Uni2DAnimationClip a_rAnimationClip) { // Get the clip m_rCurrentClip = a_rAnimationClip; // Reset // Time m_fAnimationTime = 0.0f; m_iCurrentFrameIndex = 0; // Play mode m_eWrapMode = Uni2DAnimationClip.WrapMode.Loop; m_fFrameRate = Uni2DAnimationClip.defaultFrameRate; if (m_rCurrentClip != null) { m_eWrapMode = m_rCurrentClip.wrapMode; m_fFrameRate = m_rCurrentClip.frameRate; } // Play m_bEnabled = true; m_bPaused = false; m_bActived = true; //RaiseAnimationActiveEvent( ); // On New Frame OnNewFrame(); }
// On clip end private void OnClipEnd() { Uni2DAnimationClip rPreviousClip = m_rCurrentClip; switch (m_eWrapMode) { case Uni2DAnimationClip.WrapMode.Loop: { } break; case Uni2DAnimationClip.WrapMode.PingPong: { } break; case Uni2DAnimationClip.WrapMode.Once: { Stop(true); } break; case Uni2DAnimationClip.WrapMode.ClampForever: { } break; } RaiseAnimationEndEvent(rPreviousClip); }
// Raise animation end event private void RaiseAnimationEndEvent(Uni2DAnimationClip a_rAnimationClip) { if (onAnimationEndEvent != null) { onAnimationEndEvent(this, a_rAnimationClip); } }
// Raise animation end event private void RaiseAnimationEndEvent(Uni2DAnimationPlayer a_rAnimationPlayer, Uni2DAnimationClip a_rAnimationClip) { if (onAnimationEndEvent != null) { onAnimationEndEvent(new Uni2DAnimationEvent(this, this.GetClipIndexByName(a_rAnimationClip.name), a_rAnimationClip)); } }
// Constructor public Uni2DAnimationFrameEvent(Uni2DSpriteAnimation a_rSpriteAnimation, int a_iClipIndex, Uni2DAnimationClip a_rClip, int a_iFrameIndex, Uni2DAnimationFrame a_rFrame) { spriteAnimation = a_rSpriteAnimation; clipIndex = a_iClipIndex; clip = a_rClip; frameIndex = a_iFrameIndex; frame = a_rFrame; }
// Displays an animation clip header public static AnimationGUIAction DisplayCompactAnimationClipHeader(Uni2DAnimationClip a_rAnimationClip, Uni2DAnimationPlayer a_rAnimationPreviewPlayer, int a_iClipIndex = -1) { AnimationGUIAction eAction; Uni2DEditorGUIUtils.DoDisplayAnimationClipHeader(a_rAnimationClip, a_rAnimationPreviewPlayer, out eAction, true, false, a_iClipIndex); return(eAction); }
private static void ApplySettings(Uni2DAnimationClip[] a_rAnimationClips, AnimationClipRegeneration a_eRegenerate) { int iClipCount = a_rAnimationClips.Length; if (iClipCount == 1) { a_rAnimationClips[0].ApplySettings(a_eRegenerate); } else if (iClipCount > 1) { // Apply clip settings first, atlases will be generated only after // (Atlases can be shared accross clips, so prevent them to be uselessly regenerated several times) HashSet <Uni2DTextureAtlas> oAtlases = new HashSet <Uni2DTextureAtlas>( ); for (int iClipIndex = 0; iClipIndex < iClipCount; ++iClipIndex) { Uni2DAnimationClip rAnimationClip = a_rAnimationClips[iClipIndex]; Uni2DTextureAtlas rGlobalAtlas = rAnimationClip.globalAtlas; if (rGlobalAtlas != null) { // Add the atlas if not already added if (a_eRegenerate == AnimationClipRegeneration.RegenerateAll || (a_eRegenerate == AnimationClipRegeneration.RegenerateAlsoAtlasIfNeeded && (rGlobalAtlas.UnappliedSettings || rGlobalAtlas.Contains(rAnimationClip.GetAllFramesTextureGUIDs( )) == false))) { oAtlases.Add(rGlobalAtlas); } } else // Null => atlas per frame { for (int iFrameIndex = 0, iFrameCount = rAnimationClip.FrameCount; iFrameIndex < iFrameCount; ++iFrameIndex) { Uni2DAnimationFrame rFrame = rAnimationClip.frames[iFrameIndex]; Uni2DTextureAtlas rFrameAtlas = rFrame.atlas; if (rFrameAtlas != null && (a_eRegenerate == AnimationClipRegeneration.RegenerateAll || (a_eRegenerate == AnimationClipRegeneration.RegenerateAlsoAtlasIfNeeded && (rFrameAtlas.UnappliedSettings || rFrameAtlas.Contains(rFrame.textureContainer.GUID) == false)))) { oAtlases.Add(rFrameAtlas); } } } // Regenerate clips only rAnimationClip.ApplySettings(AnimationClipRegeneration.RegenerateAnimationClipOnly); } // Then, regenerate atlases foreach (Uni2DTextureAtlas rAtlas in oAtlases) { rAtlas.ApplySettings( ); } } }
public static Uni2DAnimationClip CreateAnimationClip(List <Texture2D> a_rTexturesList, string a_rAnimationClipName = null, string a_rAnimationClipPath = null) { // Create a new animation clip prefab GameObject oModel = new GameObject( ); Uni2DAnimationClip oAnimationClipModel = oModel.AddComponent <Uni2DAnimationClip>( ); // Path to save prefab string oPrefabPath; if (a_rTexturesList != null && a_rTexturesList.Count > 0) { // Sort by name IOrderedEnumerable <Texture2D> rOrderedTexturesEnumerable = a_rTexturesList.OrderBy(x => x.name); Texture2D rFirstTexture = rOrderedTexturesEnumerable.First( ); // Create frames foreach (Texture2D rTexture in rOrderedTexturesEnumerable) { Uni2DAnimationFrame oAnimationFrame = new Uni2DAnimationFrame( ); oAnimationFrame.textureContainer = new Texture2DContainer(rTexture, true); oAnimationClipModel.frames.Add(oAnimationFrame); } // Apply oAnimationClipModel.ApplySettings(Uni2DAnimationClip.AnimationClipRegeneration.RegenerateAnimationClipOnly); oPrefabPath = (a_rAnimationClipPath == null ? Uni2DEditorUtils.GetLocalAssetFolderPath(rFirstTexture) : a_rAnimationClipPath) + (a_rAnimationClipName == null ? ("AnimationClip_" + rFirstTexture.name) : a_rAnimationClipName) + ".prefab"; // Make prefab path unique oPrefabPath = AssetDatabase.GenerateUniqueAssetPath(oPrefabPath); } else { // Unique prefab path string oClipName = (a_rAnimationClipName == null ? mc_oAnimationClipDefaultName : a_rAnimationClipName); oPrefabPath = (a_rAnimationClipPath == null ? Uni2DEditorUtils.GenerateNewPrefabLocalPath(oClipName) : AssetDatabase.GenerateUniqueAssetPath(a_rAnimationClipPath + oClipName)); } // Save it as a prefab GameObject oPrefab = PrefabUtility.CreatePrefab(oPrefabPath, oModel); // Destroy model GameObject.DestroyImmediate(oModel); // Return prefab animation clip component return(oPrefab.GetComponent <Uni2DAnimationClip>( )); }
private void DisplayBuilder( ) { bool bCreateSprite = false; bool bCreatePhysicSprite = false; bool bCreateAnimationClip = false; EditorGUILayout.BeginHorizontal( ); { EditorGUI.BeginDisabledGroup(m_rSelectedObjects == null || m_rSelectedObjects.Length == 0); { bCreateSprite = GUILayout.Button(mc_oGUILabelCreateSprite); bCreatePhysicSprite = GUILayout.Button(mc_oGUILabelCreatePhysicSprite); bCreateAnimationClip = GUILayout.Button(mc_oGUILabelCreateAnimationClip); } EditorGUI.EndDisabledGroup( ); } EditorGUILayout.EndHorizontal( ); if (bCreateSprite == true || bCreatePhysicSprite == true) { if (m_rSelectedObjects != null) { List <GameObject> oCreatedGameObjects = new List <GameObject>(); foreach (Object rObject in m_rSelectedObjects) { Texture2D rTexture = (Texture2D)rObject; // Create sprite GameObject oSpriteMeshGameObject = CreateSprite(rTexture, ComputeCreateFromButtonPositionWorld(SceneView.lastActiveSceneView), bCreatePhysicSprite); oCreatedGameObjects.Add(oSpriteMeshGameObject); } // Update editor selection Selection.objects = oCreatedGameObjects.ToArray(); EditorUtility.UnloadUnusedAssets( ); } } else if (bCreateAnimationClip) { List <Texture2D> oTexturesList = null; if (m_rSelectedObjects != null) { // Object -> Texture2D cast oTexturesList = m_rSelectedObjects.Cast <Texture2D>( ).ToList( ); } Uni2DAnimationClip rAnimationClip = Uni2DEditorSpriteBuilderWindow.CreateAnimationClip(oTexturesList); Selection.objects = new Object[1] { rAnimationClip.gameObject }; } }
public static bool AddClipPopup(string a_rLabel, out Uni2DAnimationClip a_rAnimationClip, params GUILayoutOption[] a_rGUILayoutOptions) { bool bHasChanged; // Get button control ID int iControlID = GUIUtility.GetControlID(FocusType.Passive); EditorGUI.BeginChangeCheck( ); { // Get selected value for our control // If no PopupCallbackInfo instance exists, the returned value is a_rClip a_rAnimationClip = PopupCallbackInfo <Uni2DAnimationClip> .GetSelectedValueForControl(iControlID, null); } bHasChanged = EditorGUI.EndChangeCheck( ); // Create a new generic menu // Each item menu will use AtlasPopupCallback as callback // AtlasPopupCallback will perform the logic and save the selected atlas to // the PopupCallbackInfo instance. if (GUILayout.Button(a_rLabel, a_rGUILayoutOptions)) { // Create a new popup callback info (control ID) and save it as current instance PopupCallbackInfo <Uni2DAnimationClip> .instance = new PopupCallbackInfo <Uni2DAnimationClip>(iControlID, null); // Create our generic menu GenericMenu oPopupMenu = new GenericMenu( ); // "Create" special item menu oPopupMenu.AddItem(new GUIContent("Create a new animation clip...", "Creates a new Uni2D animation clip"), false, ClipPopupCallback, "NEW"); Uni2DEditorAssetTable rAssetTable = Uni2DEditorAssetTable.Instance; // List all available atlases Dictionary <string, string> oAvailableAnimationClips = rAssetTable.GetAllClipNames( ); if (oAvailableAnimationClips.Count != 0) { oPopupMenu.AddSeparator(""); // Add an item menu for each ready to use atlas foreach (KeyValuePair <string, string> rAnimationClipNameGUIDPair in oAvailableAnimationClips) { oPopupMenu.AddItem(new GUIContent(rAnimationClipNameGUIDPair.Value), false, ClipPopupCallback, rAnimationClipNameGUIDPair.Key); } } // Finally show up the menu oPopupMenu.ShowAsContext( ); } return(bHasChanged); }
private void ApplyAnimationClipGlobalAtlas(Uni2DTextureAtlas a_rGlobalAtlas) { for (int iClipIndex = 0, iClipCount = this.targets.Length; iClipIndex < iClipCount; ++iClipIndex) { Uni2DAnimationClip rAnimationClip = (Uni2DAnimationClip)this.targets[iClipIndex]; rAnimationClip.globalAtlas = a_rGlobalAtlas; for (int iFrameIndex = 0, iFrameCount = rAnimationClip.FrameCount; iFrameIndex < iFrameCount; ++iFrameIndex) { rAnimationClip.frames[iFrameIndex].atlas = a_rGlobalAtlas; } EditorUtility.SetDirty(rAnimationClip); } }
///// Inspector utils ///// private void CheckClipsAndAtlasSynced( ) { for (int iClipIndex = 0, iClipCount = targets.Length; iClipIndex < iClipCount; ++iClipIndex) { if (targets[iClipIndex] != null) { Uni2DAnimationClip rAnimationClip = (Uni2DAnimationClip)targets[iClipIndex]; if (rAnimationClip.AreClipAndAtlasSynced( ) == false) { m_bAreClipsAndAtlasSynced = false; return; } } } m_bAreClipsAndAtlasSynced = true; }
// Stop playing the current clip public void Stop(bool a_bResetToMainFrame = true) { m_bEnabled = false; m_bPaused = false; if (a_bResetToMainFrame) { //m_rSprite.ResetToMainFrame(); m_bActived = false; m_rCurrentClip = null; m_iCurrentFrameIndex = 0; m_fAnimationTime = 0; // Notify animation inactivity RaiseAnimationInactiveEvent( ); } }
// Deletes null animation clip references (which appear after deleting a clip resource) public void CleanDeletedAnimationClips( ) { Uni2DAnimationClip rStartAnimationClip = playAutomatically ? m_rAnimationClips[m_iStartClipIndex] : null; // LINQ: Select only non null clips m_rAnimationClips = m_rAnimationClips.Where(x => x != null).ToArray( ); if (rStartAnimationClip != null) { m_iStartClipIndex = ArrayUtility.IndexOf <Uni2DAnimationClip>(m_rAnimationClips, rStartAnimationClip); } else { // Turn off auto play if clip array is empty playAutomatically = (m_rAnimationClips.Length > 0 ? playAutomatically : false); m_iStartClipIndex = 0; } }
// Swaps 2 clips specified by their index public void SwapClips(int a_iClipIndexA, int a_iClipIndexB) { if (a_iClipIndexA != a_iClipIndexB && this.IsValidClipIndex(a_iClipIndexA) && this.IsValidClipIndex(a_iClipIndexB)) { // Update start clip index if (a_iClipIndexA == m_iStartClipIndex) { m_iStartClipIndex = a_iClipIndexB; } else if (a_iClipIndexB == m_iStartClipIndex) { m_iStartClipIndex = a_iClipIndexA; } // Swap clips Uni2DAnimationClip rTmp = m_rAnimationClips[a_iClipIndexA]; m_rAnimationClips[a_iClipIndexA] = m_rAnimationClips[a_iClipIndexB]; m_rAnimationClips[a_iClipIndexB] = rTmp; } }
private GameObject[] CreateSpritesFromDragAndDrop(List <Texture2D> a_rTexturesList, Vector3 a_f3Position, bool a_bPhysic, bool a_bCreateAnimationClip) { GameObject[] oGeneratedSprites; // Create an animation clip from selected textures if (a_bCreateAnimationClip) { oGeneratedSprites = new GameObject[1]; // Create clip Uni2DAnimationClip rAnimationClip = this.CreateAnimationClip(a_rTexturesList); // Create a sprite from first animation frame GameObject rSpriteGameObject = this.CreateSprite(rAnimationClip.frames[0].textureContainer, a_f3Position, a_bPhysic); // Add clip to sprite animation Uni2DSpriteAnimation rSpriteAnimation = rSpriteGameObject.GetComponent <Uni2DSprite>( ).spriteAnimation; rSpriteAnimation.AddClip(rAnimationClip); // Set auto play rSpriteAnimation.playAutomatically = true; rSpriteAnimation.StartClipIndex = 0; // Add to generated sprites oGeneratedSprites[0] = rSpriteGameObject; } else { int iTextureCount = a_rTexturesList.Count; oGeneratedSprites = new GameObject[iTextureCount]; for (int iTextureIndex = 0; iTextureIndex < iTextureCount; ++iTextureIndex) { oGeneratedSprites[iTextureIndex] = this.CreateSprite(a_rTexturesList[iTextureIndex], a_f3Position, a_bPhysic); } } return(oGeneratedSprites); }
// Displays a preview of an animation clip at given position rect // The animation is played when the mouse is hovering the preview public static void DrawAnimationClipPreview(Rect a_rPositionRect, Uni2DAnimationClip a_rAnimationClip, Uni2DAnimationPlayer a_rAnimationPlayer) { Uni2DAnimationFrame rFrame; Texture2D rFrameTexture; if (a_rPositionRect.Contains(Event.current.mousePosition)) // If mouse hovering preview rect... { if (a_rAnimationPlayer.Enabled == false || a_rAnimationPlayer.Clip != a_rAnimationClip) // ... and player not enabled or not set with current clip... { a_rAnimationPlayer.Play(a_rAnimationClip); // ... play clip } rFrame = a_rAnimationPlayer.Frame; } else if (Event.current.type != EventType.Layout && a_rAnimationPlayer.Enabled && a_rAnimationPlayer.Clip == a_rAnimationClip) // Stop player if playing current clip { a_rAnimationPlayer.Stop(false); a_rAnimationPlayer.FrameIndex = 0; rFrame = a_rAnimationPlayer.Frame; } else // Use first clip frame otherwise (if any) { rFrame = a_rAnimationClip != null && a_rAnimationClip.frames != null && a_rAnimationClip.frames.Count > 0 ? a_rAnimationClip.frames[0] : null; } if (rFrame == null || rFrame.textureContainer == null || rFrame.textureContainer.Texture == null) { rFrameTexture = EditorGUIUtility.whiteTexture; } else { rFrameTexture = rFrame.textureContainer; } EditorGUI.DrawPreviewTexture(a_rPositionRect, rFrameTexture); return; }
// Raise animation end event private void RaiseAnimationEndEvent( Uni2DAnimationPlayer a_rAnimationPlayer, Uni2DAnimationClip a_rAnimationClip ) { if( onAnimationEndEvent != null ) { onAnimationEndEvent( new Uni2DAnimationEvent( this, this.GetClipIndexByName( a_rAnimationClip.name ), a_rAnimationClip ) ); } }
// On anim length change private void OnWrapModeChange(Uni2DAnimationClip.WrapMode a_eWrapModePrevious, float a_fFrameShowTimeElapsed) { if(a_eWrapModePrevious == Uni2DAnimationClip.WrapMode.PingPong || m_eWrapMode == Uni2DAnimationClip.WrapMode.PingPong) { if(a_eWrapModePrevious == Uni2DAnimationClip.WrapMode.PingPong) { m_iCurrentFrameIndex = (int)Mathf.PingPong(m_iCurrentFrameIndex, FrameCount - 1); } // Compute the time the image has been show until then m_fAnimationTime = ComputeAnimationTimeFromFrame() + a_fFrameShowTimeElapsed; } }
// Constructor public Uni2DAnimationEvent(Uni2DSpriteAnimation a_rSpriteAnimation, int a_iClipIndex, Uni2DAnimationClip a_rClip) { spriteAnimation = a_rSpriteAnimation; clipIndex = a_iClipIndex; clip = a_rClip; }
public void Rebuild( ) { //Debug.Log( "Rebuilding Uni2D Asset Table..." ); m_oAtlasGUIDSpritePrefabGUIDsMultiDict.Clear( ); m_oTextureGUIDAtlasGUIDsMultiDict.Clear( ); m_oTextureGUIDClipGUIDsMultiDict.Clear( ); m_oTextureGUIDSpritePrefabGUIDsMultiDict.Clear( ); m_oAtlasPathGUIDDict.Clear( ); m_oClipPathGUIDDict.Clear( ); // Iterate project's assets string[] rAssetPaths = AssetDatabase.GetAllAssetPaths( ); int iAssetCount = rAssetPaths.Length; float fInvAssetCount = 1.0f / (float)iAssetCount; int iProcessedAssets = 0; try { foreach (string rPath in rAssetPaths) { EditorUtility.DisplayProgressBar("Uni2D - Asset Table Rebuilding Progress", iProcessedAssets + " out of " + iAssetCount + " asset(s) processed...", fInvAssetCount * iProcessedAssets); Object rAssetObject = null; // Might be an atlas or a clip if (rPath.EndsWith(".prefab")) { rAssetObject = AssetDatabase.LoadAssetAtPath(rPath, typeof(Uni2DTextureAtlas)); if (rAssetObject != null) // It's an atlas { Uni2DTextureAtlas rAtlasAsset = (Uni2DTextureAtlas)rAssetObject; string rAtlasGUID = AssetDatabase.AssetPathToGUID(rPath); foreach (string rTextureGUID in rAtlasAsset.GetTextureGUIDs( )) { this.AddAtlasUsingTexture(rAtlasGUID, rTextureGUID); } m_oAtlasPathGUIDDict.Add(rPath, rAtlasGUID); rAtlasAsset = null; EditorUtility.UnloadUnusedAssets( ); } rAssetObject = AssetDatabase.LoadAssetAtPath(rPath, typeof(Uni2DAnimationClip)); if (rAssetObject != null) // It's an animation clip { Uni2DAnimationClip rAnimationClipAsset = (Uni2DAnimationClip)rAssetObject; string rAnimationClipGUID = AssetDatabase.AssetPathToGUID(rPath); foreach (string rTextureGUID in rAnimationClipAsset.GetAllFramesTextureGUIDs( )) { this.AddClipUsingTexture(rAnimationClipGUID, rTextureGUID); } m_oClipPathGUIDDict.Add(rPath, rAnimationClipGUID); rAnimationClipAsset = null; EditorUtility.UnloadUnusedAssets( ); } rAssetObject = AssetDatabase.LoadAssetAtPath(rPath, typeof(GameObject)); if (rAssetObject != null) // It's a sprite prefab { GameObject rPrefabAsset = (GameObject)rAssetObject; string rPrefabGUID = AssetDatabase.AssetPathToGUID(rPath); Uni2DSprite[] rSpritePrefabComponents = rPrefabAsset.GetComponentsInChildren <Uni2DSprite>(true); foreach (Uni2DSprite rSpritePrefabComponent in rSpritePrefabComponents) { Uni2DEditorSpriteSettings rSpriteSettings = rSpritePrefabComponent.SpriteSettings; this.AddSpritePrefabUsingTexture(rPrefabGUID, rSpriteSettings.textureContainer.GUID); if (rSpriteSettings.atlas != null) { this.AddSpritePrefabUsingAtlas(rPrefabGUID, Uni2DEditorUtils.GetUnityAssetGUID(rSpriteSettings.atlas)); } } rPrefabAsset = null; rSpritePrefabComponents = null; EditorUtility.UnloadUnusedAssets( ); } } ++iProcessedAssets; } } finally { this.Save( ); EditorUtility.UnloadUnusedAssets( ); EditorUtility.SetDirty(this); EditorUtility.ClearProgressBar( ); } //Debug.Log( "Uni2D Asset Table Rebuild: Done." ); }
private static void OnPostprocessAllAssets(string[] a_rImportedAssets, string[] a_rDeletedAssets, string[] a_rMovedAssets, string[] a_rMovedFromPath) { if (ms_bEnabled) { bool bUpdateAssets = false; bool bPostprocessPrefabs = false; bool bSaveTable = false; Uni2DEditorAssetTable rAssetTable = Uni2DEditorAssetTable.Instance; foreach (string rImportedAssetPath in a_rImportedAssets) { // Check if the asset isn't re-processed due to a call to GenerateTextureImportGUID if (ms_oImportedTexturesWithUpdatedUni2DGUIDs.Contains(rImportedAssetPath) == false) { Texture2D rImportedTexture = (Texture2D)AssetDatabase.LoadAssetAtPath(rImportedAssetPath, typeof(Texture2D)); if (rImportedTexture != null) { //Debug.Log ( "Imported " + rImportedAssetPath ); string rImportedTextureGUID = AssetDatabase.AssetPathToGUID(rImportedAssetPath); ms_oImportedTextureGUIDs.Add(rImportedTextureGUID); if (Uni2DEditorUtils.ItIsTheFirstTimeWeUseTheTexture(rImportedTexture)) { Uni2DEditorSpriteBuilderUtils.SetDefaultTextureImporterSettings(rImportedTexture, false); } // This call will produce an unvoidable import of the texture (didn't find out how to prevent it) Uni2DEditorUtils.GenerateTextureImportGUID(rImportedTexture); // ... so, save the path reference to avoid to re-process it again ms_oImportedTexturesWithUpdatedUni2DGUIDs.Add(rImportedAssetPath); bUpdateAssets = true; rImportedTexture = null; EditorUtility.UnloadUnusedAssets( ); continue; } Uni2DTextureAtlas rImportedAtlas = (Uni2DTextureAtlas)AssetDatabase.LoadAssetAtPath(rImportedAssetPath, typeof(Uni2DTextureAtlas)); if (rImportedAtlas != null) { //Debug.Log ( "Imported atlas " + rImportedAssetPath ); bSaveTable = true; rAssetTable.AddAtlasPath(rImportedAssetPath, AssetDatabase.AssetPathToGUID(rImportedAssetPath)); rImportedAtlas = null; EditorUtility.UnloadUnusedAssets( ); continue; } Uni2DAnimationClip rImportedClip = (Uni2DAnimationClip)AssetDatabase.LoadAssetAtPath(rImportedAssetPath, typeof(Uni2DAnimationClip)); if (rImportedClip != null) { //Debug.Log ( "Imported clip " + rImportedClip ); bSaveTable = true; rAssetTable.AddClipPath(rImportedAssetPath, AssetDatabase.AssetPathToGUID(rImportedAssetPath)); rImportedClip = null; EditorUtility.UnloadUnusedAssets( ); continue; } GameObject rImportedGameObject = (GameObject)AssetDatabase.LoadAssetAtPath(rImportedAssetPath, typeof(GameObject)); if (rImportedGameObject != null) { //Debug.Log ( "Imported game object " + rImportedAssetPath ); ms_oGameObjectGUIDsToPostProcess.Add(AssetDatabase.AssetPathToGUID(rImportedAssetPath)); bPostprocessPrefabs = true; rImportedGameObject = null; EditorUtility.UnloadUnusedAssets( ); } } else { // ... remove the asset path from our list if it was already processed ms_oImportedTexturesWithUpdatedUni2DGUIDs.Remove(rImportedAssetPath); } } // Moved assets for (int iIndex = 0, iCount = a_rMovedAssets.Length; iIndex < iCount; ++iIndex) { //Debug.Log ( "Importing moved asset" ); Uni2DTextureAtlas rMovedAtlas = (Uni2DTextureAtlas)AssetDatabase.LoadAssetAtPath(a_rMovedAssets[iIndex], typeof(Uni2DTextureAtlas)); if (rMovedAtlas != null) { rAssetTable.RemoveAtlasFromPath(a_rMovedFromPath[iIndex], false); rAssetTable.AddAtlasPath(a_rMovedAssets[iIndex], AssetDatabase.AssetPathToGUID(a_rMovedAssets[iIndex])); bSaveTable = true; rMovedAtlas = null; EditorUtility.UnloadUnusedAssets( ); continue; } Uni2DAnimationClip rMovedClip = (Uni2DAnimationClip)AssetDatabase.LoadAssetAtPath(a_rMovedAssets[iIndex], typeof(Uni2DAnimationClip)); if (rMovedClip != null) { rAssetTable.RemoveClipFromPath(a_rMovedFromPath[iIndex], false); rAssetTable.AddClipPath(a_rMovedAssets[iIndex], AssetDatabase.AssetPathToGUID(a_rMovedAssets[iIndex])); bSaveTable = true; rMovedClip = null; EditorUtility.UnloadUnusedAssets( ); } } // Deleted assets foreach (string rDeletedAsset in a_rDeletedAssets) { string[] rSpritePrefabGUIDs = rAssetTable.GetSpritePrefabGUIDsUsingThisAtlasPath(rDeletedAsset); if (rSpritePrefabGUIDs.Length > 0) { bUpdateAssets = true; ms_oSpritePrefabGUIDsToUpdate.UnionWith(rSpritePrefabGUIDs); } /* * // TODO: mettre des paths au lieu d'IDs * string[ ] rClipGUIDs = rAssetTable.GetClipGUIDsUsingThisTexturePath( rDeletedAsset ); * if( rClipGUIDs.Length > 0 ) * { * bUpdateAssets = true; * ms_oAnimationClipGUIDsToUpdate.UnionWith( rClipGUIDs ); * } */ bSaveTable = rAssetTable.RemoveAtlasFromPath(rDeletedAsset, true) || bSaveTable; bSaveTable = rAssetTable.RemoveClipFromPath(rDeletedAsset, true) || bSaveTable; } if (bSaveTable) { rAssetTable.Save( ); } if (bUpdateAssets) { ms_oAtlasGUIDsToUpdate.UnionWith(rAssetTable.GetAtlasGUIDsUsingTheseTextures(ms_oImportedTextureGUIDs)); ms_oAnimationClipGUIDsToUpdate.UnionWith(rAssetTable.GetClipGUIDsUsingTheseTextures(ms_oImportedTextureGUIDs)); ms_oSpritePrefabGUIDsToUpdate.UnionWith(rAssetTable.GetSpritePrefabGUIDsUsingTheseTextures(ms_oImportedTextureGUIDs)); ms_oSpritePrefabGUIDsToUpdate.UnionWith(rAssetTable.GetSpritePrefabGUIDsUsingTheseAtlases(ms_oAtlasGUIDsToUpdate)); EditorApplication.delayCall += UpdateUni2DAssets; } if (bPostprocessPrefabs) { EditorApplication.delayCall += OnSpritePrefabPostprocess; } } }
private static void UpdateUni2DAssets( ) { EditorApplication.delayCall -= UpdateUni2DAssets; Uni2DEditorAssetTable rAssetTable = Uni2DEditorAssetTable.Instance; try { Uni2DAssetPostprocessor.LockTo(false); // Update animation clips first, because they can change the atlases foreach (string rAnimationClipGUID in ms_oAnimationClipGUIDsToUpdate) { Uni2DAnimationClip rAnimationClip = Uni2DEditorUtils.GetAssetFromUnityGUID <Uni2DAnimationClip>(rAnimationClipGUID); if (rAnimationClip != null) { //Debug.Log ( "Updating clip " + rAnimationClipGUID ); rAnimationClip.OnTexturesChange(ms_oImportedTextureGUIDs); rAnimationClip = null; EditorUtility.UnloadUnusedAssets( ); } else { // Clean asset table foreach (string rTextureGUID in ms_oImportedTextureGUIDs) { rAssetTable.RemoveClipUsingTexture(rAnimationClipGUID, rTextureGUID); } } } foreach (string rAtlasGUID in ms_oAtlasGUIDsToUpdate) { Uni2DTextureAtlas rAtlas = Uni2DEditorUtils.GetAssetFromUnityGUID <Uni2DTextureAtlas>(rAtlasGUID); if (rAtlas != null) { //Debug.Log( "Updating atlas " + rAtlasGUID ); rAtlas.OnTextureChange( ); rAtlas = null; EditorUtility.UnloadUnusedAssets( ); } else { // Clean foreach (string rTextureGUID in ms_oImportedTextureGUIDs) { rAssetTable.RemoveAtlasUsingTexture(rAtlasGUID, rTextureGUID); } } } foreach (string rSpritePrefabGUID in ms_oSpritePrefabGUIDsToUpdate) { GameObject rSpritePrefab = Uni2DEditorUtils.GetAssetFromUnityGUID <GameObject>(rSpritePrefabGUID); if (rSpritePrefab != null) { //Debug.Log( "Updating sprite prefab " + rSpritePrefabGUID ); foreach (Uni2DSprite rSpritePrefabComponent in rSpritePrefab.GetComponentsInChildren <Uni2DSprite>(true)) { Uni2DEditorSpriteSettings rSpriteSettings = rSpritePrefabComponent.SpriteSettings; string rSpriteTextureGUID = rSpriteSettings.textureContainer.GUID; string rSpriteAtlasGUID = rSpriteSettings.atlas != null?Uni2DEditorUtils.GetUnityAssetGUID(rSpriteSettings.atlas) : null; if (ms_oImportedTextureGUIDs.Contains(rSpriteTextureGUID) || (!string.IsNullOrEmpty(rSpriteAtlasGUID) && ms_oAtlasGUIDsToUpdate.Contains(rSpriteAtlasGUID))) { rSpritePrefabComponent.Regenerate(true); } EditorUtility.UnloadUnusedAssets( ); } rSpritePrefab = null; EditorUtility.UnloadUnusedAssets( ); } else { // Clean foreach (string rTextureGUID in ms_oImportedTextureGUIDs) { rAssetTable.RemoveSpritePrefabUsingTexture(rSpritePrefabGUID, rTextureGUID); } foreach (string rAtlasGUID in ms_oAtlasGUIDsToUpdate) { rAssetTable.RemoveSpritePrefabUsingAtlas(rSpritePrefabGUID, rAtlasGUID); } } } } finally { ms_oImportedTextureGUIDs.Clear( ); ms_oAtlasGUIDsToUpdate.Clear( ); ms_oAnimationClipGUIDsToUpdate.Clear( ); ms_oSpritePrefabGUIDsToUpdate.Clear( ); rAssetTable.Save( ); Uni2DAssetPostprocessor.Unlock( ); Uni2DAssetPostprocessor.Enabled = true; } }
// Remove a clip specified by the given index public void RemoveClip( int a_iClipToRemoveIndex ) { if( this.IsValidClipIndex( a_iClipToRemoveIndex ) ) { if( m_iStartClipIndex == a_iClipToRemoveIndex ) { //playAutomatically = false; m_iStartClipIndex = 0; } int iClipCount = this.ClipCount; Uni2DAnimationClip[ ] oAnimationClips = new Uni2DAnimationClip[ iClipCount - 1 ]; for( int iClipIndex = 0; iClipIndex < a_iClipToRemoveIndex; ++iClipIndex ) { oAnimationClips[ iClipIndex ] = m_rAnimationClips[ iClipIndex ]; } for( int iClipIndex = a_iClipToRemoveIndex + 1; iClipIndex < iClipCount; ++iClipIndex ) { oAnimationClips[ iClipIndex - 1 ] = m_rAnimationClips[ iClipIndex ]; } m_rAnimationClips = oAnimationClips; } }
public override void OnInspectorGUI( ) { // Update animation player used in clip header m_oAnimationPlayerClipHeader.Update(this.ComputeDeltaTime(ref m_lLastTimeTicks)); // Atlas bool bHasMultipleDifferentGlobalAtlasValues; Uni2DTextureAtlas rGlobalAtlas; this.GetGlobalAtlas(out rGlobalAtlas, out bHasMultipleDifferentGlobalAtlasValues); // Atlas size AtlasSize eMaximumAtlasSize = AtlasSize._2048; //SerializedSetting<EAtlasSize> oSerializedSetting_MaximumAtlasSize; // Selected object count int iTargetObjectCount = targets.Length; bool bDisplayFrames = (iTargetObjectCount == 1); EditorGUI.BeginDisabledGroup(Application.isPlaying); { EditorGUILayout.BeginVertical( ); { if (bDisplayFrames == false) { EditorGUILayout.HelpBox("Animation Clip edition is restricted when inspecting multiple clips, but you can change the atlas settings to pack the clips together.", MessageType.Info, true); } if (m_bAreClipsAndAtlasSynced == false) { EditorGUILayout.HelpBox("At least one animation frame is referencing an atlas which does not contain its texture.\nPlease regenerate the clip or manually add the frame texture to the atlas.", MessageType.Error, true); } ///// Atlas section ///// ms_bAtlasFoldout = EditorGUILayout.Foldout(ms_bAtlasFoldout, "Atlas"); if (ms_bAtlasFoldout) { bool bHasAtlasSettingsChanged; bool bHasAtlasChanged; ++EditorGUI.indentLevel; { EditorGUILayout.BeginVertical( ); { EditorGUILayout.BeginHorizontal( ); { EditorGUILayout.PrefixLabel("Use Atlas"); // Atlas popup EditorGUI.BeginChangeCheck( ); { EditorGUI.showMixedValue = bHasMultipleDifferentGlobalAtlasValues; { rGlobalAtlas = Uni2DEditorGUIUtils.AtlasPopup(rGlobalAtlas, m_oTextureGUIDs); } EditorGUI.showMixedValue = false; } bHasAtlasChanged = EditorGUI.EndChangeCheck( ); // Atlas select button EditorGUI.BeginDisabledGroup(rGlobalAtlas == null); { if (GUILayout.Button("Select", GUILayout.Width(80.0f))) { EditorGUIUtility.PingObject(rGlobalAtlas.gameObject); } } EditorGUI.EndDisabledGroup( ); } EditorGUILayout.EndHorizontal( ); // Atlas max size EditorGUI.BeginChangeCheck( ); { EditorGUI.BeginDisabledGroup((bHasAtlasChanged == false && bHasMultipleDifferentGlobalAtlasValues) || rGlobalAtlas == null); { eMaximumAtlasSize = (AtlasSize)EditorGUILayout.EnumPopup("Maximum Atlas Size", rGlobalAtlas != null ? rGlobalAtlas.maximumAtlasSize : eMaximumAtlasSize); } EditorGUI.EndDisabledGroup( ); } bHasAtlasSettingsChanged = EditorGUI.EndChangeCheck( ); } EditorGUILayout.EndVertical( ); } --EditorGUI.indentLevel; if (rGlobalAtlas != null && bHasAtlasSettingsChanged) { rGlobalAtlas.maximumAtlasSize = eMaximumAtlasSize; EditorUtility.SetDirty(rGlobalAtlas); } if (bHasAtlasChanged) { this.ApplyAnimationClipGlobalAtlas(rGlobalAtlas); } } EditorGUILayout.Space( ); ///// Animation Clip Header ///// for (int iClipIndex = 0, iClipCount = iTargetObjectCount; iClipIndex < iClipCount; ++iClipIndex) { Uni2DAnimationClip rAnimationClip = (Uni2DAnimationClip)this.targets[iClipIndex]; int iFrameCount = rAnimationClip.FrameCount; this.UpdateClipsFoldouts(iClipIndex, iFrameCount); bool bClipHeaderFoldout = this.GetClipFoldout(iClipIndex); EditorGUI.BeginDisabledGroup(bDisplayFrames == false); { EditorGUI.BeginChangeCheck( ); { bClipHeaderFoldout = Uni2DEditorGUIUtils.DisplayAnimationClipHeader(rAnimationClip, m_oAnimationPlayerClipHeader, bClipHeaderFoldout); } if (EditorGUI.EndChangeCheck( ) && bDisplayFrames) { // Update animation preview player settings m_oAnimationPlayerClipPreview.FrameRate = rAnimationClip.frameRate; m_oAnimationPlayerClipPreview.WrapMode = rAnimationClip.wrapMode; } } EditorGUI.EndDisabledGroup( ); this.SetClipFoldout(bClipHeaderFoldout, iClipIndex); ///// Clip frames section ///// if (bDisplayFrames && bClipHeaderFoldout) { EditorGUILayout.BeginHorizontal( ); { // Dummy space GUILayout.Space(32.0f); EditorGUILayout.BeginVertical( ); { // Display all frames for (int iFrameIndex = 0; iFrameIndex < iFrameCount; ++iFrameIndex) { // Display animation frame AnimationGUIAction eAction; // = AnimationGUIAction.None; bool bFrameFoldout = this.GetClipFoldout(iClipIndex, iFrameIndex); EditorGUI.BeginChangeCheck( ); { eAction = Uni2DEditorGUIUtils.DisplayAnimationFrame(rAnimationClip.frames[iFrameIndex], rGlobalAtlas, ref bFrameFoldout); } if (EditorGUI.EndChangeCheck( )) { EditorUtility.SetDirty(rAnimationClip); } this.SetClipFoldout(bFrameFoldout, iClipIndex, iFrameIndex); // Handle returned action (if any) switch (eAction) { // No action case AnimationGUIAction.None: default: break; case AnimationGUIAction.AddUp: { Uni2DAnimationFrame oNewFrame = new Uni2DAnimationFrame( ); oNewFrame.atlas = rGlobalAtlas; rAnimationClip.frames.Insert(iFrameIndex, oNewFrame); ++iFrameCount; ++iFrameIndex; this.UpdateClipsFoldouts(iClipIndex, iFrameCount); EditorUtility.SetDirty(rAnimationClip); } break; case AnimationGUIAction.AddDown: { Uni2DAnimationFrame oNewFrame = new Uni2DAnimationFrame( ); oNewFrame.atlas = rGlobalAtlas; rAnimationClip.frames.Insert(iFrameIndex + 1, oNewFrame); ++iFrameCount; this.UpdateClipsFoldouts(iClipIndex, iFrameCount); EditorUtility.SetDirty(rAnimationClip); } break; case AnimationGUIAction.MoveUp: { if (iFrameIndex != 0) { rAnimationClip.SwapFrames(iFrameIndex, iFrameIndex - 1); EditorUtility.SetDirty(rAnimationClip); } } break; case AnimationGUIAction.MoveDown: { if (iFrameIndex != iFrameCount - 1) { rAnimationClip.SwapFrames(iFrameIndex, iFrameIndex + 1); EditorUtility.SetDirty(rAnimationClip); } } break; case AnimationGUIAction.Close: { rAnimationClip.frames.RemoveAt(iFrameIndex); UpdateTextureGUIDsList( ); --iFrameCount; --iFrameIndex; EditorUtility.SetDirty(rAnimationClip); } break; } } EditorGUILayout.Space( ); } EditorGUILayout.EndVertical( ); } EditorGUILayout.EndHorizontal( ); EditorGUILayout.BeginHorizontal( ); { GUILayout.FlexibleSpace( ); if (GUILayout.Button("Add Frame", GUILayout.Width(225.0f))) { Uni2DAnimationFrame oNewFrame = new Uni2DAnimationFrame( ); oNewFrame.atlas = rGlobalAtlas; rAnimationClip.frames.Add(oNewFrame); EditorUtility.SetDirty(rAnimationClip); } GUILayout.FlexibleSpace( ); } EditorGUILayout.EndHorizontal( ); } // End of clip header foldout EditorGUILayout.Space( ); } ///// Apply / Revert / Force regeneration buttons ///// EditorGUILayout.BeginVertical( ); { EditorGUILayout.BeginHorizontal( ); { EditorGUI.BeginDisabledGroup(this.DoTargetsHaveUnappliedSettings( ) == false); { if (GUILayout.Button("Apply")) { this.ApplySettings(AnimationClipRegeneration.RegenerateAlsoAtlasIfNeeded); } if (GUILayout.Button("Revert")) { this.RevertSettings( ); } } EditorGUI.EndDisabledGroup( ); } EditorGUILayout.EndHorizontal( ); if (GUILayout.Button("Force Clip Regeneration")) { this.ApplySettings(AnimationClipRegeneration.RegenerateAll); } } EditorGUILayout.EndVertical( ); } EditorGUILayout.EndVertical( ); } EditorGUI.EndDisabledGroup( ); if (Application.isPlaying == false) { this.CheckTextureDragAndDrop(GUILayoutUtility.GetLastRect( )); } // Force repaint if needed (== animation players enabled) if (m_oAnimationPlayerClipHeader.Enabled || m_oAnimationPlayerClipPreview.Enabled) { this.Repaint( ); } }
private static bool DoDisplayAnimationClipHeader(Uni2DAnimationClip a_rAnimationClip, Uni2DAnimationPlayer a_rAnimationPreviewPlayer, out AnimationGUIAction a_eAction, bool a_bCompactMode, bool a_bFolded, int iClipIndex = -1) { a_eAction = AnimationGUIAction.None; ///// Clip header ///// EditorGUILayout.BeginVertical(EditorStyles.textField); { if (a_bCompactMode) { ///// Top toolbar ///// EditorGUILayout.BeginHorizontal(EditorStyles.toolbar, GUILayout.ExpandWidth(true)); { // ^ if (GUILayout.Button("\u25B2" /*"\u2191"*/, EditorStyles.toolbarButton, GUILayout.ExpandWidth(false))) { a_eAction = AnimationGUIAction.MoveUp; } // v if (GUILayout.Button("\u25BC" /*"\u2193"*/, EditorStyles.toolbarButton, GUILayout.ExpandWidth(false))) { a_eAction = AnimationGUIAction.MoveDown; } if (iClipIndex > -1) { if (GUILayout.Button("Clip #" + iClipIndex, EditorStyles.toolbarButton, GUILayout.ExpandWidth(true))) { EditorGUIUtility.PingObject(a_rAnimationClip.gameObject); } } else { GUILayout.FlexibleSpace( ); } // X if (GUILayout.Button("X", EditorStyles.toolbarButton, GUILayout.ExpandWidth(false))) { a_eAction = AnimationGUIAction.Close; } } EditorGUILayout.EndHorizontal( ); } /////////////// EditorGUILayout.Space( ); EditorGUILayout.BeginHorizontal( ); { Rect oClipTextureRect = GUILayoutUtility.GetRect(64.0f, 64.0f, 64.0f, 64.0f, GUILayout.ExpandWidth(false)); // Animation clip preview Uni2DEditorGUIUtils.DrawAnimationClipPreview(oClipTextureRect, a_rAnimationClip, a_rAnimationPreviewPlayer); // Clip settings EditorGUILayout.BeginVertical( ); { //string rName; float fFrameRate; Uni2DAnimationClip.WrapMode eWrapMode; // Name //rName = EditorGUILayout.TextField( "Clip Name", a_rAnimationClip.name ); EditorGUILayout.LabelField(a_rAnimationClip.name, EditorStyles.boldLabel); EditorGUI.BeginChangeCheck( ); { EditorGUI.BeginChangeCheck( ); { // Frame rate fFrameRate = EditorGUILayout.FloatField("Frame Rate", a_rAnimationClip.frameRate); // Wrap mode eWrapMode = (Uni2DAnimationClip.WrapMode)EditorGUILayout.EnumPopup("Wrap Mode", a_rAnimationClip.wrapMode); } if (EditorGUI.EndChangeCheck( )) { // Update animation players settings a_rAnimationPreviewPlayer.FrameRate = fFrameRate; a_rAnimationPreviewPlayer.WrapMode = eWrapMode; } } if (EditorGUI.EndChangeCheck( )) { //a_rAnimationClip.name = rName; a_rAnimationClip.frameRate = fFrameRate; a_rAnimationClip.wrapMode = eWrapMode; if (a_bCompactMode) { a_rAnimationClip.ApplySettings(Uni2DAnimationClip.AnimationClipRegeneration.RegenerateNothing); } EditorUtility.SetDirty(a_rAnimationClip); } // Clip length infos // TODO: refactor with AnimationPlayer int iClipFrameCount = a_rAnimationClip.FrameCount; int iWrappedFrameCount = iClipFrameCount; if (a_rAnimationClip.wrapMode == Uni2DAnimationClip.WrapMode.PingPong && iWrappedFrameCount > 2) { iWrappedFrameCount = (iWrappedFrameCount * 2 - 2); } float fClipLength = Mathf.Abs(iWrappedFrameCount / a_rAnimationClip.frameRate); EditorGUILayout.BeginHorizontal( ); { EditorGUILayout.LabelField(iClipFrameCount + " frame(s) = " + (iClipFrameCount != iWrappedFrameCount ? (iWrappedFrameCount + " wrapped frame(s) = ") : null ) + fClipLength + " sec. @ " + a_rAnimationClip.frameRate + " FPS", EditorStyles.miniLabel, GUILayout.ExpandWidth(false)); if (a_bCompactMode && GUILayout.Button("Edit", EditorStyles.miniButton, GUILayout.ExpandWidth(true))) { Selection.activeObject = a_rAnimationClip; } } EditorGUILayout.EndHorizontal( ); } EditorGUILayout.EndVertical( ); } EditorGUILayout.EndHorizontal( ); // Frame foldout if (!a_bCompactMode) { EditorGUILayout.BeginHorizontal( ); { a_bFolded = EditorGUILayout.Foldout(a_bFolded, GUIContent.none); } EditorGUILayout.EndHorizontal( ); } else { EditorGUILayout.Space( ); } } EditorGUILayout.EndVertical( ); return(a_bFolded); }
public static bool DisplayAnimationClipHeader(Uni2DAnimationClip a_rAnimationClip, Uni2DAnimationPlayer a_rAnimationPreviewPlayer, bool a_bFolded) { AnimationGUIAction eAction; return(Uni2DEditorGUIUtils.DoDisplayAnimationClipHeader(a_rAnimationClip, a_rAnimationPreviewPlayer, out eAction, false, a_bFolded)); }
private static void RevertSettings( Uni2DAnimationClip[ ] a_rAnimationClips ) { for( int iIndex = 0, iCount = a_rAnimationClips.Length; iIndex < iCount; ++iIndex ) { a_rAnimationClips[ iIndex ].RevertSettings( ); } }
// Play the clip from the beginning public void Play( Uni2DAnimationClip a_rAnimationClip ) { // Get the clip m_rCurrentClip = a_rAnimationClip; // Reset // Time m_fAnimationTime = 0.0f; m_iCurrentFrameIndex = 0; // Play mode m_eWrapMode = Uni2DAnimationClip.WrapMode.Loop; m_fFrameRate = Uni2DAnimationClip.defaultFrameRate; if(m_rCurrentClip != null) { m_eWrapMode = m_rCurrentClip.wrapMode; m_fFrameRate = m_rCurrentClip.frameRate; } // Play m_bEnabled = true; m_bPaused = false; m_bActived = true; //RaiseAnimationActiveEvent( ); // On New Frame OnNewFrame(); }
// Raise animation end event private void RaiseAnimationEndEvent( Uni2DAnimationClip a_rAnimationClip ) { if( onAnimationEndEvent != null ) { onAnimationEndEvent( this, a_rAnimationClip ); } }
// Add a clip to the list public void AddClip( Uni2DAnimationClip a_rAnimationClip ) { if( a_rAnimationClip != null ) { int iClipCount = this.ClipCount; // Prevent to add a clip twice for( int iClipIndex = 0; iClipIndex < iClipCount; ++iClipIndex ) { if( a_rAnimationClip == m_rAnimationClips[ iClipIndex ] ) { return; } } Uni2DAnimationClip[ ] oAnimationClips = new Uni2DAnimationClip[ iClipCount + 1 ]; if( m_rAnimationClips != null ) { m_rAnimationClips.CopyTo( oAnimationClips, 0 ); } oAnimationClips[ iClipCount ] = a_rAnimationClip; m_rAnimationClips = oAnimationClips; } }
private static void OnPostprocessAllAssets(string[] a_rImportedAssets, string[] a_rDeletedAssets, string[] a_rMovedAssets, string[] a_rMovedFromPath) { if (ms_bEnabled) { bool bUpdateAssets = false; bool bPostprocessPrefabs = false; bool bSaveTable = false; Uni2DEditorAssetTable rAssetTable = Uni2DEditorAssetTable.Instance; foreach (string rImportedAssetPath in a_rImportedAssets) { Texture2D rImportedTexture = (Texture2D)AssetDatabase.LoadAssetAtPath(rImportedAssetPath, typeof(Texture2D)); if (rImportedTexture != null) { if (Uni2DEditorUtils.IsMarkedAsSourceTexture(rImportedTexture)) { //Debug.Log ( "Imported " + rImportedAssetPath ); string rImportedTextureGUID = AssetDatabase.AssetPathToGUID(rImportedAssetPath); ms_oImportedTextureGUIDs.Add(rImportedTextureGUID); Uni2DEditorUtils.GenerateTextureImportGUID(rImportedTexture); bUpdateAssets = true; rImportedTexture = null; MultiUnityVersionSupportUtility.UnloadUnusedAssets( ); continue; } } Uni2DTextureAtlas rImportedAtlas = (Uni2DTextureAtlas)AssetDatabase.LoadAssetAtPath(rImportedAssetPath, typeof(Uni2DTextureAtlas)); if (rImportedAtlas != null) { //Debug.Log ( "Imported atlas " + rImportedAssetPath ); bSaveTable = true; rAssetTable.AddAtlasPath(rImportedAssetPath, AssetDatabase.AssetPathToGUID(rImportedAssetPath)); rImportedAtlas = null; MultiUnityVersionSupportUtility.UnloadUnusedAssets( ); continue; } Uni2DAnimationClip rImportedClip = (Uni2DAnimationClip)AssetDatabase.LoadAssetAtPath(rImportedAssetPath, typeof(Uni2DAnimationClip)); if (rImportedClip != null) { //Debug.Log ( "Imported clip " + rImportedClip ); bSaveTable = true; rAssetTable.AddClipPath(rImportedAssetPath, AssetDatabase.AssetPathToGUID(rImportedAssetPath)); rImportedClip = null; MultiUnityVersionSupportUtility.UnloadUnusedAssets( ); continue; } GameObject rImportedGameObject = (GameObject)AssetDatabase.LoadAssetAtPath(rImportedAssetPath, typeof(GameObject)); if (rImportedGameObject != null) { //Debug.Log ( "Imported game object " + rImportedAssetPath ); ms_oGameObjectGUIDsToPostProcess.Add(AssetDatabase.AssetPathToGUID(rImportedAssetPath)); bPostprocessPrefabs = true; rImportedGameObject = null; MultiUnityVersionSupportUtility.UnloadUnusedAssets( ); } } // Moved assets for (int iIndex = 0, iCount = a_rMovedAssets.Length; iIndex < iCount; ++iIndex) { //Debug.Log ( "Importing moved asset" ); Uni2DTextureAtlas rMovedAtlas = (Uni2DTextureAtlas)AssetDatabase.LoadAssetAtPath(a_rMovedAssets[iIndex], typeof(Uni2DTextureAtlas)); if (rMovedAtlas != null) { rAssetTable.RemoveAtlasFromPath(a_rMovedFromPath[iIndex], false); rAssetTable.AddAtlasPath(a_rMovedAssets[iIndex], AssetDatabase.AssetPathToGUID(a_rMovedAssets[iIndex])); bSaveTable = true; rMovedAtlas = null; MultiUnityVersionSupportUtility.UnloadUnusedAssets( ); continue; } Uni2DAnimationClip rMovedClip = (Uni2DAnimationClip)AssetDatabase.LoadAssetAtPath(a_rMovedAssets[iIndex], typeof(Uni2DAnimationClip)); if (rMovedClip != null) { rAssetTable.RemoveClipFromPath(a_rMovedFromPath[iIndex], false); rAssetTable.AddClipPath(a_rMovedAssets[iIndex], AssetDatabase.AssetPathToGUID(a_rMovedAssets[iIndex])); bSaveTable = true; rMovedClip = null; MultiUnityVersionSupportUtility.UnloadUnusedAssets( ); } } // Deleted assets foreach (string rDeletedAsset in a_rDeletedAssets) { string[] rSpritePrefabGUIDs = rAssetTable.GetSpritePrefabGUIDsUsingThisAtlasPath(rDeletedAsset); if (rSpritePrefabGUIDs.Length > 0) { bUpdateAssets = true; ms_oSpritePrefabGUIDsToUpdate.UnionWith(rSpritePrefabGUIDs); } /* * // TODO: mettre des paths au lieu d'IDs * string[ ] rClipGUIDs = rAssetTable.GetClipGUIDsUsingThisTexturePath( rDeletedAsset ); * if( rClipGUIDs.Length > 0 ) * { * bUpdateAssets = true; * ms_oAnimationClipGUIDsToUpdate.UnionWith( rClipGUIDs ); * } */ bSaveTable = rAssetTable.RemoveAtlasFromPath(rDeletedAsset, true) || bSaveTable; bSaveTable = rAssetTable.RemoveClipFromPath(rDeletedAsset, true) || bSaveTable; } if (bSaveTable) { rAssetTable.Save( ); } if (bUpdateAssets) { ms_oAtlasGUIDsToUpdate.UnionWith(rAssetTable.GetAtlasGUIDsUsingTheseTextures(ms_oImportedTextureGUIDs)); ms_oAnimationClipGUIDsToUpdate.UnionWith(rAssetTable.GetClipGUIDsUsingTheseTextures(ms_oImportedTextureGUIDs)); ms_oSpritePrefabGUIDsToUpdate.UnionWith(rAssetTable.GetSpritePrefabGUIDsUsingTheseTextures(ms_oImportedTextureGUIDs)); ms_oSpritePrefabGUIDsToUpdate.UnionWith(rAssetTable.GetSpritePrefabGUIDsUsingTheseAtlases(ms_oAtlasGUIDsToUpdate)); EditorApplication.delayCall += UpdateUni2DAssets; } if (bPostprocessPrefabs) { EditorApplication.delayCall += OnSpritePrefabPostprocess; } } }
private static void ApplySettings( Uni2DAnimationClip[ ] a_rAnimationClips, AnimationClipRegeneration a_eRegenerate ) { int iClipCount = a_rAnimationClips.Length; if( iClipCount == 1 ) { a_rAnimationClips[ 0 ].ApplySettings( a_eRegenerate ); } else if( iClipCount > 1 ) { // Apply clip settings first, atlases will be generated only after // (Atlases can be shared accross clips, so prevent them to be uselessly regenerated several times) HashSet<Uni2DTextureAtlas> oAtlases = new HashSet<Uni2DTextureAtlas>( ); for( int iClipIndex = 0; iClipIndex < iClipCount; ++iClipIndex ) { Uni2DAnimationClip rAnimationClip = a_rAnimationClips[ iClipIndex ]; Uni2DTextureAtlas rGlobalAtlas = rAnimationClip.globalAtlas; if( rGlobalAtlas != null ) { // Add the atlas if not already added if( a_eRegenerate == AnimationClipRegeneration.RegenerateAll || ( a_eRegenerate == AnimationClipRegeneration.RegenerateAlsoAtlasIfNeeded && ( rGlobalAtlas.UnappliedSettings || rGlobalAtlas.Contains( rAnimationClip.GetAllFramesTextureGUIDs( ) ) == false ) ) ) { oAtlases.Add( rGlobalAtlas ); } } else // Null => atlas per frame { for( int iFrameIndex = 0, iFrameCount = rAnimationClip.FrameCount; iFrameIndex < iFrameCount; ++iFrameIndex ) { Uni2DAnimationFrame rFrame = rAnimationClip.frames[ iFrameIndex ]; Uni2DTextureAtlas rFrameAtlas = rFrame.atlas; if( rFrameAtlas != null && ( a_eRegenerate == AnimationClipRegeneration.RegenerateAll || ( a_eRegenerate == AnimationClipRegeneration.RegenerateAlsoAtlasIfNeeded && ( rFrameAtlas.UnappliedSettings || rFrameAtlas.Contains( rFrame.textureContainer.GUID ) == false ) ) ) ) { oAtlases.Add( rFrameAtlas ); } } } // Regenerate clips only rAnimationClip.ApplySettings( AnimationClipRegeneration.RegenerateAnimationClipOnly ); } // Then, regenerate atlases foreach( Uni2DTextureAtlas rAtlas in oAtlases ) { rAtlas.ApplySettings( ); } } }
// Stop playing the current clip public void Stop( bool a_bResetToMainFrame = true ) { m_bEnabled = false; m_bPaused = false; if(a_bResetToMainFrame) { //m_rSprite.ResetToMainFrame(); m_bActived = false; m_rCurrentClip = null; m_iCurrentFrameIndex = 0; m_fAnimationTime = 0; // Notify animation inactivity RaiseAnimationInactiveEvent( ); } }