def main():
window = sf.RenderWindow(sf.VideoMode(640, 480),
'SFML RenderTexture example')
window.framerate_limit = 60
running = True
rect0 = sf.RectangleShape((5, 5))
rect0.position = (90, 50)
rect0.fill_color = sf.Color.GREEN
rect0.outline_color = sf.Color.BLUE
rect0.outline_thickness = 2.0
rect1 = sf.RectangleShape((20, 30))
rect1.position = (50, 50)
rect1.fill_color = sf.Color.CYAN
rt = sf.RenderTexture(110, 110)
rt.clear(sf.Color(0, 0, 0, 0))
rt.draw(rect0)
rt.draw(rect1)
rt.display()
s = sf.Sprite(rt.texture)
s.origin = (55, 55)
s.position = (320, 240)
while running:
for event in window.iter_events():
if event.type == sf.Event.CLOSED:
running = False
window.clear(sf.Color.WHITE)
s.rotate(5)
window.draw(s)
window.display()
window.close()
def prerender(self, map_):
# create textures for pre-rendering
self.top_layers = sf.RenderTexture(self.mapwidth, self.mapheight)
self.bottom_layers = sf.RenderTexture(self.mapwidth, self.mapheight)
# render map tiles on the textures
for z, layer in enumerate(map_):
for col in layer:
for tile in col:
if z > self.piece_layer:
self.top_layers.draw(tile)
else:
self.bottom_layers.draw(tile)
# update textures
self.top_layers.display()
self.bottom_layers.display()
# set sprites
self.map_top = sf.Sprite(self.top_layers.texture)
self.map_bottom = sf.Sprite(self.bottom_layers.texture)
def __init__(self, input, client, ships):
self.input = input
self.client = client
client.add_handler(self)
# Enemy render window
self.lock_window = sf.RenderTexture(500, 500)
self.lock_window_sprite = sf.Sprite(self.lock_window.texture)
self.lock_window_sprite.position = (500, 50)
# Ships
self.ships = ships
self.player_ship = self.ships[self.client.client_id]
self.enemy_ship = None
self.losers = []
# Create the systems interface
self.systems_interface = SystemsInterface(self.player_ship)
self.input.add_mouse_handler(self.systems_interface)
# Create the weapons interface
self.weapons_interface = WeaponsInterface(self.lock_window,
self.lock_window_sprite,
self.player_ship)
for client_id, ship in self.ships.items():
if client_id != self.client.client_id:
self.weapons_interface.add_enemy_ship(ship)
print("added enemy ship: " + str(ship))
self.enemy_ship = ship # TODO
self.input.add_mouse_handler(self.weapons_interface)
self.input.add_text_handler(self.weapons_interface)
# Turn stuff
self.mode = const.plan
self.turn_timer = 0
self.turn_number = 0
# Timer text
self.turn_mode_text = sf.Text("0", res.font_8bit, 20)
self.turn_mode_text.position = sf.Vector2(400, 30)
# Room index
self.room_index = {}
for ship in ships.values():
for room in ship.rooms:
self.room_index[room.id] = room
# System index
self.system_index = {}
for ship in ships.values():
ship.engine_system.id = ship.id + ":engine_sys"
ship.weapon_system.id = ship.id + ":weapon_sys"
ship.shield_system.id = ship.id + ":shield_sys"
self.system_index[ship.engine_system.id] = ship.engine_system
self.system_index[ship.weapon_system.id] = ship.weapon_system
self.system_index[ship.shield_system.id] = ship.shield_system
# Weapon index and projectiles
self.weapon_index = {}
self.projectiles = []
for ship in ships.values():
if not ship.weapon_system:
continue
for weapon in ship.weapon_system.weapons:
self.weapon_index[weapon.id] = weapon
self.projectiles.extend(weapon.projectiles)
# Client ship's projectiles
if self.player_ship.weapon_system:
for weapon in self.player_ship.weapon_system.weapons:
for projectile in weapon.projectiles:
projectile.is_mine = True
def main():
if not sf.Shader.IS_AVAILABLE:
display_error()
# Create the main window
window = sf.RenderWindow(sf.VideoMode(800, 600), 'SFML shader example')
clock = sf.Clock()
# Create the render texture
texture = sf.RenderTexture(window.width, window.height)
# Load a background texture to display
background_texture = sf.Texture.load_from_file('resources/background.jpg')
background = sf.Sprite(background_texture)
# Load a sprite which we'll move into the scene
entity_texture = sf.Texture.load_from_file('resources/sprite.png')
entity = sf.Sprite(entity_texture)
# Load the text font
font = sf.Font.load_from_file('resources/sansation.ttf')
# Load the texture needed for the wave shader
wave_texture = sf.Texture.load_from_file('resources/wave.jpg')
# Load all shaders
shaders = [None] * 7
shaders[NOTHING] = sf.Shader.load_from_file('resources/nothing.sfx',
sf.Shader.FRAGMENT)
shaders[BLUR] = sf.Shader.load_from_file('resources/blur.sfx',
sf.Shader.FRAGMENT)
shaders[COLORIZE] = sf.Shader.load_from_file('resources/colorize.sfx',
sf.Shader.FRAGMENT)
shaders[EDGE] = sf.Shader.load_from_file('resources/edge.sfx',
sf.Shader.FRAGMENT)
shaders[FISHEYE] = sf.Shader.load_from_file('resources/fisheye.sfx',
sf.Shader.FRAGMENT)
shaders[WAVE] = sf.Shader.load_from_file('resources/wave.sfx',
sf.Shader.FRAGMENT)
shaders[PIXELATE] = sf.Shader.load_from_file('resources/pixelate.sfx',
sf.Shader.FRAGMENT)
background_shader = ShaderSelector(shaders)
entity_shader = ShaderSelector(shaders)
global_shader = ShaderSelector(shaders)
# Do specific initializations
shaders[NOTHING].set_parameter('texture', sf.Shader.CURRENT_TEXTURE)
shaders[BLUR].set_parameter('texture', sf.Shader.CURRENT_TEXTURE)
shaders[BLUR].set_parameter('offset', 0.0)
shaders[COLORIZE].set_parameter('texture', sf.Shader.CURRENT_TEXTURE)
shaders[COLORIZE].set_parameter('color', 1.0, 1.0, 1.0)
shaders[EDGE].set_parameter('texture', sf.Shader.CURRENT_TEXTURE)
shaders[FISHEYE].set_parameter('texture', sf.Shader.CURRENT_TEXTURE)
shaders[WAVE].set_parameter('texture', sf.Shader.CURRENT_TEXTURE)
shaders[WAVE].set_parameter('wave', wave_texture)
shaders[PIXELATE].set_parameter('texture', sf.Shader.CURRENT_TEXTURE)
# Define a string for displaying the description of the current shader
shader_str = sf.Text()
shader_str.font = font
shader_str.character_size = 20
shader_str.position = (5.0, 0.0)
shader_str.color = sf.Color(250, 100, 30)
shader_str.string = ("Background shader: \"{0}\"\n"
"Flower shader: \"{1}\"\n"
"Global shader: \"{2}\"\n".format(
background_shader.get_name(),
entity_shader.get_name(),
global_shader.get_name()))
# Define a string for displaying help
info_str = sf.Text()
info_str.font = font
info_str.character_size = 20
info_str.position = (5.0, 500.0)
info_str.color = sf.Color(250, 100, 30)
info_str.string = ("Move your mouse to change the shaders' parameters\n"
"Press numpad 1/4 to change the background shader\n"
"Press numpad 2/5 to change the flower shader\n"
"Press numpad 3/6 to change the global shader")
# Create a clock to measure the total time elapsed
clock = sf.Clock()
# Start the game loop
while window.open:
# Process events
for event in window.iter_events():
# Close window : exit
if event.type == sf.Event.CLOSED:
window.close()
if event.type == sf.Event.KEY_PRESSED:
# Escape key : exit
if event.code == sf.Keyboard.ESCAPE:
window.close()
# Numpad : switch effect
if event.code == sf.Keyboard.NUMPAD1:
background_shader.go_to_previous()
elif event.code == sf.Keyboard.NUMPAD4:
background_shader.go_to_next()
elif event.code == sf.Keyboard.NUMPAD2:
entity_shader.go_to_previous()
elif event.code == sf.Keyboard.NUMPAD5:
entity_shader.go_to_next()
elif event.code == sf.Keyboard.NUMPAD3:
global_shader.go_to_previous()
elif event.code == sf.Keyboard.NUMPAD6:
global_shader.go_to_next()
# Update the text
shader_str.string = ("Background shader: \"{0}\"\n"
"Entity shader: \"{1}\"\n"
"Global shader: \"{2}\"\n".format(
background_shader.get_name(),
entity_shader.get_name(),
global_shader.get_name()))
frame_time = clock.restart().as_milliseconds()
# Get the mouse position in the range [0, 1]
if window.width and window.height:
mouse_x = sf.Mouse.get_position(window)[0] / float(window.width)
mouse_y = sf.Mouse.get_position(window)[1] / float(window.height)
# Update the shaders
background_shader.update(mouse_x, mouse_y)
entity_shader.update(mouse_x, mouse_y)
global_shader.update(mouse_x, mouse_y)
# Animate the entity
entity_x = (
(math.cos(clock.elapsed_time.as_milliseconds() * 0.0013) + 1.2) *
300)
entity_y = (
(math.cos(clock.elapsed_time.as_milliseconds() * 0.0008) + 1.2) *
200)
entity.position = (entity_x, entity_y)
entity.rotate(frame_time * 0.1)
# Draw the background and the moving entity to the render texture
texture.clear()
texture.draw(background, background_shader.get_shader())
texture.draw(entity, entity_shader.get_shader())
texture.display()
# Draw the contents of the render texture to the window
screen = sf.Sprite(texture.texture)
window.draw(screen, global_shader.get_shader())
# Draw the interface texts
window.draw(shader_str)
window.draw(info_str)
# Finally, display the rendered frame on screen
window.display()
def creer_sprites_str(self, chaine):
"""
Fonction qui créer les sprites du bouton à partir d'une chaine de
caractères.
"""
try:
assert isinstance(chaine, str)
except AssertionError:
raise ValueError(chaine, " n'est pas une chaine de caractère.")
# Créer les images
self.sprites["normal"] = sf.Image.create(
len(chaine) * 32, 64, sf.Color(255, 255, 255))
self.sprites["selection"] = sf.Image.create(
len(chaine) * 32, 64, sf.Color(255, 255, 255))
# Dessiner le message sur les images
for l, lettre in enumerate(chaine):
coord_lettre = ((ord(lettre) % 10) * 32, (ord(lettre) // 10) * 64,
32, 64)
self.sprites["normal"].blit(ASCII, (l * 32, 0), coord_lettre)
self.sprites["selection"].blit(ASCII_SELECTION, (l * 32, 0),
coord_lettre)
# Créer le dessin de la zone de saisie
largeur_bouton = len(chaine) * 32 if len(
chaine) * 32 > self.maxlength * 32 + 8 else self.maxlength * 32 + 8
zone_saisie = sf.RectangleShape()
zone_saisie.size = (self.maxlength * 32 + 4, 68)
zone_saisie.fill_color = sf.Color(255, 255, 255)
zone_saisie.outline_thickness = 2
zone_saisie.position = ((largeur_bouton - self.maxlength * 32 - 4) //
2, 68)
# Créer des sf.RenderTexture pour y dessiner le sprite final
render_texture_normal = sf.RenderTexture(largeur_bouton, 138)
render_texture_selection = sf.RenderTexture(largeur_bouton, 138)
# Dessiner les sprites
zone_saisie.outline_color = sf.Color(255, 242, 0)
render_texture_normal.draw(
sf.Sprite(sf.Texture.from_image(self.sprites["normal"])))
render_texture_normal.draw(zone_saisie)
zone_saisie.outline_color = sf.Color(63, 72, 204)
render_texture_selection.draw(
sf.Sprite(sf.Texture.from_image(self.sprites["selection"])))
render_texture_selection.draw(zone_saisie)
# Obtenir les images finales
self.sprites["normal"] = render_texture_normal.texture.to_image()
self.sprites["selection"] = render_texture_selection.texture.to_image()
self.sprites["normal"].flip_vertically()
self.sprites["selection"].flip_vertically()
self.sprites["normal"].create_mask_from_color(sf.Color(255, 255, 255))
self.sprites["selection"].create_mask_from_color(
sf.Color(255, 255, 255))
# Convertir les images finales en textures
self.sprites["normal"] = sf.Texture.from_image(self.sprites["normal"])
self.sprites["selection"] = sf.Texture.from_image(
self.sprites["selection"])