*** empty log message ***

direct/src/showbase/Particles.py

@@ -0,0 +1,156 @@
+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()
+
+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.setFactory("Point")
+	self.renderer = None 
+	self.setRenderer("Line")
+	self.emitter = None 
+	self.setEmitter("Sphere Volume")
+
+	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 setFactory(self, type):
+	"""setFactory(self, type)"""
+	if (self.factory):
+	    self.factory = None
+	if (type == "Point"):
+	    self.factory = PointParticleFactory.PointParticleFactory() 
+	elif (type == "Z Spin"):
+	    self.factory = ZSpinParticleFactory.ZSpinParticleFactory()
+	elif (type == "Oriented"):
+	    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.renderer):
+	    self.renderer = None
+	if (type == "Point"):
+	    self.renderer = PointParticleRenderer.PointParticleRenderer()
+	    self.renderer.setPointSize(1.0)
+	elif (type == "Line"):
+	    self.renderer = LineParticleRenderer.LineParticleRenderer()
+	    self.renderer.setHeadColor(Vec4(1.0, 1.0, 1.0, 1.0))
+	    self.renderer.setTailColor(Vec4(1.0, 1.0, 1.0, 1.0))
+	elif (type == "Geom"):
+	    self.renderer = GeomParticleRenderer.GeomParticleRenderer()
+	elif (type == "Sparkle"):
+	    self.renderer = SparkleParticleRenderer.SparkleParticleRenderer()
+	elif (type == "Sprite"):
+	    self.renderer = SpriteParticleRenderer.SpriteParticleRenderer()
+	else:
+	    print "unknown renderer type: %s" % type
+	    return None
+	self.renderer.setAlphaMode(
+		BaseParticleRenderer.BaseParticleRenderer.PRALPHAUSER)
+	self.renderer.setUserAlpha(1.0)
+	ParticleSystem.ParticleSystem.setRenderer(self, self.renderer)
+
+    def setEmitter(self, type):
+	"""setEmitter(self, type)"""
+	if (self.emitter):
+	    self.emitter = None
+	if (type == "Box"):
+	    self.emitter = BoxEmitter.BoxEmitter()
+	elif (type == "Disc"):
+	    self.emitter = DiskEmitter.DiskEmitter()
+	elif (type == "Line"):
+	    self.emitter = LineEmitter.LineEmitter()
+	elif (type == "Point"):
+	    self.emitter = PointEmitter.PointEmitter()
+	elif (type == "Rectangle"):
+	    self.emitter = RectangleEmitter.RectangleEmitter()
+	elif (type == "Ring"):
+	    self.emitter = RingEmitter.RingEmitter()
+	elif (type == "Sphere Surface"):
+	    self.emitter = SphereSurfaceEmitter.SphereSurfaceEmitter()
+	elif (type == "Sphere Volume"):
+	    self.emitter = SphereVolumeEmitter.SphereVolumeEmitter()
+	    self.emitter.setRadius(1.0)
+	elif (type == "Tangent Ring"):
+	    self.emitter = TangentRingEmitter.TangentRingEmitter()
+	else:
+	    print "unknown emitter type: %s" % type
+	    return None
+	self.emitter.setEmissionType(
+		BaseParticleEmitter.BaseParticleEmitter.ETEXPLICIT)
+	self.emitter.setExplicitLaunchVector(Vec3(-1.0, -1.0, 1.0))
+	self.emitter.setAmplitude(1.0)
+	ParticleSystem.ParticleSystem.setEmitter(self, self.emitter)
+
+    def __update(self, state):
+	"""update(self, state)"""
+        dt = globalClock.getDt()
+        physicsMgr.doPhysics(dt)
+        particleMgr.doParticles(dt)
+        return Task.cont
+
+    def getNodePath(self):
+	"""getNode(self)"""
+	return self.nodePath
+
+    def start(self):
+	"""start(self)"""
+	taskMgr.spawnTaskNamed(Task.Task(self.__update), 'update-particles')
+
+    def stop(self):
+	"""stop(self)"""
+	taskMgr.removeTasksNamed('update-particles')

direct/src/tkpanels/ParticlePanel.py

@@ -1,4 +1,4 @@
-""" PANDA3D Particle Panel module """
+"""PANDA3D Particle Panel"""
 
 # Import Tkinter, Pmw, and the floater code from this directory tree.
 from AppShell import *
@@ -8,6 +8,7 @@ import Dial
 import Floater
 import VectorWidgets
 import Placer
+import Particles
 
 class ParticlePanel(AppShell):
     # Override class variables
@@ -17,13 +18,15 @@ class ParticlePanel(AppShell):
     usecommandarea = 0
     usestatusarea  = 0
     
-    def __init__(self, **kw):
+    def __init__(self, particles, **kw):
         INITOPT = Pmw.INITOPT
         optiondefs = (
             ('title',     self.appname,       None),
             )
         self.defineoptions(kw, optiondefs)
 
+	self.particles = particles
+
         AppShell.__init__(self)
 
         self.initialiseoptions(ParticlePanel)
@@ -254,9 +257,17 @@ class ParticlePanel(AppShell):
         ## RENDERER PAGE ##
         self.createOptionMenu(rendererPage, 'Renderer type:',
                               'Select type of particle renderer',
-                              ('Geom', 'Point', 'Sparkle', 'Sprite'),
+                              ('Line', 'Geom', 'Point', 'Sparkle', 'Sprite'),
                               self.selectRendererType)
         self.rendererNotebook = Pmw.NoteBook(rendererPage, tabpos = None)
+	# Line page #
+	linePage = self.rendererNotebook.add('Line')
+	self.createColorEntry(linePage, 'Head color',
+				'Head color of line',
+				command = self.setRendererLineHeadColor)
+	self.createColorEntry(linePage, 'Tail color',
+				'Tail color of line',
+				command = self.setRendererLineTailColor)
         # Geom page #
         geomPage = self.rendererNotebook.add('Geom')
         f = Frame(geomPage)
@@ -428,48 +439,40 @@ class ParticlePanel(AppShell):
     ### PARTICLE SYSTEM COMMANDS ###
     ## System Page ##
     def setSystemPoolSize(self, value):
-        print 'Pool size:', value
+	self.particles.setPoolSize(value)
     def setSystemBirthRate(self, value):
-        print 'Birth rate:', value
+	self.particles.setBirthRate(value)
     def setSystemLitterSize(self, value):
-        print 'Litter size:', value
+	self.particles.setLitterSize(value)
     def setSystemLitterSpread(self, value):
-        print 'Litter spread:', value
+	self.particles.setLitterSpread(value)
     def setSystemLifespan(self, value):
-        print 'System lifespan:', value
+	self.particles.setSystemLifespan(value)
     def toggleSystemLocalVelocity(self):
-        print 'Local velocity is ',
-        if self.systemLocalVelocity.get():
-            print 'on'
-        else:
-            print 'off'
+	self.particles.setLocalVelocityFlag(self.systemLocalVelocity.get())
     def toggleSystemGrowsOlder(self):
-        print 'System Grows Older is ',
-        if self.systemGrowsOlder.get():
-            print 'on'
-        else:
-            print 'off'
+	self.particles.setSystemGrowsOlderFlag(self.systemGrowsOlder.get())
     def setSystemPos(self, pos):
-        print 'System pos:', pos
+	self.particles.getNodePath().setPos(Vec3(pos[0], pos[1], pos[2]))
     def setSystemHpr(self, pos):
-        print 'System hpr:', pos
+	self.particles.getNodePath().setHpr(Vec3(pos[0], pos[1], pos[2]))
 
     ## Factory Page ##
     def selectFactoryType(self, type):
         self.factoryNotebook.selectpage(type)
-        print 'Factory type:', type
+	self.particles.setFactory(type)
     def setFactoryLifeSpan(self, value):
-        print 'Factory Life span:', value
+	self.particles.factory.setLifeSpanBase(value)
     def setFactoryLifeSpanSpread(self, value):
-        print 'Factory Life span spread:', value
+	self.particles.factory.setLifeSpanSpread(value)
     def setFactoryParticleMass(self, value):
-        print 'Factory Particle mass:', value
+	self.particles.factory.setMassBase(value)
     def setFactoryParticleMassSpread(self, value):
-        print 'Factory Particle mass spread:', value
+	self.particles.factory.setMassSpread(value)
     def setFactoryTerminalVelocity(self, value):
-        print 'Factory Terminal velocity:', value
+	self.particles.factory.setTerminalVelocityBase(value)
     def setFactoryTerminalVelocitySpread(self, value):
-        print 'Factory Terminal velocity spread:', value
+	self.particles.factory.setTerminalVelocitySpread(value)
     # Point Page #
     # Z Spin Page #
     def setFactoryZSpinInitialAngle(self, angle):
@@ -482,7 +485,7 @@ class ParticlePanel(AppShell):
     ## Emitter page ##
     def selectEmitterType(self, type):
         self.emitterNotebook.selectpage(type)
-        print 'Emitter type:', type
+	self.particles.setEmitter(type)
     # Box #
     def setEmitterBoxPoint1(self, point):
         print 'Emitter box point 1:', point
@@ -546,6 +549,12 @@ class ParticlePanel(AppShell):
     ## RENDERER PAGE ##
     def selectRendererType(self, type):
         self.rendererNotebook.selectpage(type)
+	self.particles.setRenderer(type)
+    # Line #
+    def setRendererLineHeadColor(self, color):
+        print 'Renderer Line head color:', color
+    def setRendererLineTailColor(self, color):
+        print 'Renderer Line tail color:', color
     # Geom #
     def setRendererGeomNode(self, event):
         print 'Renderer Geom node:', self.rendererGeomNode.get()