// 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);
}
// 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;
}
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( );
}
}
// Constructor
public Uni2DAnimationEvent(Uni2DSpriteAnimation a_rSpriteAnimation, int a_iClipIndex, Uni2DAnimationClip a_rClip)
{
spriteAnimation = a_rSpriteAnimation;
clipIndex = a_iClipIndex;
clip = a_rClip;
}
// 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( );
}
}
