def retargetSkin(meshes=None):
"""
Creates new meshes retargeted to the root skeleton.
Args:
meshes(list): A list of meshes, defaults to the current selection.
"""
meshes = meshes or pmc.selected()
meshes = getMeshes(meshes)
newMeshes = []
for srcMesh in meshes:
# Create a duplicate mesh
dstParent = pmc.duplicate(srcMesh.getParent())
pmc.parent(dstParent, world=True)
# Copy the skinning
srcCluster = pmc.ls(srcMesh.listHistory(), type='skinCluster')[0]
dstCluster = pmc.skinCluster(dstParent, getBindSkeleton(), mi=4, tsb=True)
pmc.copySkinWeights(ss=srcCluster, ds=dstCluster, noMirror=True)
newMeshes.append(dstParent)
# If more than one mesh selected, combine meshes
if len(newMeshes) > 1:
newMesh, newCluster = pmc.polyUniteSkinned(newMeshes, ch=False)
pmc.delete(newMeshes)
pmc.rename(newMesh, 'body')
bindRootSkeleton()
def marge_run(self):
objects = common.search_polygon_mesh(self.objects, serchChildeNode=True, fullPath=True)
#print('marge target :', objects)
if len(objects) < 2:
self.marged_mesh = objects
return True
skined_list = []
no_skin_list = []
parent_list = [cmds.listRelatives(obj, p=True, f=True) for obj in objects]
for obj in objects:
skin = cmds.ls(cmds.listHistory(obj), type='skinCluster')
if skin:
skined_list.append(obj)
else:
no_skin_list.append(obj)
if no_skin_list and skined_list:
skined_mesh = skined_list[0]
for no_skin_mesh in no_skin_list:
weight.transfer_weight(skined_mesh, no_skin_mesh, transferWeight=False, returnInfluences=False, logTransfer=False)
if skined_list:
marged_mesh = pm.polyUniteSkinned(objects)[0]
pm.polyMergeVertex(marged_mesh, d=0.001)
target_mesh = pm.duplicate(marged_mesh)[0]
weight.transfer_weight(str(marged_mesh), str(target_mesh), transferWeight=True, returnInfluences=False, logTransfer=False)
else:
marged_mesh = pm.polyUnite(objects, o=True)[0]
pm.polyMergeVertex(marged_mesh, d=0.001)
target_mesh = pm.duplicate(marged_mesh)[0]
#pm.delete(objects)
for obj in objects:
if pm.ls(obj):
pm.delete(obj)
pm.delete(marged_mesh)
all_attr_list = [['.sx', '.sy', '.sz'], ['.rx', '.ry', '.rz'], ['.tx', '.ty', '.tz']]
for p_node in parent_list:
if cmds.ls(p_node, l=True):
all_lock_list = []
for attr_list in all_attr_list:
lock_list = []
for attr in attr_list:
lock_list.append(pm.getAttr(target_mesh+attr, lock=True))
pm.setAttr(target_mesh+attr, lock=False)
all_lock_list.append(lock_list)
pm.parent(target_mesh, p_node[0])
for lock_list, attr_list in zip(all_lock_list, all_attr_list):
for lock, attr in zip(lock_list, attr_list):
#continue
#print('lock attr :', lock, target_mesh, attr)
pm.setAttr(target_mesh+attr, lock=lock)
break
pm.rename(target_mesh, objects[0])
pm.select(target_mesh)
self.marged_mesh = str(target_mesh)
return True
def run(self):
cubes = list()
regexes = {}
if self.options.size_regexes:
for size_details in self.options.size_regexes.split(';'):
regex = re.compile(size_details.split(':')[0])
value = float(size_details.split(':')[1])
regexes[regex] = value
for joint in pm.PyNode('deformers').members():
size = self.options.size
for regex, size_variant in regexes.items():
if regex.search(joint.name()):
size = size_variant
break
cube, shape = pm.polyCube(
width=size,
height=size,
depth=size,
)
pm.delete(cube, constructionHistory=True)
cube.setMatrix(
joint.getMatrix(worldSpace=True),
worldSpace=True,
)
pm.skinCluster(
joint,
cube,
toSelectedBones=True,
)
cubes.append(cube)
mesh, skin = pm.polyUniteSkinned(
cubes,
ch=1,
mergeUVSets=1,
centerPivot=True,
)
pm.select(mesh)
pm.mel.BakeNonDefHistory()
def import_model(body_index, settings, loading_box):
global body_file
global palette
global resources
lba_model = read_lba2_model(body_file[body_index])
materials = []
if settings.use_palette:
pm.progressWindow(loading_box,
edit=True,
status="Generating Palette...",
progress=5)
# get list with all used palette values
for i in range(len(lba_model.polygons)):
materials.append(lba_model.polygons[i].colour)
for i in range(len(lba_model.spheres)):
materials.append(lba_model.spheres[i].colour)
for i in range(len(lba_model.lines)):
materials.append(lba_model.lines[i].colour)
materials = list(dict.fromkeys(materials))
create_materials(materials)
bones = None
if settings.use_rigging:
pm.progressWindow(loading_box,
edit=True,
status="Generating Bones...",
progress=10)
bones = bone_generator(lba_model.bones, lba_model.vertices)
# generate the main mesh
pm.progressWindow(loading_box,
edit=True,
status="Generating Mesh...",
progress=15)
model = mesh_generator(lba_model.vertices, lba_model.polygons,
lba_model.normals, materials, lba_model.bones,
bones, settings)
# generate the spheres
pm.progressWindow(loading_box,
edit=True,
status="Generating Spheres...",
progress=20)
spheres = sphere_generator(lba_model.spheres, lba_model.vertices, bones,
settings)
# generate the lines
pm.progressWindow(loading_box,
edit=True,
status="Generating Lines...",
progress=25)
lines = line_generator(lba_model.lines, lba_model.vertices, bones,
settings)
# unite all the rigged meshes
pm.progressWindow(loading_box,
edit=True,
status="Unifying...",
progress=40)
pm.select(clear=True)
pm.select(model, add=True)
pm.polyAutoProjection()
pm.select(clear=True)
pm.select(model, add=True)
pm.select(spheres, add=True)
pm.select(lines, add=True)
unified_mesh = None
if len(lba_model.spheres) > 0 or len(lba_model.lines) > 0:
unified_mesh = pm.polyUniteSkinned(
) if settings.use_rigging else pm.polyUnite()
if settings.use_rigging:
if unified_mesh is None:
pm.select(model, r=True)
else:
pm.select(unified_mesh, r=True)
pm.select(bones[0], add=True)
pm.group()
# ## Load Animations ## #
if settings.use_animation:
pm.progressWindow(loading_box,
edit=True,
status="Loading Animations...",
progress=45)
for resource in resources:
for body in resource.bodies:
if body.realIndex == body_index:
if len(resource.animations) > 0:
pm.progressWindow(
loading_box,
edit=True,
status="Generating Animations...",
progress=50)
anim_importer(bones, resource.animations,
loading_box)
pm.progressWindow(loading_box, endProgress=1)
return
else:
pm.progressWindow(loading_box, endProgress=1)
def oneSkin(arg = 2):
meshArg = pm.ls(sl = True)
if len(meshArg) == 1:
pm.confirmDialog(title = 'Error', message = 'Mesh is already one skin')
return
if arg == 0:#arg = 0 don't retain old data.
weightGeo = pm.polyUniteSkinned(meshArg, ch = True, mergeUVSets = True) #[0] is the mesh, [1] is the skindata
charaGeo = pm.duplicate(weightGeo[0], name = 'CharaGeo')
newSkinClust = pm.skinCluster(charaGeo, pm.skinCluster(weightGeo[1], q = True, influence = True)) #skin object
pm.select(weightGeo)
pm.select(charaGeo, add = True)
pm.copySkinWeights(noMirror = True, surfaceAssociation = 'closestComponent', influenceAssociation = 'oneToOne') #copying skin weights
pm.delete(meshArg, weightGeo)
pm.parent(charaGeo, world = True)
print('EKKO oneSkin successful!')
return charaGeo
elif arg == 1: #retain data
meshDupe = pm.duplicate(meshArg, rr = True)
skinDictionary = {}
counter = 0
for i in meshArg:
skinDictionary[i] = meshDupe[counter]
counter += 1
for i in meshArg:
pm.skinCluster(skinDictionary[i], pm.skinCluster(i, q = True, influence = True))
#copy skin first
for i in meshArg:
pm.select(i)
pm.select(skinDictionary[i], add = True)
pm.copySkinWeights(noMirror = True, surfaceAssociation = 'closestComponent', influenceAssociation = 'closestJoint') #copying skin weights
charaGeo = pm.polyUniteSkinned(meshDupe, ch = False) #charaGeo[0] is the mesh/transform, [1] is the skin node
pm.parent(charaGeo[0], world = True)
renamedGeo = pm.rename(charaGeo[0], 'CharaGeo')
pm.delete(meshDupe) #deleting garbage data
print('EKKO oneSkin successful!')
return renamedGeo
elif arg == 2: #original method, if mesh is unclean and keeps crashing
meshList = pm.duplicate(meshArg, rr = True)
charaGeo = pm.polyUnite(meshList, ch = False, name = 'CharaGeo')[0]
pm.delete(meshList) #deleting leftover garbage transform nodes
pm.parent(charaGeo, world = True)
newSkinClust = pm.skinCluster(charaGeo, pm.ls(type = 'joint')) #skinning begins
pm.select(meshArg)
pm.select(charaGeo, add = True)
pm.copySkinWeights(noMirror = True, surfaceAssociation = 'closestPoint', influenceAssociation = 'closestJoint') #copying skin weights
pm.selectMode(o = True)
pm.select(deselect = True)
pm.select(charaGeo)
print('EKKO oneSkin successful!')
return charaGeo
print('EKKO oneSkin successful!')
