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)
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 = [mat.name 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():
if len(mesh.data.materials) == 1:
mat = mesh.data.materials[0]
idx = mat_names.index(mat.name)
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
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 __importUVMorphs(self):
mmd_root = self.__root.mmd_root
categories = self.CATEGORIES
__OffsetData = collections.namedtuple('OffsetData', 'index, offset')
__convert_offset = lambda x: (x[0], -x[1], x[2], -x[3])
for morph in (x for x in self.__model.morphs if isinstance(x, pmx.UVMorph)):
uv_morph = mmd_root.uv_morphs.add()
uv_morph.name = morph.name
uv_morph.name_e = morph.name_e
uv_morph.category = categories.get(morph.category, 'OTHER')
uv_morph.uv_index = morph.uv_index
offsets = (__OffsetData(d.index, __convert_offset(d.offset)) for d in morph.offsets)
FnMorph.store_uv_morph_data(self.__meshObj, uv_morph, offsets, '')
uv_morph.data_type = 'VERTEX_GROUP'
def _set_name(prop, value):
mmd_root = prop.id_data.mmd_root
#morph_type = mmd_root.active_morph_type
morph_type = '%s_morphs' % prop.bl_rna.identifier[:-5].lower()
#assert(prop.bl_rna.identifier.endswith('Morph'))
#print('_set_name:', prop, value, morph_type)
prop_name = prop.get('name', None)
if prop_name == value:
return
used_names = {x.name for x in getattr(mmd_root, morph_type) if x != prop}
value = utils.uniqueName(value, used_names)
if prop_name is not None:
if morph_type == 'vertex_morphs':
kb_list = {}
for mesh in FnModel(prop.id_data).meshes():
for kb in getattr(mesh.data.shape_keys, 'key_blocks', ()):
kb_list.setdefault(kb.name, []).append(kb)
if prop_name in kb_list:
value = utils.uniqueName(value, used_names | kb_list.keys())
for kb in kb_list[prop_name]:
kb.name = value
elif morph_type == 'uv_morphs':
vg_list = {}
for mesh in FnModel(prop.id_data).meshes():
for vg, n, x in FnMorph.get_uv_morph_vertex_groups(mesh):
vg_list.setdefault(n, []).append(vg)
if prop_name in vg_list:
value = utils.uniqueName(value, used_names | vg_list.keys())
for vg in vg_list[prop_name]:
vg.name = vg.name.replace(prop_name, value)
if 1: #morph_type != 'group_morphs':
for m in mmd_root.group_morphs:
for d in m.data:
if d.name == prop_name and d.morph_type == morph_type:
d.name = value
frame_facial = mmd_root.display_item_frames.get(u'表情')
for item in getattr(frame_facial, 'data', []):
if item.name == prop_name and item.morph_type == morph_type:
item.name = value
break
obj = FnModel(prop.id_data).morph_slider.placeholder()
if obj and value not in obj.data.shape_keys.key_blocks:
kb = obj.data.shape_keys.key_blocks.get(prop_name, None)
if kb:
kb.name = value
prop['name'] = value
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)
mmd_root = root.mmd_root
meshes = tuple(rig.meshes())
if len(meshes) == 1:
obj = meshes[0]
elif obj not in meshes:
self.report({'ERROR'}, 'Please select a mesh object')
return {'CANCELLED'}
meshObj = obj
bpy.ops.mmd_tools.clear_uv_morph_view()
selected = meshObj.select
with bpyutils.select_object(meshObj) as data:
morph = mmd_root.uv_morphs[mmd_root.active_morph]
mesh = meshObj.data
uv_textures = mesh.uv_textures
base_uv_layers = [l for l in mesh.uv_layers if not l.name.startswith('_')]
if morph.uv_index >= len(base_uv_layers):
self.report({ 'ERROR' }, "Invalid uv index: %d"%morph.uv_index)
return { 'CANCELLED' }
uv_layer_name = base_uv_layers[morph.uv_index].name
if morph.uv_index == 0 or uv_textures.active.name not in {uv_layer_name, '_'+uv_layer_name}:
uv_textures.active = uv_textures[uv_layer_name]
uv_layer_name = uv_textures.active.name
uv_tex = uv_textures.new(name='__uv.%s'%uv_layer_name)
if uv_tex is None:
self.report({ 'ERROR' }, "Failed to create a temporary uv layer")
return { 'CANCELLED' }
offsets = FnMorph.get_uv_morph_offset_map(meshObj, morph).items()
offsets = {k:getattr(Vector(v), 'zw' if uv_layer_name.startswith('_') else 'xy') for k, v in offsets}
if len(offsets) > 0:
base_uv_data = mesh.uv_layers.active.data
temp_uv_data = mesh.uv_layers[uv_tex.name].data
for i, l in enumerate(mesh.loops):
select = temp_uv_data[i].select = (l.vertex_index in offsets)
if select:
temp_uv_data[i].uv = base_uv_data[i].uv + offsets[l.vertex_index]
uv_textures.active = uv_tex
uv_tex.active_render = True
meshObj.hide = False
meshObj.select = selected
return { 'FINISHED' }
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' }
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 mmd_tools_local 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 mat 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
for morph in root.mmd_root.material_morphs:
FnMorph(morph, rig).update_mat_related_mesh(active_mesh)
utils.clearUnusedMeshes()
return { 'FINISHED' }
def execute(self, context):
obj = context.active_object
root = mmd_model.Model.findRoot(obj)
if root is None:
self.__separate_by_materials(obj)
else:
bpy.ops.mmd_tools.clear_temp_materials()
bpy.ops.mmd_tools.clear_uv_morph_view()
# Store the current material names
rig = mmd_model.Model(root)
mat_names = [getattr(mat, 'name', None) for mat in rig.materials()]
self.__separate_by_materials(obj)
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)
for morph in root.mmd_root.material_morphs:
FnMorph(morph, rig).update_mat_related_mesh()
utils.clearUnusedMeshes()
return {'FINISHED'}
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)
active_mesh = meshes_list[0]
bpy.ops.object.select_all(action='DESELECT')
act_layer = context.scene.active_layer
for mesh in meshes_list:
mesh.layers[act_layer] = True
mesh.hide_select = False
mesh.hide = False
mesh.select = True
bpy.context.scene.objects.active = active_mesh
# Store the current order of the materials
for m in meshes_list[1:]:
for mat in m.data.materials:
if mat and mat.name not in active_mesh.data.materials:
active_mesh.data.materials.append(mat)
# Store the current order of shape keys (vertex morphs)
from collections import OrderedDict
__get_key_blocks = lambda x: x.data.shape_keys.key_blocks if x.data.shape_keys else [
]
shape_key_names = OrderedDict(
(kb.name, None) for m in meshes_list for kb in __get_key_blocks(m))
shape_key_names = sorted(
shape_key_names.keys(),
key=lambda x: root.mmd_root.vertex_morphs.find(x))
FnMorph.storeShapeKeyOrder(active_mesh, shape_key_names)
active_mesh.active_shape_key_index = 0
# Join selected meshes
bpy.ops.object.join()
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 loadMorphs(self):
FnMorph.load_morphs(self)
def morph_slider(self):
return FnMorph.get_morph_slider(self)