[Projekt] CyberDive (MARPG)

[Zudomon]

Kurzupdate: die Control-Klasse ist bei 640 Zeilen ... das passiert halt wenn man ein vernünftiges Event-System macht :)

BAD PROGRAMMING! :lol:

[Artificial Mind]

Kurzupdate: die Control-Klasse ist bei 640 Zeilen ... das passiert halt wenn man ein vernünftiges Event-System macht :)

BAD PROGRAMMING! :lol:

Selber! xD
Aber was geh ich auch auf nen "Bad programming" Kommentar von nem Delphi-programmierer ein :D *silly me*

2be honest:
Das meiste davon sind Kommentare. Es sind viele Deklarationen und sehr wenig Funktionen (bis jetzt). Ich will das GUI eh im Endeffekt opensource machen, deswegen gebe ich mir besonders bei der Grundklasse mühe.

[Artificial Mind]

Hm ich bin momentan echt unsicher wie ich das GUI weitermachen will...

Ich will das GUI-System sowohl für C++ als auch C# benutzen können und ich weiß nicht wie ich das anstellen soll, ohne dass ein widerliches C-Interface dabei rauskommt...
Hat jemand da ne gute Idee?

[joggel]

Kann man das evtl. unter Windows über diese COM-Schnittstelle lösen?

[Artificial Mind]

Hm ja da gibt es Möglichkeiten, nur das ist weder einfach, noch unkompliziert, noch hat es einen angenehmen Workflow.

Wir (mein Kumpel mit dem ich das GUI zusammen entwickel) machen das jetzt erstmal in C#, dann kann man das sehr einfach in C++/CLI verwenden, das muss erstmal tun. Später kann man das System immer noch portieren wenn die Algorithmen stehen und in C# entwickelt es sich wesentlich angenehmer.

[Artificial Mind]

Falls ihr euch wundert, weswegen es gerade so ruhig bei mir ist, dann liegt das nicht nur am neuen Semester:
Für die Uni mache ich ein Projekt in welchem ich eine Grafikengine schreibe, die auf C++ und OGL 3.3 basiert und viele fortgeschrittene Techniken benutzt. Wie ich im IRC schon ein wenig gezeigt habe, läuft bereits das Deferred Shading, das HDR mit Bloom, das Parallaxmapping und ich habe die drei Beleuchtungsmodelle Phong (Gips bis Plastik), Cook-Torrance (Metall) und Oren-Nayar (Stein, Tapete, rauhe Oberflächen) bereits implementiert. Dazu ein kleines Framework für prozedurale Geometrie und Texturen (von denen Fractal Noise bereits läuft und Cellular Textures so halb).
Je nachdem, was meine Betreuer sagen, kann ich die auch hier vorstellen, während ich sie entwickle (und nicht erst nach der Benotung), aber da ich noch keine Rückmeldung habe, kann ich auch noch nichts offiziell posten ;)

Was für CyberDive dabei rausspringt, ist genau dieses Framework bzw. dessen Struktur (von C++ nach C# porten ist nahezu kein Problem, wenn man eh Templates größtenteils vermieden hat, um das Compilen und die Abhängigkeiten klein zu halten).

Der große Vorteil (von Mogre weg zu kommen): Wenn ich mich nicht irre, sollte es dann trotz C#-Natur auf Linux laufen. Als Physik-Engine wollte ich mir dann mal Bullet angucken bzw. die Linux PhysX Treiber ;)

[Artificial Mind]

So, YADC ist abgegeben und ich will wieder voller Energie und Euphorie an CyberDive weiterschreiben!

Ich bin also gerade dabei, die Engine von YADC quasi als zweite Iteration in C# zu implementieren und die Ecken und Kanten die die erste Iteration hatte etwas abzuschleifen. Das Ganze läuft nun mit OpenTK als C# OGL 3.3 Port und sollte damit prinzipiell auch unter Linux laufen, wenn ich alle WinForms-Debug-Fenster rausnehme.

Das erste neue "Convenience-Feature" ist Shader-HotSwap.

Debug Fenster mit Shader HotSwap

Ich kann nun Runtime den Shadercode bearbeiten (in dem rechten Debug-Fenster), ihn neu kompilieren lassen, mir die Compile-Errors angucken und dran rumwerkeln. Der Compiler ist so schnell, dass man es kaum merkt. Außerdem wird der HotSwap immer genau zwischen zwei Frames gelegt, ohne irgendeinen Zustand zu korrumpieren.
Ein super praktisches Feature, dass mir sicher später viel Ärger ersparen wird.

[Artificial Mind]

So die neue Engine ist in vielen Punkten flexibler, C# programmieren macht schon spaß :)

Deferred Shading, Transparenzen und HDR

Es funktioniert wieder das Deferred Shading, Transparenzen und HDR Rendering mit Bloom. An der Seite sieht man diesmal im Debug-Window eine genaue Performance-Anzeige mit den CPU Zeiten und den OpenGL Zeiten (sprich Timer Queries), sodass ich auch die Grafikkartenzeiten gut sehen kann.

Transparenzen werden hier erstmal Objektweise sortiert, das muss erstmal reichen. Sobald ich mir Gedanken über meine Weltrepräsentation gemacht habe, wir hier sicherlich eine Art kd-Tree landen, der die Objekte beinhaltet und damit in O(n) nach Kamera-z sortieren kann.
Alternativ nehme ich eine Art SmoothSort (sortiert in O(n) bei vorsortierten und nahezu O(n) bei nahezu vorsortierten Daten) und eine moeglichst lockere Halbordnung (sowas wie Objekt 1 < Objekt 2 nur dann wenn sich die Bounding Volumes von den beiden Objekten nach Projektion auf Image Plane schneiden und Objekt 1 hinter Objekt 2 liegt, wenn sich die Volumes nicht schneiden ist die relative Ordnung von den beiden Objekten egal). Damit sollte dann pro Frame nicht allzu viel Sortieraufwand entstehen.

[Jeason]

Verwendest du die Standard OpenTK Math Klassen? Welche OpenTK Version verwendest du? Hattest / Hast du irgendwelche besondere Probleme beim portieren?

[Artificial Mind]

Ja ich benutze die Standard OpenTK Math Klassen, die sind auch soweit ganz ok, leider nicht ganz so umfangreich wie GLM. (Ich vermisse z. B. Matrix3 oder Matrix3x2)
Ansonsten ist OpenTK super, endlich Exceptions wenn man was falsch macht in OpenGL, keine 10.000 GL_XYZ Definitionen mehr, sondern schön immer die richtigen Werte als Enum für die Methoden.

Eine Sache, auf die man recht schnell reinfallen kann, ist, dass man, wenn man Texturen benutzen möchte und ein Vector4[,] data Array hat, dann muss man das mit data[y,x] addressieren, einfach wegen des Speicherlayouts.

Als OpenTK Version habe ich mir die aktuelle Nightly gezogen, da die offizielle OpenTK 1.0 Version noch kein OpenGL 3.3 unterstützt, sondern erst bei OpenGL 3.2 ist. (Die Nightly kann sogar OGL 4)

Achja ein anderer netter Pitfall: der OpenGL Context ist Threadabhängig. Sprich: Wenn man in einem Destruktor OpenGL-Ressourcen freigibt, kriegt man eine NullReferenceException weil der Context im GC-Thread natürlich nicht gültig ist.

[Artificial Mind]

So nun gibt es eine zweite Rendering-Pipeline (Eine Engine = ein Context, jede Engine kann mehrere Pipelines enthalten), die für prozedurale Inhalte, die auf der Grafikkarte erstellt werden sollen, verantwortlich ist.

Procedural Content Pipeline

Zu sehen ist die gleiche Szene wie im letzten Update, nur dass diesmal ein Textured Quad in der Mitte ist, der nach 5 Sekunden mit dem Inhalt der aktuellen Szene (vor Postprocessing) gefüllt wird.

Diesmal zeigt das Debug-Fenster am Rand den Aufbau der aktuellen Rendering Engine mit Pipelines und Passes. Klickt man auf eine Pipeline, werden alle Shared Textures (Texturen, die zwischen verschiedenen Passes geshared sind) angezeigt und man kann diese per Klick anzeigen lassen (dazu werden die von der Grafikkarte geladen und als Bitmap angezeigt und koennen auch direkt ins ClipBoard kopiert werden)
Hätte man auf einen Render Pass geklickt, so hätte man Einstellungen zu diesem Pass (z. B. Wireframe) verändern können.

Ich hoffe das ich die meisten Texturen einfach per Shader "backen" kann, da dies auch die Performance von C++ um längen schlagen sollte ;)

[RazorX]

Sieht echt faszinierend aus was du da mit C# zusammen baust. Das bringt mich ins grübeln ob ich das nicht auch mal versuchen sollte (finde C# deutlich umgänglicher als C++, wenn auch in manchen Situationen deutlich langsamer je nachdem wie viele Exceptions man nutzt). C# dürfte vorallem was das SceneManagement mit dem Reflections Bereich sehr interessant werden, wodurch States direkt am Objekt manipuliert werden können ohne die GUI extra darauf auszulegen.

[Artificial Mind]

Ja, C# programmiert sich echt Größenordnungen angenehmer als C++...
Was die Geschwindigkeit angeht, so sollte man halt wissen, was in C# schnell ist und was nicht. Exceptions sollte man normalerweise nicht im Programmfluss haben (sprich: es sollte im Schnitt 0 Exceptions pro Frame geben ;) ).
Datenlastige Operationen, wie z. B. prozedural Texturen/Geometrie erstellen oder soetwas ist natürlich in C# langsam, aber man kann ja C++ Module relativ bequem und performant einbinden.

[RazorX]

Mal kurz zum Verständnis: Verstehe ich das richtig das du dann pro "Engine" einen Thread erstellst, die jeweils einen OpenGl Context erstellen und unabhängig von einander agieren? Wie transferierst du dann Resourcen des einen auf den anderen Context? (hab was OpenGl angeht wenig Erfahrung, ist jetzt nur etwas was mir ins Auge sticht).

[Artificial Mind]

Ja, pro Engine müsste ein Thread erstellt werden mit je eigenem Context. Transferieren würde man dann wohl über CPU machen müssen (Buffer read -> Buffer write). Mehrere "Engines" werde ich allerdings selten brauchen, wenn, dann wahrscheinlich als Zusatzoption für mehrere Grafikkarten, dass High Quality Texturen auf der ungenutzten Karte gerendert werden können und die dann gespeichert werden.

[Artificial Mind]

Ok, Font-Rendering-Engine schreiben, die auch noch performant und cool ist, ist nicht-trivial :D

Ich möchte ja Signed Distance Fonts benutzen, um kostengünstig Alphablending, Outlines, Glows, Shadows usw. in den Fonts unterstützen zu können und gleichzeitig an der Auflösung der Basis-Texturen zu sparen.
Folgende Schritte gehen bereits:

1. für jeden Char ein High-Res (erstmal 512 Höhe) Bild zeichnen (per System.Drawing)
2. für jeden Char die Signed Distance High-Res Karte berechnen
3. alle High-Res Bilder auf die gewünschte Höhe zum Speichern (nicht mit der nachher zum Zeichnen gewünschte Höhe) runterskalieren (hier z. B. 128 angedacht)
4. jedes Bild links und rechts so weit beschneiden wie es geht (sprich bis die signed distance function nicht mehr 0 ist)
5. alle Bilder auf eine gemeinsame Höhe zusammencroppen (hier 108)
6. alle Bilder per LPT-Algorithmus (4/3-Approximation für Scheduling) in eine power-of-two Texture packen

Signed Distance Font Texture

uff.

Nachtrag:
Ich bin natürlich Unicode-kompatibel ;)

Hiragana + Katakana in Signed Distance

[Artificial Mind]

So, endlich funktioniert der Font-Renderer! (per Geometry Shader)
Allerdings muss ich noch ne ganze Menge Caching einbauen damit große Mengen Text mit vergleichsmäßig wenig dynamischen Texten performant gezeichnet werden können.

Signed Distance Font mit Outline und Glow

mit der signed distance kann man sehr viele coole Effekte hinbekommen, eignet sich auch für irgendwelche Decals.
Obwohl die Font-Textur nur mit ca. 108 Pixeln Höhe pro Zeichen gespeichert ist und nachher mit ~250 Pixel Höhe angezeigt wird, sieht man nahezu keine Artefakte, ich bin begeistert.

[Artificial Mind]

So, das basic-GUI-System steht und es gibt Labels.
Strings können jetzt nach Wunsch automatisch gewrappt werden.
Nachdem ein GUI auf ein solches Quad gerendert wurden, werden auch die Mipmaps neu generiert.
Der Text wird hier gerade auf das GUI in einen seperaten Framebuffer gezeichnet, sodass die Schriftauflösung durch die GUI-Auflösung begrenzt ist. Später möchte ich allerdings auch alternativ Text direkt in 3D zeichnen können, sodass ich dort durch die signed distance function wieder sehr viel bessere Qualität bei Magnifikation habe.

3D GUIs mit Labels

Rechts gibt es wieder den Shader Debugger mit Hotswap, erweitert um Scintilla.NET Source Code Editor mit Syntax Highlighting (mit C# Highlighting, keine Lust gehabt, einen GLSL Lexer zu erstellen) und vernünftigem Undo.
Außerdem sieht man hier mein Shader "Specification" System, das mit einfachen #ifs im ShaderSource arbeitet und dann runtime die Shader mit den gewünschten Flags kompiliert, sodass ich z. B. beim normalen Geometrie-Shader per Flag einstellen kann, ob ich alle Textur-Channels mit einzelnen Texturkoordinaten habe oder eine Koordinate für alle Channels, ohne mehrere Kopien des Shaders im Projekt zu haben.

[Artificial Mind]

Neustes GUI-Element: Panels
ebenfalls per Signed Distance Function, diesmal aber prozedural aus nem Shader und nicht per Textur. Optionales Chamfering pro Ecke (hier left-upper und right-bottom).

Panels

[Jeason]

Sieht sehr gut aus :) Wie performant läuft das ganze? Ist dir da C# nicht im weg?

[Artificial Mind]

Läuft alles ziemlich performant, in C# konnte ich schnell nen vernünftiges Caching-System bauen, um OGL-Calls zu minimieren. Der OpenTK Wrapper hat nahezu keinen Overhead. Bei der Rendering Engine ist mir C# sicher nicht im Weg. Ich denke bei aufwendigen AI Berechnungen (Viele Graphsuchen, Decision Tree Learning, Planning, Neural Networks etc.) könnte es problematisch werden, da muss ich eben eventuell C++ Module für schreiben (welche sich ja zum Glück gut einbinden lassen und unter Windows gibt es sogar eine Art "Mixed Mode" wo man nahezu keinen Overhead zwischen native/C# Wechsel hat (darauf basiert Mogre z. B. mittlerweile)).
Um mal Werte zu nennen: ich bin bei 13 ms GPU Zeit, 1.5ms CPU Zeit pro Frame und das bei meiner 9800 GT die schon durch meine 4 Full HD Bildschirme stark ausgelastet ist (Bevor jemand fragt: ich habe 2 9800 GT dran, jede mit zwei Bildschirmen, aber der Windows DWM muss die Ressourcen zwischen den beiden Grafikkarten synchronisieren, damit man Fenster rumschieben kann, ohne dass man die "Grafikkartengrenze" merkt. 4 Bildschirme lasten die Grafikkarten gut aus ;) ) Dabei sind die 13 ms inklusive HDR, Bloom, Deferred Shading und Transparent Composition (Brechung und so) zu verstehen, also sehr viel konstanter Overhead schon mit drin, sodass Szenenkomplexität erstmal nicht so viel ausmacht.
Momentan braucht das Updaten eines der lorem-ipsum-GUIs leider noch relativ lange (0.5 ms oder so) weil ich beim Font-Rendering noch kein Caching habe und viel Framebuffer und Shader umgebunden und konfiguriert werden müssen ... da lässt sich noch gut was rausholen, denke ich.

[Artificial Mind]

So:

• Text kann aligned werden (selbst automatisch umgebrochene lange Texte)
• Schnittpunktberechnung zwischen Mouse-Ray und GUI-Plane in 3D
• "Hover-Stack" mit Mouse-Handling für GUIs
• Buttons
• Die Panels können jetzt unterschiedliche Transparenzwerte für Innen, Outline und Glow haben (sodass z. B. das Outline opaque ist, aber Innen 30% transparent)

Buttons

Ja, man kann GUIs auch von hinten benutzen *g*

[Artificial Mind]

So es hat sich wieder ein bisschen getam:

• Es gibt nun GUI-Templates, die die Gelegenheit haben, die Controls zu stylen.
• GUIs können serialisiert und deserialisiert werden.
• Es gibt einen rudimentären Designer, um die GUIs runtime zu verändern (siehe Screenshot)
• Ich habe eine Scenen-Klasse zum verwalten aller Szenendaten erstellt, die unter anderem den Input der GUIs verwaltet, sodass sich Fokus und Mouse-Events richtig verhalten, wenn man mehrere GUIs in 3D übereinandersieht (man kann auch durch "leere" Bereiche eines GUIs "durchklicken")

GUI Designer

Hier sieht man den aktiven Designer. Der GUI-Renderer erkennt den Designer-Modus und malt dann automatisch farbige Rechtecke um die Controls, damit man die Mouse-Over Bereiche richtig einschätzen kann und so. (Man sieht auch, dass die Labels noch keine richtige Größe haben, obwohl der Text richtig ist. Steht schon auf meine "TODO" ;) )
Ohne GUI-Designer kann man nicht arbeiten, statische GUIs per Code handerstellen ist ja wohl die Manifestation schlechten Codes ohnegleichen.

Ich hatte mich Sonntag und Montag auch mal um eine vernünftige Serialisierung und Deserialisierung meiner Weltdaten (wisst ihr noch, die generierte Welt aus 60.000 Geozonen der Größe 100km x 100km) gekümmert. Bis auf die Straßenssysteme (die noch mal eine gründliche Überarbeitung brauchen) wird alles in ca. 2-3 sec gespeichert und das Laden aller Daten, die für die Städte relevant sind dauer ca. 1 sec. Soll die ganze Welt (also alle Geozonen) geladen werden, brauchts ca. 6-7 Sekunden. Dabei ist mein Format noch relativ verbose, es werden zu den Daten auch noch Feldname und Typname gespeichert, sodass ich bei fehlerhaftem Laden nicht nur den erwarteten Feldnamen sondern auch den Typen davon habe. In diesem Format ist die bisherige Welt ca. 100 MB Groß, in der nächst kleineren Variante (Hashvalue des Feld-Typ-Strings speichern) ist es sicherlich unter 20MB.
Ist schon echt angenehm, alle relevanten Daten in ca. 1 sec zu laden, anstatt min. 5 Minuten völlig ausgelastete 8 Kerne zu haben.
Ich arbeite momentan auf ein "Hauptmenü" im Client hin, welches die Weltkarte vom Server bekommt und rudimentäre Charactererstellung erlaubt.

[RazorX]

Krass! (mehr fällt mir dazu nicht mehr ein^^)

[Artificial Mind]

Danke, sowas motiviert immer gut :)
Ich hätte auch kein Problem die Render-Engine im Endeffekt Open Source zu machen, allerdings weiß ich nicht inwieweit Interesse bestünde und die hat sicher auch nicht so viel technische Genialität wie breeze ;)

[RazorX]

Mich motiviert deine Arbeit auch ungemein wieder was in die Richtung zu machen (nachdem ich nächsten Dienstag die letzte Prüfung geschrieben habe :D). Wie ich schonmal erwähnte, finde ich es interessant wie komfortabel das doch mit C# erscheint und ich denke ich werde das mal ausprobieren. Arbeite aber erstmal noch an deiner Engine bevor du die OpenSource machst (bei breeze2 hat es ja auch seine Zeit gedauert) und ich bin mir sicher das dann bestimmt Leute dafür Verwendung finden werden.

[BeRsErKeR]

Kann mich da nur anschließen. Sieht ziemlich vielversprechend aus und motiviert mich auch mal wieder bischen was zu Coden. Gerade in Hinblick darauf, dass ich seit kurzem auch mit C# arbeite.

[RazorX]

Hab gestern auch mal angefangen (ich hab doch keine Ruhe mehr gehabt :D) und muss sagen, dass es sehr angenehm ist mit dem OpenTK zu arbeiten. Ich habe dann auchmal als erstes einen LiveShader Editor mit ScintillaNET gebastelt und eine kleine GLSL Konfigurationsdatei geschrieben (mit AutoComplete). Leider hab ich es nicht hinbekommen mehr als zwei Keyword Gruppen zu färben, da der Cpp-Lexer auf WORD und WORD2 beschränkt ist :(. Wie man sehen kann sind die Wörter noch ein bisschen formatiert, sodass man es einfach in neue Gruppen bauen kann. Wäre cool wenn jemand weiß wie das geht, ansonsten ist es denke ich auch so schon eine Erweiterung (@Artificial Mind: ich dachte ich poste die mal hier, da du ja keine geschrieben hast und mit C# Highlighting arbeitest).

[Artificial Mind]

Vielen Dank für das Engagement, ich werde das gleich mal einbauen ;)

[Artificial Mind]

So nochmal danke, RazorX, ich habe die xml eingebunden und es sieht soweit gut aus (Credit-Hinweis-Notiz ist auch erstellt ;) )
Dann gibt es nun das neue GUI Control "TextBox" und halbwegs vernünftiges Key-Handling.
Man kann neue Controls platzieren und ganze Control-Teilbäume per Strg-C kopieren.
Ganze GUIs können nun gespeichert und geladen werden.
Der Zugriff vom Programm auf die Controls wird per Name gemacht, der pro GUI einzigartig ist für jeden Control (Name kann auch null sein, dann wird das Feld ignoriert)

GUI Designer

Ich bin immer noch am überlegen wie ich für TextBoxen einbaue, dass die Cursor-Position richtig gesetzt wird, wenn man reinklickt. Denn die komplette Rendering-Logik ist von der GUI-Logik getrennt (also die GUI-Logik ist sogar eine eigene dll), die einzelnen Buchstabengrößen kann aber eigentlich nur der Renderer kennen ... Vielleicht muss ich da irgendwie nen ekligen Feedbackweg einbauen, der dann das schöne Public-Interface der Klasse beschmutzt. Oder hat jemand einen besseren Vorschlag?^^

Nachtrag: GUI-Entwicklung ist schon architekturiell herausfordernd *g*