The power of the

plug-in is that it can find all the referenced resources in the current scenario, locate them quickly, and then manually delete any resources that are not located.

code

   1 // Resource Checker
   2 // (c) 2012 Simon Oliver/HandCircus/[email protected]
   3 // (c) 2015 Brice Clocher/Mangatome/[email protected]
   4 // Public domain, do with whatever you like, commercial or not
   5 // This comes with no warranty, use at your own risk!
   6 // https://github.com/handcircus/Unity-Resource-Checker
   7 
   8 using System;
   9 using System.Linq;
  10 using UnityEngine;
  11 using UnityEngine.UI;
  12 using UnityEditor;
  13 using System.Collections.Generic;
  14 using System.Reflection;
  15 using Object = UnityEngine.Object;
  16 
  17 public class TextureDetails : IEquatable<TextureDetails>
  18 {
  19     public bool isCubeMap;
  20     public int memSizeKB;
  21     public Texture texture;
  22     public TextureFormat format;
  23     public int mipMapCount;
  24     public List<Object> FoundInMaterials=new List<Object>();
  25     public List<Object> FoundInRenderers=new List<Object>();
  26     public List<Object> FoundInAnimators = new List<Object>();
  27     public List<Object> FoundInScripts = new List<Object>();
  28     public List<Object> FoundInGraphics = new List<Object>();
  29     public bool isSky;
  30     public bool instance;
  31     public bool isgui;
  32     public TextureDetails()
  33     {
  34 
  35     }
  36 
  37     public bool Equals(TextureDetails other)
  38     {
  39         return texture != null && other.texture != null &&
  40             texture.GetNativeTexturePtr() == other.texture.GetNativeTexturePtr();
  41     }
  42 
  43     public override int GetHashCode()
  44     {
  45         return (int)texture.GetNativeTexturePtr();
  46     }
  47 
  48     public override bool Equals(object obj)
  49     {
  50         return Equals(obj as TextureDetails);
  51     }
  52 };
  53 
  54 public class MaterialDetails
  55 {
  56 
  57     public Material material;
  58 
  59     public List<Renderer> FoundInRenderers=new List<Renderer>();
  60     public List<Graphic> FoundInGraphics=new List<Graphic>();
  61     public bool instance;
  62     public bool isgui;
  63     public bool isSky;
  64 
  65     public MaterialDetails()
  66     {
  67         instance = false;
  68         isgui = false;
  69         isSky = false;
  70     }
  71 };
  72 
  73 public class MeshDetails
  74 {
  75 
  76     public Mesh mesh;
  77 
  78     public List<MeshFilter> FoundInMeshFilters=new List<MeshFilter>();
  79     public List<SkinnedMeshRenderer> FoundInSkinnedMeshRenderer=new List<SkinnedMeshRenderer>();
  80     public bool instance;
  81 
  82     public MeshDetails()
  83     {
  84         instance = false;
  85     }
  86 };
  87 
  88 public class MissingGraphic{
  89     public Transform Object;
  90     public string type;
  91     public string name;
  92 }
  93 
  94 public class ResourceChecker : EditorWindow {
  95 
  96 
  97     string[] inspectToolbarStrings = {"Textures", "Materials","Meshes"};
  98     string[] inspectToolbarStrings2 = {"Textures", "Materials","Meshes", "Missing"};
  99 
 100     enum InspectType 
 101     {
 102         Textures,Materials,Meshes,Missing
 103     };
 104 
 105     bool IncludeDisabledObjects=true;
 106     bool IncludeSpriteAnimations=true;
 107     bool IncludeScriptReferences=true;
 108     bool IncludeGuiElements=true;
 109     bool thingsMissing = false;
 110 
 111     InspectType ActiveInspectType=InspectType.Textures;
 112 
 113     float ThumbnailWidth=40;
 114     float ThumbnailHeight=40;
 115 
 116     List<TextureDetails> ActiveTextures=new List<TextureDetails>();
 117     List<MaterialDetails> ActiveMaterials=new List<MaterialDetails>();
 118     List<MeshDetails> ActiveMeshDetails=new List<MeshDetails>();
 119     List<MissingGraphic> MissingObjects = new List<MissingGraphic> ();
 120 
 121     Vector2 textureListScrollPos=new Vector2(0,0);
 122     Vector2 materialListScrollPos=new Vector2(0,0);
 123     Vector2 meshListScrollPos=new Vector2(0,0);
 124     Vector2 missingListScrollPos = new Vector2 (0,0);
 125 
 126     int TotalTextureMemory=0;
 127     int TotalMeshVertices=0;
 128 
 129     bool ctrlPressed=false;
 130 
 131     static int MinWidth=475;
 132     Color defColor;
 133 
 134     bool collectedInPlayingMode;
 135 
 136     [MenuItem ("Window/Resource Checker")]
 137     static void Init ()
 138     {  
 139         ResourceChecker window = (ResourceChecker) EditorWindow.GetWindow (typeof (ResourceChecker));
 140         window.CheckResources();
 141         window.minSize=new Vector2(MinWidth,475);
 142     }
 143 
 144     void OnGUI ()
 145     {
 146         defColor = GUI.color;
 147         IncludeDisabledObjects = GUILayout.Toggle(IncludeDisabledObjects, "Include disabled objects", GUILayout.Width(300));
 148         IncludeSpriteAnimations = GUILayout.Toggle(IncludeSpriteAnimations, "Look in sprite animations", GUILayout.Width(300));
 149         GUI.color = new Color (0.8f, 0.8f, 1.0f, 1.0f);
 150         IncludeScriptReferences = GUILayout.Toggle(IncludeScriptReferences, "Look in behavior fields", GUILayout.Width(300));
 151         GUI.color = new Color (1.0f, 0.95f, 0.8f, 1.0f);
 152         IncludeGuiElements = GUILayout.Toggle(IncludeGuiElements, "Look in GUI elements", GUILayout.Width(300));
 153         GUI.color = defColor;
 154         GUILayout.BeginArea(new Rect(position.width-85,5,100,65));
 155         if (GUILayout.Button("Calculate",GUILayout.Width(80), GUILayout.Height(40)))
 156             CheckResources();
 157         if (GUILayout.Button("CleanUp",GUILayout.Width(80), GUILayout.Height(20)))
 158             Resources.UnloadUnusedAssets();
 159         GUILayout.EndArea();
 160         RemoveDestroyedResources();
 161 
 162         GUILayout.Space(30);
 163         if (thingsMissing == true) {
 164             EditorGUI.HelpBox (new Rect(8,75,300,25),"Some GameObjects are missing graphical elements.", MessageType.Error);
 165         }
 166         GUILayout.BeginHorizontal();
 167         GUILayout.Label("Textures "+ActiveTextures.Count+" - "+FormatSizeString(TotalTextureMemory));
 168         GUILayout.Label("Materials "+ActiveMaterials.Count);
 169         GUILayout.Label("Meshes "+ActiveMeshDetails.Count+" - "+TotalMeshVertices+" verts");
 170         GUILayout.EndHorizontal();
 171         if (thingsMissing == true) {
 172             ActiveInspectType = (InspectType)GUILayout.Toolbar ((int)ActiveInspectType, inspectToolbarStrings2);
 173         } else {
 174             ActiveInspectType = (InspectType)GUILayout.Toolbar ((int)ActiveInspectType, inspectToolbarStrings);
 175         }
 176 
 177         ctrlPressed=Event.current.control || Event.current.command;
 178 
 179         switch (ActiveInspectType)
 180         {
 181         case InspectType.Textures:
 182             ListTextures();
 183             break;
 184         case InspectType.Materials:
 185             ListMaterials();
 186             break;
 187         case InspectType.Meshes:
 188             ListMeshes();
 189             break;
 190         case InspectType.Missing:
 191             ListMissing();
 192             break;
 193         }
 194     }
 195 
 196     private void RemoveDestroyedResources()
 197     {
 198         if (collectedInPlayingMode != Application.isPlaying)
 199         {
 200             ActiveTextures.Clear();
 201             ActiveMaterials.Clear();
 202             ActiveMeshDetails.Clear();
 203             MissingObjects.Clear ();
 204             thingsMissing = false;
 205             collectedInPlayingMode = Application.isPlaying;
 206         }
 207         
 208         ActiveTextures.RemoveAll(x => !x.texture);
 209         ActiveTextures.ForEach(delegate(TextureDetails obj) {
 210             obj.FoundInAnimators.RemoveAll(x => !x);
 211             obj.FoundInMaterials.RemoveAll(x => !x);
 212             obj.FoundInRenderers.RemoveAll(x => !x);
 213             obj.FoundInScripts.RemoveAll(x => !x);
 214             obj.FoundInGraphics.RemoveAll(x => !x);
 215         });
 216 
 217         ActiveMaterials.RemoveAll(x => !x.material);
 218         ActiveMaterials.ForEach(delegate(MaterialDetails obj) {
 219             obj.FoundInRenderers.RemoveAll(x => !x);
 220             obj.FoundInGraphics.RemoveAll(x => !x);
 221         });
 222 
 223         ActiveMeshDetails.RemoveAll(x => !x.mesh);
 224         ActiveMeshDetails.ForEach(delegate(MeshDetails obj) {
 225             obj.FoundInMeshFilters.RemoveAll(x => !x);
 226             obj.FoundInSkinnedMeshRenderer.RemoveAll(x => !x);
 227         });
 228 
 229         TotalTextureMemory = 0;
 230         foreach (TextureDetails tTextureDetails in ActiveTextures) TotalTextureMemory += tTextureDetails.memSizeKB;
 231 
 232         TotalMeshVertices = 0;
 233         foreach (MeshDetails tMeshDetails in ActiveMeshDetails) TotalMeshVertices += tMeshDetails.mesh.vertexCount;
 234     }
 235 
 236     int GetBitsPerPixel(TextureFormat format)
 237     {
 238         switch (format)
 239         {
 240         case TextureFormat.Alpha8: //     Alpha-only texture format.
 241             return 8;
 242         case TextureFormat.ARGB4444: //     A 16 bits/pixel texture format. Texture stores color with an alpha channel.
 243             return 16;
 244         case TextureFormat.RGBA4444: //     A 16 bits/pixel texture format.
 245             return 16;
 246         case TextureFormat.RGB24:    // A color texture format.
 247             return 24;
 248         case TextureFormat.RGBA32:    //Color with an alpha channel texture format.
 249             return 32;
 250         case TextureFormat.ARGB32:    //Color with an alpha channel texture format.
 251             return 32;
 252         case TextureFormat.RGB565:    //     A 16 bit color texture format.
 253             return 16;
 254         case TextureFormat.DXT1:    // Compressed color texture format.
 255             return 4;
 256         case TextureFormat.DXT5:    // Compressed color with alpha channel texture format.
 257             return 8;
 258             /*
 259             case TextureFormat.WiiI4:    // Wii texture format.
 260             case TextureFormat.WiiI8:    // Wii texture format. Intensity 8 bit.
 261             case TextureFormat.WiiIA4:    // Wii texture format. Intensity + Alpha 8 bit (4 + 4).
 262             case TextureFormat.WiiIA8:    // Wii texture format. Intensity + Alpha 16 bit (8 + 8).
 263             case TextureFormat.WiiRGB565:    // Wii texture format. RGB 16 bit (565).
 264             case TextureFormat.WiiRGB5A3:    // Wii texture format. RGBA 16 bit (4443).
 265             case TextureFormat.WiiRGBA8:    // Wii texture format. RGBA 32 bit (8888).
 266             case TextureFormat.WiiCMPR:    //     Compressed Wii texture format. 4 bits/texel, ~RGB8A1 (Outline alpha is not currently supported).
 267                 return 0;  //Not supported yet
 268             */
 269         case TextureFormat.PVRTC_RGB2://     PowerVR (iOS) 2 bits/pixel compressed color texture format.
 270             return 2;
 271         case TextureFormat.PVRTC_RGBA2://     PowerVR (iOS) 2 bits/pixel compressed with alpha channel texture format
 272             return 2;
 273         case TextureFormat.PVRTC_RGB4://     PowerVR (iOS) 4 bits/pixel compressed color texture format.
 274             return 4;
 275         case TextureFormat.PVRTC_RGBA4://     PowerVR (iOS) 4 bits/pixel compressed with alpha channel texture format
 276             return 4;
 277         case TextureFormat.ETC_RGB4://     ETC (GLES2.0) 4 bits/pixel compressed RGB texture format.
 278             return 4;
 279         case TextureFormat.ATC_RGB4://     ATC (ATITC) 4 bits/pixel compressed RGB texture format.
 280             return 4;
 281         case TextureFormat.ATC_RGBA8://     ATC (ATITC) 8 bits/pixel compressed RGB texture format.
 282             return 8;
 283         case TextureFormat.BGRA32://     Format returned by iPhone camera
 284             return 32;
 285             #if !UNITY_5 && !UNITY_5_3_OR_NEWER
 286             case TextureFormat.ATF_RGB_DXT1://     Flash-specific RGB DXT1 compressed color texture format.
 287             case TextureFormat.ATF_RGBA_JPG://     Flash-specific RGBA JPG-compressed color texture format.
 288             case TextureFormat.ATF_RGB_JPG://     Flash-specific RGB JPG-compressed color texture format.
 289             return 0; //Not supported yet  
 290             #endif
 291         }
 292         return 0;
 293     }
 294 
 295     int CalculateTextureSizeBytes(Texture tTexture)
 296     {
 297 
 298         int tWidth=tTexture.width;
 299         int tHeight=tTexture.height;
 300         if (tTexture is Texture2D)
 301         {
 302             Texture2D tTex2D=tTexture as Texture2D;
 303             int bitsPerPixel=GetBitsPerPixel(tTex2D.format);
 304             int mipMapCount=tTex2D.mipmapCount;
 305             int mipLevel=1;
 306             int tSize=0;
 307             while (mipLevel<=mipMapCount)
 308             {
 309                 tSize+=tWidth*tHeight*bitsPerPixel/8;
 310                 tWidth=tWidth/2;
 311                 tHeight=tHeight/2;
 312                 mipLevel++;
 313             }
 314             return tSize;
 315         }
 316         if (tTexture is Texture2DArray)
 317         {
 318             Texture2DArray tTex2D=tTexture as Texture2DArray;
 319             int bitsPerPixel=GetBitsPerPixel(tTex2D.format);
 320             int mipMapCount=10;
 321             int mipLevel=1;
 322             int tSize=0;
 323             while (mipLevel<=mipMapCount)
 324             {
 325                 tSize+=tWidth*tHeight*bitsPerPixel/8;
 326                 tWidth=tWidth/2;
 327                 tHeight=tHeight/2;
 328                 mipLevel++;
 329             }
 330             return tSize*((Texture2DArray)tTex2D).depth;
 331         }
 332         if (tTexture is Cubemap) {
 333             Cubemap tCubemap = tTexture as Cubemap;
 334             int bitsPerPixel = GetBitsPerPixel (tCubemap.format);
 335             return tWidth * tHeight * 6 * bitsPerPixel/8;
 336         }
 337         return 0;
 338     }
 339 
 340 
 341     void SelectObject(Object selectedObject,bool append)
 342     {
 343         if (append)
 344         {
 345             List<Object> currentSelection=new List<Object>(Selection.objects);
 346             // Allow toggle selection
 347             if (currentSelection.Contains(selectedObject)) currentSelection.Remove(selectedObject);
 348             else currentSelection.Add(selectedObject);
 349 
 350             Selection.objects=currentSelection.ToArray();
 351         }
 352         else Selection.activeObject=selectedObject;
 353     }
 354 
 355     void SelectObjects(List<Object> selectedObjects,bool append)
 356     {
 357         if (append)
 358         {
 359             List<Object> currentSelection=new List<Object>(Selection.objects);
 360             currentSelection.AddRange(selectedObjects);
 361             Selection.objects=currentSelection.ToArray();
 362         }
 363         else Selection.objects=selectedObjects.ToArray();
 364     }
 365 
 366     void ListTextures()
 367     {
 368         textureListScrollPos = EditorGUILayout.BeginScrollView(textureListScrollPos);
 369 
 370         foreach (TextureDetails tDetails in ActiveTextures)
 371         {            
 372 
 373             GUILayout.BeginHorizontal ();
 374             Texture tex = new Texture();
 375             tex = tDetails.texture;
 376             if(tDetails.texture.GetType() == typeof(Texture2DArray) || tDetails.texture.GetType() == typeof(Cubemap)){
 377                 tex = AssetPreview.GetMiniThumbnail(tDetails.texture);
 378             }
 379             GUILayout.Box(tex, GUILayout.Width(ThumbnailWidth), GUILayout.Height(ThumbnailHeight));
 380 
 381             if (tDetails.instance == true)
 382                 GUI.color = new Color (0.8f, 0.8f, defColor.b, 1.0f);
 383             if (tDetails.isgui == true)
 384                 GUI.color = new Color (defColor.r, 0.95f, 0.8f, 1.0f);
 385             if (tDetails.isSky)
 386                 GUI.color = new Color (0.9f, defColor.g, defColor.b, 1.0f);
 387             if(GUILayout.Button(tDetails.texture.name,GUILayout.Width(150)))
 388             {
 389                 SelectObject(tDetails.texture,ctrlPressed);
 390             }
 391             GUI.color = defColor;
 392 
 393             string sizeLabel=""+tDetails.texture.width+"x"+tDetails.texture.height;
 394             if (tDetails.isCubeMap) sizeLabel+="x6";
 395             if (tDetails.texture.GetType () == typeof(Texture2DArray))
 396                 sizeLabel+= "[]\n" + ((Texture2DArray)tDetails.texture).depth+"depths";
 397             sizeLabel+=" - "+tDetails.mipMapCount+"mip\n"+FormatSizeString(tDetails.memSizeKB)+" - "+tDetails.format;
 398 
 399             GUILayout.Label (sizeLabel,GUILayout.Width(120));
 400 
 401             if(GUILayout.Button(tDetails.FoundInMaterials.Count+" Mat",GUILayout.Width(50)))
 402             {
 403                 SelectObjects(tDetails.FoundInMaterials,ctrlPressed);
 404             }
 405 
 406             HashSet<Object> FoundObjects = new HashSet<Object>();
 407             foreach (Renderer renderer in tDetails.FoundInRenderers) FoundObjects.Add(renderer.gameObject);
 408             foreach (Animator animator in tDetails.FoundInAnimators) FoundObjects.Add(animator.gameObject);
 409             foreach (Graphic graphic in tDetails.FoundInGraphics) FoundObjects.Add(graphic.gameObject);
 410             foreach (MonoBehaviour script in tDetails.FoundInScripts) FoundObjects.Add(script.gameObject);
 411             if (GUILayout.Button(FoundObjects.Count+" GO",GUILayout.Width(50)))
 412             {
 413                 SelectObjects(new List<Object>(FoundObjects),ctrlPressed);
 414             }
 415 
 416             GUILayout.EndHorizontal();    
 417         }
 418         if (ActiveTextures.Count>0)
 419         {
 420             EditorGUILayout.Space();
 421             GUILayout.BeginHorizontal ();
 422             //GUILayout.Box(" ",GUILayout.Width(ThumbnailWidth),GUILayout.Height(ThumbnailHeight));
 423             if(GUILayout.Button("Select \n All",GUILayout.Width(ThumbnailWidth*2)))
 424             {
 425                 List<Object> AllTextures=new List<Object>();
 426                 foreach (TextureDetails tDetails in ActiveTextures) AllTextures.Add(tDetails.texture);
 427                 SelectObjects(AllTextures,ctrlPressed);
 428             }
 429             EditorGUILayout.EndHorizontal();
 430         }
 431         EditorGUILayout.EndScrollView();
 432     }
 433 
 434     void ListMaterials()
 435     {
 436         materialListScrollPos = EditorGUILayout.BeginScrollView(materialListScrollPos);
 437 
 438         foreach (MaterialDetails tDetails in ActiveMaterials)
 439         {            
 440             if (tDetails.material!=null)
 441             {
 442                 GUILayout.BeginHorizontal ();
 443 
 444                 GUILayout.Box(AssetPreview.GetAssetPreview(tDetails.material), GUILayout.Width(ThumbnailWidth), GUILayout.Height(ThumbnailHeight));
 445 
 446                 if (tDetails.instance == true)
 447                     GUI.color = new Color (0.8f, 0.8f, defColor.b, 1.0f);
 448                 if (tDetails.isgui == true)
 449                     GUI.color = new Color (defColor.r, 0.95f, 0.8f, 1.0f);
 450                 if (tDetails.isSky)
 451                     GUI.color = new Color (0.9f, defColor.g, defColor.b, 1.0f);
 452                 if(GUILayout.Button(tDetails.material.name,GUILayout.Width(150)))
 453                 {
 454                     SelectObject(tDetails.material,ctrlPressed);
 455                 }
 456                 GUI.color = defColor;
 457 
 458                 string shaderLabel = tDetails.material.shader != null ?tDetails.material.shader.name : "no shader";
 459                 GUILayout.Label (shaderLabel, GUILayout.Width(200));
 460 
 461                 if(GUILayout.Button((tDetails.FoundInRenderers.Count + tDetails.FoundInGraphics.Count) +" GO",GUILayout.Width(50)))
 462                 {
 463                     List<Object> FoundObjects=new List<Object>();
 464                     foreach (Renderer renderer in tDetails.FoundInRenderers) FoundObjects.Add(renderer.gameObject);
 465                     foreach (Graphic graphic in tDetails.FoundInGraphics) FoundObjects.Add(graphic.gameObject);
 466                     SelectObjects(FoundObjects,ctrlPressed);
 467                 }
 468 
 469 
 470                 GUILayout.EndHorizontal();    
 471             }
 472         }
 473         EditorGUILayout.EndScrollView();        
 474     }
 475 
 476     void ListMeshes()
 477     {
 478         meshListScrollPos = EditorGUILayout.BeginScrollView(meshListScrollPos);
 479 
 480         foreach (MeshDetails tDetails in ActiveMeshDetails)
 481         {            
 482             if (tDetails.mesh!=null)
 483             {
 484                 GUILayout.BeginHorizontal ();
 485                 string name = tDetails.mesh.name;
 486                 if (name == null || name.Count() < 1)
 487                     name = tDetails.FoundInMeshFilters[0].gameObject.name;
 488                 if (tDetails.instance == true)
 489                     GUI.color = new Color (0.8f, 0.8f, defColor.b, 1.0f);
 490                 if(GUILayout.Button(name,GUILayout.Width(150)))
 491                 {
 492                     SelectObject(tDetails.mesh,ctrlPressed);
 493                 }
 494                 GUI.color = defColor;
 495                 string sizeLabel=""+tDetails.mesh.vertexCount+" vert";
 496 
 497                 GUILayout.Label (sizeLabel,GUILayout.Width(100));
 498 
 499 
 500                 if(GUILayout.Button(tDetails.FoundInMeshFilters.Count + " GO",GUILayout.Width(50)))
 501                 {
 502                     List<Object> FoundObjects=new List<Object>();
 503                     foreach (MeshFilter meshFilter in tDetails.FoundInMeshFilters) FoundObjects.Add(meshFilter.gameObject);
 504                     SelectObjects(FoundObjects,ctrlPressed);
 505                 }
 506                 if (tDetails.FoundInSkinnedMeshRenderer.Count > 0) {
 507                     if (GUILayout.Button (tDetails.FoundInSkinnedMeshRenderer.Count + " skinned mesh GO", GUILayout.Width (140))) {
 508                         List<Object> FoundObjects = new List<Object> ();
 509                         foreach (SkinnedMeshRenderer skinnedMeshRenderer in tDetails.FoundInSkinnedMeshRenderer)
 510                             FoundObjects.Add (skinnedMeshRenderer.gameObject);
 511                         SelectObjects (FoundObjects, ctrlPressed);
 512                     }
 513                 } else {
 514                     GUI.color = new Color (defColor.r, defColor.g, defColor.b, 0.5f);
 515                     GUILayout.Label("   0 skinned mesh");
 516                     GUI.color = defColor;
 517                 }
 518 
 519 
 520                 GUILayout.EndHorizontal();    
 521             }
 522         }
 523         EditorGUILayout.EndScrollView();        
 524     }
 525 
 526     void ListMissing(){
 527         missingListScrollPos = EditorGUILayout.BeginScrollView(missingListScrollPos);
 528         foreach (MissingGraphic dMissing in MissingObjects) {
 529             GUILayout.BeginHorizontal ();
 530             if (GUILayout.Button (dMissing.name, GUILayout.Width (150)))
 531                 SelectObject (dMissing.Object, ctrlPressed);
 532             GUILayout.Label ("missing ", GUILayout.Width(48));
 533             switch (dMissing.type) {
 534             case "mesh":
 535                 GUI.color = new Color (0.8f, 0.8f, defColor.b, 1.0f);
 536                 break;
 537             case "sprite":
 538                 GUI.color = new Color (defColor.r, 0.8f, 0.8f, 1.0f);
 539                 break;
 540             case "material":
 541                 GUI.color = new Color (0.8f, defColor.g, 0.8f, 1.0f);
 542                 break;
 543             }
 544             GUILayout.Label (dMissing.type);
 545             GUI.color = defColor;
 546             GUILayout.EndHorizontal ();
 547         }
 548         EditorGUILayout.EndScrollView();
 549     }
 550 
 551     string FormatSizeString(int memSizeKB)
 552     {
 553         if (memSizeKB<1024) return ""+memSizeKB+"k";
 554         else
 555         {
 556             float memSizeMB=((float)memSizeKB)/1024.0f;
 557             return memSizeMB.ToString("0.00")+"Mb";
 558         }
 559     }
 560 
 561 
 562     TextureDetails FindTextureDetails(Texture tTexture)
 563     {
 564         foreach (TextureDetails tTextureDetails in ActiveTextures)
 565         {
 566             if (tTextureDetails.texture==tTexture) return tTextureDetails;
 567         }
 568         return null;
 569 
 570     }
 571 
 572     MaterialDetails FindMaterialDetails(Material tMaterial)
 573     {
 574         foreach (MaterialDetails tMaterialDetails in ActiveMaterials)
 575         {
 576             if (tMaterialDetails.material==tMaterial) return tMaterialDetails;
 577         }
 578         return null;
 579 
 580     }
 581 
 582     MeshDetails FindMeshDetails(Mesh tMesh)
 583     {
 584         foreach (MeshDetails tMeshDetails in ActiveMeshDetails)
 585         {
 586             if (tMeshDetails.mesh==tMesh) return tMeshDetails;
 587         }
 588         return null;
 589 
 590     }
 591 
 592 
 593     void CheckResources()
 594     {
 595         ActiveTextures.Clear();
 596         ActiveMaterials.Clear();
 597         ActiveMeshDetails.Clear();
 598         MissingObjects.Clear ();
 599         thingsMissing = false;
 600 
 601         Renderer[] renderers = FindObjects<Renderer>();
 602 
 603         MaterialDetails skyMat = new MaterialDetails ();
 604         skyMat.material = RenderSettings.skybox;
 605         skyMat.isSky = true;
 606         ActiveMaterials.Add (skyMat);
 607 
 608         //Debug.Log("Total renderers "+renderers.Length);
 609         foreach (Renderer renderer in renderers)
 610         {
 611             //Debug.Log("Renderer is "+renderer.name);
 612             foreach (Material material in renderer.sharedMaterials)
 613             {
 614 
 615                 MaterialDetails tMaterialDetails = FindMaterialDetails(material);
 616                 if (tMaterialDetails == null)
 617                 {
 618                     tMaterialDetails = new MaterialDetails();
 619                     tMaterialDetails.material = material;
 620                     ActiveMaterials.Add(tMaterialDetails);
 621                 }
 622                 tMaterialDetails.FoundInRenderers.Add(renderer);
 623             }
 624 
 625             if (renderer is SpriteRenderer)
 626             {
 627                 SpriteRenderer tSpriteRenderer = (SpriteRenderer)renderer;
 628 
 629                 if (tSpriteRenderer.sprite != null) {
 630                     var tSpriteTextureDetail = GetTextureDetail (tSpriteRenderer.sprite.texture, renderer);
 631                     if (!ActiveTextures.Contains (tSpriteTextureDetail)) {
 632                         ActiveTextures.Add (tSpriteTextureDetail);
 633                     }
 634                 } else if (tSpriteRenderer.sprite == null) {
 635                     MissingGraphic tMissing = new MissingGraphic ();
 636                     tMissing.Object = tSpriteRenderer.transform;
 637                     tMissing.type = "sprite";
 638                     tMissing.name = tSpriteRenderer.transform.name;
 639                     MissingObjects.Add (tMissing);
 640                     thingsMissing = true;
 641                 }
 642             }
 643         }
 644 
 645         if (IncludeGuiElements)
 646         {
 647             Graphic[] graphics = FindObjects<Graphic>();
 648 
 649             foreach(Graphic graphic in graphics)
 650             {
 651                 if (graphic.mainTexture)
 652                 {
 653                     var tSpriteTextureDetail = GetTextureDetail(graphic.mainTexture, graphic);
 654                     if (!ActiveTextures.Contains(tSpriteTextureDetail))
 655                     {
 656                         ActiveTextures.Add(tSpriteTextureDetail);
 657                     }
 658                 }
 659 
 660                 if (graphic.materialForRendering)
 661                 {
 662                     MaterialDetails tMaterialDetails = FindMaterialDetails(graphic.materialForRendering);
 663                     if (tMaterialDetails == null)
 664                     {
 665                         tMaterialDetails = new MaterialDetails();
 666                         tMaterialDetails.material = graphic.materialForRendering;
 667                         tMaterialDetails.isgui = true;
 668                         ActiveMaterials.Add(tMaterialDetails);
 669                     }
 670                     tMaterialDetails.FoundInGraphics.Add(graphic);
 671                 }
 672             }
 673         }
 674 
 675         foreach (MaterialDetails tMaterialDetails in ActiveMaterials)
 676         {
 677             Material tMaterial = tMaterialDetails.material;
 678             if (tMaterial != null)
 679             {
 680                 var dependencies = EditorUtility.CollectDependencies(new UnityEngine.Object[] { tMaterial });
 681                 foreach (Object obj in dependencies)
 682                 {
 683                     if (obj is Texture)
 684                     {
 685                         Texture tTexture = obj as Texture;
 686                         var tTextureDetail = GetTextureDetail(tTexture, tMaterial, tMaterialDetails);
 687                         tTextureDetail.isSky = tMaterialDetails.isSky;
 688                         tTextureDetail.instance = tMaterialDetails.instance;
 689                         tTextureDetail.isgui = tMaterialDetails.isgui;
 690                         ActiveTextures.Add(tTextureDetail);
 691                     }
 692                 }
 693 
 694                 //if the texture was downloaded, it won't be included in the editor dependencies
 695                 if (tMaterial.HasProperty ("_MainTex")) {
 696                     if (tMaterial.mainTexture != null && !dependencies.Contains (tMaterial.mainTexture)) {
 697                         var tTextureDetail = GetTextureDetail (tMaterial.mainTexture, tMaterial, tMaterialDetails);
 698                         ActiveTextures.Add (tTextureDetail);
 699                     }
 700                 }
 701             }
 702         }
 703 
 704 
 705         MeshFilter[] meshFilters = FindObjects<MeshFilter>();
 706 
 707         foreach (MeshFilter tMeshFilter in meshFilters)
 708         {
 709             Mesh tMesh = tMeshFilter.sharedMesh;
 710             if (tMesh != null)
 711             {
 712                 MeshDetails tMeshDetails = FindMeshDetails(tMesh);
 713                 if (tMeshDetails == null)
 714                 {
 715                     tMeshDetails = new MeshDetails();
 716                     tMeshDetails.mesh = tMesh;
 717                     ActiveMeshDetails.Add(tMeshDetails);
 718                 }
 719                 tMeshDetails.FoundInMeshFilters.Add(tMeshFilter);
 720             } else if (tMesh == null && tMeshFilter.transform.GetComponent("TextContainer")== null) {
 721                 MissingGraphic tMissing = new MissingGraphic ();
 722                 tMissing.Object = tMeshFilter.transform;
 723                 tMissing.type = "mesh";
 724                 tMissing.name = tMeshFilter.transform.name;
 725                 MissingObjects.Add (tMissing);
 726                 thingsMissing = true;
 727             }
 728 
 729             var meshRenderrer = tMeshFilter.transform.GetComponent<MeshRenderer>();
 730                 
 731             if (meshRenderrer == null || meshRenderrer.sharedMaterial == null) {
 732                 MissingGraphic tMissing = new MissingGraphic ();
 733                 tMissing.Object = tMeshFilter.transform;
 734                 tMissing.type = "material";
 735                 tMissing.name = tMeshFilter.transform.name;
 736                 MissingObjects.Add (tMissing);
 737                 thingsMissing = true;
 738             }
 739         }
 740 
 741         SkinnedMeshRenderer[] skinnedMeshRenderers = FindObjects<SkinnedMeshRenderer>();
 742 
 743         foreach (SkinnedMeshRenderer tSkinnedMeshRenderer in skinnedMeshRenderers)
 744         {
 745             Mesh tMesh = tSkinnedMeshRenderer.sharedMesh;
 746             if (tMesh != null)
 747             {
 748                 MeshDetails tMeshDetails = FindMeshDetails(tMesh);
 749                 if (tMeshDetails == null)
 750                 {
 751                     tMeshDetails = new MeshDetails();
 752                     tMeshDetails.mesh = tMesh;
 753                     ActiveMeshDetails.Add(tMeshDetails);
 754                 }
 755                 tMeshDetails.FoundInSkinnedMeshRenderer.Add(tSkinnedMeshRenderer);
 756             } else if (tMesh == null) {
 757                 MissingGraphic tMissing = new MissingGraphic ();
 758                 tMissing.Object = tSkinnedMeshRenderer.transform;
 759                 tMissing.type = "mesh";
 760                 tMissing.name = tSkinnedMeshRenderer.transform.name;
 761                 MissingObjects.Add (tMissing);
 762                 thingsMissing = true;
 763             }
 764             if (tSkinnedMeshRenderer.sharedMaterial == null) {
 765                 MissingGraphic tMissing = new MissingGraphic ();
 766                 tMissing.Object = tSkinnedMeshRenderer.transform;
 767                 tMissing.type = "material";
 768                 tMissing.name = tSkinnedMeshRenderer.transform.name;
 769                 MissingObjects.Add (tMissing);
 770                 thingsMissing = true;
 771             }
 772         }
 773 
 774         if (IncludeSpriteAnimations)
 775         {
 776             Animator[] animators = FindObjects<Animator>();
 777             foreach (Animator anim in animators)
 778             {
 779                 #if UNITY_4_6 || UNITY_4_5 || UNITY_4_4 || UNITY_4_3
 780                 UnityEditorInternal.AnimatorController ac = anim.runtimeAnimatorController as UnityEditorInternal.AnimatorController;
 781                 #elif UNITY_5 || UNITY_5_3_OR_NEWER
 782                 UnityEditor.Animations.AnimatorController ac = anim.runtimeAnimatorController as UnityEditor.Animations.AnimatorController;
 783                 #endif
 784 
 785                 //Skip animators without layers, this can happen if they don't have an animator controller.
 786                 if (!ac || ac.layers == null || ac.layers.Length == 0)
 787                     continue;
 788 
 789                 for (int x = 0; x < anim.layerCount; x++)
 790                 {
 791                     #if UNITY_4_6 || UNITY_4_5 || UNITY_4_4 || UNITY_4_3
 792                     UnityEditorInternal.StateMachine sm = ac.GetLayer(x).stateMachine;
 793                     int cnt = sm.stateCount;
 794                     #elif UNITY_5 || UNITY_5_3_OR_NEWER
 795                     UnityEditor.Animations.AnimatorStateMachine sm = ac.layers[x].stateMachine;
 796                     int cnt = sm.states.Length;
 797                     #endif
 798 
 799                     for (int i = 0; i < cnt; i++)
 800                     {
 801                         #if UNITY_4_6 || UNITY_4_5 || UNITY_4_4 || UNITY_4_3
 802                         UnityEditorInternal.State state = sm.GetState(i);
 803                         Motion m = state.GetMotion();
 804                         #elif UNITY_5 || UNITY_5_3_OR_NEWER
 805                         UnityEditor.Animations.AnimatorState state = sm.states[i].state;
 806                         Motion m = state.motion;
 807                         #endif
 808                         if (m != null)
 809                         {
 810                             AnimationClip clip = m as AnimationClip;
 811 
 812                             if (clip != null)
 813                             {
 814                                 EditorCurveBinding[] ecbs = AnimationUtility.GetObjectReferenceCurveBindings(clip);
 815 
 816                                 foreach (EditorCurveBinding ecb in ecbs)
 817                                 {
 818                                     if (ecb.propertyName == "m_Sprite")
 819                                     {
 820                                         foreach (ObjectReferenceKeyframe keyframe in AnimationUtility.GetObjectReferenceCurve(clip, ecb))
 821                                         {
 822                                             Sprite tSprite = keyframe.value as Sprite;
 823 
 824                                             if (tSprite != null)
 825                                             {
 826                                                 var tTextureDetail = GetTextureDetail(tSprite.texture, anim);
 827                                                 if (!ActiveTextures.Contains(tTextureDetail))
 828                                                 {
 829                                                     ActiveTextures.Add(tTextureDetail);
 830                                                 }
 831                                             }
 832                                         }
 833                                     }
 834                                 }
 835                             }
 836                         }
 837                     }
 838                 }
 839 
 840             }
 841         }
 842 
 843         if (IncludeScriptReferences)
 844         {
 845             MonoBehaviour[] scripts = FindObjects<MonoBehaviour>();
 846             foreach (MonoBehaviour script in scripts)
 847             {
 848                 BindingFlags flags = BindingFlags.Public | BindingFlags.Instance; // only public non-static fields are bound to by Unity.
 849                 FieldInfo[] fields = script.GetType().GetFields(flags);
 850 
 851                 foreach (FieldInfo field in fields)
 852                 {
 853                     System.Type fieldType = field.FieldType;
 854                     if (fieldType == typeof(Sprite))
 855                     {
 856                         Sprite tSprite = field.GetValue(script) as Sprite;
 857                         if (tSprite != null)
 858                         {
 859                             var tSpriteTextureDetail = GetTextureDetail(tSprite.texture, script);
 860                             if (!ActiveTextures.Contains(tSpriteTextureDetail))
 861                             {
 862                                 ActiveTextures.Add(tSpriteTextureDetail);
 863                             }
 864                         }
 865                     }if (fieldType == typeof(Mesh))
 866                     {
 867                         Mesh tMesh = field.GetValue(script) as Mesh;
 868                         if (tMesh != null)
 869                         {
 870                             MeshDetails tMeshDetails = FindMeshDetails(tMesh);
 871                             if (tMeshDetails == null)
 872                             {
 873                                 tMeshDetails = new MeshDetails();
 874                                 tMeshDetails.mesh = tMesh;
 875                                 tMeshDetails.instance = true;
 876                                 ActiveMeshDetails.Add(tMeshDetails);
 877                             }
 878                         }
 879                     }if (fieldType == typeof(Material))
 880                     {
 881                         Material tMaterial = field.GetValue(script) as Material;
 882                         if (tMaterial != null)
 883                         {
 884                             MaterialDetails tMatDetails = FindMaterialDetails(tMaterial);
 885                             if (tMatDetails == null)
 886                             {
 887                                 tMatDetails = new MaterialDetails();
 888                                 tMatDetails.instance = true;
 889                                 tMatDetails.material = tMaterial;
 890                                 if(!ActiveMaterials.Contains(tMatDetails))
 891                                     ActiveMaterials.Add(tMatDetails);
 892                             }
 893                             if (tMaterial.mainTexture)
 894                             {
 895                                 var tSpriteTextureDetail = GetTextureDetail(tMaterial.mainTexture);
 896                                 if (!ActiveTextures.Contains(tSpriteTextureDetail))
 897                                 {
 898                                     ActiveTextures.Add(tSpriteTextureDetail);
 899                                 }
 900                             }
 901                             var dependencies = EditorUtility.CollectDependencies(new UnityEngine.Object[] { tMaterial });
 902                             foreach (Object obj in dependencies)
 903                             {
 904                                 if (obj is Texture)
 905                                 {
 906                                     Texture tTexture = obj as Texture;
 907                                     var tTextureDetail = GetTextureDetail(tTexture, tMaterial, tMatDetails);
 908                                     if(!ActiveTextures.Contains(tTextureDetail))
 909                                         ActiveTextures.Add(tTextureDetail);
 910                                 }
 911                             }
 912                         }
 913                     }
 914                 }
 915             }
 916         }
 917 
 918         TotalTextureMemory = 0;
 919         foreach (TextureDetails tTextureDetails in ActiveTextures) TotalTextureMemory += tTextureDetails.memSizeKB;
 920 
 921         TotalMeshVertices = 0;
 922         foreach (MeshDetails tMeshDetails in ActiveMeshDetails) TotalMeshVertices += tMeshDetails.mesh.vertexCount;
 923 
 924         // Sort by size, descending
 925         ActiveTextures.Sort(delegate(TextureDetails details1, TextureDetails details2) { return details2.memSizeKB - details1.memSizeKB; });
 926         ActiveTextures = ActiveTextures.Distinct().ToList();
 927         ActiveMeshDetails.Sort(delegate(MeshDetails details1, MeshDetails details2) { return details2.mesh.vertexCount - details1.mesh.vertexCount; });
 928 
 929         collectedInPlayingMode = Application.isPlaying;
 930     }
 931 
 932     private static GameObject[] GetAllRootGameObjects()
 933     {
 934 #if !UNITY_5 && !UNITY_5_3_OR_NEWER
 935         return UnityEngine.SceneManagement.SceneManager.GetActiveScene().GetRootGameObjects().ToArray();
 936 #else
 937         List<GameObject> allGo = new List<GameObject>();
 938         for (int sceneIdx = 0; sceneIdx < UnityEngine.SceneManagement.SceneManager.sceneCount; ++sceneIdx){
 939             allGo.AddRange( UnityEngine.SceneManagement.SceneManager.GetSceneAt(sceneIdx).GetRootGameObjects().ToArray() );
 940         }
 941         return allGo.ToArray();
 942 #endif
 943     }
 944 
 945     private T[] FindObjects<T>() where T : Object
 946     {
 947         if (IncludeDisabledObjects) {
 948             List<T> meshfilters = new List<T> ();
 949             GameObject[] allGo = GetAllRootGameObjects();
 950             foreach (GameObject go in allGo) {
 951                 Transform[] tgo = go.GetComponentsInChildren<Transform> (true).ToArray ();
 952                 foreach (Transform tr in tgo) {
 953                     if (tr.GetComponent<T> ())
 954                         meshfilters.Add (tr.GetComponent<T> ());
 955                 }
 956             }
 957             return (T[])meshfilters.ToArray ();
 958         }
 959         else
 960             return (T[])FindObjectsOfType(typeof(T));
 961     }
 962 
 963     private TextureDetails GetTextureDetail(Texture tTexture, Material tMaterial, MaterialDetails tMaterialDetails)
 964     {
 965         TextureDetails tTextureDetails = GetTextureDetail(tTexture);
 966 
 967         tTextureDetails.FoundInMaterials.Add(tMaterial);
 968         foreach (Renderer renderer in tMaterialDetails.FoundInRenderers)
 969         {
 970             if (!tTextureDetails.FoundInRenderers.Contains(renderer)) tTextureDetails.FoundInRenderers.Add(renderer);
 971         }
 972         return tTextureDetails;
 973     }
 974 
 975     private TextureDetails GetTextureDetail(Texture tTexture, Renderer renderer)
 976     {
 977         TextureDetails tTextureDetails = GetTextureDetail(tTexture);
 978 
 979         tTextureDetails.FoundInRenderers.Add(renderer);
 980         return tTextureDetails;
 981     }
 982 
 983     private TextureDetails GetTextureDetail(Texture tTexture, Animator animator)
 984     {
 985         TextureDetails tTextureDetails = GetTextureDetail(tTexture);
 986 
 987         tTextureDetails.FoundInAnimators.Add(animator);
 988         return tTextureDetails;
 989     }
 990 
 991     private TextureDetails GetTextureDetail(Texture tTexture, Graphic graphic)
 992     {
 993         TextureDetails tTextureDetails = GetTextureDetail(tTexture);
 994 
 995         tTextureDetails.FoundInGraphics.Add(graphic);
 996         return tTextureDetails;
 997     }
 998 
 999     private TextureDetails GetTextureDetail(Texture tTexture, MonoBehaviour script)
1000     {
1001         TextureDetails tTextureDetails = GetTextureDetail(tTexture);
1002 
1003         tTextureDetails.FoundInScripts.Add(script);
1004         return tTextureDetails;
1005     }
1006 
1007     private TextureDetails GetTextureDetail(Texture tTexture)
1008     {
1009         TextureDetails tTextureDetails = FindTextureDetails(tTexture);
1010         if (tTextureDetails == null)
1011         {
1012             tTextureDetails = new TextureDetails();
1013             tTextureDetails.texture = tTexture;
1014             tTextureDetails.isCubeMap = tTexture is Cubemap;
1015 
1016             int memSize = CalculateTextureSizeBytes(tTexture);
1017 
1018             TextureFormat tFormat = TextureFormat.RGBA32;
1019             int tMipMapCount = 1;
1020             if (tTexture is Texture2D)
1021             {
1022                 tFormat = (tTexture as Texture2D).format;
1023                 tMipMapCount = (tTexture as Texture2D).mipmapCount;
1024             }
1025             if (tTexture is Cubemap)
1026             {
1027                 tFormat = (tTexture as Cubemap).format;
1028                 memSize = 8 * tTexture.height * tTexture.width;
1029             }
1030             if(tTexture is Texture2DArray){
1031                 tFormat = (tTexture as Texture2DArray).format;
1032                 tMipMapCount = 10;
1033             }
1034 
1035             tTextureDetails.memSizeKB = memSize/1024;
1036             tTextureDetails.format = tFormat;
1037             tTextureDetails.mipMapCount = tMipMapCount;
1038 
1039         }
1040 
1041         return tTextureDetails;
1042     }
1043 
1044 }

ResourceChecker

download address: https://github.com/handcircus/Unity-Resource-Checker

use: Unity navigation menu bar select Windows -> Resource Checker, click to get

ii, UnityAssetCleaner

super diao Fried day plug-in, strongly recommended to use, there are three types of cleaning up the resource mode, more importantly, it will remove the resources under the assets,

will automatically delete the file backup a package package, so you no longer need to worry about mistakenly delete useful resources, mistakenly delete, the biggest thing is the package package guide in.

code:

  1 /**
  2     asset cleaner
  3     Copyright (c) 2015 Tatsuhiko Yamamura
  4 
  5     This software is released under the MIT License.
  6     http://opensource.org/licenses/mit-license.php
  7 */
  8 using UnityEngine;
  9 using System.Collections;
 10 using System.Collections.Generic;
 11 using System.Linq;
 12 using UnityEditor;
 13 using System.IO;
 14 using System.Text.RegularExpressions;
 15 
 16 namespace AssetClean
 17 {
 18     public class AssetCollector
 19     {
 20         public List<string> deleteFileList = new List<string> ();
 21         ClassReferenceCollection classCollection = new ClassReferenceCollection ();
 22         ShaderReferenceCollection shaderCollection = new ShaderReferenceCollection ();
 23 
 24         public bool useCodeStrip = true;
 25         public bool saveEditorExtensions = true;
 26 
 27         public void Collection ()
 28         {
 29             try {
 30                 deleteFileList.Clear ();
 31 
 32                 if( useCodeStrip ){
 33                     classCollection.Collection ();
 34                 }
 35                 shaderCollection.Collection ();
 36 
 37                 // Find assets
 38                 var files = Directory.GetFiles ("Assets", "*.*", SearchOption.AllDirectories)
 39                     .Where (item => Path.GetExtension (item) != ".meta")
 40                     .Where (item => Path.GetExtension (item) != ".js")
 41                     .Where (item => Path.GetExtension (item) != ".dll")
 42                     .Where (item => Regex.IsMatch (item, "[\\/\\\\]Gizmos[\\/\\\\]") == false)
 43                     .Where (item => Regex.IsMatch (item, "[\\/\\\\]Plugins[\\/\\\\]Android[\\/\\\\]") == false)
 44                     .Where (item => Regex.IsMatch (item, "[\\/\\\\]Plugins[\\/\\\\]iOS[\\/\\\\]") == false)
 45                     .Where (item => Regex.IsMatch (item, "[\\/\\\\]Resources[\\/\\\\]") == false);
 46 
 47                 if( useCodeStrip == false ){
 48                     files = files.Where( item => Path.GetExtension(item) != ".cs");
 49                 }
 50 
 51                 foreach (var path in files) {
 52                     var guid = AssetDatabase.AssetPathToGUID (path);
 53                     deleteFileList.Add (guid);
 54                 }
 55                 EditorUtility.DisplayProgressBar ("checking", "collection all files", 0.2f);
 56                 UnregistReferenceFromResources();
 57                 
 58                 EditorUtility.DisplayProgressBar ("checking", "check reference from resources", 0.4f);
 59                 UnregistReferenceFromScenes();
 60 
 61                 EditorUtility.DisplayProgressBar ("checking", "check reference from scenes", 0.6f);
 62                 if( saveEditorExtensions ){
 63                     UnregistEditorCodes();
 64                 }
 65             } finally {
 66                 EditorUtility.ClearProgressBar ();
 67             }
 68         }
 69         void UnregistReferenceFromResources()
 70         {
 71             var resourcesFiles = Directory.GetFiles ("Assets", "*.*", SearchOption.AllDirectories)
 72                 .Where (item => Regex.IsMatch (item, "[\\/\\\\]Resources[\\/\\\\]") == true)
 73                     .Where (item => Path.GetExtension (item) != ".meta")
 74                     .ToArray ();
 75             foreach (var path in AssetDatabase.GetDependencies (resourcesFiles)) {
 76                 UnregistFromDelteList (AssetDatabase.AssetPathToGUID(path));
 77             }
 78         }
 79         
 80         void UnregistReferenceFromScenes()
 81         {
 82             // Exclude objects that reference from scenes.
 83             var scenes = EditorBuildSettings.scenes
 84                 .Where (item => item.enabled == true)
 85                     .Select (item => item.path)
 86                     .ToArray ();
 87             foreach (var path in AssetDatabase.GetDependencies (scenes)) {
 88                 if( saveEditorExtensions == false ){
 89                     Debug.Log(path);
 90                 }
 91                 UnregistFromDelteList (AssetDatabase.AssetPathToGUID(path));
 92             } 
 93         }
 94 
 95         void UnregistEditorCodes()
 96         {
 97             // Exclude objects that reference from Editor API
 98             var editorcodes = Directory.GetFiles ("Assets", "*.cs", SearchOption.AllDirectories)
 99                 .Where (item => Regex.IsMatch (item, "[\\/\\\\]Editor[\\/\\\\]") == true)
100                     .ToArray ();
101             
102             var undeleteClassList = classCollection.codeFileList
103                 .Where (codefile => codefile.Value.Any( guid => deleteFileList.Contains(guid)) == false)
104                     .Select( item => item.Key );
105             
106             EditorUtility.DisplayProgressBar ("checking", "check reference from editor codes", 0.8f);
107             
108             foreach (var path in editorcodes) {
109                 var code = File.ReadAllText (path);
110                 code = Regex.Replace(code, "//.*[\\n\\r]", "");
111                 code = Regex.Replace(code, "/\\*.*[\\n\\r]\\*/", "");
112                 if (Regex.IsMatch (code, "(\\[MenuItem|AssetPostprocessor|EditorWindow)")) {
113                     UnregistFromDelteList ( AssetDatabase.AssetPathToGUID(path));
114                     continue;
115                 }
116                 
117                 foreach (var undeleteClass in undeleteClassList) {
118                     if (Regex.IsMatch (code, string.Format ("\\[CustomEditor.*\\(\\s*{0}\\s*\\).*\\]", undeleteClass.Name))) {
119                         UnregistFromDelteList (path);
120                         continue;
121                     }
122                 }
123             }
124         }
125 
126         void UnregistFromDelteList (string guid)
127         {
128             if (deleteFileList.Contains (guid) == false) {
129                 return;
130             }
131             deleteFileList.Remove (guid);
132             
133             if (classCollection.references.ContainsKey (guid) == true) {
134                 
135                 foreach (var type in classCollection.references[guid]) {
136                     var codePaths = classCollection.codeFileList [type];
137                     foreach( var codePath in codePaths){
138                         UnregistFromDelteList (codePath);
139                     }
140                 }
141             }
142             
143             if (shaderCollection.shaderFileList.ContainsValue (guid)) {
144                 var shader = shaderCollection.shaderFileList.First (item => item.Value == guid);
145                 var shaderAssets = shaderCollection.shaderReferenceList [shader.Key];
146                 foreach (var shaderPath in shaderAssets) {
147                     UnregistFromDelteList (shaderPath);
148                 }
149             }
150         }
151     }
152 }

AssetCollector

  1 /**
  2     asset cleaner
  3     Copyright (c) 2015 Tatsuhiko Yamamura
  4 
  5     This software is released under the MIT License.
  6     http://opensource.org/licenses/mit-license.php
  7 */
  8 using UnityEngine;
  9 using System.Collections;
 10 using System.Collections.Generic;
 11 using System.Text.RegularExpressions;
 12 using UnityEditor;
 13 using System.IO;
 14 using System.Reflection;
 15 using System.Linq;
 16 
 17 namespace AssetClean
 18 {
 19     public class ClassReferenceCollection
 20     {
 21         // type : guid
 22         public Dictionary<System.Type, List<string>> codeFileList = new Dictionary<System.Type, List<string>> ();
 23         // guid : types
 24         public Dictionary<string, List<System.Type>> references = new Dictionary<string, List<System.Type>> ();
 25 
 26         public void Collection ()
 27         {
 28             references.Clear ();
 29             EditorUtility.DisplayProgressBar ("checking", "collection all type", 0);
 30 
 31             // Connect the files and class.
 32             var codes = Directory.GetFiles ("Assets", "*.cs", SearchOption.AllDirectories);
 33             // connect each classes.
 34             var firstPassList = new List<string>();
 35             if( Directory.Exists ("Assets/Plugins") )
 36                 firstPassList.AddRange( Directory.GetFiles ("Assets/Plugins", "*.cs", SearchOption.AllDirectories));
 37             if( Directory.Exists ("Assets/Standard Assets") )
 38                 firstPassList.AddRange( Directory.GetFiles ("Assets/Standard Assets", "*.cs", SearchOption.AllDirectories));
 39 
 40             var allFirstpassTypes = collectionAllFastspassClasses ();
 41             CollectionCodeFileDictionary (allFirstpassTypes, firstPassList.ToArray());
 42 
 43 
 44             var alltypes = CollectionAllClasses ();
 45             CollectionCodeFileDictionary (alltypes, codes.ToArray());
 46             alltypes.AddRange (allFirstpassTypes);
 47 
 48             int count = 0;
 49             foreach (var codepath in firstPassList) {
 50                 CollectionReferenceClasses (AssetDatabase.AssetPathToGUID (codepath), allFirstpassTypes);
 51                 EditorUtility.DisplayProgressBar ("checking", "analytics codes", ((float)++count/codes.Length) * 0.5f + 0.5f);
 52             }
 53             count = 0;
 54             foreach (var codepath in codes) {
 55                 CollectionReferenceClasses (AssetDatabase.AssetPathToGUID (codepath), alltypes);
 56                 EditorUtility.DisplayProgressBar ("checking", "analytics codes", ((float)++count/codes.Length) * 0.5f);
 57             }
 58         }
 59 
 60         void CollectionCodeFileDictionary (List<System.Type> alltypes, string[] codes)
 61         {
 62             float count = 1;
 63             foreach (var codePath in codes) {
 64                 EditorUtility.DisplayProgressBar ("checking", "search files", count++ / codes.Length);
 65 
 66                 // connect file and classes.
 67                 var code = System.IO.File.ReadAllText (codePath);
 68                 code = Regex.Replace(code, "//.*[\\n\\r]", "");
 69                 code = Regex.Replace(code, "/\\*.*[\\n\\r]\\*/", "");
 70 
 71                 foreach (var type in alltypes) {
 72 
 73                     if( codeFileList.ContainsKey(type ) == false ){
 74                         codeFileList.Add(type, new List<string>());
 75                     }
 76                     var list = codeFileList[type];
 77                 
 78                     if (string.IsNullOrEmpty (type.Namespace) == false) {
 79                         var namespacepattern = string.Format ("namespace[\\s.]{0}[{{\\s\\n]", type.Namespace);
 80                         if (Regex.IsMatch (code, namespacepattern) == false) {
 81                             continue;
 82                         }
 83                     }
 84 
 85                     string typeName = type.IsGenericTypeDefinition ?type.GetGenericTypeDefinition ().Name.Split ('`') [0] : type.Name;
 86                     if (Regex.IsMatch (code, string.Format ("class\\s*{0}?[\\s:<{{]", typeName))) {
 87                         list.Add( AssetDatabase.AssetPathToGUID(codePath) );
 88                         continue;
 89                     }
 90 
 91                     if (Regex.IsMatch (code, string.Format ("struct\\s*{0}[\\s:<{{]", typeName))) {
 92                         list.Add( AssetDatabase.AssetPathToGUID(codePath) );
 93                         continue;
 94                     }
 95                 
 96                     if (Regex.IsMatch (code, string.Format ("enum\\s*{0}[\\s{{]", type.Name))) {
 97                         list.Add( AssetDatabase.AssetPathToGUID(codePath) );
 98                         continue;
 99                     }
100                 
101                     if (Regex.IsMatch (code, string.Format ("delegate\\s*{0}\\s\\(", type.Name))) {
102                         list.Add( AssetDatabase.AssetPathToGUID(codePath) );
103                         continue;
104                     }
105                 }
106             }
107         }
108 
109         List<System.Type> CollectionAllClasses ()
110         {
111             List<System.Type> alltypes = new List<System.Type> ();
112         
113             if (File.Exists ("Library/ScriptAssemblies/Assembly-CSharp.dll"))
114                 alltypes.AddRange (Assembly.LoadFile ("Library/ScriptAssemblies/Assembly-CSharp.dll").GetTypes ());
115             if (File.Exists ("Library/ScriptAssemblies/Assembly-CSharp-Editor.dll"))
116                 alltypes.AddRange (Assembly.LoadFile ("Library/ScriptAssemblies/Assembly-CSharp-Editor.dll").GetTypes ());
117 
118             return alltypes    .ToList ();
119         }
120 
121         List<System.Type> collectionAllFastspassClasses()
122         {
123             List<System.Type> alltypes = new List<System.Type> ();
124             if (File.Exists ("Library/ScriptAssemblies/Assembly-CSharp-firstpass.dll"))
125                 alltypes.AddRange (Assembly.LoadFile ("Library/ScriptAssemblies/Assembly-CSharp-firstpass.dll").GetTypes ());
126             if (File.Exists ("Library/ScriptAssemblies/Assembly-CSharp-Editor-firstpass.dll"))
127                 alltypes.AddRange (Assembly.LoadFile ("Library/ScriptAssemblies/Assembly-CSharp-Editor-firstpass.dll").GetTypes ());
128             return alltypes;
129         }
130         
131         void CollectionReferenceClasses (string guid, List<System.Type> types)
132         {
133             var codePath = AssetDatabase.GUIDToAssetPath(guid);
134             if (string.IsNullOrEmpty (codePath) || references.ContainsKey (guid) || File.Exists(codePath)==false) {
135                 return;
136             }
137 
138             var code = System.IO.File.ReadAllText (codePath);
139             code = Regex.Replace(code, "//.*[\\n\\r]", "");
140             code = Regex.Replace(code, "/\\*.*[\\n\\r]\\*/", "");
141 
142             var list = new List<System.Type> ();
143             references [guid] = list;
144 
145             foreach (var type in types) {
146     
147                 if (string.IsNullOrEmpty (type.Namespace) == false) {
148                     var namespacepattern = string.Format ("[namespace|using][\\s\\.]{0}[{{\\s\\r\\n\\r;]", type.Namespace);
149                     if (Regex.IsMatch (code, namespacepattern) == false) {
150                         continue;
151                     }
152                 }
153 
154                 if (codeFileList.ContainsKey (type) == false) {
155                     continue;
156                 }
157 
158                 string match = string.Empty;
159                 if (type.IsGenericTypeDefinition) {
160                     string typeName = type.GetGenericTypeDefinition ().Name.Split ('`') [0];
161                     match = string.Format ("[\\]\\[\\.\\s<(]{0}[\\.\\s\\n\\r>,<(){{]", typeName);
162                 } else {
163                     match = string.Format ("[\\]\\[\\.\\s<(]{0}[\\.\\s\\n\\r>,<(){{\\]]", type.Name.Replace("Attribute", ""));
164                 }
165                 if (Regex.IsMatch (code, match)) {
166                     list.Add (type);
167                     var typeGuid =  codeFileList[type];
168                     foreach( var referenceGuid in typeGuid){
169                         CollectionReferenceClasses (referenceGuid, types);
170                     }
171                 }
172             }
173         }
174     }
175 }

ClassReferenceCollection

  1 /**
  2     asset cleaner
  3     Copyright (c) 2015 Tatsuhiko Yamamura
  4 
  5     This software is released under the MIT License.
  6     http://opensource.org/licenses/mit-license.php
  7 */
  8 using UnityEngine;
  9 using System.Collections;
 10 using System.Collections.Generic;
 11 using UnityEditor;
 12 using System.IO;
 13 using System.Linq;
 14 
 15 namespace AssetClean
 16 {
 17     public class FindUnusedAssets : EditorWindow
 18     {
 19         AssetCollector collection = new AssetCollector ();
 20         List<DeleteAsset> deleteAssets = new List<DeleteAsset> ();
 21         Vector2 scroll;
 22 
 23         [MenuItem("Assets/Delete Unused Assets/only resource", false, 50)]
 24         static void InitWithoutCode ()
 25         {
 26             var window = FindUnusedAssets.CreateInstance<FindUnusedAssets> ();
 27             window.collection.useCodeStrip = false;
 28             window.collection.Collection ();
 29             window.CopyDeleteFileList (window.collection.deleteFileList);
 30             
 31             window.Show ();
 32         }
 33 
 34         [MenuItem("Assets/Delete Unused Assets/unused by editor", false, 51)]
 35         static void InitWithout ()
 36         {
 37             var window = FindUnusedAssets.CreateInstance<FindUnusedAssets> ();
 38             window.collection.Collection ();
 39             window.CopyDeleteFileList (window.collection.deleteFileList);
 40             
 41             window.Show ();
 42         }
 43 
 44         [MenuItem("Assets/Delete Unused Assets/unused by game", false, 52)]
 45         static void Init ()
 46         {
 47             var window = FindUnusedAssets.CreateInstance<FindUnusedAssets> ();
 48             window.collection.saveEditorExtensions = false;
 49             window.collection.Collection ();
 50             window.CopyDeleteFileList (window.collection.deleteFileList);
 51             
 52             window.Show ();
 53         }
 54         
 55         void OnGUI ()
 56         {
 57             using (var horizonal = new EditorGUILayout.HorizontalScope("box")) {
 58                 EditorGUILayout.LabelField ("delete unreference assets from buildsettings and resources");
 59 
 60                 if (GUILayout.Button ("Delete", GUILayout.Width (120), GUILayout.Height (40)) && deleteAssets.Count != 0) {
 61                     RemoveFiles ();
 62                     Close ();
 63                 }
 64             }
 65 
 66             using (var scrollScope = new EditorGUILayout.ScrollViewScope(scroll)) {
 67                 scroll = scrollScope.scrollPosition;
 68                 foreach (var asset in deleteAssets) {
 69                     if (string.IsNullOrEmpty (asset.path)) {
 70                         continue;
 71                     }
 72 
 73                     using (var horizonal = new EditorGUILayout.HorizontalScope()) {
 74                         asset.isDelete = EditorGUILayout.Toggle (asset.isDelete, GUILayout.Width (20));
 75                         var icon = AssetDatabase.GetCachedIcon (asset.path);
 76                         GUILayout.Label (icon, GUILayout.Width (20), GUILayout.Height (20));
 77                         if (GUILayout.Button (asset.path, EditorStyles.largeLabel)) {
 78                             Selection.activeObject = AssetDatabase.LoadAssetAtPath<Object> (asset.path);
 79                         }
 80                     }
 81                 }
 82             }
 83 
 84         }
 85 
 86          static void CleanDir()
 87          {
 88             RemoveEmptyDirectry ("Assets");
 89             AssetDatabase.Refresh ();
 90         }
 91 
 92         void CopyDeleteFileList(IEnumerable<string> deleteFileList)
 93         {
 94             foreach (var asset in deleteFileList) {
 95                 var filePath = AssetDatabase.GUIDToAssetPath (asset);
 96                 if (string.IsNullOrEmpty (filePath) == false) {
 97                     deleteAssets.Add (new DeleteAsset (){ path = filePath});
 98                 }
 99             }
100         }
101 
102         void RemoveFiles ()
103         {
104             try {
105                 string exportDirectry = "BackupUnusedAssets";
106                 Directory.CreateDirectory (exportDirectry);
107                 var files = deleteAssets.Where (item => item.isDelete == true).Select (item => item.path).ToArray ();
108                 string backupPackageName = exportDirectry + "/package" + System.DateTime.Now.ToString ("yyyyMMddHHmmss") + ".unitypackage";
109                 EditorUtility.DisplayProgressBar ("export package", backupPackageName, 0);
110                 AssetDatabase.ExportPackage (files, backupPackageName);
111 
112                 int i = 0;
113                 int length = deleteAssets.Count;
114 
115                 foreach (var assetPath in files) {
116                     i++;
117                     EditorUtility.DisplayProgressBar ("delete unused assets", assetPath, (float)i / length);
118                     AssetDatabase.DeleteAsset (assetPath);
119                 }
120 
121                 EditorUtility.DisplayProgressBar ("clean directory", "", 1);
122                 foreach (var dir in Directory.GetDirectories("Assets")) {
123                     RemoveEmptyDirectry (dir);
124                 }
125 
126                 System.Diagnostics.Process.Start (exportDirectry);
127 
128                 AssetDatabase.Refresh ();
129             }
130             catch( System.Exception e ){
131                 Debug.Log(e.Message);
132             }finally {
133                 EditorUtility.ClearProgressBar ();
134             }
135         }
136 
137         static void RemoveEmptyDirectry (string path)
138         {
139             var dirs = Directory.GetDirectories (path);
140             foreach (var dir in dirs) {
141                 RemoveEmptyDirectry (dir);
142             }
143 
144             var files = Directory.GetFiles (path, "*", SearchOption.TopDirectoryOnly).Where (item => Path.GetExtension (item) != ".meta");
145             if (files.Count () == 0 && Directory.GetDirectories (path).Count () == 0) {
146                 var metaFile = AssetDatabase.GetTextMetaFilePathFromAssetPath(path);
147                 UnityEditor.FileUtil.DeleteFileOrDirectory (path);
148                 UnityEditor.FileUtil.DeleteFileOrDirectory (metaFile);
149             }
150         }
151 
152         class DeleteAsset
153         {
154             public bool isDelete = true;
155             public string path;
156         }
157     }
158 }

FindUnusedAssets

 1 /**
 2     asset cleaner
 3     Copyright (c) 2015 Tatsuhiko Yamamura
 4 
 5     This software is released under the MIT License.
 6     http://opensource.org/licenses/mit-license.php
 7 */
 8 using UnityEngine;
 9 using System.Collections;
10 using System.Collections.Generic;
11 using System.IO;
12 using System.Text.RegularExpressions;
13 using UnityEditor;
14 
15 namespace AssetClean
16 {
17     public class ShaderReferenceCollection
18     {
19         // shader name/shader file guid
20         public Dictionary<string, string> shaderFileList = new Dictionary<string, string> ();
21         public Dictionary<string, List<string> > shaderReferenceList = new Dictionary<string, List<string>> ();
22 
23         public void Collection ()
24         {
25             CollectionShaderFiles ();
26             CheckReference ();
27         }
28 
29         void CollectionShaderFiles ()
30         {
31             var shaderFiles = Directory.GetFiles ("Assets", "*.shader", SearchOption.AllDirectories);
32             foreach (var shaderFilePath in shaderFiles) {
33                 var code = File.ReadAllText (shaderFilePath);
34                 var match = Regex.Match (code, "Shader \"(?<name>.*)\"");
35                 if (match.Success) {
36                     var shaderName = match.Groups ["name"].ToString ();
37                     if (shaderFileList.ContainsKey (shaderName) == false) {
38                         shaderFileList.Add (shaderName, AssetDatabase.AssetPathToGUID(shaderFilePath));
39                     }
40                 }
41             }
42         
43             var cgFiles = Directory.GetFiles ("Assets", "*.cg", SearchOption.AllDirectories);
44             foreach (var cgFilePath in cgFiles) {
45                 var file = Path.GetFileName (cgFilePath);
46                 shaderFileList.Add (file, cgFilePath);
47             }
48 
49             var cgincFiles = Directory.GetFiles ("Assets", "*.cginc", SearchOption.AllDirectories);
50             foreach (var cgincPath in cgincFiles) {
51                 var file = Path.GetFileName (cgincPath);
52                 shaderFileList.Add (file, cgincPath);
53             }
54         }
55 
56         void CheckReference ()
57         {
58             foreach (var shader in shaderFileList) {
59                 var shaderFilePath = AssetDatabase.GUIDToAssetPath(shader.Value);
60                 var shaderName = shader.Key;
61             
62                 List<string> referenceList = new List<string> ();
63                 shaderReferenceList.Add (shaderName, referenceList);
64             
65                 var code = File.ReadAllText (shaderFilePath);
66             
67                 foreach (var checkingShaderName in shaderFileList.Keys) {
68                     if (Regex.IsMatch (code, string.Format ("{0}", checkingShaderName))) {
69                         var filePath = shaderFileList [checkingShaderName];
70                         referenceList.Add (filePath);
71                     }
72                 }
73             }
74         }
75     }
76 }

ShaderReferenceCollection

Reality cn/tool-unityassetcleaner

is one of the few reality cleaners

use: Unity navigation menu bar select Assets-> Delete Unused Assets

three modes, select a suitable, and then click Delete, easy to fix

reproduced in: https://www.cnblogs.com/Jason-c/p/7526326.html