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)
for meshObj in rig.meshes():
mats_to_delete = []
for mat in meshObj.data.materials:
if "_temp" in mat.name:
mats_to_delete.append(mat)
for temp_mat in mats_to_delete:
base_mat_name = temp_mat.name[0:-1 * len("_temp")]
base_idx = meshObj.data.materials.find(base_mat_name)
temp_idx = meshObj.data.materials.find(temp_mat.name)
for poly in meshObj.data.polygons:
if poly.material_index == temp_idx:
if base_idx == -1:
self.report(
{'ERROR'},
'Warning! base material for %s was not found' %
temp_mat.name)
else:
poly.material_index = base_idx
if base_idx != -1:
mat = meshObj.data.materials.pop(index=temp_idx)
bpy.data.materials.remove(mat)
return {'FINISHED'}
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 = None
for i in rig.meshes():
meshObj = i
break
if meshObj is None:
self.report({'ERROR'}, "The model mesh can't be found")
return {'CANCELLED'}
morph = mmd_root.material_morphs[mmd_root.active_morph]
mat_data = morph.data[morph.active_material_data]
base_mat = meshObj.data.materials[mat_data.material]
work_mat_name = base_mat.name + "_temp"
if work_mat_name in meshObj.data.materials.keys():
work_mat = meshObj.data.materials[work_mat_name]
base_idx = meshObj.data.materials.find(base_mat.name)
copy_idx = meshObj.data.materials.find(work_mat.name)
for poly in meshObj.data.polygons:
if poly.material_index == copy_idx:
poly.material_index = base_idx
mat = meshObj.data.materials.pop(index=copy_idx)
bpy.data.materials.remove(mat)
morph.data.remove(morph.active_material_data)
morph.active_material_data -= 1
return {'FINISHED'}
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 = None
for i in rig.meshes():
meshObj = i
break
if meshObj is None:
self.report({'ERROR'}, "The model mesh can't be found")
return {'CANCELLED'}
with bpyutils.select_object(meshObj) as data:
if meshObj.data.shape_keys is None:
bpy.ops.object.shape_key_add()
data.shape_key_add(self.name_j)
idx = len(meshObj.data.shape_keys.key_blocks) - 1
meshObj.active_shape_key_index = idx
vtx_morph = mmd_root.vertex_morphs.add()
vtx_morph.name = self.name_j
vtx_morph.name_e = self.name_e
vtx_morph.category = self.category
mmd_root.active_morph = len(mmd_root.vertex_morphs) - 1
frame = mmd_root.display_item_frames[u'表情']
item = frame.items.add()
item.name = vtx_morph.name
item.type = 'MORPH'
item.morph_category = self.category
return {'FINISHED'}
def execute(self, context):
obj = context.active_object
root = mmd_model.Model.findRoot(obj)
rig = mmd_model.Model(root)
mmd_root = rig.rootObject().mmd_root
joint = rig.createJoint(
name='Joint',
name_e='Joint_e',
location=[0, 0, 0],
rotation=[0, 0, 0],
size=0.5 * mmd_root.scale,
rigid_a=None,
rigid_b=None,
maximum_location=[0, 0, 0],
minimum_location=[0, 0, 0],
maximum_rotation=[0, 0, 0],
minimum_rotation=[0, 0, 0],
spring_linear=[0, 0, 0],
spring_angular=[0, 0, 0],
)
if mmd_root.show_joints:
joint.hide = False
utils.selectAObject(joint)
else:
joint.hide = True
utils.selectAObject(obj)
if 'mmd_tools.' + mmd_root.name + '_all' in bpy.data.groups.keys(
): # Add Joint to allGroup
bpy.data.groups['mmd_tools.' + mmd_root.name + '_all'].link(joint)
if 'mmd_tools.' + mmd_root.name + '_joints' in bpy.data.groups.keys(
): # Add Joint to joints group
bpy.data.groups['mmd_tools.' + mmd_root.name +
'_joints'].link(joint)
return {'FINISHED'}
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 = None
for i in rig.meshes():
meshObj = i
break
if meshObj is None:
self.report({ 'ERROR' }, "The model mesh can't be found")
return { 'CANCELLED' }
# Let's create a temporary material to edit the offset
orig_mat = meshObj.active_material
if "_temp" in orig_mat.name:
self.report({ 'ERROR' }, 'This material is not valid as a base material')
return { 'CANCELLED' }
if orig_mat.name+"_temp" in meshObj.data.materials.keys():
self.report({ 'ERROR' }, 'Another offset is using this Material, apply it first')
return { 'CANCELLED' }
copy_mat = orig_mat.copy()
copy_mat.name = orig_mat.name+"_temp"
meshObj.data.materials.append(copy_mat)
orig_idx = meshObj.active_material_index
copy_idx = meshObj.data.materials.find(copy_mat.name)
for poly in meshObj.data.polygons:
if poly.material_index == orig_idx:
poly.material_index = copy_idx
morph = mmd_root.material_morphs[mmd_root.active_morph]
mat_data = morph.data.add()
mat_data.material = orig_mat.name
return { 'FINISHED' }
def execute(self, context):
obj = context.active_object
root = mmd_model.Model.findRoot(context.active_object)
rig = mmd_model.Model(root)
rig.build()
context.view_layer.objects.active = obj
return {'FINISHED'}
def execute(self, context):
try:
self.__translator = DictionaryEnum.get_translator(self.dictionary)
except Exception as e:
self.report({'ERROR'}, 'Failed to load dictionary: %s' % e)
return {'CANCELLED'}
obj = context.active_object
root = mmd_model.Model.findRoot(obj)
rig = mmd_model.Model(root)
if 'MMD' in self.modes:
for i in self.types:
getattr(self, 'translate_%s' % i.lower())(rig)
if 'BLENDER' in self.modes:
self.translate_blender_names(rig)
translator = self.__translator
txt = translator.save_fails()
if translator.fails:
self.report(
{'WARNING'},
"Failed to translate %d names, see '%s' in text editor" %
(len(translator.fails), txt.name))
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)
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):
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 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.morph_slider.placeholder(
binded=True) or rig.firstMesh()
params['armature'] = rig.armature()
params['model_name'] = obj.mmd_root.name or obj.name
elif getattr(obj.data, 'shape_keys', None):
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):
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):
obj = context.active_object
root = mmd_model.Model.findRoot(obj)
rig = mmd_model.Model(root)
mmd_root = root.mmd_root
try:
bpy.ops.object.mode_set(mode='OBJECT')
except Exception:
pass
arm = rig.armature()
for i in context.scene.objects:
i.select_set(False)
arm.hide_set(False)
arm.select_set(True)
context.view_layer.objects.active = arm
bpy.ops.object.mode_set(mode='POSE')
frame = mmd_root.display_item_frames[
mmd_root.active_display_item_frame]
item = frame.items[frame.active_item]
bone_name = item.name
for i in arm.pose.bones:
i.bone.select_set(i.name == bone_name)
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 bakePhysics(self,context,start,end,step):
root = mmd_model.Model.findRoot(context.active_object)
if(root==None):
self.report({'INFO'}, 'Not a MMD armature!')
if(not root.mmd_root.is_built):
self.report({'INFO'}, 'Physics is not built!')
raise MMDPhysicsError('Physics Error')
rig = mmd_model.Model(root)
arm = rig.armature()
rigidbodyGroup=[]
boneGroup=[]
rigidbodyGroup=rig.rigidBodies()
bpy.ops.object.posemode_toggle()
for rb in rigidbodyGroup:
print(rb)
boneGroup.append(rb.mmd_rigid.bone)
bpy.ops.object.mode_set(mode='POSE')
pbone=arm.data.bones.get(rb.mmd_rigid.bone, None)
if(int(rb.mmd_rigid.type)==1 or int(rb.mmd_rigid.type)==2):
pbone.select=True
#bake it
bpy.ops.nla.bake(frame_start=start \
, frame_end=end \
, step=step \
, only_selected=True \
, visual_keying=True \
, clear_constraints=True \
, clear_parents=False \
, use_current_action=True \
, bake_types={'POSE'})
return { 'FINISHED' }
def execute(self, context):
obj = context.active_object
root = mmd_model.Model.findRoot(obj)
rig = mmd_model.Model(root)
mmd_root = root.mmd_root
items_map = {
"MATMORPH": "material_morphs",
"BONEMORPH": "bone_morphs",
"VTXMORPH": "vertex_morphs"
}
attr_name = items_map[mmd_root.active_morph_type]
items = getattr(mmd_root, attr_name)
if mmd_root.active_morph >= 0 and mmd_root.active_morph < len(items):
active_morph = items[mmd_root.active_morph]
if attr_name == "vertex_morphs":
for meshObj in rig.meshes():
with bpyutils.select_object(meshObj) as m:
if m.data.shape_keys is not None:
i = m.data.shape_keys.key_blocks.find(
active_morph.name)
m.active_shape_key_index = i
bpy.ops.object.shape_key_remove()
facial_frame = mmd_root.display_item_frames[u'表情']
idx = facial_frame.items.find(active_morph.name)
if facial_frame.active_item == idx:
facial_frame.active_item -= 1
facial_frame.items.remove(idx)
items.remove(mmd_root.active_morph)
mmd_root.active_morph -= 1
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 execute(self, context):
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')
else:
handler = log_handler(self.log_level)
logger.addHandler(handler)
root = mmd_model.Model.findRoot(context.active_object)
rig = mmd_model.Model(root)
rig.clean()
try:
pmx_exporter.export(
filepath=self.filepath,
scale=root.mmd_root.scale,
root=rig.rootObject(),
armature=rig.armature(),
meshes=rig.meshes(),
rigid_bodies=rig.rigidBodies(),
joints=rig.joints(),
copy_textures=self.copy_textures,
)
finally:
logger.removeHandler(handler)
return {'FINISHED'}
def draw(self, context):
active_obj = context.active_object
root = None
if active_obj:
root = mmd_model.Model.findRoot(active_obj)
if root is None:
c = self.layout.column()
c.label(text='Select a MMD Model')
return
rig = mmd_model.Model(root)
root = rig.rootObject()
mmd_root = root.mmd_root
col = self.layout.column()
c = col.column(align=True)
row = c.row()
row.template_list(
"UL_joints",
"",
context.scene,
"objects",
mmd_root,
'active_joint_index',
)
tb = row.column()
tb1 = tb.column(align=True)
tb1.operator(operators.rigid_body.AddJoint.bl_idname,
text='',
icon='ZOOM_IN')
tb1.operator(operators.rigid_body.RemoveJoint.bl_idname,
text='',
icon='ZOOM_OUT')
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 _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 _setActiveRigidbodyObject(prop, v):
obj = bpy.context.scene.objects[v]
root = prop.id_data
rig = mmd_model.Model(root)
for i in rig.rigidBodies():
i.hide = False
if not obj.hide:
utils.selectAObject(obj)
prop['active_rigidbody_object_index'] = v
def _setActiveJointObject(prop, v):
obj = bpy.context.scene.objects[v]
root = prop.id_data
rig = mmd_model.Model(root)
for i in rig.joints():
i.hide = False
if not obj.hide:
utils.selectAObject(obj)
prop['active_joint_object_index'] = v
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