internal static void ChangeTextureToRequestedFormat(TextureContent texture,
Type originalType,
TextureProcessorOutputFormat textureFormat)
{
switch (textureFormat)
{
case TextureProcessorOutputFormat.NoChange:
if (originalType == null)
{
break;
}
texture.ConvertBitmapType(originalType);
return;
case TextureProcessorOutputFormat.Color:
texture.ConvertBitmapType(typeof(PixelBitmapContent <Color>));
return;
case TextureProcessorOutputFormat.DxtCompressed:
BestGuessCompress(texture);
break;
default:
return;
}
}
protected override void PlatformCompressTexture(
ContentProcessorContext context, TextureContent content,
TextureProcessorOutputFormat format, bool isSpriteFont)
{
format = GetTextureFormatForPlatform(format, context.TargetPlatform);
// Make sure we're in a floating point format
content.ConvertBitmapType(typeof(PixelBitmapContent <RgbaVector>));
switch (format)
{
case TextureProcessorOutputFormat.AtcCompressed:
GraphicsUtil.CompressAti(content, isSpriteFont);
break;
case TextureProcessorOutputFormat.Color16Bit:
GraphicsUtil.CompressColor16Bit(content);
break;
case TextureProcessorOutputFormat.DxtCompressed:
GraphicsUtil.CompressDxt(context, content, isSpriteFont);
break;
case TextureProcessorOutputFormat.Etc1Compressed:
GraphicsUtil.CompressEtc1(context, content, isSpriteFont);
break;
case TextureProcessorOutputFormat.PvrCompressed:
GraphicsUtil.CompressPvrtc(context, content, isSpriteFont);
break;
}
}
internal static void ChangeTextureToRequestedFormat(TextureContent texture,
Type originalType,
TextureProcessorOutputFormat textureFormat)
{
switch (textureFormat)
{
case TextureProcessorOutputFormat.NoChange:
if (originalType == null)
{
break;
}
texture.ConvertBitmapType(originalType);
return;
case TextureProcessorOutputFormat.Color:
texture.ConvertBitmapType(typeof (PixelBitmapContent<Color>));
return;
case TextureProcessorOutputFormat.DxtCompressed:
BestGuessCompress(texture);
break;
default:
return;
}
}
public override TextureContent Process(TextureContent input, ContentProcessorContext context)
{
if (input == null)
{
throw new ArgumentNullException("input");
}
if (context == null)
{
throw new ArgumentNullException("context");
}
if (!this.ForceDXT5)
{
return(base.Process(input, context));
}
TextureContent ret = null;
TextureProcessorOutputFormat fmt = this.TextureFormat;
this.TextureFormat = TextureProcessorOutputFormat.NoChange;
try
{
ret = base.Process(input, context);
Type originalType = ret.Faces[0][0].GetType();
if (originalType != typeof(Dxt5BitmapContent))
{
ret.ConvertBitmapType(typeof(Dxt5BitmapContent));
}
}
finally
{
this.TextureFormat = fmt;
}
return(ret);
}
/// <summary>
/// Initializes a new instance of the MaterialProcessor class.
/// </summary>
public MaterialProcessor()
{
colorKeyColor = Color.Magenta;
colorKeyEnabled = true;
defaultEffect = MaterialProcessorDefaultEffect.BasicEffect;
generateMipmaps = false;
premultiplyTextureAlpha = true;
resizeTexturesToPowerOfTwo = true;
textureFormat = TextureProcessorOutputFormat.Color;
}
private static bool IsCompressedTextureFormat(TextureProcessorOutputFormat format)
{
switch (format)
{
case TextureProcessorOutputFormat.AtcCompressed:
case TextureProcessorOutputFormat.DxtCompressed:
case TextureProcessorOutputFormat.Etc1Compressed:
case TextureProcessorOutputFormat.PvrCompressed:
return(true);
}
return(false);
}
public TextureAtlasProcessor()
{
Pack = true;
RowCount = 1;
ColumnCount = 1;
ColorKey = new Color(255, 0, 255, 255);
ColorKeyEnabled = true;
GenerateMipmaps = false;
PremultiplyAlpha = true;
ResizeToPowerOfTwo = false;
TextureFormat = TextureProcessorOutputFormat.Color;
}
private static TextureProcessorOutputFormat GetTextureFormatForPlatform(
TextureProcessorOutputFormat format, TargetPlatform platform)
{
// Select the default texture compression format for the target platform
if (format == TextureProcessorOutputFormat.Compressed)
{
if (platform == TargetPlatform.iOS)
{
format = TextureProcessorOutputFormat.PvrCompressed;
}
else if (platform == TargetPlatform.Android)
{
format = TextureProcessorOutputFormat.Etc1Compressed;
}
else
{
format = TextureProcessorOutputFormat.DxtCompressed;
}
}
if (IsCompressedTextureFormat(format))
{
// Make sure the target platform supports the selected texture compression format
if (platform == TargetPlatform.iOS)
{
if (format != TextureProcessorOutputFormat.PvrCompressed)
{
throw new PlatformNotSupportedException(
"iOS platform only supports PVR texture compression.");
}
}
else if (
platform == TargetPlatform.Windows ||
platform == TargetPlatform.WindowsPhone8 ||
platform == TargetPlatform.WindowsStoreApp ||
platform == TargetPlatform.DesktopGL ||
platform == TargetPlatform.MacOSX ||
platform == TargetPlatform.NativeClient ||
platform == TargetPlatform.Web)
{
if (format != TextureProcessorOutputFormat.DxtCompressed)
{
throw new PlatformNotSupportedException(
platform + " platform only supports DXT texture compression.");
}
}
}
return(format);
}
/// <summary>
/// If format is TextureProcessorOutputFormat.Compressed, the appropriate compressed texture format for the target
/// platform is returned. Otherwise the format is returned unchanged.
/// </summary>
/// <param name="format">The supplied texture format.</param>
/// <param name="platform">The target platform.</param>
/// <returns>The texture format.</returns>
public static TextureProcessorOutputFormat GetTextureFormatForPlatform(TextureProcessorOutputFormat format, TargetPlatform platform)
{
// Select the default texture compression format for the target platform
if (format == TextureProcessorOutputFormat.Compressed)
{
switch (platform)
{
case TargetPlatform.iOS:
format = TextureProcessorOutputFormat.PvrCompressed;
break;
case TargetPlatform.Android:
format = TextureProcessorOutputFormat.Etc1Compressed;
break;
default:
format = TextureProcessorOutputFormat.DxtCompressed;
break;
}
}
if (IsCompressedTextureFormat(format))
{
// Make sure the target platform supports the selected texture compression format
switch (platform)
{
case TargetPlatform.iOS:
if (format != TextureProcessorOutputFormat.PvrCompressed)
{
throw new PlatformNotSupportedException("iOS platform only supports PVR texture compression");
}
break;
case TargetPlatform.Windows:
case TargetPlatform.WindowsPhone8:
case TargetPlatform.WindowsStoreApp:
case TargetPlatform.DesktopGL:
case TargetPlatform.MacOSX:
case TargetPlatform.NativeClient:
if (format != TextureProcessorOutputFormat.DxtCompressed)
{
throw new PlatformNotSupportedException(platform.ToString() + " platform only supports DXT texture compression");
}
break;
}
}
return(format);
}
/// <summary>
/// Determines if the given texture format requires equal width and height on the target platform.
/// </summary>
/// <param name="format">The texture format.</param>
/// <param name="platform">The target platform.</param>
/// <returns>True if the texture format requires equal width and height on the target platform.</returns>
public static bool RequiresSquare(TextureProcessorOutputFormat format, TargetPlatform platform)
{
if (format == TextureProcessorOutputFormat.Compressed)
{
format = GetTextureFormatForPlatform(format, platform);
}
switch (format)
{
case TextureProcessorOutputFormat.PvrCompressed:
return(true);
}
return(false);
}
/// <summary>
/// Performs conversion of the texture content to the correct format.
/// </summary>
/// <param name="context">The processor context.</param>
/// <param name="content">The content to be compressed.</param>
/// <param name="format">The user requested format for compression.</param>
/// <param name="isSpriteFont">If the texture has represents a sprite font, i.e. is greyscale and has sharp black/white contrast.</param>
public void ConvertTexture(
ContentProcessorContext context, TextureContent content, TextureProcessorOutputFormat format, bool isSpriteFont)
{
// We do nothing in this case.
if (format == TextureProcessorOutputFormat.NoChange)
{
return;
}
// If this is color just make sure the format is right and return it.
if (format == TextureProcessorOutputFormat.Color)
{
content.ConvertBitmapType(typeof(PixelBitmapContent <Color>));
return;
}
// Handle this common compression format.
if (format == TextureProcessorOutputFormat.Color16Bit)
{
GraphicsUtil.CompressColor16Bit(content);
return;
}
try
{
// All other formats require platform specific choices.
PlatformCompressTexture(context, content, format, isSpriteFont);
}
catch (EntryPointNotFoundException ex)
{
context.Logger.LogImportantMessage("Could not find the entry point to compress the texture. " + ex.ToString());
throw;
}
catch (DllNotFoundException ex)
{
context.Logger.LogImportantMessage("Could not compress texture. Required shared lib is missing. " + ex.ToString());
throw;
}
catch (Exception ex)
{
context.Logger.LogImportantMessage("Could not convert texture. " + ex.ToString());
throw;
}
}
/// <summary>
/// Determines if the texture format requires power-of-two dimensions on the target platform.
/// </summary>
/// <param name="format">The texture format.</param>
/// <param name="platform">The target platform.</param>
/// <param name="profile">The targeted graphics profile.</param>
/// <returns>True if the texture format requires power-of-two dimensions on the target platform.</returns>
public static bool RequiresPowerOfTwo(TextureProcessorOutputFormat format, TargetPlatform platform, GraphicsProfile profile)
{
if (format == TextureProcessorOutputFormat.Compressed)
{
format = GetTextureFormatForPlatform(format, platform);
}
switch (format)
{
case TextureProcessorOutputFormat.DxtCompressed:
return(profile == GraphicsProfile.Reach);
case TextureProcessorOutputFormat.PvrCompressed:
case TextureProcessorOutputFormat.Etc1Compressed:
return(true);
}
return(false);
}
public override void Requirements(
ContentProcessorContext context, TextureProcessorOutputFormat format,
out bool requiresPowerOfTwo, out bool requiresSquare)
{
if (format == TextureProcessorOutputFormat.Compressed)
{
format = GetTextureFormatForPlatform(format, context.TargetPlatform);
}
// Does it require POT textures?
switch (format)
{
default:
requiresPowerOfTwo = false;
break;
case TextureProcessorOutputFormat.DxtCompressed:
requiresPowerOfTwo = context.TargetProfile == GraphicsProfile.Reach;
break;
case TextureProcessorOutputFormat.PvrCompressed:
case TextureProcessorOutputFormat.Etc1Compressed:
requiresPowerOfTwo = true;
break;
}
// Does it require square textures?
switch (format)
{
default:
requiresSquare = false;
break;
case TextureProcessorOutputFormat.PvrCompressed:
requiresSquare = true;
break;
}
}
/// <summary> /// Determines if the texture format will require power-of-two dimensions and/or equal width and height. /// </summary> /// <param name="context">The processor context.</param> /// <param name="format">The desired texture format.</param> /// <param name="requiresPowerOfTwo">True if the texture format requires power-of-two dimensions.</param> /// <param name="requiresSquare">True if the texture format requires equal width and height.</param> /// <returns>True if the texture format requires power-of-two dimensions.</returns> public abstract void Requirements(ContentProcessorContext context, TextureProcessorOutputFormat format, out bool requiresPowerOfTwo, out bool requiresSquare);
protected abstract void PlatformCompressTexture(ContentProcessorContext context, TextureContent content, TextureProcessorOutputFormat format, bool generateMipmaps, bool isSpriteFont);
/// <summary>
/// Returns true if the format is a compressed format.
/// </summary>
/// <param name="format">The texture processor output format.</param>
/// <returns>True if the format is a compressed format.</returns>
public static bool IsCompressedTextureFormat(TextureProcessorOutputFormat format)
{
switch (format)
{
case TextureProcessorOutputFormat.AtcCompressed:
case TextureProcessorOutputFormat.DxtCompressed:
case TextureProcessorOutputFormat.Etc1Compressed:
case TextureProcessorOutputFormat.PvrCompressed:
return true;
}
return false;
}
public DDSProcessor()
{
GenerateMipmaps = true;
TextureFormat = TextureProcessorOutputFormat.NoChange;
}
public FontDescriptionProcessor()
{
this.TextureFormat = TextureProcessorOutputFormat.Compressed;
}
public override TextureContent Process(TextureContent input, ContentProcessorContext context)
{
var bmp = input.Faces[0][0];
if (ColorKeyEnabled)
{
var data = bmp.GetPixelData();
var idx = 0;
for (; idx < data.Length;)
{
var r = data[idx + 0];
var g = data[idx + 1];
var b = data[idx + 2];
var a = data[idx + 3];
var col = new Color(r, g, b, a);
if (col.Equals(ColorKeyColor))
{
data[idx + 0] = 0;
data[idx + 1] = 0;
data[idx + 2] = 0;
data[idx + 3] = 0;
}
idx += 4;
}
bmp.SetPixelData(data);
}
if (ResizeToPowerOfTwo)
{
if (!GraphicsUtil.IsPowerOfTwo(bmp.Width) || !GraphicsUtil.IsPowerOfTwo(bmp.Height))
{
input.Resize(GraphicsUtil.GetNextPowerOfTwo(bmp.Width), GraphicsUtil.GetNextPowerOfTwo(bmp.Height));
bmp = input.Faces[0][0];
}
}
if (PremultiplyAlpha)
{
var data = bmp.GetPixelData();
var idx = 0;
for (; idx < data.Length;)
{
var r = data[idx + 0];
var g = data[idx + 1];
var b = data[idx + 2];
var a = data[idx + 3];
var col = Color.FromNonPremultiplied(r, g, b, a);
data[idx + 0] = col.R;
data[idx + 1] = col.G;
data[idx + 2] = col.B;
data[idx + 3] = col.A;
idx += 4;
}
bmp.SetPixelData(data);
}
if (TextureFormat == TextureProcessorOutputFormat.NoChange)
{
return(input);
}
try
{
if (TextureFormat == TextureProcessorOutputFormat.DxtCompressed ||
TextureFormat == TextureProcessorOutputFormat.Compressed)
{
GraphicsUtil.CompressTexture(context.TargetProfile, input, context, GenerateMipmaps, PremultiplyAlpha, false);
}
}
catch (EntryPointNotFoundException ex) {
context.Logger.LogImportantMessage("Could not find the entry point to compress the texture", ex.ToString());
TextureFormat = TextureProcessorOutputFormat.Color;
}
catch (DllNotFoundException ex) {
context.Logger.LogImportantMessage("Could not compress texture. Required shared lib is missing. {0}", ex.ToString());
TextureFormat = TextureProcessorOutputFormat.Color;
}
catch (Exception ex)
{
context.Logger.LogImportantMessage("Could not compress texture {0}", ex.ToString());
TextureFormat = TextureProcessorOutputFormat.Color;
}
if (GenerateMipmaps)
{
context.Logger.LogMessage("Generating mipmaps.");
input.GenerateMipmaps(false);
}
return(input);
}
private CompilerResults CompilePlugin(string filepath)
{
bool hasCs = System.IO.Directory.GetFiles(filepath).Any(item => FileManager.GetDirectory(item) == "cs");
if (!hasCs)
{
return(null);
}
CompilePluginOutput("Attempting to compile plugin : " + filepath);
//Reference types to force assembly load
const TextureProcessorOutputFormat texture = TextureProcessorOutputFormat.Color;
using (new ZipFile()) { }
texture.ToString();// We do this to eliminate "is never used" warnings
string whyIsntCompatible = GetWhyIsntCompatible(filepath);
if (string.IsNullOrEmpty(whyIsntCompatible))
{
LoadExternalReferenceList(filepath);
string output;
string name = Assembly.GetEntryAssembly().GetName().Name;
PluginCompiler.Compiler.Path = System.IO.Path.GetTempPath() + name + @"Compiled\";
string details;
// need to fix this, or pass it a root folder or something.
CompilerResults results = PluginCompiler.Compiler.CompilePlugin(
filepath,
mReferenceListInternal,
mReferenceListLoaded,
mReferenceListExternal,
out details);
// Make sure a non-null result was returned
if (results == null)
{
return(null);
}
string outputString = "";
foreach (string s in results.Output)
{
outputString += s + " ";
}
string errorString = "";
foreach (var s in results.Errors)
{
errorString += s.ToString() + " ";
}
if (!results.Errors.HasErrors && results.CompiledAssembly != null)
{
Type[] types = results.CompiledAssembly.GetTypes();
bool foundAnExportedType = false;
foreach (Type type in types)
{
var attributes = type.GetCustomAttributes(typeof(ExportAttribute), true);
if (attributes != null && attributes.Length > 0)
{
foundAnExportedType = true;
break;
}
}
if (!foundAnExportedType)
{
CompilePluginError("Could not find any plugins with the [Export] tag for plugin than " + filepath);
}
}
string message = null;
// I don't think we care about this anymore - it just clutters output a ton
//"Plugin compile output: " + outputString;
if (!string.IsNullOrEmpty(errorString))
{
message += "Compile errors: " + errorString;
}
CompilePluginError(message);
return(results);
}
else
{
CompilePluginOutput("Error on plugin in folder " + filepath + " : " + whyIsntCompatible);
}
return(null);
}
public FontDescriptionProcessor()
{
PremultiplyAlpha = true;
TextureFormat = TextureProcessorOutputFormat.Compressed;
}
public override TextureContent Process(TextureContent input, ContentProcessorContext context)
{
if (ColorKeyEnabled)
{
var replaceColor = System.Drawing.Color.FromArgb(0);
for (var x = 0; x < input._bitmap.Width; x++)
{
for (var y = 0; y < input._bitmap.Height; y++)
{
var col = input._bitmap.GetPixel(x, y);
if (col.ColorsEqual(ColorKeyColor))
{
input._bitmap.SetPixel(x, y, replaceColor);
}
}
}
}
var face = input.Faces[0][0];
if (ResizeToPowerOfTwo)
{
if (!GraphicsUtil.IsPowerOfTwo(face.Width) || !GraphicsUtil.IsPowerOfTwo(face.Height))
{
input.Resize(GraphicsUtil.GetNextPowerOfTwo(face.Width), GraphicsUtil.GetNextPowerOfTwo(face.Height));
}
}
if (PremultiplyAlpha)
{
for (var x = 0; x < input._bitmap.Width; x++)
{
for (var y = 0; y < input._bitmap.Height; y++)
{
var oldCol = input._bitmap.GetPixel(x, y);
var preMultipliedColor = Color.FromNonPremultiplied(oldCol.R, oldCol.G, oldCol.B, oldCol.A);
input._bitmap.SetPixel(x, y, System.Drawing.Color.FromArgb(preMultipliedColor.A,
preMultipliedColor.R,
preMultipliedColor.G,
preMultipliedColor.B));
}
}
}
// Set the first layer
input.Faces[0][0].SetPixelData(input._bitmap.GetData());
if (TextureFormat == TextureProcessorOutputFormat.NoChange)
{
return(input);
}
try
{
if (TextureFormat == TextureProcessorOutputFormat.DXTCompressed ||
TextureFormat == TextureProcessorOutputFormat.Compressed)
{
context.Logger.LogMessage("Compressing using {0}", TextureFormat);
}
GraphicsUtil.CompressTexture(input, context, GenerateMipmaps, PremultiplyAlpha);
context.Logger.LogMessage("Compression {0} Suceeded", TextureFormat);
}
catch (EntryPointNotFoundException ex) {
context.Logger.LogImportantMessage("Could not find the entry point to compress the texture", ex.ToString());
TextureFormat = TextureProcessorOutputFormat.Color;
}
catch (DllNotFoundException ex) {
context.Logger.LogImportantMessage("Could not compress texture. Required shared lib is missing. {0}", ex.ToString());
TextureFormat = TextureProcessorOutputFormat.Color;
}
catch (Exception ex)
{
context.Logger.LogImportantMessage("Could not compress texture {0}", ex.ToString());
TextureFormat = TextureProcessorOutputFormat.Color;
}
return(input);
}
public LocalizedFontProcessor()
{
PremultiplyAlpha = true;
TextureFormat = TextureProcessorOutputFormat.Compressed;
}
/// <summary>
/// If format is TextureProcessorOutputFormat.Compressed, the appropriate compressed texture format for the target
/// platform is returned. Otherwise the format is returned unchanged.
/// </summary>
/// <param name="format">The supplied texture format.</param>
/// <param name="platform">The target platform.</param>
/// <returns>The texture format.</returns>
public static TextureProcessorOutputFormat GetTextureFormatForPlatform(TextureProcessorOutputFormat format, TargetPlatform platform)
{
// Select the default texture compression format for the target platform
if (format == TextureProcessorOutputFormat.Compressed)
{
switch (platform)
{
case TargetPlatform.iOS:
format = TextureProcessorOutputFormat.PvrCompressed;
break;
case TargetPlatform.Android:
format = TextureProcessorOutputFormat.Etc1Compressed;
break;
default:
format = TextureProcessorOutputFormat.DxtCompressed;
break;
}
}
if (IsCompressedTextureFormat(format))
{
// Make sure the target platform supports the selected texture compression format
switch (platform)
{
case TargetPlatform.iOS:
if (format != TextureProcessorOutputFormat.PvrCompressed)
throw new PlatformNotSupportedException("iOS platform only supports PVR texture compression");
break;
case TargetPlatform.Windows:
case TargetPlatform.WindowsPhone8:
case TargetPlatform.WindowsStoreApp:
case TargetPlatform.DesktopGL:
case TargetPlatform.MacOSX:
case TargetPlatform.NativeClient:
if (format != TextureProcessorOutputFormat.DxtCompressed)
throw new PlatformNotSupportedException(platform.ToString() + " platform only supports DXT texture compression");
break;
}
}
return format;
}
/// <summary>
/// Compresses TextureContent in a format appropriate to the platform
/// </summary>
public static void CompressTexture(GraphicsProfile profile, TextureContent content, TextureProcessorOutputFormat format, ContentProcessorContext context, bool generateMipmaps, bool sharpAlpha)
{
format = GetTextureFormatForPlatform(format, context.TargetPlatform);
// Make sure we're in a floating point format
content.ConvertBitmapType(typeof(PixelBitmapContent<Vector4>));
switch (format)
{
case TextureProcessorOutputFormat.AtcCompressed:
CompressAti(content, generateMipmaps);
break;
case TextureProcessorOutputFormat.Color16Bit:
CompressColor16Bit(content, generateMipmaps);
break;
case TextureProcessorOutputFormat.DxtCompressed:
CompressDxt(profile, content, generateMipmaps, sharpAlpha);
break;
case TextureProcessorOutputFormat.Etc1Compressed:
CompressEtc1(content, generateMipmaps);
break;
case TextureProcessorOutputFormat.PvrCompressed:
CompressPvrtc(content, generateMipmaps);
break;
}
}
/// <summary>
/// Determines if the texture format requires power-of-two dimensions on the target platform.
/// </summary>
/// <param name="format">The texture format.</param>
/// <param name="platform">The target platform.</param>
/// <param name="profile">The targeted graphics profile.</param>
/// <returns>True if the texture format requires power-of-two dimensions on the target platform.</returns>
public static bool RequiresPowerOfTwo(TextureProcessorOutputFormat format, TargetPlatform platform, GraphicsProfile profile)
{
if (format == TextureProcessorOutputFormat.Compressed)
format = GetTextureFormatForPlatform(format, platform);
switch (format)
{
case TextureProcessorOutputFormat.DxtCompressed:
return profile == GraphicsProfile.Reach;
case TextureProcessorOutputFormat.PvrCompressed:
case TextureProcessorOutputFormat.Etc1Compressed:
return true;
}
return false;
}
/// <summary>
/// Compresses TextureContent in a format appropriate to the platform
/// </summary>
public static void CompressTexture(GraphicsProfile profile, TextureContent content, TextureProcessorOutputFormat format, ContentProcessorContext context, bool generateMipmaps, bool sharpAlpha)
{
format = GetTextureFormatForPlatform(format, context.TargetPlatform);
// Make sure we're in a floating point format
content.ConvertBitmapType(typeof(PixelBitmapContent <Vector4>));
switch (format)
{
case TextureProcessorOutputFormat.AtcCompressed:
CompressAti(content, generateMipmaps);
break;
case TextureProcessorOutputFormat.Color16Bit:
CompressColor16Bit(content, generateMipmaps);
break;
case TextureProcessorOutputFormat.DxtCompressed:
CompressDxt(profile, content, generateMipmaps, sharpAlpha);
break;
case TextureProcessorOutputFormat.Etc1Compressed:
CompressEtc1(content, generateMipmaps);
break;
case TextureProcessorOutputFormat.PvrCompressed:
CompressPvrtc(content, generateMipmaps);
break;
}
}
/// <summary>
/// Determines if the given texture format requires equal width and height on the target platform.
/// </summary>
/// <param name="format">The texture format.</param>
/// <param name="platform">The target platform.</param>
/// <returns>True if the texture format requires equal width and height on the target platform.</returns>
public static bool RequiresSquare(TextureProcessorOutputFormat format, TargetPlatform platform)
{
if (format == TextureProcessorOutputFormat.Compressed)
format = GetTextureFormatForPlatform(format, platform);
switch (format)
{
case TextureProcessorOutputFormat.PvrCompressed:
return true;
}
return false;
}
public void BuildLocalizedFont(TargetPlatform platform, TextureProcessorOutputFormat format)
{
var context = new TestProcessorContext(platform, "Localized.xnb");
var processor = new LocalizedFontProcessor()
{
TextureFormat = format,
PremultiplyAlpha = true,
};
LocalizedFontDescription fontDescription = null;
using (var fs = File.OpenRead(Path.Combine("Assets", "Fonts", "Localized.spritefont")))
using (var input = XmlReader.Create(new StreamReader(fs)))
fontDescription = IntermediateSerializer.Deserialize <LocalizedFontDescription>(input, "");
fontDescription.Identity = new ContentIdentity("Localized.spritefont");
var output = processor.Process(fontDescription, context);
Assert.IsNotNull(output, "output should not be null");
Assert.IsNotNull(output.Texture, "output.Texture should not be null");
var textureType = output.Texture.Faces[0][0].GetType();
switch (format)
{
case TextureProcessorOutputFormat.Color:
Assert.IsTrue(textureType == typeof(PixelBitmapContent <Color>));
break;
case TextureProcessorOutputFormat.Color16Bit:
Assert.IsTrue(textureType == typeof(PixelBitmapContent <Microsoft.Xna.Framework.Graphics.PackedVector.Bgr565>));
break;
case TextureProcessorOutputFormat.Compressed:
switch (platform)
{
case TargetPlatform.Windows:
case TargetPlatform.DesktopGL:
Assert.IsTrue(textureType == typeof(Dxt3BitmapContent));
break;
case TargetPlatform.iOS:
Assert.IsTrue(textureType == typeof(PixelBitmapContent <Microsoft.Xna.Framework.Graphics.PackedVector.Bgra4444>));
break;
case TargetPlatform.Android:
Assert.IsTrue(textureType == typeof(PixelBitmapContent <Microsoft.Xna.Framework.Graphics.PackedVector.Bgra4444>));
break;
}
break;
case TextureProcessorOutputFormat.PvrCompressed:
// because the font is not power of 2 we should use Brga4444
Assert.IsTrue(textureType == typeof(PixelBitmapContent <Microsoft.Xna.Framework.Graphics.PackedVector.Bgra4444>));
break;
case TextureProcessorOutputFormat.Etc1Compressed:
// because the font has Alpha we should use Brga4444
Assert.IsTrue(textureType == typeof(PixelBitmapContent <Microsoft.Xna.Framework.Graphics.PackedVector.Bgra4444>));
break;
default:
Assert.Fail("Test not written for " + format);
break;
}
}