RomanNum3ral
/
open_toontown_panda3d
mirror of https://github.com/open-toontown/panda3d.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

from prezmek:

This commit is contained in:
Asad M. Zaman 2007-08-10 02:41:20 +00:00
parent 84c44e8872
commit 558999a774
5 changed files with 401 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
direct/src/particles/Particles.py
View File

@ -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()

140
direct/src/tkpanels/ParticlePanel.py
View File

@ -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()

173
panda/src/particlesystem/geomParticleRenderer.I
View File

@ -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;
}

59
panda/src/particlesystem/geomParticleRenderer.cxx
View File

@ -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

30
panda/src/particlesystem/geomParticleRenderer.h
View File

@ -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