def extrudeLedge(face):
""" extrude the first ledge on rooftop """
localScaleRDM = random.uniform(0.88, 0.98)
localScale = (localScaleRDM, localScaleRDM, 1)
cmds.polyExtrudeFacet(face, ch=HISTORY, keepFacesTogether=False, thickness=0, localScale=localScale)
return face
def createHoneyPiece(n):
planeName = 'plane'+str(n)
print planeName
cmds.polyPlane(w=20, h=20, sx=12, sy=12, n=planeName)
edgeNum = 26
modVal = 1;
edgeArray = []
for i in range(52):
edgeArray.append(planeName+'.e['+str(edgeNum)+']');
edgeNum += 2
if(edgeNum == 51):
edgeNum = 101
if(edgeNum==50):
edgeNum = 49
if(edgeNum == 126):
edgeNum = 176
if(edgeNum==125):
edgeNum = 124
if(edgeNum==201):
edgeNum = 251
if(edgeNum==200):
edgeNum = 199
if(edgeNum==275):
edgeNum = 274
cmds.polyBevel(edgeArray, offset=1,offsetAsFraction=1,autoFit=1,segments=1,worldSpace=1,uvAssignment=0,fillNgons=1,mergeVertices=1,mergeVertexTolerance=0.0001,smoothingAngle=30,miteringAngle=180,angleTolerance=180,ch=1)
cmds.select( clear=True)
print len(edgeArray)
del edgeArray[:]
print len(edgeArray)
for i in range(532, 620):
cmds.select(planeName+'.e['+str(i)+']', toggle=True);
size = 36;
edgeNum = 31
counter = 0
for i in range(size):
cmds.select(planeName+'.e['+str(edgeNum)+']', toggle=True);
edgeNum += 2
counter += 1
if(counter == 12):
counter = 0
edgeNum += 7;
cmds.delete();
for i in range(12):
cmds.select(planeName+'.f['+str(i)+']', toggle=True);
for i in range(96, 108):
cmds.select(planeName+'.f['+str(i)+']', toggle=True);
for i in range(1,8):
cmds.select(planeName+'.f['+str(i*12)+']', toggle=True);
for i in range(1,8):
cmds.select(planeName+'.f['+str(i*12+11)+']', toggle=True);
cmds.delete();
cmds.scale(1, 1, 0.5, planeName);
#cmds.select(planeName+'.f[0:113]')
cmds.polyExtrudeFacet(planeName+'.f[0:113]', constructionHistory=1, keepFacesTogether=0, pvx=4.7, pvy=-1.058, pvz=2.38, divisions=1, twist=0, taper=1, off=0, thickness=0, smoothingAngle=30)
cmds.setAttr("polyExtrudeFace"+str(n*2+1)+".localScale", 0.833333, 0.833333, 0.829938, type="double3")
cmds.delete();
cmds.select(planeName+'.f[0:723]')
cmds.polyExtrudeFacet(constructionHistory=1, keepFacesTogether=1, pvx=-4.7, pvy=-1.058, pvz=2.38, divisions=1, twist=0, taper=1, off=0, thickness=0, smoothingAngle=30)
cmds.setAttr("polyExtrudeFace"+str(n*2+2)+".localTranslate", 0, 0, 1, type="double3")
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 hsbc() :
hsbcBuilding = mc.polyCube(h=9,n="HSBC")
mc.move(0,9/2.0,0,hsbcBuilding)
mc.polyExtrudeFacet( hsbcBuilding[0] +".f[1]", kft=False, ltz=2, ls=(.5, .5, 0) )
mc.select(clear =True)
def extrudeSimple(face):
""" extrude a simple rooftop """
localScaleRDM = random.uniform(0.88, 0.98)
localScale = (localScaleRDM, localScaleRDM, 1)
thickness = random.randint(30,65)
cmds.polyExtrudeFacet(face, ch=HISTORY, keepFacesTogether=False, thickness=thickness, localScale=localScale)
return face
def extrudeHole(face):
""" extrude a rounded and """
iterations = 5
localScale = 0.9
thickness = 25
for iteration in range(iterations):
cmds.polyExtrudeFacet(face, ch=HISTORY, keepFacesTogether=False, thickness=thickness, localScale=[localScale, localScale, localScale])
thickness -= 10
return face
def extrudeConcave(face):
""" extrude a concave rooftop """
iterations = 3
localScale = 0.85
thickness = 25
for iteration in range(iterations):
cmds.polyExtrudeFacet(face, ch=HISTORY, keepFacesTogether=False, thickness=thickness, localScale=[localScale, localScale, localScale])
localScale += 0.04
thickness += 5
return face
def extrudeRounded(face):
""" extrude a rounded rooftop """
iterations = 4
localScale = 0.92
thickness = random.randint(25,35)
for iteration in range(iterations):
cmds.polyExtrudeFacet(face, ch=HISTORY, keepFacesTogether=False, thickness=thickness, localScale=[localScale, localScale, localScale])
localScale -= 0.04
thickness -= 5
return face
def extrudePinched(face):
""" extrude a pinched rooftop if the face has exactly 4 edges """
iterations = 1
localScaleX = 1
localScaleY = 0
localScaleZ = 1
thickness = 25
for iteration in range(iterations):
cmds.polyExtrudeFacet(face, ch=HISTORY, keepFacesTogether=False, thickness=thickness, localScale=[localScaleX, localScaleY, localScaleZ])
return face
def extrudeTool(self):
X = self.getSelection() # adds selection to a variable so we can deselect it later while still using it for the Dragger command.
if self.getType(0) == 'face':
cmds.polyExtrudeFacet( X, constructionHistory = 1, keepFacesTogether = 1)
self.setAttributes( attrs = [('Thickness', '.thickness'), ('Offset', '.offset'), ('Division', '.divisions'), ('Z Translate', '.localTranslateZ'), ('Faces Together', '.keepFacesTogether')] )
elif self.getType(0) == 'edge':
cmds.polyExtrudeEdge( X, constructionHistory = 1, keepFacesTogether = 1)
self.setAttributes( attrs = [('Thickness', '.thickness'), ('Offset', '.offset'), ('Division', '.divisions'), ('Z Translate', '.localTranslateZ')] )
else:
pass
#cmds.select( deselect = 1 ) # removes selection from the face initially extruded, to allow for rotation and translation of new extruded face
self.Dragger( X , 'Extrude')
def add_spikes(obj):
"""This function adds spikes to a polygon object."""
try:
polyCount = cmds.polyEvaluate(obj, face=True)
except:
raise
for i in range(0,polyCount):
face="%s.f[%s]" % (obj,i)
cmds.polyExtrudeFacet(face, ltz=1, ch=0)
cmds.polyExtrudeFacet(face, ltz=1, ch=0, ls=[0.1,0.1,0.1])
cmds.polySoftEdge(obj, a=180, ch=0)
cmds.select(obj)
def extrudeDouble(face):
""" extrude a double iteration rooftop """
iterations = 2
s = 0.0
t = 0
for iteration in range(iterations):
localScaleRDM = random.uniform(0.88-s, 0.98-s)
localScale = (localScaleRDM, localScaleRDM, 1)
thickness = random.randint(30,65)-t
cmds.polyExtrudeFacet(face, ch=HISTORY, keepFacesTogether=False, thickness=thickness, localScale=localScale)
s += 0.2
t += 10
return face
def crear(self): #Tipo 1 if(self.edififio_seleccionado == 0): cmds.polyCube(w = self.anchura, d = self.Largo, h = self.Anchura_random, n = str(self.EdificioName)) #Tipo 2 elif(self.edififio_seleccionado == 1): cmds.polyCube(w = self.anchura, d = self.Largo, h = self.Anchura_random, n = str(self.EdificioName)) #Modificamos las caras aleatoriamente for i in range(0, random.randrange(0,3)): cmds.polyExtrudeFacet(str(self.EdificioName) + ".f[1]", kft = False, ls = (0.8, 0.8, 0)) cmds.polyExtrudeFacet(str(self.EdificioName) + ".f[1]", kft = False, ltz = 30) #Tipo 3 else: cmds.polyCube(w = self.anchura, d = self.Largo, h = self.Anchura_random, sx = self.xDiv, sy = self.yDiv, sz = self.zDiv, n = str(self.EdificioName)) sides = [] #Seleccionamos el edificio for i in range(0, 8): if(i != 1 and i != 3): sides.append(str(self.EdificioName) + ".f[" + str(self.xDiv * self.yDiv * i) + ":" + str((self.xDiv * self.yDiv * (i+1)) - 1) + "]") #Modificamos las caras para generar ventanas cmds.polyExtrudeFacet(sides[0], sides[1], sides[2], sides[3], sides[4], sides[5], kft = False, ls = (0.8, 0.8, 0)) windows = cmds.ls(sl = True) cmds.polyExtrudeFacet(windows[1], windows[2], windows[3], kft = False, ltz = -0.2) cmds.select( self.EdificioName)
def create(self): #building type number 1 if(self.buildingType == 0): cmds.polyCube(w = self.width, d = self.depth, h = self.height, n = str(self.buildingName)) #building type number 2 elif(self.buildingType == 1): cmds.polyCube(w = self.width, d = self.depth, h = self.height, n = str(self.buildingName)) #random number of upward extrusions for i in range(0, random.randrange(0,3)): cmds.polyExtrudeFacet(str(self.buildingName) + ".f[1]", kft = False, ls = (0.8, 0.8, 0)) cmds.polyExtrudeFacet(str(self.buildingName) + ".f[1]", kft = False, ltz = 30) #building type number 3 else: cmds.polyCube(w = self.width, d = self.depth, h = self.height, sx = self.xDiv, sy = self.yDiv, sz = self.zDiv, n = str(self.buildingName)) sides = [] #select everything except the top and bottom of the building for i in range(0, 8): if(i != 1 and i != 3): sides.append(str(self.buildingName) + ".f[" + str(self.xDiv * self.yDiv * i) + ":" + str((self.xDiv * self.yDiv * (i+1)) - 1) + "]") #extrude the faces to create windows cmds.polyExtrudeFacet(sides[0], sides[1], sides[2], sides[3], sides[4], sides[5], kft = False, ls = (0.8, 0.8, 0)) windows = cmds.ls(sl = True) cmds.polyExtrudeFacet(windows[1], windows[2], windows[3], kft = False, ltz = -0.2) cmds.select( self.buildingName)
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 changeTeeth(constructor, extrude, teeth=10, length=1):
# we get the number of spans
spans = teeth * 2
#We edit the polyPipe node to change its teeth
cmds.polyPipe(constructor, edit=True, sa=spans)
# input components attr allow us to change the extrude node
sideFaces = range(spans * 2, spans * 3, 2)
faceNames = []
for face in sideFaces:
faceName = 'f[%s]' % (face)
faceNames.append(faceName)
# We define what we want to change where and how many tgrough the setAttr functions
cmds.setAttr('%s.inputComponents' % (extrude),
len(faceNames),
*(faceNames),
type='componentList') # expands faceName list
#We edit the polyExtrude node to change its legth
cmds.polyExtrudeFacet(extrude, edit=True, ltz=length)
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)
faceNames = []
for face in sideFaces:
faceName = 'f[%s]' % (face)
faceNames.append(faceName)
cmds.setAttr('%s.inputComponents' % (extrude),
len(faceNames),
*faceNames,
type="componentList")
cmds.polyExtrudeFacet(extrude, edit=True, ltz=length)
def makeTeeth(self, teeth=10, length=0.3):
mc.select(clear=True)
faces = self.getTeethFaces(teeth)
for face in faces:
mc.select('%s.%s' % (self.transform, face), add=True)
self.extrude = mc.polyExtrudeFacet(localTranslateZ=length)[0]
mc.select(clear=True)
def flatTop(_top):
edge = random.choice([True, False])
edgeHeight = random.uniform(0.1, 0.5)
edgeWidth = random.uniform(0.7, 0.95)
boxSizeX = random.uniform(0.2, 0.8)
boxSizeY = random.uniform(0.2, 0.8)
boxSizeZ = random.uniform(0.2, 0.8)
if edge == True:
cmds.polyExtrudeFacet(_top, translateY=edgeHeight)
cmds.polyExtrudeFacet(_top,
localScale=(edgeWidth, edgeWidth, edgeWidth))
cmds.polyExtrudeFacet(_top, translateY=(-1 * edgeHeight))
else:
cmds.polyExtrudeFacet(_top, localScale=(boxSizeX, boxSizeY, boxSizeZ))
cmds.move(boxSizeX / 4, 0, boxSizeZ / 4, _top, r=True)
cmds.polyExtrudeFacet(_top, translateY=2 * edgeHeight)
def create_joint(name, side, position):
groove = True
j_radius = 0.05
rotation = [90, 90, 0]
ctrl_rotation = [90, 0, 0]
if name in ['elbow', 'knee', 'ankle', 'wrist']:
j_radius = 0.038
if name in ['wrist', 'ankle']:
j_radius = 0.032
if name == 'wrist':
rotation = [90, 0, 0]
elif name == 'shoulder':
rotation = [90, 0, 0]
ctrl_rotation = [45, 90, 0]
if side == r:
ctrl_rotation = [-45, 90, 0]
elif name == 'neck':
groove = False
elif name == 'waist':
j_radius = 0.08
groove = False
ctrl_crv = cmds.circle(name='{0}_joint_{1}_crv'.format(name, side),
radius=1.75 * j_radius)
cmds.move(position[0], position[1], position[2], ctrl_crv)
cmds.rotate(ctrl_rotation[0], ctrl_rotation[1], ctrl_rotation[2], ctrl_crv)
paintCurve(ctrl_crv[0], side)
joint_geo = cmds.polySphere(name='{0}_joint_{1}_geo'.format(name, side),
radius=j_radius,
sy=21)
cmds.move(position[0], position[1], position[2], joint_geo)
cmds.rotate(rotation[0], rotation[1], rotation[2], joint_geo)
if groove:
cmds.polyExtrudeFacet('{0}_joint_{1}_geo.f[180:199]'.format(
name, side),
kft=True,
ltz=-0.004)
def make_stair(w_val, h_val):
stairbody = cmds.polyCube(n='stair_body*', w=w_val, h=0.4, d=2.5)
cmds.move(0, 0.2, 0)
cmds.move(0, h_val + 0.2, 0)
stairfoot = cmds.polyCube(n='stair_foot*', w=0.1, h=h_val, d=0.5)
cmds.polyExtrudeFacet('stair_foot_.f[1]', kft=True, ltz=0.4)
cmds.polyExtrudeFacet('stair_foot_.f[8]', kft=True, ltz=2)
cmds.select(stairfoot)
cmds.move(w_val / 2 + 0.05, h_val / 2, 1, r=True)
stairfoot_dup = cmds.duplicate(stairfoot[0])
cmds.move(-w_val - 0.1, 0, 0, r=True)
cmds.group(stairbody, stairfoot, stairfoot_dup, name='stairs')
cmds.move(0, 0, -1.25)
cmds.makeIdentity(apply=True)
def makeTeeth(self, teeth=10, length=0.3):
# The logic here is exactly the same as in the makeTeeth function we created
cmds.select(clear=True)
faces = self.getTeethFaces(teeth)
for face in faces:
cmds.select('%s.%s' % (self.transform, face), add=True)
# Instead of returning a value, lets just store the extrude node onto the class as a class variable
self.extrude = cmds.polyExtrudeFacet(localTranslateZ=length)[0]
cmds.select(clear=True)
def branchMesh(branchName, branchBark, branchNode, branchParent):
#setup new cylinder for each branch
jointPosWorld = cmds.joint(branchParent, a=True, query=True, p=True)
cmds.polySphere(r=0.5)
cmds.move(jointPosWorld[0],jointPosWorld[1], jointPosWorld[2])
cmds.polyCylinder(n=branchBark, sx=20, sy=0, sz=0, h=8, r = 2)
cmds.move(8/2, y=True)
cmds.makeIdentity(apply=True, t=1, r=1, s=1, n=0)
cmds.select( d=True )
for k in range(20):
cmds.select(branchBark+'.f[' + (str(k)) + ']', add=True)
cmds.select(branchBark+'.f[21]', add=True)
cmds.delete(s=True)
cmds.move(0,0,0, branchBark+".scalePivot",branchBark+".rotatePivot", absolute=True)
cmds.select(d=True)
cmds.select(branchBark)
cmds.move(jointPosWorld[0],jointPosWorld[1], jointPosWorld[2])
#aims cylinder face at next node position, then rotates so extrusion with ltz can be performed
cmds.aimConstraint( branchNode, branchBark )
cmds.aimConstraint( branchNode, branchBark, rm=True)
cmds.select(branchBark)
cmds.rotate('90deg', rotateZ=True, os=True, r=True)
cmds.scale(0.25,0.25,0.25)
rotationVal=cmds.joint(branchName, query=True,ax=True, ay=True, az=True)
jointPosWorld = cmds.joint(branchName, a=True, query=True, p=True)
jointPosRelative = cmds.joint(branchName, r=True, query=True, p=True)
cmds.move(jointPosWorld[0], jointPosWorld[1], jointPosWorld[2], branchBark+'.scalePivot',branchBark+'.rotatePivot', absolute=True)
cmds.select(branchBark+'.f[0]')
localZ = math.sqrt((math.pow(jointPosRelative[0], 2)) + (math.pow(jointPosRelative[1], 2)) + (math.pow(jointPosRelative[2], 2)))
cmds.polyExtrudeFacet(lrx = rotationVal[0], ltx = 0, lty = 0, ltz = localZ)
cmds.makeIdentity(apply=True, t=1, r=1, s=1, n=0)
cmds.select(branchBark+'.f[0]', d=True)
def blueprintIKArrow():
""" Arrow geo creation """
arrow = cmds.polyCube(name='blueprint_ikArrow',
width=5,
height=1,
subdivisionsX=2,
subdivisionsY=2,
axis=(0, 1, 0))
cmds.select(arrow)
cmds.select('blueprint_ikArrow.vtx[1]', 'blueprint_ikArrow.vtx[4]',
'blueprint_ikArrow.vtx[7]', 'blueprint_ikArrow.vtx[10]',
'blueprint_ikArrow.vtx[13]', 'blueprint_ikArrow.vtx[16]')
cmds.move(2.15,
0,
0,
relative=True,
objectSpace=True,
worldSpaceDistance=True)
cmds.select('blueprint_ikArrow.f[5]', 'blueprint_ikArrow.f[11]')
cmds.polyExtrudeFacet(pivotX=2.325000048)
cmds.setAttr('polyExtrudeFace1.localTranslate', 0, 0, 0.65, type='double3')
cmds.select('blueprint_ikArrow.vtx[5]', 'blueprint_ikArrow.vtx[14]')
cmds.move(1.15,
0,
0,
relative=True,
objectSpace=True,
worldSpaceDistance=True)
cmds.select('blueprint_ikArrow.vtx[2]', 'blueprint_ikArrow.vtx[8]',
'blueprint_ikArrow.vtx[11]', 'blueprint_ikArrow.vtx[17]')
cmds.move(0.648,
0,
0,
relative=True,
objectSpace=True,
worldSpaceDistance=True)
""" Create and assign shader """
shader = cmds.shadingNode('lambert', name='bp_red', asShader=True)
cmds.select(arrow)
cmds.hyperShade(assign=shader)
cmds.setAttr(shader + '.color', 1, 0, 0, type='double3')
""" Delete history """
cmds.delete(constructionHistory=True)
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 changeTeeth(constructor, extrude, teeth=10, length=0.3):
spans = teeth * 2
#edit=True is important. taking the existing node and change that.
cmds.polyPipe(constructor, edit=True, subdivisionsAxis=spans)
sideFaces = range(spans * 2, spans * 3, 2)
faceNames = []
for face in sideFaces:
facename = "f[%s]" % (face)
faceNames.append(facename)
#note: *faceNames -> the `*` means expanding the list into individual arguements
cmds.setAttr('%s.inputComponents' % (extrude),
len(faceNames),
*faceNames,
type="componentList")
cmds.polyExtrudeFacet(extrude, edit=True, ltz=length)
def extrude_building(building=None, height=None):
"""
Given an object will extrude it upwards
"""
building_face = '{}.f[0]'.format(building)
if not height:
building_scale = math.ceil(
cmds.polyEvaluate(building_face, worldArea=True) / 1000000)
if building_scale > 12:
building_scale = 12
num_stories = math.floor(random.uniform(1, 3)) * building_scale
height = 450 * num_stories
cmds.polyExtrudeFacet(building_face, kft=True, ltz=height, sma=0)
cmds.polyNormalPerVertex(building, ufn=True)
def changeTeeth(constructor, extrudeFaces, teeth=10, length=0.3):
spans = teeth * 2
# use polypipe with the poly pipe that you already have. use edit flag so it knows to edit the existing one instead of creating a new one
cmds.polyPipe(constructor, edit=True, subdivisionsAxis=spans)
sideFaces = range(spans * 2, spans * 3, 2)
faceNames = []
for face in sideFaces:
faceName = 'f[%s]' % (face)
faceNames.append(faceName)
# print faceNames
# get the length of the faceNames list, give it to setAttr(), get list of all the faces to use: expand the face names list so each one will be a parameter
cmds.setAttr('%s.inputComponents' % (extrudeFaces),
len(faceNames),
*faceNames,
type="componentList")
cmds.polyExtrudeFacet(extrudeFaces, edit=True,
ltz=length) # localTranslateZ shorthand
def addTrunkMesh(self):
for curve in self.allBranchCurves:
#Names trunk
startIdx = len(self.name) + len("_curve_")
trunkName = self.name + "_trunk_" + curve["name"][startIdx:]
#Creates cylinder and moves it to the origin pt
cmds.polyCylinder(name=trunkName,
subdivisionsX=20,
subdivisionsY=1,
r=curve["baseRad"])
cmds.move(-1,
trunkName + ".scalePivot",
trunkName + ".rotatePivot",
moveY=True,
relative=True)
#move polygon to start and align with normal
cmds.select(clear=True)
cmds.select(trunkName, tgl=True)
cmds.select(curve["name"], add=True)
cmds.pathAnimation(follow=True,
followAxis='y',
upAxis='z',
startTimeU=True)
#Selects the face to scale and extrude
cmds.select(clear=True)
cmds.select(trunkName + ".f[26]")
#get Scale of decreased radius
scale = [curve["tipRad"] / curve["baseRad"] for i in range(3)]
#extrudes along curve
cmds.polyExtrudeFacet(inputCurve=curve["name"],
d=1,
localScale=scale)
cmds.parent(trunkName, self.trunkGroup)
self.allTrunks.append(trunkName)
def buildRoof(self):
cmds.select(clear = True)
if(self.roofType == 1):
cmds.polyPlane(w=self.dim[0],h=self.dim[2], sx=1, sy=1, n = 'roof' + str(self.idx))
cmds.move(self.pos[0], self.dim[1] + 0.0*self.roofHeight, self.pos[2], r=1)
cmds.select('roof'+str(self.idx)+'.f[1]')
cmds.polyExtrudeFacet(s=[0.9,1.0,0.9], t=[0.0, self.roofHeight, 0.0])
else:
cmds.polyCube(w=self.dim[0], h=self.roofHeight, d=self.dim[2], n = 'roof' + str(self.idx))
cmds.move(self.pos[0], self.dim[1] + 0.5*self.roofHeight, self.pos[2], r=1)
if(self.dim[2] < self.dim[0] ):
cmds.select('roof' + str(self.idx) + '.vtx[2:3]')
cmds.move(0, 0, -0.5 * self.dim[2], r=1)
cmds.select('roof' + str(self.idx) + '.vtx[4:5]')
cmds.move(0, 0, 0.5 * self.dim[2], r=1)
else:
cmds.select(['roof' + str(self.idx) + '.vtx[2]', 'roof' + str(self.idx) + '.vtx[4]'])
cmds.move(0.5 * self.dim[0], 0, 0, r=1)
cmds.select(['roof' + str(self.idx) + '.vtx[3]', 'roof' + str(self.idx) + '.vtx[5]'])
cmds.move(-0.5 * self.dim[0], 0, 0, r=1)
def set_key_extrusion(self, start, end, numExt): # create individual constants for this extrusion distance = random.uniform(self.minDist, self.maxDist) scale = [random.uniform(self.minScale, self.maxScale), \ random.uniform(self.minScale, self.maxScale), \ random.uniform(self.minScale, self.maxScale) \ ] # get a random face randomFace = self.get_random_face() # create extrude node cmds.polyExtrudeFacet(randomFace.name, kft=False) # get extrusion node extrusion = "polyExtrudeFace" + str(numExt) # set initial keyframe cmds.setKeyframe( extrusion, attribute=['localTranslateZ', 'localScaleX', 'localScaleY', 'localScaleZ'], t=start ) # set final keyframes cmds.setKeyframe( extrusion, attribute='localTranslateZ', v=distance, t=end ) cmds.setKeyframe( extrusion, attribute='localScaleX', v=scale[0], t=end ) cmds.setKeyframe( extrusion, attribute='localScaleY', v=scale[1], t=end ) cmds.setKeyframe( extrusion, attribute='localScaleZ', v=scale[2], t=end )
def changeTeeth(self, teeth=10, length=1):
spans = teeth * 2
cmds.polyPipe(self.constructor, edit=True, subdivisionsAxis=spans)
sideFaces = range(spans * 2, spans * 3, 2)
faceNames = []
for face in sideFaces:
faceName = 'f[%s]' % (face)
faceNames.append(faceName)
#expend list instead of give list,
cmds.setAttr('%s.inputComponents' % (self.extrude),
len(faceNames),
*faceNames,
type="componentList")
cmds.polyExtrudeFacet(self.extrude, edit=True, localTranslateZ=length)
cmds.select(clear=True)
def honeycomb(xbound, zbound, flat, buildCity): dx = 0 indentOn = False #start 0.867 ahead cellnum = 0 while (dx < xbound): dz = 0 if(indentOn): dz = 0.867 while (dz < zbound): cellname = "cell" + "%04d"%cellnum randomheight = 0 raiseMe = False if not flat: randomheight = .1 - (0.2 * random.random()) if buildCity: if xbound/2 - xbound/10 < dx and dx < xbound/2 + xbound/10 and zbound/2 - zbound/10 < dz and dz < zbound/2 + zbound/10: raiseMe = True randombuildingheight = 20 - (10 * random.random()) cmds.polyCylinder(name = cellname, ax=[0,1,0], radius=1, height=1, sx=6, sy=1, sz=0) if raiseMe: cmds.move(0, randombuildingheight, 0, cellname+'.f[7]', r=True) else: cmds.move(0, randomheight, 0, cellname+'.f[7]', r=True) cmds.polyExtrudeFacet(cellname+'.f[7]', kft=False, s=(0.896415,0.896415,0.896415), divisions = 3) cmds.polyExtrudeFacet(cellname+'.f[7]', kft=False, ty=-0.15636, divisions=3) cmds.select(cellname) cmds.polyBevel(offset = 0.7, offsetAsFraction = 1, autoFit = 1, segments = 1, worldSpace = 1, uvAssignment = 0, fillNgons = 1, mergeVertices = 1, mergeVertexTolerance = 0.0001, miteringAngle = 180, angleTolerance = 180, ch = 1) cmds.move(dx, 0, dz) print "cylinder " + cellname + " location = dx: " + str(dx) + ", dz: " + str(dz) dz+=1.729 cellnum += 1 dx += 1.5 indentOn = not indentOn cmds.select([node for node in cmds.ls() if 'cell' in node and 'Shape' not in node]) cmds.group(name='honeycomb') cmds.move(-xbound/2, 0, -zbound/2, 'honeycomb')
def generateGrass(numberOfGrassObjects):
grassObjects = []
for i in range(numberOfGrassObjects):
# Start by creating a new object for the grass to be built with
grassObjects.append(cmds.polyCube(w=1, h=0.01, d=1))
# Move the object into a position accordingly
if (i != 0): moveObject(i)
# Make the grass do grass things...
grassSegments = random.randint(3, 7)
currentName = grassObjects[len(grassObjects) - 1][0]
cmds.select('{}.f[{}]'.format(currentName, 1))
# Randomly extrude and position the grass
for i in range(grassSegments):
translateList = [
random.uniform(-0.5, 0.5),
random.uniform(-0.5, 0.5),
random.uniform(0.5, 1.5)
]
cmds.polyExtrudeFacet(localTranslate=translateList,
localScale=(0.7, 0.7, 0.7))
def modGear(self, teeth=10, length=0.3):
spans = teeth * 2
cmds.polyPipe(self.constructor, edit=1, subdivisionsAxis=spans)
sideFacesNumber = range(spans*2, spans*3, 2)
faceNames = []
for face in sideFacesNumber:
faceName = 'f[%s]' % (face)
faceNames.append(faceName)
cmds.setAttr('%s.inputComponents' % (self.extrude),
len(faceNames),
*faceNames,
type="componentList")
cmds.polyExtrudeFacet(self.extrude, edit=1, ltz=length)
def modify(self, teeth=15, length=0.1):
"""
This function will modify existing gear's profile
:param teeth: number of teeth to create
:param length: how long is the extrusion 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:
name = "f[%s]" % face
face_names.append(name)
cmds.setAttr('%s.inputComponents' % self.extrude,
len(face_names),
*face_names,
type="componentList")
cmds.polyExtrudeFacet(self.extrude, edit=True, ltz=length)
def makeBuilding(face, levels, height, sidewalkHeight):
hl = height/levels
type = random.choice(['indent', 'rim','well'])
makeSidewalk(face, sidewalkHeight)
for i in range(1, levels):
dHeight = height/(2*i)
#extrude in
extrude1 = cmds.polyExtrudeFacet(face, ch=1, kft=0)[0]
cmds.setAttr(extrude1+".localScaleX", 0.5+(0.5*random.random()));
cmds.setAttr(extrude1+".localScaleY", 0.5+(0.5*random.random()));
#extrude again and translate up
extrude2 = cmds.polyExtrudeFacet(face, ch=1, kft=0)[0]
cmds.setAttr(extrude2+".localTranslateZ", dHeight)
if type == 'indent':
makeIndent(face, hl/10.0)
if type == 'rim':
makeRim(face, hl/10.0)
if type == 'well':
makeWell(face, hl/30.0)
if(i == levels-1 and random.random() > 0.6):
makeAntenna(face, dHeight/2.0)
def createRack():
rgb = cmds.colorSliderGrp('rackColour', q=True, rgbValue=True)
# name
nsTmp = "Rack" + str(rnd.randint(1000, 9999))
cmds.select(clear=True)
cmds.namespace(add=nsTmp)
cmds.namespace(set=nsTmp)
# base
rack = cmds.polyCube(h=0.6, w=1.5, d=6, sz=24)
# extrude teeth
for i in range(24):
if (i % 2 == 1):
cmds.select(rack[0] + ".f[" + str(i) + "]")
cmds.polyExtrudeFacet(ltz=0.3)
cmds.polyExtrudeFacet(ltz=0.3)
cmds.polyMoveFacet(lsx=0.1)
tmp = cmds.polyCube(h=0.6, w=1.5, d=2)
cmds.move(-3.753, moveZ=True)
rack = cmds.polyCBoolOp(rack, tmp, op=2)
tmp = cmds.polyCube(h=0.6, w=1.5, d=2)
# add material
myShader = cmds.shadingNode('lambert', asShader=True, name="blckMat")
cmds.setAttr(nsTmp + ":blckMat.color",
rgb[0],
rgb[1],
rgb[2],
type='double3')
cmds.polyUnite((nsTmp + ":*"), n=nsTmp, ch=False)
cmds.move(0.4, moveY=True, a=True)
cmds.delete(ch=True)
cmds.hyperShade(assign=(nsTmp + ":blckMat"))
cmds.namespace(removeNamespace=":" + nsTmp, mergeNamespaceWithParent=True)
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
"""
# Above this is the docstring enclosed in """ """ that documents the function
# This helps for people who want to use the function without needing to read the code
# Teeth are every alternate face, so we double the number of teeth to get the number of spans required
spans = teeth * 2
# the polyPipe command will create a polygon pipe
# the subdivisionsAxis will say how many divisions we'll have along it's length
# It returns a list of [transform, constructor]
# Instead of getting a list and then extracting it's members, we can directly expand it to variables like here
# The transform is the name of the node created and the constructor is the node that creates the pipe and controls its parameters
transform, constructor = cmds.polyPipe(subdivisionsAxis=spans)
# We need to select all the faces that will become the teeth.
# We use the range function to start at span times 2 because that's where the side faces start from
# Then we continue until span times 3 because that's where it ends
# The third optional parameter is how big the steps we will take are.
# So we'll be taking 2 steps instead of 1. e.g. 0, 2, 4, 6, 8
# This will return a list of numbers
sideFaces = range(spans * 2, spans * 3, 2)
# Now we need to clear the selection because we'll be adding each face to it
cmds.select(clear=True)
# We'll loop through all the faces in the list of sideFaces
for face in sideFaces:
# We'll add to the selection
# The '%s.f[%s]' notation looks odd but it expands to something like pPipe1.f[20]
# Which tells it to select the 20th face of the pPipe1 object
# The %s notation means it is a placeholder for the value of the variables after the %
cmds.select('%s.f[%s]' % (transform, face), add=True)
# Now we extrude the selected faces by the given length
# This gives us back the value of the extrude node inside a list
extrude = cmds.polyExtrudeFacet(localTranslateZ=length)[0]
# Finally we return a tuple of (transform, constructor, extrude)
# A tuple is similar to a list but cannot be modified.
# Notice that we don't need to provide the parenthesis that define a tuple, just adding the comma here will do it for us
# Here the transform is our gear node, the constructor is the node that creates the original pipe and the extrude is the node that extrudes the faces
return transform, constructor, extrude
def CreateLeaves(self, height, minSize, maxSize):
leafBase = cmds.polyPrimitive(r=1, l=1, pt=0)[0]
cmds.move(height, y=True)
cmds.polyChipOff(dup=False, kft=False)
cmds.polyChipOff(dup=False, kft=True, ltz=0.08, ran=1.0)
cmds.polyExtrudeFacet(ltz=0.6)
cmds.polySmooth()
cmds.polySeparate()
cmds.xform(cp=True)
for leaf in cmds.ls(sl=True):
leafScale = round(random.uniform(minSize, maxSize), 3)
cmds.select(leaf)
cmds.polySoftEdge(a=0, name=leaf)
cmds.scale(leafScale, leafScale, leafScale)
leafPosition = cmds.xform(leaf, q=True, rp=True, ws=True)
leafPosition[1] = height + 0.5 * (height - leafPosition[1])
cmds.xform(leaf, t=leafPosition, ws=True)
self.SetRandomLeafColor(leaf)
return leafBase
def makeBuilding(self, face, levels, height, sidewalkHeight):
"""
Creates a building frm a supplied polygon face.
@param face string
The face from which to create the building.
@param levels float
The number of levels to extrude.
@param height float
The total height of the building.
@param sidewalkHeight float
The height of the sidewalk.
"""
hl = height/levels
presetType = random.choice(['indent', 'rim','well'])
self.makeSidewalk(face, sidewalkHeight)
for i in range(1, levels):
dHeight = height/(2*i)
# Extrude in.
extrude1 = cmds.polyExtrudeFacet(face, ch=1, kft=0)[0]
cmds.setAttr(extrude1+".localScaleX", 0.5+(0.5*random.random()));
cmds.setAttr(extrude1+".localScaleY", 0.5+(0.5*random.random()));
# Extrude again and translate up.
extrude2 = cmds.polyExtrudeFacet(face, ch=1, kft=0)[0]
cmds.setAttr(extrude2+".localTranslateZ", dHeight)
# Add a preset.
if presetType == 'indent':
self.makeIndent(face, hl/10.0)
if presetType == 'rim':
self.makeRim(face, hl/10.0)
if presetType == 'well':
self.makeWell(face, hl/30.0)
# If we're at the top level, add an antenna.
if(i == levels-1 and random.random() > ANTENNA_CHANCE):
self.makeAntenna(face, dHeight/2.0)
def extrudeList(face, extrudes, heights, scales):
"""
Given a face and a list of extrusions, performs the extrudes in order,
applying the given heights and scales. NOTE: The height for down is a
positive number.
@param face string
The start face to extrude.
@param extrudes list
A list containing extrude keywords to apply to face.
@param heights list
A list of height values corresponding to 'up' or 'down' extrusion
keywords.
@param scales list
A list of scale values corresponding to 'out' and 'in' keywords.
"""
if len(extrudes) != len(heights) + len(scales):
return
heightIndex = 0
scaleIndex = 0
for e in extrudes:
if e in ["up", "down", "antenna"]:
h = heights[heightIndex]
if e == "down":
h = -1.0*h
extrude1 = cmds.polyExtrudeFacet(face, ch=1, kft=0)[0]
cmds.setAttr(extrude1+".localTranslateZ", h)
if e == "antenna":
cmds.setAttr(extrude1+".localScaleX", 0.5)
cmds.setAttr(extrude1+".localScaleY", 0.5)
heightIndex += 1
elif e in ["in", "out"]:
s = scales[scaleIndex]
extrude1 = cmds.polyExtrudeFacet(face, ch=1, kft=0)[0]
cmds.setAttr(extrude1+".localScaleX", s)
cmds.setAttr(extrude1+".localScaleY", s)
scaleIndex += 1
else:
print "e was not a valid extrude type"
def modificar_tuerca(constructor, extruded_faces, teeth=10, length=0.3):
spans = teeth * 2
cmds.polyPipe(constructor, edit=True, subdivisionsAxis=spans)
side_faces = range(spans*2, spans*3, 2)
face_names = []
for face in side_faces:
face_name = 'f[%s]' % (face)
face_names.append(face_name)
print extruded_faces
# Cambia el numero de dientes
cmds.setAttr('%s.inputComponents' % extruded_faces[0],
len(face_names),
*face_names,
type="componentList")
# Cambiar la longitud de los dientes
cmds.polyExtrudeFacet(extruded_faces, edit=True, ltz=length)
def change_teeth(self, teeth=10, length=0.3):
"""
Allows you to change the number of teeth and length of an existing gear mesh
Args:
teeth: How many teeth the gear will have
length: How long each teeth will be
"""
subdivisions_axis = teeth * 2
cmds.polyPipe(self.poly_pipe_constructor, edit=True, subdivisionsAxis=subdivisions_axis)
side_faces = range(subdivisions_axis * 2, subdivisions_axis * 3, 2)
face_names = []
for face in side_faces:
face_name = "f[%s]" % face
face_names.append(face_name)
# print("face_names: " + str(face_names)) # the faces that should be extruded in the modified gear
# setAttr has different parameters depending on the type of data we're trying to set https://help.autodesk.com/cloudhelp/2018/CHS/Maya-Tech-Docs/CommandsPython/setAttr.html
# In this case we want to set a list of face components on the extrude node's inputComponents attribute
# The asterisk unpacks the list and passes the elements as individual arguments
cmds.setAttr("%s.inputComponents" % self.extrude, len(face_names), *face_names, type="componentList")
cmds.polyExtrudeFacet(self.extrude, edit=True, localTranslateZ=length)
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 changeTeeth(self, teeth=10, length=0.3):
spans = teeth * 2
# This sets the number of subdivision axes i.e. # of gears
cmds.polyPipe(self.constructor, edit=True, subdivisionsAxis=spans)
# This stores the names/#s of the faces to select
sideFaces = range(spans * 2, spans * 3, 2)
faceNames = []
for face in sideFaces:
faceName = 'f[%s]' % (face)
faceNames.append(faceName)
# This extrudes only the faces we want extruded, otherwise Maya doesn't know which ones
cmds.setAttr('%s.inputComponents' % (self.extrude),
len(faceNames),
*faceNames,
type="componentList")
# This actively changes the extrusion, i.e. changes the extrusion value on the z axis
cmds.polyExtrudeFacet(self.extrude, edit=True, ltz=length)
def createGear(self, teeth=10, length=0.3):
spans = teeth * 2
self.transform, self.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]' % (self.transform, face), add=True)
self.extrude = cmds.polyExtrudeFacet(localTranslateZ=length)[0]
def makeProxyGeo():
"""This function creates a default proxy geo if the user does not provides one """
# Create a cube
geo = cmds.polyCube(name="TreadProxyGeo", width=5, height=.5, depth=1, sx=5)[0]
faces = [0,2,4,11,13]
cmds.select(clear=True)
# Select specific faces to make desired shape
for f in faces:
cmds.select("%s.f[%s]"%(geo,f), add=True)
# Extrude those faces
cmds.polyExtrudeFacet(thickness=.5, offset=.1)
# Select the geo itself
cmds.select(geo, r=True)
# Delete its history
cmds.DeleteHistory()
# Return reference to the geo
return geo
def generate(cls, *args):
components = []
width = 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 = width * Constants["wheel_radius_unit"]
wheel_height = height * Constants["wheel_height_unit"]
wheel_component = cmds.polyCylinder(name=get_unique_name(cls.get_prefix(), "cylender"), sx=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"])
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 build(self, file):
print "start to build"
osm = pooper.data()
osm.castData(file)
osm.freezePoints(100000)
ct = 0
pro = self.progressBar(len(osm.buildings), 100)
for key, val in osm.buildings.items():
if ct in pro:
self.valueUpdated.emit(pro[ct])
ct += 1
if val.type and val.type.startswith("build"):
tPoint = self.ps2tuple(osm.points, val.pID)
if len(tPoint) <= 2: continue
bid = "b" + str(key)
cmds.polyCreateFacet(p=tPoint, n=bid)
if cmds.polyInfo(fn=True)[0].split(' ')[-2][0] == "-":
cmds.polyNormal(nm=0)
if val.height:
cmds.select(bid)
cmds.xform(cp=True)
cmds.polyExtrudeFacet(kft=False, ltz=val.height)
elif len(val.pID) >= 3 and val.pID[0] == val.pID[-1]:
tPoint = self.ps2tuple(osm.points, val.pID)
if len(tPoint) <= 2: continue
bid = "b" + str(key)
cmds.polyCreateFacet(p=tPoint, n=bid)
if cmds.polyInfo(fn=True)[0].split(' ')[-2][0] == "-":
cmds.polyNormal(nm=0)
if val.height:
cmds.select(bid)
cmds.xform(cp=True)
cmds.polyExtrudeFacet(kft=False, ltz=val.height)
elif "boundary" in val.tags:
tPoint = self.ps2tuple(osm.points, val.pID)
if len(tPoint) <= 2: continue
cmds.curve(p=tPoint, d=1)
def extrudeList(face, extrudes, heights, scales):
if(len(extrudes) != len(heights) + len(scales)):
return
i = 0 #for heights
j = 0 #for scales
for e in extrudes:
if(e == "up" or e == "down" or e == "antenna"):
h = heights[i]
if(e == "down"):
h = -1.0*h
extrude1 = cmds.polyExtrudeFacet(face, ch=1, kft=0)[0]
cmds.setAttr(extrude1+".localTranslateZ", h)
if(e == "antenna"):
cmds.setAttr(extrude1+".localScaleX", 0.5)
cmds.setAttr(extrude1+".localScaleY", 0.5)
i += 1
elif(e == "in" or e == "out"):
s = scales[j]
extrude1 = cmds.polyExtrudeFacet(face, ch=1, kft=0)[0]
cmds.setAttr(extrude1+".localScaleX", s)
cmds.setAttr(extrude1+".localScaleY", s)
j += 1
else:
print "e was not a valid extrude type"
def generateGrass(numberOfGrassObjects):
# Create list to hold the objects within the grass to be created
grassObjects = []
# Make a grass object for each part
for i in range(numberOfGrassObjects):
# Start by creating a new object for the grass to be built with
grassObjects.append(cmds.polyCube(w=1, h=0.01, d=1))
# Move the object into a position accordingly
if (i != 0): moveGrassObject(i)
# Make the grass do grass things...
grassSegments = random.randint(3, 7)
currentName = grassObjects[len(grassObjects) - 1][0]
cmds.select('{}.f[{}]'.format(currentName, 1))
# Randomly extrude and position the grass
for i in range(grassSegments):
translateList = [
random.uniform(-0.5, 0.5),
random.uniform(-0.5, 0.5),
random.uniform(0.5, 1.5)
]
cmds.polyExtrudeFacet(localTranslate=translateList,
localScale=(0.7, 0.7, 0.7))
# Now that we have all of the grass that we need generated we can now group it all and return it
for grass in grassObjects:
cmds.select(grass[0], tgl=True)
grassGrp = cmds.polyUnite(ch=False)
cmds.select(grassGrp[0])
# My smooth brain made the grass way too big, so let's scale it down afterwards and pretend nothing happened, it will be fine
scaleValue = random.uniform(0.02, 0.1)
cmds.scale(scaleValue, scaleValue, scaleValue)
return grassGrp
def CreateGear(self, teeth = 10, length = 0.3):
'''
Create a gear with the given parameters
Args:
teeth: number of teeth
length: Length of the teeth
'''
self.transform, self.node = cmds.polyPipe(subdivisionsAxis = teeth * 2)
cmds.select(clear =True)
faces = self.GetTeethFaces(teeth)
for face in faces:
cmds.select("%s.%s" % (self.transform, face), add = True)
self.extrude = cmds.polyExtrudeFacet(localTranslateZ = length)[0]
cmds.select(clear = True)
def solidifyObject(object, height=1, divisions=2, history=True): """ Solidifies given object. :param object: Object. :type object: str :param height: Extrusion height. :type height: float :param division: Extrusion divisions. :type division: float :param history: Keep construction history. :type history: bool """ if hasBorderEdges(object): transform = getTransform(object) vertices = cmds.ls(cmds.polyListComponentConversion(object, toVertex=True), fl=True) barycenters = cmds.xform(vertices, q=True, t=True, ws=True) barycenter = getAverageVector([(barycenters[i], barycenters[i + 1], barycenters[i + 2]) for i in range(0, len(barycenters), 3)]) normals = cmds.polyNormalPerVertex(cmds.polyListComponentConversion(object, toVertexFace=True), q=True, xyz=True) normals = [(normals[i], normals[i + 1], normals[i + 2]) for i in range(0, len(normals), 3)] averageNormal = vectorMatrixMultiplication(normalize(getAverageVector(normals)), cmds.xform(transform, query=True, matrix=True, worldSpace=True)) facesCount = cmds.polyEvaluate(object, face=True) faces = object + ".f[0:" + str(facesCount - 1) + "]" extrude = cmds.polyExtrudeFacet(faces, constructionHistory=1, keepFacesTogether=1, divisions=divisions) cmds.setAttr(extrude[0] + ".localTranslateZ", height) borderEdges = cmds.polyListComponentConversion(faces, te=True, bo=True) cmds.polyMapCut(borderEdges) uvs = cmds.polyListComponentConversion(object + ".f[0:" + str(facesCount - 1) + "]", toUV=1) cmds.polyEditUV(uvs, u=0, v=-5) extendedFaces = cmds.ls(faces, fl=True) for i in range(divisions): adjacentEdges = cmds.polyListComponentConversion(extendedFaces, ff=True, te=True) extendedFaces.extend(cmds.ls(cmds.polyListComponentConversion(adjacentEdges, fe=True, tf=True), fl=True)) borderFaces = list(set(extendedFaces).difference(set(cmds.ls(faces, fl=True)))) cmds.select(borderFaces) cmds.polyAutoProjection(borderFaces, t=barycenter, ry=getAngle((0, 0, 1), averageNormal), rz=getAngle((1, 0, 0), averageNormal)) uvs = cmds.polyListComponentConversion(borderFaces, toUV=1) cmds.polyEditUV(uvs, u=0, v=-5) not history and cmds.delete(object, ch=True)
def createSpeaker():
"""create a speaker shape to be used as a sound visualiser.
return : name of the cylinder created
"""
# create cylinder
speaker = cmds.polyCylinder(h=0.025, r=0.5)
# extrude to create 'speaker' shape
cmds.polyExtrudeFacet(speaker[0] + ".f[21]", scale=(0.8, 0.8, 0.8))
cmds.polyExtrudeFacet(speaker[0] + ".f[21]", scale=(0.5, 0.5, 0.5), translate=(0, -0.2, 0))
cmds.polyExtrudeFacet(speaker[0] + ".f[21]", translate=(0, 0.1, 0))
return speaker
def normalCheck(meshList=[]):
'''
Setup normal check properties for a specified list of meshes.
@param meshList: List of meshes to setup normal check for
@type meshList: list
'''
# Check Mesh List
meshList = cleanup.getMeshList(meshList)
if not meshList: return []
# Check Normal Shader
normalSG = 'normalCheckSG'
normalShader = 'normalCheckShader'
if not mc.objExists(normalShader):
# Create Shader
normalShader = mc.shadingNode('lambert',asShader=True,n=normalShader)
normalSG = mc.sets(renderable=True,noSurfaceShader=True,empty=True,name=normalSG)
mc.connectAttr(normalShader+'.outColor',normalSG+'.surfaceShader',f=True)
mc.setAttr(normalShader+'.color',0,0,0)
mc.setAttr(normalShader+'.incandescence',1,0,0)
# Setup Normal Check
for mesh in meshList:
# Clear selection
mc.select(cl=True)
# Turn on double sided
mc.setAttr(mesh+'.doubleSided',1)
# Extrude face
numFace = mc.polyEvaluate(mesh,f=True)
polyExtrude = mc.polyExtrudeFacet(mesh+'.f[0:'+str(numFace)+']',ch=1,kft=True,pvt=(0,0,0),divisions=2,twist=0,taper=1,off=0,smoothingAngle=30)
mm.eval('PolySelectTraverse 1')
extrudeFaceList = mc.filterExpand(ex=True,sm=34)
mc.setAttr(polyExtrude[0]+'.localTranslateZ',-0.001)
# Apply shader
mc.sets(extrudeFaceList,fe=normalSG)
# Set selection
mc.select(meshList)
# Retrun result
return meshList
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 createBladeOfGrass(self):
""" This method creates a blade of grass. """
# random the high of blade
self.grassHeight = 0.2 * random.randrange ( 6, 10 );
# create the plane of blade
mc.polyPlane( axis=(0, 0, 0), subdivisionsX=2, subdivisionsY=6, height=4 );
mc.move( 0, 2, 0 )
self.currentBlade = mc.ls( sl=True );
# create the form of blade
mc.displaySmoothness( divisionsU=3, divisionsV=3, pointsWire=16, pointsShaded=4, polygonObject=3 );
mc.select( self.currentBlade[0] + ".vtx[18:20]", r=True ) ;
mc.softSelect( softSelectEnabled=True, ssd=20, sud=0.5 );
mc.scale( 0.1, 1, 1, p=(0, 9.86, 0), r=True );
mc.softSelect( ssd=8.08, sud=0.5 );
# bend the grass
bendGrassRandom = 15 * (3.0 - random.random())
mc.rotate( bendGrassRandom, 0, 0, os=True, r=True, p=(0, 9.18, 0) );
mc.select( self.currentBlade )
extrudeFace = mc.polyExtrudeFacet( self.currentBlade[0] + ".f[0:11]", constructionHistory=1, keepFacesTogether=1, pvx=0, pvy=4.84, pvz=0.14, divisions=1, twist=0, taper=1, off=0, thickness=0, smoothingAngle=30 );
mc.setAttr( extrudeFace[0] + ".localTranslate", 0, 0, 0.05, type='double3' );
mc.softSelect( softSelectEnabled=False )
# scale the blade
mc.select( self.currentBlade )
mc.scale( 1, self.grassHeight, 1, r=True )
# delete history
maya.mel.eval( "DeleteHistory" )
# change the position
self.changePositionBlade()
return self.currentBlade
import maya.cmds as mc import random currentObjSel = mc.ls(sl=True, tr=True) objFaceCnt = mc.polyEvaluate(currentObjSel, f=True) print objFaceCnt randnum = random.sample(xrange(0, objFaceCnt), (objFaceCnt)) for value in randnum: #print(value) currentFaceCnt = mc.polyEvaluate(currentObjSel, f=True) #used in the next for loop #print currentFaceCnt extRand = random.uniform(1,3) mc.select(currentObjSel[0] + '.f[' + str(value) + ']', r=True) mc.polyExtrudeFacet(ltz = extRand, d=2) for obj in range(1): newFaceCnt = mc.polyEvaluate(currentObjSel, f=True) getFace = newFaceCnt - currentFaceCnt print getFace
getCurvLen = mc.arclen(curveObj)
makeCvrLenInt = math.ceil(getCurvLen*.5)#reduces the amount of spans the curve has, this is useful on very long extrusions
makeCircle = mc.circle(n="newCircle",d=1, s=12)
aCircle = mc.planarSrf(makeCircle[0], n="extruTube", ch=1, d=1, ko=0, rn=0, po=1, nds=3)
getTesInfo = mc.listConnections(aCircle[1], t="nurbsTessellate")
mc.setAttr(getTesInfo[0] + ".polygonCount", 1)
mc.setAttr(getTesInfo[0] + ".polygonType", 1)
mc.setAttr(getTesInfo[0] + ".format", 0)
getCurveCVPos = mc.xform(curveObj + ".cv[0]", ws=True, q=True, translation=True)
mc.xform(makeCircle[0], ws=True, t=(getCurveCVPos[0], getCurveCVPos[1], getCurveCVPos[2]),ro=(90, 0, 0))#use "ro" to orient the circle to the curve if your extrusion is black
tubes = mc.polyExtrudeFacet(aCircle[0] + ".f[0]", inc=curveObj, d=makeCvrLenInt)
subCurveCreate = mc.createNode("subCurve", n="subCurve_" + curveObj)
curveShape = mc.listRelatives(curveObj, s=True)
mc.setAttr(subCurveCreate + ".relative", 1)
mc.connectAttr(curveShape[0] + ".worldSpace", subCurveCreate + ".inputCurve", f=True)
mc.connectAttr(subCurveCreate + ".outputCurve", tubes[0] + ".inputProfile", f=True)
mc.setAttr(subCurveCreate + ".maxValue", 0)
mc.setKeyframe(subCurveCreate, attribute='maxValue', t=[sortedKeyFrameList[0]])
mc.setAttr(subCurveCreate + ".maxValue", 1)
mc.setKeyframe(subCurveCreate, attribute='maxValue', t=[sortedKeyFrameList[-1]])
#set the visibility
mc.setAttr(aCircle[0] + ".visibility", 1)
