fixed folders with '.' in names being ignored in regenerating ot applying guids. now also supporting to only regen guids of folder meta assets.

Author: nikodemgrz

Assets/NikosAssets/U3DHelperTools/Samples/Resources/RegenerateGUIDFolder/Folder.With.Dots.meta

@@ -0,0 +1,77 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: File.With.Dots
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/NikosAssets/U3DHelperTools/Samples/Resources/RegenerateGUIDFolder/Folder.With.Dots/File.With.Dots.mat

@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using NaughtyAttributes;
+using NikosAssets.Helpers.Editor;
 using UnityEngine;
 using Object = UnityEngine.Object;
 
@@ -12,6 +13,12 @@ public class EditorUtilitiesSample : BaseNotesMono
 
         [BoxGroup(HelperConstants.ATTRIBUTE_FIELD_BOXGROUP_SETTINGS)]
         public string desiredFileName = "_RENAME_TEST_2";
+
+        [BoxGroup(HelperConstants.ATTRIBUTE_FIELD_BOXGROUP_SETTINGS)]
+        public bool regenGuidsRecursive = true;
+        
+        [BoxGroup(HelperConstants.ATTRIBUTE_FIELD_BOXGROUP_SETTINGS)]
+        public GUIDHelper.AcceptedMetaFiles acceptedMetaFilesForGuidRegen = GUIDHelper.AcceptedMetaFiles.Any;
 
         [BoxGroup(HelperConstants.ATTRIBUTE_FIELD_BOXGROUP_DESCRIPTIONS)]
         public string pathChosen = "Assets/";
@@ -69,7 +76,7 @@ public void RenameFilesAtChosenPath()
         [Button("Regenerate GUIDs recursive and keep the file references at the chosen path")]
         public void RegenerateGUIDsAtChosenPathRecursive()
         {
-            Editor.GUIDHelper.RegenerateGuids(pathChosen, true);
+            Editor.GUIDHelper.RegenerateGuids(pathChosen, regenGuidsRecursive, acceptedMetaFilesForGuidRegen);
         }
 
         #endif

Assets/NikosAssets/U3DHelperTools/Samples/Resources/RegenerateGUIDFolder/Folder.With.Dots/File.With.Dots.mat.meta

@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using NaughtyAttributes;
+using NikosAssets.Helpers.Editor;
 using UnityEngine;
 
 namespace NikosAssets.Helpers.Samples
@@ -16,7 +17,7 @@ public void RegenerateOnlyScriptableObjectsRecursive()
             #if UNITY_EDITOR
             Editor.GUIDHelper.RegenerateGuids(Editor.EditorUtilitiesHelper.PickFolderInsideProject("Regen GUIDS", 
                 "Assets/", "Assets/"), true, 
-                true, true, new []{".asset"});
+                GUIDHelper.AcceptedMetaFiles.Any, true, new []{".asset"});
             #endif
         }
     }

Assets/NikosAssets/U3DHelperTools/Samples/Scripts/EditorUtilitiesSample.cs

@@ -129,7 +129,10 @@ public static Object CreateScript(string localFilePath, string templateFileName,
         /// <param name="recursive">
         /// Go into sub folders as well?
         /// </param>
-        public static void PickFolderAndRegenerateGUIDs(bool recursive)
+        /// <param name="acceptedMetaFiles">
+        /// Only Regen GUIDs for files or folders or both?
+        /// </param>
+        public static void PickFolderAndRegenerateGUIDs(bool recursive, GUIDHelper.AcceptedMetaFiles acceptedMetaFiles)
         {
             string path = PickFolderInsideProject("Regenerate GUIDs in folder", "Assets/", null);
 
@@ -139,7 +142,7 @@ public static void PickFolderAndRegenerateGUIDs(bool recursive)
                 return;
             }
 
-            GUIDHelper.RegenerateGuids(path, recursive);
+            GUIDHelper.RegenerateGuids(path, recursive, acceptedMetaFiles);
         }
 
         /// <summary>
@@ -313,7 +316,7 @@ private static void RegenerateGUIDsRecursive()
                 "\n\nMake a backup of your project beforehand!",
                 "Regenerate GUIDs recursive", "Cancel"))
             {
-                PickFolderAndRegenerateGUIDs(true);
+                PickFolderAndRegenerateGUIDs(true, GUIDHelper.AcceptedMetaFiles.Any);
             }
         }
 
@@ -325,7 +328,7 @@ private static void RegenerateGUIDsNonRecursive()
                 "\n\nMake a backup of your project beforehand!",
                 "Regenerate GUIDs non-recursive", "Cancel"))
             {
-                PickFolderAndRegenerateGUIDs(false);
+                PickFolderAndRegenerateGUIDs(false, GUIDHelper.AcceptedMetaFiles.Any);
             }
         }
 

Assets/NikosAssets/U3DHelperTools/Samples/Scripts/GUIDRegenScriptableObjectSample.cs

@@ -14,6 +14,22 @@ namespace NikosAssets.Helpers.Editor
     /// </summary>
     public static class GUIDHelper
     {
+        public enum AcceptedMetaFiles
+        {
+            /// <summary>
+            /// Any file or folder asset
+            /// </summary>
+            Any = 0,
+            /// <summary>
+            /// Only search for files and ignore folder meta assets
+            /// </summary>
+            IgnoreFolders = 1,
+            /// <summary>
+            /// Only search for folder meta assets and ignore files
+            /// </summary>
+            IgnoreFiles = 2
+        }
+        
         /// <summary>
         /// Unity files that contain GUID (references), feel free to add unlisted ones
         /// </summary>
@@ -64,8 +80,8 @@ public static class GUIDHelper
         /// <param name="recursive">
         /// Can the asset be in a sub directory of <paramref name="isInLocalDirectory"/>?
         /// </param>
-        /// <param name="ignoreFolderAssets">
-        /// Can the owner GUID be a folder asset (folder + .meta)?
+        /// <param name="acceptedMetaFiles">
+        /// Should we accept only folders or only file assets or both?
         /// </param>
         /// <param name="whiteListExtensions">
         /// Must include extensions like (.mat, .cs) or accept all file types.
@@ -74,15 +90,28 @@ public static class GUIDHelper
         /// <returns>
         /// If the given file at <paramref name="filePath"/> is a GUID owner (meta) file (true or false)
         /// </returns>
-        private static bool IsAcceptedMetaFile(string isInLocalDirectory, string filePath, bool recursive, bool ignoreFolderAssets, string[] whiteListExtensions)
+        private static bool IsAcceptedMetaFile(string isInLocalDirectory, string filePath, bool recursive, 
+            AcceptedMetaFiles acceptedMetaFiles, string[] whiteListExtensions)
         {
             string directory = Path.GetDirectoryName(filePath).Replace(@"\", "/") + "/";
 
-            // First GUID in .meta file is always the GUID of the asset itself
-            // We must only replace GUIDs for Resources present in Assets.
+            if (!Path.GetExtension(filePath).Equals(".meta")) return false;
+
+            //any meta file
+            bool isAccepted = true;
+            string fileOrFolder = filePath.Substring(0, filePath.Length - 5);
+            switch (acceptedMetaFiles)
+            {
+                case AcceptedMetaFiles.IgnoreFolders:
+                    isAccepted = File.Exists(fileOrFolder);
+                    break;
+                case AcceptedMetaFiles.IgnoreFiles:
+                    isAccepted = Directory.Exists(fileOrFolder);
+                    break;
+            }
+            
             return 
-                (Path.GetExtension(filePath) == ".meta" 
-                 && (!ignoreFolderAssets || filePath.Count(fp => fp == '.') > 1)
+                (isAccepted
                  &&
                  (
                      //not recursive means that the directory ends with the localAssetPath
@@ -206,8 +235,8 @@ public static void SetGuids(
         /// <param name="recursive">
         /// Should we search for files inside other found folders of the <paramref name="localPathToApply"/>?
         /// </param>
-        /// <param name="ignoreFolderAssets">
-        /// Should we apply GUIDs to folder .meta files?
+        /// <param name="acceptedMetaFiles">
+        /// Should we accept only folders or only file assets or both?
         /// </param>
         /// <param name="logChangedAssets">
         /// Should we log the changed assets?
@@ -217,7 +246,7 @@ public static void SetGuids(
         /// </param>
         public static void ApplyGUIDsFrom(string localPathToApply, string globalPathToRead,
             bool recursive = true,
-            bool ignoreFolderAssets = true,
+            AcceptedMetaFiles acceptedMetaFiles = AcceptedMetaFiles.IgnoreFolders,
             bool logChangedAssets = false,
             string[] whiteListExtensions = null)
         {
@@ -251,7 +280,7 @@ public static void ApplyGUIDsFrom(string localPathToApply, string globalPathToRe
                     List<string> guids = GetGuidsFromFileContents(contents);
 
                     //can we add this file to the guidOldToNewMap?
-                    if (IsAcceptedMetaFile(localPathToApply, filePath, recursive, ignoreFolderAssets,
+                    if (IsAcceptedMetaFile(localPathToApply, filePath, recursive, acceptedMetaFiles,
                         whiteListExtensions))
                     {
                         int matchingGlobalFilePathIndex =
@@ -309,8 +338,8 @@ public static void ApplyGUIDsFrom(string localPathToApply, string globalPathToRe
         /// <param name="recursive">
         /// Should we search for files inside other found folders of the <paramref name="localPath"/>?
         /// </param>
-        /// <param name="ignoreFolderAssets">
-        /// Should we generate new GUIDs for folder .meta files?
+        /// <param name="acceptedMetaFiles">
+        /// Should we accept only folders or only file assets or both?
         /// </param>
         /// <param name="logChangedAssets">
         /// Should we log the changed assets?
@@ -321,7 +350,7 @@ public static void ApplyGUIDsFrom(string localPathToApply, string globalPathToRe
         public static void RegenerateGuids(
             string localPath,
             bool recursive = true,
-            bool ignoreFolderAssets = true,
+            AcceptedMetaFiles acceptedMetaFiles = AcceptedMetaFiles.Any,
             bool logChangedAssets = false,
             string[] whiteListExtensions = null)
         {
@@ -345,7 +374,7 @@ public static void RegenerateGuids(
                     List<string> guids = GetGuidsFromFileContents(contents);
 
                     //can we add this file to the guidOldToNewMap?
-                    if (IsAcceptedMetaFile(localPath, filePath, recursive, ignoreFolderAssets, whiteListExtensions))
+                    if (IsAcceptedMetaFile(localPath, filePath, recursive, acceptedMetaFiles, whiteListExtensions))
                     {
                         string oldGuid = guids.First();
                         // Generate and save new GUID if we haven't added it before