def execute(self, context):
obj = context.active_object
root = mmd_model.Model.findRoot(obj)
if root:
bpy.ops.mmd_tools.clear_temp_materials()
bpy.ops.mmd_tools.clear_uv_morph_view()
if root:
# Store the current material names
rig = mmd_model.Model(root)
mat_names = [getattr(mat, 'name', None) for mat in rig.materials()]
utils.separateByMaterials(obj)
if self.clean_shape_keys:
bpy.ops.mmd_tools.clean_shape_keys()
if root:
rig = mmd_model.Model(root)
# The material morphs store the name of the mesh, not of the object.
# So they will not be out of sync
for mesh in rig.meshes():
FnMorph.clean_uv_morph_vertex_groups(mesh)
if len(mesh.data.materials) > 0:
mat = mesh.data.materials[0]
idx = mat_names.index(getattr(mat, 'name', None))
MoveObject.set_index(mesh, idx)
if root and len(root.mmd_root.material_morphs) > 0:
for morph in root.mmd_root.material_morphs:
mo = FnMorph(morph, mmd_model.Model(root))
mo.update_mat_related_mesh()
utils.clearUnusedMeshes()
return {'FINISHED'}
def execute(self, context):
obj = context.active_object
root = mmd_model.Model.findRoot(obj)
mmd_root = root.mmd_root
morph_type = mmd_root.active_morph_type
morph = ItemOp.get_by_index(getattr(mmd_root, morph_type),
mmd_root.active_morph)
if morph is None:
return {'CANCELLED'}
if morph_type.startswith('material'):
bpy.ops.mmd_tools.clear_temp_materials()
if self.all:
if morph_type.startswith('vertex'):
for obj in mmd_model.Model(root).meshes():
FnMorph.remove_shape_key(obj, morph.name)
return {'FINISHED'}
elif morph_type.startswith('uv'):
if morph.data_type == 'VERTEX_GROUP':
for obj in mmd_model.Model(root).meshes():
FnMorph.store_uv_morph_data(obj, morph)
return {'FINISHED'}
morph.data.clear()
morph.active_data = 0
else:
morph.data.remove(morph.active_data)
morph.active_data = max(0, morph.active_data - 1)
return {'FINISHED'}
def execute(self, context):
obj = context.active_object
root = mmd_model.Model.findRoot(obj)
mmd_root = root.mmd_root
morph_type = mmd_root.active_morph_type
morphs = getattr(mmd_root, morph_type)
morph = ItemOp.get_by_index(morphs, mmd_root.active_morph)
if morph is None:
return {'CANCELLED'}
name_orig, name_tmp = morph.name, '_tmp%s' % str(morph.as_pointer())
if morph_type.startswith('vertex'):
for obj in mmd_model.Model(root).meshes():
FnMorph.copy_shape_key(obj, name_orig, name_tmp)
elif morph_type.startswith('uv'):
if morph.data_type == 'VERTEX_GROUP':
for obj in mmd_model.Model(root).meshes():
FnMorph.copy_uv_morph_vertex_groups(
obj, name_orig, name_tmp)
morph_new, mmd_root.active_morph = ItemOp.add_after(
morphs, mmd_root.active_morph)
for k, v in morph.items():
morph_new[k] = v if k != 'name' else name_tmp
morph_new.name = name_orig + '_copy' # trigger name check
return {'FINISHED'}
def execute(self, context):
obj = context.active_object
root = mmd_model.Model.findRoot(obj)
rig = mmd_model.Model(root)
rig.applyAdditionalTransformConstraints()
SceneOp(context).active_object = obj
return {'FINISHED'}
def execute(self, context):
params = {
'filepath': self.filepath,
'scale': self.scale,
'pose_type': self.pose_type,
'use_pose_mode': self.use_pose_mode,
}
obj = context.active_object
if obj.mmd_type == 'ROOT':
rig = mmd_model.Model(obj)
params['mesh'] = rig.firstMesh()
params['armature'] = rig.armature()
params['model_name'] = obj.mmd_root.name or obj.name
elif obj.type == 'MESH':
params['mesh'] = obj
params['model_name'] = obj.name
elif obj.type == 'ARMATURE':
params['armature'] = obj
params['model_name'] = obj.name
try:
vpd_exporter.VPDExporter().export(**params)
except Exception as e:
err_msg = traceback.format_exc()
logging.error(err_msg)
self.report({'ERROR'}, err_msg)
return {'FINISHED'}
def execute(self, context):
obj = context.active_object
root = mmd_model.Model.findRoot(obj)
rig = mmd_model.Model(root)
for m in rig.meshes():
mesh = m.data
uv_textures = getattr(mesh, 'uv_textures', mesh.uv_layers)
for t in uv_textures:
if t.name.startswith('__uv.'):
uv_textures.remove(t)
if len(uv_textures) > 0:
uv_textures[0].active_render = True
uv_textures.active_index = 0
animation_data = mesh.animation_data
if animation_data:
nla_tracks = animation_data.nla_tracks
for t in nla_tracks:
if t.name.startswith('__uv.'):
nla_tracks.remove(t)
if animation_data.action and animation_data.action.name.startswith(
'__uv.'):
animation_data.action = None
if animation_data.action is None and len(nla_tracks) == 0:
mesh.animation_data_clear()
for act in bpy.data.actions:
if act.name.startswith('__uv.') and act.users < 1:
bpy.data.actions.remove(act)
return {'FINISHED'}
def draw_item(self, context, layout, data, item, icon, active_data,
active_propname, index):
if self.layout_type in {'DEFAULT'}:
if item.type == 'BONE':
row = _layout_split(layout, factor=0.5, align=True)
row.prop(item, 'name', text='', emboss=False, icon='BONE_DATA')
self.draw_bone_special(
row,
mmd_model.Model(item.id_data).armature(), item.name,
self.mmd_name)
else:
row = _layout_split(layout, factor=0.6, align=True)
row.prop(item,
'name',
text='',
emboss=False,
icon='SHAPEKEY_DATA')
row = row.row(align=True)
row.prop(item, 'morph_type', text='', emboss=False)
if item.name not in getattr(item.id_data.mmd_root,
item.morph_type):
row.label(icon='ERROR')
elif self.layout_type in {'COMPACT'}:
pass
elif self.layout_type in {'GRID'}:
layout.alignment = 'CENTER'
layout.label(text="", icon_value=icon)
def execute(self, context):
obj = context.active_object
root = mmd_model.Model.findRoot(obj)
if root is None:
self.report({'ERROR'}, "The model root can't be found")
return {'CANCELLED'}
rig = mmd_model.Model(root)
selection = set(rig.rigidBodies())
for prop_name in self.properties:
prop_value = getattr(obj.mmd_rigid, prop_name)
if prop_name == 'collision_group_mask':
prop_value = tuple(prop_value)
for i in selection.copy():
if tuple(i.mmd_rigid.collision_group_mask) != prop_value:
selection.remove(i)
if self.hide_others:
i.select = False
i.hide = True
else:
for i in selection.copy():
if getattr(i.mmd_rigid, prop_name) != prop_value:
selection.remove(i)
if self.hide_others:
i.select = False
i.hide = True
for i in selection:
i.hide = False
i.select = True
return {'FINISHED'}
def execute(self, context):
selected_objects = set(context.selected_objects)
for i in frozenset(selected_objects):
root = mmd_model.Model.findRoot(i)
if root == i:
rig = mmd_model.Model(root)
selected_objects.add(rig.armature())
selected_objects.add(rig.morph_slider.placeholder())
selected_objects |= set(rig.meshes())
bone_mapper = None
if self.bone_mapper == 'PMX':
bone_mapper = makePmxBoneMap
elif self.bone_mapper == 'RENAMED_BONES':
bone_mapper = vmd_importer.RenamedBoneMapper(
rename_LR_bones=self.rename_bones,
use_underscore=self.use_underscore,
translator=DictionaryEnum.get_translator(self.dictionary),
).init
for f in self.files:
importer = vpd_importer.VPDImporter(
filepath=os.path.join(self.directory, f.name),
scale=self.scale,
bone_mapper=bone_mapper,
use_pose_mode=self.use_pose_mode,
)
for i in selected_objects:
importer.assign(i)
return {'FINISHED'}
def execute(self, context):
root = mmd_model.Model.findRoot(context.active_object)
if root is None:
self.report({'ERROR'}, 'Select a MMD model')
return {'CANCELLED'}
rig = mmd_model.Model(root)
armObj = rig.armature()
if armObj is None:
self.report({'ERROR'}, 'Model Armature not found')
return {'CANCELLED'}
def __get_root(mesh):
if mesh.parent is None:
return mesh
return __get_root(mesh.parent)
meshes_list = (o for o in context.visible_objects
if o.type == 'MESH' and o.mmd_type == 'NONE')
for mesh in meshes_list:
if mmd_model.Model.findRoot(mesh) is not None:
# Do not attach meshes from other models
continue
mesh = __get_root(mesh)
m = mesh.matrix_world
mesh.parent_type = 'OBJECT'
mesh.parent = armObj
mesh.matrix_world = m
return {'FINISHED'}
def execute(self, context):
obj = context.active_object
root = mmd_model.Model.findRoot(obj)
rig = mmd_model.Model(root)
arm = rig.armature()
bone_map = {}
for i in context.selected_objects:
if mmd_model.isRigidBodyObject(i):
bone_map[i] = arm.data.bones.get(i.mmd_rigid.bone, None)
if len(bone_map) < 2:
self.report({'ERROR'},
"Please select two or more mmd rigid objects")
return {'CANCELLED'}
utils.selectAObject(root)
root.select = False
if context.scene.rigidbody_world is None:
bpy.ops.rigidbody.world_add()
for pair in self.__enumerate_rigid_pair(bone_map):
joint = self.__add_joint(rig, pair, bone_map)
joint.select = True
return {'FINISHED'}
def _toggleVisibilityOfTemporaryObjects(self, context):
root = self.id_data
rig = mmd_model.Model(root)
hide = not self.show_temporary_objects
for i in rig.temporaryObjects(rigid_track_only=True):
i.hide = hide
if hide and context.active_object is None:
SceneOp(context).active_object = root
def _toggleVisibilityOfJoints(self, context):
root = self.id_data
rig = mmd_model.Model(root)
hide = not self.show_joints
for i in rig.joints():
i.hide = hide
if hide and context.active_object is None:
SceneOp(context).active_object = root
def _toggleUseSDEF(self, context):
root = self.id_data
rig = mmd_model.Model(root)
mute_sdef = not self.use_sdef
for i in rig.meshes():
if FnSDEF.SHAPEKEY_NAME in getattr(i.data.shape_keys, 'key_blocks',
()):
i.data.shape_keys.key_blocks[FnSDEF.SHAPEKEY_NAME].mute = mute_sdef
def execute(self, context):
obj = context.active_object
root = mmd_model.Model.findRoot(obj)
rig = mmd_model.Model(root)
armature = rig.armature()
for p_bone in armature.pose.bones:
p_bone.matrix_basis.identity()
return {'FINISHED'}
def _toggleUseSphereTexture(self, context):
root = self.id_data
rig = mmd_model.Model(root)
use_sphere = self.use_sphere_texture
for i in rig.meshes():
for m in i.data.materials:
if m is None:
continue
FnMaterial(m).use_sphere_texture(use_sphere, i)
def _setVisibilityOfMMDRigArmature(prop, v):
obj = prop.id_data
rig = mmd_model.Model(obj)
arm = rig.armature()
if arm is None:
return
if bpy.context.active_object == arm:
SceneOp(bpy.context).active_object = obj
arm.hide = not v
def execute(self, context):
obj = context.active_object
root = mmd_model.Model.findRoot(obj)
mmd_root = root.mmd_root
rig = mmd_model.Model(root)
armature = rig.armature()
morph = mmd_root.bone_morphs[mmd_root.active_morph]
morph_data = morph.data[morph.active_data]
utils.selectSingleBone(context, armature, morph_data.bone)
return {'FINISHED'}
def execute(self, context):
obj = context.active_object
root = mmd_model.Model.findRoot(context.active_object)
rig = mmd_model.Model(root)
if self.type == 'BIND':
rig.morph_slider.bind()
elif self.type == 'UNBIND':
rig.morph_slider.unbind()
else:
rig.morph_slider.create()
SceneOp(context).active_object = obj
return {'FINISHED'}
def execute(self, context):
obj = context.active_object
root = mmd_model.Model.findRoot(obj)
mmd_root = root.mmd_root
rig = mmd_model.Model(root)
armature = rig.armature()
morph = mmd_root.bone_morphs[mmd_root.active_morph]
morph_data = morph.data[morph.active_data]
p_bone = armature.pose.bones[morph_data.bone]
morph_data.location = p_bone.location
morph_data.rotation = p_bone.rotation_quaternion
return {'FINISHED'}
def draw_item(self, context, layout, data, item, icon, active_data,
active_propname, index):
if self.layout_type in {'DEFAULT'}:
layout.prop(item, 'bone', text='', emboss=False, icon='BONE_DATA')
MMD_ROOT_UL_display_items.draw_bone_special(
layout,
mmd_model.Model(item.id_data).armature(), item.bone)
elif self.layout_type in {'COMPACT'}:
pass
elif self.layout_type in {'GRID'}:
layout.alignment = 'CENTER'
layout.label(text="", icon_value=icon)
def _do_execute(self, context, root):
logger = logging.getLogger()
logger.setLevel(self.log_level)
if self.save_log:
handler = log_handler(self.log_level,
filepath=self.filepath +
'.mmd_tools.export.log')
logger.addHandler(handler)
if root:
bpy.ops.mmd_tools.clear_temp_materials()
bpy.ops.mmd_tools.clear_uv_morph_view()
rig = mmd_model.Model(root)
arm = rig.armature()
orig_pose_position = None
if not root.mmd_root.is_built: # use 'REST' pose when the model is not built
orig_pose_position = arm.data.pose_position
arm.data.pose_position = 'REST'
arm.update_tag()
context.scene.frame_set(context.scene.frame_current)
try:
meshes = rig.meshes()
if self.visible_meshes_only:
meshes = (x for x in meshes if x in context.visible_objects)
pmx_exporter.export(
filepath=self.filepath,
scale=self.scale,
root=rig.rootObject(),
armature=rig.armature(),
meshes=meshes,
rigid_bodies=rig.rigidBodies(),
joints=rig.joints(),
copy_textures=self.copy_textures,
sort_materials=self.sort_materials,
sort_vertices=self.sort_vertices,
disable_specular=self.disable_specular,
)
self.report({'INFO'}, 'Exported MMD model "%s" to "%s"' %
(root.name, self.filepath))
except Exception as e:
err_msg = traceback.format_exc()
logging.error(err_msg)
raise
finally:
if orig_pose_position:
arm.data.pose_position = orig_pose_position
if self.save_log:
logger.removeHandler(handler)
return {'FINISHED'}
def execute(self, context):
#TODO convert some basic MMD properties
armature = context.active_object
scale = 1
model_name = 'New MMD Model'
root = mmd_model.Model.findRoot(armature)
if root is None or root != armature.parent:
rig = mmd_model.Model.create(model_name, model_name, scale, armature=armature)
self.__attach_meshes_to(armature, SceneOp(context).id_objects)
self.__configure_rig(mmd_model.Model(armature.parent))
return {'FINISHED'}
def execute(self, context):
obj = context.active_object
root = mmd_model.Model.findRoot(obj)
rig = mmd_model.Model(root)
if self.type == 'RESET':
rig.initialDisplayFrames()
elif self.type == 'FACIAL':
rig.initialDisplayFrames(reset=False) # ensure default frames
self.load_facial_items(root.mmd_root)
elif self.type == 'GROUP_LOAD':
self.load_bone_groups(root.mmd_root, rig.armature())
rig.initialDisplayFrames(reset=False) # ensure default frames
elif self.type == 'GROUP_APPLY':
self.apply_bone_groups(root.mmd_root, rig.armature())
return {'FINISHED'}
def execute(self, context):
from core.mmd_tools.bpyutils import matmul
obj = context.active_object
root = mmd_model.Model.findRoot(obj)
mmd_root = root.mmd_root
rig = mmd_model.Model(root)
armature = rig.armature()
utils.selectSingleBone(context, armature, None, True)
morph = mmd_root.bone_morphs[mmd_root.active_morph]
for morph_data in morph.data:
p_bone = armature.pose.bones.get(morph_data.bone, None)
if p_bone:
p_bone.bone.select = True
p_bone.location += morph_data.location
p_bone.rotation_quaternion = matmul(p_bone.rotation_quaternion,
morph_data.rotation)
return {'FINISHED'}
def __get_objects(self, obj):
class __MovableList(list):
def move(self, index_old, index_new):
item = self[index_old]
self.remove(item)
self.insert(index_new, item)
objects = []
root = mmd_model.Model.findRoot(obj)
if root:
rig = mmd_model.Model(root)
if obj.mmd_type == 'NONE' and obj.type == 'MESH':
objects = rig.meshes()
elif obj.mmd_type == 'RIGID_BODY':
objects = rig.rigidBodies()
elif obj.mmd_type == 'JOINT':
objects = rig.joints()
return __MovableList(objects)
def execute(self, context):
obj = context.active_object
root = mmd_model.Model.findRoot(obj)
if root is None:
self.report({'ERROR'}, 'Select a MMD model')
return {'CANCELLED'}
if root:
bpy.ops.mmd_tools.clear_temp_materials()
bpy.ops.mmd_tools.clear_uv_morph_view()
# Find all the meshes in mmd_root
rig = mmd_model.Model(root)
meshes_list = sorted(rig.meshes(), key=lambda x: x.name)
if not meshes_list:
self.report({'ERROR'}, 'The model does not have any meshes')
return {'CANCELLED'}
active_mesh = meshes_list[0]
from core.mmd_tools import bpyutils
bpyutils.select_object(active_mesh, objects=meshes_list)
# Store the current order of the materials
for m in meshes_list[1:]:
for mat in m.data.materials:
if getattr(mat, 'name',
None) not in active_mesh.data.materials[:]:
active_mesh.data.materials.append(mat)
# Join selected meshes
bpy.ops.object.join()
if self.sort_shape_keys:
FnMorph.fixShapeKeyOrder(active_mesh,
root.mmd_root.vertex_morphs.keys())
active_mesh.active_shape_key_index = 0
if len(root.mmd_root.material_morphs) > 0:
for morph in root.mmd_root.material_morphs:
mo = FnMorph(morph, rig)
mo.update_mat_related_mesh(active_mesh)
utils.clearUnusedMeshes()
return {'FINISHED'}
def draw(self, context):
active_obj = context.active_object
root = mmd_model.Model.findRoot(active_obj)
if root is None:
self.layout.label(text='Select a MMD Model')
return
rig = mmd_model.Model(root)
mmd_root = root.mmd_root
col = self.layout.column()
row = col.row()
row.prop(mmd_root, 'active_morph_type', expand=True)
morph_type = mmd_root.active_morph_type
c = col.column(align=True)
row = c.row()
row.template_list("UL_Morphs", "", mmd_root, morph_type, mmd_root,
"active_morph")
tb = row.column()
tb1 = tb.column(align=True)
tb1.operator('mmd_tools.morph_add', text='', icon=ICON_ADD)
tb1.operator('mmd_tools.morph_remove', text='', icon=ICON_REMOVE)
tb1.menu('OBJECT_MT_mmd_tools_morph_menu',
text='',
icon='DOWNARROW_HLT')
tb.separator()
tb1 = tb.column(align=True)
tb1.operator('mmd_tools.morph_move', text='',
icon='TRIA_UP').type = 'UP'
tb1.operator('mmd_tools.morph_move', text='',
icon='TRIA_DOWN').type = 'DOWN'
morph = ItemOp.get_by_index(getattr(mmd_root, morph_type),
mmd_root.active_morph)
if morph:
slider = rig.morph_slider.get(morph.name)
if slider:
col.row().prop(slider, 'value')
draw_func = getattr(self, '_draw_%s_data' % morph_type[:-7], None)
if draw_func:
draw_func(context, rig, col, morph)
def execute(self, context):
obj = context.active_object
root = mmd_model.Model.findRoot(obj)
rig = mmd_model.Model(root)
mmd_root = root.mmd_root
meshObj = obj
selected = meshObj.select
with bpyutils.select_object(meshObj) as data:
morph = mmd_root.uv_morphs[mmd_root.active_morph]
mesh = meshObj.data
base_uv_name = mesh.uv_layers.active.name[5:]
if base_uv_name not in mesh.uv_layers:
self.report({'ERROR'},
' * UV map "%s" not found' % base_uv_name)
return {'CANCELLED'}
base_uv_data = mesh.uv_layers[base_uv_name].data
temp_uv_data = mesh.uv_layers.active.data
axis_type = 'ZW' if base_uv_name.startswith('_') else 'XY'
from collections import namedtuple
__OffsetData = namedtuple('OffsetData', 'index, offset')
offsets = {}
vertices = mesh.vertices
for l, i0, i1 in zip(mesh.loops, base_uv_data, temp_uv_data):
if vertices[
l.
vertex_index].select and l.vertex_index not in offsets:
dx, dy = i1.uv - i0.uv
if abs(dx) > 0.0001 or abs(dy) > 0.0001:
offsets[l.vertex_index] = __OffsetData(
l.vertex_index, (dx, dy, dx, dy))
FnMorph.store_uv_morph_data(meshObj, morph, offsets.values(),
axis_type)
morph.data_type = 'VERTEX_GROUP'
meshObj.select = selected
return {'FINISHED'}
def execute(self, context):
obj = context.active_object
root = mmd_model.Model.findRoot(obj)
rig = mmd_model.Model(root)
armature = rig.armature()
mmd_root = root.mmd_root
morph = mmd_root.bone_morphs[mmd_root.active_morph]
morph.data.clear()
morph.active_data = 0
def_loc = Vector((0, 0, 0))
def_rot = Quaternion((1, 0, 0, 0))
for p_bone in armature.pose.bones:
if p_bone.location != def_loc or p_bone.rotation_quaternion != def_rot:
item = morph.data.add()
item.bone = p_bone.name
item.location = p_bone.location
item.rotation = p_bone.rotation_quaternion
p_bone.bone.select = True
else:
p_bone.bone.select = False
return {'FINISHED'}
