# Override class variables

appname = 'Particle Panel'

frameWidth = 375

frameHeight = 675

usecommandarea = 0

usestatusarea = 0

balloonState = 'both'

def __init__(self, particleEffect = None, **kw):

INITOPT = Pmw.INITOPT

optiondefs = (

('title', self.appname, None),

)

self.defineoptions(kw, optiondefs)

# Record particle effect

if particleEffect != None:

self.particleEffect = particleEffect

else:

# Make sure particles are enabled

base.enableParticles()

# Or create a new one if none given

particles = Particles.Particles()

particles.setBirthRate(0.02)

particles.setLitterSize(10)

particles.setLitterSpread(0)

particles.setFactory("PointParticleFactory")

particles.setRenderer("PointParticleRenderer")

particles.setEmitter("SphereVolumeEmitter")

particles.enable()

pe = ParticleEffect.ParticleEffect('effect-1', particles)

self.particleEffect = pe

pe.reparentTo(render)

pe.enable()

# Initialize application specific info

AppShell.__init__(self)

# Initialize panel Pmw options

self.initialiseoptions(ParticlePanel)

# Update panel values to reflect particle effect's state

self.selectEffectNamed(next(iter(self.effectsDict)))

# Make sure labels/menus reflect current state

self.updateMenusAndLabels()

# Make sure there is a page for each forceGroup objects

for forceGroup in self.particleEffect.getForceGroupList():

self.addForceGroupNotebookPage(self.particleEffect, forceGroup)

def appInit(self):

# Create dictionaries to keep track of panel objects

self.widgetDict = {}

self.variableDict = {}

self.effectsDict = {}

self.effectsDict[self.particleEffect.getName()] = (

self.particleEffect)

self.forcePagesDict = {}

def createInterface(self):

# Handle to the toplevels hull

interior = self.interior()

# Create particle panel menu items

## MENUBAR ENTRIES ##

# FILE MENU

# Get a handle on the file menu, and delete the Quit item that AppShell

# created so we can add it back after adding the other items.

self.menuBar.deletemenuitems('File', 0, 0)

self.menuBar.addmenuitem('File', 'command',

label='Load Params',

command=self.loadParticleEffectFromFile)

self.menuBar.addmenuitem('File', 'command',

label='Save Params',

command=self.saveParticleEffectToFile)

self.menuBar.addmenuitem('File', 'command',

label='Print Params',

command=lambda s=self:s.particles.printParams())

self.menuBar.addmenuitem('File', 'command', 'Quit this application',

label='Quit',

command=self.quit)

# PARTICLE MANAGER MENU

self.menuBar.addmenu('ParticleMgr', 'ParticleMgr Operations')

self.particleMgrActive = IntVar()

self.particleMgrActive.set(base.isParticleMgrEnabled())

self.menuBar.addmenuitem(

'ParticleMgr', 'checkbutton',

'Enable/Disable ParticleMgr',

label = 'Active',

variable = self.particleMgrActive,

command = self.toggleParticleMgr)

## MENUBUTTON LABELS ##

# Menubutton/label to identify the current objects being configured

labelFrame = Frame(interior)

# Current effect

self.effectsLabel = Menubutton(labelFrame, width = 10,

relief = RAISED,

borderwidth = 2,

font=('MSSansSerif', 12, 'bold'),

activebackground = '#909090')

self.effectsLabelMenu = Menu(self.effectsLabel, tearoff = 0)

self.effectsLabel['menu'] = self.effectsLabelMenu

self.effectsLabel.pack(side = LEFT, fill = 'x', expand = 1)

self.bind(self.effectsLabel,

'Select effect to configure or create new effect')

self.effectsLabelMenu.add_command(label = 'Create New Effect',

command = self.createNewEffect)

self.effectsLabelMenu.add_command(

label = 'Select Particle Effect',

command = lambda s = self: base.direct.select(s.particleEffect))

self.effectsLabelMenu.add_command(

label = 'Place Particle Effect',

command = lambda s = self: Placer.place(s.particleEffect))

def togglePEVis(s = self):

if s.particleEffect.isHidden():

s.particleEffect.show()

else:

s.particleEffect.hide()

self.effectsLabelMenu.add_command(

label = 'Toggle Effect Vis',

command = togglePEVis)

self.effectsEnableMenu = Menu(self.effectsLabelMenu, tearoff = 0)

self.effectsLabelMenu.add_cascade(label = 'Enable/Disable',

menu = self.effectsEnableMenu)

self.effectsLabelMenu.add_separator()

# Current particles

self.particlesLabel = Menubutton(labelFrame, width = 10,

relief = RAISED,

borderwidth = 2,

font=('MSSansSerif', 12, 'bold'),

activebackground = '#909090')

self.particlesLabelMenu = Menu(self.particlesLabel, tearoff = 0)

self.particlesLabel['menu'] = self.particlesLabelMenu

self.particlesLabel.pack(side = LEFT, fill = 'x', expand = 1)

self.bind(self.particlesLabel,

('Select particles object to configure ' +

'or add new particles object to current effect'))

self.particlesLabelMenu.add_command(label = 'Create New Particles',

command = self.createNewParticles)

self.particlesEnableMenu = Menu(self.particlesLabelMenu, tearoff = 0)

self.particlesLabelMenu.add_cascade(label = 'Enable/Disable',

menu = self.particlesEnableMenu)

self.particlesLabelMenu.add_separator()

# Current force

self.forceGroupLabel = Menubutton(labelFrame, width = 10,

relief = RAISED,

borderwidth = 2,

font=('MSSansSerif', 12, 'bold'),

activebackground = '#909090')

self.forceGroupLabelMenu = Menu(self.forceGroupLabel, tearoff = 0)

self.forceGroupLabel['menu'] = self.forceGroupLabelMenu

self.forceGroupLabel.pack(side = LEFT, fill = 'x', expand = 1)

self.bind(self.forceGroupLabel,

('Select force group to configure ' +

'or add a new force group to current effect'))

self.forceGroupLabelMenu.add_command(

label = 'Create New ForceGroup',

command = self.createNewForceGroup)

self.forceGroupEnableMenu = Menu(self.forceGroupLabelMenu, tearoff = 0)

self.forceGroupLabelMenu.add_cascade(label = 'Enable/Disable',

menu = self.forceGroupEnableMenu)

self.forceGroupLabelMenu.add_separator()

# Pack labels

labelFrame.pack(fill = 'x', expand = 0)

# Create the toplevel notebook pages

self.mainNotebook = Pmw.NoteBook(interior)

self.mainNotebook.pack(fill = BOTH, expand = 1)

systemPage = self.mainNotebook.add('System')

factoryPage = self.mainNotebook.add('Factory')

emitterPage = self.mainNotebook.add('Emitter')

rendererPage = self.mainNotebook.add('Renderer')

forcePage = self.mainNotebook.add('Force')

# Put this here so it isn't called right away

self.mainNotebook['raisecommand'] = self.updateInfo

## SYSTEM PAGE WIDGETS ##

# Create system floaters

systemFloaterDefs = (

('System', 'Pool Size',

'Max number of simultaneous particles',

self.setSystemPoolSize,

1.0, 2000000, 1.0),

('System', 'Birth Rate',

'Seconds between particle births',

self.setSystemBirthRate,

0.0, None, None),

('System', 'Litter Size',

'Number of particle created at each birth',

self.setSystemLitterSize,

1.0, 0x7fffffff, 1.0),

('System', 'Litter Spread',

'Variation in litter size',

self.setSystemLitterSpread,

0.0, 0x7fffffff, 1.0),

('System', 'Lifespan',

'Age in seconds at which the system (vs. particles) should die',

self.setSystemLifespan,

0.0, None, None)

)

self.createFloaters(systemPage, systemFloaterDefs)

# Checkboxes

self.createCheckbutton(

systemPage, 'System', 'Render Space Velocities',

('On: velocities are in render space; ' +

'Off: velocities are in particle local space'),

self.toggleSystemLocalVelocity, 0)

self.createCheckbutton(

systemPage, 'System', 'System Grows Older',

'On: system has a lifespan',

self.toggleSystemGrowsOlder, 0)

# Vector widgets

pos = self.createVector3Entry(systemPage, 'System', 'Pos',

'Particle system position',

command = self.setSystemPos)

pos.addMenuItem('Popup Placer Panel', Placer.Placer)

hpr = self.createVector3Entry(systemPage, 'System', 'Hpr',

'Particle system orientation',

fGroup_labels = ('H', 'P', 'R'),

command = self.setSystemHpr)

hpr.addMenuItem('Popup Placer Panel', Placer.Placer)

## FACTORY PAGE WIDGETS ##

self.createOptionMenu(

factoryPage,

'Factory', 'Factory Type',

'Select type of particle factory',

('PointParticleFactory', 'ZSpinParticleFactory',

#'OrientedParticleFactory'

),

self.selectFactoryType)

factoryWidgets = (

('Factory', 'Life Span',

'Average particle lifespan in seconds',

self.setFactoryLifeSpan,

0.0, None, None),

('Factory', 'Life Span Spread',

'Variation in lifespan',

self.setFactoryLifeSpanSpread,

0.0, None, None),

('Factory', 'Mass',

'Average particle mass',

self.setFactoryParticleMass,

0.001, None, None),

('Factory', 'Mass Spread',

'Variation in particle mass',

self.setFactoryParticleMassSpread,

0.0, None, None),

('Factory', 'Terminal Velocity',

'Cap on average particle velocity',

self.setFactoryTerminalVelocity,

0.0, None, None),

('Factory', 'Terminal Vel. Spread',

'Variation in terminal velocity',

self.setFactoryTerminalVelocitySpread,

0.0, None, None),

)

self.createFloaters(factoryPage, factoryWidgets)

self.factoryNotebook = Pmw.NoteBook(factoryPage, tabpos = None)

# Point page #

factoryPointPage = self.factoryNotebook.add('PointParticleFactory')

# Z spin page #

zSpinPage = self.factoryNotebook.add('ZSpinParticleFactory')

self.createCheckbutton(

zSpinPage, 'Z Spin Factory', 'Enable Angular Velocity',

("On: angular velocity is used; " +

"Off: final angle is used"),

self.toggleAngularVelocity, 0, side = TOP),

self.createFloater(

zSpinPage, 'Z Spin Factory', 'Angular Velocity',

'How fast sprites rotate',

command = self.setFactoryZSpinAngularVelocity)

self.createFloater(

zSpinPage, 'Z Spin Factory', 'Angular Velocity Spread',

'Variation in how fast sprites rotate',

command = self.setFactoryZSpinAngularVelocitySpread)

self.createAngleDial(zSpinPage, 'Z Spin Factory', 'Initial Angle',

'Starting angle in degrees',

fRollover = 1,

command = self.setFactoryZSpinInitialAngle)

self.createAngleDial(

zSpinPage, 'Z Spin Factory',

'Initial Angle Spread',

'Spread of the initial angle',

fRollover = 1,

command = self.setFactoryZSpinInitialAngleSpread)

self.createAngleDial(zSpinPage, 'Z Spin Factory', 'Final Angle',

'Final angle in degrees',

fRollover = 1,

command = self.setFactoryZSpinFinalAngle)

self.createAngleDial(

zSpinPage, 'Z Spin Factory',

'Final Angle Spread',

'Spread of the final angle',

fRollover = 1,

command = self.setFactoryZSpinFinalAngleSpread)

# Oriented page #

orientedPage = self.factoryNotebook.add('OrientedParticleFactory')

Label(orientedPage, text = 'Not implemented').pack(expand = 1,

fill = BOTH)

self.factoryNotebook.pack(expand = 1, fill = BOTH)

## EMITTER PAGE WIDGETS ##

self.createOptionMenu(

emitterPage, 'Emitter',

'Emitter Type',

'Select type of particle emitter',

('BoxEmitter', 'DiscEmitter', 'LineEmitter', 'PointEmitter',

'RectangleEmitter', 'RingEmitter', 'SphereVolumeEmitter',

'SphereSurfaceEmitter', 'TangentRingEmitter'),

self.selectEmitterType)

# Emitter modes

self.emissionType = IntVar()

self.emissionType.set(BaseParticleEmitter.ETRADIATE)

emissionFrame = Frame(emitterPage)

self.createRadiobutton(

emissionFrame, 'left',

'Emitter', 'Explicit Emission',

('particles are all emitted in parallel, direction is based ' +

'on explicit velocity vector'),

self.emissionType, BaseParticleEmitter.ETEXPLICIT,

self.setEmissionType)

self.createRadiobutton(

emissionFrame, 'left',

'Emitter', 'Radiate Emission',

'particles are emitted away from a specific point',

self.emissionType, BaseParticleEmitter.ETRADIATE,

self.setEmissionType)

self.createRadiobutton(

emissionFrame, 'left',

'Emitter', 'Custom Emission',

('particles are emitted with a velocity that ' +

'is determined by the particular emitter'),

self.emissionType, BaseParticleEmitter.ETCUSTOM,

self.setEmissionType)

emissionFrame.pack(fill = 'x', expand = 0)

self.createFloater(

emitterPage, 'Emitter', 'Velocity Multiplier',

'launch velocity multiplier (all emission modes)',

command = self.setEmitterAmplitude,

min = None)

self.createFloater(

emitterPage, 'Emitter', 'Velocity Multiplier Spread',

'spread for launch velocity multiplier (all emission modes)',

command = self.setEmitterAmplitudeSpread)

self.createVector3Entry(

emitterPage, 'Emitter', 'Offset Velocity',

'Velocity vector applied to all particles',

command = self.setEmitterOffsetForce)

self.createVector3Entry(

emitterPage, 'Emitter', 'Explicit Velocity',

'all particles launch with this velocity in Explicit mode',

command = self.setEmitterExplicitLaunchVector)

self.createVector3Entry(

emitterPage, 'Emitter', 'Radiate Origin',

'particles launch away from this point in Radiate mode',

command = self.setEmitterRadiateOrigin)

self.emitterNotebook = Pmw.NoteBook(emitterPage, tabpos = None)

# Box page #

boxPage = self.emitterNotebook.add('BoxEmitter')

self.createVector3Entry(boxPage, 'Box Emitter', 'Min',

'Min point defining emitter box',

command = self.setEmitterBoxPoint1)

self.createVector3Entry(boxPage, 'Box Emitter', 'Max',

'Max point defining emitter box',

command = self.setEmitterBoxPoint2,

value = (1.0, 1.0, 1.0))

# Disc page #

discPage = self.emitterNotebook.add('DiscEmitter')

self.createFloater(discPage, 'Disc Emitter', 'Radius',

'Radius of disc',

command = self.setEmitterDiscRadius,

min = 0.01)

customPage = self.discCustomFrame = Frame(discPage)

self.createAngleDial(customPage, 'Disc Emitter', 'Inner Angle',

'Particle launch angle at center of disc',

command = self.setEmitterDiscInnerAngle)

self.createFloater(customPage, 'Disc Emitter', 'Inner Velocity',

'Launch velocity multiplier at center of disc',

command = self.setEmitterDiscInnerVelocity)

self.createAngleDial(customPage, 'Disc Emitter', 'Outer Angle',

'Particle launch angle at outer edge of disc',

command = self.setEmitterDiscOuterAngle)

self.createFloater(customPage, 'Disc Emitter', 'Outer Velocity',

'Launch velocity multiplier at edge of disc',

command = self.setEmitterDiscOuterVelocity)

self.createCheckbutton(

customPage, 'Disc Emitter', 'Cubic Lerping',

'On: magnitude/angle interpolation from center',

self.toggleEmitterDiscCubicLerping, 0)

customPage.pack(fill = BOTH, expand = 1)

# Line page #

linePage = self.emitterNotebook.add('LineEmitter')

self.createVector3Entry(linePage, 'Line Emitter', 'Min',

'Min point defining emitter line',

command = self.setEmitterLinePoint1)

self.createVector3Entry(linePage, 'Line Emitter', 'Max',

'Max point defining emitter line',

command = self.setEmitterLinePoint2,

value = (1.0, 0.0, 0.0))

# Point page #

emitterPointPage = self.emitterNotebook.add('PointEmitter')

self.createVector3Entry(emitterPointPage, 'Point Emitter', 'Position',

'Position of emitter point',

command = self.setEmitterPointPosition)

# Rectangle #

rectanglePage = self.emitterNotebook.add('RectangleEmitter')

self.createVector2Entry(rectanglePage,

'Rectangle Emitter', 'Min',

'Point defining rectangle',

command = self.setEmitterRectanglePoint1)

self.createVector2Entry(rectanglePage,

'Rectangle Emitter', 'Max',

'Point defining rectangle',

command = self.setEmitterRectanglePoint2)

# Ring #

ringPage = self.emitterNotebook.add('RingEmitter')

self.createFloater(ringPage, 'Ring Emitter', 'Radius',

'Radius of ring',

command = self.setEmitterRingRadius,

min = 0.01)

self.createFloater(ringPage, 'Ring Emitter', 'Radius Spread',

'Variation in radius of ring',

command = self.setEmitterRingRadiusSpread,

min = 0.0)

self.ringCustomFrame = Frame(ringPage)

self.createAngleDial(self.ringCustomFrame, 'Ring Emitter', 'Angle',

'Particle launch angle',

command = self.setEmitterRingLaunchAngle)

self.ringCustomFrame.pack(fill = BOTH, expand = 1)

# Sphere volume #

sphereVolumePage = self.emitterNotebook.add('SphereVolumeEmitter')

self.createFloater(sphereVolumePage, 'Sphere Volume Emitter', 'Radius',

'Radius of sphere',

command = self.setEmitterSphereVolumeRadius,

min = 0.01)

# Sphere surface #

sphereSurfacePage = self.emitterNotebook.add('SphereSurfaceEmitter')

self.createFloater(sphereSurfacePage, 'Sphere Surface Emitter',

'Radius',

'Radius of sphere',

command = self.setEmitterSphereSurfaceRadius,

min = 0.01)

# Tangent ring #

tangentRingPage = self.emitterNotebook.add('TangentRingEmitter')

self.createFloater(tangentRingPage, 'Tangent Ring Emitter', 'Radius',

'Radius of ring',

command = self.setEmitterTangentRingRadius,

min = 0.01)

self.createFloater(tangentRingPage, 'Tangent Ring Emitter',

'Radius Spread',

'Variation in radius of ring',

command = self.setEmitterTangentRingRadiusSpread)

self.emitterNotebook.pack(fill = X)

## RENDERER PAGE WIDGETS ##

self.createOptionMenu(

rendererPage, 'Renderer', 'Renderer Type',

'Select type of particle renderer',

('LineParticleRenderer', 'GeomParticleRenderer',

'PointParticleRenderer', 'SparkleParticleRenderer',

'SpriteParticleRenderer'),

self.selectRendererType)

self.createOptionMenu(rendererPage,

'Renderer', 'Alpha Mode',

"alpha setting over particles' lifetime",

('NO_ALPHA','ALPHA_IN','ALPHA_OUT',

'ALPHA_IN_OUT', 'ALPHA_USER'),

self.setRendererAlphaMode)

self.createSlider(

rendererPage, 'Renderer', 'User Alpha',

'alpha value for ALPHA_USER alpha mode',

command = self.setRendererUserAlpha)

self.rendererNotebook = Pmw.NoteBook(rendererPage, tabpos = None)

self.rendererNotebook.pack(fill = BOTH, expand = 1)

# Line page #

linePage = self.rendererNotebook.add('LineParticleRenderer')

self.createColorEntry(linePage, 'Line Renderer', 'Head Color',

'Head color of line',

command = self.setRendererLineHeadColor)

self.createColorEntry(linePage, 'Line Renderer', 'Tail Color',

'Tail color of line',

command = self.setRendererLineTailColor)

self.createFloater(linePage, 'Line Renderer', 'Line Scale Factor',

'Scale Factor applied to length of line',

command = self.setRendererLineScaleFactor)

############################################################################

# 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.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',

('MNone','MAdd','MSubtract','MInvSubtract','MMin','MMax'),

self.setRendererGeomColorBlendMethod)

self.createOptionMenu(p, 'Geom Renderer',

'Incoming Op.',

'See ColorBlendAttrib.h for explanation',

('OOne','OIncomingColor','OOneMinusIncomingColor','OFbufferColor',

'OOneMinusFbufferColor','OIncomingAlpha','OOneMinusIncomingAlpha',

'OFbufferAlpha','OOneMinusFbufferAlpha','OConstantColor',

'OOneMinusConstantColor','OConstantAlpha','OOneMinusConstantAlpha',

'OIncomingColorSaturate','OZero'),

self.setRendererGeomColorBlendIncomingOperand)

self.getVariable('Geom Renderer','Incoming Op.').set('OIncomingAlpha')

self.createOptionMenu(p, 'Geom Renderer',

'Fbuffer Op.',

'See ColorBlendAttrib.h for explanation',

('OOne','OIncomingColor','OOneMinusIncomingColor','OFbufferColor',

'OOneMinusFbufferColor','OIncomingAlpha','OOneMinusIncomingAlpha',

'OFbufferAlpha','OOneMinusFbufferAlpha','OConstantColor',

'OOneMinusConstantColor','OConstantAlpha','OOneMinusConstantAlpha',

'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',

relief = RAISED,

borderwidth = 2,

font=('MSSansSerif', 14, 'bold'),

activebackground = '#909090')

segmentMenu = Menu(addSegmentButton)

addSegmentButton['menu'] = segmentMenu

segmentMenu.add_command(label = 'Add Constant segment',

command = self.addConstantInterpolationSegment)

segmentMenu.add_command(label = 'Add Linear segment',

command = self.addLinearInterpolationSegment)

segmentMenu.add_command(label = 'Add Stepwave segment',

command = self.addStepwaveInterpolationSegment)

segmentMenu.add_command(label = 'Add Sinusoid segment',

command = self.addSinusoidInterpolationSegment)

addSegmentButton.pack(expand = 0)

sf = Pmw.ScrolledFrame(p, horizflex = 'elastic')

sf.pack(fill = BOTH, expand = 1)

self.rendererGeomSegmentFrame = sf.interior()

self.rendererGeomSegmentFrame.pack(fill = BOTH, expand = 1)

self.rendererSegmentWidgetList = []

rendererGeomNotebook.setnaturalsize()

############################################################################

# POINT PARTICLE RENDERER PAGE #

############################################################################

rendererPointPage = self.rendererNotebook.add('PointParticleRenderer')

self.createFloater(rendererPointPage, 'Point Renderer', 'Point Size',

'Width and height of points in pixels',

command = self.setRendererPointSize)

self.createColorEntry(rendererPointPage, 'Point Renderer',

'Start Color',

'Starting color of point',

command = self.setRendererPointStartColor)

self.createColorEntry(rendererPointPage, 'Point Renderer',

'End Color',

'Ending color of point',

command = self.setRendererPointEndColor)

self.createOptionMenu(rendererPointPage, 'Point Renderer',

'Blend Type',

'Type of color blending used for particle',

('PP_ONE_COLOR', 'PP_BLEND_LIFE',

'PP_BLEND_VEL'),

self.rendererPointSelectBlendType)

self.createOptionMenu(rendererPointPage, 'Point Renderer',

'Blend Method',

'Interpolation method between colors',

('PP_NO_BLEND', 'PP_BLEND_LINEAR',

'PP_BLEND_CUBIC'),

self.rendererPointSelectBlendMethod)

# Sparkle #

sparklePage = self.rendererNotebook.add('SparkleParticleRenderer')

self.createColorEntry(sparklePage, 'Sparkle Renderer',

'Center Color',

'Color of sparkle center',

command = self.setRendererSparkleCenterColor)

self.createColorEntry(sparklePage, 'Sparkle Renderer',

'Edge Color',

'Color of sparkle line endpoints',

command = self.setRendererSparkleEdgeColor)

self.createFloater(sparklePage, 'Sparkle Renderer',

'Birth Radius',

'Initial sparkle radius',

command = self.setRendererSparkleBirthRadius)

self.createFloater(sparklePage, 'Sparkle Renderer',

'Death Radius',

'Final sparkle radius',

command = self.setRendererSparkleDeathRadius)

self.createOptionMenu(sparklePage,

'Sparkle Renderer', 'Life Scale',

'Does particle scale over its lifetime?',

('SP_NO_SCALE', 'SP_SCALE'),

self.setRendererSparkleLifeScale)

# Sprite #

spritePage = self.rendererNotebook.add('SpriteParticleRenderer')

f = Frame(spritePage)

f.pack(fill = BOTH, expand = 1)

rendererSpriteNotebook = Pmw.NoteBook(f)

rendererSpriteNotebook.pack(fill = BOTH, expand = 1)

rendererSpriteTexturePage = rendererSpriteNotebook.add('Texture')

rendererSpriteScalePage = rendererSpriteNotebook.add('Scale')

rendererSpriteBlendPage = rendererSpriteNotebook.add('Blend')

rendererSpriteInterpolationPage = rendererSpriteNotebook.add('Interpolate')

p = Frame(rendererSpriteTexturePage)

p.pack(fill = BOTH, expand = 1)

bp = Frame(p)

bp.pack(expand = 0, side = TOP)

bbp = Frame(bp)

bbp.pack()

self.createCheckbutton(

bbp, 'Sprite Renderer', 'Enable Animation',

("On: Multitexture node will be animated; " +

"Off: Only the first frame of a node is rendered"),

self.setRendererSpriteAnimationEnable, 0, side = LEFT)

self.createFloater(bbp, 'Sprite Renderer', 'Frame Rate', 'Animation frame rate',

command = self.setRendererSpriteAnimationFrameRate).pack(side = LEFT)

bbp = Frame(bp)

bbp.pack(pady=3)

Button(bbp, text = 'Add Texture',

command = self.addRendererSpriteAnimationTexture).pack(pady = 3, padx = 15, side = LEFT)

Button(bbp, text = 'Add Animation',

command = self.addRendererSpriteAnimationFromNode).pack(pady = 3, padx = 15, side = LEFT)

pp = Frame(p)

pp.pack(fill = BOTH, expand = 1, pady = 3)

sf = Pmw.ScrolledFrame(pp, horizflex = 'elastic')

sf.pack(fill = BOTH, expand = 1)

self.rendererSpriteAnimationFrame = sf.interior()

self.rendererSpriteAnimationFrame.pack(fill = BOTH, expand = 1)

self.rendererSpriteAnimationWidgetList = []

self.rendererSpriteTexture = StringVar()

self.rendererSpriteFile = StringVar()

self.rendererSpriteNode = StringVar()

p = Frame(rendererSpriteScalePage)

p.pack(fill = X)

self.createCheckbutton(

p, 'Sprite Renderer', 'X Scale',

("On: x scale is interpolated over particle's life; " +

"Off: stays as start_X_Scale"),

self.toggleRendererSpriteXScale, 0, side = LEFT)

self.createCheckbutton(

p, 'Sprite Renderer', 'Y Scale',

("On: y scale is interpolated over particle's life; " +

"Off: stays as start_Y_Scale"),

self.toggleRendererSpriteYScale, 0, side = LEFT)

self.createCheckbutton(

p, 'Sprite Renderer', 'Anim Angle',

("On: particles that are set to spin on the Z axis will " +

"spin appropriately"),

self.toggleRendererSpriteAnimAngle, 0, side = LEFT)

p = Frame(rendererSpriteScalePage)

p.pack(fill = X)

self.createFloater(p, 'Sprite Renderer',

'Initial X Scale',

'Initial X scaling factor',

command = self.setRendererSpriteInitialXScale)

self.createFloater(p, 'Sprite Renderer',

'Final X Scale',

'Final X scaling factor, if xScale enabled',

command = self.setRendererSpriteFinalXScale)

self.createFloater(p, 'Sprite Renderer',

'Initial Y Scale',

'Initial Y scaling factor',

command = self.setRendererSpriteInitialYScale)

self.createFloater(p, 'Sprite Renderer',

'Final Y Scale',

'Final Y scaling factor, if yScale enabled',

command = self.setRendererSpriteFinalYScale)

self.createAngleDial(p, 'Sprite Renderer',

'Non Animated Theta',

('If animAngle is false: counter clockwise ' +

'Z rotation of all sprites'),

command = self.setRendererSpriteNonAnimatedTheta)

p = Frame(rendererSpriteBlendPage)

p.pack(fill = X)

self.createOptionMenu(p, 'Sprite Renderer',

'Blend Type',

'Interpolation blend type for X and Y scaling',

('PP_NO_BLEND', 'PP_LINEAR', 'PP_CUBIC'),

self.setRendererSpriteBlendMethod)

self.createCheckbutton(

p, 'Sprite Renderer', 'Alpha Disable',

'On: alpha blending is disabled',

self.toggleRendererSpriteAlphaDisable, 0)

self.createOptionMenu(p, 'Sprite Renderer',

'Color Blend',

'How to render semi-transparent colors',

('MNone','MAdd','MSubtract','MInvSubtract','MMin','MMax'),

self.setRendererSpriteColorBlendMethod)

self.createOptionMenu(p, 'Sprite Renderer',

'Incoming Op.',

'See ColorBlendAttrib.h for explanation',

('OOne','OIncomingColor','OOneMinusIncomingColor','OFbufferColor',

'OOneMinusFbufferColor','OIncomingAlpha','OOneMinusIncomingAlpha',

'OFbufferAlpha','OOneMinusFbufferAlpha','OConstantColor',

'OOneMinusConstantColor','OConstantAlpha','OOneMinusConstantAlpha',

'OIncomingColorSaturate','OZero'),

self.setRendererSpriteColorBlendIncomingOperand)

self.getVariable('Sprite Renderer','Incoming Op.').set('OIncomingAlpha')

self.createOptionMenu(p, 'Sprite Renderer',

'Fbuffer Op.',

'See ColorBlendAttrib.h for explanation',

('OOne','OIncomingColor','OOneMinusIncomingColor','OFbufferColor',

'OOneMinusFbufferColor','OIncomingAlpha','OOneMinusIncomingAlpha',

'OFbufferAlpha','OOneMinusFbufferAlpha','OConstantColor',

'OOneMinusConstantColor','OConstantAlpha','OOneMinusConstantAlpha',

'OZero'),

self.setRendererSpriteColorBlendFbufferOperand)

self.getVariable('Sprite Renderer','Fbuffer Op.').set('OOneMinusIncomingAlpha')

p = Frame(rendererSpriteInterpolationPage)

p.pack(fill = BOTH, expand = 1)

addSegmentButton = Menubutton(p, text = 'Add Segment',

relief = RAISED,

borderwidth = 2,

font=('MSSansSerif', 14, 'bold'),

activebackground = '#909090')

segmentMenu = Menu(addSegmentButton)

addSegmentButton['menu'] = segmentMenu

segmentMenu.add_command(label = 'Add Constant segment',

command = self.addConstantInterpolationSegment)

segmentMenu.add_command(label = 'Add Linear segment',

command = self.addLinearInterpolationSegment)

segmentMenu.add_command(label = 'Add Stepwave segment',

command = self.addStepwaveInterpolationSegment)

segmentMenu.add_command(label = 'Add Sinusoid segment',

command = self.addSinusoidInterpolationSegment)

addSegmentButton.pack(expand = 0)

pp = Frame(p)

pp.pack(fill = BOTH, expand = 1, pady = 3)

sf = Pmw.ScrolledFrame(pp, horizflex = 'elastic')

sf.pack(fill = BOTH, expand = 1)

self.rendererSpriteSegmentFrame = sf.interior()

self.rendererSpriteSegmentFrame.pack(fill = BOTH, expand = 1)

self.rendererSegmentWidgetList = []

rendererSpriteNotebook.setnaturalsize()

##########################################################

## FORCE PAGE WIDGETS ##

self.addForceButton = Menubutton(forcePage, text = 'Add Force',

relief = RAISED,

borderwidth = 2,

font=('MSSansSerif', 14, 'bold'),

activebackground = '#909090')

forceMenu = Menu(self.addForceButton)

self.addForceButton['menu'] = forceMenu

# DERIVED FROM LINEAR FORCE

# This also has: setVector

forceMenu.add_command(label = 'Add Linear Vector Force',

command = self.addLinearVectorForce)

# Parameters: setAmplitude, setMassDependent, setVectorMasks

forceMenu.add_command(label = 'Add Linear Noise Force',

command = self.addLinearNoiseForce)

forceMenu.add_command(label = 'Add Linear Jitter Force',

command = self.addLinearJitterForce)

# This also has setCoef

forceMenu.add_command(label = 'Add Linear Friction Force',

command = self.addLinearFrictionForce)

# This also has: setCoef, setLength, setRadius,

forceMenu.add_command(label = 'Add Linear Cylinder Vortex Force',

command = self.addLinearCylinderVortexForce)

# DERIVED FROM LINEAR DISTANCE FORCE

# Parameters: setFalloffType, setForceCenter, setRadius

forceMenu.add_command(label = 'Add Linear Sink Force',

command = self.addLinearSinkForce)

forceMenu.add_command(label = 'Add Linear Source Force',

command = self.addLinearSourceForce)

"""

self.addForceButton.pack(expand = 0)

# Scrolled frame to hold force widgets

self.sf = Pmw.ScrolledFrame(forcePage, horizflex = 'elastic')

self.sf.pack(fill = 'both', expand = 1)

self.forceFrame = self.sf.interior()

# Notebook to hold force widgets as the are added

self.forceGroupNotebook = Pmw.NoteBook(self.forceFrame, tabpos = None)

self.forceGroupNotebook.pack(fill = X)

########################################################################

self.factoryNotebook.setnaturalsize()

self.emitterNotebook.setnaturalsize()

self.rendererNotebook.setnaturalsize()

self.forceGroupNotebook.setnaturalsize()

self.mainNotebook.setnaturalsize()

# Make sure input variables processed

self.initialiseoptions(ParticlePanel)

### WIDGET UTILITY FUNCTIONS ###

def createCheckbutton(self, parent, category, text,

balloonHelp, command, initialState, side = 'top'):

bool = BooleanVar()

bool.set(initialState)

widget = Checkbutton(parent, text = text, anchor = W,

variable = bool)

# Do this after the widget so command isn't called on creation

widget['command'] = command

widget.pack(fill = X, side = side)

self.bind(widget, balloonHelp)

self.widgetDict[category + '-' + text] = widget

self.variableDict[category + '-' + text] = bool

return widget

def createRadiobutton(self, parent, side, category, text,

balloonHelp, variable, value,

command):

widget = Radiobutton(parent, text = text, anchor = W,

variable = variable, value = value)

# Do this after the widget so command isn't called on creation

widget['command'] = command

widget.pack(side = side, fill = X)

self.bind(widget, balloonHelp)

self.widgetDict[category + '-' + text] = widget

return widget

def createFloaters(self, parent, widgetDefinitions):

widgets = []

for category, label, balloonHelp, command, min, max, resolution in widgetDefinitions:

widgets.append(

self.createFloater(parent, category, label, balloonHelp,

command, min, max, resolution)

)

return widgets

def createFloater(self, parent, category, text, balloonHelp,

command = None, min = 0.0, max = None, resolution = None,

numDigits = None, **kw):

kw['text'] = text

kw['min'] = min

if max is not None:

kw['max'] = max

kw['resolution'] = resolution

if numDigits is None:

# If this is apparently an integer setting, show no decimals.

if resolution is not None and int(resolution) == resolution and \

(min is None or int(min) == min) and \

(max is None or int(max) == max):

numDigits = 0

else:

numDigits = 3

kw['numDigits'] = numDigits

widget = Floater.Floater(parent, **kw)

# Do this after the widget so command isn't called on creation

widget['command'] = command

widget.pack(fill = X)

self.bind(widget, balloonHelp)

self.widgetDict[category + '-' + text] = widget

return widget

def createAngleDial(self, parent, category, text, balloonHelp,

command = None, **kw):

kw['text'] = text

kw['style'] = 'mini'

widget = Dial.AngleDial(parent, **kw)

# Do this after the widget so command isn't called on creation