private static IEnumerable <CompileConfig> ExtractDirectives(string filePath)
{
using (var file = new StreamReader(filePath))
{
string line = null;
while ((line = file.ReadLine()) != null)
{
if (!line.StartsWith("#pragma FXC"))
{
yield break;
}
var match = FxcPragmaPatten.Match(line);
var options = new CompileConfig()
{
Name = match.Groups[1].Value,
Profile = match.Groups[2].Success ? match.Groups[2].Value : match.Groups[3].Value,
EntryPoint = match.Groups[4].Value,
ExtraArgs = match.Groups[5].Value
};
if (options.Name == "" || options.Profile == "")
{
throw new InvalidOperationException($"Could not parse FXC directive: {line}");
}
yield return(options);
}
}
}
private static void CompileShader(string sourcePath, CompileConfig config)
{
var targetDirectory = Path.GetDirectoryName(sourcePath);
var objectPath = Path.Combine(targetDirectory, $"{config.Name}.o");
DateTime srcTime = File.GetLastWriteTime(sourcePath);
DateTime dstTime = File.GetLastWriteTime(objectPath);
if (dstTime > srcTime)
{
return;
}
var sourceName = Path.GetFileName(sourcePath);
var fxc10 = Path.Combine(FxcDir, "fxc10.exe");
var sb = new StringBuilder();
sb.Append(sourceName);
sb.AppendFormat(" /Fo {0}.o", config.Name);
sb.AppendFormat(" /Fc {0}.asm", config.Name);
sb.AppendFormat(" /T {0}", config.Profile);
sb.Append(" /nologo");
if (config.EntryPoint != "")
{
sb.AppendFormat(" /E {0}", config.EntryPoint);
}
if (config.ExtraArgs != "")
{
sb.AppendFormat(" {0}", config.ExtraArgs);
}
var result = Command(fxc10, sb.ToString(), targetDirectory);
if (result.ResultCode != 0)
{
throw new InvalidOperationException($"fxc {sb} returned error code {result.ResultCode}\n{result.Stderr}");
}
//FXC 10.1 cannot disassemble fx_2_0 shaders
if (config.EntryPoint != "")
{
return;
}
var profileMatch = ProfilePatten.Match(config.Profile);
if (profileMatch.Groups[2].Value != "2" && profileMatch.Groups[2].Value != "3")
{
return;
}
var fxc9 = Path.Combine(FxcDir, "fxc9.exe");
sb = new StringBuilder();
sb.AppendFormat("/dumpbin {0}.o", config.Name);
sb.AppendFormat(" /Fc {0}.asm", config.Name);
sb.AppendFormat(" /T {0}", config.Profile);
sb.Append(" /nologo");
result = Command(fxc9, sb.ToString(), targetDirectory);
if (result.ResultCode != 0)
{
throw new InvalidOperationException($"fxc {sb} returned error code {result.ResultCode}\n{result.Stderr}");
}
}
internal void ApplyConfig(CompileConfig config)
{
foreach (MapVersion mapVersion in config.Maps)
{
this.MapVersionList.Items.Add(this.CreateLvi(mapVersion));
}
}
internal void Save(CompileConfig config)
{
config.Maps = new List <MapVersion>();
foreach (ListViewItem lvi in this.MapVersionList.Items)
{
config.Maps.Add((MapVersion)lvi.Tag);
}
}
internal void Save(CompileConfig config)
{
config.BinWriterTasks.Clear();
foreach (ListViewItem lvi in this.BinWriterTaskList.Items)
{
config.BinWriterTasks.Add((BinWriterTask)lvi.Tag);
}
}
private void CompileWorker_DoWork(object sender, DoWorkEventArgs e)
{
CompileConfig config = (CompileConfig)e.Argument;
var compiler = new Compiler(config);
Stopwatch sw = Stopwatch.StartNew();
compiler.Compile();
sw.Stop();
e.Result = sw.Elapsed;
}
internal void ApplyConfig(CompileConfig config)
{
this.ImageList.BeginUpdate();
this.ImageList.Items.Clear();
foreach (var img in config.Images)
{
this.AddImage(img.Name, img.Path);
}
this.ImageList.EndUpdate();
}
internal void ApplyConfig(CompileConfig config)
{
this.BinWriterTaskList.BeginUpdate();
this.BinWriterTaskList.Items.Clear();
foreach (var task in config.BinWriterTasks.OrderBy(t => t.Order))
{
this.BinWriterTaskList.Items.Add(this.CreateLvi(task));
}
this.AssignOrder();
this.BinWriterTaskList.EndUpdate();
}
private void ApplyConfig(CompileConfig config)
{
this.BinName.Text = config.BinFile;
this.MapSubfolder.Text = config.MapDirectory;
this.OutputTextBox.Text = config.OutputDirectory;
this.MapVersionTextBox.Text = config.MapVersion;
this.ThreadCount.Value = config.Threads;
this.ImagesUserControl.ApplyConfig(config);
this.BinWriterTaskUserControl.ApplyConfig(config);
this.MapUserControl.ApplyConfig(config);
}
public void Save(CompileConfig config)
{
config.Images.Clear();
foreach (ListViewItem img in this.ImageList.Items)
{
config.Images.Add(new ImageDefinition
{
Name = img.SubItems[0].Text,
Path = img.SubItems[1].Text
});
}
}
private void openToolStripMenuItem_Click(object sender, EventArgs e)
{
var dr = this.OpenConfigDialog.ShowDialog();
if (dr != DialogResult.OK)
{
return;
}
this.configFile = new FileInfo(this.OpenConfigDialog.FileName);
CompileConfig config = Xml.Deserialize <CompileConfig>(this.configFile, false);
this.ApplyConfig(config);
}
private void GenerateConfig(out CompileConfig config)
{
config = new CompileConfig();
// Store information which resides in the main window
config.BinFile = this.BinName.Text;
config.MapDirectory = this.MapSubfolder.Text;
config.OutputDirectory = this.OutputTextBox.Text;
config.MapVersion = this.MapVersionTextBox.Text;
config.Threads = (int)this.ThreadCount.Value;
// Store usercontrol settings
this.ImagesUserControl.Save(config);
this.BinWriterTaskUserControl.Save(config);
this.MapUserControl.Save(config);
}
public CompileOptions(CompileConfig cfg)
{
InitializeComponent();
DialogResult = DialogResult.Cancel;
config = cfg;
textBox_ram.Text = cfg.RAM.ToString();
textBox_flash.Text = cfg.Flash.ToString();
textBox_eeprom.Text = cfg.EEPROM.ToString();
textBox_registerCount.Text = cfg.RegisterCount.ToString();
textBox_registerNameFormat.Text = cfg.RegisterNameFormat;
richTextBox_incPath.Text = string.Join("\n", cfg.IncludePaths);
comboBox_base.Text = cfg.Base.ToString();
checkedListBox_bf.Items.Clear();
foreach (var a in Enum.GetNames(typeof(HASMMachineBannedFeatures)))
{
checkedListBox_bf.Items.Add(a, cfg.BannedFeatures.HasFlag((HASMMachineBannedFeatures)Enum.Parse(typeof(HASMMachineBannedFeatures), a)));
}
dataGridView1.Rows.Clear();
foreach (var a in cfg.Defines)
{
if (string.IsNullOrEmpty(a.Name))
{
continue;
}
DataGridViewRow row = new DataGridViewRow();
DataGridViewTextBoxCell cell1 = new DataGridViewTextBoxCell
{
Value = a.Name
};
DataGridViewTextBoxCell cell2 = new DataGridViewTextBoxCell
{
Value = a.Value
};
row.Cells.Add(cell1);
row.Cells.Add(cell2);
dataGridView1.Rows.Add(row);
}
}
private void button_ok_Click(object sender, EventArgs e)
{
config.IncludePaths = new List <string>();
config.IncludePaths.AddRange(richTextBox_incPath.Text.Split('\n'));
config.EEPROM = int.Parse(textBox_eeprom.Text);
config.Flash = int.Parse(textBox_flash.Text);
config.RAM = int.Parse(textBox_ram.Text);
config.RegisterNameFormat = textBox_registerNameFormat.Text;
config.RegisterCount = int.Parse(textBox_registerCount.Text);
config.Base = int.Parse(comboBox_base.Text);
HASMMachineBannedFeatures bf = 0;
foreach (var a in checkedListBox_bf.Items)
{
string name = (string)a;
if (checkedListBox_bf.CheckedItems.Contains(a))
{
bf |= (HASMMachineBannedFeatures)Enum.Parse(typeof(HASMMachineBannedFeatures), name);
}
}
List <Define> defines = new List <Define>();
foreach (DataGridViewRow row in dataGridView1.Rows)
{
string name = (string)row.Cells[0].Value;
string value = (string)row.Cells[1].Value;
defines.Add(new Define(name, value));
}
config.BannedFeatures = bf;
config.Defines = defines;
CompileConfig.ToFile(config.FileName, config);
DialogResult = DialogResult.OK;
Close();
}
public Compiler(CompileConfig config)
{
this.Config = config;
}
static void Main(string[] args)
{
CompileConfig config = new CompileConfig
{
OutputDirectory = @"d:\tmp\mapout",
BinFile = "AoRK.bin",
MapDirectory = "AoRK"
};
config.Images.Add(new ImageDefinition {
Name = "Layer1", Path = @"D:\Anarchy Online\Maps\AoRK\output\AoRK_map1.png"
});
config.Images.Add(new ImageDefinition {
Name = "Layer2", Path = @"D:\Anarchy Online\Maps\AoRK\output\AoRK_map2.png"
});
config.Images.Add(new ImageDefinition {
Name = "Layer3", Path = @"D:\Anarchy Online\Maps\AoRK\output\AoRK_map3.png"
});
config.Images.Add(new ImageDefinition {
Name = "Layer3_atlantean", Path = @"D:\Anarchy Online\Maps\AoRK\output\AoRK_map3_rimor.png"
});
config.Images.Add(new ImageDefinition {
Name = "Layer3_rimor", Path = @"D:\Anarchy Online\Maps\AoRK\output\AoRK_map3_atlantean.png"
});
config.BinWriterTasks.Add(new BinWriterTask
{
MapRect = "7 0 360 457",
Order = 0,
Images = new string[] { "Layer1" }
});
config.BinWriterTasks.Add(new BinWriterTask
{
MapRect = "55 0 944 1144",
Order = 1,
Images = new string[] { "Layer2" }
});
config.BinWriterTasks.Add(new BinWriterTask
{
MapRect = "5 -7 3573 4583",
Order = 2,
Images = new string[] { "Layer3", "Layer3_atlantean", "Layer3_rimor" },
});
config.Maps.Add(new MapVersion
{
File = "AoRK.txt",
CoordsFile = "AoRK/AoRK.xml",
Name = "Atlas of Rubi-Ka",
Type = MapType.Rubika,
Images = new string[] { "Layer1", "Layer2", "Layer3" }
});
config.Maps.Add(new MapVersion
{
File = "AoRK-Atlantean.txt",
CoordsFile = "AoRK/AoRK.xml",
Name = "Atlas of Rubi-Ka (Atlantean)",
Type = MapType.Rubika,
Images = new string[] { "Layer1", "Layer2", "Layer3_atlantean" }
});
config.Maps.Add(new MapVersion
{
File = "AoRK-Rimor.txt",
CoordsFile = "AoRK/AoRK.xml",
Name = "Atlas of Rubi-Ka (Rimor)",
Type = MapType.Rubika,
Images = new string[] { "Layer1", "Layer2", "Layer3_rimor" }
});
Compiler compiler = new Compiler(config);
Console.WriteLine("Compiler set up. Starting slicing...");
Stopwatch sw = Stopwatch.StartNew();
compiler.Compile();
Console.WriteLine("Compiler done. Took {0} seconds.", sw.Elapsed.TotalSeconds);
Console.WriteLine("Press any key to continue...");
Console.ReadLine();
}
private void Form1_Load(object sender, EventArgs e)
{
Self = this;
tabControl1_SizeChanged(null, null);
string configName = "";
if (File.Exists("directory.txt"))
{
configName = File.ReadAllText("directory.txt");
}
if (!Directory.Exists(configName))
{
if (folderBrowserDialog1.ShowDialog() == DialogResult.OK)
{
configName =
PlatformSpecific.CombinePath(folderBrowserDialog1.SelectedPath, WorkingFolder.MainConfigPostfix);
string compileConfigFileName =
PlatformSpecific.CombinePath(folderBrowserDialog1.SelectedPath, WorkingFolder.CompileConfigPostfix);
string userConfigFileName =
PlatformSpecific.CombinePath(folderBrowserDialog1.SelectedPath, WorkingFolder.UserConfigPostfix);
Directory.CreateDirectory(PlatformSpecific.CombinePath(folderBrowserDialog1.SelectedPath, WorkingFolder.IdeDirPostfix));
workingFolder = new WorkingFolder()
{
CompileConfigPath = compileConfigFileName,
UserConfigPath = userConfigFileName,
Path = folderBrowserDialog1.SelectedPath,
PreferedToCompile = new SourceFile("", "")
};
WorkingFolder.ToFile(configName, workingFolder);
File.WriteAllText("directory.txt", folderBrowserDialog1.SelectedPath);
}
else
{
Close();
return;
}
}
else
{
configName =
PlatformSpecific.CombinePath(configName, WorkingFolder.MainConfigPostfix);
if (File.Exists(configName))
{
workingFolder = WorkingFolder.FromFile(configName, configName);
}
else
{
workingFolder = new WorkingFolder()
{
CompileConfigPath =
PlatformSpecific.CombinePath(new FileInfo(configName).DirectoryName, WorkingFolder.CompileConfigPostfix),
UserConfigPath =
PlatformSpecific.CombinePath(new FileInfo(configName).DirectoryName, WorkingFolder.UserConfigPostfix),
Path = new FileInfo(configName).Directory.Parent.FullName,
};
WorkingFolder.ToFile(configName, workingFolder);
}
}
if (File.Exists(workingFolder.UserConfigPath))
{
workingFolder.UserConfig = UserConfig.FromFile(workingFolder.UserConfigPath, workingFolder.Path);
Size = workingFolder.UserConfig.WindowSize;
splitContainer_main.SplitterDistance = workingFolder.UserConfig.MainSplitterDistance;
splitContainer_editor.SplitterDistance = workingFolder.UserConfig.EditorSplitterDistance;
if (workingFolder.UserConfig.WindowPosition.X == -32000)
{
WindowState = FormWindowState.Minimized;
}
else
{
Left = workingFolder.UserConfig.WindowPosition.X;
Top = workingFolder.UserConfig.WindowPosition.Y;
}
}
else
{
workingFolder.UserConfig = new UserConfig()
{
EditorSplitterDistance = splitContainer_editor.SplitterDistance,
MainSplitterDistance = splitContainer_main.SplitterDistance,
OpenedTabs = new List <string>(),
OutputType = OutputType.Hex,
SelectedTab = -1,
WindowPosition = new Point(Left, Top),
WindowSize = Size
};
UserConfig.ToFile(workingFolder.UserConfigPath, workingFolder.UserConfig);
}
if (File.Exists(workingFolder.CompileConfigPath))
{
workingFolder.CompileConfig = CompileConfig.FromFile(workingFolder.CompileConfigPath);
workingFolder.CompileConfig.FileName = workingFolder.CompileConfigPath;
}
else
{
workingFolder.CompileConfig = new CompileConfig()
{
FileName = workingFolder.CompileConfigPath
};
CompileConfig.ToFile(workingFolder.CompileConfigPath, workingFolder.CompileConfig);
}
Machine = new HASMMachine(
(uint)workingFolder.CompileConfig.RAM,
(uint)workingFolder.CompileConfig.EEPROM,
(uint)workingFolder.CompileConfig.Flash,
workingFolder.CompileConfig.Base)
{
BannedFeatures = workingFolder.CompileConfig.BannedFeatures,
UserDefinedDefines = workingFolder.CompileConfig.Defines
.FindAll(p => !string.IsNullOrEmpty(p.Name))
.Select(p => new HASMLib.Parser.SyntaxTokens.Preprocessor.Define(p.Name, new HASMLib.Parser.SyntaxTokens.Preprocessor.StringGroup(p.Value)))
.ToList()
};
Machine.SetRegisters(workingFolder.CompileConfig.RegisterNameFormat, (uint)workingFolder.CompileConfig.RegisterCount);
foreach (var path in workingFolder.CompileConfig.IncludePaths)
{
string value = path.Split(',')[0];
string pattern = path.Split(',')[1];
if (Directory.Exists(value))
{
Machine.Cache.AddFileNames(value, pattern);
}
else
{
value = PlatformSpecific.CombinePath(workingFolder.Path, value);
if (Directory.Exists(value))
{
Machine.Cache.AddFileNames(value, pattern);
}
else
{
MessageBox.Show($"Unable to directory file {value}",
"Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
continue;
}
}
}
RebuildCache();
if (workingFolder.UserConfig.OpenedTabs != null)
{
foreach (string path in workingFolder.UserConfig.OpenedTabs)
{
AddTab(path);
}
}
workingFolder.SetTreeView(treeView1);
treeView1.ExpandAll();
toolStripComboBox1.Items.Clear();
toolStripComboBox1.Items.AddRange(workingFolder.SourceFiles.Select(p => (object)p).ToArray());
toolStripComboBox1.SelectedItem = workingFolder.PreferedToCompile;
tabControl1.Enabled = true;
tabControl1.SelectedIndex = workingFolder.UserConfig.SelectedTab;
switch (workingFolder.UserConfig.OutputType)
{
case OutputType.Hex:
hexOutputToolStripMenuItem.Checked = true;
break;
case OutputType.Dec:
decOutputToolStripMenuItem.Checked = true;
break;
case OutputType.Char:
charOutputToolStripMenuItem.Checked = true;
break;
default:
break;
}
outputType = workingFolder.UserConfig.OutputType;
Text = $"HASM Editor { (tabControl1.SelectedTab == null ? "" : " - " + (tabControl1.SelectedTab as TextEditor).Path.NormalizePath())}";
}
