def _write_lods(self, object_, parent_node, group):
#prop_name = object_.name
prop_name = utils.changed_lod_name(object_.name)
node_type = utils.get_node_type(group)
if node_type in ('chr', 'ckin'):
prop_name = join(object_.name,
self._create_properties_name(object_, group))
node = self._doc.createElement("node")
node.setAttribute("id", prop_name)
node.setAttribute("name", prop_name)
node.setIdAttribute("id")
self._write_transforms(object_, node)
ALLOWED_NODE_TYPES = ('cgf', 'cga', 'chr', 'skin')
if utils.get_node_type(group) in ALLOWED_NODE_TYPES:
instance = self._create_instance(group, object_)
if instance is not None:
node.appendChild(instance)
udp_extra = self._create_user_defined_property(object_)
if udp_extra is not None:
node.appendChild(udp_extra)
parent_node.appendChild(node)
return node
def _write_child_objects(self, parent_object, parent_node, group):
for child_object in parent_object.children:
if utils.is_lod_geometry(child_object):
continue
if not utils.is_object_in_group(child_object, group):
continue
prop_name = child_object.name
node_type = utils.get_node_type(group)
node = self._doc.createElement("node")
node.setAttribute("id", prop_name)
node.setAttribute("name", prop_name)
node.setIdAttribute("id")
self._write_transforms(child_object, node)
ALLOWED_NODE_TYPES = ('cgf', 'cga', 'chr', 'skin')
if utils.get_node_type(group) in ALLOWED_NODE_TYPES:
instance = self._create_instance(group, child_object)
if instance is not None:
node.appendChild(instance)
udp_extra = self._create_user_defined_property(child_object)
if udp_extra is not None:
node.appendChild(udp_extra)
self._write_child_objects(child_object, node, group)
parent_node.appendChild(node)
return parent_node
def _write_visual_scene_node(self, objects, parent_node, group):
node_type = utils.get_node_type(group)
for object_ in objects:
if node_type == 'i_caf' and object_.type == 'ARMATURE':
self._write_bone_list([utils.get_root_bone(
object_)], object_, parent_node, group)
elif node_type == 'anm' and object_.type == 'MESH':
prop_name = "{}{}".format(
object_.name, self._create_properties_name(
object_, group))
node = self._doc.createElement("node")
node.setAttribute("id", prop_name)
node.setAttribute("name", prop_name)
node.setIdAttribute("id")
self._write_transforms(object_, node)
udp_extra = self._create_user_defined_property(object_)
if udp_extra is not None:
node.appendChild(udp_extra)
parent_node.appendChild(node)
return parent_node
def _write_visual_scene_node(self, objects, parent_node, group):
for object_ in objects:
if (object_.type == "MESH" or object_.type == 'EMPTY') \
and not utils.is_fakebone(object_) \
and not utils.is_lod_geometry(object_) \
and not utils.is_there_a_parent_releation(object_, group):
prop_name = object_.name
node_type = utils.get_node_type(group)
if node_type in ('chr', 'skin'):
prop_name = join(
object_.name,
self._create_properties_name(object_, group))
node = self._doc.createElement("node")
node.setAttribute("id", prop_name)
node.setAttribute("name", prop_name)
node.setIdAttribute("id")
self._write_transforms(object_, node)
if not utils.is_dummy(object_):
ALLOWED_NODE_TYPES = ('cgf', 'cga', 'chr', 'skin')
if node_type in ALLOWED_NODE_TYPES:
instance = self._create_instance(group, object_)
if instance is not None:
node.appendChild(instance)
udp_extra = self._create_user_defined_property(object_)
if udp_extra is not None:
node.appendChild(udp_extra)
parent_node.appendChild(node)
if utils.is_has_lod(object_):
sub_node = node
for lod in utils.get_lod_geometries(object_):
sub_node = self._write_lods(lod, sub_node, group)
if node_type in ('chr', 'skin') and object_.parent \
and object_.parent.type == "ARMATURE":
armature = object_.parent
self._write_bone_list([utils.get_root_bone(armature)],
object_, parent_node, group)
armature_physic = utils.get_armature_physic(armature)
if armature_physic:
self._write_bone_list(
[utils.get_root_bone(armature_physic)],
armature_physic, parent_node, group)
else:
self._write_child_objects(object_, node, group)
return parent_node
def _export_library_controllers(self, parent_element):
library_node = self._doc.createElement("library_controllers")
ALLOWED_NODE_TYPES = ('chr', 'skin')
for group in utils.get_mesh_export_nodes(
self._config.export_selected_nodes):
node_type = utils.get_node_type(group)
if node_type in ALLOWED_NODE_TYPES:
for object_ in group.objects:
if not utils.is_bone_geometry(object_):
armature = utils.get_armature_for_object(object_)
if armature is not None:
self._process_bones(library_node, group, object_,
armature)
parent_element.appendChild(library_node)
def __rename_anm_files(self, dae_path):
output_path = os.path.dirname(dae_path)
for group in utils.get_export_nodes():
if utils.get_node_type(group) == 'anm':
node_name = utils.get_node_name(group)
src_name = "{}_{}".format(node_name, group.name)
src_name = os.path.join(output_path, src_name)
if os.path.exists(src_name):
dest_name = utils.get_geometry_animation_file_name(group)
dest_name = os.path.join(output_path, dest_name)
if os.path.exists(dest_name):
os.remove(dest_name)
os.rename(src_name, dest_name)
def _create_instance(self, group, object_):
armature = utils.get_armature_for_object(object_)
node_type = utils.get_node_type(group)
instance = None
if armature and node_type in ('chr', 'skin'):
instance = self._doc.createElement("instance_controller")
# This binds the mesh object to the armature in control of it
instance.setAttribute(
"url", "#{!s}_{!s}".format(armature.name, object_.name))
elif object_.name[:6] != "_joint" and object_.type == "MESH":
instance = self._doc.createElement("instance_geometry")
instance.setAttribute(
"url", "#{!s}".format(utils.get_geometry_name(group, object_)))
if instance is not None:
bind_material = self._create_bind_material(object_)
instance.appendChild(bind_material)
return instance
def _create_cryengine_extra(self, node):
extra = self._doc.createElement("extra")
technique = self._doc.createElement("technique")
technique.setAttribute("profile", "CryEngine")
properties = self._doc.createElement("properties")
ALLOWED_NODE_TYPES = ("cgf", "cga", "chr", "skin")
if utils.is_export_node(node):
node_type = utils.get_node_type(node)
if node_type in ALLOWED_NODE_TYPES:
prop = self._doc.createTextNode(
"fileType={}".format(node_type))
properties.appendChild(prop)
if not self._config.merge_all_nodes:
prop = self._doc.createTextNode("DoNotMerge")
properties.appendChild(prop)
prop = self._doc.createTextNode("UseCustomNormals")
properties.appendChild(prop)
if self._config.vcloth_pre_process and node_type == 'skin':
prop = self._doc.createTextNode("VClothPreProcess")
properties.appendChild(prop)
prop = self._doc.createTextNode("CustomExportPath=")
properties.appendChild(prop)
else:
if not node.rna_type.id_data.items():
return
technique.appendChild(properties)
if (node.name[:6] == "_joint"):
helper = self._create_helper_joint(node)
technique.appendChild(helper)
extra.appendChild(technique)
extra.appendChild(self._create_xsi_profile(node))
return extra
def __recompile(self, dae_path):
name = os.path.basename(dae_path)
output_path = os.path.dirname(dae_path)
ALLOWED_NODE_TYPES = ("chr", "skin")
for group in utils.get_export_nodes():
node_type = utils.get_node_type(group)
if node_type in ALLOWED_NODE_TYPES:
out_file = os.path.join(output_path, group.name)
args = [
self.__config.rc_path,
"/refresh",
"/vertexindexformat=u16",
out_file]
rc_second_pass = subprocess.Popen(args)
elif node_type == 'i_caf':
try:
os.remove(os.path.join(output_path, ".animsettings"))
os.remove(os.path.join(output_path, ".caf"))
os.remove(os.path.join(output_path, ".$animsettings"))
except:
pass
def _create_cryengine_extra(self, node):
extra = self._doc.createElement("extra")
technique = self._doc.createElement("technique")
technique.setAttribute("profile", "CryEngine")
properties = self._doc.createElement("properties")
node_type = utils.get_node_type(node)
prop = self._doc.createTextNode("fileType={}".format(node_type))
properties.appendChild(prop)
prop = self._doc.createTextNode("CustomExportPath=")
properties.appendChild(prop)
technique.appendChild(properties)
if (node.name[:6] == "_joint"):
helper = self._create_helper_joint(node)
technique.appendChild(helper)
extra.appendChild(technique)
extra.appendChild(self._create_xsi_profile(node))
return extra
def export(self):
self._prepare_for_export()
root_element = self._doc.createElement('collada')
root_element.setAttribute(
"xmlns", "http://www.collada.org/2005/11/COLLADASchema")
root_element.setAttribute("version", "1.4.1")
self._doc.appendChild(root_element)
self._create_file_header(root_element)
libanmcl = self._doc.createElement("library_animation_clips")
libanm = self._doc.createElement("library_animations")
root_element.appendChild(libanmcl)
root_element.appendChild(libanm)
lib_visual_scene = self._doc.createElement("library_visual_scenes")
visual_scene = self._doc.createElement("visual_scene")
visual_scene.setAttribute("id", "scene")
visual_scene.setAttribute("name", "scene")
lib_visual_scene.appendChild(visual_scene)
root_element.appendChild(lib_visual_scene)
initial_frame_active = bpy.context.scene.frame_current
initial_frame_start = bpy.context.scene.frame_start
initial_frame_end = bpy.context.scene.frame_end
ALLOWED_NODE_TYPES = ("i_caf", "anm")
for group in utils.get_animation_export_nodes():
node_type = utils.get_node_type(group)
node_name = utils.get_node_name(group)
if node_type in ALLOWED_NODE_TYPES:
object_ = None
layers = None
if node_type == 'i_caf':
object_ = utils.get_armature_from_node(group)
layers = utils.activate_all_bone_layers(object_)
elif node_type == 'anm':
object_ = group.objects[0]
frame_start, frame_end = utils.get_animation_node_range(
object_, node_name, initial_frame_start, initial_frame_end)
bpy.context.scene.frame_start = frame_start
bpy.context.scene.frame_end = frame_end
print('')
bcPrint(group.name)
bcPrint("Animation is being preparing to process.")
bcPrint("Animation frame range are [{} - {}]".format(
frame_start, frame_end))
if node_type == 'i_caf':
utils.add_fakebones(group)
try:
self._export_library_animation_clips_and_animations(
libanmcl, libanm, group)
self._export_library_visual_scenes(visual_scene, group)
except RuntimeError:
pass
finally:
if node_type == 'i_caf':
utils.remove_fakebones()
utils.recover_bone_layers(object_, layers)
bcPrint("Animation has been processed.")
bpy.context.scene.frame_current = initial_frame_active
bpy.context.scene.frame_start = initial_frame_start
bpy.context.scene.frame_end = initial_frame_end
print('')
self._export_scene(root_element)
converter = RCInstance(self._config)
converter.convert_dae(self._doc)
def _export_library_geometries(self, parent_element):
libgeo = self._doc.createElement("library_geometries")
parent_element.appendChild(libgeo)
for group in utils.get_mesh_export_nodes(
self._config.export_selected_nodes):
for object_ in group.objects:
if object_.type != 'MESH':
continue
apply_modifiers = self._config.apply_modifiers
if utils.get_node_type(group) in ('chr', 'skin'):
apply_modifiers = False
bmesh_, backup_info = utils.get_bmesh(object_, apply_modifiers)
geometry_node = self._doc.createElement("geometry")
geometry_name = utils.get_geometry_name(group, object_)
geometry_node.setAttribute("id", geometry_name)
mesh_node = self._doc.createElement("mesh")
print()
bcPrint('"{}" object is being processed...'.format(
object_.name))
start_time = clock()
self._write_positions(bmesh_, mesh_node, geometry_name)
bcPrint('Positions have been writed {:.4f} seconds.'.format(
clock() - start_time))
start_time = clock()
self._write_normals(object_, bmesh_, mesh_node, geometry_name)
bcPrint('Normals have been writed {:.4f} seconds.'.format(
clock() - start_time))
start_time = clock()
self._write_uvs(object_, bmesh_, mesh_node, geometry_name)
bcPrint(
'UVs have been writed {:.4f} seconds.'.format(clock() -
start_time))
start_time = clock()
self._write_vertex_colors(object_, bmesh_, mesh_node,
geometry_name)
bcPrint(
'Vertex colors have been writed {:.4f} seconds.'.format(
clock() - start_time))
start_time = clock()
self._write_vertices(mesh_node, geometry_name)
bcPrint('Vertices have been writed {:.4f} seconds.'.format(
clock() - start_time))
start_time = clock()
self._write_triangle_list(object_, bmesh_, mesh_node,
geometry_name)
bcPrint(
'Triangle list have been writed {:.4f} seconds.'.format(
clock() - start_time))
extra = self._create_double_sided_extra("MAYA")
mesh_node.appendChild(extra)
geometry_node.appendChild(mesh_node)
libgeo.appendChild(geometry_node)
utils.clear_bmesh(object_, backup_info)
bcPrint('"{}" object has been processed for "{}" node.'.format(
object_.name, group.name))
