def run():
# init sdl and get window up
sdl2ext.init()
window = sdl2ext.Window("Traction Edge RL", size=(800, 600))
window.show()
#create hardware accelerated context for drawing on
context = sdl2ext.RenderContext(window, index=-1, flags=SDL_RENDERER_ACCELERATED)
#create our custom renderer with the context
renderer = systems.Renderer(context)
# init world
world = sdl2ext.World()
world.add_system(renderer)
# create our sprites
factory = sdl2ext.SpriteFactory(sprite_type=sdl2ext.TEXTURE, renderer=context)
sp_player = factory.from_color(WHITE, size=(32,32))
#create player
player = entities.Creature(world, sp_player, 100, 400)
#main loop
running = True
while running:
events = sdl2ext.get_events()
for event in events:
if event.type == SDL_QUIT:
running = False
break
SDL_Delay(10)
world.process()
return
def run():
sdl2ext.init()
window = sdl2ext.Window("The Pong Game", size=(800, 600))
window.show()
if "-hardware" in sys.argv:
print("Using hardware acceleration")
renderer = sdl2ext.RenderContext(window)
factory = sdl2ext.SpriteFactory(sdl2ext.TEXTURE, renderer=renderer)
else:
print("Using software rendering")
factory = sdl2ext.SpriteFactory(sdl2ext.SOFTWARE)
# Create the paddles - we want white ones. To keep it easy enough for us,
# we create a set of surfaces that can be used for Texture- and
# Software-based sprites.
sp_paddle1 = factory.from_color(WHITE, size=(20, 100))
sp_paddle2 = factory.from_color(WHITE, size=(20, 100))
sp_ball = factory.from_color(WHITE, size=(20, 20))
world = World()
movement = MovementSystem(0, 0, 800, 600)
collision = CollisionSystem(0, 0, 800, 600)
aicontroller = TrackingAIController(0, 600)
if factory.sprite_type == sdl2ext.SOFTWARE:
spriterenderer = SoftwareRenderer(window)
else:
spriterenderer = TextureRenderer(renderer)
world.add_system(aicontroller)
world.add_system(movement)
world.add_system(collision)
world.add_system(spriterenderer)
player1 = Player(world, sp_paddle1, 0, 250)
player2 = Player(world, sp_paddle2, 780, 250, True)
ball = Ball(world, sp_ball, 390, 290)
ball.velocity.vx = -BALL_SPEED
collision.ball = ball
aicontroller.ball = ball
running = True
while running:
for event in sdl2ext.get_events():
if event.type == sdlevents.SDL_QUIT:
running = False
break
if event.type == sdlevents.SDL_KEYDOWN:
if event.key.keysym.sym == sdlkc.SDLK_UP:
player1.velocity.vy = -PADDLE_SPEED
elif event.key.keysym.sym == sdlkc.SDLK_DOWN:
player1.velocity.vy = PADDLE_SPEED
elif event.type == sdlevents.SDL_KEYUP:
if event.key.keysym.sym in (sdlkc.SDLK_UP, sdlkc.SDLK_DOWN):
player1.velocity.vy = 0
sdltimer.SDL_Delay(10)
world.process()
def run():
# You know those from the helloworld.py example.
# Initialize the video subsystem, create a window and make it visible.
sdl2ext.init()
window = sdl2ext.Window("sdlgfx drawing examples", size=(800, 600))
window.show()
# Create a rendering context for the window. The sdlgfx module requires it.
context = sdl2ext.RenderContext(window)
# We implement the functionality as it was done in colorpalettes.py and
# utilise a mapping table to look up the function to be executed, together
# with the arguments they should receive
functions = ((draw_lines, (context, 800, 600)),
(draw_circles, (context, 800, 600)),
(draw_ellipsis, (context, 800, 600)),
(draw_rects, (context, 800, 600)),
(draw_trigons, (context, 800, 600)),
(draw_polygons, (context, 800, 600)),
(draw_mixed, (context, 800, 600))
)
# A storage variable for the function we are currently on, so that we know
# which function to execute next.
curindex = 0
draw_lines(context, 800, 600)
# The event loop is nearly the same as we used in colorpalettes.py. If you
# do not know, what happens here, take a look at colorpalettes.py for a
# detailed description.
running = True
while running:
events = sdl2ext.get_events()
for event in events:
if event.type == SDL_QUIT:
running = False
break
if event.type == SDL_MOUSEBUTTONDOWN:
curindex += 1
if curindex >= len(functions):
curindex = 0
# In contrast to colorpalettes.py, our mapping table consists
# of functions and their arguments. Thus, we get the currently
# requested function and argument tuple and execute the
# function with the arguments.
func, args = functions[curindex]
func(*args)
break
context.present()
sdl2ext.quit()
return 0
def main():
sdl2ext.init()
TTF_Init()
window = sdl2ext.Window("Text display", size=(800, 600))
window.show()
renderer = sdl2ext.RenderContext(window)
factory = sdl2ext.SpriteFactory(sdl2ext.TEXTURE, renderer=renderer)
world = sdl2ext.World()
fps = FPSCounter(world, renderer=renderer)
spriteRenderer = factory.create_sprite_renderer()
fpsController = FPSController()
world.add_system(fpsController)
world.add_system(spriteRenderer)
running = True
while running:
for event in sdl2ext.get_events():
if event.type == sdlevents.SDL_QUIT:
running = False
break
elif event.type == sdlevents.SDL_USEREVENT:
entity = cast(event.user.data1,
POINTER(py_object)).contents.value
entity.textsprite.text = "FPS: " + str(entity.fps.counter)
entity.fps.counter = 0
renderer.clear()
world.process()
TTF_Quit()
sdl2ext.quit()
return 0
def run():
# You know those from the helloworld.py example.
# Initialize the video subsystem, create a window and make it visible.
sdl2ext.init()
window = sdl2ext.Window("UI Elements", size=(800, 600))
window.show()
# Create a sprite factory that allows us to create visible 2D elements
# easily. Depending on what the user chosses, we either create a factory
# that supports hardware-accelerated sprites or software-based ones.
# The hardware-accelerated SpriteFactory requres a rendering context
# (or SDL_Renderer), which will create the underlying textures for us.
if "-hardware" in sys.argv:
print("Using hardware acceleration")
renderer = sdl2ext.RenderContext(window)
factory = sdl2ext.SpriteFactory(sdl2ext.TEXTURE, renderer=renderer)
else:
print("Using software rendering")
factory = sdl2ext.SpriteFactory(sdl2ext.SOFTWARE)
# Create a UI factory, which will handle several defaults for
# us. Also, the UIFactory can utilises software-based UI elements as
# well as hardware-accelerated ones; this allows us to keep the UI
# creation code clean.
uifactory = sdl2ext.UIFactory(factory)
# Create a simple Button sprite, which reacts on mouse movements and
# button presses and fill it with a white color. All UI elements
# inherit directly from the TextureSprite (for TEXTURE) or SoftwareSprite
# (for SOFTWARE), so everything you can do with those classes is also
# possible for the UI elements.
button = uifactory.from_image(sdl2ext.BUTTON,
RESOURCES.get_path("button.bmp"))
button.position = 50, 50
# Create a TextEntry sprite, which reacts on keyboard presses and
# text input.
entry = uifactory.from_image(sdl2ext.TEXTENTRY,
RESOURCES.get_path("textentry.bmp"))
entry.position = 50, 200
# Create a CheckButton sprite. The CheckButton is a specialised
# Button, which can switch its state, identified by the 'checked'
# attribute by clicking.
checkbutton = uifactory.from_color(sdl2ext.CHECKBUTTON, RED, size=(50, 50))
checkbutton.position = 200, 50
# Bind some actions to the button's event handlers. Whenever a click
# (combination of a mouse button press and mouse button release), the
# onclick() function will be called.
# Whenever the mouse moves around in the area occupied by the button, the
# onmotion() function will be called.
# The event handlers receive the issuer of the event as first argument
# (the button is the issuer of that event) and the SDL event data as second
# argument for further processing, if necessary.
button.click += onclick
button.motion += onmotion
# Bind some actions to the entry's event handlers. The TextEntry
# receives input events, once it has been activated by a mouse
# button press on its designated area. The UIProcessor class takes
# care of this internally through its activate() method. If the
# TextEntry is activated, SDL_TEXTINPUT events are enabled by the
# relevant SDL2 functions, causing input events to occur, that are
# handled by the TextEntry.
entry.input += oninput
entry.editing += onedit
checkbutton.click += oncheck
checkbutton.factory = factory
# Since all gui elements are sprites, we can use the
# SpriteRenderer class, we learned about in helloworld.py, to
# draw them on the Window.
spriterenderer = factory.create_sprite_renderer(window)
# Create a new UIProcessor, which will handle the user input events
# and pass them on to the relevant user interface elements.
uiprocessor = sdl2ext.UIProcessor()
running = True
while running:
events = sdl2ext.get_events()
for event in events:
if event.type == SDL_QUIT:
running = False
break
# Pass the SDL2 events to the UIProcessor, which takes care of
# the user interface logic.
uiprocessor.dispatch([button, checkbutton, entry], event)
# Render all user interface elements on the window.
spriterenderer.render((button, entry, checkbutton))
sdl2ext.quit()
return 0
def run():
# Initialize the video system - this implicitly initializes some
# necessary parts within the SDL2 DLL used by the video module.
#
# You SHOULD call this before using any video related methods or
# classes.
sdl2ext.init()
# Create a new window (like your browser window or editor window,
# etc.) and give it a meaningful title and size. We definitely need
# this, if we want to present something to the user.
window = sdl2ext.Window("Hello World!", size=(592, 460))
# By default, every Window is hidden, not shown on the screen right
# after creation. Thus we need to tell it to be shown now.
window.show()
# Create a sprite factory that allows us to create visible 2D elements
# easily. Depending on what the user chosses, we either create a factory
# that supports hardware-accelerated sprites or software-based ones.
# The hardware-accelerated SpriteFactory requres a rendering context
# (or SDL_Renderer), which will create the underlying textures for us.
if "-hardware" in sys.argv:
print("Using hardware acceleration")
renderer = sdl2ext.RenderContext(window)
factory = sdl2ext.SpriteFactory(sdl2ext.TEXTURE, renderer=renderer)
else:
print("Using software rendering")
factory = sdl2ext.SpriteFactory(sdl2ext.SOFTWARE)
# Creates a simple rendering system for the Window. The
# SpriteRenderer can draw Sprite objects on the window.
spriterenderer = factory.create_sprite_renderer(window)
# Creates a new 2D pixel-based surface to be displayed, processed or
# manipulated. We will use the one of the shipped example images
# from the resource package to display.
sprite = factory.from_image(RESOURCES.get_path("hello.bmp"))
# Display the surface on the window. This will copy the contents
# (pixels) of the surface to the window. The surface will be
# displayed at surface.position on the window. Play around with the
# surface.x and surface.y values or surface.position (which is just
# surface.x and surface.y grouped as tuple)!
spriterenderer.render(sprite)
# Set up an example event loop processing system. This is a necessity,
# so the application can exit correctly, mouse movements, etc. are
# recognised and so on. The TestEventProcessor class is just for
# testing purposes and does not do anything meaningful. Take a look
# at its code to better understand how the event processing can be
# done and customized!
processor = sdl2ext.TestEventProcessor()
# Start the event processing. This will run in an endless loop, so
# everything following after processor.run() will not be executed
# before some quitting event is raised.
processor.run(window)
# We called video.init(), so we have to call video.quit() as well to
# release the resources hold by the SDL DLL.
sdl2ext.quit()
def run():
# Create the environment, in which our particles will exist.
world = sdl2ext.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 = 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.
sdl2ext.init()
window = sdl2ext.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 = sdl2ext.RenderContext(window)
factory = sdl2ext.SpriteFactory(sdl2ext.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.
SDL_WarpMouseInWindow(window.window, world.mousex, world.mousey)
# Hide the mouse cursor, so it does not show up - just show the
# particles.
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 = ParticleRenderer(renderer, images)
world.add_system(particlerenderer)
# The almighty event loop. You already know several parts of it.
running = True
while running:
for event in sdl2ext.get_events():
if event.type == SDL_QUIT:
running = False
break
if event.type == 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.
SDL_FlushEvent(SDL_MOUSEMOTION)
break
world.process()
SDL_Delay(1)
sdl2ext.quit()
return 0