public void Import(CommandLineOptions options) { // Load the source bitmap. Bitmap bitmap; try { bitmap = new Bitmap(options.SourceFont); } catch { throw new Exception(string.Format("Unable to load '{0}'.", options.SourceFont)); } // Convert to our desired pixel format. bitmap = BitmapUtils.ChangePixelFormat(bitmap, PixelFormat.Format32bppArgb); // What characters are included in this font? var characters = CharacterRegion.Flatten(options.CharacterRegions).ToArray(); int characterIndex = 0; char currentCharacter = '\0'; // Split the source image into a list of individual glyphs. var glyphList = new List<Glyph>(); Glyphs = glyphList; LineSpacing = 0; foreach (Rectangle rectangle in FindGlyphs(bitmap)) { if (characterIndex < characters.Length) currentCharacter = characters[characterIndex++]; else currentCharacter++; glyphList.Add(new Glyph(currentCharacter, bitmap, rectangle)); LineSpacing = Math.Max(LineSpacing, rectangle.Height); } // If the bitmap doesn't already have an alpha channel, create one now. if (BitmapUtils.IsAlphaEntirely(255, bitmap)) { BitmapUtils.ConvertGreyToAlpha(bitmap); } }
public static void Main(string[] args) { var options = new CommandLineOptions(); if (!ConsoleProgram.ParseCommandLine(options, args, 32)) { Environment.Exit(-1); } MakeSpriteFont(options); }
static void MakeSpriteFont(CommandLineOptions options) { // Import. Console.WriteLine("Importing {0}", options.SourceFont); float lineSpacing; Glyph[] glyphs = ImportFont(options, out lineSpacing); // Optimize. Console.WriteLine("Cropping glyph borders"); foreach (Glyph glyph in glyphs) { GlyphCropper.Crop(glyph); } Console.WriteLine("Packing glyphs into sprite sheet"); Bitmap bitmap = GlyphPacker.ArrangeGlyphs(glyphs); // Adjust line and character spacing. lineSpacing += options.LineSpacing; foreach (Glyph glyph in glyphs) { glyph.XAdvance += options.CharacterSpacing; } // Automatically detect whether this is a monochromatic or color font? if (options.TextureFormat == TextureFormat.Auto) { bool isMono = BitmapUtils.IsRgbEntirely(Color.White, bitmap); options.TextureFormat = isMono ? TextureFormat.CompressedMono : TextureFormat.Rgba32; } // Convert to premultiplied alpha format. if (!options.NoPremultiply) { Console.WriteLine("Premultiplying alpha"); BitmapUtils.PremultiplyAlpha(bitmap); } // Save output files. if (!string.IsNullOrEmpty(options.DebugOutputSpriteSheet)) { Console.WriteLine("Saving debug output spritesheet {0}", options.DebugOutputSpriteSheet); bitmap.Save(options.DebugOutputSpriteSheet); } Console.WriteLine("Writing {0} ({1} format)", options.OutputFile, options.TextureFormat); SpriteFontWriter.WriteSpriteFont(options, glyphs, lineSpacing, bitmap); }
public void Import(CommandLineOptions options) { // Create a bunch of GDI+ objects. using (Font font = CreateFont(options)) using (Brush brush = new SolidBrush(Color.White)) using (StringFormat stringFormat = new StringFormat(StringFormatFlags.NoFontFallback)) using (Bitmap bitmap = new Bitmap(MaxGlyphSize, MaxGlyphSize, PixelFormat.Format32bppArgb)) using (System.Drawing.Graphics graphics = System.Drawing.Graphics.FromImage(bitmap)) { graphics.PixelOffsetMode = PixelOffsetMode.HighQuality; graphics.InterpolationMode = InterpolationMode.HighQualityBicubic; graphics.TextRenderingHint = TextRenderingHint.AntiAliasGridFit; // Which characters do we want to include? var characters = CharacterRegion.Flatten(options.CharacterRegions); var glyphList = new List<Glyph>(); // Rasterize each character in turn. foreach (char character in characters) { Glyph glyph = ImportGlyph(character, font, brush, stringFormat, bitmap, graphics); glyphList.Add(glyph); } Glyphs = glyphList; // Store the font height. LineSpacing = font.GetHeight(); } }
static Glyph[] ImportFont(CommandLineOptions options, out float lineSpacing) { // Which importer knows how to read this source font? IFontImporter importer; string fileExtension = Path.GetExtension(options.SourceFont).ToLowerInvariant(); string[] BitmapFileExtensions = { ".bmp", ".png", ".gif" }; if (BitmapFileExtensions.Contains(fileExtension)) { importer = new BitmapImporter(); } else { importer = new TrueTypeImporter(); } // Import the source font data. importer.Import(options); lineSpacing = importer.LineSpacing; var glyphs = importer.Glyphs .OrderBy(glyph => glyph.Character) .ToArray(); // Validate. if (glyphs.Length == 0) { throw new Exception("Font does not contain any glyphs."); } if ((options.DefaultCharacter != 0) && !glyphs.Any(glyph => glyph.Character == options.DefaultCharacter)) { throw new Exception("The specified DefaultCharacter is not part of this font."); } return glyphs; }
// Attempts to instantiate the requested GDI+ font object. static Font CreateFont(CommandLineOptions options) { Font font = new Font(options.SourceFont, PointsToPixels(options.FontSize), options.FontStyle, GraphicsUnit.Pixel); try { // The font constructor automatically substitutes fonts if it can't find the one requested. // But we prefer the caller to know if anything is wrong with their data. A simple string compare // isn't sufficient because some fonts (eg. MS Mincho) change names depending on the locale. // Early out: in most cases the name will match the current or invariant culture. if (options.SourceFont.Equals(font.FontFamily.GetName(CultureInfo.CurrentCulture.LCID), StringComparison.OrdinalIgnoreCase) || options.SourceFont.Equals(font.FontFamily.GetName(CultureInfo.InvariantCulture.LCID), StringComparison.OrdinalIgnoreCase)) { return font; } // Check the font name in every culture. foreach (CultureInfo culture in CultureInfo.GetCultures(CultureTypes.SpecificCultures)) { if (options.SourceFont.Equals(font.FontFamily.GetName(culture.LCID), StringComparison.OrdinalIgnoreCase)) { return font; } } // A font substitution must have occurred. throw new Exception(string.Format("Can't find font '{0}'.", options.SourceFont)); } catch { font.Dispose(); throw; } }
public static void WriteSpriteFont(CommandLineOptions options, Glyph[] glyphs, float lineSpacing, Bitmap bitmap) { using (FileStream file = File.OpenWrite(options.OutputFile)) using (BinaryWriter writer = new BinaryWriter(file)) { WriteMagic(writer); WriteGlyphs(writer, glyphs); writer.Write(lineSpacing); writer.Write(options.DefaultCharacter); WriteBitmap(writer, options, bitmap); } }
// We want to compress our font textures, because, like, smaller is better, // right? But a standard DXT compressor doesn't do a great job with fonts that // are in premultiplied alpha format. Our font data is greyscale, so all of the // RGBA channels have the same value. If one channel is compressed differently // to another, this causes an ugly variation in brightness of the rendered text. // Also, fonts are mostly either black or white, with grey values only used for // antialiasing along their edges. It is very important that the black and white // areas be accurately represented, while the precise value of grey is less // important. // // Trouble is, your average DXT compressor knows nothing about these // requirements. It will optimize to minimize a generic error metric such as // RMS, but this will often sacrifice crisp black and white in exchange for // needless accuracy of the antialiasing pixels, or encode RGB differently to // alpha. UGLY! // // Fortunately, encoding monochrome fonts turns out to be trivial. Using DXT3, // we can fix the end colors as black and white, which gives guaranteed exact // encoding of the font inside and outside, plus two fractional values for edge // antialiasing. Also, these RGB values (0, 1/3, 2/3, 1) map exactly to four of // the possible 16 alpha values available in DXT3, so we can ensure the RGB and // alpha channels always exactly match. static void CompressBlock(BinaryWriter writer, BitmapUtils.PixelAccessor bitmapData, int blockX, int blockY, CommandLineOptions options) { long alphaBits = 0; int rgbBits = 0; int pixelCount = 0; for (int y = 0; y < 4; y++) { for (int x = 0; x < 4; x++) { long alpha; int rgb; int value = bitmapData[blockX + x, blockY + y].A; if (options.NoPremultiply) { // If we are not premultiplied, RGB is always white and we have 4 bit alpha. alpha = value >> 4; rgb = 0; } else { // For premultiplied encoding, quantize the source value to 2 bit precision. if (value < 256 / 6) { alpha = 0; rgb = 1; } else if (value < 256 / 2) { alpha = 5; rgb = 3; } else if (value < 256 * 5 / 6) { alpha = 10; rgb = 2; } else { alpha = 15; rgb = 0; } } // Add this pixel to the alpha and RGB bit masks. alphaBits |= alpha << (pixelCount * 4); rgbBits |= rgb << (pixelCount * 2); pixelCount++; } } // Output the alpha bit mask. writer.Write(alphaBits); // Output the two endpoint colors (black and white in 5.6.5 format). writer.Write((ushort)0xFFFF); writer.Write((ushort)0); // Output the RGB bit mask. writer.Write(rgbBits); }
// Writes a block compressed monochromatic font texture. static void WriteCompressedMono(BinaryWriter writer, Bitmap bitmap, CommandLineOptions options) { if ((bitmap.Width & 3) != 0 || (bitmap.Height & 3) != 0) { throw new ArgumentException("Block compression requires texture size to be a multiple of 4."); } writer.Write(DXGI_FORMAT_BC2_UNORM); writer.Write(bitmap.Width * 4); writer.Write(bitmap.Height / 4); using (var bitmapData = new BitmapUtils.PixelAccessor(bitmap, ImageLockMode.ReadOnly)) { for (int y = 0; y < bitmap.Height; y += 4) { for (int x = 0; x < bitmap.Width; x += 4) { CompressBlock(writer, bitmapData, x, y, options); } } } }
static void WriteBitmap(BinaryWriter writer, CommandLineOptions options, Bitmap bitmap) { writer.Write(bitmap.Width); writer.Write(bitmap.Height); switch (options.TextureFormat) { case TextureFormat.Rgba32: WriteRgba32(writer, bitmap); break; case TextureFormat.Bgra4444: WriteBgra4444(writer, bitmap); break; case TextureFormat.CompressedMono: WriteCompressedMono(writer, bitmap, options); break; default: throw new NotSupportedException(); } }