mirror of
https://github.com/panda3d/panda3d.git
synced 2025-09-30 16:58:40 -04:00
*** empty log message ***
This commit is contained in:
Mark Mine
parent
6b55fbb87e
commit
1d0e3778e1
@ -179,14 +179,14 @@ class DirectCameraControl(PandaObject):
|
||||
return Task.cont
|
||||
|
||||
def HPanYZoomTask(self,state):
|
||||
if direct.fShift:
|
||||
if direct.fControl:
|
||||
moveDir = Vec3(Y_AXIS)
|
||||
else:
|
||||
moveDir = Vec3(self.coaMarker.getPos(direct.camera))
|
||||
# If marker is behind camera invert vector
|
||||
if moveDir[1] < 0.0:
|
||||
moveDir.assign(moveDir * -1)
|
||||
moveDir.normalize()
|
||||
else:
|
||||
moveDir = Vec3(Y_AXIS)
|
||||
moveDir.assign(moveDir * (-2.0 * direct.dr.mouseDeltaY *
|
||||
state.zoomSF))
|
||||
direct.camera.setPosHpr(direct.camera,
|
||||
|
||||
@ -1,51 +1,42 @@
|
||||
"PANDA3D Particle Panel"
|
||||
"""PANDA3D Particle Panel"""
|
||||
|
||||
# Import Tkinter, Pmw, and the floater code from this directory tree.
|
||||
from AppShell import *
|
||||
from Tkinter import *
|
||||
import Pmw
|
||||
import Dial
|
||||
import Floater
|
||||
import VectorWidgets
|
||||
import Placer
|
||||
|
||||
class ParticlePanel(Pmw.MegaToplevel):
|
||||
def __init__(self, parent = None, **kw):
|
||||
|
||||
class ParticlePanel(AppShell):
|
||||
# Override class variables
|
||||
appname = 'Particle Panel'
|
||||
frameWidth = 300
|
||||
frameHeight = 600
|
||||
usecommandarea = 0
|
||||
usestatusarea = 0
|
||||
|
||||
def __init__(self, **kw):
|
||||
INITOPT = Pmw.INITOPT
|
||||
optiondefs = (
|
||||
('title', 'Particle Panel', None),
|
||||
('title', self.appname, None),
|
||||
)
|
||||
self.defineoptions(kw, optiondefs)
|
||||
|
||||
Pmw.MegaToplevel.__init__(self, parent, title = self['title'])
|
||||
AppShell.__init__(self)
|
||||
|
||||
self.initialiseoptions(ParticlePanel)
|
||||
|
||||
def appInit(self):
|
||||
self.widgetDict = {}
|
||||
|
||||
def createInterface(self):
|
||||
# Handle to the toplevels hull
|
||||
hull = self.component('hull')
|
||||
interior = self.interior()
|
||||
|
||||
balloon = self.balloon = Pmw.Balloon(hull)
|
||||
# Start with balloon help disabled
|
||||
self.balloon.configure(state = 'none')
|
||||
|
||||
menuFrame = Frame(hull, relief = GROOVE, bd = 2)
|
||||
menuFrame.pack(fill = X, expand = 1)
|
||||
|
||||
menuBar = Pmw.MenuBar(menuFrame, hotkeys = 1, balloon = balloon)
|
||||
menuBar.pack(side = LEFT, expand = 1, fill = X)
|
||||
menuBar.addmenu('Particles', 'Particle Panel Operations')
|
||||
menuBar.addmenuitem('Particles', 'command',
|
||||
'Exit Particles Panel',
|
||||
label = 'Exit',
|
||||
command = self.destroy)
|
||||
|
||||
menuBar.addmenu('Help', 'Particle Panel Help Operations')
|
||||
self.toggleBalloonVar = IntVar()
|
||||
self.toggleBalloonVar.set(0)
|
||||
menuBar.addmenuitem('Help', 'checkbutton',
|
||||
'Toggle balloon help',
|
||||
label = 'Balloon Help',
|
||||
variable = self.toggleBalloonVar,
|
||||
command = self.toggleBalloon)
|
||||
|
||||
self.systemSelector = Pmw.ComboBox(menuFrame,
|
||||
# Combo box to switch between particle systems
|
||||
self.systemSelector = Pmw.ComboBox(self.menuFrame,
|
||||
labelpos = W,
|
||||
label_text = 'Particle System:',
|
||||
entry_width = 16,
|
||||
@ -55,207 +46,309 @@ class ParticlePanel(Pmw.MegaToplevel):
|
||||
self.systemSelector.pack(side = 'left', expand = 0)
|
||||
|
||||
# Create the notebook pages
|
||||
notebook = Pmw.NoteBook(hull)
|
||||
notebook = Pmw.NoteBook(interior)
|
||||
notebook.pack(fill = BOTH, expand = 1)
|
||||
systemPage = notebook.add('System')
|
||||
factoryPage = notebook.add('Factory')
|
||||
emitterPage = notebook.add('Emitter')
|
||||
rendererPage = notebook.add('Renderer')
|
||||
|
||||
# System page
|
||||
systemWidgets = (
|
||||
('Pool size', 'Size of particle pool', 0.0, 1.0),
|
||||
('Birth rate', 'Seconds between particle births', 0.0, None),
|
||||
('Litter size', 'Number of particle created at each birth', 1.0, 1.0),
|
||||
('Litter spread', 'Variation in litter size', 0.0, 1.0),
|
||||
('System lifespan', 'Age in seconds at which system should die', 0.0, None)
|
||||
## SYSTEM PAGE ##
|
||||
# Create system floaters
|
||||
systemFloaterDefs = (
|
||||
('System Pool size',
|
||||
'Size of particle pool',
|
||||
self.setSystemPoolSize,
|
||||
0.0, 1.0),
|
||||
('System Birth rate',
|
||||
'Seconds between particle births',
|
||||
self.setSystemBirthRate,
|
||||
0.0, None),
|
||||
('System Litter size',
|
||||
'Number of particle created at each birth',
|
||||
self.setSystemLitterSize,
|
||||
1.0, 1.0),
|
||||
('System Litter spread',
|
||||
'Variation in litter size',
|
||||
self.setSystemLitterSpread,
|
||||
0.0, 1.0),
|
||||
('System lifespan',
|
||||
'Age in seconds at which system should die',
|
||||
self.setSystemLifespan,
|
||||
0.0, None)
|
||||
)
|
||||
self.createFloaters(systemPage, systemWidgets)
|
||||
Checkbutton(systemPage, text = 'Local velocity',anchor = W).pack(
|
||||
fill = X)
|
||||
Checkbutton(systemPage, text = 'System grows older',anchor = W).pack(
|
||||
fill = X)
|
||||
self.createFloaters(systemPage, systemFloaterDefs)
|
||||
# Checkboxes
|
||||
self.systemLocalVelocity = self.createCheckbutton(
|
||||
systemPage, 'Local velocity',
|
||||
self.toggleSystemLocalVelocity, 0)
|
||||
self.systemGrowsOlder = self.createCheckbutton(
|
||||
systemPage, 'System grows older',
|
||||
self.toggleSystemGrowsOlder, 0)
|
||||
# Vector widgets
|
||||
pos = self.createVector3Entry(systemPage, 'Pos',
|
||||
'Particle system position')
|
||||
pos.addMenuItem('Popup 3DoF Panel')
|
||||
'Particle system position',
|
||||
command = self.setSystemPos)
|
||||
pos.addMenuItem('Popup Placer Panel', Placer.Placer)
|
||||
hpr = self.createVector3Entry(systemPage, 'Hpr',
|
||||
'Particle system orientation',
|
||||
floaterGroup_labels = ('H', 'P', 'R'))
|
||||
hpr.addMenuItem('Popup 3DoF Panel')
|
||||
fGroup_labels = ('H', 'P', 'R'),
|
||||
command = self.setSystemHpr)
|
||||
hpr.addMenuItem('Popup Placer Panel', Placer.Placer)
|
||||
|
||||
# FACTORY PAGE
|
||||
self.createOptionMenu(factoryPage, 'Factory type:',
|
||||
'Select type of particle factory',
|
||||
('Point', 'Z Spin', 'Oriented'),
|
||||
self.selectFactoryType)
|
||||
## FACTORY PAGE ##
|
||||
self.factorType = self.createOptionMenu(
|
||||
factoryPage,
|
||||
'Factory type:',
|
||||
'Select type of particle factory',
|
||||
('Point', 'Z Spin', 'Oriented'),
|
||||
self.selectFactoryType)
|
||||
factoryWidgets = (
|
||||
('Life span', 'Average lifespan in seconds', 0.0, None),
|
||||
('Life span spread', 'Variation in lifespan', 0.0, None),
|
||||
('Mass', 'Average particle mass', 0.0, None),
|
||||
('Mass spread', 'Variation in particle mass', 0.0, None),
|
||||
('Terminal velocity', 'Average particle terminal velocity', 0.0, None),
|
||||
('Terminal vel. spread', 'Variation in terminal velocity', 0.0, None))
|
||||
('Life span',
|
||||
'Average lifespan in seconds',
|
||||
self.setFactoryLifeSpan,
|
||||
0.0, None),
|
||||
('Life span spread',
|
||||
'Variation in lifespan',
|
||||
self.setFactoryLifeSpanSpread,
|
||||
0.0, None),
|
||||
('Mass',
|
||||
'Average particle mass',
|
||||
self.setFactoryParticleMass,
|
||||
0.0, None),
|
||||
('Mass spread',
|
||||
'Variation in particle mass',
|
||||
self.setFactoryParticleMassSpread,
|
||||
0.0, None),
|
||||
('Terminal velocity',
|
||||
'Average particle terminal velocity',
|
||||
self.setFactoryTerminalVelocity,
|
||||
0.0, None),
|
||||
('Terminal vel. spread',
|
||||
'Variation in terminal velocity',
|
||||
self.setFactoryTerminalVelocitySpread,
|
||||
0.0, None))
|
||||
self.createFloaters(factoryPage, factoryWidgets)
|
||||
|
||||
self.factoryNotebook = Pmw.NoteBook(factoryPage, tabpos = None)
|
||||
pointPage = self.factoryNotebook.add('Point')
|
||||
# Point page #
|
||||
factoryPointPage = self.factoryNotebook.add('Point')
|
||||
# Z spin page #
|
||||
zSpinPage = self.factoryNotebook.add('Z Spin')
|
||||
self.createAngleDial(zSpinPage, 'Initial angle',
|
||||
'Starting angle in degrees')
|
||||
'Starting angle in degrees',
|
||||
command = self.setFactoryZSpinInitialAngle)
|
||||
self.createAngleDial(zSpinPage, 'Final angle',
|
||||
'Final angle in degrees')
|
||||
'Final angle in degrees',
|
||||
command = self.setFactoryZSpinFinalAngle)
|
||||
self.createAngleDial(zSpinPage, 'Angle spread',
|
||||
'Spread of the final angle')
|
||||
'Spread of the final angle',
|
||||
command = self.setFactoryZSpinAngleSpread)
|
||||
# Oriented page #
|
||||
orientedPage = self.factoryNotebook.add('Oriented')
|
||||
Label(orientedPage, text = 'Not implemented').pack(expand = 1,
|
||||
fill = BOTH)
|
||||
self.factoryNotebook.pack(expand = 1, fill = BOTH)
|
||||
|
||||
# EMITTER PAGE
|
||||
## EMITTER PAGE ##
|
||||
self.createOptionMenu(emitterPage, 'Emitter type:',
|
||||
'Select type of particle emitter',
|
||||
('Box', 'Disc', 'Line', 'Point', 'Rectangle',
|
||||
'Ring', 'Sphere Surface', 'Sphere Volume',
|
||||
'Tangent Ring'),
|
||||
self.selectEmitterType)
|
||||
|
||||
self.emitterNotebook = Pmw.NoteBook(emitterPage, tabpos = None)
|
||||
pointPage = self.emitterNotebook.add('Box')
|
||||
self.createVector3Entry(pointPage, 'Point 1',
|
||||
'Point defining emitter box')
|
||||
self.createVector3Entry(pointPage, 'Point 2',
|
||||
# Box page #
|
||||
boxPage = self.emitterNotebook.add('Box')
|
||||
self.createVector3Entry(boxPage, 'Point 1',
|
||||
'Point defining emitter box',
|
||||
command = self.setEmitterBoxPoint1)
|
||||
self.createVector3Entry(boxPage, 'Point 2',
|
||||
'Point defining emitter box',
|
||||
command = self.setEmitterBoxPoint2,
|
||||
initialValue = (1.0, 1.0, 1.0))
|
||||
self.createVector3Entry(pointPage, 'Launch vector',
|
||||
'Initial particle velocity vector')
|
||||
|
||||
self.createVector3Entry(boxPage, 'Velocity vector',
|
||||
'Initial particle velocity vector',
|
||||
command = self.setEmitterBoxVelocityVector)
|
||||
# Disc page #
|
||||
discPage = self.emitterNotebook.add('Disc')
|
||||
self.createFloater(discPage, 'Radius', 'Radius of disc')
|
||||
self.createFloater(discPage, 'Radius', 'Radius of disc',
|
||||
command = self.setEmitterDiscRadius)
|
||||
self.createAngleDial(discPage, 'Inner angle',
|
||||
'Particle launch angle at center of disc')
|
||||
self.createFloater(discPage, 'Inner magnitude',
|
||||
'Launch velocity multiplier at center of disc')
|
||||
'Particle launch angle at center of disc',
|
||||
command = self.setEmitterDiscInnerAngle)
|
||||
self.createFloater(discPage, 'Inner velocity',
|
||||
'Launch velocity multiplier at center of disc',
|
||||
command = self.setEmitterDiscInnerVelocity)
|
||||
self.createAngleDial(discPage, 'Outer angle',
|
||||
'Particle launch angle at outer edge of disc')
|
||||
self.createFloater(discPage, 'Outer magnitude',
|
||||
'Launch velocity multiplier at edge of disc')
|
||||
|
||||
Checkbutton(discPage, text = 'Cubic Lerping').pack(
|
||||
side = LEFT, expand = 1, fill = X)
|
||||
|
||||
'Particle launch angle at outer edge of disc',
|
||||
command = self.setEmitterDiscOuterAngle)
|
||||
self.createFloater(discPage, 'Outer velocity',
|
||||
'Launch velocity multiplier at edge of disc',
|
||||
command = self.setEmitterDiscOuterVelocity)
|
||||
self.emitterDiscCubicLerping = self.createCheckbutton(
|
||||
discPage, 'Cubic Lerping',
|
||||
self.toggleEmitterDiscCubicLerping, 0)
|
||||
# Line page #
|
||||
linePage = self.emitterNotebook.add('Line')
|
||||
self.createVector3Entry(linePage, 'Point 1',
|
||||
'Point defining emitter line')
|
||||
'Point defining emitter line',
|
||||
command = self.setEmitterLinePoint1)
|
||||
self.createVector3Entry(linePage, 'Point 2',
|
||||
'Point defining emitter line',
|
||||
command = self.setEmitterLinePoint2,
|
||||
initialValue = (1.0, 0.0, 0.0))
|
||||
self.createVector3Entry(linePage, 'Launch Vector',
|
||||
self.createVector3Entry(linePage, 'Velocity Vector',
|
||||
'Initial particle velocity vector',
|
||||
command = self.setEmitterLineVelocityVector,
|
||||
initialValue = (0.0, 0.0, 1.0))
|
||||
|
||||
pointPage = self.emitterNotebook.add('Point')
|
||||
self.createVector3Entry(pointPage, 'Location',
|
||||
'Location of emitter point')
|
||||
self.createVector3Entry(pointPage, 'Launch vector',
|
||||
# Point page #
|
||||
emitterPointPage = self.emitterNotebook.add('Point')
|
||||
self.createVector3Entry(emitterPointPage, 'Position',
|
||||
'Position of emitter point',
|
||||
command = self.setEmitterPointPosition)
|
||||
self.createVector3Entry(emitterPointPage, 'Velocity vector',
|
||||
'Initial particle velocity vector',
|
||||
command = self.setEmitterPointVelocityVector,
|
||||
initialValue = (0.0, 0.0, 1.0))
|
||||
|
||||
# Rectangle #
|
||||
rectanglePage = self.emitterNotebook.add('Rectangle')
|
||||
self.createVector3Entry(rectanglePage, 'Point 1',
|
||||
'Point defining rectangle')
|
||||
'Point defining rectangle',
|
||||
command = self.setEmitterRectanglePoint1)
|
||||
self.createVector3Entry(rectanglePage, 'Point 2',
|
||||
'Point defining rectangle')
|
||||
self.createVector3Entry(rectanglePage, 'Launch vector',
|
||||
'Initial particle velocity vector',
|
||||
initialValue = (0.0, 0.0, 1.0))
|
||||
|
||||
'Point defining rectangle',
|
||||
command = self.setEmitterRectanglePoint2)
|
||||
self.createVector3Entry(
|
||||
rectanglePage, 'Velocity vector',
|
||||
'Initial particle velocity vector',
|
||||
command = self.setEmitterRectangleVelocityVector,
|
||||
initialValue = (0.0, 0.0, 1.0))
|
||||
# Ring #
|
||||
ringPage = self.emitterNotebook.add('Ring')
|
||||
self.createFloater(ringPage, 'Radius', 'Radius of ring')
|
||||
self.createAngleDial(ringPage, 'Angle', 'Particle launch angle')
|
||||
self.createFloater(ringPage, 'Radius', 'Radius of ring',
|
||||
command = self.setEmitterRingRadius)
|
||||
self.createAngleDial(ringPage, 'Angle', 'Particle launch angle',
|
||||
command = self.setEmitterRingLaunchAngle)
|
||||
self.createFloater(ringPage, 'Magnitude',
|
||||
'Launch velocity multiplier at outer edge of ring')
|
||||
|
||||
'Launch velocity multiplier at outer edge of ring',
|
||||
command = self.setEmitterRingVelocityMultiplier)
|
||||
# Sphere surface #
|
||||
sphereSurfacePage = self.emitterNotebook.add('Sphere Surface')
|
||||
self.createFloater(sphereSurfacePage, 'Radius',
|
||||
'Radius of sphere')
|
||||
|
||||
'Radius of sphere',
|
||||
command = self.setEmitterSphereSurfaceRadius)
|
||||
# Sphere volume #
|
||||
sphereVolumePage = self.emitterNotebook.add('Sphere Volume')
|
||||
self.createFloater(sphereVolumePage, 'Radius',
|
||||
'Radius of sphere')
|
||||
|
||||
'Radius of sphere',
|
||||
command = self.setEmitterSphereVolumeRadius)
|
||||
# Tangent ring #
|
||||
tangentRingPage = self.emitterNotebook.add('Tangent Ring')
|
||||
self.createFloater(tangentRingPage, 'Radius',
|
||||
'Radius of ring')
|
||||
|
||||
'Radius of ring',
|
||||
command = self.setEmitterTangentRingRadius)
|
||||
self.emitterNotebook.pack(fill = X)
|
||||
|
||||
# RENDERER PAGE
|
||||
## RENDERER PAGE ##
|
||||
self.createOptionMenu(rendererPage, 'Renderer type:',
|
||||
'Select type of particle renderer',
|
||||
('Geom', 'Point', 'Sparkle', 'Sprite'),
|
||||
self.selectRendererType)
|
||||
self.rendererNotebook = Pmw.NoteBook(rendererPage, tabpos = None)
|
||||
# Geom page #
|
||||
geomPage = self.rendererNotebook.add('Geom')
|
||||
f = Frame(geomPage)
|
||||
f.pack(fill = X)
|
||||
Label(f, width = 12, text = 'Geom node:').pack(side = LEFT)
|
||||
Entry(f, width = 12).pack(side = LEFT, expand = 1, fill = X)
|
||||
|
||||
pointPage = self.rendererNotebook.add('Point')
|
||||
self.createFloater(pointPage, 'Point size',
|
||||
'Width and height of points in pixels')
|
||||
self.createColorEntry(pointPage, 'Start color',
|
||||
'Starting color of point')
|
||||
self.createColorEntry(pointPage, 'End color',
|
||||
'Ending color of point')
|
||||
self.createOptionMenu(pointPage, 'Blend type:',
|
||||
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)
|
||||
# Point #
|
||||
rendererPointPage = self.rendererNotebook.add('Point')
|
||||
self.createFloater(rendererPointPage, 'Point size',
|
||||
'Width and height of points in pixels',
|
||||
command = self.setRendererPointSize)
|
||||
self.createColorEntry(rendererPointPage, 'Start color',
|
||||
'Starting color of point',
|
||||
command = self.setRendererPointStartColor)
|
||||
self.createColorEntry(rendererPointPage, 'End color',
|
||||
'Ending color of point',
|
||||
command = self.setRendererPointEndColor)
|
||||
self.createOptionMenu(rendererPointPage, 'Blend type:',
|
||||
'Type of color blending used for particle',
|
||||
('ONE_COLOR', 'BLEND_LIFE', 'BLEND_VEL'),
|
||||
self.selectBlendType)
|
||||
self.createOptionMenu(pointPage, 'Blend method:',
|
||||
self.rendererPointSelectBlendType)
|
||||
self.createOptionMenu(rendererPointPage, 'Blend method:',
|
||||
'Interpolation method between colors',
|
||||
('LINEAR', 'CUBIC'),
|
||||
self.selectBlendMethod)
|
||||
|
||||
self.rendererPointSelectBlendMethod)
|
||||
# Sparkle #
|
||||
sparklePage = self.rendererNotebook.add('Sparkle')
|
||||
self.createColorEntry(sparklePage, 'Center color',
|
||||
'Color of sparkle center')
|
||||
'Color of sparkle center',
|
||||
command = self.setRendererSparkleCenterColor)
|
||||
self.createColorEntry(sparklePage, 'Edge color',
|
||||
'Color of sparkle line endpoints')
|
||||
'Color of sparkle line endpoints',
|
||||
command = self.setRendererSparkleEdgeColor)
|
||||
self.createFloater(sparklePage, 'Birth radius',
|
||||
'Initial sparkle radius')
|
||||
'Initial sparkle radius',
|
||||
command = self.setRendererSparkleBirthRadius)
|
||||
self.createFloater(sparklePage, 'Death radius',
|
||||
'Final sparkle radius')
|
||||
self.createOptionMenu(pointPage, 'Life scale:',
|
||||
'Final sparkle radius',
|
||||
command = self.setRendererSparkleDeathRadius)
|
||||
self.createOptionMenu(sparklePage, 'Life scale:',
|
||||
'Does particle scale over its lifetime?',
|
||||
('NO_SCALE', 'SCALE'),
|
||||
self.selectBlendMethod)
|
||||
|
||||
self.setRendererSparkleBlendMethod)
|
||||
# Sprite #
|
||||
spritePage = self.rendererNotebook.add('Sprite')
|
||||
f = Frame(spritePage)
|
||||
f.pack(fill = X)
|
||||
Label(f, width = 12, text = 'Texture:').pack(side = LEFT)
|
||||
Entry(f, width = 12).pack(side = LEFT, expand = 1, fill = X)
|
||||
self.rendererSpriteTexture = StringVar()
|
||||
self.rendererSpriteTextureEntry = Entry(
|
||||
f, width = 12,
|
||||
textvariable = self.rendererSpriteTexture)
|
||||
self.rendererSpriteTextureEntry.bind(
|
||||
'<Return>', self.setRendererSpriteTexture)
|
||||
self.rendererSpriteTextureEntry.pack(side = LEFT, expand = 1, fill = X)
|
||||
|
||||
Checkbutton(spritePage, text = 'xScale',anchor = W).pack(fill = X)
|
||||
Checkbutton(spritePage, text = 'yScale',anchor = W).pack(fill = X)
|
||||
Checkbutton(spritePage, text = 'animAngle',anchor = W).pack(fill = X)
|
||||
self.rendererSpriteXScale = self.createCheckbutton(
|
||||
spritePage, 'X Scale',
|
||||
self.toggleRendererSpriteXScale, 0)
|
||||
self.rendererSpriteYScale = self.createCheckbutton(
|
||||
spritePage, 'Y Scale',
|
||||
self.toggleRendererSpriteYScale, 0)
|
||||
self.rendererSpriteAnimAngle = self.createCheckbutton(
|
||||
spritePage, 'Anim Angle',
|
||||
self.toggleRendererSpriteAnimAngle, 0)
|
||||
self.createFloater(spritePage, 'Initial X Scale',
|
||||
'Initial X scaling factor')
|
||||
'Initial X scaling factor',
|
||||
command = self.setRendererSpriteInitialXScale)
|
||||
self.createFloater(spritePage, 'Final X Scale',
|
||||
'Final X scaling factor')
|
||||
'Final X scaling factor',
|
||||
command = self.setRendererSpriteFinalXScale)
|
||||
self.createFloater(spritePage, 'Initial Y Scale',
|
||||
'Initial Y scaling factor')
|
||||
'Initial Y scaling factor',
|
||||
command = self.setRendererSpriteInitialYScale)
|
||||
self.createFloater(spritePage, 'Final Y Scale',
|
||||
'Final Y scaling factor')
|
||||
'Final Y scaling factor',
|
||||
command = self.setRendererSpriteFinalYScale)
|
||||
self.createAngleDial(spritePage, 'Non Animated Theta',
|
||||
'Counter clockwise Z rotation of all sprites')
|
||||
'Counter clockwise Z rotation of all sprites',
|
||||
command = self.setRendererSpriteNonAnimatedTheta)
|
||||
self.createOptionMenu(spritePage, 'Blend Type',
|
||||
'Interpolation blend type for X and Y scaling',
|
||||
('LINEAR', 'CUBIC'),
|
||||
self.selectBlendMethod)
|
||||
Checkbutton(spritePage, text = 'alphaDisable',anchor = W).pack(fill = X)
|
||||
|
||||
|
||||
self.setRendererSpriteBlendMethod)
|
||||
self.rendererSpriteAlphaDisable = self.createCheckbutton(
|
||||
spritePage, 'alphaDisable',
|
||||
self.toggleRendererSpriteAlphaDisable, 0)
|
||||
self.rendererNotebook.pack(fill = X)
|
||||
|
||||
self.factoryNotebook.setnaturalsize()
|
||||
@ -266,26 +359,42 @@ class ParticlePanel(Pmw.MegaToplevel):
|
||||
# Make sure input variables processed
|
||||
self.initialiseoptions(ParticlePanel)
|
||||
|
||||
### WIDGET UTILITY FUNCTIONS ###
|
||||
def createCheckbutton(self, parent, text, command, initialState):
|
||||
bool = BooleanVar()
|
||||
bool.set(initialState)
|
||||
cb = Checkbutton(parent, text = text, anchor = W,
|
||||
variable = bool, command = command)
|
||||
cb.pack(fill = X)
|
||||
return bool
|
||||
|
||||
def createFloaters(self, parent, widgetDefinitions):
|
||||
for label, balloonHelp, min, resolution in widgetDefinitions:
|
||||
self.createFloater(parent, label, balloonHelp, min, resolution)
|
||||
widgets = []
|
||||
for label, balloonHelp, command, min, resolution in widgetDefinitions:
|
||||
widgets.append(
|
||||
self.createFloater(parent, label, balloonHelp,
|
||||
command, min, resolution)
|
||||
)
|
||||
return widgets
|
||||
|
||||
def createFloater(self, parent, text, balloonHelp,
|
||||
def createFloater(self, parent, text, balloonHelp, command = None,
|
||||
min = 0.0, resolution = None, **kw):
|
||||
kw['text'] = text
|
||||
kw['min'] = min
|
||||
kw['initialValue'] = min
|
||||
kw['resolution'] = resolution
|
||||
kw['command'] = command
|
||||
widget = apply(Floater.Floater, (parent,), kw)
|
||||
widget.pack(fill = X)
|
||||
self.balloon.bind(widget, balloonHelp)
|
||||
self.bind(widget, balloonHelp)
|
||||
self.widgetDict['text'] = widget
|
||||
return widget
|
||||
|
||||
def createAngleDial(self, parent, text, balloonHelp, **kw):
|
||||
kw['text'] = text
|
||||
widget = apply(Dial.AngleDial,(parent,), kw)
|
||||
widget.pack(fill = X)
|
||||
self.balloon.bind(widget, balloonHelp)
|
||||
self.bind(widget, balloonHelp)
|
||||
return widget
|
||||
|
||||
def createVector3Entry(self, parent, text, balloonHelp, **kw):
|
||||
@ -293,7 +402,7 @@ class ParticlePanel(Pmw.MegaToplevel):
|
||||
kw['text'] = text
|
||||
widget = apply(VectorWidgets.Vector3Entry, (parent,), kw)
|
||||
widget.pack(fill = X)
|
||||
self.balloon.bind(widget, balloonHelp)
|
||||
self.bind(widget, balloonHelp)
|
||||
return widget
|
||||
|
||||
def createColorEntry(self, parent, text, balloonHelp, **kw):
|
||||
@ -301,7 +410,7 @@ class ParticlePanel(Pmw.MegaToplevel):
|
||||
kw['text'] = text
|
||||
widget = apply(VectorWidgets.ColorEntry, (parent,) ,kw)
|
||||
widget.pack(fill = X)
|
||||
self.balloon.bind(widget, balloonHelp)
|
||||
self.bind(widget, balloonHelp)
|
||||
return widget
|
||||
|
||||
def createOptionMenu(self, parent, text, balloonHelp, items, command):
|
||||
@ -313,32 +422,198 @@ class ParticlePanel(Pmw.MegaToplevel):
|
||||
items = items,
|
||||
command = command)
|
||||
widget.pack(fill = X)
|
||||
self.balloon.bind(widget.component('menubutton'), balloonHelp)
|
||||
self.bind(widget.component('menubutton'), balloonHelp)
|
||||
return optionVar
|
||||
|
||||
|
||||
### PARTICLE SYSTEM COMMANDS ###
|
||||
## System Page ##
|
||||
def setSystemPoolSize(self, value):
|
||||
print 'Pool size:', value
|
||||
def setSystemBirthRate(self, value):
|
||||
print 'Birth rate:', value
|
||||
def setSystemLitterSize(self, value):
|
||||
print 'Litter size:', value
|
||||
def setSystemLitterSpread(self, value):
|
||||
print 'Litter spread:', value
|
||||
def setSystemLifespan(self, value):
|
||||
print 'System lifespan:', value
|
||||
def toggleSystemLocalVelocity(self):
|
||||
print 'Local velocity is ',
|
||||
if self.systemLocalVelocity.get():
|
||||
print 'on'
|
||||
else:
|
||||
print 'off'
|
||||
def toggleSystemGrowsOlder(self):
|
||||
print 'System Grows Older is ',
|
||||
if self.systemGrowsOlder.get():
|
||||
print 'on'
|
||||
else:
|
||||
print 'off'
|
||||
def setSystemPos(self, pos):
|
||||
print 'System pos:', pos
|
||||
def setSystemHpr(self, pos):
|
||||
print 'System hpr:', pos
|
||||
|
||||
## Factory Page ##
|
||||
def selectFactoryType(self, type):
|
||||
self.factoryNotebook.selectpage(type)
|
||||
print 'Factory type:', type
|
||||
def setFactoryLifeSpan(self, value):
|
||||
print 'Factory Life span:', value
|
||||
def setFactoryLifeSpanSpread(self, value):
|
||||
print 'Factory Life span spread:', value
|
||||
def setFactoryParticleMass(self, value):
|
||||
print 'Factory Particle mass:', value
|
||||
def setFactoryParticleMassSpread(self, value):
|
||||
print 'Factory Particle mass spread:', value
|
||||
def setFactoryTerminalVelocity(self, value):
|
||||
print 'Factory Terminal velocity:', value
|
||||
def setFactoryTerminalVelocitySpread(self, value):
|
||||
print 'Factory Terminal velocity spread:', value
|
||||
# Point Page #
|
||||
# Z Spin Page #
|
||||
def setFactoryZSpinInitialAngle(self, angle):
|
||||
print 'Factor Z Spin initial angle:', angle
|
||||
def setFactoryZSpinFinalAngle(self, angle):
|
||||
print 'Factory Z Spin final angle:', angle
|
||||
def setFactoryZSpinAngleSpread(self, spread):
|
||||
print 'Factory Z Spin angle spread:', spread
|
||||
|
||||
## Emitter page ##
|
||||
def selectEmitterType(self, type):
|
||||
self.emitterNotebook.selectpage(type)
|
||||
print 'Emitter type:', type
|
||||
# Box #
|
||||
def setEmitterBoxPoint1(self, point):
|
||||
print 'Emitter box point 1:', point
|
||||
def setEmitterBoxPoint2(self, point):
|
||||
print 'Emitter box point 2:', point
|
||||
def setEmitterBoxVelocityVector(self, vec):
|
||||
print 'Emitter box velocity vector:', vec
|
||||
# Disc #
|
||||
def setEmitterDiscRadius(self, radius):
|
||||
print 'Emitter disc radius:', radius
|
||||
def setEmitterDiscInnerAngle(self, angle):
|
||||
print 'Emitter disc inner angle:', angle
|
||||
def setEmitterDiscInnerVelocity(self, velocity):
|
||||
print 'Emitter disc inner velocity:', velocity
|
||||
def setEmitterDiscOuterAngle(self, angle):
|
||||
print 'Emitter disc outer angle:', angle
|
||||
def setEmitterDiscOuterVelocity(self, velocity):
|
||||
print 'Emitter disc outer velocity:', velocity
|
||||
def toggleEmitterDiscCubicLerping(self):
|
||||
print 'Emitter disc cubic lerping is ',
|
||||
if self.emitterDiscCubicLerping.get():
|
||||
print 'on'
|
||||
else:
|
||||
print 'off'
|
||||
# Line #
|
||||
def setEmitterLinePoint1(self, point):
|
||||
print 'Emitter line point 1:', point
|
||||
def setEmitterLinePoint2(self, point):
|
||||
print 'Emitter line point 2:', point
|
||||
def setEmitterLineVelocityVector(self, vec):
|
||||
print 'Emitter line velocity vector:', vec
|
||||
# Point #
|
||||
def setEmitterPointPosition(self, pos):
|
||||
print 'Emitter point position:', pos
|
||||
def setEmitterPointVelocityVector(self, velocity):
|
||||
print 'Emitter point velocity:', velocity
|
||||
# Rectangle #
|
||||
def setEmitterRectanglePoint1(self, point):
|
||||
print 'Emitter rectangle point 1:', point
|
||||
def setEmitterRectanglePoint2(self, point):
|
||||
print 'Emitter rectangle point 2:', point
|
||||
def setEmitterRectangleVelocityVector(self, vec):
|
||||
print 'Emitter rectangle velocity vector:', vec
|
||||
# Ring #
|
||||
def setEmitterRingRadius(self, radius):
|
||||
print 'Emitter ring radius:', radius
|
||||
def setEmitterRingLaunchAngle(self, angle):
|
||||
print 'Emitter ring launch angle:', angle
|
||||
def setEmitterRingVelocityMultiplier(self, multiplier):
|
||||
print 'Emitter ring velocity multiplier:', multiplier
|
||||
# Sphere surface #
|
||||
def setEmitterSphereSurfaceRadius(self, radius):
|
||||
print 'Emitter sphere surface radius:', radius
|
||||
# Sphere volume #
|
||||
def setEmitterSphereVolumeRadius(self, radius):
|
||||
print 'Emitter sphere volume radius:', radius
|
||||
# Tangent ring #
|
||||
def setEmitterTangentRingRadius(self, radius):
|
||||
print 'Emitter tangent ring radius:', radius
|
||||
|
||||
## RENDERER PAGE ##
|
||||
def selectRendererType(self, type):
|
||||
self.rendererNotebook.selectpage(type)
|
||||
|
||||
def selectBlendType(self, type):
|
||||
print type
|
||||
|
||||
def selectBlendMethod(self, method):
|
||||
print method
|
||||
|
||||
# Geom #
|
||||
def setRendererGeomNode(self, event):
|
||||
print 'Renderer Geom node:', self.rendererGeomNode.get()
|
||||
# Point #
|
||||
def setRendererPointSize(self, size):
|
||||
print 'Renderer Point size:', size
|
||||
def setRendererPointStartColor(self, color):
|
||||
print 'Renderer Point start color:', color
|
||||
def setRendererPointEndColor(self, color):
|
||||
print 'Renderer Point end color:', color
|
||||
def rendererPointSelectBlendType(self, type):
|
||||
print 'Renderer Point blend type:', type
|
||||
def rendererPointSelectBlendMethod(self, method):
|
||||
print 'Renderer Point blend method:', method
|
||||
# Sparkle #
|
||||
def setRendererSparkleCenterColor(self, color):
|
||||
print 'Renderer Sparkle center color:', color
|
||||
def setRendererSparkleEdgeColor(self, color):
|
||||
print 'Renderer Sparkle edge color:', color
|
||||
def setRendererSparkleBirthRadius(self, radius):
|
||||
print 'Renderer Sparkle birth radius:', radius
|
||||
def setRendererSparkleDeathRadius(self, radius):
|
||||
print 'Renderer Sparkle death radius:', radius
|
||||
def setRendererSparkleBlendMethod(self, method):
|
||||
print 'Renderer Sparkle blend method:', method
|
||||
# Sprite #
|
||||
def setRendererSpriteTexture(self, event):
|
||||
print 'Sprite texture:', self.rendererSpriteTexture.get()
|
||||
def toggleRendererSpriteXScale(self):
|
||||
print 'Renderer Sprite x scale is ',
|
||||
if self.rendererSpriteXScale.get():
|
||||
print 'on'
|
||||
else:
|
||||
print 'off'
|
||||
def toggleRendererSpriteYScale(self):
|
||||
print 'Renderer Sprite y scale is ',
|
||||
if self.rendererSpriteYScale.get():
|
||||
print 'on'
|
||||
else:
|
||||
print 'off'
|
||||
def toggleRendererSpriteAnimAngle(self):
|
||||
print 'Renderer Sprite anim angle is ',
|
||||
if self.rendererSpriteAnimAngle.get():
|
||||
print 'on'
|
||||
else:
|
||||
print 'off'
|
||||
def setRendererSpriteInitialXScale(self, xScale):
|
||||
print 'Renderer Sprite initial x scale:', xScale
|
||||
def setRendererSpriteFinalXScale(self, xScale):
|
||||
print 'Renderer Sprite final x scale:', xScale
|
||||
def setRendererSpriteInitialYScale(self, yScale):
|
||||
print 'Renderer Sprite initial y scale:', yScale
|
||||
def setRendererSpriteFinalYScale(self, yScale):
|
||||
print 'Renderer Sprite final y scale:', yScale
|
||||
def setRendererSpriteNonAnimatedTheta(self, theta):
|
||||
print 'Renderer Sprite non animated theta:', theta
|
||||
def setRendererSpriteBlendMethod(self, method):
|
||||
print 'Renderer Sprite blend method:', method
|
||||
def toggleRendererSpriteAlphaDisable(self):
|
||||
print 'Renderer Sprite alpha disable is ',
|
||||
if self.rendererSpriteAlphaDisable.get():
|
||||
print 'on'
|
||||
else:
|
||||
print 'off'
|
||||
|
||||
def selectSystemNamed(self, name):
|
||||
print name
|
||||
|
||||
def toggleBalloon(self):
|
||||
if self.toggleBalloonVar.get():
|
||||
self.balloon.configure(state = 'balloon')
|
||||
else:
|
||||
self.balloon.configure(state = 'none')
|
||||
|
||||
######################################################################
|
||||
|
||||
|
||||
@ -28,7 +28,7 @@ class Placer(AppShell):
|
||||
def __init__(self, parent = None, **kw):
|
||||
INITOPT = Pmw.INITOPT
|
||||
optiondefs = (
|
||||
('title', 'Placer Panel', None),
|
||||
('title', self.appname, None),
|
||||
('nodePath', direct.camera, None),
|
||||
)
|
||||
self.defineoptions(kw, optiondefs)
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user