Esempio n. 1
0
        public static PersistantConfig Deserialize(string file)
        {
            XmlSerializer    xs     = new XmlSerializer(typeof(PersistantConfig));
            StreamReader     reader = File.OpenText(file);
            PersistantConfig c      = (PersistantConfig)xs.Deserialize(reader);

            reader.Close();

            foreach (var kv in c.ReplayHostKeyValues)
            {
                if (kv.Key != null && kv.Key.Length > 0 &&
                    kv.Value != null)
                {
                    c.ReplayHosts.Add(kv.Key, kv.Value);
                }
            }

            foreach (var kv in c.ConfigSettingsValues)
            {
                if (kv.Key != null && kv.Key.Length > 0 &&
                    kv.Value != null)
                {
                    c.SetConfigSetting(kv.Key, kv.Value);
                }
            }

            return(c);
        }
Esempio n. 2
0
        public Core(string paramFilename, bool temp, PersistantConfig config)
        {
            if (!Directory.Exists(ConfigDirectory))
            {
                Directory.CreateDirectory(ConfigDirectory);
            }

            m_Config     = config;
            m_MainWindow = new MainWindow(this, paramFilename, temp);
        }
Esempio n. 3
0
        public static PersistantConfig Deserialize(string file)
        {
            XmlSerializer    xs     = new XmlSerializer(typeof(PersistantConfig));
            StreamReader     reader = File.OpenText(file);
            PersistantConfig c      = (PersistantConfig)xs.Deserialize(reader);

            reader.Close();

            StaticExports.SetConfigSetting("Disassembly_FriendlyNaming",
                                           c.ShaderViewer_FriendlyNaming ? "1" : "0");

            foreach (var kv in c.ConfigSettingsValues)
            {
                if (kv.Key != null && kv.Key.Length > 0 &&
                    kv.Value != null)
                {
                    c.SetConfigSetting(kv.Key, kv.Value);
                }
            }

            //external disassemblers
            foreach (var kv in c.ExternalDisassemblersValues)
            {
                if (kv.Key >= 0 && kv.Value != null)
                {
                    c.SetExternalDisassemblers(kv.Key, kv.Value);
                }
            }

            // localhost should always be available
            bool foundLocalhost = false;

            for (int i = 0; i < c.RemoteHosts.Count; i++)
            {
                if (c.RemoteHosts[i].Hostname == "localhost")
                {
                    foundLocalhost = true;
                    break;
                }
            }

            if (!foundLocalhost)
            {
                RemoteHost host = new RemoteHost();
                host.Hostname = "localhost";
                c.RemoteHosts.Add(host);
            }

            return(c);
        }
Esempio n. 4
0
        public Core(string paramFilename, string remoteHost, uint remoteIdent, bool temp, PersistantConfig config)
        {
            if (!Directory.Exists(ConfigDirectory))
                Directory.CreateDirectory(ConfigDirectory);

            m_Config = config;
            m_MainWindow = new MainWindow(this, paramFilename, remoteHost, remoteIdent, temp);
        }
Esempio n. 5
0
        static void Main(string[] args)
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);

            Application.ThreadException += new System.Threading.ThreadExceptionEventHandler(Application_ThreadException);
            AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
            Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException);

            // command line arguments that we can call when we temporarily elevate the process
            if (args.Contains("--registerRDCext"))
            {
                Helpers.InstallRDCAssociation();
                return;
            }

            if (args.Contains("--registerCAPext"))
            {
                Helpers.InstallCAPAssociation();
                return;
            }

            if (args.Contains("--registerVKLayer"))
            {
                Helpers.RegisterVulkanLayer();
                return;
            }

            Win32PInvoke.LoadLibrary("renderdoc.dll");

            // clean up any update that just happened
            string updateFilesPath = Path.Combine(Path.GetTempPath(), "RenderDocUpdate");

            try
            {
                if (Directory.Exists(updateFilesPath))
                {
                    Directory.Delete(updateFilesPath, true);
                }
            }
            catch (Exception)
            {
                // ignore any exceptions from this
            }

            string filename = "";

            bool temp = false;

            // not real command line argument processing, but allow an argument to indicate we're being passed
            // a temporary filename that we should take ownership of to delete when we're done (if the user doesn't
            // save it)
            foreach (var a in args)
            {
                if (a.ToUpperInvariant() == "--TEMPFILE")
                {
                    temp = true;
                }
            }

            string remoteHost  = "";
            uint   remoteIdent = 0;

            for (int i = 0; i < args.Length; i++)
            {
                // accept --remoteaccess for backwards compatibility
                if (i + 1 < args.Length &&
                    (args[i].ToUpperInvariant() == "--REMOTEACCESS" ||
                     args[i].ToUpperInvariant() == "--TARGETCONTROL"))
                {
                    var regexp = @"^([a-zA-Z0-9_-]+:)?([0-9]+)$";

                    var match = Regex.Match(args[i + 1], regexp);

                    if (match.Success)
                    {
                        var host = match.Groups[1].Value;
                        if (host.Length > 0 && host[host.Length - 1] == ':')
                        {
                            host = host.Substring(0, host.Length - 1);
                        }
                        uint ident = 0;
                        if (uint.TryParse(match.Groups[2].Value, out ident))
                        {
                            remoteHost  = host;
                            remoteIdent = ident;
                        }
                    }
                }
            }

            List <String> pyscripts = new List <String>();

            for (int i = 0; i + 1 < args.Length; i++)
            {
                if (args[i].ToUpperInvariant() == "--PYTHON" ||
                    args[i].ToUpperInvariant() == "--PY" ||
                    args[i].ToUpperInvariant() == "--SCRIPT")
                {
                    if (File.Exists(args[i + 1]))
                    {
                        pyscripts.Add(args[i + 1]);
                    }
                }
            }

            if (args.Length > 0 && File.Exists(args[args.Length - 1]) && Path.GetExtension(args[args.Length - 1]) != ".py")
            {
                filename = args[args.Length - 1];
            }

            var cfg = new PersistantConfig();

            // load up the config from user folder, handling errors if it's malformed and falling back to defaults
            if (File.Exists(Core.ConfigFilename))
            {
                try
                {
                    cfg = PersistantConfig.Deserialize(Core.ConfigFilename);
                }
                catch (System.Xml.XmlException)
                {
                    MessageBox.Show(String.Format("Error loading config file\n{0}\nA default config is loaded and will be saved out.", Core.ConfigFilename));
                }
                catch (System.InvalidOperationException)
                {
                    MessageBox.Show(String.Format("Error loading config file\n{0}\nA default config is loaded and will be saved out.", Core.ConfigFilename));
                }
                catch (System.IO.IOException ex)
                {
                    MessageBox.Show(String.Format("Error loading config file: {1}\n{0}\nA default config is loaded and will be saved out.", Core.ConfigFilename, ex.Message));
                }
            }

            // propogate float formatting settings to the Formatter class used globally to format float values
            cfg.SetupFormatting();

            Application.CurrentCulture = new System.Globalization.CultureInfo("en-GB");

            var core = new Core(filename, remoteHost, remoteIdent, temp, cfg);

            for (int i = 0; i < args.Length; i++)
            {
                var a = args[i];

                if (a.ToUpperInvariant() == "--UPDATEDONE")
                {
                    cfg.CheckUpdate_UpdateAvailable = false;
                    cfg.CheckUpdate_UpdateResponse  = "";

                    bool     hasOtherJSON;
                    bool     thisRegistered;
                    string[] otherJSONs;

                    bool configured = Helpers.CheckVulkanLayerRegistration(out hasOtherJSON, out thisRegistered, out otherJSONs);

                    // if nothing is configured (ie. no other JSON files), then set up our layer
                    // as part of the update process.
                    if (!configured && !hasOtherJSON && !thisRegistered)
                    {
                        Helpers.RegisterVulkanLayer();
                    }

                    Helpers.UpdateInstalledVersionNumber();
                }

                if (a.ToUpperInvariant() == "--UPDATEFAILED")
                {
                    if (i < args.Length - 1)
                    {
                        MessageBox.Show(String.Format("Error applying update: {0}", args[i + 1]), "Error updating", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    }
                    else
                    {
                        MessageBox.Show("Unknown error applying update", "Error updating", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    }
                }
            }

            try
            {
                if (pyscripts.Count > 0)
                {
                    var engine = Python.CreateEngine();

                    List <string> searches = new List <string>(engine.GetSearchPaths());

                    searches.Add(Directory.GetCurrentDirectory());

                    string libspath = Path.Combine(Path.GetDirectoryName(Application.ExecutablePath), "pythonlibs.zip");

                    if (File.Exists(libspath))
                    {
                        searches.Add(libspath);
                    }

                    engine.SetSearchPaths(searches);

                    engine.Runtime.LoadAssembly(typeof(AppMain).Assembly);

                    var scope = engine.CreateScope();

                    scope.SetVariable("pyrenderdoc", core);

                    // try to import the RenderDoc namespace.
                    // This isn't equivalent to scope.ImportModule
                    try
                    {
                        engine.CreateScriptSourceFromString("import renderdoc").Execute(scope);
                    }
                    catch (Exception)
                    {
                    }

                    try
                    {
                        core.Renderer.SetExceptionCatching(true);
                        foreach (var script in pyscripts)
                        {
                            engine.CreateScriptSourceFromString(File.ReadAllText(script)).Execute(scope);
                        }
                        core.Renderer.SetExceptionCatching(false);
                    }
                    catch (Exception)
                    {
                        core.Renderer.SetExceptionCatching(false);

                        // IronPython throws so many exceptions, we don't want to kill the application
                        // so we just swallow Exception to cover all the bases
                    }
                }

                Application.Run(core.AppWindow);
            }
            catch (Exception e)
            {
                HandleException(e);
            }

            cfg.Serialize(Core.ConfigFilename);
        }
Esempio n. 6
0
        static void Main(string[] args)
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);

            Application.ThreadException += new System.Threading.ThreadExceptionEventHandler(Application_ThreadException);
            AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
            Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException);

            // command line arguments that we can call when we temporarily elevate the process
            if(args.Contains("--registerRDCext"))
            {
                Helpers.InstallRDCAssociation();
                return;
            }

            if(args.Contains("--registerCAPext"))
            {
                Helpers.InstallCAPAssociation();
                return;
            }

            if (args.Contains("--registerVKLayer"))
            {
                Helpers.RegisterVulkanLayer();
                return;
            }

            Win32PInvoke.LoadLibrary("renderdoc.dll");

            // clean up any update that just happened
            string updateFilesPath = Path.Combine(Path.GetTempPath(), "RenderDocUpdate");

            try
            {
                if (Directory.Exists(updateFilesPath))
                    Directory.Delete(updateFilesPath, true);
            }
            catch (Exception)
            {
                // ignore any exceptions from this
            }

            string filename = "";

            bool temp = false;

            // not real command line argument processing, but allow an argument to indicate we're being passed
            // a temporary filename that we should take ownership of to delete when we're done (if the user doesn't
            // save it)
            foreach(var a in args)
            {
                if(a.ToUpperInvariant() == "--TEMPFILE")
                    temp = true;
            }

            string remoteHost = "";
            uint remoteIdent = 0;

            for (int i = 0; i < args.Length; i++)
            {
                if (args[i].ToUpperInvariant() == "--REMOTEACCESS" && i + 1 < args.Length)
                {
                    var regexp = @"^([a-zA-Z0-9_-]+:)?([0-9]+)$";

                    var match = Regex.Match(args[i+1], regexp);

                    if (match.Success)
                    {
                        var host = match.Groups[1].Value;
                        if (host.Length > 0 && host[host.Length - 1] == ':')
                            host = host.Substring(0, host.Length - 1);
                        uint ident = 0;
                        if (uint.TryParse(match.Groups[2].Value, out ident))
                        {
                            remoteHost = host;
                            remoteIdent = ident;
                        }
                    }
                }
            }

            if (args.Length > 0 && File.Exists(args[args.Length - 1]))
            {
                filename = args[args.Length - 1];
            }

            var cfg = new PersistantConfig();

            // load up the config from user folder, handling errors if it's malformed and falling back to defaults
            if (File.Exists(Core.ConfigFilename))
            {
                try
                {
                    cfg = PersistantConfig.Deserialize(Core.ConfigFilename);
                }
                catch (System.Xml.XmlException)
                {
                    MessageBox.Show(String.Format("Error loading config file\n{0}\nA default config is loaded and will be saved out.", Core.ConfigFilename));
                }
                catch (System.InvalidOperationException)
                {
                    MessageBox.Show(String.Format("Error loading config file\n{0}\nA default config is loaded and will be saved out.", Core.ConfigFilename));
                }
                catch (System.IO.IOException ex)
                {
                    MessageBox.Show(String.Format("Error loading config file: {1}\n{0}\nA default config is loaded and will be saved out.", Core.ConfigFilename, ex.Message));
                }
            }

            // propogate float formatting settings to the Formatter class used globally to format float values
            cfg.SetupFormatting();

            Application.CurrentCulture = new System.Globalization.CultureInfo("en-GB");

            var core = new Core(filename, remoteHost, remoteIdent, temp, cfg);

            foreach (var a in args)
            {
                if (a.ToUpperInvariant() == "--UPDATEDONE")
                {
                    cfg.CheckUpdate_UpdateAvailable = false;
                    cfg.CheckUpdate_UpdateResponse = "";

                    bool hasOtherJSON;
                    bool thisRegistered;
                    string[] otherJSONs;

                    bool configured = Helpers.CheckVulkanLayerRegistration(out hasOtherJSON, out thisRegistered, out otherJSONs);

                    // if nothing is configured (ie. no other JSON files), then set up our layer
                    // as part of the update process.
                    if (!configured && !hasOtherJSON && !thisRegistered)
                    {
                        Helpers.RegisterVulkanLayer();
                    }
                }
            }

            try
            {
                Application.Run(core.AppWindow);
            }
            catch (Exception e)
            {
                HandleException(e);
            }

            cfg.Serialize(Core.ConfigFilename);
        }
Esempio n. 7
0
        static void Main(string[] args)
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);

            Application.ThreadException += new System.Threading.ThreadExceptionEventHandler(Application_ThreadException);
            AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
            Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException);

            // command line arguments that we can call when we temporarily elevate the process
            if(args.Contains("--registerRDCext"))
            {
                Helpers.InstallRDCAssociation();
                return;
            }

            if(args.Contains("--registerCAPext"))
            {
                Helpers.InstallCAPAssociation();
                return;
            }

            Win32PInvoke.LoadLibrary("renderdoc.dll");

            string filename = "";

            bool temp = false;

            // not real command line argument processing, but allow an argument to indicate we're being passed
            // a temporary filename that we should take ownership of to delete when we're done (if the user doesn't
            // save it)
            foreach(var a in args)
            {
                if(a.ToLowerInvariant() == "--tempfile")
                    temp = true;
            }

            string remoteHost = "";
            uint remoteIdent = 0;

            for (int i = 0; i < args.Length; i++)
            {
                if (args[i].ToLowerInvariant() == "--remoteaccess" && i + 1 < args.Length)
                {
                    var regexp = @"^([a-zA-Z0-9_-]+:)?([0-9]+)$";

                    var match = Regex.Match(args[i+1], regexp);

                    if (match.Success)
                    {
                        var host = match.Groups[1].Value;
                        if (host != "" && host[host.Length - 1] == ':')
                            host = host.Substring(0, host.Length - 1);
                        uint ident = 0;
                        if (uint.TryParse(match.Groups[2].Value, out ident))
                        {
                            remoteHost = host;
                            remoteIdent = ident;
                        }
                    }
                }
            }

            if (args.Length > 0 && File.Exists(args[args.Length - 1]))
            {
                filename = args[args.Length - 1];
            }

            var cfg = new PersistantConfig();

            // load up the config from user folder, handling errors if it's malformed and falling back to defaults
            if (File.Exists(Core.ConfigFilename))
            {
                try
                {
                    cfg = PersistantConfig.Deserialize(Core.ConfigFilename);
                }
                catch (System.Xml.XmlException)
                {
                    MessageBox.Show(String.Format("Error loading config file\n{0}\nA default config is loaded and will be saved out.", Core.ConfigFilename));
                }
                catch (System.InvalidOperationException)
                {
                    MessageBox.Show(String.Format("Error loading config file\n{0}\nA default config is loaded and will be saved out.", Core.ConfigFilename));
                }
                catch (System.IO.IOException ex)
                {
                    MessageBox.Show(String.Format("Error loading config file: {1}\n{0}\nA default config is loaded and will be saved out.", Core.ConfigFilename, ex.Message));
                }
            }

            // propogate float formatting settings to the Formatter class used globally to format float values
            cfg.SetupFormatter();

            Application.CurrentCulture = new System.Globalization.CultureInfo("en-GB");

            var core = new Core(filename, remoteHost, remoteIdent, temp, cfg);

            try
            {
                Application.Run(core.AppWindow);
            }
            catch (Exception e)
            {
                HandleException(e);
            }

            cfg.Serialize(Core.ConfigFilename);
        }
Esempio n. 8
0
        static void Main(string[] args)
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);

            Application.ThreadException += new System.Threading.ThreadExceptionEventHandler(Application_ThreadException);
            AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
            Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException);

            // command line arguments that we can call when we temporarily elevate the process
            if (args.Contains("--registerRDCext"))
            {
                Helpers.InstallRDCAssociation();
                return;
            }

            if (args.Contains("--registerCAPext"))
            {
                Helpers.InstallCAPAssociation();
                return;
            }

            Win32PInvoke.LoadLibrary("renderdoc.dll");

            // clean up any update that just happened
            string updateFilesPath = Path.Combine(Path.GetTempPath(), "RenderDocUpdate");

            try
            {
                if (Directory.Exists(updateFilesPath))
                {
                    Directory.Delete(updateFilesPath, true);
                }
            }
            catch (Exception)
            {
                // ignore any exceptions from this
            }

            string filename = "";

            bool temp = false;

            // not real command line argument processing, but allow an argument to indicate we're being passed
            // a temporary filename that we should take ownership of to delete when we're done (if the user doesn't
            // save it)
            foreach (var a in args)
            {
                if (a.ToUpperInvariant() == "--TEMPFILE")
                {
                    temp = true;
                }
            }

            string remoteHost  = "";
            uint   remoteIdent = 0;

            for (int i = 0; i < args.Length; i++)
            {
                if (args[i].ToUpperInvariant() == "--REMOTEACCESS" && i + 1 < args.Length)
                {
                    var regexp = @"^([a-zA-Z0-9_-]+:)?([0-9]+)$";

                    var match = Regex.Match(args[i + 1], regexp);

                    if (match.Success)
                    {
                        var host = match.Groups[1].Value;
                        if (host.Length > 0 && host[host.Length - 1] == ':')
                        {
                            host = host.Substring(0, host.Length - 1);
                        }
                        uint ident = 0;
                        if (uint.TryParse(match.Groups[2].Value, out ident))
                        {
                            remoteHost  = host;
                            remoteIdent = ident;
                        }
                    }
                }
            }

            if (args.Length > 0 && File.Exists(args[args.Length - 1]))
            {
                filename = args[args.Length - 1];
            }

            var cfg = new PersistantConfig();

            // load up the config from user folder, handling errors if it's malformed and falling back to defaults
            if (File.Exists(Core.ConfigFilename))
            {
                try
                {
                    cfg = PersistantConfig.Deserialize(Core.ConfigFilename);
                }
                catch (System.Xml.XmlException)
                {
                    MessageBox.Show(String.Format("Error loading config file\n{0}\nA default config is loaded and will be saved out.", Core.ConfigFilename));
                }
                catch (System.InvalidOperationException)
                {
                    MessageBox.Show(String.Format("Error loading config file\n{0}\nA default config is loaded and will be saved out.", Core.ConfigFilename));
                }
                catch (System.IO.IOException ex)
                {
                    MessageBox.Show(String.Format("Error loading config file: {1}\n{0}\nA default config is loaded and will be saved out.", Core.ConfigFilename, ex.Message));
                }
            }

            // propogate float formatting settings to the Formatter class used globally to format float values
            cfg.SetupFormatting();

            Application.CurrentCulture = new System.Globalization.CultureInfo("en-GB");

            var core = new Core(filename, remoteHost, remoteIdent, temp, cfg);

            foreach (var a in args)
            {
                if (a.ToUpperInvariant() == "--UPDATEDONE")
                {
                    cfg.CheckUpdate_UpdateAvailable = false;
                    cfg.CheckUpdate_UpdateResponse  = "";
                }
            }

            try
            {
                Application.Run(core.AppWindow);
            }
            catch (Exception e)
            {
                HandleException(e);
            }

            cfg.Serialize(Core.ConfigFilename);
        }
Esempio n. 9
0
        static void Main(string[] args)
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);

            Application.ThreadException += new System.Threading.ThreadExceptionEventHandler(Application_ThreadException);
            AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
            Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException);

            // command line arguments that we can call when we temporarily elevate the process
            if (args.Contains("--registerRDCext"))
            {
                Helpers.InstallRDCAssociation();
                return;
            }

            if (args.Contains("--registerCAPext"))
            {
                Helpers.InstallCAPAssociation();
                return;
            }

            Win32PInvoke.LoadLibrary("renderdoc.dll");

            string filename = "";

            bool temp = false;

            // not real command line argument processing, but allow an argument to indicate we're being passed
            // a temporary filename that we should take ownership of to delete when we're done (if the user doesn't
            // save it)
            foreach (var a in args)
            {
                if (a.ToLowerInvariant() == "--tempfile")
                {
                    temp = true;
                }
            }

            if (args.Length > 0 && File.Exists(args[args.Length - 1]))
            {
                filename = args[args.Length - 1];
            }

            var cfg = new PersistantConfig();

            // load up the config from user folder, handling errors if it's malformed and falling back to defaults
            if (File.Exists(Core.ConfigFilename))
            {
                try
                {
                    cfg = PersistantConfig.Deserialize(Core.ConfigFilename);
                }
                catch (System.Xml.XmlException)
                {
                    MessageBox.Show(String.Format("Error loading config file\n{0}\nA default config is loaded and will be saved out.", Core.ConfigFilename));
                }
                catch (System.InvalidOperationException)
                {
                    MessageBox.Show(String.Format("Error loading config file\n{0}\nA default config is loaded and will be saved out.", Core.ConfigFilename));
                }
            }

            // propogate float formatting settings to the Formatter class used globally to format float values
            cfg.SetupFormatter();

            var core = new Core(filename, temp, cfg);

            try
            {
                Application.Run(core.AppWindow);
            }
            catch (Exception e)
            {
                HandleException(e);
            }

            cfg.Serialize(Core.ConfigFilename);
        }
Esempio n. 10
0
        static void Main(string[] args)
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);

            Application.ThreadException += new System.Threading.ThreadExceptionEventHandler(Application_ThreadException);
            AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
            Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException);

            // command line arguments that we can call when we temporarily elevate the process
            if(args.Contains("--registerRDCext"))
            {
                Helpers.InstallRDCAssociation();
                return;
            }

            if(args.Contains("--registerCAPext"))
            {
                Helpers.InstallCAPAssociation();
                return;
            }

            Win32PInvoke.LoadLibrary("renderdoc.dll");

            string filename = "";

            bool temp = false;

            // not real command line argument processing, but allow an argument to indicate we're being passed
            // a temporary filename that we should take ownership of to delete when we're done (if the user doesn't
            // save it)
            foreach(var a in args)
            {
                if(a.ToLowerInvariant() == "--tempfile")
                    temp = true;
            }

            if (args.Length > 0 && File.Exists(args[args.Length - 1]))
            {
                filename = args[args.Length - 1];
            }

            var cfg = new PersistantConfig();

            // load up the config from user folder, handling errors if it's malformed and falling back to defaults
            if (File.Exists(Core.ConfigFilename))
            {
                try
                {
                    cfg = PersistantConfig.Deserialize(Core.ConfigFilename);
                }
                catch (System.Xml.XmlException)
                {
                    MessageBox.Show(String.Format("Error loading config file\n{0}\nA default config is loaded and will be saved out.", Core.ConfigFilename));
                }
                catch (System.InvalidOperationException)
                {
                    MessageBox.Show(String.Format("Error loading config file\n{0}\nA default config is loaded and will be saved out.", Core.ConfigFilename));
                }
            }

            // propogate float formatting settings to the Formatter class used globally to format float values
            cfg.SetupFormatter();

            var core = new Core(filename, temp, cfg);

            try
            {
                Application.Run(core.AppWindow);
            }
            catch (Exception e)
            {
                HandleException(e);
            }

            cfg.Serialize(Core.ConfigFilename);
        }