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
|
# Copyright 2018 The glTF-Blender-IO authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import bpy
from mathutils import Vector, Matrix
from ..com.gltf2_blender_conversion import matrix_gltf_to_blender, scale_to_matrix
from ...io.imp.gltf2_io_binary import BinaryData
class BlenderSkin():
"""Blender Skinning / Armature."""
def __new__(cls, *args, **kwargs):
raise RuntimeError("%s should not be instantiated" % cls)
@staticmethod
def create_armature(gltf, skin_id, parent):
"""Armature creation."""
pyskin = gltf.data.skins[skin_id]
if pyskin.name is not None:
name = pyskin.name
else:
name = "Armature_" + str(skin_id)
armature = bpy.data.armatures.new(name)
obj = bpy.data.objects.new(name, armature)
bpy.data.scenes[gltf.blender_scene].collection.objects.link(obj)
pyskin.blender_armature_name = obj.name
if parent is not None:
obj.parent = bpy.data.objects[gltf.data.nodes[parent].blender_object]
@staticmethod
def set_bone_transforms(gltf, skin_id, bone, node_id, parent):
"""Set bone transformations."""
pyskin = gltf.data.skins[skin_id]
pynode = gltf.data.nodes[node_id]
obj = bpy.data.objects[pyskin.blender_armature_name]
# Set bone bind_pose by inverting bindpose matrix
if node_id in pyskin.joints:
index_in_skel = pyskin.joints.index(node_id)
inverse_bind_matrices = BinaryData.get_data_from_accessor(gltf, pyskin.inverse_bind_matrices)
# Needed to keep scale in matrix, as bone.matrix seems to drop it
if index_in_skel < len(inverse_bind_matrices):
pynode.blender_bone_matrix = matrix_gltf_to_blender(
inverse_bind_matrices[index_in_skel]
).inverted()
bone.matrix = pynode.blender_bone_matrix
else:
gltf.log.error("Error with inverseBindMatrix for skin " + pyskin)
else:
print('No invBindMatrix for bone ' + str(node_id))
pynode.blender_bone_matrix = Matrix()
# Parent the bone
if parent is not None and hasattr(gltf.data.nodes[parent], "blender_bone_name"):
bone.parent = obj.data.edit_bones[gltf.data.nodes[parent].blender_bone_name] # TODO if in another scene
# Switch to Pose mode
bpy.ops.object.mode_set(mode="POSE")
obj.data.pose_position = 'POSE'
# Set posebone location/rotation/scale (in armature space)
# location is actual bone location minus it's original (bind) location
bind_location = Matrix.Translation(pynode.blender_bone_matrix.to_translation())
bind_rotation = pynode.blender_bone_matrix.to_quaternion()
bind_scale = scale_to_matrix(pynode.blender_bone_matrix.to_scale())
location, rotation, scale = matrix_gltf_to_blender(pynode.transform).decompose()
if parent is not None and hasattr(gltf.data.nodes[parent], "blender_bone_matrix"):
parent_mat = gltf.data.nodes[parent].blender_bone_matrix
# Get armature space location (bindpose + pose)
# Then, remove original bind location from armspace location, and bind rotation
final_location = (bind_location.inverted() @ parent_mat @ Matrix.Translation(location)).to_translation()
obj.pose.bones[pynode.blender_bone_name].location = \
bind_rotation.inverted().to_matrix().to_4x4() @ final_location
# Do the same for rotation
obj.pose.bones[pynode.blender_bone_name].rotation_quaternion = \
(bind_rotation.to_matrix().to_4x4().inverted() @ parent_mat @
rotation.to_matrix().to_4x4()).to_quaternion()
obj.pose.bones[pynode.blender_bone_name].scale = \
(bind_scale.inverted() @ parent_mat @ scale_to_matrix(scale)).to_scale()
else:
obj.pose.bones[pynode.blender_bone_name].location = bind_location.inverted() @ location
obj.pose.bones[pynode.blender_bone_name].rotation_quaternion = bind_rotation.inverted() @ rotation
obj.pose.bones[pynode.blender_bone_name].scale = bind_scale.inverted() @ scale
@staticmethod
def create_bone(gltf, skin_id, node_id, parent):
"""Bone creation."""
pyskin = gltf.data.skins[skin_id]
pynode = gltf.data.nodes[node_id]
scene = bpy.data.scenes[gltf.blender_scene]
obj = bpy.data.objects[pyskin.blender_armature_name]
bpy.context.window.scene = scene
bpy.context.view_layer.objects.active = obj
bpy.ops.object.mode_set(mode="EDIT")
if pynode.name:
name = pynode.name
else:
name = "Bone_" + str(node_id)
bone = obj.data.edit_bones.new(name)
pynode.blender_bone_name = bone.name
pynode.blender_armature_name = pyskin.blender_armature_name
bone.tail = Vector((0.0, 1.0, 0.0)) # Needed to keep bone alive
# set bind and pose transforms
BlenderSkin.set_bone_transforms(gltf, skin_id, bone, node_id, parent)
bpy.ops.object.mode_set(mode="OBJECT")
@staticmethod
def create_vertex_groups(gltf, skin_id):
"""Vertex Group creation."""
pyskin = gltf.data.skins[skin_id]
for node_id in pyskin.node_ids:
obj = bpy.data.objects[gltf.data.nodes[node_id].blender_object]
for bone in pyskin.joints:
obj.vertex_groups.new(name=gltf.data.nodes[bone].blender_bone_name)
@staticmethod
def assign_vertex_groups(gltf, skin_id):
"""Assign vertex groups to vertices."""
pyskin = gltf.data.skins[skin_id]
for node_id in pyskin.node_ids:
node = gltf.data.nodes[node_id]
obj = bpy.data.objects[node.blender_object]
offset = 0
for prim in gltf.data.meshes[node.mesh].primitives:
idx_already_done = {}
if 'JOINTS_0' in prim.attributes.keys() and 'WEIGHTS_0' in prim.attributes.keys():
joint_ = BinaryData.get_data_from_accessor(gltf, prim.attributes['JOINTS_0'])
weight_ = BinaryData.get_data_from_accessor(gltf, prim.attributes['WEIGHTS_0'])
for poly in obj.data.polygons:
for loop_idx in range(poly.loop_start, poly.loop_start + poly.loop_total):
vert_idx = obj.data.loops[loop_idx].vertex_index
if vert_idx in idx_already_done.keys():
continue
idx_already_done[vert_idx] = True
if vert_idx in range(offset, offset + prim.vertices_length):
tab_index = vert_idx - offset
cpt = 0
for joint_idx in joint_[tab_index]:
weight_val = weight_[tab_index][cpt]
if weight_val != 0.0: # It can be a problem to assign weights of 0
# for bone index 0, if there is always 4 indices in joint_
# tuple
group = obj.vertex_groups[gltf.data.nodes[
pyskin.joints[joint_idx]
].blender_bone_name]
group.add([vert_idx], weight_val, 'REPLACE')
cpt += 1
else:
gltf.log.error("No Skinning ?????") # TODO
offset = offset + prim.vertices_length
@staticmethod
def create_armature_modifiers(gltf, skin_id):
"""Create Armature modifier."""
pyskin = gltf.data.skins[skin_id]
if pyskin.blender_armature_name is None:
# TODO seems something is wrong
# For example, some joints are in skin 0, and are in another skin too
# Not sure this is glTF compliant, will check it
return
for node_id in pyskin.node_ids:
node = gltf.data.nodes[node_id]
obj = bpy.data.objects[node.blender_object]
for obj_sel in bpy.context.scene.objects:
obj_sel.select_set(False)
obj.select_set(True)
bpy.context.view_layer.objects.active = obj
# bpy.ops.object.parent_clear(type='CLEAR_KEEP_TRANSFORM')
# Reparent skinned mesh to it's armature to avoid breaking
# skinning with interleaved transforms
obj.parent = bpy.data.objects[pyskin.blender_armature_name]
arma = obj.modifiers.new(name="Armature", type="ARMATURE")
arma.object = bpy.data.objects[pyskin.blender_armature_name]
|
