コード例 #1
0
    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))
コード例 #2
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))
コード例 #3
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)
コード例 #4
0
ファイル: controller_test.py プロジェクト: lordmauve/lepton
 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
コード例 #5
0
 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
コード例 #6
0
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)
コード例 #7
0
ファイル: engines.py プロジェクト: lordmauve/korovic
    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
コード例 #8
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)
コード例 #9
0
ファイル: emitter_test.py プロジェクト: jmichelsen/py-lepton
	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)
コード例 #10
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
コード例 #11
0
ファイル: group_test.py プロジェクト: jmichelsen/py-lepton
	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))
コード例 #12
0
 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))
コード例 #13
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
コード例 #14
0
ファイル: emitter_test.py プロジェクト: jmichelsen/py-lepton
	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)
コード例 #15
0
    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)
コード例 #16
0
ファイル: group_test.py プロジェクト: jmichelsen/py-lepton
	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)
コード例 #17
0
ファイル: controller_test.py プロジェクト: lordmauve/lepton
 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)
コード例 #18
0
	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
コード例 #19
0
ファイル: emitter_test.py プロジェクト: jmichelsen/py-lepton
	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))
コード例 #20
0
ファイル: emitter_test.py プロジェクト: jmichelsen/py-lepton
	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)
コード例 #21
0
ファイル: fireworks.py プロジェクト: lordmauve/lepton
    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)
コード例 #22
0
ファイル: group_test.py プロジェクト: jmichelsen/py-lepton
	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))

		'''
コード例 #23
0
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)
コード例 #24
0
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)
コード例 #25
0
ファイル: effects.py プロジェクト: MikeTam1021/WEP_class
    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)
コード例 #26
0
ファイル: group_test.py プロジェクト: jmichelsen/py-lepton
	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)
コード例 #27
0
    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)
コード例 #28
0
    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))
コード例 #29
0
ファイル: group_test.py プロジェクト: jmichelsen/py-lepton
	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)
コード例 #30
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)
コード例 #31
0
    def test_PerParticleEmitter_invalid_rate(self):
        from lepton import Particle, ParticleGroup
        from lepton.emitter import PerParticleEmitter

        self.assertRaises(ValueError,
                          PerParticleEmitter,
                          ParticleGroup(),
                          rate=-1)
コード例 #32
0
	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)
コード例 #33
0
ファイル: Effects.py プロジェクト: daedalusz/SpacePotato
    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)
コード例 #34
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)
コード例 #35
0
ファイル: group_test.py プロジェクト: jmichelsen/py-lepton
	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)
コード例 #36
0
ファイル: emitter_test.py プロジェクト: jmichelsen/py-lepton
	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))
コード例 #37
0
ファイル: world.py プロジェクト: lordmauve/korovic
 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)
コード例 #38
0
ファイル: emitter_test.py プロジェクト: jmichelsen/py-lepton
	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))
コード例 #39
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)
コード例 #40
0
ファイル: group_test.py プロジェクト: jmichelsen/py-lepton
	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)
コード例 #41
0
ファイル: group_test.py プロジェクト: jmichelsen/py-lepton
	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)
コード例 #42
0
    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)
コード例 #43
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)
コード例 #44
0
ファイル: group_test.py プロジェクト: jmichelsen/py-lepton
	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)
コード例 #45
0
ファイル: emitter_test.py プロジェクト: jmichelsen/py-lepton
	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)
コード例 #46
0
ファイル: sandbox.py プロジェクト: Dancorg/ShipHell
 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)
コード例 #47
0
    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)
コード例 #48
0
ファイル: controller_test.py プロジェクト: lordmauve/lepton
 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
コード例 #49
0
    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)
コード例 #50
0
ファイル: group_test.py プロジェクト: jmichelsen/py-lepton
	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)
コード例 #51
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)
コード例 #52
0
ファイル: emitter_test.py プロジェクト: jmichelsen/py-lepton
	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))
コード例 #53
0
ファイル: emitter_test.py プロジェクト: jmichelsen/py-lepton
	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)
コード例 #54
0
ファイル: logo.py プロジェクト: jmichelsen/py-lepton
	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)
コード例 #55
0
ファイル: emitter_test.py プロジェクト: jmichelsen/py-lepton
	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)
コード例 #56
0
ファイル: bouncy.py プロジェクト: jmichelsen/py-lepton
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)
コード例 #57
0
ファイル: group_test.py プロジェクト: jmichelsen/py-lepton
	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
コード例 #58
0
ファイル: emitter_test.py プロジェクト: jmichelsen/py-lepton
	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)