def __call__(self, ext_weight):
weights=[ (self.skeleton.indexByName(w[0]), w[1]) \
for w in ext_weight.get_normalized(4, self.__filter) ]
if len(weights) == 0:
self.count_error += 1
return pmx.Bdef1(0) # Recovery
elif len(weights) == 1:
self.count_bdef1 += 1
return pmx.Bdef1(weights[0][0])
elif len(weights) == 2:
self.count_bdef2 += 1
return pmx.Bdef2(weights[0][0], weights[1][0], weights[0][1])
else:
if len(weights) == 3:
weights.append((0, 0.0)) # Dummy Data
self.count_bdef4 += 1
return pmx.Bdef4(weights[0][0], weights[1][0], weights[2][0],
weights[3][0], weights[0][1], weights[1][1],
weights[2][1], weights[3][1])
def savepmx(model, filename):
pmx_model = pmx.Model()
pmx_model.english_name = u'Empty model'
pmx_model.comment = u'NeoX Model Converterで生成'
pmx_model.english_comment = u'Created by NeoX Model Converter.'
parent_child_dict = {}
old2new = {}
index_pool = [-1]
bone_pool = []
for i in range(len(model['bone_parent'])):
p = model['bone_parent'][i]
if p not in parent_child_dict:
parent_child_dict[p] = []
parent_child_dict[p].append(i)
def build_joint(index, parent_index):
matrix = model['bone_original_matrix'][index]
x, y, z = tf.translation_from_matrix(matrix.T)
bone_pool.append(
pmx.Bone(name=model['bone_name'][index],
english_name=model['bone_name'][index],
position=common.Vector3(-x, y, -z),
parent_index=parent_index,
layer=0,
flag=0))
bone_pool[-1].setFlag(pmx.BONEFLAG_CAN_ROTATE, True)
bone_pool[-1].setFlag(pmx.BONEFLAG_IS_VISIBLE, True)
bone_pool[-1].setFlag(pmx.BONEFLAG_CAN_MANIPULATE, True)
def deep_first_search(index, index_pool, parent_index):
index_pool[0] += 1
current_node_index = index_pool[0]
old2new[index] = current_node_index
build_joint(index, parent_index)
if index in parent_child_dict:
for child in parent_child_dict[index]:
deep_first_search(child, index_pool, current_node_index)
deep_first_search(model['bone_parent'].index(-1), index_pool, -1)
pmx_model.bones = bone_pool
for i in range(len(model['position'])):
x, y, z = model['position'][i]
nx, ny, nz = model['normal'][i]
u, v = model['uv'][i]
if 65535 in model['vertex_joint'][i]:
vertex_joint_index = list(
map(lambda x: old2new[x]
if x != 65535 else 0, model['vertex_joint'][i]))
else:
vertex_joint_index = list(
map(lambda x: old2new[x]
if x != 255 else 0, model['vertex_joint'][i]))
vertex = pmx.Vertex(
common.Vector3(-x, y, -z), common.Vector3(-nx, ny, -nz),
common.Vector2(u, v),
pmx.Bdef4(*vertex_joint_index, *(model['vertex_joint_weight'][i])),
0.0)
pmx_model.vertices.append(vertex)
for i in range(len(model['face'])):
pmx_model.indices += list(model['face'][i])
pmx_model.materials[0].vertex_count = len(model['face']) * 3
###########
pmx_model.materials = []
for i in range(len(model['mesh'])):
_, mesh_face_count, _, _ = model['mesh'][i]
pmx_model.materials.append(
pmx.Material(u'Mat{}'.format(i), u'material{}'.format(i),
common.RGB(0.5, 0.5, 1), 1.0, 1, common.RGB(1, 1, 1),
common.RGB(0, 0, 0), 0, common.RGBA(0, 0, 0, 1), 0,
-1, -1, pmx.MATERIALSPHERE_NONE, 1, 0, u"comment",
mesh_face_count * 3))
filename = filename.replace('.mesh', '')
pymeshio.pmx.writer.write_to_file(pmx_model, filename + '.pmx')
for bone in pmx_model.bones:
if bone.english_name in paj_middle_bone_name:
bone.position.x = 0.0
if 'bip001_l_finger13' in [bone.english_name for bone in pmx_model.bones]:
paj_bone_name.update(paj_hand1_name)
else:
paj_bone_name.update(paj_hand0_name)
for bone in pmx_model.bones:
if bone.english_name in paj_bone_name:
bone.name = paj_bone_name[bone.english_name][0]
bone.english_name = paj_bone_name[bone.english_name][1]
def add_bone(pmxm, bone, index):
assert index <= len(pmxm.bones)
pmxm.bones.insert(index, bone)
for bone in pmxm.bones:
if bone.parent_index >= index:
bone.parent_index += 1
for vertex in pmxm.vertices:
if vertex.deform.index0 >= index:
vertex.deform.index0 += 1
if vertex.deform.index1 >= index:
vertex.deform.index1 += 1
if vertex.deform.index2 >= index:
vertex.deform.index2 += 1
if vertex.deform.index3 >= index:
vertex.deform.index3 += 1
return index
def find_bone_index_by_name(pmxm, bone_english_name):
ret = None
for i in range(len(pmxm.bones)):
if pmxm.bones[i].english_name == bone_english_name:
ret = i
break
return ret
#######################
parent_node_index = find_bone_index_by_name(pmx_model, 'ParentNode')
center_bone = pmx.Bone(name='センター',
english_name='Center',
position=common.Vector3(0, 8.0, 0),
parent_index=parent_node_index,
layer=0,
flag=0)
center_bone.setFlag(pmx.BONEFLAG_CAN_ROTATE, True)
center_bone.setFlag(pmx.BONEFLAG_IS_VISIBLE, True)
center_bone.setFlag(pmx.BONEFLAG_CAN_MANIPULATE, True)
waist_index = find_bone_index_by_name(pmx_model, 'Waist')
center_index = add_bone(pmx_model, center_bone, waist_index)
groove_bone = pmx.Bone(name='グルーブ',
english_name='Groove',
position=common.Vector3(0, 8.2, 0),
parent_index=center_index,
layer=0,
flag=0)
groove_bone.setFlag(pmx.BONEFLAG_CAN_ROTATE, True)
groove_bone.setFlag(pmx.BONEFLAG_IS_VISIBLE, True)
groove_bone.setFlag(pmx.BONEFLAG_CAN_MANIPULATE, True)
waist_index = find_bone_index_by_name(pmx_model, 'Waist')
groove_index = add_bone(pmx_model, groove_bone, waist_index)
waist_index = find_bone_index_by_name(pmx_model, 'Waist')
pmx_model.bones[waist_index].parent_index = groove_index
waist_index = find_bone_index_by_name(pmx_model, 'Waist')
upper_body_index = find_bone_index_by_name(pmx_model, 'UpperBody')
pmx_model.bones[upper_body_index].parent_index = waist_index
##########################
for LR in ['Left', 'Right']:
ankle_index = find_bone_index_by_name(pmx_model, '{}Ankle'.format(LR))
ankle_x, ankle_y, ankle_z = pmx_model.bones[
ankle_index].position.to_tuple()
toe_index = find_bone_index_by_name(pmx_model, '{}Toe'.format(LR))
toe_vec = pmx_model.bones[toe_index].position
toe_vec.y = ankle_y - 1.0
toe_vec.z = -1.65
leg_ik_parent_bone = pmx.Bone(
name='左足IK親' if LR == 'Left' else '右足IK親',
english_name='{}LegIkParent'.format(LR),
position=common.Vector3(ankle_x, 0, ankle_z),
parent_index=parent_node_index,
layer=0,
flag=0)
leg_ik_parent_bone.setFlag(pmx.BONEFLAG_CAN_ROTATE, True)
leg_ik_parent_bone.setFlag(pmx.BONEFLAG_CAN_TRANSLATE, True)
leg_ik_parent_bone.setFlag(pmx.BONEFLAG_IS_VISIBLE, True)
leg_ik_parent_bone.setFlag(pmx.BONEFLAG_CAN_MANIPULATE, True)
leg_ik_parent_index = add_bone(pmx_model, leg_ik_parent_bone,
len(pmx_model.bones))
leg_ik_bone = pmx.Bone(name='左足ＩＫ' if LR == 'Left' else '右足ＩＫ',
english_name='{}LegIk'.format(LR),
position=common.Vector3(ankle_x, ankle_y,
ankle_z),
parent_index=leg_ik_parent_index,
layer=0,
flag=0)
leg_ik_bone.setFlag(pmx.BONEFLAG_CAN_ROTATE, True)
leg_ik_bone.setFlag(pmx.BONEFLAG_CAN_TRANSLATE, True)
leg_ik_bone.setFlag(pmx.BONEFLAG_IS_IK, True)
leg_ik_bone.setFlag(pmx.BONEFLAG_IS_VISIBLE, True)
leg_ik_bone.setFlag(pmx.BONEFLAG_CAN_MANIPULATE, True)
knee_index = find_bone_index_by_name(pmx_model, '{}Knee'.format(LR))
leg_index = find_bone_index_by_name(pmx_model, '{}Leg'.format(LR))
leg_ik_link = [
pmx.IkLink(knee_index, 1, common.Vector3(-180.0 / 57.325, 0, 0),
common.Vector3(-0.5 / 57.325, 0, 0)),
pmx.IkLink(leg_index, 0)
]
leg_ik_bone.ik = pmx.Ik(ankle_index, 40, 2, leg_ik_link)
leg_ik_index = add_bone(pmx_model, leg_ik_bone, len(pmx_model.bones))
toe_ik_bone = pmx.Bone(name='左つま先ＩＫ' if LR == 'Left' else '右つま先ＩＫ',
english_name='{}LegIk'.format(LR),
position=common.Vector3(toe_vec.x, toe_vec.y,
toe_vec.z),
parent_index=leg_ik_index,
layer=0,
flag=0)
toe_ik_bone.setFlag(pmx.BONEFLAG_CAN_ROTATE, True)
toe_ik_bone.setFlag(pmx.BONEFLAG_CAN_TRANSLATE, True)
toe_ik_bone.setFlag(pmx.BONEFLAG_IS_IK, True)
toe_ik_bone.setFlag(pmx.BONEFLAG_IS_VISIBLE, True)
toe_ik_bone.setFlag(pmx.BONEFLAG_CAN_MANIPULATE, True)
toe_ik_bone.ik = pmx.Ik(toe_index, 3, 4, [pmx.IkLink(ankle_index, 0)])
add_bone(pmx_model, toe_ik_bone, len(pmx_model.bones))
'''
# build local axis and get rotation
left_arm_index = find_bone_index_by_name(pmx_model, 'LeftArm')
left_elbow_index = find_bone_index_by_name(pmx_model, 'LeftElbow')
left_wrist_index = find_bone_index_by_name(pmx_model, 'LeftWrist')
larm_pos = np.array(list(pmx_model.bones[left_arm_index].position.to_tuple()))
lelbow_pos = np.array(list(pmx_model.bones[left_elbow_index].position.to_tuple()))
lwrist_pos = np.array(list(pmx_model.bones[left_wrist_index].position.to_tuple()))
vec_ew = lwrist_pos - lelbow_pos
vec_ea = larm_pos - lelbow_pos
vec_ew = vec_ew / np.linalg.norm(vec_ew)
vec_ea = vec_ea / np.linalg.norm(vec_ea)
cos_ew_ea = np.dot(vec_ea, vec_ew)
if -1 * math.cos(3/180 * 3.14) < cos_ew_ea and cos_ew_ea < 0:
y_axis = np.cross(vec_ew, vec_ea)
y_axis = y_axis / np.linalg.norm(y_axis)
z_axis = np.cross(vec_ea, y_axis)
z_axis = z_axis / np.linalg.norm(z_axis)
x_axis = np.cross(z_axis, y_axis)
x_axis = x_axis / np.linalg.norm(x_axis)
# pmx_model.bones[left_elbow_index].setFlag(pmx.BONEFLAG_HAS_LOCAL_COORDINATE, True)
pmx_model.bones[left_elbow_index].local_x_vector = common.Vector3(*x_axis.tolist())
pmx_model.bones[left_elbow_index].local_z_vector = common.Vector3(*z_axis.tolist())
'''
head_index = find_bone_index_by_name(pmx_model, 'Head')
eyes_bone = pmx.Bone(name='両目',
english_name='Eyes',
position=common.Vector3(0, 25, 0),
parent_index=head_index,
layer=0,
flag=0)
eyes_bone.setFlag(pmx.BONEFLAG_CAN_ROTATE, True)
eyes_bone.setFlag(pmx.BONEFLAG_IS_VISIBLE, True)
eyes_bone.setFlag(pmx.BONEFLAG_CAN_MANIPULATE, True)
pmx_model.bones.append(eyes_bone)
eyes_index = find_bone_index_by_name(pmx_model, 'Eyes')
for LR in 'lr':
eyeball_index = find_bone_index_by_name(pmx_model,
'bone_eyeball_{}'.format(LR))
pmx_model.bones[eyeball_index].effect_index = eyes_index
pmx_model.bones[eyeball_index].effect_factor = 2.2
pmx_model.bones[eyeball_index].setFlag(
pmx.BONEFLAG_IS_EXTERNAL_ROTATION, True)
'''
morph_ref_model = pymeshio.pmx.reader.read_from_file('morph_ref')
pmx_model.morphs = morph_ref_model.morphs
for morph in pmx_model.morphs:
for offset in morph.offsets:
bone_english_name = morph_ref_model.bones[offset.bone_index].english_name
offset.bone_index = find_bone_index_by_name(pmx_model, bone_english_name)
'''
pymeshio.pmx.writer.write_to_file(pmx_model, filename + '_modified.pmx')
def khiankhuen(chue_tem_file='',khanat_ok=0.125,chai_kraduk=1,chai_bs=1,chai_watsadu=1,lok_tex=1,mod_sph=1,tex_sph=''):
t0 = time.time()
chue_path_file = os.path.dirname(chue_tem_file)
shoki = os.path.join(os.path.dirname(__file__),u'shoki.pmx')
model = pmxread(shoki) # สร้างโมเดล pmx ตั้งต้น
# เพื่อความรวดเร็ว ดึง append มาเก็บไว้ก่อน
model_vert_ap = model.vertices.append
model_ind_ap = model.indices.append
model_bon_ap = model.bones.append
model_mat_ap = model.materials.append
model_mor_ap = model.morphs.append
model_slot_ap1 = model.display_slots[1].references.append
model_slot_ap2 = model.display_slots[2].references.append
# โหนดโพลิกอนทั้งหมดที่เลือกอยู่
list_chue_nod_poly = mc.filterExpand(mc.ls(tr=1,sl=1),sm=12)
list_chue_nod_shep = []
list_chue_nod_skin = []
list_matrix_mun = [0]
if(list_chue_nod_poly==None): # กรณีที่ไม่ได้เลือกโพลิกอนไว้เลย
print(u'ポリゴンは選択せれていません')
return
for chue_nod_poly in list_chue_nod_poly:
# โหนดรูปร่างของโพลิกอนนั้นๆ
chue_nod_shep = mc.listRelatives(chue_nod_poly,s=1)[0]
list_chue_nod_shep.append(chue_nod_shep)
# หาโหนด skin ที่ใช้กับโพลิกอนนั้นๆ
if(chai_kraduk):
for chue_nod_skin in mc.ls(typ='skinCluster'):
if(chue_nod_shep in mc.skinCluster(chue_nod_skin,q=1,g=1)):
list_chue_nod_skin.append(chue_nod_skin)
break
# ถ้าหาไม่เจอก็คือไม่มี
else:
list_chue_nod_skin.append(0)
if(chai_kraduk):
dic_chue_nod_kho = {u'全ての親':0}
i_kho = 1
for k in mc.ls(typ='joint',l=1):
# ถ้ามีอยู่แล้วก็ข้ามไปได้เลย
if(k in dic_chue_nod_kho):
continue
# หาว่าตรึงอยู่กับสกินที่ใช้หรือเปล่า
for chue_nod_skin in list_chue_nod_skin:
if(chue_nod_skin and k in (pm.PyNode(x).fullPath() for x in mc.skinCluster(chue_nod_skin,q=1,inf=1))):
break
# ถ้าไม่มีเลยก็ข้ามไป
else:
continue
# หาตัวรากฐาน
parent = mc.listRelatives(k,p=1,f=1)
if(parent):
pp = ['']
for p in parent[0].split('|')[1:]:
pp.append(p)
pj = '|'.join(pp)
if(mc.nodeType(pj)=='joint'):
parent = pj
break
else:
parent = k
else:
parent = k # ถ้าไม่มีก็คือตัวมันเองเป็น
# ถ้าตัวรากฐานมีอยู่แล้วก็ข้ามไปได้เลย
if(parent in dic_chue_nod_kho):
continue
# ถ้ายังไม่มีก็ใส่ข้อมูลเข้าไปทั้งตัวรากฐานและลูกทั้งหมด
list_child = mc.listRelatives(parent,ad=1,f=1)
list_cp = [parent]
if(list_child):
list_cp += list(reversed(list_child))
for j,chue_nod_kho in enumerate(list_cp):
dic_chue_nod_kho[chue_nod_kho] = i_kho+j
for chue_nod_kho in list_cp:
if(mc.objExists(chue_nod_kho+'.namae')):
namae = mc.getAttr(chue_nod_kho+'.namae')
else:
namae = u'骨%d'%i_kho
kw = {'name':namae,'english_name':chue_nod_kho,'layer':0,'flag':2074}
kho = pm.PyNode(chue_nod_kho)
p = kho.getTranslation(space='world')
kw['position'] = common.Vector3(p.x*khanat_ok,p.y*khanat_ok,-1*p.z*khanat_ok)
try:
chue_parent = kho.getParent().fullPath()
parent_index = dic_chue_nod_kho[chue_parent]
kw['parent_index'] = parent_index
except:
parent_index = 0
kw['parent_index'] = 0
kw['flag'] += 4 # ให้ขยับได้อิสระ
child = kho.getChildren()
if(len(child)==1):
kw['tail_index'] = dic_chue_nod_kho[child[0].fullPath()]
kw['flag'] += 1
else:
kw['tail_index'] = -1
jo = mc.getAttr(chue_nod_kho+'.jo')[0]
mm = list_matrix_mun[parent_index]
if(jo==(0,0,0)):
if(not mm):
kw['flag'] -= 2048
list_matrix_mun.append(mm)
else:
mm *= 1
if(mm):
mm *= om.MEulerRotation(math.radians(jo[0]),math.radians(jo[1]),math.radians(jo[2])).asMatrix()
else:
mm = om.MEulerRotation(math.radians(jo[0]),math.radians(jo[1]),math.radians(jo[2])).asMatrix()
list_matrix_mun.append(mm)
if(mm):
kw['local_x_vector'] = common.Vector3(mm(0,0),mm(0,1),-mm(0,2))
kw['local_z_vector'] = common.Vector3(mm(2,0),mm(2,1),-mm(2,2))
model_bon_ap(pmx.Bone(**kw))
# ใส่ข้อต่อลงในแผงควบคุม ถ้าไม่ใช่ท่อนปลายสุด
if(child):
model_slot_ap2((0,i_kho))
i_kho += 1
list_tamnaeng = []
list_norm = []
list_u = []
list_v = []
list_lek_tamnaeng_nai_na = []
list_na_to_poly = []
list_chut_to_poly = []
lai_lek_tamnaeng = 0
lai_lek_norm = 0
lai_lek_uv = 0
list_lek_chut_mai = []
dic_str_chut = {}
lai_lek = 0
list_chue_nod_bs = mc.ls(typ='blendShape')
i_poly = 0 # โพลิกอนอันที่เท่าไหร่
for chue_nod_poly in list_chue_nod_poly:
chue_nod_shep = list_chue_nod_shep[i_poly]
try:
nod_shep = pm.PyNode(chue_nod_shep)
except pm.MayaNodeError:
print(u'特殊なポリゴンが含まれる可能性があります。ポリゴンを結合しておいてください')
raise # กรณีที่เป็นโพลิกอนที่สร้างมาจากวิธีที่เหนือความคาดหมายอาจมีข้อผิดพลาด แก้ได้โดยรวมโพลิกอนที่มีปัญหา
if(chai_kraduk):
chue_nod_skin = list_chue_nod_skin[i_poly]
if(chue_nod_skin):
dic_kho = {} # ดิกเชื่อมโยงเลขข้อสำหรับสกินนี้ กับเลขดัชนีของข้อต่อที่ลำดับตามดิกที่สร้างตอนแรก
for i,chue_nod_kho in enumerate(mc.skinCluster(chue_nod_skin,q=1,inf=1)):
dic_kho[i] = dic_chue_nod_kho[pm.PyNode(chue_nod_kho).fullPath()]
# โค้ดยาวๆก้อนนี้มีไว้เพื่อดึงข้อมูลน้ำหนักที่เชื่อมข้อต่อกับโพลิกอน
nod_skin = pm.PyNode(chue_nod_skin)
obj_skin = om.MObject()
sl = om.MSelectionList()
sl.add(nod_skin.name())
sl.getDependNode(0,obj_skin)
fn_skin = oma.MFnSkinCluster(obj_skin)
path_mesh = om.MDagPath()
sl = om.MSelectionList()
sl.add(nod_shep.fullPath())
sl.getDagPath(0,path_mesh)
nod_shep.fullPath()
path_inf = om.MDagPathArray()
n_inf = fn_skin.influenceObjects(path_inf)
util = om.MScriptUtil()
util.createFromList(range(n_inf),n_inf)
id_inf = om.MIntArray(util.asIntPtr(),n_inf)
n_vert = nod_shep.numVertices()
fn_comp = om.MFnSingleIndexedComponent()
components = fn_comp.create(om.MFn.kMeshVertComponent)
util = om.MScriptUtil()
util.createFromList(range(n_vert),n_vert)
id_vert = om.MIntArray(util.asIntPtr(),n_vert)
fn_comp.addElements(id_vert)
list_namnak = om.MDoubleArray() # ได้ข้อมูลน้ำหนักเป็นลิสต์ ยาว = จำนวนข้อ x จำนวนจุดยอด
fn_skin.getWeights(path_mesh,components,id_inf,list_namnak)
n_kho = len(dic_kho) # จำนวนข้อ
if(chai_bs):
w = [] # ลิสต์เก็บค่าน้ำหนักเดิมของเบลนด์เชปทั้งหมด
# หาเบลนด์เชปคัดเอาเฉพาะที่เชื่อมกับโพลิกอนตัวนี้อยู่
list_chue_nod_bs_ni = []
for chue_nod_bs in list_chue_nod_bs:
# ดูว่านี่เป็นโพลิกอนที่เชื่อมอยู่กับเบลนด์เชปอันนี้หรือเปล่า
if(chue_nod_shep not in mc.blendShape(chue_nod_bs,q=1,g=1)):
continue
try: # try เพื่อกันกรณีที่มีโหนดเบลนด์เชปอยู่แต่ไม่มีเบลนด์เชปอยู่เลย
ww = mc.getAttr(chue_nod_bs+'.w[*]') # เก็บค่าน้ำหนักปัจจุบันไว้
except:
continue
if(type(ww)==float):
ww = [ww] # เพื่อกันกรณีที่มีอยู่แค่ตัวเดียว จะได้ค่าไม่เป็นลิสต์ ต้องทำให้เป็นลิสต์เหมือนกันหมด
w.append(ww)
mc.setAttr(chue_nod_bs+'.w[*]',*[0]*len(ww)) # ตั้งน้ำหนักให้เป็น 0 ไว้ก่อน
list_chue_nod_bs_ni.append(chue_nod_bs)
# เก็บค่าตำแหน่งจุด
tamnaeng = nod_shep.getPoints(space='world')
list_tamnaeng.extend(tamnaeng)
list_chut_to_na,vertid = nod_shep.getVertices()
chut_to_poly = len(vertid)
# เก็บค่าเส้นตั้งฉาก
norm = nod_shep.getNormals(space='world')
list_norm.extend(norm)
normid = nod_shep.getNormalIds()[1]
# เก็บค่า uv
u,v = nod_shep.getUVs()
list_u.extend(u)
list_v.extend(v)
uvid = nod_shep.getAssignedUVs()[1]
list_samliam_to_na,list_lek_chut = nod_shep.getTriangles()
list_lek_tamnaeng_nai_na_to_poly = []
lai_samliam = 0
# ดึงข้อมูลเบลนด์เชป
list_chue_bs = []
if(chai_bs):
list_tamnaeng_bs = []
list_luean_bs = []
list_luean_bs_ap = []
for i,chue_nod_bs in enumerate(list_chue_nod_bs_ni):
# ถ้ามีข้อมูลชื่อญี่ปุ่นหรือช่องให้ดึงมา
if(mc.objExists(chue_nod_bs+'.namae')):
try:
dic_namae = dict(namae.split(u'๑',1) for namae in mc.getAttr(chue_nod_bs+'.namae').split(u'๐'))
except:
dic_namae = {}
else:
dic_namae = {}
lenw = len(w[i]) # จำนวนเบลนด์เชปในโหนดนั้นๆ
for i,bs in enumerate(mc.listAttr(chue_nod_bs+'.w',m=1)):
# ตั้งให้น้ำหนักเป็น 1 แค่แบบเดียวทีละแบบ ที่เหลือเป็น 0 ไปก่อน
ww = [0]*lenw
ww[i] = 1
mc.setAttr(chue_nod_bs+'.w[*]',*ww)
# ดึงข้อมูลตำแหน่งที่เลื่อนแล่้ว
tamnaeng_bs = nod_shep.getPoints(space='world')
list_tamnaeng_bs.append(tamnaeng_bs)
if(bs in dic_namae):
namae = dic_namae[bs].split(u'๑')
try:
list_chue_bs.append((namae[0],bs,int(namae[1])))
except:
list_chue_bs.append((namae[0],bs,4))
# ถ้าไม่ได้มีชื่อที่ตั้งเก็บไว้ในโหนดแต่แรกก็ให้ใช้ทั้งชื่อญี่ปุ่นและชื่ออังกฤษเป็นชื่อเดียวกัน
else:
list_chue_bs.append((bs,bs,4))
luean_bs = []
list_luean_bs.append(luean_bs)
list_luean_bs_ap.append(luean_bs.append)
# เปลี่ยนรูปร่างกลับคืนเดิมด้วย
for i,chue_nod_bs in enumerate(list_chue_nod_bs_ni):
mc.setAttr(chue_nod_bs+'.w[*]',*w[i])
n_bs = len(list_chue_bs)
list_lek_chut_mai_to_poly = []
i = 0
for samliam_to_na,chut_to_na in zip(list_samliam_to_na,list_chut_to_na):
dic_lai_lek = {}
for j in range(chut_to_na):
lek_tamnaeng = vertid[i]
lek_norm = normid[i]
lek_uv = uvid[i]
str_chut = '%d:%d:%d'%(lek_tamnaeng+lai_lek_tamnaeng,lek_norm+lai_lek_norm,lek_uv+lai_lek_uv)
if(str_chut in dic_str_chut):
lek_chut_mai = dic_str_chut[str_chut]
else:
lek_chut_mai = lai_lek
dic_str_chut[str_chut] = lek_chut_mai
#ถ้ามีเชื่อมสกินอยู่ก็ดึงน้ำหนักมาใช้
if(chai_kraduk and chue_nod_skin):
w = [] # ลิสต์เก็บทูเพิลของ (ดัชนีข้อ,ค่าน้ำหนัก)
# ดึงข้อมูลน้ำหนักจากลิสต์น้ำหนัก ความยาวเท่ากับจำนวนข้อ
for i_namnak,namnak in enumerate(list_namnak[lek_tamnaeng*n_kho:(lek_tamnaeng+1)*n_kho]):
# คัดเฉพาะที่ไม่น้อยจนเกือบ 0 เท่านั้น
if(namnak>0.001):
w.append((dic_kho[i_namnak],namnak))
if(len(w)>3):
# ถ้ามากเกิน 4 ให้เรียงเอาอันที่มากก็พอ
if(len(w)>4):
w.sort(key=f_riang_namnak,reverse=1)
w = w[:4]
w_ruam = w[0][1]+w[1][1]+w[2][1]+w[3][1]
ww0 = w[0][1]/w_ruam
ww1 = w[1][1]/w_ruam
ww2 = w[2][1]/w_ruam
ww3 = w[3][1]/w_ruam
deform = pmx.Bdef4(w[0][0],w[1][0],w[2][0],w[3][0],ww0,ww1,ww2,ww3)
elif(len(w)==3):
w_ruam = w[0][1]+w[1][1]+w[2][1]
ww0 = w[0][1]/w_ruam
ww1 = w[1][1]/w_ruam
ww2 = w[2][1]/w_ruam
deform = pmx.Bdef4(w[0][0],w[1][0],w[2][0],-1,ww0,ww1,ww2,0.)
elif(len(w)==2):
ww0 = w[0][1]/(w[0][1]+w[1][1])
deform = pmx.Bdef2(w[0][0],w[1][0],ww0)
elif(len(w)==1):
deform = pmx.Bdef1(w[0][0])
else:
deform = pmx.Bdef1(0)
# ถ้าไม่ได้เชื่อมกับสกินก็ให้ตรึงกับข้อรากฐานให้หมด
else:
deform = pmx.Bdef1(0)
p = list_tamnaeng[lek_tamnaeng+lai_lek_tamnaeng]
position = common.Vector3(p[0]*khanat_ok,p[1]*khanat_ok,-p[2]*khanat_ok)
nm = list_norm[lek_norm+lai_lek_norm]
normal = common.Vector3(nm[0],nm[1],-nm[2])
uv = common.Vector2(list_u[lek_uv+lai_lek_uv],1.-list_v[lek_uv+lai_lek_uv])
# สร้างจุดจากข้อมูลที่ดึงมาได้ แล้วเพื่มเข้าไปในลิสต์ของจุด
vertex = pmx.Vertex(position,normal,uv,deform,edge_factor=1.)
model_vert_ap(vertex)
for i_bs in range(n_bs):
p1 = list_tamnaeng_bs[i_bs][lek_tamnaeng]
po = common.Vector3((p1[0]-p[0])*khanat_ok,(p1[1]-p[1])*khanat_ok,(p[2]-p1[2])*khanat_ok)
# เอาข้อมูลเฉพาะจุดที่มีการเปลี่ยนตำแหน่ง
if(po.getNorm()>0):
list_luean_bs_ap[i_bs](pmx.VertexMorphOffset(lai_lek,po))
lai_lek += 1
dic_lai_lek[lek_tamnaeng+lai_lek_tamnaeng] = lek_chut_mai
i += 1
ll = []
for j in range(lai_samliam*3,(lai_samliam+samliam_to_na)*3,3):
for jj in range(3):
lek_tamnaeng = list_lek_chut[j+2-jj]
lek_chut_mai = dic_lai_lek[lek_tamnaeng+lai_lek_tamnaeng]
ll.append(lek_chut_mai)
lai_samliam += samliam_to_na
list_lek_chut_mai_to_poly.append(ll)
# สร้างมอร์ฟทั้งหมดจากข้อมูลเบลนด์เชปที่เตรียมไว้
if(chai_bs):
for i_mor,(chue_bs,luean_bs) in enumerate(zip(list_chue_bs,list_luean_bs)):
model_mor_ap(pmx.Morph(name=chue_bs[0],english_name=chue_bs[1],panel=chue_bs[2],morph_type=1,offsets=luean_bs))
model_slot_ap1((1,i_mor))
list_na_to_poly.append(vertid)
list_chut_to_poly.append(chut_to_poly)
lai_lek_tamnaeng += len(tamnaeng)
lai_lek_norm += len(norm)
lai_lek_uv += len(u)
list_lek_tamnaeng_nai_na.append(list_lek_tamnaeng_nai_na_to_poly)
list_lek_chut_mai.append(list_lek_chut_mai_to_poly)
i_poly += 1
# ถ้าเลือกจะสร้างวัสดุด้วยก็สร้างแล้วเรียงจุดในหน้าตามวัสดุ
if(chai_watsadu):
list_chue_nod_mat = [] # ลิสต์เก็บโหนดวัสดุ
list_chue_nod_sg = [] # ลิสต์เก็บโหนด sg
i_tex = 0 # ดัชนีเท็กซ์เจอร์
i_mat = 0 # ดัชนีวัสดุ
for mat in mc.ls(mat=1):
# เอาเฉพาะวัสดุที่มี sg เท่านั้น
try:
liscon = mc.listConnections(mat+'.outColor')
sg = liscon[0]
list_na = mc.sets(sg,q=1) # ดูว่ามีหน้าไหนที่ใช้วัสดุนี้
if(not list_na):
if(len(liscon)>1):
sg = liscon[1]
list_na = mc.sets(sg,q=1)
# หากไม่ถูกใช้อยู่ก็ข้าม
if(not list_na):
continue
except:
continue
n_chut_to_mat = 0 # จำนวนจุดของหน้านี้ (= 3 เท่าของจำนวนหน้า)
for na in list_na:
if('[' in na):
chue_nod_poly,na0,na1 = re.findall(r'(\w+).f\[(\d+):?(\d+)?]',na)[0]
na0 = int(na0)
if(na1==''):
na1 = na0
else:
na1 = int(na1)
else:
chue_nod_poly = mc.listRelatives(na,p=1)[0]
na0 = 0
na1 = mc.polyEvaluate(chue_nod_poly,f=1)-1
# ถ้าอยู่ในลิสต์ของโพลิกอนที่เลือกอยู่ให้หาเลขดัชนีของโพลิกอนนั้นในลิสต์
if(chue_nod_poly in list_chue_nod_poly):
lek_nod_poly = list_chue_nod_poly.index(chue_nod_poly)
# ถ้าไม่อยู่ในลิสต์ก็ข้ามไปเลย
else:
continue
for lai_na in range(na0,na1+1):
for lek in list_lek_chut_mai[lek_nod_poly][lai_na]:
model_ind_ap(lek)
n_chut_to_mat += 1
# ถ้าวัสดุนี้ไม่ถูกใช้ในโพลิกอนที่เลือกอยู่เลยก็ข้าม
if(n_chut_to_mat==0):
continue
if(mc.objExists(mat+'.namae')):
namae = mc.getAttr(mat+'.namae')
else:
namae = u'材質%d'%(i_mat+1)
# ค่าองค์ประกอบต่างๆของวัสดุ เก็บไว้ในดิกก่อน
kw = {'name':namae,'english_name':mat,
'diffuse_color':common.RGB(1,1,1),'alpha':1,
'specular_factor':0.5,'specular_color':common.RGB(0.,0.,0.),
'ambient_color':common.RGB(0.5,0.5,0.5),
'flag':1,'edge_color':common.RGBA(0.,0.,0.,1.),'edge_size':1,
'texture_index':-1,'sphere_texture_index':-1,'sphere_mode':0,
'toon_sharing_flag':0,'toon_texture_index':-1,'vertex_count':n_chut_to_mat}
# ใส่ try กันกรณีที่เป็นวัสดุชนิดแปลกๆที่ไม่สามารถอ่านค่าได้ปกติ
try:
nodetype = mc.nodeType(mat) # ชนิดของวัสดุ
# หาดูว่าวัสดุนี้ใช้เท็กซ์เจอร์หรือไม่
if(nodetype!='aiStandardSurface'):
chue_nod_tex = mc.listConnections(mat+'.color')
else:
chue_nod_tex = mc.listConnections(mat+'.baseColor')
# ถ้ามีเท็กซ์เจอร์ และเป็นไฟล์
if(chue_nod_tex):
if(mc.nodeType(chue_nod_tex[0])=='file'):
chue_tem_file_tex = mc.getAttr(chue_nod_tex[0]+'.ftn') # ชื่อไฟล์
# ถ้ามีชื่อไฟล์นี้อยู่แล้ว
if(chue_tem_file_tex in model.textures):
kw['texture_index'] = model.textures.index(chue_tem_file_tex)
# ถ้ายังไม่มีก็เพิ่มเข้าไป
else:
chue_tex = os.path.basename(chue_tem_file_tex)
model.textures.append(chue_tex)
# ถ้าเลือกว่าจะคัดลอกไฟล์เท็กซ์เจอร์ก็ทำการคัดลอก
if(lok_tex):
shutil.copyfile(chue_tem_file_tex,os.path.join(chue_path_file,chue_tex))
kw['texture_index'] = i_tex
i_tex += 1 # นับไล่ดัชนีเท็กซ์เจอร์ต่อ
else:
print(u'テクスチャ%sはファイルではないため使えません'%chue_nod_tex[0])
dc = [1.,1.,1.]
# ถ้าไม่ใช้เท็กซ์เจอร์ไฟล์จึงกำหนดสีผิว
else:
if(nodetype!='aiStandardSurface'):
dc = mc.getAttr(mat+'.color')[0]
else:
dc = mc.getAttr(mat+'.baseColor')[0]
dc = [min(max(s,0.),1.) for s in dc]
kw['diffuse_color'] = common.RGB(*dc)
if(nodetype not in ['aiStandard','aiStandardSurface']):
tran = sum(mc.getAttr(mat+'.transparency')[0])/3 # ความโปร่งใสใช้เป็นค่าเฉลี่ย
kw['alpha'] = min(max(1-tran,0),1.)
# ค่าสีแอมเบียนต์ให้คูณสีผิวไปด้วย
ac = [min(max(s,0.),1.)*d for s,d in zip(mc.getAttr(mat+'.ambientColor')[0],dc)]
kw['ambient_color'] = common.RGB(*ac)
# เฉพาะ blinn เท่านั้นจึงเก็บค่าสเป็กคิวลาร์ นอกนั้นใช้ค่าตั้งต้น
if(nodetype=='blinn'):
sr = min(max(mc.getAttr(mat+'.specularRollOff'),0.1),1.)
kw['specular_factor'] = round(math.pow(2,math.log(sr,0.75)-1))
kw['specular_color'] = common.RGB(*[min(max(s,0.),1.) for s in mc.getAttr(mat+'.specularColor')[0]])
# กรณี aiStandard
else:
opa = sum(mc.getAttr(mat+'.opacity')[0])/3 # ความทึบแสงใช้เป็นค่าเฉลี่ย
kw['alpha'] = min(max(opa,0.),1.)
if(nodetype!='aiStandardSurface'):
kw['specular_color'] = common.RGB(*[min(max(s,0.),1.) for s in mc.getAttr(mat+'.KsColor')[0]])
else:
kw['specular_color'] = common.RGB(*[min(max(s,0.),1.) for s in mc.getAttr(mat+'.specularColor')[0]])
sr = max(mc.getAttr(mat+'.specularRoughness'),0.1)
kw['specular_factor'] = round(math.pow(2,math.log(sr,0.75)-1))
kw['ambient_color'] = common.RGB(0,0,0)
except:
print(u'材質%sに問題が見つかりました'%mat)
model_mat_ap(pmx.Material(**kw)) # เพิ่มวัสดุเข้าไปในโมเดล
list_chue_nod_mat.append(mat)
list_chue_nod_sg.append(sg)
i_mat += 1
if(mod_sph):
i = len(model.textures)
model.textures.append(tex_sph)
for mat in model.materials:
mat.sphere_mode = mod_sph
mat.sphere_texture_index = i
# ถ้าเลือกไม่เอาวัสดุก็ให้ใช้เป็นวัสดุตั้งต้นแบบเดียวกันหมด
else:
n_chut_to_mat = 0
for list_lek_chut_nai_poly in list_lek_chut_mai:
for list_lek_chut_nai_na in list_lek_chut_nai_poly:
n_chut_to_mat += len(list_lek_chut_nai_na)
for lek_chut in list_lek_chut_nai_na:
model_ind_ap(lek_chut)
model_mat_ap(pmx.Material(name=u'材質1',english_name='',
diffuse_color=common.RGB(0.5,0.5,0.5),alpha=1,
specular_factor=0.5,specular_color=common.RGB(0.5,0.5,0.5),
ambient_color=common.RGB(0.25,0.25,0.25),
flag=1,edge_color=common.RGBA(0.,0.,0.,1.),edge_size=1,
texture_index=-1,sphere_texture_index=-1,sphere_mode=0,
toon_sharing_flag=0,toon_texture_index=-1,vertex_count=n_chut_to_mat))
chue_model = os.path.basename(chue_tem_file).split('.')[0]
model.name = chue_model
model.english_name = chue_model
if(not model.display_slots[2].references):
model.display_slots.pop()
with io.open(chue_tem_file,'wb') as s:
pmxwri(s,model)
mc.select(list_chue_nod_poly)
print(u'ファイル%s作成完了。%.2f秒かかりました'%(chue_tem_file,time.time()-t0))