596 lines
32 KiB
Python
596 lines
32 KiB
Python
from panda3d.core import *
|
|
|
|
from panda3d.physics import PhysicalNode
|
|
from panda3d.physics import ParticleSystem
|
|
from panda3d.physics import PointParticleFactory
|
|
from panda3d.physics import ZSpinParticleFactory
|
|
#from panda3d.physics import OrientedParticleFactory
|
|
from panda3d.physics import BaseParticleRenderer
|
|
from panda3d.physics import PointParticleRenderer
|
|
from panda3d.physics import LineParticleRenderer
|
|
from panda3d.physics import GeomParticleRenderer
|
|
from panda3d.physics import SparkleParticleRenderer
|
|
#from panda3d.physics import SpriteParticleRenderer
|
|
from panda3d.physics import BaseParticleEmitter
|
|
from panda3d.physics import ArcEmitter
|
|
from panda3d.physics import BoxEmitter
|
|
from panda3d.physics import DiscEmitter
|
|
from panda3d.physics import LineEmitter
|
|
from panda3d.physics import PointEmitter
|
|
from panda3d.physics import RectangleEmitter
|
|
from panda3d.physics import RingEmitter
|
|
from panda3d.physics import SphereSurfaceEmitter
|
|
from panda3d.physics import SphereVolumeEmitter
|
|
from panda3d.physics import TangentRingEmitter
|
|
from panda3d.physics import SpriteAnim
|
|
|
|
from . import SpriteParticleRendererExt
|
|
|
|
from direct.directnotify.DirectNotifyGlobal import directNotify
|
|
import sys
|
|
|
|
class Particles(ParticleSystem):
|
|
notify = directNotify.newCategory('Particles')
|
|
id = 1
|
|
|
|
def __init__(self, name=None, poolSize=1024):
|
|
if (name == None):
|
|
self.name = 'particles-%d' % Particles.id
|
|
Particles.id += 1
|
|
else:
|
|
self.name = name
|
|
ParticleSystem.__init__(self, poolSize)
|
|
# self.setBirthRate(0.02)
|
|
# self.setLitterSize(10)
|
|
# self.setLitterSpread(0)
|
|
|
|
# Set up a physical node
|
|
self.node = PhysicalNode(self.name)
|
|
self.nodePath = NodePath(self.node)
|
|
self.setRenderParent(self.node)
|
|
self.node.addPhysical(self)
|
|
|
|
self.factory = None
|
|
self.factoryType = "undefined"
|
|
# self.setFactory("PointParticleFactory")
|
|
self.renderer = None
|
|
self.rendererType = "undefined"
|
|
# self.setRenderer("PointParticleRenderer")
|
|
self.emitter = None
|
|
self.emitterType = "undefined"
|
|
# self.setEmitter("SphereVolumeEmitter")
|
|
|
|
# Enable particles by default
|
|
self.fEnabled = 0
|
|
#self.enable()
|
|
self.geomReference = ""
|
|
|
|
def cleanup(self):
|
|
self.disable()
|
|
self.clearLinearForces()
|
|
self.clearAngularForces()
|
|
self.setRenderParent(self.node)
|
|
self.node.removePhysical(self)
|
|
self.nodePath.removeNode()
|
|
del self.node
|
|
del self.nodePath
|
|
del self.factory
|
|
del self.renderer
|
|
del self.emitter
|
|
|
|
def enable(self):
|
|
if (self.fEnabled == 0):
|
|
base.physicsMgr.attachPhysical(self)
|
|
base.particleMgr.attachParticlesystem(self)
|
|
self.fEnabled = 1
|
|
|
|
def disable(self):
|
|
if (self.fEnabled == 1):
|
|
base.physicsMgr.removePhysical(self)
|
|
base.particleMgr.removeParticlesystem(self)
|
|
self.fEnabled = 0
|
|
|
|
def isEnabled(self):
|
|
return self.fEnabled
|
|
|
|
def getNode(self):
|
|
return self.node
|
|
|
|
def setFactory(self, type):
|
|
if (self.factoryType == type):
|
|
return None
|
|
if (self.factory):
|
|
self.factory = None
|
|
self.factoryType = type
|
|
if (type == "PointParticleFactory"):
|
|
self.factory = PointParticleFactory()
|
|
elif (type == "ZSpinParticleFactory"):
|
|
self.factory = ZSpinParticleFactory()
|
|
elif (type == "OrientedParticleFactory"):
|
|
self.factory = OrientedParticleFactory()
|
|
else:
|
|
print("unknown factory type: %s" % type)
|
|
return None
|
|
self.factory.setLifespanBase(0.5)
|
|
ParticleSystem.setFactory(self, self.factory)
|
|
|
|
def setRenderer(self, type):
|
|
if (self.rendererType == type):
|
|
return None
|
|
if (self.renderer):
|
|
self.renderer = None
|
|
self.rendererType = type
|
|
if (type == "PointParticleRenderer"):
|
|
self.renderer = PointParticleRenderer()
|
|
self.renderer.setPointSize(1.0)
|
|
elif (type == "LineParticleRenderer"):
|
|
self.renderer = LineParticleRenderer()
|
|
elif (type == "GeomParticleRenderer"):
|
|
self.renderer = GeomParticleRenderer()
|
|
# This was moved here because we do not want to download
|
|
# the direct tools with toontown.
|
|
if __dev__:
|
|
from direct.directtools import DirectSelection
|
|
npath = NodePath('default-geom')
|
|
bbox = DirectSelection.DirectBoundingBox(npath)
|
|
self.renderer.setGeomNode(bbox.lines.node())
|
|
elif (type == "SparkleParticleRenderer"):
|
|
self.renderer = SparkleParticleRenderer()
|
|
elif (type == "SpriteParticleRenderer"):
|
|
self.renderer = SpriteParticleRendererExt.SpriteParticleRendererExt()
|
|
# self.renderer.setTextureFromFile()
|
|
else:
|
|
print("unknown renderer type: %s" % type)
|
|
return None
|
|
ParticleSystem.setRenderer(self, self.renderer)
|
|
|
|
def setEmitter(self, type):
|
|
if (self.emitterType == type):
|
|
return None
|
|
if (self.emitter):
|
|
self.emitter = None
|
|
self.emitterType = type
|
|
if (type == "ArcEmitter"):
|
|
self.emitter = ArcEmitter()
|
|
elif (type == "BoxEmitter"):
|
|
self.emitter = BoxEmitter()
|
|
elif (type == "DiscEmitter"):
|
|
self.emitter = DiscEmitter()
|
|
elif (type == "LineEmitter"):
|
|
self.emitter = LineEmitter()
|
|
elif (type == "PointEmitter"):
|
|
self.emitter = PointEmitter()
|
|
elif (type == "RectangleEmitter"):
|
|
self.emitter = RectangleEmitter()
|
|
elif (type == "RingEmitter"):
|
|
self.emitter = RingEmitter()
|
|
elif (type == "SphereSurfaceEmitter"):
|
|
self.emitter = SphereSurfaceEmitter()
|
|
elif (type == "SphereVolumeEmitter"):
|
|
self.emitter = SphereVolumeEmitter()
|
|
self.emitter.setRadius(1.0)
|
|
elif (type == "TangentRingEmitter"):
|
|
self.emitter = TangentRingEmitter()
|
|
else:
|
|
print("unknown emitter type: %s" % type)
|
|
return None
|
|
ParticleSystem.setEmitter(self, self.emitter)
|
|
|
|
def addForce(self, force):
|
|
if (force.isLinear()):
|
|
self.addLinearForce(force)
|
|
else:
|
|
self.addAngularForce(force)
|
|
|
|
def removeForce(self, force):
|
|
if (force == None):
|
|
self.notify.warning('removeForce() - force == None!')
|
|
return
|
|
if (force.isLinear()):
|
|
self.removeLinearForce(force)
|
|
else:
|
|
self.removeAngularForce(force)
|
|
|
|
def setRenderNodePath(self, nodePath):
|
|
self.setRenderParent(nodePath.node())
|
|
|
|
## Getters ##
|
|
def getName(self):
|
|
return self.name
|
|
|
|
def getFactory(self):
|
|
return self.factory
|
|
|
|
def getEmitter(self):
|
|
return self.emitter
|
|
|
|
def getRenderer(self):
|
|
return self.renderer
|
|
|
|
def printParams(self, file = sys.stdout, targ = 'self'):
|
|
file.write('# Particles parameters\n')
|
|
file.write(targ + '.setFactory(\"' + self.factoryType + '\")\n')
|
|
file.write(targ + '.setRenderer(\"' + self.rendererType + '\")\n')
|
|
file.write(targ + '.setEmitter(\"' + self.emitterType + '\")\n')
|
|
|
|
# System parameters
|
|
file.write(targ + ('.setPoolSize(%d)\n' %
|
|
int(self.getPoolSize())))
|
|
file.write(targ + ('.setBirthRate(%.4f)\n' %
|
|
self.getBirthRate()))
|
|
file.write(targ + ('.setLitterSize(%d)\n' %
|
|
int(self.getLitterSize())))
|
|
file.write(targ + ('.setLitterSpread(%d)\n' %
|
|
self.getLitterSpread()))
|
|
file.write(targ + ('.setSystemLifespan(%.4f)\n' %
|
|
self.getSystemLifespan()))
|
|
file.write(targ + ('.setLocalVelocityFlag(%d)\n' %
|
|
self.getLocalVelocityFlag()))
|
|
file.write(targ + ('.setSystemGrowsOlderFlag(%d)\n' %
|
|
self.getSystemGrowsOlderFlag()))
|
|
file.write('# Factory parameters\n')
|
|
file.write(targ + ('.factory.setLifespanBase(%.4f)\n' %
|
|
self.factory.getLifespanBase()))
|
|
file.write(targ + '.factory.setLifespanSpread(%.4f)\n' % \
|
|
self.factory.getLifespanSpread())
|
|
file.write(targ + '.factory.setMassBase(%.4f)\n' % \
|
|
self.factory.getMassBase())
|
|
file.write(targ + '.factory.setMassSpread(%.4f)\n' % \
|
|
self.factory.getMassSpread())
|
|
file.write(targ + '.factory.setTerminalVelocityBase(%.4f)\n' % \
|
|
self.factory.getTerminalVelocityBase())
|
|
file.write(targ + '.factory.setTerminalVelocitySpread(%.4f)\n' % \
|
|
self.factory.getTerminalVelocitySpread())
|
|
if (self.factoryType == "PointParticleFactory"):
|
|
file.write('# Point factory parameters\n')
|
|
elif (self.factoryType == "ZSpinParticleFactory"):
|
|
file.write('# Z Spin factory parameters\n')
|
|
file.write(targ + '.factory.setInitialAngle(%.4f)\n' % \
|
|
self.factory.getInitialAngle())
|
|
file.write(targ + '.factory.setInitialAngleSpread(%.4f)\n' % \
|
|
self.factory.getInitialAngleSpread())
|
|
file.write(targ + '.factory.enableAngularVelocity(%d)\n' % \
|
|
self.factory.getAngularVelocityEnabled())
|
|
if(self.factory.getAngularVelocityEnabled()):
|
|
file.write(targ + '.factory.setAngularVelocity(%.4f)\n' % \
|
|
self.factory.getAngularVelocity())
|
|
file.write(targ + '.factory.setAngularVelocitySpread(%.4f)\n' % \
|
|
self.factory.getAngularVelocitySpread())
|
|
else:
|
|
file.write(targ + '.factory.setFinalAngle(%.4f)\n' % \
|
|
self.factory.getFinalAngle())
|
|
file.write(targ + '.factory.setFinalAngleSpread(%.4f)\n' % \
|
|
self.factory.getFinalAngleSpread())
|
|
|
|
elif (self.factoryType == "OrientedParticleFactory"):
|
|
file.write('# Oriented factory parameters\n')
|
|
file.write(targ + '.factory.setInitialOrientation(%.4f)\n' % \
|
|
self.factory.getInitialOrientation())
|
|
file.write(targ + '.factory.setFinalOrientation(%.4f)\n' % \
|
|
self.factory.getFinalOrientation())
|
|
|
|
file.write('# Renderer parameters\n')
|
|
alphaMode = self.renderer.getAlphaMode()
|
|
aMode = "PRALPHANONE"
|
|
if (alphaMode == BaseParticleRenderer.PRALPHANONE):
|
|
aMode = "PRALPHANONE"
|
|
elif (alphaMode == BaseParticleRenderer.PRALPHAOUT):
|
|
aMode = "PRALPHAOUT"
|
|
elif (alphaMode == BaseParticleRenderer.PRALPHAIN):
|
|
aMode = "PRALPHAIN"
|
|
elif (alphaMode == BaseParticleRenderer.PRALPHAINOUT):
|
|
aMode = "PRALPHAINOUT"
|
|
elif (alphaMode == BaseParticleRenderer.PRALPHAUSER):
|
|
aMode = "PRALPHAUSER"
|
|
file.write(targ + '.renderer.setAlphaMode(BaseParticleRenderer.' + aMode + ')\n')
|
|
file.write(targ + '.renderer.setUserAlpha(%.2f)\n' % \
|
|
self.renderer.getUserAlpha())
|
|
if (self.rendererType == "PointParticleRenderer"):
|
|
file.write('# Point parameters\n')
|
|
file.write(targ + '.renderer.setPointSize(%.2f)\n' % \
|
|
self.renderer.getPointSize())
|
|
sColor = self.renderer.getStartColor()
|
|
file.write((targ + '.renderer.setStartColor(Vec4(%.2f, %.2f, %.2f, %.2f))\n' % (sColor[0], sColor[1], sColor[2], sColor[3])))
|
|
sColor = self.renderer.getEndColor()
|
|
file.write((targ + '.renderer.setEndColor(Vec4(%.2f, %.2f, %.2f, %.2f))\n' % (sColor[0], sColor[1], sColor[2], sColor[3])))
|
|
blendType = self.renderer.getBlendType()
|
|
bType = "PPONECOLOR"
|
|
if (blendType == PointParticleRenderer.PPONECOLOR):
|
|
bType = "PPONECOLOR"
|
|
elif (blendType == PointParticleRenderer.PPBLENDLIFE):
|
|
bType = "PPBLENDLIFE"
|
|
elif (blendType == PointParticleRenderer.PPBLENDVEL):
|
|
bType = "PPBLENDVEL"
|
|
file.write(targ + '.renderer.setBlendType(PointParticleRenderer.' + bType + ')\n')
|
|
blendMethod = self.renderer.getBlendMethod()
|
|
bMethod = "PPNOBLEND"
|
|
if (blendMethod == BaseParticleRenderer.PPNOBLEND):
|
|
bMethod = "PPNOBLEND"
|
|
elif (blendMethod == BaseParticleRenderer.PPBLENDLINEAR):
|
|
bMethod = "PPBLENDLINEAR"
|
|
elif (blendMethod == BaseParticleRenderer.PPBLENDCUBIC):
|
|
bMethod = "PPBLENDCUBIC"
|
|
file.write(targ + '.renderer.setBlendMethod(BaseParticleRenderer.' + bMethod + ')\n')
|
|
elif (self.rendererType == "LineParticleRenderer"):
|
|
file.write('# Line parameters\n')
|
|
sColor = self.renderer.getHeadColor()
|
|
file.write((targ + '.renderer.setHeadColor(Vec4(%.2f, %.2f, %.2f, %.2f))\n' % (sColor[0], sColor[1], sColor[2], sColor[3])))
|
|
sColor = self.renderer.getTailColor()
|
|
file.write((targ + '.renderer.setTailColor(Vec4(%.2f, %.2f, %.2f, %.2f))\n' % (sColor[0], sColor[1], sColor[2], sColor[3])))
|
|
sf = self.renderer.getLineScaleFactor()
|
|
file.write((targ + '.renderer.setLineScaleFactor(%.2f)\n' % (sf)))
|
|
elif (self.rendererType == "GeomParticleRenderer"):
|
|
file.write('# Geom parameters\n')
|
|
node = self.renderer.getGeomNode()
|
|
file.write('geomRef = loader.loadModel("' + self.geomReference + '")\n')
|
|
file.write(targ + '.renderer.setGeomNode(geomRef.node())\n')
|
|
file.write(targ + '.geomReference = "' + self.geomReference + '"\n');
|
|
cbmLut = ('MNone','MAdd','MSubtract','MInvSubtract','MMin','MMax')
|
|
cboLut = ('OZero','OOne','OIncomingColor','OOneMinusIncomingColor','OFbufferColor',
|
|
'OOneMinusFbufferColor','OIncomingAlpha','OOneMinusIncomingAlpha',
|
|
'OFbufferAlpha','OOneMinusFbufferAlpha','OConstantColor',
|
|
'OOneMinusConstantColor','OConstantAlpha','OOneMinusConstantAlpha',
|
|
'OIncomingColorSaturate')
|
|
file.write(targ + '.renderer.setXScaleFlag(%d)\n' % self.renderer.getXScaleFlag())
|
|
file.write(targ + '.renderer.setYScaleFlag(%d)\n' % self.renderer.getYScaleFlag())
|
|
file.write(targ + '.renderer.setZScaleFlag(%d)\n' % self.renderer.getZScaleFlag())
|
|
file.write(targ + '.renderer.setInitialXScale(%.4f)\n' % self.renderer.getInitialXScale())
|
|
file.write(targ + '.renderer.setFinalXScale(%.4f)\n' % self.renderer.getFinalXScale())
|
|
file.write(targ + '.renderer.setInitialYScale(%.4f)\n' % self.renderer.getInitialYScale())
|
|
file.write(targ + '.renderer.setFinalYScale(%.4f)\n' % self.renderer.getFinalYScale())
|
|
file.write(targ + '.renderer.setInitialZScale(%.4f)\n' % self.renderer.getInitialZScale())
|
|
file.write(targ + '.renderer.setFinalZScale(%.4f)\n' % self.renderer.getFinalZScale())
|
|
|
|
cbAttrib = self.renderer.getRenderNode().getAttrib(ColorBlendAttrib.getClassType())
|
|
if(cbAttrib):
|
|
cbMode = cbAttrib.getMode()
|
|
if(cbMode > 0):
|
|
if(cbMode in (ColorBlendAttrib.MAdd, ColorBlendAttrib.MSubtract, ColorBlendAttrib.MInvSubtract)):
|
|
cboa = cbAttrib.getOperandA()
|
|
cbob = cbAttrib.getOperandB()
|
|
file.write(targ+'.renderer.setColorBlendMode(ColorBlendAttrib.%s, ColorBlendAttrib.%s, ColorBlendAttrib.%s)\n' %
|
|
(cbmLut[cbMode], cboLut[cboa], cboLut[cbob]))
|
|
else:
|
|
file.write(targ+'.renderer.setColorBlendMode(ColorBlendAttrib.%s)\n' % cbmLut[cbMode])
|
|
cim = self.renderer.getColorInterpolationManager()
|
|
segIdList = [int(seg) for seg in cim.getSegmentIdList().split()]
|
|
for sid in segIdList:
|
|
seg = cim.getSegment(sid)
|
|
if seg.isEnabled():
|
|
t_b = seg.getTimeBegin()
|
|
t_e = seg.getTimeEnd()
|
|
mod = seg.isModulated()
|
|
fun = seg.getFunction()
|
|
typ = type(fun).__name__
|
|
if typ == 'ColorInterpolationFunctionConstant':
|
|
c_a = fun.getColorA()
|
|
file.write(targ+'.renderer.getColorInterpolationManager().addConstant('+repr(t_b)+','+repr(t_e)+','+ \
|
|
'Vec4('+repr(c_a[0])+','+repr(c_a[1])+','+repr(c_a[2])+','+repr(c_a[3])+'),'+repr(mod)+')\n')
|
|
elif typ == 'ColorInterpolationFunctionLinear':
|
|
c_a = fun.getColorA()
|
|
c_b = fun.getColorB()
|
|
file.write(targ+'.renderer.getColorInterpolationManager().addLinear('+repr(t_b)+','+repr(t_e)+','+ \
|
|
'Vec4('+repr(c_a[0])+','+repr(c_a[1])+','+repr(c_a[2])+','+repr(c_a[3])+'),' + \
|
|
'Vec4('+repr(c_b[0])+','+repr(c_b[1])+','+repr(c_b[2])+','+repr(c_b[3])+'),'+repr(mod)+')\n')
|
|
elif typ == 'ColorInterpolationFunctionStepwave':
|
|
c_a = fun.getColorA()
|
|
c_b = fun.getColorB()
|
|
w_a = fun.getWidthA()
|
|
w_b = fun.getWidthB()
|
|
file.write(targ+'.renderer.getColorInterpolationManager().addStepwave('+repr(t_b)+','+repr(t_e)+','+ \
|
|
'Vec4('+repr(c_a[0])+','+repr(c_a[1])+','+repr(c_a[2])+','+repr(c_a[3])+'),' + \
|
|
'Vec4('+repr(c_b[0])+','+repr(c_b[1])+','+repr(c_b[2])+','+repr(c_b[3])+'),' + \
|
|
repr(w_a)+','+repr(w_b)+','+repr(mod)+')\n')
|
|
elif typ == 'ColorInterpolationFunctionSinusoid':
|
|
c_a = fun.getColorA()
|
|
c_b = fun.getColorB()
|
|
per = fun.getPeriod()
|
|
file.write(targ+'.renderer.getColorInterpolationManager().addSinusoid('+repr(t_b)+','+repr(t_e)+','+ \
|
|
'Vec4('+repr(c_a[0])+','+repr(c_a[1])+','+repr(c_a[2])+','+repr(c_a[3])+'),' + \
|
|
'Vec4('+repr(c_b[0])+','+repr(c_b[1])+','+repr(c_b[2])+','+repr(c_b[3])+'),' + \
|
|
repr(per)+','+repr(mod)+')\n')
|
|
|
|
elif (self.rendererType == "SparkleParticleRenderer"):
|
|
file.write('# Sparkle parameters\n')
|
|
sColor = self.renderer.getCenterColor()
|
|
file.write((targ + '.renderer.setCenterColor(Vec4(%.2f, %.2f, %.2f, %.2f))\n' % (sColor[0], sColor[1], sColor[2], sColor[3])))
|
|
sColor = self.renderer.getEdgeColor()
|
|
file.write((targ + '.renderer.setEdgeColor(Vec4(%.2f, %.2f, %.2f, %.2f))\n' % (sColor[0], sColor[1], sColor[2], sColor[3])))
|
|
file.write(targ + '.renderer.setBirthRadius(%.4f)\n' % self.renderer.getBirthRadius())
|
|
file.write(targ + '.renderer.setDeathRadius(%.4f)\n' % self.renderer.getDeathRadius())
|
|
lifeScale = self.renderer.getLifeScale()
|
|
lScale = "SPNOSCALE"
|
|
if (lifeScale == SparkleParticleRenderer.SPSCALE):
|
|
lScale = "SPSCALE"
|
|
file.write(targ + '.renderer.setLifeScale(SparkleParticleRenderer.' + lScale + ')\n')
|
|
elif (self.rendererType == "SpriteParticleRenderer"):
|
|
file.write('# Sprite parameters\n')
|
|
if (self.renderer.getAnimateFramesEnable()):
|
|
file.write(targ + '.renderer.setAnimateFramesEnable(True)\n')
|
|
rate = self.renderer.getAnimateFramesRate()
|
|
if(rate):
|
|
file.write(targ + '.renderer.setAnimateFramesRate(%.3f)\n'%rate)
|
|
animCount = self.renderer.getNumAnims()
|
|
for x in range(animCount):
|
|
anim = self.renderer.getAnim(x)
|
|
if(anim.getSourceType() == SpriteAnim.STTexture):
|
|
file.write(targ + '.renderer.addTextureFromFile(\'%s\')\n' % (anim.getTexSource(),))
|
|
else:
|
|
file.write(targ + '.renderer.addTextureFromNode(\'%s\',\'%s\')\n' % (anim.getModelSource(), anim.getNodeSource()))
|
|
sColor = self.renderer.getColor()
|
|
file.write((targ + '.renderer.setColor(Vec4(%.2f, %.2f, %.2f, %.2f))\n' % (sColor[0], sColor[1], sColor[2], sColor[3])))
|
|
file.write(targ + '.renderer.setXScaleFlag(%d)\n' % self.renderer.getXScaleFlag())
|
|
file.write(targ + '.renderer.setYScaleFlag(%d)\n' % self.renderer.getYScaleFlag())
|
|
file.write(targ + '.renderer.setAnimAngleFlag(%d)\n' % self.renderer.getAnimAngleFlag())
|
|
file.write(targ + '.renderer.setInitialXScale(%.4f)\n' % self.renderer.getInitialXScale())
|
|
file.write(targ + '.renderer.setFinalXScale(%.4f)\n' % self.renderer.getFinalXScale())
|
|
file.write(targ + '.renderer.setInitialYScale(%.4f)\n' % self.renderer.getInitialYScale())
|
|
file.write(targ + '.renderer.setFinalYScale(%.4f)\n' % self.renderer.getFinalYScale())
|
|
file.write(targ + '.renderer.setNonanimatedTheta(%.4f)\n' % self.renderer.getNonanimatedTheta())
|
|
blendMethod = self.renderer.getAlphaBlendMethod()
|
|
bMethod = "PPNOBLEND"
|
|
if (blendMethod == BaseParticleRenderer.PPNOBLEND):
|
|
bMethod = "PPNOBLEND"
|
|
elif (blendMethod == BaseParticleRenderer.PPBLENDLINEAR):
|
|
bMethod = "PPBLENDLINEAR"
|
|
elif (blendMethod == BaseParticleRenderer.PPBLENDCUBIC):
|
|
bMethod = "PPBLENDCUBIC"
|
|
file.write(targ + '.renderer.setAlphaBlendMethod(BaseParticleRenderer.' + bMethod + ')\n')
|
|
file.write(targ + '.renderer.setAlphaDisable(%d)\n' % self.renderer.getAlphaDisable())
|
|
# Save the color blending to file
|
|
cbmLut = ('MNone','MAdd','MSubtract','MInvSubtract','MMin','MMax')
|
|
cboLut = ('OZero','OOne','OIncomingColor','OOneMinusIncomingColor','OFbufferColor',
|
|
'OOneMinusFbufferColor','OIncomingAlpha','OOneMinusIncomingAlpha',
|
|
'OFbufferAlpha','OOneMinusFbufferAlpha','OConstantColor',
|
|
'OOneMinusConstantColor','OConstantAlpha','OOneMinusConstantAlpha',
|
|
'OIncomingColorSaturate')
|
|
cbAttrib = self.renderer.getRenderNode().getAttrib(ColorBlendAttrib.getClassType())
|
|
if(cbAttrib):
|
|
cbMode = cbAttrib.getMode()
|
|
if(cbMode > 0):
|
|
if(cbMode in (ColorBlendAttrib.MAdd, ColorBlendAttrib.MSubtract, ColorBlendAttrib.MInvSubtract)):
|
|
cboa = cbAttrib.getOperandA()
|
|
cbob = cbAttrib.getOperandB()
|
|
file.write(targ+'.renderer.setColorBlendMode(ColorBlendAttrib.%s, ColorBlendAttrib.%s, ColorBlendAttrib.%s)\n' %
|
|
(cbmLut[cbMode], cboLut[cboa], cboLut[cbob]))
|
|
else:
|
|
file.write(targ+'.renderer.setColorBlendMode(ColorBlendAttrib.%s)\n' % cbmLut[cbMode])
|
|
cim = self.renderer.getColorInterpolationManager()
|
|
segIdList = [int(seg) for seg in cim.getSegmentIdList().split()]
|
|
for sid in segIdList:
|
|
seg = cim.getSegment(sid)
|
|
if seg.isEnabled():
|
|
t_b = seg.getTimeBegin()
|
|
t_e = seg.getTimeEnd()
|
|
mod = seg.isModulated()
|
|
fun = seg.getFunction()
|
|
typ = type(fun).__name__
|
|
if typ == 'ColorInterpolationFunctionConstant':
|
|
c_a = fun.getColorA()
|
|
file.write(targ+'.renderer.getColorInterpolationManager().addConstant('+repr(t_b)+','+repr(t_e)+','+ \
|
|
'Vec4('+repr(c_a[0])+','+repr(c_a[1])+','+repr(c_a[2])+','+repr(c_a[3])+'),'+repr(mod)+')\n')
|
|
elif typ == 'ColorInterpolationFunctionLinear':
|
|
c_a = fun.getColorA()
|
|
c_b = fun.getColorB()
|
|
file.write(targ+'.renderer.getColorInterpolationManager().addLinear('+repr(t_b)+','+repr(t_e)+','+ \
|
|
'Vec4('+repr(c_a[0])+','+repr(c_a[1])+','+repr(c_a[2])+','+repr(c_a[3])+'),' + \
|
|
'Vec4('+repr(c_b[0])+','+repr(c_b[1])+','+repr(c_b[2])+','+repr(c_b[3])+'),'+repr(mod)+')\n')
|
|
elif typ == 'ColorInterpolationFunctionStepwave':
|
|
c_a = fun.getColorA()
|
|
c_b = fun.getColorB()
|
|
w_a = fun.getWidthA()
|
|
w_b = fun.getWidthB()
|
|
file.write(targ+'.renderer.getColorInterpolationManager().addStepwave('+repr(t_b)+','+repr(t_e)+','+ \
|
|
'Vec4('+repr(c_a[0])+','+repr(c_a[1])+','+repr(c_a[2])+','+repr(c_a[3])+'),' + \
|
|
'Vec4('+repr(c_b[0])+','+repr(c_b[1])+','+repr(c_b[2])+','+repr(c_b[3])+'),' + \
|
|
repr(w_a)+','+repr(w_b)+','+repr(mod)+')\n')
|
|
elif typ == 'ColorInterpolationFunctionSinusoid':
|
|
c_a = fun.getColorA()
|
|
c_b = fun.getColorB()
|
|
per = fun.getPeriod()
|
|
file.write(targ+'.renderer.getColorInterpolationManager().addSinusoid('+repr(t_b)+','+repr(t_e)+','+ \
|
|
'Vec4('+repr(c_a[0])+','+repr(c_a[1])+','+repr(c_a[2])+','+repr(c_a[3])+'),' + \
|
|
'Vec4('+repr(c_b[0])+','+repr(c_b[1])+','+repr(c_b[2])+','+repr(c_b[3])+'),' + \
|
|
repr(per)+','+repr(mod)+')\n')
|
|
|
|
file.write('# Emitter parameters\n')
|
|
emissionType = self.emitter.getEmissionType()
|
|
eType = "ETEXPLICIT"
|
|
if (emissionType == BaseParticleEmitter.ETEXPLICIT):
|
|
eType = "ETEXPLICIT"
|
|
elif (emissionType == BaseParticleEmitter.ETRADIATE):
|
|
eType = "ETRADIATE"
|
|
elif (emissionType == BaseParticleEmitter.ETCUSTOM):
|
|
eType = "ETCUSTOM"
|
|
file.write(targ + '.emitter.setEmissionType(BaseParticleEmitter.' + eType + ')\n')
|
|
file.write(targ + '.emitter.setAmplitude(%.4f)\n' % self.emitter.getAmplitude())
|
|
file.write(targ + '.emitter.setAmplitudeSpread(%.4f)\n' % self.emitter.getAmplitudeSpread())
|
|
oForce = self.emitter.getOffsetForce()
|
|
file.write((targ + '.emitter.setOffsetForce(Vec3(%.4f, %.4f, %.4f))\n' % (oForce[0], oForce[1], oForce[2])))
|
|
oForce = self.emitter.getExplicitLaunchVector()
|
|
file.write((targ + '.emitter.setExplicitLaunchVector(Vec3(%.4f, %.4f, %.4f))\n' % (oForce[0], oForce[1], oForce[2])))
|
|
orig = self.emitter.getRadiateOrigin()
|
|
file.write((targ + '.emitter.setRadiateOrigin(Point3(%.4f, %.4f, %.4f))\n' % (orig[0], orig[1], orig[2])))
|
|
if (self.emitterType == "BoxEmitter"):
|
|
file.write('# Box parameters\n')
|
|
bound = self.emitter.getMinBound()
|
|
file.write((targ + '.emitter.setMinBound(Point3(%.4f, %.4f, %.4f))\n' % (bound[0], bound[1], bound[2])))
|
|
bound = self.emitter.getMaxBound()
|
|
file.write((targ + '.emitter.setMaxBound(Point3(%.4f, %.4f, %.4f))\n' % (bound[0], bound[1], bound[2])))
|
|
elif (self.emitterType == "DiscEmitter"):
|
|
file.write('# Disc parameters\n')
|
|
file.write(targ + '.emitter.setRadius(%.4f)\n' % self.emitter.getRadius())
|
|
if (eType == "ETCUSTOM"):
|
|
file.write(targ + '.emitter.setOuterAngle(%.4f)\n' % self.emitter.getOuterAngle())
|
|
file.write(targ + '.emitter.setInnerAngle(%.4f)\n' % self.emitter.getInnerAngle())
|
|
file.write(targ + '.emitter.setOuterMagnitude(%.4f)\n' % self.emitter.getOuterMagnitude())
|
|
file.write(targ + '.emitter.setInnerMagnitude(%.4f)\n' % self.emitter.getInnerMagnitude())
|
|
file.write(targ + '.emitter.setCubicLerping(%d)\n' % self.emitter.getCubicLerping())
|
|
|
|
elif (self.emitterType == "LineEmitter"):
|
|
file.write('# Line parameters\n')
|
|
point = self.emitter.getEndpoint1()
|
|
file.write((targ + '.emitter.setEndpoint1(Point3(%.4f, %.4f, %.4f))\n' % (point[0], point[1], point[2])))
|
|
point = self.emitter.getEndpoint2()
|
|
file.write((targ + '.emitter.setEndpoint2(Point3(%.4f, %.4f, %.4f))\n' % (point[0], point[1], point[2])))
|
|
elif (self.emitterType == "PointEmitter"):
|
|
file.write('# Point parameters\n')
|
|
point = self.emitter.getLocation()
|
|
file.write((targ + '.emitter.setLocation(Point3(%.4f, %.4f, %.4f))\n' % (point[0], point[1], point[2])))
|
|
elif (self.emitterType == "RectangleEmitter"):
|
|
file.write('# Rectangle parameters\n')
|
|
point = self.emitter.getMinBound()
|
|
file.write((targ + '.emitter.setMinBound(Point2(%.4f, %.4f))\n' % (point[0], point[1])))
|
|
point = self.emitter.getMaxBound()
|
|
file.write((targ + '.emitter.setMaxBound(Point2(%.4f, %.4f))\n' % (point[0], point[1])))
|
|
elif (self.emitterType == "RingEmitter"):
|
|
file.write('# Ring parameters\n')
|
|
file.write(targ + '.emitter.setRadius(%.4f)\n' % self.emitter.getRadius())
|
|
file.write(targ + '.emitter.setRadiusSpread(%.4f)\n' % self.emitter.getRadiusSpread())
|
|
if (eType == "ETCUSTOM"):
|
|
file.write(targ + '.emitter.setAngle(%.4f)\n' % self.emitter.getAngle())
|
|
elif (self.emitterType == "SphereSurfaceEmitter"):
|
|
file.write('# Sphere Surface parameters\n')
|
|
file.write(targ + '.emitter.setRadius(%.4f)\n' % self.emitter.getRadius())
|
|
elif (self.emitterType == "SphereVolumeEmitter"):
|
|
file.write('# Sphere Volume parameters\n')
|
|
file.write(targ + '.emitter.setRadius(%.4f)\n' % self.emitter.getRadius())
|
|
elif (self.emitterType == "TangentRingEmitter"):
|
|
file.write('# Tangent Ring parameters\n')
|
|
file.write(targ + '.emitter.setRadius(%.4f)\n' % self.emitter.getRadius())
|
|
file.write(targ + '.emitter.setRadiusSpread(%.4f)\n' % self.emitter.getRadiusSpread())
|
|
|
|
def getPoolSizeRanges(self):
|
|
litterRange = [max(1,self.getLitterSize()-self.getLitterSpread()),
|
|
self.getLitterSize(),
|
|
self.getLitterSize()+self.getLitterSpread()]
|
|
lifespanRange = [self.factory.getLifespanBase()-self.factory.getLifespanSpread(),
|
|
self.factory.getLifespanBase(),
|
|
self.factory.getLifespanBase()+self.factory.getLifespanSpread()]
|
|
birthRateRange = [self.getBirthRate()] * 3
|
|
|
|
print('Litter Ranges: %s' % litterRange)
|
|
print('LifeSpan Ranges: %s' % lifespanRange)
|
|
print('BirthRate Ranges: %s' % birthRateRange)
|
|
|
|
return dict(zip(('min','median','max'),[l*s/b for l,s,b in zip(litterRange,lifespanRange,birthRateRange)]))
|
|
|
|
|
|
def accelerate(self,time,stepCount = 1,stepTime=0.0):
|
|
if time > 0.0:
|
|
if stepTime == 0.0:
|
|
stepTime = float(time)/stepCount
|
|
remainder = 0.0
|
|
else:
|
|
stepCount = int(float(time)/stepTime)
|
|
remainder = time-stepCount*stepTime
|
|
|
|
for step in range(stepCount):
|
|
base.particleMgr.doParticles(stepTime,self,False)
|
|
base.physicsMgr.doPhysics(stepTime,self)
|
|
|
|
if(remainder):
|
|
base.particleMgr.doParticles(remainder,self,False)
|
|
base.physicsMgr.doPhysics(remainder,self)
|
|
|
|
self.render()
|