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
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
|
# Copyright 2018-2021 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
import typing
from ..com.gltf2_blender_data_path import get_target_object_path, get_target_property_name, get_rotation_modes
from io_scene_gltf2.io.com import gltf2_io
from io_scene_gltf2.io.com import gltf2_io_debug
from io_scene_gltf2.blender.exp.gltf2_blender_gather_cache import cached
from io_scene_gltf2.blender.exp import gltf2_blender_gather_animation_samplers
from io_scene_gltf2.blender.exp import gltf2_blender_gather_animation_channel_target
from io_scene_gltf2.blender.exp import gltf2_blender_gather_animation_sampler_keyframes
from io_scene_gltf2.blender.exp import gltf2_blender_get
from io_scene_gltf2.blender.exp import gltf2_blender_gather_skins
from io_scene_gltf2.blender.exp import gltf2_blender_gather_drivers
from io_scene_gltf2.io.exp.gltf2_io_user_extensions import export_user_extensions
@cached
def gather_animation_channels(blender_action: bpy.types.Action,
blender_object: bpy.types.Object,
export_settings
) -> typing.List[gltf2_io.AnimationChannel]:
channels = []
# First calculate range of animation for baking
# This is need if user set 'Force sampling' and in case we need to bake
bake_range_start = None
bake_range_end = None
groups = __get_channel_groups(blender_action, blender_object, export_settings)
# Note: channels has some None items only for SK if some SK are not animated
for chans in groups:
ranges = [channel.range() for channel in chans if channel is not None]
if bake_range_start is None:
bake_range_start = min([channel.range()[0] for channel in chans if channel is not None])
else:
bake_range_start = min(bake_range_start, min([channel.range()[0] for channel in chans if channel is not None]))
if bake_range_end is None:
bake_range_end = max([channel.range()[1] for channel in chans if channel is not None])
else:
bake_range_end = max(bake_range_end, max([channel.range()[1] for channel in chans if channel is not None]))
if blender_object.type == "ARMATURE" and export_settings['gltf_force_sampling'] is True:
# We have to store sampled animation data for every deformation bones
# Check that there are some anim in this action
if bake_range_start is None:
return []
# Then bake all bones
bones_to_be_animated = []
if export_settings["gltf_def_bones"] is False:
bones_to_be_animated = blender_object.data.bones
else:
bones_to_be_animated, _, _ = gltf2_blender_gather_skins.get_bone_tree(None, blender_object)
bones_to_be_animated = [blender_object.pose.bones[b.name] for b in bones_to_be_animated]
for bone in bones_to_be_animated:
for p in ["location", "rotation_quaternion", "scale"]:
channel = __gather_animation_channel(
(),
blender_object,
export_settings,
bone.name,
p,
bake_range_start,
bake_range_end,
blender_action.name,
None)
channels.append(channel)
# Retrieve animation on armature object itself, if any
fcurves_armature = __gather_armature_object_channel_groups(blender_action, blender_object, export_settings)
for channel_group in fcurves_armature:
# No need to sort on armature, that can't have SK
if len(channel_group) == 0:
# Only errors on channels, ignoring
continue
channel = __gather_animation_channel(channel_group, blender_object, export_settings, None, None, bake_range_start, bake_range_end, blender_action.name, None)
if channel is not None:
channels.append(channel)
# Retrieve channels for drivers, if needed
obj_driver = blender_object.proxy if blender_object.proxy else blender_object
drivers_to_manage = gltf2_blender_gather_drivers.get_sk_drivers(obj_driver)
for obj, fcurves in drivers_to_manage:
channel = __gather_animation_channel(
fcurves,
blender_object,
export_settings,
None,
None,
bake_range_start,
bake_range_end,
blender_action.name,
obj)
channels.append(channel)
else:
for channel_group in __get_channel_groups(blender_action, blender_object, export_settings):
channel_group_sorted = __get_channel_group_sorted(channel_group, blender_object)
if len(channel_group_sorted) == 0:
# Only errors on channels, ignoring
continue
channel = __gather_animation_channel(channel_group_sorted, blender_object, export_settings, None, None, bake_range_start, bake_range_end, blender_action.name, None)
if channel is not None:
channels.append(channel)
# resetting driver caches
gltf2_blender_gather_drivers.get_sk_driver_values.reset_cache()
gltf2_blender_gather_drivers.get_sk_drivers.reset_cache()
# resetting bone caches
gltf2_blender_gather_animation_sampler_keyframes.get_bone_matrix.reset_cache()
return channels
def __get_channel_group_sorted(channels: typing.Tuple[bpy.types.FCurve], blender_object: bpy.types.Object):
# if this is shapekey animation, we need to sort in same order than shapekeys
# else, no need to sort
if blender_object.type == "MESH":
first_channel = channels[0]
object_path = get_target_object_path(first_channel.data_path)
if object_path:
if not blender_object.data.shape_keys:
# Something is wrong. Maybe the user assigned an armature action
# to a mesh object. Returning without sorting
return channels
# This is shapekeys, we need to sort channels
shapekeys_idx = {}
cpt_sk = 0
for sk in blender_object.data.shape_keys.key_blocks:
if sk == sk.relative_key:
continue
if sk.mute is True:
continue
shapekeys_idx[sk.name] = cpt_sk
cpt_sk += 1
# Note: channels will have some None items only for SK if some SK are not animated
idx_channel_mapping = []
all_sorted_channels = []
for sk_c in channels:
try:
sk_name = blender_object.data.shape_keys.path_resolve(get_target_object_path(sk_c.data_path)).name
idx = shapekeys_idx[sk_name]
idx_channel_mapping.append((shapekeys_idx[sk_name], sk_c))
except:
# Something is wrong. For example, an armature action linked to a mesh object
continue
existing_idx = dict(idx_channel_mapping)
for i in range(0, cpt_sk):
if i not in existing_idx.keys():
all_sorted_channels.append(None)
else:
all_sorted_channels.append(existing_idx[i])
if all([i is None for i in all_sorted_channels]): # all channel in error, and some non keyed SK
return channels # This happen when an armature action is linked to a mesh object with non keyed SK
return tuple(all_sorted_channels)
# if not shapekeys, stay in same order, because order doesn't matter
return channels
def __gather_animation_channel(channels: typing.Tuple[bpy.types.FCurve],
blender_object: bpy.types.Object,
export_settings,
bake_bone: typing.Union[str, None],
bake_channel: typing.Union[str, None],
bake_range_start,
bake_range_end,
action_name: str,
driver_obj
) -> typing.Union[gltf2_io.AnimationChannel, None]:
if not __filter_animation_channel(channels, blender_object, export_settings):
return None
__target= __gather_target(channels, blender_object, export_settings, bake_bone, bake_channel, driver_obj)
if __target.path is not None:
animation_channel = gltf2_io.AnimationChannel(
extensions=__gather_extensions(channels, blender_object, export_settings, bake_bone),
extras=__gather_extras(channels, blender_object, export_settings, bake_bone),
sampler=__gather_sampler(channels, blender_object, export_settings, bake_bone, bake_channel, bake_range_start, bake_range_end, action_name, driver_obj),
target=__target
)
export_user_extensions('gather_animation_channel_hook',
export_settings,
animation_channel,
channels,
blender_object,
bake_bone,
bake_channel,
bake_range_start,
bake_range_end,
action_name)
return animation_channel
return None
def __filter_animation_channel(channels: typing.Tuple[bpy.types.FCurve],
blender_object: bpy.types.Object,
export_settings
) -> bool:
return True
def __gather_extensions(channels: typing.Tuple[bpy.types.FCurve],
blender_object: bpy.types.Object,
export_settings,
bake_bone: typing.Union[str, None]
) -> typing.Any:
return None
def __gather_extras(channels: typing.Tuple[bpy.types.FCurve],
blender_object: bpy.types.Object,
export_settings,
bake_bone: typing.Union[str, None]
) -> typing.Any:
return None
def __gather_sampler(channels: typing.Tuple[bpy.types.FCurve],
blender_object: bpy.types.Object,
export_settings,
bake_bone: typing.Union[str, None],
bake_channel: typing.Union[str, None],
bake_range_start,
bake_range_end,
action_name,
driver_obj
) -> gltf2_io.AnimationSampler:
return gltf2_blender_gather_animation_samplers.gather_animation_sampler(
channels,
blender_object,
bake_bone,
bake_channel,
bake_range_start,
bake_range_end,
action_name,
driver_obj,
export_settings
)
def __gather_target(channels: typing.Tuple[bpy.types.FCurve],
blender_object: bpy.types.Object,
export_settings,
bake_bone: typing.Union[str, None],
bake_channel: typing.Union[str, None],
driver_obj
) -> gltf2_io.AnimationChannelTarget:
return gltf2_blender_gather_animation_channel_target.gather_animation_channel_target(
channels, blender_object, bake_bone, bake_channel, driver_obj, export_settings)
def __get_channel_groups(blender_action: bpy.types.Action, blender_object: bpy.types.Object, export_settings):
targets = {}
multiple_rotation_mode_detected = False
delta_rotation_detection = [False, False] # Normal / Delta
for fcurve in blender_action.fcurves:
# In some invalid files, channel hasn't any keyframes ... this channel need to be ignored
if len(fcurve.keyframe_points) == 0:
continue
try:
target_property = get_target_property_name(fcurve.data_path)
except:
gltf2_io_debug.print_console("WARNING", "Invalid animation fcurve name on action {}".format(blender_action.name))
continue
object_path = get_target_object_path(fcurve.data_path)
# find the object affected by this action
if not object_path:
target = blender_object
else:
try:
target = gltf2_blender_get.get_object_from_datapath(blender_object, object_path)
if blender_object.type == "MESH" and object_path.startswith("key_blocks"):
shape_key = blender_object.data.shape_keys.path_resolve(object_path)
if shape_key.mute is True:
continue
target = blender_object.data.shape_keys
except ValueError as e:
# if the object is a mesh and the action target path can not be resolved, we know that this is a morph
# animation.
if blender_object.type == "MESH":
try:
shape_key = blender_object.data.shape_keys.path_resolve(object_path)
if shape_key.mute is True:
continue
target = blender_object.data.shape_keys
except:
# Something is wrong, for example a bone animation is linked to an object mesh...
gltf2_io_debug.print_console("WARNING", "Animation target {} not found".format(object_path))
continue
else:
gltf2_io_debug.print_console("WARNING", "Animation target {} not found".format(object_path))
continue
# Detect that object or bone are not multiple keyed for euler and quaternion
# Keep only the current rotation mode used by object
rotation, delta, rotation_modes = get_rotation_modes(target_property)
# Delta rotation management
if delta is False:
if delta_rotation_detection[1] is True: # normal rotation coming, but delta is already present
multiple_rotation_mode_detected = True
continue
delta_rotation_detection[0] = True
else:
if delta_rotation_detection[0] is True: # delta rotation coming, but normal is already present
multiple_rotation_mode_detected = True
continue
delta_rotation_detection[1] = True
if rotation and target.rotation_mode not in rotation_modes:
multiple_rotation_mode_detected = True
continue
# group channels by target object and affected property of the target
target_properties = targets.get(target, {})
channels = target_properties.get(target_property, [])
channels.append(fcurve)
target_properties[target_property] = channels
targets[target] = target_properties
groups = []
for p in targets.values():
groups += list(p.values())
if multiple_rotation_mode_detected is True:
gltf2_io_debug.print_console("WARNING", "Multiple rotation mode detected for {}".format(blender_object.name))
return map(tuple, groups)
def __gather_armature_object_channel_groups(blender_action: bpy.types.Action, blender_object: bpy.types.Object, export_settings):
targets = {}
if blender_object.type != "ARMATURE":
return tuple()
delta_rotation_detection = [False, False] # Normal / Delta
for fcurve in blender_action.fcurves:
object_path = get_target_object_path(fcurve.data_path)
if object_path != "":
continue
# In some invalid files, channel hasn't any keyframes ... this channel need to be ignored
if len(fcurve.keyframe_points) == 0:
continue
try:
target_property = get_target_property_name(fcurve.data_path)
except:
gltf2_io_debug.print_console("WARNING", "Invalid animation fcurve name on action {}".format(blender_action.name))
continue
target = gltf2_blender_get.get_object_from_datapath(blender_object, object_path)
# Detect that armature is not multiple keyed for euler and quaternion
# Keep only the current rotation mode used by bone
rotation, delta, rotation_modes = get_rotation_modes(target_property)
# Delta rotation management
if delta is False:
if delta_rotation_detection[1] is True: # normal rotation coming, but delta is already present
continue
delta_rotation_detection[0] = True
else:
if delta_rotation_detection[0] is True: # delta rotation coming, but normal is already present
continue
delta_rotation_detection[1] = True
if rotation and target.rotation_mode not in rotation_modes:
continue
# group channels by target object and affected property of the target
target_properties = targets.get(target, {})
channels = target_properties.get(target_property, [])
channels.append(fcurve)
target_properties[target_property] = channels
targets[target] = target_properties
groups = []
for p in targets.values():
groups += list(p.values())
return map(tuple, groups)
|