spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

Hi,

ich hätte mal eine Frage zur Entwicklung meines ersten Spiels. Das ganze fing im Rahmen meines Studiums (Info) als Beleg an, ich möchte das aber noch ausbauen etc um es eventuell mal als Referenz zu benutzen.

Das Spiel ist ein reines OpenGL-Spiel, es wird also keine Engine etc benutzt. Im Prinzip bediene ich mich bei dem Gameplay ein wenig bei Race the Sun: man "schwebt" in einem Flugzeug / Raumschiff über einen unebenen Boden und muss möglichst schnell werden. Momentan gibt es noch "Tore" durch die man einen kleinen Boost bekommt oder abgebremst wird. Wer zu langsam ist wird irgendwann von der Zeit eingeholt und verliert.

Hier mal ein paar wichtige Infos

Ich benutze einen kleinen "Algorithmus" um die Welt zu generieren. Also vor allem der Boden besteht aus zufällig generierten Stücken. Das ganze funktioniert so:
- es wird eine Matrix mit Größe k erzeugt, die mit zufälligen Werten gefüllt wird
- es wird eine Matrix mit Größe m*k erzeugt, wobei "m" quasi die Subdivision ist
- die zweite Matrix wird mit gefilterten Werten der ersten gefüllt

Im Prinzip ist das das selbe, als würde man ein 2D-Textur mit Rauschen füllen, hochskalieren (ohne zu interpolieren!) und dann einen Gauß-Filter drüber laufen lassen. Recht simpel also

Das ist also noch nichts kompliziertes oder so. Nun muss das natürlich der Grafikkarte übergeben werden. Da ich noch fancy Normal-Mapping implementiert habe sieht das ganze so aus:

1) erste Matrix erzeugen
2) zweite Matrix erzeugen, mit gefilterten Werten der ersten
3) Buffer für Vertices, Normalen, UV-Koordinaten, Tangenten und Bitangenten (Normal-Mapping) erzeugen
4) Vetex-Buffer füllen
5) UV-Buffer füllen
6) Normalen Berechnen aus Normalen der anliegenden Dreiecke (damit das ganze keine Ecken bekommt)
7) Tangenten und Bitangenten berechnen

Alle Buffer in einem VertexArray verbinden
9) Temporäre Buffer löschen


Man sieht also, das das ganze ziemlich Zeitaufwändig ist. Ich verwalte die "Stücke" der Welt in einer Klasse in einer Matrix. Diese hat eine Feste Größe. Bewegt die Kamera sich eine Gewisse Distanz von dem Zentrum der generierten Spielwelt weg, wird die Matrix angepasst:
- weiter distanzierte Stücke löschen
- Stücke in der Matrix "verschieben"
- neue Stücke generieren (siehe oben)
- Zentrum der generierten Spielwelt aktualisieren.


Jetzt meine Frage: (endlich)
Ich rufe nach jedem "Tick" die Funktion auf, die überprüft ob die Welt aktualisiert werden muss. Wenn dem so ist, wird das in der Main-Loop gemacht. Das heißt, man hat ein Frame dessen Berechnung wesentlich länger dauert als die der anderen Frames. Ich mache alle Bewegungen etc in Abhängigkeit von der Dauer des letzten Frames, dadurch bleibt die Spiegeschwindigkeit konstant. Aber auf langsameren Maschinen merkt man in diesen Frames trotzdem einen starken Ruckler. Wie sollte man die Generierung der Welt machen, wenn man diesen Ruckler vermeiden will?

Mein Ansatz wäre folgender: Alle Elemente der Spielwelt, die für das Gameplay nötig sind (Berechnung der Höhe etc) in der Main-Loop erzeugen, die Berechnung grafischer Elemente dann jedoch in einem separaten Thread übernehmen. Was für Ansätze habt ihr?


Das war eigentlich schon alles. Danke!

(Anbei ein kleiner Screen von der Spielwelt. Da seht ihr besser was gemeint ist.