示例#1
0
	def add_rigid_body( self, objects, magnitude = 50 ):
		
		cmds.rigidBody( objects, active = False, m = magnitude, collisions = False )
		
		cmds.gravity( pos = [0, 0, 0], m = magnitude, att = 0, dx = 0, dy = -1, dz = 0, mxd = -1, vsh = 'none', vex = 0, vof = [0, 0, 0], vsw = 360, tsr = 0.5 )
		gravity_dag = oopmaya.DAG_Node()
		cmds.connectDynamic( objects, fields = gravity_dag.name() )
示例#2
0
 def doIt(self,argList):
     cmds.polyPlane(n='myPlane', h=5, w=2)
     cmds.polySphere(n='mySphere', r=5)
     cmds.select('mySphere')
     cmds.move(0,5,0)
     cmds.rigidBody( n='myRigidBody', active=True, b=0.5, sf=0.4 )
     cmds.select(cl=True)
     cmds.gravity(n='myGravity')
     cmds.connectDynamic('mySphere', fields='myGravity')
示例#3
0
 def addDynamics(self,*args):
     for i in self.scene_before:
         self.obj = mc.listRelatives(i, p = True)
         mc.select(self.obj)
         mc.rigidBody( active = True, mass = 10, initialVelocity = (0.0,0.0,0.0), bounciness = 1, dynamicFriction = 0.8, damping = 0.2)
         self.G = mc.gravity(directionX = 0.0, directionY = -1.0, directionZ = 0.0, magnitude = 100)
         mc.connectDynamic(*self.obj, f = self.G)
示例#4
0
def gravity(*args, **kwargs):
    res = cmds.gravity(*args, **kwargs)
    if not kwargs.get('query', kwargs.get('q', False)):
        res = _factories.maybeConvert(res, _general.PyNode)
    # unpack create/edit list result
    if isinstance(res, list) and len(res) == 1 and not kwargs.get('query', kwargs.get('q', False)):
        res = res[0]
    return res
示例#5
0
    def add_rigid_body(self, objects, magnitude=50):

        cmds.rigidBody(objects, active=False, m=magnitude, collisions=False)

        cmds.gravity(pos=[0, 0, 0],
                     m=magnitude,
                     att=0,
                     dx=0,
                     dy=-1,
                     dz=0,
                     mxd=-1,
                     vsh='none',
                     vex=0,
                     vof=[0, 0, 0],
                     vsw=360,
                     tsr=0.5)
        gravity_dag = oopmaya.DAG_Node()
        cmds.connectDynamic(objects, fields=gravity_dag.name())
示例#6
0
	def init(WeatherUI,self):
		c.select('emitPlane');
		c.emitter(n='snowEmitter',type='surf',r=300,sro=0,nuv=0,cye='none',cyi=1,spd=1,srn=0,nsp=1,tsp=0,mxd=0,mnd=0,dx=0,dy=-1,dz=0,sp=1);
		c.particle(n='snowParticle');

		c.select(cl=True);
		c.setAttr( "snowParticle|snowParticleShape.particleRenderType", 8); # 1 ist for 8
		c.gravity(n='snowGravity',m=0.5);
		c.select(cl=True);
		
		c.connectDynamic('snowParticle',em='snowEmitter');
		c.connectDynamic('snowParticle',f='snowGravity');
		
		c.addAttr('snowParticleShape', ln='rgbPP', dt='vectorArray' );
		c.dynExpression('snowParticleShape', s='snowParticleShape.rgbPP = <<1.0, 1.0, 1.0>>', c=1);
		c.addAttr('snowParticleShape', ln='radius', at='float', min=0, max=20, dv=1);
		c.setAttr('snowParticleShape.radius', 0.3);
		c.setAttr("particleCloud1.color", 1, 1, 1, type="double3");
		c.setAttr('snowParticleShape.lifespanMode', 2);
		c.setAttr('snowParticleShape.lifespan', 30)
		
		c.select(cl=True);
		
		c.floatSliderGrp('snowIntens', en=True, e=True);
示例#7
0
	def init(WeatherUI,self):
		c.select('emitPlane');
		c.emitter(n='rainEmitter',type='surf',r=300,sro=0,nuv=0,cye='none',cyi=1,spd=1,srn=0,nsp=1,tsp=0,mxd=0,mnd=0,dx=0,dy=-1,dz=0,sp=1);
		c.particle(n='rainParticle');
		
		c.select(cl=True);
		c.setAttr( "rainParticle|rainParticleShape.particleRenderType", 6); # rainParticleShape/render Attributes
		c.gravity(n='rainGravity');
		c.select(cl=True);
		c.connectDynamic('rainParticle',em='rainEmitter');
		c.connectDynamic('rainParticle',f='rainGravity');
		c.addAttr('rainParticleShape', ln='rgbPP', dt='vectorArray' );
		c.dynExpression('rainParticleShape', s='rainParticleShape.rgbPP = <<0, 0, 1.0>>', c=1);
		c.select(cl=True);
		c.setAttr("particleCloud1.color", 1, 1, 1, type="double3"); #instead of particleCloud1?
		#sets the collision event and particle spawning
		c.particle( name='rainCollisionParticle' , inherit=True);
		c.connectDynamic('rainCollisionParticle',f='rainGravity');
		c.select(cl=True);
		c.setAttr( "rainCollisionParticle|rainCollisionParticleShape.particleRenderType", 6); # rainParticleShape/render Attributes
		c.setAttr('rainCollisionParticle.inheritFactor', 1);
		c.event( 'rainParticle', em=2, die=True, target='rainCollisionParticle', spread=0.5, random=True, count=0, name='rainParticleCollideEvent' );
		
		c.floatSliderGrp('rainIntens',en=True, e=True);
    def create_rain(self, *args):
        # Create the initial rain surface
        rainSurface = cmds.polyPlane(n="rainSurface",
                                     sx=10,
                                     sy=10,
                                     width=10,
                                     height=10)
        cmds.move(10, "rainSurface", y=True)

        # Create the emitter and particles
        rate = self.get_float_value(self.rain_rate)
        _emitter = cmds.emitter(type='omni', r=rate, sro=False)
        emitterName = _emitter[1]
        particleName, particleShape = cmds.particle()

        cmds.select(emitterName)
        emitterConnect = cmds.connectDynamic(particleName, em=emitterName)
        cmds.setAttr(emitterName + ".emitterType", 2)

        # Set particle attributes
        cmds.setAttr(particleShape + ".lifespanMode", 2)
        cmds.setAttr(particleShape + ".lifespanRandom", 5)

        # Select particle for gravity field creation
        cmds.select(particleName)

        _gravity = cmds.gravity(pos=(0, 0, 0), m=9.8)
        #print _gravity
        gravityName = _gravity[0]

        gravityConnect = cmds.connectDynamic(particleName, f=gravityName)

        # Change particle render type
        cmds.setAttr(particleShape + ".particleRenderType", 6)

        # Create turbulence field
        cmds.select(particleName)
        _turbulence = cmds.turbulence()
        turbulenceName = _turbulence[1]
        cmds.connectDynamic(particleShape, f=turbulenceName)
        turb_magnitude = self.get_float_value(self.turbulence_magnitude)
        cmds.setAttr(turbulenceName + ".magnitude", turb_magnitude)
        cmds.setAttr(turbulenceName + ".attenuation",
                     0)  # Attenuation at 0 for
        cmds.setAttr(turbulenceName + ".frequency", 50)

        # Create vortex field
        cmds.select(particleName)
        vortex = cmds.vortex()
        vortexName = vortex[1]
        vortexConnect = cmds.connectDynamic(particleShape, f=vortexName)

        vort_magnitude = self.get_float_value(self.vortex_magnitude)
        print vort_magnitude

        # Update Vortex Attributes
        cmds.setAttr(vortexName + ".magnitude", vort_magnitude)

        # Make raindrops past the bounds of the surface plane
        cmds.setAttr(emitterName + ".minDistance", 1)
        cmds.setAttr(emitterName + ".maxDistance", 1)

        # Set raindrops speed
        cmds.setAttr(emitterName + ".speedRandom", 0.9)
        cmds.setAttr(emitterName + ".tangentSpeed", 1.5)

        wind_speed = self.get_float_value(self.rain_speed)
        cmds.setAttr(emitterName + ".speed", wind_speed)

        print "Raindrops speed added."
        # Create surface for collisions (should be selected in the beginning, if not, a new surface will be created)
        #if self.selected_surface is None:
        groundName, groundShape = cmds.polyPlane(n="groundSurface",
                                                 sx=10,
                                                 sy=10,
                                                 width=25,
                                                 height=25)

        # Set resilience
        resilience = self.get_float_value(self.surface_resilience)
        cmds.select(particleName, r=True)
        cmds.select(groundName, add=True)
        cmds.collision(groundName, particleName, r=resilience)
        cmds.connectDynamic(particleName, c=groundName)
        print "Collisions added."

        # Split the raindrops on collision
        splitName, splitShape = cmds.particle(inherit=0.5,
                                              name="splitParticle")
        #print splitName, splitShape

        cmds.event(particleName,
                   split=3,
                   t=splitShape,
                   spread=0.5,
                   random=False)
        cmds.setAttr(splitShape + ".inheritFactor", 0.5)
        print "Raindrop splits added."

        # Add the gravity field to newly split particles
        cmds.select(gravityName, r=True)
        cmds.select(splitShape, add=True)
        cmds.connectDynamic(splitShape, f=gravityName)
        print "Gravity field added."
cmds.setAttr('log3.translateY', 100)
cmds.setAttr('log3.translateX', 5)
#cmds.setAttr('log3.rotateY', 90)
#cmds.rigidBody(active=True, mass=10, b=0)

# Create passiv floor
floor = cmds.polyPlane(h=55,
                       w=55,
                       sx=10,
                       sy=10,
                       ax=(0, 1, 0),
                       name='floor',
                       cuv=2,
                       ch=0)
#cmds.rigidBody(passive=True, bounciness=0.02, layer=-1)
RigidBody.CreateRigidBody(False).executeCommandCB()

# Add dynamics (gravity)
grav = cmds.gravity(pos=(0, 0, 0),
                    m=9.8,
                    dx=0,
                    dy=-1,
                    dz=0,
                    att=0,
                    mxd=-1,
                    name='myGravity')
#cmds.connectDynamic( 'log1', 'log2', 'log3', f='myGravity' )

# Add some light
#cmds.directionalLight(name='dirLight', decayRate=2, intensity=90, rgb=(1.0, 0.8, 0.8), rotation=(45, 70, 60))
示例#10
0
def voxel(victime):

    #definition
    step = cmds.intSliderGrp('StepSlider', query=True, value=True)

    #Bounding box
    bbox = cmds.exactWorldBoundingBox()

    #Remplit un mesh de particule
    if (len(cmds.ls(sl=1))):
        obj = cmds.ls(sl=1)[0]
        try:
            cmds.particleFill(rs=step,
                              maxX=1,
                              maxY=1,
                              maxZ=1,
                              minX=0,
                              minY=0,
                              minZ=0,
                              pd=1,
                              cp=0)
        except:
            pass

    #Met les particules das une liste
    part = cmds.ls(sl=1)[0]
    closest = cmds.createNode("closestPointOnMesh")
    cmds.connectAttr(obj + ".outMesh", closest + ".inMesh")
    points = cmds.getAttr(part + ".position")
    cmds.delete(part)

    #Recupere tous les rayons
    rayons = []
    for point in points:
        setAttr(closest + ".inPosition", point)
        rayons.append(mag(point, getAttr(closest + ".position")))
    delete(closest)

    max = 0
    #Recherche le MAX entre 2 particules (distance la plus grande)
    for i in range(len(points)):
        if rayons[i] > max:
            max, p, maxId = rayons[i], points[i], i

    #print max;
    amount = 0
    nbCube = 0.0
    cmds.progressWindow(title='Legosification',
                        progress=amount,
                        status='Legosification',
                        isInterruptable=True)

    #Compte le nombre de lego dans la scene
    objList1 = ls("lego*", geometry=True, l=True)
    if (len(objList1) == 0):
        cmds.polyCube(n="lego")
        objList1 = ls("lego*", geometry=True, l=True)
    objList2 = cmds.listRelatives(objList1, p=True)
    #print len(objList1)
    name = len(objList2) - 1
    #Cree des cubes
    for point in points:
        # Check if the dialog has been cancelled
        if cmds.progressWindow(query=True, isCancelled=True):
            break
        # Check if end condition has been reached
        if cmds.progressWindow(query=True, progress=True) >= 100:
            break
        name += 1
        dimension = (float)(bbox[3] - bbox[0]) / (float)(step + 1.0)
        #cmds.duplicate("lego")
        #cmds.select("lego"+`i`)
        #cmds.polyCube(w=dimension, h=dimension, d=dimension)
        #cmds.select("lego")
        #cmds.move(point[0],point[1],point[2])
        createLego(point[0], point[1], point[2], name, dimension, victime)
        nbCube += 1
        amount = (nbCube / len(points)) * 100
        cmds.progressWindow(edit=True,
                            progress=amount,
                            status=('Please Wait ! '))
    cmds.progressWindow(endProgress=1)

    #Gravity and animation
    if cmds.checkBox("physics", query=True, value=True) and cmds.checkBox(
            "animation", query=True, value=True) == False:
        objList1 = ls("lego*", geometry=True, l=True)
        objList2 = cmds.listRelatives(objList1, p=True)
        cmds.select(cl=1)
        grav = cmds.gravity()
        #Connect gravity to list of objects
        cmds.connectDynamic(objList2, fields=grav[0])
    #Menage
    if cmds.objExists('lego'):
        cmds.delete("lego")
cmds.addAttr(part[1], internalSet=True, ln="colorAccum", at="bool", dv=False )
cmds.addAttr(part[1], internalSet=True, ln="useLighting", at="bool", dv=False )
cmds.addAttr(part[1], internalSet=True, ln="pointSize", at="long", min=1, max=60, dv=2 )
cmds.addAttr(part[1], internalSet=True, ln="multiCount", at="long", min=1, max=60, dv=10 )
cmds.addAttr(part[1], internalSet=True, ln="multiRadius", at="float", min=0, max=10, dv=0.3 )
cmds.addAttr(part[1], internalSet=True, ln="normalDir", at="long", min=1, max=3, dv=2 )

part_attrs = {'colorAccum':False, 'useLighting':True, 'particleRenderType':0,}

for attr, value in part_attrs.items():
    cmds.setAttr('%s.%s' %(part[1], attr), value)

#Adding fields
#This code selects the particles so the gravity field can be added
cmds.select(part)
drop_grav = cmds.gravity(part, m=15, dy=-1)
cmds.connectDynamic(part, f='gravityField1')

#Reselect Particles to add in the radial field
cmds.select(part)
radial_drop = cmds.radial(part, m=0.010)
cmds.connectDynamic(part, f=radial_drop[0])

#Create Partilce Mist from the Particle Tool
mist_part_1 = cmds.particle(n='mist', c=0)
mist_part_2 = cmds.particle(n='mist1', c=0)
cmds.select(mist_part_1[0])
cmds.connectDynamic(mist_part_1[0], em=emit[0])
cmds.select(mist_part_2[0])
cmds.connectDynamic(mist_part_2[0], em=emit[0])
示例#12
0
def addGravity():
    selectDupeArray()
    gravInf= cmds.ls(sl=True)
    cmds.select(cl=True)
    cmds.gravity()
    cmds.connectDynamic( gravInf, f= 'gravityField1')
示例#13
0
def readK2P():
    mc.constructionHistory(toggle=False)
    mc.select(all=True)
    mc.delete()

    counterMin = 1;
    counter=counterMin;
    counterMax = 200;
    mc.playbackOptions(minTime=counterMin, maxTime=counterMax)

    skipCounterMin = 1;
    skipCounter=skipCounterMin;
    skipCounterMax = 6;


    path = "/Users/nick/Development/Maya/readxml"
    fileName = "mocapData1.xml"
    #trackPoint = ["l_foot","l_knee","l_hip","r_foot","r_knee","r_hip","l_hand","l_elbow","l_shoulder","r_hand","r_elbow","r_shoulder","torso","neck","head"]
    trackPoint = ["head"]
    scaler = 10
    grav = mc.gravity()

    xmlFile = xd.parse(path + "/" + fileName)
    print("loaded: " + fileName)

    for t in trackPoint:    
        joint = xmlFile.getElementsByTagName(t)
        jointCounter = 0;
        cubeName = t
        #mergeName = t + "Merge"

        for j in joint:
            counter=counterMin;
            x = scaler * float(j.getAttribute("x"))
            y = scaler * float(j.getAttribute("y"))
            z = scaler * float(j.getAttribute("z"))
            
            if(x!=0 and y!=0 and z!=0):
                mc.currentTime(counter)
                counter+=1
                if(skipCounter<skipCounterMax):
                    jointCounter+=1
                    mc.polyCube(name=cubeName+str(counter))
                    #polyCube(sx=2, sy=2, sz=2, name=cubeName+str(counter))
                    #polySmooth(dv=1)
                    mc.connectDynamic(f=grav) #adds gravity
                    mc.move(x, y, z)
                    mc.rotate(rnd.uniform(-1 * scaler, scaler),rnd.uniform(-1 * scaler, scaler),rnd.uniform(-1 * scaler, scaler))
                    skipCounter+=1
                else:
                    skipCounter=skipCounterMin

        print("cubes made: " + str(jointCounter))
        
        #select(all=True)
        #polyUnite(constructionHistory=False) #1=union, 2=difference, 3=intersection

    floor = mc.polyPlane(w=30,h=30)
    mc.rigidBody(passive=True)
    mc.move(0,0,0)

    print("...script complete.")
    def create_rain(self, *args):
        # Create the initial rain surface
        rainSurface = cmds.polyPlane(n="rainSurface", sx=10, sy=10, width=10, height=10)
        cmds.move(10, "rainSurface", y=True)

        # Create the emitter and particles
        rate = self.get_float_value(self.rain_rate)
        _emitter = cmds.emitter(type='omni', r=rate, sro=False)
        emitterName = _emitter[1]
        particleName, particleShape = cmds.particle()

        cmds.select(emitterName)
        emitterConnect = cmds.connectDynamic(particleName, em=emitterName)
        cmds.setAttr(emitterName+".emitterType", 2)

        # Set particle attributes
        cmds.setAttr(particleShape+".lifespanMode", 2)
        cmds.setAttr(particleShape+".lifespanRandom", 5)

        # Select particle for gravity field creation
        cmds.select(particleName)

        _gravity = cmds.gravity(pos=(0,0,0), m=9.8)
        #print _gravity
        gravityName = _gravity[0]

        gravityConnect = cmds.connectDynamic(particleName, f=gravityName)

        # Change particle render type
        cmds.setAttr(particleShape + ".particleRenderType", 6)

        # Create turbulence field
        cmds.select(particleName)
        _turbulence = cmds.turbulence()
        turbulenceName = _turbulence[1]
        cmds.connectDynamic(particleShape, f=turbulenceName)
        turb_magnitude = self.get_float_value(self.turbulence_magnitude)
        cmds.setAttr(turbulenceName+".magnitude", turb_magnitude)
        cmds.setAttr(turbulenceName+".attenuation", 0) # Attenuation at 0 for
        cmds.setAttr(turbulenceName+".frequency", 50)

        # Create vortex field
        cmds.select(particleName)
        vortex = cmds.vortex()
        vortexName = vortex[1]
        vortexConnect = cmds.connectDynamic(particleShape,f=vortexName)

        vort_magnitude = self.get_float_value(self.vortex_magnitude)
        print vort_magnitude

        # Update Vortex Attributes
        cmds.setAttr(vortexName+".magnitude",  vort_magnitude)

        # Make raindrops past the bounds of the surface plane
        cmds.setAttr(emitterName+".minDistance", 1)
        cmds.setAttr(emitterName+".maxDistance", 1)

        # Set raindrops speed
        cmds.setAttr(emitterName+".speedRandom", 0.9)
        cmds.setAttr(emitterName+".tangentSpeed", 1.5)

        wind_speed = self.get_float_value(self.rain_speed)
        cmds.setAttr(emitterName+".speed", wind_speed)

        print "Raindrops speed added."
        # Create surface for collisions (should be selected in the beginning, if not, a new surface will be created)
        #if self.selected_surface is None:
        groundName, groundShape = cmds.polyPlane(n="groundSurface", sx=10, sy=10, width=25, height=25)

        # Set resilience
        resilience = self.get_float_value(self.surface_resilience)
        cmds.select(particleName, r=True)
        cmds.select(groundName, add=True)
        cmds.collision(groundName, particleName, r=resilience)
        cmds.connectDynamic(particleName, c=groundName)
        print "Collisions added."

        # Split the raindrops on collision
        splitName, splitShape = cmds.particle(inherit=0.5, name="splitParticle")
        #print splitName, splitShape

        cmds.event(particleName, split=3, t=splitShape, spread=0.5, random=False)
        cmds.setAttr(splitShape+".inheritFactor", 0.5)
        print "Raindrop splits added."

        # Add the gravity field to newly split particles
        cmds.select(gravityName, r=True)
        cmds.select(splitShape, add=True)
        cmds.connectDynamic(splitShape, f=gravityName)
        print "Gravity field added."
             max=3,
             dv=2)

part_attrs = {
    'colorAccum': False,
    'useLighting': True,
    'particleRenderType': 0,
}

for attr, value in part_attrs.items():
    cmds.setAttr('%s.%s' % (part[1], attr), value)

#Adding fields
#This code selects the particles so the gravity field can be added
cmds.select(part)
drop_grav = cmds.gravity(part, m=15, dy=-1)
cmds.connectDynamic(part, f='gravityField1')

#Reselect Particles to add in the radial field
cmds.select(part)
radial_drop = cmds.radial(part, m=0.010)
cmds.connectDynamic(part, f=radial_drop[0])

#Create Partilce Mist from the Particle Tool
mist_part_1 = cmds.particle(n='mist', c=0)
mist_part_2 = cmds.particle(n='mist1', c=0)
cmds.select(mist_part_1[0])
cmds.connectDynamic(mist_part_1[0], em=emit[0])
cmds.select(mist_part_2[0])
cmds.connectDynamic(mist_part_2[0], em=emit[0])
#Didn't add in all of the attributes for multipoint, just what was directed in the tutorial
#Turn on Use Lighting
cmds.setAttr('dropletsShape.useLighting', True)

#Point Size to 1
cmds.setAttr('dropletsShape.pointSize', 1)
'''

#Adding Fields
'''
gravity -pos 0 0 0 -m 9.8 -att 0 -dx 0 -dy -1 -dz 0  -mxd -1  -vsh none -vex 0 -vof 0 0 0 -vsw 360 -tsr 0.5 ;
// gravityField1 //
#Select particles before adding in fields
'''
cmds.select('droplets')
cmds.gravity('droplets', m=15, dy=-1)
cmds.connectDynamic('droplets', f='gravityField1')
#Reselect Particles
cmds.select('droplets')
cmds.radial('droplets', m=0.010)
cmds.connectDynamic('droplets', f='radialField1')

#Create Partilce Mist from the Particle Tool
cmds.particle(n='mist', c=0)
cmds.particle(n='mist1', c=0)
cmds.select('mist')
cmds.connectDynamic('mist', em=emit[0])
cmds.select('mist1')
cmds.connectDynamic('mist1', em=emit[0])

#Add gravityField1 and radialField1 to mist and mist1 through dynamicRelationship editor
示例#17
0
mygrid = cmds.polyPlane(name='emi')
cmds.setAttr("emi.rotateX", -45)
cmds.setAttr("emi.translateZ", 10)
cmds.setAttr("emi.translateY", 10)
cmds.setAttr("emi.scaleX", 30)
cmds.setAttr("emi.scaleY", 20)
cmds.setAttr("emi.scaleZ", 20)

cmds.select('emi')
myem = cmds.emitter(name='myEmitter', speed=30, speedRandom=10, rate=0.005)
mypa = cmds.particle(name='myParticle')
cmds.connectDynamic(mypa[0], em=myem)

cmds.setAttr("myEmitter.emitterType", 2)

mygr = cmds.gravity(name='myGravity')
cmds.connectDynamic(mypa, f=mygr)
cmds.setAttr("myGravity.magnitude", 4)

cmds.select('pCone1', 'myParticle')
cmds.particleInstancer("myParticle", object='pCone1', aimDirection='velocity')

cmds.select('myParticle')
myem2 = cmds.emitter(name='trailEmitter',
                     rate=1000,
                     spread=1,
                     speed=4,
                     speedRandom=3)
mypa2 = cmds.particle(name='trailParticle')
cmds.connectDynamic(mypa2[0], em=myem2)
示例#18
0
              sx=10,
              sy=1,
              sz=10,
              ax=(0, 1, 0),
              name='floor')
cmds.setAttr('floor.translateY', -15)
''' Initiate rigidSolvers 
mySphere should interact with shards created from myPlane
Shards created below by way of cutObject should interact
'''
cmds.rigidSolver(create=True, name='rigidSolver1')
cmds.select('floor')
cmds.rigidBody(passive=True,
               solver='rigidSolver1',
               name='passiveRigidBodyFloor')
cmds.gravity(pos=(0, 0, 0), m=9.8, dx=0, dy=-1, dz=0, name='gravityField')

fracturePosition = cmds.objectCenter(myPlane, gl=True)
print("Fracture position")
print(fracturePosition)

centerPoints = generateVoronoiPoints(fracturePosition)
shatteredPlane = cutObject(myPlane, centerPoints)

shards = cmds.listRelatives(shatteredPlane, children=True)

for i in range(len(shards)):
    cmds.select(shards[i])
    cmds.rigidBody(active=True, solver='rigidSolver1', name='shard' + str(i))
    #cmds.connectDynamic('shard' + str(i), f='gravityField')
示例#19
0
    def buildSplash(self):
        objectName = str(self.getObject.text())
        if self.checkWake.isChecked() == True:
            wakeEmitter = str(self.getWake.text())
        else:
            wakeEmitter = "OceanWakeEmitter1"
        if self.checkOcean.isChecked() == True:
            oceanShader = str(self.getOcean.text())
        else:
            oceanShader = "oceanShader1"

        ###Bcreating Splash Disc
        objectNameAxis = generator.getMaxAndMinAxis(objectName)
        #generator_Return: 0-maxX, 1-minX, 2-maxY, 3-minY, 4-maxZ, 5-minZ
        avrgX = objectNameAxis[0] - objectNameAxis[1]
        avrgZ = objectNameAxis[4] - objectNameAxis[5]
        avrgY = objectNameAxis[2] - objectNameAxis[3]
        if avrgX > avrgZ:
            SplashCurve = avrgX
        else:
            SplashCurve = avrgZ
        baseCurve = cmds.circle(name="base",
                                normal=[0, 1, 0],
                                radius=SplashCurve / 1.5)
        headCurve = cmds.circle(name="head",
                                normal=[0, 1, 0],
                                radius=SplashCurve / 2)
        cmds.move(0, (avrgY / 4), 0, headCurve)
        cmds.rebuildCurve("base",
                          ch=1,
                          rpo=1,
                          rt=0,
                          end=1,
                          kr=0,
                          kcp=0,
                          kep=0,
                          kt=0,
                          s=100,
                          d=7,
                          tol=0.01)
        cmds.rebuildCurve("head",
                          ch=1,
                          rpo=1,
                          rt=0,
                          end=1,
                          kr=0,
                          kcp=0,
                          kep=0,
                          kt=0,
                          s=100,
                          d=7,
                          tol=0.01)
        splashDisc = cmds.loft("base",
                               "head",
                               name="%s_SplashDisc" % objectName,
                               ch=1,
                               u=1,
                               c=0,
                               ar=1,
                               d=3,
                               ss=int(avrgY + 1),
                               rn=0,
                               po=0,
                               rsn=True)
        #Return: 0-SplashDisc, 1-loft1
        cmds.delete(baseCurve, headCurve)
        cmds.setAttr("%s.visibility" % splashDisc[0], False)
        objectPosition = cmds.xform(objectName,
                                    query=True,
                                    translation=True,
                                    worldSpace=True)
        cmds.move(objectPosition[0], 0, objectPosition[2], splashDisc[0])

        ###adding emitter and particle to Object
        objectNameEmitter = cmds.emitter(objectName,
                                         type='surface',
                                         rate=0,
                                         scaleRateByObjectSize=False,
                                         needParentUV=False,
                                         cycleEmission="none",
                                         cycleInterval=1,
                                         speed=1,
                                         speedRandom=0,
                                         normalSpeed=1,
                                         tangentSpeed=0,
                                         maxDistance=0,
                                         minDistance=0,
                                         directionX=1,
                                         directionY=0,
                                         directionZ=0,
                                         spread=0,
                                         name="%s_emitter" % objectName)
        #Return: 0-objectName, 1-objectName_emitter
        objectNameParticle = cmds.particle(name="%s_particle" % objectName)
        cmds.connectDynamic(objectNameParticle[0],
                            emitters=objectNameEmitter[0])
        ###adding emitter and particle to Splash Disc
        splashDiscEmitter = cmds.emitter(splashDisc[0],
                                         type='surface',
                                         rate=0,
                                         scaleRateByObjectSize=False,
                                         needParentUV=False,
                                         cycleEmission="none",
                                         cycleInterval=1,
                                         speed=1,
                                         speedRandom=1.5,
                                         normalSpeed=1,
                                         tangentSpeed=0,
                                         maxDistance=0,
                                         minDistance=0,
                                         directionX=1,
                                         directionY=0,
                                         directionZ=0,
                                         spread=0,
                                         name="%s_emitter" % splashDisc[0])
        #Return: 0-SplashDisc, 1-SplashDisc_emitter
        splashDiscParticle = cmds.particle(name="%s_particle" % splashDisc[0])
        cmds.connectDynamic(splashDiscParticle[0],
                            emitters=splashDiscEmitter[0])

        #connecting the X and Z object position to Splash Disc to follow
        cmds.connectAttr("%s.translate.translateZ" % objectName,
                         "%s.translate.translateZ" % splashDisc[0])
        cmds.connectAttr("%s.translate.translateX" % objectName,
                         "%s.translate.translateX" % splashDisc[0])

        #setting up the splash Disc particle Setting
        cmds.setAttr("%s.lifespanMode" % splashDiscParticle[1], 3)
        cmds.setAttr("%s.lifespanRandom" % splashDiscParticle[1], 0.5)
        cmds.setAttr("%s.conserve" % splashDiscParticle[1], 0.983)
        cmds.setAttr("%s.inheritFactor" % splashDiscParticle[1], 0.2)
        cmds.setAttr("%s.particleRenderType" % splashDiscParticle[1], 5)
        cmds.addAttr(splashDiscParticle[1],
                     keyable=True,
                     ln="useLighting",
                     at="bool",
                     dv=False)
        cmds.addAttr(splashDiscParticle[1],
                     ln="spriteScaleYPP",
                     dt="doubleArray")
        cmds.addAttr(splashDiscParticle[1],
                     ln="spriteScaleYPP0",
                     dt="doubleArray")
        cmds.addAttr(splashDiscParticle[1],
                     ln="spriteScaleXPP",
                     dt="doubleArray")
        cmds.addAttr(splashDiscParticle[1],
                     ln="spriteScaleXPP0",
                     dt="doubleArray")
        cmds.addAttr(splashDiscParticle[1],
                     ln="spriteTwistPP",
                     dt="doubleArray")
        cmds.addAttr(splashDiscParticle[1],
                     ln="spriteTwistPP0",
                     dt="doubleArray")
        #creating Ramp for Splash Disc particle
        splashDiscParticle_spriteScaleXPP = cmds.arrayMapper(
            target=splashDiscParticle[1],
            destAttr="spriteScaleXPP",
            inputV="ageNormalized",
            type="ramp")
        ramp_spriteScaleXPP = cmds.listConnections(
            splashDiscParticle_spriteScaleXPP, type="ramp")
        ramp_spriteScaleXPP = cmds.rename(
            ramp_spriteScaleXPP[1],
            "%s_spriteScaleXPP_Rampe" % splashDiscParticle[1])
        cmds.setAttr("%s.colorEntryList[2].color" % ramp_spriteScaleXPP, 0, 0,
                     0)
        cmds.setAttr("%s.colorEntryList[2].position" % ramp_spriteScaleXPP, 1)
        cmds.setAttr("%s.colorEntryList[1].color" % ramp_spriteScaleXPP, 0.5,
                     0.5, 0.5)
        cmds.setAttr("%s.colorEntryList[1].position" % ramp_spriteScaleXPP,
                     0.165)
        cmds.setAttr("%s.colorEntryList[0].color" % ramp_spriteScaleXPP, 1, 1,
                     1)
        cmds.setAttr("%s.colorEntryList[0].position" % ramp_spriteScaleXPP, 0)

        splashDiscParticle_spriteScaleYPP = cmds.arrayMapper(
            target=splashDiscParticle[1],
            destAttr="spriteScaleYPP",
            inputV="ageNormalized",
            type="ramp")
        ramp_spriteScaleYPP = cmds.listConnections(
            splashDiscParticle_spriteScaleYPP, type="ramp")
        ramp_spriteScaleYPP = cmds.rename(
            ramp_spriteScaleYPP[1],
            "%s_SpriteScaleYPP_Rampe" % splashDiscParticle[1])
        cmds.setAttr("%s.colorEntryList[2].color" % ramp_spriteScaleYPP, 0, 0,
                     0)
        cmds.setAttr("%s.colorEntryList[2].position" % ramp_spriteScaleYPP, 1)
        cmds.setAttr("%s.colorEntryList[1].color" % ramp_spriteScaleYPP, 0.5,
                     0.5, 0.5)
        cmds.setAttr("%s.colorEntryList[1].position" % ramp_spriteScaleYPP,
                     0.165)
        cmds.setAttr("%s.colorEntryList[0].color" % ramp_spriteScaleYPP, 1, 1,
                     1)
        cmds.setAttr("%s.colorEntryList[0].position" % ramp_spriteScaleYPP, 0)

        #setting up the object particle Setting
        cmds.setAttr("%s.lifespanMode" % objectNameParticle[1], 3)
        cmds.setAttr("%s.particleRenderType" % objectNameParticle[1], 7)
        cmds.addAttr(objectNameParticle[1],
                     keyable=True,
                     ln="threshold",
                     at="float",
                     min=0,
                     max=10,
                     dv=0.7)
        cmds.addAttr(objectNameParticle[1],
                     keyable=True,
                     ln="radius",
                     at="float",
                     min=0,
                     max=10,
                     dv=0.5)
        cmds.addAttr(objectNameParticle[1], ln="radiusPP", dt="doubleArray")
        #creating Ramp for object particle
        objectNameParticle_radiusPP = cmds.arrayMapper(
            target=objectNameParticle[1],
            destAttr="radiusPP",
            inputV="ageNormalized",
            type="ramp")
        ramp_radiusPP = cmds.listConnections(objectNameParticle_radiusPP,
                                             type="ramp")
        ramp_radiusPP = cmds.rename(
            ramp_radiusPP[1], "%s_RadiusPP_Rampe" % objectNameParticle[1])
        cmds.setAttr("%s.colorEntryList[3].color" % ramp_radiusPP, 0.056,
                     0.056, 0.056)
        cmds.setAttr("%s.colorEntryList[3].position" % ramp_radiusPP, 1)
        cmds.setAttr("%s.colorEntryList[2].color" % ramp_radiusPP, 0.223,
                     0.223, 0.223)
        cmds.setAttr("%s.colorEntryList[2].position" % ramp_radiusPP, 0.690)
        cmds.setAttr("%s.colorEntryList[1].color" % ramp_radiusPP, 0.178,
                     0.178, 0.178)
        cmds.setAttr("%s.colorEntryList[1].position" % ramp_radiusPP, 0.455)
        cmds.setAttr("%s.colorEntryList[0].color" % ramp_radiusPP, 0, 0, 0)
        cmds.setAttr("%s.colorEntryList[0].position" % ramp_radiusPP, 0)

        #adding gravity to SplashDisc
        splashDiscGravity = cmds.gravity(name="%s_GravityField" %
                                         splashDiscParticle[0],
                                         pos=[0, 0, 0],
                                         m=9.8,
                                         att=0,
                                         dx=0,
                                         dy=-1,
                                         dz=0,
                                         mxd=-1,
                                         vsh="none",
                                         vex=0,
                                         vof=[0, 0, 0],
                                         vsw=360,
                                         tsr=0.5)
        cmds.connectDynamic(splashDiscParticle[0], fields=splashDiscGravity)

        #adding gravity to Object
        objectNameGravity = cmds.uniform(name="%s_UniformField" %
                                         objectNameParticle[0],
                                         pos=[0, 0, 0],
                                         m=5,
                                         att=1,
                                         dx=1,
                                         dy=-1,
                                         dz=0,
                                         mxd=-1,
                                         vsh="none",
                                         vex=0,
                                         vof=[0, 0, 0],
                                         vsw=360,
                                         tsr=0.5)
        cmds.connectDynamic(objectNameParticle[0], fields=objectNameGravity)
        print objectNameGravity
        cmds.setAttr("%s.directionX" % objectNameGravity[0], 0)
        cmds.setAttr("%s.directionY" % objectNameGravity[0], 1)
        cmds.setAttr("%s.directionZ" % objectNameGravity[0], 0)
        cmds.setAttr("%s.magnitude" % objectNameGravity[0], 28)

        #adding Expression for Object and SplashDisc
        generator.objectNameParticleExpressionBeforeDynamics(
            objectNameParticle[1], oceanShader)
        generator.splashDiscParticleExpressionBeforeDynamics(
            splashDiscParticle[1], oceanShader)
        generator.splashDiscParticleExpressionAfterDynamics(
            splashDiscParticle[1])
        generator.splashDiscParticleExpressionCreation(splashDiscParticle[1])
        if "ocean_MainExpression" not in cmds.ls():
            generator.createMainExpression(objectNameEmitter[1])
        if "ocean_MainExpression" in cmds.ls():
            generator.editMainExpression(objectName, splashDiscEmitter[0],
                                         oceanShader, objectNameEmitter[1],
                                         wakeEmitter, splashDiscEmitter[1])
#         num=0
        if "mainSplashDisc_Shader" not in cmds.ls():
            generator.shaderSetup()
            #             cmds.select(splashDiscEmitter[0], replace=True)
            #             cmds.sets(edit=True,forceElement="mainSplashDisc_ShaderSG")
            cmds.sets(splashDiscParticle,
                      edit=True,
                      forceElement='mainSplashDisc_ShaderSG')
        else:
            cmds.sets(splashDiscParticle,
                      edit=True,
                      forceElement='mainSplashDisc_ShaderSG')
#             while cmds.connectionInfo("mainSplashDisc_ShaderSG.dagSetMembers[%s]"%num,getExactDestination=True) != "":
#                 num+=1
#             cmds.connectAttr(splashDiscEmitter[1] + ".instObjGroups[0]", "mainSplashDisc_Shader.dagSetMembers[%s]"%num, force = True)
#         else:
#             while cmds.connectionInfo("mainSplashDisc_ShaderSG.dagSetMembers[%s]"%num,getExactDestination=True) != "":
#                 num+=1
#             cmds.connectAttr(splashDiscEmitter[1] + ".instObjGroups[0]", "mainSplashDisc_Shader.dagSetMembers[%s]"%num, force = True)
#         pSphere1_SplashDisc.translateX = pSphere1.translateX;
#         pSphere1_SplashDisc.translateZ = pSphere1.translateZ;
        return
示例#20
0
def create_jiggle_locator(position_object, base_name):
    """Create jiggle rig at the specified postion, you will then need to make sure
    this jiggle rig is hooked up to be driven by the source rig

    Usage:
        create_jiggle_locator('ball', 'my_jiggle')
    """
    if cmds.objExists(position_object):
        # Get position of input object
        pos = cmds.xform(position_object, q=True, ws=True, t=True)

        # Create single particle
        part = cmds.particle(p=[pos[0], (pos[1]), pos[2]],
                             c=1,
                             name='{}_particle'.format(base_name))
        cmds.setAttr("{}.particleRenderType".format(part[1]), 4)

        # Goal particle to source object
        cmds.goal(part[0], goal=position_object, w=0.5, utr=True)

        # Create output transform
        jiggle_output = cmds.spaceLocator(name="{}_ctl".format(base_name))[0]
        cmds.connectAttr("{}.worldCentroid".format(part[1]),
                         '{}.translate'.format(jiggle_output))

        # Create jiggle control
        for attr in ['rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v']:
            cmds.setAttr('{}.{}'.format(jiggle_output, attr),
                         k=False,
                         lock=True)

        # Add gravity
        grav = \
        cmds.gravity(name='{}_gravity'.format(base_name), pos=[0, 0, 0], m=100, att=0, dx=0, dy=-1, dz=0, mxd=-1)[
            0]  # , vsh=none -vex 0 -vof 0 0 0 -vsw 360 -tsr 0.5 ;
        cmds.connectDynamic(part, f=grav)

        # Add attrs: isDynamic=on, conserve=1.0, goalWeight[0]=1.0, goalSmoothness=3, gravity=9.8
        cmds.addAttr(jiggle_output, ln="JIGGLE", at="enum", en="__:")
        cmds.setAttr('{}.JIGGLE'.format(jiggle_output), cb=True)

        # Enabled
        cmds.addAttr(jiggle_output, ln="enabled", at="bool")
        cmds.setAttr('{}.enabled'.format(jiggle_output), k=True, l=False)
        cmds.setAttr('{}.enabled'.format(jiggle_output), 1)
        cmds.connectAttr('{}.enabled'.format(jiggle_output),
                         '{}.isDynamic'.format(part[1]))

        # Dynamics Weight
        """
        cmds.addAttr(jiggle_output, ln="dynamicsWeight", at="double", min=0, max=1, dv=1)
        cmds.setAttr('{}.dynamicsWeight'.format(jiggle_output), k=True, l=False)
        cmds.connectAttr('{}.dynamicsWeight'.format(jiggle_output), '{}.dynamicsWeight'.format(part[1]))
        """
        # Conserve
        cmds.addAttr(jiggle_output,
                     ln="conserve",
                     at="double",
                     min=0,
                     max=1,
                     dv=1)
        cmds.setAttr('{}.conserve'.format(jiggle_output), k=True, l=False)
        cmds.connectAttr('{}.conserve'.format(jiggle_output),
                         '{}.conserve'.format(part[1]))

        # Goal Smoothness
        cmds.addAttr(jiggle_output,
                     ln="goalSmoothness",
                     at="double",
                     min=0,
                     dv=3)
        cmds.setAttr('{}.goalSmoothness'.format(jiggle_output),
                     k=True,
                     l=False)
        cmds.connectAttr('{}.goalSmoothness'.format(jiggle_output),
                         '{}.goalSmoothness'.format(part[1]))

        # Goal Weight
        cmds.addAttr(jiggle_output,
                     ln="goalWeight",
                     at="double",
                     min=0,
                     max=1.0,
                     dv=.5)
        cmds.setAttr('{}.goalWeight'.format(jiggle_output), k=True, l=False)
        cmds.connectAttr('{}.goalWeight'.format(jiggle_output),
                         '{}.goalWeight[0]'.format(part[1]))

        cmds.addAttr(jiggle_output, ln="GRAVITY", at="enum", en="__:")
        cmds.setAttr('{}.GRAVITY'.format(jiggle_output), cb=True)

        # Gravity
        cmds.addAttr(jiggle_output,
                     ln="gravityMagnitude",
                     at="double",
                     min=0,
                     dv=100)
        cmds.setAttr('{}.gravityMagnitude'.format(jiggle_output),
                     k=True,
                     l=False)
        cmds.connectAttr('{}.gravityMagnitude'.format(jiggle_output),
                         '{}.magnitude'.format(grav))

        # Gravity Direction
        cmds.addAttr(jiggle_output, ln="gravityDirection", at="double3")
        cmds.addAttr(jiggle_output,
                     ln="gravityDirectionX",
                     at="double",
                     p="gravityDirection",
                     dv=0)
        cmds.addAttr(jiggle_output,
                     ln="gravityDirectionY",
                     at="double",
                     p="gravityDirection",
                     dv=-1)
        cmds.addAttr(jiggle_output,
                     ln="gravityDirectionZ",
                     at="double",
                     p="gravityDirection",
                     dv=0)

        cmds.setAttr('{}.gravityDirection'.format(jiggle_output),
                     k=True,
                     l=False)
        cmds.setAttr('{}.gravityDirectionX'.format(jiggle_output),
                     k=True,
                     l=False)
        cmds.setAttr('{}.gravityDirectionY'.format(jiggle_output),
                     k=True,
                     l=False)
        cmds.setAttr('{}.gravityDirectionZ'.format(jiggle_output),
                     k=True,
                     l=False)

        cmds.connectAttr('{}.gravityDirectionX'.format(jiggle_output),
                         '{}.directionX'.format(grav))
        cmds.connectAttr('{}.gravityDirectionY'.format(jiggle_output),
                         '{}.directionY'.format(grav))
        cmds.connectAttr('{}.gravityDirectionZ'.format(jiggle_output),
                         '{}.directionZ'.format(grav))

        # Cleanup
        jiggle_group = cmds.group(empty=True,
                                  name="{}All_grp".format(base_name))
        cmds.parent(part[0], jiggle_output, grav, jiggle_group)

        cmds.select(jiggle_output)
        return jiggle_output
    cmds.setKeyframe( pObjectName, time=pStartTime, attribute=pTargetAttribute, value=0 )
    
    cmds.setKeyframe( pObjectName, time=pEndTime, attribute=pTargetAttribute, value=360 )
    
    cmds.selectKey( pObjectName, time=(pStartTime, pEndTime), attribute=pTargetAttribute, keyframe=True )
    
    cmds.keyTangent( inTangentType='linear', outTangentType='linear' )


### Main script ###

selected = cmds.ls( selection=True, type='transform' )

if len( selected ) > 0:
    
    # Set animation keyframes at start and end of playback
    startTime = cmds.playbackOptions( query=True, minTime=True )
    endTime = cmds.playbackOptions( query=True, maxTime=True )
    
    #cmds.gravity(selected)
    
    for object in selected: 
        # Apply gravity!?
        # But first: Rotate!
        keyFullRotation( object, startTime, endTime, 'rotateY' )
        #applyGravity(object)
        cmds.gravity( object )
        

else: 
    print 'Please select at least one object'
示例#22
0
    def buildSplash(self):            
        objectName = str(self.getObject.text())
        if self.checkWake.isChecked()==True:
            wakeEmitter = str(self.getWake.text())
        else:
            wakeEmitter = "OceanWakeEmitter1"
        if self.checkOcean.isChecked()==True:
            oceanShader = str(self.getOcean.text())
        else:
            oceanShader = "oceanShader1"
        
        ###Bcreating Splash Disc
        objectNameAxis = generator.getMaxAndMinAxis(objectName)
        #generator_Return: 0-maxX, 1-minX, 2-maxY, 3-minY, 4-maxZ, 5-minZ
        avrgX = objectNameAxis[0] - objectNameAxis[1]
        avrgZ = objectNameAxis[4] - objectNameAxis[5]
        avrgY = objectNameAxis[2] - objectNameAxis[3]
        if avrgX > avrgZ:
            SplashCurve = avrgX
        else:
            SplashCurve = avrgZ
        baseCurve = cmds.circle(name="base",normal=[0,1,0],radius=SplashCurve/1.5)
        headCurve = cmds.circle(name="head",normal=[0,1,0],radius=SplashCurve/2)
        cmds.move(0,(avrgY/4),0,headCurve)
        cmds.rebuildCurve ("base", ch=1, rpo=1, rt=0, end=1, kr=0, kcp=0, kep=0, kt=0, s=100, d=7, tol=0.01)
        cmds.rebuildCurve ("head", ch=1, rpo=1, rt=0, end=1, kr=0, kcp=0, kep=0, kt=0, s=100, d=7, tol=0.01)
        splashDisc = cmds.loft ("base", "head",name="%s_SplashDisc"%objectName, ch=1, u=1, c=0, ar=1, d=3, ss=int(avrgY+1), rn=0, po=0, rsn=True)
        #Return: 0-SplashDisc, 1-loft1
        cmds.delete(baseCurve,headCurve)    
        cmds.setAttr("%s.visibility"%splashDisc[0], False )
        objectPosition = cmds.xform(objectName, query=True, translation=True, worldSpace=True )
        cmds.move(objectPosition[0], 0, objectPosition[2], splashDisc[0])
        
        ###adding emitter and particle to Object
        objectNameEmitter = cmds.emitter(objectName,type='surface',rate=0,scaleRateByObjectSize=False,needParentUV=False,cycleEmission="none",
                           cycleInterval=1,speed=1,speedRandom=0,normalSpeed=1,tangentSpeed=0,maxDistance=0,minDistance=0,
                           directionX=1,directionY=0,directionZ=0,spread=0,name="%s_emitter"%objectName)
        #Return: 0-objectName, 1-objectName_emitter
        objectNameParticle = cmds.particle(name="%s_particle"%objectName)
        cmds.connectDynamic(objectNameParticle[0],emitters=objectNameEmitter[0])
        ###adding emitter and particle to Splash Disc
        splashDiscEmitter = cmds.emitter(splashDisc[0],type='surface',rate=0,scaleRateByObjectSize=False,needParentUV=False,cycleEmission="none",
                           cycleInterval=1,speed=1,speedRandom=1.5,normalSpeed=1,tangentSpeed=0,maxDistance=0,minDistance=0,
                           directionX=1,directionY=0,directionZ=0,spread=0,name="%s_emitter"%splashDisc[0])
        #Return: 0-SplashDisc, 1-SplashDisc_emitter
        splashDiscParticle = cmds.particle(name="%s_particle"%splashDisc[0])
        cmds.connectDynamic(splashDiscParticle[0],emitters=splashDiscEmitter[0])
        
        #connecting the X and Z object position to Splash Disc to follow 
        cmds.connectAttr("%s.translate.translateZ"%objectName, "%s.translate.translateZ"%splashDisc[0])
        cmds.connectAttr("%s.translate.translateX"%objectName, "%s.translate.translateX"%splashDisc[0])
        
        #setting up the splash Disc particle Setting 
        cmds.setAttr("%s.lifespanMode"%splashDiscParticle[1],3)
        cmds.setAttr("%s.lifespanRandom"%splashDiscParticle[1],0.5)
        cmds.setAttr("%s.conserve"%splashDiscParticle[1],0.983)
        cmds.setAttr("%s.inheritFactor"%splashDiscParticle[1],0.2)
        cmds.setAttr("%s.particleRenderType"%splashDiscParticle[1],5)
        cmds.addAttr(splashDiscParticle[1], keyable=True, ln="useLighting", at="bool", dv=False)
        cmds.addAttr(splashDiscParticle[1], ln="spriteScaleYPP", dt="doubleArray")
        cmds.addAttr(splashDiscParticle[1], ln="spriteScaleYPP0", dt="doubleArray")
        cmds.addAttr(splashDiscParticle[1], ln="spriteScaleXPP", dt="doubleArray")
        cmds.addAttr(splashDiscParticle[1], ln="spriteScaleXPP0", dt="doubleArray")
        cmds.addAttr(splashDiscParticle[1], ln="spriteTwistPP", dt="doubleArray")
        cmds.addAttr(splashDiscParticle[1], ln="spriteTwistPP0", dt="doubleArray")
        #creating Ramp for Splash Disc particle
        splashDiscParticle_spriteScaleXPP = cmds.arrayMapper(target=splashDiscParticle[1], destAttr="spriteScaleXPP", inputV="ageNormalized", type="ramp")
        ramp_spriteScaleXPP = cmds.listConnections(splashDiscParticle_spriteScaleXPP, type="ramp")
        ramp_spriteScaleXPP = cmds.rename(ramp_spriteScaleXPP[1], "%s_spriteScaleXPP_Rampe"%splashDiscParticle[1])
        cmds.setAttr("%s.colorEntryList[2].color"%ramp_spriteScaleXPP, 0,0,0)
        cmds.setAttr("%s.colorEntryList[2].position"%ramp_spriteScaleXPP, 1)
        cmds.setAttr("%s.colorEntryList[1].color"%ramp_spriteScaleXPP, 0.5,0.5,0.5)
        cmds.setAttr("%s.colorEntryList[1].position"%ramp_spriteScaleXPP, 0.165)
        cmds.setAttr("%s.colorEntryList[0].color"%ramp_spriteScaleXPP, 1,1,1)
        cmds.setAttr("%s.colorEntryList[0].position"%ramp_spriteScaleXPP, 0)
        
        splashDiscParticle_spriteScaleYPP = cmds.arrayMapper(target=splashDiscParticle[1], destAttr="spriteScaleYPP", inputV="ageNormalized", type="ramp")
        ramp_spriteScaleYPP = cmds.listConnections(splashDiscParticle_spriteScaleYPP, type="ramp")
        ramp_spriteScaleYPP = cmds.rename(ramp_spriteScaleYPP[1], "%s_SpriteScaleYPP_Rampe"%splashDiscParticle[1])
        cmds.setAttr("%s.colorEntryList[2].color"%ramp_spriteScaleYPP, 0,0,0)
        cmds.setAttr("%s.colorEntryList[2].position"%ramp_spriteScaleYPP, 1)
        cmds.setAttr("%s.colorEntryList[1].color"%ramp_spriteScaleYPP, 0.5,0.5,0.5)
        cmds.setAttr("%s.colorEntryList[1].position"%ramp_spriteScaleYPP, 0.165)
        cmds.setAttr("%s.colorEntryList[0].color"%ramp_spriteScaleYPP, 1,1,1)
        cmds.setAttr("%s.colorEntryList[0].position"%ramp_spriteScaleYPP, 0)
         
        #setting up the object particle Setting 
        cmds.setAttr("%s.lifespanMode"%objectNameParticle[1],3)
        cmds.setAttr("%s.particleRenderType"%objectNameParticle[1],7)
        cmds.addAttr(objectNameParticle[1], keyable=True, ln="threshold", at="float", min=0, max=10, dv=0.7)
        cmds.addAttr(objectNameParticle[1], keyable=True, ln="radius", at="float", min=0, max=10, dv=0.5)
        cmds.addAttr (objectNameParticle[1], ln="radiusPP", dt="doubleArray")
        #creating Ramp for object particle
        objectNameParticle_radiusPP = cmds.arrayMapper(target=objectNameParticle[1], destAttr="radiusPP", inputV="ageNormalized", type="ramp")
        ramp_radiusPP = cmds.listConnections(objectNameParticle_radiusPP, type="ramp")
        ramp_radiusPP = cmds.rename(ramp_radiusPP[1], "%s_RadiusPP_Rampe"%objectNameParticle[1])
        cmds.setAttr("%s.colorEntryList[3].color"%ramp_radiusPP, 0.056,0.056,0.056)
        cmds.setAttr("%s.colorEntryList[3].position"%ramp_radiusPP, 1)
        cmds.setAttr("%s.colorEntryList[2].color"%ramp_radiusPP, 0.223,0.223,0.223)
        cmds.setAttr("%s.colorEntryList[2].position"%ramp_radiusPP, 0.690)
        cmds.setAttr("%s.colorEntryList[1].color"%ramp_radiusPP, 0.178,0.178,0.178)
        cmds.setAttr("%s.colorEntryList[1].position"%ramp_radiusPP, 0.455)
        cmds.setAttr("%s.colorEntryList[0].color"%ramp_radiusPP, 0,0,0)
        cmds.setAttr("%s.colorEntryList[0].position"%ramp_radiusPP, 0)
         
        #adding gravity to SplashDisc
        splashDiscGravity = cmds.gravity(name="%s_GravityField"%splashDiscParticle[0], pos=[0,0,0], m=9.8, att=0, dx=0, dy=-1, dz=0, mxd=-1, vsh="none", vex=0, vof=[0,0,0], vsw=360, tsr=0.5)
        cmds.connectDynamic(splashDiscParticle[0], fields=splashDiscGravity)
         
        #adding gravity to Object
        objectNameGravity = cmds.uniform(name="%s_UniformField"%objectNameParticle[0], pos=[0,0,0], m=5, att=1, dx=1, dy=-1, dz=0, mxd=-1, vsh="none", vex=0, vof=[0,0,0], vsw=360, tsr=0.5)
        cmds.connectDynamic(objectNameParticle[0], fields=objectNameGravity)
        print objectNameGravity
        cmds.setAttr("%s.directionX"%objectNameGravity[0],0)
        cmds.setAttr("%s.directionY"%objectNameGravity[0],1)
        cmds.setAttr("%s.directionZ"%objectNameGravity[0],0)
        cmds.setAttr("%s.magnitude"%objectNameGravity[0],28)
         
        #adding Expression for Object and SplashDisc
        generator.objectNameParticleExpressionBeforeDynamics(objectNameParticle[1], oceanShader)
        generator.splashDiscParticleExpressionBeforeDynamics(splashDiscParticle[1], oceanShader)
        generator.splashDiscParticleExpressionAfterDynamics(splashDiscParticle[1])
        generator.splashDiscParticleExpressionCreation(splashDiscParticle[1])
        if "ocean_MainExpression" not in cmds.ls() :
            generator.createMainExpression(objectNameEmitter[1])
        if "ocean_MainExpression" in cmds.ls() :
            generator.editMainExpression(objectName, splashDiscEmitter[0], oceanShader, objectNameEmitter[1], wakeEmitter, splashDiscEmitter[1])
#         num=0 
        if "mainSplashDisc_Shader" not in cmds.ls():
            generator.shaderSetup()
#             cmds.select(splashDiscEmitter[0], replace=True)
#             cmds.sets(edit=True,forceElement="mainSplashDisc_ShaderSG")
            cmds.sets(splashDiscParticle, edit = True, forceElement = 'mainSplashDisc_ShaderSG')
        else:
            cmds.sets(splashDiscParticle, edit = True, forceElement = 'mainSplashDisc_ShaderSG')
#             while cmds.connectionInfo("mainSplashDisc_ShaderSG.dagSetMembers[%s]"%num,getExactDestination=True) != "":
#                 num+=1
#             cmds.connectAttr(splashDiscEmitter[1] + ".instObjGroups[0]", "mainSplashDisc_Shader.dagSetMembers[%s]"%num, force = True)
#         else:     
#             while cmds.connectionInfo("mainSplashDisc_ShaderSG.dagSetMembers[%s]"%num,getExactDestination=True) != "":
#                 num+=1
#             cmds.connectAttr(splashDiscEmitter[1] + ".instObjGroups[0]", "mainSplashDisc_Shader.dagSetMembers[%s]"%num, force = True)
#         pSphere1_SplashDisc.translateX = pSphere1.translateX;
#         pSphere1_SplashDisc.translateZ = pSphere1.translateZ;
        return  
示例#23
0
    def doIt(self, args):
        # Procesar argumentos
        try:
            self.parseArgs(args)
        except Exception as e:
            print('[' + commandName + '] Sintaxis de flag invalida')
            return

        # Guardar seleccion de la superficie
        surface = cmds.ls(sl=True)

        ################################# Control maestro ###############################
        cmds.spaceLocator(name=self.controllerName)
        cmds.addAttr(ln='floor', at='double', defaultValue=self.floor)
        cmds.addAttr(ln='beginTolerance',
                     at='double',
                     defaultValue=0.3,
                     minValue=0,
                     maxValue=1)
        cmds.addAttr(ln='gravity', at='double', defaultValue=self.gravity)
        cmds.addAttr(ln='magnitudeTLow',
                     at='double',
                     defaultValue=self.turbulenceLow)
        cmds.addAttr(ln='magnitudeTHigh',
                     at='double',
                     defaultValue=self.turbulenceHigh)
        cmds.addAttr(ln='dewRate',
                     at='double',
                     defaultValue=self.dewRate,
                     minValue=0)
        cmds.addAttr(ln='spumeRate',
                     at='double',
                     defaultValue=self.spumeRate,
                     minValue=0)
        cmds.addAttr(ln='waterRate',
                     at='double',
                     defaultValue=self.waterRate,
                     minValue=0)
        cmds.setAttr(self.controllerName + '.translateX', keyable=False)
        cmds.setAttr(self.controllerName + '.translateY', keyable=False)
        cmds.setAttr(self.controllerName + '.translateZ', keyable=False)
        cmds.setAttr(self.controllerName + '.rotateX', keyable=False)
        cmds.setAttr(self.controllerName + '.rotateY', keyable=False)
        cmds.setAttr(self.controllerName + '.rotateZ', keyable=False)
        cmds.setAttr(self.controllerName + '.scaleX', keyable=False)
        cmds.setAttr(self.controllerName + '.scaleY', keyable=False)
        cmds.setAttr(self.controllerName + '.scaleZ', keyable=False)
        cmds.setAttr(self.controllerName + '.floor', keyable=True)
        cmds.setAttr(self.controllerName + '.beginTolerance', keyable=True)
        cmds.setAttr(self.controllerName + '.gravity', keyable=True)
        cmds.setAttr(self.controllerName + '.magnitudeTLow', keyable=True)
        cmds.setAttr(self.controllerName + '.magnitudeTHigh', keyable=True)
        cmds.setAttr(self.controllerName + '.dewRate', keyable=True)
        cmds.setAttr(self.controllerName + '.spumeRate', keyable=True)
        cmds.setAttr(self.controllerName + '.waterRate', keyable=True)

        ################################ Campos de fuerza ###############################
        cmds.select(clear=True)
        cmds.gravity(name=self.gravityName, att=0, dx=0, dy=-1, dz=0)
        cmds.connectAttr(self.controllerName + '.gravity',
                         self.gravityName + '.magnitude')

        cmds.select(clear=True)
        cmds.turbulence(name=self.turbulenceLowName, att=0, f=0.8, nsr=0.6)
        cmds.expression(
            s=
            "phaseX = rand(1,100)*10;\nphaseY = rand(1,100)*20;\nphaseZ = rand(1,100)*30;",
            o=self.turbulenceLowName,
            alwaysEvaluate=1)
        cmds.connectAttr(self.controllerName + '.magnitudeTLow',
                         self.turbulenceLowName + '.magnitude')

        cmds.select(clear=True)
        cmds.turbulence(name=self.turbulenceHighName, att=0, f=0.8, nsr=0.7)
        cmds.expression(
            s=
            "phaseX = time*135.165;\nphaseY = time+10*135.165;\nphaseZ = time+767*135.165;",
            o=self.turbulenceHighName,
            alwaysEvaluate=1)
        cmds.connectAttr(self.controllerName + '.magnitudeTHigh',
                         self.turbulenceHighName + '.magnitude')

        ##################################### Gotas #####################################
        # Crear sistema y emisor
        cmds.select(surface)

        cmds.emitter(n=self.dewEmitterName, type='surface', rate=self.dewRate)
        cmds.particle(n=self.dewSystemName)
        cmds.connectDynamic(self.dewSystemShapeName, em=self.dewEmitterName)
        cmds.connectAttr(self.controllerName + '.dewRate',
                         self.dewEmitterName + '.rate')

        # Agregar goal entre superficie y sistema
        cmds.select(self.dewSystemName, r=True)
        cmds.select(surface, add=True)
        cmds.goal(self.dewSystemName, g=surface, w=1, utr=0)

        cmds.connectDynamic(self.dewSystemName, f=self.gravityName)
        cmds.connectDynamic(self.dewSystemName, f=self.turbulenceLowName)
        cmds.connectDynamic(self.dewSystemName, f=self.turbulenceHighName)

        # Setear valores
        cmds.setAttr(self.dewSystemShapeName + ".conserve", 0.98)
        cmds.setAttr(self.dewSystemShapeName + ".lifespanMode",
                     3)  # only LifespanPP
        cmds.setAttr(self.dewSystemShapeName + ".particleRenderType",
                     3)  # points
        cmds.select(self.dewSystemShapeName)
        cmds.addAttr(ln='goalU', dt='doubleArray')
        cmds.addAttr(ln='goalU0', dt='doubleArray')
        cmds.addAttr(ln='goalV', dt='doubleArray')
        cmds.addAttr(ln='goalV0', dt='doubleArray')
        cmds.addAttr(ln='opacityPP', dt='doubleArray')
        cmds.addAttr(ln='opacityPP0', dt='doubleArray')
        cmds.dynExpression(self.dewSystemShapeName,
                           s="goalV = 0;\ngoalU = rand(1);\nopacityPP = 0;",
                           c=1)
        cmds.dynExpression(
            self.dewSystemShapeName,
            s="goalV += rand(0.1);\nif (goalV > " + self.controllerName +
            ".beginTolerance){\n\topacityPP = 1;\n}\nif (goalV > 0.99){\n\tgoalPP = 0;\n\tvector $pos = position;\n\tif ($pos.y < "
            + self.controllerName + ".floor){\n\t\tlifespanPP = 0;\n\t}\n}",
            rbd=1)

        ##################################### Espuma ####################################
        # Crear sistema y emisor
        cmds.select(surface)

        cmds.emitter(n=self.spumeEmitterName,
                     type='surface',
                     rate=self.spumeRate)
        cmds.particle(n=self.spumeSystemName)
        cmds.connectDynamic(self.spumeSystemShapeName,
                            em=self.spumeEmitterName)
        cmds.connectAttr(self.controllerName + '.spumeRate',
                         self.spumeEmitterName + '.rate')

        # Agregar goal entre superficie y sistema
        cmds.select(self.spumeSystemName, r=True)
        cmds.select(surface, add=True)
        cmds.goal(self.spumeSystemName, g=surface, w=1, utr=0)

        cmds.connectDynamic(self.spumeSystemName, f=self.gravityName)
        cmds.connectDynamic(self.spumeSystemName, f=self.turbulenceLowName)
        cmds.connectDynamic(self.spumeSystemName, f=self.turbulenceHighName)

        # Setear valores
        cmds.setAttr(self.spumeSystemShapeName + ".conserve", 0.98)
        cmds.setAttr(self.spumeSystemShapeName + ".lifespanMode",
                     3)  # only LifespanPP
        cmds.setAttr(self.spumeSystemShapeName + ".particleRenderType",
                     6)  # streaks
        cmds.select(self.spumeSystemShapeName)
        cmds.addAttr(ln='goalU', dt='doubleArray')
        cmds.addAttr(ln='goalU0', dt='doubleArray')
        cmds.addAttr(ln='goalV', dt='doubleArray')
        cmds.addAttr(ln='goalV0', dt='doubleArray')
        cmds.addAttr(ln='opacityPP', dt='doubleArray')
        cmds.addAttr(ln='opacityPP0', dt='doubleArray')
        cmds.dynExpression(self.spumeSystemShapeName,
                           s="goalV = 0;\ngoalU = rand(1);\nopacityPP = 0;",
                           c=1)
        cmds.dynExpression(
            self.spumeSystemShapeName,
            s="goalV += rand(0.1);\nif (goalV > " + self.controllerName +
            ".beginTolerance){\n\topacityPP = 1;\n}\nif (goalV > 0.99){\n\tgoalPP = 0;\n\tvector $pos = position;\n\tif ($pos.y < "
            + self.controllerName + ".floor){\n\t\tlifespanPP = 0;\n\t}\n}",
            rbd=1)

        ###################################### Agua #####################################
        # Crear sistema y emisor
        cmds.select(surface)

        cmds.emitter(n=self.waterEmitterName,
                     type='surface',
                     rate=self.waterRate)
        cmds.particle(n=self.waterSystemName)
        cmds.connectDynamic(self.waterSystemShapeName,
                            em=self.waterEmitterName)
        cmds.connectAttr(self.controllerName + '.waterRate',
                         self.waterEmitterName + '.rate')

        # Agregar goal entre superficie y sistema
        cmds.select(self.waterSystemName, r=True)
        cmds.select(surface, add=True)
        cmds.goal(self.waterSystemName, g=surface, w=1, utr=0)

        cmds.connectDynamic(self.waterSystemName, f=self.gravityName)
        cmds.connectDynamic(self.waterSystemName, f=self.turbulenceLowName)
        cmds.connectDynamic(self.waterSystemName, f=self.turbulenceHighName)

        # Setear valores
        cmds.setAttr(self.waterSystemShapeName + ".conserve", 0.98)
        cmds.setAttr(self.waterSystemShapeName + ".lifespanMode",
                     3)  # only LifespanPP
        cmds.setAttr(self.waterSystemShapeName + ".particleRenderType",
                     7)  # Bubble
        cmds.select(self.waterSystemShapeName)
        cmds.addAttr(ln='threshold',
                     at='float',
                     defaultValue=0.75,
                     minValue=0,
                     maxValue=10)
        #cmds.addAttr(ln='radius',at='float',defaultValue=0.75,minValue=0,maxValue=20)
        cmds.addAttr(ln='radiusPP', dt='doubleArray')
        cmds.addAttr(ln='radiusPP0', dt='doubleArray')
        cmds.setAttr(self.waterSystemShapeName + ".threshold", 0.75)
        cmds.select(self.waterSystemShapeName)
        cmds.addAttr(ln='goalU', dt='doubleArray')
        cmds.addAttr(ln='goalU0', dt='doubleArray')
        cmds.addAttr(ln='goalV', dt='doubleArray')
        cmds.addAttr(ln='goalV0', dt='doubleArray')
        cmds.dynExpression(
            self.waterSystemShapeName,
            s=
            "goalV = 0;\ngoalU = rand(1);\nif (rand(1) < 0.25){\n\tradiusPP = rand(0.7);\n} else {\n\tradiusPP = rand(1,2);\n}",
            c=1)
        cmds.dynExpression(
            self.waterSystemShapeName,
            s="goalV += rand(0.1);\nif (goalV > 0.99){\n\tgoalPP = 0;\n\tvector $pos = position;\n\tif ($pos.y < "
            + self.controllerName + ".floor){\n\t\tlifespanPP = 0;\n\t}\n}",
            rbd=1)

        cmds.select(self.controllerName)
        # cmds.getAttr()
        self.dagModifier.doIt()
cmds.setAttr('dropletsShape.useLighting', True)

#Point Size to 1
cmds.setAttr('dropletsShape.pointSize', 1)
'''

#Adding Fields
'''
gravity -pos 0 0 0 -m 9.8 -att 0 -dx 0 -dy -1 -dz 0  -mxd -1  -vsh none -vex 0 -vof 0 0 0 -vsw 360 -tsr 0.5 ;
// gravityField1 //
#Select particles before adding in fields
'''
# Placement (xform command)
# emit and part
cmds.select('droplets')
drop_grav = cmds.gravity('droplets', m=15, dy=-1)
cmds.connectDynamic('droplets', f='gravityField1')
#Reselect Particles
cmds.select('droplets')
radial_drop = cmds.radial('droplets', m=0.010)
cmds.connectDynamic(part[0], f=radial_drop[0])

#Create Partilce Mist from the Particle Tool
mist_part_1 = cmds.particle(n='mist', c=0)
mist_part_2 = cmds.particle(n='mist1', c=0)
cmds.select('mist')
cmds.connectDynamic(mist_part_1[0], em=emit[0])
cmds.select('mist1')
cmds.connectDynamic('mist1', em=emit[0])

#Add gravityField1 and radialField1 to mist and mist1 through dynamicRelationship editor
示例#25
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)