private static void OnSpritePrefabPostprocess( )
{
EditorApplication.delayCall -= OnSpritePrefabPostprocess;
try
{
Uni2DAssetPostprocessor.LockTo(false);
foreach (string rGameObjectPrefabGUID in ms_oGameObjectGUIDsToPostProcess)
{
GameObject rGameObjectPrefab = Uni2DEditorUtils.GetAssetFromUnityGUID <GameObject>(rGameObjectPrefabGUID);
if (rGameObjectPrefab != null)
{
//Debug.Log ( "Post processing game object prefab " + rGameObjectPrefabGUID );
Uni2DEditorSpriteBuilderUtils.OnPrefabPostProcess(rGameObjectPrefab);
rGameObjectPrefab = null;
EditorUtility.UnloadUnusedAssets( );
}
}
}
finally
{
ms_oGameObjectGUIDsToPostProcess.Clear( );
Uni2DAssetPostprocessor.Unlock( );
Uni2DAssetPostprocessor.Enabled = true;
}
}
// Copy clips
private void CopyFrames(List <Uni2DAnimationFrame> a_rFramesSource, List <Uni2DAnimationFrame> a_rFramesDestination)
{
// Update asset table
Uni2DEditorAssetTable rAssetTable = Uni2DEditorAssetTable.Instance;
string rClipGUID = Uni2DEditorUtils.GetUnityAssetGUID(this);
foreach (Uni2DAnimationFrame rOldFrame in a_rFramesDestination)
{
string oTextureGUID = rOldFrame.textureContainer != null ? rOldFrame.textureContainer.GUID : null;
if (!string.IsNullOrEmpty(oTextureGUID))
{
rAssetTable.RemoveClipUsingTexture(rClipGUID, oTextureGUID);
}
}
a_rFramesDestination.Clear( );
foreach (Uni2DAnimationFrame rFrameSource in a_rFramesSource)
{
a_rFramesDestination.Add(new Uni2DAnimationFrame(rFrameSource));
string oTextureGUID = rFrameSource.textureContainer != null ? rFrameSource.textureContainer.GUID : null;
if (!string.IsNullOrEmpty(oTextureGUID))
{
rAssetTable.AddClipUsingTexture(rClipGUID, oTextureGUID);
}
}
rAssetTable.Save( );
}
// Fins the first texture atlas
public static Uni2DTextureAtlas FindFirstTextureAtlas(string a_rTextureGUID)
{
Uni2DEditorAssetTable rAssetTable = Uni2DEditorAssetTable.Instance;
Uni2DTextureAtlas rAtlas = null;
bool bSaveTable = false;
string[] rAtlasGUIDs = rAssetTable.GetAtlasGUIDsUsingThisTexture(a_rTextureGUID);
foreach (string rAtlasGUID in rAtlasGUIDs)
{
rAtlas = Uni2DEditorUtils.GetAssetFromUnityGUID <Uni2DTextureAtlas>(rAtlasGUID);
if (rAtlas != null && rAtlas.Contains(a_rTextureGUID))
{
//rAtlas = null;
break;
}
else
{
rAssetTable.RemoveAtlasUsingTexture(rAtlasGUID, a_rTextureGUID);
bSaveTable = true;
}
}
if (bSaveTable)
{
rAssetTable.Save( );
}
return(rAtlas);
}
public Texture2DContainer(Texture2D a_rTexture, bool a_bKeepTextureReference)
{
m_oTextureGUID = Uni2DEditorUtils.GetUnityAssetGUID(a_rTexture);
if (a_bKeepTextureReference)
{
m_rTexture = a_rTexture;
}
}
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>( ));
}
// Creates a new sprite settings with the given texture.
// If the a_bPhysic argument is set to true, the settings will
// depict a physical sprite
public Uni2DEditorSpriteSettings(Texture2D a_rTexture2D, bool a_bPhysic = false)
{
this.textureContainer = new Texture2DContainer(a_rTexture2D, true);
atlas = Uni2DEditorUtils.FindFirstTextureAtlas(textureContainer.GUID);
// Set physic mode accordingly to given argument
this.physicsMode = a_bPhysic
? PhysicsMode.Dynamic
: PhysicsMode.NoPhysics;
}
static void DoCreatePixelPerfectCameraAssetsMenu( )
{
string oNewPrefabPath = Uni2DEditorUtils.GenerateNewPrefabLocalPath(mc_oPixelPerfectCameraDefaultName);
GameObject oPrefabModel = new GameObject( );
oPrefabModel.AddComponent <Camera>( );
oPrefabModel.AddComponent <Uni2DPixelPerfectCamera>( );
PrefabUtility.CreatePrefab(oNewPrefabPath, oPrefabModel);
GameObject.DestroyImmediate(oPrefabModel);
}
// Check if dirty
private void CheckIfTextureChange()
{
Texture2D rSpriteTexture = m_rSpriteSettings.textureContainer;
if (rSpriteTexture != null)
{
string oTextureImportGUID = Uni2DEditorUtils.GetTextureImportGUID(rSpriteTexture);
if (oTextureImportGUID != m_oTextureImportGUID)
{
// On texture change
OnTextureChange(oTextureImportGUID);
}
}
}
// Generate atlas materials
private Material GenerateAtlasMaterial(int a_iEntryIndex, Material a_rCurrentAtlasMaterial, Texture2D a_rAtlasTexture, string a_oGeneratedDataPathLocal)
{
bool bNewMaterial = false;
Material rAtlasMaterial = a_rCurrentAtlasMaterial;
// Create material
if (a_rCurrentAtlasMaterial == null)
{
// Clone base material
rAtlasMaterial = this.materialOverride != null
? new Material(this.materialOverride)
: new Material(Shader.Find(Uni2DEditorSpriteBuilderUtils.mc_oSpriteDefaultShader));
bNewMaterial = true;
}
else
{
string oFolderPathLocal = Uni2DEditorUtils.GetLocalAssetFolderPath(a_rCurrentAtlasMaterial);
if (oFolderPathLocal != a_oGeneratedDataPathLocal)
{
// Duplicate
rAtlasMaterial = new Material(a_rCurrentAtlasMaterial);
bNewMaterial = true;
}
}
// If we have created a new material
if (bNewMaterial)
{
rAtlasMaterial.name = gameObject.name + "_AtlasMaterial" + a_iEntryIndex;
string oMaterialPathLocal = a_oGeneratedDataPathLocal + rAtlasMaterial.name + ".mat";
// Ensure the material can be created
Material rMaterialAtWantedPath = AssetDatabase.LoadAssetAtPath(oMaterialPathLocal, typeof(Texture2D)) as Material;
if (rMaterialAtWantedPath != null)
{
// Todo_Sev : ask user before deletion?
AssetDatabase.DeleteAsset(oMaterialPathLocal);
}
// Create material
AssetDatabase.CreateAsset(rAtlasMaterial, oMaterialPathLocal);
}
// Assign the atlas texture
rAtlasMaterial.mainTexture = a_rAtlasTexture;
return(rAtlasMaterial);
}
static void DoCreateTextureAtlas()
{
// Get the selected path
string oNewPrefabPath = Uni2DEditorUtils.GenerateNewPrefabLocalPath(mc_oTextureAtlasDefaultName);
// Create model
GameObject oPrefabModel = new GameObject();
oPrefabModel.AddComponent <Uni2DTextureAtlas>();
// Save it as a prefab
PrefabUtility.CreatePrefab(oNewPrefabPath, oPrefabModel);
// Destroy model
GameObject.DestroyImmediate(oPrefabModel);
}
///// Custom popup callbacks /////
private static void AtlasPopupCallback(object a_rValue)
{
if (a_rValue != null && a_rValue is string)
{
PopupCallbackInfo <Uni2DTextureAtlas> rPopupCallbackInfoInstance = PopupCallbackInfo <Uni2DTextureAtlas> .instance;
string rGUID = (string)a_rValue;
if (string.IsNullOrEmpty(rGUID))
{
rPopupCallbackInfoInstance.SetValue(null);
}
else if (rGUID == "NEW")
{
string oTextureAtlasPath = EditorUtility.SaveFilePanelInProject("Create new Uni2D texture atlas",
"TextureAtlas_New",
"prefab",
"Create a new Uni2D texture atlas:");
if (string.IsNullOrEmpty(oTextureAtlasPath) == false)
{
// TODO: refactor with Sprite Builder Window
// Create model
GameObject oPrefabModel = new GameObject( );
oPrefabModel.AddComponent <Uni2DTextureAtlas>( );
// Save it as a prefab
GameObject rTextureAtlasGameObject = PrefabUtility.CreatePrefab(oTextureAtlasPath, oPrefabModel);
// Destroy model
GameObject.DestroyImmediate(oPrefabModel);
rPopupCallbackInfoInstance.SetValue(rTextureAtlasGameObject.GetComponent <Uni2DTextureAtlas>( ));
}
}
else
{
rPopupCallbackInfoInstance.SetValue(Uni2DEditorUtils.GetAssetFromUnityGUID <Uni2DTextureAtlas>(rGUID));
}
}
}
// Generate
public bool Generate( )
{
// Make sure the data directory exist
string oGeneratedDataPathLocal = Uni2DEditorUtils.GetLocalAssetFolderPath(gameObject) + gameObject.name + "_GeneratedData" + "/";
string oGeneratedDataPathGlobal = Uni2DEditorUtils.LocalToGlobalAssetPath(oGeneratedDataPathLocal);
if (!Directory.Exists(oGeneratedDataPathGlobal))
{
Directory.CreateDirectory(oGeneratedDataPathGlobal);
}
// Generate data!
bool bSuccess = GenerateAtlasData(oGeneratedDataPathLocal);
generationId = System.Guid.NewGuid( ).ToString( );
EditorUtility.SetDirty(this);
AssetDatabase.SaveAssets( );
return(bSuccess);
}
private Dictionary <string, string> GetAssetNamesFromGUIDsAndRemoveOutdatedOnes(MultiValueDictionary <string, string> a_rMultiDict, IEnumerable <string> a_rGUIDs)
{
Dictionary <string, string> oGUIDNamesDict = new Dictionary <string, string>( );
List <string> oOutdatedGUIDs = new List <string>( );
foreach (string rGUID in a_rGUIDs)
{
string oName = Uni2DEditorUtils.GetAssetNameFromUnityGUID(rGUID);
if (oName != null)
{
oGUIDNamesDict.Add(rGUID, oName);
}
else
{
// Name is null => asset doesn't exist anymore
oOutdatedGUIDs.Add(rGUID);
}
}
// Remove the outdated GUID from our multi-value dict
foreach (string rOutdatedGUID in oOutdatedGUIDs)
{
MultiValueDictionary <string, string> .KeyCollection rKeys = a_rMultiDict.Keys;
foreach (string rKey in rKeys)
{
if (a_rMultiDict.ContainsValue(rKey, rOutdatedGUID))
{
a_rMultiDict.Remove(rKey, rOutdatedGUID);
}
}
// TODO: save?
}
return(oGUIDNamesDict);
}
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;
}
}
// Apply settings
public bool ApplySettings(bool a_bUpdateSprites = true)
{
bool bSuccess;
Uni2DAssetPostprocessor.Enabled = false;
{
int iContainerCount = textures.Length;
Texture2D[] oTexturesToPack = new Texture2D[iContainerCount];
for (int iContainerIndex = 0; iContainerIndex < iContainerCount; ++iContainerIndex)
{
oTexturesToPack[iContainerIndex] = textures[iContainerIndex].Texture;
}
List <Uni2DTextureImporterSettingsPair> rTextureImporterSettings = Uni2DEditorSpriteBuilderUtils.TexturesProcessingBegin(oTexturesToPack);
oTexturesToPack = null;
// Look if the atlas is set properly regarding to texture sizes
int iOversizedTextures = this.LookForOversizedTextures(textures, padding, maximumAtlasSize);
if (iOversizedTextures == 0)
{
textures = this.SanitizeInputTextures(textures);
iContainerCount = textures.Length;
string rAtlasGUID = Uni2DEditorUtils.GetUnityAssetGUID(this);
Uni2DEditorAssetTable rAssetTable = Uni2DEditorAssetTable.Instance;
for (int iTextureIndex = 0, iTextureCount = m_rTextureContainers.Length; iTextureIndex < iTextureCount; ++iTextureIndex)
{
rAssetTable.RemoveAtlasUsingTexture(rAtlasGUID, m_rTextureContainers[iTextureIndex].GUID);
}
m_rTextureContainers = new Texture2DContainer[iContainerCount];
// Deep copy
for (int iContainerIndex = 0; iContainerIndex < iContainerCount; ++iContainerIndex)
{
Texture2DContainer oTextureContainer = new Texture2DContainer(textures[iContainerIndex]);
m_rTextureContainers[iContainerIndex] = oTextureContainer;
rAssetTable.AddAtlasUsingTexture(rAtlasGUID, oTextureContainer.GUID);
}
rAssetTable.Save( );
m_iPadding = padding;
m_eMaximumAtlasSize = maximumAtlasSize;
bSuccess = Generate( );
if (a_bUpdateSprites)
{
Uni2DEditorSpriteBuilderUtils.UpdateSpriteInCurrentSceneAndResourcesAccordinglyToAtlasChange(this);
}
}
else // Some textures can't fit
{
bSuccess = false;
Debug.LogWarning("Uni2D could not regenerate atlas '" + (this.gameObject.name) + "' properly: "
+ iOversizedTextures + " texture" + (iOversizedTextures > 1 ? "s are" : " is")
+ " too large to fit in the atlas.", this.gameObject);
}
Uni2DEditorSpriteBuilderUtils.TexturesProcessingEnd(rTextureImporterSettings);
}
Uni2DAssetPostprocessor.Enabled = true;
EditorUtility.UnloadUnusedAssets( );
return(bSuccess);
}
public Texture2D GetAtlasTexture(Texture2D a_rTexture)
{
return(this.GetAtlasTexture(Uni2DEditorUtils.GetUnityAssetGUID(a_rTexture)));
}
public Material GetMaterial(Texture2D a_rTexture)
{
return(this.GetMaterial(Uni2DEditorUtils.GetUnityAssetGUID(a_rTexture)));
}
public bool Contains(Texture2D a_rTexture)
{
return(this.Contains(Uni2DEditorUtils.GetUnityAssetGUID(a_rTexture)));
}
public bool GetUVs(Texture2D a_rTexture, out Rect a_rUVs, out bool a_bIsFlipped)
{
return(this.GetUVs(Uni2DEditorUtils.GetUnityAssetGUID(a_rTexture), out a_rUVs, out a_bIsFlipped));
}
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;
}
}
}
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)
{
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;
}
}
}
// After build
public void AfterBuild()
{
m_oTextureImportGUID = Uni2DEditorUtils.GetTextureImportGUID(m_rSpriteSettings.textureContainer);
}
// Set default atlas
public void SetDefaultAtlas()
{
m_rSpriteSettings.atlas = Uni2DEditorUtils.FindFirstTextureAtlas(m_rSpriteSettings.textureContainer.GUID);
}
// Has shared resources
public bool HasSharedResources()
{
return(EditorUtility.IsPersistent(this.renderMesh)
//|| EditorUtility.IsPersistent( this.spriteQuadMaterial )
|| (this.meshCollidersList != null && Uni2DEditorUtils.IsThereAtLeastOnePersistentObject(this.meshCollidersList)));
}
public static Uni2DTextureAtlas AtlasPopup(Uni2DTextureAtlas a_rTextureAtlas, IEnumerable <string> a_rTextureGUIDs, params GUILayoutOption[] a_rGUILayoutOptions)
{
// Get button control ID
int iControlID = GUIUtility.GetControlID(FocusType.Passive);
// Get selected value for our control
// If no PopupCallbackInfo instance exists, the returned value is a_rTextureAtlas
a_rTextureAtlas = PopupCallbackInfo <Uni2DTextureAtlas> .GetSelectedValueForControl(iControlID, a_rTextureAtlas);
// 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.
string oPopupSelected = EditorGUI.showMixedValue ? "-" : (a_rTextureAtlas != null ? a_rTextureAtlas.name : "(None)");
if (GUILayout.Button(oPopupSelected, EditorStyles.popup, a_rGUILayoutOptions))
{
string rAtlasGUID = Uni2DEditorUtils.GetUnityAssetGUID(a_rTextureAtlas);
// Create a new popup callback info (control ID) and save it as current instance
PopupCallbackInfo <Uni2DTextureAtlas> .instance = new PopupCallbackInfo <Uni2DTextureAtlas>(iControlID, a_rTextureAtlas);
// Create our generic menu
GenericMenu oPopupMenu = new GenericMenu( );
if (a_rTextureAtlas != null)
{
oPopupMenu.AddItem(new GUIContent(a_rTextureAtlas.name), true, AtlasPopupCallback, rAtlasGUID);
oPopupMenu.AddSeparator("");
}
// "None" special item menu
oPopupMenu.AddItem(new GUIContent("(None)", "No atlasing"), a_rTextureAtlas == null, AtlasPopupCallback, "");
oPopupMenu.AddSeparator("");
// "Create" special item menu
oPopupMenu.AddItem(new GUIContent("Create a new atlas...", "Creates a new Uni2D atlas and add the texture(s) right away"), false, AtlasPopupCallback, "NEW");
Uni2DEditorAssetTable rAssetTable = Uni2DEditorAssetTable.Instance;
// List atlases containing the texture(s)
Dictionary <string, string> oAtlasesReadyToUse = rAssetTable.GetAtlasNamesUsingTheseTextures(a_rTextureGUIDs);
if (!string.IsNullOrEmpty(rAtlasGUID))
{
oAtlasesReadyToUse.Remove(rAtlasGUID);
}
if (oAtlasesReadyToUse.Count > 0)
{
oPopupMenu.AddSeparator("");
// Add an item menu for each ready to use atlas
foreach (KeyValuePair <string, string> rAtlasNameGUIDPair in oAtlasesReadyToUse)
{
oPopupMenu.AddItem(new GUIContent(rAtlasNameGUIDPair.Value), rAtlasNameGUIDPair.Key == rAtlasGUID, AtlasPopupCallback, rAtlasNameGUIDPair.Key);
}
}
// List all available atlases
Dictionary <string, string> oAvailableAtlases = rAssetTable.GetAllAtlasNames( );
if (oAvailableAtlases.Count > 0)
{
oPopupMenu.AddSeparator("");
// Add an item menu for each available atlas, in a submenu
foreach (KeyValuePair <string, string> rAtlasNameGUIDPair in oAvailableAtlases)
{
oPopupMenu.AddItem(new GUIContent("All atlases/" + rAtlasNameGUIDPair.Value), rAtlasNameGUIDPair.Key == rAtlasGUID, AtlasPopupCallback, rAtlasNameGUIDPair.Key);
}
}
// Finally show up the menu
oPopupMenu.ShowAsContext( );
}
return(a_rTextureAtlas);
}
private Texture2D ExportAndSaveAtlasTexture(int a_iAtlasEntryIndex, Texture2D a_rCurrentAtlasTexture, Texture2D a_rNewAtlasTexture, string a_oGeneratedDataPathLocal)
{
bool bNewTexture = false;
// Look if there's already a texture at desired path
if (a_rCurrentAtlasTexture == null)
{
// No => create the texture
bNewTexture = true;
}
else
{
string oFolderPathLocal = Uni2DEditorUtils.GetLocalAssetFolderPath(a_rCurrentAtlasTexture);
if (oFolderPathLocal != a_oGeneratedDataPathLocal)
{
bNewTexture = true;
}
}
// Set atlas name accordingly
if (bNewTexture)
{
a_rNewAtlasTexture.name = gameObject.name + "_AtlasTexture" + a_iAtlasEntryIndex;
}
else
{
a_rNewAtlasTexture.name = a_rCurrentAtlasTexture.name;
}
// Get the atlas texture path
string oAtlasTexturePathLocal = a_oGeneratedDataPathLocal + a_rNewAtlasTexture.name + ".png";
string oAtlasTexturePathGlobal = Uni2DEditorUtils.LocalToGlobalAssetPath(oAtlasTexturePathLocal);
// Save the atlas
FileStream oFileStream = new FileStream(oAtlasTexturePathGlobal, FileMode.Create);
BinaryWriter oBinaryWriter = new BinaryWriter(oFileStream);
oBinaryWriter.Write(a_rNewAtlasTexture.EncodeToPNG( ));
// Close IO resources
oBinaryWriter.Close( );
oFileStream.Close( );
// If we had just created a new texture set the default import settings
if (bNewTexture)
{
ImportNewAtlasTexture(oAtlasTexturePathLocal);
}
else
{
// or reimport
AssetDatabase.ImportAsset(oAtlasTexturePathLocal, ImportAssetOptions.ForceUpdate);
}
// Destroy the runtime-created instance
DestroyImmediate(a_rNewAtlasTexture);
// Save a ref to new atlas texture (by instancing its Unity serialized model)
a_rNewAtlasTexture = AssetDatabase.LoadAssetAtPath(oAtlasTexturePathLocal, typeof(Texture2D)) as Texture2D;
// Mark the atlas texture
Uni2DEditorUtils.MarkAsTextureAtlas(a_rNewAtlasTexture);
return(a_rNewAtlasTexture);
}
// On inspector gui
public override void OnInspectorGUI( )
{
Uni2DTextureAtlas rAtlas = target as Uni2DTextureAtlas;
#if BEFORE_UNITY_4_3
EditorGUIUtility.LookLikeInspector( );
#endif
// Material override
EditorGUILayout.BeginVertical( );
{
rAtlas.materialOverride = (Material)EditorGUILayout.ObjectField("Material Override", rAtlas.materialOverride, typeof(Material), false);
rAtlas.maximumAtlasSize = (AtlasSize)EditorGUILayout.EnumPopup("Maximum Atlas Size", rAtlas.maximumAtlasSize);
rAtlas.padding = EditorGUILayout.IntField("Padding", rAtlas.padding);
rAtlas.padding = Mathf.Abs(rAtlas.padding);
// Texture to pack list
// Custom list GUI: displays Texture2D objects, handles asset GUIDs
serializedObject.Update( );
SerializedProperty rSerializedProperty_Textures = serializedObject.FindProperty("textures");
int iContainerIndex = 0;
EditorGUILayout.Space( );
while (true)
{
string oPropertyPath = rSerializedProperty_Textures.propertyPath;
string oPropertyName = rSerializedProperty_Textures.name;
bool bIsTextureContainer = oPropertyPath.Contains("textures");
// Indent
EditorGUI.indentLevel = rSerializedProperty_Textures.depth;
if (bIsTextureContainer)
{
if (oPropertyName == "textures")
{
GUIContent oGUIContentTexturesLabel = new GUIContent("Textures");
Rect rFoldoutRect = GUILayoutUtility.GetRect(oGUIContentTexturesLabel, EditorStyles.foldout);
Event rCurrentEvent = Event.current;
switch (rCurrentEvent.type)
{
// Drag performed
case EventType.DragPerform:
{
// Check if dragged objects are inside the foldout rect
if (rFoldoutRect.Contains(rCurrentEvent.mousePosition))
{
// Accept and use the event
DragAndDrop.AcceptDrag( );
rCurrentEvent.Use( );
EditorGUIUtility.hotControl = 0;
DragAndDrop.activeControlID = 0;
// Add the textures to the current list
foreach (Object rDraggedObject in DragAndDrop.objectReferences)
{
if (rDraggedObject is Texture2D)
{
int iCurrentSize = rSerializedProperty_Textures.arraySize;
++rSerializedProperty_Textures.arraySize;
SerializedProperty rSerializedProperty_Data = rSerializedProperty_Textures.GetArrayElementAtIndex(iCurrentSize);
rSerializedProperty_Data = rSerializedProperty_Data.FindPropertyRelative("m_oTextureGUID");
rSerializedProperty_Data.stringValue = rDraggedObject != null
? Uni2DEditorUtils.GetUnityAssetGUID((Texture2D)rDraggedObject)
: null;
}
}
}
}
break;
case EventType.DragUpdated:
{
if (rFoldoutRect.Contains(rCurrentEvent.mousePosition))
{
DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
}
}
break;
}
EditorGUI.indentLevel = 0;
ms_bTexturesFoldout = EditorGUI.Foldout(rFoldoutRect, ms_bTexturesFoldout, oGUIContentTexturesLabel);
}
else if (oPropertyName == "data")
{
SerializedProperty rSerializedProperty_TextureGUID = rSerializedProperty_Textures.FindPropertyRelative("m_oTextureGUID");
Texture2D rTexture = Uni2DEditorUtils.GetAssetFromUnityGUID <Texture2D>(rSerializedProperty_TextureGUID.stringValue);
EditorGUI.BeginChangeCheck( );
{
rTexture = (Texture2D)EditorGUILayout.ObjectField("Element " + iContainerIndex, rTexture, typeof(Texture2D), false);
++iContainerIndex;
}
if (EditorGUI.EndChangeCheck( ))
{
rSerializedProperty_TextureGUID.stringValue = rTexture != null
? Uni2DEditorUtils.GetUnityAssetGUID(rTexture)
: null;
}
}
else
{
// Default draw of the property field
EditorGUILayout.PropertyField(rSerializedProperty_Textures);
}
}
if (rSerializedProperty_Textures.NextVisible(ms_bTexturesFoldout) == false)
{
break;
}
}
serializedObject.ApplyModifiedProperties( );
EditorGUILayout.Space( );
EditorGUI.indentLevel = 0;
///// Generated assets section /////
// Materials
ms_bGeneratedMaterialsFoldout = EditorGUILayout.Foldout(ms_bGeneratedMaterialsFoldout, "Generated Materials");
if (ms_bGeneratedMaterialsFoldout)
{
++EditorGUI.indentLevel;
{
if (ms_oAtlasMaterials.Length > 0)
{
foreach (Material rAtlasMaterial in ms_oAtlasMaterials)
{
EditorGUILayout.BeginHorizontal( );
{
GUILayout.Space(16.0f);
if (GUILayout.Button(EditorGUIUtility.ObjectContent(rAtlasMaterial, typeof(Material)), EditorStyles.label, GUILayout.ExpandWidth(false), GUILayout.MaxWidth(225.0f), GUILayout.MaxHeight(16.0f)))
{
EditorGUIUtility.PingObject(rAtlasMaterial);
}
}
EditorGUILayout.EndHorizontal( );
}
}
else
{
EditorGUILayout.PrefixLabel("(None)");
}
}
--EditorGUI.indentLevel;
}
EditorGUILayout.Space( );
// Atlas textures
ms_bGeneratedTexturesFoldout = EditorGUILayout.Foldout(ms_bGeneratedTexturesFoldout, "Generated Textures");
if (ms_bGeneratedTexturesFoldout)
{
++EditorGUI.indentLevel;
{
if (ms_oAtlasTextures.Length > 0)
{
foreach (Texture2D rAtlasTexture in ms_oAtlasTextures)
{
EditorGUILayout.BeginHorizontal( );
{
GUILayout.Space(16.0f);
if (GUILayout.Button(EditorGUIUtility.ObjectContent(rAtlasTexture, typeof(Texture2D)), EditorStyles.label, GUILayout.ExpandWidth(false), GUILayout.MaxWidth(225.0f), GUILayout.MaxHeight(16.0f)))
{
EditorGUIUtility.PingObject(rAtlasTexture);
}
}
EditorGUILayout.EndHorizontal( );
}
}
else
{
EditorGUILayout.PrefixLabel("(None)");
}
}
--EditorGUI.indentLevel;
}
bool bUnappliedSettings = rAtlas.UnappliedSettings;
EditorGUI.BeginDisabledGroup(bUnappliedSettings == false);
{
// Apply/Revert
EditorGUILayout.BeginHorizontal( );
{
if (GUILayout.Button("Apply"))
{
this.ApplySettings( );
}
if (GUILayout.Button("Revert"))
{
rAtlas.RevertSettings( );
}
}
EditorGUILayout.EndHorizontal( );
}
EditorGUI.EndDisabledGroup();
// Generate
if (GUILayout.Button("Force atlas regeneration"))
{
this.ApplySettings( );
}
}
EditorGUILayout.EndVertical( );
}
