def on_btn_ok_clicked(self):
print 'btn_ok_clicked'
with pymel.UndoChunk():
make_planer.project_vertex(mode=self.cb_mode.currentText(),
x=self.rb_x.isChecked(),
y=self.rb_y.isChecked(),
z=self.rb_z.isChecked())
def keyObj(model, object_names):
"""
Set the keyframe in the controls pass by a list in obj_names variable
:param model: Name of the namespace that will define de the model
:param object_names: names of the controls, without the name space
:return: None
"""
with pm.UndoChunk():
nodes = []
nameSpace = getNamespace(model)
for name in object_names:
if nameSpace:
node = getNode(nameSpace + ":" + name)
else:
node = getNode(name)
if not node:
continue
if not node and nameSpace:
mgear.log("Can't find object : %s:%s" % (nameSpace, name),
mgear.sev_error)
elif not node:
mgear.log("Can't find object : %s" % (name), mgear.sev_error)
nodes.append(node)
if not nodes:
return
pm.setKeyframe(*nodes)
def mouseReleaseEvent_(self, event):
# type: (QtGui.QMouseEvent) -> None
if not self.origin:
self.origin = event.pos()
selected = []
rect = QtCore.QRect(self.origin, event.pos()).normalized()
for child in self.findChildren(widgets.SelectButton):
# if rect.intersects(child.geometry()):
if rect.intersects(self._getButtonAbsoluteGeometry(child)):
selected.append(child)
if selected:
firstLoop = True
with pm.UndoChunk():
for wi in selected:
wi.rectangleSelection(event, firstLoop)
firstLoop = False
else:
if event.modifiers() == QtCore.Qt.NoModifier:
pm.select(cl=True)
pm.displayInfo("Clear selection")
self.origin = None
QtWidgets.QWidget.mouseReleaseEvent(self, event)
def _importConfiguration(configDict):
with pm.UndoChunk():
for sm in configDict["softMods"]:
smConfig = configDict[sm]
targets = []
for t in smConfig["affected"]:
try:
targets.append(pm.PyNode(t))
except pm.MayaNodeError:
pm.displayWarning("{}: has not been found in the scene "
"and will be skipped".format(t))
name = smConfig["name"]
parent = smConfig["rootParent"]
size = smConfig["iconSize"]
grp = smConfig["grpName"]
rootMatrix = datatypes.Matrix(smConfig["rootMatrix"])
softModNode, baseCtl, tweakCtl = createSoftTweak(name,
targets=targets,
parent=parent,
t=rootMatrix,
grp=grp,
size=size)
if softModNode:
ctlBaseMatrix = datatypes.Matrix(smConfig["baseCtlMatrix"])
ctlMatrix = datatypes.Matrix(smConfig["ctlMatrix"])
baseCtl.setMatrix(ctlBaseMatrix, objectSpace=True)
tweakCtl.setMatrix(ctlMatrix, objectSpace=True)
tweakCtl.falloff.set(smConfig["falloff"])
# we have to set the matrix again on the root because is stored
# in local space
baseCtl.getParent().setMatrix(rootMatrix, objectSpace=True)
def createSoftTweak(name,
targets=[],
parent=None,
t=None,
grp=None,
size=0.5,
nameExt="softMod",
is_asset=False):
with pm.UndoChunk():
if isinstance(targets, basestring):
targets = pm.PyNode(targets)
if not isinstance(targets, list):
targets = [targets]
if not targets:
pm.displayWarning("Can't find the targets to apply to "
"softModTweak or Targets not selectedIndexes")
return False, False, False
# namespace basic handling
# NOTE: Doesn't support more than one namespace stacked
if pm.ls(parent) and len(name.split(":")) < 2:
name = pm.PyNode(parent).namespace() + name
baseCtl, tweakCtl = _createSoftTweakControls(name, parent, t, grp,
size)
if baseCtl:
softModNode = _createSoftModTweak(baseCtl, tweakCtl, name, targets,
nameExt, is_asset)
return softModNode, baseCtl, tweakCtl
else:
return False, False, False
def selectObj(model, object_names, mouse_button, key_modifier):
if not model:
return
nameSpace = getNamespace(model)
with pm.UndoChunk():
nodes = []
for name in object_names:
if nameSpace:
node = getNode(nameSpace + ":" + name)
else:
node = getNode(name)
if not node:
continue
if not node and nameSpace:
mgear.log("Can't find object : %s:%s" % (nameSpace, name),
mgear.sev_error)
elif not node:
mgear.log("Can't find object : %s" % (name), mgear.sev_error)
nodes.append(node)
if not nodes:
return
if mouse_button == QtCore.Qt.RightButton:
mirrorPose(False, nodes)
return
if mouse_button == QtCore.Qt.MiddleButton:
mirrorPose(True, nodes)
return
# Key pressed
if key_modifier is None:
pm.select(nodes)
elif key_modifier == QtCore.Qt.NoModifier: # No Key
pm.select(nodes)
elif key_modifier == QtCore.Qt.ControlModifier: # ctrl
pm.select(nodes, deselect=True)
elif key_modifier == QtCore.Qt.ShiftModifier: # shift
pm.select(nodes, toggle=True)
elif int(key_modifier) == (QtCore.Qt.ControlModifier
| QtCore.Qt.ShiftModifier): # ctrl + shift
pm.select(nodes, add=True)
elif key_modifier == QtCore.Qt.AltModifier: # alt
pm.select(nodes)
elif int(key_modifier) == (QtCore.Qt.ControlModifier
| QtCore.Qt.AltModifier): # ctrl + alt
pm.select(nodes, deselect=True)
elif int(key_modifier) == (QtCore.Qt.ShiftModifier
| QtCore.Qt.AltModifier): # shift + alt
pm.select(nodes, toggle=True)
elif int(key_modifier) == (
QtCore.Qt.ControlModifier | QtCore.Qt.AltModifier
| QtCore.Qt.ShiftModifier): # Ctrl + alt + shift
pm.select(nodes, add=True)
else:
pm.select(nodes)
def smart_loop():
with pm.UndoChunk():
for obj in pm.ls(sl=True):
for curve in pm.keyframe(obj, q=True, name=True):
first = pm.findKeyframe(curve, which='first')
last = pm.findKeyframe(curve, which='last')
t = (first, last)
pm.copyKey(curve)
pm.pasteKey(curve, time=last, option='insert', connect=True)
def on_btn_anim_export_clicked(self):
log.info('on_btn_anim_export_clicked')
main_net = pymel.PyNode('Main_Net')
with pymel.UndoChunk():
main = pymel.PyNode('Main_Net')
root = main.jnts[0]
anim_utils.bake_anim(root)
anim_utils.export_anim(root)
pymel.undo()
def export_skinned_mesh(skinned_mesh, output_path, go_to_bind_pose=True):
with pm.UndoChunk():
if go_to_bind_pose:
bind_pose = skinutils.get_bind_pose_from_skinned_mesh(skinned_mesh)
pm.dagPose(bind_pose, restore=True, g=True)
with selutils.preserve_selection():
dup_mesh, dup_root, dup_cluster = skinutils.duplicate_skinned_mesh_and_skeleton(
skinned_mesh, dup_namespace=NAMESPACE_SKINCOPY_EXPORT, dup_parent=nsutils.PARENT_WORLD)
pm.select((dup_mesh, dup_root), replace=True)
pm.exportSelected(output_path, constraints=False, expressions=False, shader=False, preserveReferences=False,
type='mayaAscii', constructionHistory=True, force=True)
pm.undo()
def on_btn_build_humanoid_clicked(self):
log.info('on_btn_build_humanoid_clicked')
start_time = pymel.timerX()
self.progress_bar = QtWidgets.QProgressBar(self)
self.pb_main.setValue(0)
self.pb_main.show()
with pymel.UndoChunk():
build_rig.build_humanoid_rig(self.pb_main, mirror=False)
log.info('Duration = {} seconds'.format(pymel.timerX(st=start_time)))
def undo_chunk(*args, **kwargs):
with pm.UndoChunk():
print_args = [
x for x in args
if (not type(x) == dict) and (not type(x) == list)
]
process = System.Diagnostics.Process.GetCurrentProcess()
v1_core.v1_logging.get_logger().debug(
"{0} - {1} - Undoable ---> {2}.{3} ~~ Args:{4} Kwargs:{5}".
format(process.ProcessName, process.Id, undo_method.__module__,
undo_method.__name__, print_args, kwargs))
return undo_method(*args, **kwargs)
def repair(cls, instance):
with maya.maintained_selection():
with pc.UndoChunk():
temp_transform = pc.polyCube()[0]
attributes = cls.get_invalid_attributes(instance,
compute=False)
for attr in attributes:
source = pc.PyNode("{}.{}".format(
temp_transform.getShape(), attr.attrName()))
attr.set(source.get())
pc.delete(temp_transform)
def smart_offset(offset = 0):
with pm.UndoChunk():
for obj in pm.ls(sl=True):
for curve in pm.keyframe(obj, q=True, name=True):
old_keys = pm.keyframe(curve, q=True, timeChange=True)
pm.keyframe(curve, timeChange=offset, relative=True)
keys = old_keys + pm.keyframe(curve, q=True, timeChange=True)
keys = list(set(keys))
for t in old_keys:
pm.setKeyframe(curve, time=t, insert=True)
for t in keys:
if t > old_keys[-1] or t < old_keys[0]:
pm.cutKey(curve, time=t, clear=True)
def applyChannelConfig(self):
with pm.UndoChunk():
configDict = self._buildConfigDict()
#TODO add checker to avoid error if the datas is not found in the scene
for rule in configDict["map"]:
# proxy
if rule[3]:
source = pm.PyNode("{}.{}".format(rule[1], rule[0]))
target = pm.PyNode(rule[2])
att.addProxyAttribute(source, target,
configDict["proxyPolicy"])
#move
else:
source = pm.PyNode(rule[1])
target = pm.PyNode(rule[2])
att.moveChannel(rule[0], source, target,
configDict["movePolicy"])
def selectObj(model, object_names, mouse_button, key_modifier):
with pm.UndoChunk():
nodes = []
for name in object_names:
if len(model.split(":")) == 2:
node = pm.PyNode( model.split(":")[0] + ":" + name)
else:
node = pm.PyNode(name)
if not node and len(model.split(":")) == 2:
mgear.log("Can't find object : %s:%s"%( model.split(":")[0], name), mgear.sev_error)
elif not node:
mgear.log("Can't find object : %s"%( name), mgear.sev_error)
nodes.append(node)
if not nodes:
return
if mouse_button == QtCore.Qt.RightButton:
mirrorPose(False, nodes)
return
if mouse_button == QtCore.Qt.MiddleButton:
mirrorPose(True, nodes)
return
# Key pressed
if key_modifier is None:
pm.select(nodes)
elif key_modifier == QtCore.Qt.NoModifier:# No Key
pm.select(nodes)
elif key_modifier == QtCore.Qt.ControlModifier: # ctrl
pm.select(nodes, add=True)
elif key_modifier == QtCore.Qt.ShiftModifier: # shift
pm.select(nodes, toggle=True)
elif int(key_modifier) == QtCore.Qt.ControlModifier + QtCore.Qt.ShiftModifier: # ctrl + shift
pm.select(nodes, deselect=True)
elif key_modifier == QtCore.Qt.AltModifier: # alt
pm.select(nodes)
elif int(key_modifier) == QtCore.Qt.ControlModifier + QtCore.Qt.AltModifier: # ctrl + alt
pm.select(nodes, add=True)
elif int(key_modifier) == QtCore.Qt.ShiftModifier + QtCore.Qt.AltModifier: # shift + alt
pm.select(nodes, toggle=True)
elif int(key_modifier) == QtCore.Qt.ControlModifier + QtCore.Qt.AltModifier + QtCore.Qt.ShiftModifier: # Ctrl + alt + shift
pm.select(nodes, deselect=True)
else:
pm.select(nodes)
def replace(before="",
after="",
search="",
replace="",
selected=True,
missing_only=False):
file_nodes = pm.ls(sl=selected, exactType='file')
file_nodes.extend(pm.ls(sl=selected, exactType='psdFileTex'))
if not file_nodes:
pm.warning('No file nodes found!')
return
before = before.replace('\\', '/')
after = after.replace('\\', '/')
search = search.replace('\\', '/')
replace = replace.replace('\\', '/')
# filter missing files
if missing_only:
missing_files = []
for node in file_nodes:
f = node.attr('fileTextureName').get()
if not os.path.isfile(f):
missing_files.append(node)
file_nodes = missing_files
with pm.UndoChunk():
for node in file_nodes:
old_path = node.attr('fileTextureName').get()
old_path = old_path.replace('\\', '/')
new_path = old_path
if search:
new_path = old_path.replace(search, replace)
try:
node.attr('fileTextureName').set(before + new_path + after)
except Exception as e:
pm.warning(str(e))
sys.stdout.write('# Replaced %d image name(s)\n' % len(file_nodes))
def mouseReleaseEvent(self, event):
if self.rubberband.isVisible():
self.rubberband.hide()
selected = []
rect = self.rubberband.geometry()
for child in self.findChildren(mwi.SelectButton):
if rect.intersects(child.geometry()):
selected.append(child)
if selected:
firstLoop = True
with pm.UndoChunk():
for wi in selected:
wi.rectangleSelection(event, firstLoop)
firstLoop = False
else:
if event.modifiers() == QtCore.Qt.NoModifier:
pm.select(cl=True)
pm.displayInfo("Clear selection")
QtWidgets.QWidget.mouseReleaseEvent(self, event)
def refit_meshes(target_meshes, driver_mesh):
with pm.UndoChunk():
blendshape = [
x for x in driver_mesh.getShape().inputs()
if isinstance(x, pm.nt.BlendShape)
][0]
initial_weight = blendshape.weight[0].get()
blendshape.weight[0].set(0.0)
base_shapes = []
for target_mesh in target_meshes:
wrap_node, base_shape = create_wrap_deformer(
driver_mesh, target_mesh)
base_shapes.append(base_shape.getParent())
blendshape.weight[0].set(1.0)
# sometimes the target meshes do not get deformed at all until the viewport is refreshed for some reason.
pm.refresh()
# clearing the history deleted the wrap deformer nodes, but does not delete the base shapes that were created.
pm.delete(target_meshes, constructionHistory=True)
pm.delete(base_shapes)
blendshape.weight[0].set(initial_weight)
def apply_average_weights(self):
shape_to_skincl, vert_to_infs_wts = get_shape_to_skincl_and_vert_to_infs_wts(
self.sampled_verts)
if not self.sampled_verts:
return
inf_to_wt_totals = get_influence_to_weight_totals(vert_to_infs_wts)
pruned_inf_to_weight = get_pruned_influences_to_weights(
inf_to_wt_totals, float(len(self.sampled_verts)))
target_verts = selectionutils.convert_selection_to_verts()
target_skincl = skinutils.get_skincluster(target_verts[0])
with pm.UndoChunk():
with skinutils.max_influences_normalize_weights_disabled(
target_skincl):
pm.skinPercent(target_skincl,
target_verts,
transformValue=pruned_inf_to_weight.items())
# Normalize weights after modifying them just our changes didn't equal exactly 1.0.
pm.skinPercent(target_skincl, target_verts, normalize=True)
def apply_proximity_weights(self):
shape_to_skincl, svert_to_infs_wts = get_shape_to_skincl_and_vert_to_infs_wts(
self.sampled_verts)
if not self.sampled_verts:
return
target_verts = selectionutils.convert_selection_to_verts()
target_skincl = skinutils.get_skincluster(target_verts[0])
with pm.UndoChunk():
with skinutils.max_influences_normalize_weights_disabled(
target_skincl):
for target_vert in target_verts:
infs_to_weights = get_scaled_influence_to_weight_totals(
svert_to_infs_wts, target_vert)
pruned_infs_to_weights = get_pruned_influences_to_weights(
infs_to_weights)
pm.skinPercent(
target_skincl,
target_vert,
transformValue=pruned_infs_to_weights.items())
pm.skinPercent(target_skincl, target_verts, normalize=True)
def create_loc_on_pivot(selection=None, nameScheme=None):
"""
Create locator on pivot of every selected or given node.
If supplied node isn't a transform it checks for a parent
transform else it will skip the node.
You can supply a nameScheme function to alter the name of
the generated locator on a per node base.
Args:
selection ([iterable], optional): List containing the nodes. Defaults to None.
nameScheme ([Function], optional): Function to alter the name of the generated locators.
Defaults to None.
"""
if not selection:
selection = pmc.selected()
assert selection, "Nothing selected."
with pmc.UndoChunk():
for node in selection:
if node.type() != "transform":
try:
par = pmc.listRelatives(node, ap=True)[0]
if par in selection:
continue
node = par
except Exception:
continue
name = node.name()
if nameScheme:
name = nameScheme(name)
else:
name = "{0}_loc".format(name)
pos = node.getPivots(worldSpace=True)[0]
loc = pmc.spaceLocator(n=name)
pmc.move(loc, pos)
def copy_paste_offset():
offset = pm.promptDialog(button=['OK', 'Cancel'],
defaultButton='OK',
dismissString='Cancel',
cancelButton='Cancel',
title='Copy Offset',
message='Copy and paste offset:')
if offset == 'Cancel':
return
try:
offset = float(pm.promptDialog(q=True, text=True))
except ValueError:
return
# get time slider range
aTimeSlider = mel.eval('$tmpVar=$gPlayBackSlider')
timeRange = []
if cmds.timeControl(aTimeSlider, q=True, rangeVisible=True):
timeRange = cmds.timeControl(aTimeSlider, q=True, rangeArray=True)
else:
timeRange += 2 * [cmds.currentTime(q=True)]
timeRange = tuple(timeRange)
with pm.UndoChunk():
for o in pm.ls(sl=True):
for k in sorted(
list(
set(
pm.keyframe(o,
q=True,
timeChange=True,
time=timeRange)))):
pm.copyKey(o, time=(k, k))
pm.pasteKey(o, time=(k, k), timeOffset=offset, option='merge')
def mirror_jnts(objs, **kwargs):
# Sort objects by hyerarchy so we mirror parents before their children.
objs = sorted(objs, key=libPymel.get_num_parents)
with pymel.UndoChunk():
for obj in objs:
mirror_jnt(obj, **kwargs)
def on_action_create(self, *args):
sName = self.ui.edtNewName.text()
# loading Maya matrix node
if not (cmds.pluginInfo("decomposeMatrix", query=True, loaded=True)):
try: # Maya 2012
cmds.loadPlugin("decomposeMatrix.mll")
except:
try: # Maya 2013 or earlier
cmds.loadPlugin("matrixNodes.mll")
except:
print self.langDic[
self.langName]['e002_decomposeMatrixNotFound']
aSel = pymel.selected()
if (len(aSel) == 2):
#Create the container of the system data
pData = PoseReaderData()
with pymel.UndoChunk():
#Get Needed matrix information
pData.nParent = aSel[1]
pData.nChild = aSel[0]
m4ParentMat = pData.nParent.getMatrix(worldSpace=True)
m4ChildMat = pData.nChild.getMatrix(worldSpace=True)
#Create the two node needed to extract the rotation
pData.nPGrp = pymel.createNode("transform",
name=sName +
"_PoseReader_Parent_Grp",
p=pData.nParent)
pData.nPGrp.setMatrix(m4ChildMat, worldSpace=True)
pData.nParentLoc = self.createLoc(
sName + "_AngExtract_ParentLoc", pData.nPGrp)
pData.nCGrp = pymel.createNode("transform",
name=sName +
"_PoseReader_Child_Grp",
p=pData.nChild)
pData.nCGrp.setMatrix(m4ChildMat, worldSpace=True)
pData.nChildLoc = self.createLoc(
sName + "_AngExtract_ChildLoc", pData.nCGrp)
#Add usefull attributes for the tool
pData.nChildLoc.setDynamicAttr("posereaderdata", True)
pData.nChildLoc.addAttr("angleMaxValue", min=-360.0, max=360.0)
pData.nChildLoc.setAttr("angleMaxValue",
180,
edit=True,
keyable=False,
lock=False)
pData.nChildLoc.addAttr("axis", at="enum", enumName="X:Y:Z")
pData.nChildLoc.setAttr("axis",
1,
edit=True,
keyable=False,
lock=False)
#Setup the rotation extaction
pData.nMultM = pymel.createNode("multMatrix",
name=sName + "_ExtactAngle_MM")
pymel.connectAttr(pData.nChildLoc.worldMatrix[0],
pData.nMultM.matrixIn[0])
pymel.connectAttr(pData.nParentLoc.worldInverseMatrix[0],
pData.nMultM.matrixIn[1])
pData.nDecM = pymel.createNode("decomposeMatrix",
name=sName + "_ExtractAngle_DM")
pymel.connectAttr(pData.nMultM.matrixSum,
pData.nDecM.inputMatrix)
#Setup the rotation affection
pData.nMD = pymel.createNode("multiplyDivide",
name=sName + "_NormValue_MD")
pData.nMD.operation.set(2)
pymel.connectAttr(pData.nDecM.outputRotateY, pData.nMD.input1X)
pymel.connectAttr(pData.nChildLoc.angleMaxValue,
pData.nMD.input2X)
pData.nCD = pymel.createNode("condition",
name=sName + "_SmallerThanOne_CD")
pymel.connectAttr(pData.nMD.outputX, pData.nCD.firstTerm)
pymel.connectAttr(pData.nMD.outputX, pData.nCD.colorIfTrueR)
pData.nCD.secondTerm.set(1)
pData.nCD.operation.set(5) #Less or equal
pData.nCDNoNeg = pymel.createNode("condition",
name=sName + "_OverZero_CD")
pymel.connectAttr(pData.nCD.outColorR,
pData.nCDNoNeg.firstTerm)
pymel.connectAttr(pData.nCD.outColorR,
pData.nCDNoNeg.colorIfTrueR)
pData.nCDNoNeg.secondTerm.set(0)
pData.nCDNoNeg.colorIfFalseR.set(0)
pData.nCDNoNeg.operation.set(3) #Greater or Equal
#Node for manual activation connection
pData.nMDActive = pymel.createNode("multiplyDivide",
name=sName + "_Active_MD")
pymel.connectAttr(pData.nCDNoNeg.outColorR,
pData.nMDActive.input1X)
#for o in pData.__dict__:
#print o
libSerialization.export_network(pData)
self.addItem(pData)
else:
pymel.confirmDialog(
title='Selection Problem',
message='You need to have exactly two nodes selected')
def patternSelection():
with pm.UndoChunk():
#pm.scriptEditorInfo(suppressInfo=True)
selOrderTrackingEnabled = pm.selectPref(q=1, trackSelectionOrder=1)
if not selOrderTrackingEnabled:
#pm.confirmDialog( title='Warning', message='For pattern selection to work you need to enable selection order tracking [Windows > Settings/Preferences > Preferences > Selection > Track selection order]', button=['OK'])
pm.selectPref(trackSelectionOrder=1)
pm.mel.eval("selectPref -trackSelectionOrder true")
return
sel = pm.ls(orderedSelection=1,fl=1)
if len(sel) <= 1:
return
# get name of mesh object containing selected components
mesh = pm.ls(sel[0].name().split(".")[0])[0]
##########
# VERTEX #
##########
if sel[0].__class__.__name__ == "MeshVertex" and sel[1].__class__.__name__ == "MeshVertex":
print "vepe"
vertFirst = sel[-2].indices()[0]
vertLast = sel[-1].indices()[0]
# detect if two last selected vertices are next to each other
nextToEachother = False
pm.select( mesh+".vtx["+str(vertFirst)+"]",r=1)
pm.select( mesh+".vtx["+str(vertLast)+"]",add=1)
pm.mel.eval("ConvertSelectionToContainedEdges;")
if len(pm.ls(sl=1)) == 1:
nextToEachother = True
# restore selection order stack
pm.mel.eval("ConvertSelectionToVertices;") # avoid getting stuck in edge/multi-component mode
pm.select(sel,r=1)
pm.select(sel[-1],d=1)
pm.select(sel[-2],d=1)
pm.select(sel[-2],add=1)
pm.select(sel[-1],add=1)
if nextToEachother:
selectNextVertex("next")
return
# detect if two last selected vertices are on same edge loop
pm.select( mesh+".vtx["+str(vertFirst)+"]",r=1)
pm.select( mesh+".vtx["+str(vertLast)+"]",add=1)
# converting two verts on the same loop to and edge loop
# results in selecting all verts between them (why?)
pm.mel.eval("SelectEdgeLoopSp;")
path = pm.ls(sl=1,fl=1)
if ( path ): # on same loop
# get edge loop, needed for inversion later
pm.mel.eval("ConvertSelectionToContainedEdges;")
edgePath = pm.ls(sl=1,fl=1)
# SelectEdgeRingSp is sometimes unreliable with multiple consecutive
# edges selected so we use just one edge to find the current loop
pm.select(edgePath[0],r=1)
pm.mel.eval("SelectEdgeLoopSp;")
loop = pm.ls(sl=1)
# restore selection order stack
pm.select(sel,r=1)
pm.select(sel[-1],d=1)
pm.select(sel[-2],d=1)
pm.select(sel[-2],add=1)
pm.select(sel[-1],add=1)
if ( path ): # on same loop
selectNextVertex("pattern", mesh, len(edgePath)-1, loop)
########
# EDGE #
########
if sel[0].__class__.__name__ == "MeshEdge" and sel[1].__class__.__name__ == "MeshEdge":
edgeFirst = sel[-2].indices()[0]
edgeLast = sel[-1].indices()[0]
ring = pm.polySelect( mesh.name(), q=1, edgeRingPath=[edgeFirst,edgeLast] )
if ( ring ):
if ( len(ring) == 2 ):
selectNextEdge("ring")
if ( len(ring) > 2 ):
selectNextEdge("ringPattern", mesh, len(ring)-2)
loop = pm.polySelect( mesh.name(), q=1, edgeLoopPath=[edgeFirst,edgeLast] )
if ( loop ):
if (len(loop) == 2 ):
selectNextEdge("loop")
if ( len(loop) > 2 ):
selectNextEdge("loopPattern", mesh, len(loop)-2)
########
# FACE #
########
if sel[0].__class__.__name__ == "MeshFace" and sel[1].__class__.__name__ == "MeshFace":
faceFirst = sel[-2].indices()[0]
faceLast = sel[-1].indices()[0]
path = pm.polySelect( mesh.name(), q=1, shortestFacePath=[faceFirst,faceLast] )
if (path):
if len(path) == 2:
selectNextFace("next")
if len(path) > 2:
pm.select( mesh+".f["+str(faceFirst)+"]",r=1)
pm.select( mesh+".f["+str(faceLast)+"]",add=1)
pm.mel.eval("SelectEdgeLoopSp;")
facePath = pm.ls(sl=1,fl=1)
if (facePath):
# face path isnt sorted
pm.mel.eval("ConvertSelectionToContainedEdges;")
pm.select(pm.ls(sl=1,fl=1)[0],r=1)
pm.mel.eval("SelectEdgeRingSp;")
pm.mel.eval("ConvertSelectionToVertices;") # TODO REM buggy command was: pm.mel.eval("GrowPolygonSelectionRegion;")
pm.mel.eval("ConvertSelectionToContainedFaces;")
loop = pm.ls(sl=1)
print loop
print "-------------------"
# restore selection order stack
pm.select(sel,r=1)
pm.select(sel[-1],d=1)
pm.select(sel[-2],d=1)
pm.select(sel[-2],add=1)
pm.select(sel[-1],add=1)
#print len(facePath)
if (facePath):
selectNextFace("pattern", mesh, len(facePath)-2, loop)
def resetSelTrans():
with pm.UndoChunk():
for obj in pm.selected():
tra.resetTransform(obj)
def export_anim(root):
# Select Root
pymel.select(root)
scene_name = str(pymel.sceneName().basename().split('.')[0])
path = os.path.join(siteCustomize.ROOT_DIR, 'animations', 'export',
scene_name)
path = path.replace('\\', '/')
pymel.mel.eval('FBXResetExport()')
pymel.mel.eval('FBXExportInAscii -v true')
# EXPORT
pymel.mel.eval('FBXExport -f "{0}" -s'.format(path))
if __name__ == '__main__':
#
# ctrl = pymel.selected()[0]
#
# export_pose(ctrl.region, pose_name='test')
with pymel.UndoChunk():
main = pymel.PyNode('Main_Net')
root = main.jnts[0]
bake_anim(root)
export_anim(root)
pymel.undo()
def selectObj(model, object_names, mouse_button, key_modifier):
"""Select an object
Args:
model (PyNode): The rig top node
object_names (list): The names of the objects to select
mouse_button (QtSignal): Clicked mouse button signal
key_modifier (QtSignal): Modifier button signal
Returns:
None
"""
if not model:
return
nameSpace = getNamespace(model)
with pm.UndoChunk():
nodes = []
for name in object_names:
if nameSpace:
node = getNode(nameSpace + ":" + name)
else:
node = getNode(name)
if not node:
continue
if not node and nameSpace:
mgear.log("Can't find object : %s:%s" % (nameSpace, name),
mgear.sev_error)
elif not node:
mgear.log("Can't find object : %s" % (name), mgear.sev_error)
nodes.append(node)
if not nodes:
return
if mouse_button == QtCore.Qt.RightButton:
mirrorPose(False, nodes)
return
if mouse_button == QtCore.Qt.MiddleButton:
mirrorPose(True, nodes)
return
# Key pressed
if key_modifier is None:
pm.select(nodes)
elif key_modifier == QtCore.Qt.NoModifier: # No Key
pm.select(nodes)
elif key_modifier == QtCore.Qt.ControlModifier: # ctrl
pm.select(nodes, deselect=True)
elif key_modifier == QtCore.Qt.ShiftModifier: # shift
pm.select(nodes, toggle=True)
elif int(key_modifier) == (QtCore.Qt.ControlModifier
| QtCore.Qt.ShiftModifier): # ctrl + shift
pm.select(nodes, add=True)
elif key_modifier == QtCore.Qt.AltModifier: # alt
pm.select(nodes)
elif int(key_modifier) == (QtCore.Qt.ControlModifier
| QtCore.Qt.AltModifier): # ctrl + alt
pm.select(nodes, deselect=True)
elif int(key_modifier) == (QtCore.Qt.ShiftModifier
| QtCore.Qt.AltModifier): # shift + alt
pm.select(nodes, toggle=True)
# Ctrl + alt + shift
elif int(key_modifier) == (QtCore.Qt.ControlModifier
| QtCore.Qt.AltModifier
| QtCore.Qt.ShiftModifier):
pm.select(nodes, add=True)
else:
pm.select(nodes)
def inner(*args, **kwargs):
with pmc.UndoChunk():
result = func_(*args, **kwargs)
return result
def resetSelTrans():
"""Reset the transfom values (SRT) for the selected objects"""
with pm.UndoChunk():
for obj in pm.selected():
transform.resetTransform(obj)
