Newer
Older
# ##### BEGIN GPL LICENSE BLOCK #####
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
# ##### END GPL LICENSE BLOCK #####
# <pep8 compliant>
# Script copyright (C) Campbell Barton, Bastien Montagne
import math
Bastien Montagne
committed
import time
from collections import namedtuple, OrderedDict
from collections.abc import Iterable
from itertools import zip_longest, chain
import bpy
import bpy_extras
from bpy.types import Object, Bone, PoseBone, DupliObject
Bastien Montagne
committed
from mathutils import Vector, Matrix
from . import encode_bin, data_types
# "Constants"
FBX_VERSION = 7400
FBX_HEADER_VERSION = 1003
FBX_SCENEINFO_VERSION = 100
FBX_TEMPLATES_VERSION = 100
FBX_MODELS_VERSION = 232
FBX_GEOMETRY_VERSION = 124
# Revert back normals to 101 (simple 3D values) for now, 102 (4D + weights) seems not well supported by most apps
# currently, apart from some AD products.
FBX_GEOMETRY_NORMAL_VERSION = 101
FBX_GEOMETRY_BINORMAL_VERSION = 101
FBX_GEOMETRY_TANGENT_VERSION = 101
FBX_GEOMETRY_SMOOTHING_VERSION = 102
FBX_GEOMETRY_VCOLOR_VERSION = 101
FBX_GEOMETRY_UV_VERSION = 101
FBX_GEOMETRY_MATERIAL_VERSION = 101
FBX_GEOMETRY_LAYER_VERSION = 100
FBX_GEOMETRY_SHAPE_VERSION = 100
FBX_DEFORMER_SHAPE_VERSION = 100
FBX_DEFORMER_SHAPECHANNEL_VERSION = 100
FBX_POSE_BIND_VERSION = 100
FBX_DEFORMER_SKIN_VERSION = 101
FBX_DEFORMER_CLUSTER_VERSION = 100
FBX_MATERIAL_VERSION = 102
FBX_TEXTURE_VERSION = 202
FBX_ANIM_KEY_VERSION = 4008
FBX_NAME_CLASS_SEP = b"\x00\x01"
FBX_ANIM_PROPSGROUP_NAME = "d"
FBX_KTIME = 46186158000 # This is the number of "ktimes" in one second (yep, precision over the nanosecond...)
MAT_CONVERT_LAMP = Matrix.Rotation(math.pi / 2.0, 4, 'X') # Blender is -Z, FBX is -Y.
MAT_CONVERT_CAMERA = Matrix.Rotation(math.pi / 2.0, 4, 'Y') # Blender is -Z, FBX is +X.
# XXX I can't get this working :(
# MAT_CONVERT_BONE = Matrix.Rotation(math.pi / 2.0, 4, 'Z') # Blender is +Y, FBX is -X.
MAT_CONVERT_BONE = Matrix()
BLENDER_OTHER_OBJECT_TYPES = {'CURVE', 'SURFACE', 'FONT', 'META'}
BLENDER_OBJECT_TYPES_MESHLIKE = {'MESH'} | BLENDER_OTHER_OBJECT_TYPES
# Lamps.
FBX_LIGHT_TYPES = {
'POINT': 0, # Point.
'SUN': 1, # Directional.
'SPOT': 2, # Spot.
'HEMI': 1, # Directional.
'AREA': 3, # Area.
}
FBX_LIGHT_DECAY_TYPES = {
'CONSTANT': 0, # None.
'INVERSE_LINEAR': 1, # Linear.
'INVERSE_SQUARE': 2, # Quadratic.
'CUSTOM_CURVE': 2, # Quadratic.
'LINEAR_QUADRATIC_WEIGHTED': 2, # Quadratic.
}
RIGHT_HAND_AXES = {
Bastien Montagne
committed
# Up, Forward -> FBX values (tuples of (axis, sign), Up, Front, Coord).
( 'X', '-Y'): ((0, 1), (1, 1), (2, 1)),
( 'X', 'Y'): ((0, 1), (1, -1), (2, -1)),
( 'X', '-Z'): ((0, 1), (2, 1), (1, -1)),
( 'X', 'Z'): ((0, 1), (2, -1), (1, 1)),
('-X', '-Y'): ((0, -1), (1, 1), (2, -1)),
('-X', 'Y'): ((0, -1), (1, -1), (2, 1)),
('-X', '-Z'): ((0, -1), (2, 1), (1, 1)),
('-X', 'Z'): ((0, -1), (2, -1), (1, -1)),
( 'Y', '-X'): ((1, 1), (0, 1), (2, -1)),
( 'Y', 'X'): ((1, 1), (0, -1), (2, 1)),
( 'Y', '-Z'): ((1, 1), (2, 1), (0, 1)),
( 'Y', 'Z'): ((1, 1), (2, -1), (0, -1)),
('-Y', '-X'): ((1, -1), (0, 1), (2, 1)),
('-Y', 'X'): ((1, -1), (0, -1), (2, -1)),
('-Y', '-Z'): ((1, -1), (2, 1), (0, -1)),
('-Y', 'Z'): ((1, -1), (2, -1), (0, 1)),
( 'Z', '-X'): ((2, 1), (0, 1), (1, 1)),
( 'Z', 'X'): ((2, 1), (0, -1), (1, -1)),
( 'Z', '-Y'): ((2, 1), (1, 1), (0, -1)),
( 'Z', 'Y'): ((2, 1), (1, -1), (0, 1)), # Blender system!
('-Z', '-X'): ((2, -1), (0, 1), (1, -1)),
('-Z', 'X'): ((2, -1), (0, -1), (1, 1)),
('-Z', '-Y'): ((2, -1), (1, 1), (0, 1)),
('-Z', 'Y'): ((2, -1), (1, -1), (0, -1)),
}
FBX_FRAMERATES = (
(-1.0, 14), # Custom framerate.
(120.0, 1),
(100.0, 2),
(60.0, 3),
(50.0, 4),
(48.0, 5),
(30.0, 6), # BW NTSC.
(30.0 / 1.001, 9), # Color NTSC.
(25.0, 10),
(24.0, 11),
(24.0 / 1.001, 13),
(96.0, 15),
(72.0, 16),
(60.0 / 1.001, 17),
)
Bastien Montagne
committed
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
DO_PERFMON = True
if DO_PERFMON:
class PerfMon():
def __init__(self):
self.level = -1
self.ref_time = []
def level_up(self, message=""):
self.level += 1
self.ref_time.append(None)
if message:
print("\t" * self.level, message, sep="")
def level_down(self, message=""):
if not self.ref_time:
if message:
print(message)
return
ref_time = self.ref_time[self.level]
print("\t" * self.level,
"\tDone (%f sec)\n" % ((time.process_time() - ref_time) if ref_time is not None else 0.0),
sep="")
if message:
print("\t" * self.level, message, sep="")
del self.ref_time[self.level]
self.level -= 1
def step(self, message=""):
ref_time = self.ref_time[self.level]
curr_time = time.process_time()
if ref_time is not None:
print("\t" * self.level, "\tDone (%f sec)\n" % (curr_time - ref_time), sep="")
self.ref_time[self.level] = curr_time
print("\t" * self.level, message, sep="")
else:
class PerfMon():
def __init__(self):
pass
def level_up(self, message=""):
pass
def level_down(self, message=""):
pass
def step(self, message=""):
pass
# Scale/unit mess. FBX can store the 'reference' unit of a file in its UnitScaleFactor property
# (1.0 meaning centimeter, afaik). We use that to reflect user's default unit as set in Blender with scale_length.
# However, we always get values in BU (i.e. meters), so we have to reverse-apply that scale in global matrix...
# Note that when no default unit is available, we assume 'meters' (and hence scale by 100).
def units_blender_to_fbx_factor(scene):
return 100.0 if (scene.unit_settings.system == 'NONE') else (100.0 * scene.unit_settings.scale_length)
# Note: this could be in a utility (math.units e.g.)...
UNITS = {
"meter": 1.0, # Ref unit!
"kilometer": 0.001,
"millimeter": 1000.0,
"foot": 1.0 / 0.3048,
"inch": 1.0 / 0.0254,
"turn": 1.0, # Ref unit!
"degree": 360.0,
"radian": math.pi * 2.0,
"second": 1.0, # Ref unit!
"ktime": FBX_KTIME,
}
def units_convertor(u_from, u_to):
"""Return a convertor between specified units."""
conv = UNITS[u_to] / UNITS[u_from]
def units_convertor_iter(u_from, u_to):
"""Return an iterable convertor between specified units."""
conv = units_convertor(u_from, u_to)
def convertor(it):
for v in it:
yield(conv(v))
"""Concatenate matrix's columns into a single, flat tuple"""
# blender matrix is row major, fbx is col major so transpose on write
return tuple(f for v in mat.transposed() for f in v)
def array_to_matrix4(arr):
"""Convert a single 16-len tuple into a valid 4D Blender matrix"""
# Blender matrix is row major, fbx is col major so transpose on read
return Matrix(tuple(zip(*[iter(arr)]*4))).transposed()
def similar_values(v1, v2, e=1e-6):
"""Return True if v1 and v2 are nearly the same."""
if v1 == v2:
return True
return ((abs(v1 - v2) / max(abs(v1), abs(v2))) <= e)
def similar_values_iter(v1, v2, e=1e-6):
"""Return True if iterables v1 and v2 are nearly the same."""
if v1 == v2:
return True
for v1, v2 in zip(v1, v2):
if (v1 != v2) and ((abs(v1 - v2) / max(abs(v1), abs(v2))) > e):
Bastien Montagne
committed
def vcos_transformed_gen(raw_cos, m=None):
# Note: we could most likely get much better performances with numpy, but will leave this as TODO for now.
gen = zip(*(iter(raw_cos),) * 3)
return gen if m is None else (m * Vector(v) for v in gen)
def nors_transformed_gen(raw_nors, m=None):
# Great, now normals are also expected 4D!
# XXX Back to 3D normals for now!
# gen = zip(*(iter(raw_nors),) * 3 + (_infinite_gen(1.0),))
gen = zip(*(iter(raw_nors),) * 3)
return gen if m is None else (m * Vector(v) for v in gen)
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
# ID class (mere int).
class UUID(int):
pass
# UIDs storage.
_keys_to_uuids = {}
_uuids_to_keys = {}
def _key_to_uuid(uuids, key):
# TODO: Check this is robust enough for our needs!
# Note: We assume we have already checked the related key wasn't yet in _keys_to_uids!
# As int64 is signed in FBX, we keep uids below 2**63...
if isinstance(key, int) and 0 <= key < 2**63:
# We can use value directly as id!
uuid = key
else:
uuid = hash(key)
if uuid < 0:
uuid = -uuid
if uuid >= 2**63:
uuid //= 2
# Try to make our uid shorter!
if uuid > int(1e9):
t_uuid = uuid % int(1e9)
if t_uuid not in uuids:
uuid = t_uuid
# Make sure our uuid *is* unique.
if uuid in uuids:
inc = 1 if uuid < 2**62 else -1
while uuid in uuids:
uuid += inc
if 0 > uuid >= 2**63:
# Note that this is more that unlikely, but does not harm anyway...
raise ValueError("Unable to generate an UUID for key {}".format(key))
return UUID(uuid)
def get_fbx_uuid_from_key(key):
"""
Return an UUID for given key, which is assumed hasable.
"""
uuid = _keys_to_uuids.get(key, None)
if uuid is None:
uuid = _key_to_uuid(_uuids_to_keys, key)
_keys_to_uuids[key] = uuid
_uuids_to_keys[uuid] = key
return uuid
# XXX Not sure we'll actually need this one?
def get_key_from_fbx_uuid(uuid):
"""
Return the key which generated this uid.
"""
assert(uuid.__class__ == UUID)
return _uuids_to_keys.get(uuid, None)
# Blender-specific key generators
Bastien Montagne
committed
def get_bid_name(bid):
library = getattr(bid, "library", None)
if library is not None:
return "%s_L_%s" % (bid.name, library.name)
else:
return bid.name
Bastien Montagne
committed
def get_blenderID_key(bid):
if isinstance(bid, Iterable):
Bastien Montagne
committed
return "|".join("B" + e.rna_type.name + "#" + get_bid_name(e) for e in bid)
Bastien Montagne
committed
return "B" + bid.rna_type.name + "#" + get_bid_name(bid)
def get_blenderID_name(bid):
if isinstance(bid, Iterable):
Bastien Montagne
committed
return "|".join(get_bid_name(e) for e in bid)
Bastien Montagne
committed
return get_bid_name(bid)
def get_blender_empty_key(obj):
"""Return bone's keys (Model and NodeAttribute)."""
return "|".join((get_blenderID_key(obj), "Empty"))
def get_blender_mesh_shape_key(me):
"""Return main shape deformer's key."""
return "|".join((get_blenderID_key(me), "Shape"))
def get_blender_mesh_shape_channel_key(me, shape):
"""Return shape channel and geometry shape keys."""
return ("|".join((get_blenderID_key(me), "Shape", get_blenderID_key(shape))),
"|".join((get_blenderID_key(me), "Geometry", get_blenderID_key(shape))))
def get_blender_bone_key(armature, bone):
"""Return bone's keys (Model and NodeAttribute)."""
return "|".join((get_blenderID_key((armature, bone)), "Data"))
def get_blender_bindpose_key(obj, mesh):
"""Return object's bindpose key."""
return "|".join((get_blenderID_key(obj), get_blenderID_key(mesh), "BindPose"))
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
def get_blender_armature_skin_key(armature, mesh):
"""Return armature's skin key."""
return "|".join((get_blenderID_key(armature), get_blenderID_key(mesh), "DeformerSkin"))
def get_blender_bone_cluster_key(armature, mesh, bone):
"""Return bone's cluster key."""
return "|".join((get_blenderID_key(armature), get_blenderID_key(mesh),
get_blenderID_key(bone), "SubDeformerCluster"))
def get_blender_anim_id_base(scene, ref_id):
if ref_id is not None:
return get_blenderID_key(scene) + "|" + get_blenderID_key(ref_id)
else:
return get_blenderID_key(scene)
def get_blender_anim_stack_key(scene, ref_id):
"""Return single anim stack key."""
return get_blender_anim_id_base(scene, ref_id) + "|AnimStack"
def get_blender_anim_layer_key(scene, ref_id):
"""Return ID's anim layer key."""
return get_blender_anim_id_base(scene, ref_id) + "|AnimLayer"
def get_blender_anim_curve_node_key(scene, ref_id, obj_key, fbx_prop_name):
"""Return (stack/layer, ID, fbxprop) curve node key."""
return "|".join((get_blender_anim_id_base(scene, ref_id), obj_key, fbx_prop_name, "AnimCurveNode"))
def get_blender_anim_curve_key(scene, ref_id, obj_key, fbx_prop_name, fbx_prop_item_name):
"""Return (stack/layer, ID, fbxprop, item) curve key."""
return "|".join((get_blender_anim_id_base(scene, ref_id), obj_key, fbx_prop_name,
fbx_prop_item_name, "AnimCurve"))
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
# Note: elem may be None, in this case the element is not added to any parent.
def elem_empty(elem, name):
sub_elem = encode_bin.FBXElem(name)
if elem is not None:
elem.elems.append(sub_elem)
return sub_elem
def _elem_data_single(elem, name, value, func_name):
sub_elem = elem_empty(elem, name)
getattr(sub_elem, func_name)(value)
return sub_elem
def _elem_data_vec(elem, name, value, func_name):
sub_elem = elem_empty(elem, name)
func = getattr(sub_elem, func_name)
for v in value:
func(v)
return sub_elem
def elem_data_single_bool(elem, name, value):
return _elem_data_single(elem, name, value, "add_bool")
def elem_data_single_int16(elem, name, value):
return _elem_data_single(elem, name, value, "add_int16")
def elem_data_single_int32(elem, name, value):
return _elem_data_single(elem, name, value, "add_int32")
def elem_data_single_int64(elem, name, value):
return _elem_data_single(elem, name, value, "add_int64")
def elem_data_single_float32(elem, name, value):
return _elem_data_single(elem, name, value, "add_float32")
def elem_data_single_float64(elem, name, value):
return _elem_data_single(elem, name, value, "add_float64")
def elem_data_single_bytes(elem, name, value):
return _elem_data_single(elem, name, value, "add_bytes")
def elem_data_single_string(elem, name, value):
return _elem_data_single(elem, name, value, "add_string")
def elem_data_single_string_unicode(elem, name, value):
return _elem_data_single(elem, name, value, "add_string_unicode")
def elem_data_single_bool_array(elem, name, value):
return _elem_data_single(elem, name, value, "add_bool_array")
def elem_data_single_int32_array(elem, name, value):
return _elem_data_single(elem, name, value, "add_int32_array")
def elem_data_single_int64_array(elem, name, value):
return _elem_data_single(elem, name, value, "add_int64_array")
def elem_data_single_float32_array(elem, name, value):
return _elem_data_single(elem, name, value, "add_float32_array")
def elem_data_single_float64_array(elem, name, value):
return _elem_data_single(elem, name, value, "add_float64_array")
def elem_data_single_byte_array(elem, name, value):
return _elem_data_single(elem, name, value, "add_byte_array")
def elem_data_vec_float64(elem, name, value):
return _elem_data_vec(elem, name, value, "add_float64")
# ##### Generators for standard FBXProperties70 properties. #####
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
def elem_properties(elem):
return elem_empty(elem, b"Properties70")
# Properties definitions, format: (b"type_1", b"label(???)", "name_set_value_1", "name_set_value_2", ...)
# XXX Looks like there can be various variations of formats here... Will have to be checked ultimately!
# Also, those "custom" types like 'FieldOfView' or 'Lcl Translation' are pure nonsense,
# these are just Vector3D ultimately... *sigh* (again).
FBX_PROPERTIES_DEFINITIONS = {
# Generic types.
"p_bool": (b"bool", b"", "add_int32"), # Yes, int32 for a bool (and they do have a core bool type)!!!
"p_integer": (b"int", b"Integer", "add_int32"),
"p_ulonglong": (b"ULongLong", b"", "add_int64"),
"p_double": (b"double", b"Number", "add_float64"), # Non-animatable?
"p_number": (b"Number", b"", "add_float64"), # Animatable-only?
"p_enum": (b"enum", b"", "add_int32"),
"p_vector_3d": (b"Vector3D", b"Vector", "add_float64", "add_float64", "add_float64"), # Non-animatable?
"p_vector": (b"Vector", b"", "add_float64", "add_float64", "add_float64"), # Animatable-only?
"p_color_rgb": (b"ColorRGB", b"Color", "add_float64", "add_float64", "add_float64"), # Non-animatable?
"p_color": (b"Color", b"", "add_float64", "add_float64", "add_float64"), # Animatable-only?
"p_string": (b"KString", b"", "add_string_unicode"),
"p_string_url": (b"KString", b"Url", "add_string_unicode"),
"p_timestamp": (b"KTime", b"Time", "add_int64"),
"p_datetime": (b"DateTime", b"", "add_string_unicode"),
# Special types.
"p_object": (b"object", b""), # XXX Check this! No value for this prop??? Would really like to know how it works!
"p_compound": (b"Compound", b""),
# Specific types (sic).
"p_lcl_translation": (b"Lcl Translation", b"", "add_float64", "add_float64", "add_float64"),
"p_lcl_rotation": (b"Lcl Rotation", b"", "add_float64", "add_float64", "add_float64"),
"p_lcl_scaling": (b"Lcl Scaling", b"", "add_float64", "add_float64", "add_float64"),
"p_visibility": (b"Visibility", b"", "add_float64"),
"p_visibility_inheritance": (b"Visibility Inheritance", b"", "add_int32"),
"p_roll": (b"Roll", b"", "add_float64"),
"p_opticalcenterx": (b"OpticalCenterX", b"", "add_float64"),
"p_opticalcentery": (b"OpticalCenterY", b"", "add_float64"),
"p_fov": (b"FieldOfView", b"", "add_float64"),
"p_fov_x": (b"FieldOfViewX", b"", "add_float64"),
"p_fov_y": (b"FieldOfViewY", b"", "add_float64"),
}
def _elem_props_set(elem, ptype, name, value, flags):
p = elem_data_single_string(elem, b"P", name)
for t in ptype[:2]:
p.add_string(t)
p.add_string(flags)
if len(ptype) == 3:
getattr(p, ptype[2])(value)
elif len(ptype) > 3:
# We assume value is iterable, else it's a bug!
for callback, val in zip(ptype[2:], value):
getattr(p, callback)(val)
Bastien Montagne
committed
def _elem_props_flags(animatable, animated, custom):
# XXX: There are way more flags, see
# http://help.autodesk.com/view/FBX/2015/ENU/?guid=__cpp_ref_class_fbx_property_flags_html
# Unfortunately, as usual, no doc at all about their 'translation' in actual FBX file format.
# Curse you-know-who.
if animatable:
if animated:
if custom:
return b"A+U"
return b"A+"
if custom:
return b"AU"
Bastien Montagne
committed
if custom:
return b"U"
return b""
Bastien Montagne
committed
def elem_props_set(elem, ptype, name, value=None, animatable=False, animated=False, custom=False):
ptype = FBX_PROPERTIES_DEFINITIONS[ptype]
Bastien Montagne
committed
_elem_props_set(elem, ptype, name, value, _elem_props_flags(animatable, animated, custom))
def elem_props_compound(elem, cmpd_name, custom=False):
Bastien Montagne
committed
def _setter(ptype, name, value, animatable=False, animated=False, custom=False):
name = cmpd_name + b"|" + name
Bastien Montagne
committed
elem_props_set(elem, ptype, name, value, animatable=animatable, animated=animated, custom=custom)
elem_props_set(elem, "p_compound", cmpd_name, custom=custom)
return _setter
def elem_props_template_init(templates, template_type):
"""
Init a writing template of given type, for *one* element's properties.
"""
ret = OrderedDict()
tmpl = templates.get(template_type)
if tmpl is not None:
written = tmpl.written[0]
props = tmpl.properties
ret = OrderedDict((name, [val, ptype, anim, written]) for name, (val, ptype, anim) in props.items())
Loading
Loading full blame...