private void BuildThread(ContentItem item)
{
FailedBuilds = 0;
IsBuilding = true;
string outputDir = GetOutputDir();
CreateFolderIfNeeded(outputDir);
PipelineHelper.PreBuilt(Project);
using (engenious.Content.Pipeline.ContentImporterContext importerContext = new engenious.Content.Pipeline.ContentImporterContext())
using (engenious.Content.Pipeline.ContentProcessorContext processorContext = new engenious.Content.Pipeline.ContentProcessorContext())
{
importerContext.BuildMessage += RaiseBuildMessage;
processorContext.BuildMessage += RaiseBuildMessage;
if (item == null)
{
BuildDir(Project, importerContext, processorContext);
}
else if (item is ContentFolder)
{
BuildDir((ContentFolder)item, importerContext, processorContext);
}
else if (item is ContentFile)
{
BuildFile((ContentFile)item, importerContext, processorContext);
}
}
//System.Threading.Thread.Sleep(8000);
cache.Save(GetCacheFile());
IsBuilding = false;
BuildStatusChanged?.BeginInvoke(this, BuildStep.Build | BuildStep.Finished, null, null);
}
/// <summary>
/// Builds a Directory based on the given folder, importerContext and processorContext
/// </summary>
/// <param name="folder"></param>
/// <param name="importerContext"></param>
/// <param name="processorContext"></param>
private void BuildDir(ContentFolder folder, engenious.Content.Pipeline.ContentImporterContext importerContext, engenious.Content.Pipeline.ContentProcessorContext processorContext)
{
foreach (var item in folder.Contents)
{
if (item is ContentFile)
{
BuildFile(item as ContentFile, importerContext, processorContext);
}
else if (item is ContentFolder)
{
BuildDir(item as ContentFolder, importerContext, processorContext);
}
}
}
public override Bitmap Import(string filename, ContentImporterContext context)
{
//if (!System.IO.File.Exists(filename))
// return null;
try
{
return(new Bitmap(filename));
}
catch (Exception ex)
{
context.RaiseBuildMessage(filename, ex.Message, BuildMessageEventArgs.BuildMessageType.Error);
}
return(null);
}
public override EffectContent Import(string filename, ContentImporterContext context)
{
try
{
EffectContent content = new EffectContent();
XmlDocument doc = new XmlDocument();
doc.Load(filename);
XmlElement effectElement;
XmlNode current = doc.FirstChild;
while (current != null && current.NodeType != XmlNodeType.Element)
{
current = current.NextSibling;
}
effectElement = (XmlElement)current;
foreach (XmlElement technique in effectElement.ChildNodes.OfType <XmlElement>())
{
EffectTechnique info = new EffectTechnique();
info.Name = technique.GetAttribute("name");
foreach (XmlElement pass in technique.ChildNodes.OfType <XmlElement>())
{
EffectPass pi = new EffectPass();
pi.Name = pass.GetAttribute("name");
foreach (XmlElement sh in pass.ChildNodes.OfType <XmlElement>())
{
if (sh.Name == "Shader")
{
ShaderType type = parseShaderType(sh.GetAttribute("type"));
if ((int)type == -1)
{
throw new Exception("Unsupported Shader type detected");
}
string shaderFile = System.IO.Path.Combine(System.IO.Path.GetDirectoryName(filename), sh.GetAttribute("filename"));
pi.Shaders.Add(type, shaderFile);
context.Dependencies.Add(shaderFile);
}
else if (sh.Name == "BlendState")
{
pi.BlendState = ParseBlendState(sh);
}
else if (sh.Name == "DepthStencilState")
{
pi.DepthStencilState = ParseDepthStencilState(sh);
}
else if (sh.Name == "RasterizerState")
{
pi.RasterizerState = ParseRasterizerState(sh);
}
else if (sh.Name == "Attributes")
{
foreach (XmlElement attr in sh.ChildNodes.OfType <XmlElement>())
{
if (attr.Name == "attribute")
{
VertexElementUsage usage = (VertexElementUsage)Enum.Parse(typeof(VertexElementUsage), attr.InnerText);
string nm = attr.GetAttribute("name");
if (nm.Length < 1)
{
throw new Exception("Not a valid attribute name'" + nm + "'");
}
pi.Attributes.Add(usage, nm);
}
}
}
else
{
throw new Exception("'" + sh.Name + "' element not recognized");
}
}
info.Passes.Add(pi);
}
content.Techniques.Add(info);
}
return(content);
}
catch (Exception ex)
{
context.RaiseBuildMessage(filename, ex.Message, BuildMessageEventArgs.BuildMessageType.Error);
}
return(null);
}
object IContentImporter.Import(string filename, ContentImporterContext context)
{
return(Import(filename, context));
}
public abstract T Import(string filename, ContentImporterContext context);
