public override TileMapContent Process(
XmlDocument input, ContentProcessorContext context)
{
TileMapContent map = new TileMapContent();
XmlNodeList colLayers = input.GetElementsByTagName("CollisionLayer");
foreach (XmlNode layer in colLayers)
{
map.CollisionLayers.Add(
context.BuildAsset <XmlDocument,
CollisionLayerContent>(
new ExternalReference <XmlDocument>(layer.InnerText),
"CollisionLayerProcessor"));
}
//System.Diagnostics.Debugger.Launch();
XmlNodeList tileLayers = input.GetElementsByTagName("TileLayer");
foreach (XmlNode layer in tileLayers)
{
map.TileLayers.Add(
context.BuildAsset <XmlDocument, TileLayerContent>(
new ExternalReference <XmlDocument>(layer.InnerText),
"TileLayerProcessor"));
}
return(map);
}
/// <summary>
/// Generates a terrain mesh from an input heightfield texture.
/// </summary>
public override TerrainModelContent Process(Texture2DContent input,
ContentProcessorContext context)
{
Texture2DContent texture = context.Convert <Texture2DContent, Texture2DContent>(input, "FloatingPointTextureProcessor");
PixelBitmapContent <float> heightfield = (PixelBitmapContent <float>)texture.Mipmaps[0];
float[,] heights = new float[heightfield.Width, heightfield.Height];
for (int y = 0; y < heightfield.Height; y++)
{
for (int x = 0; x < heightfield.Width; x++)
{
heights[x, y] = heightfield.GetPixel(x, y);
}
}
HeightMapContent heightMap = new HeightMapContent(heightfield.Width, heightfield.Height, heights, VerticalScale, HorizontalScale);
string directory = Path.GetDirectoryName(input.Identity.SourceFilename);
string texture1 = Path.Combine(directory, ColorTexture);
string texture2 = Path.Combine(directory, DetailTexture);
// Create a material, and point it at our terrain texture.
DualTextureMaterialContent material = new DualTextureMaterialContent
{
Texture = context.BuildAsset <TextureContent, TextureContent>(new ExternalReference <TextureContent>(texture1), null),
Texture2 = context.BuildAsset <TextureContent, TextureContent>(new ExternalReference <TextureContent>(texture2), null),
};
TerrainModelContentBuilder terrainModelContentBuilder = new TerrainModelContentBuilder(PatchSize, Tau, heightMap, material, DetailTextureTiling, HorizontalScale);
return(terrainModelContentBuilder.Build(context));
}
public void LoadTextureReferences(TiledMap map, ContentProcessorContext context)
{
TextureReferences = new Dictionary <string, ExternalReference <Texture2DContent> >();
foreach (var tileset in map.Tilesets)
{
if (
tileset.Properties.ContainsKey(TilesetParser.IgnoreTilesetTextureFlag) &&
bool.Parse(tileset.Properties[TilesetParser.IgnoreTilesetTextureFlag])
)
{
continue; // Skip texture, if we won't need it.
}
foreach (var path in tileset.TexturePaths)
{
if (TextureReferences.ContainsKey(path))
{
continue;
}
var assetReference = new ExternalReference <Texture2DContent>(TiledMapImporter.TmxRootDir + "/" + path);
TextureReferences.Add(path, context.BuildAsset <Texture2DContent, Texture2DContent>(assetReference, "", null, "", ""));
}
}
foreach (var imageLayer in map.ImageLayers)
{
if (TextureReferences.ContainsKey(imageLayer.TexturePath))
{
continue;
}
var asserReference = new ExternalReference <Texture2DContent>(TiledMapImporter.TmxRootDir + "/" + imageLayer.TexturePath);
TextureReferences.Add(imageLayer.TexturePath, context.BuildAsset <Texture2DContent, Texture2DContent>(asserReference, "", null, "", ""));
}
}
protected virtual ExternalReference<CompiledEffectContent> OnBuildEffect(ExternalReference<EffectContent> effect, ContentProcessorContext context)
{
return context.BuildAsset<EffectContent, CompiledEffectContent>(effect, typeof(EffectProcessor).Name);
#else
if (string.IsNullOrEmpty(ContentHelper.GetMonoGamePlatform()))
return context.BuildAsset<EffectContent, CompiledEffectContent>(effect, typeof(EffectProcessor).Name);
else
return context.BuildAsset<EffectContent, CompiledEffectContent>(effect, "MGEffectProcessor");
}
protected virtual ExternalReference<TextureContent> OnBuildTexture(string textureName, ExternalReference<TextureContent> texture, ContentProcessorContext context)
{
// Processor parameters are stored in opaque data!
var processorParameters = texture.OpaqueData;
return context.BuildAsset<TextureContent, TextureContent>(texture, typeof(DRTextureProcessor).Name, processorParameters, typeof(DRTextureImporter).Name, null);
}
protected override MaterialContent ConvertMaterial(MaterialContent material, ContentProcessorContext context)
{
OpaqueDataDictionary pparams = new OpaqueDataDictionary( );
pparams["ColorKeyEnabled"] = false;
pparams["GenerateMipmaps"] = this.GenerateMipmaps;
pparams["TextureFormat"] = this.TextureFormat;
pparams["ResizeTexturesToPowerOfTwo"] = this.ResizeTexturesToPowerOfTwo;
pparams["PremultiplyTextureAlpha"] = false;
string exePath = Application.ExecutablePath;
string appDir = exePath.Replace(Path.GetFileName(exePath), string.Empty);
string shaderPath = Path.Combine(appDir, DATA_DIR + @"\game.fx");
EffectMaterialContent vixenMaterial = new EffectMaterialContent( );
vixenMaterial.Effect = new ExternalReference <EffectContent>(shaderPath);
vixenMaterial.CompiledEffect = context.BuildAsset <EffectContent, CompiledEffectContent>(vixenMaterial.Effect, "EffectProcessor");
foreach (KeyValuePair <string, ExternalReference <TextureContent> > texture in material.Textures)
{
switch (texture.Key)
{
case C4D_DMAP:
vixenMaterial.Textures.Add(KEY_DMAP, texture.Value);
break;
case C4D_NMAP:
vixenMaterial.Textures.Add(KEY_NMAP, texture.Value);
break;
case C4D_SMAP:
vixenMaterial.Textures.Add(KEY_SMAP, texture.Value);
break;
case C4D_EMAP:
vixenMaterial.Textures.Add(KEY_EMAP, texture.Value);
break;
}
}
if (!vixenMaterial.Textures.ContainsKey(KEY_DMAP))
{
vixenMaterial.Textures[KEY_DMAP] = new ExternalReference <TextureContent>(Path.Combine(appDir, DATA_DIR + @"\dmap.tga"));
}
if (!vixenMaterial.Textures.ContainsKey(KEY_NMAP))
{
vixenMaterial.Textures[KEY_DMAP] = new ExternalReference <TextureContent>(Path.Combine(appDir, DATA_DIR + @"\nmap.tga"));
}
if (!vixenMaterial.Textures.ContainsKey(KEY_SMAP))
{
vixenMaterial.Textures[KEY_DMAP] = new ExternalReference <TextureContent>(Path.Combine(appDir, DATA_DIR + @"\smap.tga"));
}
if (!vixenMaterial.Textures.ContainsKey(KEY_EMAP))
{
vixenMaterial.Textures[KEY_DMAP] = new ExternalReference <TextureContent>(Path.Combine(appDir, DATA_DIR + @"\emap.tga"));
}
return(context.Convert <MaterialContent, MaterialContent>(vixenMaterial, typeof(MaterialProcessor).Name, pparams));
}
/// <summary>
/// Iterates all of the tile sets and builds external references to the textures. Useful if you want to just
/// load the resulting map and not have to also load up textures. The external reference is stored on the
/// TileSet's Texture field so make sure you serialize that if you call this method.
/// </summary>
public static void BuildTileSetTextures(MapContent input, ContentProcessorContext context, string textureRoot = "")
{
foreach (var tileSet in input.TileSets)
{
// get the real path to the image
string path = Path.Combine(textureRoot, tileSet.Image);
// the asset name is the entire path, minus extension, after the content directory
string asset = string.Empty;
if (path.StartsWith(Directory.GetCurrentDirectory()))
asset = path.Remove(tileSet.Image.LastIndexOf('.')).Substring(Directory.GetCurrentDirectory().Length + 1);
else
asset = Path.GetFileNameWithoutExtension(path);
// build the asset as an external reference
OpaqueDataDictionary data = new OpaqueDataDictionary();
data.Add("GenerateMipmaps", false);
data.Add("ResizeToPowerOfTwo", false);
data.Add("TextureFormat", TextureProcessorOutputFormat.Color);
data.Add("ColorKeyEnabled", tileSet.ColorKey.HasValue);
data.Add("ColorKeyColor", tileSet.ColorKey.HasValue ? tileSet.ColorKey.Value : Microsoft.Xna.Framework.Color.Magenta);
tileSet.Texture = context.BuildAsset<Texture2DContent, Texture2DContent>(
new ExternalReference<Texture2DContent>(path), null, data, null, asset);
}
}
/// <summary>
/// Builds Distorter textures with the DisplacementMapProcessor
/// </summary>
protected override ExternalReference <TextureContent> BuildTexture(
string textureName, ExternalReference <TextureContent> texture,
ContentProcessorContext context)
{
return(context.BuildAsset <TextureContent,
TextureContent>(texture, "DisplacementMapProcessor"));
}
public void BuildExternalReference <TInput>(ContentProcessorContext context, string source, OpaqueDataDictionary parameters = null)
{
var sourceAsset = new ExternalReference <TInput>(source);
var externalReference = context.BuildAsset <TInput, TInput>(sourceAsset, "", parameters, "", "");
_externalReferences.Add(source, externalReference);
}
/// <summary>
/// Processes the raw .tsx XML and creates a TilesetContent
/// for use in an XNA framework game
/// </summary>
/// <param name="input">The XML string</param>
/// <param name="context">The pipeline context</param>
/// <returns>A TilesetContent instance corresponding to the tsx input</returns>
public override TOutput Process(TInput input, ContentProcessorContext context)
{
// Process the Tilesets
for (int i = 0; i < input.Tilesets.Count; i++)
{
var tileset = input.Tilesets[i];
ExternalReference <TilesetContent> externalRef = new ExternalReference <TilesetContent>(tileset.Source);
tileset.Reference = context.BuildAsset <TilesetContent, TilesetContent>(externalRef, "TilesetProcessor");
}
foreach (TilemapLayerContent layer in input.Layers)
{
List <uint> dataIds = new List <uint>();
foreach (var id in layer.DataString.Split(','))
{
dataIds.Add(uint.Parse(id));
}
;
layer.Data = dataIds.ToArray();
}
foreach (TilemapObjectContent obj in input.Objects)
{
}
// The tileset has been processed
return(input);
}
public override AnimationsData Process(AnimationsData input, ContentProcessorContext context)
{
// Save spritesheet texture
var spriteSheetAsset = Path.Combine(input.FilePath, input.SpriteSheetFilename);
string assetName;
if (spriteSheetAsset.StartsWith(Directory.GetCurrentDirectory()))
{
assetName = spriteSheetAsset.Substring(Directory.GetCurrentDirectory().Length + 1);
}
else
{
assetName = Path.GetFileName(spriteSheetAsset);
}
// Remove file extension
assetName = Path.Combine(Path.GetDirectoryName(assetName), Path.GetFileNameWithoutExtension(assetName));
input.SpriteSheetRef = context.BuildAsset <SpriteSheetData, SpriteSheetData>(
new ExternalReference <SpriteSheetData>(spriteSheetAsset),
"DarkFunctionSpritesProcessor",
null,
"DarkFunctionSpritesImporter",
assetName);
return(input);
}
private void ProcessTextures(ThemeContent theme, ContentProcessorContext context)
{
theme.Textures = new NamedObjectCollection<ThemeTextureContent>();
var document = theme.Description;
if (document.Root == null)
{
string message = string.Format("Root element \"<Theme>\" is missing in XML.");
throw new InvalidContentException(message, theme.Identity);
}
if (document.Root.Elements("Texture").Any())
{
// Issue error because theme file is using old alpha version format.
throw new InvalidContentException("Given theme file is using a format which is no longer supported. All textures need to be defined inside a 'Textures' node.", theme.Identity);
}
var texturesElement = document.Root.Element("Textures");
if (texturesElement == null)
throw new InvalidContentException("Given theme file does not contain a 'Textures' node.", theme.Identity);
foreach (var textureElement in texturesElement.Elements("Texture"))
{
string name = GetMandatoryAttribute(textureElement, "Name", theme.Identity);
bool isDefault = (bool?)textureElement.Attribute("IsDefault") ?? false;
string filename = GetMandatoryAttribute(textureElement, "File", theme.Identity);
bool premultiplyAlpha = (bool?)textureElement.Attribute("PremultiplyAlpha") ?? true;
// Get path of texture relative to root directory without file extension.
string textureSourcePath = FindFile(theme, filename);
string relativeTextureSourcePath =
_sourceRootDirectoryUri.MakeRelativeUri(new Uri(textureSourcePath)).OriginalString;
relativeTextureSourcePath = Uri.UnescapeDataString(relativeTextureSourcePath);
string extension = Path.GetExtension(relativeTextureSourcePath);
relativeTextureSourcePath = relativeTextureSourcePath.Remove(
relativeTextureSourcePath.Length - extension.Length, extension.Length);
// Build Texture.
var processorParameters = new OpaqueDataDictionary();
processorParameters.Add("PremultiplyAlpha", premultiplyAlpha);
var textureReference = context.BuildAsset<TextureContent, TextureContent>(
new ExternalReference<TextureContent>(textureSourcePath),
"TextureProcessor",
processorParameters,
"TextureImporter",
relativeTextureSourcePath);
var texture = new ThemeTextureContent
{
Name = name,
IsDefault = isDefault,
Texture = textureReference,
};
theme.Textures.Add(texture);
}
if (theme.Textures.Count == 0)
throw new InvalidContentException("The UI theme does not contain any textures. At least 1 texture is required.", theme.Identity);
}
/// <summary>
/// Iterates all of the tile sets and builds external references to the textures. Useful if you want to just
/// load the resulting map and not have to also load up textures. The external reference is stored on the
/// TileSet's Texture field so make sure you serialize that if you call this method.
/// </summary>
public static void BuildTileSetTextures(MapContent input, ContentProcessorContext context, string textureRoot = "")
{
foreach (var tileSet in input.TileSets)
{
// get the real path to the image
string path = Path.Combine(textureRoot, tileSet.Image);
// the asset name is the entire path, minus extension, after the content directory
string asset = string.Empty;
if (path.StartsWith(Directory.GetCurrentDirectory()))
{
asset = path.Remove(tileSet.Image.LastIndexOf('.')).Substring(Directory.GetCurrentDirectory().Length + 1);
}
else
{
asset = Path.GetFileNameWithoutExtension(path);
}
// build the asset as an external reference
OpaqueDataDictionary data = new OpaqueDataDictionary();
data.Add("GenerateMipmaps", false);
data.Add("ResizeToPowerOfTwo", false);
data.Add("TextureFormat", TextureProcessorOutputFormat.Color);
data.Add("ColorKeyEnabled", tileSet.ColorKey.HasValue);
data.Add("ColorKeyColor", tileSet.ColorKey.HasValue ? tileSet.ColorKey.Value : Microsoft.Xna.Framework.Color.Magenta);
tileSet.Texture = context.BuildAsset <Texture2DContent, Texture2DContent>(
new ExternalReference <Texture2DContent>(path), null, data, null, asset);
}
}
private string BuildTexture(string textureName)
{
if (textureName == null || textureName.Length == 0)
{
return("");
}
string assetLocation = new FileInfo(rootPath).DirectoryName + @"/" + textureName;
string comparePath = rootPath;
if (importTextures)
{
OpaqueDataDictionary processorParameters = new OpaqueDataDictionary();
processorParameters.Add("ColorKeyColor", this.colourKeyColour);
processorParameters.Add("ColorKeyEnabled", this.ColorKeyEnabled);
processorParameters.Add("TextureFormat", this.TextureFormat);
processorParameters.Add("GenerateMipmaps", this.GenerateMipmaps);
processorParameters.Add("ResizeToPowerOfTwo", this.ResizeTexturesToPowerOfTwo);
ExternalReference <TextureContent> texture = context.BuildAsset <TextureContent, TextureContent>(new ExternalReference <TextureContent>(textureName, new ContentIdentity(rootPath)), typeof(TextureProcessor).Name, processorParameters, null, null);
assetLocation = texture.Filename;
comparePath = context.OutputFilename;
}
else
{
if (!File.Exists(assetLocation))
{
context.Logger.LogWarning("", new ContentIdentity(rootPath), "File not found:\t{1} ({0})", textureName, @".\" + GetSharedPath(assetLocation, comparePath) + new FileInfo(assetLocation).Extension);
return("");
}
}
return(GetSharedPath(assetLocation, comparePath));
}
public override AnimationData Process(AnimationData input, ContentProcessorContext context)
{
var inRef = new ExternalReference <TextureContent>(input.sheet);
input.sheetRef = context.BuildAsset <TextureContent, TextureContent>(inRef, "TextureProcessor");
return(input);
}
private MagmaModelContent ProcessContainerFile(
NodeContent input,
ContentProcessorContext context
)
{
#if DEBUG
context.Logger.LogImportantMessage(" processing file as a model container");
#endif
int startIndex = input.Identity.SourceFilename.LastIndexOf("Content\\") + "Content\\".Length;
int endIndex = input.Identity.SourceFilename.LastIndexOf('\\') + 1;
string dir = input.Identity.SourceFilename.Substring(startIndex, endIndex - startIndex);
// parameters to be passed into the processor
OpaqueDataDictionary dictionary = new OpaqueDataDictionary();
dictionary.Add("CallRecursive", true);
foreach (NodeContent child in input.Children)
{
#if DEBUG
context.Logger.LogImportantMessage(" spawning a new build process for {0}", child.Name);
#endif
dictionary["CurrentGroup"] = child.Name;
context.BuildAsset <NodeContent, MagmaModelContent>(
new ExternalReference <NodeContent>(input.Identity.SourceFilename),
this.GetType().Name, dictionary, GetContainerGroupImporter(), dir + child.Name);
}
RemoveTextureReferences(input, context);
return(BaseProcessing(input, context));
}
/// <summary>
/// builds an external reference to a texture
/// </summary>
internal static ExternalReference <TextureContent> BuildTexture(string file, ContentProcessorContext context)
{
ExternalReference <Texture2DContent> tex = new ExternalReference <Texture2DContent>(file);
tex.Name = Path.GetFileNameWithoutExtension(file);
CreateDictionaryIfNecessary();
//string extension = Path.GetExtension(file);
//UseBlackAsAlpha = extension.ToLower() == ".bmp";
//if (UseBlackAsAlpha)
//{
// TextureProcessor.ColorKeyColor = Color.Black;
// TextureProcessor.ColorKeyEnabled = true;
//}
//else
//{
// TextureProcessor.ColorKeyEnabled = false;
//}
return(context.BuildAsset <Texture2DContent, TextureContent>(
tex,
typeof(TextureProcessor).Name,
dictionary,
"TextureImporter",
null // Passing null lets the content pipeline decide on the default name, which is what we want.
));
}
public override LevelContent Process(OelContent input, ContentProcessorContext context)
{
if (string.IsNullOrEmpty(this.OgmoProjectFile))
{
throw new Exception("No project file specified.");
}
if (!this.OgmoProjectFile.EndsWith(".oep"))
{
this.OgmoProjectFile += ".oep";
}
string projectPath = Path.GetFullPath(Path.Combine(input.Directory, this.OgmoProjectFile));
string projectAsset = projectPath.Remove(projectPath.LastIndexOf('.')).Substring(Directory.GetCurrentDirectory().Length + 1);
ProjectContent projectContent = context.BuildAndLoadAsset <OepContent, ProjectContent>(
new ExternalReference <OepContent>(projectPath),
"OepProcessor",
new OpaqueDataDictionary(),
"OepImporter");
LevelContent levelContent = new LevelContent(projectContent, input.Document);
levelContent.ProjectReference = context.BuildAsset <OepContent, ProjectContent>(
new ExternalReference <OepContent>(projectPath),
"OepProcessor",
new OpaqueDataDictionary(),
"OepImporter",
projectAsset);
return(levelContent);
}
public override SpriteSheetData Process(SpriteSheetData input, ContentProcessorContext context)
{
// Save spritesheet texture
var sourceAsset = Path.Combine(input.FilePath, input.ImageFilename);
string assetName;
if (sourceAsset.StartsWith(Directory.GetCurrentDirectory()))
{
assetName = sourceAsset.Substring(Directory.GetCurrentDirectory().Length + 1);
}
else
{
assetName = Path.GetFileName(sourceAsset);
}
// Remove file extension
assetName = Path.Combine(Path.GetDirectoryName(assetName), Path.GetFileNameWithoutExtension(assetName));
input.ImageRef = context.BuildAsset <TextureContent, TextureContent>(
new ExternalReference <TextureContent>(sourceAsset),
"TextureProcessor",
null,
"TextureImporter",
assetName);
return(input);
}
protected override MaterialContent ConvertMaterial(MaterialContent material,
ContentProcessorContext context)
{
EffectMaterialContent lppMaterial = new EffectMaterialContent();
OpaqueDataDictionary processorParameters = new OpaqueDataDictionary();
processorParameters["ColorKeyColor"] = this.ColorKeyColor;
processorParameters["ColorKeyEnabled"] = false;
processorParameters["TextureFormat"] = this.TextureFormat;
processorParameters["GenerateMipmaps"] = this.GenerateMipmaps;
processorParameters["ResizeTexturesToPowerOfTwo"] = this.ResizeTexturesToPowerOfTwo;
processorParameters["PremultiplyTextureAlpha"] = false;
processorParameters["ColorKeyEnabled"] = false;
lppMaterial.Effect = new ExternalReference <EffectContent>(_customFx.Length == 0 ? "shaders/LPPMainEffect.fx" : _customFx);
lppMaterial.CompiledEffect = context.BuildAsset <EffectContent, CompiledEffectContent>(lppMaterial.Effect, "EffectProcessor");
// copy the textures in the original material to the new lpp
// material
ExtractTextures(lppMaterial, material);
//extract the extra parameters
ExtractDefines(lppMaterial, material, context);
// and convert the material using the NormalMappingMaterialProcessor,
// who has something special in store for the normal map.
return(context.Convert <MaterialContent, MaterialContent>
(lppMaterial, typeof(LightPrePassMaterialProcessor).Name, processorParameters));
}
/// <summary>
/// Processes the raw .tsx XML and creates a TilesetContent
/// for use in an XNA framework game
/// </summary>
/// <param name="input">The XML string</param>
/// <param name="context">The pipeline context</param>
/// <returns>A TilesetContent instance corresponding to the tsx input</returns>
public override TOutput Process(TInput input, ContentProcessorContext context)
{
// Process the Tilesets
for (int i = 0; i < input.Tilesets.Count; i++)
{
var tileset = input.Tilesets[i];
ExternalReference <TilesetContent> externalRef = new ExternalReference <TilesetContent>(tileset.Source);
tileset.Reference = context.BuildAsset <TilesetContent, TilesetContent>(externalRef, "TilesetProcessor");
}
foreach (TilemapLayerContent layer in input.Layers)
{
List <uint> dataIds = new List <uint>();
foreach (var id in layer.DataString.Split(','))
{
dataIds.Add(uint.Parse(id));
}
;
layer.Data = dataIds.ToArray();
}
// Correction for tile objects X,Y being left,bottom origin instead of left,top
foreach (TilemapObjectGroupContent objectGroup in input.ObjectGroups)
{
foreach (ObjectGroupObjects groupObject in objectGroup.Objects)
{
groupObject.Y -= input.TileHeight;
}
}
// The tileset has been processed
return(input);
}
/// <summary>
/// Processes a compiled material and prepares it for disk writing.
/// </summary>
/// <param name="input">The CompiledMaterial instance to process.</param>
/// <param name="context">The current content processor context.</param>
/// <returns></returns>
public override CompiledMaterial Process(CompiledMaterial input, ContentProcessorContext context)
{
input.compiledEffect = context.BuildAsset <EffectContent, CompiledEffectContent>(new ExternalReference <EffectContent>(string.Format("{0}{1}.fx", Path.GetFullPath("Effects/"), input.effect)), "EffectProcessor");
// TODO: ExternalReference to textures, or leave management to run-time renderer?
return(input);
}
//build default texture accompany
public void BuildTextures(ContentProcessorContext context)
{
//build texture.xnb files
for (int i = 0; i < textures.Count; i++)
{
textures[i] = context.BuildAsset <TextureContent, TextureContent>(textures[i], "TextureProcessor");
}
}
protected override ExternalReference<CompiledEffectContent> BuildEffect(ExternalReference<EffectContent> effect, ContentProcessorContext context)
{
OpaqueDataDictionary processorParameters = new OpaqueDataDictionary();
if (context.Parameters.ContainsKey("Defines"))
processorParameters.Add("Defines", context.Parameters["Defines"]);
return context.BuildAsset<EffectContent, CompiledEffectContent>(effect, "DeferredRendererFXProcessor", processorParameters, "EffectImporter", effect.Name);
}
public static ExternalReference <SpriteEditorSceneContent> CreateAndBuildExternalReference(
string name, ContentProcessorContext context)
{
ExternalReference <SpriteEditorSceneContent> returnObject =
new ExternalReference <FlatRedBall.Content.SpriteEditorSceneContent>(name);
return(context.BuildAsset <SpriteEditorSceneContent, SpriteEditorSceneContent>(
returnObject, typeof(SceneFileProcessor).Name));
}
/// <summary>
/// Builds an External Reference for use in the content pipeline
/// </summary>
public static ExternalReference <AnimationChainListSaveContent> BuildExternalReference(string path, ContentProcessorContext context)
{
return(context.BuildAsset <AnimationChainListSaveContent, AnimationChainListSaveContent>(
new ExternalReference <AnimationChainListSaveContent>(path),
typeof(AnimationChainArrayProcessor).Name,
context.Parameters,
typeof(AnimationChainArrayImporter).Name,
null));
}
protected override ExternalReference <CompiledEffectContent> BuildEffect(ExternalReference <EffectContent> effect, ContentProcessorContext context)
{
OpaqueDataDictionary processorParameters = new OpaqueDataDictionary();
if (context.Parameters.ContainsKey("Defines"))
{
processorParameters.Add("Defines", context.Parameters["Defines"]);
}
return(context.BuildAsset <EffectContent, CompiledEffectContent>(effect, "LightPrePassFXProcessor", processorParameters, "EffectImporter", effect.Name));
}
public virtual ExternalReference <TextureContent> BuildControlTexture(
ContentProcessorContext context, string path)
{
return(context.BuildAsset <TextureContent, TextureContent>(
new ExternalReference <TextureContent>(path),
"SplatWeightProcessor",
null,
"TextureImporter",
path.Substring(0, path.IndexOf('.'))));
}
public override TOutput Process(TInput input, ContentProcessorContext context)
{
for (int i = 0; i < input.Count; i++)
{
Spawn s = input[i];
ExternalReference <TextureContent> tc = new ExternalReference <TextureContent>(s.TextureFileName);
s.Texture = context.BuildAsset <TextureContent, TextureContent>(tc, "TextureProcessor");
}
return(input);
}
public override ProjectContent Process(OepContent input, ContentProcessorContext context)
{
ProjectContent projectContent = new ProjectContent(input.Document);
string workingDirectory = Path.GetFullPath(Path.Combine(input.Directory, projectContent.Settings.WorkingDirectory));
foreach (TilesetContent tileset in projectContent.Tilesets)
{
string assetPath = Path.Combine(workingDirectory, tileset.TextureFile);
string asset = assetPath.Remove(assetPath.LastIndexOf('.')).Substring(Directory.GetCurrentDirectory().Length + 1);
OpaqueDataDictionary data = new OpaqueDataDictionary();
data.Add("GenerateMipmaps", false);
data.Add("ResizeToPowerOfTwo", false);
data.Add("TextureFormat", TextureProcessorOutputFormat.Color);
data.Add("ColorKeyEnabled", false);
data.Add("ColorKeyColor", Microsoft.Xna.Framework.Color.Magenta);
tileset.TextureReference = context.BuildAsset <TextureContent, TextureContent>(
new ExternalReference <TextureContent>(assetPath),
"TextureProcessor",
data,
"TextureImporter",
asset);
}
foreach (ObjectTemplateContent obj in projectContent.Objects)
{
string assetPath = Path.Combine(workingDirectory, obj.TextureFile);
string asset = assetPath.Remove(assetPath.LastIndexOf('.')).Substring(Directory.GetCurrentDirectory().Length + 1);
OpaqueDataDictionary data = new OpaqueDataDictionary();
data.Add("GenerateMipmaps", false);
data.Add("ResizeToPowerOfTwo", false);
data.Add("TextureFormat", TextureProcessorOutputFormat.Color);
data.Add("ColorKeyEnabled", false);
data.Add("ColorKeyColor", Microsoft.Xna.Framework.Color.Magenta);
obj.TextureReference = context.BuildAsset <TextureContent, TextureContent>(
new ExternalReference <TextureContent>(assetPath),
"TextureProcessor",
data,
"TextureImporter",
asset);
}
return(projectContent);
}
protected override ExternalReference<TextureContent> BuildTexture(string textureName, ExternalReference<TextureContent> texture, ContentProcessorContext context)
{
// Named textures will each have their own custom processor
switch (textureName) {
case HMModelProcessor.SPECULAR_MAP_KEY:
return context.BuildAsset<TextureContent, TextureContent>(texture, typeof (HMSpecularProcessor).Name);
default:
// Default processing for all others
return base.BuildTexture(textureName, texture, context);
}
}
protected override ExternalReference <TextureContent> BuildTexture(string textureName, ExternalReference <TextureContent> texture, ContentProcessorContext context)
{
OpaqueDataDictionary processorParameters = new OpaqueDataDictionary();
processorParameters.Add("ColorKeyColor", this.ColorKeyColor);
processorParameters.Add("ColorKeyEnabled", this.ColorKeyEnabled);
processorParameters.Add("TextureFormat", this.TextureFormat);
processorParameters.Add("GenerateMipmaps", this.GenerateMipmaps);
processorParameters.Add("ResizeToPowerOfTwo", this.ResizeTexturesToPowerOfTwo);
processorParameters.Add("ForceDXT5", this.ForceDXT5);
return(context.BuildAsset <TextureContent, TextureContent>(texture, typeof(Dxt5TextureProcessor).Name, processorParameters, null, null));
}
private int torso_frames; //animation offset, for legs
#endregion Fields
#region Methods
public void buildTextures(ContentProcessorContext context)
{
Dictionary<string, ExternalReference<TextureContent>>.Enumerator e = materials_list.GetEnumerator();
built_textures = new List<ExternalReference<TextureContent>>();
while (e.MoveNext())
{
ExternalReference<TextureContent> t = e.Current.Value;
ExternalReference<TextureContent> builtTexture = context.BuildAsset<TextureContent, TextureContent>(t, "TextureProcessor");
builtTexture.Name = e.Current.Key;
built_textures.Add(builtTexture);
}
}
/// <summary>
/// Builds texture content.
/// </summary>
/// <param name="textureName">The name of the texture. This should correspond to the key used to store the texture in Textures.</param>
/// <param name="texture">The asset to build. This should be a member of Textures.</param>
/// <param name="context">Context for the specified processor.</param>
/// <returns>The built texture content.</returns>
/// <remarks>textureName can be used to determine which processor to use. For example, if a texture is being used as a normal map, the user may not want to use the ModelTextureProcessor on it, which compresses textures.</remarks>
protected virtual ExternalReference <TextureContent> BuildTexture(string textureName, ExternalReference <TextureContent> texture, ContentProcessorContext context)
{
var parameters = new OpaqueDataDictionary();
parameters.Add("ColorKeyColor", ColorKeyColor);
parameters.Add("ColorKeyEnabled", ColorKeyEnabled);
parameters.Add("GenerateMipmaps", GenerateMipmaps);
parameters.Add("PremultiplyAlpha", PremultiplyTextureAlpha);
parameters.Add("ResizeToPowerOfTwo", ResizeTexturesToPowerOfTwo);
parameters.Add("TextureFormat", TextureFormat);
return(context.BuildAsset <TextureContent, TextureContent>(texture, "TextureProcessor", parameters, "TextureImporter", null));
}
protected override ExternalReference<TextureContent> BuildTexture(string textureName, ExternalReference<TextureContent> texture,
ContentProcessorContext context)
{
if (textureName == NormalMappingModelProcessor.NormalMapKey)
{
// put the normal map through the special NormalMapTextureProcessor,
// which will convert it to a signed format.
return context.BuildAsset<TextureContent, TextureContent>(texture,
typeof(NormalMapTextureProcessor).Name);
}
// Apply default processing to all other textures.
return base.BuildTexture(textureName, texture, context);
}
protected override ExternalReference<TextureContent> BuildTexture(string textureName, ExternalReference<TextureContent> texture, ContentProcessorContext context)
{
// Fallback if we aren't buiding for iOS.
var platform = ContentHelper.GetMonoGamePlatform();
if (platform != MonoGamePlatform.iOS)
return base.BuildTexture(textureName, texture, context);
var processorParameters = new OpaqueDataDictionary();
processorParameters.Add("ColorKeyColor", this.ColorKeyColor);
processorParameters.Add("ColorKeyEnabled", this.ColorKeyEnabled);
processorParameters.Add("TextureFormat", this.TextureFormat);
processorParameters.Add("GenerateMipmaps", this.GenerateMipmaps);
processorParameters.Add("ResizeToPowerOfTwo", this.ResizeTexturesToPowerOfTwo);
processorParameters.Add("PremultiplyAlpha", this.PremultiplyTextureAlpha);
return context.BuildAsset<TextureContent, TextureContent>(texture, typeof(MGTextureProcessor).Name, processorParameters, null, null);
}
protected override MaterialContent ConvertMaterial(MaterialContent material,
ContentProcessorContext context)
{
EffectMaterialContent lppMaterial = new EffectMaterialContent();
OpaqueDataDictionary processorParameters = new OpaqueDataDictionary();
processorParameters["ColorKeyColor"] = this.ColorKeyColor;
processorParameters["ColorKeyEnabled"] = this.ColorKeyEnabled;
processorParameters["TextureFormat"] = this.TextureFormat;
processorParameters["GenerateMipmaps"] = this.GenerateMipmaps;
processorParameters["ResizeTexturesToPowerOfTwo"] = this.ResizeTexturesToPowerOfTwo;
processorParameters["PremultiplyTextureAlpha"] = false;
processorParameters["ColorKeyEnabled"] = false;
lppMaterial.Effect = new ExternalReference<EffectContent>("shaders/LPPMainEffect.fx");
lppMaterial.CompiledEffect = context.BuildAsset<EffectContent, CompiledEffectContent>(lppMaterial.Effect, "EffectProcessor");
//extract the extra parameters
ExtractDefines(lppMaterial, material, context);
// copy the textures in the original material to the new normal mapping
// material. this way the diffuse texture is preserved. The
// PreprocessSceneHierarchy function has already added the normal map
// texture to the Textures collection, so that will be copied as well.
foreach (KeyValuePair<String, ExternalReference<TextureContent>> texture
in material.Textures)
{
lppMaterial.Textures.Add(texture.Key, texture.Value);
}
try
{
lppMaterial.OpaqueData.Add("DiffuseColor", new Vector4((Vector3)material.OpaqueData["DiffuseColor"], (float)material.OpaqueData["Alpha"]));
lppMaterial.OpaqueData.Add("SpecularColor", material.OpaqueData["SpecularColor"]);
lppMaterial.OpaqueData.Add("SpecularPower", material.OpaqueData["SpecularPower"]);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
// and convert the material using the NormalMappingMaterialProcessor,
// who has something special in store for the normal map.
return context.Convert<MaterialContent, MaterialContent>
(lppMaterial, typeof(LightPrePassMaterialProcessor).Name, processorParameters);
}
protected override MaterialContent ConvertMaterial(MaterialContent material, ContentProcessorContext context)
{
if (string.IsNullOrEmpty(StitchedEffect))
throw new Exception("Stitched Effect property must be set for StitchUp Model Processor.");
string fullPath = Path.GetFullPath(Path.Combine(new FileInfo(material.Identity.SourceFilename).DirectoryName, StitchedEffect));
context.AddDependency(fullPath);
EffectMaterialContent effectMaterial = new EffectMaterialContent
{
CompiledEffect = context.BuildAsset<StitchedEffectContent, CompiledEffectContent>(new ExternalReference<StitchedEffectContent>(fullPath), typeof(StitchedEffectProcessor).Name),
Identity = material.Identity,
Name = material.Name
};
return effectMaterial;
}
public static ExternalReference<Texture2DContent> LoadTexture(string imagePath, Color? color_key, ContentProcessorContext context, string textureRoot = "")
{
string path = Path.Combine(textureRoot, imagePath);
// the asset name is the entire path, minus extension, after the content directory
string asset = string.Empty;
if (path.StartsWith(Directory.GetCurrentDirectory()))
asset = path.Remove(imagePath.LastIndexOf('.')).Substring(Directory.GetCurrentDirectory().Length + 1);
else
asset = Path.GetFileNameWithoutExtension(path);
// build the asset as an external reference
OpaqueDataDictionary data = new OpaqueDataDictionary();
data.Add("GenerateMipmaps", false);
data.Add("ResizeToPowerOfTwo", false);
data.Add("TextureFormat", TextureProcessorOutputFormat.Color);
data.Add("ColorKeyEnabled", color_key.HasValue);
data.Add("ColorKeyColor", color_key.HasValue ? color_key.Value : Microsoft.Xna.Framework.Color.Magenta);
return context.BuildAsset<Texture2DContent, Texture2DContent>(
new ExternalReference<Texture2DContent>(path), null, data, null, asset);
}
protected override ExternalReference<CompiledEffectContent> BuildEffect(ExternalReference<EffectContent> effect, ContentProcessorContext context)
{
return context.BuildAsset<EffectContent, CompiledEffectContent>(effect, typeof(MGEffectProcessor).Name);
}
protected virtual ExternalReference<DRMaterialContent> OnBuildMaterial(ExternalReference<DRMaterialContent> material, ContentProcessorContext context)
{
return context.BuildAsset<DRMaterialContent, DRMaterialContent>(material, typeof(DRMaterialProcessor).Name, null, typeof(DRMaterialImporter).Name, null);
}
public static string BuildTextureExternal(ContentProcessorContext context, string texPath)
{
var dir = Path.GetDirectoryName(texPath);
return Path.Combine(dir, Path.GetFileNameWithoutExtension(context.BuildAsset<TextureContent, TextureContent>(new ExternalReference<TextureContent>(texPath), "TextureProcessor").Filename));
}
protected override MaterialContent ConvertMaterial(MaterialContent material,
ContentProcessorContext context)
{
EffectMaterialContent lppMaterial = new EffectMaterialContent();
OpaqueDataDictionary processorParameters = new OpaqueDataDictionary();
processorParameters["ColorKeyColor"] = this.ColorKeyColor;
processorParameters["ColorKeyEnabled"] = false;
processorParameters["TextureFormat"] = this.TextureFormat;
processorParameters["GenerateMipmaps"] = this.GenerateMipmaps;
processorParameters["ResizeTexturesToPowerOfTwo"] = this.ResizeTexturesToPowerOfTwo;
processorParameters["PremultiplyTextureAlpha"] = false;
processorParameters["ColorKeyEnabled"] = false;
lppMaterial.Effect = new ExternalReference<EffectContent>(_customFx.Length == 0 ? "shaders/LPPMainEffect.fx" : _customFx);
lppMaterial.CompiledEffect = context.BuildAsset<EffectContent, CompiledEffectContent>(lppMaterial.Effect, "EffectProcessor");
// copy the textures in the original material to the new lpp
// material
ExtractTextures(lppMaterial, material);
//extract the extra parameters
ExtractDefines(lppMaterial, material, context);
// and convert the material using the NormalMappingMaterialProcessor,
// who has something special in store for the normal map.
return context.Convert<MaterialContent, MaterialContent>
(lppMaterial, typeof(LightPrePassMaterialProcessor).Name, processorParameters);
}
/// <summary>
/// Builds a texture for use by this material.
/// </summary>
protected override ExternalReference<TextureContent> BuildTexture(
string textureName,
ExternalReference<TextureContent> texture,
ContentProcessorContext context)
{
// Use our custom CubemapProcessor for the environment map texture.
if (textureName == "EnvironmentMap")
{
return context.BuildAsset<TextureContent,
TextureContent>(texture, "CubemapProcessor");
}
// Apply default processing to all other textures.
return base.BuildTexture(textureName, texture, context);
}
protected override MaterialContent ConvertMaterial(MaterialContent material, ContentProcessorContext context)
{
EffectMaterialContent deferredShadingMaterial = new EffectMaterialContent();
deferredShadingMaterial.Effect = new ExternalReference<EffectContent>("../../GraphicsLibrary/GraphicsContent/Shaders/Deferred Rendering/RenderGBuffer.fx");
deferredShadingMaterial.CompiledEffect = context.BuildAsset<EffectContent, CompiledEffectContent>(deferredShadingMaterial.Effect, "EffectProcessor");
// copy the textures in the original material to the new normal mapping
// material, if they are relevant to our renderer. The
// LookUpTextures function has added the normal map and specular map
// textures to the Textures collection, so that will be copied as well.
foreach (KeyValuePair<String, ExternalReference<TextureContent>> texture in material.Textures)
{
if (texture.Key.Contains("DiffuseMap") || texture.Key.Contains("Texture"))
deferredShadingMaterial.Textures.Add(texture.Key, texture.Value);
if (texture.Key.Contains("NormalMap"))
deferredShadingMaterial.Textures.Add(texture.Key, texture.Value);
if (texture.Key.Contains("SpecularMap"))
deferredShadingMaterial.Textures.Add(texture.Key, texture.Value);
if (texture.Key.Contains("EmissiveMap"))
deferredShadingMaterial.Textures.Add(texture.Key, texture.Value);
}
//extract the extra parameters
ExtractDefines(deferredShadingMaterial, material, context);
// Return material
return context.Convert<MaterialContent, MaterialContent>(deferredShadingMaterial, typeof(DeferredRendererMaterialProcessor).Name);
}
/// <summary>
/// builds an external reference to a texture
/// </summary>
internal static ExternalReference<TextureContent> BuildTexture(string file, ContentProcessorContext context)
{
ExternalReference<Texture2DContent> tex = new ExternalReference<Texture2DContent>(file);
tex.Name = Path.GetFileNameWithoutExtension(file);
CreateDictionaryIfNecessary();
//string extension = Path.GetExtension(file);
//UseBlackAsAlpha = extension.ToLower() == ".bmp";
//if (UseBlackAsAlpha)
//{
// TextureProcessor.ColorKeyColor = Color.Black;
// TextureProcessor.ColorKeyEnabled = true;
//}
//else
//{
// TextureProcessor.ColorKeyEnabled = false;
//}
return context.BuildAsset<Texture2DContent, TextureContent>(
tex,
typeof(TextureProcessor).Name,
dictionary,
"TextureImporter",
null // Passing null lets the content pipeline decide on the default name, which is what we want.
);
}
public static string BuildFontExternal(ContentProcessorContext context, string fontPath)
{
var dir = Path.GetDirectoryName(fontPath);
return Path.Combine(dir, Path.GetFileNameWithoutExtension(context.BuildAsset<FontDescription, SpriteFontContent>(new ExternalReference<FontDescription>(fontPath), "FontDescriptionProcessor").Filename));
}
