def changeTeeth(constructor, extrude, teeth=10, length=0.3):
"""
Change the number of teeth on a gear with a given number of teeth and a given length for the teeth.
This will create a new extrude node.
Args:
constructor (str): the constructor node
extrude (str): the extrude node
teeth (int): the number of teeth to create
length (float): the length of the teeth to create
"""
spans = teeth * 2
# Tmodify its attributes instead of creating a new one
cmds.polyPipe(constructor, edit=True, subdivisionsAxis=spans)
# list of faces to extrude as teeth
sideFaces = range(spans * 2, spans * 3, 2)
faceNames = []
for face in sideFaces:
faceName = 'f[%s]' % (face)
faceNames.append(faceName)
# cmds.setAttr('extrudeNode.inputComponents', numberOfItems, item1, item2, item3, type='componentList')
cmds.setAttr('%s.inputComponents' % (extrude),
len(faceNames),
*faceNames,
type="componentList")
# cmds.setAttr('extrudeNode.inputComponents', 2, 'f[1]', 'f[2]', type='componentList'
cmds.polyExtrudeFacet(extrude, edit=True, ltz=length)
def update_gear(constructor, extrude, teeth=10, length=0.3):
"""
Updates created gear object with new values
:param constructor: gear object
:param extrude: list of extruded faces
:param teeth: new number of teeth
:param length: new length of teeth
:return: void
"""
spans = spans_count(teeth)
side_faces = create_side_faces(spans)
cmds.polyPipe(constructor, subdivisionsAxis=spans, edit=True)
face_names = []
for face in side_faces:
face_name = "f[{}]".format(face)
face_names.append(face_name)
cmds.setAttr("{}.inputComponents".format(extrude),
len(face_names),
*face_names,
type="componentList")
cmds.polyExtrudeFacet(extrude, edit=True, ltz=length)
def __init__(self, name_, height, radius, sides, thickness, shader):
'''
Initializes a PipeHouse object, and creates a polygonal house object based on a
pipe primitive.
self: Object that is to be initialized.
name_: A string with the name the polygonal house object will have.
height: The height of the house.
radius: See Attributes.
sides: See Attributes.
thickness: See Attributes.
shader: Shader that will be assigned to the house.
On exit: A PipeHouse object has been initialized and a polygonal house has
been created out of a pipe primitive. A foundation for the house has
also been created and united with the box. The given shader has been
assigned to the house.
'''
House.__init__(self, name_, "pipe", height, radius * 2, radius * 2)
self.radius = radius
self.sides = sides
self.thickness = thickness
# The actual height of a pipe object in maya is half of the height it is given. Therefore here h = 2 * height.
n = cmds.polyPipe(n = name_, r = radius, h = 2 * height, t = thickness, sa = sides, sh = height)
cmds.xform(n[0], translation = (0,height/2.0,0))
f = cmds.polyPipe(n = "foundation", r = radius + 0.15, height = 0.8 * 2, t = thickness + 0.3, sa = sides)
cmds.xform(f[0], translation = (0, 0.4, 0))
n = cmds.polyUnite(n[0],f[0], n = name_)
self.name = n[0]
cmds.sets(n[0], edit=True, forceElement=shader[1])
cmds.delete(self.name, ch = True)
def createStalk(self):
''' This method creates the stalk. '''
# y ax is calculated by flower position
mc.polyPipe( subdivisionsHeight=3 );
mc.scale( 0.24, self.flowerTY+1, 0.24 )
mc.move( 0, -self.flowerTY/2, 0 );
mc.displaySmoothness( divisionsU=3, divisionsV=3, pointsWire=16, pointsShaded=4, polygonObject=3 );
self.currentStalk = mc.ls( sl=True );
currentStalk0 = self.currentStalk[0]
# bend the stalk
bendStalkRandomUpX = 1.5 * (1.0 - random.random())
bendStalkRandomUpZ = 1.5 * (1.0 - random.random())
for uCV in range (40,60):
mc.select( currentStalk0 + ".vtx[" + str(uCV) + "]" );
mc.move( bendStalkRandomUpX, 0, bendStalkRandomUpZ, r=True );
mc.select( currentStalk0 + ".vtx[" + str(uCV+60) + "]" );
mc.move( bendStalkRandomUpX, 0, bendStalkRandomUpZ, r=True );
bendStalkRandomDownX = 1.2 * (1.0 - random.random())
bendStalkRandomDownZ = 1.2 * (1.0 - random.random())
for uCV in range (20,40):
mc.select( currentStalk0 + ".vtx[" + str(uCV) + "]" );
mc.move( bendStalkRandomDownX, 0, bendStalkRandomDownZ, r=True );
mc.select( currentStalk0 + ".vtx[" + str(uCV+100) + "]" );
mc.move( bendStalkRandomDownX, 0, bendStalkRandomDownZ, r=True )
# delete history
mc.select( currentStalk0 )
maya.mel.eval( "DeleteHistory" )
mc.select( clear=True )
return self.currentStalk
def changeTeeth(self, teeth=10, length=0.3):
"""
this function is used to change the number of teeth and its length
Args:
teeth: give the NEW number of teeth
length: give the NEW length of teeth
Returns:
self.transform
self.constructor
self.extrude
"""
# todo if not extrude, constructor:
# raise RuntimeError(" either constructor or extrude node is deleted, maybe you have deleted construction history")
# new number of faces (spans)= teeth*2
spans = teeth * 2
# edit the gear
cmds.polyPipe(self.constructor, edit=True, subdivisionsAxis=spans)
# select the side faces of pipe
sideFaces = range(spans * 2, spans * 3, 2)
faceNames = []
for face in sideFaces:
fname = 'f[%s]' % (face)
faceNames.append(fname)
cmds.setAttr('%s.inputComponents' % (self.extrude), len(faceNames), *faceNames, type="componentList")
cmds.polyExtrudeFacet(self.extrude, edit=True, localTranslateZ=length)
def change_teeth(self, teeth=10, length=0.3):
"""
This function will change an existing gear with the given perameters.
Args:
teeth: The number of teeth to create
length: The length of the teeth
"""
spans = teeth * 2
cmds.polyPipe(self.constructor, edit=True, subdivisionsAxis=spans)
side_faces = range(spans * 2, spans * 3, 2)
face_names = []
for face in side_faces:
face_name = "f[{}]".format(face)
face_names.append(face_name)
cmds.setAttr("{0}.inputComponents".format(self.gearextrude),
len(face_names),
*face_names,
type="componentList")
cmds.polyExtrudeFacet(self.gearextrude,
edit=True,
localTranslateZ=length)
def gear_teeth_modifier(constructor, extrude, standard_teeth=10, length=0.3):
"""
Change the number of teeth on a gear with a given number of teeth and a given length for the teeth.
This will create a new extrude node.
Args:
constructor (str): the constructor node
extrude (str): the extrude node
teeth (int): the number of teeth to create
length (float): the length of the teeth tp create
"""
spans = standard_teeth * 2;
# Modifying its attributes instead of creating a new one
cmds.polyPipe(constructor, edit=True, subdivisionsAxis=spans)
# List of faces to extrude as teeth
side_faces = range(spans * 2, spans * 3, 2)
face_names = []
# Collecting the face names
for face in side_faces:
face_name = "f[%s]" % face
face_names.append(face_name)
# cmds.setAttr('extrudeNode.inputComponents', numberOfItems, item1, item2, item3, type='componentList')
# Example cmds.setAttr('extrudeNode.inputComponents', 2, 'f[1]', 'f[2]', type='componentList'
cmds.setAttr("%s.inputComponents" % extrude, len(face_names), *face_names, type="componentList")
cmds.polyExtrudeFacet(extrude, edit=True, ltz=length)
def changeGear(transform, constructor, extrudeNode, teeth = 5, length = 0.2):
'''
this function will change target gearlike geo's teeth number and teeth length
:param transform: transform node
:param constructor: mesh constructor
:param extrudeNode: extrudenode
:param teeth: new number of teeth
:param length: new number of teeth length
:return: 0
'''
spin = teeth*2
##use edit flag to change target meshNode(constructor)
cmds.polyPipe(constructor, edit = True, subdivisionsAxis=spin)
faceNum = range(spin * 2, spin * 3, 2)
cmds.select(clear=True)
newFaceList = []
for face in faceNum:
#build a new extrudeFaceList to upgrade the Node
newFaceList.append("f[%s]" % (face))
##ust need to edit the current extrude attr
print newFaceList;
##use setAttr to specify the new list of extrude faces
cmds.setAttr("%s.inputComponents" % (extrudeNode), len(newFaceList), *newFaceList, type ='componentList')
##it seems can use cmds.xxxnode(edit = True) to change it's flag value
cmds.polyExtrudeFacet(extrudeNode, edit=True, ltz=length)
return 0
def a_ring():
ring_diameter = 22 # outer diameter
ring_thickness = 1.5
divit_diameter = 1.5
divit_depth = .75
ring_height = 4
#divit_spacing = .5
divits = []
cmds.polyPipe(radius=ring_diameter/2, height=ring_height*2, thickness=ring_thickness, name='ring0')
cmds.setAttr( 'polyPipe1.subdivisionsAxis', 20 )
for x in range(0,6):
for y in range(0,3):
letter = initials[x]
symbol = letter[y]
myName = "_c" + str(x) + str(y)
if symbol == 0 :
cmds.polyCylinder(axis=[0,0,1], radius=(divit_diameter/2), height=divit_depth, name=myName)
elif symbol == 2:
cmds.polyCylinder(axis=[0,0,1], radius=(divit_diameter/2), height=ring_thickness * 2.1, name=myName)
if symbol != 1:
divits.append(myName)
y_off = 0
cmds.move(0,y_off,(ring_diameter/2 - divit_depth/2 + .3),myName)
cmds.rotate(0,(x*3+y)*20,0,myName, pivot=[0,0,0])
rn = 0;
for d in divits[:]:
print 'ring' + str(rn) + " " + d
cmds.polyBoolOp('ring' + str(rn), d, op=2, n='ring' + str(rn+1), )
rn += 1
def makeBeamPipe( block, x, cubeDimX, cubeDimY, cubeDimZ ):
innerPipe = cmds.polyPipe( r=cubeDimY * 0.5, h=cubeDimX*2, t=0.05, ax=(1,0,0) )
innerAdd = cmds.polyPipe( r=cubeDimY * 0.45, h=cubeDimX*1.64, t=0.1, ax=(1,0,0) )
inner = cmds.polyCBoolOp( innerPipe[0], innerAdd[0], op=1, ch=False )
cmds.move( (x*0.8) - (cubeDimZ/2.0), moveZ= True, a=True)
cmds.move( (cubeDimY * 0.5), moveY= True, a=True)
block = cmds.polyCBoolOp( block[0], inner[0], op=1, ch=False )
return block
def changeTeeth(constructor, extrude, teeth, length=0.3):
"""
Change number of teeth with a given amount of teeth and its length on an existing gear
This will create a new extrude node
Args:
constructor (str): constructor node
extrude (str): extrude node
teeth (int): number of teeth to create
length (int): length of the teeth to create
"""
# Number of spans by duplicating the number of teeth
spans = teeth * 2
# polyPipe cmd used to modify the gear
# edit="true" - instead of creating a new one, edit its attributes
# Creates new subdivisions
cmds.polyPipe(constructor, edit=True, subdivisionsAxis=spans)
# Now we must get a list to know what faces to extrude
# Go through first face, and step up every two values
sideFaces = range(spans * 2, spans * 3, 2)
faceNames = []
# We want to get a list in the following format:
# [u'f[40]', u'f[42]', u'f[44]', u'f[46]', u'f[48]', u'f[50]', u'f[52]', u'f[54]', u'f[56]', u'f[58]']
# Loop through all the side faces
for face in sideFaces:
# Use string substitution to create the names where 'face' = number of the face
faceName = 'f[%s]' % (face)
faceNames.append(faceName)
# Set the attributes
# Modify extrude's parameter for which components it affects
# We use setAttr call instead of recreating the extrude which can be expensive
# In maya cmds do....
# listAttr('polyExtrudeFace1') - we are interested in 'inputComponents'
# getAttr('polyExtrudeFace1.inputComponents') - return face values we have
# The arguments to changing a list of components is slightly different than a simple setAttr
# it is:
# cmds.setAttr('extrudeNode.inputComponents', numberOfItems, item1, item2, item3, type='componentList')
# Arg1 - Pass in extrude node since we dont know what the name of extrude while running the funciton
# Arg2 - How many items in the list we are giving it
# Arg3 - Needs list of all the faces we will be using by expanding it by *
# Arg4 - Tell it what kind of type the attribute is
cmds.setAttr('%s.inputComponents' % (extrude),
len(faceNames),
*faceNames,
type="componentList")
# We want to change the length of the teeth
# 'ltz' - short form for "localTranslateZ"
cmds.polyExtrudeFacet(extrude, edit=True, ltz=length)
def ChangeTeeth(self, teeth = 10):
'''
Change the teeth's number
Args:
teeth: Number of teeth
'''
cmds.polyPipe(self.node, edit = True, subdivisionsAxis = teeth * 2)
faces = self.GetTeethFaces(teeth)
cmds.setAttr("%s.inputComponents" % self.extrude, len(faces), * faces, type = "componentList")
def changeTeeth(constructor, extrude, teeth=10, length=0.3):
"""
Change the number of teeth on a gear with a given number of teeth and a given length for the teeth.
This will create a new extrude node.
Args:
constructor (str): the constructor node
extrude (str): the extrude node
teeth (int): the number of teeth to create
length (float): the length of the teeth to create
"""
# Just like before we calculate the number of spans required by duplicating the number of teeth.
spans = teeth * 2
# We then use the same polyPipe command we used to create the pipe to modify it, this time providing the edit=True parameter
# This edit parameter tells it we want to modify its attributes instead of creating a new one
cmds.polyPipe(constructor, edit=True,
subdivisionsAxis=spans)
# As we did when creating it we need to get a list of faces to extrude as teeth
sideFaces = range(spans * 2, spans * 3, 2)
faceNames = []
# We need to get a list in the following format
# [u'f[40]', u'f[42]', u'f[44]', u'f[46]', u'f[48]', u'f[50]', u'f[52]', u'f[54]', u'f[56]', u'f[58]']
# So we'll loop through all the sidefaces
for face in sideFaces:
# And we'll use the string substitution to create the names
# In this case, %s will be replaced by 'face' which is the number of our face
faceName = 'f[%s]' % (face)
# We'll add this to our list of faceNames
faceNames.append(faceName)
# Then we must modify the extrude's parameter for which components it affects.
# This takes a few different arguments
# The extrude node has an attribute called inputComponents
# To change it we can use a simple setAttr call instead of recreating the extrude which can be expensive
# The arguments to changing a list of components is slightly different than a simple setAttr
# it is:
# cmds.setAttr('extrudeNode.inputComponents', numberOfItems, item1, item2, item3, type='componentList')
cmds.setAttr('%s.inputComponents' % (extrude),
len(faceNames),
*faceNames,
type="componentList")
# The *faces will be new to you.
# It basically means to expand a list in place for arguments
# so if the list has ['f[1]', 'f[2]'] etc, it will be expanded in the arguments to be like this
# cmds.setAttr('extrudeNode.inputComponents', 2, 'f[1]', 'f[2]', type='componentList'
cmds.polyExtrudeFacet(extrude, edit=True, ltz=length)
def changeTeeth(self, constructor, extrude, teeth=10, length=0.3):
spans = teeth * 2
cmds.polyPipe(self.constructor, edit=True, sa=spans)
sideFaces = range(spans * 2, spans * 3, 2)
faceNames = []
for face in sideFaces:
faceName = 'f[%s]' % (face)
faceNames.append(faceName)
cmds.setAttr('%s.inputComponents' % (extrude),
len(faceNames),
*faceNames,
type="componentList")
cmds.polyExtrudeFacet(self.extrude, edit=True, ltz=length)
def changeTeeth(constructor, extrude, teeth = 10, length = 0.3):
spans = teeth * 2
cmds.polyPipe(constructor, edit = True, sa = spans)
sideFaces = range(spans * 2, spans * 3, 2)
newSideFaces = []
for face in sideFaces:
faceName = "f[%s]" % (face)
newSideFaces.append(faceName)
cmds.setAttr("%s.inputComponents" % (extrude), len(newSideFaces), *newSideFaces, type = "componentList")
cmds.polyExtrudeFacet(extrude, edit = True, ltz = length)
def createTire():
global cu
cu = cmds.polyTorus(sx=2, sy=2, r=0.5, sr=0.25)
cmds.scale(1, 1.712, 1)
cmds.delete(ch=True)
middle = cmds.polyCylinder(r=0.45, h=2, sz=4, sy=12)
cu[0] = cmds.polyBoolOp(cu[0], middle[0], op=2, n="block", ch=False)
extrudeForTire()
cmds.delete(ch=True)
pip1 = cmds.polyPipe(r=0.4906, h=1.5094, t=0.0755)
cu[0] = cmds.polyUnite(cu[0], pip1[0], n="block", ch=False)
pip2 = cmds.polyPipe(r=0.4150, h=1.1321, t=0.0)
cu[0] = cmds.polyUnite(cu[0], pip2[0], n="block", ch=False)
def makeStreetTree(shaders):
'''
Creates a tree on a circular platform and with a circular fence around it.
shaders: A list of shaders for the tree crowns.
On exit: A tree has been created using makeTree(...), a circular platform
has been created underneath it and a fence around it. Appropriate
shaders have been assigned. Everything is united into one polygonal
object and returned as a tuple with the object name and the node
name.
'''
tree = makeTree(shaders)
platform = cmds.polyCylinder(name = "platform",h = 0.1, r = 0.8)
cmds.move(0.25, y = True)
cmds.sets(platform[0], edit=True, forceElement="fountainMaterialGroup")
pole = cmds.polyCube(name = "pole", h = 0.6, w = 0.04, d = 0.04)
cmds.xform(pole, t = (0.7,0.45,0))
angle = 360/10.0
for i in range(1,10):
pole1 = cmds.polyCube(name = "pole", h = 0.6, w = 0.04, d = 0.04)
cmds.rotate(angle * i, y = True)
cmds.move(0.7,0.45,0, os = True)
pole = cmds.polyUnite(pole, pole1)
bar = cmds.polyPipe(name = "bar", h = 0.1, r = 0.65, t = 0.04)
cmds.move(0.65, y = True)
bar1 = cmds.duplicate(bar[0])
cmds.move(-0.2, y = True, r = True)
fence = cmds.polyUnite(pole, bar, bar1)
cmds.sets(fence[0], edit=True, forceElement="blackMetalGroup")
streetTree = cmds.polyUnite(tree,platform, fence)
cmds.delete(streetTree, ch = True)
return streetTree
def createGear(teeth=10, length=0.3):
"""
This function will create a gear mesh procedurally
:param teeth: number of teeth to create
:param length: how long is the extrusion of the teeth
:return:Tuple of the transform, constructor and extrude node
"""
# teeth are alternative face so spans times 2
spans = teeth * 2
transform, constructor = cmds.polyPipe(subdivisionsAxis=spans)
# side face index: start---end-----every 2
# range create a sequence like this
sideFaces = range(spans * 2, spans * 3, 2)
cmds.select(clear=True)
for face in sideFaces:
cmds.select("%s.f[%s]" % (transform, face), add=True)
extrude = cmds.polyExtrudeFacet(localTranslateZ=length)[0]
print(extrude)
return transform, constructor, extrude
def createGear(teeth = 10, len = 0.3):
"""
Create a gear with the given parameter.
Args:
teeth (int, optional): number of teeth to create. Defaults to 10.
len (float, optional): length of teeth. Defaults to 0.3.
Returns:
tuple: a tuple of (transform, constructor, extrude face)
"""
# teeth are every other face
spans = teeth * 2
#
transform, constructor = cmds.polyPipe(sa = spans)
# this is because the faces we want in Maya are numbered from [spans * 2, spans * 3)
# *** if you run ls -sl in MEL, Maya gives you all the face names
sideFaces = range(spans * 2, spans * 3, 2)
# clear any selection you have
cmds.select(clear = True)
# iterate through every other side face
for face in sideFaces:
cmds.select("%s.f[%s]" % (transform, face), add = True)
# get the poly extrude face
extrude = cmds.polyExtrudeFacet(ltz = len)[0]
#clean up and return
cmds.select(clear = True)
return transform, constructor, extrude
def create_gear(self, teeth=10, length=0.3):
"""
This function will create a gear with the given perameters.
Args:
teeth: The number of teeth to create
length: The length of the teeth
"""
#print("Creating Gear: {0} Teeth and {1} Length".format(teeth, length))
# Teeth are on alternate faces so we will span x 2
spans = teeth * 2
self.transform, self.constructor = cmds.polyPipe(
subdivisionsAxis=spans)
side_faces = range(spans * 2, spans * 3, 2)
cmds.select(clear=True)
for face in side_faces:
cmds.select("{0}.f[{1}]".format(self.transform, face), add=True)
self.gearextrude = cmds.polyExtrudeFacet(localTranslateZ=length)[0]
def createPipe(self, spans):
self.transform, self.shape = mc.polyPipe(sa=spans)
for node in mc.listConnections('%s.inMesh' % self.transform):
if mc.objectType(node) == 'polyPipe':
self.constructor = node
break
def createGear(teeth=10, length=0.3):
"""
This function will create a gear with the given parameters
:param
teeth: The number of teeth to create
:param
length: The length of the teeth
:return:
A tuple of the transform, constructor and extrude node
"""
# Teeth are every alternate face, so spans x 2
spans = teeth * 2
transform, constructor = cmds.polyPipe(subdivisionsAxis=spans)
sideFaces = range(spans * 2, spans * 3, 2)
cmds.select(clear=True)
for face in sideFaces:
cmds.select('%s.f[%s]' % (transform, face), add=True)
extrude = cmds.polyExtrudeFacet(localTranslateZ=length)[0]
return transform, constructor, extrude
def createGear(teeth=10, length=0.3):
sele = cmds.select("gearpipe")
cmds.delete()
print "creating gear", teeth, length
span = teeth * 2
#global span
transfo_node, shape_node = cmds.polyPipe(subdivisionsAxis=span,
n="gearpipe")
print transfo_node
print shape_node
sideface = range(span * 2, span * 3, 2)
cmds.select(clear=True)
for face in sideface:
cmds.select('%s.f[%s]' % (transfo_node, face), add=True)
extrude = cmds.polyExtrudeFacet(localTranslateZ=length)[0]
print extrude
cmds.select(clear=True)
return transfo_node, shape_node, extrude
def createGear(teeth=10, length=0.3):
"""
This function will create a gear with the given parameters
Args:
teeth: The number of teeth to create
length: The length of the teeth
Returns:
A tuple of the transform, constructor and extrude node
"""
spans = teeth * 2
transform, constructor = cmds.polyPipe(subdivisionsAxis=spans)
sideFaces = range(spans * 2, spans * 3, 2)
# clear the selection to add each face to it
cmds.select(clear=True)
for face in sideFaces:
cmds.select('%s.f[%s]' % (transform, face), add=True)
# extrude the selected faces by the given length
# returns value of the extrude node inside a list
extrude = cmds.polyExtrudeFacet(localTranslateZ=length)[0]
# return a tuple of (transform, constructor, extrude)
return transform, constructor, extrude
def generar_tuerca(teeth=10, length=0.3):
"""Funcion que crea una tuerca con los parametros dados
Args:
teeth: El numero de dientes de la tuerca
length: Tamano de cada tuerca
Returns:
Una tupla con la transformada, el constructor y el nodo que hace la extruccion
"""
# Teeth (dientes) son cada una de las caras que es extruida
spans = teeth * 2
transform, constructor = cmds.polyPipe(subdivisionsAxis=spans)
#select -r pPipe1.f[40] pPipe1.f[42] pPipe1.f[44] pPipe1.f[46] pPipe1.f[48] pPipe1.f[50] pPipe1.f[52] pPipe1.f[54] pPipe1.f[56] pPipe1.f[58] ;
sideFaces = range(spans*2, spans*3, 2)
print(transform, constructor, sideFaces)
cmds.select(clear=True)
for face in sideFaces:
cmds.select("%s.f[%s]" % (transform, face), add=True)
#polyExtrudeFacet -constructionHistory 1 -keepFacesTogether 1 -pvx -1.192092896e-07 -pvy 0 -pvz 1.788139343e-07 -divisions 1 -twist 0 -taper 1 -off 0 -thickness 0 -smoothingAngle 30 pPipe2.f[40] pPipe2.f[42] pPipe2.f[44] pPipe2.f[46] pPipe2.f[48] pPipe2.f[50] pPipe2.f[52] pPipe2.f[54] pPipe2.f[56] pPipe2.f[58];
#setAttr "polyExtrudeFace2.localTranslate" -type double3 0 0 0.143625 ;
extruded_faces = cmds.polyExtrudeFacet(localTranslateZ=length)
return transform, constructor, extruded_faces
def makeGear(teeth = 10, length = 0.5):
'''
this function will create a gear according to specified number of teeth and length
:param teeth: number of teeth that gear has
:param length: number of teeth length
:return: 1.transform node 2. meshconstructor 3. extrudeNode
'''
removeGear()
spin = teeth * 2
#total side face number = teeth number * 2
transform, constructor = cmds.polyPipe(subdivisionsAxis=spin, name='Gear')
##calculate sideFaceID from spin*2 to spin*3 at intervals of one
faceNum = range(spin * 2, spin * 3, 2)
##clean everySelection
cmds.select(clear=True)
for face in faceNum:
print face
##select target faces based of sideFaceID
cmds.select("%s.f[%s]" % (transform, face), add=True) or []
##set localTranslateZ flag to make the length of gear
extrudeAttr = cmds.polyExtrudeFacet(ltz = length)[0]
print extrudeAttr
print transform, constructor
return transform,constructor,extrudeAttr
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)
def generate_gear(self, teeth=10, length=0.3):
"""
Generates a gear mesh
Args:
teeth: How many teeth the gear will have
length: How long each teeth will be
"""
subdivisions_axis = teeth * 2
# Assigns pPipe to transform and polyPipe input node to poly_pipe_constructor
self.transform, self.poly_pipe_constructor = cmds.polyPipe(subdivisionsAxis=subdivisions_axis)
# in a default 20-subdivision pipe, the numbering of the faces is as follows:
# inner faces: 0-19, top: 20-39, outer: 40-59, and bottom: 60-79
# Thus, the outer faces always start counting at NumberOfSubdivisions * 2 and end at NumberOfSubdivisions * 3 -1
# since the upper limit of range() is exclusive, we don't have to do the "-1"
outer_side_faces = range(subdivisions_axis * 2, subdivisions_axis * 3, 2)
# print("outer_side_faces: " + str(outer_side_faces)) # the faces that will be extruded
cmds.select(clear=True)
# select all the faces to extrude
for face in outer_side_faces:
# transform_name.f allows you to access a list containing all the faces of the mesh
# "add' means the next face we select is added to the selection w/o deselecting previously selected faces
cmds.select("%s.f[%s]" % (self.transform, face), add=True)
# extrudes the selected faces and returns the polyExtrudeFace node that is fed into the pPipeShape node
self.extrude = cmds.polyExtrudeFacet(localTranslateZ=length)[0]
def create(self, teeth=10, length=0.3):
"""
This function will create a gear mesh procedurally
:param teeth: number of teeth to create
:param length: how long is the extrusion of the teeth
"""
# teeth are alternative face so spans times 2
spans = teeth * 2
self.transform, self.constructor = cmds.polyPipe(
subdivisionsAxis=spans)
# side face index: start---end-----every 2
# `range` create a sequence like this
side_faces = range(spans * 2, spans * 3, 2)
# how cmd works is selection load/unload at runtime
cmds.select(clear=True)
for face in side_faces:
cmds.select("%s.f[%s]" % (self.transform, face), add=True)
self.extrude = cmds.polyExtrudeFacet(localTranslateZ=length)[0]
if self.debug:
print(self.extrude)
def createGear(teeth=10, length=0.3):
"""
This function will create a gear with the given params
Args:
teeth: number of teeth
length: the length
Returns:
A tuple with the transform, constructor and extrude node
"""
# teeth are every alternate face, spans = teeth * 2
spans = teeth * 2
transform, constructor = cmds.polyPipe(sa=spans)
# selection of the faces
sideFaces = range(spans * 2, spans * 3,
2) # between 40 and 60 and every second number
# clear selection
cmds.select(clear=True)
# faceSelection
for face in sideFaces:
cmds.select('%s.f[%s]' % (transform, face), add=True)
# extrude faces
extrude = cmds.polyExtrudeFacet(localTranslateZ=length)[0]
#unselect
cmds.select(cl=True)
# we print
print("the final polyelement is: " + extrude)
# we return for futur use
return transform, constructor, extrude
def createGear(self, teeth=10, length=0.3):
spans = teeth * 2
self.transform, self.constructor = cmds.polyPipe(sa=spans)
sideFaces = range(spans * 2, spans * 3, 2)
cmds.select(clear=True)
for face in sideFaces:
cmds.select('%s.f[%s]' % (self.transform, face), add=True)
self.extrude = cmds.polyExtrudeFacet(ltz=length)[0]
def changeTeeth(constructor, extrude, teeth=10, length=0.3):
spans = teeth * 2
cmds.polyPipe(constructor, edit=True, subdivisionsAxis=spans)
sideFaces = range(spans * 2, spans * 3, 2)
facesNames = []
for face in sideFaces:
facesName = 'f[%s]' % (face)
facesNames.append(facesName)
cmds.setAttr('%s.inputComponents' % (extrude),
len(facesNames),
*facesNames,
type="componentList")
cmds.polyExtrudeFacet(extrude, edit=True, localTranslateZ=length)
def HoleConnector():
components = []
# Fetching slider data
rgb = cmds.colorSliderGrp('HoleColour', query=True, rgbValue=True)
cmds.select(clear=True)
cubeDimX = 0.74
cubeDimY = 0.78
# Inner tube
innerCyl = cmds.polyPipe( r=cubeDimY * 0.40, h=cubeDimX*3.85, t=0.1, ax=(1,0,0), ch=False )
# End Ring
endCyl1 = cmds.polyPipe( r=cubeDimY * 0.45, h=cubeDimX*0.1, t=0.05, ax=(1,0,0), ch=False )
cmds.move(cubeDimX*1 - (cubeDimX*0.05),0,0)
midShape = cmds.polyCBoolOp( innerCyl[0], endCyl1[0] , op=1, ch=False)
# Subtraction cube
endCube1 = cmds.polyCube(width=0.5, height=0.09, depth=1, ch=False)
cmds.move(cubeDimX*1 - (cubeDimX*0.15),0,0)
midShape = cmds.polyCBoolOp( midShape[0], endCube1[0], op=2, ch=False )
# End Ring 2
endCyl2 = cmds.polyPipe( r=cubeDimY * 0.45, h=cubeDimX*0.1, t=0.05, ax=(1,0,0), ch=False )
cmds.move((cubeDimX*0.05) - cubeDimX*1,0,0)
midShape = cmds.polyCBoolOp( midShape[0], endCyl2[0] , op=1, ch=False)
# Subtraction cube 2
endCube2 = cmds.polyCube(width=0.5, height=0.09, depth=1, ch=False)
cmds.move((cubeDimX*0.15) - cubeDimX*1,0,0)
midShape = cmds.polyCBoolOp( midShape[0], endCube2[0], op=2, ch=False )
outerCyl1 = cmds.polyPipe( r=cubeDimY * 0.45, h=cubeDimX*0.2, t=0.05, ax=(1,0,0),ch=False )
finalShape = cmds.polyCBoolOp( midShape[0], outerCyl1[0], op=1, ch=False )
# Adding on the color
shadedShape = addShader(finalShape, rgb)
def holeBlock():
blockWidth = cmds.intSliderGrp('holeWidth', q=True, v=True)
rgb = cmds.colorSliderGrp('holeColour', q=True, rgbValue=True)
global nextBlockId
nsTmp = "Block" + str(nextBlockId)
nextBlockId = nextBlockId + 1
createNamespace(nsTmp)
cubeSizeX = (blockWidth) * 0.8
cubeSizeZ = 0.8
cubeSizeY = .96
#Create Cube
cmds.polyCube(width=cubeSizeX,
height=cubeSizeY,
depth=cubeSizeZ,
sh=2,
sd=2)
cmds.move(0, (cubeSizeY / 2), 0)
#separate loop for punching holes
for i in range(blockWidth - 1):
moveX = (((i + .5) * 0.8) - (cubeSizeX / 2.0) + 0.4)
punchHole(.25, 2, 90, moveX, .5, nsTmp, ":pCube1", "pCube1")
#add bumps to cube and also rename it to pCube1 for loop friendly code
for i in range(blockWidth):
#Create pipe, used to make bump
cmds.polyPipe(r=.25, h=.4, t=.05)
cmds.move(((i * 0.8) - (cubeSizeX / 2.0) + 0.4), moveX=True, a=True)
cmds.move((cubeSizeY + 0.10), moveY=True, a=True)
BOOLEAN(nsTmp, ":pPipe1", ":pCube1", 1, "pCube1")
myShader = cmds.shadingNode('lambert', asShader=True, name="blckMat")
cmds.setAttr(nsTmp + ":blckMat.color",
rgb[0],
rgb[1],
rgb[2],
typ='double3')
#since there is no need for unite, one last rename to nsTMP to add texture
cmds.select(nsTmp + ":pCube1")
cmds.rename(nsTmp)
cmds.hyperShade(assign=(nsTmp + ":blckMat"))
cmds.namespace(removeNamespace=":" + nsTmp, mergeNamespaceWithParent=True)
def create_pipe(self):
# Setting the shape and transform to the class variables
self.transform, self.shape = cmds.polyPipe(subdivisionsAxis=self.spans)
# Finding the polyPipe node and set it equal to the constructor
for node in cmds.listConnections("{0}.inMesh".format(self.transform)):
if cmds.objectType(node) == "polyPipe":
self.constructor = node
break
def changeGear(self, teeth = 5, length = 0.2):
spin = teeth * 2
##use edit flag to change target meshNode(constructor)
cmds.polyPipe(self.constructor, edit=True, subdivisionsAxis=spin)
faceNum = range(spin * 2, spin * 3, 2)
cmds.select(clear=True)
newFaceList = []
for face in faceNum:
# build a new extrudeFaceList to upgrade the Node
newFaceList.append("f[%s]" % (face))
##ust need to edit the current extrude attr
print newFaceList;
##use setAttr to specify the new list of extrude faces
cmds.setAttr("%s.inputComponents" % (self.extrudeNode), len(newFaceList), *newFaceList, type='componentList')
##it seems can use cmds.xxxnode(edit = True) to change it's flag value
cmds.polyExtrudeFacet(self.extrudeNode, edit=True, ltz=length)
return 0
def setJoints(self,rootPos, endPos, ringPos,rConstLoc,bConstLoc,radius,jntName,pGroup):
thickness = radius/3
#clear selection
mc.select(clear=True)
#create joints
joints=[]
joints.append(mc.joint(position=rootPos,name=(jntName+"_root_JNT_#")))
joints.append(mc.joint(position=ringPos,name=(jntName+"_end_JNT_#")))
mc.joint(joints,edit=True,orientJoint="xyz",zeroScaleOrient=True,
secondaryAxisOrient="yup")
#create IKhandle
self.pistonIK=mc.ikHandle(sj=joints[0], ee=joints[1],
name=(jntName+"_IK_#"))
#parent to locators
mc.parent(joints[0],rConstLoc)
#constrain to locators
mc.pointConstraint(bConstLoc,self.pistonIK[0])
#distance between
distance = sqrt( pow((rootPos[0]-ringPos[0]),2) +
pow((rootPos[1]-ringPos[1]),2) +
pow((rootPos[2]-ringPos[2]),2))
#create pipe rod (polyPipe bug...must double the height)
self.rod=mc.polyPipe(r=radius,t=thickness,h=(distance*2),
sa=20,ax=(0,1,0),cuv=3,ch=1,sc=0,
name=(jntName+"_geo_#"))
#move pivot point to origin
mc.xform(pivots=(0,(distance/-2),0))
#aim and parent to joints
mc.pointConstraint(joints[0],self.rod[0])
mc.aimConstraint(joints[1],self.rod[0],aimVector=(0,1,0))
#clear the list
del joints[:]
mc.select(self.pistonIK[0],self.rod[0])
mc.ls(sl=True)[0]
toGroup=mc.group(n=jntName+"_GRP_#")
mc.parent(toGroup, pGroup)
def make_pipe(new_radius, new_height, basename="pipe_000", from_pipe_name=None):
t = 1/float(16) # 16ga
if from_pipe_name:
ret = cmds.duplicate(from_pipe_name, un=True)
log.debug(ret)
new_name = ret[0]
shape = ret[-1]
else:
new_name, shape = cmds.polyPipe(n=basename, t=t)
log.debug("copied: " + new_name if from_pipe_name else "new: " + new_name)
cmds.setAttr(shape + '.radius', new_radius)
cmds.setAttr(shape + '.height', new_height*2)
return new_name, shape
def makeGear(self, teeth=10,length=0.5):
self.removeGear(self.name)
spin = teeth * 2
# total side face number = teeth number * 2
transform, constructor = cmds.polyPipe(subdivisionsAxis=spin, name=self.name)
##calculate sideFaceID from spin*2 to spin*3 at intervals of one
faceNum = range(spin * 2, spin * 3, 2)
##clean everySelection
cmds.select(clear=True)
for face in faceNum:
print face
##select target faces based of sideFaceID
cmds.select("%s.f[%s]" % (transform, face), add=True) or []
##set localTranslateZ flag to make the length of gear
extrudeAttr = cmds.polyExtrudeFacet(ltz=length)[0]
print transform, constructor, extrudeAttr
self.transform = transform
self.constructor = constructor
self.extrudeNode = extrudeAttr
return 0
def PolyPipes(\
x = random.uniform(-10,10),\
x_r = 1,\
y = random.uniform(0,20),\
y_r = 1,\
z = random.uniform(-10,10),\
z_r = 1,\
xRot = random.uniform( 0, 360 ),\
xRot_r = 10,\
yRot = random.uniform( 0, 360 ),\
yRot_r = 10,\
zRot = random.uniform( 0, 360 ),\
zRot_r = 10,\
r = random.uniform(0,2),\
r_r = .1,\
g = random.uniform(0,2),\
g_r = .1,\
b = random.randint(0,2),\
b_r = .1,\
scaleF = random.uniform( 0.3, 1.5 ),\
scaleF_r = .1,\
):
def change(start,min,max,rate):
if random.randint(0,5) == 0:
rate = (-1 * rate)
start += rate
if start < min or start > max:
rate = (-1 * rate)
start += rate
return start,rate
for i in range( 0, 50 ):
#create cube
cmds.polyPipe( sh=1, h=1, n='pipe{}'.format(i))
#vary location
x = change(x,-10,10,x_r)[0]
x_r = change(x,-10,10,x_r)[1]
y = change(y,0,20,y_r)[0]
y_r = change(y,0,20,y_r)[1]
z = change(z,-10,10,z_r)[0]
z_r = change(z,-10,10,z_r)[1]
#vary rotation
xRot = change(xRot,1,360,xRot_r)[0]
xRot_r = change(xRot,1,360,xRot_r)[1]
yRot = change(yRot,1,360,yRot_r)[0]
yRot_r = change(yRot,1,360,yRot_r)[1]
zRot = change(zRot,1,360,zRot_r)[0]
zRot_r = change(zRot,1,360,zRot_r)[1]
#vary color
r = change(r,0,2,r_r)[0]
r_r = change(r,0,2,r_r)[1]
g = change(g,0,2,g_r)[0]
g_r = change(g,0,2,g_r)[1]
b = change(b,0,2,b_r)[0]
b_r = change(b,0,2,b_r)[1]
#vary scale
scaleF = change(scaleF,0.3,1.5,scaleF_r)[0]
scaleF_r = change(scaleF,0.3,1.5,scaleF_r)[1]
#apply variabels
cmds.rotate( xRot, yRot, zRot, 'pipe{}'.format(i))
cmds.scale(scaleF, scaleF, scaleF, 'pipe{}'.format(i))
cmds.move( x, y, z, 'pipe{}'.format(i))
cmds.sets( name='PipeMaterial{}'.format(i), renderable=True, empty=True )
cmds.shadingNode( 'phong', name='PipeShader{}'.format(i), asShader=True )
cmds.setAttr( 'PipeShader{}'.format(i)+'.color', r, g, b, type='double3' )
cmds.surfaceShaderList( 'PipeShader{}'.format(i), add='PipeMaterial{}'.format(i))
cmds.sets( 'pipe{}'.format(i), forceElement='PipeMaterial{}'.format(i))
def pipe(radius, height, name=None):
t = 1/float(16) # 16ga
val = cmds.polyPipe(
thickness=t, radius=radius, height=height*2, name=name)
log.debug(val)
return val
cone = mc.polyCone(r=1, h=2, sx=20, sy=1, sz=0, ax=(0, 1, 0), rcp=0, cuv=3, ch=1) mc.scale(2, 3, 2, cone, r=True) mc.move(6, 0, 6, cone, r=True) mc.rotate(12, 11, 5, cone, r=True, os=True) torus = mc.polyTorus(r=1, sr=0.5, tx=0, sx=20, sy=0, ax=(0, 1, 0), cuv=3, ch=1) mc.scale(2, 2, 2, torus, r=True) mc.move(-6, 0, 6, torus, r=True) mc.rotate(1, 23, 5, torus, r=True, os=True) prism = mc.polyPrism(w=1, ns=3, sh=1, sc=0, ax=(0, 1, 0), cuv=3, ch=1) mc.scale(2, 2, 2, prism, r=True) mc.move(0, 0, 6, prism, r=True) mc.rotate(1, 4, 30, prism, r=True, os=True) pyramid = mc.polyPyramid(w=1, ns=4, sh=0, sc=0, ax=(0, 1, 0), cuv=3, ch=1) mc.scale(4, 5, 4, pyramid, r=True) mc.move(6, 0, -6, pyramid, r=True) pipe = mc.polyPipe(r=1, h=3, t=0.5, sa=20, sh=1, sc=0, ax=(0, 1, 0), cuv=3, rcp=0, ch=1) mc.scale(2, 2, 2, pipe, r=True) mc.move(-6, 0, -6, pipe, r=True) mc.rotate(14, 32, 30, pipe, r=True, os=True) helix = mc.polyHelix(c=3, h=2, w=2, r=0.4, sa=8, sco=50, sc=0, d=1, ax=(0, 1, 0), cuv=3, rcp=0, ch=1) mc.scale(2, 2, 2, helix, r=True) mc.move(0, 0, 0, helix, r=True) mc.rotate(14, 32, 90, helix, r=True, os=True) # Deselect all mc.select(clear=True)
import maya.cmds as cmds
cmds.polyCylinder(n='TourBase',r=3,h=6)
cmds.xform(ws=True, piv=(0,3,0))
cmds.move(0,-3,0)
for i in range(2):
cmds.polyCylinder(n='Tour1',r=3.2+(.1*i),h=0.3,sa=30)
cmds.move(0,0.3*i,0)
cmds.group('Tour*',n='GroupTour')
cmds.select('GroupTour')
cmds.xform(ws=True, piv=(0,0.75,0))
cmds.move(0,-0.75,0, 'GroupTour')
cmds.polyPipe(n='Remp',r=3.4,h=2.5,t=0.5,sa=40)
for i in range(12):
cmds.polyCube(n='Rempart',w=0.5,h=0.5,d=1)
cmds.xform(ws=True,piv=(0,-.25,0))
cmds.move(0,.25,0)
cmds.move(0,.2,3.2, relative=True)
cmds.xform(ws=True, rotatePivot=(0,0,0))
cmds.rotate(0,30*i,0)
for i in range(12):
cmds.polyCube(n='Fente',w=1,h=.5,d=.1)
cmds.move(3.2,0,0, relative=True)
cmds.xform(ws=True, rotatePivot=(0,0,0))
cmds.rotate(0,30*i,0)
def _polyPipe(self):
cmds.polyPipe()
def rim():
#get values from UI
rimStyle = cmds.radioButtonGrp( 'rimStyle', query = True, select = True)
rgb = cmds.colorSliderGrp('wheelColour', query=True, rgbValue=True)
#set up variables
radius = 1.6
widthHalf = 2.1 / 2
if( rimStyle == 1 ):
mediumCircle = cmds.polyCylinder( h = widthHalf * 0.4, r = radius * 0.67 )
cmds.rotate( 90, rotateZ = True )
crossV = cmds.polyCube( w = widthHalf, h = 0.4, d = 0.2 )
crossH = cmds.polyCube( w = widthHalf, h = 0.2, d = 0.4 )
cross = cmds.polyCBoolOp( crossV, crossH, op = 1 )
cmds.move( widthHalf / 2, moveX = True )
mediumCircle = cmds.polyCBoolOp( mediumCircle, cross, op = 2 )
innerCircle = cmds.polyPipe( h = widthHalf * 0.3, r = radius * 0.33, t = 0.14 )
cmds.rotate( 90, rotateZ = True )
cmds.move( ((widthHalf * 0.4) / 2) + ((widthHalf * 0.3) / 2), moveX = True )
outerCircle = cmds.polyPipe( h = widthHalf, r = radius, t = 0.2 )
cmds.rotate( 90, rotateZ = True )
cmds.move( (((widthHalf * 0.4) / 2) + ((widthHalf * 0.5) / 2)) + 0.1, moveX = True )
outerCircleCut = cmds.polyPipe( h = widthHalf * 0.33, r = radius, t = 0.1 )
cmds.rotate( 90, rotateZ = True )
cmds.move( (((widthHalf * 0.4) / 2) + ((widthHalf * 0.5) / 2)) + 0.1, moveX = True )
outerCircle = cmds.polyCBoolOp( outerCircle, outerCircleCut, op = 2 )
slope = cmds.polyCone()
cmds.rotate( 90, rotateZ = True )
cmds.move( 0.810, moveX = True )
cmds.scale( 5.455, 1, 5.455 )
slopeCutL = cmds.polyCylinder( h = widthHalf, r = radius )
cmds.rotate( 90, rotateZ = True )
cmds.move( -( widthHalf / 2), moveX = True )
slopeCutR = cmds.polyCylinder( h = 4, r = radius * 10 )
cmds.rotate( 90, rotateZ = True )
cmds.move( 2.326, moveX = True )
slope = cmds.polyCBoolOp( slope, slopeCutL, op = 2 )[0]
slope = cmds.polyCBoolOp( slope, slopeCutR, op = 2 )[0]
cmds.delete( slope+".f[21]")
rimL = cmds.polyUnite( mediumCircle, innerCircle, outerCircle, slope )
cmds.move( (widthHalf*0.4)/2, moveX = True )
rimR = cmds.duplicate( rimL )
cmds.scale( -1, scaleX = True )
cmds.move( -((widthHalf*0.4)/2), moveX = True )
rim = cmds.polyUnite( rimR, rimL )
elif( rimStyle == 2 ):
radius = 1.5
circleList = []
mainCircle = cmds.polyCylinder( h = 0.4, r = radius - 0.2 )
innerCircle = cmds.polyCylinder( h = 0.5, r = radius * 0.2 )
hCross = cmds.polyCube( w = radius * 0.24, h = 3, d = radius * 0.1 )
vCross = cmds.polyCube( w = radius * 0.1, h = 3, d = radius * 0.24 )
cross = cmds.polyCBoolOp( hCross, vCross, op = 1 )[0]
rim = cmds.polyCBoolOp( mainCircle, innerCircle, op = 1 )
rim = cmds.polyCBoolOp( rim, cross, op = 2 )
lRidge = cmds.polyTorus( sr = 0.1, r = (radius * 0.9))
cmds.move( 0.4/2, moveY = True )
rRidge = cmds.polyTorus( sr = 0.1, r = (radius * 0.9))
cmds.move( -(0.4/2), moveY = True )
rim = cmds.polyCBoolOp( rim, lRidge, op = 1 )[0]
rim = cmds.polyCBoolOp( rim, rRidge, op = 1 )[0]
cutCircle = cmds.polyCylinder( h = 3, r = radius * 0.17 )[0]
cmds.move( 0, 0, 0.8)
cmds.move( 0, 0, 0, cutCircle+".scalePivot", cutCircle+".rotatePivot", absolute=True)
circleList.append( cutCircle )
for i in range( 0, 5):
cutCircle = cmds.duplicate( cutCircle )
cmds.rotate( 0, 60, 0, cutCircle, r = True )
circleList.append( cutCircle )
cutCircles = cmds.polyUnite( *circleList)
rim = cmds.polyCBoolOp( rim, cutCircles, op = 2 )
cmds.rotate( 90, rotateX = True )
myShader = cmds.shadingNode( 'phong', asShader=True )
cmds.setAttr( myShader+".color", rgb[0], rgb[1], rgb[2], type='double3')
cmds.setAttr( myShader+".reflectivity", 0 )
cmds.select( rim )
cmds.hyperShade( assign = myShader )
cmds.delete( ch = True )
def tyre():
#get values from UI
rgb = cmds.colorSliderGrp('wheelColour', query=True, rgbValue=True)
#set up variables
radius = 2.85
widthHalf = 2.7
ridgeShapeList = []
innerCircle = cmds.polyPipe( h = widthHalf * 0.7, r = 2.65, t = 1.05 )
outerCircle = cmds.polyPipe( h = widthHalf, r = 2.65, t = 0.85 )
ridge1 = cmds.polyPipe( h = (widthHalf * 0.33)/2, r = 2.85, t = 0.80 )
cmds.move( -0.567, moveY = True)
ridge2 = cmds.polyPipe( h = widthHalf * 0.33, r = 2.85, t = 0.80 )
cmds.move( -0.120, moveY = True)
tire = cmds.polyCBoolOp( innerCircle, outerCircle, op = 1 )[0]
tire = cmds.polyCBoolOp( tire, ridge1, op = 1 )[0]
tire = cmds.polyCBoolOp( tire, ridge2, op = 1 )[0]
ridgeShape = cmds.polyCube( w = 0.63, h = 0.2, d = 0.2)
cmds.move( -0.05, moveY = True)
ridgeShapeL = cmds.polyCube( w = 0.2, h = 0.33, d = 0.2, sy = 2)[0]
cmds.select( ridgeShapeL+'.vtx[4]', ridgeShapeL+'.vtx[5]')
cmds.move( -0.09, moveZ = True )
ridgeShapeR = cmds.duplicate( ridgeShapeL )
cmds.move( -((0.63/2) - 0.1), 0.33/2, 0, ridgeShapeL )
cmds.move( (0.63/2) - 0.1, 0.33/2, 0, ridgeShapeR )
ridgeShape = cmds.polyCBoolOp( ridgeShape, ridgeShapeL, op = 1 )[0]
ridgeShape = cmds.polyCBoolOp( ridgeShape, ridgeShapeR, op = 1 )[0]
cmds.move( 0, 0.343, radius - 0.14)
cmds.move( 0, 0, 0, ridgeShape+".scalePivot", ridgeShape+".rotatePivot", absolute=True)
ridgeShapeList.append( ridgeShape )
for i in range( 0, 19):
ridgeShape = cmds.duplicate( ridgeShape )[0]
cmds.rotate( 0, 18, 0, ridgeShape, r = True )
ridgeShapeList.append( ridgeShape )
ridges = cmds.polyUnite( *ridgeShapeList )
cmds.rotate( 9, rotateY = True )
tireL = cmds.polyUnite( tire, ridges )[0]
cmds.rotate( 90, tireL, rotateZ = True )
cmds.move( ((widthHalf / 2)/2), tireL, moveX = True )
tireR = cmds.duplicate( tireL )[0]
cmds.scale( -1, scaleY = True )
cmds.move( -((widthHalf / 2)/2), tireL, moveX = True )
tire = cmds.polyUnite( tireR, tireL )
myShader = cmds.shadingNode( 'phong', asShader=True )
cmds.setAttr( myShader+".color", rgb[0], rgb[1], rgb[2], type='double3')
cmds.setAttr( myShader+".reflectivity", 0 )
cmds.select( tire )
cmds.hyperShade( assign = myShader )
cmds.delete( ch = True )
