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 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 _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 _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 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)
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 spawn_smoke(pos, vel):
"""Spawn a cannon smoke puff."""
e = StaticEmitter(template=Particle(
position=tuple(pos),
velocity=tuple(vel * 0.1),
size=(0.2, 0.2, 0.2),
color=(1, 1, 1, 0.2),
),
rotation=domain.Line((0, 0, -1), (0, 0, 1)),
deviation=Particle(velocity=(1.0, 1.0, 1.0), ),
rate=100,
time_to_live=0.1)
smoke_particles.bind_controller(e)
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 __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 __init__(self, wpos):
self.last_pos = wpos
self.domain = Cylinder((*wpos, -10), (*wpos, 0), 5)
self.emitter = StaticEmitter(rate=600,
position=self.domain,
template=Particle(
color=(1.0, 1.0, 1.0, 0.3),
size=(2.0, ) * 3,
rotation=(0, 0, 1),
velocity=(0, 0, 0),
),
deviation=Particle(
rotation=(0, 0, 0.5),
angle=(0, 0, 6),
))
self.group.bind_controller(self.emitter)
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 spawn_splinters(pos, vel):
"""Spawn a cannon smoke puff."""
e = StaticEmitter(
template=Particle(
position=tuple(pos),
velocity=tuple(vel * -0.1),
size=(0.15, 0.15, 0.15),
color=(1, 1, 1, 0.8),
),
rotation=domain.Line((0, 0, -1), (0, 0, 1)),
deviation=Particle(
size=(0.05, 0.05, 0.05),
velocity=(2.0, 2.0, 2.0),
),
)
e.emit(10, splinters1)
e.emit(10, splinters2)
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 __init__(self, ship):
self.ship = ship
self.emitters = [
StaticEmitter(template=Particle(
position=tuple(p),
velocity=tuple(v),
size=(0.2, 0.2, 0.0),
color=(1, 1, 1, 0.2),
),
deviation=Particle(
position=(0.02, 0.0, 0.02) if i < 2 else
(0.2, 0.0, 0.2),
size=(0.0, 0.07, 0.0),
velocity=(0.04, 0.0, 0.04),
),
rate=5 if i < 2 else 20)
for i, (p, v, rate) in enumerate(self.emitter_positions)
]
def emit_sparks(self, pos, count):
sparks = ParticleGroup(
controllers=[
Lifetime(1),
Movement(damping=0.93),
Fader(fade_out_start=0.75, fade_out_end=1.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=(100, 100, 0),
age=1.5),
size=[(6, 6, 0), (7, 7, 0), (12, 12, 0)])
spark_emitter.emit(count, sparks)
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 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 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_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_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 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 __init__(self, x, y, size):
self.emitter = emitter.StaticEmitter(
template = Particle(
position=(x, y, 0),
color=(1, 1, 1, .01),
velocity=(0, 0, 0),
size=(64, 64, 0),
),
velocity=Disc((0,0,0), (0,0,1), 400),
)
self.group = ParticleGroup(
controllers=[
self.emitter,
controller.Growth(50),
controller.Movement(),
controller.Fader(start_alpha=1,fade_out_start=0,fade_out_end=.7,end_alpha=0),
controller.Lifetime(.7),
],
renderer = Render('point64.png'),
)
self.emitter.emit(50, self.group)
def set_active(self, _):
if not self.active:
self.time_left = self.BURN_TIME
self.active = True
self.on_start()
# Stuff in any numbers for now, update later
self.vel_domain = domain.Disc((0, 0, 0), (0, 0, 1), 100)
self.pos_domain = domain.Cone((0, 0, 0), (-1, 0, 0), 1)
self.template = Particle(
size=(20.0, 20.0, 0),
color=(1.0, 0.5, 0.0, 1.0),
)
self.emitter = StaticEmitter(
position=self.pos_domain,
velocity=self.vel_domain,
template=self.template,
rate=30,
time_to_live=self.BURN_TIME,
)
self.particlegroup.bind_controller(self.emitter)
def __init__(self, rect, scale=1):
x, y = rect.center
self.emitter = emitter.StaticEmitter(
rate = 20,
template = Particle(
position=(x, y, 0),
color=(1, 1, 1, .5),
velocity=(0, 0, 0),
size=(8, 8, 0),
),
velocity=Disc((0,0,0), (0,0,1), rect.width*.75*scale),
)
self.group = ParticleGroup(
controllers=[
self.emitter,
controller.Movement(),
controller.Clumper(50),
controller.Fader(start_alpha=1,fade_out_start=0,fade_out_end=1,end_alpha=0),
controller.Lifetime(1),
],
renderer = Render(self.filename),
)
self.emitter.emit(1, self.group)
def __init__(self, x1, y1, x2, y2):
self.emitter = emitter.StaticEmitter(
rate = (x2-x1) // 5,
template = Particle(
position=(x1, y1, 0),
color=(1, 1, 1, .5),
velocity=(0, 0, 0),
size=(32, 32, 0),
),
position=Line((x1, y1, 0), (x2, y1, 0)),
velocity=AABox((-100, -50, 0), (100, -200, 1)),
)
self.group = ParticleGroup(
controllers=[
self.emitter,
controller.Movement(),
controller.Growth(100),
controller.Gravity((0, -50, 0)),
controller.Fader(start_alpha=1,fade_out_start=0,fade_out_end=1,end_alpha=0),
controller.Lifetime(2),
],
renderer = Render('black-bubble.png'),
)
self.emitter.emit(1, self.group)
win.on_resize = on_resize
glEnable(GL_BLEND)
glShadeModel(GL_SMOOTH)
glBlendFunc(GL_SRC_ALPHA, GL_ONE)
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST)
glDisable(GL_DEPTH_TEST)
disc = domain.Disc((0, 0, -50), (0, 0, 1), 1.5, 1.5)
viewer_plane = domain.Plane((0, 0, 0), (0, 0, -1))
jet = StaticEmitter(rate=2000,
position=disc,
template=Particle(color=(1, 1, 0), ),
deviation=Particle(velocity=(0, 0, 15),
up=(0, 0, math.pi),
color=(0.1, 0.1, 0.1)))
default_system.add_global_controller(
Movement(max_velocity=10),
Collector(viewer_plane),
Gravity((0, 0, 15)),
Growth(0.17),
Fader(fade_in_end=0, max_alpha=0.3, fade_out_start=0, fade_out_end=8.0),
)
texture = image.load(os.path.join(os.path.dirname(__file__),
'Particle.bmp')).get_texture()
group = ParticleGroup(controllers=[jet],
def _add_particles(self, group, pcount):
from lepton import Particle
for i in range(pcount):
group.new(Particle())
group.update(0)
from pygame.locals import *
from lepton import Particle, ParticleGroup, default_system, domain
from lepton.pygame_renderer import BlitRenderer
from lepton.emitter import StaticEmitter
from lepton.controller import Gravity, Lifetime, Movement, Growth
if __name__ == '__main__':
pygame.init()
width, height = 800, 600
display = pygame.display.set_mode((width, height))
pygame.display.set_caption('Lepton pygame BlitRenderer example', 'Lepton')
clock = pygame.time.Clock()
bubbler = StaticEmitter(rate=80,
template=Particle(position=(width / 2, height - 50,
0)),
deviation=Particle(velocity=(5, 15, 0),
size=(5, 5, 0)),
position=[((width * i / 4), height, 0)
for i in range(5)])
bubble = pygame.image.load(
os.path.join(os.path.dirname(__file__), 'bubble.png'))
water = ParticleGroup(controllers=[bubbler],
renderer=BlitRenderer(display,
bubble,
rotate_and_scale=True))
default_system.add_global_controller(
Lifetime(7),
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST)
glDisable(GL_DEPTH_TEST)
spark_tex = image.load(os.path.join(os.path.dirname(__file__),
'flare3.png')).get_texture()
sparks = ParticleGroup(controllers=[
Lifetime(3),
Movement(damping=0.93),
Fader(fade_out_start=0.75, fade_out_end=3.0),
],
renderer=BillboardRenderer(
SpriteTexturizer(spark_tex.id)))
spark_emitter = StaticEmitter(template=Particle(position=(win.width / 2,
win.height / 2, 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(400, sparks)
fire_tex = image.load(os.path.join(os.path.dirname(__file__),
'puff.png')).get_texture()
fire = ParticleGroup(controllers=[
Lifetime(4),
Movement(damping=0.95),
Growth(30),
