Genesis Game Engine 4

    • Beta
    • Open Source

    Es gibt 11 Antworten in diesem Thema. Der letzte Beitrag () ist von Andy.

      Genesis Game Engine 4

      Genesis Game Engine

      Was ist die „Genesis Game Engine“?

      Die Genesis Game Engine ist ein auf C# basierendes Framework zum Erstellen von 2D- und 3D-Spielen. Dabei liegt der Fokus auf einer einfachen Implementierung und Verwaltung von Szenen, Spielelementen und deren Komponenten. Trotzdem wurde darauf geachtet, Funktionen wie das Rendern, die Physik und die Komponenten so abstrakt wie möglich zu gestalten, um eigene Anpassungen leicht umsetzbar zu machen.

      Wie funktioniert die Game Engine?

      Die Funktionsweise der Engine ist leicht verständlich. Es wird immer nur eine Szene aktiv gerendert. Jede Szene kann eine beliebige Anzahl von Layern haben, zu denen dann Spielelemente hinzugefügt werden können. Diese können Sprites, 3D-Objekte oder auch leere Elemente sein. Jedes dieser Spielelemente nimmt wiederum Komponenten auf, die als "GameBehaviors" bezeichnet werden und mit denen die Logik des Spiels implementiert werden kann. Wie auch bei anderen Klassen in der Engine können eigene GameBehaviors oder sogar ganze Spielelemente mithilfe abstrakter Klassen erstellt werden. Genesis wird standardmäßig mit einer Sammlung der wichtigsten Elemente geliefert.

      Wie wird die aktive Szene gerendert?

      Derzeit gibt es ein Renderer, OpenGL 4.5, das mit DirectX 11 vergleichbar ist. Es können jedoch auch eigene Renderer erstellt werden. Die Integration von Vulkan und DirectX 12 ist für die Zukunft geplant. Als 3D-Format werden derzeit Wavefront-Dateien unterstützt. Dank der Game-Klasse, die Initialisierung, Rendern und Laden der Szene übernimmt, musst du dir keine weiteren Gedanken über das Rendern machen, sofern du dies nicht möchtest.

      Wie wird die Physik des Spiels behandelt?

      Die Physik wird über sogenannte PhysicHandler übernommen. Derzeit gibt es einen PhysicHandler3D und einen PhysicHandler2D, der mit BulletSharp, einem Bullet Physics Wrapper, die Physik innerhalb der Spielwelt simuliert. Wie auch bei den Renderern und Spielelementen können eigene PhysikHandler erstellt werden.

      Welche Arten von Spielen können mit Genesis gemacht werden?

      Derzeit können sehr gut 2D-Spiele aller Genres erstellt werden. 3D wird zum aktuellen Zeitpunkt noch nicht vollständig unterstützt; es fehlen Animationen, das Laden von FBX-Objekten sowie eine effiziente Möglichkeit, Schatten zu implementieren. Bei Letzterem gibt es bereits mehrere Ansätze, und es wird eines der nächsten Features sein.

      Welche 3D-Funktionen existieren bereits?

      Im 3D-Bereich funktioniert bereits das Laden und Rendern von Wavefront (.obj) Dateien sowie die Grundlagen der Physiksimulation (Kollisionen, Raycasts).

      Wie werden Assets ins Spiel geladen?

      Texturen und Schriftarten können einfach in den Ressourcenordner gelegt werden, der dann automatisch geladen wird. Beachte bitte, dass du, wenn du sie in den Ressourcenordner in Visual Studio kopierst, einstellen musst, dass sie beim Build kopiert werden. Mithilfe des Asset Managers kannst du dann darauf zugreifen oder auch die Texturen als Archiv verpacken, sodass du die RAR-Dateien nicht mit dem Projekt mitliefern musst.

      Welche externen Libraries benutzt Genesis?

      Genesis selbst verwendet Open-Source-Bibliotheken wie glmSharp, bulletSharp, NetGL und den OpenObjectLoader. Die einzelnen Lizenzen kannst du im License-Ordner einsehen.

      Roadmap:
      • Implementieren von Schatten (3D)
      • Implementieren von Animationen (3D) Implementiert mit v. 1.1.2
      • Hinzufügen von weiteren UI Elementen (2D/3D)
      • Hinzufügen von OpenAL (Sound)
      • Bug Fixes
      • 2D Szenen Editor
      • 3D Szenen Editor
      Screenshot(s):


      Verwendete Programmiersprache(n) und IDE(s):
      Visual Studio 2022 | C++ / C#

      Systemanforderungen:
      .Net Framework 4.5

      Systemveränderungen:
      Keine Veränderungen

      Download(s):
      github.com/Andy16823/GFX/tree/main/GFX/GFX 0.1.0.0

      Beispiele:
      github.com/Andy16823/GFX/tree/main/Examples

      Lizenz/Weitergabe:
      MIT Lizenz
      Meine Projekte Genesis Game Engine | GFX | smartli.me - Der smarte URL shortener

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Andy“ ()

      Macht es da nicht mehr Sinn, einfach die Monogame-Repo zu forken und diese um die erwähnten Collision-Solver zu ergänzen? Habe mir mal das Sample angeguckt, finde aber den Framework-Ansatz von XNA/Monogame gelungener.
      Eventuell wäre es einfach besser, wenn man von einem Interface erben kann, welche Methodenimplementierungen wie OnInit, OnRenderEnd erzwingt. Ansonsten schöne Engine. Ein nützliches Szenario sehe ich in der Integration von hardwarebeschleunigtem Rendering in WindowsForms-Anwendungen. Schätze man könnte statt des Fenster-Handles, einfach bspws. den Panel-Handle übergeben und dann seine UI wie gewohnt konstruieren.
      Und Gott alleine weiß alles am allerbesten und besser.

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „φConst“ ()

      Hallo, ja genau, du kannst jedes handle übergeben, egal ob Panel oder Window. Habe mich damals bewusst für diesen Aufbau entschieden, da ich ihn logischer fand. Wobei das auch schon 10 Jahre oder mehr her ist.
      Meine Projekte Genesis Game Engine | GFX | smartli.me - Der smarte URL shortener

      Update 0.1.0.1

      Ich habe soeben das Update auf die Version 0.1.0.1 hochgeladen. Die wohl größte Neuerung in diesem Update ist, dass ich das laden von 3D Modellen nun mit AssimpNet Realisiere. Dies war ein wichtiger Schritt, gerade in Richtung Animationen. Da es mit AssimpNet möglich ist auch FBX und andere Formate zu laden. Aktuell habe ich nur die Formate .fbx und .obj getestet. In der Theorie können mit Assimp noch mehr Formate geladen werden, diese muss ich noch genauer testen. Außerdem wurde ein Bug der Collider gefixt, welche einen Gimbal Lock hatten.

      Changelog
      • Implemtierung von AssimpNet
      • FBX Support hinzugefügt
      • Gimbal Lock beim Collider gefixt
      • Anpassungen an dem Element3D
      • Anpassungen an der Mesh Klasse
      • Material Klasse hinzugefügt

      FBX Export Einstellungen in Blender
      Meine Projekte Genesis Game Engine | GFX | smartli.me - Der smarte URL shortener

      Ich habe nun auch eine kleine Website für das Projekt angelegt. Bitte beachtet, dass diese noch WIP ist. Es befindet sich allerdings ein Getting Started Guide dort und weitere Content zu der Engine wird dort folgen um den Beitrag möglichst sauber zu halten.

      Die Website ist hier zu erreichen gfx.676-games.de/
      Meine Projekte Genesis Game Engine | GFX | smartli.me - Der smarte URL shortener

      Moin Andy!

      Ich glaube hier ist ein besserer Ort für Feedback, als in deinem Fragethema :)

      Meine Anmerkung zum Plesk kannst du von dort allerdings gerne mitnehmen, ich halte nichts von doppelter Datenhaltung :D

      Ich schaue mir gerade deinen Quellcode an und was mir aufgefallen ist, ist dass du z.B. Equals selten (oder gar nicht, wenn ich mich nicht verguckt habe) überlädst.
      Du könntest dann noch == und != überladen.

      Ansonsten muss ich sagen, finde ich den Code bisher sehr sauber und strukturiert!
      Quellcode lizensiert unter CC by SA 2.0 (Creative Commons Share-Alike)

      Meine Firma: Procyon Systems
      Meine Privatwebseite: SimonC.eu

      Bitte nicht wundern, wenn meine Aktivitäten im Forum etwas langsamer sind, ich baue gerade mein Nebengewerbe zum Vollgewerbe aus.
      Ich versuche auf euch zurückzukommen :)

      Update 0.1.1.2: Animationen, 2D-Partikel & 3D-Physikverbesserungen

      Es war eine Weile lang ruhig um das Projekt, jedoch bedeutet das nicht, dass in dieser Zeit nichts passiert ist.
      Mit dem Update 0.1.1.2 kommen einige interessante Features in die Engine.

      2D-Partikel-Emitter
      Dokumentation: Class ParticleEmitter | GFX (676-games.de)

      Zum einen gibt es ein neues Element namens Partikel-Emitter, der, wie der Name schon sagt,
      Partikel erzeugt und verwaltet. Der Partikel-Emitter nutzt instanced rendering, was bedeutet,
      dass mit nur einem Draw Call bis zu 1000 oder sogar mehr Partikel gerendert werden können,
      die sich sowohl in Position, Größe, Rotation und Farbe unterscheiden. Außerdem können die
      Partikel mit Alpha-Texturen versehen werden, was dazu führt, dass die Form der
      Partikel individuell angepasst werden kann.

      Beispiel Code

      C#-Quellcode

      1. ParticleEmitter particles = new ParticleEmitter("Particles", new Vec3(10, 100, 0), Vec3.Zero(), new Vec3(40, 40), m_game.AssetManager.GetTexture("5.png"));
      2. particles.ParticleDistance = 150;
      3. particles.CreateParticles(50, new Vec3(15, 15));
      4. scene.AddGameElement("ObjectsLayer", particles);



      Video: streamable.com/2o7jmm

      Animationen mit dem Model-Element
      Dokumentation: Class Model | GFX (676-games.de)

      Das wohl interessanteste Feature sind jedoch die 3D-Animationen. Zuvor war es bereits möglich,
      mit dem Element3D-Element 3D-Modelle zu rendern. Jedoch waren diese Modelle immer nur statisch,
      und ja, ein 3D-Spiel konnte man bislang damit noch nicht mit GFX erstellen. Mit diesem Update
      wurde nun der Grundstein gelegt, dass es nun auch möglich sein wird, 3D-Spiele zu erstellen.

      Dafür wurde ein weiteres Element hinzugefügt, das Model. Das Model-Element kann derzeit nur
      für 3D-Modelle genutzt werden, die über ein Rig und Animationen verfügen. Für statische Elemente,
      die dies nicht haben, kann weiterhin das Element3D genutzt werden. Mit einem späteren Update
      wird es jedoch auch möglich sein, dass Modelle ohne Rig und Animationen damit dargestellt werden können.

      Getestet wurden die Formate FBX und DAE für Animationen. Bei FBX müssen die Texturen mit blender extrahiert werden
      und in das Ausgabe Verzeichnis kopiert werden.

      Beispiel Code

      C#-Quellcode

      1. var model = new Model("Vampire", new Vec3(-1f, -1f, -1f), modelspath + "\\Vampire\\vampire.dae");
      2. model.AnimationSpeed = 0.02f;
      3. model.Size = new Vec3(0.7f);
      4. model.PlayAnimation("");
      5. baseScene.AddGameElement("BaseLayer", model);



      Video: streamable.com/c0ybjl

      Third-Person-Character-Controller & Physik
      Dokumentation: Klasse ThirdpersonCharacterController | GFX (676-games.de)

      Da es nun möglich ist, Animationen abzuspielen, sollte es nun auch möglich sein, sich mit einem Charakter durch die Szene zu bewegen.
      Daher habe ich den ThirdPersonController als Behavior hinzugefügt. Hierbei habe ich einige Fehler in der 3D-Physik bemerkt,
      welche ich behoben habe.

      Beispiel Code

      C#-Quellcode

      1. ​
      2. // Create the player model with an Capsule Collider and check for collisions.
      3. Model model = new Model("Character", new Vec3(2f, 2f, 0f), modelspath + "\\Assets\\Animation\\Human.fbx");
      4. model.PlayAnimation("Armature|idle");
      5. scene.AddGameElement("BaseLayer", model);
      7. var controller = model.AddBehavior(new Genesis.Core.Behaviors._3D.ThirdpersonCharacterController());
      8. controller.CreatePhysics(physicsHandler, new Vec3(0f, 0.75f, 0f), 0.5f, 0.5f, 50f);
      9. controller.RunAnimation = "Armature|run";
      10. controller.IdleAnimation = "Armature|idle";

      ​


      Video: streamable.com/yqxwmv
      Meine Projekte Genesis Game Engine | GFX | smartli.me - Der smarte URL shortener

      Andy schrieb:

      modelspath + "\\Assets\\Animation\\Human.fbx"


      Ich hatte auch mal mit DirectX12 so ein Projekt begonnen, hab da einiges drin gehabt. Aber an eines habe ich nicht gedacht. Nutzung von kommerziellen Assets durch User der Engine. Wenn man die Assets so verwendet, könnten Spieler von Spielen die mit deiner Engine gemacht wurden, einfach so die Modelle klauen. Ich hab mittlerweile einen großen Haufen gekaufte Assets(UE Market), ich glaub keines davon dürfte ich so in deiner Engine nutzen(lässt sich ja alles aus dem UE-Editor exportieren), weil das vermutlich gegen die Lizenz(in Sachen weiterverbreitung) verstoßen könnte. Um so ein Problem zu vermeiden, könntest du wie bei der UE auch, "Kochen". Cooked Content, so das keiner einfach so die Modelle/Texturen etc... kopieren und nutzen kann. Lass dich dazu evtl. mal vom Fachman beraten und bau sowas frühzeitig ein. Ich hatte das nicht, hätte die ganze Struktur ändern müssen, so das ein Rewrite besser gewesen wäre. Da hab ich as dann verworfen und dachte mir, das ist es nicht Wert. War eine gute Entscheidung, bin richtig happy mit der UE.
      Zitat von mir 2023:
      Was interessiert mich Rechtschreibung? Der Compiler wird meckern wenn nötig :D

      Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „DTF“ ()

      Da hast du recht. Ich habe die Idee, einen "Converter" zu entwickeln, der Formate in ein internes Format umwandelt, das zusätzlich verschlüsselt werden kann. Ich verwende bereits eine ähnliche Funktion in meinem Backup-Tool, um die Backups etwas sicherer zu machen.
      Meine Projekte Genesis Game Engine | GFX | smartli.me - Der smarte URL shortener

      Ja so kann man das machen. Ich hatte zu der Zeit auch noch reichlich überlegt, wie ich das umsetzen könnte bevor ich das Projekt eingemottet hab. Ein Import-Tool hatte ich erst vor zu machen, dann dachte ich beim Kompilieren einzugreifen, selbst Code zu generieren(wie mit den Macros der UE, bei C++ Projekten), bzw. dort das Packen einzubauen, so das User der Engine sich darum nicht selbst kümmern müssen. Aber ob sich sowas mit C# machen lässt kann ich dir so nicht sagen, kann es mir aber vorstellen.

      PS:
      Eine Suche via Google brachte mir das folgendes, ich glaube das ist besser als wenn User selbst packen müssen. Also neuen Code aus alten Code generieren, der dir das packen erledigt und dann auch die gepackte Datei zur Laufzeit lädt.
      Das läuft so auch auf ein eigenes Dateiformat hinaus.
      https://devblogs.microsoft.com/dotnet/introducing-c-source-generators/



      PPS. @Andy
      Hatte eben noch eine Idee. Die Assets nicht im Ausgabeordner haben, ein weiterer Parameter "optional bool pack = true", wenn pack == true, das Assets aus einem Ordner auf Projektebene(nicht Ausgabeordner) laden, kompilieren(dein Format) und das in die Ordnerstruktur der Ausgabe packen und nutzen.
      Zitat von mir 2023:
      Was interessiert mich Rechtschreibung? Der Compiler wird meckern wenn nötig :D

      Dieser Beitrag wurde bereits 7 mal editiert, zuletzt von „DTF“ ()

    Facebook
    Telefonspende