示例#1
0
def nmManipulator_world():
    '''
	this function will set all the transform tools to world space.
	'''
    cmds.manipMoveContext('Move', e=True, mode=2)
    cmds.manipRotateContext('Rotate', e=True, mode=1)
    try:
        cmds.manipScaleContext('Scale', e=True, mode=2)
    except:
        pass
    # line
    nmGUI_func.nmGUI_runCheck(
        'complete', 'Manipulator tools have been set to world space.')
示例#2
0
    def scaleTool(self):
        try:
            if Cache.keyOffset == 0:
                cmds.manipScaleContext('myScale', edit=True,
                                       mode=2)  # world mode
                Cache.currentContext = 'myScale'
                self.setAttributes()
            else:
                cmds.manipScaleContext('myScale', edit=True,
                                       mode=0)  # object mode
                Cache.currentContext = 'myScale'
                self.setAttributes()
        except:
            if Cache.keyOffset == 0:
                cmds.manipScaleContext('myScale', mode=2)  # world mode
                Cache.currentContext = 'myScale'
                self.setAttributes()
            else:
                cmds.manipScaleContext('myScale', mode=0)  # object mode
                Cache.currentContext = 'myScale'
                self.setAttributes()
        cmds.setToolTo(Cache.currentContext)


#
#Tool = Tools()
示例#3
0
def set_commands(node_type='transform', pre_func=str, post_func=str):
    mc.manipMoveContext('Move', e=True, preDragCommand=[pre_func, node_type])
    mc.manipMoveContext('Move', e=True, postDragCommand=[post_func, node_type])
    mc.manipRotateContext('Rotate',
                          e=True,
                          preDragCommand=[pre_func, node_type])
    mc.manipRotateContext('Rotate',
                          e=True,
                          postDragCommand=[post_func, node_type])
    mc.manipScaleContext('Scale', e=True, preDragCommand=[pre_func, node_type])
    mc.manipScaleContext('Scale',
                         e=True,
                         postDragCommand=[post_func, node_type])
    # the drag commands are only active on reentering the context
    mc.setToolTo(mc.currentCtx())
示例#4
0
    def flatten(component, script_job=False):

        if script_job:
            cmds.select(selected.cmdslist())
        else:
            cmds.select(component.cmdslist())

        center = list(component.bbox.center)[:3]
        origin = get_average_vert_normal(component.normals, component.indices)

        # Perform scale
        cmds.manipScaleContext('Scale', e=True, mode=6, alignAlong=origin)
        radians = cmds.manipScaleContext('Scale', q=True, orientAxes=True)
        t = [math.degrees(r) for r in radians]
        cmds.scale(0, 1, 1, r=True, oa=t, p=center)
示例#5
0
def setManipCommands(nodeType='transform', preFunc=str, postFunc=str):
    mc.manipMoveContext('Move', e=True, preDragCommand=[preFunc, nodeType])
    mc.manipMoveContext('Move', e=True, postDragCommand=[postFunc, nodeType])
    mc.manipRotateContext('Rotate', e=True, preDragCommand=[preFunc, nodeType])
    mc.manipRotateContext('Rotate',
                          e=True,
                          postDragCommand=[postFunc, nodeType])
    mc.manipScaleContext('Scale', e=True, preDragCommand=[preFunc, nodeType])
    mc.manipScaleContext('Scale', e=True, postDragCommand=[postFunc, nodeType])
    # the drag commands are only active on reentering the context
    currentCtx = mc.currentCtx()
    if currentCtx in [
            'moveSuperContext', 'RotateSuperContext', 'scaleSuperContext'
    ]:
        # only set context if needed
        mc.setToolTo(currentCtx)
示例#6
0
def setManip():

    manip = cmds.radioButtonGrp('manip', q=True, sl=True)

    # Setting to World Space
    if (manip == 1):
        cmds.manipMoveContext('Move', e=True, mode=2)
        cmds.manipRotateContext('Rotate', e=True, mode=1)
        cmds.manipScaleContext('Scale', e=True, mode=2)

    # Setting to Object Space
    elif (manip == 2):
        cmds.manipMoveContext('Move', e=True, mode=0)
        cmds.manipRotateContext('Rotate', e=True, mode=0)
        cmds.manipScaleContext('Scale', e=True, mode=0)

    maya.mel.eval('SelectToolOptionsMarkingMenu; MarkingMenuPopDown;'
                  )  # Changing Tool to selection
    def scriptJobCmds(self):

        mc.manipScaleContext('Scale', e=True, mode=6)
        mc.manipRotateContext('Rotate', e=True, mode=3)
        mc.manipMoveContext('Move', e=True, mode=6)

        #fix: isolateSelection
        viewSelectedSets = mc.ls('*ViewSelectedSet', type='objectSet')
        isolatedObjs = []
        panelName = ''

        for set in viewSelectedSets:
            isolatedObjs = mc.sets(set, q=True)

            if (len(isolatedObjs) == 0):
                continue

            panelName = set.split('ViewSelectedSet')[0]
            mc.isolateSelect(panelName, s=False)
            mc.isolateSelect(panelName, s=True)
            break
示例#8
0
def manipScaleContext(*args, **kwargs):
    if len(args):
        doPassSelf = kwargs.pop('passSelf', False)
    else:
        doPassSelf = False
    for key in ['pod', 'postCommand', 'postDragCommand', 'prc', 'prd', 'preCommand', 'preDragCommand', 'psc']:
        try:
            cb = kwargs[key]
            if callable(cb):
                kwargs[key] = _factories.makeUICallback(cb, args, doPassSelf)
        except KeyError:
            pass
    res = cmds.manipScaleContext(*args, **kwargs)
    return res
示例#9
0
def alignPivot(move = True, scale = False, fix = False):
    normal = getFaceNormals()

    if fix:
        up = pm.dt.Vector(0.0, 1.0, 0.0)
        if up == normal: up = pm.dt.Vector(1.0, 0.0, 0.0)

        y_axis = normal.cross(up)
        x_axis = y_axis.cross(normal)

        rot = computeFrame(normal, x_axis, y_axis)

    if move:
        if fix:
            cmds.manipMoveContext("Move", edit=True, mode=6, orientAxes=[rot[0], rot[1], rot[2]])
        else:
            cmds.manipMoveContext("Move", edit=True, mode=6, alignAlong=[normal.x, normal.y, normal.z])
    if scale:
        if fix:
            cmds.manipScaleContext("Scale", edit=True, mode=6, orientAxes=[rot[0], rot[1], rot[2]])
        else:
            cmds.manipScaleContext("Scale", edit=True, mode=6, alignAlong=[normal.x, normal.y, normal.z])
    cmds.refresh(currentView=True)
示例#10
0
    def testScaleUSD(self):
        '''Scale USD object, read through the Transform3d interface.'''

        # Select Ball_35 to scale it.
        ball35Path = ufe.Path([
            mayaUtils.createUfePathSegment("|world|transform1|proxyShape1"),
            usdUtils.createUfePathSegment("/Room_set/Props/Ball_35")
        ])
        ball35Item = ufe.Hierarchy.createItem(ball35Path)

        ufe.GlobalSelection.get().append(ball35Item)

        # Create a Transform3d interface for it.
        transform3d = ufe.Transform3d.transform3d(ball35Item)

        # We compare the UFE scale with the USD run-time scale.  To
        # obtain the full scale of Ball_35, we need to add the USD
        # scale to the Maya proxy shape scale.
        proxyShapeXformObj = om.MSelectionList().add('transform1').getDagPath(
            0).node()
        proxyShapeXformFn = om.MFnTransform(proxyShapeXformObj)

        def ball35Scale():
            ball35Prim = usdUtils.getPrimFromSceneItem(ball35Item)
            if not ball35Prim.HasAttribute('xformOp:scale'):
                return proxyShapeXformFn.scale()
            else:
                return combineScales(
                    proxyShapeXformFn.scale(),
                    ball35Prim.GetAttribute('xformOp:scale').Get())

        # Set up the callables that will retrieve the scale.
        self.runTimeScale = ball35Scale
        self.ufeScale = partial(transform3dScale, transform3d)

        # Save the initial position to the memento list.
        expected = ball35Scale()

        # MAYA-96058: unfortunately, scale command currently requires a scale
        # manipulator to be created to update the UFE object.
        manipCtx = cmds.manipScaleContext()
        cmds.setToolTo(manipCtx)

        self.runTestScale(expected)
示例#11
0
	def scaleTool(self):
		try:
			if Cache.keyOffset == 0:
				cmds.manipScaleContext('myScale', edit = True, mode = 2) # world mode
				Cache.currentContext = 'myScale'
				self.setAttributes()
			else:
				cmds.manipScaleContext('myScale', edit = True, mode = 0) # object mode
				Cache.currentContext = 'myScale'
				self.setAttributes()
		except:
			if Cache.keyOffset == 0:
				cmds.manipScaleContext( 'myScale', mode = 2 ) # world mode
				Cache.currentContext = 'myScale'
				self.setAttributes()
			else:
				cmds.manipScaleContext('myScale', mode = 0) # object mode
				Cache.currentContext = 'myScale'
				self.setAttributes()
		cmds.setToolTo( Cache.currentContext )
#
#Tool = Tools()
示例#12
0
    def scaleModePress(self):
        cmds.ScaleToolWithSnapMarkingMenu()

        mode = int(cmds.manipScaleContext('Scale', q=True, mode=True))
        if self.tool == 'scaleSuperContext':
            if mode == 1:
                # 0 = Object, 1 = Local, 2 = World
                cmds.manipScaleContext('Scale', e=True, mode=2)
                self.printMode('World', changed=True)
            elif mode == 2:
                cmds.manipScaleContext('Scale', e=True, mode=0)
                self.printMode('Object', changed=True)
            elif mode == 0:
                cmds.manipScaleContext('Scale', e=True, mode=1)
                self.printMode('Local', changed=True)

        elif mode == 0:
            self.printMode('Object')
        elif mode == 2:
            self.printMode('World')
        elif mode == 1:
            self.printMode('Local')
示例#13
0
文件: MocBox.py 项目: Mocson/MocBox
def cus():
    cmds.manipMoveContext("Move", e=True, m=6)
    cmds.manipScaleContext("Scale", e=True, m=6)
    cmds.manipRotateContext("Rotate", e=True, m=6)
示例#14
0
def degToRad(xDeg, yDeg, zDeg, relativeOpt, applyFor):
    """
      This function sets degree values and converts them to radians
      within 'Custom axis orientation'.
   """

    # Retrieve degrees data from floatSliderGrp
    xDegVal = cmds.floatSliderGrp(xDeg, query=True, value=True)
    yDegVal = cmds.floatSliderGrp(yDeg, query=True, value=True)
    zDegVal = cmds.floatSliderGrp(zDeg, query=True, value=True)

    # Convert data to radians
    xRadVal = math.radians(xDegVal)
    yRadVal = math.radians(yDegVal)
    zRadVal = math.radians(zDegVal)

    # Find out what boxes were checked and assign those states to variables
    relativeState = cmds.checkBoxGrp(relativeOpt, query=True,
                                     value1=True)  # Relative checkbox
    moveState = cmds.checkBoxGrp(applyFor, query=True,
                                 value1=True)  # Move checkbox
    rotateState = cmds.checkBoxGrp(applyFor, query=True,
                                   value2=True)  # Rotate checkbox
    scaleState = cmds.checkBoxGrp(applyFor, query=True,
                                  value3=True)  # Scale checkbox

    # Execute
    if moveState == True:
        # If Relative checkbox - Checked
        if relativeState == True:
            # Retrieve current radian values from Move 'Custom axis orientation'
            curMoveVal = cmds.manipMoveContext('Move',
                                               query=True,
                                               orientAxes=True)
            # Add new values to current ones
            xRadMoveVal = xRadVal + curMoveVal[0]
            yRadMoveVal = yRadVal + curMoveVal[1]
            zRadMoveVal = zRadVal + curMoveVal[2]
            cmds.manipMoveContext('Move',
                                  e=True,
                                  mode=6,
                                  oa=(xRadMoveVal, yRadMoveVal, zRadMoveVal))
            cmds.setToolTo('moveSuperContext')
        # If Relative checkbox - Unchecked
        else:
            cmds.manipMoveContext('Move',
                                  e=True,
                                  mode=6,
                                  oa=(xRadVal, yRadVal, zRadVal))
            cmds.setToolTo('moveSuperContext')

    if rotateState == True:
        pass  # future code for rotate [RotateSuperContext]

    if scaleState == True:
        # If Relative checkbox - Checked
        if relativeState == True:
            # Retrieve current radian values from Scale 'Custom axis orientation'
            curScaleVal = cmds.manipScaleContext('Scale',
                                                 query=True,
                                                 orientAxes=True)
            # Add new values to current ones
            xRadScaleVal = xRadVal + curScaleVal[0]
            yRadScaleVal = yRadVal + curScaleVal[1]
            zRadScaleVal = zRadVal + curScaleVal[2]
            cmds.manipScaleContext('Scale',
                                   e=True,
                                   mode=6,
                                   oa=(xRadScaleVal, yRadScaleVal,
                                       zRadScaleVal))
            cmds.setToolTo('scaleSuperContext')
        # If Relative checkbox - Unchecked
        else:
            cmds.manipScaleContext('Scale',
                                   e=True,
                                   mode=6,
                                   oa=(xRadVal, yRadVal, zRadVal))
            cmds.setToolTo('scaleSuperContext')
示例#15
0
def caoidWindow():
    """
      This function creates a Maya window.
    """

    caoid = 'caoid'  # Name of the window

    # Check if window already exists. If it exists, delete it.
    if cmds.window(caoid, ex=True):
        cmds.deleteUI(caoid, window=True)

    # Build window
    cmds.window(caoid,
                title='Custom axis orientation in degrees',
                wh=(580, 370),
                retain=False)

    mainContainer = cmds.frameLayout(labelVisible=False,
                                     borderVisible=False,
                                     marginHeight=6,
                                     marginWidth=6)

    # This subContainer prevetns frameLayout children to scale in height
    subContainer = cmds.columnLayout(adjustableColumn=True, rowSpacing=4)
    # SUBCONTAINER CHILDREN : DESCRIPTION FRAME, CURRENT VALUES FRAME, SETTINGS FRAME

    # DESCRIPTION FRAME
    cmds.frameLayout(label="Description",
                     borderStyle="etchedIn",
                     marginHeight=3,
                     labelIndent=5)
    cmds.columnLayout(columnAttach=("left", 18))
    cmds.text(
        l=
        "This tool is setting up values in degrees for 'Custom axis orientation'.",
        align='left')
    cmds.setParent(subContainer)

    # CURRENT VALUES FRAME
    cmds.frameLayout(label="Current values in degrees",
                     borderStyle="etchedIn",
                     marginHeight=6,
                     labelIndent=5)
    cmds.columnLayout(adjustableColumn=True,
                      rowSpacing=4,
                      columnAttach=("left", 18))

    # Retrieve current radian values from Move and Scale 'Custom axis orientation'
    curMoveVal = cmds.manipMoveContext('Move', query=True, orientAxes=True)
    curScaleVal = cmds.manipScaleContext('Scale', query=True, orientAxes=True)

    # Create a new list with converted values (Rad -> Deg)
    curMoveDegVal = []
    for i in curMoveVal:
        curMoveDegVal.append(math.degrees(i))
    curScaleDegVal = []
    for i in curScaleVal:
        curScaleDegVal.append(math.degrees(i))

    cmds.text(l='{0:>18} {1:>13} {2:>13}'.format('X', 'Y', 'Z'), align='left')
    cmds.text(l='Move: {0:>10.3f} {1:>10.3f} {2:>10.3f}'.format(
        curMoveDegVal[0], curMoveDegVal[1], curMoveDegVal[2]),
              align='left')
    cmds.text(l='Scale: {0:>10.3f} {1:>10.3f} {2:>10.3f}'.format(
        curScaleDegVal[0], curScaleDegVal[1], curScaleDegVal[2]),
              align='left')
    cmds.setParent(subContainer)

    # SETTINGS FRAME
    cmds.frameLayout(label='Settings',
                     borderStyle='etchedIn',
                     marginHeight=3,
                     labelIndent=5)
    cmds.columnLayout(adjustableColumn=True)
    xDeg = cmds.floatSliderGrp(l='X axis (deg):',
                               field=True,
                               minValue=-360,
                               maxValue=360,
                               fieldMinValue=-360,
                               fieldMaxValue=360,
                               columnAttach3=('right', 'both', 'left'),
                               columnOffset3=(6, 0, 0))
    yDeg = cmds.floatSliderGrp(l='Y axis (deg):',
                               field=True,
                               minValue=-360,
                               maxValue=360,
                               fieldMinValue=-360,
                               fieldMaxValue=360,
                               columnAttach3=('right', 'both', 'left'),
                               columnOffset3=(6, 0, 0))
    zDeg = cmds.floatSliderGrp(l='Z axis (deg):',
                               field=True,
                               minValue=-360,
                               maxValue=360,
                               fieldMinValue=-360,
                               fieldMaxValue=360,
                               columnAttach3=('right', 'both', 'left'),
                               columnOffset3=(6, 0, 0))
    relativeOpt = cmds.checkBoxGrp(
        label='',
        numberOfCheckBoxes=1,
        label1='Relative',
        annotation="""When checked, add to or subtract from current seted values
   of X, Y or Z in 'Custom axis orientation.'""")

    cmds.separator(height=10, style='in')

    applyFor = cmds.checkBoxGrp(
        label='Apply for:',
        numberOfCheckBoxes=3,
        vertical=True,
        columnAttach2=('right', 'left'),
        columnOffset2=(6, 2),
        labelArray3=('Move', 'Rotate', 'Scale'),
        enable2=False)  # disable Rotate for the time being
    cmds.setParent(mainContainer)

    # BUTTONS SECTION
    form = cmds.formLayout(numberOfDivisions=100)

    def clickCmd(buttonValue):
        degToRad(xDeg, yDeg, zDeg, relativeOpt, applyFor)

    applyButton = cmds.button(l='Apply', height=26, c=clickCmd)

    closeCmd = 'cmds.deleteUI("%s", window=True)' % caoid
    closeButton = cmds.button(l='Close', height=26, c=closeCmd)

    cmds.formLayout(form,
                    edit=True,
                    attachForm=((applyButton, 'bottom', 0), (applyButton,
                                                             'left', 0),
                                (closeButton, 'bottom', 0), (closeButton,
                                                             'right', 0)),
                    attachPosition=((applyButton, 'right', 2, 50),
                                    (closeButton, 'left', 2, 50)))

    cmds.showWindow(caoid)
def setCustomAxisOrientation():
    '''
	TENTATIVE DE PATH DE L ISOLATE SELECTION ----
	
	#fix: isolateSelection   part1	
	viewSelectedSets = mc.ls( '*ViewSelectedSet' , type = 'objectSet' )
	isolatedObjs     = []
	panelName = ''
	
	for set in viewSelectedSets:
		isolatedObjs  = mc.sets( set , q = True )
		
		if( len(isolatedObjs) == 0 ):
		    continue
		 
		panelName = set.split( 'ViewSelectedSet' )[0]
		break
	#fix: isolateSelection   part1	
	
	'''

    selection = mc.ls(sl=True)
    locators = buildLocator.buildLocator()

    if (len(locators) > 1):
        mc.delete(locators)
        mc.error('marche pas avec plusieurs obj')

    rot = [0, 0, 0]
    rotRad = [0, 0, 0]

    rot[0] = mc.getAttr(locators[0] + '.rotateX')
    rot[1] = mc.getAttr(locators[0] + '.rotateY')
    rot[2] = mc.getAttr(locators[0] + '.rotateZ')

    rotRad[0] = math.radians(rot[0])
    rotRad[1] = math.radians(rot[1])
    rotRad[2] = math.radians(rot[2])

    mc.delete(locators)
    mc.select(selection)

    if (len(selection) == 0):
        return 0

    if ('.' in selection[0]):
        i = selection[0].index('.')
        selection[0] = selection[0][0:i]

    #changement orientation

    mel.eval('changeSelectMode -component;')
    mc.hilite(selection[0], r=True)

    mc.manipScaleContext('Scale', e=True, mode=6, orientAxes=rotRad)
    mc.manipRotateContext('Rotate', e=True, mode=3, orientAxes=rotRad)
    mc.manipMoveContext('Move', e=True, mode=6, orientAxes=rotRad)

    #fix gizmo au centre du monde
    mc.setToolTo('RotateSuperContext')
    mc.setToolTo('scaleSuperContext')
    mc.setToolTo('moveSuperContext')
    '''
	TENTATIVE DE PATH DE L ISOLATE SELECTION ----
		
	
	#fix: isolateSelection   part2	
	
	print( isolatedObjs )
	print( panelName )
	
	mc.refresh()

	if( len( isolatedObjs ) > 0 ):		
		mc.isolateSelect( panelName , s = False )
		for obj in isolatedObjs:
			mc.isolateSelect( panelName , ado = obj  )

	mc.isolateSelect( panelName , rdo = '|polySurface115.f[58]')
	mc.isolateSelect( panelName , u = True  )			
	mc.isolateSelect( panelName , s = True  )	
	
	'''

    #fix: scriptJob pour les changement de selection

    exec('maintainCustomOrientationSJW = scriptJobWindow()') in globals()
    exec('maintainCustomOrientationSJW.UI()') in globals()

    return 1
示例#17
0
def get_matrix():
    global SYM_AVOIDANCE
    global sb
    from . import sisidebar_main as sb
    #print '-------------get Matrix---------------- :'
    #print 'select obj :', cmds.ls(sl=True)
    #current_tool = cmds.currentCtx()
    #print 'current tool ;',  current_tool
    #cmds.setToolTo('selectSuperContext')
    #cmds.setToolTo(current_tool)
    if SYM_AVOIDANCE:
        SYM_AVOIDANCE = False
        return
    #ロックの有無をチェック
    try:
        sb.window.attribute_lock_state(mode=3, check_only=True)
    except Exception as e:
        print e.message
        pass
    try:  #2018up2以降の不具合対応
        sid = sb.space_group.checkedId()
    except Exception as e:
        print e.message
        return
    #一旦スケールX値をリセットしてメインウィンドウクラスに変更をお知らせする
    #sb.set_temp_text('change')
    sb.set_active_mute()
    scale = ['', '', '']
    rot = ['', '', '']
    trans = ['', '', '']
    if cmds.selectMode(q=True, o=True):
        selection = cmds.ls(sl=True, type='transform')
        if selection:
            try:
                s_list, r_list, t_list = get_srt(selection)
            except Exception as e:
                print e.message
                return
            #print 'get matrix :', s_list, r_list, t_list
            for i in range(3):
                s_list = [
                    map(lambda a: round(float(a), view_decimal), xyz)
                    for xyz in s_list
                ]
                r_list = [
                    map(lambda a: round(float(a), view_decimal), xyz)
                    for xyz in r_list
                ]
                t_list = [
                    map(lambda a: round(float(a), view_decimal), xyz)
                    for xyz in t_list
                ]
                if not all(s[i] == s_list[0][i] for s in s_list):
                    #print 'not same'
                    scale[i] = ''
                else:
                    #print 'same'
                    scale[i] = str(s_list[0][i])
                if not all(r[i] == r_list[0][i] for r in r_list):
                    #print 'not same', r_list
                    rot[i] = ''
                else:
                    #print 'same', r_list
                    rot[i] = str(r_list[0][i])
                if not all(t[i] == t_list[0][i] for t in t_list):
                    trans[i] = ''
                else:
                    trans[i] = str(t_list[0][i])
        #sb.check_key_anim()
        if np_flag:
            sb.view_np_time(culc_time='- Numpy Calculation Mode -')
        else:
            sb.view_np_time(culc_time='- Usual Calculation Mode -')
    selection = cmds.ls(sl=True, type='float3')
    #カーブもとっておく
    cv_selection = cmds.ls(sl=True, type='double3', fl=True)
    #print cv_selection
    if selection or cv_selection:
        #ラティスポイント他すべてを有効にする
        sel_str = str(selection + cv_selection)
        '''
        if '.vtx[' in sel_str:
            cmds.selectType(polymeshVertex=True)
            #cmds.selectType(particle=True)
        '''
        if '.cv[' in sel_str:
            cmds.selectType(cv=True)
            cmds.selectMode(co=True)
        if '.pt[' in sel_str:
            cmds.selectType(latticePoint=True)
            cmds.selectMode(co=True)
        #オブジェクトモードでもコンポーネント選択がある場合は強制的にモード変更する

        components = cmds.polyListComponentConversion(selection,
                                                      tv=True) + cv_selection
        #print components
        #if not components:
        s_list, r_list, t_list = get_srt(components, mode='component')
        start = dt.datetime.now()  #計測開始
        #マニプ情報取得に必要な情報を集める
        sym = cmds.symmetricModelling(q=True, symmetry=True)
        current_tool = cmds.currentCtx()
        tools_list = [
            'scaleSuperContext', 'RotateSuperContext', 'moveSuperContext'
        ]
        if sym:
            axis_list = ['x', 'y', 'z']
            sym_axis = cmds.symmetricModelling(q=True, ax=True)
            axis_id = axis_list.index(sym_axis)
            meshes = cmds.ls(hl=True, l=True)
            #マニプが有効でない場合はシンメトリ座標を取得できないので自前計算
            if not current_tool in tools_list:
                for i, value in enumerate(t_list):
                    if i % 3 == axis_id:
                        value = math.sqrt(value**2)
                        t_list[i] = value

        if np_flag:
            #print 'culc in numpy'
            s_list = np.reshape(s_list, (len(s_list) / 3, 3))
            scale = np.average(s_list, axis=0).tolist()
            r_list = np.reshape(r_list, (len(r_list) / 3, 3))
            rot = np.average(r_list, axis=0).tolist()
            t_list = np.reshape(t_list, (len(t_list) / 3, 3))
            trans = np.average(t_list, axis=0).tolist()
        else:
            #print 'culc in math'
            srt_list = [0, 0, 0, 0, 0, 0, 0, 0, 0]
            for i in range(0, len(s_list), 3):
                srt_list[0] += s_list[i + 0]
                srt_list[1] += s_list[i + 1]
                srt_list[2] += s_list[i + 2]
            scale = map(lambda a: a / (len(s_list) / 3), srt_list[0:3])
            for i in range(0, len(r_list), 3):
                srt_list[3] += r_list[i + 0]
                srt_list[4] += r_list[i + 1]
                srt_list[5] += r_list[i + 2]
            rot = map(lambda a: a / (len(r_list) / 3), srt_list[3:6])
            for i in range(0, len(t_list), 3):
                srt_list[6] += t_list[i + 0]
                srt_list[7] += t_list[i + 1]
                srt_list[8] += t_list[i + 2]
            trans = map(lambda a: a / (len(t_list) / 3), srt_list[6:9])
        #シンメトリのときとワールド座標の場合の処理
        #ワールド空間のときもMayaのマニピュレータ位置とあわせる
        if sym or sid == 0 or sid == 4:
            if current_tool in tools_list:
                if current_tool == 'moveSuperContext':
                    trans = cmds.manipMoveContext('Move', q=True, p=True)
                elif current_tool == 'RotateSuperContext':
                    trans = cmds.manipRotateContext('Rotate', q=True, p=True)
                elif current_tool == 'scaleSuperContext':
                    trans = cmds.manipScaleContext('Scale', q=True, p=True)
                #ワールド空間でない且つ選択オブジェクトが1つの場合はマトリクス計算で座標を求める
                if sid != 0 and sid != 4 and len(meshes) == 1:
                    scale = cmds.xform(meshes[0], q=True, s=True, ws=True)
                    #scale = [1.0]*3
                    if len(meshes) == 1:
                        pos = trans + [1]  #行列掛けるようの位置配列、末尾に1つけとく
                        if np_flag:
                            #マトリクス計算で座標求める
                            matrix = cmds.xform(meshes[0],
                                                q=True,
                                                m=True,
                                                ws=True)
                            matrix = np.reshape(matrix, (4, 4))
                            rev_matrix = np.linalg.inv(matrix)  #逆行列
                            #print 'get mesh matrix :', matrix, meshes[0]
                            #print 'get rev matrix np:', rev_matrix
                            mul_matrix_trans = np.dot(pos, matrix)
                            mul_rev_matrix_trans = np.dot(pos, rev_matrix)
                            #print 'mul matrix :', mul_matrix_trans
                            #print 'mul rev matrix :', mul_rev_matrix_trans
                            trans = scale * mul_rev_matrix_trans[:3]
                            #print 'Local trans np:', trans
                        else:  #Numpy使わない処理
                            matrix = cmds.xform(meshes[0],
                                                q=True,
                                                m=True,
                                                ws=True)
                            rev_matrix = pm.ls(
                                meshes[0])[0].transformationMatrix().inverse()
                            #print 'get rev matrix :', rev_matrix
                            pos = [pos]  #行列掛けるようの位置配列、末尾に1つけとく
                            #print matrix
                            #print rev_matrix
                            mul_rev_matrix_trans = mm.dot(pos, rev_matrix)[0]
                            #print mul_rev_matrix_trans
                            trans = mm.mul(mul_rev_matrix_trans[:3], scale)
                        #print 'Local trans :', trans
                    #print 'sym pos :',  trans, meshes, sid
        #print 'trans :', trans
        end = dt.datetime.now()
        culc_time = end - start
        sb.view_np_time(culc_time='Culc Time ' + str(culc_time))
        #表示桁数を調整する
    try:
        scale = map(lambda a: round(float(a), view_decimal)
                    if a != '' else '', scale)
        rot = map(lambda a: round(float(a), view_decimal)
                  if a != '' else '', rot)
        trans = map(lambda a: round(float(a), view_decimal)
                    if a != '' else '', trans)
        #念のため0のマイナス符号を除去、main側のセットでもやってるんで一旦ミュート
        #print rot
        #scale = map(lambda a : float(str(a).replace('-0.0', '0.0')) if a=='-0.0' else a, scale)
        #rot = map(lambda a : float(str(a).replace('-0.0', '0.0')) if a=='-0.0' else a, rot)
        #trans = map(lambda a : float(str(a).replace('-0.0', '0.0')) if a=='-0.0' else a, trans)
        #print rot
        sb.set_pre_transform(trans, rot, scale)
        sb.set_srt_text(scale, rot, trans)
    except:
        sb.set_pre_transform(trans, rot, scale)
        sb.set_srt_text(scale, rot, trans)
示例#18
0
文件: MocBox.py 项目: Mocson/MocBox
def wrd():
    cmds.manipMoveContext("Move", e=True, m=2)
    cmds.manipScaleContext("Scale", e=True, m=2)
    cmds.manipRotateContext("Rotate", e=True, m=1)
示例#19
0
def bakePivot(ob, pos=1, ori=1):
    currentCtx = mc.currentCtx()
    contextList = [
        "moveSuperContext", "manipMoveContext", "RotateSuperContext",
        "manipRotateContext", "scaleSuperContext", "manipScaleContext"
    ]

    if currentCtx not in contextList:
        mc.error("m_bakeCustomToolPivot.kWrongToolError")
        return None

    # Check 3) must be in custom orientation mode
    customOri = []
    pivotModeActive = 0
    customModeActive = 0
    if currentCtx == "moveSuperContext" or currentCtx == "manipMoveContext":
        customOri = mc.manipMoveContext('Move', q=1, orientAxes=1)
        pivotModeActive = mc.manipMoveContext('Move', q=1, editPivotMode=1)
        customModeActive = mc.manipMoveContext('Move', q=1, mode=1) / 6
    elif (
        currentCtx == "RotateSuperContext"
        or currentCtx == "manipRotateContext"
    ):
        customOri = mc.manipRotateContext('Rotate', q=1, orientAxes=1)
        pivotModeActive = mc.manipRotateContext('Rotate', q=1, editPivotMode=1)
        customModeActive = mc.manipRotateContext('Rotate', q=1, mode=1) / 3
    elif (
        currentCtx == "scaleSuperContext" or currentCtx == "manipScaleContext"
    ):
        customOri = mc.manipScaleContext('Scale', q=1, orientAxes=1)
        pivotModeActive = mc.manipScaleContext('Scale', q=1, editPivotMode=1)
        customModeActive = mc.manipScaleContext('Scale', q=1, mode=1) / 6

    if ori and not pos and not customModeActive:
        mc.error("m_bakeCustomToolPivot.kWrongAxisOriModeError")
        return None

    # Get custom orientation
    if ori and customModeActive:
        customOri[0] = mel.eval('rad_to_deg({})'.format(customOri[0]))
        customOri[1] = mel.eval('rad_to_deg({})'.format(customOri[1]))
        customOri[2] = mel.eval('rad_to_deg({})'.format(customOri[2]))
        # Set object(s) rotation to the custom one
        # (preserving child transform positions and geometry positions)
        mc.rotate(
            customOri[0], customOri[1], customOri[2],
            ob, a=1, pcp=1, pgp=1, ws=1, fo=1
        )

    if pos:
        # Get pivot in parent space
        # object = 'pSphere4'
        old = [0, 0, 0]
        m = mc.xform(ob, q=1, m=1)
        p = mc.xform(ob, q=1, os=1, sp=1)
        old[0] = (p[0] * m[0] + p[1] * m[4] + p[2] * m[8] + m[12])
        old[1] = (p[0] * m[1] + p[1] * m[5] + p[2] * m[9] + m[13])
        old[2] = (p[0] * m[2] + p[1] * m[6] + p[2] * m[10] + m[14])

        # Zero out pivots
        mc.xform(ob, zeroTransformPivots=1)

        # Translate object(s) back to previous pivot
        # (preserving child transform positions and geometry positions)
        new = mc.getAttr(ob + ".translate")[0]
        mc.move(
            (old[0] - new[0]),
            (old[1] - new[1]),
            (old[2] - new[2]),
            ob, pcp=1, pgp=1, ls=1, r=1
        )

    # Exit pivot mode
    if pivotModeActive:
        mel.eval('ctxEditMode;')

    # Set the axis orientation mode back to object
    if ori and customModeActive:
        if (
            currentCtx == "moveSuperContext"
            or currentCtx == "manipMoveContext"
        ):
            mc.manipMoveContext('Move', e=1, mode=0)
        elif (
            currentCtx == "RotateSuperContext"
            or currentCtx == "manipRotateContext"
        ):
            mc.manipRotateContext('Rotate', e=True, mode=0)
        elif (
            currentCtx == "scaleSuperContext"
            or currentCtx == "manipScaleContext"
        ):
            mc.manipScaleContext('Scale', e=1, mode=0)
示例#20
0
    def _testMultiSelectScaleUSD(self):
        '''Scale multiple USD objects, read through Transform3d interface.'''

        # Select multiple balls to scale them.
        proxyShapePathSegment = mayaUtils.createUfePathSegment(
            "|world|transform1|proxyShape1")

        # Test passes for a single item.
        # balls = ['Ball_33']
        balls = ['Ball_33', 'Ball_34']
        ballPaths = [
            ufe.Path([
                proxyShapePathSegment,
                usdUtils.createUfePathSegment('/Room_set/Props/' + ball)
            ]) for ball in balls
        ]
        ballItems = [
            ufe.Hierarchy.createItem(ballPath) for ballPath in ballPaths
        ]

        for ballItem in ballItems:
            ufe.GlobalSelection.get().append(ballItem)

        # We compare the UFE scale with the USD run-time scale.  To
        # obtain the full scale of USD scene items, we need to add the USD
        # scale to the Maya proxy shape scale.
        proxyShapeXformObj = om.MSelectionList().add('transform1').getDagPath(
            0).node()
        proxyShapeXformFn = om.MFnTransform(proxyShapeXformObj)

        def usdSceneItemScale(item):
            prim = usdUtils.getPrimFromSceneItem(ball35Item)
            if not prim.HasAttribute('xformOp:scale'):
                return proxyShapeXformFn.scale()
            else:
                return combineScales(proxyShapeXformFn.scale(),
                                     prim.GetAttribute('xformOp:scale').Get())

        def ufeSceneItemScale(item):
            return transform3dScale(ufe.Transform3d.transform3d(item))

        # Set up the callables that will retrieve the scale.
        self.runTimeScale = usdSceneItemScale
        self.ufeScale = ufeSceneItemScale

        # Give the tail item in the selection an initial scale that
        # is different, to catch bugs where the relative scale
        # incorrectly squashes any existing scale.
        backItem = ballItems[-1]
        backT3d = ufe.Transform3d.transform3d(backItem)
        initialScale = [1.1, 2.2, 3.3]
        backT3d.scale(*initialScale)
        self.assertVectorAlmostEqual(initialScale, usdSceneItemScale(backItem))

        # Save the initial positions to the memento list.
        expected = [usdSceneItemScale(ballItem) for ballItem in ballItems]

        # MAYA-96058: unfortunately, scale command currently requires a scale
        # manipulator to be created to update the UFE object.
        manipCtx = cmds.manipScaleContext()
        cmds.setToolTo(manipCtx)

        #Temporarily disabling undo redo until we fix it for PR 94
        self.runMultiSelectTestScale(ballItems, expected)
示例#21
0
def resetPivot(pivot):
    if pivot == "move":
        cmds.manipMoveContext("Move", edit=True, mode=2, orientAxes=[0.0, 0.0, 0.0])
    else:
        cmds.manipScaleContext("Scale", edit=True, mode=0, orientAxes=[0.0, 0.0, 0.0])
示例#22
0
def set_reference(mode=''):
    c_ctx = cmds.currentCtx(q=True)
    #print c_ctx
    sel = cmds.ls(sl=True, l=True)
    #print 'set reference :', mode, sel
    current_ctx = cmds.currentCtx()
    if mode == 'object':
        #print 'set reference object mode :'
        cmds.selectMode(o=True)
        rot = cmds.xform(sel, q=True, ro=True, ws=True)
        pos = cmds.xform(sel, q=True, t=True, ws=True)
        rx = rot[0] / 180 * math.pi
        ry = rot[1] / 180 * math.pi
        rz = rot[2] / 180 * math.pi
        cmds.manipScaleContext('Scale', e=True, orientAxes=(rx, ry, rz))
        cmds.manipRotateContext('Rotate', e=True, orientAxes=(rx, ry, rz))
        cmds.manipMoveContext('Move', e=True, orientAxes=(rx, ry, rz))

        cmds.setToolTo('scaleSuperContext')  #マニプ表示がおかしくなるのでいったんコンテキスト設定してから戻す
        cmds.setToolTo('RotateSuperContext')
        cmds.setToolTo('moveSuperContext')
        cmds.setToolTo(current_ctx)
    else:
        if mode == 'vertex':
            manip_type = 'PointHandleTowards'
            comp = cmds.polyListComponentConversion(sel, tv=True)
            comp = cmds.filterExpand(comp, sm=31)
            sel_node = '" , "'.join(pre_sel)
            #print 'vertex ref :', sel_node, comp[0]
        if mode == 'edge':
            manip_type = 'AlignHandleWith'
            comp = cmds.polyListComponentConversion(sel, te=True)
            comp = cmds.filterExpand(comp, sm=32)
            sel_node = comp[0]
        if mode == 'face':
            manip_type = 'AlignHandleWith'
            comp = cmds.polyListComponentConversion(sel, tf=True)
            comp = cmds.filterExpand(comp, sm=34)
            sel_node = comp[0]
        if comp:
            mel.eval('manipScaleOrient 5;')
            mel.eval('{  string $Selection1[]; $Selection1[0] = "' + comp[0] +
                     '"; manipScale' + manip_type + '($Selection1[0], {"' +
                     sel_node + '"}, {}, "", 0);;  };')
            mel.eval('manipRotateOrient 5;')
            mel.eval('{  string $Selection1[]; $Selection1[0] = "' + comp[0] +
                     '"; manipRotate' + manip_type + '($Selection1[0], {"' +
                     sel_node + '"}, {}, "", 0);;  };')
            mel.eval('manipMoveOrient 5;')
            mel.eval('{  string $Selection1[]; $Selection1[0] = "' + comp[0] +
                     '"; manipMove' + manip_type + '($Selection1[0], {"' +
                     sel_node + '"}, {}, "", 0);;  };')
        cmds.selectMode(co=True)
        if pre_ref_mode == 'vertex':
            cmds.selectType(pv=1,
                            smu=0,
                            smp=1,
                            pf=0,
                            pe=0,
                            smf=0,
                            sme=0,
                            puv=0)
        if pre_ref_mode == 'edge':
            cmds.selectType(pv=0,
                            smu=0,
                            smp=0,
                            pf=0,
                            pe=1,
                            smf=0,
                            sme=1,
                            puv=0)
        if pre_ref_mode == 'face':
            cmds.selectType(pv=0,
                            smu=0,
                            smp=0,
                            pf=1,
                            pe=0,
                            smf=0,
                            sme=1,
                            puv=0)
        trans = cmds.xform(sel, q=True, t=True, ws=True)
        num = len(trans) / 3
        x = y = z = 0
        for i in range(0, len(trans), 3):
            x += trans[i]
            y += trans[i + 1]
            z += trans[i + 2]
        pos = [x / num, y / num, z / num]
        #sel_obj = []
        #obj_list = list(set([vtx.split('.')[0] for vtx in pre_sel]))
        #if obj_list:
        #sel_obj = [cmds.listRelatives(s, p=True)[0] if cmds.nodeType(s)=='mesh' else s for s in obj_list]
        #print obj_list, pre_sel
        #cmds.hilite(obj_list, r=True)
        #cmds.hilite(pre_sel, r=True)
    #print 'set to pre mode :', pre_ref_mode
    #print 'set to mode pre :', pre_ref_mode
    if pre_ref_mode == 'object':
        cmds.selectMode(o=True)
    else:
        cmds.selectMode(co=True)
        if pre_obj_list:
            cmds.hilite(pre_obj_list, r=True)
    if pre_sel:
        cmds.select(pre_sel, r=True)
    else:
        cmds.select(cl=True)
    sb.after_pick_context(ctx=c_ctx)
    #移動マニプを選択の中心に移動する
    cmds.manipPivot(p=pos)
示例#23
0
文件: MocBox.py 项目: Mocson/MocBox
def lcl():
    cmds.manipMoveContext("Move", e=True, m=0)
    cmds.manipScaleContext("Scale", e=True, m=0)
    cmds.manipRotateContext("Rotate", e=True, m=0)