def generateGeometry():
    webCurves = determineSelectedCurves()
    stringThickness = cmds.intSliderGrp('stringThickness', q=True, v=True)
    stringThickness = float(stringThickness)
    stringThickness = 0.002 * stringThickness
    """ Create circle curve with radius based on stringThickness as webExtrudeMap """
    cmds.circle(nr=(0, 0, 0),
                c=(0, 0, 0),
                sw=360,
                r=stringThickness,
                n='webExtrudeMap')
    circleGeo = 'webExtrudeMap'

    for web in webCurves:
        """ Extrude circle curve along web curve to create geometry (po=0 is nurbs surface, po=1 is polygons, po=3 is bezier surface) """
        cmds.extrude(circleGeo,
                     web,
                     ch=True,
                     rn=False,
                     po=1,
                     et=2,
                     ucp=1,
                     fpt=1,
                     upn=1,
                     rotation=0,
                     scale=1,
                     rsp=1,
                     n='web')

        cmds.delete(web)
    cmds.delete(circleGeo)
def cycloGeoCreation(namespace, name):

    pp1 = [-12, -2.6394186146319176e-15, 11]
    pp2 = [-12, 15.735990524291992, -7.29987907409668]
    pp3 = [-12, -2.6394186146319176e-15, -4.922739028930664]
    pp4 = [-12, 0.18094894289970398, -5.832431793212891]
    pp5 = [-12, 0.696247935295105, -6.603630065917969]
    pp6 = [-12, 1.4674474000930786, -7.118930816650391]
    pp7 = [-12, 2.37713885307312, -7.29987907409668]
    pp8 = [-12, 12.396276473999023, -7.29987907409668]
    pp9 = [-12, 9.056564331054688, -7.29987907409668]
    pp10 = [-12, 5.716851234436035, -7.29987907409668]
    pp11 = [-12, -2.6394186146319176e-15, -0.9603691101074219]
    pp12 = [-12, -2.6394186146319176e-15, 3.002007007598877]
    pp13 = [-12, -2.6394186146319176e-15, 7]

    cmds.curve(n=namespace + ':tempCurve',
               d=1,
               p=[
                   pp1, pp13, pp12, pp11, pp3, pp4, pp5, pp6, pp7, pp10, pp9,
                   pp8, pp2
               ])
    cmds.extrude(namespace + ':tempCurve',
                 ch=True,
                 rn=False,
                 po=1,
                 et=0,
                 upn=0,
                 d=[1, 0, 0],
                 length=24,
                 scale=1,
                 dl=1,
                 n=namespace + ':' + name)
    tesselateNode = cmds.listHistory(namespace + ':' + name, pdo=True)[0]

    cmds.setAttr(tesselateNode + '.polygonType', 1)
    cmds.setAttr(tesselateNode + '.format', 2)
    cmds.setAttr(tesselateNode + '.uNumber', 1)
    cmds.setAttr(tesselateNode + '.vNumber', 6)
    cmds.polyNormal(namespace + ':' + name, ch=False)

    cmds.delete(namespace + ':' + name, ch=True)
    cmds.delete(namespace + ':tempCurve')
    cmds.select(cl=True)

    cycloShader = cmds.shadingNode('lambert',
                                   name=namespace + ':' + 'cyclo_MAT',
                                   asShader=True)
    cycloShaderSG = cmds.sets(name=namespace + ':' + 'cyclo_MAT_SG',
                              empty=True,
                              renderable=True,
                              noSurfaceShader=True)
    cmds.connectAttr(cycloShader + '.outColor',
                     cycloShaderSG + '.surfaceShader')
    cmds.setAttr(cycloShader + '.color', 0.9, 0.9, 0.9, type='double3')
    cmds.sets(namespace + ':' + name, e=True, forceElement=cycloShaderSG)

    activateSmoothPreview(namespace + ':' + name)
Exemplo n.º 3
0
 def draw_tower(self):
     """
     Draw the panoptical tower.
     """
     #column = cmds.cylinder(r=.1, heightRatio=10, p=[0,0,0])
     tower = cmds.circle( nr=(1, 0, 0), c=(0, 0, 0), r=.1)
     cmds.extrude(tower, et=0, d=(1,0,0), l=3)
     pointer = cmds.curve(p=[(0, 0, 0), (0, 2, 0)], degree=1)
     cmds.extrude(pointer, et=0, d=(1,0,0), l=3)
Exemplo n.º 4
0
def visualizeDropoff(node):
    '''
    '''
    shapeCrv, cirNode = mc.circle(n=node+'_visCircle')
    
    mc.connectAttr(node+'.dropoff', cirNode+'.radius', f=True)
    
    pathCrv = node.replace('_mod', '_baseCrv_crv')
    
    # make loft
    mc.extrude(shapeCrv, pathCrv, et=2, fixedPath=True, useComponentPivot=1, useProfileNormal=1)
Exemplo n.º 5
0
def forward ( turtle, _length):        
    newPosition = [ turtle.position[0] + (turtle.heading[0]* _length)  , turtle.position[1] + (turtle.heading[1] * _length), turtle.position[2] + (turtle.heading[2] * _length)]   
    if turtle.pen == True:
        cmds.curve(p = [turtle.position, newPosition ], d = 1, name = 'curve' + str(turtle.curveNum) ) 
        if turtle.fill[0] == 'poly':
            cmds.polyPlane (name = 'plane' + str(turtle.curveNum), w = turtle.size, h = turtle.size, sx = 1, sy = 1)           
            cmds.setAttr ( 'plane' + str(turtle.curveNum) + '.translate', turtle.position[0], turtle.position[1], turtle.position[2], type = 'double3' )   
            cmds.polyExtrudeFacet ( 'plane' + str(turtle.curveNum) , inc = 'curve'+ str(turtle.curveNum) )
            cmds.setAttr ( 'polyExtrudeFace'+ str(turtle.curveNum + 1) + '.taper' , turtle.sf)    #taper branch
        elif turtle.fill[0] == 'nurbs':
            cmds.circle( center = turtle.position, radius = turtle.size, normal = turtle.heading, sections = 1,  name = 'circle' + str(turtle.curveNum) )
            cmds.extrude ( 'circle' + str(turtle.curveNum), 'curve' + str(turtle.curveNum), et = 2, upn = True, scale = turtle.sf, name = 'plane' + str(turtle.curveNum))         
    turtle.curveNum += 1            #increment curve num        
    turtle.position = newPosition   #update position 
Exemplo n.º 6
0
    def draw(self):

            circle1 = cmds.circle( nr=(1, 0, 0), c=(0, 0, 0), sw=self.sweep, r=self.start_radius )
            circle2 = cmds.circle( nr=(1, 0, 0), c=(0, 0, 0), sw=self.sweep, r=self.end_radius )

            l1 = cmds.loft(circle1, circle2)

            # curves
            crv = cmds.curve(p=[(0, self.start_radius, 0), (0, self.end_radius, 0)], degree=1)
            crv2 = cmds.duplicate(crv)
            cmds.rotate(str(self.sweep) + 'deg', 0, 0, r=True)

            extrusions = []

            for e in [circle1, circle2, crv, crv2]:
                extrusions.append(cmds.extrude(e, et=0, d=(1,0,0), l=self.height))
                cmds.delete(e)

            pieces = extrusions + [l1]
            group = cmds.group(*[e[0] for e in pieces])

            cmds.move(0,0,0, group+".scalePivot",group+".rotatePivot", absolute=True)
            cmds.setKeyframe(group, attribute='rotateX', t='0sec', value=self.rotation)

            return (pieces, group)
Exemplo n.º 7
0
def visualizeDropoff(node):
    '''
    '''
    shapeCrv, cirNode = mc.circle(n=node + '_visCircle')

    mc.connectAttr(node + '.dropoff', cirNode + '.radius', f=True)

    pathCrv = node.replace('_mod', '_baseCrv_crv')

    # make loft
    mc.extrude(shapeCrv,
               pathCrv,
               et=2,
               fixedPath=True,
               useComponentPivot=1,
               useProfileNormal=1)
 def extrude(self,caps=True):
     """ extrudes a tube along the NURBS curve """
     self.curve2 = mc.duplicate(self.origCurve, name=self.origCurve+"_copy")[0]
     # select the first CV of the path (curve)
     mc.select("%s.cv[0]"%self.curve2,replace=True)
     # figure out where to put the circle and which way to point it
     circleCenter = mc.xform(q=True,ws=True,t=True)
     circleNormal = mc.pointOnCurve(self.curve2, parameter=0, tangent=True)
     # create a circle to use for extrusion
     circle = mc.circle(radius=self.radius, center=circleCenter, normal=circleNormal)[0]
     # extrude!
     extrusion = mc.extrude( circle, self.curve2, n="nurbsTubeTrace", extrudeType=2, range=True )[0]
     self.traceBits = [extrusion, self.curve2, self.origCurve, circle]
     if caps:
         # select the first isoparm
         mc.select(extrusion+".v[%f]"%cu.findParamAtArcPercent( self.origCurve, 0.0))
         # create planar surface
         begCap = mc.planarSrf(n="cap1")[0]
         # select the last isoparm
         mc.select(extrusion+".v[%f]"%cu.findParamAtArcPercent( self.origCurve, 1.0))
         # create planar surface
         endCap = mc.planarSrf(n="cap2")[0]
         mc.setKeyframe( endCap+".visibility", t=self.timeSpan[1]-1, v=0.0 )
         mc.setKeyframe( endCap+".visibility", t=self.timeSpan[1], v=1.0 )
         # add the caps to the traceBits list
         self.traceBits.extend([begCap,endCap])
     return extrusion
Exemplo n.º 9
0
def dessCourbe(formule, puissance, pDepart, taille, epaisseur, getX):

    pDepX = pDepart[0]
    pDepY = pDepart[1]
    pDepZ = pDepart[2]
    c = cmds.curve(point=[tuple(pDepart)])

    if (formule == "cLog"):
        for x in range(1, taille + 1):
            cmds.curve(c,
                       a=True,
                       p=[(pDepX + math.log(x, puissance * 1.3), pDepY + x,
                           pDepZ)])
        getPosDeb = (pDepX + math.log(getX, puissance * 1.3), pDepY + getX,
                     pDepZ)
        getPosFin = (pDepX + math.log(taille, puissance * 1.3), pDepY + taille,
                     pDepZ)

    if (formule == "cSin"):
        for x in range(1, taille + 1):
            cmds.curve(c,
                       a=True,
                       p=[((pDepX + math.sin(x) / x * puissance * 10) +
                           math.log(x, puissance * 1.3), pDepY + x, pDepZ)])
        getPosDeb = ((pDepX + math.sin(getX) / getX * puissance * 10) +
                     math.log(getX, puissance * 1.3), pDepY + getX, pDepZ)
        getPosFin = ((pDepX + math.sin(taille) / taille * puissance * 10) +
                     math.log(taille, puissance * 1.3), pDepY + taille, pDepZ)

    if (formule == "cDrt"):
        for x in range(1, taille + 1):
            cmds.curve(c, a=True, p=[(pDepX, pDepY + x, pDepZ)])
        getPosDeb = (pDepX, pDepY + getX, pDepZ)
        getPosFin = (pDepX, pDepY + taille, pDepZ)

    cercle = cmds.circle(nr=(0, 1, 0), r=epaisseur)
    #cercle = cmds.polyPlane( w=0.1, h=0.1, sx=1, sy=1 )
    cmds.move(pDepart[0], pDepart[1], pDepart[2])
    cmds.rename("yo" + str(x))
    cmds.extrude("yo" + str(x), c, et=2)
    cmds.delete("yo" + str(x))

    cmds.delete(c)
    return getPosDeb, getPosFin
Exemplo n.º 10
0
def CurveExtruder(profileArray, shapesArray):
    polygonTypeQuery = cmds.optionMenu("OutputTypeQuery", query=True, value=0)
    rotationValue = cmds.intField("RotateAlongValue", query=True, value=True)

    if polygonTypeQuery == "NURBS":
        polygonTypeQuery = 0
    else:
        polygonTypeQuery = 1

    for curva in shapesArray:
        cmds.select(curva)
        cmds.extrude(profileArray[0],
                     curva,
                     extrudeType=2,
                     fixedPath=True,
                     useComponentPivot=1,
                     useProfileNormal=True,
                     constructionHistory=False,
                     polygon=polygonTypeQuery,
                     rotation=rotationValue)
        cmds.delete(constructionHistory=True)
Exemplo n.º 11
0
    def __makeMesh(self,curva):
        scale_0 = self.ui.spin_radius.value()
        scale_1 = self.ui.spin_radius_1.value()
        scale = self.ui.spin_radius.value()
        if (scale_0 >= scale_1):
            tempMaior = scale_0
            tempMenor = scale_1
        else:
            tempMaior = scale_1
            tempMenor = scale_0

        scale_extrude = tempMenor/tempMaior

        position = cmds.pointOnCurve(curva, top=True, pr=0, position=True)
        tangent  = cmds.pointOnCurve(curva, top=True, pr=0, normalizedTangent=True)
        angle    = cmds.angleBetween(er=True, v1=(0.0, 1.0, 0.0), v2=tangent)

        circle = cmds.circle(nr=(0, 1, 0), c=(0, 0, 0), degree=3, sections=16, r = 0.5)
        cmds.scale(tempMaior,
                   tempMaior,
                   tempMaior,
                   circle[0])
        cmds.move(position[0],
                  position[1],
                  position[2],
                  circle[0])
        cmds.rotate(angle[0],
                    angle[1],
                    angle[2],
                    circle[0])


        extrude = cmds.extrude(circle[0],
                                curva,
                                constructionHistory = True,
                                range = True,
                                polygon = 0,
                                extrudeType = 2,
                                useComponentPivot = 0,
                                fixedPath = 0,
                                useProfileNormal = 1,
                                rotation = 0,
                                scale = scale_extrude,
                                reverseSurfaceIfPathReversed = 1)


        poly = cmds.nurbsToPoly(extrude[0], matchNormalDir = True, constructionHistory = False, format = 2, polygonType = 1, uType = 3, uNumber = 1, vType = 3, vNumber = 3)

        cmds.delete(circle, extrude[0])
        print poly
        return poly
Exemplo n.º 12
0
 def perform_multi_function(self, selfU, selfV):
     '''----------------------------------------------------------------------------------
     Common add to list function
     ----------------------------------------------------------------------------------''' 
     # maya.mel.eval( 'nurbsToPolygonsPref -un %d -vn %d;',  %(selfU, ) %(selfV, )
     cmds.nurbsToPolygonsPref(un=selfU, vn=selfV)
     # nurbsToPolygonsPref -un 1 -vn 90
     ConstraintType=cmds.optionMenu(colMenu, q=1, sl=1)
     getObj=cmds.ls(sl=1)
     getParent=getObj[0]
     # cmds.nurbsToPolygonsPref(un=selfU, uv=selfV)
     for each in getObj[1:]: 
         if ConstraintType==1:#orient
             cmds.orientConstraint(getParent, each, mo=1)   
         elif ConstraintType==2:#aim
             cmds.aimConstraint(getParent, each, mo=1)   
         elif ConstraintType==3:#parent
             cmds.parentConstraint(getParent, each, mo=1) 
         elif ConstraintType==4:#point
             cmds.pointConstraint(getParent, each, mo=1)  
         elif ConstraintType==5:#extrude_tube
             cmds.extrude(getParent, each, ch=1, rn=0, po=1, et=2, ucp=1, fpt=1, upn=1, rsp=1, rotation=0, scale=1)
             # nurbsToPoly -mnd 1  -ch 1 -f 2 -pt 1 -pc 81 -chr 0.99 -ft 0.01 -mel 0.001 -d 0.1 -ut 1 -un 24 -vt 1 -vn 1 -uch 1 -ucr 1 -cht 0.2 -es 0 -ntr 0 -mrt 0 -uss 1 "extrudedSurface3"; 
         elif ConstraintType==6:#extrude_path
             cmds.nurbsToPolygonsPref(un=selfU, vn=selfV)
             cmds.extrude(getParent, each, ch=1, rn=0, po=1, et=1, ucp=1, fpt=1, upn=1, rotation=0, scale=1, rsp=1) 
             # cmds.extrude(getParent, each, ch=1, rn=0, po=1, et=0, fpt=1, upn=1, rotation=0, scale=1) 
         elif ConstraintType==7:#xform
             getTranslation, getRotation=self.locationXForm(getParent)
             each.setTranslation(getTranslation)
             each.setTranslation(getRotation)
         # elif ConstraintType==8:#xform                
         #     toolClass.point_const()
         # elif ConstraintType==9:#xform                
         #     toolClass.rivet()                
         else:
             print "nothing performed"         
Exemplo n.º 13
0
    def createSpiralCurve(self, baseCurve, numRounds, radius, profileScale):

        surfaceCV = float(numRounds+2)*(float(numRounds+2)/2.0)
        
        # duplicate curve and get the maxValue
        cmds.select(baseCurve, r=True)
        curveMaxValue = cmds.getAttr(baseCurve+".maxValue")
        cmds.rebuildCurve(ch=0, rpo=1, rt=0, end=1, kr=2, kcp=0, kep=1, kt=0, s=0, d=3)
        # create a circle profile
        profile = cmds.circle(nr=[0, 1, 0], c=[0, 0, 0], r=radius)
        # put it at the start of the baseCurve
        cmds.pathAnimation(profile, fm=True, f=True, fa="y", ua="x", wut=4, wu=[0, 1, 0], c=baseCurve)
        # extrude the profile
        extrudesurface = cmds.extrude(profile[0], baseCurve, et=2, sc=profileScale)
        # curve on surface
        curveonsurface = cmds.curveOnSurface(extrudesurface, append=False, uv=(0, 0))
        
        y = 0.0
        for i in range(int(surfaceCV)):
            y += curveMaxValue/surfaceCV
            x = math.fmod(y*2*surfaceCV/curveMaxValue, 8)
            #print x, y
            cmds.curveOnSurface(curveonsurface, append=True, uv=(x, y))
            
        # duplicate the created curve
        cmds.duplicateCurve(ch = False)
        cmds.rename("duplicated_"+baseCurve)
        spiralCurve = cmds.ls(sl = True)
        cmds.rebuildCurve(ch=0, rpo=1, rt=0, end=1, kr=2, kcp=0, kep=1, kt=0, s=0, d=3)
        # create wire
        #cmds.wire(spiralCurve, dds = [(0, 100)], gw = True, en = 1.0, ce = 0.0, li = 0.0, w = baseCurve)
        #cmds.pickWalk(d = "up")
        cmds.select(spiralCurve, r = True)
        arcCurveGroup = cmds.group(n = "spiralCurveWire"+baseCurve+"___GRP")
        
        #delete unused nodes
        cmds.delete(profile)
        cmds.delete(extrudesurface[0])    
        
        #print "spiral curve created."
    
        return spiralCurve, arcCurveGroup
Exemplo n.º 14
0
    def convert(cls, *args):
        cls.selCrvs = cmds.ls(sl=True)
        polyTubeLs = []

        for crv in cls.selCrvs:
            # create nurbs circle for profile and place to start point of the Path
            profile = cmds.circle(name='%s_profile' % (crv),
                                  normal=(0, 1, 0),
                                  degree=1,
                                  constructionHistory=True)[0]
            zroCvPos = cmds.pointPosition('%s.cv[0]' % (crv), world=True)
            cmds.xform(profile, ws=True, t=zroCvPos)
            # profile scale grp
            scaleGrp = cmds.duplicate(profile,
                                      po=True,
                                      n='%s_scale' % (profile))
            cmds.makeIdentity(scaleGrp, apply=True)
            cmds.parent(profile, scaleGrp)
            # set to profile rotation 45 degree as default
            cmds.setAttr('%s.rotateY' % (profile), 45)

            # rebuild crv
            # cls.rebuildCrv(crv, 8)

            # extrude
            extrRslt = cmds.extrude(profile,
                                    crv,
                                    ch=True,
                                    rn=False,
                                    et=2,
                                    po=1,
                                    ucp=1,
                                    fpt=1,
                                    upn=1,
                                    rsp=1,
                                    n='%s_poly' % (crv))
            polyTubeLs.append(extrRslt[0])

            # hide curve and profile
            cmds.hide(profile)

        cmds.select(polyTubeLs)
Exemplo n.º 15
0
def extrude(name = "defaultName", *args):
    print "starting extrude"
    sel = cmds.ls(sl=True)
    guideCrv = sel[0]

    if len(sel)>1:
        profileCrv = cmds.duplicate(sel[1], name="{}_profile_CRV".format(name))[0]
    else:
        profileCrv = cmds.circle(r=1, normal = (0, 1, 0), name="{}_profile_CRV".format(name), ch=False)[0]

    if len(sel) == 3:
        capRig = sel[2]
    else:
        capRig = ""

    if len(sel) > 3:
        return

    capAxis = "y"
    capUp = "z"
    # upLoc = cmds.spaceLocator(name = "{}_upLoc".format(name))[0]

    ctrl = rig.createControl(type="sphere", name="{}_CTRL".format(name), color="blue")
    ctrlGrp = cmds.group(empty=True, name="{}_path_GRP".format(name))
    capGrp = cmds.group(empty=True, name="{}_cap_GRP".format(name))
    deadGrp = cmds.group(empty=True, name="{}_noInherit_GRP".format(name))
    if capRig:
        cmds.parent(capRig, capGrp)

    cmds.parent(deadGrp, ctrlGrp)	
    cmds.parent(ctrl, ctrlGrp)

    # add attrs to control
    cmds.addAttr(ctrl, ln="__xtraAttrs__", nn="__xtraAttrs__", at="bool", k=True)
    cmds.setAttr("{}.__xtraAttrs__".format(ctrl), l=True)
    cmds.addAttr(ctrl, ln="alongPath", at="float", min=0, max=100, k=True, dv=100.0)	
    cmds.setAttr("{}.alongPath".format(ctrl), 100)
    cmds.addAttr(ctrl, ln="reverseNormals", at="long", min=0, max=1, k=True)
    cmds.addAttr(ctrl, ln="capVisibility", at="long", min=0, max=1, k=True)
    cmds.setAttr("{}.capVisibility".format(ctrl), 1)
    cmds.addAttr(ctrl, ln="capWidth", at="float", k=True, min=.01, max=2.0, dv=1.0)	
    cmds.addAttr(ctrl, ln="capHeight", at="float", k=True, min=.01, max=2.0, dv=1.0)
    cmds.addAttr(ctrl, ln="profileWidth", at="float", k=True, min=.001, max=3, dv=1.0)	

    # driver attrs
    cmds.addAttr(ctrl, ln="textureRepeatMult", at="float", min = 0.01, dv= 1.0, k=True)
    cmds.addAttr(ctrl, ln="prmHolder", at="float", k=True)
    cmds.addAttr(ctrl, ln="rptHolder", at="float", k=True)

    # cmds.addAttr(ctrl, ln="repeatMult", at="message", k=True)
    # cmds.addAttr(ctrl, ln="parameterMult", at ="message", k=True)

    # connect mult to path
    mult = cmds.shadingNode("multiplyDivide", asUtility=True, name="{}_paraMult".format(name))
    cmds.connectAttr("{}.alongPath".format(ctrl), "{}.input1X".format(mult))
    cmds.setAttr("{}.input2X".format(mult), 0.01)
    cmds.connectAttr("{}.profileWidth".format(ctrl), "{}.scaleX".format(profileCrv))
    cmds.connectAttr("{}.profileWidth".format(ctrl), "{}.scaleZ".format(profileCrv))

    # reverse for normals
    reverse = cmds.shadingNode("reverse", asUtility=True, name="{}_reverse".format(name))
    cmds.connectAttr("{}.reverseNormals".format(ctrl), "{}.inputX".format(reverse))
    
    # cap and texture attrs and nodes
    cmds.connectAttr("{}.capVisibility".format(ctrl), "{}.v".format(capGrp))
    repeatMult = cmds.shadingNode("multiplyDivide", asUtility=True, name="{}_RptMult".format(name))
    cmds.connectAttr("{}.outputX".format(mult), "{}.input1X".format(repeatMult))
    cmds.connectAttr("{}.textureRepeatMult".format(ctrl), "{}.input2X".format(repeatMult))
    # cmds.connectAttr("{}.message".format(repeatMult), "{}.repeatMult".format(ctrl))
    # cmds.connectAttr("{}.message".format(mult), "{}.parameterMult".format(ctrl))
    cmds.connectAttr("{}.outputX".format(repeatMult), "{}.rptHolder".format(ctrl))
    cmds.connectAttr("{}.outputX".format(mult), "{}.prmHolder".format(ctrl))
    cmds.setAttr("{}.prmHolder".format(ctrl), l=True)
    cmds.setAttr("{}.rptHolder".format(ctrl), l=True)
    cmds.connectAttr("{}.capWidth".format(ctrl), "{}.scaleX".format(capGrp))
    cmds.connectAttr("{}.capWidth".format(ctrl), "{}.scaleZ".format(capGrp))
    cmds.connectAttr("{}.capHeight".format(ctrl), "{}.scaleY".format(capGrp))

    # position control at start of curve
    startPos = cmds.pointOnCurve(guideCrv, parameter = 0, position = True)
    cmds.xform(ctrlGrp, ws=True, t=startPos)
    # cmds.xform(upLoc, ws=True, t=(startPos[0], startPos[1]+3.0, startPos[2]))

    moPath = cmds.pathAnimation(capGrp, guideCrv, fractionMode=True, follow=True, followAxis=capAxis, upAxis=capUp,
                                worldUpType="scene", startTimeU=0.0, endTimeU=100.0)
    moPathAnimAttr = cmds.listConnections("{}.uValue".format(moPath), d=False, p=True)[0]

    start, end = getSliderRange()
    current = cmds.currentTime(q=True)
    cmds.currentTime(start)

    pPos = cmds.xform(capGrp, q=True, ws=True, rp=True)
    pRot = cmds.xform(capGrp, q=True, ws=True, ro=True)
    cmds.xform(profileCrv, ws=True, t=pPos)
    cmds.xform(profileCrv, ws=True, ro=pRot)

    cmds.currentTime(current)

    # extrude the curve
    extr = cmds.extrude(profileCrv, guideCrv, ch=True, range=True, polygon=True, extrudeType=2, useComponentPivot=True,
                        fixedPath=True, useProfileNormal=True, reverseSurfaceIfPathReversed=True)
    extrGeo, extrNode = extr[0], extr[1]
    
    normal = cmds.polyNormal(extrGeo, normalMode=4, userNormalMode=0, ch=1)[0]
    cmds.connectAttr("{}.outputX".format(reverse), "{}.normalMode".format(normal))
    
    # get extrude connections
    connects = cmds.listConnections(extrNode)
    profNode, pathNode, tessNode = connects[0], connects[1], connects[2]

    # connect up stuff to extrusion
    cmds.connectAttr("{}.outputX".format(mult), "{}.maxValue".format(pathNode))
    cmds.parent(guideCrv, ctrl)
    cmds.setAttr("{}.inheritsTransform".format(deadGrp), 0)
    cmds.parent(extrGeo, deadGrp)
    cmds.parent(profileCrv, deadGrp)	
    cmds.setAttr("{}.v".format(profileCrv), 0)
    cmds.parent(capGrp, deadGrp)	

    # motion path stuff
    cmds.delete(moPathAnimAttr.partition(".")[0])
    cmds.connectAttr("{}.outputX".format(mult), "{}.uValue".format(moPath))

    # reference
    # extrude -ch true -rn true -po 1 -et 2 -ucp 1 -fpt 1 -upn 1 -rotation 0 -scale 1 -rsp 1 "nurbsCircle1" "curve4" ;

    print "ending extrude"
Exemplo n.º 16
0
def _buildSideSplashEmitter(name='',
                            boatName='',
                            splashParticleName=[],
                            boatIntersectCurveShape='',
                            sideAnimatable='',
                            presetName=None):
    """
    New builder for sideSplash nParticle Emitter
    Checks if the NPARTICLE_EMITTLERS_hrc exists or not too

    @param name: The name of the new emitter
    @param splashParticleName: List of the names of nParticleShape nodes to connect to the emitter
    @param boatIntersectCurveShape: The name of the intersection curve to emit from.
    @type name:  String
    @type splashParticleName: List
    @type boatIntersectCurveShape: String
    """
    if not cmds.objExists('nPARTICLE_EMITTERS_hrc'):
        cmds.group(n='nPARTICLE_EMITTERS_hrc', em=True)

    debug(None,
          method='_buildSideSplashEmitter',
          message='name: %s' % name,
          verbose=False)

    # Get base flat surface
    lineCurve = cmds.curve(name='%s_extrudeCurve' % name,
                           degree=1,
                           point=[(-0.01, 0, 0), (0.01, 0, 0)])
    flatSurface = cmds.extrude(lineCurve,
                               boatIntersectCurveShape,
                               name='%s_flatSurface' % name,
                               constructionHistory=True,
                               range=False,
                               polygon=0,
                               useComponentPivot=1,
                               fixedPath=True,
                               useProfileNormal=True,
                               extrudeType=2,
                               reverseSurfaceIfPathReversed=True)[0]
    cmds.rebuildSurface(flatSurface,
                        constructionHistory=True,
                        replaceOriginal=True,
                        rebuildType=0,
                        endKnots=1,
                        keepCorners=False,
                        spansU=1,
                        degreeU=1,
                        spansV=100,
                        degreeV=3)

    # Offset upwards curve from surface
    offsetUp = cmds.offsetCurve('%s.u[0.5]' % flatSurface,
                                name='%s_offsetUp' % name,
                                distance=0,
                                constructionHistory=True,
                                range=0,
                                subdivisionDensity=1)[0]
    cmds.rebuildCurve(offsetUp,
                      constructionHistory=False,
                      replaceOriginal=True,
                      end=1,
                      keepRange=0,
                      keepControlPoints=True,
                      degree=1)
    cmds.setAttr('%s.translateY' % offsetUp, 0.01)

    # Offset from upwards curve with distance and translate down to get the 45 degree angle
    offset_distance = -0.01
    offsetOut = cmds.offsetCurve(offsetUp,
                                 name='%s_offsetOut' % name,
                                 distance=offset_distance,
                                 constructionHistory=True,
                                 range=0,
                                 subdivisionDensity=1)[0]
    cmds.setAttr('%s.translateY' % offsetOut, offset_distance)

    # Finally, loft a non-flipping surface solution (45 degree angle of the boat)
    noFlipSurface = cmds.loft(offsetUp,
                              offsetOut,
                              degree=1,
                              constructionHistory=True,
                              range=0,
                              polygon=0,
                              sectionSpans=1)[0]
    noFlipSurface = cmds.rename(noFlipSurface, '%s_noFlipSurface' % name)

    ## Build the emitter
    emitter = cmds.emitter(noFlipSurface,
                           name='%s_emitter' % name,
                           type='surface')

    # Create closestPointOnSurface for acceleration expression where front more acceleration
    cPoS = cmds.createNode('closestPointOnSurface', name='%s_cPoS' % name)
    cmds.connectAttr('%s.worldSpace' % noFlipSurface, '%s.inputSurface' % cPoS)

    ## Build the emitter group if it doesn't already exist
    emitterGroup = '%s_hrc' % name
    if not cmds.objExists(emitterGroup):
        cmds.group(lineCurve,
                   flatSurface,
                   offsetUp,
                   offsetOut,
                   noFlipSurface,
                   emitter[0],
                   n=emitterGroup)
    debug(None,
          method='_buildSideSplashEmitter',
          message='emitterName: %s' % emitter[1],
          verbose=False)

    ## Check if a custom preset has been assigned via the func flags for the emitter, if not use the default preset...
    if presetName:
        pathToPreset = '%s/%s' % (CONST.EMITTERBASEPRESETPATH, presetName)
        debug(None,
              method='_buildSideSplashEmitter',
              message='pathToPreset: %s' % pathToPreset,
              verbose=False)
        mel.eval('applyPresetToNode "%s" "" "" "%s" 1;' %
                 (emitter[1], pathToPreset))

    ## Now parent it
    try:
        cmds.parent(emitterGroup, 'nPARTICLE_EMITTERS_hrc')
    except:
        pass

    ## Connect the emitter to the particles
    debug(None,
          method='_buildSideSplashEmitter',
          message='Connected %s: %s' % (splashParticleName, emitter[1]),
          verbose=False)
    for each in splashParticleName:
        _connect_NParticleShape_to_NParticleEmitter(particleShapeNode=each,
                                                    emitter=emitter[1])

    ## Now do the expression for the side emitter
    if 'IntersectCurveRight' in emitter[1]:
        direction = 'R'
    else:
        direction = 'L'

    expStringList = [
        'float $minSpeed = %s.minSpeed;\n' % sideAnimatable,
        'float $maxSpeed = %s.maxSpeed;\n' % sideAnimatable,
        'float $speed = %s:world_ctrl.speed;\n' % boatName,
        'float $curve = smoothstep($minSpeed, $maxSpeed, $speed);\n',
        'float $rateMuliplier = %s.rateMultiplier%s;\n' %
        (sideAnimatable, direction),
        'float $splashMaxSpeed = %s.splashMaxSpeed%s;\n' %
        (sideAnimatable, direction),
        '\n',
        'if (%s.useSpeed == 1)\n' % sideAnimatable,
        '{\n\t',
        '%s.rate = $rateMuliplier * $curve;\n' % emitter[1],
        '\n\t\t',
        'float $emitterSpeed = $splashMaxSpeed * $curve;\n\t\t',
        'if ($emitterSpeed == 0)\n\t\t',
        '{\n\t\t\t',
        '$emitterSpeed = 0.1;\n\t\t',
        '}\n\t\t',
        '%s.speed = $emitterSpeed;\n' % emitter[1],
        '}\n',
        'else\n',
        '{\n\t',
        '%s.rate = $rateMuliplier;\n\t' % emitter[1],
        '%s.speed = $splashMaxSpeed;\n' % emitter[1],
        '}\n',
    ]
    ## Check if the expression already exists in the scene, if so delete it
    utils.checkExpressionExists('%s_sideSplashEmitter' % boatName)

    ## Build new expression
    cmds.expression(emitter[1],
                    n='%s_sideSplashEmitter' % emitter[1],
                    string=utils.processExpressionString(expStringList))

    ## Connect some attributes
    if not cmds.isConnected('%s.normalSpeed%s' % (sideAnimatable, direction),
                            '%s.normalSpeed' % emitter[1]):
        cmds.connectAttr('%s.normalSpeed%s' % (sideAnimatable, direction),
                         '%s.normalSpeed' % emitter[1])
    if not cmds.isConnected('%s.randomSpeed%s' % (sideAnimatable, direction),
                            '%s.speedRandom' % emitter[1]):
        cmds.connectAttr('%s.randomSpeed%s' % (sideAnimatable, direction),
                         '%s.speedRandom' % emitter[1])

    return cPoS
Exemplo n.º 17
0
    def drawBranch(self, iteration, cX, cY, cZ, nrX, nrY, nrZ, radius, length):
        if (iteration < self.branches):
            iteration = iteration + 1

            #Draw circle and extrude based on parameters
            shape = mc.circle(nr=(nrX, nrY, nrZ), c=(cX, cY, cZ), r=radius)
            poly = mc.extrude(shape, et=0, d=(nrX, nrY, nrZ), l=length)

            mc.group(poly, parent=self.grp)

            #Delete the base circle and keep the cylinder
            mc.delete(shape)

            #direction vector to grow
            vector = MVector(nrX, nrY, nrZ)
            vector.normalize()

            cX = cX + (length * vector.x)
            cY = cY + (length * vector.y)
            cZ = cZ + (length * vector.z)

            randX = r.randint(0, 1) * 2 - 1
            randY = r.randint(0, 1) * 2 - 1
            randZ = r.randint(0, 1) * 2 - 1

            #Random direction vector
            #For X, Y, Z, ( -1 or 1 )*angle + (randint from -angleVariance to +angleVariance)

            nrX = nrX + ((self.angle * randX) + random.randint(
                0, self.angleVariance * 2) - self.angleVariance) / 100.0
            nrY = nrY + ((self.angle * randY) + random.randint(
                0, self.angleVariance * 2) - self.angleVariance) / 100.0
            nrZ = nrZ + ((self.angle * randZ) + random.randint(
                0, self.angleVariance * 2) - self.angleVariance) / 100.0

            #Length and Radius based on factor + (randint from -variance to +variance)

            length = length * (
                self.lengthFactor +
                (random.randint(0, self.lengthVariance * 2 * 100) / 100.0) -
                self.lengthVariance)
            radius = radius * (
                self.radiusFactor +
                (random.randint(0, self.radiusVariance * 2 * 100) / 100.0) -
                self.radiusVariance)

            #Draw first branch
            self.drawBranch(iteration, cX, cY, cZ, nrX, nrY, nrZ, radius,
                            length)

            #Use opposite base angle from previous branch

            nrX = nrX + ((self.angle * randX * -1) + random.randint(
                0, self.angleVariance * 2) - self.angleVariance) / 100.0
            nrY = nrY + ((self.angle * randY * -1) + random.randint(
                0, self.angleVariance * 2) - self.angleVariance) / 100.0
            nrZ = nrZ + ((self.angle * randZ * -1) + random.randint(
                0, self.angleVariance * 2) - self.angleVariance) / 100.0

            length = length * (
                self.lengthFactor +
                (random.randint(0, self.lengthVariance * 2 * 100) / 100.0) -
                self.lengthVariance)
            radius = radius * (
                self.radiusFactor +
                (random.randint(0, self.radiusVariance * 2 * 100) / 100.0) -
                self.radiusVariance)

            #Draw second branch
            self.drawBranch(iteration, cX, cY, cZ, nrX, nrY, nrZ, radius,
                            length)
Exemplo n.º 18
0
    def build(self):
        self.addPinParent()
        self.addAttrLimb(ln='noStretch',
                         at='float',
                         min=0,
                         max=1,
                         dv=0,
                         k=True,
                         s=1)
        self.addAttrLimb(ln='slideAlong',
                         at='float',
                         min=-1,
                         max=1,
                         dv=0,
                         k=True,
                         s=1)
        jointList = mpJoint.getJointList(self.startJoint, self.endJoint)
        if len(jointList) < 2:
            raise RuntimeError(
                'NurbsStrip requires at least 2 joints in chain. Got %s' %
                len(jointList))

        #Create NURBS strip by making curves along joints, and a cross section crv, then extruding
        crv = mpNurbs.curveFromNodes(jointList)
        crossCurve = cmds.curve(d=1,
                                p=[(0, 0, -0.5 * self.stripWidth),
                                   (0, 0, 0.5 * self.stripWidth)],
                                k=(0, 1))
        cmds.select([crossCurve, crv], r=1)
        surf = cmds.extrude(ch=False,
                            po=0,
                            et=2,
                            ucp=1,
                            fpt=1,
                            upn=1,
                            rotation=0,
                            scale=1,
                            rsp=1)[0]
        cmds.delete([crv, crossCurve])
        self.name.desc = 'driverSurf'
        surf = cmds.rename(surf, self.name.get())
        cmds.parent(surf, self.noXform)

        #Rebuild strip to proper number of spans
        cmds.rebuildSurface(surf,
                            ch=0,
                            rpo=1,
                            rt=0,
                            end=1,
                            kr=0,
                            kcp=0,
                            kc=1,
                            sv=self.numSpans,
                            su=0,
                            du=1,
                            tol=0.01,
                            fr=0,
                            dir=2)

        #make live curve on surface down the middle
        #this is used later for noStretch
        curvMaker = cmds.createNode('curveFromSurfaceIso', n=surf + "CurveIso")
        cmds.setAttr(curvMaker + ".isoparmValue", 0.5)
        cmds.setAttr(curvMaker + ".isoparmDirection", 1)
        cmds.connectAttr(surf + ".worldSpace[0]", curvMaker + ".inputSurface")
        offsetCrvShp = cmds.createNode("nurbsCurve",
                                       n=crv + "_driverSurfCrvShape")
        offsetCrv = cmds.listRelatives(p=1)[0]
        offsetCrv = cmds.rename(offsetCrv, crv + "_driverSurfCrv")
        cmds.connectAttr(curvMaker + ".outputCurve", offsetCrvShp + ".create")
        cmds.parent(offsetCrv, self.noXform)

        #Measure curve length and divide by start length
        #to get a normalized value that is useful later to control stretch
        crvInfo = cmds.createNode('curveInfo', n=offsetCrv + "Info")
        cmds.connectAttr(offsetCrv + ".worldSpace[0]", crvInfo + ".ic")
        arcLength = cmds.getAttr(crvInfo + ".al")
        stretchAmountNode = cmds.createNode('multiplyDivide',
                                            n=offsetCrv + "Stretch")
        cmds.setAttr(stretchAmountNode + ".op", 2)  #divide
        cmds.setAttr(stretchAmountNode + ".input1X", arcLength)
        cmds.connectAttr(crvInfo + ".al", stretchAmountNode + ".input2X")

        #Stretch Blender blends start length with current length
        #and pipes it back into stretchAmoundNode's startLength, so user can turn
        #stretch behavior on or off
        stretchBlender = cmds.createNode('blendColors',
                                         n=offsetCrv + "StretchBlender")
        cmds.setAttr(stretchBlender + ".c1r", arcLength)
        cmds.connectAttr(crvInfo + ".al", stretchBlender + ".c2r")
        cmds.connectAttr(stretchBlender + ".opr",
                         stretchAmountNode + ".input1X")
        cmds.connectAttr(self.limbNode + ".noStretch",
                         stretchBlender + ".blender")

        #attach joints to surface
        closestPoint = cmds.createNode('closestPointOnSurface', n='tempClose')
        cmds.connectAttr(surf + ".worldSpace[0]",
                         closestPoint + ".inputSurface")
        for idx, jnt in enumerate(jointList):
            self.name.desc = 'jnt%02dOffset' % idx
            locator = cmds.spaceLocator(n=self.name.get())[0]
            cmds.setAttr(locator + '.localScale', self.stripWidth,
                         self.stripWidth, self.stripWidth)
            cmds.parent(locator, self.noXform)
            #Use closest point to to find jnt's percent along the curve
            cmds.setAttr(closestPoint + '.ip',
                         *cmds.xform(jnt, q=True, t=True, ws=True))
            percentage = cmds.getAttr(closestPoint + '.r.v')
            #attach to surface
            posNode, aimCnss, moPath, slider = self.attachObjToSurf(
                locator, surf, offsetCrv, stretchAmountNode, percentage)

            cmds.connectAttr(self.limbNode + ".slideAlong", slider + ".i2")
            cmds.parentConstraint(locator, jnt, mo=True)
        cmds.delete(closestPoint)

        #add controls.These drive new joints which skinCluster the NURBS strips
        stripJoints = []
        stripJointParent = cmds.createNode('transform',
                                           n=crv + "_stripJoints",
                                           p=self.noXform)
        ctrlParent = cmds.createNode('transform',
                                     n=crv + "_Ctrls",
                                     p=self.pinParent)
        cmds.xform(ctrlParent,
                   ws=True,
                   m=[1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])

        prevCtrl = None
        for i in range(self.numCtrls):
            ctrlXform = mpMath.Transform(jointList[0])
            zero, ctrl = self.addCtrl('Ctrl%02d' % i,
                                      type='FK',
                                      shape='box',
                                      parent=ctrlParent,
                                      xform=ctrlXform)
            ctrlXform.scale(0.8, 0.8, 0.8)
            tZero, tCtrl = self.addCtrl('TweakCtrl%02d' % i,
                                        type='FK',
                                        shape='cross',
                                        parent=ctrl,
                                        xform=ctrlXform)

            #Make the new joint for the control to drive
            cmds.select(clear=True)
            self.name.desc = 'StripJnt%02d' % i
            jnt = cmds.joint(p=(0, 0, 0), n=self.name.get())
            cmds.parentConstraint(tCtrl, jnt, mo=False)

            #briefly attach ctrls to strip to align them
            percentage = float(i) / (self.numCtrls - 1.0)
            if i > 0 and i < self.numCtrls - 1:
                percentage = self.uMin + (percentage * (self.uMax - self.uMin))
            cmds.delete(
                self.attachObjToSurf(zero, surf, offsetCrv, stretchAmountNode,
                                     percentage))
            cmds.parent(jnt, stripJointParent)
            stripJoints.append(jnt)

            if prevCtrl:
                cmds.parent(zero, prevCtrl)
                mpRig.addPickParent(ctrl, prevCtrl)
            prevCtrl = ctrl

        #skin strip to controls
        #Can get some different behavior by chaning the strip's weights
        #or perhaps using dual quat. mode on the skinCluster
        skinObjs = stripJoints + [surf]
        cmds.skinCluster(
            skinObjs,
            bindMethod=0,  #closest Point
            sm=0,  #standard bind method
            ih=True,  #ignore hierarchy
        )
Exemplo n.º 19
0
        cmds.addAttr(ctrl, ln='param', min=0, max=1, dv=param, k=True)
        cmds.addAttr(ctrl, ln='bulge', min=-1, dv=0, k=True)
        cmds.connectAttr(ctrl + '.param', locs[i] + '.param[' + str(ind) + ']', f=True)
        cmds.connectAttr(ctrl + '.bulge', wire + '.wireLocatorEnvelope[' + str(ind) + ']', f=True)


def buildTube(crv, profile = None, addCage = False, prefix = None):
    """
    """
# Nurbs Tube
cmds.extrude(
    ch=True,
    rn=False,
    po=0,
    et=2,
    ucp=1,
    fpt=1,
    upn=1,
    rotation=0,
    scale=1,
    rsp=1
)

# Polygon Tube
cmds.extrude(
    ch=True,
    rn=False,
    po=1,
    et=2,
    ucp=1,
    fpt=1,
    upn=1,
Exemplo n.º 20
0
def _buildSideSplashEmitter(name = '', boatName = '', splashParticleName = [], boatIntersectCurveShape = '', sideAnimatable = '', presetName = None):
    """
    New builder for sideSplash nParticle Emitter
    Checks if the NPARTICLE_EMITTLERS_hrc exists or not too

    @param name: The name of the new emitter
    @param splashParticleName: List of the names of nParticleShape nodes to connect to the emitter
    @param boatIntersectCurveShape: The name of the intersection curve to emit from.
    @type name:  String
    @type splashParticleName: List
    @type boatIntersectCurveShape: String
    """
    if not cmds.objExists('nPARTICLE_EMITTERS_hrc'):
        cmds.group(n = 'nPARTICLE_EMITTERS_hrc', em = True)

    debug(None, method = '_buildSideSplashEmitter', message = 'name: %s' % name, verbose = False)

    # Get base flat surface
    lineCurve       = cmds.curve( name = '%s_extrudeCurve' % name, degree = 1, point = [(-0.01, 0, 0), (0.01, 0, 0)] )
    flatSurface  = cmds.extrude(lineCurve, boatIntersectCurveShape, name = '%s_flatSurface' % name, constructionHistory = True, range = False, polygon = 0, useComponentPivot = 1, fixedPath = True, useProfileNormal = True, extrudeType = 2, reverseSurfaceIfPathReversed = True)[0]
    cmds.rebuildSurface(flatSurface, constructionHistory = True, replaceOriginal = True, rebuildType = 0, endKnots = 1, keepCorners = False, spansU = 1, degreeU = 1, spansV = 100, degreeV = 3)

    # Offset upwards curve from surface
    offsetUp = cmds.offsetCurve('%s.u[0.5]' % flatSurface, name = '%s_offsetUp' % name, distance = 0, constructionHistory = True, range = 0, subdivisionDensity = 1)[0]
    cmds.rebuildCurve(offsetUp, constructionHistory = False, replaceOriginal = True, end = 1, keepRange = 0, keepControlPoints = True, degree = 1)
    cmds.setAttr('%s.translateY' % offsetUp, 0.01)

    # Offset from upwards curve with distance and translate down to get the 45 degree angle
    offset_distance = -0.01
    offsetOut = cmds.offsetCurve(offsetUp, name = '%s_offsetOut' % name, distance = offset_distance, constructionHistory = True, range = 0, subdivisionDensity = 1)[0]
    cmds.setAttr('%s.translateY' % offsetOut, offset_distance)

    # Finally, loft a non-flipping surface solution (45 degree angle of the boat)
    noFlipSurface = cmds.loft(offsetUp, offsetOut, degree = 1, constructionHistory = True, range = 0, polygon = 0, sectionSpans = 1)[0]
    noFlipSurface = cmds.rename(noFlipSurface, '%s_noFlipSurface' % name)

    ## Build the emitter
    emitter = cmds.emitter(noFlipSurface, name = '%s_emitter' % name, type = 'surface')

    # Create closestPointOnSurface for acceleration expression where front more acceleration
    cPoS = cmds.createNode('closestPointOnSurface', name = '%s_cPoS' % name)
    cmds.connectAttr('%s.worldSpace' % noFlipSurface, '%s.inputSurface' % cPoS)

    ## Build the emitter group if it doesn't already exist
    emitterGroup = '%s_hrc' % name
    if not cmds.objExists(emitterGroup):
        cmds.group(lineCurve, flatSurface, offsetUp, offsetOut, noFlipSurface, emitter[0], n = emitterGroup)
    debug(None, method = '_buildSideSplashEmitter', message = 'emitterName: %s' % emitter[1], verbose = False)

    ## Check if a custom preset has been assigned via the func flags for the emitter, if not use the default preset...
    if presetName:
        pathToPreset = '%s/%s' %(CONST.EMITTERBASEPRESETPATH, presetName)
        debug(None, method = '_buildSideSplashEmitter', message = 'pathToPreset: %s' % pathToPreset, verbose = False)
        mel.eval( 'applyPresetToNode "%s" "" "" "%s" 1;' %(emitter[1], pathToPreset) )

    ## Now parent it
    try:    cmds.parent(emitterGroup, 'nPARTICLE_EMITTERS_hrc')
    except: pass

    ## Connect the emitter to the particles
    debug(None, method = '_buildSideSplashEmitter', message = 'Connected %s: %s' % (splashParticleName, emitter[1]), verbose = False)
    for each in splashParticleName:
        _connect_NParticleShape_to_NParticleEmitter(particleShapeNode = each, emitter = emitter[1])

    ## Now do the expression for the side emitter
    if 'IntersectCurveRight' in emitter[1]:
        direction = 'R'
    else:
        direction = 'L'

    expStringList = [
                    'float $minSpeed = %s.minSpeed;\n' % sideAnimatable,
                    'float $maxSpeed = %s.maxSpeed;\n' % sideAnimatable,
                    'float $speed = %s:world_ctrl.speed;\n' % boatName,
                    'float $curve = smoothstep($minSpeed, $maxSpeed, $speed);\n',
                    'float $rateMuliplier = %s.rateMultiplier%s;\n' %(sideAnimatable, direction),
                    'float $splashMaxSpeed = %s.splashMaxSpeed%s;\n' %(sideAnimatable, direction),
                    '\n',
                    'if (%s.useSpeed == 1)\n' % sideAnimatable,
                    '{\n\t',
                        '%s.rate = $rateMuliplier * $curve;\n' % emitter[1],
                        '\n\t\t',
                        'float $emitterSpeed = $splashMaxSpeed * $curve;\n\t\t',
                        'if ($emitterSpeed == 0)\n\t\t',
                        '{\n\t\t\t',
                            '$emitterSpeed = 0.1;\n\t\t',
                        '}\n\t\t',
                        '%s.speed = $emitterSpeed;\n' % emitter[1],
                    '}\n',
                    'else\n',
                    '{\n\t',
                        '%s.rate = $rateMuliplier;\n\t' % emitter[1],
                        '%s.speed = $splashMaxSpeed;\n' % emitter[1],
                    '}\n',
                    ]
    ## Check if the expression already exists in the scene, if so delete it
    utils.checkExpressionExists('%s_sideSplashEmitter' % boatName)

    ## Build new expression
    cmds.expression(emitter[1], n = '%s_sideSplashEmitter' % emitter[1], string = utils.processExpressionString(expStringList))

    ## Connect some attributes
    if not cmds.isConnected('%s.normalSpeed%s' %(sideAnimatable, direction), '%s.normalSpeed' % emitter[1]):
        cmds.connectAttr('%s.normalSpeed%s' %(sideAnimatable, direction), '%s.normalSpeed' % emitter[1])
    if not cmds.isConnected('%s.randomSpeed%s' %(sideAnimatable, direction), '%s.speedRandom' % emitter[1]):
        cmds.connectAttr('%s.randomSpeed%s' %(sideAnimatable, direction), '%s.speedRandom' % emitter[1])

    return cPoS
Exemplo n.º 21
0
    def execute(self):

        sx = self.sx
        sy = self.sy
        sdv = self.sdv
        sdu = self.sdu
        tap = self.tap
        degs = self.degs
        subCurve = self.subCurve
        clean = self.clean
        do_uvs = self.do_uvs
        rbc = self.rbc
        cTol = self.cTol
        cSubd = self.cSubd

        if cmds.checkBox(self.aUACCB, q=True, v=True):
            useAltShape = True
        else:
            useAltShape = False

        multSel = cmds.ls(sl=True, fl=True, ap=True)
        if cmds.objectType(multSel[0]) == 'mesh':
            thisIsAMesh = True
        else:
            thisIsAMesh = False
        # Select curve type to extrude along - convert and store
        for x in multSel:
            print x
            if thisIsAMesh != True:
                cmds.select(x)
            else:
                cmds.select(multSel)

            objSel = cmds.ls(sl=True, fl=True, ap=True)
            if self.ko == 1:
                dupObj = cmds.duplicate(objSel)
                objSel = dupObj
            if len(objSel) > 1:
                print objSel
                if degs == 0:
                    curveDg = cmds.promptDialog(
                        t='Enter Degrees:',
                        m='Enter Degrees - ie. 1 for linear, 3 for curved')
                    objSel = cmds.polyToCurve(f=2,
                                              dg=int(
                                                  cmds.promptDialog(q=True,
                                                                    tx=True)))
                else:
                    objSel = cmds.polyToCurve(f=2,
                                              dg=int(degs),
                                              n='%s_curve' %
                                              objSel[0].split('.')[0])
            else:
                objType = cmds.listRelatives(objSel[0], f=True)
                if cmds.objectType(
                        objType[0]) != 'nurbsCurve' and cmds.objectType(
                            objType[0]) != 'bezierCurve':
                    cmds.error(
                        'Select the nurbs curve first, then the object to align'
                    )
                if cmds.objectType(objType[0]) == 'bezierCurve':
                    mm.eval("bezierCurveToNurbs;")
            # Create a nurbs curve for the extrusion
            if useAltShape:
                nurbsCir = self.objToUse
            else:
                nurbsCir = cmds.circle(n='extrudeCircle',
                                       d=3,
                                       r=1,
                                       nr=(0, 0, 1),
                                       sw=360,
                                       ch=True,
                                       s=8)
            objCV = cmds.ls('%s.ep[*]' % objSel[0], fl=True)

            noOfCV = len(objCV)
            firstCV = 0
            lastCV = noOfCV - 1
            cvNumberToUse = firstCV

            # Rebuild the curve to help with uniformity
            if self.rev == 1:
                cmds.reverseCurve(objSel[0], ch=0, rpo=1)

            if rbc == 1:
                try:
                    cmds.rebuildCurve(objSel[0],
                                      ch=0,
                                      rpo=1,
                                      rt=4,
                                      end=1,
                                      kr=0,
                                      kcp=0,
                                      kep=1,
                                      kt=0,
                                      s=cSubd,
                                      d=3,
                                      tol=cTol)
                    cmds.rebuildCurve(objSel[0],
                                      ch=0,
                                      rpo=1,
                                      rt=0,
                                      end=1,
                                      kr=0,
                                      kcp=0,
                                      kep=1,
                                      kt=0,
                                      s=cSubd,
                                      d=3,
                                      tol=cTol)
                except:
                    cmds.warning(
                        'Tolerance for rebuild likely to low, try a higher value or turn Rebuild Curve off'
                    )

            if do_uvs == 1:
                objShape = cmds.listRelatives(objSel[0], c=True, type='shape')
                mInfo = cmds.shadingNode('curveInfo',
                                         n='cMeasure',
                                         asUtility=True)
                cmds.connectAttr('%s.local' % objShape[0],
                                 '%s.inputCurve' % mInfo)
                curveLength = cmds.getAttr('%s.arcLength' % mInfo)
                cmds.delete(mInfo)

                self.uvRatio = float(
                    (((sx * sy) * 2.0) * math.pi) / curveLength)
                print "uvRatio:  " + str(self.uvRatio)

            # Create a tangent contraint to position nurbs circle to the first cv
            cvPos = cmds.xform('%s.ep[%d]' % (objSel[0], cvNumberToUse),
                               query=True,
                               ws=True,
                               t=True)
            cmds.xform(nurbsCir[0], ws=True, t=(cvPos[0], cvPos[1], cvPos[2]))
            fastCon = cmds.tangentConstraint(objSel[0],
                                             nurbsCir[0],
                                             aim=(0, 0, 1))
            cmds.delete(fastCon[0])

            # Extrude along curve and set attributes
            pipeExt = cmds.extrude(nurbsCir[0],
                                   objSel[0],
                                   n='%s_pipe' % objSel[0],
                                   ch=True,
                                   rn=subCurve,
                                   po=1,
                                   et=2,
                                   ucp=1,
                                   fpt=1,
                                   upn=1,
                                   rotation=0,
                                   scale=1,
                                   rsp=1)
            pipeTes = cmds.listConnections(pipeExt[1], type='nurbsTessellate')
            if subCurve != 0:
                pipeSubCurve = cmds.listConnections(pipeExt[1],
                                                    type='subCurve')

            cmds.setAttr('%s.format' % pipeTes[0], 2)
            cmds.setAttr('%s.polygonType' % pipeTes[0], 1)
            cmds.setAttr('%s.uType' % pipeTes[0], 2)
            cmds.setAttr('%s.vType' % pipeTes[0], 2)
            cmds.setAttr('%s.vNumber' % pipeTes[0], sdv)
            cmds.setAttr('%s.uNumber' % pipeTes[0], sdu)

            # Add attributes
            if clean == 0:
                cmds.addAttr(pipeExt[0], ln='________', k=True)
                cmds.setAttr('%s.________' % pipeExt[0], l=True)
                cmds.addAttr(pipeExt[0], ln='Ext_ScaleX', k=True, dv=sx)
                cmds.addAttr(pipeExt[0], ln='Ext_ScaleY', k=True, dv=sy)
                cmds.connectAttr('%s.Ext_ScaleX' % pipeExt[0],
                                 '%s.scaleX' % nurbsCir[0])
                cmds.connectAttr('%s.Ext_ScaleY' % pipeExt[0],
                                 '%s.scaleY' % nurbsCir[0])
                cmds.addAttr(pipeExt[0],
                             ln='Ext_DivisionV',
                             at='short',
                             k=True,
                             dv=sdv)
                cmds.connectAttr('%s.Ext_DivisionV' % pipeExt[0],
                                 '%s.vNumber' % pipeTes[0])
                cmds.addAttr(pipeExt[0],
                             ln='Ext_DivisionU',
                             at='short',
                             k=True,
                             dv=sdu)
                cmds.connectAttr('%s.Ext_DivisionU' % pipeExt[0],
                                 '%s.uNumber' % pipeTes[0])
                if subCurve != 0:
                    cmds.addAttr(pipeExt[0],
                                 ln='Ext_Length',
                                 k=True,
                                 dv=1,
                                 max=1,
                                 min=0)
                    cmds.connectAttr('%s.Ext_Length' % pipeExt[0],
                                     '%s.maxValue' % pipeSubCurve[1])
                cmds.addAttr(pipeExt[0], ln='Ext_Taper', k=True, dv=tap, min=0)
                cmds.connectAttr('%s.Ext_Taper' % pipeExt[0],
                                 '%s.scale' % pipeExt[1])
                cmds.addAttr(pipeExt[0], ln='Ext_Twist', k=True, dv=1)
                cmds.connectAttr('%s.Ext_Twist' % pipeExt[0],
                                 '%s.rotation' % pipeExt[1])
                cmds.addAttr(pipeExt[0], ln='Ext_ComponentPivot', k=True, dv=1)
                cmds.connectAttr('%s.Ext_ComponentPivot' % pipeExt[0],
                                 '%s.useComponentPivot' % pipeExt[1])

            curveGrpNode = cmds.createNode('transform', n='pipeCurves')
            cmds.parent(nurbsCir, curveGrpNode)
            cmds.parent(objSel, curveGrpNode)

            cmds.setAttr('%s.inheritsTransform' % curveGrpNode, 0)
            cmds.setAttr('%s.visibility' % curveGrpNode, 1)
            cmds.parent(curveGrpNode, pipeExt[0])
            cmds.select(pipeExt[0])
            if do_uvs == 1:
                cmds.polyLayoutUV(ps=0.2)
                cmds.polyEditUV(sv=1, su=self.uvRatio)
                cmds.polyEditUV(sv=0.95, su=0.95)
                cmds.select(pipeExt[0])
                CentreUVs()
                if clean == 1:
                    cmds.delete(ch=True)
                    cmds.delete(curveGrpNode)
                    cmds.select(pipeExt[0])
            if thisIsAMesh == True:
                print 'hello'
                break
Exemplo n.º 22
0
    def rigFromCurve(self,crv,numSpans=8,numJoints=10,numCtrls=5,stripWidth = 1.0,ctrlWidth=2.0,geo=None,uMin=0.0,uMax=1.0):
        '''make a cable rig from the given curve
            numSpans = number of spans in Nurbs strip
            numJoints = number of joints riding on nurbs strip
            numCtrls = number of controls to make  
            stripWidth = width of nurbs strip (can make it easier to paint weights if wider) 
            ctrlWidth = size of ctrls 
        '''
    
        shapes = cmds.listRelatives(crv,s=1)
        crvShape = shapes[0]
        #Make rig top nulls to parent stuff under
        topNull = cmds.createNode('transform',n=crv + "_Rig")
        hiddenStuff = cmds.createNode('transform',n=crv + "_NOTOUCH",p=topNull)
        cmds.setAttr(hiddenStuff + ".inheritsTransform", 0)
        cmds.setAttr(hiddenStuff + ".visibility", 0)
        cmds.addAttr(topNull, ln="stretchAmount",dv=1.0,min=0,max=1)
        cmds.addAttr(topNull, ln='slideAmount',dv=0.0)

        #make nurbs strip using extrude
        crossCurve = cmds.curve(d=1,p=[(0,0,-0.5 * stripWidth),(0,0,0.5 * stripWidth)],k=(0,1))
        cmds.select([crossCurve,crv],r=1)
        surf = cmds.extrude(ch=False,po=0,et=2,ucp=1,fpt=1,upn=1,rotation=0,scale=1,rsp=1)[0]
        cmds.delete(crossCurve)
        surf = cmds.rename(surf, crv + "_driverSurf")
        cmds.parent(surf,hiddenStuff)

        #Rebuild strip to proper number of spans
        cmds.rebuildSurface(surf,ch=0,rpo=1,rt=0,end=1,kr=0,kcp=0,kc=1,sv=numSpans,su=0,du=1,tol=0.01,fr=0,dir=2)

        #make live curve on surface down the middle 
        #this is used later for noStretch
        curvMaker = cmds.createNode('curveFromSurfaceIso', n = surf+"CurveIso")
        cmds.setAttr(curvMaker + ".isoparmValue", 0.5)
        cmds.setAttr(curvMaker + ".isoparmDirection", 1)
        cmds.connectAttr(surf + ".worldSpace[0]", curvMaker + ".inputSurface")

        offsetCrvShp = cmds.createNode("nurbsCurve", n=crv + "_driverSurfCrvShape")
        offsetCrv = cmds.listRelatives(p=1)[0]
        offsetCrv = cmds.rename(offsetCrv,crv + "_driverSurfCrv")
        cmds.connectAttr(curvMaker + ".outputCurve", offsetCrvShp + ".create")
        cmds.parent(offsetCrv, hiddenStuff)
    
        #Measure curve length and divide by start length. 
        #This turns curve length into a normalized value that is
        #useful for multiplying by UV values later to control stretch
        crvInfo = cmds.createNode('curveInfo', n=offsetCrv + "Info")
        cmds.connectAttr(offsetCrv + ".worldSpace[0]", crvInfo + ".ic")
        arcLength = cmds.getAttr(crvInfo + ".al")
        stretchAmountNode = cmds.createNode('multiplyDivide', n=offsetCrv + "Stretch")
        cmds.setAttr(stretchAmountNode + ".op" , 2) #divide
        cmds.setAttr(stretchAmountNode + ".input1X", arcLength)
        cmds.connectAttr( crvInfo + ".al",stretchAmountNode + ".input2X")
    
        #Stretch Blender blends start length with current length
        #and pipes it back into stretchAmoundNode's startLength, to "trick" it into
        #thinking there is no stretch..
        #That way, when user turns on this "noStretch" attr, the startLength will
        #be made to equal current length, and stretchAmountNode will always be 1.
        #so the chain will not stretch. 
        stretchBlender = cmds.createNode('blendColors', n =offsetCrv + "StretchBlender")
        cmds.setAttr(stretchBlender + ".c1r", arcLength)
        cmds.connectAttr(crvInfo + ".al", stretchBlender + ".c2r")
        cmds.connectAttr(stretchBlender + ".opr", stretchAmountNode + ".input1X")
        cmds.connectAttr(topNull + ".stretchAmount",stretchBlender + ".blender")
    
        #make skin joints and attach to surface
        skinJoints = []
        skinJointParent = cmds.createNode('transform',n=crv + "_skinJoints",p=topNull)
        for i in range(numJoints):
            cmds.select(clear=True)
            jnt = cmds.joint(p=(0,0,0),n=crv + "_driverJoint%02d"%i) 
            locator = cmds.spaceLocator(n=crv + "driverLoc%02d"%i)[0]
            cmds.setAttr(locator + ".localScale",stripWidth,stripWidth,stripWidth)
            cmds.parent(locator,hiddenStuff)
            percentage = float(i)/(numJoints-1.0)
            print "percentage:", percentage
            print i
            if i > 1 and i < numJoints-2:
                percentage = uMin + (percentage * (uMax-uMin))
                print "\tinterp percent", percentage
            posNode,aimCnss,moPath,slider = self.attachObjToSurf(locator,surf,offsetCrv,stretchAmountNode,percentage)
            cmds.connectAttr(topNull + ".slideAmount", slider + ".i2")
            cmds.parentConstraint(locator,jnt,mo=False)
            if len(skinJoints):
                cmds.parent(jnt,skinJoints[-1])
            else:
                cmds.parent(jnt,skinJointParent)
            skinJoints.append(jnt)
            cmds.setAttr(jnt + ".radius",stripWidth) #just cosmetic
        
        #add controls
        ctrls = []
        stripJoints = []
        stripJointParent = cmds.createNode('transform',n=crv + "_stripJoints",p=hiddenStuff)
        ctrlParent = cmds.createNode('transform',n=crv+"_Ctrls",p=topNull)
    
        for i in range(numCtrls):
            #The first control is larger, and has the stretch attr
            if i == 0:
                zero,ctrl = self.makeCubeCtrl(crv + "_Ctrl%02d"%i,size=ctrlWidth*1.8)
                cmds.addAttr(ctrl,ln="noStretch",dv=0.0,min=0,max=1,k=1,s=1)
                cmds.addAttr(ctrl,ln='slideAmount',dv=0.0,min=-1.0,max=1.0,k=1,s=1)
                cmds.connectAttr(ctrl + ".noStretch",topNull + ".stretchAmount")
                cmds.connectAttr(ctrl + ".slideAmount",topNull + ".slideAmount")
            else:
                zero,ctrl = self.makeCubeCtrl(crv + "_Ctrl%02d"%i,size=ctrlWidth)
            
            #Make the joint the control. These drive the nurbs strip.
            cmds.select(clear=True)
            jnt = cmds.joint(p=(0,0,0),n=ctrl + "StripJnt")
            cmds.parentConstraint(ctrl,jnt,mo=False)
            cmds.setAttr(jnt + ".radius", stripWidth * 1.3) #just cosmetic
        
            #briefly attach ctrls to strip to align them
            percentage = float(i)/(numCtrls-1.0)
            print "ctrl percentage:",percentage
            if i > 0 and i < numCtrls-1:
                percentage = uMin + (percentage * (uMax-uMin))
                print '\tinterp percentage:', percentage
            cmds.delete(self.attachObjToSurf(zero,surf,offsetCrv,stretchAmountNode,percentage))
            ctrls.append(ctrl)
            cmds.parent(jnt,stripJointParent)
            stripJoints.append(jnt)
            cmds.parent(zero,ctrlParent)
        
        #skin strip to controls
        #Can get some different behavior by chaning the strip's weights
        #or perhaps using dual quat. mode on the skinCluster
        skinObjs = stripJoints + [surf]
        cmds.skinCluster(skinObjs,
            bindMethod=0, #closest Point
            sm=0, #standard bind method
            ih=True, #ignore hierarchy
        )    
        
        #rebuild curve and skin to joints
        newCurve = cmds.duplicate(crv)[0]
        newCurve = cmds.rename(newCurve, crv + "_skinned")
        cmds.parent(newCurve, topNull)
        cmds.rebuildCurve(newCurve,ch=0,rpo=1,rt=0,end=1,kr=0,kcp=0,kep=1,kt=0,s=numJoints-2,d=3,tol=0.01)
        skinObjs = skinJoints + [newCurve]
        cmds.skinCluster(skinObjs,
            bindMethod = 0,
            sm = 0,
            ih=True,
            mi=1
            )
        if geo:
            wireDef,wireCrv = cmds.wire(geo,w=newCurve,n=crv + "_wire",dds=(0,10),en=1.0,ce=0,li=0)
            print wireDef
            cmds.parent(wireCrv,hiddenStuff)
            if cmds.objExists(wireCrv+"BaseWire"):
                cmds.parent(wireCrv+"BaseWire",hiddenStuff)
Exemplo n.º 23
0
    def postBuild(self):
        jointsNames = []
        for i in range(len(self.Joints.outs)):
            exec('jointsNames.append( self.Joints.outs[{0}].str() )'.format(i))

        self.utils_prepareJointForIk(jointsNames)

        # IK___________CREATE SOLVER
        mc.ikHandle(sj=self.Joints.outs[0].str(),
                    ee=self.Joints.outs[-1].str(),
                    sol='ikRPsolver',
                    n=self.Name.handleIkSolver.str())
        mc.parent(self.Name.handleIkSolver.str(), self.Name.rigGrp.str())
        #mc.poleVectorConstraint( self.Pv.Name.ctrl.str() , self.Name.handleIkSolver.str() )
        utilsMaya.buildConstraint(
            [self.CtrlB.outs[0].str(),
             self.Name.handleIkSolver.str()], ['parent', 'scale'], 'oneMaster',
            1)
        utilsMaya.buildConstraint(
            [self.CtrlA.outs[0].str(), self.Joints.ins[0].str()], ['parent'],
            'oneMaster', 1)
        utilsMaya.buildConstraint(
            [self.Pv.outs[0].str(),
             self.Name.handleIkSolver.str()], ['poleVector'], 'oneMaster', 0)

        # CREATE CURVE
        Curve = curveShape.curveShape()
        curveShapeName = Curve.utils_buildCurveShape(self.Name.curve.str(),
                                                     'None', self.pos, 3, 5)

        ctrlsName = []
        for i in range(3, len(self.outs)):
            ctrlsName.append(self.outs[i].str())

        Curve.utils_connectTransformsToCurve(ctrlsName, self.Name.curve.str())
        mc.parent(self.Name.curve.str(), self.Name.rigGrp.str())

        # CREATE thicknessCuve
        circleShape = mc.circle(nr=[1, 0, 0], n=self.Name.circle.str())[0]
        utilsMaya.buildConstraint(
            [self.Ctrl0.outs[0].str(),
             self.Name.circle.str()], ['parent'], 'oneMaster', 0)
        mc.connectAttr(self.Attr.ctrl.thickness.str(),
                       self.Name.circle.str() + '.scaleX')
        mc.connectAttr(self.Attr.ctrl.thickness.str(),
                       self.Name.circle.str() + '.scaleY')
        mc.connectAttr(self.Attr.ctrl.thickness.str(),
                       self.Name.circle.str() + '.scaleZ')
        mc.parent(self.Name.circle.str(), self.Name.rigGrp.str())

        #CREATE POLY TUBE
        extrudeOut = mc.extrude(circleShape,
                                self.Name.curve.str(),
                                ch=True,
                                rn=True,
                                po=1,
                                et=2,
                                ucp=1,
                                fpt=0,
                                upn=0,
                                rotation=0,
                                scale=1,
                                rsp=1)
        extrudeMesh = extrudeOut[0]
        extrudeNode = extrudeOut[1]
        mc.rename(extrudeMesh, self.Name.outGeometry.str())
        extrudeMesh = self.Name.outGeometry.str()
        #mc.parent( extrudeMesh , w = True )
        mc.setAttr((extrudeNode + ".fixedPath"), 0)
        mc.setAttr((extrudeNode + ".useComponentPivot"), 0)
        mc.setAttr((extrudeNode + ".useProfileNormal"), 0)

        nurbsTessellateNode = mc.listConnections(extrudeNode +
                                                 '.outputSurface',
                                                 s=False,
                                                 d=True)[0]
        mc.setAttr((nurbsTessellateNode + ".format"), 0)
        mc.setAttr((nurbsTessellateNode + ".polygonType"), 1)
        mc.connectAttr(self.Attr.ctrl.polyCount.str(),
                       (nurbsTessellateNode + ".polygonCount"))

        #VISIBILITY
        mc.setAttr(self.Name.topNode.str() + ".skeletonVis", 1)
        mc.setAttr(self.Name.topNode.str() + ".skeletonRef", 2)
        mc.setAttr(self.Joints.Name.topNode.str() + ".v", 0)
        '''
Exemplo n.º 24
0
	def execute(self):

		sx = self.sx
		sy = self.sy
		sdv = self.sdv
		sdu = self.sdu
		tap = self.tap
		degs = self.degs
		subCurve = self.subCurve
		clean = self.clean
		do_uvs = self.do_uvs
		rbc = self.rbc
		cTol = self.cTol
		cSubd = self.cSubd
		
		if cmds.checkBox(self.aUACCB, q=True, v=True):
			useAltShape = True
		else:
			useAltShape = False
		
		multSel = cmds.ls(sl=True,fl=True, ap=True)
		if cmds.objectType(multSel[0]) == 'mesh':
			thisIsAMesh = True
		else:
			thisIsAMesh = False
		# Select curve type to extrude along - convert and store
		for x in multSel:
			print x
			if thisIsAMesh != True:
				cmds.select(x)
			else:
				cmds.select(multSel)
				
			objSel = cmds.ls(sl=True,fl=True, ap=True)
			if self.ko == 1:
				dupObj = cmds.duplicate(objSel)
				objSel = dupObj
			if len(objSel) > 1:
				print objSel
				if degs == 0:
					curveDg = cmds.promptDialog(t='Enter Degrees:', m='Enter Degrees - ie. 1 for linear, 3 for curved')
					objSel = cmds.polyToCurve(f=2, dg=int(cmds.promptDialog(q=True, tx=True)))
				else:
					objSel = cmds.polyToCurve(f=2, dg=int(degs), n='%s_curve' %objSel[0].split('.')[0])
			else:
				objType = cmds.listRelatives(objSel[0], f=True)
				if cmds.objectType(objType[0]) != 'nurbsCurve' and cmds.objectType(objType[0]) != 'bezierCurve':
				    cmds.error('Select the nurbs curve first, then the object to align')
				if cmds.objectType(objType[0]) == 'bezierCurve':
					mm.eval("bezierCurveToNurbs;")
			# Create a nurbs curve for the extrusion
			if useAltShape:
				nurbsCir = self.objToUse
			else:	
				nurbsCir = cmds.circle(n='extrudeCircle', d=3, r=1, nr=(0,0,1), sw=360, ch=True, s=8)
			objCV = cmds.ls('%s.ep[*]' %objSel[0], fl=True)
			
			noOfCV = len(objCV)
			firstCV = 0
			lastCV = noOfCV - 1
			cvNumberToUse=firstCV
			
			# Rebuild the curve to help with uniformity
			if self.rev == 1:
				cmds.reverseCurve(objSel[0], ch=0, rpo=1)
			
			if rbc == 1:
				try:
					cmds.rebuildCurve(objSel[0], ch=0,rpo=1,rt=4,end=1,kr=0, kcp=0, kep=1, kt=0, s=cSubd, d=3, tol=cTol)
					cmds.rebuildCurve(objSel[0], ch=0,rpo=1,rt=0,end=1,kr=0, kcp=0, kep=1, kt=0, s=cSubd, d=3, tol=cTol)
				except:
					cmds.warning('Tolerance for rebuild likely to low, try a higher value or turn Rebuild Curve off')
			
			if do_uvs == 1:
				objShape = cmds.listRelatives(objSel[0], c=True, type='shape')
				mInfo = cmds.shadingNode('curveInfo', n='cMeasure', asUtility=True)
				cmds.connectAttr('%s.local' %objShape[0], '%s.inputCurve' %mInfo)
				curveLength = cmds.getAttr('%s.arcLength' %mInfo)
				cmds.delete(mInfo)
				
				self.uvRatio = float((((sx * sy)*2.0) * math.pi) / curveLength)
				print "uvRatio:  " + str(self.uvRatio)
				
			
			# Create a tangent contraint to position nurbs circle to the first cv
			cvPos = cmds.xform('%s.ep[%d]' %(objSel[0],cvNumberToUse), query=True, ws=True, t=True)
			cmds.xform(nurbsCir[0], ws=True, t=(cvPos[0],cvPos[1],cvPos[2]))
			fastCon = cmds.tangentConstraint(objSel[0], nurbsCir[0], aim=(0,0,1))
			cmds.delete(fastCon[0])
			
			# Extrude along curve and set attributes
			pipeExt = cmds.extrude(nurbsCir[0], objSel[0], n='%s_pipe' %objSel[0], ch=True, rn=subCurve, po=1, et=2, ucp=1, fpt=1,upn=1, rotation=0, scale=1,rsp=1) 
			pipeTes = cmds.listConnections(pipeExt[1], type='nurbsTessellate')
			if subCurve != 0:
				pipeSubCurve = cmds.listConnections(pipeExt[1], type='subCurve')
			
			cmds.setAttr('%s.format' %pipeTes[0],2)
			cmds.setAttr('%s.polygonType' %pipeTes[0],1)
			cmds.setAttr('%s.uType' %pipeTes[0],2)
			cmds.setAttr('%s.vType' %pipeTes[0],2)
			cmds.setAttr('%s.vNumber' %pipeTes[0],sdv)
			cmds.setAttr('%s.uNumber' %pipeTes[0],sdu)
			
			# Add attributes
			if clean == 0:
				cmds.addAttr(pipeExt[0], ln='________', k=True)
				cmds.setAttr('%s.________' %pipeExt[0], l=True)
				cmds.addAttr(pipeExt[0], ln='Ext_ScaleX', k=True, dv=sx)
				cmds.addAttr(pipeExt[0], ln='Ext_ScaleY', k=True, dv=sy)
				cmds.connectAttr('%s.Ext_ScaleX' %pipeExt[0], '%s.scaleX' %nurbsCir[0])
				cmds.connectAttr('%s.Ext_ScaleY' %pipeExt[0], '%s.scaleY' %nurbsCir[0])
				cmds.addAttr(pipeExt[0], ln='Ext_DivisionV', at='short', k=True, dv=sdv)
				cmds.connectAttr('%s.Ext_DivisionV' %pipeExt[0], '%s.vNumber' %pipeTes[0])
				cmds.addAttr(pipeExt[0], ln='Ext_DivisionU', at='short', k=True, dv=sdu)
				cmds.connectAttr('%s.Ext_DivisionU' %pipeExt[0], '%s.uNumber' %pipeTes[0])
				if subCurve != 0:
					cmds.addAttr(pipeExt[0], ln='Ext_Length', k=True, dv=1, max=1, min=0)
					cmds.connectAttr('%s.Ext_Length' %pipeExt[0], '%s.maxValue' %pipeSubCurve[1])
				cmds.addAttr(pipeExt[0], ln='Ext_Taper', k=True, dv=tap, min=0)
				cmds.connectAttr('%s.Ext_Taper' %pipeExt[0], '%s.scale' %pipeExt[1])
				cmds.addAttr(pipeExt[0], ln='Ext_Twist', k=True, dv=1)
				cmds.connectAttr('%s.Ext_Twist' %pipeExt[0], '%s.rotation' %pipeExt[1])
				cmds.addAttr(pipeExt[0], ln='Ext_ComponentPivot', k=True, dv=1)
				cmds.connectAttr('%s.Ext_ComponentPivot' %pipeExt[0], '%s.useComponentPivot' %pipeExt[1])

			curveGrpNode = cmds.createNode('transform', n='pipeCurves')
			cmds.parent(nurbsCir, curveGrpNode)
			cmds.parent(objSel, curveGrpNode)
	
			cmds.setAttr('%s.inheritsTransform' %curveGrpNode, 0)
			cmds.setAttr('%s.visibility' %curveGrpNode, 1)
			cmds.parent(curveGrpNode, pipeExt[0])
			cmds.select(pipeExt[0])
			if do_uvs == 1:
				cmds.polyLayoutUV(ps=0.2)
				cmds.polyEditUV(sv=1, su=self.uvRatio)
				cmds.polyEditUV(sv=0.95, su=0.95)
				cmds.select(pipeExt[0])
				CentreUVs()
				if clean == 1:
					cmds.delete(ch=True)
					cmds.delete(curveGrpNode)
					cmds.select(pipeExt[0])
			if thisIsAMesh == True:
				print 'hello'
				break					
Exemplo n.º 25
0
def extrude(*args):

    sel = cmds.ls(sl=True, exactType="transform")

    #keep = cmds.checkBoxGrp(widgets["keepCBG"], q=True, v1=True)

    if len(sel) < 3:
        cmds.warning(
            "You need to select the profile, then cap, then path curve in order!"
        )
        return

    profileOrig = sel[0]
    cap = sel[1]
    curves = sel[2:]

    if not cmds.objExists("pastaRigSetupComponents_Grp"):
        cmds.group(empty=True, name="pastaRigSetupComponents_Grp")

    if not curveCheck(profileOrig):
        cmds.warning("Your first selection (profile) is not a curve!")
        return

    if not cmds.objExists("curveRebuild_originals_grp"):
        cmds.group(empty=True, name="curveRebuild_originals_grp")

    cmds.parent("curveRebuild_originals_grp", "pastaRigSetupComponents_Grp")
    cmds.parent(profileOrig, cap, "pastaRigSetupComponents_Grp")

    for curve in curves:
        if not curveCheck(curve):
            cmds.warning("{} is not a curve, skipping!".format(curve))

        else:
            profile = cmds.duplicate(profileOrig,
                                     name="{}_profileCrv".format(curve))[0]

            newCap = cmds.duplicate(cap,
                                    returnRootsOnly=True,
                                    rebuildType=0,
                                    renameChildren=True,
                                    name="{}_capRig".format(curve))[0]
            # rigGrp = cmds.group(empty=True, name = "{}_rig_grp".format(curve))
            curveResults = rebuildCurve(curve)
            newCrv = curveResults[0]
            rebuild = curveResults[1]

            cmds.parent(curve, "curveRebuild_originals_grp")

            capAxis = "y"
            capUp = "z"

            ctrl = rig.createControl(type="sphere",
                                     name="{}_CTRL".format(curve),
                                     color="blue")
            ctrlScale(ctrl)
            capGrp = cmds.group(empty=True, name="{}_cap_grp".format(curve))
            deadGrp = cmds.group(empty=True,
                                 name="{}_noInherit_grp".format(curve))

            cmds.parent(deadGrp, ctrl)
            #cmds.parent(ctrl, rigGrp)
            cmds.parent(newCap, capGrp)

            # add attrs to control
            cmds.addAttr(ctrl,
                         ln="__xtraAttrs__",
                         nn="__xtraAttrs__",
                         at="bool",
                         k=True)
            cmds.setAttr("{}.__xtraAttrs__".format(ctrl), l=True)
            cmds.addAttr(ctrl,
                         ln="alongPath",
                         at="float",
                         min=0,
                         max=100,
                         k=True,
                         dv=100.0)
            cmds.setAttr("{}.alongPath".format(ctrl), 100)
            cmds.addAttr(ctrl,
                         ln="geoVis",
                         at="long",
                         min=0,
                         max=1,
                         k=True,
                         dv=1)
            cmds.addAttr(ctrl,
                         ln="pathCurveVis",
                         at="long",
                         min=0,
                         max=1,
                         k=True,
                         dv=1)
            cmds.addAttr(ctrl,
                         ln="__curveStuff__",
                         nn="__curveStuff__",
                         at="bool",
                         k=True)
            cmds.setAttr("{}.__curveStuff__".format(ctrl), l=True)
            cmds.addAttr(ctrl,
                         ln="density",
                         at="float",
                         min=0.02,
                         max=8,
                         k=True,
                         dv=0.05)
            cmds.addAttr(ctrl,
                         ln="radiusDivisions",
                         at="float",
                         k=True,
                         min=1,
                         max=3,
                         dv=1.0)
            cmds.addAttr(ctrl,
                         ln="reverseNormals",
                         at="long",
                         min=0,
                         max=1,
                         k=True)
            cmds.addAttr(ctrl,
                         ln="capVisibility",
                         at="long",
                         min=0,
                         max=1,
                         k=True)
            cmds.setAttr("{}.capVisibility".format(ctrl), 1)
            cmds.addAttr(ctrl,
                         ln="profileWidth",
                         at="float",
                         k=True,
                         min=.001,
                         max=3,
                         dv=1.0)
            cmds.addAttr(ctrl,
                         ln="capWidth",
                         at="float",
                         k=True,
                         min=.01,
                         max=2.0,
                         dv=1.0)
            cmds.addAttr(ctrl,
                         ln="capHeight",
                         at="float",
                         k=True,
                         min=.01,
                         max=2.0,
                         dv=1.0)
            cmds.addAttr(ctrl,
                         ln="rotateExtrusion",
                         at="float",
                         k=True,
                         min=0,
                         max=360)
            cmds.addAttr(ctrl, ln="rotateCap", at="float", k=True)
            cmds.addAttr(ctrl,
                         ln="__textureAndRef__",
                         nn="__textureAndRef__",
                         at="bool",
                         k=True)
            cmds.setAttr("{}.__textureAndRef__".format(ctrl), l=True)
            cmds.addAttr(ctrl,
                         ln="textureRepeatMult",
                         at="float",
                         min=0.01,
                         dv=1.0,
                         k=True)
            cmds.addAttr(ctrl, ln="length", at="float", k=True)
            initLen = cmds.arclen(newCrv, ch=False)
            cmds.setAttr("{}.length".format(ctrl), initLen)
            cmds.setAttr("{}.length".format(ctrl), l=True)

            cmds.addAttr(ctrl, ln="geo", at="message")
            cmds.addAttr(ctrl, ln="fileTexture", at="message")
            cmds.addAttr(ctrl, ln="capRig", at="message")
            cmds.connectAttr("{}.message".format(newCap),
                             "{}.capRig".format(ctrl))

            # reference/driver attrs
            cmds.addAttr(ctrl, ln="prmHolder", at="float", k=True)
            cmds.addAttr(ctrl, ln="rptHolder", at="float", k=True)
            #cmds.setAttr("{}.radiusDivisions".format(ctrl), l=True)

            # connect mult to path
            mult = cmds.shadingNode("multiplyDivide",
                                    asUtility=True,
                                    name="{}_paraMult".format(curve))
            cmds.connectAttr("{}.alongPath".format(ctrl),
                             "{}.input1X".format(mult))
            cmds.setAttr("{}.input2X".format(mult), 0.01)
            cmds.connectAttr("{}.profileWidth".format(ctrl),
                             "{}.scaleX".format(profile))
            cmds.connectAttr("{}.profileWidth".format(ctrl),
                             "{}.scaleZ".format(profile))

            # reverse for normals
            reverse = cmds.shadingNode("reverse",
                                       asUtility=True,
                                       name="{}_reverse".format(curve))
            cmds.connectAttr("{}.reverseNormals".format(ctrl),
                             "{}.inputX".format(reverse))

            # cap, path and texture attrs and nodes
            cmds.connectAttr("{}.capVisibility".format(ctrl),
                             "{}.v".format(capGrp))
            repeatMult = cmds.shadingNode("multiplyDivide",
                                          asUtility=True,
                                          name="{}_RptMult".format(curve))
            cmds.connectAttr("{}.outputX".format(mult),
                             "{}.input1X".format(repeatMult))
            cmds.connectAttr("{}.textureRepeatMult".format(ctrl),
                             "{}.input2X".format(repeatMult))
            cmds.connectAttr("{}.pathCurveVis".format(ctrl),
                             "{}.visibility".format(newCrv))

            #connect the rebuild density
            densityMult = cmds.shadingNode("multiplyDivide",
                                           asUtility=True,
                                           name="{}_DensityMult".format(curve))
            cmds.connectAttr("{}.density".format(ctrl),
                             "{}.input1X".format(densityMult))
            cmds.connectAttr("{}.length".format(ctrl),
                             "{}.input2X".format(densityMult))
            cmds.connectAttr("{}.outputX".format(densityMult),
                             "{}.spans".format(rebuild))

            cmds.connectAttr("{}.outputX".format(repeatMult),
                             "{}.rptHolder".format(ctrl))
            cmds.connectAttr("{}.outputX".format(mult),
                             "{}.prmHolder".format(ctrl))
            cmds.setAttr("{}.prmHolder".format(ctrl), l=True)
            cmds.setAttr("{}.rptHolder".format(ctrl), l=True)
            cmds.connectAttr("{}.capWidth".format(ctrl),
                             "{}.scaleX".format(capGrp))
            cmds.connectAttr("{}.capWidth".format(ctrl),
                             "{}.scaleZ".format(capGrp))
            cmds.connectAttr("{}.capHeight".format(ctrl),
                             "{}.scaleY".format(capGrp))
            cmds.connectAttr("{}.rotateCap".format(ctrl),
                             "{}.rotateY".format(newCap))

            # position control at start of curve
            startPos = cmds.pointOnCurve(curve, parameter=0, position=True)
            cmds.xform(ctrl, ws=True, t=startPos)

            moPath = cmds.pathAnimation(capGrp,
                                        newCrv,
                                        fractionMode=True,
                                        follow=True,
                                        followAxis=capAxis,
                                        upAxis=capUp,
                                        worldUpType="scene",
                                        startTimeU=0.0,
                                        endTimeU=100.0)
            moPathAnimAttr = cmds.listConnections("{}.uValue".format(moPath),
                                                  d=False,
                                                  p=True)[0]

            start, end = getSliderRange()
            current = cmds.currentTime(q=True)
            cmds.currentTime(0)

            pPos = cmds.xform(capGrp, q=True, ws=True, rp=True)
            pRot = cmds.xform(capGrp, q=True, ws=True, ro=True)
            cmds.xform(profile, ws=True, t=pPos)
            cmds.xform(profile, ws=True, ro=pRot)

            cmds.currentTime(current)

            # extrude the curve
            extr = cmds.extrude(profile,
                                newCrv,
                                ch=True,
                                range=True,
                                polygon=True,
                                extrudeType=2,
                                useComponentPivot=True,
                                fixedPath=True,
                                useProfileNormal=True,
                                reverseSurfaceIfPathReversed=True)
            extrGeo, extrNode = extr[0], extr[1]

            normal = cmds.polyNormal(extrGeo,
                                     normalMode=4,
                                     userNormalMode=0,
                                     ch=1)[0]
            cmds.connectAttr("{}.outputX".format(reverse),
                             "{}.normalMode".format(normal))
            cmds.connectAttr("{}.message".format(extrGeo),
                             "{}.geo".format(ctrl))
            cmds.connectAttr("{}.geoVis".format(ctrl),
                             "{}.visibility".format(extrGeo))
            cmds.connectAttr("{}.rotateExtrusion".format(ctrl),
                             "{}.rotation".format(extrNode))

            # get extrude connections
            connects = cmds.listConnections(extrNode)
            profNode, pathNode, tessNode = connects[0], connects[1], connects[
                2]

            # connect up stuff to extrusion
            cmds.connectAttr("{}.outputX".format(mult),
                             "{}.maxValue".format(pathNode))
            cmds.connectAttr("{}.radiusDivisions".format(ctrl),
                             "{}.uNumber".format(tessNode))
            cmds.parent(newCrv, ctrl)
            cmds.setAttr("{}.inheritsTransform".format(deadGrp), 0)
            cmds.parent(extrGeo, deadGrp)
            cmds.parent(profile, deadGrp)
            cmds.setAttr("{}.v".format(profile), 0)
            cmds.parent(capGrp, deadGrp)

            # motion path stuff
            cmds.delete(moPathAnimAttr.partition(".")[0])
            cmds.connectAttr("{}.outputX".format(mult),
                             "{}.uValue".format(moPath))
            cmds.setAttr("{}.visibility".format(cap))
            cmds.setAttr("{}.visibility".format(profileOrig))
Exemplo n.º 26
0
    shapes = cmds.listRelatives(c, s=True, path=True)
    curve0Pos = cmds.xform('%s.cv[0]' % shapes[0], q=True, t=True, ws=True)
    curve1Pos = cmds.xform('%s.cv[1]' % shapes[0], q=True, t=True, ws=True)

    newProfileCuve = cmds.duplicate(profileCurve)
    cmds.xform(newProfileCuve, t=curve0Pos, ws=True)

    aimPoint = cmds.spaceLocator(p=[0, 0, 0])
    cmds.xform(aimPoint, t=curve1Pos, ws=True)

    tempConstraint = cmds.aimConstraint(aimPoint,
                                        newProfileCuve,
                                        aimVector=[0, 1, 0],
                                        upVector=[0, 1, 0])

    cmds.delete(tempConstraint)
    cmds.delete(aimPoint)

    cmds.extrude(newProfileCuve,
                 c,
                 ch=True,
                 rn=False,
                 po=1,
                 et=2,
                 ucp=0,
                 fpt=0,
                 upn=1,
                 rotation=0,
                 scale=1,
                 rsp=1)
Exemplo n.º 27
0
	def onPress(self):
		"""
		execute on press
		"""
		# modifier
		self.mod = cmds.getModifiers()
		
		# button
		self.btn = cmds.draggerContext(self.dragCtx, query=True, button=True)
		
		# timer
		self.timer = cmds.timerX()
		initPos = cmds.draggerContext(self.dragCtx, query=True, anchorPoint=True)
		
		# camera far clip
		currentView = omui.M3dView().active3dView()
		camDP = om.MDagPath()
		
		currentView.getCamera(camDP)
		camFn = om.MFnCamera(camDP)
		farclip = camFn.farClippingPlane()
		
		# screen to world conversion
		worldPos, worldDir = utils().viewToWorld(initPos[0],initPos[1])
		
		if self.btn is not 2:
			closestHit = None
			closestObj = None
			for obj in self.targetObj:
				if cmds.objExists(obj):
					state, hit, fnMesh, facePtr, triPtr = utils().intersect(obj, worldPos, worldDir, farclip)
					
					if state is True:
						dif = [hit.x - worldPos[0],hit.y - worldPos[1],hit.z - worldPos[2]]
						distToCam = math.sqrt(math.pow(float(dif[0]),2) + math.pow(float(dif[1]),2) + math.pow(float(dif[2]),2))
						if closestHit == None:
							closestHit = distToCam
							closestObj = [state, hit, fnMesh, facePtr, triPtr]
						elif distToCam < closestHit:
							closestHit = distToCam
							closestObj = [state, hit, fnMesh, facePtr, triPtr]
				else:
					self.targetObj.remove(obj)
			if closestObj is not None:
				state, hit, fnMesh, facePtr, triPtr = closestObj
				
				mHit = om.MPoint(hit)
				# get smooth normal
				normal = om.MVector()
				fnMesh.getClosestNormal(mHit, normal, om.MSpace.kWorld, None)
				
				# get smooth normal
				normal = om.MVector()
				fnMesh.getClosestNormal(mHit, normal, om.MSpace.kWorld, None)
				
				tangent = utils().crossProduct(normal,self.worldUp)
				
				upAxis = utils().crossProduct(normal,tangent)
				
				# define transformation matrix
				matrix = [tangent.x,tangent.y,tangent.z,0,upAxis.x,upAxis.y,upAxis.z,0,normal.x,normal.y,normal.z,0,hit.x,hit.y,hit.z,0]
				
				# create object
				if self.mod == 0:
					self.loc = cmds.curve(p = (hit.x,hit.y,hit.z))
				# cmds.toggle(self.loc, localAxis=True)
				
				# store values
				self.prevHit = hit
				print self.prevHit
				
				self.screenPoint = initPos
				
				self.angle = 0
				
				# draw Mesh
				if self.mesh is True and self.mod == 0:
					self.circle = cmds.circle(center = (hit.x,hit.y,hit.z),radius = self.bRad,d=3)
					self.extrude = cmds.extrude(self.circle[0],self.loc,po=1, ch=True,rn=False,et=2,ucp=0,fpt=0,upn=0,rotation=0,scale=1,rsp=1)
					self.nbTes = cmds.listConnections(self.extrude[1] + '.outputSurface')[0]
					
					cmds.setAttr(self.nbTes + '.polygonType',1)
					cmds.setAttr(self.nbTes + '.format',2)
					cmds.setAttr(self.nbTes + '.polygonCount',200)
					cmds.setAttr(self.nbTes + '.uType',3)
					cmds.setAttr(self.nbTes + '.uNumber',1)
					cmds.setAttr(self.nbTes + '.vType',3)
					cmds.setAttr(self.nbTes + '.vNumber',1)
					cmds.setAttr(self.extrude[1] + '.scale',self.taper)
					
					if self.autoAdd is True and self.extrude[0] not in self.targetObj:
							self.targetObj.append(self.extrude[0])
						
		# refresh viewport
		cmds.refresh(cv=True)
Exemplo n.º 28
0
def extrude(*args, **kwargs):
    res = cmds.extrude(*args, **kwargs)
    if not kwargs.get('query', kwargs.get('q', False)):
        res = _factories.maybeConvert(res, _general.PyNode)
    return res
Exemplo n.º 29
0
    def generateCity(self, *args):
        map_file = cmds.textField(self.widgets["osmFileTextField"], q = True, fi = True)
        winds_file = cmds.textField(self.widgets["wrfFileTextField"], q = True, fi = True)
        heights_file = cmds.textField(self.widgets["demFileTextField"], q = True, fi = True)
        jams_file = cmds.textField(self.widgets["jamsFileTextField"], q = True, fi = True)

        raw_wrf = cmds.checkBox(self.widgets["wrfCheckBox"], q=True, v=True)
        raw_dem = cmds.checkBox(self.widgets["demCheckBox"], q=True, v=True)

        if raw_wrf:
            if platform.system() == 'Windows':
                s = subprocess.check_output(["where", "python"], shell=True)
            else:
                s = subprocess.check_output(["which", "python"], shell=False)
            python_path = s.splitlines()[-1]
            script_dir = os.path.dirname(os.path.realpath(__file__))
            winds_file = subprocess.check_output([python_path, script_dir + "\NetCDF_converter.py", map_file, winds_file], shell=False).rstrip()

        if raw_dem:
            if platform.system() == 'Windows':
                s = subprocess.check_output(["where", "python"], shell=True)
            else:
                s = subprocess.check_output(["which", "python"], shell=False)
            python_path = s.splitlines()[-1]
            script_dir = os.path.dirname(os.path.realpath(__file__))
            heights_file = subprocess.check_output([python_path, script_dir + "\DEM_converter.py", map_file, heights_file], shell=False).rstrip()


        if cmds.objExists('city'):
            cmds.delete('city')

        def calc_emmiter_level(waypoints):
            if (jams_file == ""):
                return 0

            jams_data = open(jams_file, 'r')
            sum_jams_level = 0
            jams_points = 0

            shift_lat = -0.00766
            shift_lon = 0.006868

            for waypoint in waypoints:
                for line in jams_data:
                    tmp = line.split(' ')
                    lon = float(tmp[0]) - shift_lon
                    lat = float(tmp[1]) - shift_lat
                    if lat < minlat or lat > maxlat or lon < minlon or lon > maxlon:
                        continue
                    data = float(tmp[2])
                    jams_point = convert_coordinates(lon, lat)
                    dist = math.sqrt(math.pow(waypoint[0]-jams_point[0], 2)+math.pow(waypoint[2]-jams_point[2], 2))
                    if dist < (25.0/size_multiplier):
                        sum_jams_level += data
                        jams_points += 1

            if jams_points >= (len(waypoints) * 0.5):
                return 1.0*sum_jams_level/jams_points
            else:
                return 0

            jams_data.close()


        def convert_coordinates(lon, lat):
            centered_lat = (lat-minlat) - (maxlat-minlat)/2
            centered_lon = (lon-minlon) - (maxlon-minlon)/2
            normalized_lat = centered_lat * norm_lat
            normalized_lon = centered_lon * norm_lon
            return [normalized_lon, 0, -normalized_lat]

        #meters
        size_multiplier = float(cmds.textField(self.widgets["sizeMultTextField"], q = True, tx = True))
        emit_multiplier = float(cmds.textField(self.widgets["emitMultTextField"], q = True, tx = True))
        hasl = float(cmds.textField(self.widgets["haslTextField"], q = True, tx = True))

        xmlData = xml.dom.minidom.parse(map_file)

        points_ids = []
        points = []
        heights = []

        bounds = xmlData.getElementsByTagName("bounds")[0]
        minlat = float(bounds.getAttribute('minlat'))
        maxlat = float(bounds.getAttribute('maxlat'))
        minlon = float(bounds.getAttribute('minlon'))
        maxlon = float(bounds.getAttribute('maxlon'))

        dist_lon = self.coordinates_dist(minlon, minlat, maxlon, minlat)
        dist_lat = self.coordinates_dist(minlon, minlat, minlon, maxlat)

        norm_lat = (dist_lat/size_multiplier)/(maxlat-minlat)
        norm_lon = (dist_lon/size_multiplier)/(maxlon-minlon)

        #============================Get heights===================================
        heights_data = open(heights_file, 'r')

        rows = 0
        cols = 0
        start_lon = 0
        start_lat = 0
        delta_lon = 0
        delta_lat = 0

        heights_matrix = []

        for line in heights_data:
            tmp = line.strip().split(' ')

            if rows == 0:
                rows = float(tmp[0])
                cols = float(tmp[1])
            elif start_lon == 0:
                start_lon = float(tmp[0])
                start_lat = float(tmp[1])
            elif delta_lon == 0:
                delta_lon = float(tmp[0])
                delta_lat = float(tmp[1])
            else:
                row = []
                for cell in tmp:
                    row.append(int(cell)-hasl)
                heights_matrix.append(row)

        #==========================================================================

        maxprogress = 0
        ways = xmlData.getElementsByTagName('way')
        for way in ways:
            tags = way.getElementsByTagName('tag')
            for tag in tags:
                tag_type = str(tag.getAttribute('k'))
                if (tag_type == 'highway'):
                    subtype = str(tag.getAttribute('v'))
                    if not(subtype == 'pedestrian') and not(subtype == 'steps') and not(subtype == 'footway') and not(subtype == 'cycleway'):
                        maxprogress += 1
                if (tag_type == 'building'):
                    maxprogress += 1

        progress = 0
        cmds.progressWindow(title='Generating city', min = 0, max = maxprogress,  progress = progress, status = 'Processing nodes', isInterruptable = False)

        #============================Handle nodes==================================
        nodes = xmlData.getElementsByTagName('node')
        for node in nodes:
            lat = float(node.getAttribute('lat'))
            lon = float(node.getAttribute('lon'))

            if lat < minlat or lat > maxlat or lon < minlon or lon > maxlon:
                continue

            point = convert_coordinates(lon, lat)

            points_ids.append(int(node.getAttribute('id')))
            points.append(point)
            heights.append(heights_matrix[int(math.floor((lon-start_lon)/delta_lon))][int(math.floor((lat-start_lat)/delta_lat))])
        #==========================================================================

        #=============================Handle ways==================================
        roads = 0
        buildings = 0
        emitter = 0

        cmds.particle(n='nParticle')
        cmds.particle('nParticle', e=True, at='mass', order=0, fv=1e-5)
        cmds.setAttr('nParticleShape.lifespanMode', 2)
        cmds.setAttr('nParticleShape.lifespan', 6)
        cmds.setAttr('nParticleShape.lifespanRandom', 2)

        cmds.select('nParticleShape', r=True)
        cmds.addAttr(longName='betterIllumination', at='bool', defaultValue=False )
        cmds.addAttr(longName='surfaceShading', at='float', defaultValue=0, minValue=0, maxValue=1)
        cmds.addAttr(longName='threshold', at='float', defaultValue=0, minValue=0, maxValue=10)
        cmds.addAttr(longName='radius', at='float', defaultValue=1, minValue=0, maxValue=20)
        cmds.addAttr(longName='flatShaded', at='bool', defaultValue=False)

        cmds.setAttr('nParticleShape.particleRenderType', 8)
        cmds.setAttr('nParticleShape.radius', 0.06)

        cmds.setAttr('particleCloud1.transparency', 0.53, 0.53, 0.53, type='double3')
        cmds.setAttr('particleCloud1.color', 1.0, 0.0, 0.483, type='double3')
        cmds.setAttr('particleCloud1.incandescence', 1.0, 0.0, 0.850, type='double3')
        cmds.setAttr('particleCloud1.glowIntensity', 0.111)


        ways = xmlData.getElementsByTagName('way')
        for way in ways:
            waypoints = []
            heights_sum = 0
            nodes = way.getElementsByTagName('nd')
            tags = way.getElementsByTagName('tag')

            for node in nodes:
                ref = int(node.getAttribute('ref'))
                try:
                    index = points_ids.index(ref)
                except ValueError:
                    index = -1

                if index != -1:
                    waypoints.append(points[index])
                    heights_sum += heights[index]

            for tag in tags:
                tag_type = str(tag.getAttribute('k'))
                if tag_type == 'highway':
                    subtype = str(tag.getAttribute('v'))
                    if not(subtype == 'pedestrian') and not(subtype == 'steps') and not(subtype == 'footway') and not(subtype == 'cycleway'):
                        roads += 1
                        progress += 1
                        cmds.progressWindow(edit=True, progress = progress, status='Generating road: ' + str(roads))

                        lanes = 2
                        for tag in tags:
                            tag_type = str(tag.getAttribute('k'))
                            if tag_type == 'lanes':
                                lanes = float(str(tag.getAttribute('v')))

                        if len(waypoints) >= 2:
                            cmds.curve(n='pathcurve_' + str(roads), p=waypoints, d=1)
                            sx = waypoints[0][0]
                            sz = waypoints[0][2]
                            dx = waypoints[0][2]-waypoints[1][2]
                            dz = waypoints[1][0]-waypoints[0][0]
                            ln = math.sqrt(math.pow(2*dx, 2) + math.pow(2*dz, 2))
                            dx /= (ln*size_multiplier)/(3*lanes)
                            dz /= (ln*size_multiplier)/(3*lanes)
                            ln = 0

                            for i in range(0, len(waypoints)-2):
                                ln += math.trunc(math.sqrt(math.pow(waypoints[i+1][0]-waypoints[i][0], 2) + math.pow(waypoints[i+1][2]-waypoints[i][2], 2))) + 1
                            cmds.curve(n='extrudecurve_' + str(roads), p=[(sx-dx, 0, sz-dz), (sx+dx, 0, sz+dz)], d=1)
                            cmds.rebuildCurve('pathcurve_' + str(roads), rt=0, s=200)
                            cmds.nurbsToPolygonsPref(f=2, pt=1, ut=1, un=2, vt=1, vn=ln * 5 + 30)
                            cmds.extrude('extrudecurve_' + str(roads), 'pathcurve_' + str(roads), n='road_' + str(roads), et=2, po=1)
                            cmds.delete('extrudecurve_' + str(roads),)


                            emitter_level = calc_emmiter_level(waypoints)
                            if emitter_level > 0:
                                emitter += 1
                                cmds.select('pathcurve_' + str(roads), r=True)
                                cmds.move(0, 0.03, 0)
                                cmds.emitter(n='emitter_' + str(emitter), type='omni', r=emit_multiplier*emitter_level, spd=0.1, srn=0, sp=0)
                                cmds.connectDynamic('nParticle', em='emitter_' + str(emitter))


                            cmds.select('road_' + str(roads), r=True)
                            cmds.move(0, 0.004, 0)


                elif tag_type == 'building':
                    temp = str(tag.getAttribute('v'))
                    if temp == 'yes':
                        buildings += 1
                        progress += 1
                        cmds.progressWindow(edit=True, progress = progress, status='Generating building: ' + str(buildings))

                        if len(waypoints) >= 3:
                            cmds.polyCreateFacet(n='building_' + str(buildings), p=waypoints)
                            cmds.select('building_' + str(buildings), r=True)
                            normal = cmds.polyInfo(fn=True)[0].partition('0: ')[2].split(' ')[1]
                            if float(normal) < 0:
                                cmds.polyMirrorFace(direction=2, p=(0, 0, 0), mergeMode=0, worldSpace=1)
                                cmds.polyDelFacet('building_' + str(buildings) + '.f[0]')

                            avg_height = heights_sum / len(waypoints)

                            cmds.polyExtrudeFacet('building_' + str(buildings) + '.f[0]',  ltz=(1.0 * avg_height/size_multiplier))

                            cmds.select('building_' + str(buildings), r=True)

                            cmds.collision('building_' + str(buildings), 'nParticle')

        #==========================================================================

        #============================Handle winds==================================
        winds_data = open(winds_file, 'r')
        winds = 0
        cmds.progressWindow(edit=True, progress = progress, status='Setting winds')
        for line in winds_data:
            winds += 1

            tmp = line.split(' ')
            lon = float(tmp[0])
            lat = float(tmp[1])
            x = float(tmp[2])
            y = float(tmp[3])
            z = float(tmp[4])

            magn = math.sqrt(math.pow(x, 2) + math.pow(y, 2) + math.pow(z, 2))
            max_dist = self.coordinates_dist(0, 0, 0.006364, 0.006364)/size_multiplier
            volume_size = self.coordinates_dist(0, 0, 0.0045, 0.0045)/size_multiplier
            position = convert_coordinates(lon, lat)

            cmds.air(n='wind_' + str(winds), pos=position, wns=True, dx=x, dy=y, dz=z, m=magn, s=1, mxd=max_dist)
            cmds.setAttr('wind_' + str(winds) + '.volumeShape', 1)
            cmds.setAttr('wind_' + str(winds) + '.volumeOffsetY', 1)
            cmds.scale(volume_size, volume_size/2, volume_size, 'wind_' + str(winds))
            cmds.connectDynamic('nParticle', f='wind_' + str(winds))
            cmds.select(cl=True)
        #==========================================================================

        cmds.gravity(n='gravity', m=9.8*1e-5)
        cmds.connectDynamic('nParticle', f='gravity')
        cmds.polyPlane(n='ground', sx=(maxlon-minlon), sy=(maxlat-minlat), w=(maxlon-minlon)*norm_lon, h=(maxlat-minlat)*norm_lat)
        cmds.collision('ground', 'nParticle')

        cmds.select('building_*', r=True)
        cmds.select('road_*', tgl=True)
        cmds.select('ground', tgl=True)
        cmds.select('nParticle', tgl=True)
        cmds.editRenderLayerGlobals(currentRenderLayer='AOLayer')
        cmds.editRenderLayerMembers('AOLayer')

        cmds.select('road_*', r=True)
        cmds.group(n='roads')

        cmds.select('building_*', r=True)
        cmds.group(n='buildings')

        cmds.select('pathcurve_*', r=True)
        cmds.group(n='emitters')

        cmds.select('roads', r=True)
        cmds.select('buildings', tgl=True)
        cmds.select('emitters', tgl=True)
        cmds.select('nParticle', tgl=True)
        cmds.select('gravity', tgl=True)
        cmds.select('ground', tgl=True)
        cmds.select('wind_1', tgl=True)
        cmds.group(n='city')

        xmlData.unlink()
        winds_data.close()
        heights_data.close()

        if raw_wrf:
            os.remove(winds_file)

        if raw_dem:
            os.remove(heights_file)

        cmds.progressWindow(endProgress = True)