Ejemplo n.º 1
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)
Ejemplo n.º 2
0
def update(*args) :
  # blindly update the settings and prepare everything other than the main loop itself
  distribution=cmds.intSliderGrp('distribution', q=True, value=True)
  samples=cmds.intSliderGrp('samples', q=True, value=True)
  budChance=cmds.floatSliderGrp('budChance', q=True, value=True)
  branchChance=cmds.floatSliderGrp('branchChance', q=True, value=True)
  leafChance=cmds.floatSliderGrp('leafChance', q=True, value=True)
  minStep=cmds.floatSliderGrp('minStep', q=True, value=True)
  maxStep=cmds.floatSliderGrp('maxStep', q=True, value=True)
  steps=cmds.intSliderGrp('steps', q=True, value=True)
  quadratic=cmds.checkBoxGrp('quadratic', q=True, v1=True)

  branchThick=cmds.floatSliderGrp('branchThick', q=True, value=True)
  leafSize=cmds.floatSliderGrp('leafSize', q=True, value=True)

  cmds.setAttr('fabricVegetation.distribution', distribution)
  cmds.setAttr('fabricVegetation.samples', samples)
  cmds.setAttr('fabricVegetation.budChance', budChance)
  cmds.setAttr('fabricVegetation.branchChance', branchChance)
  cmds.setAttr('fabricVegetation.leafChance', leafChance)
  cmds.setAttr('fabricVegetation.minStep', minStep)
  cmds.setAttr('fabricVegetation.maxStep', maxStep)
  cmds.setAttr('fabricVegetation.steps', steps)
  cmds.setAttr('fabricVegetation.quadratic', quadratic)

  cmds.setAttr('fabricVegetation.branchThick', branchThick)
  cmds.setAttr('fabricVegetation.leafSize', leafSize)
Ejemplo n.º 3
0
  def generate(cls, *args):
    components = []
    radius = cmds.intSliderGrp(cls.get_prefix() + Labels["radius_label"], query=True, value=True)
    height = cmds.intSliderGrp(cls.get_prefix() + Labels["height_label"], query=True, value=True)
    subdivs = cmds.intSliderGrp(cls.get_prefix() + Labels["subdivs_label"], query=True, value=True)
    rgb = cmds.colorSliderGrp(cls.get_prefix() + Labels["color_label"], query=True, rgbValue=True)
    wheel_radius = radius * Constants["wheel_radius_unit"]
    wheel_height = height * Constants["wheel_height_unit"]
    
    wheel_component = cmds.polyPipe(name=get_unique_name(cls.get_prefix(), "cylender"), sh=4, sc=subdivs, h=wheel_height, r=wheel_radius)
    wheel_extrusion_faces = []
    cmds.select(r=True)

    for i in range(0, subdivs):
      if i % 2 == 1:
        facet_title = wheel_component[0] + ".f[" + str(i) + "]"
        wheel_extrusion_faces.append(facet_title)

    #cmds.polyExtrudeFacet(wheel_extrusion_faces, ltz=Constants["wheel_ridge_depth"])
    cmds.delete(ch=1)
    cmds.lattice(wheel_component[0],divisions=[2,3,2], name=get_unique_name(cls.get_prefix(),"lattice"), cp=wheel_component[0])
    shader = cmds.shadingNode('blinn', asShader=True, name=get_unique_name(cls.get_prefix(),"mat"))
    cmds.setAttr(shader + ".color", rgb[0],rgb[1],rgb[2], type='double3')
    cmds.select(wheel_component[0], r=True)
    cmds.hyperShade(assign=shader)
Ejemplo n.º 4
0
def randomize(args):
    '''
    Randomizes the hue, saturation and value for both the start
    and the end of the colour range.
    
    args: Dummy argument needed to satisfy the command interface.
    On exit: Random values for hue, saturation and value have been
    picked for both the start and the end of the colour range. The 
    canvases and the sliders have been updated accordingly.
    '''
    rhue1 = random.randint(0,360)
    rsaturation1 = random.uniform(0,1)
    rvalue1 = random.uniform(0,1)
    rhue2 = random.randint(0,360)
    rsaturation2 = random.uniform(0,1)
    rvalue2 = random.uniform(0,1)
    cmds.intSliderGrp("hue1", edit = True, value = rhue1)
    cmds.floatSliderGrp("saturation1", edit = True, value = rsaturation1)
    cmds.floatSliderGrp("value1", edit = True, value = rvalue1)
    cmds.canvas("hueCanvas1", edit = True, hsvValue = (rhue1,1,1))
    cmds.canvas("saturationCanvas1", edit = True, hsvValue = (rhue1, rsaturation1,1))    
    cmds.canvas("valueCanvas1", edit = True, hsvValue = (rhue1, rsaturation1,rvalue1)) 
    cmds.intSliderGrp("hue2", edit = True, value = rhue2)
    cmds.floatSliderGrp("saturation2", edit = True, value = rsaturation2)
    cmds.floatSliderGrp("value2", edit = True, value = rvalue2)
    cmds.canvas("hueCanvas2", edit = True, hsvValue = (rhue2,1,1))
    cmds.canvas("saturationCanvas2", edit = True, hsvValue = (rhue2, rsaturation2,1))    
    cmds.canvas("valueCanvas2", edit = True, hsvValue = (rhue2, rsaturation2,rvalue2)) 
Ejemplo n.º 5
0
def unfoldBand_window():
	"""
	This definition creates the 'Unfold Band' main window.
	"""

	cmds.windowPref(enableAll=False)

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

	cmds.window("unfoldBand_window",
		title="Unfold Band",
		width=384)

	spacing = 5

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

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

	cmds.intSliderGrp("divisions_intSliderGrp", label="Divisions", field=True, minValue=0, maxValue=10, fieldMinValue=0, fieldMaxValue=65535, value=2)

	cmds.separator(style="single")

	cmds.columnLayout(columnOffset=("left", 140))
	cmds.checkBox("keepConstructionHistory_checkBox", label="Keep Construction History", v=True)
	cmds.setParent(topLevel=True)

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

	cmds.button("unfoldBand_button", label="Unfold Band!", command=unfoldBand_button_OnClicked)

	cmds.showWindow("unfoldBand_window")

	cmds.windowPref(enableAll=True)
    def bulge_button( self, *args  ):
        if( cmds.objExists( "ZBend" ) ):
            cmds.confirmDialog( title="Error", message="First delete the bulge history on the previously\ndeformed object before bulging another.", button="Okie Dokie" )
            return 0

        latestSelection = cmds.ls( selection=True )
        if( len( latestSelection ) == 0 ):
            return 0

        if( len( latestSelection ) == 1 ):
            self.relatives = cmds.listRelatives( children=True )

            if( len(self.relatives) == 1 ):
                self.bbox = cmds.exactWorldBoundingBox( latestSelection )

                cmds.nonLinear( type='bend', curvature=cmds.intSliderGrp( "x_bulge_slider", value=True, query=True ) )
                cmds.rename( "XBend" )
                cmds.move((self.bbox[0] + self.bbox[3])/2, self.bbox[1], (self.bbox[2] + self.bbox[5])/2, "XBend", rpr=True )
                cmds.setAttr( "XBend.rotateZ", -90 )

                cmds.select( latestSelection )

                cmds.nonLinear( type='bend', curvature=cmds.intSliderGrp( "z_bulge_slider", value=True, query=True ) )
                cmds.rename( "ZBend" )
                cmds.move((self.bbox[0] + self.bbox[3])/2, self.bbox[1], (self.bbox[2] + self.bbox[5])/2, "ZBend", rpr=True )
                cmds.setAttr( "ZBend.rotateZ", -90 )
                cmds.setAttr( "ZBend.rotateX", 90 )
                cmds.connectControl( "x_bulge_slider", "bend1.curvature" )
                cmds.connectControl( "z_bulge_slider", "bend2.curvature" )
                cmds.select( latestSelection )
Ejemplo n.º 7
0
  def generate(cls, *args):
    components = []
    width = cmds.intSliderGrp(cls.get_prefix() + Labels["width_label"], query=True, value=True)
    height = cmds.intSliderGrp(cls.get_prefix() + Labels["height_label"], query=True, value=True)
    depth = cmds.intSliderGrp(cls.get_prefix() + Labels["depth_label"], query=True, value=True)
    rgb = cmds.colorSliderGrp(cls.get_prefix() + Labels["color_label"], query=True, rgbValue=True)

    block_width = width * Constants["block_width_unit"]
    block_height = height * Constants["block_height_unit"]
    block_depth = depth * Constants["block_depth_unit"]

    #stubs
    for x in range(0, width):
      for z in range(0, depth):
        stub = cmds.polyCylinder(name=get_unique_name(cls.get_prefix(), "Stub"), radius=Constants["stub_radius"], height = Constants["stub_height"])
        components.append(stub[0])
        cmds.move(Constants["block_width_unit"] * x + half(Constants["block_width_unit"]), half(Constants["block_height_unit"]) * height + half(Constants["stub_height"]), Constants["block_depth_unit"] * z + half(Constants["block_depth_unit"]), stub[0])

    cube = cmds.polyCube(name=get_unique_name(cls.get_prefix(), "block"), width=block_width, height=block_height, depth=block_depth)
    components.append(cube[0])
    cmds.move(half(width * Constants["block_width_unit"]), 0, half(depth * Constants["block_depth_unit"]), cube)
    if components.count > 1:
      final = cmds.polyUnite(components, name=get_unique_name(cls.get_prefix(), ""))
    else:
      final = components[0]

    shader = cmds.shadingNode('blinn', asShader=True, name=get_unique_name(cls.get_prefix(),"mat"))
    cmds.setAttr(shader + ".color", rgb[0],rgb[1],rgb[2], type='double3')
    cmds.select(final[0], r=True)
    cmds.hyperShade(assign=shader)
def myCube():
    myCubeWidth = mc.intSliderGrp( cubW, q=True, v=True )
    myCubeHigth = mc.intSliderGrp( cubH, q=True, v=True )
    myCubeDepth = mc.intSliderGrp( cubD, q=True, v=True )
    # ch stands for construction history
    finalCube = mc.polyCube( w=myCubeWidth, h=myCubeHigth, d=myCubeDepth, n="myCube#", ch=False )
    mc.move( 0,myCubeHigth/2.0,0, finalCube, relative=True ) 
Ejemplo n.º 9
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))
Ejemplo n.º 10
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)
Ejemplo n.º 11
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)
Ejemplo n.º 12
0
	def __init__(self) :
		# get the currently selected objects and make sure we have only one object
		selected = OM.MSelectionList()
		OM.MGlobal.getActiveSelectionList(selected)
		self.selectedObjects = []
		selected.getSelectionStrings(self.selectedObjects)
		if len(self.selectedObjects) == 0 :
			cmds.confirmDialog( title='No objects Selected', message='Select a Mesh Object', button=['Ok'], defaultButton='Ok', cancelButton='Ok', dismissString='Ok' )
		elif len(self.selectedObjects) > 1 :
			cmds.confirmDialog( title='Select One Object', message='Only One Mesh mat be exported at a time', button=['Ok'], defaultButton='Ok', cancelButton='Ok', dismissString='Ok' )
		# now we have the correct criteria we can proceed with the export
		else :
			# get the start and end values for our UI sliders
			anim=OMA.MAnimControl()
			minTime=anim.minTime()
			maxTime=anim.maxTime()
			self.m_start=int(minTime.value())
			self.m_end=int(maxTime.value())
			# now we create a window ready to populate the components
			self.m_window = cmds.window( title='NCCA Pointbake Export' )
			# create a layout
			cmds.columnLayout()
			# create two sliders for start and end we also attach methods to be called when the slider
			# changes
			self.m_startSlider=cmds.intSliderGrp( changeCommand=self.startChanged,field=True, label='Start Frame', minValue=self.m_start, maxValue=self.m_end, fieldMinValue=self.m_start, fieldMaxValue=self.m_end, value=self.m_start )
			self.m_endSlider=cmds.intSliderGrp( changeCommand=self.endChanged ,field=True, label='End Frame', minValue=self.m_start, maxValue=self.m_end, fieldMinValue=self.m_end, fieldMaxValue=self.m_end, value=self.m_end )
			# create a button and add the method called when pressed
			cmds.button( label='Export', command=self.export )
			# finally show the window
			cmds.showWindow( self.m_window )
Ejemplo n.º 13
0
def windowUI(*args):

	if cmds.window("windowUI", exists=True):
		cmds.deleteUI("windowUI")
	cmds.window("windowUI", title="Bedazzler", resizeToFitChildren = True, sizeable = False)

	# base object layout
	cmds.frameLayout(label = "General", collapsable=False, mw=5, mh=5)
	cmds.rowColumnLayout(nc=3, cal=[(1,"right")], cw=[(1,80),(2,200),(3,95)])
	

	cmds.text(l="Base Object: ")
	cmds.textField("baseObject")
	cmds.button("baseObjectButton", l="Select", c=selectBaseObjectButton)
	
	cmds.setParent("..")
	cmds.separator(h=10, st='in')

	# # info button
	# cmds.button("infoButton", l="INFO", w=75, al="center", c=infoButton)

	# reset button
	cmds.button("resetButton", l="Reset Values", w=75, al="center", c=windowUI)

	# size
	cmds.rowColumnLayout(w=380)
	cmds.floatSliderGrp("size", l="Gem Size: ", v=.25, min=0.001, max=1.0, f=True,w=370,pre=3)

	# padding
	cmds.rowColumnLayout(w=380)
	cmds.floatSliderGrp("padding", l="Spacing: ", v=0, min=0.0, max=1.0, f=True,w=370,pre=3)
	
	cmds.rowColumnLayout(w=380)
	cmds.floatSliderGrp("overlap", l="Overlap Tolerance: ", v=0, min=0.0, max=1.0, f=True,w=370,pre=3)
	
	cmds.separator(h=10, st='in')
		
	#smoothe
	cmds.rowColumnLayout(w=380)
	cmds.floatSliderGrp("smoothe", l="Smooth mesh: ", v=0, min=0.0, max=1.0, f=True,w=370,pre=3)

	# reduce mesh
	cmds.rowColumnLayout(w=380)
	cmds.intSliderGrp("meshReduce", l="% to reduce mesh: ", v=0, min=0, max=100, f=True,w=370)
	
	#shade
	cmds.checkBox("shaderCheckBox", l='Include shader', value=False)

	
	# # text
	# cmds.text(l='\nINFO\n', w=370, ww=True)
	# cmds.text(l='The algorithm works best on objects with planar quads that are not too small in any one dimension.\n', w=370, al = 'left', ww=True)
	# cmds.text(l='If your mesh has a lot of fine geometry, it is recommended that you use a poly-reduced mesh using the slider above. This will not modify your original geometry.', w=370,  al = 'left', ww=True)
	cmds.separator(h=10, st='in')

	# bedazzle button
	cmds.button("bedazzleButton", l="~*~BEDAZZLE~*~", w=370, h = 40, al="center", bgc=[0.14,0.94,0.86], c=bedazzleButton)

	cmds.showWindow("windowUI")
Ejemplo n.º 14
0
 def byNumSpansCmd(self, *args ):
     
     value = cmds.checkBox( self._byNumSpans, q=1, v=1 )
     
     if value:
         cmds.intSliderGrp( self._outerNumCurve, e=1, en=0 )
     else:
         cmds.intSliderGrp( self._outerNumCurve, e=1, en=1 )
Ejemplo n.º 15
0
	def main(self, *args):

		'''

		This method will be the main function of the tool letting the
		user generate random values for the color set 2.

		'''

		selected_obj = cmds.ls(selection=True)

		#Warning message for no selection
		if not selected_obj:

			cmds.confirmDialog(
									title="Error Message",
									message="No objects selected. Must select one object!",
									button="Accept"
								)
			return False

		color_sets = cmds.polyColorSet(query=True, allColorSets=True)

		#Warning message for no current color sets
		if not color_sets:

			cmds.confirmDialog(
									title="Error Message",
									message="Must create color set two!",
									button="Accept"
								)
			return False

		#If statement generates random values based on the users input for Minimum and Maximum sliders
		if "colorSet2" in color_sets:

			for index in xrange(cmds.polyEvaluate(selected_obj[0], vertex=True)):

				#slider values
				min_value = cmds.intSliderGrp("minimum", query=True, value=True)
				max_value = cmds.intSliderGrp("maximum", query=True, value=True)

				generate_value = rand.randint(min_value, max_value)
				color_value = generate_value/100.00

				color_set = cmds.polyColorPerVertex(
														"{object}.vtx[{number}]".format(object=selected_obj[0], number=index),
														rgb=( color_value, color_value, color_value)
													)
		#Error Message if colorSet2 does not exist
		else:

			cmds.confirmDialog(
									title="Error Message",
									message="Must create color set two!",
									button="Accept"
								)
			return False
def brickHeightToggle():
    flatBrick = cmds.checkBox('flatBrickCheck', query = True, value = True)
    
    if( flatBrick == True ):
        cmds.intSliderGrp( 'brickHeight', edit = True, value = 1, enable = False)
        cmds.radioButtonGrp( 'brickHoleOptions', edit = True, select = 3, enable = False)
    elif( flatBrick == False ):
        cmds.intSliderGrp( 'brickHeight', edit = True, enable = True )
        cmds.radioButtonGrp( 'brickHoleOptions', edit = True, enable = True)
def tf_buttonCmd():
    
    #set the selection type for the selectedJoint array to joint only...
    selectedJoint = cmds.ls(selection=True, type='joint')
    #if we've selected any joints
    if len(selectedJoint) > 0:
        #do all of this stuff...
        colorIndex = cmds.colorIndexSliderGrp( colorSlider, query = True, value = True)
        
        dummySizeW = cmds.intSliderGrp(sizeSliderW, query = True, value = True)
        dummySizeD = cmds.intSliderGrp(sizeSliderD, query = True, value = True)
        
        subdivs = cmds.radioButtonGrp(dummyRadio, query= True, sl= True)
        
        
        #check if we have the prefix enabled
        if cmds.checkBox(lockPrefixText, query= True, value = True) == 1 :
            prefix = cmds.textField(dummyPrefix, query = True, tx= True)
        else:
            prefix = ""
        #check if we have the suffix text enabled
        if cmds.checkBox(lockSuffixText, query= True, value = True) == 1 :
            suffix = cmds.textField(dummySuffix, query = True, tx= True)
        else:
            suffix = ""
        
        
        allDisplayLayers = cmds.ls(type = 'displayLayer')
        dummyLayer = 'DummyLayer'
        #check if we have the DummyLayer
        doLayer = tf_findDupeLayer(dummyLayer,allDisplayLayers)
        #if not... make it
        if doLayer == 0:
            tf_createLayer(dummyLayer, colorIndex)
            
        #if they want joint and all children
        if cmds.radioButtonGrp( jointRadio, query=True, sl=True ) == 1 :
            
            allDescendants_SA = tf_listChain( selectedJoint )
            #do the dummy on the root joint
            tf_doTheDummy( selectedJoint[0], colorIndex, dummySizeW, dummySizeD, subdivs, prefix, suffix)
            #now iterate through the whole joint chain
            for eachJoint in allDescendants_SA:
                
                tf_doTheDummy( eachJoint, colorIndex, dummySizeW, dummySizeD, subdivs, prefix, suffix)
                
                
        #if they want selected joint   
        if cmds.radioButtonGrp( jointRadio, query=True, sl=True ) == 2:
    
            tf_doTheDummy( selectedJoint[0], colorIndex, dummySizeW, dummySizeD, subdivs, prefix, suffix)
            
    #if we don't have any selected joints... return warning to console
    else:
        cmds.warning("Select joint(s) then press 'Create'")
Ejemplo n.º 18
0
def changeMinHeight(args):
    '''
    Changes the minimum house height if it is larger than the maximum house height.
    
    args: Dummy argument needed to satisfy the command interface.
    On exit: If the value of "minHeight" was larger than the value of 
             "maxHeight", "minHeight" has been changed to have the same value
             as "maxHeight".
    '''
    minHeight = cmds.intSliderGrp("minHeight", query = True, value = True)
    maxHeight = cmds.intSliderGrp("maxHeight", query = True, value = True)
    if minHeight > maxHeight:
        cmds.intSliderGrp("minHeight", edit = True, value = maxHeight)
Ejemplo n.º 19
0
 def generate(cls, *args):
   
   before_kink = cmds.intSliderGrp(cls.get_prefix() + Labels["before_kink_label"], query=True, value=True)
   after_kink = cmds.intSliderGrp(cls.get_prefix() + Labels["after_kink_label"], query=True, value=True)
   rgb = cmds.colorSliderGrp(cls.get_prefix() + Labels["color_label"], query=True, rgbValue=True)
   before = cls.generate_kink_peice(before_kink)
   after = cls.generate_kink_peice(after_kink)
   cmds.rotate(0,0,'90deg', after[0])
   final = cmds.polyUnite(before[0], after[0])
   shader = cmds.shadingNode('blinn', asShader=True, name=get_unique_name(cls.get_prefix(),"mat"))
   cmds.setAttr(shader + ".color", rgb[0],rgb[1],rgb[2], type='double3')
   cmds.select(final[0], r=True)
   cmds.hyperShade(assign=shader)
Ejemplo n.º 20
0
    def actionBtnCmd(self, intSliderGrp1, intSliderGrp2, checkbox1, *args):
        multipleFilters = "Maya Files (*.ma *.mb);;Maya ASCII (*.ma);;Maya Binary (*.mb)"
        outputFile = cmds.fileDialog2(fileFilter=multipleFilters,
                         fileMode=0,
                         dialogStyle=2,
                         caption="Save Output File As")[0]
        gridSpacing = cmds.intSliderGrp(intSliderGrp1, query=True, value=True)
        gridWidth = cmds.intSliderGrp(intSliderGrp2, query=True, value=True)
        createInstructions = cmds.checkBox(checkbox1, query=True, value=True)

        cmds.deleteUI(self.window, window=True)
        exporter = bamboo.exporter.Exporter(gridSpacing, gridWidth, createInstructions)
        exporter.export(outputFile)
Ejemplo n.º 21
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))    
Ejemplo n.º 22
0
def changeMinWidth(args):
    '''
    Changes the minimum house width so that it is at least 10 units smaller 
    than the maximum house height.
    
    args: Dummy argument needed to satisfy the command interface.
    On exit: If the value of "minWidth" was less than ten units smaller than 
             the value of "maxWidth", "minWidth" has been changed to be ten 
             units smalle than "maxWidth"
    '''
    minWidth = cmds.intSliderGrp("minWidth", query = True, value = True)
    maxWidth = cmds.intSliderGrp("maxWidth", query = True, value = True)
    if minWidth > (maxWidth - 10):
        cmds.intSliderGrp("minWidth", edit = True, value = maxWidth - 10)
Ejemplo n.º 23
0
def keyDown(*args):
    
    selected = cmds.ls(sl=1, dag=1)
    if not selected:
        cmds.error("Please select an animatable object")
        return 

    distance = cmds.intSliderGrp('distance', query=True, value=True)
    key_rate = cmds.intSliderGrp('key_rate', query=True, value=True)

    currentTime = cmds.currentTime(query=True)
    cmds.currentTime(currentTime + key_rate, edit=True)
    cmds.move(0, 0, distance, r=True)
    cmds.setKeyframe()
Ejemplo n.º 24
0
	def buildWindow( self ):
		self.window = cmds.window( title="Submit to Farm", iconName='Render', widthHeight=(387, 450) )
		
		cmds.columnLayout(rowSpacing=20, columnOffset=['both',20] )
		
		cmds.setParent("..")
		
		cmds.rowColumnLayout( numberOfColumns=2, columnAttach=(1, 'right', 0), columnWidth=[(1, 100), (2, 250)] )
		
		
		# render globals
		cmds.text( label = 'Job Name' )
		self.ui.jobname = cmds.textField()
		
		cmds.text( label = 'Render Name' )
		self.ui.rendername = cmds.textField()
		
		cmds.text( label = 'Frame Range' )
		self.ui.framerange = cmds.textField()
		
		cmds.text( label = 'Chunk Size' )
		self.ui.chunksize = cmds.intSliderGrp( field=True, maxValue=100, step=15,fieldStep=15,sliderStep=15 )
		
		cmds.text( label = 'Threads' )
		self.ui.threads = cmds.intSliderGrp( field=True, minValue=1, maxValue=16, fieldStep=2, value=8 )
		
		cmds.text( label = '' )
		self.ui.globals = cmds.button( label='Open Render Settings')
		
		# select the layers to render
		cmds.text( label = 'Render Layers' )
		self.ui.renderlayers = cmds.textScrollList( numberOfRows=8, allowMultiSelection=True,  append=['default'], selectItem='default', showIndexedItem=1 )
				
		cmds.text( label = '' )
		self.ui.refresh = cmds.button( label='refresh' )
		
		
		# general options for the render manager
		cmds.text( label = 'Options' )
		self.ui.options = cmds.checkBoxGrp( numberOfCheckBoxes=2, labelArray2=['Check Outputs', 'Generate Quicktime'] )
		cmds.text( label = 'Process' )
		self.ui.process = cmds.radioButtonGrp( labelArray4=['Light', 'Medium', 'Heavy', 'Sumo'], select=2, numberOfRadioButtons=4, columnWidth4=[60,60,60,60] )
		
		cmds.setParent("..")
		
		
		# render button
		cmds.columnLayout( columnOffset=['both',20] )
		self.ui.render = cmds.button( label='Render', width=330, height=50 )
Ejemplo n.º 25
0
	def render( self, clicked ):
		self.jobname = cmds.textField( self.ui.jobname, query=True, text=True )
		self.rendername = cmds.textField( self.ui.rendername, query=True, text=True )
		self.framerange = cmds.textField( self.ui.framerange, query=True, text=True )
		self.chunksize = cmds.intSliderGrp( self.ui.chunksize, query=True, value=True )
		self.threads = cmds.intSliderGrp( self.ui.threads, query=True, value=True )
		self.checkoutput =  cmds.checkBoxGrp( self.ui.options, query=True, value1=True )
		self.quicktime =  cmds.checkBoxGrp( self.ui.options, query=True, value2=True )
		self.weight =  cmds.radioButtonGrp( self.ui.process, query=True, select=True )
		self.projectpath = cmds.workspace(q=True,fn=True)
				
		self.username = getpass.getuser()
		self.timestamp = int( time.time() )  
			
		if self.rendername.find( "[not set; using scene name]" ) >= 0:
			if not cmds.file( query=True, sceneName=True ):
				self.rendername = "MayaRender-%s" % self.username
			else:
				scenepath = cmds.file( query=True, sceneName=True )
				self.rendername = scenepath.split("/")[-1].split(".")[0]
				
		
		try:
			spooldir = "/mnt/muxfs/users/%s/spool" % self.username  # should be built from a template in cfg
			if not os.path.exists( spooldir ):
				os.makedirs( spooldir )
		except:
			print "Warning. Attempt to create spool directory %s failed" % spooldir
					
		filename = "maya-%s-%s.ma" % ( self.username, self.timestamp )
		filepath = os.path.join( spooldir, filename )
		
		try:
			cmds.file( rename=filepath )
			cmds.file( save=True, type='mayaAscii' )
		except:
			cmds.confirmDialog( title='Error', message='Error, unable to save scene to %s'%filepath)
		finally:
			cmds.file( rename=self.sceneInfo['SceneName'] )
		
		maya_args   = {  "type":"Maya", "threads":self.threads, "file":filepath, "layers":self.selectedLayers() }    
		render_args = { "range":self.framerange,  "chunksize":self.chunksize, "timestamp":self.timestamp, "name":self.rendername,  "user":self.username,
						"quicktime":self.quicktime, "weight":self.weight , "check":self.checkoutput, "title":self.jobname, "projectpath":self.projectpath }

		print render_args
		print maya_args
			
		launchRender( render_args, maya_args )  
def createUI():
    
    #cmds.select(all=True)
    #cmds.delete()
    
    prevRot=[0,0,0]
    prevPos=[0,0,0]

    if cmds.window('LSys', exists=True):
        cmds.deleteUI("LSys")
        print 'deleted window'
    
    cmds.window("LSys")    
    
    #    Create a window with two separate radio button groups.        
    cmds.columnLayout()
    axesRadio = cmds.radioButtonGrp( label='Rotation About Axis', labelArray3=['X', 'Y', 'Z'], numberOfRadioButtons=3, onCommand = lambda *args: setRotAxis(cmds.radioButtonGrp(axesRadio, query=True, sl=True)) )    
    
    angleSlider = mc.intSliderGrp('angle',field=True, label='Angle of rotation', minValue=-180, maxValue=180,value=0, changeCommand = lambda *args: setAngle(cmds.intSliderGrp(angleSlider, query=True, value=True)) )
    #print 'generic angle'+str(genericLSysAngle)
    cmds.button(label = "Create Branch", command = lambda *args: createABranch(rotAxis, genericLSysAngle) )
    
    cmds.button(label = "Push-Store branch's Root position and rotation ", command = lambda *args: push() )
    cmds.button(label = "Pop-Use and remove branch's Root position and rotation ", command = lambda *args: pop() )
    
    cmds.showWindow()
Ejemplo n.º 27
0
 def Run(self):
     Hyperbola = mc.textFieldGrp(self.Hyperbola,q=1,tx=1)
     JntNumber = mc.intSliderGrp(self.JntNumber,q=1,v=1)
     setCV = mc.ls(sl=1)
     CvBase = mc.rename(setCV[0],Hyperbola+'_hyperbola_cv_base')
     CvTgt = mc.rename(setCV[1],Hyperbola+'_hyperbola_cv_Tgt')
     self.CurveInfo(Hyperbola,CvBase,CvTgt,JntNumber)
Ejemplo n.º 28
0
def uniformRebuildCurveUI():
	'''
	UI for uniformRebuild()
	'''
	# Window
	window = 'uniformRebuildCurveUI'
	if mc.window(window,q=True,ex=1): mc.deleteUI(window)
	window = mc.window(window,t='Uniform Rebuild Curve')
	
	# Layout
	cl = mc.columnLayout()
	# Curve
	curveTFB = mc.textFieldButtonGrp('uniformRebuildCurveTFB',label='Source Curve',text='',buttonLabel='Load Selected')
	# Prefix
	prefixTFG = mc.textFieldGrp('uniformRebuildCurvePrefixTFG',label='Prefix',text='')
	# Replace Original
	replaceCBG = mc.checkBoxGrp('uniformRebuildCurveReplaceCBG',numberOfCheckBoxes=1,label='Replace Original',v1=False)
	# Spans
	spanISG = mc.intSliderGrp('uniformRebuildCurveSpansISG',field=True,label='Rebuild Spans',minValue=2,maxValue=10,fieldMinValue=2,fieldMaxValue=100,value=6)
	
	# Buttons
	createB = mc.button('uniformRebuildCurveCreateB',l='Create',c='glTools.ui.curve.uniformRebuildCurveFromUI(False)')
	createCloseB = mc.button('uniformRebuildCurveCreateCloseB',l='Create and Close',c='glTools.ui.curve.uniformRebuildCurveFromUI(True)')
	cancelB = mc.button('uniformRebuildCurveCancelB',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)
Ejemplo n.º 29
0
 def addControlerToCurveCmd(self, winPointer, basePointer, *args ):
     
     sels = cmds.ls( sl=1 )
     
     baseMesh = cmds.textField( basePointer._baseMesh, q=1, tx=1 )
     surfs = winPointer.getSurfaceShapes( basePointer )
     
     controlerNum = cmds.intSliderGrp( self._controlerNum, q=1, v=1 )
     
     progress.start()
     progress.append( 'N Hair' )
     
     progress.setLength( len( surfs ) )
     
     if cmds.checkBox( self._addControler, q=1, v=1 ):
         for surf in surfs:
             progress.addCount()
             mainCmd.allSet( surf, baseMesh, True, controlerNum )
     else:
         for surf in surfs:
             progress.addCount()
             mainCmd.allSet( surf, baseMesh, False )
     
     progress.end()
         
     if sels:
         cmds.select( sels )
Ejemplo n.º 30
0
def edgeLoopCurveUI():
	'''
	UI for edgeLoopCurve()
	'''
	# Window
	window = 'edgeLoopCurveUI'
	if mc.window(window,q=True,ex=1): mc.deleteUI(window)
	window = mc.window(window,t='Edge Loop Curve')
	
	# Layout
	CL = mc.columnLayout()
	# Prefix
	prefixTFG = mc.textFieldGrp('edgeLoopCurvePrefixTFG',label='Prefix',text='')
	# Rebuild
	rebuildCBG = mc.checkBoxGrp('edgeLoopCurveRebuildCBG',numberOfCheckBoxes=1,label='Rebuild Curve',v1=True)
	# Span Count
	spanISG = mc.intSliderGrp('edgeLoopCurveSpanISG',field=True,label='Rebuild Spans',minValue=0,maxValue=10,fieldMinValue=0,fieldMaxValue=100,value=0,en=1)
	
	# Toggle UI element
	mc.checkBoxGrp('edgeLoopCurveRebuildCBG',e=True,cc='mc.intSliderGrp("edgeLoopCurveSpanISG",e=1,en=(not mc.intSliderGrp("edgeLoopCurveSpanISG",q=1,en=1)))')
	
	# Buttons
	createB = mc.button('edgeLoopCurveCreateB',l='Create',c='glTools.ui.curve.edgeLoopCurveFromUI(False)')
	createCloseB = mc.button('edgeLoopCurveCreateCloseB',l='Create and Close',c='glTools.ui.curve.edgeLoopCurveFromUI(True)')
	cancelB = mc.button('edgeLoopCurveCancelB',l='Cancel',c='mc.deleteUI("'+window+'")')
	
	# Show Window
	mc.showWindow(window)
Ejemplo n.º 31
0
def armoire():

    # planche_height = 5
    # planche_width = 0.15
    # planche_depth = 4
    # module_width = 4
    # number_modules = 3
    planche_height = cmds.intSliderGrp(slider1, q=True, value=True)
    planche_width = cmds.floatSliderGrp(slider2, q=True, value=True)
    planche_depth = cmds.intSliderGrp(slider3, q=True, value=True)
    module_width = cmds.intSliderGrp(slider4, q=True, value=True)
    number_modules = cmds.intSliderGrp(slider5, q=True, value=True)

    #estos dos valores deben ser iguales
    number_tiroir = 3.0
    tiroir = 3

    #group MODULE
    mir = random.randint(0, 19)
    crazyR = random.randint(0, 1000)
    mName = 'MODULE' + str(mir) + str(crazyR)
    tName = 'TIROIR' + str(mir) + str(crazyR)
    dName = 'MEUBLE_DOWN' + str(mir) + str(crazyR)
    cmds.group(n=mName, em=True)
    cmds.group(n=tName, em=True)
    cmds.group(n=dName, em=True)

    #tiroir

    tiroirPorte = cmds.polyCube(h=(planche_height / number_tiroir),
                                w=module_width + planche_width,
                                depth=planche_width * 2.0)
    cmds.polyBevel3(offset=0.03)

    tiroirLat = cmds.polyCube(h=(planche_height / number_tiroir) / 1.5,
                              w=planche_width,
                              depth=planche_depth)
    cmds.move(-module_width / 2.0 + planche_width, 0, -planche_depth / 2.0)
    cmds.polyBevel3(offset=0.02)

    tiroirLatDos = cmds.polyCube(h=(planche_height / number_tiroir) / 1.5,
                                 w=planche_width,
                                 depth=planche_depth)
    cmds.move(module_width / 2.0 - planche_width, 0, -planche_depth / 2.0)
    cmds.polyBevel3(offset=0.02)

    tiroirBase = cmds.polyCube(h=planche_width,
                               w=module_width,
                               depth=planche_depth)
    cmds.move(0, (-planche_height / number_tiroir) / 4.0, -planche_depth / 2.0)
    cmds.polyBevel3(offset=0.02)

    tiroirAtras = cmds.polyCube(h=(planche_height / number_tiroir) / 1.5,
                                w=module_width,
                                depth=planche_width)
    cmds.move(0, 0, -planche_depth)
    cmds.polyBevel3(offset=0.02)

    # cmds.parent('tiroirporte_'+str(i),'tiroirLat1_'+str(i),'tiroirLat2_'+str(i),'tiroiratras_'+str(i),'tiroirBase_'+str(i),'TIROIR')
    cmds.parent(tiroirPorte, tiroirLat, tiroirLatDos, tiroirAtras, tiroirBase,
                tName)
    cmds.move(0, (planche_height / number_tiroir) / 2.0, planche_depth / 2.0,
              tName)

    for i in range(1, tiroir):
        tNameD = cmds.instance(tName)
        cmds.move(
            0,
            i * (planche_height / number_tiroir) +
            (planche_height / number_tiroir) / 2, planche_depth / 2.0, tNameD)
        # cmds.parent(tNameD[i],mName, relative=True)

    cmds.parent(tName, mName, relative=True)

    #laterales
    for i in range(0, 2):
        planche = cmds.polyCube(h=planche_height,
                                w=planche_width,
                                depth=planche_depth)
        cmds.polyBevel3(offset=0.02)
        cmds.move(-i * module_width + module_width / 2.0, planche_height / 2.0,
                  0)
        cmds.parent(planche, mName, relative=True)
    #superior - inferior
    for i in range(0, 2):
        placheUpDown = cmds.polyCube(h=planche_width,
                                     w=module_width,
                                     depth=planche_depth)
        cmds.polyBevel3(offset=0.02)
        cmds.move(0, i * planche_height, 0)
        cmds.parent(placheUpDown, mName, relative=True)

    #respaldo
    respaldo = cmds.polyCube(h=planche_height,
                             w=module_width,
                             depth=planche_width)
    cmds.polyBevel3(offset=0.02)
    cmds.move(0, planche_height / 2.0, -planche_depth / 2.0)
    cmds.parent(respaldo, mName, relative=True)

    #superior

    plancheSuperior = cmds.polyCube(h=planche_width * 2.0,
                                    w=module_width * number_modules +
                                    planche_width * 6.0,
                                    depth=planche_depth + 1.0)
    cmds.polyBevel3(offset=0.02)
    cmds.move((module_width * number_modules) / 2.0 - (module_width / 2.0) +
              planche_width, (planche_height) + planche_width * 2, 0)
    cmds.parent(plancheSuperior, dName, relative=True)

    for i in range(1, number_modules):
        modulesDuplicate = cmds.instance(mName)
        cmds.move(i * (module_width + planche_width), 0, 0, modulesDuplicate)
        cmds.parent(modulesDuplicate, dName, relative=True)

    cmds.parent(mName, dName, relative=True)
Ejemplo n.º 32
0
 def DoLocators(self, void):
     _spineCount = base.intSliderGrp(self.spineCount, q=True, v=True)
     _fingerCount = base.intSliderGrp(self.fingerCount, q=True, v=True)
     _doubleElbow = base.checkBox(self.doubleElbow, q=True, v=True)
     Locators.CreateLocators(_spineCount, _fingerCount, _doubleElbow)
Ejemplo n.º 33
0
 def dummyCommand(_):  #function nested inside
     print(cmds.intSliderGrp(bodySliderGrp, query=True, value=True))
Ejemplo n.º 34
0
    cmds.select(cl=True)


#ImagesPaths
imagePath = cmds.internalVar(usd=True)
Path = imagePath + 'RdMTools/'
Icons = Path + 'icons/'

#Window

cmds.window("AutoSpine", width=250, title="AutoSpine", toolbox=True)
cmds.columnLayout(adjustableColumn=True)
cmds.separator(h=20)
locatorNum = cmds.intSliderGrp(l='Spine joints: ',
                               min=3,
                               max=10,
                               field=True,
                               v=5,
                               hlc=(0.8, 0.2, 0.5))
cmds.separator(h=10)
cmds.symbolButton(image=Icons + 'Locator.png', c=LocatorsBtn)
cmds.separator(h=10)
cmds.symbolButton(image=Icons + 'Joint.png', c=JointsBtn)
cmds.separator(h=10)
cmds.separator(h=10)
RadioControlador = cmds.floatSliderGrp(l='Size:',
                                       min=1,
                                       max=20,
                                       field=True,
                                       v=1,
                                       hlc=(0.8, 0.2, 0.5))
cmds.separator(h=10)
def createUI( windowname, pApplyCallback):
    '''Creates the user interface which will recieve various inputs from the user which will later be used to build the tree in the treegen function.
    The user can pick the treetype, the colour of the tree and leaves, the material, the length, the starting angle, the number of iterations, whether they want leaves and apples, 
    the type of leaf, the size of the leaf, and the thickness of the leaves.
    There are also 4 buttons,
    Apply will pass the control path names
    
       windowname	    : the name that will be displayed on the GUI
       pApplyCallback	: the function that the inputs will be passed to when the user clicks apply
    '''
    
    windowID = 'mainwindow'
    
    if cmds.window( windowID, exists=True):
        cmds.deleteUI(windowID)
    cmds.window( windowID, title= windowname , sizeable=False, resizeToFitChildren=True)
    
    cmds.columnLayout( adjustableColumn=True )
    
    #the user interface image that will appear at the top of the window
    submission_path = "/home/s5113911/PythonProgramming"
    cmds.image( w =10, h = 150, i= submission_path+"/Project/panarama4.jpg")
    cmds.separator(h =10, style = 'none')
       
    cmds.text( label ='Tree Type:',align='left')
    
    #controls to choose the treetype
    treetype =cmds.radioButtonGrp( label='', labelArray4=['Standard', 'Dispersed', 'Curved', 'Slant'], numberOfRadioButtons=4, select = 1 )
    treetype2 = cmds.radioButtonGrp( numberOfRadioButtons=2, shareCollection=treetype, label='', labelArray2=['Square', 'Curved2'] )
    
    cmds.separator(h =10, style = 'none')
    
    #control to choose the colour of the tree
    rgbs = cmds.colorSliderGrp( label='Tree Colour:',columnAlign=(1,'left'), rgb=(0.2, 0.08, 0.0) )
    
    cmds.separator(h =10, style = 'none')
    
    #control to choose the colour of the leaves
    rgbleaves = cmds.colorSliderGrp( label='Leaves Colour:',columnAlign=(1,'left'), rgb=(0.06, 0.2, 0.01) )
    
    cmds.separator(h =10, style = 'none')
    cmds.text( label ='Material:',align='left')
    
    #control to choose the material of the tree
    materiall =cmds.radioButtonGrp( label='', labelArray3=['Lambert', 'Blinn', 'Phong'], numberOfRadioButtons=3, select = 1 )
    
    cmds.separator(h =10, style = 'none')
    
    #slider controls to specify the length, angle and iterations of the tree, (iterations meaning th number of the types the chosen l-system will be iterated
    length = cmds.floatSliderGrp(label='Height:', minValue=0.05, maxValue=1.0, value=0.6, step=0.01, field=True, columnAlign=[1,'left'])
    angle = cmds.floatSliderGrp(label='Angle:', minValue=10, maxValue=60, value=25, step=0.01, field=True, columnAlign=[1,'left'])
    iterations = cmds.intSliderGrp( label='Iterations:', minValue=1, maxValue=5, value=4, step=1, field = True, columnAlign=[1,'left'] )
    
    cmds.separator(h =10, style = 'none')
    
    #control to enable or disable apples on the tree
    applecheck = cmds.checkBoxGrp( numberOfCheckBoxes=1, label='Fruit?:  ', columnAlign=[1,'left']  )
    
    cmds.separator(h =10, style = 'none')
    cmds.separator(h =10, style = 'none')
    
    cmds.text( label ='Leaf Type:',align='left')
    #control to enable or disable apples on the tree
    leaves =cmds.radioButtonGrp( label='', labelArray2=['Default', 'Maple'], numberOfRadioButtons=2, select = 1, enable = True )
    
    cmds.separator(h =10, style = 'none')
    cmds.separator(h =10, style = 'none')
    #control to enable or disable leaves on the tree
    leafcheck = cmds.checkBoxGrp( numberOfCheckBoxes=1, label='Leaves?:  ', columnAlign=[1,'left'], value1 =True, changeCommand1=functools.partial( toggleRadio, leaves )  )
    
    cmds.separator(h =10, style = 'none')
    cmds.separator(h =10, style = 'none')
    cmds.text( label ='Leaf Material:',align='left')
    #control to choose the material of the leaves
    materialleaves =cmds.radioButtonGrp( label='', labelArray3=['Lambert', 'Blinn', 'Phong'], numberOfRadioButtons=3, select = 1 )

    cmds.separator(h =10, style = 'none')
    cmds.separator(h =10, style = 'none')
    #control to specify a scaling factor for the leaves
    leafscale = cmds.floatSliderGrp( label='Leafscale:', minValue=0.1, maxValue=3, value=1.2, step=0.01, field = True, columnAlign=[1,'left'])
    
    cmds.separator(h =10, style = 'none')
    cmds.text( label ='Leaves Thickness:',align='left')
    
    #control to specify the 'thickness' of the leaves, e.g if thicker is selected the rule l = ll is added which on average will double the number of leaves created
    leavesamount =cmds.radioButtonGrp( label='', labelArray2=['Default', 'Thicker'], numberOfRadioButtons=2, select = 1)
     
    cmds.separator(h =10, style = 'none')
    cmds.separator(h =10, style = 'none')
    
    #creating and defining the flags of the progress bar, which will allow the user to track the programs progress for each tree generation
    progressControl = cmds.progressBar(maxValue=8000, width = 300, bgc =[0.23,0.16,0.0] )
    
    cmds.separator(h =10, style = 'none')
    
    #when the apply button is pressed, the path names of the various controls are passed to the pApplyCallback function( treegen function)
    cmds.button( label='Apply', backgroundColor=[0.9,0.9,0.9], command=functools.partial( pApplyCallback, length, iterations, treetype, materiall, rgbs, leafscale, leavesamount, rgbleaves, applecheck, leafcheck, angle, leaves, treetype2, progressControl, materialleaves) )
             
    cmds.separator(h =10, style = 'none')
    
    #the 'savemenu' fucntion is called
    cmds.button( label = 'Save', command=functools.partial(savemenu), backgroundColor=[0.101,0.338,0.017])
    cmds.separator(h =10, style = 'none') 
    
    #The 'previous' function is called
    cmds.button( label = 'Undo', command=functools.partial(previous), backgroundColor=[0.23,0.16,0.0])
    cmds.separator(h =10, style = 'none')
    
    cmds.separator(h =10, style = 'none')
    cmds.separator(h =10, style = 'none')
    cmds.separator(h =10, style = 'none')
   
    #the cancelCallback function is called
    cmds.button( label = 'Cancel', command=functools.partial( cancelCallback, windowID) )
    
    cmds.separator(h =10, style = 'none')
    
    cmds.showWindow()
    cmds.window(windowID, e=True, width=640)   
Ejemplo n.º 36
0
	def main_ui(self):

		'''

		main_ui consists of the UI elements for the Color Set Tool.
		Each UI element will be stored in a dictionary for easy use.


		'''

		#empty dictionary for UI elements
		self.ui_elements = {}

		#delete window if it already exists
		if cmds.window("colorSetWindow", exists=True):
			cmds.deleteUI("colorSetWindow")

		#default values for the window
		self.window_width = 100
		self.window_height = 100
		self.column_Width = 75

		#main window
		self.ui_elements["main_window"] = cmds.window(
															"colorSetWindow",
															title="Color Set Tool",
															width=self.window_width,
															height=self.window_height,
															sizeable=False,
															closeCommand=self.delete_script_job
														)

		#main column
		self.ui_elements["top_column"] = cmds.columnLayout(
																adjustableColumn=True,
																columnAlign="center",
																adj=True
															)

		#text field for selected item
		self.ui_elements["item_textfield"] = cmds.textFieldGrp(
																	label="Selected Item",
																	columnWidth=[1, self.column_Width],
																	text="Please select an object",
																	columnAlign=(1, "left"),
																	editable=False
																)

		#separator
		cmds.separator()

		#create color set button
		self.ui_elements["colorset_btn"] = cmds.button(
															label="Create Color Set",
															width=self.window_width,
															align="center",
															command=partial(self.create_color_set)
														)

		#separator
		cmds.separator()

		#minimum value slider
		self.ui_elements["min_slider"] = cmds.intSliderGrp(
																"minimum",
																columnAlign=(1, "left"),
																columnWidth=[1, self.column_Width],
																label="Min Value",
																field=True,
																minValue=0,
																maxValue=100,
																value=20
															)

		#maximum value slider
		self.ui_elements["max_slider"] = cmds.intSliderGrp(
																"maximum",
																columnAlign=(1, "left"),
																columnWidth=[1, self.column_Width],
																label="Max Value",
																field=True,
																minValue=0,
																maxValue=100,
																value=80
															)

		#separator
		cmds.separator()

		#randomize button for colorset2
		self.ui_elements["random_button"] = cmds.button(
															label="Randomize",
															width=self.window_width,
															align="center",
															enable=True,
															command=partial(self.main)
														)

		#show the main window
		cmds.showWindow(self.ui_elements["main_window"])

		#pointer to script job method
		self.create_script_job()
Ejemplo n.º 37
0
def tableChaise():

    tablewidthz = cmds.intSliderGrp(slider1, q=True, value=True)
    tableWidthx = cmds.intSliderGrp(slider2, q=True, value=True)
    tableHeight = cmds.intSliderGrp(slider3, q=True, value=True)
    #Roundness = cmds.intSliderGrp(slider4, q=True, value=True)

    #mesa
    table = cmds.polyCube(h=0.7, w=tableWidthx, depth=tablewidthz)
    rtable = cmds.ls(table[0])
    print(rtable)
    cmds.move(0, tableHeight / 2.0 - 0.3, 0)
    cmds.select(str(rtable[0]) + '.e[4:5]')
    cmds.select(str(rtable[0]) + '.e[8:9]', add=True)
    # cmds.select('table.e[4:5]')
    # cmds.select('table.e[8:9]', add=True)
    cmds.polyBevel3(offset=1, segments=3)
    cmds.polyBevel3(rtable[0], offset=0.1)

    #patas

    pataUno = cmds.polyCube(h=tableHeight, w=1, depth=1)
    cmds.move(-tableWidthx / 2.0 + 1, 0, tablewidthz / 2.0 - 1)
    cmds.polyBevel(offset=0.1)

    pataDos = cmds.polyCube(h=tableHeight, w=1, depth=1)
    cmds.move(tableWidthx / 2.0 - 1, 0, tablewidthz / 2.0 - 1)
    cmds.polyBevel(offset=0.1)

    pataTres = cmds.polyCube(h=tableHeight, w=1, depth=1)
    cmds.move(tableWidthx / 2.0 - 1, 0, -tablewidthz / 2.0 + 1)
    cmds.polyBevel(offset=0.1)

    pataCuatro = cmds.polyCube(h=tableHeight, w=1, depth=1)
    cmds.move(-tableWidthx / 2.0 + 1, 0, -tablewidthz / 2.0 + 1)
    cmds.polyBevel(offset=0.1)
    mir = random.randint(0, 19)
    crazyR = random.randint(0, 1000)
    tName = 'Table' + str(mir) + str(crazyR)
    cmds.group(table, pataUno, pataDos, pataTres, pataCuatro, n=tName)

    Chaisewidthz = cmds.intSliderGrp(slider4, q=True, value=True)
    ChaiseWidthx = cmds.intSliderGrp(slider5, q=True, value=True)
    ChaiseHeight = cmds.intSliderGrp(slider6, q=True, value=True)
    Distance = cmds.intSliderGrp(slider7, q=True, value=True)

    mainC = cmds.polyCube(h=1, w=ChaiseWidthx, depth=Chaisewidthz)
    cmds.move(0, ChaiseHeight / 2.0 - 0.3, 0)
    cmds.polyBevel(offset=0.2)
    cmds.polySmooth(dv=1)

    #patas

    pataUno = cmds.polyCube(h=ChaiseHeight, w=0.7, depth=0.7)
    cmds.move(-ChaiseWidthx / 2.0 + 0.5, 0, Chaisewidthz / 2.0 - 0.5)
    cmds.rotate(-4, 0, -4)
    cmds.polyBevel(offset=0.1)

    pataDos = cmds.polyCube(h=ChaiseHeight, w=0.7, depth=0.7)
    cmds.move(ChaiseWidthx / 2.0 - 0.5, 0, Chaisewidthz / 2.0 - 0.5)
    cmds.rotate(-4, 0, 4)
    cmds.polyBevel(offset=0.1)

    pataTres = cmds.polyCube(h=ChaiseHeight, w=0.7, depth=0.7)
    cmds.move(ChaiseWidthx / 2.0 - 0.5, 0, -Chaisewidthz / 2.0 + 0.5)
    cmds.rotate(4, 0, 4)
    cmds.polyBevel(offset=0.1)

    pataCuatro = cmds.polyCube(h=ChaiseHeight, w=0.7, depth=0.7)
    cmds.move(-ChaiseWidthx / 2.0 + 0.5, 0, -Chaisewidthz / 2.0 + 0.5)
    cmds.rotate(4, 0, -4)
    cmds.polyBevel(offset=0.1)

    #espaldar

    e_uno = cmds.polyCube(h=ChaiseHeight, w=0.5, depth=0.5)
    cmds.move(-ChaiseWidthx / 2.0 + 0.2, ChaiseHeight, Chaisewidthz / 2.0 - 1)
    cmds.rotate(0, 0, 7)
    cmds.polyBevel(offset=0.1)

    e_dos = cmds.polyCube(h=ChaiseHeight, w=0.5, depth=0.5)
    cmds.move(-ChaiseWidthx / 2.0 + 0.2, ChaiseHeight, -Chaisewidthz / 2.0 + 1)
    cmds.rotate(0, 0, 7)
    cmds.polyBevel(offset=0.1)

    e_tres = cmds.polyCube(h=2.5, w=1, depth=Chaisewidthz)
    cmds.move(-ChaiseWidthx / 2.0 + 0.5, ChaiseHeight * 1.4, 0)
    cmds.rotate(0, 0, 7)
    cmds.polyBevel(offset=0.2)
    cmds.polySmooth(dv=1)
    mir = random.randint(0, 19)
    crazyR = random.randint(0, 1000)
    rName = 'Chair' + str(mir) + str(crazyR)
    cmds.group(mainC,
               pataUno,
               pataDos,
               pataTres,
               pataCuatro,
               e_uno,
               e_dos,
               e_tres,
               n=rName)

    cmds.select(rName)
    cmds.move(Distance, -1, 0)
    cmds.duplicate(rName)
    cmds.move(-Distance, -1, 0)
    cmds.rotate(0, -180, 0)

    cmds.select(rName)
    cmds.duplicate(rName)
    cmds.move(0, -1, -Distance)
    cmds.rotate(0, 90, 0)

    cmds.select(rName)
    cmds.duplicate(rName)
    cmds.move(0, -1, Distance)
    cmds.rotate(0, -90, 0)
def createUI():
    global win
    global colorField
    global temperatureField
    global intensityField
    global subdivsField
    global skp
    global sskp
    global noDecayBox
    global doubleSidedBox

    win = "multiLightWin"
    if cmds.window(win, exists=True):
        deleteWindow()

    myWindow = cmds.window(win,
                           title="VRay Multiple Light",
                           resizeToFitChildren=True,
                           sizeable=True,
                           maximizeButton=False,
                           minimizeButton=True)
    cmds.columnLayout(adjustableColumn=True,
                      rowSpacing=2,
                      columnAttach=("both", 8))

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

    cmds.checkBox(label="Enabled",
                  onCommand=("enabled(True)"),
                  offCommand=("enabled(False)"),
                  value=True)

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

    cmds.radioButtonGrp(numberOfRadioButtons=2,
                        labelArray2=["color", "temperature"],
                        changeCommand1="setColorMode(False)",
                        changeCommand2="setColorMode(True)",
                        select=1)

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

    #cmds.rowLayout(numberOfColumns=2)

    cmds.columnLayout(adjustableColumn=True,
                      rowSpacing=2,
                      columnAttach=("both", 8))
    cmds.text(label="light Color", align="center", font="smallBoldLabelFont")
    colorField = cmds.colorSliderGrp(changeCommand=setColor,
                                     dragCommand=setColor)

    cmds.text(label="Temperature", align="center", font="smallBoldLabelFont")
    temperatureField = cmds.floatSliderGrp(field=True,
                                           minValue=0.00,
                                           maxValue=10000.00,
                                           fieldMinValue=0.00,
                                           fieldMaxValue=30000,
                                           dragCommand=setTemperature,
                                           changeCommand=setTemperature,
                                           value=6500,
                                           precision=3,
                                           enable=False)

    cmds.text(label="Intensity", align="center", font="smallBoldLabelFont")
    #cmds.separator( height=5)
    intensityField = cmds.floatSliderGrp(field=True,
                                         minValue=0.00,
                                         maxValue=100.00,
                                         fieldMinValue=0.00,
                                         fieldMaxValue=1000000000.00,
                                         dragCommand=setIntensity,
                                         changeCommand=setIntensity,
                                         value=30.00,
                                         precision=3)

    cmds.text(label="Subdivs", align="center", font="smallBoldLabelFont")
    subdivsField = cmds.intSliderGrp(field=True,
                                     minValue=1,
                                     maxValue=32,
                                     fieldMinValue=1,
                                     fieldMaxValue=1000000000,
                                     dragCommand=setSubdivs,
                                     changeCommand=setSubdivs,
                                     value=8)

    cmds.setParent("..")

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

    noDecayBox = cmds.checkBox(label="No Decay",
                               onCommand=("noDecay(True)"),
                               offCommand=("noDecay(False)"))
    doubleSidedBox = cmds.checkBox(label="Double Sided",
                                   onCommand=("doubleSided(True)"),
                                   offCommand=("doubleSided(False)"))
    cmds.checkBox(label="invisible",
                  onCommand=("invisible(True)"),
                  offCommand=("invisible(False)"))
    skp = cmds.checkBox(label="Skylight Portal",
                        onCommand=("skylightPortal(True)"),
                        offCommand=("skylightPortal(False)"))
    sskp = cmds.checkBox(label="Simple Skylight Portal",
                         onCommand=("simpleSkylightPortal(True)"),
                         offCommand=("simpleSkylightPortal(False)"),
                         enable=False)
    cmds.checkBox(label="Store With Irradiance Map",
                  onCommand=("storeWithIrradianceMap(True)"),
                  offCommand=("storeWithIrradianceMap(False)"))

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

    cmds.checkBox(label="Affect Diffuse",
                  onCommand=("affectDiffuse(True)"),
                  offCommand=("affectDiffuse(False)"),
                  value=True)
    cmds.checkBox(label="Affect Specular",
                  onCommand=("affectSpecular(True)"),
                  offCommand=("affectSpecular(False)"),
                  value=True)
    cmds.checkBox(label="Affect Reflections",
                  onCommand=("affectReflections(True)"),
                  offCommand=("affectReflections(False)"),
                  value=True)

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

    cmds.columnLayout(adj=True, cat=("both", 70))
    cmds.button(label="close", align="center", command=deleteWindow)
    cmds.setParent("..")

    cmds.separator(height=15, style='in')
    cmds.showWindow(myWindow)
Ejemplo n.º 39
0
    def alignJoints(self, *args, **kwargs):
        '''Main function, called by Orient Joint Chain button, aligns the joints.'''
        downAxis = cmds.radioButtonGrp(self.widgets['downAxis'],
                                       q=True,
                                       sl=True)
        upAxis = cmds.radioButtonGrp(self.widgets['upAxis'], q=True, sl=True)
        downNeg = cmds.checkBox(self.widgets['downNeg'], q=True, v=True)
        upNeg = cmds.checkBox(self.widgets['upNeg'], q=True, v=True)
        planeSize = cmds.intSliderGrp(self.widgets['planeSize'],
                                      q=True,
                                      v=True)
        upObject = cmds.textFieldButtonGrp(self.widgets['locatorNameGrp'],
                                           q=True,
                                           text=True)

        #store option vars for next time
        cmds.optionVar(iv=('Mpyr_JointTools_DownAxis', downAxis))
        cmds.optionVar(iv=('Mpyr_JointTools_DownAxisNeg', downNeg))
        cmds.optionVar(iv=('Mpyr_JointTools_UpAxis', upAxis))
        cmds.optionVar(iv=('Mpyr_JointTools_UpAxisNeg', upNeg))
        cmds.optionVar(fv=('Mpyr_JointTools_PlaneSize', planeSize))
        cmds.optionVar(sv=('Mpyr_JointTools_UpObject', upObject))

        #Sanity checking inputs
        if downAxis == upAxis:
            raise RuntimeError("Please select different axes for down and up")
        if not cmds.objExists(upObject):
            raise RuntimeError("Up Object not found in scene")

        #sometimes axis widget returns 0,1,or 2, sometimes str. So always convert to string
        axisNames = 'xyz'
        if isinstance(downAxis, int):
            downAxis = axisNames[downAxis - 1]
        if isinstance(upAxis, int):
            upAxis = axisNames[upAxis - 1]
        if downNeg:
            downAxis = '-' + downAxis
        if upNeg:
            upAxis = '-' + upAxis

        #Gather joints in the chain
        sel = cmds.ls(sl=True)
        if not sel or not cmds.nodeType(sel[0]) == 'joint':
            raise RuntimeError("Please select a joint to orient")
        #create list to hold joints
        jointList = [sel[0]]
        #go through chain, stopping when there are no children or a branch
        while True:
            children = cmds.listRelatives(
                jointList[-1], children=True, type='joint') or []
            if len(children) != 1:
                break
            jointList.append(children[0])

        if len(jointList) == 1:
            raise RuntimeError(
                "Only one joint in chain. Cannot orient a joint with no children, skipping."
            )

        for joint in jointList:
            #Before we do anything make sure joint rotate order is xyz.
            #jointOrient is always xyz, so to combine them we need rotation order to be in the same order.
            rotOrder = cmds.xform(joint, q=True, roo=True)
            cmds.xform(joint, p=True, roo='xyz')

            #orient
            mpJoint.orientJoint(joint,
                                upVector=upObject,
                                downAxis=downAxis,
                                upAxis=upAxis)

            #restore rotation order
            cmds.xform(joint, p=True, roo=rotOrder)

        print("Joint orient complete")
Ejemplo n.º 40
0
mainCL = cmds.columnLayout()
mainRLWidth = [winWidth * 0.4, winWidth * 0.8]
mainRL = cmds.rowLayout(w=winWidth,
                        numberOfColumns=2,
                        columnWidth2=mainRLWidth,
                        rowAttach=(2, 'top', 0))

cmds.columnLayout(
    w=mainRLWidth[0])  # create a columnLayout under the first row of mainRL
# cmds.button(label='runFirst', width=mainRLWidth[1]*0.95, height=70, c='buildVariables()')
cmds.iconTextButton(style='iconAndTextVertical',
                    image1=sc + '/icons/1x/moduledown_cuisine.png',
                    label='tv',
                    width=mainRLWidth[1] * 0.5,
                    c=lambda: tv())
cmds.setParent(
    '..'
)  # this will exit the rowLayout back to the mainRL, same as cmds.setParent(mainRL)

cmds.columnLayout(width=mainRLWidth[1])  # start another vertical layout
# slider1 = cmds.intSliderGrp(field=True, label='BASE HEGHT', minValue=1, maxValue=10, value=3, width=winWidth/2 )
# slider2 = cmds.intSliderGrp(field=True, label='BASE WIDTH', minValue=1, maxValue=10, value=3, width=winWidth/2 )
# slider3 = cmds.intSliderGrp(field=True, label='STICK HEIGHT', minValue=1, maxValue=10, value=2, width=winWidth/2 )
slider4 = cmds.intSliderGrp(field=True,
                            label='TV SIZE',
                            minValue=5,
                            maxValue=20,
                            value=10,
                            width=winWidth / 2)
# slider4 = cmds.intSliderGrp(field=True, label='MODULE WIDTH', minValue=1, maxValue=10, value=4, width=winWidth/2 )
# slider5 = cmds.intSliderGrp(field=True, label='MODULES', minValue=1, maxValue=20, value=3, width=winWidth/2 )
Ejemplo n.º 41
0
def splinifyUI():

    # Create window
    if cmds.window('splinifyWin', exists=1):
        cmds.deleteUI('splinifyWin')
    window = cmds.window('splinifyWin', title='Splinify', sizeable=1)

    # Create form + UI elements
    form = cmds.formLayout(numberOfDivisions=100)
    scroll = cmds.scrollLayout(parent=form)
    scrollForm = cmds.formLayout(numberOfDivisions=100, parent=scroll)

    startJointText = cmds.textFieldGrp(label='Start Joint: ',
                                       adjustableColumn=2,
                                       editable=0)
    startJointBtn = cmds.button(label='Set Selected',
                                command=partial(checkSelectedJoint,
                                                startJointText))

    endJointText = cmds.textFieldGrp(label='End Joint: ',
                                     adjustableColumn=2,
                                     editable=0)
    endJointBtn = cmds.button(label='Set Selected',
                              command=partial(checkSelectedJoint,
                                              endJointText))

    boneIntSlider = cmds.intSliderGrp(label='Number of Bones: ',
                                      field=1,
                                      step=2,
                                      minValue=2,
                                      maxValue=100,
                                      value=10,
                                      adjustableColumn=3)
    jointChainOptions = cmds.optionMenuGrp(label='Joint Chain: ',
                                           changeCommand=partial(
                                               changeJointChain,
                                               boneIntSlider))
    cmds.menuItem(label='Create From Start/End Joints')
    cmds.menuItem(label='Use Existing Joint Chain')

    controlIntSlider = cmds.intSliderGrp(label='Number of Controls: ',
                                         field=1,
                                         step=2,
                                         minValue=2,
                                         maxValue=30,
                                         value=4,
                                         adjustableColumn=3)
    startColorSlider = cmds.colorSliderGrp(label='Start Control Color: ',
                                           rgb=(0, 0, 1))
    endColorSlider = cmds.colorSliderGrp(label='End Control Color: ',
                                         rgb=(0, 1, 0))

    volumePrsvCheckbox = cmds.checkBoxGrp(label='Preserve Volume: ', visible=0)

    splineTypeOptions = cmds.optionMenuGrp(
        label='Spline Type: ',
        changeCommand=partial(changeSplineType, controlIntSlider,
                              startColorSlider, endColorSlider,
                              volumePrsvCheckbox))
    cmds.menuItem(label='Cluster Controls')
    cmds.menuItem(label='Stretchy Spine')

    splinifyBtn = cmds.button(
        label='Splinify!',
        command=partial(executeSplinify, jointChainOptions, startJointText,
                        endJointText, boneIntSlider, splineTypeOptions,
                        controlIntSlider, startColorSlider, endColorSlider,
                        volumePrsvCheckbox),
        parent=form)
    applyBtn = cmds.button(label='Apply',
                           command=partial(applySplinify, jointChainOptions,
                                           startJointText, endJointText,
                                           boneIntSlider, splineTypeOptions,
                                           controlIntSlider, startColorSlider,
                                           endColorSlider, volumePrsvCheckbox),
                           parent=form)
    closeBtn = cmds.button(label='Close',
                           command="cmds.deleteUI('splinifyWin')",
                           parent=form)

    # Format UI elements
    cmds.formLayout(form,
                    edit=1,
                    attachForm=[(scroll, 'top', 5), (scroll, 'left', 5),
                                (scroll, 'right', 5), (splinifyBtn, 'left', 5),
                                (splinifyBtn, 'bottom', 5),
                                (applyBtn, 'bottom', 5),
                                (closeBtn, 'bottom', 5),
                                (closeBtn, 'right', 5)],
                    attachControl=[(scroll, 'bottom', 5, splinifyBtn),
                                   (splinifyBtn, 'right', 5, applyBtn),
                                   (closeBtn, 'left', 5, applyBtn)],
                    attachPosition=[
                        (applyBtn, 'left', 0, 34),
                        (applyBtn, 'right', 0, 66),
                    ])
    cmds.formLayout(scrollForm,
                    edit=1,
                    attachForm=[
                        (jointChainOptions, 'top', 25),
                        (jointChainOptions, 'left', 0),
                        (startJointText, 'left', 0),
                        (startJointBtn, 'right', 10),
                        (endJointText, 'left', 0),
                        (endJointText, 'right', 0),
                        (endJointBtn, 'right', 10),
                        (boneIntSlider, 'left', 0),
                        (boneIntSlider, 'right', 0),
                        (splineTypeOptions, 'left', 0),
                        (controlIntSlider, 'left', 0),
                        (controlIntSlider, 'right', 0),
                        (startColorSlider, 'left', 0),
                        (startColorSlider, 'right', 0),
                        (endColorSlider, 'left', 0),
                        (endColorSlider, 'right', 0),
                        (volumePrsvCheckbox, 'left', 0),
                        (volumePrsvCheckbox, 'right', 0),
                        (volumePrsvCheckbox, 'bottom', 5),
                    ],
                    attachControl=[
                        (jointChainOptions, 'bottom', 5, startJointText),
                        (startJointText, 'bottom', 5, endJointText),
                        (startJointText, 'right', 5, startJointBtn),
                        (startJointBtn, 'bottom', 5, endJointBtn),
                        (endJointText, 'right', 5, endJointBtn),
                        (endJointText, 'bottom', 5, boneIntSlider),
                        (endJointBtn, 'bottom', 5, boneIntSlider),
                        (boneIntSlider, 'bottom', 5, splineTypeOptions),
                        (splineTypeOptions, 'bottom', 5, controlIntSlider),
                        (controlIntSlider, 'bottom', 5, startColorSlider),
                        (startColorSlider, 'bottom', 5, endColorSlider),
                        (endColorSlider, 'bottom', 5, volumePrsvCheckbox),
                    ])
    cmds.showWindow(window)
Ejemplo n.º 42
0
cmds.columnLayout(
    w=mainRLWidth[0])  # create a columnLayout under the first row of mainRL
# cmds.button(label='runFirst', width=mainRLWidth[1]*0.95, height=70, c='buildVariables()')
cmds.iconTextButton(style='iconAndTextVertical',
                    image1=sc + '/icons/1x/moduledown_cuisine.png',
                    label=' Armoire',
                    width=mainRLWidth[1] * 0.5,
                    c=lambda: armoire())
cmds.setParent(
    '..'
)  # this will exit the rowLayout back to the mainRL, same as cmds.setParent(mainRL)

cmds.columnLayout(width=mainRLWidth[1])  # start another vertical layout
slider1 = cmds.intSliderGrp(field=True,
                            label='HEGHT',
                            minValue=1,
                            maxValue=20,
                            value=5,
                            width=winWidth / 2)
slider2 = cmds.floatSliderGrp(field=True,
                              label='WIDTH',
                              minValue=0.01,
                              maxValue=2,
                              value=0.15,
                              width=winWidth / 2)
slider3 = cmds.intSliderGrp(field=True,
                            label='DEPTH',
                            minValue=1,
                            maxValue=20,
                            value=4,
                            width=winWidth / 2)
slider4 = cmds.intSliderGrp(field=True,
Ejemplo n.º 43
0
 def changeEdgeDivide(self, arg=None):
     edgeDivide = mc.intSliderGrp(self.edgeDivideSlider, q=True, value=True)
     mc.setAttr(SS_scaleCtr+".input1Z", edgeDivide)
     return
Ejemplo n.º 44
0
def SpineBtn(*args):

    jointsNum = cmds.intSliderGrp(locatorNum, q=True, value=5)

    #CopyJoints for the SpineLater

    cmds.duplicate('Spine_1', n='SpineStart_JC', po=True)
    cmds.duplicate('Spine_' + str(jointsNum), n='SpineEnd_JC', po=True)
    cmds.setAttr('SpineStart_JC.radius', 3)
    cmds.setAttr('SpineEnd_JC.radius', 3)

    cmds.parent('SpineEnd_JC', 'SpineStart_JC')
    cmds.joint(n='dummyJoint')
    cmds.select('SpineEnd_JC', 'SpineStart_JC', 'dummyJoint')
    cmds.joint(e=True, zso=True, oj="xyz", sao="zup")
    cmds.delete('dummyJoint')

    ############################
    GlobalMult = cmds.floatSliderGrp(RadioControlador, q=True, value=2)
    radio = GlobalMult  #cmds.getAttr ('L_Leg_IK.translateY') - cmds.getAttr ('L_Knee_IK.translateY')
    ############################

    #Reverse Spine Controls

    Distance1 = cmds.getAttr('Spine_1.translateX')
    Distance2 = cmds.getAttr('Spine_2.translateX')
    COGPos = cmds.getAttr('COG.translateY')

    if cmds.objExists('ReverseSpine_JJ'):
        Distance2 = cmds.getAttr('Spine_2.translateX')

        cmds.circle(n='ReverseSpine_CC',
                    r=(Distance2 - Distance1) * 2 * GlobalMult,
                    nr=(1, 0, 0))
        cmds.group(n='ReverseSpine_GRP')
        cmds.pointConstraint('ReverseSpine_JJ', 'ReverseSpine_GRP', mo=False)
        cmds.orientConstraint('ReverseSpine_JJ', 'ReverseSpine_GRP', mo=False)
        cmds.delete('ReverseSpine_GRP_pointConstraint1')
        cmds.delete('ReverseSpine_GRP_orientConstraint1')
        MoveY = cmds.xform('ReverseSpine_JE', q=True, ws=True, t=True)
        cmds.select('ReverseSpine_GRP')
        cmds.move(0, MoveY[1], 0)
        cmds.setAttr('ReverseSpine_CC.overrideEnabled', 1)
        cmds.setAttr('ReverseSpine_CC.overrideColor', 14)
        cmds.xform('ReverseSpine_CC', piv=(0, COGPos, 0), ws=True)

    cmds.pointConstraint('ReverseSpine_CC', 'ReverseSpine_JJ', mo=True)
    cmds.orientConstraint('ReverseSpine_CC', 'ReverseSpine_JJ', mo=True)

    #COG Controls

    cmds.nurbsSquare(n='COG_CC',
                     nr=(1, 0, 0),
                     sl1=(Distance2 - Distance1) * 4,
                     sl2=(Distance2 - Distance1) * 4)
    cmds.parent('leftCOG_CCShape',
                'bottomCOG_CCShape',
                'rightCOG_CCShape',
                'topCOG_CC',
                r=True,
                s=True)
    cmds.rename('COG_CC', 'COG_GRP')
    cmds.rename('topCOG_CC', 'COG_CC')
    cmds.delete('leftCOG_CC', 'bottomCOG_CC', 'rightCOG_CC')
    cmds.parentConstraint('COG', 'COG_GRP')
    cmds.delete('COG_GRP_parentConstraint1')
    cmds.parentConstraint('COG_CC', 'COG')
    cmds.scale(GlobalMult, GlobalMult, GlobalMult, 'COG_GRP')
    cmds.setAttr('COG_CC.overrideEnabled', 1)
    cmds.setAttr('COG_CC.overrideColor', 9)

    #SpineControls

    Distance1 = cmds.getAttr('Spine_1.translateX')
    Distance2 = cmds.getAttr('Spine_2.translateX')
    SpineX = 1

    while cmds.objExists("Spine_" + str(SpineX)):

        cmds.circle(n="Spine" + str(SpineX) + '_CC',
                    r=(Distance2 - Distance1) * 2 * GlobalMult,
                    nr=(1, 0, 0))
        cmds.group(n="Spine" + str(SpineX) + '_GRP')
        cmds.pointConstraint("Spine_" + str(SpineX),
                             "Spine" + str(SpineX) + '_GRP',
                             mo=False)
        cmds.orientConstraint("Spine_" + str(SpineX),
                              "Spine" + str(SpineX) + '_GRP',
                              mo=False)
        cmds.delete("Spine" + str(SpineX) + '_GRP' + '_pointConstraint1')
        cmds.delete("Spine" + str(SpineX) + '_GRP' + '_orientConstraint1')
        cmds.setAttr('Spine' + str(SpineX) + '_CC' + '.overrideEnabled', 1)
        cmds.setAttr('Spine' + str(SpineX) + '_CC' + '.overrideColor', 17)
        cmds.setAttr("Spine" + str(SpineX) + '_CC.scaleX',
                     lock=True,
                     keyable=False,
                     channelBox=False)
        cmds.setAttr("Spine" + str(SpineX) + '_CC.scaleY',
                     lock=True,
                     keyable=False,
                     channelBox=False)
        cmds.setAttr("Spine" + str(SpineX) + '_CC.scaleZ',
                     lock=True,
                     keyable=False,
                     channelBox=False)

        cmds.setAttr("Spine" + str(SpineX) + '_CC.visibility',
                     lock=True,
                     keyable=False,
                     channelBox=False)

        SpineX = SpineX + 1

    SpineX = SpineX - 1

    cmds.delete("Spine" + str(SpineX) + '_GRP')

    SpineX = SpineX - 1

    #Shape the Curves

    cmds.select('Spine1_CC.cv[7]', 'Spine1_CC.cv[3]')
    cmds.move(0, (Distance2 - Distance1), 0, r=True)
    cmds.select("Spine" + str(SpineX) + '_CC.cv[7]',
                "Spine" + str(SpineX) + '_CC.cv[3]')
    cmds.move(0, -(Distance2 - Distance1), 0, r=True)

    cmds.select('ReverseSpine_CC.cv[7]', 'ReverseSpine_CC.cv[3]')
    cmds.move(0, -(Distance2 - Distance1) / 2, 0, r=True)

    #Create hierarchy

    ParentNum = jointsNum - 1

    while cmds.objExists('Spine' + str(ParentNum) + '_CC'):

        cmds.parent('Spine' + str(ParentNum) + '_GRP',
                    'Spine' + str(ParentNum - 1) + '_CC')

        if ParentNum > 2:
            ParentNum = ParentNum - 1
        else:
            ParentNum = ParentNum - 2

    cmds.parent('Spine1_GRP', 'COG_CC')
    cmds.parent('ReverseSpine_GRP', 'COG_CC')

    #IK Stuff

    cmds.curve(n="SpineIK_CC", d=1, p=[(0, 0, 0), (10, 0, 0)], k=(0, 1))
    cmds.cluster('SpineIK_CC.cv[0]', n='SpineStartCluster01')
    cmds.cluster('SpineIK_CC.cv[1]', n='SpineEndCluster02')

    cmds.pointConstraint('SpineStart_JC', 'SpineStartCluster01Handle')
    cmds.pointConstraint('SpineEnd_JC', 'SpineEndCluster02Handle')

    cmds.delete('SpineIK_CC', ch=True)
    cmds.rebuildCurve('SpineIK_CC', s=jointsNum - 1, d=3)

    cmds.delete('SpineStartCluster01Handle', 'SpineEndCluster02Handle')

    IkRef = jointsNum - 1

    cmds.parent('SpineEnd_JC', 'Spine' + str(IkRef) + '_CC')
    cmds.parent('SpineStart_JC', 'Spine1_CC')

    cmds.skinCluster("SpineStart_JC",
                     "SpineEnd_JC",
                     "SpineIK_CC",
                     tsb=True,
                     nw=1,
                     wd=0,
                     mi=5,
                     omi=True,
                     dr=4,
                     rui=True)

    cmds.ikHandle(n="Spine_IK",
                  sj="Spine_1",
                  ee="Spine_" + str(jointsNum),
                  c='SpineIK_CC',
                  sol="ikSplineSolver",
                  ccv=False,
                  pcv=False)

    #RenameLastCurve

    cmds.rename("Spine" + str(SpineX) + '_CC', 'Spine_End_CC')

    #IK Twist
    cmds.setAttr("SpineIK_CC.inheritsTransform", 0)

    cmds.setAttr("Spine_IK.dTwistControlEnable", 1)
    cmds.setAttr("Spine_IK.dWorldUpType", 4)

    cmds.connectAttr("SpineStart_JC.worldMatrix[0]",
                     "Spine_IK.dWorldUpMatrix",
                     f=True)
    cmds.connectAttr("SpineEnd_JC.worldMatrix[0]",
                     "Spine_IK.dWorldUpMatrixEnd",
                     f=True)

    #Changing last curve pivot
    SpineEnd_JCTranslatePivot = cmds.getAttr('SpineEnd_JC.translateX')
    cmds.move(0,
              SpineEnd_JCTranslatePivot,
              0,
              'Spine_End_CC.rotatePivot',
              r=True)

    #Orginizaing

    cmds.select('COG_CC', 'ReverseSpine_CC')
    IK = cmds.ls(sl=True)

    for T in IK:

        cmds.setAttr(str(T) + '.scaleX',
                     lock=True,
                     keyable=False,
                     channelBox=False)
        cmds.setAttr(str(T) + '.scaleY',
                     lock=True,
                     keyable=False,
                     channelBox=False)
        cmds.setAttr(str(T) + '.scaleZ',
                     lock=True,
                     keyable=False,
                     channelBox=False)

        cmds.setAttr(str(T) + '.visibility',
                     lock=True,
                     keyable=False,
                     channelBox=False)

    #Colors

    cmds.setAttr('Spine1' + '_CC' + '.overrideEnabled', 1)
    cmds.setAttr('Spine1' + '_CC' + '.overrideColor', 14)

    cmds.setAttr('Spine_End_CC.overrideEnabled', 1)
    cmds.setAttr('Spine_End_CC' + '.overrideColor', 14)

    cmds.select('SpineIK_CC', 'Spine_IK')
    cmds.group(n='IK_GRP')

    cmds.group('COG', 'COG_GRP', 'IK_GRP', n="RdM_AutoSPINE")
    cmds.select('Spine_1', hi=True)
    cmds.select('Spine_' + str(jointsNum), tgl=True)
    cmds.select('ReverseSpine_JJ', tgl=True)

    cmds.sets(n='BindThisToSpine')

    cmds.rename('Spine_' + str(jointsNum), 'Spine_ConnectToArms')

    cmds.select(cl=True)
Ejemplo n.º 45
0
# cmds.button(label='runFirst', width=mainRLWidth[1]*0.95, height=70, c='buildVariables()')
cmds.iconTextButton(style='iconAndTextVertical',
                    image1=sc + '/icons/2x/table_chaise.png',
                    label='Table and Chair',
                    width=mainRLWidth[1] * 0.5,
                    c=lambda: tableChaise())
cmds.setParent(
    '..'
)  # this will exit the rowLayout back to the mainRL, same as cmds.setParent(mainRL)

cmds.columnLayout(width=mainRLWidth[1])  # start another vertical layout
cmds.text(label='Table', font='boldLabelFont')
cmds.text(label='')
slider1 = cmds.intSliderGrp(field=True,
                            label='TABLE WIDTH Y',
                            minValue=4,
                            maxValue=20,
                            value=10,
                            width=winWidth / 2)
slider2 = cmds.intSliderGrp(field=True,
                            label='TABLE WIDTH X',
                            minValue=2,
                            maxValue=20,
                            value=10,
                            width=winWidth / 2)
slider3 = cmds.intSliderGrp(field=True,
                            label='TABLE HEIGHT',
                            minValue=2,
                            maxValue=20,
                            value=6,
                            width=winWidth / 2)
#-------------------------------------------------------------------------------------------------------------------
Ejemplo n.º 46
0
    def showWindow(self):
        '''UI creation method'''
        window = cmds.window(title='Joint Tools', menuBar=True)

        #Delete helper plane when window is closed:
        cmds.scriptJob(uiDeleted=(window, self.deletePlaneButton))

        #Read stored options, if they don't exist use defaults
        defaultDown = self.defaults['downAxis']
        defaultDownNeg = self.defaults['downNeg']
        defaultUp = self.defaults['upAxis']
        defaultUpNeg = self.defaults['upNeg']
        defaultPlaneSize = self.defaults['planeSize']
        defaultUpObject = self.defaults['upObject']
        if cmds.optionVar(exists='Mpyr_JointTools_DownAxis'):
            defaultDown = cmds.optionVar(q='Mpyr_JointTools_DownAxis')
        if cmds.optionVar(exists='Mpyr_JointTools_DownAxisNeg'):
            defaultDownNeg = cmds.optionVar(q='Mpyr_JointTools_DownAxisNeg')
        if cmds.optionVar(exists='Mpyr_JointTools_UpAxis'):
            defaultUp = cmds.optionVar(q='Mpyr_JointTools_UpAxis')
        if cmds.optionVar(exists='Mpyr_JointTools_UpAxisNeg'):
            defaultUpNeg = cmds.optionVar(q='Mpyr_JointTools_UpAxisNeg')
        if cmds.optionVar(exists='Mpyr_JointTools_PlaneSize'):
            defaultPlaneSize = cmds.optionVar(q='Mpyr_JointTools_PlaneSize')
        if cmds.optionVar(exists='Mpyr_JointTools_PlaneSize'):
            storedUpObj = cmds.optionVar(q='Mpyr_JointTools_UpObject')
            if cmds.objExists(storedUpObj):
                defaultUpObject = storedUpObj

        #Create widgets
        menu = cmds.menu(label='Help', helpMenu=True, p=window)
        cmds.menuItem(label='Instructions', c=self.helpPromptButton, p=menu)
        cmds.menuItem(label='Restore Defaults',
                      c=self.setDefaultsButton,
                      p=menu)

        mainLayout = cmds.columnLayout(adj=True)
        #Axes widgets
        helpText = 'Pick which axes will point down and up on the joints'
        cmds.text(l='Axes',
                  al='left',
                  fn='boldLabelFont',
                  bgc=[0.2, 0.2, 0.2],
                  ann=helpText)
        rowLayout1 = cmds.rowLayout(
            "jtrl1",
            numberOfColumns=2,
            p=mainLayout,
            ad2=2,
            cl2=('center', 'center'),
            ct2=('both', 'both'),
        )
        self.widgets['downAxis'] = cmds.radioButtonGrp(
            numberOfRadioButtons=3,
            label='Down:  ',
            labelArray3=['X', 'Y', 'Z'],
            cw=((1, 50), (2, 50), (3, 50), (4, 100)),
            adj=1,
            p=rowLayout1,
            sl=defaultDown)
        self.widgets['downNeg'] = cmds.checkBox(label='Neg',
                                                p=rowLayout1,
                                                v=defaultDownNeg)

        rowLayout2 = cmds.rowLayout(
            "jtrl2",
            numberOfColumns=2,
            p=mainLayout,
            ad2=2,
            cl2=('center', 'center'),
            ct2=('both', 'both'),
        )
        self.widgets['upAxis'] = cmds.radioButtonGrp(
            numberOfRadioButtons=3,
            label='Up:    ',
            labelArray3=['X', 'Y', 'Z'],
            cw=((1, 50), (2, 50), (3, 50), (4, 100)),
            adj=1,
            p=rowLayout2,
            sl=defaultUp)
        self.widgets['upNeg'] = cmds.checkBox(label='Neg',
                                              p=rowLayout2,
                                              v=defaultUpNeg)

        #Locator widgets
        cmds.separator(p=mainLayout)
        helpText = 'Select object to use as up vector for joints'
        cmds.text(l='Up Object',
                  al='left',
                  fn='boldLabelFont',
                  bgc=[0.2, 0.2, 0.2],
                  p=mainLayout,
                  ann=helpText)
        self.widgets['locatorNameGrp'] = cmds.textFieldButtonGrp(
            label='',
            cw=((1, 10), (2, 250), (3, 50)),
            text=defaultUpObject,
            buttonLabel='<<<<',
            bc=self.locatorNameButton,
            p=mainLayout)

        #The main button
        cmds.separator(p=mainLayout)
        cmds.button(label='Orient Joint Chain',
                    command=self.alignJoints,
                    p=mainLayout,
                    bgc=(0.7, 1.0, 0.7),
                    h=50)

        #Plane widgets
        cmds.separator(p=mainLayout)
        cmds.text(l='Helpers',
                  al='left',
                  fn='boldLabelFont',
                  bgc=[0.2, 0.2, 0.2],
                  p=mainLayout)
        rowLayout3 = cmds.rowLayout("jtrl3",
                                    numberOfColumns=2,
                                    p=mainLayout,
                                    ad2=1,
                                    cl2=('center', 'center'),
                                    ct2=('both', 'both'))
        cmds.button(label='Make Plane',
                    command=self.makePlaneButton,
                    p=rowLayout3)
        cmds.button(label='Delete Plane',
                    command=self.deletePlaneButton,
                    p=rowLayout3)
        self.widgets['planeSize'] = cmds.intSliderGrp(l='size',
                                                      cw=(1, 30),
                                                      min=1,
                                                      max=200,
                                                      ss=1.0,
                                                      cc=self.planeSizeSlider,
                                                      field=True,
                                                      v=defaultPlaneSize,
                                                      p=mainLayout)
        cmds.separator(p=mainLayout)
        cmds.button(label='Tweak Joint',
                    command=self.tweakButton,
                    p=mainLayout)
        cmds.showWindow(window)
Ejemplo n.º 47
0
    def __init__(self):
        wName = 'w12A_HideHairs'
        if cmds.window(wName, exists=True):
            cmds.deleteUI(wName)

        cmds.window(wName, title=wName, sizeable=True)

        cmds.formLayout('w12A_uiMainLay', p=wName)
        cmds.frameLayout('w12A_uiUtilLay',
                         p="w12A_uiMainLay",
                         label="Utility",
                         collapsable=True,
                         borderStyle="in")
        cmds.rowColumnLayout('w12A_uiRowLay_02', p='w12A_uiUtilLay',
                             nc=2)  #, cw=[(1,200),(2,80), (3,180),(4,150)] )

        cmds.button(l='Rename Hairs',
                    p='w12A_uiRowLay_02',
                    h=30,
                    c=self.renameHair)
        cmds.button(l='Assign aiHair shader',
                    p='w12A_uiRowLay_02',
                    h=30,
                    c=self.assignAiHairShader)
        cmds.separator(p='w12A_uiRowLay_02', st="out", h=10)
        cmds.separator(p='w12A_uiRowLay_02', st="out", h=10)

        cmds.optionMenu('w12A_uiCameras',
                        l='Cameras:',
                        p='w12A_uiRowLay_02',
                        h=30,
                        w=200)
        for cam in cmds.listRelatives(cmds.ls(cameras=True),
                                      parent=True,
                                      f=True):
            cmds.menuItem(label=cam, p='w12A_uiCameras')
        cmds.button('w12_uiUpdataCam',
                    l='Update cam',
                    p='w12A_uiRowLay_02',
                    w=80,
                    c=self.w12A_uiUpdateCam_cmd)
        cmds.separator(p='w12A_uiRowLay_02', st="in", h=10)
        cmds.separator(p='w12A_uiRowLay_02', st="in", h=10)
        cmds.intSliderGrp('w12A_uiStep',
                          p='w12A_uiRowLay_02',
                          field=True,
                          label='Key step',
                          cw3=[50, 30, 100],
                          h=30,
                          minValue=1,
                          maxValue=100,
                          fieldMinValue=1,
                          fieldMaxValue=100,
                          value=1)
        cmds.button('w12A_uiDisToCamera',
                    l='Get distance to camera',
                    p='w12A_uiRowLay_02',
                    h=30,
                    c=self.w12A_uiAddDistAttr)
        #cmds.button( 'w12A_uiListAll', l='Sort by minimum distance',  p='w12A_uiRowLay_02')

        cmds.rowColumnLayout('w12A_uiRowLay_top',
                             p='w12A_uiMainLay',
                             nc=10,
                             cs=[(4, 10), (6, 10)],
                             cw=[(1, 28), (2, 150), (3, 50), (4, 150), (5, 50),
                                 (6, 40)])
        cmds.text('w12A_uiCount', l=0, p='w12A_uiRowLay_top')
        cmds.button(l='Get Selected',
                    p='w12A_uiRowLay_top',
                    h=30,
                    c=self.w12A_GetAll_cmd)
        cmds.button('w12A_uiSelAllFurs',
                    l='Sel All',
                    p='w12A_uiRowLay_top',
                    c=self.w12A_uiSelAllFurs_cmd)
        cmds.button('w12A_uiSortByDist',
                    l='Sort by minimum distance',
                    p='w12A_uiRowLay_top',
                    en=False,
                    c=self.w12A_uiSortByDist_cmd)
        #cmds.text( p='w12A_uiRowLay_top', en=False)
        cmds.button('w12A_uiSelAllSurs',
                    l='Sel All',
                    p='w12A_uiRowLay_top',
                    c=self.w12A_uiSelAllSurs_cmd)
        #cmds.text(l='Select', p='w12A_uiRowLay_top' )
        #cmds.button(l='', p='w12A_uiRowLay_top')
        #cmds.button(l='', p='w12A_uiRowLay_top')
        #cmds.button(l='', p='w12A_uiRowLay_top')
        #cmds.radioButtonGrp( 'w12A_uiSelChoose', numberOfRadioButtons=2, cw2=(40,400), labelArray2=('Hair', 'Surface' ), sl=1 )

        ###
        cmds.scrollLayout('w12A_uiScroLay', p='w12A_uiMainLay', cr=True)
        ####

        cmds.rowColumnLayout('w12A_uiRowLay',
                             p='w12A_uiScroLay',
                             nc=5,
                             cs=[(4, 10)],
                             cw=[(1, 25), (2, 150), (3, 50), (4, 150),
                                 (5, 50)])



        cmds.formLayout('w12A_uiMainLay', e=True,\
                        attachForm=[('w12A_uiUtilLay', 'top', 3),('w12A_uiUtilLay', 'left', 3),('w12A_uiUtilLay', 'right', 3),\
                                    ('w12A_uiRowLay_top', 'left', 3),('w12A_uiRowLay_top', 'right', 3),\
                                    ('w12A_uiScroLay', 'bottom', 3),('w12A_uiScroLay', 'left', 3),('w12A_uiScroLay', 'right', 3)
                                    ],\
                        attachControl=[('w12A_uiRowLay_top', 'top', 4, 'w12A_uiUtilLay'),\
                                        ('w12A_uiScroLay', 'top', 4, 'w12A_uiRowLay_top')\
                                        ]\
                        )

        cmds.showWindow(wName)
Ejemplo n.º 48
0
def attrWindow():
    winName = 'myWindow'
    if cmds.window(winName, exists = True):
        cmds.deleteUI(winName)    
    mainWindow = cmds.window(winName, title = "Dave's Toolbox",)
    form = cmds.formLayout()
    tabs = cmds.tabLayout()
    cmds.formLayout( form, edit=True, attachForm=((tabs, 'top', 0), (tabs, 'left', 0), (tabs, 'bottom', 0), (tabs, 'right', 0)) )
#Generaltab
    general = cmds.rowColumnLayout(numberOfColumns=1)
    outlinerBtn = cmds.button(l = "Launch Outliner", c = lambda x: myOutliner.create())   
    freezeBtn = cmds.button(l='FreezeTransforms', c=lambda x:freezeAttr(tbox, rbox, sbox))
    tbox = cmds.checkBox(l = 'Translate',v=True)
    rbox = cmds.checkBox(l = 'Rotate',v=True)
    sbox = cmds.checkBox(l = 'Scale',v=True)  
    combineBtn = cmds.button(l = "Combine", c = lambda x: combine())
    separateBtn = cmds.button(l = "Separate", c = lambda x: separate())
    deleteBtn = cmds.button(l='DeleteHistory', c=lambda x:deleteHistory(cmds.ls(sl = True)))
    myText = cmds.textField()  
    cmds.textField(myText, e=True, text = "Enter new name")
    renameBtn = cmds.button(l= "Rename Hierarchy",c = lambda x: renameHierarchy(myText))
    grpBtn = cmds.button(l = "Group Items", c = lambda x: grpParent())
    parentScaleBtn = cmds.button(l = "Parent and Scale Constrain", c = lambda x: parentScale())
    populateObjBtn = cmds.button(l = "Populate with first selected Object",c=lambda x:populateMesh())
    cmds.setParent( '..' )
#RiggingCtrls
    rigging = cmds.rowColumnLayout(numberOfColumns=1)
    cmds.text("Control Shape")
    shapeRdCol = cmds.radioCollection("Shapes")
    circleRd = cmds.radioButton("circle",l = "Circle", select = True)
    squareRd = cmds.radioButton("square",l = "Square")
    diamondRd = cmds.radioButton("diamond",l = "Diamond")
    arrowRd = cmds.radioButton("arrow",l = "Arrow")


    cmds.text("Color Index")
    colorValue = cmds.intSliderGrp(min=0, max=16, value=0, step=1, field = True)
    cmds.text("Control Size")
    sizeField = cmds.floatField(min = 0, v =1)
    
    AutoFKbtn = cmds.button(l = "Auto FK System", c = lambda x: rigCall(colorValue,sizeField,shapeRdCol, solverBox, "FK", orientation))
    solverBox = cmds.checkBox(l = "IK Solver", v = True)
    
    cmds.text("Solver Orientation") 
    solverOrientRdCol = cmds.radioCollection("Solver Orientation")
    orientXRd = cmds.radioButton('x',l = 'X')
    orientYRd = cmds.radioButton('y',l = 'Y')
    orientZRd = cmds.radioButton('z',l = 'Z', select = True)
    
    cmds.text("Axis Value")
    orientValueCol = cmds.radioCollection("Axis Value")
    positiveRd = cmds.radioButton('Positive', l = "+", select = True)
    negativeRd = cmds.radioButton('Negative', l = "-")
    
    cmds.text("PoleVector Distance")
    distanceField = cmds.floatField(min = 0, v = 1)
    orientation = [solverOrientRdCol, orientValueCol, distanceField]
    
    AutoIKbtn = cmds.button(p = rigging, l = "Auto IK Solver", c = lambda x: rigCall(colorValue,sizeField,shapeRdCol, solverBox, "IK", orientation))
    AutoRKbtn = cmds.button(p = rigging, l = "Auto RK System", c = lambda x: rigCall(colorValue,sizeField,shapeRdCol, solverBox, "RK", orientation))
    
    cmds.setParent( '..' )
#Rigging/Joints 
    skeleton = cmds.rowColumnLayout()
    scaleBox = cmds.checkBox(l = 'Add Scale Constraint', v=False)
    parentBox = cmds.checkBox(l = 'Add Parent Constraint',v=False)
    chainBox = cmds.checkBox(l = 'Create Chain From Joints', v = True)
    jointChainBtn = cmds.button(l = "Create Joint Chain", c = lambda x: callJointChain(parentBox, scaleBox, chainBox))
    toggleBtn = cmds.button(l = "Toggle Axis Display", c = lambda x: toggleAxisDisplay())
    cmds.setParent( '..' )
#TabLayout
    cmds.tabLayout( tabs, edit=True, tabLabel=((general, 'General'),(rigging, 'Rigging'), (skeleton, 'Joints')) )
#-------------------------------------------------------   
    cmds.showWindow(winName)
Ejemplo n.º 49
0
    def uiCreate(self):

        self.onCloseClicked()

        self.window = m.window(WIN_NAME,
                               title='Maya Window',
                               maximizeButton=False)

        uiLAY_mainForm = m.formLayout()

        self.uiLAY_mainScroll = m.scrollLayout(childResizable=True)

        mainColumn = m.columnLayout(
            adjustableColumn=True)  # main column layout with frames

        # --------
        self.uiLAY_frameCheckBoxes = self.uiCreateFrame(
            'uiLAY_frameCheckBoxes', 'Check Boxes (PMCheckBox)')

        m.columnLayout()

        m.separator(style='none', height=2)

        m.rowLayout(numberOfColumns=3)

        m.separator(width=140, style='none')
        self.uiCHK_test1 = m.checkBox('uiCHK_test1', label='test1')
        self.uiCHK_test2 = m.checkBox('uiCHK_test2', label='test2')

        m.setParent(mainColumn)

        # --------
        self.uiLAY_frameCheckBoxGroups = self.uiCreateFrame(
            'uiLAY_frameCheckBoxGroups', 'Check Box Groups (PMCheckBoxGrp#)')

        m.columnLayout()

        m.separator(style='none', height=2)
        self.uiCHKGRP_test1 = m.checkBoxGrp('uiCHKGRP_test1',
                                            numberOfCheckBoxes=1,
                                            label='PMCheckBoxGrp1',
                                            label1='test1')
        self.uiCHKGRP_test2 = m.checkBoxGrp('uiCHKGRP_test2',
                                            numberOfCheckBoxes=2,
                                            label='PMCheckBoxGrp2',
                                            labelArray2=('test1', 'test2'))
        self.uiCHKGRP_test3 = m.checkBoxGrp('uiCHKGRP_test3',
                                            numberOfCheckBoxes=3,
                                            label='PMCheckBoxGrp3',
                                            labelArray3=('test1', 'test2',
                                                         'test3'))
        self.uiCHKGRP_test4 = m.checkBoxGrp('uiCHKGRP_test4',
                                            numberOfCheckBoxes=4,
                                            label='PMCheckBoxGrp4',
                                            labelArray4=('test1', 'test2',
                                                         'test3', 'test4'))

        m.setParent(mainColumn)

        # --------
        self.uiLAY_frameColorSliders = self.uiCreateFrame(
            'uiLAY_frameColorSliders',
            'Color Slider Groups (PMColorSliderGrp)')

        m.columnLayout()

        m.separator(style='none', height=2)
        self.uiCLRGRP_test1 = m.colorSliderGrp('uiCLRGRP_test1', label='test1')
        self.uiCLRGRP_test2 = m.colorSliderGrp('uiCLRGRP_test2', label='test2')

        m.setParent(mainColumn)

        # --------
        self.uiLAY_frameFloatFields = self.uiCreateFrame(
            'uiLAY_frameFloatFields', 'Float Fields (PMFloatField)')

        m.columnLayout()

        m.separator(style='none', height=2)

        m.rowLayout(numberOfColumns=3)
        m.separator(width=140, style='none')
        self.uiFLF_test1 = m.floatField('uiFLF_test1')
        self.uiFLF_test2 = m.floatField('uiFLF_test2')

        m.setParent(mainColumn)

        # --------
        self.uiLAY_frameFloatFieldGroups = self.uiCreateFrame(
            'uiLAY_frameFloatFieldGroups',
            'Float Field Groups (PMFloatFieldGrp#)')

        m.columnLayout()

        m.separator(style='none', height=2)
        self.uiFLFGRP_test1 = m.floatFieldGrp('uiFLFGRP_test1',
                                              numberOfFields=1,
                                              label='PMFloatFieldGrp1')
        self.uiFLFGRP_test2 = m.floatFieldGrp('uiFLFGRP_test2',
                                              numberOfFields=2,
                                              label='PMFloatFieldGrp2')
        self.uiFLFGRP_test3 = m.floatFieldGrp('uiFLFGRP_test3',
                                              numberOfFields=3,
                                              label='PMFloatFieldGrp3')
        self.uiFLFGRP_test4 = m.floatFieldGrp('uiFLFGRP_test4',
                                              numberOfFields=4,
                                              label='PMFloatFieldGrp4')

        m.setParent(mainColumn)

        # --------
        self.uiLAY_frameFloatScrollBars = self.uiCreateFrame(
            'uiLAY_frameFloatScrollBars',
            'Float Scroll Bars (PMFloatScrollBar)')

        m.columnLayout(adjustableColumn=True)

        m.separator(style='none', height=2)
        self.uiFLSCRL_test1 = m.floatScrollBar('uiFLSCRL_test1')
        self.uiFLSCRL_test2 = m.floatScrollBar('uiFLSCRL_test2')

        m.setParent(mainColumn)

        # --------
        self.uiLAY_frameFloatSliders = self.uiCreateFrame(
            'uiLAY_frameFloatSliders', 'Float Sliders (PMFloatSlider)')

        m.columnLayout(adjustableColumn=True)

        m.separator(style='none', height=2)
        self.uiFLTSLD_test1 = m.floatSlider('uiFLTSLD_test1')
        self.uiFLTSLD_test2 = m.floatSlider('uiFLTSLD_test2')

        m.setParent(mainColumn)

        # --------
        self.uiLAY_frameFloatSliderGroups = self.uiCreateFrame(
            'uiLAY_frameFloatSliderGroups',
            'Float Slider Groups (PMFloatSliderGrp)')
        m.columnLayout()
        m.separator(style='none', height=2)
        self.uiFLSGRP_test1 = m.floatSliderGrp('uiFLSGRP_test1',
                                               label='test1',
                                               field=True)
        self.uiFLSGRP_test2 = m.floatSliderGrp('uiFLSGRP_test2',
                                               label='test2',
                                               field=True)

        m.setParent(mainColumn)

        # --------
        self.uiLAY_frameIconTextCheckBoxes = self.uiCreateFrame(
            'uiLAY_frameIconTextCheckBoxes',
            'Icon Text Check Boxes (PMIconTextCheckBox)')

        m.columnLayout()

        m.rowLayout(numberOfColumns=3)

        m.separator(style='none', width=140)
        self.uiITCHK_test1 = m.iconTextCheckBox('uiITCHK_test1',
                                                style='iconAndTextHorizontal',
                                                label='cube',
                                                image1='cube')
        self.uiITCHK_test2 = m.iconTextCheckBox('uiITCHK_test2',
                                                style='iconAndTextHorizontal',
                                                label='cone',
                                                image1='cone')

        m.setParent(mainColumn)

        # --------
        self.uiLAY_frameIconTextRadioButtons = self.uiCreateFrame(
            'uiLAY_frameIconTextRadioButtons',
            'Icon Text Radio Buttons (PMIconTextRadioButton)')

        m.columnLayout()

        m.rowLayout(numberOfColumns=4)

        m.separator(style='none', width=140)
        m.iconTextRadioCollection()
        self.uiITRAD_test1 = m.iconTextRadioButton(
            'uiITRAD_test1',
            style='iconAndTextHorizontal',
            label='cube',
            image1='cube')
        self.uiITRAD_test2 = m.iconTextRadioButton(
            'uiITRAD_test2',
            style='iconAndTextHorizontal',
            label='cone',
            image1='cone')
        self.uiITRAD_test3 = m.iconTextRadioButton(
            'uiITRAD_test3',
            style='iconAndTextHorizontal',
            label='torus',
            image1='torus')

        m.setParent(mainColumn)

        # --------
        self.uiLAY_frameIconTextScrollLists = self.uiCreateFrame(
            'uiLAY_frameIconTextScrollLists',
            'Icon Text Scroll Lists (PMIconTextScrollList)')

        m.columnLayout()

        m.rowLayout(numberOfColumns=3)

        m.separator(style='none', width=140)
        self.uiITSLST_test1 = m.iconTextScrollList(
            'uiITSLST_test1',
            allowMultiSelection=True,
            append=('one', 'two', 'three', 'four', 'five', 'six', 'seven',
                    'eight', 'nine', 'ten'))
        self.uiITSLST_test2 = m.iconTextScrollList(
            'uiITSLST_test2',
            allowMultiSelection=True,
            append=('one', 'two', 'three', 'four', 'five', 'six', 'seven',
                    'eight', 'nine', 'ten'))

        m.setParent(mainColumn)

        # --------
        self.uiLAY_frameIntFields = self.uiCreateFrame(
            'uiLAY_frameIntFields', 'Int Fields (PMIntField)')

        m.columnLayout()

        m.separator(style='none', height=2)

        m.rowLayout(numberOfColumns=3)

        m.separator(width=140, style='none')
        self.uiINF_test1 = m.intField('uiINF_test1')
        self.uiINF_test2 = m.intField('uiINF_test2')

        m.setParent(mainColumn)

        # --------
        self.uiLAY_frameIntFieldGroups = self.uiCreateFrame(
            'uiLAY_frameIntFieldGroups', 'Int Field Groups (PMIntFieldGrp#)')

        m.columnLayout()

        m.separator(style='none', height=2)
        self.uiINFGRP_test1 = m.intFieldGrp('uiINFGRP_test1',
                                            numberOfFields=1,
                                            label='PMIntFieldGrp1')
        self.uiINFGRP_test2 = m.intFieldGrp('uiINFGRP_test2',
                                            numberOfFields=2,
                                            label='PMIntFieldGrp2')
        self.uiINFGRP_test3 = m.intFieldGrp('uiINFGRP_test3',
                                            numberOfFields=3,
                                            label='PMIntFieldGrp3')
        self.uiINFGRP_test4 = m.intFieldGrp('uiINFGRP_test4',
                                            numberOfFields=4,
                                            label='PMIntFieldGrp4')

        m.setParent(mainColumn)

        # --------
        self.uiLAY_frameIntScrollBars = self.uiCreateFrame(
            'uiLAY_frameIntScrollBars', 'Int Scroll Bars (PMIntScrollBar)')

        m.columnLayout(adjustableColumn=True)

        m.separator(style='none', height=2)
        self.uiINSCRL_test1 = m.intScrollBar('uiINSCRL_test1')
        self.uiINSCRL_test2 = m.intScrollBar('uiINSCRL_test2')

        m.setParent(mainColumn)

        # --------
        self.uiLAY_frameIntSliders = self.uiCreateFrame(
            'uiLAY_frameIntSliders', 'Int Sliders (PMIntSlider)')

        m.columnLayout(adjustableColumn=True)

        m.separator(style='none', height=2)
        self.uiINTSLD_test1 = m.intSlider('uiINTSLD_test1')
        self.uiINTSLD_test2 = m.intSlider('uiINTSLD_test2')

        m.setParent(mainColumn)

        # --------
        self.uiLAY_frameIntSliderGroups = self.uiCreateFrame(
            'uiLAY_frameIntSliderGroups', 'Int Slider Groups (PMIntSliderGrp)')

        m.columnLayout()

        m.separator(style='none', height=2)
        self.uiINSGRP_test1 = m.intSliderGrp('uiINSGRP_test1',
                                             label='test1',
                                             field=True)
        self.uiINSGRP_test2 = m.intSliderGrp('uiINSGRP_test2',
                                             label='test2',
                                             field=True)

        m.setParent(mainColumn)

        # --------
        self.uiLAY_frameOptionMenus = self.uiCreateFrame(
            'uiLAY_frameOptionMenus', 'Option Menus (PMOptionMenu)')

        m.columnLayout()

        m.separator(style='none', height=2)

        m.rowLayout(numberOfColumns=3)

        m.separator(width=110, style='none')
        self.uiOPTMNU_test1 = m.optionMenu('uiOPTMNU_test1', label='test1')
        m.menuItem(label='one')
        m.menuItem(label='two')
        m.menuItem(label='three')
        self.uiOPTMNU_test2 = m.optionMenu('uiOPTMNU_test2', label='test2')
        m.menuItem(label='four')
        m.menuItem(label='five')
        m.menuItem(label='six')

        m.setParent(mainColumn)

        # --------
        self.uiLAY_frameOptionMenuGroups = self.uiCreateFrame(
            'uiLAY_frameOptionMenuGroups',
            'Option Menus Groups (PMOptionMenuGrp)')

        m.columnLayout()

        m.separator(style='none', height=2)
        self.uiOPMGRP_test1 = m.optionMenuGrp('uiOPMGRP_test1',
                                              label='test1',
                                              extraLabel='extraLabel')
        m.menuItem(label='one')
        m.menuItem(label='two')
        m.menuItem(label='three')
        self.uiOPMGRP_test2 = m.optionMenuGrp('uiOPMGRP_test2',
                                              label='test2',
                                              extraLabel='extraLabel')
        m.menuItem(label='four')
        m.menuItem(label='five')
        m.menuItem(label='six')

        m.setParent(mainColumn)

        # --------
        self.uiLAY_frameRadioButtons = self.uiCreateFrame(
            'uiLAY_frameRadioButtons', 'Radio Buttons (PMRadioButton)')

        m.columnLayout()

        m.rowLayout(numberOfColumns=4)

        m.separator(style='none', width=140)
        m.radioCollection()
        self.uiRAD_test1 = m.radioButton('uiRAD_test1', label='test1')
        self.uiRAD_test2 = m.radioButton('uiRAD_test2', label='test2')
        self.uiRAD_test3 = m.radioButton('uiRAD_test3', label='test3')

        m.setParent(mainColumn)

        # --------
        self.uiLAY_frameRadioButtonGroups = self.uiCreateFrame(
            'uiLAY_frameRadioButtonGroups',
            'Radio Button Groups (PMRadioButtonGrp#)')

        m.columnLayout()
        m.separator(style='none', height=2)
        self.uiRADGRP_test1 = m.radioButtonGrp('uiRADGRP_test1',
                                               numberOfRadioButtons=1,
                                               label='PMRadioButtonGrp1',
                                               label1='test1')
        self.uiRADGRP_test2 = m.radioButtonGrp('uiRADGRP_test2',
                                               numberOfRadioButtons=2,
                                               label='PMRadioButtonGrp2',
                                               labelArray2=('test1', 'test2'))
        self.uiRADGRP_test3 = m.radioButtonGrp('uiRADGRP_test3',
                                               numberOfRadioButtons=3,
                                               label='PMRadioButtonGrp3',
                                               labelArray3=('test1', 'test2',
                                                            'test3'))
        self.uiRADGRP_test4 = m.radioButtonGrp('uiRADGRP_test4',
                                               numberOfRadioButtons=4,
                                               label='PMRadioButtonGrp4',
                                               labelArray4=('test1', 'test2',
                                                            'test3', 'test4'))

        m.setParent(mainColumn)

        # --------
        self.uiLAY_frameSymbolCheckBoxes = self.uiCreateFrame(
            'uiLAY_frameSymbolCheckBoxes',
            'Symbol Check Boxes (PMSymbolCheckBox)')

        m.columnLayout()

        m.rowLayout(numberOfColumns=3)

        m.separator(style='none', width=140)
        self.uiSYMCHK_test1 = m.symbolCheckBox('uiSYMCHK_test1',
                                               image='polyCube')
        self.uiSYMCHK_test2 = m.symbolCheckBox('uiSYMCHK_test2',
                                               image='polyCone')

        m.setParent(mainColumn)

        # --------
        self.uiLAY_frameScriptTables = self.uiCreateFrame(
            'uiLAY_frameScriptTables', 'Script Tables (PMScriptTable)')

        m.columnLayout()

        m.rowLayout(numberOfColumns=3)

        m.separator(style='none', width=140)
        self.uiSCRTBL_test1 = m.scriptTable('uiSCRTBL_test1',
                                            selectionMode=3,
                                            rows=4,
                                            columns=2)
        self.uiSCRTBL_test2 = m.scriptTable('uiSCRTBL_test2',
                                            selectionMode=3,
                                            rows=4,
                                            columns=2)

        m.setParent(mainColumn)

        # --------
        self.uiLAY_frameScrollField = self.uiCreateFrame(
            'uiLAY_frameScrollField', 'Scroll Field (PMScrollField)')

        m.columnLayout()

        m.rowLayout(numberOfColumns=3)

        m.separator(style='none', width=140)
        self.uiSCRFLD_test1 = m.scrollField('uiSCRFLD_test1', wordWrap=True)
        self.uiSCRFLD_test2 = m.scrollField('uiSCRFLD_test2', wordWrap=True)

        m.setParent(mainColumn)

        # --------
        self.uiLAY_frameShelfTabLayout = self.uiCreateFrame(
            'uiLAY_frameShelfTabLayout', 'Shelf Tab Layout (PMShelfTabLayout)')

        m.columnLayout(adjustableColumn=True)

        self.uiSHLTAB_test1 = m.shelfTabLayout()

        m.shelfLayout('test1')
        m.setParent('..')
        m.shelfLayout('test2')
        m.setParent('..')
        m.shelfLayout('test3')
        m.setParent('..')

        m.setParent('..')

        self.uiSHLTAB_test2 = m.shelfTabLayout()

        m.shelfLayout('test4')
        m.setParent('..')
        m.shelfLayout('test5')
        m.setParent('..')
        m.shelfLayout('test6')
        m.setParent('..')

        m.setParent(mainColumn)

        # --------
        self.uiLAY_frameTabLayout = self.uiCreateFrame(
            'uiLAY_frameTabLayout', 'Tab Layout (PMTabLayout)')

        m.columnLayout(adjustableColumn=True)

        self.uiTAB_test1 = m.tabLayout()

        uiLAY_tabRow1 = m.rowLayout(numberOfColumns=1)
        m.setParent('..')
        uiLAY_tabRow2 = m.rowLayout(numberOfColumns=1)
        m.setParent('..')
        uiLAY_tabRow3 = m.rowLayout(numberOfColumns=1)
        m.setParent('..')

        m.setParent('..')

        m.tabLayout(self.uiTAB_test1,
                    edit=True,
                    tabLabel=(
                        (uiLAY_tabRow1, 'test1'),
                        (uiLAY_tabRow2, 'test2'),
                        (uiLAY_tabRow3, 'test3'),
                    ))

        self.uiTAB_test2 = m.tabLayout()

        uiLAY_tabRow4 = m.rowLayout(numberOfColumns=1)
        m.setParent('..')
        uiLAY_tabRow5 = m.rowLayout(numberOfColumns=1)
        m.setParent('..')
        uiLAY_tabRow6 = m.rowLayout(numberOfColumns=1)
        m.setParent('..')

        m.setParent('..')

        m.tabLayout(self.uiTAB_test2,
                    edit=True,
                    tabLabel=(
                        (uiLAY_tabRow4, 'test4'),
                        (uiLAY_tabRow5, 'test5'),
                        (uiLAY_tabRow6, 'test6'),
                    ))

        m.setParent(mainColumn)

        # --------
        self.uiLAY_frameTextFields = self.uiCreateFrame(
            'uiLAY_frameTextFields', 'Text Fields (PMTextField)')

        m.columnLayout()

        m.separator(style='none', height=2)

        m.rowLayout(numberOfColumns=3)

        m.separator(width=140, style='none')
        self.uiTXT_test1 = m.textField('uiTXT_test1')
        self.uiTXT_test2 = m.textField('uiTXT_test2')

        m.setParent(mainColumn)

        # --------
        self.uiLAY_frameTextFieldButtonGroups = self.uiCreateFrame(
            'uiLAY_frameTextFieldButtonGroups',
            'Text Field Button Groups (PMTextFieldButtonGrp)')

        m.columnLayout()

        m.separator(style='none', height=2)
        self.uiTXBTGR_test1 = m.textFieldButtonGrp('uiTXBTGR_test1',
                                                   label='test1',
                                                   buttonLabel='button1')
        self.uiTXBTGR_test2 = m.textFieldButtonGrp('uiTXBTGR_test2',
                                                   label='test2',
                                                   buttonLabel='button2')

        m.setParent(mainColumn)

        # --------
        self.uiLAY_frameTextFieldGroups = self.uiCreateFrame(
            'uiLAY_frameTextFieldGroups', 'Text Field Groups (PMTextFieldGrp)')

        m.columnLayout()

        m.separator(style='none', height=2)
        self.uiTXTGRP_test1 = m.textFieldGrp('uiTXTGRP_test1', label='test1')
        self.uiTXTGRP_test2 = m.textFieldGrp('uiTXTGRP_test2', label='test2')

        m.setParent(mainColumn)

        # --------
        self.uiLAY_frameTextScrollLists = self.uiCreateFrame(
            'uiLAY_frameTextScrollLists',
            'Text Scroll Lists (PMTextScrollList)')

        m.columnLayout()

        m.rowLayout(numberOfColumns=3)

        m.separator(style='none', width=140)
        self.uiTXTLST_test1 = m.textScrollList(
            'uiTXTLST_test1',
            allowMultiSelection=True,
            append=('one', 'two', 'three', 'four', 'five', 'six', 'seven',
                    'eight', 'nine', 'ten'))
        self.uiTXTLST_test2 = m.textScrollList(
            'uiTXTLST_test2',
            allowMultiSelection=True,
            append=('one', 'two', 'three', 'four', 'five', 'six', 'seven',
                    'eight', 'nine', 'ten'))

        # --------
        m.setParent(uiLAY_mainForm)

        self.uiBTN_savePrefs = m.button(label='Save Prefs',
                                        height=MAIN_BUTTONS_HEIGHT,
                                        command=self.onSavePrefsClicked)

        self.uiBTN_loadPrefs = m.button(label='Load Prefs',
                                        height=MAIN_BUTTONS_HEIGHT,
                                        command=self.onLoadPrefsClicked)

        self.uiBTN_resetPrefs = m.button(label='Reset Prefs',
                                         height=MAIN_BUTTONS_HEIGHT,
                                         command=self.onResetPrefsClicked)

        m.setParent('..')  # -> window

        m.formLayout(uiLAY_mainForm,
                     e=True,
                     attachForm=[(self.uiLAY_mainScroll, 'top', 2)])
        m.formLayout(uiLAY_mainForm,
                     e=True,
                     attachForm=[(self.uiLAY_mainScroll, 'left', 2)])
        m.formLayout(uiLAY_mainForm,
                     e=True,
                     attachForm=[(self.uiLAY_mainScroll, 'right', 2)])
        m.formLayout(uiLAY_mainForm,
                     e=True,
                     attachControl=[(self.uiLAY_mainScroll, 'bottom', 2,
                                     self.uiBTN_savePrefs)])

        m.formLayout(uiLAY_mainForm,
                     e=True,
                     attachNone=[(self.uiBTN_savePrefs, 'top')])
        m.formLayout(uiLAY_mainForm,
                     e=True,
                     attachForm=[(self.uiBTN_savePrefs, 'left', 2)])
        m.formLayout(uiLAY_mainForm,
                     e=True,
                     attachPosition=[(self.uiBTN_savePrefs, 'right', 2, 33)])
        m.formLayout(uiLAY_mainForm,
                     e=True,
                     attachForm=[(self.uiBTN_savePrefs, 'bottom', 2)])

        m.formLayout(uiLAY_mainForm,
                     e=True,
                     attachNone=[(self.uiBTN_loadPrefs, 'top')])
        m.formLayout(uiLAY_mainForm,
                     e=True,
                     attachPosition=[(self.uiBTN_loadPrefs, 'left', 2, 33)])
        m.formLayout(uiLAY_mainForm,
                     e=True,
                     attachPosition=[(self.uiBTN_loadPrefs, 'right', 2, 66)])
        m.formLayout(uiLAY_mainForm,
                     e=True,
                     attachForm=[(self.uiBTN_loadPrefs, 'bottom', 2)])

        m.formLayout(uiLAY_mainForm,
                     e=True,
                     attachNone=[(self.uiBTN_resetPrefs, 'top')])
        m.formLayout(uiLAY_mainForm,
                     e=True,
                     attachPosition=[(self.uiBTN_resetPrefs, 'left', 2, 66)])
        m.formLayout(uiLAY_mainForm,
                     e=True,
                     attachForm=[(self.uiBTN_resetPrefs, 'right', 2)])
        m.formLayout(uiLAY_mainForm,
                     e=True,
                     attachForm=[(self.uiBTN_resetPrefs, 'bottom', 2)])

        m.showWindow(self.window)
Ejemplo n.º 50
0
    def BuildUI(self):

        base.window("Auto Rigger")

        form = base.formLayout()
        tabs = base.tabLayout(imh=5, imw=5)

        base.formLayout(form,
                        edit=True,
                        attachForm=((tabs, 'top', 0), (tabs, 'left', 0),
                                    (tabs, 'right', 0), (tabs, 'bottom', 0)))

        ch1 = base.rowColumnLayout(nc=1,
                                   cal=(1, 'right'),
                                   adjustableColumn=True)

        base.image(w=400,
                   h=100,
                   image=os.path.dirname(os.path.realpath(__file__)) +
                   "\logo.jpg")
        settingsText = base.text('Settings', l='Rig Settings')
        base.separator(st='none')

        self.prefix = base.textFieldGrp(w=100, text='test', editable=True)
        self.spineCount = base.intSliderGrp(l="Spine Count",
                                            min=1,
                                            max=10,
                                            value=4,
                                            step=1,
                                            field=True)

        self.fingerCount = base.intSliderGrp(l="Finger Count",
                                             min=1,
                                             max=10,
                                             value=5,
                                             step=1,
                                             field=True)

        base.separator(h=10, st='none')
        self.doubleElbow = base.checkBox(l='Double Elbow', align='left')

        base.setParent('..')

        ch2 = base.rowColumnLayout(nc=1,
                                   cal=(1, 'right'),
                                   adjustableColumn=True)
        base.separator(h=10, st='none')
        base.button(l="Create Base Locators", w=200, c=self.DoLocators)
        base.separator(st='none')
        base.button(l="Create Secondary Locators",
                    w=200,
                    c="SL.SecondaryLocators()")
        base.separator(st='none')
        base.button(l="Mirror L->R",
                    w=200,
                    c="AutoRigger.Locators.mirrorLocators()")
        base.separator(st='none', h=20)
        base.button(l="Create Facial Locators", w=200, c=self.FaceLocators)
        base.separator(st='none')
        base.button(l="Delete All Locators",
                    w=200,
                    c="AutoRigger.Locators.deleteLocators()")

        base.setParent('..')
        ch3 = base.rowColumnLayout(nc=1,
                                   cal=(1, 'right'),
                                   adjustableColumn=True)

        base.separator(st='none')
        base.button(l="Joints Window",
                    w=200,
                    c="AutoRigger.Joints.CreateJointsWindow()")
        base.separator(st='none')

        base.setParent('..')
        ch4 = base.rowColumnLayout(nc=1,
                                   cal=(1, 'right'),
                                   adjustableColumn=True)
        base.button(l="Add Facial Joints", w=200, c=self.FaceJoints)
        base.separator(st='none')

        base.setParent('..')
        ch5 = base.rowColumnLayout(nc=1,
                                   cal=(1, 'right'),
                                   adjustableColumn=True)

        base.button(l="Finalize Rig", w=200, c=self.FinalizeRig)
        base.separator(st='none')
        base.button(l="Bind Skin", w=200, c="Constraints.BindSkin()")
        base.separator(st='none')
        base.button(l="Clear Locators", w=200, c=self.ClearScene)

        base.setParent('..')

        base.tabLayout(tabs,
                       edit=True,
                       tabLabel=((ch1, 'Settings'), (ch2, 'Locators'),
                                 (ch3, 'Body Rig'), (ch4, 'Face Rig'),
                                 (ch5, 'Finalize')))

        base.showWindow()
def treegen( plength, piterations, ptreetype, pmaterialtype, prgbs, pleafscale, pleavesamount, prgbleaves, papplecheck, pleafcheck, pangle, pleaves, ptreetype2, progress, pleafmaterial, *pArgs):
	'''using the user inputs from createUI to set the variable that will define the characteristics of the tree
	
	  plength       : the path name of the length control which through querying will be used to set the length of the cyclinders that make up the entire tree structure
      piterations   : the path name of the iterations control which through querying will be used to set the number of iterations
      ptreetype     : the path name of the treetype control which through querying will be used to set the axiom and rules for the various treetypes (1-4)
      prgbs         : the path name of the rgbs control which through querying will be used to set the colour of the trunk and branches
      pleavesamount : the path name of the leavesamount control which through querying will be used to set the thickness of the leaves,
                      by specifying the leaf rule (l rule) in the dictionary, e.g l = ll
      prgbleaves    : the path name of the rgbleaves control which through querying will be used to set the rgb of the leaves
      papplecheck   : the path name of the applecheck control which through querying will be used to enable or disable fruit/apples in the tree
      pleafcheck    : the path name of the leafcheck control which through querying will be used to enable or disable leaves in the tree
      pangle        : the path name of the angle control which through querying will be used to set the starting angle in which brnaches in the tree will be created
      pleaves       : the path name of the leaves control which through querying will be used to set the type of leaves that will be generated (maple, standard)
      ptreetype2    : the path name of the treetype2 control which through querying will be used to set the axiom and rules for the 5th 6th and 7th treetypes (5-7)
      progress      : the path name of the progress control which through querying will be used to increment or set the specific value of the progress bar
	   
	'''
	
	cmds.progressBar(progress, pr = 0,  edit=True)
	
	#for the undo tool
	#saving previous scene before it gets deleted for the next tree generation
	cmds.file(rename="/home/s5113911/PythonProgramming/Project/previous")
	saved = cmds.file(save=True, type="mayaAscii")

	# clear up the scene
	cmds.select(all=True)
	cmds.delete()
	
	modelGroup = []
	
	actionString = ""	# the final action string to build the tree
	
	apple = False
	leaf = False
	lamount = 0

	axiom, ruleDictionary = treetype(cmds.radioButtonGrp(ptreetype, query=True, select=True), cmds.radioButtonGrp(ptreetype2, query=True, select=True))
	
	material = materialtype(cmds.radioButtonGrp(pmaterialtype, query=True, select=True))
	leafmaterial = materialtype(cmds.radioButtonGrp(pleafmaterial, query=True, select=True))
	
	leaftype = cmds.radioButtonGrp(pleaves, query=True, select=True)
	
	leavesamount = cmds.radioButtonGrp(pleavesamount, query=True, select=True)
	
	
	if(cmds.checkBoxGrp(papplecheck, query=True, value1=True)):
	    cmds.file("/home/s5113911/PythonProgramming/Project/apple.ma", i=True)
	    #cmds.file("\home\xyang\maya_scripts\submission\models\apple.ma", i = True)
	    apple = True
	    
	if(cmds.checkBoxGrp(pleafcheck, query=True, value1=True)):
	    if leaftype ==1:
	        #cmds.file("/home/s5113911/PythonProgramming/Project/leafy1.ma", i=True)
   	        cmds.file("/home/s5113911/PythonProgramming/Project/leafynomaterial.ma", i=True)
	       
	        #cmds.file("\home\xyang\maya_scripts\submission\models\leafy1.ma", i=True)
	    if leaftype ==2:
	        cmds.file("/home/s5113911/PythonProgramming/Project/mapleleaf2.ma", i=True)
	        #cmds.file("\home\xyang\maya_scripts\submission\models\mapleleaf2.ma", i = True)
	    leaf =True
	   
	iterations = cmds.intSliderGrp(piterations, query=True, value=True)
	stepLength = cmds.floatSliderGrp(plength, query=True, value=True)
	
	rgb = cmds.colorSliderGrp(prgbs, query=True, rgbValue=True)
	leavesrgb = cmds.colorSliderGrp(prgbleaves, query=True, rgbValue=True)
	leafscale = cmds.floatSliderGrp(pleafscale, query=True, value=True)
	angle = cmds.floatSliderGrp(pangle, query=True, value=True)
	
   
	if leavesamount==2:
	    addRule(ruleDictionary, "l", "ll")
	    lamount = 2
	
	# create the action string
	finalString=iterate(axiom, iterations, ruleDictionary)
	
	# create the 3D model
	modelGroup = createModel(finalString, stepLength, angle, leafscale, leaf, apple, progress)
	
	
	# set the color to green
	setMaterial(modelGroup[0], modelGroup[1], material, leafmaterial, rgb ,leavesrgb, progress)
Ejemplo n.º 52
0
def run_command(b):
    n_jnts = cmds.intSliderGrp('intJoints_ISG_UI', q=1, v=1)
    n_ctrl = cmds.intSliderGrp('intControl_ISG_UI', q=1, v=1)
    VK_system(n_ctrl, n_jnts, b)
Ejemplo n.º 53
0
def translatorOptions(parent, action, initialSettings, resultCallback):
    defaults = {
        "activeCamera": "<Current>",
        "exportAnim": False,
        "startFrame": 1,
        "endFrame": 100,
        "stepFrame": 1
    }

    createGlobalNodes()

    if initialSettings:
        logger.debug("Parsing initial translator settings %s" %
                     initialSettings)

        opts = initialSettings.split(";")
        for opt in opts:
            opt = opt.strip()

            if opt == "":
                continue

            name, value = opt.split("=")
            if name in defaults:
                if isinstance(defaults[name], basestring):
                    defaults[name] = value
                elif isinstance(defaults[name], bool):
                    defaults[name] = bool(value)
                elif isinstance(defaults[name], int):
                    defaults[name] = int(value)
                else:
                    logger.warning("Unhandled param %s in translator options" %
                                   name)

    if action == "post":
        mc.setParent(parent)
        mc.setUITemplate("DefaultTemplate", pushTemplate=True)
        mc.columnLayout(adj=True)

        mc.optionMenuGrp("as_exportOpts_activeCamera", label="Render camera")
        mc.menuItem(label='<Current>', divider=True)
        for camera in mc.ls(type='camera'):
            if mc.getAttr(camera + '.orthographic'):
                continue
            if not mc.getAttr(camera + ".renderable"):
                continue

            mc.menuItem(label=camera)

        mc.separator(style="single")

        def exportAnimChanged(value):
            mc.intSliderGrp("as_exportOpts_startFrame",
                            edit=True,
                            enable=value)

            mc.intSliderGrp("as_exportOpts_endFrame", edit=True, enable=value)

            mc.intSliderGrp("as_exportOpts_stepFrame", edit=True, enable=value)

        exportAnim = defaults["exportAnim"]
        mc.checkBoxGrp("as_exportOpts_exportAnim",
                       numberOfCheckBoxes=1,
                       label=" ",
                       label1="Animation",
                       cc=exportAnimChanged,
                       value1=exportAnim)

        mc.intSliderGrp("as_exportOpts_startFrame",
                        label="Start:",
                        field=True,
                        min=1,
                        max=1000,
                        enable=exportAnim,
                        value=defaults["startFrame"])

        mc.intSliderGrp("as_exportOpts_endFrame",
                        label="End:",
                        field=True,
                        min=1,
                        max=1000,
                        enable=exportAnim,
                        value=defaults["endFrame"])

        mc.intSliderGrp("as_exportOpts_stepFrame",
                        label="Step:",
                        field=True,
                        min=1,
                        max=100,
                        enable=exportAnim,
                        value=defaults["stepFrame"])

    elif action == "query":
        options = ""

        value = mc.optionMenuGrp("as_exportOpts_activeCamera",
                                 query=True,
                                 value=True)

        # Replace current by the active camera.
        if value == "<Current>":
            if om.MGlobal.mayaState() == om.MGlobal.kInteractive:
                camera = om.MDagPath()
                omui.M3dView.active3dView().getCamera(camera)

                if mc.getAttr(camera.partialPathName() + ".renderable"):
                    value = camera.partialPathName()
                else:
                    logger.warning("Active camera not renderable. Ignoring.")
                    value = ""
            else:
                logger.warning("Active camera specified for maya batch.")
                value = ""

        if value:
            options += "activeCamera=" + value + ";"

        exportAnim = mc.checkBoxGrp("as_exportOpts_exportAnim",
                                    query=True,
                                    value1=True)
        if exportAnim:
            options += "exportAnim=true;"

            value = mc.intSliderGrp("as_exportOpts_startFrame",
                                    query=True,
                                    value=True)
            options += "startFrame=" + str(value) + ";"

            value = mc.intSliderGrp("as_exportOpts_endFrame",
                                    query=True,
                                    value=True)
            options += "endFrame=" + str(value) + ";"

            value = mc.intSliderGrp("as_exportOpts_stepFrame",
                                    query=True,
                                    value=True)
            options += "stepFrame=" + str(value) + ";"

        logger.debug("calling translator callback, options = %s" % options)
        mel.eval('%s "%s"' % (resultCallback, options))
Ejemplo n.º 54
0
def bdSetToesNumber(args):
    bdToesNumberVal = cmds.intSliderGrp("bdToesNumber", q=True, v=True)
Ejemplo n.º 55
0
def bdSetFingersNumber(args):
    bdFingerNumbersVal = cmds.intSliderGrp("bdFingersNumber", q=True, v=True)
Ejemplo n.º 56
0
    def ui(self):
        '''
        Launch a UI to display the marks that were recorded.
        '''

        with utl.MlUi(
                'ml_stopwatchReport',
                'Stopwatch Report',
                width=400,
                height=400,
                info='''This is the report from the stopwatch you just ran.
Adjust the start frame, and then press the frame buttons to jump to that frame.
The fields on the right can be used for notes.''',
                menu=False) as win:

            self.uiSlider = mc.intSliderGrp(
                field=True,
                label='Start Frame',
                value=self.startFrame,
                minValue=((-0.5 * self.frameMarks[-1]) + self.startFrame),
                maxValue=(self.frameMarks[-1] / 2) + self.startFrame,
                fieldMinValue=-1000,
                fieldMaxValue=1000,
                changeCommand=self.uiUpdateStartFrame)

            self.frameRateField = mc.intFieldGrp(label='Frame Rate',
                                                 value1=self.frameRate,
                                                 enable1=False,
                                                 extraLabel='fps',
                                                 annotation='')

            mc.scrollLayout()
            mc.rowColumnLayout(numberOfColumns=3,
                               columnWidth=[(1, 50), (2, 80), (3, 340)])
            mc.text('Frame')
            mc.text('Duration')
            mc.text('Notes')

            for i in range(3):
                mc.separator(style='single', height=15)

            self.uiButton = list()

            for i in range(len(self.frameMarks)):

                #frame button
                frame = self.frameMarks[i] + self.startFrame
                self.uiButton.append(
                    mc.button(
                        label=str(frame),
                        annotation='Go to frame %i' % frame,
                        command=
                        'import maya.cmds;maya.cmds.currentTime(%i,edit=True)'
                        % frame))

                #duration text
                if i:
                    mc.text(label=str(self.frameMarks[i] -
                                      self.frameMarks[i - 1]))
                else:
                    mc.text(label='Start')

                #notes field
                mc.textField()

            #add the stop
            mc.text(label='')
            mc.text(label='Stop')
            mc.setParent('..')
            mc.setParent('..')

            #next and prev buttons!
            mc.paneLayout(configuration='vertical2', separatorThickness=1)
            mc.button(label='<< Previous',
                      command=self.previousFrame,
                      annotation='Go to the previous frame in the list.')
            mc.button(label='Next >>',
                      command=self.nextFrame,
                      annotation='Go to the next frame in the list.')
Ejemplo n.º 57
0
    def displayUI(self):
        RigGUI = 'autoRigging'
        if rig.window(RigGUI, exists=True):
            rig.deleteUI(RigGUI)
        rig.window(RigGUI,
                   title=' 2009 AutoRig',
                   menuBar=True,
                   wh=(400, 500),
                   minimizeButton=True,
                   maximizeButton=True)

        #===============================================================================
        # 开始菜单
        #===============================================================================
        rig.menu(label='File', tearOff=True)
        rig.menuItem(label='New')
        rig.menuItem(label='Open')
        rig.menuItem(label='Save')
        rig.menuItem(divider=True)
        rig.menuItem(label='Quit')
        rig.menu(label='Help', helpMenu=True)
        rig.menuItem('Application..."',
                     label=u'帮助文档',
                     c='from RIG.Help.helpUI import *;SK_helptUI()')

        self.tabs = rig.tabLayout(innerMarginWidth=5, innerMarginHeight=5)
        #===============================================================================
        # 开始"AutoRiggingLayout"
        #===============================================================================
        self.AutoRiggingLayout = rig.columnLayout(w=100,
                                                  h=600,
                                                  columnAlign='center')

        rig.button(label=u'     导入模版     ', w=322, c='SK_BodyJointPosition()')
        rig.separator(w=322, h=15, style='in')
        rig.setParent(self.AutoRiggingLayout)

        rig.intSliderGrp('fingerNumsField',
                         field=True,
                         label=u'手指个数:',
                         minValue=0,
                         maxValue=5,
                         fieldMinValue=0,
                         fieldMaxValue=100,
                         value=5,
                         columnAttach=[(1, 'left', 0), (2, 'left', 0),
                                       (3, 'both', 0)],
                         columnWidth3=(55, 50, 222))
        rig.intSliderGrp('toesNumsField',
                         field=True,
                         label=u'脚趾个数:',
                         minValue=0,
                         maxValue=5,
                         fieldMinValue=0,
                         fieldMaxValue=100,
                         value=5,
                         columnAttach=[(1, 'left', 0), (2, 'left', 0),
                                       (3, 'both', 0)],
                         columnWidth3=(55, 50, 222))
        rig.intSliderGrp('neckSegsField',
                         field=True,
                         label=u'脖子段数:',
                         minValue=2,
                         maxValue=5,
                         fieldMinValue=2,
                         fieldMaxValue=100,
                         value=2,
                         columnAttach=[(1, 'left', 0), (2, 'left', 0),
                                       (3, 'both', 0)],
                         columnWidth3=(55, 50, 222))
        rig.intSliderGrp('waistSegsField',
                         field=True,
                         label=u'腰部段数:',
                         minValue=3,
                         maxValue=10,
                         fieldMinValue=4,
                         fieldMaxValue=100,
                         value=0,
                         columnAttach=[(1, 'left', 0), (2, 'left', 0),
                                       (3, 'both', 0)],
                         columnWidth3=(55, 50, 222))
        rig.setParent(self.AutoRiggingLayout)

        rig.separator(w=322, h=15, style='in')

        rig.rowColumnLayout(numberOfColumns=2,
                            columnWidth=[(1, 161), (2, 161)],
                            columnAttach=(2, 'both', 0))
        rig.button(label=u' 刷新模版  ', w=130, c='SK_refreshTemp()')
        rig.button(label=u' 镜像骨骼 ', w=130, c='orientAndMirrorJoint ()')
        rig.setParent(self.AutoRiggingLayout)

        rig.separator(w=322, h=15, style='in')

        rig.text(l=u'选择项目')  #选择项目
        rig.radioCollection()
        rig.rowColumnLayout(nc=3, columnWidth=[(1, 100), (2, 100), (3, 100)])
        self.OrigenRB = rig.radioButton(label=u'初始版本', sl=1)
        self.WoodliesRB = rig.radioButton(label='Woodlies')
        self.WinxTVRB = rig.radioButton(label='WinxTV', vis=False)
        rig.setParent(self.AutoRiggingLayout)

        rig.button(label=u' 生成身体设置  ',
                   w=322,
                   h=40,
                   c=lambda x: self.buildSetup())

        rig.separator(w=322, h=15, style='in')

        rig.columnLayout('MeshListLayout')
        rig.textScrollList('meshList',
                           w=322,
                           h=100,
                           allowMultiSelection=True,
                           deleteKeyCommand='SK_delMeshList() ')
        rig.setParent(self.AutoRiggingLayout)

        rig.separator(w=322, h=15, style='in')

        rig.rowColumnLayout(numberOfColumns=2,
                            columnWidth=[(1, 161), (2, 161)],
                            columnAttach=(2, 'both', 0))
        rig.button(label=u' 添加绑定模型 ', w=130, c='SK_addMeshList()')
        rig.button(label=u' 对绑定模型蒙皮 ', w=130, c='SK_rigSkin()')
        rig.setParent(self.AutoRiggingLayout)

        rig.separator(w=322, h=15, style='in')
        rig.button(l=u'IK<-->FK', w=322, h=40, c='SK_IKFKSwitchCommand()')

        rig.separator(w=322, h=15, style='in')
        rig.button(l=u'恢复初始POSE', w=322, h=40, c='SK_creatConDefaultPos(0)')

        rig.setParent(self.tabs)
        #===============================================================================
        # 开始"assemblageLayout"
        #===============================================================================
        self.assemblageLayout = rig.columnLayout(w=300, h=355)

        rig.text(u'1:->选择你要复制的部件2:->在下面的输入复制的数量\n3:->完成复制4:->完成镜像')
        rig.rowColumnLayout('skinningLayout',
                            numberOfColumns=3,
                            columnWidth=[(1, 109), (2, 109), (3, 109)],
                            columnAttach=(2, 'both', 0))
        rig.intField('numOfduplicate', min=1, max=100, value=1, step=1)
        rig.button(label=u' 完成复制 ', c='SK_duplicateJnt()')
        rig.button(label=u' 完成镜像 ', c='SK_mirrorDupJoint ()')
        rig.setParent('..')
        rig.separator(w=332, h=15, style='in')

        rig.setParent(self.tabs)
        #===============================================================================
        # 开始"RiggingToolsLayout"
        #===============================================================================
        self.RiggingToolsLayout = rig.columnLayout(w=300, h=355)

        #------------------------------------------------------------------------------
        modelFL = rig.frameLayout(w=327,
                                  label=u"模型工具",
                                  borderStyle='in',
                                  cll=True,
                                  cl=True)
        rig.frameLayout(modelFL,
                        edit=True,
                        expandCommand="rig.frameLayout(\"" + modelFL +
                        "\" ,edit=True,h=200)")
        rig.frameLayout(modelFL,
                        edit=True,
                        collapseCommand="rig.frameLayout(\"" + modelFL +
                        "\" ,edit=True,h=20)")
        rig.columnLayout()

        rig.separator(w=312, h=5, style='in')
        rig.button(
            label=u' 打开模型工具窗口 ',
            w=312,
            c='from RIG.tools.modelTools.modelUI import *; SK_modelUI()')

        rig.setParent(self.RiggingToolsLayout)
        #------------------------------------------------------------------------------
        simulationFL = rig.frameLayout(w=327,
                                       label=u"解算设置工具",
                                       borderStyle='in',
                                       cll=True,
                                       cl=True)
        rig.frameLayout(simulationFL,
                        edit=True,
                        expandCommand="rig.frameLayout(\"" + simulationFL +
                        "\" ,edit=True,h=200)")
        rig.frameLayout(simulationFL,
                        edit=True,
                        collapseCommand="rig.frameLayout(\"" + simulationFL +
                        "\" ,edit=True,h=20)")
        rig.columnLayout()

        rig.separator(w=312, h=5, style='in')
        rig.text(u'增加布料设置')
        rig.button(
            label=u' 打开布料设置窗口 ',
            w=312,
            c='from RIG.simulation.simulationUI import *; SK_simulationUI()')

        rig.separator(w=312, h=5, style='in')
        rig.text(u'增加动力学IK设置')
        rig.button(
            label=u' 打开动力学IK设置设置窗口 ',
            w=312,
            c='from RIG.tools.dynamicCurve.DC_dynamicCurveUI import *; SK_dynamicIKUI()'
        )

        rig.separator(w=312, h=5, style='in')
        rig.text(u'导入导出头发Cache工具')
        rig.button(
            label=u' 打开头发Cache窗口 ',
            w=312,
            c='from RIG.tools.ImportExportHairCache.hairCacheUI import *; SK_HairCacheUI()'
        )

        rig.setParent(self.RiggingToolsLayout)
        #------------------------------------------------------------------------------
        fingerFL = rig.frameLayout(w=327,
                                   label=u"手指工具",
                                   borderStyle='in',
                                   cll=True,
                                   cl=True)
        rig.frameLayout(fingerFL,
                        edit=True,
                        expandCommand="rig.frameLayout(\"" + fingerFL +
                        "\" ,edit=True,h=200)")
        rig.frameLayout(fingerFL,
                        edit=True,
                        collapseCommand="rig.frameLayout(\"" + fingerFL +
                        "\" ,edit=True,h=20)")
        rig.scrollLayout()
        fingerMoLayout = rig.columnLayout()

        rig.separator(w=312, h=5, style='in')
        rig.text(u' 增加手指工具')
        rig.button(label=u' 打开窗口 ', w=312, c='SK_fingerAnimUI()')
        rig.setParent(self.RiggingToolsLayout)
        #------------------------------------------------------------------------------
        resetFL = rig.frameLayout(w=327,
                                  label=u"恢复工具",
                                  borderStyle='in',
                                  cll=True,
                                  cl=True)
        rig.frameLayout(resetFL,
                        edit=True,
                        expandCommand="rig.frameLayout(\"" + resetFL +
                        "\" ,edit=True,h=200)")
        rig.frameLayout(resetFL,
                        edit=True,
                        collapseCommand="rig.frameLayout(\"" + resetFL +
                        "\" ,edit=True,h=20)")
        rig.scrollLayout()
        resetMoLayout = rig.columnLayout()

        rig.text(u"重新恢复到模版文件")
        rig.button(label=u' 恢复 ', w=312, c='SK_restoreJoint(True)')
        rig.setParent(self.RiggingToolsLayout)
        #------------------------------------------------------------------------------
        curveFL = rig.frameLayout(w=327,
                                  label=u"曲线工具",
                                  borderStyle='in',
                                  cll=True,
                                  cl=True)
        rig.frameLayout(curveFL,
                        edit=True,
                        expandCommand="rig.frameLayout(\"" + curveFL +
                        "\" ,edit=True,h=200)")
        rig.frameLayout(curveFL,
                        edit=True,
                        collapseCommand="rig.frameLayout(\"" + curveFL +
                        "\" ,edit=True,h=20)")
        curveMoScr = rig.scrollLayout()
        rig.columnLayout()

        rig.text(u" 导入-导出控制器形状 ")
        rig.button(
            label=u' 打开窗口',
            w=312,
            c='from RIG.tools.importExputCurveShape import *\nSK_ImportExportUI().displayUI()'
        )
        rig.separator(w=312, h=15, style='in')

        rig.text(u"镜像控制器形状")
        rig.rowColumnLayout('curveMirrorLayout',
                            numberOfColumns=2,
                            columnWidth=[(1, 156), (2, 156)],
                            columnAttach=(2, 'both', 0))
        rig.button(l=u'左 ——>右', c='SK_MirrorCurveControlCmd(1)')
        rig.button(l=u'右 ——>左', c='SK_MirrorCurveControlCmd(0)')
        rig.separator(w=312, h=15, style='in')
        rig.setParent('..')

        rig.text(u" 增加控制器到bodySet ")
        rig.button(
            label=u' 增加',
            w=312,
            c='from RIG.tools.addSet import *\nSK_AddToSet("bodySet",rig.ls(sl = True),True)'
        )
        rig.separator(w=312, h=15, style='in')
        rig.setParent(self.RiggingToolsLayout)
        #------------------------------------------------------------------------------
        extraFL = rig.frameLayout('extraFrame',
                                  w=327,
                                  label=u"附加工具",
                                  borderStyle='in',
                                  cll=True,
                                  cl=True)
        rig.frameLayout(extraFL,
                        edit=True,
                        expandCommand="rig.frameLayout(\"" + extraFL +
                        "\" ,edit=True,h=300)")
        rig.frameLayout(extraFL,
                        edit=True,
                        collapseCommand="rig.frameLayout(\"" + extraFL +
                        "\" ,edit=True,h=20)")
        rig.columnLayout()

        #   选择骨骼增加控制器
        rig.text(u'为选择的骨骼添加控制器:')
        rig.button(label=u'确定', w=312, c='buildSKTOCON()')
        rig.separator(w=312, h=15, style='in')

        #   将软选择变形器转为CLUSTER
        rig.text(u'将softMod转为cluster:')
        rig.button(label=u'确定', w=312, c='softModToCluster()')
        rig.separator(w=312, h=15, style='in')

        rig.text(u'重设簇的形节点位置:')
        rig.button(label=u'确定', w=312, c='resetClusterPos()')
        rig.separator(w=312, h=15, style='in')

        rig.text(u'关闭场景中局部旋转轴向显示:')
        rig.button(label=u'确定', w=312, c='TL_CloseDisplayLocalAxis()')
        rig.separator(w=312, h=15, style='in')

        rig.text(u'创建线性IK:')
        rig.button(
            label=u'打开窗口',
            w=312,
            c='from RIG.tools.IKsplineTool.ikSpline import * \nIKSplineUI()')
        rig.setParent(self.RiggingToolsLayout)
        #------------------------------------------------------------------------------
        skinFL = rig.frameLayout('skinTools',
                                 w=327,
                                 label=u"权重工具",
                                 borderStyle='in',
                                 cll=True,
                                 cl=True)
        rig.frameLayout(skinFL,
                        edit=True,
                        expandCommand="rig.frameLayout(\"" + skinFL +
                        "\" ,edit=True,h=200)")
        rig.frameLayout(skinFL,
                        edit=True,
                        collapseCommand="rig.frameLayout(\"" + skinFL +
                        "\" ,edit=True,h=20)")
        rig.columnLayout()

        rig.separator(w=312, h=5, style='in')
        rig.text(u' 将一个物体的权重拷给多个物体')
        rig.button(
            label=u' 确定 ',
            w=312,
            c='from RIG.tools.copyWeigths import *\nSK_copyWeightToOtherObj()')

        rig.separator(w=312, h=5, style='in')
        rig.text(u'检测是否有影响物体重叠')
        rig.button(
            label=u' 确定 ',
            w=312,
            c='from RIG.tools.detectInfluence import *\ndetectInfluenceObj()')

        rig.separator(w=312, h=5, style='in')
        rig.text(u'导入导出权重')
        rig.button(
            label=u' 打开工具窗口 ',
            w=312,
            c='from RIG.tools.IOWeights.IOWeightsUI import *\nSK_IOWeightsUI()'
        )

        rig.setParent(self.RiggingToolsLayout)
        rig.setParent(self.tabs)
        #===============================================================================
        # 开始"faceRiggingLayout"
        #===============================================================================
        self.faceRiggingLayout = rig.columnLayout(w=300, h=355)

        rig.button(l=u'打开面部设置窗口',
                   c='from RIG.face.faceUI import *\nOpenFaceUI()',
                   w=325)

        rig.separator(w=325, h=5, style='in')
        rig.button(l=u'打开最新面部设置窗口',
                   c='import RIG.WDface.WD_FaceUI as face;face.WD_SelectUI()',
                   w=325)

        rig.separator(w=325, h=5, style='in')
        rig.text(u' 增加下颚设置')
        rig.rowColumnLayout(numberOfColumns=2,
                            columnWidth=[(1, 162), (2, 162)])
        rig.button(label=u' 确定 ',
                   c='from RIG.tools.AddJawSetup import *\nSK_AddJawSetup()')
        rig.button(
            l=u'移除设置',
            c='from RIG.tools.AddJawSetup import *\nSK_removeJawSetup()')
        rig.setParent('..')

        rig.separator(w=325, h=5, style='in')
        rig.text(u' 增加眼睛设置')
        rig.rowColumnLayout(numberOfColumns=3,
                            columnWidth=[(1, 108), (2, 108), (3, 108)],
                            columnAttach=(3, 'both', 0))
        rig.button(
            l=u'导入控制器',
            c='from RIG.tools.AddEyeSetup import SK_AddEyeSetup\nSK_AddEyeSetup(True)'
        )
        rig.button(
            l=u'完成设置',
            c='from RIG.tools.AddEyeSetup import SK_AddEyeSetup\nSK_AddEyeSetup(False)'
        )
        rig.button(
            l=u'移除设置',
            c='from RIG.tools.AddEyeSetup import SK_removeEyeSetup\nSK_removeEyeSetup()'
        )

        rig.setParent(self.tabs)
        rig.tabLayout( self.tabs,edit=True,tabLabel=((self.AutoRiggingLayout,'AutoRigging'), (self.assemblageLayout,'assemblage'),  (self.RiggingToolsLayout,'RiggingTools'),(self.faceRiggingLayout,'faceRigging')),\
                       selectTabIndex = self.getOptionVar(),changeCommand = lambda x = 0:self.setOptionVar())

        rig.showWindow(RigGUI)
        rig.window(RigGUI, e=True, wh=(344, 680))
Ejemplo n.º 58
0
    def makeUI(self):

        global editMode

        # Background colour for all labels.
        label_colour = (0.450, 0.541, 0.858)

        cmds.window(self.name)

        cmds.rowColumnLayout(nc=2)

        cmds.frameLayout(label="Name Rig", bgc=label_colour)

        # Prefix to be assigned throughout Rig to all locators, joints and controls.
        cmds.text(label="Rig Name Prefix")
        self.prefixField = cmds.textField(text='Tom')

        # Creates label for Step 1 and sliders to control spine count and finger count.
        cmds.frameLayout(label="Step 1: Skeleton Options", bgc=label_colour)

        self.spineCount = cmds.intSliderGrp(l="Spine Count (Incl. Chest)",
                                            min=2,
                                            max=10,
                                            value=4,
                                            step=1,
                                            field=True)
        self.fingerCount = cmds.intSliderGrp(l="Finger Count (Incl. Thumb)",
                                             min=1,
                                             max=10,
                                             value=5,
                                             step=1,
                                             field=True)

        # Creates label for Step 2 and buttons to create, delete and mirror locators.
        cmds.frameLayout(label="Step 2: Create Locators", bgc=label_colour)

        cmds.button(l="Create Locators", w=200, c=self.createBaseLocators)
        cmds.button(l="Delete Locators", w=200, c=self.deleteLocators)
        cmds.button(l="Mirror L->R", w=200, c=self.mirrorLocators)

        cmds.text(label="Scale Locator Group to match size of character")

        # Creates label for Step 3 and buttons to create and delete secondary locators.
        cmds.frameLayout(label="Step 3: Create Secondary Locators",
                         bgc=label_colour)

        cmds.button(l="Create Secondary Locators",
                    w=200,
                    c=self.createSecondaryLocators)
        cmds.button(l="Delete Secondary Locators",
                    w=200,
                    c=self.deleteSecondaryLocators)

        #cmds.button(l = "Lock/Unlock", w = 200, c = partial(self.lockAll,editMode))

        # Creates label for Step 4 and buttons to create and delete joints
        cmds.frameLayout(label="Step 4: Create Skeleton", bgc=label_colour)

        cmds.button(l="Create Joints", w=200, c=self.createJoints)
        cmds.button(l="Delete Joints", w=200, c=self.deleteJoints)

        # Creates label for Step 5 and buttons to create and set controllers
        cmds.frameLayout(label="Step 5: Create Controllers", bgc=label_colour)

        cmds.button(l="Create Controllers", w=200, c=self.createControllers)

        cmds.text(
            label=
            "Use to change size of controller without affecting child controllers:"
        )

        cmds.button(l="Select CV's of Controller",
                    w=200,
                    c=self.editControllers)

        cmds.button(l="Mirror L->R", w=200, c=self.mirrorControllers)

        cmds.button(l="Set Controllers", w=200, c=self.setControllers)
        cmds.text(label="Won't change or affect knee pole vector controllers.")

        # Creates label for Step 6 and buttons to create IK's and constraints
        cmds.frameLayout(label="Step 6: Create IK and Constraints",
                         bgc=label_colour)

        cmds.button(l="Create IK", w=200, c=self.createIK)
        cmds.button(l="Create Constraints", w=200, c=self.createContraints)

        # Creates label for Step 7 and buttons to bind skin
        cmds.frameLayout(label="Step 7: Bind Skin", bgc=label_colour)

        cmds.button(l="Bind Skin", w=200, c=self.bindSkin)

        # Creates label for Step 8 and buttons to finalise
        cmds.frameLayout(label="Step 8: Finalise Rig", bgc=label_colour)

        cmds.button(l="Finalise Rig", w=200, c=self.finalizeRig)

        # Creates UI window
        cmds.showWindow()
Ejemplo n.º 59
0
    def buildSplineIKFK(cls, *args):
        '''
        Main method.
        '''

        numOfCtrl = cmds.intSliderGrp(cls.uiWdgDic['numCtrlIntSldrGrp'],
                                      q=True,
                                      v=True)
        ctrlNumOfSpan = numOfCtrl - 1
        ctrlIncreNum = 1.0 / ctrlNumOfSpan

        numOfJnt = cmds.intSliderGrp(cls.uiWdgDic['numJntIntSldrGrp'],
                                     q=True,
                                     v=True)
        jntNumOfSpan = numOfJnt - 1
        jntIncreNum = 1.0 / jntNumOfSpan

        stretchOpt = cmds.checkBoxGrp(cls.uiWdgDic['optChkBoxGrp'],
                                      q=True,
                                      v2=True)

        crv = cmds.ls(sl=True)[0]
        # for crv in crvLs:

        # # Create control layout
        # crvBndJntLs = cls.ctrlLayout(crv, numOfCtrl, ctrlNumOfSpan, ctrlIncreNum)

        # # Create joint chain
        # bndJntLs = cls.jntChain(crv, numOfJnt, jntIncreNum)

        # Build spline IK
        ikh = cmds.ikHandle(sol='ikSplineSolver',
                            sj=cls.bndJntLs[0],
                            ee=cls.bndJntLs[-1],
                            curve=crv,
                            ccv=False,
                            pcv=False)[0]

        # Create controls
        ctrlLs = cls.createCtrl(crv, cls.crvBndJntLs)

        # Bind curve with curve bind joints
        cmds.select(cls.crvBndJntLs, crv, r=True)
        cmds.skinCluster(dr=4, toSelectedBones=True, bindMethod=0)

        # Turn off inherits transform of curve transform node.
        cmds.setAttr('%s.inheritsTransform' % crv, False)

        # Add stretch function
        if stretchOpt:
            cls.stretchy(crv, cls.bndJntLs)

        # Twist set up
        cmds.setAttr('%s.dTwistControlEnable' % ikh, True)
        cmds.setAttr('%s.dWorldUpType' % ikh, 4)
        cmds.connectAttr('%s.worldMatrix[0]' % ctrlLs[1],
                         '%s.dWorldUpMatrix' % ikh)
        cmds.connectAttr('%s.worldMatrix[0]' % ctrlLs[-1],
                         '%s.dWorldUpMatrixEnd' % ikh)

        # Setup scaleNormalize curve
        scaleNormalizeCrv = cls.setUpScaleNormalizeCurve(crv)

        # Add dynamic function

        # Clean up outliner
        cls.cleanUpOutliner(cls.crvBndJntLs, cls.bndJntLs, ctrlLs, crv,
                            scaleNormalizeCrv, ikh)

        # Connect attributes
        cls.connections(crv, cls.bndJntLs)
Ejemplo n.º 60
0
 def __init__(self):
     self.name = "rsObjectsInPathUI"
     self.title = "rs Objects In Path"
     i_windowSize = (300, 385)
     if (cmds.window(self.name, q=1, exists=1)):
         cmds.deleteUI(self.name)
     self.window = cmds.window(self.name, title=self.title)
     s_winColPro2 = cmds.columnLayout(adjustableColumn=True,
                                      parent=self.window)
     s_winLayOr = cmds.frameLayout(label='Constrain objects in path',
                                   li=70,
                                   borderStyle='etchedOut',
                                   height=140,
                                   parent=s_winColPro2)
     s_winColA = cmds.columnLayout(adjustableColumn=True, parent=s_winLayOr)
     cmds.separator(height=10, style="none", hr=True, parent=s_winColA)
     self.intSliderObInPa = cmds.intSliderGrp(field=True,
                                              label='Objects in Path',
                                              cal=(1, "center"),
                                              cw=[(1, 90), (2, 50),
                                                  (3, 100)],
                                              ad3=3,
                                              minValue=3,
                                              maxValue=50,
                                              fieldMinValue=3,
                                              fieldMaxValue=1000,
                                              value=3,
                                              parent=s_winColA)
     cmds.separator(height=10, style="none", hr=True, parent=s_winColA)
     cmds.rowLayout(numberOfColumns=6,
                    cw=[(1, 2), (2, 90), (3, 2), (4, 90), (5, 5), (6, 110)],
                    parent=s_winColA)
     cmds.separator(height=10, style="none", hr=True, parent=s_winColA)
     s_winLayOptions = cmds.frameLayout(lv=False,
                                        borderStyle='in',
                                        parent=s_winColA)
     s_winLayOptionsCol = cmds.columnLayout(adjustableColumn=True,
                                            parent=s_winLayOptions)
     cmds.separator(height=5,
                    style="none",
                    hr=True,
                    parent=s_winLayOptionsCol)
     s_winRowA = cmds.rowLayout(numberOfColumns=6,
                                cw=[(1, 2), (2, 90), (3, 2), (4, 90),
                                    (5, 5), (6, 110)],
                                parent=s_winLayOptionsCol)
     cmds.separator(height=5, style="none", hr=True, parent=s_winRowA)
     self.mainPosObInPa = cmds.checkBox("rsConsPos",
                                        label='Cons Position',
                                        cc=self.rsMaintPos,
                                        align='right',
                                        v=True,
                                        parent=s_winRowA)
     cmds.separator(height=5, style="none", hr=True, parent=s_winRowA)
     self.mainTangObInPa = cmds.checkBox("rsConsOri",
                                         label='Cons Rotation',
                                         cc=self.rsMaintTan,
                                         align='right',
                                         v=True,
                                         parent=s_winRowA)
     cmds.separator(height=5, style="none", hr=True, parent=s_winRowA)
     cmds.separator(height=10,
                    style="none",
                    hr=True,
                    parent=s_winLayOptionsCol)
     self.globalOriObInPaObInPa = cmds.checkBox("rsglobalOriObInPaentation",
                                                label='Global Rotation',
                                                align='right',
                                                v=False,
                                                en=False,
                                                parent=s_winRowA)
     s_winRowB = cmds.rowLayout(numberOfColumns=4,
                                cw=[(1, 20), (2, 110), (3, 20), (4, 90)],
                                parent=s_winLayOptionsCol)
     cmds.separator(height=5, style="none", hr=True, parent=s_winRowB)
     self.parentHierarObInPa = cmds.checkBox("rsParentHierarchyObInPa",
                                             label='Parent Hierarchy',
                                             align='right',
                                             v=False,
                                             parent=s_winRowB,
                                             en=False)
     cmds.separator(height=5, style="none", hr=True, parent=s_winRowB)
     self.selectNewObjsObInPa = cmds.checkBox("rsSelectNewObjsObInPa",
                                              label='Select New Objects',
                                              align='right',
                                              v=True,
                                              parent=s_winRowB)
     cmds.separator(height=5, style="none", hr=True, parent=s_winLayOptions)
     cmds.separator(height=10, style="none", hr=True, parent=s_winColA)
     s_winLayObjects = cmds.frameLayout(label='Objects for the path',
                                        li=86,
                                        borderStyle='etchedOut',
                                        parent=s_winColPro2)
     s_winColB = cmds.columnLayout(adjustableColumn=True,
                                   parent=s_winLayObjects)
     cmds.separator(height=10, style="none", hr=True, parent=s_winColB)
     s_winRowType = cmds.rowLayout(numberOfColumns=2,
                                   adjustableColumn3=2,
                                   cw=[(1, 4), (2, 100)],
                                   parent=s_winColB)
     cmds.separator(width=4, style="none", hr=True, parent=s_winRowType)
     self.opMenuCoInPa = cmds.attrEnumOptionMenu(
         l='Object type   ',
         ei=[(0, '    Empty Group'), (1, '    Locator'), (2, '    Joint'),
             (3, '    Scene Object     ')],
         cc=self.rsObjTypeCoInPa,
         parent=s_winRowType)
     cmds.separator(height=10, style="none", hr=True, parent=s_winColB)
     s_winLayObjOptions = cmds.frameLayout(lv=False,
                                           borderStyle='in',
                                           parent=s_winColB)
     s_winLayObjOptionsCol = cmds.columnLayout(adjustableColumn=True,
                                               parent=s_winLayObjOptions)
     cmds.separator(height=10,
                    style="none",
                    hr=True,
                    parent=s_winLayObjOptionsCol)
     s_winRowObjects = cmds.rowLayout(numberOfColumns=3,
                                      adjustableColumn3=2,
                                      cw=[(1, 70), (2, 100), (3, 50)],
                                      columnAlign=(1, 'center'),
                                      columnAttach=[(1, 'both', 0),
                                                    (2, 'both', 0),
                                                    (3, 'both', 0)],
                                      parent=s_winLayObjOptionsCol)
     self.textObInPa = cmds.text(label='Scene object',
                                 align='center',
                                 parent=s_winRowObjects,
                                 en=False)
     self.fieldObInPa = cmds.textField(cmds.textField(),
                                       cc=self.rsFieldObInPa,
                                       edit=True,
                                       parent=s_winRowObjects,
                                       text=None,
                                       en=False)
     self.buttonObInPa = cmds.button(label='Pick up',
                                     c=self.rsPickObInPa,
                                     parent=s_winRowObjects,
                                     en=False)
     cmds.separator(height=10,
                    style="none",
                    hr=True,
                    parent=s_winLayObjOptionsCol)
     s_winRowObjectsOptions = cmds.rowLayout(numberOfColumns=4,
                                             cw=[(1, 60), (2, 60), (3, 30),
                                                 (4, 60)],
                                             columnAttach=[(1, 'both', 0),
                                                           (2, 'both', 0),
                                                           (3, 'both', 0),
                                                           (4, 'both', 0)],
                                             parent=s_winLayObjOptionsCol)
     cmds.separator(width=40,
                    style="none",
                    hr=True,
                    parent=s_winRowObjectsOptions)
     cmds.radioCollection("OptionObject", parent=s_winRowObjectsOptions)
     self.copyObInPa = cmds.radioButton(label='Copy',
                                        parent=s_winRowObjectsOptions,
                                        en=False)
     cmds.separator(width=40,
                    style="none",
                    hr=True,
                    parent=s_winRowObjectsOptions)
     self.instanceObInPa = cmds.radioButton(label='Instance',
                                            parent=s_winRowObjectsOptions,
                                            en=False)
     cmds.separator(height=10,
                    style="none",
                    hr=True,
                    parent=s_winLayObjOptionsCol)
     self.frameLayoutLoftObInPa = cmds.frameLayout(
         label='Loft',
         li=128,
         lv=True,
         borderStyle='in',
         parent=s_winLayObjOptionsCol,
         en=False)
     s_winLayLoftButtonsCol = cmds.columnLayout(
         adjustableColumn=True, parent=self.frameLayoutLoftObInPa)
     cmds.separator(height=5,
                    style="none",
                    hr=True,
                    parent=s_winLayLoftButtonsCol)
     s_winLayObjOptCurveOps = cmds.rowLayout(numberOfColumns=6,
                                             cw=[(1, 30), (2, 55), (3, 20),
                                                 (4, 60), (5, 20), (6, 60)],
                                             columnAttach=[(1, 'both', 0),
                                                           (2, 'both', 0),
                                                           (3, 'both', 0),
                                                           (4, 'both', 0)],
                                             parent=s_winLayLoftButtonsCol)
     cmds.separator(width=10,
                    style="none",
                    hr=True,
                    parent=s_winLayObjOptCurveOps)
     cmds.radioCollection("LoftOptions", parent=s_winLayObjOptCurveOps)
     self.opNoneObInPa = cmds.radioButton(label='None',
                                          parent=s_winLayObjOptCurveOps,
                                          en=False)
     cmds.separator(width=10,
                    style="none",
                    hr=True,
                    parent=s_winLayObjOptCurveOps)
     self.opPolyObInPa = cmds.radioButton(label='Poligons',
                                          parent=s_winLayObjOptCurveOps,
                                          en=False)
     cmds.separator(width=10,
                    style="none",
                    hr=True,
                    parent=s_winLayObjOptCurveOps)
     self.opNurbsObInPa = cmds.radioButton(label='Nurbs',
                                           parent=s_winLayObjOptCurveOps,
                                           en=False)
     cmds.separator(height=5,
                    style="none",
                    hr=True,
                    parent=s_winLayLoftButtonsCol)
     cmds.separator(height=10, style="none", hr=True, parent=s_winColPro2)
     self.rsLaunchObInPa = cmds.button(label='Execute',
                                       w=100,
                                       c=self.rsLaunchObInPa,
                                       parent=s_winColPro2)
     self.rsTextObInPa = cmds.text(label='    Empty Group',
                                   vis=False,
                                   parent=s_winColPro2)
     cmds.window(self.window, e=1, w=430, h=103)
     cmds.showWindow(self.window)
     cmds.radioButton(self.instanceObInPa, e=True, select=True)
     cmds.radioButton(self.opNoneObInPa, e=True, select=True)
     cmds.window(self.window,
                 edit=True,
                 widthHeight=(i_windowSize),
                 s=False)