Example #1
0
 def __init__(self):
     self.name = "pythant"
     self.title = "Pythant"
     #creates the ui window, replacing any existing ui windows
     if (cmds.window(self.name, q=1, exists=1)):
         cmds.deleteUI(self.name)
     self.window = cmds.window(self.name, title=self.title)
     self.form = cmds.columnLayout(adjustableColumn=True, columnAlign="center", rowSpacing=10)
     cmds.intFieldGrp("numAnts", label="Number of ants:", value1=1, cal=[1,"left"])
     cmds.intFieldGrp("startFrame", label="Start frame:", value1=1, nf=1,cal=[1,"left"])
     cmds.intFieldGrp("endFrame", label="End frame:",nf=1,value1=50,cal=[1,"left"])
     cmds.text( label="Select the curves:",align="left")
     cmds.textScrollList("curves",numberOfRows=3,allowMultiSelection=True,h=100)
     cmds.button(label="OK",w=20, align="left",c=self.getCurves)
     cmds.textFieldButtonGrp("groundObj", label="Select the Ground:",buttonLabel='OK', bc=self.getGround,cal=[1,"left"])
     cmds.checkBox("isFlat",label="Is this a flat ground",value=1)        
     cmds.floatSliderGrp("Velocity",field=True, label="Velocity (mm/s):",min=1, max=40,value=20, cal=[1,"left"])        
     #cmds.floatSliderGrp("strideFreq",field=True, label="Stride Frequency:",min=1, max=10,value=5, cal=[1,"left"])        
     cmds.floatSliderGrp("load",field=True, label="Load (mg):",min=0, max=4,value=0, cal=[1,"left"])        
     # cmds.textFieldButtonGrp("force", label="External Force", buttonLabel='OK', bc = self.getForce, cal=[1, "left"])        
     cmds.text( label='The external force is setup with a directional light named forceVector.')
     cmds.text( label='The force magnitude (N) is specified with the custom attribute "Force Magnitude".') 
     cmds.text(label='The lighting direction is the force direction.')
     cmds.button(label='Run', w=100, c=self.accept)        
     cmds.button(label='Reset', w=100, c=self.reset)
     
     
     
     cmds.showWindow(self.window)
     cmds.window(self.window, edit = True, widthHeight=(415, 580))        
Example #2
0
def defaultButtonPush(args):
    '''
    Calls the procedure cityGenerator.city(...) with the user specified 
    arguments.
    
    args: Dummy argument needed to satisfy the command interface.
    On exit: The cityGenerator.city(...) procedure has been called with
             the arguments specified by the user. 
    '''
    Name_ = cmds.textField("cityName", query = True, text = True)
    if Name_ == "":
        Name_ = "Helsinki"
    cityWidth = cmds.intSliderGrp("cityWidth", query = True, value = True)
    cityDepth = cmds.intSliderGrp("cityDepth", query = True, value = True)
    minHeight = cmds.intSliderGrp("minHeight", query = True, value = True)
    maxHeight = cmds.intSliderGrp("maxHeight", query = True, value = True)
    minWidth = cmds.intSliderGrp("minWidth", query = True, value = True)
    maxWidth = cmds.intSliderGrp("maxWidth", query = True, value = True)
    windows = cmds.checkBoxGrp("features", query = True, v1 = True)
    booleans = cmds.checkBoxGrp("features", query = True, v2 = True)
    deformers = cmds.checkBoxGrp("features", query = True, v3 = True)
    dayTime = cmds.checkBoxGrp("time", query = True, v1=True)
    glow = cmds.checkBoxGrp("time", query = True, v3=True)
    environment = cmds.colorSliderGrp("environment", query = True, rgbValue = True)
    colourRangeStart = (cmds.intSliderGrp("hue1", query = True, value = True),
    cmds.floatSliderGrp("saturation1", query = True, value = True), 
    cmds.floatSliderGrp("value1", query = True, value = True))
    colourRangeEnd = (cmds.intSliderGrp("hue2", query = True, value = True),
    cmds.floatSliderGrp("saturation2", query = True, value = True), 
    cmds.floatSliderGrp("value2", query = True, value = True))
    cityGenerator.city(Name_, (cityWidth,cityDepth),(minHeight,maxHeight),
    (minWidth,maxWidth), windows, booleans, deformers, dayTime, glow, environment,(colourRangeStart,colourRangeEnd))    
Example #3
0
def ruMainWindow():
	ruWin = "riggUtils"
	if mc.window(ruWin,q=True,ex=True):
		mc.deleteUI(ruWin)

	mc.window(ruWin,title = "Rigging Utilities")
	mc.scrollLayout(horizontalScrollBarThickness=16)
	ruMainColumn = mc.columnLayout(columnAttach=("both",5),rowSpacing=10,columnWidth=320)
	mc.frameLayout(label="General",bs="etchedOut",w=300,mw=5,cll=1)
	mc.button(label='Show Axis',command='mc.toggle(state=True, localAxis=True)')
	mc.button(label='Hide Axis',command='mc.toggle(state=False, localAxis=True)')
		
	mc.frameLayout(label="Non T-Pose joint placer",bs="etchedOut",w=300,mw=5,cll=1,p=ruMainColumn)
	mc.columnLayout(rs=5,adj=1)
	mc.button(l="Create Helper Locator",c =ruCreateLocator)
	mc.button(l="Create Joint on Helper Locator",c =ruCreateJointLocator)
	mc.floatSliderGrp("ruJointRadius",en=1,label="Joint Radius",field=True,minValue=0,maxValue=5,fieldMinValue=0,fieldMaxValue=5,value=0.5,cw3=(70,30,10),dc=ruJointRadius)
	
	mc.frameLayout(label="Fingers Utils",bs="etchedOut",w=300,mw=5,cll=1,p=ruMainColumn)
	mc.columnLayout(rs=5,adj=1)
	mc.floatSliderGrp("ruJointOrientation",en=1,label="Finger Orient",field=True,minValue=0,maxValue=5,fieldMinValue=0,fieldMaxValue=5,value=0.5,cw3=(70,30,10),dc=ruOrientJoint)
	mc.frameLayout(label="Finger Renaming",bs="etchedOut",w=300,mw=5,cll=1)
	mc.optionMenu('ruFinger',l='Choose finger')
	mc.menuItem(l='Thumb')
	mc.menuItem(l='Index')
	mc.menuItem(l='Middle')
	mc.menuItem(l='Ring')
	mc.menuItem(l='Pinky')
	mc.textFieldButtonGrp( label='Template string', text='', buttonLabel='Rename', bc=ruRenameFinger, cw3=[120,70,70],ct3=['left','left','left'],co3=[2,2,2] )
	
	mc.showWindow(ruWin)
Example #4
0
 def prefPut(self):
     cmds.checkBox(self.c2, e=True, v=self.prefs['BkRmvCon'])
     cmds.checkBox(self.c3, e=True, v=self.prefs['BkTmRng'])
     cmds.checkBox(self.c4, e=True, v=self.prefs['BkAllFrms'])
     cmds.checkBox(self.c7, e=True, v=self.prefs['LocTrns'])
     cmds.checkBox(self.c8, e=True, v=self.prefs['LocRot'])
     cmds.checkBox(self.c12, e=True, v=self.prefs['LocAllFrms'])
     cmds.checkBox(self.c17, e=True, v=self.prefs['PrntRgPosOnly'])
     cmds.checkBox(self.c15, e=True, v=self.prefs['AimRgNegAim'])
     cmds.radioButtonGrp(self.aimGrp, e=True, select=self.prefs['AimRgAim'])
     cmds.checkBox(self.c16, e=True, v=self.prefs['AimRgNegUp'])
     cmds.radioButtonGrp(self.upGrp, e=True, select=self.prefs['AimRgUp'])
     cmds.checkBox(self.c18, e=True, v=self.prefs['PvtRgNegAim'])
     cmds.radioButtonGrp(self.aimPivotGrp, e=True, select=self.prefs['PvtRgAim'])
     cmds.checkBox(self.c19, e=True, v=self.prefs['PvtRgNegUp'])
     cmds.radioButtonGrp(self.upPivotGrp, e=True, select=self.prefs['PvtRgUp'])
     cmds.checkBox(self.c21, e=True, v=self.prefs['PvtRgMstr'])
     cmds.radioButtonGrp(self.masterGrp, e=True, select=self.prefs['PvtRgMstrSl'])
     cmds.radioButtonGrp(self.masterGrp, e=True, en=self.prefs['PvtRgMstrEnbl'])
     cmds.checkBox(self.c22, e=True, v=self.prefs['PvtRgAutoDstnc'])
     cmds.floatSliderGrp(self.sl1, e=True, v=self.prefs['PvtRgDstnc'])
     cmds.floatSliderGrp(self.sl1, e=True, en=self.prefs['PvtRgDstncEnbl'])
     cmds.checkBox(self.c21, e=True, v=self.prefs['LcAllFrms'])
     cmds.checkBox(self.c5, e=True, v=self.prefs['PlcCon'])
     cmds.radioButtonGrp(self.conGrp, e=True, select=self.prefs['PlcConTo'])
     cmds.radioButtonGrp(self.conGrp, e=True, en=self.prefs['PlcConToEnbl'])
     cmds.checkBox(self.c13, e=True, v=self.prefs['PlcMtchKys'])
     cmds.checkBox(self.c9, e=True, v=self.prefs['ConOffst'])
     cmds.checkBox(self.c10, e=True, v=self.prefs['ConTrns'])
     cmds.checkBox(self.c11, e=True, v=self.prefs['ConRot'])
     cmds.intField(self.actionField1, e=True, v=self.prefs['DstKys'])
     cmds.checkBox(self.c14, e=True, v=self.prefs['DstKysDstrct'])
     cmds.floatFieldGrp(self.floatGroup1, e=True, v=self.prefs['ObjctSpaceOffst'])
Example #5
0
def get_ui_values():
    global engine_path, folder, file_name, export_batch, resolution_x, resolution_y, exposure, gamma, \
        ray_number, time, seed, export_animation, start_frame, end_frame, export_normals, invert_normals, check_Z, materials
        
    engine_path = cmds.textFieldButtonGrp(engine_field, query=True, text=True)
    folder = cmds.textFieldButtonGrp(directory_field, query=True, text=True)
    file_name = cmds.textFieldGrp(file_field, query=True, text=True)
    
    export_batch = cmds.checkBoxGrp(batch_field, query=True, value1=True)
    
    resolution_x = cmds.intFieldGrp(resolution_field, query=True, value1=True)
    resolution_y = cmds.intFieldGrp(resolution_field, query=True, value2=True)
    exposure = cmds.floatSliderGrp(exposure_field, query=True, value=True)
    gamma = cmds.floatSliderGrp(gamma_field, query=True, value = True)
    ray_number = cmds.intSliderGrp(rays_field, query=True, value=True)
    seed = cmds.intSliderGrp(seed_field, query=True, value=True)
    time = cmds.intSliderGrp(time_field, query=True, value=True)
    export_animation = cmds.checkBoxGrp(animation_field, query=True, value1=True)
    start_frame =  cmds.intFieldGrp(frame_range_field, query=True, value1=True)
    end_frame =  cmds.intFieldGrp(frame_range_field, query=True, value2=True)
    export_normals = cmds.checkBoxGrp(normals_export_field, query=True, value1=True)
    invert_normals = cmds.checkBoxGrp(normals_invert_field, query=True, value1=True)
    check_Z = cmds.checkBoxGrp(check_Z_field, query = True, value1=True)
    
    materials = []
    for mat in range(5):
        materials.append(cmds.floatFieldGrp(eval('material_%i_field' % (mat)), query=True, value=True))
def activateBlendshapes_window():
	"""
	This definition creates the 'Activate Blendshapes' main window.
	"""

	cmds.windowPref(enableAll=False)

	if (cmds.window("activateBlendshapes_window", exists=True)):
		cmds.deleteUI("activateBlendshapes_window")

	cmds.window("activateBlendshapes_window",
		title="Activate Blendshapes",
		width=320)

	spacing = 5

	cmds.columnLayout(adjustableColumn=True, rowSpacing=spacing)

	cmds.separator(height=10, style="singleDash")

	cmds.floatSliderGrp("weight_floatSliderGrp", label="Weight", field=True, minValue=0, maxValue=1, fieldMinValue=0, fieldMaxValue=1, sliderStep=0.01, value=0, changeCommand=weight_floatSliderGrp_OnValueChanged, dragCommand=weight_floatSliderGrp_OnValueChanged)

	cmds.separator(height=10, style="singleDash")

	cmds.showWindow("activateBlendshapes_window")

	cmds.windowPref(enableAll=True)
Example #7
0
def stretchyIkSplineFromUI(close=False):
	'''
	'''
	# Window
	window = 'stretchyIkSplineUI'
	if not mc.window(window,q=True,ex=1): raise UIError('StretchyIkSpline UI does not exist!!')
	
	# Get UI data
	ik = mc.textFieldButtonGrp('stretchyIkSplineTFB',q=True,text=True)
	pre = mc.textFieldGrp('stretchyIkSplinePrefixTFG',q=True,text=True)
	scaleAxis = str.lower(str(mc.optionMenuGrp('stretchyIkSplineAxisOMG',q=True,v=True)))
	scaleAttr = mc.textFieldButtonGrp('stretchyIkSplineScaleAttrTFB',q=True,text=True)
	blendCtrl = mc.textFieldButtonGrp('stretchyIkSplineBlendCtrlTFB',q=True,text=True)
	blendAttr = mc.textFieldGrp('stretchyIkSplineBlendAttrTFG',q=True,text=True)
	method = mc.optionMenuGrp('stretchyIkSplineMethodOMG',q=True,sl=True)-1
	minPercent = mc.floatSliderGrp('stretchyIkSplineMinPFSG',q=True,v=True)
	maxPercent = mc.floatSliderGrp('stretchyIkSplineMaxPFSG',q=True,v=True)
	
	# Execute command
	if method: # Parametric
		glTools.builder.stretchyIkSpline_parametric.StretchyIkSpline_parametric().build(ikHandle=ik,scaleAttr=scaleAttr,blendControl=blendCtrl,blendAttr=blendAttr,scaleAxis=scaleAxis,minPercent=minPercent,maxPercent=maxPercent,prefix=pre)
	else: # Arc Length
		glTools.builder.stretchyIkSpline_arcLength.StretchyIkSpline_arcLength().build(ikHandle=ik,scaleAttr=scaleAttr,blendControl=blendCtrl,blendAttr=blendAttr,scaleAxis=scaleAxis,prefix=pre)
	
	# Cleanup
	if close: mc.deleteUI(window)
Example #8
0
def bdMainWindow():
	bdWin = "CreateSkeleton"
	if cmds.window(bdWin,q=True,ex=True):
		cmds.deleteUI(bdWin)

	cmds.window(bdWin,title = "Create Skeleton")
	cmds.scrollLayout(horizontalScrollBarThickness=16)
	bdMainCL = cmds.columnLayout(columnAttach=("both",5),rowSpacing=10,columnWidth=320)
	#GUIDES CREATION
	bdFL1 = cmds.frameLayout(label="Template Guides",bs="etchedOut",w=300,mw=5,cll=1,p=bdMainCL)
	bdCL1= cmds.columnLayout(rs=5,adj=1,p=bdFL1)
	#Character Name
	cmds.textFieldGrp("bdChName",l="Character Name",tx="")
	#Number of Fingers/Toes
	#cmds.intSliderGrp("bdFingersNumber",label="Number of Fingers",field=True,minValue=1,maxValue=5,fieldMinValue=1,fieldMaxValue=5,value=4,cw3=(100,30,10),dc=bdSetFingersNumber)
	#cmds.checkBoxGrp("bdHasThumb",numberOfCheckBoxes=1, label='Thumb?')
	#cmds.intSliderGrp("bdToesNumber",label="Number of Toes",field=True,minValue=1,maxValue=5,fieldMinValue=1,fieldMaxValue=5,value=4,cw3=(100,30,10),dc=bdSetToesNumber)
	cmds.button(l="Import Template",c=bdImportTemplate)
	#Character Scale Slider
	cmds.floatSliderGrp("bdScaleSlider",en=0,label="Guide scale",field=True,minValue=1,maxValue=100,fieldMinValue=1,fieldMaxValue=100,value=1,cw3=(70,30,10),dc=bdScaleGuides)
	#Character Mirror
	cmds.rowColumnLayout(nc=2,cw=[(1,138),(2,138)],p=bdCL1);
	cmds.button(l="Mirror left << ",al="right",c = functools.partial(bdMirrorGuide,"left"))
	cmds.button(l=">> Mirror right",al="left",c = functools.partial(bdMirrorGuide,"right"));
	#END GUIDES CREATION
	
	#JOINTS CREATION
	bdFL2 = cmds.frameLayout(label="Create Joints",bs="etchedOut",w=300,mw=5,cll=1,p=bdMainCL)
	bdCL2 = cmds.columnLayout(rs=5,adj=1,p=bdFL2)
	cmds.button(l="Create Joints",c =bdCreateSkeleton)
	#floatSliderGrp -en 0 -label "THUMB Orient" -field true	-minValue 0 -maxValue 180 -fieldMinValue 1 -fieldMaxValue 100	-value 0 -cw3 80 40 10 -dc bdJointOrientX bdJointXSlider;
	#END JOINTS CREATION
	
	cmds.showWindow(bdWin)
Example #9
0
	def init(self):
		window = c.window(title='WeatherViz',widthHeight=(400,600));
		#form = c.formLayout(numberOfDivisions=100);
		c.rowColumnLayout(numberOfColumns=1);
		c.checkBoxGrp('weatherPanel', label='Weather');
		c.checkBox('snowCheck', label='Snow', onc=self.snow.init, ofc=self.snow.remove, p='weatherPanel');
		c.checkBox('rainCheck', label='Rain', onc=self.rain.init, ofc=self.rain.remove, p='weatherPanel');
		c.checkBox('windCheck', label='Wind', onc=self.wind.init, ofc=self.wind.remove, p='weatherPanel');
		c.button('collButton', label='Add collision', c=self.addCollision);


		#s1 = c.floatSliderGrp('snowTurb',label='Snow turbulence', field=True, value=5, dc=self.slider_drag_callback, min=0, max=10);
		c.floatSliderGrp('snowIntens',label='Snow Intencity', field=True, value=200, dc=self.slider_drag_callback, min=0, max=1000, en=False);
		c.floatSliderGrp('rainIntens',label='Rain Intencity', field=True, value=200, dc=self.slider_drag_callback, min=0, max=1000, en=False);
		c.floatSliderGrp('snowTurbSlider',label='Turbulence', field=True, value=1, dc=self.slider_drag_callback, min=0, max=100, en=False);
		c.floatSliderGrp('airMSlider',label='Wind Magnitude', field=True, value=30, dc=self.slider_drag_callback, min=0, max=100, en=False);
		c.floatSliderGrp('airMxdSlider',label='Wind Distance', field=True, value=20, dc=self.slider_drag_callback, min=0, max=100, en=False);
		#c.formLayout(form, edit=True, attachPosition=[(s1, 'top', 20, 1)]);
		#c.formLayout(form, edit=True, attachPosition=[(s2, 'top', 20, 1)]);
		
		c.textField("WeatherViz_HDR_Path_textField", cc=_WeatherViz_HDR_Path_textField__changeCommand)
		c.button("WeatherViz_HDR_Path_button", label="...", al="center", command=_WeatherViz_HDR_Path_button__command)
		
		WeatherViz_HDR_Path = c.optionVar(q="WeatherViz_HDR_Path")
		if WeatherViz_HDR_Path:
			c.textField("WeatherViz_HDR_Path_textField", edit=True, text=WeatherViz_HDR_Path)
			
		c.showWindow(window);
		c.windowPref(enableAll=True)
Example #10
0
 def accept(self, *args):        
     numAnts = int(cmds.intFieldGrp("numAnts",query=True,value=True)[0])                    
     startFrame = int(cmds.intFieldGrp("startFrame",query=True,value=True)[0])                    
     endFrame = int(cmds.intFieldGrp("endFrame",query=True,value=True)[0])                    
     
     curves = cmds.textScrollList("curves",q=True,ai=True)
     if curves == None:
         curves = ["curve1"]
     isFlat = cmds.checkBox("isFlat", query = True, value = True)        
     vel = cmds.floatSliderGrp("Velocity", query=True, value=True)        
     load = cmds.floatSliderGrp("load", query=True, value=True)
     
     ground = cmds.textFieldButtonGrp("groundObj",q=True,text=True)
     if ground == None:
         ground = "nurbsPlane1"
         
     
     numCurves = len(curves)
     
     if (numAnts > 1) and (numAnts != numCurves):
         cmds.warning("the number of ants and curves must be the same")
         return 0
     else:
         if (numAnts > 1):
             self.duplicateAnts(numAnts-1)
         for ind in range(numAnts):                
             arcLen = cmds.arclen(curves[ind])
             # rebuiltCurve = cmds.rebuildCurve(curves[ind], kr=1)[0]            
             ct.walking(ind+1, startFrame, endFrame, curves[ind], ground, vel, load, isFlat)
def csMainWindow():
	csWin = "CreateSkeleton"
	if mc.window(csWin,q=True,ex=True):
		mc.deleteUI(csWin)

	mc.window(csWin,title = "Create Skeleton")
	mc.scrollLayout(horizontalScrollBarThickness=16)
	csMainCL = mc.columnLayout(columnAttach=("both",5),rowSpacing=10,columnWidth=320)
	#GUIDES CREATION
	csFL1 = mc.frameLayout(label="Create Guides",bs="etchedOut",w=300,mw=5,cll=1,p=csMainCL)
	csCL1= mc.columnLayout(rs=5,adj=1,p=csFL1)
		#Character Name
	mc.textFieldGrp("csChName",l="Character Name",tx="")
		#Number of Fingers/Toes
	#mc.intSliderGrp("csFingersNumber",label="Number of Fingers",field=True,minValue=1,maxValue=5,fieldMinValue=1,fieldMaxValue=5,value=4,cw3=(100,30,10),dc=csSetFingersNumber)
	#mc.checkBoxGrp("csHasThumb",numberOfCheckBoxes=1, label='Thumb?')
	#mc.intSliderGrp("csToesNumber",label="Number of Toes",field=True,minValue=1,maxValue=5,fieldMinValue=1,fieldMaxValue=5,value=4,cw3=(100,30,10),dc=csSetToesNumber)
	mc.button(l="Create Guides",c=csCreateGuides)
		#Character Scale Slider
	mc.floatSliderGrp("csScaleSlider",en=0,label="Guide scale",field=True,minValue=1,maxValue=100,fieldMinValue=1,fieldMaxValue=100,value=1,cw3=(70,30,10),dc=csScaleGuides)
		#Character Mirror
	mc.rowColumnLayout(nc=2,cw=[(1,138),(2,138)],p=csCL1);
	mc.button(l="Mirror left << ",al="right",c = functools.partial(csMirrorGuide,"left"))
	mc.button(l=">> Mirror right",al="left",c = functools.partial(csMirrorGuide,"right"));
	#END GUIDES CREATION
	
	#JOINTS CREATION
	csFL2 = mc.frameLayout(label="Create Joints",bs="etchedOut",w=300,mw=5,cll=1,p=csMainCL)
	csCL2 = mc.columnLayout(rs=5,adj=1,p=csFL2)
	mc.button(l="Create Joints",c =csCreateJoints)
	#floatSliderGrp -en 0 -label "THUMB Orient" -field true	-minValue 0 -maxValue 180 -fieldMinValue 1 -fieldMaxValue 100	-value 0 -cw3 80 40 10 -dc csJointOrientX csJointXSlider;
	#END JOINTS CREATION
	
	mc.showWindow(csWin)
Example #12
0
    def setEditMode(self, topJoint, endJoint, curveEdit=True ):

        self.dragOn = False

        endJoint = cmds.ls( endJoint, l=1 )[0]
        jntChildren = cmds.listRelatives( topJoint, c=1, ad=1, f=1 )
        jntChildren.append( topJoint )
        jntChildren.reverse()
        
        if not endJoint in jntChildren:
            cmds.frameLayout( WinA_Global.frame, e=1, en=0 )
            cmds.floatSliderGrp( WinA_Global.slider_joint, e=1, v=0 )
            return False
        
        index = jntChildren.index( endJoint )
        self.jntH = jntChildren[:index+1]
        self.numPoints = len( self.jntH )
        
        cmds.intField( WinA_Global.num_original, e=1, v=self.numPoints )
        cmds.floatSliderGrp( WinA_Global.slider_joint, e=1, v=0 )
        
        self.editCurveByPosition()
        self.setGlobalValue( self.getGlobalValue() )
        
        return True
Example #13
0
def createGeometryButtonAction(*pArgs):
    """ Queries all the fields related to the geometry interpretation and calls the procedure. """
    pAngle = cmds.floatSliderGrp( "angle", q=True, v=True )
    pStep = cmds.floatSliderGrp( "length", q=True, v=True )
    pRad = cmds.floatSliderGrp( "radius", q=True, v=True )
    subDivs = cmds.intSliderGrp( "cylSubdivs", q=True, v=True )
    length_atenuation = cmds.intSliderGrp( "length_atenuation", q=True, v=True )
    radius_atenuation = cmds.intSliderGrp( "radius_atenuation", q=True, v=True )
    turtleSpeed = cmds.floatSliderGrp( "turtleSpeed", q=True, v=True)
    rgb_blossom = cmds.colorSliderGrp( "rgb_blossomField", q=True, rgb=True )
    rgb_leaf = cmds.colorSliderGrp( "rgb_leafField", q=True, rgb=True )
    rgb_branch = cmds.colorSliderGrp( "rgb_branchField", q=True, rgb=True )

    if pAngle == 0 or pStep == 0 or pRad == 0 or subDivs == 0 or LStringVar == '':
        cmds.textField('warningsTextField', edit=True, tx='Please, revise all the fields again')  
    else:
        import globalVar
        reload(globalVar)
        globalVar.plantNumber += 1
        cmds.textField('warningsTextField', edit=True, tx='None.')
        createBranchShader(rgb_branch)
        createLeafShader(rgb_leaf)
        createBlossomShader(rgb_blossom)
        createGeometry(LStringVar, pRad, pStep, pAngle, subDivs, length_atenuation/100.0, radius_atenuation/100.0,
            turtleSpeed, rgb_branch, rgb_leaf, rgb_blossom)
Example #14
0
def evenEdgeSpacingUI():
    """
    Even Edge Spacing UI
    """
    # Window
    window = 'evenEdgeSpacingUI'
    if cmds.window(window, q=True, ex=1): cmds.deleteUI(window)
    window = cmds.window(window, t='Even Edge Spacing', s=True)

    # Layout
    CL = cmds.columnLayout()

    # UI Elements
    cmds.intSliderGrp('evenEdgeSpacing_smoothISG', label='Smooth', field=True, minValue=0, maxValue=20, fieldMinValue=0,
                    fieldMaxValue=100, value=4)
    cmds.floatSliderGrp('evenEdgeSpacing_influenceFSG', label='Influence', field=True, minValue=0.0, maxValue=1.0,
                      fieldMinValue=0.0, fieldMaxValue=1.0, value=1.0)
    cmds.checkBoxGrp('evenEdgeSpacing_snapToOrigCBG', label='Maintain Shape', numberOfCheckBoxes=1,
                   v1=False)  # columnWidth2=[100,165]
    cmds.checkBoxGrp('evenEdgeSpacing_deleteHistoryCBG', label='Delete History', numberOfCheckBoxes=1, v1=False)
    cmds.button('evenEdgeSpacingB', l='Even Edge Spacing', w=390,
              c='glTools.model.straightenVerts.evenEdgeSpacingFromUI()')

    # Show Window
    cmds.window(window, e=True, wh=[392, 99])
    cmds.showWindow(window)
Example #15
0
def smoothEdgeLineUI():
    """
    Smooth Edge Line UI
    """
    # Window
    window = 'smoothEdgesUI'
    if cmds.window(window, q=True, ex=1): cmds.deleteUI(window)
    window = cmds.window(window, t='Smooth Edge Line', s=True)

    # Layout
    CL = cmds.columnLayout()

    # UI Elements
    cmds.intSliderGrp('smoothEdges_smoothISG', label='Smooth', field=True, minValue=1, maxValue=20, fieldMinValue=1,
                    fieldMaxValue=100, value=4)
    cmds.floatSliderGrp('smoothEdges_falloffFSG', label='Falloff Distance', field=True, precision=3, minValue=0.0,
                      maxValue=10.0, fieldMinValue=0.0, fieldMaxValue=100.0, value=0.01)
    cmds.checkBoxGrp('smoothEdges_edgeSpacingCBG', label='Maintain Edge Spacing', numberOfCheckBoxes=1, v1=False)
    cmds.checkBoxGrp('smoothEdges_snapToOrigCBG', label='Maintain Shape', numberOfCheckBoxes=1,
                   v1=False)  # columnWidth2=[100,165]
    cmds.checkBoxGrp('smoothEdges_deleteHistoryCBG', label='Delete History', numberOfCheckBoxes=1, v1=False)
    cmds.button('smoothEdgesB', l='Smooth', w=390, c='glTools.model.straightenVerts.smoothEdgeLineFromUI()')

    # Show Window
    cmds.window(window, e=True, wh=[392, 115])
    cmds.showWindow(window)
Example #16
0
def update_ui():
    if g_skipUiUpdate:
        return
    value = cmds.getAttr("fumeFXShape1.sh_shadow_falloff");     cmds.floatSliderGrp(g_ffxShadowFalloff_floatSliderGrp,  e=True, v=value)
    value = cmds.getAttr("directionalLightXShape.intensity");   cmds.floatSliderGrp(g_lightsIntencity_floatSliderGrp,   e=True, v=value)
    value = cmds.currentTime(query=True);                       cmds.floatField(g_animCurrentFrame_floatField,          e=True, v=value)
    value = cmds.getAttr("defaultRenderGlobals.startFrame");    cmds.floatField(g_animStartFrame_floatField,            e=True, v=value)
    value = cmds.getAttr("defaultRenderGlobals.endFrame");      cmds.floatField(g_animEndFrame_floatField,              e=True, v=value)
Example #17
0
 def conditionControl(self, mode='edit', *args ):
     
     if mode == 'default':
         cmds.floatSliderGrp( WinA_Global.slider_joint, e=1, v=0 )
         cmds.formLayout( WinA_Global.slider_form, e=1, en=0 )
     elif mode == 'edit':
         cmds.floatSliderGrp( WinA_Global.slider_joint, e=1, v=0 )
         cmds.formLayout( WinA_Global.slider_form, e=1, en=1 )
    def uvSetOptions(self):
        window_name = "uvSetOptions"
        if cmds.window(window_name, q=True, exists=True):
            cmds.deleteUI(window_name)
        self.optionWindow = cmds.window(window_name, title="Lightmap Options")
        tabs = cmds.tabLayout(innerMarginWidth=5, innerMarginHeight=5)
        
        standardLayout = cmds.columnLayout(parent=self.optionWindow, adj=True)
        self.uvSetChoice = cmds.optionMenuGrp(label="Source UV Set")
        for uvSet in self.uvList:    #lists selections' uv sets
            cmds.menuItem(label=uvSet)
        self.lightmapBox = cmds.textFieldGrp(label="New UV Set Name", text=self.lightmap)
        self.presetSelect = cmds.optionMenuGrp(self.presetSelect, label="Spacing Presets", cc=self.presetValue)
        for preset in self.spacingPresets:
            cmds.menuItem(label=preset)
        cmds.floatSliderGrp(self.shellSpacingSlider, label="Percentage Space:", v=3.200, step=0.001, max=5.000, field=True)
        print cmds.floatSliderGrp(self.shellSpacingSlider, q=True, v=True)
        cmds.button(label="Generate Lightmap", width=200, c=self.copyAndLayoutCheck)
        
        advancedLayout = cmds.columnLayout(parent=self.optionWindow, adj=True)
        
        layoutObjectsCollection = cmds.radioCollection()                        #radial button, creates new layout
        layoutObjectsCollection_layout = cmds.columnLayout()
        cmds.text(label = "Layout objects:", p=layoutObjectsCollection_layout)
        rbl = cmds.radioButton(label="Per object(overlapping)", p=layoutObjectsCollection_layout, onc=lambda *args: self.perObjectLayout(0))
        rbl = cmds.radioButton(label="Single or multiple objects(non-overlapping)", p=layoutObjectsCollection_layout, onc=lambda *args: self.perObjectLayout(1), sl=True )
                
        prescaleCollection = cmds.radioCollection()                        #radial button, creates new layout
        prescaleCollection_layout = cmds.columnLayout()
        cmds.text(label = "Prescale:", p=prescaleCollection_layout)
        rbl = cmds.radioButton(label="None", p=prescaleCollection_layout, onc=lambda *args: self.prescaleLayout(0))
        rbl = cmds.radioButton(label="Object", p=prescaleCollection_layout, onc=lambda *args: self.prescaleLayout(1))
        rbl = cmds.radioButton(label="World", p=prescaleCollection_layout, onc=lambda *args: self.prescaleLayout(2), sl=True)

        collection = cmds.radioCollection()                        #radial button, creates new layout
        collection_layout = cmds.columnLayout()
        cmds.text(label = "Shell Layout:", p=collection_layout)
        rbl = cmds.radioButton(label="Into region", p=collection_layout, onc=lambda *args: self.shellLayout(0), sl=True)
        rbl = cmds.radioButton(label="Along U", p=collection_layout, onc=lambda *args: self.shellLayout(1))
        rbl = cmds.radioButton(label="None", p=collection_layout, onc=lambda *args: self.shellLayout(2))
           
        collection = cmds.radioCollection()                        #radial button, creates new layout
        collection_layout = cmds.columnLayout()
        cmds.text(label = "Scale:", p=collection_layout)
        rbl = cmds.radioButton(label="None", p=collection_layout, onc=lambda *args: self.scaleLayout(0))
        rbl = cmds.radioButton(label="Uniform", p=collection_layout, onc=lambda *args: self.scaleLayout(1), sl=True)
        rbl = cmds.radioButton(label="Stretch", p=collection_layout, onc=lambda *args: self.scaleLayout(2))
        
        rotateCollection = cmds.radioCollection()                        #radial button, creates new layout
        rotateCollection_layout = cmds.columnLayout()
        cmds.text(label = "Rotate:", p=rotateCollection_layout)
        rbl = cmds.radioButton(label="None", p=rotateCollection_layout, onc=lambda *args: self.rotationLayout(0))
        rbl = cmds.radioButton(label="90 degrees", p=rotateCollection_layout, onc=lambda *args: self.rotationLayout(1), sl=True)
        rbl = cmds.radioButton(label="Free", p=rotateCollection_layout, onc=lambda *args: self.rotationLayout(2))
        
        cmds.tabLayout( tabs, edit=True, tabLabel=((standardLayout, 'General'), (advancedLayout, 'Advanced')) ) 
        
        cmds.showWindow(self.optionWindow)
Example #19
0
    def core(self):
        
        uiInfo.addFrameLayout( self._uiName, self._label )
        
        uiInfo.setSpace( 10 )
        
        textScrollArea = (self._width-20) / 2
        textScrollArea2 =  self._width-20-textScrollArea
        
        cmds.rowColumnLayout( nc=4, cw=[(1,10), (2,textScrollArea),(3,textScrollArea2),(4,10)] )
        uiInfo.setSpace()
        self._set = cmds.textScrollList(  h=100, ams=1,  sc = partial( self.selectOnSetCmd ) )
        self._guideSet = cmds.textScrollList(  h=100, ams=1,  sc = partial( self.selectOnGuideSetCmd ) )
        uiInfo.setSpace()
        cmds.setParent( '..' )
        
        uiInfo.setSpace( 5 )
        
        checkWidth = 25
        textWidth = (self._width-checkWidth-20)*.45 - 5
        sliderWidth = (self._width-checkWidth-20) - textWidth - checkWidth*2 + 5
        
        cmds.rowColumnLayout( nc=7, cw=[(1,10),(2,textWidth),(3,checkWidth),(4,checkWidth),(5,checkWidth),(6,sliderWidth),(7,10)])
        uiInfo.setSpace()
        cmds.frameLayout( lv=0, bs='out', h=20 )
        cmds.text( l='ATTRIBUTE' )
        cmds.setParent( '..' )
        cmds.button( 'A', c=self.allCheckBoxOnCmd, bgc=[.8,.39,.41] )
        cmds.button( 'C', c=self.allCheckBoxOffCmd, bgc=[.47,.72,.21] )
        cmds.button( 'R', c=self.reverseCheckBoxCmd, bgc=[.09,.41,.51] )
        cmds.frameLayout( lv=0, bs='out' )
        cmds.text( l='VALUE' )
        cmds.setParent( '..' )
        uiInfo.setSpace()
        cmds.setParent( '..' )
        
        cmds.rowColumnLayout( nc=5, cw=[(1,10),(2,textWidth),(3,20),(4,sliderWidth+checkWidth+20),(5,10)])
        for i in self._sliderDefineList:
            uiInfo.setSpace()
            cuSlider = self.sliderSet( i[0], i[1], i[2], i[3], [(1,50),(2,150)] )
            cmds.floatSliderGrp( cuSlider[1], e=1, step=0.01, fmx=100, cc=self.saveData )
            uiInfo.setSpace()
            
            self._sliders.append( cuSlider )
        cmds.setParent( '..' )
        
        uiInfo.setSpace( 10 )

        cmds.rowColumnLayout( nc=4, cw=[(1,10),(2,30),(3,self._width-20-30),(4,10)])
        uiInfo.setSpace()
        cmds.iconTextButton( image= uiModel.iconPath +'/spoid.png', c= partial( self.getCmd ) )
        uiInfo.setButton( partial( self.setCmd ) )
        uiInfo.setSpace()
        cmds.setParent( '..' )
        
        uiInfo.setSpace( 10 )
        
        uiInfo.getOutFrameLayout()
Example #20
0
def ribbonAttributes():
	global ribbonWidth, ribbonHeight, ribbonSubX, ribbonSubY
	ribbonWidth = mc.floatSliderGrp(ribbonWidthInput, query=True, value=True)
	ribbonHeight = mc.floatSliderGrp(ribbonHeightInput, query=True, value=True)
	ribbonSubX = mc.floatSliderGrp(ribbonSubXInput, query=True, value=True)
	ribbonSubY = mc.floatSliderGrp(ribbonSubYInput, query=True, value=True)

	adjustRibbonWidth(ribbonWidth)
	return
Example #21
0
	def run(self):
		step = cmds.floatSliderButtonGrp(self.stepSlider,q=True,value=True)
		mesh = cmds.checkBox(self.meshCbx,q=True, value = True)
		radius = cmds.floatSliderGrp(self.bRadSlider,q=True,value=True)
		bmult = cmds.floatSliderGrp(self.baseMultSlider,q=True,value=True)
		taper = cmds.floatSliderGrp(self.taperSlider,q=True,value=True)
		tmult = cmds.floatSliderGrp(self.taperMultSlider,q=True,value=True)
		autoAdd = cmds.checkBox(self.autoAddCbx,q=True, value = True)
		meshDrawCtx(cmds.ls(sl=True,l=True),step,mesh,radius,bmult,taper,tmult,autoAdd).run()
Example #22
0
def custom_playblast_UI():
	global cppercentage,cpname,cpincremental
	cpwin = cmds.window(title="Custom Playblast",rtf=True)
	cplay = cmds.columnLayout(p=cpwin, w=300, h=200,cat=("left",10),rs=10)
	cmds.floatSliderGrp(cppercentage,p=cplay,label="Quality",w=280,min=0,max=100,value=50,step=1,field=True,cal=[1,"left"])
	cmds.textFieldGrp(cpname,p=cplay,h=50,label="File name",w=280,cal=[1,"left"])
	cmds.checkBox(cpincremental,p=cplay,l="Incremental Save",w=280,enable=True)
	cpplayblastbtn = cmds.button(p=cplay,h=50,w=280,l="Custom Playblast",c="custom_playblast()")
	cmds.showWindow(cpwin)
Example #23
0
def bedazzleButton(*args):
	reduceMesh = cmds.intSliderGrp("meshReduce", query=True, v=True)
	size = cmds.floatSliderGrp("size", query=True, v=True)
	padding = cmds.floatSliderGrp("padding", query=True, v=True)
	shade = cmds.checkBox("shaderCheckBox", query=True, v=True)
	smoothe = cmds.floatSliderGrp("smoothe", query=True, v=True)
	overlap = cmds.floatSliderGrp("overlap", query=True, v=True)

	success = run(isObj, reduceMesh, size, padding, shade, smoothe, overlap)
Example #24
0
def balloonAttributes():
	global minBalloonDrop, balloonDrop, balloonRadius, balloonQuantity
	balloonRadius = mc.floatSliderGrp(balloonRadiusInput, query=True, value=True)
	minBalloonDrop = mc.floatSliderGrp(minBalloonDropInput, query=True, value=True)
	balloonDrop = mc.floatSliderGrp(balloonDropInput, query=True, value=True)
	balloonQuantity = mc.intSliderGrp(balloonQuantityInput, query=True, value=True)

	adjustRadius(balloonRadius)
	adjustDrop(balloonDrop, balloonRadius)
	return
Example #25
0
def switches():
    # IK FK Switches
    ltIKFK = cmds.floatSliderGrp(label="Left IKFK", field=True, min=0, max=10, step=0.1)
    rtIKFK = cmds.floatSliderGrp(label="Left IKFK", field=True, min=0, max=10, step=0.1)
    cmds.connectControl(ltIKFK, "lt_hand_controls.IK_FK_Switch")
    cmds.connectControl(rtIKFK, "rt_hand_controls.IK_FK_Switch")

    # Face Shapes
    rtPuff = cmds.floatSliderGrp(label="Right Puff", field=True, min=0, max=2, step=0.1)
    cmds.connectControl(rtPuff, "mouth_control_group|control_slider_curves|puff_marker_r_curve.translateX")
Example #26
0
def makeGui():
	# Make a new window
	cordMakerWindow = cmds.window('cordMaker', title="Hanging Cord Generator", iconName='cordMaker', widthHeight=(350, 100) )
	cmds.columnLayout('uiColWrapper', w = 350, adjustableColumn=False, parent = 'cordMaker' )
	cmds.floatSliderGrp('cordWeightRandomizeGrp', label='Weight Randomization', v = .25, min =0, max = 5, cw2 = [120,200], parent = 'cordMaker' )
	cmds.floatSliderGrp('cordWeightPointRandomization', label='Attach Randomization', v = .2, min =0, max = 5, cw2 = [120,200], parent = 'cordMaker' )
	cmds.floatSliderButtonGrp('cordWeightGrp', label='Cord Weight', field=True, pre = 2,v = .25, min =-10, max = 10, buttonLabel='Generate', cw4 = [75,50,146,5], bc = makeCord, parent = 'cordMaker' )

	cmds.button('backUp', label = "Revert to Selection", parent = 'uiColWrapper', en = 0, width = 334, c = recoverSel)
	
	cmds.showWindow( cordMakerWindow )
Example #27
0
 def UIqury(self):
     jointA = cmds.textField('jointA',q = True,text = True)
     jointB = cmds.textField('jointB',q = True,text = True)
     if cmds.radioButton( 'Replace',q = True,sl=True) == True:
         paint_operation = 'Replace'
     if cmds.radioButton( 'Add',q = True,sl=True) == True:
         paint_operation = 'Add'
     Opacity = cmds.floatSliderGrp('Opacity',q = True,value=True)
     Value = cmds.floatSliderGrp('Value',q = True,value=True)
     weightValue = Opacity * Value
     print paint_operation,weightValue
     return jointA,jointB,paint_operation,weightValue
def splitMeshByInfluencesUI(*args):
    if cmds.window("splitMeshByInfluencesUI", exists = True):
        cmds.deleteUI("splitMeshByInfluencesUI")

    window = cmds.window("splitMeshByInfluencesUI", title='Split Mesh by Influences', s=False)
    cmds.columnLayout()
    cmds.floatSliderGrp("skinWeightFloatSliderGrp", label='Skin Weight Threshold', field=True, minValue=0, maxValue=1, value=0.5, step=0.01, cw3=[110, 30, 150])
    cmds.button("Apply", label="Apply", w=290, c=findThreshold)

    cmds.showWindow(window)

#splitMeshByInfluencesUI()
def construct_surface():
    status = True 
    global sizeX, sizeY, Height
    widthPlaneX = mc.floatSliderGrp(widthX,q=True,value = True)
    widthPlaneZ = mc.floatSliderGrp(widthZ,q=True,value = True)    
    if status == True:
        mc.polyPlane(sx=widthPlaneX, sy=widthPlaneZ)
        
    mc.scale(scaleX,0.0,scaleZ)
    mc.rename("pPlane1", "Landscape_0")
    #Freeze scale transformation
    mc.makeIdentity(s=True, a=True)
    return sizeX, sizeY
Example #30
0
 def clear(self):
     
     valueStr = "1.0|1.0|0.0|2.0|1.0|0.0|0.0|0.1|0.0|0.0|0.0|1.0"
     
     values = []
     for i in valueStr.split( '|' ):
         values.append( float( i ) )
             
     for slider in self._sliders:
         index = self._sliders.index( slider )
         cmds.floatSliderGrp( slider[1], e=1, v=values[index] )
         
     self.saveData()
Example #31
0
def get_create_command_kwargs():
    """Gets the cvWrap command arguments either from the option box widgets or the saved
    option vars.  If the widgets exist, their values will be saved to the option vars.
    @return A dictionary of the kwargs to the cvWrap command."""
    args = {}
    if cmds.textFieldGrp(NAME_WIDGET, exists=True):
        args['name'] = cmds.textFieldGrp(NAME_WIDGET, q=True, text=True)
        cmds.optionVar(sv=(NAME_WIDGET, args['name']))
    else:
        args['name'] = cmds.optionVar(q=NAME_WIDGET) or 'cvWrap#'
    if cmds.floatSliderGrp(RADIUS_WIDGET, exists=True):
        args['radius'] = cmds.floatSliderGrp(RADIUS_WIDGET, q=True, value=True)
        cmds.optionVar(fv=(RADIUS_WIDGET, args['radius']))
    else:
        args['radius'] = cmds.optionVar(q=RADIUS_WIDGET)

    if cmds.checkBoxGrp(NEW_BIND_MESH_WIDGET, exists=True):
        if cmds.checkBoxGrp(NEW_BIND_MESH_WIDGET, q=True, v1=True):
            args['newBindMesh'] = True
            cmds.optionVar(iv=(NEW_BIND_MESH_WIDGET, 1))
        else:
            cmds.optionVar(iv=(NEW_BIND_MESH_WIDGET, 0))
    else:
        value = cmds.optionVar(q=NEW_BIND_MESH_WIDGET)
        if value:
            args['newBindMesh'] = True

    if cmds.textFieldButtonGrp(BIND_FILE_WIDGET, exists=True):
        bind_file = cmds.textFieldButtonGrp(BIND_FILE_WIDGET,
                                            q=True,
                                            text=True)
        bind_file = os.path.expandvars(bind_file.strip())
        if bind_file:
            if os.path.exists(bind_file):
                args['binding'] = bind_file
            else:
                cmds.warning('{0} does not exist.'.format(bind_file))

    return args
Example #32
0
def getInput():
    deleteCity()
    _name = cmds.textFieldGrp('cityName', query=True, text=True)
    _amount = cmds.intSliderGrp('buildPerBlockSlider', query=True, value=True)
    _districtSize = cmds.intSliderGrp('blockSlider', query=True, value=True)
    _citySpread = cmds.floatSliderGrp('citySpreadSlider',
                                      query=True,
                                      value=True)
    _rgb = cmds.colorSliderGrp('cityColorSlider', query=True, rgbValue=True)
    makeCity('city', _amount, 2, 5, 5, 5, _districtSize, _citySpread, _rgb)
    # set color after creation
    setColor(_rgb)
    print 'Your city has been made. Welcome to', _name
Example #33
0
File: menu.py Project: iVerb/cvwrap
def display_cvwrap_options(*args, **kwargs):
    cmds.loadPlugin('cvwrap', qt=True)
    layout = mel.eval('getOptionBox')
    cmds.setParent(layout)
    cmds.columnLayout(adj=True)

    for widget in [NAME_WIDGET, RADIUS_WIDGET, BIND_FILE_WIDGET, NEW_BIND_MESH_WIDGET]:
        # Delete the widgets so we don't create multiple controls with the same name
        try:
            cmds.deleteUI(widget, control=True)
        except:
            pass

    cmds.textFieldGrp(NAME_WIDGET, label='Node name', text='cvWrap#')
    radius = cmds.optionVar(q=RADIUS_WIDGET)
    cmds.floatSliderGrp(RADIUS_WIDGET, label='Sample radius', field=True, minValue=0.0,
                        maxValue=100.0, fieldMinValue=0.0, fieldMaxValue=100.0, value=radius,
                        step=0.01, precision=2)
    cmds.textFieldButtonGrp(BIND_FILE_WIDGET, label='Binding file ', text='', buttonLabel='Browse',
                            bc=display_bind_file_dialog)
    use_new_bind_mesh = cmds.optionVar(q=NEW_BIND_MESH_WIDGET)
    cmds.checkBoxGrp(NEW_BIND_MESH_WIDGET, numberOfCheckBoxes=1, label='Create new bind mesh',
                     v1=use_new_bind_mesh)
    mel.eval('setOptionBoxTitle("cvWrap Options");')
    mel.eval('setOptionBoxCommandName("cvWrap");')
    apply_close_button = mel.eval('getOptionBoxApplyAndCloseBtn;')
    cmds.button(apply_close_button, e=True, command=apply_and_close)
    apply_button = mel.eval('getOptionBoxApplyBtn;')
    cmds.button(apply_button, e=True, command=create_cvwrap)
    reset_button = mel.eval('getOptionBoxResetBtn;')
    # For some reason, the buttons in the menu only accept MEL.
    cmds.button(reset_button, e=True,
                command='python("import cvwrap.menu; cvwrap.menu.reset_to_defaults()");')
    close_button = mel.eval('getOptionBoxCloseBtn;')
    cmds.button(close_button, e=True, command=close_option_box)
    save_button = mel.eval('getOptionBoxSaveBtn;')
    cmds.button(save_button, e=True,
                command='python("import cvwrap.menu; cvwrap.menu.get_create_command_kwargs()");')
    mel.eval('showOptionBox')
def setTemperature(*args):
    global temperatureField

    mySelection = cmds.ls(selection=True)

    vRayLight = VRayLightList(mySelection)

    myTemperature = cmds.floatSliderGrp(temperatureField,
                                        query=True,
                                        value=True)

    for light in vRayLight:
        cmds.setAttr(light + ".temperature", myTemperature)
Example #35
0
    def spotLightConeAngleControls(self, *args):

        if (cmds.textScrollList(self.lightList, q=True,
                                selectItem=True)) is None:
            cmds.error('Nothing is Selected')
            return
        else:
            lightN = cmds.textScrollList(self.lightList,
                                         q=True,
                                         selectItem=True)[0]
        if cmds.nodeType(lightN) == 'spotLight':
            coneAngle = cmds.floatSliderGrp(self.spotCone, q=True, value=True)
            self.lmFunc.spotLightConeAngle(lightN, coneAngle)
 def createCave(self, *args):
     nodeName = mc.textFieldGrp(self.m_caveNameTextField,
                                query=True,
                                tx=True)
     if nodeName == "":
         nodeName = "CaveNode"
     depthValue = mc.floatSliderGrp(self.m_caveDepthControl,
                                    query=True,
                                    value=True)
     rebuildStatus = mc.checkBox(self.m_caveRebuildCurveCheckBox,
                                 query=True,
                                 value=True)
     mc.createCave(n=nodeName, d=depthValue, rb=rebuildStatus)
def createFKControls():
    if mc.window("makeFKWindow", ex=True):
        mc.deleteUI("makeFKWindow")

    sel = mc.ls(sl=True)

    if len(sel) >= 1:

        text = sel[0]

        mc.window("makeFKWindow", title="Create FK Controls")
        mc.columnLayout("makeFKColumn", adj=True)

        controlSize = mc.floatSliderGrp("controlSize",
                                        label="Control Size",
                                        field=True,
                                        cw3=(80, 40, 150),
                                        minValue=.01,
                                        maxValue=50,
                                        fieldMinValue=.1,
                                        fieldMaxValue=50,
                                        value=2)

        controlColor = mc.colorIndexSliderGrp("controlColor",
                                              cw2=(80, 40),
                                              label="Control Color",
                                              min=0,
                                              max=31,
                                              value=5)

        controlName = mc.textFieldGrp("controlName",
                                      cw2=(80, 200),
                                      label="Control Suffix",
                                      text="_CTRL")

        mc.button("createFKButton",
                  label="CREATE CONTROL",
                  command="makeFKMS(controlSize, controlColor)")

        originalSelection = mc.ls(sl=True)

        mc.select(originalSelection, r=True)

        mc.showWindow("makeFKWindow")
        mc.window("makeFKWindow", edit=True, wh=(310, 90))

        if len(sel) >= 1:
            mc.textFieldGrp("controlName", e=True, text="_CTRL", editable=True)


#createFKControls()
Example #38
0
 def Tt_Rig_Button10(self):
     Curve = cmds.curve(d=1,
                        p=[[-2.4009185406449163, 0.0, -15.701629409832192],
                           [-6.1229929289248366, 0.0, -14.78221684919226],
                           [-11.313820044880201, 0.0, -11.313820044880201],
                           [-14.78221684919226, 0.0, -6.1229929289248366],
                           [-16.000155614386657, 0.0, 0.0],
                           [-14.78221684919226, 0.0, 6.1229929289248366],
                           [-11.313820044880201, 0.0, 11.313820044880201],
                           [-6.1229929289248366, 0.0, 14.78221684919226],
                           [0.0, 0.0, 16.000155614386657],
                           [6.1229929289248366, 0.0, 14.78221684919226],
                           [11.313820044880201, 0.0, 11.313820044880201],
                           [14.78221684919226, 0.0, 6.1229929289248366],
                           [16.000155614386657, 0.0, 0.0],
                           [14.78221684919226, 0.0, -6.1229929289248366],
                           [11.313820044880201, 0.0, -11.313820044880201],
                           [8.6673016136207153, 0.0, -13.244781553953684],
                           [10.330014013461584, 0.0, -16.14832901999192],
                           [0.32890973536521306, 0.0, -14.262266815071186],
                           [4.4484712581737451, 0.0, -5.2290108475947896],
                           [5.863017911864298, 0.0, -8.107742372562571],
                           [7.2183788311968735, 0.0, -7.2183788311968735],
                           [9.4312613414687725, 0.0, -3.9065562335774922],
                           [10.208322771163576, 0.0, 0.0],
                           [9.4312613414687725, 0.0, 3.9065562335774922],
                           [7.2183788311968735, 0.0, 7.2183788311968735],
                           [3.9065562335774922, 0.0, 9.4312613414687725],
                           [0.0, 0.0, 10.208322771163576],
                           [-3.9065562335774922, 0.0, 9.4312613414687725],
                           [-7.2183788311968735, 0.0, 7.2183788311968735],
                           [-9.4312613414687725, 0.0, 3.9065562335774922],
                           [-10.208322771163576, 0.0, 0.0],
                           [-9.4312613414687725, 0.0, -3.9065562335774922],
                           [-7.2183788311968735, 0.0, -7.2183788311968735],
                           [-3.9065562335774922, 0.0, -9.4312613414687725],
                           [-2.4009185406449163, 0.0, -9.7704547724034416],
                           [-2.4009185406449163, 0.0, -15.701629409832192]])
     Curve_Rename = cmds.rename(Curve, 'Circle_Arrow')
     color = cmds.palettePort('color_set', q=True, setCurCell=True)
     if color > 0:
         cmds.setAttr(Curve_Rename + '.overrideEnabled', True)
         cmds.setAttr(Curve_Rename + '.overrideColor', color)
     scale = cmds.floatSliderGrp('ScaleSlider', q=True, value=True)
     cmds.xform(Curve_Rename, ws=True, s=[scale, scale, scale])
     cmds.makeIdentity(Curve_Rename,
                       apply=True,
                       t=False,
                       r=False,
                       s=True,
                       n=False)
Example #39
0
def sharpenCrease(slider):
    """Sharpen (reduce width) of selected creased vertices.
        First vertex will be given a small width, and progress
        until the last vertex in the selection
    """
    min_thickness = cmds.floatSliderGrp(slider, query=True, value=True)
    min_thickness = min_thickness + 0.1

    selected = cmds.ls(orderedSelection=True, flatten=True)
    if len(selected) < 1:
        return

    alphas = cmds.polyColorPerVertex(query=True, a=True)
    thickness = breakAlphaV3(alphas.pop())

    # If minimum is greater than maximum, then all vertices will
    # gain the same thickness
    max_thickness = max(thickness, min_thickness)

    # Edge case: if there's only one vertex selected, set that
    # vertex to whatever the slider says.
    if len(alphas) < 1:
        max_thickness = min_thickness

    # Set the last vert in the list to maximum
    print(selected[-1])
    print(max_thickness)

    cmds.select(selected[-1], replace=True)
    cmds.polyColorPerVertex(a=makeAlphaV3(max_thickness))

    # Set every other vert in the list to increment to the local maximum
    flen = len(alphas) * 1.0
    for i in range(0, len(alphas)):
        thickness = min_thickness + (i / flen) * (max_thickness -
                                                  min_thickness)

        print(selected[i])
        print(thickness)
        print(makeAlphaV3(thickness))

        cmds.select(selected[i], replace=True)
        cmds.polyColorPerVertex(a=makeAlphaV3(thickness))

    # Restore selection
    cmds.select(selected, replace=True)
    selected = cmds.ls(orderedSelection=True, flatten=True)
    print('-----')
    print(selected)
    alphas = cmds.polyColorPerVertex(query=True, a=True)
    print(alphas)
 def __init__(self,n):
     
     self.name = n # le nom du perso
     self.mainGroup = cmds.group(empty=True, name=n) # Le groupe du perso
     
     
     
     self.bodyHeight = cmds.floatSliderGrp(bodyHeight_, q = True, v = True)
     self.bodyDepth = cmds.floatSliderGrp(bodyDepth_, q = True, v = True)
     self.bodyW = cmds.floatSliderGrp(bodyW_, q = True, v = True)
     self.legSize = cmds.floatSliderGrp(legSize_, q = True, v = True)
     self.legLenght = cmds.floatSliderGrp(legLenght_, q = True, v = True)
     self.headSize = cmds.floatSliderGrp(headSize_, q = True, v = True)
     self.armSize = cmds.floatSliderGrp(armsize_, q = True, v = True)
     self.armLenght = cmds.floatSliderGrp(armLenght_, q = True, v = True)
Example #41
0
def createAlongCurveUI():
	'''
	UI for createAlongCurve()
	'''
	# Window
	window = 'createAlongCurveUI'
	if mc.window(window,q=True,ex=1): mc.deleteUI(window)
	window = mc.window(window,t='Create Along Curve')

	# Layout
	cl = mc.columnLayout()
	# Curve
	curveTFB = mc.textFieldButtonGrp('createAlongCurveTFB',label='Target Curve',text='',buttonLabel='Load Selected')
	# Prefix
	prefixTFG = mc.textFieldGrp('createAlongCurvePrefixTFG',label='Prefix',text='')
	# Object Type
	typeOMG = mc.optionMenuGrp('createAlongCurveTypeOMG',label='Object Type')
	for item in ['joint','transform','locator']: mc.menuItem(label=item)
	# Object Count
	countISG = mc.intSliderGrp('createAlongCurveCountISG',field=True,label='Object Count',minValue=0,maxValue=10,fieldMinValue=0,fieldMaxValue=100,value=0)
	# Parent Objects
	parentCBG = mc.checkBoxGrp('createAlongCurveParentCBG',numberOfCheckBoxes=1,label='Parent Objects',v1=True)
	# Use Distance
	distanceCBG = mc.checkBoxGrp('createAlongCurveDistCBG',numberOfCheckBoxes=1,label='Use Distance',v1=False)
	# Min/Max Percent
	minPercentFFG = mc.floatSliderGrp('createAlongCurveMinFSG',label='Min Percent',field=True,minValue=0.0,maxValue=1.0,fieldMinValue=0.0,fieldMaxValue=1.0,value=0.0)
	maxPercentFFG = mc.floatSliderGrp('createAlongCurveMaxFSG',label='Max Percent',field=True,minValue=0.0,maxValue=1.0,fieldMinValue=0.0,fieldMaxValue=1.0,value=1.0)

	# Buttons
	createB = mc.button('createAlongCurveCreateB',l='Create',c='glTools.ui.curve.createAlongCurveFromUI(False)')
	createCloseB = mc.button('createAlongCurveCreateCloseB',l='Create and Close',c='glTools.ui.curve.createAlongCurveFromUI(True)')
	cancelB = mc.button('createAlongCurveCancelB',l='Cancel',c='mc.deleteUI("'+window+'")')

	# TFB commands
	mc.textFieldButtonGrp(curveTFB,e=True,bc='glTools.ui.utils.loadCurveSel("'+curveTFB+'","'+prefixTFG+'")')

	# Show Window
	mc.showWindow(window)
Example #42
0
    def offsetCurveChangeCmd(self, *args):

        multRate = cmds.floatSliderGrp(self._offsetCurve, q=1, v=1)
        cmds.floatSliderGrp(self._offsetCurve, e=1, v=1)

        if self._dragStart:

            for i in range(len(self._targetCurves)):
                targetCurve = self._targetCurves[i]
                value = self._keepTargetCurveValues[i]
                cmds.setAttr(targetCurve + '.centerRate', value)

            cmds.undoInfo(swf=1)
            self._dragStart = False

            for i in range(len(self._targetCurves)):
                targetCurve = self._targetCurves[i]
                value = self._keepTargetCurveValues[i]
                cmds.setAttr(targetCurve + '.centerRate', value * multRate)
        else:
            selCurves = cmds.ls(sl=1)

            self._targetCurves = []
            self._keepTargetCurveValues = []
            for curve in selCurves:
                if cmds.attributeQuery('centerRate', node=curve, ex=1):
                    self._targetCurves.append(curve)
                    self._keepTargetCurveValues.append(
                        cmds.getAttr(curve + '.centerRate'))

            if not self._targetCurves:
                cmds.warning("Select VolumeCurves")
                return None

            for i in range(len(self._targetCurves)):
                targetCurve = self._targetCurves[i]
                value = self._keepTargetCurveValues[i]
                cmds.setAttr(targetCurve + '.centerRate', value * multRate)
Example #43
0
def interactiveSnapToMeshUI():
	'''
	UI for snapToMesh()
	'''
	# Window
	window = 'interactiveSnapUI'
	if mc.window(window,q=True,ex=1): mc.deleteUI(window)
	window = mc.window(window,t='Snap To Mesh - Interactive')
	
	# Layout
	FL = mc.formLayout(numberOfDivisions=100)
	
	# UI Elements
	#---
	
	# Target Mesh
	snapMeshTFB = mc.textFieldButtonGrp('interactiveSnapMeshTFB',label='Target Mesh',text='',buttonLabel='Load Selected')
	
	# Slider
	snapFSG = mc.floatSliderGrp('interactiveSnapFSG', label='Drag:',field=False, minValue=0.0, maxValue=1.0,value=0 )
	snapRangeFFG = mc.floatFieldGrp('interactiveSnapRangeFSG', numberOfFields=2, label='Slider Min/Max', value1=0.0, value2=1.0)
	
	# UI Callbacks
	mc.textFieldButtonGrp(snapMeshTFB,e=True,bc='glTools.ui.utils.loadMeshSel("'+snapMeshTFB+'")')
	mc.floatSliderGrp('interactiveSnapFSG',e=True,cc='glTools.ui.mesh.interactiveSnapChangeCommand()')
	mc.floatSliderGrp('interactiveSnapFSG',e=True,dc='glTools.ui.mesh.interactiveSnapDragCommand()')
	
	# Buttons
	cancelB = mc.button('interactiveSnapCancelB',l='Cancel',c='mc.deleteUI("'+window+'")')
	
	# Form Layout - MAIN
	mc.formLayout(FL,e=True,af=[(snapMeshTFB,'top',5),(snapMeshTFB,'left',5),(snapMeshTFB,'right',5)])
	mc.formLayout(FL,e=True,af=[(snapFSG,'left',5),(snapFSG,'right',5)],ac=[(snapFSG,'top',5,snapMeshTFB)])
	mc.formLayout(FL,e=True,af=[(snapRangeFFG,'left',5),(snapRangeFFG,'right',5)],ac=[(snapRangeFFG,'top',5,snapFSG)])
	mc.formLayout(FL,e=True,af=[(cancelB,'left',5),(cancelB,'right',5),(cancelB,'bottom',5)])
	
	# Show Window
	mc.showWindow(window)
Example #44
0
    def randomSelectionPanelUI(self, name, parent, collapse=False):
        """Create random selection UI controls"""

        mc.frameLayout(width=400,
                       collapsable=True,
                       cl=collapse,
                       borderStyle="etchedIn",
                       label="Random Selection")
        mc.columnLayout(name)
        mc.separator(height=4, style="none")
        mc.rowLayout(numberOfColumns=1,
                     columnAttach1="left",
                     columnAlign1="both",
                     columnOffset1=4)
        mc.text(
            label="Randomly select items from within the current selection.")
        mc.setParent(name)
        mc.separator(height=8, style="none")
        mc.floatSliderGrp("randomPercentage",
                          label="Percentage: ",
                          value=50,
                          field=True,
                          minValue=0,
                          maxValue=100,
                          fieldMinValue=0,
                          fieldMaxValue=100)
        mc.separator(height=4, style="none")
        mc.rowLayout(numberOfColumns=1,
                     columnAttach1="left",
                     columnAlign1="both",
                     columnOffset1=142)
        mc.button(width=116,
                  label="Random Selection",
                  command=lambda *args: self.randomSelection(
                      mc.floatSliderGrp('randomPercentage', q=True, v=True)))
        mc.setParent(name)
        mc.separator(height=4, style="none")
        mc.setParent(parent)
Example #45
0
def buildUI():

    window = cmd.window(title="Replicator",
                        iconName='replic8r',
                        widthHeight=(400, 210))
    column = cmd.columnLayout(columnAttach=("both", 10),
                              columnAlign="center",
                              adjustableColumn=True)

    cmd.separator(height=10)
    cmd.text(label="REPLICATOR")
    cmd.separator(height=10)
    cmd.text(
        label=
        "Select the element to replicate,\nselect the curve to replicate it along,\nset the separation between elements (increment),\nand press Replicate button"
    )
    cmd.separator(height=10)

    cmd.textFieldGrp("name", label="Name", text="chain", editable=True)
    cmd.floatSliderGrp("incr",
                       label="Increment",
                       min=0,
                       max=10,
                       fieldMaxValue=100,
                       field=True,
                       value=1.0)

    cmd.separator(height=10)

    cmd.button(label='Replicate',
               command=("mayatools.python.replicator.doReplicate()"))
    cmd.button(label='Close',
               command=('maya.cmds.deleteUI(\"' + window + '\", window=True)'))

    # Set its parent to the Maya window (denoted by '..')
    cmd.setParent('..')
    # Show the window that we created (window)
    cmd.showWindow(window)
Example #46
0
def UI():
    cityWindow = cmds.window(title='City Generator', wh=(400, 300), s=True)
    cmds.columnLayout(adjustableColumn=True, rowSpacing=5, cw=100, cal='left')
    cmds.text(label='Name of city:')
    cmds.textFieldGrp('cityName', ann='Name Of City:', tx='city')
    cmds.intSliderGrp('buildPerBlockSlider',
                      field=True,
                      label="Buildings Per Block",
                      v=4,
                      min=1,
                      max=25)

    cmds.intSliderGrp('blockSlider',
                      field=True,
                      label="Number Of Blocks",
                      v=2,
                      min=2,
                      max=30)
    cmds.floatSliderGrp('citySpreadSlider',
                        field=True,
                        label="City Spread",
                        v=0.6,
                        min=0,
                        max=1.2,
                        fs=0.1)
    cmds.colorSliderGrp('cityColorSlider', label="Colour", rgb=(0.1, 0.1, 1))
    cmds.rowColumnLayout(numberOfColumns=2, columnWidth=[(1, 200), (2, 200)])
    _rgb = cmds.colorSliderGrp('cityColorSlider', query=True, rgbValue=True)
    cmds.button(label="Delete City",
                width=150,
                align='center',
                command='deleteCity()')
    cmds.button(label="Make City",
                width=150,
                align='center',
                command='getInput()')

    cmds.showWindow(cityWindow)
Example #47
0
	def _mixerGUI(self, currParent):
	
		frm = cmds.formLayout( parent=currParent )
		slider = cmds.floatSliderGrp( label="Main Offset", field=1,
		cc=changeVal, dc=changeVal, min=-10, max=10, step=.1 )
		btn1 = cmds.button( label="Reset", w=50,
					    c=self.resetSlider)
		btn2 = cmds.button( label="Offset", w=50)
		
		cmds.formLayout( frm, e=1, af=[[slider, "left", 5],[slider, "top", 0]])
		cmds.formLayout( frm, e=1, ac=[btn1, "left", 5, slider], af=[btn1, "top", 0])
		cmds.formLayout( frm, e=1, ac=[btn2, "left", 5, btn1], af=[btn2, "top", 0])
		
		return frm
Example #48
0
def ui():
    '''
    User interface for arc tracer
    '''

    globalScale = 1
    if mc.optionVar(exists='ml_arcTracer_brushGlobalScale'):
        globalScale = mc.optionVar(query='ml_arcTracer_brushGlobalScale')

    with utl.MlUi('ml_arcTracer', 'Arc Tracer', width=400, height=180, info='''Select objects to trace.
Choose camera space or worldspace arc.
Press clear to delete the arcs, or retrace to redo the last arc.''') as win:

        win.buttonWithPopup(label='Trace Camera', command=traceCamera, annotation='Trace an arc as an overlay over the current camera.',
                            shelfLabel='cam', shelfIcon='flowPathObj')#motionTrail
        win.buttonWithPopup(label='Trace World', command=traceWorld, annotation='Trace an arc in world space.',
                            shelfLabel='world', shelfIcon='flowPathObj')
        win.buttonWithPopup(label='Retrace Previous', command=retraceArc, annotation='Retrace the previously traced arc.',
                            shelfLabel='retrace', shelfIcon='flowPathObj')
        win.buttonWithPopup(label='Clear Arcs', command=clearArcs, annotation='Clear all arcs.',
                            shelfLabel='clear', shelfIcon='flowPathObj')
        fsg = mc.floatSliderGrp( label='Line Width', minValue=0.1, maxValue=5, value=globalScale)
        mc.floatSliderGrp(fsg, edit=True, dragCommand=partial(setLineWidthCallback, fsg))
Example #49
0
    def saveData(self, *args ):
        
        app_dir = mel.eval( 'getenv( "MAYA_APP_DIR" )' )+"/LocusCommPackagePrefs"

        path = app_dir+"/HSBVC_prefs/GUIDE.txt"
        
        values = []
        for slider in self._sliders:
            value = cmds.floatSliderGrp( slider[1], q=1, v=1 )
            values.append( str( value ) )
        
        fileTextSpace = open( path, 'w' )
        fileTextSpace.write( '|'.join( values ) )
        fileTextSpace.close()
Example #50
0
 def Tt_Rig_Button15(self):
     Curve = cmds.curve(
         d=1,
         p=[[
             -2.0837488086736507e-14, -1.1368964172363258,
             -15.958007537346161
         ], [-6.3960000000000008, 0.20310418167114488, -9.6197905645275146],
            [-3.1980000000000004, 0.20310418167114488, -9.6197905645275146],
            [-3.1980000000000004, 0.62313568725586166, -6.4225789164394245],
            [-3.1980000000000004, 0.8754559158325218, -3.2140993473991109],
            [
                -3.1980000000000004, 0.95960738983154525,
                1.8585436000170167e-05
            ],
            [-3.1980000000000004, 0.87544981613159412, 3.2141365563950823],
            [-3.1980000000000004, 0.62311738815307849, 6.4226149054683148],
            [-3.1980000000000004, 0.2030736831665062, 9.6198259435728648],
            [-6.3960000000000008, 0.2030736831665062, 9.6198259435728648],
            [
                -2.0837478605896728e-14, -1.1369391151428201,
                15.958039256490268
            ], [6.3960000000000008, 0.2030736831665062, 9.6198259435728648],
            [3.1980000000000004, 0.2030736831665062, 9.6198259435728648],
            [3.1980000000000004, 0.62311738815307849, 6.4226149054683148],
            [3.1980000000000004, 0.87544981613159412, 3.2141365563950823],
            [
                3.1980000000000004, 0.95960738983154525,
                1.8585436000170167e-05
            ],
            [3.1980000000000004, 0.8754559158325218, -3.2140993473991109],
            [3.1980000000000004, 0.62313568725586166, -6.4225789164394245],
            [3.1980000000000004, 0.20310418167114488, -9.6197905645275146],
            [6.3960000000000008, 0.20310418167114488, -9.6197905645275146],
            [
                -2.0837488086736507e-14, -1.1368964172363258,
                -15.958007537346161
            ]])
     Curve_Rename = cmds.rename(Curve, 'Double_Arrow_Arch')
     color = cmds.palettePort('color_set', q=True, setCurCell=True)
     if color > 0:
         cmds.setAttr(Curve_Rename + '.overrideEnabled', True)
         cmds.setAttr(Curve_Rename + '.overrideColor', color)
     scale = cmds.floatSliderGrp('ScaleSlider', q=True, value=True)
     cmds.xform(Curve_Rename, ws=True, s=[scale, scale, scale])
     cmds.makeIdentity(Curve_Rename,
                       apply=True,
                       t=False,
                       r=False,
                       s=True,
                       n=False)
Example #51
0
 def setCmd( self, winPointer, basePointer, *args ):
     
     sels = cmds.ls( sl=1 )
     
     surfs = winPointer.getSurfaceShapes( basePointer )
     
     constStart = cmds.floatSliderGrp( self._constStart , q=1, v=1 )
     consEnd    = cmds.floatSliderGrp( self._constEnd   , q=1, v=1 )
     applyUV    = cmds.checkBox( self._applyUV, q=1, v=1 )
     
     progress.start()
     progress.append( 'Cutting' )
     
     progress.setLength( len( surfs ) )
     
     for surf in surfs:
         progress.addCount()
         mainCmd.cutCurve( surf, constStart, consEnd, applyUV )
     
     progress.end()
         
     if sels:
         cmds.select( sels )
Example #52
0
	def __init__(self):
		self.blendShapeMesh = cmds.textFieldGrp('meshShapeText',query =True,text=True) 
		self.newNameBlendShape = cmds.textFieldButtonGrp('newNameText',query=True,text=True)
		self.tragetBlendShape = targetBlendShapeText()
		self.BlendShape = blendShapeNode(self.blendShapeMesh)
		self.ConnectBox = cmds.checkBox('ConnectBox',query = True,value=True)
		self.CreateBox = cmds.checkBox('CreateBox',query = True,value=True)
		self.HideBox = cmds.checkBox('HideBox',query = True,value=True)
		self.DeleteBox = cmds.checkBox('DeleteBox',query = True,value=True)

		self.targetInbetween= cmds.textScrollList('targetInbetweenText',query = True,si=True)
		self.InbetweenSlider = cmds.floatSliderGrp('InbetweenSlider',query=True,value =True)
		self.InbetweenField=cmds.floatField('InbetweenField',query=True,value=True)
		self.MirrorTargetText = cmds.textFieldButtonGrp('MirrorTargetText',tx=True,query=True)
Example #53
0
 def trgSldrDragCmd(cls, *args):
     trgSldrVal = cmds.floatSliderGrp(UI.widgets['trgFltSldrGrp'],
                                      q=True,
                                      v=True)
     selTrgList = cmds.textScrollList(UI.widgets['correctiveTrgTxtScrList'],
                                      q=True,
                                      selectItem=True)
     if selTrgList:
         for selTrg in selTrgList:
             try:
                 cmds.setAttr('{0}.{1}'.format(cls.bsNodeName, selTrg),
                              trgSldrVal)
             except:
                 pass
def convertsettogroom(*args):
    listSel = cmds.ls(sl=True)
    if listSel is None:
         cmds.warning('Please select a set')
    if len(listSel)==1:
        if cmds.objectType(listSel[0]) == 'objectSet':
            set = listSel[0]
            val = cmds.floatSliderGrp('subDivGroomSliderS_ui', q=True, v=True)
            mel.eval ('pgYetiConvertGuideSetToGroom("'+str(set)+'","'+objCurrent()+'",'+str(val)+')')
        else:
            cmds.warning('Select a set')
        
    else: 
         cmds.warning('Select only one set')         
Example #55
0
def updateRotate(undoState):
    global sel
    global win

    if undoState:
        for obj in sel: obj.getSavedRotate()
    mc.undoInfo( stateWithoutFlush=undoState)

    rRange = mc.floatSliderGrp( win.rRange, q=1, v=1)
    rScaleX, rScaleY, rScaleZ = mc.floatFieldGrp( win.rScale, q=1, v=1)
    for obj in sel: obj.setRotate( rRange, rScaleX, rScaleY, rScaleZ)

    if undoState:
        for obj in sel: obj.saveRotate()
Example #56
0
    def update(self, *args):
        color_val = cmds.floatSliderGrp(self.slider, q=1, v=1)

        for grade in Slider_button.grade_vals:
            if color_val < grade:
                self.grade_state = grade
                cmds.scrollField(self.info_area,
                                 e=1,
                                 text=self.grade_range[grade][-1])
                cmds.scrollField(self.info_area,
                                 e=1,
                                 bgc=self.grade_range[grade][0])

                break
Example #57
0
    def intensityIntSlider(self, *args):

        if (cmds.textScrollList(self.lightList, q=True,
                                selectItem=True)) is None:
            cmds.error('Nothing is Selected')
            return
        else:
            lightN = cmds.textScrollList(self.lightList,
                                         q=True,
                                         selectItem=True)[0]
            intensityLight = cmds.floatSliderGrp('Intensity',
                                                 q=True,
                                                 value=True)
            self.lmFunc.setLightIntensity(lightN, intensityLight)
Example #58
0
    def create(self):
        form = cmds.formLayout()
        slider = cmds.floatSliderGrp(**self.options)
        cmds.setParent('..')

        cmds.formLayout(form,
                        e=1,
                        af=[(slider, 'top', 0), (slider, 'left', 0),
                            (slider, 'right', 0)])

        self.form = form
        self.slider = slider

        return form
Example #59
0
    def radiusCmd(cls, *args):
        # cmds.select(cls.selCrvs)
        selLs = cmds.ls(sl=True)
        selCrvs = cls.getPathCrvFromPoly(selLs)
        radiusVal = cmds.floatSliderGrp(UI.widgets['radiusSldrGrp'],
                                        q=True,
                                        v=True)

        for crv in selCrvs:
            crvProfileShape = cmds.listRelatives('%s_profile' % (crv), s=True)
            crvProfileMakeNode = cmds.listConnections(crvProfileShape,
                                                      s=True,
                                                      d=False)[0]
            cmds.setAttr('%s.radius' % (crvProfileMakeNode), radiusVal)
Example #60
0
    def twistCmd(cls, *args):
        # cmds.select(cls.selCrvs)
        selLs = cmds.ls(sl=True)
        selCrvs = cls.getPathCrvFromPoly(selLs)
        twistVal = cmds.floatSliderGrp(UI.widgets['twistSldrGrp'],
                                       q=True,
                                       v=True)

        for crv in selCrvs:
            crvProfileShape = cmds.listRelatives('%s_profile' % (crv), s=True)
            extrudeNode = cmds.listConnections(crvProfileShape,
                                               s=False,
                                               d=True)[0]
            cmds.setAttr('%s.rotation' % (extrudeNode), twistVal)