Blenderexporter
Bitte haben Sie etwas Geduld und nehmen Sie keine Änderungen vor, bis der Artikel hochgeladen wurde. |
 |
Inhaltsverzeichnis
Vorwort
Hier werde ich einige Codeschnipsel zeigen, mit denen man sich einen eigenen Blenderexporter bauen kann. Der Schwerpunkt liegt dabei darauf, die Daten so vorzubereiten, dass sie direkt als VertexBufferObjekt in die Grafikkarte hochgeladen werden können.
Dieses Tutorial, soll kein festes Format beschreiben. Es ist sowohl möglich die Daten sauber in XML zu kapseln, als auch ganz dirty mal eben ein Includierbares C oder Pascalfile zu erzeugen. Der Compiler wird einen dafür aber mit erheblich längeren compelierungszeiten bestrafen.
Prinzipell bin ich der Meinung, das eine eigene Engine nicht zwangshaft mit einem Universalformat wie Collada verwendet werden muss. Auch beliebte Formate wie 3DS haben gewaltige Nachteile, da sie nicht alle Daten speichern können, die beim Arbeiten mit Shadern benötigt werden. 3DS ist eine gut wahl, solang man nicht viel mehr als Vertices, Normals und UV Coordinaten benötigt. Sobald Bones Vertexgruppen, TBN Matrizen und möglicherweise weitere eigene Daten gespeichert werden müssen gibt es große Probleme.
Aufbau eines Exporters
Jeder Blenderexporter verfügt über einen Header, in dem Daten stehen, wie er in die Menüstruktur eingefügt wird. Anschließen folt der Python code. Näheres dazu steht in den Wikibooks.
#!BPY
"""
Name: 'DGL Wiki'
Blender: 241
Group: 'Export'
Tooltip: 'DGL Wiki Exporter'
"""
import Blender
def write(file):
out = file(file, 'w')
obj = Blender.Object.GetSelected()[0]
msh = obj.getData()
#hier wird Code eingefügt, der die zu exportierenden Daten in das File schreibt
out.close()
Blender.Window.FileSelector(write, "Export")
Wichtig ist, das man bei Python die Einrückungen beachtet. Als erstes wird eine Funktion definiert, die vom Fileexportdialog aus aufgerufen wird. Dabei wird der Filename als Argument übergeben. Die folgenden Zeilen öffnen ein File zum schreiben und hohlen sich die Meshdaten des erstem selektiertem Objektes. Starten tut das Script eigendlich erst in der letzten Zeile, die den Exportdialog aufruft.
Exportieren der Daten
hier beschreiben ich wie man die wichtigsten Daten exportieren kann. Um ein anderes Format zu erhalten, müssen die Stings entsprechend angepasst werden. Eine neue Zeile erhält man durch "\n" In den Beispielen werde ich mich weitgehend an Werten gekapselt in einem XMLformat halten. Durch simple Modifikationen sind auch andere Formate kein problem.
Es gibt zwei Möglichkeiten die Vertexdaten zu speichern: Interleaved oder getrennte Blöcke. Beim interleaved Format verliert man die Flexibilität und die Daten werden noch unübersichtlicher. Ein Geschwindigkeitsgewinn ist auch nicht zu erwarten.
In einigen Codestücken wird auffallen, das die Convertierung von Quads nach Triangles immer wieder vorgenommen wird. In einem komplettem Exporten macht es durchaus Sinn, alle Daten erst zu sammel, dann zu sortieren, umwandeln und erst zum Schluss zu schreiben. Dabei wäre es allerdings nicht mehr möglich einzelne Beispiele zu liefern.
Eine besonder Problematik ist, dass Blender Quads beforzugt, jedoch Quads und Triangles gemischt vorliegen können. Um diese Mischung zu vermeiden sollte man entweder den Exporter so schreiben, dass er die Quads in 3 Triangles zerlegt oder vor dem Exportieren alle Quads in Triangles umwandelt und Speichert (Intern bleiben die Daten sonst anscheined immer noch Quads)
Einfachen Text, der keine zu exportierenden Daten enhält lässt sich so in die Datei schreiben. Hier ein möglicher begin der XML Datei:
out.write('<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<vbo>\n')
Die letzte Zeile sollte das VBO tag wieder schließen:
out.write('<vbo>\n')
Wichtig ist hier wieder die Einrückung. Sie muss genauso weit eingerück sein wie die vorige Zeile, oder weiter eingerück werden wenn es sich um eine Schleife handelt.
Eine kleines Problem kann entstehen, wenn die letzte Zeile eines Datensatzes kein Komma enthalten darf. Der einfachste Weg ist eine Dummyzeile mit Nullwerten anzuhängen.
Name des Objektes
In einem XML format ist es nicht alzuwichtig den Objektnamen aus Blender zu behalten. Jedoch kann es sehr nützlich sein wenn man andere Formate schreibt oder mehrere Objekte in einer Datei speichert:
out.write('<name>%s</name>\n' % (mesh.name))
Anzahl der Dreiecke
Wenn nur Dreiecke vorhanden sind kann man so die Anzahl der Dreiecke speichern:
out.write('<triangles>%i</triangles>\n' % (len(mesh.faces)))
Mit folgendem Code kann man berücksichtigen, wie viele Triangles entstehen wenn die Quads gesplittet werden:
count = 0
for face in msh.faces:
count += len (face.v)-2
out.write('<triangles>%i</triangles>\n' % (count)))
Vertices
Da man den Index eines Vertexarray nicht in einem VBO verpacken kann. Ist es besser die Triangles nicht indiziert in einem VBO zu speichern. Der Speicherbedarf ist hier Allerdings höher. Trotz der erhöten Datenmenge scheint diese Variante schneller zu sein, da hier keine Array vom Prozessor abgearbeitet werden müssen. Unter der Annahme, das nur Triangles vorhanden sind reicht dieser Code:
out.write('<vertices>\n')
for face in msh.faces:
for vert in face.v:
out.write( ' %f %f %f' % (msh.verts[vert.index].co.x, msh.verts[vert.index].co.y, msh.verts[vert.index].co.z) )
out.write('\n')
out.write('</vertices>\n')
Komplizierter wird es wenn möglicher weise auch Quads vorhanden sind. Es gibt zwei Möglichkeiten sie zu splitten. Die bessere Möglichkeit ist, die kürzere Diagolnale zu suchen und den Quad dor in zwei Triangles zu splitten:
out.write('<vertices>\n')
for face in msh.faces:
#Ein einfaches Triangle
if (len(face.v) == 3)
for vert in face.v:
out.write( ' %f %f %f' % (msh.verts[vert.index].co.x, msh.verts[vert.index].co.y, msh.verts[vert.index].co.z))
out.write('\n')
#Quads
else
#ermitteln der kürzeren diagonale durch pytagoras ohne Wurzel
d1 =(msh.verts[face.v[0]].co.x - msh.verts[face.v[2]].co.x) ** 2
d1+=(msh.verts[face.v[0]].co.y - msh.verts[face.v[2]].co.y) ** 2
d1+=(msh.verts[face.v[0]].co.z - msh.verts[face.v[2]].co.z) ** 2
d2 =(msh.verts[face.v[1]].co.x - msh.verts[face.v[3]].co.x) ** 2
d2+=(msh.verts[face.v[1]].co.y - msh.verts[face.v[3]].co.y) ** 2
d2+=(msh.verts[face.v[1]].co.z - msh.verts[face.v[3]].co.z) ** 2
if (d1<d2)
out.write( ' %f %f %f' % (msh.verts[face.v[0]].co.x, msh.verts[face.v[0]].co.y, msh.verts[face.v[0]].co.z))
out.write( ' %f %f %f' % (msh.verts[face.v[1]].co.x, msh.verts[face.v[1]].co.y, msh.verts[face.v[1]].co.z))
out.write( ' %f %f %f' % (msh.verts[face.v[2]].co.x, msh.verts[face.v[2]].co.y, msh.verts[face.v[2]].co.z))
out.write('\n')
out.write( ' %f %f %f' % (msh.verts[face.v[0]].co.x, msh.verts[face.v[0]].co.y, msh.verts[face.v[0]].co.z))
out.write( ' %f %f %f' % (msh.verts[face.v[2]].co.x, msh.verts[face.v[2]].co.y, msh.verts[face.v[2]].co.z))
out.write( ' %f %f %f' % (msh.verts[face.v[3]].co.x, msh.verts[face.v[3]].co.y, msh.verts[face.v[3]].co.z))
out.write('\n')
else
out.write( ' %f %f %f' % (msh.verts[face.v[0]].co.x, msh.verts[face.v[0]].co.y, msh.verts[face.v[0]].co.z))
out.write( ' %f %f %f' % (msh.verts[face.v[1]].co.x, msh.verts[face.v[1]].co.y, msh.verts[face.v[1]].co.z))
out.write( ' %f %f %f' % (msh.verts[face.v[3]].co.x, msh.verts[face.v[3]].co.y, msh.verts[face.v[3]].co.z))
out.write('\n')
out.write( ' %f %f %f' % (msh.verts[face.v[1]].co.x, msh.verts[face.v[1]].co.y, msh.verts[face.v[1]].co.z))
out.write( ' %f %f %f' % (msh.verts[face.v[2]].co.x, msh.verts[face.v[2]].co.y, msh.verts[face.v[2]].co.z))
out.write( ' %f %f %f' % (msh.verts[face.v[3]].co.x, msh.verts[face.v[3]].co.y, msh.verts[face.v[3]].co.z))
out.write('\n')
out.write('</vertices>\n')
Textur-Koordinaten
Kaum schwerer als die Vertexdaten sind die Texturkoordinaten zu exportieren. Da die Texturkoordinaten innerhalb der Faces gespeichert werden. Ist der Code abgesehen von der Quadkonvertierung sogar etwas leichter. Wieder erst der einfache Code:
out.write('<texturecoords>\n')
for face in msh.faces:
out.write( ' %f %f %f %f %f %f\n' % (face.uv[0][0],face.uv[0][1],face.uv[1][0],face.uv[1][1],face.uv[2][0],face.uv[2][1]) )
out.write('</texturecoords>\n')
Um die konvertierung der Quads in Triangles auch in den Texturkoordinaten zu berücksichtigen wird der Code etwas umfangreicher:
out.write('<texturecoords>\n'>
for face in msh.faces:
#Ein einfaches Triangle
if (len(face.v) == 3)
for vert in face.v:
out.write( ' %f %f %f %f %f %f\n' % (face.uv[0][0],face.uv[0][1],face.uv[1][0],face.uv[1][1],face.uv[2][0],face.uv[2][1]) )
#Quads
else
#ermitteln der kürzeren diagonale durch pytagoras ohne Wurzel
d1 =(msh.verts[face.v[0]].co.x - msh.verts[face.v[2]].co.x) ** 2
d1+=(msh.verts[face.v[0]].co.y - msh.verts[face.v[2]].co.y) ** 2
d1+=(msh.verts[face.v[0]].co.z - msh.verts[face.v[2]].co.z) ** 2
d2 =(msh.verts[face.v[1]].co.x - msh.verts[face.v[3]].co.x) ** 2
d2+=(msh.verts[face.v[1]].co.y - msh.verts[face.v[3]].co.y) ** 2
d2+=(msh.verts[face.v[1]].co.z - msh.verts[face.v[3]].co.z) ** 2
if (d1<d2)
out.write( ' %f %f %f %f %f %f\n' % (face.uv[0][0],face.uv[0][1],face.uv[1][0],face.uv[1][1],face.uv[2][0],face.uv[2][1]) )
out.write( ' %f %f %f %f %f %f\n' % (face.uv[0][0],face.uv[0][1],face.uv[2][0],face.uv[2][1],face.uv[3][0],face.uv[3][1]) )
else
out.write( ' %f %f %f %f %f %f\n' % (face.uv[0][0],face.uv[0][1],face.uv[1][0],face.uv[1][1],face.uv[3][0],face.uv[3][1]) )
out.write( ' %f %f %f %f %f %f\n' % (face.uv[1][0],face.uv[1][1],face.uv[2][0],face.uv[2][1],face.uv[3][0],face.uv[3][1]) )
out.write('</texturecoords>\n')
Normals
Normalvektoren sind in Blender sowohl per Vertex als auch per Face abgespeichert. Abhängig, davon ob eine Fläche als Smooth (per Vertex) oder Solid (per Face) dargestellt wird, werden die die entsprechenden Normalvektoren ausgewählt. Damit auch Klötze mit Kanten dargestellt werden können müssen beide Fälle berücksichtigt werden. Im Fall Solid müssen für alle Vertices der Fläche der Normalvektor der Fläche verwendet werden. Im Fall Smooth muss hier der Normalvektor der Vertices benutz werden. Auf keinen Fall sollte man nun die Vervielfachung der Vertices als Problem ansehen, da die verschiedenen Normalvektoren, diesen Nachteil wieder volkommen ausgleichen.
Tip: Da ganze Flächen als Solid keinerlei Optische Rundungen zulassen, ist der einzige Weg, echte Kanten an runden Objekten zu erzeugen in dem man das Mesch an der Stelle splittet. Leider muss man zum Splitten einen vollständigen Edgeloop auswählen. An Stellen die nicht kantig sein sollen muss man dann beide Vertices Makieren und mit "remove doubles" vereinen.
Auch hier ersst einmal ein einfaches Beispiel was haufig schon genügen sollte:
out.write('<vertices>\n')
for face in msh.faces:
for vert in face.v:
out.write( ' %f, %f, %f,' % (msh.verts[vert.index].no.x, msh.verts[vert.index].no.y, msh.verts[vert.index].no.z) )
out.write('\n')
out.write('</vertices>\n')
Besser wird es, wenn Smooth/Solid berücksichtigt wird.
out.write('<vertices>\n')
for face in msh.faces:
if (face.smooth == 1)
for vert in face.v:
out.write( ' %f, %f, %f,' % (msh.verts[vert.index].no.x, msh.verts[vert.index].no.y, msh.verts[vert.index].no.z))
out.write('\n')
else
for vert in range(0,3):
out.write( ' %f, %f, %f,' % (face.no.x, face.no.y, face.no.z))
out.write('\n')
out.write('</vertices>\n')
Nun bleibt noch der Fall in dem noch Triangles und Quads gemischt sind. Die Entscheidung wie das Quad gesplitted wird muss die gleiche sein, wie bei den Vertices. Der Code wird allerdings noch ein wenig länger, da noch mehr Fälle vorkommen können:
out.write('<normals>\n')
for face in mesh.faces:
if (face.smooth==1)
#Ein einfaches Triangle
if (len(face.v) == 3)
for vert in face.v:
out.write( ' %f %f %f' % (msh.verts[vert.index].no.x, msh.verts[vert.index].no.y, msh.verts[vert.index].no.z))
out.write('\n')
#Quads
else
#ermitteln der kürzeren diagonale durch pytagoras ohne Wurzel
d1 =(msh.verts[face.v[0]].co.x - msh.verts[face.v[2]].co.x) ** 2
d1+=(msh.verts[face.v[0]].co.y - msh.verts[face.v[2]].co.y) ** 2
d1+=(msh.verts[face.v[0]].co.z - msh.verts[face.v[2]].co.z) ** 2
d2 =(msh.verts[face.v[1]].co.x - msh.verts[face.v[3]].co.x) ** 2
d2+=(msh.verts[face.v[1]].co.y - msh.verts[face.v[3]].co.y) ** 2
d2+=(msh.verts[face.v[1]].co.z - msh.verts[face.v[3]].co.z) ** 2
if (d1<d2)
out.write( ' %f %f %f' % (msh.verts[face.v[0]].no.x, msh.verts[face.v[0]].no.y, msh.verts[face.v[0]].no.z))
out.write( ' %f %f %f' % (msh.verts[face.v[1]].no.x, msh.verts[face.v[1]].no.y, msh.verts[face.v[1]].no.z))
out.write( ' %f %f %f' % (msh.verts[face.v[2]].no.x, msh.verts[face.v[2]].no.y, msh.verts[face.v[2]].no.z))
out.write('\n')
out.write( ' %f %f %f' % (msh.verts[face.v[0]].no.x, msh.verts[face.v[0]].no.y, msh.verts[face.v[0]].no.z))
out.write( ' %f %f %f' % (msh.verts[face.v[2]].no.x, msh.verts[face.v[2]].no.y, msh.verts[face.v[2]].no.z))
out.write( ' %f %f %f' % (msh.verts[face.v[3]].no.x, msh.verts[face.v[3]].no.y, msh.verts[face.v[3]].no.z))
out.write('\n')
else
out.write( ' %f %f %f' % (msh.verts[face.v[0]].no.x, msh.verts[face.v[0]].no.y, msh.verts[face.v[0]].no.z))
out.write( ' %f %f %f' % (msh.verts[face.v[1]].no.x, msh.verts[face.v[1]].no.y, msh.verts[face.v[1]].no.z))
out.write( ' %f %f %f' % (msh.verts[face.v[3]].no.x, msh.verts[face.v[3]].no.y, msh.verts[face.v[3]].no.z))
out.write('\n')
out.write( ' %f %f %f' % (msh.verts[face.v[1]].no.x, msh.verts[face.v[1]].no.y, msh.verts[face.v[1]].no.z))
out.write( ' %f %f %f' % (msh.verts[face.v[2]].no.x, msh.verts[face.v[2]].no.y, msh.verts[face.v[2]].no.z))
out.write( ' %f %f %f' % (msh.verts[face.v[3]].no.x, msh.verts[face.v[3]].no.y, msh.verts[face.v[3]].no.z))
out.write('\n')
else
#Drei Normalvektoren für ein Solid Triangle
for vert in range(0,3):
out.write( ' %f, %f, %f,' % (face.no.x, face.no.y, face.no.z))
out.write('\n')
# Drei zusätzliche Normalvektoren für ein gesplitetes Solid Quad
if (len(face.v)==4)
for vert in range(0,3)
out.write( ' %f, %f, %f,' % (face.no.x, face.no.y, face.no.z))
out.write('\n')
out.write('</normals>\n')
Tangenvektor / TBN Matrix
Ohne die TBN Matrix lässt sich in den shadern kein sinvolles Bumpmapping durchführen...
Vertuxgruppen / Bones
Ohne Vertexgruppen und Bones lassen sich keine Animationen mit hilfe des Vertexshaders realisieren. Diesen Teil können alle überspringen, die keine Vertexshader zum Animieren benutzen wollen. Die Jenigen, die diese Daten im Vertexshader benötigen, traue ich auch zu durch diesen etwas umfangreicheren Code durchzusteigen.
Leider liegen die Daten in Blender in einer für Vertexshader total unbrauchbaren Form vor. In jeder Vertexgruppe, auf die man auch noch über Ihren Namen zugreifen muss, liegt eine Liste mit der Vertexnummer und der Gewichtung. Für einen Vertexshader benötigen wir pro Vertex einen Index, der die Vertexgruppe/Bone beschreibt und die Gewichtung. Außerdem müssen wir uns voher entscheiden, wie viele Bones wir maximal pro Vertex berücksichtigen.
Da das umformen der Daten etwas komplizierter ist erst mal ein wenig Code:
out.write('<vertexgroups>\n')
groups = msh.getVertGroupNames()
for face in msh.faces:
for vert in face.v:
list = []
count = 1
for group in groups:
if (len(msh.getVertsFromGroup(group,0,[vert.index]))==1)
list += [(msh.getVertsFromGroup(group,1,[vert.index])[0][1],count)]
count ++
list.sort()
list.reverse()
#liste auf minstesanzahl mit nulldaten auffüllen zuviel schadet nicht
for vert in range(0,4):
list += [(0.0, 0)]
#Ausgabe Die Indizies könnten noch von den Gewichtungen getrennt werden...
out.write( ' %f %f %f %f' % (list[0][0],list[1][0],list[2][0],list[3][0]))
out.write( ' %i %i %i %i \n' % (list[0][1],list[1][1],list[2][1],list[3][1]))
out.write('</vertexgroups>\n')
Bei Mangel an "attribute" Variablen macht es Sinn, die Gewichtung (muss kleiner als 1 sein) mit den Indizies zu addieren. Im Shader kann man die dann wieder herausrechnen. Da der Code nun schon recht unüberschau bar ist und es ein völliges Caos geben würden wenn noch die Quads in Triangles zerlegt werden, werden im nächstem Codesample die Vertexgruppen vorab zusammengesammlt:
vertGroupData = []
groups = msh.getVertGroupNames()
for vert in mesh.verts:
list = []
count = 1
for group in groups:
if (len(msh.getVertsFromGroup(group,0,[vert.index]))==1)
list += [(msh.getVertsFromGroup(group,1,[vert.index])[0][1],count)]
count ++
list.sort()
list.reverse()
list += [(0.0, 0),(0.0, 0),(0.0, 0),(0.0, 0)]
vertGroupData += (list[0],list[1],list[2],list[3])
Zu jedem Vertex liegen nun die vier Vertexgruppen mit der höchsten Gewichtung als Listen in vertGroupData. Das schreiben in eine Datei ist nun sehr ähnlich zu den vorigen Codesamples aufgrund der Datenmenge allerdings etwas länger:
out.write('<verrtexgroups>\n')
out.write('<weight>\n')
for face in msh.faces:
#Ein einfaches Triangle
if (len(face.v) == 3)
for vert in face.v:
out.write( ' %f %f' % (vertGroupData[vert.index][0][0],vertGroupData[vert.index][1][0]))
out.write( ' %f %f\n' % (vertGroupData[vert.index][2][0],vertGroupData[vert.index][3][0]))
#Quads
else
#ermitteln der kürzeren diagonale durch pytagoras ohne Wurzel
d1 =(msh.verts[face.v[0]].co.x - msh.verts[face.v[2]].co.x) ** 2
d1+=(msh.verts[face.v[0]].co.y - msh.verts[face.v[2]].co.y) ** 2
d1+=(msh.verts[face.v[0]].co.z - msh.verts[face.v[2]].co.z) ** 2
d2 =(msh.verts[face.v[1]].co.x - msh.verts[face.v[3]].co.x) ** 2
d2+=(msh.verts[face.v[1]].co.y - msh.verts[face.v[3]].co.y) ** 2
d2+=(msh.verts[face.v[1]].co.z - msh.verts[face.v[3]].co.z) ** 2
if (d1<d2)
out.write( ' %f %f' % (vertGroupData[face.v[0]][0][0],vertGroupData[face.v[0]][1][0]))
out.write( ' %f %f\n' % (vertGroupData[face.v[0]][2][0],vertGroupData[face.v[0]][3][0]))
out.write( ' %f %f' % (vertGroupData[face.v[1]][0][0],vertGroupData[face.v[1]][1][0]))
out.write( ' %f %f\n' % (vertGroupData[face.v[1]][2][0],vertGroupData[face.v[1]][3][0]))
out.write( ' %f %f' % (vertGroupData[face.v[2]][0][0],vertGroupData[face.v[2]][1][0]))
out.write( ' %f %f\n' % (vertGroupData[face.v[2]][2][0],vertGroupData[face.v[2]][3][0]))
out.write( ' %f %f' % (vertGroupData[face.v[0]][0][0],vertGroupData[face.v[0]][1][0]))
out.write( ' %f %f\n' % (vertGroupData[face.v[0]][2][0],vertGroupData[face.v[0]][3][0]))
out.write( ' %f %f' % (vertGroupData[face.v[2]][0][0],vertGroupData[face.v[2]][1][0]))
out.write( ' %f %f\n' % (vertGroupData[face.v[2]][2][0],vertGroupData[face.v[2]][3][0]))
out.write( ' %f %f' % (vertGroupData[face.v[3]][0][0],vertGroupData[face.v[3]][1][0]))
out.write( ' %f %f\n' % (vertGroupData[face.v[3]][2][0],vertGroupData[face.v[3]][3][0]))
else
out.write( ' %f %f' % (vertGroupData[face.v[0]][0][0],vertGroupData[face.v[0]][1][0]))
out.write( ' %f %f\n' % (vertGroupData[face.v[0]][2][0],vertGroupData[face.v[0]][3][0]))
out.write( ' %f %f' % (vertGroupData[face.v[1]][0][0],vertGroupData[face.v[1]][1][0]))
out.write( ' %f %f\n' % (vertGroupData[face.v[1]][2][0],vertGroupData[face.v[1]][3][0]))
out.write( ' %f %f' % (vertGroupData[face.v[3]][0][0],vertGroupData[face.v[3]][1][0]))
out.write( ' %f %f\n' % (vertGroupData[face.v[3]][2][0],vertGroupData[face.v[3]][3][0]))
out.write( ' %f %f' % (vertGroupData[face.v[1]][0][0],vertGroupData[face.v[1]][1][0]))
out.write( ' %f %f\n' % (vertGroupData[face.v[1]][2][0],vertGroupData[face.v[1]][3][0]))
out.write( ' %f %f' % (vertGroupData[face.v[2]][0][0],vertGroupData[face.v[2]][1][0]))
out.write( ' %f %f\n' % (vertGroupData[face.v[2]][2][0],vertGroupData[face.v[2]][3][0]))
out.write( ' %f %f' % (vertGroupData[face.v[3]][0][0],vertGroupData[face.v[3]][1][0]))
out.write( ' %f %f\n' % (vertGroupData[face.v[3]][2][0],vertGroupData[face.v[3]][3][0]))
out.write('</weight>\n')
out.write('<index>\n')
for face in msh.faces:
#Ein einfaches Triangle
if (len(face.v) == 3)
for vert in face.v:
out.write( ' %i %i' % (vertGroupData[vert.index][0][1],vertGroupData[vert.index][1][1]))
out.write( ' %i %i\n' % (vertGroupData[vert.index][2][1],vertGroupData[vert.index][3][1]))
#Quads
else
#ermitteln der kürzeren diagonale durch pytagoras ohne Wurzel
d1 =(msh.verts[face.v[0]].co.x - msh.verts[face.v[2]].co.x) ** 2
d1+=(msh.verts[face.v[0]].co.y - msh.verts[face.v[2]].co.y) ** 2
d1+=(msh.verts[face.v[0]].co.z - msh.verts[face.v[2]].co.z) ** 2
d2 =(msh.verts[face.v[1]].co.x - msh.verts[face.v[3]].co.x) ** 2
d2+=(msh.verts[face.v[1]].co.y - msh.verts[face.v[3]].co.y) ** 2
d2+=(msh.verts[face.v[1]].co.z - msh.verts[face.v[3]].co.z) ** 2
if (d1<d2)
#Vertex 0 Triangle 0
out.write( ' %i %i' % (vertGroupData[face.v[0]][0][1],vertGroupData[face.v[0]][1][1]))
out.write( ' %i %i\n' % (vertGroupData[face.v[0]][2][1],vertGroupData[face.v[0]][3][1]))
#Vertex 1 Triangle 0
out.write( ' %i %i' % (vertGroupData[face.v[1]][0][1],vertGroupData[face.v[1]][1][1]))
out.write( ' %i %i\n' % (vertGroupData[face.v[1]][2][1],vertGroupData[face.v[1]][3][1]))
out.write( ' %i %i' % (vertGroupData[face.v[2]][0][1],vertGroupData[face.v[2]][1][1]))
out.write( ' %i %i\n' % (vertGroupData[face.v[2]][2][1],vertGroupData[face.v[2]][3][1]))
out.write( ' %i %i' % (vertGroupData[face.v[0]][0][1],vertGroupData[face.v[0]][1][1]))
out.write( ' %i %i\n' % (vertGroupData[face.v[0]][2][1],vertGroupData[face.v[0]][3][1]))
out.write( ' %i %i' % (vertGroupData[face.v[2]][0][1],vertGroupData[face.v[2]][1][1]))
out.write( ' %i %i\n' % (vertGroupData[face.v[2]][2][1],vertGroupData[face.v[2]][3][1]))
out.write( ' %i %i' % (vertGroupData[face.v[3]][0][1],vertGroupData[face.v[3]][1][1]))
out.write( ' %i %i\n' % (vertGroupData[face.v[3]][2][1],vertGroupData[face.v[3]][3][1]))
else
out.write( ' %i %i' % (vertGroupData[face.v[0]][0][1],vertGroupData[face.v[0]][1][1]))
out.write( ' %i %i\n' % (vertGroupData[face.v[0]][2][1],vertGroupData[face.v[0]][3][1]))
out.write( ' %i %i' % (vertGroupData[face.v[1]][0][1],vertGroupData[face.v[1]][1][1]))
out.write( ' %i %i\n' % (vertGroupData[face.v[1]][2][1],vertGroupData[face.v[1]][3][1]))
out.write( ' %i %i' % (vertGroupData[face.v[3]][0][1],vertGroupData[face.v[3]][1][1]))
out.write( ' %i %i\n' % (vertGroupData[face.v[3]][2][1],vertGroupData[face.v[3]][3][1]))
out.write( ' %i %i' % (vertGroupData[face.v[1]][0][1],vertGroupData[face.v[1]][1][1]))
out.write( ' %i %i\n' % (vertGroupData[face.v[1]][2][1],vertGroupData[face.v[1]][3][1]))
out.write( ' %i %i' % (vertGroupData[face.v[2]][0][1],vertGroupData[face.v[2]][1][1]))
out.write( ' %i %i\n' % (vertGroupData[face.v[2]][2][1],vertGroupData[face.v[2]][3][1]))
out.write( ' %i %i' % (vertGroupData[face.v[3]][0][1],vertGroupData[face.v[3]][1][1]))
out.write( ' %i %i\n' % (vertGroupData[face.v[3]][2][1],vertGroupData[face.v[3]][3][1]))
out.write('</index>\n')
out.write('</vertexgroups>\n')
Optimierung der Daten
Bisher haben wir uns Hauptsachlich damit beschäftig wie wir die Daten aus der Blenderstruktur auszulesen und in ein Vertexbufferobjekt kompatible daten unzuformen. Wen die Modelle größer werden oder komplette Level in Blender realisiert werden sollen macht es Sinn die Daten so umzusortieren, das Triangles mit ähnlichen Eigenschaften wie Ort oder Ausrichtung nah im Vertexbufferobjekt beieinander liegen.
Quad/Octree
Beim Octree werden nur die Teile gerender, bei denen voher bekannt ist, dass sie sichtbar sind, leider ist die Baumstruktur eines Octtrees auf dem erstem Blick völlig inkompatibel zu dem linearem Verlauf des Vertexbuffersobjektes.
Um die Faces in den Octree einzusortieren muss von jedem der Schwerpunkt berechnet werden. Dabei sollte ermittelt werden wie groß das größte Face ist und welche Ausmaße der Octtree hat.
Jede der bisherigen exportfunktionen began mit folgender Schleife:
for face in msh.faces:
Sie arbeitet die Faces ohne Optimierung in der Reinfolge ab, wie Blender sie im Speicher hällt. Diese Schleife kann nun einfach ersetzt werden:
