|
@@ -66,7 +66,7 @@ class ParticlePanel(AppShell):
|
|
|
INITOPT = Pmw.INITOPT
|
|
INITOPT = Pmw.INITOPT
|
|
|
optiondefs = (
|
|
optiondefs = (
|
|
|
('title', self.appname, None),
|
|
('title', self.appname, None),
|
|
|
- )
|
|
|
|
|
|
|
+ )
|
|
|
self.defineoptions(kw, optiondefs)
|
|
self.defineoptions(kw, optiondefs)
|
|
|
|
|
|
|
|
# Record particle effect
|
|
# Record particle effect
|
|
@@ -113,7 +113,6 @@ class ParticlePanel(AppShell):
|
|
|
self.particleEffect)
|
|
self.particleEffect)
|
|
|
self.forcePagesDict = {}
|
|
self.forcePagesDict = {}
|
|
|
|
|
|
|
|
-
|
|
|
|
|
def createInterface(self):
|
|
def createInterface(self):
|
|
|
# Handle to the toplevels hull
|
|
# Handle to the toplevels hull
|
|
|
interior = self.interior()
|
|
interior = self.interior()
|
|
@@ -171,6 +170,7 @@ class ParticlePanel(AppShell):
|
|
|
self.effectsLabelMenu.add_command(
|
|
self.effectsLabelMenu.add_command(
|
|
|
label = 'Place Particle Effect',
|
|
label = 'Place Particle Effect',
|
|
|
command = lambda s = self: Placer.place(s.particleEffect))
|
|
command = lambda s = self: Placer.place(s.particleEffect))
|
|
|
|
|
+
|
|
|
def togglePEVis(s = self):
|
|
def togglePEVis(s = self):
|
|
|
if s.particleEffect.isHidden():
|
|
if s.particleEffect.isHidden():
|
|
|
s.particleEffect.show()
|
|
s.particleEffect.show()
|
|
@@ -257,7 +257,7 @@ class ParticlePanel(AppShell):
|
|
|
'Age in seconds at which the system (vs. particles) should die',
|
|
'Age in seconds at which the system (vs. particles) should die',
|
|
|
self.setSystemLifespan,
|
|
self.setSystemLifespan,
|
|
|
0.0, None, None)
|
|
0.0, None, None)
|
|
|
- )
|
|
|
|
|
|
|
+ )
|
|
|
self.createFloaters(systemPage, systemFloaterDefs)
|
|
self.createFloaters(systemPage, systemFloaterDefs)
|
|
|
|
|
|
|
|
# Checkboxes
|
|
# Checkboxes
|
|
@@ -327,19 +327,18 @@ class ParticlePanel(AppShell):
|
|
|
|
|
|
|
|
self.createCheckbutton(
|
|
self.createCheckbutton(
|
|
|
zSpinPage, 'Z Spin Factory', 'Enable Angular Velocity',
|
|
zSpinPage, 'Z Spin Factory', 'Enable Angular Velocity',
|
|
|
- ("On: angular velocity is used; " +
|
|
|
|
|
- "Off: final angle is used"),
|
|
|
|
|
|
|
+ 'On: angular velocity is used; Off: final angle is used',
|
|
|
self.toggleAngularVelocity, 0, side = tk.TOP)
|
|
self.toggleAngularVelocity, 0, side = tk.TOP)
|
|
|
|
|
|
|
|
self.createFloater(
|
|
self.createFloater(
|
|
|
zSpinPage, 'Z Spin Factory', 'Angular Velocity',
|
|
zSpinPage, 'Z Spin Factory', 'Angular Velocity',
|
|
|
- 'How fast sprites rotate',
|
|
|
|
|
- command = self.setFactoryZSpinAngularVelocity)
|
|
|
|
|
|
|
+ 'How fast sprites rotate',
|
|
|
|
|
+ command = self.setFactoryZSpinAngularVelocity)
|
|
|
|
|
|
|
|
self.createFloater(
|
|
self.createFloater(
|
|
|
zSpinPage, 'Z Spin Factory', 'Angular Velocity Spread',
|
|
zSpinPage, 'Z Spin Factory', 'Angular Velocity Spread',
|
|
|
- 'Variation in how fast sprites rotate',
|
|
|
|
|
- command = self.setFactoryZSpinAngularVelocitySpread)
|
|
|
|
|
|
|
+ 'Variation in how fast sprites rotate',
|
|
|
|
|
+ command = self.setFactoryZSpinAngularVelocitySpread)
|
|
|
|
|
|
|
|
self.createAngleDial(zSpinPage, 'Z Spin Factory', 'Initial Angle',
|
|
self.createAngleDial(zSpinPage, 'Z Spin Factory', 'Initial Angle',
|
|
|
'Starting angle in degrees',
|
|
'Starting angle in degrees',
|
|
@@ -996,7 +995,7 @@ class ParticlePanel(AppShell):
|
|
|
widgets.append(
|
|
widgets.append(
|
|
|
self.createFloater(parent, category, label, balloonHelp,
|
|
self.createFloater(parent, category, label, balloonHelp,
|
|
|
command, min, max, resolution)
|
|
command, min, max, resolution)
|
|
|
- )
|
|
|
|
|
|
|
+ )
|
|
|
return widgets
|
|
return widgets
|
|
|
|
|
|
|
|
def createFloater(self, parent, category, text, balloonHelp,
|
|
def createFloater(self, parent, category, text, balloonHelp,
|
|
@@ -1158,7 +1157,7 @@ class ParticlePanel(AppShell):
|
|
|
label = effect.getName(),
|
|
label = effect.getName(),
|
|
|
command = (lambda s = self,
|
|
command = (lambda s = self,
|
|
|
e = effect: s.selectEffectNamed(e.getName()))
|
|
e = effect: s.selectEffectNamed(e.getName()))
|
|
|
- )
|
|
|
|
|
|
|
+ )
|
|
|
effectActive = tk.IntVar()
|
|
effectActive = tk.IntVar()
|
|
|
effectActive.set(effect.isEnabled())
|
|
effectActive.set(effect.isEnabled())
|
|
|
self.effectsEnableMenu.add_checkbutton(
|
|
self.effectsEnableMenu.add_checkbutton(
|
|
@@ -1183,7 +1182,7 @@ class ParticlePanel(AppShell):
|
|
|
label = name,
|
|
label = name,
|
|
|
command = (lambda s = self,
|
|
command = (lambda s = self,
|
|
|
n = name: s.selectParticlesNamed(n))
|
|
n = name: s.selectParticlesNamed(n))
|
|
|
- )
|
|
|
|
|
|
|
+ )
|
|
|
particleActive = tk.IntVar()
|
|
particleActive = tk.IntVar()
|
|
|
particleActive.set(particle.isEnabled())
|
|
particleActive.set(particle.isEnabled())
|
|
|
self.particlesEnableMenu.add_checkbutton(
|
|
self.particlesEnableMenu.add_checkbutton(
|
|
@@ -1208,7 +1207,7 @@ class ParticlePanel(AppShell):
|
|
|
label = name,
|
|
label = name,
|
|
|
command = (lambda s = self,
|
|
command = (lambda s = self,
|
|
|
n = name: s.selectForceGroupNamed(n))
|
|
n = name: s.selectForceGroupNamed(n))
|
|
|
- )
|
|
|
|
|
|
|
+ )
|
|
|
forceActive = tk.IntVar()
|
|
forceActive = tk.IntVar()
|
|
|
forceActive.set(force.isEnabled())
|
|
forceActive.set(force.isEnabled())
|
|
|
self.forceGroupEnableMenu.add_checkbutton(
|
|
self.forceGroupEnableMenu.add_checkbutton(
|
|
@@ -1379,24 +1378,33 @@ class ParticlePanel(AppShell):
|
|
|
self.particles.getLocalVelocityFlag())
|
|
self.particles.getLocalVelocityFlag())
|
|
|
self.getVariable('System', 'System Grows Older').set(
|
|
self.getVariable('System', 'System Grows Older').set(
|
|
|
self.particles.getSystemGrowsOlderFlag())
|
|
self.particles.getSystemGrowsOlderFlag())
|
|
|
|
|
+
|
|
|
def setSystemPoolSize(self, value):
|
|
def setSystemPoolSize(self, value):
|
|
|
self.particles.setPoolSize(int(value))
|
|
self.particles.setPoolSize(int(value))
|
|
|
|
|
+
|
|
|
def setSystemBirthRate(self, value):
|
|
def setSystemBirthRate(self, value):
|
|
|
self.particles.setBirthRate(value)
|
|
self.particles.setBirthRate(value)
|
|
|
|
|
+
|
|
|
def setSystemLitterSize(self, value):
|
|
def setSystemLitterSize(self, value):
|
|
|
self.particles.setLitterSize(int(value))
|
|
self.particles.setLitterSize(int(value))
|
|
|
|
|
+
|
|
|
def setSystemLitterSpread(self, value):
|
|
def setSystemLitterSpread(self, value):
|
|
|
self.particles.setLitterSpread(int(value))
|
|
self.particles.setLitterSpread(int(value))
|
|
|
|
|
+
|
|
|
def setSystemLifespan(self, value):
|
|
def setSystemLifespan(self, value):
|
|
|
self.particles.setSystemLifespan(value)
|
|
self.particles.setSystemLifespan(value)
|
|
|
|
|
+
|
|
|
def toggleSystemLocalVelocity(self):
|
|
def toggleSystemLocalVelocity(self):
|
|
|
self.particles.setLocalVelocityFlag(
|
|
self.particles.setLocalVelocityFlag(
|
|
|
self.getVariable('System', 'Render Space Velocities').get())
|
|
self.getVariable('System', 'Render Space Velocities').get())
|
|
|
|
|
+
|
|
|
def toggleSystemGrowsOlder(self):
|
|
def toggleSystemGrowsOlder(self):
|
|
|
self.particles.setSystemGrowsOlderFlag(
|
|
self.particles.setSystemGrowsOlderFlag(
|
|
|
self.getVariable('System', 'System Grows Older').get())
|
|
self.getVariable('System', 'System Grows Older').get())
|
|
|
|
|
+
|
|
|
def setSystemPos(self, pos):
|
|
def setSystemPos(self, pos):
|
|
|
self.particles.nodePath.setPos(Vec3(pos[0], pos[1], pos[2]))
|
|
self.particles.nodePath.setPos(Vec3(pos[0], pos[1], pos[2]))
|
|
|
|
|
+
|
|
|
def setSystemHpr(self, pos):
|
|
def setSystemHpr(self, pos):
|
|
|
self.particles.nodePath.setHpr(Vec3(pos[0], pos[1], pos[2]))
|
|
self.particles.nodePath.setHpr(Vec3(pos[0], pos[1], pos[2]))
|
|
|
|
|
|
|
@@ -1427,28 +1435,39 @@ class ParticlePanel(AppShell):
|
|
|
|
|
|
|
|
def setFactoryLifeSpan(self, value):
|
|
def setFactoryLifeSpan(self, value):
|
|
|
self.particles.factory.setLifespanBase(value)
|
|
self.particles.factory.setLifespanBase(value)
|
|
|
|
|
+
|
|
|
def setFactoryLifeSpanSpread(self, value):
|
|
def setFactoryLifeSpanSpread(self, value):
|
|
|
self.particles.factory.setLifespanSpread(value)
|
|
self.particles.factory.setLifespanSpread(value)
|
|
|
|
|
+
|
|
|
def setFactoryParticleMass(self, value):
|
|
def setFactoryParticleMass(self, value):
|
|
|
self.particles.factory.setMassBase(value)
|
|
self.particles.factory.setMassBase(value)
|
|
|
|
|
+
|
|
|
def setFactoryParticleMassSpread(self, value):
|
|
def setFactoryParticleMassSpread(self, value):
|
|
|
self.particles.factory.setMassSpread(value)
|
|
self.particles.factory.setMassSpread(value)
|
|
|
|
|
+
|
|
|
def setFactoryTerminalVelocity(self, value):
|
|
def setFactoryTerminalVelocity(self, value):
|
|
|
self.particles.factory.setTerminalVelocityBase(value)
|
|
self.particles.factory.setTerminalVelocityBase(value)
|
|
|
|
|
+
|
|
|
def setFactoryTerminalVelocitySpread(self, value):
|
|
def setFactoryTerminalVelocitySpread(self, value):
|
|
|
self.particles.factory.setTerminalVelocitySpread(value)
|
|
self.particles.factory.setTerminalVelocitySpread(value)
|
|
|
# Point Page #
|
|
# Point Page #
|
|
|
# Z Spin Page #
|
|
# Z Spin Page #
|
|
|
|
|
+
|
|
|
def setFactoryZSpinInitialAngle(self, angle):
|
|
def setFactoryZSpinInitialAngle(self, angle):
|
|
|
self.particles.factory.setInitialAngle(angle)
|
|
self.particles.factory.setInitialAngle(angle)
|
|
|
|
|
+
|
|
|
def setFactoryZSpinInitialAngleSpread(self, spread):
|
|
def setFactoryZSpinInitialAngleSpread(self, spread):
|
|
|
self.particles.factory.setInitialAngleSpread(spread)
|
|
self.particles.factory.setInitialAngleSpread(spread)
|
|
|
|
|
+
|
|
|
def setFactoryZSpinFinalAngle(self, angle):
|
|
def setFactoryZSpinFinalAngle(self, angle):
|
|
|
self.particles.factory.setFinalAngle(angle)
|
|
self.particles.factory.setFinalAngle(angle)
|
|
|
|
|
+
|
|
|
def setFactoryZSpinFinalAngleSpread(self, spread):
|
|
def setFactoryZSpinFinalAngleSpread(self, spread):
|
|
|
self.particles.factory.setFinalAngleSpread(spread)
|
|
self.particles.factory.setFinalAngleSpread(spread)
|
|
|
|
|
+
|
|
|
def setFactoryZSpinAngularVelocity(self, vel):
|
|
def setFactoryZSpinAngularVelocity(self, vel):
|
|
|
self.particles.factory.setAngularVelocity(vel)
|
|
self.particles.factory.setAngularVelocity(vel)
|
|
|
|
|
+
|
|
|
def setFactoryZSpinAngularVelocitySpread(self, spread):
|
|
def setFactoryZSpinAngularVelocitySpread(self, spread):
|
|
|
self.particles.factory.setAngularVelocitySpread(spread)
|
|
self.particles.factory.setAngularVelocitySpread(spread)
|
|
|
|
|
|
|
@@ -1539,6 +1558,7 @@ class ParticlePanel(AppShell):
|
|
|
self.getWidget('Tangent Ring Emitter', 'Radius Spread').set(
|
|
self.getWidget('Tangent Ring Emitter', 'Radius Spread').set(
|
|
|
radiusSpread, 0)
|
|
radiusSpread, 0)
|
|
|
# All #
|
|
# All #
|
|
|
|
|
+
|
|
|
def setEmissionType(self, newType = None):
|
|
def setEmissionType(self, newType = None):
|
|
|
if newType:
|
|
if newType:
|
|
|
type = newType
|
|
type = newType
|
|
@@ -1601,57 +1621,76 @@ class ParticlePanel(AppShell):
|
|
|
self.particles.emitter.setMinBound(Point3(point[0],
|
|
self.particles.emitter.setMinBound(Point3(point[0],
|
|
|
point[1],
|
|
point[1],
|
|
|
point[2]))
|
|
point[2]))
|
|
|
|
|
+
|
|
|
def setEmitterBoxPoint2(self, point):
|
|
def setEmitterBoxPoint2(self, point):
|
|
|
self.particles.emitter.setMaxBound(Point3(point[0],
|
|
self.particles.emitter.setMaxBound(Point3(point[0],
|
|
|
point[1],
|
|
point[1],
|
|
|
point[2]))
|
|
point[2]))
|
|
|
# Disc #
|
|
# Disc #
|
|
|
|
|
+
|
|
|
def setEmitterDiscRadius(self, radius):
|
|
def setEmitterDiscRadius(self, radius):
|
|
|
self.particles.emitter.setRadius(radius)
|
|
self.particles.emitter.setRadius(radius)
|
|
|
|
|
+
|
|
|
def setEmitterDiscInnerAngle(self, angle):
|
|
def setEmitterDiscInnerAngle(self, angle):
|
|
|
self.particles.emitter.setInnerAngle(angle)
|
|
self.particles.emitter.setInnerAngle(angle)
|
|
|
|
|
+
|
|
|
def setEmitterDiscInnerVelocity(self, velocity):
|
|
def setEmitterDiscInnerVelocity(self, velocity):
|
|
|
self.particles.emitter.setInnerMagnitude(velocity)
|
|
self.particles.emitter.setInnerMagnitude(velocity)
|
|
|
|
|
+
|
|
|
def setEmitterDiscOuterAngle(self, angle):
|
|
def setEmitterDiscOuterAngle(self, angle):
|
|
|
self.particles.emitter.setOuterAngle(angle)
|
|
self.particles.emitter.setOuterAngle(angle)
|
|
|
|
|
+
|
|
|
def setEmitterDiscOuterVelocity(self, velocity):
|
|
def setEmitterDiscOuterVelocity(self, velocity):
|
|
|
self.particles.emitter.setOuterMagnitude(velocity)
|
|
self.particles.emitter.setOuterMagnitude(velocity)
|
|
|
|
|
+
|
|
|
def toggleEmitterDiscCubicLerping(self):
|
|
def toggleEmitterDiscCubicLerping(self):
|
|
|
self.particles.emitter.setCubicLerping(
|
|
self.particles.emitter.setCubicLerping(
|
|
|
self.getVariable('Disc Emitter', 'Cubic Lerping').get())
|
|
self.getVariable('Disc Emitter', 'Cubic Lerping').get())
|
|
|
# Line #
|
|
# Line #
|
|
|
|
|
+
|
|
|
def setEmitterLinePoint1(self, point):
|
|
def setEmitterLinePoint1(self, point):
|
|
|
self.particles.emitter.setEndpoint1(Point3(point[0],
|
|
self.particles.emitter.setEndpoint1(Point3(point[0],
|
|
|
point[1],
|
|
point[1],
|
|
|
point[2]))
|
|
point[2]))
|
|
|
|
|
+
|
|
|
def setEmitterLinePoint2(self, point):
|
|
def setEmitterLinePoint2(self, point):
|
|
|
self.particles.emitter.setEndpoint2(Point3(point[0],
|
|
self.particles.emitter.setEndpoint2(Point3(point[0],
|
|
|
point[1],
|
|
point[1],
|
|
|
point[2]))
|
|
point[2]))
|
|
|
# Point #
|
|
# Point #
|
|
|
|
|
+
|
|
|
def setEmitterPointPosition(self, pos):
|
|
def setEmitterPointPosition(self, pos):
|
|
|
self.particles.emitter.setLocation(Point3(pos[0], pos[1], pos[2]))
|
|
self.particles.emitter.setLocation(Point3(pos[0], pos[1], pos[2]))
|
|
|
# Rectangle #
|
|
# Rectangle #
|
|
|
|
|
+
|
|
|
def setEmitterRectanglePoint1(self, point):
|
|
def setEmitterRectanglePoint1(self, point):
|
|
|
self.particles.emitter.setMinBound(Point2(point[0], point[1]))
|
|
self.particles.emitter.setMinBound(Point2(point[0], point[1]))
|
|
|
|
|
+
|
|
|
def setEmitterRectanglePoint2(self, point):
|
|
def setEmitterRectanglePoint2(self, point):
|
|
|
self.particles.emitter.setMaxBound(Point2(point[0], point[1]))
|
|
self.particles.emitter.setMaxBound(Point2(point[0], point[1]))
|
|
|
# Ring #
|
|
# Ring #
|
|
|
|
|
+
|
|
|
def setEmitterRingRadius(self, radius):
|
|
def setEmitterRingRadius(self, radius):
|
|
|
self.particles.emitter.setRadius(radius)
|
|
self.particles.emitter.setRadius(radius)
|
|
|
|
|
+
|
|
|
def setEmitterRingRadiusSpread(self, radiusSpread):
|
|
def setEmitterRingRadiusSpread(self, radiusSpread):
|
|
|
self.particles.emitter.setRadiusSpread(radiusSpread)
|
|
self.particles.emitter.setRadiusSpread(radiusSpread)
|
|
|
|
|
+
|
|
|
def setEmitterRingLaunchAngle(self, angle):
|
|
def setEmitterRingLaunchAngle(self, angle):
|
|
|
self.particles.emitter.setAngle(angle)
|
|
self.particles.emitter.setAngle(angle)
|
|
|
# Sphere surface #
|
|
# Sphere surface #
|
|
|
|
|
+
|
|
|
def setEmitterSphereSurfaceRadius(self, radius):
|
|
def setEmitterSphereSurfaceRadius(self, radius):
|
|
|
self.particles.emitter.setRadius(radius)
|
|
self.particles.emitter.setRadius(radius)
|
|
|
# Sphere volume #
|
|
# Sphere volume #
|
|
|
|
|
+
|
|
|
def setEmitterSphereVolumeRadius(self, radius):
|
|
def setEmitterSphereVolumeRadius(self, radius):
|
|
|
self.particles.emitter.setRadius(radius)
|
|
self.particles.emitter.setRadius(radius)
|
|
|
# Tangent ring #
|
|
# Tangent ring #
|
|
|
|
|
+
|
|
|
def setEmitterTangentRingRadius(self, radius):
|
|
def setEmitterTangentRingRadius(self, radius):
|
|
|
self.particles.emitter.setRadius(radius)
|
|
self.particles.emitter.setRadius(radius)
|
|
|
|
|
+
|
|
|
def setEmitterTangentRingRadiusSpread(self, radiusSpread):
|
|
def setEmitterTangentRingRadiusSpread(self, radiusSpread):
|
|
|
self.particles.emitter.setRadiusSpread(radiusSpread)
|
|
self.particles.emitter.setRadiusSpread(radiusSpread)
|
|
|
|
|
|
|
@@ -1849,13 +1888,16 @@ class ParticlePanel(AppShell):
|
|
|
self.particles.renderer.setHeadColor(
|
|
self.particles.renderer.setHeadColor(
|
|
|
Vec4(color[0]/255.0, color[1]/255.0,
|
|
Vec4(color[0]/255.0, color[1]/255.0,
|
|
|
color[2]/255.0, color[3]/255.0))
|
|
color[2]/255.0, color[3]/255.0))
|
|
|
|
|
+
|
|
|
def setRendererLineTailColor(self, color):
|
|
def setRendererLineTailColor(self, color):
|
|
|
self.particles.renderer.setTailColor(
|
|
self.particles.renderer.setTailColor(
|
|
|
Vec4(color[0]/255.0, color[1]/255.0,
|
|
Vec4(color[0]/255.0, color[1]/255.0,
|
|
|
color[2]/255.0, color[3]/255.0))
|
|
color[2]/255.0, color[3]/255.0))
|
|
|
|
|
+
|
|
|
def setRendererLineScaleFactor(self, sf):
|
|
def setRendererLineScaleFactor(self, sf):
|
|
|
self.particles.renderer.setLineScaleFactor(sf)
|
|
self.particles.renderer.setLineScaleFactor(sf)
|
|
|
# Geom #
|
|
# Geom #
|
|
|
|
|
+
|
|
|
def setRendererGeomNode(self, event):
|
|
def setRendererGeomNode(self, event):
|
|
|
node = None
|
|
node = None
|
|
|
nodePath = base.loader.loadModel(self.rendererGeomNode.get())
|
|
nodePath = base.loader.loadModel(self.rendererGeomNode.get())
|
|
@@ -1865,16 +1907,20 @@ class ParticlePanel(AppShell):
|
|
|
self.particles.geomReference = self.rendererGeomNode.get()
|
|
self.particles.geomReference = self.rendererGeomNode.get()
|
|
|
self.particles.renderer.setGeomNode(node)
|
|
self.particles.renderer.setGeomNode(node)
|
|
|
# Point #
|
|
# Point #
|
|
|
|
|
+
|
|
|
def setRendererPointSize(self, size):
|
|
def setRendererPointSize(self, size):
|
|
|
self.particles.renderer.setPointSize(size)
|
|
self.particles.renderer.setPointSize(size)
|
|
|
|
|
+
|
|
|
def setRendererPointStartColor(self, color):
|
|
def setRendererPointStartColor(self, color):
|
|
|
self.particles.renderer.setStartColor(
|
|
self.particles.renderer.setStartColor(
|
|
|
Vec4(color[0]/255.0, color[1]/255.0,
|
|
Vec4(color[0]/255.0, color[1]/255.0,
|
|
|
color[2]/255.0, color[3]/255.0))
|
|
color[2]/255.0, color[3]/255.0))
|
|
|
|
|
+
|
|
|
def setRendererPointEndColor(self, color):
|
|
def setRendererPointEndColor(self, color):
|
|
|
self.particles.renderer.setEndColor(
|
|
self.particles.renderer.setEndColor(
|
|
|
Vec4(color[0]/255.0, color[1]/255.0,
|
|
Vec4(color[0]/255.0, color[1]/255.0,
|
|
|
color[2]/255.0, color[3]/255.0))
|
|
color[2]/255.0, color[3]/255.0))
|
|
|
|
|
+
|
|
|
def rendererPointSelectBlendType(self, blendType):
|
|
def rendererPointSelectBlendType(self, blendType):
|
|
|
if blendType == "PP_ONE_COLOR":
|
|
if blendType == "PP_ONE_COLOR":
|
|
|
bType = PointParticleRenderer.PPONECOLOR
|
|
bType = PointParticleRenderer.PPONECOLOR
|
|
@@ -1883,6 +1929,7 @@ class ParticlePanel(AppShell):
|
|
|
elif blendType == "PP_BLEND_VEL":
|
|
elif blendType == "PP_BLEND_VEL":
|
|
|
bType = PointParticleRenderer.PPBLENDVEL
|
|
bType = PointParticleRenderer.PPBLENDVEL
|
|
|
self.particles.renderer.setBlendType(bType)
|
|
self.particles.renderer.setBlendType(bType)
|
|
|
|
|
+
|
|
|
def rendererPointSelectBlendMethod(self, blendMethod):
|
|
def rendererPointSelectBlendMethod(self, blendMethod):
|
|
|
if blendMethod == "PP_NO_BLEND":
|
|
if blendMethod == "PP_NO_BLEND":
|
|
|
bMethod = BaseParticleRenderer.PPNOBLEND
|
|
bMethod = BaseParticleRenderer.PPNOBLEND
|
|
@@ -1892,18 +1939,23 @@ class ParticlePanel(AppShell):
|
|
|
bMethod = BaseParticleRenderer.PPBLENDCUBIC
|
|
bMethod = BaseParticleRenderer.PPBLENDCUBIC
|
|
|
self.particles.renderer.setBlendMethod(bMethod)
|
|
self.particles.renderer.setBlendMethod(bMethod)
|
|
|
# Sparkle #
|
|
# Sparkle #
|
|
|
|
|
+
|
|
|
def setRendererSparkleCenterColor(self, color):
|
|
def setRendererSparkleCenterColor(self, color):
|
|
|
self.particles.renderer.setCenterColor(
|
|
self.particles.renderer.setCenterColor(
|
|
|
Vec4(color[0]/255.0, color[1]/255.0,
|
|
Vec4(color[0]/255.0, color[1]/255.0,
|
|
|
color[2]/255.0, color[3]/255.0))
|
|
color[2]/255.0, color[3]/255.0))
|
|
|
|
|
+
|
|
|
def setRendererSparkleEdgeColor(self, color):
|
|
def setRendererSparkleEdgeColor(self, color):
|
|
|
self.particles.renderer.setEdgeColor(
|
|
self.particles.renderer.setEdgeColor(
|
|
|
Vec4(color[0]/255.0, color[1]/255.0,
|
|
Vec4(color[0]/255.0, color[1]/255.0,
|
|
|
color[2]/255.0, color[3]/255.0))
|
|
color[2]/255.0, color[3]/255.0))
|
|
|
|
|
+
|
|
|
def setRendererSparkleBirthRadius(self, radius):
|
|
def setRendererSparkleBirthRadius(self, radius):
|
|
|
self.particles.renderer.setBirthRadius(radius)
|
|
self.particles.renderer.setBirthRadius(radius)
|
|
|
|
|
+
|
|
|
def setRendererSparkleDeathRadius(self, radius):
|
|
def setRendererSparkleDeathRadius(self, radius):
|
|
|
self.particles.renderer.setDeathRadius(radius)
|
|
self.particles.renderer.setDeathRadius(radius)
|
|
|
|
|
+
|
|
|
def setRendererSparkleLifeScale(self, lifeScaleMethod):
|
|
def setRendererSparkleLifeScale(self, lifeScaleMethod):
|
|
|
if lifeScaleMethod == 'SP_NO_SCALE':
|
|
if lifeScaleMethod == 'SP_NO_SCALE':
|
|
|
lScale = SparkleParticleRenderer.SPNOSCALE
|
|
lScale = SparkleParticleRenderer.SPNOSCALE
|
|
@@ -1911,6 +1963,7 @@ class ParticlePanel(AppShell):
|
|
|
lScale = SparkleParticleRenderer.SPSCALE
|
|
lScale = SparkleParticleRenderer.SPSCALE
|
|
|
self.particles.renderer.setLifeScale(lScale)
|
|
self.particles.renderer.setLifeScale(lScale)
|
|
|
# Sprite #
|
|
# Sprite #
|
|
|
|
|
+
|
|
|
def setSpriteSourceType(self):
|
|
def setSpriteSourceType(self):
|
|
|
if self.rendererSpriteSourceType.get() == 0:
|
|
if self.rendererSpriteSourceType.get() == 0:
|
|
|
self.rendererSpriteTextureEntry['state'] = 'normal'
|
|
self.rendererSpriteTextureEntry['state'] = 'normal'
|
|
@@ -1929,9 +1982,11 @@ class ParticlePanel(AppShell):
|
|
|
|
|
|
|
|
def setRendererSpriteAnimationFrameRate(self, rate):
|
|
def setRendererSpriteAnimationFrameRate(self, rate):
|
|
|
self.particles.renderer.setAnimateFramesRate(rate)
|
|
self.particles.renderer.setAnimateFramesRate(rate)
|
|
|
|
|
+
|
|
|
def setRendererSpriteAnimationEnable(self):
|
|
def setRendererSpriteAnimationEnable(self):
|
|
|
self.particles.renderer.setAnimateFramesEnable(
|
|
self.particles.renderer.setAnimateFramesEnable(
|
|
|
self.getVariable('Sprite Renderer','Enable Animation').get())
|
|
self.getVariable('Sprite Renderer','Enable Animation').get())
|
|
|
|
|
+
|
|
|
def addRendererSpriteAnimationTexture(self):
|
|
def addRendererSpriteAnimationTexture(self):
|
|
|
ren = self.particles.getRenderer()
|
|
ren = self.particles.getRenderer()
|
|
|
parent = self.rendererSpriteAnimationFrame
|
|
parent = self.rendererSpriteAnimationFrame
|
|
@@ -1953,6 +2008,7 @@ class ParticlePanel(AppShell):
|
|
|
self.rendererSpriteAnimationWidgetList.append(
|
|
self.rendererSpriteAnimationWidgetList.append(
|
|
|
self.createSpriteAnimationTextureWidget(parent, anim, repr(frameNum)))
|
|
self.createSpriteAnimationTextureWidget(parent, anim, repr(frameNum)))
|
|
|
parent.pack(fill=tk.BOTH, expand=1)
|
|
parent.pack(fill=tk.BOTH, expand=1)
|
|
|
|
|
+
|
|
|
def addRendererSpriteAnimationFromNode(self):
|
|
def addRendererSpriteAnimationFromNode(self):
|
|
|
ren = self.particles.getRenderer()
|
|
ren = self.particles.getRenderer()
|
|
|
parent = self.rendererSpriteAnimationFrame
|
|
parent = self.rendererSpriteAnimationFrame
|
|
@@ -1978,9 +2034,11 @@ class ParticlePanel(AppShell):
|
|
|
def toggleRendererSpriteXScale(self):
|
|
def toggleRendererSpriteXScale(self):
|
|
|
self.particles.renderer.setXScaleFlag(
|
|
self.particles.renderer.setXScaleFlag(
|
|
|
self.getVariable('Sprite Renderer', 'X Scale').get())
|
|
self.getVariable('Sprite Renderer', 'X Scale').get())
|
|
|
|
|
+
|
|
|
def toggleRendererSpriteYScale(self):
|
|
def toggleRendererSpriteYScale(self):
|
|
|
self.particles.renderer.setYScaleFlag(
|
|
self.particles.renderer.setYScaleFlag(
|
|
|
self.getVariable('Sprite Renderer', 'Y Scale').get())
|
|
self.getVariable('Sprite Renderer', 'Y Scale').get())
|
|
|
|
|
+
|
|
|
def toggleRendererSpriteAnimAngle(self):
|
|
def toggleRendererSpriteAnimAngle(self):
|
|
|
self.particles.renderer.setAnimAngleFlag(
|
|
self.particles.renderer.setAnimAngleFlag(
|
|
|
self.getVariable('Sprite Renderer', 'Anim Angle').get())
|
|
self.getVariable('Sprite Renderer', 'Anim Angle').get())
|
|
@@ -1991,14 +2049,19 @@ class ParticlePanel(AppShell):
|
|
|
|
|
|
|
|
def setRendererSpriteInitialXScale(self, xScale):
|
|
def setRendererSpriteInitialXScale(self, xScale):
|
|
|
self.particles.renderer.setInitialXScale(xScale)
|
|
self.particles.renderer.setInitialXScale(xScale)
|
|
|
|
|
+
|
|
|
def setRendererSpriteFinalXScale(self, xScale):
|
|
def setRendererSpriteFinalXScale(self, xScale):
|
|
|
self.particles.renderer.setFinalXScale(xScale)
|
|
self.particles.renderer.setFinalXScale(xScale)
|
|
|
|
|
+
|
|
|
def setRendererSpriteInitialYScale(self, yScale):
|
|
def setRendererSpriteInitialYScale(self, yScale):
|
|
|
self.particles.renderer.setInitialYScale(yScale)
|
|
self.particles.renderer.setInitialYScale(yScale)
|
|
|
|
|
+
|
|
|
def setRendererSpriteFinalYScale(self, yScale):
|
|
def setRendererSpriteFinalYScale(self, yScale):
|
|
|
self.particles.renderer.setFinalYScale(yScale)
|
|
self.particles.renderer.setFinalYScale(yScale)
|
|
|
|
|
+
|
|
|
def setRendererSpriteNonAnimatedTheta(self, theta):
|
|
def setRendererSpriteNonAnimatedTheta(self, theta):
|
|
|
self.particles.renderer.setNonanimatedTheta(theta)
|
|
self.particles.renderer.setNonanimatedTheta(theta)
|
|
|
|
|
+
|
|
|
def setRendererSpriteBlendMethod(self, blendMethod):
|
|
def setRendererSpriteBlendMethod(self, blendMethod):
|
|
|
if blendMethod == 'PP_NO_BLEND':
|
|
if blendMethod == 'PP_NO_BLEND':
|
|
|
bMethod = BaseParticleRenderer.PPNOBLEND
|
|
bMethod = BaseParticleRenderer.PPNOBLEND
|
|
@@ -2008,9 +2071,11 @@ class ParticlePanel(AppShell):
|
|
|
bMethod = BaseParticleRenderer.PPBLENDCUBIC
|
|
bMethod = BaseParticleRenderer.PPBLENDCUBIC
|
|
|
else:
|
|
else:
|
|
|
bMethod = BaseParticleRenderer.PPNOBLEND
|
|
bMethod = BaseParticleRenderer.PPNOBLEND
|
|
|
|
|
+
|
|
|
def toggleRendererSpriteAlphaDisable(self):
|
|
def toggleRendererSpriteAlphaDisable(self):
|
|
|
self.particles.renderer.setAlphaDisable(
|
|
self.particles.renderer.setAlphaDisable(
|
|
|
self.getVariable('Sprite Renderer', 'Alpha Disable').get())
|
|
self.getVariable('Sprite Renderer', 'Alpha Disable').get())
|
|
|
|
|
+
|
|
|
def setRendererColorBlendAttrib(self, rendererName, blendMethodStr, incomingOperandStr, fbufferOperandStr):
|
|
def setRendererColorBlendAttrib(self, rendererName, blendMethodStr, incomingOperandStr, fbufferOperandStr):
|
|
|
self.particles.getRenderer().setColorBlendMode(getattr(ColorBlendAttrib, blendMethodStr),
|
|
self.particles.getRenderer().setColorBlendMode(getattr(ColorBlendAttrib, blendMethodStr),
|
|
|
getattr(ColorBlendAttrib, incomingOperandStr),
|
|
getattr(ColorBlendAttrib, incomingOperandStr),
|
|
@@ -2024,48 +2089,56 @@ class ParticlePanel(AppShell):
|
|
|
self.getWidget(rendererName,'Fbuffer Op.').pack_forget()
|
|
self.getWidget(rendererName,'Fbuffer Op.').pack_forget()
|
|
|
|
|
|
|
|
self.updateRendererWidgets()
|
|
self.updateRendererWidgets()
|
|
|
|
|
+
|
|
|
def setRendererSpriteColorBlendMethod(self, blendMethod):
|
|
def setRendererSpriteColorBlendMethod(self, blendMethod):
|
|
|
blendMethodStr = blendMethod
|
|
blendMethodStr = blendMethod
|
|
|
incomingOperandStr = self.getVariable('Sprite Renderer','Incoming Op.').get()
|
|
incomingOperandStr = self.getVariable('Sprite Renderer','Incoming Op.').get()
|
|
|
fbufferOperandStr = self.getVariable('Sprite Renderer','Fbuffer Op.').get()
|
|
fbufferOperandStr = self.getVariable('Sprite Renderer','Fbuffer Op.').get()
|
|
|
|
|
|
|
|
self.setRendererColorBlendAttrib('Sprite Renderer', blendMethodStr, incomingOperandStr, fbufferOperandStr)
|
|
self.setRendererColorBlendAttrib('Sprite Renderer', blendMethodStr, incomingOperandStr, fbufferOperandStr)
|
|
|
|
|
+
|
|
|
def setRendererSpriteColorBlendIncomingOperand(self, operand):
|
|
def setRendererSpriteColorBlendIncomingOperand(self, operand):
|
|
|
blendMethodStr = self.getVariable('Sprite Renderer','Color Blend').get()
|
|
blendMethodStr = self.getVariable('Sprite Renderer','Color Blend').get()
|
|
|
incomingOperandStr = operand
|
|
incomingOperandStr = operand
|
|
|
fbufferOperandStr = self.getVariable('Sprite Renderer','Fbuffer Op.').get()
|
|
fbufferOperandStr = self.getVariable('Sprite Renderer','Fbuffer Op.').get()
|
|
|
|
|
|
|
|
self.setRendererColorBlendAttrib('Sprite Renderer', blendMethodStr, incomingOperandStr, fbufferOperandStr)
|
|
self.setRendererColorBlendAttrib('Sprite Renderer', blendMethodStr, incomingOperandStr, fbufferOperandStr)
|
|
|
|
|
+
|
|
|
def setRendererSpriteColorBlendFbufferOperand(self, operand):
|
|
def setRendererSpriteColorBlendFbufferOperand(self, operand):
|
|
|
blendMethodStr = self.getVariable('Sprite Renderer','Color Blend').get()
|
|
blendMethodStr = self.getVariable('Sprite Renderer','Color Blend').get()
|
|
|
incomingOperandStr = self.getVariable('Sprite Renderer','Incoming Op.').get()
|
|
incomingOperandStr = self.getVariable('Sprite Renderer','Incoming Op.').get()
|
|
|
fbufferOperandStr = operand
|
|
fbufferOperandStr = operand
|
|
|
self.setRendererColorBlendAttrib('Sprite Renderer', blendMethodStr, incomingOperandStr, fbufferOperandStr)
|
|
self.setRendererColorBlendAttrib('Sprite Renderer', blendMethodStr, incomingOperandStr, fbufferOperandStr)
|
|
|
|
|
|
|
|
-
|
|
|
|
|
# GeomParticleRenderer Functionality
|
|
# GeomParticleRenderer Functionality
|
|
|
|
|
+
|
|
|
def toggleRendererGeomXScale(self):
|
|
def toggleRendererGeomXScale(self):
|
|
|
self.particles.renderer.setXScaleFlag(
|
|
self.particles.renderer.setXScaleFlag(
|
|
|
self.getVariable('Geom Renderer', 'X Scale').get())
|
|
self.getVariable('Geom Renderer', 'X Scale').get())
|
|
|
|
|
+
|
|
|
def toggleRendererGeomYScale(self):
|
|
def toggleRendererGeomYScale(self):
|
|
|
self.particles.renderer.setYScaleFlag(
|
|
self.particles.renderer.setYScaleFlag(
|
|
|
self.getVariable('Geom Renderer', 'Y Scale').get())
|
|
self.getVariable('Geom Renderer', 'Y Scale').get())
|
|
|
|
|
+
|
|
|
def toggleRendererGeomZScale(self):
|
|
def toggleRendererGeomZScale(self):
|
|
|
self.particles.renderer.setZScaleFlag(
|
|
self.particles.renderer.setZScaleFlag(
|
|
|
self.getVariable('Geom Renderer', 'Z Scale').get())
|
|
self.getVariable('Geom Renderer', 'Z Scale').get())
|
|
|
|
|
|
|
|
def setRendererGeomInitialXScale(self, xScale):
|
|
def setRendererGeomInitialXScale(self, xScale):
|
|
|
self.particles.renderer.setInitialXScale(xScale)
|
|
self.particles.renderer.setInitialXScale(xScale)
|
|
|
|
|
+
|
|
|
def setRendererGeomFinalXScale(self, xScale):
|
|
def setRendererGeomFinalXScale(self, xScale):
|
|
|
self.particles.renderer.setFinalXScale(xScale)
|
|
self.particles.renderer.setFinalXScale(xScale)
|
|
|
|
|
|
|
|
def setRendererGeomInitialYScale(self, yScale):
|
|
def setRendererGeomInitialYScale(self, yScale):
|
|
|
self.particles.renderer.setInitialYScale(yScale)
|
|
self.particles.renderer.setInitialYScale(yScale)
|
|
|
|
|
+
|
|
|
def setRendererGeomFinalYScale(self, yScale):
|
|
def setRendererGeomFinalYScale(self, yScale):
|
|
|
self.particles.renderer.setFinalYScale(yScale)
|
|
self.particles.renderer.setFinalYScale(yScale)
|
|
|
|
|
|
|
|
def setRendererGeomInitialZScale(self, zScale):
|
|
def setRendererGeomInitialZScale(self, zScale):
|
|
|
self.particles.renderer.setInitialZScale(zScale)
|
|
self.particles.renderer.setInitialZScale(zScale)
|
|
|
|
|
+
|
|
|
def setRendererGeomFinalZScale(self, zScale):
|
|
def setRendererGeomFinalZScale(self, zScale):
|
|
|
self.particles.renderer.setFinalZScale(zScale)
|
|
self.particles.renderer.setFinalZScale(zScale)
|
|
|
|
|
|
|
@@ -2087,7 +2160,6 @@ class ParticlePanel(AppShell):
|
|
|
fbufferOperandStr = operand
|
|
fbufferOperandStr = operand
|
|
|
self.setRendererColorBlendAttrib('Geom Renderer', blendMethodStr, incomingOperandStr, fbufferOperandStr)
|
|
self.setRendererColorBlendAttrib('Geom Renderer', blendMethodStr, incomingOperandStr, fbufferOperandStr)
|
|
|
|
|
|
|
|
-
|
|
|
|
|
def addConstantInterpolationSegment(self, id = None):
|
|
def addConstantInterpolationSegment(self, id = None):
|
|
|
ren = self.particles.getRenderer()
|
|
ren = self.particles.getRenderer()
|
|
|
cim = ren.getColorInterpolationManager()
|
|
cim = ren.getColorInterpolationManager()
|
|
@@ -2187,17 +2259,22 @@ class ParticlePanel(AppShell):
|
|
|
def createInterpolationSegmentFrame(self, parent, segName, seg):
|
|
def createInterpolationSegmentFrame(self, parent, segName, seg):
|
|
|
frame = tk.Frame(parent, relief = tk.RAISED, borderwidth = 2)
|
|
frame = tk.Frame(parent, relief = tk.RAISED, borderwidth = 2)
|
|
|
lFrame = tk.Frame(frame, relief = tk.FLAT)
|
|
lFrame = tk.Frame(frame, relief = tk.FLAT)
|
|
|
|
|
+
|
|
|
def removeInterpolationSegmentFrame(s = self, seg = seg, fr = frame):
|
|
def removeInterpolationSegmentFrame(s = self, seg = seg, fr = frame):
|
|
|
s.particles.getRenderer().getColorInterpolationManager().clearSegment(seg.getId())
|
|
s.particles.getRenderer().getColorInterpolationManager().clearSegment(seg.getId())
|
|
|
fr.pack_forget()
|
|
fr.pack_forget()
|
|
|
|
|
+
|
|
|
def setSegEnabled(s=self, n=segName):
|
|
def setSegEnabled(s=self, n=segName):
|
|
|
enabled = s.getVariable('Sprite Renderer', n+' Enabled')
|
|
enabled = s.getVariable('Sprite Renderer', n+' Enabled')
|
|
|
seg.setEnabled(enabled.get())
|
|
seg.setEnabled(enabled.get())
|
|
|
|
|
+
|
|
|
def setIsModulated(s=self, n=segName):
|
|
def setIsModulated(s=self, n=segName):
|
|
|
modulated = s.getVariable('Sprite Renderer', n+' isModulated')
|
|
modulated = s.getVariable('Sprite Renderer', n+' isModulated')
|
|
|
seg.setIsModulated(modulated.get())
|
|
seg.setIsModulated(modulated.get())
|
|
|
|
|
+
|
|
|
def setSegBegin(time):
|
|
def setSegBegin(time):
|
|
|
seg.setTimeBegin(time)
|
|
seg.setTimeBegin(time)
|
|
|
|
|
+
|
|
|
def setSegEnd(time):
|
|
def setSegEnd(time):
|
|
|
seg.setTimeEnd(time)
|
|
seg.setTimeEnd(time)
|
|
|
tk.Button(lFrame, text = 'X',
|
|
tk.Button(lFrame, text = 'X',
|
|
@@ -2236,6 +2313,7 @@ class ParticlePanel(AppShell):
|
|
|
|
|
|
|
|
def createConstantInterpolationSegmentWidget(self, parent, segName, segment):
|
|
def createConstantInterpolationSegmentWidget(self, parent, segName, segment):
|
|
|
fun = segment.getFunction()
|
|
fun = segment.getFunction()
|
|
|
|
|
+
|
|
|
def setSegColorA(color):
|
|
def setSegColorA(color):
|
|
|
fun.setColorA(
|
|
fun.setColorA(
|
|
|
Vec4(color[0]/255.0, color[1]/255.0,
|
|
Vec4(color[0]/255.0, color[1]/255.0,
|
|
@@ -2255,10 +2333,12 @@ class ParticlePanel(AppShell):
|
|
|
|
|
|
|
|
def createLinearInterpolationSegmentWidget(self, parent, segName, segment):
|
|
def createLinearInterpolationSegmentWidget(self, parent, segName, segment):
|
|
|
fun = segment.getFunction()
|
|
fun = segment.getFunction()
|
|
|
|
|
+
|
|
|
def setSegColorA(color):
|
|
def setSegColorA(color):
|
|
|
fun.setColorA(
|
|
fun.setColorA(
|
|
|
Vec4(color[0]/255.0, color[1]/255.0,
|
|
Vec4(color[0]/255.0, color[1]/255.0,
|
|
|
color[2]/255.0, color[3]/255.0))
|
|
color[2]/255.0, color[3]/255.0))
|
|
|
|
|
+
|
|
|
def setSegColorB(color):
|
|
def setSegColorB(color):
|
|
|
fun.setColorB(
|
|
fun.setColorB(
|
|
|
Vec4(color[0]/255.0, color[1]/255.0,
|
|
Vec4(color[0]/255.0, color[1]/255.0,
|
|
@@ -2284,16 +2364,20 @@ class ParticlePanel(AppShell):
|
|
|
|
|
|
|
|
def createStepwaveInterpolationSegmentWidget(self, parent, segName, segment):
|
|
def createStepwaveInterpolationSegmentWidget(self, parent, segName, segment):
|
|
|
fun = segment.getFunction()
|
|
fun = segment.getFunction()
|
|
|
|
|
+
|
|
|
def setColorA(color):
|
|
def setColorA(color):
|
|
|
fun.setColorA(
|
|
fun.setColorA(
|
|
|
Vec4(color[0]/255.0, color[1]/255.0,
|
|
Vec4(color[0]/255.0, color[1]/255.0,
|
|
|
color[2]/255.0, color[3]/255.0))
|
|
color[2]/255.0, color[3]/255.0))
|
|
|
|
|
+
|
|
|
def setColorB(color):
|
|
def setColorB(color):
|
|
|
fun.setColorB(
|
|
fun.setColorB(
|
|
|
Vec4(color[0]/255.0, color[1]/255.0,
|
|
Vec4(color[0]/255.0, color[1]/255.0,
|
|
|
color[2]/255.0, color[3]/255.0))
|
|
color[2]/255.0, color[3]/255.0))
|
|
|
|
|
+
|
|
|
def setWidthA(width):
|
|
def setWidthA(width):
|
|
|
fun.setWidthA(width)
|
|
fun.setWidthA(width)
|
|
|
|
|
+
|
|
|
def setWidthB(width):
|
|
def setWidthB(width):
|
|
|
fun.setWidthB(width)
|
|
fun.setWidthB(width)
|
|
|
|
|
|
|
@@ -2327,14 +2411,17 @@ class ParticlePanel(AppShell):
|
|
|
|
|
|
|
|
def createSinusoidInterpolationSegmentWidget(self, parent, segName, segment):
|
|
def createSinusoidInterpolationSegmentWidget(self, parent, segName, segment):
|
|
|
fun = segment.getFunction()
|
|
fun = segment.getFunction()
|
|
|
|
|
+
|
|
|
def setColorA(color):
|
|
def setColorA(color):
|
|
|
fun.setColorA(
|
|
fun.setColorA(
|
|
|
Vec4(color[0]/255.0, color[1]/255.0,
|
|
Vec4(color[0]/255.0, color[1]/255.0,
|
|
|
color[2]/255.0, color[3]/255.0))
|
|
color[2]/255.0, color[3]/255.0))
|
|
|
|
|
+
|
|
|
def setColorB(color):
|
|
def setColorB(color):
|
|
|
fun.setColorB(
|
|
fun.setColorB(
|
|
|
Vec4(color[0]/255.0, color[1]/255.0,
|
|
Vec4(color[0]/255.0, color[1]/255.0,
|
|
|
color[2]/255.0, color[3]/255.0))
|
|
color[2]/255.0, color[3]/255.0))
|
|
|
|
|
+
|
|
|
def setPeriod(period):
|
|
def setPeriod(period):
|
|
|
fun.setPeriod(period)
|
|
fun.setPeriod(period)
|
|
|
|
|
|
|
@@ -2543,18 +2630,25 @@ class ParticlePanel(AppShell):
|
|
|
|
|
|
|
|
def addLinearVectorForce(self):
|
|
def addLinearVectorForce(self):
|
|
|
self.addForce(LinearVectorForce())
|
|
self.addForce(LinearVectorForce())
|
|
|
|
|
+
|
|
|
def addLinearFrictionForce(self):
|
|
def addLinearFrictionForce(self):
|
|
|
self.addForce(LinearFrictionForce())
|
|
self.addForce(LinearFrictionForce())
|
|
|
|
|
+
|
|
|
def addLinearJitterForce(self):
|
|
def addLinearJitterForce(self):
|
|
|
self.addForce(LinearJitterForce())
|
|
self.addForce(LinearJitterForce())
|
|
|
|
|
+
|
|
|
def addLinearNoiseForce(self):
|
|
def addLinearNoiseForce(self):
|
|
|
self.addForce(LinearNoiseForce())
|
|
self.addForce(LinearNoiseForce())
|
|
|
|
|
+
|
|
|
def addLinearSinkForce(self):
|
|
def addLinearSinkForce(self):
|
|
|
self.addForce(LinearSinkForce())
|
|
self.addForce(LinearSinkForce())
|
|
|
|
|
+
|
|
|
def addLinearSourceForce(self):
|
|
def addLinearSourceForce(self):
|
|
|
self.addForce(LinearSourceForce())
|
|
self.addForce(LinearSourceForce())
|
|
|
|
|
+
|
|
|
def addLinearCylinderVortexForce(self):
|
|
def addLinearCylinderVortexForce(self):
|
|
|
self.addForce(LinearCylinderVortexForce())
|
|
self.addForce(LinearCylinderVortexForce())
|
|
|
|
|
+
|
|
|
def addLinearUserDefinedForce(self):
|
|
def addLinearUserDefinedForce(self):
|
|
|
self.addForce(LinearUserDefinedForce())
|
|
self.addForce(LinearUserDefinedForce())
|
|
|
|
|
|
|
@@ -2650,6 +2744,7 @@ class ParticlePanel(AppShell):
|
|
|
def createForceFrame(self, forcePage, forceName, force):
|
|
def createForceFrame(self, forcePage, forceName, force):
|
|
|
frame = tk.Frame(forcePage, relief = tk.RAISED, borderwidth = 2)
|
|
frame = tk.Frame(forcePage, relief = tk.RAISED, borderwidth = 2)
|
|
|
lFrame = tk.Frame(frame, relief = tk.FLAT)
|
|
lFrame = tk.Frame(frame, relief = tk.FLAT)
|
|
|
|
|
+
|
|
|
def removeForce(s = self, f = force, fr = frame):
|
|
def removeForce(s = self, f = force, fr = frame):
|
|
|
s.forceGroup.removeForce(f)
|
|
s.forceGroup.removeForce(f)
|
|
|
fr.pack_forget()
|
|
fr.pack_forget()
|
|
@@ -2667,9 +2762,11 @@ class ParticlePanel(AppShell):
|
|
|
def createLinearForceWidgets(self, frame, pageName, forceName, force):
|
|
def createLinearForceWidgets(self, frame, pageName, forceName, force):
|
|
|
def setAmplitude(amp, f = force):
|
|
def setAmplitude(amp, f = force):
|
|
|
f.setAmplitude(amp)
|
|
f.setAmplitude(amp)
|
|
|
|
|
+
|
|
|
def toggleMassDependent(s=self, f=force, p=pageName, n=forceName):
|
|
def toggleMassDependent(s=self, f=force, p=pageName, n=forceName):
|
|
|
v = s.getVariable(p, n+' Mass Dependent')
|
|
v = s.getVariable(p, n+' Mass Dependent')
|
|
|
f.setMassDependent(v.get())
|
|
f.setMassDependent(v.get())
|
|
|
|
|
+
|
|
|
def setVectorMasks(s=self, f=force, p=pageName, n=forceName):
|
|
def setVectorMasks(s=self, f=force, p=pageName, n=forceName):
|
|
|
xMask = s.getVariable(p, n+' Mask X').get()
|
|
xMask = s.getVariable(p, n+' Mask X').get()
|
|
|
yMask = s.getVariable(p, n+' Mask Y').get()
|
|
yMask = s.getVariable(p, n+' Mask Y').get()
|
|
@@ -2698,6 +2795,7 @@ class ParticlePanel(AppShell):
|
|
|
|
|
|
|
|
def createForceActiveWidget(self, frame, pageName, forceName, force):
|
|
def createForceActiveWidget(self, frame, pageName, forceName, force):
|
|
|
cbName = forceName + ' Active'
|
|
cbName = forceName + ' Active'
|
|
|
|
|
+
|
|
|
def toggle(s = self, f = force, p = pageName, n = cbName):
|
|
def toggle(s = self, f = force, p = pageName, n = cbName):
|
|
|
s.toggleForce(f, p, n)
|
|
s.toggleForce(f, p, n)
|
|
|
self.createCheckbutton(frame, pageName, cbName,
|
|
self.createCheckbutton(frame, pageName, cbName,
|
|
@@ -2741,10 +2839,13 @@ class ParticlePanel(AppShell):
|
|
|
def createLinearCylinderVortexForceWidget(self, forcePage, pageName,
|
|
def createLinearCylinderVortexForceWidget(self, forcePage, pageName,
|
|
|
count, force):
|
|
count, force):
|
|
|
forceName = 'Vortex Force-' + repr(count)
|
|
forceName = 'Vortex Force-' + repr(count)
|
|
|
|
|
+
|
|
|
def setCoef(coef, f = force):
|
|
def setCoef(coef, f = force):
|
|
|
f.setCoef(coef)
|
|
f.setCoef(coef)
|
|
|
|
|
+
|
|
|
def setLength(length, f = force):
|
|
def setLength(length, f = force):
|
|
|
f.setLength(length)
|
|
f.setLength(length)
|
|
|
|
|
+
|
|
|
def setRadius(radius, f = force):
|
|
def setRadius(radius, f = force):
|
|
|
f.setRadius(radius)
|
|
f.setRadius(radius)
|
|
|
frame = self.createForceFrame(forcePage, forceName, force)
|
|
frame = self.createForceFrame(forcePage, forceName, force)
|
|
@@ -2775,8 +2876,10 @@ class ParticlePanel(AppShell):
|
|
|
if type == 'FT_ONE_OVER_R_CUBED':
|
|
if type == 'FT_ONE_OVER_R_CUBED':
|
|
|
#f.setFalloffType(LinearDistanceForce.FTONEOVERRCUBED)
|
|
#f.setFalloffType(LinearDistanceForce.FTONEOVERRCUBED)
|
|
|
f.setFalloffType(2)
|
|
f.setFalloffType(2)
|
|
|
|
|
+
|
|
|
def setForceCenter(vec, f = force):
|
|
def setForceCenter(vec, f = force):
|
|
|
f.setForceCenter(Point3(vec[0], vec[1], vec[2]))
|
|
f.setForceCenter(Point3(vec[0], vec[1], vec[2]))
|
|
|
|
|
+
|
|
|
def setRadius(radius, f = force):
|
|
def setRadius(radius, f = force):
|
|
|
f.setRadius(radius)
|
|
f.setRadius(radius)
|
|
|
forceName = type + ' Force-' + repr(count)
|
|
forceName = type + ' Force-' + repr(count)
|
|
@@ -2813,12 +2916,12 @@ class ParticlePanel(AppShell):
|
|
|
|
|
|
|
|
######################################################################
|
|
######################################################################
|
|
|
|
|
|
|
|
|
|
+
|
|
|
# Create demo in root window for testing.
|
|
# Create demo in root window for testing.
|
|
|
if __name__ == '__main__':
|
|
if __name__ == '__main__':
|
|
|
-
|
|
|
|
|
try:
|
|
try:
|
|
|
base
|
|
base
|
|
|
- except:
|
|
|
|
|
|
|
+ except NameError:
|
|
|
from direct.showbase.ShowBase import ShowBase
|
|
from direct.showbase.ShowBase import ShowBase
|
|
|
base = ShowBase()
|
|
base = ShowBase()
|
|
|
|
|
|