public void UpdateIfNeeded()
{
if (string.IsNullOrEmpty(Path))
{
Debug.LogWarning(Maintainer.LogPrefix + "Can't update Asset since path is not set!");
return;
}
/*if (Path.Contains("qwerty.unity"))
* {
* Debug.Log(Path);
* }*/
fileInfo.Refresh();
if (!fileInfo.Exists)
{
Debug.LogWarning(Maintainer.LogPrefix + "Can't update asset since file at path is not found:\n" + fileInfo.FullName + "\nAsset Path: " + Path);
return;
}
ulong currentHash = 0;
if (metaFileInfo == null)
{
metaFileInfo = new FileInfo(fileInfo.FullName + ".meta");
}
metaFileInfo.Refresh();
if (metaFileInfo.Exists)
{
currentHash += (ulong)metaFileInfo.LastWriteTimeUtc.Ticks;
currentHash += (ulong)metaFileInfo.Length;
}
currentHash += (ulong)fileInfo.LastWriteTimeUtc.Ticks;
currentHash += (ulong)fileInfo.Length;
if (lastHash == currentHash)
{
for (var i = dependenciesGUIDs.Length - 1; i > -1; i--)
{
var guid = dependenciesGUIDs[i];
var path = AssetDatabase.GUIDToAssetPath(guid);
path = CSPathTools.EnforceSlashes(path);
if (!string.IsNullOrEmpty(path) && File.Exists(path))
{
continue;
}
ArrayUtility.RemoveAt(ref dependenciesGUIDs, i);
foreach (var referenceInfo in referencesInfo)
{
if (referenceInfo.assetInfo.GUID != guid)
{
continue;
}
ArrayUtility.Remove(ref referencesInfo, referenceInfo);
break;
}
}
if (!needToRebuildReferences)
{
return;
}
}
foreach (var referenceInfo in referencesInfo)
{
foreach (var info in referenceInfo.assetInfo.referencedAtInfoList)
{
if (info.assetInfo != this)
{
continue;
}
ArrayUtility.Remove(ref referenceInfo.assetInfo.referencedAtInfoList, info);
break;
}
}
lastHash = currentHash;
needToRebuildReferences = true;
Size = fileInfo.Length;
referencesInfo = new ReferenceInfo[0];
dependenciesGUIDs = new string[0];
var dependencies = new List <string>();
if (SettingsKind == AssetSettingsKind.NotSettings)
{
var getRegularDependencies = true;
/* pre-regular dependencies additions */
if (Type == CSReflectionTools.assemblyDefinitionAssetType)
{
if (Kind == AssetKind.Regular)
{
//TODO: check if bug 1020737 is fixed and this can be removed
dependencies.AddRange(GetAssetsReferencedFromAssemblyDefinition(Path));
getRegularDependencies = false;
}
}
#if UNITY_2019_2_OR_NEWER
if (Type == CSReflectionTools.assemblyDefinitionReferenceAssetType)
{
if (Kind == AssetKind.Regular)
{
dependencies.AddRange(GetAssetsReferencedFromAssemblyDefinitionReference(Path));
getRegularDependencies = false;
}
}
#endif
#if UNITY_2018_2_OR_NEWER
// checking by name since addressables are in optional external package
if (Type != null && Type.Name == "AddressableAssetGroup")
{
var references = AddressablesReferenceFinder.Extract(Path);
if (references != null && references.Count > 0)
{
dependencies.AddRange(references);
}
}
#endif
/* regular dependencies additions */
if (getRegularDependencies)
{
dependencies.AddRange(AssetDatabase.GetDependencies(Path, false));
}
/* post-regular dependencies additions */
if (Type == CSReflectionTools.spriteAtlasType)
{
CSArrayTools.TryAddIfNotExists(ref dependencies, GetGetAssetsInFoldersReferencedFromSpriteAtlas(Path));
}
}
else
{
dependencies.AddRange(GetAssetsReferencedInPlayerSettingsAsset(Path, SettingsKind));
}
// kept for debugging purposes
/*if (Path.Contains("1.unity"))
* {
* Debug.Log("1.unity non-recursive dependencies:");
* foreach (var reference in references)
* {
* Debug.Log(reference);
* }
* }*/
if (Type == CSReflectionTools.shaderType)
{
// below is an another workaround for dependencies not include #include-ed files, like *.cginc
ScanFileForIncludes(dependencies, Path);
}
if (Type == CSReflectionTools.textAssetType && Path.EndsWith(".cginc"))
{
// below is an another workaround for dependencies not include #include-ed files, like *.cginc
ScanFileForIncludes(dependencies, Path);
}
var guids = new string[dependencies.Count];
for (var i = 0; i < dependencies.Count; i++)
{
guids[i] = AssetDatabase.AssetPathToGUID(dependencies[i]);
}
dependenciesGUIDs = guids;
}
static public void Setup(string testType, string pathFormat, string suffix)
{
#if UNITY_EDITOR
bool currentIgnoreState = LogAssert.ignoreFailingMessages;
LogAssert.ignoreFailingMessages = true;
var RootFolder = string.Format(pathFormat, testType, suffix);
Directory.CreateDirectory(RootFolder);
var settings = AddressableAssetSettings.Create(RootFolder + "/Settings", "AddressableAssetSettings.Tests", false, true);
var group = settings.FindGroup("TestStuff" + suffix);
if (group == null)
{
group = settings.CreateGroup("TestStuff" + suffix, true, false, false, null, typeof(BundledAssetGroupSchema));
}
settings.DefaultGroup = group;
for (int i = 0; i < kPrefabCount; i++)
{
var guid = CreateAsset(RootFolder + "/test" + i + suffix + ".prefab", "testPrefab" + i);
var entry = settings.CreateOrMoveEntry(guid, group, false, false);
entry.address = Path.GetFileNameWithoutExtension(entry.AssetPath);
entry.SetLabel(GetPrefabLabel(suffix), true, false);
entry.SetLabel(GetPrefabAlternatingLabel(suffix, i), true, false);
entry.SetLabel(GetPrefabUniqueLabel(suffix, i), true, false);
}
var texture = new Texture2D(32, 32);
var data = ImageConversion.EncodeToPNG(texture);
UnityEngine.Object.DestroyImmediate(texture);
AssetDatabase.GenerateUniqueAssetPath(RootFolder);
var spritePath = RootFolder + "sprite.png";
File.WriteAllBytes(spritePath, data);
AssetDatabase.ImportAsset(spritePath, ImportAssetOptions.ForceSynchronousImport | ImportAssetOptions.ForceUpdate);
var spriteGuid = AssetDatabase.AssetPathToGUID(spritePath);
var importer = (TextureImporter)AssetImporter.GetAtPath(spritePath);
importer.textureType = TextureImporterType.Sprite;
importer.spriteImportMode = SpriteImportMode.Multiple;
importer.spritesheet = new SpriteMetaData[] { new SpriteMetaData()
{
name = "topleft", pivot = Vector2.zero, rect = new Rect(0, 0, 16, 16)
},
new SpriteMetaData()
{
name = "botright", pivot = Vector2.zero, rect = new Rect(16, 16, 16, 16)
} };
importer.SaveAndReimport();
var spriteEntry = settings.CreateOrMoveEntry(AssetDatabase.AssetPathToGUID(spritePath), group, false, false);
spriteEntry.address = "sprite";
var so = ScriptableObject.CreateInstance <TestObject>();
var sub = ScriptableObject.CreateInstance <TestObject>();
sub.name = "sub";
AssetDatabase.CreateAsset(so, RootFolder + "sub.asset");
AssetDatabase.AddObjectToAsset(sub, RootFolder + "sub.asset");
AssetDatabase.ImportAsset(RootFolder + "sub.asset", ImportAssetOptions.ForceSynchronousImport | ImportAssetOptions.ForceUpdate);
var subGuid = AssetDatabase.AssetPathToGUID(RootFolder + "sub.asset");
string assetRefGuid = CreateAsset(RootFolder + "/testIsReference.prefab", "IsReference");
GameObject go = new GameObject("AssetReferenceBehavior");
AssetReferenceTestBehavior aRefTestBehavior = go.AddComponent <AssetReferenceTestBehavior>();
aRefTestBehavior.Reference = settings.CreateAssetReference(assetRefGuid);
aRefTestBehavior.ReferenceWithSubObject = settings.CreateAssetReference(subGuid);
aRefTestBehavior.ReferenceWithSubObject.SubObjectName = "sub";
aRefTestBehavior.LabelReference = new AssetLabelReference()
{
labelString = settings.labelTable.labelNames[0]
};
string hasBehaviorPath = RootFolder + "/AssetReferenceBehavior.prefab";
PrefabUtility.SaveAsPrefabAsset(go, hasBehaviorPath);
settings.CreateOrMoveEntry(AssetDatabase.AssetPathToGUID(hasBehaviorPath), group, false, false);
//AssetDatabase.StopAssetEditing();
AssetDatabase.SaveAssets();
AssetDatabase.Refresh(ImportAssetOptions.ForceUpdate);
RunBuilder(settings, testType, suffix);
LogAssert.ignoreFailingMessages = currentIgnoreState;
#endif
}
void Listmat()
{
string path = Application.dataPath;
MaterialPath = new List <string>(Directory.GetFiles(path, "*.mat", SearchOption.AllDirectories));
PrefabPath = new List <string>(Directory.GetFiles(path, "*.prefab", SearchOption.AllDirectories));
Checkshaderpath = new List <string>();
PrefabQuotePath = new List <string>();
Shader shaderpath = (Shader.Find(shadername));
string shaderguid = AssetDatabase.GetAssetPath(shaderpath);
guid01 = AssetDatabase.AssetPathToGUID(shaderguid); //获取shaderGUID
for (int i = 0; i < MaterialPath.Count; i++)
{
string filepath = MaterialPath[i];
if (Regex.IsMatch(File.ReadAllText(filepath), guid01))
{
Checkshaderpath.Add(MaterialPath[i]);
string matpath = MaterialPath[i];
string[] matArray = matpath.Split('/');
string path01 = matArray[matArray.Length - 1];
string matguid = AssetDatabase.AssetPathToGUID(path01);
for (int t = 0; t < PrefabPath.Count; t++)
{
string prefabfilepath = PrefabPath[t];
if (Regex.IsMatch(File.ReadAllText(prefabfilepath), matguid))
{
PrefabQuotePath.Add(PrefabPath[t]);
//Debug.LogWarning(PrefabPath[t] + "引用了" + path01);
string prefabpathstring = PrefabPath[t];
string[] prefabArray = prefabpathstring.Split('/');
string path02 = prefabArray[prefabArray.Length - 1];
string[] PFchildname = path02.Split(new char[2] {
'.', '\\'
});
string childname = PFchildname[PFchildname.Length - 2];
string[] childname01Array = childname.Split('_');
string childname02 = childname01Array[0];
GameObject thisloadprefab = AssetDatabase.LoadAssetAtPath <GameObject>(path02);
// Debug.Log(childname02);
Vector3 prefabscale = thisloadprefab.transform.GetChild(0).gameObject.transform.localScale;
if (prefabscale != null)
{
Material thismat = AssetDatabase.LoadAssetAtPath <Material>(path01);
thismat.SetFloat(ShaderProperties, prefabscale.x * OutLineScale);
}
else
{
Debug.LogError("未找到子对象");
}
}
else
{
// Debug.LogWarning("没有找到" + MaterialPath[i]+"关联的prefab");
}
}
//Debug.LogWarning("shader关联材质matGUID:" + matguid);
}
}
}
public void Update(List <LiveLinkChangeSet> changeSets, NativeList <Hash128> loadScenes, NativeList <Hash128> unloadScenes, LiveLinkMode mode)
{
if (_LoadedScenes.Count == 0 && _SceneGUIDToLiveLink.Count == 0 && _RemovedScenes.Length == 0)
{
return;
}
// If build configuration changed, we need to trigger a full conversion
if (_BuildConfigurationGUID != default)
{
// TODO: Allocs, needs better API
var buildConfigurationDependencyHash = AssetDatabase.GetAssetDependencyHash(AssetDatabase.GUIDToAssetPath(_BuildConfigurationGUID.ToString()));
if (_BuildConfigurationArtifactHash != buildConfigurationDependencyHash)
{
_BuildConfigurationArtifactHash = buildConfigurationDependencyHash;
RequestCleanConversion();
}
}
if (_PreviousGlobalDirtyID != GlobalDirtyID)
{
RequestCleanConversion();
_PreviousGlobalDirtyID = GlobalDirtyID;
}
// By default all scenes need to have m_GameObjectSceneCullingMask, otherwise they won't show up in game view
_GUIDToEditScene.Clear();
for (int i = 0; i != EditorSceneManager.sceneCount; i++)
{
var scene = EditorSceneManager.GetSceneAt(i);
var sceneGUID = new GUID(AssetDatabase.AssetPathToGUID(scene.path));
if (_LoadedScenes.Contains(sceneGUID))
{
if (scene.isLoaded && sceneGUID != default(GUID))
{
_GUIDToEditScene.Add(sceneGUID, scene);
}
}
}
foreach (var scene in _SceneGUIDToLiveLink)
{
if (!_GUIDToEditScene.ContainsKey(scene.Key))
{
unloadScenes.Add(scene.Key);
}
}
// Process scenes that are no longer loaded
foreach (var scene in unloadScenes)
{
var liveLink = _SceneGUIDToLiveLink[scene];
liveLink.Dispose();
_SceneGUIDToLiveLink.Remove(scene);
_SentLoadScenes.Remove(scene);
}
foreach (var scene in _RemovedScenes)
{
if (_SceneGUIDToLiveLink.TryGetValue(scene, out var liveLink))
{
liveLink.Dispose();
_SceneGUIDToLiveLink.Remove(scene);
}
unloadScenes.Add(scene);
_SentLoadScenes.Remove(scene);
}
_RemovedScenes.Clear();
_SentLoadScenes.RemoveWhere(scene => !_LoadedScenes.Contains(scene));
// Process all scenes that the player needs
foreach (var sceneGuid in _LoadedScenes)
{
var isLoaded = _GUIDToEditScene.TryGetValue(sceneGuid, out var scene);
// We are editing with live link. Ensure it is active & up to date
if (isLoaded)
{
var liveLink = GetLiveLink(sceneGuid);
if (liveLink == null || liveLink.DidRequestUpdate() || liveLink.LiveLinkDirtyID != GetSceneDirtyID(scene))
{
AddLiveLinkChangeSet(sceneGuid, changeSets, mode);
}
}
else
{
if (_SentLoadScenes.Add(sceneGuid))
{
loadScenes.Add(sceneGuid);
}
}
}
}
/// <summary> Copies the file into the resources folder. Naming the new asset to KEY </summary>
public static string CopyFileIntoResources(SerializableLocalizationObjectPair objectPair, SmartCultureInfo thisCultureInfo)
{
if (!DirectoryUtility.CheckAndCreate(LocalizationWorkspace.LanguageRuntimeFolderPath(thisCultureInfo.languageCode)))
{
return("");
}
string newFileName = objectPair.keyValue;
string filePath = string.Empty;
string currentAssetPath = string.Empty;
LocalizedObject objectToCopy = objectPair.changedValue;
if (objectToCopy.ObjectType == LocalizedObjectType.AUDIO && objectToCopy.ThisAudioClip != null)
{
filePath = LocalizationWorkspace.LanguageAudioFolderPath(thisCultureInfo.languageCode);
currentAssetPath = AssetDatabase.GetAssetPath(objectToCopy.ThisAudioClip);
}
else if (objectToCopy.ObjectType == LocalizedObjectType.TEXTURE && objectToCopy.ThisTexture != null)
{
filePath = LocalizationWorkspace.LanguageTexturesFolderPath(thisCultureInfo.languageCode);
currentAssetPath = AssetDatabase.GetAssetPath(objectToCopy.ThisTexture);
}
else if (objectToCopy.ObjectType == LocalizedObjectType.GAME_OBJECT && objectToCopy.ThisGameObject != null)
{
filePath = LocalizationWorkspace.LanguagePrefabsFolderPath(thisCultureInfo.languageCode);
currentAssetPath = AssetDatabase.GetAssetPath(objectToCopy.ThisGameObject);
}
else if (objectToCopy.ObjectType == LocalizedObjectType.TEXT_ASSET && objectToCopy.ThisTextAsset != null)
{
filePath = LocalizationWorkspace.LanguageTextAssetsFolderPath(thisCultureInfo.languageCode);
currentAssetPath = AssetDatabase.GetAssetPath(objectToCopy.ThisTextAsset);
}
else if (objectToCopy.ObjectType == LocalizedObjectType.FONT && objectToCopy.Font != null)
{
filePath = LocalizationWorkspace.LanguageFontsFolderPath(thisCultureInfo.languageCode);
currentAssetPath = AssetDatabase.GetAssetPath(objectToCopy.Font);
}
else
{
return(string.Empty);
}
if (!DirectoryUtility.CheckAndCreate(filePath))
{
return("");
}
//Get the fileExtension of the asset
string fileExtension = FileUtility.GetFileExtension(Application.dataPath + currentAssetPath);
if (objectToCopy.ObjectType != LocalizedObjectType.GAME_OBJECT)
{
//Copy or replace the file to the new path
FileUtil.ReplaceFile(currentAssetPath, filePath + "/" + newFileName + fileExtension);
string metaFile = Application.dataPath.Substring(0, Application.dataPath.Length - "Assets".Length) +
currentAssetPath.Substring(0, currentAssetPath.Length - fileExtension.Length) + fileExtension + ".meta";
if (File.Exists(metaFile))
{
FileUtil.ReplaceFile(metaFile, filePath + "/" + newFileName + fileExtension + ".meta");
}
}
else
{
string relativePath = filePath + "/" + newFileName + fileExtension;
relativePath = "Assets" + relativePath.Substring(Application.dataPath.Length);
//1PrefabUtility.CreatePrefab(relativePath, objectToCopy.ThisGameObject);
PrefabUtility.SaveAsPrefabAsset(objectToCopy.ThisGameObject, relativePath); // TODO Перепроверить
}
return(AssetDatabase.AssetPathToGUID(currentAssetPath));
}
static bool IsSpriteMesh(string assetPath)
{
return(s_SpriteMeshToTextureCache.ContainsKey(AssetDatabase.AssetPathToGUID(assetPath)));
}
public override void OnInspectorGUI(NodeGUI node, AssetReferenceStreamManager streamManager, NodeGUIEditor editor, Action onValueChanged)
{
if (m_loadPath == null)
{
return;
}
EditorGUILayout.HelpBox("Load From Directory: Load assets from given directory path.", MessageType.Info);
editor.UpdateNodeName(node);
GUILayout.Space(10f);
bool bRespondAP = EditorGUILayout.ToggleLeft("Respond To Asset Change", m_respondToAssetChange);
if (bRespondAP != m_respondToAssetChange)
{
using (new RecordUndoScope("Remove Target Load Path Settings", node, true)) {
m_respondToAssetChange = bRespondAP;
}
}
GUILayout.Space(4f);
//Show target configuration tab
editor.DrawPlatformSelector(node);
using (new EditorGUILayout.VerticalScope(GUI.skin.box)) {
var disabledScope = editor.DrawOverrideTargetToggle(node, m_loadPath.ContainsValueOf(editor.CurrentEditingGroup), (bool b) => {
using (new RecordUndoScope("Remove Target Load Path Settings", node, true)) {
if (b)
{
m_loadPath[editor.CurrentEditingGroup] = m_loadPath.DefaultValue;
m_loadPathGuid[editor.CurrentEditingGroup] = m_loadPathGuid.DefaultValue;
}
else
{
m_loadPath.Remove(editor.CurrentEditingGroup);
m_loadPathGuid.Remove(editor.CurrentEditingGroup);
}
onValueChanged();
}
});
using (disabledScope) {
var path = m_loadPath[editor.CurrentEditingGroup];
EditorGUILayout.LabelField("Load Path:");
string newLoadPath = null;
newLoadPath = editor.DrawFolderSelector(Model.Settings.Path.ASSETS_PATH, "Select Asset Folder",
path,
FileUtility.PathCombine(Model.Settings.Path.ASSETS_PATH, path),
(string folderSelected) => { return(NormalizeLoadPath(folderSelected)); }
);
var dirPath = Path.Combine(Model.Settings.Path.ASSETS_PATH, newLoadPath);
if (newLoadPath != path)
{
using (new RecordUndoScope("Load Path Changed", node, true)){
m_loadPath[editor.CurrentEditingGroup] = newLoadPath;
m_loadPathGuid [editor.CurrentEditingGroup] = AssetDatabase.AssetPathToGUID(dirPath);
onValueChanged();
}
}
bool dirExists = Directory.Exists(dirPath);
GUILayout.Space(10f);
using (new EditorGUILayout.HorizontalScope()) {
using (new EditorGUI.DisabledScope(string.IsNullOrEmpty(newLoadPath) || !dirExists))
{
GUILayout.FlexibleSpace();
if (GUILayout.Button("Highlight in Project Window", GUILayout.Width(180f)))
{
// trailing is "/" not good for LoadMainAssetAtPath
if (dirPath[dirPath.Length - 1] == '/')
{
dirPath = dirPath.Substring(0, dirPath.Length - 1);
}
var obj = AssetDatabase.LoadMainAssetAtPath(dirPath);
EditorGUIUtility.PingObject(obj);
}
}
}
if (!dirExists)
{
var parentDirPath = Path.GetDirectoryName(dirPath);
bool parentDirExists = Directory.Exists(parentDirPath);
if (parentDirExists)
{
EditorGUILayout.LabelField("Available Directories:");
string[] dirs = Directory.GetDirectories(parentDirPath);
foreach (string s in dirs)
{
EditorGUILayout.LabelField(s);
}
}
}
}
}
GUILayout.Space(8f);
DrawIgnoredPatterns(node, onValueChanged);
}
public static void SetUp()
{
s_Assets.SetUp();
var assetGuids = new List<GUID>();
try
{
{
string path = s_Assets.GetNextPath(".asset");
AssetDatabase.CreateAsset(s_TempTexture = new Texture2D(64, 64), path);
s_TempTextureGuid = new GUID(AssetDatabase.AssetPathToGUID(path));
assetGuids.Add(s_TempTextureGuid);
}
{
string path = s_Assets.GetNextPath(".mat");
AssetDatabase.CreateAsset(s_TempMaterial = new Material(Shader.Find("Standard")), path);
s_TempMaterialGuid = new GUID(AssetDatabase.AssetPathToGUID(path));
assetGuids.Add(s_TempMaterialGuid);
s_TempMaterial.mainTexture = s_TempTexture;
}
var tempScenePath = s_Assets.GetNextPath(".unity");
s_TempScene = SubSceneTestsHelper.CreateScene(tempScenePath);
s_SubSceneWithSections = SubSceneTestsHelper.CreateSubSceneInSceneFromObjects("SubScene", false, s_TempScene, () =>
{
var go1 = new GameObject();
go1.AddComponent<SceneSectionComponent>().SectionIndex = 0;
var go2 = new GameObject();
go2.AddComponent<SceneSectionComponent>().SectionIndex = 2;
go2.AddComponent<TestComponentAuthoring>().Material = s_TempMaterial;
return new List<GameObject> { go1, go2 };
});
{
var path = s_Assets.GetNextPath("LiveLinkBuildConfig.buildconfiguration");
BuildConfiguration.CreateAsset(path, config =>
{
config.SetComponent(new SceneList
{
SceneInfos = new List<SceneList.SceneInfo>
{
new SceneList.SceneInfo
{
Scene = GlobalObjectId.GetGlobalObjectIdSlow(AssetDatabase.LoadAssetAtPath<SceneAsset>(tempScenePath))
}
}
});
});
s_LiveLinkBuildConfigGuid = new GUID(AssetDatabase.AssetPathToGUID(path));
}
}
catch
{
s_Assets.TearDown();
throw;
}
// This call ensures that the asset worker is already running and no test times out because we're still
// waiting for the asset worker. Effectively this doesn't change the runtime that much since we will have
// to wait for the import to finish in most of the tests anyway.
GeEntitySceneArtifactHash(s_SubSceneWithSections.SceneGUID, s_LiveLinkBuildConfigGuid, ImportMode.Synchronous);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
s_TempAssetGuids = assetGuids.ToArray();
DefaultWorldInitialization.DefaultLazyEditModeInitialize();
s_Connection = new LiveLinkTestConnection();
EditorSceneLiveLinkToPlayerSendSystem.instance.SetConnection(s_Connection);
LiveLinkAssetBundleBuildSystem.instance.SetConnection(s_Connection);
}
public static void AllReferenceFindResource()
{
EditorSettings.serializationMode = SerializationMode.ForceText;
string fullDir = Application.dataPath + "/" + dirpath;
var notwithhoutExtensions = new List <string>()
{
".meta"
};
// 需要反向查找的资源
string[] files = Directory.GetFiles(fullDir, "*.*", SearchOption.AllDirectories)
.Where(s => !notwithhoutExtensions.Contains(Path.GetExtension(s).ToLower())).ToArray();
// 目标资源
var targetExtensions = new List <string>()
{
".prefab", ".unity", ".fbx", ".mat", ".asset"
};
string[] targetFiles = Directory.GetFiles(Application.dataPath + "/ModelTest", "*.*", SearchOption.AllDirectories)
.Where(s => targetExtensions.Contains(Path.GetExtension(s).ToLower())).ToArray();
int startIndex = 0;
//EditorApplication.update = delegate()
{
for (int i = 0; i < files.Length; i++)
{
string assetpath = files[i].Replace("\\", "/").Replace(Application.dataPath, "Assets");
string guid = AssetDatabase.AssetPathToGUID(assetpath);
Debug.Log(guid);
for (int j = 0; j < targetFiles.Length; j++)
{
string _target = targetFiles[j];
bool isCancel = EditorUtility.DisplayCancelableProgressBar("资源匹配中", _target, (float)startIndex / (float)targetFiles.Length);
string txt = File.ReadAllText(_target);
Debug.Log(txt);
if (Regex.IsMatch(txt /*File.ReadAllText(_target)*/, guid))
{
Debug.LogError(guid);
string taregtpath = _target.Replace("\\", "/").Replace(Application.dataPath + "/", "");
string[] shield = taregtpath.Split('/');
if (shield.Length > 0)
{
if (!shieldDir.Contains(shield[0]))
{
Debug.Log(assetpath.Replace("Assets/", "") + "-->> " + _target.Replace("\\", "/").Replace(Application.dataPath + "/", "") + ": ");
}
}
else
{
Debug.Log(assetpath.Replace("Assets/", "") + "-->> " + _target.Replace("\\", "/").Replace(Application.dataPath + "/", "") + ": ");
}
}
if (isCancel)
{
//EditorUtility.ClearProgressBar();
//EditorApplication.update = null;
Debug.Log("匹配结束 匹配数量： " + startIndex + " 总数量： " + targetFiles.Length);
startIndex = 0;
break;
}
}
}
EditorUtility.ClearProgressBar();
//EditorApplication.update = null;
};
}
private void Generate()
{
var file = File.ReadAllText(Application.dataPath.Replace("Assets", string.Empty) + AssetDatabase.GetAssetPath(shaderFile));
var regex = new Regex("(?<=(properties)).*?(?=(subshader))", RegexOptions.Singleline | RegexOptions.IgnoreCase);
var match = regex.Match(file).Value;
if (string.IsNullOrEmpty(match))
{
return;
}
var lines = match
.Split(new[] { "\r\n", "\n" }, StringSplitOptions.None)
.Select(x => x.Trim().Trim('\t'))
.Where(x => !string.IsNullOrEmpty(x) && !x.StartsWith("/") && x.Length > 4);
var attrebutes = new List <ShaderPropertyAttrebute>();
var attrebuteTemp = new List <ShaderPropertyAttrebute>();
foreach (var line in lines)
{
var attrebute = ShaderPropertyAttrebute.ParseToAttrebute(line);
if (string.IsNullOrEmpty(attrebute.Name))
{
attrebuteTemp.Add(attrebute);
}
else
{
attrebuteTemp.Select(x =>
{
return(x.GetType().GetProperties()
.Where(y => !y.Name.Contains("Name"))
.Select(y =>
{
var value = y.GetValue(x, null);
if (Equals(value, null) || Equals(value, false))
{
return y;
}
attrebute.GetType().GetProperties().First(z => z.Name == y.Name).SetValue(attrebute, value, null);
return y;
})
.ToList());
})
.ToList();
attrebutes.Add(attrebute);
attrebuteTemp.Clear();
}
}
var predicate = new Func <ShaderPropertyAttrebute, bool>(x => !x.HasHideInInspector && !x.HasPerRendererData);
var maxVariableLength = attrebutes
.Where(predicate)
.Max(x => x.Name.Length);
var fields = attrebutes
.Where(predicate)
.Select(x =>
{
var camelVariable = x.Name.ToCamelCase();
var castResult = 0;
camelVariable = int.TryParse(camelVariable.First().ToString(), out castResult)
? camelVariable.Remove(0, 1)
: camelVariable;
return(string.Format
(
"private readonly string {0}{1}= \"_{2}\"; ",
camelVariable,
"".AppendIndent(maxVariableLength - camelVariable.Length),
x.Name
).AppendIndent(4));
}).ToList();
var foldFields = attrebutes
.Where(x => x.HasHeader)
.Select(x =>
{
var camelVariable = x.Name.ToCamelCase();
var castResult = 0;
camelVariable = int.TryParse(camelVariable.First().ToString(), out castResult)
? camelVariable.Remove(0, 1)
: camelVariable;
return(string.Format("private bool {0}Fold = false;", camelVariable).AppendIndent(4));
})
.ToList();
var headers = attrebutes.Where(x => x.HasHeader).Select(x => x.Header);
var toggleFields = attrebutes
.Where(x => x.Name.ToLower().Contains("use")
// && headers.Any(y => y.ToLower().Contains(x.Name.ToLower().Replace("use", string.Empty)))
)
.Select(x =>
{
var camelVariable = x.Name.ToCamelCase();
var castResult = 0;
camelVariable = int.TryParse(camelVariable.First().ToString(), out castResult)
? camelVariable.Remove(0, 1)
: camelVariable;
return(new
{
Field = string.Format("private bool {0}Toggle = true;", camelVariable).AppendIndent(4),
Variable = string.Format("{0}Toggle", camelVariable),
PropertyName = x.Name
});
})
.ToList();
fields.AddRange(foldFields);
fields.AddRange(toggleFields.Select(x => x.Field));
var template = File.ReadAllText(Application.dataPath.Replace("Assets", string.Empty) + AssetDatabase.GetAssetPath(templateFile));
var fieldsArray = fields.ToArray();
template = template.Replace("<#fields#>", string.Join(Environment.NewLine, fieldsArray));
var inFold = false;
var propertyFoldGroup = string.Empty;
var properties = new List <string>();
var attrebuteProps = attrebutes
.Where(predicate)
.Select(x =>
{
var camelVariable = x.Name.ToCamelCase();
var castResult = 0;
camelVariable = int.TryParse(camelVariable.First().ToString(), out castResult)
? camelVariable.Remove(0, 1)
: camelVariable;
return(new
{
Attrebute = x,
FindProperty = string.Format
(
"var {0}Prop {1}= FindProperty(this.{0}, properties, false);",
camelVariable,
"".AppendIndent(maxVariableLength - camelVariable.Length)
).AppendIndent(8),
PropertyVariable = string.Format("{0}Prop", camelVariable)
});
})
.ToList();
var findProps = string.Join(Environment.NewLine, attrebuteProps.Select(x => x.FindProperty).ToArray());
template = template.Replace("<#findProps#>", findProps);
var setKeywords = toggleFields
.Select(x => string.Format("UiUtils.SetKeyword({0}Prop, this.{1});", x.PropertyName.ToCamelCase(), x.Variable).AppendIndent(12))
.ToArray();
template = template.Replace("<#setKeywords#>", string.Join(Environment.NewLine, setKeywords));
var initializeToggles = toggleFields
.Select(x => string.Format("this.{0} = {1}Prop.floatValue > 0;", x.Variable, x.PropertyName.ToCamelCase()).AppendIndent(16))
.ToArray();
template = template.Replace("<#initialToggle#>", string.Join(Environment.NewLine, initializeToggles));
foreach (var toggleField in toggleFields)
{
attrebuteProps.RemoveAll(x => x.Attrebute.Name.Contains(toggleField.PropertyName));
}
foreach (var attrebute in attrebuteProps)
{
var camelVariable = attrebute.Attrebute.Name.ToCamelCase();
var castResult = 0;
camelVariable = int.TryParse(camelVariable.First().ToString(), out castResult)
? camelVariable.Remove(0, 1)
: camelVariable;
if (attrebute.Attrebute.HasHeader)
{
if (inFold)
{
propertyFoldGroup += string.Format("}});{0}{0}", Environment.NewLine).AppendIndent(12);
}
var toggle = toggleFields.FirstOrDefault(x => attrebute.Attrebute.Header.ToLower().Contains(x.PropertyName.ToLower().Replace("use", string.Empty)));
if (toggle == null)
{
propertyFoldGroup += string.Format
(
"UiUtils.PropertyFoldGroup(\"{0}\", ref this.{1}Fold, () => {2}",
attrebute.Attrebute.Header,
camelVariable,
Environment.NewLine
).AppendIndent(12);
}
else
{
propertyFoldGroup += string.Format
(
"UiUtils.PropertyToggleFoldGroup(\"{0}\", ref this.{1}Fold, ref this.{2}, () => {3}",
attrebute.Attrebute.Header,
camelVariable,
toggle.Variable,
Environment.NewLine
).AppendIndent(12);
}
propertyFoldGroup += string.Format("{{{0}", Environment.NewLine).AppendIndent(12);
inFold = true;
}
if (attrebute.Attrebute.HasNoScaleOffset)
{
propertyFoldGroup += string.Format
(
"materialEditor.TexturePropertySingleLine(new GUIContent(\"{0}\"), {1}); ",
attrebute.Attrebute.DisplayName,
attrebute.PropertyVariable
).AppendIndent(16) + Environment.NewLine;
}
else if (attrebute.Attrebute.IsTexture)
{
propertyFoldGroup += string.Format
(
"materialEditor.ShaderProperty({0}, \"{1}\");",
attrebute.PropertyVariable,
attrebute.Attrebute.DisplayName
).AppendIndent(16) + Environment.NewLine;
}
else
{
propertyFoldGroup += string.Format
(
"materialEditor.ShaderProperty({0}, \"{1}\");",
attrebute.PropertyVariable,
attrebute.Attrebute.DisplayName
).AppendIndent(16) + Environment.NewLine;
}
}
if (inFold)
{
propertyFoldGroup += string.Format("}});{0}{0}", Environment.NewLine).AppendIndent(12);
}
template = template.Replace("<#propGroup#>", propertyFoldGroup);
template = template.Replace("<#=generatorName#>", "ShaderPropertyGenerator");
template = template.Replace("<#=dateTimeNow#>", DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss"));
template = template.Replace("<#=className#>", className.ToPascalCase());
template = template.Replace("<#=guid#>", AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(shaderFile)));
Directory.CreateDirectory(Application.dataPath.Replace("Assets", string.Empty) + "/Editor/");
File.WriteAllText(Application.dataPath + "/Editor/" + className.ToPascalCase() + ".cs", template);
AssetDatabase.Refresh();
}
static void SetDiffBuilds()
{
mBuildsList = new List <AssetBundleBuild>();
mClearList = new List <AssstCaheData>();
var isNeedPack = false;
var cacheList = new List <string>();
if (mCacheAssetBund != null)
{
cacheList = mCacheAssetBund.Keys.ToList();
}
foreach (var build in tempBuilds.Values)
{
isNeedPack = false;
//差异化判断,如果没缓存表,就打包全部资源
if (mCacheAssetBund != null)
{
var abName = build.assetBundleName;
//如果缓存表存在AB包的key,开始检查缓存的与需要打包资源的差异
if (mCacheAssetBund.ContainsKey(abName))
{
//从缓存list中删除,如果删到最后list不为空,则说明资源需要删除
cacheList.Remove(abName);
var cache = mCacheAssetBund[abName];
// Debug.Log(abName + "=> hash " + cache.md5);
//如何缓存的guid列表存在,则继续比较差异,如果不存在说明需要打包
if (cache.mGuilds != null)
{
var guids = cache.mGuilds.Keys.ToList();
//比对缓存的ab包和要打包的ab包的文件差异
foreach (var path in build.assetNames)
{
var guid = AssetDatabase.AssetPathToGUID(path);
var hash = AssetDatabase.GetAssetDependencyHash(path).ToString();
if (guids.Contains(guid))
{
guids.Remove(guid);
var cacheHash = cache.mGuilds[guid];
if (cacheHash != hash)
{
Debug.LogError(abName + "hash 发生改变！old" + cacheHash + " cur " + hash);
isNeedPack = true;
break;
}
}
else
{
Debug.LogError(guid + "缓存不包括此guids！" + path);
isNeedPack = true;
break;
}
}
//如果取完build的path的keys发现还有缓存的,说明缓存的文件比要打包的文件多,需要重新打包
if (guids.Count > 0)
{
Debug.LogError("取完build的path的keys发现还有缓存的,需要重新打包==> 剩余guids Count" + guids.Count);
isNeedPack = true;
}
}
else
{
Debug.LogError("hashs 没有值直接需要打包");
isNeedPack = true;
}
if (isNeedPack)
{
mClearList.Add(cache);
}
}
else
{
Debug.Log(abName + "=> 没有缓存需要重新打包 ");
isNeedPack = true;
}
}
else
{
Debug.Log("CacheAssetBund 没有值需要重新打包 ");
isNeedPack = true;
}
if (isNeedPack)
{
Debug.LogError("Is NeedPack item: " + build.assetBundleName + " count " + build.assetNames.Count);
foreach (var path in build.assetNames)
{
Debug.LogError("item Path: " + path);
}
mBuildsList.Add(build.GetAssetBundleBuild());
}
else
{
// Debug.Log("Not NeedPack item: " + build.assetBundleName + " count " + build.assetNames.Count);
}
}
if (cacheList.Count > 0)
{
foreach (var abName in cacheList)
{
var cache = mCacheAssetBund[abName];
Debug.LogError(abName + "已经不需要,添加删除！");
mClearList.Add(cache);
}
}
Debug.Log(" 需要打包的数量 " + mBuildsList.Count);
}
void PostProcessMeta()
{
#region Repair GUIDS
bool refresh = false;
foreach (var a in scriptAbsPathToGuid)
{
// Get latest guid of script from assetdatabase and compare to cached to see if changed
string newGuid = AssetDatabase.AssetPathToGUID(SmartEditorUtils.ToRelativePath(a.Key));
if (newGuid != a.Value)
{
Debug.LogWarningFormat("Repairing changed GUID for script {0}", a.Key);
string metaPath = a.Key + ".meta";
#region Repair meta file
if (File.Exists(metaPath))
{
// Find line with latest guid and replace with cached guid
var lines = File.ReadAllLines(a.Key);
for (int i = 0; i < lines.Length; ++i)
{
string l = lines[i];
if (l.Contains(newGuid))
{
Debug.LogFormat("\n\tRestoring {0} to {1}", newGuid, a.Value);
lines[i] = l.Replace(newGuid, a.Value);
// Save and flag for asset database refresh
File.WriteAllLines(a.Key, lines);
refresh = true;
break;
}
}
}
#endregion
}
}
if (refresh)
{
AssetDatabase.Refresh();
}
#endregion
#region Set icons
refresh = false;
foreach (var a in scriptAbsPathToGuid)
{
string metaPath = a.Key + ".meta";
if (File.Exists(metaPath))
{
var lines = File.ReadAllLines(metaPath);
// Read meta file, look for line with "icon:"
for (int i = 0; i < lines.Length; ++i)
{
string l = lines[i];
// Line must have "icon: " and default icon stuff
if (l.Contains(ICON_MATCH))
{
// Get type of script, then get associated icon from utilities
string pathToScript = AssetDatabase.GUIDToAssetPath(a.Value);
MonoScript script = AssetDatabase.LoadAssetAtPath <MonoScript>(pathToScript);
System.Type tData;
var sot = SmartEditorUtils.GetSmartObjectType(script.GetClass(), out tData);
//TODO Implement icons for component types
if (sot == SmartEditorUtils.SmartObjectType.NONE)
{
break;
}
Texture2D icon = SmartEditorUtils.LoadSmartIcon(sot, false, true);
// Get guid of icon and jam it in there
string pathToIcon = AssetDatabase.GetAssetPath(icon);
string iconGuid = AssetDatabase.AssetPathToGUID(pathToIcon);
bool modified = false;
if (l.Contains(ICON_DEFAULT))
{
// Replace entire default icon
l = l.Replace(ICON_DEFAULT, string.Format("{{fileID: 2800000, guid: {0}, type: 3}}", iconGuid));
modified = true;
}
else if (l.Contains(ICON_CUSTOM_HEAD))
{
// Isolate guid to check if changed
string check = l.Trim().Replace(ICON_MATCH, "").Replace(ICON_CUSTOM_HEAD, "").Replace(ICON_CUSTOM_TAIL, "");
if (check != iconGuid)
{
var sb = new System.Text.StringBuilder();
// Whitespace
for (int j = 0; j < l.Length; ++j)
{
if (l[j] != ' ')
{
break;
}
sb.Append(' ');
}
// Build with new guid
sb.Append(ICON_MATCH);
sb.Append(ICON_CUSTOM_HEAD);
sb.Append(iconGuid);
sb.Append(ICON_CUSTOM_TAIL);
l = sb.ToString();
modified = true;
}
}
if (modified)
{
Debug.Log("Setting icon for script " + a.Key);
// Save and flag for asset database refresh
lines[i] = l;
File.WriteAllLines(metaPath, lines);
refresh = true;
}
break;
}
}
}
else
{
Debug.LogError("Meta file not found: " + metaPath);
}
}
#endregion
if (refresh)
{
AssetDatabase.Refresh();
}
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
if (!isInitialized)
{
Initialize(property);
}
Event ev = Event.current;
GUIContent guiContent = EditorGUIUtility.ObjectContent(folderAsset, typeof(DefaultAsset));
Rect rect = EditorGUI.PrefixLabel(position, label);
Rect textFieldRect = rect;
Rect objectFieldRect = rect;
objectFieldRect.x = textFieldRect.xMax - 19f;
objectFieldRect.y += 1.0f;
objectFieldRect.height = objectFieldRect.height - 2;
objectFieldRect.width = 18f;
GUIStyle textFieldStyle = new GUIStyle("TextField")
{
imagePosition = folderAsset ? ImagePosition.ImageLeft : ImagePosition.TextOnly
};
if (objectFieldRect.Contains(ev.mousePosition) && ev.type == EventType.MouseDown)
{
//Object field press.
string path = EditorUtility.OpenFolderPanel("Select a folder", "Assets", "");
if (path.Contains(Application.dataPath))
{
path = "Assets" + path.Substring(Application.dataPath.Length);
folderAsset = AssetDatabase.LoadAssetAtPath(path, typeof(DefaultAsset));
guidSP.stringValue = AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(folderAsset));
}
else
{
GameConsole.LogError(this, "The path must be in the Assets folder");
}
ev.Use();
}
if (GUI.Button(textFieldRect, guiContent, textFieldStyle) && folderAsset)
{
EditorGUIUtility.PingObject(folderAsset);
}
if (GUI.Button(objectFieldRect, "", GUI.skin.GetStyle("ObjectFieldButton")))
{
//Just for show.
}
if (textFieldRect.Contains(ev.mousePosition))
{
//Drag and drop support for folders.
if (ev.type == EventType.DragUpdated)
{
Object reference = DragAndDrop.objectReferences[0];
string path = AssetDatabase.GetAssetPath(reference);
DragAndDrop.visualMode = Directory.Exists(path) ? DragAndDropVisualMode.Copy : DragAndDropVisualMode.Rejected;
ev.Use();
}
else if (ev.type == EventType.DragPerform)
{
Object reference = DragAndDrop.objectReferences[0];
string path = AssetDatabase.GetAssetPath(reference);
if (Directory.Exists(path))
{
folderAsset = reference;
guidSP.stringValue = AssetDatabase.AssetPathToGUID(path);
}
ev.Use();
}
}
}
private void GroupLoadPrefabs(SerializedProperty proprety)
{
for (int i = 0; i < proprety.arraySize; i++)
{
var itemProp = proprety.GetArrayElementAtIndex(i);
GameObject prefab = null;
var prefabProp = itemProp.FindPropertyRelative("prefab");
var assetNameProp = itemProp.FindPropertyRelative("panelName");
var instanceIDProp = itemProp.FindPropertyRelative("instanceID");
if (instanceIDProp.intValue != 0)
{
continue;
}
if (prefabProp == null)
{
var bundleNameProp = itemProp.FindPropertyRelative("bundleName");
var guidProp = itemProp.FindPropertyRelative("guid");
var paths = AssetDatabase.GetAssetPathsFromAssetBundleAndAssetName(bundleNameProp.stringValue, assetNameProp.stringValue);
if (paths.Length > 0)
{
prefab = AssetDatabase.LoadAssetAtPath <GameObject>(paths[0]);
guidProp.stringValue = AssetDatabase.AssetPathToGUID(paths[0]);
}
}
else
{
prefab = prefabProp.objectReferenceValue as GameObject;
}
if (prefab == null)
{
UnityEditor.EditorUtility.DisplayDialog("空对象", "找不到预制体" + assetNameProp.stringValue, "确认");
}
else
{
//var rematrixProp = itemProp.FindPropertyRelative("reset");
GameObject go = PrefabUtility.InstantiatePrefab(prefab) as GameObject;
if (target is PanelGroup)
{
if (go.GetComponent <Transform>() is RectTransform)
{
go.transform.SetParent((target as PanelGroup).transform, false);
}
else
{
go.transform.SetParent((target as PanelGroup).transform, true);
}
}
else if (target is PanelGroupObj)
{
if (go.GetComponent <Transform>() is RectTransform)
{
var canvas = GameObject.FindObjectOfType <Canvas>();
go.transform.SetParent(canvas.transform, false);
}
else
{
go.transform.SetParent(null);
}
}
//if (rematrixProp.boolValue)
//{
// go.transform.position = Vector3.zero;
// go.transform.localRotation = Quaternion.identity;
//}
instanceIDProp.intValue = go.GetInstanceID();
}
}
}
internal static List <string> ScanFileForIncludes(string filePath)
{
var fileLines = File.ReadAllLines(filePath);
var references = new List <string>();
foreach (var line in fileLines)
{
var includeIndex = line.IndexOf("include", StringComparison.Ordinal);
if (includeIndex == -1)
{
continue;
}
var noSharp = line.IndexOf('#', 0, includeIndex) == -1;
if (noSharp)
{
continue;
}
var indexOfFirstQuote = line.IndexOf('"', includeIndex);
if (indexOfFirstQuote == -1)
{
continue;
}
var indexOfLastQuote = line.IndexOf('"', indexOfFirstQuote + 1);
if (indexOfLastQuote == -1)
{
continue;
}
var path = line.Substring(indexOfFirstQuote + 1, indexOfLastQuote - indexOfFirstQuote - 1);
path = CSPathTools.EnforceSlashes(path);
string assetPath;
if (path.StartsWith("Assets/"))
{
assetPath = path;
}
else if (path.IndexOf('/') != -1)
{
var folder = System.IO.Path.GetDirectoryName(filePath);
if (folder == null)
{
continue;
}
var combinedPath = System.IO.Path.Combine(folder, path);
var fullPath = CSPathTools.EnforceSlashes(System.IO.Path.GetFullPath(combinedPath));
var assetsIndex = fullPath.IndexOf("Assets/", StringComparison.Ordinal);
if (assetsIndex == -1)
{
continue;
}
assetPath = fullPath.Substring(assetsIndex, fullPath.Length - assetsIndex);
}
else
{
var folder = System.IO.Path.GetDirectoryName(filePath);
if (folder == null)
{
continue;
}
assetPath = CSPathTools.EnforceSlashes(System.IO.Path.Combine(folder, path));
}
if (!File.Exists(assetPath))
{
continue;
}
var guid = AssetDatabase.AssetPathToGUID(assetPath);
if (references.IndexOf(guid) != -1)
{
continue;
}
{
references.Add(guid);
}
}
return(references);
}
public override void OnInspectorGUI()
{
Init();
if (animLibs == null)
{
GUILayout.Label("no libraries found");
if (GUILayout.Button("Refresh"))
{
initialized = false;
Init();
}
}
else
{
tk2dSpriteAnimator sprite = (tk2dSpriteAnimator)target;
EditorGUIUtility.LookLikeInspector();
EditorGUI.indentLevel = 1;
if (sprite.Library == null)
{
sprite.Library = animLibs[0].GetAsset <tk2dSpriteAnimation>();
GUI.changed = true;
}
// Display animation library
int selAnimLib = 0;
string selectedGUID = AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(sprite.Library));
for (int i = 0; i < animLibs.Length; ++i)
{
if (animLibs[i].assetGUID == selectedGUID)
{
selAnimLib = i;
break;
}
}
int newAnimLib = EditorGUILayout.Popup("Anim Lib", selAnimLib, animLibNames);
if (newAnimLib != selAnimLib)
{
Undo.RegisterUndo(targetAnimators, "Sprite Anim Lib");
foreach (tk2dSpriteAnimator animator in targetAnimators)
{
animator.Library = animLibs[newAnimLib].GetAsset <tk2dSpriteAnimation>();
animator.DefaultClipId = 0;
if (animator.Library.clips.Length > 0)
{
if (animator.Sprite != null)
{
// automatically switch to the first frame of the new clip
var f = animator.Library.clips;
foreach (var ff in f)
{
Debug.LogError(ff.name);
}
animator.Sprite.SetSprite(animator.Library.clips[animator.DefaultClipId].frames[0].spriteCollection,
animator.Library.clips[animator.DefaultClipId].frames[0].spriteId);
}
}
}
}
// Everything else
if (sprite.Library && sprite.Library.clips.Length > 0)
{
int clipId = sprite.DefaultClipId;
// Sanity check clip id
clipId = Mathf.Clamp(clipId, 0, sprite.Library.clips.Length - 1);
if (clipId != sprite.DefaultClipId)
{
sprite.DefaultClipId = clipId;
GUI.changed = true;
}
List <string> clipNames = new List <string>(sprite.Library.clips.Length);
List <int> clipIds = new List <int>(sprite.Library.clips.Length);
// fill names (with ids if necessary)
for (int i = 0; i < sprite.Library.clips.Length; ++i)
{
if (sprite.Library.clips[i].name != null && sprite.Library.clips[i].name.Length > 0)
{
string name = sprite.Library.clips[i].name;
if (tk2dPreferences.inst.showIds)
{
name += "\t[" + i.ToString() + "]";
}
clipNames.Add(name);
clipIds.Add(i);
}
}
int newClipId = EditorGUILayout.IntPopup("Clip", sprite.DefaultClipId, clipNames.ToArray(), clipIds.ToArray());
if (newClipId != sprite.DefaultClipId)
{
Undo.RegisterUndo(targetAnimators, "Sprite Anim Clip");
foreach (tk2dSpriteAnimator animator in targetAnimators)
{
animator.DefaultClipId = newClipId;
if (animator.Sprite != null)
{
// automatically switch to the first frame of the new clip
animator.Sprite.SetSprite(animator.Library.clips[animator.DefaultClipId].frames[0].spriteCollection,
animator.Library.clips[animator.DefaultClipId].frames[0].spriteId);
}
}
}
}
// Play automatically
bool newPlayAutomatically = EditorGUILayout.Toggle("Play automatically", sprite.playAutomatically);
if (newPlayAutomatically != sprite.playAutomatically)
{
Undo.RegisterUndo(targetAnimators, "Sprite Anim Play Automatically");
foreach (tk2dSpriteAnimator animator in targetAnimators)
{
animator.playAutomatically = newPlayAutomatically;
}
}
if (GUI.changed)
{
foreach (tk2dSpriteAnimator spr in targetAnimators)
{
EditorUtility.SetDirty(spr);
}
}
}
}
// static string[] GatherDependenciesFromSourceFile(string path) {
// // Called before actual import for each changed asset that is imported by this importer type
// // Extract the dependencies for the asset specified in path.
// // For asset dependencies that are discovered, return them in the string array, where the string is the path to asset
//
// // TODO: Texture files with relative URIs should be included here
// return null;
// }
public override void OnImportAsset(AssetImportContext ctx)
{
reportItems = null;
var downloadProvider = new EditorDownloadProvider();
var logger = new CollectingLogger();
m_Gltf = new GltfImport(
downloadProvider,
new UninterruptedDeferAgent(),
null,
logger
);
if (importSettings == null)
{
// Design-time import specific settings
importSettings = new ImportSettings {
// Avoid naming conflicts by default
nodeNameMethod = ImportSettings.NameImportMethod.OriginalUnique
};
}
var success = AsyncHelpers.RunSync <bool>(() => m_Gltf.Load(ctx.assetPath, importSettings));
GameObjectInstantiator instantiator = null;
CollectingLogger instantiationLogger = null;
if (success)
{
m_ImportedNames = new HashSet <string>();
m_ImportedObjects = new HashSet <Object>();
var go = new GameObject("root");
instantiationLogger = new CollectingLogger();
instantiator = new GameObjectInstantiator(m_Gltf, go.transform, instantiationLogger);
for (var sceneIndex = 0; sceneIndex < m_Gltf.sceneCount; sceneIndex++)
{
success = m_Gltf.InstantiateScene(instantiator, sceneIndex);
if (!success)
{
break;
}
var sceneTransform = go.transform.GetChild(sceneIndex);
var sceneGo = sceneTransform.gameObject;
AddObjectToAsset(ctx, $"scenes/{sceneGo.name}", sceneGo);
if (sceneIndex == m_Gltf.defaultSceneIndex)
{
ctx.SetMainObject(sceneGo);
}
}
for (var i = 0; i < m_Gltf.textureCount; i++)
{
var texture = m_Gltf.GetTexture(i);
if (texture != null)
{
AddObjectToAsset(ctx, $"textures/{texture.name}", texture);
}
}
for (var i = 0; i < m_Gltf.materialCount; i++)
{
var mat = m_Gltf.GetMaterial(i);
AddObjectToAsset(ctx, $"materials/{mat.name}", mat);
}
if (m_Gltf.defaultMaterial != null)
{
// If a default/fallback material was created, import it as well'
// to avoid (pink) objects without materials
var mat = m_Gltf.defaultMaterial;
AddObjectToAsset(ctx, $"materials/{mat.name}", mat);
}
var meshes = m_Gltf.GetMeshes();
if (meshes != null)
{
foreach (var mesh in meshes)
{
AddObjectToAsset(ctx, $"meshes/{mesh.name}", mesh);
}
}
var clips = m_Gltf.GetAnimationClips();
if (clips != null)
{
foreach (var animationClip in clips)
{
AddObjectToAsset(ctx, $"animations/{animationClip.name}", animationClip);
}
}
m_ImportedNames = null;
m_ImportedObjects = null;
}
var deps = new List <GltfAssetDependency>();
for (var index = 0; index < downloadProvider.assetDependencies.Count; index++)
{
var dependency = downloadProvider.assetDependencies[index];
if (ctx.assetPath == dependency.originalUri)
{
// Skip original gltf/glb file
continue;
}
var guid = AssetDatabase.AssetPathToGUID(dependency.originalUri);
if (!string.IsNullOrEmpty(guid))
{
dependency.assetPath = dependency.originalUri;
ctx.DependsOnSourceAsset(dependency.assetPath);
}
deps.Add(dependency);
}
assetDependencies = deps.ToArray();
var reportItemList = new List <LogItem>();
reportItemList.AddRange(logger.items);
if (instantiationLogger?.items != null)
{
reportItemList.AddRange(instantiationLogger.items);
}
reportItems = reportItemList.ToArray();
}
private void GenerateClass()
{
VFXConfigEditor config = target as VFXConfigEditor;
string generateAssetPath = string.Format("{0}{1}.cs", config.GeneratePath, VFXConstants.VFC_CONFIG_CLASS_NAME);
string generateFullPath = Application.dataPath.Substring(0, Application.dataPath.LastIndexOf("Assets")) + generateAssetPath;
if (!CheckPath(generateFullPath))
{
EditorUtility.DisplayDialog("Generate VFX Config", string.Format("{0}\nPath is invalid", generateFullPath), "ok");
return;
}
if (config.VFXAddressableAssetGroup == null ||
string.IsNullOrEmpty(config.GeneratePath) ||
config.ConfigTemplate == null)
{
EditorUtility.DisplayDialog("Generate VFX Config", "Config editor has null parameter", "ok");
return;
}
RemoveEmptyOrDuplicateEffects();
List <ForGenerateVFXConfigItem> vfxConfigItems = new List <ForGenerateVFXConfigItem>();
HashSet <string> vfxTypes = new HashSet <string>();
List <GameObject> vfxPrefabs = new List <GameObject>();
for (int iEffect = 0; iEffect < config.Effects.Length; iEffect++)
{
GameObject iterEffect = config.Effects[iEffect];
string assetPath = AssetDatabase.GetAssetPath(iterEffect);
if (string.IsNullOrEmpty(assetPath))
{
Debug.LogError(string.Format("Effect({0}) 不是一个Assets", iEffect), iterEffect);
continue;
}
string assetName = StringUtility.SubFileNameFromPath(assetPath);
if (!vfxTypes.Add(assetName))
{
Debug.LogError(string.Format("Effect({0}) FileName({1})重复", iEffect, assetName), iterEffect);
continue;
}
string assetGuid = AssetDatabase.AssetPathToGUID(assetPath);
AddressableAssetEntry unitPrefabAssetEntry = AddressableAssetSettingsDefaultObject.Settings.CreateOrMoveEntry(assetGuid, config.VFXAddressableAssetGroup);
string assetKey = VFXConstants.VFX_EFFECT_ASSET_KEY_STARTWITH + assetName;
unitPrefabAssetEntry.address = assetKey;
ForGenerateVFXConfigItem vfxConfigItem = new ForGenerateVFXConfigItem();
vfxConfigItem.Type = assetName;
vfxConfigItem.ItemConfig = new VFXItemConfig(assetKey);
vfxConfigItems.Add(vfxConfigItem);
vfxPrefabs.Add(iterEffect);
}
VFXConfigForEditorLoader.Get().EffectPrefabs = vfxPrefabs.ToArray();
VFXConfigForEditorLoader.Save();
string[] configTemplateLines = config.ConfigTemplate.text.Split(new char[] { '\n' });
StringBuilder stringBuilder = new StringBuilder();
for (int iLine = 0; iLine < configTemplateLines.Length; iLine++)
{
string iterLine = configTemplateLines[iLine].Replace("\r", "");
if (iterLine.Contains(VFXConstants.VFX_CONFIG_CLASS_NAME_FLAG))
{
stringBuilder.AppendLine(iterLine.Replace(VFXConstants.VFX_CONFIG_CLASS_NAME_FLAG, VFXConstants.VFC_CONFIG_CLASS_NAME));
}
else if (iterLine.Contains(VFXConstants.VFX_CONFIG_TYPE_FLAG))
{
stringBuilder.AppendLine(iterLine);
for (int iItem = 0; iItem < vfxConfigItems.Count; iItem++)
{
stringBuilder.AppendLine(string.Format(VFXConstants.VFX_CONFIG_TYPE_FORAMT, vfxConfigItems[iItem].Type));
}
stringBuilder.AppendLine(string.Format(VFXConstants.VFX_CONFIG_TYPE_FORAMT, "Count"));
}
else if (iterLine.Contains(VFXConstants.VFX_CONFIG_ITEM_CONFIGS_FLAG))
{
stringBuilder.AppendLine(iterLine);
for (int iItem = 0; iItem < vfxConfigItems.Count; iItem++)
{
stringBuilder.AppendLine(string.Format(VFXConstants.VFX_CONFIG_ITEM_CONFIG_FORAMT, vfxConfigItems[iItem].ItemConfig.AssetKey));
}
}
else
{
stringBuilder.AppendLine(iterLine);
}
}
File.WriteAllText(generateFullPath, stringBuilder.ToString());
AssetDatabase.ImportAsset(generateAssetPath);
TextAsset generateAsset = AssetDatabase.LoadAssetAtPath(generateAssetPath, typeof(TextAsset)) as TextAsset;
Selection.activeObject = generateAsset;
}
void OnPreprocessTexture()
{
if (!s_Initialized)
{
return;
}
string guid = AssetDatabase.AssetPathToGUID(assetPath);
if (s_SpriteMeshToTextureCache.ContainsValue(guid))
{
TextureImporter textureImporter = (TextureImporter)assetImporter;
SerializedObject textureImporterSO = new SerializedObject(textureImporter);
SerializedProperty textureImporterSprites = textureImporterSO.FindProperty("m_SpriteSheet.m_Sprites");
foreach (KeyValuePair <string, string> pair in s_SpriteMeshToTextureCache)
{
if (pair.Value == guid)
{
SpriteMesh spriteMesh = LoadSpriteMesh(AssetDatabase.GUIDToAssetPath(pair.Key));
SpriteMeshData spriteMeshData = SpriteMeshUtils.LoadSpriteMeshData(spriteMesh);
if (spriteMesh && spriteMeshData && spriteMesh.sprite && spriteMeshData.vertices.Length > 0)
{
if (textureImporter.spriteImportMode == SpriteImportMode.Multiple)
{
SerializedProperty spriteProp = null;
int i = 0;
string name = "";
while (i < textureImporterSprites.arraySize && name != spriteMesh.sprite.name)
{
spriteProp = textureImporterSprites.GetArrayElementAtIndex(i);
name = spriteProp.FindPropertyRelative("m_Name").stringValue;
++i;
}
if (name == spriteMesh.sprite.name)
{
Rect textureRect = SpriteMeshUtils.CalculateSpriteRect(spriteMesh, 5);
spriteProp.FindPropertyRelative("m_Rect").rectValue = textureRect;
spriteProp.FindPropertyRelative("m_Alignment").intValue = 9;
spriteProp.FindPropertyRelative("m_Pivot").vector2Value = Vector2.Scale(spriteMeshData.pivotPoint - textureRect.position, new Vector2(1f / textureRect.size.x, 1f / textureRect.size.y));
}
}
else
{
int width = 0;
int height = 0;
SpriteMeshUtils.GetSpriteTextureSize(spriteMesh.sprite, ref width, ref height);
textureImporterSO.FindProperty("m_Alignment").intValue = 9;
textureImporterSO.FindProperty("m_SpritePivot").vector2Value = Vector2.Scale(spriteMeshData.pivotPoint, new Vector2(1f / width, 1f / height));
}
}
}
}
textureImporterSO.ApplyModifiedProperties();
}
}
/// <summary>
/// 验证构建结果
/// </summary>
private void VerifyingBuildingResult(BuildContext context, AssetBundleManifest unityManifest)
{
var buildParameters = context.GetContextObject <AssetBundleBuilder.BuildParametersContext>();
var buildMapContext = context.GetContextObject <BuildMapContext>();
string[] buildedBundles = unityManifest.GetAllAssetBundles();
// 1. 过滤掉原生Bundle
List <BuildBundleInfo> expectBundles = new List <BuildBundleInfo>(buildedBundles.Length);
foreach (var bundleInfo in buildMapContext.BundleInfos)
{
if (bundleInfo.IsRawFile == false)
{
expectBundles.Add(bundleInfo);
}
}
// 2. 验证数量
if (buildedBundles.Length != expectBundles.Count)
{
Debug.LogWarning($"构建过程中可能存在无效的资源，导致和预期构建的Bundle数量不一致！");
}
// 3. 正向验证Bundle
foreach (var bundleName in buildedBundles)
{
if (buildMapContext.IsContainsBundle(bundleName) == false)
{
throw new Exception($"Should never get here !");
}
}
// 4. 反向验证Bundle
bool isPass = true;
foreach (var expectBundle in expectBundles)
{
bool isMatch = false;
foreach (var buildedBundle in buildedBundles)
{
if (buildedBundle == expectBundle.BundleName)
{
isMatch = true;
break;
}
}
if (isMatch == false)
{
isPass = false;
Debug.LogWarning($"没有找到预期构建的Bundle文件 : {expectBundle.BundleName}");
}
}
if (isPass == false)
{
throw new Exception("构建结果验证没有通过，请参考警告日志！");
}
// 5. 验证Asset
var buildMode = buildParameters.Parameters.BuildMode;
if (buildMode == EBuildMode.ForceRebuild || buildMode == EBuildMode.IncrementalBuild)
{
int progressValue = 0;
foreach (var buildedBundle in buildedBundles)
{
string filePath = $"{buildParameters.PipelineOutputDirectory}/{buildedBundle}";
string[] allBuildinAssetPaths = GetAssetBundleAllAssets(filePath);
string[] expectBuildinAssetPaths = buildMapContext.GetBuildinAssetPaths(buildedBundle);
if (expectBuildinAssetPaths.Length != allBuildinAssetPaths.Length)
{
Debug.LogWarning($"构建的Bundle文件内的资源对象数量和预期不匹配 : {buildedBundle}");
isPass = false;
continue;
}
foreach (var buildinAssetPath in allBuildinAssetPaths)
{
var guid = AssetDatabase.AssetPathToGUID(buildinAssetPath);
if (string.IsNullOrEmpty(guid))
{
Debug.LogWarning($"无效的资源路径，请检查路径是否带有特殊符号或中文：{buildinAssetPath}");
isPass = false;
continue;
}
bool isMatch = false;
foreach (var exceptBuildAssetPath in expectBuildinAssetPaths)
{
var guidExcept = AssetDatabase.AssetPathToGUID(exceptBuildAssetPath);
if (guid == guidExcept)
{
isMatch = true;
break;
}
}
if (isMatch == false)
{
Debug.LogWarning($"在构建的Bundle文件里发现了没有匹配的资源对象：{buildinAssetPath}");
isPass = false;
continue;
}
}
EditorTools.DisplayProgressBar("验证构建结果", ++progressValue, buildedBundles.Length);
}
EditorTools.ClearProgressBar();
if (isPass == false)
{
throw new Exception("构建结果验证没有通过，请参考警告日志！");
}
}
// 卸载所有加载的Bundle
BuildRunner.Log("构建结果验证成功！");
}
public override void OnInspectorGUI()
{
spriteUiVisible = EditorGUILayout.Foldout(spriteUiVisible, "Sprite");
if (spriteUiVisible)
{
base.OnInspectorGUI();
}
Init();
if (animLibs == null)
{
GUILayout.Label("no libraries found");
if (GUILayout.Button("Refresh"))
{
initialized = false;
Init();
}
}
else
{
tk2dAnimatedSprite sprite = (tk2dAnimatedSprite)target;
EditorGUIUtility.LookLikeInspector();
EditorGUI.indentLevel = 1;
if (sprite.anim == null)
{
sprite.anim = animLibs[0].GetAsset <tk2dSpriteAnimation>();
GUI.changed = true;
}
// Display animation library
int selAnimLib = 0;
string selectedGUID = AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(sprite.anim));
for (int i = 0; i < animLibs.Length; ++i)
{
if (animLibs[i].assetGUID == selectedGUID)
{
selAnimLib = i;
break;
}
}
int newAnimLib = EditorGUILayout.Popup("Anim Lib", selAnimLib, animLibNames);
if (newAnimLib != selAnimLib)
{
sprite.anim = animLibs[newAnimLib].GetAsset <tk2dSpriteAnimation>();
sprite.clipId = 0;
if (sprite.anim.clips.Length > 0)
{
// automatically switch to the first frame of the new clip
sprite.SwitchCollectionAndSprite(sprite.anim.clips[sprite.clipId].frames[0].spriteCollection,
sprite.anim.clips[sprite.clipId].frames[0].spriteId);
}
}
// Everything else
if (sprite.anim && sprite.anim.clips.Length > 0)
{
int clipId = sprite.clipId;
// Sanity check clip id
clipId = Mathf.Clamp(clipId, 0, sprite.anim.clips.Length - 1);
if (clipId != sprite.clipId)
{
sprite.clipId = clipId;
GUI.changed = true;
}
string[] clipNames = new string[sprite.anim.clips.Length];
// fill names (with ids if necessary)
if (tk2dPreferences.inst.showIds)
{
for (int i = 0; i < sprite.anim.clips.Length; ++i)
{
if (sprite.anim.clips[i].name != null && sprite.anim.clips[i].name.Length > 0)
{
clipNames[i] = sprite.anim.clips[i].name + "\t[" + i.ToString() + "]";
}
else
{
clipNames[i] = sprite.anim.clips[i].name;
}
}
}
else
{
for (int i = 0; i < sprite.anim.clips.Length; ++i)
{
clipNames[i] = sprite.anim.clips[i].name;
}
}
int newClipId = EditorGUILayout.Popup("Clip", sprite.clipId, clipNames);
if (newClipId != sprite.clipId)
{
sprite.clipId = newClipId;
// automatically switch to the first frame of the new clip
sprite.SwitchCollectionAndSprite(sprite.anim.clips[sprite.clipId].frames[0].spriteCollection,
sprite.anim.clips[sprite.clipId].frames[0].spriteId);
}
}
// Play automatically
sprite.playAutomatically = EditorGUILayout.Toggle("Play automatically", sprite.playAutomatically);
bool oldCreateCollider = sprite.createCollider;
sprite.createCollider = EditorGUILayout.Toggle("Create collider", sprite.createCollider);
if (oldCreateCollider != sprite.createCollider)
{
sprite.EditMode__CreateCollider();
}
if (GUI.changed)
{
EditorUtility.SetDirty(sprite);
}
}
}
public static string pathToGUID(string path)
{
return(AssetDatabase.AssetPathToGUID(path));
}
private void AssignAssetID(GameObject prefab)
{
string assetPath = AssetDatabase.GetAssetPath(prefab);
this.m_AssetId = NetworkHash128.Parse(AssetDatabase.AssetPathToGUID(assetPath));
}
public override void OnImportAsset(AssetImportContext ctx)
{
var oldShader = AssetDatabase.LoadAssetAtPath <Shader>(ctx.assetPath);
if (oldShader != null)
{
ShaderUtil.ClearShaderMessages(oldShader);
}
List <PropertyCollector.TextureInfo> configuredTextures;
string path = ctx.assetPath;
AssetCollection assetCollection = new AssetCollection();
MinimalGraphData.GatherMinimalDependenciesFromFile(assetPath, assetCollection);
var textGraph = File.ReadAllText(path, Encoding.UTF8);
var graph = new GraphData
{
messageManager = new MessageManager(), assetGuid = AssetDatabase.AssetPathToGUID(path)
};
MultiJson.Deserialize(graph, textGraph);
graph.OnEnable();
graph.ValidateGraph();
Shader shader = null;
#if VFX_GRAPH_10_0_0_OR_NEWER
if (!graph.isOnlyVFXTarget)
#endif
{
// build the shader text
// this will also add Target dependencies into the asset collection
var text = GetShaderText(path, out configuredTextures, assetCollection, graph);
#if UNITY_2021_1_OR_NEWER
// 2021.1 or later is guaranteed to have the new version of this function
shader = ShaderUtil.CreateShaderAsset(ctx, text, false);
#else
// earlier builds of Unity may or may not have it
// here we try to invoke the new version via reflection
var createShaderAssetMethod = typeof(ShaderUtil).GetMethod(
"CreateShaderAsset",
System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.ExactBinding,
null,
new Type[] { typeof(AssetImportContext), typeof(string), typeof(bool) },
null);
if (createShaderAssetMethod != null)
{
shader = createShaderAssetMethod.Invoke(null, new Object[] { ctx, text, false }) as Shader;
}
else
{
// method doesn't exist in this version of Unity, call old version
// this doesn't create dependencies properly, but is the best that we can do
shader = ShaderUtil.CreateShaderAsset(text, false);
}
#endif
ReportErrors(graph, shader, path);
EditorMaterialUtility.SetShaderDefaults(
shader,
configuredTextures.Where(x => x.modifiable).Select(x => x.name).ToArray(),
configuredTextures.Where(x => x.modifiable).Select(x => EditorUtility.InstanceIDToObject(x.textureId) as Texture).ToArray());
EditorMaterialUtility.SetShaderNonModifiableDefaults(
shader,
configuredTextures.Where(x => !x.modifiable).Select(x => x.name).ToArray(),
configuredTextures.Where(x => !x.modifiable).Select(x => EditorUtility.InstanceIDToObject(x.textureId) as Texture).ToArray());
}
UnityEngine.Object mainObject = shader;
#if VFX_GRAPH_10_0_0_OR_NEWER
ShaderGraphVfxAsset vfxAsset = null;
if (graph.hasVFXTarget)
{
vfxAsset = GenerateVfxShaderGraphAsset(graph);
if (mainObject == null)
{
mainObject = vfxAsset;
}
else
{
//Correct main object if we have a shader and ShaderGraphVfxAsset : save as sub asset
vfxAsset.name = Path.GetFileNameWithoutExtension(path);
ctx.AddObjectToAsset("VFXShaderGraph", vfxAsset);
}
}
#endif
Texture2D texture = Resources.Load <Texture2D>("Icons/sg_graph_icon");
ctx.AddObjectToAsset("MainAsset", mainObject, texture);
ctx.SetMainObject(mainObject);
foreach (var target in graph.activeTargets)
{
if (target is IHasMetadata iHasMetadata)
{
var metadata = iHasMetadata.GetMetadataObject();
if (metadata == null)
{
continue;
}
metadata.hideFlags = HideFlags.HideInHierarchy;
ctx.AddObjectToAsset($"{iHasMetadata.identifier}:Metadata", metadata);
}
}
var sgMetadata = ScriptableObject.CreateInstance <ShaderGraphMetadata>();
sgMetadata.hideFlags = HideFlags.HideInHierarchy;
sgMetadata.assetDependencies = new List <UnityEngine.Object>();
foreach (var asset in assetCollection.assets)
{
if (asset.Value.HasFlag(AssetCollection.Flags.IncludeInExportPackage))
{
// this sucks that we have to fully load these assets just to set the reference,
// which then gets serialized as the GUID that we already have here. :P
var dependencyPath = AssetDatabase.GUIDToAssetPath(asset.Key);
if (!string.IsNullOrEmpty(dependencyPath))
{
sgMetadata.assetDependencies.Add(
AssetDatabase.LoadAssetAtPath(dependencyPath, typeof(UnityEngine.Object)));
}
}
}
List <GraphInputData> inputInspectorDataList = new List <GraphInputData>();
foreach (AbstractShaderProperty property in graph.properties)
{
// Don't write out data for non-exposed blackboard items
if (!property.isExposed)
{
continue;
}
// VTs are treated differently
if (property is VirtualTextureShaderProperty virtualTextureShaderProperty)
{
inputInspectorDataList.Add(MinimalCategoryData.ProcessVirtualTextureProperty(virtualTextureShaderProperty));
}
else
{
inputInspectorDataList.Add(new GraphInputData()
{
referenceName = property.referenceName, propertyType = property.propertyType, isKeyword = false
});
}
}
foreach (ShaderKeyword keyword in graph.keywords)
{
// Don't write out data for non-exposed blackboard items
if (!keyword.isExposed)
{
continue;
}
var sanitizedReferenceName = keyword.referenceName;
if (keyword.keywordType == KeywordType.Boolean && keyword.referenceName.Contains("_ON"))
{
sanitizedReferenceName = sanitizedReferenceName.Replace("_ON", String.Empty);
}
inputInspectorDataList.Add(new GraphInputData()
{
referenceName = sanitizedReferenceName, keywordType = keyword.keywordType, isKeyword = true
});
}
sgMetadata.categoryDatas = new List <MinimalCategoryData>();
foreach (CategoryData categoryData in graph.categories)
{
// Don't write out empty categories
if (categoryData.childCount == 0)
{
continue;
}
MinimalCategoryData mcd = new MinimalCategoryData()
{
categoryName = categoryData.name,
propertyDatas = new List <GraphInputData>()
};
foreach (var input in categoryData.Children)
{
GraphInputData propData;
// Only write out data for exposed blackboard items
if (input.isExposed == false)
{
continue;
}
// VTs are treated differently
if (input is VirtualTextureShaderProperty virtualTextureShaderProperty)
{
propData = MinimalCategoryData.ProcessVirtualTextureProperty(virtualTextureShaderProperty);
inputInspectorDataList.RemoveAll(inputData => inputData.referenceName == propData.referenceName);
mcd.propertyDatas.Add(propData);
continue;
}
else if (input is ShaderKeyword keyword)
{
var sanitizedReferenceName = keyword.referenceName;
if (keyword.keywordType == KeywordType.Boolean && keyword.referenceName.Contains("_ON"))
{
sanitizedReferenceName = sanitizedReferenceName.Replace("_ON", String.Empty);
}
propData = new GraphInputData()
{
referenceName = sanitizedReferenceName, keywordType = keyword.keywordType, isKeyword = true
};
}
else
{
var prop = input as AbstractShaderProperty;
propData = new GraphInputData()
{
referenceName = input.referenceName, propertyType = prop.propertyType, isKeyword = false
};
}
mcd.propertyDatas.Add(propData);
inputInspectorDataList.Remove(propData);
}
sgMetadata.categoryDatas.Add(mcd);
}
// Any uncategorized elements get tossed into an un-named category at the top as a fallback
if (inputInspectorDataList.Count > 0)
{
sgMetadata.categoryDatas.Insert(0, new MinimalCategoryData()
{
categoryName = "", propertyDatas = inputInspectorDataList
});
}
ctx.AddObjectToAsset("SGInternal:Metadata", sgMetadata);
// declare dependencies
foreach (var asset in assetCollection.assets)
{
if (asset.Value.HasFlag(AssetCollection.Flags.SourceDependency))
{
ctx.DependsOnSourceAsset(asset.Key);
// I'm not sure if this warning below is actually used or not, keeping it to be safe
var assetPath = AssetDatabase.GUIDToAssetPath(asset.Key);
// Ensure that dependency path is relative to project
if (!string.IsNullOrEmpty(assetPath) && !assetPath.StartsWith("Packages/") && !assetPath.StartsWith("Assets/"))
{
Debug.LogWarning($"Invalid dependency path: {assetPath}", mainObject);
}
}
// NOTE: dependencies declared by GatherDependenciesFromSourceFile are automatically registered as artifact dependencies
// HOWEVER: that path ONLY grabs dependencies via MinimalGraphData, and will fail to register dependencies
// on GUIDs that don't exist in the project. For both of those reasons, we re-declare the dependencies here.
if (asset.Value.HasFlag(AssetCollection.Flags.ArtifactDependency))
{
ctx.DependsOnArtifact(asset.Key);
}
}
}
public override void OnInspectorGUI()
{
var registry = ReplicatedEntityRegistry.GetReplicatedEntityRegistry();
if (registry == null)
{
EditorGUILayout.HelpBox("Make sure you have a ReplicatedEntityRegistry in project", MessageType.Error);
return;
}
var replicatedEntity = target as ReplicatedEntity;
var guid = "";
var stage = PrefabStageUtility.GetPrefabStage(replicatedEntity.gameObject);
if (stage != null)
{
guid = AssetDatabase.AssetPathToGUID(stage.prefabAssetPath);
}
else
{
if (!PrefabUtility.IsAnyPrefabInstanceRoot(replicatedEntity.gameObject) && !Application.isPlaying)
{
EditorGUILayout.HelpBox("Replicated entity must be placed on root of prefab", MessageType.Error);
return;
}
var path = PrefabUtility.GetPrefabAssetPathOfNearestInstanceRoot(replicatedEntity.gameObject);
guid = AssetDatabase.AssetPathToGUID(path);
}
var registryIndex = registry != null?registry.GetId(guid) : -1;
GUILayout.Label("Entity registry index:" + replicatedEntity.registryId);
if (Application.isPlaying)
{
return;
}
GUILayout.Label("Registry index:" + registryIndex);
if (registryIndex != replicatedEntity.registryId)
{
EditorGUILayout.HelpBox("Local index does not match client registry index", MessageType.Error);
}
if (registryIndex != -1 || replicatedEntity.registryId != -1)
{
if (GUILayout.Button("Unregister"))
{
if (registryIndex != -1)
{
registry.ClearAtId(registryIndex);
}
replicatedEntity.registryId = -1;
PrefabUtility.SaveAsPrefabAsset(replicatedEntity.gameObject, stage.prefabAssetPath);
// EditorUtility.SetDirty(replicatedEntity);
}
}
else
{
EditorGUILayout.HelpBox("NOT REGISTERED!", MessageType.Error);
if (GUILayout.Button("Register"))
{
registryIndex = registry.FindFreeId();
registry.SetPrefab(registryIndex, guid);
replicatedEntity.registryId = registryIndex;
PrefabUtility.SaveAsPrefabAsset(replicatedEntity.gameObject, stage.prefabAssetPath);
// EditorUtility.SetDirty(replicatedEntity);
}
}
}
public override void SaveReferences()
{
EditorPrefs.SetString(PrefKey, AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(countdownAnimation)));
}
public static void SetAddressbaleGroupName()
{
try
{
var asset = AssetDatabase.LoadAssetAtPath <AddressableAssetSettings>(SettingPath);
var addressGroupCfg = AssetDatabase.LoadAssetAtPath <BundleGroups>(BundleGroupConfigPath);
var groups = addressGroupCfg.BundleItems;
EditorUtility.DisplayCancelableProgressBar("Addressable 资源处理中", "清理Groups..", 0.1f);
for (int i = asset.groups.Count - 1; i >= 0; i--)
{
var assetGroup = asset.groups[i];
if (assetGroup == null)
{
asset.groups.RemoveAt(i);
continue;
}
if (assetGroup.name.Contains("Builde In Data"))
{
continue;
}
if (assetGroup.IsDefaultGroup())
{
continue;
}
if (assetGroup.entries.Count <= 0 && IsDefaultGroup(assetGroup))
{
asset.groups.RemoveAt(i);
asset.RemoveGroup(assetGroup);
}
}
EditorUtility.DisplayCancelableProgressBar("Addressable 资源处理中", "清理Groups..", 0.2f);
for (int j = 0; j < groups.Count; j++)
{
var item = groups[j];
if (string.IsNullOrEmpty(item.groupName))
{
throw new ArgumentNullException("groupName");
}
EditorUtility.DisplayCancelableProgressBar("Addressable 资源处理中", item.groupName, (float)j / groups.Count);
var assets = item.GetAllAssets();
var addressGroup = asset.FindGroup(item.groupName);
if (!addressGroup)
{
var groupSchmeTemple = (asset.GroupTemplateObjects[0] as AddressableAssetGroupTemplate);
addressGroup = asset.CreateGroup(item.groupName, false, false, false, null, groupSchmeTemple.GetTypes());
groupSchmeTemple.ApplyToAddressableAssetGroup(addressGroup);
}
if (addressGroup)
{
var bundleAssetGroup = addressGroup.GetSchema <BundledAssetGroupSchema>();
if (!bundleAssetGroup)
{
bundleAssetGroup = addressGroup.AddSchema <BundledAssetGroupSchema>(false);
}
bundleAssetGroup.UseAssetBundleCrc = false;
bundleAssetGroup.BundleNaming = item.namingStyle;
bundleAssetGroup.BundleMode = item.bundleMode;
var contentUpdateScnema = addressGroup.GetSchema <ContentUpdateGroupSchema>();
if (!contentUpdateScnema)
{
contentUpdateScnema = addressGroup.AddSchema <ContentUpdateGroupSchema>(false);
}
contentUpdateScnema.StaticContent = true;
}
foreach (var assetPath in assets)
{
var guid = AssetDatabase.AssetPathToGUID(assetPath);
var entry = asset.CreateOrMoveEntry(guid, addressGroup, false, false);
entry.SetAddress(GetSimpleAddresName(entry.address), false);
}
}
for (int i = 0; i < asset.groups.Count; i++)
{
var item = asset.groups[i];
if (!IsDefaultGroup(item))
{
foreach (var entry in item.entries.ToArray())
{
string filePath = Path.Combine(Application.dataPath, "BundleResource", entry.address);
if (string.IsNullOrEmpty(entry.AssetPath))
{
item.RemoveAssetEntry(entry);
Debug.Log("AssetRemove:" + filePath);
}
if (File.Exists(filePath))
{
entry.SetLabel("dlc-content", false);
entry.SetAddress(GetSimpleAddresName(entry.address), false);
}
else
{
Debug.Log(filePath);
item.RemoveAssetEntry(entry);
}
}
}
}
AssetDatabase.SaveAssets();
}
finally
{
EditorUtility.ClearProgressBar();
}
}
public override void OnInspectorGUI()
{
GraphData GetGraphData(AssetImporter importer)
{
var textGraph = File.ReadAllText(importer.assetPath, Encoding.UTF8);
var graphObject = CreateInstance <GraphObject>();
graphObject.hideFlags = HideFlags.HideAndDontSave;
bool isSubGraph;
var extension = Path.GetExtension(importer.assetPath).Replace(".", "");
switch (extension)
{
case ShaderGraphImporter.Extension:
isSubGraph = false;
break;
case ShaderGraphImporter.LegacyExtension:
isSubGraph = false;
break;
case ShaderSubGraphImporter.Extension:
isSubGraph = true;
break;
default:
throw new Exception($"Invalid file extension {extension}");
}
var assetGuid = AssetDatabase.AssetPathToGUID(importer.assetPath);
graphObject.graph = new GraphData
{
assetGuid = assetGuid, isSubGraph = isSubGraph, messageManager = null
};
MultiJson.Deserialize(graphObject.graph, textGraph);
graphObject.graph.OnEnable();
graphObject.graph.ValidateGraph();
return(graphObject.graph);
}
if (GUILayout.Button("Open Shader Editor"))
{
AssetImporter importer = target as AssetImporter;
Debug.Assert(importer != null, "importer != null");
ShowGraphEditWindow(importer.assetPath);
}
if (GUILayout.Button("View Generated Shader"))
{
AssetImporter importer = target as AssetImporter;
string assetName = Path.GetFileNameWithoutExtension(importer.assetPath);
string path = String.Format("Temp/GeneratedFromGraph-{0}.shader", assetName.Replace(" ", ""));
var graphData = GetGraphData(importer);
var generator = new Generator(graphData, null, GenerationMode.ForReals, assetName);
if (GraphUtil.WriteToFile(path, generator.generatedShader))
{
GraphUtil.OpenFile(path);
}
}
if (Unsupported.IsDeveloperMode())
{
if (GUILayout.Button("View Preview Shader"))
{
AssetImporter importer = target as AssetImporter;
string assetName = Path.GetFileNameWithoutExtension(importer.assetPath);
string path = String.Format("Temp/GeneratedFromGraph-{0}-Preview.shader", assetName.Replace(" ", ""));
var graphData = GetGraphData(importer);
var generator = new Generator(graphData, null, GenerationMode.Preview, $"{assetName}-Preview");
if (GraphUtil.WriteToFile(path, generator.generatedShader))
{
GraphUtil.OpenFile(path);
}
}
}
if (GUILayout.Button("Copy Shader"))
{
AssetImporter importer = target as AssetImporter;
string assetName = Path.GetFileNameWithoutExtension(importer.assetPath);
var graphData = GetGraphData(importer);
var generator = new Generator(graphData, null, GenerationMode.ForReals, assetName);
GUIUtility.systemCopyBuffer = generator.generatedShader;
}
ApplyRevertGUI();
}
public static void LoadPackages()
{
if (Application.isPlaying || _loaded)
{
return;
}
#if !(UNITY_5 || UNITY_5_3_OR_NEWER)
EditorApplication.update -= EditorApplication_Update;
EditorApplication.update += EditorApplication_Update;
#endif
_loaded = true;
UIPackage.RemoveAllPackages();
FontManager.Clear();
NTexture.DisposeEmpty();
UIObjectFactory.Clear();
string[] ids = AssetDatabase.FindAssets("_fui t:textAsset");
int cnt = ids.Length;
for (int i = 0; i < cnt; i++)
{
string assetPath = AssetDatabase.GUIDToAssetPath(ids[i]);
int pos = assetPath.LastIndexOf("_fui");
if (pos == -1)
{
continue;
}
assetPath = assetPath.Substring(0, pos);
if (AssetDatabase.AssetPathToGUID(assetPath) != null)
{
UIPackage.AddPackage(assetPath,
(string name, string extension, System.Type type, out DestroyMethod destroyMethod) =>
{
destroyMethod = DestroyMethod.Unload;
return(AssetDatabase.LoadAssetAtPath(name + extension, type));
}
);
}
}
List <UIPackage> pkgs = UIPackage.GetPackages();
pkgs.Sort(CompareUIPackage);
cnt = pkgs.Count;
packagesPopupContents = new GUIContent[cnt + 1];
for (int i = 0; i < cnt; i++)
{
packagesPopupContents[i] = new GUIContent(pkgs[i].name);
}
packagesPopupContents[cnt] = new GUIContent("Please Select");
UIConfig.ClearResourceRefs();
UIConfig[] configs = GameObject.FindObjectsOfType <UIConfig>();
foreach (UIConfig config in configs)
{
config.Load();
}
EMRenderSupport.Reload();
}
public void AddSpriteCollectionData(tk2dSpriteCollectionData sc)
{
#if UNITY_EDITOR
// prune list
GetSpriteCollectionIndex();
spriteCollectionIndex.RemoveAll(item => item == null);
string guid = AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(sc));
bool existing = false;
tk2dSpriteCollectionIndex indexEntry = null;
foreach (var v in spriteCollectionIndex)
{
if (v.spriteCollectionDataGUID == guid)
{
indexEntry = v;
existing = true;
break;
}
}
if (indexEntry == null)
{
indexEntry = new tk2dSpriteCollectionIndex();
}
indexEntry.name = sc.spriteCollectionName;
indexEntry.spriteCollectionDataGUID = guid;
indexEntry.spriteCollectionGUID = sc.spriteCollectionGUID;
indexEntry.spriteNames = new string[sc.spriteDefinitions.Length];
indexEntry.spriteTextureGUIDs = new string[sc.spriteDefinitions.Length];
indexEntry.spriteTextureTimeStamps = new string[sc.spriteDefinitions.Length];
indexEntry.version = sc.version;
indexEntry.managedSpriteCollection = sc.managedSpriteCollection;
indexEntry.loadable = sc.loadable;
indexEntry.assetName = sc.assetName;
for (int i = 0; i < sc.spriteDefinitions.Length; ++i)
{
var s = sc.spriteDefinitions[i];
if (s != null)
{
indexEntry.spriteNames[i] = sc.spriteDefinitions[i].name;
indexEntry.spriteTextureGUIDs[i] = sc.spriteDefinitions[i].sourceTextureGUID;
string assetPath = AssetDatabase.GUIDToAssetPath(indexEntry.spriteTextureGUIDs[i]);
if (assetPath.Length > 0 && System.IO.File.Exists(assetPath))
{
indexEntry.spriteTextureTimeStamps[i] = (System.IO.File.GetLastWriteTime(assetPath) - new System.DateTime(1970, 1, 1, 0, 0, 0, 0)).TotalSeconds.ToString();
}
else
{
indexEntry.spriteTextureTimeStamps[i] = "0";
}
}
else
{
indexEntry.spriteNames[i] = "";
indexEntry.spriteTextureGUIDs[i] = "";
indexEntry.spriteTextureTimeStamps[i] = "";
}
}
if (!existing)
{
spriteCollectionIndex.Add(indexEntry);
}
#endif
}
