/// <inheritdoc/>
public IEnumerable<AssetItem> GetAssets(AssetCompilerResult assetCompilerResult)
{
// Check integrity of the packages
var packageAnalysis = new PackageSessionAnalysis(package.Session, new PackageAnalysisParameters());
packageAnalysis.Run(assetCompilerResult);
if (assetCompilerResult.HasErrors)
{
return Enumerable.Empty<AssetItem>();
}
// Compute list of assets to compile and their dependencies
var packagesProcessed = new HashSet<Package>();
var assetsReferenced = new HashSet<AssetItem>();
CollectReferences(package, assetsReferenced, packagesProcessed);
var assets = assetsReferenced.ToList();
assets.Sort((item1, item2) => item1.Asset != null && item2.Asset != null ? item1.Asset.InternalBuildOrder.CompareTo(item2.Asset.InternalBuildOrder) : 0);
return assets;
}
/// <summary>
/// Compile the current package session.
/// That is generate the list of build steps to execute to create the package assets.
/// </summary>
public AssetCompilerResult Compile(AssetCompilerContext compilerContext)
{
if (compilerContext == null) throw new ArgumentNullException("compilerContext");
if (compilerContext.Package == null)
{
throw new ArgumentException("Expecting a non null package", "compilerContext");
}
if (compilerContext.Package.Session == null)
{
throw new ArgumentException("Expecting a package attached to a session", "compilerContext");
}
var result = new AssetCompilerResult();
// Check integrity of the packages
var packageAnalysis = new PackageSessionAnalysis(compilerContext.Package.Session, new PackageAnalysisParameters());
packageAnalysis.Run(result);
if (result.HasErrors)
{
return result;
}
// Add default compilers
compilers.Clear();
var defaultAssetsCompiler = new DefaultAssetsCompiler();
defaultAssetsCompiler.AssetCompiled += OnAssetCompiled;
compilers.Add(defaultAssetsCompiler);
var packagesProcessed = new HashSet<Package>();
RecursiveCompile(result, compilerContext, packagesProcessed);
return result;
}
/// <inheritdoc/>
public IEnumerable<AssetItem> GetAssets(AssetCompilerResult assetCompilerResult)
{
// Check integrity of the packages
var packageAnalysis = new PackageSessionAnalysis(package.Session, new PackageAnalysisParameters());
packageAnalysis.Run(assetCompilerResult);
if (assetCompilerResult.HasErrors)
{
return Enumerable.Empty<AssetItem>();
}
// Get the dependencies (in reverse order so that we start depth first)
// TODO: result.Error("Unable to find package [{0}]", packageDependency); < when resolving dependencies
// TODO: result.Info("Compiling package [{0}]", package.FullPath); < probably doesn't make sense anymore
var packages = package.GetPackagesWithRecursiveDependencies().Reverse();
// For each package, list assets and sort by build order
return packages.SelectMany(x =>
{
var packageAssets = x.Assets.ToList();
// Sort the items to build by build order
packageAssets.Sort((item1, item2) => item1.Asset != null && item2.Asset != null ? item1.Asset.InternalBuildOrder.CompareTo(item2.Asset.InternalBuildOrder) : 0);
return packageAssets;
}).ToList();
}
/// <summary>
/// Loads a package from specified file path.
/// </summary>
/// <param name="filePath">The file path to a package file.</param>
/// <param name="sessionResult">The session result.</param>
/// <param name="loadParameters">The load parameters.</param>
/// <returns>A package.</returns>
/// <exception cref="System.ArgumentNullException">filePath</exception>
/// <exception cref="System.ArgumentException">File [{0}] must exist.ToFormat(filePath);filePath</exception>
public static void Load(string filePath, PackageSessionResult sessionResult, PackageLoadParameters loadParameters = null)
{
if (filePath == null) throw new ArgumentNullException("filePath");
if (sessionResult == null) throw new ArgumentNullException("sessionResult");
// Make sure with have valid parameters
loadParameters = loadParameters ?? PackageLoadParameters.Default();
// Make sure to use a full path.
filePath = FileUtility.GetAbsolutePath(filePath);
if (!File.Exists(filePath)) throw new ArgumentException("File [{0}] must exist".ToFormat(filePath), "filePath");
try
{
// Enable reference analysis caching during loading
AssetReferenceAnalysis.EnableCaching = true;
using (var profile = Profiler.Begin(PackageSessionProfilingKeys.Loading))
{
sessionResult.Clear();
sessionResult.Progress("Loading..", 0, 1);
var session = new PackageSession();
var packagePaths = new List<string>();
// If we have a solution, load all packages
if (PackageSessionHelper.IsSolutionFile(filePath))
{
PackageSessionHelper.LoadSolution(session, filePath, packagePaths, sessionResult);
}
else if (PackageSessionHelper.IsPackageFile(filePath))
{
packagePaths.Add(filePath);
}
else
{
sessionResult.Error("Unsupported file extension (only .sln or {0} are supported)", Package.PackageFileExtension);
return;
}
var cancelToken = loadParameters.CancelToken;
// Load all packages
var packagesLoaded = new PackageCollection();
foreach (var packageFilePath in packagePaths)
{
PreLoadPackage(session, sessionResult, packageFilePath, false, packagesLoaded, loadParameters);
// Output the session only if there is no cancellation
if (cancelToken.HasValue && cancelToken.Value.IsCancellationRequested)
{
return;
}
}
// Load all missing references/dependencies
session.LoadMissingReferences(sessionResult, loadParameters);
// Fix relative references
var analysis = new PackageSessionAnalysis(session, GetPackageAnalysisParametersForLoad());
var analysisResults = analysis.Run();
analysisResults.CopyTo(sessionResult);
// Run custom package session analysis
foreach (var type in AssetRegistry.GetPackageSessionAnalysisTypes())
{
var pkgAnalysis = (PackageSessionAnalysisBase)Activator.CreateInstance(type);
pkgAnalysis.Session = session;
var results = pkgAnalysis.Run();
results.CopyTo(sessionResult);
}
// Output the session only if there is no cancellation
if (!cancelToken.HasValue || !cancelToken.Value.IsCancellationRequested)
{
sessionResult.Session = session;
// Defer the initialization of the dependency manager
//session.DependencyManager.InitializeDeferred();
}
// Setup the current package when loading it
if (packagePaths.Count == 1)
{
var currentPackagePath = new UFile(packagePaths[0]);
foreach (var package in packagesLoaded)
{
if (package.FullPath == currentPackagePath)
{
session.CurrentPackage = package;
break;
}
}
}
// The session is not dirty when loading it
session.IsDirty = false;
}
}
finally
{
// Disable reference analysis caching after loading
AssetReferenceAnalysis.EnableCaching = false;
}
}