def splashDiscParticleExpressionBeforeDynamics(splashDiscParticle="",oceanShader=""):
    """
    send splashDiscParticle and oceanShader to make custom expression on splashDiscParticle
    @param splashDiscParticle: Name of SplashDiscParticle
    @type splashDiscParticle: String
    --------------------------------------------
    @param oceanShader: Name of shader
    @type oceanShader: String
    --------------------------------------------
    @return: 0-ExpressionText
    """
    newExp = ""
    newExp += "float $particleFoamEmission = 0.8; \n"
    newExp += "float $particleWakeEmission = 0.01;\n"
    newExp += "vector $pos = %s.position;\n"%splashDiscParticle
    newExp += "vector $vel = %s.velocity;\n"%splashDiscParticle
    newExp += "float $px = $pos.x;\n"
    newExp += "float $pz = $pos.z;\n"
    newExp += "float $disp[] = `colorAtPoint -u $px -v $pz %s`;\n"%oceanShader
    newExp += "\nif( $vel.y < 0 && $pos.y < ($disp[0]-.2) ){\n\t"
    newExp += "%s.lifespanPP = 0;\n\t"%splashDiscParticle
    newExp += "int $vox[] = `fluidVoxelInfo -objectSpace false -cb -voxel $px 0 $pz OceanWakeTexture1`;\n\t"
    newExp += "if( size($vox) > 0){\n\t\t"
    newExp += "setFluidAttr -at density -ad -xi $vox[0] -yi $vox[1] -zi $vox[2] -fv $particleWakeEmission OceanWakeTexture1;\n\t"
    newExp += "}\n\t"
    newExp += "$vox = `fluidVoxelInfo -objectSpace false -cb -voxel $px 0 $pz OceanWakeFoamTexture1`;\n\t"
    newExp += "if( size($vox) > 0){\n\t\t"
    newExp += "setFluidAttr -at temperature -ad -xi $vox[0] -yi $vox[1] -zi $vox[2] -fv $particleFoamEmission OceanWakeFoamTexture1;\n\t}\n"
    newExp += "}"
    
    cmds.dynExpression(splashDiscParticle,string=newExp,runtimeBeforeDynamics=True)
    
    return newExp
 def updateParticleBucket(self,emitSurfPtcsShape):
     '''update the settings of the particle system passed to the proc'''
     randSeed = cmds.getAttr(emitSurfPtcsShape+'.randSeed')
     scaleMin = cmds.getAttr(emitSurfPtcsShape+'.scaleMin')
     scaleMax = cmds.getAttr(emitSurfPtcsShape+'.scaleMax')
     dressType = cmds.getAttr(emitSurfPtcsShape+'.dressType')
     
     if dressType == 'all':
         instSize = str(len(cmds.listRelatives('dressExampleGrp', c = True, f = True)))
     #build the strings that set the on creation expression
     createExp = 'seed('+str(randSeed)+'+id);\ngoalU = parentU;\ngoalV = parentV;\n'
     createExp +=emitSurfPtcsShape+'.indexPP = floor(rand('+instSize+'));\n'
     createExp +=emitSurfPtcsShape+'.scalePP = rand('+str(scaleMin)+','+str(scaleMax)
     createExp +=');\n'+emitSurfPtcsShape+'.aimRotOffPP = <<rand(-1.0,1.0),0.0,rand(-1.0,1.0)>>;\n'
     createExp +=emitSurfPtcsShape+'.surfRotOffPP = <<0.0,sin(id*rand(50)),cos(id * rand(5))>>;\n'
     
     print createExp
     #build the strings that set the run on dynamics expression
     rbdExp = emitSurfPtcsShape+'.surfRotPP = '+emitSurfPtcsShape+'.surfRotOffPP;\n'
     rbdExp +=emitSurfPtcsShape+'.aimRotPP = '+emitSurfPtcsShape+'.aimRotOffPP;\n'
     print rbdExp
     #update the per particle expressions
     cmds.dynExpression(emitSurfPtcsShape, s = str(createExp), c = 1)
     cmds.dynExpression(emitSurfPtcsShape, s = str(rbdExp), rbd = 1)
     return
Exemple #3
0
def objectNameParticleExpressionBeforeDynamics(objectNameParticle="",
                                               oceanShader=""):
    """
    send objectParticle and oceanShader to make custom expression on objectParticle
    @param objectNameParticle: Name of Object
    @type objectNameParticle: String
    --------------------------------------------
    @param oceanShader: Name of shader
    @type oceanShader: String
    --------------------------------------------
    @return: 0-ExpressionText
    """
    newExp = ""
    newExp += "%s.lifespanPP = rand(2,4);\n" % objectNameParticle
    newExp += "vector $pos = %s.position;\n" % objectNameParticle
    newExp += "float $px = $pos.x;\n"
    newExp += "float $pz = $pos.z;\n"
    newExp += "float $disp[] = `colorAtPoint -u $px -v $pz %s`;\n" % oceanShader
    newExp += "if( $pos.y > $disp[0]-0.2 ){\n"
    newExp += "\n\t%s.lifespanPP = 0;\n" % objectNameParticle
    newExp += "}\n"

    cmds.dynExpression(objectNameParticle,
                       string=newExp,
                       runtimeBeforeDynamics=True)

    return newExp
def createParticleSystem_2():
    # Creates a point emitter, with a collide plane and some PP attributes

    cmds.playbackOptions(maxTime=180)

    emitter = cmds.emitter(dx=1, dy=0, dz=0, sp=0.1, pos=(0, 5, 0),rate=20)[0]

    # nParticle creation depends on an optionVar value, make sure we use the default one
    cmds.optionVar( sv=("NParticleStyle","Points") )

    particleSystem, particleSystemShape = cmds.nParticle(n="nParticle_test_2")
    cmds.setAttr('%s.lfm' % particleSystemShape, 2.0) # random range
    cmds.setAttr('%s.lifespan' % particleSystemShape, 3)
    cmds.setAttr('%s.lifespanRandom' % particleSystemShape, 4)
    cmds.setAttr('%s.friction' % particleSystemShape, 0.01)
    cmds.setAttr('%s.bounce' % particleSystemShape, 0.5)
    cmds.setAttr('%s.rotationFriction' % particleSystemShape, 0.98)
    cmds.setAttr('%s.pointMass' % particleSystemShape, 4)
    cmds.setAttr('%s.computeRotation' % particleSystemShape, True)
    cmds.setAttr('%s.particleRenderType' % particleSystemShape, 7) # Blobby, to see radius
    cmds.setAttr('%s.selfCollide' % particleSystemShape, True)
    cmds.connectDynamic( particleSystemShape, em=emitter)


    # add Custom Attributes
    # rgb
    if not cmds.objExists( "%s.rgbPP" % particleSystemShape):
        cmds.addAttr( particleSystemShape ,ln="rgbPP",dt="vectorArray")
    else:
        # Disconnect possible thing in rgbPP
        input = cmds.connectionInfo("%s.rgbPP" % particleSystemShape,sourceFromDestination=True)
        if input:
            cmds.disconnectAttr(input,"%s.rgbPP" % particleSystemShape)

    cmds.dynExpression( particleSystem, s="\nfloat $r = rand(1.0);float $g = rand(1.0);float $b = rand(1.0);\n%s.rgbPP = <<$r,$g,$b>>;" % particleSystemShape, c=True)

    # radius
    if not cmds.objExists( "%s.radiusPP" % particleSystemShape):
        cmds.addAttr( particleSystemShape, ln="radiusPP",dt="doubleArray")
    cmds.dynExpression( particleSystem, s="seed(%s.id);\n%s.radiusPP = .2 + time * .2 * rand(.2,1.5)" % (particleSystemShape,particleSystemShape), runtimeAfterDynamics=True)

    # rotatePP (enabled by "compute rotation", the attribute would be created by attribut editor's first constrcution in a gui maya)
    if not cmds.objExists( "%s.rotationPP" % particleSystemShape):
        cmds.addAttr( particleSystemShape, ln="rotationPP",dt="vectorArray")

    # add collision plane
    plane = cmds.polyPlane( w=30,h=30,sx=10,sy=10,ax=[0, 1, .5], cuv=2)
    cmds.select(plane[0])
    maya.mel.eval("makePassiveCollider")
    cmds.select(clear=True)
    cmds.setAttr( "nRigidShape1.friction", 0.25)
    cmds.setAttr( "nRigidShape1.stickiness", 0.0)

    return particleSystem, particleSystemShape
Exemple #5
0
def createParticleSystem_2():
    # Creates a point emitter, with a collide plane and some PP attributes

    cmds.playbackOptions(maxTime=180)

    emitter = cmds.emitter(dx=1, dy=0, dz=0, sp=0.1, pos=(0, 5, 0), rate=20)[0]

    # nParticle creation depends on an optionVar value, make sure we use the default one
    cmds.optionVar(sv=("NParticleStyle", "Points"))

    particleSystem, particleSystemShape = cmds.nParticle(n="nParticle_test_2")
    cmds.setAttr('%s.lfm' % particleSystemShape, 2.0)  # random range
    cmds.setAttr('%s.lifespan' % particleSystemShape, 3)
    cmds.setAttr('%s.lifespanRandom' % particleSystemShape, 4)
    cmds.setAttr('%s.friction' % particleSystemShape, 0.01)
    cmds.setAttr('%s.bounce' % particleSystemShape, 0.5)
    cmds.setAttr('%s.rotationFriction' % particleSystemShape, 0.98)
    cmds.setAttr('%s.pointMass' % particleSystemShape, 4)
    cmds.setAttr('%s.computeRotation' % particleSystemShape, True)
    cmds.setAttr('%s.particleRenderType' % particleSystemShape, 7)  # Blobby, to see radius
    cmds.setAttr('%s.selfCollide' % particleSystemShape, True)
    cmds.connectDynamic(particleSystemShape, em=emitter)

    # add Custom Attributes
    # rgb
    if not cmds.objExists("%s.rgbPP" % particleSystemShape):
        cmds.addAttr(particleSystemShape , ln="rgbPP", dt="vectorArray")
    else:
        # Disconnect possible thing in rgbPP
        input = cmds.connectionInfo("%s.rgbPP" % particleSystemShape, sourceFromDestination=True)
        if input:
            cmds.disconnectAttr(input, "%s.rgbPP" % particleSystemShape)

    cmds.dynExpression(particleSystem, s="\nfloat $r = rand(1.0);float $g = rand(1.0);float $b = rand(1.0);\n%s.rgbPP = <<$r,$g,$b>>;" % particleSystemShape, c=True)

    # radius
    if not cmds.objExists("%s.radiusPP" % particleSystemShape):
        cmds.addAttr(particleSystemShape, ln="radiusPP", dt="doubleArray")
    cmds.dynExpression(particleSystem, s="seed(%s.id);\n%s.radiusPP = .2 + time * .2 * rand(.2,1.5)" % (particleSystemShape, particleSystemShape), runtimeAfterDynamics=True)

    # rotatePP (enabled by "compute rotation", the attribute would be created by attribut editor's first constrcution in a gui maya)
    if not cmds.objExists("%s.rotationPP" % particleSystemShape):
        cmds.addAttr(particleSystemShape, ln="rotationPP", dt="vectorArray")

    # add collision plane
    plane = cmds.polyPlane(w=30, h=30, sx=10, sy=10, ax=[0, 1, .5], cuv=2)
    cmds.select(plane[0])
    maya.mel.eval("makePassiveCollider")
    cmds.select(clear=True)
    cmds.setAttr("nRigidShape1.friction", 0.25)
    cmds.setAttr("nRigidShape1.stickiness", 0.0)

    return particleSystem, particleSystemShape
def splashDiscParticleExpressionCreation(splashDiscParticle=""):
    """
    send splashDiscParticle to make custom expression on splashDiscParticle
    @param splashDiscParticle: Name of SplashDiscParticle
    @type splashDiscParticle: String
    --------------------------------------------
    @return: 0-ExpressionText
    """
    newExp = ""
    newExp += "%s.lifespanPP = rand(2,3);\n"%splashDiscParticle
    newExp += "%s.spriteTwistPP = rand(360);"%splashDiscParticle
    
    cmds.dynExpression(splashDiscParticle,string=newExp,creation=True)
    
    return newExp
Exemple #7
0
def splashDiscParticleExpressionCreation(splashDiscParticle=""):
    """
    send splashDiscParticle to make custom expression on splashDiscParticle
    @param splashDiscParticle: Name of SplashDiscParticle
    @type splashDiscParticle: String
    --------------------------------------------
    @return: 0-ExpressionText
    """
    newExp = ""
    newExp += "%s.lifespanPP = rand(2,3);\n" % splashDiscParticle
    newExp += "%s.spriteTwistPP = rand(360);" % splashDiscParticle

    cmds.dynExpression(splashDiscParticle, string=newExp, creation=True)

    return newExp
def _setupRear_ParticleExpressions(particleShapeName = '', type = 'splash', boatWorldCtrl = '', boatName = '', rearAnimatable = ''):
    """
    Setup the expressions for the rearEmitter nParticleShape node
    @param particleShapeName: The name of the nParticleShape node
    @param boatWorldCtrl: The name of the boatWorldCtrl curve
    @param boatName: The name of the boat should be stripped :
    @type particleShapeName: String
    @type boatWorldCtrl: String
    @type boatName: String
    """

    if type == 'splash':
        ############################
        ## Creation
        expStringList = [
                        '%s.lifespanPP = rand(%s.lifespanMin, %s.lifespanMax);\n' %(particleShapeName, rearAnimatable, rearAnimatable),
                        '%s.twistSpeedPP = rand(%s.twistSpeedMin, %s.twistSpeedMax);\n' %(particleShapeName, rearAnimatable, rearAnimatable),
                        '%s.spriteStartSizePP = rand(%s.spriteStartSizeMin, %s.spriteStartSizeMax);\n' %(particleShapeName, rearAnimatable, rearAnimatable),
                        '%s.spriteScaleYPP = %s.spriteScaleXPP = %s.spriteStartSizePP;\n' %(particleShapeName, particleShapeName, particleShapeName),
                        '%s.spriteTwistPP = rand(%s.twistAngleMin, %s.twistAngleMax);\n' %(particleShapeName, rearAnimatable, rearAnimatable),
                        ]

        ## Check if the expression already exists in the scene, if so delete it
        utils.checkExpressionExists('%s_sprite_settings' % particleShapeName)

        ## Build new expression
        cmds.dynExpression( particleShapeName, n = "%s_sprite_settings" % particleShapeName, creation = True, string = utils.processExpressionString(expStringList) )

        ############################
        ## Runtime Before Dynamics
        expStringList = [
                        '%s.spriteScaleYPP = %s.spriteScaleXPP = %s.spriteStartSizePP * %s.scaleOverLifeRamp;\n' %(particleShapeName, particleShapeName, particleShapeName, particleShapeName),
                        '%s.spriteScaleXPP = %s.spriteScaleYPP;\n' %(particleShapeName, particleShapeName),
                        '%s.spriteTwistPP += (%s.twistSpeedPP * %s.twistRateOverLife);\n' %(particleShapeName, particleShapeName, particleShapeName),
                        '\n',
                        ]

        ## Check if the expression already exists in the scene, if so delete it
        utils.checkExpressionExists('%s_sprite_settings' % particleShapeName)

        ## Build new expression
        cmds.dynExpression( particleShapeName, n = "%s_sprite_settings" % particleShapeName, rbd = True, string = utils.processExpressionString(expStringList) )

        ## Connect some attrs to animatable group
        attrs = ['inheritFactor', 'conserve', 'drag', 'damp']
        for att in attrs:
            if not cmds.isConnected( '%s.%s' %(rearAnimatable, att), '%s.%s' %(particleShapeName, att) ):
                cmds.connectAttr('%s.%s' %(rearAnimatable, att), '%s.%s' %(particleShapeName, att), force = True)
Exemple #9
0
    def __run(self, *args, **kwargs):
        pos = kwargs.get("position", [])
        col = kwargs.pop("color", [])

        particle = cmds.particle(**kwargs)[1]

        if col and len(col) == len(pos):
            cmds.addAttr(particle, ln="rgbPP", dt="vectorArray")
            cmds.addAttr(particle, ln="rgbPP0", dt="vectorArray")
            color_exp = "vector $vectorList[] = {%s};" % (",".join(
                map(lambda x: "<<{},{},{}>>".format(x[0], x[1], x[2]), col)))
            color_exp += "\nint $id = id;\n%s.rgbPP = $vectorList[$id];" % (
                particle)
            cmds.dynExpression(particle, c=1, s=color_exp)

        return particle
def splashDiscParticleExpressionAfterDynamics(splashDiscParticle=""):
    """
    send splashDiscParticle to make custom expression on splashDiscParticle
    @param splashDiscParticle: Name of SplashDiscParticle
    @type splashDiscParticle: String
    --------------------------------------------
    @return: 0-ExpressionText
    """
    
    newExp = ""
    newExp += "vector $appear = %s.position;\n"%splashDiscParticle
    newExp += "if ($appear.y < -0.25){\n\t"
    newExp += "%s.lifespanPP = 0;\n"%splashDiscParticle
    newExp += "}"
    
    cmds.dynExpression(splashDiscParticle,string=newExp,runtimeAfterDynamics=True)
    
    return newExp
Exemple #11
0
def splashDiscParticleExpressionAfterDynamics(splashDiscParticle=""):
    """
    send splashDiscParticle to make custom expression on splashDiscParticle
    @param splashDiscParticle: Name of SplashDiscParticle
    @type splashDiscParticle: String
    --------------------------------------------
    @return: 0-ExpressionText
    """

    newExp = ""
    newExp += "vector $appear = %s.position;\n" % splashDiscParticle
    newExp += "if ($appear.y < -0.25){\n\t"
    newExp += "%s.lifespanPP = 0;\n" % splashDiscParticle
    newExp += "}"

    cmds.dynExpression(splashDiscParticle,
                       string=newExp,
                       runtimeAfterDynamics=True)

    return newExp
Exemple #12
0
def cleanerUpLoad():
    '''{'del_path':'Dynamics/QS/cleanerUpLoad()',
'icon':':/SP_TrashIcon.png',
'usage':'$fun()',
'help':'删除指定脚本,所有粒子表达式',
}
'''
    #Delete 'QS_VFX*' nodes
    node = cmds.ls('QS_VFX*')
    if node != []:
        cmds.delete(node)
        print 'Deleted %s node' % (node)

    #Delete 'All expressions of particles
    for parShape in cmds.ls(type='particle'):
        cmds.dynExpression(parShape, s='', c=True, rbd=True, rad=True)
    print 'Deleted all expressions of particles'

    #Delete inputForce attributes for particle nodes
    addInputForceAttrForPar(cmds.ls(exactType='particle'))
Exemple #13
0
	def _build_nParticleExpressions(self, particleShapeName = '', animatable = ''):
		"""
		Setup the expressions for the sideEmitter's nParticleShape node
		@param particleShapeName: The name of the nParticleShape node
		@param boatWorldCtrl: The name of the boatWorldCtrl curve
		@param speedObject: The name of the boat should be stripped :
		@type particleShapeName: String
		@type boatWorldCtrl: String
		@type speedObject: String
		"""

		## Creation
		expStringList = [
						'%s.lifespanPP = rand(%s.lifespanMin, %s.lifespanMax);' %(particleShapeName, animatable, animatable),
						'%s.twistSpeedPP = rand(%s.twistSpeedMin, %s.twistSpeedMax);' %(particleShapeName, animatable, animatable),
						'%s.spriteStartSizePP = rand(%s.spriteStartSizeMin, %s.spriteStartSizeMax);' %(particleShapeName, animatable, animatable),
						'%s.spriteScaleYPP = %s.spriteScaleXPP = %s.spriteStartSizePP;' %(particleShapeName, particleShapeName, particleShapeName),
						'%s.spriteTwistPP = rand(%s.twistAngleMin, %s.twistAngleMax);' %(particleShapeName, animatable, animatable),
						]
		## Build new expression
		cmds.dynExpression( particleShapeName, name = "%s_expression" % particleShapeName, creation = True, string = self.processExpressionString(expStringList) )

		## Runtime Before Dynamics
		expStringList = [
						'%s.spriteScaleYPP = %s.spriteScaleXPP = %s.spriteStartSizePP * %s.scaleOverLifeRamp;' %(particleShapeName, particleShapeName, particleShapeName, particleShapeName),
						'%s.spriteScaleXPP = %s.spriteScaleYPP;' %(particleShapeName, particleShapeName),
						'%s.spriteTwistPP += (%s.twistSpeedPP * %s.twistRateOverLife);' %(particleShapeName, particleShapeName, particleShapeName),
						'',
						]
		## Build new expression
		cmds.dynExpression( particleShapeName, name = "%s_expression" % particleShapeName, rbd = True, string = self.processExpressionString(expStringList) )

		## Connect some attrs to animatable group
		attrs = ['inheritFactor', 'conserve', 'drag', 'damp']
		for att in attrs:
			if not cmds.isConnected( '%s.%sSprite' %(animatable, att), '%s.%s' %(particleShapeName, att) ):
				cmds.connectAttr('%s.%sSprite' %(animatable, att), '%s.%s' %(particleShapeName, att), force = True)
Exemple #14
0
def splashDiscParticleExpressionBeforeDynamics(splashDiscParticle="",
                                               oceanShader=""):
    """
    send splashDiscParticle and oceanShader to make custom expression on splashDiscParticle
    @param splashDiscParticle: Name of SplashDiscParticle
    @type splashDiscParticle: String
    --------------------------------------------
    @param oceanShader: Name of shader
    @type oceanShader: String
    --------------------------------------------
    @return: 0-ExpressionText
    """
    newExp = ""
    newExp += "float $particleFoamEmission = 0.8; \n"
    newExp += "float $particleWakeEmission = 0.01;\n"
    newExp += "vector $pos = %s.position;\n" % splashDiscParticle
    newExp += "vector $vel = %s.velocity;\n" % splashDiscParticle
    newExp += "float $px = $pos.x;\n"
    newExp += "float $pz = $pos.z;\n"
    newExp += "float $disp[] = `colorAtPoint -u $px -v $pz %s`;\n" % oceanShader
    newExp += "\nif( $vel.y < 0 && $pos.y < ($disp[0]-.2) ){\n\t"
    newExp += "%s.lifespanPP = 0;\n\t" % splashDiscParticle
    newExp += "int $vox[] = `fluidVoxelInfo -objectSpace false -cb -voxel $px 0 $pz OceanWakeTexture1`;\n\t"
    newExp += "if( size($vox) > 0){\n\t\t"
    newExp += "setFluidAttr -at density -ad -xi $vox[0] -yi $vox[1] -zi $vox[2] -fv $particleWakeEmission OceanWakeTexture1;\n\t"
    newExp += "}\n\t"
    newExp += "$vox = `fluidVoxelInfo -objectSpace false -cb -voxel $px 0 $pz OceanWakeFoamTexture1`;\n\t"
    newExp += "if( size($vox) > 0){\n\t\t"
    newExp += "setFluidAttr -at temperature -ad -xi $vox[0] -yi $vox[1] -zi $vox[2] -fv $particleFoamEmission OceanWakeFoamTexture1;\n\t}\n"
    newExp += "}"

    cmds.dynExpression(splashDiscParticle,
                       string=newExp,
                       runtimeBeforeDynamics=True)

    return newExp
Exemple #15
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);
Exemple #16
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);
def objectNameParticleExpressionBeforeDynamics(objectNameParticle="",oceanShader=""):
    """
    send objectParticle and oceanShader to make custom expression on objectParticle
    @param objectNameParticle: Name of Object
    @type objectNameParticle: String
    --------------------------------------------
    @param oceanShader: Name of shader
    @type oceanShader: String
    --------------------------------------------
    @return: 0-ExpressionText
    """
    newExp = ""
    newExp += "%s.lifespanPP = rand(2,4);\n"%objectNameParticle
    newExp += "vector $pos = %s.position;\n"%objectNameParticle
    newExp += "float $px = $pos.x;\n"
    newExp += "float $pz = $pos.z;\n"
    newExp += "float $disp[] = `colorAtPoint -u $px -v $pz %s`;\n"%oceanShader
    newExp += "if( $pos.y > $disp[0]-0.2 ){\n"
    newExp += "\n\t%s.lifespanPP = 0;\n"%objectNameParticle
    newExp += "}\n"
    
    cmds.dynExpression(objectNameParticle, string=newExp, runtimeBeforeDynamics=True)
    
    return newExp
Exemple #18
0
def _dynamicField(field = "uniform", opts = {}):
	## Only proceed if nParticle(s) in selection
	selection = _filter_type_on_selection(type = 'nParticle', toShape = True)
	if selection:

		cmds.select(clear = True)
		try:
			## Field creation
			node = eval( 'cmds.%s(**%s)' %(field, opts) )
		except:
			node = None

		if node:
			for each in selection:
				cmds.connectDynamic(each, fields = node[0])

			## Set expression to all nParticle (runtimeAfterDynamics)
			inputForce = cmds.listConnections('%s.outputForce' % node[0], type = 'nParticle', plugs = True)
			if inputForce:
				inputForce = list( set( inputForce ) )

				for each in inputForce:
					## Get expression's current string to add-on inputForce line
					nParticleShape = each.split(".")[0]

					currentStr = cmds.dynExpression(nParticleShape, query = True, rad = True, string = True)
					inputForceStr = 'if (mag(%s) >= 0.001){%s.lifespanPP = 0.0;}\n' %(each, nParticleShape)
					if not currentStr.endswith('\n'):
						currentStr = '%s\n' % currentStr
						currentStr += inputForceStr

					cmds.dynExpression(nParticleShape, edit = True, rad = True, string = currentStr)
		else:
			mel.eval('warning "Failed to create killField!";')
	else:
		mel.eval('warning "Please select proper nParticle(s)!";')
Exemple #19
0
def addDriverByParForWrapedTFNode(tfGrp):
    '''{'del_path':'TfCtrl/Add/Group/addDriverByParForWrapedTFNode(cmds.ls(sl=True)[0])',
'usage':'$fun(cmds.ls(sl=True)[0])',
}
'''

    #get tfNodeGrp
    cmds.lockNode(tfGrp, l=False)
    if cmds.attributeQuery('shellPoly', n=tfGrp, exists=True) == False:
        raise IOError('This is not tfGrp object')
    else:
        shellPoly = cmds.getAttr('%s.shellPoly' % (tfGrp))

    if cmds.attributeQuery('nParShapeNode', n=tfGrp, exists=True) == False:
        cmds.addAttr(tfGrp, ln="nParShapeNode", dt="string")
    else:
        raise IOError('%s object has a nParShapeNode to control it')

    tfNodeGrp = tfGrp
    #print '%s, %s'%(shellPoly, tfNodeGrp)

    tfNodeGrpVarStr = tfNodeGrp.replace('|', '__')
    objects = cmds.listRelatives(tfNodeGrp, type='transform', f=True)

    cmds.lockNode([shellPoly, tfNodeGrp], l=False)

    ####################create and set nParticle etc.######################################
    #create nParticle
    nPar = cmds.nParticle(n='%s_nPar' % (tfNodeGrp))
    cmds.setAttr(nPar[0] + '.t', l=True)
    cmds.setAttr(nPar[0] + '.r', l=True)
    cmds.setAttr(nPar[0] + '.s', l=True)
    cmds.lockNode(nPar[0], l=True)

    nParShape = nPar[1]

    #setAttr to get_tfGrpNode

    cmds.setAttr(tfNodeGrp + '.nParShapeNode',
                 nParShape,
                 type='string',
                 l=True)
    cmds.lockNode([shellPoly, tfNodeGrp], l=True)
    cmds.setAttr('%s.computeRotation' % (nParShape), 1)
    cmds.goal(nParShape, g=shellPoly, w=.99)
    #set attributes
    cmds.setAttr(nParShape + '.goalSmoothness', .01)
    cmds.setAttr(nParShape + '.radius', .01)

    #add attributes
    cmds.addAttr(nParShape, ln="cus_toObjPos", dt='doubleArray')
    cmds.addAttr(nParShape, ln="cus_toObjPos0", dt='doubleArray')

    #Add particles and set attributes(goalU, goalV, cus_bbsiRadius) initialize states
    posLi, radiusLi, atULi, atVLi = [], [], [], []
    for tfNode in objects:
        objPos = cmds.objectCenter(tfNode)
        bbsize = cmds.getAttr(tfNode + '.bbsi')[0]
        radius = vectorLen(bbsize) / 2
        atU = cmds.getAttr(tfNode + '.atU')
        atV = cmds.getAttr(tfNode + '.atV')
        posLi.append(objPos)
        radiusLi.append(radius)
        atULi.append(atU)
        atVLi.append(atV)

    qsEmit(object = nParShape, position=posLi, attributes=( ('cus_radiusPP', 'floatValue', radiusLi), ('goalU', 'floatValue', atULi),\
                                                               ('goalV', 'floatValue', atVLi) )\
              )

    ##creation expression
    #parCExpStr = cmds.dynExpression(nParShape, q=True,s=True, c=True)
    parCExpStr = '\n\n\
/*string $tfNode = $%s[int(particleId)];\n\
goalU = `getAttr ($tfNode+".atU")`;\n\
goalV = `getAttr ($tfNode+".atV")`;\n\
cus_toObjPos = 0;*/' % (tfNodeGrpVarStr)

    cmds.dynExpression(nParShape, s=parCExpStr, c=True)

    ##runtime after dynamics expression
    #parRADExpStr = cmds.dynExpression(nParShape, q=True, s=True, rad=True)
    parRADExpStr = '\n\n\
/*string $tfNode = $%s[int(particleId)];\n\n\
\
if (cus_toObjPos == 1){\n\
    float $pos[] = position;\n\
    vector $rotate = rotationPP;\n\
    setAttr ($tfNode + ".pBInT2") -type "double3" ($pos[0]) ($pos[1]) ($pos[2]);\n\
    setAttr ($tfNode + ".pBInR2") -type "double3" ($rotate.x) ($rotate.y) ($rotate.z);\n\
}\n\n\
\
\
if (goalPP==0 && cus_toObjPos==0){\n\
    cus_toObjPos = 1;\n\
    float $pos[] = `getAttr ($tfNode+".translate")`;\n\
    position = <<$pos[0], $pos[1], $pos[2]>>;\n\
    vector $rotate = rotationPP;\n\
    setAttr ($tfNode + ".pBInT2") -type "double3" ($pos[0]) ($pos[1]) ($pos[2]);\n\
    setAttr ($tfNode + ".pBInR2") -type "double3" ($rotate.x) ($rotate.y) ($rotate.z);\n\
    setAttr ($tfNode+".pBWeight") 1;\n\
    setAttr ($tfNode+".follicleNodeState") 2;\n\
}*/' % (tfNodeGrpVarStr)
    cmds.dynExpression(nParShape, s=parRADExpStr, rad=True)

    ######################################create script nodes########################################
    ####openCloseMel script node   Execute On:Open/close
    openCloseMelStr = '\n\n\
///////////for TFNode by Particles/////////////////////\n\
global string $%s[];\n\
$%s = `listRelatives -f "%s"`;\n' % (tfNodeGrpVarStr, tfNodeGrpVarStr,
                                     tfNodeGrp)
    mel.eval(openCloseMelStr)
    if cmds.objExists("QS_VFX_M_OC"):
        existsStr = cmds.scriptNode('QS_VFX_M_OC', q=True, bs=True)
        openCloseMelStr += existsStr
        cmds.scriptNode('QS_VFX_M_OC', e=True, bs=openCloseMelStr)
    else:
        cmds.scriptNode(n='QS_VFX_M_OC',
                        scriptType=1,
                        bs=openCloseMelStr,
                        sourceType='mel')
        cmds.setAttr('QS_VFX_M_OC.scriptType', l=True)

    ####timeChangedMel script Node    Execute on: Time changed
    timeChangedMelStr = '\n\n\
///////////for TFNode by Particles/////////////////////\n\
int $current = `currentTime -q`;\n\
int $start = `playbackOptions -q -min`;\n\
if ($current == $start){\n\
    //%s is a global variable, Declare in QS_VFX_M_QC script node.\n\
    $%s = `listRelatives -type "transform" "%s"`; \n\
    for ($tfNode in $%s){\n\
        setAttr($tfNode+".follicleNodeState") 0;\n\
        setAttr($tfNode+".pBWeight") 0;\n\
    }\n\
}' % (tfNodeGrpVarStr, tfNodeGrpVarStr, tfNodeGrp, tfNodeGrpVarStr)
    mel.eval(timeChangedMelStr)
    if cmds.objExists("QS_VFX_M_TC"):
        existsStr = cmds.scriptNode('QS_VFX_M_TC', q=True, bs=True)
        timeChangedMelStr += existsStr
        cmds.scriptNode('QS_VFX_M_TC', e=True, bs=timeChangedMelStr)
    else:
        cmds.scriptNode(n='QS_VFX_M_TC',
                        scriptType=7,
                        bs=timeChangedMelStr,
                        sourceType='mel')
        cmds.setAttr('QS_VFX_M_TC.scriptType', l=True)
Exemple #20
0
	def __init__(self, prefix, mesh):

		## Create ctrl for bubbles
		self.bubbleCtrlShape = cmds.createNode( 'implicitSphere', name = '%s_%sShape' % (prefix, self.BUBBLE_CTRL_NAME) )
		self.bubbleCtrl = cmds.listRelatives(self.bubbleCtrlShape, parent = True, fullPath = True)
		self.bubbleCtrl = cmds.rename( self.bubbleCtrl, '%s_%s' % (prefix, self.BUBBLE_CTRL_NAME) )
		self.bubbleCtrlGroup = cmds.group( self.bubbleCtrl, name = '%s_%s' % (prefix, self.BUBBLE_CTRL_OFFSET_GRP) )

		## Space locator with speed attribute
		self.speedLocator = cmds.spaceLocator( name = '%s_%s' % (prefix, self.LOCATOR_NAME) )[0]
		cmds.addAttr(self.speedLocator, longName = 'speed', attributeType = 'double')
		cmds.setAttr('%s.speed' % self.speedLocator, keyable = True)

		###################################################################################################

		## Creation
		self.bubble, self.bubbleShape = cmds.particle(name = '%s_%s' % (prefix, self.BUBBLE_NAME) )

		## Set presets
		for attr, val in self.BUBBLE_PRESET_ATTRS.iteritems():
			cmds.setAttr('%s.%s' % (self.bubbleShape, attr), val)

		## Create necessary PP attr and hook-up necsesary ramp info
		arrayMap, ramp = self.addAttrPP(particleShapeName = self.bubbleShape, attrPP = self.BUBBLE_ATTR_PP)

		## Emitter
		cmds.select(mesh, replace = True)
		self.bubbleEmitter = cmds.emitter(type = 'surface', rate = 100, sro = 0, nuv = 0, cye = 'none', cyi = 1, spd = 1, srn = 0, nsp = 1, tsp = 0, mxd = 0, mnd = 0, dx = 1, dy = 0, dz = 0, sp = 0)[1]
		# elif _TYPE == 'volume':
		#   cmds.select(clear = True)
		#   self.bubbleEmitter = cmds.emitter(pos = [0, 0, 0], type = 'volume', r = 100, sro = 0, nuv = 0, cye = 'none', cyi = 1, spd = 1, srn = 0, nsp = 1, tsp = 0, mxd = 0, mnd = 0, dx = 0, dy = 0, dz = 0, sp = 0, vsh = 'sphere', vof = [0, 0, 0], vsw = 360, tsr = 0.5, afc = 1, afx = 1, arx = 0, alx = 0, rnd = 0, drs = 0, ssz = 0)[0]
		#   cmds.setAttr('%s.scaleX' % self.bubbleEmitter, 0.2)
		#   cmds.setAttr('%s.scaleY' % self.bubbleEmitter, 0.2)
		#   cmds.setAttr('%s.scaleZ' % self.bubbleEmitter, 0.2)

		self.bubbleEmitter = cmds.rename(self.bubbleEmitter, '%s_%s' % (prefix, self.BUBBLE_EMITTER_NAME) )
		cmds.connectDynamic(self.bubbleShape, emitters = self.bubbleEmitter)

		###################################################################################################

		## Creation
		self.bubbleBurst, self.bubbleBurstShape = cmds.particle(name = '%s_%s' % (prefix, self.BUBBLEBURST_NAME) )

		## Set presets
		for attr, val in self.BUBBLEBURST_PRESET_ATTRS.iteritems():
			cmds.setAttr('%s.%s' % (self.bubbleBurstShape, attr), val)

		## Create necessary PP attr and hook-up necsesary ramp info
		self.addAttrPP(particleShapeName = self.bubbleBurstShape, attrPP = self.BUBBLEBURST_ATTR_PP)

		cmds.select(self.bubbleShape, replace = True)
		self.bubbleBurstEmitter = cmds.emitter(type = 'omni', rate = 100, sro = 0, nuv = 0, cye = 'none', cyi = 1, spd = 1, srn = 0, nsp = 1, tsp = 0, mxd = 0, mnd = 0, dx = 1, dy = 0, dz = 0, sp = 0)[1]
		self.bubbleBurstEmitter = cmds.rename(self.bubbleBurstEmitter, '%s_%s' % (prefix, self.BUBBLEBURST_EMITTER_NAME) )
		cmds.setAttr('%s.speed' % self.bubbleBurstEmitter, 0.4)
		cmds.addPP(self.bubbleBurstEmitter, attribute = 'rate')
		cmds.connectDynamic(self.bubbleBurstShape, emitters = self.bubbleBurstEmitter)

		###################################################################################################

		## Create necessary fields
		## Uniform Field
		self.uniformField = cmds.uniform(name = '%s_%s' % (prefix, self.UNIFORM_FIELD_NAME), pos = [0, 0, 0], m = 2.5, att = 0, dx = 0, dy = 2, dz = 0, mxd = -1, vsh = 'none', vex = 0, vof = [0, 0, 0], vsw = 360, tsr = 0.5)[0]

		## Turbulence Field
		self.turbulenceField = cmds.turbulence(name = '%s_%s' % (prefix, self.TURBULENCE_FIELD_NAME), pos = [0, 0, 0], m = 3, att = 0, f = 10, phaseX = 0, phaseY = 0, phaseZ = 0, noiseLevel = 0, noiseRatio = 0.707, mxd = -1, vsh = 'none', vex = 0, vof = [0, 0, 0], vsw = 360, tsr = 0.5)[0]

		## Radial Field
		self.radialField = cmds.radial(name = '%s_%s' % (prefix, self.RADIAL_FIELD_NAME), pos = [0, 0, 0], m = 2, att = 1, typ = 0, mxd = 20, vsh = 'sphere', vex = 0, vof = [0, 0, 0], vsw = 360, tsr = 0.5)[0]

		## Make necessary connections
		cmds.connectDynamic(self.bubbleShape, fields = self.uniformField)
		cmds.connectDynamic(self.bubbleBurstShape, fields = self.uniformField)
		cmds.connectDynamic(self.bubbleShape, fields = self.turbulenceField)
		cmds.connectDynamic(self.bubbleBurstShape, fields = self.turbulenceField)
		cmds.connectDynamic(self.bubbleShape, fields = self.radialField)
		cmds.connectDynamic(self.bubbleBurstShape, fields = self.radialField)

		###################################################################################################

		self.bubbleGroup = cmds.group(self.bubbleCtrlGroup, self.bubble, self.bubbleBurst, self.uniformField, self.turbulenceField, self.radialField, self.bubbleEmitter, self.bubbleBurstEmitter, self.speedLocator, name = '%s_%s' % (prefix, self.BUBBLE_GROUP_NAME) )
		cmds.parent(self.bubbleEmitter, self.speedLocator)
		cmds.pointConstraint(self.bubbleCtrl, self.speedLocator, maintainOffset = False)
		cmds.pointConstraint(cmds.listRelatives(mesh, parent = True, fullPath = True)[0], self.bubbleCtrlGroup, maintainOffset = False)
		cmds.setAttr('%s.scaleX' % self.radialField, 3.165)
		cmds.setAttr('%s.scaleY' % self.radialField, 3.165)
		cmds.setAttr('%s.scaleZ' % self.radialField, 3.165)

		attr = {'longName':'speed', 'niceName':' ', 'attributeType':'enum', 'enumName':'Speed:', 'keyable':False}
		self.add_custom_attrs(self.bubbleCtrl, **attr)
		attr = {'longName':'minSpeed', 'attributeType':'double', 'defaultValue':0.01, 'min':0}
		self.add_custom_attrs(self.bubbleCtrl, **attr)
		attr = {'longName':'maxSpeed', 'attributeType':'double', 'defaultValue':20}
		self.add_custom_attrs(self.bubbleCtrl, **attr)
		attr = {'longName':'useSpeed', 'niceName':'Use Speed', 'attributeType':'bool', 'defaultValue':0}
		self.add_custom_attrs(self.bubbleCtrl, **attr)

		attr = {'longName':'emitters', 'niceName':' ', 'attributeType':'enum', 'enumName':'Emitters:', 'keyable':False}
		self.add_custom_attrs(self.bubbleCtrl, **attr)
		attr = {'longName':'rate', 'niceName':'Rate', 'attributeType':'double', 'defaultValue':20, 'min':0}
		self.add_custom_attrs(self.bubbleCtrl, **attr)
		attr = {'longName':'splashMaxSpeed', 'niceName':'Splash Max Speed', 'attributeType':'double', 'defaultValue':0.1}
		self.add_custom_attrs(self.bubbleCtrl, **attr)
		attr = {'longName':'directionalSpeed', 'niceName':'Directional Speed', 'attributeType':'double', 'defaultValue':0}
		self.add_custom_attrs(self.bubbleCtrl, **attr)
		attr = {'longName':'randomDirection', 'niceName':'Random Direction', 'attributeType':'double', 'defaultValue':0}
		self.add_custom_attrs(self.bubbleCtrl, **attr)

		attr = {'longName':'burstAttr', 'niceName':' ', 'attributeType':'enum', 'enumName':'Burst Attrs:', 'keyable':False}
		self.add_custom_attrs(self.bubbleCtrl, **attr)
		attr = {'longName':'popVelocity', 'niceName':'Pop Velocity', 'attributeType':'double', 'defaultValue':1}
		self.add_custom_attrs(self.bubbleCtrl, **attr)
		attr = {'longName':'burstSizeMin', 'niceName':'Size Min', 'attributeType':'double', 'defaultValue':0.01, 'min':0}
		self.add_custom_attrs(self.bubbleCtrl, **attr)
		attr = {'longName':'burstSizeMax', 'niceName':'Size Max', 'attributeType':'double', 'defaultValue':0.1, 'min':0}
		self.add_custom_attrs(self.bubbleCtrl, **attr)
		attr = {'longName':'burstLifespanMin', 'niceName':'Lifespan Min', 'attributeType':'double', 'defaultValue':1, 'min':-1}
		self.add_custom_attrs(self.bubbleCtrl, **attr)
		attr = {'longName':'burstLifespanMax', 'niceName':'Lifespan Max', 'attributeType':'double', 'defaultValue':2, 'min':-1}
		self.add_custom_attrs(self.bubbleCtrl, **attr)

		attr = {'longName':'bubbleAttr', 'niceName':' ', 'attributeType':'enum', 'enumName':'Bubble Attrs', 'keyable':False}
		self.add_custom_attrs(self.bubbleCtrl, **attr)
		attr = {'longName':'bubbleSizeMin', 'niceName':'Size Min', 'attributeType':'double', 'defaultValue':0.2, 'min':0}
		self.add_custom_attrs(self.bubbleCtrl, **attr)
		attr = {'longName':'bubbleSizeMax', 'niceName':'Size Max', 'attributeType':'double', 'defaultValue':0.4, 'min':0}
		self.add_custom_attrs(self.bubbleCtrl, **attr)
		attr = {'longName':'lifespanMin', 'niceName':'Lifespan Min', 'attributeType':'double', 'defaultValue':2, 'min':-1}
		self.add_custom_attrs(self.bubbleCtrl, **attr)
		attr = {'longName':'lifespanMax', 'niceName':'Lifespan Max', 'attributeType':'double', 'defaultValue':4, 'min':-1}
		self.add_custom_attrs(self.bubbleCtrl, **attr)

		attr = {'longName':'killField', 'niceName':' ', 'attributeType':'enum', 'enumName':'Kill Field:', 'keyable':False}
		self.add_custom_attrs(self.bubbleCtrl, **attr)
		attr = {'longName':'killHeight', 'niceName':'Kill Height', 'attributeType':'double', 'defaultValue':-0.1}
		self.add_custom_attrs(self.bubbleCtrl, **attr)

		###################################################################################################

		## Locator speed expression
		expStringList = [
						'float $time;',
						'float $trx;',
						'float $try;',
						'float $trz;',
						'float $dx = %s.translateX - $trx;' % self.speedLocator,
						'float $dy = %s.translateY - $try;' % self.speedLocator,
						'float $dz = %s.translateZ - $trz;' % self.speedLocator,
						'float $d = sqrt( ($dx * $dx) + ($dy * $dy) + ($dz * $dz) );',
						'%s.speed = abs( $d / ( time - ($time + 0.001) ) );' % self.speedLocator,
						'$trx = %s.translateX;' % self.speedLocator,
						'$try = %s.translateY;' % self.speedLocator,
						'$trz = %s.translateZ;' % self.speedLocator,
						'$time = time;'
						]
		expString = self.processExpressionString(expStringList)
		cmds.expression(self.speedLocator, string = expString)

		## Bubbles Creation Expression
		expStringList = [
						'%s.lifespanPP = rand(%s.lifespanMin, %s.lifespanMax);' %(self.bubbleShape, self.bubbleCtrl, self.bubbleCtrl)
						]
		expString = self.processExpressionString(expStringList)
		cmds.dynExpression(self.bubbleShape, string = expString, creation = True)

		## Bubbles Runtime After Dynamics
		expStringList = [
						'vector $vel = %s.velocity;' % self.bubbleShape,
						'vector $kill = %s.position;' % self.bubbleShape,
						'float $popVel = %s.popVelocity;' % self.bubbleCtrl,
						'float $age = %s.age;' % self.bubbleShape,
						'',
						'if ( $kill.y > %s.killHeight )' % self.bubbleCtrl,
						'{',
						'   %s.lifespanPP = 0;' % self.bubbleShape,
						'}',
						'',
						'if ($vel.y >=  $popVel)',
						'{',
						'   %s.lifespanPP = 0;' % self.bubbleShape,
						'   %s.%s_emitterRatePP = 100;' % (self.bubbleShape, '_'.join(self.bubbleBurst.split('_')[0:-1])),
						'}',
						]
		expString = self.processExpressionString(expStringList)
		cmds.dynExpression(self.bubbleShape, string = expString, runtimeAfterDynamics = True)

		## Bubble Bursts Creation Expression
		expStringList = [
						'%s.lifespanPP = rand(%s.burstLifespanMin, %s.burstLifespanMax);' %(self.bubbleBurstShape, self.bubbleCtrl, self.bubbleCtrl),
						'%s.radiusPP = rand(%s.burstSizeMin, %s.burstSizeMax)' % (self.bubbleBurstShape, self.bubbleCtrl, self.bubbleCtrl),
						]
		expString = self.processExpressionString(expStringList)
		cmds.dynExpression(self.bubbleBurstShape, string = expString, creation = True)

		## Bubble Bursts Runtime After Dynamics Expression
		expStringList = [
						'vector $kill = %s.position;' % self.bubbleBurstShape,
						'',
						'if ($kill.y > %s.killHeight)' % self.bubbleCtrl,
						'{',
						'   %s.lifespanPP = 0;' % self.bubbleBurstShape,
						'}',
						]
		expString = self.processExpressionString(expStringList)
		cmds.dynExpression(self.bubbleBurstShape, string = expString, runtimeAfterDynamics = True)

		## Expression for Turbulence Field
		expStringList = [
						'%s.phaseX = time;' % self.turbulenceField,
						'%s.phaseY = time;' % self.turbulenceField,
						'%s.phaseZ = time;' % self.turbulenceField,
						]
		expString = self.processExpressionString(expStringList)
		cmds.expression(self.turbulenceField, string = expString)

		## Expression for Bubble Emitter
		expStringList = [
						'float $minSpeed = %s.minSpeed;' % self.bubbleCtrl,
						'float $maxSpeed = %s.maxSpeed;' % self.bubbleCtrl,
						'float $speed = %s.speed;' % self.speedLocator,
						'float $curve = smoothstep($minSpeed, $maxSpeed, $speed);',
						'float $rateMuliplier = %s.rate;' % self.bubbleCtrl,
						'float $splashMaxSpeed = %s.splashMaxSpeed;' % self.bubbleCtrl,
						'',
						'if (%s.useSpeed == 1)' % self.bubbleCtrl,
						'{',
						'   %s.rate = $rateMuliplier * $curve;' % self.bubbleEmitter,
						'',
						'   float $emitterSpeed = $splashMaxSpeed * $curve;',
						'   if ($emitterSpeed == 0)',
						'   {',
						'       $emitterSpeed = 0.1;',
						'   }',
						'   %s.awayFromCenter = $emitterSpeed;' % self.bubbleEmitter,
						'}',
						'else',
						'{',
						'   %s.rate = $rateMuliplier;' % self.bubbleEmitter,
						'   %s.awayFromCenter = $splashMaxSpeed;' % self.bubbleEmitter,
						'}',
						'%s.alongAxis = %s.directionalSpeed;' % (self.bubbleEmitter, self.bubbleCtrl),
						'%s.randomDirection = %s.randomDirection;' % (self.bubbleEmitter, self.bubbleCtrl),
						]
		expString = self.processExpressionString(expStringList)
		cmds.expression(self.bubbleEmitter, string = expString)

		###################################################################################################

		## Finalizing stuffs
		cmds.connectAttr('%s.bubbleSizeMin' % self.bubbleCtrl, '%s.minValue' % arrayMap)
		cmds.connectAttr('%s.bubbleSizeMax' % self.bubbleCtrl, '%s.maxValue' % arrayMap)

		###################################################################################################

		## Assigning shader
		self.bubbleShader(particleShapeName = [self.bubbleShape, self.bubbleBurstShape])
def particleLocators(particle, bakeSimulation=False, rotate=False, scale=False, start=0, end=-1, prefix=''):
    """
    """
    # Check Particle
    if not cmds.objExists(particle):
        raise Exception('Object "' + nParticle + '" is not a valid particle or nParticle object!')

    # Check Prefix
    if not prefix: prefix = particle

    # Get particle count
    count = cmds.getAttr(particle + '.count')
    if not count: raise Exception('Invalid particle count! (' + count + ')')

    # Create locators
    partiLocs = [cmds.spaceLocator(n=prefix + '_loc' + str(i))[0] for i in range(count)]
    partiLocsGrp = prefix + '_locGrp'
    if not cmds.objExists(partiLocsGrp): partiLocsGrp = cmds.group(em=True, n=partiLocsGrp)
    cmds.parent(partiLocs, partiLocsGrp)

    # For each particle, set locator position
    for i in range(count):
        pt = cmds.pointPosition(particle + '.pt[' + str(i) + ']')
        cmds.setAttr(partiLocs[i] + '.t', *pt)
        if rotate:
            rt = cmds.particle(particle, q=True, at='rotatePP', id=i)
            cmds.setAttr(partiLocs[i] + '.r', *rt)
        if scale:
            sc = cmds.particle(particle, q=True, at='scalePP', id=i)
            cmds.setAttr(partiLocs[i] + '.s', *sc)

    # Bake Simulation
    if (bakeSimulation):

        # Append particle expression
        expStr = '\n\n//--\n'
        expStr += 'int $id = id;\n'
        expStr += 'vector $pos = pos;\n'
        expStr += 'string $loc = ("' + prefix + '_loc"+$id);\n'
        expStr += 'if(`objExists $loc`){'
        expStr += '\t move -a ($pos.x) ($pos.y) ($pos.z) $loc;\n'
        if rotate:
            expStr += '\tvector $rot = rotatePP;\n'
            expStr += '\t rotate -a ($rot.x) ($rot.y) ($rot.z) $loc;\n'
        if scale:
            expStr += '\tvector $scl = scalePP;\n'
            expStr += '\t scale -a ($scl.x) ($scl.y) ($scl.z) $loc;\n'
        expStr += '}'

        # Old expression string
        oldRadStr = cmds.dynExpression(particle, q=True, s=True, rad=True)

        # Apply particle expression
        cmds.dynExpression(particle, s=oldRadStr + expStr, rad=True)

        # Bake to keyframes
        if end < start:
            start = cmds.playbackOptions(q=True, min=True)
            end = cmds.playbackOptions(q=True, max=True)
        bakeAttrs = ['tx', 'ty', 'tz']
        if rotate: bakeAttrs.extend(['rx', 'ry', 'rz'])
        if scale: bakeAttrs.extend(['sx', 'sy', 'sz'])
        cmds.bakeSimulation(partiLocs, at=bakeAttrs, t=(start, end))

        # Restore particle expression
        cmds.dynExpression(particle, s=oldRadStr, rad=True)
    partsShape.radiusPP = .2;
    float $rx = rand(.1)-.05;
    float $rz = rand(.1)-.05;
    //emit -pos ($p.x+$rx) ($p.y) ($p.z+$rz) -o partsShape;
    
    //  set the color to be based on the parent's color - Brian
    if (partsShape.rgbPP == <<0,0,1>>)
    emit -pos ($p.x+$rx) ($p.y) ($p.z+$rz) -o partsShape
    -attribute rgbPP
    -vectorValue 0 0 1;
    else
    emit -pos ($p.x+$rx) ($p.y) ($p.z+$rz) -o partsShape;
    }
    """ % locals()

mc.dynExpression('partsShape', s='%s' % expression, rbd=True)



## Capsule constructed along the z axis.
#capsuleArray = pm.polyCylinder(axis=(0, 0, 1), r=1, h=2, sx=20, sy=10, sz=5, sa=20, rcp=True)
## Move the capsule 10 units along the z axis
## BUG - The function doesn't except "micrometers" as a unit
#capsuleArray[0].translateBy(pm.datatypes.Vector(0, 0, 10, unit='millimeters'))
## A sphere is added at the center of the capsule.
#sphereArray = pm.polySphere(r=1)
## Move the sphere 10 units along the z axis
## BUG - The function doesn't except "micrometers" as a unit
#sphereArray[0].translateBy(pm.datatypes.Vector(0, 0, 10, unit='millimeters'))
## The capsule and sphere are grouped
#group = pm.group(capsuleArray[0].nodeName(), sphereArray[0].nodeName())
def _setupSide_ParticleExpressions(particleShapeName='',
                                   type='splash',
                                   boatWorldCtrl='',
                                   boatName='',
                                   cPoS='',
                                   sideAnimatable=''):
    """
    Setup the expressions for the sideEmitter's nParticleShape node
    @param particleShapeName: The name of the nParticleShape node
    @param boatWorldCtrl: The name of the boatWorldCtrl curve
    @param boatName: The name of the boat should be stripped :
    @type particleShapeName: String
    @type boatWorldCtrl: String
    @type boatName: String
    """

    if type == 'splash':
        ############################
        ## Creation
        expStringList = [
            '%s.lifespanPP = rand(%s.lifespanMin, %s.lifespanMax);\n' %
            (particleShapeName, sideAnimatable, sideAnimatable),
            '%s.twistSpeedPP = rand(%s.twistSpeedMin, %s.twistSpeedMax);\n' %
            (particleShapeName, sideAnimatable, sideAnimatable),
            '%s.spriteStartSizePP = rand(%s.spriteStartSizeMin, %s.spriteStartSizeMax);\n'
            % (particleShapeName, sideAnimatable, sideAnimatable),
            '%s.spriteScaleYPP = %s.spriteScaleXPP = %s.spriteStartSizePP;\n' %
            (particleShapeName, particleShapeName, particleShapeName),
            '%s.spriteTwistPP = rand(%s.twistAngleMin, %s.twistAngleMax);\n' %
            (particleShapeName, sideAnimatable, sideAnimatable),
        ]

        ## Check if the expression already exists in the scene, if so delete it
        utils.checkExpressionExists('%s_sprite_settings' % particleShapeName)

        ## Build new expression
        cmds.dynExpression(particleShapeName,
                           n="%s_sprite_settings" % particleShapeName,
                           creation=True,
                           string=utils.processExpressionString(expStringList))

        ############################
        ## Runtime Before Dynamics
        expStringList = [
            '%s.spriteScaleYPP = %s.spriteScaleXPP = %s.spriteStartSizePP * %s.scaleOverLifeRamp;\n'
            % (particleShapeName, particleShapeName, particleShapeName,
               particleShapeName),
            '%s.spriteScaleXPP = %s.spriteScaleYPP;\n' %
            (particleShapeName, particleShapeName),
            '%s.spriteTwistPP += (%s.twistSpeedPP * %s.twistRateOverLife);\n' %
            (particleShapeName, particleShapeName, particleShapeName),
            '\n',
        ]

        ## Check if the expression already exists in the scene, if so delete it
        utils.checkExpressionExists('%s_sprite_settings' % particleShapeName)

        ## Build new expression
        cmds.dynExpression(particleShapeName,
                           n="%s_sprite_settings" % particleShapeName,
                           rbd=True,
                           string=utils.processExpressionString(expStringList))

        ## Connect some attrs to animatable group
        attrs = ['inheritFactor', 'conserve', 'drag', 'damp']
        for att in attrs:
            if not cmds.isConnected('%s.%sSprite' %
                                    (sideAnimatable, att), '%s.%s' %
                                    (particleShapeName, att)):
                cmds.connectAttr('%s.%sSprite' % (sideAnimatable, att),
                                 '%s.%s' % (particleShapeName, att),
                                 force=True)

    elif type == 'mist':
        ## Creation
        expStringList = [
            '%s.lifespanPP = rand(%s.lifespanMin, %s.lifespanMax);\n' %
            (particleShapeName, sideAnimatable, sideAnimatable),
        ]

        ## Check if the expression already exists in the scene, if so delete it
        utils.checkExpressionExists('%s_sprite_settings' % particleShapeName)

        ## Build new expression
        cmds.dynExpression(particleShapeName,
                           n="%s_sprite_settings" % particleShapeName,
                           creation=True,
                           string=utils.processExpressionString(expStringList))

        ## Connect some attrs to animatable group
        attrs = ['inheritFactor', 'conserve', 'drag', 'damp']
        for att in attrs:
            if not cmds.isConnected('%s.%sMist' %
                                    (sideAnimatable, att), '%s.%s' %
                                    (particleShapeName, att)):
                cmds.connectAttr('%s.%sMist' % (sideAnimatable, att),
                                 '%s.%s' % (particleShapeName, att),
                                 force=True)
def particleLocators(particle,
                     bakeSimulation=False,
                     rotate=False,
                     scale=False,
                     start=0,
                     end=-1,
                     prefix=''):
    '''
	'''
    # Check Particle
    if not mc.objExists(particle):
        raise Exception('Object "' + nParticle +
                        '" is not a valid particle or nParticle object!')

    # Check Prefix
    if not prefix: prefix = particle

    # Get particle count
    count = mc.getAttr(particle + '.count')
    if not count: raise Exception('Invalid particle count! (' + count + ')')

    # Create locators
    partiLocs = [
        mc.spaceLocator(n=prefix + '_loc' + str(i))[0] for i in range(count)
    ]
    partiLocsGrp = prefix + '_locGrp'
    if not mc.objExists(partiLocsGrp):
        partiLocsGrp = mc.group(em=True, n=partiLocsGrp)
    mc.parent(partiLocs, partiLocsGrp)

    # For each particle, set locator position
    for i in range(count):
        pt = mc.pointPosition(particle + '.pt[' + str(i) + ']')
        mc.setAttr(partiLocs[i] + '.t', *pt)
        if rotate:
            rt = mc.particle(particle, q=True, at='rotatePP', id=i)
            mc.setAttr(partiLocs[i] + '.r', *rt)
        if scale:
            sc = mc.particle(particle, q=True, at='scalePP', id=i)
            mc.setAttr(partiLocs[i] + '.s', *sc)

    # Bake Simulation
    if (bakeSimulation):

        # Append particle expression
        expStr = '\n\n//--\n'
        expStr += 'int $id = id;\n'
        expStr += 'vector $pos = pos;\n'
        expStr += 'string $loc = ("' + prefix + '_loc"+$id);\n'
        expStr += 'if(`objExists $loc`){'
        expStr += '\t move -a ($pos.x) ($pos.y) ($pos.z) $loc;\n'
        if rotate:
            expStr += '\tvector $rot = rotatePP;\n'
            expStr += '\t rotate -a ($rot.x) ($rot.y) ($rot.z) $loc;\n'
        if scale:
            expStr += '\tvector $scl = scalePP;\n'
            expStr += '\t scale -a ($scl.x) ($scl.y) ($scl.z) $loc;\n'
        expStr += '}'

        # Old expression string
        oldRadStr = mc.dynExpression(particle, q=True, s=True, rad=True)

        # Apply particle expression
        mc.dynExpression(particle, s=oldRadStr + expStr, rad=True)

        # Bake to keyframes
        if end < start:
            start = mc.playbackOptions(q=True, min=True)
            end = mc.playbackOptions(q=True, max=True)
        bakeAttrs = ['tx', 'ty', 'tz']
        if rotate: bakeAttrs.extend(['rx', 'ry', 'rz'])
        if scale: bakeAttrs.extend(['sx', 'sy', 'sz'])
        mc.bakeSimulation(partiLocs, at=bakeAttrs, t=(start, end))

        # Restore particle expression
        mc.dynExpression(particle, s=oldRadStr, rad=True)
def setColor(*argv):
    rgb = cmds.colorSliderGrp("GalaxyColor", q = True, rgbValue = True)
    rgb = ', '.join(str(i) for i in rgb)
    rgb = 'rgbPP = rand(<<0, 0, 0.6>>,<<' + str(rgb) + '>>)'
    cmds.dynExpression("Galaxy_StarShape", s = rgb, creation = True, runtimeAfterDynamics = True)    
    cmds.dynExpression("Galaxy_CloudShape", s = rgb, creation = True, runtimeAfterDynamics = True) 
Exemple #26
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()
    def __publish_maya_nParticle_export(self, item, output, work_template, primary_publish_path, 
                                        sg_task, comment, thumbnail_path, progress_cb):
        """
        Publish a Maya export selected for the selected nParticle systems and publish it to Shotgun.
        
        :param item:                    The item to publish
        :param output:                  The output definition to publish with
        :param work_template:           The work template for the current scene
        :param primary_publish_path:    The path to the primary published file
        :param sg_task:                 The Shotgun task we are publishing for
        :param comment:                 The publish comment/description
        :param thumbnail_path:          The path to the publish thumbnail
        :param progress_cb:             A callback that can be used to report progress
        """
        # determine the publish info to use
        #

        print("Running maya export selected command...")
        progress_cb(10, "Determining publish details")


        # get the current scene path and extract fields from it
        # using the work template:
        scene_path = os.path.abspath(cmds.file(query=True, sn=True))
        fields = work_template.get_fields(scene_path)
        publish_version = fields["version"]
        tank_type = output["tank_type"]
        fields["grp_name"] = str(item['name']).split("|")[1]
                
        print("Got fields...")
        print("Applying fields...")

        # create the publish path by applying the fields 
        # with the publish template:
        publish_template = output["publish_template"]
        publish_path = publish_template.apply_fields(fields)

        # publish name, NO VERSION NUMBERS HERE
        # This should be a name that's the same accross all publishes so the Loader app can group them to create a version history
        # @TODO: Set up a template or something to handle this nicely, ideally this would be: basename.(publish_path) - {version} and {extension}
        publish_name = "nParticle_" + fields["grp_name"] + "_" + fields["name"]
        #publish_name = os.path.basename(publish_path)

        # Also get the cache template to copy over the particle cache as well
        # @TODO: Read this from *_step.yml, for now I'm just applying a naming convention
        cache_template = sgtk.platform.current_engine().get_template_by_name(output["publish_template"].name.replace("nparticle","nparticle_cache"))

        print("Applied fields to templates...")
        print(publish_path)
    
        # Find additional info from the scene:
        #

        progress_cb(10, "Analysing scene")

        # The main body of this export:
        # Select each node in the hierarchy above a particle system and a bunch of related nodes, such as instancers, cache nodes and the nucleus node
        selection = []
 
        for nParticle_object in cmds.ls(item["name"], dag=True, type="nParticle", long=True):

            # get the name of the particle system           
            split_path = str(nParticle_object).split("|")[1:]
            
    
            print(split_path)
            # get all instancers connected to the particle system and append it to the selection list
            con = cmds.listConnections(split_path[len(split_path)-1:], type="instancer")
            if con:
                for i in set(con):
                    selection.extend(cmds.ls(i, long=True))
            
            print(con)
            # get all instances connected to the instancer and append it to the selection list
            if con:
                inst = cmds.particleInstancer(split_path[len(split_path)-1:], q=True, object=True)
                if inst:
                    for i in set(inst):
                        selection.extend(cmds.ls(i, long=True))
            
                print(inst)
            # get the cache node, append it to the selection list and copy the cache to the publishing directory
            cache = cmds.listConnections(split_path[len(split_path)-1:], type="cacheFile")
            print(cache)
            if cache:
                for i in set(cache):
                    print("copy cache loop!")
                    # append cache node to selection
                    selection.extend(cmds.ls(i, long=True))
    
                    # modify a copy of "fields" to add the node name, the "grp_name" field is used for this
                    # This is done to make sure all caches stay unique and with the correct node
                    temp_fields = fields
                    #temp_fields["grp_name"] = "{0}".format(cmds.getAttr('{0}.cacheName'.format(i)))
                    cache_path = cache_template.apply_fields(temp_fields).replace("\\", "/")
                    
                    print("start copy!")
                    progress_cb(30, "Copying Cache")
    
                    # Copy the cache files to the publishing folder, this takes a while
                    # @TODO: More interactive feedback for the user
                    # @TODO2: Optimize, run this in background so the user can continue working and 
                    # make sure the files aren't copied locally first if they're moving from 1 location on the server
                    # to another location on the server
                    dirutil.copy_tree(cmds.getAttr('{0}.cachePath'.format(i)), cache_path)
                    
                    print("copy done!")

                    progress_cb(50, "Analyzing scene")
    
                    # Set the path of the cache node to the new location, 
                    # for some reason the setAttr MEL command for this is more reliable than the python setAttr command... 
                    mel.eval('setAttr -type "string" {0}.cachePath "{1}"'.format(i, cache_path))
    
                    print("cache path set!")
            
            # Get all nucleus nodes and append them to the selection list           
            nucleus = cmds.listConnections(split_path[len(split_path)-1:], type="nucleus")
            if nucleus:
                for i in set(nucleus):
                    selection.extend(cmds.ls(i, long=True))
            
            print(nucleus)

            # Get all display layers and appends them to the selection list
            #for i in cmds.ls(type="displayLayer"):
            #    selection.extend(cmds.ls(i, long=True))
                    
            selection.append(nParticle_object)

            # Remove all expressions from the particle systems in the selection as these can cause issues
            cmds.dynExpression(nParticle_object, c=True, s="")
            cmds.dynExpression(nParticle_object, rbd=True, s="")
            cmds.dynExpression(nParticle_object, rad=True, s="")
    
        # Get display layers the object is in and appends them to the selection list
        print(selection)
        for i in range(len(selection)):
            split_sel = selection[i].split("|")
            print split_sel
            if len(split_sel) > 1:
                dispLayer = cmds.listConnections(list(split_sel[1:]), type="displayLayer")
            else:
                dispLayer = cmds.listConnections(str(split_sel[0]), type="displayLayer")
            
            print(dispLayer)
            if dispLayer:
                for i in set(dispLayer):
                    selection.extend(cmds.ls(i, long=True))

        # Make a set of the selection list to get rid of duplicate entries
        selection = set(selection)

        print("test")
        print(selection)

        # Because we want to delete everything except what is in the selection list
        # we select everything and then deselect the things in the selection list
        cmds.select(all=True, hi=True)
        for i in selection:
            split_sel = i.split("|")
            if len(split_sel) > 1:
                cmds.select(split_sel[1:], deselect=True)
            else:
                cmds.select(split_sel[0], deselect=True)

        print("test2")
        self.parent.log_debug("Executing delete, export selection and reopen")

        # delete everything that is selected now
        cmds.delete()
        
        print("test3")

        # clear the selection, just in case things didn't get deleted for some reason (ie, maya system nodes, reference nodes, etc.)
        # then select everything to be exported again
        cmds.select(clear=True)
        for i in selection:
            split_sel = i.split("|")
            if len(split_sel) > 1:
                cmds.select(split_sel[1:], add=True)
            else:
                cmds.select(split_sel[0], add=True)
      

        progress_cb(60, "Export scene and reopening file")

        # get the current file, so we can reopen it after saving
        old_file = cmds.file(q=True,sceneName=True)

        # rename the file and "export selected"
        cmds.file(rename=publish_path)
        cmds.file(exportSelected=True,type='mayaAscii',force=True)

        # create a new empty file in case it's easier to open from
        cmds.file(new=True, force=True)
        # open the old file from before for the publish registration, otherwise the template won't fit
        # could this cause issues?
        cmds.file(old_file, open=True)

        print("Registering Export Publish")

        # all data to register the publish
        # NOTE!!: publish_path has to have backslashes, forward slashes cause the publish to fail!
        progress_cb(75, "Registering the publish")        
        args = {
            "tk": self.parent.tank,
            "context": self.parent.context,
            "comment": comment,
            "path": publish_path,
            "name": publish_name,
            "version_number": publish_version,
            "thumbnail_path": thumbnail_path,
            "task": sg_task,
            "dependency_paths": [primary_publish_path],
            "published_file_type":tank_type
        }

        # register the publish
        tank.util.register_publish(**args)

        print("Finished Registering Export Publish")
Exemple #28
0
def set_goals():

    sel = cmds.ls(sl=True, l=True)

    # make sure we have at least two items
    if len(sel) < 2:
        print 'Please select a nParticle system followed by the objects to set as goals'
        return

    elif len(sel) > 2:
        print 'For inital goal we want one particle system and one object to goal!'
        print 'Try again :)'
        return

    print sel

    # from the list make sure the first object is a nparticle system, get a handle on this
    # then remove from the list
    if not cmds.objectType(sel[0]) == 'nParticle':

        shape = cmds.listRelatives(sel[0])[0]

        if not cmds.objectType(shape) == 'nParticle':
            print 'Please select a nParticle system followed by objects to goal to!'
            return

        else:
            npSystem = sel.pop(0)
            npShape = shape

    else:
        npShape = sel.pop(0)
        npSystem = cmds.listRelatives(npShape, parent=True, f=True)

    obj = sel[0]

    selList = om.MSelectionList()
    selList.add(npShape)

    npDag = om.MDagPath()
    npMObj = om.MObject()

    selList.getDependNode(0, npMObj)
    selList.getDagPath(0, npDag)

    npNode = om.MFnDependencyNode(npMObj)
    npFnPart = omfx.MFnParticleSystem(npDag)

    if _get_goal(npDag):
        print 'Particle system already has goal. For now we are only supporting one goal!'
        return

    cmds.goal(npSystem, g=obj, w=1)

    set_initial_state(npNode, npFnPart)

    print '#------------------------------#'

    creation_dynExpression = ('.goalV = 0;\n'
                              '.goalU = 0;\n'
                              '.goalWeight0PP = .2;\n'
                              '.verticalSpeedPP = rand(0.01, 0.1);\n'
                              '.rotationRatePP = rand(0.03, 0.05);\n'
                              '.jitterIntervalPP = 0;\n'
                              '.jitterStepPP = 0;\n'
                              '.jitterRangePP = 0;\n'
                              '.lifespanPP = 5;')
    runtime_dynExpression = ('.goalV += .verticalSpeedPP;\n'
                             '.goalU += .rotationRatePP;\n\n'
                             'if (.jitterIntervalPP > .jitterStepPP)\n'
                             '{\n'
                             '\t.jitterStepPP ++;\n'
                             '}\n'
                             'else\n'
                             '{\n'
                             '\t.goalU += .jitterValuePP;\n'
                             '\t$hiRange = rand(0, .jitterRangePP);\n'
                             '\t$loRange = $hiRange * -1;\n'
                             '\t.jitterValuePP = rand($loRange, $hiRange);\n'
                             '\t.jitterStepPP = 0;\n'
                             '}\n\n'
                             'if (.goalU > 1)\n'
                             '{\n'
                             '\t.goalU -= 1;\n'
                             '}\n'
                             'else if(.goalU < 0)\n'
                             '{\n'
                             '\t.goalU += 1;\n'
                             '}')

    cmds.dynExpression(npShape, creation=True, string=creation_dynExpression)
    cmds.dynExpression(npShape, rbd=True, string=runtime_dynExpression)

    # now we want to make our goal object a passive rigid body so that
    # the particles don't go through it
    cmds.select(obj)

    print 'Selection is: %s' % cmds.ls(sl=True)

    # make our goal object a passive rigid body so the particles
    # can collide with it
    cmd = 'makeCollideNCloth'
    rigidShape = mel.eval(cmd)

    # rigid shape is not created if it already exists!
    if rigidShape:
        # parent the rigid body to keep things tidy
        nRigid = cmds.listRelatives(rigidShape[0], parent=True, f=True)
        #cmds.parent(nRigid, dynamics_grp)

    # select our particle system to tidy things up
    cmds.select(npSystem)
Exemple #29
0
def miSequence(start=None, end=None):
    '''{'path':'Rendering/Render/miSequence()ONLYSE',
'icon' : ':/menuIconRender.png',
'tip' : '将物体转为mentalray代理的粒子替代',
'usage':'$fun( start=0, end=100)',
}
'''
    projDir = cmds.workspace(q=1, rootDirectory=1)
    proxyFolder = os.path.join(projDir, 'data/mrProxyFiles')

    if os.path.exists(proxyFolder) == False:
        os.makedirs(proxyFolder)

    exportObjs = cmds.ls(sl=True)

    if start == None:
        start = cmds.playbackOptions(q=True, min=True)

    if end == None:
        end = cmds.playbackOptions(q=True, max=True)

    end = end + 1

    pad = 5

    padStr = '%0' + '%sd' % (pad)

    #print padStr

    subFolder = exportObjs[0]

    finalFolder = proxyFolder + '/' + subFolder
    if os.path.exists(finalFolder) == False:
        os.makedirs(finalFolder)

    import mentalray.renderProxyUtils

    proxyObjs = []
    for i in range(start, end):
        cmds.currentTime(i)
        exec('frameStr = padStr%(i)')
        miName = '%s_s.%s.mi' % (exportObjs[0], frameStr)
        miFilePath = finalFolder + '/' + miName
        print miFilePath
        #miFilePath = 'F:/t.mi'
        cmds.select(exportObjs, r=True)
        mel.eval(
            'Mayatomr -mi  -exportFilter 721600 -active -binary -fe  -fem  -fma  -fis  -fcd  -pcm  -as -asn "%s" -xp "3313333333" -file "%s";'
            % (exportObjs[0] + "_s", miFilePath))

        proxyName = miName.replace('.', '-')
        proxyObj = cmds.polyCube(ch=False, name=proxyName)[0]
        proxyObjs.append(proxyObj)
        boxShape = cmds.listRelatives(proxyObj, shapes=True)[0]

        cmds.setAttr(proxyObj + '.miProxyFile', miFilePath, type='string')

        mentalray.renderProxyUtils.resizeToBoundingBox(boxShape)
        cmds.setAttr(proxyObj + ".t", lock=True)
        cmds.setAttr(proxyObj + ".r", lock=True)
        cmds.setAttr(proxyObj + ".s", lock=True)

    cmds.currentTime(start)
    nPar, parShape = cmds.nParticle()
    cmds.setAttr(parShape + '.collide', 0)
    cmds.setAttr(parShape + ".conserve", 0)
    cmds.setAttr(parShape + ".dynamicsWeight", 0)
    cmds.setAttr(parShape + ".particleRenderType", 2)

    #cmds.setAttr( parShape+".selectedOnly", 1)

    cmds.addAttr(parShape, ln="cus_index0", dt="doubleArray")
    cmds.addAttr(parShape, ln="cus_index", dt="doubleArray")

    mel.eval('emit -object nParticle1 -pos 0 0 0')

    expString = "cus_index = clamp(0, %i, frame-%i);" % (end - start - 1,
                                                         start)

    cmds.dynExpression(parShape, s=expString, c=True)
    cmds.dynExpression(parShape, s=expString, rbd=True)

    instancerObj = cmds.particleInstancer(parShape,
                                          addObject=True,
                                          object=proxyObjs,
                                          cycle='None',
                                          cycleStep=1,
                                          cycleStepUnits='Frames',
                                          levelOfDetail='Geometry',
                                          rotationUnits='Degrees',
                                          rotationOrder='XYZ',
                                          position='worldPosition',
                                          age='age')
    cmds.particleInstancer(parShape,
                           e=True,
                           name=instancerObj,
                           objectIndex='cus_index')

    cmds.saveInitialState(parShape)

    miGrp = cmds.group(proxyObjs, n=exportObjs[0] + '_s_mi')
    cmds.setAttr(miGrp + '.v', False)
    cmds.setAttr(miGrp + '.v', lock=True)
    papaGrp = cmds.group([nPar, miGrp, instancerObj],
                         n=exportObjs[0] + '_mi_group')

    for obj in (nPar, miGrp, instancerObj, papaGrp):
        cmds.setAttr(obj + ".t", lock=True)
        cmds.setAttr(obj + ".r", lock=True)
        cmds.setAttr(obj + ".s", lock=True)
Exemple #30
0
def addParByTFSet(tfSet=cmds.ls(sl=True, exactType='objectSet')):
    '''{'del_path':'TfCtrl/Add/Set/addParByTFSet( tfSet = cmds.ls(sl=True, exactType="objectSet") )',
'usage':'$fun( tfSet = cmds.ls(sl=True, exactType="objectSet") )',
}
'''
    #tfSet = cmds.ls(sl=True, type='objectSet')[0]
    if isinstance(tfSet, list):
        tfSet = tfSet[0]
    cmds.lockNode(tfSet, l=False)
    objects = cmds.listConnections(tfSet + '.dagSetMembers', d=False)

    createNewPar = True

    if cmds.attributeQuery(
            'setType', n=tfSet,
            exists=True) and cmds.getAttr(tfSet + '.setType') == 1:
        raise IOError('This set type is three particle controls!')

    if cmds.attributeQuery(
            'setType', n=tfSet, exists=True) and cmds.attributeQuery(
                'posPar', n=tfSet, exists=True) and cmds.objExists(
                    cmds.getAttr(tfSet + '.posPar')):
        createNewPar = False

    if createNewPar:
        for attr in ['posPar', 'aimPar', 'upPar']:
            if cmds.attributeQuery(attr, n=tfSet,
                                   exists=True) and cmds.objExists(
                                       cmds.getAttr('%s.%s' % (attr))):
                cmds.delete(cmds.getAttr('%s.%s' % (attr)))

        delAttr(tfSet, ['setType', 'posPar', 'aimPar', 'upPar'])

        cmds.addAttr(tfSet,
                     ln="setType",
                     at="enum",
                     en="singlePar:threePar:",
                     k=False,
                     r=False)
        cmds.setAttr(tfSet + '.setType', 0, l=True)
        cmds.addAttr(tfSet, ln="posPar", dt="string")
        nPar = cmds.nParticle(n='%s_nPar' % (tfSet))
        cmds.setAttr(nPar[0] + '.t', l=True)
        cmds.setAttr(nPar[0] + '.r', l=True)
        cmds.setAttr(nPar[0] + '.s', l=True)

        nParShape = nPar[1]
        cmds.setAttr(tfSet + '.posPar', nParShape, type='string', l=True)
        cmds.setAttr("%s.computeRotation" % (nParShape), 1)

        cmds.addAttr(nParShape, ln="cus_toObjPos", dt='doubleArray')
        cmds.addAttr(nParShape, ln="cus_toObjPos0", dt='doubleArray')
    else:
        nParShape = cmds.getAttr(tfSet + '.posPar')
        cmds.lockNode(nParShape, l=False)

    #Add particles and set attributes(goalU, goalV, cus_bbsiRadius) initialize states
    posLi, radiusLi, atULi, atVLi = [], [], [], []
    for tfNode in objects:
        objPos = cmds.objectCenter(tfNode)
        bbsize = cmds.getAttr(tfNode + '.bbsi')[0]
        radius = newom.MVector(bbsize).length() / 2
        atU = cmds.getAttr(tfNode + '.atU')
        atV = cmds.getAttr(tfNode + '.atV')
        posLi.append(objPos)
        radiusLi.append(radius)
        atULi.append(atU)
        atVLi.append(atV)

    qsEmit(object = nParShape, position=posLi, attributes=( ('cus_radiusPP', 'floatValue', radiusLi), ('goalU', 'floatValue', atULi),\
                                                                   ('goalV', 'floatValue', atVLi) )\
                  )

    cmds.lockNode(tfSet, l=True)

    if createNewPar:
        ##creation expression
        #parCExpStr = cmds.dynExpression(nParShape, q=True,s=True, c=True)
        parCExpStr = '\n\n\
/*string $tfNode = $%s[int(particleId)];\n\
goalU = `getAttr ($tfNode+".atU")`;\n\
goalV = `getAttr ($tfNode+".atV")`;\n\
cus_toObjPos = 0;*/' % (tfSet)

        cmds.dynExpression(nParShape, s=parCExpStr, c=True)

        ##runtime after dynamics expression
        #parRADExpStr = cmds.dynExpression(nParShape, q=True, s=True, rad=True)
        parRADExpStr = '\n\n\
/*string $tfNode = $%s[int(particleId)];\n\n\
\
if (cus_toObjPos == 1){\n\
    float $pos[] = position;\n\
    vector $rotate = rotationPP;\n\
    setAttr ($tfNode + ".pBInT2") -type "double3" ($pos[0]) ($pos[1]) ($pos[2]);\n\
    setAttr ($tfNode + ".pBInR2") -type "double3" ($rotate.x) ($rotate.y) ($rotate.z);\n\
}\n\n\
\
\
if (goalPP==0 && cus_toObjPos==0){\n\
    cus_toObjPos = 1;\n\
    float $pos[] = `getAttr ($tfNode+".translate")`;\n\
    position = <<$pos[0], $pos[1], $pos[2]>>;\n\
    vector $rotate = rotationPP;\n\
    setAttr ($tfNode + ".pBInT2") -type "double3" ($pos[0]) ($pos[1]) ($pos[2]);\n\
    setAttr ($tfNode + ".pBInR2") -type "double3" ($rotate.x) ($rotate.y) ($rotate.z);\n\
    setAttr ($tfNode+".pBWeight") 1;\n\
    setAttr ($tfNode+".follicleNodeState") 2;\n\
}*/' % (tfSet)
        cmds.dynExpression(nParShape, s=parRADExpStr, rad=True)

        ######################################create script nodes########################################
        ####openCloseMel script node   Execute On:Open/close
        openCloseMelStr = '\n\n\
///////////for TFNode by Particles/////////////////////\n\
global string $%s[];\n\
$%s = `listConnections  -d off "%s.dagSetMembers"`;\n' % (tfSet, tfSet, tfSet)
        mel.eval(openCloseMelStr)
        if cmds.objExists("QS_VFX_M_OC"):
            existsStr = cmds.scriptNode('QS_VFX_M_OC', q=True, bs=True)
            openCloseMelStr += existsStr
            cmds.scriptNode('QS_VFX_M_OC', e=True, bs=openCloseMelStr)
        else:
            cmds.scriptNode(n='QS_VFX_M_OC',
                            scriptType=1,
                            bs=openCloseMelStr,
                            sourceType='mel')
            cmds.setAttr('QS_VFX_M_OC.scriptType', l=True)

        ####timeChangedMel script Node    Execute on: Time changed
        timeChangedMelStr = '\n\n\
///////////for TFNode by Particles/////////////////////\n\
int $current = `currentTime -q`;\n\
int $start = `playbackOptions -q -min`;\n\
if ($current == $start){\n\
    //%s is a global variable, Declare in QS_VFX_M_QC script node.\n\
    $%s = `listConnections  -d off "%s.dagSetMembers"`; \n\
    for ($tfNode in $%s){\n\
        setAttr($tfNode+".follicleNodeState") 0;\n\
        setAttr($tfNode+".pBWeight") 0;\n\
    }\n\
}' % (tfSet, tfSet, tfSet, tfSet)

        mel.eval(timeChangedMelStr)
        if cmds.objExists("QS_VFX_M_TC"):
            existsStr = cmds.scriptNode('QS_VFX_M_TC', q=True, bs=True)
            timeChangedMelStr += existsStr
            cmds.scriptNode('QS_VFX_M_TC', e=True, bs=timeChangedMelStr)
        else:
            cmds.scriptNode(n='QS_VFX_M_TC',
                            scriptType=7,
                            bs=timeChangedMelStr,
                            sourceType='mel')
            cmds.setAttr('QS_VFX_M_TC.scriptType', l=True)