from prezmek:

direct/src/particles/Particles.py

@@ -66,6 +66,7 @@ class Particles(ParticleSystem):
         # Enable particles by default
         self.fEnabled = 0
         #self.enable()
+        self.geomReference = ""
 
     def cleanup(self):
         self.disable()
@@ -324,13 +325,25 @@ class Particles(ParticleSystem):
         elif (self.rendererType == "GeomParticleRenderer"):
             file.write('# Geom parameters\n')
             node = self.renderer.getGeomNode()
-            file.write(targ + '.renderer.setGeomNode(' + node.getName() + ')\n')
+            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()

direct/src/tkpanels/ParticlePanel.py

@@ -528,27 +528,36 @@ class ParticlePanel(AppShell):
         self.createFloater(linePage, 'Line Renderer', 'Line Scale Factor',
                            'Scale Factor applied to length of line',
                            command = self.setRendererLineScaleFactor)
-        # Geom page #
+
+        ############################################################################
+        # GEOM PARTICLE RENDERER PAGE #
+        ############################################################################
         geomPage = self.rendererNotebook.add('GeomParticleRenderer')
         f = Frame(geomPage)
         f.pack(fill = X)
+
+        # Geom Node input field
         Label(f, width = 12, text = 'Geom Node', pady = 3).pack(side = LEFT)
         self.rendererGeomNode = StringVar()
-        self.rendererGeomNodeEntry = Entry(
-            f, width = 12,
-            textvariable = self.rendererGeomNode)
+        self.rendererGeomNodeEntry = Entry(f, width = 12,
+                                           textvariable = self.rendererGeomNode)
         self.rendererGeomNodeEntry.bind('<Return>', self.setRendererGeomNode)
         self.rendererGeomNodeEntry.pack(side = LEFT, expand = 1, fill = X)
 
+        # Setup frames
         f = Frame(geomPage)
         f.pack(fill = BOTH, expand = 1)
         rendererGeomNotebook = Pmw.NoteBook(f)
         rendererGeomNotebook.pack(fill = BOTH, expand = 1)
 
         rendererGeomBlendPage = rendererGeomNotebook.add('Blend')
+        rendererGeomScalePage = rendererGeomNotebook.add('Scale')
         rendererGeomInterpolationPage = rendererGeomNotebook.add('Interpolate')
-
+        
+        ############################################################################
+        # Blend tab
         p = Frame(rendererGeomBlendPage)
+        p.pack(fill = X)
         self.createOptionMenu(p, 'Geom Renderer',
                               'Color Blend',
                               'How to render semi-transparent colors',
@@ -574,7 +583,58 @@ class ParticlePanel(AppShell):
                                'OZero'),
                               self.setRendererGeomColorBlendFbufferOperand)
         self.getVariable('Geom Renderer','Fbuffer Op.').set('OOneMinusIncomingAlpha')
+
+        ############################################################################
+        # Scale tab
+        p = Frame(rendererGeomScalePage)
         p.pack(fill = X)
+        
+        self.createCheckbutton(
+            p, 'Geom Renderer', 'X Scale',
+            ("On: x scale is interpolated over particle's life; " +
+             "Off: stays as start_X_Scale"),
+            self.toggleRendererGeomXScale, 0, side = LEFT)
+        self.createCheckbutton(
+            p, 'Geom Renderer', 'Y Scale',
+            ("On: y scale is interpolated over particle's life; " +
+             "Off: stays as start_Y_Scale"),
+            self.toggleRendererGeomYScale, 0, side = LEFT)
+        self.createCheckbutton(
+            p, 'Geom Renderer', 'Z Scale',
+            ("On: z scale is interpolated over particle's life; " +
+             "Off: stays as start_Z_Scale"),
+            self.toggleRendererGeomZScale, 0, side = LEFT)
+        
+        p = Frame(rendererGeomScalePage)
+        p.pack(fill = X)
+        
+        self.createFloater(p, 'Geom Renderer',
+                           'Initial X Scale',
+                           'Initial X scaling factor',
+                           command = self.setRendererGeomInitialXScale)
+        self.createFloater(p, 'Geom Renderer',
+                           'Final X Scale',
+                           'Final X scaling factor, if xScale enabled',
+                           command = self.setRendererGeomFinalXScale)
+        self.createFloater(p, 'Geom Renderer',
+                           'Initial Y Scale',
+                           'Initial Y scaling factor',
+                           command = self.setRendererGeomInitialYScale)
+        self.createFloater(p, 'Geom Renderer',
+                           'Final Y Scale',
+                           'Final Y scaling factor, if yScale enabled',
+                           command = self.setRendererGeomFinalYScale)
+        self.createFloater(p, 'Geom Renderer',
+                           'Initial Z Scale',
+                           'Initial Z scaling factor',
+                           command = self.setRendererGeomInitialZScale)
+        self.createFloater(p, 'Geom Renderer',
+                           'Final Z Scale',
+                           'Final Z scaling factor, if zScale enabled',
+                           command = self.setRendererGeomFinalZScale)
+
+        ############################################################################
+        # Interpolate tab
         p = Frame(rendererGeomInterpolationPage)
         p.pack(fill = X)
         addSegmentButton = Menubutton(p, text = 'Add Segment',
@@ -603,7 +663,9 @@ class ParticlePanel(AppShell):
 
         rendererGeomNotebook.setnaturalsize()
 
-        # Point #
+        ############################################################################
+        # POINT PARTICLE RENDERER PAGE #
+        ############################################################################
         rendererPointPage = self.rendererNotebook.add('PointParticleRenderer')
         self.createFloater(rendererPointPage, 'Point Renderer', 'Point Size',
                            'Width and height of points in pixels',
@@ -704,6 +766,7 @@ class ParticlePanel(AppShell):
 ##################################################################################
         p = Frame(rendererSpriteScalePage)
         p.pack(fill = X)
+        
         self.createCheckbutton(
             p, 'Sprite Renderer', 'X Scale',
             ("On: x scale is interpolated over particle's life; " +
@@ -1569,6 +1632,7 @@ class ParticlePanel(AppShell):
         self.getVariable('Renderer', 'Alpha Mode').set(aMode)
         userAlpha = renderer.getUserAlpha()
         self.getWidget('Renderer', 'User Alpha').set(userAlpha)
+        
         if isinstance(renderer, LineParticleRenderer):
             headColor = renderer.getHeadColor() * 255.0
             self.getWidget('Line Renderer', 'Head Color').set(
@@ -1578,7 +1642,32 @@ class ParticlePanel(AppShell):
                 [tailColor[0], tailColor[1], tailColor[2], tailColor[3]])
             self.getWidget('Line Renderer', 'Line Scale Factor').set(
                 renderer.getLineScaleFactor())
+            
         elif isinstance(renderer, GeomParticleRenderer):
+            self.getVariable('Geom Renderer', 'X Scale').set(
+                renderer.getXScaleFlag())
+            self.getVariable('Geom Renderer', 'Y Scale').set(
+                renderer.getYScaleFlag())
+            self.getVariable('Geom Renderer', 'Z Scale').set(
+                renderer.getZScaleFlag())
+            initialXScale = renderer.getInitialXScale()
+            self.getWidget('Geom Renderer', 'Initial X Scale').set(
+                initialXScale)
+            initialYScale = renderer.getInitialYScale()
+            self.getWidget('Geom Renderer', 'Initial Y Scale').set(
+                initialYScale)
+            initialZScale = renderer.getInitialZScale()
+            self.getWidget('Geom Renderer', 'Initial Z Scale').set(
+                initialZScale)
+            finalXScale = renderer.getFinalXScale()
+            self.getWidget('Geom Renderer', 'Final X Scale').set(
+                finalXScale)
+            finalYScale = renderer.getFinalYScale()
+            self.getWidget('Geom Renderer', 'Final Y Scale').set(
+                finalYScale)
+            finalZScale = renderer.getFinalZScale()
+            self.getWidget('Geom Renderer', 'Final Z Scale').set(
+                finalZScale)
             if(self.getVariable('Geom Renderer','Color Blend').get() in ['MAdd','MSubtract','MInvSubtract']):
                 self.getWidget('Geom Renderer','Incoming Op.').pack(fill = X)
                 self.getWidget('Geom Renderer','Fbuffer Op.').pack(fill = X)
@@ -1618,6 +1707,7 @@ class ParticlePanel(AppShell):
             elif (blendMethod == BaseParticleRenderer.PPBLENDCUBIC):
                 bMethod = "PP_BLEND_CUBIC"
             self.getVariable('Point Renderer', 'Blend Method').set(bMethod)
+            
         elif isinstance(renderer, SparkleParticleRenderer):
             centerColor = renderer.getCenterColor() * 255.0
             self.getWidget('Sparkle Renderer', 'Center Color').set(
@@ -1635,6 +1725,7 @@ class ParticlePanel(AppShell):
             if (lifeScale == SparkleParticleRenderer.SPSCALE):
                 lScale = "SP_SCALE"
             self.getVariable('Sparkle Renderer', 'Life Scale').set(lScale)
+            
         elif isinstance(renderer, SpriteParticleRenderer):
             self.getWidget('Sprite Renderer','Frame Rate').set(renderer.getAnimateFramesRate(), 0)
             self.getVariable('Sprite Renderer','Enable Animation').set(
@@ -1726,6 +1817,7 @@ class ParticlePanel(AppShell):
         if nodePath != None:
             node = nodePath.node()
         if (node != None):
+            self.particles.geomReference = self.rendererGeomNode.get()
             self.particles.renderer.setGeomNode(node)
     # Point #
     def setRendererPointSize(self, size):
@@ -1903,26 +1995,54 @@ class ParticlePanel(AppShell):
         blendMethodStr = self.getVariable('Sprite Renderer','Color Blend').get()
         incomingOperandStr = self.getVariable('Sprite Renderer','Incoming Op.').get()
         fbufferOperandStr = operand
-
         self.setRendererColorBlendAttrib('Sprite Renderer', blendMethodStr, incomingOperandStr, fbufferOperandStr)
+
+
+    # GeomParticleRenderer Functionality
+    def toggleRendererGeomXScale(self):
+        self.particles.renderer.setXScaleFlag(
+            self.getVariable('Geom Renderer', 'X Scale').get())
+    def toggleRendererGeomYScale(self):
+        self.particles.renderer.setYScaleFlag(
+            self.getVariable('Geom Renderer', 'Y Scale').get())
+    def toggleRendererGeomZScale(self):
+        self.particles.renderer.setZScaleFlag(
+            self.getVariable('Geom Renderer', 'Z Scale').get())
+        
+    def setRendererGeomInitialXScale(self, xScale):
+        self.particles.renderer.setInitialXScale(xScale)
+    def setRendererGeomFinalXScale(self, xScale):
+        self.particles.renderer.setFinalXScale(xScale)
+        
+    def setRendererGeomInitialYScale(self, yScale):
+        self.particles.renderer.setInitialYScale(yScale)
+    def setRendererGeomFinalYScale(self, yScale):
+        self.particles.renderer.setFinalYScale(yScale)
+        
+    def setRendererGeomInitialZScale(self, zScale):
+        self.particles.renderer.setInitialZScale(zScale)
+    def setRendererGeomFinalZScale(self, zScale):
+        self.particles.renderer.setFinalZScale(zScale)
+    
     def setRendererGeomColorBlendMethod(self, blendMethod):
         blendMethodStr = blendMethod
         incomingOperandStr = self.getVariable('Geom Renderer','Incoming Op.').get()
         fbufferOperandStr = self.getVariable('Geom Renderer','Fbuffer Op.').get()
-
         self.setRendererColorBlendAttrib('Geom Renderer', blendMethodStr, incomingOperandStr, fbufferOperandStr)
+
     def setRendererGeomColorBlendIncomingOperand(self, operand):
         blendMethodStr = self.getVariable('Geom Renderer','Color Blend').get()
         incomingOperandStr = operand
         fbufferOperandStr = self.getVariable('Geom Renderer','Fbuffer Op.').get()
-
         self.setRendererColorBlendAttrib('Geom Renderer', blendMethodStr, incomingOperandStr, fbufferOperandStr)
+
     def setRendererGeomColorBlendFbufferOperand(self, operand):
         blendMethodStr = self.getVariable('Geom Renderer','Color Blend').get()
         incomingOperandStr = self.getVariable('Geom Renderer','Incoming Op.').get()
         fbufferOperandStr = operand
         self.setRendererColorBlendAttrib('Geom Renderer', blendMethodStr, incomingOperandStr, fbufferOperandStr)
 
+
     def addConstantInterpolationSegment(self, id = None):
         ren = self.particles.getRenderer()
         cim = ren.getColorInterpolationManager()
@@ -2652,7 +2772,9 @@ class ParticlePanel(AppShell):
 
 # Create demo in root window for testing.
 if __name__ == '__main__':
+    
     root = Pmw.initialise()
     pp = ParticlePanel()
+    base.pp=pp
     #ve = VectorEntry(Toplevel(), relief = GROOVE)
     #ve.pack()

panda/src/particlesystem/geomParticleRenderer.I

@@ -33,11 +33,100 @@ set_geom_node(PandaNode *node) {
   resize_pool(_pool_size);
 }
 
+////////////////////////////////////////////////////////////////////
+// Function : GeomParticleRenderer::set_x_scale_flag
+//   Access : public
+////////////////////////////////////////////////////////////////////
+INLINE void GeomParticleRenderer::
+set_x_scale_flag(bool animate_x_ratio) {
+  _animate_x_ratio = animate_x_ratio;
+  init_geoms();
+}
+
+////////////////////////////////////////////////////////////////////
+// Function : GeomParticleRenderer::set_y_scale_flag
+//   Access : public
+////////////////////////////////////////////////////////////////////
+INLINE void GeomParticleRenderer::
+set_y_scale_flag(bool animate_y_ratio) {
+  _animate_y_ratio = animate_y_ratio;
+  init_geoms();
+}
+
+////////////////////////////////////////////////////////////////////
+// Function : GeomParticleRenderer::set_z_scale_flag
+//   Access : public
+////////////////////////////////////////////////////////////////////
+INLINE void GeomParticleRenderer::
+set_z_scale_flag(bool animate_z_ratio) {
+  _animate_z_ratio = animate_z_ratio;
+  init_geoms();
+}
+
+////////////////////////////////////////////////////////////////////
+// Function : GeomParticleRenderer::set_initial_x_scale
+//   Access : public
+////////////////////////////////////////////////////////////////////
+INLINE void GeomParticleRenderer::
+set_initial_x_scale(float initial_x_scale) {
+  _initial_x_scale = initial_x_scale;
+  init_geoms();
+}
+
+////////////////////////////////////////////////////////////////////
+// Function : GeomParticleRenderer::set_final_x_scale
+//   Access : public
+////////////////////////////////////////////////////////////////////
+INLINE void GeomParticleRenderer::
+set_final_x_scale(float final_x_scale) {
+  _final_x_scale = final_x_scale;
+  init_geoms();
+}
+
+////////////////////////////////////////////////////////////////////
+// Function : GeomParticleRenderer::set_initial_y_scale
+//   Access : public
+////////////////////////////////////////////////////////////////////
+INLINE void GeomParticleRenderer::
+set_initial_y_scale(float initial_y_scale) {
+  _initial_y_scale = initial_y_scale;
+  init_geoms();
+}
+
+////////////////////////////////////////////////////////////////////
+// Function : GeomParticleRenderer::set_final_y_scale
+//   Access : public
+////////////////////////////////////////////////////////////////////
+INLINE void GeomParticleRenderer::
+set_final_y_scale(float final_y_scale) {
+  _final_y_scale = final_y_scale;
+  init_geoms();
+}
+
+////////////////////////////////////////////////////////////////////
+// Function : GeomParticleRenderer::set_initial_z_scale
+//   Access : public
+////////////////////////////////////////////////////////////////////
+INLINE void GeomParticleRenderer::
+set_initial_z_scale(float initial_z_scale) {
+  _initial_z_scale = initial_z_scale;
+  init_geoms();
+}
+
+////////////////////////////////////////////////////////////////////
+// Function : GeomParticleRenderer::set_final_z_scale
+//   Access : public
+////////////////////////////////////////////////////////////////////
+INLINE void GeomParticleRenderer::
+set_final_z_scale(float final_z_scale) {
+  _final_z_scale = final_z_scale;
+  init_geoms();
+}
+
 ////////////////////////////////////////////////////////////////////
 //  Function : get_geom_node
 //    Access : public
 ////////////////////////////////////////////////////////////////////
-
 INLINE PandaNode *GeomParticleRenderer::
 get_geom_node() {
   return _geom_node;
@@ -47,8 +136,88 @@ get_geom_node() {
 //  Function : get_color_interpolation_manager
 //    Access : public
 ////////////////////////////////////////////////////////////////////
-
 INLINE ColorInterpolationManager* GeomParticleRenderer::
 get_color_interpolation_manager() const {
   return _color_interpolation_manager;
 }
+
+////////////////////////////////////////////////////////////////////
+// Function : GeomParticleRenderer::get_x_scale_flag
+//   Access : public
+////////////////////////////////////////////////////////////////////
+INLINE bool GeomParticleRenderer::
+get_x_scale_flag() const {
+  return _animate_x_ratio;
+}
+
+////////////////////////////////////////////////////////////////////
+// Function : GeomParticleRenderer::get_y_scale_flag
+//   Access : public
+////////////////////////////////////////////////////////////////////
+INLINE bool GeomParticleRenderer::
+get_y_scale_flag() const {
+  return _animate_y_ratio;
+}
+
+////////////////////////////////////////////////////////////////////
+// Function : GeomParticleRenderer::get_z_scale_flag
+//   Access : public
+////////////////////////////////////////////////////////////////////
+INLINE bool GeomParticleRenderer::
+get_z_scale_flag() const {
+  return _animate_z_ratio;
+}
+
+////////////////////////////////////////////////////////////////////
+// Function : GeomParticleRenderer::get_initial_x_scale
+//   Access : public
+////////////////////////////////////////////////////////////////////
+INLINE float GeomParticleRenderer::
+get_initial_x_scale() const {
+  return _initial_x_scale;
+}
+
+////////////////////////////////////////////////////////////////////
+// Function : GeomParticleRenderer::get_final_x_scale
+//   Access : public
+////////////////////////////////////////////////////////////////////
+INLINE float GeomParticleRenderer::
+get_final_x_scale() const {
+  return _final_x_scale;
+}
+
+////////////////////////////////////////////////////////////////////
+// Function : GeomParticleRenderer::get_initial_y_scale
+//   Access : public
+////////////////////////////////////////////////////////////////////
+INLINE float GeomParticleRenderer::
+get_initial_y_scale() const {
+  return _initial_y_scale;
+}
+
+////////////////////////////////////////////////////////////////////
+// Function : GeomParticleRenderer::get_final_y_scale
+//   Access : public
+////////////////////////////////////////////////////////////////////
+INLINE float GeomParticleRenderer::
+get_final_y_scale() const {
+  return _final_y_scale;
+}
+
+////////////////////////////////////////////////////////////////////
+// Function : GeomParticleRenderer::get_initial_z_scale
+//   Access : public
+////////////////////////////////////////////////////////////////////
+INLINE float GeomParticleRenderer::
+get_initial_z_scale() const {
+  return _initial_z_scale;
+}
+
+////////////////////////////////////////////////////////////////////
+// Function : GeomParticleRenderer::get_final_z_scale
+//   Access : public
+////////////////////////////////////////////////////////////////////
+INLINE float GeomParticleRenderer::
+get_final_z_scale() const {
+  return _final_z_scale;
+}

panda/src/particlesystem/geomParticleRenderer.cxx

@@ -37,7 +37,16 @@ GeomParticleRenderer(ParticleRendererAlphaMode am, PandaNode *geom_node) :
   BaseParticleRenderer(am),
   _geom_node(geom_node),
   _color_interpolation_manager(new ColorInterpolationManager(Colorf(1.0f,1.0f,1.0f,1.0f))),
-  _pool_size(0)
+  _pool_size(0),
+  _initial_x_scale(1.0f),
+  _final_x_scale(1.0f),
+  _initial_y_scale(1.0f),
+  _final_y_scale(1.0f),
+  _initial_z_scale(1.0f),
+  _final_z_scale(1.0f),
+  _animate_x_ratio(false),
+  _animate_y_ratio(false),
+  _animate_z_ratio(false)
 {
   if (_geom_node.is_null())
     _geom_node = new PandaNode("empty");
@@ -51,7 +60,18 @@ GeomParticleRenderer(ParticleRendererAlphaMode am, PandaNode *geom_node) :
 
 GeomParticleRenderer::
 GeomParticleRenderer(const GeomParticleRenderer& copy) :
-  BaseParticleRenderer(copy), _pool_size(0) {
+  BaseParticleRenderer(copy), 
+  _pool_size(0),
+  _initial_x_scale(copy._initial_x_scale),
+  _final_x_scale(copy._final_x_scale),
+  _initial_y_scale(copy._initial_y_scale),
+  _final_y_scale(copy._final_y_scale),
+  _initial_z_scale(copy._initial_z_scale),
+  _final_z_scale(copy._final_z_scale),
+  _animate_x_ratio(copy._animate_x_ratio),
+  _animate_y_ratio(copy._animate_y_ratio),
+  _animate_z_ratio(copy._animate_z_ratio)
+{
   _geom_node = copy._geom_node;
 }
 
@@ -82,9 +102,9 @@ make_copy() {
 //      Access : private
 // Description : links the child nodes to the parent stuff
 ////////////////////////////////////////////////////////////////////
-
 void GeomParticleRenderer::
 init_geoms() {
+
 }
 
 ////////////////////////////////////////////////////////////////////
@@ -215,10 +235,30 @@ render(pvector< PT(PhysicsObject) >& po_vector, int ttl_particles) {
 
       cur_node->set_attrib(ColorAttrib::make_flat(c), 0);
 
+      // animate scale
+      float current_x_scale = _initial_x_scale;
+      float current_y_scale = _initial_y_scale;
+      float current_z_scale = _initial_z_scale;
+
+      if (_animate_x_ratio || _animate_y_ratio || _animate_z_ratio) {
+        if (_animate_x_ratio) {
+          current_x_scale = (_initial_x_scale + 
+                             (t * (_final_x_scale - _initial_x_scale)));
+        }
+        if (_animate_y_ratio) {
+          current_y_scale = (_initial_y_scale + 
+                             (t * (_final_y_scale - _initial_y_scale)));
+        }
+        if (_animate_z_ratio) {
+          current_z_scale = (_initial_z_scale + 
+                             (t * (_final_z_scale - _initial_z_scale)));
+        }
+      }
+
       cur_node->set_transform(TransformState::make_pos_quat_scale
                               (cur_particle->get_position(),
                                cur_particle->get_orientation(),
-                               LVecBase3f(1.0f, 1.0f, 1.0f)));
+                               LVecBase3f(current_x_scale, current_y_scale, current_z_scale)));
 
       // maybe get out early if possible.
 
@@ -276,6 +316,17 @@ write(ostream &out, int indent) const {
   out.width(indent); out<<""; out<<"GeomParticleRenderer:\n";
   out.width(indent+2); out<<""; out<<"_geom_node "<<_geom_node<<"\n";
   out.width(indent+2); out<<""; out<<"_pool_size "<<_pool_size<<"\n";
+
+  out.width(indent+2); out<<""; out<<"_initial_x_scale "<<_initial_x_scale<<"\n";
+  out.width(indent+2); out<<""; out<<"_final_x_scale "<<_final_x_scale<<"\n";
+  out.width(indent+2); out<<""; out<<"_initial_y_scale "<<_initial_y_scale<<"\n";
+  out.width(indent+2); out<<""; out<<"_final_y_scale "<<_final_y_scale<<"\n";
+  out.width(indent+2); out<<""; out<<"_initial_z_scale "<<_initial_z_scale<<"\n";
+  out.width(indent+2); out<<""; out<<"_final_z_scale "<<_final_z_scale<<"\n";
+  out.width(indent+2); out<<""; out<<"_animate_x_ratio "<<_animate_x_ratio<<"\n";
+  out.width(indent+2); out<<""; out<<"_animate_y_ratio "<<_animate_y_ratio<<"\n";
+  out.width(indent+2); out<<""; out<<"_animate_z_ratio "<<_animate_z_ratio<<"\n";
+
   write_linear_forces(out, indent+2);
   BaseParticleRenderer::write(out, indent+2);
   #endif //] NDEBUG

panda/src/particlesystem/geomParticleRenderer.h

@@ -39,6 +39,26 @@ PUBLISHED:
   INLINE PandaNode *get_geom_node();
   INLINE ColorInterpolationManager* get_color_interpolation_manager() const;  
 
+  INLINE void set_x_scale_flag(bool animate_x_ratio);
+  INLINE void set_y_scale_flag(bool animate_y_ratio);
+  INLINE void set_z_scale_flag(bool animate_z_ratio);
+  INLINE void set_initial_x_scale(float initial_x_scale);
+  INLINE void set_final_x_scale(float final_x_scale);
+  INLINE void set_initial_y_scale(float initial_y_scale);
+  INLINE void set_final_y_scale(float final_y_scale);
+  INLINE void set_initial_z_scale(float initial_z_scale);
+  INLINE void set_final_z_scale(float final_z_scale);
+
+  INLINE bool get_x_scale_flag() const;
+  INLINE bool get_y_scale_flag() const;
+  INLINE bool get_z_scale_flag() const;
+  INLINE float get_initial_x_scale() const;
+  INLINE float get_final_x_scale() const;
+  INLINE float get_initial_y_scale() const;
+  INLINE float get_final_y_scale() const;
+  INLINE float get_initial_z_scale() const;
+  INLINE float get_final_z_scale() const;
+
   virtual BaseParticleRenderer *make_copy();
 
   virtual void output(ostream &out) const;
@@ -52,6 +72,16 @@ private:
   pvector< PT(PandaNode) > _node_vector;
 
   int _pool_size;
+  float _initial_x_scale;
+  float _final_x_scale;
+  float _initial_y_scale;
+  float _final_y_scale;
+  float _initial_z_scale;
+  float _final_z_scale;
+
+  bool _animate_x_ratio;
+  bool _animate_y_ratio;
+  bool _animate_z_ratio;
 
   // geomparticlerenderer takes advantage of the birth/death functions