def radioEventHandler(self):
""" FOR WORD: choose color style of the word"""
if self.radio_deColor.isChecked():
self.hSl_R.setEnabled(False)
self.hSl_B.setEnabled(False)
self.hSl_G.setEnabled(False)
self.dial.setEnabled(False)
if self.radio_setColor.isChecked():
self.hSl_R.setEnabled(True)
self.hSl_B.setEnabled(True)
self.hSl_G.setEnabled(True)
self.dial.setEnabled(True)
else:
self.hSl_R.setSliderPosition(500)
self.lcd_R.display(0.5)
self.hSl_B.setSliderPosition(500)
self.lcd_B.display(0.5)
self.hSl_G.setSliderPosition(500)
self.lcd_G.display(0.5)
pm.dynExpression(self.wordPar[-1], s='rgbPP=position;', rbd=1)
def BHandler(self):
""" FOR WORD: change blue"""
slider = self.sender()
val = slider.value()
# print("val",val)
self.setRGB['b'] = val * 0.001
self.lcd_B.display(self.setRGB['b'])
pm.dynExpression(
self.wordPar[-1],
s="rgbPP=<<%s,%s,%s>>;" %
(self.setRGB['r'], self.setRGB['g'], self.setRGB['b']),
rbd=1)
def DialHandler(self):
""" FOR WORD: change color with dial"""
slider = self.sender()
val = slider.value()
r = val
g = val
b = val
# count the value of RGB
if val <= 150:
r = 1
elif (val > 150 and val <= 180):
r = 1 - (val - 150) / 30.000
elif val > 330:
r = (val - 330) / 30.000
else:
r = 0
if (val <= 30 or val > 240):
g = 1
elif (val > 30 and val <= 60):
g = 1 - (val - 30) / 30.000
elif (val > 210 and val <= 240):
g = (val - 210) / 30.000
else:
g = 0
if (val > 120 and val <= 270):
b = 1
elif (val > 90 and val <= 120):
b = (val - 90) / 30.000
elif (val > 270 and val <= 300):
b = 1 - (val - 270) / 30.000
else:
b = 0
print r
print g
print b
pm.dynExpression(self.wordPar[-1],
s="rgbPP=<<%s,%s,%s>>;" % (r, g, b),
rbd=1)
def read_exp(self):
result = {}
expressions = {
"crt": pc.dynExpression(self.nparticle, q=True, c=True),
"rbd": pc.dynExpression(self.nparticle, q=True, rbd=True),
"rad": pc.dynExpression(self.nparticle, q=True, rad=True)
}
for key in self.exp_json.keys():
tag_begin = "//__%s_Start_Tag__\n" % key
tag_end = "//__%s_End_Tag__" % key
for ek, value in expressions.items():
pos_start = value.find(tag_begin)
pos_end = value.find(tag_end)
if pos_start != -1 and pos_end != -1:
result[key] = {}
result[key]["attrs"] = self.exp_json[key]["attrs"]
result[key]["exp"] = {"crt": "", "rbd": "", "rad": ""}
for ek, value in expressions.items():
pos_start = value.find(tag_begin)
pos_end = value.find(tag_end)
if pos_start != -1 and pos_end != -1:
result[key]["exp"][ek] = value[pos_start:pos_end +
len(tag_end)]
# for key, value in result.items():
# print key
# for k, v in value.items():
# print k
# print v
return result
def _dynExpr(self, *args):
self.numInstances=self.numInst.getText()
if self.nparticle!=None:
npShape=self.nparticle[1]
else:
child=''
for nparticle in pm.ls(sl=True):
child = nparticle.listRelatives(c=True,s=True,type='nParticle')[0]
npShape=child
l1 = 'seed ('+npShape+'.particleId);'
l2 = npShape+'.scalePP = rand (0.5, 1.8);'
l3 = 'if ('+npShape+'.particleId%6==0) '+npShape+'.scalePP = 3;'
l4 = npShape+'.rotPP = rand (<<0, 0, 0>>, <<359, 359, 359>>);'
l5 = npShape+'.indexPP = floor (rand ('+self.numInstances+'));'
l6 = npShape+'.posPP = '+npShape+'.worldPosition;'
l7 = 'vector $wp = '+npShape+'.worldPosition;'
l8 = npShape+'.posPP = <<$wp.x, ($wp.y*mag('+npShape+'.scalePP)), $wp.z>>;'
expr=[l1,l2,l3,l4,l5,l6,l7,l8]
print npShape
pm.dynExpression(npShape, s="\n".join(expr), c=True)
print 'Creation Expression for %s Updated' % npShape
def write_exp(self):
tmp = self.exp_par
crt_exp = rbd_exp = rad_exp = "\n"
for key in ["staticSeed", "randomLifespan", "flowingOn"]:
if key in tmp.keys():
if "crt" in tmp[key]["exp"].keys():
crt_exp += "\n" + tmp[key]["exp"]["crt"]
tmp[key]["exp"].pop("crt")
if "rbd" in tmp[key]["exp"].keys():
rbd_exp += "\n" + tmp[key]["exp"]["rbd"]
tmp[key]["exp"].pop("rbd")
if "rad" in tmp[key]["exp"].keys():
rad_exp += "\n" + tmp[key]["exp"]["rad"]
tmp[key]["exp"].pop("rad")
for key, value in tmp.items():
if "crt" in value["exp"].keys():
crt_exp += "\n" + value["exp"]["crt"]
if "rbd" in value["exp"].keys():
rbd_exp += "\n" + value["exp"]["rbd"]
if "rad" in value["exp"].keys():
rad_exp += "\n" + value["exp"]["rad"]
# print crt_exp
pc.dynExpression(self.nparticle, s=crt_exp, c=True)
pc.dynExpression(self.nparticle, s=rbd_exp, rbd=True)
pc.dynExpression(self.nparticle, s=rad_exp, rad=True)
def updateDynExpressionCreation(self, particleShape):
pm.setAttr(self.partShape + ".radiusPP", l=0)
if self.DynState == 1:
expression = """
if (rgbPP == << 1,1,1 >>)
{
position = fixPosPP;
}
"""
expression += "if(age>={0} && rgbPP != <<0,1,0>> && rgbPP != <<1,1,1>>)\n".format(
self.ui.simulationAge_le.text()
)
expression += """
{
lifespanPP=0;
}
if (rgbPP != <<1,1,1>> && rgbPP == <<0,1,0>> && mag(position - lastPosition) >= 2)
{
lifespanPP=0;
}
"""
elif self.DynState == 2:
expression = """
if ((opacityPP == 0 || mag(position - lastPosition) >= 2) && rgbPP != <<1,1,1>>)
{
lifespanPP=0;
}
else
{
rgbPP = <<1,1,1>>;
fixPosPP = position;
}
"""
else:
expression = """
vector $pos = position;
position = << $pos.x, $pos.y - (radiusPP/2) ,$pos.z >>;
"""
pm.dynExpression(self.partShape, s=expression, runtimeAfterDynamics=True)
l = []
for i, x in enumerate(self.listInstance):
inst = self.getRowByName(x.getAttr("originalMesh").name())
typ = inst["type"]
if "Large" == typ and self.ui.simulationlarge_cb.isChecked():
l.append(i)
continue
if "Medium" == typ and self.ui.simulationMedium_cb.isChecked():
l.append(i)
continue
if "Small" == typ and self.ui.simulationSmall_cb.isChecked():
l.append(i)
continue
expression = "// AUTO BUILD\n"
expression += "int $percent = rand(0,100);\n"
expression += "int $listIndex[];\n"
for i, itm in enumerate(l):
perc = self.ui.instance_tw.item(itm, self.columnsName["percent"]["id"]).text()
expression += "if($percent <= {0})//{1}\n".format(perc, str(self.listInstance[itm]))
expression += "{\n"
expression += "\t\t$listIndex[{0}] = {1};\n".format(i, itm)
expression += "}\n"
expression += "int $j = rand(0,size($listIndex));\n"
expression += "int $i = $listIndex[$j];\n"
expression += "if(size($listIndex) == 0)\n"
expression += "{\n"
expression += "\t\tlifespanPP=0;\n".format(i, itm)
expression += "}\n"
expression += "float $gScale ={0};\n".format(float(self.ui.globalScale_le.text()))
expression += "indexPP = $i;\n\n"
expression += "//Compute Radius , Scale & Rotation\n\n"
for i, itm in enumerate(self.listInstance):
expression += "if($i == {0})//{1}\n".format(i, str(itm))
expression += "{\n"
expression += "\t//Scale\n"
expression += "\tscalePP = rand({0},{1})*$gScale;\n".format(
float(self.ui.instance_tw.item(i, self.columnsName["scMin"]["id"]).text()),
float(self.ui.instance_tw.item(i, self.columnsName["scMax"]["id"]).text()),
)
expression += "\t//Radius\n"
expression += "\tradiusPP = {0}*{1}*scalePP;\n".format(
float(self.listInstanceInfo[str(itm)]["radius"]),
float(self.ui.instance_tw.item(i, self.columnsName["radius"]["id"]).text()),
)
expression += "\t//rotate\n"
rx = float(self.ui.instance_tw.item(i, self.columnsName["rx"]["id"]).text()) / 2
ry = float(self.ui.instance_tw.item(i, self.columnsName["ry"]["id"]).text()) / 2
rz = float(self.ui.instance_tw.item(i, self.columnsName["rz"]["id"]).text()) / 2
expression += "\trotatePP = << rand(-{0},{0}) , rand(-{1},{1}), rand(-{2},{2})>>;\n".format(rx, ry, rz)
expression += "\t//type\n"
typ = self.ui.instance_tw.item(i, self.columnsName["type"]["id"]).text()
if "Large" == typ:
t = 2
if "Medium" == typ:
t = 1
if "Small" == typ:
t = 0
expression += "\ttypePP = {0};\n".format(t)
expression += "}\n"
expression += "opacityPP = 0;\n"
expression += "rgbPP = <<0,0,0>>;\n"
pm.dynExpression(self.partShape, s=expression, creation=True)
pm.setAttr(self.partShape + ".radiusPP", l=1)
def updateDynExpressionCreation(self, particleShape):
pm.setAttr(self.partShape + ".radiusPP", l=0)
if self.DynState == 1:
expression = """
if (rgbPP == << 1,1,1 >>)
{
position = fixPosPP;
}
"""
expression += "if(age>={0} && rgbPP != <<0,1,0>> && rgbPP != <<1,1,1>>)\n".format(
self.ui.simulationAge_le.text())
expression += """
{
lifespanPP=0;
}
if (rgbPP != <<1,1,1>> && rgbPP == <<0,1,0>> && mag(position - lastPosition) >= 2)
{
lifespanPP=0;
}
"""
elif self.DynState == 2:
expression = """
if ((opacityPP == 0 || mag(position - lastPosition) >= 2) && rgbPP != <<1,1,1>>)
{
lifespanPP=0;
}
else
{
rgbPP = <<1,1,1>>;
fixPosPP = position;
}
"""
else:
expression = """
vector $pos = position;
position = << $pos.x, $pos.y - (radiusPP/2) ,$pos.z >>;
"""
pm.dynExpression(self.partShape,
s=expression,
runtimeAfterDynamics=True)
l = []
for i, x in enumerate(self.listInstance):
inst = self.getRowByName(x.getAttr("originalMesh").name())
typ = inst['type']
if "Large" == typ and self.ui.simulationlarge_cb.isChecked():
l.append(i)
continue
if "Medium" == typ and self.ui.simulationMedium_cb.isChecked():
l.append(i)
continue
if "Small" == typ and self.ui.simulationSmall_cb.isChecked():
l.append(i)
continue
expression = "// AUTO BUILD\n"
expression += "int $percent = rand(0,100);\n"
expression += "int $listIndex[];\n"
for i, itm in enumerate(l):
perc = self.ui.instance_tw.item(
itm, self.columnsName['percent']['id']).text()
expression += "if($percent <= {0})//{1}\n".format(
perc, str(self.listInstance[itm]))
expression += "{\n"
expression += "\t\t$listIndex[{0}] = {1};\n".format(i, itm)
expression += "}\n"
expression += "int $j = rand(0,size($listIndex));\n"
expression += "int $i = $listIndex[$j];\n"
expression += "if(size($listIndex) == 0)\n"
expression += "{\n"
expression += "\t\tlifespanPP=0;\n".format(i, itm)
expression += "}\n"
expression += "float $gScale ={0};\n".format(
float(self.ui.globalScale_le.text()))
expression += "indexPP = $i;\n\n"
expression += "//Compute Radius , Scale & Rotation\n\n"
for i, itm in enumerate(self.listInstance):
expression += "if($i == {0})//{1}\n".format(i, str(itm))
expression += "{\n"
expression += "\t//Scale\n"
expression += "\tscalePP = rand({0},{1})*$gScale;\n".format(
float(
self.ui.instance_tw.item(
i, self.columnsName['scMin']['id']).text()),
float(
self.ui.instance_tw.item(
i, self.columnsName['scMax']['id']).text()))
expression += "\t//Radius\n"
expression += "\tradiusPP = {0}*{1}*scalePP;\n".format(
float(self.listInstanceInfo[str(itm)]['radius']),
float(
self.ui.instance_tw.item(
i, self.columnsName['radius']['id']).text()))
expression += "\t//rotate\n"
rx = float(
self.ui.instance_tw.item(
i, self.columnsName['rx']['id']).text()) / 2
ry = float(
self.ui.instance_tw.item(
i, self.columnsName['ry']['id']).text()) / 2
rz = float(
self.ui.instance_tw.item(
i, self.columnsName['rz']['id']).text()) / 2
expression += "\trotatePP = << rand(-{0},{0}) , rand(-{1},{1}), rand(-{2},{2})>>;\n".format(
rx, ry, rz)
expression += "\t//type\n"
typ = self.ui.instance_tw.item(
i, self.columnsName['type']['id']).text()
if "Large" == typ: t = 2
if "Medium" == typ: t = 1
if "Small" == typ: t = 0
expression += "\ttypePP = {0};\n".format(t)
expression += "}\n"
expression += "opacityPP = 0;\n"
expression += "rgbPP = <<0,0,0>>;\n"
pm.dynExpression(self.partShape, s=expression, creation=True)
pm.setAttr(self.partShape + ".radiusPP", l=1)
def run(sliderSize, sliderDensity, sliderHeight, textSequence, ckboxTexture, ckboxSequence, ckboxCover, directionX, directionY, directionZ, snowPieceBrowser):
'''
This function is the main function to generate the snowy scene.
Args:
avgSize from sliderSize: The average size of all snow piece
density from sliderDensity: The density of the snow
maxDistance from sliderHeight: The highest distance the user want the snow to fall
snowTexture from ckboxTexture: Whether using the texture for snowflakes
snowSequence from textSequence: The length of the sequence of images as texture
directionX: directionX of gravity field
directionY: directionX of gravity field
directionZ: directionX of gravity field
coverFlag(coverObj) from ckboxCover: Decide whether the snow will cover the models and which models to cover
windFlag(windDirection, windStrength): Decide whether there are winds and the directions and strength
GLobal variables used:
startArea: The surface area the user want the snow fall from
snowPath: The file path of the snowflake texture
coverObj: The objects the particles will make collision with
Result:
a generated snowy scene animation
Return:
none
'''
## check whether the user has selected the start Area
if isset('startArea') == 0:
logger.error('Please choose a plane to start snow!')
pm.PopupError('Please choose a plane to start snow!')
return
## check whether the user has selected the objects to make collision with
if ckboxCover.getValue():
if isset('coverObj') == 0:
logger.error('Please select the objects to make collision with!')
pm.PopupError('Please select the objects to make collision with!')
return
## check whether the user has selected files for textures
snowPath = snowPieceBrowser.getText()
if ckboxTexture.getValue():
if snowPath == '':
logger.error('Please select the images for textures!')
pm.PopupError('Please select the images for textures!')
return
logger.info('Start generating the snowy scene')
snowSize = sliderSize.getValue()
snowDensity = sliderDensity.getValue()
snowHeight = sliderHeight.getValue()
snowTexture = ckboxTexture.getValue()
snowSequenceTmp = textSequence.getText()
snowSequence = int(snowSequenceTmp)
gdXs = directionX.getText()
gdYs = directionY.getText()
gdZs = directionZ.getText()
gdX = float(gdXs)
gdY = float(gdYs)
gdZ = float(gdZs)
pm.playbackOptions(ps = 0.4)
offsetSize = snowSize * 0.3
minSize = snowSize - offsetSize
maxSize = snowSize + offsetSize
startFace = startArea
emitter1 = pm.emitter(startFace, sro = True, type = 'surface', rate = snowDensity, minDistance = 0.5, mxd = 1)
particle_snow2 = pm.particle()
pm.connectDynamic(particle_snow2, em = emitter1)
## using image textures for particles
if ckboxTexture.getValue():
logger.info(' particle render type: sprite ')
pm.setAttr('%s.particleRenderType'%particle_snow2[0], 5)
pm.addAttr(particle_snow2[1], internalSet = True, longName = 'spriteTwist', attributeType = 'float', minValue = -180, maxValue = 180, defaultValue = 0.0)
pm.addAttr(particle_snow2[1], internalSet = True, ln = 'spriteScaleX', dv = 0.2)
pm.addAttr(particle_snow2[1], internalSet = True, ln = 'spriteScaleY', dv = 0.2)
pm.addAttr(particle_snow2[1], internalSet = True, ln = 'spriteNum', at = 'long', dv = 1)
pm.addAttr(particle_snow2[1], internalSet = True, ln = 'useLighting', at = 'bool',dv = False)
shader2 = pm.shadingNode('lambert', asShader = True)
file_node2 = pm.shadingNode('file', asTexture = True)
pm.setAttr('%s.fileTextureName'%file_node2, snowPath, type = 'string')
shading_group2 = pm.sets(renderable = True, noSurfaceShader = True, empty = True)
pm.setAttr('%s.ambientColor'%shader2, 1.0, 1.0, 1.0, type = 'double3')
pm.connectAttr('%s.outColor'%shader2, '%s.surfaceShader'%shading_group2, force = True)
pm.connectAttr('%s.outColor'%file_node2, '%s.color'%shader2, force = True)
pm.connectAttr('%s.outTransparency'%shader2, '%s.surfaceShader'%shading_group2, force = True)
pm.connectAttr('%s.outTransparency'%file_node2, '%s.transparency'%shader2, force = True)
pm.sets(shading_group2, e = True, forceElement = '%s'%particle_snow2[0])
if ckboxSequence.getValue():
pm.setAttr('%s.useFrameExtension'%file_node2, 1)
pm.setAttr('%s.useHardwareTextureCycling'%file_node2, 1)
pm.setAttr('%s.endCycleExtension'%file_node2, snowSequence)
pm.addAttr(particle_snow2[1], dataType = 'doubleArray', ln = 'spriteScaleXPP')
pm.addAttr(particle_snow2[1], dataType = 'doubleArray', ln = 'spriteScaleXPP0')
pm.addAttr(particle_snow2[1], dataType = 'doubleArray', ln = 'spriteScaleYPP')
pm.addAttr(particle_snow2[1], dataType = 'doubleArray', ln = 'spriteScaleYPP0')
pm.addAttr(particle_snow2[1], dataType = 'doubleArray', ln = 'spriteTwistPP')
pm.addAttr(particle_snow2[1], dataType = 'doubleArray', ln = 'spriteTwistPP0')
pm.dynExpression(particle_snow2[1], s = 'spriteScaleXPP = rand(%f,%f);\nspriteScaleYPP = spriteScaleXPP;\nspriteTwistPP = rand(0,30);'%(minSize, maxSize), c = True)
if ckboxSequence.getValue():
pm.addAttr(particle_snow2[1], dataType = 'doubleArray', ln = 'spriteNumPP')
pm.addAttr(particle_snow2[1], dataType = 'doubleArray', ln = 'spriteNumPP0')
pm.dynExpression(particle_snow2[1], s = 'spriteScaleXPP = rand(%f,%f);\nspriteScaleYPP = spriteScaleXPP;\nspriteTwistPP = rand(0,30);\nspriteNumPP = rand(0,%f);\nspriteNumPP = (spriteNumPP+1)%%%f;'%(minSize, maxSize, snowSequence, snowSequence+1), c = True)
## don't using textures
else:
logger.info(' particle render type: cloud ')
pm.setAttr('%s.particleRenderType'%particle_snow2[0], 8)
pm.addAttr(particle_snow2[1], dataType = 'doubleArray', ln = 'radiusPP')
pm.addAttr(particle_snow2[1], dataType = 'doubleArray', ln = 'radiusPP0')
pm.addAttr(particle_snow2[1], dataType = 'vectorArray', ln = 'rgbPP')
pm.addAttr(particle_snow2[1], dataType = 'vectorArray', ln = 'rgbPP0')
pm.dynExpression(particle_snow2[1], s = 'radiusPP = rand(%f,%f);\nrgbPP = <<1,1,1>>;'%(minSize, maxSize), c = True)
## if make collision
if ckboxCover.getValue():
for j in range(len(coverObj)):
pm.collision(coverObj[j], particle_snow2[1], r = 0, f = 1)
## add gravity
snowGravity = pm.gravity('%s'%particle_snow2[0], dx = gdX, dy = gdY, dz = gdZ, magnitude = 1.0)
pm.connectDynamic('%s'%particle_snow2[0], f = snowGravity)
logger.info('Scene generation finished!')
return
def main(count=100):
# create locators
start_locator = pm.spaceLocator(name="start_point")
end_locator = pm.spaceLocator(name="end_point")
pm.setAttr(end_locator.tx, 5)
start_x = pm.getAttr(start_locator.tx)
start_y = pm.getAttr(start_locator.ty)
start_z = pm.getAttr(start_locator.tz)
end_x = pm.getAttr(end_locator.tx)
end_y = pm.getAttr(end_locator.ty)
end_z = pm.getAttr(end_locator.tz)
# create guide curve and divide into select spans
guide_curve_transform = pm.curve(name='guide_curve',
degree=1,
p=([start_x, start_y,
start_z], [end_x, end_y, end_z]))
guide_curve = pm.listRelatives(guide_curve_transform, children=True)[0]
pm.rebuildCurve(guide_curve, spans=(count - 3), degree=3)
# convert to soft body
particle_pack = pm.nSoft(guide_curve, convert=True)
particle_transform = particle_pack[0]
index = guide_curve[-1]
try:
index = int(index)
particle_transform = pm.rename(particle_transform,
"lightning_particle%s" % index)
except:
particle_transform = pm.rename(particle_transform,
"lightning_particle")
particle_system = pm.listRelatives(particle_transform, children=True)[0]
# turn off gravity effects
pm.setAttr(particle_system.ignoreSolverGravity, 1)
pm.dynExpression(
particle_system,
creation=1,
string=str(
"{ps}.position = hermite ( <<{sp}.translateX,{sp}.translateY,{sp}.translateZ>>, \n\t\t\t <<{ep}.translateX,{ep}.translateY,{ep}.translateZ>>,\n <<{ep}.translateX-{sp}.translateX,{ep}.translateY-{sp}.translateY,{ep}.translateZ-{sp}.translateZ>>,<<{sp}.translateX-{sp}.translateX,{ep}.translateY-{sp}.translateY,{ep}.translateZ-{sp}.translateZ>>,\n linstep(0,{ps}.count-1,{ps}.particleId) );\n\nfloat $inNoise = (0.5- abs(0.5- linstep(0,{ps}.count,{ps}.particleId) ) )*2;\nfloat $speed_1 = 0.5;\nfloat $speed_2 = 2;\nfloat $speed_3 = 2; \n{ps}.position += << noise({ps}.particleId/50 + $speed_1*time ), \n\t\t\t \t\t\t\t\t\tnoise(({ps}.particleId-{ps}.count/2)/50 + $speed_1*time ),\n\t\t\t \t\t\t\t\t\tnoise(({ps}.particleId-{ps}.count)/50 + $speed_1*time ) >> * 1 *$inNoise;\n{ps}.position += << noise({ps}.particleId/10 + $speed_2*time ),\n\t\t\t \t\t\t\t\t\tnoise(({ps}.particleId-{ps}.count/2)/10 + $speed_2*time ),\n\t\t\t \t\t\t\t\t\tnoise(({ps}.particleId-{ps}.count)/10 + $speed_2*time ) >> *0.3 *$inNoise;\n{ps}.position += << noise({ps}.particleId/2 + $speed_3*time ),\n\t\t \t \t\t\t\t\t\tnoise(({ps}.particleId-{ps}.count/2)/2 + $speed_3*time ),\n\t\t\t \t\t\t\t\t\tnoise(({ps}.particleId-{ps}.count)/2 + $speed_3*time ) >> *0.1 *$inNoise;"
.format(ps=particle_system, sp=start_locator, ep=end_locator)))
pm.dynExpression(
particle_system,
runtimeBeforeDynamics=1,
string=str(
"{ps}.position = hermite ( <<{sp}.translateX,{sp}.translateY,{sp}.translateZ>>,\n <<{ep}.translateX,{ep}.translateY,{ep}.translateZ>>,\n <<{ep}.translateX-{sp}.translateX,{ep}.translateY-{sp}.translateY,{ep}.translateZ-{sp}.translateZ>>,<<{ep}.translateX-{sp}.translateX,{ep}.translateY-{sp}.translateY,{ep}.translateZ-{sp}.translateZ>>,\n linstep(0,{ps}.count-1,{ps}.particleId) );\n\nfloat $inNoise = (0.5- abs(0.5- linstep(0,{ps}.count,{ps}.particleId) ) )*2;\nfloat $speed_1 = 6;\nfloat $speed_2 = 5;\nfloat $speed_3 = 5;\n{ps}.position += << noise({ps}.particleId/50 + $speed_1*-time ),\n noise(({ps}.particleId-{ps}.count/2)/50 + $speed_1*-time ),\n noise(({ps}.particleId-{ps}.count)/50 + $speed_1*-time ) >> * 1.3 *$inNoise;\n{ps}.position += << noise({ps}.particleId/10 + $speed_2*-time ),\n noise(({ps}.particleId-{ps}.count/2)/10 + $speed_2*-time ),\n noise(({ps}.particleId-{ps}.count)/10 + $speed_2*-time ) >> *0.2 *$inNoise;\n{ps}.position += << noise({ps}.particleId/2 + $speed_3*-time ),\n noise(({ps}.particleId-{ps}.count/2)/2 + $speed_3*-time ),\n noise(({ps}.particleId-{ps}.count)/2 + $speed_3*-time ) >> *0.05 *$inNoise;"
.format(ps=particle_system, sp=start_locator, ep=end_locator)))
# do the extrude for the nurbcurve
# make the circle curve
makeNurbCircle = pm.createNode("makeNurbCircle")
pm.setAttr(makeNurbCircle.radius, 1.35)
pm.setAttr(makeNurbCircle.normal, [1, 0, 0])
circle_curve = pm.createNode('nurbsCurve', n='circle_curve')
circle_curve_transform = pm.listRelatives(circle_curve,
fullPath=True,
allParents=True)[0]
pm.connectAttr(start_locator.translate, circle_curve_transform.translate)
pm.setAttr(circle_curve_transform.scale, [0.019, 0.019, 0.019])
pm.getAttr(circle_curve_transform.scale)
pm.rename(circle_curve_transform, "%s_transform" % circle_curve)
pm.connectAttr(makeNurbCircle.outputCurve, circle_curve.create)
# create extrude node
extrude_node = pm.createNode('extrude', n='extrude_node')
pm.setAttr(extrude_node.useProfileNormal, 0)
pm.setAttr(extrude_node.fixedPath, 0)
pm.setAttr(extrude_node.useComponentPivot, 0)
pm.setAttr(extrude_node.scale, 0.25)
pm.connectAttr(guide_curve.worldSpace[0], extrude_node.path)
pm.connectAttr(circle_curve.worldSpace[0], extrude_node.profile)
#create tessellate node
nurbsTessellate = pm.createNode('nurbsTessellate', n='nurbsTessellate')
pm.setAttr(nurbsTessellate.polygonType, 1)
pm.setAttr("%s.format" % nurbsTessellate, 2)
pm.setAttr(nurbsTessellate.uNumber, 1)
pm.setAttr(nurbsTessellate.useChordHeightRatio, 0)
pm.setAttr(nurbsTessellate.vNumber, 1)
pm.connectAttr(extrude_node.outputSurface, nurbsTessellate.inputSurface)
#create a mesh for curve extrude
extrude_mesh = pm.createNode('mesh', name='extrude_mesh')
extrude_mesh_transform = pm.listRelatives(extrude_mesh, parent=True)[0]
extrude_mesh_transform = pm.rename(extrude_mesh_transform,
"%s_transform" % extrude_mesh)
pm.connectAttr(nurbsTessellate.outputPolygon, extrude_mesh.inMesh)
brush = pm.createNode("brush", name="lightning_spark")
pm.setAttr(brush.brushType, 5)
pm.setAttr(brush.globalScale, 7.458)
pm.setAttr(brush.depth, 1)
pm.setAttr(brush.brushWidth, 0)
pm.setAttr(brush.softness, 0)
pm.setAttr(brush.mapDisplacement, 1)
pm.setAttr(brush.luminanceIsDisplacement, 0)
pm.setAttr(brush.textureType, 3)
pm.setAttr(brush.texAlpha1, 0.386)
pm.setAttr(brush.texAlpha2, 1)
pm.setAttr(brush.repeatU, 2.542)
pm.setAttr(brush.blurMult, 5)
pm.setAttr(brush.smear, 251)
pm.setAttr(brush.fractalAmplitude, 2.094)
pm.setAttr(brush.fractalRatio, 0.592)
pm.setAttr(brush.tubes, 1)
pm.setAttr(brush.tubeCompletion, 0)
pm.setAttr(brush.tubesPerStep, 0.061)
pm.setAttr(brush.segments, 70)
pm.setAttr(brush.lengthMin, 0.061)
pm.setAttr(brush.lengthMax, 1.104)
pm.setAttr(brush.blurMult, 5)
pm.setAttr(brush.tubeWidth1, 0.04)
pm.setAttr(brush.tubeWidth2, 0)
pm.setAttr(brush.widthRand, 0.282)
pm.setAttr(brush.widthBias, -0.215)
#the width scale
pm.setAttr(brush.widthScale[1].widthScale_FloatValue, 0.96)
pm.setAttr(brush.widthScale[1].widthScale_Position, 0.982609)
pm.setAttr(brush.widthScale[1].widthScale_Interp, 1)
pm.setAttr(brush.widthScale[1].widthScale_Position, 1)
pm.setAttr(brush.widthScale[1].widthScale_FloatValue, 0.72)
pm.setAttr(brush.elevationMin, 0)
pm.setAttr(brush.elevationMax, 0.160)
pm.setAttr(brush.azimuthMin, -0.068)
pm.setAttr(brush.azimuthMax, 0.006)
#growth
pm.setAttr(brush.branches, 1)
#branches
pm.setAttr(brush.numBranches, 3)
pm.setAttr(brush.branchDropout, 0.359)
pm.setAttr(brush.splitAngle, 36.7)
pm.setAttr(brush.splitBias, 0.368)
pm.setAttr(brush.minSize, 0.003)
#behavior
#displacement
pm.setAttr(brush.displacementDelay, 0.117)
pm.setAttr(brush.noise, 10)
pm.setAttr(brush.noiseFrequency, 0.074)
pm.setAttr(brush.wiggleFrequency, 5)
#force
pm.setAttr(brush.gravity, 0.107)
#gaps
pm.setAttr(brush.gapSpacing, 0.02)
pm.setAttr(brush.gapRand, 1)
#flow animation
pm.connectAttr("time1.outTime", brush.time)
##################
#create stroke
stroke = pm.createNode("stroke", name="lightning_stroke")
stroke_transform = pm.listRelatives(stroke, fullPath=True,
allParents=True)[0]
stroke_transform = pm.rename(stroke_transform, "%s_transform" % stroke)
pm.connectAttr(guide_curve.worldSpace, stroke.pathCurve[0].curve)
pm.connectAttr(brush.outBrush, stroke.brush)
#basic
pm.expression(
string="float $a = rand(1);\nif($a>0.5)\n{\n\t%s.seed=frame;\n}" %
stroke,
object=stroke,
alwaysEvaluate=True,
unitConversion=all)
pm.setAttr(stroke.sampleDensity, 0.109)
#normal_direction
pm.setAttr(stroke.minimalTwist, 1)
#pressure mapping
pm.setAttr(stroke.minimalTwist, 1)
pm.setAttr(stroke.pressureScale[0].pressureScale_Position, 0)
pm.setAttr(stroke.pressureScale[0].pressureScale_FloatValue, 0.12)
pm.setAttr(stroke.pressureScale[1].pressureScale_FloatValue, 0)
pm.setAttr(stroke.pressureScale[1].pressureScale_Position, 1)
pm.setAttr(stroke.pressureMap1, 6)
#input curves
#********************
#path curve
pm.setAttr(stroke.pathCurve[0].samples, 588)
pm.setAttr(stroke.mainVertBufSize, 906)
#mesh output
pm.setAttr(stroke.meshQuadOutput, 1)
#object display
pm.setAttr(stroke.visibility, 0)
#############
#create a mesh for the strock
stroke_mesh = pm.createNode("mesh", name="stroke_mesh")
pm.connectAttr(stroke.worldMainMesh, stroke_mesh.inMesh)
stroke_mesh_transform = pm.listRelatives(stroke_mesh, parent=True)[0]
stroke_mesh_transform = pm.rename(stroke_mesh_transform,
"%s_transform" % stroke_mesh)
#hide the curve and particle
pm.hide(guide_curve_transform)
pm.hide(circle_curve_transform)
pm.hide(stroke_transform)
##
#group all elements in a group
trans_list = [
start_locator, end_locator, guide_curve_transform,
circle_curve_transform, stroke_mesh_transform, stroke_transform,
extrude_mesh_transform
]
group_lightning = pm.group(trans_list)
group_lightning = pm.rename(group_lightning, "lightning_group")
return group_lightning
def makeWord(self, in_word):
""" create particle word"""
# in_word='maya'
# font = 'Arial'
# font = self.fontChoose.currentFont()
# print self.font[-1]
tCrvs = pm.textCurves(t=in_word, f=self.font, ch=0)
tCrvs = pm.PyNode(tCrvs[0])
letterNum = tCrvs.numChildren()
letter = []
grpWord = pm.group(em=True)
for n in range(0, letterNum):
letterShape = pm.listRelatives(tCrvs.getChildren()[n],
type='nurbsCurve',
ad=True,
path=True)
letter.append(
pm.planarSrf(letterShape, ch=1, tol=0.01, o=1, po=1)[0])
pm.parent(letter, grpWord)
# pm.select(grpWord)
wordshape = pm.polyUnite(ch=1, muv=1)[0]
mc.DeleteHistory()
wordshape = pm.PyNode(wordshape)
self.word.append(wordshape)
# see(wordshape)
pm.setAttr(tCrvs + ".visibility", 0)
wordshape.centerPivots()
# pm.move(-8,0,0)
pm.makeIdentity(apply=True, t=1, r=1, s=1, n=0, pn=1)
wordshape.makeLive()
wordshape.select()
pm.emitter(type='surface', r=1000, spd=0)
wordEmitter = wordshape.getChildren()[1]
wordEmitter = pm.PyNode(wordEmitter)
wordEmitter.cycleEmission.set(1)
wordEmitter.maxDistance.set(5)
# see(wordEmitter)
# wordEmitter.select()
wordParticle = pm.particle()[0]
wordParticle = pm.PyNode(wordParticle)
wordPaShape = wordParticle.getShape()
self.wordPar.append(wordPaShape)
pm.connectDynamic(wordParticle, em=wordEmitter)
mc.setKeyframe([wordEmitter + ".rate"], v=200, t=100)
mc.setKeyframe([wordEmitter + ".rate"], v=0, t=101)
wordPaShape.lifespanMode.set(2)
wordPaShape.attr("lifespan").set(5)
wordPaShape.lifespanRandom.set(3)
wordPaShape.particleRenderType.set(0)
wordPaShape.addAttr('colorAccum',
dv=True,
at='bool',
internalSet=True,
keyable=True)
wordPaShape.addAttr('useLighting',
dv=False,
at='bool',
internalSet=True)
wordPaShape.addAttr('multiCount',
at='long',
min=1,
max=60,
dv=2,
internalSet=True)
wordPaShape.addAttr('multiRadius',
at='float',
min=1,
max=60,
dv=0.3,
internalSet=True)
wordPaShape.addAttr('normalDir',
min=1,
max=3,
at='long',
internalSet=True,
dv=2)
wordPaShape.addAttr('pointSize',
min=1,
max=60,
at='long',
internalSet=True,
dv=2)
wordPaShape.colorAccum.set(1)
wordPaShape.multiCount.set(7)
wordPaShape.pointSize.set(1)
wordPaShape.addAttr('goalU', dt='doubleArray', keyable=True)
wordPaShape.addAttr('goalV', dt='doubleArray', keyable=True)
pm.dynExpression(wordPaShape,
s='goalU=rand(0,1);\ngoalV=rand(0,1);',
c=1)
wordPaShape.addAttr('rgbPP', dt='vectorArray', keyable=True)
pm.dynExpression(wordPaShape, s='rgbPP=position;', rbd=1)
pm.goal(wordParticle, g=wordshape, w=1, utr=0)
pm.setKeyframe(wordParticle, attribute='goalWeight[0]', v=1, t=90)
pm.setKeyframe(wordParticle, attribute='goalWeight[0]', v=0, t=100)
pm.setAttr(wordshape + ".visibility", 0)
field = pm.turbulence(pos=(0, 0, 2), m=10)
pm.connectDynamic(wordParticle, f=field)
pm.setKeyframe(field, attribute='tx', v=12, t=100)
pm.setKeyframe(field, attribute='tx', v=0, t=110)
pm.parent(field, wordshape)
lambert = pm.shadingNode('lambert', asShader=1)
lambertSG = pm.sets(renderable=True,
empty=1,
noSurfaceShader=True,
name=lambert + "SG")
pm.connectAttr(lambert + ".outColor",
lambert + "SG.surfaceShader",
f=1)
# pm.sets(wordParticle,forceElement='lambert6SG',e=True)
wordParticle.select()
pm.hyperShade(a=lambertSG)
self.wordTexture.append(lambert)
pm.setAttr(lambert + ".transparency", 0.7, 0.7, 0.7, type='double3')
pm.setAttr(lambert + ".incandescence", 0.6, 0.6, 0.6, type='double3')
pm.setAttr(lambert + ".incandescence", 0.5, 0.5, 0.5, type='double3')
pm.setAttr(lambert + ".glowIntensity", 0.6)
wordshape.select()
