public XNIProcessor() : base() { _metaData = new Dictionary <string, ControlMetadata>(); attribImporter = new Importers(); LoadAllControlMetadata(); }
static void LoadGameDll(string BasePath) { BasePath = Path.Combine(BasePath, "Game.dll"); Assembly GameAssembly = Reflect.LoadAssembly(BasePath); Type[] GameImplementations = Reflect.GetAllImplementationsOf(GameAssembly, typeof(LibTechGame)).ToArray(); if (GameImplementations.Length == 0) { GConsole.WriteLine("No game implementations found in " + BasePath); Environment.Exit(0); } else if (GameImplementations.Length > 1) { GConsole.WriteLine("Too many game implementations in " + BasePath); Environment.Exit(0); } AppDomain.CurrentDomain.AssemblyResolve += (S, E) => TryLoadAssembly(E.Name, BasePath); Importers.RegisterAll(GameAssembly); Game = (LibTechGame)Activator.CreateInstance(GameImplementations[0]); Game.Load(); }
public virtual void Register(IImporter importer) { if (importer == null) throw new ArgumentNullException("importer"); Importers.Put(importer); }
void Load(string DefFile) { string[] Lines = File.ReadAllLines(DefFile); RelativeSpawns = new List <Vector3>(); foreach (var L in Lines) { string[] Args = L.Trim().Split(' '); switch (Args[0].ToLower()) { case "model": WorldModel = Importers.Load <Model>(Args[1]); break; case "spawn": RelativeSpawns.Add(new Vector3(Args[1].ParseToFloat(), Args[2].ParseToFloat(), Args[3].ParseToFloat())); break; default: GConsole.WriteLine("Invalid world argument: {0}", L); break; } } if (WorldModel == null) { throw new Exception("World model was not loaded"); } }
public List <string> GetTopicImportUids() { lock (Importers) { return(Importers.Select(i => i.Key).ToList()); } }
public string StartTopicImport(string uid, MqttImportTopicParameters parameters) { if (parameters == null) { throw new ArgumentNullException(nameof(parameters)); } if (string.IsNullOrEmpty(uid)) { uid = Guid.NewGuid().ToString("D"); } var importer = new MqttTopicImporter(parameters, this, _logger); importer.Start(); lock (Importers) { if (Importers.TryGetValue(uid, out var existingImporter)) { existingImporter.Stop(); } Importers[uid] = importer; } _logger.Log(LogLevel.Information, "Started importer '{0}' for topic '{1}' from server '{2}'.", uid, parameters.Topic, parameters.Server); return(uid); }
private static List <FavoriteConfigurationElement> ImportItemsFromFile(IPersistence persistence, string path, string fileName = DUPLICIT_ITEMS_FILE) { string fullFileName = Path.Combine(path, fileName); var importers = new Importers(persistence); return(importers.ImportFavorites(fullFileName)); }
public void RegisterImporter <T, U>() where U : ContentImporter <T> { if (Importers.ContainsKey(typeof(U))) { return; // TODO: Throw/log something in future? } Importers.Add(typeof(T), Activator.CreateInstance <U>()); }
public virtual void Register(IImporter importer) { if (importer == null) { throw new ArgumentNullException(nameof(importer)); } Importers.Put(importer); }
internal OrganizeFavoritesForm(IPersistence persistence, ConnectionManager connectionManager, FavoriteIcons favoriteIcons) { InitializeComponent(); this.persistence = persistence; this.connectionManager = connectionManager; this.favoriteIcons = favoriteIcons; InitializeDataGrid(); this.importers = new Importers(this.persistence); ImportOpenFileDialog.Filter = this.importers.GetProvidersDialogFilter(); UpdateCountLabels(); }
static void RunGame() { InitConsole(); FileWatcher.Init("content"); Importers.RegisterAll(Reflect.GetExeAssembly()); Engine.GUI = new libGUI(); Engine.Window = new RenderWindow(Engine.WindowWidth, Engine.WindowHeight, "libTech", Engine.WindowResizable); Engine.Window.OnMouseMove += Engine.GUI.OnMouseMove; Engine.Window.OnKey += OnKey; Engine.Window.OnChar += Engine.GUI.OnChar; Engine.GUI.Init(Engine.Window, new ShaderProgram(new ShaderStage(ShaderType.VertexShader, "content/shaders/gui.vert"), new ShaderStage(ShaderType.FragmentShader, "content/shaders/gui.frag"))); GConsole.Init(); GConsole.WriteLine("Running {0}", RenderAPI.Renderer, RenderAPI.Version); GConsole.Color = FishGfx.Color.Orange; foreach (var DllName in FailedToLoadDLLs) { GConsole.WriteLine("Failed to load '{0}'", DllName); } GConsole.Color = FishGfx.Color.White; // Graphics init Gfx.ShadersDirectory = "content/shaders"; //Gfx.Line3D = DefaultShaders.Line3D; //Gfx.Point3D = DefaultShaders.Point3D; //Gfx.Default3D = DefaultShaders.DefaultColor3D; // Camera init Engine.Camera2D = new Camera(); Engine.Camera2D.SetOrthogonal(0, 0, Engine.Window.WindowWidth, Engine.Window.WindowHeight); Engine.Camera3D = new Camera(); Engine.Camera3D.SetPerspective(Engine.Window.WindowWidth, Engine.Window.WindowHeight); LoadGameDll(Engine.GamePath); float Dt = 0; while (!Engine.Window.ShouldClose) { Update(Dt); Draw(Dt); Thread.Sleep(0); } }
private void DropFiles(Form parentForm) { var files = this.data.GetData(DataFormats.FileDrop) as String[]; if (files == null) { return; } var importers = new Importers(this.persistence); var toImport = importers.ImportFavorites(files); this.ApplyTargetGroup(toImport); var managedImport = new ImportWithDialogs(parentForm, this.persistence, this.connectinManager); managedImport.Import(toImport); }
/// <summary> /// Fills the document whith the result of the import /// </summary> /// <param name="importResult"></param> public void CreateDocument(Importers.RtfDeltaImporter.Document importResult) { AddParagraph("This document lists the changes that have been applied during the imporation of a new release of the specification"); AddSubParagraph("Modified paragraphs"); AddParagraph("This section lists the paragraphs that have been modified during the importation"); foreach (Importers.RtfDeltaImporter.Paragraph paragraph in importResult.ChangedParagraphs) { AddSubParagraph(paragraph.Id); AddSubParagraph("Original contents"); AddParagraph(ValidText(paragraph.OriginalText)); CloseSubParagraph(); AddSubParagraph("New contents"); AddParagraph(ValidText(paragraph.Text)); CloseSubParagraph(); CloseSubParagraph(); } CloseSubParagraph(); AddSubParagraph("New paragraphs"); AddParagraph("This section lists the paragraphs that have been added during the importation"); AddTable(new string[] { "Paragraph", "Contents" }, new int[] { 40, 100 }); foreach (Importers.RtfDeltaImporter.Paragraph paragraph in importResult.NewParagraphs) { AddRow(paragraph.Id, paragraph.Text); } CloseSubParagraph(); AddSubParagraph("Removed paragraphs"); AddParagraph("This section lists the paragraphs that have been removed during the importation"); AddTable(new string[] { "Paragraph", "Contents" }, new int[] { 40, 100 }); foreach (Importers.RtfDeltaImporter.Paragraph paragraph in importResult.RemovedParagraphs) { AddRow(paragraph.Id, paragraph.Text); } CloseSubParagraph(); AddSubParagraph("Errors during importation"); AddParagraph("This section lists the errors encountered during importation"); AddTable(new string[] { "Paragraph", "Error" }, new int[] { 40, 100 }); foreach (Importers.RtfDeltaImporter.ImportationError error in importResult.Errors) { AddRow(error.Paragraph.Id, error.Message); } CloseSubParagraph(); }
public void StopTopicImport(string uid) { if (uid == null) { throw new ArgumentNullException(nameof(uid)); } lock (Importers) { if (Importers.TryGetValue(uid, out var importer)) { importer.Stop(); _logger.Log(LogLevel.Information, "Stopped importer '{0}'."); } Importers.Remove(uid); } }
public T Load <T>(string relativePath) where T : class { var completePath = Path.Combine(ContentRoot, relativePath); if (!File.Exists(completePath)) { throw new ContentPathException(completePath, "Could not find a file at the provided path."); } var type = typeof(T); if (!Importers.ContainsKey(type)) { throw new ContentUnsupportedException(type, "The requested type has no importers registered."); } return(Importers[type].ImportObject(completePath) as T); }
public override void Load() { FontTest = new MSDFFont("content/fonts/Hack.ttf"); CrosshairTex = Importers.Load <Texture>("content/textures/crosshair_default.png"); /*MSDF = new ShaderProgram(new ShaderStage(ShaderType.VertexShader, "content/shaders/default.vert"), * new ShaderStage(ShaderType.FragmentShader, "content/shaders/msdf.frag"));*/ Ply = new Player(); Engine.SpawnEntity(Ply); GameWorld = new World("content/maps/sandbox.txt"); Ply.Position = GameWorld.RelativeSpawns.FirstOrDefault(); Engine.SpawnEntity(GameWorld); GConsole.RegisterCommand("getcam", () => { GConsole.WriteLine("Pos: " + Ply.Position.ToString()); }); }
private void TraceExtensions() { Trace.TraceInformation("Factories {0}:", Factories.Count); Factories.ForEach(x => Trace.TraceInformation(x.ToString())); Trace.TraceInformation("Importers {0}:", Importers.Count); Importers.ForEach(x => Trace.TraceInformation(x.ToString())); Trace.TraceInformation("Exporters: {0}", Exporters.Count); Exporters.ForEach(x => Trace.TraceInformation(x.ToString())); Trace.TraceInformation("Visualizers: {0}", Visualizers.Count); Visualizers.ForEach(x => Trace.TraceInformation(x.ToString())); Trace.TraceInformation("Settings: {0}", Settings.Count); Settings.ForEach(x => Trace.TraceInformation(x.ToString())); Trace.TraceInformation("AttributeProviders: {0}", AttributeProviders.Count); AttributeProviders.ForEach(x => Trace.TraceInformation(x.ToString())); }
static void LoadGameDll(string BasePath) { string GameDllPath = Path.Combine(BasePath, "Game.dll"); Assembly GameAssembly = Assembly.GetExecutingAssembly(); bool LoadImporters = false; if (File.Exists(GameDllPath)) { GameAssembly = Reflect.LoadAssembly(GameDllPath); LoadImporters = true; } Type[] GameImplementations = Reflect.GetAllImplementationsOf(GameAssembly, typeof(LibTechGame)).ToArray(); if (GameImplementations.Length == 0) { GConsole.WriteLine("No game implementations found in " + GameDllPath); Environment.Exit(0); } else if (GameImplementations.Length > 1) { GConsole.WriteLine("Too many game implementations in " + GameDllPath); Environment.Exit(0); } AppDomain.CurrentDomain.AssemblyResolve += (S, E) => TryLoadAssembly(E.Name, GameDllPath); if (LoadImporters) { Importers.RegisterAll(GameAssembly); } Entity.LoadAllTypes(); Engine.Game = (LibTechGame)Activator.CreateInstance(GameImplementations[0]); Engine.Game.Load(); }
internal void Load(Editor editor, string path) { Verify.DirectoryExists(path, "path"); Trace.TraceInformation("Loading default editor extensions at folder {0}", Path.GetFullPath(path)); var extensions = Directory.GetFiles(path, "*.DLL").Concat(Directory.GetFiles(path, "*.EXE")) .SelectMany(file => LoadExportedTypes(file)) .Select(type => new { Export = type.GetCustomAttributes(typeof(ExportAttribute), false).SingleOrDefault(), Type = type }) .Where(pair => pair.Export != null) .ToLookup(pair => ((ExportAttribute)pair.Export).ContractType, pair => pair.Type); AttributeProviders.AddRange(from type in extensions[typeof(IAttributeProvider)] where !AttributeProviders.Any(x => x.GetType() == type) select(IAttributeProvider) Activator.CreateInstance(type)); Factories.AddRange(from type in extensions[typeof(IFactory)] where !Factories.Any(x => x.Value.GetType() == type) select new Extension <IFactory>(editor, (IFactory)Activator.CreateInstance(type))); Visualizers.AddRange(from type in extensions[typeof(IVisualizer)] where !Visualizers.Any(x => x.Value.GetType() == type) select new Extension <IVisualizer>(editor, (IVisualizer)Activator.CreateInstance(type))); Tools.AddRange(from type in extensions[typeof(ITool)] where !Tools.Any(x => x.Value.GetType() == type) select new Extension <ITool>(editor, (ITool)Activator.CreateInstance(type))); Importers.AddRange(from type in extensions[typeof(IImporter)] where !Importers.Any(x => x.Value.GetType() == type) select new Extension <IImporter>(editor, (IImporter)Activator.CreateInstance(type))); Exporters.AddRange(from type in extensions[typeof(IExporter)] where !Exporters.Any(x => x.Value.GetType() == type) select new Extension <IExporter>(editor, (IExporter)Activator.CreateInstance(type))); Settings.AddRange(from type in extensions[typeof(ISettings)] where !Settings.Any(x => x.Value.GetType() == type) select new Extension <ISettings>(editor, (ISettings)Activator.CreateInstance(type))); TraceExtensions(); Trace.TraceInformation("Extensions Loaded."); }
public VersionSpecificImporter_6_6_5_15100(Importers.IImporter importer) : base(importer) { }
public static T Load <T>(string Pth) { return(Importers.Get <T>(Pth).Load(Pth)); }
/// <summary> /// Constructor /// </summary> /// <param name="aDictionary"></param> /// <param name="importResult"></param> public DeltaImportReportHandler(DataDictionary.Dictionary aDictionary, Importers.RtfDeltaImporter.Document importResult, string baseFileName) : base(aDictionary) { createFileName(baseFileName); ImportResult = importResult; }
private BankStatementImporterRepository CreateSubject() { return(new BankStatementImporterRepository(Importers.Select(i => i.Object))); }
protected VersionSpecificImporter(Importers.IImporter importer) { Importer = importer; }
/// <summary> /// Fills the document whith the result of the import /// </summary> /// <param name="importResult"></param> public void CreateDocument(Importers.RtfDeltaImporter.Document importResult) { AddParagraph( "This document lists the changes that have been applied during the imporation of a new release of the specification"); AddSubParagraph("Summary"); AddParagraph("This section presents the summary of the document importation"); AddTable(new string[] {"Item", "Count", "Comment"}, new int[] {40, 40, 60}); AddRow("Paragraph count", importResult.Paragraphs.Count.ToString(), "This is the number of paragraphs processed during the importation of the document"); AddRow("Modified paragraphs", importResult.ChangedParagraphs.Count.ToString(), "This is the number of paragraphs that have been changed between the two revisions"); AddRow("New paragraphs", importResult.NewParagraphs.Count.ToString(), "The is the number of new paragraphs in this new revision"); AddRow("Moved paragraphs", importResult.MovedParagraphs.Count.ToString(), "The is the number of paragraphs that have been moved around in this new revision"); AddRow("Deleted paragraphs", importResult.RemovedParagraphs.Count.ToString(), "This is the number of paragraphs that have been deleted in this new revision"); CloseSubParagraph(); AddSubParagraph("Modified paragraphs"); AddParagraph("This section lists the paragraphs that have been modified during the importation"); foreach (Paragraph paragraph in importResult.ChangedParagraphs) { AddSubParagraph(paragraph.Id); AddSubParagraph("Original contents"); AddParagraph(ValidText(paragraph.OriginalText)); CloseSubParagraph(); AddSubParagraph("New contents"); AddParagraph(ValidText(paragraph.Text)); CloseSubParagraph(); CloseSubParagraph(); } CloseSubParagraph(); AddSubParagraph("New paragraphs"); AddParagraph("This section lists the paragraphs that have been added during the importation"); AddTable(new string[] {"Paragraph", "Contents"}, new int[] {40, 100}); foreach (Paragraph paragraph in importResult.NewParagraphs) { AddRow(paragraph.Id, paragraph.Text); } CloseSubParagraph(); AddSubParagraph("Removed paragraphs"); AddParagraph("This section lists the paragraphs that have been removed during the importation"); AddTable(new string[] {"Paragraph", "Contents"}, new int[] {40, 100}); foreach (Paragraph paragraph in importResult.RemovedParagraphs) { AddRow(paragraph.Id, paragraph.Text); } CloseSubParagraph(); AddSubParagraph("Moved paragraphs"); AddParagraph( "This section lists the paragraphs that have been moved during the importation. No change has been performed in the model. Review should be performed manually."); AddTable(new string[] {"Paragraph", "Contents", "Initial position"}, new int[] {40, 100, 40}); foreach (Paragraph paragraph in importResult.MovedParagraphs) { AddRow(paragraph.Id, paragraph.Text, paragraph.OriginalText); } CloseSubParagraph(); AddSubParagraph("Errors during importation"); AddParagraph( "This section lists the errors encountered during importation. No change has been performed in the model. Review should be performed manually."); AddTable(new string[] {"Paragraph", "Text", "Error"}, new int[] {30, 80, 80}); foreach (ImportationError error in importResult.Errors) { AddRow(error.Paragraph.Id, error.Paragraph.Text, error.Message); } CloseSubParagraph(); AddSubParagraph("List of paragraphs"); AddParagraph("This section lists the paragraphs that have been processed during the importation"); AddTable(new string[] {"Paragraph", "", "", "", ""}, new int[] {30, 30, 30, 30, 30}); int i = 0; string[] data = new string[5] {"", "", "", "", ""}; foreach (Paragraph paragraph in importResult.Paragraphs.Values) { data[i] = paragraph.Id; i += 1; if (i == data.Length) { AddRow(data); i = 0; data = new string[5] {"", "", "", "", ""}; } } if (i > 0) { AddRow(data); } CloseSubParagraph(); }
internal Extension <IImporter> FindImporter(Type type) { return(Importers.SingleOrDefault(e => e.IsDefault && e.Value.TargetType == type) ?? Importers.FirstOrDefault(e => e.Value.TargetType == type)); }
static void Main(string[] args) { CVar.InitMode = true; CVar.Register("game", "basegame", CVarType.Replicated | CVarType.Init, (This, Old, New) => This.Value = Path.GetFullPath((string)New)); CVar.Register("width", 1366, CVarType.Archive); CVar.Register("height", 768, CVarType.Archive); CVar.Register("borderless", false, CVarType.Archive); CVar.Register("resizable", false, CVarType.Archive); CVar.Register("gl_doublebuffer", true, CVarType.Archive); CVar.Register("gl_samples", 8, CVarType.Archive); CVar.Register("gl_forwardcompat", true, CVarType.Archive | CVarType.Init | CVarType.Unsafe); CVar.Register("gl_major", 4, CVarType.Archive | CVarType.Init | CVarType.Unsafe); CVar.Register("gl_minor", 5, CVarType.Archive | CVarType.Init | CVarType.Unsafe); // Parse all arguments and set CVars foreach (var Arg in ArgumentParser.All) { switch (Arg.Key) { case "console": GConsole.Open = true; break; default: { CVar CVar = CVar.Find(Arg.Key); if (CVar != null) { CVar.Value = Arg.Value.LastOrDefault(); } else { CVar.Register(Arg.Key, Arg.Value.LastOrDefault()); } break; } } } CVar.InitMode = false; foreach (var CVar in CVar.GetAll()) { GConsole.WriteLine(CVar); } FileWatcher.Init("content"); Importers.RegisterAll(Reflect.GetExeAssembly()); CreateContext(); InitPhysics(); LoadContent(); Stopwatch SWatch = Stopwatch.StartNew(); float Target = 1.0f / 120; float Dt = Target; TextureTarget Tgt = TextureTarget.Texture2dMultisample; if (CVar.GetInt("gl_samples") == 0) { Tgt = TextureTarget.Texture2d; } Texture ColorTex = new Texture(Width, Height, Tgt, 1, InternalFormat.Rgb16f); Texture DepthTex = new Texture(Width, Height, Tgt, 1, InternalFormat.Depth24Stencil8); Framebuffer FB = new Framebuffer(); FB.AttachColorTexture(ColorTex); FB.AttachDepthTexture(DepthTex); Texture SkyboxCubeMap = new Texture(1024, 1024, TextureTarget.TextureCubeMap, 1, InternalFormat.Srgb8Alpha8); SkyboxCubeMap.SetFilter(Gl.LINEAR, Gl.LINEAR); SkyboxCubeMap.SubImage3D(Image.FromFile("content/textures/skybox/interstellar/front.png"), Z: Texture.FRONT); SkyboxCubeMap.SubImage3D(Image.FromFile("content/textures/skybox/interstellar/back.png"), Z: Texture.BACK); SkyboxCubeMap.SubImage3D(Image.FromFile("content/textures/skybox/interstellar/left.png"), Z: Texture.LEFT); SkyboxCubeMap.SubImage3D(Image.FromFile("content/textures/skybox/interstellar/right.png"), Z: Texture.RIGHT); SkyboxCubeMap.SubImage3D(Image.FromFile("content/textures/skybox/interstellar/top.png"), Z: Texture.TOP); SkyboxCubeMap.SubImage3D(Image.FromFile("content/textures/skybox/interstellar/bottom.png"), Z: Texture.BOTTOM); //FB.Clear(new Vector4(1, 0, 0, 1)); Model SkyboxCube = Importers.Load <Model>("content/models/cube.obj"); SkyboxCube.Scale = new Vector3(2); SkyboxCube.Meshes[0].Material.Shader = ShaderProgram.Skybox; SkyboxCube.Meshes[0].Material.Diffuse = SkyboxCubeMap; //bool DoDebug = true; while (!Glfw.WindowShouldClose(Window)) { /*if (Khronos.KhronosApi.LogEnabled) { * Khronos.KhronosApi.LogCommand("END FRAME", null, null); * Khronos.KhronosApi.LogEnabled = false; * } * * if (DoDebug) { * DoDebug = false; * Khronos.KhronosApi.LogEnabled = true; * Khronos.KhronosApi.LogCommand("BEGIN FRAME", null, null); * }*/ Update(Dt); Gl.Clear(ClearBufferMask.DepthBufferBit | ClearBufferMask.ColorBufferBit | ClearBufferMask.StencilBufferBit); FB.Bind(); { Gl.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit | ClearBufferMask.StencilBufferBit); SetupState(); Gl.Disable(EnableCap.CullFace); Gl.DepthMask(false); SkyboxCube.Position = Camera.ActiveCamera?.Position ?? Vector3.Zero; SkyboxCube.Draw(); Gl.DepthMask(true); DrawScene(Dt); } FB.Unbind(); // Swap to GUI camera Gl.Disable(EnableCap.DepthTest); Gl.Disable(EnableCap.CullFace); Camera.ActiveCamera = Camera.GUICamera; Immediate.UseShaders(() => { if (ColorTex.Multisampled) { Immediate.TriangleShader = ShaderProgram.PostMultisample; Immediate.TriangleShader.Uniform2f("TexSize", new Vector2(ColorTex.Width, ColorTex.Height)); } else { Immediate.TriangleShader = ShaderProgram.Post; } Immediate.TriangleShader.Uniform1f("Exposure", 1.0f); Gl.Enable(EnableCap.FramebufferSrgb); Immediate.Texture2D(Vector2.Zero, ColorTex, UVInvertY: true); Gl.Disable(EnableCap.FramebufferSrgb); }); DrawGUI(Dt); Glfw.SwapBuffers(Window); // Cap at Target framerate while ((float)SWatch.ElapsedMilliseconds / 1000 < Target) { ; } Dt = (float)SWatch.ElapsedMilliseconds / 1000; FPS = (int)(1.0f / Dt); SWatch.Restart(); } Environment.Exit(0); }
public static Dictionary <string, string> AvailableImporters() { return(Importers .OrderBy(i => i.Value.Emulator) .ToDictionary(tkey => tkey.Value.Emulator, tvalue => tvalue.Value.Extension)); }
/// <summary> /// Given a file, read its headers, and find a suitable importer for it /// </summary> public static Importer ImporterFor(CsvParser csv) { return(Importers.FirstOrDefault(i => i.Matches(csv))); }
static void LoadContent() { string GameDllPath = Path.Combine(CVar.GetString("game"), "Game.dll"); if (!File.Exists(GameDllPath)) { FatalError("File not found: {0}", GameDllPath); } Assembly GameAssembly = Reflect.LoadAssembly(GameDllPath); Importers.RegisterAll(GameAssembly); Type[] GameImplementations = Reflect.GetAllImplementationsOf(GameAssembly, typeof(LibTechGame)).ToArray(); if (GameImplementations.Length == 0) { FatalError("Could not find game implementation in {0}", GameDllPath); } if (GameImplementations.Length > 1) { FatalError("Found too many game implementations in {0}", GameDllPath); } Game = (LibTechGame)Activator.CreateInstance(GameImplementations[0]); Game.Load(); RenderDevice = new RenderDevice(ShaderProgram.GUI, Width, Height); NuklearAPI.Init(RenderDevice); NuklearAPI.SetClipboardCallback((Txt) => { if (string.IsNullOrEmpty(Txt)) { return; } Glfw.SetClipboardString(Window, Txt); }, () => { string Str = Glfw.GetClipboardString(Window); if (Str == null) { Str = ""; } return(Str); }); Glfw.SetCursorPosCallback(Window, (Wnd, X, Y) => { RenderDevice.OnMouseMove((int)X, (int)Y); }); Glfw.SetMouseButtonCallback(Window, (Wnd, Button, State, Mods) => { NuklearEvent.MouseButton NkButton; bool IsDown = State == Glfw.InputState.Press ? true : false; if (!(State == Glfw.InputState.Press || State == Glfw.InputState.Release)) { return; } if (Button == Glfw.MouseButton.ButtonLeft) { NkButton = NuklearEvent.MouseButton.Left; } else if (Button == Glfw.MouseButton.ButtonMiddle) { NkButton = NuklearEvent.MouseButton.Middle; } else if (Button == Glfw.MouseButton.ButtonRight) { NkButton = NuklearEvent.MouseButton.Right; } else { return; } RenderDevice.OnMouseButton(NkButton, (int)MousePos.X, (int)MousePos.Y, IsDown); }); Glfw.SetScrollCallback(Window, (Wnd, X, Y) => { RenderDevice.OnScroll((float)X, (float)Y); }); Glfw.SetCharCallback(Window, (Wnd, Chr) => { RenderDevice.OnText(((char)Chr).ToString()); }); Glfw.SetKeyCallback(Window, (Wnd, KCode, SCode, State, Mods) => { if (KCode == Glfw.KeyCode.F1 && State == Glfw.InputState.Press) { GConsole.Open = true; } NkKeys K = ConvertToNkKey(KCode, Mods); if (K != NkKeys.None) { RenderDevice.OnKey(K, State == Glfw.InputState.Press); if (State == Glfw.InputState.Repeat) { RenderDevice.OnKey(K, true); } } }); Glfw.SetDropCallback(Window, (Wnd, Cnt, Paths) => { DragDropPaths = Paths; }); }
/// <summary> /// Returns a value indicating whether or not there is an importer for the given extension /// </summary> public static bool IsValidMovieExtension(string extension) { return(Importers .Select(i => i.Value) .Any(e => string.Equals(extension, e.Extension, StringComparison.OrdinalIgnoreCase))); }
static void RunGame() { TimeStopwatch = Stopwatch.StartNew(); InitConsole(); Engine.VFS = new VirtualFileSystem(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)); Engine.VFS.Mount("/content/", "./content"); Engine.VFS.Mount("/materials/", "C:/Program Files (x86)/Steam/steamapps/common/GarrysMod/garrysmod/addons/quake_3_gmod_160207505/materials"); string[] SourceGameDirs = Engine.SourceGameDirs.Value.Split(new[] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries).Where(Pth => Directory.Exists(Pth)).ToArray(); if (SourceGameDirs.Length > 0) { foreach (var GameDir in SourceGameDirs) { Engine.VFS.GetSourceProvider().AddRoot(GameDir); } } if (Directory.Exists(Path.Combine(Engine.GamePath, "content"))) { Engine.VFS.Mount("/content/", Path.Combine(Engine.GamePath, "content")); } List <string> ZipResources = new List <string>(); ZipResources.AddRange(Engine.VFS.GetFiles("/content/").Where(P => Path.GetExtension(P) == ".pk3" || Path.GetExtension(P) == ".zip")); foreach (var ZipResource in ZipResources) { Engine.VFS.MountArchive("/content/", ZipResource); } FileWatcher.Init("content"); Importers.RegisterAll(Reflect.GetExeAssembly()); Engine.GUI = new NuklearGUI(); Engine.Window = new RenderWindow(Engine.WindowWidth, Engine.WindowHeight, "libTech", Engine.WindowResizable); Engine.Window.OnMouseMove += Engine.GUI.OnMouseMove; Engine.Window.OnKey += OnKey; Engine.Window.OnChar += Engine.GUI.OnChar; RenderDoc.Init(); GConsole.Init(); GConsole.WriteLine("Running {0}", RenderAPI.Renderer, RenderAPI.Version); string ExtensionsFile = "extensions.txt"; if (File.Exists(ExtensionsFile)) { File.Delete(ExtensionsFile); } File.WriteAllLines(ExtensionsFile, RenderAPI.Extensions); EngineRenderer.Init(); Engine.GUI.Init(Engine.Window, new ShaderProgram(new ShaderStage(ShaderType.VertexShader, "content/shaders/gui.vert"), new ShaderStage(ShaderType.FragmentShader, "content/shaders/gui.frag"))); Engine.UI = new libGUI(Engine.Window); DbgDraw.Init(); Lua.Init(); GConsole.Color = Color.Orange; foreach (var DllName in FailedToLoadDLLs) { GConsole.WriteLine("Failed to load '{0}'", DllName); } GConsole.Color = Color.White; // Graphics init Gfx.ShadersDirectory = "content/shaders"; //Gfx.Line3D = DefaultShaders.Line3D; //Gfx.Point3D = DefaultShaders.Point3D; //Gfx.Default3D = DefaultShaders.DefaultColor3D; // Camera init Engine.Camera2D = new Camera(); Engine.Camera2D.SetOrthogonal(0, 0, Engine.Window.WindowWidth, Engine.Window.WindowHeight); Engine.Camera3D = new Camera(); Engine.Camera3D.SetPerspective(Engine.Window.WindowWidth, Engine.Window.WindowHeight, FarPlane: 16000); LoadGameDll(Engine.GamePath); Stopwatch SWatch = Stopwatch.StartNew(); int MaxFPS = Engine.MaxFPS; if (MaxFPS <= 0) { MaxFPS = 900; } float FrameCap = 1.0f / MaxFPS; float Dt = 1.0f / 60.0f; while (!Engine.Window.ShouldClose) { Engine.FrameTime.Push(Dt); Update(Dt); EngineRenderer.Draw(Dt); // TODO: Move frame cap somewhere else while ((SWatch.ElapsedMilliseconds / 1000.0f) < FrameCap) { Thread.Sleep(0); } Dt = SWatch.ElapsedMilliseconds / 1000.0f; SWatch.Restart(); } }
private static Type ImporterForExtension(string ext) { return(Importers.FirstOrDefault(i => string.Equals(i.Value.Extension, ext, StringComparison.OrdinalIgnoreCase)).Key); }
public TLCGenPluginManager(string pluginpath) { try { if (Directory.Exists(pluginpath)) { // Find all Generator DLL's foreach (String file in Directory.GetFiles(pluginpath)) { if (Path.GetExtension(file).ToLower() == ".dll") { // Find and loop all types from the assembly var assemblyInstance = Assembly.LoadFrom(file); var types = assemblyInstance.GetTypes(); var bFound = false; foreach (Type t in types) { // Find TLCGenPluginAttribute attribute, and if found, continue var attr = (TLCGenPluginAttribute)Attribute.GetCustomAttribute(t, typeof(TLCGenPluginAttribute)); if (attr != null) { var plugin = Activator.CreateInstance(t); if ((attr.PluginElements & TLCGenPluginElems.Generator) == TLCGenPluginElems.Generator) { Generators.Add(plugin as ITLCGenGenerator); } if ((attr.PluginElements & TLCGenPluginElems.Importer) == TLCGenPluginElems.Importer) { Importers.Add(plugin as ITLCGenImporter); } if ((attr.PluginElements & TLCGenPluginElems.MenuControl) == TLCGenPluginElems.MenuControl) { MenuItems.Add(plugin as ITLCGenMenuItem); } if ((attr.PluginElements & TLCGenPluginElems.TabControl) == TLCGenPluginElems.TabControl) { TabItems.Add(plugin as ITLCGenTabItem); } if ((attr.PluginElements & TLCGenPluginElems.ToolBarControl) == TLCGenPluginElems.ToolBarControl) { TabItems.Add(plugin as ITLCGenTabItem); } bFound = true; } } if (!bFound) { //#if !DEBUG System.Windows.MessageBox.Show($"Library {file} wordt niet herkend als TLCGen addin."); //#endif } } } } else { } } catch { throw new NotImplementedException(); } }