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( ); }