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 _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_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_PerParticleEmitter_invalid_rate(self): from lepton import Particle, ParticleGroup from lepton.emitter import PerParticleEmitter self.assertRaises(ValueError, PerParticleEmitter, ParticleGroup(), rate=-1)
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_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_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_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)