public void Clean()
{
if (Project == null)
{
return;
}
currentBuild = BuildStep.Clean;
BuildStatusChanged?.BeginInvoke(this, BuildStep.Clean, null, null);
buildingThread = new System.Threading.Thread(new System.Threading.ThreadStart(delegate()
{
string outputDir = getOutputDir();
IsBuilding = true;
foreach (var file in cache.Files.Where(x => x.Value.IsBuilt(outputDir)).Select(x => x.Value.InputFile))
{
ContentFile item;
if (builtFiles.TryGetValue(file, out item))
{
ItemProgress?.BeginInvoke(this, new ItemProgressEventArgs(BuildStep.Clean, item), null, null);
if (System.IO.File.Exists(getDestinationFileAbsolute(item)))
{
System.IO.File.Delete(getDestinationFileAbsolute(item));
}
}
}
IsBuilding = false;
BuildStatusChanged?.Invoke(this, BuildStep.Clean | BuildStep.Finished);
}));
buildingThread.Start();
}
private void CleanThread()
{
IsBuilding = true;
foreach (var cachedItem in cache.Files)
{
var item = Project.GetElement(cachedItem.Value.InputFile) as ContentFile;
if (item != null)
{
ItemProgress?.BeginInvoke(this, new ItemProgressEventArgs(BuildStep.Clean, item), null, null);
if (System.IO.File.Exists(GetDestinationFileAbsolute(item)))
{
System.IO.File.Delete(GetDestinationFileAbsolute(item));
}
}
}
IsBuilding = false;
BuildStatusChanged?.Invoke(this, BuildStep.Clean | BuildStep.Finished);
}
/// <summary>
/// Builds a File based on the given File, ImporterContext and Processor Context
/// </summary>
/// <param name="contentFile"></param>
/// <param name="importerContext"></param>
/// <param name="processorContext"></param>
public Tuple <object, object> BuildFile(ContentFile contentFile, ContentImporterContext importerContext, ContentProcessorContext processorContext)
{
string importDir = System.IO.Path.GetDirectoryName(Project.File);
string importFile = System.IO.Path.Combine(importDir, contentFile.getPath());
string destFile = GetDestinationFileAbsolute(contentFile);
string outputPath = GetOutputDir();
CreateFolderIfNeeded(destFile);
if (!cache.NeedsRebuild(importDir, outputPath, contentFile.getPath()))
{
RaiseBuildMessage(this, new BuildMessageEventArgs(contentFile.Name, "skipped!", BuildMessageEventArgs.BuildMessageType.Information));
return(null);
}
BuildInfo cacheInfo = new BuildInfo(importDir, contentFile.getPath(), GetDestinationFile(contentFile));
var importer = contentFile.Importer;
if (importer == null)
{
return(null);
}
object importerOutput = importer.Import(importFile, importerContext);
if (importerOutput == null)
{
return(null);
}
cacheInfo.Dependencies.AddRange(importerContext.Dependencies);
cache.AddDependencies(importDir, importerContext.Dependencies);
engenious.Content.Pipeline.IContentProcessor processor = contentFile.Processor;
if (processor == null)
{
return(new Tuple <object, object>(importerOutput, null));
}
object processedData = processor.Process(importerOutput, importFile, processorContext);
if (processedData == null)
{
return(new Tuple <object, object>(importerOutput, null));
}
cacheInfo.Dependencies.AddRange(processorContext.Dependencies);
cache.AddDependencies(importDir, processorContext.Dependencies);
engenious.Content.Serialization.IContentTypeWriter typeWriter = engenious.Content.Serialization.SerializationManager.Instance.GetWriter(processedData.GetType());
engenious.Content.ContentFile outputFileWriter = new engenious.Content.ContentFile(typeWriter.RuntimeReaderName);
BinaryFormatter formatter = new BinaryFormatter();
using (FileStream fs = new FileStream(destFile, FileMode.Create, FileAccess.Write))
{
formatter.Serialize(fs, outputFileWriter);
engenious.Content.Serialization.ContentWriter writer = new engenious.Content.Serialization.ContentWriter(fs);
writer.WriteObject(processedData, typeWriter);
}
cacheInfo.BuildDone(outputPath);
cache.AddBuildInfo(cacheInfo);
builtFiles[contentFile.getPath()] = contentFile;
ItemProgress?.BeginInvoke(this, new ItemProgressEventArgs(BuildStep.Build, contentFile), null, null);
return(new Tuple <object, object>(importerOutput, processedData));
}
