[Art] Dungeon

[NeoArmageddon]

Du kannst die Scene auch mal in meiner spartanischen Engine rendern. Die basiert eh auf deinem Jumpstart, hat aber schon alle wichtigen Shader und läd das zeug mit Assimp inkl. Material.
Wenn du willst könnte ich dir die Scene auch mal mit Tessellation rendern und ein Video davon machen.
Ich denke die Scene eignet sich gut für ein bissl Tessellation.

[Glatzemann]

Das wär was... Ich schau mal, daß ich die Szene in den nächsten Tagen mal entsprechend vorbereite. Aktuell geht das noch nicht, da ich teilweise prozedurale Texturen und massiv Modifier von Blender einsetze.

[Glatzemann]

So, mühsam ernährt sich das Eichhörnchen, aber langsam gibt es Fortschritte *g*

Da ich in der Regel einen evolutionären Entwicklungsstil bevorzuge, habe ich mal langsam angefangen und einen Screenshot von der ersten Version "in Echtzeit" gemacht. Diese ist noch sehr weit am Anfang und daher noch nicht sonderlich schön und auch noch sehr weit vom finalen, geplanten Ergebnis entfernt...

Hier mal kurz war ich bisher gemacht habe

• Einfachen Raum in Blender modelliert
• Einfache Spielfigur in Blender modelliert
• Grafik initialisiert
• Einfache Objektstruktur erzeugt -> AbstractGameObject -> ModelObject -> Room (und Character)
• Einfache Kamera-Klasse erzeugt
• Einfachen Character-Controller erzeugt, der per Tastatur bedient wird
• Einfaches Material- und Effekt-System implementiert
  ['] Entwicklung eines Renderers, um alles zusammen zu halten
• Milestone 1: Darstellung eines Raums inkl. einer steuerbaren Spielfigur (ohne Screenshot)
• Entwicklung eines einfachen Schatten-Renderers
• Entwicklung eines HLSL-Shaders zum Rendern von Shadow-Maps
• Erweiterung der Objektstruktur um Flags für Shadow-Caster und Shadow-Receiver
• Entwicklung einer einfachen Licht-Klasse (inkl. Shadow-Casting-Flag)
• Simples Scene-Management, welches Shadow-Caster, Shadow-Receiver und Shadow-Lights liefern kann (Iterator)
• Erweiterung des Renderers für die Verwendung von Shadow-Maps
• Entwicklung eins HLSL-Shaders für rudimentäre Beleuchtung (Ambient und ein Directional Light) unter Berücksichtigung von Shadow-Maps
• Erweiterung des Shaders um PCF (Percentage Close Filtering) für weichere Schatten-Kanten und zur Verbergung von Aliasing-Artefakten
• Milestone 2: Darstellung von zwei Räumen inkl. einer Steuerbaren Spielfigur und Shadow Mapping mit PCF (siehe Screenshot)

Die nächsten Schritte die ich jetzt plane um dem Ziel näher zu kommen:

• dynamischer Kamera-Controller mit Easing und automatischen Kameraschwenks für möglichst optimale Sicht
• einfaches View-Frustum-Culling der Räume
• Texturen verwenden
• Bump-Mapping (super wäre Steep-Parallax-Mapping)
• Variance Shadow Maps für bessere Artefakt-Vermeidung
• Verbesserungen des Material-System (zur Verwendung von mehreren Materialien gleichzeitig in der Szene, Sortierung nach Material, etc.)
• Animierte Modelle

Genug "geblubbert", hier der aktuelle Screenshot

Milestone 2: Zwei Räume, steuerbare Spielfigur und PCF Shadow Mapping

[Glatzemann]

Mit Texturen sieht's dann doch etwas hübscher aus

Milestone 3 Work-In-Progress: Texturen

[Razer]

Wow echt nice
Was wird das eigentlich? Ein ganzes Spiel oder mehr eine reine Übung? Wenn zweiteres, wäre es verdammt gut wenn du den Source irgendwann mal zeigen könntest.
Ich denke es wäre ein super Sample wie man so Basic Dinge macht, die man für ein Spiel braucht. Sowas findet man selten komplett, so könnte man sich mal inspirieren
lassen wie die Struktur, das Rendersystem, Materialsystem, Schatten usw. funktionieren

Klasse Arbeit, weiter so und immer schön Screenshots (oder Videos) posten

MfG
R

[Glatzemann]

Danke sehr...

Tja, was das wird? Ich weis auch nicht so genau Ich habe eine Vorstellung, wo sich das hinentwickeln kann und was ich gerne ausprobieren möchte. Ich habe auch eine Idee, was das für ein Spiel werden könnte, aber ich habe keine konkrete Planung - zumindest nicht aktuell - für ein Game, daß darauf basiert...

Ich denke mal, daß ich ein paar Informationen zusammenschreiben werde, vermutlich bei mir im Blog. Aktuell ist aber nicht geplant daraus eine Tutorialreihe oder einen Beispielsource zu entwickeln. Ich werde aber sicherlich zum ein oder anderen Themengebiet mal ein Tutorial schreiben.

[Glatzemann]

In der Zwischenzeit habe ich noch ein wenig weiter gearbeitet und werde gleich einen neuen Screenshot präsentieren.

Folgendes ist neu / wurde geändert:

• Refactoring-Session -> Einige Programmteile wurden überarbeitet und besser strukturiert um höhere Übersicht im Source zu erhalten und weniger Overhead zu produzieren
• Verbesserungen und Bug-Fixing am Shadow-Mapping. Artefakte werden nun besser vermieden, insbesondere am Rand der Szene
• Normal-Mapping implementiert
• Shader besser strukturiert
• Verbesserungen am Material-System für klarere Trennung zwischen Model-Klasse und Effekten
• Verbessertes Scene-Management (Collection-Klasse für Objekte mit Enumeratoren)

Im nachfolgenden Screenshot sieht man zwei Räume. Der hintere (oben rechts) ist der aus dem letzten Screenshot. Dieser verwendet ein einfaches Texture-Mapping Material (Normalen, Texturkoordinaten und eine Textur). Der andere Raum verwendet das neue Normal-Mapping Material (Normalen, zwei Sätze Texturkoordinaten, zwei Texturen: Diffuse Map und Normal Map). Die Spielfigur verwendet das Clay-Material, daß im letzten Screenshot auch schon für die Spielfigur und einen Raum verwendet wurde.

In allen Materialien wurde das Shadow-Caster und Shadow-Receiver Flag aktiviert. Damit werfen alle Objekte Schatten und alle empfangen Schatten, wie unschwer im Screenshot sichtbar ist.

Der rote Bereich links oben ist eine Debug-Ausgabe. Dies ist die Tiefenansicht der Szene aus Sicht der Lichtquelle, also die sogenannte "Shadow Map", mit der die Schatten berechnet werden.

Zum Normal-Mapping: Gefällt mir noch nicht so ganz, da ich den Effekt noch nicht so richtig kontrollieren kann, zumindest nicht so, wie ich mir das wünschen werde. Ich werde jetzt erstmal eine Lichtklasse erzeugen, sowie einen Light-Manager, damit ich mehrere Lichtquellen erzeugen kann. Damit sollte die Normal-Map dann sichtbarer werden. Was mir auch noch fehlt ist die Beeinflussung der Schatten durch die Normal-Map (falls vorhanden). Aktuell wird zur Erzeugung der Shadow Map die "nackte" Geometrie verwendet.

So, genug geschrieben, hier jetzt der aktuelle Screenshot...

Milestone 3 Work-In-Progress: Normal-Maps

P.S.: Die Ränder in den Wänden vom Raum mit dem Normal-Map-Material liegen an der Normal-Map. Diese wurde aus einer Seamless-Textur generiert (automatisch), allerdings treten dabei in der Regel Artefakte an den Rändern auf, die sich so wie im Screenshot äussern. Dies wird später kein Problem sein, da ich die Normal-Maps aus High-Poly-Modellen generieren werde.

[Glatzemann]

Länger nichts mehr zum Projekt geschrieben und das hat auch einen Grund, eigentlich sogar zwei...

Erstmal musste ich meinen Rechner neu aufsetzen, was knapp 2 Tage gedauert hat. Windows 7, Service Packs, SDKs, Entwicklungsumgebungen, Service Packs für Entwicklungsumgebungen, Treiber... Da kommt schnell was zusammen... Leider ist dabei erstmal die Windows 8 Installation auf der Strecke geblieben

Zum anderen habe ich aber auch damit begonnen den Prototype, den ich in XNA entwickelt habe nun nach DirectX und C++ zu überführen. Das ist im Grunde genommen nicht weiter schwierig, da ich ja noch keine Rocket Science verwende. Hier und da gibt es aber ein paar Stolpersteine. Eines davon ist das Format der Assets, insbesondere der 3D-Modelle. Hier habe ich eine Menge Grundlagen geschaffen. Ich importiere ein 3D-Modell, welches ich aus Blender exportiert habe in ein eigenes C#-Programm. Dieses bedient sich entweder Assimp für alle unterstützten Formate, oder aber dem ModelImporter von XNA. Die 3D-Daten werden in den Speicher eingelesen und ein wenig aufgearbeitet und untersucht. Daraufhin schreibe ich die Daten in ein eigenes Binärformat mit minimalem Overhead. Dieses ist daraufhin optimiert, daß es möglichst schnell gelesen werden kann und möglichst wenig Platz benötigt, ohne es jetzt übermäßig kompliziert zu machen (sprich: Es gibt aktuell noch keine Kompression). Das Schreiben erfolgt dabei noch von C# aus. Sinn dahinter ist, daß ich so später leichter eine nette GUI dafür machen kann, wenn es denn notwendig ist.

Auf C++-Seite habe ich einen Reader für das Binärformat erstellt. Dieses wird in den Speicher geladen und die entsprechenden Buffer werden erzeugt (Index- und Vertex-Buffer, Texturen sind noch offen) und zur Grafikkarte geladen. Entstanden ist daraus eine kleine Mesh-Klasse die so ähnlich funktioniert wie die Model-Klasse von XNA.

Aktuell werden noch keine Animationen unterstützt. Das Format ist aber schon relativ flexibel und man kann mit beliebigen Strukturen umgehen, egal wieviele Positionen, Farben, Normalen, Tangenten, Binormale und UV-Koordinaten in der Datei vorhanden sind: Diese werden geladen und für DirectX aufbereitet.

An dieser Baustelle habe ich jetzt aber erstmal genug gearbeitet, da alles soweit funktioniert, wie ich es mir vorstelle. Animationen spare ich mir für später auf, wenn ich diese benötige und ein flexibleres Laden (Stichwort Streams und Virtuelle Filesysteme) sind auch erstmal nicht ganz so wichtig.

Nächster Schritt ist eine Effektklasse, die so ähnlich funktioniert, wie die aus XNA, allerdings etwas flexibler und moderner (Stichwort Geometrie-Shader und Tesselation). Darauf werde ich dann ein Materialsystem aufbauen und dann habe ich auch schon fast den XNA-Stand vom Dungeon erreicht

[Glatzemann]

Und weiter geht's im Text. Leider nicht mit so großen Schritte, wie ich es mir wünschen würde, aber es geht trotzdem vorwärts

Ich habe mittlerweile ein paar Fehlerchen im Asset Loader behoben. Dieser ist nun voll durchgetestet mit Textur-Koordinaten und Vertex-Positionen. Der Index Buffer wird nun auch korrekt verwendet, falls Indices aus dem 3D-Programm exportiert wurden, oder der Model-Konverter diese generiert. Das Ganze habe ich mittlerweile zu einem kleinen Tool mit diversen Command Line Parametern ausgebaut, so daß es wunderbar in den Build-Prozess eingebunden werden kann (sprich: per MSBuild Models konvertieren -> Fast so komfortabel wie XNA's ContentPipeline )

Weiterhin habe ich mich intensiv mit dem Constant Buffer beschäftigt und eine Klasse entwickelt, die die Erzeugung und das Aktualisieren von Daten etwas optimiert und erleichtert.

Die Model-Klasse wurde an das neue Model-Format angepasst und kann nun auch mit Index Buffern umgehen. Die Model Klasse ist leider noch etwas statisch und kann noch nicht so flexibel auf Änderungen des Model Formats reagieren wie ich das hätte, aber das krieg ich schon noch hin Dafür habe ich aber die Model Klasse "entschlackt" und den gesamten Lade-Code "ausgelagert". Man benötigt nun eine Instanz eines ModelLoader. Dieser kümmert sich, unter Angabe eines Dateinamens, um das Laden eines Modells, der Konstruktion von Vertex- und Index-Buffer, sowie um die Instanziierung der einzelnen Mesh-Objekte. Der Vorteil davon ist, daß ich die Implementation einfach austauschen kann und beispielsweise prozedural erzeugte Meshes per Loader realisieren könnte.

Eine Camera-Klasse existiert mittlerweile auch. Der kann man diverse Parameter übergeben und die einzelnen Matrizen werden je nach Bedarf bereitgestellt und vorher natürlich aktualisiert, wenn notwendig.

Um das Ganze nun zu testen habe ich ein einfaches Objekt (zunächst ein Würfel, dann ein Würfel mit ein paar extrudierten Flächen) durch den Model Importer gejagt, in mein Beispielprogramm geladen, dort eine Kamera erzeugt, per Constant Buffer alle notwendigen Parameter an den Shader geschickt und eine kleine Rotationsroutine im Update eingebaut. Das Ergebnis ist ein rotierendes Objekt. Nicht besonders spektakulär:

Ich werde jetzt hier und da noch ein wenig "feilen" und werde dann bald versuchen die Models aus dem ursprünglichen XNA-Beispiel zu laden. Die Shader müssen dann noch entsprechend angepasst werden und dann sollte fast schon der alte Stand wieder erreicht sein. Natürlich fehlen da dann noch die Schatten, aber wenn ich soweit bin, sollten die eher das kleinste Problem sein

[Glatzemann]

Und wieder ein paar kleine Schritte weiter... Mitterlweile existiert ein einfacher Directional Light Shader (aber noch keine Licht-Klasse). Die Spielfigur kann auch schon gesteuert werden, ganz so wie im Prototyp. Ein rudimentäres Frustum Culling habe ich ebenfalls bereits realisiert (das war im Prototype noch nicht drin).

Natürlich habe ich auch diesmal wieder ein wenig Refactoring betrieben und ein paar Stellen um Shared ptr erweitert. Das ist nicht nur weniger fehleranfällig, sondern auch noch übersichtlicher.

Das Objekt-Modell (soll heißen: GameObjects) ist nun auch fast vollständig in C++ übersetzt, mit ein paar kleineren Änderung hier und da. Funktioniert auch bisher schon ganz gut. Das ist aber trotzdem noch die aktuelle Baustelle. Hier werde ich die nächsten Schritte wagen und hoffentlich bald wieder die Licht-Klasse soweit haben, daß ich mich wieder um die Shader kümmern kann. Dort ist noch einiges an Arbeit notwendig, vor allem Texturen und dann wieder die Shadow Map.

Auch diesmal habe ich wieder einen Screenshot, der aber leider immer noch nicht besonders spektakulär aussieht Dafür hat dieser jetzt die native Auflösung des "kleinen" Surface von Microsoft (also die ARM-Variante).