private static bool ShouldTreatPackageAsMod(UnityEditor.PackageManager.PackageInfo package)
{
//if (package.status == UnityEditor.PackageManager.PackageStatus.Available
// && (package.source == UnityEditor.PackageManager.PackageSource.Embedded || package.source == UnityEditor.PackageManager.PackageSource.Git || package.source == UnityEditor.PackageManager.PackageSource.Local)
// )
{
var path = package.resolvedPath;
if (!string.IsNullOrEmpty(path))
{
if (System.IO.Directory.Exists(path + "/Link~"))
{
return(true);
}
if (System.IO.File.Exists(path + "/mcs.rsp"))
{
return(true);
}
if (System.IO.File.Exists(path + "/Runtime/Resources/resdesc.asset"))
{
return(true);
}
if (System.IO.File.Exists(path + "/Resources/resdesc.asset"))
{
return(true);
}
if (System.IO.File.Exists(path + "/mod.readme.md"))
{
return(true);
}
}
}
return(false);
}
internal static IEnumerable <AsmDefDescription> AllAssemblyDefinitions()
{
var guids = AssetDatabase.FindAssets("t:AssemblyDefinitionAsset");
var ret = new List <AsmDefDescription>();
foreach (var guid in guids)
{
var asmdefFile = AssetDatabase.GUIDToAssetPath(guid);
var fullpath = new NPath(asmdefFile).MakeAbsolute();
var asmdef = JsonUtility.FromJson <AsmDefJsonObject>(fullpath.ReadAllText());
var packageInfo = PackageInfo.FindForAssetPath(asmdefFile.ToString());
var packageSource = packageInfo?.source.ToString() ?? "NoPackage";
// this creates a world of problems
//if (AssemblyDefinitionUtility.IsRuntimeAssembly(path))
ret.Add(new AsmDefDescription
{
AsmdefName = asmdef.name,
FullPath = Path.GetFullPath(fullpath.ToString()),
Guid = guid,
PackageSource = packageSource
});
}
return(ret.OrderBy(asmdef => new NPath(asmdef.FullPath).RelativeTo(new NPath(Application.dataPath).Parent)));
}
//----------------------------------------------------------------------------------------------------------------------
void CopyDCCPluginsFromPackage(string dccPluginVersion, Action <string> onSuccess, Action <string> onFail)
{
PackageRequestJobManager.CreateListRequest(/*offlineMode=*/ true, /*includeIndirectIndependencies=*/ true,
/*onSuccess=*/ (listReq) => {
PackageInfo packageInfo = listReq.FindPackage(MESHSYNC_DCC_PLUGIN_PACKAGE);
if (null != packageInfo && packageInfo.version == dccPluginVersion)
{
//Package is already installed.
CopyDCCPluginsFromPackage(dccPluginVersion);
onSuccess(packageInfo.version);
return;
}
string packageNameAndVer = $"{MESHSYNC_DCC_PLUGIN_PACKAGE}@{dccPluginVersion}";
PackageRequestJobManager.CreateAddRequest(packageNameAndVer,
/*onSuccess=*/ (addReq) => {
//Package was successfully added
CopyDCCPluginsFromPackage(dccPluginVersion);
onSuccess(dccPluginVersion);
},
/*onFail=*/ (req) => {
PackageInfo meshSyncInfo = listReq.FindPackage(MeshSyncConstants.PACKAGE_NAME);
onFail?.Invoke(meshSyncInfo.version);
});
},
/*OnFail=*/ null
);
}
static IEnumerable <string> FindVisualStudioDevEnvPaths()
{
string asset = AssetDatabase.FindAssets("VSWhere a:packages").Select(AssetDatabase.GUIDToAssetPath).FirstOrDefault(assetPath => assetPath.Contains("vswhere.exe"));
if (string.IsNullOrWhiteSpace(asset)) // This may be called too early where the asset database has not replicated this information yet.
{
yield break;
}
UnityEditor.PackageManager.PackageInfo packageInfo = UnityEditor.PackageManager.PackageInfo.FindForAssetPath(asset);
var progpath = packageInfo.resolvedPath + asset.Substring("Packages/com.unity.ide.visualstudio".Length);
var process = new Process
{
StartInfo = new ProcessStartInfo
{
FileName = progpath,
Arguments = "-prerelease -property productPath",
UseShellExecute = false,
CreateNoWindow = true,
RedirectStandardOutput = true,
RedirectStandardError = true,
}
};
process.Start();
process.WaitForExit();
while (!process.StandardOutput.EndOfStream)
{
yield return(process.StandardOutput.ReadLine());
}
}
public void CurrentBuilderVersionIsDisplayedInTheTitlebar()
{
var packageInfo = PackageInfo.FindForAssetPath("Packages/" + BuilderConstants.BuilderPackageName);
var builderPackageVersion = packageInfo.version;
Assert.True(ViewportPane.subTitle.Contains(builderPackageVersion));
}
private static void LinkPackageToMod(UnityEditor.PackageManager.PackageInfo package)
{
var path = package.resolvedPath;
var mod = System.IO.Path.GetFileName(path);
if (mod.Contains("@"))
{
mod = mod.Substring(0, mod.IndexOf('@'));
}
if (System.IO.Directory.Exists(path + "/Link~/Mod"))
{
var link = "Assets/Mods/" + mod;
if (!System.IO.Directory.Exists(link) && !System.IO.File.Exists(link))
{
System.IO.Directory.CreateDirectory("Assets/Mods/");
ResManagerEditorEntryUtils.MakeDirLink(link, path + "/Link~/Mod");
ResManagerEditorEntryUtils.AddGitIgnore("Assets/Mods/.gitignore", mod);
}
}
for (int i = 0; i < UniqueSpecialFolders.Length; ++i)
{
var usdir = UniqueSpecialFolders[i];
var link = "Assets/" + usdir + "/Mods/" + mod + "/Content";
var target = path + "/Link~/" + usdir;
if (System.IO.Directory.Exists(target) && !System.IO.Directory.Exists(link) && !System.IO.File.Exists(link))
{
System.IO.Directory.CreateDirectory("Assets/" + usdir + "/Mods/" + mod);
ResManagerEditorEntryUtils.MakeDirLink(link, target);
}
}
}
static void WriteAsmdefsJson(NPath directory)
{
var file = directory.Combine("asmdefs.json");
if (file.FileExists() && alreadyWrittenDataFile)
{
return;
}
var asmdefs = new List <AsmDefDescription>();
foreach (var asmdefFile in AllAssemblyDefinitions())
{
var asmdef = JsonUtility.FromJson <AsmDefJsonObject>(asmdefFile.MakeAbsolute().ReadAllText());
var packageInfo = PackageInfo.FindForAssetPath(asmdefFile.ToString());
var packageSource = packageInfo?.source.ToString() ?? "NoPackage";
asmdefs.Add(new AsmDefDescription()
{
AsmdefName = asmdef.name, FullPath = Path.GetFullPath(asmdefFile.ToString()), PackageSource = packageSource
});
}
var projectPath = new NPath(UnityEngine.Application.dataPath).Parent;
file.UpdateAllText(JsonSerialization.Serialize(new BeeAsmdefConfiguration()
{
asmdefs = asmdefs,
UnityProjectPath = projectPath.ToString(),
ProjectName = projectPath.FileName,
}));
alreadyWrittenDataFile = true;
}
/// <summary>
/// 在PackageManager视窗
/// 当选择插件包时,获取这个插件包的信息
/// </summary>
/// <param name="packageInfo"></param>
public void OnPackageSelectionChange(PackageInfo packageInfo)
{
if (_ui == null)
{
return;
}
if (packageInfo == null)
{
return;
}
_selectPackageInfo = packageInfo;
var packageId = _selectPackageInfo.packageId;
// 判断这个包是否是git途径获取的
_gitUrl = GetGitUrl(packageId);
// 只有git途径获取的包,才能使用UPM Tool拓展功能
if (string.IsNullOrEmpty(_gitUrl))
{
_ui.SetUIVisible(false);
return;
}
_ui.SetUIVisible(true);
_ui.ResetDrawPackageVersionUI();
if (_inRequestList == false)
{
DrawDependenciesUt();
}
}
private static string FormatName(UnityEditor.PackageManager.PackageInfo pi)
{
if (String.IsNullOrEmpty(pi.displayName))
{
return($"{pi.name}@{pi.version}");
}
return($"{pi.displayName} ({pi.name}@{pi.version})");
}
// package の version (SemVer)
public static string GetCreatorKitVersion()
{
var type = MethodBase.GetCurrentMethod().DeclaringType;
var assembly = Assembly.GetAssembly(type);
var package = PackageInfo.FindForAssembly(assembly);
return(package.version);
}
private bool OpenWindowsApp(string path, int line)
{
var comAssetPath = AssetDatabase.FindAssets("COMIntegration a:packages").Select(AssetDatabase.GUIDToAssetPath).First(assetPath => assetPath.Contains("COMIntegration.dom"));
if (string.IsNullOrWhiteSpace(comAssetPath)) // This may be called too early where the asset database has not replicated this information yet.
{
return(false);
}
UnityEditor.PackageManager.PackageInfo packageInfo = UnityEditor.PackageManager.PackageInfo.FindForAssetPath(comAssetPath);
var progpath = packageInfo.resolvedPath + comAssetPath.Substring("Packages/com.unity.ide.visualstudio".Length);
string absolutePath = "";
if (!string.IsNullOrWhiteSpace(path))
{
absolutePath = Path.GetFullPath(path);
}
var solution = GetOrGenerateSolutionFile(path);
solution = solution == "" ? "" : $"\"{solution}\"";
var process = new Process
{
StartInfo = new ProcessStartInfo
{
FileName = progpath,
Arguments = $"\"{CodeEditor.CurrentEditorInstallation}\" \"{absolutePath}\" {solution} {line}",
CreateNoWindow = true,
UseShellExecute = false,
RedirectStandardOutput = true,
RedirectStandardError = true,
}
};
var result = process.Start();
while (!process.StandardOutput.EndOfStream)
{
var outputLine = process.StandardOutput.ReadLine();
if (outputLine == "displayProgressBar")
{
EditorUtility.DisplayProgressBar("Opening Visual Studio", "Starting up Visual Studio, this might take some time.", .5f);
}
if (outputLine == "clearprogressbar")
{
EditorUtility.ClearProgressBar();
}
}
var errorOutput = process.StandardError.ReadToEnd();
if (!string.IsNullOrEmpty(errorOutput))
{
Console.WriteLine("Error: \n" + errorOutput);
}
process.WaitForExit();
return(result);
}
public ProjectIssue Analyze()
{
#if UNITY_2019_3_OR_NEWER
if (PackageInfo.FindForAssetPath("Packages/com.unity.rendering.hybrid") != null && IsStaticBatchingEnabled(EditorUserBuildSettings.activeBuildTarget))
{
return(new ProjectIssue(k_Descriptor, k_Descriptor.description, IssueCategory.ProjectSettings));
}
#endif
return(null);
}
/// <summary>
/// Called by the Package Manager UI when the package selection changed.
/// </summary>
/// <param name="packageInfo">The newly selected package information (can be null)</param>
public void OnPackageSelectionChange(PackageInfo packageInfo)
{
if (packageInfo == null)
{
return;
}
InitializeUI();
packageDetailsExtension?.OnPackageSelectionChange(packageInfo);
}
private static string FormatLabel(UnityEditor.PackageManager.PackageInfo pi)
{
var installedPackage = s_ListRequest.Result.FirstOrDefault(l => l.name == pi.name);
var status = installedPackage != null ? (installedPackage.version == pi.version ?
" - <i>In Project</i>" : " - <b>Update Available</b>") : "";
if (String.IsNullOrEmpty(pi.displayName))
{
return($"{pi.name}@{pi.version}{status}");
}
return($"{FormatName(pi)}{status}");
}
public static PackageInfo FindPackageByName(string packageName)
{
if (packageName.Substring(0, 4) == "com.")
{
return(PackageInfo.FindForAssetPath($"Packages/{packageName}"));
}
return(AssetDatabase.FindAssets("package")
.Select(AssetDatabase.GUIDToAssetPath)
.Where(packageJsonPath => AssetDatabase.LoadAssetAtPath <TextAsset>(packageJsonPath) != null)
.Select(PackageInfo.FindForAssetPath)
.FirstOrDefault(x => x.displayName == packageName));
}
public void OnPackageSelectionChange(PackageInfo packageInfo)
{
var thisPackageIsSelected = packageInfo?.name == PackageData.packageUniqueName;
if (thisPackageIsSelected)
{
FetchModel();
}
if (_view != null)
{
_view.style.display = thisPackageIsSelected ? DisplayStyle.Flex : DisplayStyle.None;
}
}
static void WriteAsmdefsJson(NPath directory)
{
var file = directory.Combine("asmdefs.json");
if (file.FileExists() && s_AlreadyWrittenDataFile)
{
}
var asmdefs = AllAssemblyDefinitions().ToList();
var asmrefs = new List <AsmRefDescription>();
foreach (var asmrefFile in AllAsmRefs())
{
var asmref = JsonUtility.FromJson <AsmRefJsonObject>(asmrefFile.MakeAbsolute().ReadAllText());
var packageInfo = PackageInfo.FindForAssetPath(asmrefFile.ToString());
var packageSource = packageInfo?.source.ToString() ?? "NoPackage";
asmrefs.Add(new AsmRefDescription()
{
AsmRefTarget = asmref.reference,
FullPath = Path.GetFullPath(asmrefFile.ToString()),
PackageSource = packageSource
});
}
var projectPath = new NPath(UnityEngine.Application.dataPath).Parent;
var projectManifestPath = projectPath.Combine("Packages/manifest.json");
var projectManifest = JsonUtility.FromJson <ProjectManifestJsonObject>(projectManifestPath.MakeAbsolute().ReadAllText());
List <string> testableAsmDefNames = new List <string>();
foreach (var testablePackageName in projectManifest.testables)
{
testableAsmDefNames.AddRange(asmdefs.Where(a => a.AsmdefName.EndsWith(".Tests") && a.FullPath.Contains(testablePackageName)).Select(a => a.AsmdefName));
}
var compilationPipelinePath = new NPath(Path.Combine(EditorApplication.applicationContentsPath, "Managed", "Unity.CompilationPipeline.Common.dll"));
file.UpdateAllText(JsonSerialization.ToJson(new BeeAsmdefConfiguration()
{
asmdefs = asmdefs,
asmrefs = asmrefs,
UnityProjectPath = projectPath.ToString(),
ProjectName = projectPath.FileName,
Testables = testableAsmDefNames,
CompilationPipelineAssemblyPath = compilationPipelinePath.ToString(),
BuildSettingsFileVersion = BuildStepGenerateBeeFiles.BuildSettingsFileVersion
}));
s_AlreadyWrittenDataFile = true;
}
internal static void CreateLocalizationAssets(string path)
{
try
{
TutorialManager.DirectoryCopy(
$"{PackageInfo.FindForAssembly(Assembly.GetExecutingAssembly()).assetPath}/.LocalizationAssets",
path
);
AssetDatabase.Refresh();
}
catch (Exception e)
{
Debug.LogException(e);
}
}
public static Rect CalculateRectAfterLabelText(Rect rect, string projectWindowItemPath, bool hasIcon)
{
var content = new GUIContent(Path.GetFileNameWithoutExtension(projectWindowItemPath));
if (projectWindowItemPath.StartsWith("Packages"))
{
var pi = PackageInfo.FindForAssetPath(projectWindowItemPath);
if (!string.IsNullOrEmpty(pi.displayName))
{
content.text = pi.displayName;
}
}
return(CalculateRectAfterLabelText(rect, content, hasIcon));
}
public PackageManifest(UnityEditor.PackageManager.PackageInfo info)
{
this.info = info;
var location = Path.Combine(info.assetPath, Paths.PackageManifest);
asset = AssetDatabase.LoadAssetAtPath <TextAsset>(location);
if (asset == null)
{
throw new System.Exception("Cannot load asset at path " + location);
}
JsonUtility.FromJsonOverwrite(asset.text, this);
OnAfterDeserialize();
filesystem_location = info.resolvedPath;
}
public void Install()
{
var info = PackageInfo.FindForAssetPath("Packages/com.rundotgames.unitybutler");
if (info == null)
{
throw new Exception("unable to locate unity butler package info");
}
if (!shell.Run("install-unity-butler.bat", true, MakePackagePath(info)))
{
throw new Exception("failed to install unity butler");
}
UpdateInstallStatus();
}
public void SetUp()
{
var assembly = Assembly.Load("Unity.XR.Interaction.Toolkit");
Assert.That(assembly, Is.Not.Null);
m_PackageInfo = PackageInfo.FindForAssembly(assembly);
Assert.That(m_PackageInfo, Is.Not.Null);
// Parse the major.minor version
Assert.That(m_PackageInfo.version, Is.Not.Null);
Assert.That(m_PackageInfo.version, Is.Not.Empty);
var secondDotIndex = m_PackageInfo.version.IndexOf('.', m_PackageInfo.version.IndexOf('.') + 1);
Assert.That(secondDotIndex, Is.GreaterThan(0));
m_MajorMinorVersion = m_PackageInfo.version.Substring(0, secondDotIndex);
}
private string EscapedRelativePathFor(string file, out UnityEditor.PackageManager.PackageInfo packageInfo)
{
var projectDir = ProjectDirectory.NormalizePathSeparators();
file = file.NormalizePathSeparators();
var path = SkipPathPrefix(file, projectDir);
packageInfo = m_AssemblyNameProvider.FindForAssetPath(path.NormalizeWindowsToUnix());
if (packageInfo != null)
{
// We have to normalize the path, because the PackageManagerRemapper assumes
// dir seperators will be os specific.
var absolutePath = Path.GetFullPath(path.NormalizePathSeparators());
path = SkipPathPrefix(absolutePath, projectDir);
}
return(XmlFilename(path));
}
void CheckNotificationWorthyStates()
{
m_PendingNotifications = 0;
#if UNITY_2020_1 || UNITY_2020_2 || UNITY_2020_3
// Handle the missing UI Toolkit package case.
var uitkPackageInfo = PackageInfo.FindForAssetPath("Packages/" + BuilderConstants.UIToolkitPackageName);
if (uitkPackageInfo == null)
{
m_PendingNotifications++;
if (!BuilderProjectSettings.hideNotificationAboutMissingUITKPackage)
{
AddNotification(
BuilderConstants.NoUIToolkitPackageInstalledNotification,
"https://forum.unity.com/threads/ui-toolkit-1-0-preview-available.927822/",
() => BuilderProjectSettings.hideNotificationAboutMissingUITKPackage = true);
}
}
#endif
}
private void PackageGUI(PublicationPackageView packageView)
{
EditorGUI.BeginChangeCheck();
if (initialSelection != null && initialSelection.packageId == packageView.package.info.packageId)
{
packageView.publish = true;
initialSelection = null;
}
packageView.publish = EditorGUILayout.BeginToggleGroup(packageView.package.displayName, packageView.publish);
if (EditorGUI.EndChangeCheck())
{
if (!packageView.publish)
{
publishAll = false;
}
}
packageView.registry = packageView.RegistrySelector.SelectRegistry("\t", packageView.registry);
EditorGUILayout.EndToggleGroup();
}
//----------------------------------------------------------------------------------------------------------------------
void TryCopyDCCPluginsFromPackage(Action <string> onSuccess, Action <string> onFail)
{
RequestJobManager.CreateListRequest(true, true, (listReq) => {
PackageInfo packageInfo = listReq.FindPackage(MESHSYNC_DCC_PLUGIN_PACKAGE);
if (null != packageInfo)
{
//Package is already installed.
CopyDCCPluginsFromPackage();
onSuccess(packageInfo.version);
return;
}
RequestJobManager.CreateAddRequest(MESHSYNC_DCC_PLUGIN_PACKAGE, (addReq) => {
//Package was successfully added
CopyDCCPluginsFromPackage();
onSuccess(packageInfo.version);
}, (req) => {
PackageInfo meshSyncInfo = listReq.FindPackage(MESHSYNC_PACKAGE);
onFail?.Invoke(meshSyncInfo.version);
});
}, null);
}
private void Package(UnityEditor.PackageManager.PackageInfo info)
{
GUIStyle boxStyle = new GUIStyle();
boxStyle.padding = new RectOffset(10, 10, 0, 0);
EditorGUILayout.BeginHorizontal(boxStyle);
EditorGUI.BeginChangeCheck();
bool upgrade = false;
if (upgradeList.ContainsKey(info))
{
upgrade = upgradeList[info];
}
upgrade = EditorGUILayout.BeginToggleGroup(info.displayName + ":" + info.version, upgrade);
if (EditorGUI.EndChangeCheck())
{
if (!upgrade)
{
upgradeAll = false;
}
}
upgradeList[info] = upgrade;
EditorGUILayout.EndToggleGroup();
EditorGUILayout.LabelField(manager.GetLatestVersion(info));
EditorGUILayout.EndHorizontal();
}
// Returns the correct path (forward slash used as the separator) depending whether we're running the tests locally or as a separate package.
protected static string GetTestAssetPath(string relativeAssetPath)
{
var packagePath = PackageInfo.FindForAssembly(Assembly.GetExecutingAssembly()).assetPath;
return(Path.Combine($"{packagePath}/Tests/Editor", relativeAssetPath).Replace('\\', '/'));
}
public static void Update()
{
//if( Application.isPlaying )
// return;
CheckLatePackageImport();
//if( m_lwPackageInfo != null )
//{
// if( m_srpVersionConverter[ m_lwPackageInfo.version ] != m_currentLWVersion )
// {
// m_currentLWVersion = m_srpVersionConverter[ m_lwPackageInfo.version ];
// EditorPrefs.SetInt( LWEditorPrefsId, (int)m_currentLWVersion );
// m_importingPackage = ASEImportState.Lightweight;
// string packagePath = AssetDatabase.GUIDToAssetPath( m_srpToASEPackageLW[ m_currentLWVersion ] );
// StartImporting( packagePath );
// }
//}
//if( m_hdPackageInfo != null )
//{
// if( m_srpVersionConverter[ m_hdPackageInfo.version ] != m_currentHDVersion )
// {
// m_currentHDVersion = m_srpVersionConverter[ m_hdPackageInfo.version ];
// EditorPrefs.SetInt( HDEditorPrefsId, (int)m_currentHDVersion );
// m_importingPackage = ASEImportState.HD;
// string packagePath = AssetDatabase.GUIDToAssetPath( m_srpToASEPackageHD[ m_currentHDVersion ] );
// StartImporting( packagePath );
// }
//}
if (m_requireUpdateList && m_importingPackage == ASEImportState.None)
{
if (m_packageListRequest != null && m_packageListRequest.IsCompleted)
{
m_requireUpdateList = false;
foreach (UnityEditor.PackageManager.PackageInfo pi in m_packageListRequest.Result)
{
if (pi.name.Equals(LWPackageId))
{
m_currentLWVersion = ASESRPVersions.ASE_SRP_RECENT;
m_lwPackageInfo = pi;
ASESRPVersions oldVersion = (ASESRPVersions)EditorPrefs.GetInt(LWEditorPrefsId);
if (m_srpVersionConverter.ContainsKey(pi.version))
{
m_currentLWVersion = m_srpVersionConverter[pi.version];
}
else
{
m_currentLWVersion = ASESRPVersions.ASE_SRP_RECENT;
}
EditorPrefs.SetInt(LWEditorPrefsId, (int)m_currentLWVersion);
bool foundNewVersion = oldVersion != m_currentLWVersion;
if (!File.Exists(AssetDatabase.GUIDToAssetPath(TemplatesManager.LightweigthPBRGUID)) ||
!File.Exists(AssetDatabase.GUIDToAssetPath(TemplatesManager.LightweigthUnlitGUID)) ||
foundNewVersion
)
{
if (foundNewVersion)
{
Debug.Log(LightweightNewVersionDetected);
}
m_importingPackage = ASEImportState.Lightweight;
string guid = m_srpToASEPackageLW.ContainsKey(m_currentLWVersion) ? m_srpToASEPackageLW[m_currentLWVersion] : m_srpToASEPackageLW[ASESRPVersions.ASE_SRP_RECENT];
string packagePath = AssetDatabase.GUIDToAssetPath(guid);
StartImporting(packagePath);
}
}
if (pi.name.Equals(UniversalPackageId))
{
m_currentLWVersion = ASESRPVersions.ASE_SRP_RECENT;
m_lwPackageInfo = pi;
ASESRPVersions oldVersion = (ASESRPVersions)EditorPrefs.GetInt(LWEditorPrefsId);
if (m_srpVersionConverter.ContainsKey(pi.version))
{
m_currentLWVersion = m_srpVersionConverter[pi.version];
}
else
{
m_currentLWVersion = ASESRPVersions.ASE_SRP_RECENT;
}
EditorPrefs.SetInt(LWEditorPrefsId, (int)m_currentLWVersion);
bool foundNewVersion = oldVersion != m_currentLWVersion;
int urpVersion = EditorPrefs.GetInt(URPTemplateVersion, m_urpTemplateVersion);
if (urpVersion < m_urpTemplateVersion)
{
foundNewVersion = true;
}
EditorPrefs.SetInt(URPTemplateVersion, m_urpTemplateVersion);
if (!File.Exists(AssetDatabase.GUIDToAssetPath(TemplatesManager.UniversalPBRGUID)) ||
!File.Exists(AssetDatabase.GUIDToAssetPath(TemplatesManager.UniversalUnlitGUID)) ||
foundNewVersion
)
{
if (foundNewVersion)
{
Debug.Log(LightweightNewVersionDetected);
}
m_importingPackage = ASEImportState.Lightweight;
string guid = m_srpToASEPackageLW.ContainsKey(m_currentLWVersion) ? m_srpToASEPackageLW[m_currentLWVersion] : m_srpToASEPackageLW[ASESRPVersions.ASE_SRP_RECENT];
string packagePath = AssetDatabase.GUIDToAssetPath(guid);
StartImporting(packagePath);
}
}
if (pi.name.Equals(HDPackageId))
{
m_currentHDVersion = ASESRPVersions.ASE_SRP_RECENT;
m_hdPackageInfo = pi;
ASESRPVersions oldVersion = (ASESRPVersions)EditorPrefs.GetInt(HDEditorPrefsId);
if (m_srpVersionConverter.ContainsKey(pi.version))
{
m_currentHDVersion = m_srpVersionConverter[pi.version];
}
else
{
m_currentHDVersion = ASESRPVersions.ASE_SRP_RECENT;
}
EditorPrefs.SetInt(HDEditorPrefsId, (int)m_currentHDVersion);
bool foundNewVersion = oldVersion != m_currentHDVersion;
int hdrpVersion = EditorPrefs.GetInt(HDRPTemplateVersion, m_hdrpTemplateVersion);
if (hdrpVersion < m_hdrpTemplateVersion)
{
foundNewVersion = true;
}
EditorPrefs.SetInt(HDRPTemplateVersion, m_hdrpTemplateVersion);
#if UNITY_2019_3_OR_NEWER
if (!File.Exists(AssetDatabase.GUIDToAssetPath(TemplatesManager.HDNewLitGUID)) ||
!File.Exists(AssetDatabase.GUIDToAssetPath(TemplatesManager.HDNewPBRGUID)) ||
!File.Exists(AssetDatabase.GUIDToAssetPath(TemplatesManager.HDNewUnlitGUID)) ||
#else
if (!File.Exists(AssetDatabase.GUIDToAssetPath(TemplatesManager.HDLitGUID)) ||
!File.Exists(AssetDatabase.GUIDToAssetPath(TemplatesManager.HDPBRGUID)) ||
!File.Exists(AssetDatabase.GUIDToAssetPath(TemplatesManager.HDUnlitGUID)) ||
#endif
foundNewVersion
)
{
if (foundNewVersion)
{
Debug.Log(HDNewVersionDetected);
}
m_importingPackage = m_importingPackage == ASEImportState.Lightweight ? ASEImportState.Both : ASEImportState.HD;
string guid = m_srpToASEPackageHD.ContainsKey(m_currentHDVersion) ? m_srpToASEPackageHD[m_currentHDVersion] : m_srpToASEPackageHD[ASESRPVersions.ASE_SRP_RECENT];
string packagePath = AssetDatabase.GUIDToAssetPath(guid);
StartImporting(packagePath);
}
}
}
}
}
}
private static string FormatDescription(UnityEditor.PackageManager.PackageInfo pi)
{
return(pi.description.Replace("\r", "").Replace("\n", ""));
}
