mirror of
https://github.com/panda3d/panda3d.git
synced 2025-10-04 19:08:55 -04:00
348 lines
15 KiB
Python
348 lines
15 KiB
Python
from PandaObject import *
|
|
from ParticleManagerGlobal import *
|
|
from PhysicsManagerGlobal import *
|
|
from TaskManagerGlobal import *
|
|
|
|
import ParticleSystem
|
|
import BaseParticleFactory
|
|
import PointParticleFactory
|
|
import ZSpinParticleFactory
|
|
import OrientedParticleFactory
|
|
import BaseParticleRenderer
|
|
import PointParticleRenderer
|
|
import LineParticleRenderer
|
|
import GeomParticleRenderer
|
|
import SparkleParticleRenderer
|
|
import SpriteParticleRenderer
|
|
import BaseParticleEmitter
|
|
import BoxEmitter
|
|
import DiscEmitter
|
|
import LineEmitter
|
|
import PointEmitter
|
|
import RectangleEmitter
|
|
import RingEmitter
|
|
import SphereSurfaceEmitter
|
|
import SphereVolumeEmitter
|
|
import TangentRingEmitter
|
|
import PhysicalNode
|
|
import ForceNode
|
|
import RenderRelation
|
|
import LinearEulerIntegrator
|
|
import ClockObject
|
|
|
|
globalClock = ClockObject.ClockObject.getGlobalClock()
|
|
SparkleParticleRenderer.SparkleParticleRenderer.SPNOSCALE = 0
|
|
SparkleParticleRenderer.SparkleParticleRenderer.SPSCALE = 1
|
|
|
|
class Particles(ParticleSystem.ParticleSystem):
|
|
|
|
def __init__(self, poolSize = 1024):
|
|
"""__init__(self)"""
|
|
|
|
ParticleSystem.ParticleSystem.__init__(self, poolSize)
|
|
self.setBirthRate(0.02)
|
|
self.setLitterSize(10)
|
|
self.setLitterSpread(0)
|
|
self.setRenderParent(render.node())
|
|
|
|
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")
|
|
|
|
self.node = PhysicalNode.PhysicalNode()
|
|
self.node.addPhysical(self)
|
|
self.nodePath = hidden.attachNewNode(self.node)
|
|
self.forceNode = ForceNode.ForceNode()
|
|
|
|
self.integrator = LinearEulerIntegrator.LinearEulerIntegrator()
|
|
|
|
physicsMgr.attachLinearIntegrator(self.integrator)
|
|
physicsMgr.attachPhysical(self)
|
|
|
|
particleMgr.setFrameStepping(1)
|
|
particleMgr.attachParticlesystem(self)
|
|
|
|
def cleanup(self):
|
|
"""cleanup(self)"""
|
|
physicsMgr.removePhysical(self)
|
|
particleMgr.removeParticlesystem(self)
|
|
|
|
def setFactory(self, type):
|
|
"""setFactory(self, type)"""
|
|
if (self.factoryType == type):
|
|
return None
|
|
if (self.factory):
|
|
self.factory = None
|
|
self.factoryType = type
|
|
if (type == "PointParticleFactory"):
|
|
self.factory = PointParticleFactory.PointParticleFactory()
|
|
elif (type == "ZSpinParticleFactory"):
|
|
self.factory = ZSpinParticleFactory.ZSpinParticleFactory()
|
|
elif (type == "OrientedParticleFactory"):
|
|
self.factory = OrientedParticleFactory.OrientedParticleFactory()
|
|
else:
|
|
print "unknown factory type: %s" % type
|
|
return None
|
|
self.factory.setLifespanBase(0.5)
|
|
ParticleSystem.ParticleSystem.setFactory(self, self.factory)
|
|
|
|
def setRenderer(self, type):
|
|
"""setRenderer(self, type)"""
|
|
if (self.rendererType == type):
|
|
return None
|
|
if (self.renderer):
|
|
self.renderer = None
|
|
self.rendererType = type
|
|
if (type == "PointParticleRenderer"):
|
|
self.renderer = PointParticleRenderer.PointParticleRenderer()
|
|
self.renderer.setPointSize(1.0)
|
|
elif (type == "LineParticleRenderer"):
|
|
self.renderer = LineParticleRenderer.LineParticleRenderer()
|
|
self.renderer.setPointSize(1.0)
|
|
elif (type == "GeomParticleRenderer"):
|
|
self.renderer = GeomParticleRenderer.GeomParticleRenderer()
|
|
elif (type == "SparkleParticleRenderer"):
|
|
self.renderer = SparkleParticleRenderer.SparkleParticleRenderer()
|
|
elif (type == "SpriteParticleRenderer"):
|
|
self.renderer = SpriteParticleRenderer.SpriteParticleRenderer()
|
|
t = loader.loadTexture('phase_3/maps/eyes.jpg')
|
|
if (t == None):
|
|
print "Couldn't find default texture: evil_eye.rgb!"
|
|
return None
|
|
self.renderer.setTexture(t)
|
|
else:
|
|
print "unknown renderer type: %s" % type
|
|
return None
|
|
ParticleSystem.ParticleSystem.setRenderer(self, self.renderer)
|
|
|
|
def setEmitter(self, type):
|
|
"""setEmitter(self, type)"""
|
|
if (self.emitterType == type):
|
|
return None
|
|
if (self.emitter):
|
|
self.emitter = None
|
|
self.emitterType = type
|
|
if (type == "BoxEmitter"):
|
|
self.emitter = BoxEmitter.BoxEmitter()
|
|
elif (type == "DiscEmitter"):
|
|
self.emitter = DiscEmitter.DiscEmitter()
|
|
elif (type == "LineEmitter"):
|
|
self.emitter = LineEmitter.LineEmitter()
|
|
elif (type == "PointEmitter"):
|
|
self.emitter = PointEmitter.PointEmitter()
|
|
elif (type == "RectangleEmitter"):
|
|
self.emitter = RectangleEmitter.RectangleEmitter()
|
|
elif (type == "RingEmitter"):
|
|
self.emitter = RingEmitter.RingEmitter()
|
|
elif (type == "SphereSurfaceEmitter"):
|
|
self.emitter = SphereSurfaceEmitter.SphereSurfaceEmitter()
|
|
elif (type == "SphereVolumeEmitter"):
|
|
self.emitter = SphereVolumeEmitter.SphereVolumeEmitter()
|
|
self.emitter.setRadius(1.0)
|
|
elif (type == "TangentRingEmitter"):
|
|
self.emitter = TangentRingEmitter.TangentRingEmitter()
|
|
else:
|
|
print "unknown emitter type: %s" % type
|
|
return None
|
|
ParticleSystem.ParticleSystem.setEmitter(self, self.emitter)
|
|
|
|
def __update(self, state):
|
|
"""update(self, state)"""
|
|
dt = min(globalClock.getDt(), 0.1)
|
|
physicsMgr.doPhysics(dt)
|
|
particleMgr.doParticles(dt)
|
|
return Task.cont
|
|
|
|
def getNodePath(self):
|
|
"""getNode(self)"""
|
|
return self.nodePath
|
|
|
|
def start(self):
|
|
"""start(self)"""
|
|
self.stop()
|
|
taskMgr.spawnTaskNamed(Task.Task(self.__update), 'update-particles')
|
|
|
|
def stop(self):
|
|
"""stop(self)"""
|
|
taskMgr.removeTasksNamed('update-particles')
|
|
|
|
def printParams(self):
|
|
"""printParams(self)"""
|
|
print "# Factory parameters"
|
|
print "factory.setLifespanBase(%f)" % self.factory.getLifespanBase()
|
|
print "factory.setLifespanSpread(%f)" % self.factory.getLifespanSpread()
|
|
print "factory.setMassBase(%f)" % self.factory.getMassBase()
|
|
print "factory.setMassSpread(%f)" % self.factory.getMassSpread()
|
|
print "factory.setTerminalVelocityBase(%f)" % self.factory.getTerminalVelocityBase()
|
|
print "factory.setTerminalVelocitySpread(%f)" % self.factory.getTerminalVelocitySpread()
|
|
if (self.factoryType == "PointParticleFactory"):
|
|
print "# Point factory parameters"
|
|
elif (self.factoryType == "ZSpinParticleFactory"):
|
|
print "# Z Spin factory parameters"
|
|
print "factory.setInitialAngle(%f)" % self.factory.getInitialAngle()
|
|
print "factory.setFinalAngle(%f)" % self.factory.getFinalAngle()
|
|
print "factory.setInitialAngleSpread(%f)" % self.factory.getInitialAngleSpread()
|
|
print "factory.setFinalAngleSpread(%f)" % self.factory.getFinalAngleSpread()
|
|
elif (self.factoryType == "OrientedParticleFactory"):
|
|
print "# Oriented factory parameters"
|
|
print 'factory.setInitialOrientation(' + self.factory.getInitialOrientation + ')'
|
|
print 'factory.setFinalOrientation(' + self.factory.getFinalOrientation + ')'
|
|
|
|
print "# Renderer parameters"
|
|
alphaMode = self.renderer.getAlphaMode()
|
|
aMode = "PR_NOT_INITIALIZED_YET"
|
|
if (alphaMode == BaseParticleRenderer.BaseParticleRenderer.PRALPHANONE):
|
|
aMode = "PR_ALPHA_NONE"
|
|
elif (alphaMode ==
|
|
BaseParticleRenderer.BaseParticleRenderer.PRALPHAOUT):
|
|
aMode = "PR_ALPHA_OUT"
|
|
elif (alphaMode ==
|
|
BaseParticleRenderer.BaseParticleRenderer.PRALPHAIN):
|
|
aMode = "PR_ALPHA_IN"
|
|
elif (alphaMode ==
|
|
BaseParticleRenderer.BaseParticleRenderer.PRALPHAUSER):
|
|
aMode = "PR_ALPHA_USER"
|
|
print 'renderer.setAlphaMode(BaseParticleRenderer.BaseParticleRenderer.' + aMode + ')'
|
|
print 'renderer.setUserAlpha(%f)' % self.renderer.getUserAlpha()
|
|
if (self.rendererType == "Point"):
|
|
print "# Point parameters"
|
|
print 'renderer.setPointSize(%f)' % self.renderer.getPointSize()
|
|
sColor = self.renderer.getStartColor()
|
|
print ('renderer.setStartColor(Colorf(%f, %f, %f, %f))' % (sColor[0], sColor[1], sColor[2], sColor[3]))
|
|
sColor = self.renderer.getEndColor()
|
|
print ('renderer.setEndColor(Colorf(%f, %f, %f, %f))' % (sColor[0], sColor[1], sColor[2], sColor[3]))
|
|
blendType = self.renderer.getBlendType()
|
|
bType = "unknown"
|
|
if (blendType == PointParticleRenderer.PointParticleRenderer.PPONECOLOR):
|
|
bType = "PP_ONE_COLOR"
|
|
elif (blendType == PointParticleRenderer.PointParticleRenderer.PPBLENDLIFE):
|
|
bType = "PP_BLEND_LIFE"
|
|
elif (blendType == PointParticleRenderer.PointParticleRenderer.PPBLENDVEL):
|
|
bType = "PP_BLEND_VEL"
|
|
print 'renderer.setBlendType(PointParticleRenderer.PointParticleRenderer.' + bType + ')'
|
|
blendMethod = self.renderer.getBlendMethod()
|
|
bMethod = "PP_NO_BLEND"
|
|
if (blendMethod == BaseParticleRenderer.BaseParticleRenderer.PPNOBLEND):
|
|
bMethod = "PP_NO_BLEND"
|
|
elif (blendMethod == BaseParticleRenderer.BaseParticleRenderer.PPBLENDLINEAR):
|
|
bMethod = "PP_BLEND_LINEAR"
|
|
elif (blendMethod == BaseParticleRenderer.BaseParticleRenderer.PPBLENDCUBIC):
|
|
bMethod = "PP_BLEND_CUBIC"
|
|
print 'renderer.setBlendMethod(BaseParticleRenderer.BaseParticleRenderer.' + bMethod + ')'
|
|
elif (self.rendererType == "LineParticleRenderer"):
|
|
print "# Line parameters"
|
|
sColor = self.renderer.getHeadColor()
|
|
print ('renderer.setHeadColor(Colorf(%f, %f, %f, %f))' % (sColor[0], sColor[1], sColor[2], sColor[3]))
|
|
sColor = self.renderer.getTailColor()
|
|
print ('renderer.setTailColor(Colorf(%f, %f, %f, %f))' % (sColor[0], sColor[1], sColor[2], sColor[3]))
|
|
elif (self.rendererType == "GeomParticleRenderer"):
|
|
print "# Geom parameters"
|
|
node = self.renderer.getGeomNode()
|
|
print 'renderer.setGeomNode(' + node.getName() + ')'
|
|
elif (self.rendererType == "SparkleParticleRenderer"):
|
|
print "# Sparkle parameters"
|
|
sColor = self.renderer.getCenterColor()
|
|
print ('renderer.setCenterColor(Colorf(%f, %f, %f, %f))' % (sColor[0], sColor[1], sColor[2], sColor[3]))
|
|
sColor = self.renderer.getEdgeColor()
|
|
print ('renderer.setEdgeColor(Colorf(%f, %f, %f, %f))' % (sColor[0], sColor[1], sColor[2], sColor[3]))
|
|
print 'renderer.setBirthRadius(%f)' % self.renderer.getBirthRadius()
|
|
print 'renderer.setDeathRadius(%f)' % self.renderer.setDeathRadius()
|
|
lifeScale = self.renderer.getLifeScale()
|
|
lScale = "SP_NO_SCALE"
|
|
if (lifeScale == SparkleParticleRenderer.SparkleParticleRenderer.SPSCALE):
|
|
lScale = "SP_SCALE"
|
|
print 'renderer.setLifeScale(SparkleParticleRenderer.SparkleParticleRenderer.' + lScale + ')'
|
|
elif (self.rendererType == "SpriteParticleRenderer"):
|
|
print "# Sprite parameters"
|
|
tex = self.renderer.getTexture()
|
|
print 'renderer.setTexture(' + tex.getName() + ')'
|
|
sColor = self.renderer.getColor()
|
|
print ('renderer.setColor(Colorf(%f, %f, %f, %f))' % (sColor[0], sColor[1], sColor[2], sColor[3]))
|
|
print 'renderer.setXScaleFlag(%d)' % self.renderer.getXScaleFlag()
|
|
print 'renderer.setYScaleFlag(%d)' % self.renderer.getYScaleFlag()
|
|
print 'renderer.setAnimAngleFlag(%d)' % self.renderer.getAnimAngleFlag()
|
|
print 'renderer.setInitialXScale(%f)' % self.renderer.getInitialXScale()
|
|
print 'renderer.setFinalXScale(%f)' % self.renderer.getFinalXScale()
|
|
print 'renderer.setInitialYScale(%f)' % self.renderer.getInitialYScale()
|
|
print 'renderer.setFinalYScale(%f)' % self.renderer.getFinalYScale()
|
|
print 'renderer.setNonanimatedTheta(%f)' % self.renderer.getNonanimatedTheta()
|
|
blendMethod = self.renderer.getAlphaBlendMethod()
|
|
bMethod = "PP_NO_BLEND"
|
|
if (blendMethod == BaseParticleRenderer.BaseParticleRenderer.PPNOBLEND):
|
|
bMethod = "PP_NO_BLEND"
|
|
elif (blendMethod == BaseParticleRenderer.BaseParticleRenderer.PPBLENDLINEAR):
|
|
bMethod = "PP_BLEND_LINEAR"
|
|
elif (blendMethod == BaseParticleRenderer.BaseParticleRenderer.PPBLENDCUBIC):
|
|
bMethod = "PP_BLEND_CUBIC"
|
|
print 'renderer.setAlphaBlendMethod(BaseParticleRenderer.BaseParticleRenderer.' + bMethod + ')'
|
|
print 'setAlphaDisable(%d)' % self.renderer.getAlphaDisable()
|
|
|
|
print "# Emitter parameters"
|
|
emissionType = self.emitter.getEmissionType()
|
|
eType = "unknown"
|
|
if (emissionType == BaseParticleEmitter.BaseParticleEmitter.ETEXPLICIT):
|
|
eType = "ET_EXPLICIT"
|
|
elif (emissionType == BaseParticleEmitter.BaseParticleEmitter.ETRADIATE):
|
|
eType = "ET_RADIATE"
|
|
elif (emissionType == BaseParticleEmitter.BaseParticleEmitter.ETCUSTOM):
|
|
eType = "ET_CUSTOM"
|
|
print 'emitter.setEmissionType(BaseParticleEmitter.BaseParticleEmitter.' + eType + ')'
|
|
print 'emitter.setAmplitude(%f)' % self.emitter.getAmplitude()
|
|
print 'emitter.setAmplitudeSpread(%f)' % self.emitter.getAmplitudeSpread()
|
|
oForce = self.emitter.getOffsetForce()
|
|
print ('emitter.setOffsetForce(Vec3(%f, %f, %f))' % (oForce[0], oForce[1], oForce[2]))
|
|
oForce = self.emitter.getExplicitLaunchVector()
|
|
print ('emitter.setExplicitLaunchVector(Vec3(%f, %f, %f))' % (oForce[0], oForce[1], oForce[2]))
|
|
orig = self.emitter.getRadiateOrigin()
|
|
print ('emitter.setRadiateOrigin(Point3(%f, %f, %f))' % (orig[0], orig[1], orig[2]))
|
|
if (self.emitterType == "BoxEmitter"):
|
|
print "# Box parameters"
|
|
bound = self.emitter.getMinBound()
|
|
print ('emitter.setMinBound(Point3(%f, %f, %f))' % (bound[0], bound[1], bound[2]))
|
|
bound = self.emitter.getMaxBound()
|
|
print ('emitter.setMaxBound(Point3(%f, %f, %f))' % (bound[0], bound[1], bound[2]))
|
|
elif (self.emitterType == "DiscEmitter"):
|
|
print "# Disc parameters"
|
|
print 'emitter.setRadius(%f)' % self.emitter.getRadius()
|
|
print 'emitter.setOuterAngle(%f)' % self.emitter.getOuterAngle()
|
|
print 'emitter.setInnerAngle(%f)' % self.emitter.getInnerAngle()
|
|
print 'emitter.setOuterMagnitude(%f)' % self.emitter.getOuterMagnitude()
|
|
print 'emitter.setInnerMagnitude(%f)' % self.emitter.getInnerMagnitude()
|
|
print 'emitter.setCubicLerping(%d)' % self.emitter.getCubicLerping()
|
|
|
|
elif (self.emitterType == "LineEmitter"):
|
|
print "# Line parameters"
|
|
point = self.emitter.getEndpoint1()
|
|
print ('emitter.setEndpoint1(Point3(%f, %f, %f))' % (point[0], point[1], point[2]))
|
|
point = self.emitter.getEndpoint2()
|
|
print ('emitter.setEndpoint2(Point3(%f, %f, %f))' % (point[0], point[1], point[2]))
|
|
elif (self.emitterType == "PointEmitter"):
|
|
print "# Point parameters"
|
|
point = self.emitter.getLocation()
|
|
print ('emitter.setLocation(Point3(%f, %f, %f))' % (point[0], point[1], point[2]))
|
|
elif (self.emitterType == "RectangleEmitter"):
|
|
print "# Rectangle parameters"
|
|
bound = self.emitter.getMinBound()
|
|
print ('emitter.setMinBound(Point2(%f, %f))' % (point[0], point[1]))
|
|
bound = self.emitter.getMaxBound()
|
|
print ('emitter.setMaxBound(Point2(%f, %f))' % (point[0], point[1]))
|
|
elif (self.emitterType == "RingEmitter"):
|
|
print "# Ring parameters"
|
|
print 'emitter.setRadius(%f)' % self.emitter.getRadius()
|
|
print 'emitter.setAngle(%f)' % self.emitter.getAngle()
|
|
elif (self.emitterType == "SphereSurfaceEmitter"):
|
|
print "# Sphere Surface parameters"
|
|
print 'emitter.setRadius(%f)' % self.emitter.getRadius()
|
|
elif (self.emitterType == "SphereVolumeEmitter"):
|
|
print "# Sphere Volume parameters"
|
|
print 'emitter.setRadius(%f)' % self.emitter.getRadius()
|
|
elif (self.emitterType == "TangentRingEmitter"):
|
|
print "# Tangent Ring parameters"
|
|
print 'emitter.setRadius(%f)' % self.emitter.getRadius()
|