static void Main() { try { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); GorgonApplication.Run(Initialize(), Idle); } catch (Exception ex) { GorgonExample.HandleException(ex); } finally { GorgonExample.UnloadResources(); foreach (GorgonTexture2D texture in _textures) { texture?.Dispose(); } _renderer?.Dispose(); _depthBuffer?.Dispose(); _screen?.Dispose(); _graphics?.Dispose(); _assemblyCache?.Dispose(); } }
/// <summary> /// Handles the <see cref="E:FormClosing" /> event. /// </summary> /// <param name="e">The <see cref="FormClosingEventArgs"/> instance containing the event data.</param> protected override void OnFormClosing(FormClosingEventArgs e) { base.OnFormClosing(e); // Always dispose your devices when the window is shutting down. // Failure to do so can lead to unpredictable results. if (_joystickList != null) { foreach (IGorgonGamingDevice joystick in _joystickList) { joystick.Dispose(); } } if (_drivers != null) { foreach (IGorgonGamingDeviceDriver driver in _drivers) { driver.Dispose(); } } _input?.UnregisterDevice(_mouse); _input?.Dispose(); _assemblyCache?.Dispose(); }
/// <summary> /// Raises the <see cref="E:System.Windows.Forms.Form.FormClosing" /> event. /// </summary> /// <param name="e">A <see cref="T:System.Windows.Forms.FormClosingEventArgs" /> that contains the event data.</param> protected override void OnFormClosing(FormClosingEventArgs e) { base.OnFormClosing(e); GorgonExample.UnloadResources(); _pluginCache?.Dispose(); _texture?.Dispose(); _swap?.Dispose(); _graphics?.Dispose(); _image?.Dispose(); }
public static async Task Main() { try { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.DoEvents(); // This is necessary to get winforms to play nice with our background thread prior to running the application. WindowsFormsSynchronizationContext.AutoInstall = false; SynchronizationContext.SetSynchronizationContext(new WindowsFormsSynchronizationContext()); FormMain window = GorgonExample.Initialize(new DX.Size2(Settings.Default.Resolution.Width, Settings.Default.Resolution.Height), "Space Scene", async(sender, _) => await InitializeAsync(sender as FormMain)); GorgonApplication.Run(window); } catch (Exception ex) { GorgonExample.HandleException(ex); } finally { // Always perform your clean up. if (_keyboard != null) { _keyboard.KeyUp -= Keyboard_KeyUp; } _helpFont?.Dispose(); _fontFactory?.Dispose(); GorgonExample.UnloadResources(); if (_keyboard != null) { _input?.UnregisterDevice(_keyboard); } _input?.Dispose(); _sceneRenderer?.Dispose(); _resources?.Dispose(); _renderer?.Dispose(); _mainRtv?.Dispose(); _screen?.Dispose(); _graphics?.Dispose(); _assemblyCache?.Dispose(); } }
/// <summary>Raises the <see cref="E:System.Windows.Forms.Form.FormClosing" /> event.</summary> /// <param name="e">A <see cref="T:System.Windows.Forms.FormClosingEventArgs" /> that contains the event data. </param> protected override void OnFormClosing(FormClosingEventArgs e) { base.OnFormClosing(e); _blurredImage[1]?.Dispose(); _blurredTarget[1]?.Dispose(); _blurredImage[0]?.Dispose(); _blurredTarget[0]?.Dispose(); _blurEffect?.Dispose(); _helpFont?.Dispose(); _textFont?.Dispose(); _renderer?.Dispose(); _screen?.Dispose(); _graphics?.Dispose(); _assemblyCache?.Dispose(); }
/// <summary>Releases the unmanaged resources used by the <see cref="T:System.Windows.Forms.ApplicationContext" /> and optionally releases the managed resources.</summary> /// <param name="disposing"> /// <see langword="true" /> to release both managed and unmanaged resources; <see langword="false" /> to release only unmanaged resources. </param> protected override void Dispose(bool disposing) { AppDomain.CurrentDomain.AssemblyResolve -= CurrentDomain_AssemblyResolve; ToolPlugInService toolPlugIns = Interlocked.Exchange(ref _toolPlugIns, null); ContentPlugInService contentPlugIns = Interlocked.Exchange(ref _contentPlugIns, null); GraphicsContext context = Interlocked.Exchange(ref _graphicsContext, null); GorgonMefPlugInCache pluginCache = Interlocked.Exchange(ref _pluginCache, null); FormMain mainForm = Interlocked.Exchange(ref _mainForm, null); FormSplash splash = Interlocked.Exchange(ref _splash, null); toolPlugIns?.Dispose(); contentPlugIns?.Dispose(); context?.Dispose(); pluginCache?.Dispose(); mainForm?.Dispose(); splash?.Dispose(); base.Dispose(disposing); }
/// <summary> /// Raises the <see cref="E:System.Windows.Forms.Form.FormClosing" /> event. /// </summary> /// <param name="e">A <see cref="T:System.Windows.Forms.FormClosingEventArgs" /> that contains the event data.</param> protected override void OnFormClosing(FormClosingEventArgs e) { base.OnFormClosing(e); if (_controllers != null) { foreach (IGorgonGamingDevice controller in _controllers) { controller.Dispose(); } } _assemblies?.Dispose(); if (_surface == null) { return; } _surface.Dispose(); _surface = null; }
/// <summary> /// The main entry point for the application. /// </summary> private static void Main() { _log = new GorgonLog("FileSystemProviders", "Tape_Worm"); _log.LogStart(); // Create a plugin assembly cache to hold our plugin assemblies. _pluginAssemblies = new GorgonMefPlugInCache(_log); // Create the plugin service. _pluginService = new GorgonMefPlugInService(_pluginAssemblies); try { Console.WriteLine("Gorgon is capable of mounting virtual file systems for file access. A virtual"); Console.WriteLine("file system root can be a folder on a hard drive, a zip file, or any data store"); Console.WriteLine("(assuming there's a provider for it).\n"); Console.WriteLine("In Gorgon, the types of data that can be mounted as a virtual file system are"); Console.WriteLine("managed by objects called providers. By default, the file system has a folder"); Console.WriteLine("provider. This allows a folder to be mounted as the root of a virtual file\nsystem.\n"); Console.WriteLine("This example will show how to load extra providers that can be used in a file\nsystem.\n"); Console.ForegroundColor = ConsoleColor.White; // Get our file system providers. Console.WriteLine("Found {0} external file system plug ins.\n", LoadFileSystemProviders()); // Loop through each provider and print some info. for (int i = 0; i < _providers.Count; ++i) { // Print some info about the file system provider. Console.ForegroundColor = ConsoleColor.Cyan; Console.WriteLine("{0}. {1}", i + 1, _providers[i].Name); Console.ForegroundColor = ConsoleColor.Gray; Console.WriteLine(" Description: {0}", _providers[i].Description); // Gather the preferred extensions. // File system providers that use a file (like a Zip file) as its root // have a list of file extensions that are preferred. For example, the // Zip provider, expects to find *.zip files. These are merely here // for the convenience of the developer and are formatted like a common // dialog file mask so they can be easily dropped into that control. // In this case, we're going to just strip out the relevant part and // concatenate each preferred extension description into a single string. // // Note that a provider may have multiple preferred extensions. string[] extensionList = (from preferred in _providers[i].PreferredExtensions select $"*.{preferred.Extension}").ToArray(); if (extensionList.Length > 0) { Console.WriteLine(" Preferred Extensions: {0}", string.Join(", ", extensionList)); } } Console.ResetColor(); Console.WriteLine("\nPress any key to close."); Console.ReadKey(); } catch (Exception ex) { ex.Catch(_ => { Console.Clear(); Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine("Exception:\n{0}\n\nStack Trace:{1}", _.Message, _.StackTrace); }, _log); Console.ResetColor(); #if DEBUG Console.ReadKey(); #endif } finally { // Always call dispose so we can unload our temporary application domain. _pluginAssemblies.Dispose(); _log.LogEnd(); } }
private static void Main() { try { Console.Clear(); Console.ForegroundColor = ConsoleColor.White; Console.Title = "Gorgon Example - Input Services."; Console.WriteLine("In this example we will perform the first step in accessing Gorgon's gaming"); Console.WriteLine("device driver API. These drivers will allow access to any gaming device (e.g. a "); Console.WriteLine("joystick, game pad, etc...) that is supported by its underlying native provider."); Console.WriteLine("These drivers are loaded as plug ins and can be used to mix and match various"); Console.WriteLine("types of gaming devices."); Console.WriteLine(); Console.WriteLine("Only connected gaming device drivers will be reported by this example."); Console.WriteLine(); Console.WriteLine("It is important to note that this example does not create any of these devices "); Console.WriteLine("since some providers (e.g. Direct Input) require a window handle to operate."); Console.WriteLine(); Console.WriteLine("Loading gaming device drivers..."); // Load our input factory plugins. IReadOnlyList <IGorgonGamingDeviceDriver> inputPlugIns = GetGamingDeviceDrivers(); // No plugins? No luck. if (inputPlugIns.Count == 0) { Console.ResetColor(); Console.WriteLine("Could not find any gaming device driver plug ins."); return; } // Display the plugin information. Console.WriteLine(); Console.WriteLine("{0} gaming device driver plug ins found:", inputPlugIns.Count); foreach (IGorgonGamingDeviceDriver plugIn in inputPlugIns) { Console.ForegroundColor = ConsoleColor.Cyan; // Enumerate the devices available on the system. try { IReadOnlyList <IGorgonGamingDeviceInfo> devices = plugIn.EnumerateGamingDevices(true); Console.WriteLine($"{plugIn.Description} ({devices.Count} device(s))"); Console.ForegroundColor = ConsoleColor.Gray; for (int i = 0; i < devices.Count; ++i) { Console.WriteLine($"\t{i + 1}. {devices[i].Description}"); } } catch (Exception ex) { Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine("Cannot enumerate devices from {0}. Error:\n{1}", plugIn.Description, ex.Message.Ellipses(Console.WindowWidth - 4)); } } Console.ResetColor(); Console.WriteLine(); Console.WriteLine("Press any key..."); Console.ReadKey(); } catch (Exception ex) { ex.Catch(_ => { Console.Clear(); Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine("Exception:\n{0}\n\nStack Trace:{1}", _.Message, _.StackTrace); }); Console.ResetColor(); Console.ReadKey(); } finally { _pluginCache?.Dispose(); } }
/// <summary> /// The main entry point for the application. /// </summary> private static void Main() { _log = new GorgonLog("ZipFileSystem", "Tape_Worm"); _log.LogStart(); // Create the plugin assembly cache. _pluginAssemblies = new GorgonMefPlugInCache(_log); // Create the plugin service. _pluginService = new GorgonMefPlugInService(_pluginAssemblies); try { Console.WindowHeight = 28; Console.BufferHeight = Console.WindowHeight; Console.ForegroundColor = ConsoleColor.White; Console.WriteLine("This example will mount a zip file as the root of a virtual file system. The"); Console.WriteLine("virtual file system is capable of mounting various types of data such as a zip,"); Console.WriteLine("a file system folder, etc... as the root or a sub directory. You can even"); Console.WriteLine("mount a zip file as the root, and a physical file system directory as a virtual"); Console.WriteLine("sub directory in the same virtual file system and access them as a single"); Console.WriteLine("unified file system."); // Unlike the folder file system example, we need to load // a provider to handle zip files before trying to mount // one. if (!LoadZipProviderPlugIn()) { return; } // Set the following zip file as root on the virtual file system. // // If we wanted to, we could mount a zip file as a sub directory of // the root of the virtual file system. For example, mounting the // directory D:\Dir\zipFile.zip with Mount(@"D:\Dir", "/VFSDir"); would mount // the contents of the D:\Dir\zipFile.zip directory under /VFSDir. // // It's also important to point out that the old Gorgon "file system" // would load files from the system into memory when mounting a // directory. While this version only loads directory and file // information when mounting. This is considerably more efficient. string physicalPath = GetResourcePath(@"FileSystem.zip"); _fileSystem.Mount(physicalPath); Console.Write("\nMounted: "); Console.ForegroundColor = ConsoleColor.Cyan; Console.Write("'{0}'", physicalPath.Ellipses(Console.WindowWidth - 20, true)); Console.ForegroundColor = ConsoleColor.White; Console.Write(" as "); Console.ForegroundColor = ConsoleColor.Cyan; Console.WriteLine("'/'\n"); Console.ForegroundColor = ConsoleColor.White; // Get a count of all sub directories and files under the root directory. IGorgonVirtualDirectory[] directoryList = _fileSystem.FindDirectories("*").ToArray(); // Display directories. Console.WriteLine("Virtual file system contents:"); for (int i = -1; i < directoryList.Length; i++) { IGorgonVirtualDirectory directory = _fileSystem.RootDirectory; // Go into the sub directories under root. if (i > -1) { directory = directoryList[i]; } Console.ForegroundColor = ConsoleColor.Cyan; Console.WriteLine("{0}", directory.FullPath); Console.ForegroundColor = ConsoleColor.Yellow; foreach (IGorgonVirtualFile file in directory.Files) { Console.Write(" {0}", file.Name); // Align the size to the same place. Console.CursorLeft = 65; Console.WriteLine("{0}", file.Size.FormatMemory()); } } Console.ResetColor(); Console.WriteLine("\nPress any key to close."); Console.ReadKey(); } catch (Exception ex) { ex.Catch(_ => { Console.Clear(); Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine("Exception:\n{0}\n\nStack Trace:{1}", _.Message, _.StackTrace); Console.ResetColor(); #if DEBUG Console.ReadKey(); #endif }); } finally { // Always dispose the cache to clean up the temporary app domain it creates. _pluginAssemblies.Dispose(); _log.LogEnd(); } }
private static void Main(string[] args) { _log = new GorgonLog("Example 004", "Tape_Worm", typeof(Program).Assembly.GetName().Version); // Set up the assembly cache. // We'll need the assemblies loaded into this object in order to load our plugin types. var pluginCache = new GorgonMefPlugInCache(_log); // Create our plugin service. // This takes the cache of assemblies we just created. IGorgonPlugInService pluginService = new GorgonMefPlugInService(pluginCache); try { Console.Title = "Gorgon Example #4 - PlugIns."; Console.ForegroundColor = ConsoleColor.White; Console.WriteLine("This is an example to show how to create and use custom plugins."); Console.WriteLine("The plugin interface in Gorgon is quite flexible and gives the developer"); Console.WriteLine("the ability to allow extensions to their own applications.\n"); Console.ResetColor(); pluginCache.LoadPlugInAssemblies(Path.GetDirectoryName(Environment.GetCommandLineArgs()[0]).FormatDirectory(Path.DirectorySeparatorChar), "Example004.*PlugIn.dll"); Console.WriteLine("{0} plugin assemblies found.", pluginCache.PlugInAssemblies.Count); if (pluginCache.PlugInAssemblies.Count == 0) { return; } // Our text writer plugin interfaces. IList <TextColorWriter> writers = new List <TextColorWriter>(); // Create our plugin instances, we'll limit to 9 entries just for giggles. TextColorPlugIn[] plugins = (from pluginName in pluginService.GetPlugInNames() let plugin = pluginService.GetPlugIn <TextColorPlugIn>(pluginName) where plugin != null select plugin).ToArray(); // Display a list of the available plugins. Console.WriteLine("\n{0} Plug-ins loaded:\n", plugins.Length); for (int i = 0; i < plugins.Length; i++) { // Here's where we make use of our description. Console.WriteLine("{0}. {1} ({2})", i + 1, plugins[i].Description, plugins[i].GetType().FullName); // Create the text writer interface and add it to the list. writers.Add(plugins[i].CreateWriter()); } Console.Write("0. Quit\n\nSelect a plugin: "); // Loop until we quit. while (true) { if (!Console.KeyAvailable) { continue; } Console.ResetColor(); // Remember our cursor coordinates. int cursorX = Console.CursorLeft; // Cursor position. int cursorY = Console.CursorTop; ConsoleKeyInfo keyValue = Console.ReadKey(false); if (char.IsNumber(keyValue.KeyChar)) { if (keyValue.KeyChar == '0') { break; } // Move to the next line and clear the previous line of text. Console.WriteLine(); Console.Write(new string(' ', Console.BufferWidth - 1)); Console.CursorLeft = 0; // Call our text color writer to print the text in the plugin color. int writerIndex = keyValue.KeyChar - '0'; writers[writerIndex - 1].WriteString($"You pressed #{writerIndex}."); } Console.CursorTop = cursorY; Console.CursorLeft = cursorX; } } catch (Exception ex) { ex.Catch(_ => { Console.Clear(); Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine("Exception:\n{0}\n\nStack Trace:{1}", ex.Message, ex.StackTrace); }, _log); Console.ResetColor(); #if DEBUG Console.ReadKey(true); #endif } finally { // Always call dispose so we can unload our temporary application domain. //pluginAssemblies.Dispose(); pluginCache.Dispose(); _log.LogEnd(); } }