public void Build(
GlyphTextureBitmapGenerator glyphTextureGen,
Typeface typeface, float fontSizeInPoints,
TextureKind textureKind,
GlyphTextureBuildDetail[] buildDetails)
{
#if DEBUG
//overall, glyph atlas generation time
System.Diagnostics.Stopwatch dbugStopWatch = new System.Diagnostics.Stopwatch();
dbugStopWatch.Start();
#endif
var atlasBuilder = new SimpleBitmapAtlasBuilder();
glyphTextureGen.CreateTextureFontFromBuildDetail(
atlasBuilder,
typeface,
fontSizeInPoints,
textureKind,
buildDetails);
//3. set information before write to font-info
atlasBuilder.SpaceCompactOption = SimpleBitmapAtlasBuilder.CompactOption.ArrangeByHeight;
atlasBuilder.SetAtlasFontInfo(typeface.Name, fontSizeInPoints);
//4. merge all glyph in the builder into a single image
using (MemBitmap totalGlyphsImg = atlasBuilder.BuildSingleImage(true))
{
if (TextureInfoFilename == null)
{
//use random suffix
string random_suffix = Guid.NewGuid().ToString().Substring(0, 7);
string textureName = typeface.Name.ToLower() + "_" + random_suffix + ".info";
string output_imgFilename = textureName + ".png";
TextureInfoFilename = textureName;
OutputImgFilename = output_imgFilename;
}
//5. save atlas info to disk
using (FileStream fs = new FileStream(TextureInfoFilename, FileMode.Create))
{
atlasBuilder.SaveAtlasInfo(fs);
}
//6. save total-glyph-image to disk
totalGlyphsImg.SaveImage(OutputImgFilename);
}
#if DEBUG
dbugStopWatch.Stop();
dbugBuildTimeMillisec = dbugStopWatch.ElapsedMilliseconds;
#endif
}
static void CreateSampleMsdfTextureFont(string fontfile, float sizeInPoint, ushort startGlyphIndex, ushort endGlyphIndex, string outputFile)
{
//sample
var reader = new OpenFontReader();
Typeface typeface = null;
using (var fs = new FileStream(fontfile, FileMode.Open))
{
//1. read typeface from font file
typeface = reader.Read(fs);
}
//sample: create sample msdf texture
//-------------------------------------------------------------
var builder = new GlyphOutlineBuilder(typeface);
//builder.UseTrueTypeInterpreter = this.chkTrueTypeHint.Checked;
//builder.UseVerticalHinting = this.chkVerticalHinting.Checked;
//-------------------------------------------------------------
RequestFont reqFont = new RequestFont(typeface.Name, sizeInPoint);
var atlasBuilder = new SimpleBitmapAtlasBuilder();
atlasBuilder.FontFilename = System.IO.Path.GetFileName(fontfile);
atlasBuilder.FontKey = reqFont.FontKey;
//create temp folder for each glyph
string tempFolderName = "tmp_msdf";
if (Directory.Exists(tempFolderName))
{
//DANGER!
Directory.Delete(tempFolderName, true);
}
Directory.CreateDirectory(tempFolderName);
if (endGlyphIndex < 1)
{
endGlyphIndex = (ushort)(typeface.GlyphCount - 1);
}
for (ushort gindex = startGlyphIndex; gindex <= endGlyphIndex; ++gindex)
{
//build glyph
builder.BuildFromGlyphIndex(gindex, sizeInPoint);
var glyphContourBuilder = new ContourBuilder();
//glyphToContour.Read(builder.GetOutputPoints(), builder.GetOutputContours());
var genParams = new MsdfGenParams();
builder.ReadShapes(new GlyphContourBuilder2(glyphContourBuilder));
//genParams.shapeScale = 1f / 64; //we scale later (as original C++ code use 1/64)
BitmapAtlasItemSource glyphImg = MsdfImageGen.CreateMsdfImageV1(glyphContourBuilder, genParams);
glyphImg.UniqueInt16Name = gindex;
atlasBuilder.AddItemSource(glyphImg);
using (Bitmap bmp = new Bitmap(glyphImg.Width, glyphImg.Height, System.Drawing.Imaging.PixelFormat.Format32bppArgb))
{
int[] buffer = glyphImg.GetImageBuffer();
var bmpdata = bmp.LockBits(new System.Drawing.Rectangle(0, 0, glyphImg.Width, glyphImg.Height), System.Drawing.Imaging.ImageLockMode.ReadWrite, bmp.PixelFormat);
System.Runtime.InteropServices.Marshal.Copy(buffer, 0, bmpdata.Scan0, buffer.Length);
bmp.UnlockBits(bmpdata);
bmp.Save(tempFolderName + "//glyph_" + gindex + ".png");
}
}
MemBitmap glyphImg2 = atlasBuilder.BuildSingleImage(true);
glyphImg2.SaveImage(outputFile);
string saveToFile = "a_info.bin";
using (System.IO.FileStream saveFs = new FileStream(saveToFile, FileMode.Create))
{
atlasBuilder.SaveAtlasInfo(saveFs);
saveFs.Flush();
saveFs.Close();
}
//
//-----------
//test read texture info back
var atlasBuilder2 = new SimpleBitmapAtlasBuilder();
using (System.IO.FileStream readFromFs = new FileStream(saveToFile, FileMode.Open))
{
var readbackFontAtlas = atlasBuilder2.LoadAtlasInfo(readFromFs);
}
}
public static void Test(string imgdir, Func <string, MemBitmap> imgLoader)
{
SimpleBitmapAtlasBuilder bmpAtlasBuilder = new SimpleBitmapAtlasBuilder();
//test!
int imgdirNameLen = imgdir.Length;
string[] filenames = System.IO.Directory.GetFiles(imgdir, "*.png");
ushort index = 0;
Dictionary <string, ushort> imgDic = new Dictionary <string, ushort>();
foreach (string f in filenames)
{
MemBitmap itemBmp = imgLoader(f);
AtlasItemImage atlasItem = new AtlasItemImage(itemBmp.Width, itemBmp.Height);
atlasItem.OriginalBounds = new PixelFarm.Drawing.RectangleF(0, 0, itemBmp.Width, itemBmp.Height);
atlasItem.SetBitmap(itemBmp, false);
//
bmpAtlasBuilder.AddAtlasItemImage(index, atlasItem);
string imgPath = f.Substring(imgdirNameLen);
imgDic.Add(imgPath, index);
index++;
//------------
#if DEBUG
if (index >= ushort.MaxValue)
{
throw new NotSupportedException();
}
#endif
//------------
}
//string atlasInfoFile = "d:\\WImageTest\\test1_atlas.info";
//string totalImgFile = "d:\\WImageTest\\test1_atlas.png";
string atlasInfoFile = "test1_atlas.info";
string totalImgFile = "test1_atlas.png";
//test, write data to disk
AtlasItemImage totalImg = bmpAtlasBuilder.BuildSingleImage();
bmpAtlasBuilder.ImgUrlDict = imgDic;
bmpAtlasBuilder.SetAtlasInfo(TextureKind.Bitmap);
bmpAtlasBuilder.SaveAtlasInfo(atlasInfoFile); //save to filename
totalImg.Bitmap.SaveImage(totalImgFile);
//-----
//test, read data back
bmpAtlasBuilder = new SimpleBitmapAtlasBuilder();
SimpleBitmaptAtlas bitmapAtlas = bmpAtlasBuilder.LoadAtlasInfo(atlasInfoFile);
//
MemBitmap totalAtlasImg = imgLoader(totalImgFile);
AtlasItemImage atlasImg = new AtlasItemImage(totalAtlasImg.Width, totalAtlasImg.Height);
bitmapAtlas.TotalImg = atlasImg;
for (int i = 0; i < index; ++i)
{
if (bitmapAtlas.TryGetBitmapMapData((ushort)i, out BitmapMapData bmpMapData))
{
//test copy data from bitmap
MemBitmap itemImg = totalAtlasImg.CopyImgBuffer(bmpMapData.Left, bmpMapData.Top, bmpMapData.Width, bmpMapData.Height);
itemImg.SaveImage("test1_atlas_item" + i + ".png");
}
}
//test,
{
if (bitmapAtlas.TryGetBitmapMapData(@"\chk_checked.png", out BitmapMapData bmpMapData))
{
MemBitmap itemImg = totalAtlasImg.CopyImgBuffer(bmpMapData.Left, bmpMapData.Top, bmpMapData.Width, bmpMapData.Height);
itemImg.SaveImage("test1_atlas_item_a.png");
}
}
}
public static void BuildBitmapAtlas(AtlasProject atlasProj, Func <string, MemBitmap> imgLoader, bool test_extract = false)
{
//demonstrate how to build a bitmap atlas
List <AtlasItemSourceFile> fileList = atlasProj.Items;
//1. create builder
var bmpAtlasBuilder = new SimpleBitmapAtlasBuilder();
ushort index = 0;
Dictionary <string, ushort> imgDic = new Dictionary <string, ushort>();
foreach (AtlasItemSourceFile f in fileList)
{
if (f.Kind != AtlasItemSourceKind.Image)
{
continue;
}
//3. load a bitmap
BitmapAtlasItemSource atlasItem = null;
using (MemBitmap itemBmp = imgLoader(f.AbsoluteFilename))
{
//4. get information about it
atlasItem = new BitmapAtlasItemSource(itemBmp.Width, itemBmp.Height);
atlasItem.SetImageBuffer(MemBitmap.CopyImgBuffer(itemBmp));
}
atlasItem.UniqueInt16Name = index;
//5. add to builder
bmpAtlasBuilder.AddItemSource(atlasItem);
//get relative filename
string imgPath = "//" + f.Link;
imgDic.Add(imgPath, index);
index++;
//------------
#if DEBUG
if (index >= ushort.MaxValue)
{
throw new NotSupportedException();
}
#endif
//------------
}
if (imgDic.Count == 0)
{
//no file
return;
}
string atlasInfoFile = atlasProj.OutputFilename + ".info";
string totalImgFile = atlasProj.OutputFilename + ".png";
//5. merge all small images into a bigone
using (MemBitmap totalImg = bmpAtlasBuilder.BuildSingleImage(false))
{
bmpAtlasBuilder.ImgUrlDict = imgDic;
bmpAtlasBuilder.SetAtlasInfo(TextureKind.Bitmap, 0); //font size
//6. save atlas info and total-img (.png file)
bmpAtlasBuilder.SaveAtlasInfo(atlasInfoFile);
totalImg.SaveImage(totalImgFile);
}
//----------------------
//7. create an atlas file in a source file version, user can embed the source to file
//easy, just read .info and .png then convert to binary buffer
BuildAtlasInEmbededSourceVersion(atlasProj, atlasInfoFile, totalImgFile, imgDic);
//----------------------
//test, read data back
//----------------------
if (test_extract)
{
bmpAtlasBuilder = new SimpleBitmapAtlasBuilder();
SimpleBitmapAtlas bitmapAtlas = bmpAtlasBuilder.LoadAtlasInfo(atlasInfoFile)[0];
//
MemBitmap totalAtlasImg = imgLoader(totalImgFile);
bitmapAtlas.SetMainBitmap(imgLoader(totalImgFile), true);
//-----
for (int i = 0; i < index; ++i)
{
if (bitmapAtlas.TryGetItem((ushort)i, out AtlasItem bmpMapData))
{
//test copy data from bitmap
MemBitmap itemImg = totalAtlasImg.CopyImgBuffer(bmpMapData.Left, bmpMapData.Top, bmpMapData.Width, bmpMapData.Height);
itemImg.SaveImage("test1_atlas_item" + i + ".png");
}
}
//test,
{
if (bitmapAtlas.TryGetItem(@"\chk_checked.png", out AtlasItem bmpMapData))
{
MemBitmap itemImg = totalAtlasImg.CopyImgBuffer(bmpMapData.Left, bmpMapData.Top, bmpMapData.Width, bmpMapData.Height);
itemImg.SaveImage("test1_atlas_item_a.png");
}
}
}
}