*** empty log message ***

direct/src/showbase/ParticleEffect.py

@@ -0,0 +1,84 @@
+from PandaObject import *
+from DirectObject import *
+from ParticleManagerGlobal import *
+from PhysicsManagerGlobal import *
+from TaskManagerGlobal import *
+
+import Particles
+import ForceNode
+import PhysicalNode
+import ClockObject
+
+globalClock = ClockObject.ClockObject.getGlobalClock()
+
+class ParticleEffect(DirectObject):
+    def __init__(self, name):
+	"""__init__(self, name)"""
+	
+	self.name = name
+	self.activated = 0
+	self.particleDict = {}
+
+	self.forceNode = ForceNode.ForceNode()
+	self.forceNodePath = hidden.attachNewNode(self.forceNode)
+
+	self.physicalNode = PhysicalNode.PhysicalNode()
+	self.physicalNodePath = hidden.attachNewNode(self.physicalNode)
+
+    def addLinearForce(self, force):
+	"""addLinearForce(self, force)"""
+	self.forceNode.addForce(force)
+	physicsMgr.addLinearForce(force) 
+
+    def removeLinearForce(self, force):
+	"""removeLinearForce(self, force)"""
+	physicsMgr.removeLinearForce(force)
+	self.forceNode.removeForce(force)
+
+    def addAngularForce(self, force):
+	"""addAngularForce(self, force)"""
+	self.forceNode.addForce(force)
+	physicsMgr.addAngularForce(force)
+
+    def removeAngularForce(self, force):
+	"""removeAngularForce(self, force)"""
+	physicsMgr.removeAngularForce(force)
+	self.forceNode.removeForce(force)
+
+    def addParticles(self, particles):
+	"""addParticles(self, particles)"""
+	self.particleDict[particles.name] = particles
+	self.physicalNode.addPhysical(particles)
+	physicsMgr.attachPhysical(particles)
+	particleMgr.attachParticlesystem(particles)
+
+    def removeParticles(self, particles):
+	"""removeParticles(self, particles)"""
+	particleMgr.removeParticlesystem(particles)	
+	physicsMgr.removePhysical(particles)
+	self.physicalNode.removePhysical(particles)
+	self.particleDict[particles.name] = None
+
+    def activate(self):
+	"""activate(self)"""
+	if (self.activated == 0):
+	    self.activated = 1
+	    self.forceNodePath.reparentTo(render)
+	    self.physicalNodePath.reparentTo(render)
+	    taskMgr.spawnTaskNamed(Task.Task(self.__update), 
+					self.name + '-update')
+
+    def deactivate(self):
+	"""deactivate(self)"""
+	if (self.activated == 1):
+	    self.activated = 0
+	    taskMgr.removeTasksNamed(self.name + '-update')
+	    self.forceNodePath.reparentTo(hidden)
+	    self.physicalNodePath.reparentTo(hidden)
+
+    def __update(self, state):
+	"""__update(self, state)"""
+	dt = min(globalClock.getDt(), 0.1)
+   	physicsMgr.doPhysics(dt)
+	particleMgr.doParticles(dt)
+	return Task.cont

direct/src/showbase/Particles.py

@@ -1,7 +1,4 @@
 from PandaObject import *
-from ParticleManagerGlobal import *
-from PhysicsManagerGlobal import *
-from TaskManagerGlobal import *
 
 import ParticleSystem
 import BaseParticleFactory
@@ -24,23 +21,18 @@ import RingEmitter
 import SphereSurfaceEmitter
 import SphereVolumeEmitter
 import TangentRingEmitter
-import PhysicalNode
-import ForceNode
-import RenderRelation
-import LinearEulerIntegrator
-import ClockObject
 import string
 import os
 
-globalClock = ClockObject.ClockObject.getGlobalClock()
 SparkleParticleRenderer.SparkleParticleRenderer.SPNOSCALE = 0
 SparkleParticleRenderer.SparkleParticleRenderer.SPSCALE = 1
 
 class Particles(ParticleSystem.ParticleSystem):
 
-    def __init__(self, poolSize = 1024):
+    def __init__(self, name, poolSize = 1024):
 	"""__init__(self)"""
 
+	self.name = name
 	ParticleSystem.ParticleSystem.__init__(self, poolSize)
 	self.setBirthRate(0.02)
 	self.setLitterSize(10)
@@ -57,24 +49,6 @@ class Particles(ParticleSystem.ParticleSystem):
 	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):
@@ -153,26 +127,6 @@ class Particles(ParticleSystem.ParticleSystem):
 	    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 bakeConfig(self, filename):
 	"""saveFileData(self, filename)"""
 	#fname = Filename(filename)

direct/src/showbase/ShowBase.py

@@ -11,6 +11,7 @@ import Task
 import EventManager
 import math
 import sys
+import LinearEulerIntegrator
 
 class ShowBase:
 
@@ -106,7 +107,10 @@ class ShowBase:
         self.taskMgr = taskMgr
 
 	self.particleMgr = particleMgr
+	self.particleMgr.setFrameStepping(1)
 	self.physicsMgr = physicsMgr
+	self.integrator = LinearEulerIntegrator.LinearEulerIntegrator()
+	self.physicsMgr.attachLinearIntegrator(self.integrator)
 
         self.createAudioManager()
         self.createRootPanel()

direct/src/tkpanels/ParticlePanel.py

@@ -10,6 +10,7 @@ import EntryScale
 import VectorWidgets
 import Placer
 import Particles
+import ParticleEffect
 
 class ParticlePanel(AppShell):
     # Override class variables
@@ -20,14 +21,15 @@ class ParticlePanel(AppShell):
     usestatusarea  = 0
     balloonState = 'both'
     
-    def __init__(self, particles, **kw):
+    def __init__(self, particleEffect, particles, **kw):
         INITOPT = Pmw.INITOPT
         optiondefs = (
             ('title',     self.appname,       None),
             )
         self.defineoptions(kw, optiondefs)
 
-	self.particles = particles
+	self.particleEffect = particleEffect
+	self.particles = particles 
 
         AppShell.__init__(self)
 
@@ -656,9 +658,10 @@ class ParticlePanel(AppShell):
 
     def toggleParticleSystem(self):
         if self.systemActive.get():
-            self.particles.start()
+            self.particleEffect.activate()
         else:
-            self.particles.stop()
+            self.particleEffect.deactivate()
+	return None
             
     ## SYSTEM PAGE ##
     def updateSystemWidgets(self):
@@ -672,9 +675,9 @@ class ParticlePanel(AppShell):
         self.getWidget('System', 'Litter Spread').set(litterSpread, 0)
         systemLifespan = self.particles.getSystemLifespan()
         self.getWidget('System', 'Lifespan').set(systemLifespan, 0)
-        pos = self.particles.getNodePath().getPos()
+        pos = self.particleEffect.physicalNodePath.getPos()
         self.getWidget('System', 'Pos').set([pos[0], pos[1], pos[2]], 0)
-        hpr = self.particles.getNodePath().getHpr()
+        hpr = self.particleEffect.physicalNodePath.getHpr()
         self.getWidget('System', 'Hpr').set([hpr[0], hpr[1], hpr[2]], 0)
         self.systemLocalVelocity.set(self.particles.getLocalVelocityFlag())
         self.systemGrowsOlder.set(self.particles.getSystemGrowsOlderFlag())
@@ -693,9 +696,9 @@ class ParticlePanel(AppShell):
     def toggleSystemGrowsOlder(self):
 	self.particles.setSystemGrowsOlderFlag(self.systemGrowsOlder.get())
     def setSystemPos(self, pos):
-	self.particles.getNodePath().setPos(Vec3(pos[0], pos[1], pos[2]))
+	self.particleEffect.physicalNodePath.setPos(Vec3(pos[0], pos[1], pos[2]))
     def setSystemHpr(self, pos):
-	self.particles.getNodePath().setHpr(Vec3(pos[0], pos[1], pos[2]))
+	self.particleEffect.physicalNodePath.setHpr(Vec3(pos[0], pos[1], pos[2]))
 
     ## FACTORY PAGE ##
     def selectFactoryType(self, type):
@@ -1165,7 +1168,7 @@ class ParticlePanel(AppShell):
     def selectSystemNamed(self, name):
         system = self.systemDict.get(name, None)
         if system == None:
-            system = Particles.Particles(1024)
+            system = Particles.Particles('new-particles')
             self.systemDict[name] = system
         if system:
             self.particles = system