def execute(self, context):
obj = context.active_object
root = mmd_model.Model.findRoot(obj)
rig = mmd_model.Model(root)
arm = rig.armature()
if obj != arm:
utils.selectAObject(root)
root.select = False
elif arm.mode != 'POSE':
bpy.ops.object.mode_set(mode='POSE')
selected_pose_bones = []
if context.selected_pose_bones:
selected_pose_bones = context.selected_pose_bones
arm.select = False
if len(selected_pose_bones) > 0:
for pose_bone in selected_pose_bones:
rigid = self.__add_rigid_body(rig, arm, pose_bone)
rigid.select = True
else:
rigid = self.__add_rigid_body(rig)
rigid.select = True
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 mat and "_temp" in mat.name:
mats_to_delete.append(mat)
for temp_mat in reversed(mats_to_delete):
base_mat_name = temp_mat.name.split('_temp')[0]
try:
FnMaterial.swap_materials(meshObj, temp_mat.name,
base_mat_name)
except MaterialNotFoundError:
self.report({'WARNING'},
'Base material for %s was not found' %
temp_mat.name)
else:
temp_idx = meshObj.data.materials.find(temp_mat.name)
mat = meshObj.data.materials.pop(index=temp_idx)
if mat.users < 1:
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 = obj
selected = meshObj.select
with bpyutils.select_object(meshObj) as data:
bpy.ops.object.mode_set(mode='EDIT')
bpy.ops.mesh.select_mode(type='VERT', action='ENABLE')
bpy.ops.mesh.reveal() # unhide all vertices
bpy.ops.mesh.select_all(action='DESELECT')
bpy.ops.object.mode_set(mode='OBJECT')
vertices = meshObj.data.vertices
for l, d in zip(meshObj.data.loops,
meshObj.data.uv_layers.active.data):
if d.select:
vertices[l.vertex_index].select = True
bpy.ops.object.mode_set(mode='EDIT')
meshObj.select = selected
return {'FINISHED'}
def execute(self, context):
root = mmd_model.Model.findRoot(context.active_object)
rig = mmd_model.Model(root)
rig.build()
SceneOp(context).active_object = root
return {'FINISHED'}
def execute(self, context):
root = mmd_model.Model.findRoot(context.active_object)
rig = mmd_model.Model(root)
rig.clean()
context.scene.objects.active = root
return {'FINISHED'}
def _toggleShowNamesOfRigidBodies(self, context):
root = self.id_data
rig = mmd_model.Model(root)
for i in rig.rigidBodies():
i.show_name = root.mmd_root.show_names_of_rigid_bodies
def _getVisibilityOfMMDRigArmature(prop):
rig = mmd_model.Model(prop.id_data)
arm = rig.armature()
return not (arm is None or arm.hide)
def _toggleShowNamesOfJoints(self, context):
root = self.id_data
rig = mmd_model.Model(root)
for i in rig.joints():
i.show_name = root.mmd_root.show_names_of_joints
def _toggleUseSDEF(self, context):
root = self.id_data
rig = mmd_model.Model(root)
mute_sdef = not self.use_sdef
for i in rig.meshes():
FnSDEF.mute_sdef_set(i, mute_sdef)
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 = getattr(mesh, 'uv_textures', mesh.uv_layers)
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)
rig = mmd_model.Model(root)
mmd_root = root.mmd_root
morph = mmd_root.material_morphs[mmd_root.active_morph]
mat_data = morph.data[morph.active_data]
meshObj = rig.findMesh(mat_data.related_mesh)
if meshObj is None:
self.report({'ERROR'}, "The model mesh can't be found")
return {'CANCELLED'}
base_mat = meshObj.data.materials.get(mat_data.material, None)
if base_mat is None:
self.report({'ERROR'},
'Material "%s" not found' % mat_data.material)
return {'CANCELLED'}
work_mat_name = base_mat.name + '_temp'
if work_mat_name in bpy.data.materials:
self.report({'ERROR'},
'Temporary material "%s" is in use' % work_mat_name)
return {'CANCELLED'}
work_mat = base_mat.copy()
work_mat.name = work_mat_name
meshObj.data.materials.append(work_mat)
FnMaterial.swap_materials(meshObj, base_mat.name, work_mat.name)
base_mmd_mat = base_mat.mmd_material
work_mmd_mat = work_mat.mmd_material
work_mmd_mat.material_id = -1
# Apply the offsets
if mat_data.offset_type == "MULT":
diffuse_offset = multiply_vector_components(
base_mmd_mat.diffuse_color, mat_data.diffuse_color[0:3])
specular_offset = multiply_vector_components(
base_mmd_mat.specular_color, mat_data.specular_color)
edge_offset = multiply_vector_components(base_mmd_mat.edge_color,
mat_data.edge_color)
ambient_offset = multiply_vector_components(
base_mmd_mat.ambient_color, mat_data.ambient_color)
work_mmd_mat.diffuse_color = diffuse_offset
work_mmd_mat.alpha *= mat_data.diffuse_color[3]
work_mmd_mat.specular_color = specular_offset
work_mmd_mat.shininess *= mat_data.shininess
work_mmd_mat.ambient_color = ambient_offset
work_mmd_mat.edge_color = edge_offset
work_mmd_mat.edge_weight *= mat_data.edge_weight
elif mat_data.offset_type == "ADD":
diffuse_offset = Vector(base_mmd_mat.diffuse_color) + Vector(
mat_data.diffuse_color[0:3])
specular_offset = Vector(base_mmd_mat.specular_color) + Vector(
mat_data.specular_color)
edge_offset = Vector(base_mmd_mat.edge_color) + Vector(
mat_data.edge_color)
ambient_offset = Vector(base_mmd_mat.ambient_color) + Vector(
mat_data.ambient_color)
work_mmd_mat.diffuse_color = list(diffuse_offset)
work_mmd_mat.alpha += mat_data.diffuse_color[3]
work_mmd_mat.specular_color = list(specular_offset)
work_mmd_mat.shininess += mat_data.shininess
work_mmd_mat.ambient_color = list(ambient_offset)
work_mmd_mat.edge_color = list(edge_offset)
work_mmd_mat.edge_weight += mat_data.edge_weight
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
morph = mmd_root.material_morphs[mmd_root.active_morph]
mat_data = morph.data[morph.active_data]
meshObj = rig.findMesh(mat_data.related_mesh)
if meshObj is None:
self.report({'ERROR'}, "The model mesh can't be found")
return {'CANCELLED'}
try:
work_mat_name = mat_data.material + '_temp'
work_mat, base_mat = FnMaterial.swap_materials(
meshObj, work_mat_name, mat_data.material)
except MaterialNotFoundError:
self.report({'ERROR'}, "Material not found")
return {'CANCELLED'}
copy_idx = meshObj.data.materials.find(work_mat.name)
base_mmd_mat = base_mat.mmd_material
work_mmd_mat = work_mat.mmd_material
if mat_data.offset_type == "MULT":
try:
diffuse_offset = divide_vector_components(
work_mmd_mat.diffuse_color, base_mmd_mat.diffuse_color
) + [special_division(work_mmd_mat.alpha, base_mmd_mat.alpha)]
specular_offset = divide_vector_components(
work_mmd_mat.specular_color, base_mmd_mat.specular_color)
edge_offset = divide_vector_components(work_mmd_mat.edge_color,
base_mmd_mat.edge_color)
mat_data.diffuse_color = diffuse_offset
mat_data.specular_color = specular_offset
mat_data.shininess = special_division(work_mmd_mat.shininess,
base_mmd_mat.shininess)
mat_data.ambient_color = divide_vector_components(
work_mmd_mat.ambient_color, base_mmd_mat.ambient_color)
mat_data.edge_color = edge_offset
mat_data.edge_weight = special_division(
work_mmd_mat.edge_weight, base_mmd_mat.edge_weight)
except DivisionError:
mat_data.offset_type = "ADD" # If there is any 0 division we automatically switch it to type ADD
except ValueError:
self.report({'ERROR'}, 'An unexpected error happened')
# We should stop on our tracks and re-raise the exception
raise
if mat_data.offset_type == "ADD":
diffuse_offset = list(work_mmd_mat.diffuse_color -
base_mmd_mat.diffuse_color) + [
work_mmd_mat.alpha - base_mmd_mat.alpha
]
specular_offset = list(work_mmd_mat.specular_color -
base_mmd_mat.specular_color)
edge_offset = Vector(work_mmd_mat.edge_color) - Vector(
base_mmd_mat.edge_color)
mat_data.diffuse_color = diffuse_offset
mat_data.specular_color = specular_offset
mat_data.shininess = work_mmd_mat.shininess - base_mmd_mat.shininess
mat_data.ambient_color = work_mmd_mat.ambient_color - base_mmd_mat.ambient_color
mat_data.edge_color = list(edge_offset)
mat_data.edge_weight = work_mmd_mat.edge_weight - base_mmd_mat.edge_weight
mat = meshObj.data.materials.pop(index=copy_idx)
if mat.users < 1:
bpy.data.materials.remove(mat)
return {'FINISHED'}
def _getVisibilityOfMMDRigArmature(prop):
if prop.id_data.mmd_type != 'ROOT':
return False
rig = mmd_model.Model(prop.id_data)
arm = rig.armature()
return not (arm is None or arm.hide)
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 = rig.firstMesh()
if meshObj is None:
self.report({'ERROR'}, "The model mesh can't be found")
return {'CANCELLED'}
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_textures.active = uv_textures[base_uv_layers[
morph.uv_index].name]
uv_tex = uv_textures.new(name='__uv.%s' % uv_textures.active.name)
if uv_tex is None:
self.report({'ERROR'}, "Failed to create a temporary uv layer")
return {'CANCELLED'}
if len(morph.data) > 0:
base_uv_data = mesh.uv_layers.active.data
temp_uv_data = mesh.uv_layers[uv_tex.name].data
uv_id_map = {}
for uv_idx, l in enumerate(mesh.loops):
uv_id_map.setdefault(l.vertex_index, []).append(uv_idx)
if self.with_animation:
morph_name = '__uv.%s' % morph.name
a = mesh.animation_data_create()
act = bpy.data.actions.new(name=morph_name)
old_act = a.action
a.action = act
for data in morph.data:
offset = Vector(data.offset[:2]) # only use dx, dy
for i in uv_id_map.get(data.index, []):
t = temp_uv_data[i]
t.keyframe_insert('uv', frame=0, group=morph_name)
t.uv = base_uv_data[i].uv + offset
t.keyframe_insert('uv',
frame=100,
group=morph_name)
for fcurve in act.fcurves:
for kp in fcurve.keyframe_points:
kp.interpolation = 'LINEAR'
fcurve.lock = True
nla = a.nla_tracks.new()
nla.name = morph_name
nla.strips.new(name=morph_name, start=0, action=act)
a.action = old_act
context.scene.frame_current = 100
else:
for data in morph.data:
offset = Vector(data.offset[:2]) # only use dx, dy
for i in uv_id_map.get(data.index, []):
temp_uv_data[i].uv = base_uv_data[i].uv + offset
uv_textures.active = uv_tex
uv_tex.active_render = True
meshObj.hide = False
meshObj.select = selected
return {'FINISHED'}
def draw(self, context):
obj = context.active_object
layout = self.layout
c = layout.column()
c.prop(obj.mmd_rigid, 'name_j')
c.prop(obj.mmd_rigid, 'name_e')
c = layout.column(align=True)
row = c.row(align=True)
row.prop(obj.mmd_rigid, 'type', expand=True)
root = mmd_model.Model.findRoot(obj)
if root is None:
row = c.row(align=True)
row.enabled = False
row.prop(obj.mmd_rigid, 'bone', text='', icon='BONE_DATA')
else:
row = c.row(align=True)
armature = mmd_model.Model(root).armature()
row.prop_search(obj.mmd_rigid,
'bone',
text='',
search_data=armature.pose,
search_property='bones',
icon='BONE_DATA')
c = layout.column(align=True)
c.enabled = obj.mode == 'OBJECT'
c.row(align=True).prop(obj.mmd_rigid, 'shape', expand=True)
c.column(align=True).prop(obj.mmd_rigid, 'size', text='')
row = layout.row()
if obj.rigid_body is None:
row.operator('rigidbody.object_add', icon='MESH_ICOSPHERE')
return
c = row.column()
c.prop(obj.rigid_body, 'mass')
c.prop(obj.mmd_rigid, 'collision_group_number')
c = row.column()
c.prop(obj.rigid_body, 'restitution')
c.prop(obj.rigid_body, 'friction')
c = layout.column()
#c.prop(obj.mmd_rigid, 'collision_group_mask')
col = c.column(align=True)
col.label('Collision Group Mask:')
row = col.row(align=True)
for i in range(0, 8):
row.prop(obj.mmd_rigid,
'collision_group_mask',
index=i,
text=str(i),
toggle=True)
row = col.row(align=True)
for i in range(8, 16):
row.prop(obj.mmd_rigid,
'collision_group_mask',
index=i,
text=str(i),
toggle=True)
c = layout.column()
c.label('Damping')
row = c.row()
row.prop(obj.rigid_body, 'linear_damping')
row.prop(obj.rigid_body, 'angular_damping')