*** empty log message ***

direct/src/showbase/Particles.py

@@ -44,10 +44,13 @@ class Particles(ParticleSystem.ParticleSystem):
 	self.setRenderParent(render.node())
 
 	self.factory = None 
+	self.factoryType = "undefined"
 	self.setFactory("Point")
 	self.renderer = None 
+	self.rendererType = "undefined"
 	self.setRenderer("Line")
 	self.emitter = None 
+	self.emitterType = "undefined"
 	self.setEmitter("Sphere Volume")
 
 	self.node = PhysicalNode.PhysicalNode()
@@ -65,8 +68,11 @@ class Particles(ParticleSystem.ParticleSystem):
 
     def setFactory(self, type):
 	"""setFactory(self, type)"""
+	if (self.factoryType == type):
+	    return None
 	if (self.factory):
 	    self.factory = None
+	self.factoryType = type
 	if (type == "Point"):
 	    self.factory = PointParticleFactory.PointParticleFactory() 
 	elif (type == "Z Spin"):
@@ -81,8 +87,11 @@ class Particles(ParticleSystem.ParticleSystem):
 
     def setRenderer(self, type):
 	"""setRenderer(self, type)"""
+	if (self.rendererType == type):
+	    return None
 	if (self.renderer):
 	    self.renderer = None
+	self.rendererType = type
 	if (type == "Point"):
 	    self.renderer = PointParticleRenderer.PointParticleRenderer()
 	    self.renderer.setPointSize(1.0)
@@ -106,8 +115,11 @@ class Particles(ParticleSystem.ParticleSystem):
 
     def setEmitter(self, type):
 	"""setEmitter(self, type)"""
+	if (self.emitterType == type):
+	    return None
 	if (self.emitter):
 	    self.emitter = None
+	self.emitterType = type
 	if (type == "Box"):
 	    self.emitter = BoxEmitter.BoxEmitter()
 	elif (type == "Disc"):
@@ -154,3 +166,177 @@ class Particles(ParticleSystem.ParticleSystem):
     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 == "Point"):
+	    print "# Point factory parameters"
+	elif (self.factoryType == "Z Spin"):
+	    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 == "Oriented"):
+	    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 == "Line"):
+	    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 == "Geom"):
+	    print "# Geom parameters"
+	    node = self.renderer.getGeomNode()
+	    print 'renderer.setGeomNode(' + node.getName() + ')'
+	elif (self.rendererType == "Sparkle"):
+	    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 == "Sprite"):
+	    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 == "Box"):
+	    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 == "Disc"):
+	    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 == "Line"):
+	    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 == "Point"):
+	    print "# Point parameters"
+	    point = self.emitter.getLocation()
+	    print ('emitter.setLocation(Point3(%f, %f, %f))' % (point[0], point[1], point[2]))
+	elif (self.emitterType == "Rectangle"):
+	    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 == "Ring"):
+	    print "# Ring parameters"
+	    print 'emitter.setRadius(%f)' % self.emitter.getRadius()
+	    print 'emitter.setAngle(%f)' % self.emitter.getAngle()
+	elif (self.emitterType == "Sphere Surface"):
+	    print "# Sphere Surface parameters"
+	    print 'emitter.setRadius(%f)' % self.emitter.getRadius()
+	elif (self.emitterType == "Sphere Volume"):
+	    print "# Sphere Volume parameters"
+	    print 'emitter.setRadius(%f)' % self.emitter.getRadius()
+	elif (self.emitterType == "Tangent Ring"):
+	    print "# Tangent Ring parameters"
+	    print 'emitter.setRadius(%f)' % self.emitter.getRadius()

direct/src/tkpanels/ParticlePanel.py

@@ -176,7 +176,7 @@ class ParticlePanel(AppShell):
                                 command = self.setEmitterBoxVelocityVector)
         # Disc page #
         discPage = self.emitterNotebook.add('Disc')
-        self.emitter
+        #self.emitter
         self.createFloater(discPage, 'Radius', 'Radius of disc',
                            command = self.setEmitterDiscRadius)
         self.createAngleDial(discPage, 'Inner angle',

panda/src/particlesystem/sparkleParticleRenderer.I

@@ -26,7 +26,7 @@ set_edge_color(const Colorf& c) {
 //      Access : public
 ////////////////////////////////////////////////////////////////////
 INLINE void SparkleParticleRenderer::
-set_life_scale(SparkleParticleLifeScale ls) {
+set_life_scale(SparkleParticleRenderer::SparkleParticleLifeScale ls) {
   _life_scale = ls;
 }
 
@@ -70,7 +70,7 @@ get_edge_color(void) const {
 //    Function : get_life_scale
 //      Access : public
 ////////////////////////////////////////////////////////////////////
-INLINE SparkleParticleLifeScale SparkleParticleRenderer::
+INLINE SparkleParticleRenderer::SparkleParticleLifeScale SparkleParticleRenderer::
 get_life_scale(void) const {
   return _life_scale;
 }

panda/src/particlesystem/sparkleParticleRenderer.h

@@ -25,6 +25,37 @@ enum SparkleParticleLifeScale {
 ////////////////////////////////////////////////////////////////////
 
 class EXPCL_PANDAPHYSICS SparkleParticleRenderer : public BaseParticleRenderer {
+PUBLISHED:
+  enum SparkleParticleLifeScale {
+    SP_NO_SCALE,
+    SP_SCALE
+  };
+
+  SparkleParticleRenderer(void);
+  SparkleParticleRenderer(const SparkleParticleRenderer& copy);
+  SparkleParticleRenderer(const Colorf& center,
+			  const Colorf& edge,
+			  float birth_radius,
+			  float death_radius,
+			  SparkleParticleLifeScale life_scale,
+			  ParticleRendererAlphaMode alpha_mode);
+
+  virtual ~SparkleParticleRenderer(void);
+
+  virtual BaseParticleRenderer *make_copy(void);
+
+  INLINE void set_center_color(const Colorf& c);
+  INLINE void set_edge_color(const Colorf& c);
+  INLINE void set_birth_radius(float radius);
+  INLINE void set_death_radius(float radius);
+  INLINE void set_life_scale(SparkleParticleLifeScale);
+
+  INLINE const Colorf& get_center_color(void) const;
+  INLINE const Colorf& get_edge_color(void) const;
+  INLINE float get_birth_radius(void) const;
+  INLINE float get_death_radius(void) const;
+  INLINE SparkleParticleLifeScale get_life_scale(void) const;
+
 private:
 
   Colorf _center_color;
@@ -51,32 +82,6 @@ private:
   virtual void render(vector< PT(PhysicsObject) >& po_vector,
 		      int ttl_particles);
   virtual void resize_pool(int new_size);
-
-PUBLISHED:
-  SparkleParticleRenderer(void);
-  SparkleParticleRenderer(const SparkleParticleRenderer& copy);
-  SparkleParticleRenderer(const Colorf& center,
-			  const Colorf& edge,
-			  float birth_radius,
-			  float death_radius,
-			  SparkleParticleLifeScale life_scale,
-			  ParticleRendererAlphaMode alpha_mode);
-
-  virtual ~SparkleParticleRenderer(void);
-
-  virtual BaseParticleRenderer *make_copy(void);
-
-  INLINE void set_center_color(const Colorf& c);
-  INLINE void set_edge_color(const Colorf& c);
-  INLINE void set_birth_radius(float radius);
-  INLINE void set_death_radius(float radius);
-  INLINE void set_life_scale(SparkleParticleLifeScale);
-
-  INLINE const Colorf& get_center_color(void) const;
-  INLINE const Colorf& get_edge_color(void) const;
-  INLINE float get_birth_radius(void) const;
-  INLINE float get_death_radius(void) const;
-  INLINE SparkleParticleLifeScale get_life_scale(void) const;
 };
 
 #include "sparkleParticleRenderer.I"