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'}