def test_default(self):
prefs = utils.get_preferences()
prefs.gamemtl_file = os.path.join(self.relpath(), 'gamemtl.xr')
# Import
bpy.ops.xray_import.level(filepath=os.path.join(
self.relpath(), 'test_fmt_level', 'level'
))
# Export
level_obj = bpy.data.objects['test_fmt_level']
if bpy.app.version >= (2, 80, 0):
level_obj.select_set(True)
else:
level_obj.select = True
directory = self.outpath('test_fmt_level_export')
if not os.path.exists(directory):
os.makedirs(directory)
utils.set_active_object(level_obj)
bpy.ops.xray_export.level(directory=directory)
# Assert
self.assertReportsNotContains('WARNING')
def test_import_without_bone_props(self):
# import mesh and armature
bpy.ops.xray_import.object(
directory=self.relpath(),
files=[{
'name': 'test_fmt_bones.object'
}],
)
arm_obj = bpy.data.objects['test_fmt_bones.object']
utils.set_active_object(arm_obj)
# remove "bone or parts" (bone groups)
for bone_group in arm_obj.pose.bone_groups:
arm_obj.pose.bone_groups.remove(bone_group)
# Act import
bpy.ops.xray_import.bones(directory=self.relpath(),
files=[{
'name': 'test_fmt.bones'
}],
import_bone_parts=True,
import_bone_properties=False)
# Assert
self.assertReportsNotContains('WARNING')
def _prepare_animation():
arm = bpy.data.armatures.new('test')
obj = bpy.data.objects.new('test', arm)
utils.link_object(obj)
utils.set_active_object(obj)
bpy.ops.object.mode_set(mode='EDIT')
try:
bone = arm.edit_bones.new('bone')
bone.head.z = 0.5
cbone = arm.edit_bones.new('cbone')
cbone.parent = bone
cbone.head.z = 0.5
finally:
bpy.ops.object.mode_set(mode='OBJECT')
pbone = obj.pose.bones['bone']
pbone.keyframe_insert('location', frame=1, group='bone')
pbone.location = (1, 2, 3)
pbone.keyframe_insert('location', frame=5, group='bone')
motion = obj.xray.motions_collection.add()
motion.name = bpy.data.actions[0].name
bmesh = utils.create_bmesh((
(0, 0, 0),
(-1, -1, 0), (+1, -1, 0), (+1, +1, 0), (-1, +1, 0),
), ((0, 1, 2), (0, 2, 3), (0, 3, 4), (0, 4, 1)), True)
obj_me = utils.create_object(bmesh, True)
group = obj_me.vertex_groups.new(name='bone')
group.add(range(len(obj_me.data.vertices)), 1, 'REPLACE')
obj_me.parent = obj
obj_me.xray.isroot = False
return obj
def _create_armature(name, connected=False, rigid=False):
arm = bpy.data.armatures.new(name)
obj = bpy.data.objects.new(name, arm)
utils.link_object(obj)
utils.set_active_object(obj)
children = []
with using_mode(mode='EDIT'):
root = arm.edit_bones.new('root')
root.tail = (0, 0, 1)
child1 = arm.edit_bones.new('child1')
child1.parent = root
child1.head = root.tail if connected else (1, 0, 0)
child1.tail = (0, 1, 1)
children.append(child1.name)
child2 = arm.edit_bones.new('child2')
child2.parent = root
child2.head = root.tail if connected else (1, 0, 0)
child2.tail = (1, 0, 1)
children.append(child2.name)
with using_mode(mode='OBJECT'):
ikjoint_type = '0' if rigid else '1'
for child_name in children:
arm.bones[child_name].xray.ikjoint.type = ikjoint_type
return obj.data
def test_import_general(self):
# import mesh and armature
bpy.ops.xray_import.object(
directory=self.relpath(),
files=[{
'name': 'test_fmt_omf.object'
}],
)
arm_obj = bpy.data.objects['test_fmt_omf.object']
utils.set_active_object(arm_obj)
# import motions
bpy.ops.xray_import.omf(directory=self.relpath(),
files=[{
'name': 'test_fmt.omf'
}],
import_motions=True,
import_bone_parts=True,
add_actions_to_motion_list=True)
# export motions
bpy.ops.xray_export.omf(filepath=self.outpath('test.omf'),
export_mode='OVERWRITE',
export_motions=True,
export_bone_parts=True)
bpy.ops.xray_export.omf(filepath=self.outpath('test.omf'),
export_mode='REPLACE',
export_motions=True,
export_bone_parts=True)
bpy.ops.xray_export.omf(filepath=self.outpath('test.omf'),
export_mode='ADD',
export_motions=True,
export_bone_parts=True)
def test_obsolete_bones(self):
# Arrange
objs = self._create_objects()
obj = _create_armature(objs[0])
utils.set_active_object(obj)
arm = obj.data
arm.bones['tbone'].xray.shape.type = '2'
arm.bones['tbone'].xray.shape.sph_rad = 1
# Act
bpy.ops.export_object.xray_objects(
objects='tobj',
directory=self.outpath(),
texture_name_from_image_path=False,
export_motions=False,
)
# Assert
self.assertOutputFiles({
'tobj.object',
})
self.assertReportsContains(
'WARNING',
re.compile('Bone edited with a different version of this plugin'))
def test_import_has_no_bone(self):
# import mesh and armature
bpy.ops.xray_import.object(
directory=self.relpath(),
files=[{
'name': 'test_fmt_bones.object'
}],
)
arm_obj = bpy.data.objects['test_fmt_bones.object']
arm_obj.data.bones[0].name = 'test'
utils.set_active_object(arm_obj)
# Act import
bpy.ops.xray_import.bones(directory=self.relpath(),
files=[{
'name': 'test_fmt.bones'
}],
import_bone_parts=True,
import_bone_properties=True)
# Assert
self.assertReportsContains('WARNING',
re.compile('Armature object has no bone'))
self.assertReportsContains(
'WARNING', re.compile('Partition contains missing bone'))
def test_export_skeletal_object(self):
# Arrange
objs = self._create_objects()
obj = _create_armature((objs[0], ))
obj.name = 'skeletal_object_soc_format'
obj.xray.lodref = 'test lod reference'
obj.xray.userdata = 'test user data'
for ref_index in range(3):
ref = obj.xray.motionrefs_collection.add()
ref.name = 'motion_reference_' + str(ref_index)
utils.set_active_object(obj)
# Act
bpy.ops.xray_export.object(
objects='skeletal_object_soc_format', directory=self.outpath(),
texture_name_from_image_path=False,
export_motions=False
)
obj.name = 'skeletal_object_cop_format'
bpy.ops.xray_export.object(
objects='skeletal_object_cop_format', directory=self.outpath(),
texture_name_from_image_path=False,
export_motions=False,
fmt_version='cscop'
)
# Assert
self.assertOutputFiles({
'skeletal_object_soc_format.object',
'skeletal_object_cop_format.object'
})
self.assertReportsNotContains()
def _create_armature(self, bone_name):
arm = bpy.data.armatures.new('tarm')
obj = bpy.data.objects.new('tobj', arm)
utils.link_object(obj)
utils.set_active_object(obj)
bpy.ops.object.mode_set(mode='EDIT')
try:
bone = arm.edit_bones.new(bone_name)
bone.tail.y = 1
finally:
bpy.ops.object.mode_set(mode='OBJECT')
def test_import_sg_maya(self):
# Arrange
arm = bpy.data.armatures.new('test')
obj = bpy.data.objects.new('test', arm)
utils.link_object(obj)
utils.set_active_object(obj)
bpy.ops.object.mode_set(mode='EDIT')
try:
bone = arm.edit_bones.new('non-exp')
bone.head.z = 0.5
bone = arm.edit_bones.new('exp')
bone.head.z = 0.5
finally:
bpy.ops.object.mode_set(mode='OBJECT')
arm.bones['non-exp'].xray.exportable = False
bmesh = utils.create_bmesh((
(0, 0, 0),
(-1, -1, 0),
(+1, -1, 0),
(+1, +1, 0),
(-1, +1, 0),
), ((0, 1, 2), (0, 2, 3), (0, 3, 4), (0, 4, 1)), True)
obj_me = utils.create_object(bmesh, True)
obj_me.parent = obj
obj_me.xray.isroot = False
group = obj_me.vertex_groups.new(name='exp')
group.add(range(len(obj_me.data.vertices)), 1, 'REPLACE')
# Act
bpy.ops.xray_export.object(
objects=obj.name,
directory=self.outpath(),
texture_name_from_image_path=False,
export_motions=False,
)
# Assert
bpy.ops.xray_import.object(
directory=self.outpath(),
files=[{
'name': 'test.object'
}],
)
obj_arm = bpy.data.objects[-1]
self.assertEqual(obj_arm.type, 'ARMATURE')
self.assertEqual(obj_arm.xray.isroot, True)
imp_arm = bpy.data.armatures[1]
self.assertEqual(len(imp_arm.bones), 1)
def test_change_fake_user(self):
for index in range(3):
name = str(index)
me = bpy.data.meshes.new(name)
obj = bpy.data.objects.new(name, me)
utils.link_object(obj)
utils.select_object(obj)
mat = bpy.data.materials.new(name)
me.materials.append(mat)
img = bpy.data.images.new(name, 0, 0)
img.source = 'FILE'
mat.use_nodes = True
img_node = mat.node_tree.nodes.new('ShaderNodeTexImage')
img_node.image = img
arm = bpy.data.armatures.new(name)
obj = bpy.data.objects.new(name + '_arm', arm)
utils.link_object(obj)
utils.select_object(obj)
act = bpy.data.actions.new(name)
motion = obj.xray.motions_collection.add()
motion.name = act.name
utils.set_active_object(bpy.data.objects[0])
modes = (
'ACTIVE_OBJECT',
'SELECTED_OBJECTS',
'ALL_OBJECTS',
'ALL_DATA'
)
data = (
'OBJECTS',
'MESHES',
'MATERIALS',
'TEXTURES',
'IMAGES',
'ARMATURES',
'ACTIONS',
'ALL'
)
fake_users = ('TRUE', 'FALSE', 'INVERT')
for mode in modes:
for data_ in data:
for fake_user in fake_users:
bpy.ops.io_scene_xray.change_fake_user(
mode=mode,
data={data_, },
fake_user=fake_user
)
def test_batch_import(self):
# Act
bpy.ops.xray_import.details(directory=self.relpath(),
files=[{
'name': 'test_fmt_v2.details'
}, {
'name': 'test_fmt_v3.details'
}],
details_format='builds_1233-1558')
# pack images
utils.set_active_object(bpy.data.objects['test_fmt_v2.details'])
bpy.ops.io_scene_xray.pack_details_images()
utils.set_active_object(bpy.data.objects['test_fmt_v3.details'])
bpy.ops.io_scene_xray.pack_details_images()
# Assert
self.assertReportsNotContains('WARNING')
def test_init_version_and_shaders(self):
# Arrange
version = utl.plugin_version_number()
obj = bpy.data.objects.new('', None)
obj.xray.flags_custom_type = 'st'
utils.link_object(obj)
utils.set_active_object(obj)
mat = bpy.data.materials.new('')
# Act
handlers.scene_update_post(bpy.context.scene)
# Assert
self.assertEqual(mat.xray.version, version)
self.assertEqual(mat.xray.eshader, 'default')
def test_init_shaders_dynamic(self):
# Arrange
version = utl.plugin_version_number()
obj = bpy.data.objects.new('', None)
obj.xray.flags_custom_type = 'dy'
utils.link_object(obj)
utils.set_active_object(obj)
mat = bpy.data.materials.new('')
# Act
plugin.scene_update_post(bpy.context.scene)
# Assert
self.assertEqual(mat.xray.version, version)
self.assertEqual(mat.xray.eshader, 'models\\model')
def test_export_with_empty(self):
# Arrange
root = bpy.data.objects.new('empty', None)
utils.link_object(root)
objs = self._create_objects()
obj = _create_armature(objs[0])
obj.parent = root
utils.set_active_object(root)
# Act
bpy.ops.xray_export.object(object='empty',
filepath=self.outpath('test.object'),
texture_name_from_image_path=False)
# Assert
self.assertOutputFiles({'test.object'})
def test_copy_paste_action_settings(self):
# copy
act = bpy.data.actions.new('test_act_copy')
arm = bpy.data.armatures.new('test_arm_copy')
obj = bpy.data.objects.new('test_obj_copy', arm)
obj.animation_data_create().action = act
utils.link_object(obj)
utils.select_object(obj)
utils.set_active_object(obj)
bpy.ops.io_scene_xray.copy_action_settings()
# paste
act = bpy.data.actions.new('test_act_paste')
arm = bpy.data.armatures.new('test_arm_paste')
obj = bpy.data.objects.new('test_obj_paste', arm)
obj.animation_data_create().action = act
utils.link_object(obj)
utils.select_object(obj)
utils.set_active_object(obj)
bpy.ops.io_scene_xray.paste_action_settings()
def test_create(self):
operator = bpy.ops.io_scene_xray.create_fake_bones
utils.set_active_object(None)
self.assertFalse(operator.poll(), msg='no armature')
arm = _create_armature('normal')
self.assertTrue(operator.poll(), msg='an armature')
operator()
self.assertEqual(_fake_names(arm.bones), ['child1.fake', 'child2.fake'], msg='created')
self.assertReportsContains('INFO', re.compile('Created 2 fake bones'))
arm = _create_armature('rigid', rigid=True)
operator()
self.assertEqual(_fake_names(arm.bones), [], msg='skip rigid')
self.assertReportsContains('INFO', re.compile('Created 0 fake bones'))
arm = _create_armature('connected', connected=True)
operator()
self.assertEqual(_fake_names(arm.bones), [], msg='skip connected')
def test_import_replace_bone_groups(self):
# import mesh and armature
bpy.ops.xray_import.object(
directory=self.relpath(),
files=[{
'name': 'test_fmt_bones.object'
}],
)
arm_obj = bpy.data.objects['test_fmt_bones.object']
utils.set_active_object(arm_obj)
# Act import
bpy.ops.xray_import.bones(directory=self.relpath(),
files=[{
'name': 'test_fmt.bones'
}],
import_bone_parts=True,
import_bone_properties=False)
# Assert
self.assertReportsNotContains('WARNING')
def _create_armature(target):
arm = bpy.data.armatures.new('tarm')
obj = bpy.data.objects.new('tobj', arm)
utils.link_object(obj)
utils.set_active_object(obj)
bpy.ops.object.mode_set(mode='EDIT')
try:
bone = arm.edit_bones.new('tbone')
bone.tail.y = 1
finally:
bpy.ops.object.mode_set(mode='OBJECT')
target.modifiers.new(name='Armature', type='ARMATURE').object = obj
target.parent = obj
grp = target.vertex_groups.new(name='tbone')
vertices_count = len(target.data.vertices)
grp.add(range(vertices_count), 1, 'REPLACE')
grp = target.vertex_groups.new(name=io_scene_xray.utils.BAD_VTX_GROUP_NAME)
grp.add([vertices_count], 1, 'REPLACE')
return obj
def test_merge_objects(self):
# Arrange
objs = self._create_objects()
arm_obj = _create_armature(objs)
utils.set_active_object(arm_obj)
objs[0].modifiers.new('subsurf', 'SUBSURF')
# Act
bpy.ops.xray_export.object(
objects='tobj', directory=self.outpath(),
texture_name_from_image_path=False,
export_motions=False,
)
# Assert
self.assertOutputFiles({
'tobj.object',
})
self.assertReportsContains(
'WARNING',
re.compile('Mesh-objects have been merged')
)
def test_import_not_have_bone_parts(self):
# import mesh and armature
bpy.ops.xray_import.object(
directory=self.relpath(),
files=[{
'name': 'test_fmt_bones.object'
}],
)
arm_obj = bpy.data.objects['test_fmt_bones.object']
utils.set_active_object(arm_obj)
# Act import
bpy.ops.xray_import.bones(directory=self.relpath(),
files=[{
'name': 'test_fmt_no_boneparts.bones'
}],
import_bone_parts=True,
import_bone_properties=True)
# Assert
self.assertReportsContains(
'WARNING', re.compile('Bones file does not have boneparts'))
def test_edit_center(self):
op_edit = bpy.ops.io_scene_xray.edit_bone_center
set_active_object(None)
self.assertFalse(op_edit.poll(), msg='no armature')
bpy.ops.xray_import.object(directory=self.relpath(),
files=[{
'name': 'test_fmt_armature.object'
}])
arm = bpy.context.active_object
bone = arm.data.bones['Bone1']
arm.data.bones.active = bone
self.assertTrue(op_edit.poll(), msg='an armature')
self.assertIsNone(get_object_helper(bpy.context),
msg='no edit helper yet')
op_edit()
self.assertIsNotNone(get_object_helper(bpy.context),
msg='an edit helper')
self.assertFalse(op_edit.poll(), msg='a helper is already active')
helper = bpy.context.active_object
self.assertTrue(is_helper_object(helper), msg='active is helper')
self.assertGreater(helper.location.length, 0.001,
'a helper with some location')
set_active_object(arm)
self.assertFalse(op_edit.poll(), msg='a helper is still active')
set_active_object(helper)
helper.location = (0, 0, 0)
self.assertFalse(bpy.ops.io_scene_xray.edit_bone_center_align.poll(),
msg='no shape')
bone.xray.shape.type = '1'
bpy.ops.io_scene_xray.edit_bone_center_align()
self.assertEqual(round_vec(helper.location, 6), (0.1, 0, 0),
msg='move helper to box')
bone.xray.shape.type = '2'
bpy.ops.io_scene_xray.edit_bone_center_align()
self.assertEqual(round_vec(helper.location, 6), (0, 0.2, 0),
msg='move helper to sphere')
bone.xray.shape.type = '3'
bpy.ops.io_scene_xray.edit_bone_center_align()
self.assertEqual(round_vec(helper.location, 6), (0, 0, 0.3),
msg='move helper to cylinder')
bpy.ops.io_scene_xray.edit_bone_center_apply()
self.assertIsNone(get_object_helper(bpy.context),
msg='a helper is hidden')
self.assertTrue(_has_nonzero(bone.xray.mass.center),
msg='has center relative')
def test_edit_shape(self):
op_edit = bpy.ops.io_scene_xray.edit_bone_shape
if bpy.app.version >= (2, 80, 0):
bpy.context.view_layer.objects.active = None
else:
bpy.context.scene.objects.active = None
self.assertFalse(op_edit.poll(), msg='no armature')
bpy.ops.xray_import.object(directory=self.relpath(),
files=[{
'name': 'test_fmt_armature.object'
}])
arm = bpy.context.active_object
bone = arm.data.bones['Bone']
arm.data.bones.active = bone
self.assertFalse(op_edit.poll(), msg='an armature, no shape')
bone.xray.shape.type = '1'
self.assertTrue(op_edit.poll(), msg='an armature, with shape')
self.assertIsNone(get_object_helper(bpy.context),
msg='no edit helper yet')
op_edit()
self.assertIsNotNone(get_object_helper(bpy.context),
msg='a box edit helper')
self.assertFalse(op_edit.poll(), msg='a helper is already active')
helper = bpy.context.active_object
self.assertTrue(is_helper_object(helper), msg='active is helper')
self.assertGreater(helper.scale.length, 0.001,
'a helper with some size')
set_active_object(arm)
self.assertFalse(op_edit.poll(), msg='a helper is still active')
set_active_object(helper)
helper.location = helper.scale = (1, 2, 3)
bpy.ops.io_scene_xray.edit_bone_shape_fit()
self.assertLess(helper.location.length, 0.1, msg='fit shape location')
self.assertLess(helper.scale.length, 0.1, msg='fit shape size')
self.assertIsNotNone(get_object_helper(bpy.context),
msg='a helper still shown')
bpy.ops.io_scene_xray.edit_bone_shape_apply()
self.assertIsNone(get_object_helper(bpy.context),
msg='a helper is hidden')
self.assertTrue(_has_nonzero(bone.xray.shape.box_rot),
msg='has box_rot')
self.assertFalse(_has_nonzero(bone.xray.shape.box_trn),
msg='has zero box_trn')
self.assertTrue(_has_nonzero(bone.xray.shape.box_hsz),
msg='has box_hsz')
scale = bone.xray.shape.get_matrix_basis().to_scale().to_tuple()
self.assertGreater(scale, (0.999, 0.999, 0.999),
msg='close to 1:1 scale')
self.assertLess(reapply_max_difference(bone.xray.shape),
0.1,
msg='box reapplies almost the same')
bone.xray.shape.type = '2'
op_edit()
self.assertIsNotNone(get_object_helper(bpy.context),
msg='a sphere edit helper')
helper = bpy.context.active_object
helper.location = helper.scale = (1, 2, 3)
bpy.ops.io_scene_xray.edit_bone_shape_fit()
self.assertLess(helper.location.length,
0.1,
msg='fit shape sphere location')
bpy.ops.io_scene_xray.edit_bone_shape_apply()
self.assertGreater(bone.xray.shape.sph_rad, 0.01, msg='has sph_rad')
self.assertLess(reapply_max_difference(bone.xray.shape),
0.1,
msg='sphere reapplies almost the same')
bone.xray.shape.type = '3'
op_edit()
self.assertIsNotNone(get_object_helper(bpy.context),
msg='a cylinder edit helper')
helper = bpy.context.active_object
helper.location = helper.scale = (1, 2, 3)
bpy.ops.io_scene_xray.edit_bone_shape_fit()
self.assertLess(helper.location.length,
0.1,
msg='fit shape cylinder location')
bpy.ops.io_scene_xray.edit_bone_shape_apply()
self.assertGreater(bone.xray.shape.cyl_hgh, 0.01, msg='has cyl_hgh')
self.assertLess(reapply_max_difference(bone.xray.shape),
0.1,
msg='cylinder reapplies almost the same')
op_edit()
self.assertIsNotNone(get_object_helper(bpy.context),
msg='anedit helper again')
bpy.ops.io_scene_xray.edit_cancel()
self.assertIsNone(get_object_helper(bpy.context),
msg='no edit helper again')
op_edit()
self.assertIsNotNone(get_object_helper(bpy.context),
msg='an edit helper once again')
bone.xray.shape.type = '0'
self.assertIsNone(get_object_helper(bpy.context),
msg='no edit helper once again')
def _create_active_object(self):
obj = bpy.data.objects.new('tobj', None)
utils.link_object(obj)
utils.set_active_object(obj)
return obj
def test_default(self):
# import mesh and armature
bpy.ops.xray_import.object(
directory=self.relpath(),
files=[{
'name': 'test_fmt_bones.object'
}],
)
arm_obj = bpy.data.objects['test_fmt_bones.object']
utils.set_active_object(arm_obj)
# remove "bone or parts" (bone groups)
for bone_group in arm_obj.pose.bone_groups:
arm_obj.pose.bone_groups.remove(bone_group)
# Act import
bpy.ops.xray_import.bones(directory=self.relpath(),
files=[{
'name': 'test_fmt.bones'
}],
import_bone_parts=True,
import_bone_properties=True)
# Assert
self.assertReportsNotContains('WARNING')
NAME_TEST = 'test.bones'
NAME_IK_LIMITS = 'ik_limits.bones'
NAME_NULL_BONEPARTS = 'null_boneparts.bones'
NAME_BATCH_EXPORT = 'batch_export.bones'
# Act export
# export all
arm_obj.name = NAME_TEST
bpy.ops.xray_export.bone(filepath=self.outpath(NAME_TEST),
object_name=arm_obj.name,
export_bone_parts=True,
export_bone_properties=True)
# export without bone properties
bpy.ops.xray_export.bone(filepath=self.outpath(NAME_TEST),
object_name=arm_obj.name,
export_bone_parts=True,
export_bone_properties=False)
# export without bone parts
bpy.ops.xray_export.bone(filepath=self.outpath(NAME_TEST),
object_name=arm_obj.name,
export_bone_parts=False,
export_bone_properties=True)
# test non-exportable bone
arm_obj.data.bones[0].xray.exportable = False
bpy.ops.xray_export.bone(filepath=self.outpath(NAME_TEST),
object_name=arm_obj.name,
export_bone_parts=True,
export_bone_properties=True)
arm_obj.data.bones[0].xray.exportable = True
# test breakable
arm_obj.data.bones[0].xray.ikflags_breakable = False
arm_obj.data.bones[1].xray.ikflags_breakable = True
bpy.ops.xray_export.bone(filepath=self.outpath(NAME_TEST),
object_name=arm_obj.name,
export_bone_parts=True,
export_bone_properties=True)
# test export without exportable bone groups
for group in arm_obj.pose.bone_groups:
arm_obj.pose.bone_groups.remove(group)
arm_obj.pose.bone_groups.new(name='test')
bpy.ops.xray_export.bone(filepath=self.outpath(NAME_TEST),
object_name=arm_obj.name,
export_bone_parts=True,
export_bone_properties=True)
# test blender ik limits
arm_obj.name = NAME_IK_LIMITS
arm_obj.data.xray.joint_limits_type = 'IK'
bpy.ops.xray_export.bone(filepath=self.outpath(NAME_IK_LIMITS),
object_name=arm_obj.name,
export_bone_parts=True,
export_bone_properties=True)
# test export null boneparts
# remove "bone or parts" (bone groups)
for bone_group in arm_obj.pose.bone_groups:
arm_obj.pose.bone_groups.remove(bone_group)
# Act export
arm_obj.name = NAME_NULL_BONEPARTS
bpy.ops.xray_export.bone(filepath=self.outpath(NAME_NULL_BONEPARTS),
object_name=arm_obj.name,
export_bone_parts=True,
export_bone_properties=True)
# Batch export test
bpy.ops.object.select_all(action='SELECT')
arm_obj.name = NAME_BATCH_EXPORT
bpy.ops.xray_export.bones(directory=self.outpath(),
export_bone_parts=True,
export_bone_properties=True)
# Assert
self.assertOutputFiles({
NAME_TEST, NAME_IK_LIMITS, NAME_NULL_BONEPARTS, NAME_BATCH_EXPORT
})
def test_change_action_bake_settings(self):
for index in range(3):
name = 'test_' + str(index)
act = bpy.data.actions.new(name)
obj = bpy.data.objects.new(name, None)
obj.animation_data_create().action = act
utils.link_object(obj)
utils.select_object(obj)
utils.set_active_object(obj)
motion = obj.xray.motions_collection.add()
motion.name = act.name
for index in range(3, 6):
name = 'test_' + str(index)
act = bpy.data.actions.new(name)
obj = bpy.data.objects.new(name, None)
obj.animation_data_create().action = act
for index in range(6, 9):
name = 'test_' + str(index)
act = bpy.data.actions.new(name)
bpy.ops.io_scene_xray.change_action_bake_settings()
bpy.ops.io_scene_xray.change_action_bake_settings(
change_mode='ACTIVE_ACTION'
)
bpy.ops.io_scene_xray.change_action_bake_settings(
change_mode='ACTIVE_OBJECT'
)
bpy.ops.io_scene_xray.change_action_bake_settings(
change_mode='SELECTED_OBJECTS'
)
bpy.ops.io_scene_xray.change_action_bake_settings(
change_mode='ALL_OBJECTS'
)
bpy.ops.io_scene_xray.change_action_bake_settings(
change_mode='ALL_ACTIONS'
)
bpy.ops.io_scene_xray.change_action_bake_settings(
change_mode='ALL_ACTIONS',
change_auto_bake_mode=False
)
bpy.ops.io_scene_xray.change_action_bake_settings(
change_mode='ALL_ACTIONS',
auto_bake_mode='auto'
)
bpy.ops.io_scene_xray.change_action_bake_settings(
change_mode='ALL_ACTIONS',
auto_bake_mode='on'
)
bpy.ops.io_scene_xray.change_action_bake_settings(
change_mode='ALL_ACTIONS',
auto_bake_mode='off'
)
bpy.ops.io_scene_xray.change_action_bake_settings(
change_mode='ALL_ACTIONS',
change_use_custom_thresholds=False
)
bpy.ops.io_scene_xray.change_action_bake_settings(
change_mode='ALL_ACTIONS',
use_custom_threshold=False
)
bpy.ops.io_scene_xray.change_action_bake_settings(
change_mode='ALL_ACTIONS',
change_location_threshold=False
)
bpy.ops.io_scene_xray.change_action_bake_settings(
change_mode='ALL_ACTIONS',
change_rotation_threshold=False
)
bpy.ops.io_scene_xray.change_action_bake_settings(
change_mode='ALL_ACTIONS',
value_location_threshold=1.0
)
bpy.ops.io_scene_xray.change_action_bake_settings(
change_mode='ALL_ACTIONS',
value_rotation_threshold=1.0
)
def test_empty_bone_groups(self):
# Arrange
arm = bpy.data.armatures.new('tarm')
obj = bpy.data.objects.new('tobj', arm)
utils.link_object(obj)
utils.set_active_object(obj)
b_exp0, b_non0, b_exp1, b_non1 = ('b-exportable0', 'b-non-exportable0',
'b-exportable1', 'b-non-exportable1')
bpy.ops.object.mode_set(mode='EDIT')
try:
for n in (b_exp0, b_non0, b_exp1, b_non1):
bone = arm.edit_bones.new(n)
bone.tail.y = 1
for n in (b_non0, b_exp1, b_non1):
bone = arm.edit_bones[n]
parent = arm.edit_bones[b_exp0]
bone.parent = parent
finally:
bpy.ops.object.mode_set(mode='POSE')
bg_exp = obj.pose.bone_groups.new(name='bg-only-exportable')
bg_mix = obj.pose.bone_groups.new(name='bg-mixed')
bg_non = obj.pose.bone_groups.new(name='bg-only-non-exportable')
bg_emp = obj.pose.bone_groups.new(name='bg-empty')
obj.pose.bones[b_exp0].bone_group = bg_exp
obj.pose.bones[b_non0].bone_group = bg_mix
obj.pose.bones[b_exp1].bone_group = bg_mix
obj.pose.bones[b_non0].bone_group = bg_non
arm.bones[b_non0].xray.exportable = False
arm.bones[b_non1].xray.exportable = False
bmesh = utils.create_bmesh((
(0, 0, 0),
(-1, -1, 0),
(+1, -1, 0),
(+1, +1, 0),
(-1, +1, 0),
), ((0, 1, 2), (0, 2, 3), (0, 3, 4), (0, 4, 1)), True)
obj_me = utils.create_object(bmesh, True)
obj_me.parent = obj
obj_me.xray.isroot = False
vertex_group = obj_me.vertex_groups.new(name='b-exportable0')
vertex_group.add(range(len(obj_me.data.vertices)), 1.0, 'REPLACE')
# Act
bpy.ops.export_object.xray_objects(
objects='tobj',
directory=self.outpath(),
texture_name_from_image_path=False,
export_motions=False,
)
# Assert
self.assertReportsNotContains('WARNING')
self.assertOutputFiles({
'tobj.object',
})
content = self.getFileSafeContent('tobj.object')
self.assertRegex(content, re.compile(bytes(b_exp0, 'cp1251')))
self.assertRegex(content, re.compile(bytes(b_exp1, 'cp1251')))
self.assertNotRegex(content, re.compile(bytes(b_non0, 'cp1251')))
self.assertNotRegex(content, re.compile(bytes(b_non1, 'cp1251')))
self.assertRegex(content, re.compile(bytes(bg_exp.name, 'cp1251')))
self.assertRegex(content, re.compile(bytes(bg_mix.name, 'cp1251')))
self.assertNotRegex(content, re.compile(bytes(bg_non.name, 'cp1251')))
self.assertNotRegex(content, re.compile(bytes(bg_emp.name, 'cp1251')))
