Пример #1
2
def lcObj_exportObjs(*args, **kwargs):
  ''' Export .obj files from selected geometry, either as one combined file or as individual files per object.  Will recognize and convert poly smooth preview to geometry for export '''
  global prefix
  path = pm.textField(prefix+'_textField_export_path', query=True, text=True)
  objPrefix = pm.textField(prefix+'_textField_prefix', query=True, text=True)
  if objPrefix:
    objPrefix+='_'

  if path:

    sel = pm.ls(sl=True)

    if sel:
      sel = geometry.filterForGeometry(sel)
      print sel

      #undo is the easiest way to work on geometry temporarily
      pm.undoInfo(openChunk=True)

      if pm.checkBox(prefix+'_checkBox_use_smooth', query=True, v=True):
        for obj in sel:
          pm.select(obj)
          #find the objects currently displayed as smooth and create converted poly copies
          if pm.displaySmoothness(q=True, polygonObject=True)[0] == 3:
            pm.mel.performSmoothMeshPreviewToPolygon()

      if pm.checkBox(prefix+'_checkBox_export_indi', query=True, v=True):
        #export objects individually
        for obj in sel:
          pm.select(obj)
          name = str(obj)
          exportString = path+'/'+objPrefix+name+'.obj'
          pm.exportSelected(exportString, force=True, options='groups=1;ptgroups=1;materials=0;smoothing=1;normals=1', type='OBJexport', pr=True, es=True)

      else:
        #export as one object
        pm.select(sel)
        name = ''
        while name == '':
          dialog = pm.promptDialog(title='OBJ Name', message='Enter Name:', button=['OK', 'Cancel'], defaultButton='OK', cancelButton='Cancel', dismissString='Cancel')
          if dialog == 'OK':
            name = pm.promptDialog(query=True, text=True)
            if name:
              exportString = path+'/'+objPrefix+name+'.obj'
              pm.exportSelected(exportString, force=True, options='groups=1;ptgroups=1;materials=0;smoothing=1;normals=1', type='OBJexport', pr=True, es=True)
            else:
              pm.warning("You didn't type a name for your obj")
          if dialog == 'Cancel':
            break

      pm.undoInfo(closeChunk=True)
      pm.undo()
      pm.select(clear=True)

  else:
    pm.warning('Did you specify a path?')
Пример #2
0
    def createCharacter(self):
        """
        Clicked event for self.charSettings.createCharBtn
        Creates a new character
        """
        pm.undoInfo(openChunk=True)
        inputName = self.charName.edit.text()
        charSuffix = self.charNameSuffix.edit.text()
        rootName = self.charSettings.rootName.edit.text()
        leftString = self.charSettings.leftString.edit.text()
        rightString = self.charSettings.rightString.edit.text()

        if len(inputName) and len(charSuffix):
            charName = inputName + charSuffix
            self.character = char.Char(charName,
                                       rootName=rootName,
                                       leftString=leftString,
                                       rightString=rightString)
            self.character.create()
            self.infoDock.infoDisplay.append('Created %s character' % charName)
            listItem = QtGui.QListWidgetItem()
            listItem.setText(self.character.chRootName)
            listItem.setTextAlignment(QtCore.Qt.AlignHCenter)
            self.bpCharList.addItem(listItem)

        pm.undoInfo(closeChunk=True)
Пример #3
0
 def wrapper(*args, **kwargs):
     pm.undoInfo(openChunk=True)
     try:
         ret = func(*args, **kwargs)
     finally:
         pm.undoInfo(closeChunk=True)
     return ret
Пример #4
0
def Connect(src, dst):

    pm.undoInfo(openChunk=True)

    alembics = src
    if not isinstance(src, list):
        alembics = pm.ls(src, dagObjects=True, type='transform')

    targets = dst
    if not isinstance(dst, list):
        targets = pm.ls(dst, dagObjects=True, type='transform')

    attrs = ['translate', 'rotate', 'scale', 'visibility']
    for node in targets:
        for abc in alembics:
            if node.longName().split(':')[-1] == abc.longName().split(':')[-1]:
                for attr in attrs:
                    pm.connectAttr('%s.%s' % (abc, attr),
                                   '%s.%s' % (node, attr),
                                   force=True)

                # securing primary shape is connected
                pm.connectAttr('%s.worldMesh[0]' % abc.getShape(),
                               '%s.inMesh' % node.getShape(),
                               force=True)

    pm.undoInfo(closeChunk=True)
Пример #5
0
 def doGuideCallback(self):
     gfs = self.mainUI.getGuide_chk.isChecked()
     pm.undoInfo(openChunk=True)
     try:
         self.doGuide(getFromScene=gfs)
     finally:
         pm.undoInfo(closeChunk=True)
Пример #6
0
    def setLegHeight(self, value):
        pm.undoInfo(openChunk=True)
        
        if value > 10.0:
            value = value / 100.0
            self.legHeight_spinBox.setValue(value)
        else:
            self.legHeight_slider.setValue(value*100)
        
        self.setJointScale(self.hips, value, self.legHeight)
        self.setJointScale(self.l_upperLeg, value, self.legHeight)
        self.setJointScale(self.l_lowerLeg, value, self.legHeight)
        self.setJointScale(self.l_foot, value, self.legHeight)
        self.setJointScale(self.l_toes, value, self.legHeight)
        self.setJointScale(self.l_toeEnd, value, self.legHeight)
        self.setJointScale(self.r_upperLeg, value, self.legHeight)
        self.setJointScale(self.r_lowerLeg, value, self.legHeight)
        self.setJointScale(self.r_foot, value, self.legHeight)
        self.setJointScale(self.r_toes, value, self.legHeight)
        self.setJointScale(self.r_toeEnd, value, self.legHeight)

        self.legHeight = value
        self.RebuildMesh()
        
        pm.undoInfo(closeChunk=True)
Пример #7
0
 def doRigCallback(self):
     rs = self.mainUI.reapplySkin_chk.isChecked()
     pm.undoInfo(openChunk=True)
     try:
         self.doRig(reapplySkin=rs)
     finally:
         pm.undoInfo(closeChunk=True)
 def __enter__(self):
     try:
         pm.undoInfo(openChunk=1)
     except TypeError:
         # Legacy support for before undo chunking existed
         pm.undoInfo(stateWithoutFlush=0)  # turn undo off
     return self
Пример #9
0
    def overrideAttrRun(self, mode):

        items = self.weightListWidget.selectedItems()
        
        if pm.editRenderLayerGlobals(q=1, crl=1) == 'defaultRenderLayer':
            return 0

        attrList = []
        
        pm.undoInfo(ock=1)        
        
        for x in items:
            attrList.append(x.text())
        
        for x in self.objectList:
            for y in attrList:
                try:
                    if mode:
                        pm.editRenderLayerAdjustment(x.attr(y))
                    else:
                        overrideList = pm.editRenderLayerAdjustment(q=1)
                        if x.attr(y).name() in overrideList:
                            pm.editRenderLayerAdjustment(x.attr(y), remove=1)
                except:
                    print x                
        
        pm.undoInfo(cck=1)
Пример #10
0
    def _ctrlDBL(self, controls):

        pmc.undoInfo(openChunk=True)

        if controls == []:
            controls = pmc.ls(sl=True)

        for control in controls:
            control_roo = pmc.xform(control, q=True, roo=True)
            control_mtx = pmc.xform(control, q=True, m=True, ws=True)
            control_parent = pmc.listRelatives(control, p=True)
            pmc.select(cl=True)

            locdbl_parent = pmc.spaceLocator(n='locDBL_parent_' + control)
            locdbl_offset = pmc.spaceLocator(n='locDBL_offset_' + control)

            pmc.xform(locdbl_parent, ws=True, m=control_mtx)
            pmc.xform(locdbl_offset, ws=True, m=control_mtx)

            pmc.parent(locdbl_offset, locdbl_parent)
            pmc.parent(locdbl_parent, control_parent)
            pmc.parent(control, locdbl_offset)

            if control_roo == 'xyz':
                pmc.xform(locdbl_offset, roo='zyx')
            if control_roo == 'yzx':
                pmc.xform(locdbl_offset, roo='xzy')
            if control_roo == 'zxy':
                pmc.xform(locdbl_offset, roo='yxz')
            if control_roo == 'xzy':
                pmc.xform(locdbl_offset, roo='yzx')
            if control_roo == 'yxz':
                pmc.xform(locdbl_offset, roo='zxy')
            if control_roo == 'zyx':
                pmc.xform(locdbl_offset, roo='xyz')

            md_trns = pmc.createNode('multiplyDivide',
                                     n='mdTRNS_locDBL_' + control)
            md_rot = pmc.createNode('multiplyDivide',
                                    n='mdROT_locDBL_' + control)
            md_scl = pmc.createNode('multiplyDivide',
                                    n='mdSCL_locDBL_' + control)

            pmc.setAttr(md_trns + '.input1', [-1, -1, -1])
            pmc.setAttr(md_rot.input1, [-1, -1, -1])
            pmc.setAttr(md_scl.input1, [1, 1, 1])
            pmc.setAttr(md_scl.operation, 2)

            pmc.connectAttr(control + '.translate', md_trns + '.input2')
            pmc.connectAttr(control + '.rotate', md_rot + '.input2')
            pmc.connectAttr(control + '.scale', md_scl + '.input2')

            pmc.connectAttr(md_trns + '.output', locdbl_offset + '.translate')
            pmc.connectAttr(md_rot + '.output', locdbl_offset + '.rotate')
            pmc.connectAttr(md_scl + '.output', locdbl_offset + '.scale')

            pmc.setAttr(locdbl_parent + 'Shape.visibility', 0)
            pmc.setAttr(locdbl_offset + 'Shape.visibility', 0)

        pmc.undoInfo(closeChunk=True)
Пример #11
0
 def meshHook(self):
     logger.debug(self.meshHookMode)
     pm.undoInfo(openChunk=True)
     try:
         attachTools.hookOnMesh(mode=self.meshHookMode)
     finally:
         pm.undoInfo(closeChunk=True)
Пример #12
0
    def addParentSpace(self):
        sel = pm.ls(sl=True)

        if not sel:
            logger.warn('Selecione um objeto para space switch')
            return

        # todo se nao existir um grupo pai, pedir pra adicionar

        if not sel[0].getParent():
            flags = QtGui.QMessageBox.StandardButton.Yes
            flags |= QtGui.QMessageBox.StandardButton.No
            question = "criar um grupo acima?"
            response = QtGui.QMessageBox.question(self, "Question",
                                                  question,
                                                  flags)
            if response:
                groupTools.zeroOut()

        spacelist = [x.text() for x in self.ui.spaceList_listWidget.selectedItems()]
        logger.debug(spacelist)

        # todo ver se ja existe o space a ser adicionado no switcher
        pm.undoInfo(openChunk=True)
        try:
            spaceTools.addSpc(target=sel[0], switcher=sel[0].getParent(),
                              type='parent', spaceList=spacelist)
        finally:
            pm.undoInfo(closeChunk=True)
 def wrapper(*args, **kwargs):
     pm.undoInfo(openChunk=True)
     try:
         ret = func(*args, **kwargs)
     finally:
         pm.undoInfo(closeChunk=True)
     return ret
Пример #14
0
    def tagEditDelShader_PB_hit(self):
        SG_list = self.getSgWithTag()
        shader_list = []
        self.child_all_list = []
        for sg in SG_list:
            shader = pm.listConnections(sg.rman__surface, source=True, scn=True)
            if len(shader) > 0:
                shader_list.append(shader[0])
                self.allChildNode(shader[0], self.child_all_list)
            dm_shader = pm.listConnections(sg.rman__displacement, source=True, scn=True)
            if len(dm_shader) > 0:
                shader_list.append(dm_shader[0])
                self.allChildNode(dm_shader[0], self.child_all_list)

        self.child_all_list = list(set(self.child_all_list))
        self.child_all_list = self.child_all_list + SG_list + shader_list
        self.child_all_list.remove('global_matteID')
        num = len(self.child_all_list)
        print '#####################################################################################################'
        print 'total of ' + str(num) + ' node(s) will be deleted'
        for node in self.child_all_list:
            print str(node) + ' (' + str(node.type())+')'

        pm.undoInfo(ock=True)
        pm.delete(self.child_all_list)
        pm.undoInfo(cck=True)
Пример #15
0
def Connect(src, dst):

    pm.undoInfo(openChunk=True)

    alembics = src
    if not isinstance(src, list):
        alembics = pm.ls(src, dagObjects=True, type='transform')

    targets = dst
    if not isinstance(dst, list):
        targets = pm.ls(dst, dagObjects=True, type='transform')

    attrs = ['translate', 'rotate', 'scale', 'visibility']
    for node in targets:
        for abc in alembics:
            if node.longName().split(':')[-1] == abc.longName().split(':')[-1]:
                for attr in attrs:
                    pm.connectAttr('%s.%s' % (abc, attr),
                                   '%s.%s' % (node, attr),
                                   force=True)

                # securing primary shape is connected
                pm.connectAttr('%s.worldMesh[0]' % abc.getShape(),
                               '%s.inMesh' % node.getShape(),
                               force=True)

    pm.undoInfo(closeChunk=True)
Пример #16
0
 def __enter__(self):
     try:
         pm.undoInfo(openChunk=1)
     except TypeError:
         # Legacy support for before undo chunking existed
         pm.undoInfo(stateWithoutFlush=0)  # turn undo off
     return self
Пример #17
0
    def _jointRes(self,
                  parentJoint,
                  endJoint,
                  boneTranslateAxis='.tx',
                  add=2.0,
                  name="subJoint_"):
        pmc.undoInfo(openChunk=True)

        selJoints = pmc.ls(selection=True)

        boneLength = mc.getAttr(endJoint + boneTranslateAxis)
        boneRadius = mc.getAttr(parentJoint + ".radius")

        mc.select(cl=True)

        for i in xrange(int(round(add))):
            newJoint = pmc.joint(name=name + str(i + 1),
                                 radius=(boneRadius * 2))
            mc.select(cl=True)
            pmc.parent(newJoint, parentJoint, relative=True)
            mc.setAttr(newJoint + boneTranslateAxis, (boneLength / (add + 1)))
            if i > 0:
                pmc.parent(newJoint, (name + str(i)), relative=True)
            if i == add - 1:
                pmc.parent(endJoint, newJoint)

        pmc.undoInfo(closeChunk=True)
Пример #18
0
def rtb_shrink_wrap_verts(highresListDropdown, *args, **kwargs):
  ''' '''
  global defaultString
  high = highresListDropdown.getValue()

  if not high == defaultString:

    pm.undoInfo(openChunk=True)

    live = pm.PyNode(high.replace('_high', '_live'))
    liveShape = live.getShape()
    sel = pm.ls(sl=True)
    if sel:
      verts = geometry.getVertsFromSelection(sel)
      if verts and verts[0].nodeType() == 'mesh':
        try:
          geometry.shrinkWrap(verts, liveShape, prefix+'_progress_control')
        except:
          pm.warning('You Should Not See This Error!')
          pm.progressBar(prefix+'_progress_control', edit=True, endProgress=True)
      else:
        pm.warning('No verts to shrink wrap!')
      pm.select(sel, r=True)
      pm.hilite(pm.PyNode(sel[0].split('.')[0]).getParent(), r=True)
      type = geometry.getMeshSelectionType(sel)
      geometry.switchSelectType(type)

      pm.undoInfo(closeChunk=True)

  else:
    pm.warning('Select a mesh from the dropdown list')
Пример #19
0
def zero_out_bend(**kwargs):
    """
    Zero out all the bend joint
    Here we assume it already has a optimised rotate order
        - joint_list: (list) List of joint to zero out te bend
        - axis: (str) Which axis is the joint bending
        - rotate_order: (str) What is the current rotate order
    @return the rotate order
    """
    joint_list = libUtilities.pyList(kwargs.get("joint_list") or get_joint_children(pm.selected()[0]))
    libUtilities.freeze_rotation(joint_list)
    libUtilities.freeze_scale(joint_list)
    rotate_order = kwargs.get("rotate_order") or joint_list[0].rotateOrder.get(asString=True)
    target_axis = kwargs.get("axis", rotate_order[0])
    new_rotate_order = None
    if target_axis != rotate_order[0]:
        new_rotate_order = "{}{}{}".format(target_axis, rotate_order[0], rotate_order[2])
    pm.undoInfo(openChunk=True)
    for joint in joint_list:
        for rotate_axis in rotate_order:
            if rotate_axis != target_axis:
                joint.attr("jointOrient{}".format(rotate_axis.upper())).set(0)
        if new_rotate_order:
            joint.rotateOrder.set(new_rotate_order)
    pm.undoInfo(closeChunk=True)
    return new_rotate_order
Пример #20
0
 def setDelAction(self):
     pm.undoInfo(openChunk=True)
     for item in self.selectedItems():
         layer_name = item.text()
         layer_name = unicode(layer_name)
         pm.delete(layer_name)
         self.takeItem(self.row(item))
     pm.undoInfo(closeChunk=True)
Пример #21
0
def undoable(name):
	try:
		pm.undoInfo(ock=True, cn=name)
		yield name
	except Exception, e:
		import traceback
		pm.warning('[XGen Hub] : Error while running undoable <%s> : %s' % (name, e))
		traceback.print_exc()
Пример #22
0
 def substitutePath(self):
     u'''點擊轉換按鈕觸發'''
     pm.undoInfo(ock=True)
     for i in self.substituteNode:
         path = mc.getAttr(i + '.filename')
         pathChanged = self.replace(path)
         mc.setAttr(i + '.filename', str(pathChanged), type='string')
     pm.undoInfo(cck=True)
Пример #23
0
 def wrapper(*args, **kwargs):
     pymel.undoInfo(openChunk=True)
     try:
         func(*args, **kwargs)
     except Exception as ex:
         log.warning(ex)
     finally:
         pymel.undoInfo(closeChunk=True)
Пример #24
0
 def inner(*args, **kwargs):
     pmc.undoInfo(openChunk=True)
     try:
         return func(*args, **kwargs)
     except RuntimeError as ex:
         print(ex)
     finally:
         pmc.undoInfo(closeChunk=True)
Пример #25
0
    def _ctrlDBL(self, controls):
        
        pmc.undoInfo(openChunk=True)
        
        if controls == []:
            controls = pmc.ls(sl=True)

        for control in controls:
            control_roo = pmc.xform(control, q=True, roo=True)
            control_mtx = pmc.xform(control, q=True, m=True, ws=True)
            control_parent = pmc.listRelatives(control, p=True)
            pmc.select(cl=True)
            
            locdbl_parent = pmc.spaceLocator(n='locDBL_parent_' + control)
            locdbl_offset = pmc.spaceLocator(n='locDBL_offset_' + control)

            pmc.xform(locdbl_parent, ws=True, m=control_mtx)
            pmc.xform(locdbl_offset, ws=True, m=control_mtx)
                
            pmc.parent(locdbl_offset, locdbl_parent)
            pmc.parent(locdbl_parent, control_parent)
            pmc.parent(control, locdbl_offset)
            
            if control_roo == 'xyz':
                pmc.xform(locdbl_offset, roo='zyx')
            if control_roo == 'yzx':
                pmc.xform(locdbl_offset, roo='xzy')        
            if control_roo == 'zxy':
                pmc.xform(locdbl_offset, roo='yxz')        
            if control_roo == 'xzy':
                pmc.xform(locdbl_offset, roo='yzx')
            if control_roo == 'yxz':
                pmc.xform(locdbl_offset, roo='zxy')            
            if control_roo == 'zyx':
                pmc.xform(locdbl_offset, roo='xyz')
                            
            md_trns = pmc.createNode('multiplyDivide', n='mdTRNS_locDBL_' + control)
            md_rot = pmc.createNode('multiplyDivide', n='mdROT_locDBL_' + control)
            md_scl = pmc.createNode('multiplyDivide', n='mdSCL_locDBL_' + control)
            
            pmc.setAttr(md_trns + '.input1', [-1,-1,-1])
            pmc.setAttr(md_rot.input1, [-1,-1,-1])
            pmc.setAttr(md_scl.input1, [ 1, 1, 1])
            pmc.setAttr(md_scl.operation, 2)

            
            pmc.connectAttr(control + '.translate', md_trns + '.input2')
            pmc.connectAttr(control + '.rotate', md_rot + '.input2')
            pmc.connectAttr(control + '.scale', md_scl + '.input2')
            
            pmc.connectAttr(md_trns + '.output', locdbl_offset + '.translate')
            pmc.connectAttr(md_rot + '.output', locdbl_offset + '.rotate')
            pmc.connectAttr(md_scl + '.output', locdbl_offset + '.scale')
            
            pmc.setAttr(locdbl_parent + 'Shape.visibility', 0)
            pmc.setAttr(locdbl_offset + 'Shape.visibility', 0)
            
        pmc.undoInfo(closeChunk=True)
Пример #26
0
 def wrapper(*args, **kwargs):
     pmc.undoInfo(openChunk=True)
     try:
         result = func(*args, **kwargs)
     except:
         vp.vPrint('Error', 1)
     finally:
         pmc.undoInfo(closeChunk=True)
         return result
Пример #27
0
def undo():
    """
    Run a block of code in an undo block.
    """
    pm.undoInfo(openChunk=True)
    try:
        yield
    finally:
        pm.undoInfo(closeChunk=True)
Пример #28
0
    def onAfterPressed(self, method):
        pm.undoInfo(closeChunk=True)

        # repeat last command
        module = method.__module__
        full_method = module + '.' + method.__name__
        pm.repeatLast(ac='python("import {}; {}()")'.format(
            module, full_method),
                      acl=full_method)
Пример #29
0
 def wrapper(*args, **kwargs):
     pm.undoInfo(openChunk=True)
     try:
         return func(*args, **kwargs)
     except Exception as e:
         print(traceback.format_exc())
         error(str(e))
     finally:
         pm.undoInfo(closeChunk=True)
Пример #30
0
    def restore(self):
        pm.undoInfo(closeChunk=True)
        self._closed = True

        try:
            pm.undo()

        except StandardError:
            pass
Пример #31
0
def uvmp_reset_slider(*args, **kwargs):
    '''
    resets the rotation slider to 0 position after its let go
    '''

    global undoChunk
    if undoChunk == True:  # close the undo chunck on slider release
        pm.undoInfo(closeChunk=True, chunkName='undo_rotate_interactive')
        undoChunk = False
    pm.floatSlider(prefix + '_rotate_free', e=True, v=0)
Пример #32
0
def clear_all_rsl():
    """Clear all renderSetupLayers
    """
    try:
        pm.undoInfo(openChunk=True)
        rs = renderSetup.instance()
        rs.clearAll()
        mel.eval('MLdeleteUnused;')
    finally:
        pm.undoInfo(closeChunk=True)
Пример #33
0
 def setDelAction(self):
     # self.dropAction = Qt.CopyAction
     print 111
     pm.undoInfo(openChunk=True)
     # self.dropAction = Qt.MoveAction
     for item in self.selectedItems():
         layer_name = item.text()
         layer_name = unicode(layer_name)
         pm.delete(layer_name)
     pm.undoInfo(closeChunk=True)
Пример #34
0
 def __exit__(self, exc_type, exc_val, exc_tb):
     pmc.undoInfo(closeChunk=True)
     if exc_val is not None:
         try:
             pmc.undo()
         except RuntimeError:
             pass
     if exc_type == AssertionError:
         logging.warning(exc_val)
         return True
    def set(self, cc=False):
        if not cc and not self.undoState:
            self.undoState = True
            pm.undoInfo(openChunk=True)

        for i in self.obj():
            getattr(i, self.name.lower()).set(self.attr_.getValue())

        if cc and self.undoState:
            pm.undoInfo(closeChunk=True)
            self.undoState = False
Пример #36
0
 def doNgSkinRelax(self, *args):
     numSteps = self.ui.ng_iteractions_spin.value()
     stepSize = self.ui.ng_stepSize_spin.value()
     nativeSoft = self.ui.ng_mayaNativeSelection_chk.isChecked()
     pm.undoInfo(openChunk=True)
     try:
         pm.ngSkinRelax(numSteps=numSteps,
                        stepSize=stepSize,
                        nss=nativeSoft)
     finally:
         pm.undoInfo(closeChunk=True)
Пример #37
0
    def onPivotPressed(self, item):
        """
        Called when dynamic pivot item is clicked. Will set dynamic pivot transforms to 0.

        Args:
            item (QtWidgets.QListWidgetItem): Dynamic pivot to reset when clicked.
        """
        pm.undoInfo(openChunk=True)
        space.resetDynamicPivot(pm.PyNode(item.text()),
                                key=self.keyframe_box.isChecked())
        pm.undoInfo(closeChunk=True)
Пример #38
0
    def _iterator_smooth(self, iterations, pass_value):
        """Function to create an undo chunk and iteratively smooth the graph keys.
		The undo chunk is used to return back to the original state in one undo command.
		"""
        # Creating an undo chunk start point
        _pm.undoInfo(openChunk=True)
        # Iteratively calling the smooth keys functionality
        for iterator in xrange(iterations):
            self.smooth_keys(pass_value)
        # Creating an undo chunk end point
        _pm.undoInfo(closeChunk=True)
Пример #39
0
    def headSquash_doGuide(self):
        getDictFromScene = self.ui.squash_getGuide_chk.isChecked()
        self.headSquash = squash.Squash(name='headSquash')
        pm.undoInfo(openChunk=True)
        try:
            if getDictFromScene:
                self.headSquash.getDict()

            self.headSquash.doGuide()
        finally:
            pm.undoInfo(closeChunk=True)
Пример #40
0
def exportAnimation(path=None):
    """
    Bakes and exports animation on a rig in the scene.
    
    Args:
        path(str): An destination fbx path to export. 
    """
    if path is None:
        path = pmc.sceneName()
    path = path.replace('.ma', '.fbx')

    # Get the root joint
    root = None
    namespace = None
    for namespace in pmc.listNamespaces():
        root = getRootJoint(namespace)
        if root is not None:
            namespace = namespace
            break
    if root is None:
        raise RootJointException('Could not find a root in the scene with a namespace.')

    try:
        pmc.undoInfo(openChunk=True)

        # Create a duplicate root joint
        dupRoot = pmc.duplicate(root)[0]
        pmc.rename(dupRoot, root.nodeName().split(':')[-1])

        # Copy animation tags
        copyTagAttribiutes(root, dupRoot)

        # Bind skeleton
        constraints = []
        exportJoints = [dupRoot] + getBindSkeleton()
        for joint in [dupRoot] + getBindSkeleton():
            source = pmc.PyNode('%s:%s' % (namespace, joint.nodeName()))
            constraints.append(pmc.parentConstraint(source, joint))

        # Bake animation and remove constraints
        bakeAnimation(exportJoints)
        pmc.delete(constraints)

        # Export animation and convert to hkx
        exportFbx([dupRoot] + getBindSkeleton(), path=path, animation=True)
        ckcmd.importanimation(
            getSceneSkeletonHkx(legacy=True), path,
            getSceneAnimationDirectory(), cache_txt=getSceneCacheFile(),
            behavior_directory=getSceneBehaviorDirectory()
        )

        # TODO copy cache file to correct directory
    finally:
        pmc.undoInfo(closeChunk=True)
Пример #41
0
def switch(space, timeRange=False, start=0, end=0):

    #undo enable
    pm.undoInfo(openChunk=True)

    sel = pm.ls(selection=True)

    for node in sel:
        cnt = getConnectedNodes(node, 'control')[0]

        controls = []
        for obj in getConnectedNodes(cnt, 'message'):

            #IK switch
            if space == 'IK':
                if obj.space.get() == space:
                    if timeRange:
                        for count in xrange(start, end):
                            pm.currentTime(count)
                            switch = getConnectedNodes(obj, 'switch')[0]
                            Snap(obj, switch)

                            cnt.blend.set(1)
                    else:
                        switch = getConnectedNodes(obj, 'switch')[0]
                        Snap(obj, switch)

                        cnt.blend.set(1)

            #FK control finding
            if space == 'FK':
                if obj.space.get() == space:
                    controls.append(obj)

        #FK switch
        controls.sort(key=lambda x: x.chain.get())
        if timeRange:
            for count in xrange(start, end):
                pm.currentTime(count)
                for obj in controls:
                    switch = getConnectedNodes(obj, 'switch')[0]
                    Snap(obj, switch)

                    cnt.blend.set(0)
        else:
            for obj in controls:
                switch = getConnectedNodes(obj, 'switch')[0]
                Snap(obj, switch)

                cnt.blend.set(0)

    pm.undoInfo(closeChunk=True)
Пример #42
0
    def create_ui(self):
        pmc.undoInfo(openChunk=True)

        self.setWindowTitle('VFK Rig Creator')
        self.setWindowFlags(qc.Qt.Tool)
        self.setMinimumSize(300, 400)
        self.setMaximumWidth(300)
        
        self.create_controls()
        self.create_layout()
        self.create_connections()

        pmc.undoInfo(closeChunk=True)
Пример #43
0
    def set(self, cc=False):
        if not cc and not self.undoState:
            self.undoState = True
            pm.undoInfo(openChunk=True)

        try:
            getattr(self.ceObj.wire[0], self.name).set(self.attr.getValue())
        except:
            AttributeError('{0} node does no longer exist'.format(self.ceObj.wire[0]))

        if cc and self.undoState:
            pm.undoInfo(closeChunk=True)
            self.undoState = False
Пример #44
0
 def RebuildMesh(self):
     pm.undoInfo(openChunk=True)
     mc.select(self.hipsMesh, self.spineMesh, self.chestMesh, self.headMesh, self.l_upperArmMesh,
     self.l_lowerArmMesh, self.l_thumbMesh_a, self.l_thumbMesh_b, self.l_thumbMesh_c, self.l_indexMesh_a,
     self.l_indexMesh_b, self.l_indexMesh_c, self.l_middleMesh_a, self.l_middleMesh_b, self.l_middleMesh_c,
     self.l_ringMesh_a, self.l_ringMesh_b, self.l_ringMesh_c, self.l_pinkieMesh_a, self.l_pinkieMesh_b,
     self.l_pinkieMesh_c, self.r_upperArmMesh, self.r_lowerArmMesh, self.r_thumbMesh_a, self.r_thumbMesh_b,
     self.r_thumbMesh_c, self.r_indexMesh_a, self.r_indexMesh_b, self.r_indexMesh_c, self.r_middleMesh_a,
     self.r_middleMesh_b, self.r_middleMesh_c, self.r_ringMesh_a, self.r_ringMesh_b, self.r_ringMesh_c,
     self.r_pinkieMesh_a, self.r_pinkieMesh_b, self.r_pinkieMesh_c, self.l_upperLegMesh, self.l_lowerLegMesh,
     self.l_footMesh, self.l_toesMesh, self.r_upperLegMesh, self.r_lowerLegMesh, self.r_footMesh, self.r_toesMesh)
     mc.delete()
     self.BuildMesh()
     pm.undoInfo(closeChunk=True)
Пример #45
0
 def setTorsoSize(self, value):
     pm.undoInfo(openChunk=True)
     if value > 10.0:
         value = value / 100.0
         self.torsoSize_spinBox.setValue(value)
     else:
         self.torsoSize_slider.setValue(value*100)
         
     self.setJointScale(self.spine, value, self.torsoSize)
     self.setJointScale(self.chest, value, self.torsoSize)
     self.setJointScale(self.neck, value, self.torsoSize)
     
     self.torsoSize = value
     self.RebuildMesh()
     pm.undoInfo(closeChunk=True)
Пример #46
0
 def InitRig(self):
     pm.undoInfo(openChunk=True)
 
     self.legHeight_slider.blockSignals(True)
     self.legHeight_spinBox.blockSignals(True)
     self.legHeight = 1
     self.legHeight_slider.setValue(100) 
     self.legHeight_spinBox.setValue(1.0)
     self.legHeight_slider.blockSignals(False)
     self.legHeight_spinBox.blockSignals(False)
     
     self.headSize_slider.blockSignals(True)
     self.headSize_spinBox.blockSignals(True)
     self.headSize = 1
     self.headSize_slider.setValue(100)
     self.headSize_spinBox.setValue(1.0)
     self.headSize_slider.blockSignals(False)
     self.headSize_spinBox.blockSignals(False)
     
     self.torsoSize_slider.blockSignals(True)
     self.torsoSize_spinBox.blockSignals(True)
     self.torsoSize = 1
     self.torsoSize_slider.setValue(100)
     self.torsoSize_spinBox.setValue(1.0)
     self.torsoSize_slider.blockSignals(False)
     self.torsoSize_spinBox.blockSignals(False)
     
     self.l_armLength_slider.blockSignals(True)
     self.l_armLength_spinBox.blockSignals(True)
     self.l_armLength = 1
     self.l_armLength_slider.setValue(100) 
     self.l_armLength_spinBox.setValue(1.0)
     self.l_armLength_slider.blockSignals(False)
     self.l_armLength_spinBox.blockSignals(False)
     
     self.r_armLength_slider.blockSignals(True)
     self.r_armLength_spinBox.blockSignals(True)
     self.r_armLength = 1
     self.r_armLength_slider.setValue(100) 
     self.r_armLength_spinBox.setValue(1.0)
     self.r_armLength_slider.blockSignals(False)
     self.r_armLength_spinBox.blockSignals(False)
     
     self.enableRigEdit(True)
     self.InitializeRig();
     
     pm.undoInfo(closeChunk=True)
Пример #47
0
def Connect(alembicRoot, targetRoot, connectShapes=True):

    pm.undoInfo(openChunk=True)

    alembics = pm.ls(alembicRoot, dagObjects=True, long=True)
    targets = pm.ls(targetRoot, dagObjects=True, long=True)
    for node in targets:
        for abc in alembics:
            if node.split(':')[-1] == abc.split(':')[-1]:

                #get connection attributes
                data = getConnectedAttr(abc, connectShapes)

                #connects any animated node
                if data:
                    for attr in data:
                        try:
                            pm.connectAttr(data[attr],
                                             '%s.%s' % (node, attr),
                                             force=True)
                            CopyTransform(abc, node)
                        except:
                            pass
                #connects any static node
                else:
                    try:
                        #copy transform and blendshape to ensure placement
                        CopyTransform(abc, node)
                        Blendshape(abc, node)

                    except:
                        pass

                #adding user defined attrs to all shapes
                if node.nodeType() == 'mesh':
                    shapes = node.getParent().getShapes()
                    for shp in shapes:
                        for attr in node.listAttr(userDefined=True):
                            attrType = pm.getAttr(attr, type=True)
                            try:
                                shp.addAttr(attr.split('.')[-1],
                                               attributeType=attrType,
                                               defaultValue=attr.get())
                            except:
                                pass

    pm.undoInfo(closeChunk=True)
Пример #48
0
 def setHeadSize(self, value):
     pm.undoInfo(openChunk=True)
     self.progressBar.setValue(100)
     if value > 10.0:
         value = value / 100.0
         self.headSize_spinBox.setValue(value)
     else:
         self.headSize_slider.setValue(value*100)
     
     mc.select(self.headMesh)
     mc.delete()
     
     self.setJointScale(self.headTop, value, self.headSize)
     self.headMesh = createSphere("char_headMesh", self.head, self.headTop)
     self.headSize = value
     self.progressBar.setValue(0)
     pm.undoInfo(closeChunk=True)
Пример #49
0
 def inner(*args, **kwargs):
     err = None
     pmc.undoInfo(openChunk=True)
     try:
         res = func(*args, **kwargs)
     except Exception as err:
         raise
     finally:
         pmc.undoInfo(closeChunk=True) # Close undo!
         if err: # Did we error out?
             pmc.undo()
             e_type, e_name, e_trace = sys.exc_info() # Last error
             pmc.confirmDialog(
                 t="Uh oh... %s" % e_type.__name__,
                 m=str(e_name)
                 )
     return res
Пример #50
0
def amcveProfile(cvSrc, trim):
	"""
	"""
	cvSrc = pm.ls(cvSrc)[0]
	tiLen = []

	if trim:
		tiLen.append(pm.playbackOptions(q= 1, min= 1))
		tiLen.append(pm.playbackOptions(q= 1, max= 1))
		pm.undoInfo(ock= 1)
		pm.setKeyframe(cvSrc, insert= 1, t= tiLen, f= tiLen)
		pm.undoInfo(cck= 1)

	cvBaseMod = {
			'cvTyp' : pm.objectType(cvSrc),
			'prInf' : cvSrc.getPreInfinityType().key,
			'poInf' : cvSrc.getPostInfinityType().key,
			'weedT' : pm.keyTangent(cvSrc, q= 1, weightedTangents= 1),
			'breaD' : pm.keyframe(cvSrc, q= 1, breakdown= 1)
	}
	cvPortray = {
			'Frame' : pm.keyframe(cvSrc, q= 1, timeChange= 1),
			'Float' : pm.keyframe(cvSrc, q= 1, floatChange= 1),
			'Value' : pm.keyframe(cvSrc, q= 1, valueChange= 1)
	}
	cvFeature = {
			'TLock' : pm.keyTangent(cvSrc, q= 1, lock= 1),
			'WLock' : pm.keyTangent(cvSrc, q= 1, weightLock= 1),
			'InTyp' : pm.keyTangent(cvSrc, q= 1, inTangentType= 1),
			'OuTyp' : pm.keyTangent(cvSrc, q= 1, outTangentType= 1),
			'InWet' : pm.keyTangent(cvSrc, q= 1, inWeight= 1),
			'OuWet' : pm.keyTangent(cvSrc, q= 1, outWeight= 1),
			'InAng' : pm.keyTangent(cvSrc, q= 1, inAngle= 1),
			'OuAng' : pm.keyTangent(cvSrc, q= 1, outAngle= 1)
	}
	cvSrcProfile = {
			'cvTrimmed' : tiLen,
			'cvBaseMod' : cvBaseMod,
			'cvPortray' : cvPortray,
			'cvFeature' : cvFeature
	}
	if trim:
		pm.undo()

	return cvSrcProfile
Пример #51
0
 def run(self):
     
     items = self.weightListWidget.selectedItems()
     
     attrList = []
     
     pm.undoInfo(ock=1)        
     
     for x in items:
         attrList.append(x.text())
     
     value = float(self.setValueLine.text())
     
     for x in self.objectList:
         for y in attrList:
             x.attr(y).set(value)
     
     pm.undoInfo(cck=1)
Пример #52
0
def localRemap(dis, remapType, tirm, sel_src, sel_dis, scale= None, mirror= None):
	"""
	### preselect dis, than select src
	dis = 'TVbuddy_rigging_master3:TVbuddyV1'
	mr.localRemap(dis, 'order', True, False, False)
	"""
	# src ctrl keys
	ctrlList_src = md.lsController(sel_src)
	src = md.keyController(ctrlList_src)
	# dis ctrl list
	dis = md.lsController(sel_dis, dis)
	# gen map
	keyMap = md.drawKeyMap(remapType, src, dis)
	# link up
	pm.undoInfo(ock= 1)
	for ctrl in keyMap:
		if not ctrl == keyMap[ctrl]:
			cvp = md.packup(src[ctrl], tirm)
			md.wireup(cvp, keyMap[ctrl], scale, mirror)
	pm.undoInfo(cck= 1)
Пример #53
0
 def bindRig(self):
     pm.undoInfo(openChunk=True)
     
     self.progressBar.setValue(50)
     mc.polyUnite(self.hipsMesh, self.spineMesh, self.chestMesh, self.headMesh, self.l_upperArmMesh,
     self.l_lowerArmMesh, self.l_thumbMesh_a, self.l_thumbMesh_b, self.l_thumbMesh_c, self.l_indexMesh_a,
     self.l_indexMesh_b, self.l_indexMesh_c, self.l_middleMesh_a, self.l_middleMesh_b, self.l_middleMesh_c,
     self.l_ringMesh_a, self.l_ringMesh_b, self.l_ringMesh_c, self.l_pinkieMesh_a, self.l_pinkieMesh_b,
     self.l_pinkieMesh_c, self.r_upperArmMesh, self.r_lowerArmMesh, self.r_thumbMesh_a, self.r_thumbMesh_b,
     self.r_thumbMesh_c, self.r_indexMesh_a, self.r_indexMesh_b, self.r_indexMesh_c, self.r_middleMesh_a,
     self.r_middleMesh_b, self.r_middleMesh_c, self.r_ringMesh_a, self.r_ringMesh_b, self.r_ringMesh_c,
     self.r_pinkieMesh_a, self.r_pinkieMesh_b, self.r_pinkieMesh_c, self.l_upperLegMesh, self.l_lowerLegMesh,
     self.l_footMesh, self.l_toesMesh, self.r_upperLegMesh, self.r_lowerLegMesh, self.r_footMesh, self.r_toesMesh,
     n = "char_body")
     self.progressBar.setValue(100)
     mc.select(self.hips, tgl=True, hi=True)
     mc.SmoothBindSkin()
     self.enableRigEdit(False)
     self.progressBar.setValue(0)
     
     pm.undoInfo(closeChunk=True)
Пример #54
0
    def _jointRes(self, parentJoint, endJoint, boneTranslateAxis = '.tx', add=2.0, name="subJoint_"):
        pmc.undoInfo(openChunk=True)
        
        selJoints = pmc.ls(selection=True)
        
        boneLength = mc.getAttr(endJoint + boneTranslateAxis)
        boneRadius = mc.getAttr(parentJoint + ".radius")

        mc.select(cl=True)
        
        for i in xrange(int(round(add))):
            newJoint = pmc.joint(name=name + str(i+1), radius = (boneRadius*2))
            mc.select(cl=True)
            pmc.parent(newJoint, parentJoint, relative=True)
            mc.setAttr(newJoint + boneTranslateAxis, (boneLength/(add + 1)))
            if i > 0:
                pmc.parent(newJoint, (name + str(i)), relative = True)
            if i == add - 1:
                pmc.parent(endJoint, newJoint)
        
        pmc.undoInfo(closeChunk=True)
Пример #55
0
def manage_default_options(**kwargs):
    """
    Sets Various Default options for Maya

    viewmManip : Default Hide the manipulator Cube
    gradient: Default Hide the Background gradient
    autosave: Default Enable Autosave
    mentalray: Default Enable mr as Default Render Engine
    interactiveCreation: Enables Disables Interactive Creation Mode for Primitive Objects

    hardware2: Optional Enable Hardware Renderer 2.0 as Default Render Engine

    """

    # Disable View Cube
    pm.viewManip(visible=kwargs.get("viewManip", False))

    # Disable Background Gradient
    pm.displayPref(displayGradient=kwargs.get("gradient", False))

    # Infinite Undo
    pm.undoInfo(state=True, infinity=kwargs.get("infiniteUndo", True))

    # Enable Autosave, max Versions 10, interval 15min
    pm.autoSave(enable=kwargs.get("autosave", True), maxBackups=kwargs.get(
        "maxBackups", 10), interval=kwargs.get("interval", 900))

    # Activate Mental Ray
    if kwargs.get("mentalray", True):
        enable_mr_plugin()

    # Sets Hardwarerenderer 2.0 as Default
    if kwargs.get("hardware2", False):
        pm.PyNode("defaultRenderGlobals").currentRenderer.set("mayaHardware2")

    # Expose Mental Ray Production Nodes
    pm.optionVar["MIP_SHD_EXPOSE"] = 1

    # Disable Interactive Creation
    set_interactive_creation(kwargs.get("interactiveCreation", False))
Пример #56
0
 def __exit__(self, type, value, tb):
     try:
         pm.undoInfo(closeChunk=1)
     except TypeError:
         # Legacy support for before undo chunking existed
         # Turn undo back on
         pm.undoInfo(stateWithoutFlush=1)
         # This is needed for things to work for some reason
         pm.undoInfo(query=1, undoName=0)
Пример #57
0
def undo_chunk(auto_undo=False, exc_callback=None):
    '''
    Undo chunk context manager...
    '''

    try:
        pm.undoInfo(openChunk=True)
        yield
    except Exception as e:
        pm.undoInfo(closeChunk=True)
        if auto_undo:
            pm.undo()
        if exc_callback:
            exc_callback(e)
        raise
    else:
        pm.undoInfo(closeChunk=True)
Пример #58
0
    def setRightArmLength(self, value):
        pm.undoInfo(openChunk=True)
        self.progressBar.setValue(50)
        if value > 10.0:
            value = value / 100.0
            self.r_armLength_spinBox.setValue(value)
        else:
            self.r_armLength_slider.setValue(value*100)
            
        mc.select(self.r_upperArmMesh, self.r_lowerArmMesh, self.r_thumbMesh_a, self.r_thumbMesh_b, self.r_thumbMesh_c,
        self.r_indexMesh_a, self.r_indexMesh_b, self.r_indexMesh_c, self.r_middleMesh_a, self.r_middleMesh_b,
        self.r_middleMesh_c, self.r_ringMesh_a, self.r_ringMesh_b, self.r_ringMesh_c, self.r_pinkieMesh_a,
        self.r_pinkieMesh_b, self.r_pinkieMesh_c)
        mc.delete()
        
        self.setJointScale(self.r_shoulder, value, self.r_armLength)
        self.setJointScale(self.r_upperArm, value, self.r_armLength)
        self.setJointScale(self.r_lowerArm, value, self.r_armLength)
        self.setJointScale(self.r_wrist, value, self.r_armLength)
        self.setJointScale(self.r_thumb_a, value, self.r_armLength)
        self.setJointScale(self.r_thumb_b, value, self.r_armLength)
        self.setJointScale(self.r_thumb_c, value, self.r_armLength)
        self.setJointScale(self.r_thumb_d, value, self.r_armLength)
        
        self.setJointScale(self.r_index_a, value, self.r_armLength)
        self.setJointScale(self.r_index_b, value, self.r_armLength)
        self.setJointScale(self.r_index_c, value, self.r_armLength)
        self.setJointScale(self.r_index_d, value, self.r_armLength)
        
        self.setJointScale(self.r_middle_a, value, self.r_armLength)
        self.setJointScale(self.r_middle_b, value, self.r_armLength)
        self.setJointScale(self.r_middle_c, value, self.r_armLength)
        self.setJointScale(self.r_middle_d, value, self.r_armLength)
        
        self.setJointScale(self.r_ring_a, value, self.r_armLength)
        self.setJointScale(self.r_ring_b, value, self.r_armLength)
        self.setJointScale(self.r_ring_c, value, self.r_armLength)
        self.setJointScale(self.r_ring_d, value, self.r_armLength)
        
        self.setJointScale(self.r_pinkie_a, value, self.r_armLength)
        self.setJointScale(self.r_pinkie_b, value, self.r_armLength)
        self.setJointScale(self.r_pinkie_c, value, self.r_armLength)
        self.setJointScale(self.r_pinkie_d, value, self.r_armLength)
        
        self.r_upperArmMesh = CreateRightCube("char_r_upperArmMesh", self.r_lowerArm, self.r_upperArm, [2,1,2], [5,1,5])
        self.r_lowerArmMesh = CreateRightCube("char_r_lowerArmMesh", self.r_wrist, self.r_lowerArm, [2,1,2], [3,1,3])

        self.r_thumbMesh_a = CreateRightCube("char_r_thumbMesh_a", self.r_thumb_b, self.r_thumb_a, [1,1,1], [1,1,1])
        self.r_thumbMesh_b = CreateRightCube("char_r_thumbMesh_b", self.r_thumb_c, self.r_thumb_b, [1,1,1], [1,1,1])
        self.r_thumbMesh_c = CreateRightCube("char_r_thumbMesh_c", self.r_thumb_d, self.r_thumb_c, [1,1,1], [1,1,1])

        self.r_indexMesh_a = CreateRightCube("char_r_indexMesh_a", self.r_index_b, self.r_index_a, [1,1,1], [1,1,1])
        self.r_indexMesh_b = CreateRightCube("char_r_indexMesh_b", self.r_index_c, self.r_index_b, [1,1,1], [1,1,1])
        self.r_indexMesh_c = CreateRightCube("char_r_indexMesh_c", self.r_index_d, self.r_index_c, [1,1,1], [1,1,1])
        
        self.progressBar.setValue(100)
        
        self.r_middleMesh_a = CreateRightCube("char_r_middleMesh_a", self.r_middle_b, self.r_middle_a, [1,1,1], [1,1,1])
        self.r_middleMesh_b = CreateRightCube("char_r_middleMesh_b", self.r_middle_c, self.r_middle_b, [1,1,1], [1,1,1])
        self.r_middleMesh_c = CreateRightCube("char_r_middleMesh_c", self.r_middle_d, self.r_middle_c, [1,1,1], [1,1,1])

        self.r_ringMesh_a = CreateRightCube("char_r_ringMesh_a", self.r_ring_b, self.r_ring_a, [1,1,1], [1,1,1])
        self.r_ringMesh_b = CreateRightCube("char_r_ringMesh_b", self.r_ring_c, self.r_ring_b, [1,1,1], [1,1,1])
        self.r_ringMesh_c = CreateRightCube("char_r_ringMesh_c", self.r_ring_d, self.r_ring_c, [1,1,1], [1,1,1])

        self.r_pinkieMesh_a = CreateRightCube("char_r_pinkieMesh_a", self.r_pinkie_b, self.r_pinkie_a, [1,1,1], [1,1,1])
        self.r_pinkieMesh_b = CreateRightCube("char_r_pinkieMesh_b", self.r_pinkie_c, self.r_pinkie_b, [1,1,1], [1,1,1])
        self.r_pinkieMesh_c = CreateRightCube("char_r_pinkieMesh_c", self.r_pinkie_d, self.r_pinkie_c, [1,1,1], [1,1,1])
        
        self.r_armLength = value
        self.progressBar.setValue(0)
        pm.undoInfo(closeChunk=True)
Пример #59
0
 def _endSliderUndo(self):
     pm.undoInfo(closeChunk=True)
     self.slider_down = False