def checkEvents(self):
"""
This just acts as a var switch and calls the process function
@type self.event: sdl2.SDL_Event()
@return: None
"""
while sdl2.SDL_PollEvent(ctypes.byref(self.event)) != 0:
if (self.event.type == sdl2.SDL_QUIT):
self.running = False
if (self.event.type == sdl2.SDL_MOUSEBUTTONDOWN):
self.mouseDown = True
if (self.event.type == sdl2.SDL_MOUSEBUTTONUP):
self.mouseDown = False
if (self.event.type == sdl2.SDL_MOUSEMOTION):
# print ("x: %i, y: %i" % (event.motion.x, event.motion.y))
self.mousePos[0] = self.event.motion.x
self.mousePos[1] = self.event.motion.y
# rend.mouseMove(self.event.motion.x, self.event.motion.y)
sdl2.SDL_FlushEvent(sdl2.SDL_MOUSEMOTION)
self.process()
return self.running
def run():
# Create the environment, in which our particles will exist.
world = sdl2.ext.World()
# Set up the globally available information about the current mouse
# position. We use that information to determine the emitter
# location for new particles.
world.mousex = 400
world.mousey = 300
# Create the particle engine. It is just a simple System that uses
# callback functions to update a set of components.
engine = sdl2.ext.particles.ParticleEngine()
# Bind the callback functions to the particle engine. The engine
# does the following on processing:
# 1) reduce the life time of each particle by one
# 2) create a list of particles, which's life time is 0 or below.
# 3) call createfunc() with the world passed to process() and
# the list of dead particles
# 4) call updatefunc() with the world passed to process() and the
# set of particles, which still are alive.
# 5) call deletefunc() with the world passed to process() and the
# list of dead particles. deletefunc() is respsonible for
# removing the dead particles from the world.
engine.createfunc = createparticles
engine.updatefunc = updateparticles
engine.deletefunc = deleteparticles
world.add_system(engine)
# We create all particles at once before starting the processing.
# We also could create them in chunks to have a visually more
# appealing effect, but let's keep it simple.
createparticles(world, None, 300)
# Initialize the video subsystem, create a window and make it visible.
sdl2.ext.init()
window = sdl2.ext.Window("Particles", size=(800, 600))
window.show()
# Create a hardware-accelerated sprite factory. The sprite factory requires
# a rendering context, which enables it to create the underlying textures
# that serve as the visual parts for the sprites.
renderer = sdl2.ext.Renderer(window)
factory = sdl2.ext.SpriteFactory(sdl2.ext.TEXTURE, renderer=renderer)
# Create a set of images to be used as particles on rendering. The
# images are used by the ParticleRenderer created below.
images = (factory.from_image(RESOURCES.get_path("circle.png")),
factory.from_image(RESOURCES.get_path("square.png")),
factory.from_image(RESOURCES.get_path("star.png"))
)
# Center the mouse on the window. We use the SDL2 functions directly
# here. Since the SDL2 functions do not know anything about the
# sdl2.ext.Window class, we have to pass the window's SDL_Window to it.
sdl2.SDL_WarpMouseInWindow(window.window, world.mousex, world.mousey)
# Hide the mouse cursor, so it does not show up - just show the
# particles.
sdl2.SDL_ShowCursor(0)
# Create the rendering system for the particles. This is somewhat
# similar to the SoftSpriteRenderer, but since we only operate with
# hundreds of particles (and not sprites with all their overhead),
# we need an own rendering system.
particlerenderer = ParticleRenderSystem(renderer, images)
world.add_system(particlerenderer)
# The almighty event loop. You already know several parts of it.
running = True
while running:
for event in sdl2.ext.get_events():
if event.type == sdl2.SDL_QUIT:
running = False
break
if event.type == sdl2.SDL_MOUSEMOTION:
# Take care of the mouse motions here. Every time the
# mouse is moved, we will make that information globally
# available to our application environment by updating
# the world attributes created earlier.
world.mousex = event.motion.x
world.mousey = event.motion.y
# We updated the mouse coordinates once, ditch all the
# other ones. Since world.process() might take several
# milliseconds, new motion events can occur on the event
# queue (10ths to 100ths!), and we do not want to handle
# each of them. For this example, it is enough to handle
# one per update cycle.
sdl2.SDL_FlushEvent(sdl2.SDL_MOUSEMOTION)
break
world.process()
sdl2.SDL_Delay(1)
sdl2.ext.quit()
return 0