static void ReimportAllMaterials()
{
//This method is called at opening and when HDRP package change (update of manifest.json)
//Check to see if the upgrader has been run for this project/HDRP version
PackageManager.PackageInfo hdrpInfo = PackageManager.PackageInfo.FindForAssembly(Assembly.GetAssembly(typeof(HDRenderPipeline)));
var hdrpVersion = hdrpInfo.version;
var curUpgradeVersion = HDProjectSettings.packageVersionForMaterialUpgrade;
if (curUpgradeVersion != hdrpVersion)
{
string[] guids = AssetDatabase.FindAssets("t:material", null);
foreach (var asset in guids)
{
var path = AssetDatabase.GUIDToAssetPath(asset);
AssetDatabase.ImportAsset(path);
}
string commandLineOptions = System.Environment.CommandLine;
bool inTestSuite = commandLineOptions.Contains("-testResults");
//prevent popup in test suite as there is no user to interact, no need to save in this case
if (!inTestSuite && EditorUtility.DisplayDialog("Material migrated",
"The change on used High-Definition Render Pipeline's version can cause materials to update. You need to save your project to definitely apply the update. If you close without saving, you will need to reimport non-updated material for them to work correctly and save project.\nPlease note that downgrade is not supported.",
"Save Project", "Not now"))
{
AssetDatabase.SaveAssets();
//to prevent data loss, only update the saved version if user applied change
HDProjectSettings.packageVersionForMaterialUpgrade = hdrpVersion;
}
}
}
void Finished()
{
EditorApplication.update -= Progress;
if (m_CurrentRequest.Status == PackageManager.StatusCode.Success)
{
var filteredResults = m_CurrentRequest.Result.Where(info => info.name == m_CurrentPackageName);
if (filteredResults.Count() == 0)
{
m_CurrentAction?.Invoke(false, default);
}
else
{
PackageManager.PackageInfo result = filteredResults.First();
m_CurrentAction?.Invoke(true, result);
}
}
else if (m_CurrentRequest.Status >= PackageManager.StatusCode.Failure)
{
Debug.LogError($"Failed to find package {m_CurrentPackageName}. Reason: {m_CurrentRequest.Error.message}");
}
else
{
Debug.LogError("Unsupported progress state " + m_CurrentRequest.Status);
}
m_CurrentRequest = null;
if (m_Queue.Count > 0)
{
(string packageIdOrName, Action <bool, PackageManager.PackageInfo> action) = m_Queue.Dequeue();
EditorApplication.delayCall += () => Start(packageIdOrName, action);
}
}
void UpdatePackageInstallationQuery()
{
Repaint();
EditorApplication.update -= UpdatePackageInstallationQuery;
if (m_InstallingPackage == null)
{
return;
}
if (!m_InstallingPackage.IsCompleted)
{
EditorApplication.update += UpdatePackageInstallationQuery;
return;
}
if (m_InstallingPackage.Status != StatusCode.Success)
{
// TODO Track installation error...
m_InstallingPackage = null;
m_InstallingPackageName = "";
return;
}
try
{
PackageManager.PackageInfo pinfo = m_InstallingPackage.Result;
XRPackageInformation xrpinfo;
bool addPackage = false;
if (!m_XRPackages.TryGetValue(pinfo.name, out xrpinfo))
{
xrpinfo.uninstalledPackageInfo = pinfo;
xrpinfo.isInstalled = false;
addPackage = true;
}
string tempPath = $"Packages/{pinfo.name}/package.json";
var packagePath = Path.GetFullPath(tempPath);
if (File.Exists(packagePath))
{
xrpinfo.isInstalled = true;
m_HasInstalledProviders = true;
}
if (addPackage)
{
m_XRPackages.Add(pinfo.name, xrpinfo);
}
}
catch (Exception)
{
// TODO Track creation error...
}
m_InstallingPackage = null;
m_InstallingPackageName = "";
}
internal static void WriteBuildLog(BuildLog log, string directory)
{
Directory.CreateDirectory(directory);
PackageManager.PackageInfo info = PackageManager.PackageInfo.FindForAssembly(typeof(BuildScriptBase).Assembly);
log.AddMetaData(info.name, info.version);
File.WriteAllText(Path.Combine(directory, "AddressablesBuildTEP.json"), log.FormatForTraceEventProfiler());
}
internal static void WriteBundleLayout(Stream stream, BuildLayout layout)
{
using (StreamWriter sw = new StreamWriter(stream))
{
TabWriter writer = new TabWriter(sw);
writer.WriteLine("WARNING! The formatting in this file may change in future package versions.");
writer.WriteLine($"Unity Version: {UnityEngine.Application.unityVersion}");
PackageManager.PackageInfo info = PackageManager.PackageInfo.FindForAssembly(typeof(BuildLayoutPrinter).Assembly);
if (info != null)
{
writer.WriteLine($"{info.name}: {info.version}");
}
WriteSummary(writer, layout);
writer.WriteLine("");
foreach (BuildLayout.Group grp in layout.Groups)
{
PrintGroup(writer, grp);
}
using (writer.IndentScope("BuiltIn Bundles"))
foreach (BuildLayout.Bundle b in layout.BuiltInBundles)
{
PrintArchive(writer, b);
}
}
}
void DownloadDefferedLoad()
{
if (m_listRequest == null)
{
m_listRequest = PackageManager.Client.List();
}
if (m_listRequest.IsCompleted)
{
var listResult = m_listRequest.Result;
if (EditorPrefs.HasKey("defferedLoadPackage"))
{
var loadPackage = EditorPrefs.GetString("defferedLoadPackage");
PackageManager.PackageInfo info = listResult.FirstOrDefault(p => p.name == loadPackage);
if (info != null)
{
if (InsertPackageXRLoaderToList(info))
{
EditorPrefs.DeleteKey("defferedLoadPackage");
}
}
else
{
m_listRequest = PackageManager.Client.List();
}
}
}
}
static void ReimportAllMaterials()
{
//This method is called at opening and when HDRP package change (update of manifest.json)
//Check to see if the upgrader has been run for this project/HDRP version
PackageManager.PackageInfo hdrpInfo = PackageManager.PackageInfo.FindForAssembly(Assembly.GetAssembly(typeof(HDRenderPipeline)));
var hdrpVersion = hdrpInfo.version;
var curUpgradeVersion = HDProjectSettings.packageVersionForMaterialUpgrade;
bool firstInstallOfHDRP = curUpgradeVersion == HDProjectSettings.k_PackageFirstTimeVersionForMaterials;
if (curUpgradeVersion != hdrpVersion)
{
string[] guids = AssetDatabase.FindAssets("t:material", null);
foreach (var asset in guids)
{
var path = AssetDatabase.GUIDToAssetPath(asset);
AssetDatabase.ImportAsset(path);
}
string commandLineOptions = System.Environment.CommandLine;
bool inTestSuite = commandLineOptions.Contains("-testResults");
//prevent popup in test suite as there is no user to interact, no need to save in this case
if (!inTestSuite && (firstInstallOfHDRP || EditorUtility.DisplayDialog("High Definition Materials Migration",
"Your current High Definition Render Pipeline requires a change that will update your Materials. In order to apply this update automatically, you need to save your Project. If you choose not to save your Project, you will need to re-import Materials manually, then save the Project.\n\nPlease note that downgrading from the High Definition Render Pipeline is not supported.",
"Save Project", "Not now")))
{
AssetDatabase.SaveAssets();
//to prevent data loss, only update the saved version if user applied change
HDProjectSettings.packageVersionForMaterialUpgrade = hdrpVersion;
}
}
}
// Based on UpmPackageInfo::IsPackageReadOnly() in PackageManagerCommon.cpp
internal static bool IsPackageReadOnly(PackageManager.PackageInfo pi)
{
if (pi.source == PackageSource.Embedded || pi.source == PackageSource.Local)
{
return(false);
}
return(true);
}
private static string FormatName(PackageManager.PackageInfo pi)
{
if (String.IsNullOrEmpty(pi.displayName))
{
return($"{pi.name}@{pi.version}");
}
return($"{pi.displayName} ({pi.name}@{pi.version})");
}
internal static void WriteBuildLog(BuildLog log, string directory)
{
Directory.CreateDirectory(directory);
#if UNITY_2019_2_OR_NEWER // PackageManager package inspection APIs didn't exist until 2019.2
PackageManager.PackageInfo info = PackageManager.PackageInfo.FindForAssembly(typeof(BuildScriptBase).Assembly);
log.AddMetaData(info.name, info.version);
#endif
File.WriteAllText(Path.Combine(directory, "AddressablesBuildTEP.json"), log.FormatForTraceEventProfiler());
}
private static string FormatLabel(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}");
}
private static bool IsPackageInstalled(PackageManager.PackageInfo pi, out string version)
{
version = null;
var installedPackage = s_ListRequest.Result.FirstOrDefault(l => l.name == pi.name);
if (installedPackage == null)
{
return(false);
}
version = installedPackage.version;
return(true);
}
protected override void OnSearchPackageFound(PackageManager.PackageInfo package)
{
base.OnSearchPackageFound(package);
foreach (var version in package.versions.compatible.Reverse())
{
if (TryGetMajorVersion(version, out var currentMajorVer))
{
if (currentMajorVer <= 2)
{
m_LatestPreMigrationPackageVersion = version;
break;
}
}
}
}
static void ReimportAllMaterials()
{
//Check to see if the upgrader has been run for this project/LWRP version
PackageManager.PackageInfo lwrpInfo = PackageManager.PackageInfo.FindForAssembly(Assembly.GetAssembly(typeof(UniversalRenderPipeline)));
var lwrpVersion = lwrpInfo.version;
var curUpgradeVersion = PlayerPrefs.GetString(Key);
if (curUpgradeVersion != lwrpVersion)
{
string[] guids = AssetDatabase.FindAssets("t:material", null);
foreach (var asset in guids)
{
var path = AssetDatabase.GUIDToAssetPath(asset);
AssetDatabase.ImportAsset(path);
}
PlayerPrefs.SetString(Key, lwrpVersion);
}
}
protected override void OnSearchPackageFound(PackageManager.PackageInfo package)
{
base.OnSearchPackageFound(package);
m_EligibleForMigration = false;
if (TryGetMajorVersion(currentPackageVersion, out var currentMajorVer))
{
if (currentMajorVer <= 2)
{
if (TryGetMajorVersion(latestPackageVersion, out var majorVer))
{
if (majorVer >= 3)
{
m_EligibleForMigration = true;
}
}
}
}
}
public void Consolidate(PackageInfo other)
{
Name = other.Name;
DisplayName = other.DisplayName;
PackageId = other.PackageId;
Version = other.Version;
Description = other.Description;
Category = other.Category;
IsCurrent = other.IsCurrent;
IsLatest = other.IsLatest;
IsVerified = other.IsVerified;
Errors = other.Errors;
Group = other.Group;
Type = other.Type;
State = other.State;
Origin = other.Origin;
Author = other.Author;
Info = other.Info;
HasFullFetch = other.HasFullFetch;
}
void Init(bool onThread)
{
m_WallTimer = Stopwatch.StartNew();
m_Root = new LogStep();
m_Stack = new Stack <LogStep>();
m_Stack.Push(m_Root);
AddMetaData("Date", DateTime.Now.ToString());
if (!onThread)
{
AddMetaData("UnityVersion", UnityEngine.Application.unityVersion);
#if UNITY_2019_2_OR_NEWER // PackageManager package inspection APIs didn't exist until 2019.2
PackageManager.PackageInfo info = PackageManager.PackageInfo.FindForAssembly(typeof(BuildLog).Assembly);
if (info != null)
{
AddMetaData(info.name, info.version);
}
#endif
}
}
protected override void OnSearchPackageFound(PackageManager.PackageInfo package)
{
base.OnSearchPackageFound(package);
m_EligibleForMigration = false;
m_LatestPreMigrationPackageVersion = string.Empty;
if (TryGetMajorVersion(currentPackageVersion, out var currentMajorVer))
{
if (currentMajorVer <= 2)
{
foreach (var version in package.versions.compatible.Reverse())
{
if (!IsPreviewVersion(version))
{
if (TryGetMajorVersion(version, out var majorVer))
{
if (majorVer <= 2)
{
if (string.IsNullOrEmpty(m_LatestPreMigrationPackageVersion))
{
m_LatestPreMigrationPackageVersion = version;
break; //Should be the last version we need to test for, given Reverse order. Move if algorithm changes.
}
}
else if (majorVer >= 3)
{
if (!m_EligibleForMigration)
{
m_EligibleForMigration = true;
m_MigratePackageVersionLabel.text = latestPackageVersion;
}
}
}
}
}
}
}
}
//----------------------------------------------------------------------------------------------------------------------
void TryCopyDCCPluginsFromPackage(Action <string> onSuccess, Action <string> onFail)
{
RequestJobManager.CreateListRequest(true, true, (listReq) => {
PackageManager.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) => {
PackageManager.PackageInfo meshSyncInfo = listReq.FindPackage(MESHSYNC_PACKAGE);
onFail?.Invoke(meshSyncInfo.version);
});
}, null);
}
bool InsertPackageXRLoaderToList(PackageManager.PackageInfo packageInfo)
{
List <LoaderInfo> newInfos = new List <LoaderInfo>();
XRManagerSettingsEditor.GetAllKnownLoaderInfos(newInfos);
foreach (var info in newInfos)
{
var assets = AssetDatabase.FindAssets(String.Format("t:{0}", info.loaderType));
if (assets.Length > 0)
{
string path = AssetDatabase.GUIDToAssetPath(assets[0]);
if (path.Contains(packageInfo.name))
{
AddLoaderMenu(info);
return(true);
}
}
}
return(false);
}
protected static IEnumerable <PackageInfo> FromUpmPackageInfo(PackageManager.PackageInfo info, bool isCurrent = true)
{
var packages = new List <PackageInfo>();
var displayName = info.displayName;
if (string.IsNullOrEmpty(displayName))
{
displayName = info.name.Replace(PackageInfo.ModulePrefix, "");
displayName = displayName.Replace(PackageInfo.UnityPrefix, "");
displayName = new CultureInfo("en-US").TextInfo.ToTitleCase(displayName);
}
string author = info.author.name;
if (string.IsNullOrEmpty(info.author.name) && info.name.StartsWith(PackageInfo.UnityPrefix))
{
author = "Unity Technologies Inc.";
}
var lastCompatible = info.versions.latestCompatible;
var versions = new List <string>();
versions.AddRange(info.versions.compatible);
if (versions.FindIndex(version => version == info.version) == -1)
{
versions.Add(info.version);
versions.Sort((left, right) =>
{
if (left == null || right == null)
{
return(0);
}
SemVersion leftVersion = left;
SemVersion righVersion = right;
return(leftVersion.CompareByPrecedence(righVersion));
});
SemVersion packageVersion = info.version;
if (!string.IsNullOrEmpty(lastCompatible))
{
SemVersion lastCompatibleVersion =
string.IsNullOrEmpty(lastCompatible) ? (SemVersion)null : lastCompatible;
if (packageVersion != null && string.IsNullOrEmpty(packageVersion.Prerelease) &&
packageVersion.CompareByPrecedence(lastCompatibleVersion) > 0)
{
lastCompatible = info.version;
}
}
else
{
if (packageVersion != null && string.IsNullOrEmpty(packageVersion.Prerelease))
{
lastCompatible = info.version;
}
}
}
foreach (var version in versions)
{
var isVersionCurrent = version == info.version && isCurrent;
var isBuiltIn = info.source == PackageSource.BuiltIn;
var isVerified = string.IsNullOrEmpty(SemVersion.Parse(version).Prerelease) && version == info.versions.verified;
var state = (isBuiltIn || info.version == lastCompatible || !isCurrent) ? PackageState.UpToDate : PackageState.Outdated;
// Happens mostly when using a package that hasn't been in production yet.
if (info.versions.all.Length <= 0)
{
state = PackageState.UpToDate;
}
if (info.errors.Length > 0)
{
state = PackageState.Error;
}
var packageInfo = new PackageInfo
{
Name = info.name,
DisplayName = displayName,
PackageId = version == info.version ? info.packageId : null,
Version = version,
Description = info.description,
Category = info.category,
IsInstalled = isVersionCurrent,
IsLatest = version == lastCompatible,
IsVerified = isVerified,
Errors = info.errors.ToList(),
Group = GroupName(info.source, info.type),
Type = info.type,
State = state,
Origin = isBuiltIn || isVersionCurrent ? info.source : PackageSource.Registry,
Author = author,
Info = info,
HasFullFetch = version == info.version
};
if (version == info.version && !string.IsNullOrEmpty(info.resolvedPath))
{
var loadedSamples = SampleJsonHelper.LoadSamplesFromPackageJson(info.resolvedPath);
packageInfo.Samples = new List <Sample>();
foreach (var sample in loadedSamples)
{
sample.resolvedPath = Path.Combine(info.resolvedPath, sample.path);
sample.importPath = IOUtils.CombinePaths
(
Application.dataPath,
"Samples",
IOUtils.SanitizeFileName(packageInfo.DisplayName),
packageInfo.Version.ToString(),
IOUtils.SanitizeFileName(sample.displayName)
);
packageInfo.Samples.Add(new Sample(sample));
}
}
packages.Add(packageInfo);
}
return(packages);
}
void OnSearchPackageFound(PackageManager.PackageInfo packageInfo)
{
m_InstallVersion = packageInfo.version;
packageSearchComplete?.Invoke(true);
}
static bool HasDependencyToPackage(PackageManager.PackageInfo packageInfo, string dependencyPackageName)
{
return(packageInfo.dependencies.Any(dependencyInfo => dependencyInfo.name.Equals(dependencyPackageName)));
}
protected static IEnumerable <PackageInfo> FromUpmPackageInfo(PackageManager.PackageInfo info, bool isCurrent = true)
{
var origin = PackageInfo.IsModule(info.name) ? PackageOrigin.Builtin : PackageOrigin.Registry;
var packages = new List <PackageInfo>();
var displayName = info.displayName;
if (string.IsNullOrEmpty(displayName))
{
displayName = info.name.Replace("com.unity.modules.", "");
displayName = displayName.Replace("com.unity.", "");
displayName = new CultureInfo("en-US").TextInfo.ToTitleCase(displayName);
}
var lastCompatible = info.versions.latestCompatible;
var versions = new List <string>();
versions.AddRange(info.versions.compatible);
if (versions.FindIndex(version => version == info.version) == -1)
{
versions.Add(info.version);
versions.Sort((left, right) =>
{
if (left == null || right == null)
{
return(0);
}
SemVersion leftVersion = left;
SemVersion righVersion = right;
return(leftVersion.CompareByPrecedence(righVersion));
});
SemVersion packageVersion = info.version;
if (!string.IsNullOrEmpty(lastCompatible))
{
SemVersion lastCompatibleVersion =
string.IsNullOrEmpty(lastCompatible) ? (SemVersion)null : lastCompatible;
if (packageVersion != null && string.IsNullOrEmpty(packageVersion.Prerelease) &&
packageVersion.CompareByPrecedence(lastCompatibleVersion) > 0)
{
lastCompatible = info.version;
}
}
else
{
if (packageVersion != null && string.IsNullOrEmpty(packageVersion.Prerelease))
{
lastCompatible = info.version;
}
}
}
foreach (var version in versions)
{
var isVersionCurrent = version == info.version && isCurrent;
var state = (origin == PackageOrigin.Builtin || info.version == lastCompatible) ? PackageState.UpToDate : PackageState.Outdated;
// Happens mostly when using a package that hasn't been in production yet.
if (info.versions.all.Length <= 0)
{
state = PackageState.UpToDate;
}
if (info.errors.Length > 0)
{
state = PackageState.Error;
}
var packageInfo = new PackageInfo
{
Name = info.name,
DisplayName = displayName,
PackageId = version == info.version ? info.packageId : null,
Version = version,
Description = info.description,
Category = info.category,
IsCurrent = isVersionCurrent,
IsLatest = version == lastCompatible,
IsVerified = version == info.versions.recommended,
Errors = info.errors.ToList(),
Group = GroupName(origin),
State = state,
Origin = origin,
Author = null
};
packages.Add(packageInfo);
}
return(packages);
}
private static string FormatDescription(PackageManager.PackageInfo pi)
{
return(pi.description.Replace("\r", "").Replace("\n", ""));
}
private static bool IsPackageInstalled(PackageManager.PackageInfo pi)
{
return(IsPackageInstalled(pi, out _));
}
