public static void GenerateBitmapFromTileSet(TileSetModel model, out WriteableBitmap bitmap)
{
bitmap = null;
ProjectModel projectModel = ModelManager.Get <ProjectModel>();
if (string.IsNullOrEmpty(model.ImagePath))
{
return;
}
string path = Path.Combine(projectModel.ProjectPath, model.ImagePath);
if (File.Exists(path))
{
BitmapImage bmImage = new BitmapImage();
bmImage.BeginInit();
bmImage.CacheOption = BitmapCacheOption.OnLoad;
bmImage.CreateOptions = BitmapCreateOptions.IgnoreImageCache;
bmImage.UriSource = new Uri(path, UriKind.RelativeOrAbsolute);
bmImage.EndInit();
bmImage.Freeze();
bitmap = BitmapFactory.ConvertToPbgra32Format(bmImage);
}
}
private async void ProcessImage(ProjectItem item, TileSetModel tileSet, string filePath)
{
string imagesFolder = (string)Application.Current.FindResource(_folderImagesKey);
ProjectModel projectModel = ModelManager.Get <ProjectModel>();
string imageFolderFullPath = Path.Combine(projectModel.ProjectPath, imagesFolder);
if (!Directory.Exists(imageFolderFullPath))
{
_ = Directory.CreateDirectory(imageFolderFullPath);
}
PaletteQuantizer quantizer = new PaletteQuantizer
{
InputFileName = filePath,
ColorCache = PaletteQuantizer.EColorCache.OctreeSearch,
Method = PaletteQuantizer.EMethod.NESQuantizer
};
// todo: If the source image is the same as the output image, Crash!!
Image outputImage = await quantizer.Convert();
string outputImagePath = Path.Combine(imageFolderFullPath, item.DisplayName + ".bmp");
tileSet.ImagePath = Path.Combine(imagesFolder, item.DisplayName + ".bmp");
tileSet.ImageWidth = outputImage.Width;
tileSet.ImageHeight = outputImage.Height;
item.FileHandler.Save();
outputImage.Save(outputImagePath, ImageFormat.Bmp);
SignalManager.Get <UpdateTileSetImageSignal>().Dispatch();
}
public static WriteableBitmap GetCacheBitmap(string tileSetID)
{
if (!TileSetModel.BitmapCache.TryGetValue(tileSetID, out WriteableBitmap tileSetBitmap))
{
// The tileset exists but the bitmap is not in the cache, so I will try to load it here
TileSetModel tileSetModel = ProjectFiles.GetModel <TileSetModel>(tileSetID);
return(tileSetModel != null?TileSetModel.LoadBitmap(tileSetModel) : null);
}
return(tileSetBitmap);
}
public void UpdateVM(IDbTileAtlasFromBlk entry)
{
model = tileSetsDataProvider.GetTileAtlas(entry.Id);
if (model == null)
{
return;
}
Viewer.FromModel(model);
SetupPaletteIds(entry.PaletteRefs);
}
private void OnNewTileSetCommand()
{
var model = new CreateTileSetModel();
var uiVisualizerService = this.GetDependencyResolver().Resolve <IUIVisualizerService>();
uiVisualizerService.ShowDialog <CreateTileSetViewModel>(model, async(s, e) =>
{
if (e.Result == true)
{
TileSet = await model.Create();
}
});
}
internal void FromModel(TileSetModel tileSet)
{
TileSize = tileSet.TileSize;
SetupTiles(tileSet.Tiles);
}
public static WriteableBitmap CreateImage(BankModel bankModel, ref Dictionary <string, WriteableBitmap> bitmapCache, bool sendSignals = true)
{
FileModelVO[] tileSets = ProjectFiles.GetModels <TileSetModel>().ToArray();
WriteableBitmap bankBitmap = BitmapFactory.New(128, 128);
int index = 0;
foreach (PTTileModel tile in bankModel.PTTiles)
{
if (string.IsNullOrEmpty(tile.GUID) || string.IsNullOrEmpty(tile.TileSetID))
{
continue;
}
if (!bitmapCache.TryGetValue(tile.TileSetID, out WriteableBitmap sourceBitmap))
{
TileSetModel model = ProjectFiles.GetModel <TileSetModel>(tile.TileSetID);
if (model == null)
{
continue;
}
ProjectModel projectModel = ModelManager.Get <ProjectModel>();
string path = Path.Combine(projectModel.ProjectPath, model.ImagePath);
BitmapImage bmImage = new BitmapImage();
bmImage.BeginInit();
bmImage.CacheOption = BitmapCacheOption.OnLoad;
bmImage.UriSource = new Uri(path, UriKind.RelativeOrAbsolute);
bmImage.EndInit();
bmImage.Freeze();
sourceBitmap = BitmapFactory.ConvertToPbgra32Format(bmImage);
bitmapCache.Add(tile.TileSetID, sourceBitmap);
if (sendSignals)
{
// Add the link object
foreach (FileModelVO tileset in tileSets)
{
if (tileset.Model.GUID == tile.TileSetID)
{
SignalManager.Get <AddNewTileSetLinkSignal>().Dispatch(new BankLinkVO()
{
Caption = tileset.Name, Id = tile.TileSetID
});
break;
}
}
}
}
WriteableBitmap cropped = sourceBitmap.Crop((int)tile.Point.X, (int)tile.Point.Y, 8, 8);
int destX = index % 16 * 8;
int destY = index / 16 * 8;
Util.CopyBitmapImageToWriteableBitmap(ref bankBitmap, destX, destY, cropped);
index++;
}
return(bankBitmap);
}
private async void LoadTileSet(string fileName)
{
TileSet = await TileSetModel.Load(fileName);
}
private static Dictionary <Color, Color> FillColorCacheByGroup(CharacterTile characterTile, int group, string paletteId)
{
Color nullColor = Util.NullColor;
BankModel bankModel = ProjectFiles.GetModel <BankModel>(characterTile.BankID);
PaletteModel paletteModel = ProjectFiles.GetModel <PaletteModel>(paletteId);
Dictionary <Color, Color> colors = new Dictionary <Color, Color>()
{
{ nullColor, nullColor }
};
foreach (PTTileModel tile in bankModel.PTTiles)
{
if (string.IsNullOrEmpty(tile.GUID))
{
continue;
}
if (tile.Group != group)
{
continue;
}
TileSetModel model = ProjectFiles.GetModel <TileSetModel>(tile.TileSetID);
if (model == null)
{
continue;
}
if (!TileSetModel.BitmapCache.TryGetValue(tile.TileSetID, out WriteableBitmap tileSetBitmap))
{
continue;
}
WriteableBitmap cropped = tileSetBitmap.Crop((int)tile.Point.X, (int)tile.Point.Y, 8, 8);
for (int y = 0; y < 8; ++y)
{
for (int x = 0; x < 8; ++x)
{
Color color = cropped.GetPixel(x, y);
color.A = 255;
if (!colors.TryGetValue(color, out Color newColor))
{
if (paletteModel == null)
{
newColor = nullColor;
}
else
{
switch (colors.Count)
{
case 1: newColor = Util.GetColorFromInt(paletteModel.Color1); break;
case 2: newColor = Util.GetColorFromInt(paletteModel.Color2); break;
case 3: newColor = Util.GetColorFromInt(paletteModel.Color3); break;
}
}
colors.Add(color, newColor);
}
}
}
}
return(colors);
}
