Animationen in OpenGL

[Capt'N Coax]

Hoi ersmal,

Mein erster Eintrag und direkt mal was zum knabbern:

Es geht um OPENGL, in Verbindung mit MSVC++, kein Glut (aber das spielt auch keine Rolle)...

Folgendes:
Ich habe einen Konverter für das 3DMax ASE Format geschrieben und lese meine Models direkt aus diesem Format aus. Diese werden in OpenGL in einer GL-Konformen Form gespeichert, und zwar in Displaylisten.

Und da liegt auch der Haken an der Sache:

Ich bin n ziemlicher Newbie in Sachen OpenGL, und weiss daß ich in Displaylisten nicht zur Echtzeit verändern kann, da vorkompiliert.
Mich würde allerdings interessieren, wie ich Animationen abspielen könnte.

Dazu müsste ich entweder die Vertex Koordinaten eines Objekts zur Echtzeit verändern (Geht wahrscheinlich net da DLs) oder für ein Objekt die jeweils unterschiedlichen Animationsstufen als einzelobjekte WIEDERRUM in Displaylisten speichern, und nacheinander zeichnen.
Aber das kanns ja wohl nicht sein.

Da ich keine Lust habe ein gängiges Format zu verwenden (wie z.B. MD2) sondern mein eigenes Format erstellen möchte, bräuchte ich hier ein paar Lösungsvorschläge (Code wär toll is aber net nötig)...

Wär toll wenns hier n Pro gibt, der sich mit sowas auskennt, ich hänge hier nämlich fest, und komme auf keine optimale Lösung...

Vielen Danke im vorraus,

de Capt'N

[Kant]

Hallo,

Mit Display-Listen im dynamischen Umfeld wirst du nicht glücklich werden. Die Listen werden zwar sehr fix gerendert, sind aber einmal erstellt statisch.. no way, eine einzelne Vertex zu ändern.
Zudem dauert die Erstellung(Compilierung) einer Liste viiellll zu lange, um es in irgendeiner art und weise "on the fly" also pro frame zu versuchen.
Die einzige alternative wäre also das vorherige Erstellen ALLER Animations-stufen in einer jeweils eigenen Display-Liste. Leider sind Display-Listen aber auch sehr speicherintensiv, so das ich auch davon Abstand nehmen würde (Es sei denn, 3 oder 4 Animationsphase reichen).

Die einzige performante Alternative, die mir dazu einfallen würde, wären Vertex Arrays. Diese sind etwas komplexer zu handhaben, haben aber denn Vorteil, sich zur Laufzeit verändern zu lassen.
Im Prinzip sieht es so aus, das man ein oder mehrere Arrays anlegt (vertex xzy,normal xyz,uv, face indizies), und dann mit einem Befehl eine gewisse Anzahl aus den Arrays zeichnen lässt.

Der Vorteil ist, wenn sich nun nur eine Vertex ändert, muss man bei einem Array auch wirklich nur diese ändern. Und kann es dann sofort neu rendern lassen.

Der Nachteil ist wie schon angesprochen eine etwas komlexere Handhabung. Man hat halt nicht nur seinen DL-Index sondern muss mehrere Daten-Arrays verwalten.

Hoffe das hilft etwas.

[Capt'N Coax]

Tjaaa, knifflige Angelegenheit...
Die Animationsgeschichte scheint sich also noch hinzuziehen.
Klar könnte ich die Werte in ein Array packen und bei bedarf ändern, allerdings hätte ich damit gerechnet, das irgendwo ein paar openGL Befehle existieren, die bei geeigneter Mischung Animationen ermöglichen.
Quasi so ne Art des Denkens Geschichte...

Ich frage mich, wie das MD2 Format animationen abarbeitet, wenn jemand hier darüber informiert ist, bitte n kleinen reply verfassen, wär echt net...

Auf jeden Fall danke für die schnelle Antwort.
Was interessant ist, ist das mein Konverter im Prinzip mit mehrdimensionalen Arrays arbeitet, eigentlich sind die Informationen in dieser Form schon gespeichert...

Bevor ich mich allerdings an werweiswasfürarrays in-Game dransetze, warte ich mal ab was es da sonst noch gibt.

In diesem Sinne,
bis denne,
de Capt'N

[Gnafoo]

vielleicht hilft dir die Seite hier weiter:
http://nehe.gamedev.net/

.. sind gute Tutorials dabei, die mir auch schon
geholfen haben ..

ansonsten würde ich erstmal mit google nach
guten tutorials oder so suchen ..
ich vermute aber, dass es letztendlich darauf
hinausläuft, dass man die Vertices in Arrays
speichern muss und dann vor jedem Frame ändert.

[zeckensack]

Quake 2/3 arbeiten mit Key Frames. Dh daß Stufen der Animation im Modeller erzeugt und im MD* abgespeichert werden. Die Engine führt dann für jeden Vertex eine lineare Interpolation durch. Das ist wichtig, damit die Animation mit höherer Framerate 'smoother' wird. Wenn man ohne Interpolation arbeitet, und nur eine 10fps-Animation hat, dann bleibt diese rucklig (siehe Quake I).

Vereinfachter Pseudo-void
Model::Model(const char* const filename)
{
load_mesh(filename);
load_materials(filename);
load_keyframes(filename);
this->current_keyframe=keyframe[0];
this->next_keyframe=keyframe[1];
this->animation_progress=0.0f;
}

void
Model::animate(float time_since_last_frame_in_seconds)
{
animation_progress+=time_since_last_frame_in_seconds;
if (animation_progress>=1.0f)
{
animation_progress=0.0f;
current=next;
++next;
if (next>max_animation_phases) next=0;
}
}

void
Model::render()
{
for (uint i=0;i<Mesh.num_vertices;++i)
{
vertex current_vertex;
current_vertex=(1.0f-animation_progress)*
current_keyframe.vertex_position[i];
current_vertex+=animation_progress*
next_keyframe.vertex_position[i];
output_vertex(current_vertex);
}

PS:
Thema Display Lists (http://www.forum-3dcenter.org/vbulletin/showthread.php?threadid=40379). Die sind für Animationen nicht geeignet.

[Capt'N Coax]

Yepp, Das mit den Displaylisten is kloar (und vor allen Dingen logisch).

Neon Helium kenne ich 'türlich auch, haben zwar Tonnenweise OGL-tuts zu allen möglichen Sachen, aber (wie immer) natürlich net zu dem Kram den man grad so braucht...

Überhaupt sind Tutorials über Animationen in OGL extrem rar bis gar net vorhanden.
Selbst Google, die normalerweise drölfzigtausend Einträge zu jedem Fliegenschiss auspuckt konnte mir nix liefern.
Wäre doch vielleicht mal n Vorschlag fürn Tutorial zum selberschreiben....??

Na egal, danke für den (P)Code und eure Antworten bis hier,
de Capt'N