3d für Fortgeschrittene - Animationen

    • GM 8

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    • 3d für Fortgeschrittene - Animationen



      Dieses Tutorial basiert auf Moolts sehr informativem 3d - Modelle Tutorial und schließt dort an. Fortgeschrittene Game Maker Kenntnisse werden vorausgesetzt. Ebenso einige Erfahrungen mit dem 3D Modus im Game Maker. Blender Kenntnisse sind auch von Vorteil. Das Tutorial wird zweigeteilt, zum einen kurze Grundlagen in Blender zu Animationen und dessen Export, danach die importierung in den Game Maker.

      Ich verwende die folgenden Programme:
      • Blender 2.69
      • Wavefront Obj Exporter (standardmäßig in Blender installiert)
      • Game Maker 8 Pro (andere Versionen, die den 3D Modus unterstützen, funktionieren möglicherweise ebenfalls)


      Ansonsten die example-simple.zip aus Moolts 3d für Anfänger - Modelle Tutorial.



      Kapitel 1: Blender Animationen Grundlagen


      Auf dieser Abbildung seht ihr das Animationsfenster in Blender
      • Rechts ist die vertraute 3D Ansicht, dort seht ihr euer Modell und die sog. Bones, die eurem Objekt zugewiesen sind.
      • Links findet ihr ein zweigeteiltes Fenster. Oben seht ihr den Action Editor. Dort könnt ihr kleine "Unteranimationen" erstellen. Man sieht die einzelnen Keyframes, die den Bones während eines bestimmten Zeitpunkts zugewiesen sind. Das untere Menü ist derzeit nicht wichtig. Nur soviel: man kann viele dieser "Unteranimationen" dort zusammenführen ;)
      • Unten ist die normale Timeline, dort können viele der kleinen "Unteranimationen" untergebracht werden. Solltet ihr gerade eine "Unteranimation" bearbeiten, seht ihr dort die selben Keyframes wie im Action Editor.


      Um in diese Ansicht zu kommen, klickt ihr auf das Screen-Layout Dropdown Auswahlmenü und wählt "Animation" aus:


      Nun habt ihr das Animationslayout geöffnet. Nehmen wir also an, ihr habt euer Objekt fertig modelliert und wollt es nun animieren.
      Es sind nun zwei Schritte zu vollenden, um das zu erreichen:
      1. riggen - Eurem Modell die sog. Bones zuweisen.
      2. animieren - das Modell animieren


      Schritt 1: Riggen
      Spoiler anzeigen

      Ihr drückt nun im 3D-Fenster die Leertaste, dadurch öffnet sich ein Auswahlmenü:

      Dort wählt ihr: Armature -> Single Bone

      nun habt ihr eine Single Bone erstellt. Diese rückt ihr zurecht, in etwa so, dass sie dem "Hauptkörper" entspricht.
      Ich bin nun in die Wireframeansicht gewechselt mittels einem Druck auf "Z", sodass ich die Körperteile besser sehe


      Nun in den Edit-Modus gewechselt, könnt ihr diese Bone duplizieren mittels "Shift und D" und an den richtigen stellen einsetzen.
      Bones, können auch direkt mittels "E" aus einer anderen herausgezogen werden. solltet ihr soweit sein, könnten eure Bones so aussehen:

      Das ist nun eine sog. Armature. Sie besteht aus vielen kleinen Bones.

      um die Armature und somit die einzelnen Bones an euer Modell zu binden, verwenden wir das "Parenting".
      Wichtig ist die folgende Reihenfolge!:
      1. Auswahl des Modells
      2. Auswahl der Armature
      3. Strg und P Drücken
      4. Armature Deform -> With Automatic Weights auswählen


      Ihr könnt bereits probieren, eure Bones zu bewegen, dazu geht ihr einfach in den "Pose Mode", während ihr die Armature ausgewählt habt:

      und nun könnt ihr die Bones rotieren und bewegen, während das Modell ihnen folgt.

      ihr merkt sicher, dass die Bones nicht ganz mit den Körperteilen des Modells übereinstimmen. Das macht nichts, das ist schon der Finale Teil im Riggen.
      Die Armature hat für jeden Bone eine Vertex-Gruppe im Modell erstellt. Diese Vertex-Gruppe beeinhaltet einige Polygone, die dem Bone zugeordnet sind.
      Als erstes geht ihr in das Armature Menü und nehmt folgende Einstellungen vor:

      Den Namen der Bone anzuzeigen ist wichtig beim zuordnen.
      xray ist notwendig, damit ihr alle Bones seht, auch welche die vom Objekt überdeckt sind.

      Euer Objekt müsst ihr nun auswählen, in den Edit Modus wechseln und zu den Vertex-Gruppen Einstellungen Wechseln:


      ihr seht nun die Vertex Gruppen, die Blender für euch angelegt hat. Jede Vertex-Gruppe ist nach dem gleichnamigen Bone benannt.
      nun müsst ihr euch an die mühselige Arbeit machen, die Gruppen auszuwählen, mittels dem Assign Knopf Polygone zuweisen, oder mittels remove überflüssige entfernen.



      Das wars! das geriggte Modell ist fertig :)


      Schritt 2: Animieren
      Spoiler anzeigen
      ihr erstellt einfach "Actions", diese könnt ihr mittels Auswahl des Action Editors machen:

      nun einfach weiter mittels "New" eine neue Action erstellen.
      Benennt diese Action recht aussagekräftig und grenzt die Timeline ein. (ansonsten würde der Obj exporter 260 Modelle erstellen wollen)


      nun kommt auch schon das Spaßige: Keyframes erstellen

      Mittels Tastendruck auf "I" während ihr ein Bone im Posemode ausgewählt habt, könnt ihr einen Keyframe
      erstellen. Wir wählen "LocRotScale" aus. Damit ist ein Keyframe an dieser stelle für Location, Rotation und Scale gesetzt.

      erstellt nun mehrere und somit eine Animation :)


      Schritt 3: Exportieren
      Spoiler anzeigen

      Eine Animation habt ihr nun fertiggestellt. Exportieren wir sie mittels dem Wavefront obj exporter:

      File -> Export -> Wavefront .Obj


      im darauffolgenden Fenster, nicht sofort auf speichern drücken, sondern die etwas versteckten Optionen freiscrollen:


      beim abspeichern erstellt Blender für jeden Frame (in meinem Fall 19) eine .obj und eine .mtl Datei.


      Damit wäre der Blenderteil geschafft. Wir gehen über in den Game Maker und Moolts example-simple.zip aus Moolts 3d für Anfänger - Modelle Tutorial.

      Kapitel 2: Game Maker Animationen laden/abspielen
      Spoiler anzeigen

      Wir erstellen ein Array mit dem Inhalt der einzelnen Frames. Generell mache ich das mittels for(i=0; i<dateienanzahl; i+=1) array = createFromObj("dateiname"+String(i));
      in diesem Fall ist der Array hardcoded:
      :event_create:

      GML-Quellcode

      1. model_char[0]=createFromObj('models\character\char_000001.obj')
      2. model_char[1]=createFromObj('models\character\char_000002.obj')
      3. model_char[2]=createFromObj('models\character\char_000003.obj')
      4. model_char[3]=createFromObj('models\character\char_000004.obj')
      5. model_char[4]=createFromObj('models\character\char_000005.obj')
      6. model_char[5]=createFromObj('models\character\char_000006.obj')
      7. model_char[6]=createFromObj('models\character\char_000007.obj')
      8. model_char[7]=createFromObj('models\character\char_000008.obj')
      9. model_char[8]=createFromObj('models\character\char_000009.obj')
      10. model_char[9]=createFromObj('models\character\char_000010.obj')
      11. model_char[10]=createFromObj('models\character\char_000011.obj')
      12. model_char[11]=createFromObj('models\character\char_000012.obj')
      13. model_char[12]=createFromObj('models\character\char_000013.obj')
      14. model_char[13]=createFromObj('models\character\char_000014.obj')
      15. model_char[14]=createFromObj('models\character\char_000015.obj')
      16. model_char[15]=createFromObj('models\character\char_000016.obj')
      17. model_char[16]=createFromObj('models\character\char_000017.obj')
      18. model_char[17]=createFromObj('models\character\char_000018.obj')
      19. model_char[18]=createFromObj('models\character\char_000019.obj')
      21. frame=0;
      22. z=0;
      Alles anzeigen

      Frame ist das derzeit angezeigte Frame.

      :event_step:

      GML-Quellcode

      1. if(frame<18){
      2. frame+=1;
      3. }else{
      4. frame=0;
      5. }

      Diese simple Abfrage, spielt den Array[0-18] durch, das sind 19 Frames. Am Ende springt es wieder zum 0. Frame


      dann nurnoch das Draw-Event anpassen:
      :event_draw:

      GML-Quellcode

      1. d3d_model_draw(model_char[frame],x,y,z,Texture)//es wird das Model mit dem Index Frame gezeichnet


      somit habt ihr eure Animation fertig im Game Maker.
      Viel Spaß!


      Nachtrag:
      - Leider ist dies nicht die effizienteste Lösung, passt zudem auf, dass ihr nicht bei jedem Objekt gleiche Animationen mehrmals lädt.
      - Es gibt in Blender ebenso die Möglichkeit mittels "Weight Paint" die Bones zuzuweisen. Meiner Meinung geht das aber nicht so präzise.

      Moolt's Example für Animationen angepasst:
      Externer Link (wikisend.com)

      Dieser Beitrag wurde bereits 4 mal editiert, zuletzt von domis4 ()

    • Durchaus ein schön ansehliches Tutorial.
      Gut geschrieben und viele Bilder (zum visuellen nachvollziehen) sind auch vorhanden.
      Wobei ich sagen muss, dass das Thema "rigging" etwas komplexer ist und für viele Anfänger anhand dieses Tutorials nciht nachvollziehbar sein wird.
      (Da müsste man sich schon konkret mit dem ganzen Bone-system in Blender auseinandersetzen um zu kapieren wie man das wirklich verwenden sollte.)
      Ist aber kein wirkliches Manko. Du hast da zumindest einen Überblick in das animieren in Blender gewährt. :)


      Diese Methode ist für große und flüssige Animationen eher ungeeignet. Es wäre schön, wenn es eine Lösung mit Shadern geben würde. Die Grundelemente sind dabei ja schon alle vorhanden: "Eigene Vertexformate und Vertexshader". Ein Tutorial dazu, würde mich sehr freuen.

      Witzigerweise habe ich mich damit schon vor einiger Zeit auseinandergesetzt. Es stimmt, wir haben die Möglichkeit Shader und eigene Vertexformate zu erstellen und diese zu benutzen.
      Jedoch gibt es da 1 Sache die eine riesige Hürde darstellt: Für Morph-animationen brauchen wir immer 2 Modelle. Zwischen den 2 Modellen kann dann interpoliert werden um eine flüssige Animation darzustellen.
      Leider gibt es keine Möglichkeit 2 (oder mehr) Modelle an einen Shader zu heften. Ohne der Möglichkeit, Informationen eines 2ten Modells an den Shader zu senden, kann man das nicht "einfach so" realisieren.
      Man könnte natürlich jetzt versuchen z.B: ein Vertexformat zu schreiben, welches pro vertex 2 Koordinaten besitzt (Koordinaten des 1ten Keyframes und die Koordinaten des 2ten Keyframes) jedoch ist dies eine aufwendige Methode die noch dazu das limit besitzt, dass man nicht willkürlich zwischen beliebigen Frames interpolieren kann.

      Falls es eine Möglichkeit gäbe diese Informationen effizient an den Shader weiterzugeben, wäre ich gerne bereit solch einen Shader zu schreiben und ihn auch der Öffentlichkeit zur verfügung zu stellen. (War selbst in letzter Zeit am Recherchieren, jedoch ohne Erfolg.)

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von LEWA ()

    • Ich hätte da eher an Bone-Animation gedacht. Ich hatte auch schonmal einen Anfang dazu geschrieben:

      Quellcode

      1. attribute vec3 in_Position;
      2. attribute vec4 in_Colour;
      3. attribute vec2 in_TextureCoord;
      4. attribute vec3 in_Normal;
      5. attribute vec2 in_Index;
      6. attribute vec2 in_Weight;
      8. uniform mat4 Bone[16];
      10. varying vec2 v_vTexcoord;
      11. varying vec4 v_vColour;
      12. varying vec3 v_vNormal;
      14. void main()
      15. {
      16. vec4 newVertex;
      17. vec4 newNormal;
      18. int index;
      20. //Gibt an wie stark das Polygon vom ersten Gelenk beeinflusst wird.
      21. index = int(in_Index.x);
      22. newVertex = (Bone[index] * vec4(in_Position, 1.0)) * in_Weight.x;
      23. newNormal = (Bone[index] * vec4(in_Normal, 0.0)) * in_Weight.x;
      24. //Gibt an wie stark das Polygon vom zweiten Gelenk beeinflusst wird.
      25. index = int(in_Index.y);
      26. newVertex += (Bone[index] * vec4(in_Position, 1.0)) * in_Weight.y;
      27. newNormal += (Bone[index] * vec4(in_Normal, 0.0)) * in_Weight.y;
      29. gl_Position = gm_Matrices[MATRIX_WORLD_VIEW_PROJECTION] * vec4(newVertex.xyz, 1.0);
      30. v_vColour = in_Colour;
      31. v_vTexcoord = in_TextureCoord;
      32. v_vNormal = vec3(gm_Matrices[MATRIX_WORLD_VIEW] * newNormal);
      33. }
      Alles anzeigen

    • Ein skellet-basierender Shader ist zwar schön und gut, jedoch bringt er dich auch nicht weiter wenn du keine geriggten Modelle mitsamt den Animationen in den Game Maker importieren kannst.
      Ich habe mir mal Blenders exportmöglichkeiten mitsamt dem exportierten Inhalt der jeweiligen Formate angeschaut.
      Schonmal ein 3D Modell mit animationen als ein Collada file exportiert? > Viel Spaß beim Parsen. (Ist eine Katastrophe XD)
      Ansonsten konnte ich kein "simples" 3D Format finden welches Bones unterstützen würde. Letzendlich lief es darauf hinaus, dass man sich ein eigenes 3D Format schreiben müsste...

      Natürlich wäre das technisch gesehen die beste Möglichkeit. Jedoch brauchst du neben den Shader noch die ganzen extra Tools um das wirklich nutzen zu können. (3D Model/Bone importer für Monster Formate wie Collada oder eben ein eigenes 3D Format was weitere import/exportscripts verlangen würde...)
      Für frame-by-frame Animationen genügt der Shader und ein Obj-importer. (Es bleibt nur die Frage offen wie man 2 Modelle an den Shader übergeben könnte...)

      /Edit: Falls du bereits solch einen Importer hast, ist es natürlich eine andere Sache.

      Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von LEWA ()