Blender + Xna + Xen = ??? (часть 1)

1
2
3
4
5
6
7

#!BPY
"""
Name: 'XnaDev.Ru Exporter Example'
Blender: 248
Group: 'Export'
Tooltip: 'Exports data from Blender to XNA'
"""

1
2
3
4
5

import os
import math
import bpy
import Blender
from Blender import *

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328

# функция записи в файл отступа от края документа
def wrIndent(file, indent): 
  if indent:
    for i in xrange(indent): # функция xrange создает виртуальный массив начиная с единицы
      file.write("  ") # запись в файл отступа
 
# функция записи открывающего xml тэга с атрибутами, передающимися в виде списка кортежей
def xmlWrOp(file, name, attr = None, indent = 0, iscomplete = 0): 
  wrIndent(file, indent)
  file.write("<" + name)
  if attr:
    for key, value in attr:
      # Здесь пример форматирования строки. Символы, начинающиеся с % будут последовательно
      # заменены аргументами, переданными в виде кортежа
      file.write(' %s="%s"' % (key, str(value)))
  if iscomplete:
	  file.write(" /")
  file.write(">\n")
 
# функция записи в файл завершающего тэга
def xmlWrCl(file, name, indent = 0):
  wrIndent(file, indent)
  file.write(" + name + ">\n")
 
# функция записи в файл конструкции в виде двухмерного вектора с заданным именем
def xmlWriteVector2D(file, name, vals, indent = 0):
  xmlWrOp(file, name, [("X", round(vals[0], 5)), ("Y", round(vals[1], 5))], indent, True)
 
# функция записи в файл конструкции в виде трехмерного вектора с заданным именем
# Обратите внимание, что аргументы вектора сохраняются в порядке 1,2,0 а не 0,1,2
# т.к. Blender имеет систему координат, в которой ось Z является верхом
# необходимо преобразовать трансформации Blender’а к системе координат XNA
def xmlWriteVector3D(file, name, vals, indent = 0):
  xmlWrOp(file, name, [("X", round(vals[1], 5)), ("Y", round(vals[2], 5)), ("Z", round(vals[0], 5))], indent, True)
 
# функция записи трансформаций объекта сцены в файл
def xmlWriteTransforms(file, obj, indent = 0):
  xmlWrOp(file, "Transforms", [], indent)
  # получаем локальные трансформации объекта
  # если у объекта нет родителя, то трансформации будут глобальными
  matrix = obj.getMatrix('localspace')
  pos = matrix.translationPart()
  rot = matrix.toEuler()
  scl = matrix.scalePart()
  # сохраняем трансформации в файл
  xmlWriteVector3D(file, "Pos", [pos[0], pos[1], pos[2]], indent + 1)
  xmlWriteVector3D(file, "Rot", [rot[0], rot[1], rot[2]], indent + 1)
  xmlWriteVector3D(file, "Scl", [scl[0], scl[1], scl[2]], indent + 1)
  xmlWrCl(file, "Transforms", indent)
 
# функция записи дополнительных параметров объектов сцены в файл
def xmlWrProperties(file, props, indent = 0):
  xmlWrOp(file, "Properties", [], indent)
  if props:
    for prop in props:
      xmlWrOp(file, "Property", [("Name", prop.getName()),("Value", prop.getData()) ], indent+1, 1)
  xmlWrCl(file, "Properties", indent)
 
# функция переводящая градусы в радианы
def toRadian(value):
  return value * math.pi / 180.0
 
# функция перевода значения lens, используемого в Blender для задания размера линз камеры
# в FOV, для использования при создании камеры в XNA
def convertLens(lens):
  return 2 * math.atan(16 / lens)
 
 
# коллекция типов источников света
lampTypes = ('Lamp', 'Sun', 'Spot', 'Hemi', 'Area', 'Photon' )
 
# коллекция типов продолжения кривых анимации на концах промежутков анимации
ipoExtendTypes = ("CONST", "EXTRAP", "CYCLIC", "CYCLIC_EXTRAP")
 
# коллекция поддерживаемых экспортером объектов 
supportedObjects = ('Mesh', 'Empty', 'Lamp', 'Camera')
 
# переменная списка, в которую будут записаны все материалы экспортируемых объектов
sceneMaterials = []
 
# коллекции необходимее для определения «правильных» имен кривых при экспорте
# основная задача – приведение анимации в координатную систему XNA
ipoFrom = ('LocX', 'LocY', 'LocZ', 'RotX', 'RotY', 'RotZ', 'ScaleX', 'ScaleY', 'ScaleZ')
ipoTo =   ('LocZ', 'LocX', 'LocY', 'RotZ', 'RotX', 'RotY', 'ScaleZ', 'ScaleX', 'ScaleY')
 
# функция, преобразующая имя кривой в соответствии с вышеприведенными коллекциями
def convertIpoName(name):
  for i, n in enumerate(ipoFrom):
    if n == name:
      return ipoTo[i]
  return name # для кривых, не входящих в коллекцию ничего не меняем
 
# функция, записывающая данные кривой в файл
# тут необходимо знать то, что каждая точка кривой состоит из трех 2D векторов h1, p, h2
# первый и третий – это манипуляторы, которыми можно управлять формой кривой в редакторе Blender.
# p – сама точка кривой.
# В координате x вектора хранится значение времени в секундах, в y – значение кривой
def xmlWriteCurve(file, curve, indent = 0):
  curveName = convertIpoName(curve.name)
  xmlWrOp(file, curveName, [( "Extend", ipoExtendTypes[curve.extend] )], indent)
  for point in curve.bezierPoints:
    xmlWrOp(file, "Point", [], indent + 1)
    h1, p, h2 = point.vec
    if (curveName in ["RotX", "RotY", "RotZ"]):
      # вращение переводим в радианы и умножаем на 10, т.к. Blender 
      # хранит градусы в единицах на порядок меньше
      h1 = [h1[0], toRadian(h1[1] * 10.0)]
      p  = [p[0],  toRadian(p[1]  * 10.0)]
      h2 = [h2[0], toRadian(h2[1] * 10.0)]
    elif (curveName == "Lens"):
      # Lens переводим в FOV
      h1 = [h1[0], convertLens(h1[1])]
      p  = [p[0],  convertLens(p[1])]
      h2 = [h2[0], convertLens(h2[1])]
    xmlWriteVector2D(file, "h1", h1, indent + 2)
    xmlWriteVector2D(file, "p",  p,  indent + 2)
    xmlWriteVector2D(file, "h2", h2, indent + 2)
    xmlWrCl(file, "Point", indent + 1)
  xmlWrCl(file, curveName, indent)
 
 
# Функция записывающие все кривые анимации объекта в файл
# здесь отмечу, что есть два места хранения кривых анимации у каждого объекта
# первое место – сам объект, в котором охраняться кривые, общие для всех объектов
# второе место – контейнер данных, который различается для каждого типа объектов сцены
# я привожу код для экспорта кривых из обоих мест, но реализация анимации не трансформаций
# объектов, а других параметров выходит за рамки текущей статьи
def xmlWriteIpo(file, obj, indent = 0):
  xmlWrOp(file, "Ipo", [], indent)
  if obj.ipo: # общие кривые анимации
    for curve in obj.ipo.curves:
      xmlWriteCurve(file, curve, indent + 1)
    try:
      for curve in obj.data.ipo:
        xmlWriteCurve(file, curve, indent + 1)
    except:
      pass
  elif obj.data: # контейнер, специфичный для каждого типа объектов
    try:
      ipo = obj.data.ipo
      if ipo:
        for curve in ipo:
          xmlWriteCurve(file, curve, indent+1)
    except:
      pass
  xmlWrCl(file, "Ipo", indent)
 
 
# функция записи в файл информации о грани геометрии
def xmlWriteFace(file, face, tan, ind, indent = 0):
  xmlWrOp(file, "Face", [], indent)
  for i in ind:
    attribs = [("Index", face.v[i].index)]
    if face.smooth: # Если грань гладкая, то нормаль берется из вершины
      attribs = attribs + [("NX", round(face.v[i].no[1], 5)), \
        ("NY", round(face.v[i].no[2], 5)), ("NZ", round(face.v[i].no[0], 5))]
    else: # иначе нормаль берется из самой грани
      attribs = attribs + [("NX", round(face.no[1], 5)), ("NY", round(face.no[2], 5)), ("NZ", round(face.no[0], 5))]
    attribs = attribs + [("TX", round(tan[i][1], 5)), ("TY", round(tan[i][2], 5)), ("TZ", round(tan[i][0], 5))]
    attribs = attribs + [("UVX", round(face.uv[i][0], 5)), ("UVY", round(face.uv[i][1], 5))]
    xmlWrOp(file, "V", attribs, indent + 1, True)
  xmlWrCl(file, "Face", indent)
 
 
# Функция записи в файл данных о геометрии объекта «Mesh»
# т.к. Blender изначально не проектировался как игровой движок, данные геометрии хранятся
# несколько иначе, чем в игровых движках или той же XNA. Построение нужных буферов 
# мы будем выполнять при загрузке сцены.
# Массив вершин содержит только положение и нормаль, а для каждой грани можно получить текстурные координаты,
# тангенсы и нормаль, если грань не сглаженная. В каждой грани содержатся ссылки на вершины,
# на основе которых она построена. 
# Здесь хочу заметить, что в Blender могут присутствовать как треугольные грани, так и квады,
# поэтому, реализация алгоритма сохранения это учитывает.
def xmlWriteMeshData(file, mesh, indent = 0):
  md = mesh.getData(mesh = 1) # данные о геометрии содержатся в контейнере объекта
 
  # первое что мы должны проверить – это наличие текстурных координат
  if not md.faceUV:
    print "Mesh '" + mesh.name + "' has no UV, skipped."
    return
 
  xmlWrOp(file, "Mesh", None, indent)
 
  # сохраняем массив вершин
  xmlWrOp(file, "Vertices", [("Count", len(md.verts))], indent + 1)
  for v in md.verts:
    xmlWrOp(file, "Vert", [("Index", v.index), \
      ("X", round(v.co[1], 5)), \
      ("Y", round(v.co[2], 5)), \
      ("Z", round(v.co[0], 5))], indent + 2, 1)
  xmlWrCl(file, "Vertices", indent + 1)
 
  # получаем все материалы объекта
  # если массив материалов объекта не пустой, то сохраняем для каждого материала
  # набор граней, которым назначен этот материал
  # если материалов нет, то сохраняем все грани с материалом None
  # Каждый набор граней сохраняется как MeshPart и атрибутом Material
  materials = md.materials
  if materials:
    for matIndex in xrange(len(materials)):
      if not materials[matIndex] in sceneMaterials:
        sceneMaterials.append(materials[matIndex])
      xmlWrOp(file, "MeshPart", [("Material", materials[matIndex].name)], indent + 1)
      tan = md.getTangents()
      for i, face in enumerate(md.faces):
        if face.mat == matIndex:
          xmlWriteFace(file, face, tan[i], (0, 2, 1) , indent + 2)
          if len(face.v) == 4: # если грань – квад, то сохраняем второй треугольник
            xmlWriteFace(file, face, tan[i], (2, 0, 3) , indent + 2)
      xmlWrCl(file, "MeshPart", indent + 1)
  else:
    xmlWrOp(file, "MeshPart", [("Material", "None")], indent + 1)
    tan = md.getTangents()
    for i, face in enumerate(md.faces):
      xmlWriteFace(file, face, tan[i], (0, 2, 1) , indent + 2)
      if len(face.v) == 4: : # если грань – квад, то сохраняем второй треугольник
        xmlWriteFace(file, face, tan[i], (2, 0, 3) , indent + 2)
    xmlWrCl(file, "MeshPart", indent + 1)
 
  xmlWrCl(file, "Mesh", indent)
 
 
# функция, записывающая в отдельный файл информацию о материалах всей сцены
# это даст возможность после экспорта редактировать материалы объектов
# здесь мы сохраняем цвет материала, ambient составляющую - силу света в тени,
# данные о бликовой составляющей материала (цвет и силу блика), а так же
# имена всех назначенных текстур объекту
def xmlWriteMaterals(filename):
  out = open(filename, "wt")
  xmlWrOp(out, "Materials")
  for mat in sceneMaterials:
    print "Export material '" + mat.name + "'"
    xmlWrOp(out, "Material", [("Name", mat.name)], 1)
    xmlWrOp(out, "Color", [("R", round(mat.R, 3)), ("G", round(mat.G, 3)), \
      ("B", round(mat.B, 3)), ("A", round(mat.alpha, 3)), ("Ambient", round(mat.amb, 3))], 2, 1)
    xmlWrOp(out, "Specular", [("R", round(mat.specR, 3)), ("G", round(mat.specG, 3)), \
      ("B", round(mat.specB, 3)), ("Power", round(mat.spec, 3))], 2, 1)
    xmlWrOp(out, "Textures", [], 1)
    for tex in mat.textures:
      if tex:
        image = tex.tex.image
        if image:
          xmlWrOp(out, "Texture", [("Name", image.name)], 2, 1)
    xmlWrCl(out, "Textures", 1)
    xmlWrCl(out, "Material", 1)
  xmlWrCl(out, "Materials")
  out.close()
 
 
# основная функция, сохраняющая общие данные всех поддерживаемых экспортером объектов,
# так же для каждого типа объектов вызывает функции экспорта специфических данных
def xmlWriteObgectData(file, obj, indent = 0):
  print "Export object '" + obj.name + "'"
  # первым делом создаем список атрибутов, и вносим в него имя и тип объекта 
  objAttribs = [("Name", obj.name), ("Type", obj.type)]
 
  if obj.type == "Lamp": # добавляем в коллекцию атрибутов объекта параметры источника света
    objAttribs.append(("LampType", lampTypes[obj.getData().getType()]))
    if (lampTypes[obj.getData().getType()] == "Lamp"):
      objAttribs.append(("Dist", round(obj.getData().getDist(), 5)))
      objAttribs.append(("Energy", round(obj.getData().getEnergy(), 5)))
 
  elif obj.type == "Camera": # добавляем в коллекцию атрибутов объекта параметры камеры
    objAttribs.append(("Lens", round(convertLens(obj.getData().lens), 5)))
    objAttribs.append(("ClipStart", round(obj.getData().clipStart, 5)))
    objAttribs.append(("ClipEnd", round(obj.getData().clipEnd, 5)))
 
  # создаем запись узла дерева сцены со всеми атрибутами
  xmlWrOp(file, "Node", objAttribs, indent)
  # сохраняем трансформации объекта
  xmlWriteTransforms(file, obj, 2)
 
  if obj.type == "Mesh": # если объект – Mesh, экспортируем данные геометрии
    xmlWriteMeshData(file, obj, 2)
 
  elif obj.type == "Lamp": # для источников света сохраняем цвет
    lamp = obj.getData();
    xmlWriteVector3D(file, "Color", ( lamp.G, lamp.B, lamp.R), 2);
 
  else: # для других типов объектов ничего не выполняем
    pass
 
  # сохраняем дополнительные параметры объекта
  xmlWrProperties(file, obj.getAllProperties(), 2)
  # сохраняем кривые анимации объекта
  xmlWriteIpo(file, obj, 2)
 
  # для всех потомков объекта, поддерживаемых экспортером, вызываем эту же функцию сохранения объекта
  for child in Object.Get():
    if (child.type in supportedObjects) and (child.parent == obj):
      xmlWriteObgectData(file, child, indent + 1)
 
  # закрываем тэг записи узла дерева
  xmlWrCl(file, "Node", indent)
 
# Главная функция экспортера, которая получает имя файла из диалога сохранения
# в который будет выполнен экспорт
def write(filename):
  print "Start export..."
 
  objects = []
  # находим все объекты, у которых нет родителя и поддерживаемые экспортером
  for obj in Object.Get():
    if (obj.type in supportedObjects) and (obj.parent == None):
      objects.append(obj)
 
  # открываем файл на запись в режиме текста
  out = open(filename, "wt")
  # записываем корневой элемент документа XML
  xmlWrOp(out, "Root")
  # записываем в файл все объекты, не имеющие родителей
  for obj in objects:
    xmlWriteObgectData(out, obj, 1)
  # закрываем корневой элемент
  xmlWrCl(out, "Root")
  # закрываем файл
  out.close()
 
  # сохраняем в отдельный файл информацию о материалах
  # обратите внимание, здесь как раз используется срез, о котором я говорил ранее
  xmlWriteMaterals(filename[0:filename.rfind(".")] + ".materials.xml")
 
  print "Finished..."
 
# первое что будет выполнено скриптом, это вызов диалога сохранения файла
# если пользователь нажмет кнопку Export, то диалог сохранения вызовет функцию write
# и будет выполнен экспорт
Window.FileSelector(write, "Export", "level.xml")