1923 lines
75 KiB
Python
1923 lines
75 KiB
Python
# ##### BEGIN GPL LICENSE BLOCK #####
|
|
#
|
|
# This program is free software; you can redistribute it and/or
|
|
# modify it under the terms of the GNU General Public License
|
|
# as published by the Free Software Foundation; either version 2
|
|
# of the License, or (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, write to the Free Software Foundation,
|
|
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
#
|
|
# ##### END GPL LICENSE BLOCK #####
|
|
|
|
# <pep8 compliant>
|
|
|
|
# Script copyright (C) Juan Linietsky
|
|
# Contact Info: juan@codenix.com
|
|
|
|
"""
|
|
This script is an exporter to the Khronos Collada file format.
|
|
|
|
http://www.khronos.org/collada/
|
|
"""
|
|
|
|
# TODO:
|
|
# Materials & Textures
|
|
# Optionally export Vertex Colors
|
|
# Morph Targets
|
|
# Control bone removal
|
|
# Copy textures
|
|
# Export Keyframe Optimization
|
|
# --
|
|
# Morph Targets
|
|
# Blender native material? (?)
|
|
|
|
import os
|
|
import time
|
|
import math # math.pi
|
|
import shutil
|
|
import bpy
|
|
import bmesh
|
|
from mathutils import Vector, Matrix
|
|
|
|
# According to collada spec, order matters
|
|
S_ASSET = 0
|
|
S_IMGS = 1
|
|
S_FX = 2
|
|
S_MATS = 3
|
|
S_GEOM = 4
|
|
S_MORPH = 5
|
|
S_SKIN = 6
|
|
S_CONT = 7
|
|
S_CAMS = 8
|
|
S_LAMPS = 9
|
|
S_ANIM_CLIPS = 10
|
|
S_NODES = 11
|
|
S_ANIM = 12
|
|
|
|
CMP_EPSILON = 0.0001
|
|
|
|
|
|
def snap_tup(tup):
|
|
ret = ()
|
|
for x in tup:
|
|
ret += (x - math.fmod(x, 0.0001), )
|
|
|
|
return tup
|
|
|
|
|
|
def strmtx(mtx):
|
|
s = " "
|
|
for x in range(4):
|
|
for y in range(4):
|
|
s += str(mtx[x][y])
|
|
s += " "
|
|
s += " "
|
|
return s
|
|
|
|
|
|
def numarr(a, mult=1.0):
|
|
s = " "
|
|
for x in a:
|
|
s += " " + str(x * mult)
|
|
s += " "
|
|
return s
|
|
|
|
|
|
def numarr_alpha(a, mult=1.0):
|
|
s = " "
|
|
for x in a:
|
|
s += " " + str(x * mult)
|
|
if len(a) == 3:
|
|
s += " 1.0"
|
|
s += " "
|
|
return s
|
|
|
|
|
|
def strarr(arr):
|
|
s = " "
|
|
for x in arr:
|
|
s += " " + str(x)
|
|
s += " "
|
|
return s
|
|
|
|
|
|
class DaeExporter:
|
|
|
|
def validate_id(self, d):
|
|
if (d.find("id-") == 0):
|
|
return "z" + d
|
|
return d
|
|
|
|
def new_id(self, t):
|
|
self.last_id += 1
|
|
return "id-" + t + "-" + str(self.last_id)
|
|
|
|
class Vertex:
|
|
|
|
def close_to(self, v):
|
|
if self.vertex - v.vertex.length() > CMP_EPSILON:
|
|
return False
|
|
if self.normal - v.normal.length() > CMP_EPSILON:
|
|
return False
|
|
if self.uv - v.uv.length() > CMP_EPSILON:
|
|
return False
|
|
if self.uv2 - v.uv2.length() > CMP_EPSILON:
|
|
return False
|
|
|
|
return True
|
|
|
|
def get_tup(self):
|
|
tup = (self.vertex.x, self.vertex.y, self.vertex.z, self.normal.x,
|
|
self.normal.y, self.normal.z)
|
|
for t in self.uv:
|
|
tup = tup + (t.x, t.y)
|
|
if self.color is not None:
|
|
tup = tup + (self.color.x, self.color.y, self.color.z)
|
|
if self.tangent is not None:
|
|
tup = tup + (self.tangent.x, self.tangent.y, self.tangent.z)
|
|
if self.bitangent is not None:
|
|
tup = tup + (self.bitangent.x, self.bitangent.y,
|
|
self.bitangent.z)
|
|
for t in self.bones:
|
|
tup = tup + (float(t), )
|
|
for t in self.weights:
|
|
tup = tup + (float(t), )
|
|
|
|
return tup
|
|
|
|
def __init__(self):
|
|
self.vertex = Vector((0.0, 0.0, 0.0))
|
|
self.normal = Vector((0.0, 0.0, 0.0))
|
|
self.tangent = None
|
|
self.bitangent = None
|
|
self.color = None
|
|
self.uv = []
|
|
self.uv2 = Vector((0.0, 0.0))
|
|
self.bones = []
|
|
self.weights = []
|
|
|
|
def writel(self, section, indent, text):
|
|
if (not (section in self.sections)):
|
|
self.sections[section] = []
|
|
line = ""
|
|
for x in range(indent):
|
|
line += "\t"
|
|
line += text
|
|
self.sections[section].append(line)
|
|
|
|
def export_image(self, image):
|
|
if (image in self.image_cache):
|
|
return self.image_cache[image]
|
|
|
|
imgpath = image.filepath
|
|
if (imgpath.find("//") == 0 or imgpath.find("\\\\") == 0):
|
|
# If relative, convert to absolute
|
|
imgpath = bpy.path.abspath(imgpath)
|
|
|
|
# Path is absolute, now do something!
|
|
|
|
if (self.config["use_copy_images"]):
|
|
# copy image
|
|
basedir = os.path.dirname(self.path) + "/images"
|
|
if (not os.path.isdir(basedir)):
|
|
os.makedirs(basedir)
|
|
|
|
if os.path.isfile(imgpath):
|
|
dstfile = basedir + "/" + os.path.basename(imgpath)
|
|
|
|
if not os.path.isfile(dstfile):
|
|
shutil.copy(imgpath, dstfile)
|
|
imgpath = "images/" + os.path.basename(imgpath)
|
|
else:
|
|
# If file is not found save it as png file in the destination
|
|
# folder
|
|
img_tmp_path = image.filepath
|
|
if img_tmp_path.endswith((".bmp", ".rgb", ".png", ".jpeg",
|
|
".jpg", ".jp2", ".tga", ".cin",
|
|
".dpx", ".exr", ".hdr", ".tif")):
|
|
image.filepath = basedir + "/" + \
|
|
os.path.basename(img_tmp_path)
|
|
else:
|
|
image.filepath = basedir + "/" + image.name + ".png"
|
|
|
|
dstfile = basedir + "/" + os.path.basename(image.filepath)
|
|
|
|
if not os.path.isfile(dstfile):
|
|
image.save()
|
|
imgpath = "images/" + os.path.basename(image.filepath)
|
|
image.filepath = img_tmp_path
|
|
|
|
else:
|
|
# Export relative, always, no one wants absolute paths.
|
|
try:
|
|
# Export unix compatible always
|
|
imgpath = os.path.relpath(
|
|
imgpath, os.path.dirname(self.path)).replace("\\", "/")
|
|
|
|
except:
|
|
# Fails sometimes, not sure why
|
|
pass
|
|
|
|
imgid = self.new_id("image")
|
|
|
|
print("FOR: " + imgpath)
|
|
|
|
# if (not os.path.isfile(imgpath)):
|
|
# print("NOT FILE?")
|
|
# if imgpath.endswith((".bmp", ".rgb", ".png", ".jpeg", ".jpg",
|
|
# ".jp2", ".tga", ".cin", ".dpx", ".exr",
|
|
# ".hdr", ".tif")):
|
|
# imgpath="images/"+os.path.basename(imgpath)
|
|
# else:
|
|
# imgpath="images/"+image.name+".png"
|
|
|
|
self.writel(S_IMGS, 1, '<image id="' + imgid +
|
|
'" name="' + image.name + '">')
|
|
self.writel(S_IMGS, 2, '<init_from>' + imgpath + '</init_from>')
|
|
self.writel(S_IMGS, 1, '</image>')
|
|
self.image_cache[image] = imgid
|
|
return imgid
|
|
|
|
def export_material(self, material, double_sided_hint=True):
|
|
if (material in self.material_cache):
|
|
return self.material_cache[material]
|
|
|
|
fxid = self.new_id("fx")
|
|
self.writel(S_FX, 1, '<effect id="' + fxid + '" name="' +
|
|
material.name + '-fx">')
|
|
self.writel(S_FX, 2, '<profile_COMMON>')
|
|
|
|
# Find and fetch the textures and create sources
|
|
sampler_table = {}
|
|
diffuse_tex = None
|
|
specular_tex = None
|
|
emission_tex = None
|
|
normal_tex = None
|
|
for i in range(len(material.texture_slots)):
|
|
ts = material.texture_slots[i]
|
|
if not ts:
|
|
continue
|
|
if not ts.use:
|
|
continue
|
|
if not ts.texture:
|
|
continue
|
|
if ts.texture.type != "IMAGE":
|
|
continue
|
|
|
|
if ts.texture.image is None:
|
|
continue
|
|
|
|
# Image
|
|
imgid = self.export_image(ts.texture.image)
|
|
|
|
# Surface
|
|
surface_sid = self.new_id("fx_surf")
|
|
self.writel(S_FX, 3, '<newparam sid="' + surface_sid + '">')
|
|
self.writel(S_FX, 4, '<surface type="2D">')
|
|
# This is sooo weird
|
|
self.writel(S_FX, 5, '<init_from>' + imgid + '</init_from>')
|
|
self.writel(S_FX, 5, '<format>A8R8G8B8</format>')
|
|
self.writel(S_FX, 4, '</surface>')
|
|
self.writel(S_FX, 3, '</newparam>')
|
|
# Sampler, collada sure likes it difficult
|
|
sampler_sid = self.new_id("fx_sampler")
|
|
self.writel(S_FX, 3, '<newparam sid="' + sampler_sid + '">')
|
|
self.writel(S_FX, 4, '<sampler2D>')
|
|
self.writel(S_FX, 5, '<source>' + surface_sid + '</source>')
|
|
self.writel(S_FX, 4, '</sampler2D>')
|
|
self.writel(S_FX, 3, '</newparam>')
|
|
sampler_table[i] = sampler_sid
|
|
|
|
if ts.use_map_color_diffuse and diffuse_tex is None:
|
|
diffuse_tex = sampler_sid
|
|
if ts.use_map_color_spec and specular_tex is None:
|
|
specular_tex = sampler_sid
|
|
if ts.use_map_emit and emission_tex is None:
|
|
emission_tex = sampler_sid
|
|
if ts.use_map_normal and normal_tex is None:
|
|
normal_tex = sampler_sid
|
|
|
|
self.writel(S_FX, 3, '<technique sid="common">')
|
|
shtype = "blinn"
|
|
self.writel(S_FX, 4, '<' + shtype + '>')
|
|
# Ambient? from where?
|
|
|
|
self.writel(S_FX, 5, '<emission>')
|
|
if emission_tex is not None:
|
|
self.writel(S_FX, 6, '<texture texture="' + emission_tex +
|
|
'" texcoord="CHANNEL1"/>')
|
|
else:
|
|
self.writel(S_FX, 6, '<color>' +
|
|
numarr_alpha(material.diffuse_color, material.emit) +
|
|
' </color>') # not totally right but good enough
|
|
self.writel(S_FX, 5, '</emission>')
|
|
|
|
self.writel(S_FX, 5, '<ambient>')
|
|
self.writel(S_FX, 6, '<color>' +
|
|
numarr_alpha(self.scene.world.ambient_color,
|
|
material.ambient) + ' </color>')
|
|
self.writel(S_FX, 5, '</ambient>')
|
|
|
|
self.writel(S_FX, 5, '<diffuse>')
|
|
if diffuse_tex is not None:
|
|
self.writel(S_FX, 6, '<texture texture="' + diffuse_tex +
|
|
'" texcoord="CHANNEL1"/>')
|
|
else:
|
|
self.writel(S_FX, 6,
|
|
'<color>' + numarr_alpha(material.diffuse_color,
|
|
material.diffuse_intensity) +
|
|
'</color>')
|
|
self.writel(S_FX, 5, '</diffuse>')
|
|
|
|
self.writel(S_FX, 5, '<specular>')
|
|
if specular_tex is not None:
|
|
self.writel(S_FX, 6, '<texture texture="' + specular_tex +
|
|
'" texcoord="CHANNEL1"/>')
|
|
else:
|
|
self.writel(S_FX, 6, '<color>' + numarr_alpha(
|
|
material.specular_color, material.specular_intensity) +
|
|
'</color>')
|
|
self.writel(S_FX, 5, '</specular>')
|
|
|
|
self.writel(S_FX, 5, '<shininess>')
|
|
self.writel(S_FX, 6, '<float>' + str(material.specular_hardness) +
|
|
'</float>')
|
|
self.writel(S_FX, 5, '</shininess>')
|
|
|
|
self.writel(S_FX, 5, '<reflective>')
|
|
self.writel(S_FX, 6, '<color>' + numarr_alpha(material.mirror_color) +
|
|
'</color>')
|
|
self.writel(S_FX, 5, '</reflective>')
|
|
|
|
if (material.use_transparency):
|
|
self.writel(S_FX, 5, '<transparency>')
|
|
self.writel(S_FX, 6, '<float>' + str(material.alpha) + '</float>')
|
|
self.writel(S_FX, 5, '</transparency>')
|
|
|
|
self.writel(S_FX, 5, '<index_of_refraction>')
|
|
self.writel(S_FX, 6, '<float>' + str(material.specular_ior) +
|
|
'</float>')
|
|
self.writel(S_FX, 5, '</index_of_refraction>')
|
|
|
|
self.writel(S_FX, 4, '</' + shtype + '>')
|
|
|
|
self.writel(S_FX, 4, '<extra>')
|
|
self.writel(S_FX, 5, '<technique profile="FCOLLADA">')
|
|
if (normal_tex):
|
|
self.writel(S_FX, 6, '<bump bumptype="NORMALMAP">')
|
|
self.writel(S_FX, 7, '<texture texture="' + normal_tex +
|
|
'" texcoord="CHANNEL1"/>')
|
|
self.writel(S_FX, 6, '</bump>')
|
|
|
|
self.writel(S_FX, 5, '</technique>')
|
|
self.writel(S_FX, 5, '<technique profile="GOOGLEEARTH">')
|
|
self.writel(S_FX, 6, '<double_sided>' + ["0", "1"][double_sided_hint] +
|
|
"</double_sided>")
|
|
self.writel(S_FX, 5, '</technique>')
|
|
|
|
if (material.use_shadeless):
|
|
self.writel(S_FX, 5, '<technique profile="GODOT">')
|
|
self.writel(S_FX, 6, '<unshaded>1</unshaded>')
|
|
self.writel(S_FX, 5, '</technique>')
|
|
|
|
self.writel(S_FX, 4, '</extra>')
|
|
|
|
self.writel(S_FX, 3, '</technique>')
|
|
self.writel(S_FX, 2, '</profile_COMMON>')
|
|
self.writel(S_FX, 1, '</effect>')
|
|
|
|
# Also export blender material in all it's glory (if set as active)
|
|
|
|
# Material
|
|
matid = self.new_id("material")
|
|
self.writel(S_MATS, 1, '<material id="' + matid + '" name="' +
|
|
material.name + '">')
|
|
self.writel(S_MATS, 2, '<instance_effect url="#' + fxid + '"/>')
|
|
self.writel(S_MATS, 1, '</material>')
|
|
|
|
self.material_cache[material] = matid
|
|
return matid
|
|
|
|
def export_mesh(self, node, armature=None, skeyindex=-1, skel_source=None,
|
|
custom_name=None):
|
|
mesh = node.data
|
|
|
|
if (node.data in self.mesh_cache):
|
|
return self.mesh_cache[mesh]
|
|
|
|
if (skeyindex == -1 and mesh.shape_keys is not None and len(
|
|
mesh.shape_keys.key_blocks)):
|
|
values = []
|
|
morph_targets = []
|
|
md = None
|
|
for k in range(0, len(mesh.shape_keys.key_blocks)):
|
|
shape = node.data.shape_keys.key_blocks[k]
|
|
values += [shape.value] # save value
|
|
shape.value = 0
|
|
|
|
mid = self.new_id("morph")
|
|
|
|
for k in range(0, len(mesh.shape_keys.key_blocks)):
|
|
|
|
shape = node.data.shape_keys.key_blocks[k]
|
|
node.show_only_shape_key = True
|
|
node.active_shape_key_index = k
|
|
shape.value = 1.0
|
|
mesh.update()
|
|
"""
|
|
oldval = shape.value
|
|
shape.value = 1.0
|
|
|
|
"""
|
|
p = node.data
|
|
v = node.to_mesh(bpy.context.scene, True, "RENDER")
|
|
node.data = v
|
|
# self.export_node(node, il, shape.name)
|
|
node.data.update()
|
|
if (armature and k == 0):
|
|
md = self.export_mesh(node, armature, k, mid, shape.name)
|
|
else:
|
|
md = self.export_mesh(node, None, k, None, shape.name)
|
|
|
|
node.data = p
|
|
node.data.update()
|
|
shape.value = 0.0
|
|
morph_targets.append(md)
|
|
|
|
"""
|
|
shape.value = oldval
|
|
"""
|
|
node.show_only_shape_key = False
|
|
node.active_shape_key_index = 0
|
|
|
|
self.writel(S_MORPH, 1, '<controller id="' + mid + '" name="">')
|
|
# if ("skin_id" in morph_targets[0]):
|
|
# self.writel(S_MORPH, 2, '<morph source="#'+morph_targets[0][
|
|
# "skin_id"]+'" method="NORMALIZED">')
|
|
# else:
|
|
self.writel(S_MORPH, 2, '<morph source="#' +
|
|
morph_targets[0]["id"] + '" method="NORMALIZED">')
|
|
|
|
self.writel(S_MORPH, 3, '<source id="' + mid + '-morph-targets">')
|
|
self.writel(S_MORPH, 4, '<IDREF_array id="' + mid +
|
|
'-morph-targets-array" count="' +
|
|
str(len(morph_targets) - 1) + '">')
|
|
marr = ""
|
|
warr = ""
|
|
for i in range(len(morph_targets)):
|
|
if (i == 0):
|
|
continue
|
|
elif (i > 1):
|
|
marr += " "
|
|
|
|
if ("skin_id" in morph_targets[i]):
|
|
marr += morph_targets[i]["skin_id"]
|
|
else:
|
|
marr += morph_targets[i]["id"]
|
|
|
|
warr += " 0"
|
|
|
|
self.writel(S_MORPH, 5, marr)
|
|
self.writel(S_MORPH, 4, '</IDREF_array>')
|
|
self.writel(S_MORPH, 4, '<technique_common>')
|
|
self.writel(S_MORPH, 5, '<accessor source="#' + mid +
|
|
'-morph-targets-array" count="' +
|
|
str(len(morph_targets) - 1) + '" stride="1">')
|
|
self.writel(
|
|
S_MORPH, 6, '<param name="MORPH_TARGET" type="IDREF"/>')
|
|
self.writel(S_MORPH, 5, '</accessor>')
|
|
self.writel(S_MORPH, 4, '</technique_common>')
|
|
self.writel(S_MORPH, 3, '</source>')
|
|
|
|
self.writel(S_MORPH, 3, '<source id="' + mid + '-morph-weights">')
|
|
self.writel(S_MORPH, 4, '<float_array id="' + mid +
|
|
'-morph-weights-array" count="' +
|
|
str(len(morph_targets) - 1) + '" >')
|
|
self.writel(S_MORPH, 5, warr)
|
|
self.writel(S_MORPH, 4, '</float_array>')
|
|
self.writel(S_MORPH, 4, '<technique_common>')
|
|
self.writel(S_MORPH, 5, '<accessor source="#' + mid +
|
|
'-morph-weights-array" count="' +
|
|
str(len(morph_targets) - 1) + '" stride="1">')
|
|
self.writel(
|
|
S_MORPH, 6, '<param name="MORPH_WEIGHT" type="float"/>')
|
|
self.writel(S_MORPH, 5, '</accessor>')
|
|
self.writel(S_MORPH, 4, '</technique_common>')
|
|
self.writel(S_MORPH, 3, '</source>')
|
|
|
|
self.writel(S_MORPH, 3, '<targets>')
|
|
self.writel(
|
|
S_MORPH, 4, '<input semantic="MORPH_TARGET" source="#' + mid +
|
|
'-morph-targets"/>')
|
|
self.writel(
|
|
S_MORPH, 4, '<input semantic="MORPH_WEIGHT" source="#' + mid +
|
|
'-morph-weights"/>')
|
|
self.writel(S_MORPH, 3, '</targets>')
|
|
self.writel(S_MORPH, 2, '</morph>')
|
|
self.writel(S_MORPH, 1, '</controller>')
|
|
if armature is not None:
|
|
|
|
self.armature_for_morph[node] = armature
|
|
|
|
meshdata = {}
|
|
if (armature):
|
|
meshdata = morph_targets[0]
|
|
meshdata["morph_id"] = mid
|
|
else:
|
|
meshdata["id"] = morph_targets[0]["id"]
|
|
meshdata["morph_id"] = mid
|
|
meshdata["material_assign"] = morph_targets[
|
|
0]["material_assign"]
|
|
|
|
self.mesh_cache[node.data] = meshdata
|
|
return meshdata
|
|
|
|
apply_modifiers = len(node.modifiers) and self.config[
|
|
"use_mesh_modifiers"]
|
|
|
|
name_to_use = mesh.name
|
|
# print("name to use: "+mesh.name)
|
|
if (custom_name is not None and custom_name != ""):
|
|
name_to_use = custom_name
|
|
|
|
mesh = node.to_mesh(self.scene, apply_modifiers,
|
|
"RENDER") # is this allright?
|
|
|
|
triangulate = self.config["use_triangles"]
|
|
if (triangulate):
|
|
bm = bmesh.new()
|
|
bm.from_mesh(mesh)
|
|
bmesh.ops.triangulate(bm, faces=bm.faces)
|
|
bm.to_mesh(mesh)
|
|
bm.free()
|
|
|
|
mesh.update(calc_tessface=True)
|
|
vertices = []
|
|
vertex_map = {}
|
|
surface_indices = {}
|
|
materials = {}
|
|
|
|
materials = {}
|
|
|
|
si = None
|
|
if armature is not None:
|
|
si = self.skeleton_info[armature]
|
|
|
|
has_uv = False
|
|
has_uv2 = False
|
|
has_weights = armature is not None
|
|
has_tangents = self.config["use_tangent_arrays"] # could detect..
|
|
has_colors = len(mesh.vertex_colors)
|
|
mat_assign = []
|
|
|
|
uv_layer_count = len(mesh.uv_textures)
|
|
if has_tangents and len(mesh.uv_textures):
|
|
try:
|
|
mesh.calc_tangents()
|
|
except:
|
|
self.operator.report(
|
|
{'WARNING'}, 'CalcTangets failed for mesh "' + mesh.name +
|
|
'", no tangets will be exported.')
|
|
# uv_layer_count=0
|
|
mesh.calc_normals_split()
|
|
has_tangents = False
|
|
|
|
else:
|
|
mesh.calc_normals_split()
|
|
has_tangents = False
|
|
|
|
for fi in range(len(mesh.polygons)):
|
|
f = mesh.polygons[fi]
|
|
|
|
if not (f.material_index in surface_indices):
|
|
surface_indices[f.material_index] = []
|
|
# print("Type: " + str(type(f.material_index)))
|
|
# print("IDX: " + str(f.material_index) + "/" + str(
|
|
# len(mesh.materials)))
|
|
|
|
try:
|
|
# Bizarre blender behavior i don't understand,
|
|
# so catching exception
|
|
mat = mesh.materials[f.material_index]
|
|
except:
|
|
mat = None
|
|
|
|
if (mat is not None):
|
|
materials[f.material_index] = self.export_material(
|
|
mat, mesh.show_double_sided)
|
|
else:
|
|
# weird, has no material?
|
|
materials[f.material_index] = None
|
|
|
|
indices = surface_indices[f.material_index]
|
|
vi = []
|
|
# Vertices always 3
|
|
"""
|
|
if (len(f.vertices)==3):
|
|
vi.append(0)
|
|
vi.append(1)
|
|
vi.append(2)
|
|
elif (len(f.vertices)==4):
|
|
#todo, should use shortest path
|
|
vi.append(0)
|
|
vi.append(1)
|
|
vi.append(2)
|
|
vi.append(0)
|
|
vi.append(2)
|
|
vi.append(3)
|
|
"""
|
|
|
|
for lt in range(f.loop_total):
|
|
loop_index = f.loop_start + lt
|
|
ml = mesh.loops[loop_index]
|
|
mv = mesh.vertices[ml.vertex_index]
|
|
|
|
v = self.Vertex()
|
|
v.vertex = Vector(mv.co)
|
|
|
|
for xt in mesh.uv_layers:
|
|
v.uv.append(Vector(xt.data[loop_index].uv))
|
|
|
|
if (has_colors):
|
|
v.color = Vector(
|
|
mesh.vertex_colors[0].data[loop_index].color)
|
|
|
|
v.normal = Vector(ml.normal)
|
|
|
|
if (has_tangents):
|
|
v.tangent = Vector(ml.tangent)
|
|
v.bitangent = Vector(ml.bitangent)
|
|
|
|
# if (armature):
|
|
# v.vertex = node.matrix_world * v.vertex
|
|
|
|
# v.color=Vertex(mv. ???
|
|
|
|
if armature is not None:
|
|
wsum = 0.0
|
|
zero_bones = []
|
|
|
|
for vg in mv.groups:
|
|
if vg.group >= len(node.vertex_groups):
|
|
continue
|
|
name = node.vertex_groups[vg.group].name
|
|
|
|
if (name in si["bone_index"]):
|
|
# could still put the weight as 0.0001 maybe
|
|
# blender has a lot of zero weight stuff
|
|
if (vg.weight > 0.001):
|
|
v.bones.append(si["bone_index"][name])
|
|
v.weights.append(vg.weight)
|
|
wsum += vg.weight
|
|
if (wsum == 0.0):
|
|
if not self.wrongvtx_report:
|
|
self.operator.report(
|
|
{'WARNING'}, 'Mesh for object "' + node.name +
|
|
'" has unassigned weights. '
|
|
'This may look wrong in exported model.')
|
|
self.wrongvtx_report = True
|
|
|
|
# blender can have bones assigned that weight zero
|
|
# so they remain local
|
|
# this is the best it can be done?
|
|
v.bones.append(0)
|
|
v.weights.append(1)
|
|
|
|
tup = v.get_tup()
|
|
idx = 0
|
|
# do not optmize if using shapekeys
|
|
if (skeyindex == -1 and tup in vertex_map):
|
|
idx = vertex_map[tup]
|
|
else:
|
|
idx = len(vertices)
|
|
vertices.append(v)
|
|
vertex_map[tup] = idx
|
|
|
|
vi.append(idx)
|
|
|
|
if (len(vi) > 2):
|
|
# only triangles and above
|
|
indices.append(vi)
|
|
|
|
meshid = self.new_id("mesh")
|
|
self.writel(S_GEOM, 1, '<geometry id="' + meshid +
|
|
'" name="' + name_to_use + '">')
|
|
|
|
self.writel(S_GEOM, 2, '<mesh>')
|
|
|
|
# Vertex Array
|
|
self.writel(S_GEOM, 3, '<source id="' + meshid + '-positions">')
|
|
float_values = ""
|
|
for v in vertices:
|
|
float_values += " " + str(v.vertex.x) + " " + \
|
|
str(v.vertex.y) + " " + str(v.vertex.z)
|
|
self.writel(S_GEOM, 4, '<float_array id="' + meshid +
|
|
'-positions-array" count="' +
|
|
str(len(vertices) * 3) + '">' + float_values +
|
|
'</float_array>')
|
|
self.writel(S_GEOM, 4, '<technique_common>')
|
|
self.writel(S_GEOM, 4, '<accessor source="#' + meshid +
|
|
'-positions-array" count="' + str(len(vertices)) +
|
|
'" stride="3">')
|
|
self.writel(S_GEOM, 5, '<param name="X" type="float"/>')
|
|
self.writel(S_GEOM, 5, '<param name="Y" type="float"/>')
|
|
self.writel(S_GEOM, 5, '<param name="Z" type="float"/>')
|
|
self.writel(S_GEOM, 4, '</accessor>')
|
|
self.writel(S_GEOM, 4, '</technique_common>')
|
|
self.writel(S_GEOM, 3, '</source>')
|
|
|
|
# Normal Array
|
|
|
|
self.writel(S_GEOM, 3, '<source id="' + meshid + '-normals">')
|
|
float_values = ""
|
|
for v in vertices:
|
|
float_values += " " + str(v.normal.x) + " " + \
|
|
str(v.normal.y) + " " + str(v.normal.z)
|
|
self.writel(S_GEOM, 4, '<float_array id="' + meshid +
|
|
'-normals-array" count="' +
|
|
str(len(vertices) * 3) + '">' + float_values +
|
|
'</float_array>')
|
|
self.writel(S_GEOM, 4, '<technique_common>')
|
|
self.writel(S_GEOM, 4, '<accessor source="#' + meshid +
|
|
'-normals-array" count="' + str(len(vertices)) +
|
|
'" stride="3">')
|
|
self.writel(S_GEOM, 5, '<param name="X" type="float"/>')
|
|
self.writel(S_GEOM, 5, '<param name="Y" type="float"/>')
|
|
self.writel(S_GEOM, 5, '<param name="Z" type="float"/>')
|
|
self.writel(S_GEOM, 4, '</accessor>')
|
|
self.writel(S_GEOM, 4, '</technique_common>')
|
|
self.writel(S_GEOM, 3, '</source>')
|
|
|
|
if (has_tangents):
|
|
self.writel(S_GEOM, 3, '<source id="' + meshid + '-tangents">')
|
|
float_values = ""
|
|
for v in vertices:
|
|
float_values += " " + \
|
|
str(v.tangent.x) + " " + \
|
|
str(v.tangent.y) + " " + str(v.tangent.z)
|
|
self.writel(S_GEOM, 4, '<float_array id="' + meshid +
|
|
'-tangents-array" count="' +
|
|
str(len(vertices) * 3) + '">' + float_values +
|
|
'</float_array>')
|
|
self.writel(S_GEOM, 4, '<technique_common>')
|
|
self.writel(S_GEOM, 4, '<accessor source="#' + meshid +
|
|
'-tangents-array" count="' + str(len(vertices)) +
|
|
'" stride="3">')
|
|
self.writel(S_GEOM, 5, '<param name="X" type="float"/>')
|
|
self.writel(S_GEOM, 5, '<param name="Y" type="float"/>')
|
|
self.writel(S_GEOM, 5, '<param name="Z" type="float"/>')
|
|
self.writel(S_GEOM, 4, '</accessor>')
|
|
self.writel(S_GEOM, 4, '</technique_common>')
|
|
self.writel(S_GEOM, 3, '</source>')
|
|
|
|
self.writel(S_GEOM, 3, '<source id="' + meshid + '-bitangents">')
|
|
float_values = ""
|
|
for v in vertices:
|
|
float_values += " " + \
|
|
str(v.bitangent.x) + " " + \
|
|
str(v.bitangent.y) + " " + str(v.bitangent.z)
|
|
self.writel(S_GEOM, 4, '<float_array id="' + meshid +
|
|
'-bitangents-array" count="' +
|
|
str(len(vertices) * 3) + '">' + float_values +
|
|
'</float_array>')
|
|
self.writel(S_GEOM, 4, '<technique_common>')
|
|
self.writel(S_GEOM, 4, '<accessor source="#' + meshid +
|
|
'-bitangents-array" count="' + str(len(vertices)) +
|
|
'" stride="3">')
|
|
self.writel(S_GEOM, 5, '<param name="X" type="float"/>')
|
|
self.writel(S_GEOM, 5, '<param name="Y" type="float"/>')
|
|
self.writel(S_GEOM, 5, '<param name="Z" type="float"/>')
|
|
self.writel(S_GEOM, 4, '</accessor>')
|
|
self.writel(S_GEOM, 4, '</technique_common>')
|
|
self.writel(S_GEOM, 3, '</source>')
|
|
|
|
# UV Arrays
|
|
|
|
for uvi in range(uv_layer_count):
|
|
|
|
self.writel(S_GEOM, 3, '<source id="' + meshid +
|
|
'-texcoord-' + str(uvi) + '">')
|
|
float_values = ""
|
|
for v in vertices:
|
|
try:
|
|
float_values += " " + \
|
|
str(v.uv[uvi].x) + " " + str(v.uv[uvi].y)
|
|
except:
|
|
# I don't understand this weird multi-uv-layer API, but
|
|
# with this it seems to works
|
|
float_values += " 0 0 "
|
|
|
|
self.writel(S_GEOM, 4, '<float_array id="' + meshid +
|
|
'-texcoord-' + str(uvi) +
|
|
'-array" count="' + str(len(vertices) * 2) + '">' +
|
|
float_values + '</float_array>')
|
|
self.writel(S_GEOM, 4, '<technique_common>')
|
|
self.writel(S_GEOM, 4, '<accessor source="#' + meshid +
|
|
'-texcoord-' +
|
|
str(uvi) + '-array" count="' + str(len(vertices)) +
|
|
'" stride="2">')
|
|
self.writel(S_GEOM, 5, '<param name="S" type="float"/>')
|
|
self.writel(S_GEOM, 5, '<param name="T" type="float"/>')
|
|
self.writel(S_GEOM, 4, '</accessor>')
|
|
self.writel(S_GEOM, 4, '</technique_common>')
|
|
self.writel(S_GEOM, 3, '</source>')
|
|
|
|
# Color Arrays
|
|
|
|
if (has_colors):
|
|
self.writel(S_GEOM, 3, '<source id="' + meshid + '-colors">')
|
|
float_values = ""
|
|
for v in vertices:
|
|
float_values += " " + \
|
|
str(v.color.x) + " " + \
|
|
str(v.color.y) + " " + str(v.color.z)
|
|
self.writel(S_GEOM, 4, '<float_array id="' + meshid +
|
|
'-colors-array" count="' +
|
|
str(len(vertices) * 3) + '">' + float_values +
|
|
'</float_array>')
|
|
self.writel(S_GEOM, 4, '<technique_common>')
|
|
self.writel(S_GEOM, 4, '<accessor source="#' + meshid +
|
|
'-colors-array" count="' + str(len(vertices)) +
|
|
'" stride="3">')
|
|
self.writel(S_GEOM, 5, '<param name="X" type="float"/>')
|
|
self.writel(S_GEOM, 5, '<param name="Y" type="float"/>')
|
|
self.writel(S_GEOM, 5, '<param name="Z" type="float"/>')
|
|
self.writel(S_GEOM, 4, '</accessor>')
|
|
self.writel(S_GEOM, 4, '</technique_common>')
|
|
self.writel(S_GEOM, 3, '</source>')
|
|
|
|
# Triangle Lists
|
|
self.writel(S_GEOM, 3, '<vertices id="' + meshid + '-vertices">')
|
|
self.writel(
|
|
S_GEOM, 4, '<input semantic="POSITION" source="#' + meshid +
|
|
'-positions"/>')
|
|
self.writel(S_GEOM, 3, '</vertices>')
|
|
|
|
prim_type = ""
|
|
if (triangulate):
|
|
prim_type = "triangles"
|
|
else:
|
|
prim_type = "polygons"
|
|
|
|
for m in surface_indices:
|
|
indices = surface_indices[m]
|
|
mat = materials[m]
|
|
|
|
if (mat is not None):
|
|
matref = self.new_id("trimat")
|
|
self.writel(S_GEOM, 3, '<' + prim_type + ' count="' + str(
|
|
int(len(indices))) + '" material="' + matref +
|
|
'">') # todo material
|
|
mat_assign.append((mat, matref))
|
|
else:
|
|
self.writel(S_GEOM, 3, '<' + prim_type + ' count="' +
|
|
str(int(len(indices))) + '">') # todo material
|
|
|
|
self.writel(S_GEOM, 4, '<input semantic="VERTEX" source="#' +
|
|
meshid + '-vertices" offset="0"/>')
|
|
self.writel(S_GEOM, 4, '<input semantic="NORMAL" source="#' +
|
|
meshid + '-normals" offset="0"/>')
|
|
|
|
for uvi in range(uv_layer_count):
|
|
self.writel(S_GEOM, 4, '<input semantic="TEXCOORD" source="#' +
|
|
meshid +
|
|
'-texcoord-' + str(uvi) + '" offset="0" set="' +
|
|
str(uvi) + '"/>')
|
|
|
|
if (has_colors):
|
|
self.writel(S_GEOM, 4, '<input semantic="COLOR" source="#' +
|
|
meshid + '-colors" offset="0"/>')
|
|
if (has_tangents):
|
|
self.writel(S_GEOM, 4,
|
|
'<input semantic="TEXTANGENT" source="#' +
|
|
meshid + '-tangents" offset="0"/>')
|
|
self.writel(S_GEOM, 4,
|
|
'<input semantic="TEXBINORMAL" source="#' +
|
|
meshid + '-bitangents" offset="0"/>')
|
|
|
|
if (triangulate):
|
|
int_values = "<p>"
|
|
for p in indices:
|
|
for i in p:
|
|
int_values += " " + str(i)
|
|
int_values += " </p>"
|
|
self.writel(S_GEOM, 4, int_values)
|
|
else:
|
|
for p in indices:
|
|
int_values = "<p>"
|
|
for i in p:
|
|
int_values += " " + str(i)
|
|
int_values += " </p>"
|
|
self.writel(S_GEOM, 4, int_values)
|
|
|
|
self.writel(S_GEOM, 3, '</' + prim_type + '>')
|
|
|
|
self.writel(S_GEOM, 2, '</mesh>')
|
|
self.writel(S_GEOM, 1, '</geometry>')
|
|
|
|
meshdata = {}
|
|
meshdata["id"] = meshid
|
|
meshdata["material_assign"] = mat_assign
|
|
if (skeyindex == -1):
|
|
self.mesh_cache[node.data] = meshdata
|
|
|
|
# Export armature data (if armature exists)
|
|
|
|
if (armature is not None and (
|
|
skel_source is not None or skeyindex == -1)):
|
|
|
|
contid = self.new_id("controller")
|
|
|
|
self.writel(S_SKIN, 1, '<controller id="' + contid + '">')
|
|
if (skel_source is not None):
|
|
self.writel(S_SKIN, 2, '<skin source="#' + skel_source + '">')
|
|
else:
|
|
self.writel(S_SKIN, 2, '<skin source="#' + meshid + '">')
|
|
|
|
self.writel(S_SKIN, 3, '<bind_shape_matrix>' +
|
|
strmtx(node.matrix_world) + '</bind_shape_matrix>')
|
|
# Joint Names
|
|
self.writel(S_SKIN, 3, '<source id="' + contid + '-joints">')
|
|
name_values = ""
|
|
for v in si["bone_names"]:
|
|
name_values += " " + v
|
|
|
|
self.writel(S_SKIN, 4, '<Name_array id="' + contid +
|
|
'-joints-array" count="' +
|
|
str(len(si["bone_names"])) + '">' + name_values +
|
|
'</Name_array>')
|
|
self.writel(S_SKIN, 4, '<technique_common>')
|
|
self.writel(S_SKIN, 4, '<accessor source="#' + contid +
|
|
'-joints-array" count="' + str(len(si["bone_names"])) +
|
|
'" stride="1">')
|
|
self.writel(S_SKIN, 5, '<param name="JOINT" type="Name"/>')
|
|
self.writel(S_SKIN, 4, '</accessor>')
|
|
self.writel(S_SKIN, 4, '</technique_common>')
|
|
self.writel(S_SKIN, 3, '</source>')
|
|
# Pose Matrices!
|
|
self.writel(S_SKIN, 3, '<source id="' + contid + '-bind_poses">')
|
|
pose_values = ""
|
|
for v in si["bone_bind_poses"]:
|
|
pose_values += " " + strmtx(v)
|
|
|
|
self.writel(S_SKIN, 4, '<float_array id="' + contid +
|
|
'-bind_poses-array" count="' +
|
|
str(len(si["bone_bind_poses"]) * 16) + '">' +
|
|
pose_values + '</float_array>')
|
|
self.writel(S_SKIN, 4, '<technique_common>')
|
|
self.writel(S_SKIN, 4, '<accessor source="#' + contid +
|
|
'-bind_poses-array" count="' +
|
|
str(len(si["bone_bind_poses"])) + '" stride="16">')
|
|
self.writel(S_SKIN, 5, '<param name="TRANSFORM" type="float4x4"/>')
|
|
self.writel(S_SKIN, 4, '</accessor>')
|
|
self.writel(S_SKIN, 4, '</technique_common>')
|
|
self.writel(S_SKIN, 3, '</source>')
|
|
# Skin Weights!
|
|
self.writel(S_SKIN, 3, '<source id="' + contid + '-skin_weights">')
|
|
skin_weights = ""
|
|
skin_weights_total = 0
|
|
for v in vertices:
|
|
skin_weights_total += len(v.weights)
|
|
for w in v.weights:
|
|
skin_weights += " " + str(w)
|
|
|
|
self.writel(S_SKIN, 4, '<float_array id="' + contid +
|
|
'-skin_weights-array" count="' +
|
|
str(skin_weights_total) + '">' + skin_weights +
|
|
'</float_array>')
|
|
self.writel(S_SKIN, 4, '<technique_common>')
|
|
self.writel(S_SKIN, 4, '<accessor source="#' + contid +
|
|
'-skin_weights-array" count="' +
|
|
str(skin_weights_total) + '" stride="1">')
|
|
self.writel(S_SKIN, 5, '<param name="WEIGHT" type="float"/>')
|
|
self.writel(S_SKIN, 4, '</accessor>')
|
|
self.writel(S_SKIN, 4, '</technique_common>')
|
|
self.writel(S_SKIN, 3, '</source>')
|
|
|
|
self.writel(S_SKIN, 3, '<joints>')
|
|
self.writel(
|
|
S_SKIN, 4, '<input semantic="JOINT" source="#' + contid +
|
|
'-joints"/>')
|
|
self.writel(
|
|
S_SKIN, 4, '<input semantic="INV_BIND_MATRIX" source="#' +
|
|
contid + '-bind_poses"/>')
|
|
self.writel(S_SKIN, 3, '</joints>')
|
|
self.writel(S_SKIN, 3, '<vertex_weights count="' +
|
|
str(len(vertices)) + '">')
|
|
self.writel(S_SKIN, 4, '<input semantic="JOINT" source="#' +
|
|
contid + '-joints" offset="0"/>')
|
|
self.writel(S_SKIN, 4, '<input semantic="WEIGHT" source="#' +
|
|
contid + '-skin_weights" offset="1"/>')
|
|
vcounts = ""
|
|
vs = ""
|
|
vcount = 0
|
|
for v in vertices:
|
|
vcounts += " " + str(len(v.weights))
|
|
for b in v.bones:
|
|
vs += " " + str(b)
|
|
vs += " " + str(vcount)
|
|
vcount += 1
|
|
self.writel(S_SKIN, 4, '<vcount>' + vcounts + '</vcount>')
|
|
self.writel(S_SKIN, 4, '<v>' + vs + '</v>')
|
|
self.writel(S_SKIN, 3, '</vertex_weights>')
|
|
|
|
self.writel(S_SKIN, 2, '</skin>')
|
|
self.writel(S_SKIN, 1, '</controller>')
|
|
meshdata["skin_id"] = contid
|
|
|
|
return meshdata
|
|
|
|
def export_mesh_node(self, node, il):
|
|
if (node.data is None):
|
|
return
|
|
|
|
armature = None
|
|
armcount = 0
|
|
for n in node.modifiers:
|
|
if (n.type == "ARMATURE"):
|
|
armcount += 1
|
|
|
|
if (node.parent is not None):
|
|
if (node.parent.type == "ARMATURE"):
|
|
armature = node.parent
|
|
if (armcount > 1):
|
|
self.operator.report({'WARNING'}, 'Object "' + node.name +
|
|
'" refers to more than one armature! '
|
|
'This is unsupported.')
|
|
if (armcount == 0):
|
|
self.operator.report({'WARNING'}, 'Object "' + node.name +
|
|
'" is child of an armature, but has '
|
|
'no armature modifier.')
|
|
|
|
if (armcount > 0 and not armature):
|
|
self.operator.report({'WARNING'}, 'Object "' + node.name +
|
|
'" has armature modifier, but is not a child '
|
|
'of an armature. This is unsupported.')
|
|
|
|
if (node.data.shape_keys is not None):
|
|
sk = node.data.shape_keys
|
|
if (sk.animation_data):
|
|
# print("HAS ANIM")
|
|
# print("DRIVERS: "+str(len(sk.animation_data.drivers)))
|
|
for d in sk.animation_data.drivers:
|
|
if (d.driver):
|
|
for v in d.driver.variables:
|
|
for t in v.targets:
|
|
if (t.id is not None and
|
|
t.id.name in self.scene.objects):
|
|
# print("LINKING " + str(node) + " WITH " +
|
|
# str(t.id.name))
|
|
self.armature_for_morph[
|
|
node] = self.scene.objects[t.id.name]
|
|
|
|
meshdata = self.export_mesh(node, armature)
|
|
close_controller = False
|
|
|
|
if ("skin_id" in meshdata):
|
|
close_controller = True
|
|
self.writel(S_NODES, il, '<instance_controller url="#' +
|
|
meshdata["skin_id"] + '">')
|
|
for sn in self.skeleton_info[armature]["skeleton_nodes"]:
|
|
self.writel(S_NODES, il + 1, '<skeleton>#' +
|
|
sn + '</skeleton>')
|
|
elif ("morph_id" in meshdata):
|
|
self.writel(S_NODES, il, '<instance_controller url="#' +
|
|
meshdata["morph_id"] + '">')
|
|
close_controller = True
|
|
elif (armature is None):
|
|
self.writel(S_NODES, il, '<instance_geometry url="#' +
|
|
meshdata["id"] + '">')
|
|
|
|
if (len(meshdata["material_assign"]) > 0):
|
|
|
|
self.writel(S_NODES, il + 1, '<bind_material>')
|
|
self.writel(S_NODES, il + 2, '<technique_common>')
|
|
for m in meshdata["material_assign"]:
|
|
self.writel(S_NODES, il + 3, '<instance_material symbol="' +
|
|
m[1] + '" target="#' + m[0] + '"/>')
|
|
|
|
self.writel(S_NODES, il + 2, '</technique_common>')
|
|
self.writel(S_NODES, il + 1, '</bind_material>')
|
|
|
|
if (close_controller):
|
|
self.writel(S_NODES, il, '</instance_controller>')
|
|
else:
|
|
self.writel(S_NODES, il, '</instance_geometry>')
|
|
|
|
def export_armature_bone(self, bone, il, si):
|
|
boneid = self.new_id("bone")
|
|
boneidx = si["bone_count"]
|
|
si["bone_count"] += 1
|
|
bonesid = si["id"] + "-" + str(boneidx)
|
|
if (bone.name in self.used_bones):
|
|
if (self.config["use_anim_action_all"]):
|
|
self.operator.report({'WARNING'}, 'Bone name "' + bone.name +
|
|
'" used in more than one skeleton. '
|
|
'Actions might export wrong.')
|
|
else:
|
|
self.used_bones.append(bone.name)
|
|
|
|
si["bone_index"][bone.name] = boneidx
|
|
si["bone_ids"][bone] = boneid
|
|
si["bone_names"].append(bonesid)
|
|
self.writel(S_NODES, il, '<node id="' + boneid + '" sid="' +
|
|
bonesid + '" name="' + bone.name + '" type="JOINT">')
|
|
il += 1
|
|
xform = bone.matrix_local
|
|
si["bone_bind_poses"].append((si["armature_xform"] * xform).inverted())
|
|
|
|
if (bone.parent is not None):
|
|
xform = bone.parent.matrix_local.inverted() * xform
|
|
else:
|
|
si["skeleton_nodes"].append(boneid)
|
|
|
|
self.writel(S_NODES, il, '<matrix sid="transform">' +
|
|
strmtx(xform) + '</matrix>')
|
|
for c in bone.children:
|
|
self.export_armature_bone(c, il, si)
|
|
il -= 1
|
|
self.writel(S_NODES, il, '</node>')
|
|
|
|
def export_armature_node(self, node, il):
|
|
if (node.data is None):
|
|
return
|
|
|
|
self.skeletons.append(node)
|
|
|
|
armature = node.data
|
|
self.skeleton_info[node] = {
|
|
"bone_count": 0,
|
|
"id": self.new_id("skelbones"),
|
|
"name": node.name, "bone_index": {},
|
|
"bone_ids": {}, "bone_names": [], "bone_bind_poses": [],
|
|
"skeleton_nodes": [],
|
|
"armature_xform": node.matrix_world}
|
|
|
|
for b in armature.bones:
|
|
if (b.parent is not None):
|
|
continue
|
|
self.export_armature_bone(b, il, self.skeleton_info[node])
|
|
|
|
if (node.pose):
|
|
for b in node.pose.bones:
|
|
for x in b.constraints:
|
|
if (x.type == 'ACTION'):
|
|
self.action_constraints.append(x.action)
|
|
|
|
def export_camera_node(self, node, il):
|
|
if (node.data is None):
|
|
return
|
|
|
|
camera = node.data
|
|
camid = self.new_id("camera")
|
|
self.writel(S_CAMS, 1, '<camera id="' + camid +
|
|
'" name="' + camera.name + '">')
|
|
self.writel(S_CAMS, 2, '<optics>')
|
|
self.writel(S_CAMS, 3, '<technique_common>')
|
|
if (camera.type == "PERSP"):
|
|
self.writel(S_CAMS, 4, '<perspective>')
|
|
self.writel(S_CAMS, 5, '<yfov> ' +
|
|
# I think?
|
|
str(math.degrees(camera.angle)) + ' </yfov>')
|
|
self.writel(S_CAMS, 5, '<aspect_ratio> ' +
|
|
str(self.scene.render.resolution_x /
|
|
self.scene.render.resolution_y) +
|
|
' </aspect_ratio>')
|
|
self.writel(S_CAMS, 5, '<znear> ' +
|
|
str(camera.clip_start) + ' </znear>')
|
|
self.writel(S_CAMS, 5, '<zfar> ' +
|
|
str(camera.clip_end) + ' </zfar>')
|
|
self.writel(S_CAMS, 4, '</perspective>')
|
|
else:
|
|
self.writel(S_CAMS, 4, '<orthographic>')
|
|
self.writel(S_CAMS, 5, '<xmag> ' +
|
|
str(camera.ortho_scale * 0.5) + ' </xmag>') # I think?
|
|
self.writel(S_CAMS, 5, '<aspect_ratio> ' + str(
|
|
self.scene.render.resolution_x /
|
|
self.scene.render.resolution_y) + ' </aspect_ratio>')
|
|
self.writel(S_CAMS, 5, '<znear> ' +
|
|
str(camera.clip_start) + ' </znear>')
|
|
self.writel(S_CAMS, 5, '<zfar> ' +
|
|
str(camera.clip_end) + ' </zfar>')
|
|
self.writel(S_CAMS, 4, '</orthographic>')
|
|
|
|
self.writel(S_CAMS, 3, '</technique_common>')
|
|
self.writel(S_CAMS, 2, '</optics>')
|
|
self.writel(S_CAMS, 1, '</camera>')
|
|
|
|
self.writel(S_NODES, il, '<instance_camera url="#' + camid + '"/>')
|
|
|
|
def export_lamp_node(self, node, il):
|
|
if (node.data is None):
|
|
return
|
|
|
|
light = node.data
|
|
lightid = self.new_id("light")
|
|
self.writel(S_LAMPS, 1, '<light id="' + lightid +
|
|
'" name="' + light.name + '">')
|
|
# self.writel(S_LAMPS, 2, '<optics>')
|
|
self.writel(S_LAMPS, 3, '<technique_common>')
|
|
|
|
if (light.type == "POINT"):
|
|
self.writel(S_LAMPS, 4, '<point>')
|
|
self.writel(S_LAMPS, 5, '<color>' +
|
|
strarr(light.color) + '</color>')
|
|
# convert to linear attenuation
|
|
att_by_distance = 2.0 / light.distance
|
|
self.writel(S_LAMPS, 5, '<linear_attenuation>' +
|
|
str(att_by_distance) + '</linear_attenuation>')
|
|
if (light.use_sphere):
|
|
self.writel(S_LAMPS, 5, '<zfar>' +
|
|
str(light.distance) + '</zfar>')
|
|
|
|
self.writel(S_LAMPS, 4, '</point>')
|
|
elif (light.type == "SPOT"):
|
|
self.writel(S_LAMPS, 4, '<spot>')
|
|
self.writel(S_LAMPS, 5, '<color>' +
|
|
strarr(light.color) + '</color>')
|
|
# convert to linear attenuation
|
|
att_by_distance = 2.0 / light.distance
|
|
self.writel(S_LAMPS, 5, '<linear_attenuation>' +
|
|
str(att_by_distance) + '</linear_attenuation>')
|
|
self.writel(S_LAMPS, 5, '<falloff_angle>' +
|
|
str(math.degrees(light.spot_size / 2)) +
|
|
'</falloff_angle>')
|
|
self.writel(S_LAMPS, 4, '</spot>')
|
|
|
|
else: # write a sun lamp for everything else (not supported)
|
|
self.writel(S_LAMPS, 4, '<directional>')
|
|
self.writel(S_LAMPS, 5, '<color>' +
|
|
strarr(light.color) + '</color>')
|
|
self.writel(S_LAMPS, 4, '</directional>')
|
|
|
|
self.writel(S_LAMPS, 3, '</technique_common>')
|
|
# self.writel(S_LAMPS, 2, '</optics>')
|
|
self.writel(S_LAMPS, 1, '</light>')
|
|
|
|
self.writel(S_NODES, il, '<instance_light url="#' + lightid + '"/>')
|
|
|
|
def export_empty_node(self, node, il):
|
|
self.writel(S_NODES, 4, '<extra>')
|
|
self.writel(S_NODES, 5, '<technique profile="GODOT">')
|
|
self.writel(S_NODES, 6, '<empty_draw_type>' +
|
|
node.empty_draw_type + '</empty_draw_type>')
|
|
self.writel(S_NODES, 5, '</technique>')
|
|
self.writel(S_NODES, 4, '</extra>')
|
|
|
|
def export_curve(self, curve):
|
|
splineid = self.new_id("spline")
|
|
|
|
self.writel(S_GEOM, 1, '<geometry id="' +
|
|
splineid + '" name="' + curve.name + '">')
|
|
self.writel(S_GEOM, 2, '<spline closed="0">')
|
|
|
|
points = []
|
|
interps = []
|
|
handles_in = []
|
|
handles_out = []
|
|
tilts = []
|
|
|
|
for cs in curve.splines:
|
|
|
|
if (cs.type == "BEZIER"):
|
|
for s in cs.bezier_points:
|
|
points.append(s.co[0])
|
|
points.append(s.co[1])
|
|
points.append(s.co[2])
|
|
|
|
handles_in.append(s.handle_left[0])
|
|
handles_in.append(s.handle_left[1])
|
|
handles_in.append(s.handle_left[2])
|
|
|
|
handles_out.append(s.handle_right[0])
|
|
handles_out.append(s.handle_right[1])
|
|
handles_out.append(s.handle_right[2])
|
|
|
|
tilts.append(s.tilt)
|
|
interps.append("BEZIER")
|
|
else:
|
|
|
|
for s in cs.points:
|
|
points.append(s.co[0])
|
|
points.append(s.co[1])
|
|
points.append(s.co[2])
|
|
handles_in.append(s.co[0])
|
|
handles_in.append(s.co[1])
|
|
handles_in.append(s.co[2])
|
|
handles_out.append(s.co[0])
|
|
handles_out.append(s.co[1])
|
|
handles_out.append(s.co[2])
|
|
tilts.append(s.tilt)
|
|
interps.append("LINEAR")
|
|
|
|
self.writel(S_GEOM, 3, '<source id="' + splineid + '-positions">')
|
|
position_values = ""
|
|
for x in points:
|
|
position_values += " " + str(x)
|
|
self.writel(S_GEOM, 4, '<float_array id="' + splineid +
|
|
'-positions-array" count="' +
|
|
str(len(points)) + '">' + position_values +
|
|
'</float_array>')
|
|
self.writel(S_GEOM, 4, '<technique_common>')
|
|
self.writel(S_GEOM, 4, '<accessor source="#' + splineid +
|
|
'-positions-array" count="' + str(len(points) / 3) +
|
|
'" stride="3">')
|
|
self.writel(S_GEOM, 5, '<param name="X" type="float"/>')
|
|
self.writel(S_GEOM, 5, '<param name="Y" type="float"/>')
|
|
self.writel(S_GEOM, 5, '<param name="Z" type="float"/>')
|
|
self.writel(S_GEOM, 4, '</accessor>')
|
|
self.writel(S_GEOM, 3, '</source>')
|
|
|
|
self.writel(S_GEOM, 3, '<source id="' + splineid + '-intangents">')
|
|
intangent_values = ""
|
|
for x in handles_in:
|
|
intangent_values += " " + str(x)
|
|
self.writel(S_GEOM, 4, '<float_array id="' + splineid +
|
|
'-intangents-array" count="' +
|
|
str(len(points)) + '">' + intangent_values +
|
|
'</float_array>')
|
|
self.writel(S_GEOM, 4, '<technique_common>')
|
|
self.writel(S_GEOM, 4, '<accessor source="#' + splineid +
|
|
'-intangents-array" count="' + str(len(points) / 3) +
|
|
'" stride="3">')
|
|
self.writel(S_GEOM, 5, '<param name="X" type="float"/>')
|
|
self.writel(S_GEOM, 5, '<param name="Y" type="float"/>')
|
|
self.writel(S_GEOM, 5, '<param name="Z" type="float"/>')
|
|
self.writel(S_GEOM, 4, '</accessor>')
|
|
self.writel(S_GEOM, 3, '</source>')
|
|
|
|
self.writel(S_GEOM, 3, '<source id="' + splineid + '-outtangents">')
|
|
outtangent_values = ""
|
|
for x in handles_out:
|
|
outtangent_values += " " + str(x)
|
|
self.writel(S_GEOM, 4, '<float_array id="' + splineid +
|
|
'-outtangents-array" count="' +
|
|
str(len(points)) + '">' + outtangent_values +
|
|
'</float_array>')
|
|
self.writel(S_GEOM, 4, '<technique_common>')
|
|
self.writel(S_GEOM, 4, '<accessor source="#' + splineid +
|
|
'-outtangents-array" count="' + str(len(points) / 3) +
|
|
'" stride="3">')
|
|
self.writel(S_GEOM, 5, '<param name="X" type="float"/>')
|
|
self.writel(S_GEOM, 5, '<param name="Y" type="float"/>')
|
|
self.writel(S_GEOM, 5, '<param name="Z" type="float"/>')
|
|
self.writel(S_GEOM, 4, '</accessor>')
|
|
self.writel(S_GEOM, 3, '</source>')
|
|
|
|
self.writel(S_GEOM, 3, '<source id="' + splineid + '-interpolations">')
|
|
interpolation_values = ""
|
|
for x in interps:
|
|
interpolation_values += " " + x
|
|
self.writel(S_GEOM, 4, '<Name_array id="' + splineid +
|
|
'-interpolations-array" count="' +
|
|
str(len(interps)) + '">' + interpolation_values +
|
|
'</Name_array>')
|
|
self.writel(S_GEOM, 4, '<technique_common>')
|
|
self.writel(S_GEOM, 4, '<accessor source="#' + splineid +
|
|
'-interpolations-array" count="' + str(len(interps)) +
|
|
'" stride="1">')
|
|
self.writel(S_GEOM, 5, '<param name="INTERPOLATION" type="name"/>')
|
|
self.writel(S_GEOM, 4, '</accessor>')
|
|
self.writel(S_GEOM, 3, '</source>')
|
|
|
|
self.writel(S_GEOM, 3, '<source id="' + splineid + '-tilts">')
|
|
tilt_values = ""
|
|
for x in tilts:
|
|
tilt_values += " " + str(x)
|
|
self.writel(S_GEOM, 4, '<float_array id="' + splineid +
|
|
'-tilts-array" count="' +
|
|
str(len(tilts)) + '">' + tilt_values + '</float_array>')
|
|
self.writel(S_GEOM, 4, '<technique_common>')
|
|
self.writel(S_GEOM, 4, '<accessor source="#' + splineid +
|
|
'-tilts-array" count="' + str(len(tilts)) +
|
|
'" stride="1">')
|
|
self.writel(S_GEOM, 5, '<param name="TILT" type="float"/>')
|
|
self.writel(S_GEOM, 4, '</accessor>')
|
|
self.writel(S_GEOM, 3, '</source>')
|
|
|
|
self.writel(S_GEOM, 3, '<control_vertices>')
|
|
self.writel(
|
|
S_GEOM, 4, '<input semantic="POSITION" source="#' + splineid +
|
|
'-positions"/>')
|
|
self.writel(S_GEOM, 4, '<input semantic="IN_TANGENT" source="#' +
|
|
splineid + '-intangents"/>')
|
|
self.writel(S_GEOM, 4, '<input semantic="OUT_TANGENT" source="#' +
|
|
splineid + '-outtangents"/>')
|
|
self.writel(S_GEOM, 4, '<input semantic="INTERPOLATION" source="#' +
|
|
splineid + '-interpolations"/>')
|
|
self.writel(S_GEOM, 4, '<input semantic="TILT" source="#' +
|
|
splineid + '-tilts"/>')
|
|
self.writel(S_GEOM, 3, '</control_vertices>')
|
|
|
|
self.writel(S_GEOM, 2, '</spline>')
|
|
self.writel(S_GEOM, 1, '</geometry>')
|
|
|
|
return splineid
|
|
|
|
def export_curve_node(self, node, il):
|
|
if (node.data is None):
|
|
return
|
|
|
|
curveid = self.export_curve(node.data)
|
|
|
|
self.writel(S_NODES, il, '<instance_geometry url="#' + curveid + '">')
|
|
self.writel(S_NODES, il, '</instance_geometry>')
|
|
|
|
def export_node(self, node, il):
|
|
if (node not in self.valid_nodes):
|
|
return
|
|
|
|
prev_node = bpy.context.scene.objects.active
|
|
bpy.context.scene.objects.active = node
|
|
|
|
self.writel(S_NODES, il, '<node id="' + self.validate_id(node.name) +
|
|
'" name="' + node.name + '" type="NODE">')
|
|
il += 1
|
|
|
|
self.writel(S_NODES, il, '<matrix sid="transform">' +
|
|
strmtx(node.matrix_local) + '</matrix>')
|
|
# print("NODE TYPE: "+node.type+" NAME: "+node.name)
|
|
if (node.type == "MESH"):
|
|
self.export_mesh_node(node, il)
|
|
elif (node.type == "CURVE"):
|
|
self.export_curve_node(node, il)
|
|
elif (node.type == "ARMATURE"):
|
|
self.export_armature_node(node, il)
|
|
elif (node.type == "CAMERA"):
|
|
self.export_camera_node(node, il)
|
|
elif (node.type == "LAMP"):
|
|
self.export_lamp_node(node, il)
|
|
elif (node.type == "EMPTY"):
|
|
self.export_empty_node(node, il)
|
|
|
|
for x in node.children:
|
|
self.export_node(x, il)
|
|
|
|
il -= 1
|
|
self.writel(S_NODES, il, '</node>')
|
|
# make previous node active again
|
|
bpy.context.scene.objects.active = prev_node
|
|
|
|
def is_node_valid(self, node):
|
|
if (node.type not in self.config["object_types"]):
|
|
return False
|
|
|
|
if (self.config["use_active_layers"]):
|
|
valid = False
|
|
# print("NAME: "+node.name)
|
|
for i in range(20):
|
|
if (node.layers[i] and self.scene.layers[i]):
|
|
valid = True
|
|
break
|
|
if (not valid):
|
|
return False
|
|
|
|
if (self.config["use_export_selected"] and not node.select):
|
|
return False
|
|
|
|
return True
|
|
|
|
def export_scene(self):
|
|
self.writel(S_NODES, 0, '<library_visual_scenes>')
|
|
self.writel(S_NODES, 1, '<visual_scene id="' +
|
|
self.scene_name + '" name="scene">')
|
|
|
|
# validate nodes
|
|
for obj in self.scene.objects:
|
|
if (obj in self.valid_nodes):
|
|
continue
|
|
if (self.is_node_valid(obj)):
|
|
n = obj
|
|
while (n is not None):
|
|
if (n not in self.valid_nodes):
|
|
self.valid_nodes.append(n)
|
|
n = n.parent
|
|
|
|
for obj in self.scene.objects:
|
|
if (obj in self.valid_nodes and obj.parent is None):
|
|
self.export_node(obj, 2)
|
|
|
|
self.writel(S_NODES, 1, '</visual_scene>')
|
|
self.writel(S_NODES, 0, '</library_visual_scenes>')
|
|
|
|
def export_asset(self):
|
|
self.writel(S_ASSET, 0, '<asset>')
|
|
# Why is this time stuff mandatory?, no one could care less...
|
|
self.writel(S_ASSET, 1, '<contributor>')
|
|
# Who made Collada, the FBI ?
|
|
self.writel(S_ASSET, 2, '<author> Anonymous </author>')
|
|
# Who made Collada, the FBI ?
|
|
self.writel(
|
|
S_ASSET, 2, '<authoring_tool> Collada Exporter for Blender 2.6+, '
|
|
'by Juan Linietsky (juan@codenix.com) </authoring_tool>')
|
|
self.writel(S_ASSET, 1, '</contributor>')
|
|
self.writel(S_ASSET, 1, '<created>' +
|
|
time.strftime("%Y-%m-%dT%H:%M:%SZ ") + '</created>')
|
|
self.writel(S_ASSET, 1, '<modified>' +
|
|
time.strftime("%Y-%m-%dT%H:%M:%SZ") + '</modified>')
|
|
self.writel(S_ASSET, 1, '<unit meter="1.0" name="meter"/>')
|
|
self.writel(S_ASSET, 1, '<up_axis>Z_UP</up_axis>')
|
|
self.writel(S_ASSET, 0, '</asset>')
|
|
|
|
def export_animation_transform_channel(self, target, keys, matrices=True):
|
|
frame_total = len(keys)
|
|
anim_id = self.new_id("anim")
|
|
self.writel(S_ANIM, 1, '<animation id="' + anim_id + '">')
|
|
source_frames = ""
|
|
source_transforms = ""
|
|
source_interps = ""
|
|
|
|
for k in keys:
|
|
source_frames += " " + str(k[0])
|
|
if (matrices):
|
|
source_transforms += " " + strmtx(k[1])
|
|
else:
|
|
source_transforms += " " + str(k[1])
|
|
|
|
source_interps += " LINEAR"
|
|
|
|
# Time Source
|
|
self.writel(S_ANIM, 2, '<source id="' + anim_id + '-input">')
|
|
self.writel(S_ANIM, 3, '<float_array id="' + anim_id +
|
|
'-input-array" count="' +
|
|
str(frame_total) + '">' + source_frames + '</float_array>')
|
|
self.writel(S_ANIM, 3, '<technique_common>')
|
|
self.writel(S_ANIM, 4, '<accessor source="#' + anim_id +
|
|
'-input-array" count="' + str(frame_total) +
|
|
'" stride="1">')
|
|
self.writel(S_ANIM, 5, '<param name="TIME" type="float"/>')
|
|
self.writel(S_ANIM, 4, '</accessor>')
|
|
self.writel(S_ANIM, 3, '</technique_common>')
|
|
self.writel(S_ANIM, 2, '</source>')
|
|
|
|
if (matrices):
|
|
# Transform Source
|
|
self.writel(S_ANIM, 2, '<source id="' +
|
|
anim_id + '-transform-output">')
|
|
self.writel(S_ANIM, 3, '<float_array id="' + anim_id +
|
|
'-transform-output-array" count="' +
|
|
str(frame_total * 16) + '">' + source_transforms +
|
|
'</float_array>')
|
|
self.writel(S_ANIM, 3, '<technique_common>')
|
|
self.writel(S_ANIM, 4, '<accessor source="#' + anim_id +
|
|
'-transform-output-array" count="' + str(frame_total) +
|
|
'" stride="16">')
|
|
self.writel(S_ANIM, 5, '<param name="TRANSFORM" type="float4x4"/>')
|
|
self.writel(S_ANIM, 4, '</accessor>')
|
|
self.writel(S_ANIM, 3, '</technique_common>')
|
|
self.writel(S_ANIM, 2, '</source>')
|
|
else:
|
|
# Value Source
|
|
self.writel(S_ANIM, 2, '<source id="' +
|
|
anim_id + '-transform-output">')
|
|
self.writel(S_ANIM, 3, '<float_array id="' + anim_id +
|
|
'-transform-output-array" count="' +
|
|
str(frame_total) + '">' + source_transforms +
|
|
'</float_array>')
|
|
self.writel(S_ANIM, 3, '<technique_common>')
|
|
self.writel(S_ANIM, 4, '<accessor source="#' + anim_id +
|
|
'-transform-output-array" count="' + str(frame_total) +
|
|
'" stride="1">')
|
|
self.writel(S_ANIM, 5, '<param name="X" type="float"/>')
|
|
self.writel(S_ANIM, 4, '</accessor>')
|
|
self.writel(S_ANIM, 3, '</technique_common>')
|
|
self.writel(S_ANIM, 2, '</source>')
|
|
|
|
# Interpolation Source
|
|
self.writel(S_ANIM, 2, '<source id="' +
|
|
anim_id + '-interpolation-output">')
|
|
self.writel(S_ANIM, 3, '<Name_array id="' + anim_id +
|
|
'-interpolation-output-array" count="' +
|
|
str(frame_total) + '">' + source_interps + '</Name_array>')
|
|
self.writel(S_ANIM, 3, '<technique_common>')
|
|
self.writel(S_ANIM, 4, '<accessor source="#' + anim_id +
|
|
'-interpolation-output-array" count="' + str(frame_total) +
|
|
'" stride="1">')
|
|
self.writel(S_ANIM, 5, '<param name="INTERPOLATION" type="Name"/>')
|
|
self.writel(S_ANIM, 4, '</accessor>')
|
|
self.writel(S_ANIM, 3, '</technique_common>')
|
|
self.writel(S_ANIM, 2, '</source>')
|
|
|
|
self.writel(S_ANIM, 2, '<sampler id="' + anim_id + '-sampler">')
|
|
self.writel(S_ANIM, 3, '<input semantic="INPUT" source="#' +
|
|
anim_id + '-input"/>')
|
|
self.writel(S_ANIM, 3, '<input semantic="OUTPUT" source="#' +
|
|
anim_id + '-transform-output"/>')
|
|
self.writel(S_ANIM, 3, '<input semantic="INTERPOLATION" source="#' +
|
|
anim_id + '-interpolation-output"/>')
|
|
self.writel(S_ANIM, 2, '</sampler>')
|
|
if (matrices):
|
|
self.writel(S_ANIM, 2, '<channel source="#' + anim_id +
|
|
'-sampler" target="' + target + '/transform"/>')
|
|
else:
|
|
self.writel(S_ANIM, 2, '<channel source="#' +
|
|
anim_id + '-sampler" target="' + target + '"/>')
|
|
self.writel(S_ANIM, 1, '</animation>')
|
|
|
|
return [anim_id]
|
|
|
|
def export_animation(self, start, end, allowed=None):
|
|
# Blender -> Collada frames needs a little work
|
|
# Collada starts from 0, blender usually from 1
|
|
# The last frame must be included also
|
|
|
|
frame_orig = self.scene.frame_current
|
|
|
|
frame_len = 1.0 / self.scene.render.fps
|
|
frame_total = end - start + 1
|
|
frame_sub = 0
|
|
if (start > 0):
|
|
frame_sub = start * frame_len
|
|
|
|
tcn = []
|
|
xform_cache = {}
|
|
blend_cache = {}
|
|
# Change frames first, export objects last
|
|
# This improves performance enormously
|
|
|
|
# print("anim from: " + str(start) + " to " + str(end) + " allowed: " +
|
|
# str(allowed))
|
|
for t in range(start, end + 1):
|
|
self.scene.frame_set(t)
|
|
key = t * frame_len - frame_sub
|
|
# print("Export Anim Frame "+str(t)+"/"+str(self.scene.frame_end+1))
|
|
|
|
for node in self.scene.objects:
|
|
|
|
if (node not in self.valid_nodes):
|
|
continue
|
|
if (allowed is not None and not (node in allowed)):
|
|
if (node.type == "MESH" and node.data is not None and
|
|
(node in self.armature_for_morph) and (
|
|
self.armature_for_morph[node] in allowed)):
|
|
# all good you pass with flying colors for morphs
|
|
# inside of action
|
|
pass
|
|
else:
|
|
# print("fail "+str((node in self.armature_for_morph)))
|
|
continue
|
|
if (node.type == "MESH" and node.data is not None and
|
|
node.data.shape_keys is not None and (
|
|
node.data in self.mesh_cache) and len(
|
|
node.data.shape_keys.key_blocks)):
|
|
target = self.mesh_cache[node.data]["morph_id"]
|
|
for i in range(len(node.data.shape_keys.key_blocks)):
|
|
|
|
if (i == 0):
|
|
continue
|
|
|
|
name = target + "-morph-weights(" + str(i - 1) + ")"
|
|
if (not (name in blend_cache)):
|
|
blend_cache[name] = []
|
|
|
|
blend_cache[name].append(
|
|
(key, node.data.shape_keys.key_blocks[i].value))
|
|
|
|
if (node.type == "MESH" and node.parent and
|
|
node.parent.type == "ARMATURE"):
|
|
|
|
# In Collada, nodes that have skin modifier must not export
|
|
# animation, animate the skin instead.
|
|
continue
|
|
|
|
if (len(node.constraints) > 0 or
|
|
node.animation_data is not None):
|
|
# If the node has constraints, or animation data, then
|
|
# export a sampled animation track
|
|
name = self.validate_id(node.name)
|
|
if (not (name in xform_cache)):
|
|
xform_cache[name] = []
|
|
|
|
mtx = node.matrix_world.copy()
|
|
if (node.parent):
|
|
mtx = node.parent.matrix_world.inverted() * mtx
|
|
|
|
xform_cache[name].append((key, mtx))
|
|
|
|
if (node.type == "ARMATURE"):
|
|
# All bones exported for now
|
|
|
|
for bone in node.data.bones:
|
|
|
|
bone_name = self.skeleton_info[node]["bone_ids"][bone]
|
|
|
|
if (not (bone_name in xform_cache)):
|
|
# print("has bone: " + bone_name)
|
|
xform_cache[bone_name] = []
|
|
|
|
posebone = node.pose.bones[bone.name]
|
|
parent_posebone = None
|
|
|
|
mtx = posebone.matrix.copy()
|
|
if (bone.parent):
|
|
parent_posebone = node.pose.bones[bone.parent.name]
|
|
parent_invisible = False
|
|
|
|
for i in range(3):
|
|
if (parent_posebone.scale[i] == 0.0):
|
|
parent_invisible = True
|
|
|
|
if (not parent_invisible):
|
|
mtx = parent_posebone.matrix.inverted() * mtx
|
|
|
|
xform_cache[bone_name].append((key, mtx))
|
|
|
|
self.scene.frame_set(frame_orig)
|
|
|
|
# export animation xml
|
|
for nid in xform_cache:
|
|
tcn += self.export_animation_transform_channel(
|
|
nid, xform_cache[nid], True)
|
|
for nid in blend_cache:
|
|
tcn += self.export_animation_transform_channel(
|
|
nid, blend_cache[nid], False)
|
|
|
|
return tcn
|
|
|
|
def export_animations(self):
|
|
tmp_mat = []
|
|
for s in self.skeletons:
|
|
tmp_bone_mat = []
|
|
for bone in s.pose.bones:
|
|
tmp_bone_mat.append(Matrix(bone.matrix_basis))
|
|
bone.matrix_basis = Matrix()
|
|
tmp_mat.append([Matrix(s.matrix_local), tmp_bone_mat])
|
|
|
|
self.writel(S_ANIM, 0, '<library_animations>')
|
|
|
|
if (self.config["use_anim_action_all"] and len(self.skeletons)):
|
|
|
|
cached_actions = {}
|
|
|
|
for s in self.skeletons:
|
|
if s.animation_data and s.animation_data.action:
|
|
cached_actions[s] = s.animation_data.action.name
|
|
|
|
self.writel(S_ANIM_CLIPS, 0, '<library_animation_clips>')
|
|
|
|
for x in bpy.data.actions[:]:
|
|
if x.users == 0 or x in self.action_constraints:
|
|
continue
|
|
if (self.config["use_anim_skip_noexp"] and
|
|
x.name.endswith("-noexp")):
|
|
continue
|
|
|
|
bones = []
|
|
# find bones used
|
|
for p in x.fcurves:
|
|
dp = str(p.data_path)
|
|
base = "pose.bones[\""
|
|
if (dp.find(base) == 0):
|
|
dp = dp[len(base):]
|
|
if (dp.find('"') != -1):
|
|
dp = dp[:dp.find('"')]
|
|
if (dp not in bones):
|
|
bones.append(dp)
|
|
|
|
allowed_skeletons = []
|
|
for i, y in enumerate(self.skeletons):
|
|
if (y.animation_data):
|
|
for z in y.pose.bones:
|
|
if (z.bone.name in bones):
|
|
if (y not in allowed_skeletons):
|
|
allowed_skeletons.append(y)
|
|
y.animation_data.action = x
|
|
|
|
y.matrix_local = tmp_mat[i][0]
|
|
for j, bone in enumerate(s.pose.bones):
|
|
bone.matrix_basis = Matrix()
|
|
|
|
# print("allowed skeletons "+str(allowed_skeletons))
|
|
|
|
# print(str(x))
|
|
|
|
tcn = self.export_animation(int(x.frame_range[0]), int(
|
|
x.frame_range[1] + 0.5), allowed_skeletons)
|
|
framelen = (1.0 / self.scene.render.fps)
|
|
start = x.frame_range[0] * framelen
|
|
end = x.frame_range[1] * framelen
|
|
# print("Export anim: "+x.name)
|
|
self.writel(
|
|
S_ANIM_CLIPS, 1, '<animation_clip name="' + x.name +
|
|
'" start="' + str(start) + '" end="' + str(end) + '">')
|
|
for z in tcn:
|
|
self.writel(S_ANIM_CLIPS, 2,
|
|
'<instance_animation url="#' + z + '"/>')
|
|
self.writel(S_ANIM_CLIPS, 1, '</animation_clip>')
|
|
if (len(tcn) == 0):
|
|
self.operator.report(
|
|
{'WARNING'}, 'Animation clip "' + x.name +
|
|
'" contains no tracks.')
|
|
|
|
self.writel(S_ANIM_CLIPS, 0, '</library_animation_clips>')
|
|
|
|
for i, s in enumerate(self.skeletons):
|
|
if (s.animation_data is None):
|
|
continue
|
|
if s in cached_actions:
|
|
s.animation_data.action = bpy.data.actions[
|
|
cached_actions[s]]
|
|
else:
|
|
s.animation_data.action = None
|
|
for j, bone in enumerate(s.pose.bones):
|
|
bone.matrix_basis = tmp_mat[i][1][j]
|
|
|
|
else:
|
|
self.export_animation(self.scene.frame_start, self.scene.frame_end)
|
|
|
|
self.writel(S_ANIM, 0, '</library_animations>')
|
|
|
|
def export(self):
|
|
self.writel(S_GEOM, 0, '<library_geometries>')
|
|
self.writel(S_CONT, 0, '<library_controllers>')
|
|
self.writel(S_CAMS, 0, '<library_cameras>')
|
|
self.writel(S_LAMPS, 0, '<library_lights>')
|
|
self.writel(S_IMGS, 0, '<library_images>')
|
|
self.writel(S_MATS, 0, '<library_materials>')
|
|
self.writel(S_FX, 0, '<library_effects>')
|
|
|
|
self.skeletons = []
|
|
self.action_constraints = []
|
|
self.export_asset()
|
|
self.export_scene()
|
|
|
|
self.writel(S_GEOM, 0, '</library_geometries>')
|
|
|
|
# morphs always go before skin controllers
|
|
if S_MORPH in self.sections:
|
|
for l in self.sections[S_MORPH]:
|
|
self.writel(S_CONT, 0, l)
|
|
del self.sections[S_MORPH]
|
|
|
|
# morphs always go before skin controllers
|
|
if S_SKIN in self.sections:
|
|
for l in self.sections[S_SKIN]:
|
|
self.writel(S_CONT, 0, l)
|
|
del self.sections[S_SKIN]
|
|
|
|
self.writel(S_CONT, 0, '</library_controllers>')
|
|
self.writel(S_CAMS, 0, '</library_cameras>')
|
|
self.writel(S_LAMPS, 0, '</library_lights>')
|
|
self.writel(S_IMGS, 0, '</library_images>')
|
|
self.writel(S_MATS, 0, '</library_materials>')
|
|
self.writel(S_FX, 0, '</library_effects>')
|
|
|
|
if (self.config["use_anim"]):
|
|
self.export_animations()
|
|
|
|
try:
|
|
f = open(self.path, "wb")
|
|
except:
|
|
return False
|
|
|
|
f.write(bytes('<?xml version="1.0" encoding="utf-8"?>\n', "UTF-8"))
|
|
f.write(bytes(
|
|
'<COLLADA xmlns="http://www.collada.org/2005/11/COLLADASchema" '
|
|
'version="1.4.1">\n', "UTF-8"))
|
|
|
|
s = []
|
|
for x in self.sections.keys():
|
|
s.append(x)
|
|
s.sort()
|
|
for x in s:
|
|
for l in self.sections[x]:
|
|
f.write(bytes(l + "\n", "UTF-8"))
|
|
|
|
f.write(bytes('<scene>\n', "UTF-8"))
|
|
f.write(bytes('\t<instance_visual_scene url="#' +
|
|
self.scene_name + '" />\n', "UTF-8"))
|
|
f.write(bytes('</scene>\n', "UTF-8"))
|
|
f.write(bytes('</COLLADA>\n', "UTF-8"))
|
|
return True
|
|
|
|
def __init__(self, path, kwargs, operator):
|
|
self.operator = operator
|
|
self.scene = bpy.context.scene
|
|
self.last_id = 0
|
|
self.scene_name = self.new_id("scene")
|
|
self.sections = {}
|
|
self.path = path
|
|
self.mesh_cache = {}
|
|
self.curve_cache = {}
|
|
self.material_cache = {}
|
|
self.image_cache = {}
|
|
self.skeleton_info = {}
|
|
self.config = kwargs
|
|
self.valid_nodes = []
|
|
self.armature_for_morph = {}
|
|
self.used_bones = []
|
|
self.wrongvtx_report = False
|
|
|
|
|
|
def save(operator, context, filepath="", use_selection=False, **kwargs):
|
|
exp = DaeExporter(filepath, kwargs, operator)
|
|
exp.export()
|
|
|
|
return {'FINISHED'} # so the script wont run after we have batch exported.
|