protected override void Compile(AssetCompilerContext context, AssetItem assetItem, string targetUrlInStorage, AssetCompilerResult result) { var asset = (SkeletonAsset)assetItem.Asset; var assetSource = GetAbsolutePath(assetItem, asset.Source); var extension = assetSource.GetFileExtension(); var buildStep = new AssetBuildStep(assetItem); var importModelCommand = ImportModelCommand.Create(extension); if (importModelCommand == null) { result.Error("No importer found for model extension '{0}. The model '{1}' can't be imported.", extension, assetSource); return; } importModelCommand.SourcePath = assetSource; importModelCommand.Location = targetUrlInStorage; importModelCommand.Mode = ImportModelCommand.ExportMode.Skeleton; importModelCommand.ScaleImport = asset.ScaleImport; importModelCommand.PivotPosition = asset.PivotPosition; importModelCommand.SkeletonNodesWithPreserveInfo = asset.NodesWithPreserveInfo; buildStep.Add(importModelCommand); result.BuildSteps = buildStep; }
/// <summary> /// Ensures that the sources of an <see cref="Asset"/> exist. /// </summary> /// <param name="result">The <see cref="AssetCompilerResult"/> in which to output log of potential errors.</param> /// <param name="assetItem">The asset to check.</param> /// <returns><c>true</c> if the source file exists, <c>false</c> otherwise.</returns> /// <exception cref="ArgumentNullException">Any of the argument is <c>null</c>.</exception> private static bool EnsureSourcesExist(AssetCompilerResult result, AssetItem assetItem) { if (result == null) throw new ArgumentNullException(nameof(result)); if (assetItem == null) throw new ArgumentNullException(nameof(assetItem)); var collector = new SourceFilesCollector(); var sourceMembers = collector.GetSourceMembers(assetItem.Asset); foreach (var member in sourceMembers) { if (string.IsNullOrEmpty(member.Value)) { result.Error($"Source is null for Asset [{assetItem}] in property [{member.Key}]"); return false; } // Get absolute path of asset source on disk var assetDirectory = assetItem.FullPath.GetParent(); var assetSource = UPath.Combine(assetDirectory, member.Value); // Ensure the file exists if (!File.Exists(assetSource)) { result.Error($"Unable to find the source file '{assetSource}' for Asset [{assetItem}]"); return false; } } return true; }
/// <summary> /// Ensures that the source of an <see cref="AssetImport"/> exists. If the given asset is not an <see cref="AssetImport"/>, this method simply returns <c>true</c>. /// </summary> /// <param name="result">The <see cref="AssetCompilerResult"/> in which to output log of potential errors.</param> /// <param name="assetImport">The asset to check.</param> /// <param name="assetAbsolutePath">The absolute path of the asset on the disk</param> /// <returns><c>true</c> if the source file exists, <c>false</c> otherwise.</returns> /// <exception cref="ArgumentNullException">Any of the argument is <c>null</c>.</exception> protected static bool EnsureSourceExists(AssetCompilerResult result, T assetImport, UFile assetAbsolutePath) { if (result == null) { throw new ArgumentNullException("result"); } if (assetImport == null) { throw new ArgumentNullException("assetImport"); } if (assetAbsolutePath == null) { throw new ArgumentNullException("assetAbsolutePath"); } var asset = assetImport as AssetImport; // The asset has no source, so there is no failure if (asset == null) { return(true); } if (string.IsNullOrEmpty(asset.Source)) { result.Error("Source is null for Asset [{0}]", asset); return(false); } // Get absolute path of asset source on disk var assetDirectory = assetAbsolutePath.GetParent(); var assetSource = UPath.Combine(assetDirectory, asset.Source); // Ensure the file exists if (!File.Exists(assetSource)) { result.Error("Unable to find the source file '{1}' for Asset [{0}]", asset, assetSource); return(false); } return(true); }
/// <summary> /// Ensures that the sources of an <see cref="Asset"/> exist. /// </summary> /// <param name="result">The <see cref="AssetCompilerResult"/> in which to output log of potential errors.</param> /// <param name="asset">The asset to check.</param> /// <param name="assetAbsolutePath">The absolute path of the asset on the disk</param> /// <returns><c>true</c> if the source file exists, <c>false</c> otherwise.</returns> /// <exception cref="ArgumentNullException">Any of the argument is <c>null</c>.</exception> protected static bool EnsureSourcesExist(AssetCompilerResult result, T asset, UFile assetAbsolutePath) { if (result == null) { throw new ArgumentNullException(nameof(result)); } if (asset == null) { throw new ArgumentNullException(nameof(asset)); } if (assetAbsolutePath == null) { throw new ArgumentNullException(nameof(assetAbsolutePath)); } var collector = new SourceFilesCollector(); var sourceMembers = collector.GetSourceMembers(asset); foreach (var member in sourceMembers) { if (string.IsNullOrEmpty(member.Value)) { result.Error($"Source is null for Asset [{asset}] in property [{member.Key}]"); return(false); } // Get absolute path of asset source on disk var assetDirectory = assetAbsolutePath.GetParent(); var assetSource = UPath.Combine(assetDirectory, member.Value); // Ensure the file exists if (!File.Exists(assetSource)) { result.Error($"Unable to find the source file '{assetSource}' for Asset [{asset}]"); return(false); } } return(true); }
protected override void Compile(AssetCompilerContext context, AssetItem assetItem, string targetUrlInStorage, AssetCompilerResult result) { var asset = (ModelAsset)assetItem.Asset; // Get absolute path of asset source on disk var assetDirectory = assetItem.FullPath.GetParent(); var assetSource = UPath.Combine(assetDirectory, asset.Source); var gameSettingsAsset = context.GetGameSettingsAsset(); var renderingSettings = gameSettingsAsset.Get<RenderingSettings>(); var allow32BitIndex = renderingSettings.DefaultGraphicsProfile >= GraphicsProfile.Level_9_2; var allowUnsignedBlendIndices = context.GetGraphicsPlatform(assetItem.Package) != GraphicsPlatform.OpenGLES; var extension = asset.Source.GetFileExtension(); // Find skeleton asset, if any AssetItem skeleton = null; if (asset.Skeleton != null) skeleton = assetItem.Package.FindAssetFromAttachedReference(asset.Skeleton); var importModelCommand = ImportModelCommand.Create(extension); if (importModelCommand == null) { result.Error("No importer found for model extension '{0}. The model '{1}' can't be imported.", extension, assetSource); return; } importModelCommand.Mode = ImportModelCommand.ExportMode.Model; importModelCommand.SourcePath = assetSource; importModelCommand.Location = targetUrlInStorage; importModelCommand.Allow32BitIndex = allow32BitIndex; importModelCommand.AllowUnsignedBlendIndices = allowUnsignedBlendIndices; importModelCommand.Materials = asset.Materials; importModelCommand.ScaleImport = asset.ScaleImport; importModelCommand.PivotPosition = asset.PivotPosition; importModelCommand.SkeletonUrl = skeleton?.Location; result.BuildSteps = new AssetBuildStep(assetItem) { importModelCommand }; }
/// <summary> /// Compile the current package and all child package recursively by generating a list of build steps /// </summary> private void RecursiveCompile(AssetCompilerResult result, AssetCompilerContext context, HashSet <Package> processed) { if (result == null) { throw new ArgumentNullException("result"); } if (context == null) { throw new ArgumentNullException("context"); } if (context.Package == null) { throw new ArgumentException("context.Package cannot be null", "context"); } if (processed.Contains(context.Package)) { return; } processed.Add(context.Package); var package = context.Package; var session = package.Session; // 1. first recursively process all store packages foreach (var packageDependency in package.Meta.Dependencies) { var subPackage = session.Packages.Find(packageDependency); if (subPackage != null) { // Work on an immutable copy for the whole set of assets to compile var contextCopy = (AssetCompilerContext)context.Clone(); contextCopy.Package = subPackage; RecursiveCompile(result, contextCopy, processed); } else { result.Error("Unable to find package [{0}]", packageDependency); } } // 2. recursively process all local packages foreach (var subPackageReference in package.LocalDependencies) { var subPackage = session.Packages.Find(subPackageReference.Id); if (subPackage != null) { // Work on an immutable copy for the whole set of assets to compile var contextCopy = (AssetCompilerContext)context.Clone(); contextCopy.Package = subPackage; RecursiveCompile(result, contextCopy, processed); } else { result.Error("Unable to find package [{0}]", subPackageReference); } } result.Info("Compiling package [{0}]", package.FullPath); // Compile using all PackageCompiler foreach (var compiler in compilers) { var compilerResult = compiler.Compile(context); compilerResult.CopyTo(result); while (compilerResult.BuildSteps.Count > 0) { var step = compilerResult.BuildSteps[0]; compilerResult.BuildSteps.RemoveAt(0); result.BuildSteps.Add(step); } } }
/// <summary> /// Compile the required build step necessary to produce the desired output item. /// </summary> /// <param name="context">The context.</param> /// <param name="compilationResult">The compilation result.</param> /// <param name="assetItem">The asset item.</param> protected ListBuildStep CompileItem(CompilerContext context, AssetCompilerResult compilationResult, AssetItem assetItem) { // First try to find an asset compiler for this particular asset. IAssetCompiler compiler; try { compiler = compilerRegistry.GetCompiler(assetItem.Asset.GetType()); } catch (Exception ex) { compilationResult.Error("Cannot find a compiler for asset [{0}] from path [{1}]", ex, assetItem.Id, assetItem.Location); return null; } if (compiler == null) { return null; } // Second we are compiling the asset (generating a build step) try { var resultPerAssetType = compiler.Compile(context, assetItem); // Raise the AssetCompiled event. var handler = AssetCompiled; if (handler != null) handler(this, new AssetCompiledArgs(assetItem, resultPerAssetType)); // TODO: See if this can be unified with PackageBuilder.BuildStepProcessed foreach (var message in resultPerAssetType.Messages) { var assetMessage = new AssetLogMessage(null, assetItem.ToReference(), message.Type, AssetMessageCode.CompilationMessage, assetItem.Location, message.Text) { Exception = message is LogMessage ? ((LogMessage)message).Exception : null }; // Forward log messages to compilationResult compilationResult.Log(assetMessage); // Forward log messages to build step logger resultPerAssetType.BuildSteps.Logger.Log(assetMessage); } // Make the build step fail if there was an error during compiling (only when we are compiling the build steps of an asset) if (resultPerAssetType.BuildSteps is AssetBuildStep && resultPerAssetType.BuildSteps.Logger.HasErrors) resultPerAssetType.BuildSteps.Add(new CommandBuildStep(new FailedCommand(assetItem.Location))); // Build the module string var assetAbsolutePath = assetItem.FullPath; assetAbsolutePath = Path.GetFullPath(assetAbsolutePath); var module = string.Format("{0}(1,1)", assetAbsolutePath); // Assign module string to all command build steps SetModule(resultPerAssetType.BuildSteps, module); // Add a wait command to the build steps if required by the item build if (resultPerAssetType.ShouldWaitForPreviousBuilds) compilationResult.BuildSteps.Add(new WaitBuildStep()); foreach (var buildStep in resultPerAssetType.BuildSteps) { buildStep.Priority = latestPriority++; } // Add the item result build steps the item list result build steps return resultPerAssetType.BuildSteps; } catch (Exception ex) { compilationResult.Error("Unexpected exception while compiling asset [{0}] from path [{1}]", ex, assetItem.Id, assetItem.Location); return null; } }
/// <summary> /// Compile the current package and all child package recursively by generating a list of build steps /// </summary> private void RecursiveCompile(AssetCompilerResult result, AssetCompilerContext context, HashSet<Package> processed) { if (result == null) throw new ArgumentNullException("result"); if (context == null) throw new ArgumentNullException("context"); if (context.Package == null) throw new ArgumentException("context.Package cannot be null", "context"); if (processed.Contains(context.Package)) { return; } processed.Add(context.Package); var package = context.Package; var session = package.Session; // 1. first recursively process all store packages foreach (var packageDependency in package.Meta.Dependencies) { var subPackage = session.Packages.Find(packageDependency); if (subPackage != null) { // Work on an immutable copy for the whole set of assets to compile var contextCopy = (AssetCompilerContext)context.Clone(); contextCopy.Package = subPackage; RecursiveCompile(result, contextCopy, processed); } else { result.Error("Unable to find package [{0}]", packageDependency); } } // 2. recursively process all local packages foreach (var subPackageReference in package.LocalDependencies) { var subPackage = session.Packages.Find(subPackageReference.Id); if (subPackage != null) { // Work on an immutable copy for the whole set of assets to compile var contextCopy = (AssetCompilerContext)context.Clone(); contextCopy.Package = subPackage; RecursiveCompile(result, contextCopy, processed); } else { result.Error("Unable to find package [{0}]", subPackageReference); } } result.Info("Compiling package [{0}]", package.FullPath); // Compile using all PackageCompiler foreach (var compiler in compilers) { var compilerResult = compiler.Compile(context); compilerResult.CopyTo(result); while (compilerResult.BuildSteps.Count > 0) { var step = compilerResult.BuildSteps[0]; compilerResult.BuildSteps.RemoveAt(0); result.BuildSteps.Add(step); } } }
/// <summary> /// Compile the required build step necessary to produce the desired output item. /// </summary> /// <param name="context">The context.</param> /// <param name="compilationResult">The compilation result.</param> /// <param name="assetItem">The asset item.</param> protected ListBuildStep CompileItem(CompilerContext context, AssetCompilerResult compilationResult, AssetItem assetItem) { // First try to find an asset compiler for this particular asset. IAssetCompiler compiler; try { compiler = compilerRegistry.GetCompiler(assetItem.Asset.GetType()); } catch (Exception ex) { compilationResult.Error("Cannot find a compiler for asset [{0}] from path [{1}]", ex, assetItem.Id, assetItem.Location); return(null); } if (compiler == null) { return(null); } // Second we are compiling the asset (generating a build step) try { var resultPerAssetType = compiler.Compile(context, assetItem); // Raise the AssetCompiled event. var handler = AssetCompiled; if (handler != null) { handler(this, new AssetCompiledArgs(assetItem, resultPerAssetType)); } // TODO: See if this can be unified with PackageBuilder.BuildStepProcessed foreach (var message in resultPerAssetType.Messages) { var assetMessage = new AssetLogMessage(null, assetItem.ToReference(), message.Type, AssetMessageCode.CompilationMessage, assetItem.Location, message.Text) { Exception = message is LogMessage ? ((LogMessage)message).Exception : null }; // Forward log messages to compilationResult compilationResult.Log(assetMessage); // Forward log messages to build step logger resultPerAssetType.BuildSteps.Logger.Log(assetMessage); } // Make the build step fail if there was an error during compiling (only when we are compiling the build steps of an asset) if (resultPerAssetType.BuildSteps is AssetBuildStep && resultPerAssetType.BuildSteps.Logger.HasErrors) { resultPerAssetType.BuildSteps.Add(new CommandBuildStep(new FailedCommand(assetItem.Location))); } // Build the module string var assetAbsolutePath = assetItem.FullPath; assetAbsolutePath = Path.GetFullPath(assetAbsolutePath); var module = string.Format("{0}(1,1)", assetAbsolutePath); // Assign module string to all command build steps SetModule(resultPerAssetType.BuildSteps, module); // Add a wait command to the build steps if required by the item build if (resultPerAssetType.ShouldWaitForPreviousBuilds) { compilationResult.BuildSteps.Add(new WaitBuildStep()); } foreach (var buildStep in resultPerAssetType.BuildSteps) { buildStep.Priority = latestPriority++; } // Add the item result build steps the item list result build steps return(resultPerAssetType.BuildSteps); } catch (Exception ex) { compilationResult.Error("Unexpected exception while compiling asset [{0}] from path [{1}]", ex, assetItem.Id, assetItem.Location); return(null); } }
private void Prepare(AssetCompilerResult finalResult, AssetCompilerContext context, AssetItem assetItem, [NotNull] Type compilationContext, HashSet <BuildAssetNode> visitedItems, Dictionary <AssetId, BuildStep> compiledItems, BuildStep parentBuildStep = null, BuildDependencyType dependencyType = BuildDependencyType.Runtime) { if (compilationContext == null) { throw new ArgumentNullException(nameof(compilationContext)); } var assetNode = BuildDependencyManager.FindOrCreateNode(assetItem, compilationContext); compiledItems.TryGetValue(assetNode.AssetItem.Id, out var assetBuildSteps); // Prevent re-entrancy in the same node if (visitedItems.Add(assetNode)) { assetNode.Analyze(context); // Invoke the compiler to prepare the build step for this asset if the dependency needs to compile it (Runtime or CompileContent) if ((dependencyType & ~BuildDependencyType.CompileAsset) != 0 && assetBuildSteps == null) { var mainCompiler = BuildDependencyManager.AssetCompilerRegistry.GetCompiler(assetItem.Asset.GetType(), assetNode.CompilationContext); if (mainCompiler == null) { return; } var compilerResult = mainCompiler.Prepare(context, assetItem); if ((dependencyType & BuildDependencyType.Runtime) == BuildDependencyType.Runtime && compilerResult.HasErrors) //allow Runtime dependencies to fail { //totally skip this asset but do not propagate errors! return; } assetBuildSteps = compilerResult.BuildSteps; compiledItems.Add(assetNode.AssetItem.Id, assetBuildSteps); // Copy the log to the final result (note: this does not copy or forward the build steps) compilerResult.CopyTo(finalResult); if (compilerResult.HasErrors) { finalResult.Error($"Failed to prepare asset {assetItem.Location}"); return; } // Add the resulting build steps to the final finalResult.BuildSteps.Add(assetBuildSteps); AssetCompiled?.Invoke(this, new AssetCompiledArgs(assetItem, compilerResult)); } // Go through the dependencies of the node and prepare them as well foreach (var reference in assetNode.References) { var target = reference.Target; Prepare(finalResult, context, target.AssetItem, target.CompilationContext, visitedItems, compiledItems, assetBuildSteps, reference.DependencyType); if (finalResult.HasErrors) { return; } } // If we didn't prepare any build step for this asset let's exit here. if (assetBuildSteps == null) { return; } } // Link the created build steps to their parent step. if (parentBuildStep != null && assetBuildSteps != null && (dependencyType & BuildDependencyType.CompileContent) == BuildDependencyType.CompileContent) //only if content is required Content.Load { BuildStep.LinkBuildSteps(assetBuildSteps, parentBuildStep); } }
/// <summary> /// Compile the current package and all child package recursively by generating a list of build steps /// </summary> private void RecursiveCompile(AssetCompilerResult result, AssetCompilerContext context, HashSet <Package> processed) { if (result == null) { throw new ArgumentNullException("result"); } if (context == null) { throw new ArgumentNullException("context"); } if (context.Package == null) { throw new ArgumentException("context.Package cannot be null", "context"); } if (processed.Contains(context.Package)) { return; } processed.Add(context.Package); var package = context.Package; GenerateRawImportBuildSteps(context, result); // 1. first recursively process all store packages foreach (var packageDependency in package.Meta.Dependencies) { var subPackage = session.Packages.Find(packageDependency); if (subPackage != null) { // Work on an immutable copy for the whole set of assets to compile var contextCopy = (AssetCompilerContext)context.Clone(); contextCopy.Package = subPackage; RecursiveCompile(result, contextCopy, processed); } else { result.Error("Unable to find package [{0}]", packageDependency); } } // 2. recursively process all local packages foreach (var subPackageReference in package.LocalDependencies) { var subPackage = session.Packages.Find(subPackageReference.Id); if (subPackage != null) { // Work on an immutable copy for the whole set of assets to compile var contextCopy = (AssetCompilerContext)context.Clone(); contextCopy.Package = subPackage; RecursiveCompile(result, contextCopy, processed); } else { result.Error("Unable to find package [{0}]", subPackageReference); } } result.Info("Compiling package [{0}]", package.FullPath); // Sort the items to build by build order var assets = package.Assets.ToList(); assets.Sort((item1, item2) => item1.Asset != null && item2.Asset != null ? item1.Asset.BuildOrder.CompareTo(item2.Asset.BuildOrder) : 0); // generate the build steps required to build the assets via base class Compile(context, assets, result); }
protected sealed override AssetCompilerResult CompileOverride(AssetCompilerContext context, AssetCompilerResult compilerResult) { var thumbnailCompilerContext = (ThumbnailCompilerContext)context; // Build the path of the thumbnail in the storage var assetStorageUrl = AssetItem.Location.GetDirectoryAndFileName(); var thumbnailStorageUrl = assetStorageUrl.Insert(0, "__THUMBNAIL__"); // Check if this asset produced any error // (dependent assets errors are generally ignored as long as thumbnail could be generated, // but we will add a thumbnail overlay to indicate the state is not good) var currentAssetHasErrors = false; try { // TODO: fix failures here (see TODOs in Compile and base.Compile) AssetsSession = AssetItem.Package.Session; // Only use the path to the asset without its extension Compile(thumbnailCompilerContext, thumbnailStorageUrl, AssetItem.FullPath, compilerResult); } catch (Exception) { // If an exception occurs, ensure that the build of thumbnail will fail. compilerResult.Error(string.Format("An exception occurred while compiling the asset [{0}]", AssetItem.Location)); } foreach (var logMessage in compilerResult.Messages) { // Ignore anything less than error if (!logMessage.IsAtLeast(LogMessageType.Error)) { continue; } // Check if there is any non-asset log message // (they are probably just emitted by current compiler, so they concern current asset) // TODO: Maybe we should wrap every message in AssetLogMessage before copying them in compilerResult? var assetLogMessage = logMessage as AssetLogMessage; if (assetLogMessage == null) { currentAssetHasErrors = true; break; } // If it was an asset log message, check it concerns current asset if (assetLogMessage.AssetReference != null && assetLogMessage.AssetReference.Location == AssetItem.Location) { currentAssetHasErrors = true; break; } } if (currentAssetHasErrors) { // if a problem occurs while compiling, we add a special build step that will always fail. compilerResult.BuildSteps.Add(new ThumbnailFailureBuildStep(compilerResult.Messages)); } var currentAsset = AssetItem; // copy the current asset item and embrace it in the callback compilerResult.BuildSteps.StepProcessed += (_, buildStepArgs) => OnThumbnailStepProcessed(thumbnailCompilerContext, currentAsset, thumbnailStorageUrl, buildStepArgs); return(compilerResult); }
/// <summary> /// Generate the build step corresponding to raw imports of the current package file. /// </summary> /// <param name="context">The compilation context</param> /// <param name="result">The compilation current result</param> private void GenerateRawImportBuildSteps(AssetCompilerContext context, AssetCompilerResult result) { if (context.Package.RootDirectory == null) { return; } foreach (var profile in context.Package.Profiles) { foreach (var sourceFolder in profile.AssetFolders) { var baseDirectory = Path.GetFullPath(context.Package.RootDirectory); // Use sub directory baseDirectory = Path.Combine(baseDirectory, sourceFolder.Path); if (!Directory.Exists(baseDirectory)) { continue; } var baseUDirectory = new UDirectory(baseDirectory); var hashSet = new HashSet <string>(); // Imports explicit foreach (var rawImport in sourceFolder.RawImports) { var sourceDirectory = baseUDirectory; if (!string.IsNullOrEmpty(rawImport.SourceDirectory)) { sourceDirectory = UPath.Combine(sourceDirectory, rawImport.SourceDirectory); } if (!Directory.Exists(sourceDirectory)) { result.Error("Unable to find raw import directory [{0}]", sourceDirectory); continue; } var files = Directory.EnumerateFiles(sourceDirectory, "*.*", SearchOption.AllDirectories).ToList(); var importRegexes = rawImport.Patterns.Select(x => new Regex(Selectors.PathSelector.TransformToRegex(x))).ToArray(); foreach (var file in files) { var pathToFileRelativeToProject = new UFile(file).MakeRelative(sourceDirectory); var outputPath = pathToFileRelativeToProject; if (!string.IsNullOrEmpty(rawImport.TargetLocation)) { outputPath = UPath.Combine(rawImport.TargetLocation, outputPath); } foreach (var importRegex in importRegexes) { if (importRegex.Match(pathToFileRelativeToProject).Success&& hashSet.Add(outputPath)) { result.BuildSteps.Add(new ImportStreamCommand { SourcePath = file, Location = outputPath, }); break; } } } } } } }
/// <summary> /// Generate the build step corresponding to raw imports of the current package file. /// </summary> /// <param name="context">The compilation context</param> /// <param name="result">The compilation current result</param> private void GenerateRawImportBuildSteps(AssetCompilerContext context, AssetCompilerResult result) { if (context.Package.RootDirectory == null) return; foreach (var profile in context.Package.Profiles) { foreach (var sourceFolder in profile.AssetFolders) { var baseDirectory = Path.GetFullPath(context.Package.RootDirectory); // Use sub directory baseDirectory = Path.Combine(baseDirectory, sourceFolder.Path); if (!Directory.Exists(baseDirectory)) { continue; } var baseUDirectory = new UDirectory(baseDirectory); var hashSet = new HashSet<string>(); // Imports explicit foreach (var rawImport in sourceFolder.RawImports) { var sourceDirectory = baseUDirectory; if (!string.IsNullOrEmpty(rawImport.SourceDirectory)) sourceDirectory = UPath.Combine(sourceDirectory, rawImport.SourceDirectory); if (!Directory.Exists(sourceDirectory)) { result.Error("Unable to find raw import directory [{0}]", sourceDirectory); continue; } var files = Directory.EnumerateFiles(sourceDirectory, "*.*", SearchOption.AllDirectories).ToList(); var importRegexes = rawImport.Patterns.Select(x => new Regex(Selectors.PathSelector.TransformToRegex(x))).ToArray(); foreach (var file in files) { var pathToFileRelativeToProject = new UFile(file).MakeRelative(sourceDirectory); var outputPath = pathToFileRelativeToProject; if (!string.IsNullOrEmpty(rawImport.TargetLocation)) outputPath = UPath.Combine(rawImport.TargetLocation, outputPath); foreach (var importRegex in importRegexes) { if (importRegex.Match(pathToFileRelativeToProject).Success && hashSet.Add(outputPath)) { result.BuildSteps.Add(new ImportStreamCommand { SourcePath = file, Location = outputPath, }); break; } } } } } } }
/// <summary> /// Compile the required build step necessary to produce the desired output item. /// </summary> /// <param name="context">The context.</param> /// <param name="compilationResult">The compilation result.</param> /// <param name="assetItem">The asset item.</param> protected BuildStep CompileItem(CompilerContext context, AssetCompilerResult compilationResult, AssetItem assetItem) { // First try to find an asset compiler for this particular asset. IAssetCompiler compiler; try { compiler = compilerRegistry.GetCompiler(assetItem.Asset.GetType()); } catch (Exception ex) { compilationResult.Error("Cannot find a compiler for asset [{0}] from path [{1}]", ex, assetItem.Id, assetItem.Location); return(null); } if (compiler == null) { return(null); } // Second we are compiling the asset (generating a build step) try { var resultPerAssetType = compiler.Compile(context, assetItem); // Raise the AssetCompiled event. var handler = AssetCompiled; if (handler != null) { handler(this, new AssetCompiledArgs(assetItem, resultPerAssetType)); } resultPerAssetType.CopyTo(compilationResult); if (resultPerAssetType.BuildSteps == null) { return(null); } // Build the module string var assetAbsolutePath = assetItem.FullPath; assetAbsolutePath = Path.GetFullPath(assetAbsolutePath); var module = string.Format("{0}(1,1)", assetAbsolutePath); // Assign module string to all command build steps SetModule(resultPerAssetType.BuildSteps, module); // Add a wait command to the build steps if required by the item build if (resultPerAssetType.ShouldWaitForPreviousBuilds) { compilationResult.BuildSteps.Add(new WaitBuildStep()); } foreach (var buildStep in resultPerAssetType.BuildSteps) { buildStep.Priority = latestPriority++; } // Add the item result build steps the item list result build steps return(resultPerAssetType.BuildSteps); } catch (Exception ex) { compilationResult.Error("Unexpected exception while compiling asset [{0}] from path [{1}]", ex, assetItem.Id, assetItem.Location); return(null); } }
/// <summary> /// Compile the required build step necessary to produce the desired output item. /// </summary> /// <param name="context">The context.</param> /// <param name="compilationResult">The compilation result.</param> /// <param name="assetItem">The asset item.</param> protected ListBuildStep CompileItem(CompilerContext context, AssetCompilerResult compilationResult, AssetItem assetItem) { // First try to find an asset compiler for this particular asset. IAssetCompiler compiler; try { compiler = compilerRegistry.GetCompiler(assetItem.Asset.GetType()); } catch (Exception ex) { compilationResult.Error("Cannot find a compiler for asset [{0}] from path [{1}]", ex, assetItem.Id, assetItem.Location); return null; } if (compiler == null) { return null; } // Second we are compiling the asset (generating a build step) try { var resultPerAssetType = compiler.Compile(context, assetItem); // Raise the AssetCompiled event. AssetCompiled?.Invoke(this, new AssetCompiledArgs(assetItem, resultPerAssetType)); // TODO: See if this can be unified with PackageBuilder.BuildStepProcessed var assetFullPath = assetItem.FullPath.ToWindowsPath(); foreach (var message in resultPerAssetType.Messages) { var assetMessage = AssetLogMessage.From(null, assetItem.ToReference(), message, assetFullPath); // Forward log messages to compilationResult compilationResult.Log(assetMessage); // Forward log messages to build step logger resultPerAssetType.BuildSteps.Logger.Log(assetMessage); } // Make the build step fail if there was an error during compiling (only when we are compiling the build steps of an asset) if (resultPerAssetType.BuildSteps is AssetBuildStep && resultPerAssetType.BuildSteps.Logger.HasErrors) resultPerAssetType.BuildSteps.Add(new CommandBuildStep(new FailedCommand(assetItem.Location))); // TODO: Big review of the log infrastructure of CompilerApp & BuildEngine! // Assign module string to all command build steps SetAssetLogger(resultPerAssetType.BuildSteps, assetItem.Package, assetItem.ToReference(), assetItem.FullPath.ToWindowsPath()); // Add a wait command to the build steps if required by the item build if (resultPerAssetType.ShouldWaitForPreviousBuilds) compilationResult.BuildSteps.Add(new WaitBuildStep()); foreach (var buildStep in resultPerAssetType.BuildSteps) { buildStep.Priority = latestPriority++; } // Add the item result build steps the item list result build steps return resultPerAssetType.BuildSteps; } catch (Exception ex) { compilationResult.Error("Unexpected exception while compiling asset [{0}] from path [{1}]", ex, assetItem.Id, assetItem.Location); return null; } }
/// <summary> /// Compile the required build step necessary to produce the desired output item. /// </summary> /// <param name="context">The context.</param> /// <param name="compilationResult">The compilation result.</param> /// <param name="assetItem">The asset item.</param> protected ListBuildStep CompileItem(CompilerContext context, AssetCompilerResult compilationResult, AssetItem assetItem) { // First try to find an asset compiler for this particular asset. IAssetCompiler compiler; try { compiler = compilerRegistry.GetCompiler(assetItem.Asset.GetType()); } catch (Exception ex) { compilationResult.Error($"Cannot find a compiler for asset [{assetItem.Id}] from path [{assetItem.Location}]", ex); return(null); } if (compiler == null) { return(null); } // Second we are compiling the asset (generating a build step) try { var resultPerAssetType = compiler.Compile(context, assetItem); // Raise the AssetCompiled event. AssetCompiled?.Invoke(this, new AssetCompiledArgs(assetItem, resultPerAssetType)); // TODO: See if this can be unified with PackageBuilder.BuildStepProcessed var assetFullPath = assetItem.FullPath.ToWindowsPath(); foreach (var message in resultPerAssetType.Messages) { var assetMessage = AssetLogMessage.From(null, assetItem.ToReference(), message, assetFullPath); // Forward log messages to compilationResult compilationResult.Log(assetMessage); // Forward log messages to build step logger resultPerAssetType.BuildSteps.Logger.Log(assetMessage); } // Make the build step fail if there was an error during compiling (only when we are compiling the build steps of an asset) if (resultPerAssetType.BuildSteps is AssetBuildStep && resultPerAssetType.BuildSteps.Logger.HasErrors) { resultPerAssetType.BuildSteps.Add(new CommandBuildStep(new FailedCommand(assetItem.Location))); } // TODO: Big review of the log infrastructure of CompilerApp & BuildEngine! // Assign module string to all command build steps SetAssetLogger(resultPerAssetType.BuildSteps, assetItem.Package, assetItem.ToReference(), assetItem.FullPath.ToWindowsPath()); // Add a wait command to the build steps if required by the item build if (resultPerAssetType.ShouldWaitForPreviousBuilds) { compilationResult.BuildSteps.Add(new WaitBuildStep()); } foreach (var buildStep in resultPerAssetType.BuildSteps) { buildStep.Priority = latestPriority++; } // Add the item result build steps the item list result build steps return(resultPerAssetType.BuildSteps); } catch (Exception ex) { compilationResult.Error($"Unexpected exception while compiling asset [{assetItem.Id}] from path [{assetItem.Location}]", ex); return(null); } }