def test_StaticEmitter_discrete(self):
from lepton import Particle, ParticleGroup
from lepton.emitter import StaticEmitter
masses = (0.5, 2.0, 8.0)
positions = ((1.0, 1.0, 1.0), (10.0, 20.0, 30.0), (-100.0, 0.0, 0.0))
velocities = ((1, 1, 0), )
colors = ((1.0, 1.0, 1.0, 0.5), (1.0, 0, 0, 1.0), (0, 1.0, 0, 1.0))
emitter = StaticEmitter(rate=1,
mass=masses,
position=positions,
velocity=velocities,
color=colors)
group = ParticleGroup()
emitter(3, group)
group.update(0)
self.assertEqual(len(group), 3)
for particle in group:
self.failUnless(particle.mass in masses, (particle.mass, masses))
self.failUnless(
tuple(particle.position) in positions,
(particle.position, positions))
self.failUnless(
tuple(particle.color) in colors, (particle.color, colors))
self.assertVector(particle.velocity, (1, 1, 0))
def test_PerParticleEmitter_template(self):
from lepton import Particle, ParticleGroup
from lepton.emitter import PerParticleEmitter
source_group = ParticleGroup()
source_group.new(Particle(position=(1, 1, 1)))
source_group.new(Particle(position=(2, 2, 2)))
source_group.update(0)
emitter = PerParticleEmitter(source_group,
rate=1,
template=Particle(position=(1.0, 1.0,
1.0),
velocity=(0, 5, 2),
color=(0.5, 0.5, 0.5,
1.0)))
group = ParticleGroup()
count = emitter(1, group)
group.update(0)
self.assertEqual(count, len(source_group))
self.assertEqual(len(group), len(source_group))
particle = list(group)[0]
self.assertVector(particle.position, (1, 1, 1))
self.assertVector(particle.velocity, (0, 5, 2))
self.assertColor(particle.color, (0.5, 0.5, 0.5, 1.0))
particle = list(group)[1]
self.assertVector(particle.position, (2, 2, 2))
self.assertVector(particle.velocity, (0, 5, 2))
self.assertColor(particle.color, (0.5, 0.5, 0.5, 1.0))
def test_group_system(self):
import lepton
from lepton import ParticleGroup
# By default the group should be added to the global system
group = ParticleGroup()
self.failUnless(group in lepton.default_system)
lepton.default_system.add_group(group)
# We should be able to override the system by argument
test_system = TestSystem()
group = ParticleGroup(system=test_system)
self.failUnless(group in test_system)
self.failIf(group in lepton.default_system)
# If the global system is overridden, the group should respect that
original_system = lepton.default_system
try:
lepton.default_system = test_system
group = ParticleGroup()
self.failUnless(group in test_system)
finally:
lepton.default_system = original_system
# If None is specified for system, group is not added
group = ParticleGroup(system=None)
self.failIf(group in lepton.default_system)
self.failIf(group in test_system)
def _make_group(self):
from lepton import Particle, ParticleGroup
g = ParticleGroup()
g.new(Particle((0, 0, 0), (0, 0, 0)))
g.new(Particle((0, 0, 0), (1, 1, 1), size=(2, 2, 2)))
g.new(Particle((1, 1, 1), (-2, -2, -2), size=(3, 2, 0)))
g.update(0)
return g
def create_group(self, controllers, texture):
particlegroup = ParticleGroup(controllers=controllers,
system=self.system)
texturizer = SpriteTexturizer(texture.id)
particlegroup.renderer = BillboardRenderer(texturizer)
self.textures.add(
texture) # hold a reference to this, otherwise it will get deleted
return particlegroup
class Kaboom:
lifetime = 0.6
color = (0.9, 0.6, 0.2, 0.3)
spark_tex = pyglet.resource.texture('bullet.png')
spark_texturizer = SpriteTexturizer(spark_tex.id)
sparks = ParticleGroup(controllers=[
Lifetime(lifetime),
Movement(damping=0.93),
ColorBlender([(0, (1, 1, 1, 1)), (lifetime * 0.8, color),
(lifetime, color)]),
Fader(fade_out_start=0.3, fade_out_end=lifetime),
],
renderer=BillboardRenderer(spark_texturizer))
trails = ParticleGroup(controllers=[
Lifetime(lifetime * 1.5),
Movement(damping=0.83),
ColorBlender([(0, (1, 1, 1, 1)), (1, color), (lifetime, color)]),
Fader(max_alpha=0.75, fade_out_start=0, fade_out_end=lifetime),
],
renderer=BillboardRenderer(spark_texturizer))
splosions = set()
def __init__(self, position):
x, y = position
spark_emitter = StaticEmitter(
template=Particle(position=(uniform(x - 5,
x + 5), uniform(y - 5,
y + 5), 0),
size=(10, ) * 3,
color=self.color),
deviation=Particle(velocity=(gauss(0, 5), gauss(0, 5), 0),
age=1.5),
velocity=domain.Sphere((0, gauss(40, 20), 0), 60, 60))
spark_emitter.emit(int(gauss(60, 40)) + 50, self.sparks)
spread = abs(gauss(0.4, 1.0))
self.trail_emitter = PerParticleEmitter(
self.sparks,
rate=uniform(5, 30),
template=Particle(size=(6, ) * 3, color=self.color),
deviation=Particle(velocity=(spread, spread, spread),
age=self.lifetime * 0.75))
self.trails.bind_controller(self.trail_emitter)
self.splosions.add(self)
pyglet.clock.schedule_once(self.die, self.lifetime)
def die(self, dt=None):
self.trails.unbind_controller(self.trail_emitter)
self.splosions.remove(self)
def __init__(self, *args):
super(Rocket, self).__init__(*args)
psystem = self.squid.world.particles
self.particlegroup = ParticleGroup(
renderer=self.particle_renderer,
controllers=self.particle_controllers,
system=psystem)
self.emitter = None
def test_PerParticleEmitter_emit_empty_source(self):
from lepton import ParticleGroup
from lepton.emitter import PerParticleEmitter
emitter = PerParticleEmitter(ParticleGroup())
group = ParticleGroup()
self.assertEqual(len(group), 0)
emitter.emit(10, group)
group.update(0)
self.assertEqual(len(group), 0)
def test_PerParticleEmitter_emit_empty_source(self): from lepton import ParticleGroup from lepton.emitter import PerParticleEmitter emitter = PerParticleEmitter(ParticleGroup()) group = ParticleGroup() self.assertEqual(len(group), 0) emitter.emit(10, group) group.update(0) self.assertEqual(len(group), 0)
def _make_group(self): from lepton import Particle, ParticleGroup g = ParticleGroup() g.new(Particle(position=(0, 1.0, 0), velocity=(0, 0, 0))), g.new(Particle(position=(0, 0, 1.0), velocity=(0, 0, 0))), g.update(0) p = list(g) p[0].position = (10.0, 0, 0) p[1].position = (0, 0.0, 10.0) return g
def test_particle_vector_clamp(self): from lepton import ParticleGroup group = ParticleGroup() p = TestParticle() p.color = (2,0.5,-1,5) p.size = (0, 2, 0) newp = group.new(p) self.assertEqual(tuple(newp.color), p.color) self.assertEqual(tuple(newp.size), p.size) self.assertEqual(tuple(newp.color.clamp(0, 1)), (1, 0.5, 0, 1)) self.assertEqual(tuple(newp.size.clamp(1, 1.5)), (1, 1.5, 1))
def test_particle_vector_clamp(self):
from lepton import ParticleGroup
group = ParticleGroup()
p = TestParticle()
p.color = (2, 0.5, -1, 5)
p.size = (0, 2, 0)
newp = group.new(p)
self.assertEqual(tuple(newp.color), p.color)
self.assertEqual(tuple(newp.size), p.size)
self.assertEqual(tuple(newp.color.clamp(0, 1)), (1, 0.5, 0, 1))
self.assertEqual(tuple(newp.size.clamp(1, 1.5)), (1, 1.5, 1))
def _make_group(self): from lepton import Particle, ParticleGroup g = ParticleGroup() g.new(Particle((0,0,0), (0,0,0))) g.new(Particle((0,0,0), (1,1,1), size=(2,2,2))) g.new(Particle((1,1,1), (-2,-2,-2), size=(3,2,0))) g.update(0) return g
def test_StaticEmitter_partial(self): from lepton import Particle, ParticleGroup from lepton.emitter import StaticEmitter emitter = StaticEmitter(rate=1) group = ParticleGroup() # It should take four quarter second updates to emit one self.assertEqual(emitter(0.25, group), 0) self.assertEqual(emitter(0.25, group), 0) self.assertEqual(emitter(0.25, group), 0) self.assertEqual(emitter(0.25, group), 1) group.update(0) self.assertEqual(len(group), 1)
def test_StaticEmitter_partial(self):
from lepton import Particle, ParticleGroup
from lepton.emitter import StaticEmitter
emitter = StaticEmitter(rate=1)
group = ParticleGroup()
# It should take four quarter second updates to emit one
self.assertEqual(emitter(0.25, group), 0)
self.assertEqual(emitter(0.25, group), 0)
self.assertEqual(emitter(0.25, group), 0)
self.assertEqual(emitter(0.25, group), 1)
group.update(0)
self.assertEqual(len(group), 1)
def test_unbind_controllers(self): from lepton import ParticleGroup ctrl1 = TestController() ctrl2 = TestController() group = ParticleGroup(controllers=(ctrl1, ctrl2)) self.failUnless(ctrl1 in group.controllers) self.failUnless(ctrl2 in group.controllers) group.unbind_controller(ctrl1) self.failUnless(ctrl1 not in group.controllers) self.failUnless(ctrl2 in group.controllers) group.unbind_controller(ctrl2) self.failUnless(ctrl1 not in group.controllers) self.failUnless(ctrl2 not in group.controllers) self.assertRaises(ValueError, group.unbind_controller, ctrl1)
def test_Lifetime_controller(self):
from lepton import controller, Particle, ParticleGroup
g = ParticleGroup()
g.new(Particle(age=0))
g.new(Particle(age=0.8))
g.new(Particle(age=1.0))
g.new(Particle(age=0.75))
lifetime = controller.Lifetime(max_age=0.75)
g.update(0)
lifetime(0, g)
p = list(g)
self.assertEqual(len(g), 2)
self.assertFloatEqiv(p[0].age, 0.0)
self.assertFloatEqiv(p[1].age, 0.75)
def _make_group(self): from lepton import Particle, ParticleGroup g = ParticleGroup() g.new(Particle(position=(0, 1, 0), velocity=(0, -1, 0))), g.new(Particle(position=(0, 1, 0), velocity=(0, -1.5, 0))), g.new(Particle(position=(-1, -1, 1), velocity=(2, 2, 0))), g.new(Particle(position=(1, 1, 1), velocity=(0, 1, 0))) g.update(0) p = list(g) p[0].position = (0, 0, 0) p[1].position = (0, -0.5, 0) p[2].position = (1, 1, 1) p[3].position = (1, 2, 1) return g
def test_StaticEmitter_template(self): from lepton import Particle, ParticleGroup from lepton.emitter import StaticEmitter emitter = StaticEmitter(rate=1, template=Particle( position=(1.0, 1.0, 1.0), velocity=(0, 5, 2), color=(0.5, 0.5, 0.5, 1.0))) group = ParticleGroup() count = emitter(1, group) group.update(0) self.assertEqual(count, 1) self.assertEqual(len(group), 1) particle = list(group)[0] self.assertVector(particle.position, (1,1,1)) self.assertVector(particle.velocity, (0,5,2)) self.assertColor(particle.color, (0.5, 0.5, 0.5, 1.0))
def test_StaticEmitter_emit(self): from lepton import ParticleGroup from lepton.emitter import StaticEmitter emitter = StaticEmitter() group = ParticleGroup() self.assertEqual(len(group), 0) emitter.emit(10, group) group.update(0) self.assertEqual(len(group), 10) # Negative emit value is equivilant to zero emitter.emit(-10, group) group.update(0) self.assertEqual(len(group), 10)
def __init__(self):
color = (uniform(0, 1), uniform(0, 1), uniform(0, 1), 1)
while max(color[:3]) < 0.9:
color = (uniform(0, 1), uniform(0, 1), uniform(0, 1), 1)
spark_emitter = StaticEmitter(
template=Particle(position=(uniform(-50, 50), uniform(-30, 30),
uniform(-30, 30)),
color=color),
deviation=Particle(velocity=(gauss(0, 5), gauss(0, 5), gauss(0,
5)),
age=1.5),
velocity=domain.Sphere((0, gauss(40, 20), 0), 60, 60))
self.sparks = ParticleGroup(controllers=[
Lifetime(self.lifetime * 0.75),
Movement(damping=0.93),
ColorBlender([(0, (1, 1, 1, 1)), (2, color),
(self.lifetime, color)]),
Fader(fade_out_start=1.0, fade_out_end=self.lifetime * 0.5),
],
renderer=PointRenderer(
abs(gauss(10, 3)), spark_texturizer))
spark_emitter.emit(int(gauss(60, 40)) + 50, self.sparks)
spread = abs(gauss(0.4, 1.0))
self.trail_emitter = PerParticleEmitter(
self.sparks,
rate=uniform(5, 30),
template=Particle(color=color),
deviation=Particle(velocity=(spread, spread, spread),
age=self.lifetime * 0.75))
self.trails = ParticleGroup(controllers=[
Lifetime(self.lifetime * 1.5),
Movement(damping=0.83),
ColorBlender([(0, (1, 1, 1, 1)), (1, color),
(self.lifetime, color)]),
Fader(max_alpha=0.75,
fade_out_start=0,
fade_out_end=gauss(self.lifetime, self.lifetime * 0.3)),
self.trail_emitter
],
renderer=PointRenderer(
10, trail_texturizer))
pyglet.clock.schedule_once(self.die, self.lifetime * 2)
def test_bind_controllers(self): from lepton import ParticleGroup ctrl1 = TestController() ctrl2 = TestController() ctrl3 = TestController() ctrl4 = TestController() group = ParticleGroup() self.failIf(group.controllers) # Can bind controllers in constructor and after group = ParticleGroup(controllers=(ctrl1, ctrl2)) self.assertEqual(tuple(group.controllers), (ctrl1, ctrl2)) group.bind_controller(ctrl3, ctrl4) self.assertEqual(tuple(group.controllers), (ctrl1, ctrl2, ctrl3, ctrl4)) '''
class Impact:
lifetime = 0.5
color = (0.9, 0.6, 0.2, 0.3)
spark_tex = pyglet.resource.texture('bullet.png')
spark_texturizer = SpriteTexturizer(spark_tex.id)
sparks = ParticleGroup(controllers=[
Lifetime(lifetime),
Movement(),
ColorBlender([(0, (1, 1, 1, 1)), (lifetime * 0.8, color),
(lifetime, (0, 0, 0, 0))]),
],
renderer=BillboardRenderer(spark_texturizer))
@classmethod
def emit(cls, position, velocity):
x, y = position + velocity * 0.3
emitter = StaticEmitter(template=Particle(position=(x, y, 0),
size=(5, ) * 3,
color=cls.color),
deviation=Particle(age=0.2),
velocity=domain.Disc((*-2 * velocity, 0),
(0, 0, 1), 100))
emitter.emit(10, cls.sparks)
class Debris:
lifetime = 0.5
color = (1.0, 1.0, 1.0, 1.0)
fragment_tex = pyglet.resource.texture('fragment.png')
fragment_texturizer = SpriteTexturizer(fragment_tex.id)
fragments = ParticleGroup(controllers=[
Lifetime(lifetime),
Movement(),
],
renderer=BillboardRenderer(fragment_texturizer),
system=diffuse_system)
@classmethod
def emit(cls, position):
emitter = StaticEmitter(template=Particle(position=(*position, 0),
size=(16, ) * 3,
rotation=(0, 0, 1),
color=cls.color),
deviation=Particle(age=0.2,
rotation=(0, 0, 2)),
velocity=domain.Disc((0, 0, 0), (0, 0, 1),
100))
emitter.emit(20, cls.fragments)
def __init__(self, x, y, direction):
self.x, self.y = (x, y)
self.direction = direction
if direction < 0: self.speed = -800
else: self.speed = 800
self.emitter = emitter.StaticEmitter(
rate=300,
template=Particle(
position=(x, y, 0),
velocity=(0, 0, 0),
color=(1, 1, 0, 0.5),
size=(8, 8, 0),
# rotation?
# up?
),
velocity=Disc((0,0,0), (0,0,1), 200),
time_to_live=self.duration,
)
self.fader = controller.Fader(start_alpha=1,fade_out_start=0,fade_out_end=.5,end_alpha=0)
self.group = ParticleGroup(
controllers=[
self.emitter,
controller.Gravity((0, -100, 0)),
controller.Movement(),
self.fader,
controller.Lifetime(1),
],
renderer=Render('zap-star.png'),
)
self.emitter.emit(1, self.group)
def test_particle_vector_swizzle(self): from lepton import ParticleGroup group = ParticleGroup() newp = group.new(TestParticle()) self.assertEqual(tuple(newp.velocity), (0,0,0)) self.assertEqual(newp.velocity.x, 0) self.assertEqual(newp.velocity.y, 0) self.assertEqual(newp.velocity.z, 0) newp.velocity.x = 2 newp.velocity.y = -2 newp.velocity.z = 1 self.assertEqual(tuple(newp.velocity), (2,-2,1)) self.assertEqual(newp.velocity.x, 2) self.assertEqual(newp.velocity.y, -2) self.assertEqual(newp.velocity.z, 1) newp.velocity = (3,4,5) self.assertEqual(tuple(newp.velocity), (3,4,5)) self.assertEqual(newp.velocity.x, 3) self.assertEqual(newp.velocity.y, 4) self.assertEqual(newp.velocity.z, 5) self.assertEqual(tuple(newp.color), (0,0,0,0)) self.assertEqual(newp.color.r, 0) self.assertEqual(newp.color.g, 0) self.assertEqual(newp.color.b, 0) self.assertEqual(newp.color.a, 0) newp.color.r = 1 newp.color.g = -2 newp.color.b = 3 newp.color.a = -1 self.assertEqual(tuple(newp.color), (1,-2,3,-1)) self.assertEqual(newp.color.r, 1) self.assertEqual(newp.color.g, -2) self.assertEqual(newp.color.b, 3) self.assertEqual(newp.color.a, -1) newp.color = (5,4,3,2) self.assertEqual(tuple(newp.color), (5,4,3,2)) self.assertEqual(newp.color.r, 5) self.assertEqual(newp.color.g, 4) self.assertEqual(newp.color.b, 3) self.assertEqual(newp.color.a, 2) newp.color = (6,5,4) # alpha defaults to 1 self.assertEqual(tuple(newp.color), (6,5,4,1)) self.assertEqual(newp.color.r, 6) self.assertEqual(newp.color.g, 5) self.assertEqual(newp.color.b, 4) self.assertEqual(newp.color.a, 1)
def test_particle_vector_swizzle(self):
from lepton import ParticleGroup
group = ParticleGroup()
newp = group.new(TestParticle())
self.assertEqual(tuple(newp.velocity), (0, 0, 0))
self.assertEqual(newp.velocity.x, 0)
self.assertEqual(newp.velocity.y, 0)
self.assertEqual(newp.velocity.z, 0)
newp.velocity.x = 2
newp.velocity.y = -2
newp.velocity.z = 1
self.assertEqual(tuple(newp.velocity), (2, -2, 1))
self.assertEqual(newp.velocity.x, 2)
self.assertEqual(newp.velocity.y, -2)
self.assertEqual(newp.velocity.z, 1)
newp.velocity = (3, 4, 5)
self.assertEqual(tuple(newp.velocity), (3, 4, 5))
self.assertEqual(newp.velocity.x, 3)
self.assertEqual(newp.velocity.y, 4)
self.assertEqual(newp.velocity.z, 5)
self.assertEqual(tuple(newp.color), (0, 0, 0, 0))
self.assertEqual(newp.color.r, 0)
self.assertEqual(newp.color.g, 0)
self.assertEqual(newp.color.b, 0)
self.assertEqual(newp.color.a, 0)
newp.color.r = 1
newp.color.g = -2
newp.color.b = 3
newp.color.a = -1
self.assertEqual(tuple(newp.color), (1, -2, 3, -1))
self.assertEqual(newp.color.r, 1)
self.assertEqual(newp.color.g, -2)
self.assertEqual(newp.color.b, 3)
self.assertEqual(newp.color.a, -1)
newp.color = (5, 4, 3, 2)
self.assertEqual(tuple(newp.color), (5, 4, 3, 2))
self.assertEqual(newp.color.r, 5)
self.assertEqual(newp.color.g, 4)
self.assertEqual(newp.color.b, 3)
self.assertEqual(newp.color.a, 2)
newp.color = (6, 5, 4) # alpha defaults to 1
self.assertEqual(tuple(newp.color), (6, 5, 4, 1))
self.assertEqual(newp.color.r, 6)
self.assertEqual(newp.color.g, 5)
self.assertEqual(newp.color.b, 4)
self.assertEqual(newp.color.a, 1)
def test_StaticEmitter_template(self):
from lepton import Particle, ParticleGroup
from lepton.emitter import StaticEmitter
emitter = StaticEmitter(rate=1,
template=Particle(position=(1.0, 1.0, 1.0),
velocity=(0, 5, 2),
color=(0.5, 0.5, 0.5, 1.0)))
group = ParticleGroup()
count = emitter(1, group)
group.update(0)
self.assertEqual(count, 1)
self.assertEqual(len(group), 1)
particle = list(group)[0]
self.assertVector(particle.position, (1, 1, 1))
self.assertVector(particle.velocity, (0, 5, 2))
self.assertColor(particle.color, (0.5, 0.5, 0.5, 1.0))
def test_set_renderer(self): from lepton import ParticleGroup renderer = TestRenderer() group = ParticleGroup() self.assertEqual(group.renderer, None) # Can set renderer after init group.renderer = renderer self.assertEqual(group.renderer, renderer) # Can set renderer at init group2 = ParticleGroup(renderer=renderer) self.assertEqual(group2.renderer, renderer) # Can set renderer back to None group.renderer = None self.assertEqual(renderer.group, None)
def test_set_renderer(self):
from lepton import ParticleGroup
renderer = TestRenderer()
group = ParticleGroup()
self.assertEqual(group.renderer, None)
# Can set renderer after init
group.renderer = renderer
self.assertEqual(group.renderer, renderer)
# Can set renderer at init
group2 = ParticleGroup(renderer=renderer)
self.assertEqual(group2.renderer, renderer)
# Can set renderer back to None
group.renderer = None
self.assertEqual(renderer.group, None)
def test_PerParticleEmitter_invalid_rate(self):
from lepton import Particle, ParticleGroup
from lepton.emitter import PerParticleEmitter
self.assertRaises(ValueError,
PerParticleEmitter,
ParticleGroup(),
rate=-1)
def test_Lifetime_controller(self): from lepton import controller, Particle, ParticleGroup g = ParticleGroup() g.new(Particle(age=0)) g.new(Particle(age=0.8)) g.new(Particle(age=1.0)) g.new(Particle(age=0.75)) lifetime = controller.Lifetime(max_age=0.75) g.update(0) lifetime(0, g) p = list(g) self.assertEqual(len(g), 2) self.assertFloatEqiv(p[0].age, 0.0) self.assertFloatEqiv(p[1].age, 0.75)
def explosion(self, pos, magnitude):
sparks = ParticleGroup(
controllers=[
Lifetime(3),
Movement(damping=0.93),
Fader(fade_out_start=0.75, fade_out_end=3.0),
],
renderer=BillboardRenderer(SpriteTexturizer(self.particle1_tex.id)))
spark_emitter = StaticEmitter(
template=Particle(
position=(pos[0], pos[1], 0),
color=(1, 1, 1)),
deviation=Particle(
position=(1, 1, 0),
velocity=(300, 300, 0),
age=1.5),
size=[(3, 3, 0), (4, 4, 0), (5, 5, 0), (5, 5, 0), (6, 6, 0), (7, 7, 0)])
spark_emitter.emit(magnitude, sparks)
fire = ParticleGroup(
controllers=[
Lifetime(2),
Movement(damping=0.95),
Growth(60),
Fader(fade_in_start=0, start_alpha=0, fade_in_end=0.5, max_alpha=0.6,
fade_out_start=1.0, fade_out_end=2.0)
],
renderer=BillboardRenderer(SpriteTexturizer(self.smoke1_tex.id)))
fire_emitter = StaticEmitter(
template=Particle(
position=(pos[0], pos[1], 0),
size=(50, 50, 0)),
deviation=Particle(
position=(0.5, 0.5, 0),
velocity=(70, 70, 0),
size=(20, 20, 0),
up=(0, 0, math.pi * 2),
rotation=(0, 0, math.pi * 0.06),
age=2, ),
color=[(0.5, 0, 0), (0.5, 0.5, 0.5), (0.4, 0.1, 0.1), (0.85, 0.3, 0)],
)
fire_emitter.emit(400, fire)
def test_len(self):
from lepton import ParticleGroup
group = ParticleGroup()
self.assertEqual(len(group), 0)
group.new(TestParticle())
self.assertEqual(len(group), 0)
group.new(TestParticle())
self.assertEqual(len(group), 0)
# New particles become visible on update
group.update(0)
self.assertEqual(len(group), 2)
def test_mass_new_particles(self): from lepton import ParticleGroup count = 12345 group = ParticleGroup() p = TestParticle() for i in xrange(count): p.mass = i newp = group.new(p) self.assertEqual(newp.mass, p.mass) group.update(0) piter = iter(group) for i in xrange(count): newp = piter.next() self.assertEqual(newp.mass, i) self.assertEqual(len(group), count) self.assertEqual(group.killed_count(), 0) self.assertRaises(StopIteration, piter.next)
def test_PerParticleEmitter_partial(self): from lepton import Particle, ParticleGroup from lepton.emitter import PerParticleEmitter source_group = ParticleGroup() source_group.new(object()) source_group.new(object()) source_group.new(object()) source_group.update(0) emitter = PerParticleEmitter(source_group, rate=1) group = ParticleGroup() # It should take four quarter second updates to emit any self.assertEqual(emitter(0.25, group), 0) self.assertEqual(emitter(0.25, group), 0) self.assertEqual(emitter(0.25, group), 0) self.assertEqual(emitter(0.25, group), len(source_group)) group.update(0) self.assertEqual(len(group), len(source_group))
def particle_splash(self, pos, vel):
img = self.load_sprite('sprites/drip')
img.anchor_x = img.width / 2
img.anchor_y = img.height / 2
e = StaticEmitter(position=domain.Disc((pos.x, SEA_LEVEL, 0),
(0, 0, 1), 50),
velocity=domain.Disc((vel.x, vel.y, 0), (0, 0, 1),
200),
size=[(64.0, 64.0, 0), (80.0, 80.0, 0),
(100.0, 100.0, 0)],
template=Particle(color=(1.0, 1.0, 1.0, 1.0), ),
rate=100,
time_to_live=0.3)
self.splash_group = ParticleGroup(controllers=[
controller.Movement(),
controller.Gravity((0, -900, 0)),
controller.Lifetime(max_age=2), e
],
renderer=Renderer(img),
system=self.particles)
def test_StaticEmitter_discrete(self): from lepton import Particle, ParticleGroup from lepton.emitter import StaticEmitter masses = (0.5, 2.0, 8.0) positions = ((1.0,1.0,1.0), (10.0,20.0,30.0), (-100.0,0.0,0.0)) velocities = ((1,1,0),) colors = ((1.0, 1.0, 1.0, 0.5), (1.0, 0, 0, 1.0), (0, 1.0, 0, 1.0)) emitter = StaticEmitter(rate=1, mass=masses, position=positions, velocity=velocities, color=colors) group = ParticleGroup() emitter(3, group) group.update(0) self.assertEqual(len(group), 3) for particle in group: self.failUnless(particle.mass in masses, (particle.mass, masses)) self.failUnless(tuple(particle.position) in positions, (particle.position, positions)) self.failUnless(tuple(particle.color) in colors, (particle.color, colors)) self.assertVector(particle.velocity, (1,1,0))
def test_new_particle_kwargs(self):
from lepton import ParticleGroup, Particle
group = ParticleGroup()
self.assertEqual(len(group), 0)
self.assertEqual(group.new_count(), 0)
p = group.new(position=(1, -1, 2), age=2)
self.assertEqual(tuple(p.position), (1, -1, 2))
self.assertEqual(p.age, 2)
tmpl_p = Particle(age=3, velocity=(-1, 2, 3))
p = group.new(tmpl_p, age=5)
self.assertEqual(tuple(p.velocity), (-1, 2, 3))
self.assertEqual(p.age, 5)
self.assertEqual(len(group), 0)
self.assertEqual(group.new_count(), 2)
self.failIf(list(group))
group.update(0) # incorporate new particles
self.assertEqual(len(group), 2)
self.assertEqual(group.new_count(), 0)
def test_len(self): from lepton import ParticleGroup group = ParticleGroup() self.assertEqual(len(group), 0) group.new(TestParticle()) self.assertEqual(len(group), 0) group.new(TestParticle()) self.assertEqual(len(group), 0) # New particles become visible on update group.update(0) self.assertEqual(len(group), 2)
def test_modify_controllers_during_update(self): from lepton import ParticleGroup ctrl1 = TestController() ctrl2 = TestUnbindingController() ctrl4 = TestController() ctrl3 = TestBindingController(ctrl4) group = ParticleGroup(controllers=(ctrl1, ctrl2, ctrl3)) self.assertEqual(len(group.controllers), 3) self.failUnless(ctrl1 in group.controllers) self.failUnless(ctrl2 in group.controllers) self.failUnless(ctrl3 in group.controllers) self.failUnless(ctrl4 not in group.controllers) group.update(1) self.failUnless(ctrl1.group is group) self.failUnless(ctrl2.group is group) self.failUnless(ctrl3.group is group) self.failUnless(ctrl4.group is None) self.assertEqual(len(group.controllers), 3) self.failUnless(ctrl1 in group.controllers) self.failUnless(ctrl2 not in group.controllers) self.failUnless(ctrl3 in group.controllers) self.failUnless(ctrl4 in group.controllers)
def test_particle_attrs(self):
from lepton import ParticleGroup
p = TestParticle()
p.position = (1, 2, 3)
p.velocity = (4, 5, 6)
p.color = (7, 8, 9, 10)
p.size = (11, 12, 13)
p.up = (-1, -2, -3)
p.rotation = (-4, -5, -6)
p.age = 111
p.mass = 2
group = ParticleGroup()
newp = group.new(p)
self.assertEqual(tuple(newp.position), p.position)
self.assertEqual(tuple(newp.velocity), p.velocity)
self.assertEqual(tuple(newp.color), p.color)
self.assertEqual(tuple(newp.size), p.size)
self.assertEqual(tuple(newp.up), p.up)
self.assertEqual(tuple(newp.rotation), p.rotation)
self.assertEqual(newp.age, p.age)
self.assertEqual(newp.mass, p.mass)
def test_modify_controllers_during_update(self):
from lepton import ParticleGroup
ctrl1 = TestController()
ctrl2 = TestUnbindingController()
ctrl4 = TestController()
ctrl3 = TestBindingController(ctrl4)
group = ParticleGroup(controllers=(ctrl1, ctrl2, ctrl3))
self.assertEqual(len(group.controllers), 3)
self.failUnless(ctrl1 in group.controllers)
self.failUnless(ctrl2 in group.controllers)
self.failUnless(ctrl3 in group.controllers)
self.failUnless(ctrl4 not in group.controllers)
group.update(1)
self.failUnless(ctrl1.group is group)
self.failUnless(ctrl2.group is group)
self.failUnless(ctrl3.group is group)
self.failUnless(ctrl4.group is None)
self.assertEqual(len(group.controllers), 3)
self.failUnless(ctrl1 in group.controllers)
self.failUnless(ctrl2 not in group.controllers)
self.failUnless(ctrl3 in group.controllers)
self.failUnless(ctrl4 in group.controllers)
def test_particle_attrs(self): from lepton import ParticleGroup p = TestParticle() p.position=(1,2,3) p.velocity=(4,5,6) p.color=(7,8,9,10) p.size=(11,12,13) p.up=(-1,-2,-3) p.rotation=(-4,-5,-6) p.age=111 p.mass=2 group = ParticleGroup() newp = group.new(p) self.assertEqual(tuple(newp.position), p.position) self.assertEqual(tuple(newp.velocity), p.velocity) self.assertEqual(tuple(newp.color), p.color) self.assertEqual(tuple(newp.size), p.size) self.assertEqual(tuple(newp.up), p.up) self.assertEqual(tuple(newp.rotation), p.rotation) self.assertEqual(newp.age, p.age) self.assertEqual(newp.mass, p.mass)
def test_StaticEmitter_domain(self): from lepton import Particle, ParticleGroup from lepton.emitter import StaticEmitter expected = (-42, 0, 9) class TestDomain: generate_calls = 0 def generate(self): self.generate_calls += 1 return expected domain = TestDomain() emitter = StaticEmitter(rate=1, position=domain) self.assertEqual(domain.generate_calls, 0) group = ParticleGroup() count = emitter(2, group) group.update(0) self.assertEqual(count, 2) self.assertEqual(domain.generate_calls, 2) self.assertEqual(len(group), 2) for particle in group: self.assertVector(particle.position, expected)
def particles(self):
self.part = ParticleGroup(renderer=BillboardRenderer(texturizer2),
controllers=[
Movement(max_velocity=self.speed,
damping=0.95),
Magnet(self.objective,
charge=500,
exponent=0),
])
self.emiter = StaticEmitter(position=self.domain,
template=Particle(
color=self.color,
size=(self.size, self.size, 0),
))
self.emiter.emit(1, self.part)
def test_StaticEmitter_domain(self):
from lepton import Particle, ParticleGroup
from lepton.emitter import StaticEmitter
expected = (-42, 0, 9)
class TestDomain:
generate_calls = 0
def generate(self):
self.generate_calls += 1
return expected
domain = TestDomain()
emitter = StaticEmitter(rate=1, position=domain)
self.assertEqual(domain.generate_calls, 0)
group = ParticleGroup()
count = emitter(2, group)
group.update(0)
self.assertEqual(count, 2)
self.assertEqual(domain.generate_calls, 2)
self.assertEqual(len(group), 2)
for particle in group:
self.assertVector(particle.position, expected)
def _make_group(self):
from lepton import Particle, ParticleGroup
g = ParticleGroup()
g.new(Particle(position=(0, 1.0, 0), velocity=(0, 0, 0))),
g.new(Particle(position=(0, 0, 1.0), velocity=(0, 0, 0))),
g.update(0)
p = list(g)
p[0].position = (10.0, 0, 0)
p[1].position = (0, 0.0, 10.0)
return g
def test_StaticEmitter_time_to_live(self):
from lepton import Particle, ParticleGroup
from lepton.emitter import StaticEmitter
emitter = StaticEmitter(rate=1, time_to_live=3.0)
group = ParticleGroup(controllers=[emitter])
count = emitter(2, group)
self.assertEqual(count, 2)
self.assertEqual(emitter.time_to_live, 1)
self.failUnless(emitter in group.controllers)
count = emitter(2, group)
# Since only one second remained before expiring
# only one particle should be emitted
self.assertEqual(count, 1)
self.assertEqual(emitter.time_to_live, 0)
self.failUnless(emitter not in group.controllers)
def test_new_particle_kwargs(self): from lepton import ParticleGroup, Particle group = ParticleGroup() self.assertEqual(len(group), 0) self.assertEqual(group.new_count(), 0) p = group.new(position=(1,-1,2), age=2) self.assertEqual(tuple(p.position), (1, -1, 2)) self.assertEqual(p.age, 2) tmpl_p = Particle(age=3, velocity=(-1,2,3)) p = group.new(tmpl_p, age=5) self.assertEqual(tuple(p.velocity), (-1,2,3)) self.assertEqual(p.age, 5) self.assertEqual(len(group), 0) self.assertEqual(group.new_count(), 2) self.failIf(list(group)) group.update(0) # incorporate new particles self.assertEqual(len(group), 2) self.assertEqual(group.new_count(), 0)
class Trail:
LIFETIME = 0.2
sprite = pyglet.resource.texture('trail.png')
group = ParticleGroup(
controllers=[
Lifetime(LIFETIME),
#Fader(start_alpha=1.0, fade_out_start=0, fade_out_end=LIFETIME),
Growth(-50),
Movement(),
],
renderer=BillboardRenderer(SpriteTexturizer(sprite.id)))
def __init__(self, player, viewport, level):
self.player = player
self.viewport = viewport
self.level = level
self.emitter = StaticEmitter(
rate=player.body.velocity.length,
template=Particle(
position=(*level.map_to_world(player.position), 0),
color=(1.0, 1.0, 1.0, 1.0),
size=(16.0, ) * 3,
),
)
self.group.bind_controller(self.emitter)
pyglet.clock.schedule(self.update)
def destroy(self):
self.group.unbind_controller(self.emitter)
def update(self, *_):
level = self.level
dir = self.player.body.velocity
l = dir.length
self.emitter.rate = l * 2 if self.player.health > 0 else 0
if l:
back = self.player.position - dir.normalized() * 0.1
backwards = -0.1 * dir
self.emitter.template.position = (*level.map_to_world(back), 0)
self.emitter.template.velocity = (*level.map_to_world(backwards),
0)
self.emitter.template.up = (0, 0,
dir.get_angle() - self.viewport.angle)
def test_PerParticleEmitter_template(self): from lepton import Particle, ParticleGroup from lepton.emitter import PerParticleEmitter source_group = ParticleGroup() source_group.new(Particle(position=(1,1,1))) source_group.new(Particle(position=(2,2,2))) source_group.update(0) emitter = PerParticleEmitter(source_group, rate=1, template=Particle( position=(1.0, 1.0, 1.0), velocity=(0, 5, 2), color=(0.5, 0.5, 0.5, 1.0))) group = ParticleGroup() count = emitter(1, group) group.update(0) self.assertEqual(count, len(source_group)) self.assertEqual(len(group), len(source_group)) particle = list(group)[0] self.assertVector(particle.position, (1,1,1)) self.assertVector(particle.velocity, (0,5,2)) self.assertColor(particle.color, (0.5, 0.5, 0.5, 1.0)) particle = list(group)[1] self.assertVector(particle.position, (2,2,2)) self.assertVector(particle.velocity, (0,5,2)) self.assertColor(particle.color, (0.5, 0.5, 0.5, 1.0))
def test_PerParticleEmitter_time_to_live(self): from lepton import Particle, ParticleGroup from lepton.emitter import PerParticleEmitter source_group = ParticleGroup() source_group.new(object()) source_group.new(object()) source_group.new(object()) source_group.new(object()) source_group.update(0) emitter = PerParticleEmitter(source_group, rate=1, time_to_live=3.0) group = ParticleGroup(controllers=[emitter]) count = emitter(2, group) self.assertEqual(count, 2 * len(source_group)) self.assertEqual(emitter.time_to_live, 1) self.failUnless(emitter in group.controllers) count = emitter(2, group) # Since only one second remained before expiring # only one particle per should be emitted self.assertEqual(count, len(source_group)) self.assertEqual(emitter.time_to_live, 0) self.failUnless(emitter not in group.controllers)
glLoadIdentity()
win.on_resize = on_resize
glClearColor(1,1,1,1)
glEnable(GL_BLEND)
glShadeModel(GL_SMOOTH)
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA)
glDisable(GL_DEPTH_TEST)
logo_files = glob.glob(os.path.join(os.path.dirname(__file__), 'logo_frames/logo*.png'))
images = [pyglet.image.load(f) for f in sorted(logo_files)]
texturizer = FlipBookTexturizer.from_images(images + images[-1::-1], 0.075)
group = ParticleGroup(
controllers=[
Fader(fade_out_start=50.0, fade_out_end=58.5)
],
renderer=BillboardRenderer(texturizer))
template = Particle(
size=(1,1,0),
color=(1,1,1,1),
)
positions = set([((x - 25) * 1.4 + (y % 2.0) * 0.7,
(y - 25) * 1.4,
(z - 25) * 1.4 + (y % 2.0) * 0.7)
for x in range(50) for y in range(50) for z in range(50)])
group.new(template)
for i in xrange(12000):
group.new(template, position=positions.pop(), age=49.35)
win.set_visible(True)
def test_StaticEmitter_deviation(self): from lepton import Particle, ParticleGroup from lepton.emitter import StaticEmitter template=Particle( position=(1.0, 1.0, 1.0), velocity=(0, 0, 0), size=(2,2,2), color=(0.5, 0.5, 0.5, 1.0)) deviation=Particle( position=(0, 0, 0), velocity=(5, 10, 5), color=(1.0, 1.0, 1.0, 0)) particle_count = 12345 emitter = StaticEmitter( rate=particle_count, template=template, deviation=deviation) group = ParticleGroup() emitter(1, group) group.update(0) self.assertEqual(len(group), particle_count) position_mean =[0,0,0] position_var = [0,0,0] velocity_mean = [0,0,0] velocity_var = [0,0,0] size_mean = [0,0,0] size_var = [0,0,0] color_mean = [0,0,0,0] color_var = [0,0,0,0] def accum(mean_list, var_list, val, template): for i in range(len(mean_list)): mean_list[i] += val[i] d = val[i] - template[i] var_list[i] += d**2 def calc_mean_var(mean_list, var_list): for i in range(len(mean_list)): mean_list[i] /= float(particle_count) var_list[i] = math.sqrt(var_list[i] / float(particle_count)) for particle in group: accum(position_mean, position_var, particle.position, template.position) accum(velocity_mean, velocity_var, particle.velocity, template.velocity) accum(size_mean, size_var, particle.size, template.size) accum(color_mean, color_var, particle.color, template.color) calc_mean_var(position_mean, position_var) calc_mean_var(velocity_mean, velocity_var) calc_mean_var(size_mean, size_var) calc_mean_var(color_mean, color_var) self.assertVector(position_mean, template.position, tolerance=0.2) self.assertVector(position_var, deviation.position, tolerance=0.2) self.assertVector(velocity_mean, template.velocity, tolerance=0.2) self.assertVector(velocity_var, deviation.velocity, tolerance=0.2) self.assertVector(size_mean, template.size, tolerance=0.2) self.assertVector(size_var, deviation.size, tolerance=0.2) self.assertColor(color_mean, template.color, tolerance=0.2) self.assertColor(color_var, deviation.color, tolerance=0.2)
right_fan = AABox((win.width/2, win.height * 0.8, -1), (win.width/2 + win.width/12, win.height, 1)) default_system.add_global_controller( Gravity((0,-50,0)), Movement(max_velocity=250), Drag(0.0, 0.0001, (0, 800, 0), domain=up_fan), Drag(0.0, 0.0001, (-200, 400, 0), domain=left_fan), Drag(0.0, 0.0001, (200, 400, 0), domain=right_fan), *[bumper.controller for bumper in bumpers] ) # Make the bounce controller for the screen boundary run last # to ensure no particles can "escape" default_system.add_global_controller( Bounce(screen_domain, friction=0.01) ) group = ParticleGroup(renderer=PointRenderer(point_size=ball_size)) ball_emitter = StaticEmitter( position=screen_domain, deviation=Particle(velocity=(60,60,0), color=(0.3,0.3,0.3,0)), color=[(1,0,0,1), (0,1,0,1), (0,0,1,1), (1,1,0,1), (0,1,1,1), (1,1,1,1)], mass=[1], ) ball_emitter.emit(ball_count, group) group.update(0) # Kill particles inside the bumpers for p in group: for bumper in bumpers: if p.position in bumper.domain: group.kill(p)
def test_new_particle(self): from lepton import ParticleGroup, Particle group = ParticleGroup() self.assertEqual(len(group), 0) self.assertEqual(group.new_count(), 0) p1 = Particle(age=1) p2 = Particle(age=2) group.new(p1) self.assertEqual(len(group), 0) self.assertEqual(group.new_count(), 1) self.failIf(list(group)) group.new(p2) self.assertEqual(len(group), 0) self.assertEqual(group.new_count(), 2) self.failIf(list(group)) group.update(0) # incorporate new particles self.assertEqual(len(group), 2) self.assertEqual(group.new_count(), 0) particles = list(group) self.assertEqual(len(particles), 2) self.assertEqual(particles[0].age, 1) self.assertEqual(particles[1].age, 2) return group, particles
def test_PerParticleEmitter_emit(self): from lepton import ParticleGroup from lepton.emitter import PerParticleEmitter source_group = ParticleGroup() source_group.new(object()) source_group.new(object()) source_group.new(object()) source_group.update(0) emitter = PerParticleEmitter(source_group) group = ParticleGroup() self.assertEqual(len(group), 0) emitter.emit(10, group) group.update(0) expected = 10 * len(source_group) self.assertEqual(len(group), expected) # Negative emit value is equivilant to zero emitter.emit(-10, group) group.update(0) self.assertEqual(len(group), expected)
