IsoCat MakeRenderer()
{
// create and configure the renderer
IsoCat newRenderer = new IsoCat {
SeeThroughLava = p.SeeThroughLava,
SeeThroughWater = p.SeeThroughWater,
Mode = p.Mode,
Gradient = !p.NoGradient,
DrawShadows = !p.NoShadows
};
if (p.Mode == IsoCatMode.Chunk)
{
newRenderer.Chunk = p.Region;
}
switch (p.Angle)
{
case 90:
newRenderer.Rotation = 1;
break;
case 180:
newRenderer.Rotation = 2;
break;
case 270:
case -90:
newRenderer.Rotation = 3;
break;
}
return(newRenderer);
}
public AddWorldPopup(WorldListEntry world)
{
InitializeComponent();
fileBrowser.Filter = MapLoadFilter;
cBackup.Items.AddRange(WorldListEntry.BackupEnumNames);
bwLoader.DoWork += AsyncLoad;
bwLoader.RunWorkerCompleted += AsyncLoadCompleted;
bwGenerator.WorkerReportsProgress = true;
bwGenerator.DoWork += AsyncGen;
bwGenerator.ProgressChanged += AsyncGenProgress;
bwGenerator.RunWorkerCompleted += AsyncGenCompleted;
bwRenderer.WorkerReportsProgress = true;
bwRenderer.DoWork += AsyncDraw;
bwRenderer.ProgressChanged += AsyncDrawProgress;
bwRenderer.RunWorkerCompleted += AsyncDrawCompleted;
renderer = new IsoCat();
// event routed through BackgroundWorker to avoid cross-thread invocation issues
renderer.ProgressChanged +=
(progressSender, progressArgs) =>
bwRenderer.ReportProgress(progressArgs.ProgressPercentage, progressArgs.UserState);
nMapWidth.Validating += MapDimensionValidating;
nMapHeight.Validating += MapDimensionValidating;
nMapLength.Validating += MapDimensionValidating;
cAccess.Items.Add("(everyone)");
cBuild.Items.Add("(everyone)");
foreach (Rank rank in RankManager.Ranks)
{
cAccess.Items.Add(MainForm.ToComboBoxOption(rank));
cBuild.Items.Add(MainForm.ToComboBoxOption(rank));
}
progressBar.Visible = false;
tStatus1.Text = "";
tStatus2.Text = "";
World = world;
cPreviewMode.SelectedIndex = 0;
savePreviewDialog.Filter =
"PNG Image|*.png|TIFF Image|*.tif;*.tiff|Bitmap Image|*.bmp|JPEG Image|*.jpg;*.jpeg";
savePreviewDialog.Title = "Saving preview image...";
cGenerator.Items.AddRange(MapGenUtil.GeneratorList.Select(gen => gen.Name).ToArray());
cGenerator.SelectedIndex = 0;
tsbLoadPreset.DropDownItemClicked += tsbLoadPreset_DropDownItemClicked;
tsbCopyGenSettings.DropDownItemClicked += tsbImportSettings_DropDownItemClicked;
Shown += LoadMap;
}
void RenderLoop()
{
renderer = MakeRenderer();
using (MemoryStream ms = new MemoryStream()) {
// loop terminates with the rest of the program (this is a background thread)
while (true)
{
// wait (block) until a map is available for drawing
RenderTask task = inQueue.WaitDequeue();
try {
// render the map
IsoCatResult result = renderer.Draw(task.Map);
task.Map = null;
// crop image (if needed)
Image image;
if (p.Uncropped)
{
image = result.Bitmap;
}
else
{
image = result.Bitmap.Clone(result.CropRectangle, result.Bitmap.PixelFormat);
result.Bitmap.Dispose();
}
// encode image
if (p.ExportFormat.Equals(ImageFormat.Jpeg))
{
EncoderParameters encoderParams = new EncoderParameters();
encoderParams.Param[0] = new EncoderParameter(Encoder.Quality, p.JpegQuality);
image.Save(ms, p.ImageEncoder, encoderParams);
}
else if (p.ExportFormat.Equals(ImageFormat.Gif))
{
OctreeQuantizer q = new OctreeQuantizer(255, 8);
image = q.Quantize(image);
image.Save(ms, p.ExportFormat);
}
else
{
image.Save(ms, p.ExportFormat);
}
image.Dispose();
// store result as a byte[]
task.Result = ms.ToArray();
} catch (Exception ex) {
task.Exception = ex;
}
// send stack to the results queue
outQueue.Enqueue(task);
ms.SetLength(0);
}
}
}
public AddWorldPopup(WorldListEntry world) {
InitializeComponent();
fileBrowser.Filter = MapLoadFilter;
cBackup.Items.AddRange(WorldListEntry.BackupEnumNames);
bwLoader.DoWork += AsyncLoad;
bwLoader.RunWorkerCompleted += AsyncLoadCompleted;
bwGenerator.WorkerReportsProgress = true;
bwGenerator.DoWork += AsyncGen;
bwGenerator.ProgressChanged += AsyncGenProgress;
bwGenerator.RunWorkerCompleted += AsyncGenCompleted;
bwRenderer.WorkerReportsProgress = true;
bwRenderer.DoWork += AsyncDraw;
bwRenderer.ProgressChanged += AsyncDrawProgress;
bwRenderer.RunWorkerCompleted += AsyncDrawCompleted;
renderer = new IsoCat();
// event routed through BackgroundWorker to avoid cross-thread invocation issues
renderer.ProgressChanged +=
(progressSender, progressArgs) =>
bwRenderer.ReportProgress(progressArgs.ProgressPercentage, progressArgs.UserState);
nMapWidth.Validating += MapDimensionValidating;
nMapHeight.Validating += MapDimensionValidating;
nMapLength.Validating += MapDimensionValidating;
cAccess.Items.Add("(everyone)");
cBuild.Items.Add("(everyone)");
foreach (Rank rank in RankManager.Ranks) {
cAccess.Items.Add(MainForm.ToComboBoxOption(rank));
cBuild.Items.Add(MainForm.ToComboBoxOption(rank));
}
progressBar.Visible = false;
tStatus1.Text = "";
tStatus2.Text = "";
World = world;
cPreviewMode.SelectedIndex = 0;
savePreviewDialog.Filter =
"PNG Image|*.png|TIFF Image|*.tif;*.tiff|Bitmap Image|*.bmp|JPEG Image|*.jpg;*.jpeg";
savePreviewDialog.Title = "Saving preview image...";
cGenerator.Items.AddRange(MapGenUtil.GeneratorList.Select(gen => gen.Name).ToArray());
cGenerator.SelectedIndex = 0;
tsbLoadPreset.DropDownItemClicked += tsbLoadPreset_DropDownItemClicked;
tsbCopyGenSettings.DropDownItemClicked += tsbImportSettings_DropDownItemClicked;
Shown += LoadMap;
}
public AddWorldPopup(WorldListEntry world)
{
InitializeComponent();
renderer = new IsoCat();
fileBrowser.Filter = MapLoadFilter;
cBackup.Items.AddRange(WorldListEntry.BackupEnumNames);
cTemplates.Items.AddRange(Enum.GetNames(typeof(MapGenTemplate)));
cTheme.Items.AddRange(Enum.GetNames(typeof(MapGenTheme)));
bwLoader.DoWork += AsyncLoad;
bwLoader.RunWorkerCompleted += AsyncLoadCompleted;
bwGenerator.DoWork += AsyncGen;
bwGenerator.WorkerReportsProgress = true;
bwGenerator.ProgressChanged += AsyncGenProgress;
bwGenerator.RunWorkerCompleted += AsyncGenCompleted;
bwRenderer.WorkerReportsProgress = true;
bwRenderer.WorkerSupportsCancellation = true;
bwRenderer.DoWork += AsyncDraw;
bwRenderer.ProgressChanged += AsyncDrawProgress;
bwRenderer.RunWorkerCompleted += AsyncDrawCompleted;
nMapWidth.Validating += MapDimensionValidating;
nMapLength.Validating += MapDimensionValidating;
nMapHeight.Validating += MapDimensionValidating;
cAccess.Items.Add("(everyone)");
cBuild.Items.Add("(everyone)");
foreach (Rank rank in RankManager.Ranks)
{
cAccess.Items.Add(MainForm.ToComboBoxOption(rank));
cBuild.Items.Add(MainForm.ToComboBoxOption(rank));
}
tStatus1.Text = "";
tStatus2.Text = "";
World = world;
savePreviewDialog.Filter = "PNG Image|*.png|TIFF Image|*.tif;*.tiff|Bitmap Image|*.bmp|JPEG Image|*.jpg;*.jpeg";
savePreviewDialog.Title = "Saving preview image...";
browseTemplateDialog.Filter = "MapGenerator Template|*.ftpl";
browseTemplateDialog.Title = "Opening a MapGenerator template...";
saveTemplateDialog.Filter = browseTemplateDialog.Filter;
saveTemplateDialog.Title = "Saving a MapGenerator template...";
Shown += LoadMap;
}
void AsyncDraw(object sender, DoWorkEventArgs e)
{
stopwatch = Stopwatch.StartNew();
renderer = new IsoCat(map, IsoCatMode.Normal, previewRotation);
Rectangle cropRectangle;
if (bwRenderer.CancellationPending)
{
return;
}
Bitmap rawImage = renderer.Draw(out cropRectangle, bwRenderer);
if (bwRenderer.CancellationPending)
{
return;
}
if (rawImage != null)
{
previewImage = rawImage.Clone(cropRectangle, rawImage.PixelFormat);
}
renderer = null;
GC.Collect(GC.MaxGeneration, GCCollectionMode.Optimized);
}
static int Main(string[] args)
{
Logger.Logged += OnLogged;
Logger.DisableFileLogging();
ReturnCode optionParsingResult = ParseOptions(args);
if (optionParsingResult != ReturnCode.Success)
{
return((int)optionParsingResult);
}
// check if input path exists, and if it's a file or directory
bool directoryMode;
try {
if (File.Exists(inputPath))
{
directoryMode = false;
if (outputDirName == null)
{
outputDirName = Paths.GetDirectoryNameOrRoot(inputPath);
}
}
else if (Directory.Exists(inputPath))
{
directoryMode = true;
if (outputDirName == null)
{
outputDirName = Paths.GetDirectoryNameOrRoot(inputPath);
}
}
else
{
Console.Error.WriteLine("MapRenderer: Cannot locate \"{0}\"", inputPath);
return((int)ReturnCode.InputDirNotFound);
}
if (!Directory.Exists(outputDirName))
{
Directory.CreateDirectory(outputDirName);
}
} catch (Exception ex) {
Console.Error.WriteLine("MapRenderer: {0}: {1}",
ex.GetType().Name,
ex.Message);
return((int)ReturnCode.PathError);
}
// check recursive flag
if (recursive && !directoryMode)
{
Console.Error.WriteLine("MapRenderer: Recursive flag is given, but input is not a directory.");
}
// check input filter
if (inputFilter != null && !directoryMode)
{
Console.Error.WriteLine("MapRenderer: Filter param is given, but input is not a directory.");
}
// initialize image encoder
ImageCodecInfo[] codecs = ImageCodecInfo.GetImageDecoders();
imageEncoder = codecs.FirstOrDefault(codec => codec.FormatID == exportFormat.Guid);
if (imageEncoder == null)
{
Console.Error.WriteLine("MapRenderer: Specified image encoder is not supported.");
return((int)ReturnCode.UnsupportedSaveFormat);
}
// create and configure the renderer
renderer = new IsoCat {
SeeThroughLava = seeThroughLava,
SeeThroughWater = seeThroughWater,
Mode = mode,
Gradient = !noGradient,
DrawShadows = !noShadows
};
if (mode == IsoCatMode.Chunk)
{
renderer.ChunkCoords[0] = region.XMin;
renderer.ChunkCoords[1] = region.YMin;
renderer.ChunkCoords[2] = region.ZMin;
renderer.ChunkCoords[3] = region.XMax;
renderer.ChunkCoords[4] = region.YMax;
renderer.ChunkCoords[5] = region.ZMax;
}
switch (angle)
{
case 90:
renderer.Rotation = 1;
break;
case 180:
renderer.Rotation = 2;
break;
case 270:
case -90:
renderer.Rotation = 3;
break;
}
if (!recursive && mapImporter != null && mapImporter.StorageType == MapStorageType.Directory)
{
// single-directory map
RenderOneMap(new DirectoryInfo(inputPath));
}
else if (!directoryMode)
{
// single-file map
RenderOneMap(new FileInfo(inputPath));
}
else
{
// possible single-directory conversion
if (!recursive && RenderOneMap(new DirectoryInfo(inputPath)))
{
return((int)ReturnCode.Success);
}
// go through all files inside the given directory
SearchOption recursiveOption = (recursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly);
DirectoryInfo inputDirInfo = new DirectoryInfo(inputPath);
if (inputFilter == null)
{
inputFilter = "*";
}
foreach (var dir in inputDirInfo.GetDirectories(inputFilter, recursiveOption))
{
RenderOneMap(dir);
}
foreach (var file in inputDirInfo.GetFiles(inputFilter, recursiveOption))
{
RenderOneMap(file);
}
}
return((int)ReturnCode.Success);
}
public void MapViewerUpdateLevel()
{
try
{
Level l = Level.Find(txtMapViewerLevelName.Text);
if (l == null)
{
Command.all.Find("load").Use(null, txtMapViewerLevelName.Text);
l = Level.Find(txtMapViewerLevelName.Text);
}
if (l == null) { MessageBox.Show("Level could not be found.", "Map Viewer"); return; }
txtMapViewerX.Text = l.width.ToString();
txtMapViewerY.Text = l.depth.ToString();
txtMapViewerZ.Text = l.height.ToString();
int rotation = (int)txtMapViewerRotation.Value;
if (rotation < 0 || rotation > 3) { MessageBox.Show("Invalid rotation (must be from 0-3).", "Map Viewer"); return; }
IsoCat IsoCat = new IsoCat(l, IsoCatMode.Normal, rotation);
Rectangle r = new Rectangle(0, 0, picMapViewer.Width, picMapViewer.Height);
System.ComponentModel.BackgroundWorker bgw = new System.ComponentModel.BackgroundWorker();
bgw.WorkerReportsProgress = true;
MapViewerLastDrawn = IsoCat.Draw(out r, bgw);
picMapViewer.Image = MapViewerLastDrawn;
}
catch (Exception ex) { Server.ErrorLog(ex); }
}
static int Main(string[] args)
{
Logger.Logged += OnLogged;
Logger.DisableFileLogging();
ReturnCode optionParsingResult = ParseOptions(args);
if (optionParsingResult != ReturnCode.Success)
{
return((int)optionParsingResult);
}
// parse importer name
if (importerName != null && !importerName.Equals("auto", StringComparison.OrdinalIgnoreCase))
{
MapFormat importFormat;
if (!EnumUtil.TryParse(importerName, out importFormat, true))
{
Console.Error.WriteLine("Unsupported importer \"{0}\"", importerName);
PrintUsage();
return((int)ReturnCode.UnrecognizedImporter);
}
mapImporter = MapUtility.GetImporter(importFormat);
if (mapImporter == null)
{
Console.Error.WriteLine("Loading from \"{0}\" is not supported", importFormat);
PrintUsage();
return((int)ReturnCode.UnsupportedLoadFormat);
}
}
// check input paths
bool hadFile = false,
hadDir = false;
foreach (string inputPath in inputPathList)
{
if (hadDir)
{
Console.Error.WriteLine("MapRenderer: Only one directory may be specified at a time.");
return((int)ReturnCode.ArgumentError);
}
// check if input path exists, and if it's a file or directory
try {
if (File.Exists(inputPath))
{
hadFile = true;
}
else if (Directory.Exists(inputPath))
{
hadDir = true;
if (hadFile)
{
Console.Error.WriteLine("MapRenderer: Cannot mix directories and files in input.");
return((int)ReturnCode.ArgumentError);
}
directoryMode = true;
if (!outputDirGiven)
{
outputDirName = inputPath;
}
}
else
{
Console.Error.WriteLine("MapRenderer: Cannot locate \"{0}\"", inputPath);
return((int)ReturnCode.InputPathNotFound);
}
} catch (Exception ex) {
Console.Error.WriteLine("MapRenderer: {0}: {1}",
ex.GetType().Name,
ex.Message);
return((int)ReturnCode.PathError);
}
}
// initialize image encoder
ImageCodecInfo[] codecs = ImageCodecInfo.GetImageDecoders();
imageEncoder = codecs.FirstOrDefault(codec => codec.FormatID == exportFormat.Guid);
if (imageEncoder == null)
{
Console.Error.WriteLine("MapRenderer: Specified image encoder is not supported.");
return((int)ReturnCode.UnsupportedSaveFormat);
}
// create and configure the renderer
renderer = new IsoCat {
SeeThroughLava = seeThroughLava,
SeeThroughWater = seeThroughWater,
Mode = mode,
Gradient = !noGradient,
DrawShadows = !noShadows
};
if (mode == IsoCatMode.Chunk)
{
renderer.ChunkCoords[0] = region.XMin;
renderer.ChunkCoords[1] = region.YMin;
renderer.ChunkCoords[2] = region.ZMin;
renderer.ChunkCoords[3] = region.XMax;
renderer.ChunkCoords[4] = region.YMax;
renderer.ChunkCoords[5] = region.ZMax;
}
switch (angle)
{
case 90:
renderer.Rotation = 1;
break;
case 180:
renderer.Rotation = 2;
break;
case 270:
case -90:
renderer.Rotation = 3;
break;
}
// check recursive flag
if (recursive && !directoryMode)
{
Console.Error.WriteLine("MapRenderer: Recursive flag is given, but input is not a directory.");
return((int)ReturnCode.ArgumentError);
}
// check input filter
if (inputFilter != null && !directoryMode)
{
Console.Error.WriteLine("MapRenderer: Filter param is given, but input is not a directory.");
return((int)ReturnCode.ArgumentError);
}
// check regex filter
if (useRegex)
{
try {
filterRegex = new Regex(inputFilter);
} catch (ArgumentException ex) {
Console.Error.WriteLine("MapRenderer: Cannot parse filter regex: {0}",
ex.Message);
return((int)ReturnCode.ArgumentError);
}
}
// check if output dir exists; create it if needed
if (outputDirName != null)
{
try {
if (!Directory.Exists(outputDirName))
{
Directory.CreateDirectory(outputDirName);
}
} catch (Exception ex) {
Console.Error.WriteLine("MapRenderer: Error checking output directory: {0}: {1}",
ex.GetType().Name, ex.Message);
}
}
// process inputs, one path at a time
foreach (string inputPath in inputPathList)
{
ReturnCode code = ProcessInputPath(inputPath);
if (code != ReturnCode.Success)
{
return((int)code);
}
}
return((int)ReturnCode.Success);
}
