public void Build(out int successCount, out int errorCount) { var projectDirectory = Directory.GetCurrentDirectory(); var outputPath = Path.GetFullPath(Path.Combine(projectDirectory, OutputDir)); var intermediatePath = Path.GetFullPath(Path.Combine(projectDirectory, IntermediateDir)); _manager = new PipelineManager(projectDirectory, outputPath, intermediatePath); _manager.Logger = new ConsoleLogger(); // Feed all the assembly references to the pipeline manager // so it can resolve importers, processors, writers, and types. foreach (var r in References) { _manager.AddAssembly(r); } // Load the previously serialized list of built content. var contentFile = Path.Combine(intermediatePath, PipelineBuildEvent.Extension); var previousContent = SourceFileCollection.Read(contentFile); // If the target changed in any way then we need to force // a fuull rebuild even under incremental builds. var targetChanged = previousContent.Config != Config || previousContent.Platform != Platform || previousContent.Profile != Profile; // First clean previously built content. foreach (var sourceFile in previousContent.SourceFiles) { var inContent = _content.Any(e => string.Equals(e.SourceFile, sourceFile, StringComparison.InvariantCultureIgnoreCase)); var cleanOldContent = !inContent && !Incremental; var cleanRebuiltContent = inContent && (Rebuild || Clean); if (cleanRebuiltContent || cleanOldContent || targetChanged) { _manager.CleanContent(sourceFile); } } var newContent = new SourceFileCollection { Profile = _manager.Profile = Profile, Platform = _manager.Platform = Platform, Config = _manager.Config = Config }; errorCount = 0; successCount = 0; foreach (var c in _content) { try { _manager.BuildContent(c.SourceFile, null, c.Importer, c.Processor, c.ProcessorParams); newContent.SourceFiles.Add(c.SourceFile); ++successCount; } catch (PipelineException ex) { Console.Error.WriteLine("{0}: error: {1}", c.SourceFile, ex.Message); ++errorCount; } } // If this is an incremental build we merge the list // of previous content with the new list. if (Incremental && !targetChanged) { newContent.Merge(previousContent); } // Delete the old file and write the new content // list if we have any to serialize. FileHelper.DeleteIfExists(contentFile); if (newContent.SourceFiles.Count > 0) { newContent.Write(contentFile); } }
protected override BuildResult Compile(MonoDevelop.Core.IProgressMonitor monitor, SolutionEntityItem item, BuildData buildData) { #if DEBUG monitor.Log.WriteLine("MonoGame Extension Compile Called"); #endif try { var cfg = buildData.Configuration as MonoGameContentProjectConfiguration; var proj = item as MonoGameContentProject; if (proj == null || cfg == null) { monitor.Log.WriteLine("Compiling for Unknown MonoGame Project"); return(base.Compile(monitor, item, buildData)); } monitor.Log.WriteLine("Detected {0} MonoGame Platform", cfg.MonoGamePlatform); var result = new BuildResult(); var manager = new PipelineManager(proj.BaseDirectory.FullPath, Path.Combine(buildData.Configuration.OutputDirectory, cfg.MonoGamePlatform), buildData.Configuration.IntermediateOutputDirectory); manager.Logger = new MonitorBuilder(monitor, result); manager.Platform = (TargetPlatform)Enum.Parse(typeof(TargetPlatform), cfg.MonoGamePlatform); try { foreach (var pr in proj.ParentSolution.GetAllProjects()) { if (pr is DotNetAssemblyProject) { var dot = pr as DotNetAssemblyProject; foreach (var r in dot.References) { if (r.Package.Name == "monogame-contentpipeline") { var output = dot.GetOutputFileName(buildData.ConfigurationSelector).FullPath; monitor.Log.WriteLine("Adding {0} to Content Pipeline Assembly List", output); manager.AddAssembly(output); proj.Manager.AddAssembly(output); break; } } } } } catch (Exception ex) { result.AddWarning(string.Format("Problem processing Content Extensions {0}", ex.Message)); } var dict = new Microsoft.Xna.Framework.Content.Pipeline.OpaqueDataDictionary(); if (cfg != null) { if (cfg.XnaCompressContent.ToLowerInvariant() == "true") { // tell the manager to compress the output } } foreach (var file in proj.Files) { if (file.BuildAction == "Compile") { try { dict.Clear(); foreach (object key in file.ExtendedProperties.Keys) { string k = key as string; if (k != null && k.StartsWith("ProcessorParameters_")) { if (!dict.ContainsKey(k.Replace("ProcessorParameters_", String.Empty))) { dict.Add(k.Replace("ProcessorParameters_", String.Empty), file.ExtendedProperties[k]); } else { dict[k.Replace("ProcessorParameters_", String.Empty)] = file.ExtendedProperties[k]; } } } // check if the file has changed and rebuild if required. manager.BuildContent(file.FilePath.FullPath, null, file.ExtendedProperties.Contains("Importer") ? (string)file.ExtendedProperties["Importer"] : null, file.ExtendedProperties.Contains("Processor") ? (string)file.ExtendedProperties["Processor"] : null, dict); } catch (Exception ex) { monitor.Log.WriteLine(ex.ToString()); result.AddError(ex.Message); } } } return(result); } finally { #if DEBUG monitor.Log.WriteLine("MonoGame Extension Compile Ended"); #endif } }
public void Build(out int successCount, out int errorCount) { var projectDirectory = PathHelper.Normalize(Directory.GetCurrentDirectory()); var outputPath = ReplaceSymbols(OutputDir); if (!Path.IsPathRooted(outputPath)) { outputPath = PathHelper.Normalize(Path.GetFullPath(Path.Combine(projectDirectory, outputPath))); } var intermediatePath = ReplaceSymbols(IntermediateDir); if (!Path.IsPathRooted(intermediatePath)) { intermediatePath = PathHelper.Normalize(Path.GetFullPath(Path.Combine(projectDirectory, intermediatePath))); } _manager = new PipelineManager(projectDirectory, outputPath, intermediatePath); _manager.Logger = new ConsoleLogger(); _manager.CompressContent = CompressContent; // If the intent is to debug build, break at the original location // of any exception, eg, within the actual importer/processor. if (LaunchDebugger) { _manager.RethrowExceptions = false; } // Feed all the assembly references to the pipeline manager // so it can resolve importers, processors, writers, and types. foreach (var r in References) { var assembly = r; if (!Path.IsPathRooted(assembly)) { assembly = Path.GetFullPath(Path.Combine(projectDirectory, assembly)); } _manager.AddAssembly(assembly); } // Load the previously serialized list of built content. var contentFile = Path.Combine(intermediatePath, PipelineBuildEvent.Extension); var previousContent = SourceFileCollection.Read(contentFile); // If the target changed in any way then we need to force // a fuull rebuild even under incremental builds. var targetChanged = previousContent.Config != Config || previousContent.Platform != Platform || previousContent.Profile != Profile; // First clean previously built content. foreach (var sourceFile in previousContent.SourceFiles) { var inContent = _content.Any(e => string.Equals(e.SourceFile, sourceFile, StringComparison.InvariantCultureIgnoreCase)); var cleanOldContent = !inContent && !Incremental; var cleanRebuiltContent = inContent && (Rebuild || Clean); if (cleanRebuiltContent || cleanOldContent || targetChanged) { _manager.CleanContent(sourceFile); } } var newContent = new SourceFileCollection { Profile = _manager.Profile = Profile, Platform = _manager.Platform = Platform, Config = _manager.Config = Config }; errorCount = 0; successCount = 0; // Before building the content, register all files to be built. (Necessary to // correctly resolve external references.) foreach (var c in _content) { try { _manager.RegisterContent(c.SourceFile, null, c.Importer, c.Processor, c.ProcessorParams); } catch { // Ignore exception. Exception will be handled below. } } foreach (var c in _content) { try { _manager.BuildContent(c.SourceFile, null, c.Importer, c.Processor, c.ProcessorParams); newContent.SourceFiles.Add(c.SourceFile); ++successCount; } catch (InvalidContentException ex) { var message = string.Empty; if (ex.ContentIdentity != null && !string.IsNullOrEmpty(ex.ContentIdentity.SourceFilename)) { message = ex.ContentIdentity.SourceFilename; if (!string.IsNullOrEmpty(ex.ContentIdentity.FragmentIdentifier)) { message += "(" + ex.ContentIdentity.FragmentIdentifier + ")"; } message += ": "; } message += ex.Message; Console.WriteLine(message); ++errorCount; } catch (PipelineException ex) { Console.Error.WriteLine("{0}: error: {1}", c.SourceFile, ex.Message); if (ex.InnerException != null) { Console.Error.WriteLine(ex.InnerException.ToString()); } ++errorCount; } catch (Exception ex) { Console.Error.WriteLine("{0}: error: {1}", c.SourceFile, ex.Message); if (ex.InnerException != null) { Console.Error.WriteLine(ex.InnerException.ToString()); } ++errorCount; } } // If this is an incremental build we merge the list // of previous content with the new list. if (Incremental && !targetChanged) { newContent.Merge(previousContent); } // Delete the old file and write the new content // list if we have any to serialize. FileHelper.DeleteIfExists(contentFile); if (newContent.SourceFiles.Count > 0) { newContent.Write(contentFile); } // Process copy items (files that bypass the content pipeline) foreach (var c in _copyItems) { try { // Figure out an asset name relative to the project directory, // retaining the file extension. // Note that replacing a sub-path like this requires consistent // directory separator characters. var relativeName = c.Replace(projectDirectory, string.Empty) .TrimStart(Path.DirectorySeparatorChar) .TrimStart(Path.AltDirectorySeparatorChar); var dest = Path.Combine(outputPath, relativeName); // Only copy if the source file is newer than the destination. // We may want to provide an option for overriding this, but for // nearly all cases this is the desired behavior. if (File.Exists(dest)) { var srcTime = File.GetLastWriteTimeUtc(c); var dstTime = File.GetLastWriteTimeUtc(dest); if (srcTime <= dstTime) { Console.WriteLine("Skipping {0}", c); continue; } } // Create the destination directory if it doesn't already exist. var destPath = Path.GetDirectoryName(dest); if (!Directory.Exists(destPath)) { Directory.CreateDirectory(destPath); } File.Copy(c, dest, true); // Destination file should not be read-only even if original was. var fileAttr = File.GetAttributes(dest); fileAttr = fileAttr & (~FileAttributes.ReadOnly); File.SetAttributes(dest, fileAttr); ++successCount; } catch (Exception ex) { Console.Error.WriteLine("{0}: error: {1}", c, ex.Message); if (ex.InnerException != null) { Console.Error.WriteLine(ex.InnerException.ToString()); } ++errorCount; } } }
/// <summary> /// Builds the specified source file. /// </summary> /// <param name="sourceFile"> /// The absolute path of the source file. The file format must be a supported 3D model file /// format. /// </param> /// <param name="importerName">The name of the content importer.</param> /// <param name="processorName">The name of the content processor.</param> /// <param name="processorParameters">The processor parameters.</param> /// <param name="errorMessage">The error message in case of failure.</param> /// <returns> /// <see langword="true"/> if the asset was successfully processed. <see langword="false"/> /// if an error has occurred, in which case the output window should contain useful /// information. /// </returns> /// <exception cref="ArgumentNullException"> /// <paramref name="sourceFile"/> is <see langword="null"/>. /// </exception> /// <exception cref="ArgumentException"> /// <paramref name="sourceFile"/> is empty or is not an absolute (rooted) path. /// </exception> public bool Build(string sourceFile, string importerName, string processorName, OpaqueDataDictionary processorParameters, out string errorMessage) { if (sourceFile == null) { throw new ArgumentNullException(nameof(sourceFile)); } if (sourceFile.Length == 0) { throw new ArgumentException("Source file path must not be empty.", nameof(sourceFile)); } if (!Path.IsPathRooted(sourceFile)) { throw new ArgumentException("Source file path must be an absolute (rooted) path.", nameof(sourceFile)); } string executableFolder = ExecutableFolder; string outputFolder = OutputFolder; if (!Path.IsPathRooted(outputFolder)) { outputFolder = Path.GetFullPath(Path.Combine(executableFolder, outputFolder)); } string intermediateFolder = IntermediateFolder; if (!Path.IsPathRooted(intermediateFolder)) { intermediateFolder = PathHelper.Normalize(Path.GetFullPath(Path.Combine(executableFolder, intermediateFolder))); } // No assets should lie outside the working folder because then some XNB are built // into parent folders. string workingFolder = Path.GetPathRoot(sourceFile); Directory.SetCurrentDirectory(workingFolder); var manager = new PipelineManager(workingFolder, outputFolder, intermediateFolder) { Logger = _logger, RethrowExceptions = false, CompressContent = false, Profile = GraphicsProfile.HiDef, Platform = TargetPlatform.Windows }; // Add references to content pipeline assemblies. // All assemblies are expected to lie in the executable folder. Therefore, this project // references the content pipeline DLLs, so that they are automatically copied to the // executable folder. // TODO: Make a public property to allow user to set references. manager.AddAssembly(Path.GetFullPath(Path.Combine(ExecutableFolder, "DigitalRune.Animation.Content.Pipeline.dll"))); manager.AddAssembly(Path.GetFullPath(Path.Combine(ExecutableFolder, "DigitalRune.Game.UI.Content.Pipeline.dll"))); manager.AddAssembly(Path.GetFullPath(Path.Combine(ExecutableFolder, "DigitalRune.Geometry.Content.Pipeline.dll"))); manager.AddAssembly(Path.GetFullPath(Path.Combine(ExecutableFolder, "DigitalRune.Graphics.Content.Pipeline.dll"))); manager.AddAssembly(Path.GetFullPath(Path.Combine(ExecutableFolder, "DigitalRune.Mathematics.Content.Pipeline.dll"))); // Add this assembly because it also contains model processors. manager.AddAssembly(Path.GetFullPath(Path.Combine(ExecutableFolder, "DigitalRune.Editor.Game.dll"))); _logger.LogMessage("----- Begin MonoGame content pipeline -----"); // Remove any previous build content to force a full rebuild. manager.CleanContent(sourceFile); try { manager.BuildContent(sourceFile, null, importerName, processorName, processorParameters); errorMessage = null; return(true); } catch (Exception exception) { _logger.LogMessage("Exception in MonoGame content pipeline:"); _logger.LogWarning(null, null, exception.Message); _logger.LogMessage(exception.StackTrace); if (exception.Message.StartsWith("Value cannot be null.", StringComparison.OrdinalIgnoreCase)) { _logger.LogWarning(null, null, "This can happen if the FBX references a texture but the filename is null. Check the referenced texture file paths in a 3D modeling tool."); } errorMessage = exception.Message; return(false); } finally { _logger.LogMessage("----- End MonoGame content pipeline -----"); } }