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
|
# 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
import mathutils
import typing
import math
from . import gltf2_blender_export_keys
from mathutils import Matrix
from io_scene_gltf2.blender.com.gltf2_blender_data_path import get_target_property_name, get_target_object_path
from io_scene_gltf2.io.com import gltf2_io
from io_scene_gltf2.blender.exp.gltf2_blender_gather_cache import cached
from io_scene_gltf2.io.exp import gltf2_io_binary_data
from io_scene_gltf2.io.com import gltf2_io_constants
from io_scene_gltf2.blender.com import gltf2_blender_math
from io_scene_gltf2.blender.exp import gltf2_blender_gather_animation_sampler_keyframes
@cached
def gather_animation_sampler(channels: typing.Tuple[bpy.types.FCurve],
blender_object: bpy.types.Object,
export_settings
) -> gltf2_io.AnimationSampler:
return gltf2_io.AnimationSampler(
extensions=__gather_extensions(channels, blender_object, export_settings),
extras=__gather_extras(channels, blender_object, export_settings),
input=__gather_input(channels, blender_object, export_settings),
interpolation=__gather_interpolation(channels, blender_object, export_settings),
output=__gather_output(channels, blender_object, export_settings)
)
def __gather_extensions(channels: typing.Tuple[bpy.types.FCurve],
blender_object: bpy.types.Object,
export_settings
) -> typing.Any:
return None
def __gather_extras(channels: typing.Tuple[bpy.types.FCurve],
blender_object: bpy.types.Object,
export_settings
) -> typing.Any:
return None
def __gather_input(channels: typing.Tuple[bpy.types.FCurve],
blender_object: bpy.types.Object,
export_settings
) -> gltf2_io.Accessor:
"""Gather the key time codes."""
keyframes = gltf2_blender_gather_animation_sampler_keyframes.gather_keyframes(channels, export_settings)
times = [k.seconds for k in keyframes]
return gltf2_io.Accessor(
buffer_view=gltf2_io_binary_data.BinaryData.from_list(times, gltf2_io_constants.ComponentType.Float),
byte_offset=None,
component_type=gltf2_io_constants.ComponentType.Float,
count=len(times),
extensions=None,
extras=None,
max=[max(times)],
min=[min(times)],
name=None,
normalized=None,
sparse=None,
type=gltf2_io_constants.DataType.Scalar
)
def __gather_interpolation(channels: typing.Tuple[bpy.types.FCurve],
blender_object: bpy.types.Object,
export_settings
) -> str:
if gltf2_blender_gather_animation_sampler_keyframes.needs_baking(channels, export_settings):
return 'STEP'
blender_keyframe = channels[0].keyframe_points[0]
# Select the interpolation method. Any unsupported method will fallback to STEP
return {
"BEZIER": "CUBICSPLINE",
"LINEAR": "LINEAR",
"CONSTANT": "STEP"
}[blender_keyframe.interpolation]
def __gather_output(channels: typing.Tuple[bpy.types.FCurve],
blender_object: bpy.types.Object,
export_settings
) -> gltf2_io.Accessor:
"""Gather the data of the keyframes."""
keyframes = gltf2_blender_gather_animation_sampler_keyframes.gather_keyframes(channels, export_settings)
target_datapath = channels[0].data_path
transform = blender_object.matrix_parent_inverse
isYup = export_settings[gltf2_blender_export_keys.YUP]
if blender_object.type == "ARMATURE":
bone = blender_object.path_resolve(get_target_object_path(target_datapath))
if isinstance(bone, bpy.types.PoseBone):
if bone.parent is not None:
parent_transform = bone.parent.bone.matrix_local
transform = gltf2_blender_math.multiply(transform, parent_transform.inverted())
# if not isYup:
# transform = gltf2_blender_math.multiply(transform, gltf2_blender_math.to_zup())
else:
# only apply the y-up conversion to root bones, as child bones already are in the y-up space
if isYup:
transform = gltf2_blender_math.multiply(transform, gltf2_blender_math.to_yup())
local_transform = bone.bone.matrix_local
transform = gltf2_blender_math.multiply(transform, local_transform)
values = []
for keyframe in keyframes:
# Transform the data and extract
value = gltf2_blender_math.transform(keyframe.value, target_datapath, transform)
if isYup and not blender_object.type == "ARMATURE":
value = gltf2_blender_math.swizzle_yup(value, target_datapath)
keyframe_value = gltf2_blender_math.mathutils_to_gltf(value)
if keyframe.in_tangent is not None:
in_tangent = gltf2_blender_math.transform(keyframe.in_tangent, target_datapath, transform)
if isYup and not blender_object.type == "ARMATURE":
in_tangent = gltf2_blender_math.swizzle_yup(in_tangent, target_datapath)
keyframe_value = gltf2_blender_math.mathutils_to_gltf(in_tangent) + keyframe_value
if keyframe.out_tangent is not None:
out_tangent = gltf2_blender_math.transform(keyframe.out_tangent, target_datapath, transform)
if isYup and not blender_object.type == "ARMATURE":
out_tangent = gltf2_blender_math.swizzle_yup(out_tangent, target_datapath)
keyframe_value = keyframe_value + gltf2_blender_math.mathutils_to_gltf(out_tangent)
values += keyframe_value
component_type = gltf2_io_constants.ComponentType.Float
if get_target_property_name(target_datapath) == "value":
# channels with 'weight' targets must have scalar accessors
data_type = gltf2_io_constants.DataType.Scalar
else:
data_type = gltf2_io_constants.DataType.vec_type_from_num(len(keyframes[0].value))
return gltf2_io.Accessor(
buffer_view=gltf2_io_binary_data.BinaryData.from_list(values, component_type),
byte_offset=None,
component_type=component_type,
count=len(values) // gltf2_io_constants.DataType.num_elements(data_type),
extensions=None,
extras=None,
max=None,
min=None,
name=None,
normalized=None,
sparse=None,
type=data_type
)
|
