def _write_normals(self, object_, bmesh_, mesh_node, geometry_name):
split_angle = 0
use_edge_angle = False
use_edge_sharp = False
if object_.data.use_auto_smooth:
use_edge_angle = True
use_edge_sharp = True
split_angle = object_.data.auto_smooth_angle
else:
for modifier in object_.modifiers:
if modifier.type == 'EDGE_SPLIT' and modifier.show_viewport:
use_edge_angle = modifier.use_edge_angle
use_edge_sharp = modifier.use_edge_sharp
split_angle = modifier.split_angle
float_normals = None
if self._config.custom_normals:
float_normals = utils.get_custom_normals(bmesh_, use_edge_angle,
split_angle)
else:
float_normals = utils.get_normal_array(bmesh_, use_edge_angle,
use_edge_sharp, split_angle)
id_ = "{!s}-normal".format(geometry_name)
source = utils.write_source(id_, "float", float_normals, "XYZ")
mesh_node.appendChild(source)
def _write_positions(self, bmesh_, mesh_node, geometry_name):
float_positions = []
for vertex in bmesh_.verts:
float_positions.extend(vertex.co)
id_ = "{!s}-pos".format(geometry_name)
source = utils.write_source(id_, "float", float_positions, "XYZ")
mesh_node.appendChild(source)
def _process_bone_weights(self, object_, armature, skin_node):
bones = utils.get_bones(armature)
group_weights = []
vw = ""
vertex_groups_lengths = ""
vertex_count = 0
bone_list = {}
for bone_id, bone in enumerate(bones):
bone_list[bone.name] = bone_id
for vertex in object_.data.vertices:
vertex_group_count = 0
for group in vertex.groups:
group_name = object_.vertex_groups[group.group].name
if (group.weight == 0 or
group_name not in bone_list):
continue
if vertex_group_count == 8:
bcPrint("Too many bone references in {}:{} vertex group"
.format(object_.name, group_name))
continue
group_weights.append(group.weight)
vw = "{}{} {} ".format(vw, bone_list[group_name], vertex_count)
vertex_count += 1
vertex_group_count += 1
vertex_groups_lengths = "{}{} ".format(vertex_groups_lengths,
vertex_group_count)
id_ = "{!s}_{!s}-weights".format(armature.name, object_.name)
source = utils.write_source(id_, "float", group_weights, [])
skin_node.appendChild(source)
vertex_weights = self._doc.createElement("vertex_weights")
vertex_weights.setAttribute("count", str(len(object_.data.vertices)))
id_ = "{!s}_{!s}".format(armature.name, object_.name)
input = utils.write_input(id_, 0, "joints", "JOINT")
vertex_weights.appendChild(input)
input = utils.write_input(id_, 1, "weights", "WEIGHT")
vertex_weights.appendChild(input)
vcount = self._doc.createElement("vcount")
vcount_text = self._doc.createTextNode(vertex_groups_lengths)
vcount.appendChild(vcount_text)
vertex_weights.appendChild(vcount)
v = self._doc.createElement("v")
v_text = self._doc.createTextNode(vw)
v.appendChild(v_text)
vertex_weights.appendChild(v)
skin_node.appendChild(vertex_weights)
def _process_bone_joints(self, object_, armature, skin_node, group):
bones = utils.get_bones(armature)
id_ = "{!s}_{!s}-joints".format(armature.name, object_.name)
bone_names = []
for bone in bones:
props_name = self._create_properties_name(bone, group)
bone_name = "{!s}{!s}".format(bone.name, props_name)
bone_names.append(bone_name)
source = utils.write_source(id_, "IDREF", bone_names, [])
skin_node.appendChild(source)
def _process_bone_matrices(self, object_, armature, skin_node):
bones = utils.get_bones(armature)
bone_matrices = []
for bone in armature.pose.bones:
bone_matrix = utils.transform_bone_matrix(bone)
bone_matrices.extend(utils.matrix_to_array(bone_matrix))
id_ = "{!s}_{!s}-matrices".format(armature.name, object_.name)
source = utils.write_source(id_, "float4x4", bone_matrices, [])
skin_node.appendChild(source)
def _create_animation_node(self, type_, data, id_prefix):
id_ = "{!s}-{!s}".format(id_prefix, type_)
type_map = {
"input": ["float", ["TIME"]],
"output": ["float", ["VALUE"]],
"intangent": ["float", "XY"],
"outangent": ["float", "XY"],
"interpolation": ["name", ["INTERPOLATION"]]
}
source = utils.write_source(
id_, type_map[type_][0], data, type_map[type_][1])
return source
def _write_vertex_colors(self, object_, bmesh_, mesh_node, geometry_name):
float_colors = []
alpha_found = False
color_layer = bmesh_.loops.layers.color.active
if object_.data.vertex_colors:
for vert in bmesh_.verts:
loop = vert.link_loops[0]
float_colors.extend(loop[color_layer])
if float_colors:
id_ = "{!s}-vcol".format(geometry_name)
params = ("RGBA" if alpha_found else "RGB")
source = utils.write_source(id_, "float", float_colors, params)
mesh_node.appendChild(source)
def _write_uvs(self, object_, bmesh_, mesh_node, geometry_name):
uv_layer = bmesh_.loops.layers.uv.active
if object_.data.uv_layers.active is None:
bcPrint(
"{} object has no a UV map, creating a default UV...".format(
object_.name))
uv_layer = bmesh_.loops.layers.uv.new()
float_uvs = []
for face in bmesh_.faces:
for loop in face.loops:
float_uvs.extend(loop[uv_layer].uv)
id_ = "{!s}-uvs".format(geometry_name)
source = utils.write_source(id_, "float", float_uvs, "ST")
mesh_node.appendChild(source)
def _write_vertex_colors(self, object_, bmesh_, mesh_node, geometry_name):
float_colors = []
alpha_found = False
active_layer = bmesh_.loops.layers.color.active
if object_.data.vertex_colors:
if active_layer.name.lower() == 'alpha':
alpha_found = True
for vert in bmesh_.verts:
loop = vert.link_loops[0]
color = loop[active_layer]
alpha_color = (color[0] + color[1] + color[2]) / 3.0
float_colors.extend([1.0, 1.0, 1.0, alpha_color])
else:
for vert in bmesh_.verts:
loop = vert.link_loops[0]
float_colors.extend(loop[active_layer])
if float_colors:
id_ = "{!s}-vcol".format(geometry_name)
params = ("RGBA" if alpha_found else "RGB")
source = utils.write_source(id_, "float", float_colors, params)
mesh_node.appendChild(source)
